dzero 0.1.1

data/lib/dzero/segments/21_response_status.rb

@@ -0,0 +1,26 @@
+module DZero::Segments
+  class ResponseStatus < Base
+    Base.register_segment(self, identifier: '21')
+
+    def self.field_id_to_symbol
+      super.merge({
+        'AN' => :response_status,
+        'F3' => :authorization_number,
+        'FA' => :reject_count,
+        'FB' => :reject_code,
+        '4F' => :reject_field_occurrence_indicator,
+        '5F' => :approved_message_code_count,
+        '6F' => :approved_message_code,
+        'UF' => :additional_message_information_count,
+        'UH' => :additional_message_information_qualifier,
+        'FQ' => :additional_message_information,
+        'UG' => :additional_message_information_continuity,
+        '7F' => :help_desk_phone_number_qualifier,
+        '8F' => :help_desk_phone_number,
+        'K5' => :transaction_reference_number,
+        'A7' => :internal_control_number,
+        'MA' => :url,
+      })
+    end
+  end
+end

data/lib/dzero/segments/22_response_claim.rb

@@ -0,0 +1,19 @@
+module DZero::Segments
+  class ResponseClaim < Base
+    Base.register_segment(self, identifier: '22')
+
+    def self.field_id_to_symbol
+      super.merge({
+        'EM' => :prescription_reference_number_qualifier,
+        'D2' => :prescription_reference_number,
+        '9F' => :preferred_product_count,
+        'AP' => :preferred_product_id_qualifier,
+        'AR' => :preferred_product_id,
+        'AS' => :preferred_product_incentive,
+        'AT' => :preferred_product_cost_share_incentive,
+        'AU' => :preferred_product_description,
+        'N4' => :medicade_icn,
+      })
+    end
+  end
+end

data/lib/dzero/segments/23_response_pricing.rb

@@ -0,0 +1,55 @@
+module DZero::Segments
+  class ResponsePricing < Base
+    Base.register_segment(self, identifier: '23')
+
+    def self.field_id_to_symbol
+      super.merge({
+        'F5' => :gross_amount_due, # :patient_pay_amount
+        'F6' => :ingredient_cost_paid,
+        'F7' => :dispensing_fee_paid,
+        'AV' => :tax_exempt_indicator,
+        'AW' => :flat_sales_tax_amount_paid,
+        'AX' => :percentage_sales_tax_amount_paid,
+        'AY' => :percentage_sales_tax_rate_paid,
+        'AZ' => :percentage_sales_tax_basis_paid,
+        'FL' => :incentive_amount_paid,
+        'J1' => :professional_service_fee_paid,
+        'J2' => :other_amount_paid_count,
+        'J3' => :other_amount_paid_qualifier,
+        'J4' => :other_amount_paid,
+        'J5' => :other_payer_amount_recognized,
+        'F9' => :total_amount_paid,
+        'FM' => :basis_of_reimbursement_determination,
+        'FN' => :amount_attributed_to_sales_tax,
+        'FC' => :accumulated_deductible_amount,
+        'FD' => :remaining_deductible_amount,
+        'FE' => :remaining_benefit_amount,
+        'FH' => :amount_applied_to_periodic_deductible,
+        'FI' => :amount_of_copay,
+        'FK' => :amount_exceeding_periodic_benefit_maximum,
+        'HH' => :basis_of_calculation_dispensing_fee,
+        'HJ' => :basis_of_calculation_copay,
+        'HK' => :basis_of_calculation_flat_sales_tax,
+        'HM' => :basis_of_calculation_percentage_sales_tax,
+        'NZ' => :amount_attributed_to_processor_fee,
+        'EQ' => :patient_sales_tax_amount,
+        '2Y' => :plan_sales_tax_amount,
+        '4U' => :amount_of_coinsurance,
+        '4V' => :basis_of_calculation_coinsurance,
+        'MU' => :benefit_stage_count,
+        'MV' => :benefit_stage_qualifier,
+        'MW' => :benefit_stage_amount,
+        'G3' => :estimated_generic_savings,
+        'UC' => :spending_account_amount_remaining,
+        'UD' => :health_plan_funded_assistance_amount,
+        'UJ' => :amount_attributed_to_provider_network_selection,
+        'UK' => :amount_attributed_to_product_selection_brand_drug,
+        'UM' => :amount_attributed_to_product_selection_non_preferred_formulary_selection,
+        'UN' => :amount_attributed_to_product_selection_brand_non_preferred_formulary_selection,
+        'UP' => :amount_attributed_to_coverage_gap,
+        'U8' => :ingredient_cost_contracted_reimbursable_amount,
+        'U9' => :dispensing_fee_contracted_reimbursable_amount,
+      })
+    end
+  end
+end

data/lib/dzero/segments/24_response_dur_pps.rb

@@ -0,0 +1,20 @@
+module DZero::Segments
+  class ResponseDurPps < Base
+    Base.register_segment(self, identifier: '24')
+
+    def self.field_id_to_symbol
+      super.merge({
+        'J6' => :dur_pps_response_code_counter,
+        'E4' => :reason_for_service_code,
+        'FS' => :clinical_significance_code,
+        'FT' => :other_pharmacy_indicator,
+        'FV' => :quantity_of_previous_fill,
+        'FU' => :previous_date_of_fill,
+        'FW' => :database_indicator,
+        'FX' => :other_prescriber_indicator,
+        'FY' => :dur_free_text_message,
+        'NS' => :dur_additional_text,
+      })
+    end
+  end
+end

data/lib/dzero/segments/25_response_insurance.rb

@@ -0,0 +1,18 @@
+module DZero::Segments
+  class ResponseInsurance < Base
+    Base.register_segment(self, identifier: '25')
+
+    def self.field_id_to_symbol
+      super.merge({
+        'C1' => :group_id,
+        'FO' => :plan_id,
+        '2F' => :network_reimbursement_id,
+        'J7' => :payer_id_qualifier,
+        'J8' => :payer_id,
+        'N5' => :medicaid_id_number,
+        'N6' => :medicaid_agency_number,
+        'C2' => :cardholder_id,
+      })
+    end
+  end
+end

data/lib/dzero/segments/26_response_prior_auth.rb

@@ -0,0 +1,18 @@
+module DZero::Segments
+  class ResponsePriorAuth < Base
+    Base.register_segment(self, identifier: '26')
+
+    def self.field_id_to_symbol
+      super.merge({
+        'PR' => :prior_authorization_processed_date,
+        'PS' => :prior_authorization_effective_date,
+        'PT' => :prior_authorization_expiration_date,
+        'RA' => :prior_authorization_quantity,
+        'RB' => :prior_authorization_dollars_authorized,
+        'PW' => :prior_authorization_number_of_refills_authorized,
+        'PX' => :prior_authorization_quantity_accumulated,
+        'PY' => :prior_authorization_number_assigned,
+      })
+    end
+  end
+end

data/lib/dzero/segments/27_response_insurance_additional_documentation.rb

@@ -0,0 +1,17 @@
+module DZero::Segments
+  class ResponseInsuranceAdditionalDocumentation < Base
+    Base.register_segment(self, identifier: '27')
+
+    def self.field_id_to_symbol
+      super.merge({
+        'UR' => :medicare_part_d_coverage_code,
+        'UQ' => :cms_low_income_cost_sharing_lics_level,
+        'U1' => :contract_number,
+        'FF' => :formulary_id,
+        'U6' => :benefit_id,
+        'US' => :next_medicare_part_d_effective_date,
+        'UT' => :next_medicare_part_d_termination_date,
+      })
+    end
+  end
+end

data/lib/dzero/segments/28_response_coord_of_benefits.rb

@@ -0,0 +1,22 @@
+module DZero::Segments
+  class ResponseCoordOfBenefits < Base
+    Base.register_segment(self, identifier: '28')
+
+    def self.field_id_to_symbol
+      super.merge({
+        'NT' => :other_payer_id_count,
+        '5C' => :other_payer_coverage_type,
+        '6C' => :other_payer_id_qualifier,
+        '7C' => :other_payer_id,
+        'MH' => :other_payer_processor_control_number,
+        'NU' => :other_payer_cardholder_id,
+        'MJ' => :other_payer_group_id,
+        'UV' => :other_payer_person_code,
+        'UB' => :other_payer_help_desk_phone_number,
+        'UW' => :other_payer_patient_relationship_code,
+        'UX' => :other_payer_benefit_effective_date,
+        'UY' => :other_payer_benefit_termination_date,
+      })
+    end
+  end
+end

data/lib/dzero/segments/29_response_patient.rb

@@ -0,0 +1,13 @@
+module DZero::Segments
+  class ResponsePatient < Base
+    Base.register_segment(self, identifier: '29')
+
+    def self.field_id_to_symbol
+      super.merge({
+        'CA' => :patient_first_name,
+        'CB' => :patient_last_name,
+        'C4' => :date_of_birth,
+      })
+    end
+  end
+end

data/lib/dzero/segments/base.rb

@@ -0,0 +1,128 @@
+require_relative './concerns/parser.rb'
+require_relative './concerns/serializer.rb'
+
+module DZero::Segments
+  class Base
+    include Concerns::Parser
+    include Concerns::Serializer
+
+    class << self
+      attr_accessor :segment_id_to_symbol
+      attr_accessor :segment_id_to_klass
+      attr_accessor :segment_identifier
+      attr_accessor :symbol
+
+      def register_segment(klass, identifier:)
+        klass.segment_identifier = identifier
+
+        self.segment_id_to_klass[identifier] = klass
+        self.segment_id_to_symbol[identifier] = klass.symbol
+      end
+
+      def field_id_to_symbol
+        { 'AM' => :segment_identification }
+      end
+
+      def get_field_by_symbol(sym)
+        field_id_to_symbol.invert[sym]
+      end
+
+      def get_symbol_by_field(sym)
+        field_id_to_symbol[sym]
+      end
+
+      def get_klass_by_symbol(sym)
+        identifier = segment_id_to_symbol.invert[sym]
+        get_klass_by_identifier(identifier)
+      end
+
+      def get_klass_by_identifier(identifier)
+        segment_id_to_klass[identifier] || self
+      end
+
+      def build(initial_hash = {})
+        given_identifier = initial_hash[get_field_by_symbol(:segment_identification)]
+        segment_klass    = segment_id_to_klass[given_identifier]
+        if segment_klass
+          segment_klass.new(initial_hash)
+        else
+          self.new(initial_hash)
+        end
+      end
+    end
+
+    self.segment_id_to_symbol = {}
+    self.segment_id_to_klass  = {}
+    self.segment_identifier   = nil
+
+    def self.inherited(klass)
+      super
+      klass.symbol = klass.name.demodulize.underscore.to_sym
+      klass.segment_id_to_symbol = segment_id_to_symbol
+      klass.segment_id_to_klass  = segment_id_to_klass
+    end
+
+    def initialize(initial_hash = {})
+      @hash = {}
+
+      unless self.class.segment_identifier.nil?
+        self[:segment_identification] = self.class.segment_identifier
+      end
+
+      self.merge(initial_hash)
+    end
+
+    attr_reader :hash
+
+    def [](key)
+      if key.is_a?(Symbol)
+        key = self.class.get_field_by_symbol(key)
+      end
+
+      @hash[key]
+    end
+
+    def []=(key, value)
+      if key.is_a?(Symbol)
+        key = self.class.get_field_by_symbol(key)
+      end
+
+      @hash[key] = value
+    end
+
+    def merge(hash = {})
+      hash.each do |key, value|
+        self[key] = value
+      end
+
+      self
+    end
+  end
+end
+
+require_relative './01_patient.rb'
+require_relative './02_pharmacy_provider.rb'
+require_relative './03_prescriber.rb'
+require_relative './04_insurance.rb'
+require_relative './05_coord_of_benefits.rb'
+require_relative './06_workers_comp.rb'
+require_relative './07_claim.rb'
+require_relative './08_dur_pps.rb'
+require_relative './09_coupon.rb'
+require_relative './10_compound.rb'
+require_relative './11_pricing.rb'
+require_relative './12_prior_auth.rb'
+require_relative './13_clinical.rb'
+require_relative './14_additional_documentation.rb'
+require_relative './15_facility.rb'
+require_relative './16_narrative.rb'
+require_relative './20_response_message.rb'
+require_relative './21_response_status.rb'
+require_relative './22_response_claim.rb'
+require_relative './23_response_pricing.rb'
+require_relative './24_response_dur_pps.rb'
+require_relative './25_response_insurance.rb'
+require_relative './26_response_prior_auth.rb'
+require_relative './27_response_insurance_additional_documentation.rb'
+require_relative './28_response_coord_of_benefits.rb'
+require_relative './29_response_patient.rb'

data/lib/dzero/segments/concerns/parser.rb

@@ -0,0 +1,18 @@
+module DZero::Segments::Concerns
+  module Parser
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # parses from a string
+      # @param [String] source
+      def parse(source)
+        elements            = source.split(/[\x1C\x1E\x3\x1D]/).delete_if(&:empty?)
+        segment_hash        = Hash[elements.map {|e| [e[0..1], e[2..-1]]}]
+  
+        self.build(segment_hash)
+      end
+    end
+  end
+end

data/lib/dzero/segments/concerns/serializer.rb

@@ -0,0 +1,20 @@
+module DZero::Segments::Concerns
+  module Serializer
+    # Serializes instance to string
+    # @return [String]
+    def to_s
+      string = hash.to_a.map(&:join).join("\x1c")
+      string = "\x1C" + string + "\x1E"
+    end
+
+    # Returns a hash
+    # @return [Hash]
+    def to_json(options = {})
+      hash.inject({}) do |memo, (key, value)|
+        readable_key = self.class.get_symbol_by_field(key) if options[:readable] == true
+        memo[readable_key || key] = value
+        memo
+      end
+    end
+  end
+end

data/lib/dzero/test_support.rb

@@ -0,0 +1,5 @@
+module DZero
+  module TestSupport
+    FACTORY_PATH = File.expand_path("../../spec/factories", __dir__)
+  end
+end

data/lib/dzero/transmissions/base.rb

@@ -0,0 +1,47 @@
+require_relative './concerns/parser.rb'
+require_relative './concerns/serializer.rb'
+require_relative './concerns/segments_methods.rb'
+
+module DZero::Transmissions
+  class Base
+    include Concerns::SegmentsMethods
+    include Concerns::Serializer
+
+    class << self
+      include Concerns::Parser
+
+      def header_schema
+        raise NotImplementedError
+      end
+    end
+
+    def initialize(
+      header: {},
+      transmission_group: Groups::TransmissionGroup.new,
+      transaction_groups: [],
+      segments: []
+    )
+      @header = header
+      @transmission_group = transmission_group
+      @transaction_groups = transaction_groups
+
+      unless segments.empty?
+        sort_segments(segments)
+      end
+    end
+
+    attr_reader :header, :transmission_group, :transaction_groups
+
+    def to_s
+      string = ::DZero::Utils::FixedWidth.to_fixed_width(header.slice(*self.class.header_schema.keys), self.class.header_schema)
+      string += ::DZero::Constants::SEGMENT_SEPARATOR
+      string += transmission_group.to_s
+      string += transaction_groups.map(&:to_s).join
+      string
+    end
+  end
+end
+
+require_relative './groups/base.rb'
+require_relative './request.rb'
+require_relative './response.rb'

data/lib/dzero/transmissions/concerns/parser.rb

@@ -0,0 +1,23 @@
+module DZero::Transmissions::Concerns
+  module Parser
+    def parse(string)
+      string = string.dup
+      header_length = header_schema.values.reduce(0, :+)
+      header = ::DZero::Utils::FixedWidth.parse_fixed_width(header_schema, string.slice!(0..header_length))
+
+      raw_transaction_groups = string.split(::DZero::Constants::GROUP_SEPARATOR)
+      raw_transmission_group = raw_transaction_groups.shift
+
+      transmission_group = ::DZero::Transmissions::Groups::TransmissionGroup.parse(raw_transmission_group)
+      transaction_groups = raw_transaction_groups.map do |raw_transaction_group|
+        ::DZero::Transmissions::Groups::TransactionGroup.parse(raw_transaction_group)
+      end
+
+      new(
+        header: header,
+        transmission_group: transmission_group,
+        transaction_groups: transaction_groups
+      )
+    end
+  end
+end

data/lib/dzero/transmissions/concerns/segments_methods.rb

@@ -0,0 +1,76 @@
+module DZero::Transmissions::Concerns
+  module SegmentsMethods
+    TRANSMISSION_LEVEL_SEGMENTS = [
+      :patient,
+      :insurance,
+      :response_message,
+      :response_insurance,
+      :response_patient,
+    ]
+
+    TRANSACTION_LEVEL_SEGMENTS = [
+      :pharmacy_provider,
+      :prescriber,
+      :coord_of_benefits,
+      :workers_comp,
+      :claim,
+      :dur_pps,
+      :coupon,
+      :compound,
+      :pricing,
+      :prior_auth,
+      :clinical,
+      :additional_documentation,
+      :facility,
+      :narrative,
+      :response_status,
+      :response_claim,
+      :response_pricing,
+      :response_dur_pps,
+      :response_prior_auth,
+      :response_additional_documentation,
+      :response_coord_of_benefits
+    ]
+
+    def self.included(base)
+      ::DZero::Segments::Base.segment_id_to_symbol.each do |segment_identifier, segment_name_sym|
+        segment_klass = ::DZero::Segments::Base.get_klass_by_identifier(segment_identifier)
+        base.send(:define_method, "#{segment_name_sym}_segment") do
+          get_segment(segment_klass)
+        end
+      end
+    end
+
+    def get_segment(segment_klass)
+      self.transmission_group.segments.detect { |s| s.is_a?(segment_klass) } || 
+      self.transaction_groups.first.segments.detect { |s| s.is_a?(segment_klass) } ||
+      begin
+        segment = segment_klass.new({})
+        self.segments << segment
+        segment
+      end
+    end
+
+    def sort_segments(segments)
+      segments.each do |segment|
+        segment_sym = segment.class.symbol
+        if TRANSMISSION_LEVEL_SEGMENTS.include?(segment_sym)
+          transmission_group.segments << segment
+        else
+          if transaction_groups.empty?
+            transaction_groups << ::DZero::Transmissions::Groups::TransactionGroup.new({ segments: [] })
+          end
+
+          transaction_groups.first.segments << segment
+        end
+      end
+    end
+
+    def segments
+      all = []
+      all += transmission_group.segments
+      all += transaction_groups.map(&:segments).flatten
+      all.compact
+    end
+  end
+end

data/lib/dzero/transmissions/concerns/serializer.rb

@@ -0,0 +1,11 @@
+module DZero::Transmissions::Concerns
+  module Serializer
+    def to_json(options = {})
+      {
+        header: header,
+        transmission_group: transmission_group.to_json(options),
+        transaction_groups: transaction_groups.map { |group| group.to_json(options) }
+      }
+    end
+  end
+end

data/lib/dzero/transmissions/groups/base.rb

@@ -0,0 +1,59 @@
+module DZero::Transmissions::Groups
+  class Base
+    class << self
+      def parse(string)
+        segments = string.split(::DZero::Constants::SEGMENT_SEPARATOR).map do |raw_segment|
+          next if raw_segment.strip == ""
+          ::DZero::Segments::Base.parse(raw_segment)
+        end
+
+        new(
+          segments: segments
+        )
+      end
+    end
+
+    def initialize(segments: [])
+      @segments = segments
+    end
+
+    attr_reader :segments
+
+    def to_s
+      string = ::DZero::Constants::GROUP_SEPARATOR
+      string += ::DZero::Constants::SEGMENT_SEPARATOR
+      string += @segments.map(&:to_s).join
+      # remove the trailing segment separator, if any
+      string.chomp!(::DZero::Constants::SEGMENT_SEPARATOR)
+      string
+    end
+
+    def to_json(options = {})
+      if options[:key_group_by_segment_sym] == true
+        segments.compact.inject({}) { |memo, segment| memo.merge(segment.class.symbol => segment.to_json(options)) }
+      else
+        {
+          segments: segments.map { |segment| segment.to_json(options) }
+        }
+      end
+    end
+
+    def get_segment(segment_klass)
+      self.segments.detect { |s| s.is_a?(segment_klass) } || begin 
+        segment = segment_klass.new({})
+        self.segments << segment
+        segment
+      end
+    end
+
+    ::DZero::Segments::Base.segment_id_to_symbol.each do |segment_identifier, segment_name_sym|
+      segment_klass = ::DZero::Segments::Base.get_klass_by_identifier(segment_identifier)
+      self.send(:define_method, "#{segment_name_sym}_segment") do
+        get_segment(segment_klass)
+      end
+    end
+  end
+end
+
+require_relative './transaction_group.rb'
+require_relative './transmission_group.rb'

data/lib/dzero/transmissions/groups/transaction_group.rb

@@ -0,0 +1,3 @@
+module DZero::Transmissions::Groups
+  class TransactionGroup < Base; end
+end

data/lib/dzero/transmissions/groups/transmission_group.rb

@@ -0,0 +1,11 @@
+module DZero::Transmissions::Groups
+  class TransmissionGroup < Base
+    # transmission level segments are not preceeded by a group separator
+    def to_s
+      string = @segments.map(&:to_s).join
+      # remove the trailing segment separator, if any
+      string.chomp!(::DZero::Constants::SEGMENT_SEPARATOR)
+      string
+    end
+  end
+end

data/lib/dzero/transmissions/request.rb

@@ -0,0 +1,19 @@
+module DZero::Transmissions
+  class Request < Base
+    class << self
+      def header_schema
+        {
+          bin_number: 6,
+          version: 2,
+          transaction_code: 2,
+          processor_control_number: 10,
+          transaction_count: 1,
+          service_provider_id_qualifier: 2,
+          service_provider_id: 15,
+          date_of_service: 8,
+          software: 10
+        }
+      end
+    end
+  end
+end

data/lib/dzero/transmissions/response.rb

@@ -0,0 +1,17 @@
+module DZero::Transmissions
+  class Response < Base
+    class << self
+      def header_schema
+        {
+          version: 2,
+          transaction_code: 2,
+          transaction_count: 1,
+          header_response_status: 1,
+          service_provider_id_qualifier: 2,
+          service_provider_id: 15,
+          date_of_service: 8,
+        }
+      end
+    end
+  end
+end