Introduced NewTypes for name, description, tags

opendut-carl/src/actions/peers.rs

@@ -311,7 +311,7 @@ mod test {
             let additional_device_id = DeviceId::random();
             let additional_device = DeviceDescriptor {
                 id: additional_device_id,
-                name: DeviceName::try_from("PeerA Device 42").unwrap(),
+                name: DeviceName::try_from("PeerA_Device_42").unwrap(),
                 description: DeviceDescription::try_from("Additional device for peerA").ok(),
                 interface: NetworkInterfaceName::try_from("eth1").unwrap(),
                 tags: vec![],
@@ -364,14 +364,14 @@ mod test {
                 devices: vec![
                     DeviceDescriptor {
                         id: peer_a_device_1,
-                        name: DeviceName::try_from("PeerA Device 1").unwrap(),
+                        name: DeviceName::try_from("PeerA_Device_1").unwrap(),
                         description: DeviceDescription::try_from("Huii").ok(),
                         interface: NetworkInterfaceName::try_from("eth0").unwrap(),
                         tags: vec![],
                     },
                     DeviceDescriptor {
                         id: peer_a_device_2,
-                        name: DeviceName::try_from("PeerA Device 2").unwrap(),
+                        name: DeviceName::try_from("PeerA_Device_2").unwrap(),
                         description: DeviceDescription::try_from("Huii").ok(),
                         interface: NetworkInterfaceName::try_from("eth1").unwrap(),
                         tags: vec![],

opendut-carl/src/cluster/manager.rs

@@ -243,7 +243,7 @@ mod test {
 
     use opendut_types::cluster::ClusterName;
     use opendut_types::peer::{PeerDescriptor, PeerId, PeerLocation, PeerName};
-    use opendut_types::topology::{DeviceDescriptor, DeviceId, Topology};
+    use opendut_types::topology::{DeviceDescription, DeviceDescriptor, DeviceId, DeviceName, Topology};
     use opendut_types::util::net::NetworkInterfaceName;
 
     use crate::actions::{CreateClusterConfigurationParams, StorePeerDescriptorParams};
@@ -279,8 +279,8 @@ mod test {
                 devices: vec![
                     DeviceDescriptor {
                         id: peer_a_device_1,
-                        name: String::from("PeerA Device 1"),
-                        description: String::from("Huii"),
+                        name: DeviceName::try_from("PeerA_Device_1").unwrap(),
+                        description: DeviceDescription::try_from("Huii").ok(),
                         interface: NetworkInterfaceName::try_from("eth0").unwrap(),
                         tags: vec![],
                     }
@@ -293,13 +293,13 @@ mod test {
         let peer_b = PeerDescriptor {
             id: peer_b_id,
             name: PeerName::try_from("PeerB").unwrap(),
-            location: PeerLocation::new("Ulm"),
+            location: PeerLocation::try_from("Ulm").ok(),
             topology: Topology {
                 devices: vec![
                     DeviceDescriptor {
                         id: peer_b_device_1,
-                        name: String::from("PeerB Device 1"),
-                        description: String::from("Pfuii"),
+                        name: DeviceName::try_from("PeerB_Device_1").unwrap(),
+                        description: DeviceDescription::try_from("Pfuii").ok(),
                         interface: NetworkInterfaceName::try_from("can1").unwrap(),
                         tags: vec![],
                     }
@@ -402,8 +402,8 @@ mod test {
         fn device(id: DeviceId, interface: NetworkInterfaceName) -> DeviceDescriptor {
             DeviceDescriptor {
                 id,
-                name: format!("test-device-{id}"),
-                description: String::new(),
+                name: DeviceName::try_from(format!("test-device-{id}")).unwrap(),
+                description: None,
                 interface,
                 tags: Vec::new(),
             }
@@ -419,7 +419,7 @@ mod test {
             PeerDescriptor {
                 id,
                 name: PeerName::try_from(format!("peer-{id}")).unwrap(),
-                location: PeerLocation::new("Ulm"),
+                location: PeerLocation::try_from("Ulm").ok(),
                 topology: Topology {
                     devices,
                 },

opendut-carl/src/grpc/peer_manager.rs

@@ -238,7 +238,7 @@ mod tests {
         let peer_descriptor = PeerDescriptor {
             id: peer_id,
             name: PeerName::try_from("TestPeer").unwrap(),
-            location: PeerLocation::new("SiFi"),
+            location: PeerLocation::try_from("SiFi").ok(),
             topology: Topology::default(),
         };
 

opendut-carl/src/resources/manager.rs

@@ -99,7 +99,7 @@ mod test {
         let peer = PeerDescriptor {
             id: peer_resource_id,
             name: PeerName::try_from("TestPeer").unwrap(),
-            location: PeerLocation::new("Ulm"),
+            location: PeerLocation::try_from("Ulm").ok(),
             topology: Topology::default(),
         };
 

opendut-cleo/src/commands/device.rs

@@ -2,7 +2,7 @@ use cli_table::{Table, WithTitle};
 use serde::Serialize;
 
 use opendut_carl_api::carl::CarlClient;
-use opendut_types::topology::{DeviceDescription, DeviceDescriptor, DeviceId, DeviceName, DeviceTag};
+use opendut_types::topology::{DeviceDescription, DeviceDescriptor, DeviceId, DeviceName};
 
 use crate::ListOutputFormat;
 
@@ -15,7 +15,7 @@ struct DeviceTable {
     #[table(title = "Description")]
     description: DeviceDescription,
     #[table(title = "Tags")]
-    tags: Vec<DeviceTag>,
+    tags: String,
 }
 
 pub async fn list_devices(carl: &mut CarlClient, output: ListOutputFormat) -> crate::Result<()> {
@@ -71,7 +71,7 @@ pub mod create {
                         .map_err(|error| error.to_string())?,
                     interface,
                     tags: tags
-                        .unwrap()
+                        .unwrap_or_default()
                         .into_iter()
                         .map(|value| DeviceTag::try_from(value))
                         .collect::<Result<_, _>>()
@@ -244,7 +244,7 @@ impl From<DeviceDescriptor> for DeviceTable {
             name: device.name,
             id: device.id,
             description: device.description.unwrap_or_default(),
-            tags: device.tags,
+            tags: device.tags.iter().map(|tag| tag.value()).collect::<Vec<_>>().join(", "),
         }
     }
 }

opendut-cleo/src/commands/peer.rs

@@ -81,7 +81,7 @@ pub mod list {
                 PeerTable {
                     name: Clone::clone(&peer.name),
                     id: peer.id,
-                    location: Clone::clone(&peer.location.unwrap_or_default()),
+                    location: Clone::clone(&peer.location.clone().unwrap_or_default()),
                     status,
                 }
             })
@@ -147,7 +147,7 @@ pub mod describe {
             .topology
             .devices
             .iter()
-            .map(|device| device.name.clone())
+            .map(|device| device.name.value())
             .collect::<Vec<_>>()
             .join(", ");
         let text = match output {

opendut-cleo/src/main.rs

@@ -143,7 +143,7 @@ enum CreateResource {
         #[arg(long)]
         interface: Option<NetworkInterfaceName>,
         /// Tags of device
-        #[arg(long)]
+        #[arg(long("tag"))]
         tags: Option<Vec<String>>,
     }
 }

opendut-lea/src/clusters/configurator/components/device_selector.rs

@@ -66,7 +66,7 @@ pub fn DeviceSelector(cluster_configuration: RwSignal<UserClusterConfiguration>)
                             <td>
                                 {&device.name.to_string()}
                             </td>
-                            <td>{peer.location.unwrap_or_default().to_string()}</td>
+                            <td>{peer.location.clone().unwrap_or_default().to_string()}</td>
                             <td class="is-narrow">
                                 <IconButton
                                     icon=FontAwesomeIcon::Check
@@ -149,7 +149,7 @@ pub fn DeviceInfo(device: DeviceDescriptor, peer_id: PeerId) -> impl IntoView {
             <div class="field">
                 <label class="label">Tags</label>
                 <div class="control">
-                    <p>{device.tags.into_iter().map(|tag| tag.value()).collect::<Vec<_>>()}</p>
+                    <p>{device.tags.iter().map(|tag| tag.value()).collect::<Vec<_>>().join("* ")}</p>
                 </div>
             </div>
             <div class="field">

opendut-lea/src/components/inputs/mod.rs

@@ -2,6 +2,7 @@ use crate::util::Ior;
 
 pub mod readonly_input;
 pub mod user_input;
+pub mod user_textarea;
 
 pub type UserInputError = String;
 pub type UserInputValue = Ior<UserInputError, String>;

opendut-lea/src/components/inputs/user_textarea.rs

@@ -0,0 +1,58 @@
+use leptos::*;
+use crate::components::inputs::{UserInputValidator, UserInputValue};
+
+use crate::util::NON_BREAKING_SPACE;
+
+#[component]
+pub fn UserTextarea<A>(
+    getter: Signal<UserInputValue>,
+    setter: SignalSetter<UserInputValue>,
+    #[prop(optional)] validator: Option<A>,
+    #[prop(into)] label: MaybeSignal<String>,
+    #[prop(into)] placeholder: MaybeSignal<String>,
+) -> impl IntoView
+where A: UserInputValidator + 'static {
+
+    let value_text = move || {
+        getter.with(|input| match input {
+            UserInputValue::Left(_) => String::new(),
+            UserInputValue::Right(value) => value.to_owned(),
+            UserInputValue::Both(_, value) => value.to_owned(),
+        })
+    };
+
+    let help_text = move || {
+        getter.with(|input| match input {
+            UserInputValue::Right(_) => String::from(NON_BREAKING_SPACE),
+            UserInputValue::Left(error) => error.to_owned(),
+            UserInputValue::Both(error, _) => error.to_owned(),
+        })
+    };
+
+    let aria_label = Clone::clone(&label);
+
+    view! {
+        <div class="field">
+            <label class="label">{ label }</label>
+            <div class="control">
+                <textarea
+                    class="textarea"
+                    aria-label=move || aria_label.get()
+                    placeholder=move || placeholder.get()
+                    prop:value={ value_text }
+                    on:input=move |ev| {
+                        if let Some(validator) = &validator {
+                            let validated_value = validator.validate(event_target_value(&ev));
+                            setter.set(validated_value);
+                        }
+                        else {
+                            let target_value = event_target_value(&ev);
+                            setter.set(UserInputValue::Right(target_value));
+                        }
+                    }
+                />
+            </div>
+            <p class="help has-text-danger">{ help_text }</p>
+        </div>
+    }
+}

opendut-lea/src/components/mod.rs

@@ -6,6 +6,7 @@ pub use initialized::Initialized;
 pub use inputs::{UserInputError, UserInputValue};
 pub use inputs::readonly_input::ReadOnlyInput;
 pub use inputs::user_input::UserInput;
+pub use inputs::user_textarea::UserTextarea;
 pub use page::BasePageContainer;
 pub use toast::{use_toaster, Toaster, Toast, ToastKind, ToastContent};
 pub use util::ButtonStateSignalProvider;

opendut-lea/src/peers/configurator/mod.rs

@@ -68,7 +68,7 @@ pub fn PeerConfigurator() -> impl IntoView {
                                     id: device.id,
                                     name: UserInputValue::Right(device.name.to_string()),
                                     interface: UserInputValue::Right(device.interface.name()),
-                                    description: device.description.unwrap_or_default().to_string(),
+                                    description: UserInputValue::Right(device.description.unwrap_or_default().to_string()),
                                     is_collapsed: true
                                 })
                             }).collect::<Vec<_>>();

opendut-lea/src/peers/configurator/tabs/devices/device_panel.rs

@@ -1,8 +1,9 @@
-use leptos::{component, create_read_slice, create_slice, event_target_value, IntoView, MaybeSignal, RwSignal, SignalGet, SignalGetUntracked, view};
-use opendut_types::topology::DeviceId;
+use leptos::{component, create_read_slice, create_slice, IntoView, MaybeSignal, RwSignal, SignalGet, SignalGetUntracked, view};
+
+use opendut_types::topology::{DeviceDescription, DeviceId};
 use opendut_types::util::net::NetworkInterfaceName;
 
-use crate::components::{ButtonColor, ButtonSize, ButtonState, ConfirmationButton, FontAwesomeIcon, IconButton, ReadOnlyInput, Toggled, UserInput, UserInputValue};
+use crate::components::{ButtonColor, ButtonSize, ButtonState, ConfirmationButton, FontAwesomeIcon, IconButton, ReadOnlyInput, Toggled, UserInput, UserInputValue, UserTextarea};
 use crate::peers::configurator::types::{EMPTY_DEVICE_NAME_ERROR_MESSAGE, UserDeviceConfiguration};
 
 #[component]
@@ -182,20 +183,25 @@ fn DeviceDescriptionInput(
         }
     );
 
+    let validator = |input: String| {
+        match DeviceDescription::try_from(Clone::clone(&input)) {
+            Err(error) => {
+                UserInputValue::Both(error.to_string(), input)
+            }
+            Ok(_) => {
+                UserInputValue::Right(input)
+            }
+        }
+    };
+
     view! {
-        <div class="field">
-            <label class="label">"Description"</label>
-            <div class="control">
-                <textarea
-                    class="textarea"
-                    aria-label="Description"
-                    prop:value=getter
-                    on:input=move |event| {
-                        setter.set(event_target_value(&event));
-                    }
-                />
-            </div>
-        </div>
+        <UserTextarea
+            getter=getter
+            setter=setter
+            label="Description"
+            placeholder="Description"
+            validator
+        />
     }
 }
 

opendut-lea/src/peers/configurator/tabs/devices/mod.rs

@@ -67,7 +67,7 @@ fn DevicesTable(peer_configuration: RwSignal<UserPeerConfiguration>) -> impl Int
                                 UserDeviceConfiguration {
                                     id: device_id,
                                     name: UserInputValue::Left(String::from(EMPTY_DEVICE_NAME_ERROR_MESSAGE)),
-                                    description: String::new(),
+                                    description: UserInputValue::Right(String::from("")),
                                     interface: UserInputValue::Left(String::from(EMPTY_DEVICE_INTERFACE_ERROR_MESSAGE)),
                                     is_collapsed: false
                                 }

opendut-lea/src/peers/configurator/types.rs

@@ -25,6 +25,8 @@ pub enum DeviceMisconfigurationError {
     InvalidDeviceLocation,
     #[error("Invalid device interface")]
     InvalidDeviceInterface,
+    #[error("Invalid device description")]
+    InvalidDeviceDescription,
 }
 
 #[derive(Clone, Debug)]
@@ -40,7 +42,7 @@ pub struct UserPeerConfiguration {
 pub struct UserDeviceConfiguration {
     pub id: DeviceId,
     pub name: UserInputValue,
-    pub description: String,
+    pub description: UserInputValue,
     pub interface: UserInputValue,
     pub is_collapsed: bool,
 }
@@ -86,19 +88,28 @@ impl TryFrom<UserDeviceConfiguration> for DeviceDescriptor {
     fn try_from(configuration: UserDeviceConfiguration) -> Result<Self, Self::Error> {
         let name = configuration
             .name
-            .right_ok_or(DeviceMisconfigurationError::InvalidDeviceName)?;
+            .right_ok_or(DeviceMisconfigurationError::InvalidDeviceName)
+            .and_then(|name| {
+                DeviceName::try_from(name)
+                    .map_err(|_| DeviceMisconfigurationError::InvalidDeviceName)
+            })?;
         let interface = configuration
             .interface
             .right_ok_or(DeviceMisconfigurationError::InvalidDeviceInterface)
             .and_then(|interface_name| {
                 NetworkInterfaceName::try_from(interface_name)
                     .map_err(|_| DeviceMisconfigurationError::InvalidDeviceInterface)
             })?;
-        let description = DeviceDescription::try_from(configuration.description)
-            .map_err(|error| error.to_string())?;
+        let description = configuration
+            .description
+            .right_ok_or(DeviceMisconfigurationError::InvalidDeviceDescription)
+            .and_then(|description| {
+                DeviceDescription::try_from(description)
+                    .map_err(|_| DeviceMisconfigurationError::InvalidDeviceDescription)
+            })?;
         Ok(DeviceDescriptor {
             id: configuration.id,
-            name: DeviceName::try_from(name).map_err(|error| error.to_string())?,
+            name,
             description: Some(description),
             interface,
             tags: vec![],

opendut-types/src/cluster/mod.rs

@@ -112,7 +112,7 @@ impl TryFrom<String> for ClusterName {
                 actual: length,
             })
         }
-        else if crate::util::invalid_start_and_end_of_a_name( & value).not()
+        else if crate::util::invalid_start_and_end_of_a_name( & value)
             || value.chars().any(|c| crate::util::valid_characters_in_name(&c).not()) {
                 Err(IllegalClusterName::InvalidCharacter {
                     value

opendut-types/src/peer/mod.rs

@@ -159,10 +159,6 @@ impl PeerLocation {
     pub fn value(self) -> String {
         self.0
     }
-
-    pub fn new(location: &str) -> PeerLocation {
-        todo!("delete new function")
-    }
 }
 
 #[derive(thiserror::Error, Clone, Debug)]