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;
}
