chore(web): direct type usage in templates instead of copy (#1218)

## Description
In many cases in Web we create intermediate data structure and copy data
there without
any necessity. It is simpler just use filters and RPC types.

This PR removes some such places. 

## Type of Change
- [ ] **Add** - New feature or capability
- [ ] **Change** - Changes in existing functionality  
- [ ] **Fix** - Bug fixes
- [ ] **Remove** - Removed features or deprecated functionality
- [x] **Internal** - Internal changes (refactoring, tests, docs, etc.)

## Related Issues (Optional)

## Breaking Changes
- [ ] This PR contains breaking changes

## Testing
- [ ] Unit tests added/updated
- [ ] Integration tests added/updated  
- [ ] Manual testing performed
- [x] No testing required (docs, internal refactor, etc.)

## Additional Notes

Signed-off-by: Dmitry Porokh <dporokh@nvidia.com>

Author: poroh

crates/api/src/web/domain.rs

@@ -24,35 +24,13 @@ use axum::response::{Html, IntoResponse, Response};
 use hyper::http::StatusCode;
 use rpc::forge::forge_server::Forge;
 
+use super::filters;
 use crate::api::Api;
 
 #[derive(Template)]
 #[template(path = "domain_show.html")]
 struct DomainShow {
-    domains: Vec<DomainRowDisplay>,
-}
-
-struct DomainRowDisplay {
-    id: String,
-    name: String,
-    created: String,
-    updated: String,
-    deleted: String,
-}
-
-impl From<::rpc::protos::dns::Domain> for DomainRowDisplay {
-    fn from(d: ::rpc::protos::dns::Domain) -> Self {
-        Self {
-            id: d.id.unwrap_or_default().to_string(),
-            name: d.name,
-            created: d.created.unwrap_or_default().to_string(),
-            updated: d.updated.unwrap_or_default().to_string(),
-            deleted: d
-                .deleted
-                .map(|x| x.to_string())
-                .unwrap_or("Not Deleted".to_string()),
-        }
-    }
+    domains: Vec<::rpc::protos::dns::Domain>,
 }
 
 /// List domains
@@ -65,15 +43,11 @@ pub async fn show_html(AxumState(state): AxumState<Arc<Api>>) -> Response {
         }
     };
 
-    let mut out = Vec::new();
-    for domain in domains.domains.into_iter() {
-        out.push(domain.into());
-    }
-
-    let tmpl = DomainShow { domains: out };
+    let tmpl = DomainShow {
+        domains: domains.domains,
+    };
     (StatusCode::OK, Html(tmpl.render().unwrap())).into_response()
 }
-
 pub async fn show_all_json(AxumState(state): AxumState<Arc<Api>>) -> Response {
     let domains = match fetch_domains(state).await {
         Ok(m) => m,

crates/api/src/web/dpa.rs

@@ -26,33 +26,14 @@ use rpc::forge as forgerpc;
 use rpc::forge::forge_server::Forge;
 use uuid::Uuid;
 
+use super::filters;
 use super::state_history::StateHistoryTable;
 use crate::api::Api;
 
 #[derive(Template)]
 #[template(path = "dpa_show.html")]
 struct DpaShow {
-    dpas: Vec<DpaRowDisplay>,
-}
-
-struct DpaRowDisplay {
-    id: String,
-    machine_id: String,
-    state: String,
-    created: String,
-    macaddr: String,
-}
-
-impl From<forgerpc::DpaInterface> for DpaRowDisplay {
-    fn from(dpa: forgerpc::DpaInterface) -> Self {
-        Self {
-            id: dpa.id.map(|i| i.to_string()).unwrap_or_default(),
-            machine_id: dpa.machine_id.map(|i| i.to_string()).unwrap_or_default(),
-            created: dpa.created.map(|c| c.to_string()).unwrap_or_default(),
-            macaddr: dpa.mac_addr,
-            state: dpa.controller_state,
-        }
-    }
+    dpas: Vec<forgerpc::DpaInterface>,
 }
 
 /// List DPAs
@@ -65,9 +46,7 @@ pub async fn show_dpas_html(AxumState(state): AxumState<Arc<Api>>) -> Response {
         }
     };
 
-    let tmpl = DpaShow {
-        dpas: dpas.into_iter().map(Into::into).collect(),
-    };
+    let tmpl = DpaShow { dpas };
     (StatusCode::OK, Html(tmpl.render().unwrap())).into_response()
 }
 
@@ -118,50 +97,17 @@ async fn fetch_dpas(api: Arc<Api>) -> Result<Vec<forgerpc::DpaInterface>, tonic:
 #[derive(Template)]
 #[template(path = "dpa_detail.html")]
 struct DpaDetail {
-    id: String,
-    machine_id: String,
-    macaddr: String,
-    created: String,
-    updated: String,
-    deleted: String,
-    underlay_ip: String,
-    overlay_ip: String,
-    state: String,
-    state_version: String,
-    network_config: String,
-    network_config_version: String,
-    network_status_observation: String,
+    dpa: forgerpc::DpaInterface,
     history: StateHistoryTable,
 }
 
 impl From<forgerpc::DpaInterface> for DpaDetail {
     fn from(dpa: forgerpc::DpaInterface) -> Self {
-        let mut history_records = Vec::new();
-
-        for record in dpa.history.into_iter().rev() {
-            history_records.push(record.into());
-        }
-
         let history = StateHistoryTable {
-            records: history_records,
+            records: dpa.history.iter().rev().cloned().map(Into::into).collect(),
         };
 
-        Self {
-            id: dpa.id.map(|i| i.to_string()).unwrap_or_default(),
-            machine_id: dpa.machine_id.map(|i| i.to_string()).unwrap_or_default(),
-            macaddr: dpa.mac_addr,
-            created: dpa.created.map(|c| c.to_string()).unwrap_or_default(),
-            updated: dpa.updated.map(|c| c.to_string()).unwrap_or_default(),
-            deleted: dpa.deleted.map(|c| c.to_string()).unwrap_or_default(),
-            underlay_ip: dpa.underlay_ip,
-            overlay_ip: dpa.overlay_ip,
-            state: dpa.controller_state,
-            state_version: dpa.controller_state_version,
-            network_config: dpa.network_config,
-            network_config_version: dpa.network_config_version,
-            network_status_observation: dpa.network_status_observation,
-            history,
-        }
+        Self { dpa, history }
     }
 }
 

crates/api/src/web/filters.rs

@@ -222,6 +222,13 @@ pub fn option_fmt(value: &Option<impl Display>) -> askama::Result<String> {
     })
 }
 
+pub fn option_fmt_or(value: &Option<impl Display>, default: &str) -> askama::Result<String> {
+    Ok(match value {
+        Some(value) => value.to_string(),
+        None => default.to_string(),
+    })
+}
+
 pub(crate) fn normalize_state_label(state: impl Display) -> String {
     state_and_substate_labels(state).0
 }

crates/api/src/web/ib_fabric.rs

@@ -30,11 +30,7 @@ use crate::api::Api;
 #[derive(Template)]
 #[template(path = "ib_fabric_show.html")]
 struct IbFabricShow {
-    fabrics: Vec<IbFabricRowDisplay>,
-}
-
-struct IbFabricRowDisplay {
-    id: String,
+    fabrics: Vec<String>,
 }
 
 /// List fabrics
@@ -51,12 +47,7 @@ pub async fn show_html(AxumState(state): AxumState<Arc<Api>>) -> Response {
         }
     };
 
-    let tmpl = IbFabricShow {
-        fabrics: fabrics
-            .into_iter()
-            .map(|id| IbFabricRowDisplay { id })
-            .collect(),
-    };
+    let tmpl = IbFabricShow { fabrics };
     (StatusCode::OK, Html(tmpl.render().unwrap())).into_response()
 }
 

crates/api/src/web/ipxe_template.rs

@@ -15,6 +15,7 @@
  * limitations under the License.
  */
 
+use std::borrow::Cow;
 use std::sync::Arc;
 
 use askama::Template;
@@ -25,37 +26,26 @@ use hyper::http::StatusCode;
 use rpc::forge as forgerpc;
 use rpc::forge::forge_server::Forge;
 
+fn ipxe_template_scope_fmt(scope: &i32) -> Cow<'static, str> {
+    rpc::forge::IpxeTemplateScope::try_from(*scope)
+        .map(|scope| Cow::Owned(format!("{scope:?}")))
+        .unwrap_or(Cow::Borrowed("Unknown"))
+}
+
+mod filters {
+    pub use super::super::filters::option_fmt;
+
+    pub fn ipxe_template_scope_fmt(scope: &i32) -> askama::Result<super::Cow<'static, str>> {
+        Ok(super::ipxe_template_scope_fmt(scope))
+    }
+}
+
 use crate::api::Api;
 
 #[derive(Template)]
 #[template(path = "ipxe_template_show.html")]
 struct IpxeTemplateShow {
-    templates: Vec<IpxeTemplateRowDisplay>,
-}
-
-struct IpxeTemplateRowDisplay {
-    id: String,
-    name: String,
-    description: String,
-    scope: String,
-    required_params_count: usize,
-    required_artifacts_count: usize,
-}
-
-impl From<&forgerpc::IpxeTemplate> for IpxeTemplateRowDisplay {
-    fn from(tmpl: &forgerpc::IpxeTemplate) -> Self {
-        let scope = forgerpc::IpxeTemplateScope::try_from(tmpl.scope)
-            .map(|s| format!("{s:?}"))
-            .unwrap_or_else(|_| "Unknown".to_string());
-        Self {
-            id: tmpl.id.as_ref().map(|u| u.to_string()).unwrap_or_default(),
-            name: tmpl.name.clone(),
-            description: tmpl.description.clone(),
-            scope,
-            required_params_count: tmpl.required_params.len(),
-            required_artifacts_count: tmpl.required_artifacts.len(),
-        }
-    }
+    templates: Vec<forgerpc::IpxeTemplate>,
 }
 
 pub async fn show_html(AxumState(state): AxumState<Arc<Api>>) -> Response {
@@ -71,9 +61,7 @@ pub async fn show_html(AxumState(state): AxumState<Arc<Api>>) -> Response {
         }
     };
 
-    let tmpl = IpxeTemplateShow {
-        templates: templates.iter().map(Into::into).collect(),
-    };
+    let tmpl = IpxeTemplateShow { templates };
     (StatusCode::OK, Html(tmpl.render().unwrap())).into_response()
 }
 
@@ -103,29 +91,12 @@ async fn fetch_templates(api: Arc<Api>) -> Result<Vec<forgerpc::IpxeTemplate>, t
 #[derive(Template)]
 #[template(path = "ipxe_template_detail.html")]
 struct IpxeTemplateDetail {
-    name: String,
-    description: String,
-    scope: String,
-    required_params: Vec<String>,
-    reserved_params: Vec<String>,
-    required_artifacts: Vec<String>,
-    template_text: String,
+    tmpl: forgerpc::IpxeTemplate,
 }
 
 impl From<forgerpc::IpxeTemplate> for IpxeTemplateDetail {
     fn from(tmpl: forgerpc::IpxeTemplate) -> Self {
-        let scope = forgerpc::IpxeTemplateScope::try_from(tmpl.scope)
-            .map(|s| format!("{s:?}"))
-            .unwrap_or_else(|_| "Unknown".to_string());
-        Self {
-            name: tmpl.name,
-            description: tmpl.description,
-            scope,
-            required_params: tmpl.required_params,
-            reserved_params: tmpl.reserved_params,
-            required_artifacts: tmpl.required_artifacts,
-            template_text: tmpl.template,
-        }
+        Self { tmpl }
     }
 }
 

crates/api/src/web/rack.rs

@@ -32,16 +32,7 @@ use crate::api::Api;
 #[derive(Template)]
 #[template(path = "rack_show.html")]
 struct Racks {
-    racks: Vec<RackRecord>,
-}
-
-#[derive(Debug, serde::Serialize)]
-struct RackRecord {
-    id: String,
-    rack_state: String,
-    compute_trays: String,
-    power_shelves: String,
-    switches: String,
+    racks: Vec<rpc::forge::Rack>,
 }
 
 #[derive(Template)]
@@ -74,31 +65,7 @@ pub async fn show_html(state: AxumState<Arc<Api>>) -> Response {
         }
     };
 
-    let racks = racks
-        .racks
-        .into_iter()
-        .map(|rack| RackRecord {
-            id: rack.id.map(|id| id.to_string()).unwrap_or_default(),
-            rack_state: rack.rack_state,
-            compute_trays: format!(
-                "{} / {}",
-                rack.compute_trays.len(),
-                rack.expected_compute_trays.len()
-            ),
-            power_shelves: format!(
-                "{} / {}",
-                rack.power_shelves.len(),
-                rack.expected_power_shelves.len()
-            ),
-            switches: format!(
-                "{} / {}",
-                rack.switches.len(),
-                rack.expected_nvlink_switches.len()
-            ),
-        })
-        .collect();
-
-    let display = Racks { racks };
+    let display = Racks { racks: racks.racks };
     (StatusCode::OK, Html(display.render().unwrap())).into_response()
 }