public int CreateOrder(OrderCreate model)
{
var entity = new Order()
{
OwnerId = _userId,
OrderId = model.OrderId,
CustomerId = model.CustomerId,
StatusId = model.StatusId,
Notes = model.Notes,
SubTotal = model.SubTotal,
Tax = model.Tax,
TotalCost = model.TotalCost,
DateOfOrder = model.DateOfOrder,
DateShipped = model.DateShipped
};
using (var ctx = new ApplicationDbContext())
{
ctx.Orders.Add(entity);
if (ctx.SaveChanges() == 1)
{
return(1);
}
return(0);
}
}
private void CreateOrder(object sender, System.Windows.RoutedEventArgs e)
{
var count = 0;
int.TryParse(CountInput.Text, out count);
var model = new OrderCreate()
{
SessionID = _session.ID,
Count = count
};
var res = RestService.Post("orders", model);
if (res.StatusCode == HttpStatusCode.OK)
{
MessageBox.Show("Заказ был добавлен");
Close();
}
if (res.StatusCode == HttpStatusCode.BadRequest)
{
var modelState = (Dictionary <string, dynamic>)res.Content["ModelState"];
foreach (var error in modelState)
{
MessageBox.Show(error.Value[0]);
}
}
Canceled = false;
}
public async Task <Order> Create(OrderCreate orderIn, string groupId)
{
var order = Order.FromCreate(orderIn, groupId);
await _orders.InsertOneAsync(order);
return(order);
}
public async Task <ActionResult> Create(OrderCreate note)
{
if (!ModelState.IsValid)
{
ViewBag.CustomerId = await GetCustomerAsync();
ViewBag.RestaurantId = await GetRestaurantAsync();
ViewBag.DriverId = await GetDriverAsync();
ViewBag.MenuId = await GetMenuAsync();
return(View(note));
}
var service = CreateOrderService();
if (await service.CreateOrderAsync(note))
{
TempData["SaveResult"] = " Order was created.";
return(RedirectToAction("Index"));
}
ModelState.AddModelError("", "Order could not be created.");
ViewBag.CustomerId = await GetCustomerAsync();
ViewBag.RestaurantId = await GetRestaurantAsync();
ViewBag.DriverId = await GetDriverAsync();
ViewBag.MenuId = await GetMenuAsync();
return(View(note));
}
public async Task <ActionResult <OrderResponse> > AddOrder([FromBody] OrderCreate order)
{
try
{
Order dbOrder = _mapper.Map <Order>(order);
User currentUser = await GetUser();
if (currentUser == null)
{
return(Unauthorized());
}
dbOrder.user = currentUser;
_db.orders.Add(dbOrder);
await _db.SaveChangesAsync();
return(new CreatedAtRouteResult("GetSingleOrder",
new { id = dbOrder.id },
_mapper.Map <OrderResponse>(dbOrder)));
}
catch (Exception e)
{
return(StatusCode(StatusCodes.Status500InternalServerError, e.Message));
}
}
public ActionResult Create(OrderCreate model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var service = CreateOrderService();
var orderedMenuItemId = model.MenuItemId;
var item = service.OrderMenuItemDetail(orderedMenuItemId);
if (item.IsAvailable.Equals(false))
{
return(HttpNotFound("Sorry, This Item Is Out Of Order At The Moment. Please Select Something Else."));
}
else if (item.ServingsInStock < model.Quantity)
{
return(HttpNotFound("Sorry, We Don't Have Enough Of This Item."));
}
else
{
if (service.CreateOrder(model))
{
TempData["SaveResult"] = "Your Order Was Created.";
return(RedirectToAction("Index"));
}
else
{
ViewBag.GuestId = AccessGuestIdList();
ViewBag.MenuItemId = AccessMenuIdList();
ModelState.AddModelError("", "Your Order Could Not Be Created.");
return(View(model));
}
}
//MenuItem item = _db.MenuItems.Find(model.MenuItemId); This Works
//if (item.IsAvailable.Equals(false))
//{
// return HttpNotFound("Sorry, This Item Is Out Of Order At The Moment. Please Select Something Else.");
//}
//else if (item.ServingsInStock < model.Quantity)
//{
// return HttpNotFound("Sorry, We Don't Have Enough Of This Item.");
//}
//else
//{
// if (service.CreateOrder(model))
// {
// TempData["SaveResult"] = "Your Order Was Created.";
// return RedirectToAction("Index");
// }
// else
// return View(model);
//}
}
public async Task <Order> CreateStockroom(OrderCreate orderIn)
{
var order = Order.FromCreateStockroom(orderIn);
await _orders.InsertOneAsync(order);
return(order);
}
public async Task <bool> CreateOrderAsync(OrderCreate model)
{
var entity =
new Order()
{
Username = model.Username,
FirstName = model.FirstName,
LastName = model.LastName,
Address = model.Address,
City = model.City,
State = model.State,
PostalCode = model.PostalCode,
Country = model.Country,
Phone = model.Phone,
Email = model.Email,
Total = model.Total,
OrderDate = model.OrderDate
};
using (var ctx = new ApplicationDbContext())
{
ctx.Orders.Add(entity);
return(await ctx.SaveChangesAsync() == 1);
}
}
public async Task <IActionResult> PostOrder([FromBody] OrderCreate order)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var newOrder = new Order
{
Date = order.Date,
UserId = order.UserId,
ShipmentMethod = order.ShipmentMethod,
GoodsInOrder = new Collection <GoodsInOrder>(
order.GoodsInOrder.Select(g => new GoodsInOrder
{
GoodsId = g.GoodsId,
Price = g.Price,
Quantity = g.Quantity
})
.ToList()
)
};
_context.Orders.Add(newOrder);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetOrder", new { id = newOrder.Id }, order));
}
public async Task <ActionResult> PostAsync([FromBody] OrderCreate order)
{
//if (!this.ModelState.IsValid)
//{
// return this.BadRequest();
//}
var orderServiceModel = this.mapper.Map <OrderServiceModel>(order);
var id = await this.orderService.SaveAsync(orderServiceModel);
return(this.Created("", new { Id = id }));
}
// POST -- Create Order
public bool CreateOrder(OrderCreate model)
{
var entity =
new Order()
{
OrderDateTimeUtc = DateTimeOffset.Now,
GuestId = model.GuestId,
TypeOfOrder = model.TypeOfOrder,
MenuItemId = model.MenuItemId,
Quantity = model.Quantity,
Notes = model.Notes,
};
//Trying
//MenuItem item = new MenuItem();
//var menuItem = item.ServingsInStock -= entity.Quantity;
//return menuItem;
using (var ctx = new ApplicationDbContext())
{
var item = ctx.MenuItems.Single(x => x.MenuItemId == model.MenuItemId);
if (item.ServingsInStock >= model.Quantity)
{
item.ServingsInStock -= entity.Quantity; // Trying this out to see if it fixes a bug
}
if (item.ServingsInStock > 0) // this added && works
{
item.IsAvailable = true; // Trying this
}
else
{
item.IsAvailable = false;
}
// Updating guests so that after first order they're no longer first time
var guest = ctx.Guests.Single(g => g.GuestId == model.GuestId);
if (guest.FirstTime)
{
guest.FirstTime = false;
}
ctx.Orders.Add(entity);
int save = ctx.SaveChanges(); // Need 2 different instances of changes bc one could come from existing guest and another from new guest. If existing guest, then save == 2 changes, and if new guest save == 3
if (save == 2 || save == 3)
{
return(true);
}
else
{
return(false);
}
}
}
public IActionResult Create([FromBody] OrderCreate model)
{
try
{
Order result = _orderService.Create(model);
return(Ok(result));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public ActionResult Post([FromBody] OrderCreate orderCreate)
{
try
{
_orderService.Process(orderCreate.MapOrder(), orderCreate.MapProducts());
return(Ok());
}
catch {
return(BadRequest());
}
}
public IHttpActionResult CreateOrder(OrderCreate order)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
OrderService service = new OrderService();
service.CreateOrder(order);
return(Ok());
}
public static bool OrderMenu(List <OrderData> orderData, List <MenuData> menuData, List <StockData> stockData)
{
Console.Clear();
Console.WriteLine("Order Manager:");
Console.WriteLine("Choose an option:");
Console.WriteLine("1) Add an order");
Console.WriteLine("2) Complete an Order");
Console.WriteLine("3) Cancel an Order");
Console.WriteLine("4) Exit");
Console.WriteLine("Current Orders:");
if (orderData.Count > 0)
{
foreach (OrderData o in orderData)
{
if (o != orderData[0])
{
Console.Write($"{o.order_id} {o.time} ");
foreach (int sk1 in o.order)
{
Console.Write($"{sk1}");
}
Console.WriteLine();
}
}
}
Console.Write("\r\nSelect an option: ");
switch (Console.ReadLine())
{
case "1":
OrderCreate.Create(OrderDataAccess.orderData, MenuDataAccess.menuData, stockData);
// GenericTextProccesor.SaveToTextFile<OrderData>(orderData, "Order.csv");
return(true);
case "2":
OrderComplete.Complete(OrderDataAccess.orderData);
// GenericTextProccesor.SaveToTextFile<OrderData>(orderData, "Order.csv");
return(true);
case "3":
OrderCancel.Cancel(OrderDataAccess.orderData, MenuDataAccess.menuData, StockDataAccess.stockData);
OrderComplete.Complete(OrderDataAccess.orderData);
// GenericTextProccesor.SaveToTextFile<OrderData>(orderData, "Order.csv");
return(true);
case "4":
return(false);
default:
return(true);
}
}
public bool CreateOrder(OrderCreate order)
{
var entity = new Order()
{
CreatedUtc = DateTimeOffset.Now,
CustomerID = order.CustomerID
};
using (var ctx = new ApplicationDbContext())
{
ctx.Orders.Add(entity);
return(ctx.SaveChanges() == 1);
}
}
public IHttpActionResult Post(OrderCreate order)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var service = CreateOrderService();
if (!service.CreateOrder(order))
{
return(InternalServerError());
}
return(Ok());
}
protected void ValidateOrderCreate(OrderCreate orderCreate)
{
try
{
if (string.IsNullOrEmpty(orderCreate.UserId))
{
ThrowError("UserId is required", ErrorNumber.EmptyRequiredField);
}
if (orderCreate.BranchId < 0)
{
ThrowError("Incorrect branchId", ErrorNumber.EmptyRequiredField);
}
if (orderCreate.OrderMeals == null || orderCreate.OrderMeals.Count < 1)
{
ThrowError("OrderMeals cannot be empty", ErrorNumber.EmptyRequiredField);
}
if (!orderCreate.IsPickUp)
{
if (orderCreate.Address == null || string.IsNullOrEmpty(orderCreate.Address.Area) || string.IsNullOrEmpty(orderCreate.Address.Building) || string.IsNullOrEmpty(orderCreate.Address.Floor) || string.IsNullOrEmpty(orderCreate.Address.OfficeNumber))
{
ThrowError("Address cannot be empty in case of delivery", ErrorNumber.EmptyRequiredField);
}
orderCreate.Address.Area = orderCreate.Address.Area.Trim();
orderCreate.Address.Street = orderCreate.Address.Street.Trim();
orderCreate.Address.Building = orderCreate.Address.Building.Trim();
orderCreate.Address.OfficeNumber = orderCreate.Address.OfficeNumber.Trim();
if (!string.IsNullOrEmpty(orderCreate.Address.Latitude))
{
orderCreate.Address.Latitude = orderCreate.Address.Latitude.Trim();
}
if (!string.IsNullOrEmpty(orderCreate.Address.Longitude))
{
orderCreate.Address.Longitude = orderCreate.Address.Longitude.Trim();
}
}
if (!string.IsNullOrEmpty(orderCreate.Notes))
{
orderCreate.Notes = orderCreate.Notes.Trim();
}
}
catch (RestaurantException ex)
{
throw ex;
}
}
public Order Create(OrderCreate model)
{
long adminId = _principalService.GetUserId();
long managerId = _db.Employees.FirstOrDefault(x => x.UserId == adminId).Id;
// Todo: change datetime.now to orderdate by configurations
DateTime orderDate = _db.Configurations.FirstOrDefault().OrdersDate;
int areaGroupId = _db.Areas.FirstOrDefault(x => x.Id == model.AreaId).AreaGroupId;
Record record = _db.Records.FirstOrDefault(x => x.AreaGroupId == areaGroupId && x.RecordDate == orderDate);
Order order = new Order
{
Address = model.Address,
AreaId = model.AreaId,
ClientId = model.ClientId,
CreatedAt = DateTime.Now,
DeliveryPhoneNumber = model.DeliveryNumber,
OrderDate = orderDate,
OrderItemTypeDescription = model.OrderItemDescription,
OrderTotalPrice = model.OrderTotalPrice,
CreatedById = managerId,
OrderNumber = Guid.NewGuid(),
PolicyNumber = model.PolicyNumber,
AddedPrice = model.AddedPrice,
IsActive = true,
OrderStatusId = 2
};
if (record != null)
{
order.RecordId = record.Id;
}
else
{
Record newRecord = new Record
{
AreaGroupId = areaGroupId,
CreatedAt = DateTime.Now,
CreatedById = adminId,
RecordDate = orderDate,
RecordGuid = Guid.NewGuid(),
IsActive = true
};
_db.Records.Add(newRecord);
_db.SaveChanges();
order.RecordId = newRecord.Id;
}
_db.Orders.Add(order);
_db.SaveChanges();
return(order);
}
public async Task <IActionResult> Create()
{
var food = await _foodData.GetFood();
OrderCreate model = new OrderCreate();
food.ForEach(x =>
{
model.FoodItems.Add(new SelectListItem {
Value = x.Id.ToString(), Text = x.Title
});
});
return(View(model));
}
// POST
public bool CreateOrder(OrderCreate model)
{
var entity =
new Order()
{
ShopId = model.ShopId,
CustomerId = model.CustomerId,
TotalPrice = model.TotalPrice,
};
using (var ctx = new ApplicationDbContext())
{
ctx.Orders.Add(entity);
return(ctx.SaveChanges() == 1);
}
}
public async Task <ActionResult> Create(OrderCreate model)
{
if (ModelState.IsValid)
{
if (await _orderService.CreateOrderAsync(model))
{
TempData["SaveResult"] = "Your order was created.";
return(RedirectToAction("Index"));
}
}
ModelState.AddModelError("", "Order could not be created.");
return(View(model));
}
public bool CreateTransaction(OrderCreate model)
{
var entity =
new Order()
{
BoardId = model.BoardId,
CustomerId = model.CustomerId,
DateOfTransaction = model.DateOfTransaction,
};
using (var ctx = new ApplicationDbContext())
{
ctx.Orders.Add(entity);
return(ctx.SaveChanges() == 1);
}
}
public ActionResult Create(OrderCreate model)
{
if (!ModelState.IsValid)
{
ViewBag.SlotId = BuildTimeSlotDropdown(model.Deliver, model.SlotId);
return(View(model));
}
string errorFound = EditItems(model.OrderDetailCategoryList);
if (errorFound != null)
{
ModelState.AddModelError("", errorFound);
ViewBag.SlotId = BuildTimeSlotDropdown(model.Deliver, model.SlotId);
return(View(model));
}
var service = CreateOrderService();
OrderCrtUpdRtnStatus orderRtnStatus = service.CreateOrder(model);
if (orderRtnStatus.OrderHeaderCreated)
{
if (orderRtnStatus.OrderAllDetailCreated)
{
TempData["SaveResult"] = $"Order created - but not all Items were added. Please review the order.";
if (model.IsCust)
{
return(RedirectToAction("Index", "Home"));
}
return(RedirectToAction("Index"));
}
TempData["SaveResult"] = $"Order created";
if (model.IsCust)
{
return(RedirectToAction("Index", "Home"));
}
return(RedirectToAction("Index"));
}
;
ModelState.AddModelError("", "Order could not be created.");
ViewBag.SlotId = BuildTimeSlotDropdown(model.Deliver, model.SlotId);
return(View(model));
}
static void TestOrders()
{
// Get a Random Number Generator.
Random r = new Random();
// Get Customer.
Customer customer = _context.FindCustomerByCnp("1900101123456");
// Get Currencies.
Currency eur = _context.FindCurrencyByCode("EUR");
// List all Orders.
List <Order> list = _context.Orders.ToList();
// Create an Order (Exchange) with 5 Random products.
Order order = new OrderCreate(_context, DateTime.Now)
.SetCustomer(customer)
.SetCurrency(eur)
.AddItemRange(_context.SampleProducts(5).Select(x =>
new OrderItemCreate()
.SetProduct(x)
.SetQuantity(r.Next(-10, 10))
// One can Alter the Price of an Item here.
// If field remains Null, the Price will be inherited from the Product.
//.SetAlterPrice(120)
.Create()))
.Execute();
// We can see that Latest State, Type and Total are computed.
var latestStatus = order.LatestEvent;
var orderType = order.Type;
var totalSum = order.Total;
// Set this Order to "Invoiced".
new OrderEdit(_context, order)
.SetDateTime(DateTime.Now)
.SetStatus(OrderStatus.Invoiced)
.Execute();
// We can see that Latest State is updated.
latestStatus = order.LatestEvent;
orderType = order.Type;
totalSum = order.Total;
list = _context.Orders.ToList();
list = null; // Place to put a break-point.
}
public async Task <bool> CreateOrderAsync(OrderCreate model)
{
var entity =
new Order()
{
DateOfOrder = DateTime.Now,
DeliveryCharge = model.DeliveryCharge,
CustomerId = model.CustomerId,
RestaurantId = model.RestaurantId,
DriverId = model.DriverId,
};
using (var ctx = new ApplicationDbContext())
{
ctx.Orders.Add(entity);
return(await ctx.SaveChangesAsync() == 1);
}
}
public bool CreateOrder(OrderCreate model)
{
Order order = new Order
//var entity = new Order()
{
OwnerId = _userId,
OrderId = model.OrderId,
Comments = model.Comments,
MenuItemId = model.MenuItemId,
CustomerId = model.CustomerId,
};
using (var ctx = new ApplicationDbContext())
{
ctx.Orders.Add(order);
return(ctx.SaveChanges() == 1);
}
}
public IActionResult CreateOrder(OrderCreate orderToCreate) //создание заказа
{
if (ModelState.IsValid)
{
if (!_repository.Orders.IsOrderExists(orderToCreate.Number))
{
if (_repository.Postamats.IsPostamatExists(orderToCreate.PostamatNumber) &&
_repository.Postamats.IsPostamatActive(orderToCreate.PostamatNumber))
{
OrderStore orderToStore = _mapper.Map <OrderStore>(orderToCreate);
_repository.Orders.CreateOrder(orderToStore);
return(NoContent());
}
return(StatusCode(403));
}
}
return(BadRequest());
}
public ActionResult Create(OrderCreate model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var service = CreateTransactionService();
if (service.CreateTransaction(model))
{
TempData["SaveResult"] = "Your transaction was posted.";
return(RedirectToAction("Index"));
}
;
ModelState.AddModelError("", "Transaction could not be posted.");
return(View(model));
}
public ActionResult Create(OrderCreate model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var service = CreateOrderService();
if (service.CreateOrder(model))
{
TempData["SaveResult"] = "Order was created.";
return(RedirectToAction("Index"));
}
;
ModelState.AddModelError("", "Order not be created.");
return(View(model));
}
