eco-helpers 1.0.13 → 1.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e68122d88dbb1cf0eb770576a4fbd72b5f11b5edb0f80b2889179bf7c5e88cf9
-  data.tar.gz: 8daf469f45bf214edc30a547e0b72920cb000b58b91f7eda812e4ded9ef49e5c
+  metadata.gz: 8187e0511f185e36a43a0e123938b1062045b812d747800b34e098a2c0b1bf62
+  data.tar.gz: a6f591af8ab1998a9476903e056a0f97c0ecaaaabbfdea87ceb31ef2a165570e
 SHA512:
-  metadata.gz: a2c159a86d73d46b22c23f3af90a57150b817daa6d776100455684d03bcb9eba981dd2a7f6119fe7a83d8b39f8ba570f10b2ec132973eb804b38eedbd84e541f
-  data.tar.gz: 35307777c1a5391c02ee847576e4bb2a4bf6a5f8371ee977ea2735c585fe23c90c19bfba1ddcc6d5a8cb9e64baa58c22838e1ae69c3709284db2e787412b4727
+  metadata.gz: d8b11d2f308202c4b122445ea348e7219dfe7a156f5e5d5fca7b3605c38215a1b8216a5447dce43626afa41cf28973459436594b520b4d4a491a776dc1a3e298
+  data.tar.gz: ee27de5eb9c71d394d6bc28e1e3966f8d3c88b4aeb0603c56e724b4865070bddef79175ed3b16c4aaafeb6d1474bb0fc2b768c4814039c61ba277d4b211cbf5e

data/lib/eco/api/common/people/entry_factory.rb

@@ -2,10 +2,12 @@ module Eco
   module API
     module Common
       module People
+        # Helper factory class to generate entries (input entries).
+        # @attr_reader schema [Ecoportal::API::V1::PersonSchema] person schema to be used in this entry factory
         # @attr_reader person_parser [Eco::API::Common::People::PersonParser] set of attribute, type and format parsers/serializers.
         class EntryFactory
 
-          attr_reader :person_parser
+          attr_reader :schema, :person_parser
 
           # @param schema [Ecoportal::API::V1::PersonSchema] schema of person details that the parser will be based upon.
           # @param person_parser [nil, Eco::API::Common::People::PersonParser] set of attribute, type and format parsers/serializers.

data/lib/eco/api/common/people/person_attribute_parser.rb

@@ -26,25 +26,48 @@ module Eco
             @active_when.call(source_data)
           end
 
+          # Helper to build the `active_when` condition
+          def active_when_any?(*attrs)
+            Proc.new do |source_data|
+              keys = data_keys(source_data)
+              attrs.any? {|key| keys.include?(key)}
+            end
+          end
+
+          # Helper to build the `active_when` condition
+          def active_when_all?(*attrs)
+            Proc.new do |source_data|
+              keys = data_keys(source_data)
+              attrs.all? {|key| keys.include?(key)}
+            end
+          end
+
           private
 
           # by default, an attribute paraser is active if in the entry to parse
           # the internal attribute is present
           def attribute_present(active_when)
             Proc.new do |source_data|
-              case source_data
-              when Array
-                keys = source_data
-              when Hash
-                keys = source_data.keys
-              else
-                keys = []
-              end
-
-              (source_data && keys.include?(self.attr)) ||
+              data_keys(source_data).include?(self.attr) ||
               (active_when && active_when.call(source_data))
             end
           end
+
+          # Helper to obtain the current internal named attributes of the data
+          # @param source_data [Array<String>, Hash] if `Array` those are already the `keys`, if `Hash` it gets the `keys`
+          # @return [Array<String>] `keys` of `source_data`
+          def data_keys(source_data)
+            case source_data
+            when Array
+              keys = source_data
+            when Hash
+              keys = source_data.keys
+            else
+              keys = []
+            end
+          end
+
+
         end
       end
     end

data/lib/eco/api/common/people/person_entry.rb

@@ -384,7 +384,7 @@ module Eco
 
           def fatal(msg)
             logger.fatal(msg)
-            exit
+            raise msg
           end
 
           # HELPERS

data/lib/eco/api/common/people/person_entry_attribute_mapper.rb

@@ -202,7 +202,7 @@ module Eco
 
           def fatal(msg)
             logger.fatal(msg)
-            exit
+            raise msg
           end
 
         end

data/lib/eco/api/common/people/person_factory.rb

@@ -2,9 +2,13 @@ module Eco
   module API
     module Common
       module People
+
+        # Helper factory to build `Ecoportal::API::V1::Person` or `Ecoportal::API::Internal::Person` objects
+        # @attr_reader schema [Ecoportal::API::V1::PersonSchema] person schema to be used in this person factory
+        # @attr_reader schema_attrs [Array<String>] _inernal names_ of the schema fields/attributes
         class PersonFactory
 
-          attr_reader :schema_attrs
+          attr_reader :schema, :schema_attrs
 
           def initialize(person: {}, schema: {}, account: {}, modifier: Common::People::PersonModifier.new)
             @modifier = Common::People::PersonModifier.new(modifier)

data/lib/eco/api/common/session/environment.rb

@@ -13,6 +13,8 @@ module Eco
 
           alias_method :fm, :file_manager
 
+          #@param init [Eco::API::Common::Session::Environment] object to ini the session environment
+          #@param session [Eco::API::Session, nil] the current session
           def initialize(init = {}, session:)
             init = init.conf if init.is_a?(Environment)
             msg = "Expected object Eco::API::Session::Config or Environment. Given: #{init}"
@@ -23,8 +25,6 @@ module Eco
             @session = session
             @file_manager = Eco::API::Common::Session::FileManager.new(enviro: self)
             @logger       = Eco::API::Common::Session::Logger.new(enviro: self)
-
-            new_api
           end
 
           def mailer
@@ -34,11 +34,15 @@ module Eco
           def sftp
             @sftp        ||= Eco::API::Common::Session::SFTP.new(enviro: self)
           end
-          
+
           def s3upoader
             @s3uploader  ||= Eco::API::Common::Session::S3Uploader.new(enviro: self)
           end
 
+          def api
+            @api || new_api
+          end
+
           def new_api
             return nil unless config.apis.active_api
 

data/lib/eco/api/common/session/mailer.rb

@@ -12,6 +12,10 @@ module Eco
             @enviro = enviro
           end
 
+          # Sends an email
+          # @param to [String] destination email address
+          # @param subject [String] subject of the email
+          # @param body [String] `html` or plain text message
           def mail(to:, subject:, body:)
             ses.send_email(
               destination: {

data/lib/eco/api/common/session/sftp.rb

@@ -23,8 +23,9 @@ module Eco
                 non_interactive: true
               )
             rescue Exception => e
-              logger.error("Could not open SFTP session. Possible misconfiguration: #{e}")
-              exit(1)
+              msg = "Could not open SFTP session. Possible misconfiguration: #{e}"
+              logger.error(msg)
+              raise msg
             end
             @sftp_session
           end
@@ -57,7 +58,7 @@ module Eco
           end
 
           # @see Net::SFTP::Session#rename
-          def move(fullname_source, fullname_dest, flags=nil, &callback)
+          def move(fullname_source, fullname_dest, flags=0x0001, &callback)
             sftp_session.rename!(fullname_source, fullname_dest, flags, &callback)
           end
 

data/lib/eco/api/error.rb

@@ -1,5 +1,6 @@
 module Eco
   module API
+    # To identify api server errors
     class Error < Exception
       class UnknownErrorClass < Exception
         def initialize(msg = nil, klass:)

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

@@ -94,7 +94,7 @@ module Eco
         def fatal(msg)
           raise msg if !@enviro
           @enviro.logger.fatal(msg)
-          exit
+          raise msg
         end
 
         def warn(msg)

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

@@ -184,7 +184,7 @@ module Eco
         def fatal(msg)
           raise msg if !@enviro
           @enviro.logger.fatal(msg)
-          exit
+          raise msg
         end
 
         def warn(msg)

data/lib/eco/api/session.rb

@@ -1,14 +1,9 @@
 module Eco
   module API
+    # Class to manage the current session.
+    # Central helper of resources.
     class Session < Common::Session::BaseSession
-      attr_reader   :batch
-      attr_accessor :schema
-
-      # Class to manage the current session.
-      # Central helper of resources.
-      #
-      # @attr_reader batch [Eco::API::Session::Batch] provides helper to launch batch operations.
-      # @attr_reader schema [Ecoportal::API::V1::PersonSchema] currently active schema.
+      #@param init [Eco::API::Session::Config, Eco::API::Common::Session::Environment] object to ini the session
       def initialize(init = {})
         e = init
         msg = "Expected object Eco::API::Session::Config or Eco::API::Common::Session::Environment. Given: #{init}"
@@ -16,43 +11,21 @@ module Eco
         e = Eco::API::Common::Session::Environment.new(init, session: self) if !e.is_a?(Eco::API::Common::Session::Environment)
         super(e)
 
-        logger.debug("LINE COMMAND: #{$0} #{ARGV.join(" ")}")
-
-        @batch        = Batch.new(enviro)
-        @task         = Task.new(enviro)
-
-        self.schema = config.people.default_schema || schemas.first
+        @entry_factories  = {}
+        @person_factories = {}
 
-        presets_custom_file = config.people.presets_custom
-        presets_map_file    = config.people.presets_map
-
-        @presets_factory = Eco::API::Organization::PresetsFactory.new({
-          presets_custom: file_manager.dir.file(presets_custom_file, should_exist: true),
-          presets_map:    file_manager.dir.file(presets_map_file, should_exist: true),
-          enviro:         enviro
-        })
+        logger.debug("LINE COMMAND: #{$0} #{ARGV.join(" ")}")
       end
 
       # Helper to perform multiple operations in one go.
       # @return [Eco::API::Session::Task] provides shortcuts to manage certain kind of operations.
       def do
-        @task
+        @task   ||= Task.new(enviro)
       end
 
-      def mail_to(**kargs)
-        mail.mail(**kargs)
-      end
-      
-      def s3upload(content: nil, file: nil, directory: nil)
-        if content && file
-          s3uploader.upload(file, content)
-        elsif file
-          s3uploader.upload_file(file)
-        elsif directory
-          s3uploader.upload_directory(directory)
-        else
-          logger.error("To use Session.s3upload, you must specify either directory, file or content and file name")
-        end
+      # @return [Eco::API::Session::Batch] provides helper to launch batch operations.
+      def batch
+        @batch  ||= Batch.new(enviro)
       end
 
       # @see Eco::API::Session::Config#policy_groups
@@ -75,40 +48,67 @@ module Eco
         config.schemas
       end
 
+      # @return [String, Ecoportal::API::V1::PersonSchema] current active session's schema
+      def schema
+        self.schema = config.people.default_schema || schemas.first unless @schema
+        @schema
+      end
+
       # Sets the current target `PersonSchema` of this session.
       # @note observe that it is essential for the parsers/serialisers to identify target/present attributes.
       # @param schema [String, Ecoportal::API::V1::PersonSchema] where `String` can be the _name_ or the _id_ of the schema.
       def schema=(value)
-        case value
-        when String
-          unless @schema = schemas.schema(value)
-            fatal "The schema with id or name '#{value}' does not exist"
-          end
-        when Ecoportal::API::V1::PersonSchema
-          @schema = value
+        @schema = to_schema(value)
+        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 [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
-          logger.error("Session: Missuse of 'schema=' method. Given: #{value}")
-          return
+          presets_factory.new(input)
         end
+      end
 
-        @person_factory = Eco::API::Common::People::PersonFactory.new(schema: @schema)
+      # Helper to obtain a EntryFactory
+      # @param schema [String, Ecoportal::API::V1::PersonSchema] `schema` to which associate the EntryFactory,
+      #  where `String` can be the _name_ or the _id_ of the schema.
+      # @return [Eco::API::Common::People::EntryFactory] associated to `schema`.
+      #  If `schema` is `nil` or not provided it uses the currently associated to the `session`
+      def entry_factory(schema: nil)
+        schema = to_schema(schema) || self.schema
+        return @entry_factories[schema&.id] if @entry_factories.key?(schema&.id)
 
         # TODO: check PersonEntry#to_internal and #to_external in init_attr_trackers
         # => when attr_map is avoided, it doesn't work as it should
+        mappings = []
         if map_file = config.people.fields_mapper
           mappings = map_file ? file_manager.load_json(map_file) : []
-        else
-          mappings = []
         end
-        attr_map = Eco::Data::Mapper.new(mappings)
 
-        @entry_factory = Eco::API::Common::People::EntryFactory.new({
-          schema:        @schema,
+        @entry_factories[schema&.id] = Eco::API::Common::People::EntryFactory.new({
+          schema:        schema,
           person_parser: config.people.parser,
-          attr_map:      attr_map,
+          attr_map:      Eco::Data::Mapper.new(mappings),
           logger:        logger
         })
-        self
+      end
+
+      # Helper to obtain a  PersonFactory
+      # @param schema [String, Ecoportal::API::V1::PersonSchema] `schema` to which associate the PersonFactory,
+      #  where `String` can be the _name_ or the _id_ of the schema.
+      # @return [Eco::API::Common::People::PersonFactory] associated to `schema`.
+      #  If `schema` is `nil` or not provided it uses the currently associated to the `session`
+      def person_factory(schema: nil)
+        schema = to_schema(schema) || self.schema
+        @person_factories[schema&.id] ||= Eco::API::Common::People::PersonFactory.new(schema: schema)
       end
 
       # Allows to use the defined parsers
@@ -116,48 +116,33 @@ module Eco
       # @param attr [String] type (`Symbol`) or attribute (`String`) to target a specific parser.
       # @param source [Any] source value to be parsed.
       def parse_attribute(attr, source)
-        unless parsers = @entry_factory.person_parser
+        unless parsers = entry_factory.person_parser
           raise "There are no parsers defined"
         end
         parsers.parse(attr, source)
       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 [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
-
       def export(*args)
-        @entry_factory.export(*args)
+        entry_factory.export(*args)
       end
 
       # @see Eco::API::Common::People::EntryFactory#new
       # @return [Ecoportal::API::Internal::Person]
       def new_person(**keyed_args)
-        @person_factory.new(**keyed_args)
+        person_factory.new(**keyed_args)
       end
 
       # Builds the entry for the given data.
       # @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.new(data, dependencies: dependencies)
       end
 
       # @see Eco::API::Common::People::EntryFactory#entries
       # @return [Eco::API::Common::People::Entries] collection of entries.
       def entries(*args)
-        @entry_factory.entries(*args).tap do |collection|
+        entry_factory.entries(*args).tap do |collection|
           logger.info("Loaded #{collection.length} input entries.")
         end
       end
@@ -216,6 +201,66 @@ module Eco
         job_groups.launch(simulate: simulate)
       end
 
+      # Sends an email
+      # @see Eco::API::Common::Session::Mailer#mail
+      def mail_to(**kargs)
+        mail.mail(**kargs)
+      end
+
+      # Uploads content into a file, a file or a directory to S3
+      # @see Eco::API::Common::Session::S3Uploader#upload
+      # @see Eco::API::Common::Session::S3Uploader#upload_file
+      # @see Eco::API::Common::Session::S3Uploader#upload_directory
+      # @param content [String] content to be uploaded (requires `file`)
+      # @param file [String] name of the file to be uploaded
+      # @param directory [String] name of source directory to be uploaded
+      def s3upload(content: nil, file: nil, directory: nil)
+        if content && file
+          s3uploader.upload(file, content)
+        elsif file
+          s3uploader.upload_file(file)
+        elsif directory
+          s3uploader.upload_directory(directory)
+        else
+          logger.error("To use Session.s3upload, you must specify either directory, file or content and file name")
+        end
+      end
+
+      private
+
+      # 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
+        })
+      end
+
+      # Comparer to state if 2 schemas are different
+      def same_schema? (schema1, schema2)
+        eq   = schema1&.id == schema2&.id
+        eq ||= schema1&.name&.downcase == schema2&.name&.downcase
+        schema1 && schema2 && eq
+      end
+
+      # from schema `id` or `name` to a PersonSchema object
+      def to_schema(value)
+        return nil unless value
+        sch = nil
+        case value
+        when String
+          unless sch = schemas.schema(value)
+            fatal "The schema with id or name '#{value}' does not exist."
+          end
+        when Ecoportal::API::V1::PersonSchema
+          sch = value
+        else
+          fatal "Required String or Ecoportal::API::V1::PersonSchema. Given: #{value}"
+        end
+        sch
+      end
+
     end
   end
 end