public QueuedImage(IMessageHeader header, ulong _tag, DicomFileMessage dicomFileMessage, DicomDataset dataset)
{
Header = header;
tag = _tag;
DicomFileMessage = dicomFileMessage;
DicomDataset = dataset;
}
public void TestEquals_DicomFileMessage()
{
var msg1 = new DicomFileMessage();
var msg2 = new DicomFileMessage();
Assert.AreEqual(msg1, msg2);
Assert.AreEqual(msg1.GetHashCode(), msg2.GetHashCode());
msg1.NationalPACSAccessionNumber = "500";
msg2.NationalPACSAccessionNumber = "500";
Assert.AreEqual(msg1, msg2);
Assert.AreEqual(msg1.GetHashCode(), msg2.GetHashCode());
msg1.NationalPACSAccessionNumber = "999";
Assert.AreNotEqual(msg1, msg2);
Assert.AreNotEqual(msg1.GetHashCode(), msg2.GetHashCode());
msg1.NationalPACSAccessionNumber = "500";
msg1.DicomDataset = "jsonified string";
msg2.DicomDataset = "jsonified string";
Assert.AreEqual(msg1, msg2);
Assert.AreEqual(msg1.GetHashCode(), msg2.GetHashCode());
}
public void TestLargeDocumentSplitOk()
{
GlobalOptions options = MongoDbPopulatorTestHelper.GetNewMongoDbPopulatorOptions();
options.MongoDbPopulatorOptions.MongoDbFlushTime = int.MaxValue / 1000;
var adapter = new MongoDbAdapter("ImageProcessor", options.MongoDatabases.ExtractionStoreOptions, "largeDocumentTest");
var processor = new ImageMessageProcessor(options.MongoDbPopulatorOptions, adapter, 2, null);
var mockModel = Mock.Of <IModel>();
processor.Model = mockModel;
var dataset = new DicomDataset
{
new DicomUnlimitedText(DicomTag.SelectorUTValue, new string('x', 15 * 1024 * 1024))
};
var largeMessage = new DicomFileMessage
{
SeriesInstanceUID = "",
StudyInstanceUID = "",
SOPInstanceUID = "",
NationalPACSAccessionNumber = "",
DicomFilePath = "",
DicomDataset = DicomTypeTranslater.SerializeDatasetToJson(dataset)
};
processor.AddToWriteQueue(largeMessage, new MessageHeader(), 1);
processor.AddToWriteQueue(largeMessage, new MessageHeader(), 2);
}
public void SetupSuite()
{
Globals = GetNewMongoDbPopulatorOptions();
_mongoTestClient = MongoClientHelpers.GetMongoClient(Globals.MongoDatabases.DicomStoreOptions, "MongoDbPopulatorTests");
_mongoTestClient.DropDatabase(TestDbName);
TestDatabase = _mongoTestClient.GetDatabase(TestDbName);
Globals.MongoDbPopulatorOptions.SeriesQueueConsumerOptions = new ConsumerOptions()
{
QueueName = "TEST.SeriesQueue",
QoSPrefetchCount = 5,
AutoAck = false
};
Globals.MongoDbPopulatorOptions.ImageQueueConsumerOptions = new ConsumerOptions()
{
QueueName = "TEST.MongoImageQueue",
QoSPrefetchCount = 50,
AutoAck = false
};
var dataset = new DicomDataset
{
new DicomUniqueIdentifier(DicomTag.SOPInstanceUID, "1.2.3.4"),
new DicomCodeString(DicomTag.Modality, "SR")
};
string serialized = DicomTypeTranslater.SerializeDatasetToJson(dataset);
TestImageMessage = new DicomFileMessage
{
DicomFilePath = "Path/To/File",
NationalPACSAccessionNumber = "123",
SeriesInstanceUID = "TestSeriesInstanceUID",
StudyInstanceUID = "TestStudyInstanceUID",
SOPInstanceUID = "TestSOPInstanceUID",
DicomDataset = serialized
};
TestSeriesMessage = new SeriesMessage
{
DirectoryPath = "Path/To/Series",
ImagesInSeries = 123,
NationalPACSAccessionNumber = "123",
SeriesInstanceUID = "TestSeriesInstanceUID",
StudyInstanceUID = "TestStudyInstanceUID",
DicomDataset = serialized
};
}
private DicomFileMessage GetTestDicomFileMessage(Test testCase = Test.Normal, int numberOfRandomTagsPerDicom = 0)
{
var msg = new DicomFileMessage()
{
DicomFilePath = "Path/To/The/File.dcm",
NationalPACSAccessionNumber = "1234",
SOPInstanceUID = "1.2.3.4",
SeriesInstanceUID = "1.2.3.4",
StudyInstanceUID = "1.2.3.4",
};
DicomDataset ds;
Random r = new Random(123);
using (var generator = new DicomDataGenerator(r, null, "CT"))
ds = generator.GenerateTestDataset(new Person(r), r);
ds.AddOrUpdate(DicomTag.AccessionNumber, "1234");
ds.AddOrUpdate(DicomTag.SOPInstanceUID, "1.2.3.4");
ds.AddOrUpdate(DicomTag.SeriesInstanceUID, "1.2.3.4");
ds.AddOrUpdate(DicomTag.StudyInstanceUID, "1.2.3.4");
switch (testCase)
{
case Test.Normal:
ds.AddOrUpdate(DicomTag.PatientID, "010101");
break;
case Test.NoPatientTag:
ds.Remove(DicomTag.PatientID);
break;
case Test.EmptyInPatientTag:
ds.AddOrUpdate(DicomTag.PatientID, string.Empty);
break;
case Test.ProperlyFormatedChi:
ds.AddOrUpdate(DicomTag.PatientID, "0101010101");
break;
default:
throw new ArgumentOutOfRangeException("testCase");
}
msg.DicomDataset = DicomTypeTranslater.SerializeDatasetToJson(ds);
return(msg);
}
private DicomFileMessage GetFileMessageForDataset(DicomDataset dicomDataset)
{
var root = TestContext.CurrentContext.TestDirectory;
var f = Path.GetRandomFileName();
var msg = new DicomFileMessage(root, Path.Combine(root, f + ".dcm"));
msg.NationalPACSAccessionNumber = "ABC";
msg.SeriesInstanceUID = dicomDataset.GetString(DicomTag.SeriesInstanceUID);
msg.StudyInstanceUID = dicomDataset.GetString(DicomTag.StudyInstanceUID);
msg.SOPInstanceUID = dicomDataset.GetString(DicomTag.SOPInstanceUID);
msg.DicomDataset = DicomTypeTranslater.SerializeDatasetToJson(dicomDataset);
return(msg);
}
public DicomFileMessage GetDicomFileMessage(DicomDataset ds, string fileSystemRoot, string file)
{
var toReturn = new DicomFileMessage(fileSystemRoot, file);
toReturn.NationalPACSAccessionNumber = "999";
toReturn.StudyInstanceUID = "999";
toReturn.SeriesInstanceUID = "999";
toReturn.SOPInstanceUID = "999";
ds.Remove(DicomTag.PixelData);
toReturn.DicomDataset = DicomTypeTranslater.SerializeDatasetToJson(ds);
return(toReturn);
}
public void ProcessDocument(BsonDocument document)
{
string documentId = document["_id"].ToString();
var headerDoc = document["header"] as BsonDocument;
if (headerDoc == null)
{
LogUnprocessedDocument(documentId, new ApplicationException("Document did not contain a header field"));
return;
}
var message = new DicomFileMessage
{
NationalPACSAccessionNumber = AccNoOrNull(headerDoc["NationalPACSAccessionNumber"]),
DicomFilePath = (string)headerDoc["DicomFilePath"],
DicomFileSize = headerDoc.Contains("DicomFileSize") ? (long)headerDoc["DicomFileSize"] : -1
};
try
{
// Rebuild the dataset from the document, then serialize it to JSON to send
DicomDataset ds = DicomTypeTranslaterWriter.BuildDicomDataset(document);
message.DicomDataset = DicomTypeTranslater.SerializeDatasetToJson(ds);
// Add the header information
message.StudyInstanceUID = ds.GetValue <string>(DicomTag.StudyInstanceUID, 0);
message.SeriesInstanceUID = ds.GetValue <string>(DicomTag.SeriesInstanceUID, 0);
message.SOPInstanceUID = ds.GetValue <string>(DicomTag.SOPInstanceUID, 0);
}
catch (Exception e)
{
LogUnprocessedDocument(documentId, e);
return;
}
if (!message.VerifyPopulated())
{
LogUnprocessedDocument(documentId, new ApplicationException("Message was not valid"));
return;
}
IMessageHeader header = MongoDocumentHeaders.RebuildMessageHeader(headerDoc["MessageHeader"].AsBsonDocument);
lock (_oBufferLock)
_messageBuffer.Add(new Tuple <DicomFileMessage, IMessageHeader>(message, header));
}
/// <summary>
/// Generate a header for an image document
/// </summary>
/// <param name="message"></param>
/// <param name="header"></param>
/// <returns></returns>
public static BsonDocument ImageDocumentHeader(DicomFileMessage message, IMessageHeader header)
{
return(new BsonDocument
{
{ "DicomFilePath", message.DicomFilePath },
{ "DicomFileSize", message.DicomFileSize },
{ "NationalPACSAccessionNumber", AccessionNoOrNull(message.NationalPACSAccessionNumber) },
{ "MessageHeader", new BsonDocument
{
{ "MessageGuid", header.MessageGuid.ToString() },
{ "ProducerProcessID", header.ProducerProcessID },
{ "ProducerExecutableName", header.ProducerExecutableName },
{ "Parents", string.Join(MessageHeader.Splitter, header.Parents) },
{ "OriginalPublishTimestamp", header.OriginalPublishTimestamp }
} }
});
}
public DicomFileMessage GetDicomFileMessage(string fileSystemRoot, FileInfo fi)
{
var toReturn = new DicomFileMessage(fileSystemRoot, fi);
toReturn.NationalPACSAccessionNumber = "999";
toReturn.StudyInstanceUID = "999";
toReturn.SeriesInstanceUID = "999";
toReturn.SOPInstanceUID = "999";
toReturn.DicomFileSize = fi.Length;
var ds = DicomFile.Open(fi.FullName).Dataset;
ds.Remove(DicomTag.PixelData);
toReturn.DicomDataset = DicomTypeTranslater.SerializeDatasetToJson(ds);
return(toReturn);
}
public void TestLargeMessageNack()
{
GlobalOptions options = MongoDbPopulatorTestHelper.GetNewMongoDbPopulatorOptions();
options.MongoDbPopulatorOptions.MongoDbFlushTime = int.MaxValue / 1000;
var adapter = new MongoDbAdapter("ImageProcessor", options.MongoDatabases.ExtractionStoreOptions, "largeDocumentTest");
var processor = new ImageMessageProcessor(options.MongoDbPopulatorOptions, adapter, 1, null);
var mockModel = Mock.Of <IModel>();
processor.Model = mockModel;
var dataset = new DicomDataset
{
new DicomUnlimitedText(DicomTag.SelectorUTValue, new string('x', 16 * 1024 * 1024))
};
string json = DicomTypeTranslater.SerializeDatasetToJson(dataset);
var largeMessage = new DicomFileMessage
{
SeriesInstanceUID = "",
StudyInstanceUID = "",
SOPInstanceUID = "",
NationalPACSAccessionNumber = "",
DicomFilePath = "",
DicomDataset = json
};
Assert.Throws <ApplicationException>(() => processor.AddToWriteQueue(largeMessage, new MessageHeader(), 1));
dataset = new DicomDataset
{
// Should be ok, getting close to the threshold
new DicomUnlimitedText(DicomTag.SelectorUTValue, new string('x', 15 * 1024 * 1024 + 512))
};
json = DicomTypeTranslater.SerializeDatasetToJson(dataset);
largeMessage.DicomDataset = json;
processor.AddToWriteQueue(largeMessage, new MessageHeader(), 2);
Assert.True(processor.AckCount == 1);
}
public void Test_DicomFileProcessor_ProcessDocument_NullAccNo()
{
var processor = new DicomFileProcessor(new DicomReprocessorOptions(), null, null);
BsonDocument datasetDoc = DicomTypeTranslaterReader.BuildBsonDocument(new DicomDataset());
var msg = new DicomFileMessage
{
DicomFilePath = "foo",
DicomFileSize = 123,
NationalPACSAccessionNumber = null,
};
datasetDoc.Add("_id", "foo");
BsonDocument bsonHeader = MongoDocumentHeaders.ImageDocumentHeader(msg, new MessageHeader());
BsonDocument document = new BsonDocument()
.Add("header", bsonHeader)
.AddRange(datasetDoc);
processor.ProcessDocument(document);
}
public void ImageDocumentHeader_HasCorrectHeaders()
{
var msg = new DicomFileMessage
{
DicomFilePath = "path/to/file.dcm",
NationalPACSAccessionNumber = "1234"
};
string parents = $"{Guid.NewGuid().ToString()}->{Guid.NewGuid().ToString()}";
var headers = new Dictionary <string, object>
{
{ "MessageGuid", Guid.NewGuid().ToString() },
{ "ProducerProcessID", 1234 },
{ "ProducerExecutableName", "MongoDocumentHeadersTests" },
{ "Parents", parents },
{ "OriginalPublishTimestamp", MessageHeader.UnixTimeNow() }
};
var header = new MessageHeader(headers);
BsonDocument bsonImageHeader = MongoDocumentHeaders.ImageDocumentHeader(msg, header);
var expected = new BsonDocument
{
{ "DicomFilePath", msg.DicomFilePath },
{ "DicomFileSize", msg.DicomFileSize },
{ "NationalPACSAccessionNumber", msg.NationalPACSAccessionNumber },
{ "MessageHeader", new BsonDocument
{
{ "MessageGuid", header.MessageGuid.ToString() },
{ "ProducerProcessID", header.ProducerProcessID },
{ "ProducerExecutableName", header.ProducerExecutableName },
{ "Parents", string.Join(MessageHeader.Splitter, header.Parents) },
{ "OriginalPublishTimestamp", header.OriginalPublishTimestamp }
} }
};
Assert.AreEqual(expected, bsonImageHeader);
}
public void ImageProcessor_FailInModalityBatch_AcksWrittenDocuments()
{
_testOptions.MongoDbPopulatorOptions.FailedWriteLimit = 1;
_testOptions.MongoDbPopulatorOptions.MongoDbFlushTime = int.MaxValue / 1000;
var testModalities = new[] { "MR", "MR", "MR", "SR", "SR" };
var testAdapter = new MongoTestAdapter();
var processor = new ImageMessageProcessor(_testOptions.MongoDbPopulatorOptions, testAdapter, testModalities.Length + 1, null);
var mockModel = new Mock <IModel>();
mockModel.Setup(x => x.BasicAck(It.Is <ulong>(y => y == ulong.MaxValue), It.IsAny <bool>()))
.Callback(() => throw new Exception("BasicAck called with delivery tag for CT message"));
processor.Model = mockModel.Object;
var ds = new DicomDataset();
var msg = new DicomFileMessage
{
DicomFilePath = "",
NationalPACSAccessionNumber = ""
};
for (var i = 0; i < testModalities.Length; ++i)
{
string modality = testModalities[i];
ds.AddOrUpdate(DicomTag.Modality, modality);
msg.DicomDataset = DicomTypeTranslater.SerializeDatasetToJson(ds);
processor.AddToWriteQueue(msg, null, (ulong)i);
}
ds.AddOrUpdate(DicomTag.Modality, "CT");
msg.DicomDataset = DicomTypeTranslater.SerializeDatasetToJson(ds);
Assert.Throws <ApplicationException>(() => processor.AddToWriteQueue(msg, new MessageHeader(), ulong.MaxValue));
Assert.AreEqual(5, processor.AckCount);
}
private static void ValidateHeader(DicomFileMessage message, MessageHeader header, BsonDocument docHeader)
{
Assert.AreEqual(message.DicomFilePath, docHeader["DicomFilePath"].AsString);
Assert.AreEqual(message.NationalPACSAccessionNumber, docHeader["NationalPACSAccessionNumber"].AsString);
BsonElement element;
Assert.True(docHeader.TryGetElement("MessageHeader", out element));
var messageHeaderDoc = (BsonDocument)element.Value;
Assert.NotNull(messageHeaderDoc);
Assert.AreEqual(header.ProducerProcessID, messageHeaderDoc["ProducerProcessID"].AsInt32);
Assert.AreEqual(header.ProducerExecutableName, messageHeaderDoc["ProducerExecutableName"].AsString);
Assert.AreEqual(header.OriginalPublishTimestamp, messageHeaderDoc["OriginalPublishTimestamp"].AsInt64);
Assert.True(messageHeaderDoc.TryGetElement("Parents", out element));
string parentsString = element.Value.AsString;
Assert.False(string.IsNullOrWhiteSpace(parentsString));
Assert.AreEqual(Guid.NewGuid().ToString().Length, parentsString.Length);
}
private void Validate(DicomFileMessage message, MessageHeader header, BsonDocument document)
{
Assert.False(message == null || document == null);
BsonElement element;
Assert.True(document.TryGetElement("header", out element));
var docHeader = (BsonDocument)element.Value;
Assert.AreEqual(_imageMessageProps.Count - 3, docHeader.ElementCount);
ValidateHeader(message, header, docHeader);
DicomDataset dataset = DicomTypeTranslater.DeserializeJsonToDataset(message.DicomDataset);
Assert.NotNull(dataset);
BsonDocument datasetDocument = DicomTypeTranslaterReader.BuildBsonDocument(dataset);
document.Remove("_id");
document.Remove("header");
Assert.AreEqual(datasetDocument, document);
}
public void RebuildMessageHeader_HasCorrectHeaders()
{
var msg = new DicomFileMessage
{
DicomFilePath = "path/to/file.dcm",
NationalPACSAccessionNumber = "1234"
};
string parents = $"{Guid.NewGuid().ToString()}->{Guid.NewGuid().ToString()}";
var headers = new Dictionary <string, object>
{
{ "MessageGuid", Guid.NewGuid().ToString() },
{ "ProducerProcessID", 1234 },
{ "ProducerExecutableName", "MongoDocumentHeadersTests" },
{ "Parents", parents },
{ "OriginalPublishTimestamp", MessageHeader.UnixTimeNow() }
};
var header = new MessageHeader(headers);
BsonDocument bsonImageHeader = MongoDocumentHeaders.ImageDocumentHeader(msg, header);
IMessageHeader rebuiltHeader = MongoDocumentHeaders.RebuildMessageHeader(bsonImageHeader["MessageHeader"].AsBsonDocument);
Assert.AreEqual(header, rebuiltHeader);
}
private void AssertDicomFileMessageHasPatientID(DicomFileMessage msg, string patientId)
{
var newDs = DicomTypeTranslater.DeserializeJsonToDataset(msg.DicomDataset);
Assert.AreEqual(newDs.GetValue <string>(DicomTag.PatientID, 0), patientId);
}
