# 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

gestion = Blueprint('gestion', __name__)

@gestion.before_request
@login_required
def verifica_permisos():
    pass

# @gestion.route("/gestion/nuevoobjetivo", methods=['POST'])
# def newsingle():
#     cid = int(request.form['responsable'])
#     fid = int(request.form['id'])
#     nombre = request.form['nombre'].strip()
#     if fid > 0 and cid > 0 and nombre:
#         fobj = Objetivo.query.get(fid)
#         nobj = Objetivo(nombre=nombre, tipo=fobj.tipo, parentid=fid, estado=0, responsableid=cid)
#         db.session.add(nobj)
#         db.session.commit()
#         flash(u'Elemento "{}" generado con exito.'.format(nombre),'success')
#     else:
#         flash(u'Los datos ingresados son inválidos.','danger')
#
#     return redirect(url_for('gestion.manager'))

@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 ilab_app.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 ilab_app.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 ilab_app.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 ilab_app 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)