Class: Micropayment::Debit

Inherits:
Object
  • Object
show all
Defined in:
lib/services/debit.rb

Constant Summary collapse

URL = 
Config::BASE_URL + "debit/v1.4/nvp/"

Class Method Summary collapse

Class Method Details

.addressGet(options = {}) ⇒ Object

“ermittelt die Adresse des Kunden”



98
99
100
101
102
 
# File 'lib/services/debit.rb', line 98

def addressGet(options={})
  assert_valid_keys(options, :customerId)
  assert_keys_exists(options, :customerId)
  execute(:addressGet, options)
end

.addressSet(options = {}) ⇒ Object

“erzeugt oder ändert Adressdaten eines Kunden”



91
92
93
94
95
 
# File 'lib/services/debit.rb', line 91

def addressSet(options={})
  assert_valid_keys(options, :customerId, :firstName, :surName, :street, :zip, :city, :country)
  assert_keys_exists(options, :customerId, :firstName, :surName, :street, :zip, :city)
  execute(:addressSet, options)
end

.assert_keys_exists(*opts) ⇒ Object 



18
19
20
 
# File 'lib/services/debit.rb', line 18

def assert_keys_exists(*opts)
  Micropayment.assert_keys_exists *opts
end

.assert_valid_keys(*opts) ⇒ Object 



14
15
16
 
# File 'lib/services/debit.rb', line 14

def assert_valid_keys(*opts)
  Micropayment.assert_valid_keys *opts
end

.bankaccountBar(options = {}) ⇒ Object

“Sperrt Bankverbindung oder gibt sie frei”



84
85
86
87
88
 
# File 'lib/services/debit.rb', line 84

def bankaccountBar(options={})
  assert_valid_keys(options, :country, :bankCode, :accountNumber, :barStatus)
  assert_keys_exists(options, :bankCode, :accountNumber, :barStatus)
  execute(:bankaccountBar, options)
end

.bankaccountCheck(options = {}) ⇒ Object

“prüft Bankverbindung und ermittelt Banknamen”



77
78
79
80
81
 
# File 'lib/services/debit.rb', line 77

def bankaccountCheck(options={})
  assert_valid_keys(options, :country, :bankCode, :accountNumber)
  assert_keys_exists(options, :bankCode, :accountNumber)
  execute(:bankaccountCheck, options)
end

.bankaccountGet(options = {}) ⇒ Object

“ermittelt die Bankverbindung des Kunden”



63
64
65
66
67
 
# File 'lib/services/debit.rb', line 63

def bankaccountGet(options={})
  assert_valid_keys(options, :customerId)
  assert_keys_exists(options, :customerId)
  execute(:bankaccountGet, options)
end

.bankaccountSet(options = {}) ⇒ Object

“erzeugt oder ändert Bankverbindung eines Kunden”



56
57
58
59
60
 
# File 'lib/services/debit.rb', line 56

def bankaccountSet(options={})
  assert_valid_keys(options, :customerId, :bankCode, :accountNumber, :accountHolder, :country)
  assert_keys_exists(options, :customerId, :bankCode, :accountNumber, :accountHolder)
  execute(:bankaccountSet, options)
end

.bankCheck(options = {}) ⇒ Object

“prüft Bankleitzahl und ermittelt Banknamen”



70
71
72
73
74
 
# File 'lib/services/debit.rb', line 70

def bankCheck(options={})
  assert_valid_keys(options, :country, :bankCode)
  assert_keys_exists(options, :bankCode)
  execute(:bankCheck, options)
end

.contactDataGet(options = {}) ⇒ Object

“ermittelt die Kontaktdaten des Kunden”



112
113
114
115
116
 
# File 'lib/services/debit.rb', line 112

def contactDataGet(options={})
  assert_valid_keys(options, :customerId)
  assert_keys_exists(options, :customerId)
  execute(:contactDataGet, options)
end

.contactDataSet(options = {}) ⇒ Object

“erzeugt oder ändert Kontaktdaten eines Kunden”



105
106
107
108
109
 
# File 'lib/services/debit.rb', line 105

def contactDataSet(options={})
  assert_valid_keys(options, :customerId, :email, :phone, :mobile)
  assert_keys_exists(options, :customerId)
  execute(:contactDataSet, options)
end

.customerCreate(options = {}) ⇒ Object

“legt neuen Kunden an”



29
30
31
32
33
 
# File 'lib/services/debit.rb', line 29

def customerCreate(options={})
  assert_valid_keys(options, :customerId, :freeParams)
  assert_keys_exists(options, :customerId)
  execute(:customerCreate, options)
end

.customerGet(options = {}) ⇒ Object

“ermittelt alle freien Parameter des Kunden”



43
44
45
46
47
 
# File 'lib/services/debit.rb', line 43

def customerGet(options={})
  assert_valid_keys(options, :customerId)
  assert_keys_exists(options, :customerId)
  execute(:customerGet, options)
end

.customerList(options = {}) ⇒ Object

“ermittelt alle Kunden”



50
51
52
53
 
# File 'lib/services/debit.rb', line 50

def customerList(options={})
  assert_valid_keys(options, :from, :count)
  execute(:customerList, options)
end

.customerSet(options = {}) ⇒ Object

“ordnet weitere freie Parameter dem Kunden zu, oder ändert sie”



36
37
38
39
40
 
# File 'lib/services/debit.rb', line 36

def customerSet(options={})
  assert_valid_keys(options, :customerId, :freeParams)
  assert_keys_exists(options, :customerId)
  execute(:customerSet, options)
end

.execute(method, data = {}) ⇒ Object 



10
11
12
 
# File 'lib/services/debit.rb', line 10

def execute(method, data={})
  API.call(URL, method, data)
end

.reset_test ⇒ Object

“löscht alle Kunden und Transaktionen in der Testumgebung”



24
25
26
 
# File 'lib/services/debit.rb', line 24

def reset_test
  execute(:resetTest, :testMode => 1)
end

.sessionApprove(options = {}) ⇒ Object

“bestätigt den Lastschrifteinzug eines Vorgangs”

> “löst die Benachrichtigung sessionStatus mit dem Status ”APPROVED“ aus”



142
143
144
145
146
 
# File 'lib/services/debit.rb', line 142

def sessionApprove(options={})
  assert_valid_keys(options, :sessionId)
  assert_keys_exists(options, :sessionId)
  execute(:sessionApprove, options)
end

.sessionChargeTest(options = {}) ⇒ Object

“simuliert die Abbuchung für alle bestätigten Vorgänge”

> “erzeugt für jede bestätigte Session eine neue Transaktion mit dem Typ ‘BOOKING’ und löst die Benachrichtigung transactionCreate aus”

> “löst die Benachrichtigung sessionStatus mit dem Status ‘CHARGED’ aus”



158
159
160
 
# File 'lib/services/debit.rb', line 158

def sessionChargeTest(options={})
  execute(:sessionChargeTest, :testMode => 1)
end

.sessionCreate(options = {}) ⇒ Object

“erzeugt einen neuen Bezahlvorgang”

> “löst die Benachrichtigung sessionStatus mit dem Status ”INIT“ bzw. ”REINIT“ aus”



120
121
122
123
124
 
# File 'lib/services/debit.rb', line 120

def sessionCreate(options={})
  assert_valid_keys(options, :customerId, :sessionId, :project, :projectCampaign, :account, :webmasterCampaign, :amount, :currency, :title, :payText, :ip, :freeParams)
  assert_keys_exists(options, :customerId, :project)
  execute(:sessionCreate, options)
end

.sessionGet(options = {}) ⇒ Object

“ermittelt Daten eines Bezahlvorgangs”



134
135
136
137
138
 
# File 'lib/services/debit.rb', line 134

def sessionGet(options={})
  assert_valid_keys(options, :sessionId)
  assert_keys_exists(options, :sessionId)
  execute(:sessionGet, options)
end

.sessionList(options = {}) ⇒ Object

“übermittelt alle Bezahlvorgänge eines Kunden”



149
150
151
152
153
 
# File 'lib/services/debit.rb', line 149

def sessionList(options={})
  assert_valid_keys(options, :customerId)
  assert_keys_exists(options, :customerId)
  execute(:sessionList, options)
end

.sessionRechargeTest(options = {}) ⇒ Object

“simuliert die komplette Nachzahlung eines stornierten Vorgangs”

> “erzeugt eine neue Transaktion mit dem Typ ”BACKPAY“ und löst die Benachrichtigung transactionCreate aus”

> “löst die Benachrichtigung sessionStatus mit dem Status ”RECHARGED“ aus, wenn der gesamte offene Betrag beglichen wurde”



174
175
176
177
178
 
# File 'lib/services/debit.rb', line 174

def sessionRechargeTest(options={})
  assert_valid_keys(options, :sessionId, :amount)
  assert_keys_exists(options, :sessionId)
  execute(:sessionRechargeTest, options.merge(:testMode => 1))
end

.sessionRefund(options = {}) ⇒ Object

“Veranlasst eine (Teil-)Gutschrift und überweist sie zurück”

> “erzeugt eine neue Transaktion mit dem Typ ”REFUND“ und löst die Benachrichtigung transactionCreate aus”



182
183
184
185
186
 
# File 'lib/services/debit.rb', line 182

def sessionRefund(options={})
  assert_valid_keys(options, :sessionId, :bankCode, :accountNumber, :accountHolder, :amount, :payText)
  assert_keys_exists(options, :sessionId)
  execute(:sessionRefund, options)
end

.sessionRefundReverseTest(options = {}) ⇒ Object

“simuliert Stornierung der letzten Gutschrift,”

> “erzeugt eine neue Transaktion mit dem Typ ”REFUNDREVERSAL“ und löst die Benachrichtigung transactionCreate aus”



190
191
192
193
194
 
# File 'lib/services/debit.rb', line 190

def sessionRefundReverseTest(options={})
  assert_valid_keys(options, :sessionId)
  assert_keys_exists(options, :sessionId)
  execute(:sessionRefundReverseTest, options.merge(:testMode => 1))
end

.sessionReverseTest(options = {}) ⇒ Object

“simuliert Stornierung eines einzelnen Vorgangs”

> “erzeugt eine neue Transaktion mit dem Typ ”REVERSAL“ und löst die Benachrichtigung transactionCreate aus”

> “löst die Benachrichtigung sessionStatus mit dem Status ”REVERSED“ aus”



165
166
167
168
169
 
# File 'lib/services/debit.rb', line 165

def sessionReverseTest(options={})
  assert_valid_keys(options, :sessionId)
  assert_keys_exists(options, :sessionId)
  execute(:sessionReverseTest, options.merge(:testMode => 1))
end

.sessionSet(options = {}) ⇒ Object

“ordnet weitere freie Parameter der Session zu, oder ändert sie”



127
128
129
130
131
 
# File 'lib/services/debit.rb', line 127

def sessionSet(options={})
  assert_valid_keys(options, :sessionId, :freeParams)
  assert_keys_exists(options, :sessionId)
  execute(:sessionSet, options)
end

.transactionCreate(options = {}) ⇒ Object

“erstellt eine Transaktion vom Typ ”EXTERNAL“”

> “löst die Benachrichtigung transactionCreate aus”



198
199
200
201
202
 
# File 'lib/services/debit.rb', line 198

def transactionCreate(options={})
  assert_valid_keys(options, :sessionId, :date, :amount, :description)
  assert_keys_exists(options, :sessionId, :amount)
  execute(:transactionCreate, options)
end

.transactionGet(options = {}) ⇒ Object

“ermittelt Daten einer Transaktion”



212
213
214
215
216
 
# File 'lib/services/debit.rb', line 212

def transactionGet(options={})
  assert_valid_keys(options, :transactionId)
  assert_keys_exists(options, :transactionId)
  execute(:transactionGet, options)
end

.transactionList(options = {}) ⇒ Object

“ermittelt alle Transaktionen für einen Bezahlvorgang”



205
206
207
208
209
 
# File 'lib/services/debit.rb', line 205

def transactionList(options={})
  assert_valid_keys(options, :sessionId)
  assert_keys_exists(options, :sessionId)
  execute(:transactionList, options)
end