eco-helpers 1.4.2 → 1.5.4

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

@@ -0,0 +1,20 @@
+class Eco::API::Common::People::DefaultParsers::FreemiumParser < Eco::API::Common::Loaders::Parser
+  attribute "freemium"
+
+  def parser(hash, deps)
+    value = hash["freemium"]
+    value = value.first if value.is_a?(Array)
+    truthy(value)
+  end
+
+  def serializer(person, deps)
+    person.freemium&.to_s
+  end
+
+  private
+
+  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

@@ -0,0 +1,26 @@
+class Eco::API::Common::People::DefaultParsers::LoginProvidersParser < Eco::API::Common::Loaders::Parser
+  attribute "login_provider_ids"
+  parsing_phase     :final
+  serializing_phase :final
+
+  def parser(hash, deps)
+    hash["login_provider_ids"].map do |name|
+      login_providers.to_id(name&.downcase.strip)
+    end.compact
+  end
+
+  def serializer(hash, deps)
+    if ids = hash["login_provider_ids"]
+      login_providers.to_name(ids)
+    else
+      []
+    end
+  end
+
+  private
+
+  def login_providers
+    @login_providers ||= ASSETS.config.login_providers
+  end
+
+end

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

@@ -1,33 +1,21 @@
-module Eco
-  module API
-    module Common
-      module People
-        class DefaultParsers
-          class MultiParser < People::BaseParser
+class Eco::API::Common::People::DefaultParsers::MultiParser < Eco::API::Common::Loaders::Parser
+  attribute :multiple
 
-            def process
-              @parsers.define_attribute(:multiple) do |parser|
-                parser.def_parser  do |value|
-                  next value if value.is_a?(Array)
-                  value = value.split("|") if value&.include?("|")
-                  into_a(value)
-                end.def_serializer do |value|
-                  into_a(value).join("|")
-                end
-              end
-            end
+  def parser(value, deps)
+    into_a(value)
+  end
 
-            private
+  def serializer(value, deps)
+    into_a(value).join("|")
+  end
 
-            def into_a(value)
-              value = [] if value == nil
-              value = [].push(value) unless value.is_a?(Array)
-              value
-            end
+  private
 
-          end
-        end
-      end
-    end
+  def into_a(value)
+    return []               if value.nil?
+    return value            if value.is_a?(Array)
+    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,23 +1,18 @@
-module Eco
-  module API
-    module Common
-      module People
-        class DefaultParsers
-          class NumericParser < People::BaseParser
+class Eco::API::Common::People::DefaultParsers::NumericParser < Eco::API::Common::Loaders::Parser
+  attribute :number
 
-            def process
-              @parsers.define_attribute(:number, dependencies: @options) do |parser|
-                parser.def_parser  do |value, deps|
-                  value = value.to_s.strip.empty? ? nil : (value.to_f rescue nil)
-                end.def_serializer do |value|
-                  value.is_a?(Array) ? value.map { |v| v.to_s } : value.to_s
-                end
-              end
-            end
+  def parser(value, deps)
+    value.is_a?(Array) ? value.map { |v| parse_number(v) } :  parse_number(value)
+  end
 
-          end
-        end
-      end
-    end
+  def serializer(value, deps)
+    value.is_a?(Array) ? value.map { |v| v.to_s } : value.to_s
   end
+
+  private
+
+  def parse_number(value)
+    value.to_s.strip.empty? ? nil : (value.to_f rescue nil)
+  end
+
 end

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

@@ -0,0 +1,31 @@
+class Eco::API::Common::People::DefaultParsers::PolicyGroupsParser < Eco::API::Common::Loaders::Parser
+  attribute "policy_group_ids"
+
+  def parser(hash, deps)
+    policy_group_ids = []
+    if policy_ids = hash["policy_group_ids"]
+      policy_group_ids = policy_ids.split("|").map do |name|
+        policy_groups.to_id(name&.downcase.strip)
+      end.compact
+    end
+    policy_group_ids.empty?? default_id : policy_group_ids.join("|")
+  end
+
+  def serializer(person, deps)
+    ids   = person&.account&.policy_group_ids || []
+    ids.map do |id|
+      policy_groups.to_name(id)
+    end.compact.join("|")
+  end
+
+  private
+
+  def policy_groups
+    @policy_groups ||= ASSETS.config.policy_groups
+  end
+
+  def default_id
+    @default_id    ||= policy_groups.to_id(ASSETS.config.people.default_usergroup)
+  end
+
+end

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

@@ -1,29 +1,20 @@
-module Eco
-  module API
-    module Common
-      module People
-        class DefaultParsers
-          class SendInvitesParser < People::BaseParser
+class Eco::API::Common::People::DefaultParsers::SendInvitesParser < Eco::API::Common::Loaders::Parser
+  attribute "send_invites"
 
-            def process
-              @parsers.define_attribute("send_invites") do |parser|
-                parser.def_parser  do |hash|
-                  value = hash["send_invites"]
-                  value.is_a?(Array) ? value.map { |v| truthy(v) } : truthy(value)
-                end.def_serializer do |person|
-                  person.account && person.account.send_invites&.to_s
-                end
-              end
-            end
+  def parser(hash, deps)
+    value = hash["send_invites"]
+    value = value.first if value.is_a?(Array)
+    truthy(value)
+  end
 
-            private
+  def serializer(person, deps)
+    person.account && person.account.send_invites&.to_s
+  end
+  
+  private
 
-            def truthy (value)
-              %w[true y yes x].include?(value.to_s&.downcase)
-            end
-          end
-        end
-      end
-    end
+  def truthy (value)
+    %w[true y yes x].include?(value.to_s&.downcase)
   end
+
 end

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

@@ -3,7 +3,7 @@ module Eco
     module Common
       module People
         # Class meant to offer a _collection_ of entries, normally used to get parsed input data.
-        # @attr_reader entries [Array<Eco::API::Common::PersonEntry] a pure `Array` object.
+        # @attr_reader entries [Array<Eco::API::Common::PeopleEntry] a pure `Array` object.
         class Entries <  Eco::Language::Models::Collection
           # build the shortcuts of Collection
           attr_collection :id, :external_id, :email, :name, :supervisor_id
@@ -17,37 +17,41 @@ module Eco
             @caches_init = false
           end
 
-          # Override `each` to make it work with supervisor hiearchy
-          def each(params: {}, &block)
-            return to_enum(:each) unless block
-            @array_supers = sort_by_supervisors(@items) unless @caches_init
-            @array_supers.each(&block)
+          # @!group Main identifier helpers
+
+          def id(*args)
+            attr('id', *args).first
+          end
+
+          def external_id(*args)
+            attr('external_id', *args).first
           end
 
           def [](id_or_ext)
             id(id_or_ext) || external_id(id_or_ext)
           end
+          # @!endgroup
 
-          def id(*args)
-            attr('id', *args).first
+          # @!group Special filters
+
+          def filter_tags_any(tags)
+            attr("filter_tags", tags, default_modifier.any.insensitive)
           end
 
-          def external_id(*args)
-            attr('external_id', *args).first
+          def filter_tags_all(tags)
+            attr("filter_tags", tags, default_modifier.all.insensitive)
           end
 
-          # Helper to dump the entries into a CSV
-          # @param filename [String] the destination file
-          def export(filename)
-            CSV.open(filename, "w") do |csv|
-              entry  = self.first
-              header = entry.internal_entry.keys
-              csv << header
-              self.each do |entry|
-                csv << entry.internal_entry.values
-              end
-            end
+          def policy_group_ids_any(ids)
+            attr("policy_group_ids", tags, default_modifier.any.insensitive)
+          end
+
+          def policy_group_ids_all(ids)
+            attr("policy_group_ids", tags, default_modifier.all.insensitive)
           end
+          # @!endgroup
+
+          # @!group Searchers
 
           # Search function to find an `entry` based on one of different options
           def entry(id: nil, external_id: nil, email: nil, strict: false)
@@ -68,11 +72,21 @@ module Eco
           # Search function to find an `entry` based on one of different options
           # see Eco::API::Common::People::Entries#entry
           def find(object, strict: false)
-            id          = object.respond_to?("id")?          object.send("id") : nil
-            external_id = object.respond_to?("external_id")? object.send("external_id") : nil
-            email       = object.respond_to?("email")?       object.send("email") : nil
+            id          = attr_value(object, "id")
+            external_id = attr_value(object, "external_id")
+            email       = attr_value(object, "email")
             entry(id: id, external_id: external_id, email: email, strict: strict)
           end
+          # @!endgroup
+
+          # @!group Basic Collection Methods
+
+          # Override `each` to make it work with supervisor hiearchy
+          def each(&block)
+            return to_enum(:each) unless block
+            @array_supers = sort_by_supervisors(@items) unless @caches_init
+            @array_supers.each(&block)
+          end
 
           def exclude(object)
             exclude_people(into_a(object))
@@ -85,6 +99,21 @@ module Eco
             newFrom to_a - discarded
           end
 
+          # Helper to dump the entries into a CSV
+          # @param filename [String] the destination file
+          def export(filename)
+            CSV.open(filename, "w") do |csv|
+              entry  = self.first
+              header = entry.internal_entry.keys
+              csv << header
+              self.each do |entry|
+                csv << entry.internal_entry.values
+              end
+            end
+          end
+
+          # @!group Groupping methods
+
           def email_id_maps
             email_present.group_by(:email).transform_values { |person| person.id }
           end
@@ -96,6 +125,7 @@ module Eco
           def to_h(attr = "id")
             super(attr || "id")
           end
+          # @!endgroup
 
           protected
 

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

@@ -4,29 +4,27 @@ module Eco
       module People
         # Helper factory class to generate entries (input entries).
         # @attr_reader schema [Ecoportal::API::V1::PersonSchema] person schema to be used in this entry factory
-        # @attr_reader person_parser [Eco::API::Common::People::PersonParser] set of attribute, type and format parsers/serializers.
-        class EntryFactory
+        class EntryFactory < Eco::API::Common::Session::BaseSession
 
           attr_reader :schema, :person_parser
 
+          # @param e [Eco::API::Common::Session::Environment] requires a session environment, as any child of `Eco::API::Common::Session::BaseSession`
           # @param schema [Ecoportal::API::V1::PersonSchema] schema of person details that the parser will be based upon.
           # @param person_parser [nil, Eco::API::Common::People::PersonParser] set of attribute, type and format parsers/serializers.
           # @param attr_map [nil, Eco::Data::Mapper] attribute names mapper to translate external names into internal ones and _vice versa_.
-          # @param logger [Common::Session::Logger, ::Logger] object to manage logs.
-          def initialize(schema:, person_parser: nil, attr_map: nil, logger: ::Logger.new(IO::NULL))
+          def initialize(e, schema:, person_parser: nil, attr_map: nil)
             fatal "Constructor needs a PersonSchema. Given: #{schema}" if !schema.is_a?(Ecoportal::API::V1::PersonSchema)
             fatal "Expecting PersonParser. Given: #{person_parser}"    if person_parser && !person_parser.is_a?(Eco::API::Common::People::PersonParser)
             fatal "Expecting Mapper object. Given: #{fields_mapper}"   if attr_map && !attr_map.is_a?(Eco::Data::Mapper)
+            super(e)
 
-            @logger = logger
             @schema = Ecoportal::API::V1::PersonSchema.new(JSON.parse(schema.doc.to_json))
-
             @source_person_parser = person_parser
 
-            # load default parsers
-            @person_parser = Eco::API::Common::People::DefaultParsers.new(schema: @schema)
-            # merge the custom parsers
-            @person_parser = @person_parser.merge(@source_person_parser)
+            # load default parser + custom parsers
+            base_parser = Eco::API::Common::People::DefaultParsers.new(schema: @schema).merge(@source_person_parser)
+            # new parser with linked schema
+            @person_parser = @source_person_parser.new(schema: @schema).merge(base_parser)
             @person_parser_patch_version = @source_person_parser.patch_version
 
             @attr_map = attr_map
@@ -34,6 +32,7 @@ module Eco
 
           # provides with a Eco::API::Common::People::PersonParser object (collection of attribute parsers)
           # @note if the custom person parser has changed, it updates the copy of this EntryFactory instance
+          # @return [Eco::API::Common::People::PersonParser] set of attribute, type and format parsers/serializers.
           def person_parser
             if @person_parser_patch_version < @source_person_parser.patch_version
               @person_parser.merge(@source_person_parser)
@@ -52,7 +51,7 @@ module Eco
               person_parser: person_parser,
               attr_map:      @attr_map,
               dependencies:  dependencies,
-              logger:        @logger
+              logger:        logger
             )
           end
 
@@ -78,10 +77,14 @@ module Eco
               arr_hash = []
               if Eco::API::Common::Session::FileManager.file_exists?(file)
                 encoding   ||= Eco::API::Common::Session::FileManager.encoding(file)
+                encoding     = (encoding != "utf-8")? "#{encoding}|utf-8": encoding
                 file_content = File.read(file, encoding: encoding)
-                arr_hash     = person_parser.parse(format, file_content)
+                arr_hash     = person_parser.parse(format, file_content).map.each_with_index do |entry_hash, i|
+                  j = (format == :csv)? i + 2 : i + 1
+                  entry_hash.tap {|hash| hash["idx"] = j}
+                end
               else
-                @logger.warn("File does not exist: #{file}")
+                logger.warn("File does not exist: #{file}")
               end
 
               entries(data: arr_hash)
@@ -118,7 +121,7 @@ module Eco
               deps = {"supervisor_id" => {people: data}}
 
               data_entries = data.map do |person|
-                self.new(person, dependencies: deps).to_hash
+                self.new(person, dependencies: deps).external_entry
               end
 
               File.open(file, "w", enconding: encoding) do |fd|
@@ -131,7 +134,7 @@ module Eco
           private
 
           def fatal(msg)
-            @logger.fatal(msg)
+            logger.fatal(msg)
             raise msg
           end
 

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

@@ -12,21 +12,39 @@ module Eco
           # parser will be active/used.
           #  - this is important to help avoiding to set values that are not present in the input entry.
           #  - if you have doubts about using it or not, do not use it.
-          # @param active_when [Proc] that expects a list of internal attributes or the internal entry itself
+          # @param phase [Symbol] the phase when this parser should be active.
+          #   Must be one of [`:internal`, `:final`]
+          # @param active_when [Proc] that expects a list of internal attributes or the internal entry itself.
           # By default, an attribute paraser is active if in the entry to parse the internal attribute is present.
-          def def_parser(active_when: nil, &block)
+          def def_parser(phase = :internal, active_when: nil, &block)
             @active_when = attribute_present(active_when)
-            super(&block)
+            super(phase, &block)
           end
 
-          # Determines if for a given source data to parse, this parser should be active or not
-          # @return [Boolean] `true` if there's no callback defined or there is and evaluates `true`
-          # when for the current data to parse. It returns `false` otherwise.
-          def parser_active?(source_data)
-            @active_when.call(source_data)
+          # @param phase [Symbol] the phase when this serializer should be active.
+          #   Must be one of [`:person,` `:final`, `:internal`]
+          def def_serializer(phase = :person, &block)
+            super(phase, &block)
           end
 
-          # Helper to build the `active_when` condition
+          # Determines if for a given source data to parse, this parser should be active or not.
+          # @param phase [Symbol] the phase when this parser should be active.
+          #   Must be one of [`:internal`, `:final`]
+          # @return [Boolean] `true` if there's parser defined and `source_data` activates it.
+          def parser_active?(source_data, phase = :any)
+            (phase == :any || parser_category?(phase)) && @active_when.call(source_data)
+          end
+
+          # Determines a serializer should be active or not.
+          # @param phase [Symbol] the phase when this serializer should be active.
+          #   Must be one of [`:person,` `:final`, `:internal`]
+          # @return [Boolean] `true` if there's serializer defined.
+          def serializer_active?(phase = :any)
+            (phase == :any) || serializer_category?(phase)
+          end
+
+
+          # Helper to build the `active_when` condition.
           def active_when_any?(*attrs)
             Proc.new do |source_data|
               keys = data_keys(source_data)
@@ -34,7 +52,7 @@ module Eco
             end
           end
 
-          # Helper to build the `active_when` condition
+          # Helper to build the `active_when` condition.
           def active_when_all?(*attrs)
             Proc.new do |source_data|
               keys = data_keys(source_data)
@@ -44,7 +62,7 @@ module Eco
 
           private
 
-          # by default, an attribute paraser is active if in the entry to parse
+          # By default, an attribute paraser is active if in the entry to parse
           # the internal attribute is present
           def attribute_present(active_when)
             Proc.new do |source_data|
@@ -67,7 +85,6 @@ module Eco
             end
           end
 
-
         end
       end
     end