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 _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 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 _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 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 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 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 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 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_candidato"),
numero,
self._("para"),
categoria.texto_asistida,
opcion['texto_asistida'],
self._("acuerdo_cancelar")]
self._decir(mensaje)
self.controlador.cambiar_monitor()
else:
opcion_ = self.confirmando[0]
self.controlador.seleccionar_lista([opcion_['codigo'],
opcion_['cod_categoria'], None,
False])
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_preludio(self):
self.categoria = Categoria.one(self.data[1])
mensaje = [self.categoria.texto_asistida_ingrese_nro,
self._("confirmando_con_e_opcion")]
return mensaje
def get_preludio(self):
"""Devuelve el mensaje del preludio."""
self.categoria = Categoria.one(self.data[1])
mensaje = [self.categoria.texto_asistida_ingrese_nro,
self._("confirmando_con_e_opcion")]
return mensaje
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])
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])
