def oncreate_academic(form):
import datetime
cdate = datetime.datetime.now()
import cpfecys
currentyear_period = cpfecys.current_year_period()
#Search for user roles
result = db(db.auth_membership.user_id==auth.user.id).select()
roll_var = ''
i = 0;
for a in result:
if i == 0:
roll_var = a.group_id.role
i = i+1
else:
roll_var = roll_var + ',' + a.group_id.role
db.academic_log.insert(user_name = auth.user.username,
roll = roll_var,
operation_log = 'insert',
after_carnet = form.vars.carnet,
after_email = form.vars.email,
id_academic = form.vars.id,
id_period = str(currentyear_period.id),
description = 'Se agrego registro desde la pagina agregar estudiantes.')
def ondelete_academic(table_involved, id_of_the_deleted_record):
import datetime
import cpfecys
currentyear_period = cpfecys.current_year_period()
cdate = datetime.datetime.now()
student_var = db.academic(id_of_the_deleted_record)
#Search for user roles
result = db(db.auth_membership.user_id==auth.user.id).select()
roll_var = ''
i = 0;
for a in result:
if i == 0:
roll_var = a.group_id.role
i = i+1
else:
roll_var = roll_var + ',' + a.group_id.role
db.academic_log.insert(user_name = auth.user.username,
roll = str(roll_var),
operation_log = 'delete',
before_carnet = student_var.carnet,
before_email = student_var.email,
id_period = str(currentyear_period.id),
description = 'Se elimino el registro desde la pagina estudiantes.')
def consult_quiz():
area = db(db.area_level.name=='DTT Tutor Académico').select().first()
ecys_var=False
if request.vars['ecys'] == "True":
ecys_var=True
import cpfecys
period = cpfecys.current_year_period()
idperiodoc = request.vars['period']
idproject = request.vars['project']
print idproject
project = db(db.project.id==idproject).select().first()
userid = auth.user.id
cursoid = project.project_id
cadena = 'uid:'+str(userid)+':curso:'+str(cursoid)+':quiz:*'
import redis
r = redis.StrictRedis()
a = r.keys(cadena)
cuestionarios = a
lista = db(db.project.project_id==cursoid).select(
db.tb_metadata_quiz.ALL,
db.auth_user.first_name,
db.auth_user.last_name,
db.project.name,
join=[
db.auth_user.on(
db.tb_metadata_quiz.creador == db.auth_user.id
),
db.project.on(
db.project.project_id == db.tb_metadata_quiz.curso)]
)
#lista = db(db.tb_metadata_quiz.id == db.auth_user.id).select()
print lista
return dict(ecys_var = ecys_var, periodo = period, project=project, idperiodoc=idperiodoc, idproject=idproject,a=a,lista=lista)
def courses():
#requires parameter year_period if no one is provided then it is automatically detected
#and shows the current period
year_period = request.vars['year_period']
max_display = 1
currentyear_period = db.period_year(db.period_year.id == year_period)
if not currentyear_period:
import cpfecys
currentyear_period = cpfecys.current_year_period()
current_data = db((db.user_project.period <= currentyear_period.id)&
((db.user_project.period + db.user_project.periods) > currentyear_period.id)&
(db.user_project.assigned_user == auth.user.id)).select()
current_period_name = T(cpfecys.second_period_name)
if currentyear_period.period == cpfecys.first_period.id:
current_period_name = T(cpfecys.first_period_name)
start_index = currentyear_period.id - max_display - 1
if start_index < 1:
start_index = 0
end_index = currentyear_period.id + max_display
periods_before = db(db.period_year).select(limitby=(start_index, currentyear_period.id - 1))
periods_after = db(db.period_year).select(limitby=(currentyear_period.id, end_index))
other_periods = db(db.period_year).select()
return dict(current_data = current_data,
currentyear_period = currentyear_period,
current_period_name = current_period_name,
periods_before = periods_before,
periods_after = periods_after,
other_periods = other_periods)
def ondelete_academic_assignation(table_involved, id_of_the_deleted_record):
import datetime
cdate = datetime.datetime.now()
student_assignation_var = db.academic_course_assignation(id_of_the_deleted_record)
import cpfecys
currentyear_period = cpfecys.current_year_period()
#Search for user roles
result = db(db.auth_membership.user_id==auth.user.id).select()
roll_var = ''
i = 0;
for a in result:
if i == 0:
roll_var = a.group_id.role
i = i+1
else:
roll_var = roll_var + ',' + a.group_id.role
project_name_var = ''
project_var = db(db.project.id == student_assignation_var.assignation).select()
for a in project_var:
project_name_var = a.name
db.academic_course_assignation_log.insert(user_name = auth.user.username,
roll = roll_var,
operation_log = 'delete',
before_carnet = student_assignation_var.carnet.carnet,
before_course = student_assignation_var.assignation.name,
before_year = str(student_assignation_var.semester.yearp) ,
before_semester = str(student_assignation_var.semester.period),
before_laboratory = student_assignation_var.laboratorio,
id_period = str(currentyear_period.id),
description = 'Se elimino el registro desde la pagina Asignar Estudiantes')
def event_editor():
assignation = request.vars['assignation']
#check assignation belongs to this user
import cpfecys
check = db.user_project(id = assignation, assigned_user = auth.user.id)
if (check is None):
#check if there is no assignation or if it is locked (shouldn't be touched)
if (session.last_assignation is None):
redirect(URL('default','index'))
return
else:
check = db.user_project(id = session.last_assignation)
if cpfecys.assignation_is_locked(check):
redirect(URL('default','index'))
return
else:
session.last_assignation = check.id
cyearperiod = cpfecys.current_year_period()
db.public_event.semester.default = cyearperiod.id
db.public_event.semester.writable = False
db.public_event.semester.readable = False
db.public_event.assignation.default = check.id
db.public_event.assignation.writable = False
db.public_event.assignation.readable = False
db.public_event_schedule.public_event.readable = False
db.public_event_schedule.public_event.writable = False
query = (db.public_event.assignation == check.id)
return dict(year = cyearperiod.yearp, semester = cyearperiod.period.name,name = check.project.name,grid = SQLFORM.smartgrid(db.public_event, constraints = {'public_event' : query}))
def reportes():
import cpfecys
period = cpfecys.current_year_period()
periodo = request.vars['period']
project = request.vars['project']
#project = db(db.project.id==idproject).select().first()
myquery = (db.project.id==project) & (db.course_activity.semester==period)
programaciones = db(myquery).select(
db.tb_quiz_actividad.id,
db.tb_quiz_actividad.id_actividad,
db.tb_quiz_actividad.id_quiz,
db.tb_quiz_actividad.fecha,
db.tb_quiz_actividad.inicio,
db.tb_quiz_actividad.duracion,
db.tb_quiz_actividad.finalizado,
db.tb_quiz_actividad.private,
db.tb_quiz_actividad.keyword,
db.tb_metadata_quiz.nombre,
db.tb_metadata_quiz.fecha_creacion,
db.tb_metadata_quiz.creador,
db.tb_metadata_quiz.id,
db.tb_metadata_quiz.curso,
db.project.name,
db.auth_user.id,
db.auth_user.first_name,
db.auth_user.last_name,
db.course_activity_category.category,
db.activity_category.description,
db.course_activity.name,
db.course_activity.semester,
join=[
db.tb_metadata_quiz.on(
db.tb_metadata_quiz.id_quiz == db.tb_quiz_actividad.id_quiz
),
db.project.on(
db.project.project_id == db.tb_metadata_quiz.curso
),
db.auth_user.on(
db.auth_user.id == db.tb_metadata_quiz.creador
),
db.course_activity.on(
db.course_activity.id == db.tb_quiz_actividad.id_actividad
),
db.course_activity_category.on(
db.course_activity_category.id == db.course_activity.course_activity_category
),
db.activity_category.on(
db.activity_category.id == db.course_activity_category.category
)
]
)
print programaciones
return dict(periodo = period, course=project, period=periodo, programaciones=programaciones)
def evaluation():
query=db.evaluation
import cpfecys
cperiod = cpfecys.current_year_period()
db.evaluation.period.default = cperiod.id
db.evaluation.period.writable = False
db.evaluation.period.readable = False
grid = SQLFORM.smartgrid(query, csv=False)
return dict(grid=grid)
def evaluation():
query = db.evaluation
import cpfecys
cperiod = cpfecys.current_year_period()
db.evaluation.period.default = cperiod.id
db.evaluation.period.writable = False
db.evaluation.period.readable = False
grid = SQLFORM.smartgrid(query, csv=False)
return dict(grid=grid)
def register_mail_notifications():
#db.user_project.assigned_user == auth.user.id
#Obtain the current period of the system and all the register periods
period = cpfecys.current_year_period()
periods = db(db.period_year).select()
#Check if the period is change
if request.vars['period'] !=None:
period = request.vars['period']
period = db(db.period_year.id==period).select().first()
#show the page resiter_mail_notifications.html
response.view='notification/register_mail_notifications.html'
#obtain the projects where the student is register and is of the select semester
projects = db((db.user_project.period==period) & (db.user_project.assigned_user == auth.user.id)).select()
# dest=[]
# for student in allProject:
# dest.append(student.project)
# projects = db(db.project.id.belongs(dest)).select()
#obtain the names of the projects that thas register the user
def obtain_nameProjects(userP):
p = db(db.project.id==userP).select()
nameP = ''
for p2 in p:
nameP=p2.name
return nameP
def obtain_period(periodo):
semester = db(db.period.id==periodo).select()
nameS = ''
for s in semester:
nameS=s.name
return nameS
#obtain all the registers of the send notices of the student
def obtain_notices(project):
#name project
n=obtain_nameProjects(project.project)
#name of the year
anio = db(db.period_year.id==project.period).select()
nameY = ''
idP = ''
for a in anio:
nameY=a.yearp
idP = a.period
#name of period
nameS=obtain_period(idP)
#obtain all the notices that has the user has register
notices = db((db.notification_general_log4.emisor==auth.user.username) & (db.notification_general_log4.course==n)&(db.notification_general_log4.period==nameS)&(db.notification_general_log4.yearp==nameY)).select()
return notices
return dict(obtain_nameProjects=obtain_nameProjects,periods=periods, projects=projects, obtain_notices=obtain_notices)
def home_quiz():
area = db(db.area_level.name=='DTT Tutor Académico').select().first()
ecys_var=False
if request.vars['ecys'] == "True":
ecys_var=True
import cpfecys
period = cpfecys.current_year_period()
periodo = request.vars['period']
project = request.vars['project']
return dict(ecys_var = ecys_var, periodo = period, course=project, period=periodo)
def aux_in_courses(project_id):
import cpfecys
period = cpfecys.current_year_period()
return db((db.project.id == project_id)&\
(db.user_project.project == db.project.id)&\
(db.auth_user.id == db.user_project.assigned_user)&\
((db.user_project.period <= period.id) & ((db.user_project.period + db.user_project.periods) > period.id))&\
(db.auth_membership.user_id == db.auth_user.id)&\
(db.auth_membership.group_id == db.auth_group.id)&\
(db.auth_group.role == 'Student')).select()
def consultar_quiz():
area = db(db.area_level.name=='DTT Tutor Académico').select().first()
ecys_var=False
if request.vars['ecys'] == "True":
ecys_var=True
import cpfecys
period = cpfecys.current_year_period()
idperiodoc = request.vars['period']
idproject = request.vars['project']
project = db(db.project.id==idproject).select().first()
idPregunta = 1
return dict(ecys_var = ecys_var, periodo = period, project=project)
def take_quiz():
import cpfecys
period = cpfecys.current_year_period()
periodo = request.vars['period']
project = request.vars['project']
projecto = db(db.project.id==project).select().first()
##inicia codigo viejo
## termina codigo viejo
myquery = (db.vw_quiz_actividad.id_project==int(project)) & (db.vw_quiz_actividad.semestre==int(period))
programaciones = db(myquery).select(db.vw_quiz_actividad.ALL)
print programaciones
return dict(periodo = period, course=project, period=periodo, programaciones=programaciones, project=projecto)
def event_editor():
assignation = request.vars['assignation']
#check assignation belongs to this user
import cpfecys
check = db((db.user_project.assigned_user==auth.user.id)&\
(db.user_project.id == assignation)&\
((db.user_project.period <= cpfecys.current_year_period().id) & \
((db.user_project.period + db.user_project.periods) > cpfecys.current_year_period().id))).select(db.user_project.ALL).first()
if (check is None):
redirect(URL('default','index'))
cyearperiod = cpfecys.current_year_period()
db.public_event.semester.default = cyearperiod.id
db.public_event.semester.writable = False
db.public_event.semester.readable = False
db.public_event.assignation.default = check.id
db.public_event.assignation.writable = False
db.public_event.assignation.readable = False
db.public_event_schedule.public_event.readable = False
db.public_event_schedule.public_event.writable = False
query = (db.public_event.assignation == check.id)
return dict(year = cyearperiod.yearp, semester = cyearperiod.period.name,name = check.project.name,grid = SQLFORM.smartgrid(db.public_event, constraints = {'public_event' : query}))
def user():
"""
exposes:
http://..../[app]/default/user/login
http://..../[app]/default/user/logout
http://..../[app]/default/user/register
http://..../[app]/default/user/profile
http://..../[app]/default/user/retrieve_password
http://..../[app]/default/user/change_password
http://..../[app]/default/user/manage_users (requires membership in
use @auth.requires_login()
@auth.requires_membership('group name')
@auth.requires_permission('read','table name',record_id)
to decorate functions that need access control
"""
if request.args(0) == 'profile':
if ((auth.has_membership('Super-Administrator') == False) & (auth.has_membership('Teacher') == False) & (auth.has_membership('Ecys-Administrator') == False)):
db.auth_user.first_name.writable = False
db.auth_user.last_name.writable = False
db.auth_user.username.writable = False
db.auth_user.email.writable = False
import cpfecys
currentyear_period = cpfecys.current_year_period()
for date_var in db((db.student_control_period.period_name==T(str(currentyear_period.period.name))+" "+str(currentyear_period.yearp))).select():
var_date_finish = date_var.date_finish
from datetime import datetime
if datetime.now() > date_var.date_start and datetime.now() < var_date_finish:
db.auth_user.email.writable = True
pass
pass
db.auth_user.photo.writable = True
review = db((db.photo_review.user_id == auth.user.id)).select().first()
if review is not None:
if review.accepted == True:
db.auth_user.photo.writable = False
pass
pass
pass
if (auth.has_membership('Teacher')):
if str(request.vars["edit_foto"]) == "True":
db.auth_user.photo.writable = True
else:
db.auth_user.photo.writable = False
db.auth_user.username.writable = False
pass
return dict(form=auth())
def user():
"""
exposes:
http://..../[app]/default/user/login
http://..../[app]/default/user/logout
http://..../[app]/default/user/register
http://..../[app]/default/user/profile
http://..../[app]/default/user/retrieve_password
http://..../[app]/default/user/change_password
http://..../[app]/default/user/manage_users (requires membership in
use @auth.requires_login()
@auth.requires_membership('group name')
@auth.requires_permission('read','table name',record_id)
to decorate functions that need access control
"""
if request.args(0) == 'profile':
if ((auth.has_membership('Super-Administrator') == False) & (auth.has_membership('Teacher') == False) & (auth.has_membership('Ecys-Administrator') == False)):
db.auth_user.first_name.writable = False
db.auth_user.last_name.writable = False
db.auth_user.username.writable = False
db.auth_user.email.writable = False
import cpfecys
currentyear_period = cpfecys.current_year_period()
for date_var in db((db.student_control_period.period_name==T(str(currentyear_period.period.name))+" "+str(currentyear_period.yearp))).select():
var_date_finish = date_var.date_finish
from datetime import datetime
if datetime.now() > date_var.date_start and datetime.now() < var_date_finish:
db.auth_user.email.writable = True
pass
pass
db.auth_user.photo.writable = True
review = db((db.photo_review.user_id == auth.user.id)).select().first()
if review is not None:
if review.accepted == True:
db.auth_user.photo.writable = False
pass
pass
pass
if (auth.has_membership('Teacher')):
if str(request.vars["edit_foto"]) == "True":
db.auth_user.photo.writable = True
else:
db.auth_user.photo.writable = False
db.auth_user.username.writable = False
pass
return dict(form=auth())
def event_editor():
assignation = request.vars['assignation']
#check assignation belongs to this user
import cpfecys
check = db((db.user_project.assigned_user==auth.user.id)&\
(db.user_project.id == assignation)&\
((db.user_project.period <= cpfecys.current_year_period().id) & \
((db.user_project.period + db.user_project.periods) > cpfecys.current_year_period().id))).select(db.user_project.ALL).first()
if (check is None):
redirect(URL('default','index'))
cyearperiod = cpfecys.current_year_period()
db.public_event.semester.default = cyearperiod.id
db.public_event.semester.writable = False
db.public_event.semester.readable = False
db.public_event.assignation.default = check.id
db.public_event.assignation.writable = False
db.public_event.assignation.readable = False
db.public_event_schedule.public_event.readable = False
db.public_event_schedule.public_event.writable = False
query = (db.public_event.assignation == check.id)
return dict(year = cyearperiod.yearp, semester = cyearperiod.period.name,name = check.project.name,grid = SQLFORM.smartgrid(db.public_event, constraints = {'public_event' : query}))
def programacion_test():
x = tuple(request.args)
y = str(''.join(x))
ide = int(y)
lista = db(db.tb_metadata_quiz.id_quiz==ide).select(
db.tb_metadata_quiz.creador,
db.tb_metadata_quiz.curso)
#OBTENGO LA METADA DEL QUIZ
lista = db(db.tb_metadata_quiz.id_quiz==ide).select(
db.tb_metadata_quiz.ALL,
db.auth_user.first_name,
db.auth_user.last_name,
db.project.name,
join=[
db.auth_user.on(
db.tb_metadata_quiz.creador == db.auth_user.id
),
db.project.on(
db.project.project_id == db.tb_metadata_quiz.curso)]
)
#OBTENGO LOS CODIGOS DE ACTIVIDADES QUE PERENECEN A UN QUIZ
categorias = db().select(
db.activity_category.id,
db.activity_category.category,
join=[
db.equivalencia_quiz_category.on(
db.equivalencia_quiz_category.categorie == db.activity_category.id
)
]
)
period = cpfecys.current_year_period()
idperiodoc = request.vars['period']
idproject = request.vars['project']
project = db(db.project.id==idproject).select().first()
#Si el periodo actual es igual al periodo recibido en la variable corresponde el quiz
actual = False
if(int(period)==int(idperiodoc)):
actual = True
print categorias
return dict(metadata = lista.first(), categorias = categorias, periodo = period, project =project)
def resources():
#Get the selected item_restriction id from parameter
item_restriction_id = request.vars['r']
#Get the items that belong to current semester
import cpfecys
period = cpfecys.current_year_period()
def teachers_on_project(project_id):
import cpfecys
period = cpfecys.current_year_period()
return db((db.project.id == project_id)&\
(db.user_project.project == db.project.id)&\
(db.auth_user.id == db.user_project.assigned_user)&\
((db.user_project.period <= period.id) & ((db.user_project.period + db.user_project.periods) > period.id))&\
(db.auth_membership.user_id == db.auth_user.id)&\
(db.auth_membership.group_id == db.auth_group.id)&\
(db.auth_group.role == 'Teacher')).select()
def aux_in_courses(project_id):
import cpfecys
period = cpfecys.current_year_period()
return db((db.project.id == project_id)&\
(db.user_project.project == db.project.id)&\
(db.auth_user.id == db.user_project.assigned_user)&\
((db.user_project.period <= period.id) & ((db.user_project.period + db.user_project.periods) > period.id))&\
(db.auth_membership.user_id == db.auth_user.id)&\
(db.auth_membership.group_id == db.auth_group.id)&\
(db.auth_group.role == 'Student')).select()
return dict(teachers_on_project = teachers_on_project,
aux_in_courses = aux_in_courses,
semester = period,
data = db((db.item.created == period)&
(db.item.item_restriction == item_restriction_id)&
(db.item.item_restriction == db.item_restriction.id)&
(db.item_restriction.is_public == True)&
((db.item_restriction.period == period)|(db.item_restriction.permanent == True))&
(db.item.assignation == db.user_project.id)&
(db.user_project.project == db.project.id)&
(db.user_project.project == db.project.id)&\
(db.auth_user.id == db.user_project.assigned_user)&\
(db.user_project.assignation_status == None)&\
(db.auth_membership.user_id == db.auth_user.id)&\
(db.auth_membership.group_id == db.auth_group.id)&\
(db.auth_group.role == 'Student')&
(db.item.id > 0)).select(orderby=db.project.name))
def onupdate_academic(form):
import datetime
import cpfecys
currentyear_period = cpfecys.current_year_period()
cdate = datetime.datetime.now()
#session.flash = T('hola-'+str(form.vars))
#Search for user roles
result = db(db.auth_membership.user_id==auth.user.id).select()
roll_var = ''
i = 0;
for a in result:
if i == 0:
roll_var = a.group_id.role
i = i+1
else:
roll_var = roll_var + ',' + a.group_id.role
student_var = db(db.academic_log.id_academic == form.vars.id).select(orderby=db.academic_log.id)
carnet_var = ''
email_var = ''
for a in student_var:
carnet_var = a.after_carnet
email_var = a.after_email
if form.vars.delete_this_record == None:
db.academic_log.insert(user_name = auth.user.username,
roll = roll_var,
operation_log = 'update',
before_carnet = carnet_var,
before_email = email_var,
after_carnet = form.vars.carnet,
after_email = form.vars.email,
id_academic = form.vars.id,
id_period = str(currentyear_period.id),
description = 'Se modifico registro desde la pagina estudiantes.')
else:
db.academic_log.insert(user_name = auth.user.username,
roll = str(roll_var),
operation_log = 'delete',
before_carnet = carnet_var,
before_email = email_var,
id_period = str(currentyear_period.id),
description = 'Se elimino el registro desde la pagina estudiantes.')
def get_current_reports(period):
from datetime import datetime
import cpfecys
cperiod = cpfecys.current_year_period()
year = str(cperiod.yearp)
if period.period == 1:
start = datetime.strptime(year + '-01-01', "%Y-%m-%d")
end = datetime.strptime(year + '-06-01', "%Y-%m-%d")
else:
start = datetime.strptime(year + '-06-01', "%Y-%m-%d")
end = datetime.strptime(year + '-12-31', "%Y-%m-%d")
reports = db((db.report.assignation == final_practice.user_project.id)&
(db.report.status.name!='Grading')&
(db.report.created >= start)&
(db.report.created <= end))
avg = reports.select((db.report.score.sum()/db.report.score.count()).\
with_alias('avg')).first()['avg'] or 0
reports = reports.select(), avg
return reports
def academic_log():
import cpfecys
#assignation = request.vars['assignation']
year_period = cpfecys.current_year_period()
max_display = 1
currentyear_period = db.period_year(db.period_year.id == year_period)
query = ((
db.academic_course_assignation.semester == currentyear_period.id))
#db.academic_course_assignation.assignation.default = check.project
db.academic_course_assignation.assignation.writable = False
db.academic_course_assignation.assignation.readable = False
db.academic_course_assignation.semester.default = currentyear_period.id
db.academic_course_assignation.semester.writable = False
db.academic_course_assignation.semester.readable = False
grid = SQLFORM.grid(query)
current_period_name = T(cpfecys.second_period.name)
if currentyear_period.period == cpfecys.first_period.id:
current_period_name = T(cpfecys.first_period.name)
start_index = currentyear_period.id - max_display - 1
if start_index < 1:
start_index = 0
end_index = currentyear_period.id + max_display
periods_before = db(db.period_year).select(limitby=(start_index, \
currentyear_period.id - 1))
periods_after = db(db.period_year).select(limitby=(currentyear_period.id, \
end_index))
other_periods = db(db.period_year).select()
return dict(
grid=grid,
currentyear_period=currentyear_period,
current_period_name=current_period_name,
periods_before=periods_before,
periods_after=periods_after,
other_periods=other_periods,
)
def academic_log():
import cpfecys
#assignation = request.vars['assignation']
year_period = cpfecys.current_year_period()
max_display = 1
currentyear_period = db.period_year(db.period_year.id == year_period)
query = ((db.academic_course_assignation.semester == currentyear_period.id))
#db.academic_course_assignation.assignation.default = check.project
db.academic_course_assignation.assignation.writable = False
db.academic_course_assignation.assignation.readable = False
db.academic_course_assignation.semester.default = currentyear_period.id
db.academic_course_assignation.semester.writable = False
db.academic_course_assignation.semester.readable = False
grid = SQLFORM.grid(query)
current_period_name = T(cpfecys.second_period.name)
if currentyear_period.period == cpfecys.first_period.id:
current_period_name = T(cpfecys.first_period.name)
start_index = currentyear_period.id - max_display - 1
if start_index < 1:
start_index = 0
end_index = currentyear_period.id + max_display
periods_before = db(db.period_year).select(limitby=(start_index, \
currentyear_period.id - 1))
periods_after = db(db.period_year).select(limitby=(currentyear_period.id, \
end_index))
other_periods = db(db.period_year).select()
return dict(grid = grid,
currentyear_period = currentyear_period,
current_period_name = current_period_name,
periods_before = periods_before,
periods_after = periods_after,
other_periods = other_periods,
)
def sent_mails():
import cpfecys
all_course = True
if request.vars['period'] is None:
cperiod = cpfecys.current_year_period()
else:
all_course = False
cperiod = db.period_year(db.period_year.id == request.vars['period'])
academic_var = db.academic(db.academic.id_auth_user==auth.user.id)
period_list = db(db.academic_course_assignation.carnet==academic_var.id).select(db.academic_course_assignation.semester,distinct=True)
select_form = FORM(INPUT(_name='semester_id',_type='text'))
if select_form.accepts(request.vars,formname='select_form'):
assignations = db((db.academic_course_assignation.semester==str(select_form.vars.semester_id)) & (db.academic_course_assignation.carnet==academic_var.id)).select()
period_id = str(select_form.vars.semester_id)
all_course = True
else:
assignations = db((db.academic_course_assignation.semester==cperiod.id) & (db.academic_course_assignation.carnet==academic_var.id)).select()
period_id = str(cperiod.id)
return dict(assignations=assignations,email=auth.user.email,period_id=period_id,period_list=period_list,cperiod=cperiod.id, all_course = all_course)
def sent_mails():
import cpfecys
all_course = True
if request.vars['period'] is None:
cperiod = cpfecys.current_year_period()
else:
all_course = False
cperiod = db.period_year(db.period_year.id == request.vars['period'])
academic_var = db.academic(db.academic.id_auth_user == auth.user.id)
period_list = db(
db.academic_course_assignation.carnet == academic_var.id).select(
db.academic_course_assignation.semester, distinct=True)
select_form = FORM(INPUT(_name='semester_id', _type='text'))
if select_form.accepts(request.vars, formname='select_form'):
assignations = db((db.academic_course_assignation.semester == str(
select_form.vars.semester_id))
& (db.academic_course_assignation.carnet ==
academic_var.id)).select()
period_id = str(select_form.vars.semester_id)
all_course = True
else:
assignations = db(
(db.academic_course_assignation.semester == cperiod.id)
& (db.academic_course_assignation.carnet == academic_var.id)
).select()
period_id = str(cperiod.id)
return dict(assignations=assignations,
email=auth.user.email,
period_id=period_id,
period_list=period_list,
cperiod=cperiod.id,
all_course=all_course)
def evaluation_reply():
import cpfecys
cperiod = cpfecys.current_year_period()
project = request.vars['project']
period = request.vars['period']
evaluation = request.vars['evaluation']
evaluated = request.vars['evaluated']
if db((db.auth_user.id==auth.user.id) & \
(db.user_project.project==project) & \
((db.user_project.period <= period) & ((db.user_project.period + db.user_project.periods) > period))).select().first() is None:
academic_var = db.academic(db.academic.id_auth_user == auth.user.id)
if db((db.academic_course_assignation.carnet == academic_var.id)
& (db.academic_course_assignation.semester == period)
& (db.academic_course_assignation.assignation == project)
).select().first() is None:
session.flash = T('Not authorized')
redirect(URL('default', 'index'))
evaluated = db((db.auth_user.id==evaluated) & \
((db.user_project.period <= period) & ((db.user_project.period + db.user_project.periods) > period))).select().first()
if evaluated is None:
session.flash = T('Not authorized')
redirect(URL('default', 'index'))
var_evaluation = db((db.evaluation.id == evaluation)).select().first()
if (str(period) != str(cperiod.id)):
session.flash = T('Not authorized')
redirect(URL('default', 'index'))
user_role = None
if auth.has_membership('Student') or auth.has_membership('Teacher'):
try:
if db((db.user_project.assigned_user == auth.user.id) & \
((db.user_project.period <= period) & ((db.user_project.period + db.user_project.periods) > period))).select().first() is not None:
if auth.has_membership('Student'):
user_role = 2
else:
user_role = 3
except:
None
if auth.has_membership('Academic'):
try:
academic_var = db.academic(
db.academic.id_auth_user == auth.user.id)
if db((db.academic_course_assignation.carnet == academic_var.id)
& (db.academic_course_assignation.semester == period)
).select().first() is not None:
user_role = 5
except:
None
if var_evaluation.repository_evaluation.user_type_evaluator != user_role:
session.flash = T('Not authorized')
redirect(URL('default', 'index'))
var_repository_evaluation = db(
db.repository_evaluation.id ==
var_evaluation.repository_evaluation).select().first()
question_category = db(db.question_repository.repository_evaluation ==
var_evaluation.repository_evaluation).select(
db.question_repository.question_type_name,
distinct=True)
evaluation_result = db((db.evaluation_result.repository_evaluation == var_evaluation.repository_evaluation) &\
(db.evaluation_result.evaluated == evaluated.auth_user.id) & \
(db.evaluation_result.period == period) & \
(db.evaluation_result.project == project) ).select().first()
if (evaluation_result is not None) and \
(db((db.evaluation_auth_user.evaluation_result == evaluation_result.id) &\
(db.evaluation_auth_user.evaluator == auth.user.id) ).select().first() is not None):
session.flash = T('Not authorized')
redirect(URL('default', 'index'))
if (request.args(0) == 'send'):
if evaluation_result is None:
evaluation_result_id = db.evaluation_result.insert(
repository_evaluation=var_evaluation.repository_evaluation,
evaluated=evaluated.auth_user.id,
period=period,
project=project)
else:
evaluation_result_id = evaluation_result.id
evaluation_auth_user = db((db.evaluation_auth_user.evaluation_result == evaluation_result_id) &\
(db.evaluation_auth_user.evaluator == auth.user.id) ).select().first()
if evaluation_auth_user is None:
db.evaluation_auth_user.insert(
evaluation_result=evaluation_result_id, evaluator=auth.user.id)
question_query = db((db.question_repository.repository_evaluation ==
var_evaluation.repository_evaluation)).select()
for question in question_query:
answer_query = db(
(db.repository_answer.question_repository == question.id
)).select()
if len(answer_query) == 0:
if (request.vars['group_' + str(question.id)] is not None) & (
request.vars['group_' + str(question.id)] != ""):
db.evaluation_solve_text.insert(
evaluation_result=evaluation_result_id,
question_repository=question.id,
answer=request.vars['group_' + str(question.id)])
else:
for answer in answer_query:
if answer.exclusive_one_answer == True:
if request.vars['group_' +
str(question.id)] is not None:
if str(request.vars['group_' +
str(question.id)]) == str(
answer.id):
evaluation_solve_detail = db((db.evaluation_solve_detail.evaluation_result == evaluation_result_id) &\
(db.evaluation_solve_detail.question_repository == question.id) & \
(db.evaluation_solve_detail.repository_answer == answer.id)).select().first()
if evaluation_solve_detail is None:
db.evaluation_solve_detail.insert(
evaluation_result=evaluation_result_id,
question_repository=question.id,
repository_answer=answer.id,
total_count=1)
else:
db(
db.evaluation_solve_detail.id ==
evaluation_solve_detail.id
).update(total_count=(
evaluation_solve_detail.total_count +
1))
session.flash = T('The evaluation has been sent')
redirect(
URL('evaluation',
'evaluation_list',
vars=dict(period=period, project=project)))
return dict(var_evaluation=var_evaluation,
var_repository_evaluation=var_repository_evaluation,
question_category=question_category,
evaluated=evaluated)
def resources():
#Get the selected item_restriction id from parameter
item_restriction_id = request.vars['r']
#Get the items that belong to current semester
import cpfecys
#emarquez: por default, sigue igual, si envia parametro d periodo, se cambia
parameter_period = request.vars['period'] or False
period = cpfecys.current_year_period()
#emarquez
if parameter_period:
period = db(db.period_year.id == parameter_period).select().first()
def teachers_on_project(project_id):
import cpfecys
#period = cpfecys.current_year_period()
if cpfecys.is_semestre(period.id):
return db((db.project.id == project_id)&\
(db.user_project.project == db.project.id)&\
(db.auth_user.id == db.user_project.assigned_user)&\
((db.user_project.period <= period.id) & ((db.user_project.period + db.user_project.periods) > period.id))&\
(db.auth_membership.user_id == db.auth_user.id)&\
(db.auth_membership.group_id == db.auth_group.id)&\
(db.auth_group.role == 'Teacher')).select()
else:
return db((db.project.id == project_id)&\
(db.user_project.project == db.project.id)&\
(db.auth_user.id == db.user_project.assigned_user)&\
(db.user_project.period == period.id) &\
(db.auth_membership.user_id == db.auth_user.id)&\
(db.auth_membership.group_id == db.auth_group.id)&\
(db.auth_group.role == 'Teacher')).select()
def aux_in_courses(project_id):
import cpfecys
#period = cpfecys.current_year_period()
rowsi = db((db.period.id==db.period_detail.period)&(db.period_year.period==db.period.id)).select()
lst = []
for r in rowsi:
lst.append(r.period_year.id)
return db((db.project.id == project_id)&\
(db.user_project.project == db.project.id)&\
(db.auth_user.id == db.user_project.assigned_user)&\
((~db.user_project.period.belongs(lst))&(db.user_project.period <= period.id) & ((db.user_project.period + db.user_project.periods) > period.id))&\
(db.auth_membership.user_id == db.auth_user.id)&\
(db.auth_membership.group_id == db.auth_group.id)&\
(db.auth_group.role == 'Student')).select()
return dict(teachers_on_project = teachers_on_project,
aux_in_courses = aux_in_courses,
semester = period,
data = db((db.item.created == period)&
(db.item.item_restriction == item_restriction_id)&
(db.item.item_restriction == db.item_restriction.id)&
(db.item_restriction.is_public == True)&
((db.item_restriction.period == period)|(db.item_restriction.permanent == True))&
(db.item.assignation == db.user_project.id)&
(db.user_project.project == db.project.id)&
(db.user_project.project == db.project.id)&\
(db.auth_user.id == db.user_project.assigned_user)&\
(db.user_project.assignation_status == None)&\
(db.auth_membership.user_id == db.auth_user.id)&\
(db.auth_membership.group_id == db.auth_group.id)&\
(db.auth_group.role == 'Student')&
(db.item.id > 0)).select(orderby=db.project.name),
period =parameter_period)
def check_student(check_carnet):
svp=db(db.validate_student).select().first()
if svp is not None:
try:
#CONSUME THE WEBSERVICE
from gluon.contrib.pysimplesoap.client import SoapClient
from gluon.contrib.pysimplesoap.client import SimpleXMLElement
client = SoapClient(
location = svp.supplier,
action = svp.supplier+"/"+svp.action_service,
namespace = svp.supplier,
soap_ns=svp.type_service, trace = True, ns = False)
import cpfecys
year = cpfecys.current_year_period()
sent="<"+svp.send+">"
for svpf in db(db.validate_student_parameters).select():
sent +="<"+svpf.parameter_name_validate+">"+svpf.parameter_value_validate+"</"+svpf.parameter_name_validate+">"
sent += "<CARNET>"+str(check_carnet)+"</CARNET><CICLO>"+str(year.yearp)+"</CICLO></"+svp.send+">"
back = client.call(svp.action_service,xmlDatos=sent)
#PREPARE FOR RETURNED XML WEB SERVICE
xml = back.as_xml()
xml=xml.replace('<','<')
xml=xml.replace('>','>')
inicio = xml.find("<"+svp.receive+">")
final = xml.find("</"+svp.receive+">")
xml = xml[inicio:(final+17)]
import xml.etree.ElementTree as ET
root = ET.fromstring(xml)
xml = SimpleXMLElement(xml)
#VARIABLE TO CHECK THE CORRECT FUNCTIONING
CARNET = xml.CARNET
NOMBRES = xml.NOMBRES
APELLIDOS= xml.APELLIDOS
CORREO = xml.CORREO
#Unicode Nombres
try:
str(NOMBRES)
except:
apellidos_var = unicode(NOMBRES).split(' ')
appellidos_return = None
for apellido in apellidos_var:
try:
if appellidos_return is None:
appellidos_return = str(apellido)
else:
appellidos_return = appellidos_return + " " + str(apellido)
except:
try:
temp = unicode(apellido).encode('utf-8').replace('á','á').replace('é','é').replace('Ã','í').replace('ó','ó').replace('ú','ú').replace('ñ','ñ').replace('Ã','Á').replace('É','É').replace('Ã','Í').replace('Ó','Ó').replace('Ú','Ú').replace('Ñ','Ñ').replace('ü‘','ü')
except:
None
apellido = temp
if appellidos_return is None:
appellidos_return = str(apellido)
else:
appellidos_return = appellidos_return + " " + str(apellido)
NOMBRES = appellidos_return
#Unicode APELLIDOS
try:
str(APELLIDOS)
except:
apellidos_var = unicode(APELLIDOS).split(' ')
appellidos_return = None
for apellido in apellidos_var:
try:
if appellidos_return is None:
appellidos_return = str(apellido)
else:
appellidos_return = appellidos_return + " " + str(apellido)
except:
try:
temp = unicode(apellido).encode('utf-8').replace('á','á').replace('é','é').replace('Ã','í').replace('ó','ó').replace('ú','ú').replace('ñ','ñ').replace('Ã','Á').replace('É','É').replace('Ã','Í').replace('Ó','Ó').replace('Ú','Ú').replace('Ñ','Ñ').replace('ü‘','ü')
except:
None
apellido = temp
if appellidos_return is None:
appellidos_return = str(apellido)
else:
appellidos_return = appellidos_return + " " + str(apellido)
APELLIDOS = appellidos_return
if (CARNET is None or CARNET=='') and (NOMBRES is None or NOMBRES=='') and (APELLIDOS is None or APELLIDOS=='') and (CORREO is None or CORREO==''):
return dict(flag=False,error=False,message=T('The record was removed because the user is not registered to the academic cycle'))
else:
isStuden=False
for c in root.findall('CARRERA'):
if c.find('UNIDAD').text=="08" and c.find('EXTENSION').text=="00" and (c.find('CARRERA').text=="05" or c.find('CARRERA').text=="09" or c.find('CARRERA').text=="07"):
isStuden=True
if isStuden==False:
return dict(flag=False,error=False,message=T('The record was removed because students not enrolled in career allowed to use the system'))
else:
return dict(flag=True, carnet=int(str(CARNET)), nombres=(NOMBRES), apellidos=(APELLIDOS), correo=str(CORREO),error=False)
except:
return dict(flag=False,error=True,message=T('Error with web service validation'))
else:
return dict(flag=False,error=True,message=T('Error with web service validation'))
def inbox():
import cpfecys
cperiod = cpfecys.current_year_period()
period_list = []
period_list2 = []
assignations = []
coursesAdmin = []
select_form = FORM(INPUT(_name='semester_id',_type='text'))
if select_form.accepts(request.vars,formname='select_form'):
if auth.has_membership('Academic'):
assignations = db((db.academic_course_assignation.semester==str(select_form.vars.semester_id)) & (db.academic_course_assignation.carnet==academic_var.id)).select()
period_id = str(select_form.vars.semester_id)
else:
if auth.has_membership('Academic'):
assignations = db((db.academic_course_assignation.semester==cperiod.id) & (db.academic_course_assignation.carnet==academic_var.id)).select()
period_id = str(cperiod.id)
if (auth.has_membership('Student') or auth.has_membership('Teacher')):
#coursesAdmin = db((db.user_project.assigned_user == auth.user.id) & (db.user_project.period == period_id) & (db.user_project.project==db.project.id) ).select()
coursesAdmin = db((db.user_project.assigned_user==auth.user.id)&\
(db.user_project.project == db.project.id)&\
((db.user_project.period <= period_id) & \
((db.user_project.period + db.user_project.periods) > period_id))).select()
#temp = db((db.user_project.assigned_user == auth.user.id) & (db.user_project.project==db.project.id) ).select(db.user_project.period ,distinct=True)
for t in db(db.period_year).select():
assignation_temp = db((db.user_project.assigned_user==auth.user.id)&\
(db.user_project.project == db.project.id)&\
((db.user_project.period <= t.id) & \
((db.user_project.period + db.user_project.periods) > t.id))).select(db.user_project.ALL).first()
periods_temp = db(db.period_year).select(orderby=~db.period_year.id)
periods = []
for period_temp in periods_temp:
added = False
if auth.has_membership('Student') or auth.has_membership('Teacher'):
try:
if db((db.user_project.assigned_user==auth.user.id)&\
(db.user_project.period == db.period_year.id)&\
((db.user_project.period <= t.id) & \
((db.user_project.period + db.user_project.periods) > period_temp.id))).select(db.user_project.ALL).first() is not None:
periods.append(period_temp)
added = True
except:
None
if auth.has_membership('Academic'):
try:
if db((db.academic_course_assignation.carnet==academic_var.id)&(db.academic_course_assignation.semester==period_temp.id)).select().first() is not None:
if added == False:
periods.append(period_temp)
except:
None
period_var = db(db.period_year.id == period_id).select().first()
return dict(assignations=assignations,email=auth.user.email,period_var=period_var,period_id=period_id,period_list=periods,cperiod=cperiod.id,coursesAdmin=coursesAdmin)
def graph():
#Import DB
import cpfecys
from decimal import Decimal
if auth.has_membership('Super-Administrator') or auth.has_membership(
'Evaluator360') or auth.has_membership('Ecys-Administrator'):
#Obtain the current period of the system and all the register periods
period = cpfecys.current_year_period()
periods = db(db.period_year).select()
# 2=student; 3= teacher; 6=ecys-administrator
group = db((db.auth_group.id == 2)|\
(db.auth_group.id == 3)|\
(db.auth_group.id == 6)).select(db.auth_group.id).first()
groups = db((db.auth_group.id == 2)|\
(db.auth_group.id == 3)|\
(db.auth_group.id == 6)).select()
#Check if the period has changed
if request.vars['period'] is None:
None
else:
if request.vars['period'] != '':
period = request.vars['period']
period = db(db.period_year.id == period).select().first()
else:
session.flash = T('Not valid Action.')
redirect(URL('default', 'index'))
#check for type of rol selected
if request.vars['group'] is None:
None
else:
if request.vars['group'] != '':
group = request.vars['group']
group = db(db.auth_group.id == group).select().first()
else:
session.flash = T('Not valid Action.')
redirect(URL('default', 'index'))
columnTotal = (
(db.answer.grade * db.evaluation_solve_detail.total_count).sum() /
(db.evaluation_solve_detail.total_count.sum())).with_alias('total')
rows = db((db.auth_membership.user_id == db.auth_user.id)
& (db.auth_membership.group_id == db.auth_group.id)
& (db.evaluation_result.evaluated == db.auth_user.id)
& (db.evaluation_solve_detail.evaluation_result ==
db.evaluation_result.id)
& (db.evaluation_solve_detail.repository_answer ==
db.repository_answer.id)
& (db.evaluation_solve_detail.question_repository ==
db.question_repository.id)
& (db.repository_answer.question_repository ==
db.question_repository.id)
& (db.evaluation_result.repository_evaluation ==
db.repository_evaluation.id)
& (db.repository_answer.answer == db.answer.answer)
& (db.repository_evaluation.user_type_evaluated ==
db.auth_group.id) & (db.auth_group.id == group)
& (db.evaluation_result.period == period)).select(
db.question_repository.question,
columnTotal,
groupby=db.question_repository.id)
constantCien = Decimal(100)
graphVal = Decimal(0)
resGraph = []
labelGraph = []
for row in rows:
graphVal = row.total / constantCien
resGraph.append("%.3f" % (graphVal))
labelGraph.append(row.question_repository.question)
pass
gridAnswer = db(db.answer).select(db.answer.grade, db.answer.answer)
else:
session.flash = T('Not authorized')
redirect(URL('default', 'index'))
return dict(periods=periods,
period=period,
periodo=period,
gridAnswer=gridAnswer,
resGraph=resGraph,
labelGraph=labelGraph,
group=group,
groups=groups,
grupo=group)
def results_search():
#Import DB
import cpfecys
from decimal import Decimal
if auth.has_membership('Super-Administrator') or auth.has_membership(
'Evaluator360') or auth.has_membership('Ecys-Administrator'):
#User information
first_name = auth.user.first_name
last_name = auth.user.last_name
user_id = auth.user.id
fullname = first_name + ' ' + last_name
#Obtain the current period of the system and all the register periods
period = cpfecys.current_year_period()
periods = db(db.period_year).select()
group = db((db.auth_group.id == 2)|\
(db.auth_group.id == 3)|\
(db.auth_group.id == 6)).select(db.auth_group.id).first()
groups = db((db.auth_group.id == 2)|\
(db.auth_group.id == 3)|\
(db.auth_group.id == 6)).select()
#Check if the period has changed
if request.vars['period'] is None:
None
else:
if request.vars['period'] != '':
period = request.vars['period']
period = db(db.period_year.id == period).select().first()
else:
session.flash = T('Not valid Action.')
redirect(URL('default', 'index'))
#check for type of rol selected
if request.vars['group'] is None:
None
else:
if request.vars['group'] != '':
group = request.vars['group']
group = db(db.auth_group.id == group).select().first()
else:
session.flash = T('Not valid Action.')
redirect(URL('default', 'index'))
columnTotal = (
(db.answer.grade * db.evaluation_solve_detail.total_count).sum() /
(db.evaluation_solve_detail.total_count.sum())).with_alias('total')
rows = db((db.auth_membership.user_id == db.auth_user.id)
& (db.auth_membership.group_id == db.auth_group.id)
& (db.evaluation_result.evaluated == db.auth_user.id)
& (db.evaluation_solve_detail.evaluation_result ==
db.evaluation_result.id)
& (db.evaluation_solve_detail.repository_answer ==
db.repository_answer.id)
& (db.evaluation_solve_detail.question_repository ==
db.question_repository.id)
& (db.repository_answer.question_repository ==
db.question_repository.id)
& (db.evaluation_result.repository_evaluation ==
db.repository_evaluation.id)
& (db.repository_answer.answer == db.answer.answer)
& (db.repository_evaluation.user_type_evaluated ==
db.auth_group.id) & (db.auth_group.id == group)
& (db.evaluation_result.period == period)).select(
db.question_repository.question,
columnTotal,
groupby=db.question_repository.id)
suma = Decimal(0)
promedio = 0
constantCien = Decimal(100)
graphVal = Decimal(0)
resGraph = []
labelGraph = []
if rows.first() is not None:
for row in rows:
suma = row.total + suma
graphVal = row.total / constantCien
resGraph.append("%.3f" % (graphVal))
labelGraph.append(row.question_repository.question)
avg = suma / len(rows)
promedio = int(avg)
gridAnswer = db(db.answer).select(db.answer.grade, db.answer.answer)
else:
session.flash = T('Not authorized')
redirect(URL('default', 'index'))
min_average = 40
max_average = 60
return dict(periods=periods,
period=period,
periodo=period,
fullname=fullname,
rows=rows,
promedio=promedio,
gridAnswer=gridAnswer,
resGraph=resGraph,
min_average=min_average,
max_average=max_average,
group=group,
groups=groups,
grupo=group)
def graphs():
#requires parameter of project if none is provided then redirected to courses
project_id = request.vars['project']
#This also validates the current user is assigned in the project
if not project_id: redirect(URL('courses'))
current_project = db((db.user_project.assigned_user == auth.user.id)&
(db.project.id == project_id)).select().first()
if not current_project: redirect(URL('courses'))
#requires parameter year_period if no one is provided then it is automatically detected
#and shows the current period
year_period = request.vars['year_period']
max_display = 1
currentyear_period = db.period_year(db.period_year.id == year_period)
if not currentyear_period:
import cpfecys
currentyear_period = cpfecys.current_year_period()
current_data = db((db.user_project.period <= currentyear_period.id)&
((db.user_project.period + db.user_project.periods) > currentyear_period.id)&
(db.user_project.project == current_project.project.id)&
(db.auth_group.role == 'Student')&
(db.auth_membership.group_id == db.auth_group.id)&
(db.user_project.assigned_user == db.auth_membership.user_id)).select()
import cpfecys
current_period_name = T(cpfecys.second_period_name)
#if we are second semester then start is 1st july
import datetime
start_date = datetime.date(currentyear_period.yearp, 7, 7)
end_date = datetime.date(currentyear_period.yearp, 12, 31)
if currentyear_period.period == cpfecys.first_period.id:
current_period_name = T(cpfecys.first_period_name)
#else we are on first semester, start jan 1st
start_date = datetime.date(currentyear_period.yearp, 1, 1)
end_date = datetime.date(currentyear_period.yearp, 6, 30)
# i need all reports delivered by students for this semester
reports = db((db.user_project.period <= currentyear_period.id)&
((db.user_project.period + db.user_project.periods) > currentyear_period.id)&
(db.user_project.project == current_project.project.id)&
(db.auth_group.role == 'Student')&
(db.auth_membership.group_id == db.auth_group.id)&
(db.user_project.assigned_user == db.auth_membership.user_id)&
(db.report_restriction.start_date >= start_date)&
(db.report_restriction.start_date <= end_date)).select(db.report.ALL, db.report_restriction.ALL, db.user_project.ALL, db.auth_group.ALL, db.auth_membership.ALL, orderby=db.user_project.assigned_user|db.report_restriction.start_date|db.report_restriction.name, left=[db.report.on(db.user_project.id == db.report.assignation), db.report_restriction.on(db.report.report_restriction == db.report_restriction.id)])
report_activities = db((db.user_project.period <= currentyear_period.id)&
((db.user_project.period + db.user_project.periods) > currentyear_period.id)&
(db.user_project.project == current_project.project.id)&
(db.auth_group.role == 'Student')&
(db.auth_membership.group_id == db.auth_group.id)&
(db.user_project.assigned_user == db.auth_membership.user_id)&
(db.report_restriction.start_date >= start_date)&
(db.report_restriction.start_date <= end_date)&
(db.report.id == db.log_metrics.report)).select(db.log_metrics.ALL, db.report.ALL, db.report_restriction.ALL, db.user_project.ALL, db.auth_group.ALL, db.auth_membership.ALL, orderby=db.user_project.assigned_user|db.report_restriction.start_date|db.report_restriction.name|db.log_metrics.created, left=[db.report.on(db.user_project.id == db.report.assignation), db.report_restriction.on(db.report.report_restriction == db.report_restriction.id)])
# A helper to display this code within js stuff
def values_display(values):
result = "["
old_user = None
for item in values:
if old_user != item.user_project.assigned_user.username:
if old_user is not None:
result += "]},"
old_user = item.user_project.assigned_user.username
result += "{ name: '" + item.user_project.assigned_user.username + " - " + item.user_project.assigned_user.first_name +"',"
result += "data: ["
#categories.add(item.report.report_restriction)
result += str(item.report.desertion_continued or 0) + ','
result += "]}]"
return XML(result)
# A helper to display this code within js stuff
def values_display_activities(values):
result = "["
old_user = None
for item in values:
if old_user != item.user_project.assigned_user.username:
if old_user is not None:
result += "]},"
old_user = item.user_project.assigned_user.username
result += "{ name: '" + item.user_project.assigned_user.username + " - " + item.user_project.assigned_user.first_name +"',"
result += "data: ["
#categories.add(item.report.report_restriction)
result += str(item.log_metrics.mediana or 0) + ','
result += "]}]"
return XML(result)
start_index = currentyear_period.id - max_display - 1
if start_index < 1:
start_index = 0
end_index = currentyear_period.id + max_display
periods_before = db(db.period_year).select(limitby=(start_index, currentyear_period.id - 1))
periods_after = db(db.period_year).select(limitby=(currentyear_period.id, end_index))
other_periods = db(db.period_year).select()
return dict(current_project = current_project,
current_data = current_data,
currentyear_period = currentyear_period,
current_period_name = current_period_name,
current_reports = reports,
values_display = values_display,
values_display_activities = values_display_activities,
report_activities = report_activities,
periods_before = periods_before,
periods_after = periods_after,
other_periods = other_periods)
def send_mail():
import cpfecys
cperiod = cpfecys.current_year_period()
assigned = db((db.user_project.assigned_user == auth.user.id) & ((db.user_project.period <= cperiod.id) & \
((db.user_project.period + db.user_project.periods + 1) > cperiod.id)) & (db.user_project.project==request.vars['project']) ).select(db.user_project.ALL).first()
try:
if assigned is None:
carnet_var = db(
db.academic.id_auth_user == auth.user.id).select().first()
assigned_user_var = db(
(db.academic_course_assignation.carnet == carnet_var.id)
& (db.academic_course_assignation.assignation ==
request.vars['project'])).select().first()
if (assigned_user_var.semester == cperiod.id) or (
(assigned_user_var.semester + 1) == cperiod.id):
None
else:
session.flash = T('Not authorized')
redirect(URL('default', 'index'))
except:
session.flash = T('Not authorized')
redirect(URL('default', 'index'))
if (request.vars['semester_id'] is None) or (str(
request.vars['semester_id']) == "None"):
period_id = cperiod.id
else:
period_id = request.vars['semester_id']
cperiod = db(db.period_year.id == period_id).select().first()
period_list = []
if (request.args(0) == 'send'):
email = request.vars['mail']
if email != None:
name = request.vars['name']
message = request.vars['message']
subject = request.vars['subject']
remessage = request.vars['remessage']
resub = request.vars['resub']
retime = request.vars['retime']
var_project_name = request.vars['var_project_name']
if message != '' and subject != '':
fail = reply_mail_with_email(email, message, remessage, retime,
resub, subject, cperiod,
var_project_name)
if fail > 0:
response.flash = T('Sent Error')
else:
response.flash = T('Mail Sent')
else:
response.flash = T('Fill all fields of the mail')
return dict(email=email,
name=name,
remessage=remessage,
retime=retime,
resub=resub,
var_project_name=var_project_name)
else:
list_users = request.vars['list_users']
message = request.vars['message']
subject = request.vars['subject']
var_course = request.vars['var_course']
if list_users != None and var_course != '' and message != '' and subject != '':
fail = send_mail_to_users(list_users, message, subject,
cperiod.period.name, cperiod.yearp,
var_course)
if fail > 0:
response.flash = T('Sent Error')
else:
response.flash = T('Mail Sent')
else:
response.flash = T('Fill all fields of the mail')
academic_var = db.academic(
db.academic.id_auth_user == auth.user.id)
assignations = []
assignations = db(
(db.academic_course_assignation.semester == period_id)
& (db.academic_course_assignation.carnet == academic_var.id)
).select()
period_list = db(db.academic_course_assignation.carnet ==
academic_var.id).select(
db.academic_course_assignation.semester,
distinct=True)
return dict(email=None,
assignations=assignations,
cperiod=cperiod,
period_list=period_list,
period_id=period_id)
else:
if (request.args(0) == 'period'):
period_id = subject = request.vars['semester_id']
if request.vars['mail'] != None:
email = request.vars['mail']
name = request.vars['name']
remessage = request.vars['remessage']
retime = request.vars['retime']
resub = request.vars['resub']
project_var = db.project(db.project.id == request.vars['project'])
var_project_name = project_var.name
return dict(email=email,
name=name,
remessage=remessage,
retime=retime,
resub=resub,
var_project_name=var_project_name)
else:
academic_var = db.academic(
db.academic.id_auth_user == auth.user.id)
assignations = db(
(db.academic_course_assignation.semester == period_id)
& (db.academic_course_assignation.carnet == academic_var.id)
).select()
period_list = db(db.academic_course_assignation.carnet ==
academic_var.id).select(
db.academic_course_assignation.semester,
distinct=True)
return dict(email=None,
assignations=assignations,
cperiod=cperiod,
period_list=period_list,
period_id=period_id)
def evaluation_reply():
import cpfecys
cperiod = cpfecys.current_year_period()
project = request.vars['project']
period = request.vars['period']
evaluation = request.vars['evaluation']
evaluated = request.vars['evaluated']
if db((db.auth_user.id==auth.user.id) & \
(db.user_project.project==project) & \
((db.user_project.period <= period) & ((db.user_project.period + db.user_project.periods) > period))).select().first() is None:
academic_var = db.academic(db.academic.id_auth_user==auth.user.id)
if db((db.academic_course_assignation.carnet==academic_var.id)&(db.academic_course_assignation.semester==period)&(db.academic_course_assignation.assignation==project)).select().first() is None:
session.flash =T('Not authorized')
redirect(URL('default','index'))
evaluated = db((db.auth_user.id==evaluated) & \
((db.user_project.period <= period) & ((db.user_project.period + db.user_project.periods) > period))).select().first()
if evaluated is None:
session.flash =T('Not authorized')
redirect(URL('default','index'))
var_evaluation = db((db.evaluation.id == evaluation)).select().first()
if (str(period) != str(cperiod.id)):
session.flash =T('Not authorized')
redirect(URL('default','index'))
user_role = None
if auth.has_membership('Student') or auth.has_membership('Teacher'):
try:
if db((db.user_project.assigned_user == auth.user.id) & \
((db.user_project.period <= period) & ((db.user_project.period + db.user_project.periods) > period))).select().first() is not None:
if auth.has_membership('Student'):
user_role = 2
else:
user_role = 3
except:
None
if auth.has_membership('Academic'):
try:
academic_var = db.academic(db.academic.id_auth_user==auth.user.id)
if db((db.academic_course_assignation.carnet==academic_var.id)&(db.academic_course_assignation.semester==period)).select().first() is not None:
user_role = 5
except:
None
if var_evaluation.repository_evaluation.user_type_evaluator != user_role:
session.flash =T('Not authorized')
redirect(URL('default','index'))
var_repository_evaluation = db(db.repository_evaluation.id == var_evaluation.repository_evaluation).select().first()
question_category = db(db.question_repository.repository_evaluation == var_evaluation.repository_evaluation).select(db.question_repository.question_type_name,distinct=True)
evaluation_result = db((db.evaluation_result.repository_evaluation == var_evaluation.repository_evaluation) &\
(db.evaluation_result.evaluated == evaluated.auth_user.id) & \
(db.evaluation_result.period == period) & \
(db.evaluation_result.project == project) ).select().first()
if (evaluation_result is not None) and \
(db((db.evaluation_auth_user.evaluation_result == evaluation_result.id) &\
(db.evaluation_auth_user.evaluator == auth.user.id) ).select().first() is not None):
session.flash =T('Not authorized')
redirect(URL('default','index'))
if (request.args(0) == 'send'):
if evaluation_result is None:
evaluation_result_id = db.evaluation_result.insert(repository_evaluation = var_evaluation.repository_evaluation,
evaluated = evaluated.auth_user.id,
period = period,
project = project)
else:
evaluation_result_id = evaluation_result.id
evaluation_auth_user = db((db.evaluation_auth_user.evaluation_result == evaluation_result_id) &\
(db.evaluation_auth_user.evaluator == auth.user.id) ).select().first()
if evaluation_auth_user is None:
db.evaluation_auth_user.insert(evaluation_result = evaluation_result_id,
evaluator = auth.user.id)
question_query = db((db.question_repository.repository_evaluation == var_evaluation.repository_evaluation)).select()
for question in question_query:
answer_query = db((db.repository_answer.question_repository == question.id) ).select()
if len(answer_query) == 0:
if (request.vars['group_'+str(question.id)] is not None) & (request.vars['group_'+str(question.id)] != ""):
db.evaluation_solve_text.insert(evaluation_result = evaluation_result_id,
question_repository = question.id,
answer = request.vars['group_'+str(question.id)])
else:
for answer in answer_query:
if answer.exclusive_one_answer == True:
if request.vars['group_'+str(question.id)] is not None:
if str(request.vars['group_'+str(question.id)]) == str(answer.id):
evaluation_solve_detail = db((db.evaluation_solve_detail.evaluation_result == evaluation_result_id) &\
(db.evaluation_solve_detail.question_repository == question.id) & \
(db.evaluation_solve_detail.repository_answer == answer.id)).select().first()
if evaluation_solve_detail is None:
db.evaluation_solve_detail.insert(evaluation_result = evaluation_result_id,
question_repository = question.id,
repository_answer = answer.id,
total_count = 1)
else:
db(db.evaluation_solve_detail.id == evaluation_solve_detail.id).update(total_count = (evaluation_solve_detail.total_count + 1) )
session.flash = T('The evaluation has been sent')
redirect(URL('evaluation','evaluation_list', vars=dict(period=period,project=project) ))
return dict(var_evaluation = var_evaluation,
var_repository_evaluation = var_repository_evaluation,
question_category = question_category,
evaluated = evaluated)
def academic_assignation_upload():
def files():
f = db(db.uploaded_file.name=='CargaEstudiantes_TutoresAcademicos').select()
nameP = ''
for p2 in f:
nameP=p2.file_data
return nameP
return dict(nameP=nameP)
assignation = request.vars['assignation']
check = db.user_project(id=assignation, assigned_user = auth.user.id)
name = check.project.name
import csv
error_users = []
aviso_users = []
success = False
import cpfecys
import datetime
cdate = datetime.datetime.now()
current_period = cpfecys.current_year_period()
if request.vars.csvfile != None:
try:
file = request.vars.csvfile.file
except AttributeError:
response.flash = T('Please upload a file.')
return dict(success = False,
file = False,
periods = periods,
current_period = current_period,
name=name, files=files)
try:
cr = csv.reader(file, delimiter=',', quotechar='"')
success = True
header = next(cr)
for row in cr:
## parameters
rcarnet = row[0]
remail = row[1]
rlaboratorio = row[2]
## check if user exists
check = db.user_project(id =assignation, assigned_user = auth.user.id)
usr = db.academic(db.academic.carnet == rcarnet)
if usr is None:
#Email validation
if rcarnet == '':
row.append(T('Error: ') + T('El carnet es un campo obligatorio.'))
error_users.append(row)
else:
if IS_EMAIL()(remail)[1]:
row.append(T('Error: ') + T('El correo ingresado no es correcto.'))
error_users.append(row)
else:
#T o F validation
if rlaboratorio != 'T' and rlaboratorio != 'F':
row.append(T('Error: ') + T('El tipo de laboratorio ingresado no es correcto. Este debe ser T o F.'))
error_users.append(row)
else:
#insert a new user with csv data
usr = db.academic.insert(carnet = rcarnet,
email = remail)
#Add log
db.academic_log.insert(user_name = auth.user.username,
roll = 'Student',
operation_log = 'insert',
after_carnet = rcarnet,
after_email = remail,
id_academic = usr.id,
id_period = current_period.id,
description = 'Se inserto desde archivo CSV.')
#add user to the course
ingresado = db.academic_course_assignation.insert(carnet = usr.id, semester = current_period, assignation = check.project, laboratorio = rlaboratorio)
#Add to log
lab_var = ''
if rlaboratorio == 'T':
lab_var = 'True'
else:
lab_var = 'False'
#Search for user roles
result = db(db.auth_membership.user_id==auth.user.id).select()
roll_var = ''
i = 0;
for a in result:
if i == 0:
roll_var = a.group_id.role
i = i+1
else:
roll_var = roll_var + ',' + a.group_id.role
db.academic_course_assignation_log.insert(user_name = auth.user.username, roll = roll_var,
operation_log = 'insert',
after_carnet = rcarnet,
after_course = str(check.project.name),
after_year = str(current_period.yearp) ,
after_semester = str(current_period.period),
after_laboratory = lab_var,
id_academic_course_assignation = str(ingresado.id),
id_period = current_period.id,
description = 'Se inserto desde archivo CSV.')
else:
#Agregar la advertencia que el usuario ya se encuentra registrado en el sistema
row.append(T('Aviso: ') + T('El estudiante ya se encuentra registrado en el sistema'))
usr2 = db.academic_course_assignation((db.academic_course_assignation.semester == current_period) & (db.academic_course_assignation.assignation == check.project) & (db.academic_course_assignation.carnet == usr.id))
if usr2 is None:
#T o F validation
if rlaboratorio != 'T' and rlaboratorio != 'F':
row.append(T('Error: ') + T('El tipo de laboratorio ingresado no es correcto. Este debe ser T o F.'))
error_users.append(row)
else:
lab_var = ''
if rlaboratorio == 'T':
lab_var = 'True'
else:
lab_var = 'False'
#Search for user roles
result = db(db.auth_membership.user_id==auth.user.id).select()
roll_var = ''
i = 0;
for a in result:
if i == 0:
roll_var = a.group_id.role
i = i+1
else:
roll_var = roll_var + ',' + a.group_id.role
ingresado = db.academic_course_assignation.insert(carnet = usr.id, semester = current_period, assignation = check.project, laboratorio = rlaboratorio)
db.academic_course_assignation_log.insert(user_name = auth.user.username, roll = roll_var,
operation_log = 'insert',
after_carnet = rcarnet,
after_course = str(check.project.name),
after_year = str(current_period.yearp) ,
after_semester = str(current_period.period),
after_laboratory = lab_var,
id_academic_course_assignation = str(ingresado.id),
id_period = current_period.id,
description = 'Se inserto desde archivo CSV.')
aviso_users.append(row)
else:
row.remove(T('Aviso: ') + T('El estudiante ya se encuentra registrado en el sistema'))
row.append(T('Error: ') + T('El estudiante ya se encuentra registrado en el sistema y asignado al curso'))
error_users.append(row)
continue
except:
response.flash = T('File doesn\'t seem properly encoded.')
return dict(success = False,
file = False,
periods = periods,
current_period = current_period,
name=name, files=files)
response.flash = T('Data uploaded')
return dict(success = success,
errors = error_users,
avisos = aviso_users,
periods = periods,
current_period = current_period,
name=name, files=files)
return dict(success = False,
file = False,
periods = periods,
current_period = current_period,
name=name, files=files)
def auto_daily():
## Get current year period
import cpfecys
currentyear_period = cpfecys.current_year_period()
## Get all report_restriction of this period_year that end_date is beyond today
import datetime
current_date = datetime.datetime.now()
#if it is the first semester then the restriction should be:
#start date >= January 1 year 00:00:00
#end date >= January 1 year 00:00:00
#start date < July 1 year 00:00:00
#end date < July 1 year 00:00:00
#if it is the second semester then the restriction should be:
#start date >= July 1 year 00:00:00
#end date >= July 1 year 00:00:00
#start date < Jan 1 year 00:00:00
#end date < Jan 1 year 00:00:00
if currentyear_period.period == cpfecys.first_period.id:
date_min = datetime.datetime(currentyear_period.yearp, 1, 1)
date_max = datetime.datetime(currentyear_period.yearp, 7, 1)
else:
date_min = datetime.datetime(currentyear_period.yearp, 7, 1)
date_max = datetime.datetime(currentyear_period.yearp, 1, 1)
expired_restrictions = db((db.report_restriction.end_date < current_date)&
(db.report_restriction.start_date >= date_min)&
(db.report_restriction.end_date >= date_min)&
(db.report_restriction.start_date < date_max)&
(db.report_restriction.end_date < date_max)&
(db.report_restriction.is_enabled == True)).select()
## Get all assignations for this period_year
semester_assignations = db((db.user_project.period <= currentyear_period.id)&
((db.user_project.period + db.user_project.periods) > currentyear_period.id)).select()
# For every assignation and restriction
## This makes all missed assignations automatically not sent and set to failed reports :(
missed_reports = 0
status_acceptance = db.report_status(db.report_status.name == 'Acceptance')
for assignation in semester_assignations:
for restriction in expired_restrictions:
reports = db((db.report.assignation == assignation.id)&
(db.report.report_restriction == restriction.id)).count()
if not(reports > 0):
missed_reports += 1
db.report.insert(assignation = assignation.id,
min_score = cpfecys.get_custom_parameters().min_score,
report_restriction = restriction.id,
created = current_date,
score = 0,
status = status_acceptance,
never_delivered = True,
teacher_comment = T('The period of time to create the report finished and it was never completed; so automatically it is considered as failed.'))
## This makes all 'Draft' reports that have no delivered anything to be set to failed!
drafties = db((db.report.status == db.report_status(name = 'Draft'))&
(db.report_restriction.end_date < current_date)&
(db.report.report_restriction == db.report_restriction.id)&
(db.report.heading == None)&
(db.report.footer == None)&
(db.report.desertion_started == None)&
(db.report.desertion_gone == None)&
(db.report.desertion_continued == None)&
(db.report.hours == None)).select()
total_drafties_empty = len(drafties)
for d in drafties:
d.report.score = 0
d.report.status = db.report_status(name = 'Acceptance')
d.report.teacher_comment = T('The period of time to create the report finished and it was never completed; so automatically it is considered as failed.')
d.report.never_delivered = True
d.report.min_score = cpfecys.get_custom_parameters().min_score
d.report.update_record()
##
## This makes all 'Draft' reports that expired get to 'Grading'
drafties = db((db.report.status == db.report_status(name = 'Draft'))&
(db.report_restriction.end_date < current_date)&
(db.report.report_restriction == db.report_restriction.id)).select()
total_drafties = len(drafties)
import cpfecys
signature = (cpfecys.get_custom_parameters().email_signature or '')
for d in drafties:
d.report.status = db.report_status(name = 'Grading')
d.report.min_score = cpfecys.get_custom_parameters().min_score
d.report.update_record()
## TODO: Send Email according to assignation
# Notification Message
me_the_user = d.report.assignation.assigned_user
message = '<html>' + T('The report') + ' ' \
+ '<b>' + XML(d.report_restriction['name']) + '</b><br/>' \
+ T('sent by student: ') + XML(me_the_user.username) + ' ' \
+ XML(me_the_user.first_name) + ' ' + XML(me_the_user.last_name) \
+ '<br/>' \
+ T('was sent to be checked.') + '<br/>' + T('Checking can be done in:') \
+ ' ' + cpfecys.get_domain() + '<br />' + signature + '</html>'
# send mail to teacher and student notifying change.
mails = []
# retrieve teacher's email
teachers = db((db.project.id == d.report.assignation.project)&
(db.user_project.project == db.project.id)&
(db.user_project.assigned_user == db.auth_user.id)&
(db.auth_membership.user_id == db.auth_user.id)&
(db.auth_membership.group_id == db.auth_group.id)&
(db.auth_group.role == 'Teacher')).select()
for teacher in teachers:
mails.append(teacher.auth_user.email)
# retrieve student's email
student_mail = me_the_user.email
mails.append(student_mail)
was_sent = mail.send(to=mails,
subject=T('[DTT]Automatic Notification - Report ready to be checked.'),
# If reply_to is omitted, then mail.settings.sender is used
reply_to = student_mail,
message=message)
#MAILER LOG
db.mailer_log.insert(sent_message = message,
destination = ','.join(mails),
result_log = str(mail.error or '') + ':' + str(mail.result),
success = was_sent)
## This makes all 'Recheck' reports that expired to 'Grading'
import datetime
recheckies = db((db.report_restriction.id == db.report.report_restriction)&
(db.report.status == db.report_status(name='Recheck'))&
(db.report.score_date <= (current_date - datetime.timedelta(days = cpfecys.get_custom_parameters().rescore_max_days)))).select()
total_recheckies = len(recheckies)
import cpfecys
signature = cpfecys.get_custom_parameters().email_signature
for rech in recheckies:
rech.report.status = db.report_status(name = 'Grading')
rech.report.update_record()
## TODO: Send Email according to assignation
me_the_user = rech.report.assignation.assigned_user
message = '<html>' + T('The report') + ' ' \
+ '<b>' + XML(rech.report_restriction['name']) + '</b><br/>' \
+ T('sent by student: ') + XML(me_the_user.username) + ' ' \
+ XML(me_the_user.first_name) + ' ' + XML(me_the_user.last_name) \
+ '<br/>' \
+ T('was sent to be checked.') + '<br/>' + T('Checking can be done in:') \
+ ' ' + cpfecys.get_domain() + '<br />' + signature + '</html>'
# send mail to teacher and student notifying change.
mails = []
# retrieve teacher's email
teachers = db((db.project.id == rech.report.assignation.project)&
(db.user_project.project == db.project.id)&
(db.user_project.assigned_user == db.auth_user.id)&
(db.auth_membership.user_id == db.auth_user.id)&
(db.auth_membership.group_id == db.auth_group.id)&
(db.auth_group.role == 'Teacher')).select()
for teacher in teachers:
mails.append(teacher.auth_user.email)
# retrieve student's email
student_mail = me_the_user.email
mails.append(student_mail)
was_sent = mail.send(to=mails,
subject=T('[DTT]Automatic Notification - Report ready to be checked.'),
# If reply_to is omitted, then mail.settings.sender is used
reply_to = student_mail,
message = message)
#MAILER LOG
db.mailer_log.insert(sent_message = message,
destination = ','.join(mails),
result_log = str(mail.error or '') + ':' + str(mail.result),
success = was_sent)
db.commit()
auto_freeze()
return T('Total Updated Reports: ') + str(total_recheckies + total_drafties + missed_reports) + ' ' + \
T('Automatically Updated Draft Reports: ') + str(total_drafties) + ' ' + \
T('Automatically Updated Recheck Reports: ') + str(total_recheckies) + ' ' + \
T('Reports Never Delivered: ') + str(missed_reports + total_drafties_empty)
T('Automatically Updated Draft Reports: ') + str(total_drafties) + ' ' + \
T('Automatically Updated Recheck Reports: ') + str(total_recheckies) + ' ' + \
T('Reports Never Delivered: ') + str(missed_reports + total_drafties_empty)
from gluon.scheduler import Scheduler
scheduler = Scheduler(db3, dict(auto_daily = auto_daily), heartbeat = 60)
import cpfecys
cpfecys.setup(db, auth, scheduler, auto_daily)
cpfecys.force_student_data_update(request.env.path_info,
['/student/update_data',
'/default/user/logout'])
#resources menu
#import cpfecys
period = cpfecys.current_year_period()
data = db((db.item_restriction.is_public == True)&
(db.item_restriction.period == period)).select()
mnu = []
for d in data:
mnu.append((T(d.name), False, URL('default', 'resources', vars=dict(r=d.id))))
response.menu.extend([(T('Resources & Schedules'), False, URL(), mnu)])
#any user should be able to see this menu
#resources menu
response.menu.extend([
(T('Help'), False, URL(), [
(T('Links'), False, URL('default', 'links'), []),
(T('Files'), False, URL('default', 'files'), []),
])])
def academic_assignation():
#requires parameter year_period if no one is provided then it is
#automatically detected
#and shows the current period
assignation = request.vars['assignation']
year_period = request.vars['year_period']
max_display = 1
import cpfecys
currentyear_period = db.period_year(db.period_year.id == year_period)
check = db.user_project(id=assignation, assigned_user = auth.user.id)
if not currentyear_period:
currentyear_period = cpfecys.current_year_period()
changid = currentyear_period.id
if (check is None):
#check if there is no assignation or if it is locked (shouldn't be touched)
if (session.last_assignation is None):
redirect(URL('default','index'))
return
else:
check = db.user_project(id = session.last_assignation)
if cpfecys.assignation_is_locked(check):
redirect(URL('default','index'))
return
else:
session.last_assignation = check.id
cyearperiod = cpfecys.current_year_period()
if request.vars['search_var'] is None:
query = ((db.academic_course_assignation.semester == currentyear_period.id) & (db.academic_course_assignation.assignation==check.project))
else:
query2 = db((db.academic_course_assignation.carnet == db.academic.id) & (db.academic_course_assignation.semester == currentyear_period.id) & (db.academic_course_assignation.assignation==check.project) & (db.academic.carnet.like('%'+request.vars['search_var']+'%')) ).select()
dest = []
query = None
for q in query2:
dest.append(q.academic.id)
#consultar a la base de datos para obtener a los usuarios a los que enviaremos
query = (db.academic_course_assignation.carnet.belongs(dest) & (db.academic_course_assignation.semester == currentyear_period.id) & (db.academic_course_assignation.assignation==check.project))
fields = (db.academic_course_assignation.carnet, db.academic_course_assignation.laboratorio)
#db.academic.id.readable = False
#db.academic.id.writable = False
#db.academic.carnet.readable = False
#db.academic.carnet.writable = False
#db.academic.email.writable = False
#db.academic.email.readable = False
db.academic_course_assignation.assignation.default = check.project
db.academic_course_assignation.assignation.writable = False
db.academic_course_assignation.assignation.readable = False
db.academic_course_assignation.semester.default = currentyear_period.id
db.academic_course_assignation.semester.writable = False
db.academic_course_assignation.semester.readable = False
if (currentyear_period.id == cpfecys.current_year_period().id):
grid = SQLFORM.grid(query, fields=fields, oncreate=oncreate_academic_assignation, onupdate=onupdate_academic_assignation, ondelete=ondelete_academic_assignation,csv=False)
else:
checkProject = db((db.user_project.project == check.project) & (db.user_project.assigned_user==check.assigned_user) & (db.user_project.period==currentyear_period.id)).select()
b=0
for a in checkProject:
b=b+1
if b!=0:
grid = SQLFORM.grid(query, fields=fields, deletable=False, editable=False, create=False,csv=False)
else:
session.flash =T('Not authorized')
redirect(URL('default','index'))
current_period_name = T(cpfecys.second_period.name)
if currentyear_period.period == cpfecys.first_period.id:
current_period_name = T(cpfecys.first_period.name)
start_index = currentyear_period.id - max_display - 1
if start_index < 1:
start_index = 0
end_index = currentyear_period.id + max_display
periods_before = db(db.period_year).select(limitby=(start_index, \
currentyear_period.id - 1))
periods_after = db(db.period_year).select(limitby=(currentyear_period.id, \
end_index))
other_periods = db(db.period_year).select()
return dict(grid = grid,
currentyear_period = currentyear_period,
current_period_name = current_period_name,
periods_before = periods_before,
periods_after = periods_after,
other_periods = other_periods,
name = check.project.name,
assignation = check.id)
def onupdate_academic_assignation(form):
import datetime
import cpfecys
cdate = datetime.datetime.now()
assignation = request.vars['assignation']
currentyear_period = cpfecys.current_year_period()
check = db.user_project(id=assignation, assigned_user = auth.user.id)
if (check is None):
#check if there is no assignation or if it is locked (shouldn't be touched)
if (session.last_assignation is None):
redirect(URL('default','index'))
return
else:
check = db.user_project(id = session.last_assignation)
if cpfecys.assignation_is_locked(check):
redirect(URL('default','index'))
return
else:
session.last_assignation = check.id
#Search for user roles
result = db(db.auth_membership.user_id==auth.user.id).select()
roll_var = ''
i = 0;
for a in result:
if i == 0:
roll_var = a.group_id.role
i = i+1
else:
roll_var = roll_var + ',' + a.group_id.role
#Search for carnet
student_var = db(db.academic.id == form.vars.carnet).select()
carnet_var = ''
for a in student_var:
carnet_var = a.carnet
#Search for before values
student_var2 = db(db.academic_course_assignation_log.id_academic_course_assignation == form.vars.id).select(orderby=db.academic_course_assignation_log.id)
bef_carnet_var = ''
course_var = ''
year_var = ''
semester_var = ''
laboratory_var = ''
for a in student_var2:
bef_carnet_var = a.after_carnet
course_var = a.after_course
year_var = a.after_year
semester_var = a.after_semester
laboratory_var = a.after_laboratory
if form.vars.delete_this_record != None:
db.academic_course_assignation_log.insert(user_name = auth.user.username,
roll = roll_var,
operation_log = 'delete',
before_carnet = bef_carnet_var,
before_course = course_var,
before_year = year_var,
before_semester = semester_var,
before_laboratory = laboratory_var,
id_period = str(currentyear_period.id),
description = 'Se elimino el registro desde la pagina Asignar Estudiantes')
else:
#Check that there is not an assignation
usr2 = db((db.academic_course_assignation.id != form.vars.id) & (db.academic_course_assignation.semester == currentyear_period.id) & (db.academic_course_assignation.assignation == check.project) & (db.academic_course_assignation.carnet == form.vars.carnet)).select()
i = 0;
for a in usr2:
i = i+1
if i == 0:
#If there is not an assignation update the log
session.flash = T('Se realizó la modificacion')
db.academic_course_assignation_log.insert(user_name = auth.user.username,
roll = roll_var,
operation_log = 'update',
before_carnet = bef_carnet_var,
before_course = course_var,
before_year = year_var,
before_semester = semester_var,
before_laboratory = laboratory_var,
after_carnet = carnet_var,
after_course = check.project.name,
after_year = str(currentyear_period.yearp) ,
after_semester = str(currentyear_period.period),
after_laboratory = form.vars.laboratorio,
id_academic_course_assignation = form.vars.id,
id_period = str(currentyear_period.id),
description = 'Se modifico el registro desde la pagina Asignar Estudiantes')
else:
#If there is an assignation delete the last record
#db(db.academic_course_assignation.id==form.vars.id).delete()
temp_academic = db(db.academic.carnet==bef_carnet_var).select()
id_academic = ''
for a in temp_academic:
id_academic = a.id
db(db.academic_course_assignation.id==form.vars.id).update(carnet=id_academic,laboratorio=laboratory_var)
session.flash = T('Error: Ya existe la asignacion, no se modifico el estudiante')
def results():
#Import DB
import cpfecys
from decimal import Decimal
first_name = ''
last_name = ''
user_id = None
fullname = ''
periods = []
group = ''
nameperiod = ''
if auth.has_membership('Student') or auth.has_membership('Teacher'):
if auth.has_membership('Ecys-Administrator'):
first_name = ''
last_name = ''
user_id = None
else:
#User information
first_name = auth.user.first_name
last_name = auth.user.last_name
user_id = auth.user.id
fullname = first_name + ' ' + last_name
#Obtain the current period of the system and all the register periods
period = cpfecys.current_year_period()
periods_temp = db(
db.period_year).select(orderby=~db.period_year.id)
for period_temp in periods_temp:
try:
if db((db.user_project.assigned_user==auth.user.id)&\
(db.user_project.period == db.period_year.id)&\
((db.user_project.period <= period_temp.id) & \
((db.user_project.period + db.user_project.periods) > period_temp.id))).select(db.user_project.ALL).first() is not None:
periods.append(period_temp)
except:
None
#Check if the period has changed
if request.vars['period'] is None:
None
else:
if request.vars['period'] != '':
period = request.vars['period']
period = db(db.period_year.id == period).select().first()
else:
session.flash = T('Not valid Action.')
redirect(URL('default', 'index'))
pass
pass
if first_name == '' and user_id is None:
if request.vars['period'] is None:
None
else:
if request.vars['period'] != '':
period = request.vars['period']
user_id = request.vars['user']
group = request.vars['group']
qFullname = db(db.auth_user.id == user_id).select(
db.auth_user.first_name, db.auth_user.last_name).first()
fullname = qFullname.first_name + ' ' + qFullname.last_name
nameperiod = db(db.period_year.id == period).select().first()
else:
session.flash = T('Not valid Action.')
redirect(URL('default', 'index'))
pass
columnTotal = (
(db.answer.grade * db.evaluation_solve_detail.total_count).sum() /
(db.evaluation_solve_detail.total_count.sum())).with_alias('total')
rows = db((db.evaluation_solve_detail.evaluation_result ==
db.evaluation_result.id)
& (db.evaluation_solve_detail.repository_answer ==
db.repository_answer.id)
& (db.evaluation_solve_detail.question_repository ==
db.question_repository.id)
& (db.repository_answer.question_repository ==
db.question_repository.id)
& (db.evaluation_result.repository_evaluation ==
db.repository_evaluation.id)
& (db.repository_answer.answer == db.answer.answer)
& (db.evaluation_result.evaluated == db.auth_user.id)
& (db.auth_user.id == user_id)
& (db.evaluation_result.period == period)).select(
db.question_repository.question,
columnTotal,
groupby=db.question_repository.id)
#print '********************LAST SQL'
#print db._lastsql
##calcular el promedio de los resultados
suma = Decimal(0)
promedio = 0
constantCien = Decimal(100)
graphVal = Decimal(0)
resGraph = []
if rows.first() is not None:
for row in rows:
#print row.question_repository.question, row.total
suma = row.total + suma
graphVal = row.total / constantCien
resGraph.append("%.3f" % (graphVal))
pass
avg = suma / len(rows)
promedio = int(avg)
pass
gridAnswer = db(db.answer).select(db.answer.grade, db.answer.answer)
#gridAnswer = SQLFORM.grid(query, fields = [db.answer.grade, db.answer.answer], csv=False,deletable=False,
#editable=False, details=False, selectable=None, create=False, searchable=False,sortable=False,
#links_in_grid=False, user_signature=False, showbuttontext=False, ignore_rw = True)
min_average = 40
max_average = 60
return dict(periods=periods,
period=period,
periodo=period,
fullname=fullname,
rows=rows,
promedio=promedio,
gridAnswer=gridAnswer,
resGraph=resGraph,
min_average=min_average,
max_average=max_average,
group=group,
nameperiod=nameperiod)
def evaluacion():
import cpfecys
import redis
r = redis.StrictRedis(host='127.0.0.1', port=6379, db=0)
period = cpfecys.current_year_period()
periodo = request.vars['period']
projecto = request.vars['project']
project = db(db.project.id==projecto).select().first()
x = tuple(request.args)
y = str(''.join(x))
id_programacion = int(y)
error = False
msjError = ""
privado = False
activo = True
JsonQuiz = ""
programacion = db(db.vw_quiz_actividad.id==int(id_programacion)).select(db.vw_quiz_actividad.ALL).first()
print "La programacion es:"
print programacion
if( int(period.id) != int(periodo)):
error = True
msjError = "El periodo actual no corresponde al periodo de la evaluacion"
pass
##Verifico si es privado
if (programacion.private == 1):
privado = True
pass
##Verifico si aun sigue estando activo
if (programacion.Estado_actual == 'Inactivo'):
activo = True
else:
activo = False
pass
##Obtengo la metadata del quiz
metadata = db(db.tb_metadata_quiz.id_quiz==programacion.id_quiz).select(
db.tb_metadata_quiz.creador,
db.tb_metadata_quiz.curso).first()
print "La metadata es:"
print metadata
cadenaRedis = 'uid:'+str(metadata.creador)+':curso:'+str(metadata.curso)+':quiz:'+str(programacion.id_quiz)
print "La cadena conexion es:"
print cadenaRedis
datos = r.hget(cadenaRedis,'preguntas')
datos = datos.replace('\n','')
datos = datos.replace('}]}"','}]}')
print 'El quiz es: ' + datos
template_respuestas = ""
template_str = ""
JsonQuiz = datos.replace('{[','{"PREGUNTAS" : [')
print 'El quiz json:'
print JsonQuiz
##Si el quiz esta activo recupero el detalle
if (activo == True):
import json
JsonQuiz = unicode(JsonQuiz, 'utf-8')
template_respuestas=json.loads(JsonQuiz)
for pregunta in template_respuestas["PREGUNTAS"]:
if(pregunta["tipo"] =="multiple"):
for respuesta in pregunta["respuesta"]:
respuesta["correcta"] ="false"
pass
elif (pregunta["tipo"]=="veracidad"):
pregunta["respuesta"] = None
else:
pregunta["respuesta"] = None
pass
pass
# template_str = json.dumps(template_respuestas)
pass
if not session.respuestas:
session.respuestas = template_respuestas
print "template de respuestas session:"
print session.respuestas
if (privado == True):
session.bloqueado = True
else:
session.bloqueado = False
pass
return dict(period=period, project=project,programacion = programacion, error=error, msjError=msjError, privado = privado, activo=activo, JsonQuiz=JsonQuiz, metadata=metadata, bloqueado=session.bloqueado)
def search():
#Import DB
import cpfecys
from decimal import Decimal
if auth.has_membership('Super-Administrator') or auth.has_membership(
'Evaluator360') or auth.has_membership('Ecys-Administrator'):
#Obtain the current period of the system and all the register periods
period = cpfecys.current_year_period()
periods = db(db.period_year).select()
# 2=student; 3= teacher; 6=ecys-administrator
group = db((db.auth_group.id == 2)|\
(db.auth_group.id == 3)|\
(db.auth_group.id == 6)).select(db.auth_group.id).first()
groups = db((db.auth_group.id == 2)|\
(db.auth_group.id == 3)|\
(db.auth_group.id == 6)).select()
#Check if the period has changed
if request.vars['period'] is None:
None
else:
if request.vars['period'] != '':
period = request.vars['period']
period = db(db.period_year.id == period).select().first()
else:
session.flash = T('Not valid Action.')
redirect(URL('default', 'index'))
#check for type of rol selected
if request.vars['group'] is None:
None
else:
if request.vars['group'] != '':
group = request.vars['group']
group = db(db.auth_group.id == group).select().first()
else:
session.flash = T('Not valid Action.')
redirect(URL('default', 'index'))
rows = db((db.auth_membership.user_id == db.auth_user.id)
& (db.auth_membership.group_id == db.auth_group.id)
& (db.evaluation_result.evaluated == db.auth_user.id)
& (db.auth_group.id == group)
& (db.evaluation_result.period == period)).select(
db.evaluation_result.period,
db.auth_user.id,
db.auth_group.id,
db.auth_user.username,
db.auth_user.username,
db.auth_user.first_name,
db.auth_user.last_name,
groupby=db.auth_user.id)
else:
session.flash = T('Not authorized')
redirect(URL('default', 'index'))
return dict(periods=periods,
period=period,
periodo=period,
rows=rows,
group=group,
groups=groups,
grupo=group)
def inbox():
import cpfecys
cperiod = cpfecys.current_year_period()
period_list = []
period_list2 = []
assignations = []
coursesAdmin = []
select_form = FORM(INPUT(_name='semester_id', _type='text'))
if select_form.accepts(request.vars, formname='select_form'):
if auth.has_membership('Academic'):
#RGUARAN:se agregó academic_var
academic_var = db.academic(
db.academic.id_auth_user == auth.user.id)
assignations = db((db.academic_course_assignation.semester == str(
select_form.vars.semester_id))
& (db.academic_course_assignation.carnet ==
academic_var.id)).select()
period_id = str(select_form.vars.semester_id)
else:
if auth.has_membership('Academic'):
#se agregó academic_var
academic_var = db.academic(
db.academic.id_auth_user == auth.user.id)
assignations = db(
(db.academic_course_assignation.semester == cperiod.id)
& (db.academic_course_assignation.carnet == academic_var.id)
).select()
period_id = str(cperiod.id)
if (auth.has_membership('Student') or auth.has_membership('Teacher')):
#coursesAdmin = db((db.user_project.assigned_user == auth.user.id) & (db.user_project.period == period_id) & (db.user_project.project==db.project.id) ).select()
coursesAdmin = db((db.user_project.assigned_user==auth.user.id)&\
(db.user_project.project == db.project.id)&\
((db.user_project.period <= period_id) & \
((db.user_project.period + db.user_project.periods) > period_id))).select()
#temp = db((db.user_project.assigned_user == auth.user.id) & (db.user_project.project==db.project.id) ).select(db.user_project.period ,distinct=True)
for t in db(db.period_year).select():
assignation_temp = db((db.user_project.assigned_user==auth.user.id)&\
(db.user_project.project == db.project.id)&\
((db.user_project.period <= t.id) & \
((db.user_project.period + db.user_project.periods) > t.id))).select(db.user_project.ALL).first()
periods_temp = db(db.period_year).select(orderby=~db.period_year.id)
periods = []
for period_temp in periods_temp:
added = False
if auth.has_membership('Student') or auth.has_membership('Teacher'):
try:
if db((db.user_project.assigned_user==auth.user.id)&\
(db.user_project.period == db.period_year.id)&\
((db.user_project.period <= t.id) & \
((db.user_project.period + db.user_project.periods) > period_temp.id))).select(db.user_project.ALL).first() is not None:
periods.append(period_temp)
added = True
except:
None
if auth.has_membership('Academic'):
try:
if db(
(db.academic_course_assignation.carnet == academic_var.id)
& (db.academic_course_assignation.semester ==
period_temp.id)).select().first() is not None:
if added == False:
periods.append(period_temp)
except:
None
period_var = db(db.period_year.id == period_id).select().first()
return dict(assignations=assignations,
email=auth.user.email,
period_var=period_var,
period_id=period_id,
period_list=periods,
cperiod=cperiod.id,
coursesAdmin=coursesAdmin)
def courses_mail_notifications():
#show all assignations of current user
import cpfecys
def split_name(project):
try:
(nameP, projectSection) = str(project).split('(')
except:
nameP = project
return nameP
def split_section(project):
try:
projectSection = None
nameS = None
(nameP, projectSection) = str(project).split('(')
(nameS,garbage) = str(projectSection).split(')')
except:
nameS = '--------'
return nameS
return dict(assignations = db((db.user_project.assigned_user == auth.user.id) & (db.user_project.period == cpfecys.current_year_period().id)).select(), split_name=split_name, split_section=split_section)
def send_mail():
import cpfecys
cperiod = cpfecys.current_year_period()
assigned = db((db.user_project.assigned_user == auth.user.id) & ((db.user_project.period <= cperiod.id) & \
((db.user_project.period + db.user_project.periods + 1) > cperiod.id)) & (db.user_project.project==request.vars['project']) ).select(db.user_project.ALL).first()
try:
if assigned is None:
carnet_var = db(db.academic.id_auth_user==auth.user.id).select().first()
assigned_user_var = db((db.academic_course_assignation.carnet==carnet_var.id)&(db.academic_course_assignation.assignation==request.vars['project'])).select().first()
if (assigned_user_var.semester == cperiod.id) or ((assigned_user_var.semester + 1) == cperiod.id):
None
else:
session.flash =T('Not authorized')
redirect(URL('default','index'))
except:
session.flash =T('Not authorized')
redirect(URL('default','index'))
if (request.vars['semester_id'] is None) or (str(request.vars['semester_id']) == "None"):
period_id = cperiod.id
else:
period_id = request.vars['semester_id']
cperiod = db(db.period_year.id==period_id).select().first()
period_list = []
if (request.args(0) == 'send'):
email = request.vars['mail']
if email != None:
name = request.vars['name']
message = request.vars['message']
subject = request.vars['subject']
remessage = request.vars['remessage']
resub = request.vars['resub']
retime = request.vars['retime']
var_project_name = request.vars['var_project_name']
if message != '' and subject != '':
fail = reply_mail_with_email(email,message, remessage, retime, resub, subject, cperiod, var_project_name)
if fail > 0:
response.flash = T('Sent Error')
else:
response.flash = T('Mail Sent')
else:
response.flash = T('Fill all fields of the mail')
return dict(email=email,name=name,remessage=remessage,retime=retime,resub=resub,var_project_name=var_project_name)
else:
list_users = request.vars['list_users']
message = request.vars['message']
subject = request.vars['subject']
var_course = request.vars['var_course']
if list_users!= None and var_course != '' and message != '' and subject != '':
fail = send_mail_to_users(list_users, message, subject, cperiod.period.name, cperiod.yearp, var_course)
if fail > 0:
response.flash = T('Sent Error')
else:
response.flash = T('Mail Sent')
else:
response.flash = T('Fill all fields of the mail')
academic_var = db.academic(db.academic.id_auth_user==auth.user.id)
assignations = []
assignations = db((db.academic_course_assignation.semester==period_id) & (db.academic_course_assignation.carnet==academic_var.id)).select()
period_list = db(db.academic_course_assignation.carnet==academic_var.id).select(db.academic_course_assignation.semester,distinct=True)
return dict(email=None,assignations=assignations,cperiod=cperiod,period_list = period_list, period_id = period_id)
else:
if (request.args(0) == 'period'):
period_id = subject = request.vars['semester_id']
if request.vars['mail'] != None:
email = request.vars['mail']
name = request.vars['name']
remessage = request.vars['remessage']
retime = request.vars['retime']
resub = request.vars['resub']
project_var = db.project(db.project.id==request.vars['project'])
var_project_name = project_var.name
return dict(email=email,name=name,remessage=remessage,retime=retime,resub=resub,var_project_name=var_project_name)
else:
academic_var = db.academic(db.academic.id_auth_user==auth.user.id)
assignations = db((db.academic_course_assignation.semester==period_id) & (db.academic_course_assignation.carnet==academic_var.id)).select()
period_list = db(db.academic_course_assignation.carnet==academic_var.id).select(db.academic_course_assignation.semester,distinct=True)
return dict(email=None,assignations=assignations,cperiod=cperiod,period_list = period_list, period_id = period_id)
