cxSessionStorageServiceImpl.cpp

Go to the documentation of this file.

/*=========================================================================
This file is part of CustusX, an Image Guided Therapy Application.
                 
Copyright (c) SINTEF Department of Medical Technology.
All rights reserved.
                 
CustusX is released under a BSD 3-Clause license.
                 
See Lisence.txt (https://github.com/SINTEFMedtek/CustusX/blob/master/License.txt) for details.
=========================================================================*/
 
#include "cxSessionStorageServiceImpl.h"
#include "cxSettings.h"
#include "cxReporter.h"
#include <QTextStream>
#include "cxTime.h"
#include <QDir>
#include "cxConfig.h"
#include "cxFileHelpers.h"
#include "cxDataLocations.h"
#include <QApplication>
#include <QTimer>
#include "cxLogger.h"
#include "cxProfile.h"
#include "cxOrderedQDomDocument.h"
#include "cxXmlFileHandler.h"
 
 
namespace cx
{
 
SessionStorageServiceImpl::SessionStorageServiceImpl(ctkPluginContext *context)
{
        this->clearCache();
        mActivePatientFolder = this->getNoPatientFolder();
        connect(this, &SessionStorageServiceImpl::sessionChanged, this, &SessionStorageServiceImpl::onSessionChanged);
 
        QTimer::singleShot(100, this, SLOT(startupLoadPatient())); // make sure this is called after application state change
}
 
SessionStorageServiceImpl::~SessionStorageServiceImpl()
{
        this->clearCache();
}
 
bool SessionStorageServiceImpl::isNull() const
{
        return false;
}
 
void SessionStorageServiceImpl::load(QString dir)
{
        bool valid = this->isValidSessionFolder(dir);
        bool exists = this->folderExists(dir);
 
        if (valid)
        {
                this->loadSession(dir);
        }
        else if (!exists)
        {
                this->initializeNewSession(dir);
        }
        else
        {
                reportError(QString("Failed to initialize session in existing folder with no valid session: %1").arg(dir));
        }
}
 
QString SessionStorageServiceImpl::getNoPatientFolder() const
{
        return DataLocations::getCachePath() + "/NoPatient";
}
 
 
bool SessionStorageServiceImpl::isValidSessionFolder(QString dir) const
{
        QString filename = QDir(dir).absoluteFilePath(this->getXmlFileName());
        return QFileInfo::exists(filename);
}
 
bool SessionStorageServiceImpl::folderExists(QString dir) const
{
        return QFileInfo(dir).exists() && QFileInfo(dir).isDir();
}
 
void SessionStorageServiceImpl::loadSession(QString dir)
{
        if (this->isActivePatient(dir))
                return;
        this->loadPatientSilent(dir);
        this->reportActivePatient();
        this->writeRecentPatientData();
}
 
void SessionStorageServiceImpl::initializeNewSession(QString dir)
{
        this->clearPatientSilent();
        dir = this->convertToValidFolderName(dir);
        this->createPatientFolders(dir);
        this->setActivePatient(dir);
        this->save();
        this->reportActivePatient();
        this->writeRecentPatientData();
}
 
QString SessionStorageServiceImpl::getXmlFileName() const
{
        return "custusdoc.xml";
}
 
void SessionStorageServiceImpl::save()
{
        if (!this->isValid())
                return;
 
        //Gather all the information that needs to be saved
        OrderedQDomDocument doc;
        this->generateSaveDoc(doc.doc());
 
        QDomElement element = doc.doc().documentElement();
        emit isSaving(element); // give all listeners a chance to add to the document
 
        QString filename = QDir(mActivePatientFolder).absoluteFilePath(this->getXmlFileName());
        XmlFileHandler::writeXmlFile(doc.doc(), filename);
        report("Saved patient " + mActivePatientFolder);
}
 
void SessionStorageServiceImpl::clear()
{
        this->clearPatientSilent();
        this->reportActivePatient();
        this->writeRecentPatientData();
}
 
bool SessionStorageServiceImpl::isValid() const
{
        return !mActivePatientFolder.isEmpty() &&
                        (mActivePatientFolder != this->getNoPatientFolder());
}
 
QString SessionStorageServiceImpl::getRootFolder() const
{
        return mActivePatientFolder;
}
 
void SessionStorageServiceImpl::reportActivePatient()
{
        report("Set Active Patient: " + mActivePatientFolder);
}
 
void SessionStorageServiceImpl::setActivePatient(const QString& activePatientFolder)
{
        if (activePatientFolder == mActivePatientFolder)
                return;
 
        mActivePatientFolder = activePatientFolder;
 
        emit sessionChanged();
}
 
void SessionStorageServiceImpl::onSessionChanged()
{
        reporter()->setLoggingFolder(this->getSubFolder("Logs/"));
}
 
void SessionStorageServiceImpl::clearPatientSilent()
{
        this->setActivePatient(this->getNoPatientFolder());
        emit cleared();
}
 
bool SessionStorageServiceImpl::isActivePatient(QString patient) const
{
        return (patient == mActivePatientFolder);
}
 
void SessionStorageServiceImpl::loadPatientSilent(QString choosenDir)
{
        if (this->isActivePatient(choosenDir))
                return;
        this->clearPatientSilent();
        if (choosenDir == QString::null)
                return; // On cancel
 
        QString filename = QDir(choosenDir).absoluteFilePath(this->getXmlFileName());
        QDomDocument doc = XmlFileHandler::readXmlFile(filename);
        mActivePatientFolder = choosenDir; // must set path before emitting isLoading()
 
        if (!doc.isNull())
        {
                //Read the xml
                QDomElement element = doc.documentElement();
                emit isLoading(element);
                emit isLoadingSecond(element);
        }
 
        emit sessionChanged();
}
 
void SessionStorageServiceImpl::writeRecentPatientData()
{
        settings()->setValue("startup/lastPatient", mActivePatientFolder);
        settings()->setValue("startup/lastPatientSaveTime", QDateTime::currentDateTime().toString(timestampSecondsFormat()));
}
 
void SessionStorageServiceImpl::generateSaveDoc(QDomDocument& doc)
{
        doc.appendChild(doc.createProcessingInstruction("xml version =", "'1.0'"));
 
        QDomElement patientNode = doc.createElement("patient");
 
        // note: all nodes must be below <patient>. XML requires only one root node per file.
        QDomElement versionName = doc.createElement("version_name");
        versionName.appendChild(doc.createTextNode(this->getVersionName()));
        patientNode.appendChild(versionName);
 
        QDomElement activePatientNode = doc.createElement("active_patient");
        activePatientNode.appendChild(doc.createTextNode(mActivePatientFolder.toStdString().c_str()));
        patientNode.appendChild(activePatientNode);
        doc.appendChild(patientNode);
}
 
QString SessionStorageServiceImpl::convertToValidFolderName(QString dir) const
{
        if (!dir.endsWith(".cx3"))
                dir.append(".cx3");
        return dir;
}
 
void SessionStorageServiceImpl::createPatientFolders(QString dir)
{
        QDir().mkpath(dir);
        QDir().mkpath(dir+"/Images");
        QDir().mkpath(dir+"/Logs");
        QDir().mkpath(dir+"/US_Acq");
}
 
QString SessionStorageServiceImpl::getVersionName()
{
        return QString("%1").arg(CustusX_VERSION_STRING);
}
 
void SessionStorageServiceImpl::clearCache()
{
//      std::cout << "DataLocations::getCachePath() " << DataLocations::getCachePath() << std::endl;
        // clear the global cache used by app
        removeNonemptyDirRecursively(DataLocations::getCachePath());
}
 
QString SessionStorageServiceImpl::getCommandLineStartupPatient()
{
        int doLoad = QApplication::arguments().indexOf("--load");
        if (doLoad < 0)
                return "";
        if (doLoad + 1 >= QApplication::arguments().size())
                return "";
 
        QString folder = QApplication::arguments()[doLoad + 1];
 
        return folder;
}
 
void SessionStorageServiceImpl::startupLoadPatient()
{
        QString folder = this->getCommandLineStartupPatient();
 
        if (!folder.isEmpty())
        {
                report(QString("Startup Load [%1] from command line").arg(folder));
        }
 
        if (folder.isEmpty() && settings()->value("Automation/autoLoadRecentPatient").toBool())
        {
                folder = settings()->value("startup/lastPatient").toString();
        if(this->isValidSessionFolder(folder))
        {
            QDateTime lastSaveTime = QDateTime::fromString(settings()->value("startup/lastPatientSaveTime").toString(), timestampSecondsFormat());
            double minsSinceLastSave = lastSaveTime.secsTo(QDateTime::currentDateTime())/60;
            double autoLoadRecentPatientWithinHours = settings()->value("Automation/autoLoadRecentPatientWithinHours").toDouble();
            int allowedMinsSinceLastSave = autoLoadRecentPatientWithinHours*60;
            if (minsSinceLastSave > allowedMinsSinceLastSave) // if less than 8 hours, accept
            {
                report(
                    QString("Startup Load: Ignored recent patient because %1 hours since last save, limit is %2")
                    .arg(int(minsSinceLastSave/60))
                    .arg(int(allowedMinsSinceLastSave/60)));
                folder = "";
            }
            if (!folder.isEmpty())
                report(QString("Startup Load [%1] as recent patient").arg(folder));
        }
        else
        {
            report("Startup Load: Ignored recent patient because it is not valid anymore");
            folder = "";
        }
 
        }
 
        if (folder.isEmpty())
                return;
 
        this->load(folder);
}
 
} // namespace cx