public async Task AddOrderAsync_ShoudThrowExceptionNoProduct()
{
var request = new AddOrderRequest
{
UserId = mockOrder.UserId,
Products = new List <AddOrderProductRequest>
{
new AddOrderProductRequest
{
ProductId = mockProductOrder.ProductId,
Quantity = mockProductOrder.Quantity
}
}
};
var listProducts = new List <Product>
{
mockProduct
};
mockUserRepository.Setup(m => m.GetById(It.IsAny <int>()))
.Returns(mockUser);
await Assert.ThrowsAsync <Exception>(() => orderService.AddOrderAsync(request));
}
public async Task <Response <Order> > PlaceOrder(AddOrderRequest request)
{
var order = new Order();
double total = 0;
List <OrderEntry> orderEntries = new List <OrderEntry>();
foreach (var temp in request.Orders)
{
var orderEntry = new OrderEntry();
orderEntry.MenuId = temp.MenuId;
orderEntry.Price = _context.Menu.Where(w => w.Id == temp.MenuId).FirstOrDefault().Price;
orderEntry.Quantity = temp.Quantity;
orderEntry.OrderId = order.Id;
orderEntry._CreatedDate = DateUtils.GetDateNow();
orderEntry.CreatedBy = "SYSTEM";
orderEntry.Id = new Guid();
total += orderEntry.Price * temp.Quantity;
orderEntries.Add(orderEntry);
}
order.Total = total;
_context.Order.Add(order);
_context.OrderEntry.AddRange(orderEntries);
await _context.SaveChangesAsync();
return(new Response <Order>());
}
public void AddOrders()
{
List <Order> pendingOrders = OrderService.GetOrders(StatusID: (int)Beasts.Model.Status.Pending).ToList();
foreach (Order order in pendingOrders)
{
try
{
if (PayPal.CheckSale(order.PaypalSaleID))
{
AddOrderRequest addOrderRequest = Mapper.Map <AddOrderRequest>(order);
AddOrderResponse addOrderResponse = client.AddOrder(addOrderRequest);
if (addOrderResponse.Result == 1 && addOrderResponse.Order != null)
{
order.PrintAuraID = addOrderResponse.Order.OrderId;
order.Status = Beasts.Model.Status.Processing;
OrderService.UpdateOrder(order);
}
}
}
catch (Exception ex)
{
ExceptionService.CreateException(ex);
}
}
}
public void AddOrder(AddOrderRequest request)
{
var validationResult = _validator.ValidateRequest(request);
if (!validationResult.PassedValidation)
{
throw new ArgumentException(validationResult.Errors.First());
}
var clinic = _context.Patient.First(x => x.Id == request.PatientId).Clinic;
var newOrder = new Order
{
Id = Guid.NewGuid(),
StartTime = request.StartTime,
EndTime = request.EndTime,
PatientId = request.PatientId,
DoctorId = request.DoctorId,
SurgeryType = (int)clinic.SurgeryType
};
_context.Order.Add(newOrder);
_context.SaveChanges();
}
public async Task <IHttpActionResult> PostOrder(AddOrderRequest dto)
{
await orderService.Add(dto);
Uow.Commit();
return(await Task.FromResult(Ok()));
}
public IActionResult addOrder(CustomerDbContext _context, AddOrderRequest request, int _clientId)
{
using (var transaction = _context.Database.BeginTransaction())
{
try
{
var cakesNotInDatabase = 0;
//check if products from the request exist in the database
request.Confectionery.ForEach(x =>
{
if (_context.Confectioneries.Where(y => y.Name == x.Name).FirstOrDefault() == null)
{
cakesNotInDatabase++;
}
});
//If a product has been provided that is not in the database, stop processing the request and return the appropriate error code
if (cakesNotInDatabase != 0)
{
return(NotFound("One of the confectionaries doesnt exist in the database"));
}
var nextIdOrder = _context.Orders.Max(o => o.IdOrder) + 1;
Order o = new Order
{
IdClient = _clientId,
IdOrder = nextIdOrder,
DateAccepted = request.DateAccepted,
DateFinished = DateTime.Now,
Notes = request.Notes,
};
_context.Orders.Add(o);
var result = request.Confectionery.Select(conf => new Confectionery_Order
{
IdConfection = _context.Confectioneries.Where(dbConf => dbConf.Name.Equals(conf.Name)).Select(dbConf => dbConf.IdConfecti).ToList().First(),
IdOrder = nextIdOrder,
Quantity = conf.Quantity,
Notes = conf.Notes
});
foreach (Confectionery_Order co in result)
{
_context.Confectionery_Orders.Add(co);
}
_context.SaveChanges();
transaction.Commit();
return(Ok("Created a new order"));
}
catch (Exception e)
{
transaction.Rollback();
return(BadRequest(e));
}
}
}
public PdrValidationResult ValidateRequest(AddOrderRequest request)
{
var result = new PdrValidationResult(true);
if (MissingRequiredFields(request, ref result))
{
return(result);
}
if (PatientNotFound(request, ref result))
{
return(result);
}
if (DoctorNotFound(request, ref result))
{
return(result);
}
if (DoctorIsAlreadyScheduled(request, ref result))
{
return(result);
}
return(result);
}
public bool InsertOrder(string clientId)
{
Log.Info("InsertOrder init...");
Log.Debug("Adding order for client id " + clientId);
var success = true;
var order = new AddOrderRequest(clientId);
Log.Info("Inserting order for product " + order.ProductId + ", and domain " + order.DomainName);
try
{
var request = ResolveRequest(order);
var response = _restClient.Execute(request) as RestResponse;
dynamic processedResponse = ProcessResponse(response);
if (!IsSuccess(processedResponse))
{
throw new Exception("API returns error.");
}
if (!AcceptOrder(processedResponse.orderid.ToString()))
{
throw new Exception("Unable to accept order.");
}
}
catch (Exception ex)
{
Log.Error("Order not added due to error: " + ex.Message);
success = false;
}
Log.Info("InsertOrder end.");
return(success);
}
public string AddOrder(AddOrderRequest request, int customerId)
{
using (var trans = _context.Database.BeginTransaction())
{
var orderId = _context.Order.Select(o => o.IdOrder).Max() + 1;
if (request.Confectionery is null || request.Notes is null)
{
trans.Rollback();
return(null);
}
try
{
var Order = new Order
{
DateAccepted = request.DateAccepted,
DateFinished = DateTime.Now,
Notes = request.Notes,
IdClient = customerId
};
_context.Order.Add(Order);
_context.SaveChanges();
// check if confectionary already exists in database if it does add to Confectionary_Order
foreach (var confec in request.Confectionery)
{
var confecId = _context.Confectionaries.Where(c => c.Name.Equals(confec.Name)).Select(c => c.IdConfectionary).FirstOrDefault();
if (confecId == 0)
{
trans.Rollback();
return(null);
}
// else add to confictionary_order
var confecOrder = new Confectionary_Order
{
IdConfection = confecId,
IdOrder = orderId,
Quantity = confec.Quantity,
Notes = confec.Notes
};
_context.confectionary_Orders.Add(confecOrder);
_context.SaveChanges();
}
trans.Commit();
return("Order has been successfully created!");
}
catch (Exception e)
{
trans.Rollback();
return(null);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
public void AddOrder(AddOrderRequest item)
{
var path = "/api/Orders";
path = path.Replace("{format}", "json");
var queryParams = new Dictionary <String, String>();
var headerParams = new Dictionary <String, String>();
var formParams = new Dictionary <String, String>();
var fileParams = new Dictionary <String, FileParameter>();
String postBody = null;
postBody = ApiClient.Serialize(item); // http body (model) parameter
// authentication setting, if any
String[] authSettings = new String[] { };
// make the HTTP request
IRestResponse response = (IRestResponse)ApiClient.CallApi(path, Method.POST, queryParams, postBody, headerParams, formParams, fileParams, authSettings);
if (((int)response.StatusCode) >= 400)
{
throw new ApiException((int)response.StatusCode, "Error calling AddOrder: " + response.Content, response.Content);
}
else if (((int)response.StatusCode) == 0)
{
throw new ApiException((int)response.StatusCode, "Error calling AddOrder: " + response.ErrorMessage, response.ErrorMessage);
}
return;
}
public void ShouldBeAbleToAddNewOrder()
{
// arrange
var mock = new MockRepository();
var repository = mock.DynamicMock<IOrderRepository>();
const string IdentityToken = "*****@*****.**";
const string RetailerUrl = "amazon.com";
Expect.Call(repository.AddOrder(IdentityToken, new Order { Retailer = new Retailer(RetailerUrl) }))
.Return(new Order(OrderStatus.New) { Retailer = new Retailer(RetailerUrl), CreatedDate = DateTime.UtcNow });
var service = new OrderService(repository, new FakeEmailService(), this.logger);
var request = new AddOrderRequest
{
IdentityToken = IdentityToken,
RetailerUrl = RetailerUrl,
CreatedDate = DateTime.UtcNow
};
// act
mock.ReplayAll();
var actual = service.AddOrder(request);
mock.VerifyAll();
// assert
Assert.That(actual, Is.Not.Null);
Assert.That(actual.CreatedDate, Is.EqualTo(request.CreatedDate).Within(1).Minutes);
Assert.That(actual.RetailerUrl, Is.EqualTo(request.RetailerUrl));
}
public async Task AddOrderAsync(AddOrderRequest request)
{
var user = userRepository.GetById(request.UserId);
if (user == null)
{
throw new Exception(ErrorMessage.UserNotFound);
}
var productsList = productRepository.GetProducts(request.Products.Select(p => p.ProductId));
if (productsList == null ||
productsList.Count() == 0 ||
request.Products.Any(p => !productsList.Any(pl => pl.Id == p.ProductId)))
{
throw new Exception(ErrorMessage.ProductsNotFound);
}
var order = mapper.Map <Order>(request);
order.CreationDate = DateTime.Now;
foreach (var product in order.Products)
{
var actualProduct = productsList.First(p => p.Id == product.ProductId);
product.UnityPrice = actualProduct.Price;
}
await orderRepository.AddAsync(order);
}
public AddOrderResponse AddOrder(int id, AddOrderRequest request)
{
var exists = _orderDbContext.Customers.Any(c => c.IdClient.Equals(id));
if (!exists)
{
return(null);
}
// taking random employee to perform the order
Random rand = new Random();
int num = rand.Next(0, _orderDbContext.Employees.Count() - 1);
var order = new Order()
{
DataAccepted = request.DateAccepted,
idClient = id,
idEmployee = _orderDbContext.Employees.Skip(num).Take(1).First().idEmployee,
Notes = request.Notes
};
_orderDbContext.Add(order);
_orderDbContext.SaveChanges();
// foreach in request
var confExists = false;
foreach (var cnf in request.Confectionery)
{
//checking if such product exists
confExists = _orderDbContext.Confectioneries.Any(c => c.Name.Equals(cnf.Name));
if (!confExists)
{
return(null);
}
var confectioneryId = _orderDbContext.Confectioneries.Where(c => c.Name.Equals(cnf.Name))
.Select(c => c.IdConfectionery).FirstOrDefault();
var conf_order = new ConfectioneryOrder()
{
IdConfection = confectioneryId,
IdOrder = order.idOrder,
Notes = cnf.Notes,
Quantity = cnf.Quantity
};
_orderDbContext.Add(conf_order);
_orderDbContext.SaveChanges();
}
return(new AddOrderResponse
{
IdOrder = order.idOrder,
Confectionery = request.Confectionery
});
}
public async Task <AddOrderResponse> AddOrderDb(AddOrderRequest request)
{
var orderId = await _repository.AddOrderAsync(request);
if (orderId > 0)
{
return(new AddOrderResponse(true, orderId));
}
return(new AddOrderResponse(false, 0));
}
public async Task <long> AddNewOrderAsync(AddOrderRequest addOrderRequest)
{
string getOrdersCacheKey = $"{nameof(GetOrdersAsync)}_{addOrderRequest.CustomerId}";
memoryCache.Remove(getOrdersCacheKey); //we remove the cache after we add a new order
//the above logic is simplified to the case which is used currently by benchmark.
//In real life we should remove all possible keys created for the customer and variations of parameters passed in the Get endpoint
return(await this.orderDao.AddNewOrderAsync(addOrderRequest));
}
public async Task <IActionResult> Post([FromBody] AddOrderRequest request)
{
var response = await _addOrder.AddOrderDb(request);
if (!response.Success)
{
return(BadRequest());
}
return(Ok(response));
}
public AddOrderResponse AddOrder(AddOrderRequest request, int idCustomer)
{
if (String.IsNullOrEmpty(idCustomer.ToString()))
{
throw new Exception("you have to provide the id of a customer");
}
var customer = _context.Customer.FirstOrDefault(c => c.IdCustomer == idCustomer);
if (customer == null)
{
throw new Exception("there is no such customer");
}
for (int i = 0; i < request.Confectionery.Count; i++)
{
var confect = _context.Confectionery.FirstOrDefault(c => c.Name.Equals(request.Confectionery.ElementAt(i).Name));
if (confect == null)
{
throw new Exception("there is no such confectionery");
}
}
Random rand = new Random();
var order = new Order()
{
// IdOrder = _context.Order.Max(o=>o.IdOrder) +1,
DateAccepted = request.DateAccepted,
DateFinished = request.DateAccepted.AddDays(3),
Notes = request.Notes,
IdCustomer = idCustomer,
IdEmployee = rand.Next(1, 3)
};
for (int i = 0; i < request.Confectionery.Count; i++)
{
var confectionery_order = new Confectionery_Order()
{
// IdOrder = _context.Order.Max(o => o.IdOrder) + 1,
IdConfectionery = _context.Confectionery.FirstOrDefault(c => c.Name.Equals(request.Confectionery.ElementAt(i).Name)).IdConfectionery,
Quantity = request.Confectionery.ElementAt(i).Quantity,
Notes = request.Confectionery.ElementAt(i).Notes
};
_context.Confectionery_Order.Add(confectionery_order);
}
_context.Order.Add(order);
// _context.SaveChanges();
var response = new AddOrderResponse()
{
Notes = order.Notes,
DateFinished = order.DateFinished,
Surname = customer.Surname,
IdEmployee = order.IdEmployee
};
return(response);
}
public Task <AddOrderResponse> AddOrderAsync(AddOrderRequest addOrderRequest)
{
var request = new PrintAuraRestRequest
{
Method = Method.POST
};
request.AddJsonBody(addOrderRequest);
return(ExecuteAsync <AddOrderResponse>(request));
}
public AddOrderResponse AddOrder(AddOrderRequest addOrderRequest)
{
var request = new PrintAuraRestRequest
{
Method = Method.POST
};
request.AddJsonBody(addOrderRequest);
return(Execute <AddOrderResponse>(request));
}
public IActionResult AddOrders(AddOrderRequest request)
{
int id = Convert.ToInt32(Request.Path.ToUriComponent().Split("/").GetValue(3));
string result = _service.AddOrders(id, request);
if (result == null)
{
return(BadRequest("404 Bad Request!"));
}
return(Ok(result));
}
public AddOrderResponse AddOrder(int IdClient, AddOrderRequest request)
{
AddOrderResponse response = new AddOrderResponse()
{
ConfenctioneryIdList = new List <int>()
};
int UserIdCounter = context.Customer.Where(c => c.IdClient == IdClient).Count();
if (UserIdCounter != 1)
{
throw new NoSuchCustomerException("Customer with such id was not found!");
}
foreach (AddConfectioneryRequest item in request.Confectionery)
{
if (context.Confectionery.Select(co => co.Name).Where(n => n == item.Name).Count() != 1)
{
throw new NoSuchConfectioneryException("Confectionary with such name was not found!");
}
}
using (var trans = context.Database.BeginTransaction())
{
Order order = new Order()
{
DateAccepted = request.DateAccepted,
Notes = request.Notes,
IdClient = IdClient,
IdEmployee = request.IdEmployee
};
context.Add <Order>(order);
context.SaveChanges();
response.IdOrder = order.IdOrder;
foreach (AddConfectioneryRequest item in request.Confectionery)
{
int id = context.Confectionery.Where(co => co.Name == item.Name).Select(co => co.IdConfectionery).FirstOrDefault();
response.ConfenctioneryIdList.Add(id);
context.Add <Confectionery_Order>(new Confectionery_Order()
{
IdConfectionery = id,
IdOrder = order.IdOrder,
Quantity = item.Quantity,
Notes = item.Notes
});
}
context.SaveChanges();
trans.Commit();
}
return(response);
}
private bool DoctorNotFound(AddOrderRequest request, ref PdrValidationResult result)
{
if (!_context.Doctor.Any(x => x.Id == request.DoctorId))
{
result.PassedValidation = false;
result.Errors.Add("A doctor with that ID could not be found");
return(true);
}
return(false);
}
public OrdersResponse addOrder(int idCustomer, AddOrderRequest req)
{
if (!context.Customers.Any(c => c.IdCustomer == idCustomer))
{
return new OrdersResponse
{
orders = null,
Error = "No customer with such id"
}
}
;
foreach (ConfectioneryDTO con in req.Confectionery)
{
if (!context.Confectioneries.Any(c => c.Name == con.Name))
{
return new OrdersResponse
{
orders = null,
Error = "no such confectionery as " + con.Name
}
}
;
}
Order newOrder = new Order
{
DateAccepted = req.DateAccepted,
DateFinished = DateTime.Now,
Notes = req.Notes,
IdEmployee = 1,
IdCustomer = idCustomer
};
context.Add <Order>(newOrder);
context.SaveChanges();
foreach (ConfectioneryDTO con in req.Confectionery)
{
Confectionery_Order newC_Order = new Confectionery_Order
{
IdOrder = context.Orders.Max(o => o.IdOrder),
IdConfectionery = context.Confectioneries.Where(c => c.Name == con.Name).First().IdConfectionery,
Quantity = con.Quantity,
Notes = con.Notes
};
context.Add <Confectionery_Order>(newC_Order);
context.SaveChanges();
}
return(getOrders(null));
}
}
}
public IActionResult AddOrder(AddOrderRequest request, int idCustomer)
{
try
{
var order = _service.AddOrder(request, idCustomer);
return(Created("AddOrder", order));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public void AddOrder(AddOrderRequest request)
{
var customer = _customerManager.Get(request.CustomerIdentityTag);
if (customer is null)
{
customer = new Entities.Customer
{
IdentityTag = request.CustomerIdentityTag,
Email = request.CustomerEmail,
Phone = request.CustomerPhone,
FirstName = request.CustomerFirstname,
LastName = request.CustomerLastname,
Updated = DateTime.Now,
CommunicationType = SystemDefaults.DefaultCommunicationType
};
_customerManager.Create(customer);
}
var order = new Order
{
Created = _timeManager.Parse(request.CreationDate, SystemDefaults.DefaultFormat),
Customer = customer,
TotalAmount = request.TotalPrice,
Catering = _cateringManager.Get(request.CateringId) ?? throw new AppException($"Caterign with '{request.CateringId}' doesn't exists")
};
var orderItems = new List <OrderItem>();
foreach (var item in request.AddOrderRequestItems)
{
ItemCategory category;
if ((category = _orderManager.GetCategory(item.CategoryId)) == null)
{
throw new AppException($"Category with '{item.CategoryId}' doesn't exists");
}
var t = new OrderItem
{
ItemName = item.Name,
Price = item.Price,
Order = order,
ItemCategory = category
};
orderItems.Add(t);
}
order.Items = orderItems;
_orderManager.Create(order);
}
public async Task <ActionResult> Post(AddOrderRequest order)
{
await mediator.Send(new MakeOrderCommand { OrderItems = order.OrderItems.Select(ToOrderItem).ToList() });
return(Ok());
MakeOrderCommand.AddOrderItemModel ToOrderItem(AddOrderItemContract source) => new MakeOrderCommand.AddOrderItemModel
{
Count = source.Count,
Description = source.Description
};
}
public IActionResult AddZamowienie(int id, AddOrderRequest req)
{
return(Ok(_service.AddZamowienie(req, id)));
try
{
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <IActionResult> CreateAsync([FromBody] AddOrderRequest request)
{
try
{
await orderService.AddOrderAsync(request);
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
return(Ok());
}
public IActionResult addOrder(int idCustomer, AddOrderRequest req)
{
var res = _service.addOrder(idCustomer, req);
if (res.orders != null)
{
return(Ok(res.orders));
}
else
{
return(BadRequest(res.Error));
}
}
public IActionResult AddOrder(int id, AddOrderRequest request)
{
var res = _service.AddOrder(id, request);
if (res == null)
{
return(BadRequest("Nie ma takiego wyrobu"));
}
else
{
return(Ok(res));
}
}
public IActionResult AddOrder(int id, AddOrderRequest request)
{
var res = _orderServiceDb.AddOrder(id, request);
if (res == null)
{
return(BadRequest("Such customer or product does not exists"));
}
else
{
return(Ok(res));
}
}
public IHttpActionResult AddOrder(AddOrderRequest addOrderRequest)
{
try
{
if (addOrderRequest == null)
{
return ResponseMessage(new HttpResponseMessage() { StatusCode = HttpStatusCode.BadRequest });
}
var addOrderResponse = _OrderService.AddOrder(addOrderRequest);
if (addOrderResponse.ValidationResults.Any())
{
return ResponseMessage(new HttpResponseMessage() { StatusCode = HttpStatusCode.InternalServerError, Content = new StringContent(JsonConvert.SerializeObject(string.Join(",", addOrderResponse.ValidationResults))) });
}
return Ok<AddOrderResponse>(addOrderResponse);
}
catch (Exception ex)
{
_logRepository.Log(ex);
return InternalServerError();
}
}
/// <summary>
/// Add new order.
/// </summary>
/// <param name="request">
/// The add new order request.
/// </param>
/// <returns>
/// The add order response.
/// </returns>
public AddOrderResponse AddOrder(AddOrderRequest request)
{
var retailer = new Retailer(request.RetailerUrl);
var newOrder = new Order(OrderStatus.New) { CreatedDate = DateTime.UtcNow, Retailer = retailer };
var response = new AddOrderResponse { BrokenRules = retailer.GetBrokenRules().ToList() };
response.BrokenRules.AddRange(newOrder.GetBrokenRules().ToList());
if (response.BrokenRules.Any())
{
response.MessageType = MessageType.Warning;
return response;
}
try
{
var orderResult = this.orderRepository.AddOrder(request.IdentityToken, newOrder);
response = orderResult.ConvertToAddOrderResponse();
response.Message = CommonResources.OrderAddSuccessMessage;
}
catch (Exception ex)
{
response.MessageType = MessageType.Error;
response.ErrorCode = ex.Message;
this.Logger.Error(CommonResources.OrderAddErrorMessage, ex);
}
return response;
}
public ActionResult Add([Bind]string retailerUrl, string userEmail)
{
this.EnsureUserEmailIsNotChanged(userEmail);
var result = new OrderViewModel { Status = "New", RetailerUrl = retailerUrl };
var validator = new OrderViewModelValidator();
var validationResult = validator.Validate(result);
if (validationResult.IsValid)
{
var request = new AddOrderRequest
{
RetailerUrl = retailerUrl,
CreatedDate = DateTime.UtcNow,
IdentityToken = userEmail,
CreatedByOperator = !userEmail.Equals(FormsAuthentication.GetAuthenticationToken())
};
var response = this.orderService.AddOrder(request);
result = response.ConverToOrderViewModel();
}
else
{
result.MessageType = MessageType.Warning.ToString();
result.BrokenRules = new List<BusinessRule>();
foreach (var failure in validationResult.Errors)
{
result.BrokenRules.Add(new BusinessRule(failure.PropertyName, failure.ErrorMessage));
}
}
var jsonNetResult = new JsonNetResult
{
Formatting = (Formatting)Newtonsoft.Json.Formatting.Indented,
Data = result
};
return jsonNetResult;
}
