Reconstruction support is back

Libs/XNAT/Core/CMakeLists.txt

@@ -18,10 +18,10 @@ set(KIT_SRCS
   ctkXnatScanFolder.cpp
   ctkXnatScanResource.cpp
   ctkXnatScanResourceFile.cpp
-  #ctkXnatReconstruction.cpp
-  #ctkXnatReconstructionFolder.cpp
-  #ctkXnatReconstructionResource.cpp
-  #ctkXnatReconstructionResourceFile.cpp
+  ctkXnatReconstruction.cpp
+  ctkXnatReconstructionFolder.cpp
+  ctkXnatReconstructionResource.cpp
+  ctkXnatReconstructionResourceFile.cpp
   ctkXnatServer.cpp
   ctkXnatSettings.cpp
   ctkXnatSubject.cpp
@@ -29,20 +29,6 @@ set(KIT_SRCS
 
 # Files which should be processed by Qts moc
 set(KIT_MOC_SRCS
-  #ctkXnatConnection.h
-  #ctkXnatExperiment.h
-  #ctkXnatObject.h
-  #ctkXnatProject.h
-  #ctkXnatReconstruction.h
-  #ctkXnatReconstructionFolder.h
-  #ctkXnatReconstructionResource.h
-  #ctkXnatReconstructionResourceFile.h
-  #ctkXnatScan.h
-  #ctkXnatScanFolder.h
-  #ctkXnatScanResource.h
-  #ctkXnatScanResourceFile.h
-  #ctkXnatServer.h
-  #ctkXnatSubject.h
 )
 
 

Libs/XNAT/Core/ctkXnatConnection.cpp

@@ -253,18 +253,23 @@ void ctkXnatConnection::fetch(const QSharedPointer<ctkXnatExperiment>& experimen
     experiment->addChild(ptr);
   }
   
-  // The reconstruction scans are not supported by XNAT so we don't fetch them
+  delete restResult;
 
-//  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);
-//  }
+  QString reconstructionsUri = experiment->uri() + "/reconstructions";
+  QUuid reconstructionsQueryId = d->xnat->get(reconstructionsUri);
+  restResult = d->xnat->takeResult(reconstructionsQueryId);
+
+  QList<ctkXnatReconstruction*> reconstructions = restResult->results<ctkXnatReconstruction>();
+
+  if (reconstructions.size() > 0)
+  {
+    ctkXnatObject::Pointer ptr = ctkXnatReconstructionFolder::Create();
+
+    ptr->setUri(reconstructionsUri);
 
+    ptr->d_func()->selfPtr = ptr;
+    experiment->addChild(ptr);
+  }
 
   delete restResult;
 }
@@ -350,92 +355,86 @@ void ctkXnatConnection::fetch(const QSharedPointer<ctkXnatScanResource>& scanRes
   }
 }
 
-//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();
+void ctkXnatConnection::fetch(const QSharedPointer<ctkXnatReconstructionFolder>& reconstructionFolder)
+{
+  Q_D(ctkXnatConnection);
 
-//  Q_D(ctkXnatConnection);
+  QString reconstructionsUri = reconstructionFolder->uri();
+  QUuid queryId = d->xnat->get(reconstructionsUri);
+  qRestResult* restResult = d->xnat->takeResult(queryId);
 
-//  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.");
-//  }
+  QList<ctkXnatReconstruction*> reconstructions = restResult->results<ctkXnatReconstruction>();
 
-//  foreach (QVariantMap map, result)
-//  {
-//    QString reconstructionID = map["ID"].toString();
-//    ctkXnatReconstruction* reconstruction = new ctkXnatReconstruction(reconstructionFolder);
-//    reconstructionFolder->addChild(reconstructionID, reconstruction);
-//  }
-//}
+  foreach (ctkXnatReconstruction* reconstruction, reconstructions)
+  {
+    reconstruction->setUri(reconstructionsUri + "/" + reconstruction->id());
 
-//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();
+    ctkXnatObject::Pointer ptr(reconstruction);
+    ptr->d_func()->selfPtr = ptr;
+    reconstructionFolder->addChild(ptr);
+  }
 
-//  Q_D(ctkXnatConnection);
+  delete restResult;
 
-//  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(const QSharedPointer<ctkXnatReconstruction>& reconstruction)
+{
+  Q_D(ctkXnatConnection);
 
-//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();
+  QString reconstructionResourcesUri = reconstruction->uri() + "/resources";
+  QUuid queryId = d->xnat->get(reconstructionResourcesUri);
+  qRestResult* restResult = d->xnat->takeResult(queryId);
 
-//  Q_D(ctkXnatConnection);
+  QList<ctkXnatReconstructionResource*> reconstructionResources = restResult->results<ctkXnatReconstructionResource>();
 
-//  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 (ctkXnatReconstructionResource* reconstructionResource, reconstructionResources)
+  {
+    QString label = reconstructionResource->property("label");
+    if (label.size())
+    {
+      reconstructionResource->setProperty("ID", label);
+    }
 
-//  foreach (QVariantMap map, result)
-//  {
-//    QString reconstructionResourceFileName = map["Name"].toString();
-//    ctkXnatReconstructionResourceFile* reconstructionResourceFile = new ctkXnatReconstructionResourceFile(reconstructionResource);
-//    reconstructionResource->addChild(reconstructionResourceFileName, reconstructionResourceFile);
-//  }
-//}
+    reconstructionResource->setUri(reconstructionResourcesUri + "/" + label);
 
+    ctkXnatObject::Pointer ptr(reconstructionResource);
+    ptr->d_func()->selfPtr = ptr;
+    reconstruction->addChild(ptr);
+  }
+}
 
+void ctkXnatConnection::fetch(const QSharedPointer<ctkXnatReconstructionResource>& reconstructionResource)
+{
+  Q_D(ctkXnatConnection);
+
+  QString reconstructionResourceFilesUri = reconstructionResource->uri() + "/files";
+  QUuid queryId = d->xnat->get(reconstructionResourceFilesUri);
+  qRestResult* restResult = d->xnat->takeResult(queryId);
+
+  QList<ctkXnatReconstructionResourceFile*> reconstructionResourceFiles = restResult->results<ctkXnatReconstructionResourceFile>();
+
+  foreach (ctkXnatReconstructionResourceFile* reconstructionResourceFile, reconstructionResourceFiles)
+  {
+    QString uri = reconstructionResourceFile->property("URI");
+    if (uri.size())
+    {
+      reconstructionResourceFile->setUri(uri);
+    }
+
+    QString label = reconstructionResourceFile->property("Name");
+    if (label.size())
+    {
+      reconstructionResourceFile->setProperty("ID", label);
+    }
+
+    reconstructionResourceFile->setUri(reconstructionResourceFilesUri + "/" + label);
+
+    ctkXnatObject::Pointer ptr(reconstructionResourceFile);
+    ptr->d_func()->selfPtr = ptr;
+    reconstructionResource->addChild(ptr);
+  }
+}
 
 //void ctkXnatConnection::create(ctkXnatProject* project)
 //{
@@ -707,6 +706,26 @@ void ctkXnatConnection::download(ctkXnatScanResourceFile* scanResourceFile, cons
   d->xnat->sync(queryId);
 }
 
+void ctkXnatConnection::download(ctkXnatReconstructionResource* reconstructionResource, const QString& fileName)
+{
+  Q_D(ctkXnatConnection);
+
+  QString query = reconstructionResource->uri() + "/files";
+  qRestAPI::Parameters parameters;
+  parameters["format"] = "zip";
+  QUuid queryId = d->xnat->download(fileName, query, parameters);
+  d->xnat->sync(queryId);
+}
+
+void ctkXnatConnection::download(ctkXnatReconstructionResourceFile* reconstructionResourceFile, const QString& fileName)
+{
+  Q_D(ctkXnatConnection);
+  QString query = reconstructionResourceFile->uri();
+
+  QUuid queryId = d->xnat->download(fileName, query);
+  d->xnat->sync(queryId);
+}
+
 void ctkXnatConnection::processResult(QUuid queryId, QList<QVariantMap> parameters)
 {
   Q_UNUSED(queryId)

Libs/XNAT/Core/ctkXnatConnection.h

@@ -80,9 +80,9 @@ public:
   void fetch(const QSharedPointer<ctkXnatScanFolder>& scanFolder);
   void fetch(const QSharedPointer<ctkXnatScan>& scan);
   void fetch(const QSharedPointer<ctkXnatScanResource>& scanResource);
-//  void fetch(ctkXnatReconstructionFolder* reconstructionFolder);
-//  void fetch(ctkXnatReconstruction* reconstruction);
-//  void fetch(ctkXnatReconstructionResource* reconstructionResource);
+  void fetch(const QSharedPointer<ctkXnatReconstructionFolder>& reconstructionFolder);
+  void fetch(const QSharedPointer<ctkXnatReconstruction>& reconstruction);
+  void fetch(const QSharedPointer<ctkXnatReconstructionResource>& reconstructionResource);
 
   void create(ctkXnatProject* project);
   void create(ctkXnatSubject* subject);
@@ -97,6 +97,8 @@ public:
 
   void download(ctkXnatScanResource* scanResource, const QString& zipFileName);
   void download(ctkXnatScanResourceFile* scanResourceFile, const QString& fileName);
+  void download(ctkXnatReconstructionResource* reconstructionResource, const QString& zipFileName);
+  void download(ctkXnatReconstructionResourceFile* reconstructionResourceFile, const QString& fileName);
 
   /* void downloadReconstruction(ctkXnatReconstruction* reconstruction, const QString& zipFilename); */
   /* void addReconstructionResource(ctkXnatReconstruction* reconstruction, const QString& resource); */

Libs/XNAT/Core/ctkXnatReconstruction.cpp

@@ -22,77 +22,40 @@
 #include "ctkXnatReconstruction.h"
 
 #include "ctkXnatConnection.h"
-#include "ctkXnatReconstructionResource.h"
+#include "ctkXnatObjectPrivate.h"
 
-class ctkXnatReconstructionPrivate
+class ctkXnatReconstructionPrivate : public ctkXnatObjectPrivate
 {
 public:
-  QString reconstructedImageId;
-  QString id;
-  QString type;
-  QString quality;
-  QString baseScanType;
-  QString note;
-  QString seriesDescription;
-  QString uri;
-};
-
-ctkXnatReconstruction::ctkXnatReconstruction(ctkXnatObject* parent)
-: ctkXnatObject(parent)
-, d_ptr(new ctkXnatReconstructionPrivate())
-{
-}
-
-ctkXnatReconstruction::~ctkXnatReconstruction()
-{
-}
 
-const QString& ctkXnatReconstruction::reconstructedImageId() const
-{
-  Q_D(const ctkXnatReconstruction);
-  return d->reconstructedImageId;
-}
+  ctkXnatReconstructionPrivate()
+  : ctkXnatObjectPrivate()
+  {
+  }
 
-void ctkXnatReconstruction::setReconstructedImageId(const QString& reconstructeImageId)
-{
-  Q_D(ctkXnatReconstruction);
-  d->reconstructedImageId = reconstructeImageId;
-}
-
-const QString& ctkXnatReconstruction::id() const
-{
-  Q_D(const ctkXnatReconstruction);
-  return d->id;
-}
-
-void ctkXnatReconstruction::setId(const QString& id)
-{
-  Q_D(ctkXnatReconstruction);
-  d->id = id;
-}
+  void reset()
+  {
+    uri.clear();
+  }
+  
+  QString uri;
+};
 
-const QString& ctkXnatReconstruction::type() const
-{
-  Q_D(const ctkXnatReconstruction);
-  return d->type;
-}
 
-void ctkXnatReconstruction::setType(const QString& type)
+ctkXnatReconstruction::ctkXnatReconstruction()
+: ctkXnatObject(new ctkXnatReconstructionPrivate())
 {
-  Q_D(ctkXnatReconstruction);
-  d->type = type;
 }
 
-const QString& ctkXnatReconstruction::baseScanType() const
+ctkXnatReconstruction::Pointer ctkXnatReconstruction::Create()
 {
-  Q_D(const ctkXnatReconstruction);
-  return d->baseScanType;
+  Pointer ptr(new ctkXnatReconstruction());
+  ptr->d_func()->selfPtr = ptr;
+  return ptr;
 }
 
-void ctkXnatReconstruction::setBaseScanType(const QString& baseScanType)
+ctkXnatReconstruction::~ctkXnatReconstruction()
 {
-  Q_D(ctkXnatReconstruction);
-  d->baseScanType = baseScanType;
 }
 
 const QString& ctkXnatReconstruction::uri() const
@@ -107,42 +70,25 @@ void ctkXnatReconstruction::setUri(const QString& uri)
   d->uri = uri;
 }
 
-void ctkXnatReconstruction::fetch(ctkXnatConnection* connection)
-{
-  connection->fetch(this);
-}
-
-void ctkXnatReconstruction::download(ctkXnatConnection* connection, const QString& zipFileName)
-{
-  connection->downloadReconstruction(this, zipFileName);
-}
-
-void ctkXnatReconstruction::add(ctkXnatConnection* connection, const QString& resource)
+void ctkXnatReconstruction::reset()
 {
-  connection->addReconstructionResource(this, resource);
+  ctkXnatObject::reset();
 }
 
-void ctkXnatReconstruction::remove(ctkXnatConnection* connection)
+void ctkXnatReconstruction::fetchImpl()
 {
-  connection->removeReconstruction(this);
-}
-
-QString ctkXnatReconstruction::getKind() const
-{
-  return "resource";
-}
-
-bool ctkXnatReconstruction::holdsFiles() const
-{
-  return true;
+  Q_D(ctkXnatReconstruction);
+  ctkXnatObject::Pointer self = d->selfPtr;
+  this->connection()->fetch(self.staticCast<ctkXnatReconstruction>());
 }
 
-bool ctkXnatReconstruction::receivesFiles() const
+void ctkXnatReconstruction::remove()
 {
-  return true;
+  // ctkXnatObject::remove();
+  // getConnection()->remove(this);
 }
 
-bool ctkXnatReconstruction::isDeletable() const
+bool ctkXnatReconstruction::isFile() const
 {
-  return true;
+  return false;
 }

Libs/XNAT/Core/ctkXnatReconstruction.h

@@ -31,47 +31,34 @@ class ctkXnatReconstructionPrivate;
 
 class CTK_XNAT_CORE_EXPORT ctkXnatReconstruction : public ctkXnatObject
 {
-  Q_OBJECT
-
-  Q_PROPERTY(QString xnat_reconstructedimagedata_id READ reconstructedImageId WRITE setReconstructedImageId)
-  Q_PROPERTY(QString ID READ id WRITE setId)
-  Q_PROPERTY(QString type READ type WRITE setType)
-  Q_PROPERTY(QString baseScanType READ baseScanType WRITE setBaseScanType)
-  Q_PROPERTY(QString URI READ uri WRITE setUri)
 
 public:
-  explicit ctkXnatReconstruction(ctkXnatObject* parent = 0);
-  virtual ~ctkXnatReconstruction();
-
-  const QString& reconstructedImageId() const;
-  void setReconstructedImageId(const QString& reconstructedImageId);
-
-  const QString& id() const;
-  void setId(const QString& id);
-
-  const QString& type() const;
-  void setType(const QString& type);
-
-  const QString& baseScanType() const;
-  void setBaseScanType(const QString& baseScanType);
 
+  typedef QSharedPointer<ctkXnatReconstruction> Pointer;
+  typedef QWeakPointer<ctkXnatReconstruction> WeakPointer;
+  
+  static Pointer Create();
+  virtual ~ctkXnatReconstruction();
+  
   const QString& uri() const;
   void setUri(const QString& uri);
-
-  virtual void fetch(ctkXnatConnection* connection);
-
-  virtual void download(ctkXnatConnection* connection, const QString& zipFilename);
-  virtual void add(ctkXnatConnection* connection, const QString& name);
-  virtual void remove(ctkXnatConnection* connection);
-
-  virtual QString getKind() const;
-  virtual bool holdsFiles() const;
-  virtual bool receivesFiles() const;
-  virtual bool isDeletable() const;
-
+  
+  void reset();
+  void remove();
+  
+  bool isFile() const;
+
+  /* bool receivesFiles() const; */
+  /* bool holdsFiles() const; */
+  /* bool isDeletable() const; */
+  /* bool isModifiable() const; */
+  
 private:
-  QScopedPointer<ctkXnatReconstructionPrivate> d_ptr;
-
+  
+  friend class qRestResult;
+  explicit ctkXnatReconstruction();
+  virtual void fetchImpl();
+  
   Q_DECLARE_PRIVATE(ctkXnatReconstruction);
   Q_DISABLE_COPY(ctkXnatReconstruction);
 };

Libs/XNAT/Core/ctkXnatReconstructionFolder.cpp

@@ -22,74 +22,75 @@
 #include "ctkXnatReconstructionFolder.h"
 
 #include "ctkXnatConnection.h"
-#include "ctkXnatExperiment.h"
-#include "ctkXnatReconstruction.h"
+#include "ctkXnatObjectPrivate.h"
 
-ctkXnatReconstructionFolder::ctkXnatReconstructionFolder(ctkXnatObject* parent)
-: ctkXnatObject(parent)
-{
-}
 
-ctkXnatReconstructionFolder::~ctkXnatReconstructionFolder()
+class ctkXnatReconstructionFolderPrivate : public ctkXnatObjectPrivate
 {
-}
+public:
 
-void ctkXnatReconstructionFolder::fetch(ctkXnatConnection* connection)
-{
-  connection->fetch(this);
-}
+  ctkXnatReconstructionFolderPrivate()
+  : ctkXnatObjectPrivate()
+  {
+  }
 
-void ctkXnatReconstructionFolder::download(ctkXnatConnection* connection, const QString& zipFileName)
-{
-  connection->downloadReconstructionFiles(dynamic_cast<ctkXnatExperiment*>(getParent()), zipFileName);
-}
+  void reset()
+  {
+//    uri.clear();
+  }
+  
+//  QString uri;
+};
 
-void ctkXnatReconstructionFolder::add(ctkXnatConnection* connection, const QString& categoryEntry)
-{
-  connection->addReconstruction(dynamic_cast<ctkXnatExperiment*>(getParent()), categoryEntry);
-}
 
-QString ctkXnatReconstructionFolder::getModifiableChildKind() const
+ctkXnatReconstructionFolder::ctkXnatReconstructionFolder()
+: ctkXnatObject(new ctkXnatReconstructionFolderPrivate())
 {
-  return "reconstruction";
+  this->setProperty("ID", "Reconstructions");
 }
 
-QString ctkXnatReconstructionFolder::getModifiableParentName() const
+ctkXnatReconstructionFolder::Pointer ctkXnatReconstructionFolder::Create()
 {
-  return getParent()->getName();
+  Pointer ptr(new ctkXnatReconstructionFolder());
+  ptr->d_func()->selfPtr = ptr;
+  return ptr;
 }
 
-bool ctkXnatReconstructionFolder::isModifiable() const
+ctkXnatReconstructionFolder::~ctkXnatReconstructionFolder()
 {
-  return true;
 }
 
-QString ctkXnatReconstructionFolder::getKind() const
-{
-  return "reconstruction";
-}
+//const QString& ctkXnatReconstructionFolder::uri() const
+//{
+//  Q_D(const ctkXnatReconstructionFolder);
+//  return d->uri;
+//}
 
-QString ctkXnatReconstructionFolder::getModifiableChildKind(int parentIndex) const
-{
-  return "resource";
-}
+//void ctkXnatReconstructionFolder::setUri(const QString& uri)
+//{
+//  Q_D(ctkXnatReconstructionFolder);
+//  d->uri = uri;
+//}
 
-QString ctkXnatReconstructionFolder::getModifiableParentName(int parentIndex) const
+void ctkXnatReconstructionFolder::reset()
 {
-  return this->childName(parentIndex);
+  ctkXnatObject::reset();
 }
 
-bool ctkXnatReconstructionFolder::holdsFiles() const
+void ctkXnatReconstructionFolder::fetchImpl()
 {
-  return true;
+  Q_D(ctkXnatReconstructionFolder);
+  ctkXnatObject::Pointer self = d->selfPtr;
+  this->connection()->fetch(self.staticCast<ctkXnatReconstructionFolder>());
 }
 
-bool ctkXnatReconstructionFolder::isModifiable(int parentIndex) const
+void ctkXnatReconstructionFolder::remove()
 {
-  return true;
+  // ctkXnatObject::remove();
+  // getConnection()->remove(this);
 }
 
-bool ctkXnatReconstructionFolder::isDeletable() const
+bool ctkXnatReconstructionFolder::isFile() const
 {
-  return true;
+  return false;
 }

Libs/XNAT/Core/ctkXnatReconstructionFolder.h

@@ -27,30 +27,40 @@
 #include "ctkXnatObject.h"
 
 class ctkXnatConnection;
+class ctkXnatReconstructionFolderPrivate;
 
 class CTK_XNAT_CORE_EXPORT ctkXnatReconstructionFolder : public ctkXnatObject
 {
-  Q_OBJECT
 
 public:
-  explicit ctkXnatReconstructionFolder(ctkXnatObject* parent = 0);
+  
+  typedef QSharedPointer<ctkXnatReconstructionFolder> Pointer;
+  typedef QWeakPointer<ctkXnatReconstructionFolder> WeakPointer;
+  
+  static Pointer Create();
   virtual ~ctkXnatReconstructionFolder();
-
-  virtual void fetch(ctkXnatConnection* connection);
-
-  void download(ctkXnatConnection* connection, const QString& zipFilename);
-  void add(ctkXnatConnection* connection, const QString& categoryEntry);
-  QString getModifiableChildKind() const;
-  QString getModifiableParentName() const;
-  bool isModifiable() const;
-
-  virtual QString getKind() const;
-  virtual QString getModifiableChildKind(int parentIndex) const;
-  virtual QString getModifiableParentName(int parentIndex) const;
-
-  virtual bool holdsFiles() const;
-  virtual bool isModifiable(int parentIndex) const;
-  virtual bool isDeletable() const;
+  
+//  const QString& uri() const;
+//  void setUri(const QString& uri);
+  
+  void reset();
+  void remove();
+  
+  bool isFile() const;
+
+  /* bool receivesFiles() const; */
+  /* bool holdsFiles() const; */
+  /* bool isDeletable() const; */
+  /* bool isModifiable() const; */
+  
+private:
+  
+  friend class qRestResult;
+  explicit ctkXnatReconstructionFolder();
+  virtual void fetchImpl();
+  
+  Q_DECLARE_PRIVATE(ctkXnatReconstructionFolder);
+  Q_DISABLE_COPY(ctkXnatReconstructionFolder);
 };
 
 #endif

Libs/XNAT/Core/ctkXnatReconstructionResource.cpp

@@ -23,126 +23,78 @@
 
 #include "ctkXnatConnection.h"
 #include "ctkXnatReconstructionResourceFile.h"
+#include "ctkXnatObjectPrivate.h"
 
-class ctkXnatReconstructionResourcePrivate
+class ctkXnatReconstructionResourcePrivate : public ctkXnatObjectPrivate
 {
 public:
-  QString resourceId;
-  QString label;
-  QString elementName;
-  QString category;
-  QString categoryId;
-  QString categoryDescription;
-};
-
-ctkXnatReconstructionResource::ctkXnatReconstructionResource(ctkXnatObject* parent)
-: ctkXnatObject(parent)
-, d_ptr(new ctkXnatReconstructionResourcePrivate())
-{
-}
-
-ctkXnatReconstructionResource::~ctkXnatReconstructionResource()
-{
-}
-
-const QString& ctkXnatReconstructionResource::resourceId() const
-{
-  Q_D(const ctkXnatReconstructionResource);
-  return d->resourceId;
-}
 
-void ctkXnatReconstructionResource::setResourceId(const QString& resourceId)
-{
-  Q_D(ctkXnatReconstructionResource);
-  d->resourceId = resourceId;
-}
-
-const QString& ctkXnatReconstructionResource::label() const
-{
-  Q_D(const ctkXnatReconstructionResource);
-  return d->label;
-}
-
-void ctkXnatReconstructionResource::setLabel(const QString& label)
-{
-  Q_D(ctkXnatReconstructionResource);
-  d->label = label;
-}
+  ctkXnatReconstructionResourcePrivate()
+  : ctkXnatObjectPrivate()
+  {
+  }
+
+  void reset()
+  {
+//    uri.clear();
+  }
+  
+//  QString uri;
+};
 
-const QString& ctkXnatReconstructionResource::elementName() const
-{
-  Q_D(const ctkXnatReconstructionResource);
-  return d->elementName;
-}
 
-void ctkXnatReconstructionResource::setElementName(const QString& elementName)
+ctkXnatReconstructionResource::ctkXnatReconstructionResource()
+: ctkXnatObject(new ctkXnatReconstructionResourcePrivate())
 {
-  Q_D(ctkXnatReconstructionResource);
-  d->elementName = elementName;
 }
 
-const QString& ctkXnatReconstructionResource::category() const
+ctkXnatReconstructionResource::Pointer ctkXnatReconstructionResource::Create()
 {
-  Q_D(const ctkXnatReconstructionResource);
-  return d->category;
+  Pointer ptr(new ctkXnatReconstructionResource());
+  ptr->d_func()->selfPtr = ptr;
+  return ptr;
 }
 
-void ctkXnatReconstructionResource::setCategory(const QString& category)
+ctkXnatReconstructionResource::~ctkXnatReconstructionResource()
 {
-  Q_D(ctkXnatReconstructionResource);
-  d->category = category;
 }
 
-const QString& ctkXnatReconstructionResource::categoryId() const
-{
-  Q_D(const ctkXnatReconstructionResource);
-  return d->categoryId;
-}
+//const QString& ctkXnatReconstructionResource::uri() const
+//{
+//  Q_D(const ctkXnatReconstructionResource);
+//  return d->uri;
+//}
 
-void ctkXnatReconstructionResource::setCategoryId(const QString& categoryId)
-{
-  Q_D(ctkXnatReconstructionResource);
-  d->categoryId = categoryId;
-}
+//void ctkXnatReconstructionResource::setUri(const QString& uri)
+//{
+//  Q_D(ctkXnatReconstructionResource);
+//  d->uri = uri;
+//}
 
-const QString& ctkXnatReconstructionResource::categoryDescription() const
+void ctkXnatReconstructionResource::reset()
 {
-  Q_D(const ctkXnatReconstructionResource);
-  return d->categoryDescription;
+  ctkXnatObject::reset();
 }
 
-void ctkXnatReconstructionResource::setCategoryDescription(const QString& categoryDescription)
+void ctkXnatReconstructionResource::fetchImpl()
 {
   Q_D(ctkXnatReconstructionResource);
-  d->categoryDescription = categoryDescription;
-}
-
-void ctkXnatReconstructionResource::fetch(ctkXnatConnection* connection)
-{
-  connection->fetch(this);
-}
-
-void ctkXnatReconstructionResource::download(ctkXnatConnection* connection, const QString& zipFileName)
-{
-  connection->downloadReconstructionResourceFiles(this, zipFileName);
+  ctkXnatObject::Pointer self = d->selfPtr;
+  this->connection()->fetch(self.staticCast<ctkXnatReconstructionResource>());
 }
 
-void ctkXnatReconstructionResource::upload(ctkXnatConnection* connection, const QString& zipFileName)
+void ctkXnatReconstructionResource::download(const QString& filename)
 {
-  connection->uploadReconstructionResourceFiles(this, zipFileName);
+  this->connection()->download(this, filename);
 }
 
-void ctkXnatReconstructionResource::remove(ctkXnatConnection* connection)
+void ctkXnatReconstructionResource::remove()
 {
-  connection->removeReconstructionResource(this);
+  // ctkXnatObject::remove();
+  // getConnection()->remove(this);
 }
 
 bool ctkXnatReconstructionResource::isFile() const
 {
-  return true;
-}
-
-bool ctkXnatReconstructionResource::isDeletable() const
-{
-  return true;
+  return false;
 }

Libs/XNAT/Core/ctkXnatReconstructionResource.h

@@ -31,51 +31,39 @@ class ctkXnatReconstructionResourcePrivate;
 
 class CTK_XNAT_CORE_EXPORT ctkXnatReconstructionResource : public ctkXnatObject
 {
-  Q_OBJECT
-
-  Q_PROPERTY(QString xnat_abstractresource_id READ resourceId WRITE setResourceId)
-  Q_PROPERTY(QString label READ label WRITE setLabel)
-  Q_PROPERTY(QString elementName READ elementName WRITE setElementName)
-  Q_PROPERTY(QString category READ category WRITE setCategory)
-  Q_PROPERTY(QString cat_id READ categoryId WRITE setCategoryId)
-  Q_PROPERTY(QString cat_desc READ categoryDescription WRITE setCategoryDescription)
-
+  
 public:
-  explicit ctkXnatReconstructionResource(ctkXnatObject* parent = 0);
-  virtual ~ctkXnatReconstructionResource();
-
-  const QString& resourceId() const;
-  void setResourceId(const QString& resourceId);
-
-  const QString& label() const;
-  void setLabel(const QString& label);
-
-  const QString& elementName() const;
-  void setElementName(const QString& elementName);
-
-  const QString& category() const;
-  void setCategory(const QString& category);
-
-  const QString& categoryId() const;
-  void setCategoryId(const QString& categoryId);
-
-  const QString& categoryDescription() const;
-  void setCategoryDescription(const QString& categoryDescription);
-
-  virtual void fetch(ctkXnatConnection* connection);
-
-  virtual void download(ctkXnatConnection* connection, const QString& zipFilename);
-  virtual void upload(ctkXnatConnection* connection, const QString& zipFilename);
-  virtual void remove(ctkXnatConnection* connection);
-
-  virtual bool isFile() const;
-  virtual bool isDeletable() const;
 
+  typedef QSharedPointer<ctkXnatReconstructionResource> Pointer;
+  typedef QWeakPointer<ctkXnatReconstructionResource> WeakPointer;
+  
+  static Pointer Create();
+  virtual ~ctkXnatReconstructionResource();
+  
+//  const QString& uri() const;
+//  void setUri(const QString& uri);
+  
+  void reset();
+  void remove();
+  
+  bool isFile() const;
+
+  void download(const QString& filename);
+
+  /* bool receivesFiles() const; */
+  /* bool holdsFiles() const; */
+  /* bool isDeletable() const; */
+  /* bool isModifiable() const; */
+  
 private:
-  QScopedPointer<ctkXnatReconstructionResourcePrivate> d_ptr;
-
+  
+  friend class qRestResult;
+  explicit ctkXnatReconstructionResource();
+  virtual void fetchImpl();
+  
   Q_DECLARE_PRIVATE(ctkXnatReconstructionResource);
   Q_DISABLE_COPY(ctkXnatReconstructionResource);
+  
 };
 
 #endif

Libs/XNAT/Core/ctkXnatReconstructionResourceFile.cpp

@@ -22,141 +22,91 @@
 #include "ctkXnatReconstructionResourceFile.h"
 
 #include "ctkXnatConnection.h"
+#include "ctkXnatObjectPrivate.h"
 
-class ctkXnatReconstructionResourceFilePrivate
-{
-public:
-  QString name;
-  QString size;
-  QString uri;
-  QString collection;
-  QString fileTags;
-  QString fileFormat;
-  QString fileContent;
-  QString categoryId;
-};
-
-ctkXnatReconstructionResourceFile::ctkXnatReconstructionResourceFile(ctkXnatObject* parent)
-: ctkXnatObject(parent)
-{
-}
-
-ctkXnatReconstructionResourceFile::~ctkXnatReconstructionResourceFile()
-{
-}
+#include <QDebug>
 
-const QString& ctkXnatReconstructionResourceFile::name() const
+class ctkXnatReconstructionResourceFilePrivate : public ctkXnatObjectPrivate
 {
-  Q_D(const ctkXnatReconstructionResourceFile);
-  return d->name;
-}
-
-void ctkXnatReconstructionResourceFile::setName(const QString& name)
-{
-  Q_D(ctkXnatReconstructionResourceFile);
-  d->name = name;
-}
-
-const QString& ctkXnatReconstructionResourceFile::size() const
-{
-  Q_D(const ctkXnatReconstructionResourceFile);
-  return d->size;
-}
-
-void ctkXnatReconstructionResourceFile::setSize(const QString& size)
-{
-  Q_D(ctkXnatReconstructionResourceFile);
-  d->size = size;
-}
+public:
 
-const QString& ctkXnatReconstructionResourceFile::uri() const
-{
-  Q_D(const ctkXnatReconstructionResourceFile);
-  return d->uri;
-}
+  ctkXnatReconstructionResourceFilePrivate()
+  : ctkXnatObjectPrivate()
+  {
+  }
+
+  void reset()
+  {
+//    uri.clear();
+  }
+  
+//  QString uri;
+};
 
-void ctkXnatReconstructionResourceFile::setUri(const QString& uri)
+ctkXnatReconstructionResourceFile::ctkXnatReconstructionResourceFile()
+: ctkXnatObject(new ctkXnatReconstructionResourceFilePrivate())
 {
-  Q_D(ctkXnatReconstructionResourceFile);
-  d->uri = uri;
 }
 
-const QString& ctkXnatReconstructionResourceFile::collection() const
+ctkXnatReconstructionResourceFile::Pointer ctkXnatReconstructionResourceFile::Create()
 {
-  Q_D(const ctkXnatReconstructionResourceFile);
-  return d->collection;
+  Pointer ptr(new ctkXnatReconstructionResourceFile());
+  ptr->d_func()->selfPtr = ptr;
+  return ptr;
 }
 
-void ctkXnatReconstructionResourceFile::setCollection(const QString& collection)
+ctkXnatReconstructionResourceFile::~ctkXnatReconstructionResourceFile()
 {
-  Q_D(ctkXnatReconstructionResourceFile);
-  d->collection = collection;
 }
 
-const QString& ctkXnatReconstructionResourceFile::fileTags() const
-{
-  Q_D(const ctkXnatReconstructionResourceFile);
-  return d->fileTags;
-}
+//const QString& ctkXnatReconstructionResourceFile::uri() const
+//{
+//  Q_D(const ctkXnatReconstructionResourceFile);
+//  return d->uri;
+//}
 
-void ctkXnatReconstructionResourceFile::setFileTags(const QString& fileTags)
-{
-  Q_D(ctkXnatReconstructionResourceFile);
-  d->fileTags = fileTags;
-}
+//void ctkXnatReconstructionResourceFile::setUri(const QString& uri)
+//{
+//  Q_D(ctkXnatReconstructionResourceFile);
+//  d->uri = uri;
+//}
 
-const QString& ctkXnatReconstructionResourceFile::fileFormat() const
+void ctkXnatReconstructionResourceFile::download(const QString& filename)
 {
-  Q_D(const ctkXnatReconstructionResourceFile);
-  return d->fileFormat;
-}
+  ctkXnatReconstructionResourceFile* object = this;
+  
+  qDebug() << "file uri is" << object->uri();
+  qDebug() << "downloading towards: " << filename;
 
-void ctkXnatReconstructionResourceFile::setFileFormat(const QString& fileFormat)
-{
-  Q_D(ctkXnatReconstructionResourceFile);
-  d->fileFormat = fileFormat;
+  object->connection()->download(this, filename);
 }
 
-const QString& ctkXnatReconstructionResourceFile::fileContent() const
+void ctkXnatReconstructionResourceFile::upload(const QString& filename)
 {
-  Q_D(const ctkXnatReconstructionResourceFile);
-  return d->fileContent;
+  ctkXnatReconstructionResourceFile* object = this;
+  
+  qDebug() << "file uri is" << object->uri();
+  qDebug() << "uploading from: " << filename;
 }
 
-void ctkXnatReconstructionResourceFile::setFileContent(const QString& fileContent)
-{
-  Q_D(ctkXnatReconstructionResourceFile);
-  d->fileContent = fileContent;
-}
 
-const QString& ctkXnatReconstructionResourceFile::categoryId() const
+void ctkXnatReconstructionResourceFile::reset()
 {
-  Q_D(const ctkXnatReconstructionResourceFile);
-  return d->categoryId;
+  ctkXnatObject::reset();
 }
 
-void ctkXnatReconstructionResourceFile::setCategoryId(const QString& categoryId)
+void ctkXnatReconstructionResourceFile::fetchImpl()
 {
-  Q_D(ctkXnatReconstructionResourceFile);
-  d->categoryId = categoryId;
-}
 
-void ctkXnatReconstructionResourceFile::download(ctkXnatConnection* connection, const QString& zipFileName)
-{
-  connection->download(this, zipFileName);
 }
 
-void ctkXnatReconstructionResourceFile::remove(ctkXnatConnection* connection)
+void ctkXnatReconstructionResourceFile::remove()
 {
-  connection->remove(this);
+  // ctkXnatObject::remove();
+  // getConnection()->remove(this);
 }
 
 bool ctkXnatReconstructionResourceFile::isFile() const
 {
   return true;
 }
-
-bool ctkXnatReconstructionResourceFile::isDeletable() const
-{
-  return true;
-}

Libs/XNAT/Core/ctkXnatReconstructionResourceFile.h

@@ -31,54 +31,37 @@ class ctkXnatReconstructionResourceFilePrivate;
 
 class CTK_XNAT_CORE_EXPORT ctkXnatReconstructionResourceFile : public ctkXnatObject
 {
-  Q_OBJECT
-
-  Q_PROPERTY(QString Name READ name WRITE setName)
-  Q_PROPERTY(QString Size READ size WRITE setSize)
-  Q_PROPERTY(QString URI READ uri WRITE setUri)
-  Q_PROPERTY(QString collection READ collection WRITE setCollection)
-  Q_PROPERTY(QString file_tags READ fileTags WRITE setFileTags)
-  Q_PROPERTY(QString file_format READ fileFormat WRITE setFileFormat)
-  Q_PROPERTY(QString file_content READ fileContent WRITE setFileContent)
-  Q_PROPERTY(QString cat_ID READ categoryId WRITE setCategoryId)
 
 public:
-  explicit ctkXnatReconstructionResourceFile(ctkXnatObject* parent = 0);
-  virtual ~ctkXnatReconstructionResourceFile();
-
-  const QString& name() const;
-  void setName(const QString& name);
-
-  const QString& size() const;
-  void setSize(const QString& size);
-
-  const QString& uri() const;
-  void setUri(const QString& uri);
-
-  const QString& collection() const;
-  void setCollection(const QString& collection);
-
-  const QString& fileTags() const;
-  void setFileTags(const QString& fileTags);
-
-  const QString& fileFormat() const;
-  void setFileFormat(const QString& fileFormat);
-
-  const QString& fileContent() const;
-  void setFileContent(const QString& fileContent);
-
-  const QString& categoryId() const;
-  void setCategoryId(const QString& categoryId);
-
-  virtual void download(ctkXnatConnection* connection, const QString& zipFilename);
-  virtual void remove(ctkXnatConnection* connection);
-
-  virtual bool isFile() const;
-  virtual bool isDeletable() const;
 
+  typedef QSharedPointer<ctkXnatReconstructionResourceFile> Pointer;
+  typedef QWeakPointer<ctkXnatReconstructionResourceFile> WeakPointer;
+  
+  static Pointer Create();
+  virtual ~ctkXnatReconstructionResourceFile();
+  
+//  const QString& uri() const;
+//  void setUri(const QString& uri);
+
+  void download(const QString& filename);
+  void upload(const QString& filename);
+
+  void reset();
+  void remove();
+  
+  bool isFile() const;
+
+  /* bool receivesFiles() const; */
+  /* bool holdsFiles() const; */
+  /* bool isDeletable() const; */
+  /* bool isModifiable() const; */
+  
 private:
-  QScopedPointer<ctkXnatReconstructionResourceFilePrivate> d_ptr;
-
+  
+  friend class qRestResult;
+  explicit ctkXnatReconstructionResourceFile();
+  virtual void fetchImpl();
+  
   Q_DECLARE_PRIVATE(ctkXnatReconstructionResourceFile);
   Q_DISABLE_COPY(ctkXnatReconstructionResourceFile);
 };