public IEnumerable <OrderLineItem> GetOrderLineItemsById(int id)
{
var ordDb = new OrderDb();
var items = ordDb.GetOrderLineItemsById(id);
return(items);
}
public async Task <JsonResult> OrderInformation(int id, int UserId)
{
OrderDb order = await db.Orders.FirstOrDefaultAsync(f => f.Id == id && f.UserDbId == UserId && f.Ordered == false && f.isPaid == true);
if (order != null)
{
return(Json(new
{
success = true,
OrderPrice = order.Price,
OrderCount = order.Quantity,
OrderComent = order.Coment,
OrderDate = order.CreatedDate.ToString(),
//OrderCategotyName = order.Category.CategoryName,
//OrderCategotyId = order.CategoryId
//OrderCountryName = order.Country.CauntryName,
//OrderCountryId = order.CountryId,
//OrderCurrency = order.Country.CountryCurrency.CurrencyName,
}));
}
return(Json(new
{
success = true,
alertMesage = "Gonderdiyiniz Sifaris Tapilmadi"
}));
}
private static void DumpDatabases()
{
using (var financeDb = new FinanceDb())
{
foreach (Account account in financeDb.Accounts)
{
WriteLine("Account {0} ({1}) - Balance ${2}",
account.Number,
account.Name,
account.Balance);
WriteLine(
"------------------------------------------------------------------------------------------");
foreach (Operation operation in account.Operations)
{
WriteLine("{0} - {1} - ${2}", operation.Time, operation.Description, operation.Amount);
}
WriteLine();
}
}
using (var orderDb = new OrderDb())
{
WriteLine("Orders");
WriteLine("----------------------------------------------------------------------------");
foreach (Order order in orderDb.Orders)
{
WriteLine("{0} - {1}", order.Description, order.TotalAmount);
}
}
}
public async Task <ActionResult> Edit(EditOder edit)
{
if (ModelState.IsValid)
{
UserDb UserSession = (UserDb)Session["User"];
OrderDb editOrder = await db.Orders.FirstOrDefaultAsync(f => f.Id == edit.Id && f.UserDbId == UserSession.Id);
if (editOrder != null)
{
editOrder.Link = edit.Link;
editOrder.OrderName = edit.OrderName;
editOrder.Price = edit.Price;
editOrder.Coment = edit.Coment;
editOrder.CategoryId = edit.CategoryId;
await db.SaveChangesAsync();
return(RedirectToAction("IndexUser"));
}
else
{
return(RedirectToAction("IndexUser"));
}
}
return(RedirectToAction("IndexUser"));
}
public IActionResult Index()
{
var orderDb = new OrderDb();
var order = orderDb.GetNewOrder();
return(View(order));
}
/// <summary>
/// Searches for users by console input.
/// Search by first name and last name.
/// Displays user details and order history.
/// </summary>
public void SearchCustomer()
{
try
{
//Console input.
Console.Write("Enter User First Name:\n> ");
string firstName = Console.ReadLine();
Console.Write("Enter User Last Name:\n> ");
string lastName = Console.ReadLine();
Console.Clear();
//Searches for users with inputted first name and last name.
var users = new UserDb().SearchByName(firstName, lastName);
Console.WriteLine("Displaying Found Users:\n");
foreach (var user in users)
{
//Displays user details.
Console.WriteLine(user);
//Loads orders references the user and displays.
var orders = new OrderDb().GetUserHistory(user.Id);
foreach (var order in orders)
{
Console.WriteLine(order);
}
Console.WriteLine();
}
Continue();
}
catch (System.Exception)
{
CommandError();
}
}
public async Task <IActionResult> Edit(int id, [Bind("OrderId,UserId,LocId,Opizza1,Opizza2,Opizza3,Opizza4,Opizza5,Opizza6,Opizza7,Opizza8,Opizza9,Opizza10,Opizza11,Opizza12,TimeofOrder,OrderTotalPrice")] OrderDb orderDb)
{
if (id != orderDb.OrderId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(orderDb);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!OrderDbExists(orderDb.OrderId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["LocId"] = new SelectList(_context.LocationDb, "LocationId", "LocationId", orderDb.LocId);
ViewData["UserId"] = new SelectList(_context.UserDb, "UserId", "UserId", orderDb.UserId);
return(View(orderDb));
}
public ModelLibrary.Order GetOrderById(int id)
{
var ordDb = new OrderDb();
var order = ConvertOrderToModel(ordDb.GetOrderById(id));
order.ItemsList = ConvertOrderLineItemsToModel(GetOrderLineItemsById(id));
return(order);
}
public int AddOrder(ModelLibrary.Order order)
{
var ordDb = new OrderDb();
var dbOrder = ConvertOrder(order);
dbOrder.OrderLineItems.AddRange(ConvertOrderLineItemsToDb(order));
return(ordDb.AddOrder(dbOrder));
}
public void AddOrder(string name, DateTime orderDate)
{
var order = new OrderDb();
order.Juice = _context.Juices.Single(j => j.Name == name);
order.OrderDateTime = orderDate;
_context.Orders.Add(order);
_context.SaveChanges();
}
public async Task <Guid> CreateOrderAsync(NewOrder newOrderRequest, CancellationToken token = default)
{
var dbOrder = new OrderDb(newOrderRequest.OrderUid, newOrderRequest.CustomerUid, newOrderRequest.OrderCreateRequestDate);
_orderDb.Orders.Add(dbOrder);
await _orderDb.SaveChangesAsync(token);
return(newOrderRequest.OrderUid);
}
public Guid CreateOrder(NewOrder newOrderRequest)
{
var dbOrder = new OrderDb(newOrderRequest.OrderUid, newOrderRequest.CustomerUid, newOrderRequest.OrderCreateRequestDate);
_orderDb.Orders.Add(dbOrder);
_orderDb.SaveChanges();
return(newOrderRequest.OrderUid);
}
public ActionResult Create(CreateOrderView createOrder)
{
try
{
if (ModelState.IsValid)
{
UserDb UserSession = (UserDb)Session["User"];
var country = db.Countries.FirstOrDefault(f => f.Id == createOrder.CountryId);
var user = db.Users.FirstOrDefault(f => f.Id == UserSession.Id);
if (country != null && user != null)
{
OrderDb order = new OrderDb();
order.CountryId = createOrder.CountryId;
order.UserDbId = user.Id;
for (var i = 0; i < createOrder.Link.Length; i++)
{
if (String.IsNullOrWhiteSpace(createOrder.Link[i]) ||
String.IsNullOrWhiteSpace(createOrder.Coment[i]) ||
createOrder.Price[i] <= 0 || createOrder.Quantity[i] < 1)
{
ViewBag.Categories = db.Categories.ToList();
ViewBag.Country = db.Countries.Where(w => w.IsActive == true).ToList();
return(View());
}
else
{
order.OrderName = createOrder.OrderName[i];
order.Link = createOrder.Link[i];
order.Price = createOrder.Price[i] * createOrder.Quantity[i];
order.Quantity = createOrder.Quantity[i];
order.Coment = createOrder.Coment[i];
order.isUrgent = createOrder.isUrgent[i];
order.CategoryId = createOrder.CategoryId[i];
order.CreatedDate = DateTime.Now;
order.isPaid = false;
db.Orders.Add(order);
db.SaveChanges();
}
}
}
ViewBag.Categories = db.Categories.ToList();
ViewBag.Country = db.Countries.Where(w => w.IsActive == true).ToList();
return(RedirectToAction("IndexUser"));
}
ViewBag.Categories = db.Categories.ToList();
ViewBag.Country = db.Countries.Where(w => w.IsActive == true).ToList();
return(View());
}
catch (Exception)
{
ViewBag.Country = db.Countries.Where(w => w.IsActive == true).ToList();
ViewBag.Categories = db.Categories.ToList();
return(View());
}
}
public static void PlaceOrder(string description, decimal amount)
{
using (var orderDb = new OrderDb())
{
orderDb.Orders.Add(new Order
{
Description = description,
TotalAmount = amount
});
orderDb.SaveChanges();
}
}
public async Task <IActionResult> Create([Bind("OrderId,UserId,LocId,Opizza1,Opizza2,Opizza3,Opizza4,Opizza5,Opizza6,Opizza7,Opizza8,Opizza9,Opizza10,Opizza11,Opizza12,TimeofOrder,OrderTotalPrice")] OrderDb orderDb)
{
if (ModelState.IsValid)
{
_context.Add(orderDb);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["LocId"] = new SelectList(_context.LocationDb, "LocationId", "LocationId", orderDb.LocId);
ViewData["UserId"] = new SelectList(_context.UserDb, "UserId", "UserId", orderDb.UserId);
return(View(orderDb));
}
public IEnumerable <ModelLibrary.Order> GetAllOrdersByRestaurant(int restaurantId)
{
var orderDb = new OrderDb();
var orderCtrl = new OrderCtrl();
var dbOrders = orderDb.GetAllRestaurantOrders(restaurantId);
var orderList = new List <ModelLibrary.Order>();
foreach (var order in dbOrders)
{
var modelOrderList = orderCtrl.ConvertOrderToModel(order);
orderList.Add(modelOrderList);
}
return(orderList);
}
/// <summary>
/// Displays all <c>Order</c> in the database which references the current <c>User</c>.
/// </summary>
public void ViewOrderHistory()
{
try
{
//Loads orders from database.
ICollection <Order> orderHistory = new OrderDb().GetUserHistory(UI.User.Id);
Console.WriteLine("Showing Order History\n");
foreach (var order in orderHistory)
{
Console.WriteLine(order);
}
Console.WriteLine();
Continue();
}
catch (System.Exception)
{
CommandError();
}
}
// GET: /ShoppingCart/Pay
public ActionResult Pay(int id)
{
string currectScheme = Request.IsHttps ? Uri.UriSchemeHttps : Uri.UriSchemeHttp;
var orderDb = new OrderDb();
var order = orderDb.GetNewOrder();
var paymentUrl = new PaymentUrl()
{
Success = Url.Action("PaymentSuccess", "ShoppingCart", null, currectScheme),
Fail = Url.Action("PaymentFail", "ShoppingCart", null, currectScheme)
};
var paymentProvider = new PaymentProvider(_optionsAccessor);
var hostOnlinePaymentUrl =
paymentProvider.GetPaymentExpressHostUrl(paymentUrl, order);
return(Redirect(hostOnlinePaymentUrl));
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, OrderDb db)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseHttpsRedirection();
app.UseRouting();
app.UseAuthentication();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
}
public async Task <IActionResult> CustomerInfo(CustomerInfomation info)
{
var uSearch = await _userManager.GetUserAsync(HttpContext.User);
ApplicationUser user = new ApplicationUser()
{
Id = uSearch.Id,
Email = uSearch.Email,
UserName = uSearch.UserName
};
if (!ModelState.IsValid)
{
Console.WriteLine("Completed");
await OrderDb.CompleteOrder(_context, info, user);
CartHelper.ClearCookie(_accessor);
return(RedirectToAction("Index", "Home"));
}
return(View(info));
}
public void Add_Order_To_Database_Test()
{
//Setup
var ordCtrl = new OrderCtrl();
var ordDb = new OrderDb();
var dt = new DateTime(2018, 11, 08, 12, 22, 33);
var resDt = new DateTime(2018, 11, 08, 18, 00, 00);
var oli = new List <OrderLineItem>();
var item = new ModelLibrary.Item();
item.Id = 1000000;
oli.Add(new OrderLineItem(item, 2));
var order = new Order
{
OrderId = (ordCtrl.GetLastOrderIdentity() + 1).ToString(),
CustomerId = "1000000",
RestaurantId = "1000000",
DateTime = "2018-11-08 12:22:33",
ReservationDateTime = "2018-11-08 18:00:00",
ItemsList = oli,
NoSeats = "2",
Payment = "200.00",
Accepted = false
};
//Act
var oliList = ordCtrl.ConvertOrderLineItemsToDb(order);
var dbOrder = ordCtrl.ConvertOrder(order);
for (var i = 0; i < dbOrder.OrderLineItems.Count - 1; i++)
{
dbOrder.OrderLineItems.Add(oliList[i]);
}
ordDb.AddOrder(dbOrder);
//Assert
Assert.IsTrue(ordCtrl.GetLastOrderIdentity() == Convert.ToInt32(order.OrderId));
}
private static void CreateDatabases()
{
string dataDirectory = Path.Combine(Path.GetDirectoryName(Environment.GetCommandLineArgs()[0]));
AppDomain.CurrentDomain.SetData("DataDirectory", dataDirectory);
using (var financeDb = new FinanceDb())
{
if (!financeDb.Database.CreateIfNotExists())
{
financeDb.Operations.RemoveRange(financeDb.Operations);
financeDb.Accounts.RemoveRange(financeDb.Accounts);
}
financeDb.Accounts.Add(new Account
{
Name = "IT Department",
Number = ItDepartment
});
financeDb.Accounts.Add(new Account
{
Name = "HR Department",
Number = HrDepartment,
Balance = 500000
});
financeDb.SaveChanges();
}
using (var orderDb = new OrderDb())
{
if (!orderDb.Database.CreateIfNotExists())
{
orderDb.Orders.RemoveRange(orderDb.Orders);
orderDb.SaveChanges();
}
}
}
/// <summary>
/// Accepts console input.
/// Instantiates new <c>Order</c> instances which reference <c>Product</c> in the current inventory.
/// Decrements product quantity in database.
/// </summary>
public void PlaceOrders()
{
try
{
CurrentLocation();
Console.WriteLine("0:\tReturn");
DisplayInventory();
Console.Write("\nExample: 42 12, 13 2, 889 3\nEnter ID Quantity of Products Separated By Commas:\n> ");
//Console input.
var input = Console.ReadLine();
Console.Clear();
//0: Return
if (input == "0")
{
Continue();
return;
}
//Creates new order instances and inserts into database.
var ordersPlaced = new OrderDb().PlaceOrders(input, UI.User.Id, UI.Location.Id);
//Displays Order details.
Console.WriteLine("Orders placed.\n");
double total = 0;
foreach (var order in ordersPlaced)
{
total += Double.Parse(order.Product.Price) * order.Quantity;
Console.WriteLine(order);
}
Console.WriteLine($"Total Price:\t${String.Format("{0:0.00}", total)}\n");
Continue();
}
catch (System.Exception)
{
CommandError();
}
}
public OrderBs()
{
orderDb = new OrderDb();
}
public void UpdateOrder(Order order)
{
var ordDb = new OrderDb();
ordDb.UpdateOrder(order);
}
public int GetLastOrderIdentity()
{
var ordDb = new OrderDb();
return(ordDb.GetLastOrderIdentity());
}
public void AddItemToOrder(int orderId, int itemId)
{
var ordDb = new OrderDb();
ordDb.AddItemToCart(orderId, itemId);
}
public OrderRepo(OrderDb context)
{
this.context = context;
}
internal OrderRepository(OrderDb context)
{
this.db = context;
}
public OrderRepository()
{
this.db = new OrderDb();
}