public SearchViewModel()
{
_repoPatient = ServiceLocator.Current.GetInstance <IPatientsRepository>();
PatientView = CollectionViewSource.GetDefaultView(_repoPatient.GetAllPatientAsync().Result);
SearchName = "Abdullah Farooq";
PatientTests = _repoPatient.GetWithChildren(1);
}
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 PatientController(IPatientsRepository repository, ILanguagesRepository languagesRepository, IHomeManager homeManager, IPatientManager patientManager)
{
this._repository = repository;
this._languagesRepository = languagesRepository;
this._homeManager = homeManager;
this._patientManager = patientManager;
}
public OldMedicineHistoryValidator(IMedicinesRepository medicinesRepository, IPatientsRepository patientsRepository)
{
RuleFor(x => x.MedicineId)
.Cascade(CascadeMode.Stop)
.NotEmpty().WithMessage("Pole nie może być puste.")
.SetValidator(new BaseIdValidator <Medicine>(medicinesRepository, "Choroba nie istnieje."));
RuleFor(x => x.PatientId)
.Cascade(CascadeMode.Stop)
.NotEmpty().WithMessage("Pole nie może być puste.")
.SetValidator(new BaseIdValidator <Patient>(patientsRepository, "Pacjent nie istnieje."));
RuleFor(x => x.Date)
.Cascade(CascadeMode.Stop)
.NotEmpty().WithMessage("Pole nie może być puste")
.Must(x => x.Date < DateTime.Now.Date).WithMessage("Data nie może być w przyszłości");
RuleFor(x => x.Description)
.Cascade(CascadeMode.Stop)
.MaximumLength(1023).WithMessage("Maksymalna długość wynosi {MaxLength} znaków, wpisano {TotalLength}.");
RuleFor(x => x)
.Cascade(CascadeMode.Stop)
.NotEmpty().WithMessage("Pole nie może być puste");
}
public AddPatientViewModel(Patient patient, IPatientsRepository pRepo)
{
_repoPatient = pRepo;
PatientTests = patient;
PatientW = new PatientW(_patientTests);
SetCommands();
}
public OldIllnessHistoryValidator(IIllnessesRepository illnessesRepository, IPatientsRepository patientsRepository)
{
RuleFor(x => x.IllnessId)
.Cascade(CascadeMode.Stop)
.NotEmpty().WithMessage("Pole nie może być puste.")
.SetValidator(new BaseIdValidator <Illness>(illnessesRepository, "Choroba nie istnieje."));
RuleFor(x => x.PatientId)
.Cascade(CascadeMode.Stop)
.NotEmpty().WithMessage("Pole nie może być puste.")
.SetValidator(new BaseIdValidator <Patient>(patientsRepository, "Pacjent nie istnieje."));
RuleFor(x => x.Date)
.Cascade(CascadeMode.Stop)
.NotEmpty().WithMessage("Pole nie może być puste")
.Must(x => x.Date < DateTime.Now.Date).WithMessage("Data nie może być w przyszłości");
RuleFor(x => x.Description)
.Cascade(CascadeMode.Stop)
.NotEmpty().WithMessage("Pole nie może być puste")
.MaximumLength(1023).WithMessage("Maksymalna długość wynosi {MaxLength} znaków, wpisano {TotalLength}.");
RuleFor(x => x)
.Cascade(CascadeMode.Stop)
.Must(x => x.Curedate.Value >= x.Date)
.When(x => x.Curedate.HasValue).WithMessage("Data końcowa nie może być wcześniejsza niż początkowa.");
}
public RegularAppointmentService(MyDbContext context)
{
this._appointmentRepository = new AppointmentRepository(context);
this._patientRepository = new PatientsRepository(context);
this.operationService = new OperationService(new OperationRepository(context));
this.employeesScheduleService = new EmployeesScheduleService(new EmployeesScheduleRepository(context));
this.doctorService = new DoctorService(new OperationRepository(context), _appointmentRepository, new EmployeesScheduleRepository(context), new DoctorRepository(context));
}
public RegularAppointmentService(IAppointmentRepository appointmentRepository, IEmployeesScheduleRepository employeesScheduleRepository, DoctorService doctorService, IPatientsRepository patientRepository, OperationService operationService)
{
this._appointmentRepository = appointmentRepository;
this.doctorService = doctorService;
this.employeesScheduleService = new EmployeesScheduleService(employeesScheduleRepository);
this._patientRepository = patientRepository;
this.operationService = operationService;
}
public DoctorsController(
UserManager <ApplicationUser> userManager,
IAppointmentsRepository appointmentsRepository,
IPatientsRepository patientsRepository)
{
_userManager = userManager;
_appointmentsRepository = appointmentsRepository;
_patientsRepository = patientsRepository;
}
public SearchViewModel(IPatientsRepository repository)
{
ViewModelName = "Search";
HeaderContent = new MainHeaderVM();
_repoPatient = repository;
DetailCommand = new RelayCommand <long>(NavigateTo);
AddNewTestCommand = new RelayCommand <string>(AddNewTest);
TestDetailCommand = new RelayCommand <IModelCommon>(TestDetail);
EditPatientCommand = new RelayCommand(EditPatient);
}
public DbContextUnitOfWork(SqliteDbContext dbContext,
IUsersRepository usersRepository,
IPatientsRepository patientsRepository,
IClassificationModelsRepository classificationModelsRepository)
{
_dbContext = dbContext;
UsersRepository = usersRepository;
PatientsRepository = patientsRepository;
ClassificationModelsRepository = classificationModelsRepository;
}
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 PatientFirstHandler(
IDateTimeProvider dateTimeProvider,
IPatientsRepository patients,
IVisitItemsRepository visitItems,
IDispanserizationsRepository dispanserizations
)
{
_dateTimeProvider = dateTimeProvider;
_patients = patients;
_visitItems = visitItems;
_dispanserizations = dispanserizations;
}
public AddPatientViewModel(IPatientsRepository pRepo)
{
_repoPatient = pRepo;
PatientTests = new Patient();
PatientW = new PatientW(_patientTests)
{
PatientID = LoadId(),
RefBy = "Self",
Sex = "Male"
};
SetCommands();
}
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 PatientsController(
UserManager <ApplicationUser> userManager,
IPatientsRepository patientsRepository,
IDoctorsRepository doctorsRepository,
ISpecializationsRepository specializationsRepository,
IAppointmentsRepository appointmentsRepository)
{
_userManager = userManager;
_patientsRepository = patientsRepository;
_doctorsRepository = doctorsRepository;
_specializationsRepository = specializationsRepository;
_appointmentsRepository = appointmentsRepository;
}
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 HomeController(
Microsoft.AspNetCore.Identity.UserManager <IdentityUser> userManager,
SignInManager <IdentityUser> signInManager,
ILogger <RegisterModel> logger,
IEmailSender emailSender,
IAuthorizationRepository authorization, IPatientsRepository patients, ITemporaryPatientsRepository temporaryPatients, ITurnsRepository turns)
{
_userManager = userManager;
_signInManager = signInManager;
_logger = logger;
_emailSender = emailSender;
this.authorizationRepository = authorization;
this.patientsRepository = patients;
this.temporaryPatientsRepository = temporaryPatients;
this.turnsRepository = turns;
}
public IllnessHistoryValidator(IIllnessesHistoryRepository illHistRepo, IPatientsRepository patRepo,
IIllnessesRepository illRepo, IVisitsRepository visitRepo, IHttpContextAccessor httpContext)
{
RuleFor(x => x.IllnessId)
.Cascade(CascadeMode.Stop)
.NotEmpty().WithMessage("Pole nie może być puste.")
.SetValidator(new BaseIdValidator <Illness>(illRepo, "Choroba nie istnieje."));
RuleFor(x => x.VisitId)
.Cascade(CascadeMode.Stop)
.NotEmpty().WithMessage("Pole nie może być puste.")
.Must(x => visitRepo.Exists(x)).WithMessage("Wizyta nie istnieje.");
RuleFor(x => x.Description)
.MaximumLength(1023).WithMessage("Maksymalna długość wynosi {MaxLength} znaków, wpisano {TotalLength}.");
}
public PatientValidator(IPeopleRepository peopleRepository, IPatientsRepository patientsRepository,
IHttpContextAccessor httpContext)
{
RuleFor(x => x.Id)
.Cascade(CascadeMode.Stop)
.NotEmpty().WithMessage("Pole nie może być puste.");
RuleFor(x => x.Id)
.SetValidator(new BaseIdValidator <Person>(peopleRepository, "Osoba nie istnieje."))
.When(x => x.Id > 0);
RuleFor(x => x.Id)
.Cascade(CascadeMode.Stop)
.Must(x => new BaseIdValidator <Patient>(patientsRepository, "").NotExist(x))
.WithMessage("Osoba jest już pacjentem")
.When(x => x.Id > 0 && httpContext.HttpContext.Request.Method.ToUpper() == "POST");
}
public PatientsManager()
{
_pRep = new PatientsRepository();
_exportService = new ExportService();
}
public PatientsService(IPatientsRepository patientsRepository)
{
_patientsRepository = patientsRepository;
}
public ProfileController(IPatientsRepository patients)
{
this.patientsRepository = patients;
}
public LoginService(IPatientsRepository patientRepository, IAdministratorRepository administratorRepository)
{
_patientRepository = patientRepository;
_administratorRepository = administratorRepository;
}
public PatientsController(IPatientsRepository repository,
IRepository <PatientDiagnosys> diagnosysRepository)
{
_repository = repository;
_diagnosysRepository = diagnosysRepository;
}
public LoginService(IPatientsRepository patientRepository, IAdministratorRepository administratorRepository, IConfiguration config)
{
_patientRepository = patientRepository;
_administratorRepository = administratorRepository;
_config = config;
}
public OldmedicinehistoriesController(IOldMedicinesHistoryRepository repository, IPatientsRepository patientsRepository, AuthorizationService authorizationService)
{
_repository = repository;
_patientsRepository = patientsRepository;
_authorizationService = authorizationService;
}
public LoginService(MyDbContext context, IConfiguration config)
{
_patientRepository = new PatientsRepository(context);
_administratorRepository = new AdministratorRepository(context);
_config = config;
}
public patientsController(IPatientsRepository patients)
{
this.patientsRepository = patients;
}
