server: Add Delete item implementation

Signed-off-by: Dhanuka Warusadura <dhanuka@gnome.org>

Author: warusadura

server/src/collection.rs

@@ -170,9 +170,9 @@ impl Collection {
     ) -> zbus::Result<()>;
 
     #[zbus(signal, name = "ItemDeleted")]
-    async fn item_deleted(
+    pub async fn item_deleted(
         signal_emitter: &SignalEmitter<'_>,
-        item: OwnedObjectPath,
+        item: &OwnedObjectPath,
     ) -> zbus::Result<()>;
 
     #[zbus(signal, name = "ItemChanged")]
@@ -300,4 +300,39 @@ impl Collection {
 
         Ok(())
     }
+
+    pub async fn delete_item(&self, path: &OwnedObjectPath) -> Result<(), ServiceError> {
+        let Some(item) = self.item_from_path(path).await else {
+            return Err(ServiceError::NoSuchObject(format!(
+                "Item `{}` does not exist.",
+                path
+            )));
+        };
+
+        if item.is_locked().await {
+            return Err(ServiceError::IsLocked(format!(
+                "Cannot delete a locked item `{}`",
+                path
+            )));
+        }
+
+        let attributes = item.attributes().await;
+        match self.keyring.delete(&attributes).await {
+            Ok(_) => tracing::debug!("Item `{}` deleted.", path),
+            Err(err) => {
+                return Err(ServiceError::ZBus(zbus::Error::FDO(Box::new(
+                    zbus::fdo::Error::Failed(format!("Failed to deleted item {err}.")),
+                ))))
+            }
+        };
+
+        let mut items = self.items.lock().await;
+        items.retain(|item| item.path() != path);
+        drop(items);
+
+        let signal_emitter = self.service.signal_emitter(&self.path)?;
+        self.items_changed(&signal_emitter).await?;
+
+        Ok(())
+    }
 }

server/src/item.rs

@@ -10,7 +10,7 @@ use oo7::{
     portal,
 };
 use tokio::sync::Mutex;
-use zbus::zvariant::{ObjectPath, OwnedObjectPath};
+use zbus::zvariant::OwnedObjectPath;
 
 use crate::{collection::Collection, Service};
 
@@ -28,8 +28,30 @@ pub struct Item {
 #[zbus::interface(name = "org.freedesktop.Secret.Item")]
 impl Item {
     #[zbus(out_args("prompt"))]
-    pub async fn delete(&self) -> Result<ObjectPath, ServiceError> {
-        todo!()
+    pub async fn delete(
+        &self,
+        #[zbus(object_server)] object_server: &zbus::ObjectServer,
+    ) -> Result<OwnedObjectPath, ServiceError> {
+        let Some(collection) = self
+            .service
+            .collection_from_path(&self.collection_path)
+            .await
+        else {
+            return Err(ServiceError::NoSuchObject(format!(
+                "Collection `{}` does not exist.",
+                &self.collection_path
+            )));
+        };
+
+        collection.delete_item(&self.path).await?;
+        object_server.remove::<Self, _>(&self.path).await?;
+
+        let signal_emitter = self.service.signal_emitter(&self.collection_path)?;
+        Collection::item_deleted(&signal_emitter, &self.path).await?;
+
+        tracing::info!("Item `{}` deleted.", &self.path);
+
+        Ok(OwnedObjectPath::default())
     }
 
     #[zbus(out_args("secret"))]

server/src/service.rs

@@ -358,6 +358,18 @@ impl Service {
         self.connection.object_server()
     }
 
+    pub async fn collection_from_path(&self, path: &OwnedObjectPath) -> Option<Collection> {
+        let collections = self.collections.lock().await;
+
+        for collection in collections.iter() {
+            if collection.path() == path {
+                return Some(collection.clone());
+            }
+        }
+
+        None
+    }
+
     pub async fn session(&self, path: &OwnedObjectPath) -> Option<Arc<Session>> {
         self.sessions.lock().await.get(path).map(Arc::clone)
     }