Demo entry 6383010

Teste de Classe Python

   

Submitted by anonymous on May 23, 2017 at 17:58
Language: Python. Code size: 18.7 kB.

#!/usr/bin/env python
# -*- coding: latin-1 -*-


import datetime
import threading
from time import sleep
from catraca.logs import Logs
from catraca.util import Util
from catraca.visao.interface.aviso import Aviso
from catraca.modelo.dao.tipo_dao import TipoDAO
from catraca.modelo.dao.turno_dao import TurnoDAO
from catraca.modelo.dao.catraca_dao import CatracaDAO
from catraca.modelo.dao.unidade_dao import UnidadeDAO
from catraca.modelo.dao.unidade_turno_dao import UnidadeTurnoDAO
from catraca.modelo.dao.custo_unidade_dao import CustoUnidadeDAO
from catraca.modelo.dao.custo_refeicao_dao import CustoRefeicaoDAO
from catraca.modelo.dao.catraca_unidade_dao import CatracaUnidadeDAO
from catraca.controle.recursos.recursos_restful import RecursosRestful
from catraca.controle.api.rede import Rede


__author__ = "Erivando Sena" 
__copyright__ = "Copyright 2015, Unilab" 
__email__ = "erivandoramos@unilab.edu.br" 
__status__ = "Prototype" # Prototype | Development | Production 



class Sincronizador(threading.Thread):
    
    log = Logs()
    util = Util()
    aviso = Aviso()
    rede = Rede()
    tipo_dao = TipoDAO()
    turno_dao = TurnoDAO()
    catraca_dao = CatracaDAO()
    unidade_dao = UnidadeDAO()
    unidade_turno_dao = UnidadeTurnoDAO()
    custo_unidade_dao = CustoUnidadeDAO()
    custo_refeicao_dao = CustoRefeicaoDAO()
    catraca_unidade_dao = CatracaUnidadeDAO()
    recursos_restful = RecursosRestful()
    
    modo = True
    status = True
    contador1 = 4
    contador2 = 14
    
    def __init__(self, intervalo=1):
        threading.Thread.__init__(self)
        self._stopevent = threading.Event()
        self._sleepperiod = intervalo
        self.__hora_inicio = datetime.datetime.strptime('00:00:00','%H:%M:%S').time()
        self.__hora_fim = datetime.datetime.strptime('00:00:00','%H:%M:%S').time()
        self.__rede_status = False
        self.__rede_interface = []
        self.__catraca = None
        self.__turno = None
        self.__periodo = False
        self.__funcionamento = False
        self.__recursos = False
        self.__uso_do_cartao = False
        self.__uso_irregular = False
        self.__lote_offline = False
        self.__sincronia = True
        self.__escreve_display = False
        self.__aguarda_giro = False
        self.name = 'Thread Sincronizador'
        
    @property
    def hora_inicio(self):
        return self.__hora_inicio
    
    @hora_inicio.setter
    def hora_inicio(self, valor):
        self.__hora_inicio = valor
        
    @property
    def hora_fim(self):
        return self.__hora_fim
    
    @hora_fim.setter
    def hora_fim(self, valor):
        self.__hora_fim = valor
        
    @property
    def rede_status(self):
        return self.__rede_status
    
    @rede_status.setter
    def rede_status(self, valor):
        self.__rede_status = valor
        
    @property
    def rede_interface(self):
        return self.__rede_interface
    
    @rede_interface.setter
    def rede_interface(self, valor):
        self.__rede_interface = valor
        
    @property
    def catraca(self):
        return self.__catraca
    
    @catraca.setter
    def catraca(self, valor):
        self.__catraca = valor
        
    @property
    def turno(self):
        return self.__turno
    
    @turno.setter
    def turno(self, valor):
        self.__turno = valor
        
    @property
    def periodo(self):
        return self.__periodo
    
    @periodo.setter
    def periodo(self, valor):
        self.__periodo = valor
        
    @property
    def funcionamento(self):
        return self.__funcionamento
     
    @funcionamento.setter
    def funcionamento(self, valor):
        self.__funcionamento = valor
        
    @property
    def recursos(self):
        return self.__recursos
     
    @recursos.setter
    def recursos(self, valor):
        self.__recursos = valor
        
    @property
    def uso_do_cartao(self):
        return self.__uso_do_cartao
     
    @uso_do_cartao.setter
    def uso_do_cartao(self, valor):
        self.__uso_do_cartao = valor
        
    @property
    def uso_irregular(self):
        return self.__uso_irregular
     
    @uso_irregular.setter
    def uso_irregular(self, valor):
        self.__uso_irregular = valor
        
    @property
    def lote_offline(self):
        return self.__lote_offline
     
    @lote_offline.setter
    def lote_offline(self, valor):
        self.__lote_offline = valor
        
    @property
    def sincronia(self):
        return self.__sincronia
     
    @sincronia.setter
    def sincronia(self, valor):
        self.__sincronia = valor
        
    @property
    def escreve_display(self):
        return self.__escreve_display
     
    @escreve_display.setter
    def escreve_display(self, valor):
        self.__escreve_display = valor
        
    @property
    def aguarda_giro(self):
        return self.__aguarda_giro
     
    @aguarda_giro.setter
    def aguarda_giro(self, valor):
        self.__aguarda_giro = valor
        
    def tGreen(self, texto):
        return '\033[1;32;40m '+  str(texto) +' \033[0m'
    
    def tYellow(self, texto):
        return '\033[1;33;40m '+  str(texto) +' \033[0m'
    
    def tRed(self, texto):
        return '\033[1;31;40m '+  str(texto) +' \033[0m'
    
    def tPisca(self, texto):
        #'\33[5m' and '\33[6m'
        return '\33[5m'+  str(texto) +' \033[0m'
        
    def run(self):
        print "%s Iniciando... " % (self.getName(),)
        while not self._stopevent.isSet():
            if self.sincronia:
                self.obtem_atualizacao()

#             print("\033[0;37;40m Normal text\n")
#             print("\033[2;37;40m Underlined text\033[0;37;40m \n")
#             print("\033[1;37;40m Bright Colour\033[0;37;40m \n")
#             print("\033[3;37;40m Negative Colour\033[0;37;40m \n")
#             print("\033[5;37;40m Negative Colour\033[0;37;40m\n")
#             print("\033[1;37;40m \033[2;37:40m TextColour BlackBackground          TextColour GreyBackground                WhiteText ColouredBackground\033[0;37;40m\n")
#             print("\033[1;30;40m Dark Gray      \033[0m 1;30;40m            \033[0;30;47m Black      \033[0m 0;30;47m               \033[0;37;41m Black      \033[0m 0;37;41m")
#             print("\033[1;31;40m Bright Red     \033[0m 1;31;40m            \033[0;31;47m Red        \033[0m 0;31;47m               \033[0;37;42m Black      \033[0m 0;37;42m")
#             print("\033[1;32;40m Bright Green   \033[0m 1;32;40m            \033[0;32;47m Green      \033[0m 0;32;47m               \033[0;37;43m Black      \033[0m 0;37;43m")
#             print("\033[1;33;40m Yellow         \033[0m 1;33;40m            \033[0;33;47m Brown      \033[0m 0;33;47m               \033[0;37;44m Black      \033[0m 0;37;44m")
#             print("\033[1;34;40m Bright Blue    \033[0m 1;34;40m            \033[0;34;47m Blue       \033[0m 0;34;47m               \033[0;37;45m Black      \033[0m 0;37;45m")
#             print("\033[1;35;40m Bright Magenta \033[0m 1;35;40m            \033[0;35;47m Magenta    \033[0m 0;35;47m               \033[0;37;46m Black      \033[0m 0;37;46m")
#             print("\033[1;36;40m Bright Cyan    \033[0m 1;36;40m            \033[0;36;47m Cyan       \033[0m 0;36;47m               \033[0;37;47m Black      \033[0m 0;37;47m")
#             print("\033[1;37;40m White          \033[0m 1;37;40m            \033[0;37;40m Light Grey \033[0m 0;37;40m               \033[0;37;48m Black      \033[0m 0;37;48m")
            
            print self.tYellow('Rede:')+'             '+self.tGreen('OK') if self.rede_status else self.tYellow('Rede:')+'             '+self.tRed('OFF')
            print self.tYellow('Interface:')+'        '+self.tGreen(self.rede_interface[1]) if self.rede_interface else self.tYellow('Interface:')+'        '+self.tRed('Sem interface definida')
            print self.tYellow('Nome:')+'             '+self.tGreen(self.catraca.nome.upper()) if self.catraca else self.tYellow('Nome:')+'             '+self.tRed('Sem catraca definida')
            print self.tYellow('Turno:')+'            '+self.tGreen(self.turno.descricao) if self.turno else self.tYellow('Turno:')+'            '+self.tRed('Sem turno atual')
            print self.tYellow('Inicico do turno:')+' '+self.tGreen(self.hora_inicio)
            print self.tYellow('Final do turno:')+'   '+self.tGreen(self.hora_fim)
            print self.tYellow('Turno ativo:')+'      '+self.tGreen('SIM') if self.periodo else self.tYellow('Turno ativo:')+'      '+self.tRed('NAO')
            print self.tYellow('Modo:')+'             '+self.tGreen('ON-Line') if self.funcionamento else self.tYellow('Modo:')+'             '+self.tRed('OFF-Line')
            print self.tYellow('BD local:')+'         '+self.tGreen('Sincronizando com o servidor') if self.recursos else self.tYellow('BD local:')+'         '+self.tRed('Nao sincronizado com o servidor')
            print self.tYellow('Leitor:')+'           '+self.tGreen('Utilizando cartao') if self.uso_do_cartao else self.tYellow('Leitor:')+'           '+self.tRed('Sem uso')
            if self.uso_irregular:
                print self.tYellow('Catraca:')+'          '+self.tRed('Com uso irregular')
            print self.tYellow('Catraca:')+'          '+self.tGreen('Aguardando girar') if self.aguarda_giro else self.tYellow('Catraca:')+'          '+self.tRed('Em repouso')
            print "\033[0;37;47m \033[0m" * 70
            
            self._stopevent.wait(self._sleepperiod)
        print "%s Finalizando..." % (self.getName(),)
        
    def obtem_atualizacao(self):
        try:
            Sincronizador.rede_interface = self.rede.interface_ativa
            Sincronizador.rede_status = self.rede.status
            Sincronizador.recursos = self.recursos_restful.obtendo_recurso
            
            self.contador1 += 1
            if self.contador1 == 15:
                self.contador1 = 0
                self.obtem_catraca()
                if self.catraca and self.rede_status:
                    #remoto
                    if not self.recursos:
                        Sincronizador.turno = self.recursos_restful.turno_json.turno_funcionamento_get()
                        print Sincronizador.turno
                else:
                    #local
                    if self.catraca:
                        Sincronizador.turno = self.turno_dao.obtem_turno(self.catraca, self.util.obtem_hora())
                if self.catraca:
                    self.obtem_turno(self.turno)
        except Exception:
            self.log.logger.error("Exception", exc_info=True)
            
    def obtem_catraca(self):
        try:
            if self.rede_status:
                #remoto
                Sincronizador.catraca = self.rede_interface[0]
                if self.modo:
                    self.modo = False
                    # codigo aqui sera exibido apenas uma vez
                    Sincronizador.funcionamento = True
                    Sincronizador.lote_offline = True
#                     print "Modo ON-LINE"
                return self.catraca
            else:
                #local
                Sincronizador.catraca = self.rede_interface[3]
                if not self.modo:
                    self.modo = True
                    # codigo aqui sera exibido apenas uma vez
                    Sincronizador.funcionamento = False
#                     print "Modo OFF-LINE"
                Sincronizador.escreve_display = True
                self.obtem_dependencias_locais()
                Sincronizador.escreve_display = False
                return self.catraca
        except Exception:
            self.log.logger.error("Exception", exc_info=True)
            
    def obtem_turno(self, turno):
        try:
            if self.rede_status and turno is None:
                Sincronizador.escreve_display = True
                if not self.recursos_restful.catraca_unidade_json.catraca_unidade_cadastrada_get(self.catraca.id):
                    self.aviso.exibir_catraca_unidade_nao_cadastrada()
                Sincronizador.escreve_display = False
            if turno:
                # Inicia
                Sincronizador.hora_inicio = datetime.datetime.strptime(str(self.turno.inicio),'%H:%M:%S').time()
                Sincronizador.hora_fim = datetime.datetime.strptime(str(self.turno.fim),'%H:%M:%S').time()
                if self.status:
                    self.status = False
                    # codigo aqui sera exibido apenas uma vez
                    Sincronizador.periodo = True
                    self.aviso.exibir_turno_atual(turno.descricao)
                    self.util.beep_buzzer(855, .5, 1)
                    self.aviso.exibir_aguarda_cartao()
#                     print "INICIO DE TURNO! :)"
            else:
                # Finaliza
                if not self.status:
                    self.status = True
                    # codigo aqui sera exibido apenas uma vez
                    Sincronizador.periodo = False
                    self.aviso.exibir_horario_invalido()
                    self.util.beep_buzzer(855, .5, 1)
#                     print "ENCERRAMENTO DE TURNO! :("
        except Exception:
            self.log.logger.error("Exception", exc_info=True)
            
    def obtem_dependencias_locais(self):
        retorno = True
        try:
            self.contador2 += 1
            if self.contador2 == 15:
                self.contador2 = 0
                
                #catraca
                if self.catraca_dao.busca() == []:
                    self.aviso.exibir_catraca_nao_cadastrada()
                    retorno = False
                
                #unidade
                if self.unidade_dao.busca() == []:
                    self.aviso.exibir_unidade_nao_cadastrada()
                    retorno = False
                
                #catraca-unidade
                if self.catraca_unidade_dao.busca() == []:
                    self.aviso.exibir_catraca_unidade_nao_cadastrada()
                    retorno = False
                
                #turno
                if self.turno_dao.busca() == []:
                    self.aviso.exibir_turno_nao_cadastrado()
                    retorno = False
                
                #unidade-turno
                if self.unidade_turno_dao.busca() == []:
                    self.aviso.exibir_unidade_turno_nao_cadastrada()
                    retorno = False
                
                #custo-refeicao
                if self.custo_refeicao_dao.busca() == []:
                    self.aviso.exibir_custo_refeicao_nao_cadastrado()
                    retorno = False
                
                #custo-unidade
                if self.custo_unidade_dao.busca() == []:
                    self.aviso.exibir_custo_unidade_nao_cadastrado()
                    retorno = False
                
                #tipo
                if self.tipo_dao.busca() == []:
                    self.aviso.exibir_tipo_nao_cadastrada()
                    retorno = False
                
            if not retorno:
                self.aviso.exibir_sem_sincronia()
            
        except Exception:
            self.log.logger.error("Exception", exc_info=True)
              
    def obtem_dados_para_offline(self, numero, id=None):
        #Json's
        usuarios = self.recursos_restful.usuario_json.LISTA_JSON
        cartoes = self.recursos_restful.cartao_json.LISTA_JSON
        vinculos = self.recursos_restful.vinculo_json.LISTA_JSON
        registros = self.recursos_restful.registro_json.LISTA_JSON
        isencoes = self.recursos_restful.isencao_json.LISTA_JSON
        cartao = []
        try:
            if vinculos and usuarios and cartoes:
                #busca no json
                if id and numero is None:
                    cartao = [item for item in cartoes if item["cart_id"] == id]
                elif numero and id is None:
                    cartao = [item for item in cartoes if item["cart_numero"] == numero]
                if cartao:
                    #busca no json
                    vinculo = [item for item in vinculos if item["cart_id"] == cartao[0]["cart_id"]]
                    usuario = [item for item in usuarios if item["usua_id"] == vinculo[0]["usua_id"]]
                    registro = [item for item in registros if item["cart_id"] == vinculo[0]["cart_id"]]
                    isencao = [item for item in isencoes if item["cart_id"] == vinculo[0]["cart_id"]]
                    if vinculo and usuario and cartao:
                        #salva no bd local
                        obj = self.recursos_restful.usuario_json.dict_obj(usuario[0])
                        if obj:
                            self.recursos_restful.usuario_json.mantem_recurso_local(obj)
                        obj = self.recursos_restful.cartao_json.dict_obj(cartao[0])
                        if obj:
                            self.recursos_restful.cartao_json.mantem_recurso_local(obj)
                        obj = self.recursos_restful.vinculo_json.dict_obj(vinculo[0])
                        if obj:
                            self.recursos_restful.vinculo_json.mantem_recurso_local(obj)
                        if registro:
                            obj = self.recursos_restful.registro_json.dict_obj(registro[0])
                            if obj:
                                self.recursos_restful.registro_json.mantem_recurso_local(obj)
                        if isencao:
                            obj = self.recursos_restful.isencao_json.dict_obj(isencao[0])
                            if obj:
                                self.recursos_restful.isencao_json.mantem_recurso_local(obj)
                        print "Json's ja baixados do servidor."
    #                     return True
                else:
                    print "Json CARTAO ainda nao baixados do servidor!"
    #                 return False
            else:
                print "Json's ainda nao baixados do servidor!"
    #             return False
        except Exception:
            self.log.logger.error("Exception", exc_info=True)
            

This snippet took 0.02 seconds to highlight.

Back to the Entry List or Home.

Delete this entry (admin only).