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