eco-helpers 2.0.13 → 2.0.18

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

@@ -0,0 +1,161 @@
+class Eco::API::UseCases::DefaultCases::AbstractPolicyGroupAbilities < Eco::API::Common::Loaders::UseCase
+  name "abstract-policygroup-abilities"
+  type :export
+
+  attr_reader :session, :people, :options
+
+  def main(people, session, options, usecase)
+    options[:end_get] = false
+    @session = session; @options = options; @people = people
+
+    generate_csv!
+  end
+
+  private
+
+  def file
+    @file ||= options.dig(:output, :file) || "suggested_abilities.csv"
+  end
+
+  def generate_csv!
+    policy_groups.each_with_object({}) do |group, data|
+      data[group.id] ||= {}
+      data[group.id][:name]      = group.name
+      data[group.id][:suggested] = group_suggestions(group.id)
+      data[group.id][:percents]  = group_abilities(group.id)
+    end.yield_self do |data|
+      abilities_list = Eco::API::Organization::PresetsFactory.abilities
+      CSV.open(file, "w") do |csv|
+        csv << ["Type", "UserGroup", "ID", *abilities_list]
+        # Dump the final suggestions
+        data.each do |id, meta|
+          csv << ["Suggested", meta[:name], id, *meta[:suggested].values_at(*abilities_list)]
+        end
+        # Dump the percentaged levels of each ability
+        data.each do |id, meta|
+          analysis = meta[:percents].values_at(*abilities_list).each_with_object([]) do |levels, values|
+            values << levels.map do |level, percentil|
+              "#{level ? level : "null"} => #{percentil}"
+            end.join("\n")
+          end
+          csv << ["Analysis", meta[:name], id, *analysis]
+        end
+      end
+      puts "Generated file #{file}"
+    end
+  end
+
+  def policy_groups
+    @policy_groups ||= session.policy_groups
+  end
+
+  # Suggests 1 final set of abilities for a usergroup
+  def group_suggestions(id)
+    group_abilities(id).each_with_object({}) do |(key, levels), set|
+      data = levels.to_a.sort_by(&:last).reverse.first
+      set[key] = data ? data.shift : nil
+    end
+  end
+
+  # Cleans up each ability's levels by:
+  #   1. cutting at some minimum threshold percentage
+  #   2. directly selecting those greater than 70%
+  def group_abilities(id)
+    @group_abilities     ||= {}
+    @group_abilities[id] ||= ability_levels_percent(id).each_with_object({}) do |(ability, levels), out|
+      outstanding = nil
+      levels.select do |level, percentil|
+        outstanding ||= level if percentil >= 75
+        percentil > 15
+      end.yield_self do |filtered|
+        out[ability] =  outstanding ? filtered.slice(outstanding) : filtered
+      end
+    end
+  end
+
+  # With given the percentages of sets of abilities
+  # it abstracts the percentage of each level of each ability
+  def ability_levels_percent(id)
+    @ability_levels_percent     ||= {}
+    @ability_levels_percent[id] ||= Eco::API::Organization::PresetsFactory.abilities.each_with_object({}) do |key, out|
+      out[key] ||= {}
+      ability_sets_percent(id).each_with_object(out[key]) do |(set, percentil), levels|
+        levels[set[key]] ||= 0
+        levels[set[key]]   = (levels[set[key]] + percentil).round(2)
+      end
+    end
+  end
+
+  # Give a percentage to each set of abilities
+  def ability_sets_percent(id)
+    @ability_sets_percent     ||= {}
+    @ability_sets_percent[id] ||= scoped_relevant_raw_data(id).yield_self do |data|
+      # Transform ability sets counter to percentage
+      total     = data[:count]
+      abilities = data[:abilities]
+      data[:abilities].transform_values do |val|
+        percent(val, total)
+      end
+    end
+  end
+
+  # Get rid of data simingly irrelevant
+  def scoped_relevant_raw_data(id)
+    sp   = single_percent(id)
+    sing = single(id); mult = multiple(id)
+
+    # Scope Relevant Raw Data
+    case
+    when sp >= 3 # >= 80
+      sing
+    #when sp < 15
+    #  mult
+    else # combine
+      all_abilities = sing[:abilities].keys | mult[:abilities].keys
+      data = {count: sing[:count] + mult[:count], abilities: {}}
+      all_abilities.each_with_object(data) do |abilities, merged|
+        scount = sing[:abilities][abilities] || 0
+        mcount = mult[:abilities][abilities] || 0
+        merged[:abilities][abilities] = scount + mcount
+      end
+    end
+  end
+
+  def single_percent(id)
+    percent(single(id)[:count], count(id))
+  end
+
+  def single(id)
+    groups_abilities.dig(id, :single) ||  {count: 0, abilities: {}}
+  end
+
+  def multiple(id)
+    groups_abilities.dig(id, :multiple) ||  {count: 0, abilities: {}}
+  end
+
+  def count(id)
+    groups_abilities.dig(id, :count) || 0
+  end
+
+  def groups_abilities
+    @groups_abilities ||= people.users.each_with_object({}) do |user, groups|
+      abilities = Eco::API::Organization::PresetsFactory.all_abilities(user.account.permissions_custom)
+      ids       = user.account.policy_group_ids
+      category  = ids.count > 1 ? :multiple : :single
+
+      ids.each do |id|
+        groups[id] ||= {count: 0}
+        groups[id][:count]   += 1
+        groups[id][category] ||= {count: 0, abilities: {}}
+        groups[id][category][:count] += 1
+        groups[id][category][:abilities][abilities] ||= 0
+        groups[id][category][:abilities][abilities]  += 1
+      end
+    end
+  end
+
+  def percent(num, total)
+    (100 * num.to_f / total).round(2)
+  end
+
+end

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

@@ -0,0 +1,76 @@
+class Eco::API::UseCases::DefaultCases::AnalysePeople < Eco::API::Common::Loaders::UseCase
+  name "analyse-people"
+  type :export
+
+  attr_reader :session, :people, :options
+
+  def main(people, session, options, usecase)
+    @session = session; @options = options; @people = people
+
+    save!(cyclic_sets)
+  end
+
+  private
+
+  def identify_double_ups
+    analytics.similarity
+    
+  end
+
+  def analytics
+    @analytics ||= people.analytics
+  end
+
+  def file
+    @file ||= options.dig(:output, :file) || "analytics.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/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

@@ -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