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 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 imprimir_serializado(self, tipo_tag, tag, transpose, only_buffer=False,
extra_data=None):
self._buffering = True
if tipo_tag == "Seleccion":
if type(tag) == Seleccion:
boleta = tag
else:
boleta = Seleccion.desde_string(tag)
image = boleta.a_imagen()
elif tipo_tag == "Apertura":
boleta = Apertura.desde_tag(b64decode(tag))
image = boleta.a_imagen()
elif tipo_tag == "Recuento":
boleta = Recuento.desde_tag(b64decode(tag))
extra_data = loads(extra_data)
autoridades = extra_data.get('autoridades')
if autoridades is not None and len(autoridades):
boleta.autoridades = [Autoridad.desde_dict(aut) for aut
in autoridades]
boleta.hora = extra_data['hora']
image = boleta.a_imagen(extra_data['tipo_acta'])
elif tipo_tag == "Prueba":
image = ImagenPrueba(hd=True).render_image()
image = image.convert('L')
if transpose:
image = image.transpose(Image.ROTATE_270)
if only_buffer:
self.parent.printer.register_load_buffer_compressed()
else:
self.parent.printer.register_print_finished()
data = image.getdata()
self.parent.printer.load_buffer_compressed(
data, self.parent._free_page_mem,
print_immediately=not only_buffer)
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 _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
self.mesa_abierta = True
self._inicio()
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 _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
self.mesa_abierta = True
self._inicio()
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 _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:
apertura = Apertura.desde_tag(dump_data)
if apertura.mesa is not None:
self._validar_configuracion(mesa=apertura.mesa.numero,
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 _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 imprimir_serializado(self,
tipo_tag,
tag,
transpose,
only_buffer=False,
extra_data=None):
self._buffering = True
if tipo_tag == "Seleccion":
if type(tag) == Seleccion:
boleta = tag
else:
boleta = Seleccion.desde_string(tag)
image = boleta.a_imagen()
elif tipo_tag == "Apertura":
boleta = Apertura.desde_tag(b64decode(tag))
image = boleta.a_imagen()
elif tipo_tag == "Recuento":
boleta = Recuento.desde_tag(b64decode(tag))
extra_data = loads(extra_data)
autoridades = extra_data.get('autoridades')
if autoridades is not None and len(autoridades):
boleta.autoridades = [
Autoridad.desde_dict(aut) for aut in autoridades
]
boleta.hora = extra_data['hora']
image = boleta.a_imagen(extra_data['tipo_acta'])
elif tipo_tag == "Prueba":
image = ImagenPrueba(hd=True).render_image()
image = image.convert('L')
if transpose:
image = image.transpose(Image.ROTATE_270)
if only_buffer:
self.parent.printer.register_load_buffer_compressed()
else:
self.parent.printer.register_print_finished()
data = image.getdata()
self.parent.printer.load_buffer_compressed(
data,
self.parent._free_page_mem,
print_immediately=not only_buffer)
def run(args):
printer = obtener_impresora()
if args.serialized is None or not args.serialized:
logger.debug("Corriendo proceso de impresion o cache de impresion")
logger.debug(args)
image_file = open(args.filepath)
data = image_file.read()
size = [int(num) for num in args.size.split(",")]
dpi = tuple([int(num) for num in args.dpi.split(",")])
image = Image.fromstring(args.mode, size, data)
printer.imprimir_image(image, dpi, args.transpose, args.compress,
args.only_buffer)
else:
extra_data = loads(b64decode(args.extra_data))
if args.tipo_tag == "Seleccion":
boleta = Seleccion.desde_string(args.tag)
image = boleta.a_imagen()
dpi = get_dpi_boletas()
elif args.tipo_tag == "Apertura":
boleta = Apertura.desde_tag(b64decode(args.tag))
autoridades = boleta.autoridades
image = boleta.a_imagen()
dpi = DPI_VOTO_ALTA if IMPRESION_HD_APERTURA else DPI_VOTO_BAJA
elif args.tipo_tag == "Recuento":
boleta = Recuento.desde_tag(b64decode(args.tag))
autoridades = extra_data.get('autoridades')
if autoridades is not None:
for autoridad in autoridades:
boleta.autoridades.append(Autoridad.desde_dict(autoridad))
boleta.hora = extra_data['hora']
image = boleta.a_imagen(extra_data['tipo_acta'])
dpi = DPI_VOTO_ALTA if IMPRESION_HD_CIERRE else DPI_VOTO_BAJA
elif args.tipo_tag == "Prueba":
dpi = DPI_VOTO_ALTA
image = ImagenPrueba(hd=True).render_image()
printer.imprimir_image(image, dpi, args.transpose, args.compress,
args.only_buffer)
def abrir_mesa(self, datos_tag):
apertura = Apertura.desde_tag(datos_tag)
self._validar_configuracion(mesa=apertura.mesa.numero, pin=None,
con_acta_apertura=True,
datos_tag=datos_tag)
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()
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()
