Adapt the software UI to the new HTTP/JSON API

rust/agama-lib/src/software/client.rs

@@ -1,14 +1,15 @@
 use super::proxies::Software1Proxy;
 use crate::error::ServiceError;
 use serde::Serialize;
+use serde_repr::Serialize_repr;
 use std::collections::HashMap;
 use zbus::Connection;
 
 /// Represents a software product
 #[derive(Debug, Serialize, utoipa::ToSchema)]
 pub struct Pattern {
-    /// Pattern ID (eg., "aaa_base", "gnome")
-    pub id: String,
+    /// Pattern name (eg., "aaa_base", "gnome")
+    pub name: String,
     /// Pattern category (e.g., "Production")
     pub category: String,
     /// Pattern icon path locally on system
@@ -22,7 +23,8 @@ pub struct Pattern {
 }
 
 /// Represents the reason why a pattern is selected.
-#[derive(Clone, Copy, Debug, PartialEq, Serialize)]
+#[derive(Clone, Copy, Debug, PartialEq, Serialize_repr)]
+#[repr(u8)]
 pub enum SelectedBy {
     /// The pattern was selected by the user.
     User = 0,
@@ -69,8 +71,8 @@ impl<'a> SoftwareClient<'a> {
             .await?
             .into_iter()
             .map(
-                |(id, (category, description, icon, summary, order))| Pattern {
-                    id,
+                |(name, (category, description, icon, summary, order))| Pattern {
+                    name,
                     category,
                     icon,
                     description,
@@ -118,11 +120,19 @@ impl<'a> SoftwareClient<'a> {
     }
 
     /// Selects patterns by user
-    pub async fn select_patterns(&self, patterns: &[String]) -> Result<(), ServiceError> {
-        let patterns: Vec<&str> = patterns.iter().map(AsRef::as_ref).collect();
+    pub async fn select_patterns(
+        &self,
+        patterns: HashMap<String, bool>,
+    ) -> Result<(), ServiceError> {
+        let (add, remove): (Vec<_>, Vec<_>) =
+            patterns.into_iter().partition(|(_, install)| *install);
+
+        let add: Vec<_> = add.iter().map(|(name, _)| name.as_ref()).collect();
+        let remove: Vec<_> = remove.iter().map(|(name, _)| name.as_ref()).collect();
+
         let wrong_patterns = self
             .software_proxy
-            .set_user_patterns(patterns.as_slice())
+            .set_user_patterns(add.as_slice(), remove.as_slice())
             .await?;
         if !wrong_patterns.is_empty() {
             Err(ServiceError::UnknownPatterns(wrong_patterns))

rust/agama-lib/src/software/proxies.rs

@@ -48,7 +48,7 @@ trait Software1 {
     fn remove_pattern(&self, id: &str) -> zbus::Result<bool>;
 
     /// SetUserPatterns method
-    fn set_user_patterns(&self, ids: &[&str]) -> zbus::Result<Vec<String>>;
+    fn set_user_patterns(&self, add: &[&str], remove: &[&str]) -> zbus::Result<Vec<String>>;
 
     /// UsedDiskSpace method
     fn used_disk_space(&self) -> zbus::Result<String>;

rust/agama-lib/src/software/store.rs

@@ -1,5 +1,7 @@
 //! Implements the store for the storage settings.
 
+use std::collections::HashMap;
+
 use super::{SoftwareClient, SoftwareSettings};
 use crate::error::ServiceError;
 use zbus::Connection;
@@ -22,9 +24,12 @@ impl<'a> SoftwareStore<'a> {
     }
 
     pub async fn store(&self, settings: &SoftwareSettings) -> Result<(), ServiceError> {
-        self.software_client
-            .select_patterns(&settings.patterns)
-            .await?;
+        let patterns: HashMap<String, bool> = settings
+            .patterns
+            .iter()
+            .map(|name| (name.to_owned(), true))
+            .collect();
+        self.software_client.select_patterns(patterns).await?;
 
         Ok(())
     }

rust/agama-server/src/software/web.rs

@@ -35,9 +35,12 @@ struct SoftwareState<'a> {
     software: SoftwareClient<'a>,
 }
 
+/// Software service configuration (product, patterns, etc.).
 #[derive(Clone, Serialize, Deserialize, utoipa::ToSchema)]
 pub struct SoftwareConfig {
-    patterns: Option<Vec<String>>,
+    /// A map where the keys are the pattern names and the values whether to install them or not.
+    patterns: Option<HashMap<String, bool>>,
+    /// Name of the product to install.
     product: Option<String>,
 }
 
@@ -92,7 +95,7 @@ async fn patterns_changed_stream(
             }
             None
         })
-        .filter_map(|e| e.map(Event::PatternsChanged));
+        .filter_map(|e| e.map(|patterns| Event::SoftwareProposalChanged { patterns }));
     Ok(stream)
 }
 
@@ -150,43 +153,16 @@ async fn products(State(state): State<SoftwareState<'_>>) -> Result<Json<Vec<Pro
     Ok(Json(products))
 }
 
-/// Represents a pattern.
-///
-/// It augments the information coming from the D-Bus client.
-#[derive(Serialize, utoipa::ToSchema)]
-pub struct PatternEntry {
-    #[serde(flatten)]
-    pattern: Pattern,
-    selected_by: SelectedBy,
-}
-
 /// Returns the list of software patterns.
 ///
 /// * `state`: service state.
 #[utoipa::path(get, path = "/software/patterns", responses(
-    (status = 200, description = "List of known software patterns", body = Vec<PatternEntry>),
+    (status = 200, description = "List of known software patterns", body = Vec<Pattern>),
     (status = 400, description = "The D-Bus service could not perform the action")
 ))]
-async fn patterns(
-    State(state): State<SoftwareState<'_>>,
-) -> Result<Json<Vec<PatternEntry>>, Error> {
+async fn patterns(State(state): State<SoftwareState<'_>>) -> Result<Json<Vec<Pattern>>, Error> {
     let patterns = state.software.patterns(true).await?;
-    let selected = state.software.selected_patterns().await?;
-    let items = patterns
-        .into_iter()
-        .map(|pattern| {
-            let selected_by: SelectedBy = selected
-                .get(&pattern.id)
-                .copied()
-                .unwrap_or(SelectedBy::None);
-            PatternEntry {
-                pattern,
-                selected_by,
-            }
-        })
-        .collect();
-
-    Ok(Json(items))
+    Ok(Json(patterns))
 }
 
 /// Sets the software configuration.
@@ -206,7 +182,7 @@ async fn set_config(
     }
 
     if let Some(patterns) = config.patterns {
-        state.software.select_patterns(&patterns).await?;
+        state.software.select_patterns(patterns).await?;
     }
 
     Ok(())
@@ -226,7 +202,13 @@ async fn get_config(State(state): State<SoftwareState<'_>>) -> Result<Json<Softw
     } else {
         Some(product)
     };
-    let patterns = state.software.user_selected_patterns().await?;
+    let patterns = state
+        .software
+        .user_selected_patterns()
+        .await?
+        .into_iter()
+        .map(|p| (p, true))
+        .collect();
     let config = SoftwareConfig {
         patterns: Some(patterns),
         product,
@@ -240,6 +222,9 @@ pub struct SoftwareProposal {
     /// Space required for installation. It is returned as a formatted string which includes
     /// a number and a unit (e.g., "GiB").
     size: String,
+    /// Patterns selection. It is respresented as a hash map where the key is the pattern's name
+    /// and the value why the pattern is selected.
+    patterns: HashMap<String, SelectedBy>,
 }
 
 /// Returns the proposal information.
@@ -251,7 +236,8 @@ pub struct SoftwareProposal {
 ))]
 async fn proposal(State(state): State<SoftwareState<'_>>) -> Result<Json<SoftwareProposal>, Error> {
     let size = state.software.used_disk_space().await?;
-    let proposal = SoftwareProposal { size };
+    let patterns = state.software.selected_patterns().await?;
+    let proposal = SoftwareProposal { size, patterns };
     Ok(Json(proposal))
 }
 

rust/agama-server/src/web/docs.rs

@@ -34,7 +34,6 @@ use utoipa::OpenApi;
         schemas(crate::network::model::Device),
         schemas(crate::network::model::Connection),
         schemas(agama_lib::network::types::DeviceType),
-        schemas(crate::software::web::PatternEntry),
         schemas(crate::software::web::SoftwareConfig),
         schemas(crate::software::web::SoftwareProposal),
         schemas(crate::manager::web::InstallerStatus),

rust/agama-server/src/web/event.rs

@@ -21,7 +21,11 @@ pub enum Event {
     ProductChanged {
         id: String,
     },
-    PatternsChanged(HashMap<String, SelectedBy>),
+    // TODO: it should include the full software proposal or, at least,
+    // all the relevant changes.
+    SoftwareProposalChanged {
+        patterns: HashMap<String, SelectedBy>,
+    },
     QuestionsChanged,
     InstallationPhaseChanged {
         phase: InstallationPhase,

service/lib/agama/dbus/software/manager.rb

@@ -89,7 +89,9 @@ def issues
 
           dbus_method(:AddPattern, "in id:s, out result:b") { |p| backend.add_pattern(p) }
           dbus_method(:RemovePattern, "in id:s, out result:b") { |p| backend.remove_pattern(p) }
-          dbus_method(:SetUserPatterns, "in ids:as, out wrong:as") { |ids| [backend.assign_patterns(ids)] }
+          dbus_method(:SetUserPatterns, "in add:as, in remove:as, out wrong:as") do |add, remove|
+            [backend.assign_patterns(add, remove)]
+          end
 
           dbus_method :ProvisionsSelected, "in Provisions:as, out Result:ab" do |provisions|
             [provisions.map { |p| backend.provision_selected?(p) }]

service/lib/agama/software/manager.rb

@@ -249,16 +249,28 @@ def remove_pattern(id)
         true
       end
 
-      def assign_patterns(ids)
-        wrong_patterns = ids.reject { |p| pattern_exist?(p) }
+      def assign_patterns(add, remove)
+        wrong_patterns = [add, remove].flatten.reject { |p| pattern_exist?(p) }
         return wrong_patterns unless wrong_patterns.empty?
 
         user_patterns = Yast::PackagesProposal.GetResolvables(PROPOSAL_ID, :pattern)
         user_patterns.each { |p| Yast::Pkg.ResolvableNeutral(p, :pattern, force = false) }
-        Yast::PackagesProposal.SetResolvables(PROPOSAL_ID, :pattern, ids)
-        ids.each { |p| Yast::Pkg.ResolvableInstall(p, :pattern) }
-        logger.info "Setting patterns to #{ids.inspect}"
+        logger.info "Adding patterns: #{add.join(", ")}. Removing patterns: #{remove.join(",")}."
+
+        Yast::PackagesProposal.SetResolvables(PROPOSAL_ID, :pattern, add)
+        add.each do |id|
+          res = Yast::Pkg.ResolvableInstall(id, :pattern)
+          logger.info "Adding pattern #{id}: #{res.inspect}"
+        end
+
+        remove.each do |id|
+          res = Yast::Pkg.ResolvableNeutral(id, :pattern, force = false)
+          logger.info "Removing pattern #{id}: #{res.inspect}"
+          Yast::PackagesProposal.RemoveResolvables(PROPOSAL_ID, :pattern, [id])
+        end
+
         proposal.solve_dependencies
+
         selected_patterns_changed
 
         []

web/src/client/index.js

@@ -78,7 +78,7 @@ const createClient = (url) => {
   const manager = new ManagerClient(client);
   // const monitor = new Monitor(address, MANAGER_SERVICE);
   // const network = new NetworkClient(address);
-  // const software = new SoftwareClient(address);
+  const software = new SoftwareClient(client);
   // const storage = new StorageClient(address);
   // const users = new UsersClient(address);
   // const questions = new QuestionsClient(address);
@@ -139,7 +139,7 @@ const createClient = (url) => {
     manager,
     // monitor,
     // network,
-    // software,
+    software,
     // storage,
     // users,
     // questions,

web/src/client/mixins.js

@@ -150,7 +150,7 @@ const WithStatus = (superclass, status_path, service_name) =>
      * Register a callback to run when the "CurrentInstallationPhase" changes
      *
      * @param {function} handler - callback function
-     * @return {function} function to disable the callback
+     * @return {import ("./http").RemoveFn} function to disable the callback
      */
     onStatusChange(handler) {
       return this.client.onEvent("ServiceStatusChanged", ({ status, service }) => {
@@ -207,7 +207,7 @@ const WithProgress = (superclass, progress_path, service_name) =>
      * Register a callback to run when the progress changes
      *
      * @param {ProgressHandler} handler - callback function
-     * @return {import ("./dbus").RemoveFn} function to disable the callback
+     * @return {import ("./http").RemoveFn} function to disable the callback
      */
     onProgressChange(handler) {
       return this.client.onEvent("Progress", ({ service, ...progress }) => {