eco-helpers 2.6.4 → 2.7.1

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

@@ -14,5 +14,4 @@ class Eco::API::Common::People::DefaultParsers::BooleanParser < Eco::API::Common
   def truthy(value)
     %w[true y yes x].include?(value.to_s.strip.downcase)
   end
-
 end

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

@@ -36,7 +36,7 @@ class Eco::API::Common::People::DefaultParsers::CSVParser < Eco::API::Common::Lo
     headers = table.headers
     abort("Missing headers in CSV") unless headers && !headers.empty?
     empty = []
-    with_value = headers.each_with_index do |header, idx|
+    headers.each_with_index do |header, idx|
       empty << idx if header.to_s.strip.empty?
     end
     abort("Empty headers in column(s): #{empty.join(', ')}") unless empty.empty?

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

@@ -1,32 +1,84 @@
 class Eco::API::Common::People::DefaultParsers::DateParser < Eco::API::Common::Loaders::Parser
   attribute :date
 
+  MIN_DATE = '1901-01-02'.freeze
+  MAX_DATE = '2099-12-31'.freeze
+
   def parser(value, deps)
-    value.is_a?(Array) ? value.map { |v| parse_date(v) } : parse_date(value)
+    parse_date(value, attr: deps['attr'])
   end
 
-  def serializer(value, deps)
-    value.is_a?(Array) ? value.map { |d| serialize_date(d) } : serialize_date(value)
+  def serializer(value, _deps)
+    serialize_date(value)
   end
 
   private
 
-  def parse_date(value)
-    begin
-      (value.to_s.empty?) ? nil : Date.parse(value)
-    rescue
+  def parse_date(value, attr:)
+    return value.map {|val| parse_date(val, attr: attr)}.compact if value.is_a?(Enumerable)
+
+    return nil if value.nil?
+    value = value.to_s.strip
+    return nil if value.empty?
+
+    if date?(value)
+      Date.parse(value).then do |date|
+        next date if valid_range?(date)
+        wrong!(value, attr: attr, desc: 'Date out of range (1900-2099). Given: ')
+        nil
+      end
+    else
+      wrong!(value, attr: attr)
       nil
     end
+  rescue TypeError, Date::Error
+    nil
   end
 
   def serialize_date(value)
+    return value.map {|val| serialize_date(val)}.compact if value.is_a?(Enumerable)
+
+    return nil   if value.nil?
+    return nil   if value.to_s.strip.empty?
     return value if value.is_a?(String)
-    begin
-      value && value.strftime('%Y-%m-%d')
-    rescue
-      nil
-    end
+    return nil   unless [Date, Time].any? {|type| value.is_a?(type)}
+    value&.strftime('%Y-%m-%d')
+  rescue TypeError, Date::Error
+    nil
+  end
+
+  def wrong!(value, attr:, desc: "Can't make a date out of")
+    return if wrong(attr).key?(value)
+    wrong(attr)[value] = value
+    log(:warn) { "#{desc} '#{value}' for '#{attr}'" }
   end
 
+  def wrong(attr = nil)
+    @wrong ||= {}
+    return @wrong if attr.nil?
+    @wrong[attr] ||= {}
+  end
+
+  def date?(value)
+    return true if value.nil?
+    return true if value.to_s.strip.empty?
+    Date.parse(value)
+    true
+  rescue TypeError, Date::Error
+    false
+  end
+
+  def valid_range?(date)
+    return true  if date.nil?
+    return false unless min_date <= date
+    max_date >= date
+  end
+
+  def min_date
+    @min_date ||= Date.parse(MIN_DATE)
+  end
 
+  def max_date
+    @max_date ||= Date.parse(MAX_DATE)
+  end
 end

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

@@ -16,5 +16,4 @@ class Eco::API::Common::People::DefaultParsers::FreemiumParser < Eco::API::Commo
   def truthy (value)
     %w[true y yes x].include?(value.to_s&.downcase)
   end
-
 end

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

@@ -3,14 +3,19 @@ class Eco::API::Common::People::DefaultParsers::LoginProvidersParser < Eco::API:
   parsing_phase     :final
   serializing_phase :final
 
-  def parser(hash, deps)
+  def parser(hash, _deps)
     hash["login_provider_ids"].map do |name|
-      login_providers.to_id(name&.downcase.strip)
+      login_providers.to_id(name&.downcase&.strip).tap do |known|
+        unless !name || known || unknown_pgs.include?(name)
+          unknown_pgs.push(name)
+          logger.warn("Unknown Login Provider: '#{name}'")
+        end
+      end
     end.compact
   end
 
-  def serializer(hash, deps)
-    if ids = hash["login_provider_ids"]
+  def serializer(hash, _deps)
+    if (ids = hash["login_provider_ids"])
       login_providers.to_name(ids)
     else
       []
@@ -19,8 +24,11 @@ class Eco::API::Common::People::DefaultParsers::LoginProvidersParser < Eco::API:
 
   private
 
+  def unknown_pgs
+    @unknown_pgs ||= []
+  end
+
   def login_providers
     @login_providers ||= config.login_providers
   end
-
 end

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

@@ -17,5 +17,4 @@ class Eco::API::Common::People::DefaultParsers::MultiParser < Eco::API::Common::
     return value.split("|") if value.is_a?(String) && value.include?("|")
     [].push(value)
   end
-
 end

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

@@ -1,18 +1,31 @@
 class Eco::API::Common::People::DefaultParsers::NumericParser < Eco::API::Common::Loaders::Parser
   attribute :number
 
-  def parser(value, deps)
-    value.is_a?(Array) ? value.map { |v| parse_number(v) } :  parse_number(value)
+  def parser(value, _deps)
+    parse_number(value)
   end
 
-  def serializer(value, deps)
-    value.is_a?(Array) ? value.map { |v| v.to_s } : value.to_s
+  def serializer(value, _deps)
+    value.is_a?(Array) ? value.map(&:to_s) : value.to_s
   end
 
   private
 
   def parse_number(value)
-    value.to_s.strip.empty? ? nil : (value.to_f rescue nil)
+    return value.map {|val| parse_number(val)}.compact if value.is_a?(Enumerable)
+
+    return nil if value.nil?
+    value = value.to_s.strip
+    return nil if value.empty?
+    return nil unless number?(value)
+    value.to_f
+  rescue ArgumentError, TypeError
+    nil
   end
 
+  def number?(value)
+    true if Float(value)
+  rescue ArgumentError, TypeError
+    false
+  end
 end

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

@@ -1,14 +1,14 @@
 class Eco::API::Common::People::DefaultParsers::PolicyGroupsParser < Eco::API::Common::Loaders::Parser
   attribute "policy_group_ids"
-  parsing_phase     :final
+  parsing_phase :final
 
-  def parser(hash, deps)
+  def parser(hash, _deps)
     policy_group_ids = hash["policy_group_ids"] || []
     policy_group_ids.map do |name|
-      policy_groups.to_id(name&.downcase.strip).tap do |known|
+      policy_groups.to_id(name&.downcase&.strip).tap do |known|
         unless !name || known || unknown_pgs.include?(name)
           unknown_pgs.push(name)
-          logger.warn("Unknown Policy Group: '#{name}'")
+          log(:warn) { "Unknown Policy Group: '#{name}'" }
         end
       end
     end.compact.tap do |pg_names|
@@ -16,8 +16,8 @@ class Eco::API::Common::People::DefaultParsers::PolicyGroupsParser < Eco::API::C
     end
   end
 
-  def serializer(person, deps)
-    ids   = person&.account&.policy_group_ids || []
+  def serializer(person, _deps)
+    ids = person&.account&.policy_group_ids || []
     ids.map do |id|
       policy_groups.to_name(id)
     end.compact
@@ -26,11 +26,11 @@ class Eco::API::Common::People::DefaultParsers::PolicyGroupsParser < Eco::API::C
   private
 
   def unknown_pgs
-    unknown_pgs ||= []
+    @unknown_pgs ||= []
   end
 
   def default_id
-    @default_id    ||= policy_groups.to_id(config.people.default_usergroup)
+    @default_id ||= policy_groups.to_id(config.people.default_usergroup)
   end
 
   def policy_groups

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

@@ -1,29 +1,53 @@
-module Eco
-  module API
-    module Common
-      module People
-        class DefaultParsers
-          class SelectParser < People::BaseParser
-
-            def process
-              @parsers.define_attribute(:select, dependencies: @options) do |parser|
-                parser.def_parser  do |value, deps|
-                  options_hash = deps[:select_hashes][deps["attr"]]
-                  next value if !options_hash
-                  if value.is_a?(Array)
-                    value.map { |v| options_hash[v&.downcase.strip]  }.compact
-                  elsif value
-                    options_hash[value&.downcase.strip]
-                  end
-                end.def_serializer do |value|
-                  value
-                end
-              end
-            end
-
-          end
-        end
-      end
+class Eco::API::Common::People::DefaultParsers::SelectParser < Eco::API::Common::Loaders::Parser
+  attribute :select
+
+  class << self
+    def select_tables
+      @select_tables ||= {}
+    end
+  end
+
+  dependencies select_hashes: (lambda do |person_parser|
+    select_tables[person_parser.schema&.id] ||= person_parser.select_tables
+  end)
+
+
+  def parser(value, deps)
+    return value unless (options_map = options_hash(deps))
+    to_select_option(value, options_map, attr: deps['attr'])
+  end
+
+  def serializer(value, _deps)
+    value
+  end
+
+  private
+
+  def to_select_option(value, options_map, attr:)
+    if value.is_a?(Array)
+      value.map {|val| to_select_option(val, options_map, attr: attr)}.compact
+    elsif value
+      val = value&.downcase&.strip
+      return options_map[val] if options_map.key?(val)
+
+      unknown!(value, attr: attr)
+      nil
     end
   end
+
+  def unknown!(value, attr:)
+    return if unknown(attr).key?(value)
+    unknown(attr)[value] = value
+    log(:warn) { "Unknown select option '#{value}' for '#{attr}'" }
+  end
+
+  def unknown(attr = nil)
+    @unknown ||= {}
+    return @unknown if attr.nil?
+    @unknown[attr] ||= {}
+  end
+
+  def options_hash(deps)
+    deps[:select_hashes][deps['attr']]
+  end
 end

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

@@ -1,20 +1,20 @@
 class Eco::API::Common::People::DefaultParsers::SendInvitesParser < Eco::API::Common::Loaders::Parser
   attribute "send_invites"
 
-  def parser(hash, deps)
+  def parser(hash, _deps)
     value = hash["send_invites"]
     value = value.first if value.is_a?(Array)
     truthy(value)
   end
 
-  def serializer(person, deps)
-    person.account && person.account.send_invites&.to_s
+  def serializer(person, _deps)
+    return unless account = person.account
+    account.send_invites&.to_s
   end
-  
+
   private
 
-  def truthy (value)
+  def truthy(value)
     %w[true y yes x].include?(value.to_s&.downcase)
   end
-
 end

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

@@ -4,7 +4,7 @@ class Eco::API::Common::People::DefaultParsers::XLSParser < Eco::API::Common::Lo
   attr_accessor :already_required
   attr_reader   :file
 
-  def parser(file, deps)
+  def parser(file, _deps)
     @file = file
     rows.tap do |rws|
       @file = nil
@@ -14,7 +14,7 @@ class Eco::API::Common::People::DefaultParsers::XLSParser < Eco::API::Common::Lo
     end
   end
 
-  def serializer(array_hash, deps)
+  def serializer(_array_hash, _deps)
     raise "Not implemented. TODO: using axlsx or rubyXL gems. See: https://spin.atomicobject.com/2017/03/22/parsing-excel-files-ruby/"
   end
 
@@ -28,7 +28,6 @@ class Eco::API::Common::People::DefaultParsers::XLSParser < Eco::API::Common::Lo
     end
   end
 
-
   def headers
     logger.warn("Headers detection is using your fields_map.json file (native behaviour)")
     session.fields_mapper.list(:external).uniq
@@ -48,20 +47,18 @@ class Eco::API::Common::People::DefaultParsers::XLSParser < Eco::API::Common::Lo
   end
 
   def rows(target = headers)
-    begin
-      spreadheet.parse(header_search: target, clean: true)
-    rescue Roo::HeaderRowNotFoundError => e
-      missing  = JSON.parse(e.message)
-      logger.warn("The input file is missing these headers: #{missing}")
-      present = target - missing
-      rows(present)
-    end
+    spreadheet.parse(header_search: target, clean: true)
+  rescue Roo::HeaderRowNotFoundError => e
+    missing = JSON.parse(e.message)
+    logger.warn("The input file is missing these headers: #{missing}")
+    present = target - missing
+    rows(present)
   end
 
   def require_reading_libs!
     return if already_required
     require 'roo'
     require 'roo-xls'
-    already_required = true
+    self.already_required = true
   end
 end

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

@@ -2,7 +2,6 @@ module Eco
   module API
     module Common
       module People
-
         # Class to define a set of default attribute parsers
         class DefaultParsers < PersonParser
           autoloads_children_of "Eco::API::Common::Loaders::Parser"
@@ -16,18 +15,8 @@ module Eco
           private
 
           def define_defaults
-            # Select Options
-            select_hashes = @schema.fields.map do |fld|
-              if fld.type == "select"
-                raise "The schema selection field '#{fld.name}' is missing selection options." unless fld.options && !fld.options.empty?
-                options_hash = fld.options.map { |v| [v.downcase.strip, v] }.to_h
-                [fld.alt_id, options_hash]
-              end
-            end.compact.to_h
-
-            SelectParser.new(self, select_hashes: select_hashes).process
+            # SelectParser.new(self, select_hashes: select_tables).process
           end
-
         end
       end
     end

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

@@ -4,25 +4,26 @@ module Eco
       module People
         # Class meant to offer a _collection_ of entries, normally used to get parsed input data.
         # @attr_reader entries [Array<Eco::API::Common::PeopleEntry] a pure `Array` object.
-        class Entries <  Eco::Language::Models::Collection
+        class Entries < Eco::Language::Models::Collection
           # Error class that allows to handle cases where multiple entries were found for the same criterion.
           # @note its main purpose to prevent the false pairing of duplicates or override information between different people.
           class MultipleSearchResults < StandardError
             attr_reader :candidates, :property
+
             # @param msg [String] the basic message error.
             # @param candiates [Array<PersonEntry>] the entries that match the same search criterion.
             # @param property [String] the property of the entry model that triggered the error (base of the search criterion).
             def initialize(msg, candidates: [], property: "email")
               @candidates = candidates
               @property   = property
-              super(msg + " " + candidates_summary)
+              super("#{msg} #{candidates_summary}")
             end
 
             # @param with_index [Boolean] to add an index to each candidate description.
             # @return [Array<String>] the `candidates` identified
             def identify_candidates(with_index: false)
               candidates.map.each_with_index do |entry, i|
-                index = with_index     ? "#{i}. " : ""
+                index = with_index ? "#{i}. " : ""
                 "#{index} #{entry.identify}"
               end
             end
@@ -38,7 +39,6 @@ module Eco
               lines = ["The following entries have the same '#{property}':"]
               lines.concat(identify_candidates(with_index: true)).join("\n  ")
             end
-
           end
 
           # build the shortcuts of Collection
@@ -79,11 +79,11 @@ module Eco
           end
 
           def policy_group_ids_any(ids)
-            attr("policy_group_ids", tags, default_modifier.any.insensitive)
+            attr("policy_group_ids", ids, default_modifier.any.insensitive)
           end
 
           def policy_group_ids_all(ids)
-            attr("policy_group_ids", tags, default_modifier.all.insensitive)
+            attr("policy_group_ids", ids, default_modifier.all.insensitive)
           end
           # @!endgroup
 
@@ -105,7 +105,8 @@ module Eco
           # @param id [String] the `internal id` of the person
           # @param external_id [String] the `exernal_id` of the person
           # @param email [String] the `email` of the person
-          # @param strict [Boolean] if should perform a `:soft` or a `:strict` search. `strict` will avoid repeated email addresses.
+          # @param strict [Boolean] if should perform a `:soft` or a `:strict` search. `strict`
+          #   will avoid repeated email addresses.
           # @return [Entry, nil] the entry we were searching, or `nil` if not found.
           def entry(id: nil, external_id: nil, email: nil, strict: false)
             init_caches
@@ -154,12 +155,12 @@ module Eco
           # Helper to dump the entries into a CSV
           # @param filename [String] the destination file
           def export(filename)
-            header = each_with_object([]) do |entry, header|
-              header.push(*entry.internal_entry.keys).uniq!
+            header = each_with_object([]) do |entry, hds|
+              hds.push(*entry.internal_entry.keys).uniq!
             end
             CSV.open(filename, "w") do |csv|
               csv << header
-              self.each do |entry|
+              each do |entry|
                 csv << entry.internal_entry.values_at(*header)
               end
             end
@@ -168,7 +169,7 @@ module Eco
           # @!group Groupping methods
 
           def email_id_maps
-            email_present.group_by(:email).transform_values { |person| person.id }
+            email_present.group_by(:email).transform_values(&:id)
           end
 
           def group_by_supervisor
@@ -191,7 +192,7 @@ module Eco
           def entry_by_email(email, prevent_multiple_match: false)
             return nil unless email
 
-            candidates  = @by_email[email] || []
+            candidates = @by_email[email] || []
             return candidates.first if candidates.length == 1
 
             if prevent_multiple_match && !candidates.empty?
@@ -214,7 +215,6 @@ module Eco
           def no_nil_key(hash)
             hash.tap {|h| h.delete(nil)}
           end
-
         end
       end
     end