eco-helpers 2.1.4 → 2.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca676558c0e1a885b1f9e15d68e3c4f3688b90713c88182854b426a8ce1bf447
-  data.tar.gz: 41e8693e90664d7789040dd2dab66521e330693a9ae62f7bb5c5bc2dbd940911
+  metadata.gz: eaeec07a9cf6c0b584a546d6626f661d73f608332a72ef938bcfe7513adc6f2c
+  data.tar.gz: 285234b6c42a281c900ae3c05dc5a71f9e6a55d4aa52a884457a6956a02c456e
 SHA512:
-  metadata.gz: 65b5157cc78ff3016f932283e2f0504e46681e15dc2acd902bb0e6188af98f5fe5271ad0db49a48fe969c642df3146daffeffcb0008dda3012433450dbbc1e87
-  data.tar.gz: 3a23f58986631f819b18bd8395ec92c321e9cb21bfde172a3e565df309cdad3b759d1d60f8c4bf52cff29332b49607f30afad19c90a80c5f9fb974637c3b218e
+  metadata.gz: bc26467b2cb2b102a03aff3e5c189c60d3d63290c107e69c609e5536e70631e50e1a2c21c5859260e048c132584288fc728fd185681df4540a3c67e822f581dc
+  data.tar.gz: 0a5a23a848dac8114d1945efac8f58508066de077cac286e4b6bd473965356ce2aa0b961b1b2e542183afb58f04b1ceeb441f14452e0477976b565c9ff414a51

data/CHANGELOG.md

@@ -1,12 +1,26 @@
 # Change Log
 All notable changes to this project will be documented in this file.
 
-## [2.1.5] - 2022-10-xx
+## [2.1.6] - 2022-10-xx
 
 ### Added
 ### Changed
 ### Fixed
 
+## [2.1.5] - 2022-10-xx
+
+### Added
+  - `Eco::API::UseCases::OozeSamples::RegisterUpdateCase` added creation count
+    - Requires use of `#create_ooze(draft, template_id)`
+  - `Eco::API::UseCases::OozeSamples::RegisterUpdateCase` added method
+    - `with_rescue` that prompts user to continue
+    - this is for usage in child classes
+  - new use case and helpers thereof `Eco::API::UseCases::OozeSamples::RegisterMigrationCase`
+  
+### Changed
+  - upgraded `ecoportal-api-v2` **gem**
+  - **refactored** `Eco::API::UseCases::OozeSamples::Helpers::Shortcuts#same_string?`
+
 ## [2.1.4] - 2022-10-20
 
 ### 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.9.3', '< 0.10'
+  spec.add_dependency 'ecoportal-api-v2', '>= 0.9.5', '< 0.10'
   spec.add_dependency 'ecoportal-api-graphql', '>= 0.1.10', '< 0.2'
   spec.add_dependency 'aws-sdk-s3',    '>= 1.83.0', '< 2'
   spec.add_dependency 'aws-sdk-ses',   '>= 1.36.0', '< 2'

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

@@ -4,29 +4,71 @@ module Eco
       class OozeSamples
         module Helpers
           module Shortcuts
+            # Basic simplification pattern (matches all but a-z and blank space)
+            def non_letters_regex
+              @non_letters_regex ||= /[^a-z ]+/
+            end
 
-            # Offers multiple ways to compare two strings
-            def same_string?(value1, value2, exact: false, mild: false)
-              case
-              when value1.is_a?(String) && value2.is_a?(String)
-                if exact
-                  value1 == value2
-                else
-                  v1 = value1.to_s.strip.downcase
-                  v2 = value2.to_s.strip.downcase
+            # Matches anything between two consecutive (), inclusive
+            def bracked_regex
+              @bracked_regex ||= /(?<bracked>\([^\)]+?\))/
+            end
+
+            # It always downcase, trim and remove double spaces.
+            # @param ignore Boolean, Regexp] ingored when `exact` is `true`
+            #   * when `false`: it does not do anything additional
+            #   * when `Regex`: it removes all characters that match the expression.
+            #   * when `String`: each character listed is removed.
+            #   * when `Array`: reduces `str` processing `ignore` in order.
+            #   * when `true` (or otherwise): it removes all non a-zA-Z characters but blank spaces.
+            def simplify_string(str, ignore: false)
+              str = str.to_s.strip.downcase.gsub(/\s+/, ' ')
+              return str unless ignore
+              sub = non_letters_regex
+              case ignore
+              when Regexp; sub = ignore
+              when String; sub = /[#{ignore}]+/
+              when Array
+                return ignore.reduce(str) do |out, sub|
+                  simplify_string(out, ignore: sub)
+                end
+              end
+              str.gsub(sub, '').gsub(/\s+/, ' ').strip
+            end
 
-                  if mild
-                    v1 = v1.gsub(/[^a-z ]+/, ' ').gsub(/\s+/, ' ').strip
-                    v2 = v2.gsub(/[^a-z ]+/, ' ').gsub(/\s+/, ' ').strip
-                  end
-                  v1 == v2
+            # Offers multiple simplification methods to compare two strings
+            # @note only one of the values can be a Regexp
+            # @param value1 [String, Regexp, Nil]
+            # @param value2 [String, Regexp, Nil]
+            # @param exact [Boolean]
+            #   * when `true`: requiring the values to be exactly the same
+            #   * otherwise (`false`): compares in downcase, with no extra spaces
+            # @param mild [Boolean] only a-z comparison
+            # @param ignore [see @simplify_string]
+            def same_string?(value1, value2, exact: false, mild: false, ignore: false)
+              return true  if value1.to_s.strip.empty? && value2.to_s.strip.empty?
+              return false if value1.to_s.strip.empty? || value2.to_s.strip.empty?
+              val1, val2 = value1, value2
+              unless exact
+                if val1.is_a?(String)
+                  val1 = simplify_string(val1, ignore: ignore) if ignore
+                  val1 = simplify_string(val1, ignore: non_letters_regex) if mild
+                end
+                if val2.is_a?(String)
+                  val2 = simplify_string(val2, ignore: ignore) if ignore
+                  val2 = simplify_string(val2, ignore: non_letters_regex) if mild
                 end
-              when value1.is_a?(Regexp) && value2.is_a?(String)
-                value2 =~ value1
-              when value1.is_a?(String) && value2.is_a?(Regexp)
-                value1 =~ value2
+              end
+              case
+              when val1.is_a?(String) && val2.is_a?(String)
+                val1 == val2
+              when val1.is_a?(Regexp) && val2.is_a?(String)
+                val2 =~ val1
+              when val1.is_a?(String) && val2.is_a?(Regexp)
+                val1 =~ val2
               else
-                value1 == value2
+                #val1 == val2
+                raise "Expected at least one String, and either a String or Regex. Given: (1: #{val1.class}) and (2: #{val2.class})"
               end
             end
 

data/lib/eco/api/usecases/ooze_samples/helpers_migration/copying.rb

@@ -0,0 +1,125 @@
+class Eco::API::UseCases::OozeSamples
+  module HelpersMigration
+    module Copying
+      def session
+        defined?(super)? super : @session
+      end
+
+      def logger
+        session.logger
+      end
+
+      def copy_generic_paired_fields(src, dst, exclude_ximport: false)
+        HelpersMigration::TypedFieldsPairing.new(src, dst, exclude_ximport: false).tap do |pairing|
+          pairing.each_pair do |src_fld, dst_fld|
+            copy_field_content(src_fld, dst_fld)
+            yield(src_fld, dst_fld, pairing) if block_given?
+          end
+        end
+      end
+
+      def copy_hooked_fields(src, dst, hook:, type:, fields_tracker: nil)
+        case hook
+        when String
+          with_src_dest_field_pair(src, dst, label: to_regex(hook), type: type) do |src_fld, dst_fld|
+            copy_field_content(src_fld, dst_fld, type).tap do |result|
+              fields_tracker.resolve(src_fld, dst_fld) if fields_tracker
+              yield(src_fld, dst_fld, fields_tracker) if block_given?
+            end
+          end
+        when Hash
+          hook.each do |hook_src, hook_dst|
+            src_lab, dst_lab = to_regex(hook_src), to_regex(hook_dst)
+            with_src_dest_field_pair(src, dst, label: src_lab, label_dst: dst_lab, type: type) do |src_fld, dst_fld|
+              copy_field_content(src_fld, dst_fld, type).tap do |result|
+                fields_tracker.resolve(src_fld, dst_fld) if fields_tracker
+                yield(src_fld, dst_fld, fields_tracker) if block_given?
+              end
+            end
+          end
+        end
+      end
+
+      def to_regex(str)
+        /^#{str}$/i
+      end
+
+      def with_src_dest_field_pair(src, dst, label: nil, label_dst: label, type: nil)
+        unless respond_to?(:with_fields, true)
+          raise "These helpers are to be included in class cases inheriting from Eco::API::UseCases::OozeSamples::RegisterUpdateCase"
+        end
+        src_flds = with_fields(src, label: label, type: type)
+        dst_flds = with_fields(dst, label: label_dst, type: type)
+
+        if dst_flds.count > 1
+          logger.warn("There are #{dst_flds.count} destination '#{type}' fields named '#{label_dst}' (source: '#{src.id}'). Using first...")
+        elsif dst_flds.empty?
+          logger.warn("There isn't a destination '#{type}' field named '#{label_dst}' (source: '#{src.id}')")
+          return nil, nil
+        end
+
+        if src_flds.count > 1
+          logger.warn("There are #{src_flds.count} source '#{type}' fields named '#{label}' (source: '#{src.id}'). Using first...")
+        elsif src_flds.empty?
+          logger.warn("There isn't a source '#{type}' field named '#{label}' (source: '#{src.id}')")
+          return nil, dst
+        end
+
+        [src_flds.first, dst_flds.first].tap do |(src_fld, dst_fld)|
+          yield(src_fld, dst_fld) if block_given?
+        end
+      end
+
+      def copy_field_content(src, dst, type = src.type)
+        case type
+        when "select"
+          src.values.each {|val| dst.select(val)}
+          dst.other_desc = src.other_desc if src.other && src.other_desc && dst.other
+        when "plain_text", "date", "number", "gauge"
+          dst.value = src.value
+        when "rich_text"
+          dst.content = src.content
+        when "cross_reference"
+          src.reference_ids.each {|id| dst.add(id)}
+        when "people"
+          dst.people_ids << src.people_ids.to_a
+        when "geo"
+          src_coo, dst_coo = src.coordinates, dst.coordinates
+          dst_coo.lat, dst_coo.lon = src_coo.lat, src_coo.lon
+        when "file"
+          src.items.each do |src_item|
+            dst.add_file(src_item.file_container_id) do |dst_item|
+              dst_item.label = src_item.label
+            end
+          end
+        when "image_gallery"
+          src.images.each do |src_image|
+            dst.add_image(src_image.upload_id) do |dst_image|
+              dst_image.caption = src_image.caption
+            end
+          end
+        when "checklist"
+          src.items.each do |src_item|
+            dst.add_item(label: src_item.label) do |dst_item|
+              dst_item.checked = src_item.checked
+            end
+          end
+        when "law"
+          "won't copy"
+        when "page_action"
+          "won't copy"
+        when "actions_list"
+          "won't copy"
+        when "signature"
+          "can't copy"
+        when "tag_field"
+          "can't copy"
+        when "chart"
+          "won't copy"
+        when "frequency_rate_chart"
+          "won't copy"
+        end
+      end
+    end
+  end
+end

data/lib/eco/api/usecases/ooze_samples/helpers_migration/typed_fields_pairing.rb

@@ -0,0 +1,235 @@
+# It pairs fields of same type with same label name.
+# It does it in two screenings:
+# => (1) where the label name is exactly the same.
+# => (2) with the rest, case insensitive letters (a-z), removed content between brackets
+# Other features:
+# => It keeps track on source and destination fields that were not paired
+# => It allows to remove from the unpaired classification fields that are paired by other means
+# => It tracks what source fields have multiple candidate destination fields
+# In other words: it is one of the World Wonders of 2022 !!
+class Eco::API::UseCases::OozeSamples
+  module HelpersMigration
+    class TypedFieldsPairing
+      include Eco::API::UseCases::OozeSamples::Helpers::Shortcuts
+
+      EXCLUDED_TYPES = ["tag_field", "chart", "frequency_rate_chart"]
+
+      attr_reader :src, :dst
+      attr_reader :src_unpaired, :dst_unpaired
+      attr_reader :src_dst_pairs, :src_dst_multi
+
+      def initialize(source, destination, src_excluded: nil, dst_excluded: nil,
+          exclude_ximport: false)
+        @src = source
+        @dst = destination
+        @src_excluded = src_excluded || []
+        @dst_excluded = dst_excluded || []
+        @exclude_ximport = !!exclude_ximport
+        reset!
+        process(exact: true)
+        process
+      end
+
+      def each_pair
+        src_dst_pairs.each do |(src_field, dst_field)|
+          yield(src_field, dst_field) if block_given?
+        end
+      end
+
+      def report_src_unpaired(only_present: true, only_indexed: false)
+        return nil if src_unpaired.empty?
+        msg  = "Source entry with unpaired fields (#{object_reference(src)}):\n"
+        src_filtered = src_unpaired.values.flatten.reject do |src_fld|
+          only_present && src_fld.empty?
+        end.reject do |src_fld|
+          only_indexed && src_fld.deindex
+        end
+        return nil if src_filtered.empty?
+        msg << src_filtered.map do |src_fld|
+          "  • #{object_reference(src_fld)}"
+        end.join("\n")
+      end
+
+      def report_dst_unpaired(only_required: false, exclude_ximport: true)
+        return nil if dst_unpaired.empty?
+        msg  = "Destination entry with unpaired fields (#{object_reference(src)}):\n"
+        dst_filtered = dst_unpaired.values.flatten.reject do |dst_fld|
+          only_required && !dst_fld.required
+        end.reject do |dst_fld|
+          exclude_ximport && ximport?(dst_fld)
+        end
+        return nil if dst_filtered.empty?
+        msg << dst_filtered.map do |dst_fld|
+          "  • #{object_reference(dst_fld)}"
+        end.join("\n")
+      end
+
+      def report_multi_pairs(only_present: true, only_indexed: false, dst_exclude_ximport: true)
+        return nil if src_dst_multi.empty?
+        "".tap do |msg|
+          msg << "Source fields in (#{object_reference(src)}) paired with multiple destination fields:\n"
+          msg_flds = ""
+          src_dst_multi.each do |type, pairs|
+            pairs.each do |(src_fld, dst_flds)|
+              next if (only_present && src_fld.empty?) || (only_indexed && src_fld.deindex)
+              dst_filtered = dst_flds.reject do |dst_fld|
+                dst_exclude_ximport && ximport?(dst_fld)
+              end
+              next if dst_filtered.empty?
+              msg_flds << "  • #{object_reference(src_fld)}\n"
+              msg_flds << dst_filtered.map do |dst_fld|
+                "    • #{object_reference(dst_fld)}"
+              end.compact.join("\n")
+            end
+          end
+          return nil if msg_flds.empty?
+          msg << msg_flds
+        end
+      end
+
+      # Remove from unpaired tracking those `flds`.
+      def resolve(*flds)
+        flds.each do |fld|
+          next if unpaired_delete(fld, src_unpaired)
+          unpaired_delete(fld, dst_unpaired)
+        end
+        multi_delete(*flds)
+      end
+
+      def some_multi?
+        !src_dst_multi.empty?
+      end
+
+      private
+
+      # When comparing, use only a-z letters.
+      def only_letters?
+        true
+      end
+
+      # When comparign, remove anything between brackets from the field label name.
+      def non_bracked?
+        true
+      end
+
+      # If `false`, it compares with all lower case.
+      def exact?
+        !(only_letters? || non_bracked?)
+      end
+
+      def process(exact: false)
+        src_unpaired.each do |type, src_pend|
+          next unless (dst_pend = dst_unpaired[type]) && !dst_pend.empty?
+          src_pend.dup.each do |src_fld|
+            dst_candidates = dst_pend.select do |dst_fld|
+              str_eq?(src_fld.label, dst_fld.label, exact: exact)
+            end
+            next if dst_candidates.empty?
+            if dst_candidates.count == 1
+              pair_add(src_fld, dst_candidates.first)
+            else
+              multi_add(type, src_fld, *dst_candidates)
+            end
+          end
+        end
+      end
+
+      def str_eq?(str1, str2, exact: false)
+        same_string?(str1, str2, **str_eq_params.merge(exact: exact))
+      end
+
+      def str_eq_params
+        {
+          exact: exact?,
+          mild: only_letters?,
+          ignore: false
+        }.tap do |params|
+          params.merge!(ignore: bracked_regex) if non_bracked?
+        end
+      end
+
+      def pair_add(src_fld, dst_fld)
+        resolve(src_fld, dst_fld)
+        src_dst_pairs << [src_fld, dst_fld]
+      end
+
+      # Removes a field from a (src or dst) unpaired fields
+      def unpaired_delete(fld, unpaired)
+        type = fld.type
+        return false unless unpaired.key?(type)
+        return false unless (flds = unpaired[type]).delete(fld)
+        unpaired.delete(type) if flds.empty?
+        true
+      end
+
+      def multi_add(type, src_fld, *dst_flds)
+        (src_dst_multi[type] ||= []) << (pair = [src_fld, dst_flds])
+        @src_multi[src_fld] = pair
+        dst_flds.each do |dst_fld|
+          (@dst_multi[dst_fld] ||= []) << pair
+        end
+      end
+
+      def multi_delete(*flds)
+        flds.each do |fld|
+          next unless type_pairs = src_dst_multi[fld.type]
+          if pairs = @dst_multi.delete(fld)
+            pairs.each do |pair|
+              src_fld = pair.first
+              dst_flds = pair.last
+              dst_flds.delete(fld)
+              if dst_flds.empty?
+                @src_multi.delete(src_fld)
+                type_pairs.delete(pair)
+              end
+            end
+          elsif @src_multi.key?(fld)
+            pair = @src_multi.delete(fld)
+            type_pairs.delete(pair)
+            pair.last.each do |dst_fld|
+              pairs = @dst_multi[dst_fld]
+              pairs.delete(pair)
+              @dst_multi.delete(dst_fld) if pairs.empty?
+            end
+          end
+          src_dst_multi.delete(type) if type_pairs.empty?
+        end
+      end
+
+      def by_type(components)
+        components.to_a.group_by(&:type).tap do |out|
+          EXCLUDED_TYPES.each {|type| out.delete(type)}
+        end
+      end
+
+      def src_components
+        flds = src.components.to_a
+        flds = flds.reject {|fld| ximport?(fld)} if @exclude_ximport
+        flds - @src_excluded
+      end
+
+      def dst_components
+        flds = dst.components.to_a
+        flds = flds.reject {|fld| ximport?(fld)} if @exclude_ximport
+        flds - @dst_excluded
+      end
+
+      def ximport?(fld)
+        fld && fld.tooltip.to_s.include?("ximport")
+      end
+
+      def reset!
+        @src_unpaired = by_type(src_components)
+        @dst_unpaired = by_type(dst_components)
+        @src_dst_pairs = []
+        reset_multi!
+      end
+
+      def reset_multi!
+        @src_dst_multi = {}
+        @src_multi = {}
+        @dst_multi = {}
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+require_relative 'helpers_migration/typed_fields_pairing'
+require_relative 'helpers_migration/copying'
+module Eco
+  module API
+    class UseCases
+      class OozeSamples
+        module HelpersMigration
+          include OozeSamples::Helpers
+          include Copying
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,193 @@
+# Use case to offer the basics to migrate a register by creating new entries
+# @note
+#   - You can define methods `filters` and `search` to change the target entries of the register
+#   - You can define a json file named after your use case file (i.e. new_training.json) to pair source-destination fields:
+#     - This file format expects an object {} where keys are field types (i.e. "select", "plain_text")
+#       and the value is an array with either:
+#         1. field label name (String or RegExp body/source),
+#         2. or an object with key-value being source-destination label names (also supports RegExp body/source)
+#     - Example: {"select": ["severity of .*:", {"type of event:" => "type of incident:"}]}
+#   - You may either
+#     1. define the `process_ooze` method calling super with a block: super.do ||
+#     2. of define the function `custom_processing(draft, source, fields_tracker: nil)`
+#   - You can define a callback function, `paired_fields_post_callback(src_fld, dst_fld, pairing_tracking = nil)`
+#     - It will be called after copying by using any of the pairing methods, and allows to introduce modifications
+#       such as selection option mappings
+# This case expects `options[:source][:register_id]`
+class Eco::API::UseCases::OozeSamples::RegisterMigrationCase < Eco::API::UseCases::OozeSamples::RegisterUpdateCase
+  name "register-migration-case"
+  type :other
+
+  #batch_size 2
+  #DRY_COUNT = 4
+
+  #SOURCE_STAGE = 'name_of_source_stage'
+  #TEMPLATE_ID  = 'id_of_the_template'
+
+  # whether or not it should try to pair src <-> dst ximport fields:
+  EXCLUDE_XIMPORT = false
+  # whether or not it should warn on unpaired destination ximport fields:
+  REPORT_DST_XIMPORT = true
+  # whether or not it should warn on unpaired source fields that are empty (no data loss):
+  REPORT_SRC_EMTPY = false
+  # whether or not it should warn on unpaired source fields that are deindexed (low potential of data loss):
+  REPORT_SRC_DEINDEX = false
+
+  include Eco::API::UseCases::OozeSamples::HelpersMigration
+
+  attr_reader :session, :options
+  attr_reader :csv
+
+  def main(session, options, usecase, &block)
+    @session = session; @options = options
+    if options[:dry_run]
+      @csv = []
+      super(session, options, usecase, &block)
+    else
+      CSV.open(out_csv_filename, "w") do |csv|
+        @csv = csv
+        csv << ["src_page_id", "dst_page_id"]
+        super(session, options, usecase, &block)
+      end
+      logger.info("File '#{out_csv_filename}' has been created.")
+    end
+  end
+
+  # This method is expected to finalize the copying/adjustment of the draft entry.
+  # @note At this stage, the RegisterMigration case has already populated the draft where
+  #   source and destination fields(in the draft) could be paired.
+  # def custom_processing(draft, source, fields_tracker: nil)
+  #   draft.tags << source.tags.to_a
+  #   # More custom logics
+  # end
+
+  def process_ooze
+    with_target_stage(self.class::SOURCE_STAGE) do |source|
+      drafting_entry(self.class::TEMPLATE_ID) do |draft|
+        draft_reference = object_reference(source)
+        draft.base_tags << ["IMPORTED", "MIGRATED"]
+
+        pairing_tracking = copy_pairings(source, draft)
+
+        if respond_to?(:custom_processing, true)
+          custom_processing(draft, source, fields_tracker: pairing_tracking)
+        elsif block_given?
+          yield(draft, source, fields_tracker: pairing_tracking)
+        end
+
+        if msg = pairing_tracking.report_src_unpaired(only_present: !self.class::REPORT_SRC_EMTPY, only_indexed: !self.class::REPORT_SRC_DEINDEX)
+          logger.warn(msg)
+        end
+
+        if msg = pairing_tracking.report_multi_pairs(only_present: !self.class::REPORT_SRC_EMTPY, only_indexed: !self.class::REPORT_SRC_DEINDEX, dst_exclude_ximport: !self.class::REPORT_DST_XIMPORT)
+          logger.warn(msg)
+        end
+
+        if msg = pairing_tracking.report_dst_unpaired(only_required: false, exclude_ximport: !self.class::REPORT_DST_XIMPORT)
+          logger.warn(msg)
+        end
+
+        if page_id = create_entry(draft, reference: draft_reference)
+          csv << [source.id, page_id]
+          logger.info("Page '#{page_id}' created successfully.")
+        elsif options.dig(:dry_run)
+          logger.info("Simulated launch for #{draft_reference}")
+        end
+      end
+    end
+  end
+
+  private
+
+  def copy_pairings(src, dst)
+    after_copy = callback(:paired_fields_post)
+    copy_generic_paired_fields(src, dst, exclude_ximport: self.class::EXCLUDE_XIMPORT, &after_copy).tap do |pairing_tracking|
+      copy_mapped_fields(src, dst, fields_tracker: pairing_tracking, &after_copy)
+    end
+  end
+
+  def script_fullname
+    msg = "You should define this method in the child class with this content:\n"
+    msg << "  @script_fullname||= File.expand_path(__FILE__)"
+    raise msg
+  end
+
+  def copy_mapped_fields(src, dst, fields_tracker: nil, &after_copy)
+    return [] unless field_maps?
+    field_maps.each do |type, field_hooks|
+      field_hooks.each do |hook_name|
+        copy_hooked_fields(src, dst, hook: hook_name, type: type, fields_tracker: fields_tracker, &after_copy)
+      end
+    end
+  end
+
+  def callback?(sym)
+    respond_to?(callback_name(sym), true)
+  end
+
+  def callback(sym)
+    if callback?(sym)
+      method(callback_name(sym))
+    end
+  end
+
+  def callback_name(sym)
+    "#{sym}_callback".to_sym
+  end
+
+  def create_entry(draft, reference:, from: self.class::TEMPLATE_ID)
+    with_rescue(reference) do
+      if !options[:dry_run]
+        create_ooze(draft, template_id: from).page_id
+      else
+        dry_run_feedback(draft)
+        false
+      end
+    end
+  end
+
+  def drafting_entry(template_id = selfTEMPLATE_ID)
+    draft = apiv2.pages.get_new(template_id)
+    yield(draft)
+  end
+
+  def with_target_stage(name)
+    if stg = target_stage(name)
+      yield(stg)
+    else
+      logger.warn("Entry '#{target.id}' does not have stage '#{name}'")
+    end
+  end
+
+  def target_stage(name)
+    stage(name)
+  end
+
+  def out_csv_filename
+    @out_csv_filename ||= File.expand_path("./#{session.config.active_enviro}_#{script_basename}_#{name_timestamp}.csv")
+  end
+
+  def name_timestamp
+    @name_timestamp ||= Time.now.strftime("%Y%m%d%H%M%S")
+  end
+
+  def field_maps
+    @field_maps ||= field_maps? && JSON.parse(File.read(field_maps_file))
+  end
+
+  def field_maps?
+    File.exist?(field_maps_file)
+  end
+
+  def field_maps_file
+    @field_maps_file ||= "#{File.join(script_dirname, script_basename)}.json"
+  end
+
+  def script_basename
+    @script_basename ||= File.basename(script_fullname, "_case.rb")
+  end
+
+  def script_dirname
+    @script_dirname ||= File.dirname(script_fullname)
+  end
+end

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

@@ -19,7 +19,7 @@ class Eco::API::UseCases::OozeSamples::RegisterUpdateCase < Eco::API::UseCases::
 
   attr_reader :retrieved_oozes, :non_retrieved_oozes
   attr_reader :total_search_oozes, :dupped_search_oozes
-  attr_reader :ooze_result_ids, :updated_oozes, :failed_update_oozes
+  attr_reader :ooze_result_ids, :updated_oozes, :failed_update_oozes, :created_oozes
 
   def main(session, options, usecase, &block)
     @retrieved_oozes = 0
@@ -28,6 +28,7 @@ class Eco::API::UseCases::OozeSamples::RegisterUpdateCase < Eco::API::UseCases::
     @ooze_result_ids     = {}
     @updated_oozes       = 0
     @failed_update_oozes = 0
+    @created_oozes       = 0
 
     super(session, options, usecase) do
       with_each_entry do |ooze|
@@ -41,6 +42,7 @@ class Eco::API::UseCases::OozeSamples::RegisterUpdateCase < Eco::API::UseCases::
     msg += "  • Could not get #{non_retrieved_oozes} oozes.\n"
     msg += "  • Updated #{updated_oozes} oozes.\n"
     msg += "    - Failed update on #{failed_update_oozes} oozes.\n"
+    msg += "  • Created #{created_oozes} oozes.\n"
     logger.info(msg)
   end
 
@@ -50,6 +52,29 @@ class Eco::API::UseCases::OozeSamples::RegisterUpdateCase < Eco::API::UseCases::
 
   private
 
+  def with_rescue(reference)
+    begin
+      yield
+    rescue StandardError => e
+      logger.error([reference, e.message].join(' => \n'))
+      lines = []
+      lines << '\nThere was an error. Choose one option:\n'
+      lines << '  (C)      - Continue/resume. Just ignore this one.'
+      lines << '  (A)      - Abort. Just break this run.'
+
+      session.prompt_user('Type one option (C/a):', explanation: lines.join('\n'), default: 'C') do |res|
+        res = res.upcase
+        case
+        when res.start_with?("A")
+          raise
+        else res.start_with?("C")
+          logger.warn "Script resumed after error..."
+          nil
+        end
+      end
+    end
+  end
+
   def before_loading_new_target(ooze_id)
     if pending = queue_shift(ooze_id)
       update_ooze(pending).tap do |result|
@@ -148,6 +173,12 @@ class Eco::API::UseCases::OozeSamples::RegisterUpdateCase < Eco::API::UseCases::
     yield(results) unless results.empty?
   end
 
+  def create_ooze(draft, template_id:)
+    apiv2.pages.create(draft, from: template_id).tap do |result|
+      @created_oozes += 1
+    end
+  end
+
   def update_oozes(batched_oozes = batch_queue)
     batched_oozes.each do |ooze|
       update_ooze(ooze).tap do |result|

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

@@ -9,6 +9,7 @@ module Eco
 end
 
 require_relative 'ooze_samples/helpers'
+require_relative 'ooze_samples/helpers_migration'
 require_relative 'ooze_samples/ooze_base_case'
 require_relative 'ooze_samples/register_export_case'
 require_relative 'ooze_samples/ooze_run_base_case'
@@ -16,3 +17,4 @@ require_relative 'ooze_samples/ooze_update_case'
 require_relative 'ooze_samples/ooze_from_doc_case'
 require_relative 'ooze_samples/register_update_case'
 require_relative 'ooze_samples/target_oozes_update_case'
+require_relative 'ooze_samples/register_migration_case'

data/lib/eco/version.rb

@@ -1,3 +1,3 @@
 module Eco
-  VERSION = "2.1.4"
+  VERSION = "2.1.5"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eco-helpers
 version: !ruby/object:Gem::Version
-  version: 2.1.4
+  version: 2.1.5
 platform: ruby
 authors:
 - Oscar Segura
@@ -136,7 +136,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.3
+        version: 0.9.5
     - - "<"
       - !ruby/object:Gem::Version
         version: '0.10'
@@ -146,7 +146,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.3
+        version: 0.9.5
     - - "<"
       - !ruby/object:Gem::Version
         version: '0.10'
@@ -597,11 +597,15 @@ files:
 - 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/helpers_migration.rb
+- lib/eco/api/usecases/ooze_samples/helpers_migration/copying.rb
+- lib/eco/api/usecases/ooze_samples/helpers_migration/typed_fields_pairing.rb
 - lib/eco/api/usecases/ooze_samples/ooze_base_case.rb
 - lib/eco/api/usecases/ooze_samples/ooze_from_doc_case.rb
 - lib/eco/api/usecases/ooze_samples/ooze_run_base_case.rb
 - lib/eco/api/usecases/ooze_samples/ooze_update_case.rb
 - lib/eco/api/usecases/ooze_samples/register_export_case.rb
+- lib/eco/api/usecases/ooze_samples/register_migration_case.rb
 - lib/eco/api/usecases/ooze_samples/register_update_case.rb
 - lib/eco/api/usecases/ooze_samples/target_oozes_update_case.rb
 - lib/eco/api/usecases/use_case.rb