eco-helpers 1.5.1 → 1.5.2

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

@@ -1,42 +1,31 @@
-module Eco
-  module API
-    module Common
-      module People
-        class DefaultParsers
-          class PolicyGroupsParser < People::BaseParser
+class Eco::API::Common::People::DefaultParsers::PolicyGroupsParser < Eco::API::Common::Loaders::Parser
+  attribute "policy_group_ids"
 
-            def process
-              @parsers.define_attribute("policy_group_ids") do |parser|
-                parser.def_parser  do |columns_hash|
-                  policy_group_ids = []
-                  if policy_ids = columns_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 do |person|
-                  ids   = person&.account&.policy_group_ids || []
-                  ids.map do |id|
-                    policy_groups.to_name(id)
-                  end.compact.join("|")
-                end
-              end
-            end
+  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
 
-            private
+  def serializer(person, deps)
+    ids   = person&.account&.policy_group_ids || []
+    ids.map do |id|
+      policy_groups.to_name(id)
+    end.compact.join("|")
+  end
 
-            def policy_groups
-              @policy_groups ||= ASSETS.config.policy_groups
-            end
+  private
 
-            def default_id
-              @default_id    ||= policy_groups.to_id(ASSETS.config.people.default_usergroup)
-            end
+  def policy_groups
+    @policy_groups ||= ASSETS.config.policy_groups
+  end
 
-          end
-        end
-      end
-    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,30 +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 = value.first if value.is_a?(Array)
-                  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

@@ -12,7 +12,6 @@ module Eco
           # @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(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)
@@ -20,13 +19,12 @@ module Eco
             super(e)
 
             @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
@@ -79,8 +77,12 @@ 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}")
               end
@@ -119,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|

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

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

@@ -9,7 +9,7 @@ module Eco
           #   - if `data` is a `Person` object, its behaviour is `serialise`.
           #   - if `data` is **not** a `Person` object, it does a `parse`.
           #   - currently **in rework**, so there may be subtle differences that make it temporarily unstable (yet it is reliable).
-          # @param data [Hash, Person] `Person` object to be serialized or hashed entry (`CSV::Row` is accepted).
+          # @param data [Hash, Ecoportal::API::V1::Person] `Person` object to be serialized or hashed entry (`CSV::Row` is accepted).
           # @param person_parser [Common::People::PersonParser]  parser/serializer of person attributes (it contains a set of attribute parsers).
           # @param attr_map [Eco::Data::Mapper] mapper to translate attribute names from _external_ to _internal_ names and _vice versa_.
           # @param dependencies [Hash] hash where _keys_ are internal attribute names. It is mostly used to deliver final dependencies to attribute parsers/serializers.
@@ -26,17 +26,43 @@ module Eco
             @emap      = PersonEntryAttributeMapper.new(@source, person_parser: @person_parser, attr_map: @attr_map, logger: @logger)
 
             if parsing?
-              @external_entry     = data
-              @serialized_entry   = _mapped_entry(@external_entry)
-              @internal_entry     = _internal_entry(@serialized_entry)
+              @external_entry     = __external_entry(data)
+              @mapped_entry       = __mapped_entry(@external_entry)
+              @internal_entry     = __internal_entry(@mapped_entry)
+              @final_entry        = __final_entry(@internal_entry)
             else  # SERIALIZING
               @person             = data
-              @internal_entry     = _internal_entry(@person)
-              @serialized_entry   = _mapped_entry(@internal_entry)
-              #@external_entry     = external_entry
+              @final_entry        = __final_entry(@person)
+              @internal_entry     = __internal_entry(@final_entry)
+              @mapped_entry       = __mapped_entry(@internal_entry)
+              @external_entry     = __external_entry(@mapped_entry)
             end
           end
 
+          # Generates a new entry
+          # @return [PersonEntry]
+          def new(data)
+            self.class.new(data, person_parser: @person_parser, attr_map: @attr_map, dependencies: @deps, logger: @logger)
+          end
+
+          # @note completely serialized entry.
+          # @return [Hash] entry `Hash` with **external** attribute names, and values and types thereof.
+          def external_entry
+            @external_entry
+          end
+
+          # @note just one step away from being completely parsed (only types parsing pending).
+          # @return [Hash] entry `Hash` with **internal** attribute names and values, but **external** types.
+          def internal_entry
+            @internal_entry
+          end
+
+          # @note values ready to be set to a person.
+          # @return [Hash] entry `Hash` with **internal** attribute names, values and types.
+          def final_entry
+            @final_entry
+          end
+
           # To know if currently the object is in parse or serialize mode.
           # @return [Boolean] returns `true` if we are **parsing**, `false` otherwise.
           def parsing?
@@ -49,73 +75,83 @@ module Eco
             !parsing?
           end
 
+          # @note `Eco::API::Common::People::EntryFactory#entries` adds this `idx`
+          # @return [Integer] the entry number in the input file
+          def idx
+            final_entry["idx"]
+          end
+
           # @return [String, nil] the _internal id_ of this person if defined.
           def id
-            @internal_entry["id"]
+            final_entry["id"]
           end
 
           def id?
-            @internal_entry.key?("id")
+            final_entry.key?("id")
           end
 
           # @return [String, nil] the _external id_ of this person if defined.
           def external_id
-            @internal_entry["external_id"]
+            final_entry["external_id"]
           end
 
           def external_id?
-            @internal_entry.key?("external_id")
+            final_entry.key?("external_id")
           end
 
           # @return [String, nil] the _name_ of this person if defined.
           def name
-            @internal_entry["name"]
+            final_entry["name"]
           end
 
           def name?
-            @internal_entry.key?("name")
+            final_entry.key?("name")
           end
 
           # @return [String, nil] the _email_ of this person if defined.
           def email
-            @internal_entry["email"]
+            final_entry["email"]
           end
 
           def email?
-            @internal_entry.key?("email")
+            final_entry.key?("email")
           end
 
           # @return [String, nil] the _supervisor id_ of this person if defined.
           def supervisor_id
-            @internal_entry["supervisor_id"]
+            final_entry["supervisor_id"]
           end
 
           def supervisor_id=(value)
-            @internal_entry["supervisor_id"] = value
+            final_entry["supervisor_id"] = value
           end
 
           def supervisor_id?
-            @internal_entry.key?("supervisor_id")
+            final_entry.key?("supervisor_id")
           end
 
           def filter_tags
-            @internal_entry["filter_tags"]
+            final_entry["filter_tags"] || []
           end
 
           def filter_tags?
-            @internal_entry.key?("filter_tags")
+            final_entry.key?("filter_tags")
+          end
+
+          def policy_group_ids
+            final_entry["policy_group_ids"] || []
           end
 
           def policy_group_ids?
-            @internal_entry.key?("policy_group_ids")
+            final_entry.key?("policy_group_ids")
           end
 
           def default_tag?
-            @internal_entry.key?("default_tag")
+            final_entry.key?("default_tag")
           end
 
           def default_tag
-            @internal_entry["default_tag"]
+            final_entry["default_tag"]
           end
 
           # Provides a reference of this person.
@@ -124,9 +160,10 @@ module Eco
             options = into_a(options)
             case
             when options.include?(:identify)
-              "'#{name}' ('#{external_id}': '#{email}')"
+              str_id = id ? "id: '#{id}'; " : ""
+              "(row: #{idx}) '#{name}' (#{str_id}ext_id: '#{external_id}'; email: '#{email}')"
             else
-              @internal_entry.each.map do |k, v|
+              final_entry.each.map do |k, v|
                 "'#{k}': '#{v.to_json}'"
               end.join(" | ")
             end
@@ -135,257 +172,302 @@ module Eco
           # 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.
-          # @param person [Person] the person we want to set the core values to.
+          # @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)
-            @internal_entry.slice(*scoped_attrs).each do |attr, value|
-              _set_to_core(person, attr, value)
-            end
-          end
-
-          # Setter to fill in all the schema `details` fields of the `Person` that are present in the `Entry`.
-          # @note it only sets those details properties defined in the entry.
-          #  Meaning that if an details property is not present in the entry, this will not be set on the target person.
-          # @param person [Person] the person we want to set the schema fields' values to.
-          # @param exclude [String, Array<String>] schema field attributes that should not be set/changed to the person.
-          def set_details(person, exclude: nil)
-            person.add_details(@person_parser.schema) if !person.details || !person.details.schema_id
-            scoped_attrs = @emap.details_attrs - into_a(exclude)
-            @internal_entry.slice(*scoped_attrs).each do |attr, value|
-              _set_to_details(person, attr, value)
+            @final_entry.slice(*scoped_attrs).each do |attr, value|
+              set_part(person, attr, value)
             end
           end
 
           # Setter to fill in the `account` properties of the `Person` that are present in the `Entry`.
           # @note it only sets those account properties defined in the entry.
           #  Meaning that if an account property is not present in the entry, this will not be set on the target person.
-          # @param person [Person] the person we want to set the account values to.
+          # @param person [Ecoportal::API::Internal::Person] the person we want to set the account values to.
           # @param exclude [String, Array<String>] account properties that should not be set/changed to the person.
           def set_account(person, exclude: nil)
             person.account = {} if !person.account
             person.account.permissions_preset = nil unless person.account.permissions_preset = "custom"
             scoped_attrs = @emap.account_attrs - into_a(exclude)
-            @internal_entry.slice(*scoped_attrs).each do |attr, value|
-              _set_to_account(person, attr, value)
+            @final_entry.slice(*scoped_attrs).each do |attr, value|
+              set_part(person.account, attr, value)
             end
           end
 
-          # Entry represented in a `Hash` with **external** attribute names and values thereof.
-          # @note normally used to obtain a **serialized entry**.
-          # @return [Hash] with **external** names and values.
-          def to_hash
-            external_entry
-          end
-
-          # Entry represented in a `Hash` with **external** attribute names and values thereof.
-          # @note normally used to obtain a **serialized entry**.
-          # @return [Hash] with **external** names and values.
-          def external_entry
-            @emap.all_attrs.each_with_object({}) do |attr, hash|
-              unless hash.key?(ext_attr = @emap.to_external(attr))
-                hash[ext_attr] = @serialized_entry[attr]
-              end
+          # Setter to fill in all the schema `details` fields of the `Person` that are present in the `Entry`.
+          # @note it only sets those details properties defined in the entry.
+          #  Meaning that if an details property is not present in the entry, this will not be set on the target person.
+          # @param person [Ecoportal::API::V1::Person] the person we want to set the schema fields' values to.
+          # @param exclude [String, Array<String>] schema field attributes that should not be set/changed to the person.
+          def set_details(person, exclude: nil)
+            person.add_details(@person_parser.schema) if !person.details || !person.details.schema_id
+            scoped_attrs = @emap.details_attrs - into_a(exclude)
+            @final_entry.slice(*scoped_attrs).each do |attr, value|
+              set_part(person.details, attr, value)
             end
           end
 
-          def internal_entry
-            @internal_entry
+          private
+
+          # @return [Hash] entry in raw: that with **external** names, values and types.
+          def __external_entry(data)
+            return data if parsing?
+            _external_serializing(data)
           end
 
-          def doc
-            return @person.doc if instance_variable_defined?(:@person) && @person
+          # @return [Hash] that with **internal** names but **external** values and types.
+          def __mapped_entry(data)
+            return _mapped_parsing(data) if parsing?
+            _mapped_serializing(data)
+          end
 
-            core_attrs    = @emap.core_attrs
-            details_attrs = @emap.details_attrs
-            account_attrs = @emap.account_attrs
+          # @return [Hash] that with **internal** names and values, but **external** values and types.
+          def __internal_entry(data)
+            return _internal_parsing(data) if parsing?
+            _internal_serializing(data)
+          end
 
-            internal_entry.slice(*core_attrs).tap do |core_hash|
-              unless details_attrs.empty?
-                schema_id      = @person_parser.schema.id
-                details_fields = @person_parser.schema.doc["fields"].each_with_object([]) do |fld, flds|
-                  if details_attrs.include?(fld.alt_id)
-                    flds << fld.merge("value" => internal_entry[fld.alt_id]).slice("id", "alt_id", "type", "name", "shared", "multiple", "value")
-                  end
-                end
-                core_hash.merge!({
-                  "details" => {
-                    "schema_id" => schema_id,
-                    "fields"    => details_fields
-                  }
-                })
-              end
+          # @return [Hash] that with **internal** names, values and types.
+          def __final_entry(data)
+            return _final_parsing(data) if parsing?
+            _final_serializing(data)
+          end
 
-              unless account_attrs.empty?
-                account_hash = internal_entry.slice(*account_attrs)
-                core_hash.merge!({
-                  "account" => account_hash
-                })
+          # Serializing helper that maps internal attributes to external attribute names
+          # @note **Serialize**: here we unaliase internal attribute names into external ones.
+          # @param mapped_entry [Hash] that with **internal** names but **external** values and types.
+          # @return [Hash] with **external** names, values and types.
+          def _external_serializing(mapped_entry)
+            target_attrs    = @emap.all_attrs | @emap.aliased_attrs
+            rest_keys       = mapped_entry.keys - target_attrs
+            target_attrs   -= ["send_invites"]
+            external_entry  = target_attrs.each_with_object({}) do |attr, hash|
+              unless hash.key?(ext_attr = @emap.to_external(attr))
+                hash[ext_attr] = mapped_entry[attr]
               end
             end
+            merge_missing_attrs(external_entry, mapped_entry.slice(*rest_keys))
           end
 
-          private
-
-          def _set_to_core(person, attr, value)
-            value = value&.downcase if attr == "email"
-            multiple = ["filter_tags"].include?(attr)
-            if multiple
-              value   = @person_parser.parse(:multiple, value)
-              value   = value.map { |v| v&.upcase } if attr == "filter_tags"
-              # preserve previous order
-              current = into_a(person.send(attr))
-              value   = (current & value) + (value - current)
-            else
-              value   = value&.strip
+          # Parsing helper that aliases attribute names (from internal to external names)
+          # @note **Parse**: here we aliase external attribute names into internal ones.
+          # @param external_entry [Hash] entry in raw, with **external** names and values.
+          # @return [Hash] entry with **internal** names, but still **external** values and types.
+          def _mapped_parsing(external_entry)
+            mapped_hash = @emap.aliased_attrs.each_with_object({}) do |attr, hash|
+              hash[attr] = external_entry[@emap.to_external(attr)]
             end
+            external_entry.slice(*@emap.direct_attrs).merge(mapped_hash)
+          end
 
-            person.send("#{attr}=", value)
+          # Serializing helper that **serializes values** that have a parser/serializer defined.
+          # @note **Serializing**:
+          #   1. here we tranform internal into external **values**.
+          #   2. when running the serializers, it overrides existing keys.
+          # @param internal_entry [Hash] entry with **internal** names and values, but **external** types.
+          # @return [Hash] entry with **internal** names and **external** values and types.
+          def _mapped_serializing(internal_entry)
+            internal_entry.merge(_serialize_values(internal_entry, :internal))
           end
 
-          def _set_to_account(person, attr, value)
-            return if !person.account
-            multiple = ["policy_group_ids", "login_provider_ids"].include?(attr)
-            if multiple
-              value   = @person_parser.parse(:multiple, value)
-              # preserve previous order
-              current = into_a(person.account.send(attr))
-              value   = (current & value) + (value - current)
+          # Parsing helper that just **parses the values** that have a parser/serializer defined.
+          # @note this entry will still miss the type parsing (i.e. to `Array` if `multiple`)
+          # @param mapped_entry [Hash] the entry with the _internal attribute_ names but the _external values_.
+          # @return [Hash] the `internal entry` with the **internal** attributes names and values.
+          def _internal_parsing(mapped_entry)
+            mapped_entry.merge(_parse_values(mapped_entry, :internal))
+          end
+
+          # Serializing helper that just creates the _internal entry_ out of a _parsed entry_ (serializes the type).
+          # @param final_entry [Hash] the entry with all _internal_ (attributes, values and types)
+          # @return [Hash] the `internal entry` with the **internal** attributes names and values, but external types.
+          def _internal_serializing(final_entry)
+            final_entry        = final_entry.merge(_serialize_values(final_entry, :final))
+            core_account       = @person_parser.target_attrs_account + @person_parser.target_attrs_core
+            core_account_hash  = core_account.reduce({}) do |hash, attr|
+              hash.merge(hash_attr(attr, _serialize_type(attr, final_entry[attr])))
+            end
+            details_hash       = @person_parser.target_attrs_details.reduce({}) do |hash, attr|
+              hash.merge(hash_attr(attr, _serialize_type(attr, final_entry[attr], schema: @person_parser.schema)))
+            end
+            merging(core_account_hash, details_hash) do |internal_entry|
+              merge_missing_attrs(internal_entry, final_entry)
             end
-
-            person.account.send("#{attr}=", value)
           end
 
-          def _set_to_details(person, attr, value)
-            return if !person.details
-            unless field = person.details.get_field(attr)
-              fatal("Field '#{attr}' does not exist in details of schema: '#{person.details.schema_id}'")
+          # Parsing helper where attributes with custom parsers are already parsed, but
+          # it finishes to parse the types (i.e. to `Array` if `multiple`)
+          # @param internal_entry [Hash] the entry with the **internal** _attribute_ names and values but the **external** types.
+          # @return [Hash] the `parsed entry` with the **internal** final attributes names, values and types.
+          def _final_parsing(internal_entry)
+            core_account      = @emap.account_attrs + @emap.core_attrs
+            core_account_hash = internal_entry.slice(*core_account).each_with_object({}) do |(attr, value), hash|
+              hash[attr]  = _parse_type(attr, value)
             end
-            value = nil if value.to_s.empty?
-            value = @person_parser.parse(:multiple, value) if field.multiple
 
-            if @person_parser.defined?(field.type.to_sym)
-              value = @person_parser.parse(field.type.to_sym, value, deps: {"attr" => attr})
+            details_hash      = internal_entry.slice(*@emap.details_attrs).each_with_object({}) do |(attr, value), hash|
+              hash[attr] = _parse_type(attr, value, schema: @person_parser.schema)
             end
 
-            person.details[attr] = value
-          end
-
-          def _get_from_core (person, attr)
-            person.send(attr)
+            merging(core_account_hash, details_hash) do |final_entry|
+              final_entry = merge_missing_attrs(final_entry, internal_entry)
+              final_entry.merge(_parse_values(final_entry, :final))
+            end
           end
 
-          def _get_from_account (person, attr)
-            return nil if !person.account
-            multiple = ["policy_group_ids", "filter_tags", "login_provider_ids"].include?(attr)
-            value = person.account.send(attr)
-            value = @person_parser.serialize(:multiple, value) if multiple
-            value
+          # Serializing helper that just creates the _parsed entry_ out of a `Person` object.
+          # @note
+          #   - when unnesting attributes, the overriding precedence for collisions is
+          #     - `core` -> _overrides_ -> `account` -> _overrides_ -> `details`
+          #   - to keep things consistent, the `internal entry` hash has keys in this order:
+          #     - `core`, `account`, `details`.
+          # @param person [Ecoportal::API::V1::Person] the `Person` object to transform into a _parsed entry_.
+          # @return [Hash] the `parsed entry` with the **internal** attributes names and internal typed values.
+          def _final_serializing(person)
+            core_hash    = @person_parser.target_attrs_core.reduce({}) do |hash, attr|
+              hash.merge(hash_attr(attr, get_part(person, attr)))
+            end
+            account_hash = @person_parser.target_attrs_account.reduce({}) do |hash, attr|
+              hash.merge(hash_attr(attr, get_part(person.account, attr)))
+            end
+            details_hash = @person_parser.target_attrs_details.reduce({}) do |hash, attr|
+              hash.merge(hash_attr(attr, get_part(person.details, attr)))
+            end
+            merging(core_hash, account_hash, details_hash) do |final_entry|
+              final_entry["Has account?"] = !!person.account
+              final_entry.merge(_serialize_values(person, :person))
+            end
           end
 
-          def _get_from_details(person, attr)
-            return nil if !person.details || !person&.details&.schema_id
-            unless field = person.details.get_field(attr)
-              fatal("Field '#{attr}' does not exist in details of schema: '#{person.details.schema_id}'")
+          # HELPERS
+          def _serialize_values(entry, phase = :person)
+            @person_parser.active_attrs(entry, phase, process: :serialize).each_with_object({}) do |attr, hash|
+              data        = entry.is_a?(Hash)? entry.merge(hash) : entry
+              serial_attr = @person_parser.serialize(attr, data, phase, deps: @deps[attr] || {})
+              hash.merge!(hash_attr(attr, serial_attr))
             end
-            value = person.details[attr]
-            value = @person_parser.serialize(:date, value) if field.type == "date"
-            value = @person_parser.serialize(:multiple, value) if field.multiple
-            value
           end
 
-          # MAPPED ENTRY (when and where applicable)
-          # To obtain an entry with internal names but external values.
-          # @param data [Hash] external or raw entry (when parsing) or internal or parsed entry (when serializing).
-          # @return [Hash] entry with **internal names** and **external values**.
-          def _mapped_entry(data)
-            return _aliased_entry(data) if parsing?
-            _serialized_entry(data)
+          def _parse_values(entry, phase = :internal)
+            @person_parser.active_attrs(entry, phase).each_with_object({}) do |attr, hash|
+              parsed_attr = @person_parser.parse(attr, entry.merge(hash), phase)
+              hash.merge!(hash_attr(attr, parsed_attr))
+            end
           end
 
-          # Parsing helper that aliases attribute names (from internal to external names)
-          # @note **Parse**: here we aliase internal attribute names into external ones.
-          # @param ext_entry [Hash] entry in raw, with **external** names and values.
-          # @return [Hash] entry with **internal names** and **external values**.
-          def _aliased_entry(ext_entry)
-            aliased_hash = @emap.aliased_attrs.map do |attr|
-              [attr, ext_entry[@emap.to_external(attr)]]
-            end.to_h
-
-            ext_entry.slice(*@emap.direct_attrs).merge(aliased_hash)
+          # Transforms each **typed** value into its `String` version
+          def _serialize_type(attr, value, schema: nil)
+            case
+            when !!schema
+              unless field = schema[attr]
+                fatal("Field '#{attr}' does not exist in details of schema: '#{schema.name}'")
+              end
+              value = @person_parser.serialize(:multiple, value) if field.multiple
+              if @person_parser.defined?(field.type.to_sym)
+                value = @person_parser.serialize(field.type.to_sym, value, deps: {"attr" => attr})
+              end
+              value
+            when ["policy_group_ids", "filter_tags", "login_provider_ids", "starred_ids"].include?(attr)
+              @person_parser.serialize(:multiple, value)
+            when ["freemium", "accept_eula"].include?(attr)
+              @person_parser.serialize(:boolean, value)
+            when ["subordinates"].include?(attr)
+              @person_parser.serialize(:number, value)
+            else
+              value
+            end
           end
 
-          def hash_attr(attr, value)
-            return value if value.is_a?(Hash)
-            { attr => value }
-          end
+          # Transforms each `String` value into its **typed** version
+          def _parse_type(attr, value, schema: nil)
+            value = value.strip if value.is_a?(String)
+            value = nil         if value.to_s.strip.empty?
+            case
+            when !!schema
+              unless field = schema[attr]
+                fatal("Field '#{attr}' does not exist in details of schema: '#{schema.name}'")
+              end
+              value = @person_parser.parse(:multiple, value) if field.multiple
 
-          # Serializing helper that serializes values (from internal to external values).
-          # @note **Serializing**:
-          #   1. here we tranform internal into external **values**.
-          #   2. when running the serializers, it overrides existing keys.
-          # @param unserialized_entry [Hash] entry with **internal** names and values.
-          # @return [Hash] entry with **internal names** and **external values**.
-          def _serialized_entry(unserialized_entry)
-            serial_attrs = @person_parser.defined_attrs.reduce({}) do |serial_hash, attr|
-              deps = @deps[attr] || {}
-              serial_attr = @person_parser.serialize(attr, @person, deps: deps)
-              serial_hash.merge(hash_attr(attr, serial_attr))
-            end
-            unserialized_entry.merge(serial_attrs).tap do |hash|
-              if hash.key?("filter_tags") && hash["filter_tags"].is_a?(Array)
-                  hash["filter_tags"] = @person_parser.serialize(:multiple, hash["filter_tags"])
+              if @person_parser.defined?(field.type.to_sym)
+                value = @person_parser.parse(field.type.to_sym, value, deps: {"attr" => attr})
               end
+              value
+            when attr == "email"
+              value = value.strip.downcase if value
+              value
+            when ["policy_group_ids", "filter_tags", "login_provider_ids", "starred_ids"].include?(attr)
+              value = @person_parser.parse(:multiple, value)
+              value = (attr == "filter_tags")? value.compact.map(&:upcase) : value
+              value
+            when ["freemium", "accept_eula"].include?(attr)
+              @person_parser.parse(:boolean, value)
+            when ["subordinates"].include?(attr)
+              @person_parser.parse(:number, value)
+            else
+              value
             end
           end
 
-          # To obtain an entry with internal names but external values.
-          # @param data [Hash, Ecoportal::API::V1::Person] alised_entry (when parsing) or person (when serializing).
-          # @return [Hash] the `internal entry` with the **internal** attributes names and values.
-          def _internal_entry(data)
-            return _parsed_entry(data) if parsing?
-            _unserialized_entry(data)
+          # Merges multiple hashes giving overriding perference to the first ones.
+          # @return [Hash] with well sorted keys, as they came in the order of the input hashes.
+          def merging(*hashes)
+            sorted_keys = hashes.map {|h| h.keys}.flatten.uniq
+            rev_hash    = hashes.reverse.each_with_object({}) {|h, out| out.merge!(h)}
+            merged      = sorted_keys.each_with_object({}) do |k, h|
+              h[k] = rev_hash[k]
+            end
+            merged      = yield(merged) if block_given?
+            merged
           end
 
-          # Parsing helper that just **parses the values** that have a parser/serializer defined.
-          # @param aliased_entry [Hash] the entry with the _internal attribute_ names but the _external values_.
-          # @return [Hash] the `internal entry` with the **internal** attributes names and values.
-          def _parsed_entry(aliased_entry)
-            parsed = @person_parser.active_attrs(aliased_entry).each_with_object({}) do |attr, hash|
-              hash[attr] = @person_parser.parse(attr, aliased_entry.merge(hash))
-            end
-            aliased_entry.merge(parsed)
+          # Adds to `dest_entry` the `keys` it misses from `source_entry`
+          def merge_missing_attrs(dest_entry, source_entry)
+            keys_rest = source_entry.keys - dest_entry.keys
+            dest_entry.merge(source_entry.slice(*keys_rest))
           end
 
-          # Serializing helper that just creates the _internal entry_ out of a `Person` object.
-          # @note
-          #   - when unnesting attributes, the overriding precedence for collisions is
-          #     - `core` -> _overrides_ -> `account` -> _overrides_ -> `details`
-          #   - to keep things consistent, the `internal entry` hash has keys in this order:
-          #     - `core`, `account`, `details`.
-          # @param person [Ecoportal::API::V1::Person] the `Person` object to transform into an _internal entry_.
-          # @return [Hash] the `internal entry` with the **internal** attributes names and values.
-          def _unserialized_entry(person)
-            core_hash = @person_parser.target_attrs_core.reduce({}) do |hash, attr|
-              value = _get_from_core(person, attr)
-              hash.merge(hash_attr(attr, value))
-            end
+          def into_a(value)
+            value = [] if value == nil
+            value = [].push(value) unless value.is_a?(Array)
+            value
+          end
 
-            details_hash = @person_parser.target_attrs_details.reduce({}) do |hash, attr|
-              value = _get_from_details(person, attr)
-              hash.merge(hash_attr(attr, value))
+          def get_part(obj, attr)
+            return unless obj
+            case obj
+            when Ecoportal::API::V1::PersonDetails
+              #unless field = obj.get_field(attr)
+              #  fatal("Field '#{attr}' does not exist in details of schema: '#{obj.schema_id}'")
+              #end
+              obj[attr]
+            else
+              obj.send(attr)
             end
+          end
 
-            account_hash = @person_parser.target_attrs_account.reduce({}) do |hash, attr|
-              value = _get_from_account(person, attr)
-              hash.merge(hash_attr(attr, value))
+          def set_part(obj, attr, value)
+            return unless obj
+            begin
+              case obj
+              when Ecoportal::API::V1::PersonDetails
+                unless field = obj.get_field(attr)
+                  fatal("Field '#{attr}' does not exist in details of schema: '#{obj.schema_id}'")
+                end
+                obj[attr] = value
+              else
+                obj.send("#{attr}=", value)
+              end
+            rescue Exception => e
+              raise e.append_message " -- Entry #{to_s(:identify)}"
             end
+          end
 
-            # merge by core overriding account and details
-            rh = details_hash.merge(account_hash).merge(core_hash)
-            # resort hash keys
-            sorted_keys = core_hash.keys | account_hash.keys | details_hash.keys
-            sorted_keys.reduce({}) {|h,k| h[k] = rh[k]; h}
+          # @return [Hash] `value` if it was a `Hash`, and `{ attr => value}` otherwise
+          def hash_attr(attr, value)
+            return value if value.is_a?(Hash)
+            { attr => value }
           end
 
           # LOGGER
@@ -398,11 +480,21 @@ module Eco
             raise msg
           end
 
-          # HELPERS
-          def into_a(value)
-            value = [] if value == nil
-            value = [].push(value) unless value.is_a?(Array)
-            value
+          # Function to debug faste
+          def print_models
+            print_it = Proc.new do |name, model|
+              puts "#{name}:"
+              pp model
+              puts "*" * 30
+            end
+
+            fin = Proc.new {|x_| print_it.call("final_entry",    @final_entry)    }
+            int = Proc.new {|x_| print_it.call("internal_entry", @internal_entry) }
+            mad = Proc.new {|x_| print_it.call("mapped_entry",   @mapped_entry)   }
+            ext = Proc.new {|x_| print_it.call("external_entry", @external_entry) }
+
+            call_order = parsing? ? [ext, mad, int, fin] : [fin, int, mad, ext]
+            call_order.each {|proc| proc.call}
           end
 
         end