eco-helpers 0.6.0

data/lib/eco/api/session_config/people.rb

@@ -0,0 +1,89 @@
+module Eco
+  module API
+    class SessionConfig
+      class People < Hash
+
+        def initialize(root:)
+          super(nil)
+          @root = root
+        end
+
+        def cache=(file)
+          self["cache"] = file
+        end
+
+        def cache
+          self["cache"]
+        end
+
+        # api queried logs
+        def requests_folder=(folder)
+          self["requests_folder"] = folder
+        end
+
+        def requests_folder
+          self["requests_folder"]
+        end
+
+        # people to exclude from update feeds
+        def discarded_file=(file)
+          self["discarded_file"] = file
+        end
+
+        def discarded_file
+          self["discarded_file"]
+        end
+
+        # internal-external fields map
+        def fields_mapper=(file)
+          self["fields_mapper"] = file
+        end
+
+        def fields_mapper
+          self["fields_mapper"]
+        end
+
+        # person model
+        def default_schema=(name)
+          self["default_schema"] = name
+        end
+
+        def default_schema
+          self["default_schema"]
+        end
+
+        def presets_custom=(file)
+          self["presets_custom"] = file
+        end
+
+        def presets_custom
+          self["presets_custom"]
+        end
+
+        def presets_map=(file)
+          self["presets_map"] = file
+        end
+
+        def presets_map
+          self["presets_map"]
+        end
+
+        # CUSTOM PERSON PARSERS
+        def person_parser(format: :csv)
+          self["parsers"] ||= Eco::API::Common::People::PersonParser.new
+          new_parsers = Eco::API::Common::People::PersonParser.new
+
+          yield(new_parsers, self)
+
+          parsers = self["parsers"][format]
+          self["parsers"][format] = parsers ? parsers.merge(new_parsers) : new_parsers
+        end
+
+        def parser(format: :csv)
+          self.dig("parsers", format)
+        end
+
+      end
+    end
+  end
+end

data/lib/eco/api/session_config/s3_bucket.rb

@@ -0,0 +1,62 @@
+module Eco
+  module API
+    class SessionConfig
+      class S3Bucket < Hash
+
+        def initialize(root:)
+          super(nil)
+          @root = root
+        end
+
+        def name=(value)
+          self["name"] = value
+        end
+
+        def name
+          self["name"]
+        end
+
+        def prefix=(value)
+          self["prefix"] = value
+        end
+
+        def prefix
+          self["prefix"]
+        end
+
+        def access_key_id=(key)
+          self["access_key_id"] = key
+        end
+
+        def access_key_id
+          self["access_key_id"]
+        end
+
+        def secret_access_key=(key)
+          self["secret_access_key"] = key
+        end
+
+        def secret_access_key
+          self["secret_access_key"]
+        end
+
+        def region=(region)
+          self["region"] = region
+        end
+
+        def region
+          self["region"]
+        end
+
+        def target_directories=(value)
+          self["target_directories"] = [value].flatten
+        end
+
+        def target_directories
+          self["target_directories"]
+        end
+
+      end
+    end
+  end
+end

data/lib/eco/api/session_config/use_cases.rb

@@ -0,0 +1,30 @@
+module Eco
+  module API
+    class SessionConfig
+      class UseCases < Hash
+
+        def initialize(root:)
+          super(nil)
+          @root = root
+        end
+
+        # CUSTOM USE CASES
+        def add
+          self["use_group"] ||= Eco::API::UseCases::UseGroup.new
+          new_group = Eco::API::UseCases::UseGroup.new
+
+          yield(new_group, self)
+
+          group = self["use_group"]
+          group = group ? group.merge(new_group) : group
+          self["use_group"] = group
+        end
+
+        def use_group
+          self["use_group"]
+        end
+
+      end
+    end
+  end
+end

data/lib/eco/api/usecases.rb

@@ -0,0 +1,12 @@
+module Eco
+  module API
+    module UseCases
+    end
+  end
+end
+
+#require_relative 'usecases/case_data'
+require_relative 'usecases/base_case'
+require_relative 'usecases/use_case'
+require_relative 'usecases/use_group'
+require_relative 'usecases/default_cases'

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

@@ -0,0 +1,14 @@
+module Eco
+  module API
+    module UseCases
+      class BaseCase
+        def initialize(cases, **options)
+          @cases = cases
+          @options = options
+        end
+
+        def process; end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Eco
+  module API
+    module UseCases
+      class UseData
+        attr_reader :usecase, :data
+        def initialize(usecase:, data:)
+          @case = usecase
+          @data = data
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module Eco
+  module API
+    module UseCases
+      class DefaultCases < UseGroup
+
+        def initialize(*args)
+          super(*args)
+          define_defaults
+        end
+
+        private
+
+        def define_defaults
+          ResetLandingPageCase.new(self).process
+          ToCsvCase.new(self).process
+          EmailAsIdCase.new(self).process
+          NewIdCase.new(self).process
+          NewEmailCase.new(self).process
+          SetSupervisorCase.new(self).process
+          UpdateDetailsCase.new(self).process
+          CreateDetailsCase.new(self).process
+          CreateDetailsWithSupervisorCase.new(self).process
+          ReinviteCase.new(self).process
+          DeleteCase.new(self).process
+          RemoveAccountCase.new(self).process
+          RefreshPresets.new(self).process
+          ChangeEMailCase.new(self).process
+          SetDefaultTagCase.new(self).process
+          UpsertAccountCase.new(self).process
+          HrisCase.new(self).process
+        end
+      end
+    end
+  end
+end
+
+require_relative 'default_cases/reset_landing_page_case'
+require_relative 'default_cases/to_csv_case'
+require_relative 'default_cases/email_as_id_case'
+require_relative 'default_cases/new_id_case'
+require_relative 'default_cases/new_email_case'
+require_relative 'default_cases/set_supervisor_case'
+require_relative 'default_cases/update_details_case'
+require_relative 'default_cases/create_details_case'
+require_relative 'default_cases/create_details_with_supervisor_case'
+require_relative 'default_cases/reinvite_case'
+require_relative 'default_cases/delete_case'
+require_relative 'default_cases/remove_account_case'
+require_relative 'default_cases/refresh_presets'
+require_relative 'default_cases/change_email_case'
+require_relative 'default_cases/set_default_tag_case'
+require_relative 'default_cases/upsert_account_case'
+require_relative 'default_cases/hris_case'

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

@@ -0,0 +1,47 @@
+module Eco
+  module API
+    module UseCases
+      class DefaultCases
+        class ChangeEMailCase < BaseCase
+
+          def process
+            @cases.define("change-email", type: :sync) do |entries, people, session|
+              remove = session.job_group("main").new("remove account", type: :update, sets: :account)
+              change = session.job_group("main").new("change email", type: :update, sets: :core)
+              add_account = session.job_group("post").new("add account", type: :update, sets: :account)
+
+              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
+                  unless entry.email.downcase == person.email
+                    account = person.account
+                    person.account = nil
+                    remove.add(person)
+
+                    new_email = entry.email
+                    change.add(person) do |person|
+                      person.sync
+                      person.email = new_email
+                      person
+                    end
+
+                    add_account.add(person) do |person|
+                      person.sync
+                      person.account = account
+                      person
+                    end
+                  end
+
+                end
+              end
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Eco
+  module API
+    module UseCases
+      class DefaultCases
+        class CreateDetailsCase < UseCases::BaseCase
+
+          def process
+            @cases.define("create-details", type: :sync) do |entries, people, session, options|
+              creation = session.job_group("main").new("create", type: :create, sets: [:core, :details])
+
+              entries.each.with_index do |entry, i|
+                if person = people.find(entry)
+                  session.logger.error("Entry(#{i}) - this person (id: '#{person.id}') already exists: #{entry.to_s(:identify)}")
+                else
+                  person = session.new_person
+                  entry.set_core(person, exclude: "supervisor_id")
+                  entry.set_details(person)
+
+                  creation.add(person)
+                end
+              end
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module Eco
+  module API
+    module UseCases
+      class DefaultCases
+        class CreateDetailsWithSupervisorCase < UseCases::BaseCase
+
+          def process
+            # good candidate to do @cases.case("create-details").use.chain(@cases.case("set-supervisor").use)
+            @cases.define("create-details-with-supervisor", type: :sync) do |entries, people, session|
+              creation = session.job_group("main").new("create", type: :create, sets: [:core, :details])
+              supers   = session.job_group("post").new("supers", type: :update, sets: :core)
+
+              entries.each.with_index do |entry, i|
+                if person = people.find(entry)
+                  session.logger.error("Entry(#{i}) - this person (id: '#{person.id}') already exists: #{entry.to_s(:identify)}")
+                else
+                  person = session.new_person
+                  entry.set_core(person, exclude: "supervisor_id")
+                  entry.set_details(person)
+
+                  creation.add(person)
+
+                  # 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
+end

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

@@ -0,0 +1,20 @@
+module Eco
+  module API
+    module UseCases
+      class DefaultCases
+        class DeleteCase < BaseCase
+
+          def process
+            @cases.define("delete", type: :transform) do |people, session|
+              delete = session.job_group("main").new("delete", type: :delete, sets: [:core, :details, :account])
+              people.map do |person|
+                delete.add(person)
+              end
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Eco
+  module API
+    module UseCases
+      class DefaultCases
+        class EmailAsIdCase < BaseCase
+
+          def process
+            @cases.define("email-as-id", type: :transform) do |people, session|
+              job = session.job_group("main").new("update", type: :update, sets: :core)
+
+              people.each do |person|
+                person.external_id = person.email
+                job.add(person)
+              end
+
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end