def updateStudent(self, studentId: int, name: str, group: int):
"""
Updates the student data
"""
student = self.findStudent(studentId)
newStudent = copy(student)
newStudent.setName(name)
newStudent.setGroup(group)
StudentValidator.validateStudent(newStudent)
self.__studentRepository.updateItem(newStudent)
self.__changesStack.beginCommit()
self.__changesStack.addChange(ChangesStack.ItemRemoved(student))
self.__changesStack.addChange(ChangesStack.ItemAdded(newStudent))
self.__changesStack.endCommit()
def updateAssignment(self, assignmentId: int, description: str,
deadline: datetime.date):
"""
Updates the assignment data
"""
assignment = self.findAssignment(assignmentId)
newAssignment = copy(assignment)
newAssignment.setDescription(description)
newAssignment.setDeadline(deadline)
AssignmentValidator.validateAssignment(newAssignment)
self.__assignmentRepository.updateItem(newAssignment)
self.__changesStack.beginCommit()
self.__changesStack.addChange(ChangesStack.ItemRemoved(assignment))
self.__changesStack.addChange(ChangesStack.ItemAdded(newAssignment))
self.__changesStack.endCommit()
def __init__(self, repositoryWrapper: RepositoryWrapper,
currentDate: date):
self.__repositoryWrapper = repositoryWrapper
self.__changesStack = ChangesStack(self)
studentRepository = repositoryWrapper.getRepository(Student)
gradeRepository = repositoryWrapper.getRepository(Grade)
assignmentRepository = repositoryWrapper.getRepository(Assignment)
self.__studentController = StudentController(studentRepository,
self.__changesStack,
self.cascadeDelete)
self.__assignmentController = AssignmentController(
repositoryWrapper.getRepository(Assignment), self.__changesStack,
self.cascadeDelete)
self.__gradeController = GradeController(studentRepository,
gradeRepository,
assignmentRepository,
currentDate,
self.__changesStack)
def addStudent(self, studentId: int, name: str, group: int) -> Student:
"""
Adds a student to the repository
"""
student = Student(studentId, name, group)
StudentValidator.validateStudent(student)
self.__studentRepository.addItem(student)
self.__changesStack.addChange(ChangesStack.ItemAdded(student),
newCommit=True)
return student
def removeAssignment(self, assignmentId: int):
"""
Removes an assignment from the repository
"""
assignment = self.findAssignment(assignmentId)
self.__assignmentRepository.deleteItem(assignment)
self.__changesStack.beginCommit()
self.__changesStack.addChange(ChangesStack.ItemRemoved(assignment))
if self.__deleteCallback is not None:
self.__deleteCallback(assignment)
else:
self.__changesStack.endCommit()
def addAssignment(self, assignmentId: int, description: str,
deadline: datetime.date) -> Assignment:
"""
Adds an assignment to the repository
"""
assignment = Assignment(assignmentId, description, deadline)
AssignmentValidator.validateAssignment(assignment)
self.__assignmentRepository.addItem(assignment)
self.__changesStack.addChange(ChangesStack.ItemAdded(assignment),
newCommit=True)
return assignment
def cascadeDelete(self, item):
if type(item) is Student or Assignment:
gradeRepository = self.__repositoryWrapper.getRepository(Grade)
gradeList = gradeRepository.getItems()
linkedGrades = [
grade for grade in gradeList
if self.__gradeLinked(grade, item)
]
for grade in linkedGrades:
self.__changesStack.addChange(ChangesStack.ItemRemoved(grade))
gradeRepository.deleteItem(grade)
self.__changesStack.endCommit()
def grade(self, studentId: int, assignmentId: int, grade: int):
"""
Grades the student at the given assignment
:param studentId: The ID of the student
:param assignmentId: The ID of the assignment
:param grade: The grade of the assignment, an integer between 1 and 10
:raises InvalidGrade: If an invalid grade is given
:raises InvalidAssignmentId: If the student has not been given the assignment
"""
self.findStudent(studentId)
self.findAssignment(assignmentId)
gradeObject = self.validateGrading(studentId, assignmentId)
newGradeObject = copy(gradeObject)
newGradeObject.setGrade(grade)
GradeValidator.validateGrade(newGradeObject)
self.__gradeRepository.updateItem(newGradeObject)
self.__changesStack.beginCommit()
self.__changesStack.addChange(ChangesStack.ItemRemoved(gradeObject))
self.__changesStack.addChange(ChangesStack.ItemAdded(newGradeObject))
self.__changesStack.endCommit()
def removeStudent(self, studentId: int):
"""
Removes a student from the repository
"""
student = self.findStudent(studentId)
self.__studentRepository.deleteItem(student)
self.__changesStack.beginCommit()
self.__changesStack.addChange(ChangesStack.ItemRemoved(student))
if self.__deleteCallback is not None:
self.__deleteCallback(student)
else:
self.__changesStack.endCommit()
def assignToStudent(self, studentId, assignmentId, newCommit=True) -> Grade:
"""
Gives an assignment to a student
"""
self.findStudent(studentId)
self.findAssignment(assignmentId)
grade = Grade(studentId, assignmentId)
self.__gradeRepository.addItem(grade)
if newCommit:
self.__changesStack.beginCommit()
self.__changesStack.addChange(ChangesStack.ItemAdded(grade))
if newCommit:
self.__changesStack.endCommit()
return grade
class ControllerWrapper(ChangesHandler):
def __init__(self, repositoryWrapper: RepositoryWrapper,
currentDate: date):
self.__repositoryWrapper = repositoryWrapper
self.__changesStack = ChangesStack(self)
studentRepository = repositoryWrapper.getRepository(Student)
gradeRepository = repositoryWrapper.getRepository(Grade)
assignmentRepository = repositoryWrapper.getRepository(Assignment)
self.__studentController = StudentController(studentRepository,
self.__changesStack,
self.cascadeDelete)
self.__assignmentController = AssignmentController(
repositoryWrapper.getRepository(Assignment), self.__changesStack,
self.cascadeDelete)
self.__gradeController = GradeController(studentRepository,
gradeRepository,
assignmentRepository,
currentDate,
self.__changesStack)
def getStudentController(self) -> StudentController:
return self.__studentController
def getGradeController(self) -> GradeController:
return self.__gradeController
def getAssignmentController(self) -> AssignmentController:
return self.__assignmentController
def cascadeDelete(self, item):
if type(item) is Student or Assignment:
gradeRepository = self.__repositoryWrapper.getRepository(Grade)
gradeList = gradeRepository.getItems()
linkedGrades = [
grade for grade in gradeList
if self.__gradeLinked(grade, item)
]
for grade in linkedGrades:
self.__changesStack.addChange(ChangesStack.ItemRemoved(grade))
gradeRepository.deleteItem(grade)
self.__changesStack.endCommit()
@staticmethod
def __gradeLinked(grade: Grade, item):
if type(item) is Student:
return grade.getStudentId() == item.getStudentId()
elif type(item) is Assignment:
return grade.getAssignmentId() == item.getAssignmentId()
def populateRepository(self):
"""
Adds default data to the repository
"""
self.__studentController.addRandomStudents(50)
self.__assignmentController.addRandomAssignments(50)
self.__gradeController.addRandomGrades(40, 40, 50)
self.clearHistory()
def handleChanges(self, changesList: List[ChangesStack.Change], reverse):
"""
Handles changes provided by the ChangesStack
"""
if reverse:
functionDict = {
ChangesStack.ItemAdded: self.removeItem,
ChangesStack.ItemRemoved: self.addItem
}
iteratedList = reversed(changesList)
else:
functionDict = {
ChangesStack.ItemAdded: self.addItem,
ChangesStack.ItemRemoved: self.removeItem
}
iteratedList = changesList
for change in iteratedList:
itemType: Type[Union[ChangesStack.ItemAdded,
ChangesStack.ItemRemoved]] = type(change)
item = change.getItem()
functionDict[itemType](item)
def addItem(self, item):
self.__repositoryWrapper.getRepository(type(item)).addItem(item)
def removeItem(self, item):
self.__repositoryWrapper.getRepository(type(item)).deleteItem(item)
def clearHistory(self):
self.__changesStack.clearStack()
def undo(self):
"""
Undoes the last operation
"""
return self.__changesStack.undo()
def redo(self):
"""
Reverses the last undo operation
"""
return self.__changesStack.redo()