public async Task <ActionResult <Reservation> > DeleteReservation(int id)
{
var reservation = await _context.Reserevations
.Where(n => n.ReservationID == id)
.Include(n => n.Guest)
.Include(n => n.Room)
.FirstOrDefaultAsync();
if (reservation == null)
{
return(NotFound());
}
var reservationToArchinve = new ReservationHistory()
{
check_in_History = reservation.Check_in,
check_out_History = reservation.Check_out,
Guest = reservation.Guest,
Room = reservation.Room,
TotalAmount_History = reservation.TotalAmount
};
_context.Reserevations.Remove(reservation);
_context.ReservationHistory.Add(reservationToArchinve);
await _context.SaveChangesAsync();
return(reservation);
}
public async Task <IActionResult> PutReservationHistory(int id, ReservationHistory reservationHistory)
{
if (id != reservationHistory.ReservationHistoryID)
{
return(BadRequest());
}
_context.Entry(reservationHistory).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ReservationHistoryExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public IActionResult DeleteReservation(int id)
{
var reservationIncludeForegin = _context.Reserevations
.Include(c => c.Room)
.Include(c => c.Guest)
.ToList();
var reservationtodelete = (from Reservation item in reservationIncludeForegin
where item.ReservationID == id
select item).FirstOrDefault();
var roomreserved = (from Room n in _context.Rooms
where n.RoomID == reservationtodelete.Room.RoomID
select n).FirstOrDefault();
if (roomreserved.Is_ocuppied == false)
{
Reservation ReservationToArchive = (from Reservation item in _context.Reserevations
where item.ReservationID == id
select item).FirstOrDefault();
ReservationHistory NewReservationHistoryItem = new ReservationHistory();
NewReservationHistoryItem.check_in_History = ReservationToArchive.Check_in.Date;
NewReservationHistoryItem.check_out_History = ReservationToArchive.Check_out.Date;
NewReservationHistoryItem.Guest = ReservationToArchive.Guest;
NewReservationHistoryItem.GuestName_History = ReservationToArchive.Guest.Name;
NewReservationHistoryItem.Room = ReservationToArchive.Room;
NewReservationHistoryItem.TotalAmount_History = ReservationToArchive.TotalAmount;
_context.ReservationHistoryItems.Add(NewReservationHistoryItem);
_context.Reserevations.Remove(reservationtodelete);
roomreserved.Is_ocuppied = false;
_context.SaveChanges();
}
return(RedirectToAction(nameof(Index)));
}
public IActionResult DeleteReservation(int id)
{
var reservationtodelete = (from Reservation item in _context.Reserevations
where item.ReservationID == id
select item).FirstOrDefault();
var roomreserved = (from Room n in _context.Rooms
where n.RoomID == reservationtodelete.RoomID
select n).FirstOrDefault();
Reservation ReservationToArchive = (from Reservation item in _context.Reserevations
where item.ReservationID == id
select item).FirstOrDefault();
ReservationHistory NewReservationHistoryItem = new ReservationHistory();
NewReservationHistoryItem.check_in_History = ReservationToArchive.check_in;
NewReservationHistoryItem.check_out_History = ReservationToArchive.check_out;
NewReservationHistoryItem.GuestID_History = ReservationToArchive.GuestID;
NewReservationHistoryItem.GuestName_History = ReservationToArchive.GuestName;
NewReservationHistoryItem.RoomID_History = ReservationToArchive.RoomID;
_context.ReservationHistoryItems.Add(NewReservationHistoryItem);
_context.Reserevations.Remove(reservationtodelete);
_context.SaveChanges();
return(RedirectToAction(nameof(Index)));
}
public AssetReservationLocal(ReservationHistory history)
{
Historical = true;
AssetId = history.AssetId;
End = history.End.ToString();
ReservedFor = history.ReservedFor;
Start = history.Start.ToString();
State = EntityState.Unchanged;
}
private static void UpdateReservationHistory(AssetInventoryContext context, AssetReservation reservation)
{
ReservationHistory history = context.ReservationHistory
.OrderByDescending(n => n.ReservationHistoryId)
.FirstOrDefault(n => n.AssetId == reservation.AssetId && n.Start == reservation.Start);
if (history != null && DateTime.Now < history.End)
{
history.End = DateTime.Now;
}
}
/// <summary>
/// Parses the sql result set into a ReservationHistory item object
/// </summary>
/// <param name="reader">The sql data reader that contains the resultset</param>
/// <returns>Populated ReservationHistory item object</returns>
private ReservationHistory GetReservationHistoryItemFromReader(SqlDataReader reader)
{
ReservationHistory item = new ReservationHistory();
item.Reservation.Id = Convert.ToInt32(reader["reservation_id"]);
item.Reservation.SiteId = Convert.ToInt32(reader["site_id"]);
item.Reservation.Name = Convert.ToString(reader["name"]);
item.Reservation.FromDate = Convert.ToDateTime(reader["from_date"]);
item.Reservation.ToDate = Convert.ToDateTime(reader["to_date"]);
item.Reservation.CreatedDate = Convert.ToDateTime(reader["create_date"]);
item.CampgroundName = Convert.ToString(reader["CampgroundName"]);
return(item);
}
public IActionResult AddReservationHistoryItem(int id)
{
Reservation ReservationToArchive = (from Reservation item in _context.Reserevations
where item.ReservationID == id
select item).FirstOrDefault();
ReservationHistory NewReservationHistoryItem = new ReservationHistory();
NewReservationHistoryItem.check_in_History = ReservationToArchive.check_in;
NewReservationHistoryItem.check_out_History = ReservationToArchive.check_out;
NewReservationHistoryItem.GuestID_History = ReservationToArchive.GuestID;
NewReservationHistoryItem.GuestName_History = ReservationToArchive.GuestName;
NewReservationHistoryItem.RoomID_History = ReservationToArchive.RoomID;
_context.ReservationHistoryItems.Add(NewReservationHistoryItem);
_context.SaveChanges();
return(View());
}
private void LogHistory(Reservation r)
{
var h = new ReservationHistory()
{
Date = r.Date,
Deleted = r.Deleted,
Notes = r.Notes,
NumberOfPeople = r.NumberOfPeople,
ReservationId = r.Id,
ReservationStatus = db.ReservationStatuses.Single(s => s.Id == r.ReservationStatusId).Status,
Revenue = r.Revenue,
Table = r.Table,
Time = r.Time,
UpdatedAt = r.UpdatedAt,
UpdatedBy = r.UpdatedBy
};
db.ReservationHistories.Add(h);
db.SaveChanges();
}
public SaveMenuItemResponse PerformUpdateReservationStatus(UpdateReservationRequest request)
{
SaveMenuItemResponse response = new SaveMenuItemResponse();
var modifiedDate = DateTime.Now;
try
{
using (var db = new CuddlyWombatEntities())
{
db.Configuration.LazyLoadingEnabled = false;
db.Configuration.ProxyCreationEnabled = false;
var reservationToUpdate = (from r in db.Reservations
where r.ReservationID == request.ReservationID
select r).FirstOrDefault();
if (reservationToUpdate != null)
{
var reservationHistory = new ReservationHistory()
{
ReservationID = reservationToUpdate.ReservationID,
CustomerID = reservationToUpdate.CustomerID,
NumberOfTables = reservationToUpdate.NumberOfTables,
ReservationDate = reservationToUpdate.ReservationDate,
ReservationStatusID = reservationToUpdate.ReservationStatusID,
DateCreated = reservationToUpdate.DateCreated,
DateModified = modifiedDate
};
db.ReservationHistories.Add(reservationHistory);
reservationToUpdate.ReservationStatusID = request.ReservationStatusID;
reservationToUpdate.DateModified = modifiedDate;
}
else
{
response = new SaveMenuItemResponse()
{
MessageString = "Please select a reservation",
MessageStatusID = (byte)EMessageStatus.Success
};
return(response);
}
db.SaveChanges();
if (request.ReservationStatusID == (byte)EReservationStatus.Canceled)
{
response.MessageString = "Reservation is cancelled";
}
else if (request.ReservationStatusID == (byte)EReservationStatus.Completed)
{
response.MessageString = "Reservation Status updated to Completed";
}
response.MessageStatusID = (byte)EMessageStatus.Success;
}
}
catch (Exception ex)
{
response.MessageStatusID = (byte)EMessageStatus.Exception;
response.MessageString = ex.Message;
}
return(response);
}
public static bool UpdateReservationHistory(int clientId, int reservationId, int?accountId, double?chargeMultiplier, string notes, bool emailClient)
{
//this does not update billing, that needs to be done separately
bool saveReservation = false;
bool addReservationHistory = false;
bool sendEmail = false;
double forgivenAmount = 0;
Reservation rsvMain = DA.Current.Single <Reservation>(reservationId);
if (rsvMain == null)
{
return(false);
}
Reservation rsv = rsvMain;
while (true) // this will loop through all linked reservations and update them.
{
if (accountId.HasValue && rsv.Account.AccountID != accountId.Value)
{
Account acct = DA.Current.Single <Account>(accountId);
if (acct == null)
{
return(false);
}
rsv.Account = acct;
saveReservation = true;
addReservationHistory = true;
}
if (chargeMultiplier.HasValue && rsv.ChargeMultiplier != chargeMultiplier.Value)
{
rsv.ChargeMultiplier = chargeMultiplier.Value;
saveReservation = true;
addReservationHistory = true;
sendEmail = emailClient;
forgivenAmount = (1 - chargeMultiplier.Value) * 100.0;
}
if (notes != null && notes != rsv.Notes)
{
rsv.Notes = notes;
saveReservation = true;
// no need to add ReservationHistory for a notes change
}
if (saveReservation)
{
DA.Current.SaveOrUpdate(rsv);
if (addReservationHistory)
{
//need to add ReservationHistory
DA.Current.SaveOrUpdate(new ReservationHistory()
{
Reservation = rsv,
UserAction = "UpdateReservationHistory",
ActionSource = "LNF.WebApi.Scheduler.Repository",
Account = rsv.Account,
BeginDateTime = rsv.BeginDateTime,
EndDateTime = rsv.EndDateTime,
ChargeMultiplier = rsv.ChargeMultiplier,
ModifiedByClientID = clientId,
ModifiedDateTime = DateTime.Now
});
}
}
ReservationHistory rh1 = DA.Current.Query <ReservationHistory>().FirstOrDefault(x => x.Reservation == rsv && x.LinkedReservationID != null && x.UserAction == ReservationHistory.INSERT_FOR_MODIFICATION);
if (rh1 == null) // if there are no more linked reservations
{
break;
}
else
{
rsv = DA.Current.Query <Reservation>().FirstOrDefault(x => x.ReservationID == rh1.LinkedReservationID.Value);
if (rsv == null)
{
// this should never happen
break;
}
}
}
if (sendEmail)
{
EmailManager.EmailOnForgiveCharge(rsv, forgivenAmount, true, clientId);
}
return(true);
}
public async Task <ActionResult <ReservationHistory> > PostReservationHistory(ReservationHistory reservationHistory)
{
_context.ReservationHistory.Add(reservationHistory);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetReservationHistory", new { id = reservationHistory.ReservationHistoryID }, reservationHistory));
}
