eco-helpers 2.5.9 → 2.6.0

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

@@ -8,6 +8,9 @@ module Eco
 
           attr_key :file, :structure_id
 
+          # @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)
@@ -20,7 +23,7 @@ module Eco
 
             if tree_file = self.file
               if (tree = file_manager.load_json(tree_file)) && !tree.empty?
-                @tagtree = Eco::API::Organization::TagTree.new(tree, enviro: enviro)
+                @tagtree = Eco::API::Organization::TagTree.new(tree)
               end
             elsif self.structure_id
               kargs.merge(id: self.structure_id)
@@ -36,6 +39,7 @@ module Eco
 
           # 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
             first_load       = !existing_cache
@@ -47,7 +51,6 @@ module Eco
             refresh_cache    = existing_cache && !switching_target
 
             kargs = {
-              enviro:               enviro,
               includeArchivedNodes: include_archived
             }.merge(kargs)
 
@@ -81,7 +84,7 @@ module Eco
           # @note it does not memoize
           # @param include_archived [Boolean] whether or not to include archived **nodes**
           # @return [Eco::API::Organization::TagTree, NilClass]
-          def live_tree_get(id: nil, enviro: nil, include_archived: false, **kargs, &block)
+          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)
 
@@ -92,14 +95,13 @@ module Eco
 
             return nil unless tree = graphql.currentOrganization.locationStructure(**kargs, &block)
 
-            args = { enviro: enviro, id: tree.id, name: tree.name }
-            Eco::API::Organization::TagTree.new(tree.treeify, **args)
+            Eco::API::Organization::TagTree.new(tree.treeify, id: tree.id, name: tree.name)
           end
 
           # Retrieves all the location structures of the organisation
           # @param include_archived [Boolean] whether or not to include archived **nodes**
           # @return [Array<Eco::API::Organization::TagTree>]
-          def live_trees(enviro: nil, include_archived: false, **kargs, &block)
+          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)
@@ -110,8 +112,7 @@ module Eco
 
               next unless trees = graphql.currentOrganization.locationStructures(**kargs, &block)
               trees.each do |tree|
-                args     = { enviro: enviro, id: tree.id, name: tree.name }
-                eco_tree = Eco::API::Organization::TagTree.new(tree.treeify, **args)
+                eco_tree = Eco::API::Organization::TagTree.new(tree.treeify, id: tree.id, name: tree.name)
                 eco_trees.push(eco_tree)
               end
             end

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

@@ -87,15 +87,16 @@ module Eco
           # @yield [stage_workflow] further _workflow_ configuration `for` the target stage `key`
           # @yieldparam stage_workflow [Eco::API::Session::Config::Workflow] the _target stage_  referred by `key`
           # @return [Eco::API::Session::Config::Workflow] the current stage object (to ease chainig).
-          def for(key = nil)
+          def for(key = nil, &block)
             raise "A block should be given." unless block_given?
             if !key
               yield(self)
             else
-              stage(key).for(&Proc.new)
+              stage(key).for(&block)
             end
             self
           end
+          alias_method :open, :for
 
           # Used in **configuration** time **to define** the **behaviour**  the target (sub)stage `key`
           # @note if a `block` is provided it will **not** `yield` the target stage immediately, but when the _workflow_ reaches the stage

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

@@ -257,6 +257,13 @@ module Eco
           tagtree_config.live_tree(id: id, enviro: enviro, **kargs, &block)
         end
 
+        # Retrieves all the location structures of the organisation
+        # @param include_archived [Boolean] whether or not to include archived **nodes**
+        # @return [Array<Eco::API::Organization::TagTree>]
+        def live_trees(**kargs, &block)
+          tagtree_config.live_trees(**kargs, &block)
+        end
+
         # @return [Eco::API::Organization::PolicyGroups]
         def policy_groups
           return @policy_groups if instance_variable_defined?(:@policy_groups)

data/lib/eco/api/session.rb

@@ -39,16 +39,31 @@ module Eco
         config.login_providers
       end
 
+      # @param live [Boolean] states preference of `live` tree if available over file.
+      # @param merge [Boolean] when in `live` mode, if mulitple trees, merge into one.
       # @see Eco::API::Session::Config#tagtree
-      def tagtree
-        config.tagtree(enviro: enviro)
+      # @see Eco::API::Session#live_trees
+      # @return [Eco::API::Organization::TagTree]
+      def tagtree(live: false, merge: false, include_archived: false, **kargs, &block)
+        if live && api?(version: :graphql)
+          return live_tree(include_archived: include_archived, **kargs, &block) unless merge
+          live_trees(include_archived: include_archived, **kargs, &block).inject(&:merge)
+        else
+          config.tagtree(enviro: enviro)
+        end
       end
 
       # @see Eco::API::Session::Config#live_tree
+      # @return [Eco::API::Organization::TagTree]
       def live_tree(id: nil, include_archived: false, **kargs, &block)
         config.live_tree(id: id, include_archived: include_archived, enviro: enviro, **kargs, &block)
       end
 
+      # @see Eco::API::Session::Config#live_tree
+      def live_trees(include_archived: false, **kargs, &block)
+        config.live_trees(include_archived: include_archived, **kargs, &block)
+      end
+
       # @see Eco::API::Session::Config#schemas
       def schemas
         config.schemas

data/lib/eco/api/usecases/cli/dsl.rb

@@ -0,0 +1,84 @@
+module Eco
+  module API
+    class UseCases
+      class Cli
+        module DSL
+          # Links the usecase to the Cli via `option_case`
+          def apply!(option_case = cli_name)
+            cli_config_case(option_case)
+            apply_options(option_case)
+            applied!
+            self
+          end
+
+          def applied?
+            @applied || false
+          end
+
+          def applied!
+            @applied = true
+          end
+
+          attr_writer :usecase
+          # Unless specified, assume Cli class hangs from its case namespace
+          def usecase
+            raise "#{self} is to use to extend a class" unless self.is_a?(Class)
+            @usecase ||= Kernel.const_get(self.to_s.split('::')[0..-2].join('::'))
+          end
+
+          def description(value = nil)
+            @description = (value.nil? ? @description : value)
+          end
+          alias_method :desc, :description
+
+          def type
+            usecase.type
+          end
+
+          def name
+            usecase.name
+          end
+
+          # It defaults to the use case preceded by dash
+          def cli_name(arg_name = nil)
+            @cli_name = (arg_name.nil? ? @cli_name : arg_name).yield_self do |value|
+              value = "-#{name}" if value.nil?
+              value
+            end
+          end
+
+          def callback(&block)
+            @callback = block
+          end
+
+          def options
+            @options ||= {}
+          end
+
+          def add_option(arg, desc = nil, &block)
+            self.tap do
+              "Overriding option '#{arg}' on case '#{name}'" if options.key?(arg)
+              @options[arg] = Eco::API::UseCases::Cli::Option.new(arg, desc, &block)
+            end
+          end
+
+          private
+
+          def apply_options(option_case)
+            options.each do |_key, option|
+              option.link_case(cli_config_case(option_case))
+            end
+          end
+
+          def cli_config_case(option_case = nil)
+            @cli_config_case ||= usecases.add(option_case, type, desc, case_name: name, &callback)
+          end
+
+          def usecases(&block)
+            ::ASSETS.cli.config.usecases(&block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eco/api/usecases/cli/option.rb

@@ -0,0 +1,19 @@
+# Class to delay the case options configuration (declaration vs configuration)
+class Eco::API::UseCases::Cli
+  class Option
+    attr_accessor :name, :desc, :callback
+
+    def initialize(name, desc, &block)
+      @name, @desc, @callback = name, desc, block
+    end
+
+    def dup(name: self.name, desc: self.desc, &block)
+      self.class.new(name, desc, &(block || callback))
+    end
+
+    def link_case(cli_config_case)
+      raise ArgumentError, "cli_config_case must have an 'add_option' method. Given: #{cli_config_case.class}" unless cli_config_case.respond_to?(:add_option)
+      cli_config_case.add_option(name, desc, &callback)
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# Class to integrate with the Cli a use case
+module Eco
+  module API
+    class UseCases
+      class Cli
+        require_relative 'cli/dsl'
+        extend DSL
+      end
+    end
+  end
+end
+
+require_relative 'cli/option'

data/lib/eco/api/usecases/default/locations/cli/tagtree_extract_cli.rb

@@ -0,0 +1,24 @@
+class Eco::API::UseCases::Default::Locations::TagtreeExtract
+  # Class to define the CLI integration of a usecase anywhere it suits.
+  class Cli < Eco::API::UseCases::Cli
+    desc "Exports the tagtree in a specific format"
+
+    add_option("-include-archived", "Whether the archived nodes should be included") do |options|
+      options.deep_merge!(output: {include: {archived: true}})
+    end
+
+    add_option("-format", "Kind of extract (list | json | nodes | csv_tree | excel_tree | excel_nodes )") do |options|
+      format = SCR.get_arg("-format", with_param: true)
+      options.deep_merge!(output: {format: format})
+    end
+
+    add_option("-node-attrs", "Attributes to be dumped (i.e. name|id ). Default: id") do |options|
+      attrs = SCR.get_arg("-node-attrs", with_param: true)
+      options.deep_merge!(output: {attrs: attrs.split('|').map(&:to_sym)})
+    end
+
+    add_option("-with-ancestors", "Include ancestors in tree csv/excel_tree") do |options|
+      options.deep_merge!(output: {include: {ancestors: true}})
+    end
+  end
+end

data/lib/eco/api/usecases/{default_cases → default/locations}/codes_to_tags_case.rb

@@ -1,4 +1,4 @@
-class Eco::API::UseCases::DefaultCases::CodesToTagsCase < Eco::API::Common::Loaders::UseCase
+class Eco::API::UseCases::Default::Locations::CodesToTagsCase < Eco::API::Common::Loaders::UseCase
   name "codes-to-tags-from"
   type :other
 

data/lib/eco/api/usecases/{default_cases → default/locations}/create_tag_paths_case.rb

@@ -1,4 +1,4 @@
-class Eco::API::UseCases::DefaultCases::TagPaths < Eco::API::Common::Loaders::UseCase
+class Eco::API::UseCases::Default::Locations::TagPaths < Eco::API::Common::Loaders::UseCase
   name "create-tag-paths"
   type :other
 
@@ -14,7 +14,7 @@ class Eco::API::UseCases::DefaultCases::TagPaths < Eco::API::Common::Loaders::Us
   private
 
   def tag_paths
-    @tag_paths ||= tagtree.tags.map do |tag|
+    @tag_paths ||= tagtree.tags.reverse.map do |tag|
       [tag, tagtree.path(tag).join("|")]
     end
   end

data/lib/eco/api/usecases/{default_cases → default/locations}/csv_to_tree_case.rb

@@ -1,4 +1,4 @@
-class Eco::API::UseCases::DefaultCases::CsvToTree < Eco::API::Common::Loaders::UseCase
+class Eco::API::UseCases::Default::Locations::CsvToTree < Eco::API::Common::Loaders::UseCase
   name "csv-to-tree"
   type :other
 

data/lib/eco/api/usecases/default/locations/tagtree_extract_case.rb

@@ -0,0 +1,173 @@
+# Use case to export an org tree into some of the offered forms.
+class Eco::API::UseCases::Default::Locations::TagtreeExtract < Eco::API::UseCases::GraphQL::Samples::Location
+  require_relative 'cli/tagtree_extract_cli'
+  #cli self::Cli
+
+  name "export-tree"
+  type :other
+
+  include Eco::Data::Files
+
+  OUT_FOLDER      = "sftp"
+  OUT_TIME_FORMAT = '%Y%m%dT%H%M%S'
+  OUT_FILENAME    = "live_tree"
+
+  def process
+    case format
+    when :excel_tree, :excel_nodes
+      excel(output_filename) do |workbook|
+        tag_trees.each do |tree|
+          excel_sheet(workbook, tree.name.gsub(/\s+/, "_"), header: format == :excel_nodes) do |sheet|
+            tree_extract(tree).each_with_index do |row, idx|
+              sheet.append_row(row)
+            end
+          end
+        end
+      end
+    when :list, :nodes, :csv_tree, :json
+      tag_trees.each do |tree|
+        file(output_filename(tree.name.gsub(/\s+/, "_"))) do |fd|
+          fd << tree_extract(tree)
+        end
+      end
+    else
+      log(:error) { "Unknown selected output format '#{format}'. Abort..." }
+      exit 1
+    end
+  end
+
+  private
+
+  def str_node_attrs
+    options.dig(:output, :attrs) || [:id]
+  end
+
+  def tree_extract(tree)
+    case format
+    when :list
+      to_indented_list(tree)
+    when :csv_tree
+      with_ancestors(csv_tree(tree, attrs: str_node_attrs)).to_csv
+    when :excel_tree
+      with_ancestors(csv_tree(tree, attrs: str_node_attrs)).to_a
+    when :nodes
+      csv_list(tree).to_csv
+    when :excel_nodes
+      csv_list(tree).to_a
+    when :json
+      hash_tree(tree).to_json
+    else
+      log(:error) { "Unsupported or must use a different function for '#{format}'. Aboart..."}
+      exit 1
+    end
+  rescue StandardError => err
+    log(:error) { "Something went wrong whene extracting '#{tree.name}':\n  • #{err}" }
+    exit 1
+  end
+
+  def with_ancestors(csv)
+    return csv unless include_ancestors?
+    # TODO: transform table so it includes previous row's ancestors up to the node level
+    csv
+  end
+
+  def format
+    options.dig(:output, :format)&.to_sym || :list
+  end
+
+  def output_file_format
+    case format
+    when :list; 'txt'
+    when :nodes; 'csv'
+    when :csv_tree; 'csv'
+    when :json; 'json'
+    when :excel_tree; 'xlsx'
+    when :excel_nodes; 'xlsx'
+    else
+      'txt'
+    end
+  end
+
+  def tag_trees
+    @tag_trees ||= session.live_trees(include_archived: include_archived?).reject do |tree|
+      tree.empty?.tap do |rejected|
+        log(:warn) { "Tree '#{tree.name}' does NOT have location nodes. Skipping..." } if rejected
+      end
+    end
+  end
+
+  def include_ancestors?
+    options.dit(:output, :include, :ancestors)
+  end
+
+  def include_archived?
+    options.dig(:output, :include, :archived)
+  end
+
+  def output_filename(name = self.class::OUT_FILENAME)
+    File.join(output_folder, "#{timestamp}_#{config.active_enviro}_#{name}.#{output_file_format}")
+  end
+
+  def output_folder
+    "#{config.active_enviro}/#{self.class::OUT_FOLDER}"
+  end
+
+  def timestamp(date = Time.now)
+    date.strftime(self.class::OUT_TIME_FORMAT)
+  end
+
+  # Transforms the input `tree` into a String list of indented nodes
+  def to_indented_list(tree, level: 0, attrs: str_node_attrs, indent: "  ")
+    ''.tap do |result|
+      out_str   = nil
+      sublevel  = tree.top?? 0 : level + 1
+      str_ary   = tree.nodes.map { |subtree| to_indented_list(subtree, level: sublevel) }
+      out_str   = str_ary.join("\n") unless str_ary.empty?
+
+      unless tree.top?
+        node_name = tree.as_json(include_children: false).values_at(*attrs.map(&:to_s)).join(" ## ")
+        out_head  = "#{indent * level}#{node_name}"
+        out_str   = out_str ? "#{out_head}\n#{out_str}" : out_head
+      end
+      result << out_str
+    end
+  end
+
+  def csv(filename, header = [])
+    CSV.open(filename, "w") do |csv|
+      csv << header unless header.empty?
+      yield(csv)
+    end
+  ensure
+    log(:info) { "Created file: #{filename}" }
+  end
+
+  def file(filename)
+    File.open(filename, "w") do |fd|
+      yield(fd)
+    end
+  ensure
+    log(:info) { "Created file: #{filename}" }
+  end
+
+  def excel(filename)
+    require 'fast_excel'
+    FastExcel.open(filename, constant_memory: true).tap do |workbook|
+      yield(workbook)
+      workbook.close
+    end
+    log(:info) { "Created file: #{filename}" }
+  end
+
+  def excel_sheet(workbook, name, header: true)
+    #unless sheet = workbook.get_worksheet_by_name(name)
+      sheet = workbook.add_worksheet(name)
+    #end
+    sheet.auto_width = true
+    yield(sheet)
+    if header
+      sheet.set_row(0, 30, workbook.bold_format)
+      sheet.freeze_panes(1, 0)
+    end
+  end
+end

data/lib/eco/api/usecases/default/locations.rb

@@ -0,0 +1,15 @@
+module Eco
+  module API
+    class UseCases
+      class Default
+        module Locations
+        end
+      end
+    end
+  end
+end
+
+require_relative 'locations/codes_to_tags_case'
+require_relative 'locations/create_tag_paths_case'
+require_relative 'locations/csv_to_tree_case'
+require_relative 'locations/tagtree_extract_case'

data/lib/eco/api/usecases/{default_cases → default/people}/analyse_people_case.rb

@@ -1,4 +1,4 @@
-class Eco::API::UseCases::DefaultCases::AnalysePeople < Eco::API::Common::Loaders::UseCase
+class Eco::API::UseCases::Default::People::Analyse < Eco::API::Common::Loaders::UseCase
   name "analyse-people"
   type :export
 

data/lib/eco/api/usecases/{default_cases → default/people}/change_email_case.rb

@@ -1,4 +1,4 @@
-class Eco::API::UseCases::DefaultCases::ChangeEMailCase < Eco::API::Common::Loaders::UseCase
+class Eco::API::UseCases::Default::People::ChangeEMailCase < Eco::API::Common::Loaders::UseCase
   name "change-email"
   type :sync
 

data/lib/eco/api/usecases/default/people/clean_unknown_tags_case.rb

@@ -0,0 +1,66 @@
+class Eco::API::UseCases::Default::People::CleanUnknownTags < Eco::API::Common::Loaders::UseCase
+  name "clean-unknown-tags"
+  type :transform
+
+  REGISTER_TAGS = [
+    "EVENT", "INJURY", "RISK", "CONTRACTOR", "PERMIT",
+    "AUDIT", "JSEA",
+    "TRAINING", "INDUCTION",
+    "MEETING",  "PPE",  "CHEMICAL",
+    "PLANT", "ASSET",
+    "POLICY", "IDEA", "REPORTS"
+  ]
+
+  def main(people, session, options, usecase)
+    update   = session.new_job("main", "update", :update, usecase)
+    people.each do |person|
+      unknown_tags = person.filter_tags.reject { |tag| tag?(tag) }
+      person.filter_tags -= unknown_tags
+      removed_tag!(*unknown_tags)
+      if (tag = default_tag(person)) && !tag?(tag)
+        removed_tag!(tag)
+        micro.refresh_default_tag(person.entry, person, options)
+      end
+      update.add(person)
+    end
+
+    log(:info) {
+      msg = "Here list of the #{removed_tags.count} removed locations..."
+      msg + "\n  • " + removed_tags.sort.join("\n  • ")
+    }
+  end
+
+  private
+
+  def default_tag(person)
+    return nil unless account = person.account
+    account.default_tag
+  end
+
+  def register_tags
+    @register_tags ||= self.class::REGISTER_TAGS.compact.map(&:upcase)
+  end
+
+  def removed_tag!(*tags)
+    @removed_tags = removed_tags | tags
+  end
+
+  def removed_tags
+    @removed_tags ||= []
+  end
+
+  def tag?(value)
+    return false if value.nil?
+    return true  if tagtree.tag?(value)
+    return false if clean_register_tags?
+    register_tags.any? { |reg| value.upcase == reg }
+  end
+
+  def tagtree
+    @tagtree ||= session.tagtree(live: true, merge: true)
+  end
+
+  def clean_register_tags?
+    options.dig(:usecase, :clear_register_tags)
+  end
+end

data/lib/eco/api/usecases/{default_cases → default/people}/clear_abilities_case.rb

@@ -1,4 +1,4 @@
-class Eco::API::UseCases::DefaultCases::ClearAbilitiesTransCase < Eco::API::Common::Loaders::UseCase
+class Eco::API::UseCases::Default::People::ClearAbilitiesTransCase < Eco::API::Common::Loaders::UseCase
   name "clear-abilities"
   type :transform
 

data/lib/eco/api/usecases/{default_cases → default/people}/org_data_convert_case.rb

@@ -1,4 +1,4 @@
-class Eco::API::UseCases::DefaultCases::OrgDataConvertCase < Eco::API::Common::Loaders::UseCase
+class Eco::API::UseCases::Default::People::OrgDataConvertCase < Eco::API::Common::Loaders::UseCase
   name "org-data-convert"
   type :import
 

data/lib/eco/api/usecases/{default_cases → default/people}/refresh_case.rb

@@ -1,4 +1,4 @@
-class Eco::API::UseCases::DefaultCases::RefreshCase < Eco::API::Common::Loaders::UseCase
+class Eco::API::UseCases::Default::People::RefreshCase < Eco::API::Common::Loaders::UseCase
   name "refresh"
   type :transform
 

data/lib/eco/api/usecases/{default_cases → default/people}/reinvite_sync_case.rb

@@ -1,9 +1,9 @@
-class Eco::API::UseCases::DefaultCases::ReinviteSyncCase < Eco::API::UseCases::DefaultCases::ReinviteTransCase
+class Eco::API::UseCases::Default::People::ReinviteSyncCase < Eco::API::UseCases::Default::People::ReinviteTransCase
   name "reinvite"
   type :sync
 
   def main(entries, people, session, options, usecase)
     found = micro.with_each_present(entries, people, options, log_starter: true)
-    reinvite(found.users, session, options, usecase)
+    reinvite(found.users)
   end
 end

data/lib/eco/api/usecases/{default_cases → default/people}/reinvite_trans_case.rb

@@ -1,4 +1,4 @@
-class Eco::API::UseCases::DefaultCases::ReinviteTransCase < Eco::API::Common::Loaders::UseCase
+class Eco::API::UseCases::Default::People::ReinviteTransCase < Eco::API::Common::Loaders::UseCase
   name "reinvite"
   type :transform
 

data/lib/eco/api/usecases/default/people/reinvite_trans_cli.rb

@@ -0,0 +1,5 @@
+class Eco::API::UseCases::Default::People::ReinviteTransCase
+  class Cli < Eco::API::UseCases::Cli
+    
+  end
+end

data/lib/eco/api/usecases/{default_cases → default/people}/restore_db_case.rb

@@ -1,4 +1,4 @@
-class Eco::API::UseCases::DefaultCases::RestoreDBCase < Eco::API::Common::Loaders::UseCase
+class Eco::API::UseCases::Default::People::RestoreDBCase < Eco::API::Common::Loaders::UseCase
   name "restore-db"
   type :sync
 

data/lib/eco/api/usecases/{default_cases → default/people}/set_default_tag_case.rb

@@ -1,4 +1,4 @@
-class Eco::API::UseCases::DefaultCases::SetDefaultTagCase < Eco::API::Common::Loaders::UseCase
+class Eco::API::UseCases::Default::People::SetDefaultTagCase < Eco::API::Common::Loaders::UseCase
   name "set-default-tag"
   type :transform
 

data/lib/eco/api/usecases/{default_cases → default/people}/supers_cyclic_identify_case.rb

@@ -1,4 +1,4 @@
-class Eco::API::UseCases::DefaultCases::SupersCyclicIdentify < Eco::API::Common::Loaders::UseCase
+class Eco::API::UseCases::Default::People::SupersCyclicIdentify < Eco::API::Common::Loaders::UseCase
   name "identify-cyclic-supers"
   type :export
 

data/lib/eco/api/usecases/{default_cases → default/people}/supers_hierarchy_case.rb

@@ -1,4 +1,4 @@
-class Eco::API::UseCases::DefaultCases::SupersHierarchy < Eco::API::Common::Loaders::UseCase
+class Eco::API::UseCases::Default::People::SupersHierarchy < Eco::API::Common::Loaders::UseCase
   name "supers-hierarchy"
   type :export
 

data/lib/eco/api/usecases/{default_cases → default/people}/switch_supervisor_case.rb

@@ -1,4 +1,4 @@
-class Eco::API::UseCases::DefaultCases::SwitchSupervisorCase < Eco::API::Common::Loaders::UseCase
+class Eco::API::UseCases::Default::People::SwitchSupervisorCase < Eco::API::Common::Loaders::UseCase
   name "switch-supervisor"
   type :transform