DataClass.cpp

/***************************************************************************
 *   Copyright (C) 2006 by Graeme Foster                                   *
 *   email    foster.graeme@gmail.com                                      *
 *                                                                         *
 *   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 2 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, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include "DataClass.h"

const int DataClass::NOT_ON_DB = -1;
const int DataClass::NO_PARENT = -1;

bool DataClass::dcCompareCI(const DataClass *p1, const DataClass * p2)
{
        return p1->getDescription().toLower() < p2->getDescription().toLower();
}

bool DataClass::dcCompareCS(const DataClass *p1, const DataClass * p2)
{
        return p1->getDescription() < p2->getDescription();
}


DataClass::DataClass(int pID)
{
        id       = pID;
        errorMsg = "";
        p_rtti   = DATA_CLASS;
        parent   = 0;
}

QString DataClass::getClassName()
{
        switch (p_rtti)
        {
                case DATA_CLASS:
                        return "DataClass";
                case INSTITUTE_CLASS:
                        return "Institute";
                case PROGRAMME_CLASS:
                        return "Programme";
                case MODULE_CLASS:
                        return "Module";
                case FACULTY_CLASS:
                        return "Faculty";
                case DEPARTMENT_CLASS:
                        return "Department";
                case STAFF_CLASS:
                        return "Staff";
                case ROOM_CLASS:
                        return "Room";
                case MOD_LEC_ALLOC_CLASS:
                        return "ModLecAlloc";
                case MOD_LEC_ENROL_CLASS:
                        return "ModLecEnrol";
                case TIMESLOT_CLASS:
                        return "TimeSlot";
        }
        return "";
}

QString DataClass::getSortValue() const
{
        if (parent == 0)
                return getDescription();
        else
                return parent->getDescription() + ":" + getDescription();
}

int DataClass::save(int insertSQL, int updateSQL, int errorSQL)
{
        if (id == NOT_ON_DB)
                return insert(insertSQL, errorSQL);
        else
                return update(updateSQL, errorSQL);
}

int DataClass::insert(int insertSQL, int errorSQL)
{
        bindValues(insertSQL, 0);
        try
        {
                sql::Instance()->query();
                id = sql::Instance()->getFirst(0).toInt();
                return id;
        }
        catch (sqlE &e)
        {
                return -1;
        }
}

int DataClass::update(int updateSQL, int errorSQL)
{
        int start = bindPKey(updateSQL);
        bindValues(updateSQL, start);
        try
        {
                sql::Instance()->query();
                id = sql::Instance()->getFirst(0).toInt();
                return id;
        }
        catch (sqlE &e)
        {
                return -1;
        }
}

int DataClass::remove(int deleteSQL, int errorSQL)
{
        bindPKey(deleteSQL);
        try
        {
                sql::Instance()->query();
                id = sql::Instance()->getFirst(0).toInt();
                return id;
        }
        catch (sqlE &e)
        {
                return -1;
        }
}

bool DataClass::unique(int uniqueSQL)
{
        try
        {
                sql::Instance()->query(uniqueSQL);
                return sql::Instance()->getFirst(0).toBool();
        }
        catch (sqlE &e)
        {
                return false;
        }
}

/*int DataClass::exec(QSqlQuery * execSQL, QSqlQuery * errorSQL)
{
        int result = -1;
        execSQL->exec();
        execSQL->first();

        if (execSQL->size() <= 0)
        {
                std::cout << execSQL->lastError().text().toStdString() << std::endl;
        }
        else
        {
                result = execSQL->value(0).toInt();
                if (result < 0)
                {
                        dbError(errorSQL, result);
                }
        }
        return result;
}

void DataClass::dbError(QSqlQuery * errorSQL, int errorID)
{
        errorSQL->bindValue(0,errorID);
        errorSQL->exec();
        errorSQL->first();
        errorMsg = errorSQL->value(0).toString();
        std::cout << errorMsg.toStdString() << std::endl;
}
*/

---