eco-helpers 3.0.20 → 3.0.22

data/lib/eco/api/usecases/cli/dsl.rb

@@ -34,6 +34,7 @@ module Eco
           # Unless specified, assume Cli class hangs from its case namespace
           def usecase
             raise "#{self} is to use to extend a class" unless is_a?(Class)
+
             @usecase ||= Kernel.const_get(to_s.split('::')[0..-2].join('::'))
           end
 
@@ -60,6 +61,7 @@ module Eco
 
           def callback(&block)
             return @callback unless block_given?
+
             @callback = block
           end
 
@@ -69,7 +71,7 @@ module Eco
 
           def add_option(arg, desc = nil, &block)
             tap do
-              "Overriding option '#{arg}' on case '#{name}'" if options.key?(arg)
+              puts "Overriding option '#{arg}' on case '#{name}'" if options.key?(arg)
               @options[arg] = Eco::API::UseCases::Cli::Option.new(arg, desc, &block)
             end
           end

data/lib/eco/api/usecases/default/people/treat/analyse_people_case.rb

@@ -4,9 +4,7 @@ class Eco::API::UseCases::Default::People::Treat::Analyse < Eco::API::Common::Lo
 
   require_relative 'cli/analyse_people_cli'
 
-  attr_reader :people
-
-  def main(_people, _session, options, _usecase)
+  def main(*_args)
     options[:end_get] = false
 
     if case_options[:identify_duplicates]
@@ -97,7 +95,12 @@ class Eco::API::UseCases::Default::People::Treat::Analyse < Eco::API::Common::Lo
     opts.deep_merge!(export: {options: {internal_names: true}})
     # opts.deep_merge!(export: {options: {split_schemas: true}})
 
-    session.process_case("to-csv", type: :export, people: data, options: opts.merge(options.slice(:export)))
+    session.process_case(
+      'to-csv',
+      type:   :export,
+      data:    data,
+      options: opts.merge(options.slice(:export))
+    )
   end
 
   def unique_words?

data/lib/eco/api/usecases/default/people/treat/supers_cyclic_identify_case.rb

@@ -8,9 +8,7 @@ class Eco::API::UseCases::Default::People::Treat::SupersCyclicIdentify < Eco::AP
   OUT_TIME_FORMAT = '%Y%m%dT%H%M%S'.freeze
   OUT_FILENAME    = "cyclic_supers".freeze
 
-  attr_reader :people
-
-  def main(_people, _session, options, _usecase)
+  def main(*_args)
     options[:end_get] = false
     save!(cyclic_sets)
   end

data/lib/eco/api/usecases/default/people/treat/supers_hierarchy_case.rb

@@ -8,12 +8,8 @@ class Eco::API::UseCases::Default::People::Treat::SupersHierarchy < Eco::API::Co
   OUT_TIME_FORMAT = '%Y%m%dT%H%M%S'.freeze
   OUT_FILENAME    = "supers_hierarchy".freeze
 
-  attr_reader :people
-
-  def main(people, _session, options, _usecase)
+  def main(*_args)
     options[:end_get] = false
-    @people = people
-
     save!(hierarchy, file: output_filename)
   end
 

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

@@ -2,8 +2,8 @@ class Eco::API::UseCases::DefaultCases::EntriesToCsv < Eco::API::Common::Loaders
   name "entries-to-csv"
   type :import
 
-  def main(entries, session, options, usecase)
-    entries.export(filename)
+  def main(*_args)
+    input.export(filename)
   end
 
   private

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

@@ -3,10 +3,8 @@ class Eco::API::UseCases::DefaultCases::HrisCase < Eco::API::Common::Loaders::Us
   type :sync
 
   attr_reader :creation, :update, :supers, :leavers
-  attr_reader :people
 
   def main(entries, people, session, options, usecase)
-    @people = people
     require_only_one_schema!
     micro     = session.micro
     @leavers  = session.new_job("pre", "leavers",  :update, usecase, :account)

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

@@ -4,11 +4,8 @@ class Eco::API::UseCases::DefaultCases::ToCsvCase < Eco::API::Common::Loaders::U
 
   OUT_FILENAME = 'pm'.freeze
 
-  attr_reader :people
-
   def main(people, _session, options, _usecase)
     options[:end_get] = false
-    @people = people
 
     unless people && !people.empty?
       log(:warn) { "No source people to create the file... aborting!" }
@@ -113,9 +110,9 @@ class Eco::API::UseCases::DefaultCases::ToCsvCase < Eco::API::Common::Loaders::U
 
   def by_schema
     people.group_by do |person|
-      if (details = person.details)
-        details.schema_id
-      end
+      next unless (details = person.details)
+
+      details.schema_id
     end.transform_values do |persons|
       people.newFrom persons
     end

data/lib/eco/api/usecases/graphql/base.rb

@@ -2,13 +2,13 @@ class Eco::API::UseCases::GraphQL::Base < Eco::API::Common::Loaders::UseCase
   class NotImplementedMethod < StandardError
   end
 
-  name "graphql-base"
+  name 'graphql-base'
   type :other
 
   include Eco::API::UseCases::GraphQL::Helpers::Base
   include Eco::Language::Methods::CallDetector
 
-  def main(_sess, options, _case)
+  def main(*_args)
     options[:end_get] = false
     process
   end
@@ -16,6 +16,7 @@ class Eco::API::UseCases::GraphQL::Base < Eco::API::Common::Loaders::UseCase
   # Write here your script
   def process
     return unless called_via?(Eco::API::UseCases::GraphQL::Base, __method__)
+
     raise NotImplementedMethod, "You need to inherit from this class ('#{self.class}')"
   end
 end

data/lib/eco/api/usecases/graphql/helpers/base/case_env.rb

@@ -13,7 +13,7 @@ module Eco::API::UseCases::GraphQL::Helpers::Base
     end
 
     def simulate?
-      options[:simulate]
+      options[:simulate] || options[:dry_run]
     end
   end
 end

data/lib/eco/api/usecases/graphql/helpers/base/error_handling.rb

@@ -32,9 +32,9 @@ module Eco::API::UseCases::GraphQL::Helpers::Base
     rescue StandardError => err
       self.exception ||= err
 
-      unless exception_already_captured?(err)
-        log(:error) { err.patch_full_message }
-      end
+      return unless exception_already_captured?(err)
+
+      log(:error) { err.patch_full_message }
     rescue SystemExit
       @exiting = true
       raise

data/lib/eco/api/usecases/graphql/helpers/contractors/base/load.rb

@@ -0,0 +1,17 @@
+module Eco::API::UseCases::GraphQL::Helpers::Contractors
+  module Base
+    module Load
+      include Eco::API::UseCases::GraphQL::Helpers::Base
+
+      def load_contractors
+        contractor_entities
+      end
+
+      private
+
+      def contractor_entities
+        graphql.currentOrganization.contractorEntities
+      end
+    end
+  end
+end

data/lib/eco/api/usecases/graphql/helpers/contractors/base.rb

@@ -0,0 +1,8 @@
+require_relative 'base/load'
+
+module Eco::API::UseCases::GraphQL::Helpers::Contractors
+  module Base
+    include Eco::API::UseCases::GraphQL::Helpers::Base
+    include Load
+  end
+end

data/lib/eco/api/usecases/graphql/helpers/contractors.rb

@@ -0,0 +1,6 @@
+module Eco::API::UseCases::GraphQL::Helpers
+  module Contractors
+  end
+end
+
+require_relative 'contractors/base'

data/lib/eco/api/usecases/graphql/helpers/location/base.rb

@@ -14,9 +14,9 @@ module Eco::API::UseCases::GraphQL::Helpers::Location
       @target_structure_id ||= current_tree.id if current_tree.respond_to?(:id)
       return @target_structure_id if @target_structure_id
 
-      msg  = "Const TARGET_STRUCTURE_ID has not been defined, "
-      msg << "nor options(:source, :structure_id). "
-      msg << "Infering active locations structure."
+      msg  = 'Const TARGET_STRUCTURE_ID has not been defined, '
+      msg << 'nor options(:source, :structure_id). '
+      msg << 'Infering active locations structure.'
       log(:warn) { msg }
 
       # a backup happens:
@@ -51,7 +51,8 @@ module Eco::API::UseCases::GraphQL::Helpers::Location
     end
 
     def target_structure_id_const
-      return nil unless self.class.const_defined?(:TARGET_STRUCTURE_ID)
+      return unless self.class.const_defined?(:TARGET_STRUCTURE_ID)
+
       self.class.const_get(:TARGET_STRUCTURE_ID)
     end
   end

data/lib/eco/api/usecases/graphql/helpers/location/command.rb

@@ -15,7 +15,7 @@ module Eco::API::UseCases::GraphQL::Helpers::Location
     # @param commands [Array<Hash>]
     def input(commands, force_continue: force_continue?)
       {
-        clientMutationId: "",
+        clientMutationId: '',
         id:               target_structure_id,
         force:            force_continue,
         commands:         commands
@@ -34,7 +34,7 @@ module Eco::API::UseCases::GraphQL::Helpers::Location
 
       if batch_input[:commands].empty?
         msg  = "#{dry_run_msg}No commands for '#{desc}'."
-        msg << " Skipping batch..." unless simulate?
+        msg << ' Skipping batch...' unless simulate?
         log(:info) { msg }
 
         return

data/lib/eco/api/usecases/graphql/helpers.rb

@@ -5,3 +5,4 @@ end
 
 require_relative 'helpers/base'
 require_relative 'helpers/location'
+require_relative 'helpers/contractors'

data/lib/eco/api/usecases/graphql/samples/contractors/dsl.rb

@@ -0,0 +1,5 @@
+module Eco::API::UseCases::GraphQL::Samples
+  module Contractors::DSL
+    include Eco::API::UseCases::GraphQL::Helpers::Contractors::Base
+  end
+end

data/lib/eco/api/usecases/graphql/samples/contractors.rb

@@ -0,0 +1,17 @@
+module Eco::API::UseCases::GraphQL
+  class Samples::Contractors < Eco::API::UseCases::GraphQL::Base
+    name 'contractors_base'
+    target_model :contractors
+
+    require_relative 'contractors/dsl'
+    include Eco::API::UseCases::GraphQL::Samples::Contractors::DSL
+
+    def main(*_args)
+      options[:end_get] = false
+    end
+
+    def process
+      raise 'Please do not use this method with contractor use cases. Use main'
+    end
+  end
+end

data/lib/eco/api/usecases/graphql/samples/location/service/base.rb

@@ -1,9 +1,9 @@
+# @todo maybe delete, it isn't being used anywhere
 module Eco::API::UseCases::GraphQL::Samples
   module Location::Service
     # Base class to create service classes that work like a use case
     class Base
       include Eco::API::UseCases::GraphQL::Samples::Location::DSL
-
     end
   end
 end

data/lib/eco/api/usecases/graphql/samples/location.rb

@@ -1,6 +1,6 @@
 module Eco::API::UseCases::GraphQL
   class Samples::Location < Eco::API::UseCases::GraphQL::Base
-    name "location-base"
+    name 'location-base'
 
     require_relative 'location/dsl'
     include Eco::API::UseCases::GraphQL::Samples::Location::DSL

data/lib/eco/api/usecases/graphql/samples.rb

@@ -4,3 +4,4 @@ module Eco::API::UseCases::GraphQL
 end
 
 require_relative 'samples/location'
+require_relative 'samples/contractors'

data/lib/eco/api/usecases/ooze_samples/ooze_base_case.rb

@@ -211,7 +211,6 @@ class Eco::API::UseCases::OozeSamples::OozeBaseCase < Eco::API::Common::Loaders:
       return
     end
 
-    patch = patch_doc(ooze)
     # store the request
     File.open(SAVE_PATCH, "w") do |file|
       #file << (patch_doc || {}).to_json

data/lib/eco/api/usecases/ooze_samples/ooze_run_base_case.rb

@@ -1,9 +1,9 @@
 # Base class to run a script against a single ooze.
 class Eco::API::UseCases::OozeSamples::OozeRunBaseCase < Eco::API::UseCases::OozeSamples::OozeBaseCase
-  name "ooze-run-base"
+  name 'ooze-run-base'
   type :other
 
-  SAVE_PATCH = "ooze_patch_update.json".freeze
+  SAVE_PATCH = 'ooze_patch_update.json'.freeze
 
   def main(session, options, usecase)
     super(session, options, usecase) do
@@ -21,8 +21,8 @@ class Eco::API::UseCases::OozeSamples::OozeRunBaseCase < Eco::API::UseCases::Ooz
     end
   end
 
-  def process_ooze(page = target)
-    raise "You need to redefine this method"
+  def process_ooze(_page = target)
+    raise 'You need to redefine this method'
   end
 
   private
@@ -50,15 +50,15 @@ class Eco::API::UseCases::OozeSamples::OozeRunBaseCase < Eco::API::UseCases::Ooz
   end
 
   def exit_if_no_changes!
-    return if !!patch_doc["page"]
+    return unless patch_doc['page'].nil?
 
-    log(:info) { "No Changes!!" }
+    log(:info) { 'No Changes!!' }
     exit(0)
   end
 
   def prompt_to_confirm!
-    micro.prompt_user("Do you want to proceed (y/N)?", default: "Y") do |response|
-      exit(1) unless response.upcase.start_with?("Y")
+    micro.prompt_user('Do you want to proceed (y/N)?', default: 'Y') do |response|
+      exit(1) unless response.upcase.start_with?('Y')
     end
   end
 end

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

@@ -0,0 +1,12 @@
+class Eco::API::UseCases::UseCase
+  module Chainer
+    def chainer
+      # @todo: root is a Eco::API::UseCases that will not point to this new case.
+      # => Moreover, the name and type will be the same as self
+      Eco::API::UseCases::UseCaseChain.new(
+        usecase: self,
+        root:    @root
+      )
+    end
+  end
+end

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

@@ -2,18 +2,18 @@ module Eco
   module API
     class UseCases
       class UseCase < BaseCase
-        @types = BaseCase.types
+        require_relative 'use_case/chainer'
+        include Chainer
 
-        attr_reader :name, :type, :times_launched
+        attr_reader :name, :type, :model
         attr_reader :options
+        attr_reader :times_launched
 
-        def initialize(name, type:, root:, &block)
-          invalid_type_err = InvalidType.new(
-            "Invalid type for '#{name}'.",
-            type:  type,
-            types: self.class.types
-          )
-          raise invalid_type_err unless self.class.valid_type?(type)
+        def initialize(name, type:, root:, model: nil, &block)
+          validate_type!(type, msg: "Invalid type for '#{name}'.")
+
+          model ||= self.class.type_to_default_model(type)
+          validate_model!(model, msg: "Invalid model for '#{name}'.")
 
           super()
 
@@ -21,6 +21,7 @@ module Eco
           @callback       = block
           @name           = name
           @type           = type
+          @model          = model
           @times_launched = 0
         end
 
@@ -30,12 +31,6 @@ module Eco
           callback_self
         end
 
-        def chainer
-          # @todo: root is a Eco::API::UseCases that will not point to this new case.
-          # => Moreover, the name and type will be the same as self
-          Eco::API::UseCases::UseCaseChain.new(usecase: self, root: @root)
-        end
-
         def root=(value)
           msg = "Root should be a Eco::API::UseCases. Given: #{value.class}"
           raise ArgumentError, msg unless value.is_a?(Eco::API::UseCases)
@@ -48,7 +43,9 @@ module Eco
         # @param kargs [Hash] hash with symbol keys.
         # @option kargs [Eco::API::Common::People::Entries, Eco::API::Organization::People] :input
         #   the input data of reference.
-        # @option kargs [Eco::API::Organization::People] :people object.
+        # @option kargs [Variant] :data object.
+        #     @option kargs [Eco::API::Organization::People] :people object.
+        #     @option kargs [Eco::API::Organization::Contractors] :contractors object.
         # @option kargs [Eco::API:Session] :session
         # @option kargs [Hash] :options hash with symbol keys (i.e. behaviour modifiers, cli trackers, filters, etc.)
         # @return [Eco::API::UseCases::UseCaseIO] an io with the result in output
@@ -94,19 +91,31 @@ module Eco
         def set_session_n_options(uio) # rubocop:disable Naming/AccessorMethodName
           return false unless callback_from_loader?
 
-          opts          = uio.options || @options
-          sess          = uio.session
-          peo           = uio.people
-          ent           = uio.input
+          opts = uio.options || @options
+          sess = uio.session
+          dt   = uio.data
+          ent  = uio.input
+
+          mdl  = model
+
           use_case_self = self
 
           callback_self.instance_eval do
             @session = sess
             @options = opts
 
-            if peo
-              @people = peo
-              singleton_class.attr_reader(:people) unless respond_to?(:people)
+            if dt
+              @data = dt
+              singleton_class.attr_reader(:data) unless respond_to?(:data)
+
+              case mdl
+              when :people
+                @people = dt
+                singleton_class.attr_reader(:people) unless respond_to?(:people)
+              when :contractors
+                @contractors = dt
+                singleton_class.attr_reader(:contractors) unless respond_to?(:contractors)
+              end
             end
 
             if ent # entries/input

data/lib/eco/api/usecases/use_case_chain/chaining.rb

@@ -0,0 +1,88 @@
+class Eco::API::UseCases::UseCaseChain
+  module Chaining
+    MAX_CHAINS   = 70
+    @@num_chains = 0
+
+    def use(preserve_chains: false, recursive: false)
+      UseCase.new(
+        @name,
+        type:  @type,
+        model: @model,
+        root:  @root,
+        &@case
+      ).tap do |newcase|
+        next unless preserve_chains
+
+        chain_use = {preserve_chains: recursive, recursive: recursive}
+
+        @chains = @chains.map do |usecase|
+          if usecase.respond_to?(:call)
+            proc do |usegroup|
+              usecase = usecase.call(usegroup)
+              usecase.use(**chain_use).chain_to(newcase)
+              usecase
+            end
+          elsif usecase.is_a?(UseCase)
+            usecase.use(**chain_use).chain_to(newcase)
+            usecase
+          end
+        end
+      end
+    end
+
+    def chain(usecase = nil, &block)
+      @@num_chains += 1
+
+      msg  = "Reached maximum number of chained use cases (#{MAX_CHAINS}). "
+      msg << "Looks like a recursive cyclic chain 'use'"
+      raise msg if @@num_chains >= MAX_CHAINS
+
+      msg = "A UseCase can only be chained with another UseCase"
+      raise msg if usecase && !usecase.is_a?(UseCase)
+
+      msg = "Missuse. Please use either parameter or block but not both"
+      raise msg if block_given? && usecase
+
+      usecase = block if block_given?
+      @chains.push(usecase)
+      self
+    end
+
+    protected
+
+    def chain_to(usecase)
+      msg = "A UseCase can only be chained with another UseCase"
+      raise msg if usecase && !usecase.is_a?(UseCase)
+
+      usecase.chain(self)
+    end
+
+    def resolved_chains(use_group = nil)
+      return @resolved_chains if @resolved_chains
+
+      msg  = "Only Eco::API::UseCases object can contain resolved chains. "
+      msg << "Given: #{use_group.class}"
+      raise msg if use_group && !use_group.is_a?(Eco::API::UseCases)
+
+      use_group ||= @root
+      @resolved_chains = @chains.map do |usecase|
+        usecase = usecase.call(use_group) if usecase.respond_to?(:call)
+
+        msg = "A UseCase can only be chained with another UseCase"
+        raise msg if usecase && !usecase.is_a?(UseCase)
+
+        usecase.resolved_chains(use_group) if usecase.respond_to?(:resolved_chains)
+        usecase
+      end
+    end
+
+    # INSTANCE METHODS
+
+    private
+
+    def reset_chains!
+      @chains = []
+      @resolved_chains = nil
+    end
+  end
+end

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

@@ -3,46 +3,31 @@ module Eco
     class UseCases
       # Class that enables to chain multiple UseCase
       class UseCaseChain < UseCase
-        @types       = UseCase.types
-        MAX_CHAINS   = 70
-        @@num_chains = 0
+        require_relative 'use_case_chain/chaining'
+        include Chaining
 
-        def initialize(name = nil, type: nil, root:, usecase: nil, &block)
+        def initialize(name = nil, root:, type: nil, model: nil, usecase: nil, &block)
           if usecase
-            raise "Expected Eco::API::UseCases::UseCase. Given #{usecase.class}" if !usecase.is_a?(Eco::API::UseCases::UseCase)
-            type = usecase.type
-            name = usecase.name
-            block = usecase.callback unless block
+            msg  = "Expected Eco::API::UseCases::UseCase. "
+            msg << "Given #{usecase.class}"
+            raise msg unless usecase.is_a?(Eco::API::UseCases::UseCase)
+
+            type    = usecase.type
+            name    = usecase.name
+            block ||= usecase.callback
           end
 
-          super(name, type: type, root: root, &block)
-          @chains   = []
-          @resolved_chains = nil
+          super(name, type: type, model: model, root: root, &block)
+
+          reset_chains!
         end
 
         def root=(value)
-          raise "You cannot change root Eco::API::UseCases once the chains have been resolved" if @resolved_chains
-          super(value)
-        end
+          return super unless @resolved_chains # rubocop:disable Lint/ReturnInVoidContext
 
-        def use(preserve_chains: false, recursive: false)
-          UseCase.new(@name, type: @type, root: @root, &@case).tap do |newcase|
-            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
-                elsif usecase.is_a?(UseCase)
-                  usecase.use(chain_use).chain_to(newcase)
-                  usecase
-                end
-              end
-            end
-          end
+          msg = "You cannot change root Eco::API::UseCases "
+          msg << "once the chains have been resolved"
+          raise msg
         end
 
         # @see Eco::API::UseCases::UseCase#launch
@@ -55,36 +40,6 @@ module Eco
             end
           end
         end
-
-        def chain(usecase = nil, &block)
-          @@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?? block : usecase
-          @chains.push(usecase)
-          self
-        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 Eco::API::UseCases object can contain resolved chains. Given: #{use_group.class} " if use_group && !use_group.is_a?(Eco::API::UseCases)
-
-          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) if usecase.respond_to?(:resolved_chains)
-            usecase
-          end
-        end
       end
     end
   end