public async Task<IHttpActionResult> PostStudent(BookingTable booking)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
db.Bookings.Add(booking);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (BookingExists(booking.ID))
{
return Conflict();
}
else
{
throw;
}
}
return CreatedAtRoute("DefaultApi", new { id = booking.ID }, booking);
}
public bool ReloadBooking()
{
var bookings = client.GetOrderBooking(pairs.ToList(), 10);
if (bookings != null && bookings.Any())
{
var tables = new List <BookingTable>();
foreach (var b in bookings)
{
var table = new BookingTable();
string[] spiltIndex = b.Pair.Split('_');
table.Currency = spiltIndex[1];
table.Coin = spiltIndex[0];
table.Pair = b.Pair;
table.Platform = this.platform;
table.Asks = JsonConvert.SerializeObject(b.Ask);
table.Bids = JsonConvert.SerializeObject(b.Bid);
tables.Add(table);
}
var dao = new BookingTableDao();
dao.InsertOrUpdate(tables);
}
return(true);
}
public async Task<IHttpActionResult> PutStudent(string id, BookingTable booking)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
if (id != booking.ID)
{
return BadRequest();
}
db.Entry(booking).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BookingExists(id))
{
return NotFound();
}
else
{
throw;
}
}
return StatusCode(HttpStatusCode.NoContent);
}
public ActionResult ViewDiagram(Reservation form)
{
BookingTable bookT = new BookingTable();
bookT.TablesView = new List <TableView>();
var myTables = db.Tables.Include(b => b.BookingForms).ToList();
Table m = new Table();
foreach (Table table in myTables)
{
bool reservation = table.BookingForms.Any(b => b.ReservationDate == form.ReservationDate);
var tableView = new TableView()
{
CoordinatesTable = table.CoordinatesTable,
TableId = table.TableId,
DimensionTable = table.DimensionTable,
//Status = table.BookingForms.Any(b => b.ReservationDate == form.ReservationDate),
};
if (reservation == true)
{
tableView.Status = Status.Reserved;
}
else
{
tableView.Status = Status.Free;
}
bookT.TablesView.Add(tableView);
}
bookT.Reservation = form;
return(View(bookT));
}
public IHttpActionResult DeleteEventsTable(int id)
{
EventsTable eventsTable = db.EventsTables.Find(id);
var sub = from n in db.SubscriptionTables where n.Event_Id == id select n;
var book = from n in db.BookingTables where n.EventId == id select n;
SubscriptionTable st = (SubscriptionTable)sub.FirstOrDefault();
BookingTable bt = (BookingTable)book.FirstOrDefault();
if (st != null)
{
db.SubscriptionTables.Remove(st);
db.SaveChanges();
}
if (bt != null)
{
db.BookingTables.Remove(bt);
db.SaveChanges();
}
//EventsTable eventsTable = db.EventsTables.Find(id);
if (eventsTable == null)
{
return(NotFound());
}
db.EventsTables.Remove(eventsTable);
db.SaveChanges();
return(Ok(eventsTable));
}
private void refreshDGV()
{
var singlebt = new BookingTable()
{
RoomType = "Single",
AvailableNoOfRooms = dgvlist[0].AvailableNoOfRooms,
RoomRatePerNight = dgvlist[0].RoomRatePerNight,
RoomsRequired = int.Parse(dataGridView1.Rows[0].Cells[3].Value.ToString()),
SubTotal = int.Parse(dataGridView1.Rows[0].Cells[3].Value.ToString()) * dgvlist[0].RoomRatePerNight
};
var doublebt = new BookingTable()
{
RoomType = "Double",
AvailableNoOfRooms = dgvlist[1].AvailableNoOfRooms,
RoomRatePerNight = dgvlist[0].RoomRatePerNight,
RoomsRequired = int.Parse(dataGridView1.Rows[1].Cells[3].Value.ToString()),
SubTotal = int.Parse(dataGridView1.Rows[1].Cells[3].Value.ToString()) * dgvlist[1].RoomRatePerNight
};
dgvlist = new List <BookingTable>();
dgvlist.Add(singlebt);
dgvlist.Add(doublebt);
dataGridView1.DataSource = null;
dataGridView1.DataSource = dgvlist;
updateValuelabel();
}
public IHttpActionResult PutBookingTable(int id, BookingTable bookingTable)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != bookingTable.Ticket_Id)
{
return(BadRequest());
}
db.Entry(bookingTable).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!BookingTableExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <IActionResult> Create(Booking booking, int[] tableId)
{
if (ModelState.IsValid)
{
User user = await _userManager.FindByIdAsync(_userManager.GetUserId(User));
if (User.IsInRole(Convert.ToString(Roles.SuperAdmin)))
{
user = await _userManager.FindByIdAsync(user.IdOfTheSelectedRestaurateur);
}
booking.RestaurantId = user.RestaurantId;
booking.CreatorId = user.Id;
_db.Entry(booking).State = EntityState.Added;
foreach (var tId in tableId)
{
BookingTable bookingTable = new BookingTable()
{
BookingId = booking.Id,
TableId = tId
};
_db.Entry(bookingTable).State = EntityState.Added;
}
await _db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(booking));
}
private bool ValidateBookingTable(BookingTable bookingTable)
{
bool isValid = true;
// Check if from date is after To date
if (bookingTable.From > bookingTable.To)
{
ModelState.AddModelError("Booking.From", "Start date cannot be after end date");
var createBookingTableViewModel = new CreateBookingTableViewModel()
{
Tables = DbContext.Tables,
};
isValid = false;
}
//1. Hämta ut alla bokning som har samma tableId som den nya bokningen
List <BookingTable> bookingsFromDb = DbContext.BookingTables.Where(b => b.TableId == bookingTable.TableId).ToList();
//2. Kolla om något av dessa bokningar har överlappande datum
foreach (var oldBooking in bookingsFromDb)
{
if (DateHelpers.HasSharedDateIntervals(bookingTable.From, bookingTable.To, oldBooking.From, oldBooking.To))
{
ModelState.AddModelError("Booking.From", "Date already occupied.");
var createBookingTableViewModel = new CreateBookingTableViewModel()
{
Tables = DbContext.Tables
};
isValid = false;
}
}
return(isValid);
}
public async Task <IActionResult> Edit(int id, [Bind("Id,seatNo,UserId,DateToPresent,MovieDetailsId,MovieName,Amount")] BookingTable bookingTable)
{
if (id != bookingTable.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(bookingTable);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BookingTableExists(bookingTable.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["MovieDetailsId"] = new SelectList(_context.MovieDetails, "Id", "Id", bookingTable.MovieDetailsId);
return(View(bookingTable));
}
public async Task <IActionResult> Book(CreateBookingViewModel model)
{
if (ModelState.IsValid)
{
Table table = _db.Tables.FirstOrDefault(t => t.Id == model.TableId);
Booking booking = new Booking()
{
ClientName = model.ClientName,
BookFrom = model.BookFrom,
BookTo = model.BookTo,
Comment = model.Comment,
RestaurantId = table.RestaurantId,
Pax = model.Pax,
PhoneNumber = model.PhoneNumber,
Email = model.Email,
};
if (model.Date == "today")
{
booking.Date = DateTime.Today.ToShortDateString();
}
else if (model.Date == "tomorrow")
{
booking.Date = DateTime.Today.AddDays(1).ToShortDateString();
}
else if (model.Date == "custom")
{
booking.Date = model.CustomDate;
}
else
{
return(PartialView("PartialViews/BookTableModalPartialView", model));
}
if (SessionHelper.GetObjectFromJson <List <Item> >(HttpContext.Session, "booking") == null)
{
List <Booking> items = new List <Booking>();
items.Add(booking);
SessionHelper.SetObjectAsJson(HttpContext.Session, "booking", items);
}
else
{
List <Booking> items = SessionHelper.GetObjectFromJson <List <Booking> >(HttpContext.Session, "booking");
items.Add(booking);
SessionHelper.SetObjectAsJson(HttpContext.Session, "booking", items);
}
_db.Entry(booking).State = EntityState.Added;
BookingTable bookingTable = new BookingTable()
{
BookingId = booking.Id,
TableId = model.TableId
};
_db.Entry(bookingTable).State = EntityState.Added;
await _db.SaveChangesAsync();
return(Json(new{ status = "success" }));
}
return(PartialView("PartialViews/BookTableModalPartialView", model));
}
/// <summary>
/// TODO: Delay between booking and delivery is too short
///
/// </summary>
public void MakeBookingTable()
{
DateTime start = Settings.MinDate;
if (NopDataSet.Tables.Contains(Settings.BookingTableName))
{
NopDataSet.Tables.Remove(Settings.BookingTableName);
}
BookingTable = NopDataSet.Tables.Add(Settings.BookingTableName);
BookingTable.Columns.Add(Settings.PickupIdName, typeof(int));
string colName = Settings.HoursString;
BookingTable.Columns.Add(colName, typeof(string));
for (int i = 0; i < Settings.DateRange + 1; i++)
{
DateTime date1 = start.AddDays(i);
colName = date1.ToString("dddd") + Environment.NewLine + date1.ToShortDateString();
//dt.Columns.Add(colName, typeof(float));
BookingTable.Columns.Add(colName, typeof(string));
}
//Must take in account Summer lightning
for (int h = Settings.DeliveryStartsAt.Hours; h < Settings.DeliveryStopsAt.Hours; h += Settings.TimeSlotIncrement)
{
DataRow row = BookingTable.NewRow();
//string s = String.Format("{0:00}H00 - {1:00}H00", h, h + Settings.TimeSlotDuration);
DateTime dto1 = new DateTime(2020, 2, 1, h, 0, 0);
DateTime dto2 = new DateTime(2020, 2, 1, h + Settings.TimeSlotDurationInHours, 0, 0);
string s = String.Format("{0:HH:mm} - {1:HH:mm}", dto1, dto2);
row[Settings.HoursString] = s;
for (int i = 1; i < BookingTable.Columns.Count; i++)
{
int dow = (int)Settings.MinDate.DayOfWeek;
int dayNo = (i - 1 + dow) % 7;
string text;
//Tenir compte des vacations ici
//check vacation table
//Simple one, by week, simple click to assign a day off
if (Settings.DeliveryDayOpen[dayNo] == "-")
{
text = "-";
}
else
{
//this must be dependent on the number of slots available eg: 7-5-3 euros
//text = Settings.DefaultFees[0].ToString();// + "€";
row[i] = Settings.DefaultFees[0];
}
}
//check time slot is not full
//check vacation
//row[1]
BookingTable.Rows.Add(row);
}
}
public async Task<IHttpActionResult> GetStudent(string id)
{
BookingTable Booking = await db.Bookings.FindAsync(id);
if (Booking == null)
{
return NotFound();
}
return Ok(Booking);
}
public IHttpActionResult GetBookingTable(int id)
{
BookingTable bookingTable = db.BookingTables.Find(id);
if (bookingTable == null)
{
return(NotFound());
}
return(Ok(bookingTable));
}
public async Task <IActionResult> Create([Bind("Id,seatNo,UserId,DateToPresent,MovieDetailsId,MovieName,Amount")] BookingTable bookingTable)
{
if (ModelState.IsValid)
{
_context.Add(bookingTable);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["MovieDetailsId"] = new SelectList(_context.MovieDetails, "Id", "Id", bookingTable.MovieDetailsId);
return(View(bookingTable));
}
public async Task<IHttpActionResult> DeleteStudent(string id)
{
BookingTable booking = await db.Bookings.FindAsync(id);
if (booking == null)
{
return NotFound();
}
db.Bookings.Remove(booking);
await db.SaveChangesAsync();
return Ok(booking);
}
public void DeleteBooking(int id)
{
if (IsAdmin)
{
BookingTable bt = Database.BookingTables.Get(id);
if (bt == null)
{
throw new ValidationException("Бронь не найдена", "");
}
Database.BookingTables.Delete(bt.Id);
Database.Save();
}
}
public IHttpActionResult DeleteBookingTable(int id)
{
BookingTable bookingTable = db.BookingTables.Find(id);
if (bookingTable == null)
{
return(NotFound());
}
db.BookingTables.Remove(bookingTable);
db.SaveChanges();
return(Ok(bookingTable));
}
public ActionResult ConfirmReservation(BookingTable bConfirm, int hiddenIdTable)
{
if (bConfirm.Reservation != null)
{
Reservation reservation = bConfirm.Reservation;
reservation.NumberOfPeople = 2;
var myReservation = bConfirm.Reservation;
myReservation.TableId = hiddenIdTable;
db.BookingForms.Add(myReservation);
db.SaveChanges();
}
return(View());
}
public IActionResult Edit(BookingTable bookingTable)
{
bookingTable.TableName = DbContext.Tables.FirstOrDefault(r => r.Id == bookingTable.TableId).Name;
var bookingTableIndex = DbContext.BookingTables.FindIndex(m => m.Id == bookingTable.Id);
if (bookingTableIndex == -1)
{
return(NotFound());
}
DbContext.BookingTables[bookingTableIndex] = bookingTable;
return(RedirectToAction(nameof(Index)));
}
protected void Button1_Click(object sender, EventArgs e)
{
BookingTable b = new BookingTable();
b.VenId = Convert.ToInt32(ViewState["ven"]);
b.Name = TextBox3.Text;
b.Pklo = TextBox2.Text;
b.E_mail = TextBox5.Text;
b.Contact = TextBox4.Text;
b.Brand = DropDownList1.SelectedValue;
b.Model_No = DropDownList2.SelectedValue;
b.Status = "u";
b.Issue = DropDownList3.SelectedValue;
dl.da.BookingTables.InsertOnSubmit(b);
dl.da.SubmitChanges();
TextBox2.Text = TextBox3.Text = TextBox4.Text = TextBox5.Text = "";
}
/// <summary>
/// BookingTable
/// </summary>
/// <param name="BookingTable">BookingTable</param>
/// <returns>状态代码</returns>
public int Delete(BookingTable obj)
{
try
{
string sql = "delete from Booking where id=@ID";
using (SQLiteCommand cmd = new SQLiteCommand(sql))
{
cmd.Parameters.AddWithValue("@ID", obj.ID);
return(SQLiteHelper.SQLiteHelper.ExecuteNonQuery(conStr, cmd));
}
}
catch (Exception ex)
{
throw new Exception("调用BookingTable 时，访问Delete时出错", ex);
}
}
public IHttpActionResult PostBookingTable(BookingTable bookingTable)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.BookingTables.Add(bookingTable);
db.SaveChanges();
return(CreatedAtRoute("DefaultApi", new { id = bookingTable.Ticket_Id }, bookingTable));
}
catch
{
return(NotFound());
}
}
public bool ReloadBooking()
{
var bookings = new List <BookingTable>();
foreach (var aPair in pairs)
{
var depth = client.GetOrderBook(aPair, 5);
var res = depth["result"] as JsonObject;
var xrp = res[aPair] as JsonObject;
var asks = xrp["asks"].ToString();
var bids = xrp["bids"].ToString();
int spiltIndex = (int)Math.Ceiling((double)aPair.Length / 2);
string coin = aPair.Substring(0, spiltIndex);
string currency = aPair.Substring(spiltIndex, aPair.Length - spiltIndex);
if (coin.StartsWith("X"))
{
coin = coin.Substring(1);
}
if (currency.StartsWith("Z"))
{
currency = currency.Substring(1);
}
var booking = new BookingTable()
{
Pair = aPair,
Coin = coin.Replace("XBT", "BTC"),
Currency = currency,
Platform = this.platform,
Asks = asks,
Bids = bids
};
bookings.Add(booking);
}
var dao = new BookingTableDao();
dao.InsertOrUpdate(bookings);
return(true);
}
public ActionResult booking(BookingTable userModel)
{
using (DbModels dbModel = new DbModels())
{
BookingTable data = new BookingTable();
if (dbModel.Users.Any(x => x.UserEmail == userModel.User_Email))
{
dbModel.BookingTables.Add(userModel);
dbModel.SaveChanges();
//return View("Registeration", userModel);
return(RedirectToAction("index", "Home"));
}
}
ModelState.Clear();
//return View("Registeration", new User());
return(RedirectToAction("Booking", "Booking"));
}
public async Task <IActionResult> Edit(EditBookingViewModel model, int tableId)
{
if (ModelState.IsValid)
{
User user = await _userManager.FindByIdAsync(_userManager.GetUserId(User));
if (User.IsInRole(Convert.ToString(Roles.SuperAdmin)))
{
user = await _userManager.FindByIdAsync(user.IdOfTheSelectedRestaurateur);
}
var booking = _db.Bookings.FirstOrDefault(b => b.Id == model.Id);
if (booking != null)
{
if (booking.BookingTables.All(b => b.TableId != tableId))
{
BookingTable bookingTable = new BookingTable()
{
BookingId = booking.Id,
TableId = tableId
};
_db.Entry(bookingTable).State = EntityState.Added;
}
booking.Date = model.Date;
booking.Comment = model.Comment;
booking.ClientName = model.ClientName;
booking.PhoneNumber = model.PhoneNumber;
booking.Email = model.Email;
booking.Pax = model.Pax;
booking.State = model.State;
booking.EditorId = user.Id;
booking.EditedDate = DateTime.Now;
_db.Entry(booking).State = EntityState.Modified;
}
await _db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View());
}
public async Task <List <BookingTable> > getInfo(int comp, int delegates)
{
var returnlist = new List <BookingTable>();
using (var db = new Session3Entities())
{
int singlerooms = 0;
int doublerooms = 0;
int i = comp;
while ((i - 2) >= 1)
{
i = i - 2;
doublerooms++;
}
singlerooms = i;
singlerooms += delegates;
var hotel = (from d in db.Hotels
where d.hotelId == hotelID
select d).First();
var singlebt = new BookingTable()
{
RoomType = "Single",
AvailableNoOfRooms = hotel.numSingleRoomsTotal - hotel.numSingleRoomsBooked,
RoomRatePerNight = hotel.singleRate,
RoomsRequired = singlerooms,
SubTotal = hotel.singleRate * singlerooms
};
var doublebt = new BookingTable()
{
RoomType = "Double",
AvailableNoOfRooms = hotel.numDoubleRoomsTotal - hotel.numDoubleRoomsBooked,
RoomRatePerNight = hotel.doubleRate,
RoomsRequired = doublerooms,
SubTotal = hotel.doubleRate * doublerooms
};
returnlist.Add(singlebt);
returnlist.Add(doublebt);
}
return(returnlist);
}
public IActionResult BookTicket(Cart Cart, BookingTable TicketProceed)
{
var CartList = _context.Cart.Where(a => a.UserId == _userManager.GetUserId(HttpContext.User)).ToList();
var Tickets = new List <BookingTable>();
foreach (var item in CartList)
{
Tickets.Add(new BookingTable {
seatNo = item.seatNo,
MovieDetailsId = item.MovieId,
Amount = item.Amount,
DateToPresent = item.date,
MovieName = item.movieName,
UserId = _userManager.GetUserId(HttpContext.User)
});
_context.Cart.Remove(item);
}
_context.BookingTable.AddRange(Tickets);
_context.SaveChanges();
return(RedirectToAction("Index", "Cart"));
}
// från vyn till metoden i controllen
public IActionResult Create(BookingTable bookingTable)
{
if (!ValidateBookingTable(bookingTable))
{
var createBookingTableViewModel = new CreateBookingTableViewModel()
{
Tables = DbContext.Tables, BookingTable = bookingTable
};
return(View(createBookingTableViewModel));
}
var tabelName = DbContext.Tables.FirstOrDefault(r => r.Id == bookingTable.TableId).Name;
bookingTable.Id = Guid.NewGuid();
bookingTable.TableName = tabelName;
DbContext.BookingTables.Add(bookingTable);
return(RedirectToAction("Index"));
}
public void BookPlace(BookingTableDTO bookt)
{
CarriageDetail carriage = Database.CarriageDetails.Get(bookt.Carriage_Id);
// валидация
if (carriage == null)
{
throw new ValidationException("Вагон не найден", "");
}
BookingTable bt = new BookingTable
{
CarriageDetail = carriage,
Carriage_Id = bookt.Carriage_Id,
Date = DateTime.Now,
NAME = bookt.NAME,
EMAIL = bookt.EMAIL,
Description = bookt.Description,
Seat_Num = bookt.Seat_Num
};
Database.BookingTables.Create(bt);
Database.Save();
/*
* try
* {
* MailMessage mailMessage = new MailMessage();
* mailMessage.To.Add(bookt.EMAIL);
* mailMessage.From = new MailAddress("*****@*****.**");
* mailMessage.Subject = "Place booked";
* mailMessage.Body = "Hello. You have booked a ticket via NovaZaliznitsya service. Your place "+ bookt.Seat_Num;
* SmtpClient smtpClient = new SmtpClient("smtp.isp.com");
* smtpClient.Send(mailMessage);
* }
* catch (Exception ex)
* {
* Response.Write("Could not send the e-mail - error: " + ex.Message);
* }*/
}
