/// <summary> /// Adds a reservation to the current schedule /// </summary> /// <param name="reserve">Reservation to be added</param> /// <returns>true if successful, false otherwise</returns> public bool AddReservation(IReservation reserve) { if (reserve.numberOfGuests <= GetRemainingCapacityForDate(reserve.date)) { AddReserveToStorage(reserve); return true; } return false; }
// We can extend this method later to actually store the reserves to a database or file private void AddReserveToStorage(IReservation reserve) { this._reservationsById.Add(reserve.id, reserve); if (!this._reservationsByDate.ContainsKey(reserve.date.Date)) { this._reservationsByDate.Add(reserve.date.Date, new List<IReservation>()); } this._reservationsByDate[reserve.date.Date].Add(reserve); }
public bool Update(IReservation item) { IReservation storedItem = Get(item.Id); if (storedItem != null) { storedItem.ClientName = item.ClientName; storedItem.Location = item.Location; return(true); } else { return(false); } }
public bool Accept( IReservation[] reservations, IReservation candidate, ITable[] tables, TimeSpan seatingDuration) { var sameDayReservations = new SameDayReservationFilter() .Filter(reservations, candidate, seatingDuration); var assignedTables = new BestFitTableAssigner() .Assign(sameDayReservations, tables); var leftTables = tables.Except(assignedTables); return(leftTables.Any(t => candidate.CanFit(t))); }
public void Test1() { var tables = new[] { new RectangularTable(2), new RectangularTable(2), new RectangularTable(4), new RectangularTable(4) }; var reservations = new IReservation[0]; var candidate = new Reservation(4, new DateTime(2024, 06, 07)); var actual = new HauteCuisineMaitreD() .Accept(reservations, candidate, tables, TimeSpan.MaxValue); Assert.IsTrue(actual); }
void IMailbox.Config(IReservation reservation, Guid primaryMailboxGuid, Guid physicalMailboxGuid, TenantPartitionHint partitionHint, Guid mdbGuid, MailboxType mbxType, Guid?mailboxContainerGuid) { if (TestIntegration.Instance.RemoteExchangeGuidOverride != Guid.Empty) { bool flag = physicalMailboxGuid != primaryMailboxGuid; primaryMailboxGuid = TestIntegration.Instance.RemoteExchangeGuidOverride; physicalMailboxGuid = (flag ? TestIntegration.Instance.RemoteArchiveGuidOverride : TestIntegration.Instance.RemoteExchangeGuidOverride); } this.reservation = reservation; this.physicalMailboxGuid = physicalMailboxGuid; this.primaryMailboxGuid = primaryMailboxGuid; this.partitionHint = partitionHint; this.mdbGuid = mdbGuid; this.mbxType = mbxType; this.mailboxContainerGuid = mailboxContainerGuid; }
public IHttpActionResult BuyTicketWithReservation(long id) { IReservation reservation = reservationRepo.GetReservationyId(id); NewTicketWithReservationSummary summary = newTicketWithReservation.New(new TicketWithReservation(id, reservation.ProjectionId, reservation.Row, reservation.Column)); if (summary.IsCreated) { ITicketDto ticket = ticketRepo.CreateTicket(reservation.ProjectionId, reservation.Row, reservation.Column); return(Ok(ticket)); } return(BadRequest(summary.Message)); }
public void Test5() { var reservations = new IReservation[] { new Reservation(2, new DateTime(2023, 09, 14)) }; var candidate = new Reservation(3, new DateTime(2023, 09, 14)); var tables = new[] { new RectangularTable(10) }; var actual = new BoutiqueRestaurantMaitreD() .Accept(reservations, candidate, tables, TimeSpan.MaxValue); Assert.IsTrue(actual); }
public CreateReservation(IReservation reservation) { InitializeComponent(); this.reservation = reservation; selectEmployeeComboBox.ItemsSource = Controller.GetEmployees(); selectMachineComboBox.ItemsSource = Controller.GetMachines(); selectEmployeeComboBox.SelectedIndex = 0; selectMachineComboBox.SelectedIndex = 0; dayDatePicker.SelectedDate = reservation.Day; timeStartDatePicker.SelectedDate = reservation.Start; timeEndDatePicker.SelectedDate = reservation.End; jamTypeTextBox.Text = reservation.JamType; descriptionTextBox.Text = reservation.Description; }
public void AddReservation(IReservation reservation) { reservation.Date = DateTime.Now; var saving = Repository.GetSavingById(reservation.SavingsId); if (reservation.Amount + saving.SavingCurrentAmount > saving.SavingsGoalAmount) { throw new Exception("Reservation precedes goal"); } else if (reservation.Amount + saving.SavingCurrentAmount == saving.SavingsGoalAmount) { saving.State = SavingState.Completed; saving.SavingCurrentAmount += reservation.Amount; Repository.UpdateSaving(saving); } Repository.AddReservation(reservation); }
public async Task <NewTicketSummary> Buy(int id) { IReservation reservation = await this.reservationRepository.GetById(id); DateTime projectionStartdate = await this.projRepo.GetProjectionStartDate(reservation.ProjectionId); //DONE: check if time is correctly set. if (DateTime.Now.AddMinutes(10) >= projectionStartdate) { int count = await this.reservationRepository.RemoveAllReservations(reservation.ProjectionId); await this.projRepo.IncreaseAvailableSeats(reservation.ProjectionId, count); return(new NewTicketSummary(false, StringConstants.ReservationExpired)); } return(await buyTicket.Buy(id)); }
public void Test5() // best fitting configuration { var tables = new[] { new RectangularTable(3), new RectangularTable(2), new RectangularTable(4) }; var reservations = new IReservation[] { new Reservation(4, new DateTime(2022, 10, 11)), new Reservation(2, new DateTime(2022, 10, 11)) }; var candidate = new Reservation(3, new DateTime(2022, 10, 11)); var actual = new HauteCuisineMaitreD() .Accept(reservations, candidate, tables, TimeSpan.MaxValue); Assert.IsTrue(actual); }
public bool Accept( IReservation[] reservations, IReservation candidate, ITable[] tables, TimeSpan seatingDuration) { var sameDayReservations = new SameIntervalReservationFilter() .Filter(reservations, candidate, seatingDuration); var assignedTables = new AlternativeConfigurationsTableAssigner() .Assign(sameDayReservations, tables); var leftTables = tables.Except(assignedTables); var leftTblsGroups = new TableConfigurationsGenerator() .Generate(leftTables); return(leftTblsGroups.Any(t => candidate.CanFit(t))); }
public async Task <IHttpActionResult> Ticket(int id) { IReservation reservation = reserveRepo.GetById(id); NewCreationSummary summary = await newReservedTicket.New(new Ticket(reservation.ProjectionStartDate, reservation.Movie, reservation.Cinema, reservation.Room, reservation.Row, reservation.Column, reservation.ProjectionId)); var ticket = ticketRepo.Get(reservation.Row, reservation.Column, reservation.ProjectionId); if (summary.IsCreated) { await projRepo.DecreaseSeatsCount(reservation.ProjectionId); return(Ok(ticket)); } else { return(BadRequest(summary.Message)); } }
public void PlaceReservation(IReservation PR1) { using (SqlConnection conn = new SqlConnection(connectionString)) { conn.Open(); string query = "INSERT INTO Reservation (ASPNetUsers_ID, Car_ID, StartDate, EndDate) VALUES (@ASPNetUsers_ID, @Car_ID, @StartDate, @EndDate); "; using (SqlCommand command = new SqlCommand(query, conn)) { command.Parameters.AddWithValue("@Reservation_Number", PR1.Reservation_Number); command.Parameters.AddWithValue("@AspNetUsers_ID", PR1.AspNetUsers_ID); command.Parameters.AddWithValue("@Car_ID", PR1.Car_ID); command.Parameters.AddWithValue("@StartDate", PR1.StartDate); command.Parameters.AddWithValue("@EndDate", PR1.EndDate); command.ExecuteNonQuery(); } } }
public void Test6() // you should not consider the time { var tables = new[] { new RectangularTable(3), new RectangularTable(2), new RectangularTable(4) }; var reservations = new IReservation[] { new Reservation(4, new DateTime(2022, 10, 11)), new Reservation(2, new DateTime(2022, 10, 11)), new Reservation(3, new DateTime(2022, 10, 11, 17, 00, 00)) }; var candidate = new Reservation(3, new DateTime(2022, 10, 11)); var actual = new HauteCuisineMaitreD() .Accept(reservations, candidate, tables, TimeSpan.MaxValue); Assert.IsFalse(actual); }
public ICollection <AvailabilityDTO> GetAvailability(IReservation reservation) { var availableSpacesByDate = new List <AvailabilityDTO>(); var carPark = carParkRepository.FindCarParkById(reservation.CarParkId); for (int i = 0; i <= (reservation.ToDate - reservation.FromDate).Days; i++) { var reservationDay = reservation.FromDate.AddDays(i); var takenReservations = carPark.Reservations.Where(x => x.FromDate <= reservationDay && x.ToDate >= reservationDay); availableSpacesByDate.Add(new AvailabilityDTO() { ReservationDate = reservationDay, SpacesAvailability = FormatAvailabilityString(carPark.AvailableSpaces, takenReservations.Count()), FreeSpaces = carPark.AvailableSpaces - takenReservations.Count(), Price = parkingPricesService.GetParkingPrice(reservationDay.Month) }); } return(availableSpacesByDate); }
private IEnumerable <ITable> AssignAlternativeConfiguration( IReservation reservation, IEnumerable <ITable> tables) { var rectangularTables = tables.Where(t => t is RectangularTable); var alternativeConfigs = new TableConfigurationsGenerator() .Generate(rectangularTables); // choose a configuration var assignedTbl = AssignTable(reservation, alternativeConfigs); if (assignedTbl == null || !(assignedTbl is TableGroup assignedTblGroup)) { return(new ITable[0]); } // return the selected tables in that configuration return(assignedTblGroup); }
public async Task <NewTicketSummary> Buy(int id) { IReservation reservation = await this.reservationRepository.GetById(id); Ticket ticket = new Ticket( reservation.ProjectionStartDate, reservation.MovieName, reservation.CinemaName, reservation.RoomNumber, reservation.Row, reservation.Column, reservation.ProjectionId ); await this.reservationRepository.RemoveReservation(reservation.Id); await this.ticketRepository.Insert(ticket); return(new NewTicketSummary(true, StringConstants.TicketCreated)); }
public IReservation StartRepair(HttpContextBase context, ResourceState resourceState, DateTime actualBeginDateTime, DateTime actualEndDateTime, string notes) { IReservation repair = null; if (Resource.HasState(ResourceState.Online)) { // Create new offline reservation or new limited mode status //ResourceState resourceState = rdoStatusOffline.Checked ? ResourceState.Offline : ResourceState.Limited; if (resourceState == ResourceState.Offline) { // User wants to create new offline reservation // Determine BeginDateTime for repair reservation DateTime beginDateTime, endDateTime; beginDateTime = Resource.GetNextGranularity(actualBeginDateTime, GranularityDirection.Previous); endDateTime = Resource.GetNextGranularity(actualEndDateTime, GranularityDirection.Next); // Insert the new repair reservation repair = Provider.Scheduler.Reservation.InsertRepair(Resource.ResourceID, CurrentUser.ClientID, beginDateTime, endDateTime, actualBeginDateTime, notes, CurrentUser.ClientID); // Remove invitees and process info that might be in the session context.Session.Remove($"ReservationInvitees#{Resource.ResourceID}"); context.Session.Remove($"ReservationProcessInfos#{Resource.ResourceID}"); // Set the state into resource table and session object Resources.UpdateState(Resource.ResourceID, ResourceState.Offline, string.Empty); UpdateAffectedReservations(repair); } else { // User sets the tool into limited mode // Set Resource State, txtNotes.Text is saved with Resource table only in limited mode, since limited mode has no reservation record Resources.UpdateState(Resource.ResourceID, ResourceState.Limited, notes); } } return(repair); }
private ITable AssignTable( IReservation reservation, IEnumerable <ITable> tables) { if (!tables.Any()) { return(null); } var minEmptySeats = tables .Where(t => reservation.CanFit(t)) .Min(t => (int?)t.Size - reservation.Quantity); if (minEmptySeats == null) { return(null); } return(tables .FirstOrDefault( t => t.Size == (minEmptySeats + reservation.Quantity))); }
public void Test1() { var seatingDuration = TimeSpan.FromHours(2.5); var tables = new ITable[] { new CircularTable(4), new RectangularTable(2), new RectangularTable(2), new RectangularTable(2), new RectangularTable(1), new RectangularTable(2) }; var reservations = new IReservation[0]; var candidate = new Reservation(4, new DateTime(2028, 12, 12, 20, 00, 00)); var actual = new AlternativeTableConfigurationsMaitreD() .Accept(reservations, candidate, tables, seatingDuration); Assert.IsTrue(actual); }
public int UpdateChargeMultiplierByReservationToolBilling(IReservation rsv) { // We used to use named queries here which called stored procs to update the ChargeMultiplier, but this was overly // complicated. All the stored procs did was just change the ChargeMultiplier so it's a lot simpler to do that here // without calling a stored proc, espeically now because we have to get the IToolBilling record anyway to update // the UsageFeeCharged amount. var tb = GetToolBillingQuery(Utility.InCurrentPeriod(rsv)).FirstOrDefault(x => x.ReservationID == rsv.ReservationID); if (tb != null) { // update the new forgiven pct tb.ChargeMultiplier = Convert.ToDecimal(rsv.ChargeMultiplier); // calculate the new UsageFeeCharged amount CalculateUsageFeeCharged(tb); return(1); } return(0); }
private void InitializeWindowContent() { reservation = facade.GetReservation(booking.ReservationID); contract = facade.GetCustomer(booking.ContractID); reservationNumber.Content = reservation.ID; checkInDate.Content = booking.StartDate.ToLongDateString().ToString(); checkOutDate.Content = booking.EndDate.ToLongDateString().ToString(); contracts.Content = contract.Name.ToString(); roomType.Content = booking.Roomtype.ToString(); contractsNum.Content = contract.Phone; company.Content = contract.Company; address.Text = contract.Address; roomPrice.Content = booking.ThisPrice; roomsprice = booking.ThisPrice; checkOutTime.Content = IClock.Time.GetDateTimeFormats('f')[0].ToString(); downPayment.Content = reservation.DownPayment; LoadRoomList(); CalculatePrice(); }
/// <summary> /// Create a IReservation object for new reservation /// </summary> /// <param name="reservationModel">reservationModel obj</param> /// <returns>IReservation object</returns> private IReservation CreateReservation(ReservationModel reservationModel) { IReservation reservation = null; if (reservationModel != null) { //get IReservation object from reservationservice reservation = _reservationService.GetReservationObject(); //set information the object reservationModel.ReservationObj = reservation; reservation.CheckInDate = reservationModel.CheckInDate; reservation.ContactNumber = reservationModel.ContactNumber; reservation.CustomerName = reservationModel.CustomerName; reservation.Occupants = reservationModel.PartyOf; foreach (TableModel tb in reservationModel.Table) { ITable tableObj = _tableService.GetTableObject(); tableObj.Id = tb.TableID; tableObj.MaxOccupancy = tb.TableOccupancy; _reservationService.SetTableObjectOnReservation(tableObj, reservation); } } return(reservation); }
internal IReservation UpdateReservation(IReservation reservation) { connect(); SQLiteCommand cmd = new SQLiteCommand("Update Reservation Set PAYMENT=:PAYMENT,DOWNPAYMENT=:DOWNPAYMENT,RSTATUS=:RSTATUS Where RESERVATIONID=:RESERVATIONID", sqlCon); cmd.Parameters.AddWithValue("RESERVATIONID", reservation.ID); cmd.Parameters.AddWithValue("PAYMENT", reservation.Payment); cmd.Parameters.AddWithValue("DOWNPAYMENT", reservation.DownPayment); cmd.Parameters.AddWithValue("RSTATUS", reservation.RStatus.ToString()); try { cmd.ExecuteNonQuery(); } catch (Exception ex) { throw new Exception("Reservation with ID: " + reservation.ID + " could not be updated!\n" + ex.Message); } finally { disconnect(); } return(GetReservation(reservation.ID)); }
public IReservation EndRepair(DateTime now) { IReservation repair = null; if (Resource.HasState(ResourceState.Offline)) { var rip = Reservations.GetRepairInProgress(Resource); if (rip != null) { repair = Provider.Scheduler.Reservation.GetReservation(rip.ReservationID); if (repair != null) { if (Resource.IsSchedulable) { // Set Scheduled EndDateTime = next gran boundary in future var endDateTime = Resource.GetNextGranularity(now, GranularityDirection.Next); Provider.Scheduler.Reservation.UpdateRepair(repair.ReservationID, endDateTime, repair.Notes, CurrentUser.ClientID); // End the repair reservation now var util = Reservations.Create(Provider, now); util.End(repair, now, CurrentUser.ClientID); UpdateAffectedReservations(repair); } } } } // Set Resource State Resources.UpdateState(Resource.ResourceID, ResourceState.Online, string.Empty); return(repair); }
public IReservation UpdateRepair(DateTime actualEndDateTime, string notes) { IReservation result = null; if (Resource.HasState(ResourceState.Offline)) { // Determine BeginDateTime for repair reservation DateTime endDateTime; var rip = Reservations.GetRepairInProgress(Resource); if (rip != null) { IReservation repair = Provider.Scheduler.Reservation.GetReservation(rip.ReservationID); if (repair != null) { endDateTime = Resource.GetNextGranularity(actualEndDateTime, GranularityDirection.Next); // Modify existing repair reservation result = Provider.Scheduler.Reservation.UpdateRepair(repair.ReservationID, endDateTime, notes, CurrentUser.ClientID); // result has the modified end datetime, so affected reservations will be updated UpdateAffectedReservations(result); } } } else { // modifying limited mode, only StateNotes is modifiable in this case Resources.UpdateState(Resource.ResourceID, ResourceState.Limited, notes); } return(result); }
public void AddReservation(IReservation reservation) { throw new NotImplementedException(); }
public HomeController(IReservation reservation) { this.reservation = reservation; }
void IMailbox.Config(IReservation reservation, Guid primaryMailboxGuid, Guid physicalMailboxGuid, TenantPartitionHint partitionHint, Guid mdbGuid, MailboxType mbxType, Guid?mailboxContainerGuid) { throw new NotImplementedException(); }
/// <summary> /// Fabrique le IReservation de la QuidditchDataAccessLayerBaseDeDonnees /// </summary> /// <param name="reservation">Reservation de la QuidditchBusinessLayer</param> /// <returns>Le reservation pour la QuidditchDataAccessLayerBaseDeDonnees</returns> public static QuidditchDataAccessLayerBaseDeDonnees.IReservation FabriquerReservation(IReservation reservation) { return new ReservationDal(reservation.Identifiant, reservation.Prix, reservation.Place); }
public ReservationController(IConfiguration configuration) { _reservationRepo = new ReservationRepository(configuration); }
// This provides a seam in the factory where I can prime the factory with the user it will then cough up. (for test code) public static void SetReservation(IReservation aReservation) { _reservation = aReservation; }
/// <summary> /// Permet d'ajouter une réservation /// </summary> /// <param name="reservation">Instance de la réservation à ajouter</param> public void AddReservation(IReservation reservation, int idMatch) { if (_dalProxy.AddReservation(FabriqueReservation.FabriquerReservation(reservation), idMatch) == -1) { throw new MatchOverbookException(); } }
private ReservationModel ReservationToModel(IReservation r) { return new ReservationModel { date = r.date, name = r.name, numberOfGuests = r.numberOfGuests, id = r.id }; }
/// <summary> /// Permet d'insérer une réservation en base de données /// </summary> /// <param name="reservation">La réservation à insérer</param> /// <returns>Retourne un entier qui est le résultat de la requête</returns> public int InsertReservation(IReservation reservation, int idMatch) { int result = 0; using (SqlConnection sqlConnection = new SqlConnection(_connectionString)) { SqlCommand sqlCommand = new SqlCommand(SqlQuery.INSERT_RESERVATION); SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand); sqlCommand.CommandType = CommandType.Text; sqlCommand.Connection = sqlConnection; sqlCommand.Parameters.AddWithValue("@place", reservation.Place); sqlCommand.Parameters.AddWithValue("@prix", reservation.Prix); sqlCommand.Parameters.AddWithValue("@match_id_ref", idMatch); sqlCommand.Parameters.AddWithValue("@spectateur_id_ref", 0); sqlConnection.Open(); result = sqlCommand.ExecuteNonQuery(); } return result; }
public bool checkOutReservationToDb(IReservation theReservation) { try { ds = new DataSet(); string sql = "SELECT * From Reservations"; da = new SqlDataAdapter(sql, con); da.MissingSchemaAction = MissingSchemaAction.AddWithKey; cb = new SqlCommandBuilder(da); //Generates da.Fill(ds, "ReservationsData"); DataRow findRow = ds.Tables["ReservationsData"].Rows.Find(theReservation.ReservationId); if (findRow != null) { findRow[12] = "checked out"; } da.Update(ds, "ReservationsData"); //remove row from database table } catch (System.Exception excep) { MessageBox.Show(excep.Message); if (getConnection().ToString() == "Open") closeConnection(); Application.Exit(); } return true; }
/// <summary> /// Constructeur par copie d'une réservation /// </summary> /// <param name="reservationToCopy">Instance de Réservation à copier</param> public Reservation(IReservation reservationToCopy) : this(reservationToCopy.Identifiant, reservationToCopy.Prix, reservationToCopy.Place) { }
/// <summary> /// Fabrique le IReservation de la QuidditchBusinessLayer /// </summary> /// <param name="reservation">Reservation de la QuidditchWebServices</param> /// <returns>Le reservation pour la QuidditchBusinessLayer</returns> public static QuidditchBusinessLayer.IReservation FabriquerReservation(IReservation reservation) { return new ReservationBusiness(reservation.Identifiant, reservation.Prix, reservation.Place); }
/// <summary> /// Permet d'ajouter une réservation /// </summary> /// <param name="reservation">Réservation à ajouter</param> /// <param name="idMatch">Identifiant du match</param> /// <returns>0 si l'ajout s'est fait correctement, -1 si non</returns> public int AddReservation(IReservation reservation, int idMatch) { return DalManager.AddReservation(reservation, idMatch); }
/// <summary> /// Permet d'ajouter un match en base /// </summary> /// <param name="match">Match à ajouter</param> /// <param name="idMatch">Identifiant du match</param> /// <returns>Entier indiquant le résultat</returns> public int AddReservation(IReservation reservation, int idMatch) { DataTable numberPlace = DataAccess.FindNumberPlaceCanBeReservedForOnMatch(idMatch); if (numberPlace.Rows.Count > 0) { int numberPlaceRestant = (int) numberPlace.Rows[0]["numbrePlaceRestante"]; if (numberPlaceRestant <= 0) { return -1; } } return DataAccess.InsertReservation(reservation, idMatch); }
public DiversHotelController(IReservation <Reservation> RRebository) { db = RRebository; }
public void addNewReservationToDb(IReservation theReservation) { try { DataSet ds = new DataSet(); string sql = "SELECT * From Reservations"; SqlDataAdapter da = new SqlDataAdapter(sql, con); SqlCommandBuilder cb = new SqlCommandBuilder(da); //Generates da.Fill(ds, "ReservationsData"); totUsers = ds.Tables["ReservationsData"].Rows.Count; DataRow dRow = ds.Tables["ReservationsData"].NewRow(); dRow[0] = theReservation.ReservationId; dRow[1] = theReservation.Guest.GuestId; dRow[2] = theReservation.Room.RoomId; dRow[3] = theReservation.CheckIn; dRow[4] = theReservation.CheckOut; dRow[5] = theReservation.NoOfPets; dRow[6] = theReservation.TotalPrice; dRow[7] = theReservation.AdditionalInfo; dRow[8] = theReservation.NoOfGuests; dRow[9] = theReservation.NoOfAdults; dRow[10] = theReservation.NoOfChildren; dRow[11] = theReservation.DateBooked; dRow[12] = theReservation.Status.Trim(); dRow[13] = theReservation.CreditCard.CardNo; ds.Tables["ReservationsData"].Rows.Add(dRow); da.Update(ds, "ReservationsData"); } catch (System.Exception excep) { if (con.State.ToString() == "Open") con.Close(); Application.Exit(); //Environment.Exit(0); //Force the application to close } }