Python candidaturas.Categoria类代码示例

    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

 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

    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

 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

    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)

    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

    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

    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

 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

 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)

 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

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

    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

 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

 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)