ctkXnatSession.cpp 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628
  1. /*=============================================================================
  2. Plugin: org.commontk.xnat
  3. Copyright (c) University College London,
  4. Centre for Medical Image Computing
  5. Licensed under the Apache License, Version 2.0 (the "License");
  6. you may not use this file except in compliance with the License.
  7. You may obtain a copy of the License at
  8. http://www.apache.org/licenses/LICENSE-2.0
  9. Unless required by applicable law or agreed to in writing, software
  10. distributed under the License is distributed on an "AS IS" BASIS,
  11. WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12. See the License for the specific language governing permissions and
  13. limitations under the License.
  14. =============================================================================*/
  15. #include "ctkXnatSession.h"
  16. #include "ctkXnatDataModel.h"
  17. #include "ctkXnatException.h"
  18. #include "ctkXnatExperiment.h"
  19. #include "ctkXnatFile.h"
  20. #include "ctkXnatLoginProfile.h"
  21. #include "ctkXnatObject.h"
  22. #include "ctkXnatProject.h"
  23. #include "ctkXnatReconstruction.h"
  24. #include "ctkXnatReconstructionFolder.h"
  25. #include "ctkXnatReconstructionResource.h"
  26. #include "ctkXnatScan.h"
  27. #include "ctkXnatScanFolder.h"
  28. #include "ctkXnatScanResource.h"
  29. #include "ctkXnatSubject.h"
  30. #include <QDebug>
  31. #include <QScopedPointer>
  32. #include <QStringBuilder>
  33. #include <QNetworkCookie>
  34. #include <QDateTime>
  35. #include <ctkXnatAPI_p.h>
  36. #include <qRestResult.h>
  37. static const char* HEADER_AUTHORIZATION = "Authorization";
  38. static const char* HEADER_USER_AGENT = "User-Agent";
  39. static const char* HEADER_COOKIE = "Cookie";
  40. static QString SERVER_VERSION = "version";
  41. static QString SESSION_EXPIRATION_DATE = "expires";
  42. class ctkXnatSessionPrivate
  43. {
  44. public:
  45. const ctkXnatLoginProfile loginProfile;
  46. QScopedPointer<ctkXnatAPI> xnat;
  47. QScopedPointer<ctkXnatDataModel> dataModel;
  48. QString sessionId;
  49. QMap<QString, QString> sessionProperties;
  50. ctkXnatSession* q;
  51. ctkXnatSessionPrivate(const ctkXnatLoginProfile& loginProfile, ctkXnatSession* q);
  52. ~ctkXnatSessionPrivate();
  53. void throwXnatException(const QString& msg);
  54. void createConnections();
  55. void setDefaultHttpHeaders();
  56. void checkSession() const;
  57. void setSessionProperties();
  58. QDateTime updateExpirationDate(qRestResult* restResult);
  59. void close();
  60. };
  61. ctkXnatSessionPrivate::ctkXnatSessionPrivate(const ctkXnatLoginProfile& loginProfile,
  62. ctkXnatSession* q)
  63. : loginProfile(loginProfile)
  64. , xnat(new ctkXnatAPI())
  65. , q(q)
  66. {
  67. // TODO This is a workaround for connecting to sites with self-signed
  68. // certificate. Should be replaced with something more clever.
  69. xnat->setSuppressSslErrors(true);
  70. createConnections();
  71. }
  72. ctkXnatSessionPrivate::~ctkXnatSessionPrivate()
  73. {
  74. }
  75. void ctkXnatSessionPrivate::throwXnatException(const QString& msg)
  76. {
  77. QString errorMsg = msg.trimmed();
  78. if (!errorMsg.isEmpty())
  79. {
  80. errorMsg.append(' ');
  81. }
  82. errorMsg.append(xnat->errorString());
  83. switch (xnat->error())
  84. {
  85. case qRestAPI::TimeoutError:
  86. throw ctkXnatTimeoutException(errorMsg);
  87. case qRestAPI::ResponseParseError:
  88. throw ctkXnatProtocolFailureException(errorMsg);
  89. case qRestAPI::UnknownUuidError:
  90. throw ctkInvalidArgumentException(errorMsg);
  91. case qRestAPI::AuthenticationError:
  92. // This signals either an initial authentication error
  93. // or a session timeout.
  94. this->close();
  95. throw ctkXnatAuthenticationException(errorMsg);
  96. default:
  97. throw ctkRuntimeException(errorMsg);
  98. }
  99. }
  100. void ctkXnatSessionPrivate::createConnections()
  101. {
  102. // Q_D(ctkXnatSession);
  103. // connect(d->xnat, SIGNAL(resultReceived(QUuid,QList<QVariantMap>)),
  104. // this, SLOT(processResult(QUuid,QList<QVariantMap>)));
  105. // connect(d->xnat, SIGNAL(progress(QUuid,double)),
  106. // this, SLOT(progress(QUuid,double)));
  107. }
  108. void ctkXnatSessionPrivate::setDefaultHttpHeaders()
  109. {
  110. ctkXnatAPI::RawHeaders rawHeaders;
  111. rawHeaders[HEADER_USER_AGENT] = "Qt";
  112. /*
  113. rawHeaders["Authorization"] = "Basic " +
  114. QByteArray(QString("%1:%2").arg(d->loginProfile.userName())
  115. .arg(d->loginProfile.password()).toAscii()).toBase64();
  116. */
  117. if (!sessionId.isEmpty())
  118. {
  119. rawHeaders[HEADER_COOKIE] = QString("JSESSIONID=%1").arg(sessionId).toAscii();
  120. }
  121. xnat->setDefaultRawHeaders(rawHeaders);
  122. }
  123. void ctkXnatSessionPrivate::checkSession() const
  124. {
  125. if (sessionId.isEmpty())
  126. {
  127. throw ctkXnatInvalidSessionException("Session closed.");
  128. }
  129. }
  130. void ctkXnatSessionPrivate::setSessionProperties()
  131. {
  132. sessionProperties.clear();
  133. QUuid uuid = xnat->get("/data/version");
  134. QScopedPointer<qRestResult> restResult(xnat->takeResult(uuid));
  135. if (restResult)
  136. {
  137. QString version = restResult->result()["content"].toString();
  138. if (version.isEmpty())
  139. {
  140. throw ctkXnatProtocolFailureException("No version information available.");
  141. }
  142. sessionProperties[SERVER_VERSION] = version;
  143. }
  144. else
  145. {
  146. this->throwXnatException("Retrieving session properties failed.");
  147. }
  148. }
  149. QDateTime ctkXnatSessionPrivate::updateExpirationDate(qRestResult* restResult)
  150. {
  151. QByteArray cookieHeader = restResult->rawHeader("Set-Cookie");
  152. QDateTime expirationDate = QDateTime::currentDateTime();
  153. if (!cookieHeader.isEmpty())
  154. {
  155. QList<QNetworkCookie> cookies = QNetworkCookie::parseCookies(cookieHeader);
  156. foreach(const QNetworkCookie& cookie, cookies)
  157. {
  158. if (cookie.name() == "SESSION_EXPIRATION_TIME")
  159. {
  160. QList<QByteArray> expirationCookie = cookie.value().split(',');
  161. if (expirationCookie.size() == 2)
  162. {
  163. unsigned long long startTime = expirationCookie[0].mid(1).toULongLong();
  164. if (startTime > 0)
  165. {
  166. expirationDate = QDateTime::fromTime_t(startTime / 1000);
  167. }
  168. QByteArray timeSpan = expirationCookie[1];
  169. timeSpan.chop(1);
  170. expirationDate = expirationDate.addMSecs(timeSpan.toLong());
  171. sessionProperties[SESSION_EXPIRATION_DATE] = expirationDate.toString(Qt::ISODate);
  172. emit q->sessionRenewed(expirationDate);
  173. }
  174. }
  175. }
  176. }
  177. return expirationDate;
  178. }
  179. void ctkXnatSessionPrivate::close()
  180. {
  181. sessionProperties.clear();
  182. sessionId.clear();
  183. this->setDefaultHttpHeaders();
  184. dataModel.reset();
  185. }
  186. // ctkXnatSession class
  187. ctkXnatSession::ctkXnatSession(const ctkXnatLoginProfile& loginProfile)
  188. : d_ptr(new ctkXnatSessionPrivate(loginProfile, this))
  189. {
  190. Q_D(ctkXnatSession);
  191. qRegisterMetaType<ctkXnatProject>(ctkXnatProject::staticSchemaType());
  192. qRegisterMetaType<ctkXnatSubject>(ctkXnatSubject::staticSchemaType());
  193. qRegisterMetaType<ctkXnatExperiment>(ctkXnatExperiment::staticSchemaType());
  194. qRegisterMetaType<ctkXnatScan>(ctkXnatScan::staticSchemaType());
  195. qRegisterMetaType<ctkXnatScanFolder>(ctkXnatScanFolder::staticSchemaType());
  196. qRegisterMetaType<ctkXnatReconstruction>(ctkXnatReconstruction::staticSchemaType());
  197. qRegisterMetaType<ctkXnatScanResource>(ctkXnatScanResource::staticSchemaType());
  198. qRegisterMetaType<ctkXnatFile>(ctkXnatFile::staticSchemaType());
  199. qRegisterMetaType<ctkXnatReconstructionResource>(ctkXnatReconstructionResource::staticSchemaType());
  200. QString url = d->loginProfile.serverUrl().toString();
  201. d->xnat->setServerUrl(url);
  202. d->setDefaultHttpHeaders();
  203. }
  204. ctkXnatSession::~ctkXnatSession()
  205. {
  206. this->close();
  207. }
  208. void ctkXnatSession::open()
  209. {
  210. Q_D(ctkXnatSession);
  211. if (this->isOpen()) return;
  212. qRestAPI::RawHeaders headers;
  213. headers[HEADER_AUTHORIZATION] = "Basic " +
  214. QByteArray(QString("%1:%2").arg(this->userName())
  215. .arg(this->password()).toAscii()).toBase64();
  216. QUuid uuid = d->xnat->get("/data/JSESSION", qRestAPI::Parameters(), headers);
  217. QScopedPointer<qRestResult> restResult(d->xnat->takeResult(uuid));
  218. if (restResult)
  219. {
  220. QString sessionId = restResult->result()["content"].toString();
  221. d->sessionId = sessionId;
  222. d->setDefaultHttpHeaders();
  223. d->setSessionProperties();
  224. d->updateExpirationDate(restResult.data());
  225. }
  226. else
  227. {
  228. d->throwXnatException("Could not get a session id.");
  229. }
  230. d->dataModel.reset(new ctkXnatDataModel(this));
  231. d->dataModel->setProperty("ID", this->url().toString());
  232. }
  233. void ctkXnatSession::close()
  234. {
  235. Q_D(ctkXnatSession);
  236. if (!this->isOpen()) return;
  237. d->close();
  238. }
  239. bool ctkXnatSession::isOpen() const
  240. {
  241. Q_D(const ctkXnatSession);
  242. return !d->sessionId.isEmpty();
  243. }
  244. QString ctkXnatSession::version() const
  245. {
  246. Q_D(const ctkXnatSession);
  247. if (d->sessionProperties.contains(SERVER_VERSION))
  248. {
  249. return d->sessionProperties[SERVER_VERSION];
  250. }
  251. else
  252. {
  253. return QString::null;
  254. }
  255. }
  256. QDateTime ctkXnatSession::expirationDate() const
  257. {
  258. Q_D(const ctkXnatSession);
  259. d->checkSession();
  260. return QDateTime::fromString(d->sessionProperties[SESSION_EXPIRATION_DATE], Qt::ISODate);
  261. }
  262. QDateTime ctkXnatSession::renew()
  263. {
  264. Q_D(ctkXnatSession);
  265. d->checkSession();
  266. QUuid uuid = d->xnat->get("/data/auth");
  267. QScopedPointer<qRestResult> restResult(d->xnat->takeResult(uuid));
  268. if (!restResult)
  269. {
  270. d->throwXnatException("Session renewal failed.");
  271. }
  272. return d->updateExpirationDate(restResult.data());
  273. }
  274. ctkXnatLoginProfile ctkXnatSession::loginProfile() const
  275. {
  276. Q_D(const ctkXnatSession);
  277. return d->loginProfile;
  278. }
  279. void ctkXnatSession::progress(QUuid /*queryId*/, double /*progress*/)
  280. {
  281. // qDebug() << "ctkXnatSession::progress(QUuid queryId, double progress)";
  282. // qDebug() << "query id:" << queryId;
  283. // qDebug() << "progress:" << (progress * 100.0) << "%";
  284. }
  285. QUrl ctkXnatSession::url() const
  286. {
  287. Q_D(const ctkXnatSession);
  288. return d->loginProfile.serverUrl();
  289. }
  290. QString ctkXnatSession::userName() const
  291. {
  292. Q_D(const ctkXnatSession);
  293. return d->loginProfile.userName();
  294. }
  295. QString ctkXnatSession::password() const
  296. {
  297. Q_D(const ctkXnatSession);
  298. return d->loginProfile.password();
  299. }
  300. ctkXnatDataModel* ctkXnatSession::dataModel() const
  301. {
  302. Q_D(const ctkXnatSession);
  303. d->checkSession();
  304. return d->dataModel.data();
  305. }
  306. QUuid ctkXnatSession::httpGet(const QString& resource, const ctkXnatSession::UrlParameters& parameters, const ctkXnatSession::HttpRawHeaders& rawHeaders)
  307. {
  308. Q_D(ctkXnatSession);
  309. d->checkSession();
  310. return d->xnat->get(resource, parameters, rawHeaders);
  311. }
  312. QList<ctkXnatObject*> ctkXnatSession::httpResults(const QUuid& uuid, const QString& schemaType)
  313. {
  314. Q_D(ctkXnatSession);
  315. d->checkSession();
  316. QScopedPointer<qRestResult> restResult(d->xnat->takeResult(uuid));
  317. if (restResult == NULL)
  318. {
  319. d->throwXnatException("Http request failed.");
  320. }
  321. return restResult->results<ctkXnatObject>(schemaType);
  322. }
  323. QList<QVariantMap> ctkXnatSession::httpSync(const QUuid& uuid)
  324. {
  325. Q_D(ctkXnatSession);
  326. d->checkSession();
  327. QList<QVariantMap> result;
  328. qRestResult* restResult = d->xnat->takeResult(uuid);
  329. if (restResult == NULL)
  330. {
  331. d->throwXnatException("Syncing with http request failed.");
  332. }
  333. else
  334. {
  335. d->updateExpirationDate(restResult);
  336. result = restResult->results();
  337. }
  338. return result;
  339. }
  340. bool ctkXnatSession::exists(const ctkXnatObject* object)
  341. {
  342. Q_D(ctkXnatSession);
  343. QString query = object->resourceUri();
  344. bool success = d->xnat->sync(d->xnat->get(query));
  345. return success;
  346. }
  347. void ctkXnatSession::save(ctkXnatObject* object)
  348. {
  349. Q_D(ctkXnatSession);
  350. QString query = object->resourceUri();
  351. query.append(QString("?%1=%2").arg("xsi:type", object->schemaType()));
  352. const QMap<QString, QString>& properties = object->properties();
  353. QMapIterator<QString, QString> itProperties(properties);
  354. while (itProperties.hasNext())
  355. {
  356. itProperties.next();
  357. query.append(QString("&%1=%2").arg(itProperties.key(), itProperties.value()));
  358. }
  359. qDebug() << "ctkXnatSession::save() query:" << query;
  360. QUuid queryId = d->xnat->put(query);
  361. qRestResult* result = d->xnat->takeResult(queryId);
  362. if (!result || !result->error().isNull())
  363. {
  364. d->throwXnatException("Error occurred while creating the data.");
  365. }
  366. const QList<QVariantMap>& maps = result->results();
  367. if (maps.size() == 1 && maps[0].size() == 1)
  368. {
  369. QVariant id = maps[0]["ID"];
  370. if (!id.isNull())
  371. {
  372. object->setId(id.toString());
  373. }
  374. }
  375. }
  376. void ctkXnatSession::remove(ctkXnatObject* object)
  377. {
  378. Q_D(ctkXnatSession);
  379. QString query = object->resourceUri();
  380. bool success = d->xnat->sync(d->xnat->del(query));
  381. if (!success)
  382. {
  383. d->throwXnatException("Error occurred while removing the data.");
  384. }
  385. }
  386. //void ctkXnatSession::create(ctkXnatSubject* subject)
  387. //{
  388. // const QString& subjectName = subject->getName();
  389. // ctkXnatObject* project = subject->getParent();
  390. // const QString& projectName = project->getName();
  391. // Q_D(ctkXnatSession);
  392. // QString query = QString("/REST/projects/%1/subjects/%2").arg(projectName, subjectName);
  393. // bool success = d->xnat->sync(d->xnat->put(query));
  394. // if (!success)
  395. // {
  396. // throw ctkXnatException("Error occurred while creating the subject.");
  397. // }
  398. //}
  399. //void ctkXnatSession::downloadScanFiles(ctkXnatExperiment* experiment, const QString& fileName)
  400. //{
  401. // const QString& experimentName = experiment->getName();
  402. // ctkXnatObject* subject = experiment->getParent();
  403. // const QString& subjectName = subject->getName();
  404. // ctkXnatObject* project = subject->getParent();
  405. // const QString& projectName = project->getName();
  406. // Q_D(ctkXnatSession);
  407. // QString query = QString("/REST/projects/%1/subjects/%2/experiments/%3/scans/ALL/files").arg(projectName, subjectName, experimentName);
  408. // qRestAPI::Parameters parameters;
  409. // parameters["format"] = "zip";
  410. // QUuid queryId = d->xnat->download(fileName, query, parameters);
  411. // d->xnat->sync(queryId);
  412. //}
  413. //void ctkXnatSession::downloadReconstructionFiles(ctkXnatExperiment* experiment, const QString& fileName)
  414. //{
  415. // const QString& experimentName = experiment->getName();
  416. // ctkXnatObject* subject = experiment->getParent();
  417. // const QString& subjectName = subject->getName();
  418. // ctkXnatObject* project = subject->getParent();
  419. // const QString& projectName = project->getName();
  420. // Q_D(ctkXnatSession);
  421. // QString query = QString("/REST/projects/%1/subjects/%2/experiments/%3/reconstructions/ALL/files").arg(projectName, subjectName, experimentName);
  422. // qRestAPI::Parameters parameters;
  423. // parameters["format"] = "zip";
  424. // QUuid queryId = d->xnat->download(fileName, query, parameters);
  425. // d->xnat->sync(queryId);
  426. //}
  427. //void ctkXnatSession::downloadReconstruction(ctkXnatReconstruction* reconstruction, const QString& fileName)
  428. //{
  429. // const QString& reconstructionName = reconstruction->getName();
  430. // ctkXnatObject* experiment = reconstruction->getParent();
  431. // const QString& experimentName = experiment->getName();
  432. // ctkXnatObject* subject = experiment->getParent();
  433. // const QString& subjectName = subject->getName();
  434. // ctkXnatObject* project = subject->getParent();
  435. // const QString& projectName = project->getName();
  436. // Q_D(ctkXnatSession);
  437. // QString query = QString("/REST/projects/%1/subjects/%2/experiments/%3/reconstructions/%4/ALL/files").arg(projectName, subjectName, experimentName, reconstructionName);
  438. // qRestAPI::Parameters parameters;
  439. // parameters["format"] = "zip";
  440. // QUuid queryId = d->xnat->download(fileName, query, parameters);
  441. // d->xnat->sync(queryId);
  442. //}
  443. //void ctkXnatSession::downloadReconstructionResourceFiles(ctkXnatReconstructionResource* reconstructionResource, const QString& fileName)
  444. //{
  445. // const QString& reconstructionResourceName = reconstructionResource->getName();
  446. // ctkXnatObject* reconstruction = reconstructionResource->getParent();
  447. // const QString& reconstructionName = reconstruction->getName();
  448. // ctkXnatObject* experiment = reconstruction->getParent()->getParent();
  449. // const QString& experimentName = experiment->getName();
  450. // ctkXnatObject* subject = experiment->getParent();
  451. // const QString& subjectName = subject->getName();
  452. // ctkXnatObject* project = subject->getParent();
  453. // const QString& projectName = project->getName();
  454. // Q_D(ctkXnatSession);
  455. // QString query = QString("/REST/projects/%1/subjects/%2/experiments/%3/reconstructions/%4/ALL/resources/%5/files").arg(projectName, subjectName, experimentName, reconstructionName, reconstructionResourceName);
  456. // qRestAPI::Parameters parameters;
  457. // parameters["format"] = "zip";
  458. // QUuid queryId = d->xnat->download(fileName, query, parameters);
  459. // d->xnat->sync(queryId);
  460. //}
  461. //void ctkXnatSession::download(ctkXnatReconstructionResourceFile* reconstructionResourceFile, const QString& fileName)
  462. //{
  463. // const QString& reconstructionResourceFileName = reconstructionResourceFile->getName();
  464. // ctkXnatObject* reconstructionResource = reconstructionResourceFile->getParent();
  465. // const QString& reconstructionResourceName = reconstructionResource->getName();
  466. // ctkXnatObject* reconstruction = reconstructionResource->getParent();
  467. // const QString& reconstructionName = reconstruction->getName();
  468. // ctkXnatObject* experiment = reconstruction->getParent()->getParent();
  469. // const QString& experimentName = experiment->getName();
  470. // ctkXnatObject* subject = experiment->getParent();
  471. // const QString& subjectName = subject->getName();
  472. // ctkXnatObject* project = subject->getParent();
  473. // const QString& projectName = project->getName();
  474. // Q_D(ctkXnatSession);
  475. // QString query = QString("/REST/projects/%1/subjects/%2/experiments/%3/reconstructions/%4/resources/%5/files/%6").arg(projectName, subjectName, experimentName, reconstructionName, reconstructionResourceName, reconstructionResourceFileName);
  476. // qRestAPI::Parameters parameters;
  477. // parameters["format"] = "zip";
  478. // QUuid queryId = d->xnat->download(fileName, query, parameters);
  479. // d->xnat->sync(queryId);
  480. //}
  481. //void ctkXnatSession::download(ctkXnatScan* scan, const QString& fileName)
  482. //{
  483. // const QString& scanName = scan->getName();
  484. // ctkXnatObject* experiment = scan->getParent()->getParent();
  485. // const QString& experimentName = experiment->getName();
  486. // ctkXnatObject* subject = experiment->getParent();
  487. // const QString& subjectName = subject->getName();
  488. // ctkXnatObject* project = subject->getParent();
  489. // const QString& projectName = project->getName();
  490. // Q_D(ctkXnatSession);
  491. // QString query = QString("/REST/projects/%1/subjects/%2/experiments/%3/scans/%4/files").arg(projectName, subjectName, experimentName, scanName);
  492. // qRestAPI::Parameters parameters;
  493. // parameters["format"] = "zip";
  494. // QUuid queryId = d->xnat->download(fileName, query, parameters);
  495. // d->xnat->sync(queryId);
  496. //}
  497. void ctkXnatSession::download(ctkXnatFile* file, const QString& fileName)
  498. {
  499. Q_D(ctkXnatSession);
  500. QString query = file->resourceUri();
  501. QUuid queryId = d->xnat->download(fileName, query);
  502. d->xnat->sync(queryId);
  503. }
  504. void ctkXnatSession::download(ctkXnatScanResource* scanResource, const QString& fileName)
  505. {
  506. Q_D(ctkXnatSession);
  507. QString query = scanResource->resourceUri() + "/files";
  508. qRestAPI::Parameters parameters;
  509. parameters["format"] = "zip";
  510. QUuid queryId = d->xnat->download(fileName, query, parameters);
  511. d->xnat->sync(queryId);
  512. }
  513. void ctkXnatSession::download(ctkXnatReconstructionResource* reconstructionResource, const QString& fileName)
  514. {
  515. Q_D(ctkXnatSession);
  516. QString query = reconstructionResource->resourceUri() + "/files";
  517. qRestAPI::Parameters parameters;
  518. parameters["format"] = "zip";
  519. QUuid queryId = d->xnat->download(fileName, query, parameters);
  520. d->xnat->sync(queryId);
  521. }
  522. void ctkXnatSession::processResult(QUuid queryId, QList<QVariantMap> parameters)
  523. {
  524. Q_UNUSED(queryId)
  525. Q_UNUSED(parameters)
  526. }