eco-helpers 2.1.12 → 2.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 335e1112db6baee9a3ddfa8ebe5bf66d6bd257c91c5c09808182683b07b7f408
-  data.tar.gz: e0b69526d52606752bb27c80f16534a8eb2cd3ae8e334cfe2576d71b37be596f
+  metadata.gz: 9786a6c42a701c7c84fc751543cd341587f637315c48febc00f85bbb948391c3
+  data.tar.gz: aec51b6308d345fa529acfb26db56178d09ac7397d25d7c323bc6904c793fdad
 SHA512:
-  metadata.gz: c07bd1e0009ce543d7f479a2bf5e21eada3b59e8e2a8e79c65b265b97fbd5c2a7a196f7ef6cd8ed8a8a979ea9ac7b59c29f986d16edac25b113369ece6bedcf9
-  data.tar.gz: c8e042cd62c67ad78db3f7cb2771c394142e471ca49b8dcf43351df4fa9b60f01e4f49df956775e0d842ddff7fea7cf6bc8d5fb309ac2f3c002ca06306dec361
+  metadata.gz: 246d8b86360b5c5a949b85d74ca2829350c206617a7ed39f071c0d853a04cc4cba40b0298897f81de8970e76d92c8b8c995dd79ccbd1748dff8c0201f4eef961
+  data.tar.gz: 4468a3e61ec3f5cc661fc42189f00ef676e4e99a7fb9a2adbd85eef40597f1c2787007b55d4cd14170de09cadcad7824b657ad005bab5efb4b6998073360e7e4

data/CHANGELOG.md

@@ -1,13 +1,29 @@
 # Change Log
 All notable changes to this project will be documented in this file.
 
-## [2.1.13] - 2022-11-xx
+## [2.2.3] - 2023-02-xx
 
 ### Added
 ### Changed
 ### Fixed
-  - `Eco::API::Session::Batch::Errors#str` remove double up on error message
-  - wrong require
+
+## [2.2.2] - 2023-02-27
+
+### Fixed
+  - Typo in GraphQL client (`locationsStructures` should read `locationStructures`)
+  - Multiple typos in new code
+
+## [2.2.1] - 2023-02-24
+
+### Added
+  - `Ecoportal::API::V1::Person#contractor_organization_id`
+  - **Support** for **Reporting Structures** (breaking change)
+  - `Eco::API::UseCases::DefaultCases::CsvToTree` use case to generate tree json out of a csv
+    - The output file can be fed to `Eco::API::Organization::TagTree`
+
+### Changed
+  - **Patch** `Ecoportal::API::V1::Person::VALID_TAG_REGEX` it now allows for dot `.`
+  - update gem dependencies
 
 ## [2.1.12] - 2022-11-30
 

data/eco-helpers.gemspec

@@ -31,8 +31,8 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "redcarpet", ">= 3.5.1",  "< 3.6"
 
   spec.add_dependency 'ecoportal-api', '>= 0.8.5', '< 0.9'
-  spec.add_dependency 'ecoportal-api-v2', '>= 0.9.7', '< 0.10'
-  spec.add_dependency 'ecoportal-api-graphql', '>= 0.1.11', '< 0.2'
+  spec.add_dependency 'ecoportal-api-v2', '>= 1.0.1', '< 1.1'
+  spec.add_dependency 'ecoportal-api-graphql', '>= 0.2.3', '< 0.3'
   spec.add_dependency 'aws-sdk-s3',    '>= 1.83.0', '< 2'
   spec.add_dependency 'aws-sdk-ses',   '>= 1.36.0', '< 2'
   spec.add_dependency 'dotenv',        '>= 2.7.6', '< 2.8'

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

@@ -13,7 +13,7 @@ module Eco
           autoloads_children_of     "Eco::API::Common::Loaders::Parser"
           autoload_namespace_ignore "Eco::API"
 
-          CORE_ATTRS    = ["id", "external_id", "email", "name", "supervisor_id", "filter_tags", "freemium"]
+          CORE_ATTRS    = ["id", "external_id", "email", "name", "supervisor_id", "filter_tags", "contractor_organization_id", "freemium"]
           ACCOUNT_ATTRS = ["policy_group_ids", "default_tag", "send_invites", "landing_page_id", "login_provider_ids"]
           TYPE          = [:select, :text, :date, :number, :phone_number, :boolean, :multiple]
           FORMAT        = [:csv, :xml, :json, :xls]

data/lib/eco/api/common/version_patches/ecoportal_api/external_person.rb

@@ -3,6 +3,17 @@ module Ecoportal
     class V1
       # @attr entry [Eco::API::Common::People::PersonEntry, Hash] the input entry plain hash data used to update/create this person.
       class Person
+        class << self
+          def redef_without_warning(const, value)
+            self.class.send(:remove_const, const) if self.class.const_defined?(const)
+            self.class.const_set(const, value)
+          end
+        end
+
+        redef_without_warning('VALID_TAG_REGEX', /^[A-Za-z0-9 &_'\/.-]+$/)
+
+        passthrough :contractor_organization_id
+
         attr_accessor :entry
 
         def identify(section = :person)
@@ -13,7 +24,6 @@ module Ecoportal
             "'#{name}' (#{str_id}ext_id: '#{external_id}'; email: '#{email}')"
           end
         end
-
       end
     end
   end

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

@@ -1,10 +1,13 @@
 module Eco
   module API
     module Organization
-
       # Provides helpers to deal with tagtrees.
       class TagTree
-        attr_reader :tag, :nodes, :children_count
+        attr_accessor :id
+        alias_method :tag, :id
+        attr_accessor :name
+
+        attr_reader :nodes, :children_count
         attr_reader :depth, :path
         attr_reader :enviro
 
@@ -18,7 +21,7 @@ module Eco
         #    ]}]
         #    tree = TagTree.new(tree.to_json)
         # @param tagtree [String] representation of the tagtree in json.
-        def initialize(tagtree = [], depth: -1, path: [], enviro: nil)
+        def initialize(tagtree = [], name: nil, id: nil, depth: -1, path: [], enviro: nil)
           case tagtree
           when String
             @source = JSON.parse(tagtree)
@@ -30,23 +33,27 @@ module Eco
           @enviro = enviro
 
           @depth = depth
-          @tag = @source.is_a?(Array) ? nil : @source.dig('tag')&.upcase
+          if @source.is_a?(Array)
+            @id    = id
+            @name  = name
+            @nodes = @source
+          else
+            @id    = @source.values_at('tag', 'id').compact.first&.upcase
+            @name  = @source['name']
+            @nodes = @source['nodes'] || []
+          end
 
           @path  = path || []
-          @path.push(@tag) unless !@tag
+          @path.push(@id) unless top?
 
-          nodes = @source.is_a?(Array) ? @source : @source.dig('nodes') || []
-          @nodes = nodes.map {|cnode| TagTree.new(cnode, depth: @depth + 1, path: @path.dup, enviro: @enviro)}
+          @nodes = nodes.map do |cnode|
+            TagTree.new(cnode, depth: @depth + 1, path: @path.dup, enviro: @enviro)
+          end
           @children_count = @nodes.count
 
           init_hashes
         end
 
-        # Updates the tag of the current tree
-        def tag=(value)
-          @tag = value
-        end
-
         # @return [Eco::API::Organization::TagTree]
         def dup
           self.class.new(as_json)
@@ -69,7 +76,7 @@ module Eco
             nodes_json
           else
             {
-              "tag"   => tag,
+              "id"    => tag,
               "nodes" => nodes_json
             }
           end
@@ -77,7 +84,12 @@ module Eco
 
         # @return [Boolean] `true` if there are tags in the node, `false` otherwise.
         def empty?
-          @has_tags.empty?
+          @hash_tags.empty?
+        end
+
+        # @return [Integer] the number of locations
+        def count
+          @hash_tags.keys.count
         end
 
         # @return [Integer] the highest `depth` of all the children.
@@ -245,12 +257,12 @@ module Eco
 
         def init_hashes
           @hash_tags  = {}
-          @hash_tags[@tag] = self unless !@tag
+          @hash_tags[@id] = self unless top?
           @hash_tags = @nodes.reduce(@hash_tags) do |h,n|
             h.merge(n.hash)
           end
           @hash_paths = {}
-          @hash_paths[@tag] = @path
+          @hash_paths[@id] = @path unless top?
           @hash_paths = @nodes.reduce(@hash_paths) do |h,n|
             h.merge(n.hash_paths)
           end
@@ -266,9 +278,7 @@ module Eco
           raise msg if !@enviro
           @enviro.logger.warn(msg)
         end
-
       end
-
     end
   end
 end

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

@@ -3,14 +3,41 @@ module Eco
     class Session
       class Config
         class BaseConfig < Hash
-          
           attr_reader :config
 
+          class << self
+            def attr_key(*attrs)
+              attrs.each do |attr|
+                method = "#{attr}".freeze
+                if self.instance_methods.include?(method.to_sym)
+                  puts "WARNING (#{self}): redefining method already defined '#{method}'."
+                end
+
+                define_method method do
+                  self[method]
+                end
+
+                define_method "#{method}=" do |value|
+                  self[method] = value
+                end
+              end
+              self
+            end
+          end
+
           def initialize(config:)
             super(nil)
             @config = config
           end
 
+          def file_manager
+            config.file_manager
+          end
+
+          def apis
+            config.apis
+          end
+
           def clone(config:)
             keys.each_with_object(self.class.new(config: config)) do |key, cnf|
               begin
@@ -24,7 +51,6 @@ module Eco
               end
             end
           end
-
         end
       end
     end

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

@@ -24,13 +24,7 @@ module Eco
             self["dir"]
           end
 
-          def timestamp_pattern=(pattern)
-            self["timestamp_pattern"] = pattern
-          end
-
-          def timestamp_pattern
-            self["timestamp_pattern"]
-          end
+          attr_key :timestamp_pattern
 
           def add_validation(format)
             raise "Block must be given" unless block_given?

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

@@ -3,47 +3,12 @@ module Eco
     class Session
       class Config
         class Logger < BaseConfig
-
-          def console_level=(value)
-            self["console_level"] = value
-          end
-
-          def console_level
-            self["console_level"]
-          end
-
-          def file_level=(value)
-            self["file_level"] = value
-          end
-
-          def file_level
-            self["file_level"]
-          end
-
-          def file=(file)
-            self["file"] = file
-          end
-
-          def file
-            self["file"]
-          end
-
-          def timestamp_console=(value)
-            self["timestamp_console"] = value
-          end
-
-          def timestamp_console
-            self["timestamp_console"]
-          end
-
-          def log_connection=(value)
-            self["log_connection"] = !!value
-          end
+          attr_key :console_level, :file_level, :file
+          attr_key :timestamp_console, :log_connection
 
           def log_connection?
-            self["log_connection"]
+            !!log_connection
           end
-
         end
       end
     end

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

@@ -3,71 +3,14 @@ module Eco
     class Session
       class Config
         class Mailer < BaseConfig
+          attr_key :access_key_id, :secret_access_key
+          attr_key :region, :server, :message_id_domain
+          attr_key :to, :from
 
           def configured?
             required = access_key_id && secret_access_key && region
             !!required
           end
-
-          def to=(value)
-            self["to"] = value
-          end
-
-          def to
-            self["to"]
-          end
-
-          def from=(value)
-            self["from"] = value
-          end
-
-          def from
-            self["from"]
-          end
-
-          def access_key_id=(key)
-            self["access_key_id"] = key
-          end
-
-          def access_key_id
-            self["access_key_id"]
-          end
-
-          def secret_access_key=(key)
-            self["secret_access_key"] = key
-          end
-
-          def secret_access_key
-            self["secret_access_key"]
-          end
-
-          # AWS::SES::Client
-          def region=(region)
-            self["region"] = region
-          end
-
-          def region
-            self["region"]
-          end
-
-          # AWS::SES::Base
-          def server=(domain)
-            self["server"] = domain
-          end
-
-          def server
-            self["server"]
-          end
-
-          # AWS::SES::Base
-          def message_id_domain=(domain)
-            self["message_id_domain"] = domain
-          end
-
-          def message_id_domain
-            self["message_id_domain"]
-          end
-
         end
       end
     end

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

@@ -63,40 +63,19 @@ module Eco
           end
 
           # person model
-          def default_usergroup=(value)
-            self["default_usergroup"] = value
-          end
+          attr_key :default_usergroup, :default_schema, :default_login_method
 
-          def default_usergroup
-            self["default_usergroup"]
-          end
 
           def default_usergroup?
-            !!self["default_usergroup"]
-          end
-
-          def default_schema=(name)
-            self["default_schema"] = name
-          end
-
-          def default_schema
-            self["default_schema"]
+            !!default_usergroup
           end
 
           def default_schema?
-            !!self["default_schema"]
-          end
-
-          def default_login_method=(name)
-            self["default_login_method"] = name
-          end
-
-          def default_login_method
-            self["default_login_method"]
+            !!default_schema
           end
 
           def default_login_method?
-            !!self["default_login_method"]
+            !!default_login_method
           end
 
           # @return [Hash] with defined pairs format `key` and Person parsers.
@@ -116,7 +95,6 @@ module Eco
               prs
             end
           end
-
         end
       end
     end

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

@@ -3,52 +3,14 @@ module Eco
     class Session
       class Config
         class S3Storage < BaseConfig
-
+          attr_key :bucket_name, :prefix, :region
+          attr_key :access_key_id, :secret_access_key
+          
           def configured?
             required = bucket_name && prefix && access_key_id && secret_access_key && region
             !!required
           end
 
-          def bucket_name=(value)
-            self["bucket_name"] = value
-          end
-
-          def bucket_name
-            self["bucket_name"]
-          end
-
-          def prefix=(value)
-            self["prefix"] = value
-          end
-
-          def prefix
-            self["prefix"]
-          end
-
-          def access_key_id=(key)
-            self["access_key_id"] = key
-          end
-
-          def access_key_id
-            self["access_key_id"]
-          end
-
-          def secret_access_key=(key)
-            self["secret_access_key"] = key
-          end
-
-          def secret_access_key
-            self["secret_access_key"]
-          end
-
-          def region=(region)
-            self["region"] = region
-          end
-
-          def region
-            self["region"]
-          end
-
           def target_files=(value)
             self["target_files"]       = [value].flatten
           end
@@ -72,7 +34,6 @@ module Eco
           def target_file_patterns
             self["target_file_patterns"]
           end
-
         end
       end
     end

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

@@ -3,60 +3,15 @@ module Eco
     class Session
       class Config
         class SFTP < BaseConfig
+          attr_key :host, :user
+          attr_key :password, :key_file
+          attr_key :base_path, :enviro_subpaths
 
           def configured?
             required = host && user && (key_file || password)
             !!required
           end
 
-          def host=(value)
-            self["host"] = value
-          end
-
-          def host
-            self["host"]
-          end
-
-          def user=(value)
-            self["user"] = value
-          end
-
-          def user
-            self["user"]
-          end
-
-          def password=(var)
-            self["password"] = var
-          end
-
-          def password
-            self["password"]
-          end
-
-          def key_file=(key)
-            self["key_file"] = key
-          end
-
-          def key_file
-            self["key_file"]
-          end
-
-          def base_path=(path)
-            self["base_path"] = path
-          end
-
-          def base_path
-            self["base_path"]
-          end
-
-          def enviro_subpaths=(hash)
-            self["enviro_subpaths"] = hash
-          end
-
-          def enviro_subpaths
-            self["enviro_subpaths"]
-          end
-
           def enviro_subpath
             enviro_subpaths[config.active_enviro]
           end

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

@@ -0,0 +1,48 @@
+module Eco
+  module API
+    class Session
+      class Config
+        class TagTree < BaseConfig
+          attr_key :file
+
+          def scope_tree(enviro: nil)
+            return @tagtree if instance_variable_defined?(:@tagtree) && @tagtree.enviro == enviro
+            if tree_file = self.file
+              if (tree = file_manager.load_json(tree_file)) && !tree.empty?
+                @tagtree  = Eco::API::Organization::TagTree.new(tree, enviro: enviro)
+              end
+            end
+            @tagtree ||= live_tree(enviro: enviro)
+          end
+
+          # Among all the locations structures it selects the one with more location nodes
+          def live_tree(enviro: nil)
+            return @live_tree if instance_variable_defined?(:@live_tree) && @live_tree.enviro == enviro
+            trees = live_trees(enviro: enviro)
+            @live_tree = trees.reject do |tree|
+              tree.empty?
+            end.max {|a,b| a.count <=> b.count}
+          end
+
+          # Retrieves all the location structures of the organisation
+          def live_trees(enviro: nil)
+            [].tap do |eco_trees|
+              next unless apis.active_api.version_available?(:graphql)
+              next unless graphql = apis.api(version: :graphql)
+              kargs = {
+                includeArchived: false,
+                includeUnpublished: false
+              }
+              next unless trees = graphql.currentOrganization.locationStructures(**kargs)
+              trees.each do |tree|
+                args = {  enviro: enviro, id: tree.id, name: tree.name}
+                eco_tree = Eco::API::Organization::TagTree.new(tree.treeify, **args)
+                eco_trees.push(eco_tree)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -46,6 +46,12 @@ module Eco
         def mailer
           self["mailer"]     ||= Eco::API::Session::Config::Mailer.new(config: self)
         end
+
+        # Helper scope reporting structures.
+        # @return [Eco::API::Session::Config::TagTree]
+        def tagtree_config
+          org["tagtree_config"] ||= Eco::API::Session::Config::TagTree.new(config: self)
+        end
         # @!endgroup
 
         # @!group Logger
@@ -225,35 +231,20 @@ module Eco
         end
 
         def tagtree=(file)
-          org["tagtree"] = file
+          tagtree_config.file = file
         end
 
-        # It uses the `tagtree.json` file and in its absence, if `graphql` enabled, the `life_tagtree`
+        # It uses the `tagtree.json` file and in its absence, if `graphql` enabled, the largest `life_tagtree`
         # @return [Eco::API::Organization::TagTree]
         def tagtree(enviro: nil)
-          return @tagtree if instance_variable_defined?(:@tagtree) && @tagtree.enviro == enviro
-          if tree_file = org["tagtree"]
-            tree      = []
-            tree      = file_manager.load_json(tree_file) unless !tree_file
-            @tagtree  = Eco::API::Organization::TagTree.new(tree, enviro: enviro)
-          else
-            @tagtree = live_tree(enviro: enviro)
-          end
+          @tagtree ||= tagtree_config.scope_tree(enviro: enviro)
         end
 
         # It obtains the first of the live tagtree in the org
         # @note it requires graphql connection configuration parameters
         # @return [Eco::API::Organization::TagTree]
         def live_tree(enviro: nil)
-          return @live_tree if instance_variable_defined?(:@live_tree) && @live_tree.enviro == enviro
-          if apis.active_api.version_available?(:graphql)
-            graphql = apis.api(version: :graphql)
-            if tree = graphql.currentOrganization.tagTrees.to_a.first.treeify
-              @live_tree  = Eco::API::Organization::TagTree.new(tree, enviro: enviro)
-            else
-              @live_tree = nil
-            end
-          end
+          @live_tree ||= tagtree_config.live_tree(enviro: enviro)
         end
 
         # @return [Eco::API::Organization::PolicyGroups]
@@ -415,5 +406,6 @@ require_relative 'config/sftp'
 require_relative 'config/s3_storage'
 require_relative 'config/files'
 require_relative 'config/people'
+require_relative 'config/tagtree'
 require_relative 'config/post_launch'
 require_relative 'config/workflow'

data/lib/eco/api/usecases/default_cases/csv_to_tree_case/helper.rb

@@ -0,0 +1,90 @@
+class Eco::API::UseCases::DefaultCases::CsvToTree
+  module Helper
+    extend NodesCleaner
+    extend Treeify
+
+    class << self
+      def csv_from(filename)
+        raise "Missing #{filename}" unless File.exists?(filename)
+        result = csv_from_file(filename)
+        if result.is_a?(Integer)
+          puts "An encoding problem was found on line #{result}"
+          result = csv_from_content(filename)
+        end
+        result
+      end
+
+      def csv_nodes(filename)
+        i = 1; prev_level = nil; prev_node = nil; prev_nodes = Array(1..11).zip(Array.new(11, nil)).to_h
+        nodes = csv_from(filename).each_with_object([]) do |row, out|
+          values = row.fields.map do |value|
+            value = value.to_s.strip
+            value.empty?? nil : value
+          end
+          i += 1
+          node = Node.new(i, *values)
+          prev_node ||= node
+
+          if prev_node.raw_level <= node.raw_level
+            node.set_high_levels(prev_node)
+          else
+            if parent_node = prev_nodes[node.raw_level - 1]
+              node.set_high_levels(parent_node)
+            else
+              raise "Node '#{node.raw_tag}' (#{node.row_num} row) doesn't have parent"
+            end
+          end
+          out << node
+          prev_nodes[node.raw_level] = node
+          prev_node = node
+        end
+        tidy_nodes(nodes)
+      end
+
+      private
+
+      def csv_from_content(filename)
+        CSV.parse(file_content(filename), headers: true)
+      end
+
+      def file_content(filename)
+        coding = encoding(filename)
+        coding = (coding != "utf-8")? "#{coding}|utf-8": coding
+        if content = File.read(filename, encoding: coding)
+          content.scrub do |bytes|
+            '<' + bytes.unpack('H*')[0] + '>'
+          end
+        end
+      end
+
+      def csv_from_file(filename)
+        coding = encoding(filename)
+        coding = (coding != "utf-8")? "#{coding}|utf-8": coding
+        CSV.read(filename, headers: true, encoding: coding)
+      rescue CSV::MalformedCSVError => e
+        if line = e.message.match(/line (?<line>\d+)/i)[:line]
+          return line.to_i
+        else
+          raise
+        end
+      end
+
+      def has_bom?(path)
+        return false if !path || file_empty?(path)
+        File.open(path, "rb") do |f|
+          bytes = f.read(3)
+          return bytes.unpack("C*") == [239, 187, 191]
+        end
+      end
+
+      def encoding(path)
+        has_bom?(path) ? "bom" : "utf-8"
+      end
+
+      def file_empty?(path)
+        return true if !File.file?(path)
+        File.zero?(path)
+      end
+    end
+  end
+end

data/lib/eco/api/usecases/default_cases/csv_to_tree_case/node.rb

@@ -0,0 +1,206 @@
+class Eco::API::UseCases::DefaultCases::CsvToTree
+  class Node < Struct.new(:row_num, :l1, :l2, :l3, :l4, :l5, :l6, :l7, :l8, :l9, :l10, :l11)
+    TAGS_ATTRS         = [:l1, :l2, :l3, :l4, :l5, :l6, :l7, :l8, :l9, :l10, :l11]
+    ADDITIONAL_ATTRS   = [:row_num]
+    ALL_ATTRS          = ADDITIONAL_ATTRS + TAGS_ATTRS
+    ALLOWED_CHARACTERS = "A-Za-z0-9 &_'\/.-"
+    VALID_TAG_REGEX    = /^[#{ALLOWED_CHARACTERS}]+$/
+    INVALID_TAG_REGEX  = /[^#{ALLOWED_CHARACTERS}]+/
+    VALID_TAG_CHARS    = /[#{ALLOWED_CHARACTERS}]+/
+    DOUBLE_BLANKS      = /\s\s+/
+
+    attr_accessor :parentId
+
+    def nodeId
+      id
+    end
+
+    def id
+      tag.upcase
+    end
+
+    def name
+      tag
+    end
+
+    def tag
+      raw_tag.yield_self do |str|
+        partial = replace_not_allowed(str)
+        remove_double_blanks(partial).tap do |result|
+          if partial != str
+            invalid_chars = identify_invalid_characters(str)
+            puts "• (Row: #{self.row_num}) Invalid characters _#{invalid_chars}_ (removed): '#{str}' (converted to '#{result}')"
+          end
+          if result != partial
+            #puts "• There were DOUBLE BLANKS: tag '#{str}' (converted to '#{result}')"
+          end
+        end
+      end
+    end
+
+    def raw_tag
+      values_at(*TAGS_ATTRS.reverse).compact.first
+    end
+
+    def level
+      actual_level
+    end
+
+    def actual_level
+      tags_array.compact.length
+    end
+
+    def raw_level
+      tags_array.index(raw_tag) + 1
+    end
+
+    def tag_idx
+      tags_array.index(raw_tag)
+    end
+
+    def previous_idx
+      idx = tag_idx - 1
+      idx < 0 ? nil : idx
+    end
+
+    def empty_idx
+      tary = tags_array
+      tary.index(nil) || tary.length + 1
+    end
+
+    def copy
+      self.class.new.set_attrs(**self.to_h)
+    end
+
+    # We got a missing level that is compacted in one row
+    # Here we get the missing intermediate levels
+    # This is done from upper to lower level to ensure processing order
+    # It skips last one, as that is this object already
+    def decouple(num = 1)
+      with_info = filled_idxs
+      # must be the last among filled_idxs, so let's use it to verify
+      unless with_info.last == tag_idx
+        raise "Review this (row #{row_num}; '#{raw_tag}'): tag_idx is #{tag_idx}, while last filled idx is #{with_info.last}"
+      end
+      len = with_info.length
+      target_idxs = with_info[len-(num+1)..-2]
+      target_idxs.map do |idx|
+        self.copy.tap do |dup|
+          dup.clear_level(idx_to_level(idx + 1))
+        end
+      end
+    end
+
+    def merge!(node)
+      override_upper_levels(node.tags_array)
+    end
+
+    def set_high_levels(node)
+      override_lower_levels(node.tags_array)
+    end
+
+    def clear_level(i)
+      case i
+      when Enumerable
+        target = i.to_a
+      when Integer
+        return false unless i >= 1 && i <= tag_attrs_count
+        target = Array(i..tag_attrs_count)
+      else
+        return false
+      end
+      return false if target.empty?
+      target.each do |n|
+        #puts "clearing 'l#{n}': #{attr("l#{n}")}"
+        set_attr("l#{n}", nil)
+      end
+      true
+    end
+
+    def override_upper_levels(src_tags_array, from_level: self.raw_level + 1)
+      target_lev = Array(from_level..tag_attrs_count)
+      target_tags = src_tags_array[level_to_idx(from_level)..level_to_idx(tag_attrs_count)]
+      target_lev.zip(target_tags).each do |(n, tag)|
+        set_attr("l#{n}", tag)
+      end
+      self
+    end
+
+    def override_lower_levels(src_tags_array, to_level: self.raw_level - 1)
+      target_lev = Array(1..to_level)
+      target_tags = src_tags_array[level_to_idx(1)..level_to_idx(to_level)]
+      target_lev.zip(target_tags).each do |(n, tag)|
+        set_attr("l#{n}", tag)
+      end
+      self
+    end
+
+    def idx_to_level(x)
+      x + 1
+    end
+
+    def level_to_idx(x)
+      x - 1
+    end
+
+    def filled_idxs
+      tags_array.each_with_index.with_object([]) do |(t, i), o|
+        o << i if t
+      end
+    end
+
+    def blanks_between?
+      actual_level > empty_idx
+    end
+
+    def tags_array
+      values_at(*TAGS_ATTRS)
+    end
+
+    def values_at(*attrs)
+      attrs.map {|a| attr(a)}
+    end
+
+    def to_h(*attrs)
+      attrs = ALL_ATTRS if attrs.empty?
+      ALL_ATTRS.zip(values_at(*ALL_ATTRS)).to_h
+    end
+
+    def slice(*attrs)
+      return {} if attrs.empty?
+      to_h(*attrs)
+    end
+
+    def set_attrs(**kargs)
+      kargs.each {|attr, value| set_attr(attr, value)}
+      self
+    end
+
+    def set_attr(attr, value)
+      self.send("#{attr}=", value)
+    end
+
+    def attr(sym)
+      self.send(sym.to_sym)
+    end
+
+    def tag_attrs_count
+      TAGS_ATTRS.length
+    end
+
+    def remove_double_blanks(str)
+      return nil if str.nil?
+      str.gsub(DOUBLE_BLANKS, ' ').strip
+    end
+
+    def replace_not_allowed(str)
+      return nil if str.nil?
+      return str if str.match(VALID_TAG_REGEX)
+      str.gsub(INVALID_TAG_REGEX, ' ')
+    end
+
+    def identify_invalid_characters(str)
+      str.gsub(VALID_TAG_CHARS, '')
+    end
+  end
+end

data/lib/eco/api/usecases/default_cases/csv_to_tree_case/nodes_cleaner.rb

@@ -0,0 +1,73 @@
+class Eco::API::UseCases::DefaultCases::CsvToTree
+  module NodesCleaner
+    def repeated_tags
+      @repeated_tags ||= []
+    end
+
+    def done_tags
+      @done_tags ||= []
+    end
+
+    def fill_in_parents(nodes)
+      nodes.tap do |nodes|
+        prev_nodes = Array(1..11).zip(Array.new(11, nil)).to_h
+        nodes.each do |node|
+          if parent_node = prev_nodes[node.raw_level - 1]
+            node.parentId = parent_node.id
+          end
+          prev_nodes[node.raw_level] = node
+        end
+      end
+    end
+
+    def tidy_nodes(nodes, prev_level: 0, main: true)
+      out = nodes.each_with_object([]) do |node, out|
+        if done_tags.include?(tag = node.tag)
+          repeated_tags << "#{tag} (level: #{node.level})"
+        else
+          level = node.actual_level
+          if level > prev_level + 1
+            gap = level - (prev_level + 1)
+            puts "(Row: #{node.row_num}) Tag '#{tag}' (lev #{level}) jumps #{gap} level(s) (expected #{prev_level + 1})."
+            #puts "  " + node.tags_array.pretty_inspect
+            missing_nodes = node.decouple(gap)
+            puts "  Adding missing upper level(s): " + missing_nodes.map(&:raw_tag).pretty_inspect
+            out.push(*tidy_nodes(missing_nodes, prev_level: prev_level, main: false))
+            # puts node.actual_level
+            # pp node.tags_array
+            level = prev_level + 1
+          end
+          out       << node
+          done_tags << tag
+          prev_level = level
+        end
+      end
+      if main
+        unless repeated_tags.empty?
+          puts "There were #{repeated_tags.length} repeated tags. Only one included. These excluded:"
+          pp repeated_tags
+        end
+      end
+      fill_in_parents(out)
+    end
+
+    def to_rows(nodes, prev_level: 0, main: true)
+      out = tidy_nodes(nodes).each_with_object([]) do |node, out|
+        tag   = node.tag
+        level = node.actual_level
+        out   << (row = Array.new(level, nil))
+        row[-1..-1] = [tag.upcase]
+        prev_level = level
+      end
+      if main
+        # Normalize length
+        max_row = out.max {|a, b| a.length <=> b.length}
+        holder  = Array.new(max_row.length, nil)
+        out = out.map do |row|
+          row.dup.concat(holder)[0..max_row.length-1]
+        end
+      end
+      out
+    end
+  end
+end

data/lib/eco/api/usecases/default_cases/csv_to_tree_case/treeify.rb

@@ -0,0 +1,33 @@
+class Eco::API::UseCases::DefaultCases::CsvToTree
+  module Treeify
+    def treeify(nodes, &block)
+      get_children(nil, parents_hash(nodes), &block)
+    end
+
+    private
+
+    def parents_hash(nodes)
+      nodes.each_with_object({}) do |node, parents|
+        (parents[node.parentId] ||= []).push(node)
+      end
+    end
+
+    def get_children(node_id, parents, &block)
+      (parents[node_id] ||= []).each_with_object([]) do |child, results|
+        node_hash = {
+          "id"    => child.id,
+          "name"  => child.name
+        }
+
+        if block_given?
+          yield_hash = yield(child)
+          node_hash.merge(yield_hash) if yield_hash.is_a?(Hash)
+        end
+        
+        results << node_hash.merge({
+          "nodes" => get_children(child.id, parents, &block).compact
+        })
+      end
+    end
+  end
+end

data/lib/eco/api/usecases/default_cases/csv_to_tree_case.rb

@@ -0,0 +1,44 @@
+class Eco::API::UseCases::DefaultCases::CsvToTree < Eco::API::Common::Loaders::UseCase
+  name "csv-to-tree"
+  type :other
+
+  TIME_FORMAT = '%Y%m%dT%H%M%S'
+
+  attr_reader :session, :options
+
+  def main(session, options, usecase)
+    options[:end_get] = false
+    @session = session; @options = options
+
+    tree_struct = Helper.treeify(Helper.csv_nodes(input_file))
+
+    File.open(output_file, "w") do |fd|
+      json = tree_struct.to_json
+      fd <<  json
+    end
+    logger.info("Saved structure in '#{output_file}'")
+  end
+
+  private
+
+  def input_file
+    @input_file   ||= options.dig(:source, :file)
+  end
+
+  def output_file
+    @output_file ||= "#{active_enviro}_tree_#{timestamp}.json"
+  end
+
+  def timestamp(date = Time.now)
+    date.strftime(TIME_FORMAT)
+  end
+
+  def active_enviro
+    config.active_enviro
+  end
+end
+
+require_relative 'csv_to_tree_case/node'
+require_relative 'csv_to_tree_case/nodes_cleaner'
+require_relative 'csv_to_tree_case/treeify'
+require_relative 'csv_to_tree_case/helper'

data/lib/eco/api/usecases/default_cases.rb

@@ -22,6 +22,7 @@ require_relative 'default_cases/create_case'
 require_relative 'default_cases/create_details_case'
 require_relative 'default_cases/create_details_with_supervisor_case'
 require_relative 'default_cases/create_tag_paths_case'
+require_relative 'default_cases/csv_to_tree_case'
 require_relative 'default_cases/delete_trans_case'
 require_relative 'default_cases/delete_sync_case'
 require_relative 'default_cases/email_as_id_case'

data/lib/eco/api/usecases/graphql/base.rb

@@ -16,7 +16,7 @@ class Eco::API::UseCases::GraphQL::Base < Eco::API::Common::Loaders::UseCase
   end
 
   def graphql
-   @graphql ||= session.api(version: :graphql)
+    @graphql ||= session.api(version: :graphql)
   end
 
   def exit_error(msg)

data/lib/eco/api/usecases/ooze_samples/helpers_migration/copying.rb

@@ -71,7 +71,7 @@ class Eco::API::UseCases::OozeSamples
         return src_fld, dst_fld if dst_flds.empty? || src_flds.empty?
 
         if dst_flds.count > 1
-          logger.warn("There are #{dst_flds.count} destination '#{type}' fields named '#{label_dst}' (source: '#{src.id}'). Using first...")
+          logger.warn("There are #{dst_flds.count} destination '#{type}' fields named '#{label_dst}' (source: '#{dst.id}'). Using first...")
         end
 
         if src_flds.count > 1

data/lib/eco/cli/config/default/usecases.rb

@@ -98,6 +98,12 @@ ASSETS.cli.config do |cnf|
     desc = "Creates a CSV with the paths to each tag"
     cases.add("-create-tag-paths", :other, desc, case_name: "create-tag-paths")
 
+    desc = "Creates a JSON file with the tagtree from a CSV file"
+    cases.add("-csv-to-tree", :other, desc, case_name: "csv-to-tree") do |session, options, usecase|
+      file = SCR.get_file("-csv-to-tree", required: true, should_exist: true)
+      options.deep_merge!(source: {file: file})
+    end
+
     desc  = "Cleans from filter_tags those tags that are not present in the tagtree (as per tagtree.json file)."
     desc += " It will preserve standard register tags of most common registers (i.e. EVENT, RISK)."
     cases.add("-clean-unknown-tags", :transform, desc, case_name: "clean-unknown-tags")

data/lib/eco/version.rb

@@ -1,3 +1,3 @@
 module Eco
-  VERSION = "2.1.12"
+  VERSION = "2.2.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eco-helpers
 version: !ruby/object:Gem::Version
-  version: 2.1.12
+  version: 2.2.2
 platform: ruby
 authors:
 - Oscar Segura
@@ -136,40 +136,40 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.7
+        version: 1.0.1
     - - "<"
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: '1.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.7
+        version: 1.0.1
     - - "<"
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: ecoportal-api-graphql
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.11
+        version: 0.2.3
     - - "<"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.11
+        version: 0.2.3
     - - "<"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.3'
 - !ruby/object:Gem::Dependency
   name: aws-sdk-s3
   requirement: !ruby/object:Gem::Requirement
@@ -540,6 +540,7 @@ files:
 - lib/eco/api/session/config/post_launch.rb
 - lib/eco/api/session/config/s3_storage.rb
 - lib/eco/api/session/config/sftp.rb
+- lib/eco/api/session/config/tagtree.rb
 - lib/eco/api/session/config/workflow.rb
 - lib/eco/api/usecases.rb
 - lib/eco/api/usecases/base_case.rb
@@ -556,6 +557,11 @@ files:
 - lib/eco/api/usecases/default_cases/create_details_case.rb
 - lib/eco/api/usecases/default_cases/create_details_with_supervisor_case.rb
 - lib/eco/api/usecases/default_cases/create_tag_paths_case.rb
+- lib/eco/api/usecases/default_cases/csv_to_tree_case.rb
+- lib/eco/api/usecases/default_cases/csv_to_tree_case/helper.rb
+- lib/eco/api/usecases/default_cases/csv_to_tree_case/node.rb
+- lib/eco/api/usecases/default_cases/csv_to_tree_case/nodes_cleaner.rb
+- lib/eco/api/usecases/default_cases/csv_to_tree_case/treeify.rb
 - lib/eco/api/usecases/default_cases/delete_sync_case.rb
 - lib/eco/api/usecases/default_cases/delete_trans_case.rb
 - lib/eco/api/usecases/default_cases/email_as_id_case.rb