eco-helpers 1.5.13 → 2.0.4

data/lib/eco/api/common/session/logger/log.rb

@@ -0,0 +1,48 @@
+module Eco
+  module API
+    module Common
+      module Session
+        class Logger
+          class Log
+
+            attr_accessor :level, :datetime, :message, :formatted
+
+            def initialize(level, datetime, message, formatted)
+              @level     = level
+              @datetime  = datetime
+              @message   = message
+              @formatted = formatted
+            end
+
+            def to_s
+              self.formatted
+            end
+
+            def <=>(other)
+              self.datetime <=> other.datetime
+            end
+
+            def before?(value)
+              return true if !value
+              datetime <= to_datetime(value)
+            end
+
+            def after?(value)
+              return true if !value
+              datetime >= to_datetime(value)
+            end
+
+            private
+
+            def to_datetime(value)
+              return value if value.is_a?(Time)
+              return nil unless value
+              Time.parse(value)
+            end
+
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eco/api/common/version_patches/ecoportal_api/external_person.rb

@@ -13,6 +13,15 @@ module Ecoportal
           original_doc["details"] = JSON.parse(doc["details"])
         end
 
+        def identify
+          if entry
+            entry.to_s(:identify)
+          else
+            str_id = id ? "id: '#{id}'; " : ""
+            "#{name}' (#{str_id}ext_id: '#{external_id}'; email: '#{email}')"
+          end
+        end
+
       end
     end
   end

data/lib/eco/api/microcases/people_cache.rb

@@ -6,7 +6,14 @@ module Eco
       # @return [Eco::API::Organization::People] the `People` object with the data.
       def people_cache(filename = enviro.config.people.cache)
         logger.info("Going to get all the people via API")
+
+        start = Time.now
         people = session.batch.get_people
+        secs    = Time.now - start
+        cnt     = people.count
+        per_sec = (cnt.to_f / secs).floor
+        logger.info("Loaded #{cnt} people in #{secs} seconds (#{per_sec} people/sec)")
+
         file   = file_manager.save_json(people, filename, :timestamp)
         logger.info("#{people.length} people loaded and saved locally to #{file}.")
         Eco::API::Organization::People.new(people)

data/lib/eco/api/microcases/people_load.rb

@@ -18,27 +18,35 @@ module Eco
       def people_load(filename = enviro.config.people.cache, modifier: [:newest, :api])
         modifier  = [modifier].flatten
         load_file = [:file, :newest].any? {|flag| modifier.include?(flag)}
-        people    = case
-                    when filename && load_file
-                      if file = people_load_filename(filename, newest: modifier.include?(:newest))
-                        file_manager.load_json(file).tap do |people|
-                          logger.info("#{people&.length} people loaded from file #{file}") if people.is_a?(Array)
-                        end
-                      else
-                        logger.error("could not find the file #{file_manager.dir.file(filename)}")
-                        exit unless modifier.include?(:api)
-                        people_load(modifier: modifier - [:newest, :file])
-                      end
-                    when modifier.include?(:api)
-                      logger.info("Going to get all the people via API")
-                      session.batch.get_people.tap do |people|
-                        if modifier.include?(:save) && people && people.length > 0
-                          file = file_manager.save_json(people, filename, :timestamp)
-                          logger.info("#{people.length } people saved to file #{file}.")
-                        end
-                      end
-                    end
-        Eco::API::Organization::People.new(people)
+        case
+        when filename && load_file
+          if file = people_load_filename(filename, newest: modifier.include?(:newest))
+            file_manager.load_json(file).tap do |people|
+              logger.info("#{people&.length} people loaded from file #{file}") if people.is_a?(Array)
+            end
+          else
+            logger.error("could not find the file #{file_manager.dir.file(filename)}")
+            exit unless modifier.include?(:api)
+            people_load(modifier: modifier - [:newest, :file])
+          end
+        when modifier.include?(:api)
+          logger.info("Going to get all the people via API")
+
+          start = Time.now
+          session.batch.get_people.tap do |people|
+            secs    = Time.now - start
+            cnt     = people.count
+            per_sec = (cnt.to_f / secs).floor
+            logger.info("Loaded #{cnt} people in #{secs} seconds (#{per_sec} people/sec)")
+
+            if modifier.include?(:save) && people && people.length > 0
+              file = file_manager.save_json(people, filename, :timestamp)
+              logger.info("#{people.length } people saved to file #{file}.")
+            end
+          end
+        end.yield_self do |people|
+          Eco::API::Organization::People.new(people)
+        end
       end
 
       private

data/lib/eco/api/microcases/people_refresh.rb

@@ -18,7 +18,13 @@ module Eco
         msg  = "Going to refresh #{people.length} people with server data"
         msg += " (including #{created} that were created)" if created > 0
         logger.info(msg)
+
+        start = Time.now
         entries = session.batch.get_people(people, silent: true)
+        secs    = Time.now - start
+        cnt     = entries.count
+        per_sec = (cnt.to_f / secs).floor
+        logger.info("Re-loaded #{cnt} people (out of #{people.length}) in #{secs} seconds (#{per_sec} people/sec)")
 
         missing = people.length - entries.length
         logger.error("Missed to obtain #{missing} people during the refresh") if missing > 0

data/lib/eco/api/microcases/people_search.rb

@@ -11,24 +11,49 @@ module Eco
       # @return [Eco::API::Organization::People] the `People` object with the found persons.
       def people_search(data, options: {}, silent: true)
         session.logger.info("Going to api get #{data.length} entries...")
-        status = session.batch.search(data, silent: silent)
-        people = Eco::API::Organization::People.new(status.people)
-        session.logger.info("... could get #{people.length} people (out of #{data.length} entries)")
+
+        start = Time.now
+        people = session.batch.search(data, silent: silent).yield_self do |status|
+          secs    = Time.now - start
+          Eco::API::Organization::People.new(status.people).tap do |people|
+            cnt     = people.count
+            per_sec = (cnt.to_f / secs).floor
+            msg     = "... could get #{cnt} people (out of #{data.length} entries) in #{secs} seconds (#{per_sec} people/sec)"
+            session.logger.info(msg)
+          end
+        end
 
         # get the supervisors of found people (current supervisors)
         supers = people_search_prepare_supers_request(people)
         if supers.length > 0
           session.logger.info("  Going to api get #{supers.length} current supervisors...")
-          status = session.batch.search(supers, silent: silent)
-          people = people.merge(status.people, strict: micro.strict_search?(options))
+          start = Time.now
+          people = session.batch.search(supers, silent: silent).yield_self do |status|
+            secs    = Time.now - start
+            found   = status.people
+            cnt     = found.count
+            per_sec = (cnt.to_f / secs).floor
+            msg     = "... could find #{cnt} current supers (out of #{supers.length}) in #{secs} seconds (#{per_sec} people/sec)"
+            session.logger.info(msg)
+            people.merge(found, strict: micro.strict_search?(options))
+          end
         end
 
         # get the supervisors referred in the input data (future supervisors)
         supers = people_search_prepare_supers_request(data, people)
         if supers.length > 0
-          session.logger.info("  Going to api get #{supers.length} supervisors as per entries...")
-          status = session.batch.search(supers, silent: silent)
-          people = people.merge(status.people, strict: micro.strict_search?(options))
+          session.logger.info("  Going to api get #{supers.length} supervisors as per input entries...")
+          start = Time.now
+
+          people = session.batch.search(supers, silent: silent).yield_self do |status|
+            secs    = Time.now - start
+            found   = status.people
+            cnt     = found.count
+            per_sec = (cnt.to_f / secs).floor
+            msg     = "... could find #{cnt} input supers (out of #{supers.length}) in #{secs} seconds (#{per_sec} people/sec)"
+            session.logger.info(msg)
+            people.merge(found, strict: micro.strict_search?(options))
+          end
         end
 
         session.logger.info("Finally got #{people.length} people (out of #{data.length} entries)")

data/lib/eco/api/policies.rb

@@ -36,3 +36,4 @@ module Eco
 end
 
 require_relative 'policies/policy'
+require_relative 'policies/default_policies'

data/lib/eco/api/policies/default_policies.rb

@@ -0,0 +1,12 @@
+module Eco
+  module API
+    class Policies
+      class DefaultPolicies < Eco::API::Policies
+        autoloads_children_of "Eco::API::Common::Loaders::Policy"
+        autoload_namespace    "Eco::API::Policies::DefaultPolicies"
+      end
+    end
+  end
+end
+
+require_relative 'default_policies/99_user_access_policy'

data/lib/eco/api/policies/default_policies/99_user_access_policy.rb

@@ -0,0 +1,88 @@
+class Eco::API::Policies::DefaultPolicies::UserAccess < Eco::API::Common::Loaders::Policy
+  name "default-user-access"
+
+  attr_reader   :session, :options, :job
+  attr_accessor :account_removed_count
+
+  def main(people, session, options, policy, job)
+    @session = session; @options = options; @job = job
+
+    self.account_removed_count = 0
+
+    people.each do |person|
+      remove_account_when_no_email!(person)    if person.email.to_s.empty?
+      person.account.policy_group_ids = defid  if no_policy_group_ids?(person)
+      refresh_abilities!(person)
+    end
+
+    warn_account_removal!
+  end
+
+  private
+
+  def warn_account_removal!
+    if account_removed_count > 0
+      msg = "(DefaultPolicy on job '#{job.name}') Removed account to #{account_removed_count} people"
+      session.logger.warn(msg)
+    end
+  end
+
+  def remove_account_when_no_email!(person)
+    if person.account
+      self.account_removed_count += 1 if had_account?(person)
+      person.account = nil
+    end
+  end
+
+  def had_account?(person)
+    return false if person.new?
+    return false if person.account_added?
+    return !!person.original_doc["account"]
+  end
+
+  def refresh_abilities!(person)
+    return nil if options.dig(:exclude, :abilities)
+    return nil unless account = person.account
+    account.permissions_custom = session.new_preset(person)
+    account.permissions_custom = min_abilities if no_abilities?(person)
+  end
+
+  def no_policy_group_ids?(person)
+    (account = person.account) &&  account.policy_group_ids.empty?
+  end
+
+  def no_abilities?(person)
+    return true unless account = person.account
+    account.permissions_custom && account.permissions_custom.values.all?(&:nil?)
+  end
+
+  def min_abilities
+    {
+      "files"         => "upload",
+      "data"          => nil,
+      "reports"       => nil,
+      "pages"         => "create",
+      "page_editor"   => "basic",
+      "registers"     => "view",
+      "organization"  => nil,
+      "person_core"         => "attach",
+      "person_core_edit"    => nil,
+      "person_core_create"  => nil,
+      "person_details"      => "view",
+      "person_account"      => nil
+    }
+  end
+
+  def defid
+    @defid ||= policy_groups.to_id([default_group]).compact
+  end
+
+  def default_group
+    session.config.people.default_usergroup
+  end
+
+  def policy_groups
+    session.policy_groups
+  end
+
+end

data/lib/eco/api/session.rb

@@ -187,6 +187,8 @@ module Eco
       end
 
       # Does merge `Eco::API::UseCases::DefaultCases` with the custom cases.
+      # @note
+      #   - the order matters, as a default usecase can be redefined by a custom one with same name
       # @return [Eco::API::UseCases]
       def usecases
         @usecases ||= config.usecases.dup.tap do |cases|
@@ -195,6 +197,17 @@ module Eco
         end
       end
 
+      # Does merge `Eco::API::Policies::DefaultPolicies` with the custom policies.
+      # @note
+      #   - the default policies are added at the end (meaning they will run after the custom policies)
+      # @return [Eco::API::Policies]
+      def policies
+        @policies ||= config.policies.dup.tap do |policies|
+          default_policies = Eco::API::Policies::DefaultPolicies.new
+          policies.merge(default_policies)
+        end
+      end
+
       # Set of helpers to simplify your code
       # @see Eco::API::MicroCases
       # @return [Eco::API::MicroCases]

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

@@ -88,10 +88,7 @@ module Eco
 
         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
-
           return people_api.get_all(params: params, silent: silent)
         end
 

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

@@ -71,12 +71,6 @@ module Eco
             @subjobs ||= Eco::API::Session::Batch::Jobs.new(enviro, name: "childs-of:#{self.name}")
           end
 
-          def subjobs_add(name = "ad-hoc:job-from:#{self.name}", usecase: self.usecase, &block)
-            dup(name, usecase: usecase).tap do |subjob|
-              subjobs.add(subjob, &block)
-            end
-          end
-
           # @return [Boolean] `true` if the current batch job is a result of an error_handler
           def error_handler?
             usecase? && usecase.is_a?(Eco::API::Error::Handler)
@@ -211,6 +205,7 @@ module Eco
                 end
 
                 msg << status.errors.message unless !status
+                msg << subjobs_summary
               end
             end.join("\n")
           end
@@ -238,7 +233,7 @@ module Eco
           # Applies the changes introduced by api policies
           def apply_policies(pre_queue)
             people(pre_queue).tap do |entries|
-              policies = session.config.policies
+              policies = session.policies
               unless policies.empty? || options.dig(:skip, :api_policies)
                 policies.launch(people: entries, session: session, options: options, job: self)
               end
@@ -307,6 +302,21 @@ module Eco
             file_manager.save_json(requests, file, :timestamp)
           end
 
+          # Adds a job tied to the current job
+          # Used with error handlers that need their own job to run
+          def subjobs_add(name = "ad-hoc:job-from:#{self.name}", usecase: self.usecase, &block)
+            dup(name, usecase: usecase).tap do |subjob|
+              subjobs.add(subjob, &block)
+            end
+          end
+
+          def subjobs_summary
+            return "" unless subjobs.count > 0
+            [].tap do |msg|
+              subjobs.map {|subjob| msg << subjob.summary}
+            end.join("\n")
+          end
+
         end
       end
     end

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

@@ -195,6 +195,7 @@ module Eco
           # @yieldreturn [Eco::API::UseCases::BaseIO] the `io` input/output object carried througout all the _workflow_
           # @return [Eco::API::Session::Config::Workflow] the current stage object (to ease chainig).
           def run(key = nil, io:, &block)
+            raise "Missing BaseIO object" unless io.is_a?(Eco::API::UseCases::BaseIO)
             begin
               if key
                 io = stage(key).run(io: io, &block)

data/lib/eco/api/usecases.rb

@@ -160,3 +160,4 @@ require_relative 'usecases/use_case_chain'
 require_relative 'usecases/base_io'
 require_relative 'usecases/use_case_io'
 require_relative 'usecases/default_cases'
+require_relative 'usecases/ooze_samples'

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

@@ -0,0 +1,11 @@
+module Eco
+  module API
+    class UseCases
+      class OozeSamples
+
+      end
+    end
+  end
+end
+
+require_relative 'ooze_samples/ooze_update_case'

data/lib/eco/api/usecases/ooze_samples/ooze_update_case.rb

@@ -0,0 +1,131 @@
+class Eco::API::UseCases::OozeSamples::OozeUpdateCase < Eco::API::Common::Loaders::UseCase
+  name "single-ooze-case"
+  type :other
+
+  attr_reader :session, :options, :usecase
+
+  SAVE_PATCH = "ooze_patch_update.json"
+
+  def main(session, options, usecase)
+    @session = session; @options = options; @usecase = usecase
+    yield
+    end_script!
+  end
+
+  private
+
+  def end_script!
+    exit_if_no_changes!
+    backup_patch!
+    launch_request unless options[:simulate]
+    exit(0)
+  end
+
+  def ooze_id
+    options.dig(:source, :ooze_id)
+  end
+
+  def stage_id
+    options.dig(:source, :stage_id)
+  end
+
+  def stage(id_name = stage_id)
+    if stg = ooze.stages[id_name] || ooze.stages.get_by_name(id_name)
+      return apiv2.pages.get(ooze_id, stage_id: stg.id).tap do |stage|
+        if stage
+          new_target(stage)
+          logger.info("Got #{object_reference(stage)} from #{object_reference(ooze)}")
+        else
+          logger.error("Could not get stage '#{id_name}' in ooze '#{ooze_id}'")
+          exit(1)
+        end
+      end
+    end
+    raise "Stage '#{id_name}' doesn't exist in ooze '#{ooze_id}'"
+  end
+
+  def ooze
+    @ooze ||= apiv2.pages.get(ooze_id).tap do |ooze|
+      if ooze
+        new_target(ooze)
+        logger.info("Got #{object_reference(ooze)}")
+      else
+        logger.error("Could not get ooze '#{ooze_id}'")
+        exit(1)
+      end
+    end
+  end
+
+  def launch_request
+    prompt_to_confirm!
+
+    apiv2.pages.update(target).tap do |response|
+      if response.success?
+        logger.info("All went OK")
+      else
+        logger.error(response.body)
+      end
+    end
+  end
+
+  def exit_if_no_changes!
+    unless changes = !!patch_doc["page"]
+      logger.warn "No Changes!!"
+      exit(0)
+    end
+  end
+
+  def apiv2
+   @apiv2 ||= session.api(version: :oozes)
+  end
+
+  def target
+    @target
+  end
+
+  def new_target(object)
+    if @target && patch_doc["page"]
+      logger.warn "You you are switching to a new target #{object_reference(object)} after doing unsaved changes to #{object_reference(@target)}"
+    end
+    @target = object
+  end
+
+  def object_reference(obj)
+    return "No reference" unless obj
+    "".tap do |ref|
+      case obj
+      when Ecoportal::API::V2::Page::Stage
+        ref << "Stage "
+      when Ecoportal::API::V2::Pages::PageStage
+        ref << "StagePage "
+      when Ecoportal::API::V2::Page
+        ref << "Page "
+      end
+      ref << "'#{obj.name}' " if obj.respond_to?(:name)
+    end
+  end
+
+
+  def patch_doc
+    apiv2.pages.get_body(target)
+  end
+
+  def backup_patch!
+    # store the request
+    File.open(SAVE_PATCH, "w") do |file|
+      #file << (patch_doc || {}).to_json
+      file << JSON.pretty_generate(patch_doc || {})
+    end
+    puts "Saved patch at: #{File.expand_path(SAVE_PATCH)}"
+  end
+
+  def logger
+    session.logger
+  end
+
+  def prompt_to_confirm!
+    print "\nDo you want to proceed (y/N)?  "
+    exit(1) unless $stdin.gets.chomp.to_s.downcase == "y"
+  end
+
+end