public int GetStudyCount(StudyRootStudyIdentifier criteria)
{
return Real.GetStudyCount(new GetStudyCountRequest
{
Criteria = new StudyEntry{Study = criteria}
}).StudyCount;
}
public void TestSameStudyMultipleServers()
{
var study1Local = CreateStudyIdentifier("1", "20130810", "112300", LocalAeTitle);
var study2Local = CreateStudyIdentifier("2", "20130901", "122400", LocalAeTitle);
var study1Streaming = new StudyRootStudyIdentifier(study1Local){RetrieveAeTitle = StreamingAeTitle};
var study1NonStreaming = new StudyRootStudyIdentifier(study1Local){RetrieveAeTitle = NonStreaminAeTitle};
var study1UnknownServer = new StudyRootStudyIdentifier(study1Local) { RetrieveAeTitle = null};
var study2Streaming = new StudyRootStudyIdentifier(study2Local) { RetrieveAeTitle = StreamingAeTitle };
var study2NonStreaming = new StudyRootStudyIdentifier(study2Local) { RetrieveAeTitle = NonStreaminAeTitle };
var study2UnknownServer = new StudyRootStudyIdentifier(study2Local) { RetrieveAeTitle = null };
var identifiers = new List<StudyRootStudyIdentifier>
{
study1UnknownServer, study2NonStreaming, study1NonStreaming,
study1Streaming, study2Local,
study1Local, study2UnknownServer, study2Streaming
};
foreach (var identifier in identifiers)
identifier.ResolveServer(false);
identifiers.Sort(new StudyDateTimeComparer());
Assert.AreEqual(identifiers[0], study2Local);
Assert.AreEqual(identifiers[1], study2Streaming);
Assert.AreEqual(identifiers[2], study2NonStreaming);
Assert.AreEqual(identifiers[3], study2UnknownServer);
Assert.AreEqual(identifiers[4], study1Local);
Assert.AreEqual(identifiers[5], study1Streaming);
Assert.AreEqual(identifiers[6], study1NonStreaming);
Assert.AreEqual(identifiers[7], study1UnknownServer);
}
private static StudyRootStudyIdentifier CreateStudyIdentifier(string uid, string date, string time)
{
StudyRootStudyIdentifier id = new StudyRootStudyIdentifier();
id.StudyInstanceUid = uid;
id.StudyDate = date;
id.StudyTime = time;
return id;
}
/// <summary>
/// Performs a STUDY level query.
/// </summary>
/// <exception cref="FaultException{TDetail}">Thrown when some part of the data in the request is poorly formatted.</exception>
/// <exception cref="FaultException{QueryFailedFault}">Thrown when the query fails.</exception>
public IList<StudyRootStudyIdentifier> StudyQuery(StudyRootStudyIdentifier queryCriteria)
{
var results = _real.StudyQuery(queryCriteria);
AuditHelper.LogQueryIssued(_remoteServer.AETitle, _remoteServer.ScpParameters.HostName, EventSource.CurrentUser,
EventResult.Success, SopClass.StudyRootQueryRetrieveInformationModelFindUid,
queryCriteria.ToDicomAttributeCollection());
return results;
}
public IList<StudyRootStudyIdentifier> LocateStudyByAccessionNumber(string accessionNumber, out LocateFailureInfo[] failures)
{
Platform.CheckForEmptyString(accessionNumber, "accessionNumber");
if (accessionNumber.Contains("*") || accessionNumber.Contains("?"))
throw new ArgumentException("Accession Number cannot contain wildcard characters.");
var criteria = new StudyRootStudyIdentifier {AccessionNumber = accessionNumber};
var result = LocateStudies(new LocateStudiesRequest {Criteria = criteria});
failures = result.Failures.ToArray();
return result.Studies;
}
public void SelectAllStudies()
{
using (var context = CreateContext())
{
var query = context.GetStudyStoreQuery();
var criteria = new StudyRootStudyIdentifier();
var results = query.StudyQuery(criteria);
var realCount = context.GetStudyBroker().GetStudyCount();
Assert.AreEqual(realCount, results.Count);
}
}
public IList<StudyRootStudyIdentifier> StudyQuery(StudyRootStudyIdentifier queryCriteria)
{
var request = new StudyQueryRequest
{
Criteria = queryCriteria,
LocalApplicationEntity = _localAE,
RemoteApplicationEntity = new ApplicationEntity(_remoteAE)
};
var query = new DicomStudyRootQueryApplication();
var result = query.StudyQuery(request);
return result.Results;
}
public void SelectPatientIdEquals()
{
using (var context = CreateContext())
{
var query = context.GetStudyStoreQuery();
var criteria = new StudyRootStudyIdentifier
{
PatientId = "12345678"
};
var results = query.StudyQuery(criteria);
Assert.AreEqual(1, results.Count);
Assert.AreEqual(criteria.PatientId, results[0].PatientId);
}
}
public void TestIsOpenQuery()
{
var identifier = new StudyRootStudyIdentifier();
Assert.IsTrue(identifier.IsOpenQuery());
identifier.RetrieveAeTitle = "Test";
identifier.InstanceAvailability = "Test";
identifier.SpecificCharacterSet = "Test";
Assert.IsTrue(identifier.IsOpenQuery());
identifier.PatientId = "Test";
Assert.IsFalse(identifier.IsOpenQuery());
identifier.PatientId = "";
identifier.PatientsName = "Test";
Assert.IsFalse(identifier.IsOpenQuery());
identifier.PatientId = "T";
identifier.PatientsName = "T";
Assert.IsFalse(identifier.IsOpenQuery());
}
public System.Collections.Generic.IList<StudyRootStudyIdentifier> StudyQuery(StudyRootStudyIdentifier queryCriteria)
{
var criteria = new StudyEntry {Study = queryCriteria};
var result = Real.GetStudyEntries(new GetStudyEntriesRequest {Criteria = criteria});
return result.StudyEntries.Select(e => e.Study).ToList();
}
/// <summary>
/// Performs a STUDY level query.
/// </summary>
/// <exception cref="FaultException{DataValidationFault}">Thrown when some part of the data in the request is poorly formatted.</exception>
/// <exception cref="FaultException{QueryFailedFault}">Thrown when the query fails.</exception>
public IList <StudyRootStudyIdentifier> StudyQuery(StudyRootStudyIdentifier queryCriteria)
{
return(base.Channel.StudyQuery(queryCriteria));
}
/// <summary>
/// Figure out which studies have been deleted and/or updated.
/// </summary>
private void ProcessChangedStudiesAsync(out DateTime? queryStartTime, out List<string> deletedStudyUids, out List<StudyEntry> updatedStudies)
{
deletedStudyUids = new List<string>();
updatedStudies = new List<StudyEntry>();
queryStartTime = null;
DateTime now = DateTime.Now;
var fiveSeconds = TimeSpan.FromSeconds(5);
var rapidChangeInterval = TimeSpan.FromMilliseconds(300);
lock (_syncLock)
{
if (_queryingForUpdates)
return; //Already querying.
//Nothing to query for? Return.
if (_setChangedStudies.Count == 0 || !_lastStudyChangeTime.HasValue)
return;
bool studiesChanging = now - _lastStudyChangeTime.Value < rapidChangeInterval;
if (studiesChanging)
{
//Many DIFFERENT studies are changing in very rapid succession. Delay until it settles down, which usually isn't long.
Platform.Log(LogLevel.Debug, "Studies are still actively changing - delaying update.");
return;
}
if (!_hastenUpdateQuery)
{
bool updatedRecently = _lastUpdateQueryEndTime.HasValue && now - _lastUpdateQueryEndTime < fiveSeconds;
if (updatedRecently)
{
//We just finished an update query less than 5 seconds ago.
Platform.Log(LogLevel.Debug, "Studies were updated within the last 5 seconds - delaying update.");
return;
}
}
//Reset this before the immediate query.
_hastenUpdateQuery = false;
//Add everything to the deleted list.
deletedStudyUids.AddRange(_setChangedStudies.Keys);
_setChangedStudies.Clear();
//We are officially querying for updates.
_queryingForUpdates = true;
}
queryStartTime = now;
string studyUids = DicomStringHelper.GetDicomStringArray(deletedStudyUids);
try
{
var clock = new CodeClock();
clock.Start();
var criteria = new StudyRootStudyIdentifier { StudyInstanceUid = studyUids };
var request = new GetStudyEntriesRequest { Criteria = new StudyEntry { Study = criteria } };
IList<StudyEntry> entries = null;
//We're doing it this way here because it's local only.
Platform.GetService<IStudyStoreQuery>(s => entries = s.GetStudyEntries(request).StudyEntries);
foreach (var entry in entries)
{
//If we got a result back, then it's not deleted.
deletedStudyUids.Remove(entry.Study.StudyInstanceUid);
updatedStudies.Add(entry);
}
clock.Stop();
Platform.Log(LogLevel.Debug, "Study update query took {0}.", clock);
}
catch (Exception e)
{
Platform.Log(LogLevel.Error, e);
}
finally
{
lock (_syncLock)
{
//Finished querying for updates.
_queryingForUpdates = false;
_lastUpdateQueryEndTime = now;
}
}
}
public void SelectPatientIdAndStudyId_Wildcard()
{
using (var context = CreateContext())
{
var query = context.GetStudyStoreQuery();
var criteria = new StudyRootStudyIdentifier
{
PatientId = "*EXAMPLE",
StudyId = "*EXAMPLE"
};
var results = query.StudyQuery(criteria);
Assert.AreEqual(4, results.Count);
}
}
public void SelectPatientIdAndName_Equals()
{
using (var context = CreateContext())
{
var query = context.GetStudyStoreQuery();
var criteria = new StudyRootStudyIdentifier
{
PatientId = "123a56b8",
PatientsName = "MISTER^CT"
};
var results = query.StudyQuery(criteria);
Assert.AreEqual(1, results.Count);
Assert.IsTrue(results.SingleOrDefault(study => study.PatientId == "123a56b8") != null);
}
}
public void SelectPatientIdAndName_Wildcard()
{
using (var context = CreateContext())
{
var query = context.GetStudyStoreQuery();
var criteria = new StudyRootStudyIdentifier
{
PatientId = "*5*",
PatientsName = "MIST*"
};
var results = query.StudyQuery(criteria);
Assert.AreEqual(4, results.Count);
//Throw in an extra.
criteria.AccessionNumber = "*6";
results = query.StudyQuery(criteria);
Assert.AreEqual(1, results.Count);
}
}
public void SelectPatientId_Wildcard()
{
using (var context = CreateContext())
{
var query = context.GetStudyStoreQuery();
var criteria = new StudyRootStudyIdentifier
{
PatientId = "123*"
};
var results = query.StudyQuery(criteria);
Assert.AreEqual(2, results.Count);
Assert.IsTrue(results.SingleOrDefault(study => study.PatientId == "12345678") != null);
Assert.IsTrue(results.SingleOrDefault(study => study.PatientId == "123a56b8") != null);
}
}
/// <summary>
/// Constructor.
/// </summary>
public Viewer(Guid identifier, StudyRootStudyIdentifier primaryStudyIdentifier)
{
Identifier = identifier;
PrimaryStudyIdentifier = primaryStudyIdentifier;
}
public IList<StudyEntry> GetStudyEntries(StudyRootStudyIdentifier criteria)
{
return GetStudyEntries(new StudyEntry {Study = criteria});
}
public override PriorStudyFinderResult FindPriorStudies()
{
_cancel = false;
var results = new Dictionary<string, StudyItem>();
IPatientReconciliationStrategy reconciliationStrategy = new DefaultPatientReconciliationStrategy();
reconciliationStrategy.SetStudyTree(Viewer.StudyTree);
var patientIds = new Dictionary<string, string>();
foreach (Patient patient in Viewer.StudyTree.Patients)
{
if (_cancel)
break;
IPatientData reconciled = reconciliationStrategy.ReconcileSearchCriteria(patient);
patientIds[reconciled.PatientId] = reconciled.PatientId;
}
int failedCount = 0;
int successCount = 0;
foreach (var priorsServer in ServerDirectory.GetPriorsServers(true))
{
if (_cancel)
break;
try
{
using (var bridge = new StudyRootQueryBridge(priorsServer.GetService<IStudyRootQuery>()))
{
foreach (string patientId in patientIds.Keys)
{
var identifier = new StudyRootStudyIdentifier { PatientId = patientId };
IList<StudyRootStudyIdentifier> studies = bridge.StudyQuery(identifier);
Platform.Log(LogLevel.Debug, "Found {0} prior studies on server '{1}'", studies.Count, priorsServer.Name);
foreach (StudyRootStudyIdentifier study in studies)
{
if (_cancel)
break;
//Eliminate false positives right away.
IPatientData reconciled = reconciliationStrategy.ReconcilePatientInformation(study);
if (reconciled == null)
continue;
StudyItem studyItem = ConvertToStudyItem(study);
if (studyItem == null || results.ContainsKey(studyItem.StudyInstanceUid))
continue;
if (!results.ContainsKey(studyItem.StudyInstanceUid))
results[studyItem.StudyInstanceUid] = studyItem;
}
}
}
++successCount;
}
catch (Exception e)
{
++failedCount;
Platform.Log(LogLevel.Error, e, "Failed to query server: {0}", priorsServer.Name);
}
}
if (_cancel)
{
//Just pretend the query never happened.
return new PriorStudyFinderResult(new StudyItemList(), true);
}
if (failedCount > 0)
{
PriorStudyLoaderExceptionPolicy.NotifyFailedQuery();
if (successCount == 0)
throw new Exception("The search for prior studies has failed.");
}
else
{
//Even if success count is zero, we'll still consider it "successful".
PriorStudyLoaderExceptionPolicy.NotifySuccessfulQuery();
}
Platform.Log(LogLevel.Debug, "Found {0} prior studies in total.", results.Count);
return new PriorStudyFinderResult(new StudyItemList(results.Values), failedCount == 0);
}
private static StudyItem ConvertToStudyItem(StudyRootStudyIdentifier study)
{
study.ResolveServer(true);
var item = new StudyItem(study);
if (String.IsNullOrEmpty(item.InstanceAvailability))
item.InstanceAvailability = "ONLINE";
return item;
}
public void SelectEmptyStudyDescription_NoCriteria()
{
using (var context = CreateContext())
{
var query = context.GetStudyStoreQuery();
var criteria = new StudyRootStudyIdentifier
{
StudyDescription = ""
};
//Get all studies back.
var results = query.StudyQuery(criteria);
var realCount = context.GetStudyBroker().GetStudyCount();
Assert.AreEqual(realCount, results.Count);
}
}
public Viewer OpenViewer(StudyRootStudyIdentifier studyRootStudyIdentifier)
{
return OpenViewer(new[] { studyRootStudyIdentifier });
}
public IList<StudyRootStudyIdentifier> LocateStudyByPatientId(string patientId, out LocateFailureInfo[] failures)
{
Platform.CheckForEmptyString(patientId, "patientId");
if (patientId.Contains("*") || patientId.Contains("?"))
throw new ArgumentException("Patient Id cannot contain wildcard characters.");
var criteria = new StudyRootStudyIdentifier {PatientId = patientId};
var result = LocateStudies(new LocateStudiesRequest {Criteria = criteria});
failures = result.Failures.ToArray();
return result.Studies;
}
public IList <StudyRootStudyIdentifier> StudyQuery(StudyRootStudyIdentifier queryCriteria)
{
return(Query <StudyRootStudyIdentifier, StudyRootFindScu>(queryCriteria));
}
public IImageSet BuildImageSet(StudyTree studyTree, out Study study)
{
if (IsRemote)
{
study = null;
//Add only the image set, which essentially makes it a remote study.
var identifier = new StudyRootStudyIdentifier(this, this, new StudyIdentifier())
{
PatientId = ReconciledPatientId ?? PatientId
};
return new ImageSet(new DicomImageSetDescriptor(identifier));
}
study = AddStudy(studyTree);
var studyIdentifier = study.GetIdentifier();
studyIdentifier = new StudyRootStudyIdentifier(studyIdentifier) { PatientId = ReconciledPatientId ?? study.ParentPatient.PatientId };
var imageSet = new ImageSet(new DicomImageSetDescriptor(studyIdentifier));
foreach (var series in study.Series)
{
foreach (var displaySet in DisplaySetFactory.CreateDisplaySets(series))
imageSet.DisplaySets.Add(displaySet);
}
return imageSet;
}
public void SelectStudyDate_Between()
{
using (var context = CreateContext())
{
var query = context.GetStudyStoreQuery();
var criteria = new StudyRootStudyIdentifier
{
StudyDate = "20050915-20111223"
};
var results = query.StudyQuery(criteria);
Assert.AreEqual(4, results.Count);
criteria = new StudyRootStudyIdentifier
{
StudyDate = "20050916-20111223"
};
results = query.StudyQuery(criteria);
Assert.AreEqual(3, results.Count);
criteria = new StudyRootStudyIdentifier
{
StudyDate = "20050915-20111222"
};
results = query.StudyQuery(criteria);
Assert.AreEqual(3, results.Count);
}
}
private IEnumerable<Study> GetStudies(StudyRootStudyIdentifier criteria)
{
return GetStudies(new StudyEntry { Study = criteria });
}
public IList<StudyRootStudyIdentifier> LocateStudyByInstanceUid(IEnumerable<string> studyInstanceUids, out LocateFailureInfo[] failures)
{
var instanceUids = studyInstanceUids.ToArray();
foreach (string studyInstanceUid in instanceUids)
{
Platform.CheckForEmptyString(studyInstanceUid, "studyInstanceUid");
if (studyInstanceUid.Contains("*") || studyInstanceUid.Contains("?"))
throw new ArgumentException("Study Instance Uid cannot contain wildcard characters.");
}
var criteria = new StudyRootStudyIdentifier {StudyInstanceUid = DicomStringHelper.GetDicomStringArray(instanceUids)};
var result = LocateStudies(new LocateStudiesRequest {Criteria = criteria});
failures = result.Failures.ToArray();
return result.Studies;
}
public void SelectStudyTime_Between()
{
using (var context = CreateContext())
{
var query = context.GetStudyStoreQuery();
var criteria = new StudyRootStudyIdentifier
{
StudyTime = "083501-100821"
};
/// TODO (CR Apr 2012): For now, we don't support time queries at all,
/// so the answer is that all studies match.
var results = query.StudyQuery(criteria);
var realCount = context.GetStudyBroker().GetStudyCount();
Assert.AreEqual(realCount, results.Count);
}
}
public IList<StudyRootStudyIdentifier> StudyQuery(StudyRootStudyIdentifier criteria)
{
var entries = GetStudies(criteria);
return entries.Select(e => e.ToStoreEntry().Study).ToList();
}
public void SelectStudyInstanceUid_Single()
{
using (var context = CreateContext())
{
var query = context.GetStudyStoreQuery();
var criteria = new StudyRootStudyIdentifier
{
StudyInstanceUid = "1.3.51.0.7.633918642.633920010109.6339100821"
};
/// TODO (CR Apr 2012): For now, we don't support time queries at all,
/// so the answer is that all studies match.
var results = query.StudyQuery(criteria);
Assert.AreEqual(1, results.Count);
}
}
/// <summary>
/// Compares 2 <see cref="StudyRootStudyIdentifier"/>s.
/// </summary>
public int Compare(StudyRootStudyIdentifier x, StudyRootStudyIdentifier y)
{
return(Compare((StudyIdentifier)x, (StudyIdentifier)y));
}
public void SelectStudyInstanceUid_Multiple()
{
using (var context = CreateContext())
{
var query = context.GetStudyStoreQuery();
var criteria = new StudyRootStudyIdentifier
{
StudyInstanceUid = @"1.3.51.0.7.633918642.633920010109.6339100821\1.3.46.670589.6.1.0.98511171.2001010909203006\1.2.840.113619.2.67.2158294438.15745010109084247.20000"
};
/// TODO (CR Apr 2012): For now, we don't support time queries at all,
/// so the answer is that all studies match.
var results = query.StudyQuery(criteria);
Assert.AreEqual(3, results.Count);
}
}
