/// <summary>
/// Processes the single aggregate.
/// </summary>
/// <param name="dto">The dto to process.</param>
/// <param name="entity">The entity.</param>
/// <returns>A <see cref="System.Boolean"/></returns>
protected override bool ProcessSingleAggregate(MedicationDto dto, Medication entity)
{
CodedConcept medicationCode = null;
if (dto.MedicationCodeCodedConcept != null)
{
medicationCode = new CodedConceptBuilder().WithCodedConceptDto(dto.MedicationCodeCodedConcept);
}
CodedConcept rootMedicationCode = null;
if (dto.RootMedicationCodedConcept != null)
{
rootMedicationCode = new CodedConceptBuilder().WithCodedConceptDto(dto.RootMedicationCodedConcept);
}
var discontinuedReason = _mappingHelper.MapLookupField <DiscontinuedReason> (dto.DiscontinuedReason);
var medicationStatus = _mappingHelper.MapLookupField <MedicationStatus> (dto.MedicationStatus);
entity.ReviseOverTheCounterIndicator(dto.OverTheCounterIndicator);
entity.RevisePrescribingPhysicianName(dto.PrescribingPhysicianName);
entity.ReviseUsageDateRange(new DateRange(dto.StartDate, dto.EndDate));
entity.ReviseDiscontinuedByPhysicianName(dto.DiscontinuedByPhysicianName);
entity.ReviseDiscontinuedReason(discontinuedReason);
entity.ReviseDiscontinuedReasonOtherDescription(dto.DiscontinuedReasonOtherDescription);
entity.ReviseFrequencyDescription(dto.FrequencyDescription);
entity.ReviseInstructionsNote(dto.InstructionsNote);
entity.ReviseMedicationStatus(medicationStatus);
entity.ReviseMedicationCodeCodedConcept(medicationCode);
entity.ReviseRootMedicationCodedConcept(rootMedicationCode);
return(true);
}
private void CreateMedication(MedicationDto dto, Patient patient, Provenance provenance)
{
CodedConcept medicationCode = null;
if (dto.MedicationCodeCodedConcept != null)
{
medicationCode = new CodedConceptBuilder().WithCodedConceptDto(dto.MedicationCodeCodedConcept);
}
var medication = patient.AddMedication(medicationCode, provenance);
CodedConcept rootMedicationCode = null;
if (dto.RootMedicationCodedConcept != null)
{
rootMedicationCode = new CodedConceptBuilder().WithCodedConceptDto(dto.RootMedicationCodedConcept);
}
var discontinuedReason = _mappingHelper.MapLookupField <DiscontinuedReason> (dto.DiscontinuedReason);
var medicationStatus = dto.MedicationStatus == null
? _mappingHelper.MapLookupField <MedicationStatus> (WellKnownNames.PatientModule.MedicationStatus.Inactive)
: _mappingHelper.MapLookupField <MedicationStatus> (dto.MedicationStatus);
medication.ReviseOverTheCounterIndicator(dto.OverTheCounterIndicator);
medication.RevisePrescribingPhysicianName(dto.PrescribingPhysicianName);
medication.ReviseUsageDateRange(new DateRange(dto.StartDate, dto.EndDate));
medication.ReviseDiscontinuedByPhysicianName(dto.DiscontinuedByPhysicianName);
medication.ReviseDiscontinuedReason(discontinuedReason);
medication.ReviseDiscontinuedReasonOtherDescription(dto.DiscontinuedReasonOtherDescription);
medication.ReviseFrequencyDescription(dto.FrequencyDescription);
medication.ReviseInstructionsNote(dto.InstructionsNote);
medication.ReviseMedicationStatus(medicationStatus);
medication.ReviseRootMedicationCodedConcept(rootMedicationCode);
}
private bool MapProperties(CdsRule cdsRule, CdsRuleDto cdsRuleDto)
{
CodedConcept medicationCodedConcept = null;
if (cdsRuleDto.MedicationCodedConcept != null)
{
medicationCodedConcept = new CodedConceptBuilder().WithCodedConceptDto(cdsRuleDto.MedicationCodedConcept);
}
CodedConcept problemCodedConcept = null;
if (cdsRuleDto.ProblemCodedConcept != null)
{
problemCodedConcept = new CodedConceptBuilder().WithCodedConceptDto(cdsRuleDto.ProblemCodedConcept.ProblemCodeCodedConcept);
}
var labTestName = _dtoToDomainMappingHelper.MapLookupField <LabTestName> (cdsRuleDto.LabTestName);
cdsRule.Rename(cdsRuleDto.Name);
cdsRule.ReviseRecommendationNote(cdsRuleDto.RecommendationNote);
cdsRule.ReviseMedicationCodedConcept(medicationCodedConcept);
cdsRule.ReviseProblemCodedConcept(problemCodedConcept);
cdsRule.ReviseLabTestName(labTestName);
cdsRule.ReviseAge(cdsRuleDto.Age);
cdsRule.ReviseValidLabOrderMonthCount(cdsRuleDto.ValidLabOrderMonthCount);
return(true);
}
private bool MapAllergyProperties(AllergyDto allergyDto, Allergy allergy)
{
var allergySeverityType = _mappingHelper.MapLookupField <AllergySeverityType> (allergyDto.AllergySeverityType);
var allergyType = _mappingHelper.MapLookupField <AllergyType> (allergyDto.AllergyType);
var allergyStatus = _mappingHelper.MapLookupField <AllergyStatus> (allergyDto.AllergyStatus);
CodedConcept allergen = null;
if (allergyDto.AllergenCodedConcept != null)
{
allergen = new CodedConceptBuilder().WithCodedConceptDto(allergyDto.AllergenCodedConcept);
}
allergy.ReviseAllergySeverityType(allergySeverityType);
allergy.ReviseAllergyType(allergyType);
allergy.ReviseOnsetDateRange(new DateRange(allergyDto.OnsetStartDate, allergyDto.OnsetEndDate));
allergy.ReviseAllergyStatus(allergyStatus);
allergy.ReviseCodedConcept(allergen);
// Map reactions
var deletedReactions = allergy.AllergyReactions.Where(
a => !allergyDto.AllergyReactions.Any(ad => ad.Key == a.Reaction.Key)).ToList();
deletedReactions.ForEach(allergy.DeleteReaction);
var addedReactions = allergyDto.AllergyReactions.Where(
a => !allergy.AllergyReactions.Any(ad => ad.Reaction.Key == a.Key)).ToList();
addedReactions.ForEach(r => allergy.AddReaction(_mappingHelper.MapLookupField <Reaction> (r)));
return(true);
}
private void CreateImmunization(ImmunizationDto dto, long patientKey, Provenance provenance)
{
var clinicalCase = _clinicalCaseRepository.GetActiveClinicalCaseByPatient(patientKey);
var immunization = _immunizationFactory.CreateImmunization(
clinicalCase, provenance, new DateTimeRange(dto.ActivityStartDateTime, dto.ActivityStartDateTime));
CodedConcept vaccineCodedConcept = null;
if (dto.VaccineCodedConcept != null)
{
vaccineCodedConcept = new CodedConceptBuilder().WithCodedConceptDto(dto.VaccineCodedConcept);
}
var unitOfMeasure = _mappingHelper.MapLookupField <ImmunizationUnitOfMeasure> (dto.ImmunizationUnitOfMeasure);
var notGivenReason = _mappingHelper.MapLookupField <ImmunizationNotGivenReason> (dto.ImmunizationNotGivenReason);
immunization.ReviseImmunizationVaccineInfo(
new ImmunizationVaccineInfo(
vaccineCodedConcept,
dto.VaccineLotNumber,
new ImmunizationVaccineManufacturer(dto.VaccineManufacturerCode, dto.VaccineManufacturerName)));
immunization.ReviseImmunizationAdministration(new ImmunizationAdministration(dto.AdministeredAmount, unitOfMeasure));
immunization.ReviseImmunizationNotGivenReason(notGivenReason);
}
private void CreateProblem(ProblemDto dto, long patientKey, Provenance provenance)
{
var clinicalCase = _clinicalCaseRepository.GetActiveClinicalCaseByPatient(patientKey);
CodedConcept problemCode = null;
if (dto.ProblemCodeCodedConcept != null)
{
problemCode = new CodedConceptBuilder().WithCodedConceptDto(dto.ProblemCodeCodedConcept);
}
var problem = _problemFactory.CreateProblem(clinicalCase, problemCode, provenance);
var problemType = _mappingHelper.MapLookupField <ProblemType> (dto.ProblemType);
var problemStatus = _mappingHelper.MapLookupField <ProblemStatus> (dto.ProblemStatus);
problem.ReviseProblemType(problemType);
problem.ReviseOnsetDateRange(new DateRange(dto.OnsetStartDate, dto.OnsetEndDate));
problem.UpdateProblemStatus(problemStatus, dto.StatusChangedDate);
problem.ReviseCauseOfDeathIndicator(dto.CauseOfDeathIndicator);
if (dto.ObservedByStaff != null)
{
var staff = Session.Load <Staff> (dto.ObservedByStaff.Key);
problem.ReviseObservationInfo(staff, dto.ObservedDate);
}
}
private void CreateAllergy(AllergyDto dto, Patient patient, Provenance provenance)
{
var allergyStatus = _mappingHelper.MapLookupField <AllergyStatus> (dto.AllergyStatus);
CodedConcept allergenCodedConcept = null;
if (dto.AllergenCodedConcept != null)
{
allergenCodedConcept = new CodedConceptBuilder().WithCodedConceptDto(dto.AllergenCodedConcept);
}
var allergy = patient.AddAllergy(allergyStatus, allergenCodedConcept, provenance);
var allergySeverityType = _mappingHelper.MapLookupField <AllergySeverityType> (dto.AllergySeverityType);
var allergyType = _mappingHelper.MapLookupField <AllergyType> (dto.AllergyType);
allergy.ReviseAllergySeverityType(allergySeverityType);
allergy.ReviseAllergyType(allergyType);
allergy.ReviseOnsetDateRange(new DateRange(dto.OnsetStartDate, dto.OnsetEndDate));
// Map reactions
var deletedReactions = allergy.AllergyReactions.Where(
a => dto.AllergyReactions.All(ad => ad.Key != a.Reaction.Key)).ToList();
deletedReactions.ForEach(allergy.DeleteReaction);
var addedReactions = dto.AllergyReactions.Where(
a => allergy.AllergyReactions.All(ad => ad.Reaction.Key != a.Key)).ToList();
addedReactions.ForEach(r => allergy.AddReaction(_mappingHelper.MapLookupField <Reaction> (r)));
}
private CodedConcept BuildCodedConcept(string codedConceptCode, string displayName = null)
{
var codedConcept = new CodedConceptBuilder()
.WithCodedConceptCode(codedConceptCode)
.WithDisplayName(displayName);
return(codedConcept);
}
/// <summary>
/// Withes the coded concept dto.
/// </summary>
/// <param name="codedConceptBuilder">The coded concept builder.</param>
/// <param name="codedConceptDto">The coded concept dto.</param>
/// <returns>A <see cref="Rem.Domain.Core.CommonModule.CodedConceptBuilder"/></returns>
public static CodedConceptBuilder WithCodedConceptDto(this CodedConceptBuilder codedConceptBuilder, CodedConceptDto codedConceptDto)
{
codedConceptBuilder.WithCodedConceptCode(codedConceptDto.CodedConceptCode)
.WithCodeSystemIdentifier(codedConceptDto.CodeSystemIdentifier)
.WithCodeSystemName(codedConceptDto.CodeSystemName)
.WithCodeSystemVersionNumber(codedConceptDto.CodeSystemVersionNumber)
.WithDisplayName(codedConceptDto.DisplayName)
.WithNullFlavorIndicator(codedConceptDto.NullFlavorIndicator)
.WithOriginalDescription(codedConceptDto.OriginalDescription);
return(codedConceptBuilder);
}
public void CreateMedication_GivenValidArguments_Succeeds()
{
var mediationRepository = new Mock <IMedicationRepository> ();
var medicationFactory = new MedicationFactory(
mediationRepository.Object);
var patient = new Mock <Patient> ();
var medicationCode = new CodedConceptBuilder().WithCodedConceptCode("TheCode");
var medication = medicationFactory.CreateMedication(patient.Object, medicationCode, medicationCode);
Assert.IsNotNull(medication);
}
private Allergy CreateAllergyByAllergyFactory()
{
var allergyRepository = new Mock <IAllergyRepository> ();
var allergyFactory = new AllergyFactory(
allergyRepository.Object);
var patient = new Mock <Patient> ();
var allergyStatus = new Mock <AllergyStatus> ();
var allergen = new CodedConceptBuilder().WithCodedConceptCode("TheCode");
var allergy = allergyFactory.CreateAllergy(patient.Object, allergyStatus.Object, allergen);
return(allergy);
}
/// <summary>
/// Creates the new.
/// </summary>
/// <param name="dto">The data transfer object.</param>
/// <returns>A <see cref="Rem.Domain.Clinical.ClinicalCaseModule.Problem"/></returns>
protected override Problem CreateNew(ProblemDto dto)
{
var clinicalCase = Session.Load <ClinicalCase> (dto.ClinicalCaseKey);
CodedConcept problemCode = null;
if (dto.ProblemCodeCodedConcept != null)
{
problemCode = new CodedConceptBuilder().WithCodedConceptDto(dto.ProblemCodeCodedConcept);
}
var entity = _problemFactory.CreateProblem(clinicalCase, problemCode);
return(entity);
}
public void CreateMedication_GivenValidArguments_MedicationIsEditable()
{
using (var serviceLocatorFixture = new ServiceLocatorFixture())
{
// Setup
var mediationRepository = new Mock <IMedicationRepository>();
var medicationFactory = new MedicationFactory(
mediationRepository.Object);
var patient = new Mock <Patient>();
var medicationCode = new CodedConceptBuilder().WithCodedConceptCode("TheCode");
var medication = medicationFactory.CreateMedication(patient.Object, medicationCode, medicationCode);
medication.ReviseInstructionsNote("some instruction");
}
}
private void AddAllergy(AllergyDto allergyDto)
{
var patient = Session.Get <Patient> (_patientKey);
var allergyStatus = _mappingHelper.MapLookupField <AllergyStatus> (allergyDto.AllergyStatus);
CodedConcept allergen = null;
if (allergyDto.AllergenCodedConcept != null)
{
allergen = new CodedConceptBuilder().WithCodedConceptDto(allergyDto.AllergenCodedConcept);
}
var allergy = _allergyFactory.CreateAllergy(patient, allergyStatus, allergen);
var mapResult = MapAllergyProperties(allergyDto, allergy);
_mappingResult &= mapResult;
}
public void CreateMedication_GivenValidArguments_MedicationMadePersistent()
{
var isPersistent = false;
var mediationRepository = new Mock <IMedicationRepository> ();
mediationRepository
.Setup(m => m.MakePersistent(It.IsAny <Medication> ()))
.Callback(() => isPersistent = true);
var medicationFactory = new MedicationFactory(
mediationRepository.Object);
var patient = new Mock <Patient> ();
var medicationCode = new CodedConceptBuilder().WithCodedConceptCode("TheCode");
medicationFactory.CreateMedication(patient.Object, medicationCode, medicationCode);
Assert.IsTrue(isPersistent);
}
/// <summary>
/// Creates the new.
/// </summary>
/// <param name="dto">The data transfer object.</param>
/// <returns>A <see cref="Rem.Domain.Clinical.PatientModule.Medication"/></returns>
protected override Medication CreateNew(MedicationDto dto)
{
CodedConcept medicationCode = null;
if (dto.MedicationCodeCodedConcept != null)
{
medicationCode = new CodedConceptBuilder().WithCodedConceptDto(dto.MedicationCodeCodedConcept);
}
CodedConcept rootMedicationCode = null;
if (dto.RootMedicationCodedConcept != null)
{
rootMedicationCode = new CodedConceptBuilder().WithCodedConceptDto(dto.RootMedicationCodedConcept);
}
var patient = _patientRepository.GetByKey(dto.PatientKey);
var entity = patient.AddMedication(medicationCode, rootMedicationCode);
return(entity);
}
private bool MapProperties(ProblemDto dto, Problem entity)
{
CodedConcept problemCode = null;
if (dto.ProblemCodeCodedConcept != null)
{
problemCode = new CodedConceptBuilder().WithCodedConceptDto(dto.ProblemCodeCodedConcept);
}
entity.ReviseProblemCode(problemCode);
var problemType = _mappingHelper.MapLookupField <ProblemType> (dto.ProblemType);
var problemStatus = _mappingHelper.MapLookupField <ProblemStatus> (dto.ProblemStatus);
var staff = Session.Load <Staff> (dto.ObservedByStaff.Key);
entity.ReviseProblemType(problemType);
entity.ReviseOnsetDateRange(new DateRange(dto.OnsetStartDate, dto.OnsetEndDate));
entity.UpdateProblemStatus(problemStatus, dto.StatusChangedDate);
entity.ReviseObservationInfo(staff, dto.ObservedDate);
entity.ReviseCauseOfDeathIndicator(dto.CauseOfDeathIndicator);
return(true);
}
/// <summary>
/// Processes the specified immunization dto.
/// </summary>
/// <param name="immunizationDto">The immunization dto.</param>
/// <returns>A <see cref="System.Boolean"/></returns>
protected override bool Process(ImmunizationDto immunizationDto)
{
var immunization = Session.Get <Immunization> (immunizationDto.Key);
CodedConcept vaccineCodedConcept = null;
if (immunizationDto.VaccineCodedConcept != null)
{
vaccineCodedConcept = new CodedConceptBuilder().WithCodedConceptDto(immunizationDto.VaccineCodedConcept);
}
var unitOfMeasure = _mappingHelper.MapLookupField <ImmunizationUnitOfMeasure> (immunizationDto.ImmunizationUnitOfMeasure);
var notGivenReason = _mappingHelper.MapLookupField <ImmunizationNotGivenReason> (immunizationDto.ImmunizationNotGivenReason);
immunization.ReviseImmunizationVaccineInfo(
new ImmunizationVaccineInfo(
vaccineCodedConcept,
immunizationDto.VaccineLotNumber,
new ImmunizationVaccineManufacturer(immunizationDto.VaccineManufacturerCode, immunizationDto.VaccineManufacturerName)));
immunization.ReviseImmunizationAdministration(new ImmunizationAdministration(immunizationDto.AdministeredAmount, unitOfMeasure));
immunization.ReviseImmunizationNotGivenReason(notGivenReason);
return(true);
}
/// <summary>
/// Handles the specified request.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>A <see cref="Agatha.Common.Response"/></returns>
public override Response Handle(SaveLabResultRequest request)
{
var response = CreateTypedResponse();
response.ErrorMessages = new List <string> ();
var parser = new PipeParser();
var encoding = new UTF8Encoding();
var decodedMessage = encoding.GetString(request.HL7Message);
var hl7Message = parser.Parse(decodedMessage);
if (hl7Message.Version != "2.5.1")
{
response.ErrorMessages.Add("Lab Result is using the version other than 2.5.1");
return(response);
}
var message = ( ORU_R01 )hl7Message;
var patientResult = message.GetPATIENT_RESULT();
var pidSegment = patientResult.PATIENT.PID;
var observation = patientResult.GetORDER_OBSERVATION();
var specimentSegment = observation.SPECIMEN.SPM;
var obResultSegment = observation.OBSERVATION.OBX;
var obRequest = observation.OBR;
if (pidSegment == null)
{
response.ErrorMessages.Add("PID segment is missing");
return(response);
}
if (pidSegment.PatientID.IDNumber.Value == null)
{
response.ErrorMessages.Add(string.Format("Patient Id is missing"));
return(response);
}
var patient = Session.Get <Patient> (Convert.ToInt64(pidSegment.PatientID.IDNumber.Value));
if (patient == null)
{
response.ErrorMessages.Add(string.Format("Patient not found with id : {0}", pidSegment.PatientID.IDNumber.Value));
return(response);
}
var clinicalCaseCriteria =
DetachedCriteria.For <ClinicalCase> ().SetProjection(Projections.Id()).Add(
Restrictions.Eq(
Projections.Property <ClinicalCase> (p => p.Patient.Key),
pidSegment.PatientID.IDNumber.Value));
var checkedInStatus = _visitStatusRepository.GetByWellKnownName(WellKnownNames.VisitModule.VisitStatus.CheckedIn);
var visitCriteria =
Session.CreateCriteria <Visit> ().Add(Subqueries.PropertyIn("ClinicalCase.Key", clinicalCaseCriteria))
////.Add(Restrictions.Eq(Projections.Property<Visit>(v => v.VisitStatus), checkedInStatus ))
////TODO: Right now, the CheckedInDateTime is the time when the user click the button to change the VisitStatus. This is not right
.Add(
Restrictions.Eq(Projections.Property <Visit> (v => v.CheckedInDateTime), obRequest.ObservationDateTime.Time.GetAsDate()));
var visitList = visitCriteria.List();
if (visitList.Count > 0)
{
var visit = ( Visit )visitList[0];
var labSpecimenType = _labSpecimenTypeRepository.GetByCodedConceptCode(specimentSegment.SpecimenType.Identifier.Value);
if (labSpecimenType == null)
{
labSpecimenType = new LabSpecimenType
{
CodedConceptCode = specimentSegment.SpecimenType.Identifier.Value,
Name = specimentSegment.SpecimenType.Text.Value,
EffectiveDateRange = new DateRange(DateTime.Now, null)
};
labSpecimenType = _labSpecimenTypeRepository.MakePersistent(labSpecimenType);
}
var labSpecimen = _labSpecimenFactory.CreateLabSpecimen(
visit);
labSpecimen.ReviseLabSpecimenType(labSpecimenType);
var labFacility = new LabFacility(
obResultSegment.PerformingOrganizationName.OrganizationName.Value,
obResultSegment.PerformingOrganizationAddress.StreetAddress.StreetOrMailingAddress.Value,
obResultSegment.PerformingOrganizationAddress.City.Value,
obResultSegment.PerformingOrganizationAddress.StateOrProvince.Value,
obResultSegment.PerformingOrganizationAddress.ZipOrPostalCode.Value);
labSpecimen.ReviseLabFacility(labFacility);
if (specimentSegment.GetSpecimenRejectReason().Count() > 0)
{
labSpecimen.ReviseTestNotCompletedReasonDescription(specimentSegment.GetSpecimenRejectReason().FirstOrDefault().Text.Value);
}
var testName = _labTestNameRepository.GetByCodedConceptCode(obRequest.UniversalServiceIdentifier.Identifier.Value);
if (testName == null)
{
testName = new LabTestName
{
CodedConceptCode = obRequest.UniversalServiceIdentifier.Identifier.Value,
Name = obRequest.UniversalServiceIdentifier.Text.Value,
EffectiveDateRange = new DateRange(DateTime.Now, null)
};
testName = _labTestNameRepository.MakePersistent(testName);
}
CodedConcept interpretationCodeCodedConcept = null;
if (obResultSegment.ValueType.Value != "TX")
{
var abnormalFlagIS = obResultSegment.GetAbnormalFlags().FirstOrDefault();
if (abnormalFlagIS != null)
{
var abnormalFlagCode = abnormalFlagIS.Value;
var abnormalFlag = AbnormalFlag.GetAbnormalFlagByCode(abnormalFlagCode);
if (abnormalFlag != null)
{
interpretationCodeCodedConcept = new CodedConceptBuilder()
.WithCodedConceptCode(abnormalFlagCode)
.WithDisplayName(abnormalFlag.WellKnownName)
.WithCodeSystemIdentifier(AbnormalFlag.CodeSystemIdentifier)
.WithCodeSystemName(AbnormalFlag.CodeSystemName);
}
}
}
var labTest = labSpecimen.AddLabTest(
new LabTestInfoBuilder()
.WithLabTestName(testName)
.WithTestReportDate(obRequest.ObservationDateTime.Time.GetAsDate())
.WithNormalRangeDescription(obResultSegment.ReferencesRange.Value)
.WithInterpretationCodedConcept(interpretationCodeCodedConcept));
var resultTestName = new CodedConceptBuilder()
.WithCodedConceptCode(obResultSegment.ObservationIdentifier.Identifier.Value)
.WithDisplayName(obResultSegment.ObservationIdentifier.Text.Value);
double?value = null;
double tempValue;
if (double.TryParse(obResultSegment.GetObservationValue().FirstOrDefault().Data.ToString(), out tempValue))
{
value = tempValue;
}
var labResult = new LabResultBuilder()
.WithLabTestResultNameCodedConcept(resultTestName)
.WithUnitOfMeasureCode(obResultSegment.Units.Identifier.Value)
.WithValue(value);
labTest.AddLabResult(labResult);
}
else
{
response.ErrorMessages.Add(
string.Format(
"Visit not found for Patient id: {0} and Visit Date: {1}",
pidSegment.PatientID.IDNumber.Value,
obRequest.ObservationDateTime.Time.GetAsDate()));
}
if (response.ErrorMessages.Count > 0)
{
response.Exception = new ExceptionInfo(new Exception("SaveLabResult failed, transaction is going to be rollback."));
response.ExceptionType = ExceptionType.Unknown;
}
return(response);
}
private void CreateLabSpecimen(LabSpecimenDto dto, long patientKey, Provenance provenance)
{
if (dto == null || dto.LabResults == null || dto.LabResults.Count == 0)
{
return;
}
var clinicalCase = _clinicalCaseRepository.GetActiveClinicalCaseByPatient(patientKey);
var labSpecimen = _labSpecimenFactory.CreateLabSpecimen(
clinicalCase, provenance, new DateTimeRange(dto.ActivityStartDateTime, dto.ActivityStartDateTime));
var labSpecimenType = _mappingHelper.MapLookupField <LabSpecimenType> (dto.LabSpecimenType);
labSpecimen.ReviseLabSpecimenType(labSpecimenType);
labSpecimen.ReviseLabReceivedDate(dto.LabReceivedDate);
labSpecimen.ReviseCollectedHereIndicator(dto.CollectedHereIndicator);
// TODO: This needs to be rethought when the domain for Lab is redone.
var labTest = labSpecimen.LabTests.FirstOrDefault(lt => lt.LabTestInfo.LabTestName.WellKnownName == dto.LabTestName.WellKnownName);
if (labTest == null && labSpecimen.LabTests.Count > 0)
{
//right now there is only every one lab test per lab specimen?
labSpecimen.RemoveLabTest(labSpecimen.LabTests.ElementAt(0));
}
var labTestInfo = new LabTestInfoBuilder()
.WithLabTestName(_mappingHelper.MapLookupField <LabTestName> (dto.LabTestName))
.WithTestReportDate(dto.LabTestDate)
.WithLabTestNote(dto.LabTestNote);
if (labTest == null)
{
labTest = labSpecimen.AddLabTest(labTestInfo);
}
else
{
labTest.ReviseLabTestInfo(labTestInfo);
}
var result = new AggregateNodeCollectionMapper <LabResultDto, LabTest, LabResult> (dto.LabResults, labTest, labTest.LabResults)
.MapAddedItem(
(lrdto, lt) =>
{
CodedConcept labTestResultNameCodedConcept = null;
if (lrdto.LabTestResultNameCodedConcept != null)
{
labTestResultNameCodedConcept = new CodedConceptBuilder().WithCodedConceptDto(lrdto.LabTestResultNameCodedConcept);
}
lt.AddLabResult(
new LabResultBuilder()
.WithLabTestResultNameCodedConcept(labTestResultNameCodedConcept)
.WithUnitOfMeasureCode(lrdto.UnitOfMeasureCode)
.WithValue(lrdto.Value));
}
)
.MapChangedItem(
(lrdto, lt, lr) =>
{
lt.RemoveLabResult(lr);
CodedConcept labTestResultNameCodedConcept = null;
if (lrdto.LabTestResultNameCodedConcept != null)
{
labTestResultNameCodedConcept = new CodedConceptBuilder().WithCodedConceptDto(lrdto.LabTestResultNameCodedConcept);
}
lt.AddLabResult(
new LabResultBuilder()
.WithLabTestResultNameCodedConcept(labTestResultNameCodedConcept)
.WithValue(lrdto.Value)
.WithUnitOfMeasureCode(lrdto.UnitOfMeasureCode));
})
.MapRemovedItem((lrdto, lt, lr) => lt.RemoveLabResult(lr))
.Map();
}
private bool MapProperties(LabSpecimenDto dto, LabSpecimen entity)
{
var labSpecimenType = _mappingHelper.MapLookupField <LabSpecimenType> (dto.LabSpecimenType);
entity.ReviseLabSpecimenType(labSpecimenType);
entity.ReviseLabReceivedDate(dto.LabReceivedDate);
entity.ReviseCollectedHereIndicator(dto.CollectedHereIndicator);
// TODO: This needs to be rethought when the domain for Lab is redone.
var labTest = entity.LabTests.FirstOrDefault(lt => lt.LabTestInfo.LabTestName.WellKnownName == dto.LabTestName.WellKnownName);
if (labTest == null && entity.LabTests.Count > 0)
{
//right now there is only every one lab test per lab specimen?
entity.RemoveLabTest(entity.LabTests.ElementAt(0));
}
var labTestInfo = new LabTestInfoBuilder()
.WithLabTestName(_mappingHelper.MapLookupField <LabTestName> (dto.LabTestName))
.WithTestReportDate(dto.LabTestDate)
.WithLabTestNote(dto.LabTestNote);
if (labTest == null)
{
labTest = entity.AddLabTest(labTestInfo);
}
else
{
labTest.ReviseLabTestInfo(labTestInfo);
}
var result = new AggregateNodeCollectionMapper <LabResultDto, LabTest, LabResult> (dto.LabResults, labTest, labTest.LabResults)
.MapAddedItem(
(lrdto, lt) =>
{
CodedConcept labTestResultNameCodedConcept = null;
if (lrdto.LabTestResultNameCodedConcept != null)
{
labTestResultNameCodedConcept = new CodedConceptBuilder().WithCodedConceptDto(lrdto.LabTestResultNameCodedConcept);
}
lt.AddLabResult(
new LabResultBuilder()
.WithLabTestResultNameCodedConcept(labTestResultNameCodedConcept)
.WithValue(lrdto.Value)
.WithUnitOfMeasureCode(lrdto.UnitOfMeasureCode));
}
)
.MapChangedItem(
(lrdto, lt, lr) =>
{
lt.RemoveLabResult(lr);
CodedConcept labTestResultNameCodedConcept = null;
if (lrdto.LabTestResultNameCodedConcept != null)
{
labTestResultNameCodedConcept = new CodedConceptBuilder().WithCodedConceptDto(lrdto.LabTestResultNameCodedConcept);
}
lt.AddLabResult(
new LabResultBuilder()
.WithLabTestResultNameCodedConcept(labTestResultNameCodedConcept)
.WithValue(lrdto.Value)
.WithUnitOfMeasureCode(lrdto.UnitOfMeasureCode));
})
.MapRemovedItem((lrdto, lt, lr) => lt.RemoveLabResult(lr))
.Map();
return(result);
}
