eco-helpers 2.6.4 → 2.7.1

data/lib/eco/api/error.rb

@@ -10,56 +10,65 @@ module Eco
       end
 
       @str_err = "api error on the server reply"
-      @match  = /.*/
+      @match   = /.*/
       #RxValidId = /[a-f0-9]{24}/
 
-
       class Unclassified < Eco::API::Error
         @str_error = "Unclassified error message"
         @match     = /.*/
       end
 
       class InternalServerError < Eco::API::Error
-        @str_err  = "Internal Server Error"
+        @str_err = "Internal Server Error"
         @match   = /#{@str_err}/
       end
+
       class UnknownPersonId < Eco::API::Error
         @str_err = "Unknown person id"
         @match   = /Cannot find person with id (.*)/
       end
+
       class ExternalIdTaken < Eco::API::Error
-        @str_err  = "external ID already taken"
+        @str_err = "external ID already taken"
         @match   = /#{@str_err}/
       end
+
       class EmailMissing < Eco::API::Error
         @str_err = "missing email for account creation"
         @match   = /#{@str_err}/
       end
+
       class EmailInvalid < Eco::API::Error
         @str_err = "Email is invalid"
         @match   = /#{@str_err}/
       end
+
       class EmailTaken < Eco::API::Error
-        @str_err  = "user email already taken"
-        @str_err2 = "Email is already taken"
-        @match    = /(?:#{@str_err}|#{@str_err2})/
+        @str_err   = "user email already taken"
+        @str_err_2 = "Email is already taken"
+        @match     = /(?:#{@str_err}|#{@str_err_2})/
       end
+
       class SupervisorNotFound < Eco::API::Error
         @str_err = "Supervisor not found"
         @match   = /Supervisor (.*?) not found/
       end
+
       class CyclicSupervisor < Eco::API::Error
         @str_err = "Supervisor is cyclic!"
         @match   = /#{@str_err}/
       end
+
       class SchemaNotFound < Eco::API::Error
         @str_err = "Schema not found"
         @match   = /Schema (.*?) not found/
       end
+
       class InvalidObjectId < Eco::API::Error
         @str_err = "Invalid ObjectId."
         @match   = /'(.*?)' is an invalid ObjectId./
       end
+
       class UnknownField < Eco::API::Error
         @str_err = "Unknown field."
         @match   = /(.+?) is an unknown field/
@@ -68,13 +77,15 @@ module Eco
           @str_err = "Unknown core field."
           @match   = /(.+?) is an unknown field/
         end
+
         class UnknownAccountField < UnknownField
           @str_err = "Unknown account field."
-          @match   = /account \> (.+?) is an unknown field/
+          @match   = /account > (.+?) is an unknown field/
         end
+
         class UnknownDetailsField < UnknownField
           @str_err = "Unknown details field."
-          @match   = /details \> (.+?) is an unknown field/
+          @match   = /details > (.+?) is an unknown field/
         end
       end
 
@@ -82,9 +93,9 @@ module Eco
         def descendants(direct: false)
           ObjectSpace.each_object(::Class).select do |klass|
             klass < self
-          end.sort do |k1, k2|
-            next -1 if k2 < k1
-            next  1 if k1 < k2
+          end.sort do |k_1, k_2|
+            next -1 if k_2 < k_1
+            next  1 if k_1 < k_2
             0
           end.tap do |siblings|
             siblings.delete(Unclassified)
@@ -97,7 +108,7 @@ module Eco
         end
 
         def descendants?(direct: false)
-          descendants(direct: direct).length > 0
+          descendants(direct: direct).length.positive?
         end
 
         def err_match?(err_msg)
@@ -106,15 +117,16 @@ module Eco
 
         def get_type(err_msg, first: true)
           type = nil
+
           descendants(direct: true).reverse.each do |klass|
-            if klass.err_match?(err_msg)
-              type = klass
-              if klass.descendants?(direct: true)
-                type = klass.get_type(err_msg, first: false) || type
-              end
-            end
+            next unless klass.err_match?(err_msg)
+            type = klass
+            next unless klass.descendants?(direct: true)
+            type = klass.get_type(err_msg, first: false) || type
           end
+
           return type unless first
+
           type || Unclassified
         end
 
@@ -138,7 +150,7 @@ module Eco
       end
 
       def built_error
-        str ||= msg
+        msg
       end
     end
   end

data/lib/eco/api/organization/node_classifications.rb

@@ -0,0 +1,82 @@
+module Eco
+  module API
+    module Organization
+      class NodeClassifications < Eco::Language::Models::Collection
+        # build the shortcuts of Collection
+        attr_collection :id, :name # , :active
+
+        def initialize(types = [], klass: Ecoportal::API::GraphQL::Base::LocationClassificationType) # rubocop:disable Lint/UnusedMethodArgument
+          @klass       = Ecoportal::API::GraphQL::Base::LocationClassificationType
+          @caches_init = false
+          super(types, klass: @klass)
+          init_caches
+        end
+
+        def ids
+          @items.map(&:id)
+        end
+
+        def names
+          @items.map(&:name)
+        end
+
+        def to_id(name)
+          case name
+          when Enumerable
+            name.map do |n|
+              type(n)&.id
+            end.compact
+          else
+            type(name)&.id
+          end
+        end
+
+        def to_name(id)
+          case id
+          when Enumerable
+            id.map do |n|
+              type(n)&.name
+            end.compact
+          else
+            type(id)&.name
+          end
+        end
+
+        def type(id_name)
+          self[id_name]
+        end
+
+        def [](id_name)
+          @by_id[type_id(id_name)]
+        end
+
+        private
+
+        def type_name(id_name)
+          key = treat_classication(id_name)
+          val = (@by_id[key] || @by_name[key])&.name
+          treat_classication(val)
+        end
+
+        def type_id(id_name)
+          key = treat_classication(id_name)
+          val = (@by_name[key] || @by_id[key])&.id
+          treat_classication(val)
+        end
+
+        def treat_classication(value)
+          return value unless value.is_a?(String)
+          value.strip.gsub(/\W+/, '').downcase
+        end
+
+        def init_caches
+          return if @caches_init
+
+          @by_id   = @items.to_h { |nc| [treat_classication(nc.id), nc] }
+          @by_name = @items.to_h { |nc| [treat_classication(nc.name), nc] }
+          @caches_init = true
+        end
+      end
+    end
+  end
+end

data/lib/eco/api/organization/policy_groups.rb

@@ -1,7 +1,7 @@
 module Eco
   module API
     module Organization
-      class PolicyGroups <  Eco::Language::Models::Collection
+      class PolicyGroups < Eco::Language::Models::Collection
         # build the shortcuts of Collection
         attr_collection :id, :name
 
@@ -40,7 +40,6 @@ module Eco
           else
             policy_group(id)&.name
           end
-
         end
 
         def policy_group(id_name)
@@ -61,7 +60,7 @@ module Eco
 
           if !non_custom_not_used && preserve_custom
             initial_custom = initial - non_custom
-            final = final + initial_custom
+            final         += initial_custom
           end
 
           new_pg_ids = final - initial
@@ -81,11 +80,10 @@ module Eco
 
         def init_caches
           return if @caches_init
-          @by_id   = self.map { |pg| [pg.id, pg] }.to_h
-          @by_name = self.map { |pg| [pg.name&.downcase, pg] }.to_h
+          @by_id   = map { |pg| [pg.id, pg] }.to_h
+          @by_name = map { |pg| [pg.name&.downcase, pg] }.to_h
           @caches_init = true
         end
-
       end
     end
   end

data/lib/eco/api/organization/tag_tree.rb

@@ -6,23 +6,27 @@ module Eco
       #   This does not allow to capture the `name` and `id` of the locations
       #   structure itself into the json storing model.
       class TagTree
-        HEADER = [
-          'id', 'name', 'weight', 'parent_id',
-          'archived', 'archived_token'
+        HEADER = %w[
+          id name weight parent_id
+          archived archived_token
+          classifications classification_names
+          level
         ].freeze
 
+        include Enumerable
+
+        attr_reader :source
+
         attr_accessor :id
         alias_method :tag, :id
+
         attr_accessor :name, :weight
         attr_accessor :archived, :archived_token
+        attr_accessor :classifications, :classification_names
 
         attr_reader :parent
-        attr_reader :nodes, :children_count
-        attr_reader :depth, :path
-
-        attr_reader :source
-
-        include Enumerable
+        attr_reader :nodes
+        attr_reader :depth
 
         # @example Node format:
         #     {"tag": "NODE NAME", "nodes": subtree}
@@ -34,33 +38,32 @@ module Eco
         #    ]}]
         #    tree = TagTree.new(tree.to_json)
         # @param tagtree [String] representation of the tagtree in json.
-        def initialize(tagtree = [], name: nil, id: nil, depth: -1, path: [], parent: nil, _weight: nil)
-          @depth  = depth
-          @parent = parent
+        def initialize(
+          tagtree = [],
+          name: nil, id: nil,
+          depth: -1, path: [],
+          parent: nil, _weight: nil # rubocop:disable Lint/UnderscorePrefixedVariableName
+        )
 
-          case tagtree
-          when String
-            @source = JSON.parse(tagtree)
-          else
-            @source = tagtree
-          end
-          raise ArgumentError, "You are trying to initialize a TagTree with a null tagtree" if !@source
+          @source = parse_source_input(tagtree)
+
+          msg = "You are trying to initialize a TagTree with a null tagtree"
+          raise ArgumentError, msg unless source
+
+          @parent = parent
+          @depth  = depth
+          @path   = path || []
 
-          if @source.is_a?(Array)
+          if source.is_a?(Array)
             @id        = id
             @name      = name
-            @raw_nodes = @source
+            @raw_nodes = source
           else
-            @id        = @source.values_at('tag', 'id').compact.first&.upcase
-            @name      = @source['name']
-            @archived  = @source['archived'] || false
-            @archived_token   = @source['archived_token']
-            @source['weight'] = @weight = @source['weight'] || _weight
-            @raw_nodes = @source['nodes'] || []
+            source['weight'] ||= _weight
+            init_node
           end
 
-          @path  = path || []
-          @path.push(@id) unless top?
+          self.path.push(self.id) unless top?
 
           @nodes = @raw_nodes.map.with_index do |cnode, idx|
             self.class.new(cnode, depth: depth + 1, path: @path.dup, parent: self, _weight: idx)
@@ -84,18 +87,19 @@ module Eco
         end
 
         # @return [Array] with the differences
-        def diff(tagtree, differences: {}, level: 0, **options)
+        def diff(tagtree, _differences: {}, _level: 0, **options)
           require 'hashdiff'
-          Hashdiff.diff(self.as_json, tagtree.as_json, **options.slice(:array_path, :similarity, :use_lcs))
+          Hashdiff.diff(as_json, tagtree.as_json, **options.slice(:array_path, :similarity, :use_lcs))
         end
 
         # It generates a merged tagtree out of two sources
         # @note it merges the first level nodes (and their children) as it comes
         # @return [Eco::API::Organization::TagTree] result of merging both trees
         def merge(other)
-          raise ArgumentError, "Expecting Eco::API::Organization::TagTree. Given: #{other.class}" unless other.is_a?(Eco::API::Organization::TagTree)
-          mid   = [self.id, other.id].join('|')
-          mname = [self.name, other.name].join('|')
+          msg = "Expecting Eco::API::Organization::TagTree. Given: #{other.class}"
+          raise ArgumentError, msg unless other.is_a?(Eco::API::Organization::TagTree)
+          mid   = [id, other.id].join('|')
+          mname = [name, other.name].join('|')
           self.class.new(as_json | other.as_json, id: mid, name: mname)
         end
 
@@ -187,7 +191,11 @@ module Eco
         # @param include_archived [Boolean] whether it should include archived nodes.
         # @param max_depth [Boolean] up to what level `depth` nodes should be included.
         # @return [Array[Hash]] where `Hash` is a `node` (i.e. `{"tag" => TAG, "nodes": Array[Hash]}`)
-        def as_json(include_children: true, include_archived: true, max_depth: total_depth, &block)
+        def as_json( # rubocop:disable Metrics/AbcSize
+          include_children: true, include_archived: true,
+          max_depth: total_depth,
+          &block
+        )
           max_depth ||= total_depth
           return nil if max_depth < depth
           return []  if top? && !include_children
@@ -202,17 +210,22 @@ module Eco
               max_depth:        max_depth
             }
             children_json = child_nodes.map {|nd| nd.as_json(**kargs, &block)}.compact
-          end
 
-          if top?
-            children_json
-          else
-            values    = [id, name, weight, parent_id, archived, archived_token]
-            node_json = self.class::HEADER.zip(values).to_h
-            node_json["nodes"] = children_json if include_children
-            node_json = yield(node_json, self) if block_given?
-            node_json
+            return children_json if top?
           end
+
+          values = [
+            id,       name,
+            weight,   parent_id,
+            archived, archived_token,
+            classifications.dup,
+            classification_names.dup,
+            depth + 1
+          ]
+          node_json = self.class::HEADER.zip(values).to_h
+          node_json["nodes"] = children_json if include_children
+          node_json = yield(node_json, self) if block_given?
+          node_json
         end
 
         # Returns a plain list form of hash nodes.
@@ -233,11 +246,9 @@ module Eco
 
         # @return [Integer] the highest `depth` of all the children.
         def total_depth
-          @total_depth ||= if has_children?
-              deepest_node = nodes.max_by do |nd|
-                nd.total_depth
-              end
-              deepest_node.total_depth
+          @total_depth ||=
+            if children?
+              nodes.max_by(&:total_depth)&.total_depth
             else
               depth
             end
@@ -245,20 +256,21 @@ module Eco
 
         # @return [Integer] if there's only top level.
         def flat?
-          self.total_depth <= 0
+          total_depth <= 0
         end
 
         # Gets all the tags of the current node tree.
         # @note
         #   - this will include the upper level tag(s) as well
         #   - to get all but the upper level tag(s) use `subtags` method instead
-        # @param depth [Integer] if empty, returns the list of tag nodes of that level. Otherwise the list of tag nodes of the entire subtree.
+        # @param depth [Integer] if empty, returns the list of tag nodes of that level.
+        #   Otherwise the list of tag nodes of the entire subtree.
         # @return [Array<String>]
         def tags(depth: nil)
-          if !depth || depth < 0
+          if !depth || depth&.negative?
             @hash_tags.keys
           else
-            @hash_tags.select do |t, n|
+            @hash_tags.select do |_t, n|
               n.depth == depth
             end.keys
           end
@@ -280,8 +292,8 @@ module Eco
         # Returns all the tags with no children
         # @return [Array<String>]
         def leafs
-          tags.select do |tag|
-            !node(tag).has_children?
+          tags.reject do |tag|
+            node(tag).children?
           end
         end
 
@@ -291,8 +303,8 @@ module Eco
         end
 
         # @return [Boolean] it has subnodes
-        def has_children?
-          children_count > 0
+        def children?
+          children_count&.positive?
         end
 
         # Verifies if a tag exists in the tree.
@@ -314,7 +326,7 @@ module Eco
         # @param list [Array<String>] source tags.
         # @return [Array<String>]
         def filter_tags(list)
-          return [] unless list && list.is_a?(Array)
+          return [] unless list.is_a?(Array)
           list.select {|str| tag?(str)}
         end
 
@@ -324,7 +336,7 @@ module Eco
         # @param key [String] tag to find the path to.
         # @return [Array<String>]
         def path(key = nil)
-          return @path.dup if !key
+          return @path.dup unless key
           @hash_paths[key.upcase].dup
         end
 
@@ -341,24 +353,32 @@ module Eco
         #     original = ["SYDNEY", "RISK"]
         #     final    = ["MELBOURNE", "EVENT"]
         #
-        #     tree.user_tags(initial: original, final: final) # out: ["MELBOURNE", "RISK"]
-        #     tree.user_tags(initial: original, final: final, preserve_custom: false) # out: ["MELBOURNE"]
-        #     tree.user_tags(initial: original, final: final, add_custom: true) # out: ["MELBOURNE", "RISK", "EVENT"]
-        #     tree.user_tags(initial: original, final: final, preserve_custom: false, add_custom: true) # out: ["MELBOURNE", "EVENT"]
+        #     tree.user_tags(initial: original, final: final)
+        #     # out: ["MELBOURNE", "RISK"]
+        #     tree.user_tags(initial: original, final: final, preserve_custom: false)
+        #     # out: ["MELBOURNE"]
+        #     tree.user_tags(initial: original, final: final, add_custom: true)
+        #     # out: ["MELBOURNE", "RISK", "EVENT"]
+        #     tree.user_tags(initial: original, final: final, preserve_custom: false, add_custom: true)
+        #     # out: ["MELBOURNE", "EVENT"]
         #
         # @param initial [Array<String>] original tags a person has in their account.
-        # @param final [Array<String>] target tags the person should have in their account afterwards.
-        # @param preserve_custom  [Boolean] indicates if original tags that are not in the tree should be added/preserved.
-        # @param add_custom [Boolean] indicates if target tags that are not in the tree should be really added.
+        # @param final [Array<String>] target tags the person should have in
+        #   their account afterwards.
+        # @param preserve_custom  [Boolean] indicates if original tags
+        #   that are not in the tree should be added/preserved.
+        # @param add_custom [Boolean] indicates if target tags that are
+        #   not in the tree should be really added.
         # @return [Array<String>] with the treated final tags.
         def user_tags(initial: [], final: [], preserve_custom: true, add_custom: false)
           initial = [initial].flatten.compact
           final   = [final].flatten.compact
           raise "Expected Array for initial: and final:" unless initial.is_a?(Array) && final.is_a?(Array)
-          final    = filter_tags(final) unless add_custom
-          custom   = initial - filter_tags(initial)
-          final    = final + custom     if preserve_custom
-          new_tags = final - initial
+
+          final     = filter_tags(final) unless add_custom
+          custom    = initial - filter_tags(initial)
+          final    |= custom if preserve_custom
+          new_tags  = final - initial
           # keep same order as they where
           (initial & final) + new_tags
         end
@@ -372,52 +392,108 @@ module Eco
         # @param [Array<String>] values list of tags.
         # @return [String] default tag.
         def default_tag(*values)
-          values = filter_tags(values)
-          nodes = []; ddepth = -1
-          values.each do |tag|
-            raise("Couldn't find the node of #{tag} in the tag-tree definition") unless cnode = node(tag)
-
-            if cnode.depth > ddepth
-              nodes = [cnode]
-              ddepth = cnode.depth
-            elsif cnode.depth == ddepth
-              nodes.push(cnode)
+          default_tag    = nil
+          values         = filter_tags(values)
+          tnodes, ddepth = get_deepest_nodes_among_tags(*values)
+
+          unless tnodes.empty?
+            common = tnodes.reduce(tags.reverse) do |com, cnode|
+              com & cnode.path.reverse
             end
+            default_tag = common.first if common.any? && ddepth&.positive?
           end
 
-          default_tag = nil
-          if nodes.length > 1
-            common      = nodes.reduce(self.tags.reverse) {|com, cnode| com & cnode.path.reverse}
-            default_tag = common.first if common.length > 0 && ddepth > 0
-          end
-          default_tag ||= nodes.first&.tag  if (ddepth > 0) || flat?
+          default_tag ||= tnodes.first&.tag if ddepth&.positive? || flat?
           default_tag
         end
 
         protected
 
+        attr_reader :hash_paths
+
         def hash
           @hash_tags
         end
 
-        def hash_paths
-          @hash_paths
+        private
+
+        def parse_source_input(value)
+          return value unless value.is_a?(String)
+          JSON.parse(value)
         end
 
-        private
+        def init_node
+          return if source.is_a?(Array)
+          @id                   = source.values_at('tag', 'id').compact.first&.upcase
+          @name                 = source['name']
+          @weight               = source['weight']
+          @archived             = as_boolean(source['archived'])
+          @archived_token       = source['archived_token']
+          @classifications      = into_a(source['classifications']).map do |value|
+            treat_classication(value)
+          end
+          @classification_names = into_a(source['classification_names'])
+          @raw_nodes            = source['nodes'] || []
+        end
 
         def init_hashes
-          @hash_tags  = {}
+          @hash_tags      = {}
           @hash_tags[@id] = self unless top?
-          @hash_tags = nodes.reduce(@hash_tags) do |h,n|
+          @hash_tags      = nodes.reduce(@hash_tags) do |h, n|
             h.merge(n.hash)
           end
-          @hash_paths = {}
+          @hash_paths      = {}
           @hash_paths[@id] = @path unless top?
-          @hash_paths = nodes.reduce(@hash_paths) do |h,n|
+          @hash_paths      = nodes.reduce(@hash_paths) do |h, n|
             h.merge(n.hash_paths)
           end
         end
+
+        ## Helpers
+        # Gathers the deepest nodes among `values`
+        # @note it will only return multiple nodes if they
+        #   they are all at the same level
+        # @return [Array<Nodes, Integer>]
+        def get_deepest_nodes_among_tags(*values)
+          ddepth = -1
+          tnodes = []
+
+          values.each do |ttag|
+            msg = "Couldn't find the node of #{ttag} in the tag-tree definition"
+            raise msg unless (cnode = node(ttag))
+
+            next                    unless cnode.depth >= ddepth
+            next tnodes.push(cnode) if     cnode.depth == ddepth
+
+            # cnode.depth > ddepth
+            tnodes = [cnode]
+            ddepth = cnode.depth
+          end
+
+          [tnodes, ddepth]
+        end
+
+        def treat_classication(value)
+          return value unless value.is_a?(String)
+          value.strip.gsub(/\W+/, '').downcase
+        end
+
+        # Helper to convert to array
+        def into_a(value)
+          if value.is_a?(String)
+            value.split('|')
+          else
+            [value].flatten
+          end.compact
+        end
+
+        def as_boolean(value)
+          return false if value.nil? || value == false
+          return true  if value == true
+          return false if value.to_s.strip.empty?
+          return true  if %w[yes x true].include?(value.downcase)
+          false
+        end
       end
     end
   end

data/lib/eco/api/organization.rb

@@ -5,6 +5,7 @@ module Eco
   end
 end
 
+require_relative 'organization/node_classifications'
 require_relative 'organization/tag_tree'
 require_relative 'organization/presets_factory'
 require_relative 'organization/preferences'