Sisyphus repositório
Última atualização: 1 outubro 2023 | SRPMs: 18631 | Visitas: 37712592
en ru br
ALT Linux repositórios
S:5.27.8-alt1

Group :: Sistema/Configurações/Pacotes
RPM: plasma5-discover

 Main   Changelog   Spec   Patches   Sources   Download   Gear   Bugs e FR  Repocop 

Patch: alt-discover-update-all-packages-from-appstream.patch
Download


diff --git b/discover/libdiscover/backends/PackageKitBackend/PackageKitBackend.cpp a/discover/libdiscover/backends/PackageKitBackend/PackageKitBackend.cpp
index d15c9142..b7e52f9f 100644
--- b/discover/libdiscover/backends/PackageKitBackend/PackageKitBackend.cpp
+++ a/discover/libdiscover/backends/PackageKitBackend/PackageKitBackend.cpp
@@ -79,8 +79,8 @@ PackageKitBackend::PackageKitBackend(QObject *parent)
     connect(PackageKit::Daemon::global(), &PackageKit::Daemon::restartScheduled, m_updater, &PackageKitUpdater::enableNeedsReboot);
     connect(PackageKit::Daemon::global(), &PackageKit::Daemon::isRunningChanged, this, &PackageKitBackend::checkDaemonRunning);
     connect(m_reviews.data(), &OdrsReviewsBackend::ratingsReady, this, [this] {
-        m_reviews->emitRatingFetched(this, kTransform<QList<AbstractResource *>>(m_packages.packages, [](AbstractResource *r) {
-                                         return r;
+        m_reviews->emitRatingFetched(this, kTransform<QList<AbstractResource *>>(m_packages.packages, [](QSharedPointer<AbstractResource> r) {
+                                         return r.get();
                                      }));
     });
 
@@ -236,22 +236,35 @@ AppPackageKitResource *PackageKitBackend::addComponent(const AppStream::Componen
     Q_ASSERT(!pkgNames.isEmpty());
 
     auto &resPos = m_packages.packages[component.id()];
-    AppPackageKitResource *res = qobject_cast<AppPackageKitResource *>(resPos);
+    QSharedPointer<AppPackageKitResource> res = qSharedPointerCast<AppPackageKitResource>(resPos);
     if (!res) {
-        res = new AppPackageKitResource(component, pkgNames.at(0), this);
+        res.reset(new AppPackageKitResource(component, pkgNames.at(0), this));
         resPos = res;
     } else {
         res->clearPackageIds();
     }
     for (const QString &pkg : pkgNames) {
         m_packages.packageToApp[pkg] += component.id();
+
+        bool found_resource = false;
+
+        foreach (const QSharedPointer<AbstractResource> iter, m_packages.allPackages[component.id()]) {
+            if (iter->packageName() == pkg) {
+                found_resource = true;
+                break;
+            }
+        }
+
+        if (!found_resource) {
+            m_packages.allPackages[component.id()].append((pkg == res->packageName()) ? res: QSharedPointer<AppPackageKitResource>(new AppPackageKitResource(component, pkg, this)));
+        }
     }
 
     const auto componentExtends = component.extends();
-    for (const QString &pkg : componentExtends) {
-        m_packages.extendedBy[pkg] += res;
+    for (const QString &pkg : component.extends()) {
+        m_packages.extendedBy[pkg] += res.get();
     }
-    return res;
+    return res.get();
 }
 
 void PackageKitBackend::resolvePackages(const QStringList &packageNames)
@@ -308,7 +321,7 @@ void PackageKitBackend::addPackage(PackageKit::Transaction::Info info, const QSt
     if (r.isEmpty()) {
         auto pk = new PackageKitResource(packageName, summary, this);
         r = {pk};
-        m_packagesToAdd.insert(pk);
+        m_packagesToAdd.insert(QSharedPointer<PackageKitResource>(pk));
     }
     for (auto res : qAsConst(r))
         static_cast<PackageKitResource *>(res)->addPackageId(info, packageId, arch);
@@ -325,21 +338,21 @@ void PackageKitBackend::includePackagesToAdd()
         return;
 
     acquireFetching(true);
-    for (PackageKitResource *res : qAsConst(m_packagesToAdd)) {
+    for (QSharedPointer<PackageKitResource> res : qAsConst(m_packagesToAdd)) {
         m_packages.packages[res->packageName()] = res;
     }
-    for (PackageKitResource *res : qAsConst(m_packagesToDelete)) {
+    for (QSharedPointer<PackageKitResource> res : qAsConst(m_packagesToDelete)) {
         const auto pkgs = m_packages.packageToApp.value(res->packageName(), {res->packageName()});
         for (const auto &pkg : pkgs) {
             auto res = m_packages.packages.take(pkg);
             if (res) {
-                if (AppPackageKitResource *ares = qobject_cast<AppPackageKitResource *>(res)) {
+                    if (QSharedPointer<AppPackageKitResource> ares = qSharedPointerCast<AppPackageKitResource>(res)) {
                     const auto extends = res->extends();
                     for (const auto &ext : extends)
-                        m_packages.extendedBy[ext].removeAll(ares);
+                        m_packages.extendedBy[ext].removeAll(ares.get());
                 }
 
-                Q_EMIT resourceRemoved(res);
+                Q_EMIT resourceRemoved(res.get());
                 res->deleteLater();
             }
         }
@@ -379,14 +392,26 @@ T PackageKitBackend::resourcesByPackageNames(const QStringList &pkgnames) const
     for (const QString &name : pkgnames) {
         const QStringList names = m_packages.packageToApp.value(name, QStringList(name));
         for (const QString &name : names) {
-            AbstractResource *res = m_packages.packages.value(name);
+            QSharedPointer<AbstractResource> res = m_packages.packages.value(name);
             if (res)
-                ret += res;
+                ret += res.get();
         }
     }
     return ret;
 }
 
+QList<AbstractResource*> PackageKitBackend::allResourcesByApp(AbstractResource* res) const
+{
+    auto intermediate = m_packages.allPackages.value(res->appstreamId());
+    QList<AbstractResource*> result;
+
+    for (const QSharedPointer<AbstractResource> &iter : intermediate) {
+        result += iter.get();
+    }
+
+    return result;
+}
+
 void PackageKitBackend::checkForUpdates()
 {
     if (PackageKit::Daemon::global()->offline()->updateTriggered()) {
@@ -415,7 +440,7 @@ QList<AppStream::Component> PackageKitBackend::componentsById(const QString &id)
     return m_appdata->componentsById(id);
 }
 
-static const auto needsResolveFilter = [](AbstractResource *res) {
+static const auto needsResolveFilter = [](QSharedPointer<AbstractResource> res) {
     return res->state() == AbstractResource::Broken;
 };
 
@@ -443,7 +468,12 @@ public:
         if (res.isEmpty())
             return;
 
-        const auto toResolve = kFilter<QVector<AbstractResource *>>(res, needsResolveFilter);
+        QVector<QSharedPointer<AbstractResource>> intermediate;
+        for (const auto i : res) {
+            intermediate += QSharedPointer<AbstractResource>(i);
+        }
+
+        const auto toResolve = kFilterSharedPtr<QVector<AbstractResource *>>(intermediate, needsResolveFilter);
         if (!toResolve.isEmpty())
             backend->resolvePackages(kTransform<QStringList>(toResolve, [](AbstractResource *res) {
                 return res->packageName();
@@ -476,9 +506,9 @@ ResultsStream *PackageKitBackend::search(const AbstractResourcesBackend::Filters
     } else if (filter.state == AbstractResource::Installed) {
         auto stream = new PKResultsStream(this, QStringLiteral("PackageKitStream-installed"));
         auto f = [this, stream, filter] {
-            const auto toResolve = kFilter<QVector<AbstractResource *>>(m_packages.packages, needsResolveFilter);
+            const auto toResolve = kFilterSharedPtr<QVector<AbstractResource *>>(m_packages.packages, needsResolveFilter);
 
-            auto installedAndNameFilter = [filter](AbstractResource *res) {
+            auto installedAndNameFilter = [filter](QSharedPointer<AbstractResource> res) {
                 return res->state() >= AbstractResource::Installed && !qobject_cast<PackageKitResource *>(res)->isCritical()
                     && (res->name().contains(filter.search, Qt::CaseInsensitive) || res->packageName().compare(filter.search, Qt::CaseInsensitive) == 0);
             };
@@ -488,7 +518,12 @@ ResultsStream *PackageKitBackend::search(const AbstractResourcesBackend::Filters
                     return res->packageName();
                 }));
                 connect(m_resolveTransaction, &PKResolveTransaction::allFinished, this, [stream, toResolve, installedAndNameFilter] {
-                    const auto resolved = kFilter<QVector<AbstractResource *>>(toResolve, installedAndNameFilter);
+                    QVector<QSharedPointer<AbstractResource>> intermediate;
+                    for (const auto i : toResolve) {
+                        intermediate += QSharedPointer<AbstractResource>(i);
+                    }
+
+                    const auto resolved = kFilterSharedPtr<QVector<AbstractResource *>>(intermediate, installedAndNameFilter);
                     if (!resolved.isEmpty())
                         Q_EMIT stream->resourcesFound(resolved);
                     stream->finish();
@@ -496,7 +531,7 @@ ResultsStream *PackageKitBackend::search(const AbstractResourcesBackend::Filters
                 furtherSearch = true;
             }
 
-            const auto resolved = kFilter<QVector<AbstractResource *>>(m_packages.packages, installedAndNameFilter);
+            const auto resolved = kFilterSharedPtr<QVector<AbstractResource *>>(m_packages.packages, installedAndNameFilter);
             if (!resolved.isEmpty()) {
                 QTimer::singleShot(0, this, [resolved, toResolve, stream]() {
                     if (!resolved.isEmpty())
@@ -516,7 +551,7 @@ ResultsStream *PackageKitBackend::search(const AbstractResourcesBackend::Filters
     } else if (filter.search.isEmpty()) {
         auto stream = new PKResultsStream(this, QStringLiteral("PackageKitStream-all"));
         auto f = [this, filter, stream] {
-            auto resources = kFilter<QVector<AbstractResource *>>(m_packages.packages, [](AbstractResource *res) {
+            auto resources = kFilterSharedPtr<QVector<AbstractResource *>>(m_packages.packages, [](QSharedPointer<AbstractResource> res) {
                 return res->type() != AbstractResource::Technical && !qobject_cast<PackageKitResource *>(res)->isCritical()
                     && !qobject_cast<PackageKitResource *>(res)->extendsItself();
             });
@@ -603,7 +638,7 @@ PKResultsStream *PackageKitBackend::findResourceByPackageName(const QUrl &url)
                              && id.startsWith(it.key(), Qt::CaseInsensitive));
                     });
                     if (matches) {
-                        pkg = it.value();
+                        pkg = it.value().get();
                         break;
                     }
                 }
diff --git b/discover/libdiscover/backends/PackageKitBackend/PackageKitBackend.h a/discover/libdiscover/backends/PackageKitBackend/PackageKitBackend.h
index 7b967bf5..1ae7de97 100644
--- b/discover/libdiscover/backends/PackageKitBackend/PackageKitBackend.h
+++ a/discover/libdiscover/backends/PackageKitBackend/PackageKitBackend.h
@@ -35,6 +35,7 @@ public:
     AbstractBackendUpdater *backendUpdater() const override;
     AbstractReviewsBackend *reviewsBackend() const override;
     QSet<AbstractResource *> resourcesByPackageName(const QString &name) const;
+    QList<AbstractResource*> allResourcesByApp(AbstractResource* res) const;
 
     ResultsStream *search(const AbstractResourcesBackend::Filters &search) override;
     PKResultsStream *findResourceByPackageName(const QUrl &search);
@@ -115,12 +116,13 @@ private:
     int m_isFetching;
     QSet<QString> m_updatesPackageId;
     bool m_hasSecurityUpdates = false;
-    QSet<PackageKitResource *> m_packagesToAdd;
-    QSet<PackageKitResource *> m_packagesToDelete;
+    QSet<QSharedPointer<PackageKitResource>> m_packagesToAdd;
+    QSet<QSharedPointer<PackageKitResource>> m_packagesToDelete;
     bool m_appstreamInitialized = false;
 
     struct {
-        QHash<QString, AbstractResource *> packages;
+        QHash<QString, QSharedPointer<AbstractResource>> packages;
+        QHash<QString, QList<QSharedPointer<AbstractResource>>> allPackages;
         QHash<QString, QStringList> packageToApp;
         QHash<QString, QVector<AppPackageKitResource *>> extendedBy;
     } m_packages;
diff --git b/discover/libdiscover/backends/PackageKitBackend/PackageKitUpdater.cpp a/discover/libdiscover/backends/PackageKitBackend/PackageKitUpdater.cpp
index 2dc4f091..8bcf8bd0 100644
--- b/discover/libdiscover/backends/PackageKitBackend/PackageKitUpdater.cpp
+++ a/discover/libdiscover/backends/PackageKitBackend/PackageKitUpdater.cpp
@@ -336,13 +336,30 @@ QSet<QString> PackageKitUpdater::involvedPackages(const QSet<AbstractResource *>
         }
 
         PackageKitResource *app = qobject_cast<PackageKitResource *>(res);
+
+        bool found = false;
+
         const QString pkgid = m_backend->upgradeablePackageId(app);
-        if (pkgid.isEmpty()) {
-            qWarning() << "no upgradeablePackageId for" << app;
-            continue;
+        if (!pkgid.isEmpty()) {
+            found = true;
+            packageIds.insert(pkgid);
+        }
+
+        QList<AbstractResource*> resources = m_backend->allResourcesByApp(app);
+
+        foreach (const auto &iter, resources) {
+            QString pkgid = m_backend->upgradeablePackageId(qobject_cast<PackageKitResource*>(iter));
+
+            if (!pkgid.isEmpty()) {
+                found = true;
+                packageIds.insert(pkgid);
+            }
         }
 
-        packageIds.insert(pkgid);
+        if (!found) {
+            qWarning() << "no upgradeablePackageId for" << res->name();
+            continue;
+        }
     }
     return packageIds;
 }
diff --git b/discover/libdiscover/utils.h a/discover/libdiscover/utils.h
index d553c9c5..d3b33ee2 100644
--- b/discover/libdiscover/utils.h
+++ a/discover/libdiscover/utils.h
@@ -89,6 +89,17 @@ static T kFilter(const Q &input, _UnaryOperation op)
     return ret;
 }
 
+template <typename T, typename Q, typename _UnaryOperation>
+static T kFilterSharedPtr(const Q &input, _UnaryOperation op)
+{
+    T ret;
+    for(const auto& v : input) {
+        if (op(v))
+            ret += v.get();
+    }
+    return ret;
+}
+
 template<typename Q, typename W>
 static int kIndexOf(const Q &list, W func)
 {
 
projeto & código: Vladimir Lettiev aka crux © 2004-2005, Andrew Avramenko aka liks © 2007-2008
mantenedor atual: Michael Shigorin
mantenedor da tradução: Fernando Martini aka fmartini © 2009