eco-helpers 1.5.10 → 1.5.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a3074007c647b1ebecc8aac29368f17218d05a57fd918ece4d9531849e6075cd
-  data.tar.gz: 85fe74039f69e7cd268250f3cac40cf84a7a69ac52b113be70be8ff504c0deba
+  metadata.gz: 71bf87e88b7a707a7684879b5462db11da003360d353d513005d169e77eaa033
+  data.tar.gz: 53fe5d42e0be580d0903ddd72e02b014ca113daafe8b37d073481a769deceb7f
 SHA512:
-  metadata.gz: 8baf56c80119b6acbabd979e4d421dbe013f056b68d7ff3b0efb9728b2da6788d3be4b464f3a5054c518befa14408a9ba74d89ff6c164d8da3c70dc09e10c08a
-  data.tar.gz: a93465c18b2c153966066e644f5021d07fbb7df00c928010a3f51865b04212764255e70d89047c643c9a48cf8e3387be9d7806e121dbfee177e8654bbc024b5e
+  metadata.gz: 36db363c1aef9dac9f5fe0ca874c5d6e8dd39c89fbc7326fc66975ac12b5282288d6ba6c1449aea457c9831aacfbfe0529a53490389fc72f1f0ede956e35b9eb
+  data.tar.gz: 17ca4ae2ce8acde161e94f203eb643d405d33210972eec1bbbc3598f50f7b7015a94f9a81c50d64bafb0a42c9066464d421f6eb491e15a17c531753aa64ff59c

data/.yardopts

@@ -5,5 +5,6 @@
 --no-private
 --output-dir ./doc
 'lib/**/*.rb'
+CHANGELOG.md
 -
 LICENSE

data/CHANGELOG.md

@@ -1,7 +1,75 @@
 # Change Log
 All notable changes to this project will be documented in this file.
 
-## [1.5.10] - 2021-01-xx
+## [1.5.15] - 2021-02-xx
+
+### Added
+  - `Eco::API::Common::ClassHelpers` added support for class methods inheritance
+    - this is key to be able to define usecase models to inherit from
+  - `Eco::API::UseCases::OozeSamples::OozeUpdateCase`: added this sample to inherit from (simplifying use cases code)
+  - `Eco::API::Common::ClassHelpers` added inheritable attribute values
+  - added benchmarking to people loaders:
+    - `Eco::API::MicroCases#people_load`
+    - `Eco::API::MicroCases#people_cache`
+    - `Eco::API::MicroCases#people_search`
+    - `Eco::API::MicroCases#refresh`
+
+### Changed
+### Fixed
+  - `Eco::API::Policies::DefaultPolicies::UserAccess` typos in default api policy
+
+## [1.5.14] - 2021-02-05
+
+### Added
+  - `Eco::API::Policies::DefaultPolicies` policies that are run always (after the custom policies)
+    - `Eco::API::Policies::DefaultPolicies::UserAccess`:
+      - remove account if there's no `email`
+      - provision min user level to those with account (if no usergroup and no abilities)
+  - `Eco::API::Session#policies` which merges the default policies to be added/run after the custom policies
+  - `Eco::API::Common::Session::Logger`: add caching of logs
+    - `Eco::API::Common::Session::Logger::Cache` new class to manage cached logs
+    - `Eco::API::Common::Session::Logger::Log` new class to have a trace on logs
+  - `Eco::API::Session::Batch::Job#summary` added subjobs (error handlers) summary
+
+### Changed
+  - `Eco::API::Session::Batch::Job#launch` it will also run the default api policies before feedback and query launch
+  - `Eco::API::Common::People::PersonEntry` add error log when wrong email error is detected
+    - previously it would have crashed
+
+### Fixed
+
+## [1.5.13] - 2021-02-01
+
+### Added
+### Changed
+  - upgraded dependency with `ecoportal-api-oozes`
+
+### Fixed
+  - `Eco::API::Session::Config::Api` was not including the correct `host`
+    - this could have launched an `api` request to `live.ecoportal.com` when targeting `pre.dev`
+
+## [1.5.12] - 2021-02-01
+
+### Added
+  - `Eco::API::Common::People::DefaultParsers::CSVParser` when cell content is `Null`, capture `nil` value.
+
+### Changed
+  - upgraded `ecoportal-api` dependency
+
+### Fixed
+
+
+## [1.5.11] - 2021-01-25
+
+### Added
+  - `Eco::API::Organization::TagTree#subtag?` to check if the tag is in any subtree.
+
+### Changed
+
+### Fixed
+  - `Eco::API::MicroCases#set_supervisor` shouldn't set it if the entry does not have it.
+
+## [1.5.10] - 2021-01-19
 
 ### Added
 ### Changed

data/eco-helpers.gemspec

@@ -29,8 +29,8 @@ Gem::Specification.new do |s|
   s.add_development_dependency "yard",      ">= 0.9.18", "< 0.10"
   s.add_development_dependency "redcarpet", ">= 3.5.0",  "< 3.6"
 
-  s.add_dependency 'ecoportal-api', '>= 0.7.3', '< 0.8'
-  s.add_dependency 'ecoportal-api-oozes', '>= 0.7.2', '< 0.8'
+  s.add_dependency 'ecoportal-api', '>= 0.7.4', '< 0.8'
+  s.add_dependency 'ecoportal-api-oozes', '>= 0.7.3', '< 0.8'
   s.add_dependency 'aws-sdk-s3',    '>= 1.64.0', '< 2'
   s.add_dependency 'aws-sdk-ses',   '>= 1.29.0', '< 2'
   s.add_dependency 'dotenv',        '>= 2.7.0', '< 2.8'

data/lib/eco/api/common/class_helpers.rb

@@ -3,7 +3,7 @@ module Eco
     module Common
       module ClassHelpers
 
-        # Creates an class and instance object methods with name `name` to resolve `klass` name
+        # Creates a class and instance object methods with name `name` to resolve `klass` name
         def class_resolver(name, klass)
           define_singleton_method(name) { resolve_class(klass) }
           define_method(name) { self.class.resolve_class(klass) }
@@ -39,6 +39,15 @@ module Eco
           end.join("")
         end
 
+        # Helper to create an instance variable `name`
+        # @param [String, Symbol] the name of the variable
+        # @reutrn [String] the name of the created instance variable
+        def instance_variable_name(name)
+          str = name.to_s
+          str = "@#{str}" unless str.start_with?("@")
+          str
+        end
+
         # If the class for `name` exists, it returns it. Otherwise it generates it.
         # @param name [String, Symbol] the name of the new class
         # @param inherits [Class] the parent class to _inherit_ from
@@ -92,6 +101,41 @@ module Eco
           descendants(parent_class: parent_class, direct: direct).length > 0
         end
 
+        # Keeps track on class instance variables that should be inherited by child classes.
+        # @note
+        #   - subclasses will inherit the value as is at that moment
+        #   - any change afterwards will be only on the specific class (in line with class instance variables)
+        #   - adapted from https://stackoverflow.com/a/10729812/4352306
+        # TODO: this separates the logic of the method to the instance var. Think if would be possible to join them somehow.
+        def inheritable_class_vars(*vars)
+          @inheritable_class_vars ||= [:inheritable_class_vars]
+          @inheritable_class_vars += vars
+        end
+
+        # Builds the attr_reader and attr_writer of `attrs` and registers the associated instance variable as inheritable.
+        def inheritable_attrs(*attrs)
+          attrs.each do |attr|
+            class_eval %(
+              class << self; attr_accessor :#{attr} end
+            )
+          end
+          inheritable_class_vars(*attrs)
+        end
+
+        # This callback method is called whenever a subclass of the current class is created.
+        # @note
+        #   - values of the instance variables are copied as they are (no dups or clones)
+        #   - the above means: avoid methods that change the state of the mutable object on it
+        #   - mutating methods would reflect the changes on other classes as well
+        #   - therefore, `freeze` will be called on the values that are inherited.
+        def inherited(subclass)
+          inheritable_class_vars.each do |var|
+            instance_var = instance_variable_name(var)
+            value        = instance_variable_get(instance_var)
+            subclass.instance_variable_set(instance_var, value.freeze)
+          end
+        end
+
       end
     end
   end

data/lib/eco/api/common/loaders/error_handler.rb

@@ -16,6 +16,8 @@ module Eco
             end
           end
 
+          inheritable_class_vars :error
+          
           def initialize(handlers)
             raise "Expected Eco::API::Policies. Given #{handlers.class}" unless handlers.is_a?(Eco::API::Error::Handlers)
             handlers.on(self.error, &self.method(:main))

data/lib/eco/api/common/loaders/parser.rb

@@ -60,6 +60,8 @@ module Eco
               end
             end
 
+            private
+
             # Helper to obtain the current internal named attributes of the data
             # @param source_data [Array<String>, Hash] if `Array` those are already the `keys`, if `Hash` it gets the `keys`
             # @return [Array<String>] `keys` of `source_data`
@@ -76,6 +78,8 @@ module Eco
 
           end
 
+          inheritable_class_vars :attribute
+
           def initialize(person_parser)
             raise "Expected Eco::API::Common::People::PersonParser. Given #{policies.class}" unless person_parser.is_a?(Eco::API::Common::People::PersonParser)
             person_parser.define_attribute(self.attribute, dependencies: self.class.dependencies) do |attr_parser|

data/lib/eco/api/common/loaders/use_case.rb

@@ -14,6 +14,8 @@ module Eco
             end
           end
 
+          inheritable_class_vars :type
+
           def initialize(usecases)
             raise "Expected Eco::API::UseCases. Given #{usecases.class}" unless usecases.is_a?(Eco::API::UseCases)
             usecases.define(self.name, type: self.type, &self.method(:main))

data/lib/eco/api/common/people/default_parsers/csv_parser.rb

@@ -5,8 +5,7 @@ class Eco::API::Common::People::DefaultParsers::CSVParser < Eco::API::Common::Lo
     Eco::CSV.parse(data, headers: true, skip_blanks: true).each_with_object([]) do |row, arr_hash|
       row_hash = row.headers.uniq.each_with_object({}) do |attr, hash|
         next if attr.to_s.strip.empty?
-        value            = row[attr]
-        hash[attr.strip] = value.to_s.empty?? nil : value
+        hash[attr.strip] = parse_string(row[attr])
       end
       arr_hash.push(row_hash)
     end
@@ -23,4 +22,18 @@ class Eco::API::Common::People::DefaultParsers::CSVParser < Eco::API::Common::Lo
     CSV::Table.new(arr_rows).to_csv
   end
 
+  private
+
+  def parse_string(value)
+    return nil if value.to_s.empty?
+    return nil if null?(value)
+    value
+  end
+
+  def null?(value)
+    return true if !value
+    str = value.strip.upcase
+    ["NULL"].any? {|token| str == token}
+  end
+
 end

data/lib/eco/api/common/people/person_entry.rb

@@ -170,14 +170,25 @@ module Eco
           end
 
           # Setter to fill in all the `core` properties of the `Person` that are present in the `Entry`.
-          # @note it only sets those core properties defined in the entry.
-          #  Meaning that if an core property is not present in the entry, this will not be set on the target person.
+          # @note
+          #   1. it only sets those core properties defined in the entry.
+          #     Meaning that if an core property is not present in the entry, this will not be set on the target person.
+          #   2. if there's an incorrect email exception, it blanks the email and logs a warning message
           # @param person [Ecoportal::API::V1::Person] the person we want to set the core values to.
           # @param exclude [String, Array<String>] core attributes that should not be set/changed to the person.
           def set_core(person, exclude: nil)
             scoped_attrs = @emap.core_attrs - into_a(exclude)
             @final_entry.slice(*scoped_attrs).each do |attr, value|
-              set_part(person, attr, value)
+              begin
+                set_part(person, attr, value)
+              rescue Exception => e
+                if attr == "email"
+                  logger.error(e.to_s + " - setting blank email instead.")
+                  set_part(person, attr, nil)
+                else
+                  raise
+                end
+              end
             end
           end
 
@@ -460,6 +471,7 @@ module Eco
                 obj.send("#{attr}=", value)
               end
             rescue Exception => e
+              # add more info to the error
               raise e.append_message " -- Entry #{to_s(:identify)}"
             end
           end

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

@@ -5,9 +5,12 @@ module Eco
         class Logger
           DEFAULT_TIMESTAMP_PATTERN = '%Y-%m-%dT%H:%M:%S'
 
+          attr_reader :cache
+
           def initialize(console_level: nil, file_level: ::Logger::DEBUG, log_file: nil, timestamp_console: false, enviro: nil)
             raise "Required Environment object (enviro:). Given: #{enviro}" if enviro && !enviro.is_a?(Eco::API::Common::Session::Environment)
             @enviro = enviro
+            @cache  = Logger::Cache.new
 
             timestamp_console = fetch_timestamp_console(timestamp_console)
             @console_logger = ::Logger.new(STDOUT).tap do |_logger|
@@ -21,7 +24,9 @@ module Eco
             if log_file = fetch_log_file(log_file)
               @file_logger = ::Logger.new(log_file).tap do |_logger|
                 _logger.formatter = proc do |severity, datetime, progname, msg|
-                  "#{severity.to_s[0]}: #{datetime.strftime(DEFAULT_TIMESTAMP_PATTERN)} > #{msg}\n"
+                  "#{severity.to_s[0]}: #{datetime.strftime(DEFAULT_TIMESTAMP_PATTERN)} > #{msg}\n".tap do |formatted|
+                    cache.add(severity, datetime, msg, formatted)
+                  end
                 end
                 _logger.level = fetch_file_level(file_level)
               end
@@ -107,3 +112,6 @@ module Eco
     end
   end
 end
+
+require_relative "logger/cache"
+require_relative "logger/log"

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

@@ -0,0 +1,91 @@
+module Eco
+  module API
+    module Common
+      module Session
+        class Logger
+          class Cache
+            LEVELS = ["UNKNOWN", "FATAL", "ERROR", "WARN", "INFO", "DEBUG"]
+
+            def initialize
+              reset
+            end
+
+            def level(level)
+              cache[to_level(level)] ||= []
+            end
+
+            def add(level, datetime, message, formatted)
+              Logger::Log.new(level, datetime, message, formatted).tap do |log|
+                self.level(level).push(log)
+              end
+            end
+
+            def cache
+              @cache ||= {}
+            end
+
+            def reset(level: nil, start_time: nil, end_time: nil)
+              where(start_time, end_time) do |cond|
+                to_levels(level).map do |lev|
+                  self.level(lev).reject(&cond)
+                end
+              end
+              self
+            end
+
+            def logs(level: nil, start_time: nil, end_time: nil)
+              where(start_time, end_time) do |cond|
+                to_levels(level).map do |lev|
+                  self.level(lev).select(&cond)
+                end.flatten
+              end.sort
+            end
+
+            private
+
+            def where(start_time, end_time)
+              tstart = to_datetime(start_time)
+              tend   = to_datetime(end_time)
+              condition = Proc.new do |log|
+                next true unless tstart || tend
+                log.after?(tstart) && log.before?(tend)
+              end
+
+              yield(condition)
+            end
+
+            def to_datetime(value)
+              return nil unless value
+              Time.parse(value)
+            end
+
+            def to_levels(value)
+              levels = [value].flatten.map {|v| to_level(v)}.compact
+              levels = levels.empty?? LEVELS : levels
+            end
+
+            def to_level(value)
+              nil_or_upcase(value).tap do |out|
+                valid_level!(out)
+              end
+            end
+
+            def valid_level!(str)
+              return true if !str
+              unless LEVELS.any? {|lev| str == lev}
+                raise "Unknown level #{str}. Should be one of #{LEVELS}"
+              end
+            end
+
+            def nil_or_upcase(value)
+              value = value.to_s.upcase if value
+              return yield(value) if block_given?
+              value
+            end
+
+          end
+        end
+      end
+    end
+  end
+end

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