コード例 #1
0
ファイル: QueryService.cs プロジェクト: etriks/ehs-server
        public DataExportObject GetQueryResult(Guid combinedQueryId)
        {
            var combinedQuery = _combinedQueryRepository.Get(combinedQueryId);
            var queryResult   = new DataExportObject();
            var projectId     = combinedQuery.ProjectId;

            //TODO: the list of included proerties should reflect the selected subject properties
            //IE if StudyArm is selected as a field, then include it, if CollectionStudyDay is included, then include it ...etc
            //INSTEAD OF INCLUDING ALL PROPERTIES WHICH WOOULD MAKE THE QUERY REALLY SLOW
            queryResult.Subjects = _subjectRepository.FindAll(
                s => s.Study.ProjectId == projectId,
                new List <string>()
            {
                "StudyArm", "Study", "SubjectCharacteristics.CharacteristicFeature"
            }).ToList();

            //QUERY FOR CLINICAL OBSERVATIONS
            _getObservations(combinedQuery, ref queryResult);


            //QUERY FOR SUBJECT CHARACTERISITIC (e.g. AGE)
            foreach (var subjCharQuery in combinedQuery.SubjectCharacteristics)
            {
                var characteristics = _subjectCharacteristicRepository.FindAll(
                    sc =>
                    sc.Subject.Study.ProjectId == projectId &&
                    subjCharQuery.QueryWhereValue == sc.CharacteristicFeatureId.ToString(),
                    new List <string>()
                {
                    "Subject"
                }).ToList();

                //APPLY FILTERING IF FILTER PRESENT
                if (characteristics.Any() && subjCharQuery.IsFiltered)
                {
                    characteristics = (subjCharQuery.DataType == "string")
                        ? characteristics.FindAll(sc => subjCharQuery.FilterExactValues.Contains(sc.VerbatimValue))
                        : characteristics.FindAll(sc =>
                                                  int.Parse(sc.VerbatimValue) >= subjCharQuery.FilterRangeFrom &&
                                                  int.Parse(sc.VerbatimValue) <= subjCharQuery.FilterRangeTo);
                }

                //ADD TO EXPORT DATA
                queryResult.SubjChars.AddRange(characteristics);
            }

            //IF A REQUESTED OBSERVATION HAS LONGITUDINAL DATA, AUTOMATICALLY ADD A TIMING COLUMN (ASSUMING VISIT AS DEFAULT FOR NOW) SHOULD BE LATER DECIDED BASED ON O3
            if (queryResult.HasLongitudinalData)
            {
                combinedQuery.DesignElements.Add(new Query()
                {
                    QueryFor = nameof(Visit)
                });
            }

            foreach (var deQuery in combinedQuery.DesignElements)
            {
                switch (deQuery.QueryFor)
                {
                case nameof(HumanSubject.StudyArm):
                    if (deQuery.IsFiltered)
                    {
                        queryResult.Arms = _armRepository.FindAll(
                            a => a.Studies.Select(s => s.Study).All(s => s.ProjectId == projectId) &&
                            deQuery.FilterExactValues.Contains(a.Name)).ToList();
                    }
                    else
                    {
                        queryResult.Arms = _armRepository.FindAll(
                            a => a.Studies.Select(s => s.Study.ProjectId).Contains(projectId)).ToList();
                    }
                    break;

                case nameof(HumanSubject.Study):
                    if (deQuery.IsFiltered)
                    {
                        queryResult.Studies = _studyRepository.FindAll(
                            s => s.ProjectId == projectId &&
                            deQuery.FilterExactValues.Contains(s.Name),
                            new List <string>()
                        {
                            "Subjects"
                        }).ToList();
                    }
                    else
                    {
                        queryResult.Studies = _studyRepository.FindAll(s => s.ProjectId == projectId).ToList();
                    }
                    break;

                case nameof(Visit):
                    var visits = _visitRepository.FindAll(
                        v => v.Study.ProjectId == projectId
                        //apply filter if present
                        ).ToList();
                    queryResult.Visits = visits;
                    break;
                }
            }

            //FOR NOW SHOULD NOT BE ALLOWED UNLESS WE DECIDED TO PROPAGATE ALL ASSAY SPECIFIC FILTERS TO ALL ASSAYS IN THE COMBINED QUERY
            //if (combinedQuery.AssayPanels.Any() && combinedQuery.AssayPanels.Count > 1)
            //    return null;

            var apQuery = combinedQuery.AssayPanels.FirstOrDefault();

            if (apQuery != null)
            {
                //TODO:BRING BACK COLLECTIONSTUDYDAY
                var assaySamples =
                    _biosampleRepository.FindAll(s => s.AssayId == apQuery.AssayId,
                                                 new List <string>()
                {
                    "Subject", "SampleCharacteristics.CharacteristicFeature", "CollectionStudyDay"
                }).ToList();
                queryResult.Samples = assaySamples;
                //HOW DO I FILTER THE SAMPLES BY THE QUERED PROPERTIES?
                //HOW DO I filter samples by collectionStudyDay?

                //TODO: TEMP SOLUTION FOR COLLECTION STUDY DAY
                //foreach (var sampleQuery in apQuery.SampleQueries.Where(sq=>sq.QueryFor != nameof(Biosample.SampleCharacteristics)))
                //{
                //    assaySamples.FindAll(b =>
                //    int.Parse(b.GetType().GetProperty("CollectionStudyDay").GetValue(b).properyObj?.GetType().GetProperty(query.QuerySelectProperty)?.GetValue(properyObj)?.ToString().ToString()) >= sampleQuery.FilterRangeFrom &&
                //    int.Parse(b.GetType().GetProperty("CollectionStudyDay").GetValue(b).ToString()) <= sampleQuery.FilterRangeTo
                //    );

                //}
                if (apQuery.SampleQueries.Exists(sq => sq.QueryFor == nameof(Biosample.CollectionStudyDay)))
                {
                    var dayQuery = apQuery.SampleQueries.Find(sq => sq.QueryFor == nameof(Biosample.CollectionStudyDay));
                    if (dayQuery.IsFiltered)
                    {
                        queryResult.Samples = assaySamples.FindAll(
                            s =>
                            s.CollectionStudyDay?.Number != null &&
                            dayQuery.FilterExactValues.Contains(s.CollectionStudyDay?.Number.Value.ToString()));
                    }
                }

                //QUERY AND FILTER SAMPLE CHARACTERISTICS
                foreach (var sampleQuery in apQuery.SampleQueries.Where(sq => sq.QueryFor == nameof(Biosample.SampleCharacteristics)))
                {
                    var characteristics = _sampleCharacteristicRepository.FindAll(
                        sc =>
                        sc.Sample.Study.ProjectId == projectId &&
                        sampleQuery.QueryWhereValue == sc.CharacteristicFeatureId.ToString(),
                        new List <string>()
                    {
                        "Sample"
                    }).ToList();

                    //APPLY FILTERING IF FILTER PRESENT
                    if (characteristics.Any() && sampleQuery.IsFiltered)
                    {
                        characteristics = (sampleQuery.DataType == "string")
                            ? characteristics.FindAll(sc => sampleQuery.FilterExactValues.Contains(sc.VerbatimValue))
                            : characteristics.FindAll(sc =>
                                                      int.Parse(sc.VerbatimValue) >= sampleQuery.FilterRangeFrom &&
                                                      int.Parse(sc.VerbatimValue) <= sampleQuery.FilterRangeTo);
                    }
                    //ADD TO EXPORT DATA
                    queryResult.SampleCharacteristics.AddRange(characteristics);
                }
            }


            queryResult.FilterAndJoin();

            return(queryResult);
        }