public async Task <Result <PatientIpt> > Handle(EditHeiPatientIptCommand request, CancellationToken cancellationToken)
{
using (_unitOfWork)
{
try
{
PatientIpt patientIpt = _unitOfWork.Repository <PatientIpt>()
.Get(x => x.PatientId == request.PatientIpt.PatientId && !x.DeleteFlag).FirstOrDefault();
if (patientIpt != null)
{
patientIpt.AdheranceMeasurement = request.PatientIpt.AdheranceMeasurement;
patientIpt.AdheranceMeasurementAction = request.PatientIpt.AdheranceMeasurementAction;
patientIpt.Hepatotoxicity = request.PatientIpt.Hepatotoxicity;
patientIpt.IptDateCollected = request.PatientIpt.IptDateCollected;
patientIpt.IptDueDate = request.PatientIpt.IptDueDate;
}
_unitOfWork.Repository <PatientIpt>().Update(patientIpt);
await _unitOfWork.SaveAsync();
return(Result <PatientIpt> .Valid(request.PatientIpt));
}
catch (Exception e)
{
Log.Error(e.Message + " " + e.InnerException);
return(Result <PatientIpt> .Invalid(e.Message));
}
}
}
public async Task <Result <PatientProfile> > Handle(GetCurrentVisitDetailsCommand request, CancellationToken cancellationToken)
{
using (_unitOfWork)
{
try
{
PatientPregnancy pregnancy = _unitOfWork.Repository <PatientPregnancy>()
.Get(x => x.Outcome == null && !x.DateOfOutcome.HasValue && !x.DeleteFlag).FirstOrDefault();
PatientProfile patientProfile = new PatientProfile();
if (pregnancy != null)
{
patientProfile = await _unitOfWork.Repository <PatientProfile>()
.Get(x => x.PatientId == request.PatientId && !x.DeleteFlag && x.PregnancyId == pregnancy.Id)
.FirstOrDefaultAsync();
}
else
{
patientProfile = await _unitOfWork.Repository <PatientProfile>()
.Get(x => x.PatientId == request.PatientId && !x.DeleteFlag)
.FirstOrDefaultAsync();
}
return(Result <PatientProfile> .Valid(patientProfile));
}
catch (Exception e)
{
Log.Error(e.Message + " " + e.InnerException);
return(Result <PatientProfile> .Invalid(e.Message + " " + e.InnerException));
}
}
}
public async Task <Result <EditPatientEducationCommadResult> > Handle(EditPatientEducationCommand request, CancellationToken cancellationToken)
{
using (_unitOfWork)
{
try
{
var patientEducation = await _unitOfWork.Repository <PatientEducation>().FindByIdAsync(request.Id);
if (patientEducation == null)
{
return(Result <EditPatientEducationCommadResult> .Invalid($"Patient Education for Id: {request.Id} could not be found"));
}
patientEducation.Description = request.Description;
patientEducation.CounsellingTopicId = request.CounsellingTopicId;
_unitOfWork.Repository <PatientEducation>().Update(patientEducation);
await _unitOfWork.SaveAsync();
return(Result <EditPatientEducationCommadResult> .Valid(new EditPatientEducationCommadResult()
{
PatientEducationId = 1
}));
}
catch (Exception e)
{
Log.Error(e.Message);
return(Result <EditPatientEducationCommadResult> .Invalid(e.Message));
}
}
}
public async Task <Result <DeleteVisitDetailsCommandResponse> > Handle(DeleteVisitDetailsCommand request, CancellationToken cancellationToken)
{
using (_unitOfWork)
{
try
{
Core.Models.VisitDetails visitDetails = await _unitOfWork.Repository <Core.Models.VisitDetails>()
.Get(x => x.Id == Int32.Parse(request.Id.ToString())).FirstOrDefaultAsync();
if (visitDetails != null)
{
visitDetails.DeleteFlag = true;
}
_unitOfWork.Repository <Core.Models.VisitDetails>().Update(visitDetails);
await _unitOfWork.SaveAsync();
return(Result <DeleteVisitDetailsCommandResponse> .Valid(new DeleteVisitDetailsCommandResponse()
{
Id = request.Id
}));
}
catch (Exception e)
{
Log.Error(e.Message);
return(Result <DeleteVisitDetailsCommandResponse> .Invalid(e.Message));
}
}
}
public async Task <Result <PatientIptOutcome> > Handle(EditHeiPatientIptOutcomeCommand request, CancellationToken cancellationToken)
{
using (_unitOfWork)
{
try
{
PatientIptOutcome patientIptOutcome = _unitOfWork.Repository <PatientIptOutcome>().Get(x =>
x.PatientId == request.PatientIptOutcome.PatientId && x.Id == request.PatientIptOutcome.Id)
.FirstOrDefault();
if (patientIptOutcome != null)
{
patientIptOutcome.IptEvent = request.PatientIptOutcome.IptEvent;
patientIptOutcome.ReasonForDiscontinuation = request.PatientIptOutcome.ReasonForDiscontinuation;
_unitOfWork.Repository <PatientIptOutcome>().Update(patientIptOutcome);
await _unitOfWork.SaveAsync();
}
return(Result <PatientIptOutcome> .Valid(patientIptOutcome));
}
catch (Exception e)
{
Log.Error(e.Message + " " + e.InnerException);
return(Result <PatientIptOutcome> .Invalid(e.Message));
}
}
}
public async Task <Result <HEIEncounter> > Handle(UpdateHeiDeliveryAt24MonthsCommand request, CancellationToken cancellationToken)
{
using (_unitOfWork)
{
try
{
var encounter = await _unitOfWork.Repository <HEIEncounter>()
.Get(x => x.Id == request.HeiEncounterId).FirstOrDefaultAsync();
if (encounter != null)
{
encounter.Outcome24MonthId = request.OutcomeAt24MonthsId;
_unitOfWork.Repository <HEIEncounter>().Update(encounter);
await _unitOfWork.SaveAsync();
return(Result <HEIEncounter> .Valid(encounter));
}
else
{
return(Result <HEIEncounter> .Invalid($"Could not find hei encouter for Id: {request.HeiEncounterId}"));
}
}
catch (Exception e)
{
Log.Error(e.Message + " " + e.InnerException);
return(Result <HEIEncounter> .Invalid(e.Message));
}
}
}
public async Task <Result <HeiPatientIcf> > Handle(EditPatientIcfCommand request, CancellationToken cancellationToken)
{
using (_unitOfWork)
{
try
{
HeiPatientIcf empty = new HeiPatientIcf();
HeiPatientIcf heiPatientIcf = _unitOfWork.Repository <HeiPatientIcf>().Get(x =>
x.PatientId == request.HeiPatientIcf.PatientId && x.Id == request.HeiPatientIcf.Id &&
!x.DeleteFlag).FirstOrDefault();
if (heiPatientIcf != null)
{
heiPatientIcf.ContactWithTb = request.HeiPatientIcf.ContactWithTb;
heiPatientIcf.Cough = request.HeiPatientIcf.Cough;
heiPatientIcf.EverBeenOnIpt = request.HeiPatientIcf.EverBeenOnIpt;
heiPatientIcf.Fever = request.HeiPatientIcf.Fever;
heiPatientIcf.OnAntiTbDrugs = request.HeiPatientIcf.OnAntiTbDrugs;
heiPatientIcf.ContactWithTb = request.HeiPatientIcf.ContactWithTb;
_unitOfWork.Repository <HeiPatientIcf>().Update(heiPatientIcf);
await _unitOfWork.SaveAsync();
}
return((heiPatientIcf.Id > 0)? Result <HeiPatientIcf> .Valid(heiPatientIcf): Result <HeiPatientIcf>
.Valid(empty));
}
catch (Exception e)
{
Log.Error(e.Message + " " + e.InnerException);
return(Result <HeiPatientIcf> .Invalid(e.Message));
}
}
}
public async Task <Result <object> > Handle(UpdatePatientVitalCommand request, CancellationToken cancellationToken)
{
try
{
var patientVitalInfoToUpdate = _pmtctUnitOfWork.Repository <PatientVital>().Get(x => x.Id == request.PatientVitalInfo.Id)
.SingleOrDefault();
if (patientVitalInfoToUpdate == null)
{
return(Result <object> .Invalid($"Patient vitals information with Id {request.PatientVitalInfo.Id} not found"));
}
patientVitalInfoToUpdate.UpdateVitalsInfo(request.PatientVitalInfo);
_pmtctUnitOfWork.Repository <PatientVital>().Update(patientVitalInfoToUpdate);
await _pmtctUnitOfWork.SaveAsync();
return(Result <object> .Valid(new { Message = "Succussfully updated patient vitals information", PatientVitalId = request.PatientVitalInfo.Id }));
}
catch (Exception ex)
{
string errorMessage = $"An error occured while updating patient vital information with Id {request.PatientVitalInfo.Id}";
Log.Error(ex, errorMessage);
return(Result <object> .Invalid(errorMessage));
}
}
public async Task <Result <HEiPatientIcfAction> > Handle(EditHeiPatientIcfActionCommand request, CancellationToken cancellationToken)
{
using (_unitOfWork)
{
try
{
HEiPatientIcfAction hEiPatientIcfAction = _unitOfWork.Repository <HEiPatientIcfAction>()
.Get(x => x.PatientId == request.HEiPatientIcfAction.PatientId &&
x.Id == request.HEiPatientIcfAction.Id).FirstOrDefault();
if (hEiPatientIcfAction != null)
{
hEiPatientIcfAction.ChestXray = request.HEiPatientIcfAction.ChestXray;
hEiPatientIcfAction.EvaluatedForIpt = request.HEiPatientIcfAction.EvaluatedForIpt;
hEiPatientIcfAction.GeneXpert = request.HEiPatientIcfAction.GeneXpert;
hEiPatientIcfAction.SputumSmear = request.HEiPatientIcfAction.SputumSmear;
hEiPatientIcfAction.StartAntiTb = request.HEiPatientIcfAction.StartAntiTb;
_unitOfWork.Repository <HEiPatientIcfAction>().Update(hEiPatientIcfAction);
await _unitOfWork.SaveAsync();
}
return(Result <HEiPatientIcfAction> .Valid(hEiPatientIcfAction));
}
catch (Exception e)
{
Log.Error(e.Message + " " + e.InnerException);
return(Result <HEiPatientIcfAction> .Invalid(e.Message));
}
}
}
public async Task <Result <Core.Models.BaselineAntenatalCare> > Handle(EditBaselineAntenatalCareCommand request, CancellationToken cancellationToken)
{
using (_unitOfWork)
{
try
{
Core.Models.BaselineAntenatalCare baselineAntenatalCare = await _unitOfWork
.Repository <Core.Models.BaselineAntenatalCare>().Get(x =>
x.PatientMasterVisitId == request.PatientMasterVisitId &&
x.PatientId == request.PatientId).FirstOrDefaultAsync();
if (baselineAntenatalCare != null)
{
baselineAntenatalCare.BreastExamDone = request.BreastExamDone;
baselineAntenatalCare.TreatedForSyphilis = request.TreatedForSyphilis;
baselineAntenatalCare.HivStatusBeforeAnc = request.HivStatusBeforeAnc;
baselineAntenatalCare.PregnancyId = request.PregnancyId;
baselineAntenatalCare.TestedForSyphilis = request.TestedForSyphilis;
baselineAntenatalCare.SyphilisTestUsed = request.SyphilisTestUsed;
baselineAntenatalCare.SyphilisResults = request.SyphilisResults;
}
_unitOfWork.Repository <Core.Models.BaselineAntenatalCare>().Update(baselineAntenatalCare);
await _unitOfWork.SaveAsync();
return(Result <Core.Models.BaselineAntenatalCare> .Valid(baselineAntenatalCare));
}
catch (Exception e)
{
Log.Error(e.Message);
return(Result <Core.Models.BaselineAntenatalCare> .Invalid(e.Message));
}
}
}
public async Task <Result <EditHeiFeedingCommandResult> > Handle(EditHeiFeedingCommand request, CancellationToken cancellationToken)
{
using (_unitOfWork)
{
try
{
var heiFeeding = await _unitOfWork.Repository <HeiFeeding>().FindByIdAsync(request.heiFeeding.Id);
if (heiFeeding == null)
{
return(Result <EditHeiFeedingCommandResult> .Invalid($"Could not find heifeeding for Id: {request.heiFeeding.Id}"));
}
heiFeeding.FeedingModeId = request.heiFeeding.FeedingModeId;
_unitOfWork.Repository <HeiFeeding>().Update(heiFeeding);
await _unitOfWork.SaveAsync();
return(Result <EditHeiFeedingCommandResult> .Valid(new EditHeiFeedingCommandResult()
{
Id = heiFeeding.Id
}));
}
catch (Exception e)
{
Log.Error($"Error updating heifeeding for Id: {request.heiFeeding.Id}. {e.Message} {e.InnerException}");
return(Result <EditHeiFeedingCommandResult> .Invalid($"Error updating heifeeding for Id: {request.heiFeeding.Id}."));
}
}
}
public async Task <Result <Core.Models.VisitDetails> > Handle(EditVisitDetailsCommand request, CancellationToken cancellationToken)
{
using (_unitOfWork)
{
try
{
Core.Models.VisitDetails visitDetails = await _unitOfWork.Repository <Core.Models.VisitDetails>()
.Get(x => x.Id == request.VisitDetails.Id).FirstOrDefaultAsync();
if (visitDetails != null)
{
visitDetails.VisitNumber = request.VisitDetails.VisitNumber;
visitDetails.VisitType = request.VisitDetails.VisitType;
visitDetails.DaysPostPartum = request.VisitDetails.DaysPostPartum;
}
_unitOfWork.Repository <Core.Models.VisitDetails>().Update(visitDetails);
await _unitOfWork.SaveAsync();
return(Result <Core.Models.VisitDetails> .Valid(visitDetails));
}
catch (Exception e)
{
Log.Error(e.Message);
return(Result <Core.Models.VisitDetails> .Invalid(e.Message));
}
}
}
public async Task <Result <PatientIptWorkup> > Handle(EditHeiPatientIptWorkupCommand request, CancellationToken cancellationToken)
{
using (_unitOfWork)
{
try
{
PatientIptWorkup patientIptWorkup = _unitOfWork.Repository <PatientIptWorkup>()
.Get(x => x.PatientId == request.PatientIptWorkup.PatientId && !x.DeleteFlag).FirstOrDefault();
if (patientIptWorkup != null)
{
patientIptWorkup.AbdominalTenderness = request.PatientIptWorkup.AbdominalTenderness;
patientIptWorkup.IptRegimen = request.PatientIptWorkup.IptRegimen;
patientIptWorkup.LiverFunctionTests = request.PatientIptWorkup.LiverFunctionTests;
patientIptWorkup.Numbness = request.PatientIptWorkup.Numbness;
patientIptWorkup.IptStartDate = request.PatientIptWorkup.IptStartDate;
patientIptWorkup.StartIpt = request.PatientIptWorkup.StartIpt;
patientIptWorkup.YellowColouredUrine = request.PatientIptWorkup.YellowColouredUrine;
patientIptWorkup.YellownessOfEyes = request.PatientIptWorkup.YellownessOfEyes;
_unitOfWork.Repository <PatientIptWorkup>().Update(patientIptWorkup);
await _unitOfWork.SaveAsync();
}
return(Result <PatientIptWorkup> .Valid(patientIptWorkup));
}
catch (Exception e)
{
Log.Error(e.Message + " " + e.InnerException);
return(Result <PatientIptWorkup> .Invalid(e.Message));
}
}
}
public async Task <int> AddPatientPhysicalExamination(PhysicalExamination physicalExamination)
{
try
{
PhysicalExamination data = new PhysicalExamination()
{
PatientId = physicalExamination.PatientId,
PatientMasterVisitId = physicalExamination.PatientMasterVisitId,
ExamId = physicalExamination.ExamId,
ExaminationTypeId = physicalExamination.ExaminationTypeId,
FindingId = physicalExamination.FindingId,
FindingsNotes = physicalExamination.FindingsNotes,
CreateDate = DateTime.Now
};
await _unitOfWork.Repository <PhysicalExamination>().AddAsync(data);
await _unitOfWork.SaveAsync();
return(1);
}
catch (Exception e)
{
Log.Error(e.Message + " " + e.InnerException);
throw;
}
}
public async Task <Result <PatientChronicIllness> > Handle(EditPatientChronicIllnessCommand request, CancellationToken cancellationToken)
{
using (_unitOfWork)
{
try
{
PatientChronicIllness patientChronicIllness = _unitOfWork.Repository <PatientChronicIllness>()
.Get(x => x.Id == request.PatientChronicIllness.Id &&
x.PatientId == request.PatientChronicIllness.PatientId).FirstOrDefault();
if (patientChronicIllness != null)
{
patientChronicIllness.ChronicIllness = request.PatientChronicIllness.ChronicIllness;
patientChronicIllness.Dose = request.PatientChronicIllness.Dose;
patientChronicIllness.Duration = request.PatientChronicIllness.Duration;
patientChronicIllness.OnsetDate = request.PatientChronicIllness.OnsetDate;
patientChronicIllness.Treatment = request.PatientChronicIllness.Treatment;
}
_unitOfWork.Repository <PatientChronicIllness>().Update(patientChronicIllness);
await _unitOfWork.SaveAsync();
return(Result <PatientChronicIllness> .Valid(request.PatientChronicIllness));
}
catch (Exception e)
{
Log.Error(e.Message + " " + e.InnerException);
return(Result <PatientChronicIllness> .Invalid(e.Message));
}
}
}
public async Task <Result <VisitDetailsCommandEditResult> > Handle(VisitDetailsCommandEdit request, CancellationToken cancellationToken)
{
using (_unitOfWork)
{
Core.Models.VisitDetails visitDetailsEdit = await _unitOfWork.Repository <Core.Models.VisitDetails>()
.Get(x => x.PatientId == request.PatientId && x.Id == request.Id)
.OrderByDescending(x => x.Id).FirstOrDefaultAsync();
if (visitDetailsEdit != null)
{
visitDetailsEdit.DaysPostPartum = request.DaysPostPartum;
visitDetailsEdit.VisitNumber = request.VisitNumber;
visitDetailsEdit.VisitType = request.VisitType;
_unitOfWork.Repository <Core.Models.VisitDetails>().Update(visitDetailsEdit);
await _unitOfWork.SaveAsync();
return(Result <VisitDetailsCommandEditResult> .Valid(new VisitDetailsCommandEditResult { Id = visitDetailsEdit.Id }));
}
else
{
return(Result <VisitDetailsCommandEditResult> .Valid(new VisitDetailsCommandEditResult { Id = 0 }));
}
}
}
public async Task <Result <PatientHeiProfile> > Handle(EditProfileCommand request, CancellationToken cancellationToken)
{
using (_unitOfWork)
{
try
{
PatientHeiProfile patientHeiProfile = _unitOfWork.Repository <PatientHeiProfile>().Get(x =>
x.PatientId == request.PatientHeiProfile.PatientId && x.PatientMasterVisitId ==
request.PatientHeiProfile.PatientMasterVisitId).FirstOrDefault();
if (patientHeiProfile != null)
{
patientHeiProfile.VisitDate = request.PatientHeiProfile.VisitDate;
patientHeiProfile.VisitType = request.PatientHeiProfile.VisitType;
}
await _unitOfWork.Repository <PatientHeiProfile>().AddAsync(patientHeiProfile);
await _unitOfWork.SaveAsync();
return(Result <PatientHeiProfile> .Valid(patientHeiProfile));
}
catch (Exception e)
{
Log.Error(e.Message + " " + e.InnerException);
return(Result <PatientHeiProfile> .Invalid(e.Message));
}
}
}
public async Task <Result <EditPreventiveServiceCommandResult> > Handle(EditPatientPrevemtiveServiceCommand request, CancellationToken cancellationToken)
{
using (_pmtctUnitOfWork)
{
try
{
PreventiveService _preventiveService = await _pmtctUnitOfWork.Repository <PreventiveService>().FindAsync(x => x.PatientId == request.preventiveService.PatientId && x.Id == request.preventiveService.Id);
if (_preventiveService != null)
{
_preventiveService.PreventiveServiceId = request.preventiveService.PreventiveServiceId;
_preventiveService.PreventiveServiceDate = request.preventiveService.PreventiveServiceDate;
}
_pmtctUnitOfWork.Repository <PreventiveService>().Update(_preventiveService);
await _pmtctUnitOfWork.SaveAsync();
_pmtctUnitOfWork.Dispose();
return(Result <EditPreventiveServiceCommandResult> .Valid(new EditPreventiveServiceCommandResult()
{
PreventiveServiceId = 1
}));
}
catch (Exception e)
{
Log.Error(e.Message);
return(Result <EditPreventiveServiceCommandResult> .Invalid(e.Message));
}
}
}
public async Task <Result <EditMilestoneResponse> > Handle(EditMilestoneCommand request, CancellationToken cancellationToken)
{
using (_unitOfWork)
{
try
{
HEIMilestone milestone = _unitOfWork.Repository <HEIMilestone>().Get(x =>
x.PatientId == request.PatientMilestone.PatientId && x.PatientMasterVisitId ==
request.PatientMilestone.PatientMasterVisitId).FirstOrDefault();
if (milestone != null)
{
milestone.AchievedId = request.PatientMilestone.AchievedId;
milestone.Comment = request.PatientMilestone.Comment;
milestone.StatusId = request.PatientMilestone.StatusId;
milestone.TypeAssessedId = request.PatientMilestone.TypeAssessedId;
}
_unitOfWork.Repository <HEIMilestone>().Update(milestone);
await _unitOfWork.SaveAsync();
return(Result <EditMilestoneResponse> .Valid(new EditMilestoneResponse()
{
Message = "Milestone Edited Successfully"
}));
}
catch (Exception e)
{
Log.Error(e.Message + " " + e.InnerException);
return(Result <EditMilestoneResponse> .Invalid(e.Message));
}
}
}
public async Task <Result <EditImmunizationResponse> > Handle(EditImmunizationHistoryCommand request, CancellationToken cancellationToken)
{
using (_unitOfWork)
{
try
{
var vacc = _unitOfWork.Repository <Vaccination>().Get(x =>
x.PatientId == request.Vaccination.PatientId &&
x.PatientMasterVisitId == request.Vaccination.PatientMasterVisitId).FirstOrDefault();
if (vacc != null)
{
vacc.AppointmentId = request.Vaccination.PatientId;
vacc.PeriodId = request.Vaccination.PeriodId;
vacc.VaccineDate = request.Vaccination.VaccineDate;
vacc.VaccineStage = request.Vaccination.VaccineStage;
}
_unitOfWork.Repository <Vaccination>().Update(vacc);
await _unitOfWork.SaveAsync();
return(Result <EditImmunizationResponse> .Valid(new EditImmunizationResponse()
{
Message = "Immunization Update successfully"
}));
}
catch (Exception e)
{
Log.Error(e.Message + " " + e.InnerException);
return(Result <EditImmunizationResponse> .Invalid(e.Message));
}
}
}
public async Task <Result <PatientChronicIllness> > Handle(AddPatientChronicIllnessCommand request, CancellationToken cancellationToken)
{
using (_unitOfWork)
{
try
{
List <PatientChronicIllness> patientChronicIllness = new List <PatientChronicIllness>();
List <PatientChronicIllness> patientChronicIllnessExists = _unitOfWork
.Repository <PatientChronicIllness>().Get(x =>
x.PatientId == request.PatientChronicIllnesses[0].PatientId && !x.DeleteFlag)
.ToList();
if (request.PatientChronicIllnesses.Count > 0)
{
foreach (var item in request.PatientChronicIllnesses)
{
bool itemExist = patientChronicIllnessExists.Exists(x =>
x.PatientId == item.PatientId && x.ChronicIllness == item.ChronicIllness &&
x.OnsetDate.ToString() == item.OnsetDate.ToString());
if (!itemExist)
{
PatientChronicIllness patientChronic = new PatientChronicIllness()
{
Active = 0,
ChronicIllness = item.ChronicIllness,
CreateBy = item.CreateBy,
DeleteFlag = item.DeleteFlag,
Dose = item.Dose,
Duration = item.Duration,
OnsetDate = item.OnsetDate,
Treatment = item.Treatment,
PatientId = item.PatientId,
PatientMasterVisitId = item.PatientMasterVisitId,
};
patientChronicIllness.Add(patientChronic);
}
}
await _unitOfWork.Repository <PatientChronicIllness>().AddRangeAsync(patientChronicIllness);
await _unitOfWork.SaveAsync();
return(Result <PatientChronicIllness> .Valid(request.PatientChronicIllnesses[0]));
}
else
{
return(Result <PatientChronicIllness> .Valid(new PatientChronicIllness()));
}
}
catch (Exception e)
{
Log.Error(e.Message);
return(Result <PatientChronicIllness> .Invalid(e.Message + e.InnerException));
}
}
}
public async Task <Result <AddPatientPreventiveServiceCommandResponse> > Handle(PatientPreventiveServiceCommand request, CancellationToken cancellationToken)
{
using (_pmtctUnitOfWork)
{
try
{
List <PreventiveService> preventiveServices = new List <PreventiveService>();
List <PreventiveService> preventiveServicesExist = _pmtctUnitOfWork
.Repository <PreventiveService>().Get(x => x.PatientId == request.preventiveService[0].PatientId)
.ToList();
if (request.preventiveService.Count > 0)
{
foreach (var item in request.preventiveService)
{
bool itemExists = preventiveServicesExist.Exists(x =>
x.PreventiveServiceId == item.PreventiveServiceId && x.PatientId == item.PatientId &&
x.PreventiveServiceDate ==
item.PreventiveServiceDate);
if (!itemExists)
{
PreventiveService _preventiveServices = new PreventiveService()
{
Id = item.Id,
PatientId = item.PatientId,
PatientMasterVisitId = item.PatientMasterVisitId,
PreventiveServiceId = item.PreventiveServiceId,
PreventiveServiceDate = item.PreventiveServiceDate,
Description = item.Description
};
preventiveServices.Add(_preventiveServices);
}
}
await _pmtctUnitOfWork.Repository <PreventiveService>().AddRangeAsync(preventiveServices);
await _pmtctUnitOfWork.SaveAsync();
return(Result <AddPatientPreventiveServiceCommandResponse> .Valid(new AddPatientPreventiveServiceCommandResponse()
{
PreventiveServiceId = 1
}));
}
else
{
return(Result <AddPatientPreventiveServiceCommandResponse> .Valid(new AddPatientPreventiveServiceCommandResponse { PreventiveServiceId = 1 }));
}
}
catch (Exception e)
{
Log.Error(e.Message);
return(Result <AddPatientPreventiveServiceCommandResponse> .Invalid(e.Message));
}
}
}
public async Task <int> AddPatientChronicIllness(List <PatientChronicIllness> patientChronicIllnesses)
{
try
{
await _unitOfWork.Repository <PatientChronicIllness>().AddRangeAsync(patientChronicIllnesses);
await _unitOfWork.SaveAsync();
return(1);
}
catch (Exception e)
{
Log.Error(e.Message);
throw e;
}
}
public async Task <int> AddPatientAppointment(PatientAppointment patientAppointment)
{
try
{
await _unitOfWork.Repository <PatientAppointment>().AddAsync(patientAppointment);
await _unitOfWork.SaveAsync();
return(1);
}
catch (Exception e)
{
Log.Error(e.Message);
throw e;
}
}
public async Task <Result <HeiFeedingViewModel> > Handle(GetHeiFeedingCommand request, CancellationToken cancellationToken)
{
using (_unitOfWork)
{
try
{
HeiFeeding result = await _unitOfWork.Repository <HeiFeeding>().Get(x => x.PatientId == request.PatientId).FirstOrDefaultAsync();
HeiFeedingViewModel heiFeedingView = new HeiFeedingViewModel();;
if (result != null)
{
heiFeedingView.Id = result.Id;
heiFeedingView.PatientId = result.PatientId;
heiFeedingView.PatientMasterVisitId = result.PatientMasterVisitId;
heiFeedingView.FeedingModeId = result.FeedingModeId;
}
return(Result <HeiFeedingViewModel> .Valid(heiFeedingView));
}
catch (Exception e)
{
Log.Error(e.Message);
return(Result <HeiFeedingViewModel> .Invalid(e.Message));
}
}
}
public async Task <PatientProfile> AddPatientProfile(PatientProfile patientProfile)
{
try
{
await _unitOfWork.Repository <PatientProfile>().AddAsync(patientProfile);
await _unitOfWork.SaveAsync();
return(patientProfile);
}
catch (Exception e)
{
Log.Error(e.Message + " " + e.InnerException);
throw e;
}
}
public async Task <Result <DeleteBaselineAntenatalCareResponse> > Handle(DeleteBaselineAntenatalCareCommand request, CancellationToken cancellationToken)
{
using (_unitOfWork)
{
try
{
Core.Models.BaselineAntenatalCare baselineAntenatalCare = await _unitOfWork
.Repository <Core.Models.BaselineAntenatalCare>().Get(x => x.Id == request.Id)
.FirstOrDefaultAsync();
if (baselineAntenatalCare != null)
{
baselineAntenatalCare.DeleteFlag = true;
}
return(Result <DeleteBaselineAntenatalCareResponse> .Valid(new DeleteBaselineAntenatalCareResponse()
{
Id = request.Id
}));
}
catch (Exception e)
{
Log.Error(e.Message);
return(Result <DeleteBaselineAntenatalCareResponse> .Invalid(e.Message));
}
}
}
public async Task <Result <Core.Models.BaselineAntenatalCare> > Handle(AddBaselineAntenatalCareCommand request, CancellationToken cancellationToken)
{
using (_unitOfWork)
{
try
{
Core.Models.BaselineAntenatalCare baselineAntenatalCare = new Core.Models.BaselineAntenatalCare()
{
Id = 0,
PatientId = request.PatientId,
PatientMasterVisitId = request.PatientMasterVisitId,
BreastExamDone = request.BreastExamDone,
TreatedForSyphilis = request.TreatedForSyphilis,
CreateDate = DateTime.Now,
CreatedBy = request.CreatedBy,
DeleteFlag = false,
HivStatusBeforeAnc = request.HivStatusBeforeAnc,
TestedForSyphilis = request.TestedForSyphilis,
SyphilisTestUsed = request.SyphilisTestUsed,
SyphilisResults = request.SyphilisResults
};
await _unitOfWork.Repository <Core.Models.BaselineAntenatalCare>().AddAsync(baselineAntenatalCare);
await _unitOfWork.SaveAsync();
return(Result <Core.Models.BaselineAntenatalCare> .Valid(baselineAntenatalCare));
}
catch (Exception e)
{
Log.Error(e.Message);
return(Result <Core.Models.BaselineAntenatalCare> .Invalid(e.Message));
}
}
}
public async Task <Result <AddHeiFeedingCommandResponse> > Handle(AddHeiFeedingCommand request, CancellationToken cancellationToken)
{
using (_unitOfWork)
{
try
{
HeiFeeding heiFeeding = new HeiFeeding()
{
PatientId = request.PatientId,
PatientMasterVisitId = request.PatientMasterVisitId,
FeedingModeId = request.FeedingModeId,
CreatedBy = request.UserId,
CreateDate = DateTime.Now,
DeleteFlag = false
};
await _unitOfWork.Repository <HeiFeeding>().AddAsync(heiFeeding);
await _unitOfWork.SaveAsync();
return(Result <AddHeiFeedingCommandResponse> .Valid(new AddHeiFeedingCommandResponse()
{
HeiFeedingId = heiFeeding.Id
}));
}
catch (Exception e)
{
Log.Error(e.Message + " " + e.InnerException);
return(Result <AddHeiFeedingCommandResponse> .Invalid(e.Message));
}
}
}
public async Task <Result <PregnancyViewModel> > Handle(GetPregnancyCommand request, CancellationToken cancellationToken)
{
using (_unitOfWork)
{
try
{
PatientPregnancy result = await _unitOfWork.Repository <PatientPregnancy>().Get(x => x.PatientId == request.PatientId).OrderByDescending(x => x.Id).FirstOrDefaultAsync();
PregnancyViewModel pregnancyView = new PregnancyViewModel();;
if (result != null)
{
pregnancyView.Id = result.Id;
pregnancyView.PatientId = result.PatientId;
pregnancyView.PatientMasterVisitId = result.PatientMasterVisitId;
pregnancyView.Lmp = result.Lmp;
pregnancyView.Edd = result.Edd;
pregnancyView.Gestation = result.Gestation;
pregnancyView.Gravidae = result.Gravidae;
pregnancyView.Parity = result.Parity;
pregnancyView.Parity2 = result.Parity2;
pregnancyView.Outcome = result.Outcome;
pregnancyView.DateOfOutcome = result.DateOfOutcome;
pregnancyView.AgeAtMenarche = result.AgeAtMenarche;
}
return(Result <PregnancyViewModel> .Valid(pregnancyView));
}
catch (Exception e)
{
Log.Error(e.Message);
return(Result <PregnancyViewModel> .Invalid(e.Message));
}
}
}