RubyGems - paygate-ruby - Versions diffs - 0.1.8 → 0.2.0 - Mend

paygate-ruby 0.1.8 → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (28) hide show

checksums.yaml +4 -4
data/CHANGELOG.md +53 -38
data/LICENSE.txt +21 -21
data/README.md +327 -343
data/Rakefile +3 -2
data/data/cdbn.20230401.unl.xlsx +0 -0
data/data/config.yml +3347 -2744
data/lib/paygate/action_view/form_helper.rb +159 -0
data/lib/paygate/aes.rb +152 -150
data/lib/paygate/aes_ctr.rb +136 -133
data/lib/paygate/configuration.rb +20 -16
data/lib/paygate/member.rb +24 -21
data/lib/paygate/profile.rb +33 -30
data/lib/paygate/response.rb +27 -25
data/lib/paygate/transaction.rb +60 -58
data/lib/paygate/version.rb +5 -3
data/lib/paygate-ruby.rb +3 -48
data/lib/paygate.rb +43 -0
data/vendor/assets/javascripts/paygate.js +86 -86
metadata +17 -49
data/.gitignore +0 -9
data/CODE_OF_CONDUCT.md +0 -74
data/Gemfile +0 -4
data/bin/console +0 -14
data/bin/setup +0 -8
data/data/card_bin_20191001.xlsx +0 -0
data/lib/paygate/helpers/form_helper.rb +0 -155
data/paygate-ruby.gemspec +0 -24

data/README.md CHANGED Viewed

@@ -1,343 +1,327 @@
-# paygate-ruby
-`paygate-ruby` is a simple Ruby wrapper for [PayGate payment gateway](http://www.paygate.net/)'s OpenPayAPI.
-## Installation
-Add this line to your application's Gemfile:
-```ruby
-gem 'paygate-ruby'
-```
-And then execute:
-    $ bundle
-Or install it yourself as:
-    $ gem install paygate-ruby
-## Configuration
-You can pass a block to the `configure` method to make changes to the `Paygate` configuration.
-```ruby
-Paygate.configure do |config|
-  config.mode = :sandbox
-end
-```
-Default value for `mode` is `:live`. It uses different API urls in different modes for making payments.
-## Usage
-To start making the transactions on PayGate, you will need a Member ID and a Secret, for which you can register [here](https://admin.paygate.net/front/regist/registMember.jsp?lang=us).
-After a successful registration, you will have access to the [dashboard](https://admin.paygate.net/front/board/welcome.jsp).
-NOTE: Unless otherwise stated, all the following documentation is for making payments with Korean local credit cards in currency 'WON'.
-Contents:
-- [1 Purchase](#1-purchase)
-- [2 Verify](#2-verify)
-- [3 Refund](#3-refund)
-- [4 Profile Pay](#4-profile-pay)
-- [5 JavaScript helpers](#5-javascript-helpers)
-### 1 Purchase
-#### 1.1 Include JavaScript
-Include the _OpenPayAPI.js_ in `<head>` of your payment page.
-```slim
-= javascript_include_tag paygate_open_pay_api_js_url
-```
-#### 1.2 Payment form
-Render the PayGate payment form in your view file.
-```slim
-= paygate_open_pay_api_form
-```
-You will see a form with all the necessary fields for making payment with a credit card. Some of the fields have default values set. You can also set the value and placeholder for almost all the fields while rendering the form. See example below:
-```slim
-/ payment.html.slim
-= paygate_open_pay_api_form(\
-    mid: { value: 'testmid', placeholder: 'Merchant ID' },
-    currency: { value: 'USD' },
-    amount: { value: 2000 }\
-  )
-```
-Here is a list of all the form fields which you can set:
-- mid
-- locale (default: 'US')
-- charset (default: 'UTF-8')
-- title
-- currency (default: 'WON')
-- amount
-- meta1, meta2, meta3, meta4, meta5
-- pay_method (default: 'card')
-- customer_name
-- customer_email
-- card_number
-- expiry_year
-- expiry_month
-- cvv
-The form also contains some fields which are filled after the response is returned by the API. They are:
-- card_auth_code
-- response_code
-- response_message
-- tid
-- profile_no
-- hash_result
-Lets explore some of these fields more.
-**mid**
-You need to set your Member ID in this field.
-If you have setup separate Member IDs for Korean and International cards, you can fill the value of `mid` accordingly. To know whether the credit card number entered by a customer is Korean or not, you can check the first 6 digits of card number to match Korean BIN numbers. Full list is available as `Paygate::KOREA_BIN_NUMBERS`.
-**pay_method**
-Value of `pay_method` for Korean cards should be set to "card" and for international cards, it should be "104".
-**locale**
-Use `Paygate.mapped_locale` to get the locale in correct format for the form input.
-```ruby
-Paygate.mapped_locale(:en)
- => 'US'
-Paygate.mapped_locale('ko')
- => 'KR'
-```
-Valid inputs are "en", "en-US", "ko", "ko-KR", "ja", "zh-CN" and their symbolized versions. Passing `nil` would return default locale i.e. "US".
-**currency**
-Use `Paygate.mapped_currency` to get the currency in the correct format.
-```ruby
-Paygate.mapped_currency('USD')
- => 'USD'
-Paygate.mapped_currency('KRW')
- => 'WON'
-```
-Passing `nil` above would return default currency i.e. "WON".
-**amount**
-You need to contact PayGate to know the correct amount for making a successful transaction in test mode.
-Remember, in test mode too, PayGate makes real transactions and you need to `refund` them.
-**meta1, meta2, meta3, meta4, meta5**
-These fields can be used to pass any additional data to PayGate. If server-to-server callbacks are enabled, the gateway then sends all of these back when making a callback request to your server.
-**tid**
-For every transaction a `tid` is created by PayGate JS before making a request to the API.
-**response_code**
-This is filled automatically by PayGate JS when response is returned. A `response_code` of "0000" means successful transaction.
-**response_message**
-In case of failure, you can see the error message returned by the API here.
-**profile_no**
-If Profile Payment Service is enabled on your Member ID, then you will get a subscription ID for customer in this field. You can use this `profile_no` to make payments for the same customer in future.
-#### 1.3 Response screen
-You also need to add a screen at the same HTML level as above form. OpenPayAPI popups for further authentication as well as the response from the API is displayed in this screen.
-```slim
-= paygate_open_pay_api_screen
-```
-#### 1.4 JavaScript callback
-You also need to implement a few callbacks to handle the API response. Add these to your JavaScript.
-```js
-// This is called when a response is returned from PayGate API
-function getPGIOresult() {
-  displayStatus(getPGIOElement('ResultScreen'));
-  verifyReceived(getPGIOElement('tid'), 'callbacksuccess', 'callbackfail');
-}
-// This is called when a response (success/failure) is returned from the API
-function callbacksuccess() {
-  var replycode = getPGIOElement('replycode');
-  if (replycode == '0000') {
-    alert('Payment was successful');
-  } else {
-    alert('Payment failed with code: ' + replycode);
-  }
-}
-// This is called when there is a system error
-function callbackfail() {
-  alert('System error. Please try again.');
-}
-```
-#### 1.5 Submit the form
-Now finally, lets add an event to make a call to OpenPayAPI on submit of the form. If you are using jQuery, you can do it as follows:
-```js
-$('form[name="PGIOForm"]').on('submit', function(event){
-  event.preventDefault();
-  doTransaction(document.PGIOForm);
-})
-```
-And, your payment form is all set to make payments.
-### 2 Verify
-If enabled, PayGate will send a server-to-server callback on every successful transaction to the URL provided by you. The same request is sent every 5 minutes (for 10 days) until your server responds with success.
-This feature can be helpful if your JavaScript failed to receive the message from PayGate after a successful payment due to network issues.
-So, once you receive a successful JavaScript callback (`replycode == '0000'`), to prevent PayGate from sending any callback requests for that transaction (`tid`), you need to make a verification request as follows:
-```ruby
-txn = Paygate::Transaction.new('testmid_123456.654321')
-response = txn.verify
- => #<Paygate::Response:0x007fd4898f14b0 ... >
-response.transaction_type
- => :verify
-response.http_code
- => "200"
-```
-Here, _testmid_123456.654321_ is `tid` of the transaction you want to verify.
-### 3 Refund
-Initialize a `Paygate::Member` instance using the Member ID and Secret you have.
-```ruby
-member = Paygate::Member.new('testmid', 'secret')
- => #<Paygate::Member:0x007f96bdb70f38 @mid="testmid", @secret="secret">
-```
-`member` responds to methods `mid`, and `secret`.
-```ruby
-member.mid
- => "testmid"
-member.secret
- => "secret"
-```
-#### 3.1 Full refund
-```ruby
-response = member.refund_transaction('testmid_123456.654321')
- => #<Paygate::Response:0x007fbf3d111940 @transaction_type=:refund, @http_code="200", @message="OK", @body="callback({\"replyCode\":\"0000\",\"replyMessage\":\"Response has been completed\",\"content\":{\"object\":\"CancelAPI tid:testmid_123456.654321 SUCCESS payRsltCode:0000\"}})", @json={"replyCode"=>"0000", "replyMessage"=>"Response has been completed", "content"=>{"object"=>"CancelAPI tid:testmid_123456.654321 SUCCESS payRsltCode:0000"}}, @raw_info=
-  #<OpenStruct tid="testmid_123456.654321", tid_enc="AES256XQIdNnkzFwMQmhF7fuJhS3m0\n", request_url="https://service.paygate.net/service/cancelAPI.json?callback=callback&mid=testmid&tid=AES256XQIdNnkzFwMQmhF7fuJhS3m0%0A&amount=F">>
-```
-`response` provides some helpful accessor methods too.
-```ruby
-response.transaction_type
- => :refund
-response.http_code
- => "200"
-response.json
- => {"replyCode"=>"0000", "replyMessage"=>"Response has been completed", "content"=>{"object"=>"CancelAPI tid:testmid_123456.654321 SUCCESS payRsltCode:0000"}}
-response.raw_info
- => #<OpenStruct tid="testmid_123456.654321", tid_enc="AES256XQIdNnkzFwMQmhF7fuJhS3m0\n", request_url="https://service.paygate.net/service/cancelAPI.json?callback=callback&mid=testmid&tid=AES256XQIdNnkzFwMQmhF7fuJhS3m0%0A&amount=F">
-response.raw_info.request_url
- => "https://service.paygate.net/service/cancelAPI.json?callback=callback&mid=testmid&tid=AES256XQIdNnkzFwMQmhF7fuJhS3m0%0A&amount=F"
-```
-Apart from these it also responds to `message` and `body`.
-#### 3.2 Partial refund
-For partial refunds, you need to pass `amount` as an option to `refund_transaction` method along with other options.
-```ruby
-response = member.refund_transaction('testmid_123456.654321',
-                                     amount: 1000,
-                                     order_id: 'ord10001')
-```
-### 4 Profile Pay
-You can use the `profile_no` returned from the OpenPayAPI after first payment by a customer to make future payments for him.
-```ruby
-response = member.profile_pay('profile_1234567890', 'WON', 1000)
-response.transaction_type
- => :profile_pay
-response.http_code
- => "200"
-response.json
- => {"validecode"=>"00", "authcode"=>"12345678", "authdt"=>"20171120165728", "cardname"=>"BC \x00\x00\x00\x00", "cardnumber"=>"411111**********", "cardtype"=>"301310", "cardquota"=>"00", "cardexpiremonth"=>"11", "cardexpireyear"=>"2020", "merchantno"=>"12345678", "m_tid"=>nil, "paymethodname"=>"CARD_BASIC", "ReplyMsg"=>"\xBA\xBA\xBC\xBD\xC1\xC2\xC3\xC4        OK: 12345678", "ReplyCode"=>"0000", "receipttoname"=>"Test name\xC1\xD1\xB1\xB1\xC1\xA1", "receipttoemail"=>"dev@paygate.net", "subtotalprice"=>"1000", "transactionid"=>"testmid_123456.654321", "hashresult"=>"db1fdc6789cc8d088172b79ca680b3af8711e9fb32", "mb_serial_no"=>"\r\n"}
-```
-### 5 JavaScript helpers
-`paygate-ruby` also provides a JavaScript class `Paygate` with some helper functions that can be used in your JavaScript e.g.
-- _openPayApiForm_ - Returns the payment form
-- _openPayApiScreen_ - Returns the screen for paygate API response
-- _findInputByName_ - Find an input field in payment form by name. Pass the _camelCased_ form of field names from section 1.2 above as arguments.
-- _responseCode_
-- _responseMessage_
-- _tid_
-- _profileNo_
-- _fillInput_ - Accepts input name (_camelCased_) and a value to set
-- _submitForm_ - Makes a call to PayGate API with the payment form inputs
-## Development
-After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
-## Contributing
-Bug reports and pull requests are welcome on GitHub at https://github.com/jagdeepsingh/paygate-ruby. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
-## License
-The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
-## Code of Conduct
-Everyone interacting in the Paygate project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/jagdeepsingh/paygate-ruby/blob/master/CODE_OF_CONDUCT.md).
+# paygate-ruby
+`paygate-ruby` is a simple Ruby wrapper for [PayGate Korean payment gateway](http://www.paygate.net/)'s OpenPayAPI.
+## Installation
+Add this line to your application's Gemfile:
+```ruby
+gem 'paygate-ruby'
+```
+## Configuration
+You can pass a block to the `configure` method to make changes to the `Paygate` configuration.
+```ruby
+Paygate.configure do |config|
+  config.mode = :sandbox
+end
+```
+Default value for `mode` is `:live`. It uses different API urls in different modes for making payments.
+## Usage
+To start making the transactions on PayGate, you will need a Member ID and a Secret,
+for which you can register [here](https://admin.paygate.net/front/regist/registMember.jsp?lang=us).
+After a successful registration, you will have access to the [dashboard](https://admin.paygate.net/front/board/welcome.jsp).
+NOTE: Unless otherwise stated, all the following documentation is for making payments
+with Korean local credit cards in currency 'WON'.
+Contents:
+- [1. Purchase](#1-purchase)
+- [2. Verify](#2-verify)
+- [3. Refund](#3-refund)
+- [4. Profile Pay](#4-profile-pay)
+- [5. JavaScript helpers](#5-javascript-helpers)
+### 1. Purchase
+#### 1.1. Include JavaScript
+Include the _OpenPayAPI.js_ in `<head>` of your payment page.
+```slim
+= javascript_include_tag paygate_open_pay_api_js_url
+```
+#### 1.2 Payment form
+Render the PayGate payment form in your view file.
+```slim
+= paygate_open_pay_api_form
+```
+You will see a form with all the necessary fields for making payment with a credit card. Some of the fields have default values set. You can also set the value and placeholder for almost all the fields while rendering the form. See example below:
+```slim
+/ payment.html.slim
+= paygate_open_pay_api_form(\
+    mid: { value: 'testmid', placeholder: 'Merchant ID' },
+    currency: { value: 'USD' },
+    amount: { value: 2000 }\
+  )
+```
+Here is a list of all the form fields which you can set:
+- mid
+- locale (default: 'US')
+- charset (default: 'UTF-8')
+- title
+- currency (default: 'WON')
+- amount
+- meta1, meta2, meta3, meta4, meta5
+- pay_method (default: 'card')
+- customer_name
+- customer_email
+- card_number
+- expiry_year
+- expiry_month
+- cvv
+The form also contains some fields which are filled after the response is returned by the API. They are:
+- card_auth_code
+- response_code
+- response_message
+- tid
+- profile_no
+- hash_result
+Lets explore some of these fields more.
+**mid**
+You need to set your Member ID in this field.
+If you have setup separate Member IDs for Korean and International cards, you can fill the value of `mid` accordingly. To know whether the credit card number entered by a customer is Korean or not, you can check the first 6 digits of card number to match Korean BIN numbers. Full list is available as `Paygate::KOREA_BIN_NUMBERS`.
+**pay_method**
+Value of `pay_method` for Korean cards should be set to "card" and for international cards, it should be "104".
+**locale**
+Use `Paygate.mapped_locale` to get the locale in correct format for the form input.
+```ruby
+Paygate.mapped_locale(:en)
+#=> 'US'
+Paygate.mapped_locale('ko')
+#=> 'KR'
+```
+Valid inputs are "en", "en-US", "ko", "ko-KR", "ja", "zh-CN" and their symbolized versions. Passing `nil` would return default locale i.e. "US".
+**currency**
+Use `Paygate.mapped_currency` to get the currency in the correct format.
+```ruby
+Paygate.mapped_currency('USD')
+#=> 'USD'
+Paygate.mapped_currency('KRW')
+#=> 'WON'
+```
+Passing `nil` above would return default currency i.e. "WON".
+**amount**
+You need to contact PayGate to know the correct amount for making a successful transaction in test mode.
+Remember, in test mode too, PayGate makes real transactions and you need to `refund` them.
+**meta1, meta2, meta3, meta4, meta5**
+These fields can be used to pass any additional data to PayGate. If server-to-server callbacks are enabled, the gateway then sends all of these back when making a callback request to your server.
+**tid**
+For every transaction a `tid` is created by PayGate JS before making a request to the API.
+**response_code**
+This is filled automatically by PayGate JS when response is returned. A `response_code` of "0000" means successful transaction.
+**response_message**
+In case of failure, you can see the error message returned by the API here.
+**profile_no**
+If Profile Payment Service is enabled on your Member ID, then you will get a subscription ID for customer in this field. You can use this `profile_no` to make payments for the same customer in future.
+#### 1.3. Response screen
+You also need to add a screen at the same HTML level as above form. OpenPayAPI popups for further authentication as well as the response from the API is displayed in this screen.
+```slim
+= paygate_open_pay_api_screen
+```
+#### 1.4. JavaScript callback
+You also need to implement a few callbacks to handle the API response. Add these to your JavaScript.
+```js
+// This is called when a response is returned from PayGate API
+function getPGIOresult() {
+  displayStatus(getPGIOElement('ResultScreen'));
+  verifyReceived(getPGIOElement('tid'), 'callbacksuccess', 'callbackfail');
+}
+// This is called when a response (success/failure) is returned from the API
+function callbacksuccess() {
+  var replycode = getPGIOElement('replycode');
+  if (replycode == '0000') {
+    alert('Payment was successful');
+  } else {
+    alert('Payment failed with code: ' + replycode);
+  }
+}
+// This is called when there is a system error
+function callbackfail() {
+  alert('System error. Please try again.');
+}
+```
+#### 1.5. Submit the form
+Now finally, lets add an event to make a call to OpenPayAPI on submit of the form. If you are using jQuery, you can do it as follows:
+```js
+$('form[name="PGIOForm"]').on('submit', function(event){
+  event.preventDefault();
+  doTransaction(document.PGIOForm);
+})
+```
+And, your payment form is all set to make payments.
+### 2. Verify
+If enabled, PayGate will send a server-to-server callback on every successful transaction to the URL provided by you. The same request is sent every 5 minutes (for 10 days) until your server responds with success.
+This feature can be helpful if your JavaScript failed to receive the message from PayGate after a successful payment due to network issues.
+So, once you receive a successful JavaScript callback (`replycode == '0000'`), to prevent PayGate from sending any callback requests for that transaction (`tid`), you need to make a verification request as follows:
+```ruby
+txn = Paygate::Transaction.new('testmid_123456.654321')
+response = txn.verify
+#=> #<Paygate::Response:0x007fd4898f14b0 ... >
+response.transaction_type
+#=> :verify
+response.http_code
+#=> "200"
+```
+Here, _testmid_123456.654321_ is `tid` of the transaction you want to verify.
+### 3. Refund
+Initialize a `Paygate::Member` instance using the Member ID and Secret you have.
+```ruby
+member = Paygate::Member.new('testmid', 'secret')
+#=> #<Paygate::Member:0x007f96bdb70f38 @mid="testmid", @secret="secret">
+```
+`member` responds to methods `mid`, and `secret`.
+```ruby
+member.mid
+#=> "testmid"
+member.secret
+#=> "secret"
+```
+#### 3.1. Full refund
+```ruby
+response = member.refund_transaction('testmid_123456.654321')
+#=> #<Paygate::Response:0x007fbf3d111940 @transaction_type=:refund, @http_code="200", @message="OK", @body="callback({\"replyCode\":\"0000\",\"replyMessage\":\"Response has been completed\",\"content\":{\"object\":\"CancelAPI tid:testmid_123456.654321 SUCCESS payRsltCode:0000\"}})", @json={"replyCode"=>"0000", "replyMessage"=>"Response has been completed", "content"=>{"object"=>"CancelAPI tid:testmid_123456.654321 SUCCESS payRsltCode:0000"}}, @raw_info=
+  #<OpenStruct tid="testmid_123456.654321", tid_enc="AES256XQIdNnkzFwMQmhF7fuJhS3m0\n", request_url="https://service.paygate.net/service/cancelAPI.json?callback=callback&mid=testmid&tid=AES256XQIdNnkzFwMQmhF7fuJhS3m0%0A&amount=F">>
+```
+`response` provides some helpful accessor methods too.
+```ruby
+response.transaction_type
+#=> :refund
+response.http_code
+#=> "200"
+response.json
+#=> {"replyCode"=>"0000", "replyMessage"=>"Response has been completed", "content"=>{"object"=>"CancelAPI tid:testmid_123456.654321 SUCCESS payRsltCode:0000"}}
+response.raw_info
+#=> #<OpenStruct tid="testmid_123456.654321", tid_enc="AES256XQIdNnkzFwMQmhF7fuJhS3m0\n", request_url="https://service.paygate.net/service/cancelAPI.json?callback=callback&mid=testmid&tid=AES256XQIdNnkzFwMQmhF7fuJhS3m0%0A&amount=F">
+response.raw_info.request_url
+#=> "https://service.paygate.net/service/cancelAPI.json?callback=callback&mid=testmid&tid=AES256XQIdNnkzFwMQmhF7fuJhS3m0%0A&amount=F"
+```
+Apart from these it also responds to `message` and `body`.
+#### 3.2. Partial refund
+For partial refunds, you need to pass `amount` as an option to `refund_transaction` method along with other options.
+```ruby
+response = member.refund_transaction('testmid_123456.654321',
+                                     amount: 1000,
+                                     order_id: 'ord10001')
+```
+### 4. Profile Pay
+You can use the `profile_no` returned from the OpenPayAPI after first payment by a customer to make future payments for him.
+```ruby
+response = member.profile_pay('profile_1234567890', 'WON', 1000)
+response.transaction_type
+#=> :profile_pay
+response.http_code
+#=> "200"
+response.json
+#=> {"validecode"=>"00", "authcode"=>"12345678", "authdt"=>"20171120165728", "cardname"=>"BC \x00\x00\x00\x00", "cardnumber"=>"411111**********", "cardtype"=>"301310", "cardquota"=>"00", "cardexpiremonth"=>"11", "cardexpireyear"=>"2020", "merchantno"=>"12345678", "m_tid"=>nil, "paymethodname"=>"CARD_BASIC", "ReplyMsg"=>"\xBA\xBA\xBC\xBD\xC1\xC2\xC3\xC4        OK: 12345678", "ReplyCode"=>"0000", "receipttoname"=>"Test name\xC1\xD1\xB1\xB1\xC1\xA1", "receipttoemail"=>"dev@paygate.net", "subtotalprice"=>"1000", "transactionid"=>"testmid_123456.654321", "hashresult"=>"db1fdc6789cc8d088172b79ca680b3af8711e9fb32", "mb_serial_no"=>"\r\n"}
+```
+### 5. JavaScript helpers
+`paygate-ruby` also provides a JavaScript class `Paygate` with some helper functions that can be used in your JavaScript e.g.
+- _openPayApiForm_ - Returns the payment form
+- _openPayApiScreen_ - Returns the screen for paygate API response
+- _findInputByName_ - Find an input field in payment form by name. Pass the _camelCased_ form of field names from section 1.2 above as arguments.
+- _responseCode_
+- _responseMessage_
+- _tid_
+- _profileNo_
+- _fillInput_ - Accepts input name (_camelCased_) and a value to set
+- _submitForm_ - Makes a call to PayGate API with the payment form inputs
+## Contributing
+Bug reports and pull requests are welcome on GitHub at https://github.com/tablecheck/paygate-ruby.
+## License
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).