Exemple #1
0
        public async Task GivenMultipleFrames_WhenRetrieveFrame_ThenServerShouldReturnExpectedContent()
        {
            string studyInstanceUid = TestUidGenerator.Generate();

            DicomFile          dicomFile1    = Samples.CreateRandomDicomFileWithPixelData(studyInstanceUid, frames: 3);
            DicomPixelData     pixelData     = DicomPixelData.Create(dicomFile1.Dataset);
            InstanceIdentifier dicomInstance = dicomFile1.Dataset.ToInstanceIdentifier();

            await InternalStoreAsync(new[] { dicomFile1 });

            using DicomWebAsyncEnumerableResponse <Stream> response = await _client.RetrieveFramesAsync(
                      dicomInstance.StudyInstanceUid,
                      dicomInstance.SeriesInstanceUid,
                      dicomInstance.SopInstanceUid,
                      frames : new[] { 1, 2 },
                      dicomTransferSyntax : "*");

            Stream[] frames = await response.ToArrayAsync();

            Assert.NotNull(frames);
            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
            Assert.Equal(2, frames.Length);
            Assert.Equal(KnownContentTypes.MultipartRelated, response.ContentHeaders.ContentType.MediaType);
            Assert.Equal(pixelData.GetFrame(0).Data, frames[0].ToByteArray());
            Assert.Equal(pixelData.GetFrame(1).Data, frames[1].ToByteArray());
        }
Exemple #2
0
        private async Task <(InstanceIdentifier, DicomFile)> CreateAndStoreDicomFile(int numberOfFrames = 0)
        {
            DicomFile dicomFile     = Samples.CreateRandomDicomFileWithPixelData(frames: numberOfFrames);
            var       dicomInstance = dicomFile.Dataset.ToInstanceIdentifier();
            await _instancesManager.StoreAsync(new[] { dicomFile });

            return(dicomInstance, dicomFile);
        }
Exemple #3
0
        public async Task GivenRetrieveRequestForFrame_WhenResourceIsFound_ThenAuditLogEntriesShouldBeCreated()
        {
            DicomFile dicomFile     = Samples.CreateRandomDicomFileWithPixelData(frames: 1);
            var       dicomInstance = dicomFile.Dataset.ToInstanceIdentifier();
            await _client.StoreAsync(new[] { dicomFile }, dicomInstance.StudyInstanceUid);

            await ExecuteAndValidate(
                () => _client.RetrieveFramesAsync(dicomInstance.StudyInstanceUid, dicomInstance.SeriesInstanceUid, dicomInstance.SopInstanceUid, frames: new int[] { 1 }),
                AuditEventSubType.Retrieve,
                $"studies/{dicomInstance.StudyInstanceUid}/series/{dicomInstance.SeriesInstanceUid}/instances/{dicomInstance.SopInstanceUid}/frames/1",
                HttpStatusCode.OK);
        }
Exemple #4
0
        public async Task GivenPostDicomRequest_WithAReadOnlyToken_ReturnUnauthorized()
        {
            if (AuthenticationSettings.SecurityEnabled)
            {
                DicomFile dicomFile     = Samples.CreateRandomDicomFileWithPixelData(frames: 1);
                var       dicomInstance = dicomFile.Dataset.ToInstanceIdentifier();

                IDicomWebClient   client    = _fixture.GetDicomWebClient(TestApplications.GlobalAdminServicePrincipal, TestUsers.User1);
                DicomWebException exception = await Assert.ThrowsAsync <DicomWebException>(
                    () => client.StoreAsync(new[] { dicomFile }, dicomInstance.StudyInstanceUid));

                Assert.Equal(HttpStatusCode.Forbidden, exception.StatusCode);
            }
        }
Exemple #5
0
        /* private static void ProcessMessageWithInstanceReference(byte[] message, ILogger log)
         * {
         *  // Get a reference to a blob named "sample-file"
         *  CloudBlob blob = container.GetBlobReference(Encoding.UTF8.GetString(message));
         *
         *  // Read Blob
         *  Stream stream = blob.OpenRead();
         *  DicomFile dicomFile = DicomFile.Open(stream);
         *
         *  System.Diagnostics.Trace.WriteLine(ToInstanceIdentifier(dicomFile.Dataset).ToString());
         *  log.LogInformation(ToInstanceIdentifier(dicomFile.Dataset).ToString());
         *
         *  StoreRetrievedData(dicomFile);
         *
         *  log.LogInformation("Successfully stored file.");
         * }
         *
         * private static void ProcessMessageWithStudyReference(byte[] message, ILogger log)
         * {
         *  string studyBlobs = Encoding.UTF8.GetString(message);
         *
         *  string[] instances = studyBlobs.Split(',');
         *
         *  foreach (string instance in instances)
         *  {
         *      // Get a reference to a blob named "sample-file"
         *      CloudBlob blob = container.GetBlobReference(instance);
         *
         *      // Read Blob
         *      Stream stream = blob.OpenRead();
         *      DicomFile dicomFile = DicomFile.Open(stream);
         *
         *      System.Diagnostics.Trace.WriteLine(ToInstanceIdentifier(dicomFile.Dataset).ToString());
         *      log.LogInformation(ToInstanceIdentifier(dicomFile.Dataset).ToString());
         *
         *      // StoreRetrievedData(dicomFile);
         *
         *      log.LogInformation("Successfully stored file.");
         *  }
         * } */

        private static void ProcessMessageWithPreGeneratedData(byte[] message)
        {
            PatientInstance pI = JsonSerializer.Deserialize <PatientInstance>(Encoding.UTF8.GetString(message));

            // 400, 400, 100 - 16MB
            // 100, 100, 100 - 1MB
            // 100, 100, 50 - 0.5MB
            DicomFile dicomFile = Samples.CreateRandomDicomFileWithPixelData(
                pI,
                rows: 100,
                columns: 100,
                frames: 50);

            StoreRetrievedData(dicomFile);
        }
        public async Task GivenInstanceWithFrames_WhenRetrieveRequestForFramesInInstanceWithSupportedTransferSyntax_ThenServerShouldReturnRequestedFrames(string transferSyntaxUid)
        {
            var       studyInstanceUid = TestUidGenerator.Generate();
            DicomFile dicomFile1       = Samples.CreateRandomDicomFileWithPixelData(studyInstanceUid, frames: 2);
            var       dicomInstance    = dicomFile1.Dataset.ToInstanceIdentifier();
            await _client.StoreAsync(new[] { dicomFile1 }, studyInstanceUid);

            DicomWebResponse <IReadOnlyList <Stream> > frames = await _client.RetrieveFramesAsync(dicomInstance.StudyInstanceUid, dicomInstance.SeriesInstanceUid, dicomInstance.SopInstanceUid, frames : new[] { 1, 2 }, dicomTransferSyntax : transferSyntaxUid);

            Assert.NotNull(frames);
            Assert.Equal(HttpStatusCode.OK, frames.StatusCode);
            Assert.Equal(2, frames.Value.Count);
            Assert.Equal(KnownContentTypes.MultipartRelated, frames.Content.Headers.ContentType.MediaType);
            AssertPixelDataEqual(DicomPixelData.Create(dicomFile1.Dataset).GetFrame(0), frames.Value[0]);
            AssertPixelDataEqual(DicomPixelData.Create(dicomFile1.Dataset).GetFrame(1), frames.Value[1]);
        }
Exemple #7
0
        private static async Task Stow(Message message, CancellationToken token)
        {
            PatientInstance pI = JsonSerializer.Deserialize <PatientInstance>(Encoding.UTF8.GetString(message.Body));

            // 400, 400, 100 - 16MB
            // 100, 100, 100 - 1MB
            // 100, 100, 50 - 0.5MB
            DicomFile dicomFile = Samples.CreateRandomDicomFileWithPixelData(
                pI,
                rows: 100,
                columns: 100,
                frames: 50);

            DicomWebResponse <DicomDataset> response = await client.StoreAsync(new List <DicomFile>() { dicomFile }, cancellationToken : token);

            int statusCode = (int)response.StatusCode;

            if (statusCode != 409 && statusCode < 200 && statusCode > 299)
            {
                throw new HttpRequestException("Stow operation failed", null, response.StatusCode);
            }

            return;
        }