StoredFunctions.sql

DELIMITER //

DROP FUNCTION IF EXISTS GetGradeID//
DROP FUNCTION IF EXISTS SetCurSemesterID//
DROP FUNCTION IF EXISTS SetHashKey//

drop function if exists InternalIsTeacherBinded//
DROP FUNCTION IF EXISTS GetSemesterID//

DROP FUNCTION IF EXISTS GetRateForDiscExtra//
DROP FUNCTION IF EXISTS GetRateForDiscBonus//
DROP FUNCTION IF EXISTS GetRateForDiscSemester//
DROP FUNCTION IF EXISTS GetRateForDiscExamNum//
DROP FUNCTION IF EXISTS GetRateForDiscExam//
DROP FUNCTION IF EXISTS InternalNotify//
DROP FUNCTION IF EXISTS GetDisciplineMaxRate//
DROP FUNCTION IF EXISTS OrderModuleTypesForSession//

DROP FUNCTION IF EXISTS CreateStudyGroup//

DROP FUNCTION IF EXISTS GetAccCountByCode//
DROP FUNCTION IF EXISTS GetAccCountByMail//
DROP FUNCTION IF EXISTS GetAccCountByLogin//

DROP FUNCTION IF EXISTS ChangePassword//
DROP FUNCTION IF EXISTS ChangeLogin//
DROP FUNCTION IF EXISTS ChangeMail//


# -------------------------------------------------------------------------------------------
# Label: abbreviations
# -------------------------------------------------------------------------------------------

# abbreviation: abbr
# specialization: spec
# department: dep

# -------------------------------------------------------------------------------------------
# Label: internals
# -------------------------------------------------------------------------------------------

# actually check for first scoring, in this case you cannot yet edit discipline
# "SetRate" stored procedure can change isLocked flag
DROP FUNCTION IF EXISTS InternalIsMapLocked//
CREATE FUNCTION `InternalIsMapLocked` (
        `pDisciplineID` INT
    ) RETURNS BOOLEAN
    NO SQL
BEGIN
    DECLARE vChecker BOOLEAN DEFAULT FALSE;

    SELECT disciplines.isLocked INTO vChecker
        FROM `disciplines`
        WHERE disciplines.ID = pDisciplineID
        LIMIT 1;

    RETURN vChecker;
END //


# check, that student really take this course
DROP FUNCTION IF EXISTS InternalIsStudentAttached//
CREATE FUNCTION `InternalIsStudentAttached` (
        `pStudentID` INT,
        `pDisciplineID` INT,
        `pSemesterID` INT
    ) RETURNS BOOLEAN
    NO SQL
BEGIN
    DECLARE vAttachType INT DEFAULT -1;

    SELECT view_disciplines_students.AttachType INTO vAttachType
        FROM `view_disciplines_students`
        WHERE view_disciplines_students.SemesterID = pSemesterID AND
              view_disciplines_students.StudentID = pStudentID AND
              view_disciplines_students.DisciplineID = pDisciplineID
        LIMIT 1;

    RETURN ( vAttachType != 2 ); # NULL or vAttachType != detach
END //


# check, that teacher teach this course
drop function if exists InternalIsTeacherBounded//
CREATE FUNCTION `InternalIsTeacherBounded` (
        `pTeacherID` INT,
        `pDisciplineID` INT
    ) RETURNS BOOLEAN
    NO SQL
BEGIN
    RETURN EXISTS (
        SELECT * FROM `disciplines_teachers`
            WHERE   disciplines_teachers.TeacherID = pTeacherID AND
                    disciplines_teachers.DisciplineID = pDisciplineID
            LIMIT 1
    );
END //


DROP FUNCTION IF EXISTS InternalIsTeacherAuthor//
CREATE FUNCTION `InternalIsTeacherAuthor` (
        `pTeacherID` INT,
        `pDisciplineID` INT
    ) RETURNS BOOLEAN
    NO SQL
BEGIN
    DECLARE vAuthorID INT DEFAULT -1;

    SELECT disciplines.AuthorID INTO vAuthorID
        FROM `disciplines`
        WHERE disciplines.ID = pDisciplineID
        LIMIT 1;

    RETURN ( vAuthorID = pTeacherID );
END //


DROP FUNCTION IF EXISTS GetRateForDisc//
CREATE FUNCTION `GetRateForDisc` (
        `pStudentID` INT,
        `pDisciplineID` INT
    ) RETURNS int(11)
    NO SQL
BEGIN
    DECLARE vRate, vExamRate INT DEFAULT 0;

    # TODO: into temp table

    # get last exam rate
    SELECT submodules.ID INTO vExamRate
        FROM view_roadmap
        INNER JOIN `rating_table` ON rating_table.SubmoduleID = view_roadmap.SubmoduleID AND
                                     rating_table.StudentID = pStudentID
        WHERE   view_roadmap.DisciplineID = pDisciplineID AND
                view_roadmap.ModuleType = 'exam'
        ORDER BY submodules.OrderNum DESC
        LIMIT 1;

    # regular + extra + bonus rate
    SELECT SUM(rating_table.Rate) INTO vRate
        FROM view_roadmap
        INNER JOIN `rating_table` ON rating_table.SubmoduleID = view_roadmap.SubmoduleID AND
                                     rating_table.StudentID = pStudentID
        WHERE   view_roadmap.DisciplineID = pDisciplineID AND
                view_roadmap.ModuleType != 'exam';

    RETURN vRate + vExamRate;
END //


DROP FUNCTION IF EXISTS SetExamPeriodOption//
CREATE FUNCTION `SetExamPeriodOption` (
        `pStudentID` INT,
        `pSubmoduleID` INT,
        `pType` VARCHAR(30) CHARSET utf8 # enum('absence','pass')
    ) RETURNS int(11)
    NO SQL
BEGIN
    DECLARE EXIT HANDLER FOR SQLEXCEPTION RETURN -1;

    INSERT INTO `exam_period_options`
        (StudentID, SubmoduleID, Type) VALUES(pStudentID, pSubmoduleID, pType)
        ON DUPLICATE KEY UPDATE
        exam_period_options.Type = pType;

    RETURN  0;
END //


# check, if any module is created
DROP FUNCTION IF EXISTS InternalIsMapCreated//
CREATE FUNCTION `InternalIsMapCreated` (
        `pDisciplineID` INT
    ) RETURNS int(11)
    NO SQL
BEGIN
    DECLARE vMaxRate INT DEFAULT -1;

    SELECT view_disciplines_results.DisciplineRateMax INTO vMaxRate
        FROM `view_disciplines_results`
        WHERE view_disciplines_results.DisciplineID = pDisciplineID
        LIMIT 1;

    RETURN ( vMaxRate = 100 );
END //

# ordering helper
DROP FUNCTION IF EXISTS InternalOrderModuleTypesForSession//
CREATE FUNCTION `InternalOrderModuleTypesForSession` (
        `pModuleType` INT
    ) RETURNS INT(3)
    NO SQL
BEGIN
    DECLARE vRes INT DEFAULT 0;

    CASE pModuleType
        WHEN 4 THEN SET vRes = 1; # extra
        WHEN 2 THEN SET vRes = 2; # exam
        WHEN 3 THEN SET vRes = 3; # bonus
        ELSE SET vRes = 4;
    END CASE;

    RETURN vRes;
END //




# -------------------------------------------------------------------------------------------
# Label: preferences
# Label: magic
# -------------------------------------------------------------------------------------------

# set values of record with key \pKey,
# if doesn't exist, then create.
DROP FUNCTION IF EXISTS SetSettings//
CREATE FUNCTION `SetSettings` (
        `pKey` VARCHAR(50) CHARSET utf8,
        `pVal` INT,
        `pValS` VARCHAR(300) CHARSET utf8
    ) RETURNS int(11)
    NO SQL
BEGIN
    INSERT INTO `general_settings`
        (Val, ValS, Name) VALUES(pVal, pValS, pKey)
        ON DUPLICATE KEY UPDATE
            general_settings.Val = pVal,
            general_settings.ValS = pValS;
    RETURN 0;
END//



DROP FUNCTION IF EXISTS SetBitmaskByPagename//
CREATE FUNCTION `SetBitmaskByPagename` (
        `pPagename` TEXT CHARSET utf8,
        `pMask` INT
    ) RETURNS int(11)
    NO SQL
BEGIN
    INSERT INTO `page_access`
        (Pagename, Bitmask) VALUES(pPagename, pMask)
        ON DUPLICATE KEY UPDATE
            page_access.Bitmask = pMask;
    RETURN 0;
END //



DROP FUNCTION IF EXISTS GetBitmaskByPagename//
CREATE FUNCTION `GetBitmaskByPagename` (
        `pPagename` TEXT CHARSET utf8
    ) RETURNS int(11)
    NO SQL
BEGIN
    DECLARE vBitmask INT DEFAULT 0;

    SELECT page_access.Bitmask INTO vBitmask
        FROM `page_access`
        WHERE page_access.Pagename = pPagename
        LIMIT 1;

    RETURN vBitmask;
END //




# -------------------------------------------------------------------------------------------
# Label: semesters
# -------------------------------------------------------------------------------------------

# set current(for user) semester, life time - db session
DROP FUNCTION IF EXISTS SetSemesterID//
CREATE FUNCTION `SetSemesterID` (`pSemesterID` INT) RETURNS int(11)
    NO SQL
BEGIN
    SET @CurrentSemesterID := pSemesterID;
    RETURN 0;
END //



# -------------------------------------------------------------------------------------------
# Label: faculties
# -------------------------------------------------------------------------------------------

DROP FUNCTION IF EXISTS CreateFaculty //
CREATE FUNCTION CreateFaculty (
        `pFacultyName` VARCHAR(100) CHARSET utf8,
        `pFacultyAbbr` VARCHAR(20) CHARSET utf8
    ) RETURNS INT(11)
    NO SQL
BEGIN
    DECLARE EXIT HANDLER FOR SQLEXCEPTION RETURN -1;

    INSERT INTO faculties
        (Name, Abbr) VALUES(pFacultyName, pFacultyAbbr);
    RETURN 0;
END //

# -------------------------------------------------------------------------------------------
# Label: departments
# -------------------------------------------------------------------------------------------

DROP FUNCTION IF EXISTS CreateDepartment //
CREATE FUNCTION CreateDepartment (
        `pName` VARCHAR(200) CHARSET utf8,
        `pFacultyID` INT(11)
    ) RETURNS INT(11) # department id or -1 if failed
    NO SQL
BEGIN
    DECLARE EXIT HANDLER FOR SQLEXCEPTION RETURN -1;

    INSERT INTO departments
        (Name, FacultyID) VALUES(pName, pFacultyID);

    IF ROW_COUNT() = 0 THEN
        RETURN -1;
    ELSE
        RETURN LAST_INSERT_ID();
    END IF;
END //

# -------------------------------------------------------------------------------------------
# Label: study groups
# -------------------------------------------------------------------------------------------

# negative int, if already exists
DROP FUNCTION IF EXISTS CreateGroup//
CREATE FUNCTION `CreateGroup` (
        `pGradeID` INT,
        `pGroupNum` INT,
        `pSpecializationID` INT,
        `pGroupName` VARCHAR(50) CHARSET utf8
    ) RETURNS int(11)
    NO SQL
BEGIN
    # check GradeID, SpecID constraints and (GradeID, GroupNum, SpecID) - unique
    DECLARE EXIT HANDLER FOR SQLEXCEPTION RETURN -1;

    # create discipline
    INSERT INTO `study_groups`
        (GradeID, GroupNum, SpecializationID, Name)
        VALUES (pGradeID, pGroupNum, pSpecializationID, pGroupName);
    RETURN 0;
END //


DROP FUNCTION IF EXISTS GetGroup//
CREATE FUNCTION `GetGroup` (
        `pGradeID` INT,
        `pGroupNum` INT,
        `pFacultyID` INT
    ) RETURNS int(11) # groupID or -1 if failed
    NO SQL
BEGIN
    DECLARE vGroupID INT DEFAULT -1;

    SELECT study_groups.ID INTO vGroupID
        FROM study_groups
        INNER JOIN `specializations` ON specializations.ID = study_groups.SpecializationID
        WHERE   study_groups.GradeID = pGradeID AND
                study_groups.GroupNum = pGroupNum AND
                specializations.FacultyID = pFacultyID
        LIMIT 1;

    RETURN vGroupID;
END //


# -------------------------------------------------------------------------------------------
# Label: subjects
# -------------------------------------------------------------------------------------------

DROP FUNCTION IF EXISTS CreateSubject//
CREATE FUNCTION `CreateSubject` (
        `pFacultyID` INT,
        `pSubjectName` VARCHAR(200) CHARSET utf8,
        `pSubjectAbbr` VARCHAR(20) CHARSET utf8
    )   RETURNS int(11)
    NO SQL
BEGIN
    DECLARE vSubjectID INT DEFAULT -1;

    # create/get subject (subject name is unique key)
    INSERT INTO `subjects`
        (Name, Abbr) VALUES(pSubjectName, pSubjectAbbr)
        ON DUPLICATE KEY UPDATE
            subjects.ID = LAST_INSERT_ID(subjects.ID);
    SET vSubjectID = LAST_INSERT_ID();

    BEGIN # handler block
        DECLARE EXIT HANDLER FOR SQLEXCEPTION RETURN -1;

        # try to attach subject to faculty
        INSERT INTO `subjects_faculties`
            (SubjectID, FacultyID)
            VALUES (vSubjectID, pFacultyID)
            ON DUPLICATE KEY UPDATE # just stub
                subjects_faculties.ID = LAST_INSERT_ID(subjects_faculties.ID);
    END;

    RETURN 0;
END //


DROP FUNCTION IF EXISTS DeleteSubject //
CREATE FUNCTION DeleteSubject (
        `pSubjectID` INT
    ) RETURNS TEXT
    NO SQL
BEGIN
    DECLARE vChecker INT DEFAULT -1;
    DECLARE EXIT HANDLER FOR SQLEXCEPTION RETURN -1;

    SELECT disciplines.ID INTO vChecker
        FROM `disciplines`
        WHERE disciplines.SubjectID = pSubjectID
        LIMIT 1;
    IF vChecker > 0 THEN
        RETURN -1; # Удаляемый предмет используется в disciplines.
    END IF;

    DELETE FROM `subjects_faculties`
        WHERE subjects_faculties.SubjectID = pSubjectID;
    DELETE FROM `subjects`
        WHERE subjects.ID = pSubjectID
        LIMIT 1;

    RETURN 0; # Успешно удалено;
END //


# -------------------------------------------------------------------------------------------
# Label: accounts
# -------------------------------------------------------------------------------------------




DROP FUNCTION IF EXISTS CheckAccountExistence//
CREATE FUNCTION `CheckAccountExistence` (
        `pData` TEXT CHARSET utf8,
        `pType` enum('login','email', 'code')
    ) RETURNS int(11)
    NO SQL
BEGIN
    DECLARE vRes BOOLEAN DEFAULT FALSE;

    SET vRes = EXISTS(
        SELECT * FROM `accounts`
            WHERE CASE pType
                WHEN 'login' THEN pData = accounts.Login
                WHEN 'email' THEN pData = accounts.EMail
                WHEN 'code' THEN pData = accounts.ActivationCode
                ELSE FALSE
            END
        LIMIT 1
    );

    RETURN vRes;
END //


DROP FUNCTION IF EXISTS ActivateAccount//
CREATE FUNCTION `ActivateAccount` (
        `pCode` VARCHAR(40) CHARSET utf8,
        `pLogin` VARCHAR(50) CHARSET utf8,
        `pEMail` VARCHAR(50) CHARSET utf8,
        `pPassword` VARCHAR(255) CHARSET utf8
    ) RETURNS int(11)
    NO SQL
BEGIN
    # check for matching with existing accounts (note: Login & E-Mail are unique)
    DECLARE EXIT HANDLER FOR SQLEXCEPTION RETURN -1;

    # activate account
    UPDATE `accounts`
        SET accounts.Login = pLogin,
            accounts.Password = pPassword,
            accounts.EMail = pEMail,
            accounts.ActivationCode = NULL
        WHERE accounts.ActivationCode = pCode AND
              ( @vAccountID := accounts.ID ) # save accountID
        LIMIT 1;

    IF ( ROW_COUNT() = 0 ) THEN
        RETURN -2; # account with this Code not found
    END IF;
    RETURN @vAccountID;
END //


DROP FUNCTION IF EXISTS ChangeAccountData//
CREATE FUNCTION `ChangeAccountData` (
        `pUserID` INT,
        `pData` TEXT CHARSET utf8,
        `pType` enum('login', 'email', 'password')
    ) RETURNS int(11) # 0 - success
    NO SQL
BEGIN
    DECLARE EXIT HANDLER FOR SQLEXCEPTION RETURN -1;

    CASE pType
        WHEN 'login' THEN
            UPDATE `accounts`
                SET accounts.Login = pData
                WHERE accounts.ID = pUserID
                LIMIT 1;
        WHEN 'email' THEN
            UPDATE `accounts`
                SET accounts.EMail = pData
                WHERE accounts.ID = pUserID
                LIMIT 1;
        WHEN 'password' THEN
            UPDATE `accounts`
                SET accounts.Password = pData
                WHERE accounts.ID = pUserID
                LIMIT 1;
    END CASE;

    RETURN ROW_COUNT()-1;
END //



DROP FUNCTION IF EXISTS SignIn//
CREATE FUNCTION `SignIn` (
        `pLoginOrMail` VARCHAR(255) CHARSET utf8,
        `pPassword`  VARCHAR(64) CHARSET utf8
    ) RETURNS int(11) # account id
    NO SQL
BEGIN
    DECLARE vAccountID INT DEFAULT -1;

    #check account existence
    SELECT accounts.ID INTO vAccountID
        FROM `accounts`
        WHERE   accounts.Password = pPassword AND
                (accounts.Login = pLoginOrMail OR accounts.EMail = pLoginOrMail)
        LIMIT 1;
    IF vAccountID <= 0 THEN
        RETURN -1;
    END IF;

    # TODO: extract method - log sign in
    INSERT INTO `logs_signin` # logging
        (AccountID) VALUES (vAccountID);
    RETURN vAccountID;
END //




# -------------------------------------------------------------------------------------------
# Label: teachers
# -------------------------------------------------------------------------------------------

DROP FUNCTION IF EXISTS ChangeTeacherInfo//
CREATE FUNCTION `ChangeTeacherInfo` (
        `pTeacherID` INT,
        `pLastName` VARCHAR(30) CHARSET utf8,
        `pFirstName` VARCHAR(30) CHARSET utf8,
        `pSecondName` VARCHAR(30) CHARSET utf8,
        `pJobPositionID` INT,
        `pDepartmentID` INT
    ) RETURNS int(11) # -1 if teacher doesn't exists, otherwise 0
    NO SQL
BEGIN
    DECLARE EXIT HANDLER FOR SQLEXCEPTION RETURN -1;

    # set new info
    UPDATE `teachers`
        SET teachers.LastName = pLastName,
            teachers.FirstName = pFirstName,
            teachers.SecondName = pSecondName,
            teachers.JobPositionID = pJobPositionID,
            teachers.DepartmentID = pDepartmentID
        WHERE teachers.ID = pTeacherID
        LIMIT 1;
    RETURN ROW_COUNT()-1;
END //



DROP FUNCTION IF EXISTS CreateTeacher//
CREATE FUNCTION `CreateTeacher` (
        `pLastName` VARCHAR(30) CHARSET utf8,
        `pFirstName` VARCHAR(30) CHARSET utf8,
        `pSecondName` VARCHAR(30) CHARSET utf8,
        `pJobPositionID` INT,
        `pDepartmentID`  INT,
        `pActivationCode` VARCHAR(40) CHARSET utf8
    ) RETURNS int(11)
    NO SQL
BEGIN
    DECLARE vAccountID INT DEFAULT -1;
    DECLARE EXIT HANDLER FOR SQLEXCEPTION RETURN -1;

    # TODO: kill magic constants
    # user role 2 - common teacher
    # create account
    INSERT INTO `accounts`
        (Login , Password , EMail, UserRoleID, ActivationCode )
        VALUES  ( NULL, NULL, NULL, 2, pActivationCode);
    SET vAccountID = LAST_INSERT_ID();

    # add new teacher
    INSERT INTO `teachers`
        (AccountID, LastName, FirstName, SecondName, JobPositionID, DepartmentID)
        VALUES  (vAccountID, pLastName, pFirstName, pSecondName, pJobPositionID, pDepartmentID);
    RETURN ROW_COUNT()-1;
END //


DROP FUNCTION IF EXISTS CreateTeacherByDepName//
CREATE FUNCTION `CreateTeacherByDepName` (
        `pLastName` VARCHAR(30) CHARSET utf8,
        `pFirstName` VARCHAR(30) CHARSET utf8,
        `pSecondName` VARCHAR(30) CHARSET utf8,
        `pDepartmentName` VARCHAR(200) CHARSET utf8,
        `pFacultyID` INT,
        `pActivationCode` VARCHAR(40) CHARSET utf8
    )   RETURNS int(11) # 0 - success, < 0 - failed
    NO SQL
BEGIN
    DECLARE vAccountID, vRoleID, vDepID INT DEFAULT -1;
    DECLARE EXIT HANDLER FOR SQLEXCEPTION RETURN -1;

    # try to find a department with same name \pDepartmentName
    SELECT departments.ID INTO vDepID
        FROM `departments`
        WHERE departments.Name = pDepartmentName AND
              departments.FacultyID = pFacultyID
        LIMIT 1;

    IF vDepID <= 0 THEN
        # pDepartmentName is not empty now
        SET vDepID = CreateDepartment(pDepartmentName, pFacultyID);
        IF vDepID < 0 THEN
           RETURN -1;
        END IF;
    END IF;

    RETURN CreateTeacher(pLastName, pFirstName, pSecondName, 12, vDepID, pActivationCode);
END //


-- -1 - не сотрудник деканата и не преподаватель дисциплины
-- 0 - только чтение
-- 1 - редактирование
DROP FUNCTION IF EXISTS GetEditRightsForTeacher//
CREATE FUNCTION `GetEditRightsForTeacher` (
        `pTeacherID` INT,
        `pDisciplineID` INT
    ) RETURNS int(11)
    NO SQL
BEGIN
    DECLARE vUserRole, vDiscTeacherID INT DEFAULT -1;
              
    SELECT disciplines_teachers.ID INTO vDiscTeacherID
        FROM `disciplines_teachers`
        WHERE disciplines_teachers.DisciplineID = pDisciplineID AND
              disciplines_teachers.TeacherID = pTeacherID
        LIMIT 1;

    IF vDiscTeacherID > 0 THEN
        RETURN 1;
    END IF;

    SELECT accounts.UserRoleID INTO vUserRole
        FROM `teachers`
        INNER JOIN `accounts` ON teachers.AccountID=accounts.ID
        WHERE teachers.ID = pTeacherID;
    IF vUserRole = 4 THEN # 4 - сотрудник деканата
        RETURN 0;
    END IF;

    RETURN -1;
END //



# -------------------------------------------------------------------------------------------
# Label: students
# -------------------------------------------------------------------------------------------

# TODO: magic constants (UserRoleID)
# TODO: transaction
DROP FUNCTION IF EXISTS CreateStudent//
CREATE FUNCTION `CreateStudent` (
        `pLastName` VARCHAR(30) CHARSET utf8,
        `pFirstName` VARCHAR(30) CHARSET utf8,
        `pSecondName` VARCHAR(30) CHARSET utf8,
        `pGradeID` INT,
        `pGroupNum` INT,
        `pFacultyID` INT,
        `pActivationCode` VARCHAR(40) CHARSET utf8
    )   RETURNS int(11)
    NO SQL
BEGIN
    DECLARE vAccountID, vGroupID, vStudentID, vSemesterID INT DEFAULT -1;
    DECLARE EXIT HANDLER FOR SQLEXCEPTION RETURN -1;

    SET vGroupID = GetGroup(pGradeID, pGroupNum, pFacultyID);
    IF vGroupID <= 0 THEN
        RETURN -1;
    END IF;

    # create new account
    # UserRoleID 1 = student
    INSERT INTO `accounts`
        (Login , Password , EMail, UserRoleID, ActivationCode )
        VALUES ( NULL, NULL, NULL, 1, pActivationCode);
    SET vAccountID = LAST_INSERT_ID();

    # create student
    INSERT INTO `students`
        (AccountID, LastName, FirstName, SecondName)
        VALUES  (vAccountID, pLastName, pFirstName, pSecondName);
    SET vStudentID = LAST_INSERT_ID();

#     SELECT general_settings.Val INTO vSemesterID
#         FROM `general_settings`
#         WHERE general_settings.Name = 'SemesterID'
#         LIMIT 1;

    # TODO: add param semester id\ instead @currentSemesterID
    RETURN ControlStudentGroup(vStudentID, vGroupID, FALSE);

    # bind group in current semester
    INSERT INTO `students_groups`
        (StudentID, GroupID, SemesterID)
        VALUES (vStudentID, vGroupID, vSemesterID);

    RETURN 0;
END //


# unlike fn CreateStudent, this can create all missing records (group, grade, specialization)
DROP FUNCTION IF EXISTS CreateStudentEx//
CREATE FUNCTION `CreateStudentEx` (
        `pLastName` VARCHAR(30) CHARSET utf8,
        `pFirstName` VARCHAR(30) CHARSET utf8,
        `pSecondName` VARCHAR(30) CHARSET utf8,
        `pGradeNum` INT,
        `pGroupNum` INT,
        `pDegree` VARCHAR(20) CHARSET utf8,
        `pSpecName` VARCHAR(50) CHARSET utf8,
        `pFacultyID` INT,
        `pActivationCode` VARCHAR(40) CHARSET utf8
    )   RETURNS int(11)
    NO SQL
BEGIN
    DECLARE vAccountID, vGradeID, vSpecID, vGroupID INT DEFAULT -1;
    DECLARE EXIT HANDLER FOR SQLEXCEPTION RETURN -1;


    # TODO: extract CreateGroup, CreateGrade, ...

    # try to find grade
    SELECT grades.ID INTO vGradeID
        FROM `grades`
        WHERE grades.Num = pGradeNum AND grades.Degree = pDegree
        LIMIT 1;
    # such grade doesn't exist
    IF vGradeID <= 0 THEN
        # insert new grade with pGradeNum and pDegree
        INSERT INTO `grades`
            (Num, Degree) VALUES (pGradeNum, pDegree);
        SET vGradeID = LAST_INSERT_ID();
    END IF;

    # try to find group
    SELECT view_groups.GroupID INTO vGroupID
        FROM `view_groups`
        WHERE view_groups.FacultyID = pFacultyID AND
            view_groups.GroupNum = pGroupNum AND
            view_groups.GradeID = vGradeID
        LIMIT 1;

    # group not found
    IF vGroupID <= 0 THEN
        # try to find specialization
        SELECT specializations.ID INTO vSpecID
            FROM `specializations`
            WHERE   (specializations.Name = pSpecName OR
                        (pSpecName = '' AND specializations.Name IS NULL)) AND
                    specializations.FacultyID = pFacultyID
            LIMIT 1;

        # specialization not found
        IF vSpecID <= 0 THEN
            # create new specialization
            INSERT INTO `specializations`
                (Name, Abbr, FacultyID)
                VALUES  (pSpecName, NULL, pFacultyID);
            SET vSpecID = LAST_INSERT_ID();
        END IF;

        # create new group
        INSERT INTO `study_groups`
            (GradeID, GroupNum, SpecializationID)
            VALUES (vGradeID, pGroupNum, vSpecID);
        SET vGroupID = LAST_INSERT_ID();
    END IF;

    RETURN CreateStudent(pLastName, pFirstName, pSecondName, vGradeID, pGroupNum, pFacultyID, pActivationCode);
END //



# Give a student an academic leave or attach him to group.
#   params:
#      StudentID (int)
#      GroupID (int)   : is used, if OnLeave == false
#      OnLeave (bool)  : true - into study leave, false - attach to group
DROP FUNCTION IF EXISTS ControlStudentGroup//
CREATE FUNCTION `ControlStudentGroup` (
        `pStudentID` INT,
        `pGroupID` INT,
        `pState` BOOLEAN
    ) RETURNS int(11)
    NO SQL
BEGIN
    DECLARE vChecker INT DEFAULT 0;
    DECLARE EXIT HANDLER FOR SQLEXCEPTION RETURN -1;

    # TODO: add semester id param
    # out to study leave
    IF pState THEN
        UPDATE `students_groups`
            SET students_groups.IsStudyLeave = TRUE,
                students_groups.Date = CURDATE()
            WHERE students_groups.StudentID = pStudentID AND
                  students_groups.SemesterID = @CurrentSemesterID
            LIMIT 1;
    # attach to new group
    ELSE
        INSERT INTO `students_groups`
            (StudentID, GroupID, SemesterID)
            VALUES(pStudentID, pGroupID, @CurrentSemesterID);
    END IF;
    RETURN ROW_COUNT()-1;
END //


# -------------------------------------------------------------------------------------------
# Label: disciplines
# -------------------------------------------------------------------------------------------



DROP FUNCTION IF EXISTS AddDiscipline//
DROP FUNCTION IF EXISTS Discipline_Create//
CREATE FUNCTION `Discipline_Create` (
    `pTeacherID` INT,
    `pGradeID` INT,
    `pSubjectID` INT,
    `pExamType` VARCHAR(30) CHARSET utf8,
    `pLectureCount` INT,
    `pPracticeCount` INT,
    `pLabCount` INT,
    `pFacultyID` INT,
    `pSemesterID` INT,
    `pSubtype` VARCHAR(30) CHARSET utf8 # scientific_coursework discipline_coursework
) RETURNS int(11)
    NO SQL
BEGIN
    DECLARE vChecker, vDisciplineID INT DEFAULT -1;
    DECLARE EXIT HANDLER FOR SQLEXCEPTION RETURN -1;

    # create discipline
    INSERT INTO `disciplines`
        (AuthorID, GradeID, SubjectID, ExamType,
        LectureCount, PracticeCount,LabCount,
        SemesterID, FacultyID, Subtype)
        VALUES (
            pTeacherID, pGradeID, pSubjectID, pExamType,
            pLectureCount, pPracticeCount, pLabCount,
            pSemesterID, pFacultyID, pSubtype
        );
    SET vDisciplineID = LAST_INSERT_ID();


    SET vChecker = BindTeacher(pTeacherID, pTeacherID, vDisciplineID);

    # add exam and extra modules
    IF pExamType = 'exam' THEN
        SET vChecker = AddModuleExam(pTeacherID, vDisciplineID);
    END IF;
    SET vChecker = AddModuleExtra(pTeacherID, vDisciplineID);

    RETURN vDisciplineID;
END //



DROP FUNCTION IF EXISTS ChangeDisciplineSubject//
CREATE FUNCTION `ChangeDisciplineSubject` (
        `pTeacherID` INT,
        `pDisciplineID` INT,
        `pSubjectID` INT
    ) RETURNS int(11)
    NO SQL
BEGIN
    DECLARE EXIT HANDLER FOR SQLEXCEPTION RETURN -1;

    IF  NOT InternalIsTeacherAuthor(pTeacherID, pDisciplineID) OR
        InternalIsMapLocked(pDisciplineID)
    THEN
        RETURN -1;
    END IF;

    UPDATE `disciplines`
        SET disciplines.SubjectID = pSubjectID
        WHERE disciplines.ID = pDisciplineID
        LIMIT 1;
    RETURN ROW_COUNT()-1;
END //



DROP FUNCTION IF EXISTS GetMilestone//
CREATE FUNCTION `GetMilestone` (
        `pFacultyID` INT,
        `pSemesterID` INT
    ) RETURNS int(11)
    NO SQL
BEGIN
    DECLARE vMilestone, vCounter INT DEFAULT 0;

    # get most frequent milestone
    SELECT COUNT(*) AS 'cnt', disciplines.Milestone
        INTO vCounter, vMilestone
        FROM `disciplines`
        WHERE disciplines.SemesterID = pSemesterID AND
              disciplines.FacultyID = pFacultyID
        GROUP BY disciplines.Milestone
        ORDER BY cnt DESC
        LIMIT 1;

    RETURN vMilestone;
END //



DROP FUNCTION IF EXISTS ChangeDisciplineGrade//
CREATE FUNCTION `ChangeDisciplineGrade` (
        `pTeacherID` INT,
        `pDisciplineID` INT,
        `pGradeID` INT
    ) RETURNS int(11)
    NO SQL
BEGIN
    DECLARE vCurGradeID INT DEFAULT -1;
    DECLARE EXIT HANDLER FOR SQLEXCEPTION RETURN -1;

    IF  InternalIsMapLocked(pDisciplineID) OR
        NOT InternalIsTeacherAuthor(pTeacherID, pDisciplineID)
    THEN
        RETURN -1;
    END IF;

    # get current grade
    SELECT disciplines.GradeID INTO vCurGradeID
        FROM `disciplines`
        WHERE disciplines.ID = pDisciplineID
        LIMIT 1;
    IF vCurGradeID = pGradeID THEN
        RETURN 0;
    END IF;

    # delete all students
    DELETE FROM `disciplines_groups`
        WHERE disciplines_groups.DisciplineID = pDisciplineID;
    DELETE FROM `disciplines_students`
        WHERE disciplines_students.DisciplineID = pDisciplineID;

    # set grade
    UPDATE `disciplines`
        SET disciplines.GradeID = pGradeID
        WHERE disciplines.ID = pDisciplineID
        LIMIT 1;
    RETURN ROW_COUNT()-1;
END //


DROP FUNCTION IF EXISTS ChangeDisciplineControl//
CREATE FUNCTION `ChangeDisciplineControl` (
        `pTeacherID` INT,
        `pDisciplineID` INT,
        `pExamType` VARCHAR(30) CHARSET utf8
    )   RETURNS int(11)
    NO SQL
BEGIN
    DECLARE vOldExamType, vChecker, vExtraMax, vExtraID INT DEFAULT -1;
    DECLARE EXIT HANDLER FOR SQLEXCEPTION RETURN -1;