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)); } } }