eco-helpers 0.6.0

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

@@ -0,0 +1,62 @@
+module Eco
+  module API
+    module Common
+      module People
+        class PersonModifier < Eco::Language::Models::Modifier
+
+          WITH_DETAILS = [:contact, :details, :with_details, :schema, :with_schema]
+          NO_DETAILS   = [:no_details, :only_account]
+
+          WITH_ACCOUNT = [:user, :account, :with_account]
+          NO_ACCOUNT   = [:no_account, :only_details]
+
+          INTERNAL_PERSON = [:internal, :v0]
+          EXTERNAL_PERSON = [:external, :v1]
+
+          def reset_add_account
+            self < self.mode - (WITH_ACCOUNT | NO_ACCOUNT)
+          end
+
+          def no_details
+            self.push(:no_details)
+          end
+          
+          def add_account?
+            mode.any? { |m| WITH_ACCOUNT.include?(m) }
+          end
+
+          def no_account?
+            mode.any? { |m| NO_ACCOUNT.include?(m) }
+          end
+
+          def add_details?
+            mode.any? { |m| WITH_DETAILS.include?(m) }
+          end
+
+          def no_details?
+            mode.any? { |m| NO_DETAILS.include?(m) }
+          end
+
+          def internal?
+            bool = mode.any? { |m| INTERNAL_PERSON.include?(m) }
+            bool || !external?
+          end
+
+          def external?
+            mode.any? { |m| EXTERNAL_PERSON.include?(m) }
+          end
+
+          protected
+
+          def resolve_mode
+            modifiers = self.to_a
+            modifiers = resolve(modifiers, WITH_DETAILS | NO_DETAILS)
+            modifiers = resolve(modifiers, WITH_ACCOUNT | NO_ACCOUNT)
+            modifiers = resolve(modifiers, INTERNAL_PERSON | EXTERNAL_PERSON)
+            modifiers
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,140 @@
+module Eco
+  module API
+    module Common
+      module People
+        class PersonParser
+          CORE_ATTRS    = ["id", "external_id", "email", "name", "supervisor_id"]
+          ACCOUNT_ATTRS = ["policy_group_ids", "filter_tags", "default_tag"]
+          TYPE          = [:select, :text, :date, :number, :phone_number, :boolean, :multiple]
+
+          attr_reader :schema
+          attr_reader :details_attrs, :all_attrs
+          attr_reader :defined_attrs
+
+          def initialize(schema: nil) #), logger: nil)
+            #self.schema = schema
+            raise "Constructor needs a PersonSchema. Given: #{schema}" if schema && !schema.is_a?(Ecoportal::API::V1::PersonSchema)
+            @details_attrs = []
+            @parsers = {}
+
+            if schema
+              @schema = Ecoportal::API::Internal::PersonSchema.new(JSON.parse(schema.doc.to_json))
+              @details_attrs  = @schema&.fields.map { |fld| fld.alt_id }
+            end
+
+            @all_attrs = CORE_ATTRS + ACCOUNT_ATTRS + @details_attrs
+            #init_default_parsers if @schema
+          end
+
+          def target_attrs_core(source_attrs = nil)
+            return CORE_ATTRS if !source_attrs
+            scoped_attrs(source_attrs, CORE_ATTRS)
+          end
+
+          def target_attrs_details(source_attrs = nil)
+            return @details_attrs if ! source_attrs
+            scoped_attrs(source_attrs, @details_attrs)
+          end
+
+          def target_attrs_account(source_attrs = nil)
+            return ACCOUNT_ATTRS if !source_attrs
+            scoped_attrs(source_attrs, ACCOUNT_ATTRS)
+          end
+
+          def defined
+            @parsers.keys
+          end
+
+          def list
+            @parsers.keys
+          end
+
+          def defined_attrs
+            defined - (defined - all_attrs)
+          end
+
+          def undefined_attrs
+            all_attrs - defined_attrs
+          end
+
+          def defined?(attr)
+            !!@parsers[attr]
+          end
+
+          #def append(attr, dependencies: {}, &bloc)
+          #  @parsers[attr] = into_a(parsers[attr]).push(define_parser(attr, dependencies, &bloc))
+          #end
+
+          # merges parser overriding self for exisint parsers
+          def merge(parser)
+            return self if !parser
+            raise "Expected a PersonParser object. Given #{parser}" if !parser.is_a?(PersonParser)
+            @parsers.merge!(parser.hash)
+            self
+          end
+
+          def define_attribute(attr, dependencies: {}, &bloc)
+            @parsers[attr] = define_parser(attr, dependencies, &bloc)
+            self
+          end
+
+          def parse(attr, source, deps: {})
+            raise "There is no parser for attribute '#{attr}'" if !self.defined?(attr)
+            @parsers[attr].parse(source, dependencies: deps)
+          end
+
+          def serialize(attr, object, deps: {})
+            raise "There is no parser for attribute '#{attr}'" if !self.defined?(attr)
+            @parsers[attr].serialize(object, dependencies: deps)
+          end
+
+          protected
+
+          def hash
+            @parsers
+          end
+
+          private
+
+          def scoped_attrs(source_attrs, section_attrs)
+            direct_attrs = source_attrs & section_attrs
+            parsed_attrs = @parsers.keys & section_attrs
+            (source_attrs + parsed_attrs) & (direct_attrs + parsed_attrs)
+          end
+
+          def define_parser(attr, dependencies = {}, &definition)
+            if !valid?(attr)
+              str_attr = (attr.is_a?(Symbol) ? ":" : "") + attr.to_s
+              msg = "The attribute '#{str_attr}' is not part of core, account or target schema, or does not match any type: #{@details_attrs}"
+              raise msg
+            end
+            parser = Eco::Language::Models::AttributeParser.new(attr, dependencies: dependencies)
+            #yield(parser)
+            definition.call(parser)
+            parser
+          end
+
+          def valid?(attr)
+            (attr.is_a?(Symbol) && valid_type?(attr)) ||
+            (attr.is_a?(String) && (!@schema || valid_attr?(attr)))
+          end
+
+          def valid_attr?(attr)
+            @all_attrs.include?(attr)
+          end
+
+          def valid_type?(attr)
+            TYPE.include?(attr)
+          end
+
+          def into_a(value)
+            value = [] if value == nil
+            value = [].push(value) unless value.is_a?(Array)
+            value
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Eco
+  module API
+    module Common
+      module People
+
+        EAPI = Ecoportal::API
+        LAST = EAPI::V1
+        EXTERNAL = LAST
+        INTERNAL = EAPI::Internal
+        COMMON_API = EAPI::Common
+
+        def is_internal_person?(object)
+          object.is_a?(INTERNAL::Person)
+        end
+
+        def is_person?(object)
+          object.is_a?(EXTERNAL::Person)
+        end
+
+        def is_internal?(object)
+          object.is_a?(INTERNAL)
+        end
+
+        def is_external?(object)
+          object.is_a?(EXTERNAL)
+        end
+
+        def is_api?(object)
+          is_internal?(object) || is_external?(object)
+        end
+
+        def is_internal_people?(object)
+          object.is_a?(INTERNAL::People)
+        end
+
+        def is_people?(object)
+          object.is_a?(EXTERNAL::People)
+        end
+
+        def is_batch_operation(object)
+          object.is_a?(COMMON_API::BatchOperation)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Eco
+  module API
+    module Common
+      module Session
+      end
+    end
+  end
+end
+
+require_relative 'session/logger'
+require_relative 'session/mailer'
+require_relative 'session/s3_uploader'
+require_relative 'session/file_manager'
+require_relative 'session/environment'
+require_relative 'session/base_session'

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

@@ -0,0 +1,46 @@
+module Eco
+  module API
+    module Common
+      module Session
+        class BaseSession
+
+          include Common::People
+
+          attr_accessor :environment, :config
+          alias_method :enviro, :environment
+          alias_method :enviro=, :environment=
+
+          attr_reader  :api, :file_manager, :logger
+          alias_method :fm, :file_manager
+
+          def initialize(e)
+            e = Environment.new(e) if !e.is_a?(Environment)
+            self.environment = e if e.is_a?(Environment)
+          end
+
+          def environment=(value)
+            @environment = nil
+            @environment = value if value.is_a?(Environment)
+          end
+
+          def config
+            enviro.config
+          end
+
+          def api
+            enviro.api
+          end
+
+          def file_manager
+            enviro.file_manager
+          end
+
+          def logger
+            enviro.logger
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Eco
+  module API
+    module Common
+      module Session
+        class Environment
+
+          include Common::People
+
+          attr_reader :config
+          attr_reader :api #, :host, :version
+          attr_reader :file_manager, :logger
+
+          alias_method :fm, :file_manager
+
+          def initialize(init = {})
+            init = init.conf if init.is_a?(Environment)
+            msg = "Wrong Session::Environment initializer. Expected Hash or Environment object. Given: #{init}"
+            raise msg unless init.is_a?(SessionConfig)
+
+            @config = init
+            @file_manager = Eco::API::Common::Session::FileManager.new(enviro: self)
+            @logger = Session::Logger.new(enviro: self)
+            new_api
+          end
+
+          def new_api
+            return nil unless config.apis.active_api
+
+            log_connection = config.logger.log_connection?
+            log = log_connection ? @logger : ::Logger.new(IO::NULL)
+
+            api = config.api(log)
+
+            unless log_connection
+              logger.info("Created connection pointing to '#{config.apis.active_api.host}'")
+              api.logger.level = ::Logger::UNKNOWN
+            end
+
+            @api = api
+            api
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+module Eco
+  module API
+    module Common
+      module Session
+        class FileManager
+
+          include Eco::Data::Files
+
+          attr_reader :dir, :dir_path
+          attr_accessor :timestamp_pattern
+
+          def initialize(init = {}, enviro: nil)
+            @enviro = enviro
+            init = @enviro.config if @enviro && init.empty?
+            @timestamp_pattern = init.files.timestamp_pattern || DEFAULT_TIMESTAMP_PATTERN
+            self.dir_path = init.files.working_directory || Dir.pwd
+          end
+
+          def dir_path=(value)
+            begin
+              @dir = Eco::Data::Files::Directory.new(value)
+              @dir_path = @dir.create
+            rescue
+              logger.error("could not create or make any sense of directory '#{value}'")
+            end
+          end
+
+          def logger
+            @enviro&.logger || ::Logger.new(IO::NULL)
+          end
+
+          #####    FILE   #####
+          def file(filename, should_exist: false)
+            dir.file(filename, should_exist: should_exit)
+          end
+
+          def newest(filename)
+            dir.newest_file(file: filename)
+          end
+
+          def file_content(filename)
+            file = dir.file(filename, should_exist: true)
+            if !file
+              logger.error("Can't read from file '#{filename}' because it does not exist.")
+              return nil
+            end
+            logger.debug("Reading from file '#{file}'")
+            File.read(file)
+          end
+
+          def load_json(filename)
+            content = file_content(filename)
+            return content && JSON.parse(content)
+          end
+
+          def touch(filename, modifier = :no_stamp, mode: :string)
+            save("", filename, modifier, mode: mode)
+          end
+
+          def save(content, filename, modifier = :no_stamp, mode: :string)
+            file = dir.file(filename)
+            file = FileManager.timestamp_file(file) if modifier == :timestamp
+            mode = (mode == :binary) ? 'wb' : 'w'
+
+            FileManager.create_directory(FileManager.file_fullpath(file))
+
+            logger.debug("Writting to file '#{file}'")
+            File.open(file, mode) { |fd| fd << content }
+            return file
+          end
+
+          def save_json(data, filename, modifier = :no_stamp)
+            return save(data.to_json, filename, modifier)
+          end
+
+          # if the file does not exist, it creates it
+          def append(content, filename, mode: :string)
+            file = dir.file(filename)
+            mode = (mode == :binary) ? 'ab' : 'a'
+
+            logger.debug("Appending to file '#{file}'")
+            File.open(file, mode) { |fd| fd << content + "\n" } # '\n' won't add line
+            return file
+          end
+
+        end
+      end
+    end
+  end
+end