eco-helpers 2.6.3 → 2.7.0

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

@@ -2,25 +2,39 @@ module Eco
   module API
     module Common
       module People
-        # TODO: EntryFactory should suppport multiple schemas itself (rather that being done on `Session`)
-        # => currently, it's through session.entry_factory(schema: id), but this is wrong
-        # => This way, Entries and PersonEntry will be able to refer to attr_map and person_parser linked to schema_id
-        # => "schema_id" should be an optional column in the input file, or parsable via a custom parser to scope the schema
+        # TODO: EntryFactory should suppport multiple schemas itself
+        #   (rather that being done on `Session`)
+        # => currently, it's through session.entry_factory(schema: id),
+        #   but this is wrong
+        # => This way, Entries and PersonEntry will be able to refer to attr_map
+        #   and person_parser linked to schema_id
+        # => "schema_id" should be an optional column in the input file,
+        #   or parsable via a custom parser to scope the schema
         # 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 schema [Ecoportal::API::V1::PersonSchema] person schema to
+        #   be used in this entry factory
         class EntryFactory < Eco::API::Common::Session::BaseSession
           include Eco::Data::Files
 
-          attr_reader :schema, :person_parser
+          attr_reader :schema
 
-          # @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 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_.
           def initialize(e, schema:, person_parser: nil, default_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)
+            msg = "Constructor needs a PersonSchema. Given: #{schema.class}"
+            fatal msg unless schema.is_a?(Ecoportal::API::V1::PersonSchema)
+
+            msg = "Expecting PersonParser. Given: #{person_parser.class}"
+            fatal msg if person_parser && !person_parser.is_a?(Eco::API::Common::People::PersonParser)
+
+            msg = "Expecting Mapper object. Given: #{attr_map.class}"
+            fatal msg if attr_map && !attr_map.is_a?(Eco::Data::Mapper)
             super(e)
 
             @schema = Ecoportal::API::V1::PersonSchema.new(JSON.parse(schema.doc.to_json))
@@ -35,17 +49,16 @@ module Eco
             @attr_map = attr_map
           end
 
-          def newFactory(schema: nil)
+          def newFactory(schema: nil) # rubocop:disable Naming/MethodName
             self.class.new(
               environment,
-              schema: schema,
-              person_parser: @source_person_parser,
+              schema:         schema,
+              person_parser:  @source_person_parser,
               default_parser: @default_parser,
-              attr_map: @attr_map
+              attr_map:       @attr_map
             )
           end
 
-
           # 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.
@@ -57,9 +70,12 @@ module Eco
             @person_parser
           end
 
-          # key method to generate objects of `PersonEntry` that share dependencies via this `EntryFactory` environment.
-          # @note this method is necessary to make the factory object work as a if it was a class `PersonEntry` you can call `new` on.
-          # @param data [Hash, Person] data to be parsed/serialized. Parsed: the external hashed entry. Serialized: a Person object.
+          # key method to generate objects of `PersonEntry` that share dependencies
+          # via this `EntryFactory` environment.
+          # @note this method is necessary to make the factory object work
+          #   as a if it was a class `PersonEntry` you can call `new` on.
+          # @param data [Hash, Person] data to be parsed/serialized.
+          #   Parsed: the external hashed entry. Serialized: a Person object.
           # @return [Eco::API::Common::People::PersonEntry]
           def new(data, dependencies: {})
             PersonEntry.new(
@@ -71,7 +87,8 @@ module Eco
             )
           end
 
-          # Helper that provides a collection of `Entries`, which in turn provides with further helpers to find and exclude entries.
+          # Helper that provides a collection of `Entries`, which in turn provides
+          # with further helpers to find and exclude entries.
           # It accepts a `file:` and `format:` or `data:` but not both options together.
           # @raise Exception
           #   - if you try to provide `data:` and `file:` at the same time.
@@ -85,11 +102,18 @@ module Eco
           # @option options [String] :encoding optional parameter to read `file:` by expecting certain encoding.
           # @option options [Boolean] :check_headers signals if the `csv` file headers should be expected.
           # @return [Eco::API::Common::People::Entries] collection of `Eco::API::Common::People::PersonEntry`.
-          def entries(data: (no_data = true; nil), file: (no_file = true; nil), format: (no_format = true; nil), **options)
-            fatal("You should at least use data: or file:, but not both")         if no_data == no_file
-            fatal("You must specify a valid format: (symbol) when you use file.") if file && no_format
-            fatal("Format should be a Symbol. Given '#{format}'")                 if format && !format.is_a?(Symbol)
-            fatal("There is no parser/serializer for format ':#{format.to_s}'")   unless no_format || @person_parser.defined?(format)
+          def entries(data: (no_data = true; nil), file: (no_file = true; nil), format: (no_format = true; nil), **options) # rubocop:disable Style/Semicolon
+            msg = "You should at least use data: or file:, but not both"
+            fatal msg if no_data == no_file
+
+            msg = "You must specify a valid format: (symbol) when you use file."
+            fatal msg if file && no_format
+
+            msg = "Format should be a Symbol. Given '#{format}'"
+            fatal msg if format && !format.is_a?(Symbol)
+
+            msg = "There is no parser/serializer for format ':#{format}'"
+            fatal msg unless no_format || @person_parser.defined?(format)
 
             options.merge!(content:  data)     unless no_data
             options.merge!(file:     file)     unless no_file
@@ -98,8 +122,7 @@ module Eco
             Entries.new(to_array_of_hashes(**options), klass: PersonEntry, factory: self)
           end
 
-          def to_array_of_hashes(**kargs)
-            data = []
+          def to_array_of_hashes(**kargs) # rubocop:disable Metrics/AbcSize
             content, file, encoding, format = kargs.values_at(:content, :file, :encoding, :format)
 
             # Support for multiple file
@@ -112,7 +135,7 @@ module Eco
             end
             # Get content only when it's not :xls
             # note: even if content was provided, file takes precedence
-            if (format != :xls) && file
+            if (format != :xls) && file # rubocop:disable Style/IfUnlessModifier
               content = get_file_content(file, encoding: encoding)
             end
 
@@ -156,34 +179,42 @@ module Eco
           #   - if there is no _parser/serializer_ defined for `format:`.
           # @param data [Eco::API::Organization::People] data to be parsed.
           # @param file [String] absolute or relative path to the ouput file.
-          # @param format [Symbol] it specifies the format of the output `file:` (i.e. `:xml`, `:csv`). There must be a parser/serializer defined for it.
+          # @param format [Symbol] it specifies the format of the output `file:` (i.e. `:xml`, `:csv`).
+          #   There must be a parser/serializer defined for it.
           # @param encoding [String] optional parameter to geneate `file:` content by unsing certain encoding.
           # @return [Void].
           def export(data:, file: "export", format: :csv, encoding: "utf-8", internal_names: false)
-            fatal("data: Expected Eco::API::Organization::People object. Given: #{data.class}") unless data.is_a?(Eco::API::Organization::People)
-            fatal("A file should be specified.") unless !file.to_s.strip.empty?
-            fatal("Format should be a Symbol. Given '#{format}'") if format && !format.is_a?(Symbol)
-            fatal("There is no parser/serializer for format ':#{format.to_s}'") unless @person_parser.defined?(format)
+            msg = "data: Expected Eco::API::Organization::People object. Given: #{data.class}"
+            fatal msg unless data.is_a?(Eco::API::Organization::People)
+
+            fatal "A file should be specified."                   if file.to_s.strip.empty?
+            fatal "Format should be a Symbol. Given '#{format}'"  if format && !format.is_a?(Symbol)
+
+            msg = "There is no parser/serializer for format ':#{format}'"
+            fatal msg unless @person_parser.defined?(format)
 
             run = true
             if self.class.file_exists?(file)
-              prompt_user("Do you want to overwrite it? (Y/n):", explanation: "The file '#{file}' already exists.", default: "Y") do |response|
+              prompt_user(
+                "Do you want to overwrite it? (Y/n):",
+                explanation: "The file '#{file}' already exists.",
+                default:     "Y"
+              ) do |response|
                 run = (response == "") || response.upcase.start_with?("Y")
               end
             end
 
-            if run
-              deps = {"supervisor_id" => {people: data}}
+            return unless run
 
-              data_entries = data.map do |person|
-                self.new(person, dependencies: deps).yield_self do |entry|
-                  internal_names ? entry.mapped_entry : entry.external_entry
-                end
+            deps         = {"supervisor_id" => {people: data}}
+            data_entries = data.map do |person|
+              new(person, dependencies: deps).then do |entry|
+                internal_names ? entry.mapped_entry : entry.external_entry
               end
+            end
 
-              File.open(file, "w", enconding: encoding) do |fd|
-                fd.write(person_parser.serialize(format, data_entries))
-              end
+            File.open(file, "w", enconding: encoding) do |fd|
+              fd.write(person_parser.serialize(format, data_entries))
             end
           end
 

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

@@ -2,10 +2,8 @@ module Eco
   module API
     module Common
       module People
-
         # Class to define a parser/serializer.
         class PersonAttributeParser < Eco::Language::Models::ParserSerializer
-
           # @note
           #   - This was introduced at a later stage and might not be available for certain org-parsers configs
           # @return [RequiredAttrs]
@@ -51,10 +49,9 @@ module Eco
             (phase == :any) || serializer_category?(phase)
           end
 
-
           # Helper to build the `active_when` condition.
           def active_when_any?(*attrs)
-            Proc.new do |source_data|
+            proc do |source_data|
               keys = data_keys(source_data)
               attrs.any? {|key| keys.include?(key)}
             end
@@ -62,7 +59,7 @@ module Eco
 
           # Helper to build the `active_when` condition.
           def active_when_all?(*attrs)
-            Proc.new do |source_data|
+            proc do |source_data|
               keys = data_keys(source_data)
               attrs.all? {|key| keys.include?(key)}
             end
@@ -73,9 +70,9 @@ module Eco
           # 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|
-              data_keys(source_data).include?(self.attr) ||
-              (active_when && active_when.call(source_data))
+            proc do |source_data|
+              data_keys(source_data).include?(self.attr) || # rubocop:disable Style/RedundantSelf
+                active_when&.call(source_data)
             end
           end
 
@@ -85,14 +82,13 @@ module Eco
           def data_keys(source_data)
             case source_data
             when Array
-              keys = source_data
+              source_data
             when Hash
-              keys = source_data.keys
+              source_data.keys
             else
-              keys = []
+              []
             end
           end
-
         end
       end
     end

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

@@ -10,21 +10,34 @@ 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, 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.
-          # @param logger [Common::Session::Logger, ::Logger] object to manage logs.
+          # @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.
+          # @param logger [Common::Session::Logger, ::Logger] object to managelogs.
           def initialize(data, person_parser:, attr_map:, dependencies: {}, logger: ::Logger.new(IO::NULL))
-            raise "Constructor needs a PersonParser. Given: #{parser}" if !person_parser.is_a?(Eco::API::Common::People::PersonParser)
-            raise "Expecting Mapper object. Given: #{attr_map}" if attr_map && !attr_map.is_a?(Eco::Data::Mapper)
-
-            @source    = data
-            @person_parser  = person_parser
-            @deps      = dependencies
-            @logger    = logger
-            @attr_map  = attr_map
-            @emap      = PersonEntryAttributeMapper.new(@source, person_parser: @person_parser, attr_map: @attr_map, logger: @logger)
+            msg = "Constructor needs a PersonParser. Given: #{person_parser.class}"
+            raise msg unless person_parser.is_a?(Eco::API::Common::People::PersonParser)
+
+            msg = "Expecting Mapper object. Given: #{attr_map.class}"
+            raise msg if attr_map && !attr_map.is_a?(Eco::Data::Mapper)
+
+            @source        = data
+            @person_parser = person_parser
+            @deps          = dependencies
+            @logger        = logger
+            @attr_map      = attr_map
+            @emap          = PersonEntryAttributeMapper.new(
+              @source,
+              person_parser: @person_parser,
+              attr_map:      @attr_map,
+              logger:        @logger
+            )
 
             if parsing?
               @external_entry     = __external_entry(data)
@@ -39,35 +52,41 @@ module Eco
               @external_entry     = __external_entry(@mapped_entry)
             end
 
-            (print_models; exit(1)) if DEBUG
+            (print_models; exit(1)) if DEBUG # rubocop:disable Style/Semicolon
           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)
+            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
+          def external_entry # rubocop:disable Style/TrivialAccessors
             @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
+          def internal_entry # rubocop:disable Style/TrivialAccessors
             @internal_entry
           end
 
           # @return [Hash] entry `Hash` with **internal** attribute names, but **external** types and values.
-          def mapped_entry
+          def mapped_entry # rubocop:disable Style/TrivialAccessors
             @mapped_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
+          def final_entry # rubocop:disable Style/TrivialAccessors
             @final_entry
           end
 
@@ -173,8 +192,7 @@ module Eco
           # @return [String] string summary of this person identity.
           def to_s(options)
             options = into_a(options)
-            case
-            when options.include?(:identify)
+            if options.include?(:identify)
               identify
             else
               final_entry.each.map do |k, v|
@@ -193,16 +211,11 @@ module Eco
           def set_core(person, exclude: nil)
             scoped_attrs = @emap.core_attrs(@final_entry) - into_a(exclude)
             @final_entry.slice(*scoped_attrs).each do |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
+              set_part(person, attr, value)
+            rescue StandardError => e
+              raise unless attr == "email"
+              logger.error("#{e} - setting blank email instead.")
+              set_part(person, attr, nil)
             end
           end
 
@@ -212,7 +225,7 @@ module Eco
           # @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 = {} unless person.account
             scoped_attrs = @emap.account_attrs(@final_entry) - into_a(exclude)
             @final_entry.slice(*scoped_attrs).each do |attr, value|
               set_part(person.account, attr, value)
@@ -316,7 +329,7 @@ module Eco
             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|
+            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|
@@ -326,12 +339,13 @@ module Eco
 
           # 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.
+          # @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_attrs = @emap.account_attrs(internal_entry) + @emap.core_attrs(internal_entry)
             core_account_hash  = internal_entry.slice(*core_account_attrs).each_with_object({}) do |(attr, value), hash|
-              hash[attr]  = _parse_type(attr, value)
+              hash[attr] = _parse_type(attr, value)
             end
 
             details_attrs     = @emap.details_attrs(internal_entry)
@@ -354,7 +368,7 @@ module Eco
           # @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|
+            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|
@@ -364,7 +378,7 @@ module Eco
               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["Has account?"] = !person.account.nil?
               final_entry.merge(_serialize_values(person, :person))
             end
           end
@@ -387,9 +401,8 @@ module Eco
 
           # Transforms each **typed** value into its `String` version
           def _serialize_type(attr, value, schema: nil)
-            case
-            when !!schema
-              unless field = schema[attr]
+            if !!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
@@ -397,11 +410,11 @@ module Eco
                 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)
+            elsif %w[policy_group_ids filter_tags login_provider_ids starred_ids].include?(attr)
               @person_parser.serialize(:multiple, value)
-            when ["freemium", "accept_eula"].include?(attr)
+            elsif %w[freemium accept_eula].include?(attr)
               @person_parser.serialize(:boolean, value)
-            when ["subordinates"].include?(attr)
+            elsif ["subordinates"].include?(attr)
               @person_parser.serialize(:number, value)
             else
               value
@@ -409,12 +422,11 @@ module Eco
           end
 
           # Transforms each `String` value into its **typed** version
-          def _parse_type(attr, value, schema: nil)
+          def _parse_type(attr, value, schema: nil) # rubocop:disable Metrics/AbcSize
             value = value.strip if value.is_a?(String)
             value = nil         if value.to_s.strip.empty?
-            case
-            when !!schema
-              unless field = schema[attr]
+            if !!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
@@ -423,16 +435,16 @@ module Eco
                 value = @person_parser.parse(field.type.to_sym, value, deps: {"attr" => attr})
               end
               value
-            when attr == "email"
+            elsif attr == "email"
               value = value.strip.downcase if value
               value
-            when ["policy_group_ids", "filter_tags", "login_provider_ids", "starred_ids"].include?(attr)
+            elsif %w[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 = value.compact.map(&:upcase) if attr == "filter_tags"
               value
-            when ["freemium", "accept_eula"].include?(attr)
+            elsif %w[freemium accept_eula].include?(attr)
               @person_parser.parse(:boolean, value)
-            when ["subordinates"].include?(attr)
+            elsif ["subordinates"].include?(attr)
               @person_parser.parse(:number, value)
             else
               value
@@ -442,12 +454,12 @@ module Eco
           # 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
+            sorted_keys = hashes.map(&: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 = yield(merged) if block_given?
             merged
           end
 
@@ -458,7 +470,7 @@ module Eco
           end
 
           def into_a(value)
-            value = [] if value == nil
+            value = [] if value.nil?
             value = [].push(value) unless value.is_a?(Array)
             value
           end
@@ -478,20 +490,19 @@ module Eco
 
           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
-              # add more info to the error
-              raise e.append_message " -- Entry #{to_s(:identify)}"
+
+            case obj
+            when Ecoportal::API::V1::PersonDetails
+              msg = "Field '#{attr}' does not exist in details of schema: '#{obj.schema_id}'"
+              fatal msg unless obj.get_field(attr)
+
+              obj[attr] = value
+            else
+              obj.send("#{attr}=", value)
             end
+          rescue StandardError => e
+            # add more info to the error
+            raise e.append_message " -- Entry #{to_s(:identify)}"
           end
 
           # @return [Hash] `value` if it was a `Hash`, and `{ attr => value}` otherwise
@@ -512,19 +523,19 @@ module Eco
 
           # Function to debug faste
           def print_models
-            print_it = Proc.new do |name, model|
+            print_it = proc 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) }
+            fin = proc { print_it.call("final_entry",    @final_entry)    }
+            int = proc { print_it.call("internal_entry", @internal_entry) }
+            mad = proc { print_it.call("mapped_entry",   @mapped_entry)   }
+            ext = proc { print_it.call("external_entry", @external_entry) }
 
             call_order = parsing? ? [ext, mad, int, fin] : [fin, int, mad, ext]
-            call_order.each {|proc| proc.call}
+            call_order.each(&:call)
           end
         end
       end