public Task <Result <List <LabOrderViewModel> > > Handle(GetLabOrdersQuery request, CancellationToken cancellationToken)
{
try
{
var labOrders = string.IsNullOrEmpty(request.OrderStatus)
? _labUnitOfWork.Repository <LabOrder>().Get().Where(x => x.PatientId == request.PatientId)
.Include(l => l.LabOrderTests)
: _labUnitOfWork.Repository <LabOrder>().Get()
.Where(x => x.PatientId == request.PatientId && x.OrderStatus.Equals(request.OrderStatus, StringComparison.InvariantCultureIgnoreCase))
.Include(l => l.LabOrderTests);
var labOrderModel = labOrders.OrderByDescending(x => x.OrderDate).Select(x => new LabOrderViewModel
{
Id = x.Id,
DateCreated = x.CreateDate.ToShortDateString(),
PatientMasterVisitId = x.PatientMasterVisitId,
OrderNotes = x.ClinicalOrderNotes,
OrderNumber = x.OrderNumber,
OrderStatus = x.OrderStatus,
PatientId = x.PatientId,
LabTests = _mapper.Map <List <LabOrderTestViewModel> >(x.LabOrderTests.OrderByDescending(l => l.CreateDate))
}).ToList();
return(Task.FromResult(Result <List <LabOrderViewModel> > .Valid(labOrderModel)));
}
catch (Exception ex)
{
Log.Error(ex, "An error occured while fetching patient lab orders");
return(Task.FromResult(Result <List <LabOrderViewModel> > .Invalid(ex.Message)));
}
}
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 <IEnumerable <LabTestViewModel> > > Handle(GetLabTestsCommand request, CancellationToken cancellationToken)
{
using (_labUnitOfwork)
{
try
{
var labTests = request.LabTests == null
? await _labUnitOfwork.Repository <LabTest>().GetAllAsync()
: _labUnitOfwork.Repository <LabTest>().Get(x => request.LabTests.Contains(x.Name));
var labTestsViewModel = _mapper.Map <IEnumerable <LabTestViewModel> >(labTests);
return(Result <IEnumerable <LabTestViewModel> > .Valid(labTestsViewModel));
}
catch (Exception e)
{
Log.Error(e.Message + " " + e.InnerException);
return(Result <IEnumerable <LabTestViewModel> > .Invalid(e.Message));
}
}
}
public Task <Result <List <LabTestResultViewModel> > > Handle(GetLabTestResults request, CancellationToken cancellationToken)
{
using (_labUnitOfWork)
{
try
{
var labTestResults = !string.IsNullOrEmpty(request.LabOrderStatus)
? _labUnitOfWork.Repository <PatientLabTracker>()
.Get(x => x.PatientId == request.PatientId && x.Results == request.LabOrderStatus).ToList()
: _labUnitOfWork.Repository <PatientLabTracker>().Get(x => x.PatientId == request.PatientId)
.ToList();
var labTestModel = _mapper.Map <List <LabTestResultViewModel> >(labTestResults.OrderByDescending(x => x.CreateDate).OrderByDescending(x => x.PatientMasterVisitId));
return(Task.FromResult(Result <List <LabTestResultViewModel> > .Valid(labTestModel)));
}
catch (Exception ex)
{
Log.Error(ex, "An error occured while getting lab test results");
return(Task.FromResult(Result <List <LabTestResultViewModel> > .Invalid(ex.Message)));
}
}
}
public async Task <Result <List <PatientLabTracker> > > Handle(GetAllViralLoadsQuery request, CancellationToken cancellationToken)
{
using (_labUnitOfWork)
{
try
{
var result = await _labUnitOfWork.Repository <PatientLabTracker>().Get(x => x.LabTestId == 3).ToListAsync();
return(Result <List <PatientLabTracker> > .Valid(result));
}
catch (Exception ex)
{
Log.Error(ex, "An error occured while fetching patient viral loads");
return(Result <List <PatientLabTracker> > .Invalid(ex.Message));
}
}
}
public Task <Result <List <LabTestResultViewModel> > > Handle(GetLabOrderTestResults request, CancellationToken cancellationToken)
{
try
{
var results = _labUnitOfWork.Repository <LabOrderTestResult>().Get(x => x.LabOrderTestId == request.LabOrderTestId)
.Include(x => x.Parameter).ToList();
var resultModel = _mapper.Map <List <LabTestResultViewModel> >(results);
return(Task.FromResult(Result <List <LabTestResultViewModel> > .Valid(resultModel.Where(x => !string.IsNullOrEmpty(x.Result)).ToList())));
}
catch (Exception ex)
{
var message = $"An error occured while fetching test results for lab order test Id {request.LabOrderTestId}";
Log.Error(ex, message);
return(Task.FromResult(Result <List <LabTestResultViewModel> > .Invalid(message)));
}
}
public async Task <Result <List <HeiLabTests> > > Handle(GetPatientHeiLabTestTypesQuery request, CancellationToken cancellationToken)
{
using (_labUnitOfWork)
{
try
{
var result = await _labUnitOfWork.Repository <HeiLabTests>()
.Get(x => x.PatientId == request.PatientId).ToListAsync();
return(Result <List <HeiLabTests> > .Valid(result));
}
catch (Exception e)
{
Log.Error(e, $"An error occured while trying hei lab test types");
return(Result <List <HeiLabTests> > .Invalid($"An error occured while trying hei lab test types"));
}
}
}
public async Task <Result <List <LabTestParamaterViewModel> > > Handle(GetLabTestPametersByLabTestIdCommand request, CancellationToken cancellationToken)
{
using (_labUnitOfWork)
{
try
{
var labTestParams = await _labUnitOfWork.Repository <LabTestParameter>()
.Get(x => x.LabTestId == request.LabTestId && x.DeleteFlag == false)
.Include(x => x.LabTestParameterResultOptions)
.Include(x => x.LabTestParameterConfig.Unit)
.Distinct()
.ToListAsync();
var viewModel = labTestParams.Select(x => new LabTestParamaterViewModel
{
Id = x.Id, LabTestId = x.LabTestId, ParameterName = x.ParameterName,
UnitId = x.LabTestParameterConfig != null ? x.LabTestParameterConfig.UnitId : default(int),
DataType = x.DataType,
UnitName = x.LabTestParameterConfig != null
? x.LabTestParameterConfig.Unit.UnitName
: "No Units",
ResultOptions = x.LabTestParameterResultOptions.Any()
? x.LabTestParameterResultOptions.Select(p =>
new
{
Key = p.Id.ToString(),
Value = p.Value.ToString()
}).ToList()
: null
}).ToList();
return(Result <List <LabTestParamaterViewModel> > .Valid(viewModel));
}
catch (Exception e)
{
Log.Error(e.Message + " " + e.InnerException);
return(Result <List <LabTestParamaterViewModel> > .Invalid(e.Message));
}
}
}
public async Task <Result <IEnumerable <VLStatuses <string, int> > > > Handle(GetVlStatusCountQuery request, CancellationToken cancellationToken)
{
using (_labUnitOfWork)
{
try
{
var result = await _labUnitOfWork.Repository <PatientLabTracker>().Get(x => x.LabTestId == 3).GroupBy(x => x.Results, y => y.Id).ToListAsync();
var countResults = result.Select(group => new VLStatuses <string, int> {
Metric = group.Key,
Count = group.Count()
});
return(Result <IEnumerable <VLStatuses <string, int> > > .Valid(countResults));
}
catch (Exception ex)
{
Log.Error(ex, "An error occured while fetching viral load statuses");
return(Result <IEnumerable <VLStatuses <string, int> > > .Invalid(ex.Message));
}
}
}
public Task <Result <List <LabOrderTestViewModel> > > Handle(GetLabTestByOrderId request, CancellationToken cancellationToken)
{
try
{
var labOrder = _labUnitOfWork.Repository <LabOrder>().Get(x => x.Id == request.Id)
.Include(x => x.LabOrderTests).SingleOrDefault();
if (labOrder == null)
{
return(Task.FromResult(
Result <List <LabOrderTestViewModel> > .Invalid($"Lab order with Id {request.Id} not found")));
}
var labOrderTests = _mapper.Map <List <LabOrderTestViewModel> >(labOrder.LabOrderTests);
return(Task.FromResult(Result <List <LabOrderTestViewModel> > .Valid(labOrderTests)));
}
catch (Exception ex)
{
Log.Error(ex, $"An error occured while getting lab order tests with Id {request.Id}");
return(Task.FromResult(Result <List <LabOrderTestViewModel> > .Invalid(ex.Message)));
}
}
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;
}
}
}
