Ejemplo n.º 1
0
def carreras_me():
    C = Storage()
    C.escuela = db.escuela(1)
    menu_migas.append(T("Descripciones de carreras"))

    tbl = db.descripcion_carrera
    query = (tbl.id > 0)

    tbl.id.readable = False
    text_lengths = {'descripcion_carrera.nombre': 50}

    C.titulo = T("Registro de carreras del Ministerio de Educación")

    puede_editar = auth.has_membership(role=myconf.take('roles.admin'))
#     puede_borrar = auth.has_membership(role=myconf.take('roles.admin'))
    puede_crear = auth.has_membership(role=myconf.take('roles.admin'))

    C.grid = grid_simple(query,
                         editable=puede_editar,
                         create=puede_crear,
                         maxtextlengths=text_lengths,
                         orderby=[tbl.nombre],
                         args=request.args[:1])

    return dict(C=C)
Ejemplo n.º 2
0
def index():
    C = Storage()
    C.escuela = db.escuela(1)
    menu_migas.append(T("Tipos de pagos"))

    C.titulo = T("Registro de tipos de pago")

    # permisos
    puede_editar = auth.has_membership(role=myconf.take('roles.admin'))
#     puede_borrar = auth.has_membership(role=myconf.take('roles.admin'))
    puede_crear = auth.has_membership(role=myconf.take('roles.admin'))

    tbl = db.tipo_pago

    query = (tbl.id > 0)
    tbl.id.readable = False

    if 'edit' in request.args:
        tbl.nombre.writable = False

    text_lengths = {'tipo_pago.nombre': 50}

    C.grid = grid_simple(query,
                         maxtextlengths=text_lengths,
                         create=puede_crear,
                         editable=puede_editar)

    return dict(C=C)
Ejemplo n.º 3
0
def historial():
    C = Storage()
    C.escuela = db.escuela(1)
    menu_migas.append(T("Control de cambios"))

    tbl_n = request.args(0)
    r_id = int(request.args(1))

    C.titulo = T("Historial de cambios TABLA: {} REGISTRO ID: {}").format(tbl_n, r_id)

    tbl = db["{}_archive".format(tbl_n)]
    query = (tbl.current_record == r_id)

    for f in tbl:
        f.readable = True
    tbl.current_record.readable = False

    C.current_record = SQLTABLE(db(db[tbl_n].id == r_id).select(),
                                headers="labels",
                                _class="table")
    C.grid = SQLFORM.grid(query, args=request.args[:2],
                          orderby=[~tbl.modified_on],
                          create=False,
                          searchable=False,
                          editable=False,
                          deletable=False,
                          details=False,
                          csv=False)

    return dict(C=C)
Ejemplo n.º 4
0
def pagos():
    """Muestra el listado de los pagos realizados"""
    C = Storage()
    C.evento = db.evento(request.args(0))
    C.persona = db.persona(request.args(1))
    C.ano = db.ano_academico(C.evento.ano_academico_id)
    C.unidad = db.unidad_organica(C.ano.unidad_organica_id)
    C.escuela = db.escuela(C.unidad.escuela_id)

    concepto = db(
        db.tipo_pago.nombre == "PROPINA"
    ).select().first()
    assert concepto != None

    query  = (db.pago.id > 0)
    query &= (db.pago.persona_id == C.persona.id)
    query &= (db.pago.evento_id == C.evento.id)
    query &= (db.pago.tipo_pago_id == concepto.id)
    l_pagos = [p.id for p in db(query).select(db.pago.id)]
    sumq = db.pago.cantidad.sum()
    C.total = db(query).select(sumq).first()[sumq] or 0.0
    sumz = db.propina.cantidad.sum()
    pquery  = (db.propina.id > 0)
    pquery &= (db.propina.persona_id == C.persona.id)
    pquery &= (db.propina.ano_academico_id == C.ano.id)
    C.propinas = db(pquery).select(sumz).first()[sumz] or 0.0

    for f in db.pago:
        f.readable = False
    db.pago.id.readable = True
    db.pago.fecha_recivo.readable = True
    db.pago.cantidad.readable = True

    db.pago.id.represent = lambda v,r: A(
        v, _href=URL(c='gcontable',
            f='pagos',
            args=['view', 'pago', v],
            extension=False,
            user_signature=True)
        )

    db.pago.id.label = T("ID Pago")

    C.titulo = T("Registro de pagos")
    C.titulo += " {}".format(C.persona.nombre_completo)
    C.grid = grid_simple(query,
        orderby=[db.pago.fecha_recivo],
        # fields=campos,
        create=False,
        history=False,
        details=False,
        csv=False,
        args=request.args[:2],
        formname="pagos")

    return dict(C=C)
Ejemplo n.º 5
0
def formulario():
    """Muestra formulario para realizar pago"""
    C = Storage()
    C.evento = db.evento(request.args(0))
    C.persona = db.persona(request.args(1))
    C.ano = db.ano_academico(C.evento.ano_academico_id)
    C.unidad = db.unidad_organica(C.ano.unidad_organica_id)
    C.escuela = db.escuela(C.unidad.escuela_id)

    concepto = db(
        db.tipo_pago.nombre == "PROPINA"
    ).select().first()

    C.titulo = T("Agregar pago")

    fld_forma_pago = db.pago.forma_pago
    fld_numero_transaccion = db.pago.numero_transaccion
    fld_transaccion = db.pago.transaccion
    fld_cantidad = db.pago.cantidad
    fld_codigo_recivo = db.pago.codigo_recivo
    fld_fecha_recivo = db.pago.fecha_recivo

    form = SQLFORM.factory(
        # campos...
        fld_forma_pago,
        fld_numero_transaccion,
        fld_transaccion,
        fld_codigo_recivo,
        fld_fecha_recivo,
        fld_cantidad,
        formstyle="bootstrap3_stacked"
    )

    if form.process().accepted:
        data = form.vars
        data.tipo_pago_id = concepto.id
        data.persona_id = C.persona.id
        data.evento_id = C.evento.id
        pago_id = db.pago.insert(**db.pago._filter_fields(data))
        # Intentar pagar las propinas que se deben
        pagar_propinas(C.evento.id, C.persona.id, db)
        response.js = "jQuery('#formulario_cmp').get(0).reload();jQuery('#pagos_cmp').get(0).reload();jQuery('#propinas_cmp').get(0).reload()"
        return T("Procesando...")

    C.form = form
    return dict(C=C)
Ejemplo n.º 6
0
def pagos():
    C = Storage()
    C.escuela = db.escuela(1)
    menu_migas.append(T("Control de pagos"))

    C.titulo = T("Registros general de pagos")

    # permisos
    puede_editar = auth.has_membership(role=myconf.take('roles.admin'))
    puede_borrar = auth.has_membership(role=myconf.take('roles.admin'))
#     puede_crear = auth.has_membership(role=myconf.take('roles.admin'))

    tbl = db.pago
    query = (tbl.id > 0) & (db.persona.id == tbl.persona_id)

    campos = [tbl.id,
              db.persona.nombre_completo,
              tbl.cantidad,
              tbl.evento_id,]
    tbl.id.readable = True
    for f in db.persona:
        f.readable = False
    db.persona.nombre_completo.readable = True
    db.persona.nombre_completo.label = T("Nombre")
    tbl.persona_id.readable = False
    if 'edit' in request.args:
        tbl.persona_id.readable = True
        tbl.persona_id.writable = False

    text_lengths = {'persona.nombre_completo': 30}

    C.grid = grid_simple(query,
                         field_id=tbl.id,
                         fields=campos,
                         orderby=[db.persona.nombre_completo],
                         create=False,
                         sortable=True,
                         maxtextlength=text_lengths,
                         editable=puede_editar,
                         deletable=puede_borrar,
                         details=True,
                         args=request.args[:1])

    return dict(C=C)
Ejemplo n.º 7
0
def turmas():
    C = Storage()
    C.unidad = db.unidad_organica(int(request.args(0)))
    C.escuela = db.escuela(C.unidad.escuela_id)

    # breadcumbs
    u_link = Accion(C.unidad.abreviatura or C.unidad.nombre,
                    URL('index', args=[C.unidad.id]),
                    True)  # siempre dentro de esta funcion
    menu_migas.append(u_link)
    menu_migas.append(T('Turmas'))

    C.titulo = T("Gestión de Turmas")

    tbl = db.turma
    tbl.id.readable = False
    tbl.unidad_organica_id.readable = False
    tbl.unidad_organica_id.writable = False
    tbl.unidad_organica_id.default = C.unidad.id

    query = (tbl.id > 0) & (tbl.unidad_organica_id == C.unidad.id)

    # permisos
    puede_crear = auth.has_membership(role=myconf.take('roles.admin'))
    puede_borrar = auth.has_membership(role=myconf.take('roles.admin'))
    puede_editar = auth.has_membership(role=myconf.take('roles.admin'))
    text_length = {'turma.carrera_id': 100}

    C.grid = grid_simple(query,
                         editable=puede_editar,
                         deletable=puede_borrar,
                         create=puede_crear,
                         maxtextlength=text_length,
                         args=request.args[:1])

    return dict(C=C)
Ejemplo n.º 8
0
def propinas():
    """Muestra el listado de los pagos realizados"""
    C = Storage()
    C.evento = db.evento(request.args(0))
    C.persona = db.persona(request.args(1))
    C.ano = db.ano_academico(C.evento.ano_academico_id)
    C.unidad = db.unidad_organica(C.ano.unidad_organica_id)
    C.escuela = db.escuela(C.unidad.escuela_id)

    concepto = db(
        db.tipo_pago.nombre == "PROPINA"
    ).select().first()
    assert concepto != None

    C.titulo = T("Registro de Propinas")

    query  = (db.propina.id > 0)
    query &= (db.propina.persona_id == C.persona.id)
    query &= (db.propina.ano_academico_id == C.ano.id)

    # configurar campos
    db.propina.id.readable = False
    # db.propina.pago_id.readable = True

    C.grid = grid_simple(query,
        create=False,
        history=False,
        details=False,
        searchable=False,
        paginate=13,
        csv=False,
        args=request.args[:2],
        formname="propinas"
    )

    return dict(C=C)
Ejemplo n.º 9
0
def index():
    """UI evento de matricua"""
    C = Storage()
    C.evento = db.evento(request.args(0))
    C.ano = db.ano_academico(C.evento.ano_academico_id)
    C.unidad = db.unidad_organica(C.ano.unidad_organica_id)
    C.escuela = db.escuela(C.unidad.escuela_id)

    # breadcumbs
    u_link = Accion(C.unidad.abreviatura or C.unidad.nombre,
                    URL('unidad', 'index', args=[C.unidad.id]),
                    True)  # siempre dentro de esta funcion
    menu_migas.append(u_link)
    a_links = Accion(C.ano.nombre,
                     URL('unidad', 'index', args=[C.unidad.id]),
                     True)
    menu_migas.append(a_links)
    e_link = Accion(C.evento.nombre,
                    URL('index', args=[C.evento.id]),
                    True)
    menu_migas.append(e_link)
    menu_migas.append(T("Candidatos admitidos"))

    con_pago = db.tipo_pago(nombre="MATRÍCULA E CONFIRMAÇÃO DE MATRÍCULA")
    if con_pago is None:
        raise HTTP(404)

    C.titulo = T("Candidatos")

    # configuración del grid
    tbl = db.candidatura

    query = (tbl.estudiante_id == db.estudiante.id)
    query &= (tbl.ano_academico_id == C.ano.id)
    query &= (tbl.estado_candidatura == ADMITIDO)
    query &= (db.estudiante.persona_id == db.persona.id)
    query &= (db.estudiante.unidad_organica_id == C.unidad.id)
    q2 = (tbl.estudiante_id == db.estudiante.id)
    q2 &= (tbl.ano_academico_id == C.ano.id)
    q2 &= (tbl.estado_candidatura == ADMITIDO)
    q2 &= (db.estudiante.persona_id == db.persona.id)
    q2 &= (db.estudiante.unidad_organica_id == C.unidad.id)
    q2 &= (db.matricula.estudiante_id == tbl.estudiante_id)
    q2 &= (db.matricula.estado_uo.belongs([MATRICULADO,
                                           MATRICULADO_CON_DEUDAS]))
    q2 = [a.estudiante_id for a in db(q2).select(tbl.estudiante_id, distinct=True)]
    query &= (~tbl.estudiante_id.belongs(q2))
    campos = [tbl.numero_inscripcion,
              db.persona.id,
              db.persona.numero_identidad,
              db.persona.nombre_completo,
              db.estudiante.id]

    for f in tbl:
        f.readable = False
    for f in db.persona:
        f.readable = False
    for f in db.estudiante:
        f.readable = False
    tbl.numero_inscripcion.readable = True
    db.persona.numero_identidad.readable = True
    db.persona.nombre_completo.readable = True
    tbl.numero_inscripcion.label = T("#INS")
    db.persona.numero_identidad.label = T("#IDENT")
    db.persona.nombre_completo.label = T("Nombre")
    text_lengths = {'persona.nombre_completo': 45}

    admin_o_cobrador = auth.has_membership(role=myconf.take('roles.admin')) or \
                       auth.has_membership(role=myconf.take('roles.cobrador_matricula'))
    adm_co_admdoc = auth.has_membership(role=myconf.take('roles.admin'))
    adm_co_admdoc |= auth.has_membership(role=myconf.take('roles.confirmador_matricula'))
    adm_co_admdoc |= auth.has_membership(role=myconf.take('roles.admdocente'))
    ev_activo = esta_activo(C.evento)

    def _enlaces(row):
        co = CAT()
        mat = db.matricula(ano_academico_id=C.ano.id,
                           estudiante_id=row.estudiante.id)
        # buscar un pago para la persona

        if mat is None:
            # si no ha pagado poner enlace para pagar
            pago_link = URL('pago', args=[C.evento.id, row.persona.id])
            puede_pagar = admin_o_cobrador

            puede_pagar &= ev_activo
            co.append(Accion(CAT(SPAN('', _class='glyphicon glyphicon-hand-up'),
                                 ' ',
                                 T("Falta de pago")),
                             pago_link,
                             puede_pagar,
                             _class="btn btn-default btn-sm",
                             _title=T("Pago confirmación de matricula")))
        elif mat.estado_uo == SIN_MATRICULAR:
            # poner enlace para confirmación de matricula
            c_link = URL('matricular', args=[C.evento.id, row.persona.id])
            puede_confirmar = adm_co_admdoc

            puede_confirmar &= ev_activo
            co.append(Accion(CAT(SPAN('', _class='glyphicon glyphicon-hand-up'),
                                 ' ',
                                 T("Confirmar")),
                             c_link,
                             puede_confirmar,
                             _class="btn btn-default btn-sm",
                             _title=T("Confirmación de matricula")))

        return co
    enlaces = [dict(header='', body=_enlaces)]

    C.grid = grid_simple(query,
                         create=False,
                         field_id=db.persona.id,
                         searchable=True,
                         fields=campos,
                         links=enlaces,
                         paginate=20,
                         maxtextlengths=text_lengths,
                         args=request.args[:1])

    return dict(C=C)
Ejemplo n.º 10
0
def matricular():
    C = Storage()
    C.evento = db.evento(request.args(0))
    C.ano = db.ano_academico(C.evento.ano_academico_id)
    C.unidad = db.unidad_organica(C.ano.unidad_organica_id)
    C.escuela = db.escuela(C.unidad.escuela_id)
    C.persona = db.persona(request.args(1))
    C.estudiante = db.estudiante(persona_id=C.persona.id)
    C.candidatura = db.candidatura(estudiante_id=C.estudiante.id,
        ano_academico_id=C.ano.id)
    matricula = db.matricula(estudiante_id=C.estudiante.id,
                       ano_academico_id=C.ano.id)

    if C.persona is None:
        raise HTTP(404)

    # breadcumbs
    u_link = Accion(C.unidad.abreviatura or C.unidad.nombre,
                    URL('unidad', 'index', args=[C.unidad.id]),
                    True)  # siempre dentro de esta funcion
    menu_migas.append(u_link)
    a_links = Accion(C.ano.nombre,
                     URL('unidad', 'index', args=[C.unidad.id]),
                     True)
    menu_migas.append(a_links)
    e_link = Accion(C.evento.nombre,
                    URL('index', args=[C.evento.id]),
                    True)
    menu_migas.append(e_link)
    menu_migas.append(T("MATRICULA"))

    # inicializar el proceso
    # -- cancelar
    mi_vars = Storage(request.vars)  # make a copy
    mi_vars._formulario_matricula = 1
    cancelar = URL(c=request.controller, f=request.function,
                   args=request.args, vars=mi_vars)
    back = URL('index', args=[C.evento.id])
    proximo = URL(c=request.controller,
               f=request.function,
               args=request.args,
               vars=request.vars)

    if request.vars._formulario_matricula:
        session.m3jd = None
        redirect(back)

    if session.m3jd is None:
        session.m3jd = Storage(dict(step=0))
        session.m3jd.persona = Storage()
        session.m3jd.estudiante = Storage()
        session.m3jd.matricula = Storage()
    data = session.m3jd
    step = data.step

    # ------------------------------------------------- PERSONA

    if step == 0:
        # datos personales
        fld_nombre = db.persona.get("nombre")
        fld_apellido1 = db.persona.get("apellido1")
        fld_apellido2 = db.persona.get("apellido2")
        fld_fecha_nacimiento = db.persona.get("fecha_nacimiento")
        fld_genero = db.persona.get("genero")
        fld_padre = db.persona.get("nombre_padre")
        fld_madre = db.persona.get("nombre_madre")
        fld_estado_civil = db.persona.get("estado_civil")
        fld_estado_politico = db.persona.get("estado_politico")
        fld_situacion_militar = db.persona.get("situacion_militar")
        fld_pais_origen = db.persona.get("pais_origen")

        fld_nombre.requires = [IS_NOT_EMPTY(), IS_UPPER()]
        fld_apellido1.requires = IS_UPPER()
        fld_apellido2.requires = [IS_NOT_EMPTY(), IS_UPPER()]
        hoy = datetime.date.today()
        _15anos = datetime.timedelta(days=(15 * 365))
        fld_fecha_nacimiento.requires = [IS_DATE_LT(maximo=hoy - _15anos),
                                         IS_NOT_EMPTY()]
        fld_padre.requires = [IS_NOT_EMPTY(), IS_UPPER()]
        fld_madre.requires = [IS_NOT_EMPTY(), IS_UPPER()]
        fld_pais_origen.requires = IS_IN_DB(db, "pais.id",
                                            "%(nombre)s",
                                            zero=T("(ESCOGER UNO)"))

        form = SQLFORM.factory(fld_nombre,
            fld_apellido1,
            fld_apellido2,
            fld_fecha_nacimiento,
            fld_genero,
            fld_padre, fld_madre,
            fld_estado_civil,
            fld_estado_politico,
            fld_situacion_militar,
            fld_pais_origen,
            record=C.persona,
            showid=False,
            table_name="persona",
            submit_button=T("Next"),
            )
        form.add_button("Cancel", cancelar)
        C.grid = form
        C.titulo = T("Datos personales")
        if form.process().accepted:
            session.m3jd.step = 1
            # en form_crear_persona.valores tenemos los datos validados
            session.m3jd.persona.update(db.persona._filter_fields(form.vars))
            C.persona.update_record(**session.m3jd.persona)
            redirect(proximo)
        return dict(C=C)

    if step == 1:
        # ORIGEN
        # Si el país de origen es ANGOLA, se puede preguntar por el lugar
        # de nacimiento.
        origen = db.pais(C.persona.pais_origen)
        campos = list()
        if origen.codigo == pais_model.ANGOLA:
            s = db(db.comuna.id > 0 and db.municipio.id == db.comuna.municipio_id)
            comunas = [(r.comuna.id, "{0} / {1}".format(r.comuna.nombre, r.municipio.nombre)) \
                for r in s.select(orderby=db.comuna.nombre)]
            fld_lugar_nacimiento = db.persona.get("lugar_nacimiento")
            fld_lugar_nacimiento.requires = IS_IN_SET(comunas, zero=T("(ESCOGER UNO)"))
            # -- arreglo para la representasión de las comunas.
            campos.append(fld_lugar_nacimiento)
        else:
            data.persona.lugar_nacimiento = None
            # no debe tener lugar de nacimiento
            C.persona.update_record(lugar_nacimiento=None)
            fld_tiene_nacionalidad = Field('tiene_nacionalidad',
                                           'boolean',
                                           default=True)
            fld_tiene_nacionalidad.label = T("¿Posee nacionalidad angolana?")
            campos.append(fld_tiene_nacionalidad)
        form = SQLFORM.factory(*campos,
                               table_name="persona",
                               submit_button=T("Next"))
        form.vars.update(C.persona)
        form.add_button("Cancel", cancelar)
        C.grid = form
        C.titulo = T("Origen")
        if form.process().accepted:
            session.m3jd.persona.update(db.persona._filter_fields(form.vars))
            C.persona.update_record(**session.m3jd.persona)
            session.m3jd.step = 2
            redirect(proximo)
        return dict(C=C)

    if data.persona.lugar_nacimiento or data.persona.tiene_nacionalidad:
        # BILHETE DE IDENTIDADE
        session.m3jd.persona.tipo_documento_identidad_id = 1
    else:
        # PASAPORTE
        session.m3jd.persona.tipo_documento_identidad_id = 2

    if step == 2:
        # residencia 1
        campos = []
        fld_numero_identidad = db.persona.get("numero_identidad")
        fld_pais_residencia = db.persona.get("pais_residencia")
        fld_pais_residencia.requires = IS_IN_DB(db, "pais.id",
                                                "%(nombre)s",
                                                zero=None)
        if data.persona.tipo_documento_identidad_id == 1:
            fld_pais_residencia.default = 3
            fld_numero_identidad.label = T("Carnet de identidad")
        else:
            fld_pais_residencia.default = C.persona.pais_origen
            fld_numero_identidad.label = T("Número de pasaporte")
        fld_numero_identidad.requires = [IS_NOT_EMPTY(), IS_UPPER(),
            IS_NOT_IN_DB(db, "persona.numero_identidad")]
        campos.append(fld_numero_identidad)
        campos.append(fld_pais_residencia)
        form = SQLFORM.factory(*campos,
                               record=C.persona,
                               showid=False,
                               table_name="persona",
                               submit_button=T("Next"))
        form.add_button("Cancel", cancelar)
        C.grid = form
        C.titulo = T("Residencia 1/2")
        if form.process().accepted:
            session.m3jd.persona.update(db.persona._filter_fields(form.vars))
            C.persona.update_record(**session.m3jd.persona)
            session.m3jd.step = 3
            redirect(proximo)
        return dict(C=C)

    if step == 3:
        # residencia 2
        campos = []
        fld_direccion = db.persona.get("direccion")
        pais_residencia = db.pais(C.persona.pais_residencia)
        if pais_residencia.codigo == pais_model.ANGOLA:
            fld_comuna = db.persona.get("dir_comuna_id")
            fld_comuna.label = T("Localidad")
            s = db((db.comuna.id > 0) & (db.municipio.id == db.comuna.municipio_id))
            comunas = [(r.comuna.id, "{0} / {1}".format(r.comuna.nombre, r.municipio.nombre)) \
                for r in s.select(orderby=db.comuna.nombre)]
            fld_comuna.requires = IS_IN_SET(comunas, zero=T("(ESCOGER UNO)"))
            campos.append(fld_comuna)
        campos.append(fld_direccion)
        form = SQLFORM.factory(*campos,
                               record=C.persona,
                               showid=False,
                               table_name="persona",
                               submit_button=T("Next"))
        form.add_button("Cancel", cancelar)
        C.grid = form
        C.titulo = T("Residencia 2/2")
        if form.process().accepted:
            session.m3jd.persona.update(db.persona._filter_fields(form.vars))
            C.persona.update_record(**session.m3jd.persona)
            session.m3jd.step = 4
            redirect(proximo)
        return dict(C=C)

    if step == 4:
        # datos de contacto
        campos = []
        fld_telefono = db.persona.get("telefono")
        fld_telefono2 = db.persona.get("telefono_alternativo")
        fld_email = db.persona.get("email")
        fld_email.requires = IS_EMPTY_OR(IS_EMAIL())
        campos.append(fld_telefono)
        campos.append(fld_telefono2)
        campos.append(fld_email)
        form = SQLFORM.factory(*campos,
                               record=C.persona,
                               showid=False,
                               table_name="persona",
                               submit_button=T("Next"))
        form.add_button("Cancel", cancelar)
        C.grid = form
        C.titulo = T("Contacto")
        if form.process().accepted:
            session.m3jd.persona.update(db.persona._filter_fields(form.vars))
            C.persona.update_record(**session.m3jd.persona)
            session.m3jd.step = 5
            redirect(proximo)
        return dict(C=C)

    # ------------------------------------------------- FIN PERSONA

    # ------------------------------------------------- ESTUDIANTE
    if step == 5:
        # -- recoger los datos del estudiante
        fld_habilitacion = db.estudiante.get('pro_habilitacion')
        fld_tipo_escuela = db.estudiante.get('pro_tipo_escuela')
        fld_pro_carrera = db.estudiante.get('pro_carrera')
        fld_pro_carrera.comment = T('''
            Nombre de la carrera que concluyó en la enseñanza previa
        ''')
        fld_pro_ano = db.estudiante.get('pro_ano')
        fld_pro_ano.comment = T('''
            Año en que se gradúo en la enseñanza media
        ''')
        fld_pro_ano.requires = IS_IN_SET(range(1950,
                                               datetime.date.today().year + 1),
                                         zero=None)
        fld_pro_ano.default = datetime.date.today().year - 1
        fld_tipo_escuela.requires = IS_IN_DB(db,
                                             'tipo_escuela_media.id',
                                             "%(nombre)s",
                                             zero=T("(ESCOGER UNO)"))

        form = SQLFORM.factory(fld_habilitacion,
                                 fld_tipo_escuela,
                                 fld_pro_carrera,
                                 fld_pro_ano,
                                 record=C.estudiante,
                                 showid=False,
                                 table_name="estudiante",
                                 submit_button=T("Next"))
        form.add_button("Cancel", cancelar)
        C.grid = form
        C.titulo = T("Procedencia 1/2")
        if form.process().accepted:
            session.m3jd.step = 6
            session.m3jd.estudiante.update(db.estudiante._filter_fields(form.vars))
            C.estudiante.update_record(**session.m3jd.estudiante)
            redirect(proximo)

        return dict(C=C)

    if step == 6:
        # --segunda parte de los datos de procedencia
        C.titulo = T("Procedencia 2/2")

        # -- configurar campos
        campos = []
        tipo_escuela_id = C.estudiante.pro_tipo_escuela
        tipo_escuela = db.tipo_escuela_media(tipo_escuela_id)
        if tipo_escuela.uuid != "a57d6b2b-8f0e-4962-a2a6-95f5c82e015d":
            fld_pro_escuela = db.estudiante.get("pro_escuela_id")
            esc_set = (db.escuela_media.id > 0)
            esc_set &= (db.escuela_media.tipo_escuela_media_id == tipo_escuela_id)
            fld_pro_escuela.requires = IS_IN_DB(db(esc_set),
                                                db.escuela_media.id,
                                                '%(nombre)s',
                                                zero=None)
            campos.append(fld_pro_escuela)
        fld_pro_media = db.estudiante.get("pro_media")
        campos.append(fld_pro_media)
        fld_es_trab = Field('es_trab', 'string', length=1, default='Não')
        fld_es_trab.label = T('¿Es trabajador?')
        fld_es_trab.requires = IS_IN_SET(['Sim', 'Não'], zero=None)
        campos.append(fld_es_trab)

        form = SQLFORM.factory(*campos,
                                 table_name="estudiante",
                                 submit_button=T("Next"))
        form.add_button("Cancel", cancelar)
        form.vars.update(C.estudiante)
        form.vars.es_trab = 'Sim' if C.estudiante.es_trabajador else 'Não'
        C.grid = form

        if form.process().accepted:
            vals = form.vars
            vals.es_trabajador = False if vals.es_trab == 'Não' else True
            session.m3jd.step = 7
            session.m3jd.estudiante.update(db.estudiante._filter_fields(form.vars))
            C.estudiante.update_record(**session.m3jd.estudiante)
            redirect(proximo)
        return dict(C=C)

    if step == 7:
        if C.estudiante.es_trabajador:
            # --pedir los datos del centro de trabajo
            C.titulo = T("Información laboral 1/2")
            fld_trab_profesion = db.estudiante.get('trab_profesion')
            fld_trab_profesion.requires = [IS_NOT_EMPTY(), IS_UPPER()]
            fld_trab_nombre = db.estudiante.get("trab_nombre")
            fld_trab_nombre.requires = [IS_NOT_EMPTY(), IS_UPPER()]
            fld_trab_provincia = db.estudiante.get("trab_provincia")
            fld_trab_provincia.label = T("Provincia")
            fld_trab_provincia.comment = T('''
                Seleccione la provincia donde se desempeña el trabajo
            ''')
            fld_trab_provincia.requires = IS_IN_DB(db, db.provincia.id,
                                                   "%(nombre)s",
                                                   zero=T("(ESCOGER UNO)"))
            fld_trab_tipo_instituto = db.estudiante.get('trab_tipo_instituto')
            from agiscore.db.estudiante import TRAB_TIPO_INSTITUTO
            fld_trab_tipo_instituto.requires = IS_IN_SET(TRAB_TIPO_INSTITUTO,
                                                         zero=None)
            fld_trab_con_titulo = Field('con_titulo', 'string', length=3,
                                        default='Não')
            fld_trab_con_titulo.label = T("¿Tiene salida con título?")
            fld_trab_con_titulo.requires = IS_IN_SET(['Sim', 'Não'], zero=None)

            form = SQLFORM.factory(fld_trab_profesion,
                                     fld_trab_nombre,
                                     fld_trab_tipo_instituto,
                                     fld_trab_con_titulo,
                                     fld_trab_provincia,
                                     table_name="estudiante",
                                     submit_button=T("Next"))
            form.add_button("Cancel", cancelar)
            form.vars.update(C.estudiante)
            form.vars.con_titulo = 'Sim' if C.estudiante.trab_titulo else 'Não'
            C.grid = form

            if form.process().accepted:
                session.m3jd.estudiante.update(db.estudiante._filter_fields(form.vars))
                C.estudiante.update_record(**session.m3jd.estudiante)
                if form.vars.con_titulo == 'Sim':
                    session.m3jd.step = 8
                else:
                    session.m3jd.step = 9
                redirect(proximo)

            return dict(C=C)
        else:
            # -- sino es trabajador seguir al proximo paso
            session.m3jd.step = 9
            redirect(proximo)

    if step == 8:
        # -- tipo de titulo que da el trabajo
        C.titulo = T("Información laboral 2/2")

        fld_trab_titulo = db.estudiante.get('trab_titulo')
        from agiscore.db.estudiante import TRAB_TITULO_VALUES
        fld_trab_titulo.requires = IS_IN_SET(TRAB_TITULO_VALUES, zero=None)

        form = SQLFORM.factory(fld_trab_titulo,
                               record=C.estudiante,
                               showid=False,
                               table_name="estudiante",
                               submit_button=T("Next"))
        form.add_button("Cancel", cancelar)
        C.grid = form

        if form.process().accepted:
            session.m3jd.step = 9
            session.m3jd.estudiante.update(db.estudiante._filter_fields(form.vars))
            C.estudiante.update_record(**session.m3jd.estudiante)
            redirect(proximo)

        return dict(C=C)

    if step == 9:
        # -- institucionales
        C.titulo = T("Institucionales")

        fld_modalidad = db.estudiante.get("modalidad")
        fld_forma_acceso = db.estudiante.get("forma_acceso")
        fld_forma_acceso.default = '01'
        fld_forma_acceso.writable = False
        fld_ano_ies = db.estudiante.get("ano_ies")
        fld_ano_es = db.estudiante.get("ano_es")
        fld_es_internado = db.estudiante.get("es_internado")
        fld_documentos = db.estudiante.get("documentos")
        fld_discapacidades = db.estudiante.get("discapacidades")
        fld_bolsa_estudio = db.estudiante.get("bolsa_estudio")

#         fld_ano_ies.requires = IS_IN_SET(range(1950,
#                                                datetime.date.today().year),
#                                          zero=None)
#         fld_ano_es.requires = IS_IN_SET(range(1950,
#                                                datetime.date.today().year),
#                                          zero=None)
        fld_ano_es.default = int(C.ano.nombre)
        fld_ano_ies.default = int(C.ano.nombre)
        fld_ano_es.writable = False
        fld_ano_ies.writable = False

        form = SQLFORM.factory(fld_modalidad,
                                 fld_forma_acceso,
                                 fld_ano_ies,
                                 fld_ano_es,
                                 fld_es_internado,
                                 fld_documentos,
                                 fld_discapacidades,
                                 fld_bolsa_estudio,
                                 record=C.estudiante,
                                 showid=False,
                                 table_name="estudiante",
                                 submit_button=T("Next"))
        form.add_button("Cancel", cancelar)
        C.grid = form

        if form.process().accepted:
            session.m3jd.step = 10
            session.m3jd.estudiante.update(db.estudiante._filter_fields(form.vars))
            C.estudiante.update_record(**session.m3jd.estudiante)
            redirect(proximo)

        return dict(C=C)
    # ------------------------------------------------- FIN ESTUDIANTE

    # ------------------------------------------------- MATRICULA
    if step == 10:
        C.titulo = T("Matricula 1/5")

        campos = []
        fld_carrera_id = db.matricula.get("carrera_id")
        fld_carrera_id.writable = False
        campos.append(fld_carrera_id)
        fld_regimen = db.matricula.get("regimen_id")
        fld_regimen.writable = False
        campos.append(fld_regimen)
        fld_nivel = db.matricula.get("nivel")
        fld_nivel.writable = False
#         q_nivel = (db.nivel_academico.id > 1)
#         q_nivel &= (db.nivel_academico.unidad_organica_id == C.unidad.id)
#         from agiscore.db.nivel_academico import nivel_represent
#         n_set = [(r.id, nivel_represent(r.nivel, r)) for r in db(q_nivel).select()]
#         fld_nivel.requires = IS_IN_SET(n_set, zero=None)
        campos.append(fld_nivel)
        fld_situacion = db.matricula.get("situacion")
        fld_situacion.writable = False
        campos.append(fld_situacion)

        form = SQLFORM.factory(*campos,
                               showid=False,
                               record=matricula,
                               table_name="matricula",
                               submit_button=T("Next"))

        form.add_button("Cancel", cancelar)
        C.grid = form

        if form.process().accepted:
            session.m3jd.step = 11
            session.m3jd.matricula.update(db.matricula._filter_fields(form.vars))
            matricula.update_record(**session.m3jd.matricula)
            redirect(proximo)

        return dict(C=C)

    if step == 11:
        C.titulo = T("Matricula 2/5")

        campos = []
        fld_turma = db.matricula.get("turma_id")
        q_turmas  = (db.turma.carrera_id == matricula.carrera_id)
        q_turmas &= (db.turma.regimen_id == matricula.regimen_id)
        q_turmas &= (db.turma.nivel_id == matricula.nivel)
        q_turmas &= (db.turma.unidad_organica_id == C.unidad.id)
        fld_turma.requires = IS_IN_DB(db(q_turmas),
                                      db.turma.id,
                                      "%(nombre)s",
                                      zero=T('(ESCOGER UNO)'))
        campos.append(fld_turma)

        fld_plan_id = db.matricula.get("plan_id")
        q_planes = (db.plan_curricular.carrera_id == matricula.carrera_id)
        fld_plan_id.requires = IS_IN_DB(db(q_planes),
                                        db.plan_curricular.id,
                                        "%(nombre)s",
                                        zero=T('(ESCOGER UNO)'))
        campos.append(fld_plan_id)

        form = SQLFORM.factory(*campos,
                               showid=False,
                               record=matricula,
                               table_name="matricula",
                               submit_button=T("Next"))

        form.add_button("Cancel", cancelar)
        C.grid = form

        if form.process().accepted:
            session.m3jd.step = 12
            session.m3jd.matricula.update(db.matricula._filter_fields(form.vars))
            matricula.update_record(**session.m3jd.matricula)
            redirect(proximo)

        return dict(C=C)

    TERM = ['1', '2', '5', '11', '12']
    if matricula.situacion in TERM:
        step = 20

    if step == 20:
        # terminar la matricula
        no_meca = ""
        no_meca += C.unidad.codigo_escuela
        c_e = db.carrera_escuela(db.carrera_uo(matricula.carrera_id).carrera_escuela_id)
        no_meca += c_e.codigo
        no_meca += C.ano.nombre[2:]
        no_meca += "1" if C.persona.genero == "M" else "2"
        query = (db.estudiante.id == db.matricula.estudiante_id)
        query &= (db.matricula.carrera_id == matricula.carrera_id)
        query &= (db.estudiante.unidad_organica_id == C.unidad.id)
        query &= (db.matricula.ano_academico_id == C.ano.id)
        query &= (db.matricula.situacion == '1')
        query &= (db.matricula.estado_uo == MATRICULADO)
        ultimo = db(query).select(db.estudiante.codigo, orderby=~db.estudiante.codigo).first()
        if ultimo is None:
            no_meca += "00001"
        else:
            ultimo = ultimo.codigo[-5:]
            ultimo = int(ultimo) + 1
            no_meca += str(ultimo).zfill(5)
        # buscar la NF del estudiante en los examenes de ingreso
        asignacion = db.asignacion_carrera(candidatura_id=C.candidatura.id)
        C.estudiante.update_record(codigo=no_meca,
            media_acceso=asignacion.media)
        matricula.update_record(estado_uo=MATRICULADO)
        session.m3jd = None
        redirect(back)
    # ------------------------------------------------- FIN MATRICULA
    return dict(C=C)
Ejemplo n.º 11
0
def pago():
    C = Storage()
    C.evento = db.evento(request.args(0))
    C.ano = db.ano_academico(C.evento.ano_academico_id)
    C.unidad = db.unidad_organica(C.ano.unidad_organica_id)
    C.escuela = db.escuela(C.unidad.escuela_id)
    C.persona = db.persona(request.args(1))
    C.estudiante = db.estudiante(persona_id=C.persona.id)

    if C.persona is None:
        raise HTTP(404)

    # buscar un tipo de pago que coincida en nombre con el tipo de evento
    concepto = db(
        db.tipo_pago.nombre == "MATRÍCULA E CONFIRMAÇÃO DE MATRÍCULA"
    ).select().first()
    if not concepto:
        raise HTTP(404)

    # breadcumbs
    u_link = Accion(C.unidad.abreviatura or C.unidad.nombre,
                    URL('unidad', 'index', args=[C.unidad.id]),
                    True)  # siempre dentro de esta funcion
    menu_migas.append(u_link)
    a_links = Accion(C.ano.nombre,
                     URL('unidad', 'index', args=[C.unidad.id]),
                     True)
    menu_migas.append(a_links)
    e_link = Accion(C.evento.nombre,
                    URL('index', args=[C.evento.id]),
                    True)
    menu_migas.append(e_link)
    menu_migas.append(T("Pago") + " de {}".format(concepto.nombre))

    campos = list()
    fld_cantidad = db.pago.get("cantidad")
    fld_cantidad.requires.append(
        IS_FLOAT_IN_RANGE(concepto.cantidad,
                          9999999999.99,
                          error_message=T("Debe ser mayor que {0}".format(concepto.cantidad))))
    campos.append(db.pago.get("forma_pago"))
    campos.append(fld_cantidad)
    campos.append(db.pago.get("numero_transaccion"))
    campos.append(db.pago.get("transaccion"))
    campos.append(db.pago.get("codigo_recivo"))
    campos.append(db.pago.get("fecha_recivo"))
    back = URL('index', args=[C.evento.id])
    manejo = SQLFORM.factory(*campos, submit_button=T('Guardar'))
    manejo.add_button(T("Cancel"), back)
    C.form = manejo
    C.titulo = "{} {} - {}".format(T("Pago"),
                         concepto.nombre,
                         C.persona.nombre_completo)
    if manejo.process().accepted:
        valores = manejo.vars
        valores.tipo_pago_id = concepto.id
        valores.persona_id = C.persona.id
        valores.evento_id = C.evento.id
        db.pago.insert(**db.pago._filter_fields(valores))

        # crear la matricula con los valores por defecto para nuevo ingreso
        mat_vals = Storage()
        mat_vals.estudiante_id = C.estudiante.id
        mat_vals.ano_academico_id = C.ano.id
        from agiscore.db.nivel_academico import _1RO
        nv = db.nivel_academico(nivel=_1RO, unidad_organica_id=C.unidad.id)
        mat_vals.nivel = nv.id
        mat_vals.situacion = '1'
        mat_vals.estado_uo = SIN_MATRICULAR
        cand = db.candidatura(estudiante_id=C.estudiante.id,
                              ano_academico_id=C.ano.id)
        mat_vals.regimen_id = cand.regimen_id
        a_carr = db.asignacion_carrera(candidatura_id=cand.id)
        mat_vals.carrera_id = a_carr.carrera_id
        db.matricula.insert(**db.matricula._filter_fields(mat_vals))

        session.flash = T('Pago registrado')
        redirect(back)

    return dict(C=C)
Ejemplo n.º 12
0
def index():
    """Configuración de las aulas"""
    C = Storage()
    C.examen = db.examen(int(request.args(0)))
    C.asignatura = C.examen.asignatura_id
    C.evento = db.evento(C.examen.evento_id)
    C.ano = db.ano_academico(C.evento.ano_academico_id)
    C.unidad = db.unidad_organica(C.ano.unidad_organica_id)
    C.escuela = db.escuela(C.unidad.escuela_id)

    # breadcumbs
    u_link = Accion(C.unidad.abreviatura or C.unidad.nombre,
                    URL('unidad', 'index', args=[C.unidad.id]),
                    True)  # siempre dentro de esta funcion
    menu_migas.append(u_link)
    a_links = Accion(T('Años académicos'),
                     URL('unidad', 'index', args=[C.unidad.id]),
                     True)
    menu_migas.append(a_links)
    e_link = Accion(C.evento.nombre,
                    URL('evento','index', args=[C.evento.id]),
                    True)
    menu_migas.append(e_link)
    menu_migas.append(db.examen._format(C.examen))
    menu_migas.append(T('Asignación de aulas'))
    
    # -- permisos
    puede_borrar = auth.has_membership(role=myconf.take('roles.admin'))
    puede_crear = auth.has_membership(role=myconf.take('roles.admin'))
    puede_editar = auth.has_membership(role=myconf.take('roles.admin'))
    
    # -- configurar grid
    tbl = db.examen_aula
    query = (tbl.id > 0) & (tbl.examen_id == C.examen.id)
    
    if 'new' in request.args:
        tbl.examen_id.default = C.examen.id
        tbl.examen_id.writable = False
        
        estan_set = (db.aula.id > 0) & (db.aula.id == db.examen_aula.aula_id)
        estan_set &= (db.examen_aula.examen_id == C.examen.id)
        estan = [a.id for a in db(estan_set).select(db.aula.id)]
        a_set  = (db.aula.id > 0) & (db.aula.disponible == True)
        a_set &= (~db.aula.id.belongs(estan))
        posibles = IS_IN_DB(db(a_set), db.aula.id, '%(nombre)s', zero=None)
        db.examen_aula.aula_id.requires = posibles
    
    C.titulo = "{}: {}".format(T("Aulas para el exámen"),
                               db.examen._format(C.examen))
    # -- configurar los campos
    tbl.id.readable = False
    tbl.examen_id.readable = False
    
    # -- datos de capacidad
    from agiscore.db.examen import obtener_candidaturas, obtener_aulas
    from agiscore.db.aula import capacidad_total
    C.a_examinar = len(obtener_candidaturas(C.examen.id))
    C.a_capacidad = capacidad_total(obtener_aulas(C.examen.id))
    
    C.grid = grid_simple(query,
                         create=puede_crear,
                         editable=puede_editar,
                         deletable=puede_borrar,
                         searchable=False,
                         history=False,
                         args=request.args[:1])
    
    return dict(C=C)
Ejemplo n.º 13
0
def distribucion():
    '''Distribución de estudiantes por aulas'''
    C = Storage()
    C.examen = db.examen(int(request.args(0)))
    C.asignatura = C.examen.asignatura_id
    C.evento = db.evento(C.examen.evento_id)
    C.ano = db.ano_academico(C.evento.ano_academico_id)
    C.unidad = db.unidad_organica(C.ano.unidad_organica_id)
    C.escuela = db.escuela(C.unidad.escuela_id)

    # breadcumbs
    u_link = Accion(C.unidad.abreviatura or C.unidad.nombre,
                    URL('unidad', 'index', args=[C.unidad.id]),
                    True)  # siempre dentro de esta funcion
    menu_migas.append(u_link)
    a_links = Accion(T('Años académicos'),
                     URL('unidad', 'index', args=[C.unidad.id]),
                     True)
    menu_migas.append(a_links)
    e_link = Accion(C.evento.nombre,
                    URL('evento','index', args=[C.evento.id]),
                    True)
    menu_migas.append(e_link)
    menu_migas.append(db.examen._format(C.examen))
    menu_migas.append(T('Distribución por aulas'))
    
    C.titulo = "{} - {}".format(T("Distribución de los estudiantes por aulas"),
                               db.examen._format(C.examen))
    
    from agiscore.db.examen_aula_estudiante import distribuir_estudiantes
    
    puede_distribuir  = auth.has_membership(role=myconf.take('roles.oexamen'))
    puede_distribuir |= auth.has_membership(role=myconf.take('roles.admin')) 
    # distribuir a los estudiantes por las aulas que tenemos definidas
    C.distribuir_link = Accion(CAT(SPAN('', _class='glyphicon glyphicon-hand-up'),
                         ' ',
                         T("Distribuir aulas")),
                     URL('distribucion',
                         args=[C.examen.id],
                         vars={'_distribuir': '1'}),
                     puede_distribuir,
                     _class="btn btn-default")
    if request.vars._distribuir:
        distribuir_estudiantes(C.examen.id)
        redirect(URL('distribucion', args=[C.examen.id]))
    
    cantidad = db(db.examen_aula_estudiante.examen_id == C.examen.id).count()
    if cantidad > 0:
        # --configurar el grid
        tbl = db.examen_aula_estudiante
        query = ((db.examen_aula_estudiante.examen_id == C.examen.id) & 
            (db.estudiante.id == db.examen_aula_estudiante.estudiante_id) & 
            (db.persona.id == db.estudiante.persona_id) & 
            (db.candidatura.estudiante_id == \
                db.examen_aula_estudiante.estudiante_id))
        
        # -- conf de los campos
        for fd in db.persona:
            fd.readable = False
        db.persona.nombre_completo.readable = True
        db.persona.numero_identidad.readable = True
        db.persona.numero_identidad.label = T("#IDENT")
        for fd in tbl:
            fd.readable = False
        tbl.aula_id.readable = True
        for fd in db.estudiante:
            fd.readable = False
        for f in db.candidatura:
            f.readable = False
        db.persona.nombre_completo.label = T('Nombre')
        campos=[db.persona.numero_identidad,
                db.persona.nombre_completo,
                tbl.aula_id]
        
        text_lengths={'persona.nombre_completo': 50,
                      'persona.numero_identidad': 15}
        exportadores = dict(xml=False, html=False, csv_with_hidden_cols=False,
                            csv=False, tsv_with_hidden_cols=False, tsv=False,
                            json=False, PDF=(tools.ExporterPDF, 'PDF'),
#                             XLS=(candidatura.EAEXLS, 'XLS')
                           )
        
        if request.vars._export_type:
            if C.examen.fecha is None or C.examen.inicio is None or C.examen.fin is None:
                myvars = Storage(request.vars)
                del myvars["_export_type"]
                session.flash = T('No se han definido los parámetros del exámen')
                redirect(URL('distribucion', vars=myvars, args=[C.examen.id]))
            response.context = C
        
        C.grid = grid_simple(query,
                             orderby=[db.persona.nombre_completo],
                             create=False,
                             maxtextlengths=text_lengths,
                             fields=campos,
                             csv=True,
                             history=False,
                             exportclasses=exportadores,
                             searchable=True,
                             args=request.args[:1])
    else:
        # --poner un mensaje
        msg_t = T("¡Avizo!")
        msg = T('''
        No se han asignado aulas a este examen, las asignadas no son 
        suficiente o no se realizó la distrubución.
        ''')
        msg = CAT(P(msg),P(Accion(T('Configuración de aulas'),
                                  URL('index', args=[request.args(0)]),
                                  True,
                                  _class="btn btn-default alert-link")),
                  P(C.distribuir_link))
        C.grid = DIV(H4(msg_t), msg,_class="alert alert-danger",
                     _role="alert")
    
    return dict(C=C)
Ejemplo n.º 14
0
def codificacion():
    C = Storage()
    C.examen = db.examen(int(request.args(0)))
    C.asignatura = C.examen.asignatura_id
    C.evento = db.evento(C.examen.evento_id)
    C.ano = db.ano_academico(C.evento.ano_academico_id)
    C.unidad = db.unidad_organica(C.ano.unidad_organica_id)
    C.escuela = db.escuela(C.unidad.escuela_id)

    # breadcumbs
    u_link = Accion(C.unidad.abreviatura or C.unidad.nombre,
                    URL('unidad', 'index', args=[C.unidad.id]),
                    True)  # siempre dentro de esta funcion
    menu_migas.append(u_link)
    a_links = Accion(T('Años académicos'),
                     URL('unidad', 'index', args=[C.unidad.id]),
                     True)
    menu_migas.append(a_links)
    e_link = Accion(C.evento.nombre,
                    URL('evento','index', args=[C.evento.id]),
                    True)
    menu_migas.append(e_link)
    menu_migas.append(db.examen._format(C.examen))
    menu_migas.append(T('Codificación de los estudiantes'))
    
    # -- configuración del grid
    query = ((db.examen_aula_estudiante.examen_id == C.examen.id) & 
            (db.estudiante.id == db.examen_aula_estudiante.estudiante_id) & 
            (db.persona.id == db.estudiante.persona_id) & 
            (db.candidatura.estudiante_id == \
                db.examen_aula_estudiante.estudiante_id))
    
    exportadores = dict(xml=False, html=False, csv_with_hidden_cols=False,
        csv=False, tsv_with_hidden_cols=False, tsv=False, json=False,
        PDF=(tools.ExporterPDF, 'PDF'))
    
    text_lengths={'persona.nombre_completo': 50,
                  'persona.uuid': 100}
    
    # --conf campos
    for f in db.persona:
        f.readable = False
    db.persona.nombre_completo.readable = True
    db.persona.numero_identidad.readable = True
    db.persona.uuid.readable = True
    db.persona.uuid.label = 'UUID'
    for f in db.examen_aula_estudiante:
        f.readable = False
    db.examen_aula_estudiante.aula_id.readable = True
    for f in db.estudiante:
        f.readable = False
    for f in db.candidatura:
        f.readable = False
    campos=[db.persona.nombre_completo,
            db.persona.numero_identidad,
            db.persona.uuid,
            db.examen_aula_estudiante.aula_id]
    C.titulo = T('Codificación de los estudiantes')
    
    if request.vars._export_type:
        response.context = C
    
    C.grid = grid_simple(query,
                         fields=campos,
                         orderby=[db.persona.nombre_completo,
                                  db.examen_aula_estudiante.aula_id],
                         csv=True,
                         searchable=True,
                         create=False,
                         history=False,
                         maxtextlengths=text_lengths,
                         exportclasses=exportadores,
                         args=request.args[:1])
    
    return dict(C=C)
Ejemplo n.º 15
0
def notas_reporte():
    '''Reporte de las notas de los estudiantes para este examen'''
    C = Storage()
    C.examen = db.examen(int(request.args(0)))
    C.asignatura = C.examen.asignatura_id
    C.evento = db.evento(C.examen.evento_id)
    C.ano = db.ano_academico(C.evento.ano_academico_id)
    C.unidad = db.unidad_organica(C.ano.unidad_organica_id)
    C.escuela = db.escuela(C.unidad.escuela_id)

    # breadcumbs
    u_link = Accion(C.unidad.abreviatura or C.unidad.nombre,
                    URL('unidad', 'index', args=[C.unidad.id]),
                    True)  # siempre dentro de esta funcion
    menu_migas.append(u_link)
    a_links = Accion(T('Años académicos'),
                     URL('unidad', 'index', args=[C.unidad.id]),
                     True)
    menu_migas.append(a_links)
    e_link = Accion(C.evento.nombre,
                    URL('evento','index', args=[C.evento.id]),
                    True)
    menu_migas.append(e_link)
    menu_migas.append(T('Reporte de resultados'))

    C.titulo = "{} - {}".format(db.examen._format(C.examen), C.evento.nombre)
    from agiscore.db import nota as nota_model
    nota_model.crear_entradas(C.examen.id)
    
    query  = (db.nota.examen_id == C.examen.id)
    query &= (db.nota.estudiante_id == db.estudiante.id)
    query &= (db.estudiante.persona_id == db.persona.id)
    query &= (db.candidatura.estudiante_id == db.nota.estudiante_id)
    
    # preparar campos
    for f in db.nota:
        f.readable = False
    for f in db.persona:
        f.readable = False
    for f in db.estudiante:
        f.readable = False
    for f in db.candidatura:
        f.readable = False
    db.candidatura.numero_inscripcion.readable = True
    db.candidatura.numero_inscripcion.label = T('#INS')
    db.persona.nombre_completo.readable = True
    db.persona.nombre_completo.label = T("Nombre")
    db.nota.valor.readable = True
    db.nota.valor.label = T("Nota")
    
    campos = [db.candidatura.numero_inscripcion,
              db.persona.nombre_completo,
              db.nota.valor]
    text_lengths={'persona.nombre_completo': 50}
    exportadores = dict(xml=False, html=False, csv_with_hidden_cols=False,
        csv=False, tsv_with_hidden_cols=False, tsv=False, json=False,
        PDF=(tools.ExporterPDF, 'PDF'))
    
    if request.vars._export_type:
        response.context = C
    
    C.grid = grid_simple(query,
                         orderby=[db.persona.nombre_completo],
                         maxtextlengths=text_lengths,
                         exportclasses=exportadores,
                         csv=True,
                         fields=campos,
                         create=False,
                         editable=False,
                         deletable=False,
                         history=False,
                         args=request.args[:1])
    
    
    return dict(C=C)
Ejemplo n.º 16
0
def matriculados():
    """UI evento de época normal"""
    C = Storage()
    C.evento = db.evento(request.args(0))
    C.ano = db.ano_academico(C.evento.ano_academico_id)
    C.unidad = db.unidad_organica(C.ano.unidad_organica_id)
    C.escuela = db.escuela(C.unidad.escuela_id)

    # breadcumbs
    u_link = Accion(C.unidad.abreviatura or C.unidad.nombre,
                    URL('unidad', 'index', args=[C.unidad.id]),
                    True)  # siempre dentro de esta funcion
    menu_migas.append(u_link)
    a_links = Accion(C.ano.nombre,
                     URL('unidad', 'index', args=[C.unidad.id]),
                     True)
    menu_migas.append(a_links)
    e_link = Accion(C.evento.nombre,
                    URL('index', args=[C.evento.id]),
                    True)
    menu_migas.append(e_link)
    menu_migas.append(T("Matriculados"))

    C.titulo = T("Registro de estudiantes")

    # configuración del grid
    tbl = db.estudiante

    query = (tbl.persona_id == db.persona.id)
    query &= (tbl.unidad_organica_id == C.unidad.id)
    query &= (tbl.id == db.matricula.estudiante_id)
    query &= (db.matricula.ano_academico_id == C.ano.id)
    query &= (db.matricula.estado_uo.belongs(MATRICULADO,
                                              MATRICULADO_CON_DEUDAS))

    exportadores = dict(xml=False, html=False, csv_with_hidden_cols=False,
        csv=False, tsv_with_hidden_cols=False, tsv=False, json=False,
        PDF=(tools.ExporterPDF, 'PDF'))

    campos = [tbl.id,
              tbl.codigo,
              db.persona.id,
              db.persona.nombre_completo,
              db.matricula.estado_uo,
              db.matricula.regimen_id]
    for f in tbl:
        f.readable = False
    tbl.codigo.readable = True
    for f in db.persona:
        f.readable = False
    db.persona.nombre_completo.readable = True
    for f in db.matricula:
        f.readable = False
    db.matricula.estado_uo.readable = True
    db.matricula.regimen_id.readable = True
    db.matricula.carrera_id.readable = True
    db.matricula.turma_id.readable = True
    db.matricula.situacion.readable = True
    for f in db.turma:
        f.readable = False
    tbl.codigo.label = T("#MEC")
    db.persona.nombre_completo.label = T("Nombre")
    db.matricula.estado_uo.label = T("Estado")
    text_lengths = {'persona.nombre_completo': 45,
                    'matricula.estado_uo': 45}
    es_admin = auth.has_membership(role=myconf.take('roles.admin'))
    ev_activo = esta_activo(C.evento)

    r_regular_q  = (db.regimen_unidad_organica.regimen_id == db.regimen.id)
    r_regular_q &= (db.regimen.codigo=='1')
    r_regular_q &= (db.regimen_unidad_organica.unidad_organica_id == C.unidad.id)
    r_regular = db(r_regular_q).select(db.regimen_unidad_organica.id).first()
    def _enlaces(row):
        co = CAT()
        # buscar un pago para la persona

        editar_link = URL('editar', args=[C.evento.id, row.persona.id])
        puede_editar = es_admin

        puede_editar &= ev_activo
        co.append(Accion(CAT(SPAN('', _class='glyphicon glyphicon-hand-up'),
                            ' ',
                            T("Editar")),
                        editar_link,
                        puede_editar,
                        _class="btn btn-default btn-sm",
                        _title=T("Editar datos del estudiante")))
        puede_pagar = es_admin or auth.has_membership(role=myconf.take('roles.cobrador_propina'))
        puede_pagar &= ev_activo
        if row.matricula.regimen_id != r_regular.id:
            # los del regimen regular no pagan propina
            co.append(pago_link("enormal-content",
                row.persona.id,
                C.evento.id,
                activo=puede_pagar,
                T=T))

        return co
    enlaces = [dict(header='', body=_enlaces)]

    if request.vars._export_type:
        response.context = C

    C.grid = grid_simple(query,
                         create=False,
                         field_id=db.persona.id,
                         searchable=True,
                         fields=campos,
                         links=enlaces,
                         paginate=20,
                         maxtextlengths=text_lengths,
                         csv=True,
                         exportclasses=exportadores,
                         orderby=[db.persona.nombre_completo],
                         args=request.args[:1])

    return dict(C=C)