eco-helpers 0.6.0

data/lib/eco/api/organization/policy_groups.rb

@@ -0,0 +1,51 @@
+module Eco
+  module API
+    module Organization
+      class PolicyGroups <  Eco::Language::Models::Collection
+        # build the shortcuts of Collection
+        attr_collection :id, :name
+
+        include Common::People
+
+        def initialize(policy_groups = [], klass: INTERNAL::PolicyGroup)
+          @klass = INTERNAL::PolicyGroup
+          @caches_init = false
+          super(policy_groups, klass: @klass)
+          init_caches
+        end
+
+        def to_id(name)
+          policy_group(name)&.id
+        end
+
+        def to_name(id)
+          policy_group(id)&.name
+        end
+
+        def policy_group(id_name)
+          @by_id.fetch(policy_group_id(id_name), nil)
+        end
+
+        private
+
+        def policy_group_name(id_name)
+          @by_id.fetch(id_name, nil)&.name&.downcase ||
+          @by_name.fetch(id_name&.downcase, nil)&.name&.downcase
+        end
+
+        def policy_group_id(id_name)
+          @by_name.fetch(id_name&.downcase, nil)&.id ||
+          @by_id.fetch(id_name, nil)&.id
+        end
+
+        def init_caches
+          return if @caches_init
+          @by_id   = self.map { |pg| [pg.id, pg] }.to_h
+          @by_name = self.map { |pg| [pg.name&.downcase, pg] }.to_h
+          @caches_init = true
+        end
+
+      end
+    end
+  end
+end

data/lib/eco/api/organization/preferences.rb

@@ -0,0 +1,28 @@
+module Eco
+  module API
+    module Organization
+      class Preferences
+
+        PREFERENCES_MODEL = {
+          show_sidebar: true,
+          show_shortcuts: true,
+          show_coming_soon: true,
+          show_recently_visited_forms: true,
+          show_tasks: true
+        }.to_json
+
+        PREFERENCES_REFERENCE  = File.join(__dir__, 'preferences_reference.json')
+
+        attr_reader :preferences_model, :preferences_reference
+        attr_reader :featured_preferences
+
+        def initialize(init = {})
+          @preferences_model = JSON.parse(PREFERENCES_MODEL)
+          @preferences_reference = JSON.load(File.open(PREFERENCES_REFERENCE))
+          @featured_preferences = @preferences_reference.keys
+        end
+
+      end
+    end
+  end
+end

data/lib/eco/api/organization/preferences_reference.json

@@ -0,0 +1,23 @@
+{
+  "contractor" : {
+    "show_sidebar" : "false",
+    "show_shortcuts": "true",
+    "show_coming_soon": "false",
+    "show_recently_visited_forms": "true",
+    "show_tasks" : "true"
+  },
+  "basic" : {
+    "show_sidebar" : "true",
+    "show_shortcuts": "true",
+    "show_coming_soon": "false",
+    "show_recently_visited_forms": "true",
+    "show_tasks" : "true"
+  },
+  "reviewer" : {
+    "show_sidebar" : "true",
+    "show_shortcuts": "true",
+    "show_coming_soon": "true",
+    "show_recently_visited_forms": "true",
+    "show_tasks" : "true"
+  }
+}

data/lib/eco/api/organization/presets.rb

@@ -0,0 +1,138 @@
+module Eco
+  module API
+    module Organization
+
+      class PresetsFactory
+        ABILITIES = File.join(__dir__, 'presets_values.json')
+        DEFAULT_CUSTOM = 'presets_custom.json'
+        DEFAULT_MAP   = 'presets_map.json'
+
+        def initialize(presets_custom: DEFAULT_CUSTOM, presets_map: DEFAULT_MAP, enviro: nil, policy_groups: nil)
+          @abilities  = JSON.load(File.open(ABILITIES))
+          @habilities = @abilities.map do |key, values|
+            h_values = values.map { |v| [v, true] }.to_h
+            [key, h_values]
+          end.to_h
+
+          fatal("Expecting Environment object. Given: #{enviro}") if enviro && !enviro.is_a?(API::Common::Session::Environment)
+          @enviro = enviro
+
+          policy_groups = policy_groups || @enviro&.api&.policy_groups.to_a
+          if policy_groups.is_a?(Eco::API::Organization::PolicyGroups)
+            @policy_groups = policy_groups
+          else
+            @policy_groups = Eco::API::Organization::PolicyGroups.new(policy_groups)
+          end
+
+          init_custom(presets_custom)
+          init_map(presets_map)
+        end
+
+        def new(*policy_group_ids_or_names)
+
+          names = policy_group_ids_or_names.map do |id_name|
+            @policy_groups.to_name(id_name)&.downcase
+          end.compact
+
+          if @presets_map
+            preset_names = names.map { |name| @presets_map.fetch(name, nil) }
+          else # option to do not use preset mapping (so just the policy group name)
+            preset_names = names
+          end
+          compile(*preset_names)
+        end
+
+        private
+
+        def init_custom(file = DEFAULT_CUSTOM)
+          @presets_custom = nil
+
+          return if !file
+          file = File.expand_path(file)
+
+          if File.exists?(file)
+            @presets_custom = JSON.load(File.open(file))
+
+            errors = @presets_custom.map do |key, preset|
+              (err = preset_errors(preset)) ? "{ '#{key}' preset -> #{err}}": nil
+            end.compact
+
+            fatal("File '#{file}' contains invalid presets:\n  #{errors.join("\n  ")}") if errors.length > 0
+          end
+
+        end
+
+        def init_map(file = DEFAULT_MAP)
+          @presets_map = nil
+
+          return if !file
+          file = File.expand_path(file)
+
+          if File.exists?(file)
+            fatal("Maps file specified without custom presets file. Aborting!") if !@presets_custom
+            @presets_map = JSON.load(File.open(file))
+
+            errors = []
+            if @policy_groups.length > 0
+              errors = @policy_groups.map do |pg|
+                exists = @presets_map[pg.name.downcase] || @presets_custom[pg.name.downcase]
+                exists ? nil : "'#{pg.name}'"
+              end.compact
+
+              warn("No maps or no preset for policy group(s): #{errors.join(", ")}") if errors.length > 0
+            end
+
+            errors = @presets_map.map do |source, dest|
+              @presets_custom[dest] ? nil : "'#{dest}'"
+            end.compact
+
+            warn("Unexisting mapped preset(s): #{errors.uniq.join(", ")}") if errors.length > 0
+          end
+
+        end
+
+        def fatal(msg)
+          raise msg if !@enviro
+          @enviro.logger.fatal(msg)
+          exit
+        end
+
+        def warn(msg)
+          raise msg if !@enviro
+          @enviro.logger.warn(msg)
+        end
+
+        def compile(*preset_names)
+          fatal("You need to specify an existing file for the custom presets.") if !@presets_custom
+          @presets_custom.values_at(*preset_names).compact.reduce(empty_model) do |p1, p2|
+            merge(p1, p2)
+          end
+        end
+
+        def merge(preset1, preset2)
+          @abilities.map do |key, values|
+            idx = [
+              values.index(preset1[key]),
+              values.index(preset2[key])
+            ].compact.max
+            [key, idx && values[idx]]
+          end.to_h
+        end
+
+        def empty_model
+          JSON.parse(@abilities.to_json).transform_values {|v| nil }
+        end
+
+        def preset_errors(preset)
+          return "No preset given" if !preset
+          errors = preset.map do |k, v|
+            @habilities.dig(k, v) ? nil : "#{k}:#{v}"
+          end.compact
+          return " unknown: {#{errors.join(", ")}}" if errors.length > 0
+          nil
+        end
+      end
+
+    end
+  end
+end

data/lib/eco/api/organization/presets_backup.rb

@@ -0,0 +1,220 @@
+module Eco
+  module API
+    module Account
+
+      #TODO set rules, make Presets immutable, and init from config
+      class PresetsFactory
+        ABILITIES = File.join(__dir__, 'presets_values.json')
+        DEFAULT_CUSTOM = 'presets_custom.json'
+        DEFAULT_MAPS   = 'presets_map.json'
+
+        def initialize(init = {}, policy_groups: [])
+          @abilities = JSON.load(File.open(ABILITIES))
+
+          init_custom(init)
+          init_maps(init)
+
+          @policy_groups         = policy_groups
+          @policy_groups_by_id   = policy_groups.map{ |pg| [pg.id, pg] }.to_h
+          @policy_groups_by_name = policy_groups.map { |pg| [pg.name&.downcase, pg] }.to_h
+        end
+
+        def new(*policy_group_ids_or_names)
+          names = policy_group_ids_or_names.map { |id_name| policy_group_name(id_name) }
+          preset_names = names.map   { |name| @presets_map.fetch(name, nil)   }
+          # validate
+          compile(*preset_names)
+        end
+
+        private
+
+        def policy_group_name(id_name)
+          @policy_groups_by_id.fetch(id_name, nil)&.name&.downcase ||
+          @policy_groups_by_name.fetch(id_name&.downcase, nil)&.name&.downcase
+        end
+
+        def init_custom(init = {})
+          file = File.expand_path(init.fetch('presets_custom', DEFAULT_CUSTOM))
+          @presets_custom = JSON.load(File.open(file))
+        end
+
+        def init_maps(init = {})
+          file = File.expand_path(init.fetch('presets_map', DEFAULT_MAPS))
+          @presets_map = JSON.load(File.open(file))
+        end
+
+        def compile(*preset_names)
+          @presets_custom.values_at(*preset_names).reduce(empty_model) do |p1, p2|
+            merge(p1, p2)
+          end
+        end
+
+        def merge(preset1, preset2)
+          @abilities.map do |key, values|
+            idx = [
+              values.index(preset1[key]),
+              values.index(preset2[key])
+            ].compact.max
+            [key, idx && values[idx]]
+          end.to_h
+        end
+
+        def empty_model
+          JSON.parse(@abilities.to_json).transform_values {|v| nil }
+        end
+
+      end
+
+      class Presets
+        DEFAULT_PRESET = "basic"
+        PRESETS_VALUES = File.join(__dir__, 'presets_values.json')
+        PRESETS_REFERENCE  = File.join(__dir__, 'presets_reference.json')
+
+        attr_reader :default
+        attr_reader :presets_model, :presets_values, :presets_reference
+        attr_reader :native_presets, :featured_presets, :all_presets
+        attr_reader :rules
+        def initialize(init = {})
+          init = {} if !init || !init.is_a?(Hash)
+
+          @presets_values = JSON.load(File.open(PRESETS_VALUES))
+          # get the index of each value of each ability (so we can compare for highest and lowest)
+          @presets_values_hashed = JSON.parse(@presets_values.to_json) \
+            .transform_values {|v| Hash[v.map.with_index.to_a] }
+
+          @presets_model = self.empty_model
+          @presets_reference = init.fetch('reference', JSON.load(File.open(PRESETS_REFERENCE)))
+          @native_presets = ["read_only", "forms", "editor", "administrator", "custom"]
+          @all_presets = @presets_reference.keys
+          @featured_presets = @all_presets - @native_presets
+          @default = init.fetch("default", DEFAULT_PRESET)
+
+          self.set_rules(init.fetch('rules', nil))
+        end
+
+        def set_rules(rules)
+          @rules = rules
+        end
+
+        def empty_model
+          JSON.parse(@presets_values.to_json).transform_values {|v| nil }
+        end
+
+        def is_custom?(preset_name)
+          return (!preset_name || preset_name == "custom")
+        end
+
+        def find_preset(preset)
+          found = @all_presets.select { |ref|
+            preset_ref = @presets_reference.fetch(ref, nil)
+            presets_equal?(preset, preset_ref)
+          }
+          return found.switch()
+        end
+
+        # returns a new hash with presets defaulting to a preset profile
+        def new_model(default = nil)
+          presets_sample = @presets_reference.fetch(default, @presets_model)
+          JSON.parse(presets_sample.to_json)
+        end
+
+        def default_model
+          self.new_model(@default)
+        end
+
+        def get_models(presets_list = [])
+          presets_list.map {|v| self.new_model(v) }
+        end
+
+        def presets_equal?(preset1, preset2)
+        return false if !preset1 || !preset2
+          all_keys = self.new_model.keys
+          # "no access" can / should be nil; or not specified (notice that it is not so for updates)
+          return !all_keys.empty? && all_keys.all? { |key| preset1.fetch(key, nil) == preset2.fetch(key, nil) }
+        end
+
+        # among a set of presets, it returns the presets doc
+        # for each flag, it contains the highest (or lowest) of all the input presets
+        # by giving at least the abilities of the preset min: to each flag
+        # and / or the max: abilities one if specified
+        def merge (presets, highest: true, min: nil, max: nil)
+          max_preset_model = max ? self.new_model(max) : nil
+          min = self.default if min == "default"
+
+          return self.new_model(min).map do |k_flag, min_ability|
+            levels = presets.map {|pre| ability_level(k_flag, pre[k_flag]) }
+
+            min_lev = ability_level(k_flag, min_ability)
+            max_lev = Float::INFINITY
+            if max
+              max_ability = max_preset_model.fetch(k_flag, nil)
+              max_lev = ability_level(k_flag, max_ability)
+            end
+            if highest
+              level = highest(levels, flag: k_flag, min: min_lev, max: max_lev)
+            else
+              level = lowest(levels, flag: k_flag, min: min_lev, max: max_lev)
+            end
+
+            [k_flag, level_ability(k_flag, level)]
+          end.to_h
+        end
+
+        def self.test(num = 2, min: "random", max: "random")
+          account_presets = self.new
+          all_presets = account_presets.all_presets
+
+          num = rand(2..5) if num == "random"
+          list_types = all_presets.sample(num)
+
+          min = rand > 0.5 if min == "random"
+          max = rand > 0.5 if max == "random"
+
+          min = all_presets.sample(1).first if (!!min === min) && min
+          max = all_presets.sample(1).first if (!!max === max) && max
+
+          presets = account_presets.get_models(list_types)
+
+          puts "min: #{min}; max: #{max}" if min || max
+          puts "chosen presets: #{list_types}"
+          puts "pre-merge models: #{presets}"
+          pp account_presets.merge(presets)  unless min || max
+          pp account_presets.merge(presets, min: min, max: max) if min && max
+          pp account_presets.merge(presets, min: min) if min && !max
+          pp account_presets.merge(presets, max: max) if !min && max
+        end
+
+        private
+
+        # given an array list of values for a flag
+        # it returns the highest of all the abilities
+        def highest(list, flag:, min: 0, max: Float::INFINITY)
+          m = (list + [min]).max
+          return (max < m)? max : m
+        end
+
+        # it returns the highest of all the values
+        def lowest(list, flag:, min: 0, max: Float::INFINITY)
+          m = (list + [max]).min
+          return (min > m)? min : m if min
+          return m
+        end
+
+        # given an ability of a flag
+        # it returns the level of that flag
+        def ability_level(flag, ability)
+          return 0 unless ability
+          return @presets_values_hashed.dig(flag, ability)
+        end
+
+        # given a level of one flag
+        # it returns the ability of that flag
+        def level_ability(flag, level)
+          return nil unless level && level > 0
+          return @presets_values[flag][level]
+        end
+
+      end
+    end
+  end
+end