eco-helpers 0.6.0

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

@@ -0,0 +1,152 @@
+module Eco
+  module API
+    class Session
+      class BatchJob < API::Common::Session::BaseSession
+        TYPES = [:create, :update, :delete, :get]
+        SETS  = [:core, :details, :account]
+
+        attr_reader :name, :status
+
+        def initialize(name, type:, sets:, root:)
+          raise "A name is required to refer a job. Given: #{name}" if !name
+          raise "Type should be one of #{TYPES}. Given: #{type}" if !BatchJob.valid_type?(type)
+          raise "Sets should be some of #{SETS}. Given: #{sets}" if !BatchJob.valid_sets?(sets)
+          super(root.enviro)
+
+          @name = name
+          @type = type
+          @sets = [sets].flatten
+          @root = root
+          reset
+        end
+
+        def reset
+          @queue     = []
+          @callbacks = {}
+          @status    = nil
+        end
+
+        def signature
+          "job \"#{@name}\" ['#{@type.to_s.upcase}': #{sets_title}]"
+        end
+
+        def match?(type:, sets:)
+          sets = [sets].flatten
+          type == @type && (sets.order == @sets.order)
+        end
+
+        def pending?
+          @queue.length > 0
+        end
+
+        def add(data)
+          unless !data
+            @queue.push(data)
+            @callbacks[data] = Proc.new if block_given?
+          end
+        end
+
+        def people
+          Eco::API::Organization::People.new(@queue)
+        end
+
+        def processed_queue
+          @queue.map do |entry|
+            callback = @callbacks[entry]
+            e = entry
+            e = callback.call(entry) if callback
+            e = nil if as_update(e).empty?
+            e
+          end.compact
+        end
+
+        def launch(simulate: false)
+          queue = processed_queue
+          launch_feedback(queue, simulate ? 2500 : 800)
+
+          if !simulate && queue.length > 0
+            backup_update(queue)
+            @status = batch.launch(queue, method: @type.to_s)
+            @status.root = self
+          end
+
+          logger.info("Simulate: this would have launched: '#{@type.to_s}'") if simulate          
+          return @status
+        end
+
+        def core?
+          sets.include?(:core)
+        end
+
+        def details?
+          sets.include?(:dettails)
+        end
+
+        def account?
+          sets.include?(:account)
+        end
+
+        def self.valid_type?(value)
+          TYPES.include?(value)
+        end
+
+        def self.valid_sets?(value)
+          sets = [value].flatten
+          sets.all? { |s| SETS.include?(s) }
+        end
+
+        private
+
+        def as_update(update)
+          hash = update if update.is_a?(Hash)
+          hash = update.as_update if update.is_a?(Ecoportal::API::V1::Person)
+          fields = hash&.dig('details', 'fields')
+          fields&.map! { |fld| fld&.slice("id", "alt_id", "value") }
+          hash || {}
+        end
+
+        def sets_title
+          "#{@sets.map {|s| s.to_s}.join(", ")}"
+        end
+
+        def launch_feedback(data, max_chars = 800)
+          if !data || !data.is_a?(Array) || data.empty?
+            logger.warn("#{"*" * 20} Nothing for #{signature} so far :)  #{"*" * 20}")
+            return
+          end
+          header = ("*" * 20) + "  #{signature} - Feedback Sample " + ("*" * 20)
+          logger.info(header)
+
+          sample_length = 1
+          sample = data.slice(0, 20).map do |entry|
+            update = as_update(entry)
+            max_chars -= update.pretty_inspect.length
+            sample_length += 1 if max_chars > 0
+            update
+          end
+
+          logger.info("#{sample.slice(0, sample_length).pretty_inspect}")
+          logger.info("#{@type.to_s.upcase} length: #{data.length}")
+          logger.info("*" * header.length)
+        end
+
+        def backup_update(data)
+          data_body = data.map { |u| as_update(u) }
+          dir  = config.people.requests_folder
+          file = File.join(dir, "#{@type.to_s}_data.json")
+          file_manager.save_json(data_body, file, :timestamp)
+        end
+
+        def session
+          @root.session
+        end
+
+        def batch
+          session.batch
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,131 @@
+module Eco
+  module API
+    class Session
+      class JobGroups < API::Common::Session::BaseSession
+        DELAY_BETWEEN_GROUPS = 2
+
+        def initialize(session:)
+          raise("JobGroups requires a session object") unless session.is_a?(API::Session)
+          super(session.enviro)
+          @session = session
+          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)
+          raise("Can't create job group named #{'name'} because it already exists.") if exists?(name)
+
+          group = BatchJobs.new(name, session: @session)
+          @groups[name] = group
+
+          if order == :last
+            @order.push(group)
+          else
+            @order.unshift(group)
+          end
+
+          @callbacks[group] = Proc.new if block_given?
+
+          group
+        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
+
+      class BatchJobs < API::Common::Session::BaseSession
+        attr_reader :name, :session
+
+        def initialize(name, session:)
+          raise("BatchJobs requires a session object") unless session.is_a?(API::Session)
+          super(session.enviro)
+          @session = session
+          @name     = name
+          reset
+        end
+
+        def reset
+          @jobs = {}
+          @callbacks = {}
+        end
+
+        def [](name)
+          @jobs[name]
+        end
+
+        def exists?(name)
+          @jobs.key?(name)
+        end
+
+        def new(name, type:, sets:)
+          raise("Can't create job named '#{name}' because it already exists.") if exists?(name)
+
+          job = BatchJob.new(name, type: type, sets: sets, root: self)
+          @jobs[name] = job
+          @callbacks[job] = Proc.new if block_given?
+
+          job
+        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

@@ -0,0 +1,138 @@
+require 'json'
+require 'pp'
+require 'securerandom' # for uuid (perhaps metter to have structure i.e. Session:id-Batch:id)
+
+module Eco
+  module API
+    class Session
+      class BatchStatus < Common::Session::BaseSession
+        attr_reader :queue, :method
+        attr_reader :root
+
+        def initialize(e, queue:, method:)
+          super(e)
+
+          unless queue && queue.is_a?(Array)
+            msg = "In batch operations you must batch an array. Received: #{queue}"
+            logger.fatal(msg)
+            raise msg
+          end
+          @method = method
+          @queue = queue
+          @hash  = @queue.each_with_index.map do |entry, i|
+            [entry, i]
+          end.to_h
+          @responses = Array(0..@queue.length-1)
+        end
+
+        def root=(object)
+          @root = object
+        end
+
+        def [](key)
+          @responses[to_index(key)]
+        end
+
+        def []=(key, response)
+          @responses[to_index(key)] = response
+        end
+
+        def received?(key)
+          !!self[key]
+        end
+
+        def success?(key)
+          self[key]&.success?
+        end
+
+        def people
+          raise "This batch wasn't a 'get'. Can't obtain people without 'get' method" unless method == "get"
+          out = Array(0..queue.length-1)
+          @responses.each_with_index do |respose, i|
+            out[i] = response.result
+          end
+          out
+        end
+
+        def error_queries
+          queue.each_with_index.map do |query,i|
+            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[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.error(strs.join("\n"))
+            #strs.each {|str| logger.error(str)}
+          else
+            logger.info("There were no errors for the current batch '#{method}'!! ;)")
+          end
+        end
+
+
+        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
+        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
+            raise "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/task.rb

@@ -0,0 +1,92 @@
+module Eco
+  module API
+    class Session
+      class Task < API::Common::Session::BaseSession
+        NEWEST_FILE_MODE = [:newest, :last_file, :previous]
+        LOAD_FILE_MODE   = [:file]
+        SAVE_FILE_MODE   = [:save]
+        API_MODE         = [:api, :api_get]
+
+        attr_reader :batch
+
+        def initialize(root, env)
+          super(env)
+          @root = root
+        end
+
+        def batch
+          @root&.batch
+        end
+
+        def file_people(filename = enviro.config.people.cache)
+          logger.info("Going to get all the people via API")
+          people = batch.get_people
+          file = file_manager.save_json(people, filename, :timestamp)
+          logger.info("#{people.length} people loaded and saved locally to #{file}.")
+          API::Organization::People.new(people)
+        end
+
+        def load_people(filename = enviro.config.people.cache, modifier: [:newest, :api])
+          modifier = [modifier].flatten
+          people = []
+          case
+          when !!filename && (load_file?(modifier) || newest_file?(modifier))
+            case
+            when newest_file?(modifier)
+              # search input file based on pattern (in case the name has a timestamp)
+              file = file_manager.dir.newest_file(file: filename)
+              logger.info("previous file found: #{file}") if !!file
+            else
+              file = file_manager.dir.file(filename)
+            end
+
+            if !file
+              logger.error("could not find the file #{file_manager.dir.file(filename)}")
+              exit if !use_api?(modifier)
+              people = self.load_people(modifier: modifier - NEWEST_FILE_MODE - LOAD_FILE_MODE)
+            else
+              people = file_manager.load_json(file)
+              if !!people && people.is_a?(Array)
+                logger.info("#{people&.length} people loaded from file #{file}")
+              end
+            end
+          when use_api?(modifier)
+            # no previous file: use API to get all people
+            logger.info("Going to get all the people via API")
+            people = batch.get_people
+
+            if save_file?(modifier) && people && people.length > 0
+              file = file_manager.save_json(people, filename, :timestamp)
+              logger.info("#{people.length } people saved to file #{file}.")
+            end
+          end
+          Eco::API::Organization::People.new(people)
+        end
+
+        private
+
+        # MODIFIERS
+        def use_api?(modifier)
+          modifiers = [modifier].flatten
+          modifiers.any? { |m| API_MODE.include?(m) }
+        end
+
+        def load_file?(modifier)
+          modifiers = [modifier].flatten
+          modifiers.any? { |m| LOAD_FILE_MODE.include?(m) }
+        end
+
+        def newest_file?(modifier)
+          modifiers = [modifier].flatten
+          modifiers.any? { |m| NEWEST_FILE_MODE.include?(m) }
+        end
+
+        def save_file?(modifier)
+          modifiers = [modifier].flatten
+          modifiers.any? { |m| SAVE_FILE_MODE.include?(m) }
+        end
+
+      end
+    end
+  end
+end