monri 0.1.0 → 0.2.0

data/lib/monri/payments/status_response.rb

@@ -0,0 +1,45 @@
+module Monri
+  class Payments
+    class StatusResponse < Response
+
+      # @param [Hash] params
+      def initialize(params)
+        if params.has_key?(:payment_result)
+          self[:payment_result] = PaymentResult.new(params.delete(:payment_result))
+        end
+        self.merge!(params)
+      end
+
+      # @return [String]
+      def status
+        self[:status]
+      end
+
+      # @return [String]
+      def payment_status
+        self[:payment_status]
+      end
+
+      # @return [String]
+      def client_secret
+        self[:client_secret]
+      end
+
+      # @return [Monri::Payments::PaymentResult]
+      def payment_result
+        self[:payment_result]
+      end
+
+      # @return [StatusResponse]
+      def self.create
+        raise ArgumentError, 'Provide a block' unless block_given?
+
+        begin
+          StatusResponse.new(yield)
+        rescue StandardError => e
+          StatusResponse.new(exception: e)
+        end
+      end
+    end
+  end
+end

data/lib/monri/payments.rb

@@ -11,10 +11,11 @@ module Monri
     attr_writer :access_tokens
 
     # @param [Hash] options
+    # @return [Monri::Payments::CreateResponse]
     def create(options)
-      Response.create do
-        access_token = @access_tokens.create(scopes: ['payments'])[:access_token]
-        response = @http_client.post('/v2/payment/new', options, headers: { 'Authorization' => "Bearer #{access_token}" })
+      CreateResponse.create do
+        access_token = @access_tokens.create!(scopes: ['payments']).access_token
+        response = @http_client.post('/v2/payment/new', options, oauth: access_token)
         if response.failed?
           raise response.exception
         elsif response.success?
@@ -26,16 +27,18 @@ module Monri
     end
 
     # @param [String] id
-    # @return [Response] id
+    # @return [StatusResponse] id
     def status(id)
-      Response.create do
+      StatusResponse.create do
         if id.nil? || !id.is_a?(String)
           raise ArgumentError('Id should be a string')
         end
 
-        access_token = @access_tokens.create(scopes: ['payments'])[:access_token]
-        response = @http_client.post("/v2/payment/#{id}/status", options, headers: { 'Authorization' => "Bearer #{access_token}" })
-        if response.success?
+        access_token = @access_tokens.create!(scopes: ['payments']).access_token
+        response = @http_client.get("/v2/payment/#{id}/status", oauth: access_token)
+        if response.failed?
+          raise response.exception
+        elsif response.success?
           response.body
         else
           # TODO: handle this case

data/lib/monri/response.rb

@@ -1,40 +1,29 @@
 # frozen_string_literal: true
 
 module Monri
-  class Response
-    # @return [Object]
-    attr_accessor :result
-    # @return [Exception]
-    attr_accessor :exception
+  class Response < Hash
 
-    # @return [Monri::Response]
-    # @param [Object] result
-    def self.result(result)
-      raise ArgumentError, 'Argument result is nil' if result.nil?
+    def initialize(params = {})
+      if params.has_key?(:exception)
+        self[:exception] = params[:exception]
+      end
+      self.merge!(params)
+    end
 
-      rv = Response.new
-      rv.result = result
-      rv
+    # @return [Exception, NilClass]
+    def exception
+      self[:exception]
     end
 
-    def success?
-      exception == nil
+    # @param [Exception] val
+    def exception=(val)
+      self[:exception] = val
     end
 
     def failed?
       exception != nil
     end
 
-    def self.create
-      raise ArgumentError, 'Provide a block' unless block_given?
-
-      begin
-        result(yield)
-      rescue StandardError => e
-        exception(e)
-      end
-    end
-
     # @param [Exception] exception
     def self.exception(exception)
       rv = Response.new

data/lib/monri/tokens/ephemeral_card_token_response.rb

@@ -0,0 +1,46 @@
+module Monri
+  class Tokens
+    class EphemeralCardTokenResponse < Response
+
+      def approved?
+        status == 'approved'
+      end
+
+      # @return [String]
+      def id
+        self[:id]
+      end
+
+      # @return [String]
+      def status
+        self[:status]
+      end
+
+      # @return [String]
+      def masked_pan
+        self[:masked_pan]
+      end
+
+      # @return [String]
+      def cc_type
+        self[:cc_type]
+      end
+
+      # @return [String]
+      def cc_issuer
+        self[:cc_issuer]
+      end
+
+      # @return [EphemeralCardTokenResponse]
+      def self.create
+        raise ArgumentError, 'Provide a block' unless block_given?
+
+        begin
+          EphemeralCardTokenResponse.new(yield)
+        rescue StandardError => e
+          EphemeralCardTokenResponse.new(exception: e)
+        end
+      end
+    end
+  end
+end

data/lib/monri/tokens.rb

@@ -0,0 +1,68 @@
+module Monri
+  class Tokens
+
+    # @return [Monri::Config]
+    attr_accessor :config
+
+    # @return [Monri::HttpClient]
+    attr_accessor :http_client
+
+    TEMP_TOKENIZE_REQUIRED_FIELDS = [:cvv, :type, :pan, :expiration_date, :temp_card_id, :digest, :timestamp]
+
+    # @note Create ephemeral (lasting for a very short time - 15minutes in this case) - token to replace card details.
+    # Required fields are: pan, expiration_date(YYMM), cvv, type (card). Optional fields are: tokenize_pan: bool
+    # @param [Hash] params
+    def create_ephemeral_card_token(params)
+
+      EphemeralCardTokenResponse.create do
+        ensure_configured!
+
+        # If there's no temp-card-id, create one
+        unless params.has_key?(:temp_card_id)
+          params.merge!(create_card_token)
+        end
+
+        missing_keys = TEMP_TOKENIZE_REQUIRED_FIELDS.reject { |k| params.has_key?(k) }
+
+        params[:authenticity_token] = config.authenticity_token
+
+        if missing_keys.length > 0
+          raise Monri::Errors::InvalidArgumentsError.new("Missing required keys=#{missing_keys.join(', ')}")
+        end
+
+        #  TODO: assert if merchant has PCI-DSS certificate - request pci-dss access token
+        http_response = http_client.post('/v2/temp-tokenize', params)
+        if http_response.failed?
+          raise http_response.exception
+        elsif http_response.success?
+          http_response.body
+        else
+          #  TODO: handle this case
+        end
+      end
+    end
+
+    private
+
+    def ensure_configured!
+      if config == nil || http_client == nil
+        raise Monri::Errors::InvalidArgumentsError.new('Configuration error, config or http client not set')
+      end
+    end
+
+    # @param [Hash] params
+    # @return [Hash]
+    def create_card_token(params = {})
+      ensure_configured!
+
+      token = params.has_key?(:temp_card_id) ? params.delete(:temp_card_id) : SecureRandom.hex
+      timestamp = Time.now.iso8601
+      {
+        timestamp: timestamp,
+        temp_card_id: token,
+        digest: Digest::SHA512.hexdigest("#{config.merchant_key}#{token}#{timestamp}")
+      }
+    end
+
+  end
+end

data/lib/monri/transactions/secure_message.rb

@@ -0,0 +1,30 @@
+module Monri
+  class Transactions
+    class SecureMessage < Hash
+      # @param [Hash] params
+      def initialize(params)
+        self.merge!(params)
+      end
+
+      # @return [String]
+      def id
+        self[:id]
+      end
+
+      # @return [String]
+      def acs_url
+        self[:acs_url]
+      end
+
+      # @return [String]
+      def pareq
+        self[:pareq]
+      end
+
+      # @return [String]
+      def authenticity_token
+        self[:authenticity_token]
+      end
+    end
+  end
+end

data/lib/monri/transactions/transaction.rb

@@ -0,0 +1,131 @@
+module Monri
+  class Transactions
+    class Transaction < Hash
+
+      # @param [Hash] params
+      def initialize(params)
+        self.merge!(params)
+      end
+
+      # @return [String]
+      def id
+        self[:id]
+      end
+
+      # @return [String]
+      def acquirer
+        self[:acquirer]
+      end
+
+      # @return [String]
+      def order_number
+        self[:order_number]
+      end
+
+      # @return [String]
+      def amount
+        self[:amount]
+      end
+
+      # @return [String]
+      def currency
+        self[:currency]
+      end
+
+      # @return [String]
+      def outgoing_amount
+        self[:outgoing_amount]
+      end
+
+      # @return [String]
+      def outgoing_currency
+        self[:outgoing_currency]
+      end
+
+      # @return [String]
+      def approval_code
+        self[:approval_code]
+      end
+
+      # @return [String]
+      def response_code
+        self[:response_code]
+      end
+
+      # @return [String]
+      def response_message
+        self[:response_message]
+      end
+
+      # @return [String]
+      def reference_number
+        self[:reference_number]
+      end
+
+      # @return [String]
+      def systan
+        self[:systan]
+      end
+
+      # @return [String]
+      def eci
+        self[:eci]
+      end
+
+      # @return [String]
+      def xid
+        self[:xid]
+      end
+
+      # @return [String]
+      def acsv
+        self[:acsv]
+      end
+
+      # @return [String]
+      def cc_type
+        self[:cc_type]
+      end
+
+      # @return [String]
+      def status
+        self[:status]
+      end
+
+      # @return [String]
+      def created_at
+        self[:created_at]
+      end
+
+      # @return [String]
+      def transaction_type
+        self[:transaction_type]
+      end
+
+      # @return [String]
+      def enrollment
+        self[:enrollment]
+      end
+
+      # @return [String]
+      def authentication
+        self[:authentication]
+      end
+
+      # @return [String]
+      def pan_token
+        self[:pan_token]
+      end
+
+      # @return [String]
+      def issuer
+        self[:issuer]
+      end
+
+      # @return [String]
+      def three_ds_version
+        self[:three_ds_version]
+      end
+    end
+  end
+end

data/lib/monri/transactions/transaction_response.rb

@@ -0,0 +1,59 @@
+module Monri
+  class Transactions
+    class TransactionResponse < Response
+
+      # @param [Hash] params
+      def initialize(params)
+        if params.has_key?(:errors)
+          self[:errors] = params.delete(:errors)
+        end
+
+        if params.has_key?(:transaction)
+          self[:transaction] = Monri::Transactions::Transaction.new(params.delete(:transaction))
+        end
+
+        if params.has_key?(:secure_message)
+          self[:secure_message] = Monri::Transactions::SecureMessage.new(params.delete(:secure_message))
+        end
+        super(params)
+      end
+
+      # @return [TrueClass, FalseClass]
+      def failed?
+        errors != nil && errors.length > 0 || super
+      end
+
+      # @return [Array]
+      def errors
+        self[:errors]
+      end
+
+      # @return [Monri::Transactions::TransactionResponse]
+      def transaction
+        self[:transaction]
+      end
+
+      # @return [Monri::Transactions::SecureMessage]
+      def secure_message
+        self[:secure_message]
+      end
+
+      # @return [TransactionResponse]
+      def self.create
+        raise ArgumentError, 'Provide a block' unless block_given?
+
+        begin
+          TransactionResponse.new(yield)
+        rescue StandardError => e
+          params = { exception: e }
+          if e.is_a?(Monri::Errors::HttpRequestError) && e.body != nil
+            body = JSON.parse(e.body, symbolize_names: true) rescue {}
+            params.merge!(body)
+          end
+          TransactionResponse.new(params)
+        end
+      end
+    end
+
+  end
+end

data/lib/monri/transactions.rb

@@ -0,0 +1,58 @@
+module Monri
+  class Transactions
+
+    # @return [Monri::Config]
+    attr_writer :config
+
+    # @return [Monri::HttpClient]
+    attr_writer :http_client
+
+    REQUIRED_FIELDS = [
+      :transaction_type,
+      :amount,
+      :ip,
+      :order_info,
+      :ch_address,
+      :ch_city,
+      :ch_country,
+      :ch_email,
+      :ch_full_name,
+      :ch_phone,
+      :ch_zip,
+      :currency,
+      :order_number,
+      :language
+    ].freeze
+
+    # @param [Hash] params
+    # @return [Monri::Transactions::TransactionResponse]
+    def transaction(params)
+      TransactionResponse.create do
+        unless params.is_a?(Hash)
+          raise Monri::Errors::InvalidArgumentsError.new('First parameter - params, should be a Hash')
+        end
+
+        missing_keys = REQUIRED_FIELDS.reject { |k| params.has_key?(k) }
+        if missing_keys.length > 0
+          raise Monri::Errors::InvalidArgumentsError.new("Missing required keys=#{missing_keys.join(', ')}")
+        end
+
+        params[:authenticity_token] = @config.authenticity_token
+        digest_parts = [@config.merchant_key, params[:order_number], params[:amount], params[:currency]]
+        params[:digest] = Digest::SHA512.hexdigest(digest_parts.join)
+
+        req = { transaction: params }
+
+        rv = @http_client.post('/v2/transaction', req)
+        if rv.failed?
+          raise rv.exception
+        elsif rv.success?
+          rv.body
+        else
+          #  TODO: how to handle this case
+        end
+      end
+
+    end
+  end
+end

data/lib/monri/validate_callback.rb

@@ -0,0 +1,47 @@
+module Monri
+  class ValidateCallback
+
+    # @return [Monri::Config]
+    attr_accessor :config
+
+    # @param [String] header
+    # @param [String] body
+    # @param [Hash] options
+    # @return [Hash{Symbol->String | TrueClass | FalseClass}]
+    def validate(header, body, options = {})
+
+      unless header.is_a?(String)
+        raise Monri::Errors::InvalidArgumentsError.new('First parameter - authorization header, should be a String')
+      end
+
+      unless body.is_a?(String)
+        raise Monri::Errors::InvalidArgumentsError.new('Second parameter - body, should be a String')
+      end
+
+      unless options.is_a?(Hash)
+        raise Monri::Errors::InvalidArgumentsError.new('Third parameter - options, should be a Hash')
+      end
+
+      version = options.delete(:version) || '2'
+
+      if version == 'v2'
+        expected_digest = Digest::SHA512.hexdigest("#{config.merchant_key}#{body}")
+      elsif version == '1'
+        unless options.has_key?(:order_number)
+          raise Monri::Errors::InvalidArgumentsError.new('For version=1 provide order-number')
+        end
+        order_number = options.delete(:order_number)
+        expected_digest = Digest::SHA1.hexdigest("#{config.merchant_key}#{order_number}")
+      else
+        raise Monri::Errors::InvalidArgumentsError.new("Version option, value='#{version}' is not supported")
+      end
+
+      expected_header = "WP3-callback #{expected_digest}"
+      {
+        header: header,
+        expected_header: expected_header,
+        valid: header == expected_header
+      }
+    end
+  end
+end

data/lib/monri.rb

@@ -11,13 +11,25 @@ require 'monri/config'
 require 'monri/client'
 require 'monri/errors'
 require 'monri/http_client'
-require 'monri/transaction'
 require 'monri/payments'
 require 'monri/payment_methods'
 require 'monri/access_tokens'
 require 'monri/customers'
 require 'monri/response'
 require 'monri/api_http_response'
+require 'monri/validate_callback'
+require 'monri/tokens'
+require 'monri/transactions'
+require 'monri/transactions/transaction'
+require 'monri/transactions/transaction_response'
+require 'monri/transactions/secure_message'
+require 'monri/payments/create_response'
+require 'monri/payments/status_response'
+require 'monri/payments/payment_result'
+require 'monri/tokens/ephemeral_card_token_response'
+require 'monri/customers/create_response'
+require 'monri/access_tokens/create_response'
+require 'time'
 
 module Monri
 end

data/monri.gemspec

@@ -2,8 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = 'monri'
-  # TODO: add version directly to the code
-  s.version = '0.1.0'
+  s.version = '0.2.0'
   s.required_ruby_version = '>= 2.3.0'
   s.summary = 'Ruby bindings for the Monri API'
   s.description = 'Your voyage through payment experience starts here. Learn more about how Monri helps to power your business.' \