ez7gen 1.0.1

data/lib/ez7gen/service/segment_generator.rb

@@ -0,0 +1,218 @@
+require 'ruby-hl7'
+require 'date'
+require 'benchmark'
+
+# require_relative 'type_aware_field_generator'
+require_relative '../../../lib/ez7gen/structure_parser'
+require_relative 'utils'
+
+class SegmentGenerator
+  include Utils
+
+  @@maxReps = 2
+  @@random = Random.new
+  @@BASE_VER={'2.4'=>'2.4','vaz2.4'=>'2.4'}
+  @@SET_ID_PIECE = 1
+
+
+  # TODO: do I need accessors for version and event? refactor.
+  attr_accessor :version; :event;
+
+  # constructor
+  def initialize(version, event, pp)
+    @version = version
+    @event = event
+
+    #If there are multiple profile parsers, instantiate a generators for each
+    @fieldGenerators = {}
+    pp.each{|profileName, parser|
+      # helper parser for lookup in the other schema
+      # when generating segments for custom (not base) ex VAZ2.4 the field generator will have to look in both schemas
+      # to resolve types and coded tables value.
+      # we will assign the other schema parser as a helper parser
+      helper_parser = pp.select{|key, value| key != profileName}
+      helper_parser = (helper_parser.empty?) ? nil: helper_parser.values.first
+
+      # starting with 2.5 use schema and version specific type generator.
+      @fieldGenerators[profileName] = get_field_generator(parser, helper_parser)
+    }
+    # p @fieldGenerators
+  end
+
+  def get_field_generator(parser, helper_parser)
+    gen = nil
+    begin
+      require_relative "../../ez7gen/service/#{version}/field_generator"
+      gen = FieldGenerator.new( parser, helper_parser)
+    rescue => e
+      # p e
+      $log.error("#{self.class.to_s}:#{__method__.to_s}") { e.message }
+      # @fieldGenerators[profileName] = TypeAwareFieldGenerator.new( parser, helper_parser)
+    end
+    return gen
+  end
+
+  # initialize msh segment
+  def init_msh
+    # create a MSH segment
+    msh = HL7::Message::Segment::MSH.new
+
+    #pick a field generator
+    fieldGenerator = @fieldGenerators['primary']
+
+    msh.enc_chars ='^~\&'
+    # msh.sending_app = fieldGenerator.HD({:codetable =>'361', :required =>'R'})
+    msh.sending_app = fieldGenerator.dt('HD',{:codetable =>'361', :required =>'R'})
+    # msh.sending_facility = fieldGenerator.HD({:codetable => '362', :required =>'R'})
+    msh.sending_facility = fieldGenerator.dt('HD',{:codetable => '362', :required =>'R'})
+    msh.recv_app = fieldGenerator.dt('HD',{:codetable => '361', :required =>'R'})
+    msh.recv_facility = fieldGenerator.dt('HD',{:codetable => '362', :required =>'R'})
+    msh.processing_id = 'P'#@fieldGenerators['primary'].ID({},true)
+    #Per Galina, set version to 2.4 for all of vaz
+    # msh.version_id = @@BASE_VER[@version]
+    msh.version_id = @version
+    msh.security = fieldGenerator.dt('ID',{:required =>'O'})
+
+    # Per Galina's requirement, fix for validation failure.
+    # MSH.9.3 needs to be populated with the correct Message Structure values for those messages
+    # that are the “copies” of the “original” messages.
+    structType = fieldGenerator.pp.get_message_structure(@event)
+    msh.message_type = @event.sub('_','^')<<'^'<<structType
+
+    msh.time =  DateTime.now.strftime('%Y%m%d%H%M%S.%L')
+    msh.message_control_id = fieldGenerator.dt('ID',{:required =>'R'})
+    msh.seq = fieldGenerator.dt('ID',{:required=>'O'})
+    msh.continue_ptr = fieldGenerator.dt('ID',{:required=>'O'})
+    msh.accept_ack_type = fieldGenerator.dt('ID',{:required=>'R', :codetable=>'155'})
+    msh.app_ack_type = fieldGenerator.dt('ID',{:required=>'R', :codetable=>'155'})
+    msh.country_code = fieldGenerator.dt('ID',{:required=>'R', :codetable=>'399'})
+    # msh.charset = @fieldGenerators['primary'].ID({:required=>'R', :codetable=>'211'})
+    msh.charset = 'ASCII' # default value from codetable, change causes problems in validating messages in Ensemble
+    #Table 296 Primary Language has no suggested values.  The field will be populated with values from the Primary Language table in the properties file. Example value: EN^English
+    msh.principal_language_of_message ='EN^English'
+    msh.alternate_character_set_handling_scheme = fieldGenerator.dt('ID',{:required=>'O', :codetable=>'356'})
+    # 21	Conformance Statement ID
+    msh.e20 =  fieldGenerator.dt('ID',{:required=>'O', :codetable=>'449'})
+
+    return msh
+  end
+
+  # refactoring
+  def generate(message, segment, parsers, isGroup=false)
+    if(segment.kind_of?(Array))
+      # handle group
+      generate_group(message, segment, parsers)
+    else
+      # build_segment
+      choiceParser = parsers[get_type_by_name(segment)]
+      attributes = choiceParser.get_segment_structure(get_name_without_base(segment))
+      generate_segment_in_context(message, segment, attributes, isGroup)
+
+    end
+  end
+
+  # generate a group of segments in test message segment using metadata
+  def generate_group( message,  group,  parsers)
+    # generate each segment in the group
+    totalReps = (group.instance_of?(RepeatingGroup))? (1..@@maxReps).to_a.sample: 1
+    totalReps.times do |i|
+      group.each{|seg| generate(message, seg, parsers, true) }
+    end
+
+    return message
+  end
+
+  # end
+
+  # generate test message segment using metadata
+  def generate_segment_in_context(message, segment, attributes, isGroup=false)
+    isRep = is_segment_repeating?(segment)
+    segmentName = get_segment_name(segment)
+
+    # decide if segment needs to repeat and how many times
+    # totalReps = (isRep)? @@random.rand(1.. @@maxReps) : 1 # between 1 and maxReps
+    totalReps = (isRep)? (1..@@maxReps).to_a.sample: 1
+
+    totalReps.times do |i|
+      # seg = (isRep)?message."get$segmentName"(i) :message."get$segmentName"()
+      #groupId = (totalReps>1)?i+1 :((isGroup)?1:nil)
+      sharedGroupId = (isGroup)? i+1: nil
+      message << generate_segment(segmentName, attributes, sharedGroupId)
+    end
+
+    return message
+  end
+
+
+  # #generate_segment_in_context test message using
+  # def generateSegmentFields( segment, attributes)
+  #   segmentName = Utils.get_segment_name(segment)
+  #   generate_segment(segmentName, attributes)
+  # end
+
+  def is_segment_repeating?(segment)
+    segment.include?("~{")
+  end
+
+  # generate a segment using Ensemble schema
+  def generate_segment(segmentName, attributes, idx=nil)
+    elements = generate_segment_elements(segmentName, attributes)
+    # overrite ids for sequential repeating segments
+    elements[@@SET_ID_PIECE] = handle_set_id(segmentName, attributes, idx) || elements[@@SET_ID_PIECE]
+
+    #generate segment using elements
+    HL7::Message::Segment::Default.new(elements)
+  end
+
+  def handle_set_id( segmentName, attributes, idx)
+
+    #set-id field sometimes set to specific non numeric value, keep it, otherwise override if needed
+    is_from_codetable = attributes.find { |p| p[:piece] == @@SET_ID_PIECE.to_s }[:codetable]
+    if(!is_from_codetable) # ignore any value that generated using codetable
+      #Set ID field in PID.1, AL1.1, DG1.1 etc. should have number 1 for the first occurrence of the segment.
+      (idx) ? idx.to_s : (['PID', 'AL1', 'DG1'].include?(segmentName))? '1' :nil
+    else
+      nil
+    end
+
+  end
+
+  # use attributes to generate contents of a specific segment
+  def generate_segment_elements(segmentName, attributes)
+
+    fields =[]
+    total = attributes.size()
+    # type = get_type_by_name(segmentName)
+    # generate segment attributes
+    total.times do |i|
+      fields << add_field(attributes[i])
+    end
+
+    # add segment name to the beginning of the array
+    fields.unshift(get_name_without_base(segmentName))
+  end
+
+  #adds a generated field based on data type
+  def add_field(attributes)
+
+    type = get_type_by_name(attributes[:datatype])
+
+    if(blank?(type)) #safe handle missing data typetype
+      attributes[:datatype] = 'ID'
+      type = get_type_by_name(attributes[:datatype])
+    end
+
+    fieldGenerator= @fieldGenerators[type]
+    data_type = get_name_without_base(attributes[:datatype])
+
+    # puts Utils.blank?(dt)?'~~~~~~~~~> data type is missing': dt
+    if(['CK'].include?(data_type))
+      return nil
+    else
+      # fld = blank?(dt)?nil :fieldGenerator.method(dt).call(attributes)
+      fld = blank?(data_type)?nil :fieldGenerator.dt(data_type, attributes)
+    end
+
+  end
+
+end

data/lib/ez7gen/service/segment_picker.rb

@@ -0,0 +1,147 @@
+require_relative 'utils'
+require_relative '../../ez7gen/structure_parser'
+
+class SegmentPicker
+  include Utils
+
+  attr_accessor :encodedSegments
+  attr_accessor :profile
+
+  # load 50 percent of optional segments
+  @@LOAD_FACTOR = 0.5
+  @@MSH_SEGMENTS = ['MSH', "#{BASE_INDICATOR}MSH"]
+  #@@MSH_SEGMENTS = ['MSH', "base:MSH"]
+
+  @@random = Random.new
+
+  def initialize(profile, encodedSegments, loadFactor=nil)
+    @profile = profile
+    @encodedSegments = encodedSegments
+    #refactoring
+    @candidates =[]
+
+    @loadFactor = loadFactor
+    @loadFactor||=@@LOAD_FACTOR # set to default if not specified or set to nil
+  end
+
+  #refactoring
+  # Get list of segments for test message generation.
+  # MSH is populated with quick generation, skip it here.
+  def pick_segments_to_build()
+    idxs = pick_segment_idx_to_build
+    segmentCandidates = build_segments_for_indexes(idxs)
+    return segmentCandidates - @@MSH_SEGMENTS
+  end
+
+  # Turn indexes to segments
+  def build_segments_for_indexes(idxs)
+    idxs.map do |it|
+      if(is_number?(@profile[it]))
+          idx = @profile[it].to_i
+          @encodedSegments[idx]
+        else
+          @profile[it]
+      end
+    end
+  end
+
+  def pick_segment_idx_to_build
+    reqIdxs= get_required_segment_idxs()
+    #profile indexes - reqired = optional?
+    optIdxs = get_optional_segment_idxs(reqIdxs)
+    (reqIdxs+optIdxs).sort.uniq
+  end
+
+  def get_optional_segment_idxs(regiredIdxs)
+    # range of indexes
+    allIdxs = (0...@profile.size).to_a
+    optIdxs = allIdxs- regiredIdxs
+    count = get_load_candidates_count(optIdxs.size())
+    optIdxs.sample(count)
+  end
+
+  # get segments that will always be build, include z segments
+  def get_required_segment_idxs()
+    # profile already has all required segments identified
+    rs = @profile.each_index.select{|it| is_required1?(@profile[it])}
+    # promote z segments to required, and add them as required, keeping their index
+    zs = @profile.each_index.select{|it| is_z1?(@profile[it])}
+    # return indexes
+    (rs+zs).sort.uniq
+  end
+
+  #end refactoring
+
+  # get segments that will always be build, include z segments
+  def get_required_segments()
+    # profile already has all required segments identified
+    # promote z segments to required, and add them as required, keeping their index
+    zs = @encodedSegments.select{|it| is_z?(it)}
+
+    #promote z to required, replace it's placeholder in profile with the value of the segment
+    # adjust optional segments, clear the value, but do not delete to preserve the indexes
+    zs.each{|it| idx = @encodedSegments.index(it); @profile[@profile.index(idx)] = it; @encodedSegments[idx] = nil}
+
+    #reset encoded segments
+    @encodedSegments.delete_if{|it| it == nil}
+
+    # Make a copy of profile and set to nil all optional segments, indexes into encoded segments array
+    # required = []
+    # @profile.each{|it| required << Utils.num_to_nil(it)}
+    #
+    return @profile.select{|it| is_required?(it)}
+  end
+
+  # calculate number of segments based on load factor
+  def get_load_candidates_count(total)
+    (total*@loadFactor).ceil     #round it up
+  end
+
+  # check is segment is required
+  def is_required1?(encoded)
+    check = false
+    #segment not encoded
+    if(!is_number?(encoded))
+      check = true
+    else
+      # look at encoded segment for the index
+      seg = @encodedSegments[encoded.to_i]
+      # Required segments left not encoded as strings, optional and groups encoded - indexes of encoded segments
+      if(seg.instance_of?(RepeatingGroup))
+        check = true
+      elsif(seg.instance_of?(String))
+        check = (seg[0] == '{' ) # signifies repeating segment
+      end
+    end
+
+    return check
+   end
+
+  def is_required?(encoded)
+  # Required segments left not encoded as strings, optional and groups encoded as numbers
+    !is_number?(encoded)
+  end
+
+
+  def is_z?(segment)
+    segment=~/\~Z/
+  end
+
+  #refactoring
+  def is_z1?(encoded)
+  segment = ''
+    if(is_number?(encoded))
+        # look at encoded segment for the index
+        segment = @encodedSegments[encoded.to_i]
+        #if segment happen to be a group, flatten it into string
+        if(segment.kind_of?(Array))
+          segment = segment.flatten().to_s
+        end
+    else
+      #segment was not encoded to an index, use it as is
+      segment = encoded
+    end
+
+     (segment =~ /\~Z/)? true: false
+  end
+end

data/lib/ez7gen/service/template_generator.rb

@@ -0,0 +1,213 @@
+require_relative 'type_aware_field_generator.rb'
+require_relative 'utils'
+
+class TemplateGenerator
+  include Utils
+  #TODO: refactor in one place
+  @@HAT = '^' # Component separator, aka hat
+  @@SUB ='&' # Subcomponent separator
+
+  # xml tags used in MWB schemas
+  DATAVALUES = 'DataValues'
+  COMPONENT = 'Component'
+  SUBCOMPONENT = 'SubComponent'
+
+  # use xml tags as symbols for name of collections
+  COMP = COMPONENT.downcase.intern
+  SUB = SUBCOMPONENT.downcase.intern
+
+  # list of usages to be picked up, other ignored
+  # @@USAGES = ['R','RE']
+  USAGES_REQ = ['R']
+  USAGES_OPT = ['RE']
+
+  # initialise template generator with the path to template xml (MWB) and parcers
+  def initialize(tempalte_path, pp)
+
+    # parse template  TODO: refactor if not needed on class level move to 'build_template_metadata'
+    text = File.path(tempalte_path)
+    @xml = Ox.parse(IO.read(text))
+
+    #If there are multiple profile parsers, instantiate a generators for each
+    @fieldGenerators = {}
+    # helper parser for lookup in the other schema
+    # when generating segments for custom (not base) ex VAZ2.4 the field generator will have to look in both schemas
+    # to resolve types and coded tables value.
+    # we will assign the other schema parser as a helper parser
+
+    pp.each{|profileName, parser|
+      helper_parser = pp.select{|key, value| key != profileName }
+      helper_parser = (helper_parser.empty?) ? nil: helper_parser.values.first
+      # a = TypeAwareFieldGenerator.new( parser, helper_parser)
+      #@fieldGenerators[profileName] = a
+      @fieldGenerators[profileName] = TypeAwareFieldGenerator.new( parser, helper_parser)
+    }
+
+  end
+
+  # build hl7 message using template as guideline
+  # def generate(message, template, parsers, isGroup=false)
+  def generate(message, useExVal)
+    # read MWB xml file into collection of metadata for each segment
+    metadata = build_metadata(useExVal)
+
+    # segment names
+    segments = metadata.keys
+
+    # add each segment to message using template metadata
+    segments.each{|segName|
+      meta = metadata[segName]
+      processed = process_partials(meta)
+      message << generate_segment(segName, processed)
+    }
+
+    return message
+  end
+
+  # generate a segment using Ensemble schema
+  def generate_segment(segmentName, attributes, idx=nil)
+    # elements = generate_segment_elements(segmentName, attributes)
+    attributes.unshift(get_name_without_base(segmentName))
+    # elements = generate_segment_elements(segmentName, attributes)
+    # overrite ids for sequential repeating segments
+    # elements[@@SET_ID_PIECE] = handle_set_id(segmentName, attributes, idx) || elements[@@SET_ID_PIECE]
+
+    #generate segment using elements
+    if(segmentName == 'MSH')
+      attributes.slice!(1)
+      # one = two.first + two.last
+      # attributes.insert(1,one)
+    end
+    return HL7::Message::Segment::Default.new(attributes)
+  end
+
+  # working with template hash brake field metadata to components and then to subcomponents
+  def process_partials(item)
+    partials = []
+
+    # process each sub type
+    if(item.kind_of? Array)
+
+      item.each{|subType| # at this level we have components or subcomponents
+        coll = subType[SUB] || subType # if subcomponents found process again
+        unit = process_partials(coll)
+        flag = (subType[SUB]) ? @@SUB : @@HAT
+        partials[subType[:Pos].to_i] = unit.join(flag)
+      }
+
+    else
+      # check for components first and then subcomponents
+      coll = item[COMP] || item[SUB]
+      if(coll)
+        partials << process_partials(coll)
+      else
+        partials << build_partial_field_data(item)
+      end
+    end
+
+    return partials
+
+  end
+
+  # convert
+  def build_partial_field_data(item)
+    # use the Example Value 'ExValue' defined in the xml file instead
+    if(item[:ExValue]) then return item[:ExValue] end
+
+    # convert attributes from MWB into Ensemble and use the
+    attrs = {}
+    # strip leading zeros from table name, MWB format.
+    if (item[:Table]) then attrs[:codetable]= item[:Table].sub(/^0+/, '') end
+    if (item[:Length]) then attrs[:max_length]= item[:Length] end
+    if (item[:Name]) then attrs[:description] = item[:Name] end
+    if (item[:Datatype]) then attrs[:datatype] = item[:Datatype] end
+
+    # return genereated field
+    # use primary field generator, as templates only work for custom schema.
+    @fieldGenerators[PRIMARY].method(attrs[:datatype]).call(attrs, true)
+  end
+
+  # using MWB profiles build collection of message metadata, to use for building a message
+  def build_metadata(useExVal)
+    meta = {}
+    segments = []
+
+    # list of segments
+    # In the event of Subgroups of Segments defined in the template, find them and allow
+    # groups only once for simplicity.
+    if( @xml.HL7v2xConformanceProfile.HL7v2xStaticDef.locate('SegGroup')) then
+      nodes = @xml.HL7v2xConformanceProfile.HL7v2xStaticDef.nodes
+
+      nodes.each{|node|
+        if (node.value == "Segment") then
+          segments << node
+        elsif (node.value == "SegGroup")then
+          segments << node.locate('Segment')
+        end
+      }
+      segments.flatten!
+    else
+      segments = @xml.HL7v2xConformanceProfile.HL7v2xStaticDef.locate('Segment')
+      end
+
+    segments.each{|seg|
+
+      fields = []
+      seg.locate('Field').each_with_index { |f,idx |
+        # if (@@USAGES.include?(f.Usage))
+        if use?(f.Usage)
+          f.attributes.merge!(:Pos => idx)
+          fields << get_metadata(f,useExVal)
+        end
+      }
+
+      meta[seg.attributes[:Name]] = fields
+    }
+
+    return meta
+  end
+
+  # parse template xml file into collection
+  def get_metadata(partial, useExVal)
+
+    element = partial.locate(COMPONENT)
+
+    # first look for DataValues example if it's there use it and stop looking any farther.
+    if(useExVal && (element.empty?) && !partial.locate(DATAVALUES).empty?)
+        exVal = partial.locate(DATAVALUES).first.attributes
+        partial.attributes.merge!(exVal)
+        return partial.attributes
+    end
+
+    # continue looking for subcomponents
+    element = (element.empty?) ? partial.locate(SUBCOMPONENT) : element
+    if(!element.empty?)
+        sub = []
+
+        element.each_with_index { |el, idx|
+
+          if (use?(el[:Usage])) # required or optional
+            el.attributes.merge!(:Pos => idx)
+            sub << get_metadata(el, useExVal)
+          end
+
+        }
+
+        if(!sub.empty?)
+          subElementName = (element.first.value.downcase).intern # subcomponent or component
+          partial.attributes[subElementName] = sub
+        end
+
+    end
+
+    return partial.attributes
+
+  end
+
+  def use?(usage)
+    # check for required field/compnent/subcomponent: R
+    # if not toss a coin for optional (required or empty): RE (required or empty)
+    return (USAGES_REQ.include?(usage)) ? true : (USAGES_OPT.include?(usage) && [true,false].sample)
+  end
+
+end