eancom 0.1.0 → 1.2.0

data/lib/eancom/edifact/body.rb

@@ -0,0 +1,63 @@
+module Eancom
+  module Edifact
+    class Body < DocumentElement
+
+      attr_accessor :hash, :items, :messages
+
+      def initialize
+        super
+        @hash = {}
+        @messages = []
+      end
+
+      def to_json_hash
+        @segments.each do |segment|
+          start_message(segment) if segment.starts_message?
+          start_item(segment) if segment.starts_item?
+          if @item
+            @item << segment
+          else
+            @message << segment
+          end
+        end
+        @message.add_item(@item.to_json_hash)
+        @messages << @message.to_json_hash
+        hash.merge!({ messages: messages })
+        { body: hash }
+      end
+
+      def start_message(segment)
+        if @message
+          @messages << @message.to_json_hash
+          if @item && !@item.empty?
+            @message.add_item(@item.to_json_hash)
+          end
+          @item = nil
+        end
+        @message = Eancom::Edifact::Message.new()
+      end
+
+      def start_item(segment)
+        if @item && !@item.empty?
+          @message.add_item(@item.to_json_hash)
+        end
+        @item = Eancom::Edifact::Item.new()
+      end
+
+      private
+
+      def merge(hash, segment)
+        if name = group_name(segment)
+          hash[name] = [] if hash[name].nil?
+          hash[name] << segment.to_json_hash
+        else
+          hash.merge!(segment.to_json_hash)
+        end
+      end
+
+      def group_name(segment)
+        return segment.group_name
+      end
+    end
+  end
+end

data/lib/eancom/edifact/composite.rb

@@ -0,0 +1,38 @@
+module Eancom
+  module Edifact
+    class Composite
+      class DataTypeError < StandardError; end
+
+      attr_reader :data
+
+      def initialize
+        @data = {}
+      end
+
+      def add(key, value)
+        if value.kind_of?(Data)
+          @data[key] = value
+        else
+          raise DataTypeError.new('Added value is not of type Data.')
+        end
+      end
+
+      def get(key)
+        @data[key]
+      end
+
+      def delete(key)
+        @data.delete(key)
+      end
+
+      def to_array
+        array = []
+        @data.each do |key, value|
+          array << key
+        end
+        array
+      end
+
+    end
+  end
+end

data/lib/eancom/edifact/data.rb

@@ -0,0 +1,108 @@
+module Eancom
+  module Edifact
+    class Data
+      class TypeError < StandardError; end
+      class LengthError < StandardError; end
+      class RequiredError < StandardError; end
+      class NotFoundInDictionary < StandardError; end
+
+      attr_accessor :type, :length, :dictionary, :description, :required
+
+      def initialize(type:,
+                     length:,
+                     dictionary: nil,
+                     description:,
+                     required:
+                    )
+        @type = type
+        @length = length
+        @dictionary = dictionary
+        @description = description
+        @required = required
+      end
+
+      def valid?(key, value)
+        type?(key, value)
+        length?(key, value)
+        required?(key, value)
+        dictionary?(key, value) unless value.empty?
+      end
+
+
+      def identifier(value)
+        if @dictionary
+          hash = @dictionary[value]
+          unless hash
+            raise NotFoundInDictionary.new(
+              "Value not found for #{value}. Error in Data: #{self.to_s}"
+            )
+          else
+            hash[:identifier]
+          end
+        else
+          ""
+        end
+      end
+
+      def to_s
+        "type: #{@type} " \
+        "length: #{@length} " \
+        "dictionary: #{@dictionary} " \
+        "description: #{@description} " \
+        "required: #{required} "
+      end
+
+      private
+
+      def type?(key, value)
+        unless value.kind_of?(@type)
+          raise TypeError.new(
+            "Wrong type of #{key}: #{value}, should be #{@type}. Error in Data: #{self.to_s}"
+          )
+        end
+      end
+
+      def length?(key, value)
+        if @length.kind_of?(Range)
+          unless @length.include?(value.length)
+            raise LengthError.new(
+              "The value #{key}: #{value} is not in the range of #{@length}. Error in Data: #{self.to_s}")
+          end
+        elsif @length.kind_of?(Integer)
+          unless value.length == @length
+            raise LengthError.new(
+              "The length of #{key}: #{value} should be #{@length}. Error in Data: #{self.to_s}"
+            )
+          end
+        else
+          raise LengthError.new(
+            "Error in length definition. Error in Data: #{self.to_s}"
+          )
+        end
+      end
+
+      def required?(key, value)
+        unless (!@required || !value.nil?)
+          raise RequiredError.new(
+            "The field required. Error in #{self.to_s}"
+          )
+        end
+      end
+
+      def dictionary?(key, value)
+        unless @dictionary.nil?
+          unless @dictionary.key?(value)
+            if @dictionary.key?('*') # Bypass Validation
+              return true
+            else
+              raise NotFoundInDictionary.new(
+                "The value '#{key}: #{value}' is not in the dictionary. Error in #{self.to_s}"
+              )
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/eancom/edifact/document.rb

@@ -2,27 +2,59 @@ module Eancom
   module Edifact
     class Document
 
+      attr_accessor :header_element,
+        :body_element, :footer_element
+
       def initialize
-        @envelope = Envelope.new
-        @message = Message.new
+        @header_element = Header.new()
+        @body_element = Body.new()
+        @footer_element = Footer.new()
+      end
+
+      def header(&block)
+        yield(@header_element)
+      end
+
+      def body(&block)
+        yield(@body_element)
+      end
+
+      def footer(&block)
+        yield(@footer_element)
+      end
+
+      def add_to_header(segment)
+        @header_element.segment(segment)
       end
 
-      def envelope(&block)
-        yield(@envelope)
+      def add_to_body(segment)
+        @body_element.segment(segment)
       end
 
-      def message(name, &block)
-        @message.name = name
-        yield(@message)
+      def add_to_footer(segment)
+        @footer_element.segment(segment)
       end
 
-      def to_s
-        stream = ""
-        stream << @envelope.to_s
-        stream << @message.to_s
+      def total_segments
+        total = 0
+        total += @body_element.segments.count
+        total
+      end
+
+      def to_s(debug: false)
+        stream = ''
+        stream << @header_element.to_s(debug: debug)
+        stream << @body_element.to_s(debug: debug)
+        stream << @footer_element.to_s(debug: debug)
         stream
       end
 
+      def to_json
+        hash = {}
+        hash.merge! @header_element.to_json_hash
+        hash.merge! @body_element.to_json_hash
+        hash.to_json
+      end
     end
   end
 end

data/lib/eancom/edifact/document_element.rb

@@ -0,0 +1,26 @@
+module Eancom
+  module Edifact
+
+    class DocumentElement
+
+      attr_accessor :segments
+
+      def initialize
+        @segments = []
+      end
+
+      def segment(segment)
+        segments << segment
+      end
+
+      def to_s(debug: false)
+        stream = ""
+        segments.each do |segment|
+          stream << segment.to_edi
+          stream << "\n" if debug
+        end
+        stream
+      end
+    end
+  end
+end

data/lib/eancom/edifact/footer.rb

@@ -0,0 +1,6 @@
+module Eancom
+  module Edifact
+    class Footer < DocumentElement
+    end
+  end
+end

data/lib/eancom/edifact/header.rb

@@ -0,0 +1,15 @@
+module Eancom
+  module Edifact
+    class Header < DocumentElement
+
+      def to_json_hash
+        hash = {}
+        hash[:header] = {}
+        @segments.each do |segment|
+          hash[:header].merge! segment.to_json_hash
+        end
+        hash
+      end
+    end
+  end
+end

data/lib/eancom/edifact/item.rb

@@ -0,0 +1,40 @@
+module Eancom
+  module Edifact
+    class Item
+
+      attr_accessor :hash
+
+      def initialize()
+        @hash = {}
+      end
+
+      def << (segment)
+        if name = group_name(segment)
+          @hash[name] = [] if @hash[name].nil?
+          @hash[name] << segment.to_json_hash
+        else
+          @hash.merge!(segment.to_json_hash)
+        end
+      end
+
+      def to_json_hash
+        @hash
+      end
+
+      def empty?
+        @hash.empty?
+      end
+
+      private
+
+      def group_name(segment)
+        if segment.item_group_name
+          segment.item_group_name
+        else
+          segment.group_name
+        end
+      end
+
+    end
+  end
+end

data/lib/eancom/edifact/message.rb

@@ -1,31 +1,39 @@
 module Eancom
   module Edifact
-    class Message < Element
+    class Message
+
+      attr_accessor :items, :hash
 
       def initialize()
-        @me = Segment.new
-        @segments = [@me]
+        @items = []
+        @hash = {}
       end
 
-      def add_segment(segment)
-        @segments << segment
+      def add_item(item)
+        @items << item
       end
 
-      def composite(composite)
-        @me.composite(composite)
+      def << (segment)
+        if name = group_name(segment)
+          @hash[name] = [] if @hash[name].nil?
+          @hash[name] << segment.to_json_hash
+        else
+          @hash.merge!(segment.to_json_hash)
+        end
       end
 
-      def name=(name)
-        @me.name = name
+      def to_json_hash
+        message_hash = {}
+        items_hash = { items: @items }
+        message_hash.merge!(@hash)
+        message_hash.merge!(items_hash)
+        message_hash
       end
 
-      def to_s
-        stream = ""
-        @segments.each do |segment|
-          stream << segment.to_s
-          stream << DELIMITERS[:segment]
-        end
-        stream
+      private
+
+      def group_name(segment)
+        segment.group_name
       end
 
     end

data/lib/eancom/edifact/segment.rb

@@ -1,26 +1,145 @@
 module Eancom
   module Edifact
     class Segment
-      attr_accessor :name, :composites
+      attr_accessor :tag
 
-      def initialize(name = "")
-        @name = name
-        @composites = []
+      class SegmentParserError < StandardError; end
+
+      def initialize(tag:)
+        @tag = tag
+        validate_structure
+      end
+
+      def self.initialize_by_components(structure, array)
+        begin
+          new(structure.build_hash(array))
+        rescue StandardError => e
+          raise SegmentParserError.new(
+            "'Parser Error in structure #{structure.tag} with array #{array}.\n \
+            'Inside Structure: \n \ '#{structure.to_s}.\n \
+            'Error:\n \
+            '#{e}"
+          )
+        end
+      end
+
+      def validate_structure
+        attributes.each do |key, value|
+          next if value.nil?
+          structure.validate!(key, value)
+        end
       end
 
-      def composite(content = "")
-        @composites << content
+      def array
+        @array ||= structure.build_array(to_hash)
+      end
+
+      def structure
+        @structure ||= Eancom.find_structure(tag: tag)
       end
 
       def to_s
-        stream = ""
-        stream << name
-        @composites.each do |composite|
-          stream << DELIMITERS[:data]
-          stream << composite
+        string = array.map do |e|
+          e = e.compact
+          next if e.empty?
+          [e.join(component_delimiter)]
+        end.join(data_delimiter)
+        clean_end_string(string)
+        string << segment_delimiter
+        string
+      end
+
+      def to_edi
+        to_s
+      end
+
+      def to_json_hash
+        raise NotImplementedError
+      end
+
+      def segment_type
+        raise NotImplementedError
+      end
+
+      def to_hash
+        attributes
+      end
+
+      def is_header?
+        segment_type == :header
+      end
+
+      def is_body?
+        segment_type == :body
+      end
+
+      def is_footer?
+        segment_type == :footer
+      end
+
+      def tag?(other)
+        tag == other
+      end
+
+      def starts_message?
+        false
+      end
+
+      def starts_item?
+        false
+      end
+
+      def group_name
+        nil
+      end
+
+      def item_group_name
+        nil
+      end
+
+      private
+
+      def data_delimiter
+        DELIMITERS[:data]
+      end
+
+      def component_delimiter
+        DELIMITERS[:component]
+      end
+
+      def segment_delimiter
+        DELIMITERS[:segment]
+      end
+
+      def attributes
+        hash = {}
+        instance_variables.each do |var|
+          key = var.to_s.delete('@').to_sym
+          next if key == :structure
+          next if key == :array
+          value = instance_variable_get(var)
+          hash[key] = value
+        end
+        hash
+      end
+
+      def find_identifier(key)
+        dictionary = structure.find(key).dictionary
+        var = instance_variable_get('@' + key.to_s)
+        if dictionary[var]
+          dictionary[var][:identifier]
+        else
+          var
+        end
+      end
+
+      def clean_end_string(string)
+        while (string[-1] == data_delimiter)
+          string.chop!
         end
-        stream
+        string
       end
+
     end
   end
 end

data/lib/eancom/edifact/segments/alc.rb

@@ -0,0 +1,61 @@
+module Eancom
+  module Edifact
+    class ALC < Segment
+      TAG = 'ALC'.freeze
+      TYPE = :body.freeze
+
+      attr_reader :segment_type
+
+      def initialize(
+        tag: nil,
+        allowance_or_charge_code_qualifier:,
+        allowance_or_charge_identifier: nil,
+        allowance_or_charge_identification_code: nil,
+        settlement_mean_code: nil,
+        calculation_sequence_code: nil,
+        special_service_description_code: nil,
+        code_list_identification_code: nil,
+        code_list_responsible_agency_code: nil,
+        special_service_description_1: nil,
+        special_service_description_2: nil
+      )
+        @tag = tag
+        @allowance_or_charge_code_qualifier = allowance_or_charge_code_qualifier
+        @allowance_or_charge_identifier = allowance_or_charge_identifier
+        @allowance_or_charge_identification_code = allowance_or_charge_identification_code
+        @settlement_mean_code = settlement_mean_code
+        @calculation_sequence_code = calculation_sequence_code
+        @special_service_description_code = special_service_description_code
+        @code_list_identification_code = code_list_identification_code
+        @code_list_responsible_agency_code = code_list_responsible_agency_code
+        @special_service_description_1 = special_service_description_1
+        @special_service_description_2 = special_service_description_2
+        super(tag: tag || TAG)
+      end
+
+      def to_json_hash
+        hash = {}
+        hash.merge!(allowance_or_charge_code_qualifier: find_identifier(:allowance_or_charge_code_qualifier)) if @allowance_or_charge_code_qualifier
+        hash.merge!(allowance_or_charge_identifier: @allowance_or_charge_identifier) if @allowance_or_charge_identifier
+        hash.merge!(allowance_or_charge_identification_code: find_identifier(:allowance_or_charge_identification_code)) if @allowance_or_charge_identification_code
+        hash.merge!(settlement_mean_code: find_identifier(:settlement_mean_code)) if @settlement_mean_code
+        hash.merge!(calculation_sequence_code: find_identifier(:calculation_sequence_code)) if @calculation_sequence_code
+        hash.merge!(special_service_description_code: find_identifier(:special_service_description_code)) if @special_service_description_code
+        hash.merge!(code_list_identification_code: @code_list_identification_code) if @code_list_identification_code
+        hash.merge!(code_list_responsible_agency_code: find_identifier(:code_list_responsible_agency_code)) if @code_list_responsible_agency_code
+        hash.merge!(special_service_description_1: @special_service_description_1) if @special_service_description_1
+        hash.merge!(special_service_description_2: @special_service_description_2) if @special_service_description_2
+        hash
+      end
+
+      def group_name
+        'allowances_or_charges'
+      end
+
+      def segment_type
+        TYPE
+      end
+
+    end
+  end
+end

data/lib/eancom/edifact/segments/ali.rb

@@ -0,0 +1,52 @@
+module Eancom
+  module Edifact
+    class ALI < Segment
+      TAG = 'ALI'.freeze
+      TYPE = :body.freeze
+
+      attr_reader :segment_type
+
+      def initialize(
+        tag: nil,
+        country_of_origin_name_code: nil,
+        duty_regime_type_code: nil,
+        special_condition_code_1: nil,
+        special_condition_code_2: nil,
+        special_condition_code_3: nil,
+        special_condition_code_4: nil,
+        special_condition_code_5: nil
+      )
+        @tag = tag
+        @country_of_origin_name_code = country_of_origin_name_code
+        @duty_regime_type_code = duty_regime_type_code
+        @special_condition_code_1 = special_condition_code_1
+        @special_condition_code_2 = special_condition_code_2
+        @special_condition_code_3 = special_condition_code_3
+        @special_condition_code_4 = special_condition_code_4
+        @special_condition_code_5 = special_condition_code_5
+
+        super(tag: tag || TAG)
+      end
+
+      def to_json_hash
+        hash = {}
+        hash.merge!(country_of_origin_name_code: @country_of_origin_name_code) if @country_of_origin_name_code
+        hash.merge!(duty_regime_type_code: @duty_regime_type_code) if @duty_regime_type_code
+        hash.merge!(special_condition_code_1: find_identifier(:special_condition_code_1)) if @special_condition_code_1
+        hash.merge!(special_condition_code_2: find_identifier(:special_condition_code_2)) if @special_condition_code_2
+        hash.merge!(special_condition_code_3: find_identifier(:special_condition_code_3)) if @special_condition_code_3
+        hash.merge!(special_condition_code_4: find_identifier(:special_condition_code_4)) if @special_condition_code_4
+        hash.merge!(special_condition_code_5: find_identifier(:special_condition_code_5)) if @special_condition_code_5
+        outer_hash = {}
+        outer_hash.merge!(additional_information: hash )
+        outer_hash
+      end
+
+      def segment_type
+        TYPE
+      end
+
+
+    end
+  end
+end