/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the Qt Mobility Components.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

// #define QT_SFW_SERVICEDATABASE_DEBUG

#include "servicedatabase_p.h"

#include <QDir>

#include <QSet>

#include "qserviceinterfacedescriptor.h"

#include "qserviceinterfacedescriptor_p.h"

#include <QUuid>

#include "dberror_p.h"

//database name

#define RESOLVERDATABASE "services.db"

//database table names

#define SERVICE_TABLE "Service"

#define INTERFACE_TABLE "Interface"

#define DEFAULTS_TABLE "Defaults"

#define SERVICE_PROPERTY_TABLE "ServiceProperty"

#define INTERFACE_PROPERTY_TABLE "InterfaceProperty"

//separator

#define RESOLVERDATABASE_PATH_SEPARATOR "//"

#ifdef QT_SFW_SERVICEDATABASE_DEBUG

#include <QDebug>

#endif

#define SERVICE_DESCRIPTION_KEY "DESCRIPTION"

#ifdef QT_SFW_SERVICEDATABASE_USE_SECURITY_TOKEN

#define SECURITY_TOKEN_KEY "SECURITYTOKEN"

#endif

#define INTERFACE_DESCRIPTION_KEY "DESCRIPTION"

#define INTERFACE_CAPABILITY_KEY "CAPABILITIES"

QTM_BEGIN_NAMESPACE

enum TBindIndexes

    {

        EBindIndex=0,

        EBindIndex1,

        EBindIndex2,

        EBindIndex3,

        EBindIndex4,

        EBindIndex5,

        EBindIndex6,

        EBindIndex7

    };

/*

   \class ServiceDatabase

   The ServiceDatabase is responsible for the management of a single

   service database.  It provides operations for:

   - opening and closing a connection with the database,

   - registering and unregistering services

   - querying for services and interfaces

   - setting and getting default interface implementations.

*/

/*

    Constructor

*/

ServiceDatabase::ServiceDatabase(void)

:m_isDatabaseOpen(false),m_inTransaction(false)

{

}

/*

    Destructor

*/

ServiceDatabase::~ServiceDatabase()

{

    close();

}

/*

    Opens the service database

    The method creates or opens database and creates tables if they are not present

    Returns true if the operation was successful, false if not.

*/

bool ServiceDatabase::open()

{

    if (m_isDatabaseOpen)

        return true;

    QString path;

    //Create full path to database

    if(m_databasePath.isEmpty ())

        m_databasePath = databasePath();

    path = m_databasePath;

    QFileInfo dbFileInfo(path);

    if (!dbFileInfo.dir().exists()) {

       if(!QDir::root().mkpath(dbFileInfo.path())) {

           QString errorText("Could not create database directory: %1");

           m_lastError.setError(DBError::CannotCreateDbDir, errorText.arg(dbFileInfo.path()));

#ifdef QT_SFW_SERVICEDATABASE_DEBUG

           qWarning() << "ServiceDatabase::open():-"

                        << "Problem:" << qPrintable(m_lastError.text());

#endif

           close();

           return false;

        }

    }

    m_connectionName = dbFileInfo.completeBaseName();

    QSqlDatabase  database;

    if(QSqlDatabase::contains(m_connectionName)) {

        database = QSqlDatabase::database(m_connectionName);

    } else {

        database = QSqlDatabase::addDatabase("QSQLITE", m_connectionName);

        database.setDatabaseName(path);

    }

    if (!database.isValid()){

        m_lastError.setError(DBError::InvalidDatabaseConnection);

        close();

        return false;

    }

    //Create or open database

    if (!database.isOpen()) {

        if(!database.open()) {

            m_lastError.setError(DBError::SqlError, database.lastError().text());

#ifdef QT_SFW_SERVICEDATABASE_DEBUG

            qWarning() << "ServiceDatabase::open():-"

                        << "Problem:" << "Could not open database. "

                        << "Reason:" << m_lastError.text();

#endif

            close();

            return false;

        }

    }

    m_isDatabaseOpen = true;

    //Check database structure (tables) and recreate tables if neccessary

    //If one of tables is missing remove all tables and recreate them

    //This operation is required in order to avoid data coruption

    if (!checkTables()) {

        if(dropTables()) {

            if (createTables()) {

#ifdef QT_SFW_SERVICEDATABASE_DEBUG

                qDebug() << "ServiceDatabase::open():-"

                    << "Database tables recreated";

#endif

            } else {

                //createTable() should've handled error message

                //and warning

                close();

                return false;

            }

        }

        else {

            //dropTables() should've handled error message

            //and warning

            close();

            return false;

        }

    }

    return true;

}

/*

   Adds a \a service into the database.

   May set the following error codes

   DBError::NoError

   DBError::LocationAlreadyRegistered

   DBError::IfaceImplAlreadyRegistered

   DBError::SqlError

   DBError::DatabaseNotOpen

   DBError::InvalidDatabaseConnection

   DBError::NoWritePermissions

   DBError::InvalidDatabaseFile

*/

//bool ServiceDatabase::registerService(ServiceMetaData &service)

bool ServiceDatabase::registerService(const ServiceMetaDataResults &service, const QString &securityToken)

{

#ifndef QT_SFW_SERVICEDATABASE_USE_SECURITY_TOKEN

    Q_UNUSED(securityToken);

#else

    if (securityToken.isEmpty()) {

        QString errorText("Access denied, no security token provided (for registering service: \"%1\")");

        m_lastError.setError(DBError::NoWritePermissions, errorText.arg(service.name));

#ifdef QT_SFW_SERVICEDATABASE_DEBUG

        qWarning() << "ServiceDatabase::registerService():-"

                << "Problem: Unable to register service,"

                << "reason:" << qPrintable(m_lastError.text());

#endif

        return false;

    }

#endif

    if(!checkConnection()) {

#ifdef QT_SFW_SERVICEDATABASE_DEBUG

        qWarning() << "ServiceDatabase::registerService():-"

                    << "Problem:" << qPrintable(m_lastError.text());

#endif

        return false;

    }

    QSqlDatabase database = QSqlDatabase::database(m_connectionName);

    QSqlQuery query(database);

    if (!beginTransaction(&query, Write)) {

#ifdef QT_SFW_SERVICEDATABASE_DEBUG

        qWarning() << "ServiceDatabase::registerService():-"

                    << "Unable to begin transaction,"

                    << "reason:" << qPrintable(m_lastError.text());

#endif

        return false;

    }

    //See if the service's location has already been previously registered

    QString statement("SELECT Name from Service WHERE Location=? COLLATE NOCASE");

    QList<QVariant> bindValues;

    bindValues.append(service.location);

    if (!executeQuery(&query, statement, bindValues)) {

        rollbackTransaction(&query);

#ifdef QT_SFW_SERVICEDATABASE_DEBUG

        qWarning() << "ServiceDatabase::registerService():-"

                    << qPrintable(m_lastError.text());

#endif

        return false;

    }

    if (query.next()) {

        QString alreadyRegisteredService = query.value(EBindIndex).toString();

        const QString errorText = "Cannot register service \"%1\". Service location \"%2\" is already "

                    "registered to service \"%3\".  \"%3\" must first be deregistered "

                    "for new registration to take place.";

        m_lastError.setError(DBError::LocationAlreadyRegistered,

                errorText.arg(service.name)

                        .arg(service.location)

                        .arg(alreadyRegisteredService));

        rollbackTransaction(&query);

#ifdef QT_SFW_SERVICEDATABASE_DEBUG

        qWarning() << "ServiceDatabase::registerService():-"

                    << "Problem:" << qPrintable(m_lastError.text());

#endif

        return false;

    }

#ifdef QT_SFW_SERVICEDATABASE_USE_SECURITY_TOKEN

    // If service(s) have already been registered with same name, they must all come from

    // same application. Fetch a service with given name and if such exists, check that its

    // security ID equals to the security ID of the current registrar.

    // One application may register multiple services with same name (different location),

    // hence the keyword DISTINCT.

    statement = "SELECT DISTINCT ServiceProperty.Value FROM Service, ServiceProperty "

                "WHERE Service.ID = ServiceProperty.ServiceID "

                "AND ServiceProperty.Key = ? "

                "AND Service.Name = ?";

    bindValues.clear();

    bindValues.append(SECURITY_TOKEN_KEY);

    bindValues.append(service.name);

    if (!executeQuery(&query, statement, bindValues)) {

        rollbackTransaction(&query);

#ifdef QT_SFW_SERVICEDATABASE_DEBUG

        qWarning() << "ServiceDatabase::registerService():-"

                   << qPrintable(m_lastError.text());

#endif

        return false;

    }

    QString existingSecurityToken;

    if (query.next()) {

        existingSecurityToken = query.value(EBindIndex).toString();

    }

    if (!existingSecurityToken.isEmpty() && (existingSecurityToken != securityToken)) {

        QString errorText("Access denied: \"%1\"");

        m_lastError.setError(DBError::NoWritePermissions, errorText.arg(service.name));

        rollbackTransaction(&query);

#ifdef QT_SFW_SERVICEDATABASE_DEBUG

        qWarning() << "ServiceDatabase::registerService():-"

                << "Problem: Unable to register service,"

                << "reason:" << qPrintable(m_lastError.text());

#endif

        return false;

    }

#endif // QT_SFW_SERVICEDATABASE_USE_SECURITY_TOKEN

    // Checks done, create new rows into tables.

    statement = "INSERT INTO Service(ID,Name,Location) VALUES(?,?,?)";

    QString serviceID = QUuid::createUuid().toString();

    bindValues.clear();

    bindValues.append(serviceID);

    bindValues.append(service.name);

    bindValues.append(service.location);

    if (!executeQuery(&query, statement, bindValues)) {

        rollbackTransaction(&query);

#ifdef QT_SFW_SERVICEDATABASE_DEBUG

        qWarning() << "ServiceDatabase::registerService():-"

                    << qPrintable(m_lastError.text());

#endif

        return false;

    }

    statement = "INSERT INTO ServiceProperty(ServiceID,Key,Value) VALUES(?,?,?)";

    bindValues.clear();

    bindValues.append(serviceID);

    bindValues.append(SERVICE_DESCRIPTION_KEY);

    if (service.description.isNull())

        bindValues.append("");

    else

        bindValues.append(service.description);

    if (!executeQuery(&query, statement, bindValues)) {

        rollbackTransaction(&query);

#ifdef QT_SFW_SERVICEDATABASE_DEBUG

        qWarning() << "ServiceDatabase::registerService():-"

                    << qPrintable(m_lastError.text());

#endif

        return false;

    }

#ifdef QT_SFW_SERVICEDATABASE_USE_SECURITY_TOKEN

    // Insert a security token for the particular service

    statement = "INSERT INTO ServiceProperty(ServiceID,Key,Value) VALUES(?,?,?)";

    bindValues.clear();

    bindValues.append(serviceID);

    bindValues.append(SECURITY_TOKEN_KEY);

    bindValues.append(securityToken);

    if (!executeQuery(&query, statement, bindValues)) {

        rollbackTransaction(&query);

#ifdef QT_SFW_SERVICEDATABASE_DEBUG

        qWarning() << "ServiceDatabase::registerService():-"

                << qPrintable(m_lastError.text());

#endif

        return false;

    }

#endif // QT_SFW_SERVICEDATABASE_USE_SECURITY_TOKEN

    QList <QServiceInterfaceDescriptor> interfaces = service.interfaces;

    QString interfaceID;;

    foreach (const QServiceInterfaceDescriptor &interface, interfaces) {

        interfaceID = getInterfaceID(&query, interface);

        if (m_lastError.code() == DBError::NoError) {

            QString errorText;

            errorText = "Cannot register service \"%1\". \"%1\" is already registered "

                        "and implements interface \"%2\", Version \"%3.%4.\"  \"%1\" must "

                        "first be deregistered for new registration to take place.";

            m_lastError.setError(DBError::IfaceImplAlreadyRegistered,

                                errorText.arg(interface.serviceName())

                                            .arg(interface.interfaceName())

                                            .arg(interface.majorVersion())

                                            .arg(interface.minorVersion()));

            rollbackTransaction(&query);

#ifdef QT_SFW_SERVICEDATABASE_DEBUG

            qWarning() << "ServiceDatabase::registerService():-"

                        << "Problem:" << qPrintable(m_lastError.text());

#endif

            return false;

        } else if (m_lastError.code() == DBError::NotFound){

            //No interface implementation already exists for the service

            //so add it

            if(!insertInterfaceData(&query, interface, serviceID)) {

                rollbackTransaction(&query);

                return false;

            } else {

                continue;

            }

        } else {

            rollbackTransaction(&query);

#ifdef QT_SFW_SERVICEDATABASE_DEBUG

            qWarning() << "ServiceDatabase::registerService():-"

                        << "Unable to confirm if implementation version"

                        << (QString::number(interface.majorVersion()) + "."

                           + QString::number(interface.minorVersion())).toAscii()

                        << "for interface" << interface.interfaceName()

                        << "is already registered for service "

                        << interface.serviceName()

                        << qPrintable(QString("\n") + m_lastError.text());

#endif

            return false;

        }

    }

    interfaces = service.latestInterfaces;

    QServiceInterfaceDescriptor defaultInterface;

    foreach(const QServiceInterfaceDescriptor &interface, interfaces) {

        defaultInterface = interfaceDefault(interface.interfaceName(), NULL, true);

        if (m_lastError.code() == DBError::NoError

                || m_lastError.code() == DBError::ExternalIfaceIDFound) {

            continue; //default already exists so don't do anything

        } else if (m_lastError.code() == DBError::NotFound) {

            //default does not already exist so create one

            interfaceID = getInterfaceID(&query, interface);

            if (m_lastError.code() != DBError::NoError) {

                rollbackTransaction(&query);

#ifdef QT_SFW_SERVICEDATABASE_DEBUG

                qWarning() << "ServiceDatabase::registerService():-"

                    << "Unable to retrieve interfaceID for "

                        "interface" << interface.interfaceName()

                        <<  qPrintable(QString("\n") + m_lastError.text());

#endif

                return false;

            }

            statement = "INSERT INTO Defaults(InterfaceName, InterfaceID) VALUES(?,?)";

            bindValues.clear();

            bindValues.append(interface.interfaceName());

            bindValues.append(interfaceID);

            if (!executeQuery(&query, statement, bindValues)) {

                rollbackTransaction(&query);

#ifdef QT_SFW_SERVICEDATABASE_DEBUG

                qWarning() << "ServiceDatabase::registerService():-"

                    << qPrintable(m_lastError.text());

#endif

                return false;

            }

        } else {

            rollbackTransaction(&query);

#ifdef QT_SFW_SERVICEDATABASE_DEBUG

            qWarning() << "ServiceDatabase::registerService()"

                        << "Problem: Unable to confirm if interface"

                        << interface.interfaceName()

                        << "already has a default implementation";

#endif

            return false;

        }

    }

    if(!commitTransaction(&query)) {

        rollbackTransaction(&query);

        return false;

    }

    m_lastError.setError(DBError::NoError);

    return true;

}

/*

    Obtains an interface ID corresponding to a given interface \a descriptor

    May set the following error codes:

    DBError::NoError

    DBError::NotFound

    DBError::SqlError

    DBError::DatabaseNotOpen

    DBError::InvalidDatabaseConnection

*/

QString ServiceDatabase::getInterfaceID(const QServiceInterfaceDescriptor &descriptor) {

    QString interfaceID;

    if (!checkConnection()) {

#ifdef QT_SFW_SERVICEDATABASE_DEBUG

        qWarning() << "ServiceDatabase::getInterfaceID():-"

                    << "Problem:" << qPrintable(m_lastError.text());

#endif

        return interfaceID;

    }

    QSqlDatabase database = QSqlDatabase::database(m_connectionName);

    QSqlQuery query(database);

    return getInterfaceID(&query, descriptor);

}

/*