def create_student():
parsed_data = json.loads(request.data)
if ((parsed_data['firstname'] == "") or (parsed_data['lastname'] == "")
or (parsed_data['birthdate'] == "")
or (parsed_data['grades'] == "")):
return "false"
else:
new_student = Student(parsed_data['firstname'],
parsed_data['lastname'],
parsed_data['birthdate'], parsed_data['grades'])
students.append(new_student.serialize())
return "true"
def retrieve_selected_students(session_admitted):
c, conn = connection()
c.execute(
"SELECT DISTINCT id, student_name FROM student WHERE session_admitted = %s",
session_admitted)
data = c.fetchall()
selected_students = []
for student in data:
new_student = Student(student[0], student[1])
selected_students.append(new_student.toJSON())
conn.close()
c.close()
print(selected_students)
return json.dumps(selected_students)
def create_bulk_import_nvq():
input_file = request.files.get('files')
if not input_file:
return jsonify({'error': 'CSV file is required','status': 400}), 400
try:
stream = io.StringIO(input_file.stream.read().decode("UTF8"), newline=None)
csv_input = csv.reader(stream)
if not csv_input:
return jsonify({'error': 'CSV file is required','status': 400}), 400
applicants = extract_nvq_details([row for row in csv_input])
for applicant in applicants:
applicant_details = Student(
identity_no = applicant.get('identity_no'),
student_type = 'NVQ',
initials = applicant.get('initials'),
surename = applicant.get('surename'),
title = applicant.get('title'),
gender = applicant.get('gender'),
ethnicity = applicant.get('ethnicity'),
address_1 = applicant.get('address_1'),
address_2 = applicant.get('address_2'),
city = applicant.get('city'),
district = applicant.get('district'),
permanent_district = applicant.get('permanent_district'),
telephone = applicant.get('telephone'),
mobile = applicant.get('mobile'),
email = applicant.get('email'),
preference_1 = applicant.get('preference_1'),
preference_2 = applicant.get('preference_2'),
preference_3 = applicant.get('preference_3'),
status = 1,
created_by = get_jwt_identity())
db.session.add(applicant_details)
db.session.flush()
db.session.refresh(applicant_details)
nvq_student = NVQStudent(student_id = applicant_details.id,
application_no = applicant.get('application_no'),
index_no = applicant.get('index_no'),
diploma = applicant.get('diploma'),
remarks = applicant.get('remarks'),
permenent_address = applicant.get('permenent_address'),
created_by = get_jwt_identity())
db.session.add(nvq_student)
db.session.commit()
except ValidationError as e:
return jsonify({'error': str(e),'status': 400}), 400
pass
except exc.IntegrityError as e:
db.session().rollback()
return jsonify({'error' : str(e.args),'status': 400}), 400
pass
return jsonify({'message' : 'Bulk import succeeded!','status': 200}), 200
def student():
if request.method=="POST":
firstname=request.form['firstname']
lastname=request.form['lastname']
# return firstname
add_student=Student([firstname,lastname]).addStudent()
return redirect(url_for("index"))
def create_groups(self):
print(f'CREATING GROUPS')
for i in range(self.__ngroups):
group = []
for j in range(self.__students_per_group):
group.append(Student())
self.__groups.append(group)
print(f'CREATED GROUP\n {group}')
def index():
student_results = StudentMarks().viewall()
students = Student().view_all_students()
quizzes = Quizzes().view_all_quizzes()
# return json.dumps(quizzes)
return render_template('index.html',
student_results=student_results,
students=students,
quizzes=quizzes)
def menu1():
correct = False
while correct==False:
print("Please data below : ")
nama = input("Input name : ")
kelas = input("Input kelas : ")
umur = input("Input umur : ")
ipk = input("Input ipk : ")
flag = input("Data is correct [Y | N]? ")
correct = True if flag.upper()=='Y' else False
print("Success insert new student !")
student = Student(nama, kelas, umur, ipk)
return student
def post_student(self, studentData):
print(studentData)
'''
General description:
Args:
no Args
Returns:
create Database entities in the Students table.
Example :
get_student()
'''
session = Session()
try:
studentData = Student(studentData["service_name"])
result = session.add(studentData)
except Exception as e:
return "can not add somthing is going wrong with exception- {}".format(
str(e))
finally:
session.commit()
return result
def newStudent():
log(str(request.url_rule), request.method)
if request.method == 'POST':
try:
newStudent = Student(name=request.form['name'],
username=request.form['username'],
major=request.form['major'])
print(newStudent.username)
session.add(newStudent)
session.commit()
except (InvalidNameError, InvalidUsernameError,
InvalidMajorError) as e:
session.rollback()
flash('Error: ' + str(e))
return redirect(url_for('showStudents'), 400)
except IntegrityError:
session.rollback()
flash(request.form['username'] + constants.DUPLICATE_USERNAME)
return redirect(url_for('showStudents'), 400)
return redirect(url_for('showStudents'), 201)
else:
return render_template('newStudent.html')
def create_report():
"""Create report and logging error"""
try:
setup_models()
STUDENTS = []
for record in Student.STUDENTS_TABLE:
STUDENTS.append(Student(record['id'], record['name']))
DATA = ''.join(list(map(str, STUDENTS)))
write_file(UserInput.OUTPUT_PATH, data=DATA)
should_open = messagebox.askyesno('Show Report File',
'Do you want to open Reports.txt? ')
if should_open:
os.system(f'start "" {UserInput.OUTPUT_PATH}\\reports.txt')
except ValueError as error:
from datetime import datetime
time = datetime.now().strftime("%H:%M:%S")
messagebox.showerror(
"Corrupted input",
"Something is wrong with your data. See logs.txt for more details")
with open("logs.txt", "w+") as f:
print(f"{time} - {error}", file=f)
def getStudentList(self):
file = pd.read_excel(self.filename,
sheet_name='rptSinifListesi',
usecols=[2, 4, 7, 10])
file = file.dropna(how='all')
file = file.drop_duplicates()
file = file.reset_index(drop=True)
file = file.drop([0])
file = file.rename(
columns={
'Unnamed: 2': 'StudentID',
'Unnamed: 4': 'Name',
'Unnamed: 7': 'Surname',
'Unnamed: 10': 'Description'
})
studentList = []
ids = file.StudentID
names = file.Name
surnames = file.Surname
desc = file.Description
for i in range(1, len(file)):
studentList.append(Student(ids[i], names[i], surnames[i], desc[i]))
return studentList
session.add(professor1)
session.commit()
professor2 = Professor(name="Albert Einstein",
username="******",
extension="234",
department="Physics")
session.add(professor2)
session.commit()
professor3 = Professor(name="Alan Turing",
username="******",
extension="345",
department="Computer Science")
session.add(professor3)
session.commit()
student1 = Student(name="Frodo", username="******", major="English")
session.add(student1)
session.commit()
student2 = Student(name="Harry Potter", username="******", major="Philosophy")
session.add(student2)
session.commit()
student3 = Student(name="Tony Stark",
username="******",
major="Electrical Engineering")
session.add(student3)
session.commit()
def home():
form = AddUserForm()
if form.validate_on_submit():
results = request.form
global courses
course_name = results['subject']
course_number = results['course_no']
course_section = results['course_section']
new_course = Course(course_name, course_number, course_section)
course_status = is_course_available(
new_course
) # checks if course is already available or if it is on SSC
if course_status != False:
if course_status == True:
return render_template('error.html',
message='Course is already available!')
elif course_status == 'Course does not exist!':
return render_template('error.html', message=course_status)
student_name = results['name']
student_surname = results['surname']
student_email = results['email']
student = Student(student_name, student_surname, student_email)
# gets the course from courses if the course exists, otherwise returns None
existing_course = next(
(course for course in courses if course == new_course), None)
try:
if existing_course is not None:
add_student_to_course(existing_course, student)
else:
num_courses_in_db = get_number_of_courses()
# Checks if the db and list is synchronized
if len(courses) == num_courses_in_db:
courses.append(new_course)
add_student_to_course(new_course, student)
else:
courses = get_courses()
existing_course = next(
(course for course in courses if course == new_course),
None)
if existing_course is not None:
add_student_to_course(existing_course, student)
else:
courses.append(new_course)
add_student_to_course(new_course, student)
except StudentExistsException:
return render_template(
'error.html',
message='A student with this email address exists.')
except Exception as e:
logging.error('Registration error', exc_info=True)
return render_template(
'error.html',
message=
'An error occurred during registration. Please try again.')
return render_template('result.html')
return render_template('seat_checker.html', form=form)
def getStudent(self, StudentID):
return [
Student(tuple) for tuple in self._db.execute(
"""select * from Student where StudentID={id};""".format(
id=StudentID)).fetchall()
][0]
def getStudents(self):
return [
Student(tuple)
for tuple in self._db.execute("select * from Student;").fetchall()
]
def getStudentsOnProject(self, ProjectID):
return [
Student(tuple) for tuple in self._db.execute("""
select * from Student where ProjectID={id}""".format(
id=ProjectID)).fetchall()
]
def add_results():
students=Student().view_all_students()
quizzes= Quizzes().view_all_quizzes()
return render_template('marks.html',students=students, quizzes=quizzes)
def delele_student(id):
Student().delete_student(id)
return redirect(url_for("index"))
def getClassList(self, TeacherID):
return [
Student(tuple) for tuple in self._db.execute(
"""select * from Student where TeacherID={id};""".format(
id=TeacherID)).fetchall()
]
def create_applicant():
try:
payload = request.get_json()
student_type = payload['student_type'].upper()
if student_type == "NVQ":
marital_status = payload['marital_status']
else:
marital_status = ""
applicant = Student(
identity_no = validate_identity_number(payload['identity_no'].upper()),
student_type = student_type,
initials = payload['initials'].upper(),
surename = payload['surename'].upper(),
title = payload['title'],
gender = payload['gender'],
marital_status = marital_status,
ethnicity = payload['ethnicity'],
address_1 = payload['address_1'],
address_2 = payload['address_2'],
address_3 = payload['address_3'],
city = payload['city'],
district = payload['district'],
permanent_district = payload['permanent_district'],
telephone = payload['telephone'],
mobile = payload['mobile'],
email = payload['email'],
preference_1 = payload['preference_1'],
preference_2 = payload['preference_2'],
preference_3 = payload['preference_3'],
status = 1,
created_by = get_jwt_identity())
db.session.add(applicant)
db.session.flush()
db.session.refresh(applicant)
if student_type == "NVQ":
nvq_student = NVQStudent(student_id = applicant.id,
application_no = validate_nvq_application_number(payload['application_no'].upper()),
batch_type = payload['batch_type'].upper(),
index_no = payload['index_no'],
diploma = payload['diploma'],
remarks = payload['remarks'],
permenent_address = payload['permenent_address'],
created_by = get_jwt_identity())
db.session.add(nvq_student)
elif student_type == "AL":
al_student = ALStudent(student_id = applicant.id,
application_no = validate_al_application_number(payload['application_no'].upper()),
stream = payload['stream'].upper(),
al_index_no = payload['al_index_no'],
z_score = payload['z_score'],
al_ict = payload['al_ict'],
comm_and_media = payload['comm_and_media'],
general_english = payload['general_english'],
general_common_test = payload['general_common_test'],
created_by = get_jwt_identity())
db.session.add(al_student)
else:
return jsonify({'error' : 'Invalid student type!','status': 400}), 400
db.session.commit()
except ValidationError as e:
db.session().rollback()
return jsonify({'error': str(e),'status': 400}), 400
except exc.IntegrityError as e:
db.session().rollback()
return jsonify({'error' : str(e.args),'status': 400}), 400
return jsonify({'message' : 'New applicant has created!','status': 200}), 200
def new_student(self, name, rollNo, marks):
student = Student(name, rollNo, marks)
self.studentRepository.add_student(student)
