refactor(Transaction Layer): finalize implementation of create/update ContentItem transactions, simplify concerns

Author: toastercup

app/controllers/cortex/content_items_controller.rb

@@ -36,7 +36,7 @@ def edit
 
     def update
       begin
-        content_item.update
+        update_content_item
       rescue ActiveRecord::RecordInvalid => e
         flash[:warning] = validation_message(e.message)
         @content_item = content_item_reload(content_type.content_items.find_by_id(params[:id]))

app/helpers/cortex/content_item_helper.rb

@@ -4,10 +4,6 @@ def content_type
       @content_type ||= Cortex::ContentType.find_by_id(params[:content_type_id])
     end
 
-    def content_item
-      @content_item ||= Cortex::ContentItemService.new(id: params[:id], content_item_params: content_item_params, current_user: current_user, state: params[:content_item][:state])
-    end
-
     def create_content_item
       CreateContentItemTransaction.new
         .with_step_args(
@@ -18,6 +14,16 @@ def create_content_item
         .value!
     end
 
+    def update_content_item
+      UpdateContentItemTransaction.new
+        .with_step_args(
+          execute_content_item_state_change: [state: params[:content_item][:state]]
+        )
+        .call(id: params[:id], content_type: content_type,
+              content_item_params: content_item_params, current_user: current_user)
+        .value!
+    end
+
     def content_item_reload(content_item)
       @content_item = content_item
       content_type.fields.each do |field|

app/operations/cortex/execute_content_item_state_change_operation.rb

@@ -3,10 +3,13 @@
 module Cortex
   class ExecuteContentItemStateChangeOperation
     include Dry::Transaction::Operation
-    include Cortex::ContentItemable
 
     def call(input, state:)
-      execute_state_change(input, state)
+      if state && input.can_transition?(state)
+        state_method = "#{state}!"
+        input.send(state_method)
+      end
+
       Success(input)
     end
   end

app/operations/cortex/parse_content_item_field_items_operation.rb

@@ -3,11 +3,16 @@
 module Cortex
   class ParseContentItemFieldItemsOperation
     include Dry::Transaction::Operation
-    include Cortex::ContentItemable
+    include Cortex::WidgetParsable
 
     def call(input)
-      content_item = parse_field_items!(input)
-      Success(content_item)
+      input.field_items.each do |field_item|
+        if field_item.field.metadata && field_item.field.metadata['parse_widgets']
+          parse_widgets!(field_item)
+        end
+      end
+
+      Success(input)
     end
   end
 end

app/transactions/concerns/cortex/content_itemable.rb

@@ -3,41 +3,13 @@ module ContentItemable
     extend ActiveSupport::Concern
 
     included do
-      include Cortex::WidgetParsable
-
-      def parse_field_items!(content_item)
-        content_item.field_items.each do |field_item|
-          if field_item.field.metadata && field_item.field.metadata['parse_widgets']
-            parse_widgets!(field_item)
-          end
-        end
-        content_item
-      end
-
       def field_items_attributes(content_item_params)
         content_item_params['field_items_attributes']
       end
 
-      def content_item_attributes(content_item_params, creator, content_type, field_items, current_user)
-        attributes = content_item_params || { creator: creator, content_type: content_type, field_items: field_items }
-        attributes.merge! latest_history_patch(current_user)
-      end
-
-      def latest_history_patch(current_user)
-        history_patch = {}
-        history_patch.merge! last_updated_by(current_user)
-      end
-
       def last_updated_by(current_user)
         { updated_by: current_user }
       end
-
-      def execute_state_change(content_item, state)
-        if state && content_item.can_transition?(state)
-          state_method = "#{state}!"
-          content_item.send(state_method)
-        end
-      end
     end
   end
 end

app/transactions/cortex/update_content_item_transaction.rb

@@ -0,0 +1,45 @@
+module Cortex
+  class UpdateContentItemTransaction < Cortex::ApplicationTransaction
+    include Dry::Transaction(container: Cortex::TransactionContainer)
+    include Cortex::ContentItemable
+
+    around :database_transact, with: "cortex.database_transact"
+    step :init
+    step :process
+    step :latest_history_patch
+    step :parse_content_item_field_items, with: "cortex.parse_content_item_field_items"
+    step :persist_content_item, with: "cortex.persist_content_item"
+    step :execute_content_item_state_change, with: "cortex.execute_content_item_state_change"
+
+    def init(input)
+      Success(ContentItemTransactionType.new(input))
+    end
+
+    def process(input)
+      if input.content_item
+        content_item = input.content_item
+      else
+        content_item = ContentItem.find(input.id)
+        field_items_attributes(input.content_item_params).each do |_key, field_item_attributes|
+          content_item.field_items << UpdateFieldItemTransaction.new.call(field_item_attributes).value!
+        end
+
+        input.content_item_params.delete('field_items_attributes')
+        content_item.assign_attributes(input.content_item_params)
+      end
+
+      Success({
+                content_item: content_item,
+                current_user: input.current_user
+              })
+    end
+
+    def latest_history_patch(input)
+      history_patch = {}
+      history_patch.merge! last_updated_by(input[:current_user])
+
+      input[:content_item].assign_attributes(history_patch)
+      Success(input[:content_item])
+    end
+  end
+end