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 _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 _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 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 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_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 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): """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 _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 _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 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 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)
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
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
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
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']]])
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
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")
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
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])
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()
def _get_categorias(self): # Ordenamos siempre por la posicion de la Categoria. filter = { "sorted": "posicion", } # Quizas queremos omitir las categorias adheridas, como en algunas # elecciones en las que el vicegobernador es un cargo que adhiere al de # gobernador. mostrar_adheridas = self.config("mostrar_adheridas", self.data["cod_datos"]) if not mostrar_adheridas: filter["adhiere"] = None # En caso de querer generar la tabla con un solo grupo de categorias if self.grupo_cat is not None: filter["id_grupo"] = self.grupo_cat # Traemos todas las categorias con el filtro que acabamos de armar categorias = Categoria.many(**filter) return categorias
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
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']]])
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
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
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
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): columna = [titulo] for fila in filas: max_chars = ancho_columnas[i] * 80 / 800 data = fila[i] if i > 0 else fila[i][:max_chars] columna.append(data) columnas.append((columna, x, y, ancho_columnas[i])) x += ancho_columnas[i] ret['alto_rectangulo'] = len(filas) * 23 ret['tabla'] = columnas titulo_columnas = ["Cod.", _("palabra_categoria"), "N°"] w = width - dx * 2 - ancho_col * 3 ancho_columnas = [ancho_col, w, ancho_col] y2 = 435 if not self.de_muestra else 193 lineas.append((y2 * self.zoom + empujar_firmas, self.margin_left, self.margin_right)) valores_especiales = [] for lista_esp in get_config("listas_especiales"): _cod_esp = lista_esp.split(".")[-1] valores_especiales.append( (_cod_esp, _("titulo_votos_%s" % _cod_esp), self.recuento.listas_especiales[lista_esp])) general = self.recuento.boletas_contadas() general += sum(self.recuento.listas_especiales.values()) valores_especiales.append((COD_TOTAL, _("total_general"), general)) x = self.margin_left y += empujar_firmas + 30 columnas = [] for i, titulo in enumerate(titulo_columnas): columna = [titulo] for fila in valores_especiales: columna.append(fila[i]) columnas.append((columna, x, y, ancho_columnas[i])) x += ancho_columnas[i] ret['alto_rectangulo_especiales'] = len(valores_especiales) * 23 ret['tabla_especiales'] = columnas empujar_firmas += len(valores_especiales) * 23 ret['lineas'] = lineas return ret, empujar_firmas