def get_materiascursadas(request,
cod_carrera=None,
inicio=None,
fin=None,
subjectCode=None):
provider = DataProvider()
transformer = DataTransformer()
manipulator = DataManipulator()
# Saco el token del request
token = get_token(request)
# Formateo los args
fecha_inicio = inicio or request.args.get('inicio')
fecha_fin = fin or request.args.get('fin')
# Tiene que ser una sola carrera y un solo plan para calcular creditos
carrera = cod_carrera or request.args.get('carrera')
plan = request.args.get('plan')
# Traigo las cursadas
if carrera:
cursadas_json = provider.get_materiascursadas(token, carrera)
else:
cursadas_json = provider.getTakenSubjects(token, subjectCode)
cursadas_data = transformer.transform_materiascursadas_to_dataframe(
cursadas_json)
# Filtro periodo
df = manipulator.filtrar_periodo(cursadas_data, fecha_inicio, fecha_fin)
return df
def recursantes_materia(cod_materia):
token = get_token(request)
cod_materia = cod_materia.zfill(5)
carrera = request.args.get('carrera')
fecha_fin = request.args.get('fecha')
anio = fecha_fin.split('-')[0] if fecha_fin else None
mes = fecha_fin.split('-')[1] if fecha_fin else None
semestre = 1 if mes and int(mes) <= 6 else 2
dm = DataManipulator()
# Filtro los inscriptos de la carrera y materia
if carrera:
inscriptos = DataProvider().get_inscriptos(token, carrera, anio,
semestre)
else:
inscriptos = DataProvider().getEnrolled(token, cod_materia, anio,
semestre)
inscriptos_df = DataTransformer().transform_materiascursadas_to_dataframe(
inscriptos)
# Filtro las cursadas de la carrera y materia
if carrera:
cursadas = DataProvider().get_materiascursadas(token, carrera)
else:
cursadas = DataProvider().getTakenSubjects(token, cod_materia)
cursadas_df = DataTransformer().transform_materiascursadas_to_dataframe(
cursadas)
recursantes = dm.get_recursantes(cursadas_df, inscriptos_df, cod_materia)
return json.dumps([{
"Legajo": key,
"Cantidad": value
} for key, value in recursantes.items()])
def promedios_alumno(legajo):
merged_data, _, plan_data = get_materiascursadas_plan(request)
manipulator = DataManipulator()
scores = manipulator.get_scores_alumno(merged_data, legajo)
return json.dumps([{
"nombre": row["periodo_semestre"],
"valor": row["score_periodo"]
} for index, row in DataTransformer().transform_scores_unicos(
scores).iterrows()])
def setUp(self):
self.manipulator = DataManipulator()
self.transformer = DataTransformer()
with open('tests/alumnos_test.json', 'r') as archivo_alumnos:
data = json.loads(archivo_alumnos.read())
df_materias = transformer.transform_to_dataframe(data)
with open('tests/plan_test.json', 'r') as archivo_plan:
data = json.loads(archivo_plan.read())
df_plan = transformer.transform_to_dataframe(data)
self.dataframe = transformer.merge_materias_con_plan(
df_materias, df_plan)
def detalle_aprobados(cod_materia):
manipulator = DataManipulator()
transformer = DataTransformer()
df = get_alumnos_de_materia_periodo(request, cod_materia)
df = manipulator.filtrar_aprobados(df)
detalle_aprobados = manipulator.cantidades_formas_aprobacion(df)
data = detalle_aprobados.to_dict()
resultado = {}
for nombre, valor in data.items():
resultado[transformer.get_forma_aprobacion(nombre)] = valor
return json.dumps([resultado])
def alumnos_carrera(carrera):
token = get_token(request)
transformer = DataTransformer()
json_data = DataProvider().get_alumnos_de_carrera(token, carrera)
data = transformer.transform_to_dataframe(json_data)
inscriptos = DataManipulator().inscriptos_por_carrera(data)['alumno']
return json.dumps([{
"nombre":
transformer.transform_timestamp_to_semester(key),
"cantidad":
value
} for key, value in inscriptos.items()])
def dispersion_score_avance(carrera):
fin = date.today()
inicio = fin - timedelta(days=int(request.args.get('dias')))
data = get_materiascursadas_promedio(request, carrera,
inicio.strftime('%Y-%m-%d'),
fin.strftime('%Y-%m-%d'))
scores = DataManipulator().get_scores_periodos(data)
return json.dumps([{
"Promedio": getattr(row, 'promedio'),
"Alumno": getattr(row, 'alumno'),
"Score": getattr(row, 'score_periodo')
} for row in scores.itertuples()])
def alumno_porcentaje_carrera(legajo):
merged_data, _, plan_data = get_materiascursadas_plan(request)
manipulator = DataManipulator()
# Filtro las materias
materias_alumno = manipulator.filtrar_materias_de_alumno(
merged_data, legajo)
cantidad_aprobadas = manipulator.cantidad_aprobadas(materias_alumno)
cantidad_materias_necesarias = get_cantidad_materias_necesarias(request)
porcentaje = manipulator.porcentaje_aprobadas(
cantidad_aprobadas, cantidad_materias_necesarias)
return json.dumps({
'nombre': 'Porcentaje de avance en carrera',
'valor': str(round(porcentaje, 2))
})
def datos_basicos_materia(cod_materia):
manipulator = DataManipulator()
df = get_materiascursadas(request, None, None, None, cod_materia)
aprobados = manipulator.cantidad_alumnos_aprobados(df, cod_materia)
desaprobados = manipulator.cantidad_alumnos_desaprobados(df, cod_materia)
ausentes = manipulator.cantidad_alumnos_ausentes(df, cod_materia)
faltantes = manipulator.cantidad_alumnos_falta_aprobar(df, cod_materia)
nombre = manipulator.get_nombre_materia(df, cod_materia)
return json.dumps([{
'Aprobados': aprobados,
'Ausentes': ausentes,
'Desaprobados': desaprobados,
'Faltantes': faltantes
}])
def notas_alumno(legajo):
merged_data, _, plan_data = get_materiascursadas_plan(request)
manipulator = DataManipulator()
# Filtro las materias
materias_alumno = manipulator.filtrar_materias_de_alumno(
merged_data, legajo)
return json.dumps([{
'Fecha': row['fecha'],
'Materia': row['materia'],
'Plan': row['plan'],
'Nota': row['nota'],
'Resultado': row['resultado'],
'Acta Examen': row['acta_examen'] or '',
'Acta Promocion': row['acta_promocion'] or ''
} for index, row in materias_alumno.iterrows()])
def porcentajes_areas_alumno(legajo):
merged_data, _, plan_data = get_materiascursadas_plan(request)
fecha_inicio = request.args.get('inicio')
fecha_fin = request.args.get('fin')
manipulator = DataManipulator()
materias_alumno = manipulator.filtrar_materias_de_alumno(
merged_data, legajo)
materias_alumno = manipulator.filtrar_periodo(materias_alumno,
fecha_inicio, fecha_fin)
data = manipulator.porcentajes_aprobadas_areas(plan_data, materias_alumno)
return json.dumps([{
"nombre": nombre,
"valor": valor
} for nombre, valor in data.items()])
def setUp(self):
self.manipulator = DataManipulator()
self.transformer = DataTransformer()
with open('source/tests/json/api_carreras_materiascursadas.json', 'r') as archivo_alumnos:
data = json.loads(archivo_alumnos.read())
self.df_materiascursadas = self.transformer.transform_materiascursadas_to_dataframe(data)
with open('source/tests/json/api_carreras_planes_anio.json', 'r') as archivo_plan:
data = json.loads(archivo_plan.read())
self.df_plan = self.transformer.transform_to_dataframe(data)
with open('source/tests/json/api_carrera_planes_anio_cantidad_materias_necesarias.json', 'r') as archivo_plan:
data = json.loads(archivo_plan.read())
self.cantidad_materias_necesarias = data["cantidad"]
self.dataframe = self.transformer.merge_materias_con_plan(
self.df_materiascursadas, self.df_plan)
def materias_traba(carrera):
from utils import calcular_score_materia
merged_data, _, plan_data = get_materiascursadas_plan(request, carrera)
manipulator = DataManipulator()
# Filtro las materias
materias = manipulator.calcular_materias_traba(merged_data)
return json.dumps([{
'Materia':
row['materia'],
'Promedio de Aprobación':
"%.2f" % row['indice_aprobacion'],
'Obligatorias dependientes':
row['cantidad_obligatoria_de'],
'Score':
"%.2f" % calcular_score_materia(row['cantidad_obligatoria_de'],
row['indice_aprobacion'])
} for index, row in materias.iterrows()])
def get_alumnos_de_materia_periodo(request, cod_materia):
manipulator = DataManipulator()
df = get_materiascursadas(request, None, None, None, cod_materia)
return manipulator.filtrar_alumnos_de_materia(df, cod_materia)