private async Task <List <string> > QueryInstances(RemoteConnection server, string PatientID, string StudyInstanceUID, string SeriesInstanceUID)
{
//study/series should be provided
if (string.IsNullOrEmpty(StudyInstanceUID) || string.IsNullOrEmpty(SeriesInstanceUID))
{
throw new ArgumentNullException("StudyInstanceUID or SeriesInstanceUID");
}
var query = new QueryOptions()
{
SeriesOptions = new SeriesQueryOptions()
{
SeriesInstanceUID = SeriesInstanceUID
},
StudiesOptions = new StudiesQueryOptions()
{
StudyInstanceUID = StudyInstanceUID
},
PatientsOptions = new PatientsQueryOptions()
{
PatientID = PatientID
}
};
var instances = await _query.FindInstances(RemoteConnectionFactory.Config(server as WadoConnection), query);
var SOPInstanceUIDList = new List <string>();
foreach (var instance in instances)
{
SOPInstanceUIDList.Add(instance.SOPInstanceUID);
}
return(SOPInstanceUIDList);
}
public async Task <Stream> GetSeriesThumbnail(string authenticationCookie, string studyInstanceUID, string seriesInstanceUID, string mimeType, int bitsPerPixel, int qualityFactor, int width, int height)
{
var userName = AuthHandler.Authorize(authenticationCookie, PermissionsTable.Instance.CanRetrieve);
if (string.IsNullOrEmpty(mimeType))
{
mimeType = SupportedMimeTypes.JPG;
if (qualityFactor < 2)
{
qualityFactor = 2;
}
}
var retrieve_query = new QueryOptions();
retrieve_query.StudiesOptions = new StudiesQueryOptions();
retrieve_query.StudiesOptions.StudyInstanceUID = studyInstanceUID;
retrieve_query.SeriesOptions = new SeriesQueryOptions();
retrieve_query.SeriesOptions.SeriesInstanceUID = seriesInstanceUID;
var config = RemoteConnectionFactory.Config(new WadoConnection()
{
dicomWebRoot = @"http://localhost/WadoService/api/", rs = "wado-rs"
});
return(await _retrieve.Value.RetrieveDatasetRendered(config, retrieve_query, new System.Drawing.Size(width, height)));
//can be supported: mimeType, bitsPerPixel, qualityFactor
}
public async Task <InstanceData[]> FindInstances(string authenticationCookie, RemoteConnection server, ClientConnection client, QueryOptions options)
{
AuthHandler.Authorize(authenticationCookie, PermissionsTable.Instance.CanQueryPACS);
var instances = await _query.FindInstances(RemoteConnectionFactory.Config(server as WadoConnection), options);
return(instances);
}
public ScenarioData(IMessageSerializer messageSerializer)
{
_connectionFactory = new RemoteConnectionFactory(messageSerializer);
_dataPerGraph = LoadDataPerGraph();
var empty = new ScenarioDataPerGraph("empty", _connectionFactory.CreateRemoteConnection("ggraph"),
new Dictionary <string, Vertex>(0), new Dictionary <string, Edge>(), new Dictionary <string, VertexProperty>());
_dataPerGraph.Add("empty", empty);
}
public Task <DownloadInfo[]> GetDownloadInfos([FromBody] dynamic model)
{
return(impl(model).GetDownloadInfos((string)model.authenticationCookie,
RemoteConnectionFactory.Server(model),
(string)model.client,
(string)model.patientID,
(string)model.studyInstanceUID,
(string)model.seriesInstanceUID,
(string)model.sopInstanceUID,
(DownloadStatus)model.status));
}
public Task <DownloadInfo> DownloadImages([FromBody] dynamic model)
{
return(impl(model).DownloadImages((string)model.authenticationCookie,
RemoteConnectionFactory.Server(model),
(string)model.client,
(string)model.patientID,
(string)model.studyInstanceUID,
(string)model.seriesInstanceUID,
(string)model.sopInstanceUID,
ParseTools.ToObject <ExtraOptions>(model.extraOptions)));
}
public async Task <IActionResult> PublishAsync([FromServices] RemoteConnectionFactory remoteConnectionFactory)
{
// This doesn't have the dead lock issue but it makes a new connection every time
var connection = await remoteConnectionFactory.ConnectAsync();
await connection.PublishAsync("group", "hello");
// Dispose the connection we created
await connection.DisposeAsync();
return(Accepted());
}
private IPacsQueryHandler impl(dynamic model)
{
var server = RemoteConnectionFactory.BaseServer(model);
if (RemoteConnectionFactory.IsWADO(server))
{
return(_wimpl);
}
else
{
return(_impl);
}
}
public async Task <DownloadInfo> DownloadImages
(
string authenticationCookie,
RemoteConnection server,
string client,
string PatientID,
string StudyInstanceUID,
string SeriesInstanceUID,
string SOPInstanceUID,
ExtraOptions extraOptions
)
{
try
{
var userName = AuthHandler.Authorize(authenticationCookie, PermissionsTable.Instance.CanDownloadImages);
var queries = await Query(server, PatientID, StudyInstanceUID, SeriesInstanceUID, SOPInstanceUID);
foreach (var query in queries)
{
using (var stream = await _ret.RetrieveDataset(RemoteConnectionFactory.Config(server as WadoConnection), query))
using (var ds = new DicomDataSet())
{
ds.Load(stream, DicomDataSetLoadFlags.None);
_store.DoStore(ds);
}
}
return(new DownloadInfo()
{
Id = "-1",
Status = DownloadStatus.Completed
});
}
catch (Exception e)
{
return(new DownloadInfo()
{
Id = "-1",
Status = DownloadStatus.Error,
ErrorMessage = e.Message
});
}
}
private async Task <List <string> > QuerySeries(RemoteConnection server, string PatientID, string StudyInstanceUID, string SeriesInstanceUID)
{
//study should be provided
if (string.IsNullOrEmpty(StudyInstanceUID))
{
throw new ArgumentNullException("StudyInstanceUID");
}
//figure out series
var SeriesInstanceUIDList = new List <string>();
if (string.IsNullOrEmpty(SeriesInstanceUID))
{
var query = new QueryOptions()
{
StudiesOptions = new StudiesQueryOptions()
{
StudyInstanceUID = StudyInstanceUID
},
PatientsOptions = new PatientsQueryOptions()
{
PatientID = PatientID
}
};
var series = await _query.FindSeries(RemoteConnectionFactory.Config(server as WadoConnection), query);
foreach (var s in series)
{
SeriesInstanceUIDList.Add(s.InstanceUID);
}
}
else
{
SeriesInstanceUIDList.Add(SeriesInstanceUID); //single series specified
}
return(SeriesInstanceUIDList);
}
public GeoshapeDeserializerTests(JanusGraphServerFixture fixture)
{
_connectionFactory = new RemoteConnectionFactory(fixture.Host, fixture.Port);
}
public GraphSONRelationIdentifierSerializerTests(JanusGraphServerFixture fixture)
{
ConnectionFactory = new RemoteConnectionFactory(fixture.Host, fixture.Port);
}
public async Task <SeriesData[]> FindSeries([FromBody] dynamic model)
{
return(await impl(model).FindSeries((string)model.authenticationCookie, RemoteConnectionFactory.Server(model), model.client.ToObject <ClientConnection>(), model.options.ToObject <QueryOptions>()));
}
public async Task <string> VerifyConnection([FromBody] dynamic model)
{
return(await impl(model).VerifyConnection((string)model.authenticationCookie, RemoteConnectionFactory.Server(model), model.client.ToObject <ClientConnection>()));
}
public async Task <DICOMQueryResult> ElectStudyTimeLineInstances([FromBody] dynamic model)
{
return(await impl(model).ElectStudyTimeLineInstances((string)model.authenticationCookie, RemoteConnectionFactory.Server(model), model.client.ToObject <ClientConnection>(), model.options.ToObject <QueryOptions>()));
}
public GraphBinaryRelationIdentifierSerializerTests(JanusGraphServerFixture fixture)
{
ConnectionFactory = new RemoteConnectionFactory(fixture.Host, fixture.Port,
new GraphBinaryMessageSerializer(JanusGraphTypeSerializerRegistry.Instance));
}
