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 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 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 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_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 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 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 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 _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 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 _precache_categorias(self):
sleep(0.1)
for categoria in Categoria.all():
self._get_candidatos_categoria(categoria.codigo, 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 dict_set_categorias(self):
"""Envia el diccionario con los datos de las categorias."""
categorias = Categoria.all().to_dict()
return categorias
def _test_multi(self):
Ubicacion.plural_name = NOMBRE_JSON_MESAS_DEFINITIVO
logger.debug("Conectando")
self.app.controller.conectar()
logger.debug("Conectado")
# while self.app.controller.valid_tags is None:
# logger.debug("esperando evento")
# esperar_evento()
sleep(5)
logger.debug("<" * 5 + "CONECTANDO" + ">" * 5)
ubic = path.join(PATH_CODIGO, UBIC_MODULO, "tests/save_transmision_id")
file_ = open(ubic)
data = pickle.load(file_)
self.app.controller._evento_tag(*data)
file_.close()
esperar_evento()
ubic = path.join(PATH_CODIGO, UBIC_MODULO,
"tests/save_transmision_recuento")
file_ = open(ubic)
data_recuento = list(pickle.load(file_))
file_.close()
file_ = open(path.join(PATH_CODIGO, UBIC_MODULO,
"tests/recuentos.txt"))
recuentos = list(pickle.load(file_))
file_.close()
print len(recuentos), "RECUENTOS"
sleep(4)
for i, recuento in enumerate(recuentos, 1):
logger.info("\n<<<<<" + "ENVIANDO RECUENTO %s>>>>>", i)
data_recuento[1]["datos"] = recuento
for j in range(2):
self.app.controller._evento_tag(*data_recuento)
sleep(1)
sleep(1.5)
self.app.controller.send_command("click_si")
sleep(3)
obj_recuento = Recuento.desde_tag(recuento)
en_db = self.get_db_for_mesa(obj_recuento.mesa)
for categoria in Categoria.all():
obj_recuento._resultados[(categoria.codigo, "BLC.BLC")] = \
obj_recuento._resultados[(categoria.codigo, "%s_BLC" %
categoria.codigo)]
del obj_recuento._resultados[(categoria.codigo,
"%s_BLC" % categoria.codigo)]
obj_recuento._resultados[(categoria.codigo, "NUL.NUL")] = \
obj_recuento.listas_especiales["NUL"]
obj_recuento._resultados[(categoria.codigo, "REC.REC")] = \
obj_recuento.listas_especiales["REC"]
obj_recuento._resultados[(categoria.codigo, "IMP.IMP")] = \
obj_recuento.listas_especiales["IMP"]
obj_recuento._resultados[(categoria.codigo, "TEC.TEC")] = \
obj_recuento.listas_especiales["TEC"]
self.iguales(obj_recuento._resultados, en_db)
try:
self.app.controller._salir_definitivo()
except RuntimeError:
pass
def _test_multi(self):
Ubicacion.plural_name = NOMBRE_JSON_MESAS_DEFINITIVO
logger.debug("Conectando")
self.app.controller.conectar()
logger.debug("Conectado")
# while self.app.controller.valid_tags is None:
# logger.debug("esperando evento")
# esperar_evento()
sleep(5)
logger.debug("<" * 5 + "CONECTANDO" + ">" * 5)
ubic = path.join(PATH_CODIGO, UBIC_MODULO, "tests/save_transmision_id")
file_ = open(ubic)
data = pickle.load(file_)
self.app.controller._evento_tag(*data)
file_.close()
esperar_evento()
ubic = path.join(PATH_CODIGO, UBIC_MODULO,
"tests/save_transmision_recuento")
file_ = open(ubic)
data_recuento = list(pickle.load(file_))
file_.close()
file_ = open(path.join(PATH_CODIGO, UBIC_MODULO,
"tests/recuentos.txt"))
recuentos = list(pickle.load(file_))
file_.close()
print len(recuentos), "RECUENTOS"
sleep(4)
for i, recuento in enumerate(recuentos, 1):
logger.info("\n<<<<<" + "ENVIANDO RECUENTO %s>>>>>", i)
data_recuento[1]["datos"] = recuento
for j in range(2):
self.app.controller._evento_tag(*data_recuento)
sleep(1)
sleep(1.5)
self.app.controller.send_command("click_si")
sleep(3)
obj_recuento = Recuento.desde_tag(recuento)
en_db = self.get_db_for_mesa(obj_recuento.mesa)
for categoria in Categoria.all():
obj_recuento._resultados[(categoria.codigo, "BLC.BLC")] = \
obj_recuento._resultados[(categoria.codigo, "%s_BLC" %
categoria.codigo)]
del obj_recuento._resultados[(categoria.codigo, "%s_BLC" %
categoria.codigo)]
obj_recuento._resultados[(categoria.codigo, "NUL.NUL")] = \
obj_recuento.listas_especiales["NUL"]
obj_recuento._resultados[(categoria.codigo, "REC.REC")] = \
obj_recuento.listas_especiales["REC"]
obj_recuento._resultados[(categoria.codigo, "IMP.IMP")] = \
obj_recuento.listas_especiales["IMP"]
obj_recuento._resultados[(categoria.codigo, "TEC.TEC")] = \
obj_recuento.listas_especiales["TEC"]
self.iguales(obj_recuento._resultados, en_db)
try:
self.app.controller._salir_definitivo()
except RuntimeError:
pass
def dict_set_categorias(self):
"""Envia el diccionario con los datos de las categorias."""
categorias = Categoria.all().to_dict()
return categorias
def _precache_categorias(self):
sleep(0.1)
for categoria in Categoria.all():
self._get_candidatos_categoria(categoria.codigo, None)
