eco-helpers 1.5.1 → 1.5.2

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

@@ -1,26 +0,0 @@
-module Eco
-  module API
-    class UseCases
-      class DefaultCases
-        class RefreshPresets < DefaultCase
-
-          def process
-            @cases.define("refresh-presets", type: :transform) do |people, session, options, usecase|
-              job = session.job_group("main").new("update", usecase: usecase, type: :update, sets: :account)
-
-              users = people.users
-              session.logger.warn("There are no people with account amoung your #{people.length} people") unless users.length > 0
-              users.each do |person|
-                person.account.permissions_custom = session.new_preset(person)
-                job.add(person)
-              end
-
-            end
-          end
-
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-module Eco
-  module API
-    class UseCases
-      class DefaultCases
-        class ReinviteCase < DefaultCase
-
-          def process
-            @cases.define("reinvite", type: :transform) do |people, session, options, usecase|
-              invite = session.job_group("main").new("invite", usecase: usecase, type: :update, sets: :account)
-              people.users.each do |person|
-                person.account.send_invites = true
-                invite.add(person)
-              end
-              invite
-            end
-
-            @cases.define("reinvite", type: :sync) do |entries, people, session, options, usecase|
-              invite = session.job_group("main").new("invite", usecase: usecase, type: :update, sets: :account)
-
-              users         = people.users
-              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)
-                  if person.account
-                    person.account.send_invites = true
-                    invite.add(person)
-                  end
-                else
-                  session.logger.error("Entry(#{i}) - this person does not exist: #{entry.to_s(:identify)}")
-                end
-              end
-
-            end
-          end
-
-        end
-      end
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-module Eco
-  module API
-    class UseCases
-      class DefaultCases
-        class RemoveAccountCase < DefaultCase
-
-          def process
-
-            @cases.define("remove-account", type: :transform) do |people, session, options, usecase|
-              update = session.job_group("main").new("update", usecase: usecase, type: :update, sets: [:core, :account])
-              people.users.map do |person|
-                person.account = nil
-                update.add(person)
-              end
-            end
-
-            @cases.define("remove-account", type: :sync) do |entries, people, session, options, usecase|
-              update = session.job_group("main").new("update", usecase: usecase, type: :update, sets: [:core, :account])
-
-              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)
-                  person.account = nil
-                  update.add(person)
-                else
-                  session.logger.error("Entry(#{i}) - this person does not exist: #{entry.to_s(:identify)}")
-                end
-              end
-            end
-
-          end
-
-        end
-      end
-    end
-  end
-end

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

@@ -1,53 +0,0 @@
-module Eco
-  module API
-    class UseCases
-      class DefaultCases
-        class HrisCase < DefaultCase
-
-          def process
-            @cases.define("hris", type: :sync) do |entries, people, session, options, usecase|
-              micro = session.microcases
-
-              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)
-              leavers  = session.new_job("post", "leavers", :update, usecase, :account)
-
-              micro.with_leavers(entries, people, options, leavers) do |person|
-                person.supervisor_id = nil
-                person.account       = nil if person.account
-              end
-              
-              people.each_with_index  do |person, i|
-                if person = people.find(entry, strict: micro.strict_search(options))
-                if !entries.find(person, strict: strict: micro.strict_search(options))
-                  leavers.add(person) do |person|
-                    person.supervisor_id = nil
-                    person.account       = nil if person.account
-                  end
-                end
-              end
-
-              entries.each_with_index do |entry, i|
-                if person = people.find(entry, strict: micro.strict_search(options))
-                  update.add(person)
-                else
-                  person = session.new_person
-                  creation.add(person)
-                end
-
-                micro.set_core(entry, person, options, people, supers)
-                entry.set_details(person) unless options.dig(:exclude, :details)
-                micro.set_account(entry, person, options)
-              end
-
-            end
-
-
-          end
-
-        end
-      end
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-module Eco
-  module API
-    class UseCases
-      class DefaultCases
-        class UpdateCase < DefaultCase
-
-          def process
-            @cases.define("update", type: :sync) do |entries, people, session, options, usecase|
-              micro = session.microcases
-
-              update   = session.new_job("main", "update", :update, usecase)
-              supers   = session.new_job("post", "supers", :update, usecase, :core)
-
-              entries.each.with_index do |entry, i|
-                if person = people.find(entry, strict: micro.strict_search(**params))
-                  micro.set_core(entry, person, options, people, supers)
-                  entry.set_details(person) unless options.dig(:exclude, :details)
-                  micro.set_account(entry, person, options)
-
-                  update.add(person)
-                else
-                  session.logger.error("Entry(#{i}) - this person does not exist: #{entry.to_s(:identify)}")
-                end
-              end
-            end
-
-          end
-
-        end
-      end
-    end
-  end
-end

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

@@ -1,30 +0,0 @@
-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|
-              micro = session.microcases
-
-              update   = session.new_job("main", "update", :update, usecase)
-              supers   = session.new_job("post", "supers", :update, usecase, :core)
-
-              entries.each.with_index do |entry, i|
-                if person = people.find(entry, strict: micro.strict_search(options))
-                  micro.set_core(entry, person, options, people, supers)
-                  entry.set_details(person) unless options.dig(:exclude, :details)
-                  update.add(person)
-                else
-                  session.logger.error("Entry(#{i}) - this person does not exist: #{entry.to_s(:identify)}")
-                end
-              end
-            end
-          end
-
-        end
-      end
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-module Eco
-  module API
-    class UseCases
-      class DefaultCases
-        class UpsertCase < DefaultCase
-
-          def process
-            @cases.define("upsert", type: :sync) do |entries, people, session, options, usecase|
-              micro = session.microcases
-
-              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)
-
-              entries.each_with_index do |entry, i|
-                params = [entry, person, session, options]
-
-                if person = people.find(entry, strict: micro.strict_search(options))
-                  update.add(person)
-                else
-                  person = session.new_person
-                  creation.add(person)
-                end
-
-                micro.set_core(entry, person, options, people, supers)
-                entry.set_details(person) unless options.dig(:exclude, :details)
-                micro.set_account(entry, person, options)
-              end
-            end
-          end
-
-        end
-      end
-    end
-  end
-end

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

@@ -1,70 +0,0 @@
-ASSETS.cli.config do |cnf|
-  cnf.people_filters do |filters|
-
-    filters.add("-only-users") do |people, session, options|
-      options.deep_merge!(people: {filter: {account: true}})
-      people.users
-    end
-
-    filters.add("-no-account") do |people, session, options|
-      options.deep_merge!(people: {filter: {account: false}})
-      people.account_present(false)
-    end
-
-    filters.add("-with-details") do |people, session, options|
-      options.deep_merge!(people: {filter: {details: true}})
-      people.details_present
-    end
-
-    filters.add("-no-id") do |people, session, options|
-      options.deep_merge!(people: {filter: {external_id: nil}})
-      people.external_id_present(false)
-    end
-
-    filters.add("-supervisors") do |people, session, options|
-      options.deep_merge!(people: {filter: {subordinates: true}})
-      people.newFrom people.to_a.select {|person| person.subordinates > 0}
-    end
-
-    filters.add("-supervisor-id") do |people, session, options|
-      id     = SCR.get_arg("-supervisor-id", with_param: true)
-      options.deep_merge!(people: {filter: {supervisor_id: id}})
-      unless sup = people.person(id: id, external_id: id, email: id, strict: true)
-        status = session.batch.search([{"id" => id}])
-        sup    = status.people.first
-      end
-      raise "Supervisor with id '#{id}' does not exist" unless sup
-      people.supervisor_id(sup.id)
-    end
-
-    filters.add("-no-default-tag") do |people, session, options|
-      options.deep_merge!(people: {filter: {account: {default_tag: nil}}})
-      filtered = people.select do |person|
-        !person.account&.default_tag
-      end
-      people.newFrom filtered
-    end
-
-    filters.add("-schema-id") do |people, session, options|
-      sch_name = SCR.get_arg("-schema-id", with_param: true)
-      sch_id   = session.schemas.to_id(sch_name)
-
-      unless sch_id
-        msg = "You need to specify the schema id"
-        session.logger.error(msg)
-        exit(1)
-      end
-
-      options.deep_merge!(people: {filter: {details: {schema_id: sch_id}}})
-      session.logger.info("Filtering people entries with schema #{session.schemas.to_name(sch_id)}")
-      
-      filtered = people.select do |person|
-        person.details && (person.details.schema_id == sch_id)
-      end
-      session.logger.info("Filtered #{filtered.count} people out of #{people.count} total")
-
-      people.newFrom filtered
-    end
-
-  end
-end

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

@@ -1,38 +0,0 @@
-module Eco
-  class CLI
-    class Config
-      class PeopleFilters
-        attr_reader :core_config
-
-        def initialize(core_config:)
-          @core_config = core_config
-          @filters     = {}
-        end
-
-        def add(option)
-          raise "Missing block to define the filters builder" unless block_given?
-          callback = Proc.new
-          [option].flatten.compact.each do |opt|
-            @filters[opt] = callback
-          end
-          self
-        end
-
-        def process(io:)
-          unless io && io.is_a?(Eco::API::UseCases::BaseIO)
-            raise "You need to provide Eco::API::UseCases::BaseIO object. Given: #{io.class}"
-          end
-
-          io = io.new(type: :transform)
-          @filters.each do |arg, callback|
-            if SCR.get_arg(arg)
-              io = io.new(people: callback.call(*io.params))
-            end
-          end
-          io.people
-        end
-
-      end
-    end
-  end
-end