public string UpdateOrderStatus(UpdateOrderStatus updateOrderStatus)
{
var listOrders = this.ListOrderByWasher(updateOrderStatus.WasherId);
var order = listOrders.FirstOrDefault(c => c.OrderId == updateOrderStatus.OrderId);
if (order == null)
{
return("Pedido não existe.");
}
if (order.Status != 1)
{
return("Este pedido não pode assumir esse status.");
}
using (MySqlConnection con = new MySqlConnection(conString))
{
var sql = String.Format(@"Update Ordered
Set Status = {0}
Where Id = {1}", updateOrderStatus.Status, updateOrderStatus.OrderId);
con.Execute(sql);
return("");
}
}
/// <summary>
/// Grids the update order status.
/// </summary>
/// <param name="request">The request.</param>
/// <returns></returns>
public async Task <int> Grid_UpdateOrderStatus(UpdateOrderStatus request)
{
try
{
SqlParameter[] parameters =
{
new SqlParameter("@OrderID", SqlDbType.Int),
new SqlParameter("@OrderNumber", SqlDbType.NVarChar),
new SqlParameter("@Orderstatus", SqlDbType.NVarChar),
new SqlParameter("@error_reason", SqlDbType.NVarChar),
};
parameters[0].Value = request.OrderID;
parameters[1].Value = request.OrderNumber;
parameters[2].Value = request.Orderstatus;
parameters[3].Value = request.error_reason;
_DataHelper = new DataAccessHelper("Grid_UpdateOrderStatus", parameters, _configuration);
DataTable dt = new DataTable();
return(await _DataHelper.RunAsync());
}
catch (Exception ex)
{
LogInfo.Error(new ExceptionHelper().GetLogString(ex, ErrorLevel.Critical));
throw;
}
finally
{
_DataHelper.Dispose();
}
}
public async Task ChangeStatus(UpdateOrderStatus model, int corpClientId)
{
var entity = await context.Orders.FirstOrDefaultAsync(o => o.Customer.CorpClientId == corpClientId && o.OrderNumber == model.OrderNumber);
entity.OrderStatusId = model.OrderStatusId;
context.Orders.Update(entity);
var rows = await context.SaveChangesAsync();
}
public ActionResult UpdateStatus(int id, UpdateOrderStatus model)
{
if (ModelState.IsValid)
{
int currentStaffId = ((Staff)Session["Staff"]).Id;
var order = db.Orders.Where(q => q.Id == id).FirstOrDefault();
if (order == null)
{
return(NotFound());
}
else if ((order.StaffId != null && order.StaffId != currentStaffId) ||
model.Status == App.Models.Order.PROCESSING ||
model.Status == App.Models.Order.WANT_TO_CANCEL ||
order.Status == App.Models.Order.RECEIVED ||
order.Status == App.Models.Order.CANCELED)
{
return(BadRequest());
}
order.StaffId = currentStaffId;
order.Message = order.Message ?? model.Message;
order.Status = model.Status;
db.Entry(order).State = EntityState.Modified;
db.SaveChanges();
EmailHandler.Handle(order, order.Customer.Email, "Detail about order " + order.Code, "Areas/Admin/Views/Orders/Template/OrderTemplate.cshtml");
// Transfer money back if status is canceled
if (order.Status == App.Models.Order.CANCELED)
{
var customer = db.Customers.Where(q => q.Id == order.CustomerId).First();
PaymentService.SendPayout("Order is canceled", new List <PayoutItem>()
{
new PayoutItem()
{
recipient_type = (customer.CreditCard != null ? PayoutRecipientType.PAYPAL_ID : PayoutRecipientType.EMAIL),
amount = new Currency
{
value = order.GrandTotal.ToString(),
currency = "USD"
},
receiver = customer.CreditCard ?? customer.Email,
note = "Money of order #" + order.Code + " is sent back",
sender_item_id = "payout_" + order.Id,
}
});
}
return(Success(new {
Id = order.Id,
Status = order.Status,
StaffName = order.Staff.Name
}));
}
return(BadRequest());
}
public async Task <object> Any(UpdateOrderStatus cmd)
{
var order = await EventStore.GetByIdAsync <PurchaseOrder>(cmd.OrderId)
.ConfigureAwait(false);
order.UpdateStatus(cmd.NewStatus);
await EventStore.SaveAsync(order).ConfigureAwait(false);
return(Task.FromResult(true));
}
public async Task <ResponseStatus> UpdateOrderStatus(UpdateOrderStatus order, dynamic customFields = null, bool returnScore = false)
{
JObject json = JObject.Parse(JsonConvert.SerializeObject(order, Formatting.None, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
}));
json.Add("$api_key", _apiKey);
json.Add("$type", "$order_status");
AddCustomFields(customFields, json);
return(await PostEvent(json.ToString(), returnScore).ConfigureAwait(false));
}
public ActionResult UpdateOrderStatus([FromBody] UpdateOrderStatus model)
{
try
{
if (model.OrderId == null || model.Status == null)
{
return(BadRequest());
}
var order = _orderService.GetOrder(model.OrderId);
order.Status = model.Status.ToLower();
_orderService.UpdateOrder(order);
_orderService.Save();
return(Ok(201));
}
catch (Exception)
{
return(BadRequest());
}
}
public static void Test()
{
UpdateOrderStatus obj = new UpdateOrderStatus
{
Action = 1,
Value = new ValueInfo
{
Shipment = new ShipmentInfo
{
Header = "Shipment header",
Body = "Shipment body"
}
}
};
XmlSerializer xs = new XmlSerializer(typeof(UpdateOrderStatus));
MemoryStream ms = new MemoryStream();
xs.Serialize(ms, obj);
Console.WriteLine(Encoding.UTF8.GetString(ms.ToArray()));
}
public bool UpdateOrderStatus([FromBody] UpdateOrderStatus model)
{
try
{
Payment payment = _context.Payment.Where(m => m.Lite_Merchant_Trace == model.OrderNumber).FirstOrDefault();
if (payment != null)
{
if (model.OrderStatus == "C")
{
//Send Mail
var pAddress = _context.PaymentAddress.Where(m => m.Lite_Merchant_Trace == model.OrderNumber).FirstOrDefault();
var pPayment = _context.Payment.Where(m => m.Lite_Merchant_Trace == model.OrderNumber).FirstOrDefault();
string email = _context.EmailTemplates.Where(m => m.TemplateType == "Route").Select(s => s.Template).FirstOrDefault();
email = email.Replace("{{name}}", pAddress.recipientName);
email = email.Replace("{{order}}", model.OrderNumber.ToString());
MailService mailService = new MailService("mail.eazibiz.co.za", "eazibkpl", "3Wnk7usY", "*****@*****.**", pPayment.UserID, email, "Schoolmall.co.za confirm ");
Thread mgrThread = new Thread(new ThreadStart(mailService.SendMail));
mgrThread.Start();
}
payment.OrderStatus = model.OrderStatus;
payment.UpdatedBy = model.UpdatedBy;
payment.UpdatedDate = model.UpdatedDate;
_context.Payment.Update(payment);
_context.SaveChanges();
return(true);
}
else
{
return(false);
}
}
catch (Exception ex)
{
var err = ex.InnerException;
return(false);
}
}
public async Task ChangeStatus(UpdateOrderStatus model, int corpClientId)
{
await orderApp.ChangeStatus(model, corpClientId);
await orderItemApp.UpdateAllOrderItemStatus(model.OrderNumber, OrderItemStatusEnum.Cancelado, corpClientId);
}
public string UpdateOrderStatus(UpdateOrderStatus updateOrderStatus)
{
return(this._orderedRepository.UpdateOrderStatus(updateOrderStatus));
}
public async Task <IActionResult> UpdateOrderStatus([FromHeader(Name = "Grid-Service-Header-Token")] string token, [FromForm] UpdateOrderStatus request)
{
try
{
if (string.IsNullOrEmpty(token))
{
return(Ok(new OperationResponse
{
HasSucceeded = false,
IsDomainValidationErrors = true,
Message = EnumExtensions.GetDescription(CommonErrors.TokenEmpty)
}));
}
if (!ModelState.IsValid)
{
return(StatusCode((int)HttpStatusCode.OK, new OperationResponse
{
HasSucceeded = false,
IsDomainValidationErrors = true,
Message = string.Join("; ", ModelState.Values
.SelectMany(x => x.Errors)
.Select(x => x.ErrorMessage))
}));
}
if (!ValidateGridHeaderToken(token))
{
return(Ok(new OperationResponse
{
HasSucceeded = false,
Message = EnumExtensions.GetDescription(DbReturnValue.TokenAuthFailed),
IsDomainValidationErrors = true
}));
}
var result = await _dataAccess.Grid_UpdateOrderStatus(request);
if (result == Enum.ReturnSuccess)
{
return(Ok(new OperationResponse
{
HasSucceeded = true,
Message = "Success",
IsDomainValidationErrors = false
}));
}
else
{
return(Ok(new OperationResponse
{
HasSucceeded = false,
Message = "Failure",
IsDomainValidationErrors = false
}));
}
}
catch (Exception ex)
{
LogInfo.Error(new ExceptionHelper().GetLogString(ex, ErrorLevel.Critical));
return(Ok(new OperationResponse
{
HasSucceeded = false,
Message = StatusMessages.ServerError,
IsDomainValidationErrors = false
}));
}
}
public string UpdateOrderStatus(UpdateOrderStatus updateOrderStatus)
{
return(this._orderedService.UpdateOrderStatus(updateOrderStatus));
}
public async Task ChangeStatus(UpdateOrderStatus model, int corpClientId)
{
await repository.ChangeStatus(model, corpClientId);
}
