CTK/Libs/XNAT/Core/ctkXnatConnection.cpp

/*=============================================================================

  Plugin: org.commontk.xnat

  Copyright (c) University College London,
    Centre for Medical Image Computing

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.

=============================================================================*/

#include "ctkXnatConnection.h"

#include "ctkXnatException.h"
#include "ctkXnatExperiment.h"
#include "ctkXnatObject.h"
#include "ctkXnatObjectPrivate.h"
#include "ctkXnatProject.h"
#include "ctkXnatReconstruction.h"
#include "ctkXnatReconstructionFolder.h"
#include "ctkXnatReconstructionResource.h"
#include "ctkXnatReconstructionResourceFile.h"
#include "ctkXnatScan.h"
#include "ctkXnatScanFolder.h"
#include "ctkXnatScanResource.h"
#include "ctkXnatScanResourceFile.h"
#include "ctkXnatServer.h"
#include "ctkXnatSubject.h"

#include <QDebug>
#include <QScopedPointer>
#include <QStringBuilder>

#include <qXnatAPI.h>
#include <qRestResult.h>

class ctkXnatConnectionPrivate
{
public:
  QString profileName;
  QString url;
  QString userName;
  QString password;

  qXnatAPI* xnat;
  qXnatAPI::RawHeaders rawHeaders;

  QSharedPointer<ctkXnatServer> server;
};

// ctkXnatConnection class

ctkXnatConnection::ctkXnatConnection()
: d_ptr(new ctkXnatConnectionPrivate())
{
  Q_D(ctkXnatConnection);
  d->xnat = new qXnatAPI();
  
//  d->xnat->setSuppressSslErrors(true);
  d->rawHeaders["User-Agent"] = "Qt";
  d->xnat->setDefaultRawHeaders(d->rawHeaders);

  d->server = ctkXnatServer::Create(this);
  createConnections();
}

ctkXnatConnection::~ctkXnatConnection()
{
  Q_D(ctkXnatConnection);
  delete d->xnat;
}

void ctkXnatConnection::createConnections()
{
//  Q_D(ctkXnatConnection);
//  connect(d->xnat, SIGNAL(resultReceived(QUuid,QList<QVariantMap>)),
//           this, SLOT(processResult(QUuid,QList<QVariantMap>)));
//  connect(d->xnat, SIGNAL(progress(QUuid,double)),
//           this, SLOT(progress(QUuid,double)));
}

void ctkXnatConnection::progress(QUuid queryId, double progress)
{
  qDebug() << "ctkXnatConnection::progress(QUuid queryId, double progress)";
  qDebug() << "query id:" << queryId;
  qDebug() << "progress:" << (progress * 100.0) << "%";
}

QString ctkXnatConnection::profileName() const
{
  Q_D(const ctkXnatConnection);
  return d->profileName;
}

void ctkXnatConnection::setProfileName(const QString& profileName)
{
  Q_D(ctkXnatConnection);
  d->profileName = profileName;
  d->server->setProperty("name", profileName);
}

QString ctkXnatConnection::url() const
{
  Q_D(const ctkXnatConnection);
  return d->url;
}

void ctkXnatConnection::setUrl(const QString& url)
{
  Q_D(ctkXnatConnection);
  d->url = url;
  d->xnat->setServerUrl(d->url);
  d->server->setProperty("ID", url);
}

QString ctkXnatConnection::userName() const
{
  Q_D(const ctkXnatConnection);
  return d->userName;
}

void ctkXnatConnection::setUserName(const QString& userName)
{
  Q_D(ctkXnatConnection);
  d->userName = userName;
  d->rawHeaders["Authorization"] = "Basic " +
      QByteArray(QString("%1:%2").arg(d->userName).arg(d->password).toAscii()).toBase64();
  d->xnat->setDefaultRawHeaders(d->rawHeaders);
}

QString ctkXnatConnection::password() const
{
  Q_D(const ctkXnatConnection);
  return d->password;
}

void ctkXnatConnection::setPassword(const QString& password)
{
  Q_D(ctkXnatConnection);
  d->password = password;
  d->rawHeaders["Authorization"] = "Basic " +
      QByteArray(QString("%1:%2").arg(d->userName).arg(d->password).toAscii()).toBase64();
  d->xnat->setDefaultRawHeaders(d->rawHeaders);
}

ctkXnatServer::Pointer ctkXnatConnection::server() const
{
  Q_D(const ctkXnatConnection);
  return d->server;
}

void ctkXnatConnection::fetch(const ctkXnatServer::Pointer& server)
{
  Q_D(ctkXnatConnection);

  QString projectsUri("/data/archive/projects");

  QUuid queryId = d->xnat->get(projectsUri);
  qRestResult* restResult = d->xnat->takeResult(queryId);
  QList<ctkXnatProject*> projects = restResult->results<ctkXnatProject>();

  foreach (ctkXnatProject* project, projects)
  {
    project->setUri(projectsUri + "/" + project->id());
    ctkXnatObject::Pointer ptr(project);
    ptr->d_func()->selfPtr = ptr;
    server->addChild(ptr);
  }

  delete restResult;
}

void ctkXnatConnection::fetch(const ctkXnatProject::Pointer& project)
{
  Q_D(ctkXnatConnection);

  QString subjectsUri = project->uri() + "/subjects";
  QUuid queryId = d->xnat->get(subjectsUri);
  qRestResult* restResult = d->xnat->takeResult(queryId);
  QList<ctkXnatSubject*> subjects = restResult->results<ctkXnatSubject>();

  foreach (ctkXnatSubject* subject, subjects)
  {
    QString label = subject->property("label");
    if (label.size())
    {
      subject->setProperty("ID", label);
    }
    subject->setUri(subjectsUri + "/" + subject->id());

    ctkXnatObject::Pointer ptr(subject);
    ptr->d_func()->selfPtr = ptr;
    project->addChild(ptr);
  }

  delete restResult;
}

void ctkXnatConnection::fetch(const QSharedPointer<ctkXnatSubject>& subject)
{
  Q_D(ctkXnatConnection);

  QString experimentsUri = subject->uri() + "/experiments";
  QUuid queryId = d->xnat->get(experimentsUri);
  qRestResult* restResult = d->xnat->takeResult(queryId);

  QList<ctkXnatExperiment*> experiments = restResult->results<ctkXnatExperiment>();

  foreach (ctkXnatExperiment* experiment, experiments)
  {
    QString label = experiment->property ("label");
    if (label.size())
    {
      experiment->setProperty ("ID", label);
    }
    experiment->setUri(experimentsUri + "/" + experiment->id());

    ctkXnatObject::Pointer ptr(experiment);
    ptr->d_func()->selfPtr = ptr;
    subject->addChild(ptr);
  }

  delete restResult;
}

void ctkXnatConnection::fetch(const QSharedPointer<ctkXnatExperiment>& experiment)
{
  Q_D(ctkXnatConnection);
  
  QString scansUri = experiment->uri() + "/scans";
  QUuid scansQueryId = d->xnat->get(scansUri);
  qRestResult* restResult = d->xnat->takeResult(scansQueryId);
  
  QList<ctkXnatScan*> scans = restResult->results<ctkXnatScan>();
  
  if (scans.size() > 0)
  {
    ctkXnatObject::Pointer ptr = ctkXnatScanFolder::Create();

    ptr->setUri(scansUri);

    ptr->d_func()->selfPtr = ptr;
    experiment->addChild(ptr);
  }
  
  // The reconstruction scans are not supported by XNAT so we don't fetch them

//  query = QString("/REST/projects/%1/subjects/%2/experiments/%3/reconstructions").arg(projectName, subjectName, experimentName);
//  queryId = d->xnat->get(query);
//  restResult = d->xnat->takeResult(queryId);
//  QList<ctkXnatReconstruction*> rconstructions = restResult->results<ctkXnatReconstruction>();
//  if (reconstructions.size() > 0)
//  {
//    ctkXnatReconstructionFolder* reconstructionFolder = new ctkXnatReconstructionFolder(experiment);
//    experiment->addChild("Reconstruction", reconstructionFolder);
//  }


  delete restResult;
}

void ctkXnatConnection::fetch(const QSharedPointer<ctkXnatScanFolder>& scanFolder)
{
  Q_D(ctkXnatConnection);
  
  QString scansUri = scanFolder->uri();
  QUuid queryId = d->xnat->get(scansUri);
  qRestResult* restResult = d->xnat->takeResult(queryId);

  QList<ctkXnatScan*> scans = restResult->results<ctkXnatScan>();
  
  foreach (ctkXnatScan* scan, scans)
  {
    scan->setUri(scansUri + "/" + scan->id());

    ctkXnatObject::Pointer ptr(scan);
    ptr->d_func()->selfPtr = ptr;
    scanFolder->addChild(ptr);
  }
  
  delete restResult;
  
}

void ctkXnatConnection::fetch(const QSharedPointer<ctkXnatScan>& scan)
{
  Q_D(ctkXnatConnection);
  
  QString scanResourcesUri = scan->uri() + "/resources";
  QUuid queryId = d->xnat->get(scanResourcesUri);
  qRestResult* restResult = d->xnat->takeResult(queryId);
  
  QList<ctkXnatScanResource*> scanResources = restResult->results<ctkXnatScanResource>();
  
  foreach (ctkXnatScanResource* scanResource, scanResources)
  {
    QString label = scanResource->property("label");
    if (label.size())
    {
      scanResource->setProperty("ID", label);
    }
    
    scanResource->setUri(scanResourcesUri + "/" + label);

    ctkXnatObject::Pointer ptr(scanResource);
    ptr->d_func()->selfPtr = ptr;
    scan->addChild(ptr);
  }
}

void ctkXnatConnection::fetch(const QSharedPointer<ctkXnatScanResource>& scanResource)
{
  Q_D(ctkXnatConnection);
  
  QString scanResourceFilesUri = scanResource->uri() + "/files";
  QUuid queryId = d->xnat->get(scanResourceFilesUri);
  qRestResult* restResult = d->xnat->takeResult(queryId);
  
  QList<ctkXnatScanResourceFile*> scanResourceFiles = restResult->results<ctkXnatScanResourceFile>();

  foreach (ctkXnatScanResourceFile* scanResourceFile, scanResourceFiles)
  {
    QString uri = scanResourceFile->property("URI");
    if (uri.size())
    {
      scanResourceFile->setUri(uri);
    }

    QString label = scanResourceFile->property("Name");
    if (label.size())
    {
      scanResourceFile->setProperty("ID", label);
    }

    scanResourceFile->setUri(scanResourceFilesUri + "/" + label);

    ctkXnatObject::Pointer ptr(scanResourceFile);
    ptr->d_func()->selfPtr = ptr;
    scanResource->addChild(ptr);
  }
}

//void ctkXnatConnection::fetch(ctkXnatReconstructionFolder* reconstructionFolder)
//{
//  ctkXnatObject* experiment = reconstructionFolder->getParent();
//  const QString& experimentName = experiment->getName();
//  ctkXnatObject* subject = experiment->getParent();
//  const QString& subjectName = subject->getName();
//  ctkXnatObject* project = subject->getParent();
//  const QString& projectName = project->getName();

//  Q_D(ctkXnatConnection);

//  QString query = QString("/REST/projects/%1/subjects/%2/experiments/%3/reconstructions").arg(projectName, subjectName, experimentName);
//  QList<QVariantMap> result;
//  bool success = d->xnat->sync(d->xnat->get(query), result);
//  if (!success)
//  {
//    throw ctkXnatException("Error occurred while retrieving reconstruction list from XNAT.");
//  }

//  foreach (QVariantMap map, result)
//  {
//    QString reconstructionID = map["ID"].toString();
//    ctkXnatReconstruction* reconstruction = new ctkXnatReconstruction(reconstructionFolder);
//    reconstructionFolder->addChild(reconstructionID, reconstruction);
//  }
//}

//void ctkXnatConnection::fetch(ctkXnatReconstruction* reconstruction)
//{
//  const QString& reconstructionName = reconstruction->getName();
//  ctkXnatObject* experiment = reconstruction->getParent()->getParent();
//  const QString& experimentName = experiment->getName();
//  ctkXnatObject* subject = experiment->getParent();
//  const QString& subjectName = subject->getName();
//  ctkXnatObject* project = subject->getParent();
//  const QString& projectName = project->getName();

//  Q_D(ctkXnatConnection);

//  QString query = QString("/REST/projects/%1/subjects/%2/experiments/%3/reconstructions/%4/ALL/resources").arg(projectName, subjectName, experimentName, reconstructionName);
//  QList<QVariantMap> result;
//  bool success = d->xnat->sync(d->xnat->get(query), result);
//  if (!success)
//  {
//    throw ctkXnatException("Error occurred while retrieving reconstruction resource list from XNAT.");
//  }

//  foreach (QVariantMap map, result)
//  {
//    QString reconstructionResourceLabel = map["label"].toString();
//    ctkXnatReconstructionResource* reconstructionResource = new ctkXnatReconstructionResource(reconstruction);
//    reconstruction->addChild(reconstructionResourceLabel, reconstructionResource);
//  }
//}

//void ctkXnatConnection::fetch(ctkXnatReconstructionResource* reconstructionResource)
//{
//  const QString& resourceName = reconstructionResource->getName();
//  ctkXnatObject* reconstruction = reconstructionResource->getParent();
//  const QString& reconstructionName = reconstruction->getName();
//  ctkXnatObject* experiment = reconstruction->getParent()->getParent();
//  const QString& experimentName = experiment->getName();
//  ctkXnatObject* subject = experiment->getParent();
//  const QString& subjectName = subject->getName();
//  ctkXnatObject* project = subject->getParent();
//  const QString& projectName = project->getName();

//  Q_D(ctkXnatConnection);

//  QString query = QString("/REST/projects/%1/subjects/%2/experiments/%3/reconstructions/%4/ALL/resources/%5/files").arg(projectName, subjectName, experimentName, reconstructionName, resourceName);
//  QList<QVariantMap> result;
//  bool success = d->xnat->sync(d->xnat->get(query), result);
//  if (!success)
//  {
//    throw ctkXnatException("Error occurred while retrieving reconstruction resource file list from XNAT.");
//  }

//  foreach (QVariantMap map, result)
//  {
//    QString reconstructionResourceFileName = map["Name"].toString();
//    ctkXnatReconstructionResourceFile* reconstructionResourceFile = new ctkXnatReconstructionResourceFile(reconstructionResource);
//    reconstructionResource->addChild(reconstructionResourceFileName, reconstructionResourceFile);
//  }
//}



//void ctkXnatConnection::create(ctkXnatProject* project)
//{
//  const QString& projectName = project->name();

//  Q_D(ctkXnatConnection);

//  QString query = QString("/REST/projects/%1").arg(projectName);
//  bool success = d->xnat->sync(d->xnat->put(query));

//  if (!success)
//  {
//    throw ctkXnatException("Error occurred while creating the project.");
//  }
//}

//void ctkXnatConnection::remove(ctkXnatProject* project)
//{
//  const QString& projectName = project->name();

//  Q_D(ctkXnatConnection);

//  QString query = QString("/REST/projects/%1").arg(projectName);
//  bool success = d->xnat->sync(d->xnat->del(query));

//  if (!success)
//  {
//    throw ctkXnatException("Error occurred while removing the project.");
//  }
//}

//void ctkXnatConnection::create(ctkXnatSubject* subject)
//{
//  const QString& subjectName = subject->getName();
//  ctkXnatObject* project = subject->getParent();
//  const QString& projectName = project->getName();

//  Q_D(ctkXnatConnection);

//  QString query = QString("/REST/projects/%1/subjects/%2").arg(projectName, subjectName);
//  bool success = d->xnat->sync(d->xnat->put(query));

//  if (!success)
//  {
//    throw ctkXnatException("Error occurred while creating the subject.");
//  }
//}

//void ctkXnatConnection::downloadScanFiles(ctkXnatExperiment* experiment, const QString& fileName)
//{
////  qDebug() << "ctkXnatConnection::downloadScanFiles(ctkXnatExperiment* experiment, const QString& zipFilename)";
//  const QString& experimentName = experiment->getName();
//  ctkXnatObject* subject = experiment->getParent();
//  const QString& subjectName = subject->getName();
//  ctkXnatObject* project = subject->getParent();
//  const QString& projectName = project->getName();

//  Q_D(ctkXnatConnection);

//  QString query = QString("/REST/projects/%1/subjects/%2/experiments/%3/scans/ALL/files").arg(projectName, subjectName, experimentName);
//  qRestAPI::Parameters parameters;
//  parameters["format"] = "zip";
//  QUuid queryId = d->xnat->download(fileName, query, parameters);
//  d->xnat->sync(queryId);
//}

//void ctkXnatConnection::downloadReconstructionFiles(ctkXnatExperiment* experiment, const QString& fileName)
//{
//  const QString& experimentName = experiment->getName();
//  ctkXnatObject* subject = experiment->getParent();
//  const QString& subjectName = subject->getName();
//  ctkXnatObject* project = subject->getParent();
//  const QString& projectName = project->getName();

//  Q_D(ctkXnatConnection);

//  QString query = QString("/REST/projects/%1/subjects/%2/experiments/%3/reconstructions/ALL/files").arg(projectName, subjectName, experimentName);
//  qRestAPI::Parameters parameters;
//  parameters["format"] = "zip";
//  QUuid queryId = d->xnat->download(fileName, query, parameters);
//  d->xnat->sync(queryId);
//}

//void ctkXnatConnection::addReconstruction(ctkXnatExperiment* /*experiment*/, const QString& /*reconstruction*/)
//{
////  const QString& experimentName = experiment->getName();
////  ctkXnatObject* subject = experiment->getParent();
////  const QString& subjectName = subject->getName();
////  ctkXnatObject* project = subject->getParent();
////  const QString& projectName = project->getName();

//  // TODO
//}

//void ctkXnatConnection::downloadReconstruction(ctkXnatReconstruction* reconstruction, const QString& fileName)
//{
//  const QString& reconstructionName = reconstruction->getName();
//  ctkXnatObject* experiment = reconstruction->getParent();
//  const QString& experimentName = experiment->getName();
//  ctkXnatObject* subject = experiment->getParent();
//  const QString& subjectName = subject->getName();
//  ctkXnatObject* project = subject->getParent();
//  const QString& projectName = project->getName();

//  Q_D(ctkXnatConnection);

//  QString query = QString("/REST/projects/%1/subjects/%2/experiments/%3/reconstructions/%4/ALL/files").arg(projectName, subjectName, experimentName, reconstructionName);
//  qRestAPI::Parameters parameters;
//  parameters["format"] = "zip";
//  QUuid queryId = d->xnat->download(fileName, query, parameters);
//  d->xnat->sync(queryId);
//}

//void ctkXnatConnection::addReconstructionResource(ctkXnatReconstruction* /*reconstruction*/, const QString& /*resourceName*/)
//{
////  const QString& reconstructionName = reconstruction->getName();
////  ctkXnatObject* experiment = reconstruction->getParent()->getParent();
////  const QString& experimentName = experiment->getName();
////  ctkXnatObject* subject = experiment->getParent();
////  const QString& subjectName = subject->getName();
////  ctkXnatObject* project = subject->getParent();
////  const QString& projectName = project->getName();

//  // TODO
//}

//void ctkXnatConnection::removeReconstruction(ctkXnatReconstruction* /*reconstruction*/)
//{
////  const QString& reconstructionName = reconstruction->getName();
////  ctkXnatObject* experiment = reconstruction->getParent()->getParent();
////  const QString& experimentName = experiment->getName();
////  ctkXnatObject* subject = experiment->getParent();
////  const QString& subjectName = subject->getName();
////  ctkXnatObject* project = subject->getParent();
////  const QString& projectName = project->getName();

//  // TODO
//}

//void ctkXnatConnection::downloadReconstructionResourceFiles(ctkXnatReconstructionResource* reconstructionResource, const QString& fileName)
//{
//  const QString& reconstructionResourceName = reconstructionResource->getName();
//  ctkXnatObject* reconstruction = reconstructionResource->getParent();
//  const QString& reconstructionName = reconstruction->getName();
//  ctkXnatObject* experiment = reconstruction->getParent()->getParent();
//  const QString& experimentName = experiment->getName();
//  ctkXnatObject* subject = experiment->getParent();
//  const QString& subjectName = subject->getName();
//  ctkXnatObject* project = subject->getParent();
//  const QString& projectName = project->getName();

//  Q_D(ctkXnatConnection);

//  QString query = QString("/REST/projects/%1/subjects/%2/experiments/%3/reconstructions/%4/ALL/resources/%5/files").arg(projectName, subjectName, experimentName, reconstructionName, reconstructionResourceName);
//  qRestAPI::Parameters parameters;
//  parameters["format"] = "zip";
//  QUuid queryId = d->xnat->download(fileName, query, parameters);
//  d->xnat->sync(queryId);
//}

//void ctkXnatConnection::uploadReconstructionResourceFiles(ctkXnatReconstructionResource* /*reconstructionResource*/, const QString& /*zipFilename*/)
//{
////  const QString& resourceName = reconstructionResource->getName();
////  ctkXnatObject* reconstruction = reconstructionResource->getParent();
////  const QString& reconstructionName = reconstruction->getName();
////  ctkXnatObject* experiment = reconstruction->getParent()->getParent();
////  const QString& experimentName = experiment->getName();
////  ctkXnatObject* subject = experiment->getParent();
////  const QString& subjectName = subject->getName();
////  ctkXnatObject* project = subject->getParent();
////  const QString& projectName = project->getName();

//  // TODO
//}

//void ctkXnatConnection::removeReconstructionResource(ctkXnatReconstructionResource* /*reconstructionResource*/)
//{
////  const QString& resourceName = reconstructionResource->getName();
////  ctkXnatObject* reconstruction = reconstructionResource->getParent();
////  const QString& reconstructionName = reconstruction->getName();
////  ctkXnatObject* experiment = reconstruction->getParent()->getParent();
////  const QString& experimentName = experiment->getName();
////  ctkXnatObject* subject = experiment->getParent();
////  const QString& subjectName = subject->getName();
////  ctkXnatObject* project = subject->getParent();
////  const QString& projectName = project->getName();

//  // TODO
//}

//void ctkXnatConnection::download(ctkXnatReconstructionResourceFile* reconstructionResourceFile, const QString& fileName)
//{
////  qDebug() <<  "ctkXnatConnection::download(ctkXnatReconstructionResourceFile* reconstructionResourceFile, const QString& zipFilename)";
//  const QString& reconstructionResourceFileName = reconstructionResourceFile->getName();
//  ctkXnatObject* reconstructionResource = reconstructionResourceFile->getParent();
//  const QString& reconstructionResourceName = reconstructionResource->getName();
//  ctkXnatObject* reconstruction = reconstructionResource->getParent();
//  const QString& reconstructionName = reconstruction->getName();
//  ctkXnatObject* experiment = reconstruction->getParent()->getParent();
//  const QString& experimentName = experiment->getName();
//  ctkXnatObject* subject = experiment->getParent();
//  const QString& subjectName = subject->getName();
//  ctkXnatObject* project = subject->getParent();
//  const QString& projectName = project->getName();

//  Q_D(ctkXnatConnection);

//  QString query = QString("/REST/projects/%1/subjects/%2/experiments/%3/reconstructions/%4/resources/%5/files/%6").arg(projectName, subjectName, experimentName, reconstructionName, reconstructionResourceName, reconstructionResourceFileName);
//  qRestAPI::Parameters parameters;
//  parameters["format"] = "zip";
//  QUuid queryId = d->xnat->download(fileName, query, parameters);
//  d->xnat->sync(queryId);
//}

//void ctkXnatConnection::remove(ctkXnatReconstructionResourceFile* /*reconstructionResourceFile*/)
//{
////  const QString& filename = reconstructionResourceFile->getName();
////  ctkXnatObject* reconstructionResource = reconstructionResourceFile->getParent();
////  const QString& resourceName = reconstructionResource->getName();
////  ctkXnatObject* reconstruction = reconstructionResource->getParent();
////  const QString& reconstructionName = reconstruction->getName();
////  ctkXnatObject* experiment = reconstruction->getParent()->getParent();
////  const QString& experimentName = experiment->getName();
////  ctkXnatObject* subject = experiment->getParent();
////  const QString& subjectName = subject->getName();
////  ctkXnatObject* project = subject->getParent();
////  const QString& projectName = project->getName();

//  // TODO
//}

//void ctkXnatConnection::download(ctkXnatScan* scan, const QString& fileName)
//{
////  qDebug() << "ctkXnatConnection::download(ctkXnatScan* scan, const QString& zipFilename)";
//  const QString& scanName = scan->getName();
//  ctkXnatObject* experiment = scan->getParent()->getParent();
//  const QString& experimentName = experiment->getName();
//  ctkXnatObject* subject = experiment->getParent();
//  const QString& subjectName = subject->getName();
//  ctkXnatObject* project = subject->getParent();
//  const QString& projectName = project->getName();

//  Q_D(ctkXnatConnection);

//  QString query = QString("/REST/projects/%1/subjects/%2/experiments/%3/scans/%4/files").arg(projectName, subjectName, experimentName, scanName);
//  qRestAPI::Parameters parameters;
//  parameters["format"] = "zip";
//  QUuid queryId = d->xnat->download(fileName, query, parameters);
//  d->xnat->sync(queryId);
//}

void ctkXnatConnection::download(ctkXnatScanResource* scanResource, const QString& fileName)
{
  Q_D(ctkXnatConnection);

  QString query = scanResource->uri() + "/files";
  qRestAPI::Parameters parameters;
  parameters["format"] = "zip";
  QUuid queryId = d->xnat->download(fileName, query, parameters);
  d->xnat->sync(queryId);
}

void ctkXnatConnection::download(ctkXnatScanResourceFile* scanResourceFile, const QString& fileName)
{
  Q_D(ctkXnatConnection);
  QString query = scanResourceFile->uri();

  QUuid queryId = d->xnat->download(fileName, query);
  d->xnat->sync(queryId);
}

void ctkXnatConnection::processResult(QUuid queryId, QList<QVariantMap> parameters)
{
  Q_UNUSED(queryId)
  Q_UNUSED(parameters)
}