def get(self): r_num = 200 ad: list = [] students: list = [] try: from core.models.Subject import NewSemData from core.models.Faculty import AdvisingData curr_sem: NewSemData = NewSemData.get_current_semester() if curr_sem is None: return response_checker(None, {}, err_msg='No Semester selected', err_num=404) print('cs_json', curr_sem) cs_json = curr_sem.to_json() count = 0 print('cs_json', cs_json) for x in cs_json['subjects']: cn: [AdvisingData] = AdvisingData.query.filter_by( available_subject_id=x['id']).all() ad.append({'code': x['code'], 'student_count': len(cn)}) count += len(cn) for s in cn: if s.student_id not in students: students.append(int(s.student_id)) print('students', students) except Exception as e: r_num = 500 rv = {'statistics': ad, 'student_this_sem_count': len(students)} return response_checker(True, rv, res_code=r_num)
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 get(self): from core.models.GeneralData import Department rv: [Department] = Department.all_department() if rv is not None: r = [x.to_json for x in rv] return response_checker(True, r) else: return response_checker(None, None, err_msg='no list of departments', err_num=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)) = [('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): from core.models.Subject import NewSemData d = NewSemData.query.filter_by().all() rx = [] if d is not None: rx = [x.to_json_lite() for x in d] return response_checker(True, {'response': rx})
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): 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): 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): 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): 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 new_subject(data, commit=True): curriculum_id = 'curriculum_id' code = 'code' title = 'title' pre_req = 'pre_req' year = 'year' semester = 'semester' units = 'units' data_keys = data.keys() c_id = data[curriculum_id] _code = str(data[code]).strip() _title = data[title] _pre_req = [] if pre_req in data_keys: dz = str(data[pre_req]).strip() _pre_req = dz.split(',') _year = data[year] _semester = data[semester] _units = data[units] from core.models.Subject import Curriculum, Subject from core.models.CurriculumEnums import YearEnum, SemesterEnum __year = YearEnum(_year) __semester = SemesterEnum(_semester) c: Curriculum = get_curriculum(c_id) rv = None res_code = 409 if c is not None: s: Subject = Subject.check_subject(code=_code, title=_title, pre_req=_pre_req, year=__year, semester=__semester, units=_units, create_if_not_exist=True) ch = c.search_subject(s.code) if ch is None: c.add_a_subject(s, commit=commit) res_code = 200 rv = { 'subject_id': s.id, 'note': 'added new subject' if ch is None else 'Subject already in Curriculum' } return response_checker(c, rv, res_code=res_code, err_msg='Subject not added', 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): 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 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 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 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 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 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)