eco-helpers 0.9.2 → 0.9.3

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

@@ -0,0 +1,189 @@
+module Eco
+  module API
+    class Session
+      class Config
+        class Workflow
+          extend Eco::API::Common::ClassHelpers
+
+          @workflow = {
+            load:     {input: nil, people: {get: nil, filter: nil}},
+            usecases: nil,
+            launch_jobs: nil,
+            post_launch: {usecases: nil, launch_jobs: nil},
+            end: nil
+          }
+
+          class << self
+            def stages
+              @stages ||= (@workflow || {}).keys
+            end
+
+            def validate_stage(stage)
+              "Unknown Workflow stage '#{stage}'. Should be any of #{stages}" unless stages.include?(stage)
+            end
+
+            def titleize(key)
+              str_name = key.to_s.strip.split(/[\-\_ ]/i).compact.map do |str|
+                str.slice(0).upcase + str.slice(1..-1).downcase
+              end.join("")
+            end
+
+            def get_model(key)
+              raise "Expected Symbol. Given: #{key.class}" unless key.is_a?(Symbol)
+              workflow = @workflow[key]
+              raise "Expected Array. Given #{model.class}" unless !workflow || workflow.is_a?(Hash)
+
+              class_name      = titleize(key.to_s)
+              full_class_name = "#{self}::#{class_name}"
+
+              if target_class = resolve_class(full_class_name, exception: false)
+              else
+                target_class  = Class.new(Eco::API::Session::Config::Workflow) do
+                  @workflow = workflow
+                end
+                self.const_set class_name, target_class
+              end
+
+              target_class
+            end
+
+          end
+
+          attr_reader :config
+          attr_reader :name
+
+          def initialize(name = nil, _parent: self, config:)
+            @config   = config
+            @name     = name
+
+            @stages   = {}
+            @_parent  = _parent
+
+            @pending  = true
+            # moments
+            @on   = nil
+            @before   = []
+            @after    = []
+          end
+
+          def pending?
+            @pending
+          end
+
+          def skip!
+            @skip    = true
+            @pending = false
+          end
+
+          def skip?
+            return @skip if instance_variable_defined?(:@skip)
+            return false if root?
+            @_parent.skip?
+          end
+
+          def for(key = nil)
+            raise "A block should be given." unless block_given?
+            if !key
+              yield(self)
+            else
+              stage(key).for(&Proc.new)
+            end
+            self
+          end
+
+          def on(key = nil, &block)
+            raise "A block should be given." unless block
+            if !key
+              @on = block
+            else
+              stage(key).on(&block)
+            end
+            self
+          end
+
+          def before(key = nil, &block)
+            raise "A block should be given." unless block
+            if !key
+              @before.push(block)
+            else
+              stage(key).before(&block)
+            end
+            self
+          end
+
+          def after(key = nil, &block)
+            raise "A block should be given." unless block
+            if !key
+              @after.push(block)
+            else
+              stage(key).after(&block)
+            end
+            self
+          end
+
+          def run(key = nil, io:, &block)
+            if key
+              io = stage(key).run(io: io, &block)
+            elsif pending?
+              @before.each {|c| io = c.call(self, io)}
+
+              unless skip?
+                io.session.logger.debug("(Workflow: #{path}) running now")
+                if block
+                  io = block.call(self, io)
+                else
+                  existing_stages.each {|stg| io = stg.run(io: io)}
+
+                  unless ready?
+                    msg = "(Workflow: #{path}) 'on' callback is not defined, nor block given"
+                    io.session.logger.debug(msg)
+                  end
+                  io = @on.call(self, io) if ready?
+                end
+                @pending = false
+              end
+
+              @after.each  {|c| io = c.call(self, io)}
+            end
+            io
+          end
+
+          protected
+
+          def path
+            return name if root?
+            "#{@_parent.path}:#{name}"
+          end
+
+          def root?
+            @_parent == self
+          end
+
+          def ready?
+            !!@on
+          end
+
+          def existing_stages
+            # sort defined stages by stage order
+            sorted_keys = self.class.stages & @stages.keys
+            sorted_keys.map {|k| stage(k)}
+          end
+
+          def ready_stages
+            exiting_stages.select {|s| s.ready?}
+          end
+
+          def stages_ready?
+            existing_stages.all? {|s| s.ready?}
+          end
+
+          def stage(key)
+            self.class.validate_stage(key)
+            @stages[key] ||= self.class.get_model(key).new(key, _parent: self, config: config)
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -15,21 +15,64 @@ module Eco
           Eco::API::Organization::People.new(people)
         end
 
-        def search(data, silent: true)
+        def people_refresh(people:, include_created: true)
+          ini = people.length
+          if include_created
+            session.job_groups.find_jobs(type: :create).map do |job|
+              people = people.merge(job.people)
+            end
+          end
+
+          created = people.length - ini
+          msg  = "Going to refresh #{people.length} people with server data"
+          msg += " (including #{created} that were created)" if created > 0
+          session.logger.info(msg)
+          status  = session.batch.get_people(people, silent: true)
+          entries = status.people
+
+          missing = people.length - entries.length
+          session.logger.error("Missed to obtain #{missing} people during the refresh") if missing > 0
+
+          Eco::API::Organization::People.new(status.people)
+        end
+
+        def search(data, options: {}, silent: true)
+          strict_search = session.config.people.strict_search? && (!options[:search]&.key?(:strict) || options.dig(:search, :strict))
+
           # to scope people to be fresh data got via api
-          session.logger.info("going to api get entries...")
+          session.logger.info("going to api get #{data.length} entries...")
+
           status = session.batch.search(data, silent: silent)
           people = Eco::API::Organization::People.new(status.people)
+
           # get the supervisors
-          session.logger.info("going to api get supervisors...")
+          supers = people.each_with_object([]) do |person, sup|
+            if sup_id = person.supervisor_id
+              spr = {"id" => sup_id}
+              sup.push(spr) unless sup.include?(spr) || people.person(id: sup_id, external_id: sup_id)
+            end
+          end
+
+          if supers.length > 0
+            session.logger.info("going to api get #{supers.length} current supervisors...")
+            status = session.batch.search(supers, silent: silent)
+            people = people.merge(status.people, strict: strict_search)
+          end
+
           supers = data.each_with_object([]) do |entry, sup|
             if entry.respond_to?(:supervisor_id) && !entry.supervisor_id.to_s.strip.empty?
+              sup_id = entry.supervisor_id
               spr = {"id" => entry.supervisor_id}
-              sup.push(spr) unless sup.include?(spr)
+              sup.push(spr) unless sup.include?(spr) || people.person(id: sup_id, external_id: sup_id)
             end
           end
-          status = session.batch.search(supers, silent: silent)
-          people = people.merge(status.people)
+
+          if supers.length > 0
+            session.logger.info("going to api get #{supers.length} supervisors as per entries...")
+            status = session.batch.search(supers, silent: silent)
+            people = people.merge(status.people, strict: strict_search)
+          end
+
           session.logger.info("could get #{people.length} people (out of #{data.length} entries)")
           people
         end

data/lib/eco/api/usecases.rb

@@ -1,13 +1,148 @@
 module Eco
   module API
-    module UseCases
+    class UseCases
+      class UnkownCase < Exception
+        def initialize(msg = nil, case_name: nil, type: nil)
+          msg ||= "Unkown case"
+          msg += ". Case name '#{case_name}'" if case_name
+          msg += ". Case type '#{type}'" if type
+          super(msg)
+        end
+      end
+
+      class AmbiguousCaseReference < Exception
+        def initialize(msg = nil, case_name: nil)
+          msg ||= "You must specify type when there are multiple cases with same name"
+          msg += ". Case name '#{case_name}'" if case_name
+          super(msg)
+        end
+
+      end
+
+      include Enumerable
+
+      def initialize()
+        @usecases      = {}
+        @cache_init    = false
+        @cases_by_name = {}
+      end
+
+      def length
+        count
+      end
+
+      def empty?
+        count == 0
+      end
+
+      def each(params: {}, &block)
+        return to_enum(:each) unless block
+        items.each(&block)
+      end
+
+      def items
+        @usecases.values
+      end
+
+      def add(usecase)
+        raise "Expected Eco::API::UseCases::UseCase object. Given: #{usecase}" if !usecase || !usecase.is_a?(Eco::API::UseCases::UseCase)
+        name = usecase.name
+        type = usecase.type
+        puts "Warning: overriding '#{type.to_s}' case #{name}" if self.defined?(name, type: type)
+        @cache_init = false
+        @usecases[key(name, type)] = usecase
+        usecase
+      end
+
+      def define(name, type:, &block)
+        Eco::API::UseCases::UseCase.new(name, type: type, root: self, &block).tap do |usecase|
+          add(usecase)
+        end
+      end
+
+      def defined?(name, type: nil)
+        return @usecases.key?(key(name, type)) if type
+        name?(name)
+      end
+
+      def name?(name)
+        !!by_name[name]
+      end
+
+      def names
+        by_name.keys
+      end
+
+      def types(name)
+        return nil if !name?(name)
+        by_name[name].map { |usecase| usecase.type }
+      end
+
+      def case(name, type: nil)
+        if type && target_case = @usecases[key(name, type)]
+          return target_case
+        elsif type
+          raise UseCases::UnkownCase.new(case_name: name, type: type)
+        end
+        raise UseCases::UnkownCase.new(case_name: name, type: type) unless cases = by_name[name]
+        raise UseCases::AmbiguousCaseReference.new(case_name: name) if cases.length > 1
+        cases.first
+      end
+
+      # merges cases overriding self for exisint parsers
+      def merge(cases)
+        return self if !cases
+        raise "Expected a Eco::API::UseCases object. Given #{cases.class}" if !cases.is_a?(Eco::API::UseCases)
+        cases_hash = cases.to_h
+
+        @usecases.merge!(cases_hash)
+
+        cases_hash.transform_values do |usecase|
+          usecase.root = self
+        end
+
+        @cache_init = false
+        self
+      end
+
+      protected
+
+      def to_h
+        @usecases
+      end
+
+      private
+
+      def by_name
+        init_caches
+        @by_name
+      end
+
+      def init_caches
+        return true if @cache_init
+        @cache_init = true
+        @by_name = @usecases.values.group_by { |usecase| usecase.name }
+      end
+
+      def key(name, type)
+        name.to_s + type.to_s
+      end
+
+      def name(key)
+        key.to_s.split(":").first
+      end
+
+      def type
+        key.to_s.split(":").last&.to_sym
+      end
     end
   end
 end
 
 require_relative 'usecases/base_case'
+require_relative 'usecases/default_case'
 require_relative 'usecases/use_case'
 require_relative 'usecases/use_case_chain'
+require_relative 'usecases/base_io'
 require_relative 'usecases/use_case_io'
-require_relative 'usecases/use_group'
 require_relative 'usecases/default_cases'

data/lib/eco/api/usecases/base_case.rb

@@ -1,16 +1,28 @@
 module Eco
   module API
-    module UseCases
+    class UseCases
       class BaseCase
-        
-        def initialize(cases, **options)
-          raise "Expected UseGroup. Given: #{cases.class}" unless cases.is_a?(UseGroup)
-          @cases   = cases
-          @options = options
+
+        class InvalidType < Exception
+          def initialize(msg = nil, type:, types:)
+            msg ||= "Invalid type."
+            msg = "Given type '#{type}'. Valid types: #{types}"
+            super(msg)
+          end
         end
 
-        def process
-          raise "You should reimplement this method"
+        @types = [:import, :filter, :transform, :sync, :export]
+
+        class << self
+          attr_reader :types
+
+          def valid_type?(type)
+            types.include?(type)
+          end
+
+          def validate_type(type)
+            raise InvalidType.new(type: type, types: types) unless valid_type?(type)
+          end
         end
 
       end