archestry_lookup 0.0.11

data/lib/context/_refactor_dialog/functional/7.ElementChains.rb

@@ -0,0 +1,28 @@
+########    #######    ########    #######    ########    ########
+##     / / / /    License    \ \ \ \ 
+##    Copyleft culture, Copyright (C) is prohibited here
+##    This work is licensed under a CC BY-SA 4.0
+##    Creative Commons Attribution-ShareAlike 4.0 License
+##    Refer to the http://creativecommons.org/licenses/by-sa/4.0/
+########    #######    ########    #######    ########    ########
+##    / / / /    Code Climate    \ \ \ \ 
+##    Language = ruby
+##    Indent = space;    4 chars;
+########    #######    ########    #######    ########    ########
+module ArchestryLookup
+  module Lookup
+    class << self      
+    
+      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
+    
+    end
+  end
+end

data/lib/context/_refactor_dialog/main.rb

@@ -0,0 +1,69 @@
+########    #######    ########    #######    ########    ########
+##     / / / /    License    \ \ \ \ 
+##    Copyleft culture, Copyright (C) is prohibited here
+##    This work is licensed under a CC BY-SA 4.0
+##    Creative Commons Attribution-ShareAlike 4.0 License
+##    Refer to the http://creativecommons.org/licenses/by-sa/4.0/
+########    #######    ########    #######    ########    ########
+##    / / / /    Code Climate    \ \ \ \ 
+##    Language = ruby
+##    Indent = space;    4 chars;
+########    #######    ########    #######    ########    ########
+module ArchestryLookup
+  module Lookup
+    class << self
+    
+      def dialog_lookup_main(args, state)
+        dialog_lookup_main_constructor(args, state) 
+      end
+      
+    
+      def dialog_lookup_main_constructor(args, state)
+        args[:stages][state[:dialectFolder]] = {codegenGlobal: {}, codegenPerView: {}, x: {}, panView: {lookup: {}}, perView: {}, constructor: {}}
+        ###_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 "ArchestryLookup constructor view '#{viewAtr[0][0]}' (id #{id}, view ver.#{row[1]}, model ver.#{row[2]}) suits for me!"     
+          end        
+        end    
+      end
+      
+      def dialog_lookup_post(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
+          ArchestryLookup.logger.debug "ArchestryLookup_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      
+      end
+      
+    end
+  end
+end

data/lib/context/archestry/library.rb

@@ -0,0 +1,53 @@
+########    #######    ########    #######    ########    ########
+##     / / / /    License    \ \ \ \ 
+##    Copyleft culture, Copyright (C) is prohibited here
+##    This work is licensed under a CC BY-SA 4.0
+##    Creative Commons Attribution-ShareAlike 4.0 License
+##    Refer to the http://creativecommons.org/licenses/by-sa/4.0/
+########    #######    ########    #######    ########    ########
+##    / / / /    Code Climate    \ \ \ \ 
+##    Language = ruby
+##    Indent = space;    4 chars;
+########    #######    ########    #######    ########    ########
+module ArchestryLookup
+  module Schema    
+    class << self
+    
+      def getObjLookupSchema
+        lookupQuery = {}
+        lookupQuery[:all] = {cClass: '*',
+                            fClass: '*', fPropsK: "*", fPropsV: "*",
+                            tClass: '*', tPropsK: "*", tPropsV: "*" }
+        
+        lookupQuery[:app] = {cClass: '*',
+                            fClass: 'Application*', fPropsK: "*", fPropsV: "*",
+                            tClass: 'Application*', tPropsK: "*", tPropsV: "*" }  
+        
+        lookupQuery[:archdevops] = {cClass: '*',          
+                            fClass: 'ArchDevOps*', fPropsK: "*", fPropsV: "*",
+                            tClass: 'ArchDevOps*', tPropsK: "*", tPropsV: "*" }
+        
+        lookupQuery[:biz] = {cClass: '*',          
+                            fClass: 'Business*', fPropsK: "*", fPropsV: "*",
+                            tClass: 'Business*', tPropsK: "*", tPropsV: "*" }
+                            
+        lookupQuery[:data] = {cClass: '*',          
+                            fClass: 'Data*', fPropsK: "*", fPropsV: "*",
+                            tClass: 'Data*', tPropsK: "*", tPropsV: "*" }
+
+        lookupQuery[:tech] = {cClass: '*',          
+                            fClass: 'Technology*', fPropsK: "*", fPropsV: "*",
+                            tClass: 'Technology*', tPropsK: "*", tPropsV: "*" }
+
+        lookupQuery[:x5] = {cClass: '*',          
+                            fClass: 'X5*', fPropsK: "*", fPropsV: "*",
+                            tClass: 'X5*', tPropsK: "*", tPropsV: "*" }
+        
+        
+        lookupQuery
+        
+      end
+  
+    end
+  end
+end

data/lib/context/archestry/prepost.rb

@@ -0,0 +1,39 @@
+########    #######    ########    #######    ########    ########
+##     / / / /    License    \ \ \ \ 
+##    Copyleft culture, Copyright (C) is prohibited here
+##    This work is licensed under a CC BY-SA 4.0
+##    Creative Commons Attribution-ShareAlike 4.0 License
+##    Refer to the http://creativecommons.org/licenses/by-sa/4.0/
+########    #######    ########    #######    ########    ########
+##    / / / /    Code Climate    \ \ \ \ 
+##    Language = ruby
+##    Indent = space;    4 chars;
+########    #######    ########    #######    ########    ########
+module ArchestryLookup
+  module Objects
+    class << self
+      
+      def lookup_pre(args, state)
+        true
+      end
+      
+      def lookup_post(args, state)
+        true
+      end      
+      
+      
+      def lookup_post2(args, state)
+#         pp args[:folders]
+        args[:views][:mtype].each do |modelType, ids| 
+          ids.each do |id|
+            args[:views][:id][id].each do |viewId, viewProps|
+              ArchestryLookup.logger.debug "ArchestryLookup_lookup RUN instance '' view '#{viewProps}' ver."
+              lookup_run(args, ArchestryLookup::Schema.getObjLookupSchema, state, modelType, id)
+            end
+          end
+        end
+      end
+      
+    end
+  end
+end

data/lib/objects/_old.rb

@@ -0,0 +1,43 @@
+########    #######    ########    #######    ########    ########
+##     / / / /    License    \ \ \ \ 
+##    Copyleft culture, Copyright (C) is prohibited here
+##    This work is licensed under a CC BY-SA 4.0
+##    Creative Commons Attribution-ShareAlike 4.0 License
+##    Refer to the http://creativecommons.org/licenses/by-sa/4.0/
+########    #######    ########    #######    ########    ########
+##    / / / /    Code Climate    \ \ \ \ 
+##    Language = ruby
+##    Indent = space;    4 chars;
+########    #######    ########    #######    ########    ########
+module ArchestryLookup
+  module Objects
+    class << self   
+  
+      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
+        
+        ArchestryLookup::Sql.sqlQuery(state,  "
+          select name, value                  
+          from properties 
+          where parent_id like '#{eID}' AND
+          parent_version = '#{eVer}' AND
+          name NOT LIKE 'fqn'
+        ")  do |row|
+  #             ArchestryLookup.logger.debug "### ROW #{eID} #: #{row}"  
+              rows[row[0].to_sym] = row[1]             
+        end  
+        return rows if not rows.empty?
+      end
+
+  
+    end
+  end
+end

data/lib/objects/lookup.rb

@@ -0,0 +1,152 @@
+########    #######    ########    #######    ########    ########
+##     / / / /    License    \ \ \ \ 
+##    Copyleft culture, Copyright (C) is prohibited here
+##    This work is licensed under a CC BY-SA 4.0
+##    Creative Commons Attribution-ShareAlike 4.0 License
+##    Refer to the http://creativecommons.org/licenses/by-sa/4.0/
+########    #######    ########    #######    ########    ########
+##    / / / /    Code Climate    \ \ \ \ 
+##    Language = ruby
+##    Indent = space;    4 chars;
+########    #######    ########    #######    ########    ########
+module ArchestryLookup
+  module Objects
+    class << self   
+  
+    
+      def archestryLookupView(args, lookupType, lookup, state, modelType, viewId)
+        if args[:objects][:view][modelType][viewId]
+          if lookup[:cClass] == '*'
+            args[:objects][:view][modelType][viewId][:links].each do |cClass, cProp|
+              archestryLookupViewRun(args, state, lookupType, lookup, modelType, viewId, cClass)
+            end
+          else
+            archestryLookupViewRun(args, state, lookupType, lookup, modelType, viewId, lookup[:cClass])
+          end
+        end
+      end
+      
+      
+      def archestryLookupViewRun(args, state, lookupType, lookup, modelType, viewId, cClass)
+        queryName = lookupType
+        if args[:objects][:view][modelType][viewId][:links][cClass].is_a?(Hash)
+          args[:objects][:view][modelType][viewId][:links][cClass].each do |_conPairId, conProp|
+          
+            lookup[:fClass] == '*' ? fClass = /^*/ : fClass = /^#{lookup[:fClass]}/
+            lookup[:tClass] == '*' ? tClass = /^*/ : tClass = /^#{lookup[:tClass]}/
+            
+            fPropMod = []
+            fPropMod << :fPropsKAll if lookup[:fPropsK] == '*'
+            fPropMod << :fPropsVAll if lookup[:fPropsV] == '*'
+            fPropMod << :fPropsAll if fPropMod.include?(:fPropsKAll) and fPropMod.include?(:fPropsVAll)
+            
+            tPropMod = []
+            tPropMod << :tPropsKAll if lookup[:tPropsK] == '*'
+            tPropMod << :tPropsVAll if lookup[:tPropsV] == '*'
+            tPropMod << :tPropsAll if tPropMod.include?(:tPropsKAll) and tPropMod.include?(:tPropsVAll)
+            
+            if fPropMod.include?(:fPropsKAll)
+              fPropsFiltered = true
+            elsif fPropMod.include?(:fPropsVAll)
+              fPropsFiltered = true if conProp[:fProps].has_key?(lookup[:fPropsK])
+            else
+              fPropsFiltered = true if conProp[:fProps][lookup[:fPropsK]] =~ /^#{lookup[:fPropsV]}/
+            end
+            
+            if tPropMod.include?(:tPropsKAll)
+              tPropsFiltered = true
+            elsif tPropMod.include?(:tPropsVAll)
+              tPropsFiltered = true if conProp[:tProps].has_key?(lookup[:tPropsK])
+            else
+#               tPropsFiltered = true if conProp[:tProps][lookup[:tPropsK]] =~ /^#{lookup[:tPropsV]}/
+            end
+          
+            
+          if  conProp[:viewID] == viewId and
+              conProp[:fClass] =~ fClass and 
+              conProp[:tClass] =~ tClass and
+              fPropsFiltered == true and 
+              tPropsFiltered == true 
+                makeStageView(args, state, conProp, modelType, viewId, queryName, lookup, cClass)
+            end
+          end
+        end
+      end
+      
+      
+      def makeStageView(args, state, conProp, modelType, viewId, queryName, lookup, cClass)
+        conProp[:cClass] = cClass
+
+        if lookup.has_key?(:fPropKey)
+          conProp[:fProp][lookup[:fPropKey]] == lookup[:fPropValue] ? store = true : store = false
+        else
+          store = true
+        end
+        
+        if store == true    
+#                 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]              
+# 
+#           if conProp[:fProps].is_a?(Hash) and conProp[:fProps].has_key?('listenIP') and conProp[:fProps]['listenIP'] == '1.1.1.1'
+#             pp "fProps:: conProp:#{conProp}"
+#           elsif conProp[:tProps].is_a?(Hash) and conProp[:tProps].has_key?('listenIP')
+#             pp "tProps:: conProp:#{conProp}"            
+#           end          
+          
+          args[:stages][:view][modelType] ||= {}
+          args[:stages][:view][modelType][viewId] ||= {}
+          args[:stages][:view][modelType][viewId][queryName] ||= {}              
+          args[:stages][:view][modelType][viewId][queryName][:lookup] ||= {}
+          args[:stages][:view][modelType][viewId][queryName][:lookup][hash_tName] ||= {}
+          args[:stages][:view][modelType][viewId][queryName][:lookup][hash_tName][hash_fName_fId_tId] = conProp                   
+        end
+      end
+
+      
+      def archestryRepack(args, lookup, state, modelType, viewId, viewType) 
+        args[:stages].each do |k, v|
+          a = args[:stages][k]
+          pp viewType
+          unless a.has_key?(viewType) and a.has_key?(viewType) and not a[viewId].nil?
+            base = false
+          else
+            base = a[viewId][queryName]          
+          end
+        end
+
+        if base.is_a?(Hash)
+          repackNames = [:fProps, :tProps, :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  
+
+            a[viewId][queryName][:repack][repackName] = res               
+          end      
+        end
+      end
+      
+      
+      def lookupDebug(name, prop)
+        ArchestryLookup.logger.debug "### #{name} :: F:: '#{prop[:fName]}' fqn:#{prop[:fProps]} o:#{prop[:fOID]} e:#{prop[:fEID]} p '#{prop[:fProp]}' :: T :: '#{prop[:tName]}' fqn:#{prop[:tProps]} o:#{prop[:tOID]} e:#{prop[:tEID]} p '#{prop[:tProp]}'"
+      end
+      
+      
+      def lookup_run(args, lookupStruct, state, modelType, viewId)
+        lookupStruct.each do |lookupType, lookup|
+          ArchestryLookup.logger.debug "### ArchestryLookup_lookup call - type::#{lookupType}, lookupStruct::#{lookupStruct}"        
+          archestryLookupView(args, lookupType, lookup, state, modelType, viewId)
+#           archestryRepack(args, lookupType, lookup, state, modelType, viewId)                 
+        end
+      end
+    
+  
+    end
+  end
+end

data/lib/schema/schema.rb

@@ -0,0 +1,38 @@
+########    #######    ########    #######    ########    ########
+##     / / / /    License    \ \ \ \ 
+##    Copyleft culture, Copyright (C) is prohibited here
+##    This work is licensed under a CC BY-SA 4.0
+##    Creative Commons Attribution-ShareAlike 4.0 License
+##    Refer to the http://creativecommons.org/licenses/by-sa/4.0/
+########    #######    ########    #######    ########    ########
+##    / / / /    Code Climate    \ \ \ \ 
+##    Language = ruby
+##    Indent = space;    4 chars;
+########    #######    ########    #######    ########    ########
+
+module ArchestryLookup
+  module Schema
+    class << self
+      
+      def getMFVSchema
+        args = Hash.recursive
+        args[:models]   = {:schema => [:name, :type, :ver, :cby, :con]}
+        args[:folders]  = {:schema => [:name, :type, :ver, :cby, :con, :pid, :rtype]}
+        args[:views]    = {:schema => [:name, :viewpoint, :ver, :cby, :con]}
+        args[:objects]  = {:schema => [:view, :objfolder]}
+        args[:stages]   = {:schema => [:view, :objfolder]}
+        
+        args
+      end
+      
+      def getElementsSchema
+        args = Hash.recursive
+        args[:elements]  = {:schema => [:mID, :mName, :mType, :fID, :fName, :vID, :vName, :vPoint, :rClass],
+                            :schemaDir => [:eClass, :oCby, :oCon]}
+        args
+      end
+
+    
+    end
+  end
+end

data/lib/sql/dbhandlers.rb

@@ -0,0 +1,81 @@
+########    #######    ########    #######    ########    ########
+##     / / / /    License    \ \ \ \ 
+##    Copyleft culture, Copyright (C) is prohibited here
+##    This work is licensed under a CC BY-SA 4.0
+##    Creative Commons Attribution-ShareAlike 4.0 License
+##    Refer to the http://creativecommons.org/licenses/by-sa/4.0/
+########    #######    ########    #######    ########    ########
+##    / / / /    Code Climate    \ \ \ \ 
+##    Language = ruby
+##    Indent = space;    4 chars;
+########    #######    ########    #######    ########    ########
+module ArchestryLookup
+  module Sql
+    class << self
+      
+      def sqlQuery(state, sql)
+        
+#         p "##SQL:: #{sql}"
+        res = {}
+
+        case state[:dbtype]
+        when :sqlite
+          res = sqliteAnswerMap(state[:db][:handler].execute2(sql))
+        when :pg
+          res = pgAnswerMap(state[:db][:handler].exec(sql))
+        end
+          
+#         p "## SQL_RES:: #{res}"        
+        res        
+      end
+      
+      def sqliteAnswerMap(answer)
+        res = {}
+        m = {}
+        n = 0
+        j = 0
+        answer.each do |result|
+          if n == 0
+#             puts "##keys::#{result}"
+            i = 0
+            result.each do |v|
+              m[i] = v.to_sym
+              i += 1
+            end 
+          else
+#             puts  "##values::#{result}"
+            i = 0
+            result.each do |v|
+              res[j] ||= {}
+              res[j][m[i]] = v
+              i += 1               
+            end 
+            j += 1            
+          end
+          n += 1
+        end   
+        
+        res
+      end
+      
+      def pgAnswerMap(answer)
+        res = {}
+        m = {}
+        i = 0
+        answer.each do |result|
+#           puts "##values::#{result}"
+          result.each do |k, v|
+            res[i] ||= {}
+            res[i][k.to_sym] = v
+          end
+          i += 1          
+        end   
+        
+        res
+      end      
+    
+ 
+      
+    end
+  end
+end

data/lib/sql/lookup_mfv.rb

@@ -0,0 +1,113 @@
+########    #######    ########    #######    ########    ########
+##     / / / /    License    \ \ \ \ 
+##    Copyleft culture, Copyright (C) is prohibited here
+##    This work is licensed under a CC BY-SA 4.0
+##    Creative Commons Attribution-ShareAlike 4.0 License
+##    Refer to the http://creativecommons.org/licenses/by-sa/4.0/
+########    #######    ########    #######    ########    ########
+##    / / / /    Code Climate    \ \ \ \ 
+##    Language = ruby
+##    Indent = space;    4 chars;
+########    #######    ########    #######    ########    ########
+module ArchestryLookup
+  module Sql
+    class << self
+      
+      #TODO: flags 'skip' in props
+      #
+      
+      def makeInternalLookups(args, keyType, valueType, container, id)
+        args[keyType][valueType] ||= {}
+        args[keyType][valueType][:id] ||= {}
+        args[keyType][valueType][:id][id] = container
+        args[valueType][:schema].each do |k|      
+          args[keyType][valueType][k] ||= {}
+          args[keyType][valueType][k][container[k]] ||= []
+          args[keyType][valueType][k][container[k]] << id
+        end
+      end
+        
+      
+      def archestry_model_lookup(args, state)
+        mfv = {}
+
+        
+        sqlQuery(state, "SELECT m1.id as id, m1.name as name, m1.version as ver, m1.created_by as cby, m1.created_on as con FROM models as m1 WHERE version = (select max(m2.version) FROM models as m2 WHERE m1.id = m2.id)").each do |id, model|
+          sqlQuery(state, "SELECT p1.name, p1.value FROM properties as p1 WHERE p1.parent_id LIKE '#{model[:id]}' and p1.name LIKE 'modelType' and p1.parent_version = #{model[:ver]}").each do |id, type|
+            model[:type] = type[:value].to_sym
+            
+            makeInternalLookups(args, :models, :models, model, model[:id])
+            args[:elements][:base][model[:type]][:id] ||= {}
+            
+            if args[:models][:models][:id][model[:id]][:type] == :library or args[:models][:models][:id][model[:id]][:name] == state[:funcFolder]
+              ArchestryLookup.logger.info "Use model '#{model[:name]}' version #{model[:ver]} type '#{model[:type]}' created by '#{model[:cby]}' on #{model[:con]}"
+              mfv[:model] = model
+              getModelFolders(state, args, mfv)
+            end
+          end
+        end
+      end
+      
+      
+      def getFolderViews(args, state, mfv)
+        a = sqlQuery(state, "select view_id as id, model_version as mver FROM views_in_model as vm1
+                      WHERE vm1.parent_folder_id in ('#{mfv[:folder][:id]}') 
+                      and vm1.model_version = (select max(vm2.model_version) FROM views_in_model as vm2 WHERE vm2.view_id in (vm1.view_id))").each do |k, viewInM|
+          
+          viewAtr = sqlQuery(state, "select v1.id, v1.version as ver, v1.name, v1.viewpoint, v1.created_by as cby, v1.created_on as con FROM views as v1 WHERE id in ('#{viewInM[:id]}') and version = (select max(version) FROM views as v2 WHERE v2.id in ('#{viewInM[:id]}'))")
+
+          view = viewAtr[0]
+#           view[:tid]= view[:id].tr("-", "_")
+          
+          makeInternalLookups(args, :views, :models,  mfv[:model],  view[:id])
+          makeInternalLookups(args, :views, :folders, mfv[:folder], view[:id])          
+          makeInternalLookups(args, :views, :views,   view,         view[:id])
+          
+          mfv[:view] = view
+          view[:viewpoint] == '' ? viewpoint = 'none' : viewpoint = view[:viewpoint]
+          ArchestryLookup.logger.info "Model '#{mfv[:model][:name]}' of type '#{mfv[:model][:type]}': view '#{view[:name]}' (id #{view[:id]}, view ver.#{view[:ver]}, model ver.#{mfv[:model][:ver]}) with viewpoint '#{viewpoint}' suits for me!"
+          getViewConnectionsFromView(args, state, mfv)    
+        end
+      end      
+      
+      
+      def getModelFolders(state, args, mfv)
+        
+        args[:folders] ||={}
+        
+        foldersInModel  = sqlQuery(state, "select fm1.folder_id as id,
+                                    fm1.parent_folder_id as pid,
+                                    f1.name as name,
+                                    f1.type as type,
+                                    f1.version as ver,                                  
+                                    f1.root_type as rtype,
+                                    f1.created_by as cby,
+                                    f1.created_on as con
+                                    FROM folders_in_model as fm1 
+                                    INNER JOIN folders as f1 ON f1.id = fm1.folder_id and f1.version = (select max(f2.version) FROM folders as f2 WHERE f2.id = fm1.folder_id) 
+                                    WHERE fm1.model_id in ('#{mfv[:model][:id]}')
+                                    and fm1.model_version = (select max(fm2.model_version) FROM folders_in_model as fm2 WHERE fm2.model_id LIKE '#{mfv[:model][:id]}')
+                                  ")
+        
+        foldersInModel.each do |id, folder|
+          if folder[:rtype].to_i == 7 and folder[:type].to_i == 0
+            
+            makeInternalLookups(args, :folders, :models,  mfv[:model], folder[:id])
+            makeInternalLookups(args, :folders, :folders, folder,      folder[:id])
+            
+            mfv[:folder] = folder
+            getFolderViews(args, state, mfv)
+#             mod = :view
+          else
+            true
+#             p "This is Archestry core view '#{folder[:name]}' (type #{folder[:type]}, Root type #{folder[:rtype]})"
+#             mod = :objfolder
+          end
+                              
+        end
+
+      end
+      
+    end
+  end
+end

data/lib/sql/pre.rb

@@ -0,0 +1,51 @@
+########    #######    ########    #######    ########    ########
+##     / / / /    License    \ \ \ \ 
+##    Copyleft culture, Copyright (C) is prohibited here
+##    This work is licensed under a CC BY-SA 4.0
+##    Creative Commons Attribution-ShareAlike 4.0 License
+##    Refer to the http://creativecommons.org/licenses/by-sa/4.0/
+########    #######    ########    #######    ########    ########
+##    / / / /    Code Climate    \ \ \ \ 
+##    Language = ruby
+##    Indent = space;    4 chars;
+########    #######    ########    #######    ########    ########
+module ArchestryLookup
+  module Sql
+    class << self
+
+  
+      
+      def preSql(state)
+        state[:db] = {}
+
+        case state[:dbtype]
+        when :sqlite
+          require 'sqlite3'
+          db = state[:dbprop][:filepath]
+          state[:db][:handler] = SQLite3::Database.new db
+        when :pg
+          require 'pg'
+          state[:db][:handler] = PG.connect( dbname: state[:dbprop][:database])
+        else
+          state[:dbtype] = :sqlite
+          require 'sqlite3'
+          db = "/tmp/archestry.sqlite"
+          state[:db][:handler] = SQLite3::Database.new db          
+        end
+          
+        case state[:myAppName]
+        when 'Dialog'
+          state[:db][:relSQL] = "and relationships.class in ('AggregationRelationship', 'TriggeringRelationship', 'FlowRelationship', 'AccessRelationship', 'SpecializationRelationship', 'CompositionRelationship', 'ServingRelationship', 'RealizationRelationship')"
+          state[:db][:elementsSQL] = "and (elements.class LIKE 'Application%' OR elements.class in ('DataObject', 'Grouping'))"
+          state[:db][:propSQL] = "AND properties.name LIKE 'fqn'"
+        when 'Archestry'
+          state[:db][:relSQL] = " "
+          state[:db][:elementsSQL] = ""
+          state[:db][:propSQL] = ""
+        end
+        
+      end
+      
+    end
+  end
+end