public void OrderResponseValidateTest()
{
var assetPair = "BTCUSD";
MarkupModel markUp = new MarkupModel(50, 30);
var merchant = new MerchantModel(markUp);
var response = lykkePayApi.assetPairRates.PostAssetPairRates(assetPair, merchant, markUp);
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK), "Unexpected status code");
var postModel = JsonConvert.DeserializeObject <PostAssetsPairRatesModel>(response.Content);
Assert.That(postModel.LykkeMerchantSessionId, Is.Not.Null, "LykkeMerchantSessionId not present in response");
// order request below
var orderRequest = new OrderRequestModel()
{
currency = "USD", amount = 10, exchangeCurrency = "BTC", successURL = successURL, errorURL = errorURL, progressURL = progressURL, orderId = TestData.GenerateNumbers(5), markup = new PostMarkup(markUp, 0)
};
var orderRequestJson = JsonConvert.SerializeObject(orderRequest);
merchant = new MerchantModel(orderRequestJson);
var orderResponse = lykkePayApi.order.PostOrderModel(merchant, orderRequestJson, postModel.LykkeMerchantSessionId);
Assert.That(orderResponse.currency, Is.EqualTo(orderRequest.exchangeCurrency), "Unexpected currency in order response");
Assert.That(orderResponse.exchangeRate * orderResponse.amount, Is.EqualTo(orderRequest.amount), "Exchange rate * amount in order response not equals to request amount");
}
public void Create_Should_return_200_ok()
{
var orderRequest = new OrderRequestModel()
{
Pizzas = new List <string>()
{
"margarita"
},
Drinks = new List <string>()
{
"cocacola"
},
ExtraIngredients = new List <string>()
{
"kronärtskocka"
}
};
//Arrange
var menu = new Menu();
var validate = new Validate(menu);
var calculatePrice = new CalculateOrderPrice();
var order = new Order(calculatePrice, menu, validate);
var controller = new OrdersController(order, menu);
var actual = controller.Create(orderRequest);
var contentResult = actual.As <OkObjectResult>();
actual.Should().Be(contentResult);
}
private OrderDto RunInputValidation(OrderRequestModel orderRequestModel)
{
if (orderRequestModel.Pizzas == null && orderRequestModel.Drinks == null && orderRequestModel.ExtraIngredients != null)
{
throw new NullReferenceException("Invalid input. You may orderDto only drinks, but you have orderDto a pizza to orderDto extra ingredients");
}
if (orderRequestModel.Drinks != null)
{
drinks = Validate.ValidateDrinks(orderRequestModel.Drinks);
}
if (orderRequestModel.Pizzas != null)
{
pizzas = Validate.ValidatePizza(orderRequestModel.Pizzas);
}
if (orderRequestModel.ExtraIngredients != null)
{
extraIngredients = Validate.ValidateExtraIngredients(orderRequestModel.ExtraIngredients);
}
orderDto = new OrderDto()
{
Pizzas = pizzas,
Drinks = drinks,
ExtraIngredients = extraIngredients,
};
return(orderDto);
}
public OrderRequestModel SaveNewOrder(OrderRequestModel model)
{
model.IsActive = true;
_context.Entry(model).State = EntityState.Added;
_context.SaveChanges();
return(model);
}
public void Sell(OpenOrdersResponseModel buyorderResponse)
{
while (true)
{
Thread.Sleep(2000);
IEnumerable <OpenOrdersResponseModel> openOrdersResponse = binance.OpenOrders(s => s.ClientOrderId == buyorderResponse.ClientOrderId);
if (!openOrdersResponse?.Any() ?? true)
{
var sellorderRequest = new OrderRequestModel
{
Price = dynamicInfo.SellPrice,
Quantity = dynamicInfo.Quantity,
Side = Side.SELL.ToString(),
Symbol = dynamicInfo.Symbol,
Type = OrderType.LIMIT.ToString()
};
var sellorderResponse = binance.NewOrder(sellorderRequest);
if (sellorderResponse is ErrorModel err)
{
Console.WriteLine($"AN ERROR OCCURRED! Message: ({err.Code}) {err.Msg} => Order Type: BUY => Date: {DateTime.Now}");
}
else
{
Console.WriteLine($"Order Type: SELL => Date: {DateTime.Now}");
Buy();
}
break;
}
}
}
public async Task TestCreateOrderAsync()
{
// Arrange
var logger = LogHelper.GetLogger <SalesController>();
var salesService = ServiceMocker.GetSalesService(nameof(TestCreateOrderAsync));
var controller = new SalesController(logger, salesService);
var model = new OrderRequestModel
{
CustomerID = 1,
PaymentMethodID = new Guid("7671A4F7-A735-4CB7-AAB4-CF47AE20171D"),
Comments = "Order from unit tests",
CreationUser = "******",
CreationDateTime = DateTime.Now,
Details = new List <OrderDetailRequestModel>
{
new OrderDetailRequestModel
{
ProductID = 1,
ProductName = "The King of Fighters XIV",
Quantity = 1,
}
}
};
// Act
var response = await controller.CreateOrderAsync(model) as ObjectResult;
var value = response.Value as ISingleResponse <Order>;
controller.Dispose();
// Assert
Assert.False(value.DidError);
Assert.True(value.Model.OrderID.HasValue);
}
public void OrderPostCurrencyNotValidTest(object currency)
{
var assetPair = "BTCUSD";
var currentCurrency = currency.ToString();
MarkupModel markUp = new MarkupModel(50, 30);
var merchant = new MerchantModel(markUp);
var response = lykkePayApi.assetPairRates.PostAssetPairRates(assetPair, merchant, markUp);
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK), "Unexpected status code");
var postModel = JsonConvert.DeserializeObject <PostAssetsPairRatesModel>(response.Content);
Assert.That(postModel.LykkeMerchantSessionId, Is.Not.Null, "LykkeMerchantSessionId not present in response");
// order request below
var orderRequest = new OrderRequestModel()
{
currency = currentCurrency, amount = 10, exchangeCurrency = "BTC", successURL = successURL, errorURL = errorURL, progressURL = progressURL, orderId = TestData.GenerateNumbers(5), markup = new PostMarkup(markUp, 0)
};
var orderRequestJson = JsonConvert.SerializeObject(orderRequest);
merchant = new MerchantModel(orderRequestJson);
var orderResponse = lykkePayApi.order.PostOrder(merchant, orderRequestJson, postModel.LykkeMerchantSessionId);
Assert.That(orderResponse.StatusCode, Is.EqualTo(HttpStatusCode.NotFound), "Unexpected status code in case currency not valid");
}
public async Task AddOrder(OrderRequestModel order)
{
var mappedOrder = _mapper.Map <OrderRequestModel, Order>(order);
await _customerContext.Orders.AddAsync(mappedOrder);
_customerContext.SaveChanges();
}
public JsonResult OrderApproval(OrderRequestModel Data)
{
var resultModel = new JsonResultModel <OrderRequest>();
try
{
using (DataService db = new DataService())
{
var item = db.Context.OrderRequests.FirstOrDefault(x => x.ID == Data.ID);
var newOrder = db.Context.Orders.Add(new Order());
newOrder.OrderQuantity = item.Quantity;
newOrder.ProductID = item.ProductID;
newOrder.CompanyID = item.CompanyID;
newOrder.EmployeeID = item.RequesterID;
newOrder.OrderDate = DateTime.Now;
newOrder.Delivered = 0;
newOrder.SalePrice = 0;
newOrder.ContQuantity = 0;
db.Context.OrderRequests.Remove(item);
db.Context.SaveChanges();
}
resultModel.Status = JsonResultType.Success;
resultModel.Message = "Sipariş Talebi Onaylanarak Siparişlere Eklendi";
}
catch (Exception ex)
{
resultModel.Status = JsonResultType.Error;
resultModel.Message = "İşlem Gerçekleştirilemedi";
}
return(Json(resultModel, JsonRequestBehavior.AllowGet));
}
public async Task Edit(OrderRequestModel order)
{
List <OrderDetail> orderDetailsEntities = await this._orderDetailRepository.FindAllAsync(x => x.OrderId == order.Id);
foreach (var details in orderDetailsEntities)
{
await this._orderDetailRepository.Delete(details.Id);
}
Order orderEntity = await this._orderRepository.GetById(order.Id);
int totalQuantity = 0;
int totalPrice = 0;
List <int> orderedItemsId = order.OrderedItems.Select(x => x.Id).ToList();
List <MenuItem> items = await this._menuItemRepository.FindAllAsync(x => orderedItemsId.Contains(x.MenuItemId));
order.OrderedItems.ForEach(x =>
{
totalQuantity += x.Quantity;
totalPrice += items.First(y => y.MenuItemId == x.Id).Price *x.Quantity;
});
orderEntity.ItemsQuantity = totalQuantity;
orderEntity.TotalPrice = totalPrice;
await this._orderRepository.Update(orderEntity);
foreach (OrderItemRequestModel item in order.OrderedItems)
{
OrderDetail orderDetailEntity = new OrderDetail()
{
OrderId = order.Id,
OrderedItemId = item.Id,
Quantity = item.Quantity
};
await this._orderDetailRepository.Create(orderDetailEntity);
}
}
public async Task <ActionResult> PostOrder(OrderRequestModel order)
{
order.CreatedDateTime = DateTime.UtcNow;
await _orderRepository.AddOrder(order);
return(Ok());
}
public OrderResponseModel CreateOrder(OrderRequestModel request)
{
var cart = _orderRepository.Load <ICart>(request.CartId, DefaultCartName).First();
AddPaymentToCart(cart, request.AddressInformation.PaymentMethodCode, request.AddressInformation.BillingAddress);
AddShippingMethod(cart, request.AddressInformation.ShippingMethodCode);
AddShippingAddress(cart, request.AddressInformation.ShippingAddress);
//Assign cart to user if there is one
if (!string.IsNullOrEmpty(request.UserId))
{
cart.CustomerId = Guid.Parse(request.UserId);
}
var savedOrderReference = _orderRepository.SaveAsPurchaseOrder(cart);
var savedOrderId = savedOrderReference.OrderGroupId;
//recreate cart after successfull order
_orderRepository.Delete(cart.OrderLink);
var newCart = _orderRepository.Create <ICart>(request.CartId, DefaultCartName);
_orderRepository.Save(newCart);
return(new OrderResponseModel
{
OrderId = savedOrderId
});
}
public async Task Add(OrderRequestModel order)
{
Order orderEntity = this._mapper.Map <OrderRequestModel, Order>(order);
int totalQuantity = 0;
int totalPrice = 0;
List <int> orderedItemsId = order.OrderedItems.Select(x => x.Id).ToList();
List <MenuItem> items = await this._menuItemRepository.FindAllAsync(x => orderedItemsId.Contains(x.MenuItemId));
order.OrderedItems.ForEach(x =>
{
totalQuantity += x.Quantity;
totalPrice += items.First(y => y.MenuItemId == x.Id).Price *x.Quantity;
});
orderEntity.ItemsQuantity = totalQuantity;
orderEntity.TotalPrice = totalPrice;
int orderId = await this._orderRepository.PlaceOrder(orderEntity);
foreach (OrderItemRequestModel item in order.OrderedItems)
{
OrderDetail orderDetailEntity = new OrderDetail()
{
OrderId = orderId,
OrderedItemId = item.Id,
Quantity = item.Quantity
};
await this._orderDetailRepository.Create(orderDetailEntity);
}
}
public ActionResult SaveAll(OrderRequestModel o)
{
Product product = new Product();
Order order = new Order();
return(RedirectToAction("Index"));
}
public async Task UpdateOrder(OrderRequestModel model)
{
var order = await GetOrderByUserId(model.UserId);
order.MenuItems.Add(model.MenuItem);
await _orderRepository.UpdateOrder(order);
}
public async Task <IActionResult> CreateNewOrder([FromBody] OrderRequestModel orderRequestModel)
{
var result = await CommandRouter.RouteAsync <CreateOrderCommand, IdResponse>(
new CreateOrderCommand(orderRequestModel.bookingId, orderRequestModel.customerNumber,
orderRequestModel.orderNumber, orderRequestModel.wareNumber, orderRequestModel.InOut));
return(!result.IsSuccessful ? Conflict(result) : new ObjectResult(result));
}
public OrderResponseModel GetDeliveredOrders(OrderRequestModel request)
{
OrderResponseModel response = new OrderResponseModel();
IOrderDataAccess _repository = new OrderDataAccess();
response.Orders = _repository.GetDeliveredOrders(request.OrderRequest);
return(response);
}
public OrderResponseModel GetOrderDetailsById(OrderRequestModel request)
{
OrderResponseModel response = new OrderResponseModel();
IOrderDataAccess _repository = new OrderDataAccess();
response.OrderDetails = _repository.GetOrderDetailsById(request.OrderRequest);
return(response);
}
public OrderResponseModel GetOrdersOfFarmer(OrderRequestModel request)
{
OrderResponseModel response = new OrderResponseModel();
IOrderDataAccess _repository = new OrderDataAccess();
response.Orders = _repository.GetOrdersOfFamer(request.OrderRequest);
return(response);
}
public void Order_ShouldSendEmailToUser_WhenValidOrder()
{
mapper.Execute();
var testId = "testId";
var testUser = new User()
{
DeliveryCountry = "BG", DeliveryTown = "SF", DeliveryAddress = "Liulin", Email = "testEmail"
};
var usersMock = new Mock <IUsersService>();
usersMock.Setup(v => v.GetById(testId)).Returns(() => testUser);
var ordersMock = new Mock <IOrdersService>();
ordersMock.Setup(v => v.Add(It.IsAny <Order>()));
ordersMock.Setup(v => v.IsValidOrder(It.IsAny <Order>())).Returns(true);
var emailsMock = new Mock <IEmailsService>();
emailsMock.Setup(x => x.SendEmail(testUser.Email, string.Format(GlobalConstants.OrderMade, It.IsAny <string>()),
It.IsAny <string>(), GlobalConstants.SMTPServer,
GlobalConstants.EmailPrimary, GlobalConstants.EmailPrimaryPassword));
// moq the user
var claim = new Claim("test", testId);
var mockIdentity = Mock.Of <ClaimsIdentity>(ci => ci.FindFirst(It.IsAny <string>()) == claim);
var controller = new OrdersController(ordersMock.Object, usersMock.Object, emailsMock.Object, null)
{
User = Mock.Of <IPrincipal>(ip => ip.Identity == mockIdentity)
};
var orderedItemRequest = new OrderedItemRequestModel()
{
Manufacturer = "nordglass",
Description = "Description",
Price = 1
};
var model = new OrderRequestModel
{
DeliveryNotes = "DeliveryNotes",
Price = 1,
PaidPrice = 1,
UserЕmail = "testEmail",
UserId = testId,
FullAddress = "BG; SF; Liulin",
OrderedItems = new List <OrderedItemRequestModel>
{
orderedItemRequest
}
};
var result = controller.Order(model);
Assert.IsInstanceOfType(result, typeof(OkResult));
emailsMock.VerifyAll();
}
public async Task <OrderRequestModel> SaveOrder(OrderRequestModel order)
{
OrderRequest newOrder = _mapper.Map <OrderRequest>(order);
OrderRequest savedOrder = await _orderManager.SaveOrder(newOrder);
OrderRequestModel savedOrderModel = _mapper.Map <OrderRequestModel>(savedOrder);
return(savedOrderModel);
}
public static Order Map(OrderRequestModel orderRequestModel, Guid userId)
{
return(new Order()
{
Id = Guid.NewGuid(),
UserId = userId,
RestaurantId = orderRequestModel.RestaurantId,
});
}
private Order MapToPending(OrderRequestModel orm)
{
return(new Order
{
Id = Guid.NewGuid().ToString(),
Name = orm.Name,
Status = OrderStatus.PENDING
});
}
public List <OrderDto> HandleRequest(OrderRequestModel orderRequestModel)
{
OrderDto orderDto = RunInputValidation(orderRequestModel);
orderDto.TotalPrice = GetOrderPrice(CalculateOrderPrice, orderDto);
allOrders = Menu.AddToListOfOrders(orderDto);
return(allOrders);
}
public async Task <IActionResult> CreateOrderAsync([FromBody] OrderRequestModel value)
{
Logger?.LogDebug("{0} has been invoked", nameof(CreateOrderAsync));
// Get response from business logic
var response = await SalesService.CreateOrderAsync(value.GetOrder(), value.GetOrderDetails().ToArray());
// Return as http response
return(response.ToHttpResponse());
}
public async Task CreateNewOrder(OrderRequestModel model)
{
var order = new Order()
{
UserId = model.UserId,
MenuItems = new List <MenuItem>()
};
await _orderRepository.InsertOrder(order);
}
public async Task <IActionResult> Post([FromBody] OrderRequestModel request)
{
/*Check if a car variant exists*/
var carVariant = await _variants.FindById(request.VariantId);
if (carVariant == null || !carVariant.IsAvailable)
{
_logger.LogWarning($"VariantId: {request.VariantId} - NotFound.");
return(NotFound());
}
/*Apply for bank loan*/
BankLoanApiRequest bankLoanApiRequest = _mapper.Map <BankLoanApiRequest>(request);
var bankLoanResponce = await _bankLoan.ApplyBankLoanAsync(bankLoanApiRequest);
if (bankLoanResponce == null)
{
return(BadRequest());
}
string responseString = await bankLoanResponce.Content.ReadAsStringAsync();
HttpContext.Response.StatusCode = (int)bankLoanResponce.StatusCode;
if (!bankLoanResponce.IsSuccessStatusCode)
{
return(new JsonResult(JsonConvert.DeserializeObject <JObject>(responseString)));
}
BankLoanApiResponce bankLoan = JsonConvert.DeserializeObject <BankLoanApiResponce>(responseString);
/*Add Customer*/
Customer newCustomer = _mapper.Map <Customer>(request);
await _customer.Create(newCustomer).ConfigureAwait(false);
/*Add CarOrder*/
CarOrder order = _mapper.Map <CarOrder>(carVariant);
Customer customer = await _customer.GetByEmail(request.CustomerEmail);
order.Created = DateTime.Now;
order.CustomerId = customer.Id;
order.BankLoanDuration = request.BankLoanDuration;
order.BankLoanDownPayment = request.BankLoanDownPayment;
order.BankLoanMonthlyPayment = (decimal)bankLoan.MonthlyPayment;
await _order.Create(order).ConfigureAwait(false);
/*building response*/
OrderApiResponce response = _mapper.Map <OrderApiResponce>(carVariant);
response.BankLoanDuration = request.BankLoanDuration;
response.BankLoanDownPament = request.BankLoanDownPayment;
response.BankLoanMonthlyPayment = (decimal)bankLoan.MonthlyPayment;
return(new JsonResult(response));
}
public async Task <IActionResult> CreateOrder([FromBody] OrderRequestModel requestModel)
{
var order = await _orderService.GetOrderByUserId(requestModel.UserId);
if (order == null)
{
await _orderService.CreateNewOrder(requestModel);
}
return(Ok());
}
public async Task IdOfNonexistentCustomer_AddCustomerOrder_ReturnNotFound()
{
const int customerId = -1;
var orderModel = new OrderRequestModel();
var exception = await Assert.ThrowsAsync <ProblemDetailsException>(() =>
_customerController.AddCustomerOrder(customerId, orderModel));
Assert.Equal(StatusCodes.Status404NotFound, exception.Details.Status);
Assert.Contains("customer", exception.Details.Title, StringComparison.OrdinalIgnoreCase);
}
public async Task <Order> Post(string id, [FromBody] OrderRequestModel request)
{
_logger.LogInformation($"Placing a market buy order for {id.ToUpper()}");
var client = new OrderClient(_appSettings.BaseUri, _authenticator);
var response = await client.PlaceMarketBuyOrderAsync($"{id.ToUpper()}-EUR", request.Funds);
_logger.LogInformation($"The order id is {response.Value.id}");
return(response.Value);
}
