lorj 0.2.0 → 1.0.0

data/lib/core/lorj-basedefinition.rb

@@ -1,1139 +0,0 @@
-# encoding: UTF-8
-
-# (c) Copyright 2014 Hewlett-Packard Development Company, L.P.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License");
-#    you may not use this file except in compliance with the License.
-#    You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
-
-# Module Lorj which contains several classes.
-#
-# Those classes describes :
-# - processes (BaseProcess)   : How to create/delete/edit/query object.
-# - controler (BaseControler) : If a provider is defined, define how will do object creation/etc...
-# - definition(BaseDefinition): Functions to declare objects, query/data mapping and setup
-# this task to make it to work.
-
-require 'highline/import'
-require 'erb'
-
-module Lorj
-   # This class limits ERC template to access only to config object data.
-   class ERBConfig
-      attr_reader :config
-
-      def initialize(config)
-          @config = config
-      end
-
-      # Bind this limited class with ERB templates
-      def get_binding()
-         binding()
-      end
-   end
-     
-   # Following class defines class levels function to
-   # declare framework objects.
-   # As each process needs to define new object to deal with
-   # require that process to define it with definition functions
-   # See definition.rb for functions to use.
-
-   class BaseDefinition
-      # Capitalized function are called to start a process. It is done by Core class.
-
-      # Call meta lorj object creation process.
-      # The creation process can implement any logic like:
-      # - create an object in the DB.
-      # - check object existence in the DB. If not exists, create it.
-      #
-      # * *Args* :
-      #   - +ObjectType+ : Meta object type to create.
-      #   - +Config+     : Optional. Hash containing list of data to use for creation.
-      #
-      # * *Returns* :
-      #   - +Object+ : Lorj::Data object of type +ObjectType+ created.
-      #
-      # * *Raises* :
-      #   - Warning if the create_e process handler did not return any data. (nil)
-      #   - Warning if the Config data passed are not required by the meta object (or dependencies) at creation time.
-      #   - Error if ObjectType has never been declared.
-      #   - Error if the dependencies create_e process handler did not return any data. (nil) - Loop detection.
-      #   - Error if the create_e process handler raise an error.
-      #
-      def Create(sObjectType, hConfig = {})
-
-         if hConfig.length > 0
-            # cleanup runtime data to avoid conflicts between multiple calls
-            valid_keys = _identify_data(sObjectType, :create_e)
-            valid_keys.each { | sKey|
-               value = Lorj::rhGet(hConfig, sKey)
-               @oForjConfig[sKey] = value if not @oForjConfig.exist?(sKey) or @oForjConfig.exist?(sKey) == 'runtime'
-               Lorj::rhSet(hConfig, nil, sKey)
-            }
-            if hConfig.length > 0
-               PrcLib::warning("'%s' has been passed but not declared to '%s' object. Those are ignored until you add it in the model definition of '%s'" % [hConfig.keys, sObjectType, sObjectType])
-            end
-         end
-
-         return nil if not sObjectType
-         raise Lorj::PrcError.new(), "%s.Create: '%s' is not a known object type." % [self.class, sObjectType] if Lorj::rhExist?(@@meta_obj, sObjectType) != 1
-
-         pProc = Lorj::rhGet(@@meta_obj, sObjectType, :lambdas, :create_e)
-
-         # Check required parameters
-         oObjMissing = _check_required(sObjectType, :create_e, pProc).reverse
-
-         while oObjMissing.length >0
-            sElem = oObjMissing.pop
-
-            raise Lorj::PrcError.new(),"Unable to create Object '%s'" % sElem if not Create(sElem)
-            oObjMissing = _check_required(sObjectType, :create_e, pProc).reverse
-
-            raise Lorj::PrcError.new(), "loop detection: '%s' is required but Create(%s) did not loaded it." % [sElem, sElem] if oObjMissing.include?(sElem)
-         end
-         @RuntimeContext[:oCurrentObj] = sObjectType # Context: Default object used.
-
-         if pProc.nil?
-            # This object is a meta object, without any data.
-            # Used to build other kind of objects.
-            oObject = Lorj::Data.new
-            oObject.set({}, sObjectType) {}
-         else
-            # build Function params to pass to the event handler.
-            aParams = _get_object_params(sObjectType, :create_e, pProc,)
-            Lorj.debug(2, "Create Object '%s' - Running '%s'" % [sObjectType, pProc])
-
-            # Call the process function.
-            # At some point, the process will call the controller, via the framework.
-            # This controller call via the framework has the role to
-            # create an ObjectData well formatted, with _return_map function
-            # See Definition.connect/create/update/query/get functions (lowercase)
-            oObject = @oForjProcess.method(pProc).call(sObjectType, aParams)
-            # return usually is the main object that the process called should provide.
-            # Save Object if the object has been created by the process, without controller
-         end
-
-         unless oObject.nil?
-            query_cleanup(sObjectType)
-            @ObjectData.add(oObject)
-         else
-            PrcLib::warning("'%s' has returned no data for object Lorj::Data '%s'!" % [pProc, sObjectType])
-         end
-      end
-
-      # Call meta lorj object deletion process
-      # There is no implementation of cascade deletion. It is up to the process to do it or not.
-      #
-      # * *Args* :
-      #   - +ObjectType+ : Meta object type to create.
-      #   - +Config+     : Optional. Hash containing list of data to use for creation.
-      #
-      # * *Returns* :
-      #   - +Deleted+    : true if deleted or false otherwise.
-      #
-      # * *Raises* :
-      #   - Warning if the create_e process handler did not return any data. (nil)
-      #   - Warning if the Config data passed are not required by the meta object (or dependencies) at creation time.
-      #   - Error if ObjectType has never been declared.
-      #   - Error if the dependencies query_e process handler did not return any data. (nil) - Loop detection.
-      #   - Error if the query_e process handler raise an error.
-      #
-      def Delete(sCloudObj, hConfig = {})
-         return nil if not sCloudObj
-
-         raise Lorj::PrcError.new(), "%s.Delete: '%s' is not a known object type." % [self.class, sCloudObj] if Lorj::rhExist?(@@meta_obj, sCloudObj) != 1
-
-         if hConfig.length > 0
-            # cleanup runtime data to avoid conflicts between multiple calls
-            valid_keys = _identify_data(sCloudObj, :delete_e)
-            valid_keys.each { | sKey|
-               value = Lorj::rhGet(hConfig, sKey)
-               @oForjConfig[sKey] = value if not @oForjConfig.exist?(sKey) or @oForjConfig.exist?(sKey) == 'runtime'
-               Lorj::rhSet(hConfig, nil, sKey)
-            }
-            if hConfig.length > 0
-               PrcLib::warning("'%s' has been passed but not declared to '%s' object. Those are ignored until you add it in the model definition of '%s'" % [hConfig.keys, sCloudObj, sCloudObj])
-            end
-         end
-
-         pProc = Lorj::rhGet(@@meta_obj, sCloudObj, :lambdas, :delete_e)
-
-         return nil if pProc.nil?
-
-         # Check required parameters
-         oObjMissing = _check_required(sCloudObj, :delete_e, pProc).reverse
-
-         while oObjMissing.length >0
-            sElem = oObjMissing.pop
-            if sElem == sCloudObj
-               debug(2, "'%s' object is not previously loaded or created." % sCloudObj) if sElem == sCloudObj
-               next
-            end
-            raise Lorj::PrcError.new(),"Unable to create Object '%s'" % sElem if not Create(sElem)
-            oObjMissing = _check_required(sCloudObj, :delete_e, pProc).reverse
-            raise Lorj::PrcError.new(), "Unable to delete '%s' object. required '%s' data was not loaded after 'Create(%s)'. Check create handler for object type '%s'." % [sCloudObj, sElem, sElem, sElem] if oObjMissing.include?(sElem)
-         end
-         @RuntimeContext[:oCurrentObj] = sCloudObj # Context: Default object used.
-
-         # build Function params to pass to the event handler.
-         aParams = _get_object_params(sCloudObj, :delete_e, pProc)
-
-         bState = @oForjProcess.method(pProc).call(sCloudObj, aParams)
-         # return usually is the main object that the process called should provide.
-         if bState
-            @ObjectData.delete(sCloudObj)
-         end
-
-      end
-
-      # Function to clean the cache for a specific meta lorj object queried.
-      #
-      # * *Args* :
-      #   - +ObjectType+ : Meta object type to cleanup.
-      #
-      # * *Returns* :
-      #   no data
-      #
-      # * *Raises* :
-      #
-      def query_cleanup(sCloudObj)
-         oList = @ObjectData[:query, sCloudObj]
-         unless oList.nil?
-            @ObjectData.delete(oList)
-            Lorj.debug(2, "Query cache for object '%s' cleaned." % sCloudObj)
-         end
-      end
-
-      # Function to clean the cache for a specific meta lorj object.
-      #
-      # * *Args* :
-      #   - +ObjectType+ : Meta object type to cleanup.
-      #
-      # * *Returns* :
-      #   no data
-      #
-      # * *Raises* :
-      #
-      def object_cleanup(sCloudObj)
-         oObject = @ObjectData[sCloudObj, :ObjectData]
-         unless oObject.nil?
-            @ObjectData.delete(oObject)
-         end
-      end
-
-      # Function to execute a query process. This function returns a Lorj::Data of type :list.
-      #
-      # * *Args* :
-      #   - +ObjectType+ : Meta object type to query.
-      #   - +Query+      : Hash. Represent the query to execute.
-      #   - +Config+     : Optional. Hash containing list of data to use for query.
-      #
-      # * *Returns* :
-      #   Lorj::Data of type :list
-      #
-      # * *Raises* :
-      #
-      #
-      def Query(sCloudObj, hQuery, hConfig = {})
-
-         return nil if not sCloudObj
-
-         raise Lorj::PrcError.new(), "%s.Get: '%s' is not a known object type." % [self.class, sCloudObj] if Lorj::rhExist?(@@meta_obj, sCloudObj) != 1
-
-         if hConfig.length > 0
-            # cleanup runtime data to avoid conflicts between multiple calls
-            valid_keys = _identify_data(sCloudObj, :query_e)
-            valid_keys.each { | sKey|
-               value = Lorj::rhGet(hConfig, sKey)
-               @oForjConfig[sKey] = value if not @oForjConfig.exist?(sKey) or @oForjConfig.exist?(sKey) == 'runtime'
-               Lorj::rhSet(hConfig, nil, sKey)
-            }
-            if hConfig.length > 0
-               PrcLib::warning("'%s' has been passed but not declared to '%s' object. Those are ignored until you add it in the model definition of '%s'" % [hConfig.keys, sCloudObj, sCloudObj])
-            end
-         end
-
-         # Check if we can re-use a previous query
-         oList = @ObjectData[:query, sCloudObj]
-         unless oList.nil?
-            if oList[:query] == hQuery
-               Lorj.debug(3, "Using Object '%s' query cache : %s" % [sCloudObj, hQuery])
-               return oList
-            end
-         end
-
-         pProc = Lorj::rhGet(@@meta_obj, sCloudObj, :lambdas, :query_e)
-
-         return nil if pProc.nil?
-
-         # Check required parameters
-         oObjMissing = _check_required(sCloudObj, :query_e, pProc).reverse
-
-         while oObjMissing.length >0
-            sElem = oObjMissing.pop
-            raise Lorj::PrcError.new(),"Unable to create Object '%s'" % sElem if not Create(sElem)
-            oObjMissing = _check_required(sCloudObj, :query_e, pProc).reverse
-            raise Lorj::PrcError.new(), "loop detection: '%s' is required but Query(%s) did not loaded it." % [sElem, sElem] if oObjMissing.include?(sElem)
-         end
-         @RuntimeContext[:oCurrentObj] = sCloudObj # Context: Default object used.
-
-         # build Function params to pass to the Process Event handler.
-         aParams = _get_object_params(sCloudObj, :query_e, pProc)
-
-         # Call the process function.
-         # At some point, the process will call the controller, via the framework.
-         # This controller call via the framework has the role to
-         # create an ObjectData well formatted, with _return_map function
-         # See Definition.connect/create/update/query/get functions (lowercase)
-         oObject = @oForjProcess.method(pProc).call(sCloudObj, hQuery, aParams)
-         # return usually is the main object that the process called should provide.
-         unless oObject.nil?
-            # Save Object if the object has been created by the process, without controller
-            @ObjectData.add(oObject)
-         else
-            PrcLib::warning("'%s' returned no collection of objects Lorj::Data for '%s'" % [pProc, sCloudObj])
-         end
-      end
-
-      # Function to execute a get process. This function returns a Lorj::Data of type :object.
-      #
-      # * *Args* :
-      #   - +ObjectType+ : Meta object type to query.
-      #   - +UniqId+     : Uniq ID.
-      #   - +Config+     : Optional. Hash containing list of data to use for getting.
-      #
-      # * *Returns* :
-      #   Lorj::Data of type :object
-      #
-      # * *Raises* :
-      #   - Warning if the Config data passed are not required by the meta object (or dependencies) at creation time.
-      #   - Error if ObjectType has never been declared.
-      #   - Error if the dependencies get_e process handler did not return any data. (nil) - Loop detection.
-      #   - Error if the get_e process handler raise an error.
-      #
-      def Get(sCloudObj, sUniqId, hConfig = {})
-
-         return nil if not sCloudObj
-
-         raise Lorj::PrcError.new(), "$s.Get: '%s' is not a known object type." % [self.class, sCloudObj] if Lorj::rhExist?(@@meta_obj, sCloudObj) != 1
-
-         if hConfig.length > 0
-            # cleanup runtime data to avoid conflicts between multiple calls
-            valid_keys = _identify_data(sCloudObj, :get_e)
-            valid_keys.each { | sKey|
-               value = Lorj::rhGet(hConfig, sKey)
-               @oForjConfig[sKey] = value if not @oForjConfig.exist?(sKey) or @oForjConfig.exist?(sKey) == 'runtime'
-               Lorj::rhSet(hConfig, nil, sKey)
-            }
-            if hConfig.length > 0
-               Lorj::warning("'%s' has been passed but not declared to '%s' object. Those are ignored until you add it in the model definition of '%s'" % [hConfig.keys, sCloudObj, sCloudObj])
-            end
-         end
-
-         pProc = Lorj::rhGet(@@meta_obj, sCloudObj, :lambdas, :get_e)
-
-         return nil if pProc.nil?
-
-         # Check required parameters
-         oObjMissing = _check_required(sCloudObj, :get_e, pProc).reverse
-
-         while oObjMissing.length >0
-            sElem = oObjMissing.pop
-            raise Lorj::PrcError.new(),"Unable to create Object '%s'" % sElem if not Create(sElem)
-            oObjMissing = _check_required(sCloudObj, :get_e, pProc).reverse
-            raise Lorj::PrcError.new(), "loop detection: '%s' is required but Get(%s) did not loaded it." % [sElem, sElem] if oObjMissing.include?(sElem)
-         end
-         @RuntimeContext[:oCurrentObj] = sCloudObj # Context: Default object used.
-
-         # build Function params to pass to the Process Event handler.
-         aParams = _get_object_params(sCloudObj, :get_e, pProc)
-
-         # Call the process function.
-         # At some point, the process will call the controller, via the framework.
-         # This controller call via the framework has the role to
-         # create an ObjectData well formatted, with _return_map function
-         # See Definition.connect/create/update/query/get functions (lowercase)
-         oObject = @oForjProcess.method(pProc).call(sCloudObj, sUniqId, aParams)
-         # return usually is the main object that the process called should provide.
-         unless oObject.nil?
-            # Save Object if the object has been created by the process, without controller
-            @ObjectData.add(oObject)
-         end
-      end
-
-      # Function to execute a update process. This function returns a Lorj::Data of type :object.
-      #
-      # * *Args* :
-      #   - +ObjectType+ : Meta object type to query.
-      #   - +Config+     : Optional. Hash containing list of data to use for updating.
-      #
-      # * *Returns* :
-      #   Lorj::Data of type :object
-      #
-      # * *Raises* :
-      #   - Warning if the Config data passed are not required by the meta object (or dependencies) at creation time.
-      #   - Error if ObjectType has never been declared.
-      #   - Error if the dependencies get_e process handler did not return any data. (nil) - Loop detection.
-      #   - Error if the get_e process handler raise an error.
-      #
-      def Update(sCloudObj, hConfig = {})
-
-         return nil if not sCloudObj
-
-         raise Lorj::PrcError.new(), "$s.Update: '%s' is not a known object type." % [self.class, sCloudObj] if Lorj::rhExist?(@@meta_obj, sCloudObj) != 1
-
-         if hConfig.length > 0
-            # cleanup runtime data to avoid conflicts between multiple calls
-            valid_keys = _identify_data(sCloudObj, :update_e)
-            valid_keys.each { | sKey|
-               value = Lorj::rhGet(hConfig, sKey)
-               @oForjConfig[sKey] = value if not @oForjConfig.exist?(sKey) or @oForjConfig.exist?(sKey) == 'runtime'
-               Lorj::rhSet(hConfig, nil, sKey)
-            }
-            if hConfig.length > 0
-               PrcLib::warning("'%s' has been passed but not declared to '%s' object. Those are ignored until you add it in the model definition of '%s'" % [hConfig.keys, sCloudObj, sCloudObj])
-            end
-         end
-
-         pProc = Lorj::rhGet(@@meta_obj, sCloudObj, :lambdas, :update_e)
-
-         return nil if pProc.nil?
-
-         # Check required parameters
-         oObjMissing = _check_required(sCloudObj, :update_e, pProc).reverse
-
-         while oObjMissing.length >0
-            sElem = oObjMissing.pop
-            raise Lorj::PrcError.new(),"Unable to create Object '%s'" % sElem if not Create(sElem)
-            oObjMissing = _check_required(sCloudObj, :update_e, pProc).reverse
-            raise Lorj::PrcError.new(), "loop detection: '%s' is required but Update(%s) did not loaded it." % [sElem, sElem] if oObjMissing.include?(sElem)
-         end
-         @RuntimeContext[:oCurrentObj] = sCloudObj # Context: Default object used.
-
-         # build Function params to pass to the event handler.
-         aParams = _get_object_params(sCloudObj, :update_e, pProc)
-
-         oObject = @oForjProcess.method(pProc).call(sCloudObj, aParams)
-         # return usually is the main object that the process called should provide.
-         unless oObject.nil?
-            # Save Object if the object has been created by the process, without controller
-            @ObjectData.add(oObject)
-         end
-      end
-
-      # Function to execute a setup process.
-      # The setup process will ask the end user to enter values as defined by the defaults.yaml application defaults.
-      # For setup features implemented, see Lorj::BaseDefinition::meta_data class variable definition.
-      #
-      # Setup by default, will ask any kind of data required by a meta object and all dependencies.
-      # If the setup needs to add some extra fields to ask to the user, set it in /:setup/:ask_step/*:add/* section
-      #
-      # Setup uses a Config model object which requires to have at least following functions:
-      # - value = get(key, default)
-      # - set(key, value)
-      #
-      # Setup keep end user data in memory. After setup, you HAVE to save them
-      # If you are using Lorj::Account, use function ac_save
-      # If you are using Lorj::Config, use function configSave
-      #
-      # * *Args* :
-      #   - +ObjectType+ : Meta object type to query.
-      #   - +Config+     : Optional. Hash containing list of data to use for updating.
-      #
-      # * *Returns* :
-      #   Lorj::Data of type :object
-      #
-      # * *Raises* :
-      #
-      def Setup(sObjectType, sAccountName)
-         # Loop in dependencies to get list of data object to setup
-         raise Lorj::PrcError,new(), "Setup: '%s' not a valid object type." if Lorj::rhExist?(@@meta_obj, sObjectType) != 1
-
-         hAskStep = Lorj::Default.get(:ask_step, :setup)
-         aSetup = []
-         hAskStep.each{ | value |
-            aSetup << {
-               :desc => value[:desc],
-               :explanation => value[:explanation],
-               :pre_step_handler => value[:pre_step_function],
-               :order => [[]],
-               :post_step_handler => value[:post_step_function]
-            }
-
-         }
-         oInspectedObjects = []
-         oInspectObj = [sObjectType]
-
-         @oForjConfig.ac_load(sAccountName) if sAccountName
-
-         Lorj.debug(2, "Setup is identifying account data to ask for '%s'" % sObjectType)
-         while oInspectObj.length() >0
-            # Identify data to ask
-            # A data to ask is a data needs from an object type
-            # which is declared in section of defaults.yaml
-            # and is declared :account to true (in defaults.yaml or in process declaration - define_data)
-
-            sObjectType = oInspectObj.pop
-            sAsk_step = 0
-            Lorj.debug(1, "Checking '%s'" % sObjectType)
-            hTopParams = Lorj::rhGet(@@meta_obj,sObjectType, :params)
-            if hTopParams[:keys].nil?
-               Lorj.debug(1, "Warning! Object '%s' has no data/object needs. Check the process" % sObjectType)
-               next
-            end
-            hTopParams[:keys].each { |sKeypath, hParams|
-               oKeyPath = KeyPath.new(sKeypath)
-               sKey = oKeyPath.sKey
-               case hParams[:type]
-                  when :data
-                     hMeta = _get_meta_data(sKey)
-                     next if hMeta.nil?
-                     sAsk_step = hMeta[:ask_step] if Lorj::rhExist?(hMeta, :ask_step) == 1 and hMeta[:ask_step].is_a?(Fixnum)
-                     Lorj.debug(3, "#{sKey} is part of setup step #{sAsk_step}")
-                     aOrder = aSetup[sAsk_step][:order]
-
-                     if oInspectedObjects.include?(sKey)
-                        Lorj.debug(2, "#{sKey} is already asked. Ignored.")
-                        next
-                     end
-                     if hMeta[:account].is_a?(TrueClass)
-                        if not hMeta[:depends_on].is_a?(Array)
-                           PrcLib.warning("'%s' depends_on definition have to be an array." % oKeyPath.sFullPath) unless hMeta[:depends_on].nil?
-                           iLevel = 0
-                           bFound = true
-                        else
-                           # Searching highest level from dependencies.
-                           bFound = false
-                           iLevel = 0
-                           hMeta[:depends_on].each { |depend_key|
-                              aOrder.each_index { |iCurLevel|
-                                 if aOrder[iCurLevel].include?(depend_key)
-                                    bFound = true
-                                    iLevel = [iLevel, iCurLevel + 1].max
-                                 end
-                              }
-                                 aOrder[iLevel] = [] if aOrder[iLevel].nil?
-                           }
-                        end
-                        if bFound
-                           if not aOrder[iLevel].include?(sKey)
-                              if hMeta[:ask_sort].is_a?(Fixnum)
-                                 iOrder = hMeta[:ask_sort]
-                                 if aOrder[iLevel][iOrder].nil?
-                                    aOrder[iLevel][iOrder] = sKey
-                                 else
-                                    aOrder[iLevel].insert(iOrder, sKey)
-                                 end
-                                 Lorj.debug(3, "S%s/L%s/O%s: '%s' added in setup list. " % [sAsk_step, iLevel, iOrder, sKey])
-                              else
-                                 aOrder[iLevel] << sKey
-                                 Lorj.debug(3, "S%s/L%s/Last: '%s' added in setup list." % [sAsk_step, iLevel, sKey])
-                              end
-                           end
-                        end
-                        oInspectedObjects << sKey
-                     else
-                        Lorj.debug(2, "#{sKey} used by #{sObjectType} won't be asked during setup. :account = true not set.")
-                     end
-                  when :CloudObject
-                     oInspectObj << sKey if not oInspectObj.include?(sKey) and not oInspectedObjects.include?(sKey)
-               end
-            }
-            oInspectedObjects << sObjectType
-         end
-         Lorj.debug(2, "Setup check if needs to add unrelated data in the process")
-         hAskStep.each_index{ | iStep |
-            value = hAskStep[iStep]
-            if Lorj::rhExist?(value, :add) == 1
-               sKeysToAdd = Lorj::rhGet(value, :add)
-               sKeysToAdd.each { | sKeyToAdd |
-                  bFound = false
-                  aSetup[iStep][:order].each_index { | iOrder |
-                     sKeysToAsk = aSetup[iStep][:order][iOrder]
-                     unless sKeysToAsk.index(sKeyToAdd).nil?
-                        bFound = true
-                        break
-                     end
-                  }
-                  next if bFound
-                  iLevel = 0
-                  iOrder = aSetup[iStep][:order].length
-                  iAtStep = iStep
-                  hMeta = _get_meta_data(sKeyToAdd)
-                  if Lorj::rhExist?(hMeta, :after) == 1
-                     sAfterKeys = hMeta[:after]
-                     sAfterKeys = [ sAfterKeys ] if not sAfterKeys.is_a?(Array)
-                     sAfterKeys.each{ |sAfterKey |
-                        bFound = false
-                        aSetup.each_index { |iStepToCheck|
-                           aSetup[iStepToCheck][:order].each_index { | iLevelToCheck |
-                              sKeysToAsk = aSetup[iStepToCheck][:order][iLevelToCheck]
-                              iOrderToCheck = sKeysToAsk.index(sAfterKey)
-                              unless iOrderToCheck.nil?
-                                 iAtStep = iStepToCheck if iStepToCheck > iAtStep
-                                 iLevel = iLevelToCheck if iLevelToCheck > iLevel
-                                 iOrder = iOrderToCheck + 1 if iOrderToCheck + 1 > iOrder
-                                 bFound = true
-                                 break
-                              end
-                           }
-                        }
-                     }
-                  end
-                  aSetup[iAtStep][:order][iLevel].insert(iOrder, sKeyToAdd)
-                  Lorj.debug(3, "S%s/L%s/O%s: '%s' added in setup list at  position." % [iAtStep, iLevel, iOrder, sKeyToAdd])
-               }
-            end
-         }
-
-         Lorj.debug(2, "Setup will ask for :\n %s" % aSetup.to_yaml)
-
-         PrcLib.info("Configuring account : '#{config[:account_name]}', provider '#{config[:provider_name]}'")
-
-         # Ask for user input
-         aSetup.each_index { | iStep |
-            Lorj.debug(2, "Ask step %s:" % iStep)
-            puts "%s%s%s" % [ANSI.bold, aSetup[iStep][:desc], ANSI.clear] unless aSetup[iStep][:desc].nil?
-            begin
-              puts "%s\n\n" % ANSI.yellow(erb(aSetup[iStep][:explanation])) unless aSetup[iStep][:explanation].nil?
-            rescue => e
-               PrcLib.Error "setup step '%d/:explanation' : %s" % [iStep, e.message]
-            end
-            aOrder = aSetup[iStep][:order]
-            aOrder.each_index { | iIndex |
-            Lorj.debug(2, "Ask order %s:" % iIndex)
-               aOrder[iIndex].each { | sKey |
-                  hParam = _get_meta_data(sKey)
-                  hParam = {} if hParam.nil?
-
-                  bOk = false
-
-                  if hParam[:pre_step_function]
-                     pProc = hParam[:pre_step_function]
-                     bOk = not(@oForjProcess.method(pProc).call(sKey))
-                  end
-
-
-                  sDesc = "'%s' value" % sKey
-                  begin
-                     puts "#{sKey}: %s" % [erb(hParam[:explanation])] unless hParam[:explanation].nil?
-                  rescue => e
-                     PrcLib.Error "setup key '%s/:explanation' : %s" % [sKey, e.message]
-                  end
-                  begin
-                     sDesc = erb(hParam[:desc]) unless hParam[:desc].nil?
-                  rescue => e
-                     PrcLib.Error "setup key '%s/:desc' : %s" % [sKey, e.message]
-                  end
-                  sDefault = @oForjConfig.get(sKey, hParam[:default_value])
-                  rValidate = nil
-
-                  rValidate = hParam[:validate] unless hParam[:validate].nil?
-                  bRequired = (hParam[:required] == true)
-                  while not bOk
-                     bOk = true
-                     if not hParam[:list_values].nil?
-                        hValues = hParam[:list_values]
-                        sObjectToLoad = hValues[:object]
-
-                        bListStrict = (hValues[:validate] == :list_strict)
-
-                        case hValues[:query_type]
-                           when :controller_call
-                              oObject = @ObjectData[sObjectToLoad, :ObjectData]
-                              PrcLib.message("Loading #{sObjectToLoad}.")
-                              oObject = Create(sObjectToLoad) if oObject.nil?
-                              return nil if oObject.nil?
-                              oParams = ObjectData.new
-                              oParams.add(oObject)
-                              oParams << hValues[:query_params]
-                              raise Lorj::PrcError.new(), "#{sKey}: query_type => :controller_call requires missing :query_call declaration (Controller function)" if hValues[:query_call].nil?
-                              pProc = hValues[:query_call]
-                              begin
-                                 aList = @oProvider.method(pProc).call(sObjectToLoad, oParams)
-                              rescue => e
-                                 raise Lorj::PrcError.new(), "Error during call of '%s':\n%s" % [pProc, e.message]
-                              end
-                           when :query_call
-                              sQuery = {}
-                              sQuery = hValues[:query_params] unless hValues[:query_params].nil?
-                              PrcLib.message("Querying #{sObjectToLoad}.")
-                              oObjectList = Query(sObjectToLoad, sQuery)
-                              aList = []
-                              oObjectList.each { | oElem |
-                                 aList << oElem[hValues[:value]]
-                              }
-                              aList.sort!
-                           when :process_call
-                              raise Lorj::PrcError.new(), "#{sKey}: query_type => :process_call requires missing :query_call declaration (Provider function)" if hValues[:query_call].nil?
-                              pProc = hValues[:query_call]
-                              sObjectToLoad = hValues[:object]
-
-                              # Building Process function hParams parameter
-                              oParams = ObjectData.new
-                              oParams << { default_value: sDefault }
-
-                              unless hValues[:query_params].nil?
-                                 hValues[:query_params].each { | key, value |
-                                   if mRes = value.match(/lorj::config\[(.*)\]/)
-                                      aExtract = mRes[1].split(', ')
-                                      aExtract.map! { | v | v = v[1..-1].to_sym if v[0] == ':' }
-                                      oParams << { key => config[aExtract] }
-                                   else
-                                      oParams << { key => value }
-                                   end
-                                 }
-                              end
-
-                              begin
-                                 hProcResult = @oForjProcess.method(pProc).call(sObjectToLoad, oParams)
-                              rescue => e
-                                 raise Lorj::PrcError.new(), "Error during call of '%s':\n%s" % [pProc, e.message]
-                              end
-
-                              if hProcResult.is_a?(Hash)
-                                 sDefault = hProcResult[:default_value].nil? ? sDefault : hProcResult[:default_value]
-                                 if hProcResult[:list].nil? or ! hProcResult[:list].is_a?(Array)
-                                    PrcLib.debug("Process function '%s' did not return an :list => Array of values." % [ hValues[:query_call] ])
-                                 else
-                                    aList = hProcResult[:list]
-                                 end
-                              else
-                                 PrcLib.debug("Process function '%s' did not return an Hash with :list and :default_value")
-                                 aList = []
-                              end
-                           else
-                              raise Lorj::PrcError.new, "'%s' invalid. %s/list_values/values_type supports %s. " % [hValues[:values_type], sKey, [:provider_function]]
-                        end
-                        PrcLib.fatal(1, "%s requires a value from the '%s' query which is empty." % [sKey, sObjectToLoad])if aList.nil? and bListStrict
-                        aList = [] if aList.nil?
-                        if not bListStrict
-                           aList << "other"
-                        end
-                        say("Enter %s" % ((sDefault.nil?)? sDesc : sDesc + " |%s|" % sDefault))
-                        value = choose { | q |
-                           q.choices(*aList)
-                           q.default = sDefault if sDefault
-                        }
-                        if not bListStrict and value == "other"
-                           value = _ask(sDesc, sDefault, rValidate, hParam[:encrypted], bRequired)
-                        end
-                     else
-                        pValidateProc = hParam[:validate_function]
-                        pAskProc = hParam[:ask_function]
-
-                        if pAskProc.nil?
-                           unless pValidateProc.nil?
-                              value = _ask(sDesc, sDefault, rValidate, hParam[:encrypted], bRequired)
-                              while not @oForjProcess.method(pValidateProc).call(value)
-                                 value = _ask(sDesc, sDefault, rValidate, hParam[:encrypted], bRequired)
-                              end
-                           else
-                              value = _ask(sDesc, sDefault, rValidate, hParam[:encrypted], bRequired)
-                           end
-                        else
-                           unless pValidateProc.nil?
-                              value = @oForjProcess.method(pAskProc).call(sDesc, sDefault, rValidate, hParam[:encrypted], bRequired)
-                              while not @oForjProcess.method(pValidateProc).call(value)
-                                 value = @oForjProcess.method(pAskProc).call(sDesc, sDefault, rValidate, hParam[:encrypted], bRequired)
-                              end
-                           else
-                              value = @oForjProcess.method(pAskProc).call(sDesc, sDefault, rValidate, hParam[:encrypted], bRequired)
-                           end
-                        end
-                     end
-
-                     @oForjConfig.set(sKey, value)
-                     if hParam[:post_step_function]
-                        pProc = hParam[:post_step_function]
-                        bResult = @oForjProcess.method(pProc).call()
-                        if bResult.boolean?
-                           bOk = bResult
-                        else
-                           PrcLib.debug("Warning: '%s' did not return any boolean value. Ignored" % [pProc])
-                        end
-                     end
-                  end
-               }
-            }
-         }
-      end
-
-      # Initialize Lorj BaseDefinition object
-
-      def initialize(oForjConfig, oForjProcess, oForjProvider = nil)
-         # Object Data object. Contains all loaded object data.
-         # This object is used to build hParams as well.
-         @ObjectData = ObjectData.new(true)
-         #
-         @RuntimeContext = {
-            :oCurrentObj => nil
-         }
-
-         @oForjConfig = oForjConfig
-         @oERBConfig = ERBConfig.new(oForjConfig)
-         raise Lorj::PrcError.new(), "'%s' is not a valid ForjAccount or ForjConfig Object." % [oForjConfig.class] if not oForjConfig.is_a?(Lorj::Account) and not oForjConfig.is_a?(Lorj::Config)
-
-         @oProvider = oForjProvider
-         if oForjProvider
-            raise Lorj::PrcError.new(), "'%s' is not a valid ForjProvider Object type." % [oForjProvider.class] if not oForjProvider.is_a?(BaseController)
-         end
-
-         @oForjProcess = oForjProcess
-         raise Lorj::PrcError.new(), "'%s' is not a valid BaseProcess Object type." % [oForjProcess.class] if not oForjProcess.is_a?(BaseProcess)
-
-         @oForjProcess.set_BaseObject(self)
-      end
-
-      # ------------------------------------------------------
-      # Functions used by processes functions
-      # ------------------------------------------------------
-      # Ex: object.set_data(...)
-      #     config
-
-
-      # Function to manipulate the config object.
-      # 2 kind of functions:
-      # - set (key, value) and []=(key, value)
-      #   From processes, you can set a runtime data with:
-      #     config.set(key, value)
-      #   OR
-      #     config[key] = value
-      #
-      # - get (key, default) and [](key, default)
-      #   default is an optional value.
-      #   From processes, you can get a data (runtime/account/config.yaml or defaults.yaml) with:
-      #     config.get(key)
-      #   OR
-      #     config[key]
-
-      def config
-         raise Lorj::PrcError.new(), "No config object loaded." if not @oForjConfig
-         @oForjConfig
-      end
-
-      def format_query(sObjectType, oControlerObject, hQuery)
-         {
-            :object        => oControlerObject,
-            :object_type   => :object_list,
-            :list_type     => sObjectType,
-            :list          => [],
-            :query         => hQuery
-         }
-      end
-
-      def format_object(sCloudObj, oMiscObject)
-         return nil if not sCloudObj or not [String, Symbol].include?(sCloudObj.class)
-
-         sCloudObj = sCloudObj.to_sym if sCloudObj.class == String
-
-         oCoreObject = {
-            :object_type => sCloudObj,
-            :attrs => {},
-            :object => oMiscObject,
-         }
-      end
-
-      def get_data_metadata(sKey)
-         _get_meta_data(sKey)
-      end
-
-      # Before doing a query, mapping fields
-      # Transform Object query field to Provider query Fields
-      def query_map(sCloudObj, hParams)
-         return nil if not sCloudObj or not [String, Symbol].include?(sCloudObj.class)
-         return {} if not hParams
-
-         sCloudObj = sCloudObj.to_sym if sCloudObj.class == String
-
-         hReturn = {}
-         hMap = Lorj::rhGet(@@meta_obj, sCloudObj, :query_mapping)
-         hParams.each { |key, value|
-            oKeyPath = KeyPath.new(key)
-            sKeyPath = oKeyPath.sFullPath
-            raise Lorj::PrcError.new(), "Forj query field '%s.%s' not defined by class '%s'.\n"  % [sCloudObj, oKeyPath.sKey, self.class ] +
-               "#{ANSI.bold}ACTION REQUIRED#{ANSI.clear}:\n" +
-               "Missing data model 'def_attribute' or 'def_query_attribute' for '%s'??? Check the object '%s' data model." % [oKeyPath.sKey, sCloudObj] if not hMap.key?(oKeyPath.sFullPath)
-            oMapPath = KeyPath.new(hMap[oKeyPath.sFullPath])
-            hValueMapping = Lorj::rhGet(@@meta_obj, sCloudObj, :value_mapping, sKeyPath)
-            if hValueMapping
-               raise Lorj::PrcError.new(), "'%s.%s': No value mapping for '%s'" % [sCloudObj, oKeyPath.sKey, value] if Lorj::rhExist?(hValueMapping, value) != 1
-
-               Lorj::rhSet(hReturn, hValueMapping[value], oMapPath.aTree)
-            else
-               Lorj::rhSet(hReturn, value, oMapPath.aTree)
-            end
-         }
-         hReturn
-      end
-
-      # Obsolete. Used by the Process.
-      # Ask controller get_attr to get a data
-      # The result is the data of a defined data attribute.
-      # If the value is normally mapped (value mapped), the value is
-      # returned as a recognized data attribute value.
-      def get_attr(oObject, key)
-
-         raise Lorj::PrcError.new(), "'%s' is not a valid Object type. " % [oObject.class] if not oObject.is_a?(Hash) and Lorj::rhExist?(oObject, :object_type) != 1
-         sCloudObj = oObject[:object_type]
-         oKeyPath = KeyPath.new(key)
-         raise Lorj::PrcError.new(), "'%s' key is not declared as data of '%s' CloudObject. You may need to add obj_needs..." % [oKeyPath.sKey, sCloudObj] if Lorj::rhExist?(@@meta_obj, sCloudObj, :returns, oKeyPath.sFullPath) != 3
-         begin
-            oMapPath = KeyPath.new Lorj::rhGet(@@meta_obj, sCloudObj, :returns, oKeyPath.sFullPath)
-            hMap = oMapPath.sFullPath
-            value = @oProvider.get_attr(get_cObject(oObject), hMap)
-
-            hValueMapping = Lorj::rhGet(@@meta_obj, sCloudObj, :value_mapping, oKeyPath.sFullPath)
-
-            if hValueMapping
-               hValueMapping.each { | found_key, found_value |
-                  if found_value == value
-                     value = found_key
-                     break
-                  end
-               }
-            end
-         rescue => e
-            raise Lorj::PrcError.new(), "'%s.get_attr' fails to provide value of '%s'" % [oProvider.class, key]
-         end
-      end
-
-      # Register the object to the internal @ObjectData instance
-      def register(oObject, sObjectType = nil, sDataType = :object)
-         if oObject.is_a?(Lorj::Data)
-            oDataObject = oObject
-         else
-            raise Lorj::PrcError.new(), "Unable to register an object '%s' as Lorj::Data object if ObjectType is not given." % [ oObject.class ] if not sObjectType
-            oDataObject = Lorj::Data.new(sDataType)
-            oDataObject.set(oObject, sObjectType) { | sObjType, oControlerObject |
-               _return_map(sObjType, oControlerObject)
-            }
-         end
-         @ObjectData.add oDataObject
-      end
-
-      def DataObjects(sObjectType, *key)
-         @ObjectData[sObjectType, key]
-      end
-
-      # get an attribute/object/... from an object.
-      def get_data(oObj, *key)
-         if oObj.is_a?(Hash) and oObj.key?(:object_type)
-            oObjData = ObjectData.new
-            oObjData << oObj
-         else
-            oObjData = @ObjectData
-         end
-         oObjData[oObj, *key]
-      end
-
-      #~ def hParams(sCloudObj, hParams)
-         #~ aParams = _get_object_params(sCloudObj, ":ObjectData.hParams")
-      #~ end
-
-      def get_cObject(oObject)
-         return nil if Lorj::rhExist?(oObject, :object) != 1
-         Lorj::rhGet(oObject, :object)
-      end
-
-      # a Process can execute any kind of predefined controler task.
-      # Those function build hParams with Provider compliant data (mapped)
-      # Results are formatted as usual framework Data object and stored.
-      def connect(sObjectType)
-
-         hParams = _get_object_params(sObjectType, :create_e, :connect, true)
-         oControlerObject = @oProvider.connect(sObjectType, hParams)
-         oDataObject = Lorj::Data.new
-         oDataObject.set(oControlerObject, sObjectType) { | sObjType, oObject |
-            begin
-               _return_map(sObjType, oObject)
-            rescue => e
-               raise Lorj::PrcError.new(), "connect %s.%s : %s" % [@oForjProcess.class, sObjectType, e.message]
-            end
-         }
-         @ObjectData.add oDataObject
-         oDataObject
-      end
-
-      def create(sObjectType)
-         # The process ask the controller to create the object.
-         # hParams have to be fully readable by the controller.
-         hParams = _get_object_params(sObjectType, :create_e, :create, true)
-         oControlerObject = @oProvider.create(sObjectType, hParams)
-         oDataObject = Lorj::Data.new
-         oDataObject.set(oControlerObject, sObjectType) { | sObjType, oObject |
-            begin
-               _return_map(sObjType, oObject)
-            rescue => e
-               raise Lorj::PrcError.new(), "create %s.%s : %s" % [@oForjProcess.class, sObjectType, e.message]
-            end
-         }
-         @ObjectData.add oDataObject
-
-         oDataObject
-      end
-
-      # The controller must return true to inform about the real deletion
-      def delete(sObjectType)
-         hParams = _get_object_params(sObjectType, :delete_e, :delete, true)
-         raise Lorj::PrcError.new(), "delete Controller - %s: Object '%s' is not loaded." % [@oProvider.class, key] if not hParams.exist?(sObjectType)
-         bState = @oProvider.delete(sObjectType, hParams)
-         @ObjectData.delete(sObjectType) if bState
-         bState
-      end
-
-      def get(sObjectType, sUniqId)
-
-         hParams = _get_object_params(sObjectType, :get_e, :get, true)
-
-         oControlerObject = @oProvider.get(sObjectType, sUniqId, hParams)
-         oDataObject = Lorj::Data.new
-         oDataObject.set(oControlerObject, sObjectType) { | sObjType, oObject |
-            begin
-               _return_map(sObjType, oObject)
-            rescue => e
-               raise Lorj::PrcError.new(), "get %s.%s : %s" % [@oForjProcess.class, sObjectType, e.message]
-            end
-         }
-         @ObjectData.add oDataObject
-
-         oDataObject
-      end
-
-      def query(sObjectType, hQuery)
-
-         # Check if we can re-use a previous query
-         oList = @ObjectData[:query, sObjectType]
-         unless oList.nil?
-            if oList[:query] == hQuery
-               Lorj.debug(3, "Using Object '%s' query cache : %s" % [sObjectType, hQuery])
-               return oList
-            end
-         end
-
-
-         hParams = _get_object_params(sObjectType, :query_e, :query, true)
-         sProviderQuery = query_map(sObjectType, hQuery)
-
-         oControlerObject = @oProvider.query(sObjectType, sProviderQuery, hParams)
-
-         oDataObjects = Lorj::Data.new :list
-         oDataObjects.set(oControlerObject, sObjectType, hQuery) { | sObjType, key |
-            begin
-               _return_map(sObjType, key)
-            rescue => e
-               raise Lorj::PrcError.new(), "query %s.%s : %s" % [@oForjProcess.class, sObjectType, e.message]
-            end
-         }
-
-         Lorj.debug(2, "Object %s - queried. Found %s object(s)." % [sObjectType, oDataObjects.length()])
-
-         @ObjectData.add oDataObjects
-         oDataObjects
-      end
-
-      def update(sObjectType)
-         # Need to detect data updated and update the Controler object with the controler
-
-         hParams = _get_object_params(sObjectType, :update_e, :update, true)
-
-         oObject = @ObjectData[sObjectType, :ObjectData]
-         oControlerObject = oObject[:object]
-
-         bUpdated = false
-         oObject[:attrs].each { |key, value |
-            oKeyPath = KeyPath.new(key)
-            oMapPath = KeyPath.new Lorj::rhGet(@@meta_obj, sObjectType, :returns, oKeyPath.sFullPath)
-            old_value = @oProvider.get_attr(oControlerObject, oMapPath.aTree)
-            if value != old_value
-               bUpdated = true
-               @oProvider.set_attr(oControlerObject, oMapPath.aTree, value)
-               Lorj.debug(2, "%s.%s - Updating: %s = %s (old : %s)" % [@oForjProcess.class, sObjectType, key, value, old_value])
-            end
-         }
-
-         bDone = @oProvider.update(sObjectType, oObject, hParams) if bUpdated
-
-         raise Lorj::PrcError.new, "Controller function 'update' must return True or False. Class returned: '%s'" % bDone.class if not [TrueClass, FalseClass].include?(bDone.class)
-
-         Lorj.debug(1, "%s.%s - updated." % [@oForjProcess.class, sObjectType]) if bDone
-         oObject.set(oControlerObject, sObjectType) { | sObjType, oObject |
-            begin
-               _return_map(sObjType, oObject)
-            rescue => e
-               raise Lorj::PrcError.new(), "update %s.%s : %s" % [@oForjProcess.class, sObjectType, e.message]
-            end
-         }
-         bDone
-      end
-
-      private
-
-      # -------------------------------------------------------------------------
-      # Functions available for Process to communicate with the controler Object
-      # -------------------------------------------------------------------------
-      def cloud_obj_requires(sCloudObj, res = {})
-         aCaller = caller
-         aCaller.pop
-
-         return res if @ObjectData.exist?(sCloudObj)
-         #~ return res if Lorj::rhExist?(@CloudData, sCloudObj) == 1
-
-         Lorj::rhGet(@@meta_obj,sCloudObj, :params).each { |key, hParams|
-            case hParams[:type]
-               when :data
-                  if  hParams.key?(:array)
-                     hParams[:array].each{ | aElem |
-                        aElem = aElem.clone
-                        aElem.pop # Do not go until last level, as used to loop next.
-                        Lorj::rhGet(hParams, aElem).each { | subkey, hSubParam |
-                           next if aElem.length == 0 and [:array, :type].include?(subkey)
-                           if hSubParams[:required] and @oForjConfig.get(subkey).nil?
-                              res[subkey] = hSubParams
-                           end
-                        }
-                     }
-                  else
-                     if hParams[:required] and @oForjConfig.get(key).nil?
-                        res[key] = hParams
-                     end
-                  end
-               when :CloudObject
-                  #~ if hParams[:required] and Lorj::rhExist?(@CloudData, sCloudObj) != 1
-                  if hParams[:required] and not @ObjectData.exist?(sCloudObj)
-                     res[key] = hParams
-                     cloud_obj_requires(key, res)
-                  end
-            end
-         }
-         res
-      end
-
-      def get_object(sCloudObj)
-         #~ return nil if Lorj::rhExist?(@CloudData, sCloudObj) != 1
-         return nil if not @ObjectData.exist?(sCloudObj)
-         @ObjectData[sCloudObj, :ObjectData]
-         #~ Lorj::rhGet(@CloudData, sCloudObj)
-      end
-
-      def objectExist?(sCloudObj)
-         @ObjectData.exist?(sCloudObj)
-         #~ (Lorj::rhExist?(@CloudData, sCloudObj) != 1)
-      end
-
-      def get_forjKey(oCloudData, key)
-         return nil if not @ObjectData.exist?(sCloudObj)
-         @ObjectData[sCloudObj, :attrs, key]
-         #~ return nil if Lorj::rhExist?(oCloudData, sCloudObj) != 1
-         #~ Lorj::rhGet(oCloudData, sCloudObj, :attrs, key)
-      end
-   end
-end