// End Testing ---------------------------------------------------------------------------------------------------------------
private void InitializeFields()
{
var fileMock = new Mock <IFormFile>();
var content = "Hello World from a Fake File";
var fileName = "test.pdf";
var ms = new MemoryStream();
var writer = new StreamWriter(ms);
writer.Write(content);
writer.Flush();
ms.Position = 0;
fileMock.Setup(_ => _.OpenReadStream()).Returns(ms);
fileMock.Setup(_ => _.FileName).Returns(fileName);
fileMock.Setup(_ => _.Length).Returns(ms.Length);
this.file = fileMock.Object;
this.orderInputModel = new OrderInputModel
{
UserId = "some userId",
ServiceId = 1,
Description = "Lorem Ipsum is simply dummy text ",
Documents = new List <IFormFile>()
{
this.file
},
};
}
public async Task <ActionResult> DoOrder()
{
// sipariş formu açılısında kullanıcı oturum açmış ise bu durumda şuan oturum açan müşteri bilgilerini getir.
if (User.Identity.IsAuthenticated)
{
var authenticatedUser = await _userManager.FindByNameAsync(User.Identity.Name);
var customer = _custormerRepo.Find(authenticatedUser.Id);
var model = new OrderInputModel();
model.CustomerDetail = new CustomerDetailModel
{
FullName = customer.FullName,
ShipAddress = customer.DefaultShippingAddress,
CustomerId = customer.Id,
PhoneNumber = customer.PhoneNumber
};
return(View(model));
}
return(View());
}
public async Task <IActionResult> Update(Guid businessId, string orderId, DateTime date,
[FromBody] OrderInputModel inputModel)
{
if (inputModel == null ||
businessId != inputModel.BusinessId ||
orderId != inputModel.OrderId ||
date != inputModel.Date)
{
return(BadRequest());
}
if (!await orderService.OrderExists(date, businessId, orderId))
{
return(NotFound());
}
if (!ModelState.IsValid)
{
return(Unprocessable(ModelState));
}
var model = ToDomainModel(inputModel);
await orderService.UpdateOrder(model);
return(NoContent());
}
public IHttpResponse Order(OrderInputModel orderInput)
{
if (orderInput.Barcode.Length != 12)
{
return(this.Error("Barcode shoud be 12 digits long!"));
}
if (orderInput.Quantity < 1)
{
return(this.Error("Quantity shoud be possitive number!"));
}
int productId = productsService.GetProductId(orderInput.Barcode);
if (productId == 0)
{
return(this.Error("Not existing product barcode!"));
}
Guid cashierId = this.GetUserId();
ordersService.Create(productId, orderInput.Quantity, cashierId);
return(this.Redirect("/"));
}
public ActionResult DoOrder(OrderInputModel model)
{
// 1 sipariş düzgün bir şekilde oluşur ise bu bilgileri database gönderip siparişe çevireceğiz ve
// daha sonrasında kullanıcıya bir mesaj verip sms email filan göndereceğiz.
// Kredi kartı işlem enum
// Başarılı 200
// red 300
// Limit Yertersiz 500 gibi
// eğer Başarılı ise Sipariş oluşturma işlemini yapıp kullanıcıya sipariş kodunu dönelim.
// 2 kredi kartı doğrulmasını yalancıktan yapalım eğer limit yeterli ise ve red verilmediyse sipariş oluşsun ve kullanıcıya ViewBag ile sipariş kodunu göster
if (ModelState.IsValid)
{
var cart = _cartService.GetCart();
_orderService.DoOrder(cart, model);
ViewBag.OrderCode = _orderService.orderCode;
ViewBag.OrderStatus = _orderService.Status;
return(View());
}
ViewBag.OrderCode = string.Empty;
ViewBag.OrderStatus = string.Empty;
return(View());
}
private async Task CreateOrder(string serviceType, OrderInputModel model)
{
if (serviceType == "mobile")
{
model.MobileServiceInfo = await this.orderService
.CreateAsync <MobileServiceInfoViewModel, OrderViewModel>(
new OrderViewModel
{
UserId = this.User.GetId(),
DocumentUrl = await this.uploadService.UploadImageAsync(model.Image),
},
model.MobileServiceInfo);
await this.orderService.FinishOrderAsync <MobileServiceInfoViewModel>(model.MobileServiceInfo);
}
else
{
model.FixedServiceInfo = await this.orderService
.CreateAsync <FixedServiceInfiViewModel, OrderViewModel>(
new OrderViewModel
{
UserId = this.User.GetId(),
DocumentUrl = await this.uploadService.UploadImageAsync(model.Image),
},
model.FixedServiceInfo);
await this.tasksService.CreateAsync(model.FixedServiceInfo.OrderId, model.InstalationSlotId);
await this.context.Clients.All.ReceiveTasksUpdate();
}
}
public async Task <IActionResult> Create(string customerId, string serviceType)
{
if (!await this.customerService.ExistAsync(customerId))
{
return(this.NotFound());
}
var model = new OrderInputModel
{
ServiceType = serviceType,
};
model.Services = await this.serviceService.GetServiceNamesByTypeAsync <ServiceViewModel>(serviceType);
if (serviceType == "mobile")
{
model.Numbers = await this.numberService.GetFreeNumbersAsync <ServiceNumberViewModel>(serviceType, null);
model.MobileServiceInfo = new MobileServiceInfoViewModel
{
ICC = await this.serviceInfoService.GetICCAsync(),
CustomerId = customerId,
};
return(this.View("Mobile", model));
}
model.FixedServiceInfo = new FixedServiceInfiViewModel
{
CustomerId = customerId,
};
return(this.View("Fixed", model));
}
public IActionResult Checkout()
{
if (!this.shoppingBagService.AnyProducts(this.User.Identity.Name))
{
this.TempData["error"] = ERROR_MESSAGE;
return(RedirectToAction("Index", "Home"));
}
var order = this.orderService.CreateOrder(this.User.Identity.Name);
var address = this.adressesService.GetAllAddressByUser(this.User.Identity.Name);
var viewModel = this.mapper.Map <IList <AddressInputModel> >(address);
var user = this.userService.GetUserByUsername(this.User.Identity.Name);
var fullName = $"{user.FirstName} {user.LastName}";
var createOrderViewModel = new OrderInputModel
{
Addresses = viewModel.ToList(),
FullName = fullName,
PhoneNumber = user.PhoneNumber
};
return(this.View(createOrderViewModel));
}
public OrderDto CreateNewOrder(string email, OrderInputModel order)
{
var user = _dbContext.Users.FirstOrDefault(u => u.Email == email)
?? throw new ResourceNotFoundException($"User with email {email} not found");
var address = _dbContext.Addresses.FirstOrDefault(a => a.Id == order.AddressId)
?? throw new ResourceNotFoundException($"Address with Id {order.AddressId} not found");
var paymentCard = _dbContext.PaymentCards.FirstOrDefault(p => p.Id == order.PaymentCardId)
?? throw new ResourceNotFoundException($"Payment card with Id {order.PaymentCardId} not found");
var cart = _dbContext.ShoppingCarts.FirstOrDefault(c => c.User.Email == email)
?? throw new ResourceNotFoundException($"No cart for with {email} was found");
var cartItems = _dbContext.ShoppingCartItems.Where(ci => ci.ShoppingCartId == cart.Id).ToList();
if (cartItems.Count == 0)
{
throw new ResourceNotFoundException($"Cart is empty");
}
var newOrder = CreateOrder(user, address, paymentCard);
PopulateItemsToOrder(newOrder, cartItems);
var orderDto = _mapper.Map <OrderDto>(newOrder);
orderDto.CreditCard = paymentCard.CardNumber;
return(orderDto);
}
public OrderDto CreateNewOrder(string email, OrderInputModel order)
{
// Retrieve information for the user with the email passed in
var user = _dbContext.Users.FirstOrDefault(u => u.Email == email);
if (user == null)
{
throw new Exception("User not found");
}
// Retrieve information for the address with the address id passed in
var address = _dbContext.Addresses.FirstOrDefault(a => a.Id == order.AddressId);
// Retrieve information for the payment card with the payment card id passed in
var card = _dbContext.PaymentCards.FirstOrDefault(c => c.Id == order.PaymentCardId);
var cardNumber = card.CardNumber;
var shoppingCart = _dbContext.ShoppingCarts.FirstOrDefault(s => s.UserId == user.Id);
var fullName = user.FullName;
float totalPrice = 0;
for (int i = 0; i < shoppingCart.ShoppingCartItems.Count(); i++)
{
totalPrice += shoppingCart.ShoppingCartItems[i].UnitPrice * shoppingCart.ShoppingCartItems[i].Quantity;
}
// Create a new order where the credit card number has been masked, e.g. ************5555
var entity = new OrderEntity
{
Email = user.Email,
FullName = fullName,
StreetName = address.StreetName,
HouseNumber = address.HouseNumber,
ZipCode = address.ZipCode,
Country = address.Country,
City = address.City,
CardHolderName = card.CardHolderName,
MaskedCreditCard = PaymentCardHelper.MaskPaymentCard(card.CardNumber),
OrderDate = DateTime.Now,
TotalPrice = totalPrice
};
_dbContext.Orders.Add(entity);
_dbContext.SaveChanges();
// Return the order but here the credit card number should not be masked
return(new OrderDto
{
Id = entity.Id,
FullName = entity.FullName,
Email = entity.Email,
StreetName = entity.StreetName,
HouseNumber = entity.HouseNumber,
ZipCode = entity.ZipCode,
Country = entity.Country,
CardholderName = entity.CardHolderName,
CreditCard = cardNumber,
OrderDate = entity.OrderDate.ToString("dd.MM.yyyy"),
TotalPrice = entity.TotalPrice
});
}
public IActionResult All(OrderInputModel model, int start)
{
if (ModelState.IsValid)
{
this.ordersService.AddOrder(model.TicketsCount, this.User, model.EventName);
return(this.Redirect("/"));
}
else
{
var totalEventsCount =
this.eventsService
.AllEventsCount();
var events =
this.eventsService
.EventsOnOnePage(start);
var viewModel = new EventsOnPageViewModel
{
Events = events,
Start = start,
TotalEventsCount = totalEventsCount
};
return(this.View(viewModel));
}
}
public async Task <IActionResult> Post([FromBody] OrderInputModel orderInputmodel)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
foreach (var item in orderInputmodel.Items)
{
var product = await _productService.GetByIdAsync(item.ProductId);
product.AvailableProduct -= item.NoOfProduct;
if (!await CheckProductAvailablityAsync(item))
{
return(NotFound(product));
}
await _productService.UpdateAsync(product);
}
var result = await _orderService.AddAsync(orderInputmodel.Map(orderInputmodel));
return(Ok(result.OrderNumber));
}
catch (Exception ex)
{
_loggerManager.LogError(ex.StackTrace + ex.Message);
return(StatusCode(StatusCodes.Status500InternalServerError, ex.Message));
}
}
public void CreateNewOrder(string email, OrderInputModel order)
{
var dto = _orderRepository.CreateNewOrder(email, order);
_shoppingCartRepository.DeleteCart(email);
_queueService.PublishMessage(_routingKey, dto);
}
public IActionResult Checkout(OrderInputModel OrderModel)
{
var Order = new Order();
var cart = OrderService.GetCart(this.HttpContext);
TryUpdateModelAsync(Order);
try
{
// fill out the order with the data from the user
Order.Username = User.Identity.Name;
Order.OrderDate = DateTime.Now;
Order.FullName = OrderModel.FullName;
Order.Address = OrderModel.Address;
Order.City = OrderModel.City;
Order.PostalCode = OrderModel.PostalCode;
Order.Country = OrderModel.Country;
Order.Email = OrderModel.Email;
Order.Total = _orderS.GetTotal();
//Add and save order
_checkoutS.Add(Order);
//returns the OrderId, we use that generate the complete page
int OrderId = cart.CreateOrder(Order);
//Checkout Complete!
return(RedirectToAction("Complete", new { id = OrderId }));
}
catch
{
//invalid, redisplay with errors
return(View(Order));
}
}
public async Task <ActionResult <Order> > Post(
[FromServices] DataContext context,
[FromBody] OrderInputModel model)
{
if (ModelState.IsValid)
{
List <Product> products = new List <Product>();
foreach (int id in model.ProductsId)
{
var productRegistered = await context.Products.Where(x => x.Id == id)
.AsNoTracking()
.SingleOrDefaultAsync();
if (productRegistered == null)
{
return(BadRequest());
}
products.Add(productRegistered);
}
Order order = new Order(model.Title, model.Description, products);
context.Orders.Add(order);
await context.SaveChangesAsync();
return(Ok(model));
}
else
{
return(BadRequest(ModelState));
}
}
public OrderDto CreateNewOrder(string email, OrderInputModel order)
{
var newOrder = _orderRepository.CreateNewOrder(email, order);
_shoppingCartRepository.DeleteCart(email);
_queueService.PublishMessage("create-order", newOrder);
return(newOrder);
}
public IActionResult Order(string coachId)
{
var inputModel = new OrderInputModel {
CoachId = coachId
};
return(this.View(inputModel));
}
public UpdateOrderCommand BuildUpdateOrderCommand(string id, OrderInputModel model)
{
var command = _mapper.Map <UpdateOrderCommand>(model);
command.OrderId = id;
return(command);
}
public IActionResult AddToWishlist(OrderInputModel input)
{
input.ExpirationTime = DateTime.Now.AddDays(90);
input.UserId = User.FindFirst(ClaimTypes.Name).Value;
orderService.AddToWishlist(input);
return(Ok());
}
private void CreateSale(OrderInputModel orderInputModel)
=> manager.PublishSale(new SaleMessage
{
SaleDate = DateTime.Now,
Customer = orderInputModel.Customer,
Price = orderInputModel.Price,
Product = orderInputModel.Product,
Quantity = orderInputModel.Quantity
});
public IActionResult Post([FromBody] OrderInputModel inputModel)
{
var paymentMethod = _paymentMethodService.GetById(inputModel.PaymentMethodId);
var payment = _mapper.Map <CreditCard>(inputModel.CreditCard) ?? BankSlip.Create() as Payment;
var address = _addressService.GetById(inputModel.AddressId);
_orderService.ProcessOrder(User.Identity.Name, paymentMethod, payment, address, inputModel.CouponCode);
return(Ok());
}
protected void DeepEqualForOrder(OrderInputModel inputModel, OrderOutputModel expOutputModel)
{
Assert.NotNull(expOutputModel.Date);
Assert.NotNull(expOutputModel.WarehouseName);
Assert.NotNull(expOutputModel.OrderDetailsOutput);
var model = mapper.Map <Order>(inputModel);
var outputModel = mapper.Map <OrderOutputModel>(model);
Assert.IsTrue(outputModel.Equals(expOutputModel));
}
public IActionResult AddToCart(OrderInputModel input)
{
input.ExpirationTime = DateTime.Now.AddDays(30);
input.UserId = User.FindFirst(ClaimTypes.Name).Value;
Console.WriteLine("\n**ADDING TO CART");
orderService.AddToCart(input);
return(Ok());
}
public async Task <ActionResult <IdField> > Update(string id, [FromBody] OrderInputModel data)
{
var command = _commandBuilder.BuildUpdateOrderCommand(id, data);
var orderId = await _commandDispatcher.ExecuteAsync(command).ConfigureAwait(false);
return(new IdField {
Id = orderId
});
}
public string OrderConsole(int id, OrderInputModel input)
{
input.GetRequestFromReST();
StockBO stock = new StockBO(new Herds(HerdBO.GetXmlEntries()), id, input.Request.order.milk, input.Request.order.skins);
Response.ContentType = "application/json";
Response.StatusCode = (int)stock.data[0];
return((string)stock.data[1]);
}
public string OrderConsole(int id, OrderInputModel input)
{
input.GetRequestFromReST();
StockBO stock = new StockBO(new Herds(HerdBO.GetXmlEntries()), id, input.Request.order.milk, input.Request.order.skins);
Response.ContentType = "application/json";
Response.StatusCode = (int)stock.data[0];
return (string)stock.data[1];
}
public async Task <ActionResult <IdField> > Create([FromBody] OrderInputModel data)
{
var command = _commandBuilder.BuildAddOrderCommand(data);
var orderId = await _commandDispatcher.ExecuteAsync(command).ConfigureAwait(false);
return(StatusCode(StatusCodes.Status201Created, new IdField {
Id = orderId
}));
}
public Order UpdateOrder(OrderInputModel model)
{
var order = GetOrderById(model.OrderId);
order.Address = model.Address;
order.ItemOrders = ConvertToItemOrder(model.Items);
order.PromoCode = model.PromoCode;
_db.SaveChanges();
return(order);
}
public ActionResult PostOrder(long id, [FromBody] OrderInputModel input)
{
try
{
using (_dal)
{
var claim = User.Claims.Where(x => x.Type == ClaimTypes.Sid).FirstOrDefault();
if (claim == null)
{
return(Unauthorized());
}
var idPlayer = long.Parse(claim.Value);
// On récupère la feuille d'ordres ciblée
var ordersSheet = (from s in _dal.OrdersSheets
where s.PlayerId == idPlayer && s.Id == id
select s).FirstOrDefault();
if (ordersSheet == null)
{
return(NotFound());
}
if (ordersSheet.Status != OrdersSheetStatus.Writing)
{
return(StatusCode((int)HttpStatusCode.PreconditionFailed, "Statut incorrect de la feuille d'ordres"));
}
var ordersCount = (from o in _dal.Orders
where o.OrdersSheetId == ordersSheet.Id
select 1).Count();
if (ordersCount >= ordersSheet.MaxOrdersCount)
{
return(BadRequest("Nombre d'ordres max atteint"));
}
var order = new Order()
{
ActionTypeId = input.ActionTypeId,
OrdersSheetId = ordersSheet.Id,
Parameters = input.Parameters,
Rank = input.Rank,
Status = OrderStatus.None
};
_dal.Orders.Add(order);
_dal.SaveChanges();
return(Ok(order));
}
}
catch (Exception)
{
return(StatusCode((int)HttpStatusCode.InternalServerError));
}
}
// POST api/<controller>
public OrderModel Post(OrderInputModel model)
{
try {
_orderHelper = new OrderHelper();
return(_orderHelper.CreateOrder(model));
}
catch (Exception ex) {
return(null);
}
}
public IActionResult AddOrder([FromBody] OrderInputModel order)
{
// Adds a new order associated with the authenticated user, see Models section for reference
if (!ModelState.IsValid)
{
return(BadRequest("Order is not properly constructed!"));
}
_orderService.CreateNewOrder(User.Identity.Name, order);
return(StatusCode(201, order));
}