public static string GetToken(CreateOrderRequestModel requestModel, string privateKey)
{
RSAParameters rsaParams;
using (var tr = new StringReader(privateKey))
{
var pemReader = new PemReader(tr);
var keyPair = pemReader.ReadObject() as AsymmetricCipherKeyPair;
if (keyPair == null)
{
throw new Exception("Could not read RSA private key");
}
var privateRsaParams = keyPair.Private as RsaPrivateCrtKeyParameters;
rsaParams = DotNetUtilities.ToRSAParameters(privateRsaParams);
}
using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
{
rsa.ImportParameters(rsaParams);
var json = JsonConvert.SerializeObject(requestModel,
new JsonSerializerSettings()
{
NullValueHandling = NullValueHandling.Ignore
});
return(Jose.JWT.Encode(json, rsa, Jose.JwsAlgorithm.RS256));
}
}
public async Task <string> CreateOrderAsync(CreateOrderRequestModel requestModel)
{
string token = GetToken(requestModel, _settings.GetConfigSetting <string>(SettingKeys.Integration.Tiqets.PrivateKey));
try
{
var baseAddress = new Uri(_settings.GetConfigSetting <string>(SettingKeys.Integration.Tiqets.Endpoint));
string responseData;
using (var httpClient = new HttpClient {
BaseAddress = baseAddress
})
{
httpClient.Timeout = new TimeSpan(1, 0, 0);
httpClient.DefaultRequestHeaders.TryAddWithoutValidation("Authorization", _settings.GetConfigSetting <string>(SettingKeys.Integration.Tiqets.Token));
var content = new StringContent(token, Encoding.Default, "text/plain");
var response = await httpClient.PostAsync("orders?lang=en", content);
responseData = await response.Content.ReadAsStringAsync();
return(responseData);
}
}
catch (Exception e)
{
_logger.Log(LogCategory.Error, new Exception("Failed to get Tiqets time slots", e));
return(null);
}
}
public static Order MapAsNewEntity(this CreateOrderRequestModel model)
{
return(new Order
{
Total = model.Total,
Customer = model.Customer,
Products = model.Products
});
}
public async Task <ActionResult <int> > Create(CreateOrderRequestModel model)
{
var userId = this.User.GetId();
int id = await orderService.Create(model.FirstName, model.LastName, model.PhoneNumber, model.Email,
model.Address, model.City, model.Country, model.PostalCode, userId);
return(Created(nameof(Create), id));
}
protected override async Task <ICommandResult> Handle(CreateOrderCommand command)
{
CreateOrderCommandResult commandResults = new CreateOrderCommandResult();
var user = _userRepository.GetByAltId(command.UserAltId);
var eventTicketAttributeIds = command.EventTicketAttributeList.Select(s => s.Id).Distinct();
var eventTicketAttributes = AutoMapper.Mapper.Map <IEnumerable <Contracts.Models.EventTicketAttribute> >(_eventTicketAttributeRepository.GetByIds(eventTicketAttributeIds));
var allEventTicketDetails = AutoMapper.Mapper.Map <IEnumerable <Contracts.Models.EventTicketDetail> >(_eventTicketDetailRepository.GetByIds(eventTicketAttributes.Select(s => s.EventTicketDetailId))).ToList();
var tiqetEventDetail = _tiqetEventDetailMappingRepository.GetByEventDetailId(allEventTicketDetails[0].EventDetailId);
CreateOrderRequestModel requestModel = new CreateOrderRequestModel();
CustomerDetails customerDetail = new CustomerDetails();
List <Variants> variants = new List <Variants>();
foreach (var ticketAttributes in command.EventTicketAttributeList)
{
var eventTicketAttribute = eventTicketAttributes.Where(w => w.Id == ticketAttributes.Id).FirstOrDefault();
var eventTicketDetail = allEventTicketDetails.Where(w => w.Id == eventTicketAttribute.EventTicketDetailId).FirstOrDefault();;
var tiqetEventTicketDetail = _tiqetEventTicketDetailMappingRepository.GetByEventTicketDetailId(eventTicketDetail.Id);
var tiqetVariant = _tiqetVariantDetailRepository.Get(tiqetEventTicketDetail.TiqetVariantDetailId);
Variants variant = new Variants();
variant.variant_id = Convert.ToInt32(tiqetVariant.VariantId);
variant.count = ticketAttributes.TotalTickets;
variants.Add(variant);
}
var item = command.EventTicketAttributeList[0];
requestModel.product_id = Convert.ToInt32(tiqetEventDetail.ProductId);
requestModel.day = item.VisitDate.ToString("yyyy-MM-dd");
if (item.TimeSlot != null && item.TimeSlot != "")
{
requestModel.timeslot = item.TimeSlot;
}
customerDetail.email = _settings.GetConfigSetting <string>(SettingKeys.Integration.Tiqets.CustomerEmail);
customerDetail.firstname = user.FirstName;
customerDetail.lastname = user.LastName;
customerDetail.phone = _settings.GetConfigSetting <string>(SettingKeys.Integration.Tiqets.CustomerPhone);
requestModel.customer_details = customerDetail;
requestModel.variants = variants;
var responseData = await CreateOrderAsync(requestModel);
var responseJson = Mapper <CreateOrderResponseModel> .MapFromJson(responseData);
if (responseJson.success)
{
commandResults.Success = true;
commandResults.OrderRefernceId = responseJson.order_reference_id;
commandResults.PaymentToken = responseJson.payment_confirmation_token;
}
else
{
commandResults.Success = false;
commandResults.OrderRefernceId = null;
commandResults.PaymentToken = null;
}
return(commandResults);
}
public async Task <ActionResult> CreateAsync([FromBody] CreateOrderRequestModel createOrderRequestModel)
{
const string actionName = nameof(CreateAsync);
Logger.LogDebug(LoggingMessage.ProcessingRequestWithModel, actionName, createOrderRequestModel);
var response = await _orderAppService.CreateAsync(createOrderRequestModel);
Logger.LogInfomation(LoggingMessage.RequestResults, actionName);
return(Ok(response));
}
public async Task <ActionResult> Create(int id)
{
var model = await _equipmentRepository.GetEquipmentDetail(id);
var createOrderModel = new CreateOrderRequestModel()
{
EquipmentName = model.Name,
Type_id = model.Type_id,
EquipmentId = model.Id,
};
return(View(createOrderModel));
}
public async Task <IEnumerable <WeatherForecast> > Get([FromQuery] CreateOrderRequestModel requestModel)
{
await _commandBus.Send(requestModel);
var rng = new Random();
return(Enumerable.Range(1, 5).Select(index => new WeatherForecast
{
Date = DateTime.Now.AddDays(index),
TemperatureC = rng.Next(-20, 55),
Summary = Summaries[rng.Next(Summaries.Length)]
})
.ToArray());
}
public async Task <Order> AddOrder(CreateOrderRequestModel model)
{
var order = new Order()
{
UserId = model.UserId,
Create_date = DateTime.Now,
Days = model.number_of_days,
EquipmentId = model.EquipmentId,
Price = Helper.Calculate(model.number_of_days, model.Type_id)
};
await _context.AddAsync(order);
_context.SaveChanges();
return(order);
}
public async Task <ActionResult> Create(CreateOrderRequestModel model)
{
if (ModelState.IsValid)
{
var user = await _userManager.GetUserAsync(HttpContext.User);
model.UserId = user.Id;
await _orderRepository.AddOrder(model);
user.LoyaltyBalance += model.Type_id == 3 ? 2 : 1;
await _userManager.UpdateAsync(user);
return(RedirectToAction("Index", "Equipment"));
}
else
{
return(View(model));
}
}
public async Task <OrderReponseModel> CreateAsync(CreateOrderRequestModel createOrderRequestModel)
{
var actionName = nameof(CreateAsync);
createOrderRequestModel = createOrderRequestModel ?? throw new ArgumentNullException(nameof(createOrderRequestModel));
Logger.LogInfomation(LoggingMessage.ProcessingInService, actionName, seviceName, createOrderRequestModel);
var listOrder = createOrderRequestModel.OrderDetails;
var listOrderDetails = new List <Entities.OrderDetail>();
foreach (var item in listOrder)
{
listOrderDetails.Add(new Entities.OrderDetail()
{
ProductId = item.ProductId,
Quantity = item.Quantity,
Price = item.Price
});
}
var order = new Entities.Order()
{
ShipName = createOrderRequestModel.ShipName,
ShipPhoneNumber = createOrderRequestModel.ShipPhoneNumber,
ShipAddress = createOrderRequestModel.ShipAddress,
UserId = createOrderRequestModel.UserId,
OrderDate = DateTime.Now,
OrderDetails = listOrderDetails
};
var response = await _orderRepository.CreateAsync(order, true);
Logger.LogInfomation(LoggingMessage.ActionSuccessfully, actionName, seviceName, createOrderRequestModel);
return(_Mapper.Map <OrderReponseModel>(order));
}
public CreateOrderCommand(CreateOrderRequestModel createOrderRequest)
{
CreateOrderRequest = createOrderRequest;
}
public async Task <IActionResult> Post([FromBody] CreateOrderRequestModel requestModel)
{
var response = await _mediator.Send(requestModel);
return(Ok(response));
}
public async Task <IActionResult> CreateOrder([FromBody] CreateOrderRequestModel createOrderRequest)
{
var response = await _mediator.Send(new CreateOrderCommand(createOrderRequest));
return(Ok(response));
}
public async Task <CreateOrderResponseModel> CreateOrder([FromBody] CreateOrderRequestModel model)
{
var response = new CreateOrderResponseModel
{
Result = false,
};
Voucher voucher = null;
if (model.VoucherCode != null)
{
voucher =
_voucherService.GetAll()
.Where(x => x.VoucherCode == model.VoucherCode && x.IsDeleted == 0 && x.IsUsed == 0)
.FirstOrDefault();
if (voucher != null)
{
if (voucher.StartDate <= DateTime.Now && voucher.EndDate >= DateTime.Now)
{
}
else
{
voucher = null;
}
}
}
var order = new Order
{
ContactName = model.ContactName,
Email = model.Email,
Phone = model.Phone,
Address = model.Address,
PaymentMethodId = PaymentMethodEnum.PAYMENT_AT_STORE,
OrderStatusId = OrderStatusEnum.WAIT,
Discount = 0,
TotalAmount = 0,
TotalPrice = 0,
Note = model.Note,
OrderDetails = new List <OrderDetail>(),
};
if (voucher != null)
{
order.VoucherId = voucher.VoucherId;
order.Discount = (double)voucher.Price;
}
//if(model.VoucherCode != null)
//{
// var voucher = GetById from DB;
// order.Discount = voucher.Value;
//}
var currentUser = CurrentUser;
if (currentUser != null)
{
order.CustomerId = currentUser.Id;
}
ApplyUserCreateEntity(order);
double total = 0;
foreach (var detail in model.OrderDetails)
{
var product = await _productService.GetByIdWithoutInclude(detail.ProductId);
total += (double)product.Price * detail.Quantity;
var orderDetail = new OrderDetail
{
ColorId = detail.ColorId,
ProductId = detail.ProductId,
Quantity = detail.Quantity,
Price = (double)product.Price,
};
ApplyUserCreateEntity(orderDetail);
order.OrderDetails.Add(orderDetail);
}
order.TotalAmount = total;
order.TotalPrice = total - order.Discount;
order.OrderCode = DateTime.Now.ToString("yyyyMMddHHmmss");
response.Result = await _orderService.Insert(order);
//response.Messages.Add(response.Result ? SuccessMessage : FailMessage);
if (response.Result == true)
{
response.Messages.Add(SuccessMessage);
// Send Email
var subject = "Đặt hàng thành công";
var bodyHtml = await _viewRenderService.RenderToStringAsync <Order>("EmailTemplates/OrderEmailTemplate", order);
var alias = "";
await _emailService.Send(subject, bodyHtml, alias, new List <string>() { order.Email });
if (voucher != null)
{
voucher.IsUsed = 1;
await _voucherService.Update(voucher);
}
}
else
{
response.Messages.Add(FailMessage);
}
if (response.Result)
{
response.OrderId = order.OrderId;
response.OrderCode = order.OrderCode;
}
return(response);
}
