bankserv 0.1.3

data/lib/bankserv/eft.rb

@@ -0,0 +1,83 @@
+module Bankserv
+  module Eft
+    # This module is tightly coupled to the Debit and Credit class.
+    # Any change here will ripple down...
+    attr_accessor :request_id
+    
+    def request(options)
+      Request.create!(options)
+    end
+    
+    def test_request(options)
+      Request.create!(options.merge(test: true))
+    end
+    
+    def build!(options)
+      @request_id = options[:bankserv_request_id]
+      
+      options[:batches].each do |batch|
+        build_batch! batch
+      end
+    end
+    
+    def build_batch!(options)
+      batch_id = next_batch_id
+      if self.partial_class_name == "Debit"
+        build_standard!(batch_id, options[:debit])
+        build_contra!(batch_id, options[:credit])
+      else
+        build_standard!(batch_id, options[:credit])
+        build_contra!(batch_id, options[:debit])
+      end
+    end
+    
+    def partial_class_name
+      self.name.split("::")[-1]
+    end
+    
+    def build_contra!(batch_id, options)
+      ba_options = options.filter_attributes(BankAccount)
+      options = options.filter_attributes(self).merge(bank_account: BankAccount.new(ba_options), record_type: "contra", batch_id: batch_id, bankserv_request_id: @request_id)
+      
+      create!(options)
+    end
+    
+    def build_standard!(batch_id, options)
+      if options.is_a? Array
+        options.each do |debit|
+          create_standard!(batch_id, debit)
+        end
+      else
+        create_standard!(batch_id, options)
+      end
+    end
+    
+    def create_standard!(batch_id, options)
+      ba_options = options.filter_attributes(BankAccount)
+      options = options.filter_attributes(self).merge(bank_account: BankAccount.new(ba_options), record_type: "standard", batch_id: batch_id, bankserv_request_id: @request_id)
+      
+      create!(options)
+    end
+    
+    def next_batch_id
+      maximum('batch_id').nil? ? 1 : maximum('batch_id') + 1
+    end
+    
+    def has_work?
+      unprocessed.select{|item| not item.request.test?}.any?
+    end
+    
+    def has_test_work?
+      unprocessed.select{|item| item.request.test?}.any?
+    end
+    
+    def self.for_reference(reference)
+      Debit.for_reference(reference) + Credit.for_reference(reference)
+    end
+    
+    def self.for_internal_reference(reference)
+      Debit.for_internal_reference(reference) + Credit.for_internal_reference(reference)
+    end
+    
+  end
+end

data/lib/bankserv/engine.rb

@@ -0,0 +1,183 @@
+module Bankserv
+  class Engine
+    
+    attr_accessor :process, :logs, :success
+    
+    def initialize
+      @logs = {
+        reply_files: [],
+        output_files: [],
+        input_files: []
+      }
+      
+      @success = true
+    end
+    
+    def process!
+      self.start!
+      self.process_reply_files
+      self.process_output_files
+      self.process_input_files
+      self.finish!
+      # self.perform_post_checks!
+    end
+    
+    def start!
+      @process = EngineProcess.create!(running: true)
+    end
+        
+    def process_reply_files
+      begin
+        Engine.reply_files.each do |file|
+          @logs[:reply_files] << "Processing #{file}."
+          
+          contents = File.open("#{Bankserv::Engine.output_directory}/#{file}", "rb").read
+          document = Bankserv::ReplyDocument.store(contents)
+          document.process!
+          
+          @logs[:reply_files] << "Processing #{file}. Complete."
+          
+          self.archive_file!("#{Bankserv::Engine.output_directory}/#{file}")
+          @logs[:reply_files] << "#{file} Archived."
+        end
+      rescue Exception => e
+        @logs[:reply_files] << "Error occured! #{e.message}"
+        @success = false
+      end
+    end
+    
+    def process_output_files
+      begin
+        Engine.output_files.each do |file|
+          @logs[:output_files] << "Processing #{file}."
+          
+          contents = File.open("#{Bankserv::Engine.output_directory}/#{file}", "rb").read
+          document = Bankserv::OutputDocument.store(contents)
+          document.process!
+          
+          @logs[:output_files] << "Processing #{file}. Complete."
+          
+          self.archive_file!("#{Bankserv::Engine.output_directory}/#{file}")
+          @logs[:output_files] << "#{file} Archived."
+        end
+      rescue Exception => e
+        @logs[:output_files] << "Error occured! #{e.message}"
+        @success = false
+      end
+    end
+    
+    def process_input_files
+      unless self.expecting_reply_file?
+        begin
+          document = Bankserv::InputDocument.generate!(
+            client_code: Bankserv::Configuration.client_code, 
+            client_name: Bankserv::Configuration.client_name, 
+            th_for_use_of_ld_user: ""
+          )
+          @logs[:input_files] << "Input Document created with id: #{document.id}"
+        rescue Exception => e
+          @logs[:input_files] << "Error occured! #{e.message}"
+          @success = false
+        end
+        
+        if self.write_file!(document)
+          document.mark_processed!
+        end      
+      end
+    end
+    
+    def write_file!(document)
+      begin
+        transmission = Absa::H2h::Transmission::Document.build([document.to_hash])
+        file_name = "INPUT.#{Time.now.strftime('%y%m%d%H%M%S')}.txt"
+        File.open("#{Bankserv::Engine.input_directory}/#{file_name}", 'w') { |f|
+          f.puts transmission
+        }
+        @logs[:input_files] << "Input Document File created. File name: #{file_name}"
+      rescue Exception => e
+        @logs[:input_files] << "Error occured. #{e.message}"
+        return false
+      end
+      
+      true
+    end
+    
+    def archive_file!(file)
+      year, month = Date.today.year, Date.today.month
+      
+      Dir::mkdir("#{Bankserv::Engine.archive_directory}/#{year}") unless File.directory?("#{Bankserv::Engine.archive_directory}/#{year}")
+      Dir::mkdir("#{Bankserv::Engine.archive_directory}/#{year}/#{month}") unless File.directory?("#{Bankserv::Engine.archive_directory}/#{year}/#{month}")
+      FileUtils.mv(file, "#{Bankserv::Engine.archive_directory}/#{year}/#{month}/")
+    end
+    
+    def expecting_reply_file?
+      Bankserv::Document.where(type: 'input', reply_status: nil, processed: true).count > 0
+    end
+    
+    def finish!
+      @process.update_attributes!(running: false, completed_at: Time.now, success: @success, response: @logs)
+    end
+    
+    def running?
+      @process.running?
+    end
+    
+    def self.start
+      return true if self.running?
+
+      if Date.today.business_day?
+        queue = Bankserv::Engine.new
+        queue.process!
+      end
+    end
+    
+    def self.running?
+      EngineProcess.where(running: true).count > 0 
+    end
+    
+    def self.config
+      EngineConfiguration.to_hash
+    end
+    
+    def self.interval
+      config[:interval]
+    end
+    
+    def self.input_directory
+      config[:input_directory]
+    end
+    
+    def self.output_directory
+      config[:output_directory]
+    end
+    
+    def self.archive_directory
+      config[:archive_directory]
+    end
+    
+    def self.interval=(interval)
+      EngineConfiguration.last.update_attributes!(interval_in_minutes: interval)
+    end
+    
+    def self.input_directory=(dir)
+      EngineConfiguration.last.update_attributes!(input_directory: dir)
+    end
+    
+    def self.output_directory=(dir)
+      EngineConfiguration.last.update_attributes!(output_directory: dir)
+    end
+    
+    def self.archive_directory=(dir)
+      EngineConfiguration.last.update_attributes!(archive_directory: dir)
+    end
+    
+    def self.reply_files
+      Dir.entries(output_directory).select {|file| file.upcase.starts_with? "REPLY" }
+    end
+    
+    def self.output_files
+      Dir.entries(output_directory).select {|file| file.upcase.starts_with? "OUTPUT" }
+    end
+    
+  end
+end

data/lib/bankserv/engine/engine_configuration.rb

@@ -0,0 +1,12 @@
+class Bankserv::EngineConfiguration < ActiveRecord::Base
+  
+  def self.to_hash
+    {
+      interval_in_minutes: last.interval_in_minutes,
+      input_directory: last.input_directory,
+      output_directory: last.output_directory,
+      archive_directory: last.archive_directory
+    }
+  end
+  
+end

data/lib/bankserv/engine/engine_process.rb

@@ -0,0 +1,3 @@
+class Bankserv::EngineProcess < ActiveRecord::Base
+  serialize :response
+end

data/lib/bankserv/request.rb

@@ -0,0 +1,27 @@
+module Bankserv
+  
+  class Request < ActiveRecord::Base
+    serialize :data
+    
+    self.inheritance_column = :_type_disabled
+    
+    after_create :delegate!
+    
+    def self.process!
+      self.where(:processed => false).each{|request| request.process!}
+    end
+    
+    def delegate!
+      case type
+      when 'ahv'
+        AccountHolderVerification.build! data.merge(bankserv_request_id: self.id)
+      when 'debit'
+        Debit.build! data.merge(bankserv_request_id: self.id)
+      when 'credit'
+        Credit.build! data.merge(bankserv_request_id: self.id)
+      end
+    end
+  
+  end
+  
+end

data/lib/bankserv/transaction.rb

@@ -0,0 +1,22 @@
+module Bankserv
+  
+  class Transaction < ActiveRecord::Base
+    
+    belongs_to :statement, :foreign_key => 'bankserv_statement_id'
+  
+    serialize :data
+    
+    scope :unprocessed, where(processed: false)
+    
+    def self.for_client_code(client_code)
+      where(client_code: client_code)
+    end
+    
+    def processed!
+      self.processed = true
+      self.save!
+    end
+    
+  end
+  
+end

data/lib/bankserv/transmission/document.rb

@@ -0,0 +1,43 @@
+module Bankserv
+  
+  class Document < ActiveRecord::Base
+    self.inheritance_column = :_type_disabled
+    
+    belongs_to :set
+    serialize :error
+        
+    def mark_processed!
+      self.update_attributes!(processed: true)
+    end
+    
+    def to_hash
+      set.to_hash
+    end
+    
+    def input?
+      type == 'input'
+    end
+    
+    def output?
+      type == 'output'
+    end
+    
+    def reply?
+      type == 'reply'
+    end
+    
+    def sets
+      set.contained_sets
+    end
+    
+    def records # unordered flat array records
+      sets.map(&:records).flatten
+    end
+    
+    def set_with_generation_number(generation_number)
+      sets.select{|set| set.generation_number == generation_number}.first
+    end
+  
+  end
+  
+end

data/lib/bankserv/transmission/input_document.rb

@@ -0,0 +1,84 @@
+class Bankserv::InputDocument < Bankserv::Document
+  
+  def self.document_type
+    'input'
+  end
+  
+  def self.store(string)
+    options = Absa::H2h::Transmission::Document.hash_from_s(string, 'input')
+    
+    raise "Expected a document set" unless options[:type] == "document"
+    
+    document = new(type: 'input', transmission_number: options[:data][0][:data][:transmission_no], transmission_status: options[:data][0][:data][:rec_status])
+    document.set = Bankserv::Set.from_hash(options)
+    document.set.document = document # whaaaaaa?
+    document.save!
+    document      
+  end
+  
+  def self.fetch_next_transmission_number
+    transmission_status = Bankserv::Configuration.live_env? ? "L" : "T"
+    where(type: 'input', reply_status: 'ACCEPTED', transmission_status: transmission_status).maximum(:transmission_number)
+  end
+  
+  def self.sets_with_work
+    defined_input_sets.select(&:has_work?)
+  end
+  
+  def self.sets_with_test_work
+    defined_input_sets.select(&:has_test_work?)
+  end
+  
+  def self.has_work?
+    sets_with_work.any?
+  end
+  
+  def self.has_test_work?
+    sets_with_test_work.any?
+  end
+  
+  def self.generate_test!(options = {})
+    build!(options.merge(rec_status: "T")) if has_test_work?
+  end
+  
+  def self.generate!(options = {})
+    build!(options.merge(rec_status: "L")) if has_work?
+  end
+  
+  def self.build!(options = {}) # move to private      
+    options[:transmission_no] ||= fetch_next_transmission_number
+    
+    transmission_status = Bankserv::Configuration.live_env? ? "L" : "T"
+    
+    document = new(transmission_status: transmission_status, rec_status: options[:rec_status], type: 'input', transmission_number: options[:transmission_no])
+    document.set = Bankserv::Transmission::UserSet::Document.generate(options.merge(rec_status: document.rec_status))
+    document.set.document = document # whaaaaaa?
+    
+    input_sets = if document.rec_status == "L"
+      sets_with_work
+    else
+      sets_with_test_work
+    end
+    
+    input_sets.each do |set| 
+      document.set.sets << set.generate(rec_status: document.rec_status)
+      document.set.sets[-1].set = document.set # whaaaaaa?
+    end
+    
+    document.save!
+    document
+  end
+      
+  def self.defined_input_sets
+    [
+      Bankserv::Transmission::UserSet::AccountHolderVerification, 
+      Bankserv::Transmission::UserSet::Debit,
+      Bankserv::Transmission::UserSet::Credit
+    ]
+  end
+  
+  def self.for_transmission_number(transmission_number)
+    where(type: 'input', transmission_number: transmission_number).first
+  end
+  
+end