public async Task <IActionResult> UpdateHoliday(long id, [FromBody] HolidayForUpdateDto holidayForUpdate) { if (holidayForUpdate == null) { ModelState.AddModelError("Message", "Unable to locate payload for new request"); return(BadRequest(ModelState)); } if (_unitOfWork.Repository <Holiday>().Queryable(). Where(l => l.HolidayDate == holidayForUpdate.HolidayDate && l.Id != id) .Count() > 0) { ModelState.AddModelError("Message", "A holiday has already been loaded for this date"); return(BadRequest(ModelState)); } var holidayFromRepo = await _holidayRepository.GetAsync(f => f.Id == id); if (holidayFromRepo == null) { return(NotFound()); } if (ModelState.IsValid) { holidayFromRepo.HolidayDate = holidayForUpdate.HolidayDate; holidayFromRepo.Description = holidayForUpdate.Description; _holidayRepository.Update(holidayFromRepo); await _unitOfWork.CompleteAsync(); } return(Ok()); }
public async Task AddOrUpdateMedicationsForWorkFlowInstanceAsync(Guid contextGuid, List <ReportInstanceMedicationListItem> medications) { if (medications == null) { throw new ArgumentNullException(nameof(medications)); } if (medications.Count == 0) { return; } ; var reportInstance = await _reportInstanceRepository.GetAsync(ri => ri.ContextGuid == contextGuid, new string[] { "Medications" }); if (reportInstance == null) { return; } ; foreach (ReportInstanceMedicationListItem medication in medications) { if (reportInstance.HasMedication(medication.ReportInstanceMedicationGuid)) { reportInstance.SetMedicationIdentifier(medication.ReportInstanceMedicationGuid, medication.MedicationIdentifier); } else { reportInstance.AddMedication(medication.MedicationIdentifier, medication.ReportInstanceMedicationGuid); } } _reportInstanceRepository.Update(reportInstance); await _unitOfWork.CompleteAsync(); }
public async Task <IActionResult> UpdateLabResult(long id, [FromBody] LabResultForUpdateDto labResultForUpdate) { if (labResultForUpdate == null) { ModelState.AddModelError("Message", "Unable to locate payload for new request"); return(BadRequest(ModelState)); } if (_unitOfWork.Repository <LabResult>().Queryable(). Where(l => l.Description == labResultForUpdate.LabResultName && l.Id != id) .Count() > 0) { ModelState.AddModelError("Message", "Item with same name already exists"); return(BadRequest(ModelState)); } var labResultFromRepo = await _labResultRepository.GetAsync(f => f.Id == id); if (labResultFromRepo == null) { return(NotFound()); } if (ModelState.IsValid) { labResultFromRepo.Description = labResultForUpdate.LabResultName; labResultFromRepo.Active = (labResultForUpdate.Active == Models.ValueTypes.YesNoValueType.Yes); _labResultRepository.Update(labResultFromRepo); await _unitOfWork.CompleteAsync(); } return(Ok()); }
public async Task <IActionResult> UpdatePatientDeenrolment(long patientId, long cohortGroupEnrolmentId, [FromBody] DeenrolmentForUpdateDto deenrolmentForUpdateDto) { if (deenrolmentForUpdateDto == null) { ModelState.AddModelError("Message", "De-enrolment payload not populated"); return(BadRequest(ModelState)); } var patientFromRepo = await _patientRepository.GetAsync(f => f.Id == patientId); if (patientFromRepo == null) { ModelState.AddModelError("Message", "Unable to locate patient record"); return(BadRequest(ModelState)); } var enrolmentFromRepo = await _cohortGroupEnrolmentRepository.GetAsync(f => f.Id == cohortGroupEnrolmentId); if (enrolmentFromRepo == null) { ModelState.AddModelError("Message", "Unable to locate enrolment record"); return(BadRequest(ModelState)); } var deenroledDate = deenrolmentForUpdateDto.DeenroledDate.AddDays(1).Date; if (deenroledDate > DateTime.Today) { ModelState.AddModelError("Message", "De-enrolment Date should be less than or the same date as today"); return(BadRequest(ModelState)); } if (deenroledDate < enrolmentFromRepo.EnroledDate.Date) { ModelState.AddModelError("Message", "De-enrolment Date should be after or the same date as the enrolment date"); return(BadRequest(ModelState)); } if (ModelState.IsValid) { enrolmentFromRepo.DeenroledDate = deenroledDate; _cohortGroupEnrolmentRepository.Update(enrolmentFromRepo); await _unitOfWork.CompleteAsync(); } return(CreatedAtAction("GetPatientEnrolmentByIdentifier", new { patientId, id = enrolmentFromRepo.Id }, CreateLinksForEnrolment <EnrolmentIdentifierDto>(patientId, _mapper.Map <EnrolmentIdentifierDto>(enrolmentFromRepo)))); }
public async Task <bool> Handle(RemoveFacilityFromUserCommand message, CancellationToken cancellationToken) { var userFromRepo = await _userRepository.GetAsync(u => u.Id == message.UserId, new string[] { "Facilities.Facility" }); if (userFromRepo == null) { throw new KeyNotFoundException("Unable to locate user"); } var facilityFromRepo = await _facilityRepository.GetAsync(message.FacilityId, new string[] { "" }); if (facilityFromRepo == null) { throw new KeyNotFoundException($"Unable to locate facility {message.FacilityId}"); } userFromRepo.RemoveFacility(facilityFromRepo); _userRepository.Update(userFromRepo); await _unitOfWork.CompleteAsync(); _logger.LogInformation($"----- User {userFromRepo.Id} facilities updated"); return(true); }
public async Task <PatientIdentifierDto> Handle(AddPatientCommand message, CancellationToken cancellationToken) { await CheckIfPatientIsUniqueAsync(message.Attributes); await ValidateCommandModelAsync(message.MeddraTermId, message.CohortGroupId, message.EncounterTypeId); var patientDetail = await PreparePatientDetailAsync(message); if (!patientDetail.IsValid()) { patientDetail.InvalidAttributes.ForEach(element => throw new DomainException(element)); } var id = await _patientService.AddPatientAsync(patientDetail); await _unitOfWork.CompleteAsync(); _logger.LogInformation($"----- Patient {message.LastName} created"); var mappedPatient = await GetPatientAsync <PatientIdentifierDto>(id); if (mappedPatient == null) { throw new KeyNotFoundException("Unable to locate newly added patient"); } return(CreateLinks(mappedPatient)); }
public async Task <bool> Handle(ChangeReportClassificationCommand message, CancellationToken cancellationToken) { var reportInstanceFromRepo = await _reportInstanceRepository.GetAsync(ri => ri.WorkFlow.WorkFlowGuid == message.WorkFlowGuid && ri.Id == message.ReportInstanceId, new string[] { "" }); if (reportInstanceFromRepo == null) { throw new KeyNotFoundException("Unable to locate report instance"); } if (await _workFlowService.ValidateExecutionStatusForCurrentActivityAsync(reportInstanceFromRepo.ContextGuid, "CLASSIFICATIONSET") == false) { throw new DomainException($"Activity CLASSIFICATIONSET not valid for workflow"); } reportInstanceFromRepo.ChangeClassification(message.ReportClassification); _reportInstanceRepository.Update(reportInstanceFromRepo); await _unitOfWork.CompleteAsync(); _logger.LogInformation($"----- Report {reportInstanceFromRepo.Id} classification updated"); await _workFlowService.ExecuteActivityAsync(reportInstanceFromRepo.ContextGuid, "CLASSIFICATIONSET", $"AUTOMATION: Classification set to {message.ReportClassification}", null, ""); return(true); }
public async Task <ProductIdentifierDto> Handle(AddProductCommand message, CancellationToken cancellationToken) { var conceptFromRepo = await _conceptRepository.GetAsync(c => c.ConceptName + "; " + c.Strength + " (" + c.MedicationForm.Description + ")" == message.ConceptName); if (conceptFromRepo == null) { throw new KeyNotFoundException($"Unable to locate concept {message.ConceptName}"); } if (_productRepository.Exists(p => p.ConceptId == conceptFromRepo.Id && p.ProductName == message.ProductName)) { throw new DomainException("Product with same name annd concept already exists"); } var newProduct = conceptFromRepo.AddProduct(message.ProductName, message.Manufacturer, message.Description); _conceptRepository.Update(conceptFromRepo); _logger.LogInformation($"----- Product {message.ProductName} created"); await _unitOfWork.CompleteAsync(); var mappedProduct = _mapper.Map <ProductIdentifierDto>(newProduct); CreateLinks(mappedProduct); return(mappedProduct); }
public async Task <bool> Handle(ChangeCohortGroupDetailsCommand message, CancellationToken cancellationToken) { var cohortGroupFromRepo = await _cohortGroupRepository.GetAsync(cg => cg.Id == message.Id); if (cohortGroupFromRepo == null) { throw new KeyNotFoundException("Unable to locate cohort group"); } var conditionFromRepo = await _conditionRepository.GetAsync(c => c.Description == message.ConditionName); if (conditionFromRepo == null) { throw new KeyNotFoundException("Unable to locate condition"); } if (_cohortGroupRepository.Exists(l => (l.CohortName == message.CohortName || l.CohortCode == message.CohortCode) && l.Id != message.Id)) { throw new DomainException("Item with same name already exists"); } cohortGroupFromRepo.ChangeDetails(message.CohortName, message.CohortCode, conditionFromRepo, message.StartDate, message.FinishDate); _cohortGroupRepository.Update(cohortGroupFromRepo); _logger.LogInformation($"----- Cohort group {message.CohortName} details updated"); return(await _unitOfWork.CompleteAsync()); }
public async Task <bool> Handle(DeleteUserCommand message, CancellationToken cancellationToken) { var userFromRepo = await _userRepository.GetAsync(u => u.Id == message.UserId, new string[] { "Facilities" }); if (userFromRepo == null) { throw new KeyNotFoundException("Unable to locate user"); } if (_auditLogRepository.Exists(a => a.User.Id == message.UserId)) { throw new DomainException("Unable to delete as item is in use"); } var userFacilities = await _userFacilityRepository.ListAsync(c => c.User.Id == message.UserId); userFacilities.ToList().ForEach(userFacility => _userFacilityRepository.Delete(userFacility)); _userRepository.Delete(userFromRepo); await _unitOfWork.CompleteAsync(); _logger.LogInformation($"----- User {userFromRepo.Id} deleted"); return(true); }
public async Task <IActionResult> UpdateConfig(long id, [FromBody] ConfigForUpdateDto configForUpdate) { if (configForUpdate == null) { ModelState.AddModelError("Message", "Unable to locate payload for new request"); return(BadRequest(ModelState)); } var configFromRepo = await _configRepository.GetAsync(f => f.Id == id); if (configFromRepo == null) { return(NotFound()); } if (ModelState.IsValid) { configFromRepo.ConfigValue = String.IsNullOrWhiteSpace(configForUpdate.ConfigValue) ? "-- not specified --" : configForUpdate.ConfigValue; _configRepository.Update(configFromRepo); await _unitOfWork.CompleteAsync(); } return(Ok()); }
public async Task <bool> Handle(ChangeMedicationDetailsCommand message, CancellationToken cancellationToken) { var patientFromRepo = await _patientRepository.GetAsync(f => f.Id == message.PatientId, new string[] { "PatientClinicalEvents", "PatientMedications.Concept.MedicationForm", "PatientMedications.Product" }); if (patientFromRepo == null) { throw new KeyNotFoundException("Unable to locate patient"); } var medicationToUpdate = patientFromRepo.PatientMedications.Single(pm => pm.Id == message.PatientMedicationId); var medicationAttributes = await PrepareMedicationAttributesWithNewValuesAsync(medicationToUpdate, message.Attributes); var userName = _httpContextAccessor.HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value; patientFromRepo.ChangeMedicationDetails(message.PatientMedicationId, message.StartDate, message.EndDate, message.Dose, message.DoseFrequency, message.DoseUnit); _modelExtensionBuilder.ValidateAndUpdateExtendable(medicationToUpdate, medicationAttributes, userName); _patientRepository.Update(patientFromRepo); await RefreshMedicationOnMatchingReportInstancesAsync(patientFromRepo, message.StartDate, message.EndDate, patientFromRepo.PatientMedications.Single(pm => pm.Id == message.PatientMedicationId).DisplayName, patientFromRepo.PatientMedications.Single(pm => pm.Id == message.PatientMedicationId).PatientMedicationGuid); _logger.LogInformation($"----- Medication {message.PatientMedicationId} details updated"); return(await _unitOfWork.CompleteAsync()); }
public async Task <bool> Handle(ChangeReportTerminologyCommand message, CancellationToken cancellationToken) { var reportInstanceFromRepo = await _reportInstanceRepository.GetAsync(ri => ri.WorkFlow.WorkFlowGuid == message.WorkFlowGuid && ri.Id == message.ReportInstanceId, new string[] { "" }); if (reportInstanceFromRepo == null) { throw new KeyNotFoundException("Unable to locate report instance"); } var terminologyFromRepo = _terminologyMeddraRepository.Get(message.TerminologyMedDraId); if (terminologyFromRepo == null) { throw new KeyNotFoundException("Unable to locate terminology"); } if (await _workFlowService.ValidateExecutionStatusForCurrentActivityAsync(reportInstanceFromRepo.ContextGuid, "MEDDRASET") == false) { throw new DomainException($"Activity MEDDRASET not valid for workflow"); } reportInstanceFromRepo.ChangeTerminology(terminologyFromRepo); _reportInstanceRepository.Update(reportInstanceFromRepo); await _unitOfWork.CompleteAsync(); _logger.LogInformation($"----- Report {reportInstanceFromRepo.Id} terminology updated"); await _workFlowService.ExecuteActivityAsync(reportInstanceFromRepo.ContextGuid, "MEDDRASET", $"AUTOMATION: MedDRA Term set to {terminologyFromRepo.DisplayName}", null, ""); return(true); }
public async Task <bool> Handle(ChangeProductDetailsCommand message, CancellationToken cancellationToken) { var conceptFromRepo = await _conceptRepository.GetAsync(c => c.ConceptName + "; " + c.Strength + " (" + c.MedicationForm.Description + ")" == message.ConceptName, new string[] { "Products" }); if (conceptFromRepo == null) { throw new KeyNotFoundException($"Unable to locate concept {message.ConceptName}"); } if (_productRepository.Exists(p => p.ConceptId == conceptFromRepo.Id && p.ProductName == message.ProductName && p.Id != message.ProductId)) { throw new DomainException("Product with same name annd concept already exists"); } conceptFromRepo.ChangeProductDetails(message.ProductId, message.ProductName, message.Manufacturer, message.Description); if (message.Active) { conceptFromRepo.MarkProductAsActive(message.ProductId); } else { conceptFromRepo.MarkProductAsInActive(message.ProductId); } _conceptRepository.Update(conceptFromRepo); _logger.LogInformation($"----- Product {message.ProductId} details updated"); return(await _unitOfWork.CompleteAsync()); }
public async Task <PatientClinicalEventIdentifierDto> Handle(AddClinicalEventToPatientCommand message, CancellationToken cancellationToken) { var patientFromRepo = await _patientRepository.GetAsync(f => f.Id == message.PatientId, new string[] { "PatientClinicalEvents.SourceTerminologyMedDra", "PatientMedications.Concept", "PatientFacilities.Facility" }); if (patientFromRepo == null) { throw new KeyNotFoundException("Unable to locate patient"); } TerminologyMedDra sourceTermFromRepo = null; if (message.SourceTerminologyMedDraId.HasValue) { if (message.SourceTerminologyMedDraId > 0) { sourceTermFromRepo = await _terminologyMeddraRepository.GetAsync(message.SourceTerminologyMedDraId);; if (sourceTermFromRepo == null) { throw new KeyNotFoundException("Unable to locate terminology for MedDRA"); } } } var clinicalEventDetail = await PrepareClinicalEventDetailAsync(message.Attributes); if (!clinicalEventDetail.IsValid()) { clinicalEventDetail.InvalidAttributes.ForEach(element => throw new DomainException(element)); } var newPatientClinicalEvent = patientFromRepo.AddClinicalEvent(message.OnsetDate, message.ResolutionDate, sourceTermFromRepo, message.SourceDescription); _modelExtensionBuilder.UpdateExtendable(newPatientClinicalEvent, clinicalEventDetail.CustomAttributes, "Admin"); _patientRepository.Update(patientFromRepo); // TODO Move to domain event await _workFlowService.CreateWorkFlowInstanceAsync( workFlowName : "New Active Surveilliance Report", contextGuid : newPatientClinicalEvent.PatientClinicalEventGuid, patientIdentifier : String.IsNullOrWhiteSpace(message.PatientIdentifier)?patientFromRepo.FullName : $"{patientFromRepo.FullName} ({message.PatientIdentifier})", sourceIdentifier : newPatientClinicalEvent.SourceTerminologyMedDra?.DisplayName ?? newPatientClinicalEvent.SourceDescription, facilityIdentifier : patientFromRepo.CurrentFacilityCode); await LinkMedicationsToClinicalEvent(patientFromRepo, newPatientClinicalEvent.OnsetDate, newPatientClinicalEvent.PatientClinicalEventGuid); await _unitOfWork.CompleteAsync(); _logger.LogInformation($"----- Clinical Event {message.SourceDescription} created"); var mappedPatientClinicalEvent = _mapper.Map <PatientClinicalEventIdentifierDto>(newPatientClinicalEvent); return(CreateLinks(mappedPatientClinicalEvent)); }
public async Task <IActionResult> UpdateEncounterType(long id, [FromBody] EncounterTypeForUpdateDto encounterTypeForUpdate) { if (encounterTypeForUpdate == null) { ModelState.AddModelError("Message", "Unable to locate payload for new request"); return(BadRequest(ModelState)); } if (Regex.Matches(encounterTypeForUpdate.EncounterTypeName, @"[a-zA-Z ']").Count < encounterTypeForUpdate.EncounterTypeName.Length) { ModelState.AddModelError("Message", "EncounterType name contains invalid characters (Enter A-Z, a-z, space)"); return(BadRequest(ModelState)); } if (_unitOfWork.Repository <EncounterType>().Queryable(). Where(l => l.Description == encounterTypeForUpdate.EncounterTypeName && l.Id != id) .Count() > 0) { ModelState.AddModelError("Message", "Item with same name already exists"); return(BadRequest(ModelState)); } var encounterTypeFromRepo = await _encounterTypeRepository.GetAsync(f => f.Id == id); if (encounterTypeFromRepo == null) { return(NotFound()); } if (ModelState.IsValid) { encounterTypeFromRepo.Description = encounterTypeForUpdate.EncounterTypeName; encounterTypeFromRepo.Help = encounterTypeForUpdate.Help; _encounterTypeRepository.Update(encounterTypeFromRepo); await _unitOfWork.CompleteAsync(); } return(Ok()); }
public async Task <IActionResult> UpdateCareEvent(long id, [FromBody] CareEventForUpdateDto careEventForUpdate) { if (careEventForUpdate == null) { ModelState.AddModelError("Message", "Unable to locate payload for new request"); return(BadRequest(ModelState)); } if (Regex.Matches(careEventForUpdate.CareEventName, @"[a-zA-Z ']").Count < careEventForUpdate.CareEventName.Length) { ModelState.AddModelError("Message", "Description contains invalid characters (Enter A-Z, a-z)"); return(BadRequest(ModelState)); } if (_unitOfWork.Repository <CareEvent>().Queryable(). Where(l => l.Description == careEventForUpdate.CareEventName && l.Id != id) .Count() > 0) { ModelState.AddModelError("Message", "Item with same name already exists"); return(BadRequest(ModelState)); } var careEventFromRepo = await _careEventRepository.GetAsync(f => f.Id == id); if (careEventFromRepo == null) { return(NotFound()); } if (ModelState.IsValid) { careEventFromRepo.Description = careEventForUpdate.CareEventName; _careEventRepository.Update(careEventFromRepo); await _unitOfWork.CompleteAsync(); } return(Ok()); }
public async Task <bool> Handle(DeleteCustomAttributeCommand message, CancellationToken cancellationToken) { var customAttributeFromRepo = await _customAttributeRepository.GetAsync(ca => ca.Id == message.Id, new string[] { "" }); if (customAttributeFromRepo == null) { throw new KeyNotFoundException("Unable to locate custom attribute"); } _customAttributeRepository.Delete(customAttributeFromRepo); _logger.LogInformation($"----- Custom Attribute {message.Id} deleted"); return(await _unitOfWork.CompleteAsync()); }
public async Task <bool> Handle(ChangePatientDateOfBirthCommand message, CancellationToken cancellationToken) { var patientFromRepo = await _patientRepository.GetAsync(f => f.Id == message.PatientId); if (patientFromRepo == null) { throw new KeyNotFoundException("Unable to locate patient"); } patientFromRepo.ChangePatientDateOfBirth(message.DateOfBirth); _patientRepository.Update(patientFromRepo); _logger.LogInformation($"----- Patient {message.PatientId} date of birth details updated"); return(await _unitOfWork.CompleteAsync()); }
public async Task <bool> Handle(ChangeContactDetailsCommand message, CancellationToken cancellationToken) { var siteContactDetailFromRepo = await _siteContactDetailRepository.GetAsync(s => s.Id == message.Id); if (siteContactDetailFromRepo == null) { throw new KeyNotFoundException("Unable to locate contact detail"); } siteContactDetailFromRepo.ChangeDetails(message.OrganisationType, message.OrganisationName, message.DepartmentName, message.ContactFirstName, message.ContactSurname, message.StreetAddress, message.City, message.State, message.PostCode, message.CountryCode, message.ContactNumber, message.ContactEmail); _siteContactDetailRepository.Update(siteContactDetailFromRepo); _logger.LogInformation($"----- Contact detail {message.Id} details updated"); return(await _unitOfWork.CompleteAsync()); }
public async Task <bool> Handle(ChangePatientNameCommand message, CancellationToken cancellationToken) { var patientFromRepo = await _patientRepository.GetAsync(f => f.Id == message.PatientId, new string[] { "PatientClinicalEvents.SourceTerminologyMedDra", "PatientConditions.TerminologyMedDra.ConditionMedDras.Condition" }); patientFromRepo.ChangePatientName(message.FirstName, message.MiddleName, message.LastName); _patientRepository.Update(patientFromRepo); // TODO Move to domain event await UpdateReportInstanceIdentifiers(patientFromRepo); _logger.LogInformation($"----- Patient {message.PatientId} name details updated"); return(await _unitOfWork.CompleteAsync()); }
public async Task <bool> Handle(ChangeUserFacilitiesCommand message, CancellationToken cancellationToken) { var userFromRepo = await _userRepository.GetAsync(u => u.Id == message.UserId, new string[] { "Facilities" }); if (userFromRepo == null) { throw new KeyNotFoundException("Unable to locate user"); } await UpdateUserFacilitiesAsync(message.Facilities, userFromRepo); await _unitOfWork.CompleteAsync(); _logger.LogInformation($"----- User {userFromRepo.Id} facilities updated"); return(true); }
public async Task <bool> Handle(ChangeTaskDetailsCommand message, CancellationToken cancellationToken) { var reportInstanceFromRepo = await _reportInstanceRepository.GetAsync(ri => ri.WorkFlow.WorkFlowGuid == message.WorkFlowGuid && ri.Id == message.ReportInstanceId, new string[] { "Tasks" }); if (reportInstanceFromRepo == null) { throw new KeyNotFoundException("Unable to locate report instance"); } reportInstanceFromRepo.ChangeTaskDetails(message.ReportInstanceTaskId, message.Source, message.Description); _reportInstanceRepository.Update(reportInstanceFromRepo); _logger.LogInformation($"----- Task {message.Source} details updated"); return(await _unitOfWork.CompleteAsync()); }
public async Task <bool> Handle(ChangeFacilityDetailsCommand message, CancellationToken cancellationToken) { var facilityFromRepo = await _facilityRepository.GetAsync(f => f.Id == message.Id); if (facilityFromRepo == null) { throw new KeyNotFoundException("Unable to locate facility"); } var facilityTypeFromRepo = await _facilityTypeRepository.GetAsync(c => c.Description == message.FacilityType); if (facilityTypeFromRepo == null) { throw new KeyNotFoundException("Unable to locate facility type"); } OrgUnit orgUnitFromRepo = null; if (message.OrgUnitId.HasValue) { if (message.OrgUnitId > 0) { orgUnitFromRepo = await _orgUnitRepository.GetAsync(message.OrgUnitId); if (orgUnitFromRepo == null) { throw new KeyNotFoundException($"Unable to locate organisation unit {message.OrgUnitId}"); } } } if (_facilityRepository.Exists(l => (l.FacilityName == message.FacilityName || l.FacilityCode == message.FacilityCode) && l.Id != message.Id)) { throw new DomainException("Item with same name already exists"); } facilityFromRepo.ChangeDetails(message.FacilityName, message.FacilityCode, facilityTypeFromRepo, message.TelNumber, message.MobileNumber, message.FaxNumber, orgUnitFromRepo); _facilityRepository.Update(facilityFromRepo); _logger.LogInformation($"----- Facility {message.FacilityName} details updated"); return(await _unitOfWork.CompleteAsync()); }
public async Task <bool> Handle(AcceptEulaCommand message, CancellationToken cancellationToken) { var userFromRepo = await _userRepository.GetAsync(u => u.Id == message.UserId, new string[] { "" }); if (userFromRepo == null) { throw new KeyNotFoundException("Unable to locate user"); } userFromRepo.AcceptEula(); _userRepository.Update(userFromRepo); await _unitOfWork.CompleteAsync(); _logger.LogInformation($"----- User {userFromRepo.Id} EULA accepted"); return(true); }
public async Task UpdateCustomAttributeAsync(CustomAttributeConfigDetail customAttribute) { var updateCustomAttribute = _unitOfWork.Repository <CustomAttributeConfiguration>().Queryable().Single(ca => ca.ExtendableTypeName == customAttribute.EntityName && ca.AttributeKey == customAttribute.AttributeName); updateCustomAttribute.Category = customAttribute.Category; updateCustomAttribute.AttributeDetail = customAttribute.AttributeDetail; updateCustomAttribute.IsRequired = customAttribute.Required; updateCustomAttribute.IsSearchable = customAttribute.Searchable; switch (updateCustomAttribute.CustomAttributeType) { case CustomAttributeType.Numeric: if (customAttribute.NumericMinValue.HasValue) { updateCustomAttribute.NumericMinValue = customAttribute.NumericMinValue.Value; } if (customAttribute.NumericMaxValue.HasValue) { updateCustomAttribute.NumericMaxValue = customAttribute.NumericMaxValue.Value; } break; case CustomAttributeType.String: if (customAttribute.StringMaxLength.HasValue) { updateCustomAttribute.StringMaxLength = customAttribute.StringMaxLength.Value; } break; case CustomAttributeType.DateTime: updateCustomAttribute.FutureDateOnly = customAttribute.FutureDateOnly; updateCustomAttribute.PastDateOnly = customAttribute.PastDateOnly; break; default: break; } _customAttributeConfigRepository.Update(updateCustomAttribute); await _unitOfWork.CompleteAsync(); }
public async Task <bool> Handle(DeleteFacilityCommand message, CancellationToken cancellationToken) { var facilityFromRepo = await _facilityRepository.GetAsync(f => f.Id == message.Id, new string[] { "PatientFacilities", "UserFacilities" }); if (facilityFromRepo == null) { throw new KeyNotFoundException("Unable to locate facility"); } if (facilityFromRepo.PatientFacilities.Count > 0 || facilityFromRepo.UserFacilities.Count > 0) { throw new DomainException("Unable to delete the Facility as it is currently in use"); } _facilityRepository.Delete(facilityFromRepo); _logger.LogInformation($"----- Facility {message.Id} deleted"); return(await _unitOfWork.CompleteAsync()); }
public async Task <bool> Handle(DeleteCohortGroupCommand message, CancellationToken cancellationToken) { var cohortGroupFromRepo = await _cohortGroupRepository.GetAsync(cg => cg.Id == message.Id); if (cohortGroupFromRepo == null) { throw new KeyNotFoundException("Unable to locate cohort group"); } if (_cohortGroupEnrolmentRepository.Exists(cge => cge.CohortGroup.Id == message.Id)) { throw new DomainException("Unable to delete the Cohort Group as it is currently in use"); } _cohortGroupRepository.Delete(cohortGroupFromRepo); _logger.LogInformation($"----- Cohort group {message.Id} deleted"); return(await _unitOfWork.CompleteAsync()); }
public async Task <bool> Handle(ChangeReportMedicationCausalityCommand message, CancellationToken cancellationToken) { var reportInstanceFromRepo = await _reportInstanceRepository.GetAsync(ri => ri.WorkFlow.WorkFlowGuid == message.WorkFlowGuid && ri.Id == message.ReportInstanceId, new string[] { "Medications" }); if (reportInstanceFromRepo == null) { throw new KeyNotFoundException("Unable to locate report instance"); } var reportInstanceMedicationFromRepo = reportInstanceFromRepo.Medications.SingleOrDefault(m => m.Id == message.ReportInstanceMedicationId); if (reportInstanceMedicationFromRepo == null) { throw new KeyNotFoundException("Unable to locate report instance medication"); } if (await _workFlowService.ValidateExecutionStatusForCurrentActivityAsync(reportInstanceFromRepo.ContextGuid, "CAUSALITYSET") == false) { throw new DomainException($"Activity CAUSALITYSET not valid for workflow"); } if (message.CausalityConfigType == CausalityConfigType.NaranjoScale) { reportInstanceFromRepo.ChangeMedicationNaranjoCausality(message.ReportInstanceMedicationId, message.Causality); } if (message.CausalityConfigType == CausalityConfigType.WHOScale) { reportInstanceFromRepo.ChangeMedicationWhoCausality(message.ReportInstanceMedicationId, message.Causality); } _reportInstanceRepository.Update(reportInstanceFromRepo); await _unitOfWork.CompleteAsync(); _logger.LogInformation($"----- Report {reportInstanceFromRepo.Id} classification updated"); await _workFlowService.ExecuteActivityAsync(reportInstanceFromRepo.ContextGuid, "CAUSALITYSET", $"AUTOMATION: Causality set for {reportInstanceMedicationFromRepo.MedicationIdentifier} to {message.Causality}", null, ""); return(true); }
public async Task <bool> Handle(ChangeClinicalEventDetailsCommand message, CancellationToken cancellationToken) { var patientFromRepo = await _patientRepository.GetAsync(f => f.Id == message.PatientId, new string[] { "PatientClinicalEvents.SourceTerminologyMedDra", "PatientConditions.TerminologyMedDra.ConditionMedDras.Condition" }); if (patientFromRepo == null) { throw new KeyNotFoundException("Unable to locate patient"); } TerminologyMedDra sourceTermFromRepo = null; if (message.SourceTerminologyMedDraId.HasValue) { sourceTermFromRepo = await _terminologyMeddraRepository.GetAsync(message.SourceTerminologyMedDraId);; if (sourceTermFromRepo == null) { throw new KeyNotFoundException("Unable to locate terminology for MedDRA"); } } var clinicalEventToUpdate = patientFromRepo.PatientClinicalEvents.Single(pce => pce.Id == message.PatientClinicalEventId); var clinicalEventAttributes = await PrepareClinicalEventAttributesWithNewValuesAsync(clinicalEventToUpdate, message.Attributes); var userName = _httpContextAccessor.HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value; patientFromRepo.ChangeClinicalEventDetails(message.PatientClinicalEventId, message.OnsetDate, message.ResolutionDate, sourceTermFromRepo, message.SourceDescription); _modelExtensionBuilder.ValidateAndUpdateExtendable(clinicalEventToUpdate, clinicalEventAttributes, userName); _patientRepository.Update(patientFromRepo); // TODO Move to domain event await UpdateReportInstanceIdentifiers(patientFromRepo, clinicalEventToUpdate); _logger.LogInformation($"----- Clinical Event {message.PatientClinicalEventId} details updated"); return(await _unitOfWork.CompleteAsync()); }