eco-helpers 0.6.0

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

@@ -0,0 +1,380 @@
+module Eco
+  module API
+    module Common
+      module People
+        class PersonEntry
+          @@cached_warnings = {}
+
+          def initialize(data, parser:, mapper:, dependencies: {}, logger: ::Logger.new(IO::NULL))
+            raise "Constructor needs a PersonParser. Given: #{parser}" if !parser.is_a?(Eco::API::Common::People::PersonParser)
+            raise "Expecting Mapper object. Given: #{mapper}" if mapper && !mapper.is_a?(Eco::Data::Mapper)
+
+            @source  = data
+            @parser  = parser
+            @mapper  = mapper
+            @deps    = dependencies
+            @logger  = logger
+
+            if parsing?
+              # PARSING
+              @raw_entry = data
+              init_attr_trackers
+              @aliased_entry = mapped_entry(@raw_entry)
+              @int_row       = internal_entry(@aliased_entry)
+
+              # internally named attrs scoped by mapper and parser against the current row
+              @int_attrs   = @int_row.keys
+            else
+              # SERIALIZING
+              @person     = data
+              @int_row    = internal_entry(@person)
+              @aliased_entry = mapped_entry(@int_row)
+              @int_attrs  = @parser.all_attrs
+            end
+
+            @core_attrs    = @parser.target_attrs_core(@int_attrs)
+            @details_attrs = @parser.target_attrs_details(@int_attrs)
+            @account_attrs = @parser.target_attrs_account(@int_attrs)
+          end
+
+          def parsing?
+            !is_person?(@source)
+          end
+
+          def serializing?
+            !parsing?
+          end
+
+          # SHORTCUTS
+
+          def id
+            @int_row["id"]
+          end
+
+          def external_id
+            @int_row["external_id"]
+          end
+
+          def name
+            @int_row["name"]
+          end
+
+          def email
+            @int_row["email"]
+          end
+
+          def supervisor_id
+            @int_row["supervisor_id"]
+          end
+
+          def supervisor_id=(value)
+            @int_row["supervisor_id"] = value
+          end
+
+          def to_s(options)
+            options = into_a(options)
+            case
+            when options.include?(:identify)
+              "'#{name}' ('#{external_id}': '#{email}')"
+            else
+              @int_row.each.map do |k, v|
+                "'#{k}': '#{v.to_json}'"
+              end.join(" | ")
+            end
+          end
+
+          # SETTERS
+          def set_core(person, exclude: nil)
+            scoped_attrs = @core_attrs - into_a(exclude)
+            @int_row.slice(*scoped_attrs).each do |attr, value|
+              set_to_core(person, attr, value)
+            end
+          end
+
+          def set_details(person, exclude: nil)
+            person.add_details(@parser.schema) if !person.details || !person.details.schema_id
+            scoped_attrs = @details_attrs - into_a(exclude)
+            @int_row.slice(*scoped_attrs).each do |attr, value|
+              set_to_details(person, attr, value)
+            end
+          end
+
+          def set_account(person, exclude: nil)
+            person.account = {} if !person.account
+            person.account.permissions_preset = nil unless person.account.permissions_preset = "custom"
+            scoped_attrs = @account_attrs - into_a(exclude)
+            @int_row.slice(*scoped_attrs).each do |attr, value|
+              set_to_account(person, attr, value)
+            end
+          end
+
+          # GETTERS
+          def entry(klass: nil)
+            return klass.new(to_hash) if klass
+            to_hash
+          end
+
+          def to_hash
+            @aliased_entry.each.map do |int_attr, v|
+              [to_external(int_attr), v || ""] if to_external(int_attr)
+            end.compact.to_h
+          end
+
+          private
+
+          def set_to_core  (person, attr, value)
+            value = value&.downcase if attr == "email"
+            person.send("#{attr}=", value&.strip)
+          end
+
+          def set_to_account (person, attr, value)
+            return if !person.account
+            multiple = ["policy_group_ids", "filter_tags"].include?(attr)
+            if multiple
+              value = @parser.parse(:multiple, value)
+              value = value.map { |v| v&.upcase } if attr == "filter_tags"
+              # preserve previous order
+              current = into_a(person.account.send(attr))
+              value = (current & value) + (value - current)
+            end
+
+            person.account.send("#{attr}=", value)
+          end
+
+          def set_to_details (person, attr, value)
+            return if !person.details
+            field = person.details.get_field(attr)
+            fatal("Field '#{attr}' does not exist in details of schema: '#{person.details.schema_id}'") if !field
+            value = @parser.parse(:multiple, value) if field.multiple
+
+            if @parser.defined?(field.type.to_sym)
+              value = @parser.parse(field.type.to_sym, value, deps: {"attr" => attr})
+            end
+
+            person.details[attr] = value
+          end
+
+          def get_from_core  (person, attr)
+            person.send(attr)
+          end
+
+          def get_from_account (person, attr)
+            return "-" if !person.account
+            multiple = ["policy_group_ids", "filter_tags"].include?(attr)
+            value = person.account.send(attr)
+            @parser.serialize(:multiple, value) if multiple
+          end
+
+          def get_from_details (person, attr)
+            return "-" if !person.details || !person&.details&.schema_id
+            field = person.details.get_field(attr)
+            fatal("Field '#{attr}' does not exist in details of schema: '#{person.details.schema_id}'") if !field
+            value = person.details[attr]
+            value = @parser.serialize(:date, value) if field.type == "date"
+            value = @parser.serialize(:multiple, value) if field.multiple
+            value
+          end
+
+          # INIT
+
+          # when parsing:
+          def init_attr_trackers
+            # internal <-> external attributes
+            int_aliased    = @parser.all_attrs.select  { |attr| to_external(attr) }
+            ext_alias      = int_aliased.map { |attr| to_external(attr) }
+
+            # virtual attrs (non native internal attr that require aliasing):
+            ext_vi_aliased = attributes(@raw_entry).select do |attr|
+              !ext_alias.include?(attr) && @mapper.external?(attr)
+            end
+
+            int_vi_aliased = ext_vi_aliased.map { |attr| @mapper.to_internal(attr) }
+            @aliased_attrs = int_aliased + int_vi_aliased
+
+            int_unlinked   = @parser.undefined_attrs.select { |attr| !to_external(attr) }
+            # those with parser or alias:
+            int_linked     = @parser.all_attrs - int_unlinked
+
+            ext_aliased    = ext_alias + ext_vi_aliased
+            # those that are direct external to internal:
+            ext_direct     = attributes(@raw_entry) - ext_aliased
+            # to avoid collisions between internal names:
+            @direct_attrs  = ext_direct - int_linked
+          end
+
+          # MAPPED ENTRY (when and where applicable)
+          # return entry with internal names and external values
+          def mapped_entry(data)
+            return aliased_entry(data) if parsing?
+            serialized_entry(data)
+          end
+
+          # parse: here we aliase attribute names
+          def aliased_entry(raw_data)
+            aliased_hash = @aliased_attrs.map do |attr|
+              [attr, raw_data[to_external(attr)]]
+            end.to_h
+
+            direct_hash = @direct_attrs.map do |attr|
+              [attr, raw_data[attr]]
+            end.to_h
+
+            aliased_hash.merge!(direct_hash)
+          end
+
+          def hash_attr(attr, value)
+            return value if value.is_a?(Hash)
+            { attr => value }
+          end
+
+          # serializing: run serializers (overrides existing keys)
+          def serialized_entry(unserialized_entry)
+            serial_attrs = @parser.defined_attrs.reduce({}) do |serial_hash, attr|
+              deps = @deps[attr] || {}
+              serial_attr = @parser.serialize(attr, @person, deps: deps)
+              serial_hash.merge(hash_attr(attr, serial_attr))
+            end
+            unserialized_entry.merge(serial_attrs)
+          end
+
+          # returns entry with interal names and values
+          def internal_entry(data)
+            return parsed_entry(data) if parsing?
+            unserialized_entry(data)
+          end
+
+          # parse: to internal entry (parse values)
+          def parsed_entry(aliased_entry)
+            parsed = @parser.defined_attrs.map do |attr|
+              value = @parser.parse(attr, aliased_entry)
+              [attr, value]
+            end.to_h
+            aliased_entry.merge(parsed)
+          end
+
+          # serializing: to internal entry (create the internal entry out of a person)
+          def unserialized_entry(person)
+            core_hash = @parser.target_attrs_core.reduce({}) do |hash, attr|
+              value = get_from_core(person, attr)
+              hash.merge(hash_attr(attr, value))
+            end
+
+            details_hash = @parser.target_attrs_details.reduce({}) do |hash, attr|
+              value = get_from_details(person, attr)
+              hash.merge(hash_attr(attr, value))
+            end
+
+            account_hash = @parser.target_attrs_account.reduce({}) do |hash, attr|
+              value = get_from_account(person, attr)
+              hash.merge(hash_attr(attr, value))
+            end
+
+            details_hash.merge(account_hash).merge(core_hash)
+            #core_hash.merge(account_hash).merge(details_hash)
+          end
+
+
+          def to_internal(value)
+            return value if !@mapper
+            attr = value
+            case value
+            when Array
+              return value.map do |v|
+                to_internal(v)
+              end.compact
+            when String
+              case
+              when @mapper.external?(value)
+                attr = @mapper.to_internal(value)
+              when @mapper.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 = @mapper.to_internal(value.strip)
+              when @mapper.internal?(value) || @mapper.internal?(value.strip) || @mapper.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 @parser.all_attrs.include?(attr)
+          end
+
+          def to_external(value)
+            return value if !@mapper
+            attr = value
+            case value
+            when Array
+              return value.map do |v|
+                to_external(v)
+              end.compact
+            when String
+              case
+              when @mapper.internal?(value)
+                attr = @mapper.to_external(value)
+              when @mapper.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 = @mapper.to_external(value.strip)
+              when @mapper.external?(value) || @mapper.external?(value.strip) || @mapper.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 !@raw_entry || attributes(@raw_entry).include?(attr)
+            attr
+          end
+
+          # LOGGER
+          def logger
+            @logger || ::Logger.new(IO::NULL)
+          end
+
+          def cached_warning(*args)
+            unless exists = !!@@cached_warnings.dig(*args)
+              args.reduce(@@cached_warnings) do |cache, level|
+                cache[level] = {} if !cache.key?(level)
+                cache[level]
+              end
+            end
+            exists
+          end
+
+          def fatal(msg)
+            logger.fatal(msg)
+            exit
+          end
+
+          # HELPERS
+          def into_a(value)
+            value = [] if value == nil
+            value = [].push(value) unless value.is_a?(Array)
+            value
+          end
+
+          def attributes(value)
+            case value
+            when CSV::Row
+              value&.headers
+            when Hash
+              value&.keys
+            when PersonEntry
+              @parser.target_attrs_core
+            else
+              []
+            end
+          end
+
+          def is_person?(value)
+            value.is_a?(Ecoportal::API::Internal::Person)
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+module Eco
+  module API
+    module Common
+      module People
+        class PersonFactory
+
+          include Common::People
+
+          attr_reader :schema_attrs
+
+          def initialize(person: {}, schema: {}, account: {}, modifier: Common::People::PersonModifier.new)
+            @modifier = Common::People::PersonModifier.new(modifier)
+            @person = person
+            @account = account
+            @schema = schema
+            @schema_attrs = @schema&.fields&.map { |fld| fld.alt_id }
+          end
+
+          def new(person: nil)
+            in_raw_modifier = Common::People::PersonModifier.new.no_details
+            return PersonFactory.new(person: person, schema: @schema, modifier: in_raw_modifier).new unless !person
+            person = klass.new(person_hash(@person))
+            person.account = account_hash(@account) if @modifier.add_account? && @modifier.internal?
+            person.details = details_hash(@schema) unless @modifier.no_details?
+            person
+          end
+
+          def new_contact(schema)
+            factory = self.class.new(@modifier.reset_account, person: @person, schema: @schema, account: @account)
+            factory.new
+          end
+
+          def new_doc
+            new_hash(@modifier)
+          end
+
+          def schema_id
+            nil if !@schema
+            @schema['schema_id'] || @schema['id']
+          end
+
+          private
+
+          def klass
+            if @modifier.external?
+              EXTERNAL::Person
+            else
+              INTERNAL::Person
+            end
+          end
+
+          def new_hash(modifier)
+            modifier = Common::People::PersonModifier.new(modifier)
+            doc = person_hash(@person)
+            doc = add_account(doc, @account) if modifier.add_account? && modifier.internal?
+            doc = add_details(doc, @schema) unless modifier.no_details?
+          end
+
+          def add_details(doc, details)
+            return nil if !doc
+            doc_det = details_hash(details)
+            doc.merge({ "details" => doc_det })
+          end
+
+          def add_account(doc, account)
+            return nil if !doc
+            doc_acc = account_hash(account)
+            doc.merge({ "account" => doc_acc })
+          end
+
+          def person_hash(person)
+            case
+            when is_person?(person)
+              JSON.parse(person.doc.to_json)
+            when person.is_a?(Hash)
+              JSON.parse(person.to_json)
+            else
+              {}
+            end
+          end
+
+          def details_hash(details)
+            case
+            when details.is_a?(EXTERNAL::PersonDetails)
+              doc = JSON.parse(details.doc.to_json)
+            when details.is_a?(EXTERNAL::PersonSchema)
+              doc =JSON.parse(details.doc.to_json)
+            when details.is_a?(Hash)
+              doc = JSON.parse(details.to_json)
+              doc = doc["details"] if doc.key?("details")
+            else
+              doc = {}
+            end
+            doc["schema_id"] = doc.delete("id") if doc&.key?("id")
+            doc
+          end
+
+          def account_hash(account)
+            case
+            when account.is_a?(INTERNAL::Account)
+              JSON.parse(account.doc.to_json)
+            when account.is_a?(Hash)
+              doc = JSON.parse(account.to_json)
+              doc["account"] if doc.key?("account")
+            else
+              {}
+            end
+          end
+
+        end
+      end
+    end
+  end
+end