exact4r 0.5.2 → 0.6

data/lib/ews/transaction/fake_response.rb

@@ -0,0 +1,137 @@
+module EWS # :nodoc:
+  module Transaction # :nodoc:
+    
+    # As its name suggests, this class allows you to generate fake responses,
+    # allowing you to stub out the web service in your testing.
+    #
+    # The most likely responses have been catered for here, but if you require a fake response
+    # which is not provided for here, the best approach would be to generate a fake valid response
+    # and then adjust its attributes (in consultation with E-xact's Web Service Programming Reference
+    # Guide) to match the particular response you want.
+    #
+    # Example:
+    #
+    #   describe "Fake requests" do
+    #     it "should stub sending" do
+    #       request = {:nonsense => "this is nonsense"}
+    #       fake_response = EWS::Transaction::FakeResponse.valid(request) # a fake valid response
+    #       transporter = EWS::Transporter.new
+    #       transporter.stubs(:submit).returns(fake_response)
+    # 
+    #       response = transporter.submit(request)
+    #       response.should == fake_response
+    #       response.should be_approved
+    #       response.bank_message.should == "APPROVED"
+    #     end
+    #   end
+    class FakeResponse
+      
+      # fake a valid response
+      def self.valid(request)
+        build_response(request)
+      end
+      # fake a declined response
+      def self.declined(request)
+        response = build_response(request, {:bank_resp_code => '200'})
+      end
+
+      # fake a response indicating an invalid credit card number
+      def self.invalid_cc_number(request)
+        build_response(request, {:exact_resp_code => '22'})
+      end
+      # fake a response indicating an invalid credit card expiry date
+      def self.invalid_cc_expiry(request)
+        build_response(request, {:exact_resp_code => '25'})
+      end
+      # fake a response indicating an invalid amount
+      def self.invalid_amount(request)
+        build_response(request, {:exact_resp_code => '26'})
+      end
+      # fake a response indicating an invalid credit card holder name
+      def self.invalid_cardholder_name(request)
+        build_response(request, {:exact_resp_code => '27'})
+      end
+      # fake a response indicating an invalid authorisation number
+      def self.invalid_auth_num(request)
+        build_response(request, {:exact_resp_code => '28'})
+      end
+      # fake a response indicating an invalid credit card verification string
+      def self.invalid_cc_verification_str(request)
+        build_response(request, {:exact_resp_code => '31'})
+      end
+      # fake a response indicating an invalid transaction code
+      def self.invalid_transaction_code(request)
+        build_response(request, {:exact_resp_code => '32'})
+      end
+      # fake a response indicating an invalid reference number
+      def self.invalid_reference_no(request)
+        build_response(request, {:exact_resp_code => '57'})
+      end
+      # fake a response indicating an invalid address verification string
+      def self.invalid_avs(request)
+        build_response(request, {:exact_resp_code => '58'})
+      end
+      
+      private
+      
+      def self.build_response(request, options = {})
+        # copy all the information from the request
+        exact_resp_code = options[:exact_resp_code] || '00'
+        bank_resp_code = options[:bank_resp_code] || '000'
+  
+        response = EWS::Transaction::Mapping.json_to_response(EWS::Transaction::Mapping.request_to_json(request))
+        response.transaction_tag = rand(9000)
+        
+        response.exact_resp_code = exact_resp_code
+        response.exact_message = @@exact_messages[exact_resp_code]
+        if (exact_resp_code == '00')
+          response.bank_resp_code = bank_resp_code
+          response.bank_resp_code_2 = '00'
+          response.bank_message = (bank_resp_code == '000') ? "APPROVED" : "Declined"
+        end
+
+        response.error_number = 0 # no http errors occurred
+        response.transaction_error = (exact_resp_code == '00') ? 0 : 1
+        response.transaction_approved = (exact_resp_code == '00' and bank_resp_code == '000') ? 1 : 0
+        
+        response.authorization_num = "ET#{response.transaction_tag}" if response.approved?
+
+        response.sequence_no = "#{rand(100000)}"
+        response.avs = 'X'  # exact match, 9-digit zip
+        response.cvv2 = 'M' # match
+        
+        # great snowboarding ;-)
+        response.merchant_name = "Fernie Alpine Resort"
+        response.merchant_address = "5339 Fernie Ski Hill Rd."
+        response.merchant_city = "Fernie"
+        response.merchant_province = "BC"
+        response.merchant_country = "Canada"
+        response.merchant_postal = "V0B 1M6"
+        response.merchant_url = "http://skifernie.com/"
+        
+        response.ctr = "Let's pretend this is a receipt"
+        
+        response
+      end
+      
+      @@exact_messages = {
+        '00' => 'Transaction Normal',
+        '08' => 'CVV2/CID/CVC2 Data not verified',
+        '22' => 'Invalid Credit Card Number',
+        '25' => 'Invalid Expiry Date',
+        '26' => 'Invalid Amount',
+        '27' => 'Invalid Card Holder',
+        '28' => 'Invalid Authorization Number',
+        '31' => 'Invalid Verification String',
+        '32' => 'Invalid Transaction Code',
+        '57' => 'Invalid Reference Number',
+        '58' => 'Invalid AVS String'
+      }
+      
+      @@bank_messages = {
+        '000' => "APPROVED",
+        '200' => "Declined"
+      }
+    end
+  end
+end

data/lib/ews/transaction/mapping.rb

@@ -24,12 +24,13 @@ module EWS # :nodoc:
         :Track1 => :track1,
         :Track2 => :track2,
         :PAN => :pan,
-        :Authorization_Num => :auth_number,
+        :Authorization_Num => :authorization_num,
         :Expiry_Date => :cc_expiry,
         :CardHoldersName => :cardholder_name,
         :VerificationStr1 => :cc_verification_str1,
         :VerificationStr2 => :cc_verification_str2,
         :CVD_Presence_Ind => :cvd_presence_ind,
+        :ZipCode => :zip_code,
         :Tax1Amount => :tax1_amount,
         :Tax1Number => :tax1_number,
         :Tax2Amount => :tax2_amount,
@@ -45,8 +46,7 @@ module EWS # :nodoc:
         :Reference_3 => :reference_3,
         :Language => :language,
         :Client_IP => :client_ip,
-        :Client_Email => :client_email,
-        :User_Name => :user_name 
+        :Client_Email => :client_email
       } unless defined?(XML_REQUEST_TAGS_TO_ATTRS)
 
       XML_RESPONSE_TAGS_TO_ATTRS = {
@@ -72,7 +72,7 @@ module EWS # :nodoc:
         :MerchantCountry => :merchant_country,
         :MerchantPostal => :merchant_postal,
         :MerchantURL => :merchant_url,
-        :CTR => :CTR
+        :CTR => :ctr
       }.merge(XML_REQUEST_TAGS_TO_ATTRS) unless defined?(XML_RESPONSE_TAGS_TO_ATTRS)
 
       def self.request_to_json(request)
@@ -110,12 +110,38 @@ module EWS # :nodoc:
       end
       def self.rest_to_response(content)
         response = EWS::Transaction::Response.new
-        response_xml_string_to_hash(response, content)
+        xml = REXML::Document.new(content)
+        root = REXML::XPath.first(xml, "//TransactionResult")
+        response_xml_string_to_hash(response, root) if root
         response
       end
       def self.soap_to_response(content)
         response = EWS::Transaction::Response.new
-        response_xml_string_to_hash(response, content, xpath = "//types:TransactionResult")
+        xml = REXML::Document.new(content)
+        root = REXML::XPath.first(xml, "//types:TransactionResult")
+        if root
+          # we have a normal response
+          response_xml_string_to_hash(response, root)
+        else
+          # check if we have an error response
+          faultErrorRoot = REXML::XPath.first(xml, "//soap:Fault")
+          unless faultErrorRoot.nil?
+            # if we do, then see if we have a details section
+            detailRoot = REXML::XPath.first(faultErrorRoot, "detail")
+            if detailRoot.nil? or !detailRoot.has_elements?
+              # no details section, so we have an XML parsing error and should raise an exception
+              faultString = REXML::XPath.first(faultErrorRoot, "faultstring")
+              raise faultString.text
+            else
+              errorElem = REXML::XPath.first(detailRoot, "error")
+              # do have details, so figure out the error_number and error_description
+              errorNumElem = errorElem.attribute("number")
+              response.error_number = errorNumElem.value.to_i unless errorNumElem.nil?
+              errorDescElem = errorElem.attribute("description")
+              response.error_description = errorDescElem.value unless errorDescElem.nil?
+            end
+          end
+        end
         response
       end
     
@@ -128,15 +154,12 @@ module EWS # :nodoc:
         end
       end
       
-      # parses xml response string into the response attributes. The XPath identifies the root element
-      # of the payload. For REST (default) this is "//TransactionResult", for SOAP this is name space
-      # prefixed "//types:TransactionResult".
-      def self.response_xml_string_to_hash(response, xml_string, xpath = "//TransactionResult")
-        xml = REXML::Document.new(xml_string)
-        if root = REXML::XPath.first(xml, xpath)
-          root.elements.to_a.each do |node|
-            gwlib_prop_name = XML_RESPONSE_TAGS_TO_ATTRS[node.name.to_sym]
-            logger.warn("No mapping for the tag #{node.name}.") if gwlib_prop_name.nil?
+      # parses xml response elements into the response attributes
+      def self.response_xml_string_to_hash(response, root)
+        root.elements.to_a.each do |node|
+          gwlib_prop_name = XML_RESPONSE_TAGS_TO_ATTRS[node.name.to_sym]
+          unless gwlib_prop_name.nil?
+            # todo: should notiy this somehow??
             value = (ATTR_FORMATS.include?(gwlib_prop_name)) ? node.text.send("to_#{ATTR_FORMATS[gwlib_prop_name]}") : node.text
             response.send "#{gwlib_prop_name}=", value
           end

data/lib/ews/transaction/request.rb

@@ -1,3 +1,4 @@
+require 'ews/transaction/validator'
 module EWS # :nodoc:
   module Transaction # :nodoc:
     
@@ -18,7 +19,7 @@ module EWS # :nodoc:
     # Reference Guide, v8.5 be consulted. This document is contained in the Webservice Plugin ZIP file:
     # http://www.e-xact.com/wp-content/uploads/2007/06/E-xact_Payment_Webservice_Plug-In.zip
     #
-    # Please note that, if your chosen transaction requires it, credit card expiry dates *must* be entered in YYMM format.
+    # Please note that, if your chosen transaction requires it, credit card expiry dates *must* be entered in MMYY format.
     #
     # =Allowable transaction types
     #  :purchase
@@ -44,11 +45,13 @@ module EWS # :nodoc:
     #  :secure_storage_eft
     #  :transaction_details
     class Request
+      include Validator
 
+      # yeah, it's ugly, but otherwise RDoc won't pick them up
       attr_accessor :errors
-      attr_accessor :gateway_id, :password, :transaction_type, :amount, :surcharge_amount, :cc_number, :transaction_tag, :track1, :track2, :pan, :auth_number, :cc_expiry, :cardholder_name
+      attr_accessor :gateway_id, :password, :transaction_type, :amount, :surcharge_amount, :cc_number, :transaction_tag, :track1, :track2, :pan, :authorization_num, :cc_expiry, :cardholder_name
       attr_accessor :cc_verification_str1, :cc_verification_str2, :cvd_presence_ind, :tax1_amount, :tax1_number, :tax2_amount, :tax2_number, :secure_auth_required, :secure_auth_result
-      attr_accessor :ecommerce_flag, :xid, :cavv, :cavv_algorithm, :reference_no, :customer_ref, :reference_3, :language, :client_ip, :client_email, :user_name 
+      attr_accessor :ecommerce_flag, :xid, :cavv, :cavv_algorithm, :reference_no, :customer_ref, :reference_3, :language, :client_ip, :client_email, :zip_code 
 		
       # Initialize a Request with a hash of values 
       def initialize(hash = {})
@@ -62,7 +65,10 @@ module EWS # :nodoc:
         # assume we're given a symbol, so look up the code
         value = @@transaction_codes[type_sym]
         # if nothing found, then maybe we were given an actual code?
-        value = type_sym if value.nil? and @@transaction_codes.values.include?(type_sym)
+        if(value.nil?)
+          raise "invalid transaction_type supplied #{type_sym}" unless @@transaction_codes.values.include?(type_sym)
+          value = type_sym
+        end
 
         @transaction_type = value
       end
@@ -72,61 +78,7 @@ module EWS # :nodoc:
         self.transaction_type == "CR"
       end
     
-      def valid?
-        errors[:transaction_type] = "transaction_type must be supplied" if self.transaction_type.blank?
-        errors[:transaction_type] = "invalid transaction_type supplied" unless @@transaction_codes.values.include? self.transaction_type
-      
-        # need to authenticate
-        errors[:gateway_id] = "gateway_id must be supplied" if self.gateway_id.blank?
-        errors[:password] = "password must be supplied" if self.password.blank?
-
-        # ensure we've been given valid amounts
-        errors[:amount] = "invalid amount supplied" unless valid_amount?(self.amount)
-        errors[:surcharge_amount] = "invalid surcharge_amount supplied" unless valid_amount?(self.surcharge_amount)
-        errors[:tax1_amount] = "invalid tax1_amount supplied" unless valid_amount?(self.tax1_amount)
-        errors[:tax2_amount] = "invalid tax2_amount supplied" unless valid_amount?(self.tax2_amount)
-      
-        errors[:cc_number] = "invalid cc_number supplied" unless valid_card_number?
-        errors[:cc_expiry] = "invalid cc_expiry supplied" unless valid_expiry_date?
-      
-        errors.empty?
-      end
-
     private
-      def valid_amount?(amount)
-        return true if amount.blank?
-
-        (amount.class == Float) or (amount.class == Fixnum) or !amount.match(/[^0-9.]/)
-      end
-
-      def valid_card_number?
-        return true if self.cc_number.blank?
-
-        # do a mod10 check
-        weight = 1
-        card_number = self.cc_number.scan(/./).map(&:to_i)
-        result = card_number.reverse[1..-1].inject(0) do |sum, num|
-          weight = 1 + weight%2
-          digit = num * weight
-          sum += (digit / 10) + (digit % 10)
-        end
-        card_number.last == (10 - result % 10 ) % 10
-      end
-
-      def valid_expiry_date?
-        return true if self.cc_expiry.blank?
-      
-        # check format
-        return false unless self.cc_expiry.match(/^\d{4}$/)
-      
-        # check date is not in past
-        year, month = 2000 + self.cc_expiry[0..1].to_i, self.cc_expiry[2..3].to_i
-
-    		# CC is still considered valid during the month of expiry,
-    		# so just compare year and month, ignoring the rest.
-    		now = DateTime.now
-        return ((1..12) === month) && DateTime.new(year, month) >= DateTime.new(now.year, now.month)
-      end
     
       @@transaction_codes = {
         :purchase => '00',

data/lib/ews/transaction/response.rb

@@ -7,11 +7,11 @@ module EWS # :nodoc:
       attr_accessor :logon_message, :error_number, :error_description, :transaction_error, :transaction_approved
       attr_accessor :exact_resp_code, :exact_message, :bank_resp_code, :bank_message, :bank_resp_code_2
       attr_accessor :sequence_no, :avs, :cvv2, :retrieval_ref_no, :cavv_response
-      attr_accessor :merchant_name, :merchant_address, :merchant_city, :merchant_province, :merchant_country, :merchant_postal, :merchant_url, :CTR
+      attr_accessor :merchant_name, :merchant_address, :merchant_city, :merchant_province, :merchant_country, :merchant_postal, :merchant_url, :ctr
 
-      attr_accessor :gateway_id, :password, :transaction_type, :amount, :surcharge_amount, :cc_number, :transaction_tag, :track1, :track2, :pan, :auth_number, :cc_expiry, :cardholder_name
+      attr_accessor :gateway_id, :password, :transaction_type, :amount, :surcharge_amount, :cc_number, :transaction_tag, :track1, :track2, :pan, :authorization_num, :cc_expiry, :cardholder_name
       attr_accessor :cc_verification_str1, :cc_verification_str2, :cvd_presence_ind, :tax1_amount, :tax1_number, :tax2_amount, :tax2_number, :secure_auth_required, :secure_auth_result
-      attr_accessor :ecommerce_flag, :xid, :cavv, :cavv_algorithm, :reference_no, :customer_ref, :reference_3, :language, :client_ip, :client_email, :user_name 
+      attr_accessor :ecommerce_flag, :xid, :cavv, :cavv_algorithm, :reference_no, :customer_ref, :reference_3, :language, :client_ip, :client_email, :user_name, :zip_code 
 
       # Indicates whether or not the transaction was approved
       def approved?

data/lib/ews/transaction/validator.rb

@@ -0,0 +1,230 @@
+module EWS  # :nodoc:
+  module Transaction  # :nodoc:
+    module Validator
+      
+      @@valid_lengths = {
+        :authorization_num => 8,
+        :cardholder_name => 30,
+        :cc_number => 19,
+        :cc_expiry => 4,
+        :cavv => 40,
+        :client_email => 30,
+        :client_ip => 15,
+        :customer_ref => 20,
+        :gateway_id => 10,
+        :pan => 39,
+        :password => 30,
+        :reference_3 => 30,
+        :reference_no => 20,
+        :tax1_number => 20,
+        :tax2_number => 20,
+        :track1 => 79,
+        :track2 => 40,
+        :transaction_type => 2,
+        :cc_verification_str1 => 40,
+        :cc_verification_str2 => 4,
+        :xid => 40,
+        :zip_code => 10
+      }.freeze unless defined?(@@valid_lengths)
+      
+      def valid?
+        @errors = {}
+
+        validate_lengths
+        
+        validate_mandatory_fields
+        
+        append_error(:transaction_type, "transaction_type must be supplied") if self.transaction_type.blank?
+      
+        # need to authenticate
+        append_error(:gateway_id, "gateway_id must be supplied") if self.gateway_id.blank?
+        append_error(:password, "password must be supplied") if self.password.blank?
+
+        # ensure we've been given valid amounts
+        append_error(:amount, "invalid amount supplied") unless valid_amount?(self.amount)
+        append_error(:surcharge_amount, "invalid surcharge_amount supplied") unless valid_amount?(self.surcharge_amount)
+        append_error(:tax1_amount, "invalid tax1_amount supplied") unless valid_amount?(self.tax1_amount)
+        append_error(:tax2_amount, "invalid tax2_amount supplied") unless valid_amount?(self.tax2_amount)
+
+        # ensure our amounts are within range
+        append_error(:amount, "amount must be between 0.00 and 99999.99") unless amount_too_big?(self.amount)
+        append_error(:surcharge_amount, "amount must be between 0.00 and 99999.99") unless amount_too_big?(self.surcharge_amount)
+        append_error(:tax1_amount, "amount must be between 0.00 and 99999.99") unless amount_too_big?(self.tax1_amount)
+        append_error(:tax2_amount, "amount must be between 0.00 and 99999.99") unless amount_too_big?(self.tax2_amount)
+        
+        # ensure our credit card information is valid
+        append_error(:cc_number, "invalid cc_number supplied") unless valid_card_number?
+        append_error(:cc_expiry, "invalid cc_expiry supplied") unless valid_expiry_date?
+        
+        @errors.empty?
+      end
+      
+    private
+      def validate_lengths
+        @@valid_lengths.each do |k,len|
+          value = self.send k
+          append_error(k, "#{k.to_s} is too long. maximum allowed length is #{len} characters") unless value.nil? or (value.length <= len)
+        end
+      end
+      
+      # which fields are mandatory and which optional depends on the transaction_type and
+      # also how the credit card information is supplied.
+      #
+      # it can be supplied either
+      # a) via the cc_number field
+      # b) via a tagged transaction
+      # c) encoded in a track1 value, or
+      # d) encoded in a track2 value
+      def validate_mandatory_fields
+        if !self.cc_number.blank?
+          validate_for_card
+        elsif !self.transaction_tag.blank?
+          validate_for_transaction_tag
+        elsif !self.track1.blank?
+          validate_for_track1
+        elsif !self.track2.blank?
+          validate_for_track2
+        end
+      end
+      
+      def valid_amount?(amount)
+        return true if amount.blank?
+
+        ((amount.class == Float) or (amount.class == Fixnum) or !amount.match(/[^0-9.]/))        
+      end
+      def amount_too_big?(amount)
+        return true if amount.blank?
+
+        return ((amount.to_f <= 99999.99) and (amount.to_f >= 0.0))
+      end
+
+      def valid_card_number?
+        return true if self.cc_number.blank?
+
+        # do a mod10 check
+        weight = 1
+        card_number = self.cc_number.scan(/./).map(&:to_i)
+        result = card_number.reverse[1..-1].inject(0) do |sum, num|
+          weight = 1 + weight%2
+          digit = num * weight
+          sum += (digit / 10) + (digit % 10)
+        end
+        card_number.last == (10 - result % 10 ) % 10
+      end
+
+      # date should be...
+      # - not blank
+      # - 4 digits
+      # - MMYY format
+      # - not in the past
+      def valid_expiry_date?
+        return true if self.cc_expiry.blank?
+      
+        # check format
+        return false unless self.cc_expiry.match(/^\d{4}$/)
+      
+        # check date is not in past
+        year, month = 2000 + self.cc_expiry[2..3].to_i, self.cc_expiry[0..1].to_i
+
+    		# CC is still considered valid during the month of expiry,
+    		# so just compare year and month, ignoring the rest.
+    		now = DateTime.now
+        return ((1..12) === month) && DateTime.new(year, month) >= DateTime.new(now.year, now.month)
+      end
+      
+      def append_error(key, message)
+        if @errors[key].nil?
+          @errors[key] = message 
+        else
+          # otherwise convert into an array of errors
+          current_val = @errors[key]
+          if current_val.is_a?(String)
+            @errors[key] = [current_val, message]
+          else
+            @errors[key] << message
+          end
+        end
+      end
+
+      # validate presence of mandatort fields when cc_number present
+      def validate_for_card
+        tt = self.transaction_type.to_i
+        
+        # mandatory: transaction_type must != (30, 31, 32, 34, 35)
+        append_error(:cc_number, "cc_number must not be set for tagged transactions") if [30,31,32,34,35].include?(tt)
+        
+        # amount, cardholder_name always mandaory
+        mandatory = [:amount, :cardholder_name]
+        
+        # card_number & expiry_date mandatory for all except 50, 54
+        # pan mandatory for only 50, 54
+        mandatory << ([50,54].include?(tt) ? :pan : [:cc_number, :cc_expiry])
+        mandatory.flatten!
+
+        # reference_no mandatory for 60
+        mandatory << :reference_no if tt == 60
+        
+        # auth_number mandatory for (02, 03, 11, 12, 13)
+        mandatory << :authorization_num if [02, 03, 11, 12, 13].include?(tt)
+        
+        check_mandatory(mandatory)
+      end
+
+      def validate_for_transaction_tag
+        tt = self.transaction_type
+
+        # mandatory: transaction_type must == (30, 31, 32, 34, 35)
+        append_error(:transaction_tag, "transaction_tag must only be set for tagged transactions") unless ['30','31','32','34','35','CR'].include?(tt)
+        
+        # transaction_tag, auth_num & amount mandatory
+        mandatory = [:transaction_tag]
+        mandatory << [:authorization_num, :amount] unless tt == 'CR'
+        
+        check_mandatory(mandatory.flatten)
+      end
+      
+      def validate_for_track1
+        tt = self.transaction_type.to_i
+        
+        # mandatory: transaction_type must != (30, 31, 32, 34, 35)
+        append_error(:track1, "track1 must not be set for tagged transactions") if [30,31,32,34,35].include?(tt)
+
+        # amount mandatory for all
+        mandatory = [:amount]
+        
+        # track1 mandatory, except 50,54
+        # pan mandatory 50,54 only
+        mandatory << ([50,54].include?(tt) ? :pan : :track1)
+
+        # reference_no mandatory for 60
+        mandatory << :reference_no if tt == 60
+        # auth_number mandatory for (02, 03, 11, 12, 13)
+        mandatory << :authorization_num if [02, 03, 11, 12, 13].include?(tt)
+        
+        check_mandatory(mandatory)
+      end
+      
+      def validate_for_track2
+        tt = self.transaction_type.to_i
+
+        # mandatory: transaction_type must != (30, 31, 32, 34, 35, 50, 54)
+        append_error(:track1, "track1 must not be set for tagged transactions") if [30,31,32,34,35,50,54].include?(tt)
+
+        # track2, expiry_date, cardholder_name, amount mandatory
+        mandatory = [:track2, :cc_expiry, :cardholder_name, :amount]
+        
+        # auth_number mandatory for (02, 03, 11, 12, 13)
+        mandatory << :authorization_num if [02, 03, 11, 12, 13].include?(tt)
+        
+        check_mandatory(mandatory)
+      end
+      
+      def check_mandatory(mandatory)
+        mandatory.each do |key|
+          append_error(key, "#{key} is required") if self.send(key).blank?
+        end
+      end
+    end
+  end
+end
+