public Task <bool> Handle(RegisterCovidPatientCommand request, CancellationToken cancellationToken) { if (!request.IsValid()) { NotifyValidationErrors(request); return(Task.FromResult(false)); } var patient = new Patient(Guid.NewGuid(), request.Name, request.Email, request.RegistrationDate, PatientType.COVID19); if (_patientRepository.GetByEmail(patient.Email) != null) { _mediator.RaiseEvent(new DomainNotification(request.MessageType, "E-mail is already registered.")); return(Task.FromResult(false)); } _patientRepository.Add(patient); if (Commit()) { _mediator.RaiseEvent(new PatientCovidRegisteredEvent(patient.Id, patient.Name, patient.Email, patient.RegistrationDate)); } return(Task.FromResult(true)); }
public ContractResponse <PatientGetResponse> Add(ContractRequest <AddUpdatePatientRequest> request) { try { var model = request.Data.Patient.ToPatient(); var brokenRules = model.GetBrokenRules().ToList(); if (!brokenRules.Any()) { _patientRepository.Add(model); _uow.Commit(); var responseModel = new PatientGetResponse { Id = model.Id }; return(ContractUtil.CreateResponse(request, responseModel)); } return(ContractUtil.CreateInvalidResponse <PatientGetResponse>(brokenRules)); } catch (Exception ex) { _logger.LogError(20, ex, ex.Message); return(ContractUtil.CreateInvalidResponse <PatientGetResponse>(ex)); } }
public BaseResponse <int> Add(BaseRequest <Patient> dto) { BaseResponse <int> response = new BaseResponse <int>(); try { Patient patient = dto.Value; if (patient.Validate()) { response.Value = _patientRepository.Add(patient); response.Success = true; } else { response.Success = false; response.BrokenRules = patient.BrokenRules; } } catch (Exception ex) { SetErrorResponse(response, ex); } return(response); }
public IActionResult Add(PatientViewModel model) { if (_patientRepository.GetAll().ToList().Any(x => x.FirstName.Equals(model.FirstName) && x.LastName.Equals(model.LastName))) { ModelState.AddModelError("", "Patient with same first name and last name already exist"); } if (!ModelState.IsValid) { return(View(model)); } try { Patient patient = model; patient.Gender = Enum.GetName(typeof(Gender), model.Gender); _patientRepository.Add(patient); _patientRepository.SaveChanges(); return(RedirectToAction(nameof(Index))); } catch (Exception) { return(View(model)); } }
public Task <bool> Handle(RegisterNewPatientCommand message, CancellationToken cancellationToken) { if (!message.IsValid()) { NotifyValidationErrors(message); return(Task.FromResult(false)); } var patient = new Patient.Builder(Guid.NewGuid()).Named(message.FullName).BornIn(message.BirthDate) .WithCpf(message.Cpf) .WithGender(message.Gender).WithPhone(message.Phone).WhichIsActive().Build(); if (_patientRepository.GetByCpf(patient.Cpf) != null) { _bus.RaiseEvent(new DomainNotification(message.MessageType, $"There is already a patient registered with this CPF ({patient.Cpf})")); return(Task.FromResult(false)); } if (!patient.IsValid()) { NotifyValidationErrors(patient.ValidationResult); return(Task.FromResult(false)); } _patientRepository.Add(patient); if (Commit()) { _bus.RaiseEvent(new PatientRegisteredEvent(patient)); } return(Task.FromResult(true)); }
public IActionResult Create(PatientViewModel model) { if (ModelState.IsValid) { string uniqueFileName = null; if (model.Photo != null) { string uploadsFolder = Path.Combine(hostingEnvironment.WebRootPath, "images"); uniqueFileName = Guid.NewGuid().ToString() + "_" + model.Photo.FileName; string filePath = Path.Combine(uploadsFolder, uniqueFileName); model.Photo.CopyTo(new FileStream(filePath, FileMode.Create)); } Patient newPatient = new Patient { PersonId = model.PersonId, ProblemCategoryId = model.ProblemCategoryId, ProblemDescription = model.ProblemDescription, EmployeId = model.EmployeId, Date = model.Date, IUser = 1, IDate = DateTime.Now, EUser = 0, EDate = null, PhotoPath = uniqueFileName }; _patientRepository.Add(newPatient); return(RedirectToAction("details", new { id = newPatient.Id })); } return(View()); }
public async Task <int> FirstVisit_Post(FirstVisitVM firstVisit) { firstVisit.Visit.VisitDate = firstVisit.Visit.VisitDate + firstVisit.Visit.TimeOfVisit; var visits = _visitRepository.GetForDateTime(firstVisit.Visit.VisitDate); if (firstVisit.Visit.DentistId == 0) { if (visits.Any()) { if (visits.Select(v => v.PatientId).Contains(firstVisit.Visit.PatientId)) { // return 1; } var dentists = _dentistRepository.GetAll().Select(d => d.Id).ToList(); foreach (var v in visits) { if (dentists.Contains(v.DentistId)) { dentists.Remove(v.DentistId); } } if (dentists.Any()) { firstVisit.Visit.DentistId = dentists.First(); } } else { firstVisit.Visit.DentistId = _dentistRepository.GetAll().Select(d => d.Id).First(); } } var patient = _mapper.Map <Patient>(firstVisit.Patient); await _patientRepository.Add(patient); var address = _mapper.Map <Address>(firstVisit.Patient.Address); address.PatientId = patient.Id; await _addressRepository.Add(address); var visit = _mapper.Map <Visit>(firstVisit.Visit); visit.PatientId = patient.Id; await _visitRepository.Add(visit); return(0); }
public void given_new_patient_when_adding_should_return_new_id() { _repository.Add(Arg.Any <Patient>()).Returns(1, 3, 5); Assert.That(_service.AddPatient(new Patient()), Is.EqualTo(1)); Assert.That(_service.AddPatient(new Patient()), Is.EqualTo(3)); Assert.That(_service.AddPatient(new Patient()), Is.EqualTo(5)); }
public IActionResult AddPatient([FromBody] Patient model) { model.FullName = (string)(model.FirstName + " " + model.LastName); model.Date = DateTime.Now; model.MRN = GenMRN(); model.Display = model.FirstName + " " + model.LastName + "-" + model.MRN; _repo.Add(model); return(new OkObjectResult(new { patientId = model.PatientId })); }
public ActionResult CreatePatient(PatientViewModel patientViewModel) { if (ModelState.IsValid) { patientRepository.Add(patientViewModel.ToDomainModel()); return(RedirectToAction("Index")); } return(View(patientViewModel)); }
public void Register(PatientRegistrationDTO registrationDTO) { PatientAccountMemento memento = registrationDTO.ToPatientAccountMemento(); memento.IsActivated = false; memento.IsBlocked = false; memento.City = _cityRepository.Get(registrationDTO.CityId).GetMemento(); PatientAccount patientAccount = new PatientAccount(memento); _patientRepository.Add(patientAccount); }
public async Task <Patient> Add(Patient entity) { try { var bOpDoneSuccessfully = await _PatientRepository.Add(entity); return(bOpDoneSuccessfully); } catch (Exception ex) { throw new Exception("BusinessLogic:PatientBusiness::InsertPatient::Error occured.", ex); } }
public void Add(GuestPatientDTO guestPatient) { var patient = new Patient(new PatientMemento() { Name = guestPatient.Name, Surname = guestPatient.Surname, Jmbg = guestPatient.Jmbg, BloodType = BloodType.Unknown, RhFactor = RhFactor.Unknown }); _repository.Add(patient); }
public void Add(Patient patient) { try { _patientRepository.Add(patient); _logger.LogInformation("New patient was added!"); } catch (Exception exception) { _logger.LogError("An error occurred while adding the patient" + " | " + exception); throw; } }
public IActionResult Post(Patient patient) { try { _patientRepository.Add(patient); var cacheKey = "Patient" + patient.Id; _cache.Set(cacheKey, patient); return(CreatedAtAction("Get", new { id = patient.Id }, patient)); } catch (Exception e) { return(StatusCode(500, $"Cannot save this patient -- Internal error: {e}")); } }
public async Task <IActionResult> AddPatient([FromBody] PatientRequestDto patientRequestDto) { if (String.IsNullOrEmpty(patientRequestDto.StudyRequests[0].EstimatedEndTime)) { patientRequestDto.StudyRequests[0].EstimatedEndTime = null; } var resultModel = new ServiceResultModel <Patient> { IsSuccess = false, Errors = new List <string>() }; var patientExsists = _patientRepository.Any(p => p.PatientName == patientRequestDto.PatientName); if (patientExsists) { return(BadRequest("Patient already exsits")); } var newPatient = _patientRepository.Add(new Patient { PatientName = patientRequestDto.PatientName, DOB = patientRequestDto.DOB, PatientSexId = patientRequestDto.PatientSex, RoomId = (int)patientRequestDto.RoomNameId, }); var saved = (newPatient != null) ? await _unitOfWork.CommitAsync() : 0; var newDoctorPatient = _doctorPatientRepository.Add(new DoctorPatient { DoctorId = patientRequestDto.DoctorRequests[0].DoctorId, PatientId = newPatient.PatientId }); var doctorPatientSaved = (newDoctorPatient != null) ? await _unitOfWork.CommitAsync() : 0; var newStudy = _studyRepository.Add(new Study { PatientId = newPatient.PatientId, StudyStatusId = patientRequestDto.StudyRequests[0].StudyStatusId, DoctorId = patientRequestDto.DoctorRequests[0].DoctorId, PlannedStartTime = DateTime.Now.ToShortDateString(), EstimatedEndTime = patientRequestDto.StudyRequests[0].EstimatedEndTime, Descriptions = patientRequestDto.StudyRequests[0].Descriptions }); var savedStudy = (newStudy != null) ? await _unitOfWork.CommitAsync() : 0; var resultPatient = _patientRepository.GetById(newPatient.PatientId); if (saved > 0 && doctorPatientSaved > 0 && savedStudy > 0) { resultModel.IsSuccess = true; resultModel.Data = resultPatient; return(Ok(resultModel)); } return(Ok("No Patient Details found")); }
public async Task <IActionResult> Upload() { FileInfo file = new FileInfo(@"D:\1.xlsx"); ExcelPackage.LicenseContext = LicenseContext.NonCommercial; using ExcelPackage package = new ExcelPackage(file); ExcelWorksheet workSheet = package.Workbook.Worksheets[0]; int totalRows = workSheet.Dimension.Rows; for (int i = 2; i <= totalRows; i++) { Patient patient = new Patient { Name = workSheet.ConvertToString(i, 1), Telephone = workSheet.ConvertToString(i, 2), Gender = workSheet.ConvertToString(i, 3) == "ذكر" ? GenderEnum.Male : GenderEnum.Female }; await patientRepository.Add(patient).ConfigureAwait(true); await unitOfWork.CompleteAsync().ConfigureAwait(true); } return(Ok()); }
public async Task <PatientDto> Add(PatientDto model) { model.Code = string.Empty; var entity = _patientRepository.Add(_mapper.Map <TPatient>(model)); await _patientRepository.SaveChangeAsync(); var maxId = await _patientRepository.Repo.MaxAsync(c => c.Id); entity.Code = $"BN-{(maxId + 1):D8}"; await _patientRepository.SaveChangeAsync(); model.Id = entity.Id; return(model); }
public async Task Adicionar(Patient patient) { if (!ExecutarValidacao(new PatientValidation(), patient)) { return; } if (await _patientRepository.CpfExists(patient.Cpf)) { Notificar("This document has been already regitered in our system!"); return; } await _patientRepository.Add(patient); }
public ActionResult create(PatientDataModel student) { if (!ModelState.IsValid) { return(View(student)); } var data = repository.Add(student); if (data == null) { ModelState.AddModelError(string.Empty, "Server Error. Please contact administrator."); return(View(student)); } return(RedirectToAction("Index")); }
public PatientDto CreatePatient(string phoneNo, string firstName, string lastName, string createdBy, string email) { var patientID = Guid.NewGuid().ToString(); if (string.IsNullOrEmpty(phoneNo)) { throw new Exception("The PhoneNo cannot be null!"); } if (string.IsNullOrEmpty(firstName)) { throw new Exception("The Firstname cannot be null!"); } if (string.IsNullOrEmpty(lastName)) { throw new Exception("The Lastname cannot be null!"); } if (string.IsNullOrEmpty(createdBy)) { throw new Exception("The CreatedBy cannot be null!"); } if (string.IsNullOrEmpty(email)) { throw new Exception("The Email cannot be null!"); } try { _patientRepository.Add(patientID, phoneNo, firstName, lastName, createdBy, email); var patientDto = _patientRepository.FindByPhoneNo(phoneNo); if (patientDto == null) { throw new InvalidPatientIDException("The PhoneNo is not correct!"); } return(patientDto); } catch (SqlException ex) { throw new DuplicatePhoneNoException("The PhoneNo exists in the database! " + ex.Message); } }
public bool Register(Patient patient) { if (!IsUsernameUnique(patient.Username)) { MessageBox.Show("Uneto korisničko ime već postoji u sistemu", "Podaci nisu unikatni", MessageBoxButton.OK); return(false); } if (!IsJMBGUnique(patient.JMBG)) { MessageBox.Show("Uneti JMBG već postoji u sistemu", "Podaci nisu unikatni", MessageBoxButton.OK); return(false); } _patientRepository.Add(patient); return(true); }
public async Task <Response> Handle(AddPatientRequest request, CancellationToken cancellationToken) { //Verifica se a requisição é válida if (request == null) { AddNotification("Request", "A requisição é inválida!"); return(new Response(this)); } //Verifica se o CPF inserido é válido if (!request.CPF.IsValidCpf()) { AddNotification("CPF", "CPF Inválido, por favor insira um válido!"); return(new Response(this)); } //Verifica se o paciente já está cadastrado if (_patientRepository.Exists(request.Email, request.CPF, request.RG)) { AddNotification("Paciente", "Paciente já cadastrado"); return(new Response(this)); } //Instancia o paciente e verifica se existe algum dado inválido Entities.Patient patient = new(request.FirstName, request.LastName, request.Email, request.Password, request.Phone, request.BirthDate, request.CPF, request.RG, request.CEP, request.Address, request.District, request.Complement, request.City, request.State); AddNotifications(patient); if (IsInvalid()) { return(new Response(this)); } //Insere os dados no banco _patientRepository.Add(patient); //Cria o objeto da resposta var response = new Response(this, patient); //Retorna a resposta return(await Task.FromResult(response)); }
public IHttpActionResult Post([FromBody] PatientEntryModel model) { try { if (ModelState.IsValid) { var entity = new Patient { Account = new Account { Username = model.Username, Password = model.Password, Email = model.Email, CreationDate = DateTime.Now }, FirstName = model.FirstName, LastName = model.LastName, BirthDate = model.BirthDate.Value, Status = model.Status, Gender = model.Gender, Telephone = model.Telephone, Address = model.Address, MedicareNumber = model.MedicareNumber }; _repository.Add(entity); _repository.Commit(); model.AccountId = entity.AccountId; return(base.Ok(model)); } else { return(base.BadRequest(ModelState)); } } catch (Exception ex) { return(base.BadRequest(ex.Message)); } }
public async Task <IActionResult> CreatePatient(PatientWriteDtoModel model) { // we can use auto mapper to map internal model to dto PatientModel entity = new PatientModel { DateOfBirth = model.DateOfBirth, EmailAddress = model.EmailAddress, MetaData = model.MetaData.Select(x => new MetaDataModel { Key = x.Key, Value = x.Value }).ToList(), PatientName = model.PatientName, OfficialID = model.OfficialID }; _patientRepository.Add(entity); if (_patientRepository.SaveChanges()) { return(Ok(new { message = "Patient added successfully." })); } return(BadRequest()); }
public IActionResult Create(Patient patient) { if (ModelState.IsValid) { var logged_usr_id = signInManager.UserManager.GetUserId(User); var logged_user_hospital = userManager.Users .Where(usr => usr.Id == logged_usr_id) .FirstOrDefault(); patient.Hospital = logged_user_hospital; var already_patient = patientRepository.GetPatientByCitizenId(patient.CitizenId); if (already_patient != null) { //already citizen is patient TempData["ErrorMessage"] = "You are already a Patient and already Hospitalized!"; return(RedirectToAction("Index")); } Patient newPatient = patientRepository.Add(patient); TempData["SuccessMessage"] = "Patient Hospitalized Successfully!"; } return(RedirectToAction("Index")); }
public async Task <Patient> AddPatientAsync(int hospitalId, int illnessId, int levelOfPain) { // add patient to hospital var hospital = await _hospitalRepository.GetAsync(hospitalId); if (hospital == null) { return(null); } var waiting = hospital.WaitingList.FirstOrDefault(x => x.LevelOfPain == levelOfPain); if (waiting == null) { return(null); } waiting.PatientCount += 1; await _hospitalRepository.SaveAsync(hospital); // calculate the waiting time var waitingTime = await GetHospitalsWatingTimeAsync(); waitingTime[hospitalId] = hospital.WaitingTotal; // save patient var patient = _patientRepository.Add(new Patient { Id = Guid.NewGuid(), HospitalId = hospitalId, IllnessId = illnessId, LevelOfPain = levelOfPain }); return(patient); }
public ActionResult Create(PatientEditViewModel creatingPatient) //[Bind(Include = "Id,Name,DayOfBirth,Status,TaxCode, ")] { List <Doctor> docs = new List <Doctor>(); if (creatingPatient.SelectedDoctorsId != null) { docs.AddRange(repo.GetDoctorsById(creatingPatient.SelectedDoctorsId.ToArray <int>())); } if (ModelState.IsValid) { Patient newPatient = new Patient { Doctors = docs, DayOfBirth = creatingPatient.DayOfBirth, Name = creatingPatient.Name, Status = creatingPatient.Status, TaxCode = creatingPatient.TaxCode }; repo.Add(newPatient); return(RedirectToAction("Index")); } creatingPatient.DoctorSelectList = GetDoctorsSelectList(creatingPatient.SelectedDoctorsId.ToArray <int>()); return(View(creatingPatient)); }
public async Task <PatientResponse> AddPatientAsync(AddPatientRequest request) { var patient = _patientMapper.Map(request); Patient result = _patientRepository.Add(patient); await _patientRepository.UnitOfWork.SaveChangesAsync(); // Create new records in joining table: if (request.RiskFactors != null && result != null) { foreach (GetRiskFactorRequest riskFactor in request.RiskFactors) { AddPatientRiskFactorRequest addPRFRequest = new AddPatientRiskFactorRequest { PatientId = result.Id, RiskFactorId = riskFactor.Id }; await _patientRiskFactorService.AddPatientRiskFactor(addPRFRequest); } } return(_patientMapper.Map(result)); }
public void Put(int id, [FromBody] Location location) { PatientRepository.Add(id, location); }