eco-helpers 3.2.16 → 3.2.17

data/lib/eco/api/usecases/graphql/helpers/pages/typed_fields_pairing.rb

@@ -0,0 +1,303 @@
+module Eco::API::UseCases::GraphQL::Helpers
+  module Pages
+    # Native GraphQL re-expression of
+    # OozeSamples::HelpersMigration::TypedFieldsPairing.
+    #
+    # It pairs fields of the SAME type with the SAME label name across two page
+    # models (a source `src` and a destination `dst`). This is the cross-template
+    # field-pairing used by migration cases — DISTINCT from the value-merge
+    # `OozeHandlers#merge_values` (which combines two values of one already-paired
+    # field).
+    #
+    # It runs two screenings:
+    #   (1) exact label match,
+    #   (2) then the rest, case-insensitive a-z only, content between brackets removed.
+    #
+    # Other features (ported verbatim from the v2 "World Wonder of 2022"):
+    #   * tracks src / dst fields that were NOT paired
+    #   * lets you `resolve` fields paired by other means out of the unpaired sets
+    #   * tracks src fields with MULTIPLE candidate dst fields (`src_dst_multi`)
+    #
+    # == What differs from the v2 class
+    #
+    # Fields are grouped and compared by the GraphQL DataField TYPE STRING (the
+    # `__typename`-derived value in `Ecoportal::API::GraphQL::Base::Page::DataField::TYPE_MAP`,
+    # e.g. 'PlainText', 'Select', 'Date') rather than the v2 snake_case component type
+    # (`'plain_text'`, `'select'`, `'date'`). Same-type grouping still guarantees a
+    # pair only forms between fields of identical type. `EXCLUDED_TYPES` therefore
+    # lists the GraphQL type strings for the never-pair types (charts / tag fields).
+    #
+    # `ximport?` detects an import-marker field via its `#tooltip` (unchanged), and
+    # `object_reference` / `same_string?` come from the native `Shortcuts`.
+    class TypedFieldsPairing
+      include Eco::API::UseCases::GraphQL::Helpers::Pages::Shortcuts
+
+      # GraphQL DataField type strings that must never be paired (no meaningful,
+      # copyable content). Mirrors the v2 EXCLUDED_TYPES
+      # (%w[tag_field chart frequency_rate_chart]) in GraphQL terms — GraphQL has no
+      # distinct chart data-field types, so TagField is the practical excluded type;
+      # any additional non-content types can be added here.
+      EXCLUDED_TYPES = %w[TagField Chart FrequencyRateChart].freeze
+
+      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 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 && field_empty?(src_fld)
+        end.reject do |src_fld|
+          only_indexed && src_fld.deindex
+        end
+
+        return 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 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 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_value do |pairs|
+            pairs.each do |(src_fld, dst_flds)|
+              next if (only_present && field_empty?(src_fld)) || (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 comparing, 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.one?
+              pair_add(src_fld, dst_candidates.first)
+            else
+              multi_add(type, src_fld, *dst_candidates)
+            end
+          end
+        end
+      end
+
+      def str_eq?(str_1, str_2, exact: false)
+        same_string?(str_1, str_2, **str_eq_params, 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 set.
+      # @return [Boolean] true when the field was present and removed.
+      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(fld.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 = components_of(src)
+        flds = flds.reject {|fld| ximport?(fld)} if @exclude_ximport
+        flds - @src_excluded
+      end
+
+      def dst_components
+        flds = components_of(dst)
+        flds = flds.reject {|fld| ximport?(fld)} if @exclude_ximport
+        flds - @dst_excluded
+      end
+
+      # Duck-typed access to a page model's data fields. Native GraphQL page
+      # models expose `#components` (a SectionCollection-backed collection); the
+      # v2 class relied on the same method name.
+      def components_of(entry)
+        entry.components.to_a
+      end
+
+      def ximport?(fld)
+        return false unless fld.respond_to?(:tooltip)
+
+        fld.tooltip.to_s.include?('ximport')
+      end
+
+      # A field is "empty" when it carries no content. Native DataField types do
+      # not universally expose `#empty?`; fall back to `#value` emptiness so the
+      # report filters behave like the v2 ones.
+      def field_empty?(fld)
+        return fld.empty? if fld.respond_to?(:empty?)
+        return fld.value.to_s.strip.empty? if fld.respond_to?(:value)
+
+        false
+      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/graphql/helpers/pages.rb

@@ -0,0 +1,21 @@
+module Eco::API::UseCases::GraphQL::Helpers
+  # Native GraphQL page-processing helper substrate.
+  #
+  # These mirror the *pure* parts of Eco::API::UseCases::OozeSamples::Helpers::* but drop the
+  # Ecoportal::API::V2 coupling: string/date utilities are ported verbatim, while the few
+  # methods that inspected V2 model types (object_reference, field_key_name) are re-expressed
+  # with duck-typing so they work against the GraphQL page/section/field models.
+  #
+  # This is Phase 1 of the ooze -> native GraphQL migration (build the shared substrate before
+  # any case). See ecoportal-api-graphql/.ai-assistance/projects/ooze-graphql-native-migration/.
+  module Pages
+  end
+end
+
+require_relative 'pages/shortcuts'
+require_relative 'pages/filters'
+require_relative 'pages/ooze_handlers'
+require_relative 'pages/rescuable'
+require_relative 'pages/creatable'
+require_relative 'pages/typed_fields_pairing'
+require_relative 'pages/copying'

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

@@ -6,3 +6,4 @@ end
 require_relative 'helpers/base'
 require_relative 'helpers/location'
 require_relative 'helpers/contractors'
+require_relative 'helpers/pages'

data/lib/eco/api/usecases/graphql/samples/location/command/service/tree_update.rb

@@ -57,7 +57,7 @@ class Eco::API::UseCases::GraphQL::Samples::Location
           digest_msgs  << "\n#{exception.patch_full_message(trace_count: 3)}" if exception
 
           session.mail(subject: subject, body: digest_msgs.join).tap do
-            options.deep_merge!({worfklow: {no_email: true}})
+            options.deep_merge!({workflow: {no_email: true}})
           end
         end
       end

data/lib/eco/api/usecases/graphql/samples/pages/register/base.rb

@@ -0,0 +1,181 @@
+module Eco::API::UseCases::GraphQL::Samples::Pages
+  # Native GraphQL re-expression of OozeSamples::RegisterUpdateCase.
+  #
+  # Register-scoped page processing: iterate the entries of a register in
+  # cursor-paginated batches, hand each page to `process_page` (a.k.a.
+  # `process_ooze` for naming parity with the v2 case), and track KPI counters
+  # over the whole run. Supports creating new entries via the native Creatable.
+  #
+  # This reproduces the SHAPE of RegisterUpdateCase (batched search, dedup-by-id,
+  # search/retrieved/updated/created/failed counters, a dry-run preview) natively,
+  # without the Ecoportal::API::V2 queue/enqueue coupling: the GraphQL update path
+  # is per-page (graphql.pages.update) rather than a batched patch queue, so the
+  # v2 batch_queue / enqueue / queue_shift machinery is intentionally dropped.
+  #
+  # == Subclass interface
+  #
+  #   class Custom::UseCase::CloseOldEntries < Eco::API::UseCases::GraphQL::Samples::Pages::Register::Base
+  #     name 'close-old-entries'
+  #     register_id 'REG_ABC123'
+  #     batch_size 25
+  #
+  #     def process_page(page)
+  #       return skip('not stale') unless stale?(page)
+  #       page.name = "[CLOSED] #{page.name}"
+  #       update_page(page)
+  #     end
+  #   end
+  #
+  # `register_id` may also come from `options[:source][:register_id]` (v2 parity),
+  # which takes precedence over the class-level declaration when present.
+  class Register::Base < Page::Base
+    include Eco::API::UseCases::GraphQL::Helpers::Pages::Shortcuts
+    include Eco::API::UseCases::GraphQL::Helpers::Pages::OozeHandlers
+    include Eco::API::UseCases::GraphQL::Helpers::Pages::Rescuable
+    include Eco::API::UseCases::GraphQL::Helpers::Pages::Creatable
+
+    name 'graphql-register-base'
+    type :other
+
+    class << self
+      def batch_size(size = nil)
+        @batch_size ||= 25
+        return @batch_size unless size
+
+        @batch_size = size
+      end
+    end
+
+    attr_reader :total_search_pages, :dupped_search_pages
+    attr_reader :retrieved_pages, :page_result_ids
+    attr_reader :created_pages, :page_create_attempts
+
+    # Entry point — called by GraphQL::Base#main.
+    def process
+      init_kpis
+      results_preview
+      each_page do |page|
+        process_page(page)
+        @processed_pages += 1
+      end
+      log_kpis
+    end
+
+    # == Subclass override points ==============================================
+
+    # Transform or act on one page. Call update_page(page) to persist changes.
+    # Alias `process_ooze` is provided for naming parity with the v2 case.
+    def process_page(_page)
+      raise NotImplementedError, "Implement #process_page in #{self.class}"
+    end
+
+    # Naming-parity alias for the v2 case. Forwards (rather than alias_method) so a
+    # subclass overriding #process_page is honoured when called as #process_ooze.
+    def process_ooze(page)
+      process_page(page)
+    end
+
+    # Return the register id to scope the search to.
+    # `options[:source][:register_id]` (v2 parity) wins over the class declaration.
+    def register_id
+      options.dig(:source, :register_id) || self.class.register_id
+    end
+
+    # Return a SearchConf for the page search. Override to add filters.
+    # Default: scoped to register_id (raises if none configured — a register case
+    # without a register would silently scan the whole org).
+    def search_conf
+      reg = register_id
+      raise ArgumentError, 'No register_id configured (class register_id or options[:source][:register_id])' unless reg
+
+      sc.new.filter(in_register(reg))
+    end
+
+    protected
+
+    # Typed value merge for a GraphQL data field. Convenience over OozeHandlers#merge_values
+    # that reads the field's own #type so a subclass need not pass it explicitly.
+    #
+    #   fld = page.components.get_by_name('Notes')
+    #   fld.value = merge_field_values(fld, incoming_notes)
+    #
+    # @param field [#type] a GraphQL DataField (or anything responding to #type).
+    # @param append [Object] the value to merge onto the field's current value.
+    # @param origin [Object] the base value; defaults to the field's current #value.
+    # @param delimiter [String] delimiter for :delimiter-strategy types.
+    # @return [Object] the merged value.
+    def merge_field_values(field, append, origin: nil, delimiter: "\n")
+      base = origin.nil? && field.respond_to?(:value) ? field.value : origin
+      merge_values(base, append, type: field, delimiter: delimiter)
+    end
+
+    # Launches the actual creation of the entry (hook driven by Creatable).
+    # Respects simulate? for dry-run; on live create, bumps the created counter.
+    # @return [Ecoportal::API::GraphQL::Compat::PageReference, false]
+    def create_ooze(draft, template_id: draft&.template_id)
+      @page_create_attempts += 1
+      if simulate?
+        dry_run_feedback(draft)
+        return false
+      end
+
+      graphql.pages.create(draft, from: template_id).tap do |result|
+        @created_pages += 1 if result.respond_to?(:page_id) && result.page_id
+      end
+    end
+
+    # Cursor-paginated iteration over the register's pages. Counts total search
+    # results and flags duplicated page ids (dedup-by-id, v2 parity).
+    def each_page(conf: search_conf, first: self.class.batch_size)
+      graphql.pages.each(search_conf: conf.to_h, first: first) do |page|
+        @total_search_pages += 1
+        if page_result_ids[page.id]
+          @dupped_search_pages += 1
+        else
+          page_result_ids[page.id] = true
+          @total_pages += 1
+        end
+        @retrieved_pages += 1
+        yield page
+      end
+    end
+
+    private
+
+    # Dry-run preview of what a create WOULD send. Faithful but scoped: the
+    # GraphQL cursor search offers no cheap "total before filtering" count like the
+    # v2 registers.search(only_first:), so there is no up-front count prompt here.
+    def dry_run_feedback(draft)
+      log(:info) { "Simulate — would create page from template #{draft&.template_id}" }
+      nil
+    end
+
+    def results_preview
+      log(:info) { "Processing register '#{register_id}' in batches of #{self.class.batch_size}" }
+    end
+
+    def init_kpis
+      super
+      @total_search_pages   = 0
+      @dupped_search_pages  = 0
+      @retrieved_pages      = 0
+      @page_result_ids      = {}
+      @created_pages        = 0
+      @page_create_attempts = 0
+    end
+
+    def kpis_message
+      [
+        'Run end:',
+        "  * Search results:  #{total_search_pages}",
+        "  * Duplicated:      #{dupped_search_pages}",
+        "  * Retrieved:       #{retrieved_pages}",
+        "  * Processed:       #{processed_pages}",
+        "  * Updated:         #{updated_pages} (of #{total_pages} unique)",
+        "  * Created:         #{created_pages} (of #{page_create_attempts} attempts)",
+        "  * Skipped:         #{skipped_pages}",
+        "  * Failed:          #{failed_pages}"
+      ].join("\n")
+    end
+  end
+end

data/lib/eco/api/usecases/graphql/samples/pages/register/migration_case.rb

@@ -0,0 +1,132 @@
+module Eco::API::UseCases::GraphQL::Samples::Pages
+  # Native GraphQL re-expression of OozeSamples::RegisterMigrationCase.
+  #
+  # Migrates the entries of a register into NEW entries of a (possibly different)
+  # template, copying data across by PAIRING typed fields between the source page
+  # and the freshly drafted destination page. Field pairing is delegated to the
+  # native `Helpers::Pages::TypedFieldsPairing` (label + type matching over
+  # GraphQL DataField types); the actual per-field content copy dispatches on the
+  # GraphQL DataField TYPE STRING (mirroring how OozeHandlers#merge_values ports
+  # the v2 type-class dispatch).
+  #
+  # It reproduces the SHAPE of RegisterMigrationCase natively:
+  #   * iterate the source register (inherited from Register::Base#each_page)
+  #   * draft a new entry of TEMPLATE_ID (via the native Creatable)
+  #   * pair the source fields to the draft fields and copy content
+  #   * run the unpaired / multi-pair reports (data-loss visibility)
+  #   * let a subclass finalise the draft via #custom_processing
+  #
+  # As with the rest of the native samples layer this is NON-BREAKING and
+  # additive: no OozeSamples name is flipped and the legacy
+  # HelpersMigration::TypedFieldsPairing / RegisterMigrationCase are untouched.
+  #
+  # == What differs from the v2 case
+  # * dispatch is on GraphQL DataField type strings (PlainText/Select/...) not
+  #   V2 component classes / snake_case types
+  # * the per-page persistence is the native create path (Creatable#create_ooze →
+  #   graphql.pages.create), not the v2 batch queue
+  # * the v2 JSON `field_maps` / `copy_hooked_fields` mapping layer is NOT ported
+  #   here (that consumes the v2 `with_fields`/regex-hook helpers); this scaffold
+  #   covers the generic typed pairing. Mapped-field hooks are a later increment.
+  #
+  # == Subclass interface
+  #
+  #   class Custom::UseCase::MigrateTraining < Eco::API::UseCases::GraphQL::Samples::Pages::Register::MigrationCase
+  #     name 'migrate-training'
+  #     register_id 'REG_SOURCE'   # source register to read from
+  #     TEMPLATE_ID = 'TPL_DEST'   # destination template to create entries of
+  #
+  #     # Optional: finalise the draft after generic pairing has run.
+  #     def custom_processing(draft, source, fields_tracker: nil)
+  #       draft.name = source.name
+  #     end
+  #   end
+  #
+  # Expects `options[:source][:register_id]` (or class `register_id`) for the
+  # source scope, and a destination template id via the `TEMPLATE_ID` constant
+  # (overridable through #destination_template_id).
+  class Register::MigrationCase < Register::Base
+    include Eco::API::UseCases::GraphQL::Helpers::Pages::Copying
+
+    name 'graphql-register-migration-case'
+    type :other
+
+    # Destination template constant (subclasses set this).
+    TEMPLATE_ID = nil
+
+    # 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_EMPTY = false
+    # whether or not it should warn on unpaired source fields that are deindexed
+    REPORT_SRC_DEINDEX = false
+
+    # One source entry → one new destination entry.
+    #
+    # Drafts a destination page of `destination_template_id`, pairs the source
+    # fields to the draft's fields, copies content across, runs the reports, and
+    # (optionally) hands the draft to #custom_processing for finalising.
+    def process_page(source)
+      draft_reference = object_reference(source)
+      creating_new_page(draft_reference, template_id: destination_template_id) do |draft|
+        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
+
+        report_pairing(pairing_tracking)
+      end
+    end
+
+    protected
+
+    # The destination template to create entries of. Override or set TEMPLATE_ID.
+    def destination_template_id
+      tpl = self.class::TEMPLATE_ID
+      raise ArgumentError, "No destination template configured (set #{self.class}::TEMPLATE_ID)" unless tpl
+
+      tpl
+    end
+
+    private
+
+    # Pair the generic typed fields and copy their content. Returns the tracker so
+    # the caller can inspect unpaired / multi-paired fields.
+    def copy_pairings(src, dst)
+      after_copy = respond_to?(:paired_fields_post_callback, true) ? method(:paired_fields_post_callback) : nil
+
+      copy_generic_paired_fields(
+        src,
+        dst,
+        exclude_ximport: self.class::EXCLUDE_XIMPORT,
+        &after_copy
+      )
+    end
+
+    def report_pairing(tracker)
+      msg = tracker.report_src_unpaired(
+        only_present: !self.class::REPORT_SRC_EMPTY,
+        only_indexed: !self.class::REPORT_SRC_DEINDEX
+      )
+      log(:warn) { msg } if msg
+
+      msg = tracker.report_multi_pairs(
+        only_present:        !self.class::REPORT_SRC_EMPTY,
+        only_indexed:        !self.class::REPORT_SRC_DEINDEX,
+        dst_exclude_ximport: !self.class::REPORT_DST_XIMPORT
+      )
+      log(:warn) { msg } if msg
+
+      msg = tracker.report_dst_unpaired(
+        only_required:   false,
+        exclude_ximport: !self.class::REPORT_DST_XIMPORT
+      )
+      log(:warn) { msg } if msg
+    end
+  end
+end