Python Categoria.many方法代码示例

# 需要导入模块: from msa.core.data.candidaturas import Categoria [as 别名]
# 或者: from msa.core.data.candidaturas.Categoria import many [as 别名]
    def desde_tag(cls, tag, con_dnis=True):
        if con_dnis:
            struct = struct_recuento_dni
        else:
            struct = struct_recuento
        datos_tag = struct.parse(tag)
        por_categoria = int(datos_tag.por_categoria)
        cod_categoria = datos_tag.cod_categoria

        if SMART_PACKING:
            num_mesa, valores = unpack("".join(datos_tag.datos))
            mesa = Ubicacion.one(numero=str(num_mesa))
        else:
            tag = "".join(datos_tag.datos)
            len_cod_mesa = int(tag[:2])
            cod_mesa = tag[2:2 + len_cod_mesa]
            mesa = Ubicacion.one(cod_mesa)
            valores = unpack(tag[len_cod_mesa + 2:])

        if not mesa:
            raise MesaNoEncontrada()

        current_data_code(mesa.cod_datos)

        if por_categoria:
            categorias = Categoria.many(codigo=cod_categoria)
        else:
            categorias = Categoria.many(sorted='codigo')

        recuento = Recuento(mesa)
        principales = recuento._get_dict_candidatos()
        # leemos los valores y los seteamos en los resultados
        # vienen ordenados por cod_lista,cod_categoria
        for lista in Lista.many(sorted='codigo'):
            for categoria in categorias:
                candidato = Candidato.one(cod_categoria=categoria.codigo,
                                          cod_lista=lista.codigo, titular=True,
                                          numero_de_orden=1)
                if candidato is not None:
                    recuento._resultados[categoria.codigo,
                                         candidato.codigo] = valores.pop(0)

        ordered_keys = sorted(recuento.campos_extra.keys())
        for key in ordered_keys:
            recuento.campos_extra[key] = valores.pop(0)

        ordered_keys = sorted(recuento.listas_especiales.keys())
        for key in ordered_keys:
            recuento.listas_especiales[key] = valores.pop(0)

        if por_categoria:
            recuento.cod_categoria = cod_categoria

        if con_dnis:
            dnis = unpack_slow(datos_tag.documentos, 27)
            for dni in dnis:
                autoridad = Autoridad("", "", 0, dni)
                recuento.autoridades.append(autoridad)

        return recuento

# 需要导入模块: from msa.core.data.candidaturas import Categoria [as 别名]
# 或者: from msa.core.data.candidaturas.Categoria import many [as 别名]
 def _get_categorias(self):
     """Devuelve las categorias para esta mesa y para esta partido en caso
     de que sea ese tipo de eleccion."""
     if not get_tipo_elec("interna"):
         categorias = Categoria.many(sorted="posicion")
     else:
         cod_cats = set([candidato.categoria.codigo for candidato in
                         Candidato.many(cod_partido=self.partido.codigo)])
         categorias = Categoria.many(codigo__in=cod_cats, sorted="posicion")
     return categorias

# 需要导入模块: from msa.core.data.candidaturas import Categoria [as 别名]
# 或者: from msa.core.data.candidaturas.Categoria import many [as 别名]
    def _get_datos_candidatos(self):
        """Devuelve los datos de los candidatos de la seleccion."""
        filter = {"sorted": "posicion"}
        mostrar_adheridas = self.config("mostrar_adheridas", self.seleccion.mesa.cod_datos)
        if not mostrar_adheridas:
            filter["adhiere"] = None

        categorias = Categoria.many(**filter)
        template = self.seleccion.mesa.template_ubic()
        candidatos = self.seleccion.candidatos_elegidos()
        if template is not None:
            cand_bloques = len([cand for cand in candidatos if cand.categoria.adhiere is None or mostrar_adheridas])
            if cand_bloques > len(template.bloques):
                template = self.seleccion.mesa.fallback_template()

        secciones = []
        if template is not None:
            categorias_usadas = []
            idx_categorias = [categoria.codigo for categoria in categorias]

            # recorro las selecciones, traigo los daots del candidato.
            for candidato in candidatos:
                if candidato.categoria.adhiere is None or mostrar_adheridas:
                    datos = self._get_datos_candidato(candidato, template, idx_categorias, categorias_usadas)
                    secciones.append(datos)

        return secciones

# 需要导入模块: from msa.core.data.candidaturas import Categoria [as 别名]
# 或者: from msa.core.data.candidaturas.Categoria import many [as 别名]
    def _get_datos_candidatos(self):
        templates = self.seleccion.mesa.templates_impresion(
            forzar_media=self.de_muestra)
        margen_izq = self.medidas_boleta['margen_izq']  # margen izquierdo
        original_dx = margen_izq
        idx_categorias = [categoria.codigo for categoria in
                          Categoria.many(sorted="posicion")]
        categorias_usadas = []
        lineas = []
        secciones = []

        # recorro las selecciones, dibujo el cargo elegido, lista, etc.
        for candidato in self.seleccion._candidatos:
            datos = self._get_datos_candidato(candidato, templates,
                idx_categorias, categorias_usadas, lineas)
            secciones.append(datos)

        for categoria in categorias_usadas:
            index = idx_categorias.index(categoria.codigo)
            template_impresion = templates[index]
            w = template_impresion['ancho']
            h = template_impresion['alto']
            if template_impresion.get('vr', True):
                dx = original_dx + template_impresion['posicion'][0]
                dy = self.medidas_boleta['padding_selecciones'] + \
                    template_impresion['posicion'][1]
                # sep vert (sin encabezado)
                puntos = (dx + w - 1, dy, dx + w - 1, dy + h)
                lineas.append(puntos)

        return lineas, secciones

# 需要导入模块: from msa.core.data.candidaturas import Categoria [as 别名]
# 或者: from msa.core.data.candidaturas.Categoria import many [as 别名]
    def a_human(self):
        texto = "%s - %s, %s, %s (%s)\n" % (self.mesa.descripcion,
                                            self.mesa.escuela,
                                            self.mesa.municipio,
                                            self.mesa.departamento,
                                            self.mesa.codigo)
        for categoria in Categoria.many(sorted="posicion"):
            texto += "%s\n" % categoria.nombre
            for lista in Lista.many(sorted='codigo'):
                candidato = Candidato.one(cod_categoria=categoria.codigo,
                                          cod_lista=lista.codigo,
                                          titular=True,
                                          numero_de_orden=1)
                if candidato is not None:
                    votos = self._resultados[categoria.codigo,
                                             candidato.codigo]
                    texto += "\t%s - %s Votos: %s\n" % (lista.nombre,
                                                        candidato.nombre,
                                                        votos)
            texto += "\n"

        texto += "\nCampos extra:\n"
        ordered_keys = sorted(self.campos_extra.keys())
        for key in ordered_keys:
            texto += "%s: %s\n" % (key, self.campos_extra[key])

        texto += "\nListas Especiales:\n"
        ordered_keys = sorted(self.listas_especiales.keys())
        for key in ordered_keys:
            texto += "%s: %s\n" % (_("titulo_votos_%s" % key),
                                   self.listas_especiales[key])

        return texto

# 需要导入模块: from msa.core.data.candidaturas import Categoria [as 别名]
# 或者: from msa.core.data.candidaturas.Categoria import many [as 别名]
 def rellenar_de_blanco(self):
     """Agrega voto en blanco a las categorias que no fueron votadas."""
     for categoria in Categoria.many():
         if self.candidato_categoria(categoria.codigo) is None:
             blanco = Candidatura.one(cod_categoria=categoria.codigo,
                                      clase="Blanco")
             if blanco is not None:
                 self.elegir_candidato(blanco)

# 需要导入模块: from msa.core.data.candidaturas import Categoria [as 别名]
# 或者: from msa.core.data.candidaturas.Categoria import many [as 别名]
def get_categorias(cod_datos, desglosada):
    if desglosada:
        current_data_code(cod_datos)
        categorias = [(c.codigo, c.nombre, c.posicion) for c in
                      Categoria.many(sorted="posicion")]
    else:
        categorias = None

    return categorias

# 需要导入模块: from msa.core.data.candidaturas import Categoria [as 别名]
# 或者: from msa.core.data.candidaturas.Categoria import many [as 别名]
    def get_datos_seleccion(self, seleccion):
        """Devuelve los candidatos de Una seleccion ordenados por categoria."""
        cand_seleccion = []
        for categoria in Categoria.many(sorted="posicion"):
            candidatos = seleccion.candidato_categoria(categoria.codigo)
            for candidato in candidatos:
                cand_seleccion.append(candidato.id_umv)

        return cand_seleccion

# 需要导入模块: from msa.core.data.candidaturas import Categoria [as 别名]
# 或者: from msa.core.data.candidaturas.Categoria import many [as 别名]
    def _crear_lista_actas(self):
        """Crea la lista de la secuencia de impresion de actas."""
        actas = []
        categorias = Categoria.many(sorted="posicion")
        grupos = sorted(list(set([cat.id_grupo for cat in categorias])))

        for tipo_acta in self.orden_actas:
            for grupo in grupos:
                datos_grupo = [tipo_acta, grupo]
                actas.append(datos_grupo)
        self.logger.info("Creanda lista de actas. %s actas a imprimir",
                         len(actas))
        return actas

# 需要导入模块: from msa.core.data.candidaturas import Categoria [as 别名]
# 或者: from msa.core.data.candidaturas.Categoria import many [as 别名]
 def imagen_consulta(self):
     """Pisamos el metodo imagen_consulta para escucharlo en vez de verlo."""
     self.modulo.seleccion = self._datos_verificacion
     categorias = Categoria.many(sorted="posicion")
     cat_list = []
     for categoria in categorias:
         cat_dict = {}
         cat_dict['categoria'] = categoria.to_dict()
         cands = self.modulo.seleccion.candidato_categoria(categoria.codigo)
         cat_dict['candidato'] = cands[0].to_dict()
         cat_list.append(cat_dict)
     self.modulo.seleccion = None
     self.asistente = AsistenteVerificacion(self, cat_list, repetir=False)
     self._imagen_verificacion = None
     self._datos_verificacion = None

# 需要导入模块: from msa.core.data.candidaturas import Categoria [as 别名]
# 或者: from msa.core.data.candidaturas.Categoria import many [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 many [as 别名]
    def a_human(self):
        texto = "{} - {}, {}, {} ({})\n".format(self.mesa.descripcion,
                                                self.mesa.escuela,
                                                self.mesa.municipio,
                                                self.mesa.departamento,
                                                self.mesa.codigo)
        for autoridad in self.autoridades:
            texto += "Autoridad: {}\n".format(autoridad.nro_documento)

        for categoria in Categoria.many(sorted="posicion",
                                        id_grupo=self.grupo_cat):
            texto += "{}\n".format(categoria.nombre)
            for lista in Lista.many(sorted='codigo'):
                candidato = Candidatura.one(cod_categoria=categoria.codigo,
                                            cod_lista=lista.codigo)
                if candidato is not None:
                    votos = self.get_resultados(candidato.id_umv)
                    texto += "\t{} - {} Votos: {}\n".format(lista.nombre,
                                                            candidato.nombre,
                                                            votos)
            candidato = Candidatura.one(cod_categoria=categoria.codigo,
                                        clase="Blanco")
            if candidato is not None:
                votos = self.get_resultados(candidato.id_umv)
                texto += "\t{}: {}\n".format(_("votos_en_blanco"), votos)
            texto += "\n"

        texto += "\nCampos extra:\n"
        ordered_keys = sorted(self.campos_extra.keys())
        for key in ordered_keys:
            texto += "{}: {}\n".format(key, self.campos_extra[key])

        texto += "\nListas Especiales:\n"
        ordered_keys = sorted(self.listas_especiales.keys())
        for key in ordered_keys:
            titulo = _("titulo_votos_{}".format(key))
            texto += "{}: {}\n".format(titulo, self.listas_especiales[key])

        return texto

# 需要导入模块: from msa.core.data.candidaturas import Categoria [as 别名]
# 或者: from msa.core.data.candidaturas.Categoria import many [as 别名]
 def get_resultados(self, id_umv=None):
     """Devuelve todos los resultados o uno en especifico."""
     # si le pedimos uno solo busca los votos de ese candidato.
     if id_umv is not None:
         ret = self.pizarra.votos_candidato(id_umv)
     else:
         # Sino devolvemos todos
         votos = self.pizarra.get_votos_actuales()
         # Si el acta está desglosada devolvemos la categorias que tiene el
         # acta guardada
         if self.grupo_cat is not None:
             categorias_grupo = Categoria.many(id_grupo=self.grupo_cat)
             cods_categoria = [cat.codigo for cat in categorias_grupo]
             ret = {}
             for key in votos.keys():
                 cand = Candidatura.one(id_umv=key,
                                        cod_categoria__in=cods_categoria)
                 if cand is not None:
                     ret[key] = votos[key]
         else:
             # no esta desgolsada devolvemos todos los votos.
             ret = votos
     return ret

# 需要导入模块: from msa.core.data.candidaturas import Categoria [as 别名]
# 或者: from msa.core.data.candidaturas.Categoria import many [as 别名]

#.........这里部分代码省略.........
            }
        else:
            alto_titulo = 0

        pos_num_lista = margen_sup + alto_titulo + layout["padding_num_lista"]

        num_lista = None
        if candidato.es_blanco:
            texto_lista = ""
        elif categoria.consulta_popular:
            texto_lista = candidato.lista.nombre.upper()
        else:
            num_lista = candidato.lista.numero.lstrip("0")
            texto_lista = " ".join((_("palabra_lista"), num_lista))

        seccion["numero_lista"] = {
            "pos_y": pos_num_lista,
            "texto": texto_lista,
            "numero": num_lista,
            "em": layout["em_num_lista"],
        }

        padding_lista = pos_num_lista + layout["padding_nom_lista"]

        if candidato.es_blanco or categoria.consulta_popular:
            nombre_lista = ""
            padding_lista += layout["sep_lineas_lista"]
        else:
            lineas_titulo = []
            if candidato.partido is not None:
                for linea_wrapeada in textwrap.wrap(candidato.partido.alianza.nombre, layout["wrap_lista"]):
                    linea = (padding_lista, linea_wrapeada)
                    padding_lista += layout["sep_lineas_lista"]
                    lineas_titulo.append(linea)
            for linea_wrapeada in textwrap.wrap(candidato.lista.nombre, layout["wrap_lista"]):
                linea = (padding_lista, linea_wrapeada)
                padding_lista += layout["sep_lineas_lista"]
                lineas_titulo.append(linea)
            nombre_lista = lineas_titulo

        seccion["nombre_lista"] = {"pos_y": padding_lista, "lineas": nombre_lista, "em": layout["em_nom_lista"]}

        # nombre del primer candidato
        y_candidato = padding_lista + layout["padding_cand_titular"]
        nombre_candidato = []
        nombre = candidato.nombre
        if categoria.consulta_popular and len(candidato.secundarios):
            nombre = " ".join(candidato.secundarios)

        for linea_wrapeada in textwrap.wrap(nombre, layout["wrap_candidato"]):
            linea = (y_candidato, linea_wrapeada)
            y_candidato += layout["sep_lineas_titular"]
            nombre_candidato.append(linea)

        seccion["nombre_candidato"] = {"pos_y": y_candidato, "lineas": nombre_candidato, "em": layout["em_candidato"]}
        pad_sec = layout["padding_secundarios"]
        # nombre del resto de los candidatos (si hay)
        y_secundarios = y_candidato + pad_sec
        secundarios = candidato.secundarios
        if len(secundarios) and not categoria.consulta_popular:
            candidatos_secundarios = "; ".join([cand for cand in secundarios])
            lineas_texto = []
            for linea_wrapeada in textwrap.wrap(candidatos_secundarios, layout["wrap_secundarios"]):
                linea = (y_secundarios, linea_wrapeada)
                y_secundarios += layout["sep_lineas_secundarios"]
                lineas_texto.append(linea)
            seccion["secundarios"] = {"pos_y": y_secundarios, "lineas": lineas_texto, "em": layout["em_secundarios"]}
        # nombre del resto de los candidatos (si hay)
        secundarios = candidato.suplentes
        mostrar_suplentes = self.config("mostrar_suplentes_en_boleta", self.seleccion.mesa.cod_datos)
        if mostrar_suplentes and len(secundarios) and not categoria.consulta_popular:
            candidatos_secundarios = "; ".join([cand for cand in secundarios])
            y_secundarios = y_secundarios + pad_sec - 20
            lineas_texto = [(y_secundarios, "Suplentes:")]
            y_secundarios = y_secundarios + pad_sec - 10
            for linea_wrapeada in textwrap.wrap(candidatos_secundarios, layout["wrap_secundarios"]):
                linea = (y_secundarios, linea_wrapeada)
                y_secundarios += pad_sec - 3
                lineas_texto.append(linea)
            seccion["suplentes"] = {"pos_y": y_secundarios, "lineas": lineas_texto, "em": layout["em_suplentes"]}
        # si no quiero mostrar las categorias adheridas como paneles separados
        # seguramente quiera mostrar la seleccion dentro del bloque del padre
        mostrar_adheridas = self.config("mostrar_adheridas", self.seleccion.mesa.cod_datos)
        if not mostrar_adheridas:
            hijas = Categoria.many(adhiere=categoria.codigo)
            lineas_texto = []
            for hija in hijas:
                cands_hijos = self.seleccion.candidato_categoria(hija.codigo)
                if cands_hijos is not None:
                    candidatos = [cands_hijos[0].nombre]
                    candidatos += cands_hijos[0].secundarios
                    cand_hijo = "{}: {}".format(hija.nombre, "; ".join(candidatos))
                    y_secundarios = y_secundarios + pad_sec
                    for linea_wrapeada in textwrap.wrap(cand_hijo, layout["wrap_adherentes"]):
                        linea = (y_secundarios, linea_wrapeada)
                        y_secundarios += layout["sep_lineas_adherentes"]
                        lineas_texto.append(linea)
            seccion["adherentes"] = {"pos_y": y_secundarios, "lineas": lineas_texto, "em": layout["em_adherentes"]}

        return seccion

# 需要导入模块: from msa.core.data.candidaturas import Categoria [as 别名]
# 或者: from msa.core.data.candidaturas.Categoria import many [as 别名]
    def _get_tabla(self, width):
        ret = {}
        empujar_firmas = 0
        lineas = []
        # muestro la tabla solo si tiene recuento
        mostrar_partidos = False  #any([lista.cod_partido for lista in Lista.all()])
        if self.categoria is None:
            categorias = Categoria.many(sorted="posicion")
        else:
            categorias = Categoria.many(codigo=self.categoria)

        dx = 10

        # ancho genérico de columnas
        ancho_col = 40 * self.zoom
        # calculo ancho columna descripción
        w = width - dx * 2 - len(categorias) * ancho_col
        w = w - ancho_col           # resto ancho col. nº de lista
        Y_INICIAL = 420 if not self.de_muestra else 180
        y2 = Y_INICIAL
        lineas.append((y2 * self.zoom, self.margin_left, self.margin_right))

        filas = []
        # listas ordenadas por numero, con blanco al final
        listas = [l for l in Lista.many(sorted='cod_partido, numero')
                  if not l.es_blanco()]

        def _sort_listas(lista_a, lista_b):
            return cmp(int(lista_a.numero)if lista_a.numero != ""
                       else lista_a.codigo,
                       int(lista_b.numero)if lista_b.numero != ""
                       else lista_b.codigo)

        def _sort_listas_paso(lista_a, lista_b):
            return cmp(lista_a.partido.nombre.upper(),
                       lista_b.partido.nombre.upper())

        if get_tipo_elec("paso"):
            listas = sorted(listas, _sort_listas_paso)
        else:
            listas = sorted(listas, _sort_listas)

        lista_blanca = Lista.one(COD_LISTA_BLANCO)
        if lista_blanca is not None:
            listas.append(lista_blanca)
        partido_actual = None
        num_listas = 0
        guiones = ["-"] * (len(categorias) + 1)

        principales = self.recuento._get_dict_candidatos()

        for lista in listas:
            lista_partido = False
            partido = lista.partido
            es_blanco = lista.es_blanco()
            if mostrar_partidos and not es_blanco and \
                    partido_actual != lista.cod_partido:
                partido_actual = lista.cod_partido
                if num_listas == 0:
                    filas = filas[:-1]
                else:
                    num_listas = 0
                una_lista = num_listas == 0 and len(partido.listas) == 1
                if una_lista or partido.nombre == lista.nombre:
                    lista_partido = True
                else:
                    fila = [partido.nombre] + guiones
                    filas.append(fila)
                    lista_partido = False

            es_cand_consulta = lista.candidatos[0].cod_categoria == "CPO"
            numero = lista.numero if lista.numero != "BLC" and \
                not es_cand_consulta else ""
            nombre_lista = lista.nombre if not lista_partido \
                else partido.nombre
            if es_cand_consulta:
                nombre_lista = "Consulta Popular - " + nombre_lista
            if not es_blanco and not lista_partido and get_tipo_elec("paso"):
                nombre_lista = "-- " + nombre_lista
            fila = [nombre_lista, numero]
            for categoria in categorias:
                candidato = principales.get((lista.codigo, categoria.codigo))
                resultado = "- "
                if candidato is not None:
                    resultado = self.recuento.obtener_resultado(
                        categoria.codigo, candidato.codigo)
                fila.append(resultado)
            num_listas += 1
            filas.append(fila)

        empujar_firmas += len(filas) * 23

        # Armando tabla superior
        x = self.margin_left
        y = (400 if not self.de_muestra else 160) * self.zoom
        ancho_columnas = [w, ancho_col] + [ancho_col] * len(categorias)
        titulo_columnas = [_("palabra_lista"), "Nº"] + \
            [cat.codigo for cat in categorias]
        columnas = []
        for i, titulo in enumerate(titulo_columnas):
#.........这里部分代码省略.........