Esempio n. 1
0
def getUpdates(aSysArgv):

    updates = []
    argc = len(aSysArgv)
    path = os.path.abspath(aSysArgv[1])
    if argc == 3:
        updates.extend(fromPathAndDate(path, aSysArgv[2]))
    else:
        updates.extend(fromPath(path))
    updates = Updates.separateToKnownAndUnknown(updates)
    return updates
def updates4Target(aStorage, aVersion, aPlatform, aLanguage, aPathToReport):

    KBs = core.kb.getKBsFromReportFile(aPathToReport) if None != aPathToReport else None
    version = Versions().getVersion('{0}{1}{0}'.format(os.sep, aVersion.replace(' ', '')))
    platform = Types().getType('{0}{1}{0}'.format(os.sep, aPlatform))
    language = Languages().getLanguage('{0}{1}{0}'.format(os.sep, aLanguage))

    query = {}
    if None != KBs and KBs != []:
        query['KB'] = KBs
    if not isinstance(version, dict):
        query['Version'] = version
    if not isinstance(platform, dict):
        query['Type'] = platform
    if not isinstance(language, dict):
        query['Language'] = language

    updates = aStorage.get(query)
    Updates.sortByFieldUpToDown(updates, 'Path')

    return (updates, version, platform, language, KBs)
Esempio n. 3
0
def updates4Target(aStorage, aVersion, aPlatform, aLanguage, aPathToReport):

    KBs = core.kb.getKBsFromReportFile(
        aPathToReport) if None != aPathToReport else None
    version = Versions().getVersion('{0}{1}{0}'.format(
        os.sep, aVersion.replace(' ', '')))
    platform = Types().getType('{0}{1}{0}'.format(os.sep, aPlatform))
    language = Languages().getLanguage('{0}{1}{0}'.format(os.sep, aLanguage))

    query = {}
    if None != KBs and KBs != []:
        query['KB'] = KBs
    if not isinstance(version, dict):
        query['Version'] = version
    if not isinstance(platform, dict):
        query['Type'] = platform
    if not isinstance(language, dict):
        query['Language'] = language

    updates = aStorage.get(query)
    Updates.sortByFieldUpToDown(updates, 'Path')

    return (updates, version, platform, language, KBs)
def getFullPath2UnknownUpdatesAtList(aPathToUifFile,
                                     aPathToRootFolderWihtUpdates):

    updates = Uif.getUpdatesFromStorage(aPathToUifFile)
    updates = Updates.separateToKnownAndUnknown(updates)

    files = []
    for up in updates['unKnown']:
        if not isinstance(up['KB'], dict):
            files.append(up['Path'])

    if 0 < len(files):
        return relPaths2Full(aPathToRootFolderWihtUpdates, files)

    return []
def getFullPath2UnknownUpdatesAtList(aPathToUifFile,
                                     aPathToRootFolderWihtUpdates):

    updates = Uif.getUpdatesFromStorage(aPathToUifFile)
    updates = Updates.separateToKnownAndUnknown(updates)

    files = []
    for up in updates['unKnown']:
        if not isinstance(up['KB'], dict):
            files.append(up['Path'])

    if 0 < len(files):
        return relPaths2Full(aPathToRootFolderWihtUpdates, files)

    return []
Esempio n. 6
0
    def get(self, aQuery, aLimit=-1, aSkip=0, aSort=None):

        query = {}

        for key in Updates.validKeys:
            if key in aQuery.keys():
                if 'Date' == key:
                    aQuery[key] = core.dates.toDateTime(aQuery[key])

                value = aQuery[key]

                if isinstance(value, list):
                    value = {'$in': value}
                query[key] = value

        if aLimit < 0:
            aLimit = None

        sort = None
        if aSort:
            for key in Updates.validKeys:
                if key in aSort.keys():
                    value = aSort[key]
                    if (isinstance(value, int) and value < 0):
                        value = -1
                    else:
                        value = 1
                    sort = [(key, value)]
                    break

        projection = {'_id': 0}

        updates = self.mDbClient.getItemsFromDB(self.mDataBase, self.mTable, query, projection, aSkip, aLimit, sort)

        updates = Updates.separateToKnownAndUnknown(updates)
        updates['known'].extend(updates['unKnown'])
        updates = updates['known']

        return updates
Esempio n. 7
0
    def get(self, aQuery, aLimit=-1, aSkip=0, aSort=None):

        if aLimit == 0:
            return []

        updates = []

        if aQuery:
            for update in self.mUpdates:
                match = True

                for key in Updates.validKeys:
                    if key in aQuery.keys():
                        if 'Date' == key:
                            aQuery[key] = core.dates.toDate(aQuery[key])

                        value = aQuery[key]

                        if isinstance(value, list):
                            if update[key] not in value:
                                match = False
                                break
                        elif not update[key] == value:
                            match = False
                            break

                if match:
                    updates.append(update)
        else:
            updates.extend(self.mUpdates)

        if aSort:
            updates = Updates.separateToKnownAndUnknown(updates)

            for key in Updates.validKeys:
                if key in aSort.keys():
                    value = aSort[key]
                    if (isinstance(value, int) and value < 0):
                        updates['known'].sort(key=lambda up: up[key], reverse=True)
                    else:
                        updates['known'].sort(key=lambda up: up[key])
                    break

            updates['known'].extend(updates['unKnown'])
            updates = updates['known']

        count = len(updates)

        if aSkip > 0:
            if aSkip < count:
                if aLimit > 0:
                    ups = []
                    for i in range(aSkip, min(aSkip + aLimit, count)):
                        ups.append(updates[i])
                    updates = ups
                else:
                    ups = []
                    for i in range(aSkip, count):
                        ups.append(updates[i])
                    updates = ups
            else:
                return []
        elif aLimit > 0:
            ups = []
            for i in range(0, min(aLimit, count)):
                ups.append(updates[i])
            updates = ups

        return updates
Esempio n. 8
0
    def get(self, aQuery, aLimit=-1, aSkip=0, aSort=None):

        statement = ('SELECT kb_id, Date, Path, Version, Type, Language FROM Updates'
                     ' INNER JOIN KBs ON kb_id LIKE KBs.id'
                     ' INNER JOIN Dates ON date_id LIKE Dates.id'
                     ' INNER JOIN Paths ON path_id LIKE Paths.id'
                     ' INNER JOIN Versions ON version_id LIKE Versions.id'
                     ' INNER JOIN Types ON type_id LIKE Types.id'
                     ' INNER JOIN Languages ON language_id LIKE Languages.id')

        if aQuery:
            subStatement = []
            for key in Updates.validKeys:
                if key in aQuery.keys():
                    if 'Date' == key:
                        aQuery[key] = core.dates.toString(aQuery[key])

                    value = aQuery[key]

                    if 'KB' == key:
                        key = 'KBs.id'

                    if isinstance(value, int):
                        subStatement.append('{} LIKE {}'.format(key, value))
                    elif isinstance(value, str):
                        subStatement.append('{} LIKE \'{}\''.format(key, value))
                    elif isinstance(value, list):
                        value = '{}'.format(value)
                        value = value.replace('[', '')
                        value = value.replace(']', '')
                        subStatement.append('{} IN ({})'.format(key, value))
            if subStatement:
                statement = '{} WHERE {}'.format(statement, subStatement[0])
                for i in range(1, len(subStatement)):
                    statement = '{} AND {}'.format(statement, subStatement[i])

        statement = statement.replace('\\\\', '\\')

        if aSort:
            for key in Updates.validKeys:
                if key in aSort.keys():
                    value = aSort[key]
                    if 'KB' == key:
                        key = 'KBs.id'
                    if (isinstance(value, int) and value < 0):
                        value = 'DESC'
                    else:
                        value = 'ASC'
                    statement = '{} ORDER BY {} {}'.format(statement, key, value)
                    break

        statement = '{} LIMIT {} OFFSET {}'.format(statement, aLimit, aSkip)

        readResult = db.sqliteDB.readAsync(self.mInit, statement, lambda l: l.fetchall())

        if not readResult:
            return []

        kb_num = 0
        date_num = 1
        path_num = 2
        version_num = 3
        type_num = 4
        language_num = 5

        updates = []
        for r in readResult:
            update = {}
            update['Date'] = core.dates.toDate(r[date_num])
            update['Path'] = r[path_num]

            if -1 != r[kb_num]:
                update['KB'] = r[kb_num]
            else:
                update['KB'] = UnknownSubstance.unknown('UNKNOWN KB',
                                                        update['Path'])

            if 'UNKNOWN VERSION' != r[version_num]:
                update['Version'] = r[version_num]
            else:
                update['Version'] = UnknownSubstance.unknown('UNKNOWN VERSION',
                                                             update['Path'])

            if 'UNKNOWN TYPE' != r[type_num]:
                update['Type'] = r[type_num]
            else:
                update['Type'] = UnknownSubstance.unknown('UNKNOWN TYPE',
                                                          update['Path'])

            if 'UNKNOWN LANGUAGE' != r[language_num]:
                update['Language'] = r[language_num]
            else:
                update['Language'] = UnknownSubstance.unknown('UNKNOWN LANGUAGE',
                                                              update['Path'])

            updates.append(update)

        updates = Updates.separateToKnownAndUnknown(updates)
        updates['known'].extend(updates['unKnown'])
        updates = updates['known']

        return updates