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 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
