Esempio n. 1
0
        private static void AddPaginationHeders(IQidoRequestModel request, HttpResponseMessage response, PagedResult <DicomDataset> results)
        {
            LinkHeaderBuilder headerBuilder = new LinkHeaderBuilder( );

            response.Headers.Add("link",
                                 headerBuilder.GetLinkHeader(results, HttpContext.Current.Request.Url.AbsoluteUri));

            response.Headers.Add("X-Total-Count", results.TotalCount.ToString());

            response.Headers.Add("Access-Control-Expose-Headers", "link");
            response.Headers.Add("Access-Control-Allow-Headers", "link");
            response.Headers.Add("Access-Control-Expose-Headers", "X-Total-Count");
            response.Headers.Add("Access-Control-Allow-Headers", "X-Total-Count");

            if (results.TotalCount > results.Result.Count())
            {
                if (!request.Limit.HasValue ||
                    (request.Limit.HasValue && request.Limit.Value > results.PageSize))
                {
                    response.Headers.Add("Warning", "299 " + "DICOMcloud" +
                                         "  \"The number of results exceeded the maximum supported by the server. Additional results can be requested.\"");

                    //DICOM: http://dicom.nema.org/dicom/2013/output/chtml/part18/sect_6.7.html
                    //Warning: 299 {SERVICE}: "The number of results exceeded the maximum supported by the server. Additional results can be requested.
                }
            }
        }
Esempio n. 2
0
        private static HttpResponseMessage CreateMultipartResponse(IQidoRequestModel request, IEnumerable <DicomDataset> results)
        {
            HttpResponseMessage response;


            if (MultipartResponseHelper.GetSubMediaType(request.AcceptHeader.FirstOrDefault( )) == MimeMediaTypes.xmlDicom)
            {
                MultipartContent multiContent;


                response     = new HttpResponseMessage( );
                multiContent = new MultipartContent("related", MultipartResponseHelper.DicomDataBoundary);

                response.Content = multiContent;

                foreach (var result in results)
                {
                    XmlDicomConverter converter = new XmlDicomConverter( );

                    MultipartResponseHelper.AddMultipartContent(multiContent,
                                                                new WadoResponse(new MemoryStream(Encoding.ASCII.GetBytes(converter.Convert(result))),
                                                                                 MimeMediaTypes.xmlDicom));
                }

                multiContent.Headers.ContentType.Parameters.Add(new System.Net.Http.Headers.NameValueHeaderValue("type",
                                                                                                                 "\"" + MimeMediaTypes.xmlDicom + "\""));
            }
            else
            {
                response = new HttpResponseMessage(System.Net.HttpStatusCode.BadRequest);
            }

            return(response);
        }
Esempio n. 3
0
 public HttpResponseMessage SearchForSeries
 (
     [ModelBinder(typeof(QidoRequestModelBinder))]
     IQidoRequestModel request
 )
 {
     return(QidoService.SearchForSeries(request));
 }
Esempio n. 4
0
        protected virtual IQueryOptions GetQueryOptions(IQidoRequestModel qidoRequest)
        {
            var queryOptions = CreateNewQueryOptions( );

            queryOptions.Limit  = Math.Min(MaximumResultsLimit, qidoRequest.Limit.HasValue ? qidoRequest.Limit.Value : MaximumResultsLimit);
            queryOptions.Offset = Math.Max(0, qidoRequest.Offset.HasValue ? qidoRequest.Offset.Value : 0);

            return(queryOptions);
        }
Esempio n. 5
0
        protected virtual IQueryOptions GetQueryOptions(IQidoRequestModel qidoRequest)
        {
            var queryOptions = CreateNewQueryOptions( );

            queryOptions.Limit  = qidoRequest.Limit;
            queryOptions.Offset = qidoRequest.Offset;

            return(queryOptions);
        }
Esempio n. 6
0
        private HttpResponseMessage SearchForDicomEntity
        (
            IQidoRequestModel request,
            DicomAttributeCollection dicomSource,
            DoQueryDelegate doQuery
        )
        {
            if (null != request.Query)
            {
                var matchingParams = request.Query.MatchingElements;
                var includeParams  = request.Query.IncludeElements;

                foreach (var queryParam in  matchingParams)
                {
                    string paramValue = queryParam.Value;

                    InsertDicomElement(dicomSource, queryParam.Key, paramValue);
                }

                foreach (var returnParam in includeParams)
                {
                    InsertDicomElement(dicomSource, returnParam, "");
                }

                ICollection <DicomAttributeCollection> results = doQuery(QueryService, dicomSource, request.Limit, request.Offset);   //TODO: move configuration params into their own object

                StringBuilder jsonReturn = new StringBuilder("[");

                JsonDicomConverter converter = new JsonDicomConverter( )
                {
                    IncludeEmptyElements = true
                };

                foreach (var response in results)
                {
                    jsonReturn.AppendLine(converter.Convert(response));

                    jsonReturn.Append(",");
                }

                if (results.Count > 0)
                {
                    jsonReturn.Remove(jsonReturn.Length - 1, 1);
                }

                jsonReturn.Append("]");

                return(new HttpResponseMessage(System.Net.HttpStatusCode.OK)
                {
                    Content = new StringContent(jsonReturn.ToString( ), Encoding.UTF8, MimeMediaTypes.Json)
                });
            }

            return(null);
        }
Esempio n. 7
0
 public virtual HttpResponseMessage SearchForSeries(IQidoRequestModel request)
 {
     return(SearchForDicomEntity(request,
                                 DefaultDicomQueryElements.GetDefaultSeriesQuery( ),
                                 delegate
                                 (
                                     IObjectArchieveQueryService queryService,
                                     DicomDataset dicomRequest,
                                     IQidoRequestModel qidoResult
                                 )
     {
         return queryService.FindSeriesPaged(dicomRequest, GetQueryOptions(qidoResult));
     }));
 }
Esempio n. 8
0
 public HttpResponseMessage SearchForInstances(IQidoRequestModel request)
 {
     return(SearchForDicomEntity(request,
                                 DefaultDicomQueryElements.GetDefaultInstanceQuery( ),
                                 delegate
                                 (
                                     IObjectArchieveQueryService queryService,
                                     fo.DicomDataset dicomRequest,
                                     IQidoRequestModel qidoResult
                                 )
     {
         return queryService.FindObjectInstances(dicomRequest, GetQueryOptions(qidoResult));
     }));
 }
Esempio n. 9
0
 public HttpResponseMessage SearchForInstances(IQidoRequestModel request)
 {
     return(SearchForDicomEntity(request,
                                 DefaultDicomQueryElements.GetDefaultInstanceQuery( ),
                                 delegate
                                 (
                                     IObjectArchieveQueryService queryService,
                                     DicomAttributeCollection dicomRequest,
                                     int?limit,
                                     int?offset
                                 )
     {
         return queryService.FindObjectInstances(dicomRequest, offset, limit);
     }));
 }
Esempio n. 10
0
        private void AddResponseHeaders
        (
            IQidoRequestModel request,
            DicomDataset dicomSource,
            HttpResponseMessage response,
            PagedResult <DicomDataset> results
        )
        {
            //special parameters, if included, a representative instance UID (first) will be returned in header for each DS result
            if (response.IsSuccessStatusCode && request.Query.CustomParameters.ContainsKey("_instance-header"))
            {
                AddPreviewInstanceHeader(results.Result, response);
            }

            AddPaginationHeders(request, response, results);
        }
Esempio n. 11
0
        /// <summary>
        /// If access Qido interface with URL http://localhost:44301/qidors/studies/1.3.12.2.1107.5.3.4.2373.1.20171103124622/series
        /// will get a 404 page, this method will check if the URL contains uid information.
        /// </summary>
        /// <param name="valueProvider"></param>
        /// <param name="wadoReq"></param>
        private void CheckAndFillUids(IValueProvider valueProvider, IQidoRequestModel wadoReq)
        {
            string studyInstanceUidKey  = fo.DicomTag.StudyInstanceUID.DictionaryEntry.Keyword.ToLower();
            string seriesInstanceUidKey = fo.DicomTag.SeriesInstanceUID.DictionaryEntry.Keyword.ToLower();
            string sopInstanceUidKey    = fo.DicomTag.SOPInstanceUID.DictionaryEntry.Keyword.ToLower();

            if (!wadoReq.Query.MatchingElements.ContainsKey(studyInstanceUidKey))
            {
                ValueProviderResult valueResult = valueProvider.GetValue(studyInstanceUidKey);
                if (valueResult != null)
                {
                    string studyInstanceUid = valueResult.RawValue as string;
                    if (!string.IsNullOrEmpty(studyInstanceUid))
                    {
                        wadoReq.Query.MatchingElements.Add(studyInstanceUidKey, studyInstanceUid);
                    }
                }
            }

            if (!wadoReq.Query.MatchingElements.ContainsKey(seriesInstanceUidKey))
            {
                ValueProviderResult valueResult = valueProvider.GetValue(seriesInstanceUidKey);
                if (valueResult != null)
                {
                    string seriesInstanceUid = valueResult.RawValue as string;
                    if (!string.IsNullOrEmpty(seriesInstanceUid))
                    {
                        wadoReq.Query.MatchingElements.Add(seriesInstanceUidKey, seriesInstanceUid);
                    }
                }
            }

            if (!wadoReq.Query.MatchingElements.ContainsKey(sopInstanceUidKey))
            {
                ValueProviderResult valueResult = valueProvider.GetValue(sopInstanceUidKey);
                if (valueResult != null)
                {
                    string sopInstanceUid = valueResult.RawValue as string;
                    if (!string.IsNullOrEmpty(sopInstanceUid))
                    {
                        wadoReq.Query.MatchingElements.Add(sopInstanceUidKey, sopInstanceUid);
                    }
                }
            }
        }
Esempio n. 12
0
        private HttpResponseMessage SearchForDicomEntity
        (
            IQidoRequestModel request,
            DicomDataset dicomSource,
            DoQueryDelegate doQuery
        )
        {
            if (null != request.Query)
            {
                HttpResponseMessage response = null;
                var matchingParams           = request.Query.MatchingElements;
                var includeParams            = request.Query.IncludeElements;

                foreach (var returnParam in includeParams)
                {
                    InsertDicomElement(dicomSource, returnParam, "");
                }

                foreach (var queryParam in matchingParams)
                {
                    string paramValue = queryParam.Value;


                    InsertDicomElement(dicomSource, queryParam.Key, paramValue);
                }

                var results = doQuery(QueryService, dicomSource, request); //TODO: move configuration params into their own object

                if (MultipartResponseHelper.IsMultiPartRequest(request))
                {
                    response = CreateMultipartResponse(request, results.Result);
                }
                else
                {
                    response = CreateJsonResponse(results.Result);
                }

                AddResponseHeaders(request, dicomSource, response, results);

                return(response);
            }

            return(null);
        }
Esempio n. 13
0
        public HttpResponseMessage SearchForStudies
        (
            IQidoRequestModel request
        )
        {
            return(SearchForDicomEntity(request,
                                        DefaultDicomQueryElements.GetDefaultStudyQuery(),
                                        delegate
                                        (
                                            IObjectArchieveQueryService queryService,
                                            fo.DicomDataset dicomRequest,
                                            IQidoRequestModel qidoRequest
                                        )
            {
                IQueryOptions queryOptions = GetQueryOptions(qidoRequest);

                return queryService.FindStudies(dicomRequest, queryOptions);
            }));
        }
Esempio n. 14
0
        private HttpResponseMessage SearchForDicomEntity
        (
            IQidoRequestModel request,
            fo.DicomDataset dicomSource,
            DoQueryDelegate doQuery
        )
        {
            if (null != request.Query)
            {
                var matchingParams = request.Query.MatchingElements;
                var includeParams  = request.Query.IncludeElements;

                foreach (var returnParam in includeParams)
                {
                    InsertDicomElement(dicomSource, returnParam, "");
                }

                foreach (var queryParam in  matchingParams)
                {
                    string paramValue = queryParam.Value;


                    InsertDicomElement(dicomSource, queryParam.Key, paramValue);
                }

                ICollection <fo.DicomDataset> results = doQuery(QueryService, dicomSource, request);  //TODO: move configuration params into their own object

                if (MultipartResponseHelper.IsMultiPartRequest(request))
                {
                    if (MultipartResponseHelper.GetSubMediaType(request.AcceptHeader.FirstOrDefault( )) == MimeMediaTypes.xmlDicom)
                    {
                        HttpResponseMessage response;
                        MultipartContent    multiContent;


                        response     = new HttpResponseMessage( );
                        multiContent = new MultipartContent("related", MultipartResponseHelper.DicomDataBoundary);

                        response.Content = multiContent;

                        foreach (var result in results)
                        {
                            XmlDicomConverter converter = new XmlDicomConverter( );

                            MultipartResponseHelper.AddMultipartContent(multiContent,
                                                                        new WadoResponse(new MemoryStream(Encoding.ASCII.GetBytes(converter.Convert(result))),
                                                                                         MimeMediaTypes.xmlDicom));
                        }

                        multiContent.Headers.ContentType.Parameters.Add(new System.Net.Http.Headers.NameValueHeaderValue("type",
                                                                                                                         "\"" + MimeMediaTypes.xmlDicom + "\""));

                        return(response);
                    }
                    else
                    {
                        return(new HttpResponseMessage(System.Net.HttpStatusCode.BadRequest));
                    }
                }
                else
                {
                    StringBuilder jsonReturn = new StringBuilder("[");

                    JsonDicomConverter converter = new JsonDicomConverter( )
                    {
                        IncludeEmptyElements = true
                    };

                    foreach (var response in results)
                    {
                        jsonReturn.AppendLine(converter.Convert(response));

                        jsonReturn.Append(",");
                    }

                    if (results.Count > 0)
                    {
                        jsonReturn.Remove(jsonReturn.Length - 1, 1);
                    }

                    jsonReturn.Append("]");

                    return(new HttpResponseMessage(System.Net.HttpStatusCode.OK)
                    {
                        Content = new StringContent(jsonReturn.ToString( ),
                                                    Encoding.UTF8,
                                                    MimeMediaTypes.Json)
                    });
                }
            }

            return(null);
        }
Esempio n. 15
0
        public bool TryParse(HttpRequestMessage request, out IQidoRequestModel result)
        {
            QidoRequestModel wadoReq = new QidoRequestModel( );

            wadoReq.Query = new QidoQuery( );

            wadoReq.AcceptHeader        = request.Headers.Accept;
            wadoReq.AcceptCharsetHeader = request.Headers.AcceptCharset;

            var query = request.RequestUri.ParseQueryString( );

            foreach (var key in query)
            {
                string queryKey = ((string)key).Trim( ).ToLower( );

                switch (queryKey)
                {
                case QidoRequestKeys.FuzzyMatching:
                {
                    bool fuzzy;

                    if (bool.TryParse(query[QidoRequestKeys.FuzzyMatching], out fuzzy))
                    {
                        wadoReq.FuzzyMatching = fuzzy;
                    }
                }
                break;

                case QidoRequestKeys.Limit:
                {
                    int limit;

                    if (int.TryParse(query[QidoRequestKeys.Limit], out limit))
                    {
                        wadoReq.Limit = limit;
                    }
                }
                break;

                case QidoRequestKeys.Offset:
                {
                    int offset;

                    if (int.TryParse(query[QidoRequestKeys.Offset], out offset))
                    {
                        wadoReq.Offset = offset;
                    }
                }
                break;

                case QidoRequestKeys.IncludeField:
                {
                    string includeFields = query[QidoRequestKeys.IncludeField];

                    if (!string.IsNullOrWhiteSpace(includeFields))
                    {
                        wadoReq.Query.IncludeElements.AddRange(includeFields.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries));
                    }
                }
                break;

                default:
                {
                    string matchingQuery = query[queryKey].Trim( );
                    //string[] matchingQueryValues = matchingQuery.Trim ( ).Split ( new char[] {','}, StringSplitOptions.RemoveEmptyEntries ) ;
                    var matchingElements = wadoReq.Query.MatchingElements;

                    //TODO: what if key exists
                    //should return invalid request
                    //foreach ( var matchingParam in matchingQueryValues )
                    {
                        matchingElements.Add(queryKey, matchingQuery);
                    }
                }
                break;
                }
            }

            result = wadoReq;

            return(true);
        }
Esempio n. 16
0
        public virtual bool TryParse(HttpRequestMessage request, ModelBindingContext bindingContext, out IQidoRequestModel result)
        {
            IQidoRequestModel wadoReq = CreateModel( );

            wadoReq.AcceptHeader        = request.Headers.Accept;
            wadoReq.AcceptCharsetHeader = request.Headers.AcceptCharset;

            var query = request.RequestUri.ParseQueryString();

            foreach (var key in query)
            {
                string queryKey = ((string)key).Trim().ToLower();

                if (queryKey == "")
                {
                    continue;
                }

                switch (queryKey)
                {
                case QidoRequestKeys.FuzzyMatching:
                {
                    bool fuzzy;

                    if (bool.TryParse(query[QidoRequestKeys.FuzzyMatching], out fuzzy))
                    {
                        wadoReq.FuzzyMatching = fuzzy;
                    }
                }
                break;

                case QidoRequestKeys.Limit:
                {
                    int limit;

                    if (int.TryParse(query[QidoRequestKeys.Limit], out limit))
                    {
                        wadoReq.Limit = limit;
                    }
                }
                break;

                case QidoRequestKeys.Offset:
                {
                    int offset;

                    if (int.TryParse(query[QidoRequestKeys.Offset], out offset))
                    {
                        wadoReq.Offset = offset;
                    }
                }
                break;

                case QidoRequestKeys.IncludeField:
                {
                    string includeFields = query[QidoRequestKeys.IncludeField];

                    if (!string.IsNullOrWhiteSpace(includeFields))
                    {
                        wadoReq.Query.IncludeElements.AddRange(includeFields.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries));
                    }
                }
                break;

                default:
                {
                    string queryValue = query[queryKey].Trim();


                    if (queryKey.StartsWith("_"))
                    {
                        wadoReq.Query.CustomParameters.Add(queryKey, queryValue);
                    }
                    else
                    {
                        wadoReq.Query.MatchingElements.Add(queryKey, queryValue);
                    }
                }
                break;
                }
            }

            CheckAndFillUids(bindingContext.ValueProvider, wadoReq);

            result = wadoReq;

            return(true);
        }