Merge branch 'refactor-upload-and-implement-file-upload' into refactor-upload-and-implement-file-upload-integration

Conflicts:
	Libs/XNAT/Core/ctkXnatFile.h
	Libs/XNAT/Core/ctkXnatSession.cpp
	Libs/XNAT/Core/ctkXnatSession.h

Applications/ctkXnatTreeBrowser/ctkXnatTreeBrowserMainWindow.cpp

@@ -22,19 +22,27 @@
 #include "ctkXnatTreeBrowserMainWindow.h"
 #include "ui_ctkXnatTreeBrowserMainWindow.h"
 
-#include "ctkXnatLoginDialog.h"
-#include "ctkXnatTreeModel.h"
-#include "ctkXnatSession.h"
+#include "ctkXnatAssessor.h"
+#include "ctkXnatAssessorFolder.h"
 #include "ctkXnatDataModel.h"
-#include "ctkXnatProject.h"
+#include "ctkXnatException.h"
+#include "ctkXnatExperiment.h"
 #include "ctkXnatFile.h"
+#include "ctkXnatLoginDialog.h"
+#include "ctkXnatProject.h"
+#include "ctkXnatReconstruction.h"
+#include "ctkXnatReconstructionFolder.h"
 #include "ctkXnatResource.h"
+#include "ctkXnatResourceFolder.h"
 #include "ctkXnatScan.h"
 #include "ctkXnatScanFolder.h"
-#include "ctkXnatAssessor.h"
-#include "ctkXnatAssessorFolder.h"
-#include "ctkXnatReconstruction.h"
-#include "ctkXnatReconstructionFolder.h"
+#include "ctkXnatSession.h"
+#include "ctkXnatSubject.h"
+#include "ctkXnatTreeModel.h"
+
+#include <QMessageBox>
+#include <QFileDialog>
+#include <QFileInfo>
 
 ctkXnatTreeBrowserMainWindow::ctkXnatTreeBrowserMainWindow(QWidget *parent) :
   QMainWindow(parent),
@@ -50,6 +58,8 @@ ctkXnatTreeBrowserMainWindow::ctkXnatTreeBrowserMainWindow(QWidget *parent) :
   this->connect(ui->loginButton, SIGNAL(clicked()), SLOT(loginButtonPushed()));
   this->connect(ui->treeView, SIGNAL(clicked(const QModelIndex&)), SLOT(itemSelected(const QModelIndex&)));
   this->connect(ui->downloadButton, SIGNAL(clicked()), SLOT(downloadButtonClicked()));
+  this->connect(ui->addResourceButton, SIGNAL(clicked()), SLOT(addResourceClicked()));
+  this->connect(ui->uploadFileButton, SIGNAL(clicked()), SLOT(uploadFileClicked()));
 }
 
 ctkXnatTreeBrowserMainWindow::~ctkXnatTreeBrowserMainWindow()
@@ -110,6 +120,16 @@ void ctkXnatTreeBrowserMainWindow::itemSelected(const QModelIndex &index)
   downloadable |= dynamic_cast<ctkXnatReconstructionFolder*>(xnatObject)!=NULL;
   ui->downloadButton->setEnabled(downloadable);
   ui->downloadLabel->setVisible(!downloadable);
+  bool canHaveResource = false;
+  canHaveResource |= dynamic_cast<ctkXnatProject*>(xnatObject) != NULL;
+  canHaveResource |=  dynamic_cast<ctkXnatSubject*>(xnatObject) != NULL;
+  canHaveResource |=  dynamic_cast<ctkXnatExperiment*>(xnatObject) != NULL;
+  ui->addResourceButton->setEnabled(canHaveResource);
+  bool uploadFilePossible = false;
+  uploadFilePossible |= dynamic_cast<ctkXnatResource*>(xnatObject) != NULL;
+  uploadFilePossible |=  dynamic_cast<ctkXnatScan*>(xnatObject) != NULL;
+  uploadFilePossible |=  dynamic_cast<ctkXnatAssessor*>(xnatObject) != NULL;
+  ui->uploadFileButton->setEnabled(uploadFilePossible);
 }
 
 void ctkXnatTreeBrowserMainWindow::downloadButtonClicked()
@@ -122,3 +142,40 @@ void ctkXnatTreeBrowserMainWindow::downloadButtonClicked()
     m_TreeModel->downloadFile(index, fileName);
   }
 }
+
+void ctkXnatTreeBrowserMainWindow::addResourceClicked()
+{
+  const QModelIndex index = ui->treeView->selectionModel()->currentIndex();
+  ctkXnatObject* parentObject = m_TreeModel->xnatObject(index);
+  parentObject->addResource("data", "ctk format", "custom content", "tag1, tag2");
+}
+
+void ctkXnatTreeBrowserMainWindow::uploadFileClicked()
+{
+  QString filename = QFileDialog::getOpenFileName(this, tr("Open File"), QDir::homePath());
+  const QModelIndex index = ui->treeView->selectionModel()->currentIndex();
+  ctkXnatResource* resource = dynamic_cast<ctkXnatResource*>(m_TreeModel->xnatObject(index));
+  if (resource)
+  {
+    ctkXnatFile* file = new ctkXnatFile();
+    file->setLocalFilePath(filename);
+    QFileInfo fileInfo (filename);
+    file->setName(fileInfo.fileName());
+    file->setFileFormat("some format");
+    file->setFileContent("some content");
+    file->setFileTags("some, tags");
+    resource->add(file);
+    try
+    {
+      file->save();
+    }
+    catch (ctkXnatException &e)
+    {
+      QMessageBox msgbox;
+      msgbox.setText(e.what());
+      msgbox.setIcon(QMessageBox::Critical);
+      msgbox.exec();
+    }
+    m_TreeModel->addChildNode(index, file);
+  }
+}

Applications/ctkXnatTreeBrowser/ctkXnatTreeBrowserMainWindow.h

@@ -46,6 +46,8 @@ private Q_SLOTS:
   void loginButtonPushed();
   void itemSelected(const QModelIndex&);
   void downloadButtonClicked();
+  void addResourceClicked();
+  void uploadFileClicked();
 
 private:
   Ui::ctkXnatTreeBrowserMainWindow* ui;

Applications/ctkXnatTreeBrowser/ctkXnatTreeBrowserMainWindow.ui

@@ -6,7 +6,7 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>409</width>
+    <width>553</width>
     <height>325</height>
    </rect>
   </property>
@@ -25,6 +25,29 @@
        </widget>
       </item>
       <item>
+       <widget class="QPushButton" name="addResourceButton">
+        <property name="enabled">
+         <bool>false</bool>
+        </property>
+        <property name="toolTip">
+         <string>Creates a new resource folder</string>
+        </property>
+        <property name="text">
+         <string>Add Resource</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QPushButton" name="uploadFileButton">
+        <property name="enabled">
+         <bool>false</bool>
+        </property>
+        <property name="text">
+         <string>Upload File</string>
+        </property>
+       </widget>
+      </item>
+      <item>
        <widget class="QPushButton" name="downloadButton">
         <property name="enabled">
          <bool>false</bool>
@@ -85,8 +108,8 @@ font: 75 10pt &quot;Lucida Grande&quot;;</string>
     <rect>
      <x>0</x>
      <y>0</y>
-     <width>409</width>
-     <height>21</height>
+     <width>553</width>
+     <height>22</height>
     </rect>
    </property>
    <widget class="QMenu" name="menu_File">

CMakeExternals/qRestAPI.cmake

@@ -24,7 +24,7 @@ endif()
 
 if(NOT DEFINED ${proj}_DIR)
 
-  set(revision_tag "5f3a03b15d")
+  set(revision_tag "4293694a89")
   if(${proj}_REVISION_TAG)
     set(revision_tag ${${proj}_REVISION_TAG})
   endif()

Libs/XNAT/Core/CMakeLists.txt

@@ -21,10 +21,12 @@ set(KIT_SRCS
   ctkXnatReconstruction.cpp
   ctkXnatReconstructionFolder.cpp
   ctkXnatResource.cpp
+  ctkXnatResourceCatalogXmlParser.cpp
   ctkXnatScan.cpp
   ctkXnatScanFolder.cpp
   ctkXnatAssessor.cpp
   ctkXnatAssessorFolder.cpp
+  ctkXnatResourceFolder.cpp
   ctkXnatSession.cpp
   ctkXnatSettings.cpp
   ctkXnatSubject.cpp

Libs/XNAT/Core/Testing/ctkXnatSessionTest.cpp

@@ -223,7 +223,7 @@ void ctkXnatSessionTestCase::testCreateProject()
   bool exists = d->Session->exists(project);
   QVERIFY(!exists);
 
-  d->Session->save(project);
+  project->save();
 
   exists = d->Session->exists(project);
   QVERIFY(exists);

Libs/XNAT/Core/ctkXnatAPI.cpp

@@ -21,13 +21,20 @@
 
 // ctkXnatAPI includes
 #include "ctkXnatAPI_p.h"
+
+#include "ctkXnatResourceCatalogXmlParser.h"
+
 #include "qRestResult.h"
+
 #include <QNetworkReply>
 #include <QRegExp>
 #include <QUrl>
 #if (QT_VERSION >= QT_VERSION_CHECK(5,0,0))
 #include <QUrlQuery>
 #endif
+#include <QXmlDefaultHandler>
+#include <QXmlInputSource>
+#include <QXmlSimpleReader>
 
 // --------------------------------------------------------------------------
 // ctkXnatAPI methods
@@ -108,9 +115,21 @@ void ctkXnatAPI::parseResponse(qRestResult* restResult, const QByteArray& respon
 }
 
 // --------------------------------------------------------------------------
-QList<QVariantMap> ctkXnatAPI::parseXmlResponse(qRestResult* /*restResult*/, const QByteArray& /*response*/)
+QList<QVariantMap> ctkXnatAPI::parseXmlResponse(qRestResult* /*restResult*/, const QByteArray& response)
 {
+  QXmlInputSource xmlInput;
+  xmlInput.setData(response);
+  QXmlSimpleReader xmlReader;
+
   QList<QVariantMap> result;
+  // In this case a resource catalog xml was requested
+  if (response.contains("<cat:Catalog"))
+  {
+    ctkXnatResourceCatalogXmlParser parser;
+    xmlReader.setContentHandler(&parser);
+    xmlReader.parse(&xmlInput, true);
+    result = parser.md5Hashes();
+  }
   return result;
 }
 

Libs/XNAT/Core/ctkXnatFile.cpp

@@ -21,9 +21,14 @@
 
 #include "ctkXnatFile.h"
 
+#include "ctkXnatException.h"
 #include "ctkXnatObjectPrivate.h"
 #include "ctkXnatSession.h"
 
+#include <QCryptographicHash>
+#include <QDebug>
+#include <QFile>
+
 const QString ctkXnatFile::FILE_NAME = "Name";
 const QString ctkXnatFile::FILE_TAGS = "file_tags";
 const QString ctkXnatFile::FILE_FORMAT = "file_format";
@@ -41,10 +46,9 @@ public:
 
   void reset()
   {
-//    uri.clear();
   }
 
-//  QString uri;
+  QString localFilePath;
 };
 
 
@@ -77,6 +81,7 @@ void ctkXnatFile::setFileFormat(const QString &fileFormat)
   this->setProperty(FILE_FORMAT, fileFormat);
 }
 
+//----------------------------------------------------------------------------
 QString ctkXnatFile::fileFormat() const
 {
   return this->property(FILE_FORMAT);
@@ -88,6 +93,7 @@ void ctkXnatFile::setFileContent(const QString &fileContent)
   this->setProperty(FILE_CONTENT, fileContent);
 }
 
+//----------------------------------------------------------------------------
 QString ctkXnatFile::fileContent() const
 {
   return this->property(FILE_CONTENT);
@@ -99,20 +105,30 @@ void ctkXnatFile::setFileTags(const QString &fileTags)
   this->setProperty(FILE_TAGS, fileTags);
 }
 
+//----------------------------------------------------------------------------
 QString ctkXnatFile::fileTags() const
 {
   return this->property(FILE_TAGS);
 }
 
 //----------------------------------------------------------------------------
-QString ctkXnatFile::resourceUri() const
+void ctkXnatFile::setLocalFilePath(const QString &filePath)
 {
-  return QString("%1/files/%2").arg(parent()->resourceUri(), this->name());
+  Q_D(ctkXnatFile);
+  d->localFilePath = filePath;
 }
 
 //----------------------------------------------------------------------------
-void ctkXnatFile::upload(const QString& /*filename*/)
+QString ctkXnatFile::localFilePath() const
 {
+  Q_D(const ctkXnatFile);
+  return d->localFilePath;
+}
+
+//----------------------------------------------------------------------------
+QString ctkXnatFile::resourceUri() const
+{
+  return QString("%1/files/%2").arg(parent()->resourceUri(), this->name());
 }
 
 //----------------------------------------------------------------------------
@@ -124,6 +140,7 @@ void ctkXnatFile::reset()
 //----------------------------------------------------------------------------
 void ctkXnatFile::fetchImpl()
 {
+  // Does not make sense to fetch a file
 }
 
 //----------------------------------------------------------------------------
@@ -132,3 +149,95 @@ void ctkXnatFile::downloadImpl(const QString& filename)
   QString query = this->resourceUri();
   this->session()->download(filename, query);
 }
+
+//----------------------------------------------------------------------------
+void ctkXnatFile::saveImpl()
+{
+  Q_D(ctkXnatFile);
+  QString query = this->resourceUri();
+  QString filename = this->localFilePath();
+
+  QFile file(filename);
+
+  if (!file.exists())
+  {
+    QString msg = "Error uploading file! ";
+    msg.append(QString("File \"%1\" does not exist!").arg(filename));
+    throw ctkXnatException(msg);
+  }
+
+  // Creating the update query
+  query.append(QString("?%1=%2").arg("xsi:type", this->schemaType()));
+  const QMap<QString, QString>& properties = this->properties();
+  QMapIterator<QString, QString> itProperties(properties);
+  while (itProperties.hasNext())
+  {
+    itProperties.next();
+
+    // Do not append these file specific properties since they require a slightly
+    // different key for uploading a file (e.g. instead of "file_format" only "format")
+    if (itProperties.key() == FILE_TAGS || itProperties.key() == FILE_FORMAT ||
+        itProperties.key() == FILE_CONTENT)
+      continue;
+
+    query.append(QString("&%1=%2").arg(itProperties.key(), itProperties.value()));
+  }
+  query.append(QString("&%1=%2").arg("format", this->fileFormat()));
+  query.append(QString("&%1=%2").arg("content", this->fileContent()));
+  query.append(QString("&%1=%2").arg("tags", this->fileTags()));
+
+  // TODO May be flag for setting overwrite and not doing this automatically
+  if (this->exists())
+    query.append(QString("&%1=%2").arg("overwrite", true));
+
+  // Flag needed for file upload
+  query.append(QString("&%1=%2").arg("inbody", "true"));
+
+  this->session()->upload(filename, query);
+
+  // Validating the file upload by requesting the catalog XML
+  // of the parent resource. Unfortunately for XNAT versions <= 1.6.4
+  // this is the only way to get the file's MD5 hash form the server.
+  QString md5Query = this->parent()->resourceUri();
+  QUuid md5ID = this->session()->httpGet(md5Query);
+  QList<QVariantMap> result = this->session()->httpSync(md5ID);
+
+  QString md5ChecksumRemote ("0");
+  // Newly added files are usually at the end of the catalog
+  // and hence at the end of the result list. So iterating backwards
+  // is for performance reasons.
+  QList<QVariantMap>::const_iterator it = result.constEnd()-1;
+  while (it != result.constBegin()-1)
+  {
+    QVariantMap::const_iterator it2 = (*it).find(this->name());
+    if (it2 != (*it).constEnd())
+    {
+      md5ChecksumRemote = it2.value().toString();
+      break;
+    }
+    --it;
+  }
+
+  if (file.open(QFile::ReadOnly) && md5ChecksumRemote != "0")
+  {
+    QCryptographicHash hash(QCryptographicHash::Md5);
+    // TODO Do this in case of Qt5
+    //if (hash.addData(&file))
+    hash.addData(file.readAll());
+    QString md5ChecksumLocal(hash.result().toHex());
+    // Retrieving the md5 checksum on the server and comparing
+    // it with the local file md5 sum
+    if (md5ChecksumLocal != md5ChecksumRemote)
+    {
+      // Remove corrupted file from server
+      this->erase();
+      throw ctkXnatException("Upload failed! An error occurred during file upload.");
+    }
+  }
+  else
+  {
+    qWarning()<<"Could not validate file upload!";
+  }
+  // End file validation
+
+}

Libs/XNAT/Core/ctkXnatFile.h

@@ -56,7 +56,8 @@ public:
   void setFileContent(const QString& fileContent);
   QString fileContent() const;
 
-  void upload(const QString& filename);
+  void setLocalFilePath(const QString& filepath);
+  QString localFilePath() const;
 
   void reset();
 
@@ -71,6 +72,13 @@ private:
 
   virtual void downloadImpl(const QString&);
 
+  /**
+    * @brief Uploads the file to the server
+    * Before calling save() the localFilePath has to be set
+    * @throws ctkXnatException it the specified file does not exists
+    */
+  virtual void saveImpl();
+
   Q_DECLARE_PRIVATE(ctkXnatFile)
 };
 

Libs/XNAT/Core/ctkXnatObject.cpp

@@ -24,6 +24,9 @@
 
 #include "ctkXnatDataModel.h"
 #include "ctkXnatDefaultSchemaTypes.h"
+#include "ctkXnatException.h"
+#include "ctkXnatResource.h"
+#include "ctkXnatResourceFolder.h"
 #include "ctkXnatSession.h"
 
 #include <QDateTime>
@@ -112,7 +115,7 @@ QString ctkXnatObject::childDataType() const
   return "Resources";
 }
 
-QDateTime ctkXnatObject::lastModifiedTime()
+QDateTime ctkXnatObject::lastModifiedTimeOnServer()
 {
   Q_D(ctkXnatObject);
   QUuid queryId = this->session()->httpHead(this->resourceUri());
@@ -144,9 +147,6 @@ QDateTime ctkXnatObject::lastModifiedTime()
         break;
     }
   }
-
-  if (lastModifiedTime.isValid() && d->lastModifiedTime < lastModifiedTime)
-    this->setLastModifiedTime(lastModifiedTime);
   return lastModifiedTime;
 }
 
@@ -175,7 +175,11 @@ QString ctkXnatObject::property(const QString& name) const
 void ctkXnatObject::setProperty(const QString& name, const QVariant& value)
 {
   Q_D(ctkXnatObject);
-  d->properties.insert(name, value.toString());
+  if (d->properties[name] != value)
+  {
+    d->properties.insert(name, value.toString());
+    d->modified = true; //TODO some internal method for e.g. setting the ID for the first time
+  }
 }
 
 //----------------------------------------------------------------------------
@@ -224,13 +228,21 @@ void ctkXnatObject::add(ctkXnatObject* child)
   {
     child->d_func()->parent = this;
   }
-  if (!d->children.contains(child))
+
+  bool childExists (false);
+  foreach (ctkXnatObject* existingChild, d->children)
   {
-    d->children.push_back(child);
+    if ((existingChild->id().length() != 0 && existingChild->id() == child->id()) ||
+        (existingChild->id().length() == 0 && existingChild->name() == child->name()))
+    {
+      d->children.replace(d->children.indexOf(existingChild), child);
+      childExists = true;
+      qWarning() << "ctkXnatObject::add(): Child already exists -> Replaced child!";
+    }
   }
-  else
+  if (!childExists)
   {
-    qWarning() << "ctkXnatObject::add(): Child already exists";
+    d->children.push_back(child);
   }
 }
 
@@ -302,43 +314,117 @@ void ctkXnatObject::download(const QString& filename)
 }
 
 //----------------------------------------------------------------------------
-void ctkXnatObject::upload(const QString& /*zipFilename*/)
+void ctkXnatObject::save()
 {
+  Q_D(ctkXnatObject);
+  this->saveImpl();
+  d->modified = false;
 }
 
 //----------------------------------------------------------------------------
-bool ctkXnatObject::exists() const
+void ctkXnatObject::addResource(QString foldername, QString format,
+                                   QString content, QString tags)
 {
-  return this->session()->exists(this);
+  if (foldername.size() == 0)
+  {
+    throw ctkXnatException("Error creating resource! Foldername must not be empty!");
+  }
+
+  ctkXnatResourceFolder* resFolder = 0;
+  QList<ctkXnatObject*> children = this->children();
+  for (unsigned int i = 0; i < children.size(); ++i)
+  {
+    resFolder = dynamic_cast<ctkXnatResourceFolder*>(children.at(i));
+    if (resFolder)
+    {
+      break;
+    }
+  }
+
+  if (!resFolder)
+  {
+    resFolder = new ctkXnatResourceFolder();
+    this->add(resFolder);
+  }
+
+  ctkXnatResource* resource = new ctkXnatResource();
+  resource->setName(foldername);
+  if (format.size() != 0)
+    resource->setFormat(format);
+  if (content.size() != 0)
+    resource->setContent(content);
+  if (tags.size() != 0)
+    resource->setTags(tags);
+
+  resFolder->add(resource);
+  resource->save();
 }
 
 //----------------------------------------------------------------------------
-void ctkXnatObject::save()
+bool ctkXnatObject::exists() const
 {
-  this->session()->save(this);
+  return this->session()->exists(this);
 }
 
 //----------------------------------------------------------------------------
-void ctkXnatObject::fetchResources(const QString& path)
+void ctkXnatObject::saveImpl()
 {
-  QString query = this->resourceUri() + path;
-  ctkXnatSession* const session = this->session();
-  QUuid queryId = session->httpGet(query);
-
-  QList<ctkXnatObject*> resources = session->httpResults(queryId,
-                                                           ctkXnatDefaultSchemaTypes::XSI_RESOURCE);
+  Q_D(ctkXnatObject);
+  QString query = this->resourceUri();
 
-  foreach (ctkXnatObject* resource, resources)
+  // If there is already a valid last-modification-time, otherwise the
+  // object is not yet on the server!
+  QDateTime remoteModTime;
+  if (d->lastModifiedTime.isValid())
   {
-    QString label = resource->name();
-    if (label.isEmpty())
+    // TODO Overwrite this for e.g. project and subject which already support modification time!
+    remoteModTime = this->lastModifiedTimeOnServer();
+    // If the object has been modified on the server, perform an update
+    if (d->lastModifiedTime < remoteModTime)
     {
-      label = "NO NAME";
+      qDebug()<<"Object maybe overwritten on server!";
+      // TODO update from server, since modification time is not really supported
+      // by xnat right now this is not of high priority
+      // something like this->updateImpl + setLastModifiedTime()
     }
+  }
+
+  // Creating the update query
+  query.append(QString("?%1=%2").arg("xsi:type", this->schemaType()));
+  const QMap<QString, QString>& properties = this->properties();
+  QMapIterator<QString, QString> itProperties(properties);
+  while (itProperties.hasNext())
+  {
+    itProperties.next();
+    if (itProperties.key() == "ID")
+      continue;
+    query.append(QString("&%1=%2").arg(itProperties.key(), itProperties.value()));
+  }
+
+  // Execute the update
+  QUuid queryID = this->session()->httpPut(query);
+  const QList<QVariantMap> results = this->session()->httpSync(queryID);
 
-    resource->setName(label);
-    this->add(resource);
+  // If this xnat object did not exist before on the server set the ID returned by Xnat
+  if (results.size() == 1 && results[0].size() == 1)
+  {
+    QVariant id = results[0][ID];
+    if (!id.isNull())
+    {
+      this->setId(id.toString());
+    }
   }
+
+  // Finally update the modification time on the server
+  remoteModTime = this->lastModifiedTimeOnServer();
+  d->lastModifiedTime = remoteModTime;
+}
+
+//----------------------------------------------------------------------------
+void ctkXnatObject::fetchResources(const QString& path)
+{
+  ctkXnatResourceFolder* resFolder = new ctkXnatResourceFolder();
+  this->add(resFolder);
 }
 
 //----------------------------------------------------------------------------

Libs/XNAT/Core/ctkXnatObject.h

@@ -78,7 +78,7 @@ public:
   void setProperty(const QString& name, const QVariant& value);
 
   /// Gets the last modification time from the server
-  QDateTime lastModifiedTime();
+  virtual QDateTime lastModifiedTimeOnServer();
 
   /// Sets the last modfication time on the server
   void setLastModifiedTime(const QDateTime& lastModifiedTime);
@@ -100,7 +100,7 @@ public:
   /// Adds an object to the children of the current one.
   void add(ctkXnatObject* child);
 
-  /// Removes the object from the children of the current object and removes it from the XNAT server.
+  /// Removes the object from the children of the current object.
   void remove(ctkXnatObject* child);
 
   /// Tells if the children and the properties of the objects have been fetched.
@@ -128,7 +128,10 @@ public:
   void erase();
 
   void download(const QString&);
-  virtual void upload(const QString&);
+
+  /// Creates the object on the XNAT server and sets the new ID.
+  virtual void addResource(QString foldername,
+                           QString format = "", QString content = "", QString tags = "");
 
   //QObject* asyncObject() const;
 
@@ -181,6 +184,10 @@ private:
   /// The implementation of the download mechanism, called by the download(const QString&) function.
   virtual void downloadImpl(const QString&) = 0;
 
+  /// The implementation of the upload mechanism, called by the save() function.
+  /// Subclasses of ctkXnatObject can overwrite this function if needed
+  virtual void saveImpl();
+
   Q_DECLARE_PRIVATE(ctkXnatObject)
 };
 

Libs/XNAT/Core/ctkXnatObjectPrivate.h

@@ -56,6 +56,10 @@ private:
 
   bool fetched;
 
+  // Indicates whether a xnatObject is locally modified and not yet
+  // synchronized with its instance on the server
+  bool modified;
+
   ctkXnatObject* parent;
 };
 

Libs/XNAT/Core/ctkXnatResource.cpp

@@ -24,6 +24,10 @@
 #include "ctkXnatObjectPrivate.h"
 #include "ctkXnatSession.h"
 
+const QString ctkXnatResource::TAGS = "tags";
+const QString ctkXnatResource::FORMAT = "format";
+const QString ctkXnatResource::CONTENT = "content";
+
 const QString ctkXnatResource::ID = "xnat_abstractresource_id";
 //----------------------------------------------------------------------------
 class ctkXnatResourcePrivate : public ctkXnatObjectPrivate
@@ -51,7 +55,7 @@ ctkXnatResource::~ctkXnatResource()
 //----------------------------------------------------------------------------
 QString ctkXnatResource::resourceUri() const
 {
-  return QString("%1/resources/%2").arg(parent()->resourceUri(), this->id());
+  return QString("%1/%2").arg(parent()->resourceUri(), this->name());
 }
 
 //----------------------------------------------------------------------------
@@ -91,6 +95,41 @@ void ctkXnatResource::setLabel(const QString &label)
 }
 
 //----------------------------------------------------------------------------
+void ctkXnatResource::setFormat(const QString &fileFormat)
+{
+  this->setProperty(FORMAT, fileFormat);
+}
+
+//----------------------------------------------------------------------------
+QString ctkXnatResource::format() const
+{
+  return this->property(FORMAT);
+}
+
+//----------------------------------------------------------------------------
+void ctkXnatResource::setContent(const QString &fileContent)
+{
+  this->setProperty(CONTENT, fileContent);
+}
+
+//----------------------------------------------------------------------------
+QString ctkXnatResource::content() const
+{
+  return this->property(CONTENT);
+}
+
+//----------------------------------------------------------------------------
+void ctkXnatResource::setTags(const QString &fileTags)
+{
+  this->setProperty(TAGS, fileTags);
+}
+
+//----------------------------------------------------------------------------
+QString ctkXnatResource::tags() const
+{
+  return this->property(TAGS);
+}
+//----------------------------------------------------------------------------
 void ctkXnatResource::reset()
 {
   ctkXnatObject::reset();
@@ -126,3 +165,22 @@ void ctkXnatResource::downloadImpl(const QString& filename)
   parameters["format"] = "zip";
   this->session()->download(filename, query, parameters);
 }
+
+//----------------------------------------------------------------------------
+void ctkXnatResource::saveImpl()
+{
+  QString query = this->resourceUri();
+
+  query.append(QString("?%1=%2").arg("xsi:type", this->schemaType()));
+  const QMap<QString, QString>& properties = this->properties();
+  QMapIterator<QString, QString> itProperties(properties);
+  while (itProperties.hasNext())
+  {
+    itProperties.next();
+    if (itProperties.key() == ID || itProperties.key() == "xsiType")
+      continue;
+    query.append(QString("&%1=%2").arg(itProperties.key(), itProperties.value()));
+  }
+  QUuid queryId = this->session()->httpPut(query);
+  session()->httpResults(queryId, ctkXnatDefaultSchemaTypes::XSI_RESOURCE);
+}

Libs/XNAT/Core/ctkXnatResource.h

@@ -56,11 +56,23 @@ public:
   /// Sets the label of the object.
   void setLabel(const QString& label);
 
+  void setFormat(const QString& format);
+  QString format() const;
+
+  void setTags(const QString& tags);
+  QString tags() const;
+
+  void setContent(const QString& content);
+  QString content() const;
+
   void reset();
 
-  void download(const QString& filename);
+  void saveImpl();
 
   static const QString ID;
+  static const QString TAGS;
+  static const QString FORMAT;
+  static const QString CONTENT;
 
 private:
 

Libs/XNAT/Core/ctkXnatResourceCatalogXmlParser.cpp

@@ -0,0 +1,86 @@
+/*=============================================================================
+
+  Library: XNAT/Core
+
+  Copyright (c) German Cancer Research Center,
+    Division of Medical and Biological Informatics
+
+  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 "ctkXnatResourceCatalogXmlParser.h"
+
+#include <QDebug>
+
+//----------------------------------------------------------------------------
+class ctkXnatResourceCatalogXmlParserPrivate
+{
+public:
+
+  ctkXnatResourceCatalogXmlParserPrivate()
+  {
+  }
+
+  QList<QVariantMap> result;
+};
+
+ctkXnatResourceCatalogXmlParser::ctkXnatResourceCatalogXmlParser()
+  : d_ptr (new ctkXnatResourceCatalogXmlParserPrivate())
+{
+}
+ctkXnatResourceCatalogXmlParser::~ctkXnatResourceCatalogXmlParser()
+{
+  delete d_ptr;
+}
+
+bool ctkXnatResourceCatalogXmlParser::startElement(const QString &/*namespaceURI*/, const QString &localName,
+                                                   const QString &qName, const QXmlAttributes &atts)
+{
+  Q_D(ctkXnatResourceCatalogXmlParser);
+  if (qName == "cat:entry")
+  {
+    QString name("");
+    QString md5("");
+    QVariantMap map;
+    for( int i=0; i<atts.count(); i++ )
+    {
+      // TODO ID would be better
+      if( atts.localName(i) == "name")
+        name = atts.value(i);
+
+      if( atts.localName( i ) == "digest" )
+      {
+        md5 = atts.value(i);
+      }
+    }
+
+    if (name.length() == 0 || md5.length() == 0)
+    {
+      qWarning()<<"Error parsing XNAT resource catalog xml!";
+      return false;
+    }
+    else
+    {
+      map[name] = QVariant(md5);
+      d->result.append(map);
+    }
+  }
+  return true;
+}
+
+const QList<QVariantMap>& ctkXnatResourceCatalogXmlParser::md5Hashes()
+{
+  Q_D(ctkXnatResourceCatalogXmlParser);
+  return d->result;
+}

Libs/XNAT/Core/ctkXnatResourceCatalogXmlParser.h

@@ -0,0 +1,73 @@
+/*=============================================================================
+
+  Library: XNAT/Core
+
+  Copyright (c) German Cancer Research Center,
+    Division of Medical and Biological Informatics
+
+  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.
+
+=============================================================================*/
+
+#ifndef CTKXNATRESOURCECATALOGXMLPARSER_H
+#define CTKXNATRESOURCECATALOGXMLPARSER_H
+
+#include "ctkXNATCoreExport.h"
+
+#include <QXmlDefaultHandler>
+
+class ctkXnatResourceCatalogXmlParserPrivate;
+
+/**
+ * @brief Parses the xml response when requesting the catalog xml of a resource
+ *
+ * When sending the following request to XNAT:
+ * <xnat-url>/projects/myProject/resources/<resource-id>
+ * you get the catalog xml of the resource folder as response
+ *
+ * This class parses this response and returns the MD5 hashes of all the resource files,
+ * which are contained by the resource folder.
+ *
+ * @ingroup XNAT_Core
+ */
+class CTK_XNAT_CORE_EXPORT ctkXnatResourceCatalogXmlParser : public QXmlDefaultHandler
+{
+
+public:
+  ctkXnatResourceCatalogXmlParser();
+  ~ctkXnatResourceCatalogXmlParser();
+
+  /**
+   * Overwrites QXmlDefaultHandler::startElement()
+   */
+  bool startElement(const QString &namespaceURI, const QString &localName,
+                    const QString &qName, const QXmlAttributes &atts);
+
+  /**
+   * @brief Returns the md5 hashes of the resource files
+   * @return A list of QVariantMaps, which contain the md5 hashes
+   */
+  const QList<QVariantMap>& md5Hashes();
+
+private:
+
+  ctkXnatResourceCatalogXmlParser(const ctkXnatResourceCatalogXmlParser& );
+  ctkXnatResourceCatalogXmlParser& operator=(const ctkXnatResourceCatalogXmlParser& );
+
+  /// The private implementation part of the object.
+  ctkXnatResourceCatalogXmlParserPrivate* d_ptr;
+
+  Q_DECLARE_PRIVATE(ctkXnatResourceCatalogXmlParser)
+};
+
+#endif //CTKXNATRESOURCECATALOGXMLPARSER_H

Libs/XNAT/Core/ctkXnatResourceFolder.cpp

@@ -0,0 +1,108 @@
+/*=============================================================================
+
+  Library: XNAT/Core
+
+  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 "ctkXnatResourceFolder.h"
+
+#include "ctkXnatDefaultSchemaTypes.h"
+#include "ctkXnatObjectPrivate.h"
+#include "ctkXnatResource.h"
+#include "ctkXnatSession.h"
+
+//----------------------------------------------------------------------------
+class ctkXnatResourceFolderPrivate : public ctkXnatObjectPrivate
+{
+public:
+
+  ctkXnatResourceFolderPrivate()
+  : ctkXnatObjectPrivate()
+  {
+  }
+
+  void reset()
+  {
+  }
+
+};
+
+
+//----------------------------------------------------------------------------
+ctkXnatResourceFolder::ctkXnatResourceFolder(ctkXnatObject* parent)
+  : ctkXnatObject(*new ctkXnatResourceFolderPrivate(), parent, QString::null)
+{
+  this->setId("resources");
+  this->setProperty(LABEL, "Resources");
+}
+
+//----------------------------------------------------------------------------
+ctkXnatResourceFolder::~ctkXnatResourceFolder()
+{
+}
+
+//----------------------------------------------------------------------------
+QString ctkXnatResourceFolder::resourceUri() const
+{
+  return QString("%1/%2").arg(parent()->resourceUri(), this->id());
+}
+
+//----------------------------------------------------------------------------
+void ctkXnatResourceFolder::reset()
+{
+  ctkXnatObject::reset();
+}
+
+//----------------------------------------------------------------------------
+void ctkXnatResourceFolder::fetchImpl()
+{
+  QString query = this->resourceUri();
+  ctkXnatSession* const session = this->session();
+  QUuid queryId = session->httpGet(query);
+
+  QList<ctkXnatObject*> resources = session->httpResults(queryId,
+                                                           ctkXnatDefaultSchemaTypes::XSI_RESOURCE);
+
+  foreach (ctkXnatObject* resource, resources)
+  {
+    QString label = resource->name();
+    if (label.isEmpty())
+    {
+      label = "NO NAME";
+    }
+
+    resource->setName(label);
+    this->add(resource);
+  }
+}
+
+//----------------------------------------------------------------------------
+void ctkXnatResourceFolder::downloadImpl(const QString& filename)
+{
+  QString query = this->resourceUri() + "/ALL/files";
+  ctkXnatSession::UrlParameters parameters;
+  parameters["format"] = "zip";
+  this->session()->download(filename, query, parameters);
+}
+
+//----------------------------------------------------------------------------
+void ctkXnatResourceFolder::saveImpl()
+{
+  // Not implemented since a resource folder is automatically created when
+  // a resource is uploaded
+}

Libs/XNAT/Core/ctkXnatResourceFolder.h

@@ -0,0 +1,57 @@
+/*=============================================================================
+
+  Library: XNAT/Core
+
+  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.
+
+=============================================================================*/
+
+#ifndef ctkXnatResourceFolder_h
+#define ctkXnatResourceFolder_h
+
+#include "ctkXNATCoreExport.h"
+
+#include "ctkXnatObject.h"
+
+class ctkXnatResourceFolderPrivate;
+
+/**
+ * @ingroup XNAT_Core
+ */
+class CTK_XNAT_CORE_EXPORT ctkXnatResourceFolder : public ctkXnatObject
+{
+
+public:
+
+  ctkXnatResourceFolder(ctkXnatObject* parent = NULL);
+
+  virtual ~ctkXnatResourceFolder();
+
+  virtual QString resourceUri() const;
+
+  void reset();
+
+private:
+
+  friend class qRestResult;
+  virtual void fetchImpl();
+  virtual void downloadImpl(const QString&);
+  virtual void saveImpl();
+
+  Q_DECLARE_PRIVATE(ctkXnatResourceFolder)
+};
+
+#endif

Libs/XNAT/Core/ctkXnatSession.cpp

@@ -37,6 +37,7 @@
 
 #include <QDateTime>
 #include <QDebug>
+#include <QDir>
 #include <QScopedPointer>
 #include <QStringBuilder>
 #include <QNetworkCookie>
@@ -61,6 +62,7 @@ public:
   QScopedPointer<ctkXnatAPI> xnat;
   QScopedPointer<ctkXnatDataModel> dataModel;
   QString sessionId;
+  QString defaultFilePath;
 
   QMap<QString, QString> sessionProperties;
 
@@ -87,6 +89,7 @@ ctkXnatSessionPrivate::ctkXnatSessionPrivate(const ctkXnatLoginProfile& loginPro
                                              ctkXnatSession* q)
   : loginProfile(loginProfile)
   , xnat(new ctkXnatAPI())
+  , defaultFilePath("")
   , q(q)
 {
   // TODO This is a workaround for connecting to sites with self-signed
@@ -329,6 +332,12 @@ ctkXnatSession::ctkXnatSession(const ctkXnatLoginProfile& loginProfile)
   QString url = d->loginProfile.serverUrl().toString();
   d->xnat->setServerUrl(url);
 
+  QObject::connect(d->xnat.data(), SIGNAL(uploadFinished()), this, SIGNAL(uploadFinished()));
+  QObject::connect(d->xnat.data(), SIGNAL(progress(QUuid,double)),
+          this, SIGNAL(progress(QUuid,double)));
+//  QObject::connect(d->xnat.data(), SIGNAL(progress(QUuid,double)),
+//          this, SLOT(onProgress(QUuid,double)));
+
   d->setDefaultHttpHeaders();
 }
 
@@ -432,7 +441,7 @@ ctkXnatLoginProfile ctkXnatSession::loginProfile() const
 }
 
 //----------------------------------------------------------------------------
-void ctkXnatSession::progress(QUuid /*queryId*/, double /*progress*/)
+void ctkXnatSession::onProgress(QUuid /*queryId*/, double /*progress*/)
 {
 //  qDebug() << "ctkXnatSession::progress(QUuid queryId, double progress)";
 //  qDebug() << "query id:" << queryId;
@@ -468,6 +477,30 @@ QString ctkXnatSession::sessionId() const
 }
 
 //----------------------------------------------------------------------------
+void ctkXnatSession::setDefaultFilePath(const QString &path)
+{
+  Q_D(ctkXnatSession);
+
+  QDir directory(path);
+  if (directory.exists() && path.size() != 0)
+  {
+    d->defaultFilePath = path;
+  }
+  else
+  {
+    d->defaultFilePath = QDir::currentPath();
+    qWarning() << "Specified directory: ["<<path<<"] does not exists! Setting default filepath to :"<<d->defaultFilePath;
+  }
+}
+
+//----------------------------------------------------------------------------
+QString ctkXnatSession::defaultFilePath() const
+{
+  Q_D(const ctkXnatSession);
+  return d->defaultFilePath;
+}
+
+//----------------------------------------------------------------------------
 ctkXnatDataModel* ctkXnatSession::dataModel() const
 {
   Q_D(const ctkXnatSession);
@@ -497,6 +530,13 @@ QList<ctkXnatObject*> ctkXnatSession::httpResults(const QUuid& uuid, const QStri
   return d->results(restResult.data(), schemaType);
 }
 
+QUuid ctkXnatSession::httpPut(const QString& resource, const ctkXnatSession::UrlParameters& parameters, const ctkXnatSession::HttpRawHeaders& rawHeaders)
+{
+  Q_D(ctkXnatSession);
+  d->checkSession();
+  return d->xnat->put(resource);
+}
+
 //----------------------------------------------------------------------------
 QList<QVariantMap> ctkXnatSession::httpSync(const QUuid& uuid)
 {
@@ -518,17 +558,6 @@ QList<QVariantMap> ctkXnatSession::httpSync(const QUuid& uuid)
 }
 
 //----------------------------------------------------------------------------
-bool ctkXnatSession::exists(const ctkXnatObject* object)
-{
-  Q_D(ctkXnatSession);
-
-  QString query = object->resourceUri();
-  bool success = d->xnat->sync(d->xnat->get(query));
-
-  return success;
-}
-
-//----------------------------------------------------------------------------
 const QMap<QByteArray, QByteArray> ctkXnatSession::httpHeadSync(const QUuid &uuid)
 {
   Q_D(ctkXnatSession);
@@ -549,38 +578,14 @@ QUuid ctkXnatSession::httpHead(const QString& resourceUri)
 }
 
 //----------------------------------------------------------------------------
-void ctkXnatSession::save(ctkXnatObject* object)
+bool ctkXnatSession::exists(const ctkXnatObject* object)
 {
   Q_D(ctkXnatSession);
 
   QString query = object->resourceUri();
-  query.append(QString("?%1=%2").arg("xsi:type", object->schemaType()));
-  const QMap<QString, QString>& properties = object->properties();
-  QMapIterator<QString, QString> itProperties(properties);
-  while (itProperties.hasNext())
-  {
-    itProperties.next();
-    query.append(QString("&%1=%2").arg(itProperties.key(), itProperties.value()));
-  }
-
-  qDebug() << "ctkXnatSession::save() query:" << query;
-  QUuid queryId = d->xnat->put(query);
-  qRestResult* result = d->xnat->takeResult(queryId);
-
-  if (!result || !result->error().isNull())
-  {
-    d->throwXnatException("Error occurred while creating the data.");
-  }
+  bool success = d->xnat->sync(d->xnat->get(query));
 
-  const QList<QVariantMap>& maps = result->results();
-  if (maps.size() == 1 && maps[0].size() == 1)
-  {
-    QVariant id = maps[0][ctkXnatObject::ID];
-    if (!id.isNull())
-    {
-      object->setId(id.toString());
-    }
-  }
+  return success;
 }
 
 //----------------------------------------------------------------------------
@@ -610,6 +615,17 @@ void ctkXnatSession::download(const QString& fileName,
 }
 
 //----------------------------------------------------------------------------
+void ctkXnatSession::upload(const QString &fileName,
+                            const QString &resource,
+                            const UrlParameters &parameters,
+                            const HttpRawHeaders &rawHeaders)
+{
+  Q_D(ctkXnatSession);
+  QUuid queryId = d->xnat->upload(fileName, resource, parameters);
+  d->xnat->sync(queryId);
+}
+
+//----------------------------------------------------------------------------
 void ctkXnatSession::processResult(QUuid queryId, QList<QVariantMap> parameters)
 {
   Q_UNUSED(queryId)

Libs/XNAT/Core/ctkXnatSession.h

@@ -146,6 +146,24 @@ public:
    */
   QString sessionId() const;
 
+  /**
+    * @brief Sets the default location where files will be save after being downloaded
+    *
+    * Sets the default directory into which file downloads will be saved.
+    * By default this value is empty and files will be stored into the directory
+    * of the executable.
+    * If the path does not exists a warning will be printed and the path will be
+    * set to the current working directory
+    *
+    * @param path the path to the download location
+    */
+  void setDefaultFilePath(const QString& path);
+
+  /**
+    * @brief returns the default download location
+    * @return the default download directory as string
+    */
+  QString defaultFilePath() const;
 
   ctkXnatDataModel* dataModel() const;
 
@@ -175,6 +193,18 @@ public:
   /**
    * @brief TODO
    * @param uuid
+   * @param parameters
+   *
+   * @throws ctkXnatInvalidSessionException if the session is closed.
+   * @return
+   */
+   QUuid httpPut(const QString& resource,
+                const UrlParameters& parameters = UrlParameters(),
+                const HttpRawHeaders& rawHeaders = HttpRawHeaders());
+
+  /**
+   * @brief TODO
+   * @param uuid
    *
    * @throws ctkXnatInvalidSessionException if the session is closed.
    * @return
@@ -192,7 +222,6 @@ public:
 
   bool exists(const ctkXnatObject* object);
 
-  void save(ctkXnatObject* object);
   void remove(ctkXnatObject* object);
 
   /// Downloads a file from the web service.
@@ -206,6 +235,17 @@ public:
     const UrlParameters& parameters = UrlParameters(),
     const HttpRawHeaders& rawHeaders = HttpRawHeaders());
 
+  /// Uploads a file to the web service.
+  /// \a fileName is the name of the file.
+  /// The \a resource and \parameters are used to compose the URL.
+  /// \a rawHeaders can be used to set the raw headers of the request to send.
+  /// These headers will be set additionally to those defined by the
+  /// \a defaultRawHeaders property.
+  void upload(const QString& fileName,
+    const QString& resource,
+    const UrlParameters& parameters = UrlParameters(),
+    const HttpRawHeaders& rawHeaders = HttpRawHeaders());
+
   /**
    * @brief Sends a http HEAD request to the xnat instance
    * @param resourceUri the URL to the server
@@ -229,9 +269,13 @@ public:
    */
   Q_SIGNAL void sessionAboutToBeClosed();
 
+  Q_SIGNAL void uploadFinished();
+
+  Q_SIGNAL void progress(QUuid, double);
+
 public slots:
   void processResult(QUuid queryId, QList<QVariantMap> parameters);
-  void progress(QUuid queryId, double progress);
+  void onProgress(QUuid queryId, double onProgress);
 
 protected:
   QScopedPointer<ctkXnatSessionPrivate> d_ptr;

Libs/XNAT/Core/ctkXnatTreeModel.cpp

@@ -298,15 +298,12 @@ void ctkXnatTreeModel::downloadFile(const QModelIndex& index, const QString& zip
 }
 
 //----------------------------------------------------------------------------
-void ctkXnatTreeModel::uploadFile(const QModelIndex& index, const QString& zipFileName)
+void ctkXnatTreeModel::addChildNode(const QModelIndex &index, ctkXnatObject* child)
 {
-  if (!index.isValid())
-  {
-    return;
-  }
-
-  ctkXnatObject* xnatObject = this->xnatObject(index);
-  ctkXnatObject* child = xnatObject->children()[index.row()];
+  Q_D(ctkXnatTreeModel);
+  ctkXnatTreeItem* item = d->itemAt(index);
 
-  child->upload(zipFileName);
+  beginInsertRows(index, 0, 1);
+  item->appendChild(new ctkXnatTreeItem(child, item));
+  endInsertRows();
 }

Libs/XNAT/Core/ctkXnatTreeModel.h

@@ -57,9 +57,10 @@ public:
 
   bool removeAllRows(const QModelIndex& parent);
 
-  void uploadFile(const QModelIndex& index, const QString& zipFilename);
   void downloadFile (const QModelIndex& index, const QString& zipFilename);
 
+  void addChildNode(const QModelIndex& index, ctkXnatObject *child);
+
 private:
 
   const QScopedPointer<ctkXnatTreeModelPrivate> d_ptr;

Libs/XNAT/Widgets/ctkXnatLoginDialog.cpp

@@ -212,6 +212,7 @@ void ctkXnatLoginDialog::accept()
     return;
     }
   d->Session = session.take();
+  d->Session->setDefaultFilePath(ui->edtDownloadDir->text());
 
   QDialog::accept();
 }

Libs/XNAT/Widgets/ctkXnatLoginDialog.ui

@@ -156,13 +156,23 @@
            </property>
           </widget>
          </item>
-         <item row="5" column="1">
+         <item row="5" column="0">
+          <widget class="QLabel" name="lblDownloadDir">
+           <property name="text">
+            <string>Download Dir.:</string>
+           </property>
+          </widget>
+         </item>
+         <item row="6" column="1">
           <widget class="QCheckBox" name="cbxDefaultProfile">
            <property name="text">
             <string>Use as default</string>
            </property>
           </widget>
          </item>
+         <item row="5" column="1">
+          <widget class="QLineEdit" name="edtDownloadDir"/>
+         </item>
         </layout>
        </widget>
       </item>
@@ -186,7 +196,6 @@
   <tabstop>edtServerUri</tabstop>
   <tabstop>edtUserName</tabstop>
   <tabstop>edtPassword</tabstop>
-  <tabstop>cbxDefaultProfile</tabstop>
   <tabstop>btnSave</tabstop>
   <tabstop>btnDelete</tabstop>
   <tabstop>lstProfiles</tabstop>