mastercard_masterpass_merchant 1.0.0

data/lib/mastercard_masterpass_merchant/api/postback_api.rb

@@ -0,0 +1,39 @@
+require 'uri'
+require 'mastercard_core_sdk'
+require_relative '../../mastercard_masterpass_merchant/models/merchant_transactions'
+ 
+
+module MastercardMasterpassMerchant
+ module Api
+
+  class PostbackApi
+    include MastercardCoreSdk::Core, MastercardCoreSdk::Client, MastercardCoreSdk::Exceptions
+	  include MastercardMasterpassMerchant::Tracker
+
+
+    # Postback Service
+    # This is the final step of MasterPass transaction. MasterPass transaction is a service call from the merchant to MasterPass,communicating the result of the transaction (success or failure). This is a mandatory step. Abandoned transactions do not need to be reported. The <TransactionId> value should be the value from the <TransactionId> element of the Checkout XML returned in the Checkout request.
+    # @param merchant_transactions Merchant transactions details.
+    # @param api_config Optional ApiConfig object specifying configuration : consumer key, private key, host URL. 
+    # @return [MerchantTransactions]
+    def self.create(merchant_transactions, api_config = nil)
+		 path = "/masterpass/v6/transaction"
+	 	 service_request = ServiceRequest.new
+     
+	   
+	   service_request.body = merchant_transactions
+	 
+	   service_request.content_type = "application/xml"
+	   api_client = ApiClient.new(api_config)
+     api_client.api_tracker = SdkApiTracker.new
+     api_client.error_handler = ErrorHandler.new
+	   return api_client.call(path, service_request, "POST",MerchantTransactions)
+    end
+
+  end
+
+ end
+end
+
+
+

data/lib/mastercard_masterpass_merchant/api/precheckout_data_api.rb

@@ -0,0 +1,42 @@
+require 'uri'
+require 'mastercard_core_sdk'
+require_relative '../../mastercard_masterpass_merchant/models/precheckout_data_response'
+require_relative '../../mastercard_masterpass_merchant/models/precheckout_data_request'
+ 
+
+module MastercardMasterpassMerchant
+ module Api
+
+  class PrecheckoutDataApi
+    include MastercardCoreSdk::Core, MastercardCoreSdk::Client, MastercardCoreSdk::Exceptions
+	  include MastercardMasterpassMerchant::Tracker
+
+
+    # Precheckout Data Service.
+    # MasterPass provides merchants with the ability to request a paired consumer's data (card alias, shipping addresses, reward program, and profile information) prior to the actual MasterPass checkout. This gives the merchant the ability to provide the consumer the opportunity to preselect their checkout options before completing the checkout. If, for any reason, the precheckout call gets rejected at MasterPass (merchant requests data that the consumer did not originally consent to, if the pairing has been deleted by the user, if the Long Access token has expired, and so on), the merchant has to request pairing again.
+    # @param oauth_token Long access token, which is used to retrieve precheckout data.
+    # @param precheckout_data_request PreCheckout Data Request.
+    # @param api_config Optional ApiConfig object specifying configuration : consumer key, private key, host URL. 
+    # @return [PrecheckoutDataResponse]
+    def self.create(oauth_token, precheckout_data_request, api_config = nil)
+		 path = "/masterpass/v6/precheckout"
+	 	 service_request = ServiceRequest.new
+     
+	   service_request.headers["oauth_token"] = oauth_token
+	 
+	   service_request.body = precheckout_data_request
+	 
+	   service_request.content_type = "application/xml"
+	   api_client = ApiClient.new(api_config)
+     api_client.api_tracker = SdkApiTracker.new
+     api_client.error_handler = ErrorHandler.new
+	   return api_client.call(path, service_request, "POST",PrecheckoutDataResponse)
+    end
+
+  end
+
+ end
+end
+
+
+

data/lib/mastercard_masterpass_merchant/api/session_key_signing_api.rb

@@ -0,0 +1,40 @@
+require 'uri'
+require 'mastercard_core_sdk'
+require_relative '../../mastercard_masterpass_merchant/models/session_key_signing_response'
+require_relative '../../mastercard_masterpass_merchant/models/session_key_signing_request'
+ 
+
+module MastercardMasterpassMerchant
+ module Api
+
+  class SessionKeySigningApi
+    include MastercardCoreSdk::Core, MastercardCoreSdk::Client, MastercardCoreSdk::Exceptions
+	  include MastercardMasterpassMerchant::Tracker
+
+
+    # Session Key Signing
+    # Session Key Signing Android SDK.
+    # @param session_key_signing_request Session Key Signing request.
+    # @param api_config Optional ApiConfig object specifying configuration : consumer key, private key, host URL. 
+    # @return [SessionKeySigningResponse]
+    def self.create(session_key_signing_request, api_config = nil)
+		 path = "/masterpass/v6/sessionkeysigning"
+	 	 service_request = ServiceRequest.new
+     
+	   
+	   service_request.body = session_key_signing_request
+	 
+	   service_request.content_type = "application/xml"
+	   api_client = ApiClient.new(api_config)
+     api_client.api_tracker = SdkApiTracker.new
+     api_client.error_handler = ErrorHandler.new
+	   return api_client.call(path, service_request, "POST",SessionKeySigningResponse)
+    end
+
+  end
+
+ end
+end
+
+
+

data/lib/mastercard_masterpass_merchant/api/shopping_cart_api.rb

@@ -0,0 +1,40 @@
+require 'uri'
+require 'mastercard_core_sdk'
+require_relative '../../mastercard_masterpass_merchant/models/shopping_cart_response'
+require_relative '../../mastercard_masterpass_merchant/models/shopping_cart_request'
+ 
+
+module MastercardMasterpassMerchant
+ module Api
+
+  class ShoppingCartApi
+    include MastercardCoreSdk::Core, MastercardCoreSdk::Client, MastercardCoreSdk::Exceptions
+	  include MastercardMasterpassMerchant::Tracker
+
+
+    # ShoppingCart service
+    # This service used to enables shopping cart data to be displayed to users as they proceed through the MasterPass login and checkout.Merchants must call the Shopping Cart service before invoking the MasterPass UI for checkout.
+    # @param shopping_cart_request Shopping Cart Request.
+    # @param api_config Optional ApiConfig object specifying configuration : consumer key, private key, host URL. 
+    # @return [ShoppingCartResponse]
+    def self.create(shopping_cart_request, api_config = nil)
+		 path = "/masterpass/v6/shopping-cart"
+	 	 service_request = ServiceRequest.new
+     
+	   
+	   service_request.body = shopping_cart_request
+	 
+	   service_request.content_type = "application/xml"
+	   api_client = ApiClient.new(api_config)
+     api_client.api_tracker = SdkApiTracker.new
+     api_client.error_handler = ErrorHandler.new
+	   return api_client.call(path, service_request, "POST",ShoppingCartResponse)
+    end
+
+  end
+
+ end
+end
+
+
+

data/lib/mastercard_masterpass_merchant/models/acceptance_option.rb

@@ -0,0 +1,177 @@
+require 'date'
+require 'roxml'
+require_relative '../../mastercard_masterpass_merchant/models/types'
+ 
+
+module MastercardMasterpassMerchant
+  # This class contains methods to set acceptance options.
+  class AcceptanceOption
+    include ROXML
+    
+    xml_name "AcceptanceOption"
+    
+    # @!attribute brand_id
+    # @return [String] the brand id.
+    xml_accessor :brand_id, :from =>"BrandId"
+   
+    # @!attribute types
+    # @return [Types] the types.
+    xml_accessor :types, :from =>"Types",:as => Types
+   
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :brand_id => :BrandId ,
+        :types => :Types 
+        
+      }
+    end
+
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+      
+      if attributes.has_key?(:BrandId) ||  attributes.has_key?(:brand_id)
+        self.brand_id = attributes[:BrandId] || attributes[:brand_id]
+      end
+      
+      if attributes.has_key?(:Types) ||  attributes.has_key?(:types)
+        self.types = attributes[:Types] || attributes[:types]
+      end
+      
+    end
+    
+ 
+	
+
+    # Check equality by comparing each attribute.
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          brand_id == o.brand_id &&
+          types == o.types
+    end
+
+    # @see the `==` method
+    def eql?(o)
+      self == o
+    end
+
+    # Calculate hash code according to all attributes.
+    def hash
+      [brand_id, types].hash
+    end
+
+    # build the object from hash
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.datatype_map.each_pair do |key, type|
+        if type =~ /^Array<(.*)>/i
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| _deserialize($1, v) } )
+          else
+            #TODO show warning in debug mode
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        else
+          # data not found in attributes(hash), not an issue as the data can be optional
+        end
+      end
+
+      self
+    end
+
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value =~ /^(true|t|yes|y|1)$/i
+          true
+        else
+          false
+        end
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        _model = MastercardMasterpassMerchant.const_get(type).new
+        _model.build_from_hash(value)
+      end
+    end
+
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_body (backward compatibility))
+    def to_body
+      to_hash
+    end
+
+    # return the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Method to output non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map{ |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+
+
+    private
+    def after_parse
+      self.send(:remove_instance_variable, :@roxml_references) if defined? self.roxml_references
+    end
+    
+    # Attribute datatype mapping.
+    def self.datatype_map
+      {
+        :brand_id => 'String',
+        :types => 'Types'
+        
+      }
+    end
+  end
+
+
+end

data/lib/mastercard_masterpass_merchant/models/address.rb

@@ -0,0 +1,243 @@
+require 'date'
+require 'roxml'
+require_relative '../../mastercard_masterpass_merchant/models/address_extension_point'
+ 
+
+module MastercardMasterpassMerchant
+  # This class contains methods to get consumer address details.
+  class Address
+    include ROXML
+    
+    xml_name "Address"
+    
+    # @!attribute city
+    # @return [String] the cardholder's city.
+    xml_accessor :city, :from =>"City"
+   
+    # @!attribute country
+    # @return [String] the cardholder's country. Defined by ISO 3166-1 alpha-2 digit country codes, for example, US is United States, AU is Australia, CA is Canada, GB is United Kingdom, and so on.
+    xml_accessor :country, :from =>"Country"
+   
+    # @!attribute country_subdivision
+    # @return [String] the cardholder's country subdivision. Defined by ISO 3166-1 alpha-2 digit code, for example, US-VA is Virginia, US-OH is Ohio
+    xml_accessor :country_subdivision, :from =>"CountrySubdivision"
+   
+    # @!attribute line1
+    # @return [String] the address line 1 used for Street number and Street Name.
+    xml_accessor :line1, :from =>"Line1"
+   
+    # @!attribute line2
+    # @return [String] the address line 2 used for Apt Number, Suite Number, and so on.
+    xml_accessor :line2, :from =>"Line2"
+   
+    # @!attribute line3
+    # @return [String] the address line 3 used to enter remaining address information if it does not fit in Line 1 and Line 2.
+    xml_accessor :line3, :from =>"Line3"
+   
+    # @!attribute postal_code
+    # @return [String] the postal code or zip code appended to mailing address for the purpose of sorting mail.
+    xml_accessor :postal_code, :from =>"PostalCode"
+   
+    # @!attribute extension_point
+    # @return [AddressExtensionPoint] the AddressExtensionPoint for additional information.
+    xml_accessor :extension_point, :from =>"ExtensionPoint",:as => AddressExtensionPoint
+   
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :city => :City ,
+        :country => :Country ,
+        :country_subdivision => :CountrySubdivision ,
+        :line1 => :Line1 ,
+        :line2 => :Line2 ,
+        :line3 => :Line3 ,
+        :postal_code => :PostalCode ,
+        :extension_point => :ExtensionPoint 
+        
+      }
+    end
+
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+      
+      if attributes.has_key?(:City) ||  attributes.has_key?(:city)
+        self.city = attributes[:City] || attributes[:city]
+      end
+      
+      if attributes.has_key?(:Country) ||  attributes.has_key?(:country)
+        self.country = attributes[:Country] || attributes[:country]
+      end
+      
+      if attributes.has_key?(:CountrySubdivision) ||  attributes.has_key?(:country_subdivision)
+        self.country_subdivision = attributes[:CountrySubdivision] || attributes[:country_subdivision]
+      end
+      
+      if attributes.has_key?(:Line1) ||  attributes.has_key?(:line1)
+        self.line1 = attributes[:Line1] || attributes[:line1]
+      end
+      
+      if attributes.has_key?(:Line2) ||  attributes.has_key?(:line2)
+        self.line2 = attributes[:Line2] || attributes[:line2]
+      end
+      
+      if attributes.has_key?(:Line3) ||  attributes.has_key?(:line3)
+        self.line3 = attributes[:Line3] || attributes[:line3]
+      end
+      
+      if attributes.has_key?(:PostalCode) ||  attributes.has_key?(:postal_code)
+        self.postal_code = attributes[:PostalCode] || attributes[:postal_code]
+      end
+      
+      if attributes.has_key?(:ExtensionPoint) ||  attributes.has_key?(:extension_point)
+        self.extension_point = attributes[:ExtensionPoint] || attributes[:extension_point]
+      end
+      
+    end
+    
+ 
+	
+
+    # Check equality by comparing each attribute.
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          city == o.city &&
+          country == o.country &&
+          country_subdivision == o.country_subdivision &&
+          line1 == o.line1 &&
+          line2 == o.line2 &&
+          line3 == o.line3 &&
+          postal_code == o.postal_code &&
+          extension_point == o.extension_point
+    end
+
+    # @see the `==` method
+    def eql?(o)
+      self == o
+    end
+
+    # Calculate hash code according to all attributes.
+    def hash
+      [city, country, country_subdivision, line1, line2, line3, postal_code, extension_point].hash
+    end
+
+    # build the object from hash
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.datatype_map.each_pair do |key, type|
+        if type =~ /^Array<(.*)>/i
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| _deserialize($1, v) } )
+          else
+            #TODO show warning in debug mode
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        else
+          # data not found in attributes(hash), not an issue as the data can be optional
+        end
+      end
+
+      self
+    end
+
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value =~ /^(true|t|yes|y|1)$/i
+          true
+        else
+          false
+        end
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        _model = MastercardMasterpassMerchant.const_get(type).new
+        _model.build_from_hash(value)
+      end
+    end
+
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_body (backward compatibility))
+    def to_body
+      to_hash
+    end
+
+    # return the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Method to output non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map{ |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+
+
+    private
+    def after_parse
+      self.send(:remove_instance_variable, :@roxml_references) if defined? self.roxml_references
+    end
+    
+    # Attribute datatype mapping.
+    def self.datatype_map
+      {
+        :city => 'String',
+        :country => 'String',
+        :country_subdivision => 'String',
+        :line1 => 'String',
+        :line2 => 'String',
+        :line3 => 'String',
+        :postal_code => 'String',
+        :extension_point => 'AddressExtensionPoint'
+        
+      }
+    end
+  end
+
+
+end