def testOuder():
student1 = Student("Naam1", "Voornaam1", 199001, "NMCT", 1990)
student2 = Student("Naam2", "Voornaam2", 199002, "NMCT", 1990)
student3 = Student("Naam3", "Voornaam3", 199003, "NMCT", 1990)
ouder1 = Ouder("Oudernaam1", "Oudervoornaam1", 1970)
ouder1.voeg_student_toe(student1)
ouder1.voeg_student_toe(student2)
ouder1.voeg_student_toe(student3)
print(ouder1.geef_info_studenten())
print(ouder1)
def example1(self):
"""
:return:
"""
serializer = StudentPDFSerializer()
students = [
Student(1, "foo", "bar", datetime.date(1991, 10, 10), "ai",
"*****@*****.**"),
Student(2, "edu", "tilos", datetime.date(1992, 10, 10), "ai",
"*****@*****.**"),
Student(3, "leo", "messi", datetime.date(1993, 10, 10), "ai",
"*****@*****.**")
]
serializer.exportAsPDFToFile(students)
def convertJSONToList(itemType: type, jsonObject):
list = json.loads(jsonObject)
newList = []
newItem = None
for item in list:
if itemType is Student:
newItem = Student(
TypeParser.parseInt(item["studentId"], InvalidStudentId),
item["name"],
TypeParser.parseInt(item["group"], InvalidStudentGroup))
StudentValidator.validateStudent(newItem)
elif itemType is Grade:
newItem = Grade(
TypeParser.parseInt(item["studentId"], InvalidStudentId),
TypeParser.parseInt(item["assignmentId"],
InvalidAssignmentId), item["grade"])
GradeValidator.validateGrade(newItem)
elif itemType is Assignment:
newItem = Assignment(
TypeParser.parseInt(item["assignmentId"],
InvalidAssignmentId),
item["description"],
TypeParser.parseDate(item["deadline"],
InvalidAssignmentDeadline))
AssignmentValidator.validateAssignment(newItem)
newList.append(newItem)
return newList
def onBtnSaveClicked(self):
"""
Slot for signal-slot handling .
Gets invoked when btnSave is clicked.
:return:
"""
try:
errors = []
enrolmentNumber = self.editEnrolmentNumber.text()
firstName = self.editFirstName.text()
lastName = self.editLastName.text()
dob = self.editDob.text()
faculty = self.editFaculty.text()
email = self.editEmail.text()
if not self.validator.validateEnrolmentNumber(enrolmentNumber):
errors.append("enrolmentNumber is incorrect.")
if not self.validator.validateFirstName(firstName):
errors.append("firstName is incorrect.")
if not self.validator.validateLastName(lastName):
errors.append("lastName is incorrect.")
if not self.validator.validateDob(dob):
errors.append("DateOfBirth is incorrect.")
if not self.validator.validateFaculty(faculty):
errors.append("Faculty is incorrect.")
if not self.validator.validateEmail(email):
errors.append("Email is incorrect.")
if len(errors) > 0:
raise Exception("\n".join(errors))
ret = self.dao.save(
Student(enrolmentNumber, firstName, lastName, dob, faculty,
email))
if ret:
raise Exception(ret)
rowPosition = self.tableWidget.rowCount()
self.tableWidget.insertRow(rowPosition)
self.tableWidget.setItem(rowPosition, 0,
QTableWidgetItem(enrolmentNumber))
self.tableWidget.setItem(rowPosition, 1,
QTableWidgetItem(firstName))
self.tableWidget.setItem(rowPosition, 2,
QTableWidgetItem(lastName))
self.tableWidget.setItem(rowPosition, 3, QTableWidgetItem(dob))
self.tableWidget.setItem(rowPosition, 4, QTableWidgetItem(faculty))
self.tableWidget.setItem(rowPosition, 5, QTableWidgetItem(email))
self.close()
except Exception as err:
QMessageBox.critical(self, "<<Error>>", str(err))
def findStudent(self, studentId: int) -> Student:
"""
Searches a student and returns it if found. Raises InvalidStudentId if not
"""
student = Student(studentId)
foundStudent = self.__studentRepository.getItem(student)
if foundStudent is None:
raise StudentIdNotFound
return foundStudent
def List():
"""Gets a list of all students (Template: student_list.html)"""
#Authorise (change who can authorise)
if not Authorization.canAccess(session.get('user'), ('admin')):
return render_template('error/no_access.html')
students = StudentModel.all()
return render_template("student_list.html", data={"students": students})
def example1(self):
"""
:return:
"""
l = [
Student(1, "foo", "bar", datetime.date(1991, 10, 10), "ai", "*****@*****.**"),
Student(2, "edu", "tilos", datetime.date(1992, 10, 10), "ai", "*****@*****.**"),
Student(3, "leo", "messi", datetime.date(1993, 10, 10), "ai", "*****@*****.**")
]
serializer = StudentXMLSerializer()
serializer.exportAsXMLToFile(l)
l2 = serializer.importFromXML()
print("<<all students>>")
for s in l2:
print(s)
def View(id):
""" Gets information for given module. """
# Verify user access
if not Authorization.canAccess(session.get('user'), ('scheduling_admin')):
return render_template('error/no_access.html')
# Get module object
module = ModuleModel.findById(id)
if not module:
return render_template('error/resource_not_found.html')
# Get leader (teacher) object
leader = TeacherModel.findById(module.getLeader())
if not module:
return render_template('error/server_error.html')
# Get teachers object
teachers = TeacherModel.all()
# Get enrolled students
students = []
enrolments = StudentModuleModel.findBy('module', id)
for enrolment in enrolments:
students.append(StudentModel.findById(enrolment.getStudent()))
# Get module sessions (+ teachers)
sessions = ModuleSessionModel.findBy('module', id)
sessions_list = []
for session2 in sessions:
sessions_list.append({
'session':
session2,
'staff':
TeacherModel.findById(session2.getStaff()),
'type':
ModuleSessionTypeModel.findById(session2.getType())
})
# Get session types
sessionTypes = ModuleSessionTypeModel.all()
return render_template('module_view.html',
data={
'module': module,
'leader': leader,
'teachers': teachers,
'students': students,
'sessionTypes': sessionTypes,
'sessions': sessions_list
})
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 example1(self):
"""
:return:
"""
dao = StudentDAOMongoImpl()
dao.drop_collection()
dao.create_collection()
l = [
Student(1, "foo", "bar", datetime.date(1991, 10, 10), "ai",
"*****@*****.**"),
Student(2, "edu", "tilos", datetime.date(1992, 10, 10), "ai",
"*****@*****.**"),
Student(3, "leo", "messi", datetime.date(1993, 10, 10), "ai",
"*****@*****.**")
]
for s in l:
dao.save(s)
all = dao.find_all()
print("<<all students>>")
for s in all:
print(s)
# update
dao.update(
1,
Student(1, "new_foo", "new_bar", datetime.date(2001, 11, 11),
"its", "*****@*****.**"))
# find one
one = dao.find_by_id(1)
print("after update = {0}".format(one))
# remove one
dao.remove(1)
all = dao.find_all()
print("<<all students after remove by enrolmentNumber = 1>>")
for s in all:
print(s)
def convertTuples(tupleList: List[Tuple], itemType: type):
newList = []
newItem = None
for item in tupleList:
if itemType is Student:
newItem = Student(item[0], item[1], item[2])
elif itemType is Grade:
newItem = Grade(item[0], item[1], item[2] if item[2] != "NULL" else None)
elif itemType is Assignment:
newItem = Assignment(item[0], item[1], TypeParser.parseDate(item[2], InvalidAssignmentDeadline))
newList.append(newItem)
return newList
def map_from_list(self, data):
"""
create model.Student.Student instance from list of strings - data
:param data: list of strings
:return: model.Student.Student
"""
ret = Student()
ret.enrolmentNumber = int(data[0])
ret.firstName = data[1]
ret.lastName = data[2]
ret.dob = datetime.datetime.strptime(data[3], '%Y-%m-%d')
ret.faculty = data[4]
ret.email = data[5]
return ret
def map_rs_to_student(self, props):
"""
maps result set from mongo query into model.Student.Student
:param props: dict of strings
:return: model.Student.Student
"""
dob_str = props["dob"]
splitted = dob_str.split("-")
year, month, day = int(splitted[0]), int(splitted[1]), int(splitted[2])
dob = datetime.date(year, month , day)
return Student(int(props["enrolmentNumber"]), props["firstName"],
props["lastName"], dob , props["faculty"], props["email"])
def onBtnUpdateClicked(self):
"""
Slot for signal-slot handling .
Gets invoked when btnUpdate is clicked.
:return:
"""
try:
errors = []
enrolmentNumber = self.editEnrolmentNumber.text()
firstName = self.editFirstName.text()
lastName = self.editLastName.text()
dob = self.editDob.text()
faculty = self.editFaculty.text()
email = self.editEmail.text()
if not self.validator.validateEnrolmentNumber(enrolmentNumber):
errors.append("enrolmentNumber is incorrect.")
if not self.validator.validateFirstName(firstName):
errors.append("firstName is incorrect.")
if not self.validator.validateLastName(lastName):
errors.append("lastName is incorrect.")
if not self.validator.validateDob(dob):
errors.append("DateOfBirth is incorrect.")
if not self.validator.validateFaculty(faculty):
errors.append("Faculty is incorrect.")
if not self.validator.validateEmail(email):
errors.append("Email is incorrect.")
if len(errors) > 0:
raise Exception("\n".join(errors))
self.dao.update(
enrolmentNumber,
Student(enrolmentNumber, firstName, lastName, dob, faculty,
email))
self.selectedItems[0].setText(enrolmentNumber)
self.selectedItems[1].setText(firstName)
self.selectedItems[2].setText(lastName)
self.selectedItems[3].setText(dob)
self.selectedItems[4].setText(faculty)
self.selectedItems[5].setText(email)
self.close()
except Exception as err:
QMessageBox.critical(self, "<<Error>>", str(err))
def View(id):
"""Returns student information [+ student module enrolments]. (Template: student_view.html)"""
if not Authorization.canAccess(session.get('user'), ('admin')):
return render_template('error/no_access.html')
student = StudentModel.findById(id)
#Get Modules ?
return render_template(
"student_view.html",
data={"student": student
#Modules?
})
def map_from_json(self, data):
"""
creates model.Student.Student instance from json map - data
:param data: json map
:return: model.Student.Student
"""
enrolmentNumber = int(data['enrolmentNumber'])
firstName = data['firstName']
lastName = data['lastName']
dob = data['dob']
faculty = data['faculty']
email = data['email']
return Student(enrolmentNumber, firstName, lastName, dob, faculty,
email)
def map_from_xml(self, student_xml):
"""
creates model.Student.Student instance from xml content: student_xml
:param student_xml: xml content , which was parsed by Beautifulsoup library
:return: model.Student.Student
"""
enrolmentNumber = student_xml.attrs["enrolmentnumber"]
firstName = student_xml.find("firstname").contents[0]
lastName = student_xml.find("lastname").contents[0]
dob = student_xml.find("dob").contents[0]
faculty = student_xml.find("faculty").contents[0]
email = student_xml.find("email").contents[0]
return Student(enrolmentNumber, firstName, lastName, dob, faculty,
email)
def Update(id):
"""Updates student information """
"""(JSON) (Post variables: first_name, last_name, email, mobile_phone, password)"""
#Auth
if not Authorization.canAccess(session.get('user'), ('admin')):
return JsonResponse.unauthorized()
first_name = request.form.get('first_name')
last_name = request.form.get('last_name')
email = request.form.get('email')
mobile_phone = request.form.get('mobile_phone')
password = request.form.get('password')
if not first_name and not last_name and not email and not mobile_phone and not password:
#Bad request
return JsonResponse.badRequest({
'message':
'missing_parameters',
'nice_message':
'Please fill out new information for the student.'
})
student = StudentModel.findById(id)
#Not sure on method names
if first_name:
student.setFirstName(first_name)
if last_name:
student.setLastName(last_name)
if email:
student.setEmail(email)
if mobile_phone:
student.setMobile(mobile_phone)
#Password hashed here
if password:
salt = student.getSalt()
hashedPassword = Security.hashPassword(password, salt)
student.setPassword(hashedPassword)
try:
student.save()
except:
return JsonResponse.badRequest({'error': 'database_error'})
return JsonResponse.ok()
def add_student():
student_content = request.json
try:
token = request.headers.get('auth-token')
teacher_id = request.headers.get('_id')
validators.validate_token(token, teacher_id)
validators.validate_student(student_content)
student = Student(student_content)
student_id = dataLayer.add_student(student.to_json())
student.set_id(str(student_id))
return create_response(student.to_json(), 200)
except Exception as e:
# Logger.log(e)
return create_response(json.dumps({"err": str(e)}), 400)
def map_from_row(self, row):
"""
creates model.Student.Student instance from list of string-s: row
:param row: list of string-s
:return: model.Student.Student
"""
ret = None
try:
enrolmentNumber = int(row[0])
firstName = row[1]
lastName = row[2]
# print(row[3])
dob = row[3]
faculty = row[4]
email = row[5]
ret = Student(enrolmentNumber, firstName, lastName, dob, faculty,
email)
except Exception as err:
print(err)
return ret
def List(student_id):
"""Returns all modules for given student."""
# Verify user access
if not Authorization.canAccess(session.get('user'), ('scheduling_admin')):
return render_template('error/no_access.html')
student = StudentModel.findById(student_id)
if not student:
return render_template('error/resource_not_found.html')
module_enrolments = StudentModuleModel.findBy('student', student_id)
modules = []
module_id = []
for enrolment in module_enrolments:
Module = ModuleModel.findById(enrolment.getModule())
modules.append(Module)
module_id.append(Module.getId())
AllModules = ModuleModel.all()
Available_Modules = []
for module in AllModules:
if module.getId() not in module_id:
Available_Modules.append(module)
# get student timetable
timetable = Timetable.getStudentTimetable(student_id,
Timetable.getStartOfMonth(),
Timetable.getEndOfMonth())
return render_template('enrolment_list.html',
data={
"enroled_modules": modules,
"available_modules": Available_Modules,
"student": student,
"timetable": timetable
})
def Delete(id):
"""Deletes a Student"""
#Authorise (Change who is authorised)
if not Authorization.canAccess(session.get('user'), ('admin')):
return JsonResponse.unauthorized({
'message':
'not_access',
'nice_message':
'You do not have access to this function. Contact system administrator.'
})
#Find student and check they exist
student = StudentModel.findById(id)
if not student:
return JsonResponse.notFound({
'message': 'not_found',
'nice_message': 'Student not found.'
})
#Delete record of student
student.delete()
return JsonResponse.ok()
from model.BasePerson import BasePerson
from model.Student import Student
print()
print("~WORKING ON BasePerson class...")
person = BasePerson(name="Arthur")
person.say_hello()
student = Student(name="Aristotle", school="Greek")
student.print_school()
student.say_hello()
# this will call Java's toString() equivalent of __str__()
print(student)
direction1 = Direction(name_direction="Физмат")
"""----------------------------------------------------------------------"""
"""Учебный план"""
syllabus1 = Syllabus(start='2019', finish='2020')
print("Учебный план:", syllabus1)
print("----------------------------------------------------------------------")
"""----------------------------------------------------------------------"""
"""Класс"""
klass1 = Klas(date_set=datetime(2013, 9, 1), letter="a", direction=direction1, syllabus=syllabus1)
klass1.get_number_today()
"""----------------------------------------------------------------------"""
"""Ученики"""
student1 = Student(date=datetime(2006, 7, 16), first_name="Коваль", second_name="Александр", patronymic="Викторович")
student2 = Student(date=datetime(2006, 8, 10), first_name="Чебыкин", second_name="Роман", patronymic="Сергеевич")
klass1.add_student(student1)
klass1.add_student(student2)
print("Класс",klass1.get_number_today(), klass1.get_letter())
print(klass1)
print("----------------------------------------------------------------------")
"""----------------------------------------------------------------------"""
"""Учителя"""
teacher1 = Teacher(first_name="Иванова", second_name="Мария", patronymic="Петровна")
teacher2 = Teacher(first_name="Гунёва", second_name="Раисия", patronymic="Петровна")
"""----------------------------------------------------------------------"""
"""Предметы"""
subject1 = Subject(item_name="Математика", teacher=teacher1)
def validateStudent(student: Student):
StudentValidator.validateId(student.getStudentId())
StudentValidator.validateName(student.getName())
StudentValidator.validateGroup(student.getGroup())
def studentToStr(student: Student):
return str(
student.getStudentId()) + " - " + student.getName() + " - " + str(
student.getGroup())
def from_dict(student):
args = student
args['result'] = Student.get(id=args['result']['id'])
return args
def SessionLogin():
if 'X-App-Token' in request.headers and ApiSession.isValid(request):
return JsonResponse.ok({'token': request.headers['X-App-Token']})
userEmail = request.form.get('email')
userPassword = request.form.get('password')
userType = request.form.get('user_type')
# Step 1: Verify presence of values and validate them
if not userEmail or not userPassword or not userType:
return JsonResponse.badRequest({
'message': 'post_property_missing',
'nice_message': 'Missing POST property.'
})
if userType not in ('student', 'teacher'):
return JsonResponse.badRequest({
'message':
'invalid_user_type',
'nice_message':
'Given user type is invalid! Allowable types are: student/teacher.'
})
# Step 2: Verify password
if userType == 'student':
user = StudentModel.findBy('email', userEmail)
elif userType == 'teacher':
user = TeacherModel.findBy('email', userEmail)
else:
return JsonResponse.internalServerError({
'message':
'unexpected_user_type',
'nice_message':
'Unexpected user type. Contact system administrator.'
})
if len(user) != 1:
return JsonResponse.unauthorized({
'message':
'invalid_credentials',
'nice_message':
'Supplied credentials (email/password) are invalid.'
})
user = user[0]
salt = user.getSalt()
hashedPassword = Security.hashPassword(userPassword, salt)
if hashedPassword != user.getPassword():
return JsonResponse.unauthorized({
'message':
'invalid_credentials',
'nice_message':
'Supplied credentials (email/password) are invalid.'
})
userId = user.getId()
# Step 3: Create session
ipAddress = request.remote_addr
if Config.getValue('DEPLOYMENT') == 'heroku':
ipAddress = request.headers['X-Forwarded-For']
token = ApiSession.create(userId, userType, ipAddress,
request.headers['User-Agent'])
if token:
return JsonResponse.ok({'token': token})
return JsonResponse.internalServerError({
'message':
'session_generation_failed',
'nice_message':
'Session generation failed. Contact system administrator.'
})
def Create():
"""Creates a new student (JSON) (Post variables: first_name, last_name, email, mobile_phone)"""
#Change who is authorised
if not Authorization.canAccess(session.get('user'), ('admin')):
return JsonResponse.unauthorized({
'message':
'no_access',
'nice_message':
'You do not have access to this function. Contact system administrator.'
})
first_name = request.form.get('first_name')
last_name = request.form.get('last_name')
email = request.form.get('email')
mobile_phone = request.form.get('mobile_phone')
password = request.form.get('password')
salt = Security.generateSalt()
hashedPassword = Security.hashPassword(password, salt)
student = StudentModel()
if not first_name or not last_name or not email or not mobile_phone or not password:
return JsonResponse.badRequest({
'message':
'missing_parameters',
'nice_message':
'Please fill all fields for the new student.'
})
student.setFirstName(first_name)
student.setLastName(last_name)
student.setEmail(email)
student.setMobile(mobile_phone)
student.setPassword(hashedPassword)
student.setSalt(salt)
try:
student.save()
except:
return JsonResponse.badRequest({'error': 'database_error'})
return JsonResponse.ok()
app_conf = yaml.load(conf, Loader=yaml.FullLoader)
secret = open(app_secrets_path)
app_secret = yaml.load(secret, Loader=yaml.FullLoader)
spark = SparkSession \
.builder \
.appName("Read ingestion enterprise applications") \
.master('local[*]') \
.config("spark.mongodb.input.uri", app_secret["mongodb_config"]["uri"])\
.config("spark.mongodb.output.uri", app_secret["mongodb_config"]["uri"])\
.getOrCreate()
spark.sparkContext.setLogLevel('ERROR')
students = spark.createDataFrame(
spark.sparkContext.parallelize([
Student("Sidhartha", "Ray", "ITER", 200),
Student("Satabdi", "Ray", "CET", 100)
]))
students.show()
students\
.write\
.format("com.mongodb.spark.sql.DefaultSource")\
.mode("append")\
.option("database", app_conf["mongodb_config"]["database"])\
.option("collection", app_conf["mongodb_config"]["collection"])\
.save()
# spark-submit --packages "org.mongodb.spark:mongo-spark-connector_2.11:2.4.2" dataframe/provision/df_mongo.py
