def restaurar_backup():
admin = get_tipo_usuario(session)
if (admin == 0 or admin == 2):
redirect(URL(c="default", f="index"))
archivo = request.args[0]
comando = "psql --dbname=postgres://Siradex:Siradex@localhost/Siradex -w < ./applications/SiraDex/SQLScripts/dropSIRADEx.sql && psql --dbname=postgres://Siradex:Siradex@localhost/Siradex -w < ./applications/SiraDex/backup/" + archivo
resp = os.system(comando)
#resp = 0
if (resp == 0):
insertar_log(db, 'BACKUP', datetime.datetime.now(), request.client,
'RESTAURACIÓN DEL SISTEMA DESDE DE BACKUP EXITOSA',
session.usuario['usbid'])
session.flash = "Restaurado."
else:
insertar_log(db, 'BACKUP', datetime.datetime.now(), request.client,
'RESTAURACIÓN DEL SISTEMA DESDE DE BACKUP FALLIDA',
session.usuario['usbid'])
session.flash = "No se pudo restaurar."
redirect(URL('index'))
def eliminar():
admin = get_tipo_usuario(session)
if (admin == 0 or admin == 2):
redirect(URL(c="default", f="index"))
if len(request.args) != 0:
if request.args[0] != session.usuario["usbid"]:
session.message = ""
print request.args[0]
if (not db(db.USUARIO.usbid == request.args[0]).isempty()):
if ((db(db.PRODUCTO.usbid_usu_creador == request.args[0]).isempty()) \
and ((db(db.PARTICIPA_PRODUCTO.usbid_usuario == request.args[0]).isempty()))\
and ((db(db.PROGRAMA.usbid_usu_modificador == request.args[0]).isempty()))) :
db(db.USUARIO.usbid == request.args[0]).delete()
insertar_log(db, 'USUARIO', datetime.datetime.now(),
request.client,
'ELIMINACION DE USUARIO ' + request.args[0],
session.usuario['usbid'])
session.message = T("Usuario eliminado exitosamente.")
redirect(URL('gestionar'))
else:
session.message = T(
"No puede eliminar usuarios que hayan creado productos, programas o actividades. En caso de ser necesario, puede bloquear al usuario para evitar el ingreso al sistema."
)
redirect(URL('gestionar'))
else:
session.message = T(
"Para eliminar su cuenta, por favor comuníquese con un administrador"
)
redirect(URL('gestionar'))
def eliminarCatalogo():
admin = get_tipo_usuario(session)
if (admin == 0):
redirect(URL(c="default", f="index"))
# Obtengo el id del Catalogo a eliminar
id_catalogo = request.args[0]
#eliminamos todos los campos de ese catalogo
campos_del_catalogo = db(
db.CAMPO_CATALOGO.id_catalogo == id_catalogo).delete()
#Buscamos todas las actividades que tengan relacionado este catalogo
#y eliminamos las referencias a este.
campos_en_tipos_actividades = db(
db.CAMPO.id_catalogo == id_catalogo).select()
for campo in campos_en_tipos_actividades:
campo.id_catalogo = None
campo.update_record()
#eliminarmos el catalogo.
del db.CATALOGO[id_catalogo]
insertar_log(db, 'CATALOGO', datetime.datetime.now(), request.client,
'ELIMINADO CATALOGO CON ID ' + (id_catalogo),
session.usuario['usbid'])
redirect(URL('vGestionarCatalogos.html'))
def eliminar():
archivo = request.args[0]
comando = "rm ./applications/SiraDex/backup/" + archivo
resp = os.system(comando)
insertar_log(db, 'BACKUP', datetime.datetime.now(), request.client,
'ELIMINACIÓN DE BACKUP', session.usuario['usbid'])
session.flash = "Backup eliminado exitosamente"
redirect(URL('index'))
def descargar_backup():
nombre_archivo = str(request.args[0])
direccion = os.path.join('applications', 'SiraDex', 'backup',
nombre_archivo)
response.headers['ContentType'] = "application/octet-stream"
response.headers[
'Content-Disposition'] = "attachment; filename=" + nombre_archivo
insertar_log(db, 'BACKUP', datetime.datetime.now(), request.client,
'DESCARGA DE BACKUP', session.usuario['usbid'])
return response.stream(open(direccion), chunk_size=4096)
def validar(id_producto):
admin = get_tipo_usuario(session)
if (admin == 0):
redirect(url)
db(db.PRODUCTO.id_producto == id_producto).update(estado='Validado')
insertar_log(db, 'VALIDACION', datetime.datetime.now(), request.client,
'PRODUCTO CON ID ' + str(id_producto) + ' VALIDADO',
session.usuario['usbid'])
## INICIO NOTIFICACION ##
# obtenemos el producto a validar
producto = db(db.PRODUCTO.id_producto == id_producto).select().first()
# obtenemos el usuario que realizo el producto
usuario = db(
db.USUARIO.usbid == producto.usbid_usu_creador).select().first()
# parseamos los datos para la notificacion
datos_usuario = {'nombres': usuario.nombres + ' ' + usuario.apellidos}
datos_usuario['correo_inst'] = usuario.correo_inst
datos_usuario['correo_alter'] = None
if usuario.correo_alter != None and usuario.correo_alter != '':
datos_usuario['correo_alter'] = usuario.correo_alter
producto = {'nombre': producto.nombre}
# enviamos la notificacion al usuario creador
enviar_correo_validacion(mail, datos_usuario, producto)
# enviamos notificacion a los coautores (si existen)
participaciones = db(
db.PARTICIPA_PRODUCTO.id_producto == id_producto).select()
for participacion in participaciones:
#obtenemos el coautor
usuario = db(
db.USUARIO.usbid == participacion.usbid_usuario).select().first()
datos_coautor = {'nombres': usuario.nombres + ' ' + usuario.apellidos}
datos_coautor['correo_inst'] = usuario.correo_inst
datos_coautor['correo_alter'] = None
if usuario.correo_alter != None and usuario.correo_alter != '':
datos_coautor['correo_alter'] = usuario.correo_alter
# Enviamos el correo.
enviar_correo_validacion_coautor(mail, datos_coautor, datos_usuario,
producto)
## FIN NOTIFICACION ##
session.message = 'Producto validado exitosamente'
redirect(URL('gestionar_validacion.html'))
def rechazar(id_producto):
print "entre a rechazar"
admin = get_tipo_usuario(session)
if (admin == 0):
redirect(URL(c="default", f="index"))
db(db.PRODUCTO.id_producto == id_producto).update(estado='No Validado')
insertar_log(db, 'VALIDACION', datetime.datetime.now(), request.client,
'PRODUCTO CON ID ' + str(id_producto) + ' NO VALIDADO',
session.usuario['usbid'])
session.message = 'Producto rechazado'
print "\n\n\nA redirigir en rechazar"
redirect(URL('gestionar_validacion.html'))
def restaurar_tipo():
admin = get_tipo_usuario(session)
if (admin == 0):
redirect(URL(c="default", f="index"))
id_tipo = request.args[0]
tipo_actividad = db(db.TIPO_ACTIVIDAD.id_tipo == id_tipo).select(
db.TIPO_ACTIVIDAD.ALL).first()
tipo_actividad.update(papelera=False)
tipo_actividad.update_record()
insertar_log(db, 'PAPELERA', datetime.datetime.now(), request.client,
'RESTAURADO TIPO DE ACTIVIDAD CON ID ' + str(id_tipo),
session.usuario['usbid'])
redirect(URL('gestionar.html'))
def generar_backup():
admin = get_tipo_usuario(session)
if (admin == 0 or admin == 2):
redirect(URL(c="default", f="index"))
fecha = time.asctime(time.localtime(time.time()))
archivo = "_".join(fecha.split()[1:]).replace(":", "") + ".sql"
comando = "pg_dump --dbname=postgres://Siradex:Siradex@localhost/Siradex -w > ./applications/SiraDex/backup/backup_" + archivo
resp = os.system(comando)
session.flash = "Backup generado exitosamente"
insertar_log(db, 'BACKUP', datetime.datetime.now(), request.client,
'GENERACIÓN DE BACKUP EXITOSA', session.usuario['usbid'])
redirect(URL('index'))
def eliminar_programa():
admin = get_tipo_usuario(session)
if (admin==0):
redirect(URL(c ="default",f="index"))
id_programa = request.args[0]
programa = db(db.PROGRAMA.id_programa == id_programa).select()[0]
programa.papelera = True
programa.modif_fecha = request.now
programa.usbid_usu_modificador = session.usuario['usbid']
programa.update_record()
insertar_log(db, 'PROGRAMA', datetime.datetime.now(), request.client, 'ENVIO DE PROGRAMA '+ programa.nombre.upper() + ' A PAPELERA', session.usuario['usbid'])
redirect(URL('gestionar_programas.html'))
def restaurar_programa():
admin = get_tipo_usuario(session)
if (admin == 0):
redirect(URL(c="default", f="index"))
id_programa = request.args[0]
programa = db(db.PROGRAMA.id_programa == id_programa).select().first()
programa.papelera = False
programa.update_record()
session.message = 'Programa Restaurado.'
insertar_log(db, 'PAPELERA', datetime.datetime.now(), request.client,
'RESTAURADO PROGRAMA CON ID ' + str(id_programa),
session.usuario['usbid'])
redirect(URL('gestionar.html'))
def editar_programa():
admin = get_tipo_usuario(session) # Obtengo el tipo del usuario actual.
if (admin==0):
redirect(URL(c ="default",f="index"))
id = request.args[0] # Se identifica cual programa se identificará.
# Se busca el programa en la base de datos.
programa = db(db.PROGRAMA.id_programa == id).select()[0]
# Se presenta el formulario donde se modificarán los valores del programa.
formulario = SQLFORM.factory(
Field('Nombre',
default = programa.nombre,
requires = [IS_NOT_EMPTY(error_message='El nombre del programa no puede quedar vacío.'),
IS_MATCH('^[A-zÀ-ÿŸ\s]*$', error_message="Use sólo letras, sin números ni caracteres especiales.")]),
Field('Abreviacion',
requires = [IS_NOT_EMPTY(error_message='La abreviación del programa no puede quedar vacía.')]),
Field('Descripcion', type="text",
default = programa.descripcion,
requires=IS_NOT_EMPTY(error_message='La descripción del programa no puede quedar vacía.')),
submit_button = 'Actualizar',
labels = {'Descripcion' : 'Descripción',
'Nombre' : 'Nombre del Programa',
'Abreviacion' : 'Abreviación del Programa'}
)
# Se verifica si los campos están llenos correctamente.
if formulario.accepts(request.vars, session):
session.form_nombre = request.vars.Nombre
programa.nombre = request.vars.Nombre
programa.abreviacion = request.vars.Abreviacion
programa.descripcion = request.vars.Descripcion
programa.update_record() # Se actualiza el programa.
insertar_log(db, 'PROGRAMA', datetime.datetime.now(), request.client, 'MODIFICACION DE PROGRAMA '+ request.vars.Nombre.upper(), session.usuario['usbid'])
redirect(URL('gestionar_programas.html')) # Se redirige a la vista de gestión.
# En caso de que el formulario no sea aceptado
elif formulario.errors:
session.message = 'Error en los datos del formulario, por favor intente nuevamente.'
# Metodo GET
else:
session.message = ''
return dict(formulario=formulario, admin = admin)
def eliminar_tipo_papelera():
admin = get_tipo_usuario(session)
if (admin == 0):
redirect(URL(c="default", f="index"))
id_tipo = int(request.args[0])
# Determino si existen productos con ese tipo de actividad
# Si existen, entonces no borro al tipo de actividad
hayProductos = not db(db.PRODUCTO.id_tipo == id_tipo).isempty()
if hayProductos:
session.message = 'No se puede eliminar un \
tipo de actividad con \
productos asociados'
return redirect(URL('gestionar.html'))
query = reduce(lambda a, b: (a & b), [
db.TIPO_ACTIVIDAD.papelera == True, db.TIPO_ACTIVIDAD.id_tipo
== id_tipo, db.TIPO_ACTIVIDAD.id_tipo
== db.ACT_POSEE_CAMPO.id_tipo_act, db.ACT_POSEE_CAMPO.id_campo
== db.CAMPO.id_campo
])
# Guardo los reusltados en 'aux'
aux = db(query).select(db.ACT_POSEE_CAMPO.ALL)
# Borro las relaciones
if (len(aux) > 0):
db(db.ACT_POSEE_CAMPO.id_tipo_act == aux[0].id_tipo_act).delete()
# Borro los campos
for row in aux:
db(db.CAMPO.id_campo == row.id_campo).delete()
# Borro el tipo_activdad
db(db.TIPO_ACTIVIDAD.id_tipo == id_tipo).delete()
insertar_log(db, 'PAPELERA', datetime.datetime.now(), request.client,
'ELIMINADO TIPO DE ACTIVIDAD CON ID ' + str(id_tipo),
session.usuario['usbid'])
# Guardo mensaje de exito
session.message = 'Tipo Eliminado'
redirect(URL('gestionar.html'))
def enviar_tipo_papelera():
admin = get_tipo_usuario(session)
if (admin == 0):
redirect(URL(c="default", f="index"))
id_tipo = int(request.args[0])
tipo = db(db.TIPO_ACTIVIDAD.id_tipo == id_tipo).select(
db.TIPO_ACTIVIDAD.ALL).first()
tipo.update(papelera=True)
tipo.update_record()
insertar_log(
db, 'ACTIVIDAD', datetime.datetime.now(), request.client,
'TIPO DE ACTIVIDAD CON ID ' + str(id_tipo) + ' ENVIADO A LA PAPELERA',
session.usuario['usbid'])
session.message = 'Tipo Enviado a la Papelera'
redirect(URL('gestionar.html'))
def eliminarCampos():
admin = get_tipo_usuario(session)
if (admin == 0):
redirect(URL(c="default", f="index"))
# Obtengo el id del campo que se eliminara
id_campo_cat = request.args[0]
id_catalogo = db(db.CAMPO_CATALOGO.id_campo_cat ==
id_campo_cat).select().first().id_catalogo
# Elimino el campo del catalogo. Esto no afecta los tipos de actividades
# Que estan definidas ya, ni los productos ya listos.
del db.CAMPO_CATALOGO[id_campo_cat]
insertar_log(db, 'CAMPO', datetime.datetime.now(), request.client,
'ELIMINACION DE CAMPO CON ID ' + str(id_campo_cat),
session.usuario['usbid'])
redirect(URL('vGestionarCatalogos', args=[id_catalogo]))
def download():
admin = get_tipo_usuario(session)
if (admin == 0):
redirect(URL(c="default", f="index"))
periodo = request.args[0]
if periodo == "0":
query = "SELECT * FROM LOG_SIRADEX;"
elif periodo == "1":
date = datetime.date.today()
query = "SELECT * FROM LOG_SIRADEX WHERE accion_fecha = '" + str(
date) + "';"
elif periodo == "2":
date = datetime.date.today() - datetime.timedelta(days=7)
query = "SELECT * FROM LOG_SIRADEX WHERE accion_fecha >= '" + str(
date) + "';"
elif periodo == "3":
date = datetime.date.today() - datetime.timedelta(days=31)
query = "SELECT * FROM LOG_SIRADEX WHERE accion_fecha >= '" + str(
date) + "';"
elif periodo == "4":
date = datetime.date.today() - datetime.timedelta(days=93)
query = "SELECT * FROM LOG_SIRADEX WHERE accion_fecha >= '" + str(
date) + "';"
insertar_log(db, 'LOG', datetime.datetime.now(), request.client,
'DESCARGA DE LOG', session.usuario['usbid'])
#Excecute query
rows = db.executesql(query, fields=db.LOG_SIRADEX)
#convert query to csv
tempfile = StringIO.StringIO()
rows.export_to_csv_file(tempfile)
response.headers['Content-Type'] = 'text/csv'
attachment = 'attachment; filename="LOGSIRADEX.csv"'
response.headers['Content-Disposition'] = attachment
return tempfile.getvalue()
def agregar_programa():
admin = get_tipo_usuario(session)
if (admin==0):
redirect(URL(c ="default",f="index"))
formulario = SQLFORM.factory(
Field('Nombre',
requires = [IS_NOT_EMPTY(error_message='El nombre del programa no puede quedar vacío.'),
IS_MATCH('^[A-zÀ-ÿŸ\s]*$', error_message="Use sólo letras, sin números ni caracteres especiales.")]),
Field('Abreviacion',
requires = [IS_NOT_EMPTY(error_message='La abreviación del programa no puede quedar vacía.'),
IS_MATCH('^[A-zÀ-ÿŸ\s]*$', error_message="Use sólo letras, sin números ni caracteres especiales.")]),
Field('Descripcion', type="text",
requires=IS_NOT_EMPTY(error_message='La descripción del programa no puede quedar vaca.')),
submit_button = 'Agregar',
labels = {'Descripcion' : 'Descripción',
'Nombre' : 'Nombre del Programa',
'Abreviacion' : 'Abreviación'},
)
# Metodos POST
# En caso de que los datos del formulario sean aceptados
if formulario.accepts(request.vars, session):
session.form_nombre = request.vars.Nombre
db.PROGRAMA.insert(nombre = request.vars.Nombre,
abreviacion = request.vars.Abreviacion,
descripcion = request.vars.Descripcion
)
insertar_log(db, 'PROGRAMA', datetime.datetime.now(), request.client, 'CREACION DE PROGRAMA '+ request.vars.Nombre.upper(), session.usuario['usbid'])
redirect(URL('gestionar_programas.html'))
# En caso de que el formulario no sea aceptado
elif formulario.errors:
session.message = 'Error en los datos del formulario, por favor intente nuevamente.'
# Metodo GET
else:
session.message = ''
return dict(formulario=formulario, admin = admin)
def eliminar_programa_papelera():
id_programa = int(request.args[0])
# Determino si existen tipos de actividad con ese programa
# Si existen, entonces no borro al programa
hayTiposDeActividad = not db(
db.TIPO_ACTIVIDAD.id_programa == id_programa).isempty()
if hayTiposDeActividad:
session.message = 'No se puede eliminar un \
programa con tipos de \
actividades asociados'
return redirect(URL('gestionar.html'))
db(db.PROGRAMA.id_programa == id_programa).delete()
insertar_log(db, 'PAPELERA', datetime.datetime.now(), request.client,
'ELIMINADO PROGRAMA CON ID ' + str(id_programa),
session.usuario['usbid'])
# Guardo mensaje de exito
session.message = 'Programa Eliminado'
redirect(URL('gestionar.html'))
def modificar():
admin = get_tipo_usuario(session)
if (admin == 0 or admin == 2):
redirect(URL(c="default", f="index"))
message = ""
form = SQLFORM.factory(Field("USBID",
default=request.args[0],
writable=False),
readonly=True)
forma = SQLFORM(db.USUARIO,
button=['Actualizar'],
fields=['tipo'],
labels={'tipo': 'TIPO'})
forma.element(
_type='submit')['_class'] = "btn blue-add btn-block btn-border"
forma.element(_type='submit')['_value'] = "Actualizar"
if len(request.vars) != 0:
if (not db(db.USUARIO.usbid == request.args[0]).isempty()):
if (request.args[0] != session.usuario["usbid"]):
db(db.USUARIO.usbid == request.args[0]).update(
tipo=request.vars.tipo)
insertar_log(
db, 'USUARIO', datetime.datetime.now(), request.client,
'CAMBIO DE USUARIO ' + request.args[0] + ' A TIPO ' +
request.vars.tipo.upper(), session.usuario['usbid'])
if request.vars.tipo.upper() == "BLOQUEADO":
asunto = "Su usuario ha sido bloqueado."
mensaje = "Atención: Cumplimos con comunicarle que su usuario en el sistema SIRADEx ha sido bloqueado.\n Si cree que esto ha sido un error, por favor contacte al Decanato de Extesión."
## Obtenemos el usuario al que deseamos contactar.
usuario = db(
db.USUARIO.usbid == request.args[0]).select().first()
## parseamos los datos para la notificacion
datos_usuario = {
'nombres': usuario.nombres + ' ' + usuario.apellidos
}
if usuario.correo_alter != None and usuario.correo_alter != '':
datos_usuario['email'] = usuario.correo_alter
## Enviamos la notificacion al correo alternativo
enviar_correo_contacto(mail, datos_usuario, asunto,
mensaje)
datos_usuario['email'] = usuario.correo_inst
## Enviamos la notificacion al correo institucional
enviar_correo_contacto(mail, datos_usuario, asunto,
mensaje)
redirect(URL('gestionar'))
else:
message = T(
"Para cambiar sus permisos, por favor comuníquese con un administrador"
)
else:
message = T("El Usuario no se encuentra registrado")
return dict(forma=form,
form=forma,
message=message,
admin=get_tipo_usuario(session))
def gestionar():
admin = get_tipo_usuario(session)
if (admin == 0 or admin == 2):
redirect(URL(c="default", f="index"))
message = session.message
session.message = ""
aux = db(db.USUARIO).select(db.USUARIO.usbid, db.USUARIO.nombres,
db.USUARIO.apellidos, db.USUARIO.tipo)
form_editar = SQLFORM(db.USUARIO,
button=['Actualizar'],
fields=['tipo'],
labels={'tipo': 'TIPO'})
form_editar.element(
_type='submit')['_class'] = "btn blue-add btn-block btn-border"
form_editar.element(_type='submit')['_value'] = "Actualizar"
## Formulario para colocar el mensaje.
formulario_contactar = SQLFORM.factory(
Field('asunto', type="string", requires=[IS_LENGTH(50)]),
Field('mensaje',
type="text",
requires=[
IS_NOT_EMPTY(error_message='El mensaje no puede estar vacío')
]),
Field('usbid', type="string"),
submit_button='Enviar')
hayErrores = {}
if formulario_contactar.accepts(request.vars,
session,
formname="formulario_contactar"):
usbid = request.vars.usbid
asunto = request.vars.asunto
mensaje = request.vars.mensaje
## Obtenemos el usuario al que deseamos contactar.
usuario = db(db.USUARIO.usbid == usbid).select().first()
## parseamos los datos para la notificacion
datos_usuario = {'nombres': usuario.nombres + ' ' + usuario.apellidos}
if usuario.correo_alter != None and usuario.correo_alter != '':
datos_usuario['email'] = usuario.correo_alter
## Enviamos la notificacion al correo alternativo
enviar_correo_contacto(mail, datos_usuario, asunto, mensaje)
datos_usuario['email'] = usuario.correo_inst
## Enviamos la notificacion al correo institucional
enviar_correo_contacto(mail, datos_usuario, asunto, mensaje)
insertar_log(db, 'CONTACTO', datetime.datetime.now(), request.client,
'ENVIO DE MENSAJE A ' + usbid, session.usuario['usbid'])
session.message = 'Correo enviado satisfactoriamente'
redirect(URL('gestionar'))
# En caso de que el formulario no sea aceptado
elif formulario_contactar.errors:
hayErrores = formulario_contactar.errors
return dict(form_editar=form_editar,
hayErrores=hayErrores,
formulario_contactar=formulario_contactar,
usuarios=aux,
message=message,
admin=get_tipo_usuario(session))
def vGestionarCatalogos():
message = session.message
session.message = ""
admin = get_tipo_usuario(session)
if (admin == 0):
redirect(URL(c="default", f="index"))
#Si hay que agregar un campo a un catalogo
#Obtenemos todos los catalogos.
listaCatalogos = db().select(db.CATALOGO.ALL)
catalogos = []
#Para cada catalogo, obtenemos sus campos.
for catalogo in listaCatalogos:
campos_guardados = db(
db.CAMPO_CATALOGO.id_catalogo == catalogo.id).select()
catalogos.append([catalogo, campos_guardados])
#chequeamos si se esta gestionando un catalogo en particular
catalogo_actual = None
if request.args:
catalogo_actual = int(request.args[0])
else:
#Si no es ninguno en especifico,
#Tomamos como actual el primer catalogo de la lista, si Existe.
if catalogos != []:
catalogo_actual = catalogos[0][0].id_catalogo
#Formulario para agregar un catalogo.
formulario_agregar_catalogo = AgregarCatalogo()
formulario_agregar_campo = AgregarCampo()
formulario_editar_campo = EditarCampo()
formulario_cambiar_nombre = cambiarNombreCatalogo()
if formulario_agregar_catalogo.process(
formname="formulario_agregar_catalogo").accepted:
# Creamos el catalogo y obtenemos su id, para pasarlo al controlador de agregar campo.
id_catalogo = db.CATALOGO.insert(
nombre=request.vars.nombre)['id_catalogo']
insertar_log(db, 'CATALOGO', datetime.datetime.now(), request.client,
'CREACION DE CATALOGO ' + request.vars.nombre.upper(),
session.usuario['usbid'])
redirect(URL('vGestionarCatalogos', args=[id_catalogo]))
# En caso de que el formulario no sea aceptado
else:
message = ''
#Formulario para agregar un campo a un catalogo
if formulario_agregar_campo.process(
formname="formulario_agregar_campo").accepted:
nombre_campo_nuevo = request.vars.nombre
id_catalogo = request.vars.id_catalogo
nombre_repetido = False
campos_guardados = db(
db.CAMPO_CATALOGO.id_catalogo == id_catalogo).select()
for campo in campos_guardados:
if campo.nombre == nombre_campo_nuevo:
nombre_repetido = True
break
# Si el nombre no esta repetido, lo eliminamos.
if nombre_repetido:
message = 'Ya existe el campo'
else:
db.CAMPO_CATALOGO.insert(id_catalogo=id_catalogo,
nombre=nombre_campo_nuevo,
tipo_campo=request.vars.tipo_campo,
obligatorio=request.vars.obligatorio)
message = ""
# Redirijo a la misma pagina para seguir agregando campos
insertar_log(
db, 'CAMPO', datetime.datetime.now(), request.client,
'NUEVO CAMPO ' + nombre_campo_nuevo.upper() +
' PARA CATALOGO CON ID ' + id_catalogo, session.usuario['usbid'])
redirect(URL('vGestionarCatalogos', args=[id_catalogo]))
# En caso de que el formulario no sea aceptado
else:
message = ''
if formulario_editar_campo.process(
formname="formulario_editar_campo").accepted:
nombre_nuevo = request.vars.nombre
id_catalogo = request.vars.id_catalogo
id_campo = int(request.vars.id_campo_cat)
nombre_repetido = False
#Bucamos los campos que esten guardados
campos_guardados = db(
db.CAMPO_CATALOGO.id_catalogo == id_catalogo).select()
#Si existe un campo que tenga el mismo nombre
#Y no sea el campo que estamos modificando.
#Entonces existe un campo con nombre repetido.
for campo in campos_guardados:
if (campo.nombre == nombre_nuevo
and campo.id_campo_cat != id_campo):
nombre_repetido = True
break
# Si el nombre no esta repetido, modificamos el campo
if nombre_repetido:
message = 'Ya existe un campo llamado "' + nombre_nuevo + '" en el catálogo.'
else:
#Actualizamos el campo
db.CAMPO_CATALOGO[id_campo] = dict(
nombre=nombre_nuevo,
tipo_campo=request.vars.tipo_campo,
obligatorio=request.vars.obligatorio)
insertar_log(db, 'CAMPO', datetime.datetime.now(), request.client,
'MODIFICACION DE CAMPO CON ID ' + str(id_campo),
session.usuario['usbid'])
session.msgErr = 0
# Redirijo a la misma pagina para seguir agregando campos
redirect(URL('vGestionarCatalogos', args=[id_catalogo]))
else:
message = ''
if formulario_cambiar_nombre.process(
formname="formulario_cambiar_nombre").accepted:
nombre_nuevo = request.vars.nombre
id_catalogo = request.vars.id_catalogo
#Actualizamos el nombre
db.CATALOGO[id_catalogo] = dict(nombre=nombre_nuevo)
insertar_log(
db, 'CATALOGO', datetime.datetime.now(), request.client,
'CATALOGO CON ID ' + str(id_catalogo) + ' RENOMBRADO A ' +
nombre_nuevo.upper(), session.usuario['usbid'])
redirect(URL('vGestionarCatalogos', args=[id_catalogo]))
else:
message = ''
formulario_agregar_catalogo.element(
_type='submit')['_class'] = "btn blue-add btn-block btn-border"
formulario_agregar_catalogo.element(_type='submit')['_value'] = "Agregar"
formulario_agregar_campo.element(
_type='submit')['_class'] = "btn blue-add btn-block btn-border"
formulario_agregar_campo.element(_type='submit')['_value'] = "Agregar"
formulario_editar_campo.element(
_type='submit')['_class'] = "btn blue-add btn-block btn-border"
formulario_editar_campo.element(_type='submit')['_value'] = "Editar"
formulario_cambiar_nombre.element(
_type='submit')['_class'] = "btn blue-add btn-block btn-border"
formulario_cambiar_nombre.element(
_type='submit')['_value'] = "Renombrar Catálogo"
return dict(catalogos=catalogos,
catalogo_actual=catalogo_actual,
formulario_agregar_catalogo=formulario_agregar_catalogo,
formulario_agregar_campo=formulario_agregar_campo,
formulario_editar_campo=formulario_editar_campo,
formulario_cambiar_nombre=formulario_cambiar_nombre,
hayErroresAgregar=formulario_agregar_catalogo.errors,
hayErroresEditarNombre=formulario_cambiar_nombre.errors,
hayErroresEditarCampo=formulario_editar_campo.errors,
hayErroresAgregarCampo=formulario_agregar_campo.errors,
admin=admin,
message=message)
def gestionar():
admin = get_tipo_usuario(session)
session.message = ""
formulario_agregar_tipo = construir_formulario_agregar_tipo()
formulario_editar_tipo = construir_formulario_editar_tipo()
# Vista básica
if formulario_editar_tipo.accepts(request.vars,
session,
formname="formulario_editar_tipo"):
tipo = db(
db.TIPO_ACTIVIDAD.id_tipo == request.vars.Id_tipo).select()[0]
tipo.nombre = request.vars.Nombre
tipo.codigo = request.vars.Codigo
tipo.tipo_p_r = request.vars.Tipo
tipo.descripcion = request.vars.Descripcion
id_programa = request.vars.Programa
tipo.id_programa = id_programa
tipo.update_record() # Se actualiza el tipo de actividad.
insertar_log(
db, 'ACTIVIDAD', datetime.datetime.now(), request.client,
'MODIFICACION DE TIPO DE ACTIVIDAD CON ID ' +
str(request.vars.Id_tipo), session.usuario['usbid'])
if formulario_agregar_tipo.accepts(request.vars,
session,
formname="formulario_agregar_tipo"):
id_programa = request.vars.Programa
db.TIPO_ACTIVIDAD.insert(nombre=request.vars.Nombre,
codigo=request.vars.Codigo,
tipo_p_r=request.vars.Tipo,
descripcion=request.vars.Descripcion,
id_programa=id_programa)
insertar_log(db, 'ACTIVIDAD', datetime.datetime.now(), request.client,
'NUEVO TIPO DE ACTIVIDAD ' + request.vars.Nombre.upper(),
session.usuario['usbid'])
if (len(request.args) == 0) or (request.args[0] == 'None'):
listaTipoActividades = db(db.TIPO_ACTIVIDAD.papelera == False).select(
db.TIPO_ACTIVIDAD.ALL)
programa = dict()
programa["nombre"] = None
programa["descripcion"] = None
id_programa = None
elif (request.args[0] != None):
id_programa = request.args[0]
listaTipoActividades = db(
(db.TIPO_ACTIVIDAD.papelera == False)
& (db.TIPO_ACTIVIDAD.id_programa == id_programa)).select(
db.TIPO_ACTIVIDAD.ALL)
programa = db(db.PROGRAMA.id_programa == id_programa).select(
db.PROGRAMA.ALL).first()
return dict(admin=get_tipo_usuario(session),
listaTipoActividades=listaTipoActividades,
programa_nombre=programa["nombre"],
programa_descripcion=programa["descripcion"],
formulario_agregar_tipo=formulario_agregar_tipo,
formulario_editar_tipo=formulario_editar_tipo,
hayErroresAgregar=formulario_agregar_tipo.errors,
hayErroresEditar=formulario_editar_tipo.errors,
id_programa=id_programa)
def agregar_tipo():
session.message = ""
admin = get_tipo_usuario(session)
if (admin == 0):
redirect(URL(c="default", f="index"))
# Configuro widgets para el formulario de Agregar Tipo Actividad
db.TIPO_ACTIVIDAD.nombre.widget = SQLFORM.widgets.string.widget
db.TIPO_ACTIVIDAD.descripcion.widget = SQLFORM.widgets.text.widget
db.TIPO_ACTIVIDAD.producto.widget = SQLFORM.widgets.text.widget
db.TIPO_ACTIVIDAD.nro_campos.widget = SQLFORM.widgets.integer.widget
def horizontal_radio(f, v):
return SQLFORM.widgets.radio.widget(f, v, cols=2)
db.TIPO_ACTIVIDAD.tipo_p_r.widget = horizontal_radio
# Se obtienen todos los programas almacenados en la base de datos.
lista_programas = db().select(db.PROGRAMA.ALL)
programas = []
# Se crea un diccionario para almacenar unicamente los nombres de los programas almacenados.
for programa in lista_programas:
programas.append(programa.nombre)
# AQUI VA UN CONDICIONAL.
# Para agregar un tipo de actividad se debe tener al menos un programa.
formulario_agregar_tipo = SQLFORM.factory(
Field(
'Nombre',
requires=[
IS_NOT_EMPTY(
error_message=
'El nombre del tipo de actividad no puede quedar vacío.'),
IS_MATCH(
'^[A-zÀ-ÿŸ\s]*$',
error_message=
"Use sólo letras, sin números ni caracteres especiales."),
IS_LENGTH(128)
]),
Field(
'Tipo',
default='Seleccione...',
requires=IS_IN_SET(
{
'P': 'Evaluables por pares académicos',
'R': 'No evaluables por pares académicos'
},
zero=T('Seleccione...'),
error_message=
'Debe elegir entre "Evaluables por pares académicos" o "No evaluables por pares académicos"'
)),
Field(
'Descripcion',
type="text",
requires=[
IS_NOT_EMPTY(
error_message=
'La descripción del tipo de actividad no puede quedar vacía.'
),
IS_LENGTH(2048)
]),
Field('Programa',
requires=IS_IN_SET(
programas,
zero="Seleccione...",
error_message='Debe elegir uno de los programas listados.')),
submit_button='Agregar',
labels={'Descripcion': 'Descripción'})
hayPrograma = len(programas) != 0
# Metodos POST
# En caso de que los datos del formulario sean aceptados
if hayPrograma and formulario_agregar_tipo.accepts(
request.vars, session, formname="formulario_agregar_tipo"):
session.form_nombre = request.vars.Nombre
programa = db(db.PROGRAMA.nombre == request.vars.Programa).select()
id_programa = programa[0].id_programa
db.TIPO_ACTIVIDAD.insert(nombre=request.vars.Nombre,
tipo_p_r=request.vars.Tipo,
descripcion=request.vars.Descripcion,
id_programa=id_programa)
insertar_log(db, 'ACTIVIDAD', datetime.datetime.now(), request.client,
'NUEVO TIPO DE ACTIVIDAD ' + request.vars.Nombre.upper(),
session.usuario['usbid'])
elif not hayPrograma:
session.message = 'Lo sentimos, no existen programas.'
# En caso de que el formulario no sea aceptado
elif formulario_agregar_tipo.errors:
session.message = 'Lo sentimos, todos los campos son obligatorios.'
# Metodo GET
else:
session.message = ''
formulario_agregar_tipo.element(
_type='submit')['_class'] = "btn blue-add btn-block btn-border"
formulario_agregar_tipo.element(_type='submit')['_value'] = "Agregar"
return dict(formulario=formulario_agregar_tipo,
admin=get_tipo_usuario(session),
mensaje=session.message,
hayPrograma=hayPrograma)
def EditarPerfil():
if session.usuario != None:
admin = get_tipo_usuario(session)
form = SQLFORM.factory(Field("USBID",
default=session.usuario["usbid"],
writable=False),
Field('Nombres',
default=session.usuario["first_name"],
writable=False),
Field('Apellidos',
default=session.usuario["last_name"],
writable=False),
readonly=True)
# Modificar datos del perfil
usuario = db(
db.USUARIO.ci == session.usuario['cedula']).select().first()
print usuario
alternativo = session.usuario[
"alternativo"] if session.usuario["alternativo"] != None else ''
telefono = session.usuario[
"phone"] if session.usuario["phone"] != None else ''
forma = SQLFORM.factory(
Field('telefono',
requires=[
IS_LENGTH(20),
IS_MATCH('^\(0[0-9]{3}\)[0-9]{3}-[0-9]{4}$|^$',
error_message="Formato inválido")
]),
Field('correo_alter',
requires=[
IS_MATCH('^[.A-z0-9À-ÿŸ\s-]+@[.A-z0-9À-ÿŸ\s-]+$|^$',
error_message="Formato inválido")
]),
submit_button='Agregar',
labels={
'telefono': 'Teléfono',
'correo_alter': 'Correo alternativo'
},
col3={
'telefono': 'Ej: (0212)123-1234',
'correo_alter': 'Ej: [email protected]'
})
forma.element(
_type='submit')['_class'] = "btn blue-add btn-block btn-border"
forma.element(_type='submit')['_value'] = "Actualizar"
if forma.accepts(request.vars, session, formname="forma"):
nuevoTelefono = request.vars.telefono
nuevoCorreoAlter = request.vars.correo_alter
valor_telefono = "" if (nuevoTelefono == None) else nuevoTelefono
session.usuario["phone"] = valor_telefono
valor_correo = "" if (nuevoCorreoAlter
== None) else nuevoCorreoAlter
session.usuario["alternativo"] = valor_correo
db(db.USUARIO.ci == session.usuario["cedula"]).update(
telefono=valor_telefono, correo_alter=valor_correo)
insertar_log(db, 'PERFIL', datetime.datetime.now(), request.client,
'ACT. PERFIL SATISFACTORIA', session.usuario['usbid'])
redirect(URL('perfil'))
else:
message = T("Debe colocar su teléfono y correo alternativo.")
return dict(form1=form,
form=forma,
admin=admin,
telefono=telefono,
alternativo=alternativo)
else:
redirect(URL("index"))
def agregar():
admin = get_tipo_usuario(session)
# Para la fecha maxima de realizacion
now = datetime.datetime.now()
if now.month < 10:
mes = "-0" + str(now.month)
else:
mes = "-" + str(now.month)
if now.day < 10:
dia = "-0" + str(now.day)
else:
dia = "-" + str(now.month)
fecha_max = str(now.year) + mes + dia
if not request.args:
raise HTTP(404)
tipo = int(request.args(0))
campos_id = db(db.ACT_POSEE_CAMPO.id_tipo_act == tipo).select()
tipo_actividad = db(db.TIPO_ACTIVIDAD.id_tipo == tipo).select().first()
nombre_actividad = tipo_actividad.nombre
descripcion_actividad = tipo_actividad.descripcion
fields = []
# Otros Autores de la Actividad
lista_usuarios = db(db.USUARIO.tipo == 'Usuario').select()
usuarios = {}
# Se crea un diccionario para almacenar unicamente los nombres de los usuarios
for usuario in lista_usuarios:
if usuario.usbid != session.usuario['usbid']:
usuarios[usuario.usbid] = usuario.nombres + ' ' + usuario.apellidos
for i in range(5):
fields.append(
Field(
"autor_" + str(i + 1),
label='Autor ',
requires=IS_EMPTY_OR(
IS_IN_SET(usuarios,
zero="Seleccione usuario",
error_message=
'Debes elegir uno de los usuarios listados.'))))
obl = {}
no_obl = {}
for row in campos_id:
rows_campo = db(db.CAMPO.id_campo == row.id_campo).select().first()
nombre = rows_campo.nombre_interno.replace(" ", "_")
try:
if int(nombre[0]):
nombre = "c4mp0_" + nombre
except:
pass
print(nombre)
obligatorio = rows_campo.obligatorio
tipo_campo = rows_campo.tipo_campo.replace(" ", "_")
if obligatorio:
obl[nombre] = tipo_campo
if tipo_campo in ['Fecha']:
fields.append(
Field(nombre,
'date',
label=rows_campo.nombre + " (**)",
requires=[
IS_NOT_EMPTY(),
IS_DATE(format=T('%Y-%m-%d'),
error_message=
'Fecha inválida, debe ser: AAA-MM-DD')
]))
elif tipo_campo in ['Texto_Corto']:
fields.append(
Field(nombre,
'string',
label=rows_campo.nombre + " (*)",
requires=[
IS_NOT_EMPTY(error_message='Inserte texto')
]))
elif tipo_campo in ['Cedula']:
fields.append(
Field(nombre,
'string',
label=rows_campo.nombre + " (*)",
requires=[
IS_NOT_EMPTY(),
IS_MATCH('\d{2}.\d{3}.\d{3}$',
error_message=
'CI inválida, debe ser: XX.XXX.XXX')
]))
elif tipo_campo in ['Documento']:
fields.append(
Field(nombre,
'upload',
label=rows_campo.nombre + " (*)",
uploadfolder=os.path.join(request.folder, 'uploads'),
requires=[
IS_NOT_EMPTY(
error_message='Debe subirse un archivo')
]))
elif tipo_campo in ['Telefono']:
fields.append(
Field(
nombre,
'string',
label=rows_campo.nombre + " (*)",
requires=[
IS_NOT_EMPTY(),
IS_MATCH(
'\(0\d{3}\)\d{3}-\d{4}$',
error_message=
'Teléfeno invélido, debe ser: (0xxx)xxx-xxxx')
]))
elif tipo_campo in ['Cantidad_Entera']:
fields.append(
Field(nombre,
'string',
label=rows_campo.nombre + " (*)",
requires=[
IS_NOT_EMPTY(),
IS_INT_IN_RANGE(-9223372036854775800,
9223372036854775807)
]))
elif tipo_campo in ['Cantidad_Decimal']:
fields.append(
Field(
nombre,
'string',
label=rows_campo.nombre + " (*)",
requires=[
IS_NOT_EMPTY(),
IS_DECIMAL_IN_RANGE(
-9223372036854775800,
9223372036854775807,
dot=".",
error_message=
'El numero debe ser de la forma X.X, donde X esta entre -9223372036854775800 y 9223372036854775807'
)
]))
elif tipo_campo in ['Texto_Largo']:
fields.append(
Field(nombre,
'text',
label=rows_campo.nombre + " (*)",
requires=IS_NOT_EMPTY()))
else:
no_obl[nombre] = tipo_campo
if tipo_campo in ['Fecha']:
fields.append(
Field(nombre,
'date',
label=rows_campo.nombre,
requires=IS_EMPTY_OR(
IS_DATE(format=T('%Y-%m-%d'),
error_message=
'Fecha inválida, debe ser: AAA-MM-DD'))))
elif tipo_campo in ['Texto_Corto']:
fields.append(Field(nombre, 'string', label=rows_campo.nombre))
elif tipo_campo in ['Cedula']:
fields.append(
Field(nombre,
'string',
label=rows_campo.nombre,
requires=IS_EMPTY_OR(
IS_MATCH('\d{2}.\d{3}.\d{3}$',
error_message=
'CI inválida, debe ser: XX.XXX.XXX'))))
elif tipo_campo in ['Documento']:
fields.append(
Field(nombre,
'upload',
label=rows_campo.nombre,
requires=IS_EMPTY_OR(IS_UPLOAD_FILENAME()),
uploadfolder=os.path.join(request.folder,
'uploads')))
elif tipo_campo in ['Telefono']:
fields.append(
Field(nombre,
'string',
label=rows_campo.nombre,
requires=IS_EMPTY_OR(
IS_MATCH(
'\(0\d{3}\)\d{3}-\d{4}$',
error_message=
'Teléfeno inválido, debe ser: (0xxx)xxx-xxxx'
))))
elif tipo_campo in ['Cantidad_Entera']:
fields.append(
Field(nombre,
'string',
label=rows_campo.nombre,
requires=IS_EMPTY_OR(
IS_INT_IN_RANGE(-9223372036854775800,
9223372036854775807))))
elif tipo_campo in ['Cantidad_Decimal']:
fields.append(
Field(
nombre,
'string',
label=rows_campo.nombre,
requires=IS_EMPTY_OR(
IS_DECIMAL_IN_RANGE(
-9223372036854775800,
9223372036854775807,
dot=".",
error_message=
'El número debe ser de la forma X.X, donde X esta entre -9223372036854775800 y 9223372036854775807'
))))
elif tipo_campo in ['Texto_Largo']:
fields.append(Field(nombre, 'text', label=rows_campo.nombre))
for i in range(5):
fields.append(
Field("c0mpr0bant3_" + str(i + 1),
'upload',
autodelete=True,
uploadseparate=True,
uploadfolder=os.path.join(request.folder, 'uploads'),
label=''))
fields.append(
Field("d3scr1pc10n_comprobante_" + str(i + 1),
'string',
label="Descripción (*)"))
#fields.append(Field(nombre,requires=IS_IN_SET([(1,'Method1'), (2,'Method2'), (3,'Method3')], zero='Select')))
url = URL('download')
form = SQLFORM.factory(
*fields,
upload=url,
buttons=[
INPUT(_value='Guardar como Borrador',
_type="submit",
_class="btn blue-add btn-block btn-border ",
_name="borrador"),
INPUT(_value='Enviar Producto',
_type="submit",
_class="btn blue-add btn-block btn-border ")
])
form.element()
#fix para el datepicker de las fechas:
for i in obl.keys():
form.element(_name=i)['_class'] = form.element(
_name=i)['_class'] + " obligatoria " + obl[i]
for i in no_obl.keys():
form.element(_name=i)['_class'] = form.element(
_name=i)['_class'] + ' ' + no_obl[i]
if form.process().accepted:
no = [
'nombre', 'descripcion', 'fecha_realizacion', 'lugar',
'colaboradores'
]
estado = "Por Validar"
if request.vars.borrador:
#Verificamos si se quiere es un borrador.
estado = "Borrador"
dicc_producto = db.PRODUCTO.insert(id_tipo = tipo,nombre=form.vars.nombre, descripcion=form.vars.descripcion,\
estado= estado, fecha_realizacion=form.vars.fecha_realizacion, fecha_modificacion=now, \
lugar = form.vars.lugar,colaboradores=form.vars.colaboradores,
usbid_usu_creador= session.usuario['usbid'])
id_producto = dicc_producto['id_producto']
if request.vars.borrador:
insertar_log(db, 'PRODUCTO', datetime.datetime.now(),
request.client,
'NUEVO BORRADOR CON ID ' + str(id_producto),
session.usuario['usbid'])
else:
insertar_log(db, 'PRODUCTO', datetime.datetime.now(),
request.client,
'NUEVO PRODUCTO CON ID ' + str(id_producto),
session.usuario['usbid'])
for var in form.vars:
if not (var in no):
#Buscamos los autores
try:
if (var[0:5] == "autor"):
usbid_autor = getattr(form.vars, var)
if usbid_autor != None:
db.PARTICIPA_PRODUCTO.insert(
id_producto=id_producto,
usbid_usuario=usbid_autor)
except Exception, e:
print "Exception Autor: "
print e
try:
if (var[0:11] == "c0mpr0bant3"):
numero_comprobante = var[12:13]
descripcion = getattr(
form.vars,
'd3scr1pc10n_comprobante_' + numero_comprobante)
nombre = getattr(form.vars, var)
if nombre != '':
db.COMPROBANTE.insert(archivo=nombre,
descripcion=descripcion,
producto=id_producto)
continue
elif (var[0:11] == "d3scr1pc10n"):
continue
except Exception, e:
print "Exception: "
print e
try:
if (var[0:6] == "c4mp0_"):
campo = var[6:]
else:
campo = var
except Exception, e:
print "Exception: "
print e
campo = var
#Ignora campos de autor
if campo[0:5] != 'autor' and campo[0:8] != 'borrador':
print campo
campo = campo.replace("_", " ")
id_camp = db(db.CAMPO.nombre_interno ==
campo).select().first().id_campo
valor = getattr(form.vars, var)
db.PRODUCTO_TIENE_CAMPO.insert(id_prod=id_producto,
id_campo=id_camp,
valor_campo=valor)
def modificar():
admin = get_tipo_usuario(session)
if not request.args:
raise HTTP(404)
id_producto = int(request.args(0))
now = datetime.datetime.now()
if now.month < 10:
mes = "-0" + str(now.month)
else:
mes = "-" + str(now.month)
if now.day < 10:
dia = "-0" + str(now.day)
else:
dia = "-" + str(now.month)
fecha_max = str(now.year) + mes + dia
# Obtenemos los productos para mostrarlos en el html
producto = db(db.PRODUCTO.id_producto == id_producto).select().first()
# Si el producto no existe
if not producto:
redirect(URL('gestionar'))
# Si no soy el creador del producto
elif producto["usbid_usu_creador"] != session.usuario["usbid"]:
redirect(URL('gestionar'))
query = "SELECT id_comprobante, descripcion FROM COMPROBANTE WHERE producto=" + str(
id_producto) + ";"
comprobantes = db.executesql(query)
temp = "SELECT id_comprobante, descripcion FROM COMPROBANTE WHERE producto=" + str(
id_producto) + "AND ;"
tipo_actividad = db(
db.TIPO_ACTIVIDAD.id_tipo == producto.id_tipo).select().first()
nombre_actividad = tipo_actividad.nombre
descripcion_actividad = tipo_actividad.descripcion
# Creamos el formulario
rows = db(db.PRODUCTO_TIENE_CAMPO.id_prod == id_producto).select()
fields = []
obl = {}
no_obl = {}
valores = {}
valores['nombre'] = producto.nombre
valores['descripcion'] = producto.descripcion
valores['fecha_realizacion'] = producto.fecha_realizacion
valores['lugar'] = producto.lugar
valores['colaboradores'] = producto.colaboradores
documentos = []
# Otros Autores de la Actividad
lista_usuarios = db(db.USUARIO.tipo == 'Usuario').select()
usuarios = {}
# Se crea un diccionario para almacenar unicamente los nombres de los usuarios
for usuario in lista_usuarios:
if usuario.usbid != session.usuario['usbid']:
usuarios[usuario.usbid] = usuario.nombres + ' ' + usuario.apellidos
for i in range(5):
fields.append(
Field(
"autor_" + str(i + 1),
label='Autor ',
requires=IS_EMPTY_OR(
IS_IN_SET(usuarios,
zero="Seleccione usuario",
error_message=
'Debes elegir uno de los usuarios listados.'))))
#Obtenemos los valores de los otros autores, si exiten
otros_autores = db(
db.PARTICIPA_PRODUCTO.id_producto == producto.id_producto).select()
num_aut = 0
for autor in otros_autores:
autorAux = db(db.USUARIO.usbid == autor.usbid_usuario).select().first()
valores['autor_' + str(num_aut + 1)] = autorAux.usbid
num_aut += 1
# Los tipos documento tienen que ser tratados diferente y cargados los enlaces con js
hay_uploads = False
for row in rows:
rows_campo = db(db.CAMPO.id_campo == row.id_campo).select().first()
nombre = rows_campo.nombre_interno.replace(" ", "_")
try:
if int(nombre[0]):
nombre = "campo_" + nombre
except:
pass
obligatorio = rows_campo.obligatorio
tipo_campo = rows_campo.tipo_campo
if obligatorio:
obl[nombre.replace(" ", "_")] = tipo_campo
if tipo_campo in ['Fecha']:
fields.append(
Field(nombre,
'date',
label=rows_campo.nombre + " (*)",
requires=[
IS_NOT_EMPTY(),
IS_DATE(format=T('%Y-%m-%d'),
error_message=
'Fecha inválida, debe ser: AAA-MM-DD')
]))
elif tipo_campo in ['Texto Corto']:
fields.append(
Field(nombre,
'string',
label=rows_campo.nombre + " (*)",
requires=[
IS_NOT_EMPTY(error_message='Inserte texto')
]))
elif tipo_campo in ['Cedula']:
fields.append(
Field(nombre,
'string',
label=rows_campo.nombre + " (*)",
requires=[
IS_NOT_EMPTY(),
IS_MATCH('\d{2}.\d{3}.\d{3}$',
error_message=
'CI inválida, debe ser: XX.XXX.XXX')
]))
elif tipo_campo in ['Documento']:
if (row.valor_campo != ''):
temp = [
str(rows_campo.id_campo),
str(row.id_prod), rows_campo.nombre + " (*)", nombre
]
documentos += [temp]
fields.append(
Field(nombre,
'upload',
label=rows_campo.nombre + " (*)",
uploadfolder=os.path.join(request.folder, 'uploads'),
requires=[
IS_NOT_EMPTY(
error_message='Debe subirse un archivo')
]))
elif tipo_campo in ['Telefono']:
fields.append(
Field(
nombre,
'string',
label=rows_campo.nombre + " (*)",
requires=[
IS_NOT_EMPTY(),
IS_MATCH(
'\(0\d{3}\)\d{3}-\d{4}$',
error_message=
'Teléfeno inválido, debe ser: (0xxx)xxx-xxxx')
]))
elif tipo_campo in ['Cantidad Entera']:
fields.append(
Field(nombre,
'string',
label=rows_campo.nombre + " (*)",
requires=[
IS_NOT_EMPTY(),
IS_INT_IN_RANGE(-9223372036854775800,
9223372036854775807)
]))
elif tipo_campo in ['Cantidad Decimal']:
fields.append(
Field(
nombre,
'string',
label=rows_campo.nombre + " (*)",
requires=[
IS_NOT_EMPTY(),
IS_DECIMAL_IN_RANGE(
-9223372036854775800,
9223372036854775807,
dot=".",
error_message=
'El número debe ser de la forma X.X, donde X está entre -9223372036854775800 y 9223372036854775807'
)
]))
elif tipo_campo in ['Texto Largo']:
fields.append(
Field(nombre,
'text',
label=rows_campo.nombre + " (*)",
requires=IS_NOT_EMPTY()))
else:
no_obl[nombre.replace(" ", "_")] = tipo_campo
if tipo_campo in ['Fecha']:
fields.append(
Field(nombre,
'date',
label=rows_campo.nombre,
requires=IS_EMPTY_OR(
IS_DATE(format=T('%Y-%m-%d'),
error_message=
'Fecha inválida, debe ser: AAA-MM-DD'))))
elif tipo_campo in ['Texto Corto']:
fields.append(Field(nombre, 'string', label=rows_campo.nombre))
elif tipo_campo in ['Cedula']:
fields.append(
Field(nombre,
'string',
label=rows_campo.nombre,
requires=IS_EMPTY_OR(
IS_MATCH('\d{2}.\d{3}.\d{3}$',
error_message=
'CI inválida, debe ser: XX.XXX.XXX'))))
elif tipo_campo in ['Documento']:
if (row.valor_campo != ''):
temp = [
str(rows_campo.id_campo), row.id_prod,
rows_campo.nombre, nombre
]
documentos += [temp]
fields.append(
Field(nombre,
'upload',
label=rows_campo.nombre,
requires=IS_EMPTY_OR(IS_UPLOAD_FILENAME()),
uploadfolder=os.path.join(request.folder,
'uploads')))
elif tipo_campo in ['Telefono']:
fields.append(
Field(nombre,
'string',
label=rows_campo.nombre,
requires=IS_EMPTY_OR(
IS_MATCH(
'\(0\d{3}\)\d{3}-\d{4}$',
error_message=
'Teléfeno inválido, debe ser: (0xxx)xxx-xxxx'
))))
elif tipo_campo in ['Cantidad Entera']:
fields.append(
Field(nombre,
'string',
label=rows_campo.nombre,
requires=IS_EMPTY_OR(
IS_INT_IN_RANGE(-9223372036854775800,
9223372036854775807))))
elif tipo_campo in ['Cantidad Decimal']:
fields.append(
Field(
nombre,
'string',
label=rows_campo.nombre,
requires=IS_EMPTY_OR(
IS_DECIMAL_IN_RANGE(
-9223372036854775800,
9223372036854775807,
dot=".",
error_message=
'El número debe ser de la forma X.X, donde X está entre -9223372036854775800 y 9223372036854775807'
))))
elif tipo_campo in ['Texto Largo']:
fields.append(Field(nombre, 'text', label=rows_campo.nombre))
valores[nombre] = row.valor_campo
print documentos
for i in range(5):
fields.append(
Field("c0mpr0bant3_" + str(i + 1),
'upload',
autodelete=True,
uploadseparate=True,
uploadfolder=os.path.join(request.folder, 'uploads'),
label=''))
fields.append(
Field("d3scr1pc10n_comprobante_" + str(i + 1),
'string',
label="Descripción"))
form = SQLFORM.factory(
*fields,
upload=URL('download'),
buttons=[
INPUT(_value='Guardar como Borrador',
_type="submit",
_class="btn blue-add btn-block btn-border ",
_name="borrador"),
INPUT(_value='Enviar Producto',
_type="submit",
_class="btn blue-add btn-block btn-border ")
])
form.element()
# Le escribimos la informacion a las vistas
for nombre_campo in valores.keys():
setattr(form.vars, nombre_campo, valores[nombre_campo])
#fix para el datepicker de las fechas:
for i in obl.keys():
form.element(_name=i)['_class'] = form.element(
_name=i)['_class'] + " obligatoria " + obl[i].replace(" ", "_")
for i in no_obl.keys():
form.element(_name=i)['_class'] = form.element(
_name=i)['_class'] + ' ' + no_obl[i].replace(" ", "_")
# Al aceptar el formulario
if form.process().accepted:
no = [
'nombre', 'descripcion', 'fecha_realizacion', 'fecha_modificacion',
'lugar', 'colaboradores'
]
sql = ''
if request.vars.borrador:
sql = "UPDATE PRODUCTO SET estado = 'Borrador' WHERE id_producto = '" + str(
id_producto) + "';"
insertar_log(db, 'PRODUCTO', datetime.datetime.now(),
request.client,
'MODICIFACION DE BORRADOR CON ID ' + str(id_producto),
session.usuario['usbid'])
else:
sql = "UPDATE PRODUCTO SET estado = 'Por Validar' WHERE id_producto = '" + str(
id_producto) + "';"
insertar_log(db, 'PRODUCTO', datetime.datetime.now(),
request.client,
'NUEVO PRODUCTO CON ID ' + str(id_producto),
session.usuario['usbid'])
sql2 = "UPDATE PRODUCTO SET fecha_modificacion='" + str(
now.date()) + "' WHERE id_producto = '" + str(id_producto) + "';"
db.executesql(sql)
db.executesql(sql2)
# Eliminamos los autores anteriores.
db(db.PARTICIPA_PRODUCTO.id_producto == id_producto).delete()
for var in form.vars:
#Buscamos los autores
try:
if (var[0:5] == "autor"):
usbid_autor = getattr(form.vars, var)
if usbid_autor != None:
db.PARTICIPA_PRODUCTO.insert(id_producto=id_producto,
usbid_usuario=usbid_autor)
except Exception, e:
print "Exception Autor: "
print e
try:
if (var[0:11] == "c0mpr0bant3"):
numero_comprobante = var[12:13]
descripcion = getattr(
form.vars,
'd3scr1pc10n_comprobante_' + numero_comprobante)
nombre = getattr(form.vars, var)
if nombre != '':
db.COMPROBANTE.insert(archivo=nombre,
descripcion=descripcion,
producto=id_producto)
continue
elif (var[0:11] == "d3scr1pc10n"):
continue
except Exception, e:
print "Exception: "
print e
if var[0:5] != 'autor' and var[0:8] != 'borrador':
valor_anterior = valores[var]
if not (var in no):
try:
if (var[0:6] == "campo_"):
campo = var[6:]
else:
campo = var
except Exception, e:
print "Exception: "
print e
campo = var
valor_nuevo = getattr(form.vars, var)
if valor_nuevo != valor_anterior:
campo = campo.replace("_", " ")
id_campo = db(db.CAMPO.nombre_interno ==
campo).select().first().id_campo
sql = "UPDATE PRODUCTO_TIENE_CAMPO SET valor_campo = '" + str(
valor_nuevo)
sql = sql + "' WHERE id_prod = '" + str(
id_producto) + "' AND id_campo = '" + str(
id_campo) + "';"
db.executesql(sql)
else:
pass
else:
valor_nuevo = getattr(form.vars, var)
if valor_nuevo != valor_anterior:
sql = "UPDATE PRODUCTO SET "+var+"= '"+str(valor_nuevo)+\
"' WHERE id_producto = '"+str(id_producto)+"';"
db.executesql(sql)
else:
pass
def agregar():
# (0212)363-7827
admin = get_tipo_usuario(session)
if (admin == 0 or admin == 2):
redirect(URL(c="default", f="index"))
message = ""
forma = SQLFORM.factory(
Field('usbid',
requires=[
IS_NOT_EMPTY(error_message='El USBID no puede quedar vacío.')
]),
Field('telefono',
requires=[
IS_LENGTH(20),
IS_MATCH('^\(0[0-9]{3}\)[0-9]{3}-[0-9]{4}$|^$',
error_message="El formato es inválido")
]),
Field(
'correo_alter',
requires=[
IS_MATCH(
'^[.A-z0-9À-ÿŸ\s-]+@[.A-z0-9À-ÿŸ\s-]+\.[.A-z0-9À-ÿŸ\s-]+$|^$',
error_message="El formato inválido")
]),
Field('tipo',
requires=IS_IN_SET(
{
'Usuario': 'Usuario',
'DEX': 'DEX',
'Administrador': 'Administrador',
'Bloqueado': 'Bloqueado'
},
zero=T('Seleccione...'),
error_message='Debe elegir un tipo de usuario')),
submit_button='Agregar',
labels={
'usbid': 'USBID (*)',
'telefono': 'Teléfono',
'correo_alter': 'Correo alternativo',
'tipo': 'Tipo (*)'
},
col3={
'telefono': 'Ej: (0212)123-1234',
'correo_alter': 'Ej: [email protected]'
})
"""
forma=SQLFORM( # Se hace un formulario para introducir un USBID.
db.USUARIO,
button=['Agregar'],
fields=['usbid','tipo','telefono','correo_alter'],
submit_button='Agregar',
labels={'usbid':'USBID','telefono':'Teléfono', 'correo_alter':'Correo alternativo','tipo':'Tipo'})
"""
# Estilo del boton
forma.element(
_type='submit')['_class'] = "btn blue-add btn-block btn-border"
forma.element(_type='submit')['_value'] = "Agregar"
if forma.accepts(request.vars, session, formname="forma"):
# En usbidAux almacenamos el usbid proporcionado por el administrador
# En buscarUser revisamos si el usuario a agregar efectivamente esta en el CAS
usbidAux = request.vars.usbid
buscasUser = os.popen(
"ldapsearch -x -h ldap.usb.ve -b \"dc=usb,dc=ve\" uid=" +
usbidAux + " |grep numEntries")
if buscasUser.read() == '':
message = T("El usuario no está registrado en el CAS")
else:
user = get_ldap_data(usbidAux)
print(user)
print("----\n")
telefonoAux = request.vars.telefono
correo_alterAux = request.vars.correo_alter
tipoAux = request.vars.tipo
print("AQUI AQUI:", telefonoAux)
print("AQUI AQUI:", correo_alterAux)
# Primero verificamos que el usuario que intenta agregarse no esta en la base de datos
if db(db.USUARIO.usbid == usbidAux).isempty():
# Luego de insertar al usuario, mostramos un formulario al administrador con los datos de la persona agregada
form = SQLFORM.factory(Field("USBID",
default=usbidAux,
writable=False),
Field('Nombres',
default=user["first_name"],
writable=False),
Field('Apellidos',
default=user["last_name"],
writable=False),
readonly=True)
if len(tipoAux) >= 3:
# Lo insertamos en la base de datos.
db.USUARIO.insert(ci=user["cedula"],
usbid=usbidAux,
nombres=user["first_name"],
apellidos=user["last_name"],
correo_inst=user["email"],
telefono=telefonoAux,
correo_alter=correo_alterAux,
tipo=tipoAux)
insertar_log(db, 'USUARIO', datetime.datetime.now(),
request.client,
'CREACION DE USUARIO ' + usbidAux,
session.usuario['usbid'])
return dict(form=form,
message=message,
errores=forma.errors,
bool=1,
admin=get_tipo_usuario(session))
else:
message = T("Debe Especificar un Tipo")
else:
message = T("El usuario ya está registrado")
else:
print("ERRORES: ", forma.errors)
return dict(form=forma,
message=message,
errores=forma.errors,
admin=get_tipo_usuario(session))
for i in range(len(comprobantes)):
pdf = os.path.join(request.folder, 'uploads', comprobantes[i][0][0:22],
comprobantes[i][0][23:25], comprobantes[i][0])
try:
os.unlink(pdf)
except Exception, e:
print "Exception: "
print e
set_tiene_campo = db(db.PRODUCTO_TIENE_CAMPO.id_prod == id_act)
set_tiene_campo.delete()
producto = db(db.PRODUCTO.id_producto == id_act)
producto.delete()
insertar_log(db, 'PRODUCTO', datetime.datetime.now(), request.client,
'PRODUCTO CON ID ' + str(id_act) + ' ELIMINADO',
session.usuario['usbid'])
redirect(URL('gestionar'))
#return "producto {} eliminada".format(producto)
return locals()
# Funcion utilizada para el ajax en el agregar
def obtener_actividades():
admin = get_tipo_usuario(session)
programa = db(db.PROGRAMA.nombre == request.vars.programa).select().first()
tiposA = db(db.TIPO_ACTIVIDAD.id_programa == programa.id_programa).select(
db.TIPO_ACTIVIDAD.nombre, db.TIPO_ACTIVIDAD.id_tipo,
db.TIPO_ACTIVIDAD.papelera).as_list()
def gestionar_programas():
admin = get_tipo_usuario(session)
# Obtengo todos los programas almacenados en la base de datos.
programas = db(db.PROGRAMA.papelera == False).select()
# Para agregar un programa.
formulario = SQLFORM.factory(
Field('Nombre',
requires = [IS_NOT_EMPTY(error_message='El nombre del programa no puede quedar vacío.'),
IS_MATCH('^[A-zÀ-ÿŸ\s]*$', error_message="Use sólo letras, sin números ni caracteres especiales."),
IS_LENGTH(256),
IS_NOT_IN_DB(db, 'PROGRAMA.nombre', error_message="Ya existe un programa con ese nombre.")]),
Field('Abreviacion',
requires = [IS_NOT_EMPTY(error_message='La abreviación del programa no puede quedar vacía.'),
IS_MATCH('^[A-zÀ-ÿŸ\s]*$', error_message="Use sólo letras, sin números ni caracteres especiales.")]),
Field('Descripcion', type="text",
requires=[IS_NOT_EMPTY(error_message='La descripción del programa no puede quedar vacía.'),
IS_LENGTH(2048)]),
submit_button = 'Agregar',
labels = {'Descripcion' : 'Descripción',
'Nombre' : 'Nombre del Programa',
'Abreviacion' : 'Abreviación del Programa'},
)
formulario.element(_type='submit')['_class']="btn blue-add btn-block btn-border"
formulario.element(_type='submit')['_value']="Agregar"
# Para editar un programa.
formulario_editar = SQLFORM.factory(
Field('Nombre',
requires = [IS_NOT_EMPTY(error_message='El nombre del programa no puede quedar vacío.'),
IS_MATCH('^[A-zÀ-ÿŸ\s]*$', error_message="Use sólo letras, sin números ni caracteres especiales."),
IS_LENGTH(256),
IS_NOT_IN_DB(db(db.PROGRAMA.id_programa != request.vars['id_programa']), 'PROGRAMA.nombre',
error_message= ('Ya existe un programa con el nombre "' + request.vars['Nombre'] + '".') if not(request.vars['Nombre'] is None) else 'Ya existe un programa con el nombre ')]),
Field('Abreviacion',
requires = [IS_NOT_EMPTY(error_message='La abreviación del programa no puede quedar vacía.'),
IS_MATCH('^[A-zÀ-ÿŸ\s]*$', error_message="Use solo letras, sin números ni caracteres especiales.")]),
Field('Descripcion', type="text",
requires=IS_NOT_EMPTY(error_message='La descripción del programa no puede quedar vacía.')),
Field('id_programa', type="string"),
submit_button = 'Agregar',
labels = {'Descripcion' : 'Descripción',
'Nombre' : 'Nombre del Programa',
'Abreviacion' : 'Abreviación del Programa'},
)
formulario_editar.element(_type='submit')['_class']="btn blue-add btn-block btn-border"
formulario_editar.element(_type='submit')['_value']="Editar"
# MÉTODO POST FORMULARIO AGREGAR:
# En caso de que los datos del formulario agregar estén correctos:
if formulario.accepts(request.vars, session, formname="formulario"):
# Se agrega el programa deseado a la base de datos.
db.PROGRAMA.insert(nombre = request.vars.Nombre,
abreviacion = request.vars.Abreviacion,
descripcion = request.vars.Descripcion)
# Se redirige a la vista de getión de programas.
insertar_log(db, 'PROGRAMA', datetime.datetime.now(), request.client, 'CREACION DE PROGRAMA '+ request.vars.Nombre.upper(), session.usuario['usbid'])
redirect(URL('gestionar_programas.html'))
# En caso de que el formulario no sea aceptado:
elif (formulario.errors):
session.message = "Los datos del programa son inválidos. Inténtelo nuevamente."
# Se verifica si los campos están llenos correctamente.
if formulario_editar.accepts(request.vars, session, formname="formulario_editar"):
id_programa = request.vars.id_programa
programa = db(db.PROGRAMA.id_programa == id_programa).select().first()
session.form_nombre = request.vars.Nombre
programa.nombre = request.vars.Nombre
programa.abreviacion = request.vars.Abreviacion
programa.descripcion = request.vars.Descripcion
programa.update_record() # Se actualiza el programa.
insertar_log(db, 'PROGRAMA', datetime.datetime.now(), request.client, 'MODIFICACION DE PROGRAMA '+ request.vars.Nombre.upper(), session.usuario['usbid'])
redirect(URL('gestionar_programas.html')) # Se redirige a la vista de gestión.
# En caso de que el formulario no sea aceptado
elif formulario_editar.errors:
session.message = 'Error en los datos del formulario, por favor intente nuevamente.'
# MÉTODO POST FORMULARIO EDITAR:
return dict(admin=admin, programas=programas, hayErroresAgregar=formulario.errors,
hayErroresEditar=formulario_editar.errors, formulario=formulario,
formulario_editar=formulario_editar)
def logout_cas():
insertar_log(db, 'LOGOUT', datetime.datetime.now(), request.client,
'LOGOUT SATISFACTORIO', session.usuario['usbid'])
session.usuario = None
return response.render()
