: If you don’t already have a custom module, you will need to create one. It involves setting up the module's folder structure and registration files.

Define the Event Observer

: You need to specify the event to listen to (sales_order_shipment_save_after) and the observer class that will handle the event.

Implement the Observer Class

: This class contains the logic to keep the order status as Processing.

Changing Magento Order Status to Processing After Shipment

Introduction
Understanding Magento’s Order Status Workflow
Leveraging Magento’s Event System
Ensuring Success: Testing the Observer
Advanced Considerations
Conclusion
FAQ

Introduction

Have you ever encountered the situation where Magento automatically changes the order status to Complete after a shipment is submitted, even though you'd prefer it to remain Processing? This quirk in Magento can be frustrating for store owners who have specific workflow requirements. Not to worry, there's a way around this with Magento’s event system. This blog post will guide you through the steps required to keep the order status as Processing after a shipment is created, ensuring that your business operations can continue seamlessly.

By the end of this article, you will understand how Magento handles order statuses, the event system’s role in modifying these statuses, and how you can leverage it to maintain orders in a Processing state post-shipment. This insight will be particularly valuable if you are running a store with extended post-shipment processes or additional packaging steps that do not immediately conclude the order cycle.

Understanding Magento’s Order Status Workflow

Order Statuses in Magento

Magento utilizes an intricate system for managing order statuses. When a customer places an order, it typically progresses through several predefined statuses like Pending, Processing, and Complete. These transitions are generally triggered by specific actions, such as payment authorization or shipment creation.

Why Orders Change to Complete Post-Shipment

In Magento, the status of an order automatically changes to Complete when a shipment is created. This default behavior assumes that once an item is shipped, the transaction is essentially finished. However, many businesses might have additional steps that need to be completed post-shipment, thereby requiring the order to stay in the Processing state.

Leveraging Magento’s Event System

Introduction to Events and Observers

Magento follows the observer design pattern to handle events. When a specific event occurs, it triggers any observers that are listening for that event. An observer is a custom piece of code designed to execute in response to the event.

To change the order status to Processing after shipment, we'll make use of the sales_order_shipment_save_after event.

Creating an Event Observer

In this example, the event observer will ensure the order status remains Processing when a shipment is submitted. Here’s a step-by-step guide:

Create a Module: If you don’t already have a custom module, you will need to create one. It involves setting up the module's folder structure and registration files.
Define the Event Observer: You need to specify the event to listen to (sales_order_shipment_save_after) and the observer class that will handle the event.
Implement the Observer Class: This class contains the logic to keep the order status as Processing.

// app/code/YourNamespace/YourModule/etc/events.xml
<event xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:framework:Event/etc/events.xsd">
    <event name="sales_order_shipment_save_after">
        <observer name="set_order_status_processing" instance="YourNamespace\YourModule\Observer\SetOrderStatusProcessing" />
    </event>
</event>

// app/code/YourNamespace/YourModule/Observer/SetOrderStatusProcessing.php
namespace YourNamespace\YourModule\Observer;

use Magento\Framework\Event\Observer;
use Magento\Framework\Event\ObserverInterface;
use Magento\Sales\Model\Order;

class SetOrderStatusProcessing implements ObserverInterface
{
    public function execute(Observer $observer)
    {
        $shipment = $observer->getEvent()->getShipment();
        $order = $shipment->getOrder();

        // Only change status if order is in specific conditions
        if ($order->getStatus() == Order::STATE_COMPLETE) {
            $order->setState(Order::STATE_PROCESSING)->setStatus(Order::STATE_PROCESSING);
            $order->save();
        }
    }
}

Ensuring Success: Testing the Observer

After setting up your module and observer, it is crucial to test and ensure the code operates as expected. This testing involves creating orders, submitting shipments, and confirming that the status remains as Processing instead of switching to Complete.

Place an Order: Initiate an order using a payment method that marks it as Processing.
Submit a Shipment: From the Magento admin, create a shipment for the order.
Verify Order Status: Check the order status after shipment submission to confirm it remains Processing.

Advanced Considerations

Conditional Status Updates

Depending on your workflow, you might want to apply more conditional logic. For instance, you could adjust the order status based on different payment methods, items, or other criteria. Here’s a refined code example that introduces a custom condition:

if ($shipment->getOrder()->getPayment()->getMethod() == 'your_custom_payment_method') {
    // Custom logic for specific payment methods
}

Logging and Debugging

Adding logging to your observer can assist in debugging and provide transparency:

use Psr\Log\LoggerInterface;

class SetOrderStatusProcessing implements ObserverInterface
{
    protected $logger;

    public function __construct(LoggerInterface $logger)
    {
        $this->logger = $logger;
    }

    public function execute(Observer $observer)
    {
        $shipment = $observer->getEvent()->getShipment();
        $order = $shipment->getOrder();

        if ($order->getStatus() == Order::STATE_COMPLETE) {
            $order->setState(Order::STATE_PROCESSING)->setStatus(Order::STATE_PROCESSING);
            $order->save();
            $this->logger->info('Order status set to processing for order ID: ' . $order->getId());
        }
    }
}

Conclusion

Customizing Magento to maintain order statuses as Processing after submitting shipments can have a significant impact on your workflow efficiency and accuracy. By utilizing Magento’s robust event and observer system, you can tailor the e-commerce experience to meet your specific operational needs. This adjustment ensures that your order processing pipeline remains consistent and reflects the realities of your business processes.

FAQ

Q: Why does Magento automatically change the order status to Complete after shipment?
A: Magento's default behavior assumes that an order is complete once the shipment is created. However, this may not suit all business workflows, necessitating custom intervention.

Q: Can I apply this logic conditionally based on payment methods or other criteria?
A: Absolutely. You can refine the observer logic to apply conditions based on payment methods, specific items, or other order attributes.

Q: How do I ensure my observer is working correctly?
A: Thoroughly test by placing multiple orders, submitting shipments, and verifying that the orders retain the Processing status. Employ logging to trace the observer’s actions and debug if necessary.

Q: Is it safe to directly modify the order status from the observer?
A: Yes, it is safe if done correctly. Make sure the observer logic is sound and conditions are clearly defined to avoid unintended behavior.