public async Task <IActionResult> DeleteCondition(int id)
{
var conditionFromRepo = await _conditionRepository.GetAsync(f => f.Id == id);
if (conditionFromRepo == null)
{
return(NotFound());
}
if (ModelState.IsValid)
{
var labTestValues = _unitOfWork.Repository <ConditionLabTest>().Queryable().Where(c => c.Condition.Id == id).ToList();
labTestValues.ForEach(conditionLabTest => _conditionLabTestRepository.Delete(conditionLabTest));
var medicationValues = _unitOfWork.Repository <ConditionMedication>().Queryable().Where(c => c.Condition.Id == id).ToList();
medicationValues.ForEach(conditionMedication => _conditionMedicationRepository.Delete(conditionMedication));
var meddraValues = _unitOfWork.Repository <ConditionMedDra>().Queryable().Where(c => c.Condition.Id == id).ToList();
meddraValues.ForEach(conditionMedication => _conditionMeddraRepository.Delete(conditionMedication));
_conditionRepository.Delete(conditionFromRepo);
await _unitOfWork.CompleteAsync();
}
return(NoContent());
}
public async Task <IActionResult> DeleteEncounterType(long id)
{
var encounterTypeFromRepo = await _encounterTypeRepository.GetAsync(f => f.Id == id);
if (encounterTypeFromRepo == null)
{
return(NotFound());
}
if (encounterTypeFromRepo.Encounters.Count > 0)
{
ModelState.AddModelError("Message", "Unable to delete as item is in use.");
}
if (ModelState.IsValid)
{
ICollection <EncounterTypeWorkPlan> deleteItems = new Collection <EncounterTypeWorkPlan>();
foreach (var item in encounterTypeFromRepo.EncounterTypeWorkPlans)
{
deleteItems.Add(item);
}
foreach (var item in deleteItems)
{
_encounterTypeWorkPlanRepository.Delete(item);
}
_encounterTypeRepository.Delete(encounterTypeFromRepo);
await _unitOfWork.CompleteAsync();
return(NoContent());
}
return(BadRequest(ModelState));
}
public async Task <IActionResult> DeleteMetaPage(long id)
{
var metaPageFromRepo = await _metaPageRepository.GetAsync(f => f.Id == id);
if (metaPageFromRepo == null)
{
return(NotFound());
}
var pageInUse = _unitOfWork.Repository <MetaWidget>().Queryable()
.Any(w => w.MetaPage.Id == id);
if (pageInUse)
{
ModelState.AddModelError("Message", "Unable to delete the page as it is currently in use.");
}
if (metaPageFromRepo.IsSystem)
{
ModelState.AddModelError("Message", "Unable to delete a system page");
}
if (ModelState.IsValid)
{
_metaPageRepository.Delete(metaPageFromRepo);
await _unitOfWork.CompleteAsync();
return(NoContent());
}
return(BadRequest(ModelState));
}
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);
}
private async Task UpdateUserFacilitiesAsync(List <string> facilityNames, User userFromRepo)
{
var userFacilities = await _userFacilityRepository.ListAsync(uf => uf.User.Id == userFromRepo.Id, null, new string[] { "Facility" });
var facilitiesToBeRemoved = PrepareFacilitiesToBeRemoved(facilityNames, userFacilities);
var facilitiesToBeAdded = await PrepareFacilitiesToBeAddedAsync(facilityNames, userFromRepo, userFacilities);
facilitiesToBeRemoved.ForEach(userFacility => _userFacilityRepository.Delete(userFacility));
facilitiesToBeAdded.ForEach(userFacility => _userFacilityRepository.Save(userFacility));
}
public async Task <IActionResult> DeleteDatasetElement(long id)
{
var datasetElementFromRepo = await _datasetElementRepository.GetAsync(f => f.Id == id, new string[] {
"DatasetCategoryElements",
"DatasetElementSubs",
"Field.FieldValues"
});
if (datasetElementFromRepo == null)
{
return(NotFound());
}
if (datasetElementFromRepo.DatasetCategoryElements.Count > 0 ||
datasetElementFromRepo.DatasetElementSubs.Count > 0 ||
_unitOfWork.Repository <DatasetInstanceValue>()
.Queryable()
.Where(div => div.DatasetElement.Id == datasetElementFromRepo.Id)
.Any())
{
ModelState.AddModelError("Message", "Unable to delete as item is in use.");
return(BadRequest(ModelState));
}
if (ModelState.IsValid)
{
ICollection <FieldValue> deleteFieldValues = new Collection <FieldValue>();
foreach (var fieldValue in datasetElementFromRepo.Field.FieldValues)
{
deleteFieldValues.Add(fieldValue);
}
foreach (var fieldValue in deleteFieldValues)
{
_fieldValueRepository.Delete(fieldValue);
}
ICollection <DatasetRule> deleteDatasetRules = new Collection <DatasetRule>();
foreach (var datasetRule in datasetElementFromRepo.DatasetRules)
{
deleteDatasetRules.Add(datasetRule);
}
foreach (var datasetRule in deleteDatasetRules)
{
_datasetRuleRepository.Delete(datasetRule);
}
_datasetElementRepository.Delete(datasetElementFromRepo);
_fieldRepository.Delete(datasetElementFromRepo.Field);
await _unitOfWork.CompleteAsync();
}
return(NoContent());
}
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 <IActionResult> DeleteLabResult(long id)
{
var labResultFromRepo = await _labResultRepository.GetAsync(f => f.Id == id);
if (labResultFromRepo == null)
{
return(NotFound());
}
if (ModelState.IsValid)
{
_labResultRepository.Delete(labResultFromRepo);
await _unitOfWork.CompleteAsync();
}
return(NoContent());
}
public async Task <IActionResult> DeleteMetaWidget(long metaPageId, long id)
{
var metaWidgetFromRepo = await _metaWidgetRepository.GetAsync(f => f.MetaPage.Id == metaPageId && f.Id == id);
if (metaWidgetFromRepo == null)
{
return(NotFound());
}
if (ModelState.IsValid)
{
_metaWidgetRepository.Delete(metaWidgetFromRepo);
await _unitOfWork.CompleteAsync();
return(NoContent());
}
return(BadRequest(ModelState));
}
public async Task <ActionResult <ExchangeRefreshTokenResponseModel> > RefreshToken([FromBody] ExchangeRefreshTokenRequest request)
{
if (request == null)
{
ModelState.AddModelError("Message", "Unable to locate payload for refresh token request");
return(BadRequest(ModelState));
}
var userName = _httpContextAccessor.HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value;
var userFromManager = await _userManager.FindByNameAsync(userName);
var userFromRepo = await _userRepository.GetAsync(u => u.UserName == userName);
if (userFromManager != null && userFromRepo != null)
{
if (userFromManager.Active == false)
{
return(StatusCode(401, "User no longer active"));
}
if (userFromRepo.HasValidRefreshToken(request.RefreshToken))
{
var jwtToken = await _jwtFactory.GenerateEncodedToken(userFromRepo, await _userManager.GetRolesAsync(userFromManager));
// delete existing refresh token
_refreshTokenRepository.Delete(userFromRepo.RefreshTokens.Single(a => a.Token == request.RefreshToken));
// generate refresh token
var refreshToken = _tokenFactory.GenerateToken();
userFromRepo.AddRefreshToken(refreshToken, HttpContext?.Connection?.RemoteIpAddress?.ToString());
_userRepository.Update(userFromRepo);
await _unitOfWork.CompleteAsync();
return(new ExchangeRefreshTokenResponseModel()
{
AccessToken = jwtToken, RefreshToken = refreshToken
});
}
}
return(StatusCode(404, "User does not have valid refresh token"));
}
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(DeleteSelectionValueCommand message, CancellationToken cancellationToken)
{
var customAttributeFromRepo = await _customAttributeRepository.GetAsync(ca => ca.Id == message.CustomAttributeId, new string[] { "" });
if (customAttributeFromRepo == null)
{
throw new KeyNotFoundException("Unable to locate custom attribute");
}
var selectionDataItemFromRepo = await _selectionDataItemRepository.GetAsync(s => s.AttributeKey == customAttributeFromRepo.AttributeKey && s.SelectionKey == message.Key, new string[] { "" });
if (selectionDataItemFromRepo == null)
{
throw new KeyNotFoundException("Unable to locate selection data item");
}
_selectionDataItemRepository.Delete(selectionDataItemFromRepo);
_logger.LogInformation($"----- Selection Data Item {message.Key} deleted");
return(await _unitOfWork.CompleteAsync());
}
public async Task <bool> Handle(DeleteProductCommand message, CancellationToken cancellationToken)
{
var productFromRepo = await _productRepository.GetAsync(p => p.Id == message.ProductId, new string[] {
"ConditionMedications",
"PatientMedications"
});
if (productFromRepo == null)
{
throw new KeyNotFoundException($"Unable to locate product {message.ProductId}");
}
if (productFromRepo.ConditionMedications.Count() > 0 || productFromRepo.PatientMedications.Count() > 0)
{
throw new DomainException("Unable to delete product as it is currently in use");
}
_productRepository.Delete(productFromRepo);
_logger.LogInformation($"----- Product {message.ProductId} deleted");
return(await _unitOfWork.CompleteAsync());
}
public async Task <IActionResult> DeleteCareEvent(long id)
{
var careEventFromRepo = await _careEventRepository.GetAsync(f => f.Id == id);
if (careEventFromRepo == null)
{
return(NotFound());
}
if (careEventFromRepo.WorkPlanCareEvents.Count > 0)
{
ModelState.AddModelError("Message", "Unable to delete as item is in use.");
return(BadRequest(ModelState));
}
if (ModelState.IsValid)
{
_careEventRepository.Delete(careEventFromRepo);
await _unitOfWork.CompleteAsync();
}
return(NoContent());
}
public async Task <IActionResult> DeleteMetaReport(long id)
{
var metaReportFromRepo = await _metaReportRepository.GetAsync(f => f.Id == id);
if (metaReportFromRepo == null)
{
return(NotFound());
}
if (metaReportFromRepo.IsSystem)
{
ModelState.AddModelError("Message", "Unable to delete a system report");
}
if (ModelState.IsValid)
{
_metaReportRepository.Delete(metaReportFromRepo);
await _unitOfWork.CompleteAsync();
return(NoContent());
}
return(BadRequest(ModelState));
}
public void RemoveSelectionDataItem(long selectionDataItemId)
{
var deleteItem = _selectionDataItemRepository.Get(selectionDataItemId);
_selectionDataItemRepository.Delete(deleteItem);
}