eco-helpers 0.6.0

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

@@ -0,0 +1,67 @@
+module Eco
+  module API
+    module UseCases
+      class DefaultCases
+        class HrisCase < BaseCase
+
+          def process
+            @cases.define("hris", type: :sync) do |entries, people, session, options|
+              # IMPORTANT: this two lines ensure that key users are preserved (only manually maintained)
+              #people  = people.exclude(session.discarded_entries)
+              #entries = entries.exclude(session.discarded_entries)
+
+              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)
+              #remove   = session.job_group("post").new("remove_account", type: :update, sets: :account)
+
+              #people.users.each_with_index  do |person, i|
+              #  if !entries.find(person)
+              #    remove.add(person) do |person|
+              #      person.account = nil
+              #      person
+              #    end
+              #  end
+              #end
+
+              entries.each.with_index do |entry, i|
+                person = people.find(entry)
+                person = session.new_person if create = !person
+
+                entry.set_core(person, exclude: "supervisor_id")
+                entry.set_details(person)
+                entry.set_account(person) #if !remove.people.find(entry)
+                person.account.permissions_custom = session.new_preset(person)
+
+                person.account.default_tag = person.account.filter_tags.first if person.account.filter_tags.length == 1
+
+                creation.add(person) if create
+                update.add(person) unless create
+
+                # set 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 = session.new_person(person: person.doc)
+                      person.sync
+                      person.supervisor_id = sup_id
+                      person
+                    end
+                  end
+                end
+
+              end
+
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Eco
+  module API
+    module UseCases
+      class DefaultCases
+        class NewEmailCase < BaseCase
+
+          def process
+            @cases.define("new-email", type: :sync) do |entries, people, session, options|
+              job = session.job_group("main").new("update", type: :update, sets: :core)
+
+              entries.each.with_index do |entry, i|
+                if person = people.find(entry)
+                  person.email = entry.email
+                  job.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/new_id_case.rb

@@ -0,0 +1,26 @@
+module Eco
+  module API
+    module UseCases
+      class DefaultCases
+        class NewIdCase < BaseCase
+
+          def process
+            @cases.define("new-id", type: :sync) do |entries, people, session|
+              job = session.job_group("main").new("update", type: :update, sets: :core)
+
+              entries.each.with_index do |entry, i|
+                if person = people.find(entry)
+                  person.external_id = entry.external_id
+                  job.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/refresh_presets.rb

@@ -0,0 +1,25 @@
+module Eco
+  module API
+    module UseCases
+      class DefaultCases
+        class RefreshPresets < BaseCase
+
+          def process
+            @cases.define("refresh-presets", type: :transform) do |people, session|
+              job = session.job_group("main").new("update", type: :update, sets: :account)
+
+              people = people.users
+              people.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

@@ -0,0 +1,22 @@
+module Eco
+  module API
+    module UseCases
+      class DefaultCases
+        class ReinviteCase < BaseCase
+
+          def process
+            @cases.define("reinvite", type: :transform) do |people, session|
+              invite = session.job_group("main").new("invite", type: :update, sets: :account)
+              people.users.each do |person|
+                person.account.send_invites = true
+                invite.add(person)
+              end
+              invite
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Eco
+  module API
+    module UseCases
+      class DefaultCases
+        class RemoveAccountCase < BaseCase
+
+          def process
+
+            @cases.define("remove-account", type: :transform) do |people, session|
+              update = session.job_group("main").new("update", 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|
+              update = session.job_group("main").new("update", type: :update, sets: [:core, :account])
+
+              entries.each.with_index do |entry, i|
+                if person = people.find(entry)
+                  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/default_cases/reset_landing_page_case.rb

@@ -0,0 +1,24 @@
+module Eco
+  module API
+    module UseCases
+      class DefaultCases
+        class ResetLandingPageCase < UseCases::BaseCase
+
+          def process
+            @cases.define("reset-landing-page", type: :transform) do |people, session|
+              job = session.job_group("main").new("update", type: :update, sets: :account)
+
+              people.users.each do |user|
+                user.account.landing_page_id = nil
+                job.add(user)
+              end
+
+              job
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module Eco
+  module API
+    module UseCases
+      class DefaultCases
+        class SetDefaultTagCase < BaseCase
+          # take the deepest tag (the one that is further down in the tree)
+          # different options (several nodes at the same depth):
+          # => take the common node between them (i.e. you have Hamilton and Auckland -> take New Zealand)
+          # => if there's no common node between them, take the `first` (unless they are at top level of the tree)
+
+          def process
+            @cases.define("set-default-tag", type: :transform) do |people, session, options|
+              if !session.tagtree
+                msg = "There is no tagtree definition in the configuration files\n" +
+                      "For this usecase to work out you need to define it."
+                session.logger.fatal(msg)
+                exit
+              end
+
+              # IMPORTANT: this two lines ensure that only people to be updated is selected
+              all_people = people
+              people = people.account_present
+
+              if people.length <= 0
+                session.logger.info("There are no people with account... aborting script")
+                exit
+              end
+
+              update   = session.job_group("main").new("update", type: :update, sets: :account)
+
+              people.each_with_index  do |person, i|
+                #next unless person.id == "5c527ba63f7690001243f5b2"
+                person.account.default_tag = session.tagtree.default_tag(*person.account.filter_tags)
+                update.add(person)
+              end
+
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module Eco
+  module API
+    module UseCases
+      class DefaultCases
+        class SetSupervisorCase < BaseCase
+
+          def process
+            @cases.define("set-supervisor", type: :sync) do |entries, people, session|
+              job = session.job_group("main").new("update", type: :update, sets: :core)
+
+              entries.each.with_index do |entry, i|
+                person = people.find(entry)
+
+                if !person
+                  session.logger.error("Entry(#{i}) - this person does not exist: #{entry.to_s(:identify)}")
+                else
+                  sup_id = entry.supervisor_id
+                  supervisor = people.person(id: sup_id, external_id: sup_id, email: sup_id)
+
+                  if !supervisor
+                    if entry.supervisor_id
+                      msg = "Entry(#{i}) - supervisor id #{entry.supervisor_id} does not exist for person: #{entry.to_s(:identify)}"
+                      session.logger.warn(msg)
+                    end
+                  else
+                    # set internal id of the supervisor (detect if actually changed)
+                    person.supervisor_id = supervisor.id
+                    job.add(person)
+                  end
+                end
+              end
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Eco
+  module API
+    module UseCases
+      class DefaultCases
+        class ToCsvCase < BaseCase
+
+          def process
+            @cases.define("to-csv", type: :export) do |people, session, options|
+              unless people && !people.empty?
+                session.logger.warn("No source people to create the file... aborting!")
+                next false
+              end
+
+              unless file = options[:file]
+                session.logger.error("Destination file not specified")
+                next false
+              end
+
+              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)
+                csv << entry.to_hash.keys
+                people.each do |person|
+                  csv << session.new_entry(person, dependencies: deps).to_hash.values
+                end
+              end
+              true
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Eco
+  module API
+    module UseCases
+      class DefaultCases
+        class UpdateDetailsCase < BaseCase
+
+          def process
+            @cases.define("update-details", type: :sync) do |entries, people, session, options|
+              job = session.job_group("main").new("update", type: :update, sets: [:core, :details])
+
+              entries.each.with_index do |entry, i|
+                if person = people.find(entry)
+                  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)
+                  entry.set_details(person)
+
+                  job.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/upsert_account_case.rb

@@ -0,0 +1,35 @@
+module Eco
+  module API
+    module UseCases
+      class DefaultCases
+        class UpsertAccountCase < BaseCase
+
+          def process
+            @cases.define("upsert-account", type: :sync) do |entries, people, session, options|
+              creation = session.job_group("main").new("create", type: :create, sets: [:core, :account])
+              update   = session.job_group("main").new("update", type: :update, sets: [:core, :account])
+
+              entries.each.with_index do |entry, i|
+                create = false
+                unless person = people.find(entry)
+                  create = true
+                  person = session.new_person
+                  entry.set_core(person)
+                  #entry.set_details(person)
+                end
+
+                entry.set_account(person)
+                person.account.permissions_custom = session.new_preset(person)
+                person.account.send_invites = false if options.key?(:send_invites) && !options(:send_invites)
+
+                creation.add(person) if create
+                update.add(person) unless create
+              end
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,177 @@
+module Eco
+  module API
+    module UseCases
+      class UseCase
+        TYPES = [:import, :filter, :transform, :sync, :export]
+        ALL_PARAMS = [:input, :people, :session, :options]
+        TYPE_PARAMS = {
+          import:    [:input, :session],
+          filter:    [:people, :session, :options],
+          transform: [:people, :session],
+          export:    [:people, :session, :options]
+        }
+        MAX_CHAINS   = 70
+        @@num_chains = 0
+
+        attr_reader :name, :type, :times_used
+
+        def initialize(name, type:, root:, options: {}, &block)
+
+          self.root = root
+          @case    = block
+          @name    = name
+          @type    = type
+          @options = options
+
+          @chains = []
+          @resolved_chains = nil
+          @times_used = 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 || {})
+
+          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_model = {
+            self => {
+              data: { input: input, people: people, session: session, options: opts, output: out }
+            }
+          }
+          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
+
+    end
+  end
+end