Class: CheckoutSdk::Payments::HostedPaymentsSession

Inherits:
Object
  • Object
show all
Defined in:
lib/checkout_sdk/payments/hosted/hosted_payments_session.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR) ⇒ HostedPaymentsSession

Returns a new instance of HostedPaymentsSession.



109
110
111
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 109

def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
  @payment_type = payment_type
end

Instance Attribute Details

#allow_payment_methods ⇒ Array(CheckoutSdk::Common::PaymentSourceType)

Returns:



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 74

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration,
                :payment_plan,
                :authorization_type

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#amount ⇒ Integer

Returns:

  • (Integer) 


74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 74

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration,
                :payment_plan,
                :authorization_type

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#amount_allocations ⇒ Array(CheckoutSdk::Common::AmountAllocations)

Returns:



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 74

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration,
                :payment_plan,
                :authorization_type

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#authorization_type ⇒ String

Returns [Optional] AuthorizationType Enum: “Final” “Estimated”. Default: “Final”.

Returns:

  • (String) —
    Optional

    AuthorizationType Enum: “Final” “Estimated”. Default: “Final”.



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 74

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration,
                :payment_plan,
                :authorization_type

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#billing ⇒ BillingInformation

Returns:



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 74

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration,
                :payment_plan,
                :authorization_type

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#billing_descriptor ⇒ BillingDescriptor

Returns:



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 74

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration,
                :payment_plan,
                :authorization_type

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#cancel_url ⇒ String

Returns:

  • (String) 


74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 74

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration,
                :payment_plan,
                :authorization_type

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#capture ⇒ TrueClass, FalseClass

Returns:

  • (TrueClass, FalseClass) 


74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 74

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration,
                :payment_plan,
                :authorization_type

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#capture_on ⇒ Time

Returns:

  • (Time) 


74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 74

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration,
                :payment_plan,
                :authorization_type

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#currency ⇒ String

Returns Common::Currency.

Returns:



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 74

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration,
                :payment_plan,
                :authorization_type

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#customer ⇒ CheckoutSdk::Common::CustomerRequest

Returns:



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 74

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration,
                :payment_plan,
                :authorization_type

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#customer_retry ⇒ PaymentRetryRequest

Returns:



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 74

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration,
                :payment_plan,
                :authorization_type

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#description ⇒ String

Returns:

  • (String) 


74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 74

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration,
                :payment_plan,
                :authorization_type

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#disabled_payment_methods ⇒ Array(CheckoutSdk::Common::PaymentSourceType)

Returns:



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 74

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration,
                :payment_plan,
                :authorization_type

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#display_name ⇒ String

Returns:

  • (String) 


74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 74

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration,
                :payment_plan,
                :authorization_type

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#failure_url ⇒ String

Returns:

  • (String) 


74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 74

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration,
                :payment_plan,
                :authorization_type

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#instruction ⇒ HostedPaymentInstruction

Returns:



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 74

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration,
                :payment_plan,
                :authorization_type

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#locale ⇒ String

Returns LocaleType.

Returns:



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 74

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration,
                :payment_plan,
                :authorization_type

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#metadata ⇒ Hash(String=>Object)

Returns:

  • (Hash(String=>Object)) 


74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 74

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration,
                :payment_plan,
                :authorization_type

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#payment_ip ⇒ String

Returns:

  • (String) 


74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 74

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration,
                :payment_plan,
                :authorization_type

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#payment_method_configuration ⇒ PaymentMethodConfiguration

Returns:



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 74

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration,
                :payment_plan,
                :authorization_type

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#payment_plan ⇒ PaymentPlan

Returns [Optional] The information to process a recurring payment request. To be used when the payment_type is Recurring.

Returns:

  • (PaymentPlan) —
    Optional

    The information to process a recurring payment request.

    To be used when the payment_type is Recurring.



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 74

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration,
                :payment_plan,
                :authorization_type

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#payment_type ⇒ String

Returns PaymentType.

Returns:



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 74

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration,
                :payment_plan,
                :authorization_type

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#processing ⇒ ProcessingSettings

Returns:



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 74

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration,
                :payment_plan,
                :authorization_type

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#processing_channel_id ⇒ String

Returns:

  • (String) 


74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 74

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration,
                :payment_plan,
                :authorization_type

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#products ⇒ Array(CheckoutSdk::Common::Product)

Returns:



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 74

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration,
                :payment_plan,
                :authorization_type

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#recipient ⇒ PaymentRecipient

Returns:



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 74

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration,
                :payment_plan,
                :authorization_type

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#reference ⇒ String

Returns:

  • (String) 


74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 74

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration,
                :payment_plan,
                :authorization_type

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#risk ⇒ RiskRequest

Returns:



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 74

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration,
                :payment_plan,
                :authorization_type

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#sender ⇒ CheckoutSdk::Payments::Sender

Returns:



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 74

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration,
                :payment_plan,
                :authorization_type

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#shipping ⇒ ShippingDetails

Returns:



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 74

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration,
                :payment_plan,
                :authorization_type

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#success_url ⇒ String

Returns:

  • (String) 


74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 74

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration,
                :payment_plan,
                :authorization_type

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#three_ds ⇒ ThreeDSRequest

Returns:



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 74

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration,
                :payment_plan,
                :authorization_type

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end