Exemplo n.º 1
0
        def check_f(h, hi, s, ls, bool_list, lbool_list, check_fdepth):
            # noinspection SpellCheckingInspection
            """
            Chequea si un nombre de archivo dentro de h[hi] pertenece a la estructura en s[si] a la misma profundidad,
            si existe entonces lo marca en la jerarquía booleana b[bi].

            Esta función retorna lo siguiente: [TYPE, POSITION, NO_SUBFOLDER]

            - TYPE: Indica tipo de inclusión, _VL_NOT, _VL_TRUE y _VL_TRUE_CHECKED.
            - POSITION: Retorna la posición del elemento en el paquete estructural en donde se encontró el archivo.
            - SUBFOLDER: Retorna true/false si el elemento de la estructura en b[bi] contiene subcarpetas o no.

            :param h: Sublista de jerarquía del paquete a analizar.
            :type h: list
            :param hi: Índice del elemento de la jerarquía del paquete a analizar.
            :type hi: int
            :param s: Sublista de la estructura a analizar.
            :type s: list
            :param ls: Largo de la sublista de la estructura
            :type ls: int
            :param bool_list: Sublista de la jerarquía estructural booleana a analizar.
            :type bool_list: list
            :param lbool_list: Largo de la sublista de la jerarquía booleana
            :type lbool_list: int
            :param check_fdepth: Profundidad de búsqueda
            :type check_fdepth: int

            :return: Lista de valores denotando tipo de pertenencia
            :rtype: list
            """
            # Se obtiene el key a buscar y su tipo
            element_to_check = h[hi]
            element_is_list = isinstance(element_to_check, list)

            # Lista a retornar, 0: Tipo de búsqueda, 1: Índice del elemento encontrado, 2: Si es una carpeta
            reslt = [_VL_NOT, -1, False]

            # Se recorre cada elemento de hs_r
            for hsk in range(0, ls):
                element_in_structure = s[hsk]  # Elemento en la estructura

                # Si el elemento es una lista y el key es una lista

                # Si el elemento en el paquete y en la estructura son listas
                if isinstance(element_in_structure, list) and element_is_list:

                    # Si los nombres de las carpetas son iguales
                    if regex_compare(element_in_structure[0], element_to_check[0], self._validRegexChars,
                                     case_insensitive=self._doRegexCaseInsensitive):

                        # Si el elemento ya fue chequeado entonces se ignora
                        if hsk < lbool_list and bool_list[hsk + 1][0]:
                            reslt[_VL_CHECK] = _VL_TRUE_CHECKED

                        # Si no fue chequeado entonces retorna true y menciona que es subcarpeta
                        else:
                            reslt[_VL_CHECK] = _VL_TRUE
                            reslt[_VL_IS_SUBFOLDER] = True

                        # Se retorna el resultado
                        reslt[_VL_INDEX] = hsk
                        return reslt

                # Si el elemento en el paquete y en la estructura son strings
                if not isinstance(element_in_structure, list) and not element_is_list:

                    # Si los nombres de los archivos son iguales
                    if regex_compare(element_in_structure, element_to_check, self._validRegexChars,
                                     case_insensitive=self._doRegexCaseInsensitive):

                        # Si el elemento ya fue chequeado
                        if hsk < lbool_list and bool_list[hsk + 1]:
                            reslt[_VL_CHECK] = _VL_TRUE_CHECKED

                        # El elemento no ha sido chequeado
                        else:
                            reslt[_VL_CHECK] = _VL_TRUE

                        # Se retorna el resultado
                        reslt[_VL_INDEX] = hsk + 1
                        return reslt

            return reslt
Exemplo n.º 2
0
    def validate_package(self, package, generate_hierarchies=False):
        """
        Valida un paquete, comprobando que todos los archivos del mismo cumplan con la estructura
        cargada.

        :param package: Paquete a comprobar
        :type package: Package
        :param generate_hierarchies: Indica si generar la jerarquía de los archivos válidos e inválidos de los paquetes.
        :type generate_hierarchies: bool

        :return: void
        :rtype: None
        """
        _validatedFilesPackage = []

        # noinspection PyUnusedLocal
        def check_f(h, hi, s, ls, bool_list, lbool_list, check_fdepth):
            # noinspection SpellCheckingInspection
            """
            Chequea si un nombre de archivo dentro de h[hi] pertenece a la estructura en s[si] a la misma profundidad,
            si existe entonces lo marca en la jerarquía booleana b[bi].

            Esta función retorna lo siguiente: [TYPE, POSITION, NO_SUBFOLDER]

            - TYPE: Indica tipo de inclusión, _VL_NOT, _VL_TRUE y _VL_TRUE_CHECKED.
            - POSITION: Retorna la posición del elemento en el paquete estructural en donde se encontró el archivo.
            - SUBFOLDER: Retorna true/false si el elemento de la estructura en b[bi] contiene subcarpetas o no.

            :param h: Sublista de jerarquía del paquete a analizar.
            :type h: list
            :param hi: Índice del elemento de la jerarquía del paquete a analizar.
            :type hi: int
            :param s: Sublista de la estructura a analizar.
            :type s: list
            :param ls: Largo de la sublista de la estructura
            :type ls: int
            :param bool_list: Sublista de la jerarquía estructural booleana a analizar.
            :type bool_list: list
            :param lbool_list: Largo de la sublista de la jerarquía booleana
            :type lbool_list: int
            :param check_fdepth: Profundidad de búsqueda
            :type check_fdepth: int

            :return: Lista de valores denotando tipo de pertenencia
            :rtype: list
            """
            # Se obtiene el key a buscar y su tipo
            element_to_check = h[hi]
            element_is_list = isinstance(element_to_check, list)

            # Lista a retornar, 0: Tipo de búsqueda, 1: Índice del elemento encontrado, 2: Si es una carpeta
            reslt = [_VL_NOT, -1, False]

            # Se recorre cada elemento de hs_r
            for hsk in range(0, ls):
                element_in_structure = s[hsk]  # Elemento en la estructura

                # Si el elemento es una lista y el key es una lista

                # Si el elemento en el paquete y en la estructura son listas
                if isinstance(element_in_structure, list) and element_is_list:

                    # Si los nombres de las carpetas son iguales
                    if regex_compare(element_in_structure[0], element_to_check[0], self._validRegexChars,
                                     case_insensitive=self._doRegexCaseInsensitive):

                        # Si el elemento ya fue chequeado entonces se ignora
                        if hsk < lbool_list and bool_list[hsk + 1][0]:
                            reslt[_VL_CHECK] = _VL_TRUE_CHECKED

                        # Si no fue chequeado entonces retorna true y menciona que es subcarpeta
                        else:
                            reslt[_VL_CHECK] = _VL_TRUE
                            reslt[_VL_IS_SUBFOLDER] = True

                        # Se retorna el resultado
                        reslt[_VL_INDEX] = hsk
                        return reslt

                # Si el elemento en el paquete y en la estructura son strings
                if not isinstance(element_in_structure, list) and not element_is_list:

                    # Si los nombres de los archivos son iguales
                    if regex_compare(element_in_structure, element_to_check, self._validRegexChars,
                                     case_insensitive=self._doRegexCaseInsensitive):

                        # Si el elemento ya fue chequeado
                        if hsk < lbool_list and bool_list[hsk + 1]:
                            reslt[_VL_CHECK] = _VL_TRUE_CHECKED

                        # El elemento no ha sido chequeado
                        else:
                            reslt[_VL_CHECK] = _VL_TRUE

                        # Se retorna el resultado
                        reslt[_VL_INDEX] = hsk + 1
                        return reslt

            return reslt

        def verify_inclusion_recursive(hp_r, hs_r, hs_nr, b_r, b_r_i, b_nr, rootpathi, depth, type_check, hsrootpath,
                                       rootpathi_nrs):
            # noinspection SpellCheckingInspection
            """
            Función auxiliar principal que recorre cada uno de los archivos de un paquete (hp_r) verificando que se
            cumpla la estructura pedida (hs_r), si se cumple entonces se marca la lista de jerarquía booleana y retorna
            true cuando _check_hierarchy_tree retorna True.

            :param hp_r: Lista de jerarquía del paquete recursiva.
            :type hp_r: list
            :param hs_r: Lista de jerarquía de la estructura recursiva.
            :type hs_r: list
            :param hs_nr: Lista de jerarquía no recursiva
            :type hs_nr: list
            :param b_r: Lista de jerarquía booleana recursiva.
            :type b_r: list
            :param b_r_i: Índice de búsqueda de la jerarquía booleana
            :type b_r_i: int
            :param b_nr: Lista de jerarquía booleana no recursiva.
            :type b_nr: list
            :param rootpathi: Indica la posición de un archivo absoluta.
            :type rootpathi: str, unicode
            :param depth: Profundidad de búsqueda
            :type depth: int
            :param type_check: Tipo de búsqueda de archivos, 0 si es clean, 1 si es continuado
            :type type_check: int
            :param hsrootpath: Indica la posición de un archivo de la estructura
            :type hsrootpath: str, unicode
            :param rootpathi_nrs: Indica la posición de un archivo sin repetir carpetas
            :type rootpathi_nrs: str

            :return: Booleano indicando si se debe seguir con la búsqueda o no.
            :rtype: bool
            """
            # Se obtiene la sub lista recursiva de la jerarquía booleana
            if b_r_i > 0:
                # print "{0}==> Se cargo el índice".format("\t" * depth), b_r_i, "de la estructura jerárquica booleana"
                b_r = b_r[b_r_i]

            # Se obtienen los largos de las listas
            lhp = len(hp_r)
            lhs = len(hs_r)
            lbr = len(b_r)

            # Se recorre cada archivo de la lista recursiva del paquete
            for packageFileIndex in range(0, lhp):

                # Se obtiene la información del check
                c = check_f(hp_r, packageFileIndex, hs_r, lhs, b_r, lbr, depth)

                # print "{0}< Resultados del análisis".format("\t" * (depth + 1)), c

                # Si el archivo no existe
                if c[_VL_CHECK] == _VL_NOT:

                    if isinstance(hp_r[packageFileIndex], list) and self._doCheckStructureInSubfolder:

                        # print "{0}<< Se buscara el structure en las subcarpetas de la carpeta fallida".format("\t" * (depth + 1)), c

                        if type_check == 0:
                            nhpr = hp_r[packageFileIndex][1:len(hp_r[packageFileIndex])]
                            nrootpathname = rootpathi + str(hp_r[packageFileIndex][0]) + "/"
                        else:
                            nhpr = hp_r
                            nrootpathname = rootpathi
                            type_check = 2

                        # Se comprueba el resto de subcarpetas
                        if number_of_sublists(nhpr) >= number_of_sublists(hs_nr):
                            if verify_inclusion_recursive(nhpr, hs_nr[1:len(hs_nr)], hs_nr, b_nr, 0, b_nr,
                                                          nrootpathname,
                                                          depth + 1, type_check, "", ""):
                                return False

                # Si el archivo existe pero no ha sido chequeado aún
                elif c[_VL_CHECK] == _VL_TRUE:

                    # Si el archivo es una carpeta entonces se comprueba de forma recursiva
                    if c[_VL_IS_SUBFOLDER]:

                        # Se establece la información para crear un walk recursivo
                        v_index = c[_VL_INDEX]
                        lpfi = len(hp_r[packageFileIndex])
                        lshr = len(hs_r[v_index])
                        rootpath_in = rootpathi + str(hp_r[packageFileIndex][0]) + "/"
                        hsrootpath_in = hsrootpath + str(hs_r[v_index][0]) + "/"
                        if type_check == 2:
                            rootpathi_nrs = hsrootpath
                        else:
                            rootpathi_nrs = hsrootpath + str(hp_r[packageFileIndex][0]) + "/"

                        # Se llama de forma recursiva a dicha carpeta
                        try:
                            # print "{0}\t > Se buscara la carpeta '".format("\t" * (depth + 1)), hp_r[packageFileIndex][1], "'"
                            if not verify_inclusion_recursive(hp_r[packageFileIndex][1:lpfi], hs_r[v_index][1:lshr],
                                                              hs_nr, b_r, v_index + 1, b_nr, rootpath_in, depth + 1, 1,
                                                              hsrootpath_in, rootpathi_nrs):
                                return False
                        except:
                            return self._throw_exception("VALIDATOR_ERROR_ON_VALIDATE_WALK_RECURSIVE")

                    # Si no entonces se marca el archivo en la lista boolena y se comprueba que
                    else:
                        # print "{0}\t > El archivo '".format("\t" * (depth + 1)), hp_r[packageFileIndex], "' se marco como valido"

                        # Se comprueba que el índice sea menor que el largo del bool, si lo es se activa
                        if c[_VL_INDEX] < lbr:
                            b_r[c[_VL_INDEX]] = True
                            _validatedFilesPackage.append(
                                [rootpathi + hp_r[packageFileIndex], hsrootpath + hs_r[c[_VL_INDEX] - 1],
                                 rootpathi_nrs + hp_r[packageFileIndex], hp_r[packageFileIndex]])

                        # Si el puntero a la estructura jerárquica no es valido
                        else:
                            # print "ERROR GRAVE!"
                            return False

                        # Se comprueba la validez booleana
                        self._check_hierarchy_tree(b_nr)

                        # Si la sub carpeta esta validada se retorna
                        if b_nr[0]:
                            return False

                # El archivo fue chequeado
                elif c[_VL_CHECK] == _VL_TRUE_CHECKED:
                    pass

                # Si no corresponde a las alternativas restantes termina la ejecución
                else:
                    return False

            return True

        self._check_variable_type(package, TYPE_OTHER, "package", Package)  # Se chequea el tipo de variable

        # Se chequea si se ha generado la estructura o no
        if not self._isStructGenerated:
            return self._throw_exception("VALIDATOR_ERROR_STRUCTURE_NOT_CREATED")

        b = copy.deepcopy(self._structureBoolHierarchy)

        # Se obtienen las listas de jerarquía
        hp = package.get_hierarchy_files()
        hs = self._structurePackage.get_hierarchy_files()

        # Se marca el paquete ha sido validado
        package._mark_as_validated()

        # Si la lista de jerarquía del paquete está vacía o no existe
        if len(hp) <= 2 and not (len(hp) == 2 and isinstance(hp[1], list)):
            if len(hp) == 2 and regex_compare(hs[1], hp[1], self._validRegexChars):
                _validatedFilesPackage.append([hp[1], hs[1], hp[1], hp[1]])
                package._mark_as_valid()
                package._set_validated_files(_validatedFilesPackage[:], generate_hierarchies)
            return

        # Se llama a la función recursiva
        try:
            verify_inclusion_recursive(hp[1:len(hp)], hs[1:len(hs)], hs, b, 0, b, "", 0, 0, "", "")
        except:
            return self._throw_exception("VALIDATOR_ERROR_ON_VALIDATE_WALK")

        # Se comprueba que el paquete sea valido
        self._check_hierarchy_tree(b)
        if b[0]:
            package._mark_as_valid()

        # Se guardan en el paquete los archivos válidos
        # print _validatedFilesPackage
        package._set_validated_files(_validatedFilesPackage[:], generate_hierarchies)

        del b