TemplateList.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include "TemplateList.h"
#include <QDir>
 
#include "FileName.h"
#include "IException.h"
#include "Project.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() {
    // 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();
  }
}