def __load_sub(self, fdct_data, fs_ver="0001"): """ carrega os dados de procedimento de subida a partir de um dicionário (formato 0001) @param fdct_data: dicionário com os dados do procedimento de subida @param fs_ver: versão do formato dos dados """ # formato versão 0.01 ? if "0001" == fs_ver: # cria a procedimento de subida self.__make_sub(fdct_data) # otherwise, formato desconhecido else: # logger l_log = logging.getLogger("CSubNEW::__load_sub") l_log.setLevel(logging.CRITICAL) l_log.critical(u"<E01: formato desconhecido.") # cria um evento de quit l_evt = event.CQuit() assert l_evt # dissemina o evento self.__event.post(l_evt) # cai fora... sys.exit(1)
def load_prf(self, fdct_data, fs_ver="0001"): """ carrega os dados de performance a partir de um dicionário (formato 0001) @param fdct_data: dicionário com os dados da performance @param fs_ver: versão do formato dos dados """ # logger # M_LOG.info("load_prf:>>") # formato versão 0.01 ? if "0001" == fs_ver: # cria a performance self.make_prf(fdct_data) # senão, formato desconhecido else: # logger l_log = logging.getLogger("CPrfNEW::load_prf") l_log.setLevel(logging.CRITICAL) l_log.critical(u"<E01: formato desconhecido.") # cria um evento de quit l_evt = events.CQuit() assert l_evt # dissemina o evento self.__event.post(l_evt) # termina a aplicação sys.exit(1)
def __load_esp(self, fdct_data, fs_ver="0001"): """ carrega os dados de espera a partir de um dicionário @param fdct_data: dicionário com os dados do espera @param fs_ver: versão do formato dos dados """ # formato versão 0.01 ? if "0001" == fs_ver: # cria a espera self.__make_esp(fdct_data) # senão, formato desconhecido else: # logger l_log = logging.getLogger("CEspNEW::__load_esp") l_log.setLevel(logging.CRITICAL) l_log.critical(u"<E01: formato desconhecido.") # cria um evento de quit l_evt = events.CQuit() assert l_evt # dissemina o evento self.__event.post(l_evt) # cai fora... sys.exit(1)
def __load_apx(self, fdct_data, fs_ver="0001"): """ carrega os dados de procedimento de aproximação a partir de um dicionário @param fdct_data: dicionário com os dados do procedimento de aproximação @param fs_ver: versão do formato dos dados """ # formato versão 0.01 ? if "0001" == fs_ver: # cria a procedimento de aproximação self.__make_apx(fdct_data) # senão, formato desconhecido else: # logger l_log = logging.getLogger("CApxNEW::__load_apx") l_log.setLevel(logging.DEBUG) l_log.critical(u"<E01: formato desconhecido.") # cria um evento de quit l_evt = events.CQuit() assert l_evt # dissemina o evento self.__event.post(l_evt) # cai fora... sys.exit(1)
def load_aer(self, f_dct_data, fs_ver="0001"): """ carrega os dados de um aeródromo a partir de um dicionário (formato 0001) @param f_dct_data: dicionário com os dados do aeródromo @param fs_ver: versão do formato dos dados """ # formato versão 0.01 ? if "0001" == fs_ver: # cria a aeródromo self.make_aer(f_dct_data) # otherwise, formato desconhecido else: # logger l_log = logging.getLogger("CAerNEW::load_aer") l_log.setLevel(logging.CRITICAL) l_log.critical(u"<E01: formato desconhecido.") # cria um evento de quit l_evt = events.CQuit() assert l_evt # dissemina o evento self.__event.post(l_evt) # cai fora... sys.exit(1)
def load_brk(self, fdct_data, fs_ver="0001"): """ carrega os dados de breakpoint a partir de um dicionário @param fdct_data: dicionário com os dados do breakpoint @param fs_ver: versão do formato dos dados """ # logger # M_LOG.info("load_brk:>>") # formato versão 0.01 ? if "0001" == fs_ver: # cria a breakpoint self.make_brk(fdct_data) # otherwise, formato desconhecido else: # logger l_log = logging.getLogger("CBrkNEW::load_brk") l_log.setLevel(logging.CRITICAL) l_log.critical(u"<E01: formato desconhecido.") # cria um evento de quit l_evt = events.CQuit() assert l_evt # dissemina o evento self.__event.post(l_evt) # cai fora... sys.exit(1)
def loadInitial(self): """ faz a carga inicial da tabela de exercícios. """ # logger M_LOG.info("loadInitial:>>") # obtém o dicionário de exercícios self._dctExe = self._model.dct_exe # o dicionário de exercícios não existe ? if self._dctExe is None: # logger l_log.critical(u"<E01: Tabela de exercícios não carregada !") # cria um evento de quit l_evtQuit = events.CQuit() assert l_evtQuit # dissemina o evento self._event.post(l_evtQuit) # cai fora... sys.exit(1) # atualiza na tela os dados da tabela de exercícios self.exeUpdateList() # logger M_LOG.info("loadInitial:<<")
def load_fix(self, fdct_data, fs_ver="0001"): """ carrega os dados do fixo a partir de um dicionário (formato 0001) @param fdct_data: dicionário com os dados do fixo @param fs_ver: versão do formato """ # logger # M_LOG.info("load_fix:>>") # formato versão 0.01 ? if "0001" == fs_ver: # cria a fixo self.make_fix(fdct_data) # senão, formato desconhecido else: # logger l_log = logging.getLogger("CFixNEW::load_fix") l_log.setLevel(logging.CRITICAL) l_log.critical(u"<E01: formato desconhecido.") # cria um evento de quit l_evt = events.CQuit() assert l_evt # dissemina o evento self.__event.post(l_evt) # cai fora... sys.exit(1)
def closeEvent(self, f_evt): """ DOCUMENT ME! """ # logger # M_LOG.info("closeEvent:>>") # really quit ? if self.__really_quit(): # salva a configuração atual self.__write_settings() # accept f_evt.accept() # cria um evento de quit l_evt = events.CQuit() assert l_evt # dissemina o evento self.__event.post(l_evt) # senão, continua... else: # ignore f_evt.ignore()
def __load_cenario(self): """ carrega as tabelas do sistema @return flag e mensagem """ # carrega o landscape # lv_ok, ls_msg = self.__load_land() # tudo Ok ? # if lv_ok: # carrega o airspace lv_ok, ls_msg = self.__load_air() # houve erro em alguma fase ? if not lv_ok: # logger l_log = logging.getLogger("CModelVisil::__load_cenario") l_log.setLevel(logging.CRITICAL) l_log.critical(u"<E01: erro na carga da base de dados: {}.".format(ls_msg)) # cria um evento de quit l_evt = event.CQuit() assert l_evt # dissemina o evento self.event.post(l_evt) # termina a aplicação sys.exit(1)
def load_initial(self): """ faz a carga inicial da tabela de exercícios. """ # logger # M_LOG.info("load_initial:>>") # obtém o dicionário de exercícios self.__dct_exe = self.__model.dct_exe # o dicionário de exercícios não existe ? if self.__dct_exe is None: # logger l_log = logging.getLogger("CWPagConfigExe::load_initial") l_log.setLevel(M_LOG_LVL) l_log.critical(u"<E01: Tabela de exercícios não carregada !") # cria um evento de quit l_evtQuit = events.CQuit() assert l_evtQuit # dissemina o evento self.__event.post(l_evtQuit) # cai fora... sys.exit(1) # atualiza na tela os dados da tabela de exercícios self.exeUpdateList()
def __load_initial(self): """ faz a carga inicial da tabela de aeródromos """ # obtém o dicionário de aeródromos self.__dct_aer = self.__model.dct_aer # o dicionário de aeródromos não existe ? if self.__dct_aer is None: # logger l_log = logging.getLogger("CDlgAerDataNEW::__load_initial") l_log.setLevel(logging.CRITICAL) l_log.critical(u"<E01: Tabela de aeródromos não carregada.") # cria um evento de quit l_evt = events.CQuit() assert l_evt # dissemina o evento self.__control.event.post(l_evt) # cai fora... sys.exit(1) # atualiza na tela os dados da tabela de aeródromos self.__aer_update_list()
def load_exe(self, fdct_data, fs_ver="0001"): """ carrega os dados do exercício a partir de um dicionário @param fdct_data: dicionário de dados de exercício @param fs_ver: versão do formato dos dados """ # logger # M_LOG.info("load_exe:>>") # formato versão 0.01 ? if "0001" == fs_ver: # cria o exercício self.make_exe(fdct_data) # senão, formato desconhecido else: # logger l_log = logging.getLogger("CExeNEW::load_exe") l_log.setLevel(logging.CRITICAL) l_log.critical(u"<E01: formato desconhecido [{}].".format(fs_ver)) # cria um evento de quit l_evt = events.CQuit() assert l_evt # dissemina o evento self.__event.post(l_evt) # cai fora... sys.exit(1) # (bool) self.v_exe_ok = True
def closeEvent(self, f_evt): """ DOCUMENT ME! """ # logger # M_LOG.info("closeEvent:>>") # really quit ? if self.__really_quit(): # save actual config self.__write_settings() # accept f_evt.accept() # create CQuit event l_evt = events.CQuit() assert l_evt # dispatch event self.__event.post(l_evt) # otherwise, continua... else: # ignore f_evt.ignore()
def cbk_termina(self): """ termina a aplicação """ # clear to go assert self.__event # cria um evento de quit l_evt = events.CQuit() assert l_evt # dissemina o evento self.__event.post(l_evt)
def cbk_termina(self): """ termina a aplicação """ # verifica condições de execução assert self.__event # cria um evento de quit l_evt = events.CQuit() assert l_evt # dissemina o evento self.__event.post(l_evt)
def cbk_termina(self): """ termina a aplicação """ # checks assert self.event # cria um evento de fim de execução l_evt = events.CQuit() assert l_evt # dissemina o evento self.event.post(l_evt)
def cbk_sair(self): """ callback da opção sair da janela principal """ # cria um evento de quit l_evt = events.CQuit() assert l_evt # dissemina o evento self.__event.post(l_evt) # finaliza o sistema self.close()
def __init__(self, f_control): """ @param f_control: control manager """ # check input assert f_control # init super class super(CModelWizard, self).__init__(f_control) # herdados de CModelManager # self.control # control manager # self.event # event manager # self.config # config manager # self.dct_config # dicionário de configuração # obtém o event manager # self.event = f_control.event # assert self.event # inicia variáveis de instância self.__dct_exe = {} # carrega as tabelas do sistema lv_ok = self.__load_tables() # M_LOG.debug("dct_exe:[{}]".format(self.__dct_exe)) # houve erro em alguma fase ? if not lv_ok: # logger l_log = logging.getLogger("CModelWizard::__init__") l_log.setLevel(logging.CRITICAL) l_log.critical(u"<E01: Erro na carga da base de dados.") # cria um evento de quit l_evt = events.CQuit() assert l_evt # dissemina o evento self.event.post(l_evt) # termina a aplicação sys.exit(1)
def __load_initial(self): """ faz a carga inicial da tabela de performances """ # obtém o dicionário de performances self.__dct_prf = self.__model.dct_prf # o dicionário de performances não existe ? if self.__dct_prf is None: # cria um evento de quit l_evt = events.CQuit() assert l_evt # dissemina o evento self.__event.post(l_evt) # cai fora... sys.exit(1) # atualiza na tela os dados da tabela de performances self.prf_update_list()
def __init__(self, f_control): """ constructor. cria o model object do editor da base de dados. @param f_control: control manager. @param fs_dbname: pathname da base de dados. """ # verifica parâmetros de entrada assert f_control # init super class super(CModelDBEdit, self).__init__(f_control) # herdados de CModelManager # self.config # config manager # self.dct_config # dicionário de configuração # self.control # control manager # self.event # event manager # obtém as coordenadas de referência lf_ref_lat = self.dct_config["map.lat"] lf_ref_lng = self.dct_config["map.lng"] lf_dcl_mag = self.dct_config["map.dcl"] # coordinate system self.__coords = coords.CCoordSys(lf_ref_lat, lf_ref_lng, lf_dcl_mag) assert self.__coords # airspace self.__airspace = None # obtém o event manager # self.event = f_control.event # assert self.event # exercício self.__exe = None # dicionário de exercícios self.__dct_exe = {} # dicionário de performances self.__dct_prf = {} # dicionário de sensores self.__dct_sen = {} # dicionário de tráfegos self.__dct_trf = {} # carrega as tabelas do sistema self.__load_airs() # carrega as tabelas do sistema lv_ok = self.__load_tables() # houve erro em alguma fase ? if not lv_ok: # logger l_log = logging.getLogger("CModelDBEdit::__init__") l_log.setLevel(logging.CRITICAL) l_log.critical(u"<E01: Erro na carga da base de dados.") # cria um evento de quit l_evt = events.CQuit() assert l_evt # dissemina o evento self._event.post(l_evt) # termina a aplicação sys.exit(1)
def make_trf(self, fdct_root, fdct_data): """ carrega os dados de tráfego a partir de um dicionário @param fdct_root: DOCUMENT ME! @param fdct_data: lista de dados de tráfego @return flag e mensagem """ # logger # M_LOG.info("make_trf:>>") # check input assert fdct_root is not None assert fdct_data is not None # return code lv_ok = True # mensagem ls_msg = None # é uma tráfego do newton ? if "trafegos" != fdct_root["tagName"]: # logger l_log = logging.getLogger("CTrfData::make_trf") l_log.setLevel(logging.CRITICAL) l_log.critical(u"<E01: não é um arquivo de tráfego.") # cria um evento de quit l_evt = events.CQuit() assert l_evt # dissemina o evento self.__event.post(l_evt) # se não for, cai fora... sys.exit(1) # é um arquivo do newton ? if "NEWTON" != fdct_root["FORMAT"]: # logger l_log = logging.getLogger("CTrfData::make_trf") l_log.setLevel(logging.CRITICAL) l_log.critical(u"<E02: não está em um formato aceito.") # cria um evento de quit l_evt = events.CQuit() assert l_evt # dissemina o evento self.__event.post(l_evt) # se não for, cai fora... sys.exit(1) # é a assinatura do newton ? if "1961" != fdct_root["CODE"]: # logger l_log = logging.getLogger("CTrfData::make_trf") l_log.setLevel(logging.CRITICAL) l_log.critical(u"<E03: não tem a assinatura correta.") # cria um evento de quit l_evt = events.CQuit() assert l_evt # dissemina o evento self.__event.post(l_evt) # se não for, cai fora... sys.exit(1) # verifica se existe indicativo if "nTrf" in fdct_data: # cria a tráfego l_trf = model.CTrfNEW(self.__model, fdct_data, fdct_root["VERSION"]) assert l_trf # coloca a tráfego no dicionário self[fdct_data["nTrf"]] = l_trf # otherwise, não existe indicativo else: # monta uma mensagem ls_msg = u"não tem identificação. Tráfego não incluído." # logger l_log = logging.getLogger("CTrfData::make_trf") l_log.setLevel(logging.WARNING) l_log.warning(u"<E04: {}".format(ls_msg)) # se não for, cai fora... return False, ls_msg # logger # M_LOG.info("make_trf:<<") # retorna Ok return lv_ok, ls_msg
def make_prf(self, fdct_root, fdct_data): """ carrega os dados de performance a partir de um dicionário @param fdct_data: lista de dados de performance @return flag e mensagem """ # logger # M_LOG.info("make_prf:>>") # check input assert fdct_root is not None assert fdct_data is not None # mensagem ls_msg = None # é uma performance do newton ? if "performances" != fdct_root["tagName"]: # logger l_log = logging.getLogger("CPrfData::make_prf") l_log.setLevel(logging.CRITICAL) l_log.critical(u"<E01: não é um arquivo de performance.") # cria um evento de quit l_evt = events.CQuit() assert l_evt # dissemina o evento self.__event.post(l_evt) # se não for, cai fora... sys.exit(1) # é um arquivo do newton ? if "NEWTON" != fdct_root["FORMAT"]: # logger l_log = logging.getLogger("CPrfData::make_prf") l_log.setLevel(logging.CRITICAL) l_log.critical(u"<E02: não está em um formato aceito.") # cria um evento de quit l_evt = events.CQuit() assert l_evt # dissemina o evento self.__event.post(l_evt) # se não for, cai fora... sys.exit(1) # é a assinatura do newton ? if "1961" != fdct_root["CODE"]: # logger l_log = logging.getLogger("CPrfData::make_prf") l_log.setLevel(logging.CRITICAL) l_log.critical(u"<E03: não tem a assinatura correta.") # cria um evento de quit l_evt = events.CQuit() assert l_evt # dissemina o evento self.__event.post(l_evt) # se não for, cai fora... sys.exit(1) # verifica se existe identificação if "nPrf" in fdct_data: # cria performance l_prf = model.CPrfNEW(self.__event, fdct_data, fdct_root["VERSION"]) assert l_prf # coloca a performance no dicionário self[fdct_data["nPrf"]] = l_prf # senão, não existe designador else: # monta a mensagem ls_msg = u"Não tem designador. Performance não incluída." # logger l_log = logging.getLogger("CPrfData::make_prf") l_log.setLevel(logging.WARNING) l_log.warning(u"<E04: {}".format(ls_msg)) # se não for, cai fora... return False, ls_msg # logger # M_LOG.info("make_prf:<<") # retorna ok return True, None
def make_apx(self, fdct_root, fdct_data): """ carrega os dados de procedimento de aproximação a partir de um dicionário @param fdct_data: lista de dados de procedimento de aproximação @return flag e mensagem """ # check input assert fdct_root is not None assert fdct_data is not None # é uma procedimento de aproximação do newton ? if "aproximacoes" != fdct_root["tagName"]: # logger l_log = logging.getLogger("CApxData::make_apx") l_log.setLevel(logging.CRITICAL) l_log.critical( u"<E01: não é um arquivo de procedimentos de aproximação.") # cria um evento de quit l_evt = events.CQuit() assert l_evt # dissemina o evento self.__event.post(l_evt) # se não for, cai fora... sys.exit(1) # é um arquivo do newton ? if "NEWTON" != fdct_root["FORMAT"]: # logger l_log = logging.getLogger("CApxData::make_apx") l_log.setLevel(logging.CRITICAL) l_log.critical(u"<E02: não está em um formato aceito.") # cria um evento de quit l_evt = events.CQuit() assert l_evt # dissemina o evento self.__event.post(l_evt) # se não for, cai fora... sys.exit(1) # é a assinatura do newton ? if "1961" != fdct_root["CODE"]: # logger l_log = logging.getLogger("CApxData::make_apx") l_log.setLevel(logging.CRITICAL) l_log.critical(u"<E03: não tem a assinatura correta.") # cria um evento de quit l_evt = events.CQuit() assert l_evt # dissemina o evento self.__event.post(l_evt) # se não for, cai fora... sys.exit(1) # verifica se existe identificação if "nApx" in fdct_data: # cria procedimento de aproximação l_apx = model.CApxNEW(self.__model, fdct_data, fdct_root["VERSION"]) assert l_apx # coloca a procedimento de aproximação no dicionário self[fdct_data["nApx"]] = l_apx # senão, não existe identificação else: # monta uma mensagem ls_msg = u"não tem identificação. Aproximação não incluída." # logger l_log = logging.getLogger("CApxData::make_apx") l_log.setLevel(logging.WARNING) l_log.warning(u"<E04: {}".format(ls_msg)) # se não for, cai fora... return False, ls_msg # retorna Ok return True, None
def parse_prf_xml(self, fs_prf_pn): """ carrega o arquivo de performance @param fs_prf_pn: pathname do arquivo em disco """ # logger # M_LOG.info("parse_prf_xml:>>") # check input assert fs_prf_pn # cria o QFile para o arquivo XML do performance l_data_file = QtCore.QFile(fs_prf_pn) assert l_data_file is not None # abre o arquivo XML do performance l_data_file.open(QtCore.QIODevice.ReadOnly) # erro na abertura do arquivo ? if not l_data_file.isOpen(): # logger l_log = logging.getLogger("CPrfData::parse_prf_xml") l_log.setLevel(logging.CRITICAL) l_log.critical(u"<E01: erro na abertura de {}.".format(fs_prf_pn)) # cria um evento de quit l_evt = events.CQuit() assert l_evt # dissemina o evento self.__event.post(l_evt) # termina a aplicação sys.exit(1) # cria o documento XML do performance l_xdoc_prf = QtXml.QDomDocument("performances") assert l_xdoc_prf is not None # erro na carga do documento ? if not l_xdoc_prf.setContent(l_data_file): # fecha o arquivo l_data_file.close() # logger l_log = logging.getLogger("CPrfData::parse_prf_xml") l_log.setLevel(logging.CRITICAL) l_log.critical(u"<E02: falha no parse de {}.".format(fs_prf_pn)) # cria um evento de quit l_evt = events.CQuit() assert l_evt # dissemina o evento self.__event.post(l_evt) # termina a aplicação sys.exit(1) # fecha o arquivo l_data_file.close() # obtém o elemento raíz do documento l_elem_root = l_xdoc_prf.documentElement() assert l_elem_root is not None # faz o parse dos atributos do elemento raíz ldct_root = parser.parse_root_element(l_elem_root) # cria uma lista com os elementos de performance l_node_list = l_elem_root.elementsByTagName("performance") # para todos os nós na lista... for li_ndx in xrange(l_node_list.length()): # inicia o dicionário de dados ldct_data = {} # obtém um nó da lista l_element = l_node_list.at(li_ndx).toElement() assert l_element is not None # read identification if available if l_element.hasAttribute("nPrf"): ldct_data["nPrf"] = str(l_element.attribute("nPrf")) # obtém o primeiro nó da sub-árvore l_node = l_element.firstChild() assert l_node is not None # percorre a sub-árvore while not l_node.isNull(): # tenta converter o nó em um elemento l_element = l_node.toElement() assert l_element is not None # o nó é um elemento ? if not l_element.isNull(): # faz o parse do elemento ldct_tmp = parser.parse_performance(l_element) # atualiza o dicionário de dados ldct_data.update(ldct_tmp) # próximo nó l_node = l_node.nextSibling() assert l_node is not None # carrega os dados de performance a partir de um dicionário self.make_prf(ldct_root, ldct_data)
def make_exe(self, f_dct_root, f_dct_data): """ carrega os dados de exercício a partir de um dicionário @param f_dct_data: lista de dados de exercício @return flag e mensagem """ # logger # M_LOG.info("make_exe:>>") # check input parameters assert f_dct_root is not None assert f_dct_data is not None # é uma exercício do newton ? if "exercicios" != f_dct_root["tagName"]: # logger l_log = logging.getLogger("CExeData::make_exe") l_log.setLevel(logging.CRITICAL) l_log.critical(u"<E01: não é um arquivo de exercício.") # cria um evento de quit l_evt = events.CQuit() assert l_evt # dissemina o evento self.__event.post(l_evt) # se não for, cai fora... sys.exit(1) # é um arquivo do newton ? if "NEWTON" != f_dct_root["FORMAT"]: # logger l_log = logging.getLogger("CExeData::make_exe") l_log.setLevel(logging.CRITICAL) l_log.critical(u"<E02: não está em um formato aceito.") # cria um evento de quit l_evt = events.CQuit() assert l_evt # dissemina o evento self.__event.post(l_evt) # se não for, cai fora... sys.exit(1) # é a assinatura do newton ? if "1961" != f_dct_root["CODE"]: # logger l_log = logging.getLogger("CExeData::make_exe") l_log.setLevel(logging.CRITICAL) l_log.critical(u"<E03: não tem a assinatura correta.") # cria um evento de quit l_evt = events.CQuit() assert l_evt # dissemina o evento self.__event.post(l_evt) # se não for, cai fora... sys.exit(1) # verifica se existe indicativo if "nExe" in f_dct_data: # cria exercício l_exe = model.CExeNEW(self.__model, f_dct_data, f_dct_root["VERSION"]) assert l_exe # coloca a exercício no dicionário self[f_dct_data["nExe"]] = l_exe # senão, não existe indicativo else: # monta uma mensagem ls_msg = u"não tem identificação. Exercício não incluído." # logger l_log = logging.getLogger("CExeData::make_exe") l_log.setLevel(logging.WARNING) l_log.warning("<E04: {}".format(ls_msg)) # se não for, cai fora... return False, ls_msg # logger # M_LOG.info("make_exe:<<") # retorna Ok return True, None