def update(self):
if self.running:
timeout_add(time_rem(), self.update)
if self.local:
self.set_label(strftime(self.format))
else:
self.set_label(strftime(self.format, time.gmtime()))
def registrar(self, tag, solo_impimir=False, crypto_tag=None):
"""Registra un voto.
Argumentos:
tag -- el voto a registrar serializado como tag.
solo_impimir -- no guarda el tag, solo imprime.
"""
ret = {"status": "OK"}
marcar_ro = QUEMA
if solo_impimir:
tag_guardado = True
else:
if crypto_tag is None:
crypto_tag = tag
tag_guardado = self.guardar_tag(TAG_VOTO, crypto_tag, marcar_ro)
if tag_guardado:
def _inner():
seleccion = Seleccion.desde_string(tag)
self.imprimir_serializado("Seleccion", seleccion, True)
timeout_add(10, _inner)
else:
ret['status'] = "TAG_NO_GUARDADO"
return dumps(ret)
def updateMovingAnim(self, f1, t0, t1, v0, a1): t2 = now() f = self.movingF if f!=f1: return v1 = self.movingV if f==0 and v1==0: return timeout = movingKeyTimeoutFirst if t2-t0<movingKeyTimeoutFirst else movingKeyTimeout if f!=0 and t2 - self.movingLastPress >= timeout:## Stopping f = self.movingF = 0 if v1 > 0: a2 = f - movingFrictionForce elif v1 < 0: a2 = f + movingFrictionForce else: a2 = f if a2 != a1: return self.updateMovingAnim(f, t2, t2, v1, a2) v2 = v0 + a2*(t2-t0) if v2 > movingMaxSpeed: v2 = movingMaxSpeed elif v2 < -movingMaxSpeed: v2 = -movingMaxSpeed if f==0 and v1*v2 <= 0: self.movingV = 0 return timeout_add(movingUpdateTime, self.updateMovingAnim, f, t0, t2, v0, a2) self.movingV = v2 self.timeStart += v2 * (t2-t1) * self.timeWidth/float(self.get_allocation().width) self.queue_draw()
def reset_device(self, number):
"""Resetea el dispositivo.
Argumentos:
number -- el numero de dispositivo a reiniciar.
"""
logger.info("Reinicializando dispositivo %s", number)
self.power_manager.set_leds(7, 1, 200, 1000)
func = None
if number == DEV_AGENT:
func = self.initialize
elif number == DEV_PWR:
func = self._eventos_power
elif number == DEV_PRINTER:
def _inner():
self._eventos_impresora()
self._set_autofeed()
self._set_print_quality()
func = _inner
elif number == DEV_RFID:
func = self._eventos_rfid
if func is not None:
timeout_add(100, func)
def _consultar(self, datos_tag, serial, force=False):
"""Cuando se apolla una boleta con datos. Mostramos el contenido."""
# si no estamos ya consultando un voto o no forzamos la muestra.
if self.estado != E_CONSULTANDO or force:
# si ese tag tiene datos
if datos_tag is not None and len(datos_tag) > 0:
def _fin():
"""Se llama en el final de la consulta."""
if self.estado == E_CONSULTANDO:
sigue = False
# Si el papel esta insertado se expulsa, sin embargo
# si está apoyada el acta hacemos que siga consultando
# nuevamente
if self.rampa.tiene_papel:
self.rampa.expulsar_boleta()
else:
tag = self.sesion.lector.get_tag()
if tag is not None:
# ok, vamos de nuevo por que la persona esta
# todavia chequeando. lo forzamos para que
# renueve
sigue = True
self._consultar(tag['datos'], tag['serial'],
True)
if not sigue:
# reseteo el estado del tag por si no me llega el
# evento.
self.rampa.datos_tag = None
self.pantalla_insercion()
seleccion_tag = None
try:
seleccion_tag = Seleccion.desde_tag(datos_tag,
self.sesion.mesa)
if seleccion_tag is not None \
and not len(seleccion_tag.candidatos_elegidos()):
# Si el tag no esta vacio pero no tiene candidatos.
seleccion_tag = None
elif seleccion_tag is not None and \
seleccion_tag.serial != bytes(serial, "utf8"):
seleccion_tag = None
except Exception as e:
# Esto maneja la instancia de que alguien quiera meter
# un voto que no cumple con las condiciones requeridas.
self.logger.error("La boleta no contiene datos validos")
self.logger.exception(e)
self.rampa.expulsar_boleta()
_fin()
# Si el tag es validos arrancamos la consulta del voto.
if seleccion_tag is not None:
self.set_estado(E_CONSULTANDO)
self.controlador.consulta(seleccion_tag)
timeout_add(self.tiempo_verificacion, _fin)
else:
# si la boleta que se ingresó no es un voto la expulsamos.
self.rampa.expulsar_boleta()
def _inicializa_pantalla(self):
"""Inicializa la pantalla de previsualizacion de la apertura."""
if self.sesion._tmp_apertura is not None:
imagen_acta = self.sesion._tmp_apertura.a_imagen(svg=True,
de_muestra=True)
imagen_data = quote(imagen_acta.encode("utf-8"))
self.set_pantalla_confirmacion(imagen_data)
else:
timeout_add(100, self.modulo.salir)
def onPressRemain(self, func, counter): if counter == self.counter and now() - self.pressTm >= ui.timeout_repeat / 1000: func() timeout_add( ui.timeout_repeat, self.onPressRemain, self.doTrigger, self.counter, )
def _imprimir_acta(self):
"""Efectivamente manda a imprimir el acta."""
def _imprimir():
self.sesion.logger.info("Imprimiendo acta de Apertura.")
tipo_tag = self.sesion._tmp_apertura.__class__.__name__
tag = self.sesion._tmp_apertura.a_tag()
self.sesion.impresora.imprimir_serializado(tipo_tag,
b64encode(tag))
timeout_add(100, _imprimir)
def onPressRemain(self, func, counter):
if counter == self.counter and now() - self.pressTm >= ui.timeout_repeat / 1000:
func()
timeout_add(
ui.timeout_repeat,
self.onPressRemain,
self.doTrigger,
self.counter,
)
def update(self):
if self.running:
timeout_add(time_rem(), self.update)
if self.seconds:
l = '%.2d:%.2d:%.2d'%tuple(localtime()[3:6])
else:
l = '%.2d:%.2d'%tuple(localtime()[3:5])
if self.bold:
l = '<b>%s</b>'%l
self.set_label(l)
def updateTimes(self):
dt = now() % 1
timeout_add(iceil(1000 * (1 - dt)), self.updateTimes)
# print('updateTimes', dt)
lt = localtime()
self.label_cur.set_label(_("Current:") + " %.4d/%.2d/%.2d - %.2d:%.2d:%.2d" % lt[:6])
if not self.editTime:
self.timeInput.set_value(lt[3:6])
if not self.editDate:
self.dateInput.set_value(lt[:3])
return False
def onPress(self, widget, event=None): self.pressTm = now() self.doTrigger() self.counter += 1 timeout_add( ui.timeout_initial, self.onPressRemain, self.doTrigger, self.counter, ) return True
def consultar_lector(self, funcion):
logger.debug("Registrando callback lector %s", funcion)
def _inner(tipo_tag, datos):
funcion(tipo_tag, datos)
lector = self._get_lector()
if lector is not None:
self.remover_consultar_lector()
self._signal_tag = lector.connect_to_signal("tag_leido", _inner)
else:
timeout_add(1000, self._intentar_conectar, _inner)
def _imprimir_acta(self, tipo_acta):
"""Imprime las actas."""
def _imprimir():
encoded_data = b64encode(self.sesion.recuento.a_tag(tipo_acta[1]))
extra_data = self._get_extra_data(tipo_acta)
try:
self.sesion.impresora.imprimir_serializado(
"Recuento", encoded_data, extra_data=extra_data)
except DBusException:
# ignorando posible timeout de dbus para carga de buffer
# el zen de python me pide que lo haga explicito :D
pass
timeout_add(100, _imprimir)
def confirmar_seleccion(self, data):
"""Confirma la seleccion. Manda a imprimir."""
def _inner():
if self.modulo.rampa.tiene_papel:
self.modulo._guardar_voto()
self.reiniciar_seleccion()
else:
self.reiniciar_seleccion()
self.modulo.pantalla_insercion()
# Lo tiramos asincronico con un timeout por que si queda en el mismo
# thread no actualiza la UI hasta que termina de cargar el buffer de
# impresion, y si se extiende mucho puede tirar un segfault.
timeout_add(50, _inner)
def _fin_registro(self):
"""Se llama cuando se termina de registrar un voto."""
self.logger.info("Se muestra la pantalla de mensaje final")
self.estado = E_ESPERANDO
self.set_pantalla(PANTALLA_MENSAJE_FINAL)
self.rampa.tiene_papel = False
def _retornar():
"""Retorna a la pantalla de insercion de voto."""
self.logger.info("Se llamó a la funcion retornar")
if self.estado not in (E_CONSULTANDO, E_VOTANDO, E_REGISTRANDO):
self.pantalla_insercion()
# Se muestra el mensaje de agradecimiento durante 6 segundos
timeout_add(6000, _retornar)
def _imprimir_acta(self, data_sensores):
"""Manda a imprimir el acta."""
if not self._imprimiendo:
self._imprimiendo = True
self.sesion.impresora.remover_insertando_papel()
self.sesion.impresora.remover_consultar_tarjeta()
self.logger.info("Imprimiendo acta")
if self.callback_imprimiendo is not None:
self.logger.info("callback_imprimiendo")
self.callback_imprimiendo(self.acta_actual, self._finalizado)
# tiramos este timeout por que sino no actualiza el panel de estado
timeout_add(200, self._impresion_real)
else:
self.logger.warning("Frenado intento de impresion concurrente")
def currentTimeUpdate(self, restart=False, draw=True):
if restart:
try:
source_remove(self.timeUpdateSourceId)
except AttributeError:
pass
try:
pixelPerSec = self.pixelPerSec
except AttributeError:
pixelPerSec = 1
seconds = iceil(0.4/pixelPerSec)
tm = now()
#print('time=%.2f'%(tm%100), 'pixelPerSec=%.1f'%pixelPerSec, 'seconds=%d'%seconds)
miliSeconds = int(1000*(seconds + 0.01 - tm%1))
miliSeconds = min(miliSeconds, 4294967295)
# to avoid: OverflowError: %d not in range 0 to 4294967295
self.timeUpdateSourceId = timeout_add(
miliSeconds,
self.currentTimeUpdate,
)
self.currentTime = int(tm)
if draw and self.get_parent():
if self.get_parent().get_visible() and \
self.timeStart <= tm <= self.timeStart + self.timeWidth + 1:
#print('%.2f'%(tm%100), 'currentTimeUpdate: DRAW')
self.queue_draw()
def cambio_tag(self, tipo_tag, tag_dict):
""" Callback de cambio de tag.
Argumentos:
tipo_tag -- el tipo de tag
tag_dict -- los datos del tag
"""
if tag_dict is not None:
if tipo_tag == TAG_ADMIN:
timeout_add(500, self.salir)
elif tipo_tag == TAG_COLISION:
self.expulsar_boleta()
self.tag_colision()
if tag_dict != self.datos_tag:
self.datos_tag = tag_dict
self.maestro()
def cambio_tag(self, tipo_tag, tag_dict):
""" Callback de cambio de tag.
Argumentos:
tipo_tag -- el tipo de tag
tag_dict -- los datos del tag
"""
if tag_dict is not None:
if tipo_tag == TAG_ADMIN:
timeout_add(500, self.salir)
elif tipo_tag == TAG_COLISION:
self.expulsar_boleta()
self.tag_colision()
if tag_dict != self.datos_tag:
self.datos_tag = tag_dict
self.maestro()
def _registrar_voto(self, solo_impimir=False):
"""La funcion que explicitamente manda a registrar el voto."""
logger = self.modulo.sesion.logger
logger.info("Registrando voto.")
fallo = False
impresora = self.modulo.sesion.impresora
def fin_de_la_impresion(estado=None):
"""Callback que se llama cuando se terminó de imprimir una BUE."""
logger.info("Terminó de imprimir.")
if not self._evento_ya_lanzado:
logger.info("Rehookeando eventos.")
self._evento_ya_lanzado = True
impresora.remover_insertando_papel()
rampa = self.modulo.rampa
rampa.tiene_papel = False
impresora.registrar_insertando_papel(rampa.cambio_sensor_2)
if not fallo:
logger.info("Llamando al callback post impresión.")
self.callback()
return False
self._evento_ya_lanzado = False
# hookeo el evento, pero tambien agrego un timeout para asegurarme de
# que si por alguna razón no salta el evento de fin de impresión sigue
# su curso y asume que la sesion de impresión terminó. El manejo del
# error de esto se hace mas abajo y es syncronico, a diferencia de
# esto que es asincronico.
if impresora is not None:
impresora.remover_insertando_papel()
impresora.registrar_insertando_papel(fin_de_la_impresion)
timeout_add(10000, fin_de_la_impresion)
logger.info("Enviando comando de impresion.")
self.seleccion.serial = \
bytes(self.modulo.rampa.datos_tag['serial'], "utf8")
respuesta = impresora.registrar(self.seleccion, solo_impimir)
logger.info("Fin del registro.")
if respuesta['status'] == "TAG_NO_GUARDADO":
logger.error("Recibido el mensaje de tag no guardado.")
fallo = True
self.callback_error()
else:
fallo = True
self.callback_error()
def _registrar_voto(self, solo_impimir=False):
"""La funcion que explicitamente manda a registrar el voto."""
logger = self.modulo.sesion.logger
logger.info("Registrando voto.")
fallo = False
impresora = self.modulo.sesion.impresora
def fin_de_la_impresion(estado=None):
"""Callback que se llama cuando se terminó de imprimir una BUE."""
logger.info("Terminó de imprimir.")
if not self._evento_ya_lanzado:
logger.info("Rehookeando eventos.")
self._evento_ya_lanzado = True
impresora.remover_insertando_papel()
rampa = self.modulo.rampa
rampa.tiene_papel = False
impresora.registrar_insertando_papel(rampa.cambio_sensor_2)
if not fallo:
logger.info("Llamando al callback post impresión.")
self.callback()
return False
self._evento_ya_lanzado = False
# hookeo el evento, pero tambien agrego un timeout para asegurarme de
# que si por alguna razón no salta el evento de fin de impresión sigue
# su curso y asume que la sesion de impresión terminó. El manejo del
# error de esto se hace mas abajo y es syncronico, a diferencia de
# esto que es asincronico.
if impresora is not None:
impresora.remover_insertando_papel()
impresora.registrar_insertando_papel(fin_de_la_impresion)
timeout_add(10000, fin_de_la_impresion)
logger.info("Enviando comando de impresion.")
self.seleccion.serial = \
bytes(self.modulo.rampa.datos_tag['serial'], "utf8")
respuesta = impresora.registrar(self.seleccion, solo_impimir)
logger.info("Fin del registro.")
if respuesta['status'] == "TAG_NO_GUARDADO":
logger.error("Recibido el mensaje de tag no guardado.")
fallo = True
self.callback_error()
else:
fallo = True
self.callback_error()
def cambio_tag(self, tipo_tag, tag_dict):
""" Callback de cambio de tag.
Argumentos:
tipo_tag -- el tipo de tag
tag_dict -- los datos del tag
"""
if tag_dict is not None:
if tag_dict['tipo'] == TAG_APERTURA:
datos_tag = tag_dict['datos']
self.modulo._configurar_mesa_apertura(datos_tag)
elif tipo_tag == TAG_ADMIN:
timeout_add(500, self.modulo.salir_a_modulo, MODULO_INICIO)
elif tipo_tag == TAG_COLISION:
self.expulsar_boleta()
self.tag_colision()
if tag_dict != self.datos_tag:
self.datos_tag = tag_dict
self.maestro()
def _service_init(self):
"""Inicializacion real del canal y corrida del service loop."""
logger.info("corriendo el canal, inicializando el service loop")
def _service_loop():
"""El loop del servicio. Se corre cada 100ms."""
try:
if self.buffer is not None and self.device is not None:
arm_data = self.device.read(True)
if arm_data is not None:
response, device_id, command_id, response_type = \
arm_data
self._process_arm_data(response, device_id, command_id,
response_type)
else:
self.connect_and_load()
except (SerialException, TypeError):
logger.error("problema de lectura del canal, desconectando")
self._reset_connection()
return True
timeout_add(100, _service_loop)
if self._usa_fan:
timeout_add(10000, self.temp_manager)
if self._usa_pir:
timeout_add(10000, self.backlight_manager)
def procesar_tag_apertura(self, tag_dict):
"""Procesa el tag que se apoya en el lector."""
read_only = tag_dict.get("read_only")
if tag_dict['datos'] == b'' and not read_only:
if self.controlador.estado == E_INGRESO_ACTA and \
self.rampa.tiene_papel:
self.apertura = None
self.sesion.apertura = None
con_datos = self.config("con_datos_personales")
if con_datos:
self.cargar_datos()
else:
self.crear_objeto([], None)
elif tag_dict['tipo'] != TAG_APERTURA:
self.controlador.set_mensaje(_("acta_contiene_informacion"))
def _expulsar():
self.controlador.set_mensaje(self.controlador.MSG_APERTURA)
self.sesion.impresora.expulsar_boleta()
timeout_add(1500, _expulsar)
def maestro(self):
"""El maestro de ceremonias, el que dice que se hace y que no."""
if self.datos_tag is not None:
if self.datos_tag['tipo'] == TAG_VOTO:
self.modulo._consultar(self.datos_tag['datos'],
self.datos_tag['serial'])
elif self.tiene_papel and self.datos_tag['tipo'] == TAG_VACIO:
self.modulo.hay_tag_vacio()
elif self.datos_tag['tipo'] in (TAG_APERTURA, TAG_RECUENTO):
self.expulsar_boleta()
elif self.modulo.estado != E_ESPERANDO:
self.modulo.pantalla_insercion()
elif self.tiene_papel:
def _expulsar():
self.datos_tag = self.sesion.lector.get_tag()
if self.tiene_papel and self.datos_tag is None:
self.modulo.pantalla_insercion()
self.expulsar_boleta()
timeout_add(300, _expulsar)
elif self.modulo.estado not in (E_REGISTRANDO, E_CONSULTANDO,
E_ESPERANDO):
self.modulo.pantalla_insercion()
def inicio_mantenimiento(self):
"""Corre el inicio de los datos del modulo de mantenimiento."""
self.get_volume()
self.get_brightness()
self.get_rfid_antenna_level()
self.get_build()
self.get_fan_mode(True)
self.get_fan_speed()
self.get_temperature()
self.get_power_source()
self.get_pir_status()
self.get_pir_mode(True)
self.send_command("inicio_mantenimiento")
self.timeout_bateria = timeout_add(10000, self.get_battery_status)
self.send_command("inicio_intervals")
def _configurar_mesa_apertura(self, datos_tag):
"""
Configura la mesa con los datos que contiene el tag.
"""
apertura = Apertura.desde_tag(datos_tag)
def _salir():
"""Estamblece la apertura y la mesa en la sesion y sale al menu."""
apertura.mesa = self.sesion.mesa
self.sesion.apertura = apertura
self.rampa.desregistrar_eventos()
self.salir_a_menu()
if apertura.mesa is not None:
if apertura.mesa.numero == self.sesion.mesa.numero:
self.sesion.impresora.expulsar_boleta()
self.sesion.impresora.consultar_tarjeta(
lambda x: timeout_add(500, _salir))
else:
self.controlador.set_mensaje(_("acta_mesa_erronea"))
self.rampa.expulsar_boleta()
def update(self):
if self.running:
timeout_add(time_rem(), self.update)
self.set_label(strftime(self.format))
def _arrow_press(self, plus): self.pressTm = now() self._remain = True timeout_add(ui.timeout_initial, self._arrow_remain, plus) self.entry_plus(plus)
def _arrow_remain(self, plus): if self.get_editable() and self._remain and now()-self.pressTm>=ui.timeout_repeat/1000.0: self.entry_plus(plus) timeout_add(ui.timeout_repeat, self._arrow_remain, plus)
def reimprimir(self, *args):
timeout_add(100, self.controlador.reimprimir)
def _hide_and_try(status):
rampa.remover_nuevo_papel()
self.modulo.hide_dialogo()
self.modulo.controlador.mostrar_imprimiendo()
timeout_add(100, self.registrar)