eco-helpers 0.9.2 → 0.9.3

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

@@ -1,62 +0,0 @@
-module Eco
-  module API
-    class Session
-      class BatchJobs < 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)
-
-          BatchJob.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? do |key|
-            @jobs[key].pending?
-          end
-        end
-
-        def launch(simulate: false)
-          group_status = {}
-          @jobs.each do |name, job|
-            group_status[job] = job_status = job.launch(simulate: simulate)
-            callback = @callbacks[job]
-            callback.call(job, job_status) if callback
-          end
-
-          return group_status
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,205 +0,0 @@
-module Eco
-  module API
-    class Session
-      class BatchStatus < Common::Session::BaseSession
-        TYPES = [:exact, :search]
-
-        attr_reader :source_queue
-        attr_reader :queue, :method, :type
-        attr_reader :root
-
-        class << self
-          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 #{TYPES} ") unless self.class.valid_type?(value)
-          @type = value
-        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
-          if type == :exact
-            out = Array(queue.length)
-            @responses.each_with_index do |respose, i|
-              out[i] = response.result
-            end
-          elsif type == :search
-            out = []
-            queue.each_with_index.map do |entry, i|
-              pers   = person(entry)
-              pers ||= person_match(entry)
-              out += pers ? [pers] : people_match(entry)
-            end
-          end
-          out
-        end
-
-        def error_queries
-          queue.each_with_index.map do |query,i|
-            unless self[i]
-              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 [: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
-            end
-
-            self[i].success? ? nil : query
-          end.compact
-        end
-
-        def errors?
-          queue.any? {|query| !self[query].success?}
-        end
-
-        def errors_count
-          error_queries.length
-        end
-
-        def str_error(key)
-          msg = ""
-          unless success?(key)
-            i = to_index(key)
-            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)}"
-          end
-          msg
-        end
-
-        def str_errors(sort: :by_status)
-          queries = error_queries
-          if sort == :by_status
-            queries = error_queries.sort_by do |query|
-              self[query].status
-            end
-          end
-          strs = []
-          if queries.length > 0
-            strs = queries.map {|query| str_error(query)}
-          end
-          strs
-        end
-
-        def print_error(key)
-          unless success?(key)
-            logger.error(str_error(key))
-          end
-        end
-
-        def print_errors(sort: :by_status)
-          strs = str_errors(sort: sort)
-          if strs.length > 0
-            logger.info()
-            logger.error("There were #{strs.length} errors:\n" + strs.join("\n"))
-          else
-            logger.info("There were no errors for the current batch '#{method}'!! ;)")
-          end
-        end
-
-
-        private
-
-        def person_ref(entry)
-          "(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)
-          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

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

@@ -1,75 +0,0 @@
-module Eco
-  module API
-    class Session
-      class JobGroups < API::Common::Session::BaseSession
-        DELAY_BETWEEN_GROUPS = 2
-
-        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)
-
-          BatchJobs.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? do |group|
-            group.pending?
-          end
-        end
-
-        def launch(simulate: false)
-          groups_status = {}
-          @order.each.with_index do |group, idx|
-            groups_status[group] = group_status = group.launch(simulate: simulate)
-            callback = @callbacks[group]
-            callback.call(group, group_status) if callback
-            JobGroups.counter(DELAY_BETWEEN_GROUPS) if !simulate && idx < @order.length - 1
-          end
-          return groups_status
-        end
-
-        def self.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
-    end
-  end
-end

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

@@ -1,124 +0,0 @@
-module Eco
-  module API
-    module UseCases
-      class UseGroup
-        include Enumerable
-
-        def initialize()
-          @usecases      = {}
-          @cache_init    = false
-          @cases_by_name = {}
-        end
-
-        def add(usecase)
-          raise "Expected UseCase object. Given: #{usecase}" if !usecase || !usecase.is_a?(UseCase)
-          name = usecase.name
-          type = usecase.type
-          puts "Warning: overriding '#{type.to_s}' case #{name}" if self.defined?(name, type: type)
-          @cache_init = false
-          @usecases[key(name, type)] = usecase
-          usecase
-        end
-
-        def define(name, type:, &block)
-          UseCase.new(name, type: type, root: self, &block).tap do |usecase|
-            add(usecase)
-          end
-        end
-
-        def defined?(name, type: nil)
-          return @usecases.key?(key(name,type)) if type
-          name?(name)
-        end
-
-        def name?(name)
-          !!by_name[name]
-        end
-
-        def types(name)
-          return nil if !name?(name)
-          by_name[name].map { |usecase| usecase.type }
-        end
-
-        def case(name, type: nil)
-          return @usecases[key(name, type)] if type
-          return nil unless cases = by_name[name]
-
-          msg = "There are cases of different types (#{types(name).map(&:to_s).join(", ")}) named '#{name}'. You should specify a correct type"
-          raise msg if cases.length > 1
-          cases.first
-        end
-
-        def names
-          by_name.keys
-        end
-
-        # merges cases overriding self for exisint parsers
-        def merge(cases)
-          return self if !cases
-          raise "Expected a UseGroup object. Given #{cases}" if !cases.is_a?(UseGroup)
-          cases_hash = cases.to_h
-
-          @usecases.merge!(cases_hash)
-
-          cases_hash.transform_values do |usecase|
-            usecase.root = self
-          end
-
-          @cache_init = false
-          self
-        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
-          @usecases.values
-        end
-        
-        protected
-
-        def to_h
-          @usecases
-        end
-
-        private
-
-        def by_name
-          init_caches
-          @by_name
-        end
-
-        def init_caches
-          return true if @cache_init
-          @cache_init = true
-          @by_name = @usecases.values.group_by { |usecase| usecase.name }
-        end
-
-        def key(name, type)
-          name + type.to_s
-        end
-
-        def name(key)
-          key&.split(":").first
-        end
-
-        def type
-          key&.split(":").last&.to_sym
-        end
-
-      end
-
-    end
-  end
-end