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 manage logs.



18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
# File 'lib/eco/api/common/people/person_entry.rb', line 18

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)

  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
end

Instance Method Details

#default_tag ⇒ Object 



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

def default_tag
  final_entry["default_tag"]
end

#default_tag? ⇒ Boolean

Returns:

  • (Boolean) 


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

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.



120
121
122
 
# File 'lib/eco/api/common/people/person_entry.rb', line 120

def email
  final_entry["email"]
end

#email? ⇒ Boolean

Returns:

  • (Boolean) 


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

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.



53
54
55
 
# File 'lib/eco/api/common/people/person_entry.rb', line 53

def external_entry
  @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.



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

def external_id
  final_entry["external_id"]
end

#external_id? ⇒ Boolean

Returns:

  • (Boolean) 


106
107
108
 
# File 'lib/eco/api/common/people/person_entry.rb', line 106

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

#filter_tags ⇒ Object 



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

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

#filter_tags? ⇒ Boolean

Returns:

  • (Boolean) 


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

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.



70
71
72
 
# File 'lib/eco/api/common/people/person_entry.rb', line 70

def final_entry
  @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.



93
94
95
 
# File 'lib/eco/api/common/people/person_entry.rb', line 93

def id
  final_entry["id"]
end

#id? ⇒ Boolean

Returns:

  • (Boolean) 


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

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

#identify ⇒ String

Provides a reference to this person entry.

Returns:

  • (String) —

    string summary of this person identity.



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

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



88
89
90
 
# File 'lib/eco/api/common/people/person_entry.rb', line 88

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.



59
60
61
 
# File 'lib/eco/api/common/people/person_entry.rb', line 59

def internal_entry
  @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.



64
65
66
 
# File 'lib/eco/api/common/people/person_entry.rb', line 64

def mapped_entry
  @mapped_entry
end

#name ⇒ String?

Returns the name of this person if defined.

Returns:

  • (String, nil) —

    the name of this person if defined.



111
112
113
 
# File 'lib/eco/api/common/people/person_entry.rb', line 111

def name
  final_entry["name"]
end

#name? ⇒ Boolean

Returns:

  • (Boolean) 


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

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

#new(data) ⇒ PersonEntry

Generates a new entry

Returns:



47
48
49
 
# File 'lib/eco/api/common/people/person_entry.rb', line 47

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.



76
77
78
 
# File 'lib/eco/api/common/people/person_entry.rb', line 76

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

#policy_group_ids ⇒ Object 



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

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

#policy_group_ids? ⇒ Boolean

Returns:

  • (Boolean) 


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

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.



82
83
84
 
# File 'lib/eco/api/common/people/person_entry.rb', line 82

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.



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

def (person, exclude: nil)
  person. = {} if !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.



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

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



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

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.



129
130
131
 
# File 'lib/eco/api/common/people/person_entry.rb', line 129

def supervisor_id
  final_entry["supervisor_id"]
end

#supervisor_id=(value) ⇒ Object 



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

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

#supervisor_id? ⇒ Boolean

Returns:

  • (Boolean) 


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

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.



174
175
176
177
178
179
180
181
182
183
184
 
# File 'lib/eco/api/common/people/person_entry.rb', line 174

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