eco-helpers 1.5.12 → 2.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb7b7377b64d086bb76f11f99c2f63f19eae2e25c67dc52fdeb034d58af888f4
-  data.tar.gz: d1fecbe4232a57e21a9f100fcb5ef7e0058787cdb19d5e84cb79dfc9d0082889
+  metadata.gz: 44dd3a1b4d94cef2da5fc8c4618c6898bf0310f48778be120cd83503913af297
+  data.tar.gz: 128f7c6d4a4112636089c82ec61a127914263553af0fe4d54aad563d73088532
 SHA512:
-  metadata.gz: 1c77b34e3ce111d4203eb54bd765f04d00044e42cdd53a05443668e3a35589193f95b877b24fe10acbdb0214aab1aaaa5031be6f6f6012983242e4e03ebcfe7a
-  data.tar.gz: 2cff100787f222de6300ec9d991b6dba8b36726b64a90ca7618ff35330efe1dd4b0431d197cdf952dc657701357b5ff3f9fe5799f2b749f512baf9f6dd145c83
+  metadata.gz: d14f77e2cf74584eafc8c9834a71d52d1e399767352d27167ef5cbf05266c2a77777f866e64c482e610c8ca2a600aea3640256ed16ee1c6855a6b2db30af2c76
+  data.tar.gz: 1db0afa72df07479f22eca03553b3ac3c51f0228a7d726422a2f6e313565c960554be778c8b36515f1b14dc1085d8378d5d1ec859e96ef26cd116b36ccc738cf

data/CHANGELOG.md

@@ -1,7 +1,80 @@
 # Change Log
 All notable changes to this project will be documented in this file.
 
-## [1.5.12] - 2021-01-xx
+## [2.0.3] - 2021-02-23
+
+### Added
+  - `Eco::API::UseCases::OozeSamples::OozeUpdateCase`: added integration to update page instances (non-templates)
+
+### Changed
+### Fixed
+  - `Eco::API::Policies::DefaultPolicies::UserAccess` complete default policy code.
+
+## [2.0.2] - 2021-02-22
+
+### Added
+### Changed
+  - upgraded dependencies with `ecoportal-api`
+
+### Fixed
+
+
+## [2.0.1] - 2021-02-22
+
+### Added
+### Changed
+  - upgraded dependencies with `ecoportal-api-oozes` to `ecoportal-api-v2`
+
+### Fixed
+
+## [1.5.15] - 2021-02-17
+
+### 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.

data/eco-helpers.gemspec

@@ -3,37 +3,39 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 require "./lib/eco/version"
 
-Gem::Specification.new do |s|
-  s.name          = "eco-helpers"
-  s.version       = Eco::VERSION
-  s.platform      = Gem::Platform::RUBY
-  s.authors       = ["Oscar Segura"]
-  s.email         = ["oscar@ecoportal.co.nz"]
-  s.date          = %q{2018-09-05}
-  s.summary       = %q{eco-helpers to manage people api cases}
-  s.homepage      = "https://www.ecoportal.com"
-  s.licenses      = %w[MIT]
-  s.required_ruby_version = '>= 2.4.4'
-
-  s.files         = `git ls-files -z`.split("\x0").reject do |f|
+Gem::Specification.new do |spec|
+  spec.name          = "eco-helpers"
+  spec.version       = Eco::VERSION
+  spec.platform      = Gem::Platform::RUBY
+  spec.authors       = ["Oscar Segura"]
+  spec.email         = ["oscar@ecoportal.co.nz"]
+  spec.date          = %q{2018-09-05}
+  spec.summary       = %q{eco-helpers to manage people api cases}
+  spec.homepage      = "https://www.ecoportal.com"
+  spec.licenses      = %w[MIT]
+
+  spec.required_ruby_version = '>= 2.4.4'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
     f.match(%r{^(test|spec|features)/})
   end
 
-  #s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  #s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
-
-  s.add_development_dependency "bundler",   ">= 2.1.3",  "< 2.2"
-  s.add_development_dependency "rspec",     ">= 3.9",    "< 4"
-  s.add_development_dependency "rake",      ">= 12.3.0", "< 13"
-  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.4', '< 0.8'
-  s.add_dependency 'ecoportal-api-oozes', '>= 0.7.2', '< 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'
-  s.add_dependency 'net-sftp',      '>= 2.1.2', '< 2.2'
+  #spec.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  #spec.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler",   ">= 2.2.11",  "< 2.3"
+  spec.add_development_dependency "rspec",     ">= 3.10.0", "< 3.11"
+  spec.add_development_dependency "rake",      ">= 13.0.3", "< 13.1"
+  spec.add_development_dependency "yard",      ">= 0.9.26", "< 0.10"
+  spec.add_development_dependency "redcarpet", ">= 3.5.1",  "< 3.6"
+
+  spec.add_dependency 'ecoportal-api', '>= 0.8.1', '< 0.9'
+  #spec.add_dependency 'ecoportal-api', '>= 0.7.5', '< 0.8'
+  spec.add_dependency 'ecoportal-api-v2', '>= 0.8.3', '< 0.9'
+  spec.add_dependency 'aws-sdk-s3',    '>= 1.83.0', '< 2'
+  spec.add_dependency 'aws-sdk-ses',   '>= 1.36.0', '< 2'
+  spec.add_dependency 'dotenv',        '>= 2.7.6', '< 2.8'
+  spec.add_dependency 'net-sftp',      '>= 3.0.0', '< 3.1'
 
 end

data/lib/eco/api.rb

@@ -1,5 +1,5 @@
 require 'ecoportal/api'
-require 'ecoportal/api-oozes'
+require 'ecoportal/api-v2'
 
 module Eco
   module API

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/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