eco-helpers 0.6.0

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

@@ -0,0 +1,10 @@
+{
+  "files": [null, "download", "upload", "browse", "administrate"],
+  "data": [null, "view", "update", "administrate", "implement"],
+  "reports": [null, "view", "edit", "administrate"],
+  "organization": [null, "view", "administrate", "implement"],
+  "people": [null, "attach", "view", "view_private", "edit"],
+  "pages": [null, "view", "update", "create", "administrate"],
+  "page_editor": [null, "basic", "intermediate", "advanced", "implement"],
+  "registers": [null, "view", "dashboard", "administrate", "implement"]
+}

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

@@ -0,0 +1,134 @@
+module Eco
+  module API
+    module Organization
+
+      class TagTree
+        attr_reader :tag, :nodes
+        attr_reader :depth, :path
+
+        def initialize(tagtree = [], depth: -1, path: [], enviro: nil)
+          case tagtree
+          when String
+            @source = JSON.parse(tagtree)
+          else
+            @source = tagtree
+          end
+          fatal("You are trying to initialize a TagTree with a null tagtree") if !@source
+          fatal("Expecting Environment object. Given: #{enviro}") if enviro && !enviro.is_a?(API::Common::Session::Environment)
+          @enviro = enviro
+
+          @depth = depth
+          @tag = @source.is_a?(Array) ? nil : @source.dig('tag')&.upcase
+
+          @path  = path || []
+          @path.push(@tag) unless !@tag
+
+          nodes = @source.is_a?(Array) ? @source : @source.dig('nodes') || []
+          @nodes = nodes.map {|node| TagTree.new(node, depth: @depth + 1, path: @path.dup, enviro: @enviro)}
+
+          init_hashes
+        end
+
+        def tags
+          @hash_tags.keys
+        end
+
+        def tag?(key)
+          @hash_tags.key?(key.upcase)
+        end
+
+        def get_node(key)
+          return nil unless tag?(key)
+          @hash_tags[key.upcase]
+        end
+
+        def filter_tags(list)
+          return [] unless list && list.is_a?(Array)
+          list.select {|str| tag?(str)}
+        end
+
+        def path(key = nil)
+          return @path if !key
+          @hash_paths[key.upcase]
+        end
+
+        def user_tags(initial: [], final: [], preserve_custom: true, add_custom: false)
+          initial ||= [initial].flatten.compact
+          final   ||= [final].flatten.compact
+          raise "Expected Array for initial: and final:" unless initial.is_a?(Array) && final.is_a?(Array)
+          final    = filter_tags(final) unless add_custom
+          custom   = initial - filter_tags(initial)
+          final    = final + custom     if preserve_custom
+          new_tags = final - initial
+          # keep same order as they where
+          (initial & final) + new_tags
+        end
+
+        # take the deepest tag (the one that is further down in the tree)
+        # different options (several nodes at the same depth):
+        # => take the common node between them (i.e. you have Hamilton and Auckland -> take New Zealand)
+        # => if there's no common node between them, take the `first` (unless they are at top level of the tree)
+        def default_tag(*values)
+          values = filter_tags(values)
+          nodes = []; depth = -1
+          values.each do |tag|
+            raise("Couldn't find the node of #{tag} in the tag-tree definition") unless node = get_node(tag)
+
+            if node.depth > depth
+              nodes = [node]
+              depth = node.depth
+            elsif node.depth == depth
+              nodes.push(node)
+            end
+          end
+
+          default_tag = nil
+          if nodes.length > 1
+            common      = nodes.reduce(self.tags.reverse) {|com, node| com & node.path.reverse}
+            default_tag = common.first if common.length > 0 && depth > 0
+          end
+          default_tag = nodes.first&.tag if !default_tag && depth > 0
+          default_tag
+        end
+
+        protected
+
+        def hash
+          @hash_tags
+        end
+
+        def hash_paths
+          @hash_paths
+        end
+
+        private
+
+        def init_hashes
+          @hash_tags  = {}
+          @hash_tags[@tag] = self unless !@tag
+          @hash_tags = @nodes.reduce(@hash_tags) do |h,n|
+            h.merge(n.hash)
+          end
+          @hash_paths = {}
+          @hash_paths[@tag] = @path
+          @hash_paths = @nodes.reduce(@hash_paths) do |h,n|
+            h.merge(n.hash_paths)
+          end
+        end
+
+        def fatal(msg)
+          raise msg if !@enviro
+          @enviro.logger.fatal(msg)
+          exit
+        end
+
+        def warn(msg)
+          raise msg if !@enviro
+          @enviro.logger.warn(msg)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/eco/api/organization_old.rb

@@ -0,0 +1,73 @@
+module Eco
+  module API
+    #TODO move as part of API::Session and inherit from < API::Common::Session::BaseModel
+    #TODO boost autoconfiguration (via file <- FileManager.dir)
+    class Organization
+
+      DUMMY_USER_EXTERNAL_ID = 'dummy'
+
+      attr_reader :tag_tree, :policy_groups, :person_schemas
+      attr_reader :default_person, :default_schema, :default_schema_id
+      attr_reader :default_policy_group_ids, :default_filter_tags, :default_login_provider_ids
+      attr_reader :login_providers
+      attr_reader :account_presets, :account_preferences
+
+      def initialize(init = {})
+        api = init.fetch('api', nil)
+        @@api = api&.instance_of?(Ecoportal::API::Internal) && api
+        # todo: maps { 'policy_group' : 'preset'}
+        set_settings(init, override: true)
+      end
+
+      def set_settings(init = {}, override: false)
+        set_defaults(init)
+        @login_providers = init['login_providers'] || @@api&.login_providers&.to_a || \
+          @login_providers ||  [] if (!@login_providers || :override)
+        @tag_tree = init['tag_tree'] || @default_filter_tags || @tag_tree || [] if (!@tag_tree || :override)
+        @policy_groups = init['policy_groups'] || @@api&.policy_groups&.to_a || \
+          @policy_groups ||  [] if (!@policy_groups || :override)
+
+        @person_schemas = init['person_schemas'] || @@api&.person_schemas&.to_a || @person_schemas || \
+          [@default_schema] || [] if (!@person_schemas || :override)
+      end
+
+      def default_schema=(value)
+        @default_schema = value || @person_schemas&.first
+        self.default_schema_id = @default_schema&.id || @default_schema&.schema_id || @default_schema_id
+      end
+
+      def default_schema_id=(value)
+        @default_schema_id = value
+      end
+
+      private
+
+      def set_defaults(init = {})
+        @account_presets = Account::Presets.new(init.fetch('presets', nil))
+        @account_preferences = Account::Preferences.new
+
+        @default_person = get_default_person(init)
+        @default_policy_group_ids = init['default_policy_group_ids'] || @default_person&.account&.policy_group_ids || []
+        @default_filter_tags = init['default_filter_tags'] || @default_person&.account&.filter_tags || []
+        @default_login_provider_ids = init['default_login_provider_ids'] || @default_person&.account&.login_provider_ids || []
+        default_schema = get_schema_from_person(@default_person)
+        self.default_schema = init['default_schema'] || default_schema
+      end
+
+      def get_default_person(init = {})
+        return nil if !@@api
+        return init.fetch('default_person', (@@api && @@api.people.get(DUMMY_USER_EXTERNAL_ID)).result || nil)
+      end
+
+      def get_schema_from_person(person)
+        return nil if !person
+        doc = person.details.doc
+        doc['id'] = doc['schema_id']
+        doc.delete('schema_id')
+        schema = Ecoportal::API::Internal::PersonSchema.new(doc)
+        return schema
+      end
+
+    end
+  end
+end

data/lib/eco/api/session.rb

@@ -0,0 +1,180 @@
+module Eco
+  module API
+    class Session < Common::Session::BaseSession
+
+      attr_reader :batch, :policy_groups
+      attr_accessor :schema, :schemas_hash
+      attr_reader :tagtree
+      attr_reader :job_groups
+
+      #attr_reader :organization
+      #alias_method :org, :organization
+
+      def initialize(init = {})
+        super(init)
+        logger.debug("LINE COMMAND: #{$0} #{ARGV.join(" ")}")
+
+        @batch        = Batch.new(enviro)
+        @task         = Task.new(self, enviro)
+        @job_groups   = JobGroups.new(session: self)
+
+        @use_cases    = Eco::API::UseCases::DefaultCases.new.merge(config.usecases.use_group)
+
+        @schemas =  api&.person_schemas.to_a
+        @schemas_hash = @schemas.map do |sch|
+          [[sch.id, sch], [sch.name.downcase, sch]]
+        end.flatten(1).to_h
+
+        self.schema = config.people.default_schema || @schemas.first
+        @policy_groups = nil
+
+        @tagtree = nil
+        if tree_file = config.dig('org', 'tagtree')
+          tree = file_manager.load_json(tree_file) unless !tree_file
+          @tagtree = Eco::API::Organization::TagTree.new(tree, enviro: enviro)
+        end
+
+        presets_custom_file = config.people.presets_custom
+        presets_map_file    = config.people.presets_map
+
+        @presets_factory = Eco::API::Organization::PresetsFactory.new({
+          #policy_groups:  @policy_groups,
+          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
+        })
+      end
+
+      def self.configure
+        #SessionConfig.new.tap
+        conf = SessionConfig.new
+        yield(conf) if block_given?
+        conf
+      end
+
+      def config
+        enviro.config
+      end
+
+      # TASKS & JOBS
+      def do
+        @task
+      end
+
+      def mail_to(**kargs)
+        @mailer ||= Eco::API::Common::Session::Mailer.new(enviro: enviro)
+        @mailer.mail(**kargs)
+      end
+
+      def s3upload(content: nil, file: nil, directory: nil)
+        @s3uploader ||= Eco::API::Common::Session::S3Uploader.new(enviro: enviro)
+        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
+
+      def job_group(name, order: :last)
+        case
+        when job_groups.exists?(name)
+          job_groups[name]
+        else
+          job_groups.new(name, order: order)
+        end
+      end
+
+      def jobs_launch(simulate: false)
+        job_groups.launch(simulate: simulate)
+      end
+
+      def policy_groups
+        @policy_groups ||= config.policy_groups
+      end
+
+      def schema=(value)
+        case value
+        when String
+          sch = @schemas_hash[value.downcase]
+          raise "The schema with id or name '#{value}' does not exist" if !sch
+          @schema = sch
+        when Ecoportal::API::V1::PersonSchema
+          @schema = value
+        else
+          logger.error("Session: Missuse of 'schema=' method. Given: #{value}")
+          return
+        end
+
+        @person_factory    = Eco::API::Common::People::PersonFactory.new(schema: @schema)
+
+        fields_mapper_file = config.people.fields_mapper
+        fields_mapper      = Eco::Data::Mapper.new(file_manager.load_json(fields_mapper_file))
+        @entry_factory     = Eco::API::Common::People::EntryFactory.new({
+          schema: @schema,
+          person_parser: config.people.parser,
+          fields_mapper: fields_mapper,
+          logger: logger
+        })
+      end
+
+      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 new_person(**keyed_args)
+        @person_factory.new(**keyed_args)
+      end
+
+      def new_entry(data, dependencies: {})
+        @entry_factory.new(data, dependencies: dependencies)
+      end
+
+      def csv_entries(file)
+        rows = []
+        if Eco::API::Common::Session::FileManager.file_exists?(file)
+          CSV.foreach(file, headers: true, encoding: Eco::API::Common::Session::FileManager.encoding(file)).with_index do |row, i|
+            rows.push(row)
+          end
+        end
+        @entry_factory.entries(rows)
+      end
+
+      def discarded_entries
+        file = config.people.discarded_file
+        file = file_manager.dir.file(file)
+        csv_entries(file)
+      end
+
+      def process_case(name, type: nil, **params)
+        args = { session: self }.merge(params)
+        fatal("Undefined usecase '#{name}' of type '#{type.to_s}'") if !@use_cases.defined?(name, type: type)
+        @use_cases.case(name, type: type).process(**args)
+      end
+
+      private
+
+      def fatal(msg)
+        logger.fatal(msg)
+        raise msg
+      end
+
+    end
+  end
+end
+
+require_relative 'session/batch'
+require_relative 'session/batch_status'
+require_relative 'session/task'
+require_relative 'session/batch_job'
+require_relative 'session/batch_jobs'

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

@@ -0,0 +1,132 @@
+module Eco
+  module API
+    class Session
+      # important! the handler should probably only create logs and save the update with same timestamp
+      class Batch < Common::Session::BaseSession
+
+        DEFAULT_BATCH_BLOCK = 100
+        VALID_METHODS = ['get', 'create', 'update', 'upsert', 'delete']
+
+        # people can be: empty, an api object, a people object, or an array with id's or persons
+        def get_people(people = nil, api: nil, params: {per_page: DEFAULT_BATCH_BLOCK})
+          api = api || self.api
+          return batch_from(people, 'get', api, params: params) if people.is_a?(Array)
+          return batch_get(api, params: params)
+        end
+
+        def launch(people = nil, method:, api: nil, params: {per_page: DEFAULT_BATCH_BLOCK})
+          if !valid_method?(method)
+            msg = "Invalid batch method: #{method}."
+            logger.fatal(msg)
+            raise msg
+          end
+          return nil if !people || !people.is_a?(Array)
+          batch_from(people, method, api || self.api, params: params)
+        end
+
+        def valid_methods
+          VALID_METHODS
+        end
+
+        def valid_method?(value)
+          VALID_METHODS.include?(value)
+        end
+
+
+        private
+
+        def new_status(queue, method)
+          BatchStatus.new(enviro, queue: queue, method: method)
+        end
+
+        def batch_get(api, params: {})
+          unless people_api = api&.people
+            msg = "cannot batch get without api connnection, please provide a valid api connection!"
+            logger.fatal(msg)
+            raise msg
+          end
+
+          params = {per_page: DEFAULT_BATCH_BLOCK}.merge(params)
+          client = people_api.client
+          people = [];
+          if (page = params.fetch(:page, false))
+            res, response = get(client, params: params)
+            people +=res
+            logger.info("page number: #{page}, got num people #{people.length}")
+          else
+            page = 1
+            loop do
+              params = params.merge({page: page})
+              people_res, response = get(client, params: params)
+              people += people_res
+
+              total_pages = response.body["total_pages"]
+              logger.info("page number: #{page}/#{total_pages}, got num people #{people_res.length}, with total #{people.length} people got")
+              break if page >= total_pages
+              page += 1
+            end
+          end
+          return people
+        end
+
+        def get(client, params:)
+          response = client.get("/people", params: params)
+          unless response.success?
+            msg = "Request failed - params: #{params}"
+            msg += "\n Error message: - Status #{response.status}: #{response.body}"
+            logger.fatal(msg)
+            raise msg
+          end
+          people = []
+          response.body["results"].each do |person_hash|
+            person = INTERNAL::Person.new(person_hash)
+            yield person if block_given?
+            people.push(person)
+          end
+          [people, response]
+        end
+
+        def batch_from(people, method, api, params: {})
+          return nil if !people || !people.is_a?(Array)
+          unless people_api = api&.people
+            msg = "cannot batch #{method} without api connnection, please provide a valid api connection!"
+            logger.fatal(msg)
+            raise msg
+          end
+
+          # batch Status
+          status = new_status(people, method)
+
+          # param q does not make sense here, even for GET method
+          params = {per_page: DEFAULT_BATCH_BLOCK}.merge(params)
+          per_page = params.fetch(:per_page)
+
+          iteration = 1; done = 0
+
+          people.each_slice(per_page) do |slice|
+            msg = "starting batch '#{method}' iteration #{iteration}, which has #{slice.length} entries of #{people.length} -- #{done} done"
+            logger.info(msg)
+
+            people_api.batch do |batch|
+              slice.each do |person|
+                # valid method checked before
+                batch.public_send(method, person) do |response|
+                  status[person] = response
+                  #status.print_error(person)
+                end # current person
+              end # next person
+            end # next batch
+
+            iteration += 1
+            done += slice.length
+          end # next slice
+
+          status.print_errors
+
+          return status
+        end
+
+      end
+    end
+  end
+end