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.



102
103
104
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 102

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

Instance Attribute Details

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

Returns:



69
70
71
72
73
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
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

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

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

#amount ⇒ Integer

Returns:

  • (Integer) 


69
70
71
72
73
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
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

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

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

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

Returns:



69
70
71
72
73
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
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

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

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

#billing ⇒ BillingInformation

Returns:



69
70
71
72
73
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
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

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

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

#billing_descriptor ⇒ BillingDescriptor

Returns:



69
70
71
72
73
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
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

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

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

#cancel_url ⇒ String

Returns:

  • (String) 


69
70
71
72
73
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
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

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

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

#capture ⇒ TrueClass, FalseClass

Returns:

  • (TrueClass, FalseClass) 


69
70
71
72
73
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
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

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

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

#capture_on ⇒ Time

Returns:

  • (Time) 


69
70
71
72
73
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
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

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

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

#currency ⇒ String

Returns Common::Currency.

Returns:



69
70
71
72
73
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
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

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

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

#customer ⇒ CheckoutSdk::Common::CustomerRequest

Returns:



69
70
71
72
73
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
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

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

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

#customer_retry ⇒ PaymentRetryRequest

Returns:



69
70
71
72
73
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
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

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

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

#description ⇒ String

Returns:

  • (String) 


69
70
71
72
73
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
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

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

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

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

Returns:



69
70
71
72
73
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
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

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

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

#display_name ⇒ String

Returns:

  • (String) 


69
70
71
72
73
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
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

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

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

#failure_url ⇒ String

Returns:

  • (String) 


69
70
71
72
73
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
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

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

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

#instruction ⇒ HostedPaymentInstruction

Returns:



69
70
71
72
73
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
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

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

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

#locale ⇒ String

Returns LocaleType.

Returns:



69
70
71
72
73
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
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

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

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

#metadata ⇒ Hash(String=>Object)

Returns:

  • (Hash(String=>Object)) 


69
70
71
72
73
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
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

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

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

#payment_ip ⇒ String

Returns:

  • (String) 


69
70
71
72
73
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
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

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

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

#payment_method_configuration ⇒ PaymentMethodConfiguration

Returns:



69
70
71
72
73
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
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

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

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

#payment_type ⇒ String

Returns PaymentType.

Returns:



69
70
71
72
73
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
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

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

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

#processing ⇒ ProcessingSettings

Returns:



69
70
71
72
73
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
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

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

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

#processing_channel_id ⇒ String

Returns:

  • (String) 


69
70
71
72
73
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
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

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

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

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

Returns:



69
70
71
72
73
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
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

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

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

#recipient ⇒ PaymentRecipient

Returns:



69
70
71
72
73
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
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

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

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

#reference ⇒ String

Returns:

  • (String) 


69
70
71
72
73
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
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

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

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

#risk ⇒ RiskRequest

Returns:



69
70
71
72
73
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
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

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

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

#sender ⇒ CheckoutSdk::Payments::Sender

Returns:



69
70
71
72
73
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
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

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

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

#shipping ⇒ ShippingDetails

Returns:



69
70
71
72
73
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
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

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

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

#success_url ⇒ String

Returns:

  • (String) 


69
70
71
72
73
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
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

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

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

#three_ds ⇒ ThreeDSRequest

Returns:



69
70
71
72
73
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
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

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

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