public ActionResult CancelOrder(ManualOrderModel manualorder)
{
try
{
CancelOrderModel model = new CancelOrderModel {
ErrorMessage = string.Empty, OrderStatus = string.Empty, TIABOrderID = manualorder.TIABOrderID, VerserOrderID = manualorder.VerserOrderID
};
var returnModel = Helper.Helper.CancelOrder(model);
if (returnModel != null && returnModel.First().ErrorMessage != null)
{
TempData["ManualOrder"] = $"{manualorder.VerserOrderID} Order Successfully Cancelled !";
TempData["TabOrder"] = "CORDER";
return(RedirectToAction("Index"));
}
else
{
TempData["OrderError"] = "Error has occurred while processing the request.";
TempData["TabOrder"] = "CORDER";
return(RedirectToAction("Index"));
}
}
catch (Exception)
{
TempData["TabOrder"] = "CORDER";
return(RedirectToAction("index", "ManualOrder"));
}
}
public ActionResult ApproveOnOrder(string VerserOrderID)
{
try
{
CancelOrderModel model = new CancelOrderModel {
ErrorMessage = string.Empty, OrderStatus = string.Empty, TIABOrderID = string.Empty, VerserOrderID = VerserOrderID
};
var returnModel = Helper.Helper.UpdateOnOrder(model);
if (returnModel != null && returnModel.First().ErrorMessage != null)
{
TempData["ManualOrder"] = $"{VerserOrderID} Order Status Successfully Approved";
TempData["TabOrder"] = "ONORDER";
return(RedirectToAction("Index"));
}
else
{
TempData["OrderError"] = "Error has occurred while processing the request.";
TempData["TabOrder"] = "ONORDER";
return(RedirectToAction("Index"));
}
}
catch (Exception)
{
TempData["TabOrder"] = "ONORDER";
return(RedirectToAction("index", "ManualOrder"));
}
}
public async Task <ActionResult <ApiResponse <int> > > CancelOrder(CancelOrderModel form)
{
try
{
var cancel = await _context.Ecom_Orders.Where(x => x.Order_ID == form.Order_ID).FirstOrDefaultAsync();
if (cancel != null)
{
cancel.OrderStatus = 6;
cancel.CancelReason = form.Reason;
_context.Update(cancel);
await _context.SaveChangesAsync();
}
else
{
_context.Ecom_Orders.Add(cancel);
await _context.SaveChangesAsync();
}
return(new ApiResponse <int> {
code = 1, data = cancel.Order_ID, message = "Success"
});
}
catch (Exception ex)
{
return(new ApiResponse <int> {
code = 0, data = 0
});
}
}
/// <summary>
/// 取消配送单接口
/// </summary>
/// <param name="accessTokenOrAppId">AccessToken或AppId（推荐使用AppId，需要先注册）</param>
/// <param name="data">请求数据</param>
/// <param name="timeOut">代理请求超时时间（毫秒）</param>
/// <returns></returns>
public static CancelOrderJsonResult CancelOrder(string accessTokenOrAppId, CancelOrderModel data, int timeOut = Config.TIME_OUT)
{
return(WxOpenApiHandlerWapper.TryCommonApi(accessToken =>
{
var urlFormat = Config.ApiMpHost + "/cgi-bin/express/local/business/order/cancel?access_token={0}";
return CommonJsonSend.Send <CancelOrderJsonResult>(accessToken, urlFormat, data, timeOut: timeOut);
}, accessTokenOrAppId));
}
public CancelOrderModel Transform()
{
var m = new CancelOrderModel();
m.OrdersCanceled = CancelOrderInfo.Count;
m.OrdersPending = CancelOrderInfo.Pending;
return(m);
}
public CancelOrderModel Transform()
{
var m = new CancelOrderModel();
m.OrdersCanceled = 1;
m.OrderId = this.Id;
return(m);
}
public async Task <BaseResponse <object> > CancelOrder(CancelOrderModel model)
{
var request = new RestRequest("cancelOrder", Method.POST);
request.AddJsonBody(model);
return(await base.Execute <BaseResponse <object> >(request));
}
internal static CancelOrderModel ConvertToCancelOrderModel(CancelOrderBtceResponseModel cancelOrderBtceResponseModel)
{
if (!cancelOrderBtceResponseModel.Success)
{
return(new CancelOrderModel()
{
Success = false,
ErrorMessage = cancelOrderBtceResponseModel.Error
});
}
var cancelOrderModel = new CancelOrderModel()
{
Success = true,
OrderId = cancelOrderBtceResponseModel.Return.Order_id,
FundInfo = cancelOrderBtceResponseModel.Return.Funds
};
return(cancelOrderModel);
}
public static void Run([ServiceBusTrigger("ChargeAmount", "chargeamountsubscription",
Connection = "ServiceBusConnection")] Message message, ILogger log)
{
var order = JsonConvert.DeserializeObject <OrderModel>(Encoding.UTF8.GetString(message.Body));
var customerAccount = PaymentRepository.customerAccountModels.FirstOrDefault(c => c.CustomerId == order.CustomerId);
var orderValue = order.Price * order.Quantity;
if (orderValue <= customerAccount.MaximumOrderLimit)
{
log.LogInformation("Payment successful");
}
else
{
var messageBody = new CancelOrderModel();
messageBody.TrackingId = order.TrackingId;
messageBody.Message = "Order cannot be process as it exceeded the maximum order set for customer";
var cancelOrderMessage = new Message(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(messageBody)));
// Send the message to the topic and assume it will be successfull - eventual consistency
cancelOrderTopicClient.SendAsync(cancelOrderMessage).GetAwaiter().GetResult();
}
}
public static void Run([ServiceBusTrigger("CreateOrder",
"CreateOrderSubscription",
Connection = "ServiceBusConnection")] Message message,
ILogger log)
{
var checkOutProcessModel = JsonConvert.DeserializeObject <CheckOutProcessModel>(Encoding.UTF8.GetString(message.Body));
var order = new OrderModel()
{
TrackingId = checkOutProcessModel.TrackingId,
CustomerId = checkOutProcessModel.CustomerId,
Price = checkOutProcessModel.Price,
Quantity = checkOutProcessModel.Quantity,
ProductId = checkOutProcessModel.ProductId
};
OrdersRepository.Orders.Add(order);
// Order service allows orders only with quantity less than 10
if (checkOutProcessModel.Quantity < 10)
{
log.LogInformation($"Order Processed");
order.OrderId = Guid.NewGuid();
OrdersRepository.ConfirmedOrders.Add(order);
chargeAmountTopicClient.SendAsync(new Message(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(order))))
.GetAwaiter().GetResult();
}
else
{
log.LogInformation($"Order cannot be processed");
var messageBody = new CancelOrderModel();
messageBody.TrackingId = checkOutProcessModel.TrackingId;
messageBody.Message = "Order cannot be process as it exceeded maximum quantity of 10";
var cancelOrderMessage = new Message(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(messageBody)));
// Send the message to the topic and assume it will be successfull - eventual consistency
cancelOrderTopicClient.SendAsync(cancelOrderMessage).GetAwaiter().GetResult();
}
}
public ActionResult CancelOrder(CancelOrderModel model)
{
if (ModelState.IsValid)
{
string sql = "Exec [SP_UPDATE_STATUS_HUY_PHIEU_DAT] '" + model.maPhieuDat + "','" + model.maHuy + "'";
DataTable lstroom = DataUtil.ExecSqlDataTable(sql, DataUtil.connstr);
var a = lstroom.Rows[0][0];
if (a.ToString() == "0")
{
TempData["HomeIndexError"] = HomeIndexError.CancelRoomIsFail;
return(View());
}
else
{
TempData["HomeIndexError"] = HomeIndexError.CancelRoomIsOk;
return(RedirectToAction("Index"));
}
}
else
{
return(View());
}
}
public static List <CancelOrderModel> UpdateOnOrder(CancelOrderModel order)
{
var response = string.Empty;
List <CancelOrderModel> theList = new List <CancelOrderModel>();
theList.Add(order);
string CancelOrderURi = System.Configuration.ConfigurationManager.AppSettings["rooturi"] + System.Configuration.ConfigurationManager.AppSettings["UpdateToOnOrder"];
string token = System.Web.HttpContext.Current.Session["BearerToken"].ToString();
try
{
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
var resp = client.PostAsJsonAsync(CancelOrderURi, theList);
resp.Wait(TimeSpan.FromSeconds(10));
if (resp.IsCompleted)
{
if (resp.Result.StatusCode == HttpStatusCode.Unauthorized)
{
Console.WriteLine("Authorization failed. Token expired or invalid.");
}
else
{
response = resp.Result.Content.ReadAsStringAsync().Result;
theList = JsonConvert.DeserializeObject <List <CancelOrderModel> >(response);
}
}
}
}
catch (Exception ex)
{
response = ex.Message;
}
return(theList);
}
/// <summary>
/// 取消配送单接口
/// </summary>
/// <param name="accessTokenOrAppId">AccessToken或AppId（推荐使用AppId，需要先注册）</param>
/// <param name="data">请求数据</param>
/// <param name="timeOut">代理请求超时时间（毫秒）</param>
/// <returns></returns>
public static async Task <CancelOrderJsonResult> CancelOrderAsync(string accessTokenOrAppId, CancelOrderModel data, int timeOut = Config.TIME_OUT)
{
return(await WxOpenApiHandlerWapper.TryCommonApiAsync(async accessToken =>
{
var urlFormat = Config.ApiMpHost + "/cgi-bin/express/local/business/order/cancel?access_token={0}";
return await CommonJsonSend.SendAsync <CancelOrderJsonResult>(accessToken, urlFormat, data, timeOut: timeOut);
}, accessTokenOrAppId).ConfigureAwait(false));
}
public async Task <ActionResult> CancelOrders(CancelOrderModel model)
{
using (var transaction = await context.Database.BeginTransactionAsync(System.Data.IsolationLevel.Serializable))
{
var orders = await context.Orders
.Include(x => x.ProductPositions)
.Include(x => x.BathPlacePositions)
.Where(x => model.OrderIds.Contains(x.Id))
.ToListAsync();
var newOrders = new List <Order>();
orders.ForEach(x => {
x.Canceled = true;
x.Commentary += model.Reason + $" (заказ №{x.Id})";
var notFree = x.BathPlacePositions
.Where(pos => !model.BathIds.Any(bathId => bathId == pos.BathPlaceId)).ToList();
if (notFree.Count > 0 || x.ProductPositions.Count() > 0)
{
newOrders.Add(new Order
{
Commentary = $"новая копия заказа {x.Id} ",
Room = x.Room,
Type = x.Type,
TotalCost = notFree.Sum(pos => pos.Cost) + x.ProductPositions.Sum(pos => pos.TotalPrice),
ProductPositions = x.ProductPositions
.Select(pos => new ProductPosition
{
Count = pos.Count,
ProductId = pos.ProductId,
ProductPrice = pos.ProductPrice,
TotalPrice = pos.TotalPrice,
}).ToList(),
BathPlacePositions = notFree
.Select(pos => new BathPlacePosition
{
Price = pos.Price,
DiscountName = pos.DiscountName,
DiscountValue = pos.DiscountValue,
Status = pos.Status,
BathPlaceId = pos.BathPlaceId,
Begin = pos.Begin,
Duration = pos.Duration,
End = pos.End,
Cost = pos.Cost,
}).ToList(),
Modified = x.Modified
});
}
foreach (var p in x.BathPlacePositions)
{
p.Status = BathPlaceStatus.Free;
context.Entry(p).State = EntityState.Modified;
}
context.Entry(x).State = EntityState.Modified;
});
await context.Orders.AddRangeAsync(newOrders);
await context.SaveChangesAsync();
transaction.Commit();
await NotrifyAll(model.Room == RoomType.Men? "men" : "women");
return(Ok());
}
}