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

int ModLecAlloc::insertSQL = 0;
int ModLecAlloc::updateSQL = 0;
int ModLecAlloc::deleteSQL = 0;
int ModLecAlloc::addClassSizeSQL = 0;
int ModLecAlloc::addGroupsSQL = 0;
int ModLecAlloc::addLabHoursSQL = 0;
int ModLecAlloc::addLabGroupsSQL = 0;

int ModLecAlloc::idSQL = 0;

int ModLecAlloc::errorSQL = 0;

void ModLecAlloc::PrepareSQL(sql * dbConn)
{
        if (dbConn != 0)
        {
                insertSQL = dbConn->prepare("basic.mod_lec_alloc_insert",3,*dbConn->useModuleConn());
                updateSQL = dbConn->prepare("basic.mod_lec_alloc_update",3,*dbConn->useModuleConn());
                deleteSQL = dbConn->prepare("basic.mod_lec_alloc_delete",2,*dbConn->useModuleConn());
                addClassSizeSQL = dbConn->prepare("basic.mod_lec_alloc_add_class_size",3,*dbConn->useModuleConn());
                addGroupsSQL =  dbConn->prepare("basic.mod_lec_alloc_add_groups",3,*dbConn->useModuleConn());
                addLabHoursSQL =  dbConn->prepare("basic.mod_lec_alloc_add_lab_hours",3,*dbConn->useModuleConn());
                addLabGroupsSQL =  dbConn->prepare("basic.mod_lec_alloc_add_lab_groups",3,*dbConn->useModuleConn());
                
                idSQL     = dbConn->prepare("basic.mod_lec_alloc_id"    ,2,*dbConn->useModuleConn());
                
                errorSQL = dbConn->prepare("basic.mod_lec_alloc_error",1,*dbConn->useModuleConn());
        }
}

ModLecAlloc::ModLecAlloc()
:DataClass()
{
        modObj = 0;
        lecObj = 0;
        hours  = 0;
        semester = 0;
        class_size = 0;
        groups = 1;
        lab_hours = 0;
        lab_groups = 0;
        p_rtti = MOD_LEC_ALLOC_CLASS;
}

ModLecAlloc::ModLecAlloc(int onDB
                                                                ,Module * mod
                                                                ,Staff * lec
                                                                ,int hrs
                                                                ,int sem
                                                                ,int c_size
                                                                ,int c_groups
                                                                ,int l_hours
                                                                ,int l_groups)
:DataClass(onDB)
{
        modObj = mod;
        lecObj = lec;
        // Don't calculate the id if it is not yet on the database
        // Otherwise calculate the id from the database (hence it will be consistent)
        if (id != NOT_ON_DB)
        {
                sql::Instance()->setCursor();
                bindPKey(idSQL);
                sql::Instance()->query(idSQL);
                id = sql::Instance()->getFirst(0).toInt();
                sql::Instance()->restoreCursor();
        }
        hours = hrs;
        semester = sem;
        class_size = c_size;
        groups = c_groups;
        lab_hours = l_hours;
        lab_groups = l_groups;
        parent = mod->getParent();
        p_rtti = MOD_LEC_ALLOC_CLASS;
}

int ModLecAlloc::bindPKey(int preparedSQL)
{
        sql::Instance()->bind(0,modObj->getID(),preparedSQL);
        sql::Instance()->bind(1,lecObj->getID());
        return 2;
}

void ModLecAlloc::bindValues(int preparedSQL, int start)
{
        // Set up the primary key for the Insert
        if (start == 0)
                start = bindPKey(preparedSQL);
        sql::Instance()->bind(start,hours,preparedSQL);
}

void ModLecAlloc::updateClassSizeonDB(int classSize)
{
        if (classSize == class_size)
                return;
        bindPKey(addClassSizeSQL);
        sql::Instance()->bind(2,classSize,addClassSizeSQL);
        try
        {
                sql::Instance()->query();
                id = sql::Instance()->getFirst(0).toInt();
                setClassSize(classSize);
        }
        catch (sqlE &e){}
}

void ModLecAlloc::updateGroupsonDB(int classGroups)
{
        if (classGroups == groups)
                return;
        bindPKey(addGroupsSQL);
        sql::Instance()->bind(2,classGroups,addGroupsSQL);
        try
        {
                sql::Instance()->query();
                id = sql::Instance()->getFirst(0).toInt();
                setGroups(classGroups);
        }
        catch (sqlE &e){}
}

void ModLecAlloc::updateLabHoursonDB(int labHours)
{
        if (labHours == lab_hours)
                return;
        bindPKey(addLabHoursSQL);
        sql::Instance()->bind(2,labHours,addLabHoursSQL);
        try
        {
                sql::Instance()->query();
                id = sql::Instance()->getFirst(0).toInt();
                setLabHours(labHours);
        }
        catch (sqlE &e){}
}

void ModLecAlloc::updateLabGroupsonDB(int labGroups)
{
        if (labGroups == lab_groups)
                return;
        bindPKey(addLabGroupsSQL);
        sql::Instance()->bind(2,labGroups,addLabGroupsSQL);
        try
        {
                sql::Instance()->query();
                id = sql::Instance()->getFirst(0).toInt();
                setLabGroups(labGroups);
        }
        catch (sqlE &e){}
}

---