Checkpoint: Migration to axum

crates/carddav/src/addressbook/methods/report/addressbook_multiget.rs

@@ -4,8 +4,6 @@ use crate::{
         AddressObjectPropWrapper, AddressObjectPropWrapperName, AddressObjectResource,
     },
 };
-use actix_web::dev::{Path, ResourceDef};
-
 use http::StatusCode;
 use rustical_dav::{
     resource::{PrincipalUri, Resource},
@@ -32,27 +30,28 @@ pub async fn get_objects_addressbook_multiget<AS: AddressbookStore>(
     addressbook_id: &str,
     store: &AS,
 ) -> Result<(Vec<AddressObject>, Vec<String>), Error> {
-    let resource_def = ResourceDef::prefix(path).join(&ResourceDef::new("/{object_id}.vcf"));
-
     let mut result = vec![];
     let mut not_found = vec![];
 
     for href in &addressbook_multiget.href {
-        let mut path = Path::new(href.as_str());
-        if !resource_def.capture_match_info(&mut path) {
+        if let Some(filename) = href.strip_prefix(path) {
+            if let Some(object_id) = filename.strip_suffix(".vcf") {
+                match store
+                    .get_object(principal, addressbook_id, object_id, false)
+                    .await
+                {
+                    Ok(object) => result.push(object),
+                    Err(rustical_store::Error::NotFound) => not_found.push(href.to_owned()),
+                    Err(err) => return Err(err.into()),
+                };
+            } else {
+                not_found.push(href.to_owned());
+                continue;
+            }
+        } else {
             not_found.push(href.to_owned());
             continue;
-        };
-        let object_id = path.get("object_id").unwrap();
-        match store
-            .get_object(principal, addressbook_id, object_id, false)
-            .await
-        {
-            Ok(object) => result.push(object),
-            Err(rustical_store::Error::NotFound) => not_found.push(href.to_owned()),
-            // TODO: Maybe add error handling on a per-object basis
-            Err(err) => return Err(err.into()),
-        };
+        }
     }
 
     Ok((result, not_found))

crates/carddav/src/addressbook/methods/report/mod.rs

@@ -1,11 +1,15 @@
-use crate::{CardDavPrincipalUri, Error, address_object::resource::AddressObjectPropWrapperName};
-use actix_web::{
-    HttpRequest, Responder,
-    web::{Data, Path},
+use crate::{
+    CardDavPrincipalUri, Error, address_object::resource::AddressObjectPropWrapperName,
+    addressbook::resource::AddressbookResourceService,
 };
 use addressbook_multiget::{AddressbookMultigetRequest, handle_addressbook_multiget};
+use axum::{
+    Extension,
+    extract::{OriginalUri, Path, State},
+    response::IntoResponse,
+};
 use rustical_dav::xml::{PropfindType, sync_collection::SyncCollectionRequest};
-use rustical_store::{AddressbookStore, auth::User};
+use rustical_store::{AddressbookStore, SubscriptionStore, auth::User};
 use rustical_xml::{XmlDeserialize, XmlDocument};
 use sync_collection::handle_sync_collection;
 use tracing::instrument;
@@ -30,16 +34,15 @@ impl ReportRequest {
     }
 }
 
-#[instrument(skip(req, addr_store))]
-pub async fn route_report_addressbook<AS: AddressbookStore>(
-    path: Path<(String, String)>,
-    body: String,
+#[instrument(skip(addr_store))]
+pub async fn route_report_addressbook<AS: AddressbookStore, S: SubscriptionStore>(
+    Path((principal, addressbook_id)): Path<(String, String)>,
     user: User,
-    req: HttpRequest,
-    puri: Data<CardDavPrincipalUri>,
-    addr_store: Data<AS>,
-) -> Result<impl Responder, Error> {
-    let (principal, addressbook_id) = path.into_inner();
+    OriginalUri(uri): OriginalUri,
+    Extension(puri): Extension<CardDavPrincipalUri>,
+    State(AddressbookResourceService { addr_store, .. }): State<AddressbookResourceService<AS, S>>,
+    body: String,
+) -> Result<impl IntoResponse, Error> {
     if !user.is_principal(&principal) {
         return Err(Error::Unauthorized);
     }
@@ -51,8 +54,8 @@ pub async fn route_report_addressbook<AS: AddressbookStore>(
             handle_addressbook_multiget(
                 addr_multiget,
                 request.props(),
-                req.path(),
-                puri.as_ref(),
+                uri.path(),
+                &puri,
                 &user,
                 &principal,
                 &addressbook_id,
@@ -63,8 +66,8 @@ pub async fn route_report_addressbook<AS: AddressbookStore>(
         ReportRequest::SyncCollection(sync_collection) => {
             handle_sync_collection(
                 sync_collection,
-                req.path(),
-                puri.as_ref(),
+                uri.path(),
+                &puri,
                 &user,
                 &principal,
                 &addressbook_id,