async def post(self, user: dict):
teachers = map_users(await self.fetch_teachers(user['escuela'], 2,
self.request.app.db))
result_data = {
'teachers': teachers,
'today': humanize_datetime(datetime.utcnow(), with_time=False)
}
data = await self.request.post()
errors = await self.validate(data)
if errors:
result_data['errors'] = errors
else:
start_date = datetime.strptime(data['beginning_date'], df)
end_date = datetime.strptime(data['ending_date'], df)
_e = []
if await self.fetch_school_term(start_date, user['escuela'],
self.request.app.db):
_e.append(
'La fecha de comienzo ya se encuentra en el rango que abarca otro ciclo académico'
)
if await self.fetch_school_term(end_date, user['escuela'],
self.request.app.db):
_e.append(
'La fecha de culminación ya se encuentra en el rango que abarca otro ciclo académico'
)
if _e:
result_data['errors'] = _e
else:
validation_groups = await self._get_validation_groups(data)
if not validation_groups:
if 'errors' not in result_data:
result_data['errors'] = list()
result_data['errors'].append(
'No se enviaron los campos de horario correctamente')
else:
validation_rules = await self._build_validation_groups(
validation_groups, data)
_validation_errors = await validator.validate(
validation_rules, self.request.app.db)
if _validation_errors:
result_data['errors'] = _validation_errors
else:
await self.create(validation_groups, data,
user['escuela'], self.request.app.db)
result_data[
'success'] = 'Se ha creado el ciclo académico exitosamente'
del _e
return result_data
async def get(self, user: dict):
if 'school_term' in self.request.match_info:
school_term = await self.get_school_term(
user['escuela'], int(self.request.match_info['school_term']))
else:
school_term = await self.get_school_term(user['escuela'])
if school_term is None:
return {
'school_term_has_not_begun':
'El ciclo académico no ha comenzado, tus acciones son limitadas'
}
# Estudiantes de escuela y tal
students = await self.get_students(school_term['id'], user['escuela'])
students = map_users(students)
# Notas disponibles para este ciclo
dd_grades = await self.get_grades(school_term['id'])
# Ciclos académicos
school_terms = await self.get_school_terms(user)
current_school_term_id = school_term['id']
can_do_grading = school_term['fecha_comienzo'] <= datetime.utcnow(
) <= school_term['fecha_fin']
return {
'students': students,
'dd_grades': dd_grades,
'school_terms': school_terms,
'current_school_term_id': current_school_term_id,
'can_do_grading': can_do_grading
}
async def get(self, user: dict):
teachers = map_users(await self.fetch_teachers(user['escuela'], 2,
self.request.app.db))
return {
'teachers': teachers,
'today': humanize_datetime(datetime.utcnow(), with_time=False)
}
async def get(self, user: dict):
if '_user_id' not in self.request.match_info:
raise HTTPNotFound # No se pasó una id de usuario por la URI, 404
# Obtenemos la ID de usuario
_user_id = int(self.request.match_info['_user_id'])
_user = await self.get_user(_user_id) # Consultar la BD por usuario
if not _user:
raise HTTPNotFound # No se encontró al usuario, 404
return {'requested_user': map_users([_user])[0]}
async def get(self, user: dict):
if 'page' in self.request.match_info:
page = int(self.request.match_info['page'])
else:
page = 1
offset = (page - 1) * 20
users = await self.fetch_users(user['escuela'], offset)
users = map_users(users)
if not users:
raise HTTPNotFound
users_amount = await self.get_users_amount(user['escuela'])
return {'users': users,
'page': page,
'users_amount': users_amount,
'pagination': pagination(page, users_amount)}
async def _get_students(self, user: dict, dbi: PoolConnectionHolder) -> list:
students = await self._fetch_students(user['escuela'], dbi)
return map_users(students)
async def get(self, user: dict):
# Primero necesitamos obtener el ciclo académico, sea el actual o uno que se ingresó en la uri
if 'school_term' in self.request.match_info: # Si se encuentra el parametro en la uri
school_term_id = int(self.request.match_info['school_term']) # Castear el valor a entero
school_term = await self.school_term_exists(school_term_id, user['escuela'])
if not school_term: # Si el ciclo académico no se encontró
raise HTTPNotFound # Se levanta 404
else:
school_term = {
'id': school_term_id
}
del school_term_id
else:
# Si no se pasó el parametro school_term en la uri, tratamos de obtener el ciclo académico actual
school_term = await self.fetch_school_term(user['escuela'])
if not school_term:
# En este caso, no hay un ciclo académico registrado, pero no podemos tirar 404
# pues no se pasó un parámetro de ciclo académico que no existe, informamos al usuario que no hay un
# ciclo académico registrado, por lo tanto no hay data a mostrar.
return {'message': 'No se encontró un ciclo académico registrado para este preciso momento. '
'Puedes seleccionar un ciclo académico previo en el selector superior.',
'school_terms': await self.get_school_terms(user)}
students = await self.fetch_students(school_term['id'])
if not students:
# No se encontraron estudiantes, por lo tanto informamos al usuario que no se encontraron estudiantes
# registrados para este ciclo académico
return {'message': 'No hay estudiantes registrados para este ciclo académico aún.',
'school_terms': await self.get_school_terms(user),
'current_school_term_id': school_term['id']}
headers = await self.fetch_grade_headers(school_term['id'])
if not headers:
return {'message': 'No hay estructura de notas registrada, no hay notas por ver...',
'school_terms': await self.get_school_terms(user),
'current_school_term_id': school_term['id']}
header_group = list()
def find_header_group(_group_name: str, _h_group: list) -> Union[int, bool]:
for _i, _h in enumerate(_h_group):
if isinstance(_h, list):
if _h[0] == _group_name:
return _i
return False
for header in headers:
if not header['grupo']:
header_group.append(header['descripcion'])
continue
_group_i = find_header_group(header['grupo'], header_group)
if _group_i is False:
header_group.append([header['grupo'], header['descripcion']])
else:
header_group[_group_i].append(header['descripcion'])
headers = [*header_group]
students = map_users(students)
async def map_student(student: dict) -> dict:
grades = await self.fetch_grades(school_term['id'], student['id'])
grades = flatten(grades, {})
grades = list(map(lambda x: float(x['valor']) if x['valor'] is not None else '-', grades))
final_grade = await self.fetch_final_grade(school_term['id'], student['id'])
if final_grade is None:
final_grade = '-'
grades.append(final_grade)
return {**student, 'grades': grades}
for _student_i, _student in enumerate(students):
students[_student_i] = await map_student(_student)
return {'headers': headers,
'students': students,
'school_terms': await self.get_school_terms(user),
'current_school_term_id': school_term['id']}