eco-helpers 2.0.60 → 2.0.61

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 182922a2146b1fa50b0372253a5279eb7d801c4fabd8fcd5303dd6322091c91c
-  data.tar.gz: 5f807f72bc3b6fc7a376bbd43d7a10b99cb5144a606ded5f9eb6817b82740788
+  metadata.gz: 21aabfeb392bd158c029ee8c1cd2503d0d6686d339333c80757a7fda273e9095
+  data.tar.gz: 23e15a543b809c2b8b9c0e51e17982da4915c7af170ddb18207b162d74752d22
 SHA512:
-  metadata.gz: 40cb65992b4c9524e025b7f7073f699062cd22008202491c593089b662c9b72ac611eb9cfcccfe14a2f62e1d519eb5dad14fef9389b6e2cbee1798ced0baa54f
-  data.tar.gz: 3e3154fcf629162a1445acbafd96f2d00f8d2a84f77bfb9b2cb68ce6c7f36ed4e8f5fea3cee43e897ac1b50b0210fd14bf9489b0a6708a6bc954093a7b1af3f8
+  metadata.gz: 777199fdf96345d5a694233c376317b008d6eb25abb736a42a1e8298b354ab7e13198149c81f699fdbc42aa414feaa05b0dd5a75bc34a0e43e75aa6a7c495a70
+  data.tar.gz: 9bca2a777df96adf7f6245627523f80480ba2e3626d89a179251507998365ca518b927267e381356fa2b9fc287a6593d4f1d60767c94fdd7f724a76b835aee77

data/CHANGELOG.md

@@ -1,13 +1,38 @@
 # Change Log
 All notable changes to this project will be documented in this file.
 
-## [2.0.60] - 2022-06-xx
+## [2.0.61] - 2022-07-xx
 
 ### Added
+  - patch for `Ecoportal::API::Common::Client#host` exposed `host` property
+  - `skip-header-checks` option
+    - It prevents checks done in the `Eco::API::Common::People::DefaultParsers::CSVParser`
+  - **Export Helpers** to be able to automate exports via `APIv2`
+    - `Eco::API::UseCases::OozeSamples::Helpers::ExportableRegister`
+    - `Eco::API::UseCases::OozeSamples::Helpers::ExportableOoze`
+  - `Eco::API::UseCases::OozeCases::ExportRegisterCase` to export registers
+    - First ooze native use case (besides the samples)
+
 ### Changed
+  - upgraded `ecoportal-api-v2` to version `0.8.30`
+
+### Fixed
+  - `-entries-to-csv` case; option `-out` was not being used
+  - `Eco::API::Common::People::Entries#export` made it so it creates one column per key
+    - It was wrongly merging the entries assuming all of them had the same keys
+    - This also fixes the `-entries-to-csv` case, which can be used with `entries-from` option to correctly merge multiple input files with no data loss
+  - `Eco::API::UseCases::OozeSamples::RegisterExportCase`
+    - On prompt to launch, it answers `Yes`
+    - It correctly captures the `state` based on the stages `state`
+    - It was not building the model
+    - Optimized
+    - It returns a `PageStage` (rather than `Page`), to ensure all supported properties are accessible (i.e. `uid`)
+
+## [2.0.60] - 2022-07-01
+
 ### Fixed
   - `Ecoportal::API::V1::PersonDetails.key?` patched
-  
+
 ## [2.0.59] - 2022-06-07
 
 ### Added

data/eco-helpers.gemspec

@@ -31,7 +31,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "redcarpet", ">= 3.5.1",  "< 3.6"
 
   spec.add_dependency 'ecoportal-api', '>= 0.8.5', '< 0.9'
-  spec.add_dependency 'ecoportal-api-v2', '>= 0.8.28', '< 0.9'
+  spec.add_dependency 'ecoportal-api-v2', '>= 0.8.30', '< 0.9'
   spec.add_dependency 'aws-sdk-s3',    '>= 1.83.0', '< 2'
   spec.add_dependency 'aws-sdk-ses',   '>= 1.36.0', '< 2'
   spec.add_dependency 'dotenv',        '>= 2.7.6', '< 2.8'

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

@@ -3,7 +3,7 @@ class Eco::API::Common::People::DefaultParsers::CSVParser < Eco::API::Common::Lo
 
   def parser(data, deps)
     Eco::CSV.parse(data, headers: true, skip_blanks: true).tap do |table|
-      check_headers(table) if deps[:check_headers]
+      check_headers(table) if deps[:check_headers] && !options.dig(:input, :skip_header_check)
     end.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?
@@ -26,6 +26,10 @@ class Eco::API::Common::People::DefaultParsers::CSVParser < Eco::API::Common::Lo
 
   private
 
+  def options
+    ASSETS.cli.options
+  end
+
   def parse_string(value)
     return nil if value.to_s.empty?
     return nil if null?(value)

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

@@ -154,12 +154,13 @@ module Eco
           # Helper to dump the entries into a CSV
           # @param filename [String] the destination file
           def export(filename)
+            header = each_with_object([]) do |entry, header|
+              header.push(*entry.internal_entry.keys).uniq!
+            end
             CSV.open(filename, "w") do |csv|
-              entry  = self.first
-              header = entry.internal_entry.keys
               csv << header
               self.each do |entry|
-                csv << entry.internal_entry.values
+                csv << entry.internal_entry.values_at(*header)
               end
             end
           end

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

@@ -0,0 +1,9 @@
+module Ecoportal
+  module API
+    module Common
+      class Client
+        attr_reader :host
+      end
+    end
+  end
+end

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

@@ -1,3 +1,4 @@
+require_relative 'ecoportal_api/client'
 require_relative 'ecoportal_api/external_person'
 require_relative 'ecoportal_api/external_details'
 require_relative 'ecoportal_api/internal_person'

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

@@ -4,6 +4,7 @@ module Eco
       class DefaultCases < Eco::API::UseCases
         autoloads_children_of "Eco::API::Common::Loaders::UseCase"
         autoload_namespace    "Eco::API::UseCases::DefaultCases"
+        autoload_namespace    "Eco::API::UseCases::OozeCases"
       end
     end
   end

data/lib/eco/api/usecases/ooze_cases/export_register_case.rb

@@ -0,0 +1,99 @@
+# Use case to export a register into a CSV
+class Eco::API::UseCases::OozeCases::ExportRegisterCase < Eco::API::UseCases::OozeSamples::RegisterExportCase
+  name "export-register"
+  type :other
+  batch_size 5
+
+  def main(session, options, usecase)
+
+    super(session, options, usecase) do
+      # Save the File
+      CSV.open(filename, "w") do |csv|
+        csv << exportable_register.header(refresh: true)
+        exportable_register.each(as_values: true) do |values|
+          csv << values
+        end
+      end
+    end
+  end
+
+  def process_ooze(ooz)
+    exportable_register.add_ooze(ooz)
+    exportable_register.header
+  end
+
+  def filters
+    [].tap do |fltrs|
+      [:any, :all].each {|mode| fltrs << build_tags_filter(mode)}
+      [:created_at, :updated_at].each {|key| fltrs << build_range_filter(key)}
+    end.compact
+  end
+
+  private
+
+  def exportable_register
+    @exportable_register ||= exportable_register_class.new(**export_options)
+  end
+
+  def exportable_register_class
+    Eco::API::UseCases::OozeSamples::Helpers::ExportableRegister
+  end
+
+  def build_tags_filter(mode = :any)
+    tags = option_tags(mode)
+    return nil if !tags || tags.empty?
+    tags_filter(tags, any: mode == :any)
+  end
+
+  def build_range_filter(key = :update_at)
+    from = from_date(key); to = to_date(key)
+    return nil unless from || to
+    date_range_filter(from: from, to: to, key: key)
+  end
+
+  def from_date(key)
+    options.dig(:export, :options, :filters, key, :from)
+  end
+
+  def to_date(key)
+    options.dig(:export, :options, :filters, key, :to)
+  end
+
+  def option_tags(mode = :any)
+    options.dig(:export, :options, :filters, :tags, mode)
+  end
+
+  def export_options
+    @export_options ||= {
+      delimiter: options_delimiter,
+      only_indexed: include_deindexed?,
+      only_labeled: include_unnamed?,
+      only_with_ref: include_unhashed?
+    }
+  end
+
+  def include_unnamed?
+    options.dig(:export, :options, :include, :unnamed)
+  end
+
+  def options_delimiter
+    options.dig(:export, :options, :delimiter) || "|"
+  end
+
+  def include_deindexed?
+    options.dig(:export, :options, :include, :deindexed)
+  end
+
+  def include_unhashed?
+    options.dig(:export, :options, :include, :unhashed)
+  end
+
+  def filename
+    @filename ||= (options[:file] || options.dig(:export, :file, :name)).tap do |filename|
+      unless filename
+        session.logger.error("Destination file not specified")
+        return false
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+module Eco
+  module API
+    class UseCases
+      class OozeCases
+      end
+    end
+  end
+end
+
+require_relative 'ooze_cases/export_register_case'

data/lib/eco/api/usecases/ooze_samples/helpers/exportable_ooze.rb

@@ -0,0 +1,169 @@
+module Eco
+  module API
+    class UseCases
+      class OozeSamples
+        module Helpers
+          # Class to ease the export process
+          class ExportableOoze
+            MERGE_DELIMITER = "#:#"
+
+            META_FIELDS = {
+              "id"   => "Internal ID",
+              "uid"  => "Unique ID",
+              "name" => "Name of Page",
+              "state" => "State of Page",
+              "time_zone" => "Time Zone",
+              "created_at" => "Page Created",
+              "updated_at" => "Last updated",
+              "tags" => "Location Tags"
+            }
+
+            class << self
+              def label?(field)
+                !label(field).to_s.strip.empty?
+              end
+
+              def label(field, default: nil)
+                value = nil
+                value ||= field.label.to_s.strip if field.respond_to?(:label)
+                value = (!value || value.empty?) ? nil : value
+                return value if value || !default
+                default || "Unnamed field:"
+              end
+
+              def key_ref_label(field, default: nil)
+                "#{field_ref(field)}#{MERGE_DELIMITER}#{label(field, default: default)}"
+              end
+
+              def key_to_label(str)
+                return str unless str.include?(MERGE_DELIMITER)
+                str.split(MERGE_DELIMITER).last
+              end
+
+              def key_to_ref(str)
+                return str unless str.include?(MERGE_DELIMITER)
+                ref = str.split(MERGE_DELIMITER).first
+                ref.to_s.strip.empty?? nil : ref
+              end
+
+              def indexed?(field)
+                !field.deindex
+              end
+
+              def with_ref?(field)
+                !field.ref_backend.to_s.strip.empty?
+              end
+
+              def field_ref(field)
+                field.ref_backend || field.ref(any_length: true)
+              end
+            end
+
+            include Eco::API::UseCases::OozeSamples::Helpers::OozeHandlers
+
+            attr_reader :ooze
+            attr_reader :options
+
+            def initialize(ooze, **options)
+              raise "Expecting Ecoportal::API::V2::Page. Given: #{ooze.class}" unless ooze.is_a?(Ecoportal::API::V2::Page)
+              @ooze = ooze
+              @options = options.merge({
+                delimiter: "\n",
+                only_indexed: true,
+                only_labeled: true,
+                only_with_ref: true
+              })
+            end
+
+            def delimiter
+              options[:delimiter] || "\n"
+            end
+
+            # It offers an intermediate structure that can be aligned with other oozes
+            # @note
+            #   - This method merges indexed values
+            #   - It overrides even between fields of different type
+            # @param only_indexed: [Boolean]
+            # @param only_labeled: [Boolean]
+            # @param only_with_ref: [Boolean]
+            # @return [Array[Hash]]
+            def key_typed_data(**options)
+              options.merge!(options)
+              meta_fields.tap do |data|
+                with_field_section_pairs do |field, section|
+                  next unless export?(field)
+                  key = self.class.key_ref_label(field, default: alternative_label(field, section))
+                  data[key] = merge_values(data[key], to_value(field), klass: field.class, delimiter: delimiter)
+                end
+              end
+            end
+
+            # Helper to go through fields and sections in the order they appear.
+            # @note
+            #   1. It prevents duplicated sections
+            # @yield [field, section] once per field and section.
+            # @yieldparam field [Component] a field.
+            # @yieldparam section [Section] the section that holds the field.
+            # @return [Array<Array] Ordered `Array` of pairs of field and section thereof.
+            def with_field_section_pairs
+              sections = []
+              ordered_sections.each_with_object([]) do |section, out|
+                next if sections.include?(section)
+                sections << section
+                section.components.each do |field|
+                  out << [field, section]
+                  yield(field, section) if block_given?
+                end
+              end
+            end
+
+            private
+
+            def meta_fields
+              META_FIELDS.each_with_object({}) do |(attr, name), data|
+                data[name] = ooze.respond_to?(attr)? ooze.send(attr).to_s : nil
+              end
+            end
+
+            def ordered_sections
+              if ooze.stages?
+                ooze.stages.ordered.each_with_object([]) do |stage, sections|
+                  sections.push(*stage.sections).uniq!
+                end
+              else
+                ooze.sections.sort_by.with_index do |sec, index|
+                  [sec.weight, index]
+                end
+              end
+            end
+
+            def export?(field, **opts)
+              opts = options.merge(opts)
+              return false unless field.respond_to?(:to_s)
+              return false if opts[:only_indexed] && !self.class.indexed?(field)
+              return false if opts[:only_labeled] && !self.class.label?(field)
+              return false if opts[:only_with_ref] && !self.class.with_ref?(field)
+              true
+            end
+
+            def alternative_label(field, section)
+              "#{field.type.upcase}::#{section.heading}"
+            end
+
+            def to_value(field, delimiter: self.delimiter)
+              return nil unless field.respond_to?(:to_s)
+              return field.to_s unless offers_delimiter?(field.method(:to_s))
+              field.to_s(delimiter: delimiter)
+            end
+
+            def offers_delimiter?(method)
+              method.parameters.any? do |(type, name)|
+                (type == :key) && name == :delimiter
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eco/api/usecases/ooze_samples/helpers/exportable_register.rb

@@ -0,0 +1,72 @@
+module Eco
+  module API
+    class UseCases
+      class OozeSamples
+        module Helpers
+          # Class to ease the export process
+          class ExportableRegister
+
+            attr_reader :options
+
+            include Eco::API::UseCases::OozeSamples::Helpers::OozeHandlers
+            include Enumerable
+
+            def initialize(**options)
+              @options = options.merge({
+                delimiter: "\n",
+                only_indexed: true,
+                only_labeled: true,
+                only_with_ref: true
+              })
+            end
+
+            def add_ooze(ooze)
+              ooz = ExportableOoze.new(ooze, **options)
+              data = ooz.key_typed_data
+              @typed_header = merge_arrays(data.keys, typed_header)
+              key_typed_data << data
+            end
+
+            def empty?
+              count < 1
+            end
+
+            def each(as_values: true, as_row: false, &block)
+              return to_enum(:each, as_row: as_row) unless block
+              key_typed_data.each do |ooze_data|
+                values = ooze_data.values_at(*typed_header)
+                case
+                when as_values
+                  values
+                when as_row
+                  ::CSV::Row.new(values, header)
+                else
+                  header.zip(values)
+                end.tap do |out|
+                  yield(out)
+                end
+              end
+            end
+
+            def header(refresh: false)
+              return @header if instance_variable_defined?(:@header) && !refresh
+              @header = typed_header.map do |name|
+                ExportableOoze.key_to_label(name)
+              end
+            end
+
+            private
+
+            def typed_header
+              @typed_header ||= []
+            end
+
+            def key_typed_data
+              @typed_keyed_data ||= []
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eco/api/usecases/ooze_samples/helpers/filters.rb

@@ -0,0 +1,72 @@
+module Eco
+  module API
+    class UseCases
+      class OozeSamples
+        module Helpers
+          module Filters
+            FILTER_TIME_FORMAT = '%Y-%m-%dT%H:%M:%SZ'
+
+            def tags_filter(tags, any: true, negate: false)
+              tags = [tags].flatten.compact
+              return nil if tags.empty?
+              key, name = field_key_name(:tags)
+              {
+                "tags": tags,
+                "mode": any ? "any" : "all",
+                "negate": negate,
+                "key": key,
+                "name": name,
+                "type": "tag_filter"
+              }
+            end
+
+            def date_range_filter(from: nil, to: nil, key: :updated_at)
+              return nil unless from || to
+              key, name = field_key_name(key)
+              {
+                "relstart": "today",
+                "time_zone": "Pacific/Auckland",
+                "relative": false,
+                "key": key,
+                "name": name,
+                "type": "date_filter"
+              }.tap do |out|
+                out.merge!("lbound": to_date_filter(from)) if from
+                out.merge!("ubound": to_date_filter(to)) if to
+              end
+            end
+
+            def to_date_filter(date)
+              daystart(date).utc.strftime(FILTER_TIME_FORMAT)
+            end
+
+            def set_time(date, h, m, s); Time.new(date.year, date.month, date.day, h, m, s); end
+            def weeks(num); num * days(7); end
+            def days(num);  num * 60 * 60 * 24; end
+            def today; Date.today.to_time; end
+            def sunday(date); date + days(7 - weekday(date)); end
+            def midnight(date); set_time(date, 23, 59, 59); end
+            def daystart(date); set_time(date, 0, 0, 0); end
+            def previous_sunday(date); midnight(sunday(date - weeks(1)));  end
+            def this_monday(date); set_time(previous_sunday(as_at_date) + days(1), 0, 0, 0);  end
+
+            def field_key_name(value)
+              case value
+              when :updated_at
+                ["updated_at", "Last updated"]
+              when :created_at
+                ["created_at", "Page created"]
+              when Ecoportal::API::V2::Page::Component
+                [value.ref_backend, value.label]
+              when :tags
+                ["tags", "Location Tags"]
+              else
+                [nil , nil]
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eco/api/usecases/ooze_samples/helpers/ooze_handlers.rb

@@ -0,0 +1,85 @@
+module Eco
+  module API
+    class UseCases
+      class OozeSamples
+        module Helpers
+          module OozeHandlers
+            def merge_values(origin, append, klass: nil, delimiter: "\n")
+              return origin if !append || append.to_s.strip.empty?
+              return append if !origin || origin.to_s.strip.empty?
+              case klass
+              when Ecoportal::API::V2::Page::Component::RichTextField
+                merge_values(origin, append, delimiter: "\n")
+              when Ecoportal::API::V2::Page::Component::PlainTextField
+                merge_values(origin, append, delimiter: "\n")
+              when Ecoportal::API::V2::Page::Component::SelectionField
+                merge_values(origin, append, delimiter: delimiter)
+              when Ecoportal::API::V2::Page::Component::ReferenceField
+                merge_values(origin, append, delimiter: delimiter)
+              when Ecoportal::API::V2::Page::Component::PeopleField
+                merge_values(origin, append, delimiter: delimiter)
+              when Ecoportal::API::V2::Page::Component::DateField
+                origin
+              when Ecoportal::API::V2::Page::Component::NumberField
+                origin
+              when Ecoportal::API::V2::Page::Component::GaugeField
+                origin
+              when Ecoportal::API::V2::Page::Component::ChecklistField
+                merge_values(origin, append, delimiter: delimiter)
+              when Ecoportal::API::V2::Page::Component::ActionField
+                merge_values(origin, append, delimiter: delimiter)
+              when Ecoportal::API::V2::Page::Component::FilesField
+                merge_values(origin, append, delimiter: delimiter)
+              when Ecoportal::API::V2::Page::Component::ImagesField
+                merge_values(origin, append, delimiter: delimiter)
+              when Ecoportal::API::V2::Page::Component::GeoField
+                merge_values(origin, append, delimiter: delimiter)
+              when Ecoportal::API::V2::Page::Component::LawField
+                merge_values(origin, append, delimiter: delimiter)
+              else
+                [origin, append].join(delimiter)
+              end
+            end
+
+            def merge_arrays(ref, plus)
+              return ref if ref == plus
+              href_idx  = array_indexes(ref)
+              hplus_idx = array_indexes(plus)
+
+              shared = ref & plus
+              hshared_ref_idx = href_idx.slice(*shared)
+
+              # hidx_plus_shared = hplus_idx.slice(*shared).each_with_object({}) do |(e, idx), reversed|
+              #   reversed[idx] = e
+              # end
+              # shared_plus_idxs = hidx_plus_shared.keys.reverse
+              shared_plus_idxs = hplus_idx.values_at(*shared).sort.reverse
+
+              only_plus = plus - ref
+              honly_plus_idx = hplus_idx.slice(*only_plus)
+
+              hplus_ref_idx = honly_plus_idx.each_with_object({}) do |(e, idx), hplus_ref_idx|
+                ps_idx = shared_plus_idxs.bsearch {|i| idx >= i}
+                rs_idx = ps_idx ? hshared_ref_idx[plus[ps_idx]] : -1
+                hplus_ref_idx[e] = rs_idx
+              end.group_by do |e, idx|
+                idx
+              end.to_a.sort_by do |(idx, pairs)|
+                idx
+              end.reverse.to_h.transform_values do |pairs|
+                pairs.map(&:first)
+              end
+              hplus_ref_idx.each_with_object(ref.dup) do |(idx, elements), ref|
+                ref.insert(idx+1, *elements)
+              end
+            end
+
+            def array_indexes(ary)
+              ary.each_with_index.to_h
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eco/api/usecases/ooze_samples/helpers.rb

@@ -1,4 +1,5 @@
-require_relative 'helpers/shortcuts.rb'
+require_relative 'helpers/shortcuts'
+require_relative 'helpers/filters'
 
 module Eco
   module API
@@ -6,8 +7,13 @@ module Eco
       class OozeSamples
         module Helpers
           include OozeSamples::Helpers::Shortcuts
+          include OozeSamples::Helpers::Filters
         end
       end
     end
   end
 end
+
+require_relative 'helpers/ooze_handlers'
+require_relative 'helpers/exportable_ooze'
+require_relative 'helpers/exportable_register'

data/lib/eco/api/usecases/ooze_samples/register_export_case.rb

@@ -1,4 +1,4 @@
-# Use case to update a register
+# Use case to offer the basics to export a register
 # @note
 #   - You can define methods `filters` and `search` to change the target entries of the register
 #   - You need to define the `process_ooze` method
@@ -62,34 +62,35 @@ class Eco::API::UseCases::OozeSamples::RegisterExportCase < Eco::API::Common::Lo
   def build_full_ooze(ooze_id)
     if page = ooze(ooze_id)
       return page unless page.is_a?(Ecoportal::API::V2::Pages::PageStage)
+      pending_stage_ids = page.stages.ordered.map(&:id) - [page.current_stage_id]
+      state  = page.state
       secs_doc = page.sections.doc
       flds_doc = page.components.doc
-      pending_stage_ids = page.stages.map(&:id) - [page.current_stage_id]
+      hsecs = secs_doc.each_with_object({}) {|sec, h| h[sec["id"]] = sec}
+      hflds = flds_doc.each_with_object({}) {|fld, h| h[fld["id"]] = fld}
       pending_stage_ids.each do |id|
-        if page = stage(id, ooze: page)
-          page.sections.doc.each do |sec_doc|
-            unless secs_doc.find {|sec| sec["id"] == sec_doc["id"]}
+        if other_stage = stage(id, ooze: page)
+          state = "inprogress" unless other_stage.state == "complete"
+          other_stage.sections.doc.each do |sec_doc|
+            unless hsecs.key?(id = sec_doc["id"])
+              hsecs[id] = sec_doc
               secs_doc << sec_doc
             end
           end
-          page.components.doc.each do |comp_doc|
-            unless flds_doc.find {|fld| fld["id"] == comp_doc["id"]}
+          other_stage.components.doc.each do |comp_doc|
+            unless hflds.key?(id = comp_doc["id"])
+              hflds[id] = comp_doc
               flds_doc << comp_doc
             end
           end
         end
       end
-      Ecoportal::API::V2::Page.new(page.doc)
+      Ecoportal::API::V2::Pages::PageStage.new(page.doc).tap do |ozz|
+        ozz.state = state
+      end
     end
   end
 
-  #def update_oozes(batched_oozes = batch_queue)
-  #  batched_oozes.each do |ooze|
-  #    update_ooze(ooze)
-  #  end
-  #  batched_oozes.clear
-  #end
-
   def batched_search_results
     raise "Missing block. It yields in slices of #{self.class.batch_size} results" unless block_given?
     results_preview
@@ -137,10 +138,14 @@ class Eco::API::UseCases::OozeSamples::RegisterExportCase < Eco::API::Common::Lo
     exit_error "Stage '#{id_name}' doesn't exist in ooze '#{ooze_id}'"
   end
 
+  def default_proceed
+    "Y"
+  end
+
   def results_preview
     apiv2.registers.search(register_id, search_options.merge(only_first: true)).tap do |search_results|
       str_results = "Total target entries: #{search_results.total} (out of #{search_results.total_before_filtering})"
-      session.prompt_user("Do you want to proceed (y/N):", explanation: str_results, default: "N", timeout: 10) do |res|
+      session.prompt_user("Do you want to proceed (y/N):", explanation: str_results, default: default_proceed, timeout: 10) do |res|
         unless res.upcase.start_with?("Y")
           puts "..."
           logger.info "Aborting script..."
@@ -180,5 +185,4 @@ class Eco::API::UseCases::OozeSamples::RegisterExportCase < Eco::API::Common::Lo
     logger.error(msg)
     exit(1)
   end
-
 end

data/lib/eco/api/usecases.rb

@@ -163,3 +163,4 @@ require_relative 'usecases/base_io'
 require_relative 'usecases/use_case_io'
 require_relative 'usecases/default_cases'
 require_relative 'usecases/ooze_samples'
+require_relative 'usecases/ooze_cases'

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

@@ -40,6 +40,11 @@ ASSETS.cli.config do |cnf|
       STDOUT.reopen(file, "w+")
     end
 
+    desc = "Skips the check of the headers"
+    options_set.add("-skip-header-check", desc) do |options, session|
+      options.deep_merge!(input: {skip_header_check: true})
+    end
+
     desc = "Fix the current session to work with this schema"
     options_set.add("-schema-id", desc) do |options, session|
       sch_name = SCR.get_arg("-schema-id", with_param: true)

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

@@ -147,7 +147,7 @@ ASSETS.cli.config do |cnf|
     cases.add("-entries-to-csv", :import, desc, case_name: "entries-to-csv")
     .add_option("-out") do |options|
       file  = SCR.get_file("-out")
-      options.deep_merge(export: {file: file})
+      options.deep_merge!(export: {file: file})
     end
 
     desc  = "Usage '-org-data-convert backup.json -restore-db-from'."
@@ -254,5 +254,53 @@ ASSETS.cli.config do |cnf|
     .add_option("-append-starters", as1) do |options|
       options.deep_merge!(people: {append_created: true})
     end
+
+    # Ooze cases
+    desc = "APIv2 Case: Exports the target register into a CSV"
+    cases.add("-export-register", :other, desc, case_name: "export-register") do |session, options, usecase|
+      file = SCR.get_file("-export-register", required: false, should_exist: false)
+      options.deep_merge!(export: {file: {name: file || "RegisterExport.csv", format: :csv}})
+
+      unless options.dig(:source, :register_id)
+        session.logger.error "You should specify the target register id"
+        exit(1)
+      end
+    end.add_option("-register-id", "Target register id") do |options|
+      reg_id = SCR.get_arg("-register-id", with_param: true)
+      options.deep_merge!(source: {register_id: reg_id})
+    end.add_option("-include-deindexed", "Tells if deindexed fields should be included") do |options|
+      options.deep_merge!(export: {options: {include: {deindexed: true}}})
+    end.add_option("-include-unnamed", "Tells if unnamed fields should be included") do |options|
+      options.deep_merge!(export: {options: {include: {unnamed: true}}})
+    end.add_option("-include-unhashed", "Tells if fields with no hash reference (very short label) should be included") do |options|
+      options.deep_merge!(export: {options: {include: {unhashed: true}}})
+    end.add_option("-delimiter", "Sets the delimiter to be used in fields multi value") do |options|
+      str = SCR.get_arg("-delimiter", with_param: true)
+      options.deep_merge!(export: {options: {delimiter: str}})
+    end.add_option("-created-from", "Filters the register to the entries created FROM the specified date") do |options|
+      str = SCR.get_arg("-created-from", with_param: true)
+      date = Time.parse(str)
+      options.deep_merge!(export: {options: {filters: {created_at: {from: date}}}})
+    end.add_option("-created-to", "Filters the register to the entries created up TO the specified date") do |options|
+      str = SCR.get_arg("-created-to", with_param: true)
+      date = Time.parse(str)
+      options.deep_merge!(export: {options: {filters: {created_at: {to: date}}}})
+    end.add_option("-updated-from", "Filters the register by entries updated FROM the specified date") do |options|
+      str = SCR.get_arg("-updated-from", with_param: true)
+      date = Time.parse(str)
+      options.deep_merge!(export: {options: {filters: {updated_at: {from: date}}}})
+    end.add_option("-updated-to", "Filters the register by entries updated up TO the specified date") do |options|
+      str = SCR.get_arg("-updated-to", with_param: true)
+      date = Time.parse(str)
+      options.deep_merge!(export: {options: {filters: {updated_at: {to: date}}}})
+    end.add_option("-all-tags", "Filters the register to entries with ALL specified tags (| separator)") do |options|
+      str = SCR.get_arg("-all-tags", with_param: true)
+      tags = str.split("|")
+      options.deep_merge!(export: {options: {filters: {tags: {all: tags}}}})
+    end.add_option("-any-tags", "Filters the register to entries with ANY specified tags (| separator)") do |options|
+      str = SCR.get_arg("-all-tags", with_param: true)
+      tags = str.split("|")
+      options.deep_merge!(export: {options: {filters: {tags: {any: tags}}}})
+    end
   end
 end

data/lib/eco/version.rb

@@ -1,3 +1,3 @@
 module Eco
-  VERSION = "2.0.60"
+  VERSION = "2.0.61"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eco-helpers
 version: !ruby/object:Gem::Version
-  version: 2.0.60
+  version: 2.0.61
 platform: ruby
 authors:
 - Oscar Segura
@@ -136,7 +136,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.28
+        version: 0.8.30
     - - "<"
       - !ruby/object:Gem::Version
         version: '0.9'
@@ -146,7 +146,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.28
+        version: 0.8.30
     - - "<"
       - !ruby/object:Gem::Version
         version: '0.9'
@@ -437,6 +437,7 @@ files:
 - lib/eco/api/common/session/sftp.rb
 - lib/eco/api/common/version_patches.rb
 - lib/eco/api/common/version_patches/ecoportal_api.rb
+- lib/eco/api/common/version_patches/ecoportal_api/client.rb
 - lib/eco/api/common/version_patches/ecoportal_api/external_details.rb
 - lib/eco/api/common/version_patches/ecoportal_api/external_person.rb
 - lib/eco/api/common/version_patches/ecoportal_api/internal_person.rb
@@ -564,8 +565,14 @@ files:
 - lib/eco/api/usecases/default_cases/update_case.rb
 - lib/eco/api/usecases/default_cases/update_details_case.rb
 - lib/eco/api/usecases/default_cases/upsert_case.rb
+- lib/eco/api/usecases/ooze_cases.rb
+- lib/eco/api/usecases/ooze_cases/export_register_case.rb
 - lib/eco/api/usecases/ooze_samples.rb
 - lib/eco/api/usecases/ooze_samples/helpers.rb
+- lib/eco/api/usecases/ooze_samples/helpers/exportable_ooze.rb
+- lib/eco/api/usecases/ooze_samples/helpers/exportable_register.rb
+- lib/eco/api/usecases/ooze_samples/helpers/filters.rb
+- lib/eco/api/usecases/ooze_samples/helpers/ooze_handlers.rb
 - lib/eco/api/usecases/ooze_samples/helpers/shortcuts.rb
 - lib/eco/api/usecases/ooze_samples/ooze_base_case.rb
 - lib/eco/api/usecases/ooze_samples/ooze_from_doc_case.rb