classes.py

import sqlite3, re

con = sqlite3.connect("databases.db")
editor = con.cursor()



class Stack(object):
    def __init__(self,items):
        self.__items = items
        self.__top = len(items) -1

    def push(self,item):
        self.__top += 1
        self.__items.append(item)

    def isEmpty(self):
        return self.__top == -1
  
    def pop(self):
        if not self.isEmpty():
            item = self.__items[self.__top]
            self.__items = self.__items[:self.__top]
            self.__top -= 1
            return item
        else:
            return -1



class Queue(object):
    def __init__(self,items):
        self.__items = items
        self.__len = len(items)

    def isEmpty(self):
        return self.__len == 0

    def deQueue(self):
        if not self.isEmpty():
            item = self.__items[0]
            del(self.__items[0])
            self.__len -= 1
            return item
        else:
            return -1

    def enQueue(self,item):
        self.__items.append(item)    
        self.__len += 1



class Staff(object):
    def __init__(self, id:int, fName:str, sName:str, level:dict, email:str, hours:list, attendance:dict):
        self.__staffID = id
        self.__firstName = fName
        self.__surname = sName
        self.__level = level
        self.__email = email
        self._hoursWorked = hours
        self.__attendance = attendance
        self._type = ""

    def getName(self):
        return self.__staffID, self.__firstName, self.__surname
    
    def getEmail(self):
        return self.__staffID, self.__email
    
    def getLevel(self):
        return self.__staffID, self.__level
    
    def getHours(self):
        return self.__staffID, self._hoursWorked
    
    def getAttendance(self):
        return self.__staffID, self.__attendance
    
    def getType(self):
        return self.__staffID, self._type

    
    def linkToJob(self):
        return self.__staffID, self.__firstName, self.__level
    
    def changeSurname(self, surname):
        if len(surname) > 0:
            self.__surname = surname
            return 1
        else:
            return 0

    def changeLevel(self,levelType,newLevel):
        valid = False
        try:
            if newLevel >= 0 and newLevel <= 3 and int(newLevel) == newLevel:
                valid = True

        except Exception:
            return 0
        keys = self.__level.keys()
        if levelType in keys and valid:
            self.__level[levelType] = newLevel
            return 1
        else:
            return 0

    def changeEmail(self,newEmail):
        if len(newEmail) > 0:
            self.__newEmail = newEmail
            return 1
        else:
            return 0

    def changeAttendance(self,day,newAttendance):
        if newAttendance == True or newAttendance == False:
            keys = self.__attendance.keys()
            if day in keys:
                self.__attendance = newAttendance
                return 1
            else:
                return 0
        else:
            return 0
        
    def changeHours(self, dayInt, newStartTime, newEndTime):
        valid = []
        if not str(dayInt).isdigit():
            return 0
        if (newStartTime != "" or newEndTime != ""):
            valid = re.findall("[0-1][0-9]:[0-5][0-9]:[0-5][0-9]",newStartTime+","+newEndTime)
            print(valid)
            if newEndTime == "" or newStartTime == "":
                valid.append("")
        if  len(valid) == 2:
            if dayInt < 0 or dayInt > 4 or (int(dayInt) != dayInt):
                return 0
            elif newStartTime == "":
                self._hoursWorked[dayInt*2] = self._hoursWorked[dayInt][0]
                self._hoursWorked[dayInt*2 + 1] = newEndTime
                return 1
            elif newEndTime == "":
                self._hoursWorked[dayInt*2] = newStartTime
                self._hoursWorked[dayInt*2 + 1] = self._hoursWorked[dayInt][1]
                return 1
            else:
                self._hoursWorked[dayInt*2] = newStartTime
                self._hoursWorked[dayInt*2+1] = newEndTime
        else:
            return 0
        

    def displayDetails(self):
        print(f"""
ID: {self.__staffID}
First Name: {self.__firstName}
Surname: {self.__surname}
Email: {self.__email}
Levels: {self.__level}
Hours: {self._hoursWorked}
Attendance: {self.__attendance}
Contract type: {self._type}""")
        if self._type == "Split":
            print(f"Split hours start times: {self._splitHoursStart}")
            print(f"Split hours end times: {self._splitHoursEnd}")
        elif self._type == "Zero":
            print(f"Zero hours start times: {self._startTime}")
            print(f"Zero hours end time: {self._endTime}")
        print()
    

    
class FullHours(Staff):
    def __init__(self, id, fName, sName, level, email, hours, attendance):
        super().__init__(id, fName, sName, level, email, hours, attendance)
        self._type = "Full"

        

class SplitHours(Staff):
    def __init__(self, id, fName, sName, level, email, hours, attendance, splitStart:dict, splitEnd:dict):
        super().__init__(id, fName, sName, level, email, hours, attendance)
        self._splitHoursStart = splitStart
        self._splitHoursEnd = splitEnd
        self._type = "Split"

    def moveSplitHour(self, dayInt, newStart, newEnd):
        try:
            dayInt = int(dayInt)
            valid = re.findall("[0-1][0-9]:[0-5][0-9]:[0-5][0-9]",newStart+","+newEnd)
        except Exception:
            return 0
        else:
            if len(valid) == 2 and dayInt >= 0 and dayInt <= 4:
                self._splitHoursStart[dayInt] = newStart
                self._splitHoursEnd[dayInt] = newEnd
                return 1
            else:
                return 0

        

class ZeroHours(Staff):
    def __init__(self, id, fName, sName, level, email, hours, attendance, startTime:list, endTime:list):
        super().__init__(id, fName, sName, level, email, hours, attendance)
        self._startTime = startTime
        self._endTime = endTime
        self._type = "Zero"

    def changeZeroHoursTimes(self, dayInt, newStart, newEnd):
        try:
            dayInt = int(dayInt)
            valid = re.findall("[0-1][0-9]:[0-5][0-9]:[0-5][0-9]",newStart+","+newEnd)
        except Exception:
            return 0
        else:
            if len(valid) == 2 and dayInt >= 0 and dayInt <= 4:
                self._startTime[dayInt] = newStart
                self._endTime[dayInt] = newEnd
                return 1
            else:
                return 0



class Job(object):
    def __init__(self,code:int,desc:str,priority:int,levelNum:int,levelNeedeed:int,hourType:int,daysNeeded:str,recordName:str):
        self._jobCode = code        
        self._hourType = hourType
        self.__description = desc
        self.__priority = priority
        self.__levelNum = levelNum
        self.__levelNeeded = levelNeedeed
        self.__days = daysNeeded
        self.__recordName = recordName

    def getLevelNum(self):
        return self._jobCode, self.__levelNum, self.__levelNeeded
    
    def getPriority(self):
        return self._jobCode, self.__priority

    def getDescription(self):
        return self._jobCode, self.__description

    def getDays(self):
        return self._jobCode, self.__days
    
    def getRecord(self):
        return self.__recordName

    def changePriority(self, newPriority):
        try:
            int(newPriority)
        except ValueError:
            return 0
        else:
            if newPriority == int(newPriority):
                self.__priority = newPriority
                return 1
            else:
                return 0


    def changeHourType(self,newType):
        if type(newType) == int:
            if newType >= 0 and newType <= 3:
                self._hourType = newType
                return 1
            else:
                return 0
        else:
            return 0 

    def changeDays(self,newDays):
        # Constant list of the codes used for the days for each job
        DAYLIST = ["ALL", "ANY", "SOME", "TDB", "MO", "TU", "WE", "TH", "FR"]
        if newDays in DAYLIST:
            self.__days = newDays
            return 1
        else:
            return 0


class DailyJob(Job):
    def __init__(self,dayHours:int,code,desc,priority,levelNum,levelNeeded,hourType,daysNeeded,recordName):
        self.__hoursPerDay = dayHours
        super().__init__(code,desc,priority,levelNum,levelNeeded,hourType,daysNeeded,recordName)

    def getHours(self):
        return self._jobCode, self.__hoursPerDay, self._hourType
        
    def changeDailyHours(self,newhours):
        if str(newhours).isdecimal() and newhours >= 0 and newhours <= 10.5:
            self.__hoursPerDay = newhours
            return 1
        else:
            return 0


class WeeklyJob(Job):
    def __init__(self, weekHours:int, code, desc, priority, levelNum, levelNeeded, hourType, daysNeeded,recordName):
        self.__weekHours = weekHours
        super().__init__(code, desc, priority, levelNum, levelNeeded, hourType, daysNeeded,recordName)

    def getHours(self):
        return self._jobCode, self.__weekHours, self._hourType


    def changeHours(self, newHours):
        if str(newHours).isdecimal():
            if newHours >= 0 and newHours <= 52.5:
                self.__weekHours = newHours
                return 1
            else:
                return 0
        else:
            return 0


# Subclass for the small number of jobs thast are monthly. This includes the hours needed, similarly to the 
# previous subclasses, but also whether the job is complete for the month, so it isn't rescheduled if so
class MonthlyJob(Job):
    def __init__(self, hoursNeeded:int, complete:bool, code, desc, priority, levelNum, levelNeeded, hourType, daysNeeded,recordName):
        self.__hours = hoursNeeded
        self.__done = complete
        super().__init__(code, desc, priority, levelNum, levelNeeded, hourType, daysNeeded,recordName)

    def getHours(self):
        return self._jobCode, self.__hours, self._hourType

    def getValid(self):
        return self._jobCode, self.__done


    def changeHours(self, newHours):
        if str(newHours).isdecimal():
            if newHours >= 0:
                self.__hours = newHours
                return 1
            else:
                return 0
        else:
            return 0

    def changeStatus(self):
        if self.__done:
            self.__done = False
        else:
            self.__done = True
        return 1


# Subclass specifically for reception, since it requires the extra attribute of the desk number. This is an inheritance chain of 3, the maximum it is going to.
class Reception(DailyJob):
    def __init__(self,desk:int,dayHours,code,desc,priority,levelNum, levelNeeded, hourType, daysNeeded,recordName):
        self.__desk = desk
        super().__init__(dayHours,code,desc,priority,levelNum, levelNeeded, hourType, daysNeeded,recordName)
    
    def getDesk(self):
        return self._jobCode, self.__desk

    def changeDesk(self, newDesk):
        if type(newDesk) == int:
            if newDesk >= 1 and newDesk <= 4:
                self.__desk = newDesk
                return 1
            else:
                return 0
        else:
            return 0 



def mergeSort(numList):
    leftList = []
    rightList = []
    if len(numList) > 1:
        mid = len(numList) // 2
        leftList = numList[:mid]
        rightList = numList[mid:]
        mergeSort(rightList)       
        mergeSort(leftList) 
        a = 0; b = 0; c = 0
        while a < len(leftList) and b < len(rightList):
            if leftList[a] < rightList[b]:
                numList[c] = leftList[a]
                a += 1
            else:
                numList[c] = rightList[b]
                b += 1
            c += 1

        while a < len(leftList):
            numList[c] = leftList[a]
            a += 1; c += 1

        while b < len(rightList):
            numList[c] = rightList[b]
            b += 1; c += 1




# Subprogram to connect the data in the database tables to the classes instantiated above
def linkStaff():

    staffList = editor.execute("""SELECT *
                         FROM StaffDetails
                         ORDER BY StaffCode ASC""")

    staff = {}
    levelNums = [["DIS",0,0,0],["HUR",0],["SCR",0,0,0],["ADM",0,0,0],["WSC",0,0],["ALL",0]]
    
    for record in staffList.fetchall():
        levelNums[-1][-1] += 1
        hourList = []
        for i in range(9,19):
            hourList.append(record[i])
                
        count = -1       # Code to collect the number of potential staff for each job
        for ind in range(3,8):
            count += 1
            if record[ind] > 0:
                levelNums[count][record[ind]] += 1
                if record[ind] > 1:
                    levelNums[count][record[ind]-1] += 1
                    if record[ind] > 2:
                        levelNums[count][record[ind]-2] += 1

        if record[19] == 0:
            staff[record[0]] = FullHours(record[0],record[1],record[2],{"DIS":record[3],"HUR":record[4],"SCR":record[5],"ADM":record[6],"WSC":record[7]},
                           record[8],hourList,{"MO":False,"TU":False,"WE":False,"TH":False,"FR":False})
        elif record[19] == 1:
            splitStart = {}
            splitEnd = {}
            splitTimes = editor.execute(f"""SELECT Day, StartTime, EndTime
                                        FROM ExtraHours
                                        WHERE ExtraHours.StaffCode = {record[0]}
                                        AND ExtraHours.Type = 'Split'""")
            for day in splitTimes:
                splitStart[day[0]] = day[1]
                splitEnd[day[0]] = day[2]
            staff[record[0]] = SplitHours(record[0],record[1],record[2],{"DIS":record[3],"HUR":record[4],"SCR":record[5],"ADM":record[6],"WSC":record[7]},
                           record[8],hourList,{"MO":False,"TU":False,"WE":False,"TH":False,"FR":False},splitStart,splitEnd)
        elif record[19] == 2:
            zeroStart = ["","","","",""]
            zeroEnds = ["","","","",""]
            zeroTimes = editor.execute(f"""SELECT Day, StartTime, EndTime
                                        FROM ExtraHours
                                        WHERE ExtraHours.StaffCode = {record[0]}
                                        AND ExtraHours.Type = 'Zero'""")
            for item in zeroTimes.fetchall():
                zeroStart[item[0]-1] = item[1]
                zeroEnds[item[0]-1] = item[2]
            staff[record[0]] = ZeroHours(record[0],record[1],record[2],{"DIS":record[3],"HUR":record[4],"SCR":record[5],"ADM":record[6],"WSC":record[7]},
                           record[8],hourList,{"MO":False,"TU":False,"WE":False,"TH":False,"FR":False},zeroStart,zeroEnds)

    return staff, levelNums
    


con.commit()