eco-helpers 2.0.12 → 2.0.17

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

@@ -4,112 +4,58 @@ module Eco
 
       class PresetsFactory
         ABILITIES = File.join(__dir__, 'presets_values.json')
-        DEFAULT_CUSTOM = 'presets_custom.json'
-        DEFAULT_MAP    = 'presets_map.json'
+        INTEGRITY = File.join(__dir__, 'presets_integrity.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
+        class << self
 
-          fatal("Expecting Environment object. Given: #{enviro}") if enviro && !enviro.is_a?(Eco::API::Common::Session::Environment)
-          @enviro = enviro
+          def all_abilities(hash = {})
+            Hash[abilities.each_with_object(nil).to_a].merge(hash)
+          end
 
-          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)
+          def abilities_model
+            @abilities_model ||= JSON.load(File.open(ABILITIES))
           end
 
-          init_custom(presets_custom)
-          init_map(presets_map)
-        end
+          def integrity_model
+            @integrity_model ||= JSON.load(File.open(INTEGRITY))
+          end
 
-        def new(*policy_group_ids_or_names)
+          def abilities
+            @abilities ||= abilities_model.keys
+          end
 
-          names = policy_group_ids_or_names.map do |id_name|
-            @policy_groups.to_name(id_name)&.downcase
-          end.compact
+        end
 
-          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)
+        def initialize(enviro: nil, policy_groups: nil)
+          fatal("Expecting Environment object. Given: #{enviro}") if enviro && !enviro.is_a?(Eco::API::Common::Session::Environment)
+          @enviro        = enviro
+          @policy_groups = policy_groups
         end
 
         # @return [Array<String>] all the abilities
         def keys
-          @abilities.keys
+          self.class.abilities
         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
-
+        def valid?(preset)
+          validate(perset).length == 0
         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
+        def validate(preset)
+          [].tap do |errors|
+            if err = preset_errors(preset)
+              errors << "{ '#{key}' preset -> #{err}}"
+            end
+            if err = preset_integrity(preset)
+              errors << "{ '#{key}' preset -> #{err}}"
             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)
-          raise msg
         end
 
-        def warn(msg)
-          raise msg if !@enviro
-          @enviro.logger.warn(msg)
-        end
+        private
 
-        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({}) do |p1, p2|
+        def compile(*presets)
+          presets.compact.reduce({}) do |p1, p2|
             merge(p1, p2)
           end
         end
@@ -117,7 +63,7 @@ module Eco
         def merge(preset1, preset2)
           keys = preset1.keys | preset2.keys
 
-          @abilities.each_with_object({}) do |(key, values), result|
+          abilities_model.each_with_object({}) do |(key, values), result|
             next unless keys.include?(key)
             idx = [
               values.index(preset1[key]),
@@ -127,19 +73,96 @@ module Eco
           end
         end
 
-        # unsused: only play with the given abilities
-        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}"
+            value_exists?(k, v) ? nil : "#{k}:#{v}"
           end.compact
-          return " unknown: {#{errors.join(", ")}}" if errors.length > 0
+          return " Unknown: {#{errors.join(", ")}}" if errors.length > 0
           nil
         end
+
+        def preset_integrity(preset)
+          preset.each_with_object([]) do |(ability, value), errors|
+            next unless checks = integrity_model[ability]
+
+            suberrors = []
+
+            checks.each do |check|
+              next unless check["value"] == value
+              check["conditions"].each do |cond, targets|
+                case cond
+                when "at_least"
+                  targets.each do |other, minimum|
+                    unless (ability_value_idx(other, minimum) <= ability_value_idx(other, preset[other]))
+                      suberrors << "'#{other}' should be at least '#{minimum}'"
+                    end
+                  end
+                when "one_of"
+                  unless targets.any? {|other, expected| preset[other] == expected}
+                    suberrors << targets.each_with_object([]) do |(other, expected), out|
+                      out << "'#{other}': '#{expected}'"
+                    end.join(", ").yield_self do |msg|
+                      "there should be at least one of: {#{msg}}"
+                    end
+                  end
+                else
+                  warn("Unsuported integrity condition statement '#{cond}' in '#{ability}' with level '#{value}'")
+                end
+              end
+            end
+
+            if suberrors.length > 0
+              errors << "Incorrect value '#{value}' for '#{ability}' - reasons: {#{suberrors.join(", ")}}"
+            end
+          end.yield_self do |errors|
+            " Integrity errors: { #{errors.join(", ")} }" if errors.length > 0
+          end
+        end
+
+        def integrity_model
+          self.class.integrity_model
+        end
+
+        def value_exists?(ability, value)
+          abilities_model_inverted.dig(ability, value)
+        end
+
+        def abilities_model_inverted
+          @abilities_model_inverted ||= abilities_model.each_with_object({}) do |(key, values), out|
+            out[key] = values.each_with_object({}) {|v, h| h[v] = true }
+          end
+        end
+
+        def ability_value_idx(ability, value)
+          abilities_model[ability].index(value) || -1
+        end
+
+        def abilities_model
+          self.class.abilities_model
+        end
+
+        def policy_groups
+          return @policy_groups if @policy_groups.is_a?(Eco::API::Organization::PolicyGroups)
+          @policy_groups ||= @enviro&.api&.policy_groups.to_a
+
+          unless @policy_groups.is_a?(Eco::API::Organization::PolicyGroups)
+            @policy_groups = Eco::API::Organization::PolicyGroups.new(@policy_groups)
+          end
+          @policy_groups
+        end
+
+        def fatal(msg)
+          raise msg if !@enviro
+          @enviro.logger.fatal(msg)
+          raise msg
+        end
+
+        def warn(msg)
+          raise msg if !@enviro
+          @enviro.logger.warn(msg)
+        end
+
       end
 
     end

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

@@ -0,0 +1,58 @@
+{
+  "person_core_create": [
+    { "value": "create", "conditions": {
+        "at_least": {"person_core": "view_people_manager"}
+      }
+    }
+  ],
+  "person_core_edit": [
+    { "value": "edit", "conditions": {
+        "at_least": {"person_core": "view_people_manager"}
+      }
+    }
+  ],
+  "person_details": [
+    { "value": "view", "conditions": {
+        "at_least": {"person_core": "attach"}
+      }
+    },
+    { "value": "edit_public", "conditions": {
+        "one_of": {
+          "person_core_edit":   "edit",
+          "person_core_create": "create"
+        }
+      }
+    },
+    { "value": "view_private", "conditions": {
+        "at_least": {"person_core": "attach" }
+      }
+    },
+    { "value": "edit_private", "conditions": {
+        "one_of": {
+          "person_core_edit":   "edit",
+          "person_core_create": "create"
+        }
+      }
+    }
+  ],
+  "person_account": [
+    { "value": "view", "conditions": {
+        "at_least": {"person_core": "attach" }
+      }
+    },
+    { "value": "create", "conditions": {
+        "at_least": {"person_core_create": "create"}
+      }
+    },
+    { "value": "edit", "conditions": {
+        "at_least": {"person_core_edit": "edit"}
+      }
+    }
+  ],
+  "person_abilities": [
+    { "value": "view", "conditions": {
+        "at_least": {"person_core_edit": "edit"}
+      }
+    }
+  ]
+}

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

@@ -2,14 +2,15 @@
   "files": [null, "download", "upload", "browse", "administrate"],
   "data": [null, "view", "update", "administrate", "implement"],
   "reports": [null, "view", "edit", "administrate"],
+  "pages": [null, "view", "update", "create", "administrate"],
+  "page_editor": [null, "basic", "intermediate", "advanced", "implement"],
+  "registers": [null, "view", "dashboard", "administrate", "implement"],
   "tasks": [null, "reassign_self", "reassign", "administrate"],
   "organization": [null, "view", "administrate", "implement"],
   "person_core": [null, "attach", "view_people_manager", "dashboard"],
   "person_core_create": [null, "create"],
   "person_core_edit": [null, "edit"],
-  "person_account": [null, "view", "create", "edit"],
   "person_details": [null, "view", "edit_public", "view_private", "edit_private"],
-  "pages": [null, "view", "update", "create", "administrate"],
-  "page_editor": [null, "basic", "intermediate", "advanced", "implement"],
-  "registers": [null, "view", "dashboard", "administrate", "implement"]
+  "person_account": [null, "view", "create", "edit"],
+  "person_abilities": [null, "view", "edit"]
 }

data/lib/eco/api/policies/default_policies/99_user_access_policy.rb

@@ -12,7 +12,6 @@ class Eco::API::Policies::DefaultPolicies::UserAccess < Eco::API::Common::Loader
     people.each do |person|
       remove_account_when_no_email!(person)    if person.email.to_s.empty?
       person.account.policy_group_ids = defid  if no_policy_group_ids?(person)
-      refresh_abilities!(person)
     end
 
     warn_account_removal!
@@ -40,39 +39,10 @@ class Eco::API::Policies::DefaultPolicies::UserAccess < Eco::API::Common::Loader
     return !!person.original_doc["account"]
   end
 
-  def refresh_abilities!(person)
-    return nil if options.dig(:exclude, :abilities)
-    return nil unless account = person.account
-    account.permissions_custom = session.new_preset(person)
-    account.permissions_custom = min_abilities if no_abilities?(person)
-  end
-
   def no_policy_group_ids?(person)
     (account = person.account) &&  account.policy_group_ids.empty?
   end
 
-  def no_abilities?(person)
-    return true unless account = person.account
-    account.permissions_custom && account.permissions_custom.values.all?(&:nil?)
-  end
-
-  def min_abilities
-    {
-      "files"         => "upload",
-      "data"          => nil,
-      "reports"       => nil,
-      "pages"         => "create",
-      "page_editor"   => "basic",
-      "registers"     => "view",
-      "organization"  => nil,
-      "person_core"         => "attach",
-      "person_core_edit"    => nil,
-      "person_core_create"  => nil,
-      "person_details"      => "view",
-      "person_account"      => nil
-    }
-  end
-
   def defid
     @defid ||= policy_groups.to_id([default_group]).compact
   end

data/lib/eco/api/session.rb

@@ -61,28 +61,9 @@ module Eco
         self
       end
 
-      # Builds the presets using the usergroup ids of the input.
-      # @note for each flag/ability it will take the highest among those mapped for the present usergroups.
-      # @param input [Ecoportal::API::Internal::Person, Array<String>] the array should be of usegroup names or ids.
-      # @return [Hash] with custom presets.
-      def new_preset(input)
-        case input
-        when Ecoportal::API::Internal::Person
-          presets_factory.new(*input&.account&.policy_group_ids)
-        when Array
-          presets_factory.new(*input)
-        else
-          presets_factory.new(input)
-        end
-      end
-
       # Helper to state the abilities that a person should have with given their usergroups
       def presets_factory
-        @presets_factory ||= Eco::API::Organization::PresetsFactory.new({
-          presets_custom: file_manager.dir.file(config.people.presets_custom, should_exist: true),
-          presets_map:    file_manager.dir.file(config.people.presets_map,    should_exist: true),
-          enviro:         enviro
-        })
+        @presets_factory ||= Eco::API::Organization::PresetsFactory.new(enviro: enviro)
       end
 
       # Helper to obtain a EntryFactory

data/lib/eco/api/session/batch.rb

@@ -105,25 +105,57 @@ module Eco
           iterations = (data.length.to_f / per_page).ceil
 
           Eco::API::Session::Batch::Status.new(enviro, queue: data, method: method).tap do |status|
+            start_time  = Time.now
+            start_slice = Time.now; slice = []
             data.each_slice(per_page) do |slice|
-              msg = "starting batch '#{method}' iteration #{iteration}/#{iterations}, with #{slice.length} entries of #{data.length} -- #{done} done"
+              msg  = "starting batch '#{method}' iteration #{iteration}/#{iterations},"
+              msg += " with #{slice.length} entries of #{data.length} -- #{done} done"
+              msg += " (last: #{str_stats(start_slice, slice.length)}; total: #{str_stats(start_time, done)})"
               logger.info(msg) unless silent
 
-              people_api.batch do |batch|
-                slice.each do |person|
-                  batch.public_send(method, person) do |response|
-                    faltal("Request with no response") unless !!response
-                    status[person] = response
+              start_slice = Time.now
+              offer_retry_on(Ecoportal::API::Errors::TimeOut) do
+                people_api.batch do |batch|
+                  slice.each do |person|
+                    batch.public_send(method, person) do |response|
+                      faltal("Request with no response") unless !!response
+                      status[person] = response
+                    end
                   end
-                end
-              end # next batch
+                end # end batch
+              end
 
-              iteration += 1
-              done += slice.length
+              iteration  += 1
+              done       += slice.length
             end # next slice
           end
         end
 
+        def offer_retry_on(error_type, retries_left = 3, &block)
+          begin
+            block.call
+          rescue error_type => e
+            raise unless retries_left > 0
+            print "Batch TimeOut. You have #{retries_left} retries left. Do you want to retry (y/N)? "
+            if (res = STDIN.gets.chomp) && res[0].downcase == "y"
+              offer_retry_on(error_type, retries_left - 1, &block)
+            else
+              raise
+            end
+          end
+        end
+
+        def str_stats(start, count)
+          now     = Time.now
+          secs    = (now - start).round(3)
+          if secs > 0.0
+            per_sec = (count.to_f / secs).round(2)
+            "#{secs}s -> #{per_sec} people/s"
+          else
+            " -- "
+          end
+        end
+
       end
     end
   end