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 _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 _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()