Class: Eco::API::Common::People::PersonEntry

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

Constant Summary collapse

DEBUG = 
false

Instance Method Summary collapse

Constructor Details

#initialize(data, person_parser:, attr_map:, dependencies: {}, logger: ::Logger.new(IO::NULL)) ⇒ PersonEntry

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).

This class is meant to provide 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 (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.

  • dependencies (Hash) (defaults to: {}) —

    hash where keys are internal attribute names. It is mostly used to deliver final dependencies to attribute parsers/serializers.

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

    object to managelogs.



25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/eco/api/common/people/person_entry.rb', line 25

def initialize(data, person_parser:, attr_map:, dependencies: {}, logger: ::Logger.new(IO::NULL))
  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)
    @mapped_entry       = __mapped_entry(@external_entry)
    @internal_entry     = __internal_entry(@mapped_entry)
    @final_entry        = __final_entry(@internal_entry)
  else  # SERIALIZING
    @person             = data
    @final_entry        = __final_entry(@person)
    @internal_entry     = __internal_entry(@final_entry)
    @mapped_entry       = __mapped_entry(@internal_entry)
    @external_entry     = __external_entry(@mapped_entry)
  end

  (print_models; exit(1)) if DEBUG # rubocop:disable Style/Semicolon
end

Instance Method Details

#default_tag ⇒ Object 



182
183
184
 
# File 'lib/eco/api/common/people/person_entry.rb', line 182

def default_tag
  final_entry["default_tag"]
end

#default_tag? ⇒ Boolean

Returns:

  • (Boolean) 


178
179
180
 
# File 'lib/eco/api/common/people/person_entry.rb', line 178

def default_tag?
  final_entry.key?("default_tag")
end

#email ⇒ String?

Returns the email of this person if defined.

Returns:

  • (String, nil) —

    the email of this person if defined.



141
142
143
 
# File 'lib/eco/api/common/people/person_entry.rb', line 141

def email
  final_entry["email"]
end

#email? ⇒ Boolean

Returns:

  • (Boolean) 


145
146
147
 
# File 'lib/eco/api/common/people/person_entry.rb', line 145

def email?
  final_entry.key?("email")
end

#external_entry ⇒ Hash

Note:

completely serialized entry.

Returns entry Hash with external attribute names, and values and types thereof.

Returns:

  • (Hash) —

    entry Hash with external attribute names, and values and types thereof.



74
75
76
 
# File 'lib/eco/api/common/people/person_entry.rb', line 74

def external_entry # rubocop:disable Style/TrivialAccessors
  @external_entry
end

#external_id ⇒ String?

Returns the external id of this person if defined.

Returns:

  • (String, nil) —

    the external id of this person if defined.



123
124
125
 
# File 'lib/eco/api/common/people/person_entry.rb', line 123

def external_id
  final_entry["external_id"]
end

#external_id? ⇒ Boolean

Returns:

  • (Boolean) 


127
128
129
 
# File 'lib/eco/api/common/people/person_entry.rb', line 127

def external_id?
  final_entry.key?("external_id")
end

#filter_tags ⇒ Object 



162
163
164
 
# File 'lib/eco/api/common/people/person_entry.rb', line 162

def filter_tags
  final_entry["filter_tags"] || []
end

#filter_tags? ⇒ Boolean

Returns:

  • (Boolean) 


166
167
168
 
# File 'lib/eco/api/common/people/person_entry.rb', line 166

def filter_tags?
  final_entry.key?("filter_tags")
end

#final_entry ⇒ Hash

Note:

values ready to be set to a person.

Returns entry Hash with internal attribute names, values and types.

Returns:

  • (Hash) —

    entry Hash with internal attribute names, values and types.



91
92
93
 
# File 'lib/eco/api/common/people/person_entry.rb', line 91

def final_entry # rubocop:disable Style/TrivialAccessors
  @final_entry
end

#id ⇒ String?

Returns the internal id of this person if defined.

Returns:

  • (String, nil) —

    the internal id of this person if defined.



114
115
116
 
# File 'lib/eco/api/common/people/person_entry.rb', line 114

def id
  final_entry["id"]
end

#id? ⇒ Boolean

Returns:

  • (Boolean) 


118
119
120
 
# File 'lib/eco/api/common/people/person_entry.rb', line 118

def id?
  final_entry.key?("id")
end

#identify ⇒ String

Provides a reference to this person entry.

Returns:

  • (String) —

    string summary of this person identity.



188
189
190
191
 
# File 'lib/eco/api/common/people/person_entry.rb', line 188

def identify
  str_id = id ? "id: '#{id}'; " : ""
  "(row: #{idx}) '#{name}' (#{str_id}ext_id: '#{external_id}'; email: '#{email}')"
end

#idx ⇒ Integer

Note:

Eco::API::Common::People::EntryFactory#entries adds this idx (i.e. row number)

Returns the entry number in the input file.

Returns:

  • (Integer) —

    the entry number in the input file



109
110
111
 
# File 'lib/eco/api/common/people/person_entry.rb', line 109

def idx
  final_entry["idx"]
end

#internal_entry ⇒ Hash

Note:

just one step away from being completely parsed (only types parsing pending).

Returns entry Hash with internal attribute names and values, but external types.

Returns:

  • (Hash) —

    entry Hash with internal attribute names and values, but external types.



80
81
82
 
# File 'lib/eco/api/common/people/person_entry.rb', line 80

def internal_entry # rubocop:disable Style/TrivialAccessors
  @internal_entry
end

#mapped_entry ⇒ Hash

Returns entry Hash with internal attribute names, but external types and values.

Returns:

  • (Hash) —

    entry Hash with internal attribute names, but external types and values.



85
86
87
 
# File 'lib/eco/api/common/people/person_entry.rb', line 85

def mapped_entry # rubocop:disable Style/TrivialAccessors
  @mapped_entry
end

#name ⇒ String?

Returns the name of this person if defined.

Returns:

  • (String, nil) —

    the name of this person if defined.



132
133
134
 
# File 'lib/eco/api/common/people/person_entry.rb', line 132

def name
  final_entry["name"]
end

#name? ⇒ Boolean

Returns:

  • (Boolean) 


136
137
138
 
# File 'lib/eco/api/common/people/person_entry.rb', line 136

def name?
  final_entry.key?("name")
end

#new(data) ⇒ PersonEntry

Generates a new entry

Returns:



62
63
64
65
66
67
68
69
70
 
# File 'lib/eco/api/common/people/person_entry.rb', line 62

def new(data)
  self.class.new(
    data,
    person_parser: @person_parser,
    attr_map:      @attr_map,
    dependencies:  @deps,
    logger:        @logger
  )
end

#parsing? ⇒ Boolean

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

Returns:

  • (Boolean) —

    returns true if we are parsing, false otherwise.



97
98
99
 
# File 'lib/eco/api/common/people/person_entry.rb', line 97

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

#policy_group_ids ⇒ Object 



170
171
172
 
# File 'lib/eco/api/common/people/person_entry.rb', line 170

def policy_group_ids
  final_entry["policy_group_ids"] || []
end

#policy_group_ids? ⇒ Boolean

Returns:

  • (Boolean) 


174
175
176
 
# File 'lib/eco/api/common/people/person_entry.rb', line 174

def policy_group_ids?
  final_entry.key?("policy_group_ids")
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.



103
104
105
 
# File 'lib/eco/api/common/people/person_entry.rb', line 103

def serializing?
  !parsing?
end

#set_account(person, exclude: nil) ⇒ Object

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.

Setter to fill in the account properties of the Person that are present in the Entry.

Parameters:

  • person (Ecoportal::API::Internal::Person) —

    the person we want to set the account values to.

  • exclude (String, Array<String>) (defaults to: nil) —

    account properties that should not be set/changed to the person.



230
231
232
233
234
235
236
 
# File 'lib/eco/api/common/people/person_entry.rb', line 230

def (person, exclude: nil)
  person. = {} unless person.
  scoped_attrs = @emap.(@final_entry) - into_a(exclude)
  @final_entry.slice(*scoped_attrs).each do |attr, value|
    set_part(person., attr, value)
  end
end

#set_core(person, exclude: nil) ⇒ Object

Note:
  1. 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.
  2. if there's an incorrect email exception, it blanks the email and logs a warning message

Setter to fill in all the core properties of the Person that are present in the Entry.

Parameters:

  • person (Ecoportal::API::V1::Person) —

    the person we want to set the core values to.

  • exclude (String, Array<String>) (defaults to: nil) —

    core attributes that should not be set/changed to the person.



213
214
215
216
217
218
219
220
221
222
223
 
# File 'lib/eco/api/common/people/person_entry.rb', line 213

def set_core(person, exclude: nil)
  scoped_attrs  = @emap.core_attrs(@final_entry) - into_a(exclude)
  scoped_attrs -= ['id']
  @final_entry.slice(*scoped_attrs).each do |attr, value|
    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

#set_details(person, exclude: nil) ⇒ Object

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.

TO DO: use person.details.schema_id to switch @emap and @person_parser (or just crash if they don't match?) Setter to fill in all the schema details fields of the Person that are present in the Entry.

Parameters:

  • person (Ecoportal::API::V1::Person) —

    the person we want to set the schema fields' values to.

  • exclude (String, Array<String>) (defaults to: nil) —

    schema field attributes that should not be set/changed to the person.



244
245
246
247
248
249
250
 
# File 'lib/eco/api/common/people/person_entry.rb', line 244

def set_details(person, exclude: nil)
  person.add_details(@person_parser.schema) if !person.details || !person.details.schema_id
  scoped_attrs = @emap.details_attrs(@final_entry) - into_a(exclude)
  @final_entry.slice(*scoped_attrs).each do |attr, value|
    set_part(person.details, attr, value)
  end
end

#supervisor_id ⇒ String?

Returns the supervisor id of this person if defined.

Returns:

  • (String, nil) —

    the supervisor id of this person if defined.



150
151
152
 
# File 'lib/eco/api/common/people/person_entry.rb', line 150

def supervisor_id
  final_entry["supervisor_id"]
end

#supervisor_id=(value) ⇒ Object 



154
155
156
 
# File 'lib/eco/api/common/people/person_entry.rb', line 154

def supervisor_id=(value)
  final_entry["supervisor_id"] = value
end

#supervisor_id? ⇒ Boolean

Returns:

  • (Boolean) 


158
159
160
 
# File 'lib/eco/api/common/people/person_entry.rb', line 158

def supervisor_id?
  final_entry.key?("supervisor_id")
end

#to_s(options) ⇒ String

Provides a reference of this person entry.

Returns:

  • (String) —

    string summary of this person identity.



195
196
197
198
199
200
201
202
203
204
 
# File 'lib/eco/api/common/people/person_entry.rb', line 195

def to_s(options)
  options = into_a(options)
  if options.include?(:identify)
    identify
  else
    final_entry.each.map do |k, v|
      "'#{k}': '#{v.to_json}'"
    end.join(" | ")
  end
end