884 lines
32 KiB
Python
884 lines
32 KiB
Python
# coding: utf-8
|
|
from flask import render_template, flash, redirect, send_file, url_for, request, Blueprint, current_app, abort, g
|
|
from flask_login import login_required, current_user
|
|
from webinterface import db
|
|
from sqlalchemy.sql import func
|
|
from webinterface.models.gestion import Objetivo, Comision, Miembro, Avance, Accion, AccesoGestion, ModuloGestion, AccesosModuloGestion, Acta, AnexosActa, MiembrosAsistentes, InvitadosAsistentes
|
|
import datetime
|
|
import jinja2
|
|
import base64
|
|
|
|
|
|
gestion = Blueprint('gestion', __name__)
|
|
|
|
@gestion.before_request
|
|
@login_required
|
|
def verifica_permisos():
|
|
pass
|
|
|
|
@jinja2.pass_context
|
|
@gestion.app_template_filter()
|
|
def b64encode(context, value):
|
|
if value is None:
|
|
return ''
|
|
else:
|
|
return base64.b64encode(value.encode("utf-8")).decode('utf-8')
|
|
|
|
|
|
@gestion.route("/objetivos/editmodulo", methods=['POST'])
|
|
def editmodulo():
|
|
# for key, values in request.form.items():
|
|
# current_app.logger.debug('request: {}: {}'.format(key, values))
|
|
|
|
try:
|
|
mid = int(request.form['id'])
|
|
except:
|
|
mid = 0
|
|
uri = request.form['uri'].strip().lower()
|
|
|
|
if not uri:
|
|
flash("Los datos ingresados son incorrectos: uri vacio", 'danger')
|
|
abort(400)
|
|
|
|
existeA = ModuloGestion.query.filter(ModuloGestion.id==mid).one_or_none()
|
|
existeB = ModuloGestion.query.filter(ModuloGestion.uri==uri).one_or_none()
|
|
|
|
|
|
if existeA is None and existeB is None:
|
|
flash("Creado el modulo: {}".format(request.form['nombre'].strip()), 'success')
|
|
|
|
nodobase = Objetivo(nombre=request.form['nombre'].strip(), tipo=request.form['icon'].strip().lower(), descripcion='gestion.{}'.format(uri), parentid=1, estado=0, responsableid=1)
|
|
db.session.add(nodobase)
|
|
|
|
if mid==0:
|
|
existe = ModuloGestion(nombre=request.form['nombre'].strip(), etiqueta=request.form['etiqueta'].strip().lower().capitalize(), uri=uri, nodobase=nodobase)
|
|
else:
|
|
existe = ModuloGestion(id=mid, nombre=request.form['nombre'].strip(), etiqueta=request.form['etiqueta'].strip().lower().capitalize(), uri=uri, nodobase=nodobase)
|
|
|
|
|
|
db.session.add(existe)
|
|
|
|
for value in request.form.getlist('comisiones'):
|
|
acceso = AccesosModuloGestion(comisionid=int(value), modulo=existe)
|
|
db.session.add(acceso)
|
|
# current_app.logger.debug('Acceso comision: {}'.format(value))
|
|
|
|
db.session.commit()
|
|
elif existeA is not None:
|
|
|
|
flash("Modificada el acceso del modulo: {}".format(existeA.nombre), 'success')
|
|
|
|
for exmiembro in AccesosModuloGestion.query.filter(AccesosModuloGestion.moduloid==mid).all():
|
|
# current_app.logger.debug('quita comision: {}'.format(exmiembro.comisionid))
|
|
db.session.delete(exmiembro)
|
|
db.session.commit()
|
|
|
|
existeA.nombre = request.form['nombre'].strip()
|
|
existeA.etiqueta = request.form['etiqueta'].strip().lower().capitalize()
|
|
existeA.uri = uri
|
|
existeA.nodobase.nombre = request.form['nombre'].strip()
|
|
existeA.nodobase.tipo = request.form['icon'].strip().lower()
|
|
existeA.nodobase.descripcion = 'gestion.{}'.format(uri)
|
|
|
|
for value in request.form.getlist('comisiones'):
|
|
acceso = AccesosModuloGestion(comisionid=int(value), modulo=existeA)
|
|
db.session.add(acceso)
|
|
# current_app.logger.debug('Acceso comision: {}'.format(value))
|
|
|
|
db.session.commit()
|
|
existe = existeA
|
|
elif existeB is not None and mid > 0:
|
|
|
|
flash("Modificada el acceso del modulo: {}".format(existeB.nombre), 'success')
|
|
|
|
for exmiembro in AccesosModuloGestion.query.filter(AccesosModuloGestion.moduloid==existeB.id).all():
|
|
# current_app.logger.debug('quita comision: {}'.format(exmiembro.comisionid))
|
|
db.session.delete(exmiembro)
|
|
db.session.commit()
|
|
|
|
existeB.nombre = request.form['nombre'].strip()
|
|
existeB.etiqueta = request.form['etiqueta'].strip().lower().capitalize()
|
|
existeB.id = mid
|
|
existeB.nodobase.nombre = request.form['nombre'].strip()
|
|
existeB.nodobase.tipo = request.form['icon'].strip().lower()
|
|
existeB.nodobase.descripcion = 'gestion.{}'.format(uri)
|
|
|
|
for value in request.form.getlist('comisiones'):
|
|
acceso = AccesosModuloGestion(comisionid=int(value), modulo=existeB)
|
|
db.session.add(acceso)
|
|
# current_app.logger.debug('Acceso comision: {}'.format(value))
|
|
|
|
db.session.commit()
|
|
existe = existeB
|
|
else:
|
|
flash("Los datos ingresados son incorrectos", 'danger')
|
|
abort(400)
|
|
|
|
############################################################################
|
|
############# Mantenimieto de las accesos grupales #############
|
|
############################################################################
|
|
|
|
administradores = []
|
|
conacceso = existe.mvector()
|
|
|
|
for item in Comision.query.filter(Comision.id>999, Comision.creado==1).all():
|
|
administradores.append(item.id)
|
|
|
|
|
|
for administrador in administradores:
|
|
acceso = Objetivo.query.filter(Objetivo.parentid==existe.nodobase.id, Objetivo.responsableid==administrador).one_or_none()
|
|
if acceso is None and administrador in conacceso:
|
|
responsable = Comision.query.get(administrador)
|
|
acceso = Objetivo(nombre="{} {}".format(request.form['nombre'].strip(), responsable.nombre), descripcion=existe.nodobase.descripcion, tipo=existe.nodobase.tipo, responsableid=administrador, parentid=existe.nodobase.id, estado=0)
|
|
db.session.add(acceso)
|
|
elif acceso is not None:
|
|
acceso.tipo = existe.nodobase.tipo
|
|
acceso.descripcion = existe.nodobase.descripcion
|
|
if administrador in conacceso:
|
|
acceso.estado = 0
|
|
else:
|
|
acceso.estado = 100
|
|
|
|
db.session.commit()
|
|
|
|
return redirect(url_for('gestion.modulos'))
|
|
|
|
@gestion.route("/objetivos/nuevacomision", methods=['POST'])
|
|
def newcomision():
|
|
cid = int(request.form['id'])
|
|
|
|
if cid == 0:
|
|
ncomision = Comision(nombre=request.form['nombre'].strip(), creado=int(request.form['admin']))
|
|
db.session.add(ncomision)
|
|
for value in request.form.getlist('miembros'):
|
|
miembro = Miembro(personaid=int(value), comision=ncomision)
|
|
db.session.add(miembro)
|
|
# current_app.logger.debug('crea miembro: {}'.format(value))
|
|
db.session.commit()
|
|
else:
|
|
for exmiembro in Miembro.query.filter_by(comisionid=cid).all():
|
|
# current_app.logger.debug('quita miembro: {}'.format(exmiembro.personaid))
|
|
db.session.delete(exmiembro)
|
|
db.session.commit()
|
|
|
|
ncomision = Comision.query.get(cid)
|
|
ncomision.nombre=request.form['nombre'].strip()
|
|
|
|
for value in request.form.getlist('miembros'):
|
|
miembro = Miembro(personaid=int(value), comision=ncomision)
|
|
db.session.add(miembro)
|
|
# current_app.logger.debug('agrega miembro: {}'.format(value))
|
|
|
|
db.session.commit()
|
|
|
|
if ncomision.creado==1 and cid==0:
|
|
return redirect(url_for('gestion.manager', admin=1))
|
|
elif ncomision.creado==1 and cid>0:
|
|
return redirect(url_for('gestion.manager', admin=cid))
|
|
else:
|
|
return redirect(url_for('gestion.manager', admin=ncomision.creado))
|
|
|
|
|
|
@gestion.route("/objetivos/delcomision/<int:comisionid>", methods=['GET'])
|
|
def delcomision(comisionid):
|
|
|
|
todel = Comision.query.filter(Comision.id == comisionid).first()
|
|
if todel is None:
|
|
abort(404)
|
|
|
|
if todel.creado == 1:
|
|
abort(403)
|
|
|
|
canI = Miembro.query.filter(Miembro.personaid==current_user.id, Miembro.comisionid==todel.creado).first()
|
|
if canI is None:
|
|
abort(403)
|
|
|
|
responsable = todel.creado
|
|
nombre = todel.nombre
|
|
|
|
for item in Objetivo.query.filter(Objetivo.responsableid==todel.id).all():
|
|
item.responsableid = responsable
|
|
for item in Objetivo.query.filter(Objetivo.invitadosid==todel.id).all():
|
|
item.invitadosid = None
|
|
for item in Miembro.query.filter(Miembro.comisionid==todel.id).all():
|
|
db.session.delete(item)
|
|
db.session.delete(todel)
|
|
db.session.commit()
|
|
|
|
flash(u"Comision '{}' eliminada con éxito".format(nombre), 'success')
|
|
return redirect(url_for('gestion.manager', admin=responsable))
|
|
|
|
|
|
@gestion.route("/objetivos/syscomision", methods=['POST'])
|
|
def syscomision():
|
|
cid = int(request.form['id'])
|
|
new = Comision.query.filter(Comision.id == cid).first()
|
|
|
|
if cid == 0:
|
|
ncomision = Comision(nombre=request.form['nombre'].strip(), creado=1)
|
|
db.session.add(ncomision)
|
|
for value in request.form.getlist('miembros'):
|
|
miembro = Miembro(personaid=int(value), comision=ncomision)
|
|
db.session.add(miembro)
|
|
# current_app.logger.debug('crea miembro: {}'.format(value))
|
|
db.session.commit()
|
|
elif new is None:
|
|
ncomision = Comision(id=cid, nombre=request.form['nombre'].strip(), creado=1)
|
|
db.session.add(ncomision)
|
|
for value in request.form.getlist('miembros'):
|
|
miembro = Miembro(personaid=int(value), comision=ncomision)
|
|
db.session.add(miembro)
|
|
# current_app.logger.debug('crea miembro: {}'.format(value))
|
|
db.session.commit()
|
|
else:
|
|
for exmiembro in Miembro.query.filter_by(comisionid=cid).all():
|
|
# current_app.logger.debug('quita miembro: {}'.format(exmiembro.personaid))
|
|
db.session.delete(exmiembro)
|
|
db.session.commit()
|
|
|
|
ncomision = Comision.query.get(cid)
|
|
ncomision.nombre=request.form['nombre'].strip()
|
|
|
|
for value in request.form.getlist('miembros'):
|
|
miembro = Miembro(personaid=int(value), comision=ncomision)
|
|
db.session.add(miembro)
|
|
# current_app.logger.debug('agrega miembro: {}'.format(value))
|
|
|
|
db.session.commit()
|
|
|
|
############################################################################
|
|
############# Mantenimieto del acceso alas tareas personales #############
|
|
############################################################################
|
|
for item in Objetivo.query.filter(Objetivo.parentid==2, Objetivo.estado<100).all():
|
|
item.estado=100
|
|
|
|
db.session.commit()
|
|
personal = []
|
|
for item in Miembro.query.filter(Miembro.comisionid==2).all():
|
|
personal.append(item.personaid)
|
|
|
|
for personaid in personal:
|
|
from webinterface.models.system import Persona
|
|
theuser = Persona.query.get(personaid)
|
|
|
|
comisionpersonal = Comision.query.filter(Comision.nombre=="Personal {}".format(theuser.login), Comision.creado==2).one_or_none()
|
|
if comisionpersonal is None:
|
|
comisionpersonal = Comision(nombre="Personal {}".format(theuser.login), creado=2)
|
|
db.session.add(comisionpersonal)
|
|
db.session.commit()
|
|
|
|
miembrocomisonpersoanal = Miembro.query.filter(Miembro.comisionid==comisionpersonal.id).first()
|
|
if miembrocomisonpersoanal is None:
|
|
miembrocomisonpersoanal = Miembro(comisionid=comisionpersonal.id, personaid=personaid)
|
|
db.session.add(miembrocomisonpersoanal)
|
|
|
|
|
|
objetivopersonal = Objetivo.query.filter(Objetivo.responsableid==comisionpersonal.id, Objetivo.parentid==2).one_or_none()
|
|
if objetivopersonal is None:
|
|
objetivopersonal = Objetivo(tipo='user-lock', nombre="{}".format(theuser.nombrecompleto), responsableid=comisionpersonal.id, parentid=2, estado=0)
|
|
db.session.add(objetivopersonal)
|
|
else:
|
|
objetivopersonal.estado=0
|
|
db.session.commit()
|
|
|
|
|
|
|
|
return redirect(url_for('gestion.manager', admin=1))
|
|
|
|
|
|
@gestion.route("/gestion/actividad", methods=['POST'])
|
|
def actividad():
|
|
# for key, values in request.form.items():
|
|
# current_app.logger.debug('request: {}: {}'.format(key, values))
|
|
|
|
try:
|
|
oid = int(request.form['oid'])
|
|
pid = int(request.form['pid'])
|
|
fecha = datetime.datetime.strptime(request.form['fecha'], '%d/%m/%Y').date()
|
|
except Exception as e:
|
|
flash("Los datos ingresados son incorrectos: {}".format(str(e)), 'danger')
|
|
abort(400)
|
|
try:
|
|
dedicacion = int(request.form['dedicacion'])
|
|
except Exception as e:
|
|
dedicacion = 0
|
|
|
|
|
|
if oid > 0:
|
|
item = Accion.query.get(oid)
|
|
|
|
item.nombre = request.form['nombre'].strip()[:100]
|
|
item.descripcion = request.form['descripcion'].strip()
|
|
item.dedicacion = dedicacion
|
|
item.fecha = fecha
|
|
|
|
item.modificadopor = current_user.id
|
|
# item.modificado = datetime.datetime.now()
|
|
|
|
db.session.commit()
|
|
elif pid > 0:
|
|
item = Accion(objetivoid=pid, nombre=request.form['nombre'].strip()[:100], descripcion=request.form['descripcion'].strip(),
|
|
fecha=fecha, estado=0, dedicacion=dedicacion)
|
|
|
|
item.creadopor = current_user.id
|
|
# item.creado = datetime.datetime.now()
|
|
item.modificadopor = current_user.id
|
|
# item.modificado = datetime.datetime.now()
|
|
|
|
db.session.add(item)
|
|
db.session.commit()
|
|
|
|
return redirect(url_for('gestion.show', objetivoid=item.objetivoid))
|
|
|
|
@gestion.route("/gestion/acta", methods=['POST'])
|
|
def acta():
|
|
# for key, values in request.form.items():
|
|
# current_app.logger.debug('request: {}: {}'.format(key, values))
|
|
|
|
try:
|
|
aid = int(request.form['aid'])
|
|
pid = int(request.form['pid'])
|
|
except Exception as e:
|
|
import traceback
|
|
current_app.logger.error('Traceback {}'.format(traceback.format_exc()))
|
|
flash("Los datos ingresados son incorrectos: {}".format(str(e)), 'danger')
|
|
abort(400)
|
|
|
|
try:
|
|
lugar = request.form['lugar'].strip()
|
|
d, m, y = request.form['fecha'].split('/',2)
|
|
hi, mi = request.form['hini'].split(':',2)
|
|
hf, mf = request.form['hfin'].split(':',2)
|
|
|
|
except Exception as e:
|
|
import traceback
|
|
current_app.logger.error('Traceback {}'.format(traceback.format_exc()))
|
|
abort(400)
|
|
|
|
horaini = datetime.datetime.strptime('{}/{}/{} {}:{}'.format(d,m,y,hi,mi), "%d/%m/%Y %H:%M")
|
|
horafin = datetime.datetime.strptime('{}/{}/{} {}:{}'.format(d,m,y,hf,mf), "%d/%m/%Y %H:%M")
|
|
|
|
if aid > 0:
|
|
item = Acta.query.filter(Acta.id==aid).one()
|
|
|
|
item.lugar = lugar
|
|
item.horaini = horaini
|
|
item.horafin = horafin
|
|
|
|
item.temas = request.form['temario']
|
|
item.desarrollo = request.form['desarrollo']
|
|
item.acuerdos = request.form['acuerdos']
|
|
|
|
item.modificadopor = current_user.id
|
|
# item.modificado = datetime.datetime.now()
|
|
|
|
# db.session.commit()
|
|
|
|
elif pid > 0:
|
|
cantidad = db.session.query(func.count(Acta.id)).filter(Acta.objetivoid==pid).scalar()
|
|
current_app.logger.debug('Contador {}'.format(cantidad))
|
|
seq = 1+int(cantidad)
|
|
|
|
item = Acta(objetivoid=pid, secuencia=seq, lugar=lugar, horaini=horaini, horafin=horafin, temas=request.form['temario'], desarrollo=request.form['desarrollo'], acuerdos=request.form['acuerdos'])
|
|
item.creadopor = current_user.id
|
|
# item.creado = datetime.datetime.now()
|
|
item.modificadopor = current_user.id
|
|
# item.modificado = datetime.datetime.now()
|
|
db.session.add(item)
|
|
else:
|
|
current_app.logger.error('aid = 0 y pid = 0')
|
|
abort(400)
|
|
|
|
db.session.commit()
|
|
miembros = []
|
|
for ma in MiembrosAsistentes.query.filter(MiembrosAsistentes.actaid==item.id).all():
|
|
miembros.append(ma.personaid)
|
|
|
|
for value in request.form.getlist('asistentes'):
|
|
v = int(value)
|
|
if v in miembros:
|
|
miembros.remove(v)
|
|
else:
|
|
db.session.add( MiembrosAsistentes(personaid=v, actaid=item.id) )
|
|
|
|
for v in miembros:
|
|
db.session.delete( MiembrosAsistentes.query.filter(MiembrosAsistentes.actaid==item.id, MiembrosAsistentes.personaid==v).one() )
|
|
|
|
invitados = []
|
|
for ia in InvitadosAsistentes.query.filter(InvitadosAsistentes.actaid==item.id).all():
|
|
invitados.append(ia.correo)
|
|
|
|
for value in request.form['invitados'].splitlines():
|
|
value = value.replace('\t', ' ')
|
|
try:
|
|
correo, nombre = value.strip().split(' ', 1)
|
|
except:
|
|
correo = value.strip()
|
|
nombre = ''
|
|
|
|
kcorreo = correo.strip().lower()
|
|
|
|
if kcorreo in invitados:
|
|
invitados.remove(kcorreo)
|
|
ikc = InvitadosAsistentes.query.filter(InvitadosAsistentes.actaid==item.id, InvitadosAsistentes.correo==kcorreo).one()
|
|
ikc.nombre = nombre.strip().title()
|
|
else:
|
|
db.session.add( InvitadosAsistentes(correo=kcorreo, actaid=item.id, nombre=nombre.strip().title()) )
|
|
|
|
for v in invitados:
|
|
db.session.delete( InvitadosAsistentes.query.filter(InvitadosAsistentes.actaid==item.id, InvitadosAsistentes.correo==v).one() )
|
|
|
|
db.session.commit()
|
|
flash(u"El Acta fue ingresado con éxito con el correlativo: {}".format(item.secuencia), 'success')
|
|
|
|
return redirect(url_for('gestion.show', objetivoid=item.objetivoid))
|
|
|
|
|
|
|
|
@gestion.route("/gestion/carpeta", methods=['POST'])
|
|
def carpeta():
|
|
# for key, values in request.form.items():
|
|
# current_app.logger.debug('request: {}: {}'.format(key, values))
|
|
|
|
try:
|
|
oid = int(request.form['oid'])
|
|
pid = int(request.form['pid'])
|
|
except Exception as e:
|
|
flash("Los datos ingresados son incorrectos: {}".format(str(e)), 'danger')
|
|
abort(400)
|
|
try:
|
|
dedicacion = int(request.form['dedicacion'])
|
|
except Exception as e:
|
|
dedicacion = 0
|
|
|
|
fecha = datetime.datetime.strptime(request.form['fecha'], '%d/%m/%Y').date()
|
|
|
|
if oid > 0:
|
|
item = Accion.query.get(oid)
|
|
|
|
item.nombre = request.form['nombre'].strip()[:100]
|
|
item.descripcion = request.form['descripcion'].strip()
|
|
item.dedicacion = dedicacion
|
|
item.fecha = fecha
|
|
|
|
item.modificadopor = current_user.id
|
|
# item.modificado = datetime.datetime.now()
|
|
|
|
|
|
db.session.commit()
|
|
elif pid > 0:
|
|
item = Accion(objetivoid=pid, nombre=request.form['nombre'].strip()[:100], descripcion=request.form['descripcion'].strip(),
|
|
fecha=fecha, estado=0, dedicacion=dedicacion)
|
|
|
|
item.creadopor = current_user.id
|
|
# item.creado = datetime.datetime.now()
|
|
item.modificadopor = current_user.id
|
|
# item.modificado = datetime.datetime.now()
|
|
|
|
db.session.add(item)
|
|
db.session.commit()
|
|
|
|
return redirect(url_for('gestion.documentos'))
|
|
|
|
|
|
@gestion.route("/gestion/edit", methods=['POST'])
|
|
def modificar():
|
|
# for key, values in request.form.items():
|
|
# current_app.logger.debug('request: {}: {}'.format(key, values))
|
|
|
|
try:
|
|
oid = int(request.form['oid'])
|
|
pid = int(request.form['pid'])
|
|
rid = int(request.form['responsable'])
|
|
except Exception as e:
|
|
flash("Los datos ingresados son incorrectos: {}".format(str(e)), 'danger')
|
|
abort(400)
|
|
|
|
try:
|
|
iid = int(request.form['invitado'])
|
|
except:
|
|
iid = None
|
|
finally:
|
|
if iid == 0:
|
|
iid = None
|
|
|
|
if oid > 0:
|
|
item = Objetivo.query.get(oid)
|
|
|
|
item.nombre = request.form['nombre'].strip()[:200]
|
|
item.descripcion = request.form['descripcion'].strip()
|
|
item.responsableid = rid
|
|
item.invitadosid = iid
|
|
|
|
item.modificadopor = current_user.id
|
|
# item.modificado = datetime.datetime.now()
|
|
|
|
db.session.commit()
|
|
elif pid > 0:
|
|
item = Objetivo(parentid=pid, nombre=request.form['nombre'].strip()[:200], descripcion = request.form['descripcion'].strip(),
|
|
responsableid = rid, invitadosid=iid, estado=0)
|
|
|
|
item.creadopor = current_user.id
|
|
item.modificadopor = current_user.id
|
|
# item.creado = datetime.datetime.now()
|
|
# item.modificado = datetime.datetime.now()
|
|
|
|
db.session.add(item)
|
|
db.session.commit()
|
|
|
|
if request.form['redirect']:
|
|
return redirect(request.form['redirect'])
|
|
else:
|
|
return redirect(url_for('gestion.show', objetivoid=item.id))
|
|
|
|
|
|
@gestion.route("/gestion/indicador", methods=['POST'])
|
|
def indicador():
|
|
# for key, values in request.form.items():
|
|
# current_app.logger.debug('request: {}: {}'.format(key, values))
|
|
|
|
try:
|
|
oid = int(request.form['oid'])
|
|
pid = int(request.form['pid'])
|
|
|
|
except Exception as e:
|
|
flash("Los datos ingresados son incorrectos: {}".format(str(e)), 'danger')
|
|
abort(400)
|
|
|
|
try:
|
|
ini = int(request.form['inicial'])
|
|
val = int(request.form['valor'])
|
|
tot = int(request.form['meta'])
|
|
except:
|
|
ini = 0
|
|
val = 0
|
|
tot = 100
|
|
|
|
if oid > 0:
|
|
item = Avance.query.get(oid)
|
|
item.nombre = request.form['nombre'].strip()[:100]
|
|
|
|
item.inicial = ini
|
|
item.valor = val
|
|
item.meta = tot
|
|
db.session.commit()
|
|
elif pid > 0:
|
|
item = Avance(objetivoid=pid, nombre=request.form['nombre'].strip()[:100],
|
|
inicial = ini, valor = val, meta = tot)
|
|
db.session.add(item)
|
|
db.session.commit()
|
|
|
|
return redirect(url_for('gestion.show', objetivoid=item.objetivoid))
|
|
|
|
@gestion.route("/gestion/subelogo", methods=['POST'])
|
|
def subelogo():
|
|
# for key, values in request.form.items():
|
|
# current_app.logger.debug('request: {}: {}'.format(key, values))
|
|
try:
|
|
cid = int(request.form['cid'])
|
|
tipologo = int(request.form['tipologo'])
|
|
|
|
except Exception as e:
|
|
flash(u"Los datos ingresados son incorrectos: {}".format(str(e)), 'danger')
|
|
abort(400)
|
|
|
|
comision = Comision.query.filter(Comision.id==cid).one_or_none()
|
|
|
|
if comision is None:
|
|
abort(404)
|
|
|
|
if comision.creado > 1:
|
|
abort(403)
|
|
|
|
permiso = Miembro.query.filter(Miembro.comisionid==comision.id, Miembro.personaid==current_user.id).one_or_none()
|
|
if permiso is None:
|
|
abort(403)
|
|
|
|
if 'documento' in request.files and len(request.files['documento'].filename) > 0:
|
|
from werkzeug.utils import secure_filename
|
|
import os
|
|
uploaded_file = request.files['documento']
|
|
name = secure_filename(uploaded_file.filename)
|
|
nombre, extension = os.path.splitext(name.lower())
|
|
if extension not in ['.png']:
|
|
flash(u"Solo se aceptan imágenes formato PNG", 'warning')
|
|
else:
|
|
from webinterface.content.docs.utils import ingest_file
|
|
(item, previtem) = ingest_file()
|
|
|
|
if tipologo == 1:
|
|
flash(u"El logo fue subido con éxito", 'success')
|
|
comision.logo = item.hash
|
|
elif tipologo == 2:
|
|
flash(u"El encabezado de página fue subido con éxito", 'success')
|
|
comision.titulo = item.hash
|
|
|
|
db.session.commit()
|
|
|
|
return redirect(url_for('gestion.manager', admin=comision.id))
|
|
|
|
|
|
@gestion.route("/gestion/admin/<int:admin>")
|
|
@gestion.route("/gestion/admin/")
|
|
def manager(admin=0):
|
|
|
|
admindata = AccesoGestion()
|
|
|
|
current_app.logger.info('Admin Access: IP({}), USER({})'.format(g.ip.ipaddr, current_user.login))
|
|
|
|
if admin==0 or (admin not in admindata.admin):
|
|
adming = next(admindata.administrador())
|
|
return redirect(url_for('gestion.manager', admin=adming.id))
|
|
else:
|
|
return render_template('gestion/comisiones.html', title=u'Gestión', admindata=admindata, admin=admin, grupo='Responsabilidades', tag='gestion.manager')
|
|
|
|
@gestion.route("/gestion/modulos/")
|
|
def modulos():
|
|
|
|
admindata = AccesoGestion()
|
|
if not admindata.sysadmin:
|
|
current_app.logger.warning('Modulo Access Denied: IP({}), USER({})'.format(g.ip.ipaddr, current_user.login))
|
|
abort(403)
|
|
|
|
current_app.logger.info('Modulo Access: IP({}), USER({})'.format(g.ip.ipaddr, current_user.login))
|
|
|
|
return render_template('gestion/modulos.html', title=u'Módulos de Gestión', admindata=admindata, grupo='Responsabilidades', tag='gestion.modulos')
|
|
|
|
@gestion.route("/gestion/documentos/")
|
|
def documentos():
|
|
uri = "documentos"
|
|
modulo = ModuloGestion.query.filter(ModuloGestion.uri==uri).one_or_none()
|
|
|
|
if modulo is None:
|
|
current_app.logger.info('Acceso main {}: 404 IP({}), USER({})'.format(uri, g.ip.ipaddr, current_user.login))
|
|
abort(404)
|
|
|
|
accessdata = AccesoGestion()
|
|
|
|
if modulo not in accessdata.usuario:
|
|
current_app.logger.info('Acceso main {}: 403 IP({}), USER({})'.format(uri, g.ip.ipaddr, current_user.login))
|
|
abort(403)
|
|
|
|
|
|
return render_template('gestion/documentos.html', title=u'Almacen de {}'.format(modulo.nombre), root=modulo.nodobase, label=modulo.etiqueta, grupo='Responsabilidades', tag='gestion.{}'.format(modulo.uri), uri=uri)
|
|
|
|
|
|
@gestion.route("/gestion/<uri>")
|
|
def main(uri):
|
|
modulo = ModuloGestion.query.filter(ModuloGestion.uri==uri).one_or_none()
|
|
|
|
if modulo is None:
|
|
current_app.logger.info('Acceso main {}: 404 IP({}), USER({})'.format(uri, g.ip.ipaddr, current_user.login))
|
|
abort(404)
|
|
|
|
accessdata = AccesoGestion()
|
|
|
|
if modulo not in accessdata.usuario:
|
|
current_app.logger.info('Acceso main {}: 403 IP({}), USER({})'.format(uri, g.ip.ipaddr, current_user.login))
|
|
abort(403)
|
|
|
|
|
|
return render_template('gestion/resumenes.html', title=u'Tareas {}'.format(modulo.nombre), root=modulo.nodobase, label=modulo.etiqueta, grupo='Responsabilidades', tag='gestion.{}'.format(modulo.uri), uri=uri)
|
|
|
|
|
|
@gestion.route("/gestion/ver/<int:objetivoid>")
|
|
def show(objetivoid):
|
|
root = Objetivo.query.filter(Objetivo.id==objetivoid).one_or_none()
|
|
|
|
if root is None:
|
|
abort(404)
|
|
if not root.visible:
|
|
abort(403)
|
|
|
|
return render_template('gestion/objetivo.html', title=u'Tareas personales', subtitulo='Vista en Detalle', root=root, label=root.modulo.etiqueta, grupo='Responsabilidades', tag='gestion.{}'.format(root.modulo.uri))
|
|
|
|
@gestion.route("/gestion/pdf/listaacta/<int:actaid>")
|
|
def listapdf(actaid):
|
|
root = Acta.query.filter(Acta.id==actaid).one_or_none()
|
|
|
|
if root is None:
|
|
abort(404)
|
|
if not root.objetivo.visible:
|
|
abort(403)
|
|
|
|
from .reporte import ListaActaPDF
|
|
from tempfile import NamedTemporaryFile
|
|
import traceback
|
|
with NamedTemporaryFile() as tmp:
|
|
try:
|
|
nombre_reporte = ListaActaPDF(tmp.name, root)
|
|
with NamedTemporaryFile() as tmp2:
|
|
import subprocess
|
|
cmd = subprocess.Popen([u"/usr/bin/ps2pdf {} {}".format(tmp.name, tmp2.name)], shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
|
cmd.wait()
|
|
return send_file(tmp2.name, as_attachment=True, download_name=nombre_reporte)
|
|
except:
|
|
current_app.logger.critical('Error al generar reporte: Objetivoid = {}'.format(actaid))
|
|
current_app.logger.debug('Traceback {}'.format(traceback.format_exc()))
|
|
abort(500)
|
|
|
|
@gestion.route("/gestion/pdf/acta/<int:actaid>")
|
|
def actapdf(actaid):
|
|
root = Acta.query.filter(Acta.id==actaid).one_or_none()
|
|
|
|
if root is None:
|
|
abort(404)
|
|
if not root.objetivo.visible:
|
|
abort(403)
|
|
|
|
from .reporte import ActaPDF
|
|
from tempfile import NamedTemporaryFile
|
|
import traceback
|
|
with NamedTemporaryFile() as tmp:
|
|
try:
|
|
nombre_reporte = ActaPDF(tmp.name, root)
|
|
with NamedTemporaryFile() as tmp2:
|
|
import subprocess
|
|
cmd = subprocess.Popen([u"/usr/bin/ps2pdf {} {}".format(tmp.name, tmp2.name)], shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
|
cmd.wait()
|
|
return send_file(tmp2.name, as_attachment=True, download_name=nombre_reporte)
|
|
except:
|
|
current_app.logger.critical('Error al generar reporte: Objetivoid = {}'.format(actaid))
|
|
current_app.logger.debug('Traceback {}'.format(traceback.format_exc()))
|
|
abort(500)
|
|
|
|
|
|
@gestion.route("/gestion/xls/reporte/<int:objetivoid>", methods=['GET'])
|
|
def reportexls(objetivoid):
|
|
|
|
root = Objetivo.query.filter(Objetivo.id==objetivoid).one_or_none()
|
|
|
|
if root is None:
|
|
abort(404)
|
|
if not root.visible:
|
|
abort(403)
|
|
|
|
|
|
from openpyxl import Workbook
|
|
from webinterface.models.system import Persona
|
|
from openpyxl.utils import get_column_letter
|
|
from tempfile import NamedTemporaryFile
|
|
|
|
wb = Workbook()
|
|
|
|
ws = wb.active
|
|
ws.title = root.nombre[:20]
|
|
ws.cell(column=1, row=1, value="Fecha")
|
|
ws.cell(column=2, row=1, value="Dedicación (Horas)")
|
|
ws.cell(column=3, row=1, value="Responsable")
|
|
ws.cell(column=4, row=1, value="Nombre")
|
|
ws.cell(column=5, row=1, value="Descripcion")
|
|
|
|
i = 1
|
|
|
|
for Accion in root.iactividades:
|
|
i = i + 1
|
|
ws.cell(column=1, row=i, value=Accion.fecha)
|
|
ws.cell(column=2, row=i, value=Accion.dedicacion)
|
|
|
|
if Accion.creadopor is not None:
|
|
creador = Persona.query.filter(Persona.id==Accion.creadopor).one_or_none()
|
|
ws.cell(column=3, row=i, value=creador.nombrecompleto)
|
|
|
|
ws.cell(column=4, row=i, value=Accion.nombre)
|
|
ws.cell(column=5, row=i, value=Accion.descripcion)
|
|
|
|
with NamedTemporaryFile() as tmp:
|
|
wb.save(tmp.name)
|
|
return send_file(tmp.name, as_attachment=True, download_name="Reporte_{}.xls".format(root.nombre[:20]))
|
|
|
|
|
|
@gestion.route("/gestion/pdf/reporte", methods=['POST'])
|
|
@gestion.route("/gestion/pdf/reporte/<int:objetivoid>", methods=['GET'])
|
|
def reporte(objetivoid=None):
|
|
if objetivoid==None:
|
|
try:
|
|
objetivoid = int(request.form['oid'])
|
|
except:
|
|
objetivoid = None
|
|
|
|
root = Objetivo.query.filter(Objetivo.id==objetivoid).one_or_none()
|
|
|
|
if root is None:
|
|
abort(404)
|
|
if not root.visible:
|
|
abort(403)
|
|
|
|
try:
|
|
Fini = datetime.datetime.strptime(request.form['fini'], '%d/%m/%Y').date()
|
|
Fend = datetime.datetime.strptime(request.form['fend'], '%d/%m/%Y').date()
|
|
current_app.logger.info('Se especifica rango de {} hasta {} para el reporte'.format(Fini, Fend))
|
|
except Exception as e:
|
|
import traceback
|
|
Fini = None
|
|
Fend = None
|
|
current_app.logger.info('No se especifica rango de fechas (valido) para el reporte')
|
|
|
|
from .reporte import ReportePDF
|
|
from tempfile import NamedTemporaryFile
|
|
import traceback
|
|
with NamedTemporaryFile() as tmp:
|
|
try:
|
|
nombre_reporte = ReportePDF(tmp.name, root, Fini, Fend)
|
|
# return send_file(tmp.name, as_attachment=True, download_name=nombre_reporte)
|
|
with NamedTemporaryFile() as tmp2:
|
|
import subprocess
|
|
cmd = subprocess.Popen([u"/usr/bin/ps2pdf {} {}".format(tmp.name, tmp2.name)], shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
|
cmd.wait()
|
|
return send_file(tmp2.name, as_attachment=True, download_name=nombre_reporte)
|
|
except:
|
|
current_app.logger.critical('Error al generar reporte: Objetivoid = {}'.format(objetivoid))
|
|
current_app.logger.debug('Traceback {}'.format(traceback.format_exc()))
|
|
abort(500)
|
|
|
|
|
|
|
|
@gestion.route("/gestion/pdf/acta/<int:actaid>/<string:masivo>")
|
|
@gestion.route("/gestion/pdf/acta/<int:actaid>/")
|
|
def acta_copiame(actaid, masivo=None):
|
|
root = Acta.query.filter(Acta.id==actaid).one_or_none()
|
|
|
|
if root is None:
|
|
abort(404)
|
|
if not root.objetivo.visible:
|
|
abort(403)
|
|
|
|
from flask_mail import Message
|
|
from webinterface import mail
|
|
from .reporte import ActaPDF
|
|
from tempfile import NamedTemporaryFile
|
|
import traceback
|
|
|
|
with NamedTemporaryFile() as tmp:
|
|
try:
|
|
nombre_reporte = ActaPDF(tmp.name, root)
|
|
with NamedTemporaryFile() as tmp2:
|
|
import subprocess
|
|
cmd = subprocess.Popen([u"/usr/bin/ps2pdf {} {}".format(tmp.name, tmp2.name)], shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
|
cmd.wait()
|
|
|
|
timestamp = datetime.datetime.today().strftime('%Y%m%d%H.%M%S')
|
|
|
|
if masivo is None:
|
|
msg = Message('Copia de Acta {}, {}'.format(root.secuencia, root.objetivo.nombre), sender='noreply@ilab.cl', recipients=[current_user.correodefecto.correo])
|
|
else:
|
|
msg = Message('Copia de Acta {}, {}'.format(root.secuencia, root.objetivo.nombre), sender='noreply@ilab.cl', recipients=root.correosasistentes)
|
|
|
|
msg.body = '''Ésta acta corresponde a la reunión {},
|
|
|
|
Fecha : {} desde las {} hasta las {} horas
|
|
Ubicación: {}
|
|
|
|
El detalle de los temas a tratar y los citados a asistir se encuentra en el documento adjunto.
|
|
|
|
Favor no contestar este mensaje, fue generado automáticamente por: {} a las {}'''.format(root.secuencia, root.horaini.strftime('%d/%m/%Y'), root.horaini.strftime('%H:%M'), root.horafin.strftime('%H:%M'), root.lugar, current_user.nombrecompleto, timestamp)
|
|
with open(tmp.name, 'rb') as fp:
|
|
msg.attach(filename=nombre_reporte, content_type="application/pdf", data=fp.read(), disposition=None, headers=None)
|
|
|
|
mail.send(msg)
|
|
return redirect(url_for('gestion.show', objetivoid=root.objetivoid))
|
|
except:
|
|
current_app.logger.critical('Error al generar reporte: Objetivoid = {}'.format(actaid))
|
|
current_app.logger.debug('Traceback {}'.format(traceback.format_exc()))
|
|
abort(500)
|