eco-helpers 1.5.1 → 1.5.6

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

@@ -1,19 +0,0 @@
-module Eco
-  module API
-    class UseCases
-      class DefaultCase
-
-        def initialize(cases, **options)
-          raise "Expected a Eco::API::UseCases object. Given #{cases.class}" if !cases.is_a?(Eco::API::UseCases)
-          @cases   = cases
-          @options = options
-        end
-
-        def process
-          raise "You should reimplement this method"
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-module Eco
-  module API
-    class UseCases
-      class DefaultCases
-        class DeleteCase < DefaultCase
-
-          def process
-            @cases.define("delete", type: :transform) do |people, session, options, usecase|
-              delete = session.job_group("main").new("delete", usecase: usecase, type: :delete, sets: [:core, :details, :account])
-              people.each_with_index do |person, i|
-                delete.add(person)
-              end
-            end
-
-            @cases.define("delete", type: :sync) do |entries, people, session, options, usecase|
-              delete = session.job_group("main").new("delete", usecase: usecase, type: :delete, sets: [:core, :details, :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)
-                  delete.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/default_cases/recover_db_case.rb

@@ -1,99 +0,0 @@
-module Eco
-  module API
-    class UseCases
-      class DefaultCases
-        class RecoverDBCase < DefaultCase
-
-          def process
-            @cases.define("recover-db", type: :sync) do |entries, people, session, options, usecase|
-              unless entries.is_a?(Eco::API::Organization::People)
-                raise "Your input should be an 'Eco::API::Organization::People' object. Got: #{entries.class}"
-              end
-
-              if options.dig(:include, :create)
-                creation = session.job_group("main").new("create", usecase: usecase, type: :create, sets: [:core, :details, :account])
-              end
-
-              update   = session.job_group("main").new("update", usecase: usecase, type: :update, sets: [:core, :details, :account])
-
-              if options.dig(:include, :delete)
-                remove   = session.job_group("main").new("remove", usecase: usecase, type: :delete, sets: [:core, :details, :account])
-                people.exclude(entries).map {|person| remove.add(person)}
-              end
-
-              strict_search = session.config.people.strict_search? && (!options[:search]&.key?(:strict) || options.dig(:search, :strict))
-              pgs = session.policy_groups
-
-              not_exist = []
-
-              entries.each.with_index do |entry, i|
-                create = ! (person = people.find(entry, strict: strict_search))
-
-                if create && !options.dig(:include, :create)
-                  not_exist.push(entry);
-                else
-                  person = session.new_person if create
-
-                  unless options.dig(:exclude, :core)
-                    person.external_id   = entry.external_id   unless options.dig(:exclude, :external_id)
-                    person.name          = entry.name          unless options.dig(:exclude, :name)
-                    person.email         = entry.email         unless options.dig(:exclude, :email)
-                    person.supervisor_id = entry.supervisor_id unless options.dig(:exclude, :supervisor)
-                    person.filter_tags   = entry.filter_tags || [] unless options.dig(:exclude, :filter_tags)
-                    person.freemium      = entry.freemium
-                  end
-
-                  unless options.dig(:exclude, :account)
-                    #person.account = entry.account
-                    if eaccount = entry.account
-                      person.account ||= {}
-                      person.account.default_tag          = eaccount.default_tag  unless options.dig(:exclude, :filter_tags)
-
-                      unless options.dig(:exclude, :policy_groups) && person.account.policy_group_ids
-                        person.account.policy_group_ids   = eaccount.policy_group_ids
-                      end
-
-                      unless options.dig(:exclude, :abilities) && (person.account.permissions_preset || person.account.permissions_custom)
-                        person.account.permissions_preset = eaccount.permissions_preset if eaccount.permissions_preset
-                        person.account.permissions_custom = eaccount.permissions_custom
-                      end
-                      person.account.login_provider_ids = eaccount.login_provider_ids if eaccount.login_provider_ids
-                      person.account.accept_eula        = eaccount.accept_eula if eaccount.accept_eula
-
-                      if eaccount.preferences
-                        person.account.doc["preferences"] = JSON.parse((eaccount.doc["preferences"] || {}).to_json)
-                      end
-
-                      person.account.starred_ids        = eaccount.starred_ids     if eaccount.landing_page_id
-                      person.account.landing_page_id    = eaccount.landing_page_id if eaccount.landing_page_id
-
-                      person.account&.send_invites = options[:send_invites] if options.key?(:send_invites)
-                    end
-                  end
-
-                  unless options.dig(:exclude, :details)
-                    person.details = entry.details
-                  end
-
-                  creation.add(person) if create
-                  update.add(person) unless create
-                end
-              end
-
-              unless not_exist.empty?
-                session.logger.error("There were #{not_exist.length} entries of the back up that do not exist in the (filtered?) people manager")
-                session.logger.error("Some examples:")
-                not_exist.slice(0, 4).each_with_index do |entry, i|
-                  session.logger.error("Entry(#{i}) - this person does not exist: #{entry.name} (#{entry.email})")
-                end
-              end
-
-            end
-          end
-
-        end
-
-      end
-    end
-  end
-end

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