eco-helpers 0.9.2 → 0.9.3

data/lib/eco/api/session/batch/jobs.rb

@@ -0,0 +1,72 @@
+module Eco
+  module API
+    class Session
+      class Batch
+        class Jobs < API::Common::Session::BaseSession
+          attr_reader :name
+
+          def initialize(e, name:)
+            super(e)
+            @name = name
+            reset
+          end
+
+          def reset
+            @jobs = {}
+            @callbacks = {}
+          end
+
+          def [](name)
+            @jobs[name]
+          end
+
+          def exists?(name)
+            @jobs.key?(name)
+          end
+
+          def job(name, type: nil, sets: nil, usecase: nil, &block)
+            new(name, type: type, sets: sets, usecase: usecase, &block) unless exists?(name)
+            self[name].tap do |job|
+              block.call(job) if block
+            end
+          end
+
+          def new(name, type:, sets:, usecase: nil)
+            fatal "Can't create job named '#{name}' because it already exists." if exists?(name)
+
+            Batch::Job.new(enviro, name: name, type: type, sets: sets, usecase: usecase).tap do |job|
+              @jobs[name] = job
+              @callbacks[job] = Proc.new if block_given?
+            end
+          end
+
+          def pending?
+            @jobs.keys.any? {|key| @jobs[key].pending?}
+          end
+
+          def launch(simulate: false)
+            group_status = {}
+            @jobs.each do |name, job|
+              if job.pending?
+                group_status[job] = job_status = job.launch(simulate: simulate)
+                callback = @callbacks[job]
+                callback.call(job, job_status) if callback
+              end
+            end
+
+            return group_status
+          end
+
+          def find_jobs(type:)
+            @jobs.each_with_object([]) do |(k, jb), jbs|
+              if jb.type == type
+                jbs.push(jb)
+              end
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/eco/api/session/batch/jobs_groups.rb

@@ -0,0 +1,85 @@
+module Eco
+  module API
+    class Session
+      class Batch
+        class JobsGroups < API::Common::Session::BaseSession
+          DELAY_BETWEEN_GROUPS = 2
+
+          class << self
+            def counter(seconds)
+              puts "\n"
+              while seconds + 1 > 0 do
+                print "  Waiting #{seconds}\r"
+                $stdout.flush
+                seconds -= 1
+                sleep 1
+              end
+              print "#{" " * 40}"
+              $stdout.flush
+              puts ""
+            end
+          end
+
+          def initialize(e)
+            super(e)
+            reset
+          end
+
+          def reset
+            @order  = []
+            @groups = {}
+            @callbacks = {}
+          end
+
+          def [](name)
+            @groups[name]
+          end
+
+          def exists?(name)
+            @groups.key?(name)
+          end
+
+          def new(name, order: :last)
+            fatal "Can't create job group named '#{name}' because it already exists." if exists?(name)
+
+            Batch::Jobs.new(enviro, name: name).tap do |group|
+              @groups[name] = group
+
+              if order == :last
+                @order.push(group)
+              else
+                @order.unshift(group)
+              end
+
+              @callbacks[group] = Proc.new if block_given?
+            end
+          end
+
+          def pending?
+            @groups.any? {|group| group.pending?}
+          end
+
+          def launch(simulate: false)
+            groups_status = {}
+            @order.each.with_index do |group, idx|
+              if group.pending?
+                groups_status[group] = group_status = group.launch(simulate: simulate)
+                callback = @callbacks[group]
+                callback.call(group, group_status) if callback
+                self.class.counter(DELAY_BETWEEN_GROUPS) if !simulate && idx < @order.length - 1
+              end
+            end
+            return groups_status
+          end
+
+          def find_jobs(type:)
+            @groups.each_with_object([]) do |(k, gr), jbs|
+              jbs.concat(gr.find_jobs(type: type))
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/eco/api/session/batch/status.rb

@@ -0,0 +1,133 @@
+module Eco
+  module API
+    class Session
+      class Batch
+        class Status < Common::Session::BaseSession
+          @types = [:exact, :search]
+
+          attr_reader :source_queue
+          attr_reader :queue, :method, :type
+          attr_reader :root
+
+          class << self
+            attr_reader :types
+
+            def valid_type?(value)
+              types.include?(value)
+            end
+          end
+
+          def initialize(e, queue:, method:, type: :exact)
+            super(e)
+            fatal("In batch operations you must batch an Enumerable. Received: #{queue}")  unless queue && queue.is_a?(Enumerable)
+
+            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
+            @responses    = []
+            @person_match = []
+            @people_match = Array.new(@queue.length, [])
+          end
+
+          def root=(object)
+            @root = object
+          end
+
+          def type=(value)
+            fatal("Invalid :type '#{value}. You must specify type: as one of #{self.class.types} ") unless self.class.valid_type?(value)
+            @type = value
+          end
+
+          def errors
+            @errors ||= Batch::Errors.new(status: self)
+          end
+
+          def [](key)
+            @responses[to_index(key)]
+          end
+
+
+          def []=(key, response)
+            @responses[to_index(key)] = response
+          end
+
+          def person(key)
+            return self[key].result if success?(key)
+            nil
+          end
+
+          def person_match(key)
+            @person_match[to_index(key)]
+          end
+
+          def set_person_match(key, person)
+            @person_match[to_index(key)] = person
+          end
+
+          def people_match(key)
+            @people_match[to_index(key)]
+          end
+
+          def set_people_match(key, people)
+            @people_match[to_index(key)] = people
+          end
+
+          def received?(key)
+            !!self[key]
+          end
+
+          def success?(key)
+            self[key]&.success?
+          end
+
+          def people
+            fatal "This batch wasn't a 'get'. Can't obtain people without 'get' method" unless method == :get
+            #out = Eco::API::Organization::People.new([])
+            if type == :exact
+              out = Array(queue.length)
+              @responses.each_with_index do |response, i|
+                # out = out.merge([response.result]) if respose.success?
+                out[i] = response.result if response.success?
+              end
+            elsif type == :search
+              out = []
+              queue.each_with_index.map do |entry, i|
+                pers   = person(entry)
+                pers ||= person_match(entry)
+                ppl    = pers ? [pers] : people_match(entry)
+                out += ppl
+                # out = out.merge(ppl) unless ppl.empty?
+              end
+            end
+            out
+          end
+
+          def to_index(key)
+            key.is_a?(Integer) ? valid_index(index: key) : valid_index(entry: key)
+          end
+
+          def valid_index(index: nil, entry: nil)
+            index ||= @hash[entry]
+            unless index && index < @queue.length
+              fatal "You must provide either the index or the original entry object of the batch"
+            end
+            index
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -24,10 +24,6 @@ module Eco
           yield(self)
         end
 
-        def cli
-          self["cli"]        ||= Eco::CLI::Config.new
-        end
-
         def apis
           self["apis"]       ||= Eco::API::Session::Config::Apis.new(config: self)
         end
@@ -140,7 +136,6 @@ module Eco
         def require(file = nil, match: nil)
           if match
             file_manager.dir.dir_files(pattern: match).each do |file|
-              #pp "#{File.expand_path(file)}"
               require_relative File.expand_path(file)
             end
           else
@@ -159,8 +154,9 @@ module Eco
         end
 
         def locations_mapper
+          return @locations_mapper if instance_variable_defined?(:@locations_mapper)
           file = file_manager.newest(location_codes)
-          @locations_mapper ||= Eco::Data::Mapper.new(file_manager.load_json(file), internal: :first)
+          @locations_mapper = Eco::Data::Mapper.new(file_manager.load_json(file), internal: :first)
         end
 
         def tagtree=(file)
@@ -193,6 +189,10 @@ module Eco
         end
 
         # PEOPLE
+        def default_usergroup=(value)
+          people.default_usergroup = value
+        end
+
         def discarded_people_file=(value)
           people.discarded_file = value
         end
@@ -228,28 +228,48 @@ module Eco
           people.parser(format: format, &block)
         end
 
-        # CUSTOM USE CASES
         def usecases
-          cases = self["usecases"] ||= Eco::API::UseCases::UseGroup.new
+          @usecases = self["usecases"] ||= Eco::API::UseCases.new
           if block_given?
-            yield(cases)
+            yield(@usecases)
             self
           else
-            cases
+            @usecases
           end
         end
 
-        # API POLICIES
+        def post_launch
+          self["post_launch"] ||= Eco::API::Session::Config::PostLaunch.new(config: self)
+        end
+
         def policies
-          api_policies = self["policies"] ||= Eco::API::Policies::UsedPolicies.new
+          @policies = self["policies"] ||= Eco::API::Policies.new
+          if block_given?
+            yield(@policies)
+            self
+          else
+            @policies
+          end
+        end
+
+        def error_handlers
+          @error_handlers = self["error_handlers"] ||= Eco::API::Error::Handlers.new
           if block_given?
-            yield(api_policies)
+            yield(@error_handlers)
             self
           else
-            api_policies
+            @error_handlers
           end
         end
 
+        def workflow
+          @workflow = self["workflow"]  ||= Eco::API::Session::Config::Workflow.new(config: self)
+          @workflow.tap do |wf|
+            yield(wf) if block_given?
+          end
+        end
+
+
       end
     end
   end
@@ -263,3 +283,5 @@ require_relative 'config/mailer'
 require_relative 'config/s3_storage'
 require_relative 'config/files'
 require_relative 'config/people'
+require_relative 'config/post_launch'
+require_relative 'config/workflow'

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

@@ -3,7 +3,9 @@ module Eco
     class Session
       class Config
         class BaseConfig < Hash
+          
           attr_reader :config
+
           def initialize(config:)
             super(nil)
             @config = config

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

@@ -49,6 +49,14 @@ module Eco
           end
 
           # person model
+          def default_usergroup=(value)
+            self["default_usergroup"] = value
+          end
+
+          def default_usergroup
+            self["default_usergroup"]
+          end
+          
           def default_schema=(name)
             self["default_schema"] = name
           end

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

@@ -0,0 +1,58 @@
+module Eco
+  module API
+    class Session
+      class Config
+        class PostLaunch < BaseConfig
+          include Enumerable
+
+          def initialize(config:)
+            @postcases = []
+            super(config: config)
+          end
+
+          def length
+            count
+          end
+
+          def empty?
+            count == 0
+          end
+
+          def each(params: {}, &block)
+            return to_enum(:each) unless block
+            items.each(&block)
+          end
+
+          def items
+            @postcases
+          end
+
+          def add(name, type: nil)
+            @postcases.push({
+              name: name,
+              type: type
+            })
+          end
+
+          def select(usecases)
+            raise "Required Eco::API::UseCases to select the target post cases" unless usecases.is_a?(Eco::API::UseCases)
+            each_with_object([]) do |pc, targets|
+              targets.push(usecases.case(pc[:name], type: pc[:type]))
+            end
+          end
+
+          private
+
+          def by_name
+            @postcases.group_by {|pc| pc[:name]}
+          end
+
+          def by_type
+            @postcases.group_by {|pc| pc[:type]}
+          end
+
+        end
+      end
+    end
+  end
+end