TemplateList.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
 
#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);
  }
}