public AppointmentService()
{
ObjectFactory.Container.Configure(x => x.AddRegistry<WcfRegistry>());
_sessionProvider = ObjectFactory.GetInstance<ISessionProvider>();
_appointmentRepository = ObjectFactory.GetInstance<IAppointmentRepository>();
_appointmentValidator = ObjectFactory.GetInstance<IAppointmentValidator>();
}
public PrescriptionController(IPrescriptionRepository _prescriptionRepository, ISessionStateManger _sessionStateManger, IMedicineRepository _medicineRepository, IAppointmentRepository _appointmentRepository, IDoctorRepository _doctorRepository)
{
sessionStateManger = _sessionStateManger;
prescriptionRepository = _prescriptionRepository;
medicineRepository = _medicineRepository;
appointmentRepository = _appointmentRepository;
doctorRepository = _doctorRepository;
}
public AppointmentService(IAppointmentRepository appointmentRepository, IReferenceGenerator referenceGenerator)
{
Check.If(appointmentRepository).IsNotNull();
Check.If(referenceGenerator).IsNotNull();
_appointmentRepository = appointmentRepository;
_referenceGenerator = referenceGenerator;
}
public AssignCleanerController(IAppointmentRepository appointmentRepository,
ICleanerRepository cleanerRepository,
ICustomerRepository customerRepository)
{
this.appointmentRepository = appointmentRepository;
this.cleanerRepository = cleanerRepository;
this.customerRepository = customerRepository;
}
public EventCustomerRegistrationViewDataFactory(IEventCustomerViewDataFactory eventCustomerViewDataFactory, IEventPodRoomRepository eventPodRoomRepository, IEventSchedulingSlotRepository eventSchedulingSlotRepository,
IAppointmentRepository appointmentRepository)
{
_eventCustomerViewDataFactory = eventCustomerViewDataFactory;
_eventPodRoomRepository = eventPodRoomRepository;
_eventSchedulingSlotRepository = eventSchedulingSlotRepository;
_appointmentRepository = appointmentRepository;
}
public PatientManagementController(IPatientRepository _patientRepository, IAppointmentRepository _appointmentRepository, IimagesRepository _imageRepository, ISessionStateManger _sessionStateManger, IDoctorRepository _doctorRepository)
{
patientRepository = _patientRepository;
appointmentRepository = _appointmentRepository;
imageRepository = _imageRepository;
sessionStateManger = _sessionStateManger;
doctorRepository = _doctorRepository;
}
public AppointmentController(IAppointmentRepository _appointmentRepo,
IDoctorRepository _doctorRepo, IPatientRepository _patientRepo, IDepartmentRepository _departmentRepo, UserManager <ApplicationUser> _userManager)
{
appointmentRepo = _appointmentRepo;
doctorRepo = _doctorRepo;
patientRepo = _patientRepo;
departmentRepo = _departmentRepo;
userManager = _userManager;
}
public MakeAsClientAppointmentCommandHandler(
IAppointmentRepository appointmentRepository,
IAppointmentFactory appointmentFactory,
ICurrentUser currentUser)
{
this.appointmentRepository = appointmentRepository;
this.appointmentFactory = appointmentFactory;
this.currentUser = currentUser;
}
public AppointmentService(
ISessionFactory sessionFactory,
IBus bus,
IAppointmentRepository appointmentRepository)
{
_sessionFactory = sessionFactory;
_bus = bus;
_appointmentRepository = appointmentRepository;
}
public PatientService(
IPatientRepository patientRepository,
ITreatmentRepository treatmentRepository,
IAppointmentRepository appointmentRepository)
{
_patientRepository = patientRepository;
_treatmentRepository = treatmentRepository;
_appointmentRespository = appointmentRepository;
}
/// <summary>
/// Reschedule Appointment Command Handler
/// </summary>
/// <param name="appointmentRepository"></param>
/// <param name="patientsRepository"></param>
/// <param name="appointmentMustExistValidator"></param>
/// <param name="appointmentEquipmentIsAvailableValidator"></param>
/// <param name="mediator"></param>
public RescheduleAppointmentCommandHandler(IAppointmentRepository appointmentWriteRepository, IBaseRepository <Appointment> appointmentRepository, IBaseRepository <Patient> patientsRepository, IAppointmentMustExistValidator appointmentMustExistValidator, IAppointmentEquipmentIsAvailableValidator appointmentEquipmentIsAvailableValidator, IMediator mediator)
{
_appointmentWriteRepository = appointmentWriteRepository;
_appointmentRepository = appointmentRepository;
_patientsRepository = patientsRepository;
_appointmentMustExistValidator = appointmentMustExistValidator;
_appointmentEquipmentIsAvailableValidator = appointmentEquipmentIsAvailableValidator;
_mediator = mediator;
}
public ChecklistController(ILogger <ChecklistController> logger, ContextEntity context)
{
_logger = logger;
_context = new ChecklistRepositoryEntity(context);
_contextAppointment = new AppointmentRepositoryEntity(context);
_save = new CheckListSaveService(_contextAppointment);
_list = new ChekListListService(_context);
_delete = new CheckListDeleteService(_context);
}
// private readonly IEventPodRoomRepository _eventPodRoomRepository;
// private readonly IEventPackageRepository _evenePackageRepository;
public EventAppointmentStatsService(IEventRepository eventRepository, IAppointmentRepository appointmentRepository, IEventSchedulingSlotRepository slotRepository)
//,IEventPodRoomRepository eventPodRoomRepository,IEventPackageRepository evenePackageRepository)
{
_eventRepository = eventRepository;
_appointmentRepository = appointmentRepository;
_slotRepository = slotRepository;
// _eventPodRoomRepository = eventPodRoomRepository;
//_evenePackageRepository = evenePackageRepository;
}
//private IDataProtector _protector;IDataProtectionProvider provider ,
public AppointmentController(IPatientAppointmentReferralRepository PARrepo, IAccountRepository accountRepo, IAddressRepository AddressRepo, IContactDetailsRepository CDRepo, IAppointmentRepository appointmentRepo, ITimesRepository timesRepo)
{
PARrepository = PARrepo;
AccountRepository = accountRepo;
AddressRepository = AddressRepo;
CDRepository = CDRepo;
AppointmentRepository = appointmentRepo;
timesRepository = timesRepo;
}
public AppointmentService(
ISessionFactory sessionFactory,
IBus bus,
IAppointmentRepository appointmentRepository)
{
_sessionFactory = sessionFactory;
_bus = bus;
_appointmentRepository = appointmentRepository;
}
/// <summary>
///
/// </summary>
/// <param name="appointmentRepository"></param>
/// <param name="appointmentEquipmentIsAvailableValidator"></param>
/// <param name="appointmentPatientMustExistRuleValidator"></param>
/// <param name="mediator"></param>
public BookAppointmentCommandHandler(IAppointmentRepository appointmentRepository, IBaseRepository <Patient> repository, IEquipmentService equipmentService, IAppointmentEquipmentIsAvailableValidator appointmentEquipmentIsAvailableValidator, IAppointmentPatientMustExistRuleValidator appointmentPatientMustExistRuleValidator, IMediator mediator)
{
_appointmentRepository = appointmentRepository;
_repository = repository;
_equipmentService = equipmentService;
_appointmentEquipmentIsAvailableValidator = appointmentEquipmentIsAvailableValidator;
_appointmentPatientMustExistRuleValidator = appointmentPatientMustExistRuleValidator;
_mediator = mediator;
}
public InternAttendancePageViewModel(INavigationService navigationService, IAppointmentRepository appointmentRepository, ICheckOutRepository checkOutRepository) :
base(navigationService)
{
this.navigationService = navigationService;
this.appointmentRepository = appointmentRepository;
this.checkOutRepository = checkOutRepository;
Title = "Comparecimento";
StartTime = DateTime.Now;
}
/// <summary>
/// Cancel Appointment Command Handler
/// </summary>
/// <param name="appointmentRepository"></param>
/// <param name="appointmentMustExistValidator"></param>
/// <param name="mediator"></param>
public CancelAppointmentCommandHandler(IAppointmentRepository appointmentWriteRepository, IBaseRepository <Appointment> appointmentRepository, IBaseRepository <Patient> patientsRepository, IAppointmentMustExistValidator appointmentMustExistValidator, IEquipmentService equipmentService, IMediator mediator)
{
_appointmentWriteRepository = appointmentWriteRepository;
_appointmentRepository = appointmentRepository;
_patientsRepository = patientsRepository;
_appointmentMustExistValidator = appointmentMustExistValidator;
_equipmentService = equipmentService;
_mediator = mediator;
}
public AppointmentController(IAppointmentRepository appointmentRepository,
IPatientRepository patientRepository,
IStaffRepository staffRepository,
IClinicRepository clinicRepository)
{
_appointmentRepository = appointmentRepository;
_patientRepository = patientRepository;
_staffRepository = staffRepository;
_clinicRepository = clinicRepository;
}
public AppointmentController(ILogger <AppointmentController> logger, IAppointmentRepository appointmentRepository,
IPractitionerRepository practitionerRepository, IPatientRepository patientRepository, IUserRepository userRepository, IModelValidator <AppointmentModel> validator)
{
_logger = logger;
_appointmentRepository = appointmentRepository;
_practitionerRepository = practitionerRepository;
_patientRepository = patientRepository;
_userRepository = userRepository;
_validator = validator;
}
public AdminsService(IAdminRepository adminRepository, IEquipmentTypeRepository equipmentTypeRepository, IContactMessageRepository contactMessageRepository, IMedicationTypeRepository medicationTypeRepository,
IMedicRepository medicRepository, IAppointmentRepository appointmentRepository)
{
this.adminRepository = adminRepository;
this.equipmentTypeRepository = equipmentTypeRepository;
this.contactMessageRepository = contactMessageRepository;
this.medicationTypeRepository = medicationTypeRepository;
this.medicRepository = medicRepository;
this.appointmentRepository = appointmentRepository;
}
public PatientsController(IPatientRepository repo, IPartnerRepository partnerrepo, IPatientReferenceRepository refrepo, IPatientDocumentRepository docrepo, IPatientVitalRepository PatientVital, IVisitRepository visit, IAppointmentRepository appointmentrepo)
{
_repo = repo;
partner_repo = partnerrepo;
ref_repo = refrepo;
doc_repo = docrepo;
PatientVital_repo = PatientVital;
Visit_repo = visit;
Appointment_repo = appointmentrepo;
}
public Dashboard(
IServiceProvider serviceProvider,
IAppointmentService appointmentService,
IAppointmentRepository appointmentRepository)
{
InitializeComponent();
_serviceProvider = serviceProvider;
_appointmentService = appointmentService;
_appointmentRepository = appointmentRepository;
}
public AppointmentService(IAppointmentRepository appointmentRepository,
IPatientRepository patientRepository,
IDoctorRepository doctorRepository,
IUserService userService)
{
this.appointmentRepository = appointmentRepository;
this.patientRepository = patientRepository;
this.doctorRepository = doctorRepository;
this.userService = userService;
}
public AppointmentService(IAppointmentRepository appointmentrepository,
IMedOfficeRepository medOfficeRepository,
IUserRepository userRepository,
IMedAreaRepository medAreaRepository)
{
_appointmentRepository = appointmentrepository;
_medOfficeRepository = medOfficeRepository;
_userRepository = userRepository;
_medAreaRepository = medAreaRepository;
}
public SchedulingService(IAppointmentRepository appointmentRepository,
IAppointmentRequestRepository appointmentRequestRepository,
IDoctorRepository doctorRepository,
IPatientRepository patientRepository)
{
_appointmentRepository = appointmentRepository;
_appointmentRequestRepository = appointmentRequestRepository;
_doctorRepository = doctorRepository;
_patientRepository = patientRepository;
}
private static IEnumerable <StudyEventAggregatedDayItemViewModel> GetStudyEventAggregatedDayItemViewModels(
IAppointmentRepository <TimeEventAppointment> appointmentsRepository,
EducatorMasterPerson forEducator = null)
{
DayOfWeek[] daysOfWeek = { DayOfWeek.Monday, DayOfWeek.Tuesday, DayOfWeek.Wednesday, DayOfWeek.Thursday, DayOfWeek.Friday, DayOfWeek.Saturday };
var appointments = appointmentsRepository.GetAppointments().Where(a => a.IsPublicMaster && !a.IsCancelled);
return(daysOfWeek.Select(d => GetStudyEventAggregatedDayItemViewModel(d, appointments, forEducator)));
}
public AppointmentsController(
IMapper mapper,
IAppointmentRepository repository,
IUnitOfWork unitOfWork,
IPatientRepository patientRepository)
{
this.mapper = mapper;
this.repository = repository;
this.unitOfWork = unitOfWork;
}
public ScheduleResponsiblePageViewModel(INavigationService navigationService, IResponsibleRepository responsibleRepository, IAppointmentRepository appointmentRepository, IInternRepository internRepository) :
base(navigationService)
{
this.navigationService = navigationService;
this.responsibleRepository = responsibleRepository;
this.appointmentRepository = appointmentRepository;
this.internRepository = internRepository;
Meetings = new ObservableCollection <ScheduleAppointment>();
BuscarAppointmentsAsync();
}
public CommentService(IOwnerProfileRepository ownerProfileRepository,
IVeterinaryProfileRepository veterinaryProfileRepository, IUnitOfWork unitOfWork,
ICommentRepository commentRepository, IAppointmentRepository appointmentRepository)
{
_ownerProfileRepository = ownerProfileRepository;
_veterinaryProfileRepository = veterinaryProfileRepository;
_unitOfWork = unitOfWork;
_commentRepository = commentRepository;
_appointmentRepository = appointmentRepository;
}
public AppointmentsController(IAppointmentRepository appointmentRepository,
IServiceRepository serviceRepository, IUserRepository userRepository,
IHttpContextAccessor httpContextAccessor, FoxtrotContext context)
{
_appointmentRepository = appointmentRepository;
_serviceRepository = serviceRepository;
_userRepository = userRepository;
_httpContextAccessor = httpContextAccessor;
_context = context;
}
public DoctorService(IDoctorRepository doctorRepository, ISpecialityRepository specialityRepository,
ILocationRepository addressRepository, IStateRepository stateRepository, IScheduleRepository scheduleRepository, IAppointmentRepository appointmentRepository)
{
_doctorRepository = doctorRepository;
_specialityRepository = specialityRepository;
_addressRepository = addressRepository;
_stateRepository = stateRepository;
_scheduleRepository = scheduleRepository;
_appointmentRepository = appointmentRepository;
}
public AppointmentService(IAppointmentRepository repository, IMapper mapper, AppointmentValidator validator,
IUserRepository userRepository, INotificationRepository notificationRepository, IEmailService emailService)
{
_repository = repository;
_userRepository = userRepository;
_mapper = mapper;
_validator = validator;
_notificationRepository = notificationRepository;
_emailService = emailService;
}
/// <summary>
/// Initializes a new instance of the AssignedEventsVM class.
/// </summary>
public AssignedEventsVM(
IAppointmentRepository _appt,
IPersonRepository _people,
INavigationService navService)
{
_appointmentRepository = _appt;
_personRepository = _people;
NavigationService = navService;
Refresh();
}
/// <summary>
/// Initializes a new instance of the ViewAllAppointmentsVM class.
/// </summary>
public ViewAllAppointmentsVM(
IAppointmentRepository _appts,
IPersonRepository _pers,
INavigationService navService
)
{
PersonRepository = _pers;
AppointmentRepository = _appts;
NavigationService = navService;
Refresh();
}
/// <summary>
/// Initializes a new instance of the AddSeniorVM class.
/// </summary>
public AddSeniorVM(INavigationService navService,
IPersonRepository _people,
IAppointmentRepository _appts,
IRequirementRepository _reqs,
IAppointmentRequirementsRepository _apptReqs)
{
_personRepo = _people;
_appointmentRepo = _appts;
_requirementRepo = _reqs;
_apptRequirementRepo = _apptReqs;
NavigationService = navService;
Refresh();
}
//private
/// <summary>
/// Initializes a new instance of the AppointmentAssignVM class.
/// </summary>
public AppointmentAssignVM(IPersonRepository _pers,
IAppointmentRepository _appts,
IAppointmentRequirementsRepository _appReqs,
IAttachedRequirementRepository _attachReqs,
IAvailabilityRepository _avail,
INavigationService _nav)
{
_personRepository = _pers;
_appointmentRepository = _appts;
_apptReqsRepository = _appReqs;
_attachedReqsRepository = _attachReqs;
_availabilityRepository = _avail;
NavigationService = _nav;
Refresh();
}
public AppointmentValidator(IAppointmentRepository appointmentRepository)
{
_appointmentRepository = appointmentRepository;
}
public AppointmentService(IAppointmentRepository appointmentRepository)
{
repository = appointmentRepository;
}
public AppointmentController(IAppointmentRepository repo)
{
this.repository = repo;
}
public AppointmentController(IAppointmentRepository appointmentRepository)
{
this.appointmentRepository = appointmentRepository;
}
public AppointmentService( IAppointmentRepository repository)
{
appointmentRepository = repository;
}
/// <summary>
/// Initializes a new instance of the <see cref="AppointmentFactory"/> class.
/// </summary>
/// <param name="appointmentRepository">
/// The appointment repository.
/// </param>
public AppointmentFactory( IAppointmentRepository appointmentRepository )
{
_appointmentRepository = appointmentRepository;
}
// DI constructor
public AppointmentController(IAppointmentRepository repository)
{
appointmentRepository = repository;
}
public AppointmentsFinder(IAppointmentRepository repository, ITimeConverter timeConverter)
{
_repository = repository;
_timeConverter = timeConverter;
}
private static AppointmentsController GetAppointmentsController(IAppointmentRepository repository)
{
var controller = new AppointmentsController(repository);
controller.ControllerContext = new ControllerContext
{
Controller = controller,
RequestContext = new RequestContext(new MockHttpContext(), new RouteData())
};
return controller;
}
