activemerchant 1.42.6 → 1.90.0

data/lib/active_merchant/billing/gateways/metrics_global.rb

@@ -20,8 +20,8 @@ module ActiveMerchant #:nodoc:
 
       class_attribute :test_url, :live_url
 
-      self.test_url = "https://secure.metricsglobalgateway.com/gateway/transact.dll?testing=true"
-      self.live_url = "https://secure.metricsglobalgateway.com/gateway/transact.dll"
+      self.test_url = 'https://secure.metricsglobalgateway.com/gateway/transact.dll?testing=true'
+      self.live_url = 'https://secure.metricsglobalgateway.com/gateway/transact.dll'
 
       class_attribute :duplicate_window
 
@@ -150,7 +150,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def credit(money, identification, options = {})
-        deprecated CREDIT_DEPRECATION_MESSAGE
+        ActiveMerchant.deprecated CREDIT_DEPRECATION_MESSAGE
         refund(money, identification, options)
       end
 
@@ -213,14 +213,14 @@ module ActiveMerchant #:nodoc:
         post[:version]        = API_VERSION
         post[:login]          = @options[:login]
         post[:tran_key]       = @options[:password]
-        post[:relay_response] = "FALSE"
+        post[:relay_response] = 'FALSE'
         post[:type]           = action
-        post[:delim_data]     = "TRUE"
-        post[:delim_char]     = ","
-        post[:encap_char]     = "$"
-        post[:solution_ID]    = application_id if application_id.present? && application_id != "ActiveMerchant"
+        post[:delim_data]     = 'TRUE'
+        post[:delim_char]     = ','
+        post[:encap_char]     = '$'
+        post[:solution_ID]    = application_id if application_id
 
-        request = post.merge(parameters).collect { |key, value| "x_#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+        request = post.merge(parameters).collect { |key, value| "x_#{key}=#{CGI.escape(value.to_s)}" }.join('&')
         request
       end
 
@@ -284,39 +284,20 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      # Make a ruby type out of the response string
-      def normalize(field)
-        case field
-        when "true"   then true
-        when "false"  then false
-        when ""       then nil
-        when "null"   then nil
-        else field
-        end
-      end
-
       def message_from(results)
         if results[:response_code] == DECLINED
-          return CVVResult.messages[ results[:card_code] ] if CARD_CODE_ERRORS.include?(results[:card_code])
+          return CVVResult.messages[results[:card_code]] if CARD_CODE_ERRORS.include?(results[:card_code])
           if AVS_REASON_CODES.include?(results[:response_reason_code]) && AVS_ERRORS.include?(results[:avs_result_code])
-            return AVSResult.messages[ results[:avs_result_code] ]
+            return AVSResult.messages[results[:avs_result_code]]
           end
         end
 
         (results[:response_reason_text] ? results[:response_reason_text].chomp('.') : '')
       end
 
-      def expdate(creditcard)
-        year  = sprintf("%.4i", creditcard.year)
-        month = sprintf("%.2i", creditcard.month)
-
-        "#{month}#{year[-2..-1]}"
-      end
-
       def split(response)
         response[1..-2].split(/\$,\$/)
       end
-
     end
   end
 end

data/lib/active_merchant/billing/gateways/micropayment.rb

@@ -0,0 +1,183 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class MicropaymentGateway < Gateway
+
+      self.display_name = 'micropayment'
+      self.homepage_url = 'https://www.micropayment.de/'
+
+      self.test_url = self.live_url = 'https://sipg.micropayment.de/public/creditcardpsp/v1/nvp/'
+
+      self.supported_countries = %w(DE)
+      self.default_currency = 'EUR'
+      self.money_format = :cents
+      self.supported_cardtypes = [:visa, :master, :american_express]
+
+      def initialize(options={})
+        requires!(options, :access_key)
+        super
+      end
+
+      def purchase(amount, payment_method, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_payment_method(post, payment_method, options)
+        add_customer_data(post, options)
+        add_address(post, options)
+        commit('purchase', post)
+      end
+
+      def authorize(amount, payment_method, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_payment_method(post, payment_method, options)
+        add_customer_data(post, options)
+        add_address(post, options)
+        commit('authorize', post)
+      end
+
+      def capture(amount, authorization, options={})
+        post = {}
+        add_reference(post, authorization)
+        add_invoice(post, amount, options)
+        commit('capture', post)
+      end
+
+      def void(authorization, options={})
+        post = {}
+        add_reference(post, authorization)
+        commit('void', post)
+      end
+
+      def refund(amount, authorization, options={})
+        post = {}
+        add_reference(post, authorization)
+        add_invoice(post, amount, options)
+        commit('refund', post)
+      end
+
+      def verify(credit_card, options={})
+        MultiResponse.run(:use_first_response) do |r|
+          r.process { authorize(250, credit_card, options) }
+          r.process(:ignore_result) { void(r.authorization, options) }
+        end
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((accessKey=)\w+), '\1[FILTERED]').
+          gsub(%r((number=)\d+), '\1[FILTERED]').
+          gsub(%r((cvc2=)\d+), '\1[FILTERED]')
+      end
+
+      private
+
+      def add_invoice(post, money, options)
+        if money
+          post[:amount] = amount(money)
+          post[:currency] = options[:currency] || currency(money)
+        end
+        post[:project] = options[:project] if options[:project]
+        post['params[title]'] = options[:description] if options[:description]
+      end
+
+      def add_payment_method(post, payment_method, options={})
+        post[:number] = payment_method.number
+        post[:recurring] = 1 if options[:recurring] == true
+        post[:cvc2] = payment_method.verification_value
+        post[:expiryYear] = format(payment_method.year, :four_digits)
+        post[:expiryMonth] = format(payment_method.month, :two_digits)
+
+        post['params[firstname]'] = payment_method.first_name
+        post['params[surname]'] = payment_method.last_name
+      end
+
+      def add_customer_data(post, options)
+        post['params[email]'] = options[:email] if options[:email]
+        post['params[ip]'] = options[:ip] || '1.1.1.1'
+        post['params[sendMail]'] = options[:send_mail] || 'false'
+      end
+
+      def add_address(post, options)
+        address = options[:billing_address]
+        return unless address
+
+        post['params[address]'] = address[:address1] if address[:address1]
+        post['params[zipcode]'] = address[:zip] if address[:zip]
+        post['params[town]'] = address[:city] if address[:city]
+        post['params[country]'] = address[:country] if address[:country]
+      end
+
+      def add_reference(post, authorization)
+        session_id, transaction_id = split_authorization(authorization)
+        post[:sessionId] = session_id
+        post[:transactionId] = transaction_id
+      end
+
+      def commit(action, params)
+        params[:testMode] = 1 if test?
+        params[:accessKey] = @options[:access_key]
+        params[:apiKey] = @options[:api_key] || 'af1fd841af792f4c50131414ff76e004'
+
+        response = parse(ssl_post(url(action), post_data(action, params), headers))
+
+        Response.new(
+          succeeded = success_from(response),
+          message_from(succeeded, response),
+          response,
+          authorization: authorization_from(response, params),
+          avs_result: AVSResult.new(code: response['some_avs_result_key']),
+          cvv_result: CVVResult.new(response['some_cvv_result_key']),
+          test: test?
+        )
+      end
+
+      def headers
+        { 'Content-Type'  => 'application/x-www-form-urlencoded;charset=UTF-8' }
+      end
+
+      def post_data(action, params)
+        params.map { |k, v| "#{CGI.escape(k.to_s)}=#{CGI.escape(v.to_s)}" }.join('&')
+      end
+
+      def url(action)
+        action_url = test? ? test_url : live_url
+        "#{action_url}?action=#{action}"
+      end
+
+      def parse(body)
+        body.split(/\r?\n/).inject({}) do |acc, pair|
+          key, value = pair.split('=')
+          acc[key] = CGI.unescape(value)
+          acc
+        end
+      end
+
+      def success_from(response)
+        response['error'] == '0' &&
+          response['transactionResultCode'] == '00' &&
+          response['transactionStatus'] == 'SUCCESS'
+      end
+
+      def message_from(succeeded, response)
+        if succeeded
+          'Succeeded'
+        else
+          response['errorMessage'] || response['transactionResultMessage']
+        end
+      end
+
+      def split_authorization(authorization)
+        authorization.split('|')
+      end
+
+      def authorization_from(response, request_params)
+        session_id = response['sessionId'] || request_params[:sessionId]
+        "#{session_id}|#{response["transactionId"]}"
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/gateways/migs.rb

@@ -1,6 +1,4 @@
-require File.dirname(__FILE__) + '/migs/migs_codes'
-
-require 'digest/md5' # Used in add_secure_hash
+require 'active_merchant/billing/gateways/migs/migs_codes'
 
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
@@ -19,12 +17,13 @@ module ActiveMerchant #:nodoc:
       # MiGS is supported throughout Asia Pacific, Middle East and Africa
       # MiGS is used in Australia (AU) by ANZ (eGate), CBA (CommWeb) and more
       # Source of Country List: http://www.scribd.com/doc/17811923
-      self.supported_countries = %w(AU AE BD BN EG HK ID IN JO KW LB LK MU MV MY NZ OM PH QA SA SG TT VN)
+      self.supported_countries = %w(AU AE BD BN EG HK ID JO KW LB LK MU MV MY NZ OM PH QA SA SG TT VN)
 
       # The card types supported by the payment gateway
       self.supported_cardtypes = [:visa, :master, :american_express, :diners_club, :jcb]
 
       self.money_format = :cents
+      self.currencies_without_fractions = %w(IDR)
 
       # The homepage URL of the gateway
       self.homepage_url = 'http://mastercard.com/mastercardsps'
@@ -58,10 +57,12 @@ module ActiveMerchant #:nodoc:
         requires!(options, :order_id)
 
         post = {}
-        post[:Amount] = amount(money)
+
+        add_amount(post, money, options)
         add_invoice(post, options)
         add_creditcard(post, creditcard)
         add_standard_parameters('pay', post, options[:unique_id])
+        add_3ds(post, options)
 
         commit(post)
       end
@@ -78,7 +79,8 @@ module ActiveMerchant #:nodoc:
         requires!(@options, :advanced_login, :advanced_password)
 
         post = options.merge(:TransNo => authorization)
-        post[:Amount] = amount(money)
+
+        add_amount(post, money, options)
         add_advanced_user(post)
         add_standard_parameters('capture', post, options[:unique_id])
 
@@ -93,18 +95,37 @@ module ActiveMerchant #:nodoc:
         requires!(@options, :advanced_login, :advanced_password)
 
         post = options.merge(:TransNo => authorization)
-        post[:Amount] = amount(money)
+
+        add_amount(post, money, options)
         add_advanced_user(post)
         add_standard_parameters('refund', post, options[:unique_id])
 
         commit(post)
       end
 
+      def void(authorization, options = {})
+        requires!(@options, :advanced_login, :advanced_password)
+
+        post = options.merge(:TransNo => authorization)
+
+        add_advanced_user(post)
+        add_standard_parameters('voidAuthorisation', post, options[:unique_id])
+
+        commit(post)
+      end
+
       def credit(money, authorization, options = {})
-        deprecated CREDIT_DEPRECATION_MESSAGE
+        ActiveMerchant.deprecated CREDIT_DEPRECATION_MESSAGE
         refund(money, authorization, options)
       end
 
+      def verify(credit_card, options={})
+        MultiResponse.run do |r|
+          r.process { authorize(100, credit_card, options) }
+          r.process(:ignore_result) { void(r.authorization, options) }
+        end
+      end
+
       # Checks the status of a previous transaction
       # This can be useful when a response is not received due to network issues
       #
@@ -143,14 +164,13 @@ module ActiveMerchant #:nodoc:
         requires!(@options, :secure_hash)
 
         post = {}
-        post[:Amount] = amount(money)
+
+        add_amount(post, money, options)
         add_invoice(post, options)
         add_creditcard_type(post, options[:card_type]) if options[:card_type]
 
-        post.merge!(
-          :Locale => options[:locale] || 'en',
-          :ReturnURL => options[:return_url]
-        )
+        post[:Locale] = options[:locale] || 'en'
+        post[:ReturnURL] = options[:return_url]
 
         add_standard_parameters('pay', post, options[:unique_id])
 
@@ -170,9 +190,9 @@ module ActiveMerchant #:nodoc:
 
         response_hash = parse(data)
 
-        expected_secure_hash = calculate_secure_hash(response_hash.reject{|k, v| k == :SecureHash}, @options[:secure_hash])
+        expected_secure_hash = calculate_secure_hash(response_hash, @options[:secure_hash])
         unless response_hash[:SecureHash] == expected_secure_hash
-          raise SecurityError, "Secure Hash mismatch, response may be tampered with"
+          raise SecurityError, 'Secure Hash mismatch, response may be tampered with'
         end
 
         response_object(response_hash)
@@ -182,8 +202,27 @@ module ActiveMerchant #:nodoc:
         @options[:login].start_with?('TEST')
       end
 
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((&?CardNum=)\d*(&?)), '\1[FILTERED]\2').
+          gsub(%r((&?CardSecurityCode=)\d*(&?)), '\1[FILTERED]\2').
+          gsub(%r((&?AccessCode=)[^&]*(&?)), '\1[FILTERED]\2').
+          gsub(%r((&?Password=)[^&]*(&?)), '\1[FILTERED]\2').
+          gsub(%r((&?3DSXID=)[^&]*(&?)), '\1[FILTERED]\2').
+          gsub(%r((&?VerToken=)[^&]*(&?)), '\1[FILTERED]\2')
+      end
+
       private
 
+      def add_amount(post, money, options)
+        post[:Amount] = localized_amount(money, options[:currency])
+        post[:Currency] = options[:currency] if options[:currency]
+      end
+
       def add_advanced_user(post)
         post[:User] = @options[:advanced_login]
         post[:Password] = @options[:advanced_password]
@@ -193,6 +232,15 @@ module ActiveMerchant #:nodoc:
         post[:OrderInfo] = options[:order_id]
       end
 
+      def add_3ds(post, options)
+        post[:VerType] = options[:ver_type] if options[:ver_type]
+        post[:VerToken] = options[:ver_token] if options[:ver_token]
+        post['3DSXID'] = options[:three_ds_xid] if options[:three_ds_xid]
+        post['3DSECI'] = options[:three_ds_eci] if options[:three_ds_eci]
+        post['3DSenrolled'] = options[:three_ds_enrolled] if options[:three_ds_enrolled]
+        post['3DSstatus'] = options[:three_ds_status] if options[:three_ds_status]
+      end
+
       def add_creditcard(post, creditcard)
         post[:CardNum] = creditcard.number
         post[:CardSecurityCode] = creditcard.verification_value if creditcard.verification_value?
@@ -201,7 +249,7 @@ module ActiveMerchant #:nodoc:
 
       def add_creditcard_type(post, card_type)
         post[:Gateway]  = 'ssl'
-        post[:card] = CARD_TYPES.detect{|ct| ct.am_code == card_type}.migs_long_code
+        post[:card] = CARD_TYPES.detect { |ct| ct.am_code == card_type }.migs_long_code
       end
 
       def parse(body)
@@ -214,18 +262,25 @@ module ActiveMerchant #:nodoc:
       end
 
       def commit(post)
+        add_secure_hash(post) if @options[:secure_hash]
         data = ssl_post self.merchant_hosted_url, post_data(post)
         response_hash = parse(data)
         response_object(response_hash)
       end
 
       def response_object(response)
+        avs_response_code = response[:AVSResultCode]
+        avs_response_code = 'S' if avs_response_code == 'Unsupported'
+
+        cvv_result_code = response[:CSCResultCode]
+        cvv_result_code = 'P' if cvv_result_code == 'Unsupported'
+
         Response.new(success?(response), response[:Message], response,
           :test => test?,
           :authorization => response[:TransactionNo],
           :fraud_review => fraud_review?(response),
-          :avs_result => { :code => response[:AVSResultCode] },
-          :cvv_result => response[:CSCResultCode]
+          :avs_result => { :code => avs_response_code },
+          :cvv_result => cvv_result_code
         )
       end
 
@@ -248,17 +303,21 @@ module ActiveMerchant #:nodoc:
       end
 
       def post_data(post)
-        post.collect { |key, value| "vpc_#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+        post.collect { |key, value| "vpc_#{key}=#{CGI.escape(value.to_s)}" }.join('&')
       end
 
       def add_secure_hash(post)
         post[:SecureHash] = calculate_secure_hash(post, @options[:secure_hash])
+        post[:SecureHashType] = 'SHA256'
       end
 
       def calculate_secure_hash(post, secure_hash)
-        sorted_values = post.sort_by(&:to_s).map(&:last)
-        input = secure_hash + sorted_values.join
-        Digest::MD5.hexdigest(input).upcase
+        input = post.
+                reject { |k| %i[SecureHash SecureHashType].include?(k) }.
+                sort.
+                map { |(k, v)| "vpc_#{k}=#{v}" }.
+                join('&')
+        OpenSSL::HMAC.hexdigest('SHA256', [secure_hash].pack('H*'), input).upcase
       end
     end
   end

data/lib/active_merchant/billing/gateways/modern_payments.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/modern_payments_cim'
+require 'active_merchant/billing/gateways/modern_payments_cim'
 
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
@@ -19,7 +19,7 @@ module ActiveMerchant #:nodoc:
         customer_response = cim.create_customer(options)
         return customer_response unless customer_response.success?
 
-        customer_id = customer_response.params["create_customer_result"]
+        customer_id = customer_response.params['create_customer_result']
 
         card_response = cim.modify_customer_credit_card(customer_id, credit_card)
         return card_response unless card_response.success?
@@ -28,10 +28,10 @@ module ActiveMerchant #:nodoc:
       end
 
       private
+
       def cim
         @cim ||= ModernPaymentsCimGateway.new(@options)
       end
     end
   end
 end
-

data/lib/active_merchant/billing/gateways/modern_payments_cim.rb

@@ -1,20 +1,20 @@
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class ModernPaymentsCimGateway < Gateway #:nodoc:
-      self.test_url = "https://secure.modpay.com/netservices/test/ModpayTest.asmx"
+      self.test_url = 'https://secure.modpay.com/netservices/test/ModpayTest.asmx'
       self.live_url = 'https://secure.modpay.com/ws/modpay.asmx'
 
-      LIVE_XMLNS = "https://secure.modpay.com/ws/"
-      TEST_XMLNS = "https://secure.modpay.com/netservices/test/"
+      LIVE_XMLNS = 'https://secure.modpay.com/ws/'
+      TEST_XMLNS = 'https://secure.modpay.com/netservices/test/'
 
       self.supported_countries = ['US']
       self.supported_cardtypes = [:visa, :master, :american_express, :discover]
       self.homepage_url = 'http://www.modpay.com'
       self.display_name = 'Modern Payments'
 
-      SUCCESS_MESSAGE = "Transaction accepted"
-      FAILURE_MESSAGE = "Transaction failed"
-      ERROR_MESSAGE   = "Transaction error"
+      SUCCESS_MESSAGE = 'Transaction accepted'
+      FAILURE_MESSAGE = 'Transaction failed'
+      ERROR_MESSAGE   = 'Transaction error'
 
       PAYMENT_METHOD = {
         :check => 1,
@@ -35,7 +35,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def modify_customer_credit_card(customer_id, credit_card)
-        raise ArgumentError, "The customer_id cannot be blank" if customer_id.blank?
+        raise ArgumentError, 'The customer_id cannot be blank' if customer_id.blank?
 
         post = {}
         add_customer_id(post, customer_id)
@@ -45,7 +45,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def authorize_credit_card_payment(customer_id, amount)
-        raise ArgumentError, "The customer_id cannot be blank" if customer_id.blank?
+        raise ArgumentError, 'The customer_id cannot be blank' if customer_id.blank?
 
         post = {}
         add_customer_id(post, customer_id)
@@ -55,7 +55,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def create_payment(customer_id, amount, options = {})
-        raise ArgumentError, "The customer_id cannot be blank" if customer_id.blank?
+        raise ArgumentError, 'The customer_id cannot be blank' if customer_id.blank?
 
         post = {}
         add_customer_id(post, customer_id)
@@ -66,8 +66,9 @@ module ActiveMerchant #:nodoc:
       end
 
       private
+
       def add_payment_details(post, options)
-        post[:pmtDate] = (options[:payment_date] || Time.now.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+        post[:pmtDate] = (options[:payment_date] || Time.now.utc).strftime('%Y-%m-%dT%H:%M:%SZ')
         post[:pmtType] = PAYMENT_METHOD[options[:payment_method] || :credit_card]
       end
 
@@ -87,9 +88,7 @@ module ActiveMerchant #:nodoc:
         address = options[:billing_address] || options[:address] || {}
 
         if name = address[:name]
-          segments = name.split(' ')
-          post[:lastName] = segments.pop
-          post[:firstName] = segments.join(' ')
+          post[:firstName], post[:lastName] = split_names(name)
         else
           post[:firstName] = address[:first_name]
           post[:lastName]  = address[:last_name]
@@ -120,10 +119,10 @@ module ActiveMerchant #:nodoc:
             'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance' } do
 
           xml.tag! 'env:Body' do
-            xml.tag! action, { "xmlns" => xmlns(action) } do
-              xml.tag! "clientId", @options[:login]
-              xml.tag! "clientCode", @options[:password]
-              params.each {|key, value| xml.tag! key, value }
+            xml.tag! action, { 'xmlns' => xmlns(action) } do
+              xml.tag! 'clientId', @options[:login]
+              xml.tag! 'clientCode', @options[:password]
+              params.each { |key, value| xml.tag! key, value }
             end
           end
         end
@@ -148,9 +147,9 @@ module ActiveMerchant #:nodoc:
 
       def commit(action, params)
         data = ssl_post(url(action), build_request(action, params),
-                 { 'Content-Type' =>'text/xml; charset=utf-8',
-                   'SOAPAction' => "#{xmlns(action)}#{action}" }
-                )
+          { 'Content-Type' =>'text/xml; charset=utf-8',
+            'SOAPAction' => "#{xmlns(action)}#{action}" }
+        )
 
         response = parse(action, data)
         Response.new(successful?(action, response), message_from(action, response), response,
@@ -165,14 +164,14 @@ module ActiveMerchant #:nodoc:
       end
 
       def authorization_key(action)
-        action == "AuthorizeCreditCardPayment" ? :trans_id : "#{action.underscore}_result".to_sym
+        action == 'AuthorizeCreditCardPayment' ? :trans_id : "#{action.underscore}_result".to_sym
       end
 
       def successful?(action, response)
         key = authorization_key(action)
 
         if key == :trans_id
-          response[:approved] == "true"
+          response[:approved] == 'true'
         else
           response[key].to_i > 0
         end
@@ -197,7 +196,7 @@ module ActiveMerchant #:nodoc:
           root.elements.to_a.each do |node|
             parse_element(response, node)
           end
-        elsif root = REXML::XPath.first(xml, "//soap:Fault")
+        elsif root = REXML::XPath.first(xml, '//soap:Fault')
           root.elements.to_a.each do |node|
             response[node.name.underscore.to_sym] = node.text
           end
@@ -208,7 +207,7 @@ module ActiveMerchant #:nodoc:
 
       def parse_element(response, node)
         if node.has_elements?
-          node.elements.each{|e| parse_element(response, e) }
+          node.elements.each { |e| parse_element(response, e) }
         else
           response[node.name.underscore.to_sym] = node.text.to_s.strip
         end
@@ -216,4 +215,3 @@ module ActiveMerchant #:nodoc:
     end
   end
 end
-