Ejemplo n.º 1
0
    def parse_exe_xml(self, fs_exe_path):
        """
        carrega o arquivo de exercício

        @param fs_exe_path: pathname do arquivo em disco
        """
        # logger
        # M_LOG.info("parse_exe_xml:>>")

        # check input parameters
        assert fs_exe_path

        # cria o QFile para o arquivo XML do exercício
        l_data_file = QtCore.QFile(fs_exe_path)
        assert l_data_file is not None

        # abre o arquivo XML do exercício
        l_data_file.open(QtCore.QIODevice.ReadOnly)

        # erro na abertura do arquivo ?
        if not l_data_file.isOpen():
            # logger
            l_log = logging.getLogger("CExeData::parse_exe_xml")
            l_log.setLevel(logging.CRITICAL)
            l_log.critical(
                u"<E01: erro na abertura de {}.".format(fs_exe_path))

            # 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 exercício
        l_xdoc_exe = QtXml.QDomDocument("exercicios")
        assert l_xdoc_exe is not None

        # erro na carga do documento ?
        if not l_xdoc_exe.setContent(l_data_file):
            # fecha o arquivo
            l_data_file.close()

            # logger
            l_log = logging.getLogger("CExeData::parse_exe_xml")
            l_log.setLevel(logging.CRITICAL)
            l_log.critical(u"<E02: falha no parse de {}.".format(fs_exe_path))

            # 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_exe.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 exercício
        l_node_list = l_elem_root.elementsByTagName("exercicio")

        # 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("nExe"):
                ldct_data["nExe"] = str(l_element.attribute("nExe"))

            # 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_exercicio(l_element)
                    # M_LOG.debug("ldct_tmp: {}".format(ldct_tmp))

                    # 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 exercício a partir de um dicionário
            self.make_exe(ldct_root, ldct_data)
Ejemplo n.º 2
0
    def _parse_sub_xml(self, fs_sub_pn):
        """
        carrega o arquivo de procedimentos de subida

        @param fs_sub_pn: pathname do arquivo em disco
        """
        # logger
        # M_LOG.info("_parse_sub_xml:>>")

        # check input
        assert fs_sub_pn

        # cria o QFile para o arquivo XML do procedimentos de subida
        l_data_file = QtCore.QFile(fs_sub_pn)
        assert l_data_file is not None

        # abre o arquivo XML do procedimentos de subida
        l_data_file.open(QtCore.QIODevice.ReadOnly)

        # erro na abertura do arquivo ?
        if not l_data_file.isOpen():
            # logger
            l_log = logging.getLogger("CCSubData::_parse_sub_xml")
            l_log.setLevel(logging.CRITICAL)
            l_log.critical("<E01: erro na abertura de {}.".format(fs_sub_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 procedimento de subida
        # FIXME QtXml is no longer supported.
        l_xdoc_sub = QtXml.QDomDocument("subidas")
        assert l_xdoc_sub is not None

        # erro na carga do documento ?
        if not l_xdoc_sub.setContent(l_data_file):
            # fecha o arquivo
            l_data_file.close()

            # logger
            l_log = logging.getLogger("CCSubData::_parse_sub_xml")
            l_log.setLevel(logging.CRITICAL)
            l_log.critical("<E02: falha no parse de {}.".format(fs_sub_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_sub.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 procedimento de subida
        l_node_list = l_elem_root.elementsByTagName("subida")

        # para todos os nós na lista...
        for li_ndx in range(l_node_list.length()):
            # inicia o dicionário de dados
            ldct_data = {}

            # inicia a lista de breakpoints
            ldct_data["breakpoints"] = []

            # 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("nSub"):
                ldct_data["nSub"] = int(l_element.attribute("nSub"))

            # 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_subida(l_element)

                    # tem breakpoint ?
                    if "breakpoint" in ldct_tmp:
                        # atualiza o dicionário com o breakpoint
                        ldct_data["breakpoints"].append(ldct_tmp["breakpoint"])

                        # apaga este elemento
                        del ldct_tmp["breakpoint"]

                    # 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 procedimento de subida a partir de um dicionário
            self._make_sub(ldct_root, ldct_data)