eco-helpers 0.8.3 → 0.8.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d1df7add146810d2ed8fa9bb2a2854d54880fa531d095cdd0e39f4ca44b181f
-  data.tar.gz: e3777d5c30e4eaff58043940428fff9cce05da58039bb17a620bbcffcb51c7af
+  metadata.gz: 05fa297f660326cad5045f7760c4352b961492c7be71a18eda2093cd7032b011
+  data.tar.gz: 13690bdea42b4960af20e835c5171df3424cfc7213f25123f154c0a42205bc58
 SHA512:
-  metadata.gz: 6d047a6b824c60f778d0c0151a0177e9edcc21a80c9fbb1473e347d909b4b02ec4cb6fe0b1ce4922d0a2dc43b366d0215f15b68bb6caf9fe117bab41d3db0444
-  data.tar.gz: 6517140b0277436045dbb162bf75c49f6fe1a76dc02b82b826b4bdc997941ba88316f3cd67ed29dc91b5e4155e1b48bdf641acbf4fc808c023c431f90905d078
+  metadata.gz: f795b7015969ddeaa59c76a1625d6d336ace2d35145651c15fdaecbbc0c32345c7023666febd94b1abb8e1de7ed1d3410aaf61bb19d5799edec6078bb0a02390
+  data.tar.gz: 33e176df8b2209373683ef79eba539f8e05e61fb1bbee63ebf4c8823c0f2ffa215a2c1cc62aa1e55d6c6e75c799f6f57599d8f67f7fd924bc371657018617777

data/eco-helpers.gemspec

@@ -29,8 +29,6 @@ Gem::Specification.new do |s|
   s.add_development_dependency "redcarpet", "~> 3.4", ">= 3.4.0"
 
   s.add_dependency 'ecoportal-api', '~> 0.4',  '>= 0.4.3'
-  s.add_dependency 'thor',          '~> 0',    '>= 0.20'
-  s.add_dependency 'nokogiri',      '~> 1.6',  '>= 1.6.8'
   s.add_dependency 'aws-sdk-s3',    '~> 1.30', '>= 1.30.1'
   s.add_dependency 'aws-sdk-ses',   '~> 1.14', '>= 1.14.0'
   s.add_dependency 'dotenv',        '~> 2.6',  '>= 2.6.0'

data/lib/eco-helpers.rb

@@ -8,7 +8,6 @@ end
 
 require_relative 'eco/language'
 require_relative 'eco/common'
-require_relative 'eco/scripting'
 require_relative 'eco/data'
 require_relative 'eco/api'
 require_relative 'eco/tester'

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

@@ -3,6 +3,7 @@ module Eco
     module Common
       module People
         class PersonEntry
+
           # This class is meant to provide a common interface to access entries of source data that come in different formats.
           # @note
           #   - if `data` is a `Person` object, its behaviour is `serialise`.
@@ -17,21 +18,21 @@ module Eco
             raise "Constructor needs a PersonParser. Given: #{parser}" if !person_parser.is_a?(Eco::API::Common::People::PersonParser)
             raise "Expecting Mapper object. Given: #{attr_map}" if attr_map && !attr_map.is_a?(Eco::Data::Mapper)
 
-            @source   = data
+            @source    = data
             @person_parser  = person_parser
-            @deps     = dependencies
-            @logger   = logger
-            @attr_map = attr_map
+            @deps      = dependencies
+            @logger    = logger
+            @attr_map  = attr_map
             @emap      = PersonEntryAttributeMapper.new(@source, person_parser: @person_parser, attr_map: @attr_map, logger: @logger)
 
             if parsing?
               @external_entry     = data
-              @serialized_entry   = mapped_entry(@external_entry)
-              @internal_entry     = internal_entry(@serialized_entry)
+              @serialized_entry   = _mapped_entry(@external_entry)
+              @internal_entry     = _internal_entry(@serialized_entry)
             else  # SERIALIZING
               @person             = data
-              @internal_entry     = internal_entry(@person)
-              @serialized_entry   = mapped_entry(@internal_entry)
+              @internal_entry     = _internal_entry(@person)
+              @serialized_entry   = _mapped_entry(@internal_entry)
               #@external_entry     = external_entry
             end
           end
@@ -99,7 +100,7 @@ module Eco
           def set_core(person, exclude: nil)
             scoped_attrs = @emap.core_attrs - into_a(exclude)
             @internal_entry.slice(*scoped_attrs).each do |attr, value|
-              set_to_core(person, attr, value)
+              _set_to_core(person, attr, value)
             end
           end
 
@@ -112,7 +113,7 @@ module Eco
             person.add_details(@person_parser.schema) if !person.details || !person.details.schema_id
             scoped_attrs = @emap.details_attrs - into_a(exclude)
             @internal_entry.slice(*scoped_attrs).each do |attr, value|
-              set_to_details(person, attr, value)
+              _set_to_details(person, attr, value)
             end
           end
 
@@ -126,7 +127,7 @@ module Eco
             person.account.permissions_preset = nil unless person.account.permissions_preset = "custom"
             scoped_attrs = @emap.account_attrs - into_a(exclude)
             @internal_entry.slice(*scoped_attrs).each do |attr, value|
-              set_to_account(person, attr, value)
+              _set_to_account(person, attr, value)
             end
           end
 
@@ -148,14 +149,50 @@ module Eco
             end
           end
 
+          def internal_entry
+            @internal_entry
+          end
+
+          def doc
+            return @person.doc if instance_variable_defined?(:@person) && @person
+
+            core_attrs    = @emap.core_attrs
+            details_attrs = @emap.details_attrs
+            account_attrs = @emap.account_attrs
+
+            internal_entry.slice(*core_attrs).tap do |core_hash|
+              unless details_attrs.empty?
+                schema_id      = @person_parser.schema.id
+                details_fields = @person_parser.schema.doc["fields"].each_with_object([]) do |fld, flds|
+                  if details_attrs.include?(fld.alt_id)
+                    flds << fld.merge("value" => internal_entry[fld.alt_id]).slice("id", "alt_id", "type", "name", "shared", "multiple", "value")
+                  end
+                end
+                core_hash.merge!({
+                  "details" => {
+                    "schema_id" => schema_id,
+                    "fields"    => details_fields
+                  }
+                })
+              end
+
+              unless account_attrs.empty?
+                account_hash = internal_entry.slice(*account_attrs)
+                core_hash.merge!({
+                  "account" => account_hash
+                })
+              end
+            end
+          end
+
           private
 
-          def set_to_core(person, attr, value)
+          def _set_to_core(person, attr, value)
             value = value&.downcase if attr == "email"
             person.send("#{attr}=", value&.strip)
           end
 
-          def set_to_account(person, attr, value)
+          def _set_to_account(person, attr, value)
             return if !person.account
             multiple = ["policy_group_ids", "filter_tags"].include?(attr)
             if multiple
@@ -169,7 +206,7 @@ module Eco
             person.account.send("#{attr}=", value)
           end
 
-          def set_to_details(person, attr, value)
+          def _set_to_details(person, attr, value)
             return if !person.details
             unless field = person.details.get_field(attr)
               fatal("Field '#{attr}' does not exist in details of schema: '#{person.details.schema_id}'")
@@ -184,18 +221,18 @@ module Eco
             person.details[attr] = value
           end
 
-          def get_from_core (person, attr)
+          def _get_from_core (person, attr)
             person.send(attr)
           end
 
-          def get_from_account (person, attr)
+          def _get_from_account (person, attr)
             return nil if !person.account
             multiple = ["policy_group_ids", "filter_tags"].include?(attr)
             value = person.account.send(attr)
             @person_parser.serialize(:multiple, value) if multiple
           end
 
-          def get_from_details(person, attr)
+          def _get_from_details(person, attr)
             return nil if !person.details || !person&.details&.schema_id
             unless field = person.details.get_field(attr)
               fatal("Field '#{attr}' does not exist in details of schema: '#{person.details.schema_id}'")
@@ -210,16 +247,16 @@ module Eco
           # To obtain an entry with internal names but external values.
           # @param data [Hash] external or raw entry (when parsing) or internal or parsed entry (when serializing).
           # @return [Hash] entry with **internal names** and **external values**.
-          def mapped_entry(data)
-            return aliased_entry(data) if parsing?
-            serialized_entry(data)
+          def _mapped_entry(data)
+            return _aliased_entry(data) if parsing?
+            _serialized_entry(data)
           end
 
           # Parsing helper that aliases attribute names (from internal to external names)
           # @note **Parse**: here we aliase internal attribute names into external ones.
           # @param ext_entry [Hash] entry in raw, with **external** names and values.
           # @return [Hash] entry with **internal names** and **external values**.
-          def aliased_entry(ext_entry)
+          def _aliased_entry(ext_entry)
             aliased_hash = @emap.aliased_attrs.map do |attr|
               [attr, ext_entry[@emap.to_external(attr)]]
             end.to_h
@@ -238,7 +275,7 @@ module Eco
           #   2. when running the serializers, it overrides existing keys.
           # @param unserialized_entry [Hash] entry with **internal** names and values.
           # @return [Hash] entry with **internal names** and **external values**.
-          def serialized_entry(unserialized_entry)
+          def _serialized_entry(unserialized_entry)
             serial_attrs = @person_parser.defined_attrs.reduce({}) do |serial_hash, attr|
               deps = @deps[attr] || {}
               serial_attr = @person_parser.serialize(attr, @person, deps: deps)
@@ -250,15 +287,15 @@ module Eco
           # To obtain an entry with internal names but external values.
           # @param data [Hash, Ecoportal::API::V1::Person] alised_entry (when parsing) or person (when serializing).
           # @return [Hash] the `internal entry` with the **internal** attributes names and values.
-          def internal_entry(data)
-            return parsed_entry(data) if parsing?
-            unserialized_entry(data)
+          def _internal_entry(data)
+            return _parsed_entry(data) if parsing?
+            _unserialized_entry(data)
           end
 
           # Parsing helper that just **parses the values** that have a parser/serializer defined.
           # @param aliased_entry [Hash] the entry with the _internal attribute_ names but the _external values_.
           # @return [Hash] the `internal entry` with the **internal** attributes names and values.
-          def parsed_entry(aliased_entry)
+          def _parsed_entry(aliased_entry)
             parsed = @person_parser.defined_attrs.map do |attr|
               value = @person_parser.parse(attr, aliased_entry)
               [attr, value]
@@ -274,19 +311,19 @@ module Eco
           #     - `core`, `account`, `details`.
           # @param person [Ecoportal::API::V1::Person] the `Person` object to transform into an _internal entry_.
           # @return [Hash] the `internal entry` with the **internal** attributes names and values.
-          def unserialized_entry(person)
+          def _unserialized_entry(person)
             core_hash = @person_parser.target_attrs_core.reduce({}) do |hash, attr|
-              value = get_from_core(person, attr)
+              value = _get_from_core(person, attr)
               hash.merge(hash_attr(attr, value))
             end
 
             details_hash = @person_parser.target_attrs_details.reduce({}) do |hash, attr|
-              value = get_from_details(person, attr)
+              value = _get_from_details(person, attr)
               hash.merge(hash_attr(attr, value))
             end
 
             account_hash = @person_parser.target_attrs_account.reduce({}) do |hash, attr|
-              value = get_from_account(person, attr)
+              value = _get_from_account(person, attr)
               hash.merge(hash_attr(attr, value))
             end
 

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

@@ -7,5 +7,6 @@ module Eco
   end
 end
 
-#require_relative 'version_patches/base_model.rb'
+require_relative 'version_patches/base_model.rb'
 require_relative 'version_patches/external_person.rb'
+require_relative 'version_patches/internal_person.rb'

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

@@ -0,0 +1,27 @@
+module Ecoportal
+  module API
+    module Common
+      class BaseModel
+
+        attr_reader :initial_doc
+
+        def initialize(doc = {}, parent: self, key: nil)
+          @_parent = parent
+          @_key    = key
+          if !_parent || !_key
+            @doc          = doc
+            @original_doc = JSON.parse(@doc.to_json)
+            @initial_doc  = JSON.parse(@doc.to_json)
+          end
+        end
+
+        def initial_doc
+          raise UnlinkedModel.new  unless linked?
+          return @initial_doc if is_root?
+          _parent.initial_doc.dig(*[_key].flatten)
+        end
+
+      end
+    end
+  end
+end

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

@@ -88,6 +88,12 @@ module Eco
           end
         end
 
+        # TODO: should keep it uniq
+        #def merge(data)
+        #  newFrom to_a + data
+        #end
+
+
         def exclude(object)
           exclude_people(into_a(object))
         end

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

@@ -6,6 +6,7 @@ module Eco
       class TagTree
         attr_reader :tag, :nodes
         attr_reader :depth, :path
+        attr_reader :enviro
 
         # @example Node format:
         #     {"tag": "NODE NAME", "nodes": subtree}
@@ -40,6 +41,11 @@ module Eco
           init_hashes
         end
 
+        # @return [Boolean] `true` if there are tags in the node, `false` otherwise.
+        def empty?
+          @has_tags.empty?
+        end
+
         # List of tag nodes of the entire subtree.
         # @return [Array<String>]
         def tags

data/lib/eco/api/policies/policy.rb

@@ -4,9 +4,9 @@ module Eco
       class Policy < Eco::API::UseCases::UseCase
         TYPES = [:transform]
 
-        def initialize(name, type: :transform, root:, options: {}, &block)
+        def initialize(name, type: :transform, root:, &block)
           raise "Undefine usecase type #{type}. Please, use any of #{TYPES}" unless self.class.valid_type?(type)
-          super(name, type: type, root: root, options: options, &block)
+          super(name, type: type, root: root, &block)
         end
 
         def root=(value)

data/lib/eco/api/session.rb

@@ -1,9 +1,8 @@
 module Eco
   module API
     class Session < Common::Session::BaseSession
-      attr_reader :batch, :policy_groups, :tagtree
-      attr_reader :job_groups
-      attr_reader :schemas
+      attr_reader   :batch
+      attr_reader   :job_groups
       attr_accessor :schema
 
       def initialize(init = {})
@@ -21,33 +20,19 @@ module Eco
 
         @use_cases    = Eco::API::UseCases::DefaultCases.new.merge(config.usecases)
 
-        @schemas      = config.schemas
-        self.schema = config.people.default_schema || @schemas.first
+        self.schema = config.people.default_schema || schemas.first
         @policy_groups = config.policy_groups
 
-        @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
-        Session::Config.new.tap do |conf|
-          yield(conf) if block_given?
-        end
-      end
-
       # TASKS & JOBS
       def do
         @task
@@ -71,27 +56,22 @@ module Eco
         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
+      def policy_groups
+        config.policy_groups
       end
 
-      def jobs_launch(simulate: false)
-        job_groups.launch(simulate: simulate)
+      def tagtree
+        config.tagtree(enviro: enviro)
       end
 
-      def policy_groups
-        @policy_groups ||= config.policy_groups
+      def schemas
+        config.schemas
       end
 
       def schema=(value)
         case value
         when String
-          unless @schema = @schemas.schema(value)
+          unless @schema = schemas.schema(value)
             fatal "The schema with id or name '#{value}' does not exist"
           end
         when Ecoportal::API::V1::PersonSchema
@@ -167,6 +147,19 @@ module Eco
         @use_cases.case(name, type: type).launch(**args)
       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
+
     end
   end
 end

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

@@ -50,7 +50,7 @@ module Eco
             entries = status.queue
             puts "\n"
             entries.each_with_index do |entry, i|
-              if (i % 500 == 0)
+              if (i % 10 == 0)
                 percent = i * 100 / entries.length
                 print "Searching: #{percent.round}% (#{i}/#{entries.length} entries)\r"
                 $stdout.flush
@@ -107,7 +107,7 @@ module Eco
             people += people_res
 
             total_iterations ||= response.body["total_pages"]
-            no_pages = !response.body["total_pages"]
+            no_pages           = !response.body["total_pages"]
             total_results    ||= response.body["total_results"]
 
             if !total_iterations
@@ -115,6 +115,7 @@ module Eco
             end
 
             msg = "iteration number: #{page}/#{total_iterations}, got num people #{people_res.length}, with total #{people.length} people got"
+            msg = "search(q=#{params[:q]}) " + msg if params.key?(:q)
             logger.info(msg) unless silent
 
             iterate = (no_pages && results_from = response.body["next_results_from"]) || (looping && page < total_iterations)