Class: MidasClient::Subscription

Inherits:
Request
  • Object
show all
Includes:
EndPoints
Defined in:
lib/midas_client/subscription.rb

Constant Summary

Constants included from EndPoints

EndPoints::Development, EndPoints::Operations, EndPoints::Production, EndPoints::Queries, EndPoints::Subscriptions

Instance Attribute Summary

Attributes inherited from Request

#login, #password

Instance Method Summary collapse

Methods included from EndPoints

get_env

Methods inherited from Request

#base_result, #external_request, #initialize, #request

Methods included from Util

#error_log, #log, #sanitize_pci

Constructor Details

This class inherits a constructor from MidasClient::Request

Instance Method Details

#cancel_subscription(subscription_token) ⇒ Object

This method cancel a subscription. This is a is synchronous operation.

Params:

subscriptionToken: string (Subscription unique identification generated by our
                          gateway and received in the subscription's creation response)

Response:

result: {
  success: true/false
  code: "XXX"
  message: "Some message to you"
}



104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
 
# File 'lib/midas_client/subscription.rb', line 104

def cancel_subscription(subscription_token)
  # inicializa as variáveis de retorno
  result ={}

  # define o método de envio da requisição
  method = :put

  # monta a URL de chamada da requisição
  endpoint =  EndPoints.get_env[:url] + EndPoints.get_env[:context] + EndPoints::Subscriptions[:cancel].gsub("{subscriptionToken}", subscription_token)

  # faz a chamada a plataforma de pagamento (MIDAS)
  response = request(method, endpoint, self., self.password, {})

  result = response[:result]

  return result
end

#create_subscription(*params) ⇒ Object

This method creates a subscription. It is a synchronous operation, using method POST

Params:

externalId: string (Transaction identification on the client application)
externalDate: [optional] datetime from client application - YYYY-MM-DDThh:mm:SS.sssTDZ - ISO8601
frequencyType string Is the frequency about the charge will run. Possible values: DAY/WEEK/MONTH
frequencyInterval integer The interval that will be used.
startDate datetime for the beginning of subscription - yyyy-MM-dd
invoicesCount integer - number of invoices for the subscription
amount: number (Only integer numbers, with the last two digits representing the cents.
                For example: 100 is equivalent to R$ 1,00)
cardToken: string (created by method card_store)
cvv: number (Security Code)
callbackUrl string - URL to receive the result for each invoice charge

Response: {

"result": {
    "success": "true",
    "code": "0",
    "message": "Sucesso"
},
"subscriptionToken": "49ac54257eb1f92f"

}

Response with first payment {

"result": {
    "success": "true",
    "code": "0",
    "message": "Sucesso"
},
"subscriptionToken": "49ac54257eb1f92f",
"firstInvoiceResult": {
    "success": true,
    "code": "000",
    "message": "Sucesso"
}

}

Error response { “result”: {

    "success": "false",
    "code": "114",
    "message": "O token do cartao é obrigatório"
}

}



58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/midas_client/subscription.rb', line 58

def create_subscription(*params)
  # Parametros são recebidos como um array de hash, pego o 1o item do array
  params = params.first

  # inicializa as variáveis de retorno
  result ={}

  first_invoice_result = ""
  subscription_token = ""

  # define o método de envio da requisição
  method = :post

  # monta a URL de chamada da requisição
  endpoint=  EndPoints.get_env[:url] + EndPoints.get_env[:context] + EndPoints::Subscriptions[:create]


  params[:externalDate] = (params[:externaldate].blank? ? Time.now.iso8601(1) : params[:externaldate])
  params[:invoicesCount]= (params[:invoicesCount].blank? ? 12 : params[:invoicesCount])

  # faz a chamada a plataforma de pagamento (MIDAS)
  response = request(method, endpoint, self., self.password, params)

  result = response[:result]
  subscription_token = response[:subscriptionToken] if !response[:subscriptionToken].nil?
  first_invoice_result = response[:firstInvoiceResult]

  # grava o tempo de execução da operação
  total_time_execution = Time.now - start_time_execution

  return result, subscription_token, first_invoice_result
end

#subscription_by_token(subscription_token) ⇒ Object

This method performs a query by a specific transaction. This is a is synchronous operation, using method GET

Params:

subscription_token: string (Transaction unique identification generated by our
                          gateway and received in the subscription's create response)#

Response: {

:result=>{
  :success=>true,
  :code=>"000",
  :message=>"Sucesso"
},
:subscription=>{
  :externalId=>"10011",
  :frequencyType=>"MONTH",
  :frequencyInterval=>1,
  :startDate=>"2016-07-28T00:00:00.000-04",
  :invoicesCount=>12,
  :paymentMethod=>"CREDIT_CARD",
  :amount=>5000,
  :creditCard=>{
    :brand=>"VISA",
    :panLastDigits=>"1855",
    :expirationMonth=>12,
    :expirationYear=>2020,
    :holderName=>"TESTE CONSOLE",
    :customer=>{
      :documentType=>"CPF",
      :documentNumber=>"41468031520"
    }
  },
  :token=>"a2bebd13f0a43e5a",
  :status=>"CANCELLED"
}

}



202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
 
# File 'lib/midas_client/subscription.rb', line 202

def subscription_by_token(subscription_token)
  # inicializa as variáveis de retorno
  result ={}

  # define o método de envio da requisição
  method = :get

  # monta a URL de chamada da requisição
  endpoint =  EndPoints.get_env[:url] + EndPoints.get_env[:context] + EndPoints::Subscriptions[:by_token].gsub("{subscriptionToken}", subscription_token)

  # faz a chamada a plataforma de pagamento (MIDAS)
  response = request(method, endpoint, self., self.password, {})

  result = response[:result]

  return result, response[:subscription]
end

#subscription_invoices(subscription_token) ⇒ Object

This method performs a query by a specific transaction. This is a is synchronous operation, using method GET

Params:

subscription_token: string (Transaction unique identification generated by our
                          gateway and received in the subscription's create response)#

Response:

{

:result=>{
  :success=>true,
  :code=>"000",
  :message=>"Sucesso"
},
:invoices=>[{
  :number=>1,
  :amount=>5000,
  :expirationDate=>"2016-07-28",
  :token=>"8bc3bf2ff9b08566fa8496fdce6c6f99",
  :status=>"PAID"
}. {:number=>2,...}, {:number=>3,}]

}



244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
 
# File 'lib/midas_client/subscription.rb', line 244

def subscription_invoices(subscription_token)
  # inicializa as variáveis de retorno
  result ={}

  # define o método de envio da requisição
  method = :get

  # monta a URL de chamada da requisição
  endpoint =  EndPoints.get_env[:url] + EndPoints.get_env[:context] + EndPoints::Subscriptions[:invoices].gsub("{subscriptionToken}", subscription_token)

  # faz a chamada a plataforma de pagamento (MIDAS)
  response = request(method, endpoint, self., self.password, {})

  result = response[:result]

  invoices = response[:invoices]

  return result, invoices
end

#update_invoice(invoice_token, params) ⇒ Object

This method updates a subscription. This is a is synchronous operation.

Params:

subscriptionToken: querystring (Subscription unique identification generated by our
                          gateway and received in the subscription's creation response)
amount: number (Only integer numbers, with the last two digits representing the cents.
                For example: 100 is equivalent to R$ 1,00)
expirationDate string deadline date for the invoice. FORMAT: YYY-MM-DD

Response:

result: {
  success: true/false
  code: "XXX"
  message: "Some message to you"
}



319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
 
# File 'lib/midas_client/subscription.rb', line 319

def update_invoice(invoice_token, params)
  # inicializa as variáveis de retorno
  result ={}

  # define o método de envio da requisição
  method = :put

  # monta a URL de chamada da requisição
  endpoint =  EndPoints.get_env[:url] + EndPoints.get_env[:context] + EndPoints::Subscriptions[:update_invoice].gsub("{invoiceToken}", invoice_token)

  # faz a chamada a plataforma de pagamento (MIDAS)
  response = request(method, endpoint, self., self.password, params)

  result = response[:result]

  return result
end

#update_subscription(subscription_token, params) ⇒ Object

This method updates a subscription callback, amount and updates opened invoices’ amount. This is a is synchronous operation.

Params:

subscriptionToken: querystring (Subscription unique identification generated by our
                          gateway and received in the subscription's creation response)
amount: number (Only integer numbers, with the last two digits representing the cents.
                For example: 100 is equivalent to R$ 1,00)
callbackUrl string - URL to receive the result for each invoice charge

Response:

result: {
  success: true/false
  code: "XXX"
  message: "Some message to you"
}



138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
 
# File 'lib/midas_client/subscription.rb', line 138

def update_subscription(subscription_token, params)
  # define o método de envio da requisição
  method = :put

  # monta a URL de chamada da requisição
  endpoint =  EndPoints.get_env[:url] + EndPoints.get_env[:context] + EndPoints::Subscriptions[:update].gsub("{subscriptionToken}", subscription_token)

  # faz a chamada a plataforma de pagamento (MIDAS) para atualizar o valor de face e callback da assinatura
  response = request(method, endpoint, self., self.password, params)

  # recupera a lista de invoices da assinatura para chamar o método de atualização de cada invoice.
  invoices = subscription_invoices(subscription_token)

  # filtra apenas as invoices em aberto
  opened_invoices = invoices[:invoices].select{|s| s[:status] == "OPEN"}

  # percorre cada uma das invoices abertas e chama o método de atualização
  opened_invoices.each do |inv|
    update_invoice(inv[:token], {amount: params[:amount]})
  end

  result = response[:result]

  return result
end

#update_subscription_card(subscription_token, new_card_token) ⇒ Object

This method updates the credit card information associated to the subscription. This is a is synchronous operation, using method PUT

Params:

subscription_token: string (Transaction unique identification generated by our
                          gateway and received in the subscription's create response)#
new_card_token: string that represents the new credit card token (created using card_store) for the subscription

Response: {

"result": {
  "success": true,
  "code": "0",
  "message": "Sucesso"
}

}



281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
 
# File 'lib/midas_client/subscription.rb', line 281

def update_subscription_card(subscription_token, new_card_token)
  # inicializa as variáveis de retorno
  result ={}

  # define o método de envio da requisição
  method = :put

  # monta a URL de chamada da requisição
  endpoint =  EndPoints.get_env[:url] + EndPoints.get_env[:context] + EndPoints::Subscriptions[:update_card].gsub("{subscriptionToken}", subscription_token)

  params = {
      cardToken: new_card_token
  }

  # faz a chamada a plataforma de pagamento (MIDAS)
  response = request(method, endpoint, self., self.password, params)

  result = response[:result]

  return result
end