uavsettingsimportexportmanager.cpp

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
 * for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, see <http://www.gnu.org/licenses/>
 *
 * Additional note on redistribution: The copyright and license notices above
 * must be maintained in each individual source file that is a derivative work
 * of this source file; otherwise redistribution is prohibited.
 */

#include "uavsettingsimportexportmanager.h"
#include <QtPlugin>
#include <QStringList>
#include <QDebug>
#include <QCheckBox>
#include <QMainWindow>
#include "importsummary.h"

// for menu item
#include <coreplugin/coreconstants.h>
#include <coreplugin/actionmanager/actionmanager.h>
#include <coreplugin/icore.h>
#include <uavtalk/telemetrymanager.h>
#include <QKeySequence>

// for UAVObjects
#include "uavobjects/uavdataobject.h"
#include "uavobjects/uavobjectmanager.h"
#include "extensionsystem/pluginmanager.h"
#include "uavobjectutil/uavobjectutilmanager.h"

// for XML object
#include <QDomDocument>
#include <QXmlQuery>

// for file dialog and error messages
#include <QFileDialog>
#include <QMessageBox>

UAVSettingsImportExportManager::~UAVSettingsImportExportManager()
{
    // Do nothing
}

UAVSettingsImportExportManager::UAVSettingsImportExportManager(QObject *parent)
    : QObject(parent)
{
    auto core = Core::ICore::instance();

    // Add Menu entry
    Core::ActionManager *am = core->actionManager();
    Core::ActionContainer *ac = am->actionContainer(Core::Constants::M_FILE);
    Core::Command *cmd =
        am->registerAction(new QAction(this), "UAVSettingsImportExportPlugin.UAVSettingsExport",
                           QList<int>() << Core::Constants::C_GLOBAL_ID);
    cmd->setDefaultKeySequence(QKeySequence("Ctrl+E"));
    cmd->action()->setText(tr("Export UAV Settings..."));
    ac->addAction(cmd, Core::Constants::G_FILE_SAVE);
    connect(cmd->action(), SIGNAL(triggered(bool)), this, SLOT(exportUAVSettings()));

    cmd = am->registerAction(new QAction(this), "UAVSettingsImportExportPlugin.UAVSettingsImport",
                             QList<int>() << Core::Constants::C_GLOBAL_ID);
    cmd->setDefaultKeySequence(QKeySequence("Ctrl+I"));
    cmd->action()->setText(tr("Import UAV Settings..."));
    ac->addAction(cmd, Core::Constants::G_FILE_SAVE);
    connect(cmd->action(), SIGNAL(triggered(bool)), this, SLOT(importUAVSettings()));

    ac = am->actionContainer(Core::Constants::M_HELP);
    cmd = am->registerAction(new QAction(this), "UAVSettingsImportExportPlugin.UAVDataExport",
                             QList<int>() << Core::Constants::C_GLOBAL_ID);
    cmd->action()->setText(tr("Export UAV Data..."));
    ac->addAction(cmd, Core::Constants::G_HELP_HELP);
    connect(cmd->action(), SIGNAL(triggered(bool)), this, SLOT(exportUAVData()));
}

void UAVSettingsImportExportManager::extensionsInitialized()
{
    // problems with circular lib dep on windows, probably related to uploader
#ifndef Q_OS_WIN
    auto pm = ExtensionSystem::PluginManager::instance();
    auto telemetry = pm->getObject<TelemetryManager>();
    // enabled/disabled commands when board is connected/disconnected
    connect(telemetry, &TelemetryManager::connectedChanged, this,
            &UAVSettingsImportExportManager::setCommandsEnabled);
    setCommandsEnabled(telemetry->isConnected());
#endif
}

bool UAVSettingsImportExportManager::importUAVSettings(const QByteArray &settings, bool quiet)
{
    QDomDocument doc("UAVObjects");

    if (!doc.setContent(settings)) {
        QMessageBox msgBox(dynamic_cast<QWidget *>(Core::ICore::instance()->mainWindow()));
        msgBox.setText(tr("File Parsing Failed."));
        msgBox.setInformativeText(tr("This file is not a correct XML file"));
        msgBox.setStandardButtons(QMessageBox::Ok);
        msgBox.exec();
        return false;
    }
    emit importAboutToBegin();
    qDebug() << "Import about to begin";

    // find the root of settings subtree
    QDomElement root = doc.documentElement();
    if (root.tagName() == "uavobjects") {
        root = root.firstChildElement("settings");
    }
    if (root.isNull() || (root.tagName() != "settings")) {
        QMessageBox msgBox(dynamic_cast<QWidget *>(Core::ICore::instance()->mainWindow()));
        msgBox.setText(tr("Wrong file contents"));
        msgBox.setInformativeText(tr("This file does not contain correct UAVSettings"));
        msgBox.setStandardButtons(QMessageBox::Ok);
        msgBox.exec();
        return false;
    }

    // We are now ok: setup the import summary dialog & update it as we
    // go along.
    ImportSummaryDialog swui(dynamic_cast<QWidget *>(Core::ICore::instance()->mainWindow()), quiet);

    ExtensionSystem::PluginManager *pm = ExtensionSystem::PluginManager::instance();
    UAVObjectManager *boardObjManager = pm->getObject<UAVObjectManager>();
    UAVObjectManager *importedObjectManager = new UAVObjectManager();

    swui.show();

    QDomNode node = root.firstChild();
    while (!node.isNull()) {
        QDomElement e = node.toElement();
        if (e.tagName() == "object") {

            //  - Read each object
            QString uavObjectName = e.attribute("name");
            uint uavObjectID = e.attribute("id").toUInt(NULL, 16);

            // Sanity Check:
            UAVObject *obj = boardObjManager->getObject(uavObjectName);
            UAVDataObject *dobj = dynamic_cast<UAVDataObject *>(obj);
            if (obj == NULL) {
                // This object is unknown!
                qDebug() << "Object unknown:" << uavObjectName << uavObjectID;
                swui.addLine(uavObjectName, "Error (Object unknown)", false);
            } else if (dobj && !dobj->getIsPresentOnHardware()) {
                swui.addLine(uavObjectName, "Error (Object not present on hw)", false);
            } else {
                //  - Update each field
                //  - Issue and "updated" command
                UAVDataObject *newObj = dobj->clone();

                bool error = false;
                bool setError = false;
                QDomNode field = node.firstChild();
                while (!field.isNull()) {
                    QDomElement f = field.toElement();
                    if (f.tagName() == "field") {
                        UAVObjectField *uavfield = newObj->getField(f.attribute("name"));
                        if (uavfield) {
                            QStringList list = f.attribute("values").split(",");
                            if (list.length() == 1) {
                                if (false == uavfield->checkValue(f.attribute("values"))) {
                                    qDebug() << "checkValue returned false on: " << uavObjectName
                                             << f.attribute("values");
                                    setError = true;
                                } else {
                                    uavfield->setValue(f.attribute("values"));
                                }
                            } else {
                                // This is an enum:
                                int i = 0;
                                QStringList list = f.attribute("values").split(",");
                                foreach (QString element, list) {
                                    if (false == uavfield->checkValue(element, i)) {
                                        qDebug() << "checkValue(list) returned false on: "
                                                 << uavObjectName << list;
                                        setError = true;
                                    } else {
                                        uavfield->setValue(element, i);
                                    }
                                    i++;
                                }
                            }
                        } else {
                            error = true;
                        }
                    }
                    field = field.nextSibling();
                }
                newObj->updated();

                if (error) {
                    swui.addLine(uavObjectName, "Warning (Object field unknown)", true);
                } else if (uavObjectID != newObj->getObjID()) {
                    qDebug() << "Mismatch for Object " << uavObjectName << uavObjectID << " - "
                             << newObj->getObjID();
                    swui.addLine(uavObjectName, "Warning (ObjectID mismatch)", true);
                } else if (setError) {
                    swui.addLine(uavObjectName, "Warning (Objects field value(s) invalid)", false);
                } else {
                    swui.addLine(uavObjectName, "OK", true);
                }
                importedObjectManager->registerObject(newObj);
            }
        }
        node = node.nextSibling();
    }
    qDebug() << "End import";

    if (swui.numLines() < 1) {
        QMessageBox::critical(dynamic_cast<QWidget *>(Core::ICore::instance()->mainWindow()),
                              tr("Unable to import settings"),
                              tr("No settings found in XML dump; the flight controller settings "
                                 "may have been blank."),
                              QMessageBox::Ok);
        /* This is a termination condition-- no settings found. */
        return true;
    }

    swui.setUAVOSettings(importedObjectManager);
    swui.exec();

    return swui.result() == QDialog::Accepted;
}

// Slot called by the menu manager on user action
void UAVSettingsImportExportManager::importUAVSettings()
{
    // ask for file name
    QString fileName;
    QString filters = tr("UAVObjects XML files (*.uav);; XML files (*.xml)");
    fileName =
        QFileDialog::getOpenFileName(dynamic_cast<QWidget *>(Core::ICore::instance()->mainWindow()),
                                     tr("Import UAV Settings"), "", filters);
    if (fileName.isEmpty()) {
        return;
    }

    // Now open the file
    QFile file(fileName);
    QDomDocument doc("UAVObjects");
    file.open(QFile::ReadOnly | QFile::Text);

    importUAVSettings(file.readAll());

    file.close();
}

// Create an XML document from UAVObject database
QString UAVSettingsImportExportManager::createXMLDocument(const enum storedData what,
                                                          const bool fullExport)
{
    // generate an XML first (used for all export formats as a formatted data source)
    ExtensionSystem::PluginManager *pm = ExtensionSystem::PluginManager::instance();
    UAVObjectManager *objManager = pm->getObject<UAVObjectManager>();

    // create an XML root
    QDomDocument doc("UAVObjects");
    QDomElement root = doc.createElement("uavobjects");
    doc.appendChild(root);

    // add hardware, firmware and GCS version info
    QDomElement versionInfo = doc.createElement("version");
    root.appendChild(versionInfo);

    UAVObjectUtilManager *utilMngr = pm->getObject<UAVObjectUtilManager>();
    deviceDescriptorStruct board;
    utilMngr->getBoardDescriptionStruct(board);

    QDomElement hw = doc.createElement("hardware");
    hw.setAttribute("type", QString().setNum(board.boardType, 16));
    hw.setAttribute("revision", QString().setNum(board.boardRevision, 16));
    hw.setAttribute("serial", QString(utilMngr->getBoardCPUSerial().toHex()));
    versionInfo.appendChild(hw);

    QDomElement fw = doc.createElement("firmware");
    fw.setAttribute("date", board.gitDate);
    fw.setAttribute("hash", board.gitHash);
    fw.setAttribute("tag", board.gitTag);
    versionInfo.appendChild(fw);

    QString gcsRevision = QString::fromLatin1(Core::Constants::GCS_REVISION_STR);
    QString gcsGitDate = gcsRevision.mid(gcsRevision.indexOf(" ") + 1, 14);
    QString gcsGitHash = gcsRevision.mid(gcsRevision.indexOf(":") + 1, 8);
    QString gcsGitTag = gcsRevision.left(gcsRevision.indexOf(":"));

    QDomElement gcs = doc.createElement("gcs");
    gcs.setAttribute("date", gcsGitDate);
    gcs.setAttribute("hash", gcsGitHash);
    gcs.setAttribute("tag", gcsGitTag);
    versionInfo.appendChild(gcs);

    // create settings and/or data elements
    QDomElement settings = doc.createElement("settings");
    QDomElement data = doc.createElement("data");

    switch (what) {
    case Settings:
        root.appendChild(settings);
        break;
    case Data:
        root.appendChild(data);
        break;
    case Both:
        root.appendChild(data);
        root.appendChild(settings);
        break;
    }

    // iterate over settings objects
    QVector<QVector<UAVDataObject *>> objList = objManager->getDataObjectsVector();
    foreach (QVector<UAVDataObject *> list, objList) {
        foreach (UAVDataObject *obj, list) {
            if (!obj->getIsPresentOnHardware())
                continue;
            if (((what == Settings) && obj->isSettings()) || ((what == Data) && !obj->isSettings())
                || (what == Both)) {

                // add each object to the XML
                QDomElement o = doc.createElement("object");
                o.setAttribute("name", obj->getName());
                o.setAttribute("id",
                               QString("0x") + QString().setNum(obj->getObjID(), 16).toUpper());
                if (fullExport) {
                    QDomElement d = doc.createElement("description");
                    QDomText t = doc.createTextNode(
                        obj->getDescription().remove("@Ref ", Qt::CaseInsensitive));
                    d.appendChild(t);
                    o.appendChild(d);
                }

                // iterate over fields
                QList<UAVObjectField *> fieldList = obj->getFields();

                foreach (UAVObjectField *field, fieldList) {
                    QDomElement f = doc.createElement("field");

                    // iterate over values
                    QString vals;
                    quint32 nelem = field->getNumElements();
                    for (unsigned int n = 0; n < nelem; ++n) {
                        vals.append(QString("%1,").arg(field->getValue(n).toString()));
                    }
                    vals.chop(1);

                    f.setAttribute("name", field->getName());
                    f.setAttribute("values", vals);
                    if (fullExport) {
                        f.setAttribute("type", field->getTypeAsString());
                        f.setAttribute("units", field->getUnits());
                        f.setAttribute("elements", nelem);
                        if (field->getType() == UAVObjectField::ENUM) {
                            f.setAttribute("options", field->getOptions().join(","));
                        }
                    }
                    o.appendChild(f);
                }

                // append to the settings or data element
                if (obj->isSettings())
                    settings.appendChild(o);
                else
                    data.appendChild(o);
            }
        }
    }

    // This sorts the XML <object> children's <name=".."> attribute by alphabetical order,
    // as well as sorting all attributes by alphabetical order (see note below for
    // special circumstances around sorting attributes. This is particularly helpful when
    // comparing *.uav files to each other.
    QString preliminaryXMLDoc = doc.toString(4);
    QString alphabetizedAttributesXMLDoc;
    QString alphabetizedXMLDoc;

    // (New C++11 "raw string literal" string format.)
    // This sorts all attributes by alphabetical order. This is *not* guaranteed to
    // work. In fact, it is guaranteed *not* to work in all conditions. See
    // http://stackoverflow.com/questions/1429991/using-xsl-to-sort-attributes.
    // However, it seems to work so far and there's no expectation it will change
    // in Qt's near future.
    QString xmlAttributeSorter = R"(
        <xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
          <xsl:output method="xml" encoding="UTF-8" indent="yes"/>
          <xsl:template match="*">
            <xsl:copy>
              <xsl:apply-templates select="@*">
                <xsl:sort select="name() "/>
              </xsl:apply-templates>
              <xsl:apply-templates/>
            </xsl:copy>
          </xsl:template>
          <xsl:template match="@*|comment()|processing-instruction() ">
            <xsl:copy />
          </xsl:template>
        </xsl:stylesheet>
    )";

    // (New C++11 "raw string literal" string format.)
    // This XSLT template sorts all children by alphabetical order. This is guaranteed
    // to work (unlike the attribute sorting).
    QString xmlAlpheticalSorter = R"(
        <xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
          <xsl:output method="xml" indent="yes" omit-xml-declaration="no"/>
          <xsl:strip-space elements="*"/>

          <xsl:template match="@* | node() ">
            <xsl:copy>
              <xsl:apply-templates select="@* | node() "/>
            </xsl:copy>
          </xsl:template>

          <xsl:template match="settings">
            <xsl:copy>
              <xsl:apply-templates select="@*" />
              <xsl:apply-templates select="object">
                <xsl:sort select="@name" data-type="text"/>

              </xsl:apply-templates>
            </xsl:copy>
          </xsl:template>

        </xsl:stylesheet>
    )";

    // Generate query and set to XSLT v2.0
    QXmlQuery query(QXmlQuery::XSLT20);

    // First sort attributes...
    query.setFocus(preliminaryXMLDoc);
    query.setQuery(xmlAttributeSorter);
    query.evaluateTo(&alphabetizedAttributesXMLDoc);

    // Then sort children.
    query.setFocus(alphabetizedAttributesXMLDoc);
    query.setQuery(xmlAlpheticalSorter);
    query.evaluateTo(&alphabetizedXMLDoc);

    return alphabetizedXMLDoc;
}

// Slot called by the menu manager on user action
void UAVSettingsImportExportManager::exportUAVSettings()
{
    // ask for file name
    QString fileName;
    QString filters = tr("UAVObjects XML files (*.uav)");

    fileName =
        QFileDialog::getSaveFileName(dynamic_cast<QWidget *>(Core::ICore::instance()->mainWindow()),
                                     tr("Save UAVSettings File As"), "", filters);

    if (fileName.isEmpty()) {
        return;
    }

    // If the filename ends with .xml, we will do a full export, otherwise, a simple export
    bool fullExport = false;
    if (fileName.endsWith(".xml")) {
        fullExport = true;
    } else if (!fileName.endsWith(".uav")) {
        fileName.append(".uav");
    }

    // generate an XML first (used for all export formats as a formatted data source)
    QString xml = createXMLDocument(Settings, fullExport);

    // save file
    QFile file(fileName);
    if (file.open(QIODevice::WriteOnly) && (file.write(xml.toLatin1()) != -1)) {
        file.close();
    } else {
        QMessageBox::critical(dynamic_cast<QWidget *>(Core::ICore::instance()->mainWindow()),
                              tr("UAV Settings Export"), tr("Unable to save settings: ") + fileName,
                              QMessageBox::Ok);
        return;
    }

    QMessageBox msgBox(dynamic_cast<QWidget *>(Core::ICore::instance()->mainWindow()));
    msgBox.setText(tr("Settings saved."));
    msgBox.setStandardButtons(QMessageBox::Ok);
    msgBox.exec();
}

// Slot called by the menu manager on user action
void UAVSettingsImportExportManager::exportUAVData()
{
    // ask for file name
    QString fileName;
    QString filters = tr("UAVObjects XML files (*.uav)");

    fileName =
        QFileDialog::getSaveFileName(dynamic_cast<QWidget *>(Core::ICore::instance()->mainWindow()),
                                     tr("Save UAVData File As"), "", filters);
    if (fileName.isEmpty()) {
        return;
    }

    // If the filename ends with .xml, we will do a full export, otherwise, a simple export
    bool fullExport = false;
    if (fileName.endsWith(".xml")) {
        fullExport = true;
    } else if (!fileName.endsWith(".uav")) {
        fileName.append(".uav");
    }

    // generate an XML first (used for all export formats as a formatted data source)
    QString xml = createXMLDocument(Both, fullExport);

    // save file
    QFile file(fileName);
    if (file.open(QIODevice::WriteOnly) && (file.write(xml.toLatin1()) != -1)) {
        file.close();
    } else {
        QMessageBox::critical(dynamic_cast<QWidget *>(Core::ICore::instance()->mainWindow()),
                              tr("UAV Data Export"), tr("Unable to save data: ") + fileName,
                              QMessageBox::Ok);
        return;
    }

    QMessageBox msgBox(dynamic_cast<QWidget *>(Core::ICore::instance()->mainWindow()));
    msgBox.setText(tr("Data saved."));
    msgBox.setStandardButtons(QMessageBox::Ok);
    msgBox.exec();
}

void UAVSettingsImportExportManager::setCommandsEnabled(bool enabled)
{
    static const std::vector<QString> commands{
        QStringLiteral("UAVSettingsImportExportPlugin.UAVSettingsExport"),
        QStringLiteral("UAVSettingsImportExportPlugin.UAVSettingsImport"),
        QStringLiteral("UAVSettingsImportExportPlugin.UAVDataExport")
    };

    Core::ActionManager *am = Core::ICore::instance()->actionManager();
    if (!am)
        return;

    for (const auto &command : commands)
        if (Core::Command *cmd = am->command(command))
            cmd->action()->setEnabled(enabled);
}