ruby-hotfile 0.0.1

data/lib/hotfile/record/BKS24.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+class Hotfile
+  class Record
+    ## Ticket/Document Identification Record
+    class BKS24 < Record
+      def initialize(line)
+        super
+
+        coupon, conjunction, agent_code, issuance_reason, tour, transaction_code, destination, pnr, time, turnaround,
+          reserved =
+          line.scan(/
+            ([A-Z0-9 ]{4})
+            ([A-Z0-9 ]{3})
+            (\d{8})
+            ([A-Z0-9 ])
+            ([A-Z0-9 ]{15})
+            ([A-Z0-9]{4})
+            ([A-Z0-9 ]{10})
+            (.{13})
+            ([\d ]{4})
+            ([A-Z0-9 ]{5})
+            (.{29})
+          /x).flatten
+        time = nil if time.strip == ''
+
+        @data = {
+          transaction_code: transaction_code,
+          time: time&.insert(2, ':'),
+          coupon: coupon.strip,
+          conjunction: conjunction.strip,
+          agent_code: agent_code.to_i,
+          issuance_reason: issuance_reason.strip,
+          tour: tour.strip,
+          destination: destination.strip,
+          pnr: pnr.strip,
+          turnaround: turnaround.strip,
+          reserved: reserved.strip
+        }
+      end
+    end
+  end
+end

data/lib/hotfile/record/BKS30.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+class Hotfile
+  class Record
+    ## STD/Document Amounts Record
+    class BKS30 < Record
+      def initialize(line)
+        super
+
+        commissionable, net_fare, misc1_type, misc1_amount, misc2_type, misc2_amount, misc3_type, misc3_amount, amount,
+            reserved, currency =
+          line.scan(/
+            (\d{10}.)
+            ([\d ]{10}.)
+            ([A-Z0-9 ]{8})
+            ([\d ]{10}.)
+            ([A-Z0-9 ]{8})
+            ([\d ]{10}.)
+            ([A-Z0-9 ]{8})
+            ([\d ]{10}.)
+            (\d{10}.)
+            (.{2})
+            ([A-Z0-9]{4})
+          /x).flatten
+
+        @data = {
+          currency: currency.strip,
+          amounts: {
+            total: Hotfile::Integer.new(amount).to_i,
+            net: Hotfile::Integer.new(net_fare).to_i,
+            commissionable: Hotfile::Integer.new(commissionable).to_i,
+            tax_misc: [
+              { type: misc1_type.strip, amount: Hotfile::Integer.new(misc1_amount).to_i },
+              { type: misc2_type.strip, amount: Hotfile::Integer.new(misc2_amount).to_i },
+              { type: misc3_type.strip, amount: Hotfile::Integer.new(misc3_amount).to_i }
+            ].reject { |x| x[:type] == '' }
+          },
+          reserved: reserved.strip
+        }
+      end
+    end
+  end
+end

data/lib/hotfile/record/BKS31.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+class Hotfile
+  class Record
+    ## Coupon Tax Information Record
+    # ! not tested, I hope this code works at all...
+    class BKS31 < Record
+      def initialize(line)
+        super
+
+        segment1, coupon_airport1, segment_airport1, tax_code1, tax_type1, tax_amount1, tax_currency1, tax_amount_a1,
+            segment2, coupon_airport2, segment_airport2, tax_code2, tax_type2, tax_amount2, tax_currency2,
+            tax_amount_a2, reserved, currency =
+          line.scan(/
+            (\d)
+            ([A-Z ]{5})
+            ([A-Z ]{6})
+            ([A-Z0-9]{2})
+            ([A-Z0-9 ]{3})
+            (\d{10}.)
+            ([A-Z0-9 ]{4})
+            ([\d ]{10}.)
+            (\d)
+            ([A-Z ]{5})
+            ([A-Z ]{6})
+            ([A-Z0-9]{2})
+            ([A-Z0-9 ]{3})
+            (\d{10}.)
+            ([A-Z0-9 ]{4})
+            ([\d ]{10}.)
+            (.{6})
+            ([A-Z0-9]{4})
+          /x).flatten
+
+        @data = {
+          currency: currency.strip,
+          coupons: [
+            {
+              segment: segment1.strip,
+              segment_airport: segment_airport1.strip,
+              coupon_tax: {
+                currency: tax_currency1.strip,
+                airport: coupon_airport1.strip,
+                code: tax_code1.strip,
+                type: tax_type1.strip,
+                amount: Hotfile::Integer.new(tax_amount1).to_i,
+                applicable_amount: Hotfile::Integer.new(tax_amount_a1).to_i
+              }
+            },
+            {
+              segment: segment2.strip,
+              segment_airport: segment_airport2.strip,
+              coupon_tax: {
+                currency: tax_currency2.strip,
+                airport: coupon_airport2.strip,
+                code: tax_code2.strip,
+                type: tax_type2.strip,
+                amount: Hotfile::Integer.new(tax_amount2).to_i,
+                applicable_amount: Hotfile::Integer.new(tax_amount_a2).to_i
+              }
+            }
+          ].reject { |x| x[:segment] == '' },
+          reserved: reserved.strip
+        }
+      end
+    end
+  end
+end

data/lib/hotfile/record/BKS39.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+class Hotfile
+  class Record
+    ## Commission Record
+    class BKS39 < Record
+      def initialize(line)
+        super
+
+        stat_code, type, rate, amount, type2, rate2, amount2, effective_rate, effective_amount, paid, rdi_indicator,
+            cca_indicator, reserved, currency =
+          line.scan(/
+            ([A-Z0-9 ]{3})
+            ([A-Z0-9 ]{6})
+            (\d{5})
+            (\d{10}.)
+            ([A-Z0-9 ]{6})
+            ([\d ]{5})
+            ([\d ]{10}.)
+            (\d{5})
+            (\d{10}.)
+            ([\d ]{10}.)
+            ([A-Z0-9 ])
+            ([A-Z0-9 ])
+            (.{16})
+            ([A-Z0-9]{4})
+          /x).flatten
+
+        @data = {
+          currency: currency.strip,
+          stat_code: stat_code.strip,
+          types: [type.strip, type2.strip].reject { |x| x == '' },
+          rates: [Hotfile::Integer.new(rate).to_i, Hotfile::Integer.new(rate2).to_i].reject(&:zero?),
+          amounts: [Hotfile::Integer.new(amount).to_i, Hotfile::Integer.new(amount2).to_i].reject(&:zero?),
+          effective_rate: Hotfile::Integer.new(effective_rate).to_i,
+          effective_amount: Hotfile::Integer.new(effective_amount).to_i,
+          paid_amount: Hotfile::Integer.new(paid).to_i,
+          rdi_indicator: rdi_indicator.strip,
+          cca_indicator: cca_indicator.strip,
+          reserved: reserved.strip
+        }
+      end
+    end
+  end
+end

data/lib/hotfile/record/BKS42.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+class Hotfile
+  class Record
+    ## Tax on Commission Record
+    # ! not tested, I hope this code works at all...
+    class BKS42 < Record
+      def initialize(line)
+        super
+
+        type1, amount1, type2, amount2, type3, amount3, type4, amount4, reserved, currency =
+          line.scan(/
+            ([A-Z0-9 ]{6})
+            ([\d ]{10}.)
+            ([A-Z0-9 ]{6})
+            ([\d ]{10}.)
+            ([A-Z0-9 ]{6})
+            ([\d ]{10}.)
+            ([A-Z0-9 ]{6})
+            ([\d ]{10}.)
+            (.{24})
+            ([A-Z0-9]{4})
+          /x).flatten
+
+        @data = {
+          currency: currency.strip,
+          taxes: [
+            { type: type1.strip, amount: Hotfile::Integer.new(amount1).to_i },
+            { type: type2.strip, amount: Hotfile::Integer.new(amount2).to_i },
+            { type: type3.strip, amount: Hotfile::Integer.new(amount3).to_i },
+            { type: type4.strip, amount: Hotfile::Integer.new(amount4).to_i }
+          ].reject { |x| x[:type] == '' },
+          reserved: reserved.strip
+        }
+      end
+    end
+  end
+end

data/lib/hotfile/record/BKS45.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class Hotfile
+  class Record
+    ## Related Ticket/Document Information Record
+    # ! not tested, I hope this code works at all...
+    class BKS45 < Record
+      def initialize(line)
+        super
+
+        waiver, reason, identifier, date_of_issue, reserved =
+          line.scan(/
+              (.{14})
+              (.{5})
+              ([\d ]{4})
+              ([\d ]{6})
+              (.{67})
+            /x).flatten
+
+        @data = {
+          waiver: waiver.strip,
+          reason_code: reason.strip,
+          identifier: identifier.strip,
+          date_of_issue: Hotfile::Date.new(date_of_issue).to_date,
+          reserved: reserved.strip
+        }
+      end
+    end
+  end
+end

data/lib/hotfile/record/BKS46.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class Hotfile
+  class Record
+    ## Qualifying Issue Information for Sales Transactions Record
+    class BKS46 < Record
+      def initialize(line)
+        super
+
+        original_doc_nr, original_location, original_date, original_agent_code, e_r, reserved =
+          line.scan(/
+            (.{14})
+            ([A-Z ]{3})
+            ([A-Z0-9 ]{7})
+            ([\d ]{8})
+            (.{49})
+            (.{15})
+          /x).flatten
+
+        @data = {
+          original_issue: {
+            doc_nr: original_doc_nr.strip,
+            location: original_location.strip,
+            date: Hotfile::Date.new(original_date).to_date,
+            agent_code: original_agent_code.to_i
+          },
+          endorsements_restrictions: e_r.strip,
+          reserved: reserved.strip
+        }
+      end
+    end
+  end
+end

data/lib/hotfile/record/BKS47.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+class Hotfile
+  class Record
+    ## Netting Values Record
+    # ! not tested, I hope this code works at all...
+    class BKS47 < Record
+      def initialize(line)
+        super
+
+        type1, code1, amount1, type2, code2, amount2, type3, code3, amount3, type4, code4, amount4, reserved, currency =
+          line.scan(/
+            ([A-Z])
+            ([A-Z0-9 ]{8})
+            (\d{10}.)
+            ([A-Z])
+            ([A-Z0-9 ]{8})
+            (\d{10}.)
+            ([A-Z])
+            ([A-Z0-9 ]{8})
+            (\d{10}.)
+            ([A-Z])
+            ([A-Z0-9 ]{8})
+            (\d{10}.)
+            (.{12})
+            ([A-Z0-9]{4})
+          /x).flatten
+
+        @data = {
+          currency: currency.strip,
+          netting_values: [
+            { type: type1.strip, code: code1.strip, amount: Hotfile::Integer.new(amount1).to_i },
+            { type: type2.strip, code: code2.strip, amount: Hotfile::Integer.new(amount2).to_i },
+            { type: type3.strip, code: code3.strip, amount: Hotfile::Integer.new(amount3).to_i },
+            { type: type4.strip, code: code4.strip, amount: Hotfile::Integer.new(amount4).to_i }
+          ].reject { |x| x[:type] == '' },
+          reserved: reserved.strip
+        }
+      end
+    end
+  end
+end

data/lib/hotfile/record/BKT06.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+class Hotfile
+  class Record
+    ## Transaction Header Record
+    class BKT06 < Record
+      def initialize(line)
+        super
+
+        transaction, net_report, record, airline_code, agreement_ref, file_ref, system_id, auth_code, status,
+            net_report_method, net_report_calc_type, are_indicator, reserved =
+          line.scan(/
+            (\d{6})
+            ([A-Z0-9 ]{2})
+            (\d{3})
+            ([A-Z0-9]{3})
+            ([A-Z0-9 ]{10})
+            ([A-Z0-9 ]{27})
+            ([A-Z0-9]{4})
+            ([A-Z0-9 ]{14})
+            ([A-Z0-9 ])
+            ([A-Z0-9 ])
+            ([A-Z0-9 ])
+            ([A-Z0-9 ])
+            (.{50})
+          /x).flatten
+
+        @data = {
+          transaction: transaction.to_i,
+          net_reporting: {
+            indicator: net_report.strip,
+            method: net_report_method.strip,
+            calc_type: net_report_calc_type.strip
+          },
+          record: record.to_i,
+          airline_code: airline_code,
+          agreement_ref: agreement_ref.strip,
+          file_ref: file_ref.strip,
+          system_id: system_id,
+          auth_code: auth_code.strip,
+          input_status: status.strip,
+          are_indicator: are_indicator.strip,
+          reserved: reserved.strip
+        }
+      end
+    end
+  end
+end

data/lib/hotfile/record/BOH03.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class Hotfile
+  class Record
+    ## (Reporting Agent) Office Header Record
+    class BOH03 < Record
+      def initialize(line)
+        super
+
+        agent_code, remittance_end_date, currency, location_id, reserved =
+          line.scan(/
+            (\d{8})
+            (\d{6})
+            ([A-Z0-9]{4})
+            ([A-Z0-9 ]{3})
+            (.{102})
+          /x).flatten
+
+        @data = {
+          currency: currency.strip,
+          agent_code: agent_code.to_i,
+          remittance_end_date: Hotfile::Date.new(remittance_end_date).to_date,
+          location_id: location_id.strip,
+          reserved: reserved.strip
+        }
+      end
+    end
+  end
+end

data/lib/hotfile/record/BOT93.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+class Hotfile
+  class Record
+    ## Office Subtotals per Transaction Code and Currency Type Record
+    class BOT93 < Record
+      def initialize(line)
+        super
+
+        agent_code, remittance_end_date, gross, remittance, commission, tax, transaction_code, commission_tax, reserved,
+            currency =
+          line.scan(/
+            (\d{8})
+            (\d{6})
+            (\d{14}.)
+            (\d{14}.)
+            (\d{14}.)
+            (\d{14}.)
+            ([A-Z0-9 ]{4})
+            (\d{14}.)
+            (.{26})
+            ([A-Z0-9]{4})
+          /x).flatten
+
+        @data = {
+          currency: currency.strip,
+          transaction_code: transaction_code.strip,
+          agent_code: agent_code.to_i,
+          remittance_end_date: Hotfile::Date.new(remittance_end_date).to_date,
+          gross: Hotfile::Integer.new(gross).to_i,
+          remittance: Hotfile::Integer.new(remittance).to_i,
+          commission: Hotfile::Integer.new(commission).to_i,
+          tax: Hotfile::Integer.new(tax).to_i,
+          commission_tax: Hotfile::Integer.new(commission_tax).to_i,
+          reserved: reserved.strip
+        }
+      end
+    end
+  end
+end

data/lib/hotfile/record/BOT94.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+class Hotfile
+  class Record
+    ## Office Totals per Currency Type Record
+    class BOT94 < Record
+      def initialize(line)
+        super
+
+        agent_code, remittance_end_date, gross, remittance, commission, tax, commission_tax, reserved, currency =
+          line.scan(/
+            (\d{8})
+            (\d{6})
+            (\d{14}.)
+            (\d{14}.)
+            (\d{14}.)
+            (\d{14}.)
+            (\d{14}.)
+            (.{30})
+            ([A-Z0-9]{4})
+          /x).flatten
+
+        @data = {
+          currency: currency.strip,
+          agent_code: agent_code.to_i,
+          remittance_end_date: Hotfile::Date.new(remittance_end_date).to_date,
+          gross: Hotfile::Integer.new(gross).to_i,
+          remittance: Hotfile::Integer.new(remittance).to_i,
+          commission: Hotfile::Integer.new(commission).to_i,
+          tax: Hotfile::Integer.new(tax).to_i,
+          commission_tax: Hotfile::Integer.new(commission_tax).to_i,
+          reserved: reserved.strip
+        }
+      end
+    end
+  end
+end

data/lib/hotfile/record/record.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class Hotfile
+  class Record
+    ## Records parent class
+    class Record
+      def initialize(line)
+        raise 'invalid line' if line.nil? || line.empty?
+      end
+
+      def parse
+        @data
+      end
+    end
+  end
+end

data/lib/hotfile/record.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class Hotfile
+  ## Metaclass for loading all parser modules
+  class Record
+    require 'hotfile/record/record'
+    require 'hotfile/record/BAR64'
+    require 'hotfile/record/BAR65'
+    require 'hotfile/record/BAR66'
+    require 'hotfile/record/BAR67'
+    require 'hotfile/record/BCC82'
+    require 'hotfile/record/BCX83'
+    require 'hotfile/record/BCH02'
+    require 'hotfile/record/BCT95'
+    require 'hotfile/record/BFH01'
+    require 'hotfile/record/BFT99'
+    require 'hotfile/record/BKF81'
+    require 'hotfile/record/BKI61'
+    require 'hotfile/record/BKI62'
+    require 'hotfile/record/BKI63'
+    require 'hotfile/record/BKP84'
+    require 'hotfile/record/BKS24'
+    require 'hotfile/record/BKS30'
+    require 'hotfile/record/BKS31'
+    require 'hotfile/record/BKS39'
+    require 'hotfile/record/BKS42'
+    require 'hotfile/record/BKS45'
+    require 'hotfile/record/BKS46'
+    require 'hotfile/record/BKS47'
+    require 'hotfile/record/BKT06'
+    require 'hotfile/record/BOH03'
+    require 'hotfile/record/BOT93'
+    require 'hotfile/record/BOT94'
+  end
+end

data/lib/hotfile/string.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class Hotfile
+  ## String data type
+  class String
+    def initialize(string)
+      @raw_value = string
+    end
+
+    def to_s
+      @raw_value.strip
+    end
+
+    def to_i
+      Hotfile::Integer.new(@raw_value).to_i
+    end
+  end
+end

data/lib/hotfile/transaction.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+class Hotfile
+  ## Gathers transaction information from parsed data.
+  module Transaction
+    def transactions
+      record_groups = parse[:records].select { |x| x[:transaction].to_i.positive? }.group_by { |x| x[:transaction] }
+      record_groups.each_value.map { |x| summarize_transaction(x) }
+    end
+
+    def summarize_transaction(records)
+      types = records.group_by { |x| x[:code][:number] }
+      {
+        transaction: records.first[:transaction],
+        payment: {
+          total: types[30].map { |x| x[:data][:amounts][:total] }.sum,
+          net: types[30].map { |x| x[:data][:amounts][:net] }.sum,
+          commissionable: types[30].map { |x| x[:data][:amounts][:commissionable] }.sum
+        },
+        flight_schedule: flight_schedule(types[63]),
+        passengers: passengers(types[65]),
+        pnr: find_pnr(types[24])
+      }
+    end
+
+    def flight_schedule(flight_records)
+      flight_records.map do |record|
+        d = record[:data]
+        {
+          carrier: d[:carrier],
+          flight_number: d[:flight_number],
+          departure: d[:departure],
+          arrival: d[:arrival],
+          baggage: d[:baggage],
+          status: d[:booking][:status]
+        }
+      end
+    end
+
+    def passengers(passenger_records)
+      passenger_records.map do |record|
+        full_name = record[:data][:name]
+        surname, first_name = full_name.split('/')
+        gender = first_name.end_with?('MS') || first_name.end_with?('MRS') ? :f : :m
+        first_name = first_name.scan(/(.*)(MS|MR|MRS)$/).flatten.first
+        type = case record[:data][:type]
+                 when 'ADT' then :adult
+                 when 'CHD' then :child
+                 when 'INF' then :infant
+                 else :unknown
+               end
+        {
+          first_name: first_name,
+          surname: surname,
+          gender: gender,
+          info: record[:data][:passenger_data],
+          date_of_birth: record[:data][:date_of_birth],
+          type: type
+        }
+      end
+    end
+
+    def find_pnr(records)
+      records.first&.dig(:data, :pnr)&.split('/')&.first
+    end
+  end
+end

data/lib/hotfile.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+## Main class
+class Hotfile
+  require 'hotfile/date'
+  require 'hotfile/integer'
+  require 'hotfile/string'
+
+  require 'hotfile/parser'
+  require 'hotfile/record'
+  require 'hotfile/transaction'
+
+  include Hotfile::Parser
+  include Hotfile::Transaction
+
+  LINE_LENGTH = 136
+
+  def initialize(file = nil)
+    @file = if file.respond_to? :read
+              file.read
+            elsif file
+              File.read file
+            end
+    @file = @file.delete("\r") if @file
+  end
+
+  def size
+    @file&.size
+  end
+  alias length size
+  alias count size
+
+  def records
+    @file&.lines(chomp: true)&.count
+  end
+  alias lines records
+end

data/lib/ruby-hotfile.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'hotfile'