eco-helpers 2.6.3 → 2.7.0

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

@@ -3,10 +3,13 @@ class Eco::API::UseCases::Default::People::OrgDataConvertCase < Eco::API::Common
   type :import
 
   def org_data_convert(people)
-    pp "Going to convert data from '#{source_enviro}' to '#{ASSETS.active_config}'"
+    log(:info) {
+      "Going to convert data from '#{source_enviro}' to '#{ASSETS.active_config}'"
+    }
+
     puts "\n"
     people.each.with_index do |person, i|
-      if (i % 10 == 0)
+      if (i % 10).zero?
         percent = i * 100 / people.length
         print "Processing: #{percent.round}% (#{i}/#{people.length} entries)\r"
         $stdout.flush
@@ -19,44 +22,43 @@ class Eco::API::UseCases::Default::People::OrgDataConvertCase < Eco::API::Common
     people
   end
 
-  def main(people, session, options, usecase)
+  def main(people, _session, _options, _usecase)
     org_data_convert(people)
   end
 
   private
 
   def account_convert!(person)
-    if account = person.account
-      account.policy_group_ids = policy_groups_convert(account.policy_group_ids)
-      account.doc.tap do |doc|
-        ["login_provider_ids", "starred_ids", "landing_page_id"].map do |attr|
-          doc.delete(attr)
-        end
+    return unless (account = person.account)
+    account.policy_group_ids = policy_groups_convert(account.policy_group_ids)
+    account.doc.tap do |doc|
+      %w[login_provider_ids starred_ids landing_page_id].map do |attr|
+        doc.delete(attr)
       end
     end
   end
 
   def details_convert!(person)
-    if person.details
-      person.details.as_json.tap do |details_doc|
-        details_doc["schema_id"] = @session.schema.id
-        person.add_details(@session.schema)
-        person.details = details_doc
-      end
+    return unless person.details
+    person.details.as_json.tap do |details_doc|
+      details_doc["schema_id"] = session.schema.id
+      person.add_details(session.schema)
+      person.details = details_doc
     end
   end
 
   def policy_groups_convert(ids)
     ids.map do |id|
-      unless name = source_policy_groups.to_name(id) || ignore_missing_policy_groups?
+      name = source_policy_groups.to_name(id)
+      unless name || ignore_missing_policy_groups?
         msg  = "Ops, do not know #{id} usergroup for source environment"
-        msg += "\nUse the option -ignore-missing-policy-groups if you do not care"
+        msg << "\nUse the option -ignore-missing-policy-groups if you do not care"
         error(msg)
       end
       session.policy_groups.to_id(name).tap do |new_id|
         unless new_id || ignore_missing_policy_groups?
           msg  = "Ops, do not know #{name} usergroup for destination environment"
-          msg += "\nUse the option -ignore-missing-policy-groups if you do not care"
+          msg << "\nUse the option -ignore-missing-policy-groups if you do not care"
           error(msg)
         end
       end
@@ -69,15 +71,15 @@ class Eco::API::UseCases::Default::People::OrgDataConvertCase < Eco::API::Common
 
   def source_config
     @source_config ||= ASSETS.config(key: source_enviro, update_active: false).tap do |config|
-      unless config
-        error("The source environment '#{source_enviro}' does not exit or is not configured")
-      end
+      next if config
+      error("The source environment '#{source_enviro}' does not exit or is not configured")
     end
   end
 
   def source_enviro
-    @source_enviro ||= options.dig(:source_enviro).tap do |enviro|
-      error("A source environment is required to migrate data from") unless enviro
+    @source_enviro ||= options[:source_enviro].tap do |enviro|
+      next if enviro
+      error("A source environment is required to migrate data from")
     end
   end
 
@@ -85,10 +87,6 @@ class Eco::API::UseCases::Default::People::OrgDataConvertCase < Eco::API::Common
     options.dig(:ignore, :missing, :policy_groups)
   end
 
-  def logger
-    @session.logger
-  end
-
   def error(msg)
     logger.error(msg)
     exit(1)

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

@@ -2,8 +2,8 @@ class Eco::API::UseCases::Default::People::RefreshCase < Eco::API::Common::Loade
   name "refresh"
   type :transform
 
-  def main(people, session, options, usecase)
-    update   = session.new_job("main", "update", :update, usecase)
+  def main(people, session, _options, usecase)
+    update = session.new_job("main", "update", :update, usecase)
     people.each {|person| update.add(person)}
   end
 end

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

@@ -9,7 +9,7 @@ class Eco::API::UseCases::Default::People::ReinviteTransCase < Eco::API::Common:
   private
 
   def reinvite(users)
-    invite   = session.new_job("main", "invite", :update, usecase, :account)
+    invite = session.new_job("main", "invite", :update, usecase, :account)
     users.each do |person|
       if force_invite?
         person.account.force_send_invites = true

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

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

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

@@ -1,8 +1,10 @@
+# @example
+#     -restore-db-from backup.json -skip-api-policies -skip-batch-policy -include-excluded -simulate
 class Eco::API::UseCases::Default::People::RestoreDBCase < Eco::API::Common::Loaders::UseCase
   name "restore-db"
   type :sync
 
-  def main(entries, people, session, options, usecase)
+  def main(entries, people, session, options, usecase) # rubocop:disable Metrics/AbcSize
     require_people_as_entries!(entries)
 
     restart  = session.new_job("main", "restart", :create, usecase) if options.dig(:include, :create)
@@ -19,14 +21,14 @@ class Eco::API::UseCases::Default::People::RestoreDBCase < Eco::API::Common::Loa
 
     micro.with_each(entries, people, options) do |entry, person|
       if person.new? && !options.dig(:include, :create)
-        re_starters.push(entry);
+        re_starters.push(entry)
         next
       end
 
       person.new? ? restart.add(person) : update.add(person)
 
-      core_copy(entry, person)        unless options.dig(:exclude, :core)
-      person.details = entry.details  unless options.dig(:exclude, :details)
+      core_copy(entry, person)       unless options.dig(:exclude, :core)
+      person.details = entry.details unless options.dig(:exclude, :details)
 
       unless options.dig(:exclude, :account) || !entry.account
         person.account ||= {}
@@ -48,46 +50,49 @@ class Eco::API::UseCases::Default::People::RestoreDBCase < Eco::API::Common::Loa
     person.freemium      = entry.freemium
   end
 
-  def account_copy(src, dst)
-    if src
-      dst.default_tag        = src.default_tag      unless options.dig(:exclude, :filter_tags)
-      dst.policy_group_ids   = src.policy_group_ids unless options.dig(:exclude, :policy_groups)
+  def account_copy(src, dst) # rubocop:disable Metrics/AbcSize
+    return unless src
+    dst.default_tag        = src.default_tag        unless options.dig(:exclude, :filter_tags)
+    dst.policy_group_ids   = src.policy_group_ids   unless options.dig(:exclude, :policy_groups)
+    dst.permissions_custom = src.permissions_custom unless options.dig(:exclude, :abilities)
 
-      unless options.dig(:exclude, :abilities)
-        dst.permissions_custom = src.permissions_custom
-      end
-
-      unless options.dig(:exclude, :login_providers) || options.dig(:source_enviro)
-        dst.login_provider_ids = src.login_provider_ids
-      end
-
-      if src.preferences
-        dst.doc["preferences"] = JSON.parse((src.doc["preferences"] || {}).to_json)
-      end
+    unless options.dig(:exclude, :login_providers) || options[:source_enviro]
+      dst.login_provider_ids = src.login_provider_ids
+    end
 
-      unless options.dig(:source_enviro)
-        dst.starred_ids        = src.starred_ids
-        dst.landing_page_id    = src.landing_page_id
-      end
+    if src.preferences # rubocop:disable Style/IfUnlessModifier
+      dst.doc["preferences"] = JSON.parse((src.doc["preferences"] || {}).to_json)
+    end
 
-      dst&.send_invites      = options[:send_invites] if options.key?(:send_invites)
+    unless options[:source_enviro]
+      dst.starred_ids     = src.starred_ids
+      dst.landing_page_id = src.landing_page_id
     end
+
+    dst&.send_invites = options[:send_invites] if options.key?(:send_invites)
   end
 
   def require_people_as_entries!(entries)
-    unless entries.is_a?(Eco::API::Organization::People)
-      logger.error("Your input should be an 'Eco::API::Organization::People' object. Got: #{entries.class}")
-      exit(1)
-    end
+    return true if entries.is_a?(Eco::API::Organization::People)
+    log(:error) {
+      "Your input should be an 'Eco::API::Organization::People' object. Got: #{entries.class}"
+    }
+    exit(1)
   end
 
   def report_re_starters(re_starters)
-    unless re_starters.empty?
-      logger.error("There were #{re_starters.length} entries of the backup that do not exist in the (filtered?) people manager")
-      logger.error("Some examples:")
-      re_starters.slice(0, 4).each_with_index do |entry, i|
-        logger.error("This person does not exist: #{entry.name} (#{entry.email})")
-      end
+    return if re_starters.empty?
+    examples = re_starters.slice(0, 4).map do |entry|
+      "This person does not exist: '#{entry.name}' (#{entry.email})"
     end
+
+    log(:error) {
+      msg  = []
+      msg << "There were #{re_starters.length} entries of the backup "
+      msg << "that do not exist in the (filtered?) people manager."
+      msg << "Some examples:"
+      msg << "  • #{examples.join("\n  • ")}"
+      msg.join("\n")
+    }
   end
 end

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

@@ -7,9 +7,9 @@ class Eco::API::UseCases::Default::People::SetDefaultTagCase < Eco::API::Common:
   # => take the common node between them (i.e. you have Hamilton and Auckland -> take New Zealand)
   # => if there's no common node between them, take the `first` (unless they are at top level of the tree)
   def main(people, session, options, usecase)
-    tagtree_present!(session)
-    users    = users_present!(people, session)
-    update   = session.new_job("main", "update", :update, usecase, :account)
+    tagtree_present!
+    users  = users_present!
+    update = session.new_job("main", "update", :update, usecase, :account)
 
     users.each do |person|
       micro.refresh_default_tag(nil, person, options)
@@ -19,22 +19,26 @@ class Eco::API::UseCases::Default::People::SetDefaultTagCase < Eco::API::Common:
 
   private
 
-  def tagtree_present!(session)
-    if !session.tagtree
-      msg = "There is no tagtree definition in the configuration files\n" +
-            "For this usecase to work out you need to define it."
-      session.logger.fatal(msg)
-      raise msg
-    end
+  def tagtree_present!
+    return unless tagtree?
+
+    msg  = "There is no locs struct defined. Aborting..."
+    logger.fatal(msg)
+    raise msg
   end
 
-  def users_present!(people, session)
+  def users_present!
     people.users.tap do |users|
-      unless users.length > 0
-        session.logger.info(msg = "There are no people with account... aborting script")
-        raise msg
-      end
+      next if users.length.positive?
+
+      msg = "There are no people with account... aborting script"
+      log(:error) { msg }
+      raise msg
     end
   end
 
+  def tagtree?
+    return false unless (tree = session.tagtree)
+    !tree.empty?
+  end
 end

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

@@ -6,8 +6,6 @@ class Eco::API::UseCases::Default::People::SupersCyclicIdentify < Eco::API::Comm
 
   def main(people, session, options, usecase)
     options[:end_get] = false
-    @people = people
-
     save!(cyclic_sets)
   end
 
@@ -27,19 +25,20 @@ class Eco::API::UseCases::Default::People::SupersCyclicIdentify < Eco::API::Comm
       return
     end
 
-    ext  = File.extname(file).downcase.delete(".")
+    ext = File.extname(file).downcase.delete(".")
 
     File.open(file, "w") do |fd|
-      if ext == "txt"
+      case ext
+      when "txt"
         create_file(data, file: file, format: :txt)
-      elsif ext == "html"
-        puts "html is still not supported"
+      when "html"
+        log(:warn) { "html is still not supported" }
         exit(1)
-        create_file(data, file: file, format: :html)
-      elsif ext == "json"
-        puts "json is still not supported"
+        # create_file(data, file: file, format: :html)
+      when "json"
+        log(:warn) { "json is still not supported" }
         exit(1)
-        create_file(data, file: file, format: :json)
+        # create_file(data, file: file, format: :json)
       end
     end
   end
@@ -62,10 +61,15 @@ class Eco::API::UseCases::Default::People::SupersCyclicIdentify < Eco::API::Comm
 
   def set_to_str(set, lev: 0, format: :txt)
     raise "Required Array. Given: #{set.class}" unless set.is_a?(Array)
+
     "".tap do |str|
       entry = set.shift
-      str << "#{"  " * lev}#{(lev > 0)? "+-#{lev}- " : ""}#{entry.name} (#{entry.external_id}|#{entry.email}|#{entry.id})\n"
-      str << set_to_str(set, lev: lev + 1, format: format) unless !set || set.empty?
+      str << "#{"  " * lev}"
+      str << lev > 0 ? "+-#{lev}- " : ""
+      str << entry.name
+      str << " (#{entry.external_id}|#{entry.email}|#{entry.id})\n"
+      next unless set && !set.empty?
+      str << set_to_str(set, lev: lev + 1, format: format)
     end
   end
 end

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

@@ -8,7 +8,7 @@ class Eco::API::UseCases::DefaultCases::HrisCase < Eco::API::Common::Loaders::Us
   def main(entries, people, session, options, usecase)
     @people = people
     require_only_one_schema!
-    micro    = session.micro
+    micro     = session.micro
     @leavers  = session.new_job("pre", "leavers",  :update, usecase, :account)
     @creation = session.new_job("main", "create",  :create, usecase)
     @update   = session.new_job("main", "update",  :update, usecase)
@@ -38,19 +38,21 @@ class Eco::API::UseCases::DefaultCases::HrisCase < Eco::API::Common::Loaders::Us
   end
 
   def require_only_one_schema!
-    unless schema_id = options.dig(:people, :filter, :details, :schema_id)
-      active_schema = session.schema
-      other_schemas = session.schemas.map(&:id) - [active_schema.id]
-      other_people  = people.group_by_schema.values_at(*other_schemas).map(&:to_a).flatten
-      if other_people.length > 3
-        msg  = "There are #{other_people.length} people in schemas other than #{active_schema.name}."
-        msg << " Please, use the filter option '-schema-id SchemaName' for the 'hris' case to only include those of that schema"
-        msg << " in the current update. The HRIS case identifies people that are not in the file as leavers"
-        msg << " (as it will remove the account of all the people of other schemas if they are not in the input file)."
-        msg << "\n For example: -schema-id '#{active_schema.name.downcase}'"
-        logger.error(msg)
-        raise msg
-      end
-    end
+    return if options.dig(:people, :filter, :details, :schema_id)
+
+    active_schema = session.schema
+    other_schemas = session.schemas.map(&:id) - [active_schema.id]
+    other_people  = people.group_by_schema.values_at(*other_schemas).map(&:to_a).flatten
+    return unless other_people.length > 3
+
+    msg  = "There are #{other_people.length} people in schemas other than #{active_schema.name}."
+    msg << " Please, use the filter option '-schema-id SchemaName' for the 'hris' case"
+    msg << " to only include those of that schema in the current update."
+    msg << " The HRIS case identifies people that are not in the file as leavers"
+    msg << " (as it will remove the account of all the people of other schemas"
+    msg << " if they are not in the input file)."
+    msg << "\n For example: -schema-id '#{active_schema.name.downcase}'"
+    logger.error(msg)
+    raise msg
   end
 end

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

@@ -1,3 +1,4 @@
+# rubocop:disable Naming/AccessorMethodName
 class Eco::API::UseCases::DefaultCases::Samples::Sftp < Eco::API::Common::Loaders::UseCase
   class WrongConst < ArgumentError; end
   class MissRemoteFolder < ArgumentError; end
@@ -6,11 +7,12 @@ class Eco::API::UseCases::DefaultCases::Samples::Sftp < Eco::API::Common::Loader
   name "sftp"
   type :other
 
-  CONST_REFERRAL = /^(?:::)?(?:[A-Z][a-zA-Z0-9_]*(?:::[A-Z][a-zA-Z0-9_]*)*)$/
+  CONST_REFERRAL = /^(?:::)?(?:[A-Z][a-zA-Z0-9_]*(?:::[A-Z][a-zA-Z0-9_]*)*)$/.freeze
 
-  def main(session, options, usecase)
+  def main(session, options, _usecase)
     options[:end_get] = false
     raise "The SFTP is not configured" unless session.sftp?
+
     case options.dig(:sftp, :command)
     when :list
       list_folder
@@ -29,11 +31,15 @@ class Eco::API::UseCases::DefaultCases::Samples::Sftp < Eco::API::Common::Loader
   def file_pattern(require: true)
     fpc = file_pattern_const
     return fpc if fpc
-    raise WrongConst, "(#{self.class}) You should redefine the file_pattern function as a RegEx expression that matches the target remote file" if require
+    return unless require
+
+    msg  = "(#{self.class}) You should redefine the file_pattern function "
+    msg << "as a RegEx expression that matches the target remote file"
+    raise WrongConst, msg
   end
 
   def file_pattern_const
-    if fpc = options.dig(:sftp, :file_pattern_const)
+    if (fpc = options.dig(:sftp, :file_pattern_const))
       raise WrongConst, "(#{self.class}) Invalid file pattern const referral: #{fpc}" unless fpc.match(CONST_REFERRAL)
       begin
         self.eval(fpc)
@@ -49,7 +55,11 @@ class Eco::API::UseCases::DefaultCases::Samples::Sftp < Eco::API::Common::Loader
   def remote_subfolder(require: true)
     rm_sf = options.dig(:sftp, :remote_subfolder)
     return rm_sf if rm_sf
-    raise MissRemoteFolder, "(#{self.class}) You should redefine remote_subfolder as the folder where the target file sits. Ex: /IN/Personnel" if require
+    return unless require
+
+    msg  = "(#{self.class}) You should redefine remote_subfolder "
+    msg << "as the folder where the target file sits. Ex: /IN/Personnel"
+    raise MissRemoteFolder, msg
   end
 
   # `remote_target_folder` overrides `sftp_config.remote_folder` as well as `remote_subfolder`
@@ -57,7 +67,7 @@ class Eco::API::UseCases::DefaultCases::Samples::Sftp < Eco::API::Common::Loader
   def remote_folder
     rm_tf   = options.dig(:sftp, :remote_target_folder)
     rm_fd   = options.dig(:sftp, :remote_folder) || sftp_config.remote_folder
-    rm_tf || File.join(rm_fd, remote_subfolder)
+    rm_tf || [rm_fd, remote_subfolder].compact.join('/')
   end
 
   def to_remote_path(file)
@@ -68,17 +78,19 @@ class Eco::API::UseCases::DefaultCases::Samples::Sftp < Eco::API::Common::Loader
     options.dig(:sftp, :local_folder) || "."
   end
 
-  def with_remote_files
-    begin
-      sftp.files(remote_folder, pattern: file_pattern).each do |remote_file|
-        yield(remote_file) if block_given?
-      end
-    rescue ArgumentError
-      raise
-    rescue ::Net::SFTP::StatusException => e
-      logger.error("(#{self.class}) There was an error trying to access the remote folder '#{remote_folder}'")
-      []
+  def with_remote_files(folder: self.remote_folder, pattern: self.file_pattern)
+    sftp.files(folder, pattern: pattern).each do |remote_file|
+      yield(remote_file) if block_given?
     end
+  rescue ArgumentError
+    raise
+  rescue ::Net::SFTP::StatusException => err
+    log(:error) {
+      msg  = "(#{self.class}) There was an error trying to access "
+      msg << "the remote folder '#{remote_folder}': #{err}"
+      msg
+    }
+    []
   end
 
   def list_folder
@@ -139,3 +151,5 @@ class Eco::API::UseCases::DefaultCases::Samples::Sftp < Eco::API::Common::Loader
     session.sftp
   end
 end
+
+# rubocop:enable Naming/AccessorMethodName

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

@@ -6,7 +6,6 @@ class Eco::API::UseCases::DefaultCases::ToCsvDetailedCase < Eco::API::UseCases::
 
   def to_row(person)
     data = super(person)
-    data << person.subordinates
     data << person_supervisor(person)
     data += user_abilities(person)
     data += user_permissions_custom(person) if options.dig(:export, :options, :permissions_custom)
@@ -39,7 +38,6 @@ class Eco::API::UseCases::DefaultCases::ToCsvDetailedCase < Eco::API::UseCases::
 
   def spot_header(person = people.first)
     super(person) do |header|
-      header << "Subordinates"
       header << "Supervisor Name"
       header += abilities_header
       header += abilities_header("custom") if options.dig(:export, :options, :permissions_custom)

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

@@ -1,13 +1,14 @@
 class Eco::API::UseCases::GraphQL::Base < Eco::API::Common::Loaders::UseCase
   class NotImplementedMethod < StandardError
   end
-  
+
   name "graphql-base"
   type :other
 
   include Eco::API::UseCases::GraphQL::Helpers::Base
+  include Eco::Language::Methods::CallDetector
 
-  def main(session, options, usecase)
+  def main(_sess, options, _case)
     options.deep_merge!(workflow: {no_email: true}) # prevent the default mailer to quick in
     options[:end_get] = false
     process
@@ -15,6 +16,7 @@ class Eco::API::UseCases::GraphQL::Base < Eco::API::Common::Loaders::UseCase
 
   # Write here your script
   def process
-    raise NotImplementedMethod, "You need to inherit from this class ('#{self.class}') and call super with a block"
+    return unless called_via?(Eco::API::UseCases::GraphQL::Base, __method__)
+    raise NotImplementedMethod, "You need to inherit from this class ('#{self.class}')"
   end
 end

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

@@ -2,6 +2,9 @@ module Eco::API::UseCases::GraphQL::Helpers::Base
   # Basic stuff you would need in any use case
   module CaseEnv
     include Eco::Language::AuxiliarLogger
+
+    private
+
     attr_reader :session, :options
 
     def config
@@ -9,7 +12,7 @@ module Eco::API::UseCases::GraphQL::Helpers::Base
     end
 
     def simulate?
-      options.dig(:simulate)
+      options[:simulate]
     end
   end
 end

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

@@ -0,0 +1,14 @@
+module Eco::API::UseCases::GraphQL::Helpers::Base
+  # Basic stuff you would need in any use case
+  module GraphQLEnv
+    include CaseEnv
+
+    private
+
+    def graphql
+      msg = "The credentials or basic graphql config are missing for the active environment"
+      raise msg unless session.api?(version: :graphql)
+      @graphql ||= session.api(version: :graphql)
+    end
+  end
+end

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

@@ -1,11 +1,12 @@
 module Eco::API::UseCases::GraphQL::Helpers
   module Base
     require_relative 'base/case_env'
-    include Eco::API::UseCases::GraphQL::Helpers::Base::CaseEnv
+    require_relative 'base/graphql_env'
 
-    def graphql
-      @graphql ||= session.api(version: :graphql)
-    end
+    include CaseEnv
+    include GraphQLEnv
+
+    private
 
     # Keep a copy of the requests/responses for future reference
     def backup(data, type:)

data/lib/eco/api/usecases/graphql/helpers/location/base/classifications_parser.rb

@@ -0,0 +1,60 @@
+module Eco::API::UseCases::GraphQL::Helpers::Location
+  module Base
+    module ClassificationsParser
+      include Eco::API::UseCases::GraphQL::Helpers::Base::CaseEnv
+
+      private
+
+      # @note
+      #   1. It returns `nil` unless there are classifications defined
+      #   2. If the value is wrong, it warns and returns `nil`
+      def to_classification(value)
+        return nil unless node_classifications?
+        raise ArgumentError, "Expecting a single element. Given: #{value.class}" if value.is_a?(Enumerator)
+        return nil unless value.is_a?(String)
+
+        node_classifications.to_id(value).tap do |type|
+          unknown_clasification!(value) unless type
+        end
+      end
+
+      def to_classification_ids(values)
+        values = [values].flatten unless values.is_a?(Array)
+        values.compact.map {|val| to_classification(val)}.compact
+      end
+
+      # @note
+      #   1. It returns `nil` unless there are classifications defined
+      #   2. If the value is wrong, it warns and returns `nil`
+      def to_classification_name(value)
+        return nil unless node_classifications?
+        raise ArgumentError, "Expecting a single element. Given: #{value.class}" if value.is_a?(Enumerator)
+        return nil unless value.is_a?(String)
+
+        node_classifications.to_name(value) do |name|
+          unknown_clasification!(value) unless name
+        end
+      end
+
+      def node_classifications?
+        node_classifications.any?
+      end
+
+      def node_classifications
+        @node_classifications ||= session.node_classifications
+      end
+
+      def unknown_clasification!(value)
+        return if unknown_classifications.include?(value)
+        unknown_classifications << value
+        log(:warn) {
+          "Unknown location node classification '#{value}'"
+        }
+      end
+
+      def unknown_classifications
+        @unknown_classifications ||= []
+      end
+    end
+  end
+end