eco-helpers 1.4.0 → 1.5.2

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

@@ -19,7 +19,7 @@ module Eco
         end
 
         # Thanks to this step the format on the declaration of the model is flexible
-        # @param value [Hash, Enumerable, String, Symbol, nil]
+        # @param model [Hash, Enumerable, String, Symbol, nil]
         # @return [Hash, nil] where keys are `Symbol` s
         def parse_model(model)
           case model

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

@@ -0,0 +1,16 @@
+module Eco
+  module API
+    module Common
+      module ClassMetaBasics
+
+        # Helps to define methods and keep track on them
+        def define(name, &block)
+          name = name.to_sym
+          @helpers[name] = block
+          define_method(name.to_sym, &block)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Eco
+  module API
+    module Common
+      module Loaders
+      end
+    end
+  end
+end
+
+require_relative 'loaders/use_case'
+require_relative 'loaders/policy'
+require_relative 'loaders/error_handler'
+require_relative 'loaders/parser'

data/lib/eco/api/common/loaders/error_handler.rb

@@ -0,0 +1,41 @@
+module Eco
+  module API
+    module Common
+      module Loaders
+        class ErrorHandler < Eco::API::Common::BaseLoader
+
+          class << self
+            attr_writer :error
+
+            # @return [Eco::API::Error] the error class, child of `Eco::API::Error`.
+            def error(value = nil)
+              unless value
+                return @error || raise("You should specify an error type for #{self.class}")
+              end
+              @error = value
+            end
+          end
+
+          def initialize(handlers)
+            raise "Expected Eco::API::Policies. Given #{handlers.class}" unless handlers.is_a?(Eco::API::Error::Handlers)
+            handlers.on(self.error, &self.method(:main))
+          end
+
+          # @param people [Eco::API::Organization::People] the people in the queue of the current `job`
+          # @param session [Eco::API::Session] the current session where the usecase kicks in.
+          # @param options [Hash] the options that modify the case behaviour or bring some dependencies.
+          # @param handler [Eco::API::Error::Hanlder] the `error handler` instance object.
+          # @param job [Eco::API::Session::Batch::Job] the `Batch::Job` made on purpose for this handler.
+          def main(people, session, options, handler, job)
+            raise "You should implement this method"
+          end
+
+          def error
+            self.class.error
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/eco/api/common/loaders/parser.rb

@@ -0,0 +1,127 @@
+module Eco
+  module API
+    module Common
+      module Loaders
+        class Parser < Eco::API::Common::BaseLoader
+
+          class << self
+            attr_reader :active_when
+
+            # @param value [String, Symbol] the attribute or type to be parsed/serialized
+            #   1. when `String`: the internal name of the field/attribute this parser/serializer manages for.
+            #   2. when `Symbol`: the type of data this parser converts between `String` and the specific type.
+            # @return [String] the `type` of usecase (i.e. `:sync`, `:transform`, `:import`, `:other`)
+            def attribute(value = nil)
+              unless value
+                return @attribute || raise("You should specify the 'attribute' this parser/serializer, #{self.class}, is linked to")
+              end
+              name value
+              @attribute = value
+            end
+
+            # Some parsers require dependencies to do their job.
+            def dependencies(value = nil)
+              @dependencies ||= {}
+              return @dependencies unless value
+              @dependencies = value
+            end
+
+            # Define or get the `phase` that the `parser` kicks in.
+            # @param phase [Symbol] the phase when this parser should be active.
+            #   Must be one of [`:internal`, `:final`]
+            def parsing_phase(phase = nil)
+              @parsing_phase ||= :internal
+              return @parsing_phase unless phase
+              @parsing_phase = phase
+            end
+
+            # Define or get the `phase` that the `serializer` kicks in.
+            # @param phase [Symbol] the phase when this serializer should be active.
+            #   Must be one of [`:person,` `:final`, `:internal`]
+            def serializing_phase(phase = nil)
+              @serializing_phase ||= :person
+              return @serializing_phase unless phase
+              @serializing_phase = phase
+            end
+
+            # Helper to build the `active_when` condition.
+            def active_when_any(*attrs)
+              @active_when = Proc.new do |source_data|
+                keys = data_keys(source_data)
+                attrs.any? {|key| keys.include?(key)}
+              end
+            end
+
+            # Helper to build the `active_when` condition.
+            def active_when_all(*attrs)
+              @active_when = Proc.new do |source_data|
+                keys = data_keys(source_data)
+                attrs.all? {|key| keys.include?(key)}
+              end
+            end
+
+            # Helper to obtain the current internal named attributes of the data
+            # @param source_data [Array<String>, Hash] if `Array` those are already the `keys`, if `Hash` it gets the `keys`
+            # @return [Array<String>] `keys` of `source_data`
+            def data_keys(source_data)
+              case source_data
+              when Array
+                keys = source_data
+              when Hash
+                keys = source_data.keys
+              else
+                keys = []
+              end
+            end
+
+          end
+
+          def initialize(person_parser)
+            raise "Expected Eco::API::Common::People::PersonParser. Given #{policies.class}" unless person_parser.is_a?(Eco::API::Common::People::PersonParser)
+            person_parser.define_attribute(self.attribute, dependencies: self.class.dependencies) do |attr_parser|
+              _define_parser(attr_parser)
+              _define_serializer(attr_parser)
+            end
+          end
+
+          # @param data [Hash] all the person data at the specified `parsing_phase`:
+          #   - when `:internal`: the parser will receive external types (i.e. String with '|' delimiters instead of an Array).
+          #   - when `:final`: the parser will receive the typed values (i.e. Array instread of String with '|' delimiters).
+          # @param deps [Hash] the merged dependencies (default to the class object and when calling the parser).
+          def parser(data, deps)
+            raise "You should implement this method"
+          end
+
+          # @param data [Hash, Ecoportal::API::V1::Person] all the person data at the specified `serializing_phase`:
+          #   - when `:internal`: it will receive a `Hash` with the **internal values** but the types already serialized to `String`.
+          #   - when `:final`: it will receive a `Hash` with the **internal values** and **types**.
+          #   - when `:person`: it will receive the `person` object.
+          # @param deps [Hash] the merged dependencies (default to the class object and when calling the parser).
+          def seralizer(data, deps)
+            raise "You should implement this method"
+          end
+
+          # @return [String, Symbol] the field/attribute or type this parser is linked to.
+          def attribute
+            self.class.attribute
+          end
+
+          private
+
+          def _define_parser(attr_parser)
+            if active_when = self.class.active_when
+              attr_parser.def_parser(self.class.parsing_phase, active_when: active_when, &self.method(:parser))
+            else
+              attr_parser.def_parser(self.class.parsing_phase, &self.method(:parser))
+            end
+          end
+
+          def _define_serializer(attr_parser)
+            attr_parser.def_serializer(self.class.serializing_phase, &self.method(:serializer))
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/eco/api/common/loaders/policy.rb

@@ -0,0 +1,25 @@
+module Eco
+  module API
+    module Common
+      module Loaders
+        class Policy < Eco::API::Common::BaseLoader
+
+          def initialize(policies)
+            raise "Expected Eco::API::Policies. Given #{policies.class}" unless policies.is_a?(Eco::API::Policies)
+            policies.define(self.name, &self.method(:main))
+          end
+
+          # @param people [Eco::API::Organization::People] the people in the queue of the current `job`
+          # @param session [Eco::API::Session] the current session where the usecase kicks in.
+          # @param options [Hash] the options that modify the case behaviour or bring some dependencies.
+          # @param policy [Eco::API::Policies::Policy] the `policy` instance object.
+          # @param job [Eco::API::Session::Batch::Job] the `Batch::Job` that these `people` belong to the queue thereof.
+          def main(people, session, options, policy, job)
+            raise "You should implement this method"
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/eco/api/common/loaders/use_case.rb

@@ -0,0 +1,40 @@
+module Eco
+  module API
+    module Common
+      module Loaders
+        class UseCase < Eco::API::Common::BaseLoader
+
+          class << self
+            # @return [Symbol] the `type` of usecase (i.e. `:sync`, `:transform`, `:import`, `:other`)
+            def type(value = nil)
+              unless value
+                return @type || raise("You should specify a type of case [:sync, :transform, :import, :other] for #{self.class}")
+              end
+              @type = value
+            end
+          end
+
+          def initialize(usecases)
+            raise "Expected Eco::API::UseCases. Given #{usecases.class}" unless usecases.is_a?(Eco::API::UseCases)
+            usecases.define(self.name, type: self.type, &self.method(:main))
+          end
+
+          # The parameters of this method will depend on the `type` of usecase.
+          # @param entries [Eco::API::Common::People::Entries] the input entries with the data.
+          # @param people [Eco::API::Organization::People] the people in the queue of the current `job`
+          # @param session [Eco::API::Session] the current session where the usecase kicks in.
+          # @param options [Hash] the options that modify the case behaviour or bring some dependencies.
+          # @param usecase [Eco::API::Policies::Policy] the `usecase` instance object.
+          def main(entries, people, session, options, usecase)
+            raise "You should implement this method"
+          end
+
+          def type
+            self.class.type
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -5,6 +5,8 @@ module Eco
 
         # Class to define a set of default attribute parsers
         class DefaultParsers < PersonParser
+          autoloads_children_of "Eco::API::Common::Loaders::Parser"
+          autoload_namespace    "Eco::API::Common::People::DefaultParsers"
 
           def initialize(*args)
             super(*args)
@@ -24,16 +26,6 @@ module Eco
             end.compact.to_h
 
             SelectParser.new(self, select_hashes: select_hashes).process
-            BooleanParser.new(self).process
-            NumericParser.new(self).process
-            DateParser.new(self).process
-            MultiParser.new(self).process
-
-            # ALWAYS PRESENT FIELDS
-            SendInvitesParser.new(self).process
-
-            # FORMAT PARSER
-            CSVParser.new(self).process
           end
 
         end
@@ -48,4 +40,7 @@ require_relative 'default_parsers/numeric_parser'
 require_relative 'default_parsers/date_parser'
 require_relative 'default_parsers/multi_parser'
 require_relative 'default_parsers/send_invites_parser'
+require_relative 'default_parsers/freemium_parser'
+require_relative 'default_parsers/policy_groups_parser'
+require_relative 'default_parsers/login_providers_parser'
 require_relative 'default_parsers/csv_parser'

data/lib/eco/api/common/people/default_parsers/boolean_parser.rb

@@ -1,28 +1,18 @@
-module Eco
-  module API
-    module Common
-      module People
-        class DefaultParsers
-          class BooleanParser < People::BaseParser
+class Eco::API::Common::People::DefaultParsers::BooleanParser < Eco::API::Common::Loaders::Parser
+  attribute :boolean
 
-            def process
-              @parsers.define_attribute(:boolean) do |parser|
-                parser.def_parser  do |value|
-                  value.is_a?(Array) ? value.map { |v| truthy(v) } : truthy(value)
-                end.def_serializer do |value|
-                  value.to_s
-                end
-              end
-            end
+  def parser(value, deps)
+    value.is_a?(Array) ? value.map { |v| truthy(v) } : truthy(value)
+  end
+
+  def serializer(value, deps)
+    value.to_s
+  end
 
-            private
+  private
 
-            def truthy (value)
-              %w[true y yes x].include?(value.to_s.strip.downcase)
-            end
-          end
-        end
-      end
-    end
+  def truthy (value)
+    %w[true y yes x].include?(value.to_s.strip.downcase)
   end
+
 end

data/lib/eco/api/common/people/default_parsers/csv_parser.rb

@@ -1,41 +1,26 @@
-module Eco
-  module API
-    module Common
-      module People
-        class DefaultParsers
-          class CSVParser < People::BaseParser
+class Eco::API::Common::People::DefaultParsers::CSVParser < Eco::API::Common::Loaders::Parser
+  attribute :csv
 
-            def process
-              @parsers.define_attribute(:csv, dependencies: @options) do |parser|
-                parser.def_parser  do |data, deps|
-                  arr_hash = []
-                  CSV.parse(data, headers: true, skip_blanks: true).reject do |row|
-                    values = row.to_hash.values
-                    values.all?(&:nil?) || values.map(&:to_s).all?(&:empty?)
-                  end.each do |row|
-                    row_hash = row.headers.uniq.each_with_object({}) do |attr, hash|
-                      value      = row[attr]
-                      hash[attr] = value.to_s.empty?? nil : value
-                    end
-                    arr_hash.push(row_hash)
-                  end
-                  arr_hash
-                end.def_serializer do |array_hash, deps|
-                  arr_rows = []
-                  unless array_hash.empty?
-                    header = array_hash.first.keys
-                    arr_rows = array_hash.map do |csv_row|
-                      CSV::Row.new(header, csv_row.values_at(*header))
-                    end
-                  end
-                  CSV::Table.new(arr_rows).to_csv
-                end
-              end
-            end
+  def parser(data, deps)
+    Eco::CSV.parse(data, headers: true, skip_blanks: true).each_with_object([]) do |row, arr_hash|
+      row_hash = row.headers.uniq.each_with_object({}) do |attr, hash|
+        next if attr.to_s.strip.empty?
+        value            = row[attr]
+        hash[attr.strip] = value.to_s.empty?? nil : value
+      end
+      arr_hash.push(row_hash)
+    end
+  end
 
-          end
-        end
+  def serializer(array_hash, deps)
+    arr_rows = []
+    unless array_hash.empty?
+      header = array_hash.first.keys
+      arr_rows = array_hash.map do |csv_row|
+        CSV::Row.new(header, csv_row.values_at(*header))
       end
     end
+    CSV::Table.new(arr_rows).to_csv
   end
+
 end

data/lib/eco/api/common/people/default_parsers/date_parser.rb

@@ -1,33 +1,22 @@
-module Eco
-  module API
-    module Common
-      module People
-        class DefaultParsers
-          class DateParser < People::BaseParser
+class Eco::API::Common::People::DefaultParsers::DateParser < Eco::API::Common::Loaders::Parser
+  attribute :date
 
-            def process
-              @parsers.define_attribute(:date) do |parser|
-                parser.def_parser  do |value|
-                  value.is_a?(Array) ? value.map { |v| parse_date(v) } :  parse_date(value)
-                end.def_serializer do |value|
-                  value.is_a?(Array) ? value.map { |d| d && d.strftime('%Y-%m-%d') } : value && value.strftime('%Y-%m-%d')
-                end
-              end
-            end
+  def parser(value, deps)
+    value.is_a?(Array) ? value.map { |v| parse_date(v) } : parse_date(value)
+  end
 
-            private
+  def serializer(value, deps)
+    value.is_a?(Array) ? value.map { |d| d && d.strftime('%Y-%m-%d') } : value && value.strftime('%Y-%m-%d')
+  end
 
-            def parse_date(value)
-              begin
-                (value.to_s.empty?) ? nil : Date.parse(value)
-              rescue
-                nil
-              end
-            end
+  private
 
-          end
-        end
-      end
+  def parse_date(value)
+    begin
+      (value.to_s.empty?) ? nil : Date.parse(value)
+    rescue
+      nil
     end
   end
+
 end