public async Task <Result <AddHeiLabTestsDoneResponse> > Handle(AddHeiLabTestsDoneCommand request, CancellationToken cancellationToken)
{
using (_labUnitOfWork)
{
try
{
if (request.HeiLabTestTypes.Any())
{
List <HeiLabTests> heiLabTestses = new List <HeiLabTests>();
request.HeiLabTestTypes.ForEach(x => heiLabTestses.Add(new HeiLabTests
{
PatientId = request.PatientId,
HeiLabTestTypeId = x.Id,
LabOrderId = request.LabOrderId
}));
await _labUnitOfWork.Repository <HeiLabTests>().AddRangeAsync(heiLabTestses);
await _labUnitOfWork.SaveAsync();
}
return(Result <AddHeiLabTestsDoneResponse> .Valid(new AddHeiLabTestsDoneResponse()
{
Message = "Successfully added Hei Lab Test Types"
}));
}
catch (Exception e)
{
Log.Error(e, $"An error occured while trying to add Hei Lab Tests Types");
return(Result <AddHeiLabTestsDoneResponse> .Invalid($"An error occured while trying to add Hei Lab Tests Types"));
}
}
}
public async Task <Result <AddLabOrderResponse> > Handle(AddLabOrderCommand request, CancellationToken cancellationToken)
{
using (var transaction = _labUnitOfWork.BeginTransaction(IsolationLevel.ReadCommitted))
{
try
{
if (request.LabTests == null)
{
throw new ArgumentException("LabTests details not found");
}
var labOrder = _mapper.Map <LabOrder>(request);
await _labUnitOfWork.Repository <LabOrder>().AddAsync(labOrder);
await _labUnitOfWork.SaveAsync();
var labOrderTests = request.LabTests
.Select(x => new LabOrderTest(labOrder.Id, x.Id, x.Notes, request.UserId, false))
.ToList();
await _labUnitOfWork.Repository <LabOrderTest>().AddRangeAsync(labOrderTests);
await _labUnitOfWork.SaveAsync();
var patientLabTrackers = new List <PatientLabTracker>();
foreach (var labOrderTest in labOrderTests)
{
var labName = request.LabTests.FirstOrDefault(x => x.Id == labOrderTest.LabTestId)?.LabTestName;
var parameterCount = _labUnitOfWork.Repository <LabTest>().Get(x => x.Id == labOrderTest.LabTestId)
.SingleOrDefault()?.ParameterCount;
if (parameterCount == 0)
{
continue;
}
var orderReason = request.LabTests.SingleOrDefault(x => x.Id == labOrderTest.LabTestId)
?.OrderReason;
var patientLabTacker = new PatientLabTracker(request.PatientId, labName,
request.PatientMasterVisitId, labOrderTest.LabTestId,
labOrder.Id, labOrderTest.Id, request.LocationId, request.OrderDate, request.UserId,
orderReason, null);
patientLabTrackers.Add(patientLabTacker);
}
await _labUnitOfWork.Repository <PatientLabTracker>().AddRangeAsync(patientLabTrackers);
await _labUnitOfWork.SaveAsync();
transaction.Commit();
return(Result <AddLabOrderResponse> .Valid(new AddLabOrderResponse
{
LabOrderId = labOrder.Id
}));
}
catch (Exception ex)
{
string message = $"An error occured while saving lab order request for patientId {request.PatientId}";
Log.Error(ex, message);
transaction.Rollback();
return(Result <AddLabOrderResponse> .Invalid(message));
}
}
}
public async Task <Result <CompleteLabOrderResponse> > Handle(CompleteLabOrderCommand request, CancellationToken cancellationToken)
{
using (var transaction = _labUnitOfwork.BeginTransaction(IsolationLevel.ReadCommitted))
{
try
{
DateTime resultDate = request.DateResultsCollected.HasValue
? request.DateResultsCollected.Value
: DateTime.Now;
request.LabTestResults = string.IsNullOrEmpty(request.StrLabTestResults)
? request.LabTestResults
: BuildLabTestResultCommandCollection(request.StrLabTestResults);
var submittedLabOrderTest = _labUnitOfwork.Repository <LabOrderTest>()
.Get(x => x.Id == request.LabOrderTestId).FirstOrDefault();
if (submittedLabOrderTest == null)
{
return(Result <CompleteLabOrderResponse> .Invalid($"Lab order request with Id {request.LabOrderTestId} not found"));
}
if (!request.LabTestResults.Any())
{
return(Result <CompleteLabOrderResponse> .Invalid($"Submit atleast one lab result to complete the lab order"));
}
var labOrderTestResults = new List <LabOrderTestResult>();
foreach (var labTestResult in request.LabTestResults)
{
var parameterConfig = GetParamterConfigDetails(labTestResult.ParameterId);
var resultUnit = parameterConfig?.LabTestParameterConfig?.Unit;
var resultOption =
parameterConfig?.LabTestParameterResultOptions?.SingleOrDefault(x =>
x.Id == labTestResult.ResultOptionId)?.Value;
var labOrderTestResult = new LabOrderTestResult(request.LabOrderId, request.LabOrderTestId,
request.LabTestId, labTestResult.ParameterId, labTestResult.ResultValue, labTestResult.ResultText,
labTestResult.ResultOptionId, resultOption, resultUnit?.UnitName, resultUnit?.UnitId,
request.UserId, labTestResult.Undetectable, resultDate, labTestResult.DetectionLimit);
labOrderTestResults.Add(labOrderTestResult);
}
await _labUnitOfwork.Repository <LabOrderTestResult>().AddRangeAsync(labOrderTestResults);
// PatientLabTracker is updated only for LabTests with only one parameter count
var labTestParameters = _labUnitOfwork.Repository <LabTestParameter>()
.Get(x => x.LabTestId == request.LabTestId && x.DeleteFlag == false).ToList();
var totalLabTestParameterCount = labTestParameters.Count;
UpdatePatientLabTestTracker(labTestParameters[0].Id, request.LabOrderId, totalLabTestParameterCount,
request.LabOrderTestId, labOrderTestResults.FirstOrDefault());
submittedLabOrderTest.ReceiveResult(request.UserId, resultDate);
submittedLabOrderTest.MarkAsReceived();
_labUnitOfwork.Repository <LabOrderTest>().Update(submittedLabOrderTest);
await _labUnitOfwork.SaveAsync();
var labOrderTestPendingSubmission = _labUnitOfwork.Repository <LabOrderTest>()
.Get(x => x.LabOrderId == request.LabOrderId && x.ResultStatus != ResultStatusEnum.Received.ToString()).Any();
if (!labOrderTestPendingSubmission)
{
var labOrder = _labUnitOfwork.Repository <LabOrder>().Get(x => x.Id == request.LabOrderId).SingleOrDefault();
labOrder?.CompleteOrder();
_labUnitOfwork.Repository <LabOrder>().Update(labOrder);
await _labUnitOfwork.SaveAsync();
}
transaction.Commit();
return(Result <CompleteLabOrderResponse> .Valid(new CompleteLabOrderResponse { LabOrderId = request.LabOrderId }));
}
catch (Exception ex)
{
transaction.Rollback();
throw;
}
}
}
