ZxQuery.cpp

Go to the documentation of this file.

/*
 * Zuble - A run-time system for QML/Javascript applications
 * Copyright (C) 2013, 2014  Bob Dinitto
 *
 * ZxQuery.cpp
 *
 *  Created on: 29-Sep, 2013
 *      Author: Bob Dinitto   bob@ninzo.com
 *
 * 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 "ZxQuery.h"
#include <QtQml>
#include <QFile>
#include "ZblThreadErr.h"
#include "zglobal.h"
//#include "ZmlEngine.h"
//#include "XmlDocument.h"
//#include "XmlFactory.h"
#include "ZxItem.h"
#include "ZApplication.h"


namespace Zbl
{

ZBL_DEFINE_LOGGED_OBJECT(Zbl::ZxQuery)


ZxQuery::ZxQuery(QObject *parent) :
    QObject(parent), m_xmlItem(0)
{
}

ZxQuery::ZxQuery(const ZxQuery& source, QObject *parent) :
    QObject(parent),
    m_query(source.m_query),
    m_queryText(source.m_queryText),
    m_focusText(source.m_focusText),
    m_xmlItem(source.m_xmlItem),
    m_enableSymbols(false)
{
    m_queryUrl = source.m_queryUrl;
    //m_focusUrl = source.m_focusUrl;
    m_focusFile.setUrl(m_focusFile.getUrl());
}

ZxQuery::ZxQuery(const QXmlNamePool & np, QObject *parent) :
    QObject(parent), m_query(np), m_xmlItem(0),
    m_enableSymbols(false)
{
}

void ZxQuery::setQueryUrl(const QString& url)
{
    zDebug() << "ZxQuery::setQueryUrl: %s" << cStr(url);

    m_queryFile.setUrl(url);

    m_queryText.clear();

    QString scheme(ZApplication::getPathScheme(url));

    bool queryOK = false;

    if(ResourceUrlFile::isResourceScheme(scheme))
    {
       zDebug() << "ZxQuery::setQueryUrl: opening resource file" << cStr(url);

       if(!m_queryFile.open())
       {
           zWarning() << "The XQuery failed. " << "Can't open query resource URL: "
                    << url <<  " File error: " << m_queryFile.errorString();

           return;
       }

       m_query.setQuery(m_queryFile.m_f);

       queryOK = m_query.isValid();

        if(!queryOK)
        {
            zDebug() << "The XQuery failed for query URL: " << url;
        }
    }
    else
    {
        m_query.setQuery(m_queryFile.m_url);

        queryOK = m_query.isValid();

        if(!queryOK)
        {
            zDebug() << "The XQuery failed for query URL: " << url;
        }
    }

    emit queryUrlChanged(queryOK);
}

const QString ZxQuery::getQueryUrl()
{
    return m_queryUrl.url();
}

void ZxQuery::setFocusUrl(const QString& url)
{
    zDebug() << "ZxQuery::setFocusUrl: %s" << cStr(url);

    m_focusFile.setUrl(url);

    QString scheme(ZApplication::getPathScheme(url));

    bool focusOK = true;

    if(ResourceUrlFile::isResourceScheme(scheme))
    {
       zDebug() << "ZxQuery::setFocusUrl: opening resource file" << cStr(url);

       if(!m_focusFile.open())
       {
           zDebug() << "XQuery can't open resource for focus URL: " << url << " File error: " << m_focusFile.errorString();

           return;
       }

       focusOK = m_query.setFocus(m_focusFile.m_f);

        if(!focusOK)
        {
            zDebug() << "Invalid XQuery focus for resource URL: " << url;
        }
    }
    else
    {
        focusOK = m_query.setFocus(m_focusFile.m_url);

        if(!focusOK)
        {
            zDebug() << "Invalid XQuery focus for URL: " << url;
        }
    }

    emit focusUrlChanged(focusOK);
}

const QString ZxQuery::getFocusUrl()
{
    return m_focusFile.getUrl();
}

void ZxQuery::setFocusText(const QString& text)
{
    zDebug() << "ZxQuery::setFocusText";

    zDebug() << "TEXT=" << text;

    m_focusFile.freeFile();

    m_focusText = text;

    m_query.setFocus(text);
}

const QString ZxQuery::getFocusText()
{
    return m_focusText;
}

void ZxQuery::setFocusItem(QObject* item)
{
    zDebug() << "ZxQuery::setFocusItem";

    Zbl::ZxItem* zItem = qobject_cast<Zbl::ZxItem*>(item);

    if(!zItem)
    {
        const char* className = item->metaObject()->className();

        zDebug() << "The XQuery failed for focus Item: " << className << ", Item object should be of class Zbl::ZxItem";

        return;
    }

    //m_queryText.clear( ); TBD: wtf?

    //m_focusUrl.clear();

    m_query.setFocus(zItem->m_item);

}

QObject* ZxQuery::getFocusItem()
{
    //ZxItem* newItem = new ZxItem();
    ZxItem* newItem = NULL;

    if(!m_xmlItem.isNull())
        newItem->setValue(m_xmlItem, this);

    return newItem;
}

void ZxQuery::setQueryText(const QString& text)
{
    zDebug() << "ZxQuery::setQueryText";

    zDebug() << "QUERY=" << text;

    m_queryText = text;

    if(!text.isEmpty())
    {
        m_queryUrl.clear( );

        m_query.setQuery(m_queryText);

        if(!m_query.isValid())
        {
            zDebug() << "Invalid XQuery: " << m_queryText.left(100) << "...";
        }
    }
}

const QString ZxQuery::getQueryText()
{
    return m_queryText;
}

#if 0
void ZxQuery::clearQueryText()
{
    m_queryText.clear();
}
#endif

void ZxQuery::registerType()
{
    ZBL_REGISTER_LOGGED_OBJECT

    qmlRegisterType<ZxQuery>("org.zuble.qml", 1, 0, "ZxQuery");
}

QObject* ZxQuery::evaluateToItems()
{
   zDebug() << "ZxQuery::evaluateToItems";

   ZxResultItems* items = new ZxResultItems(this);

   QXmlResultItems result;

   if (m_query.isValid())
   {
       m_query.evaluateTo(&result);

       /*
       if(!result.hasError())
       {
           zDebug() << "XQuery evaluation failed for url: %s", cStr(m_srcUrl.url()));

           QString msg("The XQuery evaluation failed for query URL: %1");

           zDebug() << "ZxQuery", "Evaluation Failed", msg.arg(m_srcUrl.url()));
       }
       else
       {
       */
           for(QXmlItem* item = new QXmlItem(result.next()); !item->isNull();
               item = new QXmlItem(result.next()))
           {
               if (result.hasError())
               {
                   zWarning() << "The XQuery evaluation failed for query URL: " << m_queryUrl.url();

                   break;
               }

               items->m_items.append(item);
           }
       //}
   }
   else
   {
       zWarning() << "The XQuery was invalid for query URL: " << m_queryUrl.url();
   }

   zDebug() << "ZxQuery::evaluateToItems found " << items->m_items.size() << " items";

   return items;
}

QStringList ZxQuery::evaluateToStringList()
{
   zDebug() << "ZxQuery::evaluateToStringList";

   QStringList result;

   if(m_query.isValid())
   {
       if(!m_query.evaluateTo(&result))
       {
           QString msg("The XQuery evaluation failed for query URL: %1");

           zDebug() << "Evaluation Failed" << m_queryUrl.url();
       }
   }

   return result;
}

QString ZxQuery::evaluateToXml()
{
   zDebug() << "ZxQuery::evaluateToXml";

   QString result;

   if(m_query.isValid())
   {
       if(!m_query.evaluateTo(&result))
       {
           zDebug() << "The XQuery evaluation failed for query URL: " << m_queryUrl.url();
       }
   }

   return result;
}

QXmlNamePool ZxQuery::getNamePool() const
{
    return m_query.namePool();
}

QObject* ZxQuery::getCopy()
{
    return new ZxQuery(*this, parent());
}

QObject* ZxQuery::getNamePoolCopy()
{
    return new ZxQuery(m_query.namePool(), parent());
}

ZxQuery::ResourceUrlFile::~ResourceUrlFile()
{
    if(m_f)
        m_f->deleteLater();
}

bool ZxQuery::ResourceUrlFile::open()
{
    resetFile();

    QString resourcePath = m_url.url();

    resourcePath = ZApplication::resolvePath(resourcePath, isResourceScheme(resourcePath));

    m_f->setFileName(resourcePath);

    zDebug() << "ZxQuery::ResourceUrlFile::open setting resource: " << resourcePath;

    if(!m_f->open(QIODevice::ReadOnly))
    {
        zWarning() << "Resource failed to open: " << resourcePath;

        return false;
    }

    return true;
}

void ZxQuery::ResourceUrlFile::resetFile()
{
    if(!m_f)
        m_f = new QFile();
    else
        closeFile();
}

void ZxQuery::ResourceUrlFile::closeFile()
{
    if(m_f && m_f->isOpen())
        m_f->close();
}

void ZxQuery::ResourceUrlFile::freeFile()
{
    if(m_f)
    {
        delete m_f;
        m_f = NULL;
    }
}

void ZxQuery::ResourceUrlFile::setUrl(const QString& url)
{
    if(url != m_url.url())
    {
        closeFile();
        m_url = url;
    }
}


void ZxQuery::bindVariable(const QString &localName, QObject* zXmlItem)
{

    ZxItem* item = qobject_cast<ZxItem*>(zXmlItem);

    if(!item)
    {
        zWarning() << "ZxQuery::bindVariable FAILED -- invalid object type: "
                 << "xZmlItem parameter must be a ZxItem object.";

        return;
    }

    m_query.bindVariable(localName, item->m_item);
}



void ZxQuery::setSymbolSubstitution(bool enabled)
{
    m_enableSymbols = enabled;
}

const bool ZxQuery::getSymbolSubstitution()
{
    return m_enableSymbols;
}

void ZxQuery::loadQueryText(const QString& fileUri)
{
    ResourceUrlFile resFile;

    resFile.setUrl(fileUri);

    bool queryOK = false;

       zDebug() << "ZxQuery::loadQueryText: opening resource file " << fileUri;

       if(!resFile.open())
       {
           zWarning() << "The XQuery failed. " << "Can't open query resource URL: "
                    << fileUri <<  " File error: " << resFile.errorString();

           return;
       }

    QFile* f = resFile.m_f;

    while(!f->atEnd() )
    {
        QString b(f->readLine(65535));

        if(f->error() != QFileDevice::NoError)
        {
            zWarning() << "ZxQuery::loadQueryText error while reading file: " << fileUri;
            zWarning() << "ZxQuery::loadQueryText ABORTING, file error = " << f->errorString();
            break;
        }

        m_queryText += b;
    }

    //zDebug() << "Query text buffer after load = " << m_queryText;
}

void ZxQuery::concatQueryText(const QString& text)
{
    zDebug() << "ZxQuery::concatQueryText";

    m_queryText += text;

    //zDebug() << "Query text buffer after concat = " << m_queryText;

}

void ZxQuery::commitQueryText()
{
    zDebug() << "ZxQuery::commitQueryText";

    m_query.setQuery(m_queryText);

    if(!m_query.isValid())
    {
        zWarning() << "The XQuery failed for query text: " << m_queryText.left(100)  << "...";
    }
}


void ZxQuery::bindSymbol(const QString& symbolName, const QString& symbolText)
{
    m_symbols.insert(symbolName, symbolText);
}

QString ZxQuery::getSymbolText(const QString& symbolName)
{
    return m_symbols.value(symbolName);
}

void ZxQuery::removeSymbol(const QString& symbolName)
{
    m_symbols.remove(symbolName);
}




} // Zbl