eco-helpers 1.4.2 → 1.5.4

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,98 +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)
-                  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/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