TemplateList.cpp

Go to the documentation of this file.

#include "TemplateList.h"
#include <QDir>

#include "FileName.h"
#include "IException.h"
#include "Project.h"
#include "XmlStackedHandlerReader.h"

namespace Isis {
  TemplateList::TemplateList(QString name, QString type, QString path, QObject *parent) : QObject(parent){
    m_name = name;
    m_path = path;
    m_type = type;
  }
  
  
  TemplateList::TemplateList(QObject *parent) : QObject(parent) {
  }


  TemplateList::TemplateList(const TemplateList &other) :
      QList<Template *>(other) {
    m_path = other.m_path;
    m_name = other.m_name;
    m_type = other.m_type;
  }


  TemplateList::TemplateList(Project *project, XmlStackedHandlerReader *xmlReader, QObject *parent) :
      QObject(parent) {
    xmlReader->pushContentHandler(new XmlHandler(this, project));
  }


  TemplateList::~TemplateList() {
    // At the moment, this only occurs during an ImportTemplateWorkOrder undo, where it is handled
  }


  QString TemplateList::name() const{
    return m_name;
  }


  QString TemplateList::type() const{
    return m_type;
  }


  QString TemplateList::path() const{
    return m_path;
  }


  void TemplateList::setName(QString newName) {
    m_name = newName;
  }


  void TemplateList::setType(QString newType) {
    m_type = newType;
  }


  void TemplateList::setPath(QString newPath) {
    m_path = newPath;
  }


  void TemplateList::deleteFromDisk(Project *project) {
    foreach (Template *currentTemplate, *this) {
      currentTemplate->deleteFromDisk();
    }

    if (!m_path.isEmpty()) {
      QFile::remove(project->templateRoot() + "/" + m_path + "/templates.xml");

      QDir dir;
      dir.rmdir(project->templateRoot() + "/" + m_path);
    }
  }


  void TemplateList::save(QXmlStreamWriter &stream, const Project *project, FileName newProjectRoot)
      const {
    
    if (m_type == "maps") {
      stream.writeStartElement("mapTemplateList");
    }
    else if (m_type == "registrations") {
      stream.writeStartElement("regTemplateList");
    }
    else {
      throw IException(IException::Io,
                       QString("Attempting to save unsupported template file type: [%1]").arg(m_type),
                       _FILEINFO_);
    }
    stream.writeAttribute("name", m_name);
    stream.writeAttribute("type", m_type);
    stream.writeAttribute("path", m_path);

    FileName settingsFileName(Project::templateRoot(newProjectRoot.toString()) 
                              + "/" + m_type + "/" + m_name + "/templates.xml");

    if (!settingsFileName.dir().mkpath(settingsFileName.path())) {
      throw IException(IException::Io,
                       QString("Failed to create directory [%1]").arg(settingsFileName.path()),
                       _FILEINFO_);
    }

    QFile templateListContentsFile(settingsFileName.toString());

    if (!templateListContentsFile.open(QIODevice::ReadWrite | QIODevice::Truncate)) {
      throw IException(IException::Io,
          QString("Unable to save template information for [%1] because [%2] could not be opened "
                  "for writing")
            .arg(m_name).arg(settingsFileName.original()),
          _FILEINFO_);
    }

    QXmlStreamWriter templateDetailsWriter(&templateListContentsFile);
    templateDetailsWriter.setAutoFormatting(true);
    templateDetailsWriter.writeStartDocument();
    templateDetailsWriter.writeStartElement("templates");

    foreach (Template *currentTemplate, *this) {
      currentTemplate->save(templateDetailsWriter, project, newProjectRoot);

      QString newPath = newProjectRoot.toString() + "/templates/" + m_type + "/" + m_name;

      if (currentTemplate->fileName() !=
          newPath + "/" + FileName(currentTemplate->fileName()).name()) {
        QFile::copy(currentTemplate->fileName(),
                    newPath + "/" + FileName(currentTemplate->fileName()).name() );
      }
    }

    templateDetailsWriter.writeEndElement();
    templateDetailsWriter.writeEndDocument();

    stream.writeEndElement();
  }


  TemplateList::XmlHandler::XmlHandler(TemplateList *templateList, Project *project) {
    m_templateList = templateList;
    m_project = project;
  }


  bool TemplateList::XmlHandler::startElement(const QString &namespaceURI, const QString &localName,
                                           const QString &qName, const QXmlAttributes &atts) {
    if (XmlStackedHandler::startElement(namespaceURI, localName, qName, atts)) {
      if (localName == "mapTemplateList" || localName == "regTemplateList") {
        QString name = atts.value("name");
        QString type = atts.value("type");
        QString path = atts.value("path");

        if (!name.isEmpty()) {
          m_templateList->setName(name);
        }

        if (!type.isEmpty()) {
          m_templateList->setType(type);
        }
        
        if (!path.isEmpty()) {
          m_templateList->setPath(path);
        }
      }
      else if (localName == "template") {
        m_templateList->append(new Template(m_project->templateRoot(), reader()));
      }
    }

    return true;
  }


  bool TemplateList::XmlHandler::endElement(const QString &namespaceURI, const QString &localName,
                                           const QString &qName) {
    if (localName == "mapTemplateList" || localName == "regTemplateList") {
      XmlHandler handler(m_templateList, m_project);

      XmlStackedHandlerReader reader;
      reader.pushContentHandler(&handler);
      reader.setErrorHandler(&handler);

      QString templateListXmlPath = m_project->templateRoot() + "/" + m_templateList->type() + "/" 
                                    + m_templateList->name() + "/templates.xml";
      templateListXmlPath = QDir::cleanPath(templateListXmlPath);
      
      QFile file(templateListXmlPath);

      if (!file.open(QFile::ReadOnly)) {
        throw IException(IException::Io,
                         QString("Unable to open [%1] with read access")
                           .arg(templateListXmlPath),
                         _FILEINFO_);
      }

      QXmlInputSource xmlInputSource(&file);
      if (!reader.parse(xmlInputSource))
        throw IException(IException::Io,
                         tr("Failed to open TemplateList XML [%1]").arg(templateListXmlPath),
                         _FILEINFO_);
    }

    return XmlStackedHandler::endElement(namespaceURI, localName, qName);
  }
}