ZTableFile.cpp

Go to the documentation of this file.

/*
 * Zuble - A run-time system for QML/Javascript applications
 * Copyright (C) 2015 Bob Dinitto
 *
 * Filename:   ZTableFile.cpp
 * Created on: 7/6/2015
 * Author:     Bob Dinitto
 *
 * Zuble is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */

#include "ZTableFile.h"
#include "ZTableModel.h"
#include "ZblException.h"
#include <QSaveFile>
#include <QFile>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonArray>

namespace Zbl
{

ZBL_DEFINE_LOGGED_OBJECT(Zbl::ZTableFile)

qint64 ZTableFile::m_maxFileBytes = 100000 * 1024;

ZTableFile::ZTableFile(QObject *parent) :
    QObject(parent)
{
    ZBL_REGISTER_LOGGED_OBJECT

   m_data = new ZTableModel(this);

   m_watcher = new QFileSystemWatcher(this);

   QMetaObject::Connection connection = connect(m_watcher,
   &QFileSystemWatcher::fileChanged, this, &ZTableFile::fileModified);

   if(!connection)
       zCritical() << "Data file object watcher connection failed.";
}

void ZTableFile::validateWatcher()
{
    if(!m_watcher)
        throw ZblException(
        "ZTableFile - Programming error: object not initialized");
}


#if 0
bool ZTableFile::open(int openMode)
{
    bool retValue;
    ZBLQ_INVOKABLE_SLOT_BEGIN_TRY
    validateFile();
    retValue = m_f->open(QFile::OpenMode(openMode));
    ZBL_SLOT_END_RETURN(retValue,  false,
    Z_FAC_JS, ZFile::open, open failed)
}
#endif



bool ZTableFile::readFile(const QString& filePath)
{
    m_data->clearRoles();

    bool pathChanged = false;

    if(filePath.isEmpty() && m_filePath.isEmpty())
    {
        zWarning() << "Can't read data file for empty path.";

        return false;
    }
    else
    {
        if(filePath != m_filePath)
        {
            m_watcher->removePath(m_filePath);

            pathChanged = true;

            m_filePath = filePath;
        }
     }

    zDebug() << "Writing data file: " << filePath;

    QFile in(m_filePath);

    if(!in.exists())
    {
        zWarning() << "Can't read non-existent data file: " << m_filePath;
        return false;
    }

    bool ok = in.open(QIODevice::ReadOnly | QIODevice::Text);

    if(!ok)
    {
        zWarning() << "Can't open data file for reading: " << m_filePath;
        zWarning() << "File error status: " << in.errorString();
        return false;
    }

    QByteArray ba = in.read(m_maxFileBytes);

    if(ba.isEmpty())
    {
        if(in.error() == QFile::NoError)
        {
            zWarning() << "Can't read empty data file: " << m_filePath;
        }
        else
        {
            zWarning() << "File I/O error reading data file: " << m_filePath;
            zWarning() << "File error status: " << in.errorString();
        }
        in.close();
        return false;
    }

    in.close();

    QJsonParseError error;

    QJsonDocument doc = QJsonDocument::fromJson(ba, &error);

    if(error.error != QJsonParseError::NoError)
    {
        zWarning() << "JSON parse error reading data file: " << m_filePath;
        zWarning() << "JSON error status: " << error.errorString();
        return false;
    }

    m_data->putJsonData(doc.object()); // TBD: EXCEPTION HANDLER NEEDED!

    if(!ok)
    {
        zWarning() << "Data format error reading file: " << m_filePath;
        return false;
    }

    if(pathChanged)
    {
        if(!m_watcher->addPath(m_filePath))
        {
            zWarning() << "Can't monitor data file: " << m_filePath;
        }
    }

    return true;

}

bool ZTableFile::writeFile(const QString& filePath)
{
    QString previousFilePath;

    if(!filePath.isEmpty())
    {
        if(filePath != m_filePath)
        {
            previousFilePath = m_filePath;

            m_filePath = filePath;
        }
    }

    QSaveFile sf(m_filePath);

    bool ok = sf.open(QIODevice::WriteOnly | QIODevice::Text);

    if(!ok)
    {
        zWarning() << "Can't open data file for writing: "
                   << m_filePath;
        return false;
    }

    QJsonObject jo = m_data->getJsonData();

    QJsonDocument jd(jo);

    QByteArray ba = jd.toBinaryData();

    qint64 bytesOut = sf.write(ba);

    if(bytesOut == -1)
    {
        zWarning() << "Can't write to data file: " << m_filePath;
        return false;
    }

    ok = sf.commit();

    if(!ok)
    {
        zWarning() << "Can't commit data file: " << m_filePath;
        return false;
    }

    if(!previousFilePath.isEmpty())
    {
        m_watcher->removePath(previousFilePath);

        if(!m_watcher->addPath(m_filePath))
        {
            zWarning() << "Can't monitor data file: " << m_filePath;
        }
    }

    return true;
}




} // Zbl