class Dialect::Lookup

Public Instance Methods

dialectLookup(args,state,viewId,viewType) click to toggle source
# File lib/lookup.rb, line 16
    def dialectLookup(args,state,viewId,viewType)            
      queryName = args[:dialectLookupQuery][:queryName]
      if args[:objects][viewId][:links][args[:dialectLookupQuery][:cClass]].is_a?(Hash)
        args[:objects][viewId][:links][args[:dialectLookupQuery][:cClass]].each do |_conPairId, conProp|
         
          
         if   conProp[:viewID] == viewId and
              conProp[:fClass] =~ /^#{args[:dialectLookupQuery][:fClass]}/ and 
              conProp[:fFqn] =~ /^#{args[:dialectLookupQuery][:fFqn]}/ and
              conProp[:tClass] =~ /^#{args[:dialectLookupQuery][:tClass]}/ and
              conProp[:tFqn] =~ /^#{args[:dialectLookupQuery][:tFqn]}/
           
              

              conProp[:cClass] = args[:dialectLookupQuery][:cClass]
              prop = getProp(args,state,conProp,'from')
              conProp[:fProp] = prop if not prop.nil?
              prop = getProp(args,state,conProp,'to')
              conProp[:tProp] = prop if not prop.nil?
              
              if args[:dialectLookupQuery].has_key?(:fPropKey)
                conProp[:fProp][args[:dialectLookupQuery][:fPropKey]] == args[:dialectLookupQuery][:fPropValue] ? store = true : store = false
              else
                store = true
              end
              
              if store == true    
#                 Dialog.logger.debug "In view #{viewId} by query '#{queryName}' we have a #{args[:dialectLookupQuery][:cClass]} connection: CONNPARID #{conPairId} FROM fClass = #{conProp[:fClass]} fqn = #{conProp[:fFqn]}  fId = #{conProp[:fId]}  NAME #{conProp[:fName]} FPROP #{conProp[:fProp]} [[ TO ]] tClass = #{conProp[:tClass]} fqn = #{conProp[:tFqn]}  tId = #{conProp[:tId]} NAME #{conProp[:tName]} TPROP #{conProp[:tProp]}\n"
                
#                 hash_fName = Digest::SHA256.hexdigest("#{conProp[:fName]}")[0..20]
                hash_tName = Digest::SHA256.hexdigest("#{conProp[:tName]}")[0..20]
                hash_fName_fId_tId = Digest::SHA256.hexdigest("#{conProp[:fName]}#{conProp[:fOID]}#{conProp[:tOID]}")[0..20]              
  #               puts conProp
                args[:stages][state[:dialectFolder]][viewType] ||= {}
                args[:stages][state[:dialectFolder]][viewType][state[:myAppName]] ||= {}
                case viewType
                when :perView
                  args[:stages][state[:dialectFolder]][viewType][state[:myAppName]][viewId] ||= {}
                  args[:stages][state[:dialectFolder]][viewType][state[:myAppName]][viewId][queryName] ||= {}              
                  args[:stages][state[:dialectFolder]][viewType][state[:myAppName]][viewId][queryName][:lookup] ||= {}
                  args[:stages][state[:dialectFolder]][viewType][state[:myAppName]][viewId][queryName][:lookup][hash_tName] ||= {}
                  args[:stages][state[:dialectFolder]][viewType][state[:myAppName]][viewId][queryName][:lookup][hash_tName][hash_fName_fId_tId] = conProp                   
                when :constructors
                  args[:stages][state[:dialectFolder]][viewType][state[:myAppName]] ||= {}
                  args[:stages][state[:dialectFolder]][viewType][state[:myAppName]][queryName] ||= {}              
                  args[:stages][state[:dialectFolder]][viewType][state[:myAppName]][queryName][:lookup] ||= {}
                  args[:stages][state[:dialectFolder]][viewType][state[:myAppName]][queryName][:lookup][hash_tName] ||= {}
                  args[:stages][state[:dialectFolder]][viewType][state[:myAppName]][queryName][:lookup][hash_tName][hash_fName_fId_tId] = conProp                  
                end
              end
                
          end
        end
      end
    end
dialectRepack(args, state, viewId, viewType, queryName) click to toggle source
# File lib/lookup.rb, line 101
def dialectRepack(args, state, viewId, viewType, queryName)
  
  case viewType
  when :perView
    if not args[:stages][state[:dialectFolder]][viewType][state[:myAppName]].nil?
      base = args[:stages][state[:dialectFolder]][viewType][state[:myAppName]][viewId][queryName]          
    else
      base = false
    end
  when :constructors
    base = args[:stages][state[:dialectFolder]][viewType][state[:myAppName]][queryName]          
  end
  if base.is_a?(Hash)
    repackNames = [:fFqn, :tFqn, :fOID, :tOID, :fEID, :tEID]              
    base[:repack] = {}      
    repackNames.each do |repackName|
      res = {}                     
      base[:repack][repackName] ||= {}      
      base[:lookup].each do |_tName, hash_tNameProp|
        hash_tNameProp.each do |_fName, hash_fNameProp|
          res[hash_fNameProp[repackName]] = hash_fNameProp
        end 
      end  
      case viewType          
      when :perView
        args[:stages][state[:dialectFolder]][viewType][state[:myAppName]][viewId][queryName][:repack][repackName] = res      
      when :constructors
        args[:stages][state[:dialectFolder]][viewType][state[:myAppName]][queryName][:repack][repackName] = res
      end          
    end      
  end
end
getObjects(args, state) click to toggle source
# File lib/sql.rb, line 16
def getObjects(args, state)
  args[:views].each do |viewId, viewProps|
    getObjectsFromSQL(args, state, viewId, viewProps)
  end
  args[:con_views].each do |viewId, viewProps|
    getObjectsFromSQL(args, state, viewId, viewProps)
  end      
  return args
end
getObjectsFromSQL(args, state, viewId, _viewProps) click to toggle source
# File lib/sql.rb, line 26
    def getObjectsFromSQL(args, state, viewId, _viewProps)
      
      args[:x] = {}
      viewIdOrig = viewId.to_s.tr("_", "-")
      args[:objects] ||= {}
      args[:objects][viewId] = {}
      rows={}
      links = {}
      i = 1

#  (views_objects.id in ('views_connections'.`source_object_id`) AND views_objects.id not in ('views_connections'.`target_object_id`))
      
      state[:dbhandler].execute( "
        select 
        views_objects.id, 
        elements.id, 
        elements.class,
        relationships.class, 
        elements.name, 
        views_connections.source_object_id, 
        views_connections.target_object_id,
        elements.documentation,
        relationships.version,
        elements.version,
        views_objects.element_version,
        properties.value
                                      
        from views_connections_in_view
        INNER JOIN views_connections ON views_connections_in_view.connection_id = views_connections.id
                                AND views_connections.version = (select max(views_connections.version) from views_connections where views_connections.id = views_connections_in_view.connection_id )
        INNER JOIN relationships ON relationships.id = views_connections.relationship_id 

        INNER JOIN views_objects ON (views_objects.id = views_connections.source_object_id OR  
                                  views_objects.id = views_connections.target_object_id) AND  

                                  views_objects.version = (select max(views_objects.version) from views_objects where (
                                  (views_objects.id in ('views_connections'.`target_object_id`) AND views_objects.id not in ('views_connections'.`source_object_id`))
                                  ))
                               
        INNER JOIN elements ON elements.id = views_objects.element_id AND elements.version = (select max(elements.version) from elements where elements.id in ('views_objects'.`element_id`))
        LEFT JOIN properties ON properties.parent_id = elements.id AND  
                                    properties.parent_version = (select max(properties.parent_version) from properties where properties.parent_id in ('elements'.`id`)) AND
                                    properties.name LIKE 'fqn'
                                      
      
          where views_connections_in_view.view_id like '#{viewIdOrig}' 
          and views_connections_in_view.view_version = (select max(views_connections_in_view.view_version) from views_connections_in_view where views_connections_in_view.view_id like '#{viewIdOrig}')
          and relationships.class in ('AggregationRelationship', 'TriggeringRelationship', 'FlowRelationship', 'AccessRelationship', 'SpecializationRelationship', 'CompositionRelationship', 'ServingRelationship', 'RealizationRelationship') 
          and (elements.class LIKE 'Application%' OR elements.class in ('DataObject', 'Grouping'))
                                      and elements.version = (select max(elements.version) from elements where elements.id in ('views_objects'.`element_id`))

      ")  do |row|
#                 Bot.logger.debug "### ROW ##{i}: #{row}"

#             hash_tName_fId_tId = Digest::SHA256.hexdigest("#{row[0]}_#{row[4]}_#{row[5]}")[0..20]
            hash_tName_fId_tId = Digest::SHA256.hexdigest("#{row[4]}_#{row[5]}")[0..20]                    
            rows[row[0]] ||= {}
            rows[row[0]][:e_id] = row[1]            
            rows[row[0]][:e_class] = row[2]
            rows[row[0]][:o_name]  = row[4]
            rows[row[0]][:e_doc] = row[7]
            rows[row[0]][:e_ver] = row[9]            
            rows[row[0]][:p_fqn]  = row[11]                        

            
            rows[row[0]][row[3]] ||= {}            
            rows[row[0]][row[3]][hash_tName_fId_tId] ||= {}  
            rows[row[0]][row[3]][hash_tName_fId_tId] = {from: row[5], to: row[6] }
            i = i + 1
      end
                    
      i = 1
        rows.each do |_objId, objProps|            
          objProps.each do |objProp, objVal|
            if objProp.to_s =~ /Relationship/
              links[objProp] ||= {}                
              objVal.sort.map do |conPairId, conProps| 
                
                if ! rows[conProps[:from]].nil? and ! rows[conProps[:to]].nil?
                  links[objProp][conPairId] ||= {}
  #                 Bot.logger.debug "### AAA #{i}: #{rows[conProps[:from]] }"
                  links[objProp][conPairId][:connUUID]  = "#{conProps[:from]}#{conProps[:to]}".unpack("H8H4H4H4H12").join('-') 
                  links[objProp][conPairId][:viewID]    = viewId                   
                  links[objProp][conPairId][:fOID]      = conProps[:from].tr("-", "_")
                  links[objProp][conPairId][:fEID]      = rows[conProps[:from]][:e_id].tr("-", "_")
                  links[objProp][conPairId][:fEVer]     = rows[conProps[:from]][:e_ver]
                  links[objProp][conPairId][:fDoc]      = rows[conProps[:from]][:e_doc] == "" ? 0 : rows[conProps[:from]][:e_doc]
                  links[objProp][conPairId][:fName]     = rows[conProps[:from]][:o_name]                
                  links[objProp][conPairId][:fClass]    = rows[conProps[:from]][:e_class]
                  links[objProp][conPairId][:fFqn]      = rows[conProps[:from]][:p_fqn]                
                  
                  
                  links[objProp][conPairId][:tOID]       = conProps[:to].tr("-", "_")
                  links[objProp][conPairId][:tEID]      = rows[conProps[:to]][:e_id].tr("-", "_")                               
                  links[objProp][conPairId][:tEVer]     = rows[conProps[:to]][:e_ver]
                  links[objProp][conPairId][:tDoc]      = rows[conProps[:to]][:e_doc] == "" ? 0 : rows[conProps[:to]][:e_doc]
                  links[objProp][conPairId][:tName]     = rows[conProps[:to]][:o_name]                
                  links[objProp][conPairId][:tClass]    = rows[conProps[:to]][:e_class]
                  links[objProp][conPairId][:tFqn]      = rows[conProps[:to]][:p_fqn] 
#                     Bot.logger.debug "### AAA #{i}: #{links[objProp][conPairId]}"
                  i = i + 1
                end
              end
            end
          end
        end
      
      args[:objects][viewId][:objects] = rows 
      args[:objects][viewId][:links] = links
    end
getProp(_args,state,conProp,direction) click to toggle source
# File lib/lookup.rb, line 74
    def getProp(_args,state,conProp,direction)
      rows = {}
      
      case direction
      when 'from'
        eID  = conProp[:fEID]
        eVer = conProp[:fEVer]        
      when 'to'
        eID  = conProp[:tEID]
        eVer = conProp[:tEVer]        
      end
      
      state[:dbhandler].execute( "
        select name, value                  
        from properties 
        where parent_id like '#{eID}' AND
        parent_version = '#{eVer}' AND
        name NOT LIKE 'fqn'
      ")  do |row|
#             Bot.logger.debug "### ROW #{eID} #: #{row}"
#             rows[eID] ||= {}
            rows[row[0].to_sym] = row[1]             
      end  
      return rows if not rows.empty?
    end
lookupDebug(name, prop) click to toggle source
# File lib/lookup.rb, line 135
def lookupDebug(name, prop)
  Bot.logger.debug "### #{name} :: F:: '#{prop[:fName]}' fqn:#{prop[:fFqn]} o:#{prop[:fOID]} e:#{prop[:fEID]} p '#{prop[:fProp]}' :: T :: '#{prop[:tName]}' fqn:#{prop[:tFqn]} o:#{prop[:tOID]} e:#{prop[:tEID]} p '#{prop[:tProp]}'"
end
lookup_constructors_DockedGroupings2AppFunctions(args, state, viewId, viewType) click to toggle source
# File lib/lookup/constructors/DockedGroupings2AppFunctions.rb, line 16
    def lookup_constructors_DockedGroupings2AppFunctions(args, state, viewId, viewType)
      queryName = __method__.to_s; queryName.slice! 'lookup_constructors_'; queryName.to_sym
      args[:dialectLookupQuery] = {queryName: queryName,    cClass: 'CompositionRelationship', fPropKey: :docked, fPropValue: "true",
                        fClass: 'Grouping',      fFqn: "#{state[:myAppName]}Element*", 
                        tClass: 'ApplicationFunction',      tFqn: "#{state[:myAppName]}Element*" }
      
      dialectLookup(args, state, viewId, viewType)
#       dialectRepack(args, state, viewId, viewType, queryName)
    end
lookup_constructors_Element2ModSend(args, state, viewId, viewType) click to toggle source
# File lib/lookup/constructors/Element2ModSend.rb, line 16
def lookup_constructors_Element2ModSend(args, state, viewId, viewType)
  queryName = __method__.to_s; queryName.slice! 'lookup_constructors_'; queryName.to_sym
  args[:dialectLookupQuery] = {queryName: queryName,    cClass: 'AccessRelationship', 
                         fClass: 'ApplicationFunction', fFqn: "#{state[:myAppName]}Element*", 
                         tClass: 'DataObject',          tFqn: "#{state[:myAppName]}ModSend*" }
  
  dialectLookup(args, state, viewId, viewType)
  dialectRepack(args, state, viewId, viewType, queryName)      
end
lookup_constructors_ElementsInElements(args, state, viewId, viewType) click to toggle source
# File lib/lookup/constructors/ElementsInElements.rb, line 16
    def lookup_constructors_ElementsInElements(args, state, viewId, viewType)
      queryName = __method__.to_s; queryName.slice! 'lookup_constructors_'; queryName.to_sym
      args[:dialectLookupQuery] = {queryName: queryName,    cClass: 'SpecializationRelationship',
                        fClass: 'ApplicationFunction',      fFqn: "#{state[:myAppName]}Element*", 
                        tClass: 'ApplicationFunction',      tFqn: "#{state[:myAppName]}Element*" }
      
      dialectLookup(args, state, viewId, viewType)
#       dialectRepack(args, state, viewId, viewType, queryName)
    end
lookup_data_GenData2Dest(args, state, viewId, viewType) click to toggle source
# File lib/lookup/data/3.GenData2Dest.rb, line 16
def lookup_data_GenData2Dest(args, state, viewId, viewType)
  queryName = __method__.to_s; queryName.slice! 'lookup_data_'; queryName.to_sym
  
  args[:dialectLookupQuery] = {queryName: queryName,        cClass: 'ServingRelationship', 
                         fClass: 'ApplicationFunction',     fFqn: "#{state[:myAppName]}Element*",                                 
                         tClass: 'ApplicationService',      tFqn: "#{state[:myAppName]}ArchiGendata*" }
  
  dialectLookup(args, state, viewId, viewType)
  dialectRepack(args, state, viewId, viewType, queryName)            
end
lookup_data_GetData2Elements(args, state, viewId, viewType) click to toggle source
# File lib/lookup/data/2.GetData2Elements.rb, line 16
def lookup_data_GetData2Elements(args, state, viewId, viewType)
  queryName = __method__.to_s; queryName.slice! 'lookup_data_'; queryName.to_sym
  
  args[:dialectLookupQuery] = {queryName: queryName,        cClass: 'TriggeringRelationship', 
                         fClass: 'ApplicationService',      fFqn: "#{state[:myAppName]}ArchiGetdata*", 
                         tClass: 'ApplicationFunction',     tFqn: "#{state[:myAppName]}Element*" }
  
  dialectLookup(args, state, viewId, viewType)
  dialectRepack(args, state, viewId, viewType, queryName)            
end
lookup_data_ModReceive2GetData(args, state, viewId, viewType) click to toggle source
# File lib/lookup/data/1.ModReceive2GetData.rb, line 16
def lookup_data_ModReceive2GetData(args, state, viewId, viewType)
  queryName = __method__.to_s; queryName.slice! 'lookup_data_'; queryName.to_sym

  args[:dialectLookupQuery] = {queryName: queryName,        cClass: 'AccessRelationship', 
                         fClass: 'ApplicationService',      fFqn: "#{state[:myAppName]}ArchiGetdata*", 
                         tClass: 'DataObject',              tFqn: "#{state[:myAppName]}ModReceiveData*" }
  
  dialectLookup(args, state, viewId, viewType)
  dialectRepack(args, state, viewId, viewType, queryName)      
end
lookup_data_Results2GenData(args, state, viewId, viewType) click to toggle source
# File lib/lookup/data/4.Results2GenData.rb, line 16
def lookup_data_Results2GenData(args, state, viewId, viewType)
  queryName = __method__.to_s; queryName.slice! 'lookup_data_'; queryName.to_sym
  
  args[:dialectLookupQuery] = {queryName: queryName,        cClass: 'RealizationRelationship', 
                         fClass: 'ApplicationFunction',     fFqn: "#{state[:myAppName]}Element*",                                 
                         tClass: 'ApplicationService',      tFqn: "#{state[:myAppName]}ArchiGendata*" }
  
  dialectLookup(args, state, viewId, viewType)
  dialectRepack(args, state, viewId, viewType, queryName)            
end
lookup_functional_AppEvent2Elements(args, state, viewId, viewType) click to toggle source
# File lib/lookup/functional/4.1.AppEvent2Elements.rb, line 16
def lookup_functional_AppEvent2Elements(args, state, viewId, viewType)
  queryName = __method__.to_s; queryName.slice! 'lookup_functional_'; queryName.to_sym
  args[:dialectLookupQuery] = {queryName: queryName,    cClass: 'TriggeringRelationship', 
                         fClass: 'ApplicationEvent',    fFqn: "#{state[:myAppName]}ArchiAppevent*", 
                         tClass: 'ApplicationFunction', tFqn: "#{state[:myAppName]}Element*" }
  
  dialectLookup(args, state, viewId, viewType)
  dialectRepack(args, state, viewId, viewType, queryName)            
end
lookup_functional_Appevent2EventBus(args, state, viewId, viewType) click to toggle source
# File lib/lookup/functional/3.Appevent2EventBus.rb, line 16
def lookup_functional_Appevent2EventBus(args, state, viewId, viewType)
  queryName = __method__.to_s; queryName.slice! 'lookup_functional_'; queryName.to_sym
  args[:dialectLookupQuery] = {queryName: queryName,   cClass: 'ServingRelationship', 
                         fClass: 'ApplicationService', fFqn: "#{state[:myAppName]}ArchiEventBus",
                         tClass: 'ApplicationEvent',   tFqn: "#{state[:myAppName]}ArchiAppevent*"  }
  
  dialectLookup(args, state, viewId, viewType)
  dialectRepack(args, state, viewId, viewType, queryName)            
end
lookup_functional_Element2ModElements(args, state, viewId, viewType) click to toggle source
# File lib/lookup/functional/5.1.Element2ModElements.rb, line 16
def lookup_functional_Element2ModElements(args, state, viewId, viewType)
  queryName = __method__.to_s; queryName.slice! 'lookup_functional_'; queryName.to_sym
  args[:dialectLookupQuery] = {queryName: queryName,    cClass: 'AccessRelationship', 
                         fClass: 'ApplicationFunction', fFqn: "#{state[:myAppName]}Element*", 
                         tClass: 'DataObject',          tFqn: "#{state[:myAppName]}ModElement*" }
  
  dialectLookup(args, state, viewId, viewType)
  dialectRepack(args, state, viewId, viewType, queryName)            
end
lookup_functional_Element2ModSend(args, state, viewId, viewType) click to toggle source
# File lib/lookup/functional/5.2.Element2ModSend.rb, line 16
def lookup_functional_Element2ModSend(args, state, viewId, viewType)
  queryName = __method__.to_s; queryName.slice! 'lookup_functional_'; queryName.to_sym
  args[:dialectLookupQuery] = {queryName: queryName,    cClass: 'AccessRelationship', 
                         fClass: 'ApplicationFunction', fFqn: "#{state[:myAppName]}Element*", 
                         tClass: 'DataObject',          tFqn: "#{state[:myAppName]}ModSend*" }
  
  dialectLookup(args, state, viewId, viewType)  
end
lookup_functional_ElementChains(args, state, viewId, viewType) click to toggle source
# File lib/lookup/functional/7.ElementChains.rb, line 16
def lookup_functional_ElementChains(args, state, viewId, viewType)
  queryName = __method__.to_s; queryName.slice! 'lookup_functional_'; queryName.to_sym
  args[:dialectLookupQuery] = {queryName: queryName,      cClass: 'TriggeringRelationship', 
                        fClass: 'ApplicationFunction',    fFqn: "#{state[:myAppName]}ElementSend*", 
                        tClass: 'ApplicationFunction',    tFqn: "#{state[:myAppName]}ElementSend*" }
  
  dialectLookup(args, state, viewId, viewType)
  dialectRepack(args, state, viewId, viewType, queryName)      
end
lookup_functional_Elements2AppEvent(args, state, viewId, viewType) click to toggle source
# File lib/lookup/functional/4.2.Elements2AppEvent.rb, line 16
def lookup_functional_Elements2AppEvent(args, state, viewId, viewType)
  queryName = __method__.to_s; queryName.slice! 'lookup_functional_'; queryName.to_sym
  args[:dialectLookupQuery] = {queryName: queryName,    cClass: 'ServingRelationship', 
                         fClass: 'ApplicationFunction', fFqn: "#{state[:myAppName]}Element*",                                   
                         tClass: 'ApplicationEvent',    tFqn: "#{state[:myAppName]}ArchiAppevent*"}
  
  dialectLookup(args, state, viewId, viewType)
  dialectRepack(args, state, viewId, viewType, queryName)            
end
lookup_functional_Events2AppEvent(args, state, viewId, viewType) click to toggle source
# File lib/lookup/functional/2.1.Events2AppEvent.rb, line 16
def lookup_functional_Events2AppEvent(args, state, viewId, viewType)
  queryName = __method__.to_s; queryName.slice! 'lookup_functional_'; queryName.to_sym
  args[:dialectLookupQuery] = {queryName: queryName,    cClass: 'FlowRelationship',
                         fClass: 'ApplicationFunction', fFqn: "#{state[:myAppName]}Event*", 
                         tClass: 'ApplicationEvent',    tFqn: "#{state[:myAppName]}ArchiAppevent*" }
  
  dialectLookup(args, state, viewId, viewType) 
  dialectRepack(args, state, viewId, viewType, queryName)      
end
lookup_functional_Events2ModReceive(args, state, viewId, viewType) click to toggle source
# File lib/lookup/functional/2.2.1.Events2ModReceive.rb, line 16
def lookup_functional_Events2ModReceive(args, state, viewId, viewType)
  queryName = __method__.to_s; queryName.slice! 'lookup_functional_'; queryName.to_sym
  args[:dialectLookupQuery] = {queryName: queryName,    cClass: 'AccessRelationship', 
                         fClass: 'ApplicationFunction', fFqn: "#{state[:myAppName]}Event*", 
                         tClass: 'DataObject',          tFqn: "#{state[:myAppName]}ModReceiveData*" }
  
  dialectLookup(args, state, viewId, viewType)
  dialectRepack(args, state, viewId, viewType, queryName)      
end
lookup_functional_Expect2Events(args, state, viewId, viewType) click to toggle source
# File lib/lookup/functional/1.Expect2Events.rb, line 16
def lookup_functional_Expect2Events(args, state, viewId, viewType)
  queryName = __method__.to_s; queryName.slice! 'lookup_functional_'; queryName.to_sym
  args[:dialectLookupQuery] = {queryName: queryName,    cClass: 'AggregationRelationship', 
                    fClass: 'ApplicationFunction',      fFqn: "#{state[:myAppName]}ArchiEventExpect", 
                    tClass: 'ApplicationFunction',      tFqn: "#{state[:myAppName]}Event*" }
  
  dialectLookup(args, state, viewId, viewType)
  dialectRepack(args, state, viewId, viewType, queryName)            
end
lookup_functional_ModElementsSpecs(args, state, viewId, viewType) click to toggle source
# File lib/lookup/functional/6.ModElementsSpecs.rb, line 16
def lookup_functional_ModElementsSpecs(args, state, viewId, viewType)
  queryName = __method__.to_s; queryName.slice! 'lookup_functional_'; queryName.to_sym
  args[:dialectLookupQuery] = {queryName: queryName,    cClass: 'SpecializationRelationship', 
                         fClass: 'DataObject',          fFqn: "#{state[:myAppName]}ModSend*", 
                         tClass: 'DataObject',          tFqn: "#{state[:myAppName]}ModElement*" }
  
  dialectLookup(args, state, viewId, viewType)
  dialectRepack(args, state, viewId, viewType, queryName)            
end
lookup_functional_ModReceive2AppEvent(args, state, viewId, viewType) click to toggle source
# File lib/lookup/functional/2.2.2.ModReceive2AppEvent.rb, line 16
def lookup_functional_ModReceive2AppEvent(args, state, viewId, viewType)
  queryName = __method__.to_s; queryName.slice! 'lookup_functional_'; queryName.to_sym
  args[:dialectLookupQuery] = {queryName: queryName,    cClass: 'AccessRelationship',
                         fClass: 'ApplicationEvent',    fFqn: "#{state[:myAppName]}ArchiAppevent*", 
                         tClass: 'DataObject',          tFqn: "#{state[:myAppName]}ModReceiveData*" }
  
  dialectLookup(args, state, viewId, viewType)
  dialectRepack(args, state, viewId, viewType, queryName)      
end
lookup_run(args, lookupStruct, state, viewId, viewType) click to toggle source
# File lib/lookup.rb, line 140
    def lookup_run(args, lookupStruct, state, viewId, viewType)
      lookupStruct.each do |type,lookups|
        lookups.each do |lookup|
        run = "lookup_#{type}_#{lookup}"
#           Dialog.logger.debug "### Dialect_lookup call - #{run}"
          send(run, args, state, viewId, viewType)
        end
      end
    end
run(state) click to toggle source
# File lib/dialect_lookup.rb, line 26
    def run(state)
        
      args = {views: {}, con_views: {}, exec: {}, stages: {} }
      state.has_key?(:sqlite) ? db = state[:sqlite] : db = "/tmp/dialect.sqlite"
      state[:dbhandler] = SQLite3::Database.new db
      
      ###functional views
      folderMain = state[:dbhandler].execute("select id from folders where name in ('#{state[:dialectFolder]}')")[0][0]
      state[:dbhandler].execute("select folder_id from folders_in_model where parent_folder_id in ('#{folderMain}') and model_version = (select max(model_version) from folders_in_model where parent_folder_id in ('#{folderMain}')) and folder_version = (select max(folder_version) from folders_in_model where parent_folder_id in ('#{folderMain}'))").each do |conFolder|
        folderDialog = state[:dbhandler].execute("select id from folders where name in ('Dialog') and id in ('#{conFolder[0]}')")[0]
        if folderDialog.is_a?(Array)
          state[:dbhandler].execute("select view_id as view_id2, view_version, model_version from views_in_model where parent_folder_id in ('#{folderDialog[0]}') and model_version = (select max(model_version) from views_in_model where view_id in (view_id2))") do |row|
            viewAtr = state[:dbhandler].execute("select name, version from views where id in ('#{row[0]}') and version = (select max(version) from views where id in ('#{row[0]}'))")
            if row[1] == viewAtr[0][1]
              id = row[0].tr("-", "_")

              args[:views][id] ||= {}
              args[:views][id][:version] = row[1]
              args[:views][id][:name] = state[:dialectFolder]
              Dialog.logger.info "Dialect functional view '#{viewAtr[0][0]}' (id #{id}, view ver.#{row[1]}, model ver.#{row[2]}) of interface '#{Dialog.config.naming.interface}' for bot '#{Dialog.config.naming.instance}' suits for me!"
            end
          end           
        end
      end
      

      
      ###_constructors views
      folderId = state[:dbhandler].execute("select id from folders where name in ('_constructors')")[0][0]       
      state[:dbhandler].execute("select folder_id, folder_version, model_version from folders_in_model where parent_folder_id in ('#{folderId}') and model_version = (select max(model_version) from folders_in_model where parent_folder_id in ('#{folderId}')) and folder_version = (select max(folder_version) from folders_in_model where parent_folder_id in ('#{folderId}'))").each do |conFolder|
        
      state[:dbhandler].execute("select view_id as view_id2, view_version, model_version from views_in_model where parent_folder_id in ('#{conFolder[0]}') and model_version = (select max(model_version) from views_in_model where view_id in (view_id2))") do |row|
        viewAtr = state[:dbhandler].execute("select name, version from views where id in ('#{row[0]}') and version = (select max(version) from views where id in ('#{row[0]}'))")
          id = row[0].tr("-", "_")

          args[:con_views][id] ||= {}
          args[:con_views][id][:version] = row[1]
          args[:con_views][id][:name] = state[:dialectFolder]
          Dialog.logger.info "Dialect constructor view '#{viewAtr[0][0]}' (id #{id}, view ver.#{row[1]}, model ver.#{row[2]}) suits for me!"     
        end        
      end
       
      
      args[:stages][state[:dialectFolder]] = {}
      args[:stages][state[:dialectFolder]] = {codegenGlobal: {}, codegenPerView: {}, x: {}, panView: {lookup: {}}, perView: {}, constructor: {}}
      
      getObjects(args, state)


      args[:con_views].each do |viewId, _viewProps|
        viewType = :constructors
        lookup_constructors_DockedGroupings2AppFunctions(args, state, viewId, viewType)  
        lookup_constructors_Element2ModSend(args, state, viewId, viewType)        
        lookup_constructors_ElementsInElements(args, state, viewId, viewType)
      end
      
      args[:views].each do |viewId, viewProps|
        viewType = :perView
        Dialog.logger.debug "Dialect_lookup RUN instance '#{state[:dialectFolder]}' view '#{viewProps[:name]}' ver.#{viewProps[:version]}"
        ###functional
        lookupStruct = {'functional' => [
          'Expect2Events',     'Events2AppEvent',   'Events2ModReceive', 'ModReceive2AppEvent',
          'Appevent2EventBus', 'AppEvent2Elements', 'Elements2AppEvent', 'Element2ModElements',
          'Element2ModSend',   'ModElementsSpecs',  'ElementChains']}
        #1
        lookup_run(args, lookupStruct, state, viewId, viewType)
        
        ###data
        lookupStruct = {'data' => [
          'ModReceive2GetData',     'GetData2Elements',   'GenData2Dest', 'Results2GenData']}
        #1
        lookup_run(args, lookupStruct, state, viewId, viewType)        
        ###
      end
        
        
        state[:dbhandler].close
        #json = Oj.dump(args) ## NO GIT-PREFERRED PRETTY OUTPUT IN OJ
        json = JSON.pretty_generate(args)
#         File.delete(db)
#         FileUtils.mkdir_p("#{state[:jsonFolder]}")
        FileUtils.rm_rf("#{state[:json]}")
        File.open(state[:json], 'w') { |file| file.write(json) }

    end