def get(self):
req_params: list((str, bool)) = [
('year', False),
('semester', False),
('data_id', False),
]
data = quick_parse(req_params).parse_args()
from core.models.Subject import AvailableSubjectEnhance, NewSemData
print('data', data)
if data['data_id'] is not None:
print('data_id', data['data_id'])
lz = NewSemData.query.filter_by(id=data['data_id']).first()
rz = []
if lz is not None:
rz = lz.to_json()
return {'data': rz}, 200, {'Access-Control-Allow-Origin': '*'}
if data['semester'] is None or data['year'] is None:
l = NewSemData.get_current_semester()
rv = {}
if l is not None:
# ls = AvailableSubjectEnhance.query.filter_by(sys_year=sys).all()
rv = l.to_json()
rv['semester_id'] = l.id
return {'data': rv}, 200, {'Access-Control-Allow-Origin': '*'}
from core.models.CurriculumEnums import SemesterEnum
sem = SemesterEnum(data['semester'])
y = data['year']
ns = NewSemData.query.filter_by(sys_year=y, semester=sem).first()
rx = {}
if ns is not None:
rx = ns.to_json()
return {'data': rx}, 200, {'Access-Control-Allow-Origin': '*'}
def post(self):
req_params: list((str, bool)) = [('content', True)]
data = quick_parse(req_params).parse_args()
import json
from core.models.Subject import AvailableSubjectEnhance, NewSemData
from main_db import db_session
content = json.loads(data['content'])
_id = content['sem_id']
print('data', data)
if _id is not None:
print('data_id', _id)
lz: NewSemData = NewSemData.query.filter_by(id=_id).first()
rz = []
if lz is not None:
# s = AvailableSubjectEnhance.query.filter_by(new_sem_id=lz.id).all()
# rz = [z.subject_code for z in s]
# AvailableSubjectEnhance.query.filter_by(new_sem_id=lz.id).delete()
# # for q in s:
# # rz.append(q.subject_code)
# # q.delete()
# NewSemData.query.filter_by(id=lz.id).delete()
lz.delete_sem_data()
db_session.commit()
lts = NewSemData.latest_id()
if lts is not None:
lts.use_as_current()
return {
'data': {
'removed': rz
}
}, 200, {
'Access-Control-Allow-Origin': '*'
}
def post(self):
req_params: list((str, bool)) = [('content', True)]
data = quick_parse(req_params).parse_args()
# sid = int(data['subject_id'])
import json
from core.models.Subject import AvailableSubjectEnhance, NewSemData
from core.models.CurriculumEnums import SemesterEnum
content = json.loads(data['content'])
sy = content['year']
ss = content['semester']
print('sem', ss)
try:
sem = SemesterEnum(ss)
print('sem', sem)
ns = NewSemData(sy, sem)
ns.save()
except Exception as e:
return response_checker(
True,
{'error': 'there is an error creating new Semester Data'},
res_code=500)
errs = []
for x in content['subject_code']:
sc = str(x).lower()
try:
added = AvailableSubjectEnhance(ns, subject_code=sc)
added.save()
except Exception as e:
errs.append(json.dumps(x))
return response_checker(True, {'response': errs})
def post(self):
parser = quick_parse([
('faculty_id', True),
('password', True),
('department', True),
('account_type', False),
])
data = parser.parse_args()
from core.models.Faculty import FacultyAccounts, AccountType
username = data['faculty_id']
password = data['password']
department = data['department']
a_type = data['account_type']
a_t = AccountType.Common
if a_type is not None and AccountType.is_account_type_valid(a_type):
a_t = AccountType(a_type)
f_data: FacultyAccounts = create_faculty_user(username, password, department, a_t)
ret_v = None
if f_data is not None:
ret_v = {
'account_data': {
'username': f_data.account_name,
'department': f_data.department,
'account_type': f_data.account_type.value
}
}
return response_checker(f_data, ret_v, err_msg='Account_name already Exist', err_num=200)
def post(self):
req_params: list((str, bool)) = [
('content', True)
# ('department', True),
# ('year', True),
# ('semester', True),
# ('subject_id', True),
]
data = quick_parse(req_params).parse_args()
# sid = int(data['subject_id'])
import json
from core.models.Subject import Subject
content = json.loads(data['content'])
errs = []
for x in content:
sd = x['department']
sy = x['year']
ss = x['semester']
si = x['subject_id']
sub: Subject = Subject.query.filter_by(id=int(si)).first()
if sub is not None:
from core.models.GeneralData import Department
from core.models.CurriculumEnums import SemesterEnum
d = Department.search_dept(sd)
sem = SemesterEnum(ss)
year = sy
added = sub.open_subject(sem, year, d)
if not added:
errs.append(json.dumps(x))
return response_checker(True, {'response': errs})
def post(self):
req_params: list((str, bool)) = [('content', True)]
data = quick_parse(req_params).parse_args()
import json
from core.models.Subject import AvailableSubjectEnhance, NewSemData
content = json.loads(data['content'])
_id = content['sem_id']
print('data', data)
if _id is not None:
print('data_id', _id)
lz = NewSemData.query.filter_by(id=_id).first()
rz = False
if lz is not None:
try:
lz.use_as_current()
rz = True
except Exception as e:
print('error', e)
return {
'data': {
'activated': rz
}
}, 200, {
'Access-Control-Allow-Origin': '*'
}
def post(self):
content = 'content'
req_params: list((str, bool)) = [(content, True)]
data = quick_parse(req_params).parse_args()
import json
c = json.loads(data[content])
err_items = []
uploaded = []
from core.models.StudentData import StudentData, Course
from core.models.CurriculumEnums import YearEnum
def req_ok(r_f):
for r in r_f:
if r is None or len(str(r)) == 0:
return False
return True
print('c', c)
if isinstance(c, list):
for s in c:
s_id = s['student_id']
s_fn = s['full_name']
s_c = s['course']
s_y = s['year']
req_f = [s_id, s_fn, s_c, s_y]
r_ok = req_ok(req_f)
err_items.append(s_id)
if not r_ok:
# err_items.append(s)
continue
# es = StudentData.search_student(s_id)
# if es is None:
# continue
_s_c: Course = Course.find_course_title(s_c)
if _s_c is None:
continue
z: StudentData = StudentData.search_student(s_id)
if z is not None:
z.full_name = s_fn
z.course_id = _s_c.id
z.year = YearEnum(str(s_y).lower())
z.save(do_commit=False)
continue
z: StudentData = StudentData(int(s_id),
str(s_fn).strip(), _s_c,
YearEnum(str(s_y).lower()))
z.save(do_commit=False)
uploaded.append(z.student_id)
del err_items[-1]
from main_db import db_session
db_session.commit()
rv = {'response': {'uploaded': uploaded, 'errors': err_items}}
return response_checker(True, rv, res_code=200)
def post(self):
content = 'content'
req_params: list((str, bool)) = [(content, True)]
data = quick_parse(req_params).parse_args()
import json
c = json.loads(data[content])
err_items = []
uploaded = []
updated = []
from core.models.StudentData import StudentGrades
from main_db import db_session
def req_ok(r_f):
for r in r_f:
if r is None or len(str(r)) == 0:
return False
return True
if isinstance(c, list):
for s in c:
s_id = s['student_id']
s_scode = s['subject_code']
s_g = s['grade']
req_f = [s_id, s_scode, s_g]
r_ok = req_ok(req_f)
err_items.append(s_id)
if not r_ok:
err_items.append(s)
continue
sg_c: StudentGrades = StudentGrades.check_grade(
int(s_id), str(s_scode))
print('sg_c', sg_c)
if sg_c is None:
z: StudentGrades = StudentGrades(
int(s_id),
str(s_scode).replace(' ', '').lower(), float(s_g))
z.save()
uploaded.append(z.student_id)
del err_items[-1]
else:
sg_c.grade = s_g
updated.append({
'student_id': sg_c.student_id,
'subject_code': sg_c.subject_code,
'grade': sg_c.grade
})
del err_items[-1]
db_session.commit()
rv = {
'response': {
'uploaded': uploaded,
'updated': updated,
'errors': err_items
}
}
return response_checker(True, rv, res_code=200)
def post(self):
year = 'year'
description = 'description'
course = 'course'
department = 'department'
par = quick_parse([(year, True), (description, True), (course, True),
(department, True)])
data = par.parse_args()
y = data[year]
desc = data[description]
c = str(data[course]).lower()
dept = str(data[department]).lower()
if len(c) == 0 or len(desc) == 0 or len(y) == 0 or len(dept) == 0:
return response_checker(None, {},
err_msg='error in request',
err_num=501)
from core.models.Subject import Course, Department
from core.models.Subject import Curriculum
c_data: Curriculum = None
e_msg = 'Server Error'
try:
_department: Department = Department.search_dept(dept)
if _department is None:
_department = Department(dept)
_department.save()
_course: Course = Course.find_course_title(c)
if _course is None:
_course = Course(c, _department)
_course.save()
checker = Curriculum.query.filter_by(year=y,
description=desc,
course_id=_course.id).first()
if checker is not None:
return response_checker(
None, {},
err_msg=
'Curriculum with same year and description detected',
err_num=409)
c_data = Curriculum(y, desc, _course)
c_data.save()
except Exception as e:
e_msg = e
rv = {}
if c_data is not None:
rv = {
'message':
f'added New Curriculum {c_data.description} for year {c_data.year}',
'curriculum_id': c_data.id
}
return response_checker(c_data, rv, err_msg=e_msg, err_num=500)
def get(self):
req_params: list((str, bool)) = [('subject_code', True),
('curriculum_id', True)]
data = quick_parse(req_params).parse_args()
from core.models.Subject import SubjectEquivalents, Curriculum
cur = Curriculum.search_curriculum(int(data['curriculum_id']))
code = data['subject_code']
res = SubjectEquivalents.subj_equiv_in_cur(code, cur)
rv = {'result': res}
return response_checker(True, rv)
def get(self):
req_params: list((str, bool)) = [('content', False)]
from api.rest.quick_parser import quick_parse
data = quick_parse(req_params).parse_args()
socketio.emit('my event', {
'test': 'okay',
'passed': data['content']
},
namespace='/advising')
# emit('test-emit', 'Change has been made', broadcast=True)
print('fired')
return {'fired': 'okay'}, 200, {'Access-Control-Allow-Origin': '*'}
def post(self):
req_params: list((str, bool)) = [('content', False)]
print('fired AdvisingDataEmitter')
from api.rest.quick_parser import quick_parse
data = quick_parse(req_params).parse_args()
to_emit = {}
if not data['content'] == None:
import json
to_emit = json.loads(data['content'])
socketio.emit('new advising form submitted', {'data': to_emit},
namespace='/advising')
# emit('test-emit', 'Change has been made', broadcast=True)
return {'fired': 'okay'}, 200, {'Access-Control-Allow-Origin': '*'}
def get(self):
req_params: list((str, bool)) = [('name', True)]
data = quick_parse(req_params).parse_args()
from core.models.Subject import SubjectClusters
s: SubjectClusters = SubjectClusters.search_cluster_name(data['name'])
if s is None:
return response_checker(None,
None,
err_msg='not found',
err_num=404)
rv = {'found': s.subjects_under}
return response_checker(True, rv)
def get(self):
req_params: list((str, bool)) = [('student_id', True),
('course', True)]
data = quick_parse(req_params).parse_args()
from core.models.StudentData import Course, nearest_curriculum
sid = int(data['student_id'])
c = Course.find_course_title(data['course'])
prefix = '20'
rv = {}
if c is not None:
cur = nearest_curriculum(str(sid), c.id, prefix)
rv = cur.subject_list_to_json
print(cur.subject_list_to_json)
return {'curriculum': rv}, 200, {'Access-Control-Allow-Origin': '*'}
def get(self):
curriculum_id = 'curriculum_id'
parser = quick_parse([(curriculum_id, True)])
data = parser.parse_args()
c_id = data[curriculum_id]
from core.models.Subject import Curriculum
c: Curriculum = get_curriculum(c_id)
rv = None
if c is not None:
rv = {'data_received': c.to_json}
return response_checker(c, rv)
def get(self):
req_params: list((str, bool)) = [('year', True), ('semester', True),
('department', True)]
data = quick_parse(req_params).parse_args()
from core.models.GeneralData import Department
from core.models.CurriculumEnums import SemesterEnum
from core.models.Subject import AvailableSubjects
d = Department.search_dept(data['department'])
sem = SemesterEnum(data['semester'])
y = data['year']
subs = AvailableSubjects.available_subjects_for_year_sem(y, sem, d)
return {
'available_subjects': subs
}, 200, {
'Access-Control-Allow-Origin': '*'
}
def post(self):
student_id = 'student_id'
req_params: list((str, bool)) = [(student_id, True)]
data = quick_parse(req_params).parse_args()
sid = data[student_id]
msg = 'deleted'
r_num = 200
try:
from core.models.StudentData import StudentData
from main_db import db_session
StudentData.query.filter_by(student_id=sid).delete()
db_session.commit()
except Exception as e:
msg = e
r_num = 500
rv = {'message': msg}
return response_checker(True, rv, res_code=r_num)
def post(self):
curriculum_id = 'curriculum_id'
req_params: list((str, bool)) = [(curriculum_id, True)]
data = quick_parse(req_params).parse_args()
cid = data[curriculum_id]
msg = 'deleted'
r_num = 200
from core.models.Subject import Curriculum, CurriculumSubjects
from main_db import db_session
Curriculum.query.filter_by(id=cid).delete()
CurriculumSubjects.query.filter_by(curriculum_id=cid).delete()
db_session.commit()
# try:
#
# except Exception as e:
# msg = e
# r_num = 500
rv = {'message': msg}
return response_checker(True, rv, res_code=r_num)
def post(self):
curriculum_id = 'curriculum_id'
content = 'content'
req_params: list((str, bool)) = [(curriculum_id, True),
(content, True)]
data = quick_parse(req_params).parse_args()
import json
_c = json.loads(data[content])
_cid = data[curriculum_id]
from core.models.Subject import Curriculum
curr = Curriculum.search_curriculum(int(_cid))
if curr is None:
return response_checker(True,
{'message': 'curriculum id not found'},
res_code=404)
errors = []
if isinstance(_c, list):
for x in _c:
if isinstance(x, dict):
x_keys = x.keys()
_2_add = {
'curriculum_id': _cid,
'code': str(x['code']).replace(' ', '').lower(),
'title': x['title'],
'year': x['year'],
'semester': x['semester'],
'units': x['units'],
}
if 'pre_req' in x_keys:
_2_add['pre_req'] = str(x['pre_req']).replace(
' ', '').lower()
rv, n, a = new_subject(_2_add, commit=False)
if isinstance(n, int):
if n != 200:
_2_add['error'] = {'code': n, 'note': rv['note']}
errors.append(_2_add)
from main_db import db_session
db_session.commit()
rv = {'response': {'errors': errors}}
return response_checker(True, rv)
def post(self):
curriculum_id = 'curriculum_id'
code = 'code'
title = 'title'
pre_req = 'pre_req'
year = 'year'
semester = 'semester'
units = 'units'
parser = quick_parse([
(curriculum_id, True),
(code, True),
(title, True),
(pre_req, False),
(year, True),
(semester, True),
(units, True),
])
data = parser.parse_args()
rv = new_subject(data)
return rv
def post(self):
req_params: list((str, bool)) = [('name', True)]
data = quick_parse(req_params).parse_args()
name = data['name']
from core.models.Subject import SubjectClusters
s: SubjectClusters = SubjectClusters.search_cluster_name(name)
if s is not None:
return response_checker(None, None,
'duplicate subject cluster name', 404)
try:
ns = SubjectClusters(name=name)
ns.save()
rv = {
'message': f'successfully created subject cluster',
'id': ns.id,
'name': ns.name
}
except Exception as e:
rv = {'message': e}
return response_checker(True, rv, err_msg=rv['message'], err_num=500)
def post(self):
parser = quick_parse([
('department_name', True)
])
data = parser.parse_args()
dn = data['department_name']
rv = {'message': 'server error', 'data': []}
from core.models.GeneralData import Department
t: Department = Department.search_dept(dn)
if t is not None:
rv['message'] = 'duplicate name'
rv['data'] = t.to_json
return response_checker(True, rv)
try:
d = Department(dn)
d.save()
rv = {'message': 'added new Department',
'data': d.to_json}
except Exception as e:
rv['message'] = e
return response_checker(True, rv)
def get(self):
department = 'department'
req_params: list((str, bool)) = [(department, True)]
data = quick_parse(req_params).parse_args()
from core.models.Subject import Curriculum
from core.models.GeneralData import Department, Course
d: Department = Department.search_dept(data[department])
if d is None:
return response_checker(True, {})
rv = {'result': []}
c: [Course] = Course.find_course_under_department(d)
if len(c) > 0:
c_titles = [{
'curriculum_data': [
q.to_json_lite
for q in Curriculum.curriculum_under_course(z)
]
} for z in c]
rv['result'] = c_titles
return response_checker(True, rv)
def get(self):
parser = quick_parse([
('faculty_id', True),
('password', True)
])
data = parser.parse_args()
username = data['faculty_id']
password = data['password']
from core.models.Faculty import FacultyAccounts
f_data: FacultyAccounts = check_user(username, password)
rv = None
if f_data is not None:
rv = {
'account_data': {
'id': f_data.id,
'name': f_data.account_name,
'department': f_data.department,
'account_type': f_data.account_type.value
}
}
return response_checker(f_data, rv, err_msg='not found', err_num=200)
def get(self):
req_params: list((str, bool)) = [
('student_id', True),
('semester_id', True),
('subjects_content', True),
]
from deploy import JRXML_BASE_DIR, OUTPUT_BASE_DIR, app, request, REPORT_EFF_EXPIRATION_DAYS
from core.models.Subject import NewSemData, SemesterEnum
from core.models.StudentData import StudentData
import datetime
import json
from flask import request
from deploy import config, APP_DIR
fname = 'advising_form'
global input_file
ad = APP_DIR
input_file = APP_DIR + config.REPORTS_JRXML_DIR + '/' + fname + '.jrxml'
# reset_input_file(_input_file)
print('input_file', input_file)
print('APP_DIR', APP_DIR)
print('config.REPORTS_JRXML_DIR', config.REPORTS_JRXML_DIR)
print('config.REPORTS_OUTPUT_DIR', config.REPORTS_OUTPUT_DIR)
se = SemesterEnum.to_list()
data = quick_parse(req_params).parse_args()
sem_data: NewSemData = NewSemData.query.filter_by(
id=data['semester_id']).first()
stud: StudentData = StudentData.query.filter_by(
student_id=int(data['student_id'])).first()
if sem_data is None or stud is None:
return response_checker(True, {'error': 'data not found'},
res_code=404)
n = datetime.datetime.now().date() + datetime.timedelta(
days=REPORT_EFF_EXPIRATION_DAYS)
data['api_resource_url'] = request.url_root
data['effectivity_date'] = str(n.strftime('%B %d %Y')).title()
data['academic_year'] = str(sem_data.sys_year)
data['semester'] = str(se.index(sem_data.semester.value))
data['student_name'] = str(stud.student_full_name).title()
to_add_content = [{}]
d_cont = json.loads(data['subjects_content'])
if isinstance(d_cont, list):
for s in d_cont:
to_add_content.append({
"subject": str(s['subject']).title(),
"units": s['units']
})
data_content = {"content": to_add_content}
parameters = filter_parameters(data)
print('parameters', parameters)
try:
with tempfile.TemporaryDirectory(
dir=APP_DIR + config.REPORTS_OUTPUT_DIR) as directory:
print('directory', directory)
tfile = tempfile.NamedTemporaryFile(prefix=data['student_id'],
suffix='.json',
dir=directory,
mode='w',
delete=False)
tfile_name = tfile.name
print('tfile_name', tfile_name)
json.dump(data_content, tfile)
tfile.close()
json_query = 'content'
db_connection = {
'data_file': tfile_name,
'driver': 'json',
'json_query': json_query,
}
print('db_connection', db_connection)
out_file_dir = processing(parameters,
directory,
db_conn=db_connection,
fname=data['student_id'])
out_file_dir += f'/{FILE_NAME}.pdf'
with app.open_resource(out_file_dir) as f:
content = f.read()
resposta = make_response(content)
resposta.headers[
'Content-Type'] = 'application/pdf; charset=utf-8'
resposta.headers['Access-Control-Allow-Origin'] = '*'
# resposta.headers['Content-Disposition'] = 'inline; filename=hello_world_params.pdf'
return resposta
except IOError:
return response_checker(True, {'error': 'forbidden'}, res_code=403)
def post(self):
req_params: list((str, bool)) = [('student_id', True),
('semester_id', True),
('content', True),
('is_block_section', False)]
data = quick_parse(req_params).parse_args()
is_block_section = data['is_block_section']
if is_block_section is None:
is_block_section = False
else:
is_block_section = True if str(
is_block_section).lower() == 'true' else False
print('is_block_section', is_block_section)
import json
from core.models.Subject import AvailableSubjectEnhance, NewSemData
from core.models.Faculty import AdvisingData
from core.models.StudentData import StudentData
from main_db import db_session
content = json.loads(data['content'])
# _id = content['sem_id']
print('data', data)
print('content', content)
print('isinstance(content, list)', isinstance(content, list))
socket_rv = {}
if isinstance(content, list):
try:
s_data: StudentData = StudentData.query.filter_by(
student_id=int(data['student_id'])).first()
ns: NewSemData = NewSemData.query.filter_by(
id=data['semester_id']).first()
old_opi: [AdvisingData] = AdvisingData.query.filter_by(
student_id=int(data['student_id'])).all()
print('old_opi', old_opi)
print('sem_i', ns.id)
rem_s_codes: [] = []
for z in old_opi:
z_id: AvailableSubjectEnhance = AvailableSubjectEnhance.query.filter_by(
id=z.available_subject_id).first()
print('z_id.id', z_id.new_sem.id)
if z_id.new_sem.id == ns.id:
AdvisingData.query.filter_by(id=z.id).delete()
db_session.commit()
rem_s_codes.append(z_id.subject_code)
s_codes: list = []
for c in content:
opi: AvailableSubjectEnhance = AvailableSubjectEnhance \
.query.filter_by(id=c) \
.first() if not \
is_block_section else \
AvailableSubjectEnhance.query.filter_by(subject_code=c, new_sem_id=ns.id).first()
if opi is None and is_block_section:
opi = AvailableSubjectEnhance(ns, c)
opi.save()
if opi is not None and s_data is not None:
new_data: AdvisingData = AdvisingData(opi, s_data)
new_data.save()
s_codes.append(opi.subject_code)
from api.sockets import AdvisingConfigs, advising_socket_emit
socket_rv = {
'content': {
'removed': rem_s_codes,
'added': s_codes
}
}
# advising_socket_emit(AdvisingConfigs.new_advising_form_submitted, socket_rv)
# print('socket_rv', socket_rv)
except Exception as e:
print('error', e)
response_checker(True, {'error': 'server error'}, res_code=500)
return response_checker(True, {
'message': 'finished',
'data': socket_rv
},
res_code=200)
else:
return response_checker(True, {'error': 'forbidden'}, res_code=403)
