eco-helpers 2.6.4 → 2.7.0

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

@@ -93,7 +93,7 @@ module Eco
           end
 
           # Adds an entry(ies) to the job queue.
-          # @param entry [Ecoportal::API::V1::Person, Enumberable<Person>] the person(s) we want to update, carrying the changes to be done.
+          # @param entry [Ecoportal::API::V1::Person, Enumerable<Person>] the person(s) we want to update, carrying the changes to be done.
           # @param unique [Boolean] specifies if repeated entries should be avoided in the queue.
           # @yield [person] callback before launching the batch job request against the server.
           # @yieldparam person [Person] current person object that that should be treated by the callback before launching the batch.

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

@@ -8,12 +8,21 @@ module Eco
 
           attr_key :file, :structure_id
 
+          # The location node classifications of the organization
+          # @return [Eco::API::Organization::NodeClassifications]
+          def node_classifications(active: true)
+            return [] unless (graphql = graphql_api)
+
+            node_types = graphql.locationStructure.nodeClassifications(active: active)
+            Eco::API::Organization::NodeClassifications.new(node_types)
+          end
+
           # @note it retrieves the tree this way:
           #   1. If there's a file tagtree.json file, it uses it
           #   2. If no file, retrieves `structure_id` (config)
           # @param include_archived [Boolean] whether or not it should include archived nodes.
           # @return [Eco::API::Organization::TagTree]
-          def scope_tree(enviro: nil, include_archived: true, raise_on_missing: true)
+          def scope_tree(enviro: nil, include_archived: true, raise_on_missing: true) # rubocop:disable Lint/UnusedMethodArgument
             return @tagtree if instance_variable_defined?(:@tagtree) && @tagtree.enviro == enviro
 
             kargs = {
@@ -21,34 +30,34 @@ module Eco
               includeArchivedNodes: include_archived
             }
 
-            if tree_file = self.file
+            if (tree_file = file)
               if (tree = file_manager.load_json(tree_file)) && !tree.empty?
                 @tagtree = Eco::API::Organization::TagTree.new(tree)
               end
-            elsif self.structure_id
-              kargs.merge(id: self.structure_id)
+            elsif structure_id
+              kargs.merge(id: structure_id)
             end
 
-            @tagtree ||= live_tree(**kargs).tap do |tree|
-              unless tree && !tree.empty?
-                msg = "Could not find a local or live locations structure."
-                raise MissingTagtree, msg
-              end
+            @tagtree ||= live_tree(**kargs).tap do |tr| # rubocop:disable Naming/MemoizedInstanceVariableName
+              next if tr && !tr.empty?
+
+              msg = "Could not find a local or live locations structure."
+              raise MissingTagtree, msg
             end
           end
 
           # Among all the locations structures it selects the one with more location nodes
           # If `id` is provided, it only retrieves this locations structure.
           # @param [enviro] used for re-caching
-          def live_tree(id: nil, enviro: nil, include_archived: false, **kargs, &block)
-            existing_cache   = !!@live_tree
+          def live_tree(id: nil, enviro: nil, include_archived: false, **kargs, &block) # rubocop:disable Metrics/AbcSize
+            existing_cache   = !@live_tree.nil?
             first_load       = !existing_cache
 
             target_change    = existing_cache && id     && @live_tree.id != id
             enviro_change    = existing_cache && enviro && @live_tree.enviro != enviro
 
             switching_target = existing_cache && (target_change || enviro_change)
-            refresh_cache    = existing_cache && !switching_target
+            _refresh_cache   = existing_cache && !switching_target
 
             kargs = {
               includeArchivedNodes: include_archived
@@ -59,10 +68,12 @@ module Eco
               @live_tree = live_tree_get(**args, &block)
             else
               trees      = live_trees(**kargs, &block)
-              @live_tree = trees.reject do |tree|
-                tree.empty?
-              end.max do |a,b|
-                a.count <=> b.count
+              if trees.count > 1
+                @live_tree = trees.reject(&:empty?).max do |a, b|
+                  a.count <=> b.count
+                end
+              else
+                @live_tree = trees.first
               end
             end.tap do |tree|
               if tree
@@ -85,8 +96,7 @@ module Eco
           # @param include_archived [Boolean] whether or not to include archived **nodes**
           # @return [Eco::API::Organization::TagTree, NilClass]
           def live_tree_get(id: nil, include_archived: false, **kargs, &block)
-            return nil unless apis.active_api.version_available?(:graphql)
-            return nil unless graphql = apis.api(version: :graphql)
+            return nil unless (graphql = graphql_api)
 
             kargs = {
               id:                   id,
@@ -94,9 +104,11 @@ module Eco
             }.merge(kargs)
 
             start = Time.now
-            return nil unless tree = graphql.currentOrganization.locationStructure(**kargs, &block)
+            tree  = graphql.currentOrganization.locationStructure(**kargs, &block)
+            return nil unless tree
+
             end_time = Time.now
-            secs    = (end_time - start).round(3)
+            secs     = (end_time - start).round(3)
 
             Eco::API::Organization::TagTree.new(tree.treeify, id: tree.id, name: tree.name).tap do |eco_tree|
               cnt     = eco_tree.count
@@ -110,15 +122,16 @@ module Eco
           # @return [Array<Eco::API::Organization::TagTree>]
           def live_trees(include_archived: false, **kargs, &block)
             [].tap do |eco_trees|
-              next unless apis.active_api.version_available?(:graphql)
-              next unless graphql = apis.api(version: :graphql)
+              next unless (graphql = graphql_api)
 
               kargs = {
                 includeArchivedNodes: include_archived
               }.merge(kargs)
 
               start = Time.now
-              next unless trees = graphql.currentOrganization.locationStructures(**kargs, &block)
+              trees = graphql.currentOrganization.locationStructures(**kargs, &block)
+              next unless trees
+
               end_time = Time.now
               secs     = (end_time - start).round(3)
               cnt      = 0
@@ -134,6 +147,11 @@ module Eco
 
           private
 
+          def graphql_api
+            return nil unless apis.active_api.version_available?(:graphql)
+            apis.api(version: :graphql)
+          end
+
           def session
             ASSETS.session
           end

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

@@ -7,13 +7,13 @@ module Eco
 
           WORKFLOW_MODEL = [
             :options,
-            {load: [{input: [:get, :filter]}, {people: [:get, :filter]}, :filter]},
+            {load: [{input: %i[get filter]}, {people: %i[get filter]}, :filter]},
             :usecases, :launch_jobs,
-            {post_launch: [:usecases, :launch_jobs]},
+            {post_launch: %i[usecases launch_jobs]},
             :report,
             :end,
             :close
-          ]
+          ].freeze
 
           class << self
             def stages
@@ -40,7 +40,7 @@ module Eco
           self.model = WORKFLOW_MODEL
           attr_reader :config
 
-          def initialize(name = nil, _parent: self, config:)
+          def initialize(name = nil, config:, _parent: self) # rubocop:disable Lint/UnderscorePrefixedVariableName
             @config   = config
             @name     = name
 
@@ -97,7 +97,7 @@ module Eco
           #   2. if block is not provided, it returns the **stage** referred by `key`
           def for(key = nil, &block)
             raise ArgumentError, "With no 'key', a block should be given." unless key || block_given?
-            self.tap do
+            tap do
               next yield(self)            unless key
               next stage(key).for(&block) if block_given?
               return stage(key)
@@ -106,7 +106,8 @@ module Eco
           alias_method :with, :for
 
           # Used in **configuration** time **to define** the **behaviour**  the target (sub)stage `key`
-          # @note if a `block` is provided it will **not** `yield` the target stage immediately, but when the _workflow_ reaches the stage
+          # @note if a `block` is provided it will **not** `yield` the target stage immediately,
+          #   but when the _workflow_ reaches the stage
           # @param key [Symbol, nil] cases:
           #   - if `key` is not provided, it targets the _current stage_
           #   - if `key` is provided, it targets the specific _sub-stage_
@@ -117,16 +118,18 @@ module Eco
           # @return [Eco::API::Session::Config::Workflow] the current stage object (to ease chainig).
           def on(key = nil, &block)
             raise ArgumentError, "A block should be given." unless block_given?
-            if !key
-              @on = block
-            else
+            if key
               stage(key).on(&block)
+            else
+              @on = block
             end
             self
           end
 
-          # When there is an `Exception`, you might have defined some `callback` to do something with it (i.e. register, email)
-          # @yield [exception, io] the `callback` to do something with an `Exception` raised within this _workflow_ stage
+          # When there is an `Exception`, you might have defined some `callback`
+          # to do something with it (i.e. register, email)
+          # @yield [exception, io] the `callback` to do something with
+          #   an `Exception` raised within this _workflow_ stage
           # @yieldparam exception [Exception] the exception object that was raised
           # @yieldparam io [Eco::API::UseCases::BaseIO] the input/output object carried througout all the _workflow_
           # @yieldreturn [Eco::API::UseCases::BaseIO] the `io` input/output object carried througout all the _workflow_
@@ -146,46 +149,50 @@ module Eco
             self
           end
 
-          # Used in **configuration** time **add previous** `callbacks` **before** the `on` _callback_ of the (sub)stage `key` is actually `run`
+          # Used in **configuration** time **add previous** `callbacks`
+          # **before** the `on` _callback_ of the (sub)stage `key` is actually `run`
           # @note
           #   - it will **not** `yield` it immediately, but when the _workflow_ reaches the target stage
           #   - in this case, you can define multiple `callbacks`
           # @param key [Symbol, nil] cases:
           #   - if `key` is not provided, it targets the _current stage_
           #   - if `key` is provided, it targets the specific _sub-stage_
-          # @yield [stage_workflow, io] one of the things to do **before** the `on` _callback_ of the (sub)stage `key` is actually `run`
+          # @yield [stage_workflow, io] one of the things to do **before** the
+          #  `on` _callback_ of the (sub)stage `key` is actually `run`
           # @yieldparam stage_workflow [Eco::API::Session::Config::Workflow] the _target stage_  referred by `key`
           # @yieldparam io [Eco::API::UseCases::BaseIO] the input/output object carried througout all the _workflow_
           # @yieldreturn [Eco::API::UseCases::BaseIO] `io` the input/output object carried througout all the _workflow_
           # @return [Eco::API::Session::Config::Workflow] the current stage object (to ease chainig).
           def before(key = nil, &block)
             raise ArgumentError, "A block should be given." unless block_given?
-            if !key
-              @before.push(block)
-            else
+            if key
               stage(key).before(&block)
+            else
+              @before.push(block)
             end
             self
           end
 
-          # Used in **configuration** time **add previous** `callbacks` **after** the `on` _callback_ of the (sub)stage `key` is actually `run`
+          # Used in **configuration** time **add previous** `callbacks` **after** the `on` _callback_
+          # of the (sub)stage `key` is actually `run`
           # @note
           #   - it will **not** `yield` it immediately, but when the _workflow_ reaches the target stage
           #   - in this case, you can define multiple `callbacks`
           # @param key [Symbol, nil] cases:
           #   - if `key` is not provided, it targets the _current stage_
           #   - if `key` is provided, it targets the specific _sub-stage_
-          # @yield [stage_workflow, io] one of the things to do **after** the `on` _callback_ of the (sub)stage `key` is actually `run`
+          # @yield [stage_workflow, io] one of the things to do **after** the
+          #   `on` _callback_ of the (sub)stage `key` is actually `run`
           # @yieldparam stage_workflow [Eco::API::Session::Config::Workflow] the _target stage_  referred by `key`
           # @yieldparam io [Eco::API::UseCases::BaseIO] the input/output object carried througout all the _workflow_
           # @yieldreturn [Eco::API::UseCases::BaseIO] `io` the input/output object carried througout all the _workflow_
           # @return [Eco::API::Session::Config::Workflow] the current stage object (to ease chainig).
           def after(key = nil, &block)
             raise ArgumentError, "A block should be given." unless block_given?
-            if !key
-              @after.push(block)
-            else
+            if key
               stage(key).after(&block)
+            else
+              @after.push(block)
             end
             self
           end
@@ -202,8 +209,8 @@ module Eco
           #   - it will **not** run the `callback` for `on` defined during the configuration time
           #   - it will rather `yield` the target stage after all the `before` _callbacks_ have been run
           #   - aside of this, the rest will be the same as when the _block_ is provided (see previous note)
-          # @note [if the object returned by `before`, `after` and `run` callbacks is not an `Eco::API::UseCases::BaseIO`,
-          #   the original `io` object will be returned instead.
+          # @note [if the object returned by `before`, `after` and `run` callbacks
+          #   is not an `Eco::API::UseCases::BaseIO`, the original `io` object will be returned instead.
           # @param key [Symbol, nil] cases:
           #   - if `key` is not provided, it targets the _current stage_
           #   - if `key` is provided, it targets the specific _sub-stage_
@@ -216,71 +223,81 @@ module Eco
           def run(key = nil, io:, &block)
             raise "Missing BaseIO object" unless io.is_a?(Eco::API::UseCases::BaseIO)
 
-            if key
-              io = io_result(io: io) do
-                stage(key).run(io: io, &block)
-              end
-            elsif pending?
-              @before.each do |c|
+            rescuable(io) do
+              if key
                 io = io_result(io: io) do
-                  io.evaluate(self, io, &c)
+                  stage(key).run(io: io, &block)
                 end
+              elsif pending?
+                io = run_before(io)
+                io = run_it(io, &block) unless skip?
+                io = run_after(io)
               end
+              io
+            ensure
+              @pending = false
+            end
+          end
 
-              unless skip?
-                io.session.logger.debug("(Workflow: #{path}) running now")
-                if block
-                  io = io_result(io: io) do
-                    io.evaluate(self, io, &block)
-                  end
-                else
-                  existing_stages.each do |stg|
-                    io = io_result(io: io) do
-                      stg.run(io: io)
-                    end
-                  end
-
-                  unless ready?
-                    msg = "(Workflow: #{path}) 'on' callback is not defined, nor block given"
-                    io.session.logger.debug(msg)
-                  end
-                  io = io_result(io: io) do
-                    io.evaluate(self, io, &@on)
-                  end
-                end
-                @pending = false
+          protected
+
+          def root?
+            @_parent == self
+          end
+
+          def path
+            return name if root?
+            "#{@_parent.path}:#{name}"
+          end
+
+          def ready?
+            !!@on
+          end
+
+          def run_before(io)
+            @before.each do |c|
+              io = io_result(io: io) do
+                io.evaluate(self, io, &c)
               end
+            end
+            io
+          end
+
+          def run_after(io)
+            @after.each do |c|
+              io = io_result(io: io) do
+                io.evaluate(self, io, &c)
+              end
+            end
+            io
+          end
 
-              @after.each do |c|
+          def run_it(io, &block)
+            io.session.logger.debug("(Workflow: #{path}) running now")
+            if block
+              io = io_result(io: io) do
+                io.evaluate(self, io, &block)
+              end
+            else
+              existing_stages.each do |stg|
                 io = io_result(io: io) do
-                  io.evaluate(self, io, &c)
+                  stg.run(io: io)
                 end
               end
+
+              unless ready?
+                msg = "(Workflow: #{path}) 'on' callback is not defined, nor block given"
+                io.session.logger.debug(msg)
+              end
+              io = io_result(io: io) do
+                io.evaluate(self, io, &@on)
+              end
             end
             io
-          rescue SystemExit => e
-            io = io_result(io: io) do
-              io.evaluate(e, io, &self.exit_handle)
-            end
-            exit e.status
-          rescue Interrupt => i
-            raise
-          rescue Exception => e
-            # raise unless self.rescue
-            io = io_result(io: io) do
-              io.evaluate(e, io, &self.rescue)
-            end
-            raise
           ensure
             @pending = false
           end
 
-          protected
-
-          def root?
-            @_parent == self
-          end
-
           # It ensures an `Eco::API::UseCases::BaseIO` is returned
           # @note it always brings the IO to be a `BaseIO`.
           #   As the `output` and the type is captured, it just cleans usecase related
@@ -296,19 +313,6 @@ module Eco
             io.instance_of?(klass) ? io : io.base
           end
 
-          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
@@ -316,17 +320,38 @@ module Eco
           end
 
           def ready_stages
-            exiting_stages.select {|s| s.ready?}
+            exiting_stages.select(&:ready?)
           end
 
           def stages_ready?
-            existing_stages.all? {|s| s.ready?}
+            existing_stages.all?(&:ready?)
           end
 
           def stage(key)
             self.class.validate_stage(key)
             @stages[key] ||= self.class.workflow_class(key).new(key, _parent: self, config: config)
           end
+
+          # helper to treat trigger the exit and rescue handlers
+          def rescuable(io)
+            yield
+          # rescue SystemStackError => err
+          #   puts err.patch_full_message(trace_count: 100)
+          #   exit 1
+          rescue SystemExit => err
+            io = io_result(io: io) do
+              io.evaluate(err, io, &exit_handle)
+            end
+            exit err.status
+          rescue Interrupt => _int
+            raise
+          rescue StandardError => err
+            # raise unless self.rescue
+            io = io_result(io: io) do
+              io.evaluate(err, io, &self.rescue)
+            end
+            raise
+          end
         end
       end
     end

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

@@ -238,6 +238,12 @@ module Eco
           tagtree_config.structure_id = value
         end
 
+        # The location node classifications of the organization
+        # @return [Eco::API::Organization::NodeClassifications]
+        def node_classifications(active: true)
+          tagtree_config.node_classifications(active: active)
+        end
+
         # It uses the `tagtree.json` file and in its absence, if `graphql` enabled, the largest `life_tagtree`
         # @note it does NOT include archived nodes by default.
         #   - This is for legacy (most usecases don't)

data/lib/eco/api/session.rb

@@ -5,16 +5,24 @@ module Eco
     class Session < Common::Session::BaseSession
       #@param init [Eco::API::Session::Config, Eco::API::Common::Session::Environment] object to ini the session
       def initialize(init = {})
-        e = init
-        msg = "Expected object Eco::API::Session::Config or Eco::API::Common::Session::Environment. Given: #{init}"
-        raise msg  unless e.is_a?(Session::Config) || e.is_a?(Eco::API::Common::Session::Environment)
-        e = Eco::API::Common::Session::Environment.new(init, session: self) if !e.is_a?(Eco::API::Common::Session::Environment)
-        super(e)
+        env = init
+
+        msg  = "Expected object Eco::API::Session::Config or Eco::API::Common::Session::Environment. "
+        msg << " Given: #{init}"
+
+        correct_env = env.is_a?(Session::Config) || env.is_a?(Eco::API::Common::Session::Environment)
+        raise ArgumentError, msg unless correct_env
+
+        unless env.is_a?(Eco::API::Common::Session::Environment)
+          env = Eco::API::Common::Session::Environment.new(init, session: self)
+        end
+
+        super(env)
 
         @entry_factories  = {}
         @person_factories = {}
 
-        logger.debug("LINE COMMAND: #{$0} #{ARGV.join(" ")}")
+        logger.debug("LINE COMMAND: #{$0} #{ARGV.join(" ")}") # rubocop:disable Style/SpecialGlobalVars
       end
 
       # @retrun [String] the name of the current environment
@@ -24,7 +32,7 @@ module Eco
 
       # @return [Eco::API::Session::Batch] provides helper to launch batch operations.
       def batch
-        @batch  ||= Batch.new(enviro)
+        @batch ||= Batch.new(enviro)
       end
 
       # @!group Pure organization helpers
@@ -39,6 +47,12 @@ module Eco
         config.login_providers
       end
 
+      # The location node classifications of the organization
+      # @return [Eco::API::Organization::NodeClassifications]
+      def node_classifications(active: true)
+        config.node_classifications(active: active)
+      end
+
       # @param live [Boolean] states preference of `live` tree if available over file.
       # @param merge [Boolean] when in `live` mode, if mulitple trees, merge into one.
       # @see Eco::API::Session::Config#tagtree
@@ -79,11 +93,12 @@ module Eco
       end
 
       # Sets the current target `PersonSchema` of this session.
-      # @note observe that it is essential for the parsers/serialisers to identify target/present attributes.
-      # @param value [String, Ecoportal::API::V1::PersonSchema] where `String` can be the _name_ or the _id_ of the schema.
+      # @note observe that it is essential for the parsers/serialisers to identify
+      #   target/present attributes.
+      # @param value [String, Ecoportal::API::V1::PersonSchema] where `String`
+      #   can be the _name_ or the _id_ of the schema.
       def schema=(value)
         @schema = to_schema(value)
-        self
       end
 
       # Helper to state the abilities that a person should have with given their usergroups
@@ -95,7 +110,7 @@ module Eco
       def fields_mapper
         return @fields_mapper if instance_variable_defined?(:@fields_mapper)
         mappings = []
-        if map_file = config.people.fields_mapper
+        if (map_file = config.people.fields_mapper)
           mappings = map_file ? file_manager.load_json(map_file) : []
         end
         @fields_mapper = Eco::Data::Mapper.new(mappings)
@@ -140,7 +155,7 @@ module Eco
       # @param phase [Symbol] the phase when this parser should be active.
       # @return [Object] the parsed attribute.
       def parse_attribute(attr, source, phase = :internal, deps: {})
-        unless parsers = entry_factory.person_parser
+        unless (parsers = entry_factory.person_parser)
           raise "There are no parsers defined"
         end
         parsers.parse(attr, source, phase, deps: deps)
@@ -182,10 +197,10 @@ module Eco
       # @return [Eco::API::Common::People::Entries] collection of entries.
       def csv_entries(file, **kargs)
         kargs.merge!({
-          file: file,
+          file:   file,
           format: :csv
         })
-        return entries(**kargs)
+        entries(**kargs)
       end
 
       # Generates the collection of entries that should be discarded from an update.
@@ -193,8 +208,11 @@ module Eco
       # @return [Eco::API::Common::People::Entries] collection of entries.
       def discarded_entries
         return @discarded_entries if instance_variable_defined?(:@discarded_entries)
+
         file = config.people.discarded_file
-        fatal("You have not specified the 'discarded_people_file'") unless file = file_manager.dir.file(file)
+        file = file_manager.dir.file(file)
+        fatal("You have not specified the 'discarded_people_file'") unless file
+
         @discarded_entries = csv_entries(file)
       end
       # @!endgroup
@@ -234,7 +252,7 @@ module Eco
       # @see Eco::API::MicroCases
       # @return [Eco::API::MicroCases]
       def micro
-        @micro    ||= Eco::API::MicroCases.new(enviro)
+        @micro ||= Eco::API::MicroCases.new(enviro)
       end
 
       def post_launch
@@ -255,18 +273,23 @@ module Eco
       # It retrives the group of `Batch::Jobs` named `name`. It creates it if it doesn't exist.
       # @return [Eco::API::Session::Batch::Jobs]
       def job_group(name, order: :last)
-        case
-        when job_groups.exists?(name)
-          job_groups[name]
-        else
-          job_groups.new(name, order: order)
-        end
+        return job_groups[name] if job_groups.exists?(name)
+
+        job_groups.new(name, order: order)
       end
 
       # Shortcut to create a job of certain type within a group
       # @param [see @Eco::API::Session::Batch::Jobs#new]
       # @return [Eco::API::Session::Batch::Job]
-      def new_job(group, name, type, usecase, sets = [:core, :details, :account], accept_update_with_no_id = false, &block)
+      def new_job(
+        group,
+        name,
+        type,
+        usecase,
+        sets = %i[core details account],
+        accept_update_with_no_id = false, # rubocop:disable Style/OptionalBooleanParameter
+        &block
+      )
         job_group(group).new(name, usecase: usecase, type: type, sets: sets, accept_update_with_no_id: accept_update_with_no_id, &block)
       end
 
@@ -330,10 +353,10 @@ module Eco
       private
 
       # Comparer to state if 2 schemas are different
-      def same_schema? (schema1, schema2)
-        eq   = schema1&.id == schema2&.id
-        eq ||= schema1&.name&.downcase == schema2&.name&.downcase
-        schema1 && schema2 && eq
+      def same_schema?(schema_1, schema_2)
+        eq   = schema_1&.id == schema_2&.id
+        eq ||= schema_1&.name&.downcase == schema_2&.name&.downcase
+        schema_1 && schema_2 && eq
       end
 
       # from schema `id` or `name` to a PersonSchema object
@@ -342,7 +365,7 @@ module Eco
         sch = nil
         case value
         when String
-          unless sch = schemas.schema(value)
+          unless (sch = schemas.schema(value))
             fatal "The schema with id or name '#{value}' does not exist."
           end
         when Ecoportal::API::V1::PersonSchema
@@ -352,7 +375,6 @@ module Eco
         end
         sch
       end
-
     end
   end
 end