def removeGrade(self, studIdentifier, discIdentifier, gradeValue):
"""
Sterge o nota pentru studentul studIdentifier, la disciplina discIdentifier cu valoarea gradeValue
:param studIdentifier: id-ul studentului - string
:param discIdentifier: id-ul disciplinei - string
:param gradeValue: valoarea notei - float
:raise: InvalidIDError - daca id-ul studentului sau al disciplinei este invalid
:raise: InvalidGradeError - daca valoarea notei este invalida
:raise: NonExistentIDError - daca disciplina cu id-ul dat nu exista
"""
try:
self.__studValidator.validateID(studIdentifier)
self.__discValidator.validateID(discIdentifier)
except InvalidIDError as err:
raise InvalidIDError(str(err))
try:
self.__gradeValidator.validateGrade(gradeValue)
except InvalidGradeError as err:
raise InvalidGradeError(str(err))
try:
self.__catalogue.findDisciplineByID(discIdentifier)
self.__catalogue.findStudentByID(studIdentifier)
except NonExistentIDError as err:
raise NonExistentIDError(str(err))
try:
self.__gradesRepo.removeGrade(
Grade(gradeValue, studIdentifier, discIdentifier))
except NonExistentGradeError as err:
raise NonExistentGradeError(str(err))
def getStudentsFromDiscipline(self, disciplineID):
"""
Returneaza toti studentii cu notele lor de la o anumita disciplina
:param disciplineID: id-ul disciplinei - string
:return studentGradesDTOS: lista de dto-uri continand studentii si notele lor la o materie
"""
try:
self.__discValidator.validateID(disciplineID)
except InvalidIDError as err:
raise InvalidIDError(str(err))
try:
self.__catalogue.findDisciplineByID(disciplineID)
except NonExistentIDError as err:
raise NonExistentIDError(str(err))
studentGradesDTOS = []
discipline = self.__catalogue.findDisciplineByID(disciplineID)
for student in self.__catalogue.getStudents():
if discipline in student.getDisciplines():
discGrades = self.__gradesRepo.getDisciplineGrades(
student.getID(), disciplineID)
average = self.__gradesRepo.getAverageForDisc(
student.getID(), disciplineID)
newDto = StudentGradesDTO(student, discGrades, average)
studentGradesDTOS.append(newDto)
if len(studentGradesDTOS) == 0:
raise NonExistentStudentError(
"Nu exista studenti inrolati la disciplina respectiva!\n")
return studentGradesDTOS
def validateID(self, id):
"""
Valideaza id-ul id
:param id: string - id
raise InvalidIDError- daca id-ul este invalid
"""
if not id.isnumeric():
raise InvalidIDError("ID-ul studentului este invalid!\n")
def validateID(self, id):
"""
Validaeza id-ul unei discipline
:param id: id- string
raise InvalidIDError - daca id-ul nu este valid
"""
if not id.isnumeric():
raise InvalidIDError("ID-ul disciplinei este invalid!\n")
def findStudentByID(self, idStudent):
try:
self.__validator.validateID(idStudent)
except InvalidIDError as err:
raise InvalidIDError(str(err))
try:
student = self.__catalogue.findStudentByID(idStudent)
except NonExistentIDError as err:
raise NonExistentIDError(str(err))
return student
def selectOptionals(self, IDStudent, identifier):
"""Selecteaza disciplina optionala cu identificata prin identifier"""
try:
self.__validator.validateID(identifier)
except InvalidIDError as err:
raise InvalidIDError(str(err))
try:
self.__catalogue.selectOptionalsByID(IDStudent, identifier)
except NonExistentIDError as err:
raise NonExistentIDError(str(err))
def findDiscipline(self, identifier):
"""Returneaza disciplina cu identificatorul identifier
identifier - string
return discipline - disciplina corespunzatoare Discipline()
"""
try:
self.__validator.validateID(identifier)
except InvalidIDError as err:
raise InvalidIDError(str(err))
try:
discipline = self.__catalogue.findDisciplineByID(identifier)
except NonExistentIDError as err:
raise NonExistentIDError(str(err))
return discipline
def modifyID(self, oldID, newID):
"""
Modifica id-ul unui student in newID
:param oldID: id-ul curent al studentului - string
:param newID: noul id al studentului - string
raise InvalidIDError - daca newID este invalid
"""
try:
self.__validator.validateID(newID)
except InvalidIDError:
raise InvalidIDError("ID-ul nou este invalid!\n")
try:
#student = self.__catalogue.findStudentByID(oldID)
self.__catalogue.modifyStudentID(oldID, newID)
except NonExistentIDError as err:
raise NonExistentIDError(str(err))
def removeOptionals(self, IDStudent, identifier):
"""
Sterge disciplina optionala identificata cu identifier pentru studentul IDStudent
:param IDStudent: id-ul studentului - string
:param identifier: identificatorul disciplinei - string
raise NonExistentIDError daca studentul sau disciplina cu id-ul dat nu exista
raise InvalidIDError- daca id-ul disciplinei este invalid
"""
try:
self.__validator.validateID(identifier)
except InvalidIDError as err:
raise InvalidIDError(str(err))
try:
self.__catalogue.removeOptionalsByID(IDStudent, identifier)
except NonExistentIDError as err:
raise NonExistentIDError(str(err))
def modifyID(self, oldID, newID):
"""
Modifica id-ul disciplinei din oldID in newID
:param oldID: id-ul disciplinei - string
:param newID: noul id al disciplinei - string
raise InvalidIDError daca newID este invalid
"""
try:
self.__validator.validateID(newID)
except InvalidIDError as err:
raise InvalidIDError(str(err))
try:
#discipline = self.__catalogue.findDisciplineByID(oldID)
self.__catalogue.modifyDiscID(oldID, newID)
except NonExistentIDError as err:
raise NonExistentIDError(str(err))
def getStudentInfoByID(self, studentID):
try:
self.__studValidator.validateID(studentID)
except InvalidIDError as err:
raise InvalidIDError(str(err))
try:
student = self.__catalogue.findStudentByID(studentID)
except NonExistentStudentError as err:
raise NonExistentStudentError(str(err))
grades = self.__gradesRepo.getAllForStudent(studentID)
studentPrint = StudentPrintDTO(student, student.getDisciplines(),
grades,
self.__gradesRepo.getAverage(studentID))
return studentPrint
def addGrade(self, studIdentifier, discIdentifier, gradeValue):
"""
Adauga o nota pentru studentul cu id-ul studIdentifier, la disciplina cu id-ul discIdentifier
avand valoarea gradeValue in lista de note
:param studIdentifier: id-ul studentului - string
:param discIdentifier: id-ul disciplinei - string
:param gradeValue: nota - float
:raise:InvalidGradeError - daca valoarea notei este invalida
:raise: InvalidIDError - daca id-ul studentului sau al disciplinei este invalid
:raise: NonExistentIDError - daca disciplina cu id-ul dat nu exista
"""
try:
self.__gradeValidator.validateGrade(gradeValue)
except InvalidGradeError as err:
raise InvalidGradeError(str(err))
try:
self.__studValidator.validateID(studIdentifier)
self.__discValidator.validateID(discIdentifier)
except InvalidIDError as err:
raise InvalidIDError(str(err))
try:
discipline = self.__catalogue.findDisciplineByID(discIdentifier)
student = self.__catalogue.findStudentByID(studIdentifier)
except NonExistentIDError as err:
raise NonExistentIDError(str(err))
if discipline.getIsOptional():
if discipline not in student.getOptionals():
raise NonExistentIDError(
"Disciplina cu ID-ul dat nu se afla in lista disciplinelor!\n"
)
grade = Grade(gradeValue, studIdentifier, discIdentifier)
self.__gradesRepo.addGrade(grade)
def getStudentsFromDisciplineSortedByAvg(self, disciplineID):
"""
Returneaza toti studentii cu notele lor de la o anumita disciplina
:param disciplineID: id-ul disciplinei - string
:return studentGradesDTOS: lista de dto-uri continand studentii si notele lor la o materie
sortata dupa medie
"""
try:
studentGradesDTOS = self.getStudentsFromDiscipline(disciplineID)
except InvalidIDError as err:
raise InvalidIDError(str(err))
except NonExistentStudentError as err:
raise NonExistentStudentError(str(err))
except NonExistentIDError as err:
raise NonExistentIDError(str(err))
mergeSort(studentGradesDTOS,
0,
len(studentGradesDTOS),
cmp=studentDTONameGrade,
reverse=True)
#bingoSort(studentGradesDTOS, key=lambda dto: dto, reverse=True, cmp=studentDTONameGrade)
return studentGradesDTOS