eco-helpers 0.6.17 → 0.7.1

data/lib/eco/api/common/session/base_session.rb

@@ -16,8 +16,7 @@ module Eco
 
           def initialize(e)
             raise "Expected object Eco::API::Common::Session::Environment. Given: #{e.class}" unless e.is_a?(Environment)
-            #e = Environment.new(e) if !e.is_a?(Environment)
-            self.environment = e   #if e.is_a?(Environment)
+            self.environment = e
           end
 
           def session

data/lib/eco/api/common/session/file_manager.rb

@@ -31,7 +31,7 @@ module Eco
 
           #####    FILE   #####
           def file(filename, should_exist: false)
-            dir.file(filename, should_exist: should_exit)
+            dir.file(filename, should_exist: should_exist)
           end
 
           def newest(filename)

data/lib/eco/api/organization.rb

@@ -6,7 +6,8 @@ module Eco
 end
 
 require_relative 'organization/tag_tree'
-require_relative 'organization/presets'
+require_relative 'organization/presets_factory'
 require_relative 'organization/preferences'
 require_relative 'organization/people'
 require_relative 'organization/policy_groups'
+require_relative 'organization/person_schemas'

data/lib/eco/api/organization/people.rb

@@ -2,7 +2,6 @@ module Eco
   module API
     module Organization
       class People <  Eco::Language::Models::Collection
-
         # build the shortcuts of Collection
         attr_collection :id, :external_id, :email, :name, :supervisor_id
         attr_presence :account, :details
@@ -16,7 +15,7 @@ module Eco
         end
 
         def [](id_or_ext)
-          self.id(id_or_ext) || self.external_id(id_or_ext)
+          id(id_or_ext) || external_id(id_or_ext)
         end
 
         def id(*args)
@@ -28,32 +27,65 @@ module Eco
         end
 
         def users
-          self.account_present(true)
+          account_present(true)
         end
 
         def contacts
-          self.details_present(true)
+          details_present(true)
         end
 
         def non_users
-          self.account_present(false)
+          account_present(false)
         end
 
-        def person(id: nil, external_id: nil, email: nil)
+        # It searches a person using the paramters given.
+        # @param id [String] the `internal id` of the person
+        # @param external_id [String] the `exernal_id` of the person
+        # @param email [String] the `email` of the person
+        # @param strict [Boolean] if should perform a `soft` or a `strict` search. `strict` will avoid repeated email addresses.
+        # @return [Person, nil] the person we were searching, or `nil` if not found.
+        def person(id: nil, external_id: nil, email: nil, strict: false)
           init_caches
           pers = @by_id[id]&.first if id
-          pers = @by_external_id[external_id&.strip]&.first if !pers && !external_id.to_s.strip.empty?
-          pers = @by_users_email[email&.downcase.strip]&.first if !pers && !email.to_s.strip.empty?
-          pers = @by_non_users_email[email&.downcase.strip]&.first if !pers && !email.to_s.strip.empty?
-          pers = @by_external_id[email&.downcase.strip]&.first if !pers && !email.to_s.strip.empty?
+          pers = @by_external_id[external_id&.strip]&.first        if !pers && !external_id.to_s.strip.empty?
+
+          # strict prevents taking existing user for searched person with same email
+          # specially useful if the organisation ensures all have external id (no need for email search)
+          if !pers && (!strict || external_id.to_s.strip.empty?)
+            # person still not found and either not strict or no external_id provided
+            pers = @by_users_email[email&.downcase.strip]&.first   if !email.to_s.strip.empty?
+
+            if !pers && !strict && !email.to_s.strip.empty?
+              candidates = @by_non_users_email[email&.downcase.strip] || []
+              raise "Too many non-user candidates (#{candiates.length}) with email '#{email}'" if candidates.length > 1
+              pers = candidates.first
+            end
+
+          end
+          pers = @by_external_id[email&.downcase.strip]&.first   if !pers && !email.to_s.strip.empty?
+
           pers
         end
 
-        def find(object)
-          id = object.respond_to?("id")? object.send("id") : nil
+        def find(object, strict: false)
+          id          = object.respond_to?("id")?          object.send("id") : nil
           external_id = object.respond_to?("external_id")? object.send("external_id") : nil
-          email = object.respond_to?("email")? object.send("email") : nil
-          person(id: id, external_id: external_id, email: email)
+          email       = object.respond_to?("email")?       object.send("email") : nil
+          person(id: id, external_id: external_id, email: email, strict: strict)
+        end
+
+        def uniq(include_unsearchable: false)
+          init_caches
+          unsearchable = []
+          newFrom to_a.each_with_object([]) do |person, people|
+            if found = find(person)
+              people << found
+            else
+              unsearchable << person
+            end
+          end.tap do |people|
+            people << unsearchable if include_unsearchable
+          end
         end
 
         def exclude(object)
@@ -64,15 +96,15 @@ module Eco
           discarded = list.map do |person|
             find(person)
           end.compact
-          newFrom self.to_a - discarded
+          newFrom to_a - discarded
         end
 
         def email_id_maps
-          self.users.group_by(:email).transform_values { |person| person.id }
+          users.group_by(:email).transform_values { |person| person.id }
         end
 
         def group_by_supervisor
-          self.to_h(:supervisor_id)
+          to_h(:supervisor_id)
         end
 
         # only those that are present
@@ -89,7 +121,7 @@ module Eco
           sup_ids - (sup_ids & self.ids)
         end
 
-        def to_h(attr)
+        def to_h(attr = "id")
           super(attr || "id")
         end
 
@@ -103,10 +135,10 @@ module Eco
 
         def init_caches
           return if @caches_init
-          @by_id = self.to_h('id')
-          @by_external_id = self.to_h('external_id')
-          @by_users_email = self.users.to_h('email')
-          @by_non_users_email = self.non_users.to_h('email')
+          @by_id              = to_h
+          @by_external_id     = to_h('external_id')
+          @by_users_email     = users.to_h('email')
+          @by_non_users_email = non_users.to_h('email')
           @caches_init = true
         end
 

data/lib/eco/api/organization/person_schemas.rb

@@ -0,0 +1,54 @@
+module Eco
+  module API
+    module Organization
+      class PersonSchemas <  Eco::Language::Models::Collection
+        # build the shortcuts of Collection
+        attr_collection :id, :name
+
+        def initialize(schemas = [], klass: Ecoportal::API::Internal::PersonSchema)
+          @klass       = Ecoportal::API::Internal::PersonSchema
+          @caches_init = false
+          super(schemas, klass: @klass)
+          init_caches
+        end
+
+        def to_id(name)
+          case name
+          when Enumerable
+            name.map do |n|
+              schema(n)&.id
+            end.compact
+          else
+            schema(name)&.id
+          end
+        end
+
+        def to_name(id)
+          schema(id)&.name
+        end
+
+        def schema(id_name)
+          @by_id.fetch(schema_id(id_name), nil)
+        end
+
+        private
+
+        def schema_name(id_name)
+          (@by_id[id_name] || @by_name[id_name&.downcase])&.name&.downcase
+        end
+
+        def schema_id(id_name)
+          (@by_name[id_name&.downcase] || @by_id[id_name])&.id
+        end
+
+        def init_caches
+          return if @caches_init
+          @by_id   = self.map { |pg| [pg.id, pg] }.to_h
+          @by_name = self.map { |pg| [pg.name&.downcase, pg] }.to_h
+          @caches_init = true
+        end
+
+      end
+    end
+  end
+end

data/lib/eco/api/organization/policy_groups.rb

@@ -5,10 +5,8 @@ module Eco
         # build the shortcuts of Collection
         attr_collection :id, :name
 
-        include Common::People
-
-        def initialize(policy_groups = [], klass: INTERNAL::PolicyGroup)
-          @klass = INTERNAL::PolicyGroup
+        def initialize(policy_groups = [], klass: Ecoportal::API::Internal::PolicyGroup)
+          @klass       = Ecoportal::API::Internal::PolicyGroup
           @caches_init = false
           super(policy_groups, klass: @klass)
           init_caches
@@ -16,7 +14,7 @@ module Eco
 
         def to_id(name)
           case name
-          when Array
+          when Enumerable
             name.map do |n|
               policy_group(n)&.id
             end.compact
@@ -54,13 +52,11 @@ module Eco
         private
 
         def policy_group_name(id_name)
-          @by_id.fetch(id_name, nil)&.name&.downcase ||
-          @by_name.fetch(id_name&.downcase, nil)&.name&.downcase
+          (@by_id[id_name] || @by_name[id_name&.downcase])&.name&.downcase
         end
 
         def policy_group_id(id_name)
-          @by_name.fetch(id_name&.downcase, nil)&.id ||
-          @by_id.fetch(id_name, nil)&.id
+          (@by_name[id_name&.downcase] || @by_id[id_name])&.id
         end
 
         def init_caches

data/lib/eco/api/organization/{presets.rb → presets_factory.rb}

@@ -5,7 +5,7 @@ module Eco
       class PresetsFactory
         ABILITIES = File.join(__dir__, 'presets_values.json')
         DEFAULT_CUSTOM = 'presets_custom.json'
-        DEFAULT_MAP   = 'presets_map.json'
+        DEFAULT_MAP    = 'presets_map.json'
 
         def initialize(presets_custom: DEFAULT_CUSTOM, presets_map: DEFAULT_MAP, enviro: nil, policy_groups: nil)
           @abilities  = JSON.load(File.open(ABILITIES))

data/lib/eco/api/policies.rb

@@ -0,0 +1,10 @@
+module Eco
+  module API
+    module Policies
+    end
+  end
+end
+
+require_relative 'policies/base_policy'
+require_relative 'policies/policy'
+require_relative 'policies/used_policies'

data/lib/eco/api/policies/base_policy.rb

@@ -0,0 +1,14 @@
+module Eco
+  module API
+    module Policies
+      class BasePolicy < Eco::API::UseCases::BaseCase
+
+        def initialize(policies, **options)
+          raise "Expected UsedPolicies. Given: #{policies.class}" unless policies.is_a?(UsedPolicies)
+          super(policies, **options)
+        end
+
+      end
+    end
+  end
+end

data/lib/eco/api/policies/policy.rb

@@ -0,0 +1,20 @@
+module Eco
+  module API
+    module Policies
+      class Policy < Eco::API::UseCases::UseCase
+        TYPES = [:transform]
+
+        def initialize(name, type: :transform, root:, options: {}, &block)
+          raise "Undefine usecase type #{type}. Please, use any of #{TYPES}" unless self.class.valid_type?(type)
+          super(name, type: type, root: root, options: options, &block)
+        end
+
+        def root=(value)
+          raise "Root should be a UsedPolicies object. Given: #{value}" if !value.is_a?(UsedPolicies)
+          @root = value
+        end
+
+      end
+    end
+  end
+end

data/lib/eco/api/policies/used_policies.rb

@@ -0,0 +1,37 @@
+module Eco
+  module API
+    module Policies
+      class UsedPolicies < Eco::API::UseCases::UseGroup
+
+        attr_reader :policies
+
+        def add(policy)
+          raise "Expected Policy object. Given: #{policy}" if !policy || !policy.is_a?(Policy)
+          super(policy)
+        end
+
+        def define(name, type: :transform, &block)
+          Policy.new(name, type: type, root: self, &block).tap do |policy|
+            add(policy)
+          end
+        end
+
+        # TODO: decide if policies deal with queue or single person
+        def launch(people:, session:, options: {})
+
+          args = {
+            people:  people,
+            session: session,
+            options: options
+          }
+
+          items.map do |policy|
+            session.logger.debug("UsedPolicies: going to process '#{policy.name}' policy")
+            policy.launch(**args)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/eco/api/session.rb

@@ -1,13 +1,10 @@
 module Eco
   module API
     class Session < Common::Session::BaseSession
-      attr_reader :batch, :policy_groups
-      attr_accessor :schema, :schemas_hash
-      attr_reader :tagtree
+      attr_reader :batch, :policy_groups, :tagtree
       attr_reader :job_groups
-
-      #attr_reader :organization
-      #alias_method :org, :organization
+      attr_reader :schemas
+      attr_accessor :schema
 
       def initialize(init = {})
         e = init
@@ -24,13 +21,9 @@ module Eco
 
         @use_cases    = Eco::API::UseCases::DefaultCases.new.merge(config.usecases.use_group)
 
-        @schemas =  api&.person_schemas.to_a
-        @schemas_hash = @schemas.map do |sch|
-          [[sch.id, sch], [sch.name.downcase, sch]]
-        end.flatten(1).to_h
-
+        @schemas      = config.schemas
         self.schema = config.people.default_schema || @schemas.first
-        @policy_groups = nil
+        @policy_groups = config.policy_groups
 
         @tagtree = nil
         if tree_file = config.dig('org', 'tagtree')
@@ -50,10 +43,9 @@ module Eco
       end
 
       def self.configure
-        # TODO: change to  Session::Config.new.tap
-        conf = Session::Config.new
-        yield(conf) if block_given?
-        conf
+        Session::Config.new.tap do |conf|
+          yield(conf) if block_given?
+        end
       end
 
       # TASKS & JOBS
@@ -99,9 +91,9 @@ module Eco
       def schema=(value)
         case value
         when String
-          sch = @schemas_hash[value.downcase]
-          fatal "The schema with id or name '#{value}' does not exist" if !sch
-          @schema = sch
+          unless @schema = @schemas.schema(value)
+            fatal "The schema with id or name '#{value}' does not exist"
+          end
         when Ecoportal::API::V1::PersonSchema
           @schema = value
         else
@@ -109,16 +101,24 @@ module Eco
           return
         end
 
-        @person_factory    = Eco::API::Common::People::PersonFactory.new(schema: @schema)
+        @person_factory = Eco::API::Common::People::PersonFactory.new(schema: @schema)
+
+        # TODO: check PersonEntry#to_internal and #to_external in init_attr_trackers
+        # => when attr_map is avoided, it doesn't work as it should
+        if map_file = config.people.fields_mapper
+          mappings = map_file ? file_manager.load_json(map_file) : []
+        else
+          mappings = []
+        end
+        attr_map = Eco::Data::Mapper.new(mappings)
 
-        fields_mapper_file = config.people.fields_mapper
-        fields_mapper      = Eco::Data::Mapper.new(file_manager.load_json(fields_mapper_file))
-        @entry_factory     = Eco::API::Common::People::EntryFactory.new({
-          schema: @schema,
+        @entry_factory = Eco::API::Common::People::EntryFactory.new({
+          schema:        @schema,
           person_parser: config.people.parser,
-          fields_mapper: fields_mapper,
-          logger: logger
+          attr_map:      attr_map,
+          logger:        logger
         })
+        self
       end
 
       def new_preset(input)
@@ -140,14 +140,16 @@ module Eco
         @entry_factory.new(data, dependencies: dependencies)
       end
 
+      def entries(*args)
+        @entry_factory.entries(*args)
+      end
+
+      def export(*args)
+        @entry_factory.export(*args)
+      end
+
       def csv_entries(file)
-        rows = []
-        if Eco::API::Common::Session::FileManager.file_exists?(file)
-          CSV.foreach(file, headers: true, encoding: Eco::API::Common::Session::FileManager.encoding(file)).with_index do |row, i|
-            rows.push(row)
-          end
-        end
-        @entry_factory.entries(rows)
+        return entries(file: file, format: :csv)
       end
 
       def discarded_entries
@@ -160,7 +162,7 @@ module Eco
         args = { session: self }.merge(params)
         fatal("Undefined usecase '#{name}' of type '#{type.to_s}'") if !@use_cases.defined?(name, type: type)
         logger.debug("Session: going to process '#{name}' defined case")
-        @use_cases.case(name, type: type).process(**args)
+        @use_cases.case(name, type: type).launch(**args)
       end
 
     end