eco-helpers 0.9.2 → 0.9.3

data/lib/eco/cli/config/default.rb

@@ -0,0 +1,15 @@
+module Eco
+  class CLI
+    class Config
+      module Default
+      end
+    end
+  end
+end
+
+require_relative 'default/options'
+require_relative 'default/input'
+require_relative 'default/people'
+require_relative 'default/filters'
+require_relative 'default/usecases'
+require_relative 'default/workflow'

data/lib/eco/cli/config/default/filters.rb

@@ -0,0 +1,69 @@
+ASSETS.cli.config do |cnf|
+  cnf.people_filters do |filters|
+
+    filters.add("-only-users") do |people, session, options|
+      options.deep_merge!(people: {filter: {account: true}})
+      people.users
+    end
+
+    filters.add("-no-account") do |people, session, options|
+      options.deep_merge!(people: {filter: {account: false}})
+      people.account_present(false)
+    end
+
+    filters.add("-with-details") do |people, session, options|
+      options.deep_merge!(people: {filter: {details: true}})
+      people.details_present
+    end
+
+    filters.add("-no-id") do |people, session, options|
+      options.deep_merge!(people: {filter: {external_id: nil}})
+      people.external_id_present(false)
+    end
+
+    filters.add("-supervisors") do |people, session, options|
+      options.deep_merge!(people: {filter: {subordinates: true}})
+      people.newFrom people.to_a.select {|person| person.subordinates > 0}
+    end
+
+    filters.add("-supervisor-id") do |people, session, options|
+      id     = SCR.get_arg("-supervisor-id", with_param: true)
+      options.deep_merge!(people: {filter: {supervisor_id: id}})
+      unless sup = people.person(id: id, external_id: id, email: id, strict: true)
+        status = session.batch.search([{"id" => id}])
+        sup    = status.people.first
+      end
+      raise "Supervisor with id '#{id}' does not exist" unless sup
+      people.supervisor_id(sup.id)
+    end
+
+    filters.add("-no-default-tag") do |people, session, options|
+      options.deep_merge!(people: {filter: {account: {default_tag: nil}}})
+      filtered = people.select do |person|
+        !person.account&.default_tag
+      end
+      people.newFrom filtered
+    end
+
+    filters.add("-schema-id") do |people, session, options|
+      sch_name = SCR.get_arg("-schema-id", with_param: true)
+      sch_id   = session.schemas.to_id(sch_name)
+
+      unless sch_id
+        puts "You need to specify the schema id"
+        exit
+      end
+
+      options.deep_merge!(people: {filter: {details: {schema_id: sch_id}}})
+      session.logger.info("Filtering for schema #{sch_name}")
+
+      session.schema = sch_id
+
+      filtered = people.select do |person|
+        person.details && (person.details.schema_id == sch_id)
+      end
+      people.newFrom filtered
+    end
+
+  end
+end

data/lib/eco/cli/config/default/input.rb

@@ -0,0 +1,21 @@
+ASSETS.cli.config do |cnf|
+  cnf.input(default_option: "-entries-from") do |session, str_opt, options|
+    input = []
+    if SCR.get_arg(str_opt)
+      file = SCR.get_file(str_opt, required: true)
+      options.deep_merge!(input: {file: {name: file}})
+      if SCR.get_arg("-xml")
+        options.deep_merge!(input: {file: {format: :xml}})
+        session.config.files.validate(:xml, file)
+        input = session.entries(file: file, format: :xml)
+      elsif SCR.get_arg("-json")
+        options.deep_merge!(input: {file: {format: :json}})
+        input = Eco::API::Organization::People.new(JSON.parse(File.read(file)))
+      else
+        options.deep_merge!(input: {file: {format: :csv}})
+        input = session.csv_entries(file)
+      end
+    end
+    input
+  end
+end

data/lib/eco/cli/config/default/options.rb

@@ -0,0 +1,47 @@
+ASSETS.cli.config do |cnf|
+  cnf.options_set do |options_set, options|
+
+    options_set.add(["-dry-run", "-simulate"]) do |options|
+      options[:dry_run]  = true
+      options[:simulate] = true
+    end
+
+    options[:end_get] = true
+    options_set.add("-no-get") do |options|
+      options[:end_get] = false
+    end
+
+    options_set.add("-search-strict") do |options|
+      options.deep_merge!(search: {strict: true})
+    end
+    options_set.add("-search-soft") do |options|
+      options.deep_merge!(search: {strict: false})
+    end
+
+    options_set.add(["-no-invites", "-exclude-invites"]) do |options|
+      options.merge!(send_invites: false)
+    end
+    options_set.add("-send-invites") do |options|
+      options.merge!(send_invites: true)
+    end
+
+    options_set.add("-exclude-core") do |options|
+      options.deep_merge!(exclude: {core: true})
+    end
+    options_set.add("-exclude-supervisor") do |options|
+      options.deep_merge!(exclude: {supervisor: true})
+    end
+    options_set.add("-exclude-email") do |options|
+      options.deep_merge!(exclude: {email: true})
+    end
+    options_set.add("-exclude-details") do |options|
+      options.deep_merge!(exclude: {details: true})
+    end
+    options_set.add("-exclude-account") do |options|
+      options.deep_merge!(exclude: {account: true})
+    end
+    options_set.add("-exclude-abilities") do |options|
+      options.deep_merge!(exclude: {abilities: true})
+    end
+  end
+end

data/lib/eco/cli/config/default/people.rb

@@ -0,0 +1,39 @@
+ASSETS.cli.config do |cnf|
+  cnf.people do |input, session, options|
+    people = Eco::API::Organization::People.new([])
+    if SCR.get_arg("-get-people")
+      options.deep_merge!(people: {
+        get: {from: :remote, type: :full}
+      })
+      people = session.do.file_people
+    elsif SCR.get_arg("-people-from-backup")
+      file = SCR.get_arg("-people-from-backup", with_param: true)
+      options.deep_merge!(people: {
+        get: {from: :local, type: :backup}
+      })
+      people = JSON.parse(File.read(file))
+      people = Eco::API::Organization::People.new(people)
+    elsif SCR.get_arg("-get-partial")
+      unless input && input.is_a?(Enumerable)
+        raise "To use -get-partial (partial updates), you need to use -entries-from"
+      end
+      options.deep_merge!(people: {
+        get: {from: :remote, type: :partial}
+      })
+
+      people = session.do.search(input, options: options)
+    else
+      options.deep_merge!(people: {
+        get: {from: :local, type: :full}
+      })
+      people = session.do.load_people(modifier: [:newest, :save])
+      if people.empty?
+        options.deep_merge!(people: {
+          get: {from: :remote, type: :full}
+        })
+        people = session.do.file_people if people.empty?
+      end
+    end
+    people
+  end
+end

data/lib/eco/cli/config/default/usecases.rb

@@ -0,0 +1,63 @@
+ASSETS.cli.config do |cnf|
+  cnf.usecases do |cases|
+
+    cases.add("-people-to-csv", :export) do |people, session, options|
+      file = SCR.get_file("-people-to-csv", required: true, should_exist: false)
+      options.deep_merge!(export: {file: {name: file, format: :csv}})
+      options.deep_merge!(export: {options: {nice_header: true}}) if SCR.get_arg("-nice-header")
+
+      case_name = SCR.get_arg("-detailed")? "to-csv-detailed" : "to-csv"
+      session.usecases.case(case_name)
+    end
+
+    cases.add("-reset-landing-page", :transform, case_name: "reset-landing-page")
+    cases.add("-email-as-id", :transform, case_name: "email-as-id")
+    cases.add("-new-id-from", :sync, case_name: "new-id")
+    # won't succeed if some other user with that email in all eP
+    cases.add("-new-email-from", :sync, case_name: "new-email")
+    # forces the change of email no matter what,
+    # unless some other user with that email in the same organization
+    cases.add("-change-email-from", :sync, case_name: "change-email")
+    cases.add("-set-supervisor-from", :sync, case_name: "set-supervisor")
+    cases.add("-switch-supervisor", :transform, case_name: "switch-supervisor") do |people, session, options|
+      unless old_id = SCR.get_arg("-old-super", with_param: true)
+        session.logger.error("You must specify an -old-super to target whose supervisor is changing")
+        exit
+      end
+      options.deep_merge!(super: {old: old_id})
+
+      unless new_id = SCR.get_arg("-new-super", with_param: true)
+        session.logger.error("You must specify the -new-super id. To reset to nil the supervisor, please, specify nil.")
+        exit
+      end
+      new_id = new_id == "nil"? nil : new_id
+      options.deep_merge!(super: {new: new_id})
+    end
+
+    cases.add("-create-details-from", :sync, case_name: "create-details")
+    cases.add("-update-details-from", :sync, case_name: "update-details")
+    cases.add("-reinvite", :transform, case_name: "reinvite")
+    cases.add("-set-default-tag", :transform, case_name: "set-default-tag")
+
+    cases.add("-recover-db-from", :sync, case_name: "recover-db") do |input, people, session, options|
+      unless input && input.is_a?(Eco::API::Organization::People)
+        file  = SCR.get_file("-recover-db-from", required: true)
+        input = Eco::API::Organization::People.new(JSON.parse(File.read(file)))
+        session.logger.info("Source DB: loaded #{input.length} entries.")
+      end
+
+      options.deep_merge!(include: {delete: true}) if SCR.get_arg("-include-delete")
+      options.deep_merge!(include: {create: true}) if SCR.get_arg("-include-create")
+    end
+
+    cases.add("-create-from", :sync, case_name: "create")
+    cases.add("-update-from", :sync, case_name: "update")
+    cases.add("-refresh-presets", :transform, case_name: "refresh-presets")
+    cases.add("-remove-account", :transform, case_name: "remove-account")
+    cases.add("-remove-account-from", :sync, case_name: "remove-account")
+    cases.add("-delete", :transform, case_name: "delete")
+    cases.add("-delete-from", :sync, case_name: "delete")
+    cases.add("-upsert-from", :sync, case_name: "upsert")
+    cases.add("-hris-from", :sync, case_name: "hris")
+  end
+end

data/lib/eco/cli/config/default/workflow.rb

@@ -0,0 +1,86 @@
+ASSETS.cli.config do |config|
+  ASSETS.config.workflow do |wf|
+
+    wf.on(:load) do |wf_load, io|
+      io = io.new(input:   config.input.get(io: io))
+      io = io.new(people:  config.people(io: io))
+      io = io.new(people:  config.people_filters.process(io: io))
+    end
+
+    wf.before(:usecases) do |wf_cases, io|
+      # save partial entries -> should be native to session.workflow
+      partial_update = io.options.dig(:people, :get, :type) == :partial
+      if !io.options[:dry_run] && partial_update
+        #enviro.config.people.cache
+        io.session.file_manager.save_json(io.people, "cache/people_partial.json", :timestamp)
+      end
+      io
+    end
+
+    wf.on(:usecases) do |wf_cases, io|
+      unless config.usecases.process(io: io)
+        io.session.logger.warn("No update operation specified... quitting")
+        exit
+      end
+      io
+    end
+
+    wf.before(:launch_jobs) do |wf_jobs, io|
+      SCR.stop_on_unknown!
+      io
+    end
+
+    wf.on(:launch_jobs) do |wf_jobs, io|
+      io.session.jobs_launch(simulate: io.options[:dry_run])
+      io
+    end
+
+    wf.before(:post_launch) do |wf_post, io|
+      if io.session.post_launch.empty?
+        wf_post.skip!
+      else
+        partial_update = io.options.dig(:people, :get, :type) == :partial
+        if !io.options[:dry_run] && partial_update
+          # get target people afresh
+          people = io.session.do.people_refresh(people: io.people, include_created: true)
+          io     = io.new(people: people)
+        else
+          wf_post.skip!
+          msg = "Although there are post_launch cases, they will NOT be RUN"
+          if io.options[:dry_run]
+            msg+= ", because we are in dry-run (simulate)."
+          elsif !partial_update
+            msg+= ", because it is not a partial update (-get-partial)"
+          end
+          io.session.logger.info(msg)
+        end
+      end
+      io
+    end
+
+    wf.for(:post_launch) do |wf_post|
+
+      wf_post.on(:usecases) do |wf_postcases, io|
+        io.session.post_launch.each do |use|
+          io = use.launch(io: io).base
+        end
+        io
+      end
+
+      wf_post.on(:launch_jobs) do |wf_postlaunch, io|
+        io.session.jobs_launch(simulate: io.options[:dry_run])
+        io
+      end
+    end
+
+    wf.on(:end) do |wf_end, io|
+      partial_update = io.options.dig(:people, :get, :type) == :partial
+      unless !io.options[:end_get] || io.options[:dry_run] || partial_update
+        people = io.session.do.file_people
+        io     = io.new(people: people)
+      end
+      io
+    end
+
+  end
+end

data/lib/eco/cli/config/input.rb

@@ -0,0 +1,40 @@
+module Eco
+  class CLI
+    class Config
+      class Input
+
+        attr_reader :core_config
+        attr_reader :default_option
+
+        def initialize(core_config:, default_option: nil)
+          @core_config    = core_config
+          @default_option = default_option
+          @callbacks = {}
+        end
+
+        def default_option?
+          !!default_option
+        end
+
+        def define(option: nil, &block)
+          option ||= default_option
+          raise "Missing option to identify the input (no default defined)" unless !!option
+          raise "Missing block to define the input obtention process" unless block
+          @callbacks[option] = block
+        end
+
+        def get(io:, option: nil)
+          unless io && io.is_a?(Eco::API::UseCases::BaseIO)
+            raise "You need to provide Eco::API::UseCases::BaseIO object. Given: #{io.class}"
+          end
+
+          option ||= default_option
+          raise "Missing option to identify the input (no default defined)" unless !!option
+          callback = @callbacks[option] || @callbacks[default_option]
+          callback.call(io.session, option, io.options)
+        end
+
+      end
+    end
+  end
+end

data/lib/eco/cli/config/options_set.rb

@@ -0,0 +1,35 @@
+module Eco
+  class CLI
+    class Config
+      class OptionsSet
+        attr_reader :core_config
+
+        def initialize(core_config:)
+          @core_config = core_config
+          @options_set = {}
+        end
+
+        def add(option)
+          raise "Missing block to define the options builder" unless block_given?
+          callback = Proc.new
+          [option].flatten.compact.each do |opt|
+            @options_set[opt] = callback
+          end
+          self
+        end
+
+        def process(io:)
+          unless io && io.is_a?(Eco::API::UseCases::BaseIO)
+            raise "You need to provide Eco::API::UseCases::BaseIO object. Given: #{io.class}"
+          end
+
+          @options_set.each do |arg, callback|
+            callback.call(io.options) if SCR.get_arg(arg)
+          end
+          io.options
+        end
+
+      end
+    end
+  end
+end

data/lib/eco/cli/config/people_filters.rb

@@ -0,0 +1,38 @@
+module Eco
+  class CLI
+    class Config
+      class PeopleFilters
+        attr_reader :core_config
+
+        def initialize(core_config:)
+          @core_config = core_config
+          @filters     = {}
+        end
+
+        def add(option)
+          raise "Missing block to define the filters builder" unless block_given?
+          callback = Proc.new
+          [option].flatten.compact.each do |opt|
+            @filters[opt] = callback
+          end
+          self
+        end
+
+        def process(io:)
+          unless io && io.is_a?(Eco::API::UseCases::BaseIO)
+            raise "You need to provide Eco::API::UseCases::BaseIO object. Given: #{io.class}"
+          end
+
+          io = io.new(type: :transform)
+          @filters.each do |arg, callback|
+            if SCR.get_arg(arg)
+              io = io.new(people: callback.call(*io.params))
+            end
+          end
+          io.people
+        end
+
+      end
+    end
+  end
+end