adapt hagrid to database changes

src/delete.rs

@@ -76,14 +76,12 @@ fn delete(db: &KeyDatabase, query: &Query, all_bindings: bool, mut all: bool)
     if all_bindings || all {
         results.push(
             ("all bindings".into(),
-             db.filter_userids(&fp, |_| false)));
+             db.set_email_unpublished_all(&fp)));
     } else {
         if let Query::ByEmail(ref email) = query {
-            use std::convert::TryFrom;
-            use database::types::Email;
-            results.push((email.to_string(), db.filter_userids(
-                &fp,
-                |u| Email::try_from(u).map(|e| &e != email).unwrap_or(true))));
+            results.push(
+                (email.to_string(),
+                 db.set_email_unpublished(&fp, email)));
         } else {
             unreachable!()
         }
@@ -91,7 +89,8 @@ fn delete(db: &KeyDatabase, query: &Query, all_bindings: bool, mut all: bool)
 
     // Now delete the key(s) itself.
     if all {
-        for skb in tpk.subkeys() {
+        // TODO
+        /*for skb in tpk.subkeys() {
             results.push(
                 (skb.subkey().fingerprint().to_keyid().to_string(),
                  db.unlink_kid(&skb.subkey().fingerprint().try_into()?,
@@ -109,6 +108,7 @@ fn delete(db: &KeyDatabase, query: &Query, all_bindings: bool, mut all: bool)
         results.push(
             (tpk.fingerprint().to_string(),
              db.update(&fp, None)));
+        */
     }
 
     let mut err = Ok(());

src/import.rs

@@ -78,7 +78,7 @@ fn do_import(base: PathBuf, keyrings: Vec<PathBuf>) -> Result<()> {
                         openpgp::PacketPile::from(
                             ::std::mem::replace(&mut acc, Vec::new())))
                     {
-                        db.merge(&tpk)?;
+                        db.merge(tpk)?;
                     }
                 }
 
@@ -92,7 +92,7 @@ fn do_import(base: PathBuf, keyrings: Vec<PathBuf>) -> Result<()> {
             openpgp::PacketPile::from(
                 ::std::mem::replace(&mut acc, Vec::new())))
         {
-            db.merge(&tpk)?;
+            db.merge(tpk)?;
         }
     }
 

src/mail.rs

@@ -7,8 +7,6 @@ use lettre_email::EmailBuilder;
 use url;
 use serde::Serialize;
 
-use sequoia_openpgp as openpgp;
-
 use database::types::Email;
 use Result;
 
@@ -73,11 +71,11 @@ impl Service {
         })
     }
 
-    pub fn send_verification(&self, tpk: &openpgp::TPK, userid: &Email,
+    pub fn send_verification(&self, tpk_name: String, userid: &Email,
                              token: &str)
                              -> Result<()> {
         let ctx = context::Verification {
-            primary_fp: tpk.fingerprint().to_string(),
+            primary_fp: tpk_name,
             uri: format!("{}/publish/{}", self.base_uri, token),
             userid: userid.to_string(),
             base_uri: self.base_uri.clone(),

src/web/manage.rs

@@ -166,6 +166,6 @@ pub fn vks_manage_unpublish_or_fail(
 ) -> Result<MyResponse> {
     let fpr = token_service.check(&request.token)?;
     let email = request.address.parse::<Email>()?;
-    db.delete_userids_matching(&fpr, &email)?;
+    db.set_email_unpublished(&fpr, &email)?;
     Ok(vks_manage_key(state, db, request.token.to_owned(), token_service))
 }

src/web/mod.rs

@@ -301,22 +301,19 @@ fn publish_verify_or_fail(
     token_service: rocket::State<StatefulTokens>,
     token: String,
 ) -> Result<MyResponse> {
-    println!("hi");
     let payload = token_service.pop_token("verify", &token)?;
+    let (fingerprint, email) = serde_json::from_str(&payload)?;
 
-    match db.verify_token(&payload)? {
-        Some((userid, _fpr)) => {
-            let context = templates::Verify {
-                verified: true,
-                userid: userid.to_string(),
-                version: env!("VERGEN_SEMVER").to_string(),
-                commit: env!("VERGEN_SHA_SHORT").to_string(),
-            };
+    db.set_email_published(&fingerprint, &email)?;
 
-            Ok(MyResponse::ok("publish-result", context))
-        }
-        None => Ok(MyResponse::not_found(Some("generic-error"), None)),
-    }
+    let context = templates::Verify {
+        verified: true,
+        userid: email.to_string(),
+        version: env!("VERGEN_SEMVER").to_string(),
+        commit: env!("VERGEN_SHA_SHORT").to_string(),
+    };
+
+    Ok(MyResponse::ok("publish-result", context))
 }
 
 #[get("/assets/<file..>")]

src/web/upload.rs

@@ -9,10 +9,12 @@ use rocket::http::ContentType;
 use rocket::Data;
 
 use database::{Database, KeyDatabase, StatefulTokens};
+use database::types::Fingerprint;
 use mail;
 use web::MyResponse;
 
 use std::io::Read;
+use std::convert::TryFrom;
 
 const UPLOAD_LIMIT: u64 = 1024 * 1024; // 1 MiB.
 
@@ -186,13 +188,16 @@ where
 
     let mut results: Vec<String> = vec!();
     for tpk in tpks {
-        let verification_strings = db.merge_or_publish(&tpk)?;
+        let tpk_name = tpk.fingerprint().to_string();
+        let tpk_fpr = Fingerprint::try_from(tpk.fingerprint()).unwrap();
+        let unpublished_emails = db.merge(tpk)?;
 
         if let Some((ref mail_service, ref token_service)) = services {
-            for (email, data) in verification_strings {
-                let token = token_service.new_token("verify", data.as_bytes())?;
+            for email in unpublished_emails {
+                let token_content = serde_json::to_string(&(tpk_fpr.clone(), email.clone()))?;
+                let token = token_service.new_token("verify", token_content.as_bytes())?;
                 mail_service.send_verification(
-                    &tpk,
+                    tpk_name.clone(),
                     &email,
                     &token,
                 )?;