dbListManager.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 "dbListManager.h"

dbListManager* dbListManager::_instance = 0;

dbListManager * dbListManager::Instance()
{
        if (_instance == 0)
        {
                _instance = new dbListManager;
        }
        return _instance;
}



dbListManager::dbListManager()
{
        dbConn = sql::Instance();
        pInstituteList  = new dbList();
        pProgrammeList  = new dbList();
        pModuleList     = new dbList();
        pFacultyList    = new dbList();
        pDepartmentList = new dbList();
        pStaffList      = new dbList();
        pRoomList       = new dbList();
        pMLAllocList    = new dbList();
        pTimeSlotList   = new dbList();
        newInstitute();
        newAlloc();
        newTimeSlot();
}

void dbListManager::registerModel(RootModel * model, int lists)
{
        registeredModels * rm = new registeredModels(model);
        pRegisteredModels.append(rm);
        if (lists & regInstitute)
                rm->registerList(pInstituteList);
        if (lists & regProgramme)
                rm->registerList(pProgrammeList);
        if (lists & regModule)
                rm->registerList(pModuleList);
        if (lists & regFaculty)
                rm->registerList(pFacultyList);
        if (lists & regDepartment)
                rm->registerList(pDepartmentList);
        if (lists & regStaff)
                rm->registerList(pStaffList);
        if (lists & regRoom)
                rm->registerList(pRoomList);
        if (lists & regMLAlloc)
                rm->registerList(pMLAllocList);
        if (lists & regTimeSlot)
                rm->registerList(pTimeSlotList);
}

void dbListManager::newInstitute ()
{
        Institute * instObj;
        int dbid;
        QString name, abbrev;

        QString sqlLine = "SELECT id, name, abbrev FROM basic.institute ORDER BY name";
        QString * dbConnName = dbConn->useModuleConn();
        sql::Instance()->prepare(sqlLine, *dbConnName);
        sql::Instance()->query();
        
        while (sql::Instance()->next())
        {
                dbid = dbConn->get(0).toInt();
                name = dbConn->get(1).toString();
                abbrev = dbConn->get(2).toString();
                instObj = new Institute (dbid, name, abbrev);
                pInstituteList->append(instObj);
                // Now get the Programmes, Faculties and Rooms for this Institute
                // Store the connection, so that the position is not lost
                dbConn->setCursor();
                newProgramme(instObj);
                newFaculty(instObj);
                newRoom(instObj);
                // Restore the connection
                dbConn->restoreCursor();
        }
}

void dbListManager::newProgramme (Institute * instObj)
{
        Programme * progObj;
        int dbid;
        QString name, abbrev;

        QString sqlLine = "SELECT id, name, abbrev FROM basic.programme WHERE institute_id = " + QString::number(instObj->getID()) + " ORDER BY name";
        QString * dbConnName = dbConn->useModuleConn();
        sql::Instance()->prepare(sqlLine, *dbConnName);
        sql::Instance()->query();
        
        while (sql::Instance()->next())
        {
                dbid = dbConn->get(0).toInt();
                name = dbConn->get(1).toString();
                abbrev = dbConn->get(2).toString();
                progObj = new Programme (dbid, name, abbrev, instObj);
                pProgrammeList->append(progObj);
                // Now get the Modules for this Programme
                // Store the connection, so that the position is not lost
                dbConn->setCursor();
                newModule(progObj);
                // Restore the connection
                dbConn->restoreCursor();
        }
}

void dbListManager::newModule (Programme * progObj)
{
        Module * moduleObj;
        int dbid;
        QString name, nomenclature;
        int duration, period;
        short semester;
        
        QString sqlLine = "SELECT id, name, nomenclature, duration, weekly_periods, semester FROM basic.module WHERE programme_id = "
                                                 + QString::number(progObj->getID()) + " ORDER BY name";
        QString * dbConnName = dbConn->useModuleConn();
        sql::Instance()->prepare(sqlLine, *dbConnName);
        sql::Instance()->query();
        
        while (sql::Instance()->next())
        {
                dbid = dbConn->get(0).toInt();
                name = dbConn->get(1).toString();
                nomenclature = dbConn->get(2).toString();
                duration = dbConn->get(3).toInt();
                period = dbConn->get(4).toInt();
                semester = dbConn->get(5).toInt();
                moduleObj = new Module (dbid, progObj, name, nomenclature, duration, period, semester);
                pModuleList->append(moduleObj);
        }
}

void dbListManager::newFaculty    (Institute  * instObj)
{
        Faculty * facultyObj;
        int dbid;
        QString name, abbrev;

        QString sqlLine = "SELECT id, name, abbrev FROM basic.faculty WHERE institute_id = " + QString::number(instObj->getID()) + " ORDER BY name";
        QString * dbConnName = dbConn->useModuleConn();
        sql::Instance()->prepare(sqlLine, *dbConnName);
        sql::Instance()->query();
        
        while (sql::Instance()->next())
        {
                dbid = dbConn->get(0).toInt();
                name = dbConn->get(1).toString();
                abbrev = dbConn->get(2).toString();
                facultyObj = new Faculty (dbid, name, abbrev, instObj);
                pFacultyList->append(facultyObj);
                // Now get the Departments for this Faculty
                // Store the connection, so that the position is not lost
                dbConn->setCursor();
                newDepartment(facultyObj);
                dbConn->restoreCursor();
                // Restore the connection
        }
}

void dbListManager::newDepartment (Faculty    * facultyObj)
{
        Department * deptObj;
        int dbid;
        QString name, abbrev;
        
        QString sqlLine = "SELECT id, name, abbrev FROM basic.department WHERE faculty_id = "
                                                 + QString::number(facultyObj->getID()) + " ORDER BY name";
        QString * dbConnName = dbConn->useModuleConn();
        sql::Instance()->prepare(sqlLine, *dbConnName);
        sql::Instance()->query();
        
        while (sql::Instance()->next())
        {
                dbid = dbConn->get(0).toInt();
                name = dbConn->get(1).toString();
                abbrev = dbConn->get(2).toString();
                deptObj = new Department (dbid, name, abbrev, facultyObj);
                pDepartmentList->append(deptObj);
                // Now get the Staff for this Department
                // Store the connection, so that the position is not lost
                dbConn->setCursor();
                newStaff(deptObj);
                // Restore the connection
                dbConn->restoreCursor();
        }
}

void dbListManager::newStaff      (Department * deptObj)
{
        Staff * staffObj;
        int dbid;
        QString fName, lName;
        
        QString sqlLine = "SELECT id, first_name, last_name FROM basic.staff WHERE dept_id = "
                                                 + QString::number(deptObj->getID()) + " ORDER BY first_name";
        QString * dbConnName = dbConn->useModuleConn();
        sql::Instance()->prepare(sqlLine, *dbConnName);
        sql::Instance()->query();
        
        while (sql::Instance()->next())
        {
                dbid = dbConn->get(0).toInt();
                fName = dbConn->get(1).toString();
                lName = dbConn->get(2).toString();
                staffObj = new Staff (dbid, fName, lName, deptObj);
                pStaffList->append(staffObj);
        }
}

void dbListManager::newRoom       (Institute  * instObj)
{
        Room * roomObj;
        int dbid;
        QString name, code;
        int capacity;

        QString sqlLine = "SELECT id, name, code, capacity FROM basic.room WHERE institute_id = " + QString::number(instObj->getID()) + " ORDER BY name";
        QString * dbConnName = dbConn->useModuleConn();
        sql::Instance()->prepare(sqlLine, *dbConnName);
        sql::Instance()->query();
        
        while (sql::Instance()->next())
        {
                dbid = dbConn->get(0).toInt();
                name = dbConn->get(1).toString();
                code = dbConn->get(2).toString();
                capacity = dbConn->get(3).toInt();
                roomObj = new Room (dbid, name, code, capacity, instObj);
                pRoomList->append(roomObj);
        }
}

void dbListManager::newAlloc()
{
        int inst_id, prog_id, mod_id, staff_id, sem, hours, c_size, c_groups, l_hours, l_groups;
   Module * modObj;
   Staff  * staffObj;
   ModLecAlloc * MLAllocObj;
   
        QString sqlLine = "SELECT institute_id, programme_id, module_id, lecturer_id, hours, semester, class_size, groups, lab_hours, lab_groups FROM basic.allocated_modules ORDER BY programme_id, semester, nomenclature";
        QString * dbConnName = dbConn->useModuleConn();
        sql::Instance()->prepare(sqlLine, *dbConnName);
        sql::Instance()->query();
        
        while (sql::Instance()->next())
        {
                inst_id  = dbConn->get(0).toInt();
                prog_id  = dbConn->get(1).toInt();
                mod_id   = dbConn->get(2).toInt();
                staff_id = dbConn->get(3).toInt();
                hours    = dbConn->get(4).toInt();
                sem      = dbConn->get(5).toInt();
                c_size   = dbConn->get(6).toInt();
                c_groups = dbConn->get(7).toInt();
                l_hours  = dbConn->get(8).toInt();
                l_groups = dbConn->get(9).toInt();
                modObj=getModuleFromID(mod_id);
                staffObj=getStaffFromID(staff_id);
                MLAllocObj = new ModLecAlloc(0, modObj, staffObj, hours, sem, c_size, c_groups, l_hours, l_groups);
                pMLAllocList->append(MLAllocObj);
        }
}

void dbListManager::newTimeSlot()
{
        int id, inst_id, theDay, duration;
   QTime startTime, finishTime;
   Institute * instObj;
   TimeSlot  * TSlotObj;
   
        QString sqlLine = "SELECT id, institute_id, day_of_week, time_start, time_finish FROM basic.timeslot ORDER BY institute_id, day_of_week, time_start";
        QString * dbConnName = dbConn->useModuleConn();
        sql::Instance()->prepare(sqlLine, *dbConnName);
        sql::Instance()->query();
        
        while (sql::Instance()->next())
        {
                id         = dbConn->get(0).toInt();
                inst_id    = dbConn->get(1).toInt();
                theDay     = dbConn->get(2).toInt();
                startTime  = dbConn->get(3).toTime();
                finishTime = dbConn->get(4).toTime();
                
                instObj=getInstituteFromID(inst_id);
                duration = startTime.secsTo(finishTime)/60;
                TSlotObj = new TimeSlot(id, instObj,TimeSlot::days(theDay), duration, startTime);
                pTimeSlotList->append(TSlotObj);
        }
}

void dbListManager::updateRMInsert(dbList * list, RootItem * item, QModelIndex & index, int posn)
{
        RootModel * rm;
        for (int i = 0; i < pRegisteredModels.size(); i++)
        {
                if (pRegisteredModels.at(i)->listIsMember(list))
                {
                        rm = pRegisteredModels.at(i)->pModel;
                        rm->insertItem(item->clone(), index, posn);
                }
        }
}

void dbListManager::updateRMUpdate(dbList * list, DataClass * dcObj, CompareRI compare)
{
        RootModel * rm;
        for (int i = 0; i < pRegisteredModels.size(); i++)
        {
                if (pRegisteredModels.at(i)->listIsMember(list))
                {
                        rm = pRegisteredModels.at(i)->pModel;
                        rm->sort(compare,dcObj);
                }
        }
}

void dbListManager::updateRMDelete(dbList * list, DataClass * dcObj)
{
        RootModel * rm;
        for (int i = 0; i < pRegisteredModels.size(); i++)
        {
                if (pRegisteredModels.at(i)->listIsMember(list))
                {
                        rm = pRegisteredModels.at(i)->pModel;
                        rm->deleteItem(dcObj);
                }
        }
}

void dbListManager::insert(RootItem * item, dbList * list, QModelIndex & index, CompareDC lessThan)
{
        DataClass * dataObj = item->getItemData();
        int posn = 0;
        int i = 0;
        while (i < list->size())
        {
                if (lessThan(list->at(i),dataObj))
                        break;
                posn = i;
                i++;
        }
        if (i == list->size())
                posn = i;
        list->insert(posn,dataObj);
        updateRMInsert(list, item, index, posn);
        // Now save the item on the database
        item->dbSave();
}

//template<typename Compare>
void dbListManager::update(RootItem * item, dbList * list, CompareRI compare)
{
        DataClass * dataObj = item->getItemData();
        list->resort(DataClass::dcCompareCI);
        updateRMUpdate(list, dataObj, compare);
        // Now save the item on the database
        item->dbSave();
}

void dbListManager::remove(RootItem * item, dbList * list, bool cascade)
{
        DataClass * dataObj = item->getItemData();
        int posn = 0;
        while (posn < list->size())
        {
                if (list->at(posn) == dataObj)
                {
                        list->remove(posn);
                        break;
                }
                posn++;
        }
        // Cascade delete on the dbLists
        if (cascade)
                removeAllChilden(dataObj);
        // Delete from the Models (cascade delete is inherent in the data structure)
        updateRMDelete(list, dataObj);
        // Now remove the item from the database (cascade delete is on the database)
        item->dbDelete();
}

void dbListManager::removeAllChilden(DataClass * dcObj)
{
        removeChild(dcObj,pInstituteList);
        removeChild(dcObj,pProgrammeList);
        removeChild(dcObj,pModuleList);
        removeChild(dcObj,pFacultyList);
        removeChild(dcObj,pDepartmentList);
        removeChild(dcObj,pStaffList);
        removeChild(dcObj,pRoomList);
        removeChild(dcObj,pMLAllocList);
        removeChild(dcObj,pTimeSlotList);
}

void dbListManager::removeChild(DataClass * dcObj, dbList * list)
{
        int posn = 0;
        while (posn < list->size())
        {
                if (list->at(posn)->getParent() == dcObj)
                {
                        DataClass * newObj = list->at(posn);
                        list->remove(posn);
                        removeAllChilden(newObj);
                }
                else
                        posn++;
        }
}


void dbListManager::dump(bool details)
{
        std::cout << "dbListManager\n";
        std::cout << "   pInstituteList [" << pInstituteList->size()<< "] - ";
        for (int i = 0; i < pInstituteList->size(); i++)
        {
                std::cout << " (";
                std::cout << getProgrammeList(static_cast<Institute*>(pInstituteList->at(i)))->size();
                std::cout << ")";
        }
        std::cout << "\n";
        if (details)
                for (int i = 0; i < pInstituteList->size(); i++)
                {
                        std::cout << "      " << pInstituteList->at(i)->getDescription().toStdString();
                        std::cout << getProgrammeList(static_cast<Institute*>(pInstituteList->at(i)))->size();
                        std::cout << "\n";
                }
        std::cout << "   pProgrammeList [" << pProgrammeList->size()<< "]\n";
        if (details)
                for (int i = 0; i < pProgrammeList->size(); i++)
                {
                        std::cout << "         " << pProgrammeList->at(i)->getDescription().toStdString() <<"\n";
                }
        std::cout << "      pModuleList [" << pModuleList->size()<< "]\n";
        if (details)
                for (int i = 0; i < pModuleList->size(); i++)
                {
                        std::cout << "            " << pModuleList->at(i)->getDescription().toStdString() <<"\n";
                }
        std::cout << "   pFacultyList [" << pFacultyList->size()<< "]\n";
        if (details)
                for (int i = 0; i < pFacultyList->size(); i++)
                {
                        std::cout << "         " << pFacultyList->at(i)->getDescription().toStdString() <<"\n";
                }
        std::cout << "   pDepartmentList [" << pDepartmentList->size()<< "]\n";
        if (details)
                for (int i = 0; i < pDepartmentList->size(); i++)
                {
                        std::cout << "         " << pDepartmentList->at(i)->getDescription().toStdString() <<"\n";
                }
        std::cout << "   pStaffList [" << pStaffList->size()<< "]\n";
        if (details)
                for (int i = 0; i < pStaffList->size(); i++)
                {
                        std::cout << "         " << pStaffList->at(i)->getDescription().toStdString() <<"\n";
                }
        std::cout << "   pRoomList [" << pRoomList->size()<< "]\n";
        if (details)
                for (int i = 0; i < pRoomList->size(); i++)
                {
                        std::cout << "         " << pRoomList->at(i)->getDescription().toStdString() <<"\n";
                }
        std::cout << "RegisteredModels [" << pRegisteredModels.size()<< "]\n";
        if (details)
                for (int i = 0; i < pRegisteredModels.size(); i++)
                {
                        pRegisteredModels.at(i)->dump();
                }
}

void dbListManager::registeredModels::dump()
{
        std::cout << "   " << pModel->metaObject()->className() << "\n";
        for (int i = 0; i<listOfLists.size(); i++)
                listOfLists.at(i)->dump();
}

---