eco-helpers 0.6.17 → 0.7.1

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

@@ -1,27 +1,78 @@
 module Eco
   module API
     class Session
-      # important! the handler should probably only create logs and save the update with same timestamp
       class Batch < Common::Session::BaseSession
 
         DEFAULT_BATCH_BLOCK = 100
-        VALID_METHODS = ['get', 'create', 'update', 'upsert', 'delete']
+        VALID_METHODS =  [:get, :create, :update, :upsert, :delete]
 
-        # people can be: empty, an api object, a people object, or an array with id's or persons
-        def get_people(people = nil, api: nil, params: {per_page: DEFAULT_BATCH_BLOCK})
-          api = api || self.api
-          return batch_from(people, 'get', api, params: params) if people.is_a?(Array)
-          return batch_get(api, params: params)
+        class << self
+          # @return [Boolean] `true` if the method is supported, `false` otherwise.
+          def valid_method?(value)
+            VALID_METHODS.include?(value)
+          end
+        end
+
+        # Gets the _people_ of the organization according `params`.
+        #   If `people` is not `nil`, scopes to only the people specified.
+        # @note
+        #   - If `people` is given keys `page:` and `q` of `params:`.
+        # @param people [Nil, People, Enumerable<Person>, Enumerable<Hash>] target _People_ to launch the batch against.
+        # @param params [Hash] api request options.
+        # @option params [String] :page the page number `page` based on `:per_page`.
+        # @option params [String] :per_page the number of people included per each batch api request.
+        # @option params [String] :q some text to search. Omit this parameter to target all the people.
+        # @return [Array<People>] all the people based on `params`
+        def get_people(people = nil, params: {})
+          return launch(people, method: :get, params: params) if people.is_a?(Enumerable)
+          return get(params: params)
         end
 
-        def launch(people = nil, method:, api: nil, params: {per_page: DEFAULT_BATCH_BLOCK})
-          fatal "Invalid batch method: #{method}." if !valid_method?(method)
-          return nil if !people || !people.is_a?(Array)
-          batch_from(people, method, api || self.api, params: params)
+        # launches a batch of `method` type using `people` and the specified `params`
+        # @raise Exception
+        #    - if `people` is `nil` or is not an `Enumerable`.
+        #    - if there's no `api` connection linked to the current `Batch`.
+        # @param people [People, Enumerable<Person>, Enumerable<Hash>] target _People_ to launch the batch against.
+        # @param method [Symbol] the method to launch the batch api request with.
+        # @param params [Hash] api request options.
+        # @option params [String] :per_page the number of people included per each batch api request.
+        # @return [BatchStatus] the `status` of this batch launch.
+        def launch(people, method:, params: {} , silent: false)
+          batch_from(people, method: method, params: params, silent: silent)
         end
 
-        def valid_method?(value)
-          VALID_METHODS.include?(value)
+        def search(data, params: {})
+          params = {per_page: DEFAULT_BATCH_BLOCK}.merge(params)
+
+          launch(data, method: :get, params: params, silent: true).tap do |status|
+            status.type = :search
+            status.queue.each do |entry|
+              unless status.success?(entry)
+                email = nil
+                case
+                when entry.respond_to?(:email)
+                  email = entry.email
+                when entry.respond_to?(:to_h)
+                  email = entry.to_h["email"]
+                end
+
+                people_matching = []
+                email = email.to_s.strip.downcase
+                unless email.empty?
+                  people_matching = get(params: params.merge(q: email), silent: true).select do |person|
+                    person.email == email
+                  end
+                end
+
+                case people_matching.length
+                when 1
+                  status.set_person_match(entry, people_matching.first)
+                when 2..Float::INFINITY
+                  status.set_people_match(entry, people.matching)
+                end
+              end
+            end
+          end
         end
 
         private
@@ -30,38 +81,38 @@ module Eco
           BatchStatus.new(enviro, queue: queue, method: method)
         end
 
-        def batch_get(api, params: {})
+        def get(params: {}, silent: false)
           fatal "cannot batch get without api connnection, please provide a valid api connection!" unless people_api = api&.people
 
           params = {per_page: DEFAULT_BATCH_BLOCK}.merge(params)
           client = people_api.client
-          people = [];
-          if page = params[:page]
-            res, response = get(client, params: params)
-            people +=res
-            logger.info("page number: #{page}, got num people #{people.length}")
-          else
-            page = 1
-            loop do
-              params = params.merge({page: page})
-              people_res, response = get(client, params: params)
-              people += people_res
-
-              total_pages = response.body["total_pages"]
-              logger.info("page number: #{page}/#{total_pages}, got num people #{people_res.length}, with total #{people.length} people got")
-              break if page >= total_pages
-              page += 1
-            end
+
+          looping = !params.key?(:page)
+          page = params[:page] || 1
+
+          people = []; total_pages = nil
+          loop do
+            people_res, response = client_get(client, params: params.merge(page: page), silent: silent)
+            people += people_res
+
+            total_pages ||= response.body["total_pages"]
+
+            msg = "page number: #{page}/#{total_pages}, got num people #{people_res.length}, with total #{people.length} people got"
+            logger.info(msg) unless silent
+
+            break if page >= total_pages || !looping
+            page += 1
           end
+
           return people
         end
 
-        def get(client, params:)
+        def client_get(client, params:, silent: false)
           response = client.get("/people", params: params)
           unless response.success?
             msg = "Request failed - params: #{params}"
             msg += "\n Error message: - Status #{response.status}: #{response.body}"
-            fatal(msg)
+            fatal msg
           end
           people = []
           response.body["results"].each do |person_hash|
@@ -72,40 +123,39 @@ module Eco
           [people, response]
         end
 
-        def batch_from(people, method, api, params: {})
-          return nil if !people || !people.is_a?(Array)
+        def batch_from(people, method:, params: {}, silent: false)
+          fatal "Invalid batch method: #{method}." if !self.class.valid_method?(method)
+          return nil if !people || !people.is_a?(Enumerable)
           fatal "cannot batch #{method} without api connnection, please provide a valid api connection!" unless people_api = api&.people
 
           # batch Status
           status = new_status(people, method)
 
           # param q does not make sense here, even for GET method
-          params = {per_page: DEFAULT_BATCH_BLOCK}.merge(params)
-          per_page = params.fetch(:per_page)
+          params   = {per_page: DEFAULT_BATCH_BLOCK}.merge(params)
+          per_page = params[:per_page] || DEFAULT_BATCH_BLOCK
 
           iteration  = 1; done = 0
           iterations = (people.length.to_f / per_page).ceil
 
           people.each_slice(per_page) do |slice|
             msg = "starting batch '#{method}' iteration #{iteration}/#{iterations}, with #{slice.length} entries of #{people.length} -- #{done} done"
-            logger.info(msg)
+            logger.info(msg) unless silent
 
             people_api.batch do |batch|
               slice.each do |person|
-                # valid method checked before
                 batch.public_send(method, person) do |response|
+                  faltal("Request with no response") unless !!response
                   status[person] = response
-                  #status.print_error(person)
-                end # current person
-              end # next person
+                end
+              end
             end # next batch
 
             iteration += 1
             done += slice.length
           end # next slice
 
-          status.print_errors
-
+          status.print_errors unless silent
           return status
         end
 

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

@@ -2,15 +2,26 @@ module Eco
   module API
     class Session
       class BatchJob < API::Common::Session::BaseSession
-        TYPES = [:create, :update, :delete, :get]
+        TYPES = [:get, :create, :update, :delete]
         SETS  = [:core, :details, :account]
 
         attr_reader :name, :status
 
+        class << self
+          def valid_type?(value)
+            TYPES.include?(value)
+          end
+
+          def valid_sets?(value)
+            sets = [value].flatten
+            sets.all? { |s| SETS.include?(s) }
+          end
+        end
+
         def initialize(e, name:, type:, sets:)
           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)
+          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)
           super(e)
 
           @name = name
@@ -20,9 +31,10 @@ module Eco
         end
 
         def reset
-          @queue     = []
-          @callbacks = {}
-          @status    = nil
+          @queue      = []
+          @queue_hash = {}
+          @callbacks  = {}
+          @status     = nil
         end
 
         def signature
@@ -38,82 +50,130 @@ module Eco
           @queue.length > 0
         end
 
-        def add(entry)
+        def core?
+          sets.include?(:core)
+        end
+
+        def details?
+          sets.include?(:details)
+        end
+
+        def account?
+          sets.include?(:account)
+        end
+
+        # Adds an entry to the job queue.
+        # @param entry [Person] the person we want to update, carrying the changes to be done.
+        # @param unique [Boolean] specifies if repeated entries should be avoided in the queue.
+        # @yield [person] callback before launching the batch job request against the server.
+        # @yeldparam param [Person] current person object that that should be treated by the callback before launching the batch.
+        # @return [Void]
+        def add(entry, unique: true)
           unless !entry
-            @queue.push(entry)
-            @callbacks[entry] = Proc.new if block_given?
+            unless unique && @queue_hash.key?(entry)
+              @queue_hash[entry] = true
+              @queue.push(entry)
+              @callbacks[entry] = Proc.new if block_given?
+            end
           end
         end
 
-        def people
-          Eco::API::Organization::People.new(@queue)
+        def people(input = @queue)
+          Eco::API::Organization::People.new(input)
         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? && @type!=:delete
+          pre_queue = @queue.map do |e|
+            if callback = @callbacks[e]
+              callback.call(e)
+            end
+            e = nil if as_update(e).empty?
             e
           end.compact
+          apply_policies(pre_queue)
+        end
+
+        def processed_queue
+          @queue.each {|e| @callbacks[e].call(e) if @callbacks.key?(e) }
+          apply_policies(@queue).select {|e| !as_update(e).empty?}
         end
 
         def launch(simulate: false)
           queue = processed_queue
           launch_feedback(queue, simulate ? 2500 : 800)
 
-          if !simulate && queue.length > 0
-            backup_update(queue)
-            @status = session.batch.launch(queue, method: @type.to_s)
-            @status.root = self
+          if !simulate
+            if queue.length > 0
+              backup_update(queue)
+              @status = session.batch.launch(queue, method: @type)
+              @status.root = self
+            end
           end
 
-          logger.info("Simulate: this would have launched: '#{@type.to_s}'") if simulate
+          post_launch(queue: queue, simulate: simulate)
+
+          logger.info("Simulate: this would have launched: '#{@type}'") if simulate
           return @status
         end
 
-        def core?
-          sets.include?(:core)
-        end
 
-        def details?
-          sets.include?(:dettails)
-        end
-
-        def account?
-          sets.include?(:account)
-        end
+        private
 
-        def self.valid_type?(value)
-          TYPES.include?(value)
+        def post_launch(queue: [], simulate: false)
+          if !simulate && @status
+            @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)
+              #  entry.reset!       if entry.respond_to?(:reset!)
+              end
+            end
+          elsif simulate
+            queue.map do |entry|
+              entry.consolidate! if entry.respond_to?(:consolidate!)
+            end
+          end
         end
 
-        def self.valid_sets?(value)
-          sets = [value].flatten
-          sets.all? { |s| SETS.include?(s) }
+        def apply_policies(pre_queue)
+          pre_queue.tap do |entries|
+            policies = session.config.api_policies.policies
+            unless policies.empty?
+              policies.launch(people: people(entries), session: session)
+            end
+          end
         end
 
-        private
-
-        def as_update(update)
-          hash = update if update.is_a?(Hash)
-          if @type == :delete
-            hash = update.as_json.slice("id", "external_id")
+        def as_update(entry)
+          hash = entry if entry.is_a?(Hash)
+          if only_ids?
+            hash = entry.as_json.slice("id", "external_id", "email")
           else
-            hash = update.as_update if update.is_a?(Ecoportal::API::V1::Person)
+            if entry.is_a?(Ecoportal::API::V1::Person)
+              hash    = entry.as_update
+              if hfields = hash.dig("details", "fields")
+                hash["details"]["fields"] = hfields.map do |fld|
+                  fld.merge!("alt_id" => entry.details.get_field(fld["id"]).alt_id) if entry.details
+                end
+              end
+            end
+
             fields = hash&.dig('details', 'fields')
             fields&.map! { |fld| fld&.slice("id", "alt_id", "value") }
           end
           hash || {}
         end
 
+        def only_ids?
+          [:delete, :get].include?(@type)
+        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?
+          if !data || !data.is_a?(Enumerable) || data.empty?
             logger.warn("#{"*" * 20} Nothing for #{signature} so far :)  #{"*" * 20}")
             return
           end
@@ -122,8 +182,8 @@ module Eco
 
           sample_length = 1
           sample = data.slice(0, 20).map do |entry|
-            update = as_update(entry)
-            max_chars -= update.pretty_inspect.length
+            update         = as_update(entry)
+            max_chars     -= update.pretty_inspect.length
             sample_length += 1 if max_chars > 0
             update
           end
@@ -135,8 +195,8 @@ module Eco
 
         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")
+          dir       = config.people.requests_folder
+          file      = File.join(dir, "#{@type}_data.json")
           file_manager.save_json(data_body, file, :timestamp)
         end
 

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

@@ -26,11 +26,10 @@ module Eco
         def new(name, type:, sets:)
           fatal "Can't create job named '#{name}' because it already exists." if exists?(name)
 
-          job = BatchJob.new(enviro, name: name, type: type, sets: sets)
-          @jobs[name] = job
-          @callbacks[job] = Proc.new if block_given?
-
-          job
+          BatchJob.new(enviro, name: name, type: type, sets: sets).tap do |job|
+            @jobs[name] = job
+            @callbacks[job] = Proc.new if block_given?
+          end
         end
 
         def pending?