public static AvailabilityReq GetAvailabilityForCancelFromDB(string sid, string HotelCode, string roomcode, string pid)
{
AvailabilityReq availabilityReq = new AvailabilityReq();
try
{
SearchDBEntities searchDB = new SearchDBEntities();
using (HotelBookingDBEntities db = new HotelBookingDBEntities())
{
availabilityReq.HotelCode = HotelCode;
availabilityReq.PID = pid;
availabilityReq.Sid = sid;
var roomsData = searchDB.SearchRoomResults.Where(x => x.sID == sid && x.HotelCode == HotelCode && x.RoomCode == roomcode && x.ProviderId.ToString() == pid).ToList();
for (int i = 0; i < roomsData.Count; i++)
{
RoomAvailability room = new RoomAvailability();
room.RoomId = int.Parse(roomsData[i].RoomCode);
room.RoomRef = roomsData[i].RoomReference;
availabilityReq.Rooms.Add(room);
availabilityReq.TotalCost += roomsData[i].costPrice.Value;
}
}
return(availabilityReq);
}
catch (Exception ex)
{
throw ex;
}
}
public IActionResult Available(string Date, int RoomId)
{
try {
//Load All of the Reservations
_resevationRepository.GetAll();
string ProcessedDate = Date;
IList <RoomAvailability> Availability = new List <RoomAvailability>();
IList <Room> Rooms = _roomRepository.GetAll();
foreach (Room Room in Rooms)
{
RoomModel model = new RoomModel(Room);
RoomAvailability AvailabilityItem = new RoomAvailability();
List <RoomDetailTime> TimesAvailable = model.GetTimes(ProcessedDate).Where(t => t.available == true).ToList();
AvailabilityItem.RoomId = Room.RoomId;
AvailabilityItem.Name = Room.Name;
AvailabilityItem.OpenFrom = Room.OpenFrom.ToString() + ":00";
AvailabilityItem.OpenTill = Room.OpenTill.ToString() + ":00";
AvailabilityItem.TimesAvailable = TimesAvailable;
Availability.Add(AvailabilityItem);
}
return(Json(Availability));
} catch (Exception e)
{
return(BadRequest(e));
}
}
public RoomAvailabilityPickerItem(RoomAvailability value)
: base(value)
{
RelativeSizeAxes = Axes.Y;
Width = 102;
Masking = true;
CornerRadius = 5;
Children = new Drawable[]
{
new Box
{
RelativeSizeAxes = Axes.Both,
Colour = Color4Extensions.FromHex(@"3d3943"),
},
selection = new Box
{
RelativeSizeAxes = Axes.Both,
Alpha = 0,
},
hover = new Box
{
RelativeSizeAxes = Axes.Both,
Colour = Color4.White,
Alpha = 0,
},
new OsuSpriteText
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
Font = OsuFont.GetFont(weight: FontWeight.Bold),
Text = value.GetDescription(),
},
};
}
public static HotelAvailability ParseHotelAvailability(string response)
{
//Room IDs:
//One bedroom Condo:
//inventory_id_111140, inventory_id_104610, inventory_id_104719, inventory_id_121005, inventory_id_104718, inventory_id_113921
//Two bedroom condo:
//inventory_id_113926
//Grotto Suites - 2 BDR + Den:
//inventory_id_73032, inventory_id_73030
// Grotto Plus - 3 BDR :
//inventory_id_87228, inventory_id_87267
Dictionary <string, RoomAvailability> roomAvailabilities = new Dictionary <string, RoomAvailability>();
int startIndex = response.IndexOf('{');
int endIndex = response.Length - 1;
string json = response.Substring(startIndex, endIndex - startIndex);
//System.IO.File.WriteAllText(@"C:\Users\Chloe\source\repos\TESTFORJSON\SummitJson.txt", json);
Dictionary <string, dynamic> root = JsonConvert.DeserializeObject <Dictionary <string, dynamic> >(json);
List <dynamic> roomAvailabilityData = root["room_types"].ToObject <List <dynamic> >();
foreach (dynamic room in roomAvailabilityData)
{
RoomAvailability roomAvailability = ParseSingleRoomAvailability(room.ToObject <Dictionary <string, dynamic> >());
roomAvailabilities[roomAvailability.RoomNumber] = roomAvailability;
}
Console.WriteLine("Successfully parsed");
return(new HotelAvailability(HotelName.SUMMIT_PENTHOUSES, roomAvailabilities));
}
public void StartBookingProcess(BookingDetails details)
{
if (details != null)
{
// check for availability
DateTime selectedDate = details.BookingCriteria.FromDate;
bool proceedBooking = true;
while (selectedDate <= details.BookingCriteria.ToDate)
{
RoomAvailability availability = DbAccess.GetReservationDetails(selectedDate);
if (availability.NoofAvailableRooms == 0)
{
proceedBooking = false;
details.Status = Status.UnConfirmed;
break;
}
selectedDate = selectedDate.AddDays(1);
}
if (proceedBooking)
{
details.Status = Status.Confirm;
// insert the booking into DB
DbAccess.Bookreservation(details);
}
}
}
public void MergeWith(RoomAvailability otherAvailability)
{
if (!otherAvailability.RoomNumber.Equals(RoomNumber))
{
throw new Exception("Error: Cannot merge availabilities for different rooms into one object");
}
foreach (KeyValuePair <DateTime, AvailabilityType> otherEntry in otherAvailability.TotalAvailability)
{
DateTime otherKey = otherEntry.Key;
AvailabilityType otherValue = otherEntry.Value;
if (TotalAvailability.ContainsKey(otherKey))
{
AvailabilityType existingValue = TotalAvailability[otherKey];
if (otherValue.Equals(AvailabilityType.NOT_SET) ^ existingValue.Equals(AvailabilityType.NOT_SET))
{
throw new Exception("Error when merging room availabilities for date " +
otherKey.ToLongDateString() + "; One value was set and the other was null");
}
else if (!otherValue.Equals(AvailabilityType.NOT_SET) && !existingValue.Equals(AvailabilityType.NOT_SET) && !otherValue.Equals(existingValue))
{
throw new Exception("Error when merging room availabilities for date " +
otherKey.ToLongDateString() + "; One value was " + otherValue.ToString() + " and the other was " + existingValue.ToString());
}
}
else
{
TotalAvailability.Add(otherKey, otherEntry.Value);
}
}
}
public static async Task AddAvailabilityAroundDate(HotelAvailability hotelAvailability, DateTime requestDate, Dictionary <string, Object> roomsData)
{
Dictionary <string, RoomAvailability> roomAvailabilities = hotelAvailability.RoomAvailabilities;
List <string> fullRoomNumbers = (List <string>)roomsData[ROOM_NUMBERS_KEY];
string requestDateString = DateUtils.GetMonthDayShortYearFormat(requestDate);
// Dictionary<string, Task<string>> pageRequests = new Dictionary<string, Task<string>>();
// TODO: Randomize request order for rooms
foreach (string fullRoomNumber in fullRoomNumbers)
{
Console.WriteLine("Getting data for room: " + fullRoomNumber + " - " + hotelAvailability.Name.Name);
string roomNumber = fullRoomNumber.Split(new [] { '-' })[1].Trim();
string resortCode = (string)roomsData[RESORT_CODE_KEY];
string roomNumberCode = (string)roomsData[ROOM_NUMBER_CODE_KEY];
string url;
if (roomsData.ContainsKey(PROPERTY_CODE_KEY))
{
url = String.Format("http://irmestore.bigwhite.com/irmnet/res/RoomDetailsPage.aspx?Resort={0}&PropertyCode={1}&RoomNum={2}{3}&Arrival={4}",
resortCode, roomsData[PROPERTY_CODE_KEY], roomNumberCode, roomNumber, requestDateString);
}
else
{
url = String.Format("http://irmestore.bigwhite.com/irmnet/res/RoomDetailsPage.aspx?Resort={0}&RoomNum={1}{2}&Arrival={3}",
resortCode, roomNumberCode, roomNumber, requestDateString);
}
Task <string> page = GetPage(url);
// pageRequests.Add(fullRoomNumber, page);
string pageText = await page;
RoomAvailability roomAvailability = BigWhiteParser.ParseSingleRoomAvailability(pageText, roomNumber);
if (!roomAvailabilities.ContainsKey(fullRoomNumber))
{
roomAvailabilities.Add(fullRoomNumber, roomAvailability);
}
else
{
roomAvailabilities[fullRoomNumber].MergeWith(roomAvailability);
}
}
/*foreach (KeyValuePair<string, Task<string>> pageRequest in pageRequests)
* {
* string fullRoomNumber = pageRequest.Key;
* string roomNumber = fullRoomNumber.Split(new[] { '-' })[1].Trim();
* string pageText = await pageRequest.Value;
* Console.WriteLine("Page received");
* RoomAvailability roomAvailability = BigWhiteParser.ParseSingleRoomAvailability(pageText, roomNumber);
* if (!roomAvailabilities.ContainsKey(fullRoomNumber))
* {
* roomAvailabilities.Add(fullRoomNumber, roomAvailability);
* }
* else
* {
* roomAvailabilities[fullRoomNumber].MergeWith(roomAvailability);
* }
* }*/
}
public IHttpActionResult PutRoomAvailability(string id, RoomAvailability roomAvailability)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != roomAvailability.BookingID)
{
return(BadRequest());
}
db.Entry(roomAvailability).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!RoomAvailabilityExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public IHttpActionResult PostRoomAvailability(RoomAvailability roomAvailability)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.RoomAvailabilities.Add(roomAvailability);
try
{
db.SaveChanges();
}
catch (DbUpdateException)
{
if (RoomAvailabilityExists(roomAvailability.BookingID))
{
return(Conflict());
}
else
{
throw;
}
}
return(CreatedAtRoute("DefaultApi", new { id = roomAvailability.BookingID }, roomAvailability));
}
public static void Parse(String page, HotelAvailability hotelAvailability, DateTime requestDate)
{
HtmlDocument htmlDocument = new HtmlDocument();
htmlDocument.LoadHtml(page);
HtmlNode rootDiv = htmlDocument.GetElementbyId("availTbl");
HtmlNode table = rootDiv.ChildNodes.ElementAt(1);
HtmlNode tHead = table.ChildNodes.ElementAt(1);
HtmlNode datesTr = tHead.ChildNodes.ElementAt(1);
List <DateTime> dates = GetDateRange(datesTr, requestDate);
HtmlNode tBody = table.ChildNodes.ElementAt(3);
for (int i = 1; i < tBody.ChildNodes.Count; i += 2)
{
HtmlNode roomInfoTr = tBody.ChildNodes.ElementAt(i);
RoomAvailability roomAvailability = GetRoomAvailability(roomInfoTr, dates);
if (!hotelAvailability.RoomAvailabilities.ContainsKey(roomAvailability.RoomNumber))
{
hotelAvailability.RoomAvailabilities.Add(roomAvailability.RoomNumber, roomAvailability);
}
else
{
RoomAvailability existingRoomAvailability = hotelAvailability.RoomAvailabilities[roomAvailability.RoomNumber];
existingRoomAvailability.MergeWith(roomAvailability);
}
}
}
public ActionResult DeleteConfirmed(string id)
{
RoomAvailability roomAvailability = db.RoomAvailabilities.Find(id);
db.RoomAvailabilities.Remove(roomAvailability);
db.SaveChanges();
return(RedirectToAction("RoomAvailability", "Home"));
}
public void MergeWith(HotelAvailability otherAvailabililty)
{
foreach (KeyValuePair <string, RoomAvailability> roomAvailabilityInfo in otherAvailabililty.RoomAvailabilities)
{
RoomAvailability correspondingRoomAvailability = RoomAvailabilities[roomAvailabilityInfo.Key];
roomAvailabilityInfo.Value.MergeWith(correspondingRoomAvailability);
}
}
public void Save(RoomAvailability roomAvailability)
{
if (roomAvailability.RoomId == Ids.OptimisticLockRoom)
{
throw new OptimisticLockException(nameof(RoomAvailability), roomAvailability.Id, 2, 1);
}
store.Save(roomAvailability);
Saved = roomAvailability;
}
public void NoAvailability()
{
var availability = new RoomAvailability(Ids.NotAvailableRoom, 0);
var result = availability.Book(Ids.JonSnow, 1);
Assert.False(result);
Assert.Equal(0, availability.Quantity);
Assert.Null(availability.BookingFor(Ids.JonSnow));
}
public ActionResult Edit([Bind(Include = "BookingID,RoomStatus,StaffIncharge,FirstName,LastName,CheckinDate,CheckoutDate,NumberOfAdult,NumberOfKid,ContactNumber,MailingAddress,EmailAddress,PaymentDetails,CreditCardNumber,CreditCardHolderName,CreditCardExpiryDate,AdditionalRemarks,LateCheck")] RoomAvailability roomAvailability)
{
if (ModelState.IsValid)
{
db.Entry(roomAvailability).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("RoomAvailability", "Home"));
}
return(View(roomAvailability));
}
public void SuccessfulBooking()
{
var availability = new RoomAvailability(Ids.AvailableRoom, 10);
var result = availability.Book(Ids.JonSnow, 1);
Assert.True(result);
Assert.Equal(9, availability.Quantity);
Assert.Equal(new RoomAvailabilityBooking(Ids.JonSnow, 1), availability.BookingFor(Ids.JonSnow));
}
public IHttpActionResult GetRoomAvailability(string id)
{
RoomAvailability roomAvailability = db.RoomAvailabilities.Find(id);
if (roomAvailability == null)
{
return(NotFound());
}
return(Ok(roomAvailability));
}
public void CustomerAlreadyBook()
{
var availability = new RoomAvailability(Ids.AvailableRoom, 10);
availability.Book(Ids.JonSnow, 1);
var result = availability.Book(Ids.JonSnow, 2);
Assert.False(result);
Assert.Equal(9, availability.Quantity);
Assert.Equal(new RoomAvailabilityBooking(Ids.JonSnow, 1), availability.BookingFor(Ids.JonSnow));
}
/// <summary>
/// Handles the Click event of the _btnAddDates control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
protected void _btnAddDates_Click(object sender, EventArgs e)
{
var startDate = (DateTime)_rdpStartDate.DbSelectedDate;
var startTime = ((DateTime)_rtpStartTime.DbSelectedDate).TimeOfDay;
var endDate = _rdpEndDate.DbSelectedDate;
var endTime = ((DateTime)_rtpEndTime.DbSelectedDate).TimeOfDay;
var days = _rcbDays.CheckedItems.Aggregate(String.Empty, (current, item) => current + (item.Value + ",")).TrimEnd(',');
var isVald = GetIsValdAddDates(days, endDate, startDate, startTime, endTime);
if (isVald == false)
{
return;
}
//Check for any overlap here
var appointMentToAdd = new AppointmentTemporaryObj
{
AllDay = false,
Days = days,
EndDate = (DateTime?)endDate,
EndTime = endTime,
RoomId = RoomId,
StartDate = startDate,
StartTime = startTime
};
var db = new UrbanDataContext();
var currentAvilList = db.Manager.RoomAvailability.GetByRoomID(RoomId).OrderByDescending(t => t.StartDate).ToList();
//Check if date to add is valid over existing range of dates.
if (AppointmentTemporaryObj.DoesDateOverLap(appointMentToAdd, currentAvilList.ToAppointmentTempObject()))
{
WriteFeedBackMaster(FeedbackType.Error, "Date overlaps");
return;
}
var newAppointment = new RoomAvailability
{
AllDay = appointMentToAdd.AllDay,
Days = appointMentToAdd.Days == String.Empty ? null : appointMentToAdd.Days,
EndDate = appointMentToAdd.EndDate,
EndTime = appointMentToAdd.EndTime,
RoomID = RoomId,
StartDate = appointMentToAdd.StartDate,
StartTime = appointMentToAdd.StartTime
};
db.RoomAvailability.InsertOnSubmit(newAppointment);
db.SubmitChanges();
RebindGridAndScheduler();
}
public void IncrementVersion()
{
var store = new InMemoryRoomAvailabilityStore();
var newAvailability = new RoomAvailability(Ids.AvailableRoom, 10);
store.Save(newAvailability);
var availability = store.LoadForRoom(Ids.AvailableRoom);
Assert.NotNull(availability);
Assert.Equal(0, newAvailability.Version);
Assert.Equal(1, availability.Version);
}
public IHttpActionResult DeleteRoomAvailability(string id)
{
RoomAvailability roomAvailability = db.RoomAvailabilities.Find(id);
if (roomAvailability == null)
{
return(NotFound());
}
db.RoomAvailabilities.Remove(roomAvailability);
db.SaveChanges();
return(Ok(roomAvailability));
}
// GET: RoomAvailabilities/Delete/5
public ActionResult Delete(string id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
RoomAvailability roomAvailability = db.RoomAvailabilities.Find(id);
if (roomAvailability == null)
{
return(HttpNotFound());
}
return(View(roomAvailability));
}
public void Save(RoomAvailability roomAvailability)
{
var @new = Clone(roomAvailability);
IncrementVersionOf(@new);
roomAvailabilitiesByRoomId.AddOrUpdate(@new.RoomId,
_ => Serialize(@new),
(_, str) =>
{
var current = Deserialize(str);
if (current.Version >= @new.Version)
{
ThrowOptimisticLock(@new, current);
}
return(Serialize(@new));
});
}
/// <summary>
/// Calculates the recurring from availble.
/// </summary>
/// <param name="avail">The avail.</param>
/// <param name="endDate">The end date.</param>
/// <returns></returns>
private static IEnumerable <AppointmentObj> CalculateRecurringFromAvailble(RoomAvailability avail, DateTime endDate)
{
var dayList = ParseDayString(avail.Days);
var apptList = new List <AppointmentObj>();
//recurring dates
var days = 0;
for (var date = avail.StartDate.Add(avail.StartTime); date.Date < endDate; date = date.AddDays(1))
{
if (dayList.Contains(date.DayOfWeek)) //Handle day of the week recurring
{
apptList.Add(new AppointmentObj("Available", avail.StartDate.Add(avail.StartTime).AddDays(days), avail.StartDate.Add(avail.EndTime).AddDays(days), "", "", "", avail.Room.UserID, false, avail.Id));
}
days++;
}
return(apptList);
}
public static AvailabilityValidModel GetAvailabilityFromDB(string sid, string BN)
{
AvailabilityValidModel availabilityValid = new AvailabilityValidModel();
AvailabilityReq availabilityReq = new AvailabilityReq();
try
{
SearchDBEntities searchDB = new SearchDBEntities();
using (HotelBookingDBEntities db = new HotelBookingDBEntities())
{
var HotelBookin = db.HotelsBookings.FirstOrDefault(x => x.SessionId == sid && x.Booking_No == BN);
availabilityReq.HotelCode = HotelBookin.Hotel_ID;
availabilityReq.BookingNum = BN;
availabilityReq.PID = HotelBookin.Provider_ID;
availabilityReq.Sid = sid;
availabilityValid.Curr = HotelBookin.Sell_Currency;
var BookedRooms = db.HotelBookingRooms.Where(x => x.SID == sid && x.Booking_No == BN).ToList();
var lstRooms = BookedRooms.Select(s => s.Room_No.ToString()).ToList();
var roomsData = searchDB.SearchRoomResults.Where(x => x.sID == sid && x.HotelCode == HotelBookin.Hotel_ID && lstRooms.Contains(x.RoomCode) && x.ProviderId.ToString() == HotelBookin.Provider_ID).ToList();
if (roomsData != null && roomsData.Count > 0)
{
for (int i = 0; i < BookedRooms.Count; i++)
{
RoomAvailability room = new RoomAvailability();
var roomData = roomsData.FirstOrDefault(a => a.RoomCode == BookedRooms[i].Room_No.ToString());
room.RoomId = int.Parse(roomData.RoomCode);
room.RoomRef = roomData.RoomReference;
room.Cost = roomData.costPrice.Value;
availabilityReq.Rooms.Add(room);
availabilityReq.TotalCost += roomData.costPrice.Value;
}
}
}
availabilityValid.availabilityReq = availabilityReq;
return(availabilityValid);
}
catch (Exception ex)
{
throw ex;
}
}
public int GetRoomAvy()
{
var roomavailability = new RoomAvailability();
Console.Clear();
Console.WriteLine("Thank you.\n Now, I will need to know how many rooms of this type are available.\n Please insert the number of rooms available in your hotel for this type.");
var roomavy = Console.ReadLine();
int.TryParse(roomavy, out int result);
var looproomavy = result;
while (looproomavy == 0)
{
Console.WriteLine("Invalid Number. Please insert the number of rooms available in your hotel for this type.");
roomavy = Console.ReadLine();
int.TryParse(roomavy, out int result1);
looproomavy = result1;
}
return(Convert.ToInt32(roomavy));
}
public static HotelAvailability ParseHotelAvailability(string response)
{
Dictionary <string, RoomAvailability> roomAvailabilities = new Dictionary <string, RoomAvailability>();
int startIndex = response.IndexOf('{');
int endIndex = response.Length - 1;
string json = response.Substring(startIndex, endIndex - startIndex);
//System.IO.File.WriteAllText(@"C:\Users\Chloe\source\repos\TESTFORJSON\FireJson.txt", json);
Dictionary <string, dynamic> root = JsonConvert.DeserializeObject <Dictionary <string, dynamic> >(json);
List <dynamic> roomAvailabilityData = root["room_types"].ToObject <List <dynamic> >();
foreach (dynamic room in roomAvailabilityData)
{
RoomAvailability roomAvailability = ParseSingleRoomAvailability(room.ToObject <Dictionary <string, dynamic> >());
roomAvailabilities[roomAvailability.RoomNumber] = roomAvailability;
}
Console.WriteLine("Successfully parsed");
return(new HotelAvailability(HotelName.FIRE_MOUNTAIN, roomAvailabilities));
}
private static string Serialize(RoomAvailability roomAvailability) => JsonConvert.SerializeObject(roomAvailability);
private static void IncrementVersionOf(RoomAvailability availability) => availability.GetType().GetProperty(nameof(RoomAvailability.Version)) .SetValue(availability, availability.Version + 1);
private static RoomAvailability Clone(RoomAvailability roomAvailability) => Deserialize(Serialize(roomAvailability));
