public async Task <string> CreateAsync(NewOrderDTO newOrder)
{
ValidateNewOrder(newOrder);
var payload = new MessageBrokerEnvelope <NewOrderDTO>(MessageTypes.NewOrder, newOrder);
await _messageBroker.SendMessageAsync("new-orders", payload);
return(payload.RequestId);
}
/// <summary>
/// Creates a new order
/// </summary>
/// <param name="orderDTO">information needed to create a new order</param>
/// <returns>The newly created order's order number</returns>
public int CreateOrder(NewOrderDTO newOrderDTO)
{
// this method is used to validate incoming data - NEVER TRUST DATA COMING FROM A UI
int order_number = -1;
// although we list the price of items in the UI, we never assume that the price being passed in is correct.
// we only pass in the product id, and then we lookup the price to ensure its accuracy
// create the orderDTO for persistence and populate its properties
OrderDTO orderDTO = new OrderDTO()
{
customer_id = newOrderDTO.customer_id,
order_date = newOrderDTO.order_date,
staff_id = newOrderDTO.staff_id,
store_id = newOrderDTO.store_id,
};
// now we'll use a method to get the order status
// a method is the preferred way, as maybe there is some business
// logic to determine was a new order's status is based on certain parameters
orderDTO.order_status = (int)GetNewOrderStatus();
//save to the persistence store, and get the order number back?
order_number = _orderDAO.CreateOrder(orderDTO);
// this is an unfortunate step - having to put the order_number into the DTO. It's a little bit of data logic leaking into the
// business logic. But it unfortunately is necessary when not using an advanced framework for persistence
orderDTO.order_number = order_number;
// now to populate items
OrderItemDTO orderItemDTO;
IList <OrderItemDTO> items = new List <OrderItemDTO>();
foreach (NewOrderItemDTO item in newOrderDTO.items)
{
var product = _productService.GetByID(item.product_id);
orderItemDTO = new OrderItemDTO()
{
product_id = item.product_id,
price = product.list_price,
quantity = item.quantity,
order_number = order_number
};
items.Add(orderItemDTO);
}
//now save the items to the persistence store
_orderItemDAO.CreateOrder(items);
OnOrderCreated(orderDTO, items);
return(order_number);
}
public OrderDTO CreateOrder(NewOrderDTO order)
{
var dbOrder = Mapper.Map <Order>(order);
var addedOrder = _dbContext.Orders.Add(dbOrder);
_dbContext.SaveChanges();
return(Mapper.Map <OrderDTO>(addedOrder));
}
public IActionResult addPizzaOrder(NewOrderDTO newOrderDto)
{
var SINGLE_ORDER_TIME = 30;
var time = SINGLE_ORDER_TIME;
var order = new Order();
order.OrderStatusName = Dto.OrderStatus.IN_REALIZATION.ToString();
if (newOrderDto.payOnline)
{
order.OrderStatusName = Dto.OrderStatus.WAITING_FOR_PAYMENT.ToString();
}
order.Phone = newOrderDto.Phone;
try
{
order.Price = getOrderPrice(newOrderDto.PizzaDefinition);
if (order.Price <= 0)
{
return(BadRequest());
}
}
catch (BadRequestException ex)
{
return(BadRequest());
}
_context.Order.ToList().ForEach(it =>
{
if (it.OrderStatusName != Dto.OrderStatus.DELIVERED.ToString())
{
time += SINGLE_ORDER_TIME;
}
});
order.PizzaDefinition = JsonConvert.SerializeObject(newOrderDto.PizzaDefinition);
order.Uid = Guid.NewGuid().ToString();
//order.Phone = "";
//order.Uid = "1";
//order.OrderStatusName = "";
//order.PizzaDefinition = "";
//order.Price = 10;
_context.Order.Add(order);
_context.SaveChanges();
return(Ok(new NewOrderResponseDTO()
{
time = time,
uid = order.Uid
}
));
}
private async Task <Order> SaveNewOrderAsync(NewOrderDTO newOrder)
{
var newOrderModel = _mapper.Map <NewOrderDTO, Order>(newOrder);
newOrderModel.CreatedAt = newOrderModel.LastUpdatedAt = DateTime.Now;
newOrderModel.Status = OrderStatus.New;
foreach (var orderItem in newOrderModel.Items)
{
orderItem.Status = OrderItemStatus.New;
}
return(await _unitOfWork.OrderRepository.CreateAsync(newOrderModel));
}
/// <summary>
/// creates an order from the form
/// </summary>
private void CreateOrder()
{
NewOrderDTO newOrderDTO = CreateOrderDTO();
try
{
_newOrderCreator.CreateOrder(newOrderDTO);
MessageBox.Show("Order created successfully.", "Order Created", MessageBoxButtons.OK, MessageBoxIcon.Information);
Close();
}
catch (Exception ex)
{
MessageBox.Show("An error occurred while creating this order: " + ex.Message, "Error Occurred", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
/// <summary>
/// Creates the new order DTO
/// </summary>
private NewOrderDTO CreateOrderDTO()
{
StaffViewModel selected_staff = (StaffViewModel)cbStaff.SelectedItem;
StoreViewModel selected_store = (StoreViewModel)cbStore.SelectedItem;
ProductViewModel selected_product = (ProductViewModel)lstBxProducts.SelectedItem;
CustomerViewModel selected_customer = (CustomerViewModel)lstBxCustomers.SelectedItem;
int quantity = Convert.ToInt32(txtQuantity.Text);
NewOrderDTO newOrderDTO = new NewOrderDTO()
{
staff_id = selected_staff.StaffID,
customer_id = selected_customer.CustomerID,
order_date = DateTime.Now,
store_id = selected_store.StoreID
};
newOrderDTO.items.Add(CreateOrderItemDTO(selected_product, quantity));
return(newOrderDTO);
}
public ActionResult CreateOrder(UWAdventure.WebApp.Models.NewOrderModel formdata)
{
NewOrderDTO dto = new NewOrderDTO();
dto.customer_id = formdata.Customer;
dto.store_id = formdata.SelectedStore;
dto.order_date = DateTime.Now;
dto.staff_id = formdata.SalesAssociate;
NewOrderItemDTO item = new NewOrderItemDTO();
item.product_id = formdata.Product;
item.quantity = formdata.Quantity;
dto.items.Add(item);
NewOrderCreator order_creator = new NewOrderCreator();
var order_number = order_creator.CreateOrder(dto);
return(RedirectToAction("AfterOrder", new { o = order_number }));
}
public IHttpActionResult CreateNewOrder(NewOrderDTO neworder)
{
// we don't have any products in the dto
if (neworder.OfferIds.Count == 0)
{
return(BadRequest("No Products Ids have been provided"));
}
var company = _context.Companies.Single(c => c.ID == neworder.CompanyId);
// if company id is not valid
if (company == null)
{
return(BadRequest("CompanyId is not Valid"));
}
var offers = _context.Offers.Where(p => neworder.OfferIds.Contains(p.ID)).ToList();
foreach (var i in offers)
{
if (i.NumberAvailable == 0)
{
return(BadRequest("This product is unavailable"));
}
i.NumberAvailable--;
var order = new Order
{
Company = company,
Offer = i,
Date_Ordered = DateTime.Now
};
_context.Orders.Add(order);
}
_context.SaveChanges();
return(Ok());
}
public Zamowienie PostOrder(int IdKlient, NewOrderDTO NewOrder)
{
Klient klient = context.Find <Klient>(IdKlient);
if (klient == null)
{
return(null);
}
Zamowienie zamowienie = new Zamowienie
{
DataPrzyjecia = NewOrder.dataPrzyjecia,
Klient = klient,
Uwagi = NewOrder.uwagi
};
context.Zamowienies.Add(zamowienie);
foreach (NewOrderDTO.NewOrderWyrob Wyrob in NewOrder.wyroby)
{
WyrobCukierniczy WyrobCukierniczy;
try
{
WyrobCukierniczy = context.WyrobCukierniczies
.Where <WyrobCukierniczy>(item => item.Nazwa.Equals(Wyrob.wyrob))
.First();
} catch (InvalidOperationException e) { return(null); };
// if (WyrobCukierniczy == null) return null;
context.Zamowienie_WyrobCukierniczies.Add(new Zamowienie_WyrobCukierniczy
{
WyrobCukierniczy = WyrobCukierniczy,
Zamowienie = zamowienie,
Ilosc = Wyrob.ilosc,
Uwagi = Wyrob.uwagi
});
}
context.SaveChanges();
return(zamowienie);
}
/// <summary>
/// Runs the order form in the UI
/// </summary>
private static void CreateOrderForm()
{
int store_id, staff_id, product_id, customer_id, quantity;
if (_storeViewer == null)
{
_storeViewer = new StoreViewer();
}
if (_staffViewer == null)
{
_staffViewer = new StaffViewer();
}
if (_productViewer == null)
{
_productViewer = new ProductViewer();
}
if (_customerViewer == null)
{
_customerViewer = new CustomerViewer();
}
if (_newOrderCreator == null)
{
_newOrderCreator = new NewOrderCreator();
}
IList <StaffViewModel> staff;
IList <StoreViewModel> stores = _storeViewer.GetAllStores();
IList <CustomerViewModel> customers = _customerViewer.GetRandom10();
IList <ProductViewModel> products = _productViewer.GetRandom10();
WriteHeader();
WriteOrderFormHeader();
Console.WriteLine("Select store:");
Console.WriteLine("---------------");
for (var i = 0; i < stores.Count; i++)
{
Console.WriteLine("{0}. {1}", i + 1, stores[i].Name);
}
CommandPrompt("Select store");
string str_store_id = Console.ReadLine();
//validate the incoming store_id
if (!Int32.TryParse(str_store_id, out store_id) || store_id > stores.Count || store_id < 1)
{
Console.WriteLine("Invalid store entry. Press any key...");
Console.ReadKey();
return;
}
//store_id is valid - grab employees
staff = _staffViewer.GetAllEmployesByStore(store_id);
//write the employee info onscreen
WriteHeader();
WriteOrderFormHeader();
Console.WriteLine("Select salesperson:");
Console.WriteLine("--------------------");
for (var i = 0; i < staff.Count; i++)
{
Console.WriteLine("{0}. {1} {2}", i + 1, staff[i].FirstName, staff[i].LastName);
}
CommandPrompt("Select salesperson");
string str_staff_id = Console.ReadLine();
//validate the incoming staff_id
if (!Int32.TryParse(str_staff_id, out staff_id) || staff_id > staff.Count || staff_id < 1)
{
Console.WriteLine("Invalid salesperson entry. Press any key...");
Console.ReadKey();
return;
}
//staff_id is valid - print out customers
WriteHeader();
WriteOrderFormHeader();
Console.WriteLine("Select customer:");
Console.WriteLine("--------------------");
for (var i = 0; i < customers.Count; i++)
{
Console.WriteLine("{0}. {1} {2}", i + 1, customers[i].FirstName, customers[i].LastName);
}
CommandPrompt("Select customer");
string str_customer_id = Console.ReadLine();
//validate the incoming customer_id
if (!Int32.TryParse(str_customer_id, out customer_id) || customer_id > customers.Count || customer_id < 1)
{
Console.WriteLine("Invalid customer entry. Press any key...");
Console.ReadKey();
return;
}
//customer_id is valid - print out products
WriteHeader();
WriteOrderFormHeader();
Console.WriteLine("Select product:");
Console.WriteLine("--------------------");
for (var i = 0; i < products.Count; i++)
{
Console.WriteLine("{0}. {1}", i + 1, products[i].Name);
}
CommandPrompt("Select product");
string str_product_id = Console.ReadLine();
//validate the incoming product_id
if (!Int32.TryParse(str_product_id, out product_id) || product_id > products.Count || product_id < 1)
{
Console.WriteLine("Invalid product entry. Press any key...");
Console.ReadKey();
return;
}
//product_id is valid - print out quantity
WriteHeader();
WriteOrderFormHeader();
Console.WriteLine("Select quantity:");
string str_quantity = Console.ReadLine();
//validate the incoming product_id
if (!Int32.TryParse(str_quantity, out quantity) || quantity < 1)
{
Console.WriteLine("Invalid quantity. Press any key...");
Console.ReadKey();
return;
}
//all inputs valid - show an order summary screen
WriteHeader();
WriteOrderFormHeader();
Console.WriteLine("Order Details:");
Console.WriteLine("----------------");
Console.WriteLine("Entered by {0} {1} at {2}", staff[staff_id - 1].FirstName, staff[staff_id - 1].LastName, stores[store_id - 1].Name);
Console.WriteLine("Order for {0} {1}", customers[customer_id - 1].FirstName, customers[customer_id - 1].LastName);
Console.WriteLine(products[product_id - 1].Name);
Console.WriteLine("Qty: {0}", quantity);
CommandPrompt("Is this correct? (Y/N)");
string str_response = Console.ReadLine();
if (str_response.ToLower() == "y")
{
NewOrderDTO newOrder = new NewOrderDTO()
{
store_id = store_id,
staff_id = staff_id,
customer_id = customer_id,
order_date = DateTime.Now,
};
NewOrderItemDTO newItem = new NewOrderItemDTO()
{
product_id = product_id,
quantity = quantity
};
newOrder.items.Add(newItem);
_newOrderCreator = new NewOrderCreator();
try
{
int order_number = _newOrderCreator.CreateOrder(newOrder);
WriteHeader();
WriteOrderFormHeader();
Console.WriteLine("Order #{0} created successfully.", order_number);
Console.WriteLine("Press any key...");
Console.ReadKey();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
return;
}
}
public Task <IActionResult> AddNewOrder([FromBody] NewOrderDTO data)
{
throw new NotImplementedException();
}
public async Task <ActionResult <string> > CreateOrder(NewOrderDTO newOrder)
{
var requestId = await _ordersService.CreateAsync(newOrder);
return(Accepted(requestId));
}
public Task <bool> AddNewOrder(NewOrderDTO data)
{
throw new NotImplementedException();
}
