eco-helpers 2.5.2 → 2.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 140086432682ed765773ca3f1fabcdd46606c04507d6652d94f3df68233cc7ec
-  data.tar.gz: fb68c2d6ab307711c45660cf169303b3e79f7555eb5199a6ed33455030def28a
+  metadata.gz: 444bec4cd18402a38eff718340932ca7d72c9959b865805964b0ec9787d94636
+  data.tar.gz: 97291544f70b525781d81f168ffc86c1d960151e53535a540ac1b7824b9eaf28
 SHA512:
-  metadata.gz: 96ab04ce3bdb34c994becd6a6223cbae38a95aa8bd2309906c047a39a0476b689cf76d7538556c650a826eae5f31cd807c351f0fd6f765cb5efb39857022981f
-  data.tar.gz: 0365d9f8777250747eef5580df8531bc07a77dfa7d46c7aaefd29898e44f2450f62fcad8c64f97976d1ae1f7526bfa5e8dcf34eeaa1c4d36777e3e0beff43dff
+  metadata.gz: 02360de987395d801aa1b1fb659dd4b6011c317a21058be33c3283b3a2856c69db519baf6eb85a022f7a2c7c4e826861b108c2cf09aefad3ca57b32d53b45c72
+  data.tar.gz: 402c880d701446c072f6534d4df35b2a104704dc79480e37e5033101df63a8b10baa25257911af1cc84994efe05744b15c608798dbc1637ad268811ca2d7d926

data/CHANGELOG.md

@@ -1,13 +1,73 @@
 # Change Log
 All notable changes to this project will be documented in this file.
 
-## [2.5.2] - 2023-06-xx
+## [2.5.5] - 2023-07-xx
+
+### Added
+### Changed
+### Fixed
+
+## [2.5.4] - 2023-07-27
+
+### Added
+  - SFTP case helpers: `Eco::API::UseCases::GraphQL::Utils::Sftp`
+  - `Eco::Data::Locations::NodeDiff` and `Eco::Data::Locations::NodeDiff::NodeDiffs`
+    - Aim to identify changes in the locations structure
+
+### Changed
+  - Some internal tidy up in `Eco::API::UseCases::GraphQL`
+
+## [2.5.3] - 2023-07-19
+
+### Added
+  - _GraphQL base case_ for **locations structure update**.
+    - Refer to `Eco::API::UseCases::GraphQL::Samples::LocationCommands`
+    - See also `Eco::API::UseCases::GraphQL`. **Added** `Helpers` and `Samples`
+  - `Eco::Data::Locations` helpers
+    - **Converters**: it offers a `DSL` (see `Eco::Data::Locations::DSL`) manage as input/output:
+      1. CSV files with locations in two basic formats (list of nodes and hierarchy of locations)
+      2. This comes with integrity checkers to ensure the input data files are correct (warnings)
+      3. It also allows to convert to/from an organization locations structure and csv files.
+    - Making generic the helpers of `Eco::API::UseCases::DefaultCases::CsvToTree`
+    - The prospect is to move to the new/reviewed helpers at some stage (so remove the old helpers)
+    - This comes with a series of **converters** and **parsers** to allow two basic forms of input/output:
+      - CSV with list of nodes (`id`, `name`, `parent_id`)
+      - CSV of the actual tree (each column is one level of the tree)
+  - `Eco::API::Organization::TagTree` - **added/improved methods**
+    - **added** shortcuts: `parent_id`, `parent_name`
+    - **added** filters: `select`, `reject`
+    - **improved** `as_json`:
+      1. new parameter `include_children`
+      2. Hash keys | Header names to `HEADER` column
+    - **added** `as_nodes_json` to obtain a plain list (rather than hierarchical `as_json`)
+  - `Eco::CSV::Table`
+    - **added** `#add_index_column` to numerate the rows in a new column
+    - **improved** `#add_column` with new parameter `pos`
+    - **added** `#nil_blank_cells` and `#nil_blank_cells!`
+  - `Eco::Language::BasicLogger` brief extensible logger.
+
+### Changed
+  - Refactored `Eco::API::Session::Logger` inheriting from `Eco::Language::BasicLogger`
+
+### Fixed
+  - Live tree retrieval. Allow to specify locations structure `id`, `kargs` & `block`.
+    - `Eco::API::Session#live_tree` allow `id`, `kargs` & `block`, **fix** pass `include_archived`
+    - `Eco::API::Session::Config#live_tree` allow `id`, `kargs` & `block`
+      - When `id` is given, it uses `tagtree_config#live_tree_get`
+      - **fixed** neither `kargs` nor `include_archived` where defined
+    - `Eco::API::Session::Config::Tagtree` methods
+      - `#live_trees` allow `kargs`
+      - `#live_tree_get` **added**: it does not memoize
+      - `#live_tree` allow `id` and `kargs`
+        - **fixed** `include_archived` nodes should not be redirected to `live_trees` as in the latter this parameter has a different meaning (it refers to archived structures).
+    - **Important note**: the `ecoportal-api-graphql` gem, at the moment always retrieves archived nodes. This makes the `include_archived` argument non-functional. However, at some stage this will be changed and everything should be sorted out by then.
+
+## [2.5.2] - 2023-06-23
 
 ### Added
   - `Eco::API::Session::Config::Workflow#exit_handle`
     - Allows to define a callback on `SystemExit` (`exit` call).
 
-### Changed
 ### Fixed
   - `Eco::API::Session::Config::Workflow` on `SystemExit` preserve original exit `status` value (i.e. `0`, `1`)
     - It was changing an `exit 1` to be an `exit 0`

data/eco-helpers.gemspec

@@ -31,8 +31,8 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "redcarpet", ">= 3.5.1",  "< 4"
 
   spec.add_dependency 'ecoportal-api', '>= 0.9.4', '< 0.10'
-  spec.add_dependency 'ecoportal-api-v2', '>= 1.1.2', '< 1.2'
-  spec.add_dependency 'ecoportal-api-graphql', '>= 0.3.7', '< 0.4'
+  spec.add_dependency 'ecoportal-api-v2', '>= 1.1.3', '< 1.2'
+  spec.add_dependency 'ecoportal-api-graphql', '>= 0.3.8', '< 0.4'
   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',  '< 3'

data/lib/eco/api/common/loaders/use_case.rb

@@ -3,7 +3,6 @@ module Eco
     module Common
       module Loaders
         class UseCase < Eco::API::Common::Loaders::CaseBase
-
           class << self
             # @return [Symbol] the `type` of usecase (i.e. `:sync`, `:transform`, `:import`, `:other`)
             def type(value = nil)
@@ -34,7 +33,6 @@ module Eco
           def type
             self.class.type
           end
-
         end
       end
     end

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

@@ -2,7 +2,6 @@ module Eco
   module API
     module Common
       module People
-
         # @attr_reader direct_attrs [Array<String>] only those internal attributes present in the person entry that do **not** have an internal/external name mapping.
         class PersonEntryAttributeMapper
           @@cached_warnings = {}
@@ -266,7 +265,6 @@ module Eco
             logger.fatal(msg)
             raise msg
           end
-
         end
       end
     end

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

@@ -2,111 +2,56 @@ module Eco
   module API
     module Common
       module Session
-        class Logger
-          DEFAULT_TIMESTAMP_PATTERN = '%Y-%m-%dT%H:%M:%S'
+        class Logger < Eco::Language::BasicLogger
+          TIMESTAMP_PATTERN = '%Y-%m-%dT%H:%M:%S'
 
           attr_reader :cache
 
-          def initialize(console_level: nil, file_level: ::Logger::DEBUG, log_file: nil, timestamp_console: false, enviro: nil)
+          def initialize(file_level: ::Logger::DEBUG, log_file: nil, enviro: nil, **kargs)
+            super(**kargs)
             raise "Required Environment object (enviro:). Given: #{enviro}" if enviro && !enviro.is_a?(Eco::API::Common::Session::Environment)
             @enviro = enviro
             @cache  = Logger::Cache.new
 
-            timestamp_console = fetch_timestamp_console(timestamp_console)
-            @console_logger = ::Logger.new(STDOUT).tap do |_logger|
-              _logger.formatter = proc do |severity, datetime, progname, msg|
-                str_timestamp = timestamp_console ? "#{datetime.strftime(DEFAULT_TIMESTAMP_PATTERN)} >" : ""
-                "#{severity.to_s[0]}: #{str_timestamp} #{msg}\n"
-              end
-              _logger.level = fetch_console_level(console_level)
-            end
-
             if log_file = fetch_log_file(log_file)
-              @file_logger = ::Logger.new(log_file).tap do |_logger|
-                _logger.formatter = proc do |severity, datetime, progname, msg|
-                  "#{severity.to_s[0]}: #{datetime.strftime(DEFAULT_TIMESTAMP_PATTERN)} > #{msg}\n".tap do |formatted|
-                    cache.add(severity, datetime, msg, formatted)
-                  end
+              loggers[:file] = ::Logger.new(log_file).tap do |logger|
+                logger.formatter = format_proc(console: false) do |severity, datetime, msg, formatted_msg|
+                  cache.add(severity, datetime, msg, formatted_msg)
                 end
-                _logger.level = fetch_file_level(file_level)
+                logger.level = file_level
               end
             end
-          end
-
-          def level=(value)
-            @console_logger.level = value
-          end
-
-          def debug(*args, &block)
-            log(:debug, *args, &block)
-          end
-
-          def info(*args, &block)
-            log(:info, *args, &block)
-          end
-
-          def warn(*args, &block)
-            return log(:warn, *args, &block)
-          end
-
-          def error(*args, &block)
-            return log(:error, *args, &block)
-          end
 
-          def fatal(*args, &block)
-            return log(:fatal, *args, &block)
+            if_config(:timestamp_console) { |value| self.timestamp  = value }
+            if_config(:console_level)     { |value| self.level      = value }
+            if_config(:file_level)        { |value| self.file_level = value }
           end
 
-          def unknown(msg, &block)
-            return log(:unknown, *args, &block)
-          end
-
-          def << (msg)
-            @console_logger << msg unless !@console_logger
-            @file_logger << msg    unless !@file_logger
-          end
-
-          def close()
-            @console_logger.close unless !@console_logger
-            @file_logger.close    unless !@file_logger
-          end
-
-          def add(*args)
-            @console_logger.add(*args) unless !@console_logger
-            @file_logger.add(*args)    unless !@file_logger
+          def file_level=(value)
+            loggers[:file]&.level = value
           end
 
           private
 
-          def log(level, *args, &block)
-            @console_logger.send(level, *args, &block) unless !@console_logger
-            @file_logger.send(level, *args, &block) unless !@file_logger
-          end
-
-          def config
-            @enviro.config || {}
-          end
-
-          def fetch_timestamp_console(value)
-            value || config.logger.timestamp_console
+          def config(attr)
+            return nil unless cnf = @enviro&.config&.logger
+            cnf.send(attr) if cnf.respond_to?(attr)
           end
 
-          def fetch_console_level(value)
-            value || config.logger.console_level || ::Logger::INFO
-          end
-
-          def fetch_file_level(value)
-            value || config.logger.file_level || ::Logger::DEBUG
+          def if_config(attr)
+            unless (value = config(attr)).nil?
+              yield(value) if block_given?
+              value
+            end
           end
 
           def fetch_log_file(log_file)
-            if log_file ||= config.logger.file
+            if log_file ||= config(:file)
               log_file = @enviro.file_manager.dir.file(log_file) if @enviro
               FileManager.create_directory(log_file, includes_file: true)
             end
             log_file
           end
-
         end
       end
     end

data/lib/eco/api/microcases/with_each.rb

@@ -86,7 +86,6 @@ module Eco
           end
         end
       end
-
     end
   end
 end

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

@@ -2,7 +2,15 @@ module Eco
   module API
     module Organization
       # Provides helpers to deal with tagtrees.
+      # @note that currenlty the parsing assumes top level to be array.
+      #   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'
+        ].freeze
+
         attr_accessor :id
         alias_method :tag, :id
         attr_accessor :name, :weight
@@ -82,6 +90,27 @@ module Eco
           all_nodes.each(&block)
         end
 
+        # @note rejected nodes will not include their children nodes
+        # @return [Array<TagTree>] plain list of nodes
+        def select(when_is: true, &block)
+          raise ArgumentError, "Missing block" unless block_given?
+          [].tap do |out_nodes|
+            selected = false
+            selected = (yield(self) == when_is) unless top?
+            out_nodes.push(self)                if selected
+            next                                unless selected || top?
+            nodes.each do |nd|
+              out_nodes.concat(nd.select(when_is: when_is, &block))
+            end
+          end
+        end
+
+        # @note rejected nodes will not include their children nodes
+        # @return [Array<TagTree>] plain list of nodes
+        def reject(&block)
+          select(when_is: false, &block)
+        end
+
         # All actual nodes of this tree
         # @note order is that of the parent to child relationships
         # @return [Array<TagTree>]
@@ -91,8 +120,8 @@ module Eco
               out_nodes.push(self)
               yield(self) if block_given?
             end
-            nodes.each do |node|
-              out_nodes.concat(node.all_nodes(&block))
+            nodes.each do |nd|
+              out_nodes.concat(nd.all_nodes(&block))
             end
           end
         end
@@ -109,6 +138,16 @@ module Eco
           end
         end
 
+        # @return [String] the `id` of the parent (unless we are on a top level node)
+        def parent_id
+          parent.id unless parent.top?
+        end
+
+        # @return [String] the `name` of the parent (unless we are on a top level node)
+        def parent_name
+          parent.name unless parent.top?
+        end
+
         # @return [Array] with the differences
         def diff(tagtree, differences: {}, level: 0, **options)
           require 'hashdiff'
@@ -119,22 +158,32 @@ module Eco
           depth == -1
         end
 
-        # @return [Array[Hash]] where `Hash` is a `node` `{"tag" => TAG, "nodes": Array[Hash]}`
-        def as_json
-          nodes_json = nodes.map {|node| node.as_json}
+        # Returns a tree of Hashes form nested via `nodes` (or just a list of hash nodes)
+        # @yield [node_json, node] block for custom output json model
+        # @yiledreturn [Hash] the custom json model.
+        # @include_children [Boolean] whether it should return a tree hash or just a list of hash nodes.
+        # @return [Array[Hash]] where `Hash` is a `node` (i.e. `{"tag" => TAG, "nodes": Array[Hash]}`)
+        def as_json(include_children: true, &block)
+          return [] if top? && !include_children
+          children_json = nodes.map {|nd| nd.as_json(include_children: true, &block)} if include_children
+
           if top?
-            nodes_json
+            children_json
           else
-            {
-              "id"        => tag,
-              "archived"  => archived,
-              "archived_token" => archived_token,
-              "weight"    => weight,
-              "nodes"     => nodes_json
-            }
+            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
           end
         end
 
+        # Returns a plain list form of hash nodes.
+        # @return [Array[Hash]] where `Hash` is a plain `node`
+        def as_nodes_json(&block)
+          all_nodes.map {|nd| nd.as_json(include_children: false, &block)}
+        end
+
         # @return [Boolean] `true` if there are tags in the node, `false` otherwise.
         def empty?
           count <= 1
@@ -148,8 +197,8 @@ 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 |node|
-                node.total_depth
+              deepest_node = nodes.max_by do |nd|
+                nd.total_depth
               end
               deepest_node.total_depth
             else

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

@@ -20,33 +20,55 @@ module Eco
           end
 
           # Among all the locations structures it selects the one with more location nodes
-          def live_tree(enviro: nil, include_archived: false, &block)
+          # If `id` is provided, it only retrieves this locations structure.
+          def live_tree(id: nil, enviro: nil, include_archived: false, **kargs, &block)
             return @live_tree if instance_variable_defined?(:@live_tree) && @live_tree.enviro == enviro
-            trees = live_trees(enviro: enviro, include_archived: include_archived, &block)
-            @live_tree = trees.reject do |tree|
-              tree.empty?
-            end.max do |a,b|
-              a.count <=> b.count
+            if id
+              args       = {id: id, enviro: enviro, include_archived: include_archived}.merge(kargs)
+              @live_tree = live_tree_get(**args, &block)
+            else
+              # note that `include_archived` nodes is NOT the same as including archived structures
+              # => In `live_tree` the paramter refers to nodes
+              trees      = live_trees(enviro: enviro, &block)
+              @live_tree = trees.reject do |tree|
+                tree.empty?
+              end.max do |a,b|
+                a.count <=> b.count
+              end
             end.tap do |tree|
               if tree
-                msg ="Using LIVE LOCATIONS Structure: '#{tree.name}' (#{tree.count} nodes)"
+                msg = "Using LIVE LOCATIONS Structure: '#{tree.name}' (#{tree.count} nodes)"
                 session_logger.info(msg)
               end
             end
           end
 
+          # Gets a single locations structure
+          # @note it does not memoize
+          def live_tree_get(id: nil, enviro: nil, include_archived: false, **kargs, &block)
+            return nil unless apis.active_api.version_available?(:graphql)
+            return nil unless graphql = apis.api(version: :graphql)
+            #kargs = { includeArchived: include_archived }.merge(kargs).slice(:includeArchived)
+            # For now, this endpoint only accepts `id` as a parameter. It is pending to
+            # expose further parameters via query
+            return nil unless tree = graphql.currentOrganization.locationStructure(id: id, &block)
+            args = { enviro: enviro, id: tree.id, name: tree.name }
+            Eco::API::Organization::TagTree.new(tree.treeify, **args)
+          end
+
           # Retrieves all the location structures of the organisation
-          def live_trees(enviro: nil, include_archived: false, &block)
+          def live_trees(enviro: nil, include_archived: false, **kargs, &block)
             [].tap do |eco_trees|
               next unless apis.active_api.version_available?(:graphql)
               next unless graphql = apis.api(version: :graphql)
               kargs = {
                 includeArchived:    include_archived,
                 includeUnpublished: false
-              }
+              }.merge(kargs).slice(:includeArchived, :includeUnpublished)
+
               next unless trees = graphql.currentOrganization.locationStructures(**kargs, &block)
               trees.each do |tree|
-                args = {  enviro: enviro, id: tree.id, name: tree.name}
+                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

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

@@ -290,7 +290,6 @@ module Eco
             self.class.validate_stage(key)
             @stages[key] ||= self.class.workflow_class(key).new(key, _parent: self, config: config)
           end
-
         end
       end
     end

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

@@ -243,8 +243,12 @@ module Eco
         # 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)
-          @live_tree ||= tagtree_config.live_tree(enviro: enviro)
+        def live_tree(id: nil, enviro: nil, **kargs, &block)
+          if id
+            tagtree_config.live_tree_get(id: id, enviro: enviro, **kargs, &block)
+          else
+            tagtree_config.live_tree(enviro: enviro, **kargs, &block)
+          end
         end
 
         # @return [Eco::API::Organization::PolicyGroups]

data/lib/eco/api/session.rb

@@ -45,8 +45,8 @@ module Eco
       end
 
       # @see Eco::API::Session::Config#live_tree
-      def live_tree(include_archived: false, &block)
-        config.live_tree(enviro: enviro, &block)
+      def live_tree(id: nil, include_archived: false, **kargs, &block)
+        config.live_tree(id: nil, include_archived: include_archived, enviro: enviro, **kargs, &block)
       end
 
       # @see Eco::API::Session::Config#schemas

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

@@ -2,11 +2,11 @@ class Eco::API::UseCases::DefaultCases::AbstractPolicyGroupAbilities < Eco::API:
   name "abstract-policygroup-abilities"
   type :export
 
-  attr_reader :session, :people, :options
+  attr_reader :people
 
   def main(people, session, options, usecase)
     options[:end_get] = false
-    @session = session; @options = options; @people = people
+    @people = people
 
     generate_csv!
   end
@@ -157,5 +157,4 @@ class Eco::API::UseCases::DefaultCases::AbstractPolicyGroupAbilities < Eco::API:
   def percent(num, total)
     (100 * num.to_f / total).round(2)
   end
-
 end

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

@@ -2,11 +2,11 @@ class Eco::API::UseCases::DefaultCases::AnalysePeople < Eco::API::Common::Loader
   name "analyse-people"
   type :export
 
-  attr_reader :session, :people, :options
+  attr_reader :people
 
   def main(people, session, options, usecase)
     options[:end_get] = false
-    @session = session; @options = options; @people = people
+    @people = people
 
     case
     when case_options[:identify_duplicates]
@@ -219,5 +219,4 @@ class Eco::API::UseCases::DefaultCases::AnalysePeople < Eco::API::Common::Loader
       raise "Review your expression. Cannot recognize '#{part}' as part of '#{obj.class}'"
     end
   end
-
 end

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

@@ -11,5 +11,4 @@ class Eco::API::UseCases::DefaultCases::AppendUsergroupsCase < Eco::API::Common:
       micro.append_usergroups(entry, person, options)
     end
   end
-
 end

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

@@ -1,7 +1,7 @@
 class Eco::API::UseCases::DefaultCases::ChangeEMailCase < Eco::API::Common::Loaders::UseCase
   name "change-email"
   type :sync
-  
+
   # Target people with non-up-to-date emails will be updated to the new email
   def main(entries, people, session, options, usecase)
     micro    = session.micro
@@ -24,5 +24,4 @@ class Eco::API::UseCases::DefaultCases::ChangeEMailCase < Eco::API::Common::Load
       end
     end
   end
-
 end

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

@@ -13,11 +13,7 @@ class Eco::API::UseCases::DefaultCases::CleanUnknownTags < Eco::API::Common::Loa
     "POLICY", "IDEA", "REPORTS"
   ]
 
-  attr_reader :session, :options
-
   def main(people, session, options, usecase)
-    @session = session; @options = options
-
     update   = session.new_job("main", "update", :update, usecase)
     people.each do |person|
       unknown_tags = person.filter_tags.select {|tag| !tag?(tag)}
@@ -75,5 +71,4 @@ class Eco::API::UseCases::DefaultCases::CleanUnknownTags < Eco::API::Common::Loa
   def clean_register_tags?
     !options.dig(:usecase, :include_register_tags)
   end
-
 end

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

@@ -3,12 +3,12 @@ class Eco::API::UseCases::DefaultCases::ClearAbilitiesTransCase < Eco::API::Comm
   type :transform
 
   def main(people, session, options, usecase)
-    clear_abilities(people.users, session, options, usecase)
+    clear_abilities(people.users)
   end
 
   private
 
-  def clear_abilities(users, session, options, usecase)
+  def clear_abilities(users)
     update   = session.new_job("main", "clear-abilities", :update, usecase, :account)
     users.each do |person|
       person.account.permissions_custom = nil_abilities.dup

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

@@ -17,7 +17,6 @@ class Eco::API::UseCases::DefaultCases::CodesToTagsCase < Eco::API::Common::Load
 
   def main(session, options, usecase)
     options[:end_get] = false
-    @session = session; @options = options
     codes_to_tags
   end
 
@@ -26,26 +25,26 @@ class Eco::API::UseCases::DefaultCases::CodesToTagsCase < Eco::API::Common::Load
   def to_tag(code)
     if mapper.external?(code)
       mapper.to_internal(code)
-    elsif @session.tagtree.tag?(code)
+    elsif session.tagtree.tag?(code)
       code.upcase
     else
-      @session.logger.warn("Unknown Location Code: '#{code}'")
+      logger.warn("Unknown Location Code: '#{code}'")
       nil
     end
   end
 
   def mapper
-    unless mapper ||= @session.config.location_codes && @session.config.locations_mapper
+    unless mapper ||= session.config.location_codes && session.config.locations_mapper
       raise "No filter_tags parser, nor location mappings are present"
     end
   end
 
   def codes_column
-    @codes_column ||= @options.dig(:other, :file, :codes_column)
+    @codes_column ||= options.dig(:other, :file, :codes_column)
   end
 
   def input_file
-    @input_file   ||= @options.dig(:other, :file, :name)
+    @input_file ||= options.dig(:other, :file, :name)
   end
 
   def output_file
@@ -55,5 +54,4 @@ class Eco::API::UseCases::DefaultCases::CodesToTagsCase < Eco::API::Common::Load
   def clean_file_name(filename)
     File.basename(filename).gsub(/\s/, "")
   end
-
 end