eco-helpers 0.6.17 → 0.7.1

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

@@ -2,33 +2,71 @@ module Eco
   module API
     class Session
       class BatchStatus < Common::Session::BaseSession
-        attr_reader :queue, :method
+        TYPES = [:exact, :search]
+
+        attr_reader :queue, :method, :type
         attr_reader :root
 
-        def initialize(e, queue:, method:)
+        class << self
+          def valid_type?(value)
+            TYPES.include?(value)
+          end
+        end
+
+        def initialize(e, queue:, method:, type: :exact)
           super(e)
           fatal("In batch operations you must batch an array. Received: #{queue}")  unless queue && queue.is_a?(Array)
 
+          self.type = type
           @method = method
-          @queue = queue
-          @hash  = @queue.each_with_index.map do |entry, i|
+          @queue  = queue
+          @hash   = @queue.each_with_index.map do |entry, i|
             [entry, i]
           end.to_h
-          @responses = Array(0..@queue.length-1)
+          @responses    = []
+          @person_match = []
+          @people_match = Array.new(@queue.length, [])
         end
 
         def root=(object)
           @root = object
         end
 
+        def type=(value)
+          fatal("Invalid :type '#{value}. You must specify type: as one of #{TYPES} ") unless self.class.valid_type?(value)
+          @type = value
+        end
+
         def [](key)
           @responses[to_index(key)]
         end
 
+
         def []=(key, response)
           @responses[to_index(key)] = response
         end
 
+        def person(key)
+          return self[key].result if success?(key)
+          nil
+        end
+
+        def person_match(key)
+          @person_match[to_index(key)]
+        end
+
+        def set_person_match(key, person)
+          @person_match[to_index(key)] = person
+        end
+
+        def people_match(key)
+          @people_match[to_index(key)]
+        end
+
+        def set_people_match(key, people)
+          @people_match[to_index(key)] = people
+        end
+
         def received?(key)
           !!self[key]
         end
@@ -38,16 +76,37 @@ module Eco
         end
 
         def people
-          fatal "This batch wasn't a 'get'. Can't obtain people without 'get' method" unless method == "get"
-          out = Array(0..queue.length-1)
-          @responses.each_with_index do |respose, i|
-            out[i] = response.result
+          fatal "This batch wasn't a 'get'. Can't obtain people without 'get' method" unless method == :get
+          if type == :exact
+            out = Array(queue.length)
+            @responses.each_with_index do |respose, i|
+              out[i] = response.result
+            end
+          elsif type == :search
+            out = []
+            queue.each_with_index.map do |entry, i|
+              pers   = person(entry)
+              pers ||= person_match(entry)
+              out += pers ? [pers] : people_match(entry)
+            end
           end
           out
         end
 
         def error_queries
           queue.each_with_index.map do |query,i|
+            unless self[i]
+              pp "Error: query with no response. You might have duplicated entries in your queue.\n"
+              msg  = "Queue length: #{queue.length}\n"
+              msg += "Query with no response. Person: #{person_ref(query)}\n"
+              queue.map do |entry|
+                if entry.id == query.id || entry.external_id == query.external_id || entry.email == query.email
+                  msg += "It could be this peson entry: #{person_ref(entry)}\n"
+                end
+              end
+              raise msg
+            end
+
             self[i].success? ? nil : query
           end.compact
         end
@@ -95,8 +154,8 @@ module Eco
         def print_errors(sort: :by_status)
           strs = str_errors(sort: sort)
           if strs.length > 0
-            logger.error(strs.join("\n"))
-            #strs.each {|str| logger.error(str)}
+            logger.info()
+            logger.error("There were #{strs.length} errors:\n" + strs.join("\n"))
           else
             logger.info("There were no errors for the current batch '#{method}'!! ;)")
           end

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

@@ -43,6 +43,10 @@ module Eco
           self["usecases"] ||= Session::Config::UseCases.new(root: self)
         end
 
+        def api_policies
+          self["api_policies"] ||= Session::Config::Policies.new(root: self)
+        end
+
         # LOGGER
         def log_console_level=(value)
           logger.console_level= value
@@ -103,11 +107,6 @@ module Eco
           apis.api(logger)
         end
 
-        def policy_groups
-          policy_groups = api&.policy_groups.to_a.compact
-          Eco::API::Organization::PolicyGroups.new(policy_groups)
-        end
-
         # FILES
         def working_directory=(path)
           files.working_directory = path
@@ -130,6 +129,18 @@ module Eco
           org["tagtree"] = file
         end
 
+        def policy_groups
+          return @policy_groups if instance_variable_defined?(:@policy_groups)
+          pgs = api&.policy_groups.to_a
+          @policy_groups = Eco::API::Organization::PolicyGroups.new(pgs)
+        end
+
+        def schemas
+          return @schemas if instance_variable_defined?(:@schemas)
+          schs     = api&.person_schemas.to_a
+          @schemas = Eco::API::Organization::PersonSchemas.new(schs)
+        end
+
         # PEOPLE
         def discarded_people_file=(value)
           people.discarded_file = value
@@ -171,6 +182,11 @@ module Eco
           usecases.add(&block)
         end
 
+        # API POLICIES
+        def policies(&block)
+          api_policies.add(&block)
+        end
+
       end
     end
   end
@@ -184,3 +200,4 @@ require_relative 'config/s3_storage'
 require_relative 'config/files'
 require_relative 'config/people'
 require_relative 'config/use_cases'
+require_relative 'config/policies'

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

@@ -6,7 +6,8 @@ module Eco
 
           def initialize(root:)
             super(nil)
-            @root = root
+            @root        = root
+            @validations = {}
           end
 
           def working_directory=(path)
@@ -25,6 +26,14 @@ module Eco
             self["timestamp_pattern"]
           end
 
+          def add_validation(format)
+            raise "Block must be given" unless block_given?
+            @validations[format] = Proc.new
+          end
+
+          def validate(format, input)
+            @validations[format].call(input) if  @validations.key?(format)
+          end
         end
       end
     end

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

@@ -19,6 +19,15 @@ module Eco
             self["cache"]
           end
 
+          # specifies if people search should be strict or not
+          def strict_search=(value)
+            self["strict_search"] = !!value
+          end
+
+          def strict_search?
+            self["strict_search"]
+          end
+
           # api queried logs
           def requests_folder=(folder)
             self["requests_folder"] = folder
@@ -71,19 +80,23 @@ module Eco
             self["presets_map"]
           end
 
-          # CUSTOM PERSON PARSERS
+          # Defines an `ParserSerializer` for a `PersonParser` of certain `format`
+          # @param format [Symbol] the target format this parser/serializer is made for.
           def add_parser(format: :csv)
-            new_parsers = Eco::API::Common::People::PersonParser.new
-            yield(new_parsers, config)
-
             parsers[format] ||= Eco::API::Common::People::PersonParser.new
-            parsers[format] = parsers[format] ? parsers[format].merge(new_parsers) : new_parsers
+            parsers[format].tap do |prs|
+              yield(prs, config)
+            end
           end
 
+          # @return [Hash] with defined pairs format `key` and Person parsers.
           def parsers
             self["parsers"] ||= {}
           end
 
+          # The person parser/serializer for a given format (default `csv`).
+          # @param format [Symbol] the format this parser/serializer recognizes.
+          # @return [Eco::API::Common::People::PersonParser] parser/serializer for the defined `format`.
           def parser(format: :csv)
             parsers[format]
           end

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

@@ -0,0 +1,29 @@
+module Eco
+  module API
+    class Session
+      class Config
+        class Policies < Hash
+          attr_reader :config
+
+          def initialize(root:)
+            super(nil)
+            @root   = root
+            @config = @root
+          end
+
+          # API POLICIES
+          def add
+            policies.tap do |group|
+              yield(group, config)
+            end
+          end
+
+          def policies
+            self["used_policies"] ||= Eco::API::Policies::UsedPolicies.new
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -13,13 +13,9 @@ module Eco
 
           # CUSTOM USE CASES
           def add
-            new_group = Eco::API::UseCases::UseGroup.new
-            yield(new_group, config)
-
-            self["use_group"] ||= Eco::API::UseCases::UseGroup.new
-            group = self["use_group"]
-            group = group ? group.merge(new_group) : group
-            self["use_group"] = group
+            use_group.tap do |group|
+              yield(group, config)
+            end            
           end
 
           def use_group

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

@@ -26,18 +26,17 @@ module Eco
         def new(name, order: :last)
           fatal "Can't create job group named '#{name}' because it already exists." if exists?(name)
 
-          group = BatchJobs.new(enviro, name: name)
-          @groups[name] = group
+          BatchJobs.new(enviro, name: name).tap do |group|
+            @groups[name] = group
 
-          if order == :last
-            @order.push(group)
-          else
-            @order.unshift(group)
-          end
-
-          @callbacks[group] = Proc.new if block_given?
+            if order == :last
+              @order.push(group)
+            else
+              @order.unshift(group)
+            end
 
-          group
+            @callbacks[group] = Proc.new if block_given?
+          end
         end
 
         def pending?

data/lib/eco/api/usecases.rb

@@ -5,8 +5,9 @@ module Eco
   end
 end
 
-#require_relative 'usecases/case_data'
 require_relative 'usecases/base_case'
 require_relative 'usecases/use_case'
+require_relative 'usecases/use_case_chain'
+require_relative 'usecases/use_case_io'
 require_relative 'usecases/use_group'
 require_relative 'usecases/default_cases'

data/lib/eco/api/usecases/base_case.rb

@@ -2,12 +2,17 @@ module Eco
   module API
     module UseCases
       class BaseCase
+        
         def initialize(cases, **options)
-          @cases = cases
+          raise "Expected UseGroup. Given: #{cases.class}" unless cases.is_a?(UseGroup)
+          @cases   = cases
           @options = options
         end
 
-        def process; end
+        def process
+          raise "You should reimplement this method"
+        end
+
       end
     end
   end

data/lib/eco/api/usecases/default_cases/change_email_case.rb

@@ -5,13 +5,15 @@ module Eco
         class ChangeEMailCase < BaseCase
 
           def process
-            @cases.define("change-email", type: :sync) do |entries, people, session|
+            @cases.define("change-email", type: :sync) do |entries, people, session, options|
               remove = session.job_group("main").new("remove account", type: :update, sets: :account)
               change = session.job_group("main").new("change email", type: :update, sets: :core)
               add_account = session.job_group("post").new("add account", type: :update, sets: :account)
 
+              strict_search = session.config.people.strict_search? || options.dig(:search, :strict)
+
               entries.each.with_index do |entry, i|
-                person = people.find(entry)
+                person = people.find(entry, strict: strict_search)
 
                 if !person
                   session.logger.error("Entry(#{i}) - this person does not exist: #{entry.to_s(:identify)}")

data/lib/eco/api/usecases/default_cases/create_case.rb

@@ -8,10 +8,11 @@ module Eco
             @cases.define("create", type: :sync) do |entries, people, session, options|
               creation = session.job_group("main").new("create", type: :create, sets: [:core, :details, :account])
 
+              strict_search = session.config.people.strict_search? || options.dig(:search, :strict)
               pgs = session.policy_groups
 
               entries.each.with_index do |entry, i|
-                if person = people.find(entry)
+                if person = people.find(entry, strict: strict_search)
                   session.logger.error("Entry(#{i}) - this person (id: '#{person.id}') already exists: #{entry.to_s(:identify)}")
                 else
                   person = session.new_person

data/lib/eco/api/usecases/default_cases/create_details_case.rb

@@ -8,8 +8,10 @@ module Eco
             @cases.define("create-details", type: :sync) do |entries, people, session, options|
               creation = session.job_group("main").new("create", type: :create, sets: [:core, :details])
 
+              strict_search = session.config.people.strict_search? || options.dig(:search, :strict)
+
               entries.each.with_index do |entry, i|
-                if person = people.find(entry)
+                if person = people.find(entry, strict: strict_search)
                   session.logger.error("Entry(#{i}) - this person (id: '#{person.id}') already exists: #{entry.to_s(:identify)}")
                 else
                   person = session.new_person

data/lib/eco/api/usecases/default_cases/create_details_with_supervisor_case.rb

@@ -6,12 +6,14 @@ module Eco
 
           def process
             # good candidate to do @cases.case("create-details").use.chain(@cases.case("set-supervisor").use)
-            @cases.define("create-details-with-supervisor", type: :sync) do |entries, people, session|
+            @cases.define("create-details-with-supervisor", type: :sync) do |entries, people, session, options|
               creation = session.job_group("main").new("create", type: :create, sets: [:core, :details])
               supers   = session.job_group("post").new("supers", type: :update, sets: :core)
 
+              strict_search = session.config.people.strict_search? || options.dig(:search, :strict)
+
               entries.each.with_index do |entry, i|
-                if person = people.find(entry)
+                if person = people.find(entry, strict: strict_search)
                   session.logger.error("Entry(#{i}) - this person (id: '#{person.id}') already exists: #{entry.to_s(:identify)}")
                 else
                   person = session.new_person

data/lib/eco/api/usecases/default_cases/hris_case.rb

@@ -24,33 +24,40 @@ module Eco
               #  end
               #end
 
+              strict_search = session.config.people.strict_search? || options.dig(:search, :strict)
+
               entries.each.with_index do |entry, i|
-                person = people.find(entry)
+                person = people.find(entry, strict: strict_search)
                 person = session.new_person if create = !person
 
                 entry.set_core(person, exclude: "supervisor_id")
                 entry.set_details(person)
                 entry.set_account(person) #if !remove.people.find(entry)
-                person.account.permissions_custom = session.new_preset(person)
+                person.account.send_invites = options[:send_invites] if options.key?(:send_invites)
+
+                person.account.permissions_custom = session.new_preset(person) unless !create && options.dig(:exclude, :abilities)
 
                 person.account.default_tag = person.account.filter_tags.first if person.account.filter_tags.length == 1
 
+
                 creation.add(person) if create
                 update.add(person) unless create
 
                 # set 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
+                # set supervisor
+                unless options.dig(:exclude, :core) || options.dig(:exclude, :supervisor)
+                  if !(sup_id = entry.supervisor_id)
+                    person.supervisor_id = nil
                   else
-                    # delay setting supervisor if does not exit
-                    supers.add(person) do |person|
-                      #person = session.new_person(person: person.doc)
-                      person.sync
-                      person.supervisor_id = sup_id
-                      person
+                    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.add(person) do |person|
+                        person.consolidate!
+                        person.supervisor_id = sup_id
+                        person
+                      end
                     end
                   end
                 end