private Medication BuildMedication(Patient patient, CodedConcept medicationCode) { var medication = new Medication(patient, medicationCode, medicationCode); Session.SaveOrUpdate(medication); return(medication); }
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); }
/// <summary> /// Returns a hash code for this instance. /// </summary> /// <returns> /// A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. /// </returns> public override int GetHashCode() { unchecked { return(((CodedConcept != null ? CodedConcept.GetHashCode() : 0) * 397) ^ (Version != null ? Version.GetHashCode() : 0)); } }
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); }
/// <summary> /// Creates the allergy. /// </summary> /// <param name="patient">The patient.</param> /// <param name="allergyStatus">The allergy status.</param> /// <param name="allergenCodedConcept">The allergen coded concept.</param> /// <param name="provenance">The provenance.</param> /// <returns> /// An Allergy. /// </returns> public Allergy CreateAllergy(Patient patient, AllergyStatus allergyStatus, CodedConcept allergenCodedConcept, Provenance provenance) { var allergy = new Allergy(patient, allergyStatus, allergenCodedConcept, provenance); _allergyRepository.MakePersistent(allergy); return(allergy); }
/// <summary> /// Initializes a new instance of the <see cref="Lookup" /> class. /// </summary> /// <param name="codedConcept">The coded concept.</param> /// <param name="value">The value.</param> /// <param name="sortOrder">The sort order.</param> /// <param name="isDefault">If set to <c>true</c> [is default].</param> public Lookup(CodedConcept codedConcept, double value, int sortOrder = 0, bool isDefault = false) { CodedConcept = codedConcept; IsDefault = isDefault; SortOrder = sortOrder; Value = value; }
// // - Methods - // /// <summary> /// Add a Context Group this this instance. /// </summary> /// <param name="contextGroup">The Context Group to add.</param> private void AddCodedConceptsToDictionary(ContextGroup contextGroup) { foreach (CodedConceptOrInclude codedConceptOrInclude in contextGroup.CodedConceptsOrIncludes) { if (codedConceptOrInclude is CodedConcept) { CodedConcept codedConcept = codedConceptOrInclude as CodedConcept; CodingSchemeDesignatorCodeValuePair codingSchemeDesignatorCodeValuePair = new CodingSchemeDesignatorCodeValuePair(codedConcept.CodingSchemeDesignator, codedConcept.CodeValue); List <CodedConcept> codedConcepts = null; if (this.codedConceptDictionary.TryGetValue(codingSchemeDesignatorCodeValuePair, out codedConcepts)) { codedConcepts.Add(codedConcept); } else { codedConcepts = new List <CodedConcept>(); codedConcepts.Add(codedConcept); this.codedConceptDictionary.Add(codingSchemeDesignatorCodeValuePair, codedConcepts); } } } }
private Problem BuildProblem(ClinicalCase clinicalCase, CodedConcept problemCode) { var problem = new Problem(clinicalCase, problemCode); Session.SaveOrUpdate(problem); return(problem); }
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); }
/// <summary> /// Creates the service. /// </summary> /// <param name="encounter">The encounter.</param> /// <param name="diagnosis">The diagnosis.</param> /// <param name="medicalProcedure">The medical procedure.</param> /// <param name="primaryIndicator">If set to <c>true</c> [primary indicator].</param> /// <param name="trackingNumber">The tracking number.</param> /// <returns>A service.</returns> public Service CreateService( Encounter encounter, CodedConcept diagnosis, MedicalProcedure medicalProcedure, bool primaryIndicator, long trackingNumber ) { var service = new Service(encounter, diagnosis, medicalProcedure, primaryIndicator, trackingNumber); encounter.AddService ( service ); _serviceRepository.MakePersistent(service); return service; }
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 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 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); }
/// <summary> /// Initializes a new instance of the <see cref="AssessmentScoredEvent" /> class. /// </summary> /// <param name="assessmentKey">The assessment key.</param> /// <param name="version">The version.</param> /// <param name="scoreCode">The score code.</param> /// <param name="value">The value.</param> /// <param name="guidance">The guidance.</param> public AssessmentScoredEvent(Guid assessmentKey, int version, CodedConcept scoreCode, object value, CodedConcept guidance = null) : base(assessmentKey, version) { Value = value; Guidance = guidance; ScoreCode = scoreCode; }
private Allergy BuildAllergy(Patient patient, AllergyStatus allergyStatus, CodedConcept allergen) { var allergy = new Allergy(patient, allergyStatus, allergen); Session.SaveOrUpdate(allergy); return(allergy); }
/// <summary> /// Returns a hash code for this instance. /// </summary> /// <returns> /// A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. /// </returns> public override int GetHashCode() { unchecked { return(((CodedConcept != null ? CodedConcept.GetHashCode() : 0) * 397) ^ Value.GetHashCode()); } }
/// <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); }
/// <summary> /// Synchronizes the service. /// </summary> /// <param name="encounter">The encounter.</param> /// <param name="procedure">The procedure.</param> /// <param name="diagnosis">The diagnosis.</param> /// <returns>A service.</returns> public Service SynchronizeService(Encounter encounter, Procedure procedure, CodedConcept diagnosis) { Check.IsNotNull(encounter, "Encounter is required."); Check.IsNotNull(procedure, "Procedure is required."); Check.IsNotNull(diagnosis, "Diagnosis is required."); var medicalProcedure = _medicalProcedureTranslator.Translate(procedure); var service = _serviceRepository.GetByTrackingNumber(procedure.Key); var primaryIndicator = (procedure.ProcedureType != ProcedureType.Activity); if (service == null) { service = _serviceFactory.CreateService(encounter, diagnosis, medicalProcedure, primaryIndicator, procedure.Key); } else { if (encounter.Key != service.Encounter.Key) { service.ReviseEncounter(encounter); } if (diagnosis != service.Diagnosis) { service.ReviseDiagnosis(diagnosis); } if (medicalProcedure != service.MedicalProcedure) { service.ReviseMedicalProcedure(medicalProcedure); } if (procedure.Key != service.TrackingNumber) { service.ReviseTrackingNumber(procedure.Key); } if (primaryIndicator != service.PrimaryIndicator) { service.RevisePrimaryIndicator(primaryIndicator); } if (procedure.BillingUnitCount != service.BillingUnitCount) { service.ReviseBillingUnitCount(procedure.BillingUnitCount); } } //TODO: move them to ctor var currency = _lookupValueRepository.GetLookupByWellKnownName <Currency>(WellKnownNames.CommonModule.Currency.USDollars); service.ReviseChargeAmount(new Money(currency, 1)); var c = new UnitCount(1); service.ReviseBillingUnitCount(c); return(service); }
/// <summary> /// Creates the medication. /// </summary> /// <param name="patient">The patient.</param> /// <param name="medicationCodeCodedConcept">The medication code coded concept.</param> /// <param name="provenance">The provenance.</param> /// <returns>A Medication.</returns> public Medication CreateMedication(Patient patient, CodedConcept medicationCodeCodedConcept, Provenance provenance) { var medication = new Medication(patient, medicationCodeCodedConcept, provenance); _medicationRepository.MakePersistent(medication); return(medication); }
/// <summary> /// Creates the medication. /// </summary> /// <param name="patient">The patient.</param> /// <param name="medicationCodeCodedConcept">The medication code coded concept.</param> /// <param name="provenance">The provenance.</param> /// <returns>A Medication.</returns> public Medication CreateMedication(Patient patient, CodedConcept medicationCodeCodedConcept, Provenance provenance) { var medication = new Medication(patient, medicationCodeCodedConcept, provenance); _medicationRepository.MakePersistent(medication); return medication; }
/// <summary> /// Creates the service. /// </summary> /// <param name="encounter">The encounter.</param> /// <param name="diagnosis">The diagnosis.</param> /// <param name="medicalProcedure">The medical procedure.</param> /// <param name="primaryIndicator">If set to <c>true</c> [primary indicator].</param> /// <param name="trackingNumber">The tracking number.</param> /// <returns>A service.</returns> public Service CreateService(Encounter encounter, CodedConcept diagnosis, MedicalProcedure medicalProcedure, bool primaryIndicator, long trackingNumber) { var service = new Service(encounter, diagnosis, medicalProcedure, primaryIndicator, trackingNumber); encounter.AddService(service); _serviceRepository.MakePersistent(service); return(service); }
public AssessmentDefinition(CodedConcept codedConcept) : this() { Check.IsNotNull(codedConcept, () => CodedConcept); Key = CombGuid.NewCombGuid(); RaiseEvent(new AssessmentDefinitionCreatedEvent(Key, Version, codedConcept)); }
/// <summary> /// Initializes a new instance of the <see cref="LabResult"/> class. /// </summary> /// <param name="labTestResultNameCodedConcept">The lab test result name coded concept.</param> /// <param name="value">The value.</param> /// <param name="unitOfMeasureCode">The unit of measure code.</param> protected internal LabResult(CodedConcept labTestResultNameCodedConcept, double?value, string unitOfMeasureCode) { Check.IsNotNull(labTestResultNameCodedConcept, () => LabTestResultNameCodedConcept); _labTestResultNameCodedConcept = labTestResultNameCodedConcept; _value = value; _unitOfMeasureCode = unitOfMeasureCode; }
public ItemDefinition(CodedConcept codedConcept, Lookup itemType, Lookup valueType, IEnumerable <Lookup> options = null, IEnumerable <ItemDefinition> itemDefinitions = null) { CodedConcept = codedConcept; ItemType = itemType; ValueType = valueType; Options = options; ItemDefinitions = itemDefinitions; }
/// <summary> /// Initializes a new instance of the <see cref="LabResult"/> class. /// </summary> /// <param name="labTestResultNameCodedConcept">The lab test result name coded concept.</param> /// <param name="value">The value.</param> /// <param name="unitOfMeasureCode">The unit of measure code.</param> protected internal LabResult( CodedConcept labTestResultNameCodedConcept, double? value, string unitOfMeasureCode ) { Check.IsNotNull ( labTestResultNameCodedConcept, () => LabTestResultNameCodedConcept ); _labTestResultNameCodedConcept = labTestResultNameCodedConcept; _value = value; _unitOfMeasureCode = unitOfMeasureCode; }
private Immunization BuildImmunization(Visit visit, ActivityType activityType, CodedConcept vaccineCodedConcept) { var immunization = new Immunization(visit, activityType); immunization.ReviseImmunizationVaccineInfo(new ImmunizationVaccineInfo(vaccineCodedConcept, null, new ImmunizationVaccineManufacturer(null, null))); Session.SaveOrUpdate(immunization); return(immunization); }
/// <summary> /// Synchronizes the service. /// </summary> /// <param name="encounter">The encounter.</param> /// <param name="procedure">The procedure.</param> /// <param name="diagnosis">The diagnosis.</param> /// <returns>A service.</returns> public Service SynchronizeService(Encounter encounter, Procedure procedure, CodedConcept diagnosis) { Check.IsNotNull(encounter, "Encounter is required."); Check.IsNotNull(procedure, "Procedure is required."); Check.IsNotNull(diagnosis, "Diagnosis is required."); var medicalProcedure = _medicalProcedureTranslator.Translate ( procedure ); var service = _serviceRepository.GetByTrackingNumber ( procedure.Key ); var primaryIndicator = ( procedure.ProcedureType != ProcedureType.Activity ); if (service == null) { service = _serviceFactory.CreateService ( encounter, diagnosis, medicalProcedure, primaryIndicator, procedure.Key ); } else { if (encounter.Key != service.Encounter.Key) { service.ReviseEncounter(encounter); } if (diagnosis != service.Diagnosis) { service.ReviseDiagnosis(diagnosis); } if (medicalProcedure != service.MedicalProcedure) { service.ReviseMedicalProcedure(medicalProcedure); } if (procedure.Key != service.TrackingNumber) { service.ReviseTrackingNumber(procedure.Key); } if (primaryIndicator != service.PrimaryIndicator) { service.RevisePrimaryIndicator(primaryIndicator); } if (procedure.BillingUnitCount != service.BillingUnitCount) { service.ReviseBillingUnitCount(procedure.BillingUnitCount); } } //TODO: move them to ctor var currency = _lookupValueRepository.GetLookupByWellKnownName<Currency>(WellKnownNames.CommonModule.Currency.USDollars); service.ReviseChargeAmount(new Money(currency, 1)); var c = new UnitCount ( 1 ); service.ReviseBillingUnitCount ( c ); return service; }
/// <summary> /// Creates the problem. /// </summary> /// <param name="clinicalCase">The clinical case.</param> /// <param name="problemCodeCodedConcept">The problem code coded concept.</param> /// <returns>A Problem.</returns> public Problem CreateProblem( ClinicalCase clinicalCase, CodedConcept problemCodeCodedConcept) { var problem = new Problem ( clinicalCase, problemCodeCodedConcept); _problemRepository.MakePersistent ( problem ); return problem; }
/// <summary> /// Initializes a new instance of the <see cref="MedicalProcedure"/> class. /// </summary> /// <param name="procedureCode">The procedure code.</param> /// <param name="firstModifierCode">The first modifier code.</param> /// <param name="secondModifierCode">The second modifier code.</param> /// <param name="thirdModifierCode">The third modifier code.</param> /// <param name="fourthModifierCode">The fourth modifier code.</param> public MedicalProcedure(CodedConcept procedureCode, CodedConcept firstModifierCode, CodedConcept secondModifierCode, CodedConcept thirdModifierCode, CodedConcept fourthModifierCode) { Check.IsNotNull(procedureCode, "Procedure code is required."); ProcedureCode = procedureCode; FirstModifierCode = firstModifierCode; SecondModifierCode = secondModifierCode; ThirdModifierCode = thirdModifierCode; FourthModifierCode = fourthModifierCode; }
/// <summary> /// Initializes a new instance of the <see cref="Problem"/> class. /// </summary> /// <param name="clinicalCase">The clinical case.</param> /// <param name="problemCodeCodedConcept">The problem code coded concept.</param> protected internal Problem( ClinicalCase clinicalCase, CodedConcept problemCodeCodedConcept ) { Check.IsNotNull ( clinicalCase, "Clinical case is required." ); Check.IsNotNull ( problemCodeCodedConcept, "Problem code coded concept is required." ); _clinicalCase = clinicalCase; _problemCodeCodedConcept = problemCodeCodedConcept; }
/// <summary> /// Initializes a new instance of the <see cref="Problem"/> class. /// </summary> /// <param name="clinicalCase">The clinical case.</param> /// <param name="problemCodeCodedConcept">The problem code coded concept.</param> protected internal Problem( ClinicalCase clinicalCase, CodedConcept problemCodeCodedConcept) { Check.IsNotNull(clinicalCase, "Clinical case is required."); Check.IsNotNull(problemCodeCodedConcept, "Problem code coded concept is required."); _clinicalCase = clinicalCase; _problemCodeCodedConcept = problemCodeCodedConcept; }
private LabResult BuildLabResult(LabTest labTest, CodedConcept labTestResultNameCodedConcept, double value) { var labResult = new LabResultBuilder() .WithLabTestResultNameCodedConcept(labTestResultNameCodedConcept) .WithValue(value).Build(); labTest.AddLabResult(labResult); Session.SaveOrUpdate(labResult); return(labResult); }
/// <summary> /// Initializes a new instance of the <see cref="Medication"/> class. /// </summary> /// <param name="patient">The patient.</param> /// <param name="medicationCodeCodedConcept">The medication code coded concept.</param> /// <param name="provenance">The provenance.</param> protected internal Medication(Patient patient, CodedConcept medicationCodeCodedConcept, Provenance provenance) { Check.IsNotNull(patient, "Patient is required."); Check.IsNotNull(medicationCodeCodedConcept, () => MedicationCodeCodedConcept); Check.IsNotNull(provenance, () => Provenance); _patient = patient; _medicationCodeCodedConcept = medicationCodeCodedConcept; _provenance = provenance; }
/// <summary>Gets the coded concept.</summary> /// <param name="propertyInfo">The property information.</param> /// <param name="defaultCodeSystem">The default code system.</param> /// <returns>A <see cref="CodedConcept" />.</returns> protected static CodedConcept GetCodedConcept(PropertyInfo propertyInfo, CodeSystem defaultCodeSystem) { var codeSystemAttribute = propertyInfo.GetCustomAttribute <CodeSystemAttribute>(); var codedConcept = new CodedConcept( codeSystemAttribute == null ? defaultCodeSystem : codeSystemAttribute.CodeSystem, propertyInfo.GetCustomAttribute <CodeAttribute>().Value, propertyInfo.Name); return(codedConcept); }
/// <summary> /// Initializes a new instance of the <see cref="Medication"/> class. /// </summary> /// <param name="patient">The patient.</param> /// <param name="medicationCodeCodedConcept">The medication code coded concept.</param> /// <param name="rootMedicationCodedConcept">The root medication coded concept.</param> protected internal Medication(Patient patient, CodedConcept medicationCodeCodedConcept, CodedConcept rootMedicationCodedConcept) { Check.IsNotNull(patient, "Patient is required."); Check.IsNotNull(medicationCodeCodedConcept, () => MedicationCodeCodedConcept); Check.IsNotNull(rootMedicationCodedConcept, () => RootMedicationCodedConcept); _patient = patient; _medicationCodeCodedConcept = medicationCodeCodedConcept; _rootMedicationCodedConcept = rootMedicationCodedConcept; }
/// <summary> /// Initializes a new instance of the <see cref="Medication"/> class. /// </summary> /// <param name="patient">The patient.</param> /// <param name="medicationCodeCodedConcept">The medication code coded concept.</param> /// <param name="rootMedicationCodedConcept">The root medication coded concept.</param> protected internal Medication( Patient patient, CodedConcept medicationCodeCodedConcept, CodedConcept rootMedicationCodedConcept ) { Check.IsNotNull ( patient, "Patient is required." ); Check.IsNotNull ( medicationCodeCodedConcept, () => MedicationCodeCodedConcept ); Check.IsNotNull ( rootMedicationCodedConcept, () => RootMedicationCodedConcept ); _patient = patient; _medicationCodeCodedConcept = medicationCodeCodedConcept; _rootMedicationCodedConcept = rootMedicationCodedConcept; }
/// <summary> /// Creates the problem. /// </summary> /// <param name="clinicalCase">The clinical case.</param> /// <param name="problemCodeCodedConcept">The problem code coded concept.</param> /// <returns>A Problem.</returns> public Problem CreateProblem( ClinicalCase clinicalCase, CodedConcept problemCodeCodedConcept) { var problem = new Problem(clinicalCase, problemCodeCodedConcept); _problemRepository.MakePersistent(problem); return(problem); }
/// <summary> /// Initializes a new instance of the <see cref="ClaimLineItem" /> class. /// </summary> /// <param name="billingUnitCount"> The billing unit count. </param> /// <param name="chargeAmount"> The charge amount. </param> /// <param name="diagnosis"> The diagnosis. </param> /// <param name="procedure"> The procedure. </param> public ClaimLineItem( UnitCount billingUnitCount, Money chargeAmount, CodedConcept diagnosis, CodedConcept procedure ) { Check.IsNotNull ( chargeAmount, () => ChargeAmount ); Check.IsNotNull ( diagnosis, () => Diagnosis ); Check.IsNotNull ( procedure, () => Procedure ); BillingUnitCount = billingUnitCount; ChargeAmount = chargeAmount; Diagnosis = diagnosis; Procedure = procedure; }
internal Allergy( Patient patient, AllergyStatus allergyStatus, CodedConcept allergenCodedConcept ) { Check.IsNotNull ( patient, () => Patient ); Check.IsNotNull ( allergyStatus, () => AllergyStatus ); Check.IsNotNull ( allergenCodedConcept, () => AllergenCodedConcept ); _allergyReactions = new List<AllergyReaction> (); _patient = patient; _allergyStatus = allergyStatus; _allergenCodedConcept = allergenCodedConcept; }
/// <summary> /// Initializes a new instance of the <see cref="Service"/> class. /// </summary> /// <param name="encounter">The encounter.</param> /// <param name="diagnosis">The diagnosis.</param> /// <param name="medicalProcedure">The medical procedure.</param> /// <param name="primaryIndicator">If set to <c>true</c> [primary indicator].</param> /// <param name="trackingNumber">The tracking number.</param> protected internal Service(Encounter encounter, CodedConcept diagnosis, MedicalProcedure medicalProcedure, bool primaryIndicator, long trackingNumber) { Check.IsNotNull(encounter, "Encounter is required."); Check.IsNotNull(diagnosis, "Diagnosis is required."); Check.IsNotNull(medicalProcedure, "Medical procedure is required."); PrimaryIndicator = primaryIndicator; Encounter = encounter; Diagnosis = diagnosis; MedicalProcedure = medicalProcedure; TrackingNumber = trackingNumber; }
/// <summary> /// Initializes a new instance of the <see cref="Procedure"/> class. /// </summary> /// <param name="codingContext">The coding context.</param> /// <param name="procedureType">Type of the procedure.</param> /// <param name="activity">The activity.</param> /// <param name="procedureCode">The procedure code.</param> /// <param name="unitCount">The unit count.</param> protected internal Procedure(CodingContext codingContext, ProcedureType procedureType, Activity activity, CodedConcept procedureCode, UnitCount unitCount) : base(codingContext) { if (procedureType == ProcedureType.Activity) { Check.IsNotNull(activity, "Activity is required for activity procedure type."); } Check.IsNotNull(procedureCode, "Procedure code is required."); CodingContext = codingContext; ProcedureType = procedureType; Activity = activity; ProcedureCode = procedureCode; BillingUnitCount = unitCount; }
/// <summary> /// Creates the allergy. /// </summary> /// <param name="patient">The patient.</param> /// <param name="allergyStatus">The allergy status.</param> /// <param name="allergenCodedConcept">The allergen coded concept.</param> /// <param name="provenance">The provenance.</param> /// <returns> /// An Allergy. /// </returns> public Allergy CreateAllergy(Patient patient, AllergyStatus allergyStatus, CodedConcept allergenCodedConcept, Provenance provenance) { var allergy = new Allergy(patient, allergyStatus, allergenCodedConcept, provenance); _allergyRepository.MakePersistent(allergy); return allergy; }
/// <summary> /// Assigns the lab result status coded concept. /// </summary> /// <param name="labResultStatusCodedConcept">The lab result status coded concept.</param> /// <returns>A LabTestInfoBuilder.</returns> public LabTestInfoBuilder WithLabResultStatusCodedConcept(CodedConcept labResultStatusCodedConcept) { _labResultStatusCodedConcept = labResultStatusCodedConcept; return this; }
/// <summary> /// Revises the diagnosis. /// </summary> /// <param name="diagnosis">The diagnosis.</param> public virtual void ReviseDiagnosis(CodedConcept diagnosis) { Check.IsNotNull(diagnosis, "Diagnosis is required."); Diagnosis = diagnosis; }
/// <summary> /// Revises the problem code. /// </summary> /// <param name="problemCodeCodedConcept">The problem code coded concept.</param> public virtual void ReviseProblemCode(CodedConcept problemCodeCodedConcept) { Check.IsNotNull(problemCodeCodedConcept, "Problem code coded concept is required."); ProblemCodeCodedConcept = problemCodeCodedConcept; }
/// <summary> /// Revises the root medication coded concept. /// </summary> /// <param name="rootMedicationCodedConcept">The root medication coded concept.</param> public virtual void ReviseRootMedicationCodedConcept( CodedConcept rootMedicationCodedConcept ) { RootMedicationCodedConcept = rootMedicationCodedConcept; }
private Problem BuildProblem( ClinicalCase clinicalCase, CodedConcept problemCode ) { var problem = new Problem ( clinicalCase, problemCode ); Session.SaveOrUpdate ( problem ); return problem; }
/// <summary> /// Revises the procedure. /// </summary> /// <param name="procedure"> The procedure. </param> public virtual void ReviseProcedure(CodedConcept procedure) { Check.IsNotNull ( procedure, () => Procedure ); Procedure = procedure; }
/// <summary> /// Assigns the lab test result name coded concept. /// </summary> /// <param name="labTestResultNameCodedConcept">The lab test result name coded concept.</param> /// <returns>A LabResultBuilder.</returns> public LabResultBuilder WithLabTestResultNameCodedConcept(CodedConcept labTestResultNameCodedConcept) { _labTestResultNameCodedConcept = labTestResultNameCodedConcept; return this; }
private Immunization BuildImmunization( Visit visit, ActivityType activityType, CodedConcept vaccineCodedConcept ) { var immunization = new Immunization ( visit, activityType ); immunization.ReviseImmunizationVaccineInfo(new ImmunizationVaccineInfo(vaccineCodedConcept, null, new ImmunizationVaccineManufacturer(null, null))); Session.SaveOrUpdate ( immunization ); return immunization; }
private LabResult BuildLabResult( LabTest labTest, CodedConcept labTestResultNameCodedConcept, double value ) { var labResult = new LabResultBuilder () .WithLabTestResultNameCodedConcept ( labTestResultNameCodedConcept ) .WithValue ( value ).Build (); labTest.AddLabResult ( labResult ); Session.SaveOrUpdate ( labResult ); return labResult; }
/// <summary> /// Adds the medication. /// </summary> /// <param name="medicationCodeCodedConcept">The medication code coded concept.</param> /// <param name="provenance">The provenance.</param> /// <returns>A Medication.</returns> public virtual Medication AddMedication(CodedConcept medicationCodeCodedConcept, Provenance provenance) { InitializeServices(); var factory = IoC.CurrentContainer.Resolve<IMedicationFactory>(); var medication = factory.CreateMedication(this, medicationCodeCodedConcept, provenance); _medications.Add(medication); NotifyItemAdded(() => Medications, medication); return medication; }
/// <summary> /// Adds the allergy. /// </summary> /// <param name="allergyStatus">The allergy status.</param> /// <param name="allergenCodedConcept">The allergen coded concept.</param> /// <param name="provenance">The provenance.</param> /// <returns>AN Allergy.</returns> public virtual Allergy AddAllergy(AllergyStatus allergyStatus, CodedConcept allergenCodedConcept, Provenance provenance) { InitializeServices(); var factory = IoC.CurrentContainer.Resolve<IAllergyFactory>(); var allergy = factory.CreateAllergy(this, allergyStatus, allergenCodedConcept, provenance); _allergies.Add(allergy); NotifyItemAdded(() => Allergies, allergy); return allergy; }
/// <summary> /// Revises the diagnosis. /// </summary> /// <param name="diagnosis"> The diagnosis. </param> public virtual void ReviseDiagnosis(CodedConcept diagnosis) { Check.IsNotNull ( diagnosis, () => Diagnosis ); Diagnosis = diagnosis; }
private Allergy BuildAllergy( Patient patient, AllergyStatus allergyStatus, CodedConcept allergen ) { var allergy = new Allergy ( patient, allergyStatus, allergen ); Session.SaveOrUpdate ( allergy ); return allergy; }
/// <summary> /// Revises the problem coded concept. /// </summary> /// <param name="problemCodedConcept">The problem coded concept.</param> public virtual void ReviseProblemCodedConcept(CodedConcept problemCodedConcept) { _problemCodedConcept = problemCodedConcept; }
/// <summary> /// Revises the medication coded concept. /// </summary> /// <param name="medicationCodedConcept">The medication coded concept.</param> public virtual void ReviseMedicationCodedConcept(CodedConcept medicationCodedConcept) { _medicationCodedConcept = medicationCodedConcept; }
private Medication BuildMedication( Patient patient, CodedConcept medicationCode ) { var medication = new Medication ( patient, medicationCode, medicationCode ); Session.SaveOrUpdate ( medication ); return medication; }
/// <summary> /// Revises the medication code coded concept. /// </summary> /// <param name="medicationCodeCodedConcept">The medication code coded concept.</param> public virtual void ReviseMedicationCodeCodedConcept( CodedConcept medicationCodeCodedConcept ) { Check.IsNotNull ( medicationCodeCodedConcept, () => MedicationCodeCodedConcept ); MedicationCodeCodedConcept = medicationCodeCodedConcept; }