eco-helpers 1.5.1 → 1.5.2

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

@@ -1,112 +1,18 @@
-module Eco
-  module API
-    class UseCases
-      class DefaultCases
-        class UpdateCase < DefaultCase
-
-          def process
-            @cases.define("update", type: :sync) do |entries, people, session, options, usecase|
-              update   = session.job_group("main").new("update", usecase: usecase, type: :update, sets: [:core, :details, :account])
-              supers   = session.job_group("post").new("supers", usecase: usecase, type: :update, sets: :core)
-
-              strict_search = session.config.people.strict_search? && (!options[:search]&.key?(:strict) || options.dig(:search, :strict))
-              pgs           = session.policy_groups
-
-              if session.config.people.default_usergroup?
-                def_id  = pgs.to_id(session.config.people.default_usergroup)
-              end
-
-              entries.each.with_index do |entry, i|
-                if person = people.find(entry, strict: strict_search)
-
-                  unless options.dig(:exclude, :core)
-                    ini_tags   = person.filter_tags || []
-
-                    core_attrs = ["name", "external_id", "email", "filter_tags"]
-                    core_excluded = core_attrs.map.select {|attr| options.dig(:exclude, attr.to_sym)}
-                    core_excluded.push("supervisor_id")
-
-                    entry.set_core(person, exclude: core_excluded)
-
-                    if session.tagtree && !options.dig(:exclude, :filter_tags)
-                      person.filter_tags = session.tagtree.user_tags(
-                        initial:          ini_tags,
-                        final:            person.filter_tags,
-                        preserve_custom:  true,
-                        add_custom:       true
-                      )
-                    end
-                  end
-
-                  entry.set_details(person) unless options.dig(:exclude, :details)
-
-                  unless options.dig(:exclude, :account)
-                    add_account = !person.account
-                    ini_pg_ids = person.account&.policy_group_ids || []
-
-                    account_excluded = []
-                    account_excluded.push("policy_group_ids") if options.dig(:exclude, :policy_groups)
-
-                    entry.set_account(person, exclude: account_excluded)
-
-                    person.account.send_invites = options[:send_invites] if options.key?(:send_invites)
-
-                    unless options.dig(:exclude, :policy_groups) && !create
-                      end_pg_ids = person.account.policy_group_ids || []
-
-                      if add_account && def_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_id]
-                      end
-
-                      # avoid false updates by preserving the original order
-                      person.account.policy_group_ids   = pgs.user_pg_ids(
-                        initial:         ini_pg_ids,
-                        final:           end_pg_ids
-                      )
-                    end
-
-                    person.account.permissions_custom = session.new_preset(person) unless options.dig(:exclude, :abilities)
-
-                    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
-                  update.add(person)
-
-                  # 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.supervisor_id = sup_id
-                        end
-                      end
-                    end
-                  end
-
-                else
-                  session.logger.error("Entry(#{i}) - this person does not exist: #{entry.to_s(:identify)}")
-                end
-              end
-            end
-
-          end
-
-        end
-      end
+class Eco::API::UseCases::DefaultCases::UpdateCase < Eco::API::Common::Loaders::UseCase
+  name "update"
+  type :sync
+
+  def main(entries, people, session, options, usecase)
+    micro    = session.micro
+    update   = session.new_job("main", "update", :update, usecase)
+    supers   = session.new_job("post", "supers", :update, usecase, :core)
+
+    micro.with_each_present(entries, people, options, log_starter: true) do |entry, person|
+      update.add(person)
+      micro.set_core_with_supervisor(entry, person, people, supers, options)
+      entry.set_details(person) unless options.dig(:exclude, :details)
+      micro.set_account(entry, person, options)
     end
   end
+
 end

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

@@ -1,64 +1,17 @@
-module Eco
-  module API
-    class UseCases
-      class DefaultCases
-        class UpdateDetailsCase < DefaultCase
-
-          def process
-            @cases.define("update-details", type: :sync) do |entries, people, session, options, usecase|
-              job    = session.job_group("main").new("update", usecase: usecase, type: :update, sets: [:core, :details])
-              supers = session.job_group("post").new("supers", usecase: usecase, type: :update, sets: :core)
-
-              strict_search = session.config.people.strict_search? && (!options[:search]&.key?(:strict) || options.dig(:search, :strict))
-
-              entries.each.with_index do |entry, i|
-                if person = people.find(entry, strict: strict_search)
-                  unless options.dig(:exclude, :core)
-                    core_attrs = ["name", "external_id", "email", "filter_tags"]
-                    core_excluded = core_attrs.map.select {|attr| options.dig(:exclude, attr.to_sym)}
-                    core_excluded.push("supervisor_id")
-
-                    entry.set_core(person, exclude: core_excluded) unless options.dig(:exclude, :core)
-
-                    if session.tagtree && !options.dig(:exclude, :filter_tags)
-                      person.filter_tags = session.tagtree.user_tags(
-                        initial:          ini_tags,
-                        final:            person.filter_tags,
-                        preserve_custom:  true,
-                        add_custom:       true
-                      )
-                    end
-                  end
-
-                  entry.set_details(person)
-
-                  job.add(person)
-
-                  # 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.supervisor_id = sup_id
-                        end
-                      end
-                    end
-                  end
-
-                else
-                  session.logger.error("Entry(#{i}) - this person does not exist: #{entry.to_s(:identify)}")
-                end
-              end
-            end
-          end
-
-        end
-      end
+class Eco::API::UseCases::DefaultCases::UpdateDetailsCase < Eco::API::Common::Loaders::UseCase
+  name "update-details"
+  type :sync
+
+  def main(entries, people, session, options, usecase)
+    micro    = session.micro
+    update   = session.new_job("main", "update", :update, usecase)
+    supers   = session.new_job("post", "supers", :update, usecase, :core)
+
+    micro.with_each_present(entries, people, options, log_starter: true) do |entry, person|
+      update.add(person)
+      micro.set_core_with_supervisor(entry, person, people, supers, options)
+      entry.set_details(person) unless options.dig(:exclude, :details)
     end
   end
+
 end

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

@@ -1,114 +1,19 @@
-module Eco
-  module API
-    class UseCases
-      class DefaultCases
-        class UpsertCase < DefaultCase
-
-          def process
-            @cases.define("upsert", type: :sync) do |entries, people, session, options, usecase|
-              creation = session.job_group("main").new("create", usecase: usecase, type: :create, sets: [:core, :details, :account])
-              update   = session.job_group("main").new("update", usecase: usecase, type: :update, sets: [:core, :details, :account])
-              supers   = session.job_group("post").new("supers", usecase: usecase, type: :update, sets: :core)
-
-              strict_search = session.config.people.strict_search? && (!options[:search]&.key?(:strict) || options.dig(:search, :strict))
-              pgs           = session.policy_groups
-
-              if session.config.people.default_usergroup?
-                def_id  = pgs.to_id(session.config.people.default_usergroup)
-              end
-
-              entries.each_with_index do |entry, i|
-                person = people.find(entry, strict: strict_search)
-                person = session.new_person if create = !person
-
-                unless options.dig(:exclude, :core) && !create
-                  ini_tags         = person.filter_tags || []
-
-                  core_excluded    = ["supervisor_id"]
-
-                  unless create
-                    core_attrs     = ["name", "external_id", "email", "filter_tags"]
-                    core_excluded += core_attrs.map.select {|attr| options.dig(:exclude, attr.to_sym)}
-                  end
-
-                  entry.set_core(person, exclude: core_excluded)
-                  if session.tagtree && !options.dig(:exclude, :filter_tags)
-                    person.filter_tags = session.tagtree.user_tags(
-                      initial:          ini_tags,
-                      final:            person.filter_tags,
-                      preserve_custom:  true,
-                      add_custom:       true
-                    )
-                  end
-                end
-
-                entry.set_details(person) unless options.dig(:exclude, :details)
-
-                unless options.dig(:exclude, :account)
-                  add_account = !person.account
-                  ini_pg_ids  = person.account&.policy_group_ids || []
-
-                  account_excluded = []
-                  account_excluded.push("policy_group_ids") if options.dig(:exclude, :policy_groups) && !create
-
-                  entry.set_account(person, exclude: account_excluded)
-
-                  person.account.send_invites = options[:send_invites] if options.key?(:send_invites)
-
-                  unless options.dig(:exclude, :policy_groups) && !create
-                    end_pg_ids = person.account.policy_group_ids || []
-
-                    if add_account && def_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_id]
-                    end
-
-                    # avoid false updates by preserving the original order
-                    person.account.policy_group_ids   = pgs.user_pg_ids(
-                      initial:         ini_pg_ids,
-                      final:           end_pg_ids
-                    )
-                  end
-
-                  person.account.permissions_custom = session.new_preset(person) unless !create && options.dig(:exclude, :abilities)
-
-                  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
-
-                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.supervisor_id = sup_id
-                      end
-                    end
-                  end
-                end
-
-              end
-            end
-          end
-
-        end
-      end
+class Eco::API::UseCases::DefaultCases::UpsertCase < Eco::API::Common::Loaders::UseCase
+  name "upsert"
+  type :sync
+
+  def main(entries, people, session, options, usecase)
+    micro    = session.micro
+    creation = session.new_job("main", "create", :create, usecase)
+    update   = session.new_job("main", "update", :update, usecase)
+    supers   = session.new_job("post", "supers", :update, usecase, :core)
+
+    micro.with_each(entries, people, options) do |entry, person|
+      person.new? ? creation.add(person) : update.add(person)
+      micro.set_core_with_supervisor(entry, person, people, supers, options)
+      entry.set_details(person) unless options.dig(:exclude, :details)
+      micro.set_account(entry, person, options)
     end
   end
+
 end

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

@@ -30,7 +30,6 @@ module Eco
           super(**default.merge(kargs))
         end
 
-
         # @param value [Eco::API::UseCases::UseCase] the usecase this InputOuput should be linked to
         def usecase=(value)
           raise "It should be a Eco::API::UseCases::UseCase. Given: #{value}" if !value.is_a?(Eco::API::UseCases::UseCase)
@@ -47,9 +46,9 @@ module Eco
         end
 
         # @see Eco::API::UseCases::BaseIO#params
-        # Same as its superclass but adding `usecase` parameter
-        def params(keyed: false)
-          super(keyed: keyed).tap do |res|
+        # Same as its superclass but adding `usecase` and `job` parameters
+        def params(keyed: false, all: false)
+          super(keyed: keyed, all: all).tap do |res|
             if keyed
               res.merge!(usecase: usecase)
               res.merge!(job: @job) if @job
@@ -62,19 +61,20 @@ module Eco
 
         def chain(usecase:)
           raise "It should be a UseCase. Given: #{usecase}" if !usecase.is_a?(UseCase)
-
-          aux_io = self.class.new(input: input, people: people, session: session, options: options, usecase: usecase)
-          kargs  = aux_io.params(keyed: true)
+          #aux_io = self.class.new(input: input, people: people, session: session, options: options, usecase: usecase)
+          #kargs  = aux_io.params(keyed: true)
+          kargs  = params(keyed: true, all: true).merge(usecase: usecase)
+          kargs.delete(:job)
 
           case self.type
           when :import
             kargs[:input]  = output
           when :filter
             kargs[:people] = output
-          when :transform, :sync, :export, :error_handler
+          when :transform, :sync, :export, :error_handler, :other
             # no redirections => should it redirect the input?
           end
-          self.class.new(kargs)
+          self.class.new(**kargs)
         end
       end
 

data/lib/eco/cli/config.rb

@@ -49,12 +49,19 @@ module Eco
       end
 
       def people_filters
-        @people_filters ||= Eco::CLI::Config::PeopleFilters.new(core_config: self)
+        @people_filters ||= Eco::CLI::Config::Filters::PeopleFilters.new(core_config: self)
         @people_filters.tap do |filters|
           yield(filters) if block_given?
         end
       end
 
+      def input_filters
+        @input_filters ||= Eco::CLI::Config::Filters::InputFilters.new(core_config: self)
+        @input_filters.tap do |filters|
+          yield(filters) if block_given?
+        end
+      end
+
       def usecases
         @usecases ||= Eco::CLI::Config::UseCases.new(core_config: self)
         @usecases.tap do |cases|
@@ -66,7 +73,8 @@ module Eco
   end
 end
 
+require_relative 'config/help'
 require_relative 'config/options_set'
 require_relative 'config/input'
-require_relative 'config/people_filters'
+require_relative 'config/filters'
 require_relative 'config/use_cases'

data/lib/eco/cli/config/default.rb

@@ -9,7 +9,8 @@ end
 
 require_relative 'default/options'
 require_relative 'default/input'
+require_relative 'default/input_filters'
 require_relative 'default/people'
-require_relative 'default/filters'
+require_relative 'default/people_filters'
 require_relative 'default/usecases'
 require_relative 'default/workflow'

data/lib/eco/cli/config/default/input_filters.rb

@@ -0,0 +1,58 @@
+ASSETS.cli.config do |cnf|
+  cnf.input_filters do |filters|
+
+    filters.add("-input-filter-tags-all", "only those that have ALL the specified tags separated by '|'") do |input, session, options|
+      tags = SCR.get_arg("-input-filter-tags-all", with_param: true).upcase.split("|")
+      options.deep_merge!(input: {filter: {filter_tags: {all: tags}}})
+      input.filter_tags_all(tags).tap do |filtered|
+        msg = "Filtered #{filtered.count} entries (out of #{input.count}) with 'all' filter_tags #{tags}"
+        session.logger.info(msg)
+      end
+    end
+
+    filters.add("-input-filter-tags-any", "only those that have ANY the specified tags separated by '|'") do |input, session, options|
+      tags = SCR.get_arg("-input-filter-tags-any", with_param: true).upcase.split("|")
+      options.deep_merge!(input: {filter: {filter_tags: {any: tags}}})
+      input.filter_tags_any(tags).tap do |filtered|
+        msg = "Filtered #{filtered.count} entries (out of #{input.count}) with 'any' filter_tags #{tags}"
+        session.logger.info(msg)
+      end
+    end
+
+    filters.add("-input-filter-tags-tree", "only those that have ANY tag in the specified subtrees separated by '|'") do |input, session, options|
+      top_tags = SCR.get_arg("-input-filter-tags-tree", with_param: true).upcase.split("|")
+      tags     = top_tags.each_with_object([])  do |top, tags|
+        tags.concat(session.tagtree.node(top).tags)
+      end.uniq
+      options.deep_merge!(input: {filter: {filter_tags: {tree: top_tags, any: tags}}})
+      input.filter_tags_any(tags).tap do |filtered|
+        msg = "Filtered #{filtered.count} entries (out of #{input.count}) with 'any' filter_tags in subtrees #{top_tags}"
+        session.logger.info(msg)
+      end
+    end
+
+    filters.add("-input-no-id", "only those that do not have 'id' or 'external_id' specified") do |input, session, options|
+      options.deep_merge!(input: {filter: {external_id: nil}})
+      input.select do |entry|
+        !!(entry.id || entry.external_id)
+      end.yield_self do |filtered|
+        input.newFrom filtered
+      end
+    end
+
+    #filters.add("-input-supervisors") do |people, session, options|
+    #  options.deep_merge!(input: {filter: {subordinates: true}})
+    #  people.newFrom people.to_a.select {|person| person.subordinates > 0}
+    #end
+
+    filters.add("-input-supervisor-id", "only those with certain supervisor id or external_id") do |input, session, options|
+      id     = SCR.get_arg("-input-supervisor-id", with_param: true)
+      options.deep_merge!(input: {filter: {supervisor_id: id}})
+      #unless sup = entries.find({"id" => id, "external_id" => id})
+      #  raise "Could not find anyone in the input with that id '#{id}'"
+      #end
+      input.supervisor_id(id)
+    end
+
+  end
+end