eco-helpers 2.0.16 → 2.0.22

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

@@ -28,7 +28,11 @@ module Eco
         end
 
         def schema(id_name)
-          @by_id.fetch(schema_id(id_name), nil)
+          self[id_name]
+        end
+
+        def [](id_name)
+          @by_id[schema_id(id_name)]
         end
 
         private

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

@@ -44,7 +44,11 @@ module Eco
         end
 
         def policy_group(id_name)
-          @by_id.fetch(policy_group_id(id_name), nil)
+          self[id_name]
+        end
+
+        def [](id_name)
+          @by_id[policy_group_id(id_name)]
         end
 
         def user_pg_ids(initial: [], final: [], non_custom: (non_custom_not_used = true; []), preserve_custom: true)

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

@@ -3,6 +3,8 @@ module Eco
     module Organization
 
       class PresetsFactory
+        ABILITIES = File.join(__dir__, 'presets_values.json')
+        INTEGRITY = File.join(__dir__, 'presets_integrity.json')
 
         class << self
 
@@ -24,44 +26,36 @@ module Eco
 
         end
 
-        ABILITIES = File.join(__dir__, 'presets_values.json')
-        INTEGRITY = File.join(__dir__, 'presets_integrity.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)
+        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
-          @presets_custom_file = presets_custom || DEFAULT_CUSTOM
-          @presets_map_file    = presets_map    || DEFAULT_MAP
+          @policy_groups = policy_groups
         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
+        # @return [Array<String>] all the abilities
+        def keys
+          self.class.abilities
+        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 valid?(preset)
+          validate(perset).length == 0
         end
 
-        # @return [Array<String>] all the abilities
-        def keys
-          abilities_model.keys
+        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
+          end
         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
@@ -79,11 +73,6 @@ module Eco
           end
         end
 
-        # unsused: only play with the given abilities
-        def empty_model
-          JSON.parse(abilities_model.to_json).transform_values {|v| nil }
-        end
-
         def preset_errors(preset)
           return "No preset given" if !preset
           errors = preset.map do |k, v|
@@ -146,7 +135,7 @@ module Eco
         end
 
         def ability_value_idx(ability, value)
-          abilities_model[ability].index(value)
+          abilities_model[ability].index(value) || -1
         end
 
         def abilities_model
@@ -163,56 +152,6 @@ module Eco
           @policy_groups
         end
 
-        def presets_custom
-          return @presets_custom if instance_variable_defined?(:@presets_custom)
-          @presets_custom = nil
-          if @presets_custom_file
-            if (file = File.expand_path(@presets_custom_file)) && File.exists?(file)
-              @presets_custom = JSON.load(File.open(file)).tap do |custom_presets|
-                errors = custom_presets.each_with_object([]) do |(key, preset), errors|
-                  if err = preset_errors(preset)
-                    errors << "{ '#{key}' preset -> #{err}}"
-                  end
-                  if err = preset_integrity(preset)
-                    errors << "{ '#{key}' preset -> #{err}}"
-                  end
-                end
-
-                fatal("File '#{file}' contains invalid presets:\n  #{errors.join("\n  ")}") if errors.length > 0
-              end
-            end
-          end
-        end
-
-        def presets_map
-          return @presets_map if instance_variable_defined?(:@presets_map)
-          @presets_map = nil
-          if @presets_map_file
-            if (file = File.expand_path(@presets_map_file)) && File.exists?(file)
-              fatal("Maps file specified without 'presets_custom.json' file. Aborting!") if !presets_custom
-              @presets_map = JSON.load(File.open(file)).tap do |map_presets|
-
-                errors = []
-                if policy_groups.length > 0
-                  errors = policy_groups.map do |pg|
-                    exists = map_presets[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 = map_presets.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
-          end
-        end
-
         def fatal(msg)
           raise msg if !@enviro
           @enviro.logger.fatal(msg)

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

@@ -48,5 +48,11 @@
         "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/organization/tag_tree.rb

@@ -42,6 +42,39 @@ module Eco
           init_hashes
         end
 
+        # Updates the tag of the current tree
+        def tag=(value)
+          @tag = value
+        end
+
+        # @return [Eco::API::Organization::TagTree]
+        def dup
+          self.class.new(as_json)
+        end
+
+        # @return [Array] with the differences
+        def diff(tagtree, differences: {}, level: 0, **options)
+          require 'hashdiff'
+          Hashdiff.diff(self.as_json, tagtree.as_json, **options.slice(:array_path, :similarity, :use_lcs))
+        end
+
+        def top?
+          depth == -1
+        end
+
+        # @return [Array[Hash]] where `Hash` is a `node` `{"tag" => TAG, "nodes": Array[Hash]}`
+        def as_json
+          nodes_json = nodes.map {|node| node.as_json}
+          if top?
+            nodes_json
+          else
+            {
+              "tag"   => tag,
+              "nodes" => nodes_json
+            }
+          end
+        end
+
         # @return [Boolean] `true` if there are tags in the node, `false` otherwise.
         def empty?
           @has_tags.empty?

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,19 @@ 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
+
+      # @return [Eco::Data::Mapper] the mappings between the internal and external attribute/property names.
+      def fields_mapper
+        return @fields_mapper if instance_variable_defined?(:@fields_mapper)
+        mappings = []
+        if map_file = config.people.fields_mapper
+          mappings = map_file ? file_manager.load_json(map_file) : []
+        end
+        @fields_mapper = Eco::Data::Mapper.new(mappings)
       end
 
       # Helper to obtain a EntryFactory
@@ -93,17 +84,16 @@ module Eco
       def entry_factory(schema: nil)
         schema = to_schema(schema) || self.schema
         return @entry_factories[schema&.id] if @entry_factories.key?(schema&.id)
-
-        mappings = []
-        if map_file = config.people.fields_mapper
-          mappings = map_file ? file_manager.load_json(map_file) : []
+        unless @entry_factories.empty?
+          @entry_factories[schema&.id] = @entry_factories.values.first.newFactory(schema: schema)
+          return @entry_factories[schema&.id]
         end
 
         @entry_factories[schema&.id] = Eco::API::Common::People::EntryFactory.new(
           enviro,
           schema:        schema,
           person_parser: config.people.parser,
-          attr_map:      Eco::Data::Mapper.new(mappings)
+          attr_map:      fields_mapper
         )
       end
 
@@ -122,11 +112,13 @@ module Eco
       # @param attr [String] type (`Symbol`) or attribute (`String`) to target a specific parser.
       # @param source [Any] source value to be parsed.
       # @param phase [Symbol] the phase when this parser should be active.
-      def parse_attribute(attr, source, phase = :internal)
+      # @param phase [Symbol] the phase when this parser should be active.
+      # @return [Object] the parsed attribute.
+      def parse_attribute(attr, source, phase = :internal, deps: {})
         unless parsers = entry_factory.person_parser
           raise "There are no parsers defined"
         end
-        parsers.parse(attr, source, phase)
+        parsers.parse(attr, source, phase, deps: deps)
       end
 
       # @see Eco::API::Common::People::EntryFactory#export
@@ -146,7 +138,7 @@ module Eco
       # @see Eco::API::Common::People::EntryFactory#new
       # @return [Eco::API::Common::People::PersonEntry] parsed entry.
       def new_entry(data, dependencies: {})
-        entry_factory.new(data, dependencies: dependencies)
+        entry_factory(schema: data&.details&.schema_id).new(data, dependencies: dependencies)
       end
 
       # @see Eco::API::Common::People::EntryFactory#entries

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

@@ -114,14 +114,16 @@ module Eco
               logger.info(msg) unless silent
 
               start_slice = Time.now
-              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
+              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
@@ -129,6 +131,22 @@ module Eco
           end
         end
 
+        def offer_retry_on(error_type, retries_left = 3, &block)
+          begin
+            block.call
+          rescue error_type => e
+            raise unless retries_left > 0
+            explanation = "Batch TimeOut. You have #{retries_left} retries left."
+            prompt_user("Do you want to retry (y/N)?", explanation, default: "Y", timeout: 10) do |response|
+              if response.upcase.start_with?("Y")
+                offer_retry_on(error_type, retries_left - 1, &block)
+              else
+                raise
+              end
+            end
+          end
+        end
+
         def str_stats(start, count)
           now     = Time.now
           secs    = (now - start).round(3)

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

@@ -297,16 +297,6 @@ module Eco
           people.default_schema = name
         end
 
-        # Specify the file with the account custom abilities presets
-        def presets_custom=(file)
-          people.presets_custom = file
-        end
-
-        # Specify the file with the usergroup to custom presets mapping
-        def presets_map=(file)
-          people.presets_map = file
-        end
-
         # @see Eco::API::Session::Config::People
         # @param (see Eco::API::Session::Config::People)
         # @return [Eco::API::Common::People::PersonParser] parser/serializer for the defined `format`.