public string CreateNewOrder([FromBody] string req)
{
var result = String.Empty;
var request = new SaveOrderRequest();
var response = new SaveOrderResponse();
try
{
OrderService service = new OrderService();
request = JsonConvert.DeserializeObject <SaveOrderRequest>(req);
ClaimsIdentity identity = (ClaimsIdentity)User.Identity;
int userID = Int32.Parse(identity.Claims.Where(x => x.Type == "UserID").First().Value);
if (request.Order.OrderTypeID == (byte)EOrderTypes.Online)
{
request.Order.CustomerID = userID;
}
response = service.PerformCreateNewOrder(request);
}
catch (Exception ex)
{
response = new SaveOrderResponse()
{
MessageString = ex.Message,
MessageStatusID = (byte)EMessageStatus.Success
};
}
result = JsonConvert.SerializeObject(response);
return(result);
}
public async Task <ActionResult> Create([FromBody] SaveOrderRequest entity)
{
try
{
var order = mapper.Map <Order>(entity);
// Deduct quantities from inventory
await inventoryService.ProcessAdjustments(order.LineItems, AdjustmentType.Deduct, Constants.AdjustmentRemarks.OrderCreated, QuantityType.Quantity);
await context.Orders.AddAsync(order);
await context.SaveChangesAsync();
return(StatusCode(StatusCodes.Status201Created));
}
catch (QuantityBelowZeroException ex)
{
logger.LogError(ex.Message);
ModelState.AddModelError(Constants.ErrorMessage, ex.Message);
return(BadRequest(ModelState));
}
catch (Exception e)
{
logger.LogError(e.Message);
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public SaveOrderResponse PerformCreateNewOrder(SaveOrderRequest request)
{
SaveOrderResponse response = new SaveOrderResponse();
try
{
using (var db = new CuddlyWombatEntities())
{
db.Configuration.LazyLoadingEnabled = false;
db.Configuration.ProxyCreationEnabled = false;
db.Orders.Add(request.Order);
db.SaveChanges();
foreach (var o in request.OrderMenuItems)
{
o.OrderID = request.Order.OrderID;
db.OrderMenuItems.Add(o);
}
db.SaveChanges();
response.MessageString = "New Order is successfully created";
response.MessageStatusID = (byte)EMessageStatus.Success;
}
}
catch (Exception ex)
{
response.MessageStatusID = (byte)EMessageStatus.Exception;
response.MessageString = ex.Message;
}
return(response);
}
/// <summary>
/// Update order with current id.
/// </summary>
/// <param name="param"></param>
/// <returns></returns>
public virtual Task <Overture.ServiceModel.Orders.Order> UpdateOrderAsync(UpdateOrderParam param)
{
if (param == null)
{
throw new ArgumentNullException(nameof(param));
}
if (param.OrderId == default)
{
throw new ArgumentException(GetMessageOfEmpty(nameof(param.OrderId)));
}
if (string.IsNullOrWhiteSpace(param.Scope))
{
throw new ArgumentException(GetMessageOfNullWhiteSpace(nameof(param.Scope)));
}
if (param.Order == null)
{
throw new ArgumentException(GetMessageOfNull(nameof(param.Order)));
}
var request = new SaveOrderRequest
{
ScopeId = param.Scope,
OrderId = param.OrderId,
Order = param.Order,
};
return(OvertureClient.SendAsync(request));
}
public IActionResult SaveOrder([FromBody] SaveOrderRequest saveOrderRequest)
{
try
{
bool isSuccess = dataBaseService.InsertOrder(saveOrderRequest);
return(StatusCode(200, isSuccess));
}
catch (Exception)
{
return(StatusCode(500, Constants.REQUEST_ERROR_MESSAGE));
}
}
public async Task <ActionResult> Update(long id, [FromBody] SaveOrderRequest entity)
{
try
{
var order = await context.Orders
.Include(a => a.Customer)
.Include(a => a.LineItems).ThenInclude(detail => (detail as OrderLineItem).TransactionHistory)
.AsNoTracking()
.SingleOrDefaultAsync(t => t.Id == id);
if (order == null)
{
return(NotFound());
}
// Process inventory adjustments
await inventoryService.ProcessAdjustments(order.LineItems, AdjustmentType.Add, Constants.AdjustmentRemarks.OrderUpdated, QuantityType.Quantity);
await inventoryService.ProcessAdjustments(entity.LineItems, AdjustmentType.Deduct, Constants.AdjustmentRemarks.OrderUpdated, QuantityType.Quantity);
// Process deleted line items
entityListHelpers.CheckItemsForDeletion(order.LineItems, entity.LineItems);
// Update the order data
order = mapper.Map <Order>(entity);
context.Update(order);
await context.SaveChangesAsync();
return(StatusCode(StatusCodes.Status204NoContent));
}
catch (QuantityBelowZeroException ex)
{
logger.LogError(ex.Message);
ModelState.AddModelError(Constants.ErrorMessage, ex.Message);
return(BadRequest(ModelState));
}
catch (DbUpdateConcurrencyException concurrencyEx)
{
logger.LogError(concurrencyEx.Message);
return(StatusCode(StatusCodes.Status409Conflict, Constants.ErrorMessages.ConcurrencyErrorMessage));
}
catch (Exception ex)
{
logger.LogError(ex.Message);
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public BasketSaveResponse Save(string userId, OrderStatus orderStatus)
{
var response = new BasketSaveResponse();
if (!_userSessionService.IsLoggedIn(userId))
{
response.AddError(new Error
{
Code = ErrorCodes.UserNotLoggedIn,
UserMessage = "You have to be logged in to save your order"
});
return(response);
}
if (orderStatus == OrderStatus.Unknown)
{
response.AddError(new Error {
UserMessage = "Order status not specified."
});
return(response);
}
var userBasket = _userSessionService.GetBasketForUser(userId);
var orderRequest = new SaveOrderRequest
{
DeliveryType = DeliveryType.Unknown.ToString(),
Voucher = "",
UserId = _userSessionService.GetUserByUserToken(userId),
GrandTotal = userBasket.Total.InPence,
Status = orderStatus.ToString(),
Orders = userBasket.Items.ConvertAll(x => new Order
{
PizzaId = x.Pizza.Id,
SizeId = x.Size.Id,
ExtraToppingIds = x.ExtraToppings.ConvertAll(y => y.Id),
SubTotal = x.Total.InPence
})
};
var saveOrderResponse = _orderRepository.SaveOrder(orderRequest);
if (saveOrderResponse.HasError)
{
response.AddError(saveOrderResponse.Error);
}
return(response);
}
public bool InsertOrder(SaveOrderRequest request)
{
using (SqlConnection connection = new SqlConnection(configuration["ConnectionStrings:DataBase"]))
{
try
{
connection.Open();
string success = request.Success ? "1" : "0";
string query = $"INSERT INTO Pedidos(Facturado, ValorTotal, Productos) VALUES ({success}, {request.TotalValue}, '{Serialize.SerializeObject(request.Request)}')";
SqlCommand command = new SqlCommand(query, connection);
int affectedRows = command.ExecuteNonQuery();
return(affectedRows > 0);
}
catch (Exception)
{
return(false);
}
}
}
public void SaveOrder(SaveOrderRequest request)
{
var staff = _staffOrderRepo.GetStaffMemberEmpNo(request.EmployeeNo);
if (staff == null)
{
throw new StaffException("Staff Member does not have an employee number. Please capture it.");
}
Domain.Order order = new Domain.Order()
{
Dept = request.Dept,
OrderDate = DateTime.Now,
Description = request.Description,
EmployeeNo = request.EmployeeNo,
ItemNo = request.ItemNo,
Mailing = request.Mailing,
Month = request.Month,
OrdCode = request.OrdCode,
page = request.page,
Price = request.Price,
Size = request.Size,
StatusID = 1
};
var stock = _stockRepo.GetStock(order.ItemNo);
if (stock == null)
{
throw new StaffException("Item not available.");
}
if (stock.QtyAvail > 0)
{
_staffOrderRepo.SaveOrder(order);
}
else
{
throw new StaffException("Not enough stock for this order.");
}
}
public void ShouldNotCreateAnEmptyComplexTypeMember()
{
var source = new SaveOrderRequest
{
Id = 678,
DateCreated = DateTime.Now,
Items = new[]
{
new SaveOrderItemRequest {
ProductId = 123
},
new SaveOrderItemRequest {
ProductId = 456
}
}
};
var result = Mapper.Map(source).ToANew <OrderEntity>(cfg => cfg
.WhenMapping
.From <SaveOrderItemRequest>()
.To <OrderItemEntity>()
.Map(ctx => ctx.Parent.Parent.GetSource <SaveOrderRequest>().Id)
.To(oi => oi.OrderId));
result.DateCreated.ShouldBe(source.DateCreated);
result.Items.Count.ShouldBe(2);
result.Items.First().OrderId.ShouldBe(678);
result.Items.First().ProductId.ShouldBe(123);
result.Items.First().Product.ShouldBeNull();
result.Items.Second().OrderId.ShouldBe(678);
result.Items.Second().ProductId.ShouldBe(456);
result.Items.Second().Product.ShouldBeNull();
}
public void LogisticsController_HttpStatusCode_200()
{
//Arrange
var IInvoiceServiceMock = new Mock <IDataBaseService>();
IInvoiceServiceMock.Setup(m => m.InsertOrder(It.IsAny <SaveOrderRequest>()))
.Returns(() => { return(true); });
SaveOrderRequest payRequest = new SaveOrderRequest()
{
Success = true,
TotalValue = 200000,
Request = new PayRequest()
{
IdUser = 123,
Products = new List <ProductDto>()
{
new ProductDto()
{
Cantidad = 1, Nombre = "CPU", Precio = 2800000
},
new ProductDto()
{
Cantidad = 3, Nombre = "Monitor", Precio = 500000
}
}
}
};
//Act
LogisticsController logisticsController = new LogisticsController(IInvoiceServiceMock.Object);
var response = logisticsController.SaveOrder(payRequest) as Microsoft.AspNetCore.Mvc.ObjectResult;
//Assert
Assert.AreEqual(true, response.Value);
}
public void SetUp()
{
_database = new Mock <IDatabase>();
_database.Setup(x => x.Query <UserRecord>()).Returns(new List <UserRecord> {
new UserRecord {
Id = 1
}
});
_database.Setup(x => x.Query <BasketRecord>()).Returns(new List <BasketRecord> {
new BasketRecord {
Id = 1
}
});
_database.Setup(x => x.Query <PizzaRecord>()).Returns(new List <PizzaRecord> {
new PizzaRecord {
Id = 2
}
});
_database.Setup(x => x.Query <SizeRecord>()).Returns(new List <SizeRecord> {
new SizeRecord {
Id = 3
}
});
_database.Setup(x => x.Query <OrderRecord>()).Returns(new List <OrderRecord> {
new OrderRecord {
Id = 2
}
});
_database.Setup(x => x.Query <ToppingRecord>())
.Returns(new List <ToppingRecord> {
new ToppingRecord {
Id = 4
}
});
_database.Setup(x => x.Save(It.IsAny <BasketRecord>())).Returns(new BasketRecord {
Id = 1
});
_database.Setup(x => x.Save(It.IsAny <OrderRecord>())).Returns(new OrderRecord {
Id = 2
});
_database.Setup(x => x.Save(It.IsAny <OrderToppingRecord>())).Returns(new OrderToppingRecord {
Id = 3
});
var subject = new OrderRepository(_database.Object);
var saveOrderRequest = new SaveOrderRequest
{
DeliveryType = DeliveryType.Collection.ToString(),
GrandTotal = 1200,
Voucher = "SOME_VOUCHER",
UserId = 1,
Status = OrderStatus.Complete.ToString(),
Orders = new List <Data.Order.Order>
{
new Data.Order.Order
{
SubTotal = 1000,
PizzaId = 2,
SizeId = 3,
ExtraToppingIds = new List <int> {
4
}
}
}
};
_result = subject.SaveOrder(saveOrderRequest);
}
public BasketCheckoutResponse Checkout(DeliveryType delivery, string voucher, string userId, OrderStatus orderStatus)
{
var response = new BasketCheckoutResponse();
if (!_userSessionService.IsLoggedIn(userId))
{
response.AddError(new Error
{
Code = ErrorCodes.UserNotLoggedIn,
UserMessage = "You have to be logged in to complete your order"
});
return(response);
}
if (delivery == DeliveryType.Unknown)
{
response.AddError(new Error
{
Code = ErrorCodes.DeliveryTypeUnknown,
UserMessage = "Delivery type not specified."
});
return(response);
}
if (orderStatus == OrderStatus.Unknown)
{
response.AddError(new Error
{
Code = ErrorCodes.OrderStatusUnkown,
UserMessage = "Order status not specified."
});
return(response);
}
var userBasket = _userSessionService.GetBasketForUser(userId);
if (!voucher.IsEmpty())
{
var verifyVoucherResponse = _voucherService.Verify(userBasket, new List <DeliveryType> {
delivery
}, voucher);
if (!verifyVoucherResponse.HasError)
{
userBasket.Total = verifyVoucherResponse.Total;
}
}
var orderRequest = new SaveOrderRequest
{
UserId = _userSessionService.GetUserByUserToken(userId),
DeliveryType = delivery.ToString(),
Voucher = voucher,
GrandTotal = userBasket.Total.InPence,
Status = orderStatus.ToString(),
Orders = userBasket.Items.ConvertAll(x => new Order
{
PizzaId = x.Pizza.Id,
SizeId = x.Size.Id,
ExtraToppingIds = x.ExtraToppings.ConvertAll(y => y.Id),
SubTotal = x.Total.InPence
})
};
var saveOrderResponse = _orderRepository.SaveOrder(orderRequest);
if (saveOrderResponse.HasError)
{
response.AddError(saveOrderResponse.Error);
}
_userSessionService.ClearBasketForUser(userId);
return(response);
}
public void SaveOrder([FromBody] SaveOrderRequest request)
{
_agentService.SaveOrder(request);
}
public async Task <SaveOrderResponse> SaveOrderAsync(SaveOrderRequest request)
{
await DataAccessClient.SaveOrderAsync(request.Order, request.Items);
return(new SaveOrderResponse());
}
