Python Categoria.one方法代码示例

# 需要导入模块: from msa.core.data.candidaturas import Categoria [as 别名]
# 或者: from msa.core.data.candidaturas.Categoria import one [as 别名]
 def get_preludio(self):
     """Devuelve el mensaje del preludio."""
     self.categoria = Categoria.one(self.data["cod_categoria"])
     mensaje = [self.categoria.texto_asistida_ingrese_nro,
                self._("confirmando_con_e_opcion"),
                self._("las_opciones_son")]
     return mensaje

# 需要导入模块: from msa.core.data.candidaturas import Categoria [as 别名]
# 或者: from msa.core.data.candidaturas.Categoria import one [as 别名]
 def _audio_opcion(self, opcion):
     num_opcion, datos = opcion
     mensaje = [
         self._('el_candidato'),
         datos['candidato']['texto_asistida'],
         self._('para'),
         Categoria.one(datos['categoria']['codigo']).texto_asistida]
     return mensaje

# 需要导入模块: from msa.core.data.candidaturas import Categoria [as 别名]
# 或者: from msa.core.data.candidaturas.Categoria import one [as 别名]
 def audios_mostrar_confirmacion(self, data):
     """Carga los audios de la confirmacion."""
     paneles = []
     for datum in data:
         categoria = Categoria.one(datum[0]).to_dict()
         candidato = Candidatura.one(datum[1]).to_dict()
         dict_panel = {"categoria": categoria,
                       "candidato": candidato}
         paneles.append(dict_panel)
     self.audios("mostrar_confirmacion", paneles)

# 需要导入模块: from msa.core.data.candidaturas import Categoria [as 别名]
# 或者: from msa.core.data.candidaturas.Categoria import one [as 别名]
 def _get_candidatos_categoria(self, cod_categoria, cod_partido):
     key = (cod_categoria, cod_partido)
     if key in self._cache_categorias:
         cand_list = self._cache_categorias[key]
     else:
         categoria = Categoria.one(cod_categoria)
         candidatos = categoria.candidatos(cod_partido, self.agrupador)
         cand_list = [candidato.full_dict(_image_name) for candidato in candidatos]
         self._cache_categorias[key] = cand_list
     return cand_list

# 需要导入模块: from msa.core.data.candidaturas import Categoria [as 别名]
# 或者: from msa.core.data.candidaturas.Categoria import one [as 别名]
    def get_imagen_acta(self, tipo=None):
        if tipo is None:
            if not ACTA_DESGLOSADA:
                tipo = (SECUENCIA_CERTIFICADOS[0], None)
            elif self.sesion.recuento.cod_categoria is not None:
                tipo = (SECUENCIA_CERTIFICADOS[0],
                        self.sesion.recuento.cod_categoria)
            else:
                primera_categoria = Categoria.one(sorted="posicion").codigo
                tipo = (SECUENCIA_CERTIFICADOS[0], primera_categoria)

        imagen = self.sesion.recuento.a_imagen(tipo, de_muestra=True, svg=True)
        image_data = quote(imagen.encode("utf-8"))
        return image_data

# 需要导入模块: from msa.core.data.candidaturas import Categoria [as 别名]
# 或者: from msa.core.data.candidaturas.Categoria import one [as 别名]
 def callback(self, opcion, numero):
     if self.confirmando is None:
         self.confirmando = [opcion, numero]
         categoria = Categoria.one(opcion['cod_categoria'])
         mensaje = [self._("ud_eligio"),
                    numero,
                    self._("para"),
                    categoria.texto_asistida,
                    opcion['texto_asistida'],
                    self._("acuerdo_cancelar")]
         self._decir(mensaje)
         self.controller.cambiar_monitor()
     else:
         self.controller.seleccionar_candidatos(
             [self.confirmando[0]['cod_categoria'],
              [self.confirmando[0]['codigo']]])

# 需要导入模块: from msa.core.data.candidaturas import Categoria [as 别名]
# 或者: from msa.core.data.candidaturas.Categoria import one [as 别名]
    def cargar_categorias(self, force=False, force_cat=None):
        """Envia el comando de cargar categorias o el comando de mostrar
        confirmacion dependiendo del contexto.
        En caso de que haya una categoria que no se voto o se este modificando
        una categoria envia el comando "cargar_categorias" en caso de que las
        categorias ya esten llenas envia el comando de mostrar confirmacion.
        """
        cat_list = self.get_data_categorias()
        next_cat = self.get_next_cat()

        run_command = True
        if next_cat is None:
            # este es el caso en que no tenemos ninguna categoria sin candidatos
            # seleccionados.
            if force:
                if force_cat is None:
                    # si ya esta todo lleno y no forzamos ninguna categoria
                    # vamos a la primera
                    next_cat = self._get_categorias()[0].codigo
                else:
                    # este es el caso en el que forzamos una categoria
                    categoria = Categoria.one(force_cat)
                    if not categoria.consulta_popular:
                        # tenemos que ver si la categoria que forzamos esta
                        # adherida a otra categoria y cambiar por la madre en
                        # caso de que sea asi.
                        madre = categoria.get_madre()
                        if madre is not None:
                            next_cat = madre.codigo
                        else:
                            next_cat = force_cat
                    else:
                        # si la categoria que forzamos es una consulta_popular
                        # vamos a levantara en modo consulta_popular
                        self.mostrar_consulta_popular(force_cat)
                        run_command = False
            else:
                # si no hay siguiente categoria quiere decir que tenemos que
                # llamar a la confirmacion
                self.mostrar_confirmacion()
                run_command = False

        if run_command:
            # solo va a entrar aca el caso de haber una proxima categoria que no
            # sea consulta popular
            self.send_command("cargar_categorias", [cat_list, next_cat])

# 需要导入模块: from msa.core.data.candidaturas import Categoria [as 别名]
# 或者: from msa.core.data.candidaturas.Categoria import one [as 别名]
    def seleccionar_candidatos(self, data):
        """Selecciona el candidato y envia el comando para cargar las
        categorias.
        """
        cod_categoria, cod_candidatos = data
        muchos_candidatos = len(cod_candidatos) > 1

        if muchos_candidatos:
            self.parent.seleccion.borrar_categoria(cod_categoria)

        for elem in data[1]:
            candidato = Candidato.one(elem)
            self.parent.seleccion.elegir_candidato(candidato, not muchos_candidatos)

        categoria = Categoria.one(cod_categoria)
        if categoria.consulta_popular:
            self.mostrar_confirmacion()
        else:
            self.cargar_categorias()

# 需要导入模块: from msa.core.data.candidaturas import Categoria [as 别名]
# 或者: from msa.core.data.candidaturas.Categoria import one [as 别名]
 def callback(self, opcion, numero):
     """
     Callback que se ejecuta cuando se selecciona una opcion.
     Argumentos:
         opcion -- la opcion elegida.
         numero -- el numero de opcion que tiene la opcion elegida.
     """
     if self.confirmando is None:
         self.confirmando = [opcion, numero]
         categoria = Categoria.one(opcion['cod_categoria'])
         mensaje = [self._("ud_eligio"),
                    numero,
                    self._("para"),
                    categoria.texto_asistida,
                    opcion['texto_asistida'],
                    self._("acuerdo_cancelar")]
         self._decir(mensaje)
         self.controlador.cambiar_monitor()
     else:
         self.controlador.send_command("seleccionar_candidatos_asistida",
             [self.confirmando[0]['cod_categoria'],
              [self.confirmando[0]['id_umv']]])

# 需要导入模块: from msa.core.data.candidaturas import Categoria [as 别名]
# 或者: from msa.core.data.candidaturas.Categoria import one [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 one [as 别名]
 def get_preludio(self):
     self.categoria = Categoria.one(self.data[1])
     mensaje = [self.categoria.texto_asistida_ingrese_nro,
                self._("confirmando_con_e_opcion")]
     return mensaje

# 需要导入模块: from msa.core.data.candidaturas import Categoria [as 别名]
# 或者: from msa.core.data.candidaturas.Categoria import one [as 别名]
    def cargar_listas(self, cod_candidatos=None, cat=None):
        """Envia el comando para cargar las listas."""
        if cod_candidatos is None:
            cod_candidatos = []
        cod_partido = self.agrupacion.codigo if self.agrupacion is not None else None
        if cod_partido is None:
            listas = Lista.all()
        else:
            listas = self.agrupador.one(cod_partido).listas
        listas_dict = []

        if MEZCLAR_LISTAS:
            listas.shuffle()

        for lista in listas:
            candidatos = lista.candidatos
            if len(candidatos):
                hash_lista = [candidato.codigo for candidato in candidatos]
                lista_dict = lista.to_dict()
                lista_dict["hash"] = hash_lista
                lista_dict["imagen"] = _image_name(lista.codigo)
                lista_dict["candidatos"] = []

                for candidato in candidatos:
                    candidato_dict = candidato.full_dict(_image_name)
                    candidato_dict["hash_lista"] = hash_lista
                    candidato_dict["categoria"] = candidato.categoria.nombre
                    lista_dict["candidatos"].append(candidato_dict)

                listas_dict.append(lista_dict)

        if get_tipo_elec("adh_segmentada"):
            if cat is None:
                search_cat = Categoria.one(sorted="posicion")
            else:
                cat = Categoria.one(cat)
                search_cat = cat.next(consulta_popular=False)
            repite, listas_filtradas, next_search_cat = self._cat_con_adh(listas_dict, cat, search_cat, cod_candidatos)
            if repite and next_search_cat is not None:
                listas_dict = listas_filtradas
                ultima_cat = False
            else:
                ultima_cat = True
                listas_finales = []
                for lista in listas_dict:
                    for candidato in listas_filtradas:
                        if lista["hash"] == candidato["hash_lista"]:
                            listas_finales.append(lista)
                listas_dict = listas_finales

        if len(listas_dict) > 1:
            if (
                get_tipo_elec("adh_segmentada")
                and repite
                and get_tipo_elec("adh_segmentada_nivel") > len(cod_candidatos)
            ):

                self.send_command("cargar_adhesiones", [listas_dict, search_cat.codigo, cod_candidatos, ultima_cat])
            else:
                self.send_command("cargar_listas_params", [listas_dict, None, cod_candidatos])
        else:
            self.seleccionar_lista([listas_dict[0]["codigo"], None, None, True])