public AccountController(ApplicationUserManager userManager, ApplicationSignInManager signInManager, IReservationManager reservationManager, EmailController emailController)
{
UserManager = userManager;
SignInManager = signInManager;
_reservationManager = reservationManager;
_emailController = emailController;
}
/// <summary>
/// Wes Richardson
/// Created: 2019/04/11
///
/// </summary>
public AppointmentController()
{
_guestID = 100000;
_appointmentMgr = new AppointmentManager();
_resvMgr = new ReservationManagerMSSQL();
ViewBag.errorMessage = "";
}
public ReservationsController(
IReservationManager _reservationManager,
ILocationManager _locationManager)
{
reservationManager = _reservationManager;
locationManager = _locationManager;
}
public ReservationDashBoardViewModel(IUnityContainer container, ILoggerFacade logger, IReservationManager reservationManager, ITableManager tableManager, IMessageBoxService messageBoxService, IDialogBoxService dialogBoxService)
{
this._logger = logger;
this._container = container;
this._reservationManager = reservationManager;
this._tableManager = tableManager;
this._messageBoxService = messageBoxService;
this._dialogBoxService = dialogBoxService;
this._reservationHours = new ObservableCollection<ReservationHour>();
this._reservations = new MappedValueCollection();
this.AddCommand = new DelegateCommand(this.OnAddCommand, () => { return this._noOfPersons > 0; });
this.BrowseCommand = new DelegateCommand(this.OnBrowseCommand);
this.ImportCommand = new DelegateCommand(this.OnImportCommand, () => { return !string.IsNullOrEmpty(this._tableXMLFile); });
this._tables = this._tableManager.GetAll();
// Assumption : Reservation duration is between 10 Am and 10 Pm
this._minFromHour = 10;
this._maxFromHour = 22;
for (int hour = this._minFromHour; hour <= this._maxFromHour; hour++)
{
this._reservationHours.Add(new ReservationHour(hour));
}
this.FromHour = this._minFromHour;
TableReservation.Common.ReservationsUpdatedEvent.Instance.Subscribe(this.ReservationsUpdated);
this.ReservationsUpdated(Guid.NewGuid());
}
public StatisticsAPI(IDishManager dishManager,
IOrderManager orderManager,
IReservationManager reservationManager)
{
this.orderManager = orderManager;
this.reservationManager = reservationManager;
}
public void testSetupMSSQL()
{
_res = new ReservationAccessorMock();
_reservationManager = new ReservationManagerMSSQL(_res);
_reservations = new List <Reservation>();
_reservations = _reservationManager.RetrieveAllReservations();
}
public PendingReservationsModel(
IReservationManager _reservationManager,
ILocationManager _locationManager
)
{
reservationManager = _reservationManager;
locationManager = _locationManager;
}
public RemoveModel(
ICarManager _carManager,
IReservationManager _reservationManager
)
{
carManager = _carManager;
reservationManager = _reservationManager;
}
public ReservationsController(IDeletableRepository <Reservation> reservations, IGenericRepositoy <GeneralSettings> settings, IFilterFactory filterFactory, ICalculatePricing pricingCalculator, IReservationManager reservationManager)
{
this.reservations = reservations;
this.setings = settings;
this.filterFactory = filterFactory;
this.pricingCalculator = pricingCalculator;
this.reservationManager = reservationManager;
}
/// <summary>
/// Author: Matt LaMarche
/// Created : 2/09/2019
/// This Constructor requires a Reservation and an instance of the IReservationManager
/// </summary>
/// <param name="reservation">The Reservation we want to deactivate</param>
/// <param name="reservationManager">The ReservationManager instance being used for this program</param>
public DeactivateReservation(Reservation reservation, IReservationManager reservationManager)
{
InitializeComponent();
_reservationManager = reservationManager;
_reservation = reservation;
txtTitleContent.Text = "Are you sure you want to delete this Reservation?";
txtBodyContent.Text = "Deleting this Item will remove it from our system. If you are unsure whether you should delete this please click cancel and ask your superior";
}
public ReservationController(IMapper mapper,
ILogger <ReservationController> logger,
IReservationManager manager)
{
_mapper = mapper;
_logger = logger;
_manager = manager;
}
public HomeController(IDeletableRepository <Image> images, IGenericRepositoy <GeneralSettings> settings, IDeletableRepository <Reservation> reservations, IReservationManager reservationManager, IOverlapDatesManager datesManager, IReservationsEmailManager _reservationsEmailManager)
{
this.images = images;
this.settings = settings;
this.reservations = reservations;
this.reservationManager = reservationManager;
this.datesManager = datesManager;
this._reservationsEmailManager = _reservationsEmailManager;
}
public PaymentModel(
ICarManager _carManager,
ILocationManager _locationManager,
IReservationManager _reservationManager)
{
carManager = _carManager;
locationManager = _locationManager;
reservationManager = _reservationManager;
}
public Reservation(DateTime creationDate, DateTime startDate, DateTime endDate, ApplicationUser user)
{
Details = new List <ReservationDetail>();
CreationDate = creationDate;
StartDate = startDate;
EndDate = endDate;
User = user;
_reservationManager = TypeManagerFactory.CreateTypeManager(user.Type);
}
public ReservationController(
IHousingManager housingManager,
IUserManager userManager,
IReservationManager reservationManager)
{
_housingManager = housingManager ?? throw new ArgumentNullException(nameof(housingManager));
_userManager = userManager ?? throw new ArgumentNullException(nameof(userManager));
_reservationManager = reservationManager ?? throw new ArgumentNullException(nameof(reservationManager));
}
public ReservationsController(ApplicationDbContext context, UserManager <ApplicationUser> userManager,
IOrderManager orderManager, IBusinessManager businessManager, IReservationManager reservationManager, ITableManager tableManager)
{
_context = context;
_orderManager = orderManager;
_businessManager = businessManager;
_reservationManager = reservationManager;
_userManager = userManager;
_tableManager = tableManager;
}
public IdentityUnitOfWork(string connectionString)
{
db = new ApplicationContext(connectionString);
userManager = new ApplicationUserManager(new UserStore <ApplicationUser>(db));
roleManager = new ApplicationRoleManager(new RoleStore <ApplicationRole>(db));
workerManager = new WorkerManager(db);
workTimeManager = new WorkTimeManager(db);
imageManager = new ImageManager(db);
reservationManager = new ReservationManager(db);
}
public ProfileModel(
UserManager <User> userManager,
SignInManager <User> signInManager,
ICompanyManager companyManager,
IReservationManager reservationManager)
{
_userManager = userManager;
_signInManager = signInManager;
_companyManager = companyManager;
_reservationManager = reservationManager;
}
public IdentityUnitOfWork(string connectionString)
{
_db = new ApplicationContext(connectionString);
_userManager = new ApplicationUserManager(new UserStore <ApplicationUser>(_db));
_roleManager = new ApplicationRoleManager(new RoleStore <ApplicationRole>(_db));
_workerManager = new WorkerManager(_db);
_workTimeManager = new WorkTimeManager(_db);
_imageManager = new ImageManager(_db);
_reservationManager = new ReservationManager(_db);
_confirmReservation = new ConfirmReservationManager(_db);
}
public ReservationViewModel(IUnityContainer container, ILoggerFacade logger, IReservationManager reservationManager, ITableManager tableManager, IMessageBoxService messageBoxService, IDialogBoxService dialogBoxService)
{
this._logger = logger;
this._container = container;
this._reservationManager = reservationManager;
this._tableManager = tableManager;
this._messageBoxService = messageBoxService;
this._dialogBoxService = dialogBoxService;
this.EditCommand = new DelegateCommand(this.OnEditCommand, () => { return this._selectedReservation != null; });
this.DeleteCommand = new DelegateCommand(this.OnDeleteCommand, () => { return this._selectedReservation != null; });
this.GetAllReservations();
TableReservation.Common.ReservationsUpdatedEvent.Instance.Subscribe(this.ReservationsUpdated);
}
/// <summary>
/// Author: Matt LaMarche
/// Created : 1/26/2019
/// This constructor is used for Reading and Updating a Reservation
/// </summary>
/// <param name="existingReservation">
/// A Reservation which already exists, presumably obtained from a list of Reservations
/// </param>
public CreateReservation(Reservation existingReservation, IReservationManager reservationManager)
{
InitializeComponent();
_reservationManager = reservationManager;
_memberManager = new MemberManagerMSSQL();
try
{
_members = _memberManager.RetrieveAllMembers();
}
catch (Exception ex)
{
SetError(ex.Message);
}
//txtMembers.ItemsSource = _members;
_existingReservation = existingReservation;
populateFormReadOnly();
}
/// <summary>
/// Author: Matt LaMarche
/// Created : 1/24/2019
/// This constructor is used for Creating a Reservation
/// Initializes connections to our ReservationManager and MemberManager
/// Populates Member Combobox and displays any errors
/// </summary>
public CreateReservation(IReservationManager reservationManager)
{
InitializeComponent();
_reservationManager = reservationManager;
_memberManager = new MemberManagerMSSQL();
try
{
_members = _memberManager.RetrieveAllMembers();
}
catch (Exception ex)
{
SetError(ex.Message);
}
//txtMembers.ItemsSource = _members;
chkActive.Visibility = Visibility.Hidden;
chkActive.IsChecked = true;
_existingReservation = null;
}
public ReservationDetailsViewModel(IUnityContainer container, ILoggerFacade logger, IReservationManager reservationManager, ITableManager tableManager, IMessageBoxService messageBoxService, IDialogBoxService dialogBoxService)
{
this._logger = logger;
this._container = container;
this._reservationManager = reservationManager;
this._tableManager = tableManager;
this._messageBoxService = messageBoxService;
this._dialogBoxService = dialogBoxService;
var allTables = this._tableManager.GetAll().ToDictionary(tbl => tbl.TableId, tbl => tbl);
// Assumption : Reservation duration is between 10 Am and 10 Pm
this._minFromHour = 10;
this._maxFromHour = 22;
this._reservedTables = new ObservableCollection<Table>();
var currentReservation = this._container.Resolve(typeof(Reservation), "SelectedReservation");
if (currentReservation != null)
{
this.FromHour = (short)(currentReservation as Reservation).TimeFrom;
this.ToHour = (short)(currentReservation as Reservation).TimeTo;
this._currentReservation = currentReservation as Reservation;
this._currentReservation.PropertyChanged += _currentReservation_PropertyChanged;
foreach (var tableId in this._currentReservation.ReservedTableIds)
{
this._reservedTables.Add(allTables[tableId]);
}
this._availableTables = new ObservableCollection<Table>(this.GetAvailableTables((ushort)this._fromHour, (ushort)this._toHour));
if (this._availableTables != null && this._availableTables.Count > 0)
{
this._selectedAvailableTable = this._availableTables.First();
}
}
else
{
this.FromHour = this._minFromHour;
}
if (this._reservedTables != null && this._reservedTables.Count > 0)
{
this._selectedReservedTable = this._reservedTables.First();
}
this.SaveCommand = new DelegateCommand(this.OnSaveCommand, () =>
{
return this._currentReservation != null &&
this._reservedTables != null &&
this._reservedTables.Count > 0 &&
!string.IsNullOrEmpty(this._currentReservation.CustomerName) &&
!string.IsNullOrEmpty(this._currentReservation.ContactNumber);
});
this.CancelCommand = new DelegateCommand(this.OnCancelCommand, () => { return this._currentReservation != null; });
this.ReserveTableCommand = new DelegateCommand(this.OnReserveTableCommand, () =>
{
return this._currentReservation != null &&
this._selectedAvailableTable != null &&
this._currentReservation.NoOfPersons > this._reservedTables.Sum(tbl => tbl.MaxOccupancy);
});
this.UnreserveTableCommand = new DelegateCommand(this.OnUnreserveTableCommand, () =>
{
return this._currentReservation != null &&
this._selectedReservedTable != null;
});
}
public ReservationFacade(IRepository repository)
{
_repository = repository;
_reservationManager = _repository.GetManagerInstance <Managers.ReservationManager>();
}
public ReservationFacade(IReservationManager reservationManager)
{
_reservationManager = reservationManager;
}
public HomeController(IRepository repository, IReservationManager reservationManager, ITimeManager timeManager)
{
this.repository = repository;
this.reservationManager = reservationManager;
this.timeManager = timeManager;
}
public ReservationController(IReservationManager reservationManager)
{
_reservationManager = reservationManager;
}
public ReservationAPI(IReservationManager reservationManager, ITableManager tableManager)
{
this.reservationManager = reservationManager;
this.tableManager = tableManager;
}
public AccountController(IReservationManager reservationManager, EmailController emailController)
{
_reservationManager = reservationManager;
_emailController = emailController;
}
public TableManager(ApplicationDbContext context, UserManager <ApplicationUser> userManager, IHttpContextAccessor httpContextAccessor, IReservationManager reservationManager)
: base(context, userManager, httpContextAccessor)
{
_reservationManager = reservationManager;
}
public ReservationController(IReservationManager reservationManager, IRepository repository, EmailController emailController)
{
this.repository = repository;
this.reservationManager = reservationManager;
this.emailController = emailController;
}
public AdminController(IRepository repository, IReservationManager reservationManager)
{
this._repository = repository;
this._reservationManager = reservationManager;
}
