/// <summary>
/// Handle the updating of terminology for an existing condition
/// </summary>
/// <param name="conditionForUpdate">The payload containing the list of lab tests</param>
/// <param name="conditionFromRepo">The condition entity that is being updated</param>
/// <returns></returns>
private void AddOrUpdateConditionMeddras(ConditionForUpdateDto conditionForUpdate, Condition conditionFromRepo)
{
// Determine what has been removed
ArrayList deleteCollection = new ArrayList();
foreach (var conditionMeddra in conditionFromRepo.ConditionMedDras)
{
if (!conditionForUpdate.ConditionMedDras.Contains(conditionMeddra.TerminologyMedDra.Id))
{
deleteCollection.Add(conditionMeddra);
}
}
// Process deletes
foreach (var conditionMeddra in deleteCollection)
{
_conditionMeddraRepository.Delete(conditionMeddra);
}
// Determine what needs to be added
foreach (var meddraId in conditionForUpdate.ConditionMedDras)
{
if (!conditionFromRepo.ConditionMedDras.Any(c => c.TerminologyMedDra.Id == meddraId))
{
var newConditionMedra = new ConditionMedDra()
{
Condition = conditionFromRepo, TerminologyMedDra = _terminologyMeddraRepository.Get(f => f.Id == meddraId)
};
_conditionMeddraRepository.Save(newConditionMedra);
}
}
}
/// <summary>
/// Handle the updating of medications for an existing condition
/// </summary>
/// <param name="conditionForUpdate">The payload containing the list of lab tests</param>
/// <param name="conditionFromRepo">The condition entity that is being updated</param>
/// <returns></returns>
private void AddOrUpdateConditionMedications(ConditionForUpdateDto conditionForUpdate, Condition conditionFromRepo)
{
// Determine what has been removed
ArrayList deleteCollection = new ArrayList();
foreach (var conditionMedication in conditionFromRepo.ConditionMedications)
{
if (!conditionForUpdate.ConditionMedications.Contains(conditionMedication.Product.Id))
{
deleteCollection.Add(conditionMedication);
}
}
// Process deletes
foreach (var conditionMedication in deleteCollection)
{
_conditionMedicationRepository.Delete(conditionMedication);
}
// Determine what needs to be added
foreach (var productId in conditionForUpdate.ConditionMedications)
{
if (!conditionFromRepo.ConditionMedications.Any(c => c.Product.Id == productId))
{
var product = _productRepository.Get(f => f.Id == productId);
var newConditionMedication = new ConditionMedication()
{
Condition = conditionFromRepo, Product = product, Concept = product.Concept
};
_conditionMedicationRepository.Save(newConditionMedication);
}
}
}
/// <summary>
/// Handle the updating of lab tests for an existing condition
/// </summary>
/// <param name="conditionForUpdate">The payload containing the list of lab tests</param>
/// <param name="conditionFromRepo">The condition entity that is being updated</param>
/// <returns></returns>
private void AddOrUpdateConditionLabTests(ConditionForUpdateDto conditionForUpdate, Condition conditionFromRepo)
{
// Determine what has been removed
ArrayList deleteCollection = new ArrayList();
foreach (var conditionLabTest in conditionFromRepo.ConditionLabTests)
{
if (!conditionForUpdate.ConditionLabTests.Contains(conditionLabTest.LabTest.Id))
{
deleteCollection.Add(conditionLabTest);
}
}
// Process deletes
foreach (var conditionLabTest in deleteCollection)
{
_conditionLabTestRepository.Delete(conditionLabTest);
}
// Determine what needs to be added
foreach (var labTestId in conditionForUpdate.ConditionLabTests)
{
if (!conditionFromRepo.ConditionLabTests.Any(c => c.LabTest.Id == labTestId))
{
var newConditionLabTest = new ConditionLabTest()
{
Condition = conditionFromRepo, LabTest = _labTestRepository.Get(f => f.Id == labTestId)
};
_conditionLabTestRepository.Save(newConditionLabTest);
}
}
}
public async Task <IActionResult> UpdateCondition(int id,
[FromBody] ConditionForUpdateDto conditionForUpdate)
{
if (conditionForUpdate == null)
{
ModelState.AddModelError("Message", "Unable to locate payload for new request");
}
if (Regex.Matches(conditionForUpdate.ConditionName, @"[a-zA-Z0-9 ]").Count < conditionForUpdate.ConditionName.Length)
{
ModelState.AddModelError("Message", "Condition contains invalid characters (Enter A-Z, a-z, 0-9, space)");
return(BadRequest(ModelState));
}
if (conditionForUpdate.ConditionMedDras.Count == 0)
{
ModelState.AddModelError("Message", "Condition must contain at least one MedDra term");
return(BadRequest(ModelState));
}
if (_unitOfWork.Repository <Condition>().Queryable().
Where(l => l.Description == conditionForUpdate.ConditionName && l.Id != id)
.Count() > 0)
{
ModelState.AddModelError("Message", "Item with same name already exists");
}
var conditionFromRepo = await _conditionRepository.GetAsync(f => f.Id == id);
if (conditionFromRepo == null)
{
return(NotFound());
}
if (ModelState.IsValid)
{
conditionFromRepo.Description = conditionForUpdate.ConditionName;
conditionFromRepo.Chronic = (conditionForUpdate.Chronic == Models.ValueTypes.YesNoValueType.Yes);
conditionFromRepo.Active = (conditionForUpdate.Active == Models.ValueTypes.YesNoValueType.Yes);
_conditionRepository.Update(conditionFromRepo);
AddOrUpdateConditionLabTests(conditionForUpdate, conditionFromRepo);
AddOrUpdateConditionMeddras(conditionForUpdate, conditionFromRepo);
AddOrUpdateConditionMedications(conditionForUpdate, conditionFromRepo);
await _unitOfWork.CompleteAsync();
return(Ok());
}
return(BadRequest(ModelState));
}
public async Task <IActionResult> CreateCondition(
[FromBody] ConditionForUpdateDto conditionForUpdate)
{
if (conditionForUpdate == null)
{
ModelState.AddModelError("Message", "Unable to locate payload for new request");
}
if (Regex.Matches(conditionForUpdate.ConditionName, @"[a-zA-Z0-9 ]").Count < conditionForUpdate.ConditionName.Length)
{
ModelState.AddModelError("Message", "Condition contains invalid characters (Enter A-Z, a-z, 0-9, space)");
return(BadRequest(ModelState));
}
if (conditionForUpdate.ConditionMedDras.Count == 0)
{
ModelState.AddModelError("Message", "Condition must contain at least one MedDra term");
return(BadRequest(ModelState));
}
if (_unitOfWork.Repository <Condition>().Queryable().
Where(l => l.Description == conditionForUpdate.ConditionName)
.Count() > 0)
{
ModelState.AddModelError("Message", "Item with same name already exists");
}
if (ModelState.IsValid)
{
var newCondition = new Condition()
{
Description = conditionForUpdate.ConditionName,
Chronic = (conditionForUpdate.Chronic == Models.ValueTypes.YesNoValueType.Yes),
Active = (conditionForUpdate.Active == Models.ValueTypes.YesNoValueType.Yes)
};
// ensure lab tests are linked to condition
foreach (var labTestId in conditionForUpdate.ConditionLabTests)
{
newCondition.ConditionLabTests.Add(new ConditionLabTest()
{
LabTest = _labTestRepository.Get(f => f.Id == labTestId)
});
}
// ensure products are linked to condition
foreach (var productId in conditionForUpdate.ConditionMedications)
{
var concept = _conceptRepository.Get(c => c.Id == productId, new string[] { "" });
newCondition.ConditionMedications.Add(new ConditionMedication()
{
Product = null, Concept = concept
});
}
// ensure meddra terms are linked to condition
foreach (var terminologyMeddraId in conditionForUpdate.ConditionMedDras)
{
newCondition.ConditionMedDras.Add(new ConditionMedDra()
{
TerminologyMedDra = _terminologyMeddraRepository.Get(f => f.Id == terminologyMeddraId)
});
}
_conditionRepository.Save(newCondition);
await _unitOfWork.CompleteAsync();
var mappedCondition = await GetConditionAsync <ConditionIdentifierDto>(newCondition.Id);
if (mappedCondition == null)
{
return(StatusCode(500, "Unable to locate newly added item"));
}
return(CreatedAtAction("GetConditionByIdentifier",
new
{
id = mappedCondition.Id
}, CreateLinksForCondition <ConditionIdentifierDto>(mappedCondition)));
}
return(BadRequest(ModelState));
}
