Add getApplicablePackages to advisory and isApplicable to advisorymodule

Increases minimal libsolv dependency, since its needed for correct
collections handling.

Author: kontura

VERSION.cmake

@@ -1,5 +1,5 @@
 set (DEFAULT_LIBDNF_MAJOR_VERSION 0)
-set (DEFAULT_LIBDNF_MINOR_VERSION 59)
+set (DEFAULT_LIBDNF_MINOR_VERSION 60)
 set (DEFAULT_LIBDNF_MICRO_VERSION 0)
 
 if(DEFINED LIBDNF_MAJOR_VERSION)

libdnf.spec

@@ -1,10 +1,10 @@
-%global libsolv_version 0.7.7
+%global libsolv_version 0.7.17
 %global libmodulemd_version 2.11.2-2
 %global librepo_version 1.13.0
 %global dnf_conflict 4.3.0
 %global swig_version 3.0.12
 %global libdnf_major_version 0
-%global libdnf_minor_version 59
+%global libdnf_minor_version 60
 %global libdnf_micro_version 0
 
 %define __cmake_in_source_build 1

libdnf/sack/advisory.cpp

@@ -154,6 +154,58 @@ std::vector<AdvisoryModule> Advisory::getModules() const
     return moduleList;
 }
 
+void
+Advisory::getApplicablePackages(std::vector<AdvisoryPkg> & pkglist, bool withFilemanes) const
+{
+    Dataiterator di;
+    Dataiterator di_inner;
+    Pool *pool = dnf_sack_get_pool(sack);
+
+    dataiterator_init(&di, pool, 0, advisory, UPDATE_COLLECTIONLIST, 0, 0);
+    while (dataiterator_step(&di)) {
+        dataiterator_setpos(&di);
+
+        bool isModuleCollectionApplicable = true;
+        dataiterator_init(&di_inner, pool, 0, SOLVID_POS, UPDATE_MODULE, 0, 0);
+        while (dataiterator_step(&di_inner)) {
+            dataiterator_setpos(&di_inner);
+            Id name = pool_lookup_id(pool, SOLVID_POS, UPDATE_MODULE_NAME);
+            Id stream = pool_lookup_id(pool, SOLVID_POS, UPDATE_MODULE_STREAM);
+            Id version = pool_lookup_id(pool, SOLVID_POS, UPDATE_MODULE_VERSION);
+            Id context = pool_lookup_id(pool, SOLVID_POS, UPDATE_MODULE_CONTEXT);
+            Id arch = pool_lookup_id(pool, SOLVID_POS, UPDATE_MODULE_ARCH);
+            AdvisoryModule moduleAdvisory(sack, advisory, name, stream, version, context, arch);
+            if (moduleAdvisory.isApplicable()) {
+                isModuleCollectionApplicable = true;
+                break;
+            } else {
+                isModuleCollectionApplicable = false;
+            }
+        }
+        dataiterator_free(&di_inner);
+
+        if (isModuleCollectionApplicable) {
+            const char * filename = nullptr;
+            dataiterator_setpos(&di);
+
+            dataiterator_init(&di_inner, pool, 0, SOLVID_POS, UPDATE_COLLECTION, 0, 0);
+            while (dataiterator_step(&di_inner)) {
+                dataiterator_setpos(&di_inner);
+                Id name = pool_lookup_id(pool, SOLVID_POS, UPDATE_COLLECTION_NAME);
+                Id evr = pool_lookup_id(pool, SOLVID_POS, UPDATE_COLLECTION_EVR);
+                Id arch = pool_lookup_id(pool, SOLVID_POS, UPDATE_COLLECTION_ARCH);
+                if (withFilemanes) {
+                    filename = pool_lookup_str(pool, SOLVID_POS, UPDATE_COLLECTION_FILENAME);
+                }
+                pkglist.emplace_back(sack, advisory, name, evr, arch, filename);
+            }
+            dataiterator_free(&di_inner);
+        }
+    }
+
+    dataiterator_free(&di);
+}
+
 void
 Advisory::getReferences(std::vector<AdvisoryRef> & reflist) const
 {

libdnf/sack/advisory.hpp

@@ -44,6 +44,7 @@ struct Advisory {
     const char *getName() const;
     void getPackages(std::vector<AdvisoryPkg> & pkglist, bool withFilemanes = true) const;
     std::vector<AdvisoryModule> getModules() const;
+    void getApplicablePackages(std::vector<AdvisoryPkg> & pkglist, bool withFilemanes = true) const;
     void getReferences(std::vector<AdvisoryRef> & reflist) const;
     const char *getRights() const;
     const char *getSeverity() const;

libdnf/sack/advisorymodule.cpp

@@ -73,6 +73,20 @@ AdvisoryModule::nsvcaEQ(AdvisoryModule & other)
         other.pImpl->arch == pImpl->arch;
 }
 
+bool
+AdvisoryModule::isApplicable() const {
+    auto moduleContainer = dnf_sack_get_module_container(pImpl->sack);
+    if (!moduleContainer) {
+        return true;
+    }
+
+    if (!moduleContainer->isEnabled(getName(), getStream())) {
+        return false;
+    }
+
+    return true;
+}
+
 Advisory * AdvisoryModule::getAdvisory() const
 {
     return new Advisory(pImpl->sack, pImpl->advisory);

libdnf/sack/advisorymodule.hpp

@@ -41,6 +41,7 @@ struct AdvisoryModule {
     AdvisoryModule & operator=(const AdvisoryModule & src);
     AdvisoryModule & operator=(AdvisoryModule && src) noexcept;
     bool nsvcaEQ(AdvisoryModule & other);
+    bool isApplicable() const;
     Advisory * getAdvisory() const;
     const char * getName() const;
     const char * getStream() const;