public async Task <DataResult <ReserveModel> > CreateReserve(ReserveModel model)
{
try
{
Reserve entity = _mapper.MapBack(model);
DataResult <Reserve> result = await _reserveRepository.Add(entity);
return(new DataResult <ReserveModel>
{
Success = result.Success,
ErrorCode = result.ErrorCode,
Data = _mapper.Map(result.Data),
});
}
catch (Exception ex)
{
_logger.LogError(ex, $"Problems with creating Reserve");
return(new DataResult <ReserveModel>
{
Success = false,
ErrorCode = ErrorCode.InternalError,
});
}
}
public void SendMail(ReserveModel model)
{
try
{
var smtpServer = _configurationlService.GetSection("AppSettings")["smtpServer"];
var userName = _configurationlService.GetSection("AppSettings")["userName"];
var password = _configurationlService.GetSection("AppSettings")["password"];
var fromAddr = _configurationlService.GetSection("AppSettings")["fromAddr"];
SmtpClient client = new SmtpClient(smtpServer);
client.UseDefaultCredentials = false;
client.Credentials = new NetworkCredential(userName, password);
client.EnableSsl = true;
MailMessage mailMessage = new MailMessage();
mailMessage.From = new MailAddress(fromAddr);
mailMessage.To.Add(model.email);
mailMessage.To.Add(fromAddr);
mailMessage.ReplyToList.Add(new MailAddress(fromAddr));
mailMessage.IsBodyHtml = true;
mailMessage.Body = model.emailMessage;
mailMessage.Subject = model.emailSubject;
client.Send(mailMessage);
}
catch (Exception exc)
{
_errorRepo.Add(
new TblError
{
StackTrace = exc.StackTrace,
Message = exc.Message
});
}
}
public async Task <IActionResult> Edit(int id, [Bind("Id,GuestId,RoomId,ReservationCode,CheckIn,CheckOut,NoOfNights,Adults,Children")] ReserveModel reserveModel)
{
if (id != reserveModel.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(reserveModel);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ReserveModelExists(reserveModel.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(reserveModel));
}
public bool Reserve(ReserveModel model)
{
var timeSlot = _slotsRepo
.GetNumOfItemsWithInclude("BOOKINGS")
.FirstOrDefault(p => p.DATE.ToString("yyyy-MM-dd") == model.selectedDate &&
p.START_TIME.ToShortTimeString() == model.selectedHour);
timeSlot.BOOKINGS.Add(new TblBooking
{
NAME = model.name,
PHONE = model.phone,
EMAIL = model.email,
QUANTITY = model.quantity
});
var success = _slotsRepo.Commit();
if (success)
{
model.emailSubject = "Rumpus Room booking completed";
model.emailMessage = GetEmailMessage(model);
_emailService.SendMail(model);
}
return(success);
}
public async Task <IEnumerable <ReserveModel> > GetAllReserve(int page, int pageSize)
{
try
{
var reserveList = new List <ReserveModel>();
var allMettingRoom = await _meetingRoomRepository.GetAllMeetingRomm();
foreach (var mettingRoom in allMettingRoom)
{
var reserve = new ReserveModel
{
MeetingRomm = mettingRoom,
MeetingRoomScheduling = await _meetingRoomSchedulingRepository.GetMeetingRoomSchedulingByNumber(mettingRoom.Number)
};
reserveList.Add(reserve);
}
var skip = (page - 1) * pageSize;
return(reserveList.Skip(skip).Take(pageSize).ToList());
}
catch (Exception)
{
throw new BusinessException("Não foi recuperar as salas de reunião com suas reservas");
}
}
public async Task <int> ReserveHotel(ReserveModel model)
{
try
{
var hotelReservationId = await _reservationRepository.ReserveHotel(new Reservations()
{
Price = model.Price,
CreatedDate = model.CreatedDate,
ReservationDate = model.ReservationDate,
ReservationStatus = model.ReservationStatus,
TransactionId = model.TransactionId
});
_hotelEventProducer.SendOrderDoneMessage(new HotelOrderConfirmedMessage()
{
TransactionId = model.TransactionId,
HotelReservationId = hotelReservationId
});
return(hotelReservationId);
}
catch (Exception e)
{
Console.WriteLine(e);
_hotelEventProducer.SendOrderNotCompleterdMessage(model.TransactionId);
return(-1);
}
}
public async Task <Result> UpdateReserve(int id, ReserveModel model)
{
try
{
Reserve entity = await _reserveRepository.GetById(id);
if (entity == null)
{
return(new Result {
Success = false, ErrorCode = ErrorCode.NotFound,
});
}
return(await _reserveRepository.Update(_mapper.MapUpdate(entity, model)));
}
catch (Exception ex)
{
_logger.LogError(ex, $"Problems with updating Reserve by id : {id}");
return(new DataResult <ReserveModel>
{
Success = false,
ErrorCode = ErrorCode.InternalError,
});
}
}
public async Task <DataResult <ReserveModel> > GetReserveById(int id)
{
try
{
Reserve entity = await _reserveRepository.GetById(id);
if (entity == null)
{
return(new DataResult <ReserveModel>
{
Success = false,
ErrorCode = ErrorCode.NotFound,
});
}
ReserveModel model = _mapper.Map(entity);
return(new DataResult <ReserveModel>
{
Success = true,
Data = model,
});
}
catch (Exception ex)
{
_logger.LogError(ex, $"Problems with getting Reserve by id : {id}");
return(new DataResult <ReserveModel>
{
Success = false,
ErrorCode = ErrorCode.InternalError,
});
}
}
public void ReserveDelete(ReserveModel entity)
{
repo.Connect();
repo.Delete(entity);
repo.Close();
}
public void ReserveAdd(ReserveModel entity)
{
repo.Connect();
repo.Insert(entity);
repo.Close();
}
public void ReserveUpdate(ReserveModel entity)
{
repo.Connect();
repo.Update(entity);
repo.Close();
}
public IActionResult Reserve([FromBody] ReserveModel model)
{
if (_bookingService.Reserve(model))
{
return(Ok());
}
return(BadRequest());
}
public ActionResult Preregistration(ReserveModel model)
{
if (ModelState.IsValid)
{
_reservationService.AddReservation(QsMapper.CreateMap <ReserveModel, ReservationDto>(model));
TempData["Message"] = "您的预约信息已成功提交，索子会在2到3个工作日内处理，接下来将电话邀约核实，期间请保持通讯工具畅通";
return(RedirectToAction("Preregistration"));
}
return(View(model));
}
public async Task AddReservation(ReserveModel reserve)
{
try
{
var response = await client.PostAsJsonAsync(Constants.TrainReservationUrl.MakeReservation, reserve);
}
catch (Exception)
{
throw new Exception(ExceptionsMessage.ConnectionGettingDataError);
}
}
public async Task <ApiResponse> Delete(string reserveId)
{
return(await Execute(() =>
{
using (SqliteConnection)
{
var model = new ReserveModel(SqliteConnection);
Result.Result = model.Delete(reserveId);
}
}));
}
public async Task <IActionResult> Create([Bind("Id,GuestId,RoomId,ReservationCode,CheckIn,CheckOut,NoOfNights,Adults,Children")] ReserveModel reserveModel)
{
ViewBag.guest = _context.Guests.Where(m => m.delete == false).ToList();
ViewBag.room = _context.Rooms.Where(m => m.delete == false && m.Available == true).ToList();
if (ModelState.IsValid)
{
_context.Add(reserveModel);
int roomtypeId = _context.Rooms.FirstOrDefault(m => m.Id == reserveModel.RoomId).RoomTypeId;
//Standard or Single price
double cost;
if (reserveModel.Adults > 1 || reserveModel.Children > 1)
{
var price = _context.RoomType.FirstOrDefault(m => m.Id == (roomtypeId));
cost = Convert.ToDouble(price.StandardPrice);
}
else
{
var price = _context.RoomType.FirstOrDefault(m => m.Id == (roomtypeId));
cost = Convert.ToDouble(price.SinglePrice);
}
//Adding the cost into Bill table
BillViewModel user = _context.Bill.FirstOrDefault(m => m.GuestId == reserveModel.GuestId);
if (user == null)
{
BillViewModel bill = new BillViewModel()
{
GuestId = reserveModel.GuestId,
ReservationCode = reserveModel.ReservationCode,
TotalBill = cost
};
_context.Bill.Add(bill);
}
else
{
user.TotalBill += cost;
}
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(reserveModel));
}
/// <summary>
/// 起動時の処理
/// </summary>
private static void Init()
{
using (var con = new SqliteConnection($"Data Source={Define.File.DbFile}"))
{
con.Open();
var cModel = new ConfigModel(con);
var config = cModel.Get();
var model = new ReserveModel(con);
model.RefreshTasks(config);
}
}
public void Post([FromBody] ReserveModel value)
{
try
{
_reservationService.ReserveHotel(value);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
private string GetEmailMessage(ReserveModel model)
{
var message = $"Hi {model.name} your booking with RumpusRoom has now been complete. Please, find details of the booking below </br></br>" +
$"Booking name: {model.name}</br>" +
$"Booking date: {model.selectedDate}</br>" +
$"Booking time: {model.selectedHour}</br>" +
$"Number of guests: {model.quantity}</br>" +
$"Location: 13B Burton St, Darlinghurst NSW 2010</br></br>" +
$"We are looking forward to seeing you at RumpusRoom!";
return(message);
}
public async Task <ApiResponse> Get()
{
return(await Execute(() =>
{
using (SqliteConnection)
{
var model = new ReserveModel(SqliteConnection);
Result.Result = true;
Result.Data = model.Get();
}
}));
}
public async Task <ApiResponse> Post([FromBody] Reserve reserve)
{
return(await Execute(() =>
{
using (SqliteConnection)
{
var cModel = new ConfigModel(SqliteConnection);
var config = cModel.Get();
var rModel = new ReserveModel(SqliteConnection);
Result.Result = rModel.Update(reserve, config);
}
}));
}
public IActionResult Reserve(int id)
{
var tutor = _tutors.GetById(id);
var model = new ReserveModel
{
TutorId = id,
Tutor = tutor.TutorName,
MemberId = "",
IMG = tutor.TutorIMG,
IsReserved = _reserves.IsReserved(id)
};
return(View(model));
}
public IActionResult Wishlist(int id)
{
var tutor = _tutors.GetById(id);
var model = new ReserveModel
{
TutorId = id,
Tutor = tutor.TutorName,
MemberId = "",
IMG = tutor.TutorIMG,
IsReserved = _reserves.IsReserved(id),
WishlistCount = _reserves.GetCurrReservationWishlistStudentName(id).Count()
};
return(View(model));
}
public async Task <IActionResult> Create(ReserveModel model)
{
DataResult <ReserveModel> result = await _reserveService.CreateReserve(model);
if (result.Success)
{
return(RedirectToAction("Details", new { result.Data.Id }));
}
if (result.ErrorCode == ErrorCode.UniquenessError)
{
ModelState[nameof(model.Name)].Errors.Add("Such a record already exists");
return(View("Create", model));
}
return(RedirectToAction("Error", "Error", new { result.ErrorCode, modelName = nameof(Reserve) }));
}
public async Task <IActionResult> Edit(int id, ReserveModel model)
{
Result result = await _reserveService.UpdateReserve(id, model);
if (result.Success)
{
return(RedirectToAction("Details", new { id }));
}
if (result.ErrorCode == ErrorCode.UniquenessError)
{
ModelState[nameof(model.Name)].Errors.Add("Such a record already exists");
return(View("Edit", model));
}
return(RedirectToAction("Error", "Error", new { result.ErrorCode, modelName = nameof(Reserve) }));
}
private void mediaGridView_CellClick(object sender, DataGridViewCellEventArgs e)
{
int row = e.RowIndex;//get which row was selected
//if user clicks column headers, row = -1, so ignore
if (row >= 0)
{
//cast dataSource from object back into what we put it in
List <MediaModel> medias = (List <MediaModel>)mediaGridView.DataSource;
//get the individual media selected
MediaModel media = medias[row];
selectMediaLable.Text = "Selected Media: " + media.MediaName;
selectedMedia = media;
selectedReserve = mediaLogic.GetReserved(selectedMedia.MediaId);
selectedBorrowed = mediaLogic.GetBorrowed(selectedMedia.MediaId);
//Media availability
if (mediaLogic.GetReservedByMedia(selectedMedia.MediaId) != null)
{
availabilityLabel.Text = "Media Availability: Reserved";
reserveButton.Text = "Unreserve";//Changes button text to unreserve
}
else if (mediaLogic.GetBorrowedByMediaId(selectedMedia.MediaId) != null)
{
var item = mediaLogic.GetBorrowedByMediaId(selectedMedia.MediaId);
if (item.Last().ActualReturnDate < item.Last().BorrowDate)
{
availabilityLabel.Text = "Media Availability: Borrowed";
}
else
{
availabilityLabel.Text = "Media Availability: Available";
}
reserveButton.Text = "Reserve";
}
else
{
availabilityLabel.Text = "Media Availability: Available";
reserveButton.Text = "Reserve"; //Returns button text to reserve
}
}
}
void CheckCoachAndBook(Dictionary <string, SeatProperty> trainInfo, ReserveModel reservationReference, int numberSeats)
{
bool hasBook = false;
foreach (var coachInfo in trainInfo.Select(x => x.Value.coach).Distinct())
{
hasBook = this.HandleEachCoachReservation(trainInfo.Where(x => x.Value.coach.Equals(coachInfo)), reservationReference, numberSeats, coachInfo);
if (hasBook)
{
break;
}
}
if (!hasBook)
{
throw new Exception(ExceptionsMessage.CompletedReservationError);
}
}
/// <summary>
/// タイマー処理
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void TimerElapsed(object sender, ElapsedEventArgs e)
{
if (!_recorderLock)
{
_recorderLock = true;
using (var con = new SqliteConnection($"Data Source={Define.File.DbFile}"))
{
con.Open();
var cModel = new ConfigModel(con);
var config = cModel.Get();
var rModel = new ReserveModel(con);
var tasks = rModel.GetTasks(true);
if (tasks.Any())
{
tasks.ForEach(t =>
{
// 予約実行
if (_recorders.All(r => r.Id != t.Id))
{
// var recorder = Recorder.GetRecorder(config, t);
var recorder = new RadikoRecorder(config, t);
_recorders.Add(recorder);
recorder.Start().Wait();
var logger = NLog.LogManager.GetCurrentClassLogger();
logger.Info("録音開始");
}
});
}
}
// 終了タスクを削除する
_recorders.RemoveAll(r => r.Status == Recorder.RecorderStatus.End);
_recorderLock = false;
}
if (!_timetableLock && (DateTime.Now - _refreshTimetableDate).TotalDays > 6)
{
_timetableLock = true;
RefreshTimeTable();
}
}
public async Task DoReservation(Train train, int seatNumber)
{
try
{
var reservationModel = new ReserveModel();
reservationModel.train_id = train.AsDisplayString();
reservationModel.booking_reference = await this.service.GetReservationReference();
var trainInfo = await this.service.GetTrainInformation(train);
Handler coachHandler = new CoachHandler(this.utils, this.service);
Handler trainHandler = new TrainHandler(this.utils, this.service);
coachHandler.SetSuccessor(trainHandler);
coachHandler.HandleReservationRequest(trainInfo, reservationModel, seatNumber);
this.PrintUserInfoBooking(reservationModel);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public async Task <IActionResult> Create([Bind("Id,Date,EmployeeId,GuestId,ReservationCode,ServiceId,Price,Quantity,paid")] OrderModel orderModel)
{
ViewBag.employeeList = _context.Employees.ToList();
ViewBag.serviceList = _context.Services.ToList();
ViewBag.roomList = _context.Rooms.ToList();
int roomId = orderModel.GuestId;
ReserveModel reserve = new ReserveModel();
reserve = _context.Reserve.FirstOrDefault(m => m.RoomId == roomId && m.ConfirmChekout == false);
if (reserve != null)
{
orderModel.GuestId = reserve.GuestId;
orderModel.ReservationCode = reserve.ReservationCode;
}
else
{
return(NotFound());
}
ServiceModel service = new ServiceModel();
service = _context.Services.SingleOrDefault(m => m.Id == orderModel.ServiceId);
if (service != null)
{
orderModel.Price = service.Price;
}
if (ModelState.IsValid)
{
_context.Add(orderModel);
BillViewModel user = _context.Bill.FirstOrDefault(m => m.GuestId == orderModel.GuestId);
if (user == null)
{
BillViewModel bill = new BillViewModel()
{
GuestId = orderModel.GuestId,
ReservationCode = orderModel.ReservationCode,
TotalBill = Convert.ToDouble(orderModel.Price) * orderModel.Quantity
};
_context.Bill.Add(bill);
}
else
{
if (orderModel.paid == false)
{
user.TotalBill += (orderModel.Price * orderModel.Quantity);
_context.Bill.Update(user);
}
}
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(orderModel));
}
