public async Task <HtsEncounter> addHtsEncounter(string encounterRemarks, int everSelfTested, int everTested, string geoLocation,
int patientEncounterId, int personId, int providerId, int testEntryPoint, int encounterType, int?testingStrategy, int?testedAs,
int?monthsSinceLastTest, int?monthSinceSelfTest)
{
try
{
// create HtsEncounter instance
var htsEncounter = new HtsEncounter
{
EncounterRemarks = encounterRemarks,
EverSelfTested = everSelfTested,
EverTested = everTested,
GeoLocation = geoLocation,
MonthSinceSelfTest = monthSinceSelfTest,
MonthsSinceLastTest = monthsSinceLastTest,
PatientEncounterID = patientEncounterId,
PersonId = personId,
ProviderId = providerId,
TestedAs = testedAs,
TestEntryPoint = testEntryPoint,
TestingStrategy = testingStrategy,
EncounterType = encounterType
};
await _htsunitOfWork.Repository <HtsEncounter>().AddAsync(htsEncounter);
await _htsunitOfWork.SaveAsync();
return(htsEncounter);
}
catch (Exception e)
{
throw e;
}
}
public async Task <Result <AddTestingResponse> > Handle(AddTestingCommand request, CancellationToken cancellationToken)
{
try
{
using (_unitOfWork)
{
HtsEncounter encounter = await _unitOfWork.Repository <HtsEncounter>().FindByIdAsync(request.HtsEncounterId);
encounter.CoupleDiscordant = request.FinalTestingResult.CoupleDiscordant;
encounter.FinalResultGiven = request.FinalTestingResult.FinalResultGiven;
_unitOfWork.Repository <HtsEncounter>().Update(encounter);
await _unitOfWork.SaveAsync();
// Create Testing instances
List <Core.Model.Testing> testings = new List <Core.Model.Testing>();
request.Testing.ForEach(t => testings.Add(new Core.Model.Testing
{
ExpiryDate = t.ExpiryDate,
HtsEncounterId = request.HtsEncounterId,
KitId = t.KitId,
KitLotNumber = t.KitLotNumber,
Outcome = t.Outcome,
ProviderId = request.ProviderId,
TestRound = t.TestRound,
CreateDate = DateTime.Now,
DeleteFlag = false
}));
await _unitOfWork.Repository <Core.Model.Testing>().AddRangeAsync(testings);
await _unitOfWork.SaveAsync();
// Create HtsEncounterResult instance
HtsEncounterResult hTSEncounterResult = new HtsEncounterResult
{
FinalResult = request.FinalTestingResult.FinalResult,
HtsEncounterId = request.HtsEncounterId,
RoundOneTestResult = request.FinalTestingResult.FinalResultHiv1,
RoundTwoTestResult = request.FinalTestingResult.FinalResultHiv2
};
await _unitOfWork.Repository <HtsEncounterResult>().AddAsync(hTSEncounterResult);
await _unitOfWork.SaveAsync();
_unitOfWork.Dispose();
return(Result <AddTestingResponse> .Valid(new AddTestingResponse()
{
AddedSuccessfully = true
}));
}
}
catch (Exception e)
{
return(Result <AddTestingResponse> .Invalid(e.Message));
}
}
public async Task <HtsEncounter> UpdateHtsEncounter(HtsEncounter htsEncounter)
{
try
{
_htsunitOfWork.Repository <HtsEncounter>().Update(htsEncounter);
await _htsunitOfWork.SaveAsync();
return(htsEncounter);
}
catch (Exception e)
{
throw e;
}
}
public async Task <HtsEncounter> updateHtsEncounter(int htsEncounterId, HtsEncounter htsEncounter)
{
try
{
var encounter = await _htsunitOfWork.Repository <HtsEncounter>().FindByIdAsync(htsEncounterId);
encounter.CoupleDiscordant = htsEncounter.CoupleDiscordant;
encounter.FinalResultGiven = htsEncounter.FinalResultGiven;
_htsunitOfWork.Repository <HtsEncounter>().Update(encounter);
await _htsunitOfWork.SaveAsync();
return(encounter);
}
catch (Exception e)
{
throw e;
}
}
public async Task <Result <AddEncounterResponse> > Handle(AddEncounterCommand request, CancellationToken cancellationToken)
{
// TODO: use automapper
using (var trans = _unitOfWork.Context.Database.BeginTransaction())
{
try
{
// create HtsEncounter instance
var htsEncounter = new HtsEncounter
{
EncounterRemarks = request.Encounter.EncounterRemarks,
EverSelfTested = request.Encounter.EverSelfTested,
EverTested = request.Encounter.EverTested,
GeoLocation = request.Encounter.GeoLocation,
MonthSinceSelfTest = request.Encounter.MonthSinceSelfTest,
MonthsSinceLastTest = request.Encounter.MonthsSinceLastTest,
PatientEncounterID = request.Encounter.PatientEncounterID,
PersonId = request.Encounter.PersonId,
ProviderId = request.Encounter.ProviderId,
TestedAs = request.Encounter.TestedAs,
TestEntryPoint = request.Encounter.TestEntryPoint,
TestingStrategy = request.Encounter.TestingStrategy,
EncounterType = request.Encounter.EncounterType,
HivCounsellingDone = request.Encounter.HivCounsellingDone,
OtherDisability = request.Encounter.OtherDisability
};
await _unitOfWork.Repository <HtsEncounter>().AddAsync(htsEncounter);
await _unitOfWork.SaveAsync();
if (request.Encounter.Disabilities.Any())
{
List <ClientDisability> clientDisabilities = new List <ClientDisability>();
request.Encounter.Disabilities.ForEach(x => clientDisabilities.Add(new ClientDisability
{
DisabilityId = x,
PatientEncounterId = request.Encounter.PatientEncounterID,
PersonId = request.Encounter.PersonId,
CreateDate = DateTime.Now,
CreatedBy = request.Encounter.ProviderId,
DeleteFlag = false
}));
await _unitOfWork.Repository <ClientDisability>().AddRangeAsync(clientDisabilities);
await _unitOfWork.SaveAsync();
}
trans.Commit();
_unitOfWork.Dispose();
return(Result <AddEncounterResponse>
.Valid(new AddEncounterResponse { HtsEncounterId = htsEncounter.Id }));
}
catch (Exception ex)
{
trans.Rollback();
Log.Error(ex.Message);
// TODO: log error
return(Result <AddEncounterResponse> .Invalid(ex.Message));
}
}
}
