/// <summary>
        /// Creates an CdaInterval with high and low.
        /// </summary>
        /// <param name="low">Low.</param>
        /// <param name="high">High.</param>
        /// <returns>Interval.</returns>
        public static CdaInterval CreateLowHigh(ISO8601DateTime low, ISO8601DateTime high)
        {
            Validation.ValidateArgumentRequired("low", low);
            Validation.ValidateArgumentRequired("high", high);

            return(CreateLowHigh(low, high, null, null, null));
        }
        /// <summary>
        /// Creates an CdaInterval with high and width.
        /// </summary>
        /// <param name="high">High.</param>
        /// <param name="width">width.</param>
        /// <param name="unit">Unit.</param>
        /// <returns>Interval</returns>
        public static CdaInterval CreateHighWidth(ISO8601DateTime high, string width, TimeUnitOfMeasure unit)
        {
            Validation.ValidateArgumentRequired("high", high);
            Validation.ValidateArgumentRequired("width", width);
            Validation.ValidateArgumentRequired("unit", unit);

            return(CreateHighWidth(high, width, unit, null, null, null));
        }
        /// <summary>
        /// Creates an CdaInterval with low and width.
        /// </summary>
        /// <param name="low">Low.</param>
        /// <param name="value">Quantity.</param>
        /// <param name="unit">Unit.</param>
        /// <returns>Interval</returns>
        public static CdaInterval CreateLowWidth(ISO8601DateTime low, string value, TimeUnitOfMeasure unit)
        {
            Validation.ValidateArgumentRequired("low", low);
            Validation.ValidateArgumentRequired("value", value);
            Validation.ValidateArgumentRequired("unit", unit);

            return(CreateLowWidth(low, value, unit, null, null, null));
        }
        /// <summary>
        /// Creates an CdaInterval with center and width.
        /// </summary>
        /// <param name="center">Center.</param>
        /// <param name="value">Quantity.</param>
        /// <param name="unit">Unit.</param>
        /// <returns>Interval</returns>
        public static CdaInterval CreateCenterWidth(ISO8601DateTime center, string value, TimeUnitOfMeasure unit)
        {
            Validation.ValidateArgumentRequired("center", center);
            Validation.ValidateArgumentRequired("value", value);
            Validation.ValidateArgumentRequired("unit", unit);

            return(new CdaInterval
            {
                Type = IntervalType.CenterWidth,
                Center = center,
                IntervalWidth = new CdaIntervalWidth(value, unit)
            });
        }
        /// <summary>
        /// Creates an CdaInterval with high.
        /// </summary>
        /// <param name="value">value.</param>
        /// <param name="operatorType">operatorType.</param>
        /// <param name="nullFlavor">nullFlavor.</param>
        /// <param name="high">High.</param>
        /// <returns>Interval</returns>
        public static CdaInterval CreateHigh(ISO8601DateTime high, int?value, OperationTypes?operatorType, NullFlavor?nullFlavor)
        {
            Validation.ValidateArgumentRequired("high", high);

            return(new CdaInterval
            {
                Operator = operatorType,
                NullFlavor = nullFlavor,
                Value = value,
                Type = IntervalType.High,
                High = high
            });
        }
        /// <summary>
        /// Creates an CdaInterval with center.
        /// </summary>
        /// <param name="value">value.</param>
        /// <param name="operatorType">operatorType.</param>
        /// <param name="nullFlavor">nullFlavor.</param>
        /// <param name="center">Center.</param>
        /// <returns>Interval</returns>
        public static CdaInterval CreateCenter(ISO8601DateTime center, int?value, OperationTypes?operatorType, NullFlavor?nullFlavor)
        {
            Validation.ValidateArgumentRequired("center", center);

            return(new CdaInterval
            {
                Operator = operatorType,
                NullFlavor = nullFlavor,
                Value = value,
                Type = IntervalType.Center,
                Center = center
            });
        }
        /// <summary>
        /// Creates an CdaInterval with low.
        /// </summary>
        /// <param name="low">Low.</param>
        /// <param name="value">value.</param>
        /// <param name="operatorType">operatorType.</param>
        /// <param name="nullFlavor">nullFlavor.</param>
        /// <returns>CdaInterval</returns>
        public static CdaInterval CreateValue(ISO8601DateTime low, int?value, OperationTypes?operatorType, NullFlavor?nullFlavor)
        {
            Validation.ValidateArgumentRequired("value", value);

            return(new CdaInterval
            {
                Operator = operatorType,
                NullFlavor = nullFlavor,
                Value = value,
                Type = IntervalType.Value,
                Low = low
            });
        }
        /// <summary>
        /// Creates an CdaInterval with center and width.
        /// </summary>
        /// <param name="center">Center.</param>
        /// <param name="width">Width.</param>
        /// <param name="unit">Unit.</param>
        /// <param name="value">value.</param>
        /// <param name="operatorType">operatorType.</param>
        /// <param name="nullFlavor">nullFlavor.</param>
        /// <returns>Interval</returns>
        public static CdaInterval CreateCenterWidth(ISO8601DateTime center, string width, TimeUnitOfMeasure unit, int?value, OperationTypes?operatorType, NullFlavor?nullFlavor)
        {
            Validation.ValidateArgumentRequired("center", center);
            Validation.ValidateArgumentRequired("width", width);
            Validation.ValidateArgumentRequired("unit", unit);

            return(new CdaInterval
            {
                Operator = operatorType,
                NullFlavor = nullFlavor,
                Value = value,
                Type = IntervalType.CenterWidth,
                Center = center,
                IntervalWidth = new CdaIntervalWidth(width, unit)
            });
        }
Example #9
0
        /// <summary>
        /// This sample populates both the mandatory and optional Sections / Entries depending on the
        /// mandatorySectionsOnly Boolean
        /// </summary>
        internal static EventSummary PopulatedEventSummary(Boolean mandatorySectionsOnly)
        {
            var eventSummary = EventSummary.CreateEventSummary();

            // Include Logo
            eventSummary.IncludeLogo = true;
            eventSummary.LogoPath    = OutputFolderPath;

            // Set Creation Time
            eventSummary.DocumentCreationTime = new ISO8601DateTime(DateTime.Now);

            #region Setup and populate the CDA context model

            // Setup and populate the CDA context model
            var cdaContext = EventSummary.CreateCDAContext();

            // Document Id
            cdaContext.DocumentId = BaseCDAModel.CreateIdentifier(BaseCDAModel.CreateOid());

            // Set Id
            if (!mandatorySectionsOnly)
            {
                cdaContext.SetId = BaseCDAModel.CreateIdentifier(BaseCDAModel.CreateGuid());
            }

            // CDA Context Version
            if (!mandatorySectionsOnly)
            {
                cdaContext.Version = "1";
            }

            // Custodian
            cdaContext.Custodian = BaseCDAModel.CreateCustodian();
            GenericObjectReuseSample.HydrateCustodian(cdaContext.Custodian, mandatorySectionsOnly);

            cdaContext.LegalAuthenticator = BaseCDAModel.CreateLegalAuthenticator();
            GenericObjectReuseSample.HydrateAuthenticator(cdaContext.LegalAuthenticator, mandatorySectionsOnly);

            eventSummary.CDAContext = cdaContext;

            #endregion

            #region Setup and Populate the SCS Context model

            // Setup and Populate the SCS Context model
            eventSummary.SCSContext = EventSummary.CreateSCSContext();

            eventSummary.SCSContext.Author = BaseCDAModel.CreateAuthor();
            GenericObjectReuseSample.HydrateAuthorV2(eventSummary.SCSContext.Author, mandatorySectionsOnly);

            eventSummary.SCSContext.SubjectOfCare = BaseCDAModel.CreateSubjectOfCare();
            GenericObjectReuseSample.HydrateSubjectofCare(eventSummary.SCSContext.SubjectOfCare, mandatorySectionsOnly, false);

            // DateTime Health Event Started & DateTime Health Event Ended allowable combinations
            var dateTimeHealthEventEnded   = new ISO8601DateTime(DateTime.Now);
            var dateTimeHealthEventStarted = new ISO8601DateTime(DateTime.Now.AddMonths(-12));

            eventSummary.SCSContext.EncounterPeriod = !mandatorySectionsOnly?
                                                      BaseCDAModel.CreateLowHigh(dateTimeHealthEventStarted, dateTimeHealthEventEnded) :
                                                          BaseCDAModel.CreateHigh(dateTimeHealthEventEnded);

            #endregion

            #region Setup and populate the SCS Content model
            // Setup and populate the SCS Content model
            eventSummary.SCSContent = EventSummary.CreateSCSContent();

            if (!mandatorySectionsOnly)
            {
                eventSummary.SCSContent.EventDetails = CreateEventDetails();

                // Adverse reactions
                eventSummary.SCSContent.AdverseReactions = CreateAdverseReactions();

                // Medications
                eventSummary.SCSContent.Medications = CreateMedications();

                // Medical history
                eventSummary.SCSContent.DiagnosesIntervention = CreateDiagnosesIntervention(mandatorySectionsOnly);

                // Immunisations
                eventSummary.SCSContent.Immunisations = CreateImmunisations();

                // Diagnostic Investigations
                eventSummary.SCSContent.DiagnosticInvestigations = CreateDiagnosticInvestigations(mandatorySectionsOnly);
            }

            #endregion

            return(eventSummary);
        }
        /// <summary>
        /// Creates an CdaInterval with center.
        /// </summary>
        /// <param name="center">Center.</param>
        /// <returns>Interval</returns>
        public static CdaInterval CreateCenter(ISO8601DateTime center)
        {
            Validation.ValidateArgumentRequired("center", center);

            return(CreateCenter(center, null, null, null));
        }
        /// <summary>
        /// Creates an CdaInterval with high.
        /// </summary>
        /// <param name="high">High.</param>
        /// <returns>Interval</returns>
        public static CdaInterval CreateHigh(ISO8601DateTime high)
        {
            Validation.ValidateArgumentRequired("high", high);

            return(CreateHigh(high, null, null, null));
        }
 /// <summary>
 /// Creates an CdaInterval with low.
 /// </summary>
 /// <param name="value">Low.</param>
 /// <returns>Interval</returns>
 public static CdaInterval CreateValue(ISO8601DateTime value)
 {
     Validation.ValidateArgumentRequired("value", value);
     return(CreateValue(value, null, null, null));
 }
 /// <summary>
 /// Creates an CdaInterval with low.
 /// </summary>
 /// <param name="low">Low.</param>
 /// <returns>Interval</returns>
 public static CdaInterval CreateLow(ISO8601DateTime low)
 {
     Validation.ValidateArgumentRequired("low", low);
     return(CreateLow(low, null, null, null));
 }