eco-helpers 0.6.0

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

@@ -0,0 +1,105 @@
+module Eco
+  module API
+    module Common
+      module Session
+        class Logger
+          DEFAULT_TIMESTAMP_PATTERN = '%Y-%m-%dT%H:%M:%S'
+
+          def initialize(console_level: nil, file_level: ::Logger::DEBUG, log_file: nil, timestamp_console: false, enviro: nil)
+            raise "Required Environment object (enviro:). Given: #{enviro}" if enviro && !enviro.is_a?(Eco::API::Common::Session::Environment)
+            @enviro = enviro
+
+            timestamp_console = fetch_timestamp_console(timestamp_console)
+            @console_logger = ::Logger.new(STDOUT).tap do |_logger|
+              _logger.formatter = proc do |severity, datetime, progname, msg|
+                str_timestamp = timestamp_console ? "#{datetime.strftime(DEFAULT_TIMESTAMP_PATTERN)} >" : ""
+                "#{severity.to_s[0]}: #{str_timestamp} #{msg}\n"
+              end
+              _logger.level = fetch_console_level(console_level)
+            end
+
+            if log_file = fetch_log_file(log_file)
+              @file_logger = ::Logger.new(log_file).tap do |_logger|
+                _logger.formatter = proc do |severity, datetime, progname, msg|
+                  "#{severity.to_s[0]}: #{datetime.strftime(DEFAULT_TIMESTAMP_PATTERN)} > #{msg}\n"
+                end
+                _logger.level = fetch_file_level(file_level)
+              end
+            end
+          end
+
+          def debug(*args, &block)
+            log(:debug, *args, &block)
+          end
+
+          def info(*args, &block)
+            log(:info, *args, &block)
+          end
+
+          def warn(*args, &block)
+            return log(:warn, *args, &block)
+          end
+
+          def error(*args, &block)
+            return log(:error, *args, &block)
+          end
+
+          def fatal(*args, &block)
+            return log(:fatal, *args, &block)
+          end
+
+          def unkown(msg, &block)
+            return log(:unkown, *args, &block)
+          end
+
+          def << (msg)
+            @console_logger << msg unless !@console_logger
+            @file_logger << msg    unless !@file_logger
+          end
+
+          def close()
+            @console_logger.close unless !@console_logger
+            @file_logger.close    unless !@file_logger
+          end
+
+          def add(*args)
+            @console_logger.add(*args) unless !@console_logger
+            @file_logger.add(*args)    unless !@file_logger
+          end
+
+          private
+
+          def log(level, *args, &block)
+            @console_logger.send(level, *args, &block) unless !@console_logger
+            @file_logger.send(level, *args, &block) unless !@file_logger
+          end
+
+          def config
+            @enviro.config || {}
+          end
+
+          def fetch_timestamp_console(value)
+            value || config.logger.timestamp_console
+          end
+
+          def fetch_console_level(value)
+            value || config.logger.console_level || ::Logger::INFO
+          end
+
+          def fetch_file_level(value)
+            value || config.logger.file_level || ::Logger::DEBUG
+          end
+
+          def fetch_log_file(log_file)
+            if log_file ||= config.logger.file
+              log_file = @enviro.file_manager.dir.file(log_file) if @enviro
+              FileManager.create_directory(log_file, includes_file: true)
+            end
+            log_file
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+require 'aws-sdk-ses'
+require 'dotenv/load'
+
+module Eco
+  module API
+    module Common
+      module Session
+        class Mailer
+
+          def initialize (enviro:)
+            raise "Required Environment object (enviro:). Given: #{enviro}" if enviro && !enviro.is_a?(Eco::API::Common::Session::Environment)
+            @enviro = enviro
+          end
+
+          def mail(to:, subject:, body:)
+            ses.send_email(
+              destination: {
+                to_addresses: [to].flatten,
+              },
+              source:  fetch_from,
+              message: {
+                subject: {
+                  charset: "UTF-8",
+                  data: subject,
+                },
+                body: {
+                  # NOTE - html: will let you send html instead
+                  # you can use both at once if you like
+                  text: {
+                    charset: "UTF-8",
+                    data: body
+                  }
+                }
+              }
+            ).tap do |response|
+              logger.debug("Sent email to #{to} (MessageId: #{response.message_id})")
+            end
+          end
+
+          private
+
+          def ses
+            begin
+              @ses ||= Aws::SES::Client.new(
+                access_key_id:     fetch_access_key_id,
+                secret_access_key: fetch_secret_access_key,
+                region:            fetch_region
+              )
+            rescue Exception => e
+              logger.error("Trying to send an email with wrong email configuration: #{e}")
+            end
+            @ses
+          end
+
+          def logger
+            @enviro&.logger || ::Logger.new(IO::NULL)
+          end
+
+          def config
+            @enviro.config || {}
+          end
+
+          def fetch_from(value = nil)
+            value || config.mailer.from
+          end
+
+          def fetch_access_key_id
+            config.mailer.access_key_id || ENV['AWS_ACCESS_KEY_ID']
+          end
+
+          def fetch_secret_access_key
+            config.mailer.secret_access_key || ENV['AWS_SECRET_ACCESS_KEY']
+          end
+
+          def fetch_region
+            config.mailer.region || ENV['AWS_REGION']
+          end
+
+          def fetch_server
+            config.mailer.server
+          end
+
+          def fetch_message_id_domain
+            config.mailer.message_id_domain
+          end
+
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+require 'aws-sdk-s3'
+require 'dotenv/load'
+
+module Eco
+  module API
+    module Common
+      module Session
+        class S3Uploader
+          attr_reader :prefix
+
+          def initialize (enviro:)
+            raise "Required Environment object (enviro:). Given: #{enviro}" if enviro && !enviro.is_a?(Eco::API::Common::Session::Environment)
+            @enviro    = enviro
+            @prefix    = fetch_prefix
+            @timestamp = Time.now.iso8601
+          end
+
+          def upload(filename, content)
+            if obj = new_s3_object(filename)
+              log_upload(obj) do
+                obj.put(body: content)
+              end
+            end
+            return full_path(obj)
+          end
+
+          def upload_file(path)
+            File.open(path, "rb") do |f|
+              upload(File.basename(path), f)
+            end
+          end
+
+          def upload_directory(path)
+            prefix = File.expand_path(File.join(path, ".."))
+            Dir.glob(File.join(path, "**/*")).sort.map do |file|
+              next unless File.file?(file) # Skip directories
+              key = file.sub(prefix,"").gsub(/\\/,"/").sub(/^\/+/,"")
+
+              File.open(file, "rb") do |f|
+                upload(key, f)
+              end
+            end.compact
+          end
+
+          private
+
+          def full_path(obj)
+            return "s3://#{bucket.name}/#{obj.key}" if obj
+          end
+
+          def bucket
+            begin
+              @bucket ||= Aws::S3::Resource.new(
+                access_key_id:     fetch_access_key_id,
+                secret_access_key: fetch_secret_access_key,
+                region:            fetch_region
+              ).bucket(fetch_bucket)
+            rescue Exception => e
+              logger.error("Trying to upload to S3 with wrong configuration: #{e}")
+            end
+            @bucket
+          end
+
+          def session_path
+            ["scripts", @prefix, @timestamp].join("/")
+          end
+
+          def new_s3_object(filename)
+            file_path = [session_path, filename].join("/")
+            bucket&.object(file_path)
+          end
+
+          def log_upload(obj)
+            yield
+            logger.debug("Uploaded #{full_path(obj)}")
+          end
+
+          def logger
+            @enviro&.logger || ::Logger.new(IO::NULL)
+          end
+
+          def config
+            @enviro.config || {}
+          end
+
+          def fetch_bucket
+            config.s3bucket.name
+          end
+
+          def fetch_prefix
+            config.s3bucket.prefix
+          end
+
+          def fetch_access_key_id
+            config.s3bucket.access_key_id || ENV['AWS_ACCESS_KEY_ID']
+          end
+
+          def fetch_secret_access_key
+            config.s3bucket.secret_access_key || ENV['AWS_SECRET_ACCESS_KEY']
+          end
+
+          def fetch_region
+            config.s3bucket.region || ENV['AWS_REGION']
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Eco
+  module API
+    module Common
+      module VersionPatches
+      end
+    end
+  end
+end
+
+#require_relative 'version_patches/base_model.rb'
+require_relative 'version_patches/external_person.rb'

data/lib/eco/api/common/version_patches/external_person.rb

@@ -0,0 +1,11 @@
+module Ecoportal
+  module API
+    class V1
+      class Person < Common::BaseModel
+        def sync
+          @original_doc = JSON.parse(@doc.to_json)
+        end
+      end
+    end
+  end
+end

data/lib/eco/api/eco_faker.rb

@@ -0,0 +1,59 @@
+module Eco
+  module API
+    # faker object
+    @@faker = nil
+    class EcoFaker
+      @@api = nil
+      @org = nil
+      # attr_accessor
+      attr_reader :org
+      def initialize(init = {})
+        set_settings(init)
+      end
+      # allows to change certain configuration settings on an existing Faker instance object
+      def set_settings (init = {})
+        @today = (aux = init['today'])? aux : Time.now
+        api = init.fetch('api', nil)
+        @@api = api.instance_of?(Ecoportal::API::Internal) && api
+        # this will initialize org basics (i.e. people_schemas, policy_groups, login_providers)
+        @org = Organization.new(init)
+      end
+      def newPerson ()
+
+      end
+      def modifyPerson(person)
+
+      end
+      private
+    end
+
+    def self.new(init = {})
+      @@faker = EcoFaker.new(init)
+    end
+
+    class FakePerson < Ecoportal::API::Internal::Person
+      @@faker
+      def initialize(faker, *args)
+        raise "You must initialize the faker first" unless faker && faker.instance_of(Faker)
+        @@faker = faker
+        super(*args)
+        @@faker.set_details
+      end
+    end
+
+    class FakeField
+      @@types = ["boolean", "number", "text", "select", "date", "phone_number"]
+      @@multiple = false
+      attr_accessor :type, :multiple
+      #attr_reader
+      def initialize (init = {})
+        init_values_generator(init)
+      end
+      private
+      def init_values_faker (init = {})
+        include
+        @fake_values = API::Data::Random::ValuesGenerator.new(init)
+      end
+    end
+  end
+end

data/lib/eco/api/organization.rb

@@ -0,0 +1,13 @@
+module Eco
+  module API
+    module Organization
+    end
+  end
+end
+
+require_relative 'organization/tag_tree'
+require_relative 'organization/presets'
+require_relative 'organization/preferences'
+require_relative 'organization/account'
+require_relative 'organization/people'
+require_relative 'organization/policy_groups'

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

@@ -0,0 +1,23 @@
+module Eco
+  module API
+    module Account
+      class Account
+
+        attr_accessor :policy_group_ids, :filter_tags
+        attr_accessor :permissions_preset, :permissions_custom
+        attr_accessor :login_provider_ids
+        attr_accessor :landing_page_id, :preferences, :starred_ids
+        attr_reader :prefilter
+        #attr_reader :presets
+
+        def initialize(init = {})
+          #@presets = AccountPresets.new
+        end
+        def set_details(person)
+
+        end
+        private
+      end
+    end
+  end
+end

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

@@ -0,0 +1,118 @@
+module Eco
+  module API
+    module Organization
+      class People <  Eco::Language::Models::Collection
+
+        # build the shortcuts of Collection
+        attr_collection :id, :external_id, :email, :name, :supervisor_id
+        attr_presence :account, :details
+
+        alias_method :people, :to_a
+
+        include Common::People
+
+        def initialize(people = [], klass: INTERNAL::Person, factory: nil)
+          @klass = INTERNAL::Person unless klass == EXTERNAL::Person
+          super(people, klass: @klass)
+          @caches_init = false
+        end
+
+        def [](id_or_ext)
+          self.id(id_or_ext) || self.external_id(id_or_ext)
+        end
+
+        def id(*args)
+          attr('id', *args).first
+        end
+
+        def external_id(*args)
+          attr('external_id', *args).first
+        end
+
+        def users
+          self.account_present(true)
+        end
+
+        def contacts
+          self.details_present(true)
+        end
+
+        def non_users
+          self.account_present(false)
+        end
+
+        def person(id: nil, external_id: nil, email: nil)
+          init_caches
+          pers = @by_id[id]&.first if id
+          pers = @by_external_id[external_id&.strip]&.first if !pers && !external_id.to_s.strip.empty?
+          pers = @by_users_email[email&.downcase.strip]&.first if !pers && !email.to_s.strip.empty?
+          pers = @by_non_users_email[email&.downcase.strip]&.first if !pers && !email.to_s.strip.empty?
+          pers = @by_external_id[email&.downcase.strip]&.first if !pers && !email.to_s.strip.empty?
+          pers
+        end
+
+        def find(object)
+          id = object.respond_to?("id")? object.send("id") : nil
+          external_id = object.respond_to?("external_id")? object.send("external_id") : nil
+          email = object.respond_to?("email")? object.send("email") : nil
+          person(id: id, external_id: external_id, email: email)
+        end
+
+        def exclude(object)
+          exclude_people(into_a(object))
+        end
+
+        def exclude_people(list)
+          discarded = list.map do |person|
+            find(person)
+          end.compact
+          newFrom self.to_a - discarded
+        end
+
+        def email_id_maps
+          self.users.group_by(:email).transform_values { |person| person.id }
+        end
+
+        def group_by_supervisor
+          self.to_h(:supervisor_id)
+        end
+
+        # only those that are present
+        def supervisors
+          h_all = self.to_h
+          sup_ids = h_all.keys & self.supervisor_ids
+          newFrom h_all.select do |id, person|
+            sup_ids.include?(id)
+          end.values
+        end
+
+        def missing_supervisors_ids
+          sup_ids = self.supervisor_ids
+          sup_ids - (sup_ids & self.ids)
+        end
+
+        def to_h(attr)
+          super(attr || "id")
+        end
+
+        protected
+
+        def on_change
+          @caches_init = false
+        end
+
+        private
+
+        def init_caches
+          return if @caches_init
+          @by_id = self.to_h('id')
+          @by_external_id = self.to_h('external_id')
+          @by_users_email = self.users.to_h('email')
+          @by_non_users_email = self.non_users.to_h('email')
+          @caches_init = true
+        end
+
+      end
+    end
+  end
+end