Пример #1
0
        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);
        }
Пример #3
0
 /// <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));
     }
 }
Пример #4
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);
        }
Пример #5
0
        /// <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);
        }
Пример #6
0
 /// <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;
 }
Пример #7
0
        //
        // - 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);
                    }
                }
            }
        }
Пример #8
0
        private Problem BuildProblem(ClinicalCase clinicalCase, CodedConcept problemCode)
        {
            var problem = new Problem(clinicalCase, problemCode);

            Session.SaveOrUpdate(problem);
            return(problem);
        }
Пример #9
0
        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);
        }
Пример #10
0
 /// <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;
 }
Пример #11
0
        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)));
        }
Пример #12
0
        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);
            }
        }
Пример #13
0
        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);
        }
Пример #14
0
 /// <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;
 }
Пример #15
0
        private Allergy BuildAllergy(Patient patient, AllergyStatus allergyStatus, CodedConcept allergen)
        {
            var allergy = new Allergy(patient, allergyStatus, allergen);

            Session.SaveOrUpdate(allergy);
            return(allergy);
        }
Пример #16
0
 /// <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());
     }
 }
Пример #17
0
        /// <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);
        }
Пример #18
0
        /// <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);
        }
Пример #19
0
        /// <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);
        }
Пример #20
0
        /// <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;
        }
Пример #21
0
        /// <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);
        }
Пример #22
0
        public AssessmentDefinition(CodedConcept codedConcept) : this()
        {
            Check.IsNotNull(codedConcept, () => CodedConcept);

            Key = CombGuid.NewCombGuid();

            RaiseEvent(new AssessmentDefinitionCreatedEvent(Key, Version, codedConcept));
        }
Пример #23
0
        /// <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;
        }
Пример #24
0
 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;
 }
Пример #25
0
        /// <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;
        }
Пример #26
0
        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;
        }
Пример #28
0
        /// <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;
        }
Пример #29
0
        /// <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;
        }
Пример #30
0
        /// <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;
        }
Пример #31
0
        /// <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;
        }
Пример #32
0
        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);
        }
Пример #33
0
        /// <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;
        }
Пример #34
0
        /// <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);
        }
Пример #35
0
        /// <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;
        }
Пример #36
0
        /// <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;
        }
Пример #37
0
        /// <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);
        }
Пример #38
0
        /// <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;
        }
Пример #39
0
        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;
        }
Пример #40
0
        /// <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;
        }
Пример #41
0
        /// <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;
        }
Пример #42
0
 /// <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;
 }
Пример #43
0
 /// <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;
 }
Пример #44
0
 /// <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;
 }
Пример #45
0
        /// <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;
        }
Пример #46
0
 /// <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;
 }
Пример #47
0
 /// <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;
 }
Пример #48
0
 private Problem BuildProblem( ClinicalCase clinicalCase, CodedConcept problemCode )
 {
     var problem = new Problem ( clinicalCase, problemCode );
     Session.SaveOrUpdate ( problem );
     return problem;
 }
Пример #49
0
 /// <summary>
 ///   Revises the procedure.
 /// </summary>
 /// <param name="procedure"> The procedure. </param>
 public virtual void ReviseProcedure(CodedConcept procedure)
 {
     Check.IsNotNull ( procedure, () => Procedure );
     Procedure = procedure;
 }
Пример #50
0
 /// <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;
 }
Пример #51
0
 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;
 }
Пример #52
0
 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;
 }
Пример #53
0
        /// <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;
        }
Пример #54
0
        /// <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;
        }
Пример #55
0
 /// <summary>
 ///   Revises the diagnosis.
 /// </summary>
 /// <param name="diagnosis"> The diagnosis. </param>
 public virtual void ReviseDiagnosis(CodedConcept diagnosis)
 {
     Check.IsNotNull ( diagnosis, () => Diagnosis );
     Diagnosis = diagnosis;
 }
Пример #56
0
 private Allergy BuildAllergy( Patient patient, AllergyStatus allergyStatus, CodedConcept allergen )
 {
     var allergy = new Allergy ( patient, allergyStatus, allergen );
     Session.SaveOrUpdate ( allergy );
     return allergy;
 }
Пример #57
0
 /// <summary>
 /// Revises the problem coded concept.
 /// </summary>
 /// <param name="problemCodedConcept">The problem coded concept.</param>
 public virtual void ReviseProblemCodedConcept(CodedConcept problemCodedConcept)
 {
     _problemCodedConcept = problemCodedConcept;
 }
Пример #58
0
 /// <summary>
 /// Revises the medication coded concept.
 /// </summary>
 /// <param name="medicationCodedConcept">The medication coded concept.</param>
 public virtual void ReviseMedicationCodedConcept(CodedConcept medicationCodedConcept)
 {
     _medicationCodedConcept = medicationCodedConcept;
 }
Пример #59
0
 private Medication BuildMedication( Patient patient, CodedConcept medicationCode )
 {
     var medication = new Medication ( patient, medicationCode, medicationCode );
     Session.SaveOrUpdate ( medication );
     return medication;
 }
Пример #60
0
 /// <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;
 }