def configurar(self):
# Inicio la configuración de la mesa.
if not USAR_CEF:
self._descargar_ui_web()
self.controller = ControllerInteraccion(self, E_MESAYPIN)
self._cargar_ui_inicio()
self.estado = E_EN_CONFIGURACION
def __init__(self):
"""Constructor"""
self.es_modulo_web = True
self.web_template = "apertura"
self.rampa = RampaApertura(self)
self.controller = ControllerInteraccion(self, modulo=MODULO_APERTURA)
self._mensaje = None
Modulo.__init__(self)
self.ret_code = MODULO_APERTURA
self.estado = E_INICIAL
self._cargar_ui_apertura()
def __init__(self):
"""Constructor"""
self.es_modulo_web = True
self.web_template = "apertura"
self.rampa = RampaApertura(self)
self.controller = ControllerInteraccion(self, modulo=MODULO_APERTURA)
self._mensaje = None
Modulo.__init__(self)
self.ret_code = MODULO_APERTURA
self.estado = E_INICIAL
self._cargar_ui_apertura()
def __init__(self):
"""Constructor"""
# Importante antes de inicializar el modulo, limpiar la configuracion
self._limpiar_configuracion()
self.mute_armve_ver_1()
self.controller = ControllerInicio(self)
self.es_modulo_web = True
self.web_template = "inicio"
Modulo.__init__(self)
self.ret_code = MODULO_INICIO
self.loop_lector = True
self._vaciar_impresora()
self.estado = E_INICIAL
self.dialogo = None
self._bind_term()
self.manejar_desconexion()
self.rampa = RampaInicio(self)
gobject.idle_add(self._dump_check)
class ModuloInicio(Modulo):
""" Modulo de Inicio.
Hereda de: ModuloLector
Este módulo muestra la pantalla de bienvenida y realiza el proceso de
configuracion de una mesa.
El usuario debe pasar el tag de presidente o de MSA para habilitar el
comienzo de la configuración.
Luego se le pedirá un PIN y el modulo configurará la mesa para la
ubicación solicitada.
"""
def __init__(self):
"""Constructor"""
# Importante antes de inicializar el modulo, limpiar la configuracion
self._limpiar_configuracion()
self.mute_armve_ver_1()
self.controller = ControllerInicio(self)
self.es_modulo_web = True
self.web_template = "inicio"
Modulo.__init__(self)
self.ret_code = MODULO_INICIO
self.loop_lector = True
self._vaciar_impresora()
self.estado = E_INICIAL
self.dialogo = None
self._bind_term()
self.manejar_desconexion()
self.rampa = RampaInicio(self)
gobject.idle_add(self._dump_check)
def mute_armve_ver_1(self):
if USA_ARMVE:
machine_number = sesion.agent.get_machine_type()
if machine_number == 1:
system('/usr/bin/amixer -c 0 sset "Auto-Mute Mode" Disabled')
def _cargar_ui_inicio(self):
Modulo._cargar_ui_web(self)
self._inicio()
self.controller.set_pantalla()
self.ventana.show_all()
def _bind_term(self):
try:
keybinder.bind('<Control><Alt>X', self.abrir_terminal)
except (KeyError, NameError):
pass
def set_pantalla(self, pantalla):
self.controller.set_screen(pantalla)
def show_dialogo(self, mensaje=None, callback_cancelar=None,
callback_aceptar=None, btn_cancelar=False,
btn_aceptar=False):
self.controller.show_dialogo(mensaje, callback_cancelar,
callback_aceptar, btn_cancelar,
btn_aceptar)
def hide_dialogo(self):
self.controller.hide_dialogo()
def _inicio(self):
""" Funcion llamada desde el controller"""
self.controller.send_constants()
def manejar_desconexion(self):
def mostrar_dialogo(estado):
if not estado and self.dialogo is None:
if USA_ARMVE:
self.dialogo = MsgDialog(_("arm_no_responde"),
MsgDialog.WARNING, MsgDialog.OK,
self.apagar)
else:
self.dialogo = MsgDialog(_("impresora_desconectada"),
MsgDialog.WARNING, MsgDialog.NONE)
self.dialogo.show()
elif estado and self.dialogo is not None:
self.dialogo.hide()
self.dialogo = None
if sesion.impresora is None or not sesion.impresora.estado():
mostrar_dialogo(False)
if sesion.impresora is not None:
sesion.impresora.connection(mostrar_dialogo)
def _vaciar_impresora(self):
impresora = sesion.impresora
if impresora is not None and impresora.estado() and \
impresora.tarjeta_ingresada():
impresora.expulsar_boleta()
def _pantalla_principal(self):
self.controller.set_screen("pantalla_inicio")
def a_demo(self):
self.ret_code = MODULO_DEMO
self.quit()
def configurar(self):
# Inicio la configuración de la mesa.
if not USAR_CEF:
self._descargar_ui_web()
self.controller = ControllerInteraccion(self, E_MESAYPIN)
self._cargar_ui_inicio()
self.estado = E_EN_CONFIGURACION
def abrir_mesa(self, datos_tag):
mesa = datos_tag.split(';')[0]
self._validar_configuracion(mesa=mesa, pin=None,
con_acta_apertura=True,
datos_tag=datos_tag)
def _validar_configuracion(self, mesa=None, pin=None,
con_acta_apertura=False, datos_tag=''):
""" Recibe el numero de mesa y el pin de la pantalla de configuración y
verifica que sea correcto.
Si es *con_acta_apertura* se carga la mesa automaticamente y con
datos tag carga los datos del presidente
Si es correcto configura la mesa para dejarla operativa y pasa al
menú de administración, en otro caso presenta la pantalla
principal.
"""
mesa_obj = Ubicacion.one(numero=mesa)
if mesa_obj is not None and \
(pin is not None and
hashlib.sha1(pin).hexdigest() == mesa_obj.pin or
con_acta_apertura):
self._mesa = mesa_obj
# Le seteo el atributo abierta si la configuracion de la mesa fue
# con el acta de apertura
self._configurar_mesa()
if con_acta_apertura:
apertura = Apertura.desde_tag(datos_tag)
sesion.apertura = apertura
self.estado = E_CONFIGURADA
self.ret_code = MODULO_ADMIN
if self.rampa.tiene_papel:
self.rampa.expulsar_boleta()
gobject.idle_add(self.quit)
else:
if sesion.lector is None:
msg = _("error_conectar_lector")
else:
msg = _("mesa_pin_incorrectos")
mensaje = {"aclaracion": msg}
self.estado = E_INICIAL
self.ventana.remove(self.ventana.children()[0])
self._cargar_ui_web()
self.ventana.show_all()
self._pantalla_principal()
self.show_dialogo(mensaje, btn_aceptar=True)
def _configurar_mesa(self):
# Configura la ubicacion actual del modulo.
sesion.mesa = self._mesa
def _limpiar_configuracion(self):
# Reinicio todos los valores
sesion.mesa = None
sesion.apertura = None
sesion.recuento = None
def calibrar_pantalla(self):
""" Sale del módulo de inicio y envia la orden de calibrar pantalla """
self.ret_code = MODULO_CALIBRADOR
self.quit()
def _dump_check(self):
""" Chequeo que el sistema no haya reiniciado previamente """
if os.path.exists(DUMP_FILE_REINICIO):
try:
dump_file = open(DUMP_FILE_REINICIO, 'r')
dump_data = cPickle.load(dump_file)
except:
pass
else:
mesa = dump_data.split(';')[0]
if mesa != '':
self._validar_configuracion(mesa=mesa, pin=None,
con_acta_apertura=True,
datos_tag=dump_data)
finally:
dump_file.close()
os.remove(DUMP_FILE_REINICIO)
return False # Se ejecuta una vez
def apagar(self):
""" Sale del módulo de inicio y envia la orden de apagado """
self.ret_code = 'shutdown'
gobject.idle_add(self.quit)
def abrir_terminal(self):
if DEBUG:
sesion.logger.debug('abrir terminal')
pop = Popen('xterm')
def _btn_apagar_clicked(self, w=None):
""" Llamo al callback para apagar la maquina en su totalidad.
"""
mensaje = {"pregunta": _("esta_seguro_apagar")}
self.show_dialogo(mensaje,
btn_aceptar=True,
btn_cancelar=True,
callback_aceptar=self.apagar,
callback_cancelar=None)
def _cargar_controller_interaccion(self):
self.controller = ControllerInteraccion(self,
modulo=MODULO_TOTALIZADOR)
class ModuloTotalizador(ModuloRecuento):
controller_recuento = ControllerTotalizador
def _cargar_controller_interaccion(self):
self.controller = ControllerInteraccion(self,
modulo=MODULO_TOTALIZADOR)
def _procesar_tag(self, tag, datos):
""" Evento. Procesa el tag recibido por parametro. Cumple la funcion
del procesar_tag() de PantallaRecuento de recuento Gtk.
Argumentos:
tag -- El objeto TAG recibido.
datos -- Los datos almacenados en el tag recibido.
Si el tag no es ICODE se descarta el evento.
Si su tipo no es voto, o está vacío, se devuelve error.
Se intenta sumar los datos al recuento, si devuelve False
es porque el tag ya fue sumado, sino está ok.
"""
# TODO: Rever esta logica cuando se implementen las pantallas
# anteriones en HTML
if self.estado == E_RECUENTO:
serial = tag['serial']
tipo_tag = tag['tipo']
if datos is None:
self.controller.set_panel_estado(RECUENTO_ERROR)
elif tipo_tag != TAG_RECUENTO:
if tipo_tag == TAG_ADMIN:
self.administrador()
else:
self.controller.set_panel_estado(RECUENTO_ERROR)
else:
try:
recuento = Recuento.desde_tag(datos)
if not sesion.recuento.serial_sumado(serial):
if sesion.recuento.mesa.cod_datos == \
recuento.mesa.cod_datos:
sesion.recuento.sumar_recuento(recuento, serial)
sesion.recuento.hora_fin = time.time()
sesion.ultima_seleccion = recuento
# Dibujo boleta
imagen = recuento.a_imagen(de_muestra=True,
svg=True)
image_data = quote(imagen.encode("utf-8"))
cant_leidas = sesion.recuento.boletas_contadas()
self.controller.actualizar_resultados(
sesion.ultima_seleccion, cant_leidas,
image_data)
gobject.timeout_add(
200, self.controller.set_panel_estado,
RECUENTO_OK)
else:
self.controller.set_panel_estado(RECUENTO_ERROR)
else:
self.controller.set_panel_estado(
RECUENTO_ERROR_REPETIDO)
except Exception as e:
print(e)
self.controller.set_panel_estado(RECUENTO_ERROR)
else:
if hasattr(self.controller, "procesar_tag"):
self.controller.procesar_tag(tag, datos)
def set_campos_extra(self, campos_recuento):
pass
def get_campos_extra(self):
campos_extra = []
campos_extra.append({
"codigo": "",
"titulo": _("boletas_procesadas"),
"editable": False,
"valor": sesion.recuento.boletas_contadas()
})
for lista in get_config("listas_especiales"):
campos_extra.append({
"codigo":
lista,
"titulo":
_("titulo_votos_%s" % lista[-3:]),
"editable":
False,
"valor":
sesion.recuento.listas_especiales[lista]
})
return campos_extra
def set_print_manager(self, callback):
ModuloRecuento.set_print_manager(self, callback)
self.print_manager.secuencia_certificados = \
SECUENCIA_CERTIFICADOS_TOTALIZACION
class ModuloApertura(Modulo):
""" Modulo de Apertura de votos.
Este módulo permite generar el acta de apertura de una mesa.
El usuario debe ingresar el acta en la maquina, agregar y confirmar sus
datos e imprimirla.
"""
def __init__(self):
"""Constructor"""
self.es_modulo_web = True
self.web_template = "apertura"
self.rampa = RampaApertura(self)
self.controller = ControllerInteraccion(self, modulo=MODULO_APERTURA)
self._mensaje = None
Modulo.__init__(self)
self.ret_code = MODULO_APERTURA
self.estado = E_INICIAL
self._cargar_ui_apertura()
def _cargar_ui_apertura(self):
pass
#self.controller._inicializa_pantalla()
def reiniciar_modulo(self):
self.estado = E_INICIAL
self.controller.estado = E_INGRESO_ACTA
self.controller._inicializa_pantalla()
def cargar_datos(self, apertura=None):
""" Callback de salida del estado inicial, que indica que se obtuvo un
tag de apertura. Ahora se pasa al estado de carga de datos,
solicita el ingreso de datos del Presidente de Mesa.
"""
self.estado = E_CARGA
self.controller.estado = E_INGRESO_DATOS
hora = None
autoridades = None
if apertura is not None:
hora = apertura.hora
autoridades = [(autoridad.a_dict()) for autoridad in \
apertura.autoridades]
self.controller.set_pantalla({"hora": hora,
"autoridades": autoridades})
def _configurar_mesa(self, datos_tag):
"""
Configura la mesa con los datos que contiene el tag.
"""
apertura = Apertura.desde_tag(datos_tag)
if apertura.mesa is not None:
sesion.apertura = apertura
sesion.mesa = apertura.mesa
sesion.impresora.expulsar_boleta()
sesion.impresora.consultar_tarjeta(lambda x: self.salir())
def crear_objeto(self, autoridades, hora):
"""
Recibe un instancia de Presidente de Mesa y del suplente con los datos
que cargo el usuario.
"""
self.apertura = Apertura(sesion.mesa, autoridades, hora)
self.estado = E_CONFIRMACION
self.controller.estado = E_CONFIRMACION
imagen_acta = self.apertura.a_imagen(svg=True, de_muestra=True)
imagen_data = quote(imagen_acta.encode("utf-8"))
self.controller.set_pantalla_confirmacion(imagen_data)
def confirmar_apertura(self):
if self.__guardar_e_imprimir():
self.estado = E_REGISTRANDO
def _inner(printer_status=None):
sesion.impresora.remover_boleta_expulsada()
sesion.impresora.remover_insertando_papel()
self.salir()
if USA_ARMVE:
sesion.impresora.registar_boleta_expulsada(_inner)
else:
sesion.impresora.registrar_insertando_papel(_inner)
else:
tag = self.rampa.datos_tag
self.controller.msg_error_apertura(tag)
def __guardar_e_imprimir(self):
""" Función que se encarga primero de guardar los datos y corroborar
que esté todo ok.
Si es así imprime y devuelve True o False en cualquier caso
contrario
"""
tag = self.rampa.datos_tag
if not tag or not sesion.impresora:
return False
# Chequeo que el tag esté vacío
datos_tag = tag['datos']
if datos_tag != '':
return False
# Todo ok, guardo el acta de apertura, si devuelve True, imprimo.
if self._guardar_apertura():
sesion.apertura = self.apertura
self._imprimir_acta()
def esperar_vacia(tiene_tarjeta):
if not tiene_tarjeta:
sesion.impresora.remover_consultar_tarjeta()
self.salir()
sesion.impresora.consultar_tarjeta(esperar_vacia)
return True
else:
return False
def _guardar_apertura(self):
""" Guarda los datos en el tag, lo vuelve a leer y compara los dos
strings para verificar la correcta escritura.
Devuelve True si el guardado y la comprobación están correctos,
False en caso contrario.
"""
guardado_ok = False
if USA_ARMVE:
datos = self.apertura.a_tag()
marcar_ro = QUEMA
guardado_ok = sesion.lector.guardar_tag(TAG_APERTURA, datos,
marcar_ro)
else:
datos1 = self.apertura.a_tag()
tag_grabado = self._guarda_tag(datos1)
if tag_grabado:
datos2 = self._lee_tag()
if datos1 == datos2:
guardado_ok = True
return guardado_ok
def _guarda_tag(self, datos):
""" Esta función guarda los datos en el tag """
# Intenta guardar el tag devolviendo True o False si pudo o no.
# Ciclo hasta encontrar un tag
tag = self.rampa.datos_tag
if not tag:
return False
# No puedo grabar si el tag ya tiene algo
if tag['datos'] != '':
return False
# Intento grabar, si algo sale mal salgo con error.
try:
#datos = datos.encode('utf-8')
sesion.lector.escribe_datos(tag, datos, TAG_APERTURA)
except Exception as e:
sesion.logger.exception(e)
return False
# Si llegue hasta aca, es porque pude guardar los datos sin problemas.
return True
def _lee_tag(self):
""" Función para obtener un tag y devolver sus datos o vacío """
if USA_ARMVE:
tag = self.rampa.datos_tag
else:
tag = sesion.lector.get_tag()
datos = tag['datos']
return datos
def _imprimir_acta(self):
tipo_tag = self.apertura.__class__.__name__
tag = self.apertura.a_tag()
sesion.impresora.posicionar_al_inicio()
sesion.impresora.imprimir_serializado(tipo_tag, b64encode(tag))
if not USA_ARMVE:
time.sleep(15)
def mensaje_inicial(self):
self.apertura = None
self.controller.mensaje_inicial()
def volver(self, apertura):
"""Vuelve a la pantalla de inicial"""
self.cargar_datos(apertura)
def salir(self):
""" Sale del módulo de apertura, vuelve al comienzo con la maquina
desconfigurada
"""
if hasattr(self, 'pantalla') and self.pantalla is not None:
self.pantalla.destroy()
if self.browser is not None:
self.ventana.remove(self.browser)
sesion.lector.remover_consultar_lector()
self.ret_code = MODULO_ADMIN
self.quit()
def procesar_tag(self, tag_dict):
read_only = tag_dict.get("read_only")
if tag_dict['datos'] == '' and not read_only:
if self.controller.estado == E_INGRESO_ACTA:
self.cargar_datos()
else:
self.controller.set_mensaje(_("acta_contiene_informacion"))
sesion.impresora.expulsar_boleta()
def _cargar_controller_interaccion(self):
self.controller = ControllerInteraccion(self)
class ModuloRecuento(Modulo):
""" Modulo de Recuento de votos.
Este módulo permite hacer el recuento de votos de una mesa.
El usuario debe pasar el tag a ser utilizado para el recuento de la
mesa, y a continuacion debe pasar todas las boletas por el lector.
El sistema va a totalizarlas y una vez que el usuario confirme el
cierre de la mesa, emite un listado con la cantidad de copias
indicadas.
E_INICIAL = 0
E_SETUP = 1
E_RECUENTO = 2
E_RESULTADO = 3
E_VERIFICACION = 4
"""
controller_recuento = ControllerRecuento
def __init__(self):
"""Constructor"""
self.send_function = None
# El primer controller es ControllerInteraccion porque es el que maneja
# el ingreso de datos de mesa y pin y autoridades
self.web_template = "recuento"
self._cargar_controller_interaccion()
self.es_modulo_web = True
Modulo.__init__(self)
self.ret_code = MODULO_RECUENTO
self.estado = E_INICIAL
self._intento = 0
self._ui_web_activa = True # Flag que indica si esta activa la ui web
self.apertura = None
"""
if USA_ARMVE:
power_source = sesion.powermanager.get_power_source()
if power_source is not None and not power_source['byte']:
sesion.fancoolers.set_fan_auto_mode(False)
sesion.fancoolers.set_fan_speed(100)
"""
self.rampa = RampaRecuento(self)
def _cargar_controller_interaccion(self):
self.controller = ControllerInteraccion(self)
def _cargar_ui_web(self):
Modulo._cargar_ui_web(self)
def _cargar_ui_recuento(self):
Modulo._cargar_ui_web(self)
self.ventana.show_all()
def reiniciar_modulo(self):
if self.rampa.tiene_papel and self.estado == E_SETUP:
pass
else:
self.estado = E_INICIAL
self.controller.estado = E_INGRESO_ACTA
self.controller._inicializa_pantalla()
def _inicio(self):
""" Funcion llamada desde el controller una vez que se encuentra lista
la interfaz web
"""
self.controller.set_panel_estado(RECUENTO_NO_TAG)
if self.estado == E_RECUENTO:
#self.controller.set_pantalla_recuento()
pass
elif self.estado == E_VERIFICACION:
self.print_manager.callback = self.print_manager.reset_copias
sesion.recuento.autoridades = None
#self.controller.set_pantalla_revision()
def procesar_tag(self, tag_dict):
""" Evento. Procesa el tag recibido por parametro. Cumple la funcion
del procesar_tag() de PantallaRecuento de recuento Gtk.
Argumentos:
tag -- El objeto TAG recibido.
datos -- Los datos almacenados en el tag recibido.
Si el tag no es ICODE se descarta el evento.
Si su tipo no es voto, o está vacío, se devuelve error.
Se intenta sumar los datos al recuento, si devuelve False
es porque el tag ya fue sumado, sino está ok.
"""
if self.estado == E_RECUENTO:
serial = tag_dict.get('serial')
tipo_tag = tag_dict.get('tipo')
datos = tag_dict.get('datos')
if None in (serial, tipo_tag, datos) or tipo_tag != TAG_VOTO:
self.controller.set_panel_estado(RECUENTO_ERROR)
else:
self.controller.hide_dialogo()
try:
seleccion = Seleccion.desde_tag(datos,
sesion.mesa)
if not sesion.recuento.serial_sumado(serial):
sesion.recuento.sumar_seleccion(seleccion, serial)
sesion.recuento.hora_fin = time.time()
sesion.ultima_seleccion = seleccion
# Dibujo boleta
imagen = seleccion.a_imagen(verificador=False,
solo_mostrar=True,
svg=True)
image_data = quote(imagen.encode("utf-8"))
cant_leidas = sesion.recuento.boletas_contadas()
self.controller.actualizar_resultados(
sesion.ultima_seleccion, cant_leidas, image_data)
gobject.timeout_add(200,
self.controller.set_panel_estado,
RECUENTO_OK)
else:
self.controller.set_panel_estado(
RECUENTO_ERROR_REPETIDO)
except Exception as e:
print(e)
self.controller.set_panel_estado(RECUENTO_ERROR)
elif self.controller.__class__.__name__ == "ControllerInteraccion":
read_only = tag_dict.get("read_only")
if self.rampa.tiene_papel and not read_only and self.estado not in \
(E_SETUP, E_VERIFICACION) and tag_dict['tipo'] in \
(TAG_VACIO, [0, 0]):
self.estado = E_SETUP
self.controller.estado = E_MESAYPIN
self.controller.set_pantalla()
self.posicion_recuento()
elif self.estado in E_INICIAL and tag_dict['tipo'] == TAG_RECUENTO:
sesion.recuento = Recuento.desde_tag(tag_dict['datos'])
sesion.mesa = sesion.recuento.mesa
def _inner():
if self.rampa.tiene_papel:
self.rampa.expulsar_boleta()
self.revision_recuento()
gobject.timeout_add(1000, _inner)
else:
def _expulsar():
if self.rampa.tiene_papel and self.rampa.datos_tag and self.estado != E_SETUP:
self.controller.set_mensaje(_("acta_contiene_informacion"))
self.rampa.expulsar_boleta()
gobject.timeout_add(300, _expulsar)
def _show_pantalla_inicial(self):
self.controller._inicializa_pantalla()
def set_print_manager(self, callback):
self.print_manager = PrintManager(self, callback)
def revision_recuento(self):
self.estado = E_VERIFICACION
if not USAR_CEF:
self._descargar_ui_web()
self.controller = self.controller_recuento(self)
self.set_print_manager(self.controller
.set_pantalla_impresion_certificados)
self.print_manager.callback = self.print_manager.reset_copias
self._cargar_ui_recuento()
self.controller.set_pantalla_impresion_certificados()
self.habilitar_impresion_certificados()
self.copiar_certificados()
sesion.impresora.remover_consultar_tarjeta()
if USA_ARMVE:
self.rampa.registrar_nuevo_papel(
self._impresion_copias_certificados)
else:
self.rampa.remover_nuevo_papel()
sesion.impresora.registrar_insertando_papel(
self._impresion_copias_certificados)
def ingreso_papel(self):
self.estado = E_SETUP
def posicion_recuento(self):
if USA_ARMVE:
sesion.impresora.linefeed(DESPLAZAMIENTO_BOLETA * 4)
else:
sesion.impresora.backfeed(DESPLAZAMIENTO_BOLETA)
def guardar_datos_del_presidente(self, autoridades, hora):
"""
Recibe un instancia de Presidente de Mesa, con los datos que cargo el
usuario.
"""
#sesion.impresora.remover_consultar_tarjeta()
sesion.recuento = Recuento(sesion.mesa, autoridades, hora)
sesion.mesa = sesion.recuento.mesa
self.estado = E_RECUENTO
if not USAR_CEF:
self._descargar_ui_web()
self.controller = self.controller_recuento(self)
self.set_print_manager(self.controller.set_pantalla_asistente_cierre)
# Cargamos la interfaz web, lo que inicia la pantalla recuento.
self._cargar_ui_recuento()
def ver_acta_de_cierre(self):
""" Callback de salida del estado de recuento, es cuando el usuario
presiona 'Terminar escrutinio'."""
self.estado = E_RESULTADO
self.controller.set_pantalla_confirmacion()
def _finalizar(self):
""" Funcion llamada desde el controller cuando se desea finalizar el
recuento"""
if sesion.recuento.boletas_contadas() < MINIMO_BOLETAS_RECUENTO:
mensaje = {
"alerta": _("pocas_boletas_alerta") % MINIMO_BOLETAS_RECUENTO,
"pregunta": _("pocas_boletas_pregunta"),
"aclaracion": _("pocas_boletas_aclaracion")}
self.show_dialogo(mensaje=mensaje,
btn_cancelar=True,
btn_aceptar=True,
callback_aceptar=self.ver_acta_de_cierre,
callback_cancelar=None)
else:
self.ver_acta_de_cierre()
def _imprimir(self):
""" Pide confirmación del usuario para guardar e imprimir los
resultados mostrados """
mensaje = {"pregunta": _("esta_seguro_acta_cierre")}
self.show_dialogo(mensaje=mensaje,
btn_cancelar=True,
btn_aceptar=True,
callback_aceptar=self._iniciar_impresion,
callback_cancelar=self.controller.cancelar_impresion)
def _iniciar_impresion(self):
""" Realiza las ultimas operaciones sobre el recuento antes de comenzar
la impresion
"""
def pre_impresion(tipo_acta):
self.controller.mostrar_imprimiendo(tipo_acta)
self.controller.hide_dialogo()
def esperando_papel(tipo_acta):
self.controller.pedir_acta(tipo_acta[0])
self.print_manager.imprimir_secuencia(
False, pre_impresion, waiting_paper_callback=esperando_papel)
def _lee_tag(self):
""" Función para obtener un tag y devolver sus datos o vacío """
if USA_ARMVE:
tag = self.rampa.datos_tag
else:
tag = sesion.lector.get_tag()
try:
datos = tag['datos']
except:
datos = ''
return datos
def set_campos_extra(self, campos_recuento):
for lista in get_config("listas_especiales"):
sesion.recuento.actualizar_lista_especial(lista,
campos_recuento[lista])
def get_campos_extra(self):
campos_extra = []
campos_extra.append({"codigo": "",
"titulo": _("boletas_procesadas"),
"editable": False,
"valor": sesion.recuento.boletas_contadas()})
for lista in get_config("listas_especiales"):
campos_extra.append(
{"codigo": lista,
"titulo": _("titulo_votos_%s" % lista[-3:]),
"editable": True,
"valor": sesion.recuento.listas_especiales[lista]})
total = 0
for campo in campos_extra:
total += campo.get('valor', 0)
campos_extra.append({"codigo": COD_TOTAL,
"titulo": _("total_general"),
"editable": False,
"valor": total})
return campos_extra
def copiar_certificados(self):
""" Callback de salida del estado de recuento, es cuando el usuario
comienza la copia de certificados."""
self.estado = E_RESULTADO
self.print_manager.callback = self.print_manager.reset_copias
self.controller.set_pantalla_impresion_certificados()
self.habilitar_impresion_certificados()
def habilitar_impresion_certificados(self):
if USA_ARMVE:
self.rampa.registrar_nuevo_papel(
self._impresion_copias_certificados)
else:
sesion.impresora.registrar_insertando_papel(
self._impresion_copias_certificados)
def _impresion_copias_certificados(self, datos_sensores):
self.controller.deshabilitar_botones()
self.controller.set_panel_estado(RECUENTO_GENERANDO)
def _inner():
tag = self.rampa.datos_tag
if not tag:
if self.estado == E_RESULTADO:
# Si estoy imprimiendo certificados extra despues de un
# recuento completo seteo los callback para dar
# feedback
def pre_impresion(tipo_acta):
pass
def post_impresion(tipo_acta):
pass
def esperando_papel(tipo_acta):
pass
self.print_manager.imprimir_secuencia(True,
pre_impresion,
post_impresion,
esperando_papel)
else:
# En otro caso (levanto un recuento ya grabado) solo
# mando a imprimir la secuencia.
self.print_manager.imprimir_secuencia(True)
else:
self.rampa.expulsar_boleta()
self.controller.habilitar_botones()
self.controller.limpiar_panel_estado()
mensaje = {"alerta": _("certificado_no_impreso_alerta"),
"aclaracion": _(
"certificado_no_impreso_aclaracion")}
self.show_dialogo(mensaje=mensaje, btn_aceptar=True)
gobject.timeout_add(200, _inner)
def cargar_apertura(self, tag_dict):
apertura = Apertura.desde_tag(tag_dict['datos'])
if (self.controller.estado == E_INGRESO_DATOS and
sesion.mesa.numero == apertura.mesa.numero) or \
self.controller.estado != E_INGRESO_DATOS:
self.apertura = apertura
self.controller.set_pantalla({"mesa": apertura.mesa.numero})
def salir(self):
""" Sale del módulo de recuento, vuelve al comienzo con la maquina
desconfigurada."""
mensaje = {"pregunta": _("seguro_salir_recuento")}
self.show_dialogo(mensaje=mensaje,
btn_aceptar=True,
btn_cancelar=True,
callback_aceptar=self.quit,
callback_cancelar=None,
error=False)
def quit(self, w=None):
#self._stop_audio()
self.ret_code = MODULO_INICIO
#self._descargar_ui_web()
Modulo.quit(self)
def mensaje_inicial(self):
if hasattr(self.controller, "mensaje_inicial"):
self.controller.mensaje_inicial()
def volver(self, admin=False, tag=None, datos_tag=None):
""" Callback para volver del estado de resultado al de recuento y
seguir recontando votos."""
if admin is True or self.estado == E_RECUENTO:
self.administrador()
else:
self.estado = E_RECUENTO
self.controller.set_pantalla_recuento()
if tag is not None and datos_tag is not None:
self._tag_disponible(self.TAG_DATOS, tag, datos_tag)
def administrador(self, callback_ok=None, callback_cancel=None):
mensaje = {"pregunta": _("seguro_salir_recuento")}
self.show_dialogo(mensaje=mensaje,
btn_aceptar=True,
btn_cancelar=True,
callback_aceptar=self.salir_a_administrador,
callback_cancelar=None)
def salir_a_administrador(self):
if self._ui_web_activa:
self._descargar_ui_web()
#self._cargar_ui()
self.rampa.desregistrar_eventos()
sesion.recuento = None
self.rampa.expulsar_boleta()
self._stop_audio()
self.admin()
def _stop_audio(self):
global _audio_player
if _audio_player is not None:
_audio_player.stop()
def show_dialogo(self, mensaje=None, callback_cancelar=None,
callback_aceptar=None, btn_cancelar=None,
btn_aceptar=None, error=True):
self.controller.show_dialogo(mensaje, callback_cancelar,
callback_aceptar, btn_cancelar,
btn_aceptar, error=error)
def _cargar_controller_interaccion(self):
self.controller = ControllerInteraccion(self,
modulo=MODULO_TOTALIZADOR)
class ModuloTotalizador(ModuloRecuento):
controller_recuento = ControllerTotalizador
def _cargar_controller_interaccion(self):
self.controller = ControllerInteraccion(self,
modulo=MODULO_TOTALIZADOR)
def _procesar_tag(self, tag, datos):
""" Evento. Procesa el tag recibido por parametro. Cumple la funcion
del procesar_tag() de PantallaRecuento de recuento Gtk.
Argumentos:
tag -- El objeto TAG recibido.
datos -- Los datos almacenados en el tag recibido.
Si el tag no es ICODE se descarta el evento.
Si su tipo no es voto, o está vacío, se devuelve error.
Se intenta sumar los datos al recuento, si devuelve False
es porque el tag ya fue sumado, sino está ok.
"""
# TODO: Rever esta logica cuando se implementen las pantallas
# anteriones en HTML
if self.estado == E_RECUENTO:
serial = tag['serial']
tipo_tag = tag['tipo']
if datos is None:
self.controller.set_panel_estado(RECUENTO_ERROR)
elif tipo_tag != TAG_RECUENTO:
if tipo_tag == TAG_ADMIN:
self.administrador()
else:
self.controller.set_panel_estado(RECUENTO_ERROR)
else:
try:
recuento = Recuento.desde_tag(datos)
if not sesion.recuento.serial_sumado(serial):
if sesion.recuento.mesa.cod_datos == \
recuento.mesa.cod_datos:
sesion.recuento.sumar_recuento(recuento, serial)
sesion.recuento.hora_fin = time.time()
sesion.ultima_seleccion = recuento
# Dibujo boleta
imagen = recuento.a_imagen(de_muestra=True,
svg=True)
image_data = quote(imagen.encode("utf-8"))
cant_leidas = sesion.recuento.boletas_contadas()
self.controller.actualizar_resultados(
sesion.ultima_seleccion,
cant_leidas, image_data)
gobject.timeout_add(
200,
self.controller.set_panel_estado, RECUENTO_OK)
else:
self.controller.set_panel_estado(RECUENTO_ERROR)
else:
self.controller.set_panel_estado(
RECUENTO_ERROR_REPETIDO)
except Exception as e:
print(e)
self.controller.set_panel_estado(RECUENTO_ERROR)
else:
if hasattr(self.controller, "procesar_tag"):
self.controller.procesar_tag(tag, datos)
def set_campos_extra(self, campos_recuento):
pass
def get_campos_extra(self):
campos_extra = []
campos_extra.append({"codigo": "",
"titulo": _("boletas_procesadas"),
"editable": False,
"valor": sesion.recuento.boletas_contadas()})
for lista in get_config("listas_especiales"):
campos_extra.append(
{"codigo": lista,
"titulo": _("titulo_votos_%s" % lista[-3:]),
"editable": False,
"valor": sesion.recuento.listas_especiales[lista]})
return campos_extra
def set_print_manager(self, callback):
ModuloRecuento.set_print_manager(self, callback)
self.print_manager.secuencia_certificados = \
SECUENCIA_CERTIFICADOS_TOTALIZACION
class ModuloApertura(Modulo):
""" Modulo de Apertura de votos.
Este módulo permite generar el acta de apertura de una mesa.
El usuario debe ingresar el acta en la maquina, agregar y confirmar sus
datos e imprimirla.
"""
def __init__(self):
"""Constructor"""
self.es_modulo_web = True
self.web_template = "apertura"
self.rampa = RampaApertura(self)
self.controller = ControllerInteraccion(self, modulo=MODULO_APERTURA)
self._mensaje = None
Modulo.__init__(self)
self.ret_code = MODULO_APERTURA
self.estado = E_INICIAL
self._cargar_ui_apertura()
def _cargar_ui_apertura(self):
pass
#self.controller._inicializa_pantalla()
def reiniciar_modulo(self):
self.estado = E_INICIAL
self.controller.estado = E_INGRESO_ACTA
self.controller._inicializa_pantalla()
def cargar_datos(self, apertura=None):
""" Callback de salida del estado inicial, que indica que se obtuvo un
tag de apertura. Ahora se pasa al estado de carga de datos,
solicita el ingreso de datos del Presidente de Mesa.
"""
self.estado = E_CARGA
self.controller.estado = E_INGRESO_DATOS
hora = None
autoridades = None
if apertura is not None:
hora = apertura.hora
autoridades = [(autoridad.a_dict()) for autoridad in \
apertura.autoridades]
self.controller.set_pantalla({
"hora": hora,
"autoridades": autoridades
})
def _configurar_mesa(self, datos_tag):
"""
Configura la mesa con los datos que contiene el tag.
"""
apertura = Apertura.desde_tag(datos_tag)
if apertura.mesa is not None:
sesion.apertura = apertura
sesion.mesa = apertura.mesa
sesion.impresora.expulsar_boleta()
sesion.impresora.consultar_tarjeta(lambda x: self.salir())
def crear_objeto(self, autoridades, hora):
"""
Recibe un instancia de Presidente de Mesa y del suplente con los datos
que cargo el usuario.
"""
self.apertura = Apertura(sesion.mesa, autoridades, hora)
self.estado = E_CONFIRMACION
self.controller.estado = E_CONFIRMACION
imagen_acta = self.apertura.a_imagen(svg=True, de_muestra=True)
imagen_data = quote(imagen_acta.encode("utf-8"))
self.controller.set_pantalla_confirmacion(imagen_data)
def confirmar_apertura(self):
if self.__guardar_e_imprimir():
self.estado = E_REGISTRANDO
def _inner(printer_status=None):
sesion.impresora.remover_boleta_expulsada()
sesion.impresora.remover_insertando_papel()
self.salir()
if USA_ARMVE:
sesion.impresora.registar_boleta_expulsada(_inner)
else:
sesion.impresora.registrar_insertando_papel(_inner)
else:
tag = self.rampa.datos_tag
self.controller.msg_error_apertura(tag)
def __guardar_e_imprimir(self):
""" Función que se encarga primero de guardar los datos y corroborar
que esté todo ok.
Si es así imprime y devuelve True o False en cualquier caso
contrario
"""
tag = self.rampa.datos_tag
if not tag or not sesion.impresora:
return False
# Chequeo que el tag esté vacío
datos_tag = tag['datos']
if datos_tag != '':
return False
# Todo ok, guardo el acta de apertura, si devuelve True, imprimo.
if self._guardar_apertura():
sesion.apertura = self.apertura
self._imprimir_acta()
def esperar_vacia(tiene_tarjeta):
if not tiene_tarjeta:
sesion.impresora.remover_consultar_tarjeta()
self.salir()
sesion.impresora.consultar_tarjeta(esperar_vacia)
return True
else:
return False
def _guardar_apertura(self):
""" Guarda los datos en el tag, lo vuelve a leer y compara los dos
strings para verificar la correcta escritura.
Devuelve True si el guardado y la comprobación están correctos,
False en caso contrario.
"""
guardado_ok = False
if USA_ARMVE:
datos = self.apertura.a_tag()
marcar_ro = not MODO_DEMO
guardado_ok = sesion.lector.guardar_tag(TAG_APERTURA, datos,
marcar_ro)
else:
datos1 = self.apertura.a_tag()
tag_grabado = self._guarda_tag(datos1)
if tag_grabado:
datos2 = self._lee_tag()
if datos1 == datos2:
guardado_ok = True
return guardado_ok
def _guarda_tag(self, datos):
""" Esta función guarda los datos en el tag """
# Intenta guardar el tag devolviendo True o False si pudo o no.
# Ciclo hasta encontrar un tag
tag = self.rampa.datos_tag
if not tag:
return False
# No puedo grabar si el tag ya tiene algo
if tag['datos'] != '':
return False
# Intento grabar, si algo sale mal salgo con error.
try:
#datos = datos.encode('utf-8')
sesion.lector.escribe_datos(tag, datos, TAG_APERTURA)
except Exception as e:
sesion.logger.exception(e)
return False
# Si llegue hasta aca, es porque pude guardar los datos sin problemas.
return True
def _lee_tag(self):
""" Función para obtener un tag y devolver sus datos o vacío """
if USA_ARMVE:
tag = self.rampa.datos_tag
else:
tag = sesion.lector.get_tag()
datos = tag['datos']
return datos
def _imprimir_acta(self):
tipo_tag = self.apertura.__class__.__name__
tag = self.apertura.a_tag()
sesion.impresora.posicionar_al_inicio()
sesion.impresora.imprimir_serializado(tipo_tag, b64encode(tag))
if not USA_ARMVE:
time.sleep(15)
def mensaje_inicial(self):
self.apertura = None
self.controller.mensaje_inicial()
def volver(self, apertura):
"""Vuelve a la pantalla de inicial"""
self.cargar_datos(apertura)
def salir(self):
""" Sale del módulo de apertura, vuelve al comienzo con la maquina
desconfigurada
"""
if hasattr(self, 'pantalla') and self.pantalla is not None:
self.pantalla.destroy()
if self.browser is not None:
self.ventana.remove(self.browser)
sesion.lector.remover_consultar_lector()
self.ret_code = MODULO_ADMIN
self.quit()
def procesar_tag(self, tag_dict):
read_only = tag_dict.get("read_only")
if tag_dict['datos'] == '' and not read_only:
if self.controller.estado == E_INGRESO_ACTA:
self.cargar_datos()
else:
self.controller.set_mensaje(_("acta_contiene_informacion"))
sesion.impresora.expulsar_boleta()
def _cargar_controller_interaccion(self):
self.controller = ControllerInteraccion(self)
class ModuloRecuento(Modulo):
""" Modulo de Recuento de votos.
Este módulo permite hacer el recuento de votos de una mesa.
El usuario debe pasar el tag a ser utilizado para el recuento de la
mesa, y a continuacion debe pasar todas las boletas por el lector.
El sistema va a totalizarlas y una vez que el usuario confirme el
cierre de la mesa, emite un listado con la cantidad de copias
indicadas.
E_INICIAL = 0
E_SETUP = 1
E_RECUENTO = 2
E_RESULTADO = 3
E_VERIFICACION = 4
"""
controller_recuento = ControllerRecuento
def __init__(self):
"""Constructor"""
self.send_function = None
# El primer controller es ControllerInteraccion porque es el que maneja
# el ingreso de datos de mesa y pin y autoridades
self.web_template = "recuento"
self._cargar_controller_interaccion()
self.es_modulo_web = True
Modulo.__init__(self)
self.ret_code = MODULO_RECUENTO
self.estado = E_INICIAL
self._intento = 0
self._ui_web_activa = True # Flag que indica si esta activa la ui web
self.apertura = None
"""
if USA_ARMVE:
power_source = sesion.powermanager.get_power_source()
if power_source is not None and not power_source['byte']:
sesion.fancoolers.set_fan_auto_mode(False)
sesion.fancoolers.set_fan_speed(100)
"""
self.rampa = RampaRecuento(self)
def _cargar_controller_interaccion(self):
self.controller = ControllerInteraccion(self)
def _cargar_ui_web(self):
Modulo._cargar_ui_web(self)
def _cargar_ui_recuento(self):
Modulo._cargar_ui_web(self)
self.ventana.show_all()
def reiniciar_modulo(self):
if self.rampa.tiene_papel and self.estado == E_SETUP:
pass
else:
self.estado = E_INICIAL
self.controller.estado = E_INGRESO_ACTA
self.controller._inicializa_pantalla()
def _inicio(self):
""" Funcion llamada desde el controller una vez que se encuentra lista
la interfaz web
"""
self.controller.set_panel_estado(RECUENTO_NO_TAG)
if self.estado == E_RECUENTO:
#self.controller.set_pantalla_recuento()
pass
elif self.estado == E_VERIFICACION:
self.print_manager.callback = self.print_manager.reset_copias
sesion.recuento.autoridades = None
#self.controller.set_pantalla_revision()
def procesar_tag(self, tag_dict):
""" Evento. Procesa el tag recibido por parametro. Cumple la funcion
del procesar_tag() de PantallaRecuento de recuento Gtk.
Argumentos:
tag -- El objeto TAG recibido.
datos -- Los datos almacenados en el tag recibido.
Si el tag no es ICODE se descarta el evento.
Si su tipo no es voto, o está vacío, se devuelve error.
Se intenta sumar los datos al recuento, si devuelve False
es porque el tag ya fue sumado, sino está ok.
"""
if self.estado == E_RECUENTO:
serial = tag_dict.get('serial')
tipo_tag = tag_dict.get('tipo')
datos = tag_dict.get('datos')
if None in (serial, tipo_tag, datos) or tipo_tag != TAG_VOTO:
self.controller.set_panel_estado(RECUENTO_ERROR)
else:
self.controller.hide_dialogo()
try:
seleccion = Seleccion.desde_tag(datos, sesion.mesa)
if not sesion.recuento.serial_sumado(serial):
sesion.recuento.sumar_seleccion(seleccion, serial)
sesion.recuento.hora_fin = time.time()
sesion.ultima_seleccion = seleccion
# Dibujo boleta
imagen = seleccion.a_imagen(verificador=False,
solo_mostrar=True,
svg=True)
image_data = quote(imagen.encode("utf-8"))
cant_leidas = sesion.recuento.boletas_contadas()
self.controller.actualizar_resultados(
sesion.ultima_seleccion, cant_leidas, image_data)
gobject.timeout_add(200,
self.controller.set_panel_estado,
RECUENTO_OK)
else:
self.controller.set_panel_estado(
RECUENTO_ERROR_REPETIDO)
except Exception as e:
print(e)
self.controller.set_panel_estado(RECUENTO_ERROR)
elif self.controller.__class__.__name__ == "ControllerInteraccion":
read_only = tag_dict.get("read_only")
if self.rampa.tiene_papel and not read_only and self.estado not in \
(E_SETUP, E_VERIFICACION) and tag_dict['tipo'] in \
(TAG_VACIO, [0, 0]):
self.estado = E_SETUP
self.controller.estado = E_MESAYPIN
self.controller.set_pantalla()
self.posicion_recuento()
elif self.estado in E_INICIAL and tag_dict['tipo'] == TAG_RECUENTO:
sesion.recuento = Recuento.desde_tag(tag_dict['datos'])
sesion.mesa = sesion.recuento.mesa
def _inner():
if self.rampa.tiene_papel:
self.rampa.expulsar_boleta()
self.revision_recuento()
gobject.timeout_add(1000, _inner)
else:
def _expulsar():
if self.rampa.tiene_papel and self.rampa.datos_tag and self.estado != E_SETUP:
self.controller.set_mensaje(
_("acta_contiene_informacion"))
self.rampa.expulsar_boleta()
gobject.timeout_add(300, _expulsar)
def _show_pantalla_inicial(self):
self.controller._inicializa_pantalla()
def set_print_manager(self, callback):
self.print_manager = PrintManager(self, callback)
def revision_recuento(self):
self.estado = E_VERIFICACION
if not USAR_CEF:
self._descargar_ui_web()
self.controller = self.controller_recuento(self)
self.set_print_manager(
self.controller.set_pantalla_impresion_certificados)
self.print_manager.callback = self.print_manager.reset_copias
self._cargar_ui_recuento()
self.controller.set_pantalla_impresion_certificados()
self.habilitar_impresion_certificados()
self.copiar_certificados()
sesion.impresora.remover_consultar_tarjeta()
if USA_ARMVE:
self.rampa.registrar_nuevo_papel(
self._impresion_copias_certificados)
else:
self.rampa.remover_nuevo_papel()
sesion.impresora.registrar_insertando_papel(
self._impresion_copias_certificados)
def ingreso_papel(self):
self.estado = E_SETUP
def posicion_recuento(self):
if USA_ARMVE:
sesion.impresora.linefeed(DESPLAZAMIENTO_BOLETA * 4)
else:
sesion.impresora.backfeed(DESPLAZAMIENTO_BOLETA)
def guardar_datos_del_presidente(self, autoridades, hora):
"""
Recibe un instancia de Presidente de Mesa, con los datos que cargo el
usuario.
"""
#sesion.impresora.remover_consultar_tarjeta()
sesion.recuento = Recuento(sesion.mesa, autoridades, hora)
sesion.mesa = sesion.recuento.mesa
self.estado = E_RECUENTO
if not USAR_CEF:
self._descargar_ui_web()
self.controller = self.controller_recuento(self)
self.set_print_manager(self.controller.set_pantalla_asistente_cierre)
# Cargamos la interfaz web, lo que inicia la pantalla recuento.
self._cargar_ui_recuento()
def ver_acta_de_cierre(self):
""" Callback de salida del estado de recuento, es cuando el usuario
presiona 'Terminar escrutinio'."""
self.estado = E_RESULTADO
self.controller.set_pantalla_confirmacion()
def _finalizar(self):
""" Funcion llamada desde el controller cuando se desea finalizar el
recuento"""
if sesion.recuento.boletas_contadas() < MINIMO_BOLETAS_RECUENTO:
mensaje = {
"alerta": _("pocas_boletas_alerta") % MINIMO_BOLETAS_RECUENTO,
"pregunta": _("pocas_boletas_pregunta"),
"aclaracion": _("pocas_boletas_aclaracion")
}
self.show_dialogo(mensaje=mensaje,
btn_cancelar=True,
btn_aceptar=True,
callback_aceptar=self.ver_acta_de_cierre,
callback_cancelar=None)
else:
self.ver_acta_de_cierre()
def _imprimir(self):
""" Pide confirmación del usuario para guardar e imprimir los
resultados mostrados """
mensaje = {"pregunta": _("esta_seguro_acta_cierre")}
self.show_dialogo(mensaje=mensaje,
btn_cancelar=True,
btn_aceptar=True,
callback_aceptar=self._iniciar_impresion,
callback_cancelar=self.controller.cancelar_impresion)
def _iniciar_impresion(self):
""" Realiza las ultimas operaciones sobre el recuento antes de comenzar
la impresion
"""
def pre_impresion(tipo_acta):
self.controller.mostrar_imprimiendo(tipo_acta)
self.controller.hide_dialogo()
def esperando_papel(tipo_acta):
self.controller.pedir_acta(tipo_acta[0])
self.print_manager.imprimir_secuencia(
False, pre_impresion, waiting_paper_callback=esperando_papel)
def _lee_tag(self):
""" Función para obtener un tag y devolver sus datos o vacío """
if USA_ARMVE:
tag = self.rampa.datos_tag
else:
tag = sesion.lector.get_tag()
try:
datos = tag['datos']
except:
datos = ''
return datos
def set_campos_extra(self, campos_recuento):
for lista in get_config("listas_especiales"):
sesion.recuento.actualizar_lista_especial(lista,
campos_recuento[lista])
def get_campos_extra(self):
campos_extra = []
campos_extra.append({
"codigo": "",
"titulo": _("boletas_procesadas"),
"editable": False,
"valor": sesion.recuento.boletas_contadas()
})
for lista in get_config("listas_especiales"):
campos_extra.append({
"codigo":
lista,
"titulo":
_("titulo_votos_%s" % lista[-3:]),
"editable":
True,
"valor":
sesion.recuento.listas_especiales[lista]
})
total = 0
for campo in campos_extra:
total += campo.get('valor', 0)
campos_extra.append({
"codigo": COD_TOTAL,
"titulo": _("total_general"),
"editable": False,
"valor": total
})
return campos_extra
def copiar_certificados(self):
""" Callback de salida del estado de recuento, es cuando el usuario
comienza la copia de certificados."""
self.estado = E_RESULTADO
self.print_manager.callback = self.print_manager.reset_copias
self.controller.set_pantalla_impresion_certificados()
self.habilitar_impresion_certificados()
def habilitar_impresion_certificados(self):
if USA_ARMVE:
self.rampa.registrar_nuevo_papel(
self._impresion_copias_certificados)
else:
sesion.impresora.registrar_insertando_papel(
self._impresion_copias_certificados)
def _impresion_copias_certificados(self, datos_sensores):
self.controller.deshabilitar_botones()
self.controller.set_panel_estado(RECUENTO_GENERANDO)
def _inner():
tag = self.rampa.datos_tag
if not tag:
if self.estado == E_RESULTADO:
# Si estoy imprimiendo certificados extra despues de un
# recuento completo seteo los callback para dar
# feedback
def pre_impresion(tipo_acta):
pass
def post_impresion(tipo_acta):
pass
def esperando_papel(tipo_acta):
pass
self.print_manager.imprimir_secuencia(
True, pre_impresion, post_impresion, esperando_papel)
else:
# En otro caso (levanto un recuento ya grabado) solo
# mando a imprimir la secuencia.
self.print_manager.imprimir_secuencia(True)
else:
self.rampa.expulsar_boleta()
self.controller.habilitar_botones()
self.controller.limpiar_panel_estado()
mensaje = {
"alerta": _("certificado_no_impreso_alerta"),
"aclaracion": _("certificado_no_impreso_aclaracion")
}
self.show_dialogo(mensaje=mensaje, btn_aceptar=True)
gobject.timeout_add(200, _inner)
def cargar_apertura(self, tag_dict):
apertura = Apertura.desde_tag(tag_dict['datos'])
if (self.controller.estado == E_INGRESO_DATOS and
sesion.mesa.numero == apertura.mesa.numero) or \
self.controller.estado != E_INGRESO_DATOS:
self.apertura = apertura
self.controller.set_pantalla({"mesa": apertura.mesa.numero})
def salir(self):
""" Sale del módulo de recuento, vuelve al comienzo con la maquina
desconfigurada."""
mensaje = {"pregunta": _("seguro_salir_recuento")}
self.show_dialogo(mensaje=mensaje,
btn_aceptar=True,
btn_cancelar=True,
callback_aceptar=self.quit,
callback_cancelar=None,
error=False)
def quit(self, w=None):
#self._stop_audio()
self.ret_code = MODULO_INICIO
#self._descargar_ui_web()
Modulo.quit(self)
def mensaje_inicial(self):
if hasattr(self.controller, "mensaje_inicial"):
self.controller.mensaje_inicial()
def volver(self, admin=False, tag=None, datos_tag=None):
""" Callback para volver del estado de resultado al de recuento y
seguir recontando votos."""
if admin is True or self.estado == E_RECUENTO:
self.administrador()
else:
self.estado = E_RECUENTO
self.controller.set_pantalla_recuento()
if tag is not None and datos_tag is not None:
self._tag_disponible(self.TAG_DATOS, tag, datos_tag)
def administrador(self, callback_ok=None, callback_cancel=None):
mensaje = {"pregunta": _("seguro_salir_recuento")}
self.show_dialogo(mensaje=mensaje,
btn_aceptar=True,
btn_cancelar=True,
callback_aceptar=self.salir_a_administrador,
callback_cancelar=None)
def salir_a_administrador(self):
if self._ui_web_activa:
self._descargar_ui_web()
#self._cargar_ui()
self.rampa.desregistrar_eventos()
sesion.recuento = None
self.rampa.expulsar_boleta()
self._stop_audio()
self.admin()
def _stop_audio(self):
global _audio_player
if _audio_player is not None:
_audio_player.stop()
def show_dialogo(self,
mensaje=None,
callback_cancelar=None,
callback_aceptar=None,
btn_cancelar=None,
btn_aceptar=None,
error=True):
self.controller.show_dialogo(mensaje,
callback_cancelar,
callback_aceptar,
btn_cancelar,
btn_aceptar,
error=error)
