ecoportal-api-graphql 1.3.5 → 1.3.9

data/lib/ecoportal/api/graphql/builder/page.rb

@@ -1,41 +1,210 @@
-module Ecoportal
-  module API
-    class GraphQL
-      module Builder
-        class Page
-          attr_reader :client
-
-          def initialize(client)
-            @client = client
-          end
-
-          # def archive(**kargs, &block)
-          #   archiveMutation.query(**kargs, &block)
-          # end
-
-          # def update(**kargs, &block)
-          #   updateMutation.query(**kargs, &block)
-          # end
-
-          # def create(**kargs, &block)
-          #   createMutation.query(**kargs, &block)
-          # end
-
-          private
-
-          # def archiveMutation
-          #   Mutation::Page::Archive.new(client)
-          # end
-
-          # def updateMutation
-          #   Mutation::Page::Update.new(client)
-          # end
-
-          # def createMutation
-          #   Mutation::Page::Create.new(client)
-          # end
-        end
-      end
-    end
-  end
-end
+module Ecoportal
+  module API
+    class GraphQL
+      module Builder
+        class Page
+          attr_reader :client
+
+          def initialize(client)
+            @client = client
+          end
+
+          def update(**kargs, &block)
+            updateMutation.query(**kargs, &block)
+          end
+
+          # Archive a page. With `clear_external_id: true`, first BLANKS the page's externalId
+          # (a separate updatePage) before archiving, so the freed id can be reused. Use this
+          # ONLY when archiving a failed / duplicate creation. Default false: a genuine
+          # historical archive KEEPS its externalId — the integration pairing key, unique per
+          # org per model (see ecoPortal_architecture/02_data_model.md).
+          #
+          # Implemented as two serial mutations (blank-then-archive) reusing the existing
+          # update/archive mutations. (The equivalent atomic single-document composite —
+          # `updatePage(page:{externalId:null}) @include(if:$blank) archivePage` — is a possible
+          # future refinement if blank-then-archive atomicity is ever required.)
+          def archive(clear_external_id: false, **kargs, &block)
+            blank_external_id(kargs) if clear_external_id
+            archiveMutation.query(**kargs, &block)
+          end
+
+          def unarchive(**kargs, &block)
+            unarchiveMutation.query(**kargs, &block)
+          end
+
+          def build_from_template(**kargs, &block)
+            buildFromTemplateMutation.query(**kargs, &block)
+          end
+
+          def create_from_template(**kargs, &block)
+            createFromTemplateMutation.query(**kargs, &block)
+          end
+
+          def create_draft(**kargs, &block)
+            createDraftMutation.query(**kargs, &block)
+          end
+
+          def delete_draft(**kargs, &block)
+            deleteDraftMutation.query(**kargs, &block)
+          end
+
+          def publish_draft(**kargs, &block)
+            publishDraftMutation.query(**kargs, &block)
+          end
+
+          def approve_review_task(**kargs, &block)
+            approveReviewTaskMutation.query(**kargs, &block)
+          end
+
+          def reject_review_task(**kargs, &block)
+            rejectReviewTaskMutation.query(**kargs, &block)
+          end
+
+          def restart_review_task(**kargs, &block)
+            restartReviewTaskMutation.query(**kargs, &block)
+          end
+
+          def undo_review_task(**kargs, &block)
+            undoReviewTaskMutation.query(**kargs, &block)
+          end
+
+          def batch_update_review_task(**kargs, &block)
+            batchUpdateReviewTaskMutation.query(**kargs, &block)
+          end
+
+          # Executes workflow commands against a page or template.
+          # @param model [Base::Page::*] the page/template (must have id and patchVer)
+          # @param commands [Array<Hash>] array of WorkflowCommandInput hashes
+          # @param patch_ver [Integer] override patchVer (defaults to model.patchVer)
+          def execute_workflow_commands(model, commands:, patch_ver: model.patchVer, &block)
+            executeWorkflowCommandsMutation.query(
+              id:        model.id,
+              patch_ver: patch_ver,
+              commands:  commands,
+              &block
+            )
+          end
+
+          # @deprecated Use execute_workflow_commands instead.
+          def execute_force_commands(id:, patch_ver:, commands:, &block)
+            Concerns::Deprecation.warn_once(:execute_force_commands,
+                                            'Use execute_workflow_commands(model, commands: [...]) instead')
+            executeForceMutation.query(id: id, patch_ver: patch_ver, commands: commands, &block)
+          end
+
+          def update_variable_bindings(**kargs, &block)
+            updateVariableBindingsMutation.query(**kargs, &block)
+          end
+
+          # AI field mutations
+          def generate_ai_summary(**kargs, &block)
+            generateAiSummaryMutation.query(**kargs, &block)
+          end
+
+          def submit_ai_summary_feedback(**kargs, &block)
+            submitAiSummaryFeedbackMutation.query(**kargs, &block)
+          end
+
+          def generate_smart_fill(**kargs, &block)
+            generateSmartFillMutation.query(**kargs, &block)
+          end
+
+          def submit_smart_fill_feedback(**kargs, &block)
+            submitSmartFillFeedbackMutation.query(**kargs, &block)
+          end
+
+          private
+
+          # Blank the page's externalId via updatePage (no patchVer needed — cleanup path).
+          # Reads the id from the archive kargs (input: { id: }).
+          def blank_external_id(kargs)
+            id = kargs.dig(:input, :id) || kargs[:id]
+            return unless id
+
+            updateMutation.query(input: { id: id, page: { externalId: nil } })
+          end
+
+          def updateMutation
+            Mutation::Page::Update.new(client)
+          end
+
+          def archiveMutation
+            Mutation::Page::Archive.new(client)
+          end
+
+          def unarchiveMutation
+            Mutation::Page::Unarchive.new(client)
+          end
+
+          def buildFromTemplateMutation
+            Mutation::Page::BuildFromTemplate.new(client)
+          end
+
+          def createFromTemplateMutation
+            Mutation::Page::CreateFromTemplate.new(client)
+          end
+
+          def createDraftMutation
+            Mutation::Page::CreateDraft.new(client)
+          end
+
+          def deleteDraftMutation
+            Mutation::Page::DeleteDraft.new(client)
+          end
+
+          def publishDraftMutation
+            Mutation::Page::PublishDraft.new(client)
+          end
+
+          def approveReviewTaskMutation
+            Mutation::Page::ApproveReviewTask.new(client)
+          end
+
+          def rejectReviewTaskMutation
+            Mutation::Page::RejectReviewTask.new(client)
+          end
+
+          def restartReviewTaskMutation
+            Mutation::Page::RestartReviewTask.new(client)
+          end
+
+          def undoReviewTaskMutation
+            Mutation::Page::UndoReviewTask.new(client)
+          end
+
+          def batchUpdateReviewTaskMutation
+            Mutation::Page::BatchUpdateReviewTask.new(client)
+          end
+
+          def generateAiSummaryMutation
+            Mutation::AiSummary::Generate.new(client)
+          end
+
+          def submitAiSummaryFeedbackMutation
+            Mutation::AiSummary::SubmitFeedback.new(client)
+          end
+
+          def generateSmartFillMutation
+            Mutation::SmartFill::Generate.new(client)
+          end
+
+          def submitSmartFillFeedbackMutation
+            Mutation::SmartFill::SubmitFeedback.new(client)
+          end
+
+          def executeWorkflowCommandsMutation
+            Mutation::Page::ExecuteWorkflowCommands.new(client)
+          end
+
+          def executeForceMutation
+            Mutation::Page::ExecuteForceCommands.new(client)
+          end
+
+          def updateVariableBindingsMutation
+            Mutation::Page::UpdateVariableBindings.new(client)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/graphql/builder/register/preset_view.rb

@@ -0,0 +1,84 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Builder
+        class Register
+          # Sub-builder for preset view operations within a register context.
+          # Access via: api.register.preset_view
+          #
+          # Usage:
+          #   pv = api.register.preset_view
+          #
+          #   # List preset views for a register (find IDs for presetViewId in searches)
+          #   views = pv.list('REG_ID')
+          #   views.map { |v| "#{v.name} (#{v.id}) global=#{v.global?}" }
+          #
+          #   # Create a preset view
+          #   pv.create(input: {
+          #     registerId:     'REG_ID',
+          #     name:           'Active Pages',
+          #     customPresetView: true,
+          #     fieldConfigs:   [{ key: 'name', weight: 0 }, { key: 'state', weight: 1 }],
+          #     sorter:         { key: 'created_at', direction: 'desc' }
+          #   })
+          #
+          #   # Share with a user (view access)
+          #   pv.permission(input: {
+          #     id:          'VIEW_ID',
+          #     permissions: [{ level: 'view', to: { userId: 'USER_ID' } }]
+          #   })
+          class PresetView
+            attr_reader :client
+
+            def initialize(client)
+              @client = client
+            end
+
+            # List all preset views for a register. Returns an array of PresetView objects.
+            def list(register_id, search_conf: nil, &block)
+              Query::RegisterPresetViews.new(client).query(
+                registerId: register_id,
+                searchConf: search_conf,
+                &block
+              ).nodes
+            end
+
+            def create(**kargs, &block)
+              createMutation.query(**kargs, &block)
+            end
+
+            def update(**kargs, &block)
+              updateMutation.query(**kargs, &block)
+            end
+
+            def permission(**kargs, &block)
+              permissionMutation.query(**kargs, &block)
+            end
+
+            def destroy(**kargs, &block)
+              destroyMutation.query(**kargs, &block)
+            end
+
+            private
+
+            def createMutation
+              Mutation::PresetView::Create.new(client)
+            end
+
+            def updateMutation
+              Mutation::PresetView::Update.new(client)
+            end
+
+            def permissionMutation
+              Mutation::PresetView::Permission.new(client)
+            end
+
+            def destroyMutation
+              Mutation::PresetView::Destroy.new(client)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/graphql/builder/register.rb

@@ -1,4 +1,4 @@
-module Ecoportal
+module Ecoportal
   module API
     class GraphQL
       module Builder
@@ -9,33 +9,41 @@ module Ecoportal
             @client = client
           end
 
-          # def archive(**kargs, &block)
-          #   archiveMutation.query(**kargs, &block)
-          # end
+          # Register CRUD
+          def create(**kargs, &block)
+            createMutation.query(**kargs, &block)
+          end
 
-          # def update(**kargs, &block)
-          #   updateMutation.query(**kargs, &block)
-          # end
+          def update(**kargs, &block)
+            updateMutation.query(**kargs, &block)
+          end
 
-          # def create(**kargs, &block)
-          #   createMutation.query(**kargs, &block)
-          # end
+          def destroy(**kargs, &block)
+            destroyMutation.query(**kargs, &block)
+          end
+
+          # Preset view sub-builder — list, create, update, permission, destroy
+          def preset_view
+            Register::PresetView.new(client)
+          end
 
           private
 
-          # def archiveMutation
-          #   Mutation::Register::Archive.new(client)
-          # end
+          def createMutation
+            Mutation::Register::Create.new(client)
+          end
 
-          # def updateMutation
-          #   Mutation::Register::Update.new(client)
-          # end
+          def updateMutation
+            Mutation::Register::Update.new(client)
+          end
 
-          # def createMutation
-          #   Mutation::Register::Create.new(client)
-          # end
+          def destroyMutation
+            Mutation::Register::Destroy.new(client)
+          end
         end
       end
     end
   end
 end
+
+require_relative 'register/preset_view'

data/lib/ecoportal/api/graphql/builder/template.rb

@@ -0,0 +1,80 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Builder
+        class Template
+          attr_reader :client
+
+          def initialize(client)
+            @client = client
+          end
+
+          def create(commands:, &block)
+            createMutation.query(commands: commands, &block)
+          end
+
+          def update(model, commands:, patch_ver: model.patchVer, &block)
+            updateMutation.query(id: model.id, patch_ver: patch_ver, commands: commands, &block)
+          end
+
+          def publish(id:, &block)
+            publishMutation.query(id: id, &block)
+          end
+
+          def unpublish(id:, &block)
+            unpublishMutation.query(id: id, &block)
+          end
+
+          def update_information(id:, **kargs, &block)
+            updateInformationMutation.query(id: id, **kargs, &block)
+          end
+
+          def create_related_page(template_id:, title:, register_id:, patch_ver:, filters: nil, &block)
+            createRelatedPageMutation.query(
+              template_id: template_id,
+              title:       title,
+              register_id: register_id,
+              patch_ver:   patch_ver,
+              filters:     filters,
+              &block
+            )
+          end
+
+          def destroy_related_page(template_id:, id:, patch_ver:, &block)
+            destroyRelatedPageMutation.query(template_id: template_id, id: id, patch_ver: patch_ver, &block)
+          end
+
+          private
+
+          def createMutation
+            Mutation::Template::Create.new(client)
+          end
+
+          def updateMutation
+            Mutation::Template::Update.new(client)
+          end
+
+          def publishMutation
+            Mutation::Template::Publish.new(client)
+          end
+
+          def unpublishMutation
+            Mutation::Template::Unpublish.new(client)
+          end
+
+          def updateInformationMutation
+            Mutation::Template::UpdateInformation.new(client)
+          end
+
+          def createRelatedPageMutation
+            Mutation::Template::CreateRelatedPage.new(client)
+          end
+
+          def destroyRelatedPageMutation
+            Mutation::Template::DestroyRelatedPage.new(client)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/graphql/builder.rb

@@ -12,3 +12,5 @@ require_relative 'builder/action'
 require_relative 'builder/contractor_entity'
 require_relative 'builder/register'
 require_relative 'builder/page'
+require_relative 'builder/kickstand'
+require_relative 'builder/template'

data/lib/ecoportal/api/graphql/compat/filter_translator.rb

@@ -0,0 +1,107 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Compat
+        # Translates v2-style filter hashes to GraphQL-compatible filter hashes.
+        # Extracted from Compat::Registers so any part of the compat layer can use it.
+        #
+        # SearchConf filter objects (respond_to :to_h, not a Hash) are passed through —
+        # callers may also pass already-translated hashes or SearchConf instances directly.
+        #
+        # v2 → GraphQL translation table:
+        #   date_filter     lbound/ubound → gte/lte (ES date range)
+        #   text_filter     {query, key} → match_filter {key, value} (partial text)
+        #   options_filter  {chosen, key, mode} → one_of_filter {key, values} (or none_of_filter)
+        #   tag_filter      passed through (same ES backend, same format)
+        #   register_filter passed through
+        #   and_filter / or_filter  passed through
+        # Operation/param shapes per .ai-assistance/code/search_filters.md.
+        class FilterTranslator
+          class << self
+            def to_graphql(filter)
+              return filter if filter.respond_to?(:to_h) && !filter.is_a?(Hash)
+              return filter unless filter.is_a?(Hash)
+
+              case filter['type'] || filter[:type]
+              when 'date_filter'
+                translate_date_filter(filter)
+              when 'text_filter'
+                translate_text_filter(filter)
+              when 'exact_filter', 'is_filter'
+                translate_exact_filter(filter)
+              when 'options_filter'
+                translate_options_filter(filter)
+              else
+                filter
+              end
+            end
+
+            private
+
+            # v2 exact_filter {query/value, key} → GraphQL is_filter (whole-value equality).
+            # For a register/page field there is NO `exact_filter` operation — `is_filter` is the
+            # exact one: it matches the field's `.exact` keyword subfield (backend
+            # NewEp::Es::Filters::Pages::IsFilter → ExactFilter on `membranes.<type>.exact`),
+            # whereas match_filter/contains_filter hit the analyzed `.value` and miss exact SKUs.
+            # Requires `path` (membranes.<type>) — derived from the key prefix when not given.
+            # CAVEAT: case-insensitive and only the first 64 chars are significant (values are
+            # lowercased + truncated at index time). No case-sensitive/>64-char exact exists.
+            def translate_exact_filter(filter)
+              key   = filter['key']   || filter[:key]
+              path  = filter['path']  || filter[:path] || membrane_path_for(key)
+              value = filter['value'] || filter[:value] || filter['query'] || filter[:query]
+              { operation: 'is_filter', params: { key: key, path: path, value: value }.compact }
+            end
+
+            # Derive the ES nested path from a field key: `plain_text.zXXXX` → `membranes.plain_text`.
+            def membrane_path_for(key)
+              prefix = key.to_s.split('.').first
+              prefix.empty? ? nil : "membranes.#{prefix}"
+            end
+
+            # v2 text_filter {query, key} → GraphQL match_filter (partial/full-text on key).
+            def translate_text_filter(filter)
+              {
+                operation: 'match_filter',
+                params:    {
+                  key:   filter['key'] || filter[:key],
+                  value: filter['query'] || filter[:query] || filter['value'] || filter[:value]
+                }
+              }
+            end
+
+            # v2 options_filter {chosen, key, mode} → one_of_filter (match any chosen) or
+            # none_of_filter (exclude) — both take {key, values}.
+            def translate_options_filter(filter)
+              mode = (filter['mode'] || filter[:mode]).to_s.downcase
+              op   = %w[none exclude not not_in].include?(mode) ? 'none_of_filter' : 'one_of_filter'
+              {
+                operation: op,
+                params:    {
+                  key:    filter['key'] || filter[:key],
+                  values: Array(filter['chosen'] || filter[:chosen])
+                }
+              }
+            end
+
+            def translate_date_filter(filter)
+              key = filter['key'] || filter[:key]
+              {
+                operation: 'date_filter',
+                params:    {
+                  key:       key,
+                  time_zone: filter['time_zone'] || filter[:time_zone] || 'UTC'
+                }.tap do |params|
+                  lbound = filter['lbound'] || filter[:lbound]
+                  ubound = filter['ubound'] || filter[:ubound]
+                  params[:gte] = lbound if lbound
+                  params[:lte] = ubound if ubound
+                end
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/graphql/compat/page_reference.rb

@@ -0,0 +1,23 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Compat
+        # Returned by Compat::Pages#create — mirrors the v2 reference object.
+        # Scripts access .page_id and .active_stage_id after page creation.
+        class PageReference
+          attr_reader :page_id, :active_stage_id, :page
+
+          def initialize(page)
+            @page            = page
+            @page_id         = page.id
+            @active_stage_id = page.respond_to?(:current_stage_id) ? page.current_stage_id : nil
+          end
+
+          def success?
+            !@page_id.nil?
+          end
+        end
+      end
+    end
+  end
+end