public object Convert(object value, Type targetType, object parameter, string language)
        {
            if (value != null)
            {
                var approxDateTime = value as ApproximateDateTime;

                // If ApproximateDateTime.Description is set, then we don't expect anything else to be present. Just output that content directly.
                if (!String.IsNullOrEmpty(approxDateTime.Description))
                {
                    return(approxDateTime.Description);
                }
                else
                {
                    ApproximateDate date    = approxDateTime.ApproximateDate;
                    var             year    = date.Year;
                    var             month   = (date.Month != null) ? date.Month.Value : 1;
                    var             day     = (date.Day != null) ? date.Day.Value : 1;
                    DateTime        current = new DateTime(year, month, day);
                    return(current.ToString(System.Globalization.DateTimeFormatInfo.CurrentInfo.ShortDatePattern));
                }
            }
            else
            {
                return(null);
            }
        }
        public void WhenSameDatePassedToEquals_ThenTrueReturned()
        {
            ApproximateDate date = new ApproximateDate(2017);

            ApproximateDateTime dateTime1 = new ApproximateDateTime(date);
            ApproximateDateTime dateTime2 = new ApproximateDateTime(date);

            Assert.IsTrue(dateTime1.Equals(dateTime2), "Equals should return true.");
        }
 internal static Date ToFhirInternal(ApproximateDate approximateDate)
 {
     if (approximateDate.Day.HasValue)
     {
         return(new Date(approximateDate.Year, approximateDate.Month.Value, approximateDate.Day.Value));
     }
     else if (approximateDate.Month.HasValue)
     {
         return(new Date(approximateDate.Year, approximateDate.Month.Value));
     }
     return(new Date(approximateDate.Year));
 }
        public static DateTime ApproximateDateTimeToDateTime(ApproximateDateTime medicationDateStarted)
        {
            ApproximateDate date = medicationDateStarted?.ApproximateDate;
            DateTime        current;

            if (date == null)
            {
                current = EmptyDate;
            }
            else
            {
                var year  = date.Year;
                var month = (date.Month != null) ? date.Month.Value : 1;
                var day   = (date.Day != null) ? date.Day.Value : 1;
                current = new DateTime(year, month, day);
            }
            return(current);
        }
        public MedicationsSummaryViewRow(Medication medication)
        {
            Medication = medication;

            Text   = medication.Name?.Text ?? "";
            Detail = DataTypeFormatter.FormatMedicationDetail(medication.Strength, medication.Dose);

            string note = medication.CommonData?.Note;

            if (note != null)
            {
                Note = note;
            }
            else
            {
                DateTimeOffset  now   = DateTimeOffset.Now;
                ApproximateDate today = new ApproximateDate(now.Year, now.Month, now.Day);

                var noteParts = new List <string>();

                ApproximateDate approximateDateStarted = medication.DateStarted?.ApproximateDate;
                if (approximateDateStarted != null)
                {
                    noteParts.Add(string.Format(
                                      StringResource.PrescribedDateFormat,
                                      FormatApproximateDate(approximateDateStarted)));
                }

                ApproximateDate approximateDateEnded = medication.DateDiscontinued?.ApproximateDate;
                if (approximateDateEnded != null && approximateDateEnded < today)
                {
                    noteParts.Add(string.Format(StringResource.ExpiredDateFormat, FormatApproximateDate(approximateDateStarted)));
                }

                Note = string.Join(", ", noteParts);
            }
        }
        private void UpdateDisplay(IEnumerable <Medication> items)
        {
            var current = new ObservableCollection <MedicationsSummaryViewRow>();
            var past    = new ObservableCollection <MedicationsSummaryViewRow>();

            foreach (Medication medication in items)
            {
                DateTimeOffset  now   = DateTimeOffset.Now;
                ApproximateDate today = new ApproximateDate(now.Year, now.Month, now.Day);

                var summaryViewRow = new MedicationsSummaryViewRow(medication);
                if (medication.DateDiscontinued == null || !(medication.DateDiscontinued.ApproximateDate < today))
                {
                    current.Add(summaryViewRow);
                }
                else
                {
                    past.Add(summaryViewRow);
                }
            }

            CurrentMedications = current;
            PastMedications    = past;
        }
        /// <summary>
        /// Populates this <see cref="ImmunizationV1"/> instance from the data in the XML.
        /// </summary>
        /// 
        /// <param name="typeSpecificXml">
        /// The XML to get the immunization data from.
        /// </param>
        /// 
        /// <exception cref="InvalidOperationException">
        /// The first node in <paramref name="typeSpecificXml"/> is not
        /// an immunization node.
        /// </exception>
        /// 
        protected override void ParseXml(IXPathNavigable typeSpecificXml)
        {
            XPathNavigator itemNav =
                typeSpecificXml.CreateNavigator().SelectSingleNode(
                    "immunization");

            Validator.ThrowInvalidIfNull(itemNav, "ImmunizationUnexpectedNode");

            // <name>
            _name.ParseXml(itemNav.SelectSingleNode("name"));

            // <administration-date>
            _dateAdministrated =
                XPathHelper.GetOptNavValue<ApproximateDateTime>(
                    itemNav,
                    "administration-date");

            // <administrator>
            _administrator =
                XPathHelper.GetOptNavValue<PersonItem>(
                    itemNav,
                    "administrator");

            // <manufacturer>
            _manufacturer =
                XPathHelper.GetOptNavValue(itemNav, "manufacturer");

            // <lot>
            _lot = XPathHelper.GetOptNavValue(itemNav, "lot");

            // <route>
            _route =
                XPathHelper.GetOptNavValue<CodableValue>(
                    itemNav,
                    "route");

            // <expiration-date> approx-date-time
            _expirationDate =
                XPathHelper.GetOptNavValue<ApproximateDate>(
                    itemNav,
                    "expiration-date");

            // <sequence>
            _sequence =
                XPathHelper.GetOptNavValue(itemNav, "sequence");

            // <anatomic-surface>
            _anatomicSurface =
                XPathHelper.GetOptNavValue<CodableValue>(
                    itemNav,
                    "anatomic-surface");

            // <adverse-event> string
            _adverseEvent =
                XPathHelper.GetOptNavValue(itemNav, "adverse-event");

            // <consent>
            _consent =
                XPathHelper.GetOptNavValue(itemNav, "consent");
        }
 public static Date ToFhir(this ApproximateDate approximateDate)
 {
     return(ApproximateDateToFhir.ToFhirInternal(approximateDate));
 }
        /// <summary>
        /// Populates this family history instance from the data in the XML.
        /// </summary>
        /// 
        /// <param name="typeSpecificXml">
        /// The XML to get the family history data from.
        /// </param>
        /// 
        /// <exception cref="InvalidOperationException">
        /// The first node in <paramref name="typeSpecificXml"/> is not
        /// a family history node.
        /// </exception>
        /// 
        protected override void ParseXml(IXPathNavigable typeSpecificXml)
        {
            XPathNavigator itemNav =
                typeSpecificXml.CreateNavigator().SelectSingleNode("family-history");

            Validator.ThrowInvalidIfNull(itemNav, "FamilyHistoryUnexpectedNode");

            // <condition>
            _condition = new CodableValue();
            _condition.ParseXml(itemNav.SelectSingleNode("condition"));

            // <relationship>
            _relationship =
                XPathHelper.GetOptNavValue<CodableValue>(
                    itemNav,
                    "relationship");

            // <date-of-birth>
            _dateOfBirth =
                XPathHelper.GetOptNavValue<ApproximateDate>(
                    itemNav,
                    "date-of-birth");

            // <age-of-onset>
            _ageOfOnset =
                XPathHelper.GetOptNavValueAsInt(
                    itemNav,
                    "age-of-onset");

            // <age-of-resolution>
            _ageOfResolution =
                XPathHelper.GetOptNavValueAsInt(
                    itemNav,
                    "age-of-resolution");

            // <duration>
            _duration =
                XPathHelper.GetOptNavValue<DurationValue>(
                    itemNav,
                    "duration");

            // <severity>
            _severity = XPathHelper.GetOptNavValue(itemNav, "severity");

            // <is-recurring>
            _isRecurring =
                XPathHelper.GetOptNavValueAsBool(itemNav, "is-recurring");

            // <status>
            _status =
                XPathHelper.GetOptNavValue<CodableValue>(
                    itemNav,
                    "status");
        }
Exemplo n.º 10
0
        /// <summary>
        /// Information related to a pregnancy.
        /// </summary>
        /// 
        /// <param name="typeSpecificXml">
        /// The XML to get the pregnancy data from.
        /// </param>
        /// 
        /// <exception cref="InvalidOperationException">
        /// If the first node in <paramref name="typeSpecificXml"/> is not
        /// a pregnancy node.
        /// </exception>
        /// 
        protected override void ParseXml(IXPathNavigable typeSpecificXml)
        {
            XPathNavigator itemNav =
                typeSpecificXml.CreateNavigator().SelectSingleNode("pregnancy");

            Validator.ThrowInvalidIfNull(itemNav, "PregnancyUnexpectedNode");

            _dueDate = XPathHelper.GetOptNavValue<ApproximateDate>(itemNav, "due-date");
            _lastMenstrualPeriod = XPathHelper.GetOptNavValue<HealthServiceDate>(itemNav, "last-menstrual-period");
            _conceptionMethod = XPathHelper.GetOptNavValue<CodableValue>(itemNav, "conception-method");
            _fetusCount = XPathHelper.GetOptNavValueAsInt(itemNav, "fetus-count");
            _gestationalAge = XPathHelper.GetOptNavValueAsInt(itemNav, "gestational-age");

            _delivery.Clear();
            foreach (XPathNavigator deliveryNav in itemNav.Select("delivery"))
            {
                Delivery delivery = new Delivery();
                delivery.ParseXml(deliveryNav);
                _delivery.Add(delivery);
            }
        }
        /// <summary>
        /// Populates this <see cref="FamilyHistoryPerson"/> instance from the 
        /// data in the XML. 
        /// </summary>
        /// 
        /// <param name="typeSpecificXml">
        /// The XML to get the family history person data from.
        /// </param>
        /// 
        /// <exception cref="InvalidOperationException">
        /// If the first node in <paramref name="typeSpecificXml"/> is not
        /// a family history person node.
        /// </exception>
        ///
        protected override void ParseXml(IXPathNavigable typeSpecificXml)
        {
            XPathNavigator itemNav =
                typeSpecificXml.CreateNavigator().SelectSingleNode("family-history-person");

            Validator.ThrowInvalidIfNull(itemNav, "FamilyHistoryPersonUnexpectedNode");

            // relative-name
            _relativeName = new PersonItem();
            _relativeName.ParseXml(itemNav.SelectSingleNode("relative-name"));

            // relationship
            _relationship =
                XPathHelper.GetOptNavValue<CodableValue>(itemNav,"relationship");

            // date-of-birth
            _dateOfBirth =
                XPathHelper.GetOptNavValue<ApproximateDate>(itemNav, "date-of-birth");

            // date-of-death
            _dateOfDeath =
                XPathHelper.GetOptNavValue<ApproximateDate>(itemNav,"date-of-death");
        }
        /// <summary>
        /// Populates this <see cref="FamilyHistoryRelativeV3"/> instance from the data in the XML. 
        /// </summary>
        /// 
        /// <param name="navigator">
        /// The XML to get the relative's data from.
        /// </param>
        /// 
        /// <exception cref="ArgumentNullException">
        /// If <paramref name="navigator"/> is <b> null </b>.
        /// </exception>
        ///
        public override void ParseXml(XPathNavigator navigator)
        {
            Validator.ThrowIfNavigatorNull(navigator);

            // relationship
            _relationship = new CodableValue();
            _relationship.ParseXml(navigator.SelectSingleNode("relationship"));

            // relative-name
            _relativeName =
                XPathHelper.GetOptNavValue<PersonItem>(navigator, "relative-name");

            // date-of-birth
            _dateOfBirth =
                XPathHelper.GetOptNavValue<ApproximateDate>(navigator, "date-of-birth");

            // date-of-death
            _dateOfDeath =
                XPathHelper.GetOptNavValue<ApproximateDate>(navigator, "date-of-death");

            //region-of-origin
            _regionOfOrigin =
                XPathHelper.GetOptNavValue<CodableValue>(navigator, "region-of-origin");
        }
        /// <summary>
        /// Populates this <see cref="FamilyHistoryRelative"/> instance from the data in the XML. 
        /// </summary>
        /// 
        /// <param name="navigator">
        /// The XML to get the relative's data from.
        /// </param>
        /// 
        /// <exception cref="ArgumentNullException">
        /// If <paramref name="navigator"/> is <b> null </b>.
        /// </exception>
        ///
        public override void ParseXml(XPathNavigator navigator)
        {
            Validator.ThrowIfNavigatorNull(navigator);

            _relativeName =
                XPathHelper.GetOptNavValue<PersonItem>(navigator, "relative-name");

            _relationship =
                XPathHelper.GetOptNavValue<CodableValue>(navigator, "relationship");

            _dateOfBirth =
                XPathHelper.GetOptNavValue<ApproximateDate>(navigator, "date-of-birth");

            _dateOfDeath =
                XPathHelper.GetOptNavValue<ApproximateDate>(navigator, "date-of-death");
        }
 private static string FormatApproximateDate(ApproximateDate date)
 {
     return(date.Month + "/" + date.Day + "/" + date.Year);
 }
        /// <summary>
        /// Populates this <see cref="Condition"/> instance from the data in the XML. 
        /// </summary>
        /// 
        /// <param name="navigator">
        /// The XML to get the condition data from.
        /// </param>
        /// 
        /// <exception cref="ArgumentNullException">
        /// If <paramref name="navigator"/> is <b> null </b>.
        /// </exception>
        ///
        public override void ParseXml(XPathNavigator navigator)
        {
            Validator.ThrowIfNavigatorNull(navigator);

            // name
            _name = new CodableValue();
            _name.ParseXml(navigator.SelectSingleNode("name"));

            // onset-date
            _onsetDate =
                XPathHelper.GetOptNavValue<ApproximateDate>(navigator, "onset-date");

            // resolution-date
            _resolutionDate =
                XPathHelper.GetOptNavValue<ApproximateDate>(navigator, "resolution-date");

            // resolution
            if (navigator.SelectSingleNode("resolution")!=null)
            {
                _resolution = navigator.SelectSingleNode("resolution").Value;
            }

            // occurrence
            _occurrence =
                XPathHelper.GetOptNavValue<CodableValue>(navigator,"occurrence");

            // severity
            _severity =
                XPathHelper.GetOptNavValue<CodableValue>(navigator,"severity");
        }