eco-helpers 2.0.15 → 2.0.21

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

@@ -0,0 +1,37 @@
+class Eco::API::UseCases::DefaultCases::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"
+  ]
+
+  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)}
+      person.filter_tags -= unknown_tags
+      update.add(person)
+    end
+  end
+
+  private
+
+  def tag?(value)
+    tagtree.tag?(value) || REGISTER_TAGS.any? {|reg| value == reg}
+  end
+
+  def tagtree
+    @tagtree ||= ASSETS.config.tagtree
+  end
+
+end

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

@@ -16,10 +16,9 @@ class Eco::API::UseCases::DefaultCases::CodesToTagsCase < Eco::API::Common::Load
   end
 
   def main(session, options, usecase)
-    @session = session
-    @options = options
+    options[:end_get] = false
+    @session = session; @options = options
     codes_to_tags
-    exit
   end
 
   private

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

@@ -2,13 +2,23 @@ class Eco::API::UseCases::DefaultCases::ResetLandingPageCase < Eco::API::Common:
   name "reset-landing-page"
   type :transform
 
+  attr_reader :session, :options
+
   def main(people, session, options, usecase)
+    @session = session; @options = options
     update   = session.new_job("main", "update", :update, usecase, :core)
 
     people.users.each do |user|
-      user.account.landing_page_id = nil
+      user.account.landing_page_id = page_id
       update.add(user)
     end
   end
 
+  private
+
+  def page_id
+    options[:page_id]
+  end
+
+
 end

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

@@ -59,7 +59,6 @@ class Eco::API::UseCases::DefaultCases::RestoreDBCase < Eco::API::Common::Loader
       dst.policy_group_ids   = src.policy_group_ids unless options.dig(:exclude, :policy_groups)
 
       unless options.dig(:exclude, :abilities)
-        dst.permissions_preset = src.permissions_preset
         dst.permissions_custom = src.permissions_custom
       end
 
@@ -75,7 +74,7 @@ class Eco::API::UseCases::DefaultCases::RestoreDBCase < Eco::API::Common::Loader
         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
   end

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

@@ -0,0 +1,72 @@
+class Eco::API::UseCases::DefaultCases::SupersCyclicIdentify < Eco::API::Common::Loaders::UseCase
+  name "identify-cyclic-supers"
+  type :export
+
+  attr_reader :session, :people, :options
+
+  def main(people, session, options, usecase)
+    options[:end_get] = false
+    @session = session; @options = options; @people = people
+
+    save!(cyclic_sets)
+  end
+
+  private
+
+  def cyclic_sets
+    Eco::API::Common::People::SupervisorHelpers.identify_cyclic_chains(people)
+  end
+
+  def file
+    @file ||= options.dig(:output, :file) || "cyclic_supers.txt"
+  end
+
+  def save!(data)
+    if data.empty?
+      session.logger.info("There were no cyclic supervisors identified!!")
+      return
+    end
+
+    ext  = File.extname(file).downcase.delete(".")
+
+    File.open(file, "w") do |fd|
+      if ext == "txt"
+        create_file(data, file: file, format: :txt)
+      elsif ext == "html"
+        puts "html is still not supported"
+        exit(1)
+        create_file(data, file: file, format: :html)
+      elsif ext == "json"
+        puts "json is still not supported"
+        exit(1)
+        create_file(data, file: file, format: :json)
+      end
+    end
+  end
+
+  def create_file(sets, file:, format: :txt)
+    File.open(file, "w") do |fd|
+      fd << sets_to_str(sets, format: format)
+    end
+    puts "Generated file #{file}"
+  end
+
+  def sets_to_str(sets, format: :txt)
+    raise "Required Array. Given: #{sets.class}" unless sets.is_a?(Array)
+    "".tap do |str|
+      sets.each do |set|
+        str << set_to_str(set, format: format)
+      end
+    end
+  end
+
+  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?
+    end
+  end
+
+end

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

@@ -5,10 +5,10 @@ class Eco::API::UseCases::DefaultCases::SupersHierarchy < Eco::API::Common::Load
   attr_reader :session, :people, :options
 
   def main(people, session, options, usecase)
+    options[:end_get] = false
     @session = session; @options = options; @people = people
 
     save!(hierarchy)
-    exit(0)
   end
 
   private

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

@@ -5,6 +5,7 @@ class Eco::API::UseCases::DefaultCases::ToCsvCase < Eco::API::Common::Loaders::U
   attr_reader :session, :options, :people
 
   def main(people, session, options, usecase)
+    options[:end_get] = false
     @session = session; @options = options; @people = people
 
     unless people && !people.empty?
@@ -12,25 +13,62 @@ class Eco::API::UseCases::DefaultCases::ToCsvCase < Eco::API::Common::Loaders::U
       return false
     end
 
-    unless file = options[:file] || options.dig(:export, :file, :name)
-      session.logger.error("Destination file not specified")
-      return false
+    if options.dig(:export, :options, :split_schemas)
+      by_schema.each do |id, people|
+        sch_name = schemas.to_name(id)
+        prefix = sch_name ? sch_name.gsub(" ", "_") : "No_Schema"
+        create_file!("#{prefix}_#{file}", people)
+      end
+    else
+      create_file!(file, people)
     end
+  end
+
+  private
 
-    session.logger.info("going to create file: #{file}")
+  def create_file!(filename = file, data = people)
+    session.logger.info("going to create file: #{filename}")
 
-    CSV.open(file, "w") do |csv|
-      csv << spot_header
-      people.each do |person|
-        csv << target_entry_type(person).values
+    CSV.open(filename, "w") do |csv|
+      csv << spot_header(data.first)
+      data.each do |person|
+        csv << to_row(person)
       end
     end
-    exit(0)
   end
 
-  private
+  def to_row(person)
+    entry = to_entry_type(person)
+    entry.values_at(*keys(entry)).tap do |row|
+      row << schemas.to_name(person.details&.schema_id) || "No Schema"
+    end
+  end
+
+  def spot_header(person = people.first)
+    header = keys(to_entry_type(person))
+    header << "Schema"
+    header = yield(header) if block_given?
+    header = nice_header_names(header, schema: schema(person.details)) if nice_header_names?
+    header
+  end
+
+  def keys(entry)
+    entry.keys - ["freemium", "send_invites"]
+  end
+
+  def nice_header_names?
+     options.dig(:nice_header) || options.dig(:export, :options, :nice_header)
+  end
 
-  def target_entry_type(person)
+  def nice_header_names(header, schema: nil)
+    schema ||= session.schema
+    name_maps = schema.fields_by_alt_id.each_with_object({}) do |(alt_id, fld), mappings|
+      mappings[alt_id] = fld.name
+    end.merge(nice_header_maps)
+    header.map {|name| name_maps[name] ? name_maps[name] : name}
+  end
+
+  def to_entry_type(person)
     session.new_entry(person, dependencies: deps).yield_self do |person_entry|
       options.dig(:export, :options, :internal_names) ? person_entry.mapped_entry : person_entry.external_entry
     end
@@ -40,26 +78,91 @@ class Eco::API::UseCases::DefaultCases::ToCsvCase < Eco::API::Common::Loaders::U
     @deps ||= {"supervisor_id" => {people: people}}
   end
 
-  def spot_header
-    entry  = target_entry_type(people.first)
-    header = entry.keys
-
-    if options.dig(:nice_header) || options.dig(:export, :options, :nice_header)
-      name_maps = session.schema.fields_by_alt_id.transform_values do |fld|
-        fld.name
-      end.merge({
-        "policy_group_ids" => "User Group(s)",
-        "email"            => "Email",
-        "name"             => "Name",
-        "supervisor_id"    => "Manager ID",
-        "filter_tags"      => "Locations",
-        "default_tag"      => "Default Location",
-        "id"               => "ecoPortal ID"
-      })
-      header = header.map {|name| name_maps[name] ? name_maps[name] : name}
+  def file
+    @file ||= (options[:file] || options.dig(:export, :file, :name)).tap do |filename|
+      unless filename
+        session.logger.error("Destination file not specified")
+        return false
+      end
+    end
+  end
+
+  def by_schema
+    people.group_by do |person|
+      if details = person.details
+        details.schema_id
+      end
+    end.transform_values do |persons|
+      people.newFrom persons
+    end
+  end
+
+  def schema(value)
+    case value
+    when Ecoportal::API::V1::Person
+      schema(value.details&.schema_id)
+    when String
+      schemas[value]
+    when Ecoportal::API::V1::PersonDetails
+      schema(value.schema_id)
+    when Ecoportal::API::V1::PersonSchema
+      value
     end
-    header
   end
 
+  def schemas
+    session.schemas
+  end
+
+  def nice_header_maps
+    @nice_header_maps ||= {
+      "policy_group_ids"   => "User Group(s)",
+      "email"              => "Email",
+      "name"               => "Name",
+      "supervisor_id"      => "Manager ID",
+      "filter_tags"        => "Locations",
+      "default_tag"        => "Default Location",
+      "id"                 => "ecoPortal ID",
+      "external_id"        => "Reference ID (ext_id)",
+      "login_provider_ids" => "Login Methods",
+      "landing_page_id"    => "Landing Page ID",
+      "show_sidebar"       => "(pref) Sidebar Open?",
+      "show_shortcuts"     => "(pref) Link to Registers?",
+      "show_coming_soon"   => "(pref) Coming Soon List?",
+      "show_recently_visited_forms" => "(pref) Recently Visited Forms List?",
+      "show_tasks"         => "(pref) Tasks List?",
+      "show_task_bubbles"  => "(pref) Task Count Bubbles",
+      "kiosk_enabled"      => "Kiosk User?",
+      "freemium"           => "Freemium User?",
+      "files"              => "(able) on Files",
+      "reports"            => "(able) on Report Structures",
+      "data"               => "(able) on Data (hours, datasets)",
+      "organization"       => "(able) on Organization Config",
+      "pages"              => "(able) on Page/Entries",
+      "page_editor"        => "(able) page Editor Level",
+      "registers"          => "(able) on Registers",
+      "tasks"              => "(able) on Tasks",
+      "person_core"        => "(able) on People",
+      "person_core_create" => "(able) Create People?",
+      "person_core_edit"   => "(able) Edit People?",
+      "person_details"     => "(able) on People Schema Details",
+      "person_account"     => "(able) on Users",
+      "person_abilities"   => "(able) on Users' Abilities",
+      "custom_files"              => "(min) on Files",
+      "custom_reports"            => "(min) on Report Structures",
+      "custom_data"               => "(min) on Data (hours, datasets)",
+      "custom_organization"       => "(min) on Organization Config",
+      "custom_pages"              => "(min) on Page/Entries",
+      "custom_page_editor"        => "(min) page Editor Level",
+      "custom_registers"          => "(min) on Registers",
+      "custom_tasks"              => "(min) on Tasks",
+      "custom_person_core"        => "(min) on People",
+      "custom_person_core_create" => "(min) Create People?",
+      "custom_person_core_edit"   => "(min) Edit People?",
+      "custom_person_details"     => "(min) on People Schema Details",
+      "custom_person_account"     => "(min) on Users",
+      "custom_person_abilities"   => "(min) on Users' Abilities"
+    }
+  end
 
 end

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

@@ -1,53 +1,78 @@
-class Eco::API::UseCases::DefaultCases::ToCsvDetailedCase < Eco::API::Common::Loaders::UseCase
+class Eco::API::UseCases::DefaultCases::ToCsvDetailedCase < Eco::API::UseCases::DefaultCases::ToCsvCase
   name "to-csv-detailed"
   type :export
 
-  def main(people, session, options, usecase)
-    unless people && !people.empty?
-      session.logger.warn("No source people to create the file... aborting!")
-      return false
-    end
+  private
+
+  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)
+    account = person.account
+    data << account&.landing_page_id
+    data += user_preferences(person)
+    data
+  end
 
-    unless file = options[:file] || options.dig(:export, :file, :name)
-      session.logger.error("Destination file not specified")
-      return false
+  def person_supervisor(person)
+    session.micro.with_supervisor(person.supervisor_id, people) do |supervisor|
+      return supervisor ? supervisor.name : ""
     end
+  end
 
-    login_providers = session.login_providers
-    abilities       = session.presets_factory.keys
+  def user_abilities(person)
+    account_abilities = (person.account && person.account.permissions_merged) || {}
+    abilities.map {|key| account_abilities[key] || "no access"}
+  end
 
-    session.logger.info("going to create file: #{file}")
-    CSV.open(file, "w") do |csv|
-      deps    = {"supervisor_id" => {people: people}}
+  def user_permissions_custom(person)
+    account_abilities = (person.account && person.account.permissions_custom) || {}
+    abilities.map {|key| account_abilities[key] || "no access"}
+  end
 
-      person_model = people.first
-      person_entry = session.new_entry(person_model, dependencies: deps)
-      header  = person_entry.external_entry.keys
-      header += ["Subordinates"]
-      header += ["Supervisor Name"]
-      header += abilities
-      header += ["Landing Page"]
+  def user_preferences(person)
+    user_preferences = (person.account && person.account.preferences&.doc) || {}
+    preferences.map {|key| user_preferences[key] || false}
+  end
 
-      csv << header
-      people.each do |person|
-        data = session.new_entry(person, dependencies: deps).external_entry.values
+  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)
+      header << "Landing Page"
+      header += preferences
+      header
+    end
+  end
 
-        data.push(person.subordinates)
-        session.micro.with_supervisor(person.supervisor_id, people) do |supervisor|
-          data.push supervisor ? supervisor.name : ""
-        end
+  def keys(entry)
+    super(entry) + ["freemium"]
+  end
 
-        person_abilities = (person.account && person.account.permissions_custom) || {}
-        data += abilities.map {|key| person_abilities[key] || "no access"}
+  def login_providers
+    session.login_providers
+  end
 
-        if person.account && landing_id = person.account.landing_page_id
-          data.push(landing_id)
-        end
+  def abilities
+    @abilities ||= session.presets_factory.keys
+  end
 
-        csv << data
-      end
+  def abilities_header(prefix = nil)
+    abilities.map do |key|
+      prefix ? "#{prefix}_#{key}" : key
     end
-    exit(0)
+  end
+
+  def preferences
+    @preferences ||= [
+      "show_sidebar", "show_shortcuts", "show_coming_soon", "show_recently_visited_forms",
+      "show_tasks", "show_task_bubbles",
+      "kiosk_enabled"
+    ]
   end
 
 end