eco-helpers 2.0.12 → 2.0.17

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

@@ -2,18 +2,17 @@ class Eco::API::UseCases::DefaultCases::HrisCase < Eco::API::Common::Loaders::Us
   name "hris"
   type :sync
 
+  attr_reader :creation, :update, :supers, :leavers
+
   def main(entries, people, session, options, usecase)
     micro    = session.micro
-    creation = session.new_job("main", "create",  :create, usecase)
-    update   = session.new_job("main", "update",  :update, usecase)
-    supers   = session.new_job("post", "supers",  :update, usecase, :core)
-    leavers  = session.new_job("post", "leavers", :update, usecase, :account)
+    @creation = session.new_job("main", "create",  :create, usecase)
+    @update   = session.new_job("main", "update",  :update, usecase)
+    @supers   = session.new_job("post", "supers",  :update, usecase, :core)
+    @leavers  = session.new_job("post", "leavers", :update, usecase, :account)
 
     micro.with_each_leaver(entries, people, options) do |person|
-      leavers.add(person) do |person|
-        person.supervisor_id = nil
-        person.account       = nil if person.account
-      end
+      leavers.add(person, &method(:leavers_callback))
     end
 
     micro.with_each(entries, people, options) do |entry, person|
@@ -24,4 +23,11 @@ class Eco::API::UseCases::DefaultCases::HrisCase < Eco::API::Common::Loaders::Us
     end
   end
 
+  private
+
+  def leavers_callback(person)
+    person.supervisor_id = nil
+    person.account       = nil if person.account
+  end
+
 end

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

@@ -0,0 +1,59 @@
+class Eco::API::UseCases::DefaultCases::SupersHierarchy < Eco::API::Common::Loaders::UseCase
+  name "supers-hierarchy"
+  type :export
+
+  attr_reader :session, :people, :options
+
+  def main(people, session, options, usecase)
+    options[:end_get] = false
+    @session = session; @options = options; @people = people
+
+    save!(hierarchy)
+  end
+
+  private
+
+  def hierarchy
+    Eco::API::Common::People::SupervisorHelpers.supervisors_tree(people)
+  end
+
+  def file
+    @file ||= options.dig(:output, :file) || "supers_hierarchy.txt"
+  end
+
+  def save!(data)
+    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(tree, file:, format: :txt)
+    File.open(file, "w") do |fd|
+      fd << tree_to_str(tree, format: format)
+    end
+    puts "Generated file #{file}"
+  end
+
+  def tree_to_str(tree, lev: 0, format: :txt)
+    raise "Required Hash tree structure. Given: #{tree.class}" unless tree.is_a?(Hash)
+    "".tap do |str|
+      tree.each do |entry, subtree|
+        str << "#{"  " * lev}#{(lev > 0)? "+-#{lev}- " : ""}#{entry.name} (#{entry.external_id}|#{entry.email}|#{entry.id})\n"
+        str << tree_to_str(subtree, lev: lev + 1, format: format) unless !subtree || subtree.empty?
+      end
+    end
+  end
+
+end

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

@@ -2,44 +2,122 @@ class Eco::API::UseCases::DefaultCases::ToCsvCase < Eco::API::Common::Loaders::U
   name "to-csv"
   type :export
 
+  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?
       session.logger.warn("No source people to create the file... aborting!")
       return false
     end
 
-    unless file = options[:file] || options.dig(:export, :file, :name)
-      session.logger.error("Destination file not specified")
-      return false
-    end
-
     session.logger.info("going to create file: #{file}")
-    CSV.open(file, "w") do |csv|
-      deps   = {"supervisor_id" => {people: people}}
-      entry  = session.new_entry(people.first, dependencies: deps)
-      header = entry.external_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}
-      end
+    header = spot_header
 
+    CSV.open(file, "w") do |csv|
       csv << header
       people.each do |person|
-        csv << session.new_entry(person, dependencies: deps).external_entry.values
+        csv << to_row(person)
       end
     end
-    exit(0)
   end
 
+  private
+
+  def to_row(person)
+    entry = to_entry_type(person)
+    entry.values_at(*keys(entry))
+  end
+
+  def spot_header
+    header = keys(to_entry_type(people.first))
+    header = yield(header) if block_given?
+    header = nice_header_names(header) 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 nice_header_names(header)
+    name_maps = session.schema.fields_by_alt_id.each_with_object({}) do |(alt_id, fld), mappings|
+      mappings[alt_id] = 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",
+      "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"
+    })
+    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
+  end
+
+  def deps
+    @deps ||= {"supervisor_id" => {people: people}}
+  end
+
+  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
+
+
 end

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

@@ -1,53 +1,79 @@
-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)
+    entry = to_entry_type(person)
+    data = entry.values_at(*keys(entry))
+    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
+    super 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