eco-helpers 3.2.16 → 3.2.17

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

@@ -0,0 +1,114 @@
+# rubocop:disable Lint/SymbolConversion, Style/QuotedSymbols
+module Eco::API::UseCases::GraphQL::Helpers
+  module Pages
+    # Search-filter + time-math helpers, ported from OozeSamples::Helpers::Filters.
+    #
+    # The time/date/tag builders are pure and ported verbatim. #field_key_name's field branch
+    # is re-expressed with duck-typing (was a `V2::Page::Component` case) — see the note there.
+    # A `weekday` helper is added because the original relied on one defined outside Filters
+    # (undefined in lib/), which made the sunday/monday chain latent-broken.
+    module Filters
+      FILTER_TIME_FORMAT = '%Y-%m-%dT%H:%M:%SZ'.freeze
+
+      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, hour, min, sec)
+        Time.new(date.year, date.month, date.day, hour, min, sec)
+      end
+
+      def weeks(num)
+        num * days(7)
+      end
+
+      def days(num)
+        num * 60 * 60 * 24
+      end
+
+      def today
+        Date.today.to_time
+      end
+
+      # 0 = Sunday .. 6 = Saturday (Date#wday). Added: the original relied on a `weekday`
+      # helper defined outside Filters (not present in lib/), leaving the chain below broken.
+      def weekday(date)
+        (date.respond_to?(:to_date) ? date.to_date : date).wday
+      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(date) + days(1), 0, 0, 0)
+      end
+
+      # Resolve a filter [key, name] pair for the register search.
+      #
+      # @note **Search-key gotcha:** the register search matches on the field DEFINITION key,
+      #   not the field's name/label. For a data-field object we therefore prefer its backend
+      #   reference key. The exact GraphQL accessor is duck-typed here (ref_backend -> key) and
+      #   must be confirmed against the live field model before relying on field-scoped search
+      #   filters (a wrong key silently matches 0 rows). See the CANS search-key note.
+      def field_key_name(value)
+        case value
+        when :updated_at then ["updated_at", "Last updated"]
+        when :created_at then ["created_at", "Page created"]
+        when :tags       then ["tags", "Location Tags"]
+        else
+          if value.respond_to?(:ref_backend)
+            [value.ref_backend, (value.respond_to?(:label) ? value.label : nil)]
+          elsif value.respond_to?(:key)
+            [value.key, (value.respond_to?(:label) ? value.label : nil)]
+          else
+            [nil, nil]
+          end
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Lint/SymbolConversion, Style/QuotedSymbols

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

@@ -0,0 +1,112 @@
+module Eco::API::UseCases::GraphQL::Helpers
+  module Pages
+    # Native GraphQL re-expression of OozeSamples::Helpers::OozeHandlers.
+    #
+    # `merge_values` combines two values of a data field of the *same* type and
+    # label into one, matching the v2 semantics but dispatching on the GraphQL
+    # DataField TYPE STRING (e.g. 'PlainText', 'Select', 'Date') rather than on
+    # `Ecoportal::API::V2::Page::Component::*` classes. The type strings are the
+    # `__typename`-derived values in
+    # `Ecoportal::API::GraphQL::Base::Page::DataField::TYPE_MAP`.
+    #
+    # `merge_arrays` / `array_indexes` are pure array utilities — ported verbatim.
+    module OozeHandlers
+      # Per-type merge strategy.
+      #   :join   → concatenate origin + append with a delimiter (text, select,
+      #             reference, people, checklist, action list, files, images, geo, law)
+      #   :origin → keep the origin value untouched (date, number, gauge — no sensible
+      #             textual concatenation; the v2 case returned `origin` for these)
+      #
+      # Text-ish types always merge with a NEWLINE delimiter in v2 (RichText /
+      # PlainText) regardless of the caller's `delimiter:`; the rest honour it.
+      MERGE_STRATEGY = {
+        'PlainText'      => %i[join newline],
+        'RichText'       => %i[join newline],
+        'Select'         => %i[join delimiter],
+        'CrossReference' => %i[join delimiter],
+        'People'         => %i[join delimiter],
+        'Checklist'      => %i[join delimiter],
+        'ActionsList'    => %i[join delimiter],
+        'FileField'      => %i[join delimiter],
+        'File'           => %i[join delimiter],
+        'ImageGallery'   => %i[join delimiter],
+        'Geo'            => %i[join delimiter],
+        'Law'            => %i[join delimiter],
+        'DateField'      => %i[origin],
+        'Date'           => %i[origin],
+        'Number'         => %i[origin],
+        'Gauge'          => %i[origin]
+      }.freeze
+
+      # Merge values of fields of the same type and label name.
+      #
+      # @param origin [Object] the value to keep as the base.
+      # @param append [Object] the value to merge onto `origin`.
+      # @param type [String, Symbol, nil] the GraphQL DataField type string
+      #   (e.g. 'PlainText', 'Select'). Nil / unknown → default join. Accepts a
+      #   field object responding to #type too (convenience).
+      # @param delimiter [String] the delimiter for :delimiter-strategy types.
+      # @return [Object] the merged value.
+      def merge_values(origin, append, type: nil, delimiter: "\n")
+        return origin if !append || append.to_s.strip.empty?
+        return append if !origin || origin.to_s.strip.empty?
+
+        type_key = resolve_field_type(type)
+        strategy, delim_kind = MERGE_STRATEGY.fetch(type_key, %i[join delimiter])
+
+        return origin if strategy == :origin
+
+        used_delimiter = delim_kind == :newline ? "\n" : delimiter
+        [origin, append].join(used_delimiter)
+      end
+
+      # Merges arrays `ref` and `plus` by keeping the order of `ref`
+      # but inserting additional elements of `plus` in the correct position
+      # (i.e. when those elements are between two elements that exist in `ref`).
+      # @note this can be used to combine two different header sequences
+      #   by using `ref` as a reference.
+      def merge_arrays(ref, plus) # rubocop:disable Metrics/AbcSize
+        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)
+
+        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), href_idx_plus|
+          ps_idx = shared_plus_idxs.bsearch {|i| idx >= i}
+          rs_idx = ps_idx ? hshared_ref_idx[plus[ps_idx]] : -1
+          href_idx_plus[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), rf|
+          rf.insert(idx + 1, *elements)
+        end
+      end
+
+      def array_indexes(ary)
+        ary.each_with_index.to_h
+      end
+
+      private
+
+      # Accept either a type string/symbol or a field object that responds to #type.
+      def resolve_field_type(type)
+        return type.type.to_s if type.respond_to?(:type)
+
+        type.to_s
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module Eco::API::UseCases::GraphQL::Helpers
+  module Pages
+    # Prevents a script from stopping on a per-item error, prompting the operator to
+    # continue or abort. Ported from OozeSamples::Helpers::Rescuable; the only change is
+    # the base-type guard, which now requires a native GraphQL::Base case.
+    module Rescuable
+      module InstanceMethods
+        private
+
+        # Helper to prevent script from stopping
+        def with_rescue(reference, trace_count: 1)
+          raise ArgumentError, 'Expecting block, but not given' unless block_given?
+          yield
+        rescue StandardError => e
+          str_err = e.patch_full_message(trace_count: trace_count)
+          log(:error) { [reference, str_err].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
+            raise if res.start_with?('A')
+
+            # 'C'
+            log(:warn) { "Script resumed after error...\n  * #{reference}" }
+            nil
+          end
+        end
+      end
+
+      class << self
+        def included(base)
+          super
+          validate_base_type!(base)
+          base.include(InstanceMethods)
+        end
+
+        def validate_base_type!(base)
+          return super if defined?(super)
+
+          msg  = "#{self} can only be included in Eco::API::UseCases::GraphQL::Base"
+          msg << "\nCan't be included in #{base}"
+          raise LoadError, msg unless base <= Eco::API::UseCases::GraphQL::Base
+
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,186 @@
+module Eco::API::UseCases::GraphQL::Helpers
+  module Pages
+    # String simplification / comparison helpers, ported from
+    # OozeSamples::Helpers::Shortcuts. Everything here is pure except #object_reference,
+    # which is re-expressed with duck-typing (no Ecoportal::API::V2 constants) so it
+    # describes GraphQL page/stage/section/field/force models.
+    module Shortcuts
+      # Basic simplification pattern (matches all but a-z and blank space)
+      def non_letters_regex
+        @non_letters_regex ||= /[^a-z ]+/
+      end
+
+      # Matches anything between two consecutive (), inclusive
+      def bracked_regex
+        @bracked_regex ||= /(?<bracked>\([^\)]+?\))/ # rubocop:disable Style/RedundantRegexpEscape
+      end
+
+      # It always downcase, trim and remove double spaces.
+      # @param ignore [Boolean, Regexp, String, Array] ignored when `exact` is `true`
+      #   * when `false`: it does not do anything additional
+      #   * when `Regexp`: 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 then sub = ignore
+        when String then sub = /[#{ignore}]+/
+        when Array
+          return ignore.reduce(str) do |out, sub_ignore|
+            simplify_string(out, ignore: sub_ignore)
+          end
+        end
+        str.gsub(sub, '').gsub(/\s+/, ' ').strip
+      end
+
+      # Offers multiple simplification methods to compare two strings
+      # @note only one of the values can be a Regexp
+      def same_string?(value_1, value_2, exact: false, mild: false, ignore: false) # rubocop:disable Metrics/AbcSize
+        return true  if value_1.to_s.strip.empty? && value_2.to_s.strip.empty?
+        return false if value_1.to_s.strip.empty? || value_2.to_s.strip.empty?
+
+        val_1 = value_1
+        val_2 = value_2
+
+        unless exact
+          if val_1.is_a?(String)
+            val_1 = simplify_string(val_1, ignore: ignore) if ignore
+            val_1 = simplify_string(val_1, ignore: non_letters_regex) if mild
+          end
+          if val_2.is_a?(String)
+            val_2 = simplify_string(val_2, ignore: ignore) if ignore
+            val_2 = simplify_string(val_2, ignore: non_letters_regex) if mild
+          end
+        end
+
+        if val_1.is_a?(String) && val_2.is_a?(String)
+          val_1 == val_2
+        elsif val_1.is_a?(Regexp) && val_2.is_a?(String)
+          val_2 =~ val_1
+        elsif val_1.is_a?(String) && val_2.is_a?(Regexp)
+          val_1 =~ val_2
+        else
+          msg  = 'Expected at least one String, and either a String or Regex. '
+          msg << "Given: (1: #{val_1.class}) and (2: #{val_2.class})"
+          raise ArgumentError, msg
+        end
+      end
+
+      def titleize(str)
+        return nil unless str
+        return str if str.strip.empty?
+
+        str.split(/\s+/).map do |part|
+          part[0] = part[0].upcase
+          part[1..] = part[1..].downcase
+          part
+        end.join(' ')
+      end
+
+      def normalize_string(str)
+        return nil unless str
+
+        str.gsub(/[^[:print:]]/, '').
+          gsub(/[[:space:]]+/, ' ').
+          gsub(/[[:space:]]$/, '').
+          gsub(/[-‑‒–]/, '-').then do |aux|
+            aux = yield(aux) if block_given?
+            aux
+          end
+      end
+
+      def clean_question(str)
+        return nil unless str
+
+        normalize_string(str) do |x|
+          x.gsub("\r\n", ' ').then do |aux|
+            aux = yield(aux) if block_given?
+            aux
+          end
+        end
+      end
+
+      # Human-readable reference for a GraphQL page-model object, for logs/errors.
+      #
+      # Re-expressed with duck-typing (was a V2 `case/when` on Page/Stage/Section/Component/
+      # Force/Binding). We inspect the object's shape rather than its class so this works
+      # across Base::/Model:: GraphQL types without coupling to constants that may move.
+      def object_reference(obj)
+        return 'No reference' unless obj
+
+        if binding_like?(obj)
+          "Binding '#{safe_name(obj)}' in #{object_reference(obj.force)}"
+        elsif force_like?(obj)
+          "Force '#{safe_name(obj)}'"
+        elsif component_like?(obj)
+          label = obj.respond_to?(:label) ? obj.label : nil
+          type  = obj.respond_to?(:type) ? obj.type : nil
+          ref = "Component '#{label || "(unnamed of type '#{type}')"}'"
+          ref += " in #{object_reference(obj.section)}" if obj.respond_to?(:section) && obj.section
+          ref
+        elsif section_like?(obj)
+          heading = obj.respond_to?(:heading) ? obj.heading : nil
+          "Section '#{heading || '(unnamed)'}'"
+        elsif stage_like?(obj)
+          named_ref('Stage', obj)
+        elsif page_like?(obj)
+          named_ref("Page (#{obj.id})", obj)
+        else
+          named_ref('', obj).strip
+        end
+      end
+
+      def to_i(value)
+        Float(value).to_i
+      end
+
+      # https://stackoverflow.com/a/5661695/4352306
+      # Kept as `is_number?` for naming parity with OozeSamples::Helpers::Shortcuts.
+      def is_number?(value) # rubocop:disable Naming/PredicatePrefix
+        true if Float(value)
+      rescue ArgumentError, TypeError
+        false
+      end
+
+      private
+
+      def binding_like?(obj)
+        obj.respond_to?(:force) && obj.respond_to?(:name) && !obj.respond_to?(:bindings)
+      end
+
+      def force_like?(obj)
+        obj.respond_to?(:bindings) && obj.respond_to?(:name)
+      end
+
+      def component_like?(obj)
+        obj.respond_to?(:label) && (obj.respond_to?(:type) || obj.respond_to?(:section))
+      end
+
+      def section_like?(obj)
+        obj.respond_to?(:heading) && obj.respond_to?(:components)
+      end
+
+      def stage_like?(obj)
+        obj.respond_to?(:ordering) && obj.respond_to?(:state)
+      end
+
+      def page_like?(obj)
+        obj.respond_to?(:id) && obj.respond_to?(:stages)
+      end
+
+      def safe_name(obj)
+        obj.respond_to?(:name) ? obj.name : nil
+      end
+
+      def named_ref(prefix, obj)
+        name = safe_name(obj)
+        name ? "#{prefix} '#{name}'" : prefix
+      end
+    end
+  end
+end