eco-helpers 0.6.17 → 0.7.1

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

@@ -8,8 +8,10 @@ module Eco
             @cases.define("new-email", type: :sync) do |entries, people, session, options|
               job = session.job_group("main").new("update", 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)
                   person.email = entry.email
                   job.add(person)
                 else

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

@@ -5,11 +5,13 @@ module Eco
         class NewIdCase < BaseCase
 
           def process
-            @cases.define("new-id", type: :sync) do |entries, people, session|
+            @cases.define("new-id", type: :sync) do |entries, people, session, options|
               job = session.job_group("main").new("update", 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)
                   person.external_id = entry.external_id
                   job.add(person)
                 else

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

@@ -14,15 +14,15 @@ module Eco
               update   = session.job_group("main").new("update", type: :update, sets: [:core, :details, :account])
               remove   = session.job_group("main").new("remove", type: :delete, sets: [:core, :details, :account])
 
+              strict_search = session.config.people.strict_search? || options.dig(:search, :strict)
               pgs = session.policy_groups
 
               if options.dig(:include, :delete)
                 people.exclude(entries).map {|person| remove.add(person)}
               end
 
-
               entries.each.with_index do |entry, i|
-                create = ! (person = people.find(entry))
+                create = ! (person = people.find(entry, strict: strict_search))
 
                 if create && !options.dig(:include, :create)
                   session.logger.error("Entry(#{i}) - this person does not exist: #{entry.email}")
@@ -32,11 +32,15 @@ module Eco
                   unless options.dig(:exclude, :core)
                     person.external_id   = entry.external_id
                     person.name          = entry.name
-                    person.email         = entry.email unless (options.dig(:exclude, :email))
-                    person.supervisor_id = entry.supervisor_id
+                    person.email         = entry.email unless options.dig(:exclude, :email)
+                    person.supervisor_id = entry.supervisor_id unless options.dig(:exclude, :supervisor)
+                  end
+
+                  unless options.dig(:exclude, :account)
+                    person.account = entry.account
+                    person.account&.send_invites = options[:send_invites] if options.key?(:send_invites)
                   end
 
-                  person.account = entry.account unless options.dig(:exclude, :account)
                   person.details = entry.details unless options.dig(:exclude, :details)
 
                   creation.add(person) if create

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

@@ -14,11 +14,13 @@ module Eco
               end
             end
 
-            @cases.define("remove-account", type: :sync) do |entries, people, session|
+            @cases.define("remove-account", type: :sync) do |entries, people, session, options|
               update = session.job_group("main").new("update", type: :update, sets: [:core, :account])
 
+              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)
                   person.account = nil
                   update.add(person)
                 else

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

@@ -5,11 +5,13 @@ module Eco
         class SetSupervisorCase < BaseCase
 
           def process
-            @cases.define("set-supervisor", type: :sync) do |entries, people, session|
+            @cases.define("set-supervisor", type: :sync) do |entries, people, session, options|
               job = session.job_group("main").new("update", type: :update, sets: :core)
 
+              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/to_csv_case.rb

@@ -18,8 +18,8 @@ module Eco
 
               session.logger.info("going to create file: #{file}")
               CSV.open(file, "w") do |csv|
-                deps = {"supervisor_id" => {people: people}}
-                entry = session.new_entry(people.first, dependencies: deps)
+                deps   = {"supervisor_id" => {people: people}}
+                entry  = session.new_entry(people.first, dependencies: deps)
                 header = entry.to_hash.keys
 
                 if options.dig(:nice_header)

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

@@ -20,8 +20,8 @@ module Eco
 
               session.logger.info("going to create file: #{file}")
               CSV.open(file, "w") do |csv|
-                deps = {"supervisor_id" => {people: people}}
-                header = session.new_entry(people.first, dependencies: deps).to_hash.keys
+                deps    = {"supervisor_id" => {people: people}}
+                header  = session.new_entry(people.first, dependencies: deps).to_hash.keys
                 header += abilities
 
                 csv << header

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

@@ -5,13 +5,24 @@ module Eco
         class UpdateCase < BaseCase
 
           def process
+            #opts = CLI::Options.new do |p|
+            #  p.option :exclude, "Allows to exclude certain options"
+            #  p.suboption :exclude, :core, "Excludes core details from the update.", optional: true
+            #  p.suboption :exclude, :details, "Excludes schema details from the update.", optional: true
+            #  p.suboption :exclude, :account, "Excludes account details from the update.", optional: true
+            #  p.suboption :exclude, :email, "Excludes core email from the update.", optional: true
+            #  p.suboption :exclude, :supervisor, "Excludes supervisor_id from the update.", optional: true
+            #  p.suboption :exclude, :abilities, "Excludes the abilities from the update.", optional: true
+            #end
+
             @cases.define("update", type: :sync) do |entries, people, session, options|
               update   = session.job_group("main").new("update", type: :update, 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)
                   core_excluded = ["supervisor_id"]
                   core_excluded.push("email") if options.dig(:exclude, :email)
                   entry.set_core(person, exclude: core_excluded) unless options.dig(:exclude, :core)
@@ -27,7 +38,7 @@ module Eco
                       final:           person.account.policy_group_ids
                     )
 
-                    person.account.permissions_custom = session.new_preset(person) unless options.dig(:exclude, :abilities)
+                    person.account.permissions_custom = session.new_preset(person) unless !create && options.dig(:exclude, :abilities)
 
                     if session.tagtree
                       person.account.filter_tags = session.tagtree.user_tags(
@@ -41,6 +52,9 @@ module Eco
                       tags = person.account.filter_tags
                       person.account.default_tag = tags.first unless tags.length > 1
                     end
+
+                    person.account&.send_invites = options[:send_invites] if options.key?(:send_invites)
+
                   end
                   update.add(person)
                 else

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

@@ -8,8 +8,10 @@ module Eco
             @cases.define("update-details", type: :sync) do |entries, people, session, options|
               job = session.job_group("main").new("update", type: :update, 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)
                   core_excluded = ["supervisor_id"]
                   core_excluded.push("email") if options.dig(:exclude, :email)
                   entry.set_core(person, exclude: core_excluded) unless options.dig(:exclude, :core)

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

@@ -8,11 +8,13 @@ module Eco
             @cases.define("upsert", type: :sync) do |entries, people, session, options|
               creation = session.job_group("main").new("create", type: :create, sets: [:core, :details, :account])
               update   = session.job_group("main").new("update", type: :update, sets: [:core, :details, :account])
+              supers   = session.job_group("post").new("supers", type: :update, sets: :core)
 
+              strict_search = session.config.people.strict_search? || options.dig(:search, :strict)
               pgs = session.policy_groups
 
               entries.each.with_index do |entry, i|
-                create = ! (person = people.find(entry))
+                create = ! (person = people.find(entry, strict: strict_search))
                 person = session.new_person if create
 
                 core_excluded = ["supervisor_id"]
@@ -25,14 +27,14 @@ module Eco
                   ini_tags   = person.account&.filter_tags || []
                   entry.set_account(person)
 
-                  person.account.send_invites = false if options.key?(:send_invites) && !options(:send_invites)
+                  person.account.send_invites = options[:send_invites] if options.key?(:send_invites)
 
                   person.account.policy_group_ids   = pgs.user_pg_ids(
                     initial:         ini_pg_ids,
                     final:           person.account.policy_group_ids
                   )
 
-                  person.account.permissions_custom = session.new_preset(person) unless options.dig(:exclude, :abilities)
+                  person.account.permissions_custom = session.new_preset(person) unless !create && options.dig(:exclude, :abilities)
 
                   if session.tagtree
                     person.account.filter_tags = session.tagtree.user_tags(
@@ -46,10 +48,30 @@ module Eco
                     tags = person.account.filter_tags
                     person.account.default_tag = tags.first unless tags.length > 1
                   end
+
                 end
 
                 creation.add(person) if create
                 update.add(person) unless create
+
+                # 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.add(person) do |person|
+                        person.consolidate!
+                        person.supervisor_id = sup_id
+                        person
+                      end
+                    end
+                  end
+                end
+
               end
             end
           end

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

@@ -10,164 +10,47 @@ module Eco
           transform: [:people, :session],
           export:    [:people, :session, :options]
         }
-        MAX_CHAINS   = 70
-        @@num_chains = 0
 
-        attr_reader :name, :type, :times_used
+        attr_reader :name, :type, :times_launched
+
+        class << self
+          def valid_type?(type)
+            TYPES.include?(type)
+          end
+
+          def type_params(type)
+            raise "Invalid type '#{type.to_s}'" if !valid_type?(type)
+            TYPE_PARAMS[type]
+          end
+        end
 
         def initialize(name, type:, root:, options: {}, &block)
+          raise "Undefine usecase type #{type}. Please, use any of #{TYPES}" unless self.class.valid_type?(type)
 
           self.root = root
-          @case    = block
-          @name    = name
-          @type    = type
-          @options = options
-
-          @chains = []
-          @resolved_chains = nil
-          @times_used = 0
+          @case     = block
+          @name     = name
+          @type     = type
+          @options  = options
+          @times_launched = 0
         end
 
         def root=(value)
-          raise "You cannot change root UseGroup once the chains have been resolved" if @resolved_chains
           raise "Root should be a UseGroup. Given: #{value}" if !value.is_a?(UseGroup)
           @root = value
         end
 
-        def use(preserve_chains: false, recursive: false)
-          newcase = UseCase.new(@name, type: @type, root: @root, options: @options, &@case)
-          if preserve_chains
-            chain_use = {preserve_chains: recursive, recursive: recursive}
-            @chains = @chains.map do |usecase|
-              if usecase.respond_to? :call
-                Proc.new do |usegroup|
-                  usecase = usecase.call(usegroup)
-                  usecase.use(chain_use).chain_to(newcase)
-                  usecase
-                end
-              else
-                usecase.use(chain_use).chain_to(newcase)
-                usecase
-              end
-            end
-          end
-          newcase
-        end
-
-        def process(input: nil, people: nil, session:, options: {})
-          raise "This case has been already used. To create multiple instances of same use case, use 'use' method" if @done
-          validate_args(input: input, people: people, session: session, options: options)
-
-          opts = options&.dup
-          opts = @options.merge(opts || {})
+        def launch(input: nil, people: nil, session:, options: {})
+          data = UseCaseIO.new(usecase: self, input: input, people: people, session: session, options: options)
 
-          case @type
-          when :import
-            out = input  = @case.call(input, session, opts)
-          when :filter
-            out = people = @case.call(people, session, opts)
-          when :transform
-            out = jobs   = into_a(@case.call(people, session, opts))
-          when :sync
-            out = jobs   = into_a(@case.call(input, people, session, opts))
-          when :export
-            out = stat   = @case.call(people, session, opts)
-          end
-          @times_used += 1
+          data.output = @case.call(data.params)
+          @times_launched += 1
 
           data_model = {
             self => {
-              data: { input: input, people: people, session: session, options: opts, output: out }
+              io: data
             }
           }
-          post_usecase(data_model)
-        end
-
-        def chain(usecase = nil)
-          @@num_chains += 1
-          raise "Reached maximum number of chained use cases (#{MAX_CHAINS}). Looks like a recursive cyclic chain 'use'" if @@num_chains >= MAX_CHAINS
-          raise "A UseCase can only be chained with another UseCase" if usecase && !usecase.is_a?(UseCase)
-          raise "Missuse. Please use either parameter or block but not both" if block_given? && usecase
-          usecase = block_given?? Proc.new : usecase
-          @chains.push(usecase)
-          self
-        end
-
-        def self.valid_type(type)
-          TYPES.include?(type)
-        end
-
-        def self.type_params(type)
-          raise "Invalid type '#{type.to_s}'" if !valid_type?(type)
-          TYPE_PARAMS[type]
-        end
-
-        protected
-
-        def chain_to(usecase)
-          raise "A UseCase can only be chained with another UseCase" if usecase && !usecase.is_a?(UseCase)
-          usecase.chain(self)
-        end
-
-        def resolved_chains(use_group = nil)
-          return @resolved_chains if @resolved_chains
-          raise "Only UseGroup object can resolve chains. Given: #{use_group} " if use_group && !use_group.is_a?(UseGroup)
-
-          use_group = use_group || @root
-          @resolved_chains = @chains.map do |usecase|
-            usecase = usecase.call(use_group) if usecase.respond_to? :call
-            raise "A UseCase can only be chained with another UseCase" if usecase && !usecase.is_a?(UseCase)
-            usecase.resolved_chains(use_group)
-            usecase
-          end
-          @resolved_chains
-        end
-
-        private
-
-        def post_usecase(data_model)
-          return data_model if resolved_chains.empty?
-          data_model[self][:chains] = {} unless data_model[self][:chains]
-
-          resolved_chains.each do |usecase|
-            # chained cases use same params as parent case (out of simplicity)
-            params = data_model[self][:data].slice(*ALL_PARAMS) #TYPE_PARAMS[usecase.type])
-            data_model[self][:chains].merge(usecase.process(params))
-          end
-          data_model
-        end
-
-        def validate_args(input:, people:, session:, options:)
-          case
-          when !session.is_a?(Eco::API::Session)
-            raise "A UseCase needs a Session object. Given: #{session}"
-          when input_required? && !input
-            raise "UseCase of type '#{@type.to_s}' requires a valid input. None given"
-          when people_required? && !people.is_a?(Eco::API::Organization::People)
-            raise "UseCase of type '#{@type.to_s}' requires a People object. Given: #{people}"
-          when !options || (options && !options.is_a?(Hash))
-            raise "To inject dependencies via ':options' it should be a Hash object. Given: #{options}"
-          when options_required? && !options
-            raise "UseCase of type '#{@type.to_s}' requires a Hash ':options' object."
-          end
-          true
-        end
-
-        def input_required?
-          [:import, :sync].include?(@type)
-        end
-
-        def people_required?
-          [:filter, :transform, :sync, :export].include?(@type)
-        end
-
-        def options_required?
-          [:filter].include?(@type)
-        end
-
-        def into_a(value)
-          value = [].push(value) unless value.is_a?(Array)
-          value
         end
 
       end

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

@@ -0,0 +1,95 @@
+module Eco
+  module API
+    module UseCases
+      class UseCaseChain < UseCase
+        MAX_CHAINS   = 70
+        @@num_chains = 0
+
+        def initialize(name, type:, root:, options: {}, &block)
+          super(name, type: type, root: root, options: options, &block)
+          @chains   = []
+          @resolved_chains = nil
+        end
+
+        def root=(value)
+          raise "You cannot change root UseGroup once the chains have been resolved" if @resolved_chains
+          super(value)
+        end
+
+        def use(preserve_chains: false, recursive: false)
+          UseCase.new(@name, type: @type, root: @root, options: @options, &@case).tap do |newcase|
+            if preserve_chains
+              chain_use = {preserve_chains: recursive, recursive: recursive}
+              @chains = @chains.map do |usecase|
+                if usecase.respond_to? :call
+                  Proc.new do |usegroup|
+                    usecase = usecase.call(usegroup)
+                    usecase.use(chain_use).chain_to(newcase)
+                    usecase
+                  end
+                elsif usecase.is_a?(UseCase)
+                  usecase.use(chain_use).chain_to(newcase)
+                  usecase
+                end
+              end
+            end
+          end
+        end
+
+        def launch(input: nil, people: nil, session:, options: {})
+          data_model = super(input: input, people: people, session: session, options: options)
+          launch_chain(data_model)
+        end
+
+        def chain(usecase = nil)
+          @@num_chains += 1
+          raise "Reached maximum number of chained use cases (#{MAX_CHAINS}). Looks like a recursive cyclic chain 'use'" if @@num_chains >= MAX_CHAINS
+          raise "A UseCase can only be chained with another UseCase" if usecase && !usecase.is_a?(UseCase)
+          raise "Missuse. Please use either parameter or block but not both" if block_given? && usecase
+          usecase = block_given?? Proc.new : usecase
+          @chains.push(usecase)
+          self
+        end
+
+        protected
+
+        def chain_to(usecase)
+          raise "A UseCase can only be chained with another UseCase" if usecase && !usecase.is_a?(UseCase)
+          usecase.chain(self)
+        end
+
+        def resolved_chains(use_group = nil)
+          return @resolved_chains if @resolved_chains
+          raise "Only UseGroup object can resolve chains. Given: #{use_group} " if use_group && !use_group.is_a?(UseGroup)
+
+          use_group = use_group || @root
+          @resolved_chains = @chains.map do |usecase|
+            usecase = usecase.call(use_group) if usecase.respond_to? :call
+            raise "A UseCase can only be chained with another UseCase" if usecase && !usecase.is_a?(UseCase)
+            usecase.resolved_chains(use_group)
+            usecase
+          end
+        end
+
+        private
+
+        def launch_chain(data_model)
+          return data_model if resolved_chains.empty?
+
+          data_model.tap do |dm|
+            dm[self][:chains] ||= {}
+
+            resolved_chains.each do |usecase|
+              # chained cases use same params as parent case (out of simplicity)
+              data_chain = dm[self][:io].chain(usecase: usecase)
+              keyed_data = data_chain.params(keyed: true)
+              dm[self][:chains].merge(usecase.launch(keyed_data))
+            end
+          end
+        end
+
+      end
+
+    end
+  end
+end