public static MessageResult RemoveMultipleFromBatch(IUnitOfWork db,
                                                            ILogService log,
                                                            ISystemActionService systemAction,
                                                            IOrderHistoryService orderHistoryService,
                                                            IBatchManager batchManager,
                                                            long batchId,
                                                            string orderIds,
                                                            long?toBatchId,
                                                            bool?removeOnHold)
        {
            var           by         = AccessManager.UserId;
            var           wasChanged = false;
            var           hasClosed  = false;
            var           fromBatch  = db.OrderBatches.GetAsDto(batchId);
            OrderBatchDTO toBatch    = null;

            if (toBatchId.HasValue)
            {
                toBatch = db.OrderBatches.GetAsDto(toBatchId.Value);
            }

            if (fromBatch.IsClosed || (toBatch != null && toBatch.IsClosed))
            {
                if (!AccessManager.CanEditSystemInfo() && !AccessManager.IsAdmin)
                {
                    hasClosed = true;
                }
            }
            if (fromBatch.IsLocked || (toBatch != null && toBatch.IsLocked))
            {
                if (!AccessManager.IsAdmin)
                {
                    return(MessageResult.Error("Source or distination batch was locked"));
                }
            }

            var orders = db.Orders.GetFiltered(o => o.BatchId == batchId);

            if (!string.IsNullOrEmpty(orderIds) && !removeOnHold.HasValue)
            {
                var stringOrderIdList = orderIds.Split(", ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
                var orderIdList       = stringOrderIdList.Select(long.Parse).ToList();
                foreach (var orderId in orderIdList)
                {
                    var order = orders.FirstOrDefault(o => o.Id == orderId);
                    if (order != null)
                    {
                        if (!hasClosed || batchManager.CanBeRemovedFromBatch(order) || AccessManager.IsAdmin)
                        {
                            order.BatchId = toBatchId;

                            batchManager.CheckRemovedOrder(db, log, systemAction, order, toBatchId, by);

                            orderHistoryService.AddRecord(order.Id, OrderHistoryHelper.AddToBatchKey, fromBatch.Id, fromBatch.Name, toBatch?.Id, toBatch?.Name, by);

                            wasChanged = true;
                        }
                    }
                }
            }
            else if (removeOnHold.HasValue && removeOnHold.Value)
            {
                var onHoldOrders = orders.Where(o => o.OnHold).ToList();
                foreach (var order in onHoldOrders)
                {
                    if (!hasClosed || batchManager.CanBeRemovedFromBatch(order))
                    {
                        order.BatchId = toBatchId;

                        batchManager.CheckRemovedOrder(db, log, systemAction, order, toBatchId, by);

                        orderHistoryService.AddRecord(order.Id, OrderHistoryHelper.AddToBatchKey, fromBatch.Id, fromBatch.Name, toBatch?.Id, toBatch?.Name, by);

                        wasChanged = true;
                    }
                }
            }

            db.Commit();

            if (!wasChanged && hasClosed)
            {
                return(MessageResult.Error("Source or distination batch was closed"));
            }
            if (!wasChanged)
            {
                return(MessageResult.Error("Order list is empty"));
            }
            return(MessageResult.Success());
        }
        public void Process(IUnitOfWork db, EmailReadingResult result)
        {
            if (result.Status == EmailMatchingResultStatus.New &&
                result.HasMatches)
            {
                var subject = result.Email.Subject ?? "";
                if (EmailHelper.IsAutoCommunicationAddress(result.Email.From) &&
                    subject.StartsWith("Your e-mail to"))
                {
                    return; //NOTE: Skip processing our emails to customer
                }

                _log.Info("AddCommentEmailRule, WasEmailProcessed=" + result.WasEmailProcessed);
                if (!result.WasEmailProcessed)
                {
                    //var orderNumber = result.MatchedIdList.FirstOrDefault();
                    var orders = db.Orders.GetAllByCustomerOrderNumbers(result.MatchedIdList);

                    var message = " > " + EmailHelper.ExtractShortSubject(result.Email.Subject);
                    message += " > " + EmailHelper.ExtractShortMessageBody(result.Email.Message, 200, true);
                    var commentText = "Customers Email" + message;
                    commentText = StringHelper.Substring(commentText, 110);

                    if (orders.Any())
                    {
                        foreach (var order in orders)
                        {
                            if ((order.OrderStatus == OrderStatusEnumEx.Unshipped ||
                                 order.OrderStatus == OrderStatusEnumEx.Pending))
                            {
                                db.OrderComments.Add(new OrderComment()
                                {
                                    OrderId       = order.Id,
                                    Message       = commentText,
                                    Type          = (int)CommentType.IncomingEmail,
                                    LinkedEmailId = result.Email.Id,
                                    CreateDate    = _time.GetAppNowTime(),
                                    UpdateDate    = _time.GetAppNowTime()
                                });

                                OrderBatchDTO batch = null;
                                if (order.BatchId.HasValue)
                                {
                                    batch = db.OrderBatches.GetAsDto(order.BatchId.Value);
                                }

                                if (batch == null || !batch.IsLocked) //Exclude set onHold to orders in locked batch
                                {
                                    order.OnHold           = true;
                                    order.OnHoldUpdateDate = _time.GetAppNowTime();
                                }

                                db.Commit();

                                _log.Info("Comment was added, orderId=" + order.AmazonIdentifier
                                          + ", customerOrderId=" + order.CustomerOrderId
                                          + ", comment=" + commentText);
                            }
                        }
                    }
                    else
                    {
                        _log.Info("No exist orders");
                        foreach (var orderNumber in result.MatchedIdList)
                        {
                            _log.Info("Action add comment was added, orderId=" + orderNumber);
                            _actionService.AddAction(db,
                                                     SystemActionType.AddComment,
                                                     orderNumber,
                                                     new AddCommentInput()
                            {
                                OrderNumber   = orderNumber,
                                Message       = message,
                                Type          = (int)CommentType.IncomingEmail,
                                LinkedEmailId = result.Email.Id,
                            },
                                                     null,
                                                     null);
                        }
                    }
                }
            }
        }