public async Task <UserResponse> AddReservation(string username, Reservation reservation)
{
var temp = await context.RegisteredUsers.Include(i => i.MyReservations).FirstOrDefaultAsync(i => i.Username.ToLower() == username.ToLower());
if (temp != null)
{
try
{
var ur = new UserReservation {
User = temp, Reservation = reservation
};
temp.MyReservations.Add(ur);
reservation.Users.Add(ur);
return(new UserResponse(temp));
}
catch (Exception e)
{
return(new UserResponse(e.InnerException.Message));
}
}
else
{
return(new UserResponse("User with given username does not exist"));
}
}
public void SearchInSeasonTest()
{
// Arrange
CampgroundsSqlDAL campgroundDAL = new CampgroundsSqlDAL(connectionString);
DateTime arrival = new DateTime(2019, 6, 1);
DateTime departure = new DateTime(2019, 6, 10);
UserReservation reserve = new UserReservation(campId, arrival, departure);
//Act
bool isInSeason = campgroundDAL.SearchInSeason(reserve);
//Assert
Assert.IsTrue(isInSeason);
//Set up a new test that should return false.
DateTime arrival2 = new DateTime(2019, 2, 15);
DateTime departure2 = new DateTime(2019, 2, 22);
UserReservation reserve2 = new UserReservation(campId, arrival2, departure2);
bool isInSeason2 = campgroundDAL.SearchInSeason(reserve2);
Assert.IsFalse(isInSeason2);
//add test where you put departure before arrival, etc
//test bounds like max dates/ end dates
}
public int AddReservation(UserReservation reservation)
{
var sqlQuery = $"INSERT INTO USER_RESERVATIONS (ID_OFFER, ID_USER, RESERVATION_DATE, GUESTS)" +
$"VALUES(@ID_OFFER, @ID_USER, @RESERVATION_DATE, @GUESTS); SELECT CAST(SCOPE_IDENTITY() AS INT)";
int id = db.Query <int>(sqlQuery, reservation).SingleOrDefault();
return(id);
}
public bool DeclineRequest(string userId, int reservationId)
{
UserReservation userReservation = _context.UserReservation.Where(i => i.UserID == userId && i.ReservationID == reservationId).FirstOrDefault();
userReservation.status = "declined";
_context.SaveChanges();
return(true);
}
public async Task <UserReservation> UpdateUserReservation(UserReservation userReservation)
{
_context.UserReservations.Update(userReservation);
await _context.SaveChangesAsync();
_context.Entry(userReservation).State = EntityState.Detached;
return(userReservation);
}
public string CreateReservation(Reservation res)
{
if (res != null)
{
if (res.Date == null)
{
return("Date cannot be null");
}
if (res.OfficeID < 1 || res.FloorID < 1 || res.BookerID < 1)
{
return("ID not correct");
}
if ((res.UserIds == null || res.UserIds.Count < 1) && !res.UserIds.Contains(res.BookerID))
{
res.UserIds = new List <int>();
res.UserIds.Add(res.BookerID);
}
if (IsFloorFull(res.OfficeID, res.FloorID, res.UserIds.Count, res.Date))
{
return("Not enough room on this floor for all reservations");
}
foreach (int u in res.UserIds)
{
Reservation r = new Reservation
{
BookerID = u,
FloorID = res.FloorID,
OfficeID = res.OfficeID,
Date = res.Date
};
_context.Reservations.Add(r);
_context.SaveChanges();
UserReservation ur = new UserReservation()
{
ReservationID = r.ReservationID,
UserID = u,
Timestamp = DateTime.Now
};
_context.UserReservations.Add(ur);
_context.SaveChanges();
}
return("Reservation Successfull");
}
else
{
return("bad model");
}
}
// GET: Cabinet
public ActionResult Index()
{
UserReservation userReservation = new UserReservation();
foreach (User user in db.User)
{
if (Session["UserEmail"].ToString() == user.Email)
{
userReservation = new UserReservation(user);
}
}
return View(userReservation);
}
public IHttpActionResult Get(int id)
{
var urManager = new UserReservationManagement();
var ur = new UserReservation()
{
Id = id
};
ur = urManager.RetrieveById(ur);
apiResponse = new ApiResponse();
apiResponse.Data = ur;
return(Ok(apiResponse));
}
public ActionResult ChangePlace()
{
UserReservation userReservation = new UserReservation();
foreach (User user in db.User)
{
if (Session["UserEmail"].ToString() == user.Email)
{
userReservation = new UserReservation(user);
}
}
return(View(userReservation));
}
public override BaseEntity BuildObject(Dictionary <string, object> row)
{
var ureservation = new UserReservation
{
Id = GetIntValue(row, DB_COL_ID),
Subreservacion = GetIntValue(row, DB_COL_ID_SUBRESERVACION),
Carrito = GetIntValue(row, DB_COL_ID_CARRITO),
Hotel = GetIntValue(row, DB_COL_HOTEL),
QRCode = GetStringValue(row, DB_COL_QRCODE),
QRState = GetStringValue(row, DB_COL_QRSTATE),
State = GetStringValue(row, DB_COL_STATE)
};
return(ureservation);
}
public string UpdateReservation(int reservationId, ReservationDto resDto)
{
Reservation reservation = _context.Reservations.FirstOrDefault(r => r.ReservationID == reservationId);
IQueryable <UserReservation> userReservations = _context.UserReservations.Where(r => r.ReservationID == reservationId);
//Update reservation
if (reservation == null)
{
return("Reservation with Id " + reservationId.ToString() + " not found to update");
}
else
{
reservation.FloorID = resDto.FloorID;
reservation.Date = resDto.Date;
_context.SaveChanges();
foreach (int userId in resDto.UserIds)
{
//Check if a new user is added
bool ifUserExist = userReservations.Any(item => item.UserID.Equals(userId));
if (!ifUserExist)
{
UserReservation ur = new UserReservation()
{
ReservationID = reservationId,
UserID = userId,
Timestamp = DateTime.Now
};
_context.UserReservations.Add(ur);
_context.SaveChanges();
}
}
//check if user needs to be deleted
List <UserReservation> toBeDeleted = userReservations.Where(userRes => !resDto.UserIds.Any(mancerId => userRes.UserID == mancerId)).ToList();
foreach (UserReservation userToDelete in toBeDeleted)
{
_context.UserReservations.Remove(userToDelete);
_context.SaveChanges();
}
return("Reservation with Id " + reservationId.ToString() + " updated");
}
}
public ActionResult Create(UserReservationEdit model)
{
List <Guest> selectedGuests = model.Guests.Where(g => g.FIRST_NAME != null).ToList();
UserReservation reservation = new UserReservation {
ID_OFFER = model.Offer.ID_OFFER, ID_USER = model.IdUser, RESERVATION_DATE = DateTime.Now, GUESTS = selectedGuests.Count
};
int idReservation = _reservationsSqlExecutor.AddReservation(reservation);
foreach (Guest guest in selectedGuests)
{
_reservationsSqlExecutor.AddGuestToReservation(idReservation, guest);
}
UserReservationFullData reservationFullData = _reservationsSqlExecutor.GetReservationById(idReservation);
User user = _accountSqlExecutor.GetUserById(model.IdUser);
EmailService.SendReservationEmail(user.Email, reservationFullData);
return(RedirectToAction("Index"));
}
public void GetAvailableSitesTest()
{
//Arrange
SitesSqlDAL siteDal = new SitesSqlDAL(connectionString);
List <Site> sites = new List <Site>();
DateTime arrival2 = new DateTime(2019, 6, 5);
DateTime departure2 = new DateTime(2019, 6, 15);
UserReservation reserve4 = new UserReservation(7, arrival2, departure2);
//Act
sites = siteDal.GetAvailableSites(reserve4);
// Assert
//Assert.AreEqual(13, sites[siteId1].SiteNumber);
//Assert.AreEqual(14, sites[siteId2].SiteNumber);
//Assert.AreEqual(15, sites[siteId3].SiteNumber);
//Assert.AreEqual(16, sites[siteId4].SiteNumber);
CollectionAssert.Contains(sites, site);
}
public bool SearchInSeason(UserReservation userReservation)
{
Campground camp = new Campground();
int fromMonth, toMonth;
try
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
connection.Open();
SqlCommand cmd = new SqlCommand(SQL_SearchInSeason);
cmd.Parameters.Add("@campgroundId", SqlDbType.Int);
cmd.Parameters["@campgroundId"].Value = userReservation.CampgroundID;
cmd.Connection = connection;
SqlDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
camp.OpenFromMonth = Convert.ToInt32(reader["open_from_mm"]);
camp.OpenToMonth = Convert.ToInt32(reader["open_to_mm"]);
}
}
fromMonth = camp.OpenFromMonth;
toMonth = camp.OpenToMonth;
if ((userReservation.ArrivalMonth >= fromMonth && userReservation.ArrivalMonth <= toMonth) &&
(userReservation.DepartureMonth >= userReservation.ArrivalMonth && userReservation.DepartureMonth <= toMonth))
{
return(true);
}
else
{
return(false);
}
}
catch (Exception)
{
return(false);
}
}
public List <Site> GetAvailableSites(UserReservation userReservation)
{
List <Site> sites = new List <Site>();
try
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
connection.Open();
SqlCommand cmd = new SqlCommand(SQL_ListAvailSites);
cmd.Parameters.AddWithValue("@campgroundId", userReservation.CampgroundID);
cmd.Parameters.AddWithValue("@arrivalDate", userReservation.ArrivalDate);
cmd.Parameters.AddWithValue("@departureDate", userReservation.DepartureDate);
cmd.Connection = connection;
SqlDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
Site site = new Site();
site.SiteId = Convert.ToInt32(reader["site_id"]);
site.CampgroundId = Convert.ToInt32(reader["campground_id"]);
site.SiteNumber = Convert.ToInt32(reader["site_number"]);
site.MaxOccupancy = Convert.ToInt32(reader["max_occupancy"]);
site.IsAccessible = Convert.ToBoolean(reader["accessible"]);
site.MaxRVLength = Convert.ToInt32(reader["max_rv_length"]);
site.UtilitiesAreAvail = Convert.ToBoolean(reader["utilities"]);
sites.Add(site);
}
}
}
catch (Exception e)
{
throw e;
}
return(sites);
}
public bool JoinReservation(int id, string name)
{
string userId = _context.ApplicationUser.Where(i => i.UserName == name).Select(i => i.Id).FirstOrDefault();
if (userId == _context.UserReservation.Where(i => i.ReservationID == id && i.isHost == true).Select(ui => ui.UserID).FirstOrDefault())
{
// host want to join himself
return(false);
}
if (_context.UserReservation.Where(i => i.ReservationID == id && i.UserID == userId).FirstOrDefault() != null)
{
// One person want to join a reservation that is pending/approved/declined to him is not possible
return(false);
}
if (rr.reservationFull(id))
{
return(false);
}
//if ()
//{
//}
UserReservation userReservation = new UserReservation()
{
ReservationID = id,
UserID = userId,
isHost = false,
status = "pending"
};
_context.UserReservation.Add(userReservation);
_context.SaveChanges();
return(true);
}
public ActionResult Save(User modifyUser)
{
Entities db = new Entities();
UserReservation userReservation = new UserReservation();
foreach (User user in db.User)
{
if (Session["UserEmail"].ToString() == user.Email)
{
if (modifyUser.FirstName != null)
{
user.FirstName = modifyUser.FirstName;
Session["UserFirstName"] = modifyUser.FirstName;
}
if (modifyUser.Surname != null)
{
user.Surname = modifyUser.Surname;
Session["UserSurname"] = modifyUser.Surname;
}
if (modifyUser.Email != null)
{
user.Email = modifyUser.Email;
Session["UserEmail"] = modifyUser.Email;
}
userReservation = new UserReservation(user);
}
}
db.SaveChanges();
return(PartialView("ChangePlace", userReservation));
}
private UserReservation FindReservedByUser(long userId, List <Movie> movies, List <ParkingPlace> parking)
{
var reservedSeats = new List <MovieSeat>();
var reservedMovies = new List <Movie>();
foreach (var movie in movies)
{
foreach (var seat in movie.Seats)
{
if (seat.Reserved && seat.UserId == userId)
{
reservedSeats.Add(seat);
if (!reservedMovies.Contains(movie))
{
reservedMovies.Add(movie);
}
}
}
}
var reservedParkingPlaces = new List <ParkingPlace>();
if (parking.Count > 0)
{
reservedParkingPlaces = parking.FindAll(x => x.UserId == userId).ToList();
}
var result = new UserReservation
{
ParkingPlaces = reservedParkingPlaces,
ReservedMovies = reservedMovies,
ReservedMovieSeats = reservedSeats,
UserId = userId
};
return(result);
}
public ActionResult SavePassword(Password newpass)
{
Entities db = new Entities();
UserReservation userReservation = new UserReservation();
foreach (User user in db.User)
{
if (Session["UserEmail"].ToString() == user.Email)
{
if (newpass.password != null && newpass.confirm != null)
{
user.Password = newpass.password;
userReservation = new UserReservation(user);
}
}
}
db.SaveChanges();
return(PartialView("ChangePlace", userReservation));
}
public bool createReservation(string title, string placeId, string placeName, string placeAddress, string placeLat, string placeLng, string date, string startTime, string endTime, string numberPeople,
string sexString, string ageString, string cuisineType, bool smoke, bool pet, bool alcohol, string languages, string description)
{
// ViewData["UserType"] = Request.Cookies["UserType"] ?? "regular";
string startString = date + " " + startTime;
string endString = date + " " + endTime;
DateTime startDate = DateTime.ParseExact(startString, "yyyy-MM-dd HH:mm", null);
DateTime endDate = DateTime.ParseExact(endString, "yyyy-MM-dd HH:mm", null);
string userID = _userManager.GetUserId(User);
if (!rr.placeIdExist(placeId))
{
Place place = new Place()
{
Id = placeId,
Latitude = Convert.ToDouble(placeLat),
Longtitude = Convert.ToDouble(placeLng),
Name = placeName,
Address = placeAddress
};
_context.Place.Add(place);
_context.SaveChanges();
}
Reservation reservation = new Reservation()
{
Id = rr.GenerateReservationId(),
Title = title,
DateStart = startDate,
DateEnd = endDate,
NumberOfPeople = Int32.Parse(numberPeople),
Status = "open",
PlaceID = placeId,
UserId = userID
};
rr.CreateReservation(reservation);
UserReservation userReservation = new UserReservation
{
UserID = reservation.UserId,
ReservationID = reservation.Id,
isHost = true
};
_context.UserReservation.Add(userReservation);
_context.SaveChanges();
Limitations limitations = new Limitations()
{
Id = reservation.Id,
Gender = sexString,
CuisineType = cuisineType,
Age = ageString,
Smoking = smoke,
Pets = pet,
Alcohol = alcohol,
Languages = languages,
Description = description
};
_context.Limitations.Add(limitations);
_context.SaveChanges();
return(true);
}
public async Task <ReservationResponseDto> ReservationAsync(ReservationDto reservationDTO)
{
if (reservationDTO.EndTime < reservationDTO.StartTime)
{
throw new BadRequestException($"No puede terminar la reserva antes de empezar");
}
if (reservationDTO.EndTime.Minute > 0 || reservationDTO.StartTime.Minute > 0)
{
throw new BadRequestException($"La reserva se debe realizar en horas completas");
}
if (reservationDTO.StartTime.Hour < 7 || reservationDTO.StartTime.Hour >= 23 ||
reservationDTO.EndTime.Hour > 23 || reservationDTO.EndTime.Hour <= 7)
{
throw new BadRequestException($"Los cubículos son solo de 7:00 am a 11:00 pm");
}
/* if (reservationDTO.StartTime.DayOfWeek == DayOfWeek.Sunday)
* {
* throw new BadRequestException($"Los cubículos no estan disponibles los domingos.");
* }*/
TimeSpan validate24Hrs = DateTime.Now.Subtract(reservationDTO.EndTime);
if (validate24Hrs.Days >= 1)
{
throw new BadRequestException($"Solo se puede reservar con 24 hrs de anticipación.");
}
/*
* if (DateTime.Now > reservationDTO.StartTime && (validate24Hrs.Hours >= 1 || validate24Hrs.Minutes > 15))
* {
* throw new BadRequestException(
* $"Solo se puede reservar cubículos hasta 15 minutos después de su inicio.");
* }*/
TimeSpan rest = reservationDTO.EndTime.Subtract(reservationDTO.StartTime);
if ((rest.Hours <= 0 || rest.Hours > 2))
{
throw new BadRequestException($"Máximo 2 horas de reserva.");
}
ICollection <Reservation> reservations = await _reservationRepository.FindByCubicleAndTimeIntervalAsync(
reservationDTO.cubicleID,
reservationDTO.StartTime, reservationDTO.EndTime);
if (reservations.Count > 0)
{
throw new BadRequestException($"El cubículo esta ocupado");
}
ICollection <UserReservation> userReservations =
await _userReservationRepository.ActiveReserveByUser(reservationDTO.hostID);
if (userReservations.Count > 0)
{
throw new BadRequestException($"Ya tiene una reserva activa");
}
DateTime day = new DateTime(reservationDTO.StartTime.Year, reservationDTO.StartTime.Month,
reservationDTO.StartTime.Day);
userReservations =
await _userReservationRepository.ReserveUserAndTimeInterval(reservationDTO.hostID, day, day.AddDays(1));
int hours = 0;
foreach (var item in userReservations)
{
TimeSpan duration = item.Reservation.EndTime.Subtract(item.Reservation.StartTime);
hours += duration.Hours;
}
if (hours > 2)
{
throw new BadRequestException($"Ya has usado tus horas máxima de reservas en el día");
}
var cubicle = await _cubicleRepository.FindOneByIdAsync(reservationDTO.cubicleID);
var user = await _userRepository.FindOneByIdAsync(reservationDTO.hostID);
if (cubicle == null)
{
throw new BadRequestException($"No existe ese cubículo");
}
if (user == null)
{
throw new BadRequestException($"No existe ese usuario");
}
var userReservation = new UserReservation
{
UserRoleId = UserReservationRoles.Host,
User = user,
IsActive = true,
CreatedAt = DateTime.Now,
UpdatedAt = DateTime.Now
};
Reservation reservation = new Reservation
{
UserReservations = new List <UserReservation>(),
StartTime = reservationDTO.StartTime,
ReservationStateId = ReservationStates.NotActive,
EndTime = reservationDTO.EndTime,
HostLeaveTime = reservationDTO.EndTime,
IsActive = true,
CreatedAt = DateTime.Now,
UpdatedAt = DateTime.Now,
};
reservation.UserReservations.Add(userReservation);
cubicle.Reservations.Add(reservation);
await _cubicleRepository.UpdateAsync(cubicle);
var response = new ReservationResponseDto
{
Id = cubicle.Reservations.Last().Id,
CubicleCode = cubicle.Code,
CubicleDescription = cubicle.Description,
CubicleTotalSeats = cubicle.TotalSeats,
StartTime = reservation.StartTime,
EndTime = reservation.EndTime
};
return(response);
}
public ActionResult Save(User modifyUser)
{
Entities db = new Entities();
UserReservation userReservation = new UserReservation();
foreach (User user in db.User)
{
if (Session["UserEmail"].ToString() == user.Email)
{
if (modifyUser.FirstName != null)
{
user.FirstName = modifyUser.FirstName;
Session["UserFirstName"] = modifyUser.FirstName;
}
if (modifyUser.Surname != null)
{
user.Surname = modifyUser.Surname;
Session["UserSurname"] = modifyUser.Surname;
}
if (modifyUser.Email != null)
{
user.Email = modifyUser.Email;
Session["UserEmail"] = modifyUser.Email;
}
userReservation = new UserReservation(user);
}
}
db.SaveChanges();
return PartialView("ChangePlace", userReservation);
}
public ActionResult SavePassword(Password newpass)
{
Entities db = new Entities();
UserReservation userReservation = new UserReservation();
foreach (User user in db.User)
{
if (Session["UserEmail"].ToString() == user.Email)
{
if (newpass.password != null && newpass.confirm!=null)
{
user.Password = newpass.password;
userReservation = new UserReservation(user);
}
}
}
db.SaveChanges();
return PartialView("ChangePlace",userReservation);
}
public UserReservation RetrieveById(UserReservation userReservation) => crudUserReservation.Retrieve <UserReservation>(userReservation);
public void Create(User user, Reservation reservation)
{
var userReservation = new UserReservation(user, reservation);
_userReservationRepository.Add(userReservation);
}
public UserReservation GetUserReservation(int userReservationId)
{
UserReservation ur = _context.UserReservations.Where(x => x.UserReservationID == userReservationId).FirstOrDefault();
return(ur);
}
public void Add(UserReservation userReservation)
{
_context.UserReservations.Add(userReservation);
_context.Save();
}
