public ProfileController(IPatientRepository patientRepo, IDoctorsRepository doctorRepo, IUserRepository userRepo, UserManager <User> userMgr)
{
this.doctroRepo = doctorRepo;
this.userMgr = userMgr;
this.patientRepo = patientRepo;
this.userRepo = userRepo;
}
public BaseReservationValidator(IDoctorsRepository docRepo, IPatientsRepository patRepo, IWorkingHoursRepository whRepo, IReservationsRepository resRepo)
{
_workHoursRepository = whRepo;
_reservationsRepository = resRepo;
RuleFor(x => x.DoctorId)
.SetValidator(new BaseIdValidator <Doctor>(docRepo, "Niepoprawne dane lekarza"));
RuleFor(x => x.PatientId)
.SetValidator(new BaseIdValidator <Patient>(patRepo, "Niepoprawne dane pacjenta"));
RuleFor(x => x.Canceled)
.Cascade(CascadeMode.Stop)
.NotNull().WithMessage("Pole nie może być puste.")
.Must(x => x == false).WithMessage("Niepoprawny stan wizyty (odwołana).");
RuleFor(x => x.Starttime)
.Cascade(CascadeMode.Stop)
.NotEmpty().WithMessage("Pole nie może być puste.")
.Must(DateTimeValidator.BeInTheFuture).WithMessage("Rezerwacja musi zaczynać sie w przyszłości.");
RuleFor(x => x.Endtime)
.Cascade(CascadeMode.Stop)
.NotEmpty().WithMessage("Pole nie może być puste.")
.Must(DateTimeValidator.BeInTheFuture).WithMessage("Rezerwacja musi kończyć sie w przyszłości.");
RuleFor(x => x)
.Cascade(CascadeMode.Stop)
.NotNull().WithMessage("Pole nie może być puste.")
.Must(x => { return(DateTimeValidator.BeOfAProperDuration(x.Starttime, x.Endtime)); }).WithMessage("Niepoprawny czas trwania wizyty.");
}
public VisitController(IUsersRepository usersRepository, IServicesRepository servicesRepository, IDoctorsRepository doctorsRepository, ISchedulesRepository schedulesRepository, IVisitsRepository visitsRepository, ScheduleService scheduleService)
{
this.usersRepository = usersRepository;
this.servicesRepository = servicesRepository;
this.doctorsRepository = doctorsRepository;
this.schedulesRepository = schedulesRepository;
this.visitsRepository = visitsRepository;
this.scheduleService = scheduleService;
}
public VisitsController(IVisitsRepository repository, ITreatmentsOnVisitRepository treatmentsOnVisitRepository,
IDoctorsRepository doctorsRepository, IReservationsRepository reservationsRepository, AuthorizationService authorizationService)
{
_repository = repository;
_treatmentsOnVisitRepository = treatmentsOnVisitRepository;
_doctorsRepository = doctorsRepository;
_reservationsRepository = reservationsRepository;
_authorizationService = authorizationService;
}
public AppointmentsController(
UserManager <ApplicationUser> userManager,
IAppointmentsRepository appointmentsRepository,
IDoctorsRepository doctorsRepository)
{
_userManager = userManager;
_appointmentsRepository = appointmentsRepository;
_doctorsRepository = doctorsRepository;
}
public ReservationsController(IReservationsRepository repository, IWorkingHoursRepository whRepo,
IRoomsRepository roomRepo, IDoctorsRepository doctorsRepository,
ISpecialitiesRepository specialitiesRepository, AuthorizationService authorizationService)
{
_repository = repository;
_workHoursRepository = whRepo;
_roomsRepository = roomRepo;
_doctorsRepository = doctorsRepository;
_specialitiesRepository = specialitiesRepository;
_authorizationService = authorizationService;
}
public DoctorsController(
IAppointmentsRepository appointmentsRepository,
IPatientsRepository patientsRepository,
IAbsenceRepository absenceRepository,
IDoctorsRepository doctorsRepository)
{
_appointmentsRepository = appointmentsRepository;
_patientsRepository = patientsRepository;
_absenceRepository = absenceRepository;
_doctorsRepository = doctorsRepository;
}
public HomeController(
UserManager <ApplicationUser> userManager,
RoleManager <IdentityRole> roleManager,
IPatientsRepository patientsRepository,
IDoctorsRepository doctorsRepository)
{
_userManager = userManager;
_roleManager = roleManager;
_patientsRepository = patientsRepository;
_doctorsRepository = doctorsRepository;
}
public PatientsController(
UserManager <ApplicationUser> userManager,
IPatientsRepository patientsRepository,
IDoctorsRepository doctorsRepository,
ISpecializationsRepository specializationsRepository,
IAppointmentsRepository appointmentsRepository)
{
_userManager = userManager;
_patientsRepository = patientsRepository;
_doctorsRepository = doctorsRepository;
_specializationsRepository = specializationsRepository;
_appointmentsRepository = appointmentsRepository;
}
public AccountController(
UserManager <ApplicationUser> userManager,
SignInManager <ApplicationUser> signInManager,
IPatientsRepository patientsRepository,
IDoctorsRepository doctorsRepository,
ISpecializationsRepository specializationsRepository)
{
_userManager = userManager;
_signInManager = signInManager;
_patientsRepository = patientsRepository;
_doctorsRepository = doctorsRepository;
_specializationsRepository = specializationsRepository;
}
public ReservationDTOValidator(IWorkingHoursRepository whRepo, IDoctorsRepository docRepo, ILocalsRepository locRepo, IPatientsRepository patRepo, IReservationsRepository resRepo)
{
var baseReservationValidator = new BaseReservationValidator(docRepo, patRepo, whRepo, resRepo);
RuleFor(x => x)
.Cascade(CascadeMode.Stop)
.SetValidator(baseReservationValidator)
.MustAsync((x, cancellation) => baseReservationValidator.BeOnAWorkDay(x)).WithMessage("Rezerwacja nie znajduje się wewnątrz godzin pracy lekarza.")
.MustAsync((x, cancellation) => baseReservationValidator.NotOverlapWithAnother(x.LocalId, x.DoctorId, x.Starttime, x.Endtime))
.WithMessage("Rezerwacja nie jest możliwa w wybranym terminie.");
RuleFor(x => x.LocalId)
.SetValidator(new BaseIdValidator <Local>(locRepo, "Niepoprawne dane lokalu"));
}
public MainwindowViewModel(IDoctorsRepository docRepo, IPatientsRepository repoPatient)
{
// _navigation = navigation;
_repoPatient = repoPatient;
_docRepo = docRepo;
HeaderContent = new MainHeaderVM();
ViewModels = new ObservableCollection <ViewModelCommon>();
NavigationCommand = new RelayCommand <string>(Navigation);
CloseTabCommand = new RelayCommand <ViewModelCommon>(CloseTab);
_searchVm = ServiceLocator.Current.GetInstance <SearchViewModel>();
Messenger.Default.Register <Tuple <Patient, string> >(this,
message => { AddEditPatient(message.Item1, message.Item2); });
Messenger.Default.Register <Tuple <Patient, IModelCommon> >(this,
message => { AddEditPatient(message.Item1, message.Item2); });
}
public DatabaseInitializer(
IDoctorsRepository doctorsRepository,
IImagesRepository imagesRepository,
IServicesRepository serviceRepository,
ISchedulesRepository schedulesRepository,
IUsersRepository usersRepository,
CryptoService cryptoService,
ILogger <DatabaseInitializer> logger)
{
this.logger = logger;
this.schedulesRepository = schedulesRepository;
this.usersRepository = usersRepository;
this.cryptoService = cryptoService;
this.serviceRepository = serviceRepository;
this.doctorsRepository = doctorsRepository;
this.imagesRepository = imagesRepository;
}
public DoctorValidator(ISpecialitiesRepository specRepo, IPeopleRepository pepRepo,
IDoctorsRepository docRepo, IHttpContextAccessor httpContext)
{
var baseIdValidator = new BaseIdValidator <Doctor>(docRepo, "");
RuleFor(x => x.Id)
.Cascade(CascadeMode.Stop)
.NotEmpty().WithMessage("Pole nie może być puste.")
.SetValidator(new BaseIdValidator <Person>(pepRepo, "Osoba nie istnieje."))
.When(x => x.Id > 0)
.Must(x => baseIdValidator.NotExist(x)).WithMessage("Osoba jest już lekarzem.")
.When(x => x.Id > 0 && httpContext.HttpContext.Request.Method.ToUpper() == "POST");
RuleFor(x => x.SpecialityId)
.Cascade(CascadeMode.Stop)
.NotEmpty().WithMessage("Pole nie może być puste.")
.SetValidator(new BaseIdValidator <Speciality>(specRepo, "Specjalizacja nie istnieje"));
}
public WorkingHoursValidator(IDoctorsRepository docRepo, ILocalsRepository locRepo, IWorkingHoursRepository whRepo)
{
_workingHoursRepository = whRepo;
RuleFor(x => x.DoctorId).SetValidator(new BaseIdValidator <Doctor>(docRepo, "Niepoprawne dane lekarza."));
RuleFor(x => x.LocalId).SetValidator(new BaseIdValidator <Local>(locRepo, "Niepoprawne dane lokalu."));
RuleFor(x => x.From)
.Cascade(CascadeMode.Stop)
.NotEmpty().WithMessage("Pole nie może być puste.")
.Must(DateTimeValidator.BeInTheFuture).WithMessage("Godziny pracy nie mogą być w przeszłości");
RuleFor(x => x.To)
.Cascade(CascadeMode.Stop)
.NotEmpty().WithMessage("Pole nie może być puste.")
.Must(DateTimeValidator.BeInTheFuture).WithMessage("Godziny pracy nie mogą być w przeszłości");;
RuleFor(x => x)
.Cascade(CascadeMode.Stop)
.NotEmpty().WithMessage("Pole nie może być puste.")
.Must((x) => { return(DateTimeValidator.BeOfAProperDuration(x.From, x.To)); }).WithMessage("Niepoprawny czas trwania.")
.MustAsync((x, cancellation) => NotOverlapWithDifferentWorkHours(x)).WithMessage("Godziny pracy kolidują z innymi godzinami pracy lekarza.");
}
public DoctorsSlotsRepository([NotNull] IDoctorsRepository repository)
{
m_Repository = repository;
}
public DoctorsController(IDoctorsRepository doctorsRepository)
{
_doctorsRepository = doctorsRepository;
}
public SelectListHelper(IPatientRepository patientRepository, IDoctorsRepository doctorsRepository)
{
_patientRepository = patientRepository;
_doctorsRepository = doctorsRepository;
}
public InformationFinder(IDoctorsRepository repository)
{
m_Repository = repository;
}
public DoctorController(ILogger <DoctorController> logger, IConfiguration iConfig, IDoctorsRepository doctorRepository)
{
_logger = logger;
_configuration = iConfig;
_doctorRepository = doctorRepository;
}
public DeleteDoctorsModel(IDoctorsRepository doctorsRepository)
{
_doctorsRepository = doctorsRepository;
}
public CreateDoctorsModel(IDoctorsRepository doctorsRepository)
{
_doctorsRepository = doctorsRepository;
}
public DoctorsController(IDoctorsRepository repo, SignInManager <User> signInManager, UserManager <User> userMgr)
{
this.repo = repo;
this.signInMgr = signInManager;
this.userMgr = userMgr;
}
public DoctorsController(IDoctorsRepository repository, PeopleController peopleController, IPeopleRepository peopleRepository)
{
_repository = repository;
_peopleController = peopleController;
_peopleRepository = peopleRepository;
}
public DoctorController(IDoctorsRepository doctorsRepository, IMapper mapper, ISchedulesRepository schedulesRepository)
{
this.doctorsRepository = doctorsRepository;
this.mapper = mapper;
this.schedulesRepository = schedulesRepository;
}
private InformationFinder CreateSut(IDoctorsRepository repository)
{
return new InformationFinder(repository);
}
public DoctorsSlotsRepository([NotNull] IDoctorsRepository repository)
{
m_Repository = repository;
}
public DoctorQueriesHandler(IDoctorsRepository doctorsRepository)
{
this.doctorsRepository = doctorsRepository;
}
public DoctorsController(IDoctorsRepository repo)
{
_repo = repo;
}
public DoctoresModel(IDoctorsRepository doctoresRepository)
{
_doctoresRepository = doctoresRepository;
}
private InformationFinder CreateSut(IDoctorsRepository repository)
{
return(new InformationFinder(repository));
}
public DoctorAuthController(SignInManager <User> signInManager, UserManager <User> userMgr, IDoctorsRepository repo)
{
this.signInManager = signInManager;
this.userMgr = userMgr;
this.repo = repo;
}
public InformationFinder(IDoctorsRepository repository)
{
m_Repository = repository;
}
