eco-helpers 2.6.3 → 2.7.0

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'

data/lib/eco/api/session/batch/job.rb

@@ -93,7 +93,7 @@ module Eco
           end
 
           # Adds an entry(ies) to the job queue.
-          # @param entry [Ecoportal::API::V1::Person, Enumberable<Person>] the person(s) we want to update, carrying the changes to be done.
+          # @param entry [Ecoportal::API::V1::Person, Enumerable<Person>] the person(s) we want to update, carrying the changes to be done.
           # @param unique [Boolean] specifies if repeated entries should be avoided in the queue.
           # @yield [person] callback before launching the batch job request against the server.
           # @yieldparam person [Person] current person object that that should be treated by the callback before launching the batch.

data/lib/eco/api/session/config/tagtree.rb

@@ -8,12 +8,21 @@ module Eco
 
           attr_key :file, :structure_id
 
+          # The location node classifications of the organization
+          # @return [Eco::API::Organization::NodeClassifications]
+          def node_classifications(active: true)
+            return [] unless (graphql = graphql_api)
+
+            node_types = graphql.locationStructure.nodeClassifications(active: active)
+            Eco::API::Organization::NodeClassifications.new(node_types)
+          end
+
           # @note it retrieves the tree this way:
           #   1. If there's a file tagtree.json file, it uses it
           #   2. If no file, retrieves `structure_id` (config)
           # @param include_archived [Boolean] whether or not it should include archived nodes.
           # @return [Eco::API::Organization::TagTree]
-          def scope_tree(enviro: nil, include_archived: true, raise_on_missing: true)
+          def scope_tree(enviro: nil, include_archived: true, raise_on_missing: true) # rubocop:disable Lint/UnusedMethodArgument
             return @tagtree if instance_variable_defined?(:@tagtree) && @tagtree.enviro == enviro
 
             kargs = {
@@ -21,34 +30,34 @@ module Eco
               includeArchivedNodes: include_archived
             }
 
-            if tree_file = self.file
+            if (tree_file = file)
               if (tree = file_manager.load_json(tree_file)) && !tree.empty?
                 @tagtree = Eco::API::Organization::TagTree.new(tree)
               end
-            elsif self.structure_id
-              kargs.merge(id: self.structure_id)
+            elsif structure_id
+              kargs.merge(id: structure_id)
             end
 
-            @tagtree ||= live_tree(**kargs).tap do |tree|
-              unless tree && !tree.empty?
-                msg = "Could not find a local or live locations structure."
-                raise MissingTagtree, msg
-              end
+            @tagtree ||= live_tree(**kargs).tap do |tr| # rubocop:disable Naming/MemoizedInstanceVariableName
+              next if tr && !tr.empty?
+
+              msg = "Could not find a local or live locations structure."
+              raise MissingTagtree, msg
             end
           end
 
           # Among all the locations structures it selects the one with more location nodes
           # If `id` is provided, it only retrieves this locations structure.
           # @param [enviro] used for re-caching
-          def live_tree(id: nil, enviro: nil, include_archived: false, **kargs, &block)
-            existing_cache   = !!@live_tree
+          def live_tree(id: nil, enviro: nil, include_archived: false, **kargs, &block) # rubocop:disable Metrics/AbcSize
+            existing_cache   = !@live_tree.nil?
             first_load       = !existing_cache
 
             target_change    = existing_cache && id     && @live_tree.id != id
             enviro_change    = existing_cache && enviro && @live_tree.enviro != enviro
 
             switching_target = existing_cache && (target_change || enviro_change)
-            refresh_cache    = existing_cache && !switching_target
+            _refresh_cache   = existing_cache && !switching_target
 
             kargs = {
               includeArchivedNodes: include_archived
@@ -59,10 +68,12 @@ module Eco
               @live_tree = live_tree_get(**args, &block)
             else
               trees      = live_trees(**kargs, &block)
-              @live_tree = trees.reject do |tree|
-                tree.empty?
-              end.max do |a,b|
-                a.count <=> b.count
+              if trees.count > 1
+                @live_tree = trees.reject(&:empty?).max do |a, b|
+                  a.count <=> b.count
+                end
+              else
+                @live_tree = trees.first
               end
             end.tap do |tree|
               if tree
@@ -85,8 +96,7 @@ module Eco
           # @param include_archived [Boolean] whether or not to include archived **nodes**
           # @return [Eco::API::Organization::TagTree, NilClass]
           def live_tree_get(id: nil, include_archived: false, **kargs, &block)
-            return nil unless apis.active_api.version_available?(:graphql)
-            return nil unless graphql = apis.api(version: :graphql)
+            return nil unless (graphql = graphql_api)
 
             kargs = {
               id:                   id,
@@ -94,9 +104,11 @@ module Eco
             }.merge(kargs)
 
             start = Time.now
-            return nil unless tree = graphql.currentOrganization.locationStructure(**kargs, &block)
+            tree  = graphql.currentOrganization.locationStructure(**kargs, &block)
+            return nil unless tree
+
             end_time = Time.now
-            secs    = (end_time - start).round(3)
+            secs     = (end_time - start).round(3)
 
             Eco::API::Organization::TagTree.new(tree.treeify, id: tree.id, name: tree.name).tap do |eco_tree|
               cnt     = eco_tree.count
@@ -110,15 +122,16 @@ module Eco
           # @return [Array<Eco::API::Organization::TagTree>]
           def live_trees(include_archived: false, **kargs, &block)
             [].tap do |eco_trees|
-              next unless apis.active_api.version_available?(:graphql)
-              next unless graphql = apis.api(version: :graphql)
+              next unless (graphql = graphql_api)
 
               kargs = {
                 includeArchivedNodes: include_archived
               }.merge(kargs)
 
               start = Time.now
-              next unless trees = graphql.currentOrganization.locationStructures(**kargs, &block)
+              trees = graphql.currentOrganization.locationStructures(**kargs, &block)
+              next unless trees
+
               end_time = Time.now
               secs     = (end_time - start).round(3)
               cnt      = 0
@@ -134,6 +147,11 @@ module Eco
 
           private
 
+          def graphql_api
+            return nil unless apis.active_api.version_available?(:graphql)
+            apis.api(version: :graphql)
+          end
+
           def session
             ASSETS.session
           end