Example #1
0
        public QueryComposerRequestInterrogator(DTO.QueryComposer.QueryComposerRequestDTO request)
        {
            _request = request;
            if (_request.Select == null)
            {
                _request.Select = new DTO.QueryComposer.QueryComposerSelectDTO
                {
                    Fields = Enumerable.Empty <DTO.QueryComposer.QueryComposerFieldDTO>()
                };
            }

            if (_request.Select.Fields == null)
            {
                _request.Select.Fields = Enumerable.Empty <DTO.QueryComposer.QueryComposerFieldDTO>();
            }

            _selectFields = _request.Select.Fields;

            if (_request.Where.Criteria == null)
            {
                _request.Where.Criteria = Enumerable.Empty <DTO.QueryComposer.QueryComposerCriteriaDTO>();
            }

            _primaryCriteria = _request.Where.Criteria.FirstOrDefault();
            if (_primaryCriteria != null)
            {
                _primaryObservationPeriodTerm = _primaryCriteria.Terms.FirstOrDefault(t => t.Type == ModelTermsFactory.ObservationPeriodID);
            }
        }
Example #2
0
        public List <string> ParagraphEncounterTypes(DTO.QueryComposer.QueryComposerCriteriaDTO paragraph)
        {
            var terms = paragraph.Terms.Where(t => t.Type == ModelTermsFactory.SettingID).Concat(paragraph.Criteria.SelectMany(c => c.Terms.Where(t => t.Type == ModelTermsFactory.SettingID)));

            List <string> values = new List <string>();

            if (terms != null || terms.Any())
            {
                foreach (var term in terms)
                {
                    string             value = term.GetStringValue("Setting");
                    DTO.Enums.Settings enumValue;
                    if (Enum.TryParse <DTO.Enums.Settings>(value, out enumValue))
                    {
                        value = enumValue.ToString("G");
                    }

                    if (enumValue == DTO.Enums.Settings.AN)
                    {
                        values.Add("AN");
                    }
                    else
                    {
                        values.Add(value);
                    }
                }
            }
            return(values.Distinct().ToList());
        }
 /// <summary>
 /// As per PMNMAINT-1025:
 /// If multiple Observation Period terms and a Diagnosis term are added to the same criteria group,
 /// the query should be looking for the specified codes in either of those two Observation Periods.
 /// As Observation Periods in this case should be ORed with each other.
 /// </summary>
 /// <param name="paragraph"></param>
 /// <returns></returns>
 public List <Lpp.Dns.DataMart.Model.QueryComposer.Adapters.DateRangeValues> ParagraphObservationPeriodDateRanges(DTO.QueryComposer.QueryComposerCriteriaDTO paragraph)
 {
     return(ParagraphDateRanges(paragraph, ModelTermsFactory.ObservationPeriodID));
 }
Example #4
0
        /// <summary>
        /// As per PMNMAINT-1025:
        /// If multiple Observation Period terms and a Diagnosis term are added to the same criteria group,
        /// the query should be looking for the specified codes in either of those two Observation Periods.
        /// As Observation Periods in this case should be ORed with each other.
        /// </summary>
        /// <param name="paragraph"></param>
        /// <returns></returns>
        public List <Lpp.Dns.DataMart.Model.QueryComposer.Adapters.DateRangeValues> ParagraphObservationPeriodDateRanges(DTO.QueryComposer.QueryComposerCriteriaDTO paragraph)
        {
            //var terms = paragraph.Terms.Where(t => t.Type == ModelTermsFactory.ObservationPeriodID);
            var terms = paragraph.Terms.Where(t => t.Type == ModelTermsFactory.ObservationPeriodID).Concat(paragraph.Criteria.SelectMany(c => c.Terms.Where(t => t.Type == ModelTermsFactory.ObservationPeriodID)));

            List <Adapters.DateRangeValues> ranges = new List <Adapters.DateRangeValues>();

            if (terms != null || terms.Any())
            {
                foreach (var term in terms)
                {
                    var range = Lpp.Dns.DataMart.Model.QueryComposer.Adapters.AdapterHelpers.ParseDateRangeValues(term);
                    if (range.StartDate.HasValue || range.EndDate.HasValue)
                    {
                        ranges.Add(range);
                    }
                }
            }
            return(ranges);
        }
Example #5
0
        /// <summary>
        /// Returns all terms contained within the specified criteria and all it's sub-criteria.
        /// </summary>
        /// <param name="criteria"></param>
        /// <returns></returns>
        public static IEnumerable <DTO.QueryComposer.QueryComposerTermDTO> FlattenCriteriaToTerms(this DTO.QueryComposer.QueryComposerCriteriaDTO criteria)
        {
            if (criteria.Criteria != null)
            {
                foreach (var subCriteria in criteria.Criteria)
                {
                    foreach (var t in FlattenCriteriaToTerms(subCriteria).Where(t => t != null))
                    {
                        yield return(t);
                    }
                }
            }

            foreach (var term in Enumerable.DefaultIfEmpty(criteria.Terms).Where(t => t != null))
            {
                yield return(term);
            }
        }