AdjustInventory activity [Legacy]

using EPiServer.Commerce.Internal;
using EPiServer.Commerce.Order;
using EPiServer.Logging;
using EPiServer.ServiceLocation;
using Mediachase.Commerce.Inventory;
using Mediachase.Commerce.InventoryService;
using Mediachase.Commerce.Orders;
using Mediachase.Commerce.Orders.Managers;
using Mediachase.Commerce.WorkflowCompatibility;
using System;
using System.Collections.Generic;
using System.Linq;

namespace Mediachase.Commerce.Workflow.Activities.Cart
  {
    public class AdjustInventoryActivity : CartActivityBase
      {
        private Injected OrderRepository;

        ///
        /// Called by the workflow runtime to execute an activity.
        ///
        ///The  to associate with this  and execution.
        /// 
        /// The  of the run task, which determines whether the activity remains in the executing state, or transitions to the closed state.
        /// 
        protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
          {
            // Check for multiple warehouses. In the default, we simply reject processing an order if the application has
            //  multiple warehouses. Any corresponding fulfillment process is the responsibility of the client.
            CheckMultiWarehouse();

            // Validate the properties at runtime
            ValidateRuntime();

            // Return close status if order group is Payment Plan
            if (OrderGroup is PaymentPlan)
              {
                return ActivityExecutionStatus.Closed;
              }

            AdjustInventoryOrRemoveLineItems();

            // Retun the closed status indicating that this activity is complete.
            return ActivityExecutionStatus.Closed;
          }

        private void AdjustInventoryOrRemoveLineItems()
          {
            var orderGroup = OrderGroup as IOrderGroup;
            var validationIssues = new Dictionary<ILineItem, IList>();

            RemoveEmptyShipment(orderGroup);

            //This is needed for backward compatibility
            foreach (var lineItem in orderGroup.GetAllLineItems())
              {
                if (!InventoryTrackingEnabled(lineItem))
                  {
                    Warnings[$"InventoryNotRequested:{lineItem.Code}"] = "Inventory tracking is disabled.";
                  }
              }

            orderGroup.AdjustInventoryOrRemoveLineItems((item, issue) => AddValidationIssues(validationIssues, item, issue));

            //This is needed for backward compatibility
            foreach (var validationIssue in validationIssues)
              {
                var lineItem = validationIssue.Key;

                foreach (var issue in validationIssue.Value)
                  {
                    switch (issue)
                      {
                        case ValidationIssue.RemovedDueToInsufficientQuantityInInventory:
                            Warnings.Add($"LineItemRemoved-{lineItem.LineItemId.ToString()}", $"Item \"{lineItem.DisplayName}\" has been removed from the cart because there is not enough available quantity.");
                            break;
                        case ValidationIssue.RejectedInventoryRequestDueToInsufficientQuantity:
                            Warnings[OrderGroupWorkflowManager.RejectedInventoryDueToInsufficientQuantityWarning] = "Can not request inventory due to not enough quantity.";
                            Warnings[OrderGroupWorkflowManager.RejectedInventoryDueToInsufficientQuantityWarning + ":" + lineItem.Code] = "Can not request inventory due to not enough quantity.";
                            break;
                        default:
                            break;
                      }
                  }
              }

            RemoveEmptyShipment(orderGroup);
          }

        private void RemoveEmptyShipment(IOrderGroup orderGroup)
          {
            //Remove empty shipment
            var deletedShipments = new List();

            foreach (var shipment in orderGroup.Forms.SelectMany(form => form.Shipments))
              {
                if (!shipment.LineItems.Any())
                  {
                    deletedShipments.Add(shipment);
                  }
              }

            if (!deletedShipments.Any())
              {
                return;
              }

            foreach (var shipment in deletedShipments)
              {
                var form = orderGroup.Forms.FirstOrDefault(f => f.Shipments.Contains(shipment));
                // Keep at least one shipment in the order form.
                if (form.Shipments.Count > 1)
                  {
                    form.Shipments.Remove(shipment);

                    InventoryRequester.CancelReservedQuantityForShipment((IShipmentInventory) shipment);
                  }
              }

            OrderRepository.Service.Save(orderGroup);
          }

        private void CheckMultiWarehouse()
          {
            var warehouses = WarehouseRepository.List().Where(w => w.IsActive && w.IsFulfillmentCenter);
            if (warehouses.Count() > 1)
              {
                throw new NotSupportedException("Multiple fulfillment centers without custom fulfillment process.");
              }
          }
      } 
  }