public async Task <TableReservation> CreateTableReservationAsync(int numberOfSeats, DateTime date, double hours, string name) { var tables = await _context.Tables .Where(x => x.NumberOfSeats >= numberOfSeats) .OrderBy(x => x.NumberOfSeats) .ToListAsync(); DateTime to = date.AddHours(hours); foreach (var table in tables) { var reservations = await _context.TableReservations .Where(x => x.TableId == table.Id) .ToListAsync(); if (!HasOverlap(date, to, reservations)) { var newReservation = new TableReservation { From = date, To = to, Table = table, Name = name }; _context.TableReservations.Add(newReservation); await _context.SaveChangesAsync(); return(newReservation); } } return(null); }
public async Task <IActionResult> PutTableReservation(long id, TableReservation tableReservation) { if (id != tableReservation.Id) { return(BadRequest()); } _context.Entry(tableReservation).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!TableReservationExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public ActionResult Reserve(int tableId, string year, string month, string day, string returnUrl) { DateTime date; if (!DateTime.TryParse(String.Join("-", year, month, day), out date) || date < DateTime.Today) { TempData["Result"] = Resource.RecordNotFound; return Redirect(returnUrl ?? Url.Action("Index")); } else { if (db.TableReservations.Any(tr => tr.TableId == tableId && tr.Date.Day == date.Day && tr.Date.Month == date.Month && tr.Date.Year == date.Year)) { var alreadyReserved = Resource.AlreadyReserved; if (Request.IsAjaxRequest()) { return Content(alreadyReserved); } TempData["Result"] = alreadyReserved; return Redirect(returnUrl ?? Url.Action("Index")); } var reservation = new TableReservation(); reservation.Date = date; reservation.TableId = tableId; if (Request.IsAjaxRequest()) { return PartialView("_ReserveForm", reservation); } return View(reservation); } }
public async Task <TableReservation> CreateCurrentTableReservationAsync(Table table, int hours) { DateTime to = DateTime.Now.AddHours(hours); var reservation = await _context.TableReservations .Where(x => x.TableId == table.Id && x.To > DateTime.Now) .OrderBy(x => x.From) .FirstOrDefaultAsync(); if (reservation == null || reservation.From > to) { var tableEntity = await _context.Tables .Where(x => x.Id == table.Id) .SingleOrDefaultAsync(); reservation = new TableReservation { From = DateTime.Now, To = to, Name = "Unkown", Table = tableEntity }; } else { return(null); } _context.TableReservations.Add(reservation); await _context.SaveChangesAsync(); return(reservation); }
public ActionResult Reserve(TableReservation reservation, string returnUrl) { if (ModelState.IsValid) { if (db.TableReservations.Any(tr => tr.Date == reservation.Date && tr.TableId == reservation.TableId)) { TempData["Result"] = Resource.AlreadyReserved; return Redirect(returnUrl ?? Url.Action("Index")); } db.TableReservations.AddObject(reservation); db.SaveChanges(); var success = String.Format(Resource.ReserveSuccess, reservation.Name, reservation.TableId); if (Request.IsAjaxRequest()) { return Content(success); } TempData["Result"] = success; return Redirect(returnUrl ?? Url.Action("Index")); } else { if (Request.IsAjaxRequest()) { return PartialView("_ReserveForm"); } return View(); } }
public async Task <ActionResult <TableReservation> > PostTableReservation(TableReservation tableReservation) { _context.TableReservations.Add(tableReservation); await _context.SaveChangesAsync(); return(CreatedAtAction("GetTableReservation", new { id = tableReservation.Id }, tableReservation)); }
public List <TableReservation> GetTableResarvations() { Dal dal = new Dal(); SqlCommand sql = dal.GetTableReservations(); List <TableReservation> TableReservations = new List <TableReservation>(); SqlDataReader oReader = sql.ExecuteReader(); { while (oReader.Read()) { TableReservation rest = new TableReservation { reservationID = oReader.GetString(0), dtableID = oReader.GetString(1), personName = oReader.GetString(2), personMail = oReader.GetString(3), personPhoneNumber = oReader.GetString(4), guestAmount = oReader.GetInt32(5), reservationDate = oReader.GetTimeSpan(6), reservationTime = oReader.GetTimeSpan(7) }; TableReservations.Add(rest); } return(TableReservations); } }
public void ConfirmReservTables(int restId, int schemaId, List <int> tablesIds, DateTime date, ApplicationUser user, string name, string phone) { using (GoodTasteContext context = new GoodTasteContext()) { ApplicationUser u = null; if (user != null) { u = context.Users.Find(user.Id); } foreach (var tableId in tablesIds) { Table table = context.Tables.Find(tableId); TableReservation reserv = new TableReservation(); reserv.Table = table; reserv.User = u; reserv.ReservedAndConfirmed = true; reserv.ConfirmedByAdministration = true; reserv.Reserved = false; reserv.Date = date; reserv.ContactInfoName = name.Trim(); reserv.ContactInfoPhone = phone.Trim(); context.TableReservations.Add(reserv); } context.SaveChanges(); } }
public TableReservationDto(TableReservation reservation) { Id = reservation.Id; From = reservation.From; To = reservation.To; Name = reservation.Name; Table = new TableDto(reservation.Table); }
public async Task <TableReservationDto> CreateTableReservationAsync(CreateTableReservationDto dto) { TableReservation created = await _repository .CreateTableReservationAsync(dto.NumberOfSeats, dto.Date.AddHours(1), dto.Hours, dto.Name); if (created == null) { throw new Exception("No available tables."); } return(new TableReservationDto(created)); }
public void RemoveReserv(List <TableReservation> reservs) { using (GoodTasteContext context = new GoodTasteContext()) { foreach (var item in reservs) { TableReservation remove = context.TableReservations.Find(item.Id); context.TableReservations.Remove(remove); } context.SaveChanges(); } }
public void ReservTables(List <TableReservation> reservs) { using (GoodTasteContext context = new GoodTasteContext()) { foreach (var item in reservs) { Table t = context.Tables.Where(x => x.Id == item.Table.Id).FirstOrDefault(); ApplicationUser u = context.Users.Find(item.User.Id); TableReservation r = new TableReservation { Date = DateTime.Now, Reserved = true, ReservedAndConfirmed = false, User = u, Table = t }; t.TableReservation.Add(r); context.TableReservations.Add(r); } context.SaveChanges(); } }
public IActionResult ConfirmReservation(ReservationViewModel reservation) { if (!ModelState.IsValid) { return(RedirectToAction("Error")); } TimeSlot slot = new TimeSlot(); slot.FullDate = reservation.ReservationDate; //Ensure reservation is still available if (ReservationLogic.isAvailable(_context, reservation.GuestAmount, ReservationLogic.getTableCount(_context), slot)) { //Convert out viewmodel to entity model Reservation EntityReservation = new Reservation(); EntityReservation.ReservationId = Guid.NewGuid().ToString(); EntityReservation.BookingUser = reservation.User; EntityReservation.GuestAmount = reservation.GuestAmount; EntityReservation.ReservationTime = reservation.ReservationDate; EntityReservation.Menu = reservation.Menu; EntityReservation.Drink = reservation.Drink; List <Table> desiredTables = ReservationLogic.reserveTables(_context, reservation.GuestAmount, slot); foreach (Table table in desiredTables) { TableReservation tableReservation = new TableReservation(); tableReservation.Reservation = EntityReservation; tableReservation.ReservationId = EntityReservation.ReservationId; tableReservation.Table = table; tableReservation.TableId = table.TableId; EntityReservation.TableReservations.Add(tableReservation); } //Save entity to db _context.Add(EntityReservation); _context.SaveChanges(); return(View()); } else { return(RedirectToAction("Error")); } }
//id == reservation id //manager will choose tables to add reservations public async Task <IActionResult> Tables(Models.Area.Tables m) { try { int id = m.Reservation.Id; //clear the previous selected tables from the res var reservation = await _db.Reservations .Include(r => r.TableReservations) .ThenInclude(tr => tr.Table) .FirstOrDefaultAsync(r => r.Id == id); //first remove all existing tables assigned to the reservation reservation.TableReservations.Clear(); await _db.SaveChangesAsync(); var endTime = reservation.EndTime;//get end time //add the selected tables to db var selectedTables = m.TableDetails.Where(to => to.Selected); foreach (var st in selectedTables) { //set the selected table to the tableReservations-connection table var tr = new TableReservation { TableId = st.TableId }; //add the connection table to reservation reservation.TableReservations.Add(tr); } await _db.SaveChangesAsync(); return(RedirectToAction("Index", "Reservation", new { Area = "Staff" })); } catch (Exception) { return(View(m)); } }
static void Main(string[] args) { Console.OutputEncoding = System.Text.Encoding.UTF8; // FILL THE RESERVATION TABLE TIMESLOTS AND DISH MENU FillTables(); FillDishMenu(); // SET THE DAILY AND MONTHLY DISH RANDOMLY Random rand = new Random(); var dishes = Dish.DishDict.Values.ToList(); Dish.DailyDish = dishes[rand.Next(0, dishes.Count)]; Dish.MonthlyDish = dishes[rand.Next(0, dishes.Count)]; // INPUT FAKE RESERVATION Account acc = Accounts.AccountsDict["admin"]; Table tab = Table.Tables[0]; DateTime time = TableReservation.GetNextNDays(1)[0]; new TableReservation(tab, acc, time, TimeSlots.FirstSlot); // INPUT FAKE ORDER Order order = new Order(new List <OrderItem> { new OrderItem(Dish.DishDict[2006], 2), new OrderItem(Dish.DishDict[4001], 1), new OrderItem(Dish.DishDict[6011], 1), }, DateTime.Today); order.MakeOrder(acc); // RUN TUI TextUserInterface TUI = new TextUserInterface(); TUI.DisplayWelcomeScreen(); }
public async Task <bool> SendTableDataToServer(TableReservation item, string action) { var url = GenerateUrl(item.id, action, "restaurant", settings.TableWelcomeMessage); var result = await gate.SetTableReservationToServer(url); if (result) { url = GenerateUrl(item.id, "printed", "restaurant", ""); result = await gate.ChangePrintStatus(url); if (result) { //TableItems.Remove(item); } } else { //TODO } return(result); }
public async Task <object> AssignTable([FromBody] AssignTableParam p) { // get data from fullCalendar int resID = p.ReservationId; int dropTableId = p.DropTableId; int tableSitId = p.TableSittingId; // search for reservation startTime, sittingId and tableSitting DateTime resDateTime = _db.Reservations .Where(r => r.Id == resID) .Select(r => r.StartDateTime) .FirstOrDefault(); int sittingID = _db.Sittings .Where(s => resDateTime >= s.StartDateTime && resDateTime <= s.EndDateTime) .Select(s => s.Id) .First(); int tableSittingId = _db.TableSittings .Where(ts => ts.SittingId == sittingID) .Where(ts => ts.TableId == dropTableId) .Select(ts => ts.Id) .First(); //Add reservationId and tableSittingId to the tableReservation table in Database var tr = new TableReservation { ReservationId = resID, TableSittingId = tableSittingId }; _db.TableReservations.Add(tr); // change reservation status to Confirmed var res = _db.Reservations.FirstOrDefault(r => r.Id == resID); if (res.ReservationStatusId == 1) { res.ReservationStatusId = 2; } await _db.SaveChangesAsync(); return(Ok(tr)); }
public List <TableReservation> GetTableResarvations() { Dal dal = new Dal(); SqlCommand sql = dal.GetTableReservations(); List <TableReservation> TableReservations = new List <TableReservation>(); using (SqlDataReader oReader = sql.ExecuteReader()) { while (oReader.Read()) { TableReservation rest = new TableReservation(); rest.reservationID = oReader.GetString(0); rest.dtableID = oReader.GetString(1); rest.personName = oReader.GetString(2); rest.personMail = oReader.GetString(3); rest.personPhoneNumber = oReader.GetString(4); rest.guestAmount = oReader.GetInt32(5); rest.reservationDate = oReader.GetDateTime(6); rest.reservationTime = oReader.GetDateTime(7); TableReservations.Add(rest); } return(TableReservations); } }
public ActionResult Manage([Bind(Include = "TableReservationId,TableId,TDateTime,PersonName,Contact,NoOfPax")] TableReservation t) { return(base.BaseSave <TableReservation>(t, t.TableReservationId > 0, new { Lid = db.ExecuteScalar <int>("Select LocationId from Tables where tableId=@0", t.TableId) })); }
public ReservedController(ILogger <ReservedController> logger, TableReservation tableReservation) { _logger = logger; _tableReservation = tableReservation; }