eco-helpers 3.2.1 → 3.2.3

data/lib/eco/api/usecases/graphql/helpers/location/command/end_points/optimizations.rb

@@ -0,0 +1,64 @@
+module Eco::API::UseCases::GraphQL::Helpers::Location
+  module Command::EndPoints
+    module Optimizations
+      DEFAULT_COMMANDS_PER_PAGE = 45
+
+      # Available options are:
+      #   - :per_request -> on each request
+      #   - :per_batch   -> at the end of each batch / stage (on last page)
+      #   - :once        -> only when the script starts to run
+      # @return [Symbol] the default tree tracking mode
+      def default_tree_tracking_mode
+        :per_request # :per_batch @todo per batch/stage is more plausible
+      end
+
+      # Helper to identify the commands payload block
+      # @note
+      #   1. Gives flexibility on at what time the structure should be retrieved
+      #   2. This increases performacne, as we don't retrieve the full tree on
+      #     each request unless necessary/specified
+      #   3. `nil` falls the block back to the `ecoportal-api-graphql` gem, which
+      #     has a default block that retrieves the structure
+      # @return [Proc, NilClass] the payload block
+      def scope_commands_block(track_tree_mode: default_tree_tracking_mode)
+        case track_tree_mode
+        when :per_request
+          nil
+        when :once, :per_batch
+          commands_payload_without_structure_block
+        end
+      end
+
+      # Prevents each request from timing out
+      def commands_per_page
+        if self.class.const_defined?(:COMMANDS_PER_PAGE)
+          self.class::COMMANDS_PER_PAGE
+        else
+          DEFAULT_COMMANDS_PER_PAGE
+        end
+      end
+
+      # Whether to stop or continue on command fail
+      def force_continue?
+        false
+      end
+
+      # Commands payload without querying Structure
+      # @note this servces the purpose of optimizing/speeding up the requests.
+      def commands_payload_without_structure_block
+        proc {
+          clientMutationId
+          ok
+          errors { # rubocop:disable Style/BlockDelimiters
+            details
+            fullMessages
+            messages
+          }
+          draft { # rubocop:disable Style/BlockDelimiters
+            ___Ecoportal__API__GraphQL__Fragment__LocationDraft
+          }
+        }
+      end
+    end
+  end
+end

data/lib/eco/api/usecases/graphql/helpers/location/command/end_points.rb

@@ -0,0 +1,96 @@
+module Eco::API::UseCases::GraphQL::Helpers::Location
+  module Command::EndPoints
+    include Eco::Language::AuxiliarLogger
+    include Eco::API::UseCases::GraphQL::Helpers::Location::Base
+
+    require_relative 'end_points/optimizations'
+
+    include Optimizations
+
+    def create_draft(
+      structure_id,
+      name:                   Time.now.iso8601,
+      notes:                  '',
+      include_archived_nodes: true
+    )
+      log(:info) { "Going to create draft (for #{structure_id})..." }
+
+      graphql.locationStructure.draft.create(
+        input:                {
+          structureId: structure_id,
+          name:        name,
+          notes:       notes
+        },
+        includeArchivedNodes: include_archived_nodes
+      ).tap do |payload|
+        unless payload.error?
+          log(:info) { "Created draft '#{payload.draft&.id}' (for #{structure_id})" }
+          next
+        end
+
+        msg = "Could not create draft for #{structure_id}:\n"
+        msg << JSON.pretty_generate(payload.error_doc)
+
+        raise StandardError, msg
+      end
+    end
+
+    def delete_draft(draft_id)
+      graphql.locationStructure.draft.delete(
+        input: {
+          id: draft_id
+        }
+      ).tap do |payload|
+        unless payload.error?
+          log(:info) { "Deleted draft #{draft_id}" }
+          next
+        end
+
+        msg = "Could not delete draft #{draft_id}:\n"
+        msg << JSON.pretty_generate(payload.error_doc)
+
+        raise StandardError, msg
+      end
+    end
+
+    def publish_draft(
+      draft_id,
+      preview:                false,
+      force:                  false,
+      include_archived_nodes: true
+    )
+      log(:info) { "Going to publish draft #{draft_id}..." }
+
+      graphql.locationStructure.draft.publish(
+        input:                {
+          id:      draft_id,
+          preview: preview,
+          force:   force
+        },
+        includeArchivedNodes: include_archived_nodes
+      ).tap do |payload|
+        unless payload.error?
+          log(:info) { "Published draft #{draft_id}" }
+          next
+        end
+
+        msg = "Could not publish draft #{draft_id}:\n"
+        msg << JSON.pretty_generate(payload.error_doc)
+
+        raise StandardError, msg
+      end
+    end
+
+    def apply_commands(
+      input,
+      final:           false,
+      track_tree_mode: nil,
+      &block
+    )
+      block ||= scope_commands_block(track_tree_mode: track_tree_mode)
+      block   = nil if final
+
+      graphql.locationStructure.draft.addCommands(input: input, &block)
+    end
+  end
+end

data/lib/eco/api/usecases/graphql/helpers/location/command/input_unit_response.rb

@@ -0,0 +1,69 @@
+module Eco::API::UseCases::GraphQL::Helpers::Location::Command
+  class InputUnitResponse
+    attr_reader :input, :response
+
+    def initialize(input, response)
+      @input    = input
+      @response = response
+    end
+
+    def draft
+      response&.draft
+    end
+
+    def structure
+      draft&.structure
+    end
+
+    def commands
+      input[:commands]
+    end
+
+    # brief summary of the error
+    def error_doc
+      if (err_doc = response&.error_doc)
+        return err_doc
+      end
+
+      conflictingIds if conflictingIds?
+    end
+
+    def error?
+      return false if response.nil?
+      return true  if conflictingIds?
+
+      response.error? # draft might have previous, but we will stop anyway!
+    end
+    alias_method :errors?, :error?
+
+    def ok?
+      !errors?
+    end
+
+    def conflictingIds? # rubocop:disable Naming/MethodName
+      conflictingIds.any?
+    end
+
+    def conflictingIds # rubocop:disable Naming/MethodName
+      draft_conflicting_ids & target_ids
+    end
+
+    private
+
+    def draft_conflicting_ids
+      return [] unless draft
+
+      draft.conflictingIds || []
+    end
+
+    def target_ids
+      return [] unless commands.is_a?(Array)
+
+      commands.map do |cmd|
+        next cmd.target_ids if cmd.respond_to?(:target_ids)
+
+        cmd.values_at(:nodeId, :newId, :id)
+      end.flatten.compact.uniq
+    end
+  end
+end

data/lib/eco/api/usecases/graphql/helpers/location/command/result.rb

@@ -7,14 +7,11 @@ module Eco::API::UseCases::GraphQL::Helpers::Location::Command
       @result = result
     end
 
-    def command
+    # @return [Symbol] the command type
+    def command_type
       input.keys.first
     end
 
-    def command_input_data
-      input[command]
-    end
-
     def node_id
       command_input_data[:nodeId]
     end
@@ -24,7 +21,7 @@ module Eco::API::UseCases::GraphQL::Helpers::Location::Command
     end
 
     def applied?
-      !pending?
+      !pending? && success?
     end
 
     def success?
@@ -47,20 +44,24 @@ module Eco::API::UseCases::GraphQL::Helpers::Location::Command
 
       feed = []
       feed.concat(error.validationErrors.map(&:message)) unless error.validationErrors.empty?
-      feed << "Command: #{command_input_data.pretty_inspect}"
+      feed << "Command: #{JSON.pretty_generate(command_input_data)}"
 
       msg  << "  * #{feed.join("\n  * ")}"
       msg.join("\n")
     end
 
-    def command_result
+    def command_result_data
       result&.command
     end
 
+    def command_input_data
+      input[command]
+    end
+
     def command_id
-      return unless result
+      return unless command_result_data
 
-      command_result['id']
+      command_result_data['id']
     end
 
     def as_json

data/lib/eco/api/usecases/graphql/helpers/location/command/results.rb

@@ -1,63 +1,133 @@
 module Eco::API::UseCases::GraphQL::Helpers::Location::Command
+  # Final ressults of the full run.
   class Results
-    attr_reader :input, :response
+    attr_accessor :draft
 
-    def initialize(input, response)
-      @input    = input
-      @response = response
+    def draft_id
+      draft&.id
     end
 
-    def stats
-      msg       = ''
-      msg << "  * Errored: #{errored.count} #{first_err_str}\n" if errored?
-      msg << "  * Applied: #{errored.count} #{last_okay_str}\n" if some_applied?
-      msg << "  * Pending: #{pending.count}\n"                  if some_pending?
-      msg
+    def parent_structure
+      draft&.parent_structure
     end
 
-    # Was this configured to force-continue on command error?
-    def force?
-      input[:force]
+    # @note target parent structure id
+    def structure_id
+      draft&.structure_id
     end
 
-    # # Offers a summary. If anything went wrong, it's `false`.
-    # # If everything went right, it's `true`.
-    # def ok?
-    #   response&.ok
-    # end
+    # @note the result of the draft
+    def structure
+      draft&.structure
+    end
 
-    # Overal errors (i.e. ID clashes between different structures)
-    def error
-      response&.error
+    # @note it receives the final `results` response (when the draft gets published)
+    def final_response(response = nil)
+      return @response if response.nil?
+
+      @response = response
+    end
+
+    def final_response?
+      !final_response.nil?
     end
 
+    # @note it only accounts for the errors of the final publishing of the draft.
     def error?
-      !!error
+      return false unless final_response
+
+      final_response.error?
     end
 
     def success?
-      !error? && results.all?(&:success?)
+      !error?
+    end
+
+    def applied_commands(with_id_change: false)
+      results.select(&:applied?).then do |applied|
+        next applied unless with_id_change
+
+        applied.select do |result|
+          next false unless (command = result.command_result_data)
+
+          command.keys.include?(:newId)
+        end
+      end
     end
 
     def results
-      @results ||= input_commands.zip(response_results).each_with_object([]) do |(i, r), results|
+      return [] unless final_response
+
+      @results ||= input_commands.zip(command_results).each_with_object([]) do |(i, r), results|
         results << Result.new(i, r)
       end
     end
 
+    # @note this captures the latest draft
+    def add_response(key, input_unit_response)
+      self[key] << input_unit_response
+      input_unit_response.tap do |iur|
+        next if final_response
+
+        self.draft = iur.draft
+      end
+    end
+
+    def[](key)
+      responses[key] ||= []
+    end
+
+    def responses
+      @responses ||= {}
+    end
+
+    def keys
+      responses.keys
+    end
+
     def count
-      results.count
+      responses.values.flatten.count
     end
 
-    def input_result(input)
-      results_by_input[input]
+    def input_commands
+      keys.each_with_object([]) do |key, commands|
+        self[key].each do |input|
+          next unless input.is_a?(InputUnitResponse)
+
+          commands.concat(input.commands)
+        end
+      end
+    end
+
+    def command_results(response = final_response)
+      response = final_response(response)
+      return [] unless response
+
+      response.results || []
+    end
+
+    def stats
+      msg       = ''
+      msg << "  * Errored: #{errored.count} #{first_err_str}\n" if errored?
+      msg << "  * Applied: #{applied.count} #{last_okay_str}\n" if some_applied?
+      msg << "  * Pending: #{pending.count}\n"                  if some_pending?
+      msg
     end
 
-    def input_idx(input)
-      results.index(input_result(input))
+    # Overal errors (i.e. ID clashes between different structures)
+    def error
+      response&.error
     end
 
-    def idx(result)
+    # def input_result(input)
+    #   results_by_input[input]
+    # end
+
+    # def input_idx(input)
+    #   results.index(input_result(input))
+    # end
+
+    def result_idx(result)
       results.index(result)
     end
 
@@ -65,24 +135,28 @@ module Eco::API::UseCases::GraphQL::Helpers::Location::Command
       @errored ||= results.select(&:error?)
     end
 
+    def applied
+      @applied ||= results.select(&:applied?)
+    end
+
+    def pending
+      @pending ||= results.select(&:pending?)
+    end
+
     def errored?
       errored.any?
     end
 
+    def applied?
+      results.all?(&:applied?)
+    end
+
     def first_errored
       errored.first
     end
 
     def first_errored_idx
-      idx(first_errored)
-    end
-
-    def applied
-      @applied ||= results.select(&:applied?)
-    end
-
-    def applied?
-      results.all?(&:applied?)
+      result_idx(first_errored)
     end
 
     def some_applied?
@@ -94,11 +168,7 @@ module Eco::API::UseCases::GraphQL::Helpers::Location::Command
     end
 
     def last_applied_idx
-      idx(last_applied)
-    end
-
-    def pending
-      @pending ||= results.select(&:pending?)
+      result_idx(last_applied)
     end
 
     def some_pending?
@@ -107,34 +177,21 @@ module Eco::API::UseCases::GraphQL::Helpers::Location::Command
 
     private
 
-    def results_by_input
-      @results_by_input ||= results.each_with_object({}) do |r, h|
-        h[r.input] = r
-      end
-    end
-
-    def input_commands
-      input[:commands]
-    end
-
-    def response_results
-      response&.results || []
-    end
+    # def results_by_input
+    #   @results_by_input ||= results.each_with_object({}) do |res, h|
+    #     h[res.input] = res
+    #   end
+    # end
 
     # First error is relevant only if request was NOT forced to continue.
     def first_err_str
-      return '' if force?
-
-      pre_str = 'stopped on node'
-      pre_str = 'first error' unless force?
+      pre_str = 'first error'
 
       "(#{pre_str}: '#{first_errored&.node_id}' - idx: #{first_errored_idx})"
     end
 
     # Last successfully applied is relevant only if request was NOT forced to continue.
     def last_okay_str
-      return '' if force?
-
       "(last node done: '#{last_applied&.node_id}' - idx: #{last_applied_idx})"
     end
   end

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

@@ -3,25 +3,10 @@ module Eco::API::UseCases::GraphQL::Helpers::Location
     include Eco::Language::AuxiliarLogger
     include Eco::API::UseCases::GraphQL::Helpers::Location::Base
 
-    require_relative 'command/optimizations'
-    include Eco::API::UseCases::GraphQL::Helpers::Location::Command::Optimizations
-
-    # Actual GraphQL request
-    def apply_commands(input, &block)
-      graphql.locationStructure.applyCommands(input: input, &block)
-    end
-
-    # With given the commands, it generates the input of the endpoint mutation.
-    # @param commands [Array<Hash>]
-    def input(commands, force_continue: force_continue?)
-      {
-        clientMutationId: '',
-        id:               target_structure_id,
-        force:            force_continue,
-        commands:         commands
-      }
-    end
+    require_relative 'command/end_points'
+    include Eco::API::UseCases::GraphQL::Helpers::Location::Command::EndPoints
 
+    # @note it does the API call.
     # @param track_tree_mode [Symbol] when should updates happen
     # @return see #with_sliced_input
     def sliced_batches(
@@ -46,17 +31,31 @@ module Eco::API::UseCases::GraphQL::Helpers::Location
         msg << "with #{count} commands (done #{done} of #{total})..."
         log(:info) { msg }
 
-        response = nil
         unless simulate? && !options.dig(:requests, :backup)
-          backup(sliced_input, type: "tree_update_#{desc}_request_#{page}_of_#{pages}")
+          backup(
+            sliced_input,
+            type: "tree_update_#{desc}_request_#{page}_of_#{pages}"
+          )
         end
 
-        if simulate?
-          log(:info) { sliced_input.pretty_inspect } if page < 3
-        else
-          curr_block = scope_commands_block(page, pages, track_tree_mode: track_tree_mode)
-          response   = apply_commands(sliced_input, &curr_block)
-          backup(response, type: "tree_update_#{desc}_response_#{page}_of_#{pages}")
+        if simulate? && page < 3
+          log(:info) {
+            JSON.pretty_generate(sliced_input)
+          }
+        end
+
+        # fetch structure? (by using default, when curr_block == nil)
+        response = apply_commands(
+          sliced_input,
+          final:           (page == pages),
+          track_tree_mode: track_tree_mode
+        )
+
+        unless simulate?
+          backup(
+            response,
+            type: "tree_update_#{desc}_response_#{page}_of_#{pages}"
+          )
         end
 
         done += count
@@ -88,6 +87,7 @@ module Eco::API::UseCases::GraphQL::Helpers::Location
 end
 
 require_relative 'command/result'
+require_relative 'command/input_unit_response'
 require_relative 'command/results'
 require_relative 'command/diff'
 require_relative 'command/diffs'