public async Task <IActionResult> SelectBarber(BarberModel model)
{
if (string.IsNullOrEmpty(model.SelectedBarber))
{
TempData.Put("message", new AlertType()
{
Title = "Hata",
Message = "Boş bırakılamaz!",
Alert = "warning"
}
);
return(View(model));
}
var barber = await _userManager.FindByIdAsync(model.SelectedBarber);
if (barber == null)
{
TempData.Put("message", new AlertType()
{
Title = "Hata",
Message = "Kuaför seçmeniz gerekiyor!",
Alert = "warning"
}
);
return(View(model));
}
var times = _bookingService.GetBusyDays(model.SelectedBarber);
var model2 = new BookingModel()
{
CustomerId = model.CustomerId,
EmployeeId = model.SelectedBarber,
StartDate = times[0].Day + "/" + times[0].Month + "/" + times[0].Year,
EndDate = times[times.Count - 1].Day + "/" + times[times.Count - 1].Month + "/" + times[times.Count - 1].Year,
};
return(View("SelectDay", model2));
}
public bool update(BookingModel booking, int id)
{
bool rtn = false;
SqlParameter[] parameters =
{
new SqlParameter {
ParameterName = "@id", Value = id
},
new SqlParameter {
ParameterName = "@idRoom", Value = booking.idRoom
},
new SqlParameter {
ParameterName = "@idClient", Value = booking.idClient
},
new SqlParameter {
ParameterName = "@date", Value = booking.date
},
new SqlParameter {
ParameterName = "@startHour", Value = booking.startHour
},
new SqlParameter {
ParameterName = "@endHour", Value = booking.endHour
},
new SqlParameter {
ParameterName = "@result", Direction = ParameterDirection.Output, DbType = DbType.Int32
}
};
SqlParameter[] outputs = base.ExecuteNonQuery("usp_booking_u_booking", parameters);
if (outputs != null && outputs.Length > 0)
{
rtn = Convert.ToBoolean(outputs[0].Value);
}
return(rtn);
}
public ActionResult Save(PassengerModel model, string selectedSeats, long boardingPoint, long droppingPoint, string payment)
{
if (ModelState.IsValid)
{
try
{
binder.passenger.Add(model);
binder.SaveChanges();
BookingModel bkModel = new BookingModel();
bkModel.PassengerId = model.Id;
bkModel.TripId = trpId;
bkModel.BoardingPoint = boardingPoint;
bkModel.DroppingPoint = droppingPoint;
bkModel.PaymentMethod = payment;
binder.booking.Add(bkModel);
binder.SaveChanges();
string[] seat = selectedSeats.Split(' ');
for (int i = 0; i < seat.Length - 1; i++)
{
BookingList bkList = new BookingList();
bkList.BookingId = bkModel.Id;
bkList.SeatNo = seat[i];
binder.bookingList.Add(bkList);
binder.SaveChanges();
}
}
catch (Exception e)
{
}
}
return(RedirectToAction("Index", "Home"));
}
/// <summary>
/// checks if booking exists via booking model (tableID)
/// </summary>
public static bool CheckTableStatus(BookingModel bookingModel)
{
string sTest = null;
SqlConnection conn = new SqlConnection(ConfigurationManager.ConnectionStrings["ConnectionString"].ConnectionString);
using (conn)
{
conn.Open();
using (SqlCommand command = new SqlCommand(
"SELECT * FROM tblBooking WHERE tableID=" + "'" + bookingModel.tableID.ToString() + "'"
+ " AND bookingDate=" + "'" + bookingModel.bookingDate.ToString("yyyy-MM-d") + "'"
+ " AND bookingHour=" + "'" + bookingModel.bookingHour.ToString() + "'",
conn))
{
SqlDataReader dr = command.ExecuteReader();
while (dr.Read())
{
sTest = dr["bookingHour"].ToString();
}
dr.Close();
}
conn.Close();
}
if (sTest == null)
{
return(true); // = available to book
}
return(false); // = table is already booked
}
public BookingModel CreateBooking(BookingModel booking)
{
var result = CreateBooking(SimpleMapper.Map <Booking>(booking), SimpleMapper.MapCollection <Guest>(booking.Guests));
if (result.Item1)
{
BookingModel newBoooking = SimpleMapper.Map <BookingModel>(result.Item2);
newBoooking.Guests = SimpleMapper.MapCollection <GuestModel>(result.Item3);
newBoooking.Room = SimpleMapper.Map <RoomModel>(BookingoContext.DataBase().Rooms.Where(x => x.Id == booking.IdRoom).FirstOrDefault());
return(newBoooking);
}
return(null);
(bool, Booking, List <Guest>) CreateBooking(Booking newBooking, List <Guest> guests)
{
bool created = false;
using (BookingoContext context = BookingoContext.NewDataBase())
{
Booking createdBooking = context.Bookings.Add(newBooking);
if (createdBooking != null)
{
List <Guest> createdGuests = new List <Guest>();
foreach (Guest guest in guests)
{
guest.IdBooking = createdBooking.Id;
createdGuests.Add(context.Guests.Add(guest));
}
context.SaveChanges();
created = true;
return(created, createdBooking, createdGuests);
}
return(created, null, null);
}
}
}
/**
* Method returns a string with attendance status
*
* @param booking Booking Model
* @return text of booking's attendance status
*/
public string getAttendanceTextPerBooking(BookingModel booking)
{
if (booking.getAttendance() == 1 && booking.getConfirmation() == 1 && booking.getLackOfCancellation() == 0)
{
return(ATTENDANCE_ON_TIME);
}
if (booking.getAttendance() == 2 && booking.getConfirmation() == 1 && booking.getLackOfCancellation() == 0)
{
return(ATTENDANCE_LATE);
}
if (booking.getAttendance() == 0 && booking.getConfirmation() == 0 && booking.getLackOfCancellation() == 0)
{
return(ATTENDANCE_CANCELLED);
}
if (booking.getAttendance() == 1 && booking.getConfirmation() == 1 && booking.getLackOfCancellation() == 1)
{
return(ATTENDANCE_IGNORED);
}
if (booking.getAttendance() == 0 && booking.getConfirmation() == 2 && booking.getLackOfCancellation() == 0)
{
return(ATTENDANCE_NOT_CONFIRMED);
}
return(ATTENDANCE_INCORRECT_DATA);
}
public ActionResult getTimeRemaining(string book_id)
{
BookingDetails book = new BookingDetails();
BookingModel bkm = new BookingModel();
bkm.book_id = book_id;
bkm = bkm.getBookingByBookId();
DateTime dtNow = DateTime.Now;
DateTime dtTarget;
if (DateTime.TryParse(bkm.tm, out dtTarget))
{
dtTarget = dtTarget.AddMinutes(2.00);
TimeSpan span = dtTarget - dtNow;
book.time = String.Format("{0:00}:{1:00}", span.Minutes, span.Seconds);
}
else
{
book.time = "00:00";
}
return(Json(book, JsonRequestBehavior.AllowGet));
}
public IActionResult Index(int?id)
{
if (id == null)
{
return(NotFound());
}
//Using singleton here, perhaps consider injecting an interface, like below.
BookingModel bookingModel = BookingModelFactory.Instance.CreateBookingModel();
try
{
bookingModel.Room = ((RoomFactory)createMultiple).GetSingle((int)id);
HttpContext.Session.SetObjectAsJson("currentRoom", bookingModel);
HttpContext.Response.Cookies.Append("currentRoom", bookingModel.Room.RoomNumber.ToString());
return(View(bookingModel));
}
catch (Exception e)
{
throw e;
}
}
public IHttpActionResult GetBooking(BookingModel model)
{
try
{
var UserId = ((ClaimsIdentity)User.Identity).Claims.FirstOrDefault(c => c.Type.Equals(ClaimTypes.NameIdentifier)).Value;
var RefType = ((ClaimsIdentity)User.Identity).Claims.FirstOrDefault(c => c.Type.Equals(ClaimTypes.Name)).Value;
BookingDL obj = new BookingDL();
BookingModel list = obj.GetBooking(Convert.ToInt32(UserId), Convert.ToInt32(RefType), model.BookingID);
list.success = true;
list.message = "Get booking details Successfully";
list.code = 200;
return(Ok(list));
}
catch (Exception ex)
{
responseData.message = ex.Message != null?ex.Message.ToString() : "server error";
return(Ok(responseData));
}
}
public async Task <ActionResult> Create([Bind(Include = "Event_Id,User_Id,User_Type")] BookingModel booking)
{
if (ModelState.IsValid)
{
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(baseUrl);
var response = await client.PostAsJsonAsync("api/Bookings", booking);
if (response.IsSuccessStatusCode)
{
logger.Info("Skapades ny bokning");
return(RedirectToAction("Index"));
}
else
{
logger.Error("Lyckades inte skapa ny bokning");
ModelState.AddModelError(string.Empty, "Server error try after some time.");
}
}
}
return(RedirectToAction("Index"));
}
public async Task Email_GetText_BookingConfirmation()
{
BookingModel bookingModel = CreateBooking(BookingStatuses.Created, true);
var emailService = new EmailService(_awsSes, _config);
string emailText = emailService.GetTextBody(EmailType.BookingConfirmation, bookingModel);
string visitType = GetVisitType(bookingModel);
await CheckCoreFields(bookingModel, emailText);
Assert.IsTrue(emailText.IndexOf(bookingModel.Phone) != -1);
Assert.IsTrue(emailText.IndexOf(visitType) != -1);
Assert.IsTrue(emailText.IndexOf("Standard Reading Room") != -1);
if (!String.IsNullOrWhiteSpace(bookingModel.AdditionalRequirements))
{
Assert.IsTrue(emailText.IndexOf(bookingModel.AdditionalRequirements) != -1);
}
await CheckDocumentOrders(bookingModel, emailText);
Assert.IsTrue(!String.IsNullOrEmpty(Environment.GetEnvironmentVariable(HOME_URL)));
Assert.IsTrue(emailText.IndexOf(RETURN_URL) != -1);
}
public async Task <ActionResult> UpdateEvent([Bind(Include = "Booking_Id,Event_Id,User_Id,User_Type")] BookingModel booking)
{
if (ModelState.IsValid)
{
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(baseUrl);
var response = await client.PutAsJsonAsync($"api/Bookings/{booking.Booking_Id}", booking);
if (response.IsSuccessStatusCode)
{
logger.Info("Uppdatera baserat på parametrar");
return(RedirectToAction("Event"));
}
else
{
logger.Error("Misslyckades med uppdatering");
ModelState.AddModelError(string.Empty, "Server error try after some time.");
}
}
return(RedirectToAction("Event"));
}
return(View(booking));
}
public async void Test_Count(BookingModel booking, StayModel stay)
{
await _connection.OpenAsync();
try
{
using (var ctx = new BookingContext(_options))
{
await ctx.Database.EnsureCreatedAsync();
await ctx.Bookings.AddAsync(booking);
await ctx.Stays.AddAsync(stay);
await ctx.SaveChangesAsync();
}
using (var ctx = new BookingContext(_options))
{
var bookings = new Repository <BookingModel>(ctx);
var bookingCount = bookings.Count();
Assert.Equal(1, bookingCount);
}
using (var ctx = new BookingContext(_options))
{
var stays = new Repository <StayModel>(ctx);
var stayCount = stays.Count();
Assert.Equal(1, stayCount);
}
}
finally
{
_connection.Close();
}
}
public IActionResult Checkin(int id, bool isEdit = true)
{
if (!Authentication.AuthenticateByCookie(HttpContext))
{
return(Redirect("/Receptionists/Authentication/Login?are=Receptionists&ctrl=Activities&act=Checkin"));
}
ViewBag.isEdit = isEdit;
BookingModel model = BookingDAO.GetBookingModel(id);
if (StayDAO.GetALLGuestsOfBooking(id).Count == 0)
{
StayDAO.InsertStay(new Stay()
{
BookingID = model.BookingID,
Status = null,
FromDate = DateTime.Now,
GuestID = model.Guest.GuestID,
ToDate = null
});
}
return(View(model));
}
public ActionResult Booking()
{
BookingModel p = new BookingModel();
p.tblBookings = _tour.DbBookingSelect(User.Identity.Name).Select(d => new tblBooking()
{
BookingId = d.BookingId,
TourId = d.TourId
}).ToList();
p.tblPackages = _tour.DbPackageSelect().Select(d => new tblPackage()
{
Tour_Name = d.Tour_Name,
Tour_ID = d.Tour_ID,
Package_Image = d.Package_Image,
Packagedetails = d.Packagedetails,
StartDate = d.StartDate,
EndDate = d.EndDate,
Price = d.Price,
Status = d.Status,
OfferInclude = d.OfferInclude,
OfferExclude = d.OfferExclude
}).ToList();
return(View(p));
}
/// <summary>
/// Gets all Booking information based on the bookingID provided.
/// </summary>
/// <param name="bookingID"></param>
/// <returns></returns>
internal BookingModel GetBooking(int bookingID)
{
BookingModel booking = new BookingModel();
booking.BookingID = bookingID;
booking.Devices = new List <DeviceModel>();
booking.Items = new List <ItemLineModel>();
SqlConnection con = new SqlConnection(connectionString);
SqlCommand cmd = new SqlCommand("GetBookingOnID", con);
cmd.CommandType = System.Data.CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@bookingID", bookingID);
con.Open();
SqlDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
booking.Customer = (string)reader["orderedBy"];
booking.BookingStatus = (byte)reader["status"];
// DeliveredBy and Notes may be DBNull (Not the same as null for C#), which means pulling them out and converting to string
// - gives a critical error.
booking.DeliveredBy = reader["deliveredBy"] == DBNull.Value ? null : (string)reader["deliveredBy"];
booking.Notes = reader["bookingNotes"] == DBNull.Value ? "" : (string)reader["bookingNotes"];
booking.PlannedBorrowDate = (DateTime)reader["rentDate"];
booking.PlannedReturnDate = (DateTime)reader["returnDate"];
booking.Location = new BuildingModel(
(string)reader["buildingName"],
(byte)reader["roomNr"]
);
}
con.Close();
return(booking);
}
public void AddOrderDetails(Consignee consignee, Shipper shipper, BookingModel booking)
{
_context.AddRange(consignee, shipper, booking);
_context.SaveChanges();
}
private async Task <DialogTurnResult> InitialStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
if (!_luisRecognizer.IsConfigured)
{
return(await stepContext.EndDialogAsync(null, cancellationToken));
}
var luisResult = await _luisRecognizer.RecognizeAsync <Booking>(stepContext.Context, cancellationToken);
double intentscore = (luisResult != null) ? luisResult.TopIntent().score : 0.0;
if (intentscore >= 0.80)
{
switch (luisResult.TopIntent().intent)
{
case Booking.Intent.booking:
var bookingDetail = new BookingModel();
if (!string.IsNullOrEmpty(luisResult.BookTime()))
{
var timex = luisResult.BookTime();
var resolution = TimexResolver.Resolve(new[] { timex }, DateTime.Today);
var timexProperty = new TimexProperty(timex);
var val = resolution.Values.ToArray();
var timeType = val[0].Type;
if (timeType == "timerange")
{
DateTime startTime = DateTime.Parse(val[0].Start);
DateTime endTime = DateTime.Parse(val[0].End);
bookingDetail.TimeFrom = startTime.ToString("H:mm");
bookingDetail.TimeTo = endTime.ToString("H:mm");
}
else if (timeType == "time")
{
DateTime startTime = DateTime.Parse(val[0].Value);
bookingDetail.TimeFrom = startTime.ToString("H:mm");
}
else if (timeType == "date")
{
var t = val[0].Value;
DateTime parsingDate = DateTime.Parse(val[0].Value);
bookingDetail.Date = parsingDate.ToString("d MMMM yyyy");
}
else if (timeType == "datetime")
{
var t = val[0].Value;
DateTime parsingDate = timex == "PRESENT_REF" ? DateTime.Now : DateTime.Parse(val[0].Value);
bookingDetail.Date = parsingDate.ToString("d MMMM yyyy");
bookingDetail.TimeFrom = parsingDate.ToString("H:mm");
}
else if (timeType == "daterange")
{
var t = val[0].Start;
DateTime parsingDate = DateTime.Parse(val[0].Start);
bookingDetail.Date = parsingDate.ToString("d MMMM yyyy");
}
else if (timeType == "datetimerange")
{
var t = val[0].Start;
var t2 = val[0].End;
DateTime parsingDateStart = DateTime.Parse(val[0].Start);
DateTime parsingDateEnd = DateTime.Parse(val[0].End);
bookingDetail.Date = parsingDateStart.ToString("d MMMM yyyy");
bookingDetail.TimeFrom = parsingDateStart.ToString("H:mm");
var startDate = parsingDateStart.Date;
var endDate = parsingDateEnd.Date;
if (DateTime.Compare(startDate, endDate) == 0)
{
bookingDetail.TimeTo = parsingDateEnd.ToString("H:mm");
}
}
}
bookingDetail.AssetName = luisResult.RoomEntities();
return(await stepContext.BeginDialogAsync(nameof(BookingDialog), bookingDetail, cancellationToken));
case Booking.Intent.greeting:
await stepContext.Context.SendActivityAsync("Hi , I'm chat bot");
return(await stepContext.ReplaceDialogAsync(InitialDialogId, "greet", cancellationToken));
case Booking.Intent.cancel:
return(await stepContext.BeginDialogAsync(nameof(CancelDialog), null, cancellationToken));
default:
// Catch all for unhandled intents
var didntUnderstandMessageText = $"Sorry, I didn't get that. Please try asking in a different way.";
var didntUnderstandMessage = MessageFactory.Text(didntUnderstandMessageText, didntUnderstandMessageText, InputHints.IgnoringInput);
errorTimes++;
await stepContext.Context.SendActivityAsync(didntUnderstandMessage, cancellationToken);
return(await stepContext.ReplaceDialogAsync(InitialDialogId, "booking", cancellationToken));
}
}
else
{
var message = "Sorry, I don't understand your question. Please try asking in a different way ";
var topIntent = luisResult.TopIntent().intent.ToString();
await stepContext.Context.SendActivityAsync(message);
errorTimes++;
return(await stepContext.ReplaceDialogAsync(InitialDialogId, topIntent, cancellationToken));
}
}
public void Save(BookingModel booking)
{
// validasi
}
public void SaveBooking(BookingModel model, string userId)
{
string BookingSerList = "";
if (model.BookingSerList != null && model.BookingSerList.Count > 0)
{
BookingSerList = ObjectToXMLGeneric(model.BookingSerList);
BookingSerList = BookingSerList.Replace("<?xml version=\"1.0\" encoding=\"utf-16\"?>", "");
}
else
{
model.BookingSerList = new List <BookingSerModel>();
}
string EHCbenefitsList = "";
if (model.EHCbenefitsList != null && model.EHCbenefitsList.Count > 0)
{
EHCbenefitsList = ObjectToXMLGeneric(model.EHCbenefitsList);
EHCbenefitsList = EHCbenefitsList.Replace("<?xml version=\"1.0\" encoding=\"utf-16\"?>", "");
}
else
{
model.EHCbenefitsList = new List <EHCbenefitsModel>();
}
if (model.DOB == DateTime.MinValue)
{
model.DOB = null;
}
if (model.PlicyDOB == DateTime.MinValue)
{
model.PlicyDOB = null;
}
model.BookingDate = DateTime.Now;
model.EnteredOn = DateTime.Now;
model.EnteredBy = userId;
if (conn.State == ConnectionState.Open)
{
conn.Close();
}
SqlCommand cmd = new SqlCommand("[therapistdb].[SP_SaveBooking]", conn);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@PatientID", model.PatientID);
cmd.Parameters.AddWithValue("@TherapistID", model.TherapistID);
//cmd.Parameters.AddWithValue("@BookingDate", model.BookingDate);
cmd.Parameters.AddWithValue("@EnteredBy", model.EnteredBy);
//cmd.Parameters.AddWithValue("@EnteredOn", model.EnteredOn);
cmd.Parameters.AddWithValue("@PatientName", model.PatientName);
cmd.Parameters.AddWithValue("@DOB", model.DOB);
cmd.Parameters.AddWithValue("@InsuranceComp", model.InsuranceComp);
cmd.Parameters.AddWithValue("@PolicyNo", model.PolicyNo);
cmd.Parameters.AddWithValue("@PlicyDOB", model.PlicyDOB);
cmd.Parameters.AddWithValue("@RelPat", model.RelPat);
cmd.Parameters.AddWithValue("@AssBen", model.AssBen);
cmd.Parameters.AddWithValue("@IsInvOtherHelthCare", model.IsInvOtherHelthCare);
cmd.Parameters.AddWithValue("@BookingSerXML", BookingSerList);
cmd.Parameters.AddWithValue("@ECHBenXML", EHCbenefitsList);
cmd.Parameters.AddWithValue("@BookingID", model.BookingID);
cmd.Parameters.AddWithValue("@Identity", 0);
conn.Open();
cmd.ExecuteNonQuery();
conn.Close();
}
public List <PatientBookingModel> GetAllBooking(int userId, int RefType, int RefID, BookingModel model1)
{
DataSet DS = new DataSet();
SqlCommand cmd = new SqlCommand("[therapistdb].[SP_GetBookingList]", conn);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@UserId", userId);
cmd.Parameters.AddWithValue("@RefType", RefType);
cmd.Parameters.AddWithValue("@RefID", RefID);
cmd.Parameters.AddWithValue("@Status", model1.Status);
cmd.Parameters.AddWithValue("@TherapistName", model1.TherapistName);
cmd.Parameters.AddWithValue("@PatientName", model1.PatientName);
SqlDataAdapter adp = new SqlDataAdapter(cmd);
DataSet ds = new DataSet();
adp.Fill(ds);
List <PatientBookingModel> model = objCommon.ConvertDataTable <PatientBookingModel>(ds.Tables[0]);
return(model);
}
public static BookingRoomModel MapBookingRoomToBookingRoomModel(BookingRoom bookingRoom, BookingModel @ref, RoomModel room)
{
var BookingRoom = new BookingRoomModel
{
Id = bookingRoom.Id,
BookingId = bookingRoom.BookingId,
BookingModel = @ref,
RoomId = bookingRoom.RoomId,
Room = room
};
BookingRoom.ExtraFacilities = bookingRoom.ExtraFacilities?.Select(ef => FacilityMappings.MapExtraFacilityToEFModel(ef,
BookingRoom, FacilityMappings.MapFacilityToFacilityModel(ef.Facility))).ToList();
return(BookingRoom);
}
public ActionResult AddOrEditBooking(int id = 0)
{
BookingModel bookingModel = new BookingModel();
return(View(bookingModel));
}
public async Task <IActionResult> Update([FromBody] BookingModel data)
{
var dataUpdate = await _bookingService.Update(BookingMapper.Map(data));
return(Ok());
}
public async Task <IActionResult> Add([FromBody] BookingModel data)
{
var dataEntity = await _bookingService.Add(BookingMapper.Map(data));
return(Ok(dataEntity));
}
public ActionResult <BookingModel> Create(BookingModel booking)
{
_bookingService.Create(booking);
return(CreatedAtRoute("GetBooking", new { id = booking.Id.ToString() }, booking));
}
private void HandleMessage(string routingKey, BookingModel booking)
{
var currentTime = DateTime.Now.ToLocalTime().ToLongTimeString();
Console.WriteLine($"[{currentTime}] Received '{routingKey}': '{booking}'");
}
public ActionResult BookStep2(BookingModel model)
{
var selectedTimes = Request.Form["selectedTimes"].ToString();
BookingsListModel bookingsList = new BookingsListModel();
foreach (var selectedTime in selectedTimes.Split(','))
{
if (!String.IsNullOrEmpty(selectedTime))
{
var bookingAmount = Convert.ToInt32(selectedTime.Split('_')[0].ToString());
var requestedDate = Convert.ToDateTime(selectedTime.Split('_')[1].ToString());
var requestedTime = Convert.ToDateTime(selectedTime.Split('_')[2].ToString().Replace('-', ':'));
var requestedDay = selectedTime.Split('_')[2].ToString();
model.bookingDate = new DateTime(requestedDate.Year, requestedDate.Month, requestedDate.Day, requestedTime.Hour, requestedTime.Minute, requestedTime.Second);
model.bookingTime = new DateTime(requestedDate.Year, requestedDate.Month, requestedDate.Day, requestedTime.Hour, requestedTime.Minute, requestedTime.Second);
model.bookingAmount = bookingAmount;
model.serviceProviderId = Convert.ToInt32(Request.Form["serviceProviderId"]);
model.serviceId = Convert.ToInt32(Request.Form["serviceId"]);
int hours = TheRepository.GetMinHours(model.serviceProviderId, requestedDate.DayOfWeek.ToString());
int customerid = 0;
if (TheRepository.GetCustomerByEmail(model.customer.emailAddress) == null)
{
var cust = TheRepository.CreateCustomer(model.customer);
customerid = cust.id;
}
else
{
customerid = TheRepository.GetCustomerByEmail(model.customer.emailAddress).id;
}
model.customerId = customerid;
model.bookingHours = hours;
var newBooking = TheRepository.CreateBooking(model);
int newBookingId = newBooking.id;
if (newBooking != null)
{
foreach (var answer in model.additionalQuestionsList)
{
answer.customerId = customerid;
answer.serviceId = model.serviceId;
TheRepository.CreateAdditionalQuestions(answer);
}
}
model.id = newBooking.id;
}
}
List <BookingModel> bookings = new List <BookingModel>();
bookings = TheRepository.GetAllBookingsByCustomer(model.customerId);
bookingsList.bookings = bookings.Where(a => a.bookingAccepted == false).ToList();
bookingsList.serviceProvider = TheRepository.GetServiceProvider(model.serviceProviderId);
return(View("ConfirmPayment", bookingsList));
}
public static ActivitiesViewModel GetActivitiesViewModel()
{
ActivitiesViewModel model = new ActivitiesViewModel();
model.ListCheckIn = new List <BookingModel>();
model.ListCheckOut = new List <BookingModel>();
model.ListConfirmCheckIn = new List <BookingModel>();
model.ListConfirmCheckOut = new List <BookingModel>();
//Empty Rooms Count
using (SqlConnection conn = Connection.GetConnection())
{
if (conn != null)
{
string sql = "SELECT COUNT(RoomID) FROM Room WHERE Status = 'Empty'";
SqlCommand cm = new SqlCommand(sql, conn);
var rs = cm.ExecuteReader();
if (rs.Read())
{
model.EmptyRoomsCount = rs[0] as int? ?? 0;
}
conn.Close();
}
}
//Occupied Rooms Count
using (SqlConnection conn = Connection.GetConnection())
{
if (conn != null)
{
string sql = "SELECT COUNT(RoomID) FROM Room WHERE Status = 'Occupited' or Status = 'Stayover' ";
SqlCommand cm = new SqlCommand(sql, conn);
var rs = cm.ExecuteReader();
if (rs.Read())
{
model.OccupiedRoomsCount = rs[0] as int? ?? 0;
}
conn.Close();
}
}
//List check-in bookings
using (SqlConnection conn = Connection.GetConnection())
{
if (conn != null)
{
BookingModel bk = null;
string sql = "SELECT BookingID FROM dbo.Booking WHERE YEAR(CheckInDate) <= YEAR(CURRENT_TIMESTAMP) and MONTH(CheckInDate) <= MONTH(CURRENT_TIMESTAMP) and DAY(CheckInDate) <= DAY(CURRENT_TIMESTAMP) and Status = 'Confirmed'";
SqlCommand cm = new SqlCommand(sql, conn);
var rs = cm.ExecuteReader();
if (rs.HasRows)
{
while (rs.Read())
{
bk = BookingDAO.GetBookingModel(rs[0] as int? ?? 0);
model.ListCheckIn.Add(bk);
}
}
conn.Close();
}
}
//List confirm check-in bookings
using (SqlConnection conn = Connection.GetConnection())
{
if (conn != null)
{
BookingModel bk = null;
string sql = "SELECT BookingID FROM dbo.Booking WHERE YEAR(CheckInDate) <= YEAR(CURRENT_TIMESTAMP) and MONTH(CheckInDate) <= MONTH(CURRENT_TIMESTAMP) and DAY(CheckInDate) <= DAY(CURRENT_TIMESTAMP) and Status = 'Checked-In'";
SqlCommand cm = new SqlCommand(sql, conn);
var rs = cm.ExecuteReader();
if (rs.HasRows)
{
while (rs.Read())
{
bk = BookingDAO.GetBookingModel(rs[0] as int? ?? 0);
model.ListConfirmCheckIn.Add(bk);
}
}
conn.Close();
}
}
//List check-out bookings
using (SqlConnection conn = Connection.GetConnection())
{
if (conn != null)
{
BookingModel bk = null;
string sql = "SELECT BookingID FROM dbo.Booking WHERE YEAR(CheckOutDate) <= YEAR(CURRENT_TIMESTAMP) and MONTH(CheckOutDate) <= MONTH(CURRENT_TIMESTAMP) and DAY(CheckOutDate) <= DAY(CURRENT_TIMESTAMP) and Status IN ('Checked-In','Stayover')";
SqlCommand cm = new SqlCommand(sql, conn);
var rs = cm.ExecuteReader();
if (rs.HasRows)
{
while (rs.Read())
{
bk = BookingDAO.GetBookingModel(rs[0] as int? ?? 0);
model.ListCheckOut.Add(bk);
}
}
conn.Close();
}
}
//List confirm check-out bookings
using (SqlConnection conn = Connection.GetConnection())
{
if (conn != null)
{
BookingModel bk = null;
string sql = "SELECT BookingID FROM dbo.Booking WHERE YEAR(CheckOutDate) >= YEAR(CURRENT_TIMESTAMP) and MONTH(CheckOutDate) >= MONTH(CURRENT_TIMESTAMP) and DAY(CheckOutDate) >= DAY(CURRENT_TIMESTAMP) and Status ='Checked-Out'";
SqlCommand cm = new SqlCommand(sql, conn);
var rs = cm.ExecuteReader();
if (rs.HasRows)
{
while (rs.Read())
{
bk = BookingDAO.GetBookingModel(rs[0] as int? ?? 0);
model.ListConfirmCheckOut.Add(bk);
}
}
conn.Close();
}
}
return(model);
}
public IHttpActionResult Post(BookingModel bookingModel)
{
throw new NotImplementedException;
}
