eco-helpers 1.5.0 → 1.5.1

data/lib/eco/api/microcases/fix_filter_tags.rb

@@ -0,0 +1,22 @@
+module Eco
+  module API
+    class MicroCases
+      #self.define(:fix_filter_tags) do |entry, person, options|
+
+      # @param person [Person] the person we want to update, carrying the changes to be done.
+      # @param options [Hash] the options
+      def fix_filter_tags(person, options)
+        if session.tagtree
+          unless !person.new? && (options.dig(:exclude, :core) || options.dig(:exclude, :filter_tags))
+            person.filter_tags = session.tagtree.user_tags(
+              initial:          person.original_doc["filter_tags"] || [],
+              final:            person.filter_tags,
+              preserve_custom:  true,
+              add_custom:       true
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eco/api/microcases/set_account.rb

@@ -0,0 +1,32 @@
+module Eco
+  module API
+    class MicroCases
+      #self.define("set_account") do |entry, person, session, options|
+
+      # @param entry [PersonEntry] the input entry with the data we should set on person.
+      # @param person [Person] the person we want to update, carrying the changes to be done.
+      # @param options [Hash] the options
+      def set_account(entry, person, options)
+        unless options.dig(:exclude, :account)
+          ini_pg_ids  = person.account&.policy_group_ids || []
+
+          account_excluded = []
+          if options.dig(:exclude, :policy_groups) && !person.new?
+            account_excluded.push("policy_group_ids")
+          end
+
+          entry.set_account(person, exclude: account_excluded)
+
+          session.microcases.set_default_group(entry, person, session, options)
+
+          unless options.dig(:exclude, :abilities) && !person.new?
+            person.account.permissions_custom = session.new_preset(person)
+          end
+
+          session.microcases.set_default_tag(entry, person, session, options)
+          person.account.send_invites = options[:send_invites] if options.key?(:send_invites)
+        end
+      end
+    end
+  end
+end

data/lib/eco/api/microcases/set_core.rb

@@ -0,0 +1,18 @@
+module Eco
+  module API
+    class MicroCases
+      #self.define("set_core") do |entry, person, session, options, people, supers|
+
+      # @param entry [PersonEntry] the input entry with the data we should set on person.
+      # @param person [Person] the person we want to update, carrying the changes to be done.
+      # @param options [Hash] the options
+      def set_account(entry, person, options, people, supers_job)
+        unless options.dig(:exclude, :core) && !person.new?
+          entry.set_core(person, exclude: micro.core_excluded(person, options))
+          micro.fix_filter_tags(person, options)
+          micro.set_supervisor(entry, person, options, people, supers_job)
+        end
+      end
+    end
+  end
+end

data/lib/eco/api/microcases/set_default_group.rb

@@ -0,0 +1,33 @@
+module Eco
+  module API
+    class MicroCases
+      #self.define("set_default_group") do |entry, person, session, options|
+
+      # @param entry [PersonEntry] the input entry with the data we should set on person.
+      # @param person [Person] the person we want to update, carrying the changes to be done.
+      # @param options [Hash] the options
+      def set_default_group(entry, person, options)
+        unless options.dig(:exclude, :account)
+          unless options.dig(:exclude, :policy_groups) && !person.new?
+            end_pg_ids = person.account.policy_group_ids || []
+
+            if person.account_added? && def_usergroup_id && !entry.policy_group_ids?
+              # on account creation, if missing policy_group_ids column in the input
+              # use default_usergroup, if it's defined
+              end_pg_ids = [def_usergroup_id]
+            end
+
+            person.account.policy_group_ids = end_pg_ids
+          end
+        end
+      end
+
+      def def_usergroup_id
+        @def_usergroup_id ||= if session.config.people.default_usergroup?
+          session.policy_groups.to_id(session.config.people.default_usergroup)
+        end
+      end
+
+    end
+  end
+end

data/lib/eco/api/microcases/set_default_tag.rb

@@ -0,0 +1,23 @@
+module Eco
+  module API
+    class MicroCases
+      #self.define("set_default_tag") do |entry, person, session, options|
+
+      # @param entry [PersonEntry] the input entry with the data we should set on person.
+      # @param person [Person] the person we want to update, carrying the changes to be done.
+      # @param options [Hash] the options
+      def set_default_tag(entry, person, options)
+        unless options.dig(:exclude, :account)
+          unless options.dig(:exclude, :filter_tags) || entry.default_tag?
+            if session.tagtree
+              person.account.default_tag = session.tagtree.default_tag(*person.filter_tags)
+            else
+              tags = person.filter_tags || []
+              person.account.default_tag = tags.first unless tags.length > 1
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eco/api/microcases/set_supervisor.rb

@@ -0,0 +1,26 @@
+module Eco
+  module API
+    class MicroCases
+      #self.define("set_supervisor") do |entry, person, session, options, people, supers_job|
+
+      def set_supervisor(entry, person, options, people, supers_job)
+        # set supervisor
+        unless options.dig(:exclude, :core) || options.dig(:exclude, :supervisor)
+          if !(sup_id = entry.supervisor_id)
+            person.supervisor_id = nil
+          else
+            if supervisor = people.person(id: sup_id, external_id: sup_id, email: sup_id)
+              person.supervisor_id = supervisor.id
+            else
+              # delay setting supervisor if does not exit
+              supers_job.add(person) do |person|
+                person.supervisor_id = sup_id
+              end
+            end
+          end
+        end
+      end
+      
+    end
+  end
+end

data/lib/eco/api/microcases/strict_search.rb

@@ -0,0 +1,14 @@
+module Eco
+  module API
+    class MicroCases
+      #self.define("strict_search") do |session, options|
+
+      # @param options [Hash] the options
+      def strict_search(options)
+        strict_config = session.config.people.strict_search?
+        strict_option = !options[:search]&.key?(:strict) || options.dig(:search, :strict)
+        strict_config && strict_option
+      end
+    end
+  end
+end

data/lib/eco/api/organization/presets_values.json

@@ -2,6 +2,7 @@
   "files": [null, "download", "upload", "browse", "administrate"],
   "data": [null, "view", "update", "administrate", "implement"],
   "reports": [null, "view", "edit", "administrate"],
+  "tasks": [null, "reassign_self", "reassign", "administrate"],
   "organization": [null, "view", "administrate", "implement"],
   "person_core": [null, "attach", "view_people_manager", "dashboard"],
   "person_core_create": [null, "create"],

data/lib/eco/api/session.rb

@@ -86,19 +86,17 @@ module Eco
         schema = to_schema(schema) || self.schema
         return @entry_factories[schema&.id] if @entry_factories.key?(schema&.id)
 
-        # TODO: check PersonEntry#to_internal and #to_external in init_attr_trackers
-        # => when attr_map is avoided, it doesn't work as it should
         mappings = []
         if map_file = config.people.fields_mapper
           mappings = map_file ? file_manager.load_json(map_file) : []
         end
 
-        @entry_factories[schema&.id] = Eco::API::Common::People::EntryFactory.new({
+        @entry_factories[schema&.id] = Eco::API::Common::People::EntryFactory.new(
+          enviro,
           schema:        schema,
           person_parser: config.people.parser,
-          attr_map:      Eco::Data::Mapper.new(mappings),
-          logger:        logger
-        })
+          attr_map:      Eco::Data::Mapper.new(mappings)
+        )
       end
 
       # Helper to obtain a  PersonFactory
@@ -197,6 +195,11 @@ module Eco
         end
       end
 
+      # shortcut to create a job of certain type within a group
+      def new_job(group, name, type, usecase, sets = [:core, :details, :account])
+        job_group(group).new(name, usecase: usecase, type: type, sets: sets)
+      end
+
       def jobs_launch(simulate: false)
         job_groups.launch(simulate: simulate)
       end

data/lib/eco/api/session/batch.rb

@@ -92,50 +92,7 @@ module Eco
           params = {per_page: DEFAULT_BATCH_BLOCK}.merge(params)
           client = people_api.client
 
-          looping = !params.key?(:page)
-          page    = params[:page] || 1
-
-          people = []; total_pages = nil
-          cursor_id = nil
-          loop do
-            params.merge!(cursor_id: cursor_id) unless !cursor_id
-            people_res, response = client_get(client, params: params.merge(page: page), silent: silent)
-            people += people_res
-
-            total_iterations ||= response.body["total_pages"]
-            no_pages           = !response.body["total_pages"]
-            total_results    ||= response.body["total_results"]
-
-            if !total_iterations
-              total_iterations ||= (total_results.to_f / params[:per_page]).ceil
-            end
-
-            msg = "iteration number: #{page}/#{total_iterations}, got num people #{people_res.length}, with total #{people.length} people got"
-            msg = "search(q=#{params[:q]}) " + msg if params.key?(:q)
-            logger.info(msg) unless silent
-
-            iterate = (no_pages && cursor_id = response.body["cursor_id"]) || (looping && page < total_iterations)
-            break unless iterate
-            page += 1
-          end
-
-          return people
-        end
-
-        def client_get(client, params:, silent: false)
-          response = client.get("/people", params: params)
-          unless response.success?
-            msg  = "Request failed - params: #{params}"
-            msg += "\n Error message: - Status #{response.status}: #{response.body}"
-            fatal msg
-          end
-          people = []
-          response.body["results"].each do |person_hash|
-            person = Ecoportal::API::Internal::Person.new(person_hash)
-            yield person if block_given?
-            people.push(person)
-          end
-          [people, response]
+          return people_api.get_all(params: params, silent: silent)
         end
 
         def batch_from(data, method:, params: {}, silent: false)

data/lib/eco/api/session/config.rb

@@ -116,8 +116,8 @@ module Eco
           apis.active_root_name
         end
 
-        def api(logger = ::Logger.new(IO::NULL))
-          apis.api(logger)
+        def api(logger = ::Logger.new(IO::NULL), version: nil)
+          apis.api(logger, version: version)
         end
 
         # FILES

data/lib/eco/api/session/config/api.rb

@@ -4,19 +4,95 @@ module Eco
       class Config
         class Api < Hash
 
-          def initialize(key:, host:, version:, mode: :local, root:)
+          class << self
+
+            def to_version(str)
+              case str.to_sym
+              when :external, :v1
+                :v1
+              when :v2, :oozes
+                :v2
+              else # :internal, :v0
+                :v0
+              end
+            end
+
+            def api_class(version = :v0)
+              case to_version(version)
+              when :v0
+                Ecoportal::API::Internal
+              when :v1
+                Ecoportal::API::V1
+              when :v2
+                Ecoportal::API::V2
+              else
+              end
+            end
+
+          end
+
+          def initialize(name, key:, host:, version:, mode: :local, root:, user_key: nil, external_key: nil)
             super(nil)
             @root = root
-            self["key"]      =  key
-            self["host"]     = host
-            self["version"]  = version
-            self["mode"]     = mode
+            @apis = {}
+            self["name"]         = name
+            self["key"]          = key
+            self["host"]         = host
+            self["version"]      = version
+            self["mode"]         = mode
+            self["user_key"]     = user_key
+            self["external_key"] = external_key
+          end
+
+          def config
+            @root.config
+          end
+
+          def api(version: nil, logger: nil)
+            version = version ? version : self.version
+            @logger = logger if logger
+
+            if (current = get(version)) && self.logger.class == current.logger.class
+              return current
+            end
+
+            unless api_params?(version)
+              raise "The api configuration for '#{name}' is missing data for the api version '#{self.version(version)}'"
+            end
+
+            new_api(version).tap do |pi|
+              set(version, pi)
+            end
+          end
+
+          def set(version, api)
+            @apis[self.version(version)] = api
+          end
+
+          def get(version)
+            @apis[self.version(version)]
+          end
+
+          def name
+            self["name"]
           end
 
           def key
             self["key"]
           end
 
+          def user_key
+            self["user_key"] || @root.default_user_key
+          end
+
+          def external_key
+            self["external_key"] || ([:v1, :v2].include?(version) && key)
+          end
+
+          def internal_key
+            (version == :v0) && self["key"]
+          end
+
           def host
             self["host"]
           end
@@ -37,10 +113,48 @@ module Eco
             !local?
           end
 
-          def version
-            self["version"]
+          def version(value = nil)
+            self.class.to_version(value || self["version"])
           end
 
+          def logger
+            @logger ||= ::Logger.new(IO::NULL)
+            log_connection? ? @logger : ::Logger.new(IO::NULL)
+          end
+
+          private
+
+          def new_api(version)
+            klass = self.class.api_class(version)
+            case self.version(version)
+            when :v0
+              klass.new(internal_key, host: host, logger: logger)
+            when :v1
+              klass.new(external_key, host: host, logger: logger)
+            when :v2
+              klass.new(user_key: user_key, org_key: external_key, logger: logger)
+            end.tap do |pi|
+              unless log_connection? || !pi
+                @logger.info("Created api#{self.version(version)} connection on '#{name}' enviro, pointing to '#{host}' in '#{mode}' mode")
+                pi.logger.level = ::Logger::UNKNOWN
+              end
+            end
+          end
+
+          def api_params?(version)
+            case self.class.to_version(version)
+            when :v0
+              internal_key && host
+            when :v1
+              external_key && host
+            when :v2
+              external_key && user_key
+            end
+          end
+
+          def log_connection?
+            config.logger.log_connection?
+          end
 
         end
       end

data/lib/eco/api/session/config/apis.rb

@@ -26,17 +26,24 @@ module Eco
             end
           end
 
-          def add(name, key:, host:, version: :internal, mode: :local)
+          def add(name, key:, host:, version: :internal, mode: :local, user_key: nil, external_key: nil)
             apis[name] = Session::Config::Api.new(
-              key: key,
-              host: host,
-              version: version,
-              mode: mode,
-              root: self
+              name,
+              key:      key,
+              host:     host,
+              version:  version,
+              mode:     mode,
+              root:     self,
+              user_key: user_key,
+              external_key: external_key
             )
             self
           end
 
+          def active_api
+            self["active-api"]
+          end
+
           def active_name=(name)
             raise "'#{name}' Api environment not defined" if !apis[name]
             self["active-name"] = name
@@ -53,34 +60,26 @@ module Eco
             active_name
           end
 
-          def active_api
-            self["active-api"]
-          end
-
           def service_up?
-            api_klass = (active_api.version == :external)? Ecoportal::API::External : Ecoportal::API::Internal
-            @api_test ||= api_klass.new("foobar", host: active_api.host, logger: ::Logger.new(IO::NULL))
+            @api_test ||= Session::Config::Api.api_class(active_api.version).new("foobar", host: active_api.host, logger: ::Logger.new(IO::NULL))
             status = @api_test.client.get("/policy_groups").status
             # 401 Unauthorized "Permission denied. API key may be invalid."
             status == 401
           end
 
-          def api(logger = ::Logger.new(IO::NULL), force_new: false)
-            key     = active_api.key
-            host    = active_api.host
-            mode    = active_api.mode
-            version = active_api.version
-            return @api if (!force_new) && @api && key == @key && host == @host && @mode == mode && version == @version
-
-            api_klass = (version == :external)? Ecoportal::API::External : Ecoportal::API::Internal
+          def api(logger = ::Logger.new(IO::NULL), version: nil)
+            unless active_api
+              raise "There's no 'active_api'. Use apis.active_name='api_enviro_name' to set the active api"
+            end
+            active_api.api(version: version, logger: logger)
+          end
 
-            @api  = api_klass.new(key, host: host, logger: logger)
-            @key  = key; @host = host; @mode = mode; @version = version
-            @api
+          def default_user_key=(key)
+            self["user_key"] = key
           end
 
-          def new_api(logger = ::Logger.new(IO::NULL))
-            api(logger, force_new: true)
+          def default_user_key
+            self["user_key"]
           end
 
         end