2168 lines
71 KiB
Python
Executable File
2168 lines
71 KiB
Python
Executable File
#!/usr/bin/env python
|
|
#coding: utf-8
|
|
|
|
# Copyright 2008, Tiril Anette Langfeldt Rødland
|
|
# 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 3 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, see <http://www.gnu.org/licenses/>.
|
|
|
|
import os
|
|
import platform
|
|
import sys
|
|
import string
|
|
import datetime
|
|
import time
|
|
import random
|
|
from PyQt4.QtCore import *
|
|
from PyQt4.QtGui import *
|
|
from pysqlite2 import dbapi2 as sqlite
|
|
from qrc_resources import *
|
|
|
|
|
|
__version__ = "1.0.2"
|
|
|
|
|
|
main = None
|
|
semesters = []
|
|
semester = None
|
|
courses = []
|
|
coursesString = []
|
|
books = []
|
|
booksString = []
|
|
colors = []
|
|
termList = None
|
|
|
|
### The main window
|
|
class MainWindow(QMainWindow):
|
|
|
|
# Initialize the main window
|
|
def __init__(self, parent=None):
|
|
super(MainWindow, self).__init__(parent)
|
|
|
|
# The program name
|
|
self.title = "Egon"
|
|
|
|
# The days
|
|
self.days = [self.trUtf8("Monday"), self.trUtf8("Tuesday"), self.trUtf8("Wednesday"), self.trUtf8("Thursday"), self.trUtf8("Friday")]
|
|
|
|
# The tabs
|
|
self.assignment = AssignmentTab()
|
|
self.reading = ReadingTab()
|
|
self.schedule = ScheduleTab()
|
|
|
|
# Set the tabs in the middle
|
|
self.tabs = QTabWidget()
|
|
self.tabs.addTab(self.assignment, "&Assignments")
|
|
self.tabs.addTab(self.reading, "&Reading List")
|
|
self.tabs.addTab(self.schedule, "&Schedule")
|
|
self.tabs.setTabShape(QTabWidget.Rounded)
|
|
self.tabs.setTabPosition(QTabWidget.North)
|
|
self.setCentralWidget(self.tabs)
|
|
|
|
# The calendar
|
|
self.calendarFrame = QFrame()
|
|
self.calendarFrame.setFrameStyle(QFrame.StyledPanel|QFrame.Sunken)
|
|
self.calendarDockWidget = QDockWidget("Calendar", self)
|
|
self.calendarDockWidget.setVisible(False)
|
|
self.calendarDockWidget.setObjectName("CalendarDockWidget")
|
|
self.calendarDockWidget.setAllowedAreas(Qt.LeftDockWidgetArea|Qt.RightDockWidgetArea|Qt.BottomDockWidgetArea)
|
|
self.calendar = QCalendarWidget()
|
|
self.calendar.setFirstDayOfWeek(Qt.Monday)
|
|
self.calendarLayout = QVBoxLayout()
|
|
self.calendarLayout.addWidget(self.calendar)
|
|
self.calendarFrame.setLayout(self.calendarLayout)
|
|
self.calendarFrame.hide()
|
|
self.calendarDockWidget.setWidget(self.calendarFrame)
|
|
|
|
# The semesters
|
|
global semester, semesters, termList
|
|
termList = QStringList()
|
|
termList.append(self.trUtf8("Spring"))
|
|
termList.append(self.trUtf8("Autumn"))
|
|
semesters = getSemestersFromDB()
|
|
semester = self.getLatestSemester(semesters)
|
|
if semester:
|
|
self.load(semester)
|
|
|
|
# Actions
|
|
fileNewAction = self.createAction("&New", self.fileNew, QKeySequence.New, "filenew", "Create a new semester plan")
|
|
fileOpenAction = self.createAction("&Open", self.fileOpen, QKeySequence.Open, "fileopen", "Open an existing semester plan")
|
|
fileQuitAction = self.createAction("&Quit", self.close, "Ctrl+Q", "filequit", "Quit program")
|
|
editAddCourse = self.createAction("Add &course", self.addCourse, "Ctrl+C", None, "Add a new course")
|
|
editAddBook = self.createAction("Add &book", self.addBook, "Ctrl+B", None, "Add a new book")
|
|
editAddAssignment = self.createAction("Add &assignment", self.addAssignment, "Ctrl+A", None, "Add a new assignment")
|
|
editAddReading = self.createAction("Add &reading", self.addReading, "Ctrl+R", None, "Add a new reading")
|
|
editAddLesson = self.createAction("Add &lesson", self.addLesson, "Ctrl+L", None, "Add a new lesson")
|
|
editShowCalendar = self.createAction("Cal&endar", self.showCalendar, "Ctrl+E", None, "Show the calendar")
|
|
helpAboutScheduler = self.createAction("&About %s" % self.title)
|
|
|
|
# Menus
|
|
self.fileMenu = self.menuBar().addMenu("&File")
|
|
self.editMenu = self.menuBar().addMenu("&Edit")
|
|
self.helpMenu = self.menuBar().addMenu("&Help")
|
|
|
|
# Add actions to the menus
|
|
self.addActions(self.fileMenu, (fileNewAction, fileOpenAction, None, fileQuitAction))
|
|
self.addActions(self.editMenu, (editAddCourse, editAddBook, None, editAddAssignment, None, editAddReading, None, editAddLesson, None, editShowCalendar))
|
|
self.addActions(self.helpMenu, (helpAboutScheduler, None))
|
|
|
|
# Connect statements
|
|
self.connect(editAddCourse, SIGNAL("triggered()"), self.addCourse)
|
|
self.connect(editAddBook, SIGNAL("triggered()"), self.addBook)
|
|
self.connect(editAddAssignment, SIGNAL("triggered()"), self.addAssignment)
|
|
self.connect(editAddReading, SIGNAL("triggered()"), self.addReading)
|
|
self.connect(editAddLesson, SIGNAL("triggered()"), self.addLesson)
|
|
self.connect(editShowCalendar, SIGNAL("pressed()"), self.showCalendar)
|
|
self.connect(helpAboutScheduler, SIGNAL("triggered()"), self.helpAbout)
|
|
self.connect(self.assignment.addAssignmentButton, SIGNAL("pressed()"), self.addAssignment)
|
|
self.connect(self.assignment.deleteAssignmentButton, SIGNAL("pressed()"), self.deleteAssignment)
|
|
self.connect(self.assignment.completeAssignmentBox, SIGNAL("currentIndexChanged(QString)"), self.completeAssignment)
|
|
self.connect(self.reading.addReadingButton, SIGNAL("pressed()"), self.addReading)
|
|
self.connect(self.reading.deleteReadingButton, SIGNAL("pressed()"), self.deleteReading)
|
|
self.connect(self.reading.readingDoneButton, SIGNAL("pressed()"), self.doneReading)
|
|
self.connect(self.schedule.addScheduleButton, SIGNAL("pressed()"), self.addLesson)
|
|
self.connect(self.schedule.deleteScheduleButton, SIGNAL("pressed()"), self.deleteLesson)
|
|
|
|
# The toolbars
|
|
fileToolbar = self.addToolBar("File")
|
|
fileToolbar.setObjectName("FileToolBar")
|
|
self.addActions(fileToolbar, (fileNewAction, fileOpenAction, None, fileQuitAction))
|
|
editToolbar = self.addToolBar("Edit")
|
|
editToolbar.setObjectName("EditToolBar")
|
|
self.addActions(editToolbar, (editAddCourse, editAddBook, None, editShowCalendar))
|
|
|
|
# Set the title
|
|
self.setMainWindowTitle()
|
|
|
|
# The courses
|
|
courses = getCourses()
|
|
makeCoursesString()
|
|
|
|
# This window
|
|
global main
|
|
main = self
|
|
|
|
# Semester
|
|
|
|
## Open the New dialog
|
|
def fileNew(self):
|
|
self.nsdlg = NewSemesterDlg()
|
|
self.nsdlg.show()
|
|
|
|
## Open the Open dialog
|
|
def fileOpen(self):
|
|
self.osdlg = OpenSemesterDlg()
|
|
self.osdlg.show()
|
|
|
|
## Return the latest semester
|
|
def getLatestSemester(self, semesters):
|
|
if len(semesters) == 0:
|
|
return None
|
|
global termList
|
|
max = semesters[0]
|
|
for s in semesters:
|
|
if s.getYear() > max.getYear():
|
|
max = s
|
|
if s.getYear() == max.getYear():
|
|
if s.getTerm() == self.trUtf8("Autumn"):
|
|
max = s
|
|
return max
|
|
|
|
# Return the list of terms
|
|
def getTermList(self):
|
|
global termList
|
|
return termList
|
|
|
|
# Assignment
|
|
|
|
## Open the Add Assignment dialog
|
|
def addAssignment(self):
|
|
self.adlg = AssignmentDlg()
|
|
self.adlg.show()
|
|
|
|
## Delete the assignment from the database and the table
|
|
def deleteAssignment(self):
|
|
course, number = self.getCourseAndNumber()
|
|
table, row = self.getAssignmentTableAndRow()
|
|
global semester
|
|
removeAssignmentFromDB(course, number)
|
|
table.removeRow(row)
|
|
table.horizontalHeader().setResizeMode(QHeaderView.ResizeToContents)
|
|
|
|
## Update the assignment's completion level to the specified level
|
|
def completeAssignment(self, completionLevel):
|
|
course, number = self.getCourseAndNumber()
|
|
table, row = self.getAssignmentTableAndRow()
|
|
updateAssignmentCompletion(course, number, completionLevel)
|
|
item = QTableWidgetItem(QString(completionLevel))
|
|
item.setBackground(self.assignment.makeBrush(completionLevel))
|
|
table.setItem(row, 4, item)
|
|
table.horizontalHeader().setResizeMode(QHeaderView.ResizeToContents)
|
|
|
|
## Return the assignment table and its current row
|
|
def getAssignmentTableAndRow(self):
|
|
table = self.assignment.assignmentTable
|
|
row = table.currentRow()
|
|
return table, row
|
|
|
|
## Return the course and number of the current assignment
|
|
def getCourseAndNumber(self):
|
|
table, row = self.getAssignmentTableAndRow()
|
|
courseItem = table.item(row, 1)
|
|
numberItem = table.item(row, 2)
|
|
courseFull = courseItem.text()
|
|
number = numberItem.text()
|
|
course = getCourseCode(courseFull)
|
|
return course, number
|
|
|
|
# Reading
|
|
|
|
## Open the Add Reading dialog
|
|
def addReading(self):
|
|
self.rdlg = ReadingDlg()
|
|
self.rdlg.show()
|
|
|
|
## Delete the reading from the database and the table
|
|
def deleteReading(self):
|
|
week, course, book = self.getWeekCourseAndBook()
|
|
table, row = self.getReadingTableAndRow()
|
|
global semester
|
|
removeReadingFromDB(week, course, book)
|
|
table.removeRow(row)
|
|
table.horizontalHeader().setResizeMode(QHeaderView.ResizeToContents)
|
|
|
|
## Mark the reading as done
|
|
def doneReading(self):
|
|
table, row = self.getReadingTableAndRow()
|
|
if table.item(row, 6).text().compare(QString(self.trUtf8("Not done"))) == 0:
|
|
done = True
|
|
item = QTableWidgetItem(self.trUtf8("Done"))
|
|
item.setBackground(QBrush(Qt.green, Qt.SolidPattern))
|
|
else:
|
|
done = False
|
|
item = QTableWidgetItem(self.trUtf8("Not done"))
|
|
item.setBackground(QBrush(Qt.red, Qt.SolidPattern))
|
|
table.setItem(row, 6, item)
|
|
table.horizontalHeader().setResizeMode(QHeaderView.ResizeToContents)
|
|
week = (table.item(row, 0).text().toInt())[0]
|
|
courseFull = table.item(row, 1).text()
|
|
courseCode = QString(getCourseCode(courseFull))
|
|
bookTitle = table.item(row, 2).text()
|
|
book = getBookWithTitleFromDB(bookTitle)
|
|
bookIsbn = book.getIsbn()
|
|
updateReadingDone(week, courseCode, bookIsbn, True)
|
|
|
|
## Return the reading table and its current row
|
|
def getReadingTableAndRow(self):
|
|
table = self.reading.readingTable
|
|
row = table.currentRow()
|
|
return table, row
|
|
|
|
## Return the week, course and book of the current reading
|
|
def getWeekCourseAndBook(self):
|
|
table, row = self.getReadingTableAndRow()
|
|
weekItem = table.item(row, 0)
|
|
courseItem = table.item(row, 1)
|
|
bookItem = table.item(row, 2)
|
|
week = (weekItem.text().toInt())[0]
|
|
courseFull = courseItem.text()
|
|
courseCode = getCourseCode(courseFull)
|
|
book = getBookWithTitleFromDB(bookItem.text())
|
|
return week, courseCode, book.getIsbn()
|
|
|
|
# Schedule
|
|
|
|
## Open the Add Lesson dialog
|
|
def addLesson(self):
|
|
self.sdlg = ScheduleDlg()
|
|
self.sdlg.show()
|
|
|
|
## Delete the lesson from the database and the table
|
|
def deleteLesson(self):
|
|
table, row, column = self.getScheduleTableRowAndColumn()
|
|
day, course, time = self.getDayCourseAndTime()
|
|
global semester
|
|
removeLessonFromDB(day, course, time)
|
|
table.setItem(row, column, QTableWidgetItem())
|
|
|
|
## Return the schedule table and the current row and column
|
|
def getScheduleTableRowAndColumn(self):
|
|
table = self.schedule.scheduleTable
|
|
row = table.currentRow()
|
|
column = table.currentColumn()
|
|
return table, row, column
|
|
|
|
## Return the day, course and time of the current lesson
|
|
def getDayCourseAndTime(self):
|
|
table, row, column = self.getScheduleTableRowAndColumn()
|
|
item = table.item(row, column)
|
|
text = item.text()
|
|
textlist = text.split('\n')
|
|
courseFull = textlist[0]
|
|
coursecode = getCourseCode(courseFull)
|
|
day = self.getDayFromTable(column)
|
|
time = row + 8
|
|
return day, coursecode, time
|
|
|
|
## Return the day belonging to the specified column
|
|
def getDayFromTable(self, column):
|
|
return self.days[column]
|
|
|
|
# Course
|
|
|
|
## Open the Add Course dialog
|
|
def addCourse(self):
|
|
self.cdlg = CourseDlg()
|
|
self.cdlg.show()
|
|
|
|
# Book
|
|
|
|
## Open the Add Book dialog
|
|
def addBook(self):
|
|
self.bdlg = BookDlg()
|
|
self.bdlg.show()
|
|
|
|
# Calendar
|
|
|
|
## Show the calendar
|
|
def showCalendar(self):
|
|
if self.calendarDockWidget.isVisible():
|
|
self.removeDockWidget(self.calendarDockWidget)
|
|
else:
|
|
self.addDockWidget(Qt.BottomDockWidgetArea, self.calendarDockWidget)
|
|
self.calendarDockWidget.setVisible(True)
|
|
|
|
# General
|
|
|
|
## Make and open the About dialog
|
|
def helpAbout(self):
|
|
QMessageBox.about(self, "About %s" % self.title, u"""
|
|
<b>%s</b> v %s
|
|
<p>Copyright © 2008 Tiril Anette Langfeldt Rødland. No rights reserved.
|
|
<p>You may modify and redistribute the program under the terms of the GPL. The license can be found here: http://www.gnu.org/licenses/gpl.html
|
|
<p>This application is mainly for use by students, and can be used to keep track of assignments, planned readings and the schedule.
|
|
<p>Python %s - Qt %s - PyQt %s on %s
|
|
<p>Developer: Tiril Anette Langfeldt Rødland, tirilane@pvv.ntnu.no
|
|
""" % (self.title, __version__, platform.python_version(), QT_VERSION_STR, PYQT_VERSION_STR, platform.system()))
|
|
|
|
## Updates the File menu
|
|
def updateFileMenu(self):
|
|
self.fileMenu.clear()
|
|
self.addActions(self.fileMenu, self.fileMenuActions[:-1])
|
|
current = QString(self.filename) if self.filename is not None else None
|
|
|
|
## Create and return the action specified by the input
|
|
def createAction(self, text, slot=None, shortcut=None, icon=None, tip=None, checkable=False, signal="triggered()"):
|
|
action = QAction(text, self)
|
|
if icon is not None:
|
|
iconfile = ":/%s.png" % icon
|
|
action.setIcon(QIcon(iconfile))
|
|
if shortcut is not None:
|
|
action.setShortcut(shortcut)
|
|
if tip is not None:
|
|
action.setToolTip(tip)
|
|
action.setStatusTip(tip)
|
|
if slot is not None:
|
|
self.connect(action, SIGNAL(signal), slot)
|
|
if checkable:
|
|
action.setCheckable(True)
|
|
return action
|
|
|
|
## Add action to the target
|
|
def addActions(self, target, actions):
|
|
for action in actions:
|
|
if action is None:
|
|
target.addSeparator()
|
|
else:
|
|
target.addAction(action)
|
|
|
|
## Set the title on the main window, depending on the chosen semester
|
|
def setMainWindowTitle(self):
|
|
global semester
|
|
if semester:
|
|
self.setWindowTitle("%s : %s %i" % (self.title, semester.getTerm(), semester.getYear()))
|
|
else:
|
|
self.setWindowTitle(self.title)
|
|
|
|
## Load the assignments, readings and schedule from the specified semester
|
|
def load(self, semester):
|
|
self.assignment.updateTable(semester)
|
|
self.reading.updateTable(semester)
|
|
self.schedule.updateTable(semester)
|
|
|
|
|
|
### The New Semester dialog
|
|
class NewSemesterDlg(QDialog):
|
|
|
|
## Initialize the New Semester dialog
|
|
def __init__(self, parent=None):
|
|
super(NewSemesterDlg, self).__init__(parent)
|
|
|
|
# Labels
|
|
self.termLabel = QLabel(self.trUtf8("Term"))
|
|
self.yearLabel = QLabel(self.trUtf8("Year"))
|
|
|
|
# Widgets
|
|
self.termEdit = QComboBox()
|
|
self.yearEdit = QSpinBox()
|
|
self.termEdit.addItems(getMain().getTermList())
|
|
self.yearEdit.setRange(2000, 2050)
|
|
self.yearEdit.setSingleStep(1)
|
|
self.buttonBox = QDialogButtonBox(QDialogButtonBox.Ok|QDialogButtonBox.Cancel)
|
|
|
|
# Layout
|
|
layout = QGridLayout()
|
|
layout.addWidget(self.termLabel, 0, 0)
|
|
layout.addWidget(self.termEdit, 0, 1)
|
|
layout.addWidget(self.yearLabel, 1, 0)
|
|
layout.addWidget(self.yearEdit, 1, 1)
|
|
layout.addWidget(self.buttonBox, 2, 1)
|
|
self.setLayout(layout)
|
|
|
|
# Connect statements
|
|
self.connect(self.buttonBox, SIGNAL("accepted()"), self, SLOT("accept()"))
|
|
self.connect(self.buttonBox, SIGNAL("rejected()"), self, SLOT("reject()"))
|
|
|
|
# Set the title
|
|
self.setWindowTitle(self.trUtf8("New semester"))
|
|
|
|
## Accept the dialog and add the specified semester
|
|
def accept(self):
|
|
term = unicode(self.termEdit.currentText())
|
|
year = self.yearEdit.value()
|
|
global semester
|
|
semester = SemesterModel(term, year)
|
|
addNewSemesterToDB(term, year)
|
|
getMain().load(semester)
|
|
getMain().setMainWindowTitle()
|
|
self.close()
|
|
|
|
|
|
### The Open Semester dialog
|
|
class OpenSemesterDlg(QDialog):
|
|
|
|
## Initialize the Open Semester dialog
|
|
def __init__(self, parent=None):
|
|
super(OpenSemesterDlg, self).__init__(parent)
|
|
|
|
# Widgets
|
|
self.semesterList = QListWidget()
|
|
semesters = getSemestersFromDB()
|
|
semesterlist = QStringList()
|
|
for semester in semesters:
|
|
semesterlist.append("%s %i" % (semester.getTerm(), semester.getYear()))
|
|
self.semesterList.addItems(semesterlist)
|
|
self.buttonBox = QDialogButtonBox(QDialogButtonBox.Ok|QDialogButtonBox.Cancel)
|
|
|
|
# Layout
|
|
layout = QVBoxLayout()
|
|
layout.addWidget(self.semesterList)
|
|
layout.addStretch()
|
|
layout.addWidget(self.buttonBox)
|
|
self.setLayout(layout)
|
|
|
|
# Connect statements
|
|
self.connect(self.buttonBox, SIGNAL("accepted()"), self, SLOT("accept()"))
|
|
self.connect(self.buttonBox, SIGNAL("rejected()"), self, SLOT("reject()"))
|
|
|
|
# Set the title
|
|
self.setWindowTitle(self.trUtf8("Open semester"))
|
|
|
|
## Accept the dialog and open the specified semester
|
|
def accept(self):
|
|
text = self.semesterList.currentItem().text()
|
|
textlist = text.split(' ')
|
|
term = textlist[0]
|
|
year = textlist[1].toInt()[0]
|
|
global semester
|
|
semester = SemesterModel(term, year)
|
|
semester.setAssignments(getAssignmentsFromDB(semester))
|
|
semester.setReadings(getReadingsFromDB(semester))
|
|
semester.setLessons(getLessonsFromDB(semester))
|
|
getMain().load(semester)
|
|
getMain().setMainWindowTitle()
|
|
self.close()
|
|
|
|
|
|
### The semester model
|
|
class SemesterModel():
|
|
|
|
term = ""
|
|
year = 0
|
|
assignments = []
|
|
readings = []
|
|
lessons = []
|
|
|
|
## Initialize the semester model
|
|
def __init__(self, term, year):
|
|
self.term = term
|
|
self.year = year
|
|
|
|
## Return the term of the semester
|
|
def getTerm(self):
|
|
return self.term
|
|
|
|
## Return the year of the semester
|
|
def getYear(self):
|
|
return self.year
|
|
|
|
## Add an assignment to the semester's list of assignments
|
|
def addAssignment(self, assignment):
|
|
self.assignments.append(assignment)
|
|
|
|
## Set the list of assignments
|
|
def setAssignments(self, assignments):
|
|
self.assignments = assignments
|
|
|
|
## Return the list of assignments
|
|
def getAssignments(self):
|
|
return self.assignments
|
|
|
|
## Add a reading to the semester's list of readings
|
|
def addReading(self, reading):
|
|
self.readings.append(reading)
|
|
|
|
## Set the list of readings
|
|
def setReadings(self, readings):
|
|
self.readings = readings
|
|
|
|
## Return the list of readings
|
|
def getReadings(self):
|
|
return self.readings
|
|
|
|
## Add a lesson to the semester's list of lessons
|
|
def addLesson(self, lesson):
|
|
self.lessons.append(lesson)
|
|
|
|
## Set the list of lessons
|
|
def setLessons(self, lessons):
|
|
self.lessons = lessons
|
|
|
|
## Return the list of lessons
|
|
def getLessons(self):
|
|
return self.lessons
|
|
|
|
|
|
### The contents of the Assignment tab
|
|
class AssignmentTab(QWidget):
|
|
|
|
## Initialize the Assignment tab
|
|
def __init__(self, parent=None):
|
|
super(AssignmentTab, self).__init__(parent)
|
|
|
|
# Widgets
|
|
self.addAssignmentButton = QPushButton("Add assignment")
|
|
self.completeAssignmentBox = QComboBox()
|
|
self.deleteAssignmentButton = QPushButton("Delete assignment")
|
|
completeTypes = [self.trUtf8("Not available"), self.trUtf8("Available"), self.trUtf8("Begun"), self.trUtf8("Finished"), self.trUtf8("Delivered"), self.trUtf8("Approved"), self.trUtf8("Not approved")]
|
|
self.completeAssignmentBox.addItems(completeTypes)
|
|
|
|
# Make the table
|
|
self.makeTable()
|
|
|
|
# Layout
|
|
self.vlayout = QVBoxLayout()
|
|
self.hlayout = QHBoxLayout()
|
|
self.hlayout.addWidget(self.addAssignmentButton)
|
|
self.hlayout.addWidget(self.deleteAssignmentButton)
|
|
self.hlayout.addWidget(self.completeAssignmentBox)
|
|
self.hlayout.addStretch()
|
|
self.vlayout.addWidget(self.assignmentTable)
|
|
self.vlayout.addLayout(self.hlayout)
|
|
self.setLayout(self.vlayout)
|
|
|
|
## Make an empty assignment table
|
|
def makeTable(self, current=None):
|
|
self.assignmentTable = QTableWidget(0, 5, self)
|
|
self.assignmentTable.clear()
|
|
|
|
self.assignmentHeaderList = QStringList()
|
|
self.assignmentHeaderList.append(self.trUtf8("Date"))
|
|
self.assignmentHeaderList.append(self.trUtf8("Course"))
|
|
self.assignmentHeaderList.append(self.trUtf8("Number"))
|
|
self.assignmentHeaderList.append(self.trUtf8("Description"))
|
|
self.assignmentHeaderList.append(self.trUtf8("Complete"))
|
|
|
|
self.assignmentTable.setHorizontalHeaderLabels(self.assignmentHeaderList)
|
|
self.assignmentTable.setAlternatingRowColors(True)
|
|
self.assignmentTable.setEditTriggers(QAbstractItemView.NoEditTriggers)
|
|
self.assignmentTable.setSelectionBehavior(QAbstractItemView.SelectRows)
|
|
self.assignmentTable.setSelectionMode(QAbstractItemView.SingleSelection)
|
|
|
|
selected = None
|
|
|
|
## Add the assignments of the semester to the table
|
|
def updateTable(self, semester, current=None):
|
|
self.assignments = getAssignmentsFromDB(semester)
|
|
rows = len(self.assignments)
|
|
self.assignmentTable.setRowCount(rows)
|
|
|
|
for row in range(rows):
|
|
self.addAssignmentToTable(row)
|
|
|
|
self.assignmentTable.horizontalHeader().setResizeMode(QHeaderView.ResizeToContents)
|
|
self.assignmentTable.sortItems(0, Qt.AscendingOrder)
|
|
|
|
## Add new assignment to Table
|
|
def addAssignmentToTable(self, row, assignment=None):
|
|
if assignment == None:
|
|
assignment = self.assignments[row]
|
|
|
|
complete = QString(assignment.getComplete())
|
|
brush = self.makeBrush(complete)
|
|
|
|
self.assignmentTable.setItem(row, 0, QTableWidgetItem(QString(assignment.getDate().toString("yyyy-MM-dd hh:mm, ddd"))))
|
|
self.assignmentTable.setItem(row, 1, QTableWidgetItem(QString(assignment.getCourse().getFull())))
|
|
self.assignmentTable.setItem(row, 2, QTableWidgetItem(QString("%i" % assignment.getNumber())))
|
|
self.assignmentTable.setItem(row, 3, QTableWidgetItem(QString("%s" % assignment.getDescription())))
|
|
|
|
completeItem = QTableWidgetItem(complete)
|
|
completeItem.setBackground(brush)
|
|
self.assignmentTable.setItem(row, 4, completeItem)
|
|
|
|
## Set the right brush and color for the assignment, depending on level of completion
|
|
def makeBrush(self, complete):
|
|
brush = QBrush(Qt.NoBrush)
|
|
if complete.compare(QString(self.trUtf8("Available"))) == 0:
|
|
brush.setStyle(Qt.Dense7Pattern)
|
|
brush.setColor(QColor(Qt.cyan))
|
|
elif complete.compare(QString(self.trUtf8("Begun"))) == 0:
|
|
brush.setStyle(Qt.Dense5Pattern)
|
|
brush.setColor(QColor(Qt.cyan))
|
|
elif complete.compare(QString(self.trUtf8("Finished"))) == 0:
|
|
brush.setStyle(Qt.Dense3Pattern)
|
|
brush.setColor(QColor(Qt.cyan))
|
|
elif complete.compare(QString(self.trUtf8("Delivered"))) == 0:
|
|
brush.setStyle(Qt.Dense1Pattern)
|
|
brush.setColor(QColor(Qt.cyan))
|
|
elif complete.compare(QString(self.trUtf8("Approved"))) == 0:
|
|
brush.setStyle(Qt.SolidPattern)
|
|
brush.setColor(QColor(Qt.green))
|
|
elif complete.compare(QString(self.trUtf8("Not approved"))) == 0:
|
|
brush.setStyle(Qt.SolidPattern)
|
|
brush.setColor(QColor(Qt.red))
|
|
else:
|
|
brush.setStyle(Qt.NoBrush)
|
|
return brush
|
|
|
|
|
|
### The Add Assignment dialog
|
|
class AssignmentDlg(QDialog):
|
|
|
|
## Initialize the Add Assignment dialog
|
|
def __init__(self, parent=None):
|
|
super(AssignmentDlg, self).__init__(parent)
|
|
|
|
# Labels
|
|
self.dateLabel = QLabel(self.trUtf8("&Date"))
|
|
self.courseLabel = QLabel(self.trUtf8("&Course"))
|
|
self.numberLabel = QLabel(self.trUtf8("&Number"))
|
|
self.descriptionLabel = QLabel(self.trUtf8("De&scription"))
|
|
self.completeLabel = QLabel(self.trUtf8("&Complete"))
|
|
|
|
# Widgets
|
|
self.dateEdit = QLineEdit("DD.MM.YYYY HH:MM")
|
|
self.dateEdit.setSelection(0, 16)
|
|
self.courseEdit = QComboBox()
|
|
self.courseEdit.addItems(makeCoursesString())
|
|
self.numberEdit = QSpinBox()
|
|
self.numberEdit.setRange(1, 20)
|
|
self.descriptionEdit = QLineEdit()
|
|
self.completeEdit = QComboBox()
|
|
completeTypes = [self.trUtf8("Not available"), self.trUtf8("Available"), self.trUtf8("Begun"), self.trUtf8("Finished"), self.trUtf8("Delivered"), self.trUtf8("Approved"), self.trUtf8("Not approved")]
|
|
self.completeEdit.addItems(completeTypes)
|
|
self.buttonBox = QDialogButtonBox(QDialogButtonBox.Ok|QDialogButtonBox.Cancel)
|
|
|
|
# Buddies
|
|
self.dateLabel.setBuddy(self.dateEdit)
|
|
self.courseLabel.setBuddy(self.courseEdit)
|
|
self.numberLabel.setBuddy(self.numberEdit)
|
|
self.descriptionLabel.setBuddy(self.descriptionEdit)
|
|
self.completeLabel.setBuddy(self.completeEdit)
|
|
|
|
# Layout
|
|
self.layout = QGridLayout()
|
|
self.layout.addWidget(self.dateLabel, 0, 0)
|
|
self.layout.addWidget(self.courseLabel, 1, 0)
|
|
self.layout.addWidget(self.numberLabel, 2, 0)
|
|
self.layout.addWidget(self.descriptionLabel, 3, 0)
|
|
self.layout.addWidget(self.completeLabel, 4, 0)
|
|
self.layout.addWidget(self.dateEdit, 0, 1)
|
|
self.layout.addWidget(self.courseEdit, 1, 1)
|
|
self.layout.addWidget(self.numberEdit, 2, 1)
|
|
self.layout.addWidget(self.descriptionEdit, 3, 1)
|
|
self.layout.addWidget(self.completeEdit, 4, 1)
|
|
self.layout.addWidget(self.buttonBox, 5, 0, 1, 2)
|
|
self.setLayout(self.layout)
|
|
|
|
# Connect statements
|
|
self.connect(self.buttonBox, SIGNAL("accepted()"), self, SLOT("accept()"))
|
|
self.connect(self.buttonBox, SIGNAL("rejected()"), self, SLOT("reject()"))
|
|
|
|
# Set the title
|
|
self.setWindowTitle(self.trUtf8("Add new assignment"))
|
|
|
|
## Return an array with the values of the widgets
|
|
def getValues(self):
|
|
assignment = []
|
|
assignment.append(unicode(self.dateEdit.text()))
|
|
assignment.append(unicode(self.courseEdit.currentText()))
|
|
assignment.append(self.numberEdit.value())
|
|
assignment.append(unicode(self.descriptionEdit.text()))
|
|
assignment.append(unicode(self.completeEdit.currentText()))
|
|
return assignment
|
|
|
|
## Accept the dialog and add the specified assignment
|
|
def accept(self):
|
|
assignmentList = self.getValues()
|
|
dateString = assignmentList[0]
|
|
courseFull = assignmentList[1]
|
|
number = assignmentList[2]
|
|
description = assignmentList[3]
|
|
complete = assignmentList[4]
|
|
|
|
regex = QRegExp(r"[01-31].[01-12].[2000-2050] [00-23]:[00-60]")
|
|
validator = QRegExpValidator(regex, self)
|
|
valid = validator.validate(dateString, 16)
|
|
if valid == QValidator.Invalid:
|
|
regexMessage = QErrorMessage()
|
|
regexMessage.showMessage(QString(self.trUtf8("The date is not in a correct format.")))
|
|
|
|
if len(dateString) <= 11:
|
|
dateList = dateString.split('.')
|
|
timeList = ['00', '00']
|
|
else:
|
|
dateTime = dateString.split()
|
|
dateList = dateTime[0].split('.')
|
|
timeList = dateTime[1].split(':')
|
|
|
|
if dateList[1] > '13':
|
|
dateMessage = QErrorMessage()
|
|
elif dateList[0] > '31':
|
|
dateMessage = QErrorMessage()
|
|
dateMessage.showMessage(QString(self.trUtf8("The day is not valid. Please enter a valid date.")))
|
|
elif timeList[0] > '23':
|
|
dateMessage = QErrorMessage()
|
|
dateMessage.showMessage(QString(self.trUtf8("The hour is not valid. Please enter a valid time.")))
|
|
elif timeList[1] > '59':
|
|
dateMessage = QErrorMessage()
|
|
dateMessage.showMessage(QString(self.trUtf8("The minutes are not valid. Please enter a valid time.")))
|
|
else:
|
|
try:
|
|
date = QDate(string.atoi(dateList[2]), string.atoi(dateList[1]), string.atoi(dateList[0]))
|
|
time = QTime(string.atoi(timeList[0]), string.atoi(timeList[1]))
|
|
datetime = QDateTime(date, time)
|
|
except ValueError, e:
|
|
valueMessage = QErrorMessage()
|
|
valueMessage.showMessage(QString(self.trUtf8("The date is not valid. Please enter a date on the DD.MM.YYYY HH:MM form.")))
|
|
|
|
course = getCourseFromDB(getCourseCode(courseFull))
|
|
|
|
try:
|
|
global semester
|
|
addNewAssignmentToDB(semester, datetime, course, number, description, complete)
|
|
assignment = AssignmentModel(datetime, course, number, description, complete)
|
|
except UnboundLocalError, e:
|
|
pass
|
|
|
|
table = getMain().assignment.assignmentTable
|
|
row = table.rowCount()
|
|
table.insertRow(row)
|
|
getMain().assignment.addAssignmentToTable(row, assignment)
|
|
table.sortItems(0, Qt.AscendingOrder)
|
|
|
|
self.close()
|
|
|
|
|
|
### The assignment model
|
|
class AssignmentModel():
|
|
|
|
date = None
|
|
course = None
|
|
number = 0
|
|
description = ""
|
|
complete = ""
|
|
|
|
## Initialize the assignment model
|
|
def __init__(self, date, course, number, description, complete):
|
|
self.date = date
|
|
self.course = course
|
|
self.number = number
|
|
self.description = description
|
|
self.complete = complete
|
|
|
|
## Return the date the assignment is due
|
|
def getDate(self):
|
|
return self.date
|
|
|
|
## Return the course the assignment is given in
|
|
def getCourse(self):
|
|
return self.course
|
|
|
|
## Return the number of the assignment
|
|
def getNumber(self):
|
|
return self.number
|
|
|
|
## Return the description of the assignment
|
|
def getDescription(self):
|
|
return self.description
|
|
|
|
## Return the level of completion for the assignment
|
|
def getComplete(self):
|
|
return self.complete
|
|
|
|
|
|
### The contents of the Reading tab
|
|
class ReadingTab(QWidget):
|
|
|
|
## Initialize the Reading tab
|
|
def __init__(self, parent=None):
|
|
super(ReadingTab, self).__init__(parent)
|
|
|
|
# Widgets
|
|
self.addReadingButton = QPushButton(self.trUtf8("Add pages to read"))
|
|
self.deleteReadingButton = QPushButton(self.trUtf8("Delete pages"))
|
|
self.readingDoneButton = QPushButton(self.trUtf8("Done"))
|
|
|
|
# Make the table
|
|
self.makeTable()
|
|
|
|
# Layout
|
|
self.vlayout = QVBoxLayout()
|
|
self.hlayout = QHBoxLayout()
|
|
self.hlayout.addWidget(self.addReadingButton)
|
|
self.hlayout.addWidget(self.deleteReadingButton)
|
|
self.hlayout.addWidget(self.readingDoneButton)
|
|
self.hlayout.addStretch()
|
|
self.vlayout.addWidget(self.readingTable)
|
|
self.vlayout.addLayout(self.hlayout)
|
|
self.setLayout(self.vlayout)
|
|
|
|
## Make an empty reading table
|
|
def makeTable(self, current=None):
|
|
self.readingTable = QTableWidget(0, 7, self)
|
|
self.readingTable.clear()
|
|
self.readingHeaderList = QStringList()
|
|
self.readingHeaderList.append(self.trUtf8("Week"))
|
|
self.readingHeaderList.append(self.trUtf8("Course"))
|
|
self.readingHeaderList.append(self.trUtf8("Book"))
|
|
self.readingHeaderList.append(self.trUtf8("Chapter"))
|
|
self.readingHeaderList.append(self.trUtf8("Pages"))
|
|
self.readingHeaderList.append(self.trUtf8("Number of pages"))
|
|
self.readingHeaderList.append(self.trUtf8("Done"))
|
|
self.readingTable.setHorizontalHeaderLabels(self.readingHeaderList)
|
|
self.readingTable.setAlternatingRowColors(True)
|
|
self.readingTable.setEditTriggers(QAbstractItemView.NoEditTriggers)
|
|
self.readingTable.setSelectionBehavior(QAbstractItemView.SelectRows)
|
|
self.readingTable.setSelectionMode(QAbstractItemView.SingleSelection)
|
|
selected = None
|
|
|
|
## Add the readings of the semester to the table
|
|
def updateTable(self, semester):
|
|
self.readings = getReadingsFromDB(semester)
|
|
rows = len(self.readings)
|
|
self.readingTable.setRowCount(rows)
|
|
for row in range(rows):
|
|
self.addReadingToTable(row)
|
|
self.readingTable.horizontalHeader().setResizeMode(QHeaderView.ResizeToContents)
|
|
self.readingTable.sortItems(0, Qt.AscendingOrder)
|
|
|
|
## Add a new reading to the table
|
|
def addReadingToTable(self, row, reading=None):
|
|
if reading == None:
|
|
reading = self.readings[row]
|
|
|
|
brush = QBrush(Qt.NoBrush)
|
|
brush.setStyle(Qt.SolidPattern)
|
|
|
|
if reading.getDone():
|
|
doneString = self.trUtf8("Done")
|
|
brush.setColor(Qt.green)
|
|
else:
|
|
doneString = self.trUtf8("Not done")
|
|
brush.setColor(Qt.red)
|
|
|
|
self.readingTable.setItem(row, 0, QTableWidgetItem(QString("%02s" % reading.getWeek())))
|
|
self.readingTable.setItem(row, 1, QTableWidgetItem(QString(reading.getCourse().getFull())))
|
|
self.readingTable.setItem(row, 2, QTableWidgetItem(QString(reading.getBook().getTitle())))
|
|
self.readingTable.setItem(row, 3, QTableWidgetItem(QString(reading.getChapter())))
|
|
self.readingTable.setItem(row, 4, QTableWidgetItem(QString(reading.getPages())))
|
|
self.readingTable.setItem(row, 5, QTableWidgetItem(QString("%i" % reading.getNumberOfPages())))
|
|
|
|
item = QTableWidgetItem(QString(doneString))
|
|
item.setBackground(brush)
|
|
self.readingTable.setItem(row, 6, item)
|
|
|
|
|
|
### The Add Reading dialog
|
|
class ReadingDlg(QDialog):
|
|
|
|
## Initialize the Add Reading dialog
|
|
def __init__(self, parent=None):
|
|
super(ReadingDlg, self).__init__(parent)
|
|
|
|
# Labels
|
|
self.weekLabel = QLabel(self.trUtf8("&Week"))
|
|
self.courseLabel = QLabel(self.trUtf8("&Course"))
|
|
self.bookLabel = QLabel(self.trUtf8("&Book"))
|
|
self.chapterLabel = QLabel(self.trUtf8("Cha&pter"))
|
|
self.pagesLabel = QLabel(self.trUtf8("&Pages"))
|
|
|
|
# Widgets
|
|
self.weekEdit = QSpinBox()
|
|
self.weekEdit.setRange(1, 52)
|
|
self.courseEdit = QComboBox()
|
|
coursesStringList = QStringList()
|
|
courses = makeCoursesString()
|
|
for course in courses:
|
|
coursesStringList.append(course)
|
|
self.courseEdit.addItems(coursesStringList)
|
|
self.bookEdit = QComboBox()
|
|
booksStringList = QStringList()
|
|
books = makeBooksString()
|
|
for book in books:
|
|
booksStringList.append(book)
|
|
self.bookEdit.addItems(booksStringList)
|
|
self.chapterEdit = QLineEdit()
|
|
self.pagesEdit = QLineEdit()
|
|
self.buttonBox = QDialogButtonBox(QDialogButtonBox.Ok|QDialogButtonBox.Cancel)
|
|
|
|
# Buddies
|
|
self.weekLabel.setBuddy(self.weekEdit)
|
|
self.courseLabel.setBuddy(self.courseEdit)
|
|
self.bookLabel.setBuddy(self.bookEdit)
|
|
self.chapterLabel.setBuddy(self.chapterEdit)
|
|
self.pagesLabel.setBuddy(self.pagesEdit)
|
|
|
|
# Layout
|
|
self.layout = QGridLayout()
|
|
self.layout.addWidget(self.weekLabel, 0, 0)
|
|
self.layout.addWidget(self.courseLabel, 1, 0)
|
|
self.layout.addWidget(self.bookLabel, 2, 0)
|
|
self.layout.addWidget(self.chapterLabel, 3, 0)
|
|
self.layout.addWidget(self.pagesLabel, 4, 0)
|
|
self.layout.addWidget(self.weekEdit, 0, 1)
|
|
self.layout.addWidget(self.courseEdit, 1, 1)
|
|
self.layout.addWidget(self.bookEdit, 2, 1)
|
|
self.layout.addWidget(self.chapterEdit, 3, 1)
|
|
self.layout.addWidget(self.pagesEdit, 4, 1)
|
|
self.layout.addWidget(self.buttonBox, 5, 0, 1, 2)
|
|
self.setLayout(self.layout)
|
|
|
|
# Connect statements
|
|
self.connect(self.buttonBox, SIGNAL("accepted()"), self, SLOT("accept()"))
|
|
self.connect(self.buttonBox, SIGNAL("rejected()"), self, SLOT("reject()"))
|
|
|
|
# Set the title
|
|
self.setWindowTitle(self.trUtf8("Add new reading"))
|
|
|
|
## Accept the dialog and add the specified reading
|
|
def accept(self):
|
|
week = unicode(self.weekEdit.value())
|
|
courseFull = unicode(self.courseEdit.currentText())
|
|
bookTitle = unicode(self.bookEdit.currentText())
|
|
chapter = unicode(self.chapterEdit.text())
|
|
pages = unicode(self.pagesEdit.text())
|
|
|
|
self.close()
|
|
|
|
course = getCourseFromDB(getCourseCode(courseFull))
|
|
book = getBookWithTitleFromDB(bookTitle)
|
|
|
|
global semester
|
|
addNewReadingToDB(semester, week, course, book, chapter, pages, False)
|
|
|
|
reading = ReadingModel(week, course, book, chapter, pages, False)
|
|
table = getMain().reading.readingTable
|
|
row = table.rowCount()
|
|
table.insertRow(row)
|
|
getMain().reading.addReadingToTable(row, reading)
|
|
table.sortItems(0, Qt.AscendingOrder)
|
|
|
|
|
|
### The reading model
|
|
class ReadingModel():
|
|
|
|
week = 0
|
|
course = None
|
|
book = None
|
|
chapter = ""
|
|
pages = ""
|
|
numberOfPages = 0
|
|
done = False
|
|
|
|
## Initialize the reading model
|
|
def __init__(self, week, course, book, chapter, pages, done=False):
|
|
self.week = week
|
|
self.course = course
|
|
self.book = book
|
|
self.chapter = chapter
|
|
self.pages = pages
|
|
self.numberOfPages = self.getNumberOfPages()
|
|
self.done = done
|
|
|
|
## Return the week the reading shall be done
|
|
def getWeek(self):
|
|
return self.week
|
|
|
|
## Return the course the reading is in
|
|
def getCourse(self):
|
|
return self.course
|
|
|
|
## Return the book to be read in
|
|
def getBook(self):
|
|
return self.book
|
|
|
|
## Return the chapter to be read
|
|
def getChapter(self):
|
|
return self.chapter
|
|
|
|
## Return the pages to be read
|
|
def getPages(self):
|
|
return self.pages
|
|
|
|
## Return the number of pages to be read
|
|
def getNumberOfPages(self):
|
|
pages = self.getPages()
|
|
pagesArray = pages.split(",")
|
|
nextArray = []
|
|
sum = 0
|
|
for p in pagesArray:
|
|
p.strip()
|
|
nextArray.append(p.split("-"))
|
|
for n in nextArray:
|
|
sum += int(n[1]) - int(n[0])
|
|
return sum
|
|
|
|
## Return whether the reading has been done or not
|
|
def getDone(self):
|
|
return self.done
|
|
|
|
|
|
### The contents of the Schedule tab
|
|
class ScheduleTab(QWidget):
|
|
|
|
## Initialize the Schedule tab
|
|
def __init__(self, parent=None):
|
|
super(ScheduleTab, self).__init__(parent)
|
|
|
|
# Widgets
|
|
self.addScheduleButton = QPushButton("Add lesson")
|
|
self.deleteScheduleButton = QPushButton("Delete lesson")
|
|
|
|
# Make the table
|
|
self.makeTable()
|
|
|
|
# Layout
|
|
self.vlayout = QVBoxLayout()
|
|
self.hlayout = QHBoxLayout()
|
|
self.hlayout.addWidget(self.addScheduleButton)
|
|
self.hlayout.addWidget(self.deleteScheduleButton)
|
|
self.hlayout.addStretch()
|
|
self.vlayout.addWidget(self.scheduleTable)
|
|
self.vlayout.addLayout(self.hlayout)
|
|
self.setLayout(self.vlayout)
|
|
|
|
## Make an empty schedule table
|
|
def makeTable(self, current=None):
|
|
self.scheduleTable = QTableWidget(12, 5, self)
|
|
self.scheduleTable.setRowCount(12)
|
|
self.scheduleTable.clear()
|
|
self.updateHeaders()
|
|
self.scheduleTable.setAlternatingRowColors(False)
|
|
self.scheduleTable.setEditTriggers(QAbstractItemView.NoEditTriggers)
|
|
self.scheduleTable.setSelectionBehavior(QAbstractItemView.SelectItems)
|
|
self.scheduleTable.setSelectionMode(QAbstractItemView.SingleSelection)
|
|
selected = None
|
|
|
|
def updateHeaders(self):
|
|
self.scheduleHorizontalHeaderList = QStringList()
|
|
self.scheduleHorizontalHeaderList.append(self.trUtf8("Monday"))
|
|
self.scheduleHorizontalHeaderList.append(self.trUtf8("Tuesday"))
|
|
self.scheduleHorizontalHeaderList.append(self.trUtf8("Wednesday"))
|
|
self.scheduleHorizontalHeaderList.append(self.trUtf8("Thursday"))
|
|
self.scheduleHorizontalHeaderList.append(self.trUtf8("Friday"))
|
|
self.scheduleVerticalHeaderList = QStringList()
|
|
for i in range(8, 20):
|
|
self.scheduleVerticalHeaderList.append(self.trUtf8("%i" % i))
|
|
self.scheduleTable.setHorizontalHeaderLabels(self.scheduleHorizontalHeaderList)
|
|
self.scheduleTable.setVerticalHeaderLabels(self.scheduleVerticalHeaderList)
|
|
|
|
|
|
## Add the lessons of the semester to the table
|
|
def updateTable(self, semester):
|
|
self.schedule = getLessonsFromDB(semester)
|
|
rows = len(self.schedule)
|
|
self.scheduleTable.clear()
|
|
for l in range(rows):
|
|
self.addLessonToTable(self.schedule[l])
|
|
self.scheduleTable.horizontalHeader().setResizeMode(QHeaderView.ResizeToContents)
|
|
self.scheduleTable.verticalHeader().setResizeMode(QHeaderView.ResizeToContents)
|
|
self.updateHeaders()
|
|
|
|
## Add a new lesson to the table
|
|
def addLessonToTable(self, lesson):
|
|
row = lesson.getTime() - 8
|
|
column = self.getColumn(lesson.getDay())
|
|
code = lesson.getCourse().getCode()
|
|
title = lesson.getCourse().getTitle()
|
|
type = lesson.getType()
|
|
room = lesson.getRoom()
|
|
olditem = self.scheduleTable.item(row, column)
|
|
newtext = "%s\n%s\n%s\n%s" % (code, title, type, room)
|
|
if olditem:
|
|
oldtext = olditem.text()
|
|
text = QString(oldtext + "\n" + newtext)
|
|
collision = True
|
|
else:
|
|
text = QString(newtext)
|
|
collision = False
|
|
item = QTableWidgetItem(text)
|
|
item.setBackground(self.getBackground(QString("%s" % type), lesson.getCourse(), collision))
|
|
self.scheduleTable.setItem(row, column, item)
|
|
|
|
## Return the column specified by the day
|
|
def getColumn(self, dayString):
|
|
day = QString("%s" % dayString)
|
|
if day.compare(QString(self.trUtf8("Monday"))) == 0:
|
|
return 0
|
|
elif day.compare(QString(self.trUtf8("Tuesday"))) == 0:
|
|
return 1
|
|
elif day.compare(QString(self.trUtf8("Wednesday"))) == 0:
|
|
return 2
|
|
elif day.compare(QString(self.trUtf8("Thursday"))) == 0:
|
|
return 3
|
|
elif day.compare(QString(self.trUtf8("Friday"))) == 0:
|
|
return 4
|
|
else:
|
|
return -1
|
|
|
|
## Set the right brush and color for the lesson, depending on type of lesson
|
|
def getBackground(self, type, course, collision):
|
|
if type.compare(QString(self.trUtf8("Lecture"))) == 0:
|
|
brush = QBrush(Qt.SolidPattern)
|
|
elif type.compare(QString(self.trUtf8("Assignment lecture"))) == 0:
|
|
brush = QBrush(Qt.Dense2Pattern)
|
|
elif type.compare(QString(self.trUtf8("Assignment help"))) == 0:
|
|
brush = QBrush(Qt.Dense3Pattern)
|
|
elif type.compare(QString(self.trUtf8("Lab"))) == 0:
|
|
brush = QBrush(Qt.Dense1Pattern)
|
|
elif type.compare(QString(self.trUtf8("Seminar"))) == 0:
|
|
brush = QBrush(Qt.Dense4Pattern)
|
|
elif type.compare(QString(self.trUtf8("Other"))) == 0:
|
|
brush = QBrush(Qt.Dense5Pattern)
|
|
else:
|
|
brush = QBrush(Qt.NoBrush)
|
|
if not collision:
|
|
brush.setColor(course.getColor())
|
|
else:
|
|
brush.setColor(Qt.red)
|
|
return brush
|
|
|
|
|
|
### The Add Lesson dialog
|
|
class ScheduleDlg(QDialog):
|
|
|
|
## Initialize the Add Lesson dialog
|
|
def __init__(self, parent=None):
|
|
super(ScheduleDlg, self).__init__(parent)
|
|
|
|
# Labels
|
|
self.dayLabel = QLabel(self.trUtf8("&Day"))
|
|
self.fromLabel = QLabel(self.trUtf8("&From"))
|
|
self.toLabel = QLabel(self.trUtf8("&To"))
|
|
self.courseLabel = QLabel(self.trUtf8("&Course"))
|
|
self.typeLabel = QLabel(self.trUtf8("Ty&pe"))
|
|
self.roomLabel = QLabel(self.trUtf8("&Room"))
|
|
|
|
# Widgets
|
|
self.dayEdit = QComboBox()
|
|
self.dayEdit.addItems(getMain().days)
|
|
self.fromEdit = QSpinBox()
|
|
self.fromEdit.setRange(08.15, 18.15)
|
|
self.fromEdit.setSingleStep(01.00)
|
|
self.toEdit = QSpinBox()
|
|
self.toEdit.setRange(09.00, 19.00)
|
|
self.toEdit.setSingleStep(01.00)
|
|
self.courseEdit = QComboBox()
|
|
courses = makeCoursesString()
|
|
coursesStringList = QStringList()
|
|
for course in courses:
|
|
coursesStringList.append(course)
|
|
self.courseEdit.addItems(coursesStringList)
|
|
self.typeEdit = QComboBox()
|
|
types = [self.trUtf8("Lecture"), self.trUtf8("Assignment lecture"), self.trUtf8("Assignment help"), self.trUtf8("Lab"), self.trUtf8("Seminar"), self.trUtf8("Other")]
|
|
self.typeEdit.addItems(types)
|
|
self.roomEdit = QLineEdit()
|
|
self.buttonBox = QDialogButtonBox(QDialogButtonBox.Ok|QDialogButtonBox.Cancel)
|
|
|
|
# Buddies
|
|
self.dayLabel.setBuddy(self.dayEdit)
|
|
self.fromLabel.setBuddy(self.fromEdit)
|
|
self.toLabel.setBuddy(self.toEdit)
|
|
self.courseLabel.setBuddy(self.courseEdit)
|
|
self.typeLabel.setBuddy(self.typeEdit)
|
|
self.roomLabel.setBuddy(self.roomEdit)
|
|
|
|
# Layout
|
|
self.layout = QGridLayout()
|
|
self.layout.addWidget(self.dayLabel, 0, 0)
|
|
self.layout.addWidget(self.fromLabel, 1, 0)
|
|
self.layout.addWidget(self.toLabel, 2, 0)
|
|
self.layout.addWidget(self.courseLabel, 3, 0)
|
|
self.layout.addWidget(self.typeLabel, 4, 0)
|
|
self.layout.addWidget(self.roomLabel, 5, 0)
|
|
self.layout.addWidget(self.dayEdit, 0, 1)
|
|
self.layout.addWidget(self.fromEdit, 1, 1)
|
|
self.layout.addWidget(self.toEdit, 2, 1)
|
|
self.layout.addWidget(self.courseEdit, 3, 1)
|
|
self.layout.addWidget(self.typeEdit, 4, 1)
|
|
self.layout.addWidget(self.roomEdit, 5, 1)
|
|
self.layout.addWidget(self.buttonBox, 6, 0, 1, 2)
|
|
self.setLayout(self.layout)
|
|
|
|
# Connect statements
|
|
self.connect(self.buttonBox, SIGNAL("accepted()"), self, SLOT("accept()"))
|
|
self.connect(self.buttonBox, SIGNAL("rejected()"), self, SLOT("reject()"))
|
|
|
|
# Set the title
|
|
self.setWindowTitle(self.trUtf8("Add new lesson"))
|
|
|
|
## Accept the dialog and add the specified lesson
|
|
def accept(self):
|
|
day = unicode(self.dayEdit.currentText())
|
|
fromtime = self.fromEdit.value()
|
|
totime = self.toEdit.value()
|
|
courseFull = unicode(self.courseEdit.currentText())
|
|
type = unicode(self.typeEdit.currentText())
|
|
room = unicode(self.roomEdit.text())
|
|
|
|
course = getCourseFromDB(getCourseCode(courseFull))
|
|
|
|
global semester
|
|
for t in range(fromtime, totime):
|
|
addNewLessonToDB(semester, day, t, course, type, room)
|
|
getMain().schedule.addLessonToTable(ScheduleModel(day, t, course, type, room))
|
|
|
|
self.close()
|
|
|
|
|
|
### The schedule model
|
|
class ScheduleModel():
|
|
|
|
day = ""
|
|
time = 0
|
|
course = None
|
|
type = ""
|
|
room = ""
|
|
|
|
## Initialize the schedule model
|
|
def __init__(self, day, time, course, type, room):
|
|
self.day = day
|
|
self.time = time
|
|
self.course = course
|
|
self.type = type
|
|
self.room = room
|
|
|
|
## Return the day of the lesson
|
|
def getDay(self):
|
|
return self.day
|
|
|
|
## Return the start time of the lesson
|
|
def getTime(self):
|
|
return self.time
|
|
|
|
## Return the course of the lesson
|
|
def getCourse(self):
|
|
return self.course
|
|
|
|
## Return the type of the lesson
|
|
def getType(self):
|
|
return self.type
|
|
|
|
## Return the room the lesson is in
|
|
def getRoom(self):
|
|
return self.room
|
|
|
|
|
|
### The Add Course dialog
|
|
class CourseDlg(QDialog):
|
|
|
|
## Initialize the Add Course dialog
|
|
def __init__(self, parent=None):
|
|
super(CourseDlg, self).__init__(parent)
|
|
|
|
# The books
|
|
self.books = []
|
|
|
|
# Labels
|
|
self.codeLabel = QLabel(self.trUtf8("&Code"))
|
|
self.titleLabel = QLabel(self.trUtf8("&Title"))
|
|
self.shortLabel = QLabel(self.trUtf8("&Short form"))
|
|
self.booksLabel = QLabel(self.trUtf8("&Books"))
|
|
|
|
# Widgets
|
|
self.codeEdit = QLineEdit()
|
|
self.titleEdit = QLineEdit()
|
|
self.shortEdit = QLineEdit()
|
|
self.booksEdit = QListWidget()
|
|
self.updateList()
|
|
self.booksEdit.setSelectionMode(QAbstractItemView.ExtendedSelection)
|
|
self.newBook = QPushButton("Add new book")
|
|
self.buttonBox = QDialogButtonBox(QDialogButtonBox.Ok|QDialogButtonBox.Cancel)
|
|
|
|
# Buddies
|
|
self.codeLabel.setBuddy(self.codeEdit)
|
|
self.titleLabel.setBuddy(self.titleEdit)
|
|
self.shortLabel.setBuddy(self.shortEdit)
|
|
self.booksLabel.setBuddy(self.booksEdit)
|
|
|
|
# Layout
|
|
self.layout = QGridLayout()
|
|
self.layout.addWidget(self.codeLabel, 0, 0)
|
|
self.layout.addWidget(self.titleLabel, 1, 0)
|
|
self.layout.addWidget(self.shortLabel, 2, 0)
|
|
self.layout.addWidget(self.booksLabel, 3, 0)
|
|
self.layout.addWidget(self.codeEdit, 0, 1)
|
|
self.layout.addWidget(self.titleEdit, 1, 1)
|
|
self.layout.addWidget(self.shortEdit, 2, 1)
|
|
self.layout.addWidget(self.booksEdit, 3, 1)
|
|
self.layout.addWidget(self.newBook, 4, 0)
|
|
self.layout.addWidget(self.buttonBox, 4, 1, 1, 2)
|
|
self.setLayout(self.layout)
|
|
|
|
# Connect statements
|
|
self.connect(self.newBook, SIGNAL("pressed()"), getMain().addBook)
|
|
self.connect(getMain(), SIGNAL("newBook"), self.updateList)
|
|
self.connect(self.buttonBox, SIGNAL("accepted()"), self, SLOT("accept()"))
|
|
self.connect(self.buttonBox, SIGNAL("rejected()"), self, SLOT("reject()"))
|
|
|
|
# Set the title
|
|
self.setWindowTitle(self.trUtf8("Add new course"))
|
|
|
|
## Update the book list
|
|
def updateList(self):
|
|
self.booksEdit.clear()
|
|
booksDB = getBooksFromDB()
|
|
booksStringList = QStringList()
|
|
for book in booksDB:
|
|
booksStringList.append(book.getTitle())
|
|
self.booksEdit.addItems(booksStringList)
|
|
self.booksEdit.sortItems()
|
|
|
|
## Add a new book to the course
|
|
def addNewBookToCourse(self):
|
|
book = getBookWithTitleFromDB(booktitle)
|
|
self.books.append(book)
|
|
|
|
## Accept the dialog and add the specified course
|
|
def accept(self):
|
|
courseCode = unicode(self.codeEdit.text())
|
|
courseTitle = unicode(self.titleEdit.text())
|
|
courseShort = unicode(self.shortEdit.text())
|
|
courseBooks = self.booksEdit.selectedItems()
|
|
color = getRandomColor()
|
|
global colors
|
|
while color in colors:
|
|
color = getRandomColor()
|
|
colors.append(color)
|
|
books = []
|
|
for book in courseBooks:
|
|
books.append(getBookWithTitleFromDB("%s" % book.text()))
|
|
course = CourseModel(courseCode, courseTitle, courseShort, color, books)
|
|
addNewCourseToDB(courseCode, courseTitle, courseShort, color, books)
|
|
self.close()
|
|
|
|
|
|
### The course model
|
|
class CourseModel():
|
|
|
|
code = ""
|
|
title = ""
|
|
short = ""
|
|
full = ""
|
|
books = []
|
|
|
|
## Initialize the course model
|
|
def __init__(self, code, title, short, color, books):
|
|
self.code = code
|
|
self.title = title
|
|
self.short = short
|
|
self.setFull(code, title)
|
|
self.color = color
|
|
self.books = books
|
|
|
|
## Return the code of the course
|
|
def getCode(self):
|
|
return self.code
|
|
|
|
## Return the title of the course
|
|
def getTitle(self):
|
|
return self.title
|
|
|
|
## Return the short form of the course
|
|
def getShort(self):
|
|
return self.short
|
|
|
|
## Set the full form of the course
|
|
def setFull(self, code, title):
|
|
self.full = code + ' ' + title
|
|
|
|
## Return the full form of the course
|
|
def getFull(self):
|
|
return self.full
|
|
|
|
## Return the color of the course
|
|
def getColor(self):
|
|
return self.color
|
|
|
|
## Add a book to the course
|
|
def addBook(self, book):
|
|
books.append(book)
|
|
|
|
## Return the books of the course
|
|
def getBooks(self):
|
|
return self.books
|
|
|
|
|
|
### The Add Book dialog
|
|
class BookDlg(QDialog):
|
|
|
|
## Initialize the Add Book dialog
|
|
def __init__(self, parent=None):
|
|
super(BookDlg, self).__init__(parent)
|
|
|
|
# Labels
|
|
self.titleLabel = QLabel(self.trUtf8("&Title"))
|
|
self.authorLabel = QLabel(self.trUtf8("&Author"))
|
|
self.editionLabel = QLabel(self.trUtf8("&Edition"))
|
|
self.isbnLabel = QLabel(self.trUtf8("&ISBN"))
|
|
|
|
# Widgets
|
|
self.titleEdit = QLineEdit()
|
|
self.authorEdit = QLineEdit()
|
|
self.editionEdit = QSpinBox()
|
|
self.editionEdit.setRange(1, 50)
|
|
self.isbnEdit = QLineEdit()
|
|
self.buttonBox = QDialogButtonBox(QDialogButtonBox.Ok|QDialogButtonBox.Cancel)
|
|
|
|
# Buddies
|
|
self.titleLabel.setBuddy(self.titleEdit)
|
|
self.authorLabel.setBuddy(self.authorEdit)
|
|
self.editionLabel.setBuddy(self.editionEdit)
|
|
self.isbnLabel.setBuddy(self.isbnEdit)
|
|
|
|
# Layout
|
|
self.layout = QGridLayout()
|
|
self.layout.addWidget(self.titleLabel, 0, 0)
|
|
self.layout.addWidget(self.authorLabel, 1, 0)
|
|
self.layout.addWidget(self.editionLabel, 2, 0)
|
|
self.layout.addWidget(self.isbnLabel, 3, 0)
|
|
self.layout.addWidget(self.titleEdit, 0, 1)
|
|
self.layout.addWidget(self.authorEdit, 1, 1)
|
|
self.layout.addWidget(self.editionEdit, 2, 1)
|
|
self.layout.addWidget(self.isbnEdit, 3, 1)
|
|
self.layout.addWidget(self.buttonBox, 4, 0, 1, 2)
|
|
self.setLayout(self.layout)
|
|
|
|
# Connect statements
|
|
self.connect(self.buttonBox, SIGNAL("accepted()"), self, SLOT("accept()"))
|
|
self.connect(self.buttonBox, SIGNAL("rejected()"), self, SLOT("reject()"))
|
|
|
|
# Set the title
|
|
self.setWindowTitle(self.trUtf8("Add new book"))
|
|
|
|
# Accept the dialog and add the specified book
|
|
def accept(self):
|
|
bookTitle = unicode(self.titleEdit.text())
|
|
bookAuthor = unicode(self.authorEdit.text())
|
|
bookEdition = self.editionEdit.value()
|
|
bookIsbn = unicode(self.isbnEdit.text())
|
|
addNewBookToDB(bookIsbn, bookTitle, bookAuthor, bookEdition)
|
|
getMain().emit(SIGNAL("newBook"))
|
|
self.close()
|
|
|
|
|
|
### The book model
|
|
class BookModel():
|
|
|
|
title = ""
|
|
author = ""
|
|
edition = 0
|
|
isbn = ""
|
|
|
|
## Initialize the book model
|
|
def __init__(self, isbn, title, author, edition):
|
|
self.isbn = isbn
|
|
self.title = title
|
|
self.author = author
|
|
self.edition = edition
|
|
|
|
# Return the ISBN number of the book
|
|
def getIsbn(self):
|
|
return self.isbn
|
|
|
|
# Return the title of the book
|
|
def getTitle(self):
|
|
return self.title
|
|
|
|
# Return the author(s) of the book
|
|
def getAuthor(self):
|
|
return self.author
|
|
|
|
# Return the edition of the book
|
|
def getEdition(self):
|
|
return self.edition
|
|
|
|
|
|
# Database
|
|
|
|
# Initialization
|
|
|
|
## Connect to the database and return the cursor and connection
|
|
def initDB():
|
|
if 'HOME' in os.environ:
|
|
home = os.environ['HOME']
|
|
else:
|
|
home = ""
|
|
path = home+"/.egon/egon.db"
|
|
conn = sqlite.connect(path)
|
|
cursor = conn.cursor()
|
|
|
|
cursor.execute('''
|
|
SELECT name FROM sqlite_master
|
|
WHERE type='table'
|
|
ORDER BY name
|
|
''')
|
|
|
|
if cursor.fetchall() == []:
|
|
initSemesterDB(cursor)
|
|
initAssignmentDB(cursor)
|
|
initReadingDB(cursor)
|
|
initScheduleDB(cursor)
|
|
initBookDB(cursor)
|
|
initCourseDB(cursor)
|
|
initCourseUsesBook(cursor)
|
|
|
|
return cursor, conn
|
|
|
|
exitDB(conn)
|
|
|
|
# Create the database
|
|
|
|
## Create the Semester table
|
|
def initSemesterDB(cursor):
|
|
cursor.execute('''
|
|
CREATE TABLE Semester (
|
|
term TEXT,
|
|
year INT,
|
|
PRIMARY KEY (term, year)
|
|
)
|
|
''')
|
|
|
|
## Create the Assignment table
|
|
def initAssignmentDB(cursor):
|
|
cursor.execute('''
|
|
CREATE TABLE Assignment (
|
|
date DATETIME,
|
|
course TEXT,
|
|
number INT,
|
|
description TEXT,
|
|
complete TEXT,
|
|
term TEXT,
|
|
year INT,
|
|
PRIMARY KEY (course, number)
|
|
)
|
|
''')
|
|
|
|
## Create the Reading table
|
|
def initReadingDB(cursor):
|
|
cursor.execute('''
|
|
CREATE TABLE Reading (
|
|
week INT,
|
|
course TEXT,
|
|
book INT,
|
|
chapter TEXT,
|
|
pages TEXT,
|
|
done BOOLEAN,
|
|
term TEXT,
|
|
year INT,
|
|
PRIMARY KEY (week, course, book)
|
|
)
|
|
''')
|
|
|
|
## Create the Lesson table
|
|
def initScheduleDB(cursor):
|
|
cursor.execute('''
|
|
CREATE TABLE Lesson (
|
|
day TEXT,
|
|
time INT,
|
|
course TEXT,
|
|
type TEXT,
|
|
room TEXT,
|
|
term TEXT,
|
|
year INT,
|
|
PRIMARY KEY (course, day, time)
|
|
)
|
|
''')
|
|
|
|
## Create the Course table
|
|
def initCourseDB(cursor):
|
|
cursor.execute('''
|
|
CREATE TABLE Course (
|
|
code TEXT PRIMARY KEY,
|
|
title TEXT,
|
|
short TEXT,
|
|
red INT,
|
|
green INT,
|
|
blue INT
|
|
)
|
|
''')
|
|
|
|
## Create the Book table
|
|
def initBookDB(cursor):
|
|
cursor.execute('''
|
|
CREATE TABLE Book (
|
|
isbn TEXT PRIMARY KEY,
|
|
title TEXT,
|
|
author TEXT,
|
|
edition INTEGER
|
|
)
|
|
''')
|
|
|
|
## Create the Course-Book relation
|
|
def initCourseUsesBook(cursor):
|
|
cursor.execute('''
|
|
CREATE TABLE CourseUsesBook (
|
|
courseCode TEXT,
|
|
bookIsbn TEXT,
|
|
PRIMARY KEY (courseCode, bookIsbn)
|
|
)
|
|
''')
|
|
|
|
# Add things to the database
|
|
|
|
## Add new semester to the database
|
|
def addNewSemesterToDB(term, year):
|
|
cursor, conn = initDB()
|
|
|
|
cursor.execute('''
|
|
INSERT INTO Semester (term, year)
|
|
VALUES (?, ?)
|
|
''', (term, year))
|
|
|
|
exitDB(conn)
|
|
|
|
## Add new assignment to the database
|
|
def addNewAssignmentToDB(semester, datetime, course, number, description, complete):
|
|
cursor, conn = initDB()
|
|
|
|
day = datetime.date().day()
|
|
month = datetime.date().month()
|
|
year = datetime.date().year()
|
|
hour = datetime.time().hour()
|
|
minute = datetime.time().minute()
|
|
timestring = "%02i-%02i-%02i %02i:%02i" % (year, month, day, hour, minute)
|
|
term = "%s" % semester.getTerm()
|
|
year = semester.getYear()
|
|
|
|
cursor.execute('''
|
|
INSERT INTO Assignment (date, course, number, description, complete, term, year)
|
|
VALUES (datetime(?), ?, ?, ?, ?, ?, ?)
|
|
''', (timestring, course.getCode(), number, description, complete, term, year))
|
|
|
|
exitDB(conn)
|
|
|
|
## Add new reading to the database
|
|
def addNewReadingToDB(semester, week, course, book, chapter, pages, done):
|
|
cursor, conn = initDB()
|
|
|
|
term = "%s" % semester.getTerm()
|
|
year = semester.getYear()
|
|
|
|
cursor.execute('''
|
|
INSERT INTO Reading (week, course, book, chapter, pages, done, term, year)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?)
|
|
''', (week, course.getCode(), book.getIsbn(), chapter, pages, done, term, year))
|
|
|
|
exitDB(conn)
|
|
|
|
## Add new lesson to the database
|
|
def addNewLessonToDB(semester, day, time, course, type, room):
|
|
cursor, conn = initDB()
|
|
|
|
term = "%s" % semester.getTerm()
|
|
year = semester.getYear()
|
|
|
|
cursor.execute('''
|
|
INSERT INTO Lesson (day, time, course, type, room, term, year)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?)
|
|
''', (day, time, course.getCode(), type, room, term, year))
|
|
|
|
exitDB(conn)
|
|
|
|
## Add new course to the database
|
|
def addNewCourseToDB(code, title, short, color, books):
|
|
cursor, conn = initDB()
|
|
|
|
red = color.red()
|
|
green = color.green()
|
|
blue = color.blue()
|
|
|
|
cursor.execute('''
|
|
INSERT INTO Course (code, title, short, red, green, blue)
|
|
VALUES (?, ?, ?, ?, ?, ?)
|
|
''', (code, title, short, red, green, blue))
|
|
|
|
for book in books:
|
|
cursor.execute('''
|
|
INSERT INTO CourseUsesBook (courseCode, bookIsbn)
|
|
VALUES (?, ?)
|
|
''', (code, book.getIsbn()))
|
|
|
|
exitDB(conn)
|
|
|
|
## Add new book to the database
|
|
def addNewBookToDB(isbn, title, author, edition):
|
|
cursor, conn = initDB()
|
|
|
|
cursor.execute('''
|
|
INSERT INTO Book
|
|
VALUES (?, ?, ?, ?)
|
|
''', (isbn, title, author, edition))
|
|
|
|
exitDB(conn)
|
|
|
|
# Get things from the database
|
|
|
|
## Get all the semesters form the database
|
|
def getSemestersFromDB():
|
|
cursor, conn = initDB()
|
|
|
|
cursor.execute('''
|
|
SELECT *
|
|
FROM Semester
|
|
''')
|
|
|
|
semesters = []
|
|
for row in cursor.fetchall():
|
|
semesters.append(SemesterModel(row[0], row[1]))
|
|
|
|
exitDB(conn)
|
|
|
|
return semesters
|
|
|
|
## Get the assignments of the specified semester from the database
|
|
def getAssignmentsFromDB(semester):
|
|
cursor, conn = initDB()
|
|
|
|
term = "%s" % semester.getTerm()
|
|
year = (semester.getYear())
|
|
|
|
cursor.execute('''
|
|
SELECT *
|
|
FROM Assignment
|
|
WHERE term = ?
|
|
AND year = ?
|
|
''', (term, year))
|
|
|
|
assignments = []
|
|
for row in cursor.fetchall():
|
|
assignments.append(AssignmentModel(getQDateTime(row[0]), getCourseFromDB(row[1]), row[2], row[3], row[4]))
|
|
|
|
exitDB(conn)
|
|
|
|
return assignments
|
|
|
|
## Get the readings of the specified semester from the database
|
|
def getReadingsFromDB(semester):
|
|
cursor, conn = initDB()
|
|
|
|
term = "%s" % semester.getTerm()
|
|
year = semester.getYear()
|
|
|
|
cursor.execute('''
|
|
SELECT *
|
|
FROM Reading
|
|
WHERE term = ?
|
|
AND year = ?
|
|
''', (term, year))
|
|
|
|
readings = []
|
|
for row in cursor.fetchall():
|
|
readings.append(ReadingModel(row[0], getCourseFromDB(row[1]), getBookFromDB(row[2]), row[3], row[4], row[5]))
|
|
|
|
exitDB(conn)
|
|
|
|
return readings
|
|
|
|
## Get the lessons of the specified semester from the database
|
|
def getLessonsFromDB(semester):
|
|
cursor, conn = initDB()
|
|
|
|
term = "%s" % semester.getTerm()
|
|
year = semester.getYear()
|
|
|
|
cursor.execute('''
|
|
SELECT *
|
|
FROM Lesson
|
|
WHERE term = ?
|
|
AND year = ?
|
|
''', (term, year))
|
|
|
|
lessons = []
|
|
for row in cursor.fetchall():
|
|
lessons.append(ScheduleModel(row[0], row[1], getCourseFromDB(row[2]), row[3], row[4]))
|
|
|
|
exitDB(conn)
|
|
|
|
return lessons
|
|
|
|
## Get all the courses from the database
|
|
def getCoursesFromDB():
|
|
cursor, conn = initDB()
|
|
|
|
cursor.execute('''
|
|
SELECT *
|
|
FROM Course
|
|
''')
|
|
|
|
courses = []
|
|
for row in cursor.fetchall():
|
|
courses.append(CourseModel(row[0], row[1], row[2], QColor(row[3], row[4], row[5]), []))
|
|
|
|
for course in courses:
|
|
cursor.execute('''
|
|
SELECT bookIsbn
|
|
FROM CourseUsesBook
|
|
WHERE courseCode = ?
|
|
''', (course.getCode(),))
|
|
fetched = cursor.fetchall()
|
|
for fetchedRow in fetched:
|
|
cursor.execute('''
|
|
SELECT *
|
|
FROM Book
|
|
WHERE isbn = ?
|
|
''', (fetchedRow[0],))
|
|
for row in cursor:
|
|
course.addBook(BookModel(row[0], row[1], row[2], row[3]))
|
|
|
|
return courses
|
|
|
|
## Get the course specified by the course code from the database
|
|
def getCourseFromDB(courseCode):
|
|
cursor, conn = initDB()
|
|
|
|
cursor.execute('''
|
|
SELECT *
|
|
FROM Course
|
|
WHERE code = ?
|
|
''', (courseCode,))
|
|
|
|
course = None
|
|
|
|
for row in cursor.fetchall():
|
|
course = CourseModel(row[0], row[1], row[2], QColor(row[3], row[4], row[5]), [])
|
|
|
|
cursor.execute('''
|
|
SELECT bookIsbn
|
|
FROM CourseUsesBook
|
|
WHERE courseCode = ?
|
|
''', (courseCode,))
|
|
fetched = cursor.fetchall()
|
|
for fetchedRow in fetched:
|
|
cursor.execute('''
|
|
SELECT *
|
|
FROM Book
|
|
WHERE isbn = ?
|
|
''', (fetchedRow[0],))
|
|
for row in cursor:
|
|
course.addBook(BookModel(row[0], row[1], row[2], row[3]))
|
|
|
|
exitDB(conn)
|
|
|
|
return course
|
|
|
|
## Get all the books from the database
|
|
def getBooksFromDB():
|
|
cursor, conn = initDB()
|
|
|
|
cursor.execute('''
|
|
SELECT *
|
|
FROM Book
|
|
''')
|
|
|
|
books = []
|
|
for row in cursor.fetchall():
|
|
books.append(BookModel(row[0], row[1], row[2], row[3]))
|
|
|
|
exitDB(conn)
|
|
|
|
return books
|
|
|
|
## Get the book specified by the ISBN number from the database
|
|
def getBookFromDB(isbn):
|
|
cursor, conn = initDB()
|
|
|
|
cursor.execute('''
|
|
SELECT *
|
|
FROM Book
|
|
WHERE isbn = ?
|
|
''', (isbn,))
|
|
|
|
for row in cursor.fetchall():
|
|
book = BookModel(row[0], row[1], row[2], row[3])
|
|
|
|
exitDB(conn)
|
|
|
|
return book
|
|
|
|
## Get the book specified by the title from the database
|
|
def getBookWithTitleFromDB(booktitle):
|
|
cursor, conn = initDB()
|
|
|
|
book = "%s" % booktitle
|
|
|
|
cursor.execute('''
|
|
SELECT *
|
|
FROM Book
|
|
WHERE title = ?
|
|
''', (book,))
|
|
|
|
for row in cursor.fetchall():
|
|
book = BookModel(row[0], row[1], row[2], row[3])
|
|
|
|
exitDB(conn)
|
|
|
|
return book
|
|
|
|
# Update things in the database
|
|
|
|
## Update the completion level of the specified assignment
|
|
def updateAssignmentCompletion(coursecode, num, completion):
|
|
cursor, conn = initDB()
|
|
|
|
complete = "%s" % completion
|
|
course = "%s" % coursecode
|
|
number = (num.toInt())[0]
|
|
|
|
cursor.execute('''
|
|
UPDATE Assignment
|
|
SET complete = ?
|
|
WHERE course = ?
|
|
AND number = ?
|
|
''', (complete, course, number))
|
|
|
|
exitDB(conn)
|
|
|
|
## Update whether the specified reading is done or not
|
|
def updateReadingDone(week, coursecode, bookisbn, done):
|
|
cursor, conn = initDB()
|
|
|
|
course = "%s" % coursecode
|
|
book = "%s" % bookisbn
|
|
|
|
cursor.execute('''
|
|
UPDATE Reading
|
|
SET done = ?
|
|
WHERE week = ?
|
|
AND course = ?
|
|
AND book = ?
|
|
''', (done, week, course, book))
|
|
|
|
exitDB(conn)
|
|
|
|
# Remove things from the database
|
|
|
|
## Remove the specified assignment from the database
|
|
def removeAssignmentFromDB(coursecode, num):
|
|
cursor, conn = initDB()
|
|
|
|
course = "%s" % coursecode
|
|
number = (num.toInt())[0]
|
|
|
|
cursor.execute('''
|
|
DELETE
|
|
FROM Assignment
|
|
WHERE course = ?
|
|
AND number = ?
|
|
''', (course, number))
|
|
|
|
exitDB(conn)
|
|
|
|
## Remove the specified reading from the database
|
|
def removeReadingFromDB(week, coursecode, bookisbn):
|
|
cursor, conn = initDB()
|
|
|
|
course = "%s" % coursecode
|
|
book = "%s" % bookisbn
|
|
|
|
cursor.execute('''
|
|
DELETE
|
|
FROM Reading
|
|
WHERE week = ?
|
|
AND course = ?
|
|
AND book = ?
|
|
''', (week, course, book))
|
|
|
|
exitDB(conn)
|
|
|
|
## Remove the specified lesson from the database
|
|
def removeLessonFromDB(daystring, coursecode, fromTime):
|
|
cursor, conn = initDB()
|
|
|
|
day = "%s" % daystring
|
|
course = "%s" % coursecode
|
|
time = "%s" % fromTime
|
|
|
|
cursor.execute('''
|
|
DELETE
|
|
FROM Lesson
|
|
WHERE day = ?
|
|
AND course = ?
|
|
AND time = ?
|
|
''', (day, course, time))
|
|
|
|
exitDB(conn)
|
|
|
|
# Exit the database
|
|
|
|
## Commit and close the connection
|
|
def exitDB(conn):
|
|
conn.commit()
|
|
conn.close()
|
|
|
|
# Course
|
|
|
|
## Get the course code from the full name of the course
|
|
def getCourseCode(courseFull):
|
|
course = courseFull.split(' ')
|
|
return course[0]
|
|
|
|
## Add a new course to the list of courses
|
|
def addNewCourse(course):
|
|
courses.append(course)
|
|
addNewCourseToDB(course.getCode(), course.getTitle(), course.getShort(), course.getColor())
|
|
addNewCourseString(course)
|
|
|
|
## Return the list of courses
|
|
def getCourses():
|
|
global courses
|
|
return courses
|
|
|
|
## Add the course as a course string
|
|
def addNewCourseString(course):
|
|
global coursesString
|
|
coursesString.append(course.getFull())
|
|
|
|
## Make the courses string list and return it
|
|
def makeCoursesString():
|
|
emptyCourses()
|
|
cs = getCoursesFromDB()
|
|
if cs:
|
|
for c in cs:
|
|
addNewCourseString(c)
|
|
s = getCoursesString()
|
|
return s
|
|
|
|
## Return the courses string list
|
|
def getCoursesString():
|
|
global coursesString
|
|
return coursesString
|
|
|
|
## Empty the courses list and the courses string list
|
|
def emptyCourses():
|
|
global courses
|
|
global coursesString
|
|
courses = []
|
|
coursesString = []
|
|
|
|
# Book
|
|
|
|
## Add a new book to the list of books
|
|
def addNewBook(book):
|
|
books.append(book)
|
|
addNewBookToDB(book.getISBN(), book.getTitle(), book.getAuthor(), book.getEdition(), book.getCourse())
|
|
addNewBookString(book)
|
|
|
|
## Return the list of books
|
|
def getBooks():
|
|
global books
|
|
return books
|
|
|
|
## Add the book as a book string
|
|
def addNewBookString(book):
|
|
global booksString
|
|
booksString.append(book.getTitle())
|
|
|
|
## Make the books string list and return it
|
|
def makeBooksString():
|
|
emptyBooks()
|
|
bs = getBooksFromDB()
|
|
if bs:
|
|
for b in bs:
|
|
addNewBookString(b)
|
|
s = getBooksString()
|
|
return s
|
|
|
|
## Return the books string list
|
|
def getBooksString():
|
|
global booksString
|
|
return booksString
|
|
|
|
## Empty the books list and the books string list
|
|
def emptyBooks():
|
|
global books
|
|
global booksString
|
|
books = []
|
|
booksString = []
|
|
|
|
# Color
|
|
|
|
## Return a random color, RGB
|
|
def getRandomColor():
|
|
return QColor(getRandomColorPart(), getRandomColorPart(), getRandomColorPart())
|
|
|
|
## Return a random number between 0 and 255
|
|
def getRandomColorPart():
|
|
return random.random()*256
|
|
|
|
# General
|
|
|
|
## Convert a SQL timestamp to a QDateTime object
|
|
def getQDateTime(timestamp):
|
|
if not timestamp:
|
|
return None
|
|
datetimeList = timestamp.split()
|
|
dateString = datetimeList[0]
|
|
timeString = datetimeList[1]
|
|
dateList = dateString.split('-')
|
|
timeList = timeString.split(':')
|
|
year = string.atoi(dateList[0])
|
|
month = string.atoi(dateList[1])
|
|
day = string.atoi(dateList[2])
|
|
hour = string.atoi(timeList[0])
|
|
minute = string.atoi(timeList[1])
|
|
date = QDate(year, month, day)
|
|
time = QTime(hour, minute)
|
|
datetime = QDateTime(date, time)
|
|
return datetime
|
|
|
|
## Return the main window
|
|
def getMain():
|
|
global main
|
|
return main
|
|
|
|
## Run the program
|
|
def main():
|
|
app = QApplication(sys.argv)
|
|
form = MainWindow()
|
|
app.setOrganizationName("PVV")
|
|
app.setOrganizationDomain("pvv.ntnu.no")
|
|
app.setApplicationName(form.title)
|
|
form.show()
|
|
app.exec_()
|
|
|
|
|
|
main()
|
|
#initNewDB()
|