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 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; }