# 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)