eco-helpers 0.8.3 → 0.8.4

data/lib/eco/api/session/batch_job.rb

@@ -5,8 +5,6 @@ module Eco
         TYPES = [:get, :create, :update, :delete]
         SETS  = [:core, :details, :account]
 
-        attr_reader :name, :status
-
         class << self
           def valid_type?(value)
             TYPES.include?(value)
@@ -18,15 +16,20 @@ module Eco
           end
         end
 
-        def initialize(e, name:, type:, sets:)
+        attr_reader :name, :status
+        attr_reader :usecase
+
+        def initialize(e, name:, type:, sets:, usecase: nil)
           raise "A name is required to refer a job. Given: #{name}" if !name
           raise "Type should be one of #{TYPES}. Given: #{type}"    if !self.class.valid_type?(type)
           raise "Sets should be some of #{SETS}. Given: #{sets}"    if !self.class.valid_sets?(sets)
+          raise "usecase must be a Eco::API::UseCases::UseCase object. Given: #{usecase.class}" if usecase && !usecase.is_a?(Eco::API::UseCases::UseCase)
           super(e)
 
-          @name = name
-          @type = type
-          @sets = [sets].flatten.compact
+          @name    = name
+          @type    = type
+          @usecase = usecase
+          @sets    = [sets].flatten.compact
           reset
         end
 
@@ -37,8 +40,12 @@ module Eco
           @status     = nil
         end
 
+        def usecase?
+          !!usecase
+        end
+
         def signature
-          "job \"#{@name}\" ['#{@type.to_s.upcase}': #{sets_title}]"
+          "job \"#{name}\" ['#{@type.to_s.upcase}': #{sets_title}]"
         end
 
         def match?(type:, sets:)
@@ -47,7 +54,7 @@ module Eco
         end
 
         def pending?
-          @queue.length > 0
+          !@status
         end
 
         def core?
@@ -124,7 +131,7 @@ module Eco
             @status.queue.map do |entry|
               if @status.success?(entry)
                 entry.consolidate! if entry.respond_to?(:consolidate!)
-              #else # shouldn't probably reset, as the model remains dirty? (well tracaked)
+              #else # shouldn't probably reset, as the model should remain dirty? (well tracaked)
               #  entry.reset!       if entry.respond_to?(:reset!)
               end
             end
@@ -139,7 +146,8 @@ module Eco
           pre_queue.tap do |entries|
             policies = session.config.policies
             unless policies.empty?
-              policies.launch(people: people(entries), session: session)
+              options = usecase?? usecase.options : {}
+              policies.launch(people: people(entries), session: session, options: options)
             end
           end
         end

data/lib/eco/api/session/batch_status.rb

@@ -4,6 +4,7 @@ module Eco
       class BatchStatus < Common::Session::BaseSession
         TYPES = [:exact, :search]
 
+        attr_reader :source_queue
         attr_reader :queue, :method, :type
         attr_reader :root
 
@@ -17,9 +18,19 @@ module Eco
           super(e)
           fatal("In batch operations you must batch an Enumerable. Received: #{queue}")  unless queue && queue.is_a?(Enumerable)
 
-          self.type = type
-          @method = method
+          self.type     = type
+          @method       = method
+          @source_queue = queue
+
+          que = queue.to_a
+          que = queue if queue.respond_to?(:uniq)
+          if que.length != que.uniq.length
+            logger.warn("Please, review your entries-to-query builder, you have repeated entries")
+            queue = que.uniq
+          end
+
           @queue  = queue
+
           @hash   = @queue.each_with_index.map do |entry, i|
             [entry, i]
           end.to_h
@@ -96,12 +107,12 @@ module Eco
         def error_queries
           queue.each_with_index.map do |query,i|
             unless self[i]
-              pp "Error: query with no response. You might have duplicated entries in your queue.\n"
-              msg  = "Queue length: #{queue.length}\n"
+              msg  = "Error: query with no response. You might have duplicated entries in your queue.\n"
+              msg += "Queue length: #{queue.length}; Queue elements class: #{queue.first.class}\n"
               msg += "Query with no response. Person: #{person_ref(query)}\n"
               queue.map do |entry|
-                if entry.id == query.id || entry.external_id == query.external_id || entry.email == query.email
-                  msg += "It could be this peson entry: #{person_ref(entry)}\n"
+                if [:id, :external_id, :email].any? {|attr| (v = get_attr(entry, attr)) && v == get_attr(query, attr)}
+                  msg += "It could be this peson entry (idx: #{to_index(entry)}): #{person_ref(entry)}\n"
                 end
               end
               raise msg
@@ -123,7 +134,7 @@ module Eco
           msg = ""
           unless success?(key)
             i = to_index(key)
-            entry = queue[i]
+            entry = queue.to_a[i]
             response = self[i]
             msg = "Error #{response.status}: #{response.body}\n"
             msg += "-- Failed to batch #{method} (entry #{i+1}). Person: #{person_ref(entry)}"
@@ -165,10 +176,15 @@ module Eco
         private
 
         def person_ref(entry)
-          is_person = entry.is_a?(Ecoportal::API::Internal::Person) || entry.is_a?(Ecoportal::API::V1::Person)
-          ref = nil
-          ref = "'#{entry.name}' ('#{entry.external_id}': '#{entry.email}')" if is_person
-          ref
+          "(id: '#{get_attr(entry, :id)}')'#{get_attr(entry, :name)}' ('#{get_attr(entry, :external_id)}': '#{get_attr(entry, :email)}')"
+        end
+
+        def get_attr(entry, attr)
+          if entry.respond_to?(attr.to_sym)
+            entry.public_send(attr.to_sym)
+          elsif entry.is_a?(Hash)
+            entry["#{attr}"]
+          end
         end
 
         def to_index(key)

data/lib/eco/api/session/config.rb

@@ -24,24 +24,28 @@ module Eco
           yield(self)
         end
 
+        def cli
+          self["cli"]        ||= Eco::CLI::Config.new
+        end
+
         def apis
-          self["apis"] ||= Session::Config::Apis.new(config: self)
+          self["apis"]       ||= Eco::API::Session::Config::Apis.new(config: self)
         end
 
         def logger
-          self["logger"] ||= Session::Config::Logger.new(config: self)
+          self["logger"]     ||= Eco::API::Session::Config::Logger.new(config: self)
         end
 
         def s3storage
-          self["s3_storage"] ||= Session::Config::S3Storage.new(config: self)
+          self["s3_storage"] ||= Eco::API::Session::Config::S3Storage.new(config: self)
         end
 
         def files
-          self["files"] ||= Session::Config::Files.new(config: self)
+          self["files"]      ||= Eco::API::Session::Config::Files.new(config: self)
         end
 
         def mailer
-          self["mailer"] ||= Session::Config::Mailer.new(config: self)
+          self["mailer"]     ||= Eco::API::Session::Config::Mailer.new(config: self)
         end
 
         def org
@@ -49,7 +53,7 @@ module Eco
         end
 
         def people
-          self["people"] ||= Session::Config::People.new(config: self)
+          self["people"]     ||= Eco::API::Session::Config::People.new(config: self)
         end
 
         # LOGGER
@@ -163,9 +167,18 @@ module Eco
           org["tagtree"] = file
         end
 
+        def tagtree(enviro: nil)
+          return @tagtree if instance_variable_defined?(:@tagtree) && @tagtree.enviro == enviro
+          if tree_file = org["tagtree"]
+            tree      = []
+            tree      = file_manager.load_json(tree_file) unless !tree_file
+            @tagtree = Eco::API::Organization::TagTree.new(tree, enviro: enviro)
+          end
+        end
+
         def policy_groups
           return @policy_groups if instance_variable_defined?(:@policy_groups)
-          pgs = api&.policy_groups.to_a
+          pgs            = api&.policy_groups.to_a
           @policy_groups = Eco::API::Organization::PolicyGroups.new(pgs)
         end
 

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

@@ -6,8 +6,8 @@ module Eco
 
           def process
             @cases.define("change-email", type: :sync) do |entries, people, session, options|
-              remove = session.job_group("main").new("remove account", type: :update, sets: :account)
-              change = session.job_group("main").new("change email", type: :update, sets: :core)
+              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)
 
               strict_search = session.config.people.strict_search? && (!options[:search]&.key?(:strict) || options.dig(:search, :strict))
@@ -25,15 +25,11 @@ module Eco
 
                     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
 

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

@@ -8,8 +8,9 @@ module Eco
             @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|
+              users = people.users
+              session.logger.warn("There are no people with account amoung your #{people.length} people")
+              users.each do |person|
                 person.account.permissions_custom = session.new_preset(person)
                 job.add(person)
               end

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

@@ -10,9 +10,7 @@ module Eco
           transform: [:people, :session],
           export:    [:people, :session, :options]
         }
-
-        attr_reader :name, :type, :times_launched
-
+        
         class << self
           def valid_type?(type)
             TYPES.include?(type)
@@ -24,14 +22,16 @@ module Eco
           end
         end
 
-        def initialize(name, type:, root:, options: {}, &block)
+        attr_reader :name, :type, :times_launched
+        attr_reader :options
+
+        def initialize(name, type:, root:, &block)
           raise "Undefined usecase type #{type}, when creating '#{name}'. Please, use any of #{TYPES}" unless self.class.valid_type?(type)
 
           self.root = root
           @case     = block
           @name     = name
           @type     = type
-          @options  = options
           @times_launched = 0
         end
 
@@ -41,6 +41,7 @@ module Eco
         end
 
         def launch(input: nil, people: nil, session:, options: {})
+          @options = options
           data = UseCaseIO.new(usecase: self, input: input, people: people, session: session, options: options)
 
           data.output = @case.call(data.params)

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

@@ -5,8 +5,8 @@ module Eco
         MAX_CHAINS   = 70
         @@num_chains = 0
 
-        def initialize(name, type:, root:, options: {}, &block)
-          super(name, type: type, root: root, options: options, &block)
+        def initialize(name, type:, root:, &block)
+          super(name, type: type, root: root, &block)
           @chains   = []
           @resolved_chains = nil
         end
@@ -17,7 +17,7 @@ module Eco
         end
 
         def use(preserve_chains: false, recursive: false)
-          UseCase.new(@name, type: @type, root: @root, options: @options, &@case).tap do |newcase|
+          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|

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

@@ -87,13 +87,13 @@ module Eco
           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"
+            raise "UseCase of type '#{type}' 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}"
+            raise "UseCase of type '#{type}' 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."
+            raise "UseCase of type '#{type}' requires a Hash ':options' object."
           end
           true
         end

data/lib/eco/assets.rb

@@ -38,5 +38,7 @@ module Eco
   end
 end
 
+require_relative 'assets/language'
+
+
 ASSETS = Eco::Assets.new
-#require_relative 'assets/'

data/lib/eco/{common → assets}/language.rb

@@ -1,9 +1,9 @@
 module Eco
-  module Common
+  class Assets
     class Language
       include Eco::Language
     end
   end
 end
 
-Handy = Eco::Common::Language.new
+Handy = Eco::Assets::Language.new

data/lib/eco/cli.rb

@@ -1,8 +1,7 @@
 module Eco
-  module CLI
+  class CLI
   end
 end
 
-require_relative 'cli/api'
-require_relative 'cli/root'
-require_relative 'cli/session'
+require_relative 'cli/scripting'
+require_relative 'cli/config'

data/lib/eco/cli/config.rb

@@ -0,0 +1,10 @@
+module Eco
+  class CLI
+    class Config
+
+
+    end
+  end
+end
+
+require_relative 'config/options'

data/lib/eco/cli/config/options.rb

@@ -0,0 +1,11 @@
+module Eco
+  class CLI
+    class Config
+      class Options
+
+      end
+    end
+  end
+end
+
+#require_relative 'config/options/'

data/lib/eco/cli/scripting.rb

@@ -0,0 +1,23 @@
+require_relative 'scripting/args_helpers'
+require_relative 'scripting/argument'
+require_relative 'scripting/arguments'
+
+module Eco
+  class CLI
+    class Scripting
+      include Scripting::ArgsHelpers
+
+      def args_contain?(*values)
+        match?(ARGV, patterns, [:any, :or, :insensitive, :pattern])
+      end
+
+      def modifiers(*values)
+        values.select { |arg| is_modifier?(arg) }
+      end
+
+    end
+  end
+end
+
+
+SCR = Eco::CLI::Scripting.new

data/lib/eco/cli/scripting/args_helpers.rb

@@ -0,0 +1,55 @@
+module Eco
+  class CLI
+    class Scripting
+      module ArgsHelpers
+
+        def is_modifier?(value)
+         value&.start_with?("-")
+        end
+
+        def arguments
+          @arguments ||= Arguments.new
+        end
+
+        def stop_on_unknown!(exclude: [])
+          if arguments.any_unkown?(exclude: exclude)
+            raise "There are unknown options in your command line arguments: #{arguments.unknown(exclude: exclude)}"
+          end
+        end
+
+        def get_arg(key, with_param: false, valid: true)
+          # track what a known option looks like
+          arguments.add(key, with_param: with_param)
+          return nil if !ARGV.include?(key)
+          value = true
+          if with_param
+            next_i = ARGV.index(key) + 1
+            value = ARGV[next_i]
+            #puts "modifier argument: #{value}"
+            value = nil if valid && is_modifier?(value)
+          end
+          return value
+        end
+
+        def get_file(key, required: false, should_exist: true)
+          filename = get_arg(key, with_param: true)
+          if !filename
+              if required
+                puts "you need to specify a file '#{key} file'"
+                exit
+              end
+          elsif  !(File.exists?(filename) || File.exists?(File.expand_path(filename)))
+            if should_exist && required
+              puts "file doesn't exist #{filename}"
+              exit
+            end
+          end
+
+          filename = File.expand_path(filename) if filename && should_exist
+          filename
+        end
+
+      end
+    end
+  end
+end