wire_client 0.1.0

data/lib/wire_client/messages/direct_debit.rb

@@ -0,0 +1,148 @@
+require_relative './message'
+require_relative '../transaction/direct_debit_transaction'
+
+module WireClient
+  class DirectDebit < Message
+    self.account_class = CreditorAccount
+    self.transaction_class = DirectDebitTransaction
+    self.xml_main_tag = 'CstmrDrctDbtInitn'
+    self.known_schemas = [WireClient::PAIN_008_001_02]
+
+    validate do |record|
+      if record.transactions.map(&:local_instrument).uniq.size > 1
+        errors.add(
+          :base,
+          'CORE, COR1 and B2B must not be mixed in one message!'
+        )
+      end
+    end
+
+    private
+
+    # Find groups of transactions which share the same values for
+    # selected attributes
+    def transaction_group(transaction)
+      {
+        requested_date:   transaction.requested_date,
+        local_instrument: transaction.local_instrument,
+        sequence_type:    transaction.sequence_type,
+        batch_booking:    transaction.batch_booking,
+        account:          transaction.creditor_account || account,
+        service_priority: transaction.service_priority,
+        service_level:    transaction.service_level
+      }
+    end
+
+    def build_payment_information(builder)
+      # Build a PmtInf block for every group of transactions
+      grouped_transactions.each do |group, transactions|
+        builder.PmtInf do
+          builder.PmtInfId(payment_information_identification(group))
+          builder.PmtMtd('TRF')
+          builder.BtchBookg(group[:batch_booking])
+          builder.NbOfTxs(transactions.length)
+          builder.CtrlSum('%.2f' % amount_total(transactions))
+          builder.PmtTpInf do
+            builder.InstrPrty(group[:service_priority])
+            builder.SvcLvl do
+              builder.Cd(group[:service_level])
+            end
+            builder.LclInstrm do
+              builder.Cd(group[:local_instrument])
+            end
+            builder.SeqTp(group[:sequence_type])
+          end
+          builder.ReqdColltnDt(group[:requested_date].iso8601)
+          builder.Cdtr do
+            builder.Nm(group[:account].name)
+            builder.PstlAdr do
+              builder.CtrySubDvsn(account.country_subdivision_name)
+              builder.Ctry(account.country)
+            end
+          end
+          builder.CdtrAcct do
+            account_id(builder, group[:account])
+          end
+          builder.CdtrAgt do
+            builder.FinInstnId do
+              account_agent_id(builder, group[:account])
+            end
+          end
+
+          if account.charge_bearer
+            builder.ChrgBr(account.charge_bearer)
+          end
+
+          transactions.each do |transaction|
+            build_transaction(builder, transaction)
+          end
+        end
+      end
+    end
+
+    def build_amendment_informations(builder, transaction)
+      return unless transaction.original_debtor_account ||
+                    transaction.same_mandate_new_debtor_agent
+      builder.AmdmntInd(true)
+      builder.AmdmntInfDtls do
+        if transaction.original_debtor_account
+          builder.OrgnlDbtrAcct do
+            builder.Id do
+              builder.IBAN(transaction.original_debtor_account)
+            end
+          end
+        else
+          builder.OrgnlDbtrAgt do
+            builder.FinInstnId do
+              builder.Othr do
+                builder.Id('SMNDA')
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def build_transaction(builder, transaction)
+      builder.DrctDbtTxInf do
+        builder.PmtId do
+          if transaction.instruction.present?
+            builder.InstrId(transaction.instruction)
+          end
+          builder.EndToEndId(transaction.reference)
+        end
+        builder.InstdAmt(
+          '%.2f' % transaction.amount,
+          Ccy: transaction.currency
+        )
+        builder.DrctDbtTx do
+          builder.MndtRltdInf do
+            builder.MndtId(transaction.mandate_id)
+            builder.DtOfSgntr(transaction.mandate_date_of_signature.iso8601)
+            build_amendment_informations(builder, transaction)
+          end
+        end
+        builder.DbtrAgt do
+          builder.FinInstnId do
+            transaction_agent_id(builder, transaction)
+            builder.Nm(transaction.agent_name)
+            builder.PstlAdr do
+              builder.Ctry(transaction.country)
+            end
+          end
+        end
+        builder.Dbtr do
+          builder.Nm(transaction.name)
+        end
+        builder.DbtrAcct do
+          transaction_account_id(builder, transaction)
+        end
+        if transaction.remittance_information
+          builder.RmtInf do
+            builder.Ustrd(transaction.remittance_information)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wire_client/messages/message.rb

@@ -0,0 +1,215 @@
+module WireClient
+  class Message
+    include ActiveModel::Validations
+
+    attr_reader :account, :grouped_transactions
+
+    validates_presence_of :transactions
+    validate do |record|
+      unless record.account.valid?
+        record.errors.add(:account, record.account.errors.full_messages)
+      end
+    end
+
+    class_attribute :account_class,
+                    :transaction_class,
+                    :xml_main_tag,
+                    :known_schemas
+
+    def initialize(account_options={})
+      @grouped_transactions = {}
+      @account = account_class.new(account_options)
+    end
+
+    def add_transaction(options)
+      transaction = transaction_class.new(options)
+      unless transaction.valid?
+        raise ArgumentError, transaction.error_messages
+      end
+      @grouped_transactions[transaction_group(transaction)] ||= []
+      @grouped_transactions[transaction_group(transaction)] << transaction
+    end
+
+    def transactions
+      grouped_transactions.values.flatten
+    end
+
+    # @return [String] xml
+    def to_xml(schema_name=self.class.known_schemas.first)
+      raise(RuntimeError, errors.full_messages.join("\n")) unless valid?
+      unless schema_compatible?(schema_name)
+        raise RuntimeError, "Incompatible with schema #{schema_name}!"
+      end
+
+      builder = Builder::XmlMarkup.new indent: 2
+      builder.instruct! :xml
+      builder.Document(xml_schema(schema_name)) do
+        builder.__send__(self.class.xml_main_tag) do
+          build_group_header(builder)
+          build_payment_information(builder)
+        end
+      end
+    end
+
+    def amount_total(selected_transactions=transactions)
+      selected_transactions.inject(0) { |sum, t| sum + t.amount }
+    end
+
+    def schema_compatible?(schema_name)
+      unless self.known_schemas.include?(schema_name)
+        raise ArgumentError, "Schema #{schema_name} is unknown!"
+      end
+
+      transactions.all? { |t| t.schema_compatible?(schema_name) }
+    end
+
+    # Set unique identifer for the message
+    def message_identification=(value)
+      unless value.is_a?(String)
+        raise ArgumentError, 'mesage_identification must be a string!'
+      end
+
+      regex = /\A([A-Za-z0-9]|[\+|\?|\/|\-|\:|\(|\)|\.|\,|\'|\ ]){1,35}\z/
+      unless value.match(regex)
+        raise ArgumentError, "mesage_identification does not match #{regex}!"
+      end
+
+      @message_identification = value
+    end
+
+    # Get unique identifer for the message (with fallback to a random string)
+    def message_identification
+      @message_identification ||= "WIRE/#{SecureRandom.hex(5)}"
+    end
+
+    # Returns the id of the batch to which the given transaction belongs
+    # Identified based upon the reference of the transaction
+    def batch_id(transaction_reference)
+      grouped_transactions.each do |group, transactions|
+        selected_transactions = begin
+          transactions.select do |transaction|
+            transaction.reference == transaction_reference
+          end
+        end
+        if selected_transactions.any?
+          return payment_information_identification(group)
+        end
+      end
+    end
+
+    def batches
+      grouped_transactions.keys.collect do |group|
+        payment_information_identification(group)
+      end
+    end
+
+    def error_messages
+      errors.full_messages.join("\n")
+    end
+
+    private
+
+    # @return {Hash<Symbol=>String>} xml schema information used in output xml
+    def xml_schema(schema_name)
+      urn = "urn:iso:std:iso:20022:tech:xsd:#{schema_name}"
+      {
+        :xmlns                => "#{urn}",
+        :'xmlns:xsi'          => 'http://www.w3.org/2001/XMLSchema-instance',
+        :'xsi:schemaLocation' => "#{urn} #{schema_name}.xsd"
+      }
+    end
+
+    def build_group_header(builder)
+      builder.GrpHdr do
+        builder.MsgId(message_identification)
+        builder.CreDtTm(Time.now.iso8601)
+        builder.NbOfTxs(transactions.length)
+        builder.CtrlSum('%.2f' % amount_total)
+        builder.InitgPty do
+          builder.Nm(account.name)
+          builder.Id do
+            builder.OrgId do
+              builder.Othr do
+                builder.Id(account.identifier)
+                builder.SchmeNm do
+                  builder.Cd(account.schema_code)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    # Unique and consecutive identifier (used for the <PmntInf> blocks)
+    def payment_information_identification(group)
+      "#{message_identification}/#{grouped_transactions.keys.index(group) + 1}"
+    end
+
+    # Returns a key to determine the group to which the transaction belongs
+    def transaction_group(transaction)
+      transaction
+    end
+
+    def account_agent_id(builder, account)
+      if account.bic
+        builder.BIC(account.bic)
+      else
+        builder.ClrSysMmbId do
+          builder.ClrSysId do
+            builder.Cd(account.clear_system_code)
+          end
+          builder.MmbId(account.wire_routing_number)
+        end
+      end
+    end
+
+    def account_id(builder, account)
+      if account.iban
+        builder.Id do
+          builder.IBAN(account.iban)
+        end
+      else
+        builder.Id do
+          builder.Othr do
+            builder.Id(account.account_number)
+          end
+        end
+        builder.Tp do
+          builder.Cd('CACC')
+        end
+        builder.Ccy(account.currency)
+      end
+    end
+
+    def transaction_agent_id(builder, transaction)
+      if transaction.bic
+        builder.BIC(transaction.bic)
+      else
+        builder.ClrSysMmbId do
+          builder.ClrSysId do
+            builder.Cd(transaction.clear_system_code)
+          end
+          builder.MmbId(transaction.wire_routing_number)
+        end
+      end
+    end
+
+    def transaction_account_id(builder, transaction)
+      if transaction.iban
+        builder.Id do
+          builder.IBAN(transaction.iban)
+        end
+      else
+        builder.Id do
+          builder.Othr do
+            builder.Id(transaction.account_number)
+          end
+        end
+        builder.Tp do
+          builder.Cd('CACC')
+        end
+      end
+    end
+  end
+end

data/lib/wire_client/providers/base/wire_batch.rb

@@ -0,0 +1,120 @@
+module WireClient
+  # Abstract Wire transfer provider, which all other providers inherit from
+  class Abstract
+
+    # Base class for sending batched Wire transfer transactions to various
+    # providers
+    class WireBatch
+      # An initiator is an entity that initiates the transfer process; it can
+      # be a debtor or a creditor. A receptor, on the other hand, is someone
+      # who will fulfill the transfer, whether receiving or withdrawing the
+      # described amount.
+
+      # @return [String] Debtor's or creditor's name for the one initianting
+      # the transfer
+      class_attribute :initiator_name
+
+      # @return [String] Debtor's or creditor's IBAN (International Bank
+      # Account Number) ID
+      class_attribute :initiator_iban
+
+      # @return [String] Debtor's or creditor's bank SWIFT Code / BIC
+      class_attribute :initiator_bic
+
+      # @return [String] Debtor's or creditor's Account Number
+      class_attribute :initiator_account_number
+
+      # @return [String] Debtor or creditor agent's wire routing number
+      class_attribute :initiator_wire_routing_number
+
+      # @return [String] The initiating party's Identifier
+      class_attribute :initiator_identifier
+
+      # @return [String] The initiating party's country (2 character country
+      # code; default: US)
+      class_attribute :initiator_country
+
+      # @return [String] The initiating party's country subdivision (name or
+      # 2 character code; default: MA)
+      class_attribute :initiator_country_subdivision
+
+      ##
+      # @return [Array] A list of arguments to use in the initializer, and as
+      # instance attributes
+      def self.arguments
+        [
+          :transaction_type
+        ]
+      end
+
+      attr_reader(*arguments)
+
+      ##
+      # @param transaction_type [WireClient::TransactionTypes::TransactionType]
+      # debit or credit
+      def initialize(*arguments)
+        args = arguments.extract_options!
+        self.class.arguments.each do |param|
+          self.instance_variable_set(
+            "@#{param}".to_sym,
+            args[param]
+          )
+        end
+        if @transaction_type == WireClient::TransactionTypes::Credit
+          initialize_payment_initiation(CreditTransfer)
+        elsif @transaction_type == WireClient::TransactionTypes::Debit
+          initialize_payment_initiation(DirectDebit)
+        else
+          raise InvalidWireTransactionTypeError,
+                'Transaction type should be explicitly defined'
+        end
+      end
+
+      def add_transaction(transaction_options)
+        @payment_initiation.add_transaction(transaction_options)
+      end
+
+      ##
+      # Sends the batch to the provider. Useful to check transaction status
+      #   before sending any data (consistency, validation, etc.)
+      def send_batch
+        if @payment_initiation.valid?
+          do_send_batch
+        else
+          raise InvalidWireTransactionError,
+                "invalid wire transfer: #{@payment_initiation.error_messages}"
+        end
+      end
+
+      # Implementation of sending the Wire transfer batch to the provider, to be
+      #   implemented by the subclass
+      def do_send_batch
+        raise AbstractMethodError
+      end
+
+      private
+
+      def initialize_payment_initiation(klass)
+        if self.class.initiator_iban
+          @payment_initiation = klass.new(
+            name: self.class.initiator_name,
+            bic: self.class.initiator_bic,
+            iban: self.class.initiator_iban,
+            identifier: self.class.initiator_identifier,
+            country: self.class.initiator_country,
+            country_subdivision: self.class.initiator_country_subdivision
+          )
+        else
+          @payment_initiation = klass.new(
+            name: self.class.initiator_name,
+            wire_routing_number: self.class.initiator_wire_routing_number,
+            account_number: self.class.initiator_account_number,
+            identifier: self.class.initiator_identifier,
+            country: self.class.initiator_country,
+            country_subdivision: self.class.initiator_country_subdivision
+          )
+        end
+      end
+    end
+  end
+end

data/lib/wire_client/providers/sftp/sftp_provider.rb

@@ -0,0 +1,39 @@
+module WireClient
+  # Base concern for providers like SVB that use an SFTP system instead of API
+  module SftpProvider
+    extend ActiveSupport::Concern
+    include AchClient::SftpProvider
+
+    included do
+      # @return [String] Hostname/URL of SVB's "Direct File Transmission" server
+      class_attribute :host
+
+      # @return [String] The username they gave you to login to the server
+      class_attribute :username
+
+      # @return [String] The password they gave you to login to the server
+      class_attribute :password
+
+      # @return [String] The private ssh key that matches the public ssh key you
+      # provided to SVB, ie the output of `cat path/to/private/ssh/key`
+      class_attribute :private_ssh_key
+
+      # @return [String | NilClass] Passphrase for your private ssh key
+      # (if applicable)
+      class_attribute :passphrase
+
+      # @return [String] The path on the remote server to the directory where
+      # you will deposit your outgoing NACHA files
+      class_attribute :outgoing_path
+
+      # @return [String] The path on the remote server to the directory where
+      # the SFTP provider will deposit return/confirmation files
+      class_attribute :incoming_path
+
+      # @return [Proc] A function that defines the filenaming strategy for your
+      # provider. The function should take an optional batch number and return
+      # a filename string
+      class_attribute :file_naming_strategy
+    end
+  end
+end

data/lib/wire_client/providers/sftp/wire_batch.rb

@@ -0,0 +1,39 @@
+module WireClient
+  # Namespace for all things Sftp
+  class Sftp
+    # NACHA representation of an AchBatch
+    class WireBatch < WireClient::Abstract::WireBatch
+
+      def initialize(transaction_type:, batch_number: nil)
+        super(transaction_type: transaction_type)
+        @batch_number = batch_number
+      end
+
+      # The filename used for the batch
+      # @return [String] filename to use
+      def batch_file_name
+        self.class.parent.file_naming_strategy.(@batch_number)
+      end
+
+      # Sends the batch to SFTP provider
+      def do_send_batch
+        file_path = File.join(
+          self.class.parent.outgoing_path,
+          batch_file_name
+        )
+        file_body = begin
+          if @transaction_type == WireClient::TransactionTypes::Credit
+            @payment_initiation.to_xml('pain.001.001.03').to_s
+          else
+            @payment_initiation.to_xml('pain.008.001.02').to_s
+          end
+        end
+        self.class.parent.write_remote_file(
+          file_path: file_path,
+          file_body: file_body
+        )
+        [file_path, file_body]
+      end
+    end
+  end
+end

data/lib/wire_client/transaction/credit_transfer_transaction.rb

@@ -0,0 +1,20 @@
+require_relative './transaction'
+
+module WireClient
+  class CreditTransferTransaction < Transaction
+    attr_accessor :service_priority, :service_level
+
+    validates_inclusion_of :service_priority, :in => SERVICE_PRIORITY_TYPES
+    validates_inclusion_of :service_level, :in => SERVICE_LEVEL_TYPES
+
+    validate do |t|
+      t.validate_requested_date_after(Time.zone.now.to_date.next)
+    end
+
+    def initialize(attributes = {})
+      super
+      @service_priority ||= 'NORM'
+      @service_level ||= 'URGP'
+    end
+  end
+end

data/lib/wire_client/transaction/direct_debit_transaction.rb

@@ -0,0 +1,49 @@
+require_relative './transaction'
+
+module WireClient
+  class DirectDebitTransaction < Transaction
+
+    attr_accessor :mandate_id,
+                  :mandate_date_of_signature,
+                  :local_instrument,
+                  :sequence_type,
+                  :creditor_account,
+                  :original_debtor_account,
+                  :same_mandate_new_debtor_agent,
+                  :service_priority,
+                  :service_level
+
+    validates_with MandateIdentifierValidator,
+                   field_name: :mandate_id,
+                   message: "%{value} is invalid"
+    validates_presence_of :mandate_date_of_signature
+    validates_inclusion_of :local_instrument, in: LOCAL_INSTRUMENTS
+    validates_inclusion_of :sequence_type, in: SEQUENCE_TYPES
+    validates_inclusion_of :service_priority, :in => SERVICE_PRIORITY_TYPES
+    validates_inclusion_of :service_level, :in => SERVICE_LEVEL_TYPES
+
+    validate do |t|
+      t.validate_requested_date_after(Time.zone.now.to_date.next)
+    end
+
+    validate do |t|
+      if creditor_account && !creditor_account.valid?
+        errors.add(:creditor_account, 'is not correct')
+      end
+
+      if t.mandate_date_of_signature.is_a?(Date)
+        if t.mandate_date_of_signature > Time.zone.now.to_date
+          errors.add(:mandate_date_of_signature, 'is in the future')
+        end
+      else
+        errors.add(:mandate_date_of_signature, 'is not a Date')
+      end
+    end
+
+    def initialize(attributes = {})
+      super
+      @local_instrument ||= 'B2B'
+      @sequence_type ||= 'OOFF'
+    end
+  end
+end