/// <summary>
/// Finds rooms appropriate for roomrequest
/// </summary>
/// <param name="roomRequest"></param>
/// <returns></returns>
//public static async Task<List<Models.Accommodation.BedRoom>> GetSuitingRooms4RoomRequest(Models.RoomRequest.RoomRequest roomRequest)
//{
// List<Models.Accommodation.BedRoom> roomsWCapacity = await GetFreeRooms(roomRequest.CheckInUser, roomRequest.CheckOutUser, roomRequest.Request_ID);
// List<Models.Accommodation.BedRoom> Rooms = new List<Models.Accommodation.BedRoom>();
// foreach (var room in roomsWCapacity)
// {
// if (!roomRequest.ShareRoom)
// {
// if (room.Vacant)
// {
// if (room.SingleBeds >= roomRequest.SingleBed && room.DoubleBeds >= roomRequest.DoubleBed)
// {
// Rooms.Add(room);
// }
// }
// }
// else
// {
// if (room.SingleBeds >= roomRequest.SingleBed && room.DoubleBeds >= roomRequest.DoubleBed)
// {
// Rooms.Add(room);
// }
// }
// }
// return null;
//}
//public static async Task<List<Models.Accommodation.BedRoom>> GetFreeRooms(DateTime CheckIn, DateTime CheckOut, int rqID)
//{
//using (var db = new ApplicationDbContext())
//{
// Models.Request.Request request = db.Requests.Find(rqID);
// // Models.Accommodation.Accommodation accom = db.Accommodations.Where(p => p.ID == request.Accommodation_ID).Include(p => p.BedRooms).Include(p => p.Capacity).FirstOrDefault();
// // int numbedRooms = accom.BedRooms.Count;
// IQueryable<Models.RoomRequest.RoomRequest> RoomRequests = db.RoomRequests.Where(p => p.Request_ID == rqID).Include(p => p.RoomRequestResponse); //Find all roomRequests and its response
// RoomRequests = RoomRequests.Where(p => p.RoomRequestResponse.responseStatus == Models.RoomRequest.RoomRequestResponseStatus.Reserved); //Filter reserved RoomRequests
// if (RoomRequests == null || RoomRequests.ToList().Count == 0) //no reservation was made, all Bedrooms are vacant
// {
// // return accom.BedRooms;
// }
// IQueryable<Models.RoomRequest.RoomRequest> RoomRequestsOutSmaller = RoomRequests.Where(p => p.CheckInUser < CheckIn && p.CheckOutUser < CheckOut); //exclude outlayers before
// IQueryable<Models.RoomRequest.RoomRequest> RoomRequestsOutBigger = RoomRequests.Where(p => p.CheckInUser > CheckIn && p.CheckOutUser > CheckOut); //exclude outlayer after
// RoomRequests = RoomRequests.Except(RoomRequestsOutSmaller); //Except outlayers
// RoomRequests = RoomRequests.Except(RoomRequestsOutBigger);
// //List<Models.RoomRequest.RoomRequest> filteredRoomRequestsReserved = await RoomRequests.Where(p => p.RoomRequestResponse.IsReserved()).ToListAsync();
// List<Models.RoomRequest.RoomRequest> filteredRoomRequestsReserved = await RoomRequests.Where(p => p.RoomRequestResponse.responseStatus == Models.RoomRequest.RoomRequestResponseStatus.Reserved).ToListAsync(); //catch empty List
// if (filteredRoomRequestsReserved == null || filteredRoomRequestsReserved.Count == 0) //no reservation was made, all Bedrooms are vacant
// {
// // return accom.BedRooms;
// }
// List<Models.Accommodation.BedRoom>[] BookedBedrooms = new List<Models.Accommodation.BedRoom>[numbedRooms];
// foreach (var rRq in filteredRoomRequestsReserved) //FindBedrooms and its occupation for the given time interval
// {
// var room = db.BedRooms.Find(rRq.Room_ID);
// BookedBedrooms[room.RoomNumber - 1].Add(room);
// }
// List<Models.Accommodation.BedRoom> FreeBedRooms = new List<Models.Accommodation.BedRoom>();
// for (int i = 0; i < numbedRooms; i++) //check if rooms are fully loaded
// {
// if (BookedBedrooms[i].Count == 0)
// {
// Models.Accommodation.BedRoom freeBedRoom = accom.BedRooms.Where(p => p.RoomNumber == i).FirstOrDefault(); //just add the roomspecification
// freeBedRoom.Vacant = true;
// FreeBedRooms.Add(freeBedRoom);
// }
// else //get detailed Booking status ->check the roomrequests for each room in that time //
// {
// List<Models.RoomRequest.RoomRequest> rRqRoom = filteredRoomRequestsReserved.Where(p => p.Room_ID == BookedBedrooms[i].FirstOrDefault().ID).ToList();
// int doublebedsOccupied = 0;
// int singlebedsOccupied = 0;
// bool shared = true;
// foreach (var rRq in rRqRoom)
// {
// doublebedsOccupied += rRq.DoubleBed;
// singlebedsOccupied += rRq.SingleBed;
// if (rRq.ShareRoom != shared) { shared = false; }
// }
// if (shared && doublebedsOccupied + singlebedsOccupied < BookedBedrooms[i].FirstOrDefault().MaxGuests)
// {
// Models.Accommodation.BedRoom SharedBedRoom = BookedBedrooms[i].FirstOrDefault();
// SharedBedRoom.DoubleBeds -= doublebedsOccupied;
// SharedBedRoom.SingleBeds -= singlebedsOccupied;
// SharedBedRoom.SharePossible = true; //these rooms are shared in this moment
// FreeBedRooms.Add(SharedBedRoom);
// }
// }
// }
// return FreeBedRooms;
//}
// }
//GET: Requests/Edit/5
public async Task <ActionResult> Edit(int id)
{
using (var db = new ApplicationDbContext())
{
Models.Request.Request request = await db.Requests.FindAsync(id);
request.Accommodation = await AccommodationsController.LoadAccommodation(request.Accommodation_ID);
if (Check.IsNull(request, "Edit Request"))
{
NotificationManager.AddNotification(NotificationType.Warning, "Request does not exist!");
return(RedirectToAction("Index", "Home"));
}
TravelerProfile tp = await ProfileManager.LoadUserAndTravelerProfile(User);
if (request.RequestOwner_ID != tp.ID)
{
NotificationManager.AddException(new Exception("User is not the Requestowner, Access Violation"));
NotificationManager.AddNotification(NotificationType.Warning, "Access Violation");
return(RedirectToAction("Index", "Home"));
}
Models.Request.RequestVMOwner rqVM = new Models.Request.RequestVMOwner(request);
return(View(rqVM));
}
}
// GET: Requests/Delete/5
public async Task <ActionResult> Delete(int?id)
{
if (Check.IsNull(id))
{
NotificationManager.AddException(new Exception("Request Delete, ID was null"));
NotificationManager.AddNotification(NotificationType.Error, "Oops, something went wrong");
return(View());
}
TravelerProfile tp = await ProfileManager.LoadUserAndTravelerProfile(User);
using (var db = new ApplicationDbContext())
{
Models.Request.Request request = await db.Requests.FindAsync(id);
if (Check.IsNull(request, "DeleteRequest"))
{
NotificationManager.AddNotification(NotificationType.Error, "Oops, something went wrong");
return(View());
}
if (request.RequestOwner_ID != tp.ID)
{
NotificationManager.AddException(new Exception("Access Violation, Requesteditor is not requestowner"));
}
request.Accommodation = await AccommodationsController.LoadAccommodation(request.Accommodation_ID);
Models.Request.RequestVMOwner rqVM = new Models.Request.RequestVMOwner(request);
return(View(rqVM));
}
}
public async Task <ActionResult> Delete(int?id)
{
if (Check.IsNull(id))
{
return(RedirectToAction("Index"));
}
TravelerProfile travelerProfile = await ProfileManager.LoadUserAndTravelerProfile(User);
using (var db = new ApplicationDbContext())
{
Models.RoomRequest.RoomRequest roomRequest = db.RoomRequests.Find(id);
roomRequest.RoomRequestResponse = db.RoomRequestResponse.Find(roomRequest.RoomRequestResponse_ID);
if (Check.IsNull(roomRequest, "RoomRequest Delete"))
{
return(RedirectToAction("Index"));
}
if (roomRequest.ApplyingTraveler_ID != travelerProfile.ID)
{
NotificationManager.AddException(new Exception("AccessViolation Roomrq Delete"));
return(RedirectToAction("Index"));
}
Models.Request.Request rq = await db.Requests.FindAsync(roomRequest.Request_ID);
rq.Accommodation = await AccommodationsController.LoadAccommodation(rq.Accommodation_ID);
Models.VM.ProfilePreviewVM host = await ProfilesController.ProfilePreviewVM(rq.RequestOwner_ID);
Models.RoomRequest.RoomRequestVMUser roomRequestVM = new Models.RoomRequest.RoomRequestVMUser(roomRequest, rq, host);
return(View(roomRequestVM));
}
}
//GET: RoomRequests/Details/5
public async Task <ActionResult> Details(int id)
{
try
{
using (var db = new ApplicationDbContext())
{
Models.RoomRequest.RoomRequest roomRequest = await db.RoomRequests.FindAsync(id);
roomRequest.RoomRequestResponse = await db.RoomRequestResponse.FindAsync(roomRequest.RoomRequestResponse_ID);
if (Check.IsNull(roomRequest, "DetailsRoomRq"))
{
NotificationManager.AddNotification(NotificationType.Error, "Oops, something went wrong");
return(View());
}
Models.Request.Request rq = await db.Requests.FindAsync(roomRequest.Request_ID);
rq.Accommodation = await AccommodationsController.LoadAccommodation(rq.Accommodation_ID);
Models.VM.ProfilePreviewVM host = await ProfilesController.ProfilePreviewVM(rq.RequestOwner_ID);
Models.RoomRequest.RoomRequestVMUser roomRequestVM = new Models.RoomRequest.RoomRequestVMUser(roomRequest, rq, host);
return(View(roomRequestVM));
}
}
catch (Exception e)
{
NotificationManager.AddException(e);
NotificationManager.AddNotification(NotificationType.Error, "Oops, something went wrong");
return(RedirectToAction("Index", "Home"));
}
}
public async Task <ActionResult> Reservations(int?id) //RequestID
{
try
{
if (!id.HasValue)
{
return(RedirectToAction("Index", "Home"));
}
id = id.Value;
TravelerProfile tp = await ProfileManager.LoadUserAndTravelerProfile(User);
if (Check.IsNull(tp, "Index RoomRequests"))
{
return(RedirectToAction("Index", "Home"));
}
using (var db = new ApplicationDbContext())
{
Models.Request.Request rq = await db.Requests.FindAsync(id);
rq.Accommodation = await AccommodationsController.LoadAccommodation(rq.Accommodation_ID);
IQueryable <Models.RoomRequest.RoomRequest> IQuery = db.RoomRequests.Where(p => p.Request_ID == id).Include(p => p.RoomRequestResponse);
IQueryable <Models.RoomRequest.RoomRequest> Reservations = IQuery.Where(p => p.RoomRequestResponse.responseStatus == Models.RoomRequest.RoomRequestResponseStatus.Reserved);
IQueryable <Models.RoomRequest.RoomRequest> Approvals = IQuery.Where(p => p.RoomRequestResponse.responseStatus == Models.RoomRequest.RoomRequestResponseStatus.Approved);
List <Models.RoomRequest.RoomRequest> ReservationsList = await Reservations.ToListAsync();
List <Models.RoomRequest.RoomRequestVMOwner> resListVM = new List <Models.RoomRequest.RoomRequestVMOwner>();
List <Models.RoomRequest.RoomRequest> ApprovalsList = await Approvals.ToListAsync();
List <Models.RoomRequest.RoomRequestVMOwner> apprListVM = new List <Models.RoomRequest.RoomRequestVMOwner>();
foreach (var res in ReservationsList)
{
Models.VM.ProfilePreviewVM tpVMPrev = await ProfilesController.ProfilePreviewVM(res.ApplyingTraveler_ID);
Models.RoomRequest.RoomRequestVMOwner rRqVM = new Models.RoomRequest.RoomRequestVMOwner(res, tpVMPrev);
resListVM.Add(rRqVM);
}
foreach (var appr in ApprovalsList)
{
Models.VM.ProfilePreviewVM tpVMPrev = await ProfilesController.ProfilePreviewVM(appr.ApplyingTraveler_ID);
Models.RoomRequest.RoomRequestVMOwner rRqVM = new Models.RoomRequest.RoomRequestVMOwner(appr, tpVMPrev);
apprListVM.Add(rRqVM);
}
Models.RoomRequest.ReservationsVM reservationsVM = new Models.RoomRequest.ReservationsVM(rq.Accommodation.BedRooms, resListVM, apprListVM, rq);
return(View(reservationsVM));
}
}
catch (Exception e)
{
NotificationManager.AddException(e);
NotificationManager.AddNotification(NotificationType.Error, "Oops, something went wrong!");
return(View());
}
}
public async Task <ActionResult> Edit(int?id) //id roomRq
{
try
{
if (!id.HasValue)
{
return(RedirectToAction("Search", "Searches"));
}
TravelerProfile travelerProfile = await ProfileManager.LoadUserAndTravelerProfile(User);
using (var db = new ApplicationDbContext())
{
Models.RoomRequest.RoomRequest roomRequest = await db.RoomRequests.FindAsync(id);
if (Check.IsNull(roomRequest, "Edit roomRequest"))
{
return(RedirectToAction("Index"));
}
Models.Request.Request request = await db.Requests.FindAsync(roomRequest.Request_ID);
request.Accommodation = await AccommodationsController.LoadAccommodation(request.Accommodation_ID);
if (!request.IsValid())
{
NotificationManager.AddNotification(NotificationType.Info, "The request is invalid, you can't edit your roomrequest anymore");
return(RedirectToAction("Index"));
}
if (roomRequest.ApplyingTraveler_ID != travelerProfile.ID)
{
NotificationManager.AddException(new Exception("Access violation, this is not your Roomrequest! Edit RoomRequest", new AccessViolationException()));
return(RedirectToAction("Index"));
}
roomRequest.RoomRequestResponse = db.RoomRequestResponse.Find(roomRequest.RoomRequestResponse_ID);
if (roomRequest.RoomRequestResponse.IsApproved())
{
NotificationManager.AddNotification(NotificationType.Info, "You cannot edit an approved roomrequest!");
return(RedirectToAction("Index"));
}
if (roomRequest.RoomRequestResponse.IsReserved())
{
NotificationManager.AddNotification(NotificationType.Info, "You cannot edit a reserved roomrequest!");
return(RedirectToAction("Index"));
}
Models.VM.ProfilePreviewVM host = await ProfilesController.ProfilePreviewVM(request.RequestOwner_ID);
Models.RoomRequest.RoomRequestVMUser roomRequestEditVM = new Models.RoomRequest.RoomRequestVMUser(roomRequest, request, null);
return(View(roomRequestEditVM));
}
}
catch (Exception e)
{
NotificationManager.AddException(e);
return(RedirectToAction("Index"));
}
}
/// <summary>
/// Display Details of a certain Request to User
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
// GET: Requests/Details/5
public async Task <ActionResult> Details(int?id)
{
try
{
if (id.HasValue)
{
id = id.Value;
}
else
{
return(View());
}
using (var db = new ApplicationDbContext())
{
Models.Request.Request request = await db.Requests.FindAsync(id);
if (Check.IsNull(request, "RequestDetails"))
{
return(RedirectToAction("Search", "Searches"));
}
if (request.IsDeleted("RequestDetails"))
{
return(RedirectToAction("Search", "Searches"));
}
///Loads Accommodation with Profile
request.Accommodation = await AccommodationsController.LoadAccommodation(request.Accommodation_ID);
Models.VM.ProfilePreviewVM rqOwnerVM = await ProfilesController.ProfilePreviewVM(request.RequestOwner_ID);
Models.Request.RequestVMUser requestVM = new Models.Request.RequestVMUser(request, rqOwnerVM);
return(View(requestVM));
}
}
catch (Exception e) {
NotificationManager.AddException(e);
NotificationManager.AddNotification(NotificationType.Error, "Oops, something went wrong!");
return(View());
}
}
public async Task <ActionResult> Index()
{
try
{
TravelerProfile tp = await ProfileManager.LoadUserAndTravelerProfile(User);
if (Check.IsNull(tp, "Index RoomRequests"))
{
return(RedirectToAction("Index", "Home"));
}
using (var db = new ApplicationDbContext())
{
IQueryable <Models.RoomRequest.RoomRequest> IQuery = db.RoomRequests.Where(p => p.ApplyingTraveler_ID == tp.ID).Include(p => p.RoomRequestResponse);
IEnumerable <Models.RoomRequest.RoomRequest> roomRqList = await IQuery.ToListAsync();
List <Models.RoomRequest.RoomRequestListUser> resultList = new List <Models.RoomRequest.RoomRequestListUser>();
foreach (var rRq in roomRqList)
{
Models.Request.Request rq = await db.Requests.FindAsync(rRq.Request_ID);
rq.Accommodation = await AccommodationsController.LoadAccommodation(rq.Accommodation_ID);
Models.VM.ProfilePreviewVM OwnerPrev = await ProfilesController.ProfilePreviewVM(rq.RequestOwner_ID);
Models.RoomRequest.RoomRequestListUser rqVM = new Models.RoomRequest.RoomRequestListUser(rRq, rq, OwnerPrev);
resultList.Add(rqVM);
}
return(View(resultList));
}
}
catch (Exception e)
{
NotificationManager.AddException(e);
return(new HttpStatusCodeResult(HttpStatusCode.InternalServerError));
}
}
public async Task <ActionResult> SelectFlatmates(int id, int update, int rrqid) //id RequestID
{
try
{
TravelerProfile tp = await ProfileManager.LoadUserAndTravelerProfile(User);
using (var db = new ApplicationDbContext())
{
Models.Request.Request request = await db.Requests.FindAsync(id);
request.Accommodation = await AccommodationsController.LoadAccommodation(request.Accommodation_ID);
if (Check.IsNull(request, "UpdateSelectFlatmates"))
{
return(RedirectToAction("Index", "Requests"));
}
if (request.RequestOwner_ID != tp.ID)
{
NotificationManager.AddException(new Exception("User is not RequestOwner, Access Violation, AcceptTraveler", new AccessViolationException()));
return(RedirectToAction("Index", "Home"));
}
if (update != 0 && rrqid != 0)
{
Models.RoomRequest.RoomRequest roomRequest = await db.RoomRequests.FindAsync(rrqid);
if (Check.IsNull(roomRequest, "UpdateSelectFlatmates"))
{
return(RedirectToAction("Index", "Requests"));
}
roomRequest.RoomRequestResponse = await db.RoomRequestResponse.FindAsync(roomRequest.RoomRequestResponse_ID);
if (roomRequest.IsDeleted("RoomRequest") || request.IsDeleted("RoomRequest"))
{
NotificationManager.AddNotification(NotificationType.Warning, "RoomRequest is not valid, Request might has been been deleted");
return(RedirectToAction("Index", "Home"));
}
var trackedRoomRq = roomRequest;
var trackedRRqResponse = roomRequest.RoomRequestResponse;
if (update > 0)
{
roomRequest.RoomRequestResponse.Approve();
NotificationManager.AddNotification(NotificationType.Success, "Flatmate approved!");
}
if (update < 0)
{
roomRequest.RoomRequestResponse.Decline();
NotificationManager.AddNotification(NotificationType.Success, "Flatmate declined!");
}
db.Entry(trackedRoomRq).CurrentValues.SetValues(roomRequest);
db.Entry(trackedRRqResponse).CurrentValues.SetValues(trackedRRqResponse);
await db.SaveChangesAsync();
}
IQueryable <Models.RoomRequest.RoomRequest> roomRequestQuery = db.RoomRequests.Where(p => p.Request_ID == id).Include(p => p.RoomRequestResponse).Where(p => p.RoomRequestResponse.responseStatus == Models.RoomRequest.RoomRequestResponseStatus.Pending);
List <Models.RoomRequest.RoomRequest> roomRequestList = await roomRequestQuery.ToListAsync();
List <Models.RoomRequest.RReqVMListItemRqOwn> roomRequestVMList = new List <Models.RoomRequest.RReqVMListItemRqOwn>();
foreach (var roomRq in roomRequestList)
{
if (roomRq.IsValid())
{
Models.VM.ProfilePreviewVM applicantVMPrev = await ProfilesController.ProfilePreviewVM(roomRq.ApplyingTraveler_ID);
roomRequestVMList.Add(new Models.RoomRequest.RReqVMListItemRqOwn(roomRq, request, applicantVMPrev));
}
}
string rrqstats = await RoomRequestStats(request);
Models.RoomRequest.RReqVMListRqOwn SelectFM = new Models.RoomRequest.RReqVMListRqOwn(request.ID, roomRequestVMList, rrqstats);
return(View(SelectFM));
}
}
catch (Exception e)
{
NotificationManager.AddException(e);
NotificationManager.AddNotification(NotificationType.Error, "Oops, something went wrong");
return(RedirectToAction("Index", "Requests"));
}
}
public async Task <ActionResult> Create(int?id) //Request id
{
try
{
if (!id.HasValue)
{
return(RedirectToAction("Search", "Searches"));
}
TravelerProfile tp = await ProfileManager.LoadUserAndTravelerProfile(User);
using (var db = new ApplicationDbContext())
{
TravelerProfileSearchSession searchSession = await db.LikibuSearchSession.FindAsync(tp.TravelerSearchID); //to fill checkDates, Location
Models.Request.Request request = await db.Requests.FindAsync(id);
request.Accommodation = await AccommodationsController.LoadAccommodation(request.Accommodation_ID);
if (Check.IsNull(request, "Create RoomRequest"))
{
NotificationManager.AddNotification(NotificationType.Warning, "Request is not valid");
return(RedirectToAction("Search", "Searches"));
}
if (request.IsDeleted("CreateRoomRequest, rq deleted"))
{
NotificationManager.AddNotification(NotificationType.Warning, "Request is not valid");
return(RedirectToAction("Search", "Searches"));
}
if (request.IsClosed()) //dann keine RoomRequests mehr
{
NotificationManager.AddNotification(NotificationType.Info, "You can't apply for closed requests");
return(RedirectToAction("Search", "Searches"));
}
//calc Valid Time here
DateTime CheckIn = request.CheckIn;
DateTime CheckOut = request.CheckOut;
DateTime chckinUser = DateTime.Parse(searchSession.CheckIn);
DateTime chckoutUser = DateTime.Parse(searchSession.CheckOut);
if (chckinUser < CheckIn)
{
CheckIn = chckinUser;
}
if (chckoutUser > CheckOut)
{
CheckOut = chckoutUser;
}
Models.RoomRequest.RoomRequestVMUser roomRequestVM = new Models.RoomRequest.RoomRequestVMUser(CheckIn, CheckOut, request);
if (tp.ID == request.RequestOwner_ID)
{
roomRequestVM.RequestOwner = true;
}
return(View(roomRequestVM));
}
}
catch (Exception e)
{
NotificationManager.AddException(e);
return(new HttpStatusCodeResult(HttpStatusCode.InternalServerError));
}
}
