Class: Eco::API::Common::People::PersonEntryAttributeMapper

Inherits:
Object
  • Object
show all
Defined in:
lib/eco/api/common/people/person_entry_attribute_mapper.rb

Constant Summary collapse

@@cached_warnings = 
{}

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(data, person_parser:, attr_map:, logger: ::Logger.new(IO::NULL)) ⇒ PersonEntryAttributeMapper

Note:
  • 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).

Helper class tied to PersonEntry that allows to track which attributes of a person entry are present and how they should be mapped between internal and external names if applicable. This class is meant to help in providing a common interface to access entries of source data that come in different formats.

Parameters:

  • data (Hash, Ecoportal::API::V1::Person) —

    Person object to be serialized or hashed entry to be parsed (note: CSV::Row is accepted).

  • person_parser (Common::People::PersonParser) —

    parser/serializer of person attributes (it contains a set of attribute parsers).

  • attr_map (Eco::Data::Mapper) —

    mapper to translate attribute names from external to internal names and vice versa.

  • logger (Common::Session::Logger, ::Logger) (defaults to: ::Logger.new(IO::NULL)) —

    object to manage logs.



30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
# File 'lib/eco/api/common/people/person_entry_attribute_mapper.rb', line 30

def initialize(data, person_parser:, attr_map:, 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
  @attr_map       = attr_map
  @logger         = logger

  if parsing?
    @external_entry   = data
    init_attr_trackers
  else  # SERIALIZING

    @person          = data
    @internal_attrs  = @person_parser.all_attrs
    @aliased_attrs   = @attr_map.list(:internal)
  end

  @core_attrs    = @person_parser.target_attrs_core(@internal_attrs)
  @details_attrs = @person_parser.target_attrs_details(@internal_attrs)
  @account_attrs = @person_parser.(@internal_attrs)
  @all_attrs     = @core_attrs | @account_attrs | @details_attrs
end

Instance Attribute Details

#account_attrs ⇒ Array<String> (readonly)

account attributes that are present in the person entry.

Returns:

  • (Array<String>) —

    the current value of account_attrs



13
14
15
 
# File 'lib/eco/api/common/people/person_entry_attribute_mapper.rb', line 13

def 
  @account_attrs
end

#aliased_attrs ⇒ Array<String> (readonly)

only those internal attributes present in the person entry that have an internal/external name mapping.

Returns:

  • (Array<String>) —

    the current value of aliased_attrs



13
14
15
 
# File 'lib/eco/api/common/people/person_entry_attribute_mapper.rb', line 13

def aliased_attrs
  @aliased_attrs
end

#all_attrs ⇒ Array<String> (readonly)

all the attrs that are present in the person entry.

Returns:

  • (Array<String>) —

    the current value of all_attrs



13
14
15
 
# File 'lib/eco/api/common/people/person_entry_attribute_mapper.rb', line 13

def all_attrs
  @all_attrs
end

#core_attrs ⇒ Array<String> (readonly)

core attributes that are present in the person entry.

Returns:

  • (Array<String>) —

    the current value of core_attrs



13
14
15
 
# File 'lib/eco/api/common/people/person_entry_attribute_mapper.rb', line 13

def core_attrs
  @core_attrs
end

#details_attrs ⇒ Array<String> (readonly)

schema details attributes that are present in the person entry.

Returns:

  • (Array<String>) —

    the current value of details_attrs



13
14
15
 
# File 'lib/eco/api/common/people/person_entry_attribute_mapper.rb', line 13

def details_attrs
  @details_attrs
end

#direct_attrs ⇒ Array<String> (readonly)

only those internal attributes present in the person entry that do not have an internal/external name mapping.

Returns:

  • (Array<String>) —

    the current value of direct_attrs



13
14
15
 
# File 'lib/eco/api/common/people/person_entry_attribute_mapper.rb', line 13

def direct_attrs
  @direct_attrs
end

#internal_attrs ⇒ Array<String> (readonly)

all the internally named attributes that the person entry has.

Returns:

  • (Array<String>) —

    the current value of internal_attrs



13
14
15
 
# File 'lib/eco/api/common/people/person_entry_attribute_mapper.rb', line 13

def internal_attrs
  @internal_attrs
end

Instance Method Details

#parsing? ⇒ Boolean

To know if currently the object is in parse or serialize mode.

Returns:

  • (Boolean) —

    returns true if we are parsing, false otherwise.



56
57
58
 
# File 'lib/eco/api/common/people/person_entry_attribute_mapper.rb', line 56

def parsing?
  !@source.is_a?(Ecoportal::API::V1::Person)
end

#serializing? ⇒ Boolean

To know if currently the object is in parse or serialize mode.

Returns:

  • (Boolean) —

    returns true if we are serializing, false otherwise.



62
63
64
 
# File 'lib/eco/api/common/people/person_entry_attribute_mapper.rb', line 62

def serializing?
  !parsing?
end

#to_external(value) ⇒ String, ...

Note:
  1. the scope of attributes is based on all the attributes defined in the current entry.
  2. the attributes recognized by the person parser are those of of the Person model (where details attributes depend on the schema).

Serializing helper also used to do a reverse mapping when parsing:

  • as there could be internal attributes that shared external attributes,
  • when parsing, you use this helper to recognize the source external attribute of each internal one. If there no mapper defined for the object, it mirrors value. If there is a mapper defined for the object:
  • if the value exists as internal-, translates it into an _external one.
  • if it doesn't exist, returns nil.

Parameters:

  • value (String, Array<String>) —

    value(s) to be translated or aliased into external ones.

Returns:

  • (String, nil, Array<String] the external name(s) of `value`.) —

    String, nil, Array<String] the external name(s) of value.



116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
 
# File 'lib/eco/api/common/people/person_entry_attribute_mapper.rb', line 116

def to_external(value)
  return value if !@attr_map
  attr = value
  case value
  when Array
    return value.map do |v|
      to_external(v)
    end.compact
  when String
    case
    when @attr_map.internal?(value)
      attr = @attr_map.to_external(value)
    when @attr_map.internal?(value.strip)
      unless cached_warning("internal", "spaces", value)
        logger.warn("The internal person field name '#{value}' contains additional spaces in the reference file")
      end
      attr = @attr_map.to_external(value.strip)
    when @attr_map.external?(value) || @attr_map.external?(value.strip) || @attr_map.external?(value.strip.downcase)
      unless cached_warning("internal", "reversed", value)
        logger.warn("The mapper [external, internal] attribute names may be declared reversedly for INTERNAL attribute: '#{value}'")
      end
    end
  end

  return nil unless !@external_entry || attributes(@external_entry).include?(attr)
  attr
end

#to_internal(value) ⇒ String, ...

Note:
  1. the scope of attributes is based on all the attributes recognized by the person parser.
  2. the attributes recognized by the person parser are those of of the Person model (where details attributes depend on the schema).

If there no mapper defined for the object, it mirrors value. If there is a mapper defined for the object:

  1. if the value exists as external, translates it into an internal one.
  2. if it doesn't exist, returns nil.

Parameters:

  • value (String, Array<String>) —

    value(s) to be translated into internal names.

Returns:

  • (String, nil, Array<String] the internal name(s) of `value`.) —

    String, nil, Array<String] the internal name(s) of value.



75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/eco/api/common/people/person_entry_attribute_mapper.rb', line 75

def to_internal(value)
  # TODO: check PersonEntry#to_internal and #to_external in init_attr_trackers

  # => when attr_map is avoided, it doesn't work as it should

  return value if !@attr_map
  attr = value
  case value
  when Array
    return value.map do |v|
      to_internal(v)
    end.compact
  when String
    case
    when @attr_map.external?(value)
      attr = @attr_map.to_internal(value)
    when @attr_map.external?(value.strip)
      unless cached_warning("external", "spaces", value)
        logger.warn("The external person field name '#{value}' contains additional spaces in the reference file")
      end
      attr = @attr_map.to_internal(value.strip)
    when @attr_map.internal?(value) || @attr_map.internal?(value.strip) || @attr_map.internal?(value.strip.downcase)
      unless cached_warning("external", "reversed", value)
        logger.warn("The mapper [external, internal] attribute names may be declared reversedly for EXTERNAL attribute: '#{value}'")
      end
    end
  end

  return nil unless @person_parser.all_attrs.include?(attr)
end