def add_update(self):
method = ['POST', 'PATCH'][self.ids['btn_positive'].text == 'Update']
data = dict()
data['mat_no'] = self.ids.mat_no.text
data['surname'] = self.ids.surname.text.upper()
data['othernames'] = ' '.join([self.ids.fname.text.capitalize(), self.ids.mname.text.capitalize()])
try:
data['mode_of_entry'] = MODES_OF_ENTRY.index(self.ids.mode_of_entry.text) + 1
except ValueError:
self.show_input_error()
return
data['session_admitted'] = int(self.ids.session_admit.text)
data['level'] = int(self.ids.level.text)
data['transfer'] = int(self.ids.transfer.text == 'Yes')
data['sex'] = ['M', 'F'][self.ids.sex.text != 'Male']
data['date_of_birth'] = self.ids.dob.text
data['state_of_origin'] = self.ids.state_of_origin.text
data['lga'] = self.ids.lga_of_origin.text
data['phone_no'] = self.ids.phone_no.text
data['email_address'] = self.ids.email.text
data['sponsor_phone_no'] = self.ids.s_phone_no.text
data['sponsor_email_address'] = self.ids.s_email.text
data['grad_status'] = int(self.ids.grad.text == 'YES')
url = urlTo('personal_info')
params = {'superuser': True} if root.sm.is_admin else None
AsyncRequest(url, method=method, data=data, params=params, on_success=self.record_added, on_failure=self.show_add_error)
def _remove(self):
params = {
'code': self.course_code,
'action': self.action
}
url = urlTo('course_details')
AsyncRequest(url, method='DELETE', params=params, on_success=self.success)
def get(self):
url = urlTo('level_gpa_cards')
params = {'level': int(self.ids['level'].text)}
AsyncRequest(url,
params=params,
on_success=self.show_gpa_cards,
on_failure=self.show_error)
def create(self):
if not self.ids['cbox'].active and self.ids['pwd'].text != self.ids[
'rpwd'].text:
self.highlight_textinput(self.ids['pwd'])
self.highlight_textinput(self.ids['rpwd'])
return
if ':' in self.ids['username'].text:
ErrorPopup(message='Username contains ":"')
self.highlight_textinput(self.ids['username'])
return
elif ':' in self.ids['pwd'].text:
ErrorPopup(message='Password contains ":"')
self.highlight_textinput(self.ids['pwd'])
return
if self.ids['cbox'].active:
self.ids['pwd'].text = ''.join(
choices(list(alphanumeric_chars), k=10))
data = {
'permissions':
titles_perm[self.ids['title'].text] % self.ids['username'].text
}
data[
'fullname'] = self.ids['fname'].text + ' ' + self.ids['lname'].text
data['email'] = self.ids['email'].text
data['username'] = self.ids['username'].text
data['title'] = self.ids['title'].text
data['password'] = tokenize(self.ids['pwd'].text)
url = urlTo('accounts')
AsyncRequest(url, method='POST', data=data, on_success=self.success)
def reset(self):
if not self.ids['cbox'].active and self.ids['pwd'].text != self.ids[
'rpwd'].text:
self.highlight_textinput(self.ids['pwd'])
self.highlight_textinput(self.ids['rpwd'])
return
if ':' in self.ids['pwd'].text:
ErrorPopup(message='Password contains ":"')
self.highlight_textinput(self.ids['pwd'])
return
if self.ids['cbox'].active:
self.ids['pwd'].text = ''.join(
choices(list(alphanumeric_chars), k=10))
username = self.ids['username'].text
self.selected_acct = self.get_user(username)
if not self.selected_acct:
ErrorPopup(username + ' not found')
return
self.selected_acct['password'] = tokenize(self.ids['pwd'].text)
url = urlTo('accounts')
params = {'superuser': True} if root.sm.is_admin else None
AsyncRequest(url,
method='PATCH',
data=self.selected_acct,
params=params,
on_success=self.success)
def remove(self):
params = {'username': self.ids['username'].text}
url = urlTo('accounts')
AsyncRequest(url,
method='DELETE',
params=params,
on_success=self.success)
def search(self):
acad_session = int(self.ids.reg_session.text)
url = urlTo('course_reg')
param = {'mat_no': self.ids.mat_no.text, 'acad_session': acad_session}
AsyncRequest(url,
on_success=self.populate_fields_for_old_reg,
on_failure=self.check_query_session,
params=param)
def delete_backup(self):
url = urlTo('backups')
params = {'backup_name': self.backup_name}
AsyncRequest(url,
method='DELETE',
params=params,
on_success=self.delete_success,
on_failure=self.show_error)
def set_results_edit(self):
switch = self.ids['result_switch']
url = urlTo('results_edit')
data = {'state': int(not switch.active)}
AsyncRequest(url,
method='POST',
data=data,
on_success=self.set_res_switch_state)
def backup(self):
url = urlTo('backups')
data = {'tag': self.ids['tag'].text}
AsyncRequest(url,
method='POST',
data=data,
on_success=self.success,
on_failure=self.show_error)
def download_backup(self):
url = urlTo('backup_download')
params = {'backup_name': self.backup_name}
AsyncRequest(url,
method='GET',
params=params,
on_success=self._download_backup,
on_failure=self.show_error)
def get_course_details(self):
if not self.ids['lvl_spinner'].text:
return
url = urlTo('course_details')
course_level = int(self.ids['lvl_spinner'].text[:3])
use_curr_session = self.ids['session_spinner'].text == 'Current session'
params = {'level': course_level, 'use_curr_session': use_curr_session}
AsyncRequest(url, method='GET', params=params, on_success=self.populate_dv)
def search(self, *args):
url = urlTo('student_summary')
mat_no = self.ids.mat_no.text
surname = self.ids.surname_.text
if mat_no:
param = {'mat_no': mat_no}
AsyncRequest(url, on_success=self.populate_personal_info, on_failure=self.show_error, params=param)
else:
self.show_error("Feature not implemented yet")
def query_users(self):
url = urlTo('accounts')
params = {}
if root.sm.is_admin == 1:
AsyncRequest(url,
params=params,
method='GET',
on_success=self.update_users)
else:
self.update_users(bypass=True)
def search(self):
url = urlTo('results_stats_multiple')
if self.validate_inputs():
session = int(self.ids['session'].text)
level = int(self.ids['level'].text)
self.query_params = {'acad_session': session, 'level': level}
AsyncRequest(url,
params=self.query_params,
on_success=self.populate_fields)
else:
ErrorPopup('Fields can\'t be empty')
def check_query_session(self, resp):
acad_session = int(self.ids.reg_session.text)
if acad_session == get_current_session():
url = urlTo('course_reg_new')
param = {'mat_no': self.ids.mat_no.text}
AsyncRequest(url,
on_success=self.populate_fields,
on_failure=self.show_error,
params=param)
else:
self.show_error(resp)
def search(self, *args):
url = urlTo('senate_version')
try:
acad_session = int(self.ids['acad_session'].text)
level = int(self.ids['level'].text)
except ValueError:
ErrorPopup('Field cannot be empty')
return
params = {'acad_session': acad_session, 'level': level}
AsyncRequest(url,
params=params,
on_success=self.generate_senate_version)
def restore(self):
url = urlTo('backups')
data = {
'backup_name': self.backup_name,
'include_accounts': self.ids['include_accounts'].text == 'Yes',
'backup_current': self.ids['backup_current'].text == 'Yes',
}
AsyncRequest(url,
method='PATCH',
data=data,
on_success=self.success,
on_failure=self.show_error)
def search(self, *args):
course_code = self.ids['code'].text
if not course_code:
ErrorPopup('Input can\'t be empty')
return
course_code = course_code[:3].upper() + course_code[3:]
params = {'course_code': course_code}
url = urlTo('course_details')
AsyncRequest(url,
params=params,
on_success=self.populate_fields,
on_failure=self.show_error)
def search(self, *args):
url = urlTo('broad_sheet')
try:
acad_session = int(self.ids['acad_session'].text)
level = int(self.ids['level'].text)
raw_score = self.ids['raw_score'].text == 'Yes'
semester = self.ids['semester'].text == 'First Only'
except ValueError:
ErrorPopup('Field cannot be empty')
return
params = {'acad_session': acad_session, 'level': level, 'first_sem_only': semester, 'raw_score': raw_score}
AsyncRequest(url, params=params, on_success=self.generate_broadsheet, on_failure=self.show_error)
def search(self):
url = urlTo('results')
session = get_current_session(
) if not self.ids['session'].text else int(self.ids['session'].text)
params = {
'mat_no': self.ids['mat_no'].text,
'acad_session': session,
'include_reg': True
}
AsyncRequest(url,
method='GET',
params=params,
on_success=self.get_grading_rules)
def search(self, *args):
url = urlTo('result_update')
mat_no = self.ids['mat_no'].text
raw_score = self.ids['raw_score'].text == 'Yes'
clearance = self.ids['clearance'].text == 'Yes'
params = {
'mat_no': mat_no,
'raw_score': raw_score,
'clearance': clearance
}
AsyncRequest(url,
params=params,
on_success=self.generate_result_update)
def session_timer(url, params):
global last_request_timestamp, logged_in
curr_timestamp = datetime.now().timestamp()
if last_request_timestamp and curr_timestamp - last_request_timestamp > ALLOWABLE_IDLE_TIME:
if url not in [urlTo('logout'), urlTo('login')] and logged_in: # if the request is logout or login, the let it pass
# else logout silently
try:
requests.post(
url=urlTo('logout'),
headers={'Content-type': 'application/json',
'token': get_token()},
json={'token': get_token()}
)
logged_in = False
except requests.exceptions.ConnectionError:
ErrorPopup('Server down')
elif url == urlTo('login'):
logged_in = True
# don't update last_request_timestamp if logs is called w/o filters (from main menu)
log_filter_params = ['time', 'operation', 'reverse']
if url != urlTo('logs') or any(map(lambda param: param in params, log_filter_params)):
last_request_timestamp = curr_timestamp
def generate_course_form(self):
url = urlTo('course_form')
try:
params = {
'mat_no': self.ids['mat_no'].text,
'session': int(self.ids['reg_session'].text),
'to_print': True
}
except ValueError:
ErrorPopup('Fields cannot be empty')
return
AsyncRequest(url,
params=params,
method='GET',
on_success=self.print_course_form)
def _delete_course_reg(self):
if not self.data:
ErrorPopup('Delete error')
return
params = {
'mat_no': self.data['mat_no'],
'acad_session': self.data['course_reg_session'],
'superuser': True if root.sm.is_admin else None
}
url = urlTo('course_reg')
AsyncRequest(url,
params=params,
method='DELETE',
on_failure=self.show_error,
on_success=self.clear_fields)
def update(self):
data = dict()
data['ViceChancellor'] = self.ids['vc'].text
data['ChairmanSubCommitteeBCS'] = self.ids['chairman'].text
data['Dean'] = self.ids['dean'].text
data['FacultyExamOfficer'] = self.ids['exam_officer'].text
data['HOD'] = self.ids['hod'].text
data['NumPrizeWinners'] = int(self.ids['prize_winners'].text)
url = urlTo('dynamic_props')
AsyncRequest(url,
data=data,
method='PATCH',
on_success=self.submit_success)
def update(self):
if not self.ids['password'].text:
ErrorPopup('Password field can\'t be empty')
return
if ':' in self.ids['password'].text:
ErrorPopup('Password contains ":"')
return
self.data['password'] = tokenize(self.ids['password'].text)
self.data['email'] = self.ids['email'].text
url = urlTo('accounts')
AsyncRequest(url,
data=self.data,
method='PATCH',
on_success=self.update_success)
def get_grading_rules(self, resp):
data = resp.json()
flatten_dict = lambda dic: [[key] + list(val[:4]) for key, val in {
**dic['first_sem'],
**dic['second_sem']
}.items()]
data['regular_courses'] = flatten_dict(data['regular_courses'])
data['carryovers'] = flatten_dict(data['carryovers'])
self.data = data
url = urlTo('grading_rules')
params = {'acad_session': self.data['entry_session']}
AsyncRequest(url,
params=params,
method='GET',
on_success=self.populate_fields)
def send_feedback(self):
from main import prev_log, fd
url = urlTo('feedback')
data = {
'username':
self.username,
'message':
self.ids['message'].text,
'error_log':
'Previous App Session\n' + '=' * 20 + '\n' + prev_log +
'\n\nCurrent App Session\n' + '=' * 19 + '\n' + fd.read()
}
AsyncRequest(url,
method='POST',
data=data,
on_success=self.show_message,
on_failure=self.show_message)
def add(self):
try:
data = {}
for key in keys[:-3]:
data[key] = self.ids[key].text
data['credit'] = int(data['credit'])
data['semester'] = [1, 2][data['semester'].strip().lower() == 'second']
data['level'] = int(self.ids['level'].text)
data['start_date'] = get_current_session() + 1
data['end_date'] = 2999
optional = self.ids['opt_yes'].active
data['options'] = [0, data['semester']][optional]
data['code'] = data['code'].upper()
data['teaching_dept'] = data['teaching_dept'].upper()
url = urlTo('course_details')
AsyncRequest(url, method='POST', data=data, on_success=self.success)
except:
ErrorPopup('Fields cannot be empty')
