Esempio n. 1
0
 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)
Esempio n. 2
0
 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})
Esempio n. 3
0
    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)
Esempio n. 4
0
 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})
Esempio n. 5
0
 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()
Esempio n. 6
0
 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())
Esempio n. 7
0
 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()
Esempio n. 8
0
 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())
Esempio n. 9
0
 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)
Esempio n. 10
0
 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
Esempio n. 11
0
    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)
Esempio n. 12
0
    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)
Esempio n. 13
0
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)
Esempio n. 14
0
 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)
Esempio n. 15
0
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()
Esempio n. 16
0
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()