Python Categoria.all方法代码示例

# 需要导入模块: from msa.core.data.candidaturas import Categoria [as 别名]
# 或者: from msa.core.data.candidaturas.Categoria import all [as 别名]
    def completa(self, interna=None):
        """Determina si la seleccion es completa (candidatos en todas las
           categorias)."""
        if get_tipo_elec("interna") and interna is not None:
            categorias = Categoria.all()
            cat_usadas = []
            for categoria in categorias:
                has_cand = Candidato.one(cod_categoria=categoria.codigo,
                                         cod_interna=interna.codigo)
                if has_cand is not None:
                    cat_usadas.append(categoria)
            len_categoria = len(cat_usadas)

        else:
            len_categoria = len(Categoria.all())
        return len(self._candidatos) == len_categoria

# 需要导入模块: from msa.core.data.candidaturas import Categoria [as 别名]
# 或者: from msa.core.data.candidaturas.Categoria import all [as 别名]
    def validar_seleccion(self, seleccion):
        """Valida que la seleccion tiene una cantidad permitida de votos por
        categoria.

        Argumentos:
            seleccion -- un objeto de tipo seleccion
        """
        # a menos que digamos otra cosa la seleccion es valida
        selecciones_validas = True
        len_selec = 0
        categorias = Categoria.all()
        # voy a recorrer las categorias fijandome que la cantidad de votos
        # almacenados en el objeto seleccion es valida para cada una de ellas
        candidatos = seleccion.candidatos_elegidos()
        for categoria in categorias:
            len_selecciones_categoria = 0
            # sumo a la cantidad maxima de selecciones
            len_selec += int(categoria.max_selecciones)
            for candidato in candidatos:
                # si el candidato pertenece a la categoría sumo un voto para el
                # total de votos de la misma
                if candidato.cod_categoria == categoria.codigo:
                    len_selecciones_categoria += 1
            # si hay mas votos que la cantidad de selecciones maximas
            # permitidas salimos
            if len_selecciones_categoria > int(categoria.max_selecciones):
                selecciones_validas = False
                break

        return selecciones_validas and len_selec == len(candidatos)

# 需要导入模块: from msa.core.data.candidaturas import Categoria [as 别名]
# 或者: from msa.core.data.candidaturas.Categoria import all [as 别名]
 def _get_categorias(self, consulta_popular=False, todas=False):
     """Devuelve las categorias para esta mesa y para esta partido en caso
     de que sea una interna no PASO."""
     if not get_tipo_elec("interna"):
         filter = {"sorted": "posicion", "consulta_popular": consulta_popular}
         if not todas:
             filter["adhiere"] = None
         categorias = Categoria.many(**filter)
     else:
         candidatos = Candidato.many(cod_partido=self.agrupacion.codigo)
         cod_cats = set([candidato.categoria.codigo for candidato in candidatos])
         filter = {"sorted": "posicion", "consulta_popular": consulta_popular, "codigo__in": cod_cats}
         if not todas:
             filter["adhiere"] = None
         categorias = Categoria.all(**filter)
     return categorias

# 需要导入模块: from msa.core.data.candidaturas import Categoria [as 别名]
# 或者: from msa.core.data.candidaturas.Categoria import all [as 别名]
def get_estado_mesas(id_ubicacion, acta_desglosada=False):
    """
        Recibe un id_ubicación de un establecimiento y devuelve los datos
        en el formato del server.
        [id_planilla, estado, numero_mesa, sexo, codigo_ubicacion]
        @TODO: Ver actas desglosadas.
    """
    mesas = []
    for u in Ubicacion.many(clase='Mesa',
                            codigo__startswith=id_ubicacion + '.'):
        datos_mesa = [[u.id_planilla, "Espera", u.numero, None, u.codigo]]
        if acta_desglosada:
            current_data_code(u.cod_datos)
            for c in Categoria.all():
                datos_mesa.append([c.codigo, c.nombre, c.posicion])
        mesas.append(datos_mesa)
    return mesas

# 需要导入模块: from msa.core.data.candidaturas import Categoria [as 别名]
# 或者: from msa.core.data.candidaturas.Categoria import all [as 别名]
    def _precache_datos(self):
        sleep(0.1)
        self.sesion.logger.debug("cacheando categorias")
        alianzas = self.agrupador.all()
        for categoria in Categoria.all():
            candidatos = self._get_candidatos_categoria(categoria.codigo, None)
            if len(candidatos) > get_tipo_elec("colapsar_listas"):
                for alianza in alianzas:
                    if len(alianza.listas) > 10:
                        self._get_candidatos_categoria(categoria.codigo, alianza.codigo)
        self.sesion.logger.debug("cacheando listas")
        for lista in Lista.all():
            self._get_dict_lista(lista)

        self.sesion.logger.debug("cacheando partidos")
        self._get_partidos()
        self.sesion.logger.debug("fin cache")

# 需要导入模块: from msa.core.data.candidaturas import Categoria [as 别名]
# 或者: from msa.core.data.candidaturas.Categoria import all [as 别名]
    def imagen_consulta(self):
        """Genera y envia la imagen de la consulta."""
        # Sr. desarrollador, resista la tentacion de mandar una imagen
        # base64 encoded SVG es mas rapido
        image_data = quote(self._imagen_verificacion.encode("utf-8"))

        datos = self._datos_verificacion
        candidatos = []
        for categoria in Categoria.all():
            candidato = datos.candidato_categoria(categoria.codigo)
            if candidato is not None:
                candidatos.extend(candidato)
        cods_candidatos = [cand.id_umv for cand in candidatos]
        self.send_command("imagen_consulta", [image_data, cods_candidatos])

        self._imagen_verificacion = None
        self._datos_verificacion = None

# 需要导入模块: from msa.core.data.candidaturas import Categoria [as 别名]
# 或者: from msa.core.data.candidaturas.Categoria import all [as 别名]
    def ejecutar(self):
        """Ejecuta la secuencia de impresion de actas."""
        self.logger.info("Ejecutando secuencia de impresion")
        try:
            self.sesion.impresora.remover_boleta_expulsada()
            self.acta_actual = self.actas_a_imprimir.pop(0)
            self._pedir_acta()
        except IndexError:
            # cuando terminamos de imprimir todas las actas cambiamos los
            # callbacks para la impresion extra de actas para fiscales.
            self._finalizado = True
            self.acta_actual[0] = CIERRE_CERTIFICADO

            self.acta_actual[1] = self.acta_actual[1] + 1
            grupos = list(set([cat.id_grupo for cat in Categoria.all()]))
            if self.acta_actual[1] > len(grupos):
                self.acta_actual[1] = 1

            self.acta_actual[1] = self.acta_actual[1]

            if self.callback_fin_secuencia is not None:
                self.callback_fin_secuencia()
                self.callback_fin_secuencia = self.callback_post_fin_secuencia
            self.callback_espera = None

# 需要导入模块: from msa.core.data.candidaturas import Categoria [as 别名]
# 或者: from msa.core.data.candidaturas.Categoria import all [as 别名]
    def desde_string(cls, tag, mesa=None):
        """Devuelve una seleccion a partir de la informacion de un tag rfid.
        """
        seleccion = None

        try:
            datos_tag = struct_voto.parse(tag)
        except (RangeError, FieldError, ValueError):
            # Manejamos que no nos puedan meter cualquier
            datos_tag = None

        if datos_tag is not None:
            ubic = datos_tag.ubicacion.decode("utf-8")
            if mesa is not None:
                # verificamos la mesa
                if mesa.cod_datos != ubic:
                    raise MesaIncorrecta()
            else:
                # OJO: Esto trae cualquier mesa del juego de datos.
                # No importa por que todas las mesas del mismo juego son
                # compatibles. Pero no nos permite identificar de que mesa es
                # el voto.
                mesa = Ubicacion.first(cod_datos=ubic)
                mesa.usar_cod_datos()

            seleccion = Seleccion(mesa)
            seleccion.serial = datos_tag.serial

            sel_por_cat = {}
            # recorremos cada uno de los pares de categoria/candidatos en el
            # tag
            str_opciones = datos_tag.opciones.decode()
            opciones = str_opciones.split(",")
            if len(opciones):
                for elem in opciones:
                    if len(elem):
                        cod_cat, id_umv = elem.split(":")
                        id_umv = int(id_umv)
                        sel_por_cat[cod_cat] = sel_por_cat.get(cod_cat, 0) + 1

                        # Buscamos el candidato votado para la categoria en
                        # cuestion
                        candidato = Candidatura.one(id_umv=id_umv,
                                                    cod_categoria=cod_cat)
                        # y lo elegimos (Si no encontró ninguno lanza un value
                        # error).
                        if candidato is None:
                            raise ValueError()
                        max_selecciones = int(
                            candidato.categoria.max_selecciones)
                        borrar = max_selecciones == 1
                        seleccion.elegir_candidato(candidato, borrar=borrar)

                if len(list(sel_por_cat.keys())) != len(Categoria.all()):
                    # caso en el que la canditad de categorias votadas sea
                    # diferente que la cantidad de categorias
                    seleccion = None
                else:
                    # aca verificamos que la cantidad de candidatos por
                    # categoria sea menor o igual de la cantidad de selecciones
                    # maximas que esperamos
                    for cod_categoria, cantidad in list(sel_por_cat.items()):
                        categoria = Categoria.one(cod_categoria)
                        max_selec = int(categoria.max_selecciones)
                        if categoria is None or cantidad > max_selec:
                            seleccion = None
                            break

        return seleccion

# 需要导入模块: from msa.core.data.candidaturas import Categoria [as 别名]
# 或者: from msa.core.data.candidaturas.Categoria import all [as 别名]
    def _test_multi(self):
        Ubicacion.plural_name = NOMBRE_JSON_MESAS_DEFINITIVO
        logger.debug("Conectando")
        self.app.controller.conectar()
        logger.debug("Conectado")

        # while self.app.controller.valid_tags is None:
        #     logger.debug("esperando evento")
        #     esperar_evento()
        sleep(5)

        logger.debug("<" * 5 + "CONECTANDO" + ">" * 5)

        ubic = path.join(PATH_CODIGO, UBIC_MODULO, "tests/save_transmision_id")
        file_ = open(ubic)
        data = pickle.load(file_)

        self.app.controller._evento_tag(*data)
        file_.close()
        esperar_evento()
        ubic = path.join(PATH_CODIGO, UBIC_MODULO,
                         "tests/save_transmision_recuento")
        file_ = open(ubic)
        data_recuento = list(pickle.load(file_))
        file_.close()

        file_ = open(path.join(PATH_CODIGO, UBIC_MODULO,
                               "tests/recuentos.txt"))
        recuentos = list(pickle.load(file_))
        file_.close()
        print len(recuentos), "RECUENTOS"
        sleep(4)
        for i, recuento in enumerate(recuentos, 1):
            logger.info("\n<<<<<" + "ENVIANDO RECUENTO %s>>>>>", i)
            data_recuento[1]["datos"] = recuento
            for j in range(2):
                self.app.controller._evento_tag(*data_recuento)
                sleep(1)

            sleep(1.5)
            self.app.controller.send_command("click_si")
            sleep(3)
            obj_recuento = Recuento.desde_tag(recuento)
            en_db = self.get_db_for_mesa(obj_recuento.mesa)
            for categoria in Categoria.all():
                obj_recuento._resultados[(categoria.codigo, "BLC.BLC")] = \
                    obj_recuento._resultados[(categoria.codigo, "%s_BLC" %
                                              categoria.codigo)]
                del obj_recuento._resultados[(categoria.codigo, "%s_BLC" %
                                              categoria.codigo)]

                obj_recuento._resultados[(categoria.codigo, "NUL.NUL")] = \
                    obj_recuento.listas_especiales["NUL"]
                obj_recuento._resultados[(categoria.codigo, "REC.REC")] = \
                    obj_recuento.listas_especiales["REC"]
                obj_recuento._resultados[(categoria.codigo, "IMP.IMP")] = \
                    obj_recuento.listas_especiales["IMP"]
                obj_recuento._resultados[(categoria.codigo, "TEC.TEC")] = \
                    obj_recuento.listas_especiales["TEC"]
            self.iguales(obj_recuento._resultados, en_db)
        try:
            self.app.controller._salir_definitivo()
        except RuntimeError:
            pass

# 需要导入模块: from msa.core.data.candidaturas import Categoria [as 别名]
# 或者: from msa.core.data.candidaturas.Categoria import all [as 别名]
 def _precache_categorias(self):
     sleep(0.1)
     for categoria in Categoria.all():
         self._get_candidatos_categoria(categoria.codigo, None)

# 需要导入模块: from msa.core.data.candidaturas import Categoria [as 别名]
# 或者: from msa.core.data.candidaturas.Categoria import all [as 别名]
 def dict_set_categorias(self):
     """Envia el diccionario con los datos de las categorias."""
     categorias = Categoria.all().to_dict()
     return categorias