aitzol/Plume
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Normalize panic message

Browse Source 
Change all unwrap to expect
Normalize expect's messages
Don't panic where it could be avoided easily
This commit is contained in:
Trinity Pointard 2018-10-20 08:44:33 +02:00
parent 9d70eeae61
commit 4e6f3209d5
18 changed files with 279 additions and 252 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
plume-cli/src/main.rs
View File

@ -27,7 +27,7 @@ fn main() {
match matches.subcommand() { match matches.subcommand() {
("instance", Some(args)) => instance::run(args, &conn.expect("Couldn't connect to the database.")), ("instance", Some(args)) => instance::run(args, &conn.expect("Couldn't connect to the database.")),
("users", Some(args)) => users::run(args, &conn.expect("Couldn't connect to the database.")), ("users", Some(args)) => users::run(args, &conn.expect("Couldn't connect to the database.")),
_ => app.print_help().unwrap() _ => app.print_help().expect("Couldn't print help")
}; };
} }

2
plume-common/src/activity_pub/inbox.rs
View File

@ -17,7 +17,7 @@ pub trait FromActivity<T: Object, C>: Sized {
fn try_from_activity(conn: &C, act: Create) -> bool { fn try_from_activity(conn: &C, act: Create) -> bool {
if let Ok(obj) = act.create_props.object_object() { if let Ok(obj) = act.create_props.object_object() {
Self::from_activity(conn, obj, act.create_props.actor_link::<Id>().unwrap()); Self::from_activity(conn, obj, act.create_props.actor_link::<Id>().expect("FromActivity::try_from_activity: id not found error"));
true true
} else { } else {
false false

15
plume-common/src/activity_pub/mod.rs
View File

@ -82,14 +82,13 @@ impl<'a, 'r> FromRequest<'a, 'r> for ApRequest {
"application/ld+json" => Outcome::Success(ApRequest), "application/ld+json" => Outcome::Success(ApRequest),
"text/html" => Outcome::Forward(true), "text/html" => Outcome::Forward(true),
_ => Outcome::Forward(false) _ => Outcome::Forward(false)
}).fold(Outcome::Forward(false), |out, ct| if out.is_success() || (out.is_forward() && out.clone().forwarded().unwrap()) { }).fold(Outcome::Forward(false), |out, ct| if out.clone().forwarded().unwrap_or(out.is_success()) {
out out
} else { } else {
ct ct
}).map_forward(|_| ())).unwrap_or(Outcome::Forward(())) }).map_forward(|_| ())).unwrap_or(Outcome::Forward(()))
} }
} }
pub fn broadcast<S: sign::Signer, A: Activity, T: inbox::WithInbox + Actor>(sender: &S, act: A, to: Vec<T>) { pub fn broadcast<S: sign::Signer, A: Activity, T: inbox::WithInbox + Actor>(sender: &S, act: A, to: Vec<T>) {
let boxes = to.into_iter() let boxes = to.into_iter()
.filter(|u| !u.is_local()) .filter(|u| !u.is_local())
@ -97,7 +96,8 @@ pub fn broadcast<S: sign::Signer, A: Activity, T: inbox::WithInbox + Actor>(send
.collect::<Vec<String>>() .collect::<Vec<String>>()
.unique(); .unique();
let mut act = serde_json::to_value(act).unwrap();
let mut act = serde_json::to_value(act).expect("activity_pub::broadcast: serialization error");
act["@context"] = context(); act["@context"] = context();
let signed = act.sign(sender); let signed = act.sign(sender);
@ -112,7 +112,14 @@ pub fn broadcast<S: sign::Signer, A: Activity, T: inbox::WithInbox + Actor>(send
.body(signed.to_string()) .body(signed.to_string())
.send(); .send();
match res { match res {
Ok(mut r) => println!("Successfully sent activity to inbox ({})\n\n{:?}", inbox, r.text().unwrap()), Ok(mut r) => {
println!("Successfully sent activity to inbox ({})", inbox);
if let Ok(response) = r.text() {
println!("Response: \"{:?}\"\n\n", response)
} else {
println!("Error while reading response")
}
},
Err(e) => println!("Error while sending to inbox ({:?})", e) Err(e) => println!("Error while sending to inbox ({:?})", e)
} }
} }

28
plume-common/src/activity_pub/request.rs
View File

@ -14,30 +14,30 @@ pub struct Digest(String);
impl Digest { impl Digest {
pub fn digest(body: String) -> HeaderValue { pub fn digest(body: String) -> HeaderValue {
let mut hasher = Hasher::new(MessageDigest::sha256()).unwrap(); let mut hasher = Hasher::new(MessageDigest::sha256()).expect("Digest::digest: initialization error");
hasher.update(&body.into_bytes()[..]).unwrap(); hasher.update(&body.into_bytes()[..]).expect("Digest::digest: content insertion error");
let res = base64::encode(&hasher.finish().unwrap()); let res = base64::encode(&hasher.finish().expect("Digest::digest: finalizing error"));
HeaderValue::from_str(&format!("SHA-256={}", res)).unwrap() HeaderValue::from_str(&format!("SHA-256={}", res)).expect("Digest::digest: header creation error")
} }
pub fn verify(&self, body: String) -> bool { pub fn verify(&self, body: String) -> bool {
if self.algorithm()=="SHA-256" { if self.algorithm()=="SHA-256" {
let mut hasher = Hasher::new(MessageDigest::sha256()).unwrap(); let mut hasher = Hasher::new(MessageDigest::sha256()).expect("Digest::digest: initialization error");
hasher.update(&body.into_bytes()).unwrap(); hasher.update(&body.into_bytes()).expect("Digest::digest: content insertion error");
self.value().deref()==hasher.finish().unwrap().deref() self.value().deref()==hasher.finish().expect("Digest::digest: finalizing error").deref()
} else { } else {
false //algorithm not supported false //algorithm not supported
} }
} }
pub fn algorithm(&self) -> &str { pub fn algorithm(&self) -> &str {
let pos = self.0.find('=').unwrap(); let pos = self.0.find('=').expect("Digest::algorithm: invalid header error");
&self.0[..pos] &self.0[..pos]
} }
pub fn value(&self) -> Vec<u8> { pub fn value(&self) -> Vec<u8> {
let pos = self.0.find('=').unwrap()+1; let pos = self.0.find('=').expect("Digest::value: invalid header error")+1;
base64::decode(&self.0[pos..]).unwrap() base64::decode(&self.0[pos..]).expect("Digest::value: invalid encoding error")
} }
pub fn from_header(dig: &str) -> Result<Self, ()> { pub fn from_header(dig: &str) -> Result<Self, ()> {
@ -60,13 +60,13 @@ pub fn headers() -> HeaderMap {
let mut headers = HeaderMap::new(); let mut headers = HeaderMap::new();
headers.insert(USER_AGENT, HeaderValue::from_static(PLUME_USER_AGENT)); headers.insert(USER_AGENT, HeaderValue::from_static(PLUME_USER_AGENT));
headers.insert(DATE, HeaderValue::from_str(&date).unwrap()); headers.insert(DATE, HeaderValue::from_str(&date).expect("request::headers: date error"));
headers.insert(ACCEPT, HeaderValue::from_str(&ap_accept_header().into_iter().collect::<Vec<_>>().join(", ")).unwrap()); headers.insert(ACCEPT, HeaderValue::from_str(&ap_accept_header().into_iter().collect::<Vec<_>>().join(", ")).expect("request::headers: accept error"));
headers headers
} }
pub fn signature<S: Signer>(signer: &S, headers: HeaderMap) -> HeaderValue { pub fn signature<S: Signer>(signer: &S, headers: HeaderMap) -> HeaderValue {
let signed_string = headers.iter().map(|(h,v)| format!("{}: {}", h.as_str().to_lowercase(), v.to_str().unwrap())).collect::<Vec<String>>().join("\n"); let signed_string = headers.iter().map(|(h,v)| format!("{}: {}", h.as_str().to_lowercase(), v.to_str().expect("request::signature: invalid header error"))).collect::<Vec<String>>().join("\n");
let signed_headers = headers.iter().map(|(h,_)| h.as_str()).collect::<Vec<&str>>().join(" ").to_lowercase(); let signed_headers = headers.iter().map(|(h,_)| h.as_str()).collect::<Vec<&str>>().join(" ").to_lowercase();
let data = signer.sign(signed_string); let data = signer.sign(signed_string);
@ -77,5 +77,5 @@ pub fn signature<S: Signer>(signer: &S, headers: HeaderMap) -> HeaderValue {
key_id = signer.get_key_id(), key_id = signer.get_key_id(),
signed_headers = signed_headers, signed_headers = signed_headers,
signature = sign signature = sign
)).unwrap() )).expect("request::signature: signature header error")
} }

15
plume-common/src/activity_pub/sign.rs
View File

@ -12,9 +12,12 @@ use serde_json;
/// Returns (public key, private key) /// Returns (public key, private key)
pub fn gen_keypair() -> (Vec<u8>, Vec<u8>) { pub fn gen_keypair() -> (Vec<u8>, Vec<u8>) {
let keypair = Rsa::generate(2048).unwrap(); let keypair = Rsa::generate(2048).expect("sign::gen_keypair: key generation error");
let keypair = PKey::from_rsa(keypair).unwrap(); let keypair = PKey::from_rsa(keypair).expect("sign::gen_keypair: parsing error");
(keypair.public_key_to_pem().unwrap(), keypair.private_key_to_pem_pkcs8().unwrap()) (
keypair.public_key_to_pem().expect("sign::gen_keypair: public key encoding error"),
keypair.private_key_to_pem_pkcs8().expect("sign::gen_keypair: private key encoding error")
)
} }
pub trait Signer { pub trait Signer {
@ -101,7 +104,7 @@ pub fn verify_http_headers<S: Signer+::std::fmt::Debug>(sender: &S, all_headers:
if sig_header.is_none() { if sig_header.is_none() {
return SignatureValidity::Absent return SignatureValidity::Absent
} }
let sig_header = sig_header.unwrap(); let sig_header = sig_header.expect("sign::verify_http_headers: unreachable");
let mut _key_id = None; let mut _key_id = None;
let mut _algorithm = None; let mut _algorithm = None;
@ -120,8 +123,8 @@ pub fn verify_http_headers<S: Signer+::std::fmt::Debug>(sender: &S, all_headers:
if signature.is_none() || headers.is_none() {//missing part of the header if signature.is_none() || headers.is_none() {//missing part of the header
return SignatureValidity::Invalid return SignatureValidity::Invalid
} }
let headers = headers.unwrap().split_whitespace().collect::<Vec<_>>(); let headers = headers.expect("sign::verify_http_headers: unreachable").split_whitespace().collect::<Vec<_>>();
let signature = signature.unwrap(); let signature = signature.expect("sign::verify_http_headers: unreachable");
let h = headers.iter() let h = headers.iter()
.map(|header| (header,all_headers.get_one(header))) .map(|header| (header,all_headers.get_one(header)))
.map(|(header, value)| format!("{}: {}", header.to_lowercase(), value.unwrap_or(""))) .map(|(header, value)| format!("{}: {}", header.to_lowercase(), value.unwrap_or("")))

61
plume-models/src/blogs.rs
View File

@ -65,7 +65,7 @@ impl Blog {
find_by!(blogs, find_by_name, actor_id as String, instance_id as i32); find_by!(blogs, find_by_name, actor_id as String, instance_id as i32);
pub fn get_instance(&self, conn: &Connection) -> Instance { pub fn get_instance(&self, conn: &Connection) -> Instance {
Instance::get(conn, self.instance_id).expect("Couldn't find instance") Instance::get(conn, self.instance_id).expect("Blog::get_instance: instance not found error")
} }
pub fn list_authors(&self, conn: &Connection) -> Vec<User> { pub fn list_authors(&self, conn: &Connection) -> Vec<User> {
@ -74,7 +74,7 @@ impl Blog {
let authors_ids = blog_authors::table.filter(blog_authors::blog_id.eq(self.id)).select(blog_authors::author_id); let authors_ids = blog_authors::table.filter(blog_authors::blog_id.eq(self.id)).select(blog_authors::author_id);
users::table.filter(users::id.eq_any(authors_ids)) users::table.filter(users::id.eq_any(authors_ids))
.load::<User>(conn) .load::<User>(conn)
.expect("Couldn't load authors of a blog") .expect("Blog::list_authors: author loading error")
} }
pub fn find_for_author(conn: &Connection, author_id: i32) -> Vec<Blog> { pub fn find_for_author(conn: &Connection, author_id: i32) -> Vec<Blog> {
@ -82,7 +82,7 @@ impl Blog {
let author_ids = blog_authors::table.filter(blog_authors::author_id.eq(author_id)).select(blog_authors::blog_id); let author_ids = blog_authors::table.filter(blog_authors::author_id.eq(author_id)).select(blog_authors::blog_id);
blogs::table.filter(blogs::id.eq_any(author_ids)) blogs::table.filter(blogs::id.eq_any(author_ids))
.load::<Blog>(conn) .load::<Blog>(conn)
.expect("Couldn't load blogs ") .expect("Blog::find_for_author: blog loading error")
} }
pub fn find_local(conn: &Connection, name: String) -> Option<Blog> { pub fn find_local(conn: &Connection, name: String) -> Option<Blog> {
@ -91,9 +91,9 @@ impl Blog {
pub fn find_by_fqn(conn: &Connection, fqn: String) -> Option<Blog> { pub fn find_by_fqn(conn: &Connection, fqn: String) -> Option<Blog> {
if fqn.contains("@") { // remote blog if fqn.contains("@") { // remote blog
match Instance::find_by_domain(conn, String::from(fqn.split("@").last().unwrap())) { match Instance::find_by_domain(conn, String::from(fqn.split("@").last().expect("Blog::find_by_fqn: unreachable"))) {
Some(instance) => { Some(instance) => {
match Blog::find_by_name(conn, String::from(fqn.split("@").nth(0).unwrap()), instance.id) { match Blog::find_by_name(conn, String::from(fqn.split("@").nth(0).expect("Blog::find_by_fqn: unreachable")), instance.id) {
Some(u) => Some(u), Some(u) => Some(u),
None => Blog::fetch_from_webfinger(conn, fqn) None => Blog::fetch_from_webfinger(conn, fqn)
} }
@ -107,7 +107,7 @@ impl Blog {
fn fetch_from_webfinger(conn: &Connection, acct: String) -> Option<Blog> { fn fetch_from_webfinger(conn: &Connection, acct: String) -> Option<Blog> {
match resolve(acct.clone(), *USE_HTTPS) { match resolve(acct.clone(), *USE_HTTPS) {
Ok(wf) => wf.links.into_iter().find(|l| l.mime_type == Some(String::from("application/activity+json"))).and_then(|l| Blog::fetch_from_url(conn, l.href.expect("No href for AP WF link"))), Ok(wf) => wf.links.into_iter().find(|l| l.mime_type == Some(String::from("application/activity+json"))).and_then(|l| Blog::fetch_from_url(conn, l.href.expect("Blog::fetch_from_webfinger: href not found error"))),
Err(details) => { Err(details) => {
println!("{:?}", details); println!("{:?}", details);
None None
@ -118,15 +118,15 @@ impl Blog {
fn fetch_from_url(conn: &Connection, url: String) -> Option<Blog> { fn fetch_from_url(conn: &Connection, url: String) -> Option<Blog> {
let req = Client::new() let req = Client::new()
.get(&url[..]) .get(&url[..])
.header(ACCEPT, HeaderValue::from_str(&ap_accept_header().into_iter().collect::<Vec<_>>().join(", ")).unwrap()) .header(ACCEPT, HeaderValue::from_str(&ap_accept_header().into_iter().collect::<Vec<_>>().join(", ")).expect("Blog::fetch_from_url: accept_header generation error"))
.send(); .send();
match req { match req {
Ok(mut res) => { Ok(mut res) => {
let text = &res.text().unwrap(); let text = &res.text().expect("Blog::fetch_from_url: body reading error");
let ap_sign: ApSignature = serde_json::from_str(text).unwrap(); let ap_sign: ApSignature = serde_json::from_str(text).expect("Blog::fetch_from_url: body parsing error");
let mut json: CustomGroup = serde_json::from_str(text).unwrap(); let mut json: CustomGroup = serde_json::from_str(text).expect("Blog::fetch_from_url: body parsing error");
json.custom_props = ap_sign; // without this workaround, publicKey is not correctly deserialized json.custom_props = ap_sign; // without this workaround, publicKey is not correctly deserialized
Some(Blog::from_activity(conn, json, Url::parse(url.as_ref()).unwrap().host_str().unwrap().to_string())) Some(Blog::from_activity(conn, json, Url::parse(url.as_ref()).expect("Blog::fetch_from_url: url parsing error").host_str().expect("Blog::fetch_from_url: host extraction error").to_string()))
}, },
Err(_) => None Err(_) => None
} }
@ -188,26 +188,26 @@ impl Blog {
if self.outbox_url.len() == 0 { if self.outbox_url.len() == 0 {
diesel::update(self) diesel::update(self)
.set(blogs::outbox_url.eq(instance.compute_box(BLOG_PREFIX, self.actor_id.clone(), "outbox"))) .set(blogs::outbox_url.eq(instance.compute_box(BLOG_PREFIX, self.actor_id.clone(), "outbox")))
.execute(conn).expect("Couldn't update outbox URL"); .execute(conn).expect("Blog::update_boxes: outbox update error");
} }
if self.inbox_url.len() == 0 { if self.inbox_url.len() == 0 {
diesel::update(self) diesel::update(self)
.set(blogs::inbox_url.eq(instance.compute_box(BLOG_PREFIX, self.actor_id.clone(), "inbox"))) .set(blogs::inbox_url.eq(instance.compute_box(BLOG_PREFIX, self.actor_id.clone(), "inbox")))
.execute(conn).expect("Couldn't update inbox URL"); .execute(conn).expect("Blog::update_boxes: inbox update error");
} }
if self.ap_url.len() == 0 { if self.ap_url.len() == 0 {
diesel::update(self) diesel::update(self)
.set(blogs::ap_url.eq(instance.compute_box(BLOG_PREFIX, self.actor_id.clone(), ""))) .set(blogs::ap_url.eq(instance.compute_box(BLOG_PREFIX, self.actor_id.clone(), "")))
.execute(conn).expect("Couldn't update AP URL"); .execute(conn).expect("Blog::update_boxes: ap_url update error");
} }
} }
pub fn outbox(&self, conn: &Connection) -> ActivityStream<OrderedCollection> { pub fn outbox(&self, conn: &Connection) -> ActivityStream<OrderedCollection> {
let mut coll = OrderedCollection::default(); let mut coll = OrderedCollection::default();
coll.collection_props.items = serde_json::to_value(self.get_activities(conn)).unwrap(); coll.collection_props.items = serde_json::to_value(self.get_activities(conn)).expect("Blog::outbox: activity serialization error");
coll.collection_props.set_total_items_u64(self.get_activities(conn).len() as u64).unwrap(); coll.collection_props.set_total_items_u64(self.get_activities(conn).len() as u64).expect("Blog::outbox: count serialization error");
ActivityStream::new(coll) ActivityStream::new(coll)
} }
@ -216,7 +216,9 @@ impl Blog {
} }
pub fn get_keypair(&self) -> PKey<Private> { pub fn get_keypair(&self) -> PKey<Private> {
PKey::from_rsa(Rsa::private_key_from_pem(self.private_key.clone().unwrap().as_ref()).unwrap()).unwrap() PKey::from_rsa(Rsa::private_key_from_pem(self.private_key.clone().expect("Blog::get_keypair: private key not found error").as_ref())
.expect("Blog::get_keypair: pem parsing error"))
.expect("Blog::get_keypair: private key deserialization error")
} }
pub fn webfinger(&self, conn: &Connection) -> Webfinger { pub fn webfinger(&self, conn: &Connection) -> Webfinger {
@ -248,9 +250,9 @@ impl Blog {
pub fn from_url(conn: &Connection, url: String) -> Option<Blog> { pub fn from_url(conn: &Connection, url: String) -> Option<Blog> {
Blog::find_by_ap_url(conn, url.clone()).or_else(|| { Blog::find_by_ap_url(conn, url.clone()).or_else(|| {
// The requested user was not in the DB // The requested blog was not in the DB
// We try to fetch it if it is remote // We try to fetch it if it is remote
if Url::parse(url.as_ref()).unwrap().host_str().unwrap() != BASE_URL.as_str() { if Url::parse(url.as_ref()).expect("Blog::from_url: ap_url parsing error").host_str().expect("Blog::from_url: host extraction error") != BASE_URL.as_str() {
Blog::fetch_from_url(conn, url) Blog::fetch_from_url(conn, url)
} else { } else {
None None
@ -267,7 +269,7 @@ impl Blog {
} }
pub fn to_json(&self, conn: &Connection) -> serde_json::Value { pub fn to_json(&self, conn: &Connection) -> serde_json::Value {
let mut json = serde_json::to_value(self).unwrap(); let mut json = serde_json::to_value(self).expect("Blog::to_json: serialization error");
json["fqn"] = json!(self.get_fqn(conn)); json["fqn"] = json!(self.get_fqn(conn));
json json
} }
@ -303,16 +305,17 @@ impl sign::Signer for Blog {
fn sign(&self, to_sign: String) -> Vec<u8> { fn sign(&self, to_sign: String) -> Vec<u8> {
let key = self.get_keypair(); let key = self.get_keypair();
let mut signer = Signer::new(MessageDigest::sha256(), &key).unwrap(); let mut signer = Signer::new(MessageDigest::sha256(), &key).expect("Blog::sign: initialization error");
signer.update(to_sign.as_bytes()).unwrap(); signer.update(to_sign.as_bytes()).expect("Blog::sign: content insertion error");
signer.sign_to_vec().unwrap() signer.sign_to_vec().expect("Blog::sign: finalization error")
} }
fn verify(&self, data: String, signature: Vec<u8>) -> bool { fn verify(&self, data: String, signature: Vec<u8>) -> bool {
let key = PKey::from_rsa(Rsa::public_key_from_pem(self.public_key.as_ref()).unwrap()).unwrap(); let key = PKey::from_rsa(Rsa::public_key_from_pem(self.public_key.as_ref()).expect("Blog::verify: pem parsing error"))
let mut verifier = Verifier::new(MessageDigest::sha256(), &key).unwrap(); .expect("Blog::verify: deserialization error");
verifier.update(data.as_bytes()).unwrap(); let mut verifier = Verifier::new(MessageDigest::sha256(), &key).expect("Blog::verify: initialization error");
verifier.verify(&signature).unwrap() verifier.update(data.as_bytes()).expect("Blog::verify: content insertion error");
verifier.verify(&signature).expect("Blog::verify: finalization error")
} }
} }
@ -332,8 +335,8 @@ impl NewBlog {
inbox_url: String::from(""), inbox_url: String::from(""),
instance_id: instance_id, instance_id: instance_id,
ap_url: String::from(""), ap_url: String::from(""),
public_key: String::from_utf8(pub_key).unwrap(), public_key: String::from_utf8(pub_key).expect("NewBlog::new_local: public key error"),
private_key: Some(String::from_utf8(priv_key).unwrap()) private_key: Some(String::from_utf8(priv_key).expect("NewBlog::new_local: private key error"))
} }
} }
} }

62
plume-models/src/comments.rs
View File

@ -53,11 +53,11 @@ impl Comment {
find_by!(comments, find_by_ap_url, ap_url as String); find_by!(comments, find_by_ap_url, ap_url as String);
pub fn get_author(&self, conn: &Connection) -> User { pub fn get_author(&self, conn: &Connection) -> User {
User::get(conn, self.author_id).unwrap() User::get(conn, self.author_id).expect("Comment::get_author: author error")
} }
pub fn get_post(&self, conn: &Connection) -> Post { pub fn get_post(&self, conn: &Connection) -> Post {
Post::get(conn, self.post_id).unwrap() Post::get(conn, self.post_id).expect("Comment::get_post: post error")
} }
pub fn count_local(conn: &Connection) -> usize { pub fn count_local(conn: &Connection) -> usize {
@ -65,17 +65,17 @@ impl Comment {
let local_authors = users::table.filter(users::instance_id.eq(Instance::local_id(conn))).select(users::id); let local_authors = users::table.filter(users::instance_id.eq(Instance::local_id(conn))).select(users::id);
comments::table.filter(comments::author_id.eq_any(local_authors)) comments::table.filter(comments::author_id.eq_any(local_authors))
.load::<Comment>(conn) .load::<Comment>(conn)
.expect("Couldn't load local comments") .expect("Comment::count_local: loading error")
.len() .len()// TODO count in database?
} }
pub fn to_json(&self, conn: &Connection, others: &Vec<Comment>) -> serde_json::Value { pub fn to_json(&self, conn: &Connection, others: &Vec<Comment>) -> serde_json::Value {
let mut json = serde_json::to_value(self).unwrap(); let mut json = serde_json::to_value(self).expect("Comment::to_json: serialization error");
json["author"] = self.get_author(conn).to_json(conn); json["author"] = self.get_author(conn).to_json(conn);
let mentions = Mention::list_for_comment(conn, self.id).into_iter() let mentions = Mention::list_for_comment(conn, self.id).into_iter()
.map(|m| m.get_mentioned(conn).map(|u| u.get_fqn(conn)).unwrap_or(String::new())) .map(|m| m.get_mentioned(conn).map(|u| u.get_fqn(conn)).unwrap_or(String::new()))
.collect::<Vec<String>>(); .collect::<Vec<String>>();
json["mentions"] = serde_json::to_value(mentions).unwrap(); json["mentions"] = serde_json::to_value(mentions).expect("Comment::to_json: mention error");
json["responses"] = json!(others.into_iter() json["responses"] = json!(others.into_iter()
.filter(|c| c.in_response_to_id.map(|id| id == self.id).unwrap_or(false)) .filter(|c| c.in_response_to_id.map(|id| id == self.id).unwrap_or(false))
.map(|c| c.to_json(conn, others)) .map(|c| c.to_json(conn, others))
@ -88,8 +88,8 @@ impl Comment {
diesel::update(self) diesel::update(self)
.set(comments::ap_url.eq(self.compute_id(conn))) .set(comments::ap_url.eq(self.compute_id(conn)))
.execute(conn) .execute(conn)
.expect("Failed to update comment AP URL"); .expect("Comment::update_ap_url: update error");
Comment::get(conn, self.id).expect("Couldn't get the updated comment") Comment::get(conn, self.id).expect("Comment::update_ap_url: get error")
} else { } else {
self.clone() self.clone()
} }
@ -102,53 +102,53 @@ impl Comment {
pub fn into_activity(&self, conn: &Connection) -> Note { pub fn into_activity(&self, conn: &Connection) -> Note {
let (html, mentions) = utils::md_to_html(self.content.get().as_ref()); let (html, mentions) = utils::md_to_html(self.content.get().as_ref());
let author = User::get(conn, self.author_id).unwrap(); let author = User::get(conn, self.author_id).expect("Comment::into_activity: author error");
let mut note = Note::default(); let mut note = Note::default();
let to = vec![Id::new(PUBLIC_VISIBILTY.to_string())]; let to = vec![Id::new(PUBLIC_VISIBILTY.to_string())];
note.object_props.set_id_string(self.ap_url.clone().unwrap_or(String::new())).expect("NewComment::create: note.id error"); note.object_props.set_id_string(self.ap_url.clone().unwrap_or(String::new())).expect("Comment::into_activity: id error");
note.object_props.set_summary_string(self.spoiler_text.clone()).expect("NewComment::create: note.summary error"); note.object_props.set_summary_string(self.spoiler_text.clone()).expect("Comment::into_activity: summary error");
note.object_props.set_content_string(html).expect("NewComment::create: note.content error"); note.object_props.set_content_string(html).expect("Comment::into_activity: content error");
note.object_props.set_in_reply_to_link(Id::new(self.in_response_to_id.map_or_else(|| Post::get(conn, self.post_id).unwrap().ap_url, |id| { note.object_props.set_in_reply_to_link(Id::new(self.in_response_to_id.map_or_else(|| Post::get(conn, self.post_id).expect("Comment::into_activity: post error").ap_url, |id| {
let comm = Comment::get(conn, id).unwrap(); let comm = Comment::get(conn, id).expect("Comment::into_activity: comment error");
comm.ap_url.clone().unwrap_or(comm.compute_id(conn)) comm.ap_url.clone().unwrap_or(comm.compute_id(conn))
}))).expect("NewComment::create: note.in_reply_to error"); }))).expect("Comment::into_activity: in_reply_to error");
note.object_props.set_published_string(chrono::Utc::now().to_rfc3339()).expect("NewComment::create: note.published error"); note.object_props.set_published_string(chrono::Utc::now().to_rfc3339()).expect("Comment::into_activity: published error");
note.object_props.set_attributed_to_link(author.clone().into_id()).expect("NewComment::create: note.attributed_to error"); note.object_props.set_attributed_to_link(author.clone().into_id()).expect("Comment::into_activity: attributed_to error");
note.object_props.set_to_link_vec(to.clone()).expect("NewComment::create: note.to error"); note.object_props.set_to_link_vec(to.clone()).expect("Comment::into_activity: to error");
note.object_props.set_tag_link_vec(mentions.into_iter().map(|m| Mention::build_activity(conn, m)).collect::<Vec<link::Mention>>()) note.object_props.set_tag_link_vec(mentions.into_iter().map(|m| Mention::build_activity(conn, m)).collect::<Vec<link::Mention>>())
.expect("NewComment::create: note.tag error"); .expect("Comment::into_activity: tag error");
note note
} }
pub fn create_activity(&self, conn: &Connection) -> Create { pub fn create_activity(&self, conn: &Connection) -> Create {
let author = User::get(conn, self.author_id).unwrap(); let author = User::get(conn, self.author_id).expect("Comment::create_activity: author error");
let note = self.into_activity(conn); let note = self.into_activity(conn);
let mut act = Create::default(); let mut act = Create::default();
act.create_props.set_actor_link(author.into_id()).expect("NewComment::create_acitivity: actor error"); act.create_props.set_actor_link(author.into_id()).expect("Comment::create_activity: actor error");
act.create_props.set_object_object(note.clone()).expect("NewComment::create_acitivity: object error"); act.create_props.set_object_object(note.clone()).expect("Comment::create_activity: object error");
act.object_props.set_id_string(format!("{}/activity", self.ap_url.clone().unwrap())).expect("NewComment::create_acitivity: id error"); act.object_props.set_id_string(format!("{}/activity", self.ap_url.clone().expect("Comment::create_activity: ap_url error"))).expect("Comment::create_activity: id error");
act.object_props.set_to_link_vec(note.object_props.to_link_vec::<Id>().expect("WTF")).expect("NewComment::create_acitivity: to error"); act.object_props.set_to_link_vec(note.object_props.to_link_vec::<Id>().expect("Comment::create_activity: id error")).expect("Comment::create_activity: to error");
act.object_props.set_cc_link_vec::<Id>(vec![]).expect("NewComment::create_acitivity: cc error"); act.object_props.set_cc_link_vec::<Id>(vec![]).expect("Comment::create_activity: cc error");
act act
} }
} }
impl FromActivity<Note, Connection> for Comment { impl FromActivity<Note, Connection> for Comment {
fn from_activity(conn: &Connection, note: Note, actor: Id) -> Comment { fn from_activity(conn: &Connection, note: Note, actor: Id) -> Comment {
let previous_url = note.object_props.in_reply_to.clone().unwrap().as_str().unwrap().to_string(); let previous_url = note.object_props.in_reply_to.clone().expect("Comment::from_activity: not an answer error").as_str().expect("Comment::from_activity: in_reply_to parsing error").to_string();
let previous_comment = Comment::find_by_ap_url(conn, previous_url.clone()); let previous_comment = Comment::find_by_ap_url(conn, previous_url.clone());
let comm = Comment::insert(conn, NewComment { let comm = Comment::insert(conn, NewComment {
content: SafeString::new(&note.object_props.content_string().unwrap()), content: SafeString::new(&note.object_props.content_string().expect("Comment::from_activity: content deserialization error")),
spoiler_text: note.object_props.summary_string().unwrap_or(String::from("")), spoiler_text: note.object_props.summary_string().unwrap_or(String::from("")),
ap_url: note.object_props.id_string().ok(), ap_url: note.object_props.id_string().ok(),
in_response_to_id: previous_comment.clone().map(|c| c.id), in_response_to_id: previous_comment.clone().map(|c| c.id),
post_id: previous_comment post_id: previous_comment
.map(|c| c.post_id) .map(|c| c.post_id)
.unwrap_or_else(|| Post::find_by_ap_url(conn, previous_url).unwrap().id), .unwrap_or_else(|| Post::find_by_ap_url(conn, previous_url).expect("Comment::from_activity: post error").id),
author_id: User::from_url(conn, actor.clone().into()).unwrap().id, author_id: User::from_url(conn, actor.clone().into()).expect("Comment::from_activity: author error").id,
sensitive: false // "sensitive" is not a standard property, we need to think about how to support it with the activitypub crate sensitive: false // "sensitive" is not a standard property, we need to think about how to support it with the activitypub crate
}); });
@ -157,8 +157,8 @@ impl FromActivity<Note, Connection> for Comment {
for tag in tags.into_iter() { for tag in tags.into_iter() {
serde_json::from_value::<link::Mention>(tag) serde_json::from_value::<link::Mention>(tag)
.map(|m| { .map(|m| {
let author = &Post::get(conn, comm.post_id).unwrap().get_authors(conn)[0]; let author = &Post::get(conn, comm.post_id).expect("Comment::from_activity: error").get_authors(conn)[0];
let not_author = m.link_props.href_string().expect("Comment mention: no href") != author.ap_url.clone(); let not_author = m.link_props.href_string().expect("Comment::from_activity: no href error") != author.ap_url.clone();
Mention::from_activity(conn, m, comm.id, false, not_author) Mention::from_activity(conn, m, comm.id, false, not_author)
}).ok(); }).ok();
} }

37
plume-models/src/follows.rs
View File

@ -38,15 +38,15 @@ impl Follow {
} }
pub fn into_activity(&self, conn: &Connection) -> FollowAct { pub fn into_activity(&self, conn: &Connection) -> FollowAct {
let user = User::get(conn, self.follower_id).unwrap(); let user = User::get(conn, self.follower_id).expect("Follow::into_activity: actor not found error");
let target = User::get(conn, self.following_id).unwrap(); let target = User::get(conn, self.following_id).expect("Follow::into_activity: target not found error");
let mut act = FollowAct::default(); let mut act = FollowAct::default();
act.follow_props.set_actor_link::<Id>(user.clone().into_id()).expect("Follow::into_activity: actor error"); act.follow_props.set_actor_link::<Id>(user.clone().into_id()).expect("Follow::into_activity: actor error");
act.follow_props.set_object_object(user.into_activity(&*conn)).unwrap(); act.follow_props.set_object_object(user.into_activity(&*conn)).expect("Follow::into_activity: object error");
act.object_props.set_id_string(self.ap_url.clone()).unwrap(); act.object_props.set_id_string(self.ap_url.clone()).expect("Follow::into_activity: id error");
act.object_props.set_to_link(target.clone().into_id()).expect("New Follow error while setting 'to'"); act.object_props.set_to_link(target.clone().into_id()).expect("Follow::into_activity: target error");
act.object_props.set_cc_link_vec::<Id>(vec![]).expect("New Follow error while setting 'cc'"); act.object_props.set_cc_link_vec::<Id>(vec![]).expect("Follow::into_activity: cc error");
act act
} }
@ -70,11 +70,11 @@ impl Follow {
let mut accept = Accept::default(); let mut accept = Accept::default();
let accept_id = format!("{}#accept", follow.object_props.id_string().unwrap_or(String::new())); let accept_id = format!("{}#accept", follow.object_props.id_string().unwrap_or(String::new()));
accept.object_props.set_id_string(accept_id).expect("accept_follow: id error"); accept.object_props.set_id_string(accept_id).expect("Follow::accept_follow: id error");
accept.object_props.set_to_link(from.clone().into_id()).expect("accept_follow: to error"); accept.object_props.set_to_link(from.clone().into_id()).expect("Follow::accept_follow: to error");
accept.object_props.set_cc_link_vec::<Id>(vec![]).expect("accept_follow: cc error"); accept.object_props.set_cc_link_vec::<Id>(vec![]).expect("Follow::accept_follow: cc error");
accept.accept_props.set_actor_link::<Id>(target.clone().into_id()).unwrap(); accept.accept_props.set_actor_link::<Id>(target.clone().into_id()).expect("Follow::accept_follow: actor error");
accept.accept_props.set_object_object(follow).unwrap(); accept.accept_props.set_object_object(follow).expect("Follow::accept_follow: object error");
broadcast(&*target, accept, vec![from.clone()]); broadcast(&*target, accept, vec![from.clone()]);
res res
} }
@ -83,12 +83,13 @@ impl Follow {
impl FromActivity<FollowAct, Connection> for Follow { impl FromActivity<FollowAct, Connection> for Follow {
fn from_activity(conn: &Connection, follow: FollowAct, _actor: Id) -> Follow { fn from_activity(conn: &Connection, follow: FollowAct, _actor: Id) -> Follow {
let from_id = follow.follow_props.actor_link::<Id>().map(|l| l.into()) let from_id = follow.follow_props.actor_link::<Id>().map(|l| l.into())
.unwrap_or_else(|_| follow.follow_props.actor_object::<Person>().expect("No actor object (nor ID) on Follow").object_props.id_string().expect("No ID on actor on Follow")); .unwrap_or_else(|_| follow.follow_props.actor_object::<Person>().expect("Follow::from_activity: actor not found error").object_props.id_string().expect("Follow::from_activity: actor not found error"));
let from = User::from_url(conn, from_id).unwrap(); let from = User::from_url(conn, from_id).expect("Follow::from_activity: actor not found error");
match User::from_url(conn, follow.follow_props.object.as_str().unwrap().to_string()) { match User::from_url(conn, follow.follow_props.object.as_str().expect("Follow::from_activity: target url parsing error").to_string()) {
Some(user) => Follow::accept_follow(conn, &from, &user, follow, from.id, user.id), Some(user) => Follow::accept_follow(conn, &from, &user, follow, from.id, user.id),
None => { None => {
let blog = Blog::from_url(conn, follow.follow_props.object.as_str().unwrap().to_string()).unwrap(); let blog = Blog::from_url(conn, follow.follow_props.object.as_str().expect("Follow::from_activity: target url parsing error").to_string())
.expect("Follow::from_activity: target not found error");
Follow::accept_follow(conn, &from, &blog, follow, from.id, blog.id) Follow::accept_follow(conn, &from, &blog, follow, from.id, blog.id)
} }
} }
@ -107,15 +108,15 @@ impl Notify<Connection> for Follow {
impl Deletable<Connection, Undo> for Follow { impl Deletable<Connection, Undo> for Follow {
fn delete(&self, conn: &Connection) -> Undo { fn delete(&self, conn: &Connection) -> Undo {
diesel::delete(self).execute(conn).expect("Coudn't delete follow"); diesel::delete(self).execute(conn).expect("Follow::delete: follow deletion error");
// delete associated notification if any // delete associated notification if any
if let Some(notif) = Notification::find(conn, notification_kind::FOLLOW, self.id) { if let Some(notif) = Notification::find(conn, notification_kind::FOLLOW, self.id) {
diesel::delete(&notif).execute(conn).expect("Couldn't delete follow notification"); diesel::delete(&notif).execute(conn).expect("Follow::delete: notification deletion error");
} }
let mut undo = Undo::default(); let mut undo = Undo::default();
undo.undo_props.set_actor_link(User::get(conn, self.follower_id).unwrap().into_id()).expect("Follow::delete: actor error"); undo.undo_props.set_actor_link(User::get(conn, self.follower_id).expect("Follow::delete: actor error").into_id()).expect("Follow::delete: actor error");
undo.object_props.set_id_string(format!("{}/undo", self.ap_url)).expect("Follow::delete: id error"); undo.object_props.set_id_string(format!("{}/undo", self.ap_url)).expect("Follow::delete: id error");
undo.undo_props.set_object_object(self.into_activity(conn)).expect("Follow::delete: object error"); undo.undo_props.set_object_object(self.into_activity(conn)).expect("Follow::delete: object error");
undo undo

20
plume-models/src/instance.rs
View File

@ -44,14 +44,14 @@ impl Instance {
instances::table.filter(instances::local.eq(true)) instances::table.filter(instances::local.eq(true))
.limit(1) .limit(1)
.load::<Instance>(conn) .load::<Instance>(conn)
.expect("Error loading local instance infos") .expect("Instance::get_local: loading error")
.into_iter().nth(0) .into_iter().nth(0)
} }
pub fn get_remotes(conn: &Connection) -> Vec<Instance> { pub fn get_remotes(conn: &Connection) -> Vec<Instance> {
instances::table.filter(instances::local.eq(false)) instances::table.filter(instances::local.eq(false))
.load::<Instance>(conn) .load::<Instance>(conn)
.expect("Error loading remote instances infos") .expect("Instance::get_remotes: loading error")
} }
pub fn page(conn: &Connection, (min, max): (i32, i32)) -> Vec<Instance> { pub fn page(conn: &Connection, (min, max): (i32, i32)) -> Vec<Instance> {
@ -59,11 +59,11 @@ impl Instance {
.offset(min.into()) .offset(min.into())
.limit((max - min).into()) .limit((max - min).into())
.load::<Instance>(conn) .load::<Instance>(conn)
.expect("Error loading a page of instances") .expect("Instance::page: loading error")
} }
pub fn local_id(conn: &Connection) -> i32 { pub fn local_id(conn: &Connection) -> i32 {
Instance::get_local(conn).unwrap().id Instance::get_local(conn).expect("Instance::local_id: local instance not found error").id
} }
insert!(instances, NewInstance); insert!(instances, NewInstance);
@ -74,14 +74,14 @@ impl Instance {
diesel::update(self) diesel::update(self)
.set(instances::blocked.eq(!self.blocked)) .set(instances::blocked.eq(!self.blocked))
.execute(conn) .execute(conn)
.expect("Couldn't block/unblock instance"); .expect("Instance::toggle_block: update error");
} }
/// id: AP object id /// id: AP object id
pub fn is_blocked(conn: &Connection, id: String) -> bool { pub fn is_blocked(conn: &Connection, id: String) -> bool {
for block in instances::table.filter(instances::blocked.eq(true)) for block in instances::table.filter(instances::blocked.eq(true))
.get_results::<Instance>(conn) .get_results::<Instance>(conn)
.expect("Error listing blocked instances") { .expect("Instance::is_blocked: loading error") {
if id.starts_with(format!("https://{}", block.public_domain).as_str()) { if id.starts_with(format!("https://{}", block.public_domain).as_str()) {
return true; return true;
} }
@ -94,7 +94,7 @@ impl Instance {
users::table.filter(users::instance_id.eq(self.id)) users::table.filter(users::instance_id.eq(self.id))
.filter(users::is_admin.eq(true)) .filter(users::is_admin.eq(true))
.load::<User>(conn) .load::<User>(conn)
.expect("Couldn't load admins") .expect("Instance::has_admin: loading error")
.len() > 0 .len() > 0
} }
@ -103,7 +103,7 @@ impl Instance {
.filter(users::is_admin.eq(true)) .filter(users::is_admin.eq(true))
.limit(1) .limit(1)
.get_result::<User>(conn) .get_result::<User>(conn)
.expect("Couldn't load admins") .expect("Instance::main_admin: loading error")
} }
pub fn compute_box(&self, prefix: &'static str, name: String, box_name: &'static str) -> String { pub fn compute_box(&self, prefix: &'static str, name: String, box_name: &'static str) -> String {
@ -128,10 +128,10 @@ impl Instance {
instances::short_description_html.eq(sd), instances::short_description_html.eq(sd),
instances::long_description_html.eq(ld) instances::long_description_html.eq(ld)
)).execute(conn) )).execute(conn)
.expect("Couldn't update instance"); .expect("Instance::update: update error");
} }
pub fn count(conn: &Connection) -> i64 { pub fn count(conn: &Connection) -> i64 {
instances::table.count().get_result(conn).expect("Couldn't count instances") instances::table.count().get_result(conn).expect("Instance::count: counting error")
} }
} }

16
plume-models/src/lib.rs
View File

@ -53,7 +53,7 @@ macro_rules! find_by {
$(.filter($table::$col.eq($col)))+ $(.filter($table::$col.eq($col)))+
.limit(1) .limit(1)
.load::<Self>(conn) .load::<Self>(conn)
.expect("Error loading $table by $col") .expect("macro::find_by: Error loading $table by $col")
.into_iter().nth(0) .into_iter().nth(0)
} }
}; };
@ -78,7 +78,7 @@ macro_rules! list_by {
$table::table $table::table
$(.filter($table::$col.eq($col)))+ $(.filter($table::$col.eq($col)))+
.load::<Self>(conn) .load::<Self>(conn)
.expect("Error loading $table by $col") .expect("macro::list_by: Error loading $table by $col")
} }
}; };
} }
@ -101,7 +101,7 @@ macro_rules! get {
$table::table.filter($table::id.eq(id)) $table::table.filter($table::id.eq(id))
.limit(1) .limit(1)
.load::<Self>(conn) .load::<Self>(conn)
.expect("Error loading $table by id") .expect("macro::get: Error loading $table by id")
.into_iter().nth(0) .into_iter().nth(0)
} }
}; };
@ -127,7 +127,7 @@ macro_rules! insert {
diesel::insert_into($table::table) diesel::insert_into($table::table)
.values(new) .values(new)
.execute(conn) .execute(conn)
.expect("Error saving new $table"); .expect("macro::insert: Error saving new $table");
Self::last(conn) Self::last(conn)
} }
}; };
@ -154,9 +154,9 @@ macro_rules! update {
diesel::update(self) diesel::update(self)
.set(self) .set(self)
.execute(conn) .execute(conn)
.expect(concat!("Error updating ", stringify!($table))); .expect(concat!("macro::update: Error updating ", stringify!($table)));
Self::get(conn, self.id) Self::get(conn, self.id)
.expect(concat!(stringify!($table), " we just updated doesn't exist anymore???")) .expect(concat!("macro::update: ", stringify!($table), " we just updated doesn't exist anymore???"))
} }
}; };
} }
@ -179,9 +179,9 @@ macro_rules! last {
$table::table.order_by($table::id.desc()) $table::table.order_by($table::id.desc())
.limit(1) .limit(1)
.load::<Self>(conn) .load::<Self>(conn)
.expect(concat!("Error getting last ", stringify!($table))) .expect(concat!("macro::last: Error getting last ", stringify!($table)))
.iter().next() .iter().next()
.expect(concat!("No last ", stringify!($table))) .expect(concat!("macro::last: No last ", stringify!($table)))
.clone() .clone()
} }
}; };

26
plume-models/src/likes.rs
View File

@ -42,17 +42,17 @@ impl Like {
diesel::update(self) diesel::update(self)
.set(likes::ap_url.eq(format!( .set(likes::ap_url.eq(format!(
"{}/like/{}", "{}/like/{}",
User::get(conn, self.user_id).unwrap().ap_url, User::get(conn, self.user_id).expect("Like::update_ap_url: user error").ap_url,
Post::get(conn, self.post_id).unwrap().ap_url Post::get(conn, self.post_id).expect("Like::update_ap_url: post error").ap_url
))) )))
.execute(conn).expect("Couldn't update AP URL"); .execute(conn).expect("Like::update_ap_url: update error");
} }
} }
pub fn into_activity(&self, conn: &Connection) -> activity::Like { pub fn into_activity(&self, conn: &Connection) -> activity::Like {
let mut act = activity::Like::default(); let mut act = activity::Like::default();
act.like_props.set_actor_link(User::get(conn, self.user_id).unwrap().into_id()).expect("Like::into_activity: actor error"); act.like_props.set_actor_link(User::get(conn, self.user_id).expect("Like::into_activity: user error").into_id()).expect("Like::into_activity: actor error");
act.like_props.set_object_link(Post::get(conn, self.post_id).unwrap().into_id()).expect("Like::into_activity: object error"); act.like_props.set_object_link(Post::get(conn, self.post_id).expect("Like::into_activity: post error").into_id()).expect("Like::into_activity: object error");
act.object_props.set_to_link(Id::new(PUBLIC_VISIBILTY.to_string())).expect("Like::into_activity: to error"); act.object_props.set_to_link(Id::new(PUBLIC_VISIBILTY.to_string())).expect("Like::into_activity: to error");
act.object_props.set_cc_link_vec::<Id>(vec![]).expect("Like::into_activity: cc error"); act.object_props.set_cc_link_vec::<Id>(vec![]).expect("Like::into_activity: cc error");
act.object_props.set_id_string(self.ap_url.clone()).expect("Like::into_activity: id error"); act.object_props.set_id_string(self.ap_url.clone()).expect("Like::into_activity: id error");
@ -63,11 +63,11 @@ impl Like {
impl FromActivity<activity::Like, Connection> for Like { impl FromActivity<activity::Like, Connection> for Like {
fn from_activity(conn: &Connection, like: activity::Like, _actor: Id) -> Like { fn from_activity(conn: &Connection, like: activity::Like, _actor: Id) -> Like {
let liker = User::from_url(conn, like.like_props.actor.as_str().unwrap().to_string()); let liker = User::from_url(conn, like.like_props.actor.as_str().expect("Like::from_activity: actor error").to_string());
let post = Post::find_by_ap_url(conn, like.like_props.object.as_str().unwrap().to_string()); let post = Post::find_by_ap_url(conn, like.like_props.object.as_str().expect("Like::from_activity: object error").to_string());
let res = Like::insert(conn, NewLike { let res = Like::insert(conn, NewLike {
post_id: post.unwrap().id, post_id: post.expect("Like::from_activity: post error").id,
user_id: liker.unwrap().id, user_id: liker.expect("Like::from_activity: user error").id,
ap_url: like.object_props.id_string().unwrap_or(String::from("")) ap_url: like.object_props.id_string().unwrap_or(String::from(""))
}); });
res.notify(conn); res.notify(conn);
@ -77,7 +77,7 @@ impl FromActivity<activity::Like, Connection> for Like {
impl Notify<Connection> for Like { impl Notify<Connection> for Like {
fn notify(&self, conn: &Connection) { fn notify(&self, conn: &Connection) {
let post = Post::get(conn, self.post_id).unwrap(); let post = Post::get(conn, self.post_id).expect("Like::notify: post error");
for author in post.get_authors(conn) { for author in post.get_authors(conn) {
Notification::insert(conn, NewNotification { Notification::insert(conn, NewNotification {
kind: notification_kind::LIKE.to_string(), kind: notification_kind::LIKE.to_string(),
@ -90,15 +90,15 @@ impl Notify<Connection> for Like {
impl Deletable<Connection, activity::Undo> for Like { impl Deletable<Connection, activity::Undo> for Like {
fn delete(&self, conn: &Connection) -> activity::Undo { fn delete(&self, conn: &Connection) -> activity::Undo {
diesel::delete(self).execute(conn).unwrap(); diesel::delete(self).execute(conn).expect("Like::delete: delete error");
// delete associated notification if any // delete associated notification if any
if let Some(notif) = Notification::find(conn, notification_kind::LIKE, self.id) { if let Some(notif) = Notification::find(conn, notification_kind::LIKE, self.id) {
diesel::delete(&notif).execute(conn).expect("Couldn't delete like notification"); diesel::delete(&notif).execute(conn).expect("Like::delete: notification error");
} }
let mut act = activity::Undo::default(); let mut act = activity::Undo::default();
act.undo_props.set_actor_link(User::get(conn, self.user_id).unwrap().into_id()).expect("Like::delete: actor error"); act.undo_props.set_actor_link(User::get(conn, self.user_id).expect("Like::delete: user error").into_id()).expect("Like::delete: actor error");
act.undo_props.set_object_object(self.into_activity(conn)).expect("Like::delete: object error"); act.undo_props.set_object_object(self.into_activity(conn)).expect("Like::delete: object error");
act.object_props.set_id_string(format!("{}#delete", self.ap_url)).expect("Like::delete: id error"); act.object_props.set_id_string(format!("{}#delete", self.ap_url)).expect("Like::delete: id error");
act.object_props.set_to_link(Id::new(PUBLIC_VISIBILTY.to_string())).expect("Like::delete: to error"); act.object_props.set_to_link(Id::new(PUBLIC_VISIBILTY.to_string())).expect("Like::delete: to error");

12
plume-models/src/medias.rs
View File

@ -36,9 +36,9 @@ impl Media {
list_by!(medias, for_user, owner_id as i32); list_by!(medias, for_user, owner_id as i32);
pub fn to_json(&self, conn: &Connection) -> serde_json::Value { pub fn to_json(&self, conn: &Connection) -> serde_json::Value {
let mut json = serde_json::to_value(self).unwrap(); let mut json = serde_json::to_value(self).expect("Media::to_json: serialization error");
let url = self.url(conn); let url = self.url(conn);
let (preview, html, md) = match self.file_path.rsplitn(2, '.').next().unwrap() { let (preview, html, md) = match self.file_path.rsplitn(2, '.').next().expect("Media::to_json: extension error") {
"png" | "jpg" | "jpeg" | "gif" | "svg" => ( "png" | "jpg" | "jpeg" | "gif" | "svg" => (
format!("<img src=\"{}\" alt=\"{}\" title=\"{}\" class=\"preview\">", url, self.alt_text, self.alt_text), format!("<img src=\"{}\" alt=\"{}\" title=\"{}\" class=\"preview\">", url, self.alt_text, self.alt_text),
format!("<img src=\"{}\" alt=\"{}\" title=\"{}\">", url, self.alt_text, self.alt_text), format!("<img src=\"{}\" alt=\"{}\" title=\"{}\">", url, self.alt_text, self.alt_text),
@ -67,13 +67,13 @@ impl Media {
if self.is_remote { if self.is_remote {
self.remote_url.clone().unwrap_or(String::new()) self.remote_url.clone().unwrap_or(String::new())
} else { } else {
ap_url(format!("{}/static/{}", Instance::get_local(conn).unwrap().public_domain, self.file_path)) ap_url(format!("{}/static/{}", Instance::get_local(conn).expect("Media::url: local instance not found error").public_domain, self.file_path))
} }
} }
pub fn delete(&self, conn: &Connection) { pub fn delete(&self, conn: &Connection) {
fs::remove_file(self.file_path.as_str()).expect("Couldn't delete media from disk"); fs::remove_file(self.file_path.as_str()).expect("Media::delete: file deletion error");
diesel::delete(self).execute(conn).expect("Couldn't remove media from DB"); diesel::delete(self).execute(conn).expect("Media::delete: database entry deletion error");
} }
pub fn save_remote(conn: &Connection, url: String) -> Media { pub fn save_remote(conn: &Connection, url: String) -> Media {
@ -92,6 +92,6 @@ impl Media {
diesel::update(self) diesel::update(self)
.set(medias::owner_id.eq(id)) .set(medias::owner_id.eq(id))
.execute(conn) .execute(conn)
.expect("Couldn't update Media.owner_id"); .expect("Media::set_owner: owner update error");
} }
} }

8
plume-models/src/mentions.rs
View File

@ -57,16 +57,16 @@ impl Mention {
pub fn build_activity(conn: &Connection, ment: String) -> link::Mention { pub fn build_activity(conn: &Connection, ment: String) -> link::Mention {
let user = User::find_by_fqn(conn, ment.clone()); let user = User::find_by_fqn(conn, ment.clone());
let mut mention = link::Mention::default(); let mut mention = link::Mention::default();
mention.link_props.set_href_string(user.clone().map(|u| u.ap_url).unwrap_or(String::new())).expect("Error setting mention's href"); mention.link_props.set_href_string(user.clone().map(|u| u.ap_url).unwrap_or(String::new())).expect("Mention::build_activity: href error");
mention.link_props.set_name_string(format!("@{}", ment)).expect("Error setting mention's name"); mention.link_props.set_name_string(format!("@{}", ment)).expect("Mention::build_activity: name error:");
mention mention
} }
pub fn to_activity(&self, conn: &Connection) -> link::Mention { pub fn to_activity(&self, conn: &Connection) -> link::Mention {
let user = self.get_mentioned(conn); let user = self.get_mentioned(conn);
let mut mention = link::Mention::default(); let mut mention = link::Mention::default();
mention.link_props.set_href_string(user.clone().map(|u| u.ap_url).unwrap_or(String::new())).expect("Error setting mention's href"); mention.link_props.set_href_string(user.clone().map(|u| u.ap_url).unwrap_or(String::new())).expect("Mention::to_activity: href error");
mention.link_props.set_name_string(user.map(|u| format!("@{}", u.get_fqn(conn))).unwrap_or(String::new())).expect("Error setting mention's name"); mention.link_props.set_name_string(user.map(|u| format!("@{}", u.get_fqn(conn))).unwrap_or(String::new())).expect("Mention::to_activity: mention error");
mention mention
} }

8
plume-models/src/notifications.rs
View File

@ -45,7 +45,7 @@ impl Notification {
notifications::table.filter(notifications::user_id.eq(user.id)) notifications::table.filter(notifications::user_id.eq(user.id))
.order_by(notifications::creation_date.desc()) .order_by(notifications::creation_date.desc())
.load::<Notification>(conn) .load::<Notification>(conn)
.expect("Couldn't load user notifications") .expect("Notification::find_for_user: notification loading error")
} }
pub fn page_for_user(conn: &Connection, user: &User, (min, max): (i32, i32)) -> Vec<Notification> { pub fn page_for_user(conn: &Connection, user: &User, (min, max): (i32, i32)) -> Vec<Notification> {
@ -54,7 +54,7 @@ impl Notification {
.offset(min.into()) .offset(min.into())
.limit((max - min).into()) .limit((max - min).into())
.load::<Notification>(conn) .load::<Notification>(conn)
.expect("Couldn't load user notifications page") .expect("Notification::page_for_user: notification loading error")
} }
pub fn find<S: Into<String>>(conn: &Connection, kind: S, obj: i32) -> Option<Notification> { pub fn find<S: Into<String>>(conn: &Connection, kind: S, obj: i32) -> Option<Notification> {
@ -90,9 +90,9 @@ impl Notification {
"user": mention.get_user(conn).map(|u| u.to_json(conn)), "user": mention.get_user(conn).map(|u| u.to_json(conn)),
"url": mention.get_post(conn).map(|p| p.to_json(conn)["url"].clone()) "url": mention.get_post(conn).map(|p| p.to_json(conn)["url"].clone())
.unwrap_or_else(|| { .unwrap_or_else(|| {
let comment = mention.get_comment(conn).expect("No comment nor post for mention"); let comment = mention.get_comment(conn).expect("Notification::to_json: comment not found error");
let post = comment.get_post(conn).to_json(conn); let post = comment.get_post(conn).to_json(conn);
json!(format!("{}#comment-{}", post["url"].as_str().unwrap(), comment.id)) json!(format!("{}#comment-{}", post["url"].as_str().expect("Notification::to_json: post url error"), comment.id))
}) })
}) })
), ),

51
plume-models/src/posts.rs
View File

@ -122,7 +122,7 @@ impl Post {
.offset(min.into()) .offset(min.into())
.limit((max - min).into()) .limit((max - min).into())
.load(conn) .load(conn)
.expect("Error loading posts by tag") .expect("Post::list_by_tag: loading error")
} }
pub fn count_for_tag(conn: &Connection, tag: String) -> i64 { pub fn count_for_tag(conn: &Connection, tag: String) -> i64 {
@ -132,8 +132,8 @@ impl Post {
.filter(posts::published.eq(true)) .filter(posts::published.eq(true))
.count() .count()
.load(conn) .load(conn)
.expect("Error counting posts by tag") .expect("Post::count_for_tag: counting error")
.iter().next().unwrap() .iter().next().expect("Post::count_for_tag: no result error")
} }
pub fn count_local(conn: &Connection) -> usize { pub fn count_local(conn: &Connection) -> usize {
@ -144,12 +144,15 @@ impl Post {
posts::table.filter(posts::id.eq_any(local_posts_id)) posts::table.filter(posts::id.eq_any(local_posts_id))
.filter(posts::published.eq(true)) .filter(posts::published.eq(true))
.load::<Post>(conn) .load::<Post>(conn)
.expect("Couldn't load local posts") .expect("Post::count_local: loading error")
.len() .len()// TODO count in database?
} }
pub fn count(conn: &Connection) -> i64 { pub fn count(conn: &Connection) -> i64 {
posts::table.filter(posts::published.eq(true)).count().get_result(conn).expect("Couldn't count posts") posts::table.filter(posts::published.eq(true))
.count()
.get_result(conn)
.expect("Post::count: counting error")
} }
pub fn get_recents(conn: &Connection, limit: i64) -> Vec<Post> { pub fn get_recents(conn: &Connection, limit: i64) -> Vec<Post> {
@ -157,7 +160,7 @@ impl Post {
.filter(posts::published.eq(true)) .filter(posts::published.eq(true))
.limit(limit) .limit(limit)
.load::<Post>(conn) .load::<Post>(conn)
.expect("Error loading recent posts") .expect("Post::get_recents: loading error")
} }
pub fn get_recents_for_author(conn: &Connection, author: &User, limit: i64) -> Vec<Post> { pub fn get_recents_for_author(conn: &Connection, author: &User, limit: i64) -> Vec<Post> {
@ -169,7 +172,7 @@ impl Post {
.order(posts::creation_date.desc()) .order(posts::creation_date.desc())
.limit(limit) .limit(limit)
.load::<Post>(conn) .load::<Post>(conn)
.expect("Error loading recent posts for author") .expect("Post::get_recents_for_author: loading error")
} }
pub fn get_recents_for_blog(conn: &Connection, blog: &Blog, limit: i64) -> Vec<Post> { pub fn get_recents_for_blog(conn: &Connection, blog: &Blog, limit: i64) -> Vec<Post> {
@ -178,14 +181,14 @@ impl Post {
.order(posts::creation_date.desc()) .order(posts::creation_date.desc())
.limit(limit) .limit(limit)
.load::<Post>(conn) .load::<Post>(conn)
.expect("Error loading recent posts for blog") .expect("Post::get_recents_for_blog: loading error")
} }
pub fn get_for_blog(conn: &Connection, blog:&Blog) -> Vec<Post> { pub fn get_for_blog(conn: &Connection, blog:&Blog) -> Vec<Post> {
posts::table.filter(posts::blog_id.eq(blog.id)) posts::table.filter(posts::blog_id.eq(blog.id))
.filter(posts::published.eq(true)) .filter(posts::published.eq(true))
.load::<Post>(conn) .load::<Post>(conn)
.expect("Error loading posts for blog") .expect("Post::get_for_blog:: loading error")
} }
pub fn blog_page(conn: &Connection, blog: &Blog, (min, max): (i32, i32)) -> Vec<Post> { pub fn blog_page(conn: &Connection, blog: &Blog, (min, max): (i32, i32)) -> Vec<Post> {
@ -195,7 +198,7 @@ impl Post {
.offset(min.into()) .offset(min.into())
.limit((max - min).into()) .limit((max - min).into())
.load::<Post>(conn) .load::<Post>(conn)
.expect("Error loading a page of posts for blog") .expect("Post::blog_page: loading error")
} }
/// Give a page of all the recent posts known to this instance (= federated timeline) /// Give a page of all the recent posts known to this instance (= federated timeline)
@ -205,7 +208,7 @@ impl Post {
.offset(min.into()) .offset(min.into())
.limit((max - min).into()) .limit((max - min).into())
.load::<Post>(conn) .load::<Post>(conn)
.expect("Error loading recent posts page") .expect("Post::get_recents_page: loading error")
} }
/// Give a page of posts from a specific instance /// Give a page of posts from a specific instance
@ -220,7 +223,7 @@ impl Post {
.offset(min.into()) .offset(min.into())
.limit((max - min).into()) .limit((max - min).into())
.load::<Post>(conn) .load::<Post>(conn)
.expect("Error loading local posts page") .expect("Post::get_instance_page: loading error")
} }
/// Give a page of customized user feed, based on a list of followed users /// Give a page of customized user feed, based on a list of followed users
@ -236,7 +239,7 @@ impl Post {
.offset(min.into()) .offset(min.into())
.limit((max - min).into()) .limit((max - min).into())
.load::<Post>(conn) .load::<Post>(conn)
.expect("Error loading user feed page") .expect("Post::user_feed_page: loading error")
} }
pub fn drafts_by_author(conn: &Connection, author: &User) -> Vec<Post> { pub fn drafts_by_author(conn: &Connection, author: &User) -> Vec<Post> {
@ -247,14 +250,14 @@ impl Post {
.filter(posts::published.eq(false)) .filter(posts::published.eq(false))
.filter(posts::id.eq_any(posts)) .filter(posts::id.eq_any(posts))
.load::<Post>(conn) .load::<Post>(conn)
.expect("Error listing drafts") .expect("Post::drafts_by_author: loading error")
} }
pub fn get_authors(&self, conn: &Connection) -> Vec<User> { pub fn get_authors(&self, conn: &Connection) -> Vec<User> {
use schema::users; use schema::users;
use schema::post_authors; use schema::post_authors;
let author_list = PostAuthor::belonging_to(self).select(post_authors::author_id); let author_list = PostAuthor::belonging_to(self).select(post_authors::author_id);
users::table.filter(users::id.eq_any(author_list)).load::<User>(conn).unwrap() users::table.filter(users::id.eq_any(author_list)).load::<User>(conn).expect("Post::get_authors: loading error")
} }
pub fn get_blog(&self, conn: &Connection) -> Blog { pub fn get_blog(&self, conn: &Connection) -> Blog {
@ -262,30 +265,30 @@ impl Post {
blogs::table.filter(blogs::id.eq(self.blog_id)) blogs::table.filter(blogs::id.eq(self.blog_id))
.limit(1) .limit(1)
.load::<Blog>(conn) .load::<Blog>(conn)
.expect("Couldn't load blog associted to post") .expect("Post::get_blog: loading error")
.into_iter().nth(0).unwrap() .into_iter().nth(0).expect("Post::get_blog: no result error")
} }
pub fn get_likes(&self, conn: &Connection) -> Vec<Like> { pub fn get_likes(&self, conn: &Connection) -> Vec<Like> {
use schema::likes; use schema::likes;
likes::table.filter(likes::post_id.eq(self.id)) likes::table.filter(likes::post_id.eq(self.id))
.load::<Like>(conn) .load::<Like>(conn)
.expect("Couldn't load likes associted to post") .expect("Post::get_likes: loading error")
} }
pub fn get_reshares(&self, conn: &Connection) -> Vec<Reshare> { pub fn get_reshares(&self, conn: &Connection) -> Vec<Reshare> {
use schema::reshares; use schema::reshares;
reshares::table.filter(reshares::post_id.eq(self.id)) reshares::table.filter(reshares::post_id.eq(self.id))
.load::<Reshare>(conn) .load::<Reshare>(conn)
.expect("Couldn't load reshares associted to post") .expect("Post::get_reshares: loading error")
} }
pub fn update_ap_url(&self, conn: &Connection) -> Post { pub fn update_ap_url(&self, conn: &Connection) -> Post {
if self.ap_url.len() == 0 { if self.ap_url.len() == 0 {
diesel::update(self) diesel::update(self)
.set(posts::ap_url.eq(self.compute_id(conn))) .set(posts::ap_url.eq(self.compute_id(conn)))
.execute(conn).expect("Couldn't update AP URL"); .execute(conn).expect("Post::update_ap_url: update error");
Post::get(conn, self.id).unwrap() Post::get(conn, self.id).expect("Post::update_ap_url: get error")
} else { } else {
self.clone() self.clone()
} }
@ -359,7 +362,7 @@ impl Post {
pub fn handle_update(conn: &Connection, updated: Article) { pub fn handle_update(conn: &Connection, updated: Article) {
let id = updated.object_props.id_string().expect("Post::handle_update: id error"); let id = updated.object_props.id_string().expect("Post::handle_update: id error");
let mut post = Post::find_by_ap_url(conn, id).unwrap(); let mut post = Post::find_by_ap_url(conn, id).expect("Post::handle_update: finding error");
if let Ok(title) = updated.object_props.name_string() { if let Ok(title) = updated.object_props.name_string() {
post.slug = title.to_kebab_case(); post.slug = title.to_kebab_case();
@ -423,7 +426,7 @@ impl FromActivity<Article, Connection> for Post {
let title = article.object_props.name_string().expect("Post::from_activity: title error"); let title = article.object_props.name_string().expect("Post::from_activity: title error");
let post = Post::insert(conn, NewPost { let post = Post::insert(conn, NewPost {
blog_id: blog.expect("Received a new Article without a blog").id, blog_id: blog.expect("Post::from_activity: blog not found error").id,
slug: title.to_kebab_case(), slug: title.to_kebab_case(),
title: title, title: title,
content: SafeString::new(&article.object_props.content_string().expect("Post::from_activity: content error")), content: SafeString::new(&article.object_props.content_string().expect("Post::from_activity: content error")),

30
plume-models/src/reshares.rs
View File

@ -37,10 +37,10 @@ impl Reshare {
diesel::update(self) diesel::update(self)
.set(reshares::ap_url.eq(format!( .set(reshares::ap_url.eq(format!(
"{}/reshare/{}", "{}/reshare/{}",
User::get(conn, self.user_id).unwrap().ap_url, User::get(conn, self.user_id).expect("Reshare::update_ap_url: user error").ap_url,
Post::get(conn, self.post_id).unwrap().ap_url Post::get(conn, self.post_id).expect("Reshare::update_ap_url: post error").ap_url
))) )))
.execute(conn).expect("Couldn't update AP URL"); .execute(conn).expect("Reshare::update_ap_url: update error");
} }
} }
@ -49,7 +49,7 @@ impl Reshare {
.order(reshares::creation_date.desc()) .order(reshares::creation_date.desc())
.limit(limit) .limit(limit)
.load::<Reshare>(conn) .load::<Reshare>(conn)
.expect("Error loading recent reshares for user") .expect("Reshare::get_recents_for_author: loading error")
} }
pub fn get_post(&self, conn: &Connection) -> Option<Post> { pub fn get_post(&self, conn: &Connection) -> Option<Post> {
@ -62,9 +62,11 @@ impl Reshare {
pub fn into_activity(&self, conn: &Connection) -> Announce { pub fn into_activity(&self, conn: &Connection) -> Announce {
let mut act = Announce::default(); let mut act = Announce::default();
act.announce_props.set_actor_link(User::get(conn, self.user_id).unwrap().into_id()).unwrap(); act.announce_props.set_actor_link(User::get(conn, self.user_id).expect("Reshare::into_activity: user error").into_id())
act.announce_props.set_object_link(Post::get(conn, self.post_id).unwrap().into_id()).unwrap(); .expect("Reshare::into_activity: actor error");
act.object_props.set_id_string(self.ap_url.clone()).unwrap(); act.announce_props.set_object_link(Post::get(conn, self.post_id).expect("Reshare::into_activity: post error").into_id())
.expect("Reshare::into_activity: object error");
act.object_props.set_id_string(self.ap_url.clone()).expect("Reshare::into_activity: id error");
act.object_props.set_to_link(Id::new(PUBLIC_VISIBILTY.to_string())).expect("Reshare::into_activity: to error"); act.object_props.set_to_link(Id::new(PUBLIC_VISIBILTY.to_string())).expect("Reshare::into_activity: to error");
act.object_props.set_cc_link_vec::<Id>(vec![]).expect("Reshare::into_activity: cc error"); act.object_props.set_cc_link_vec::<Id>(vec![]).expect("Reshare::into_activity: cc error");
@ -77,8 +79,8 @@ impl FromActivity<Announce, Connection> for Reshare {
let user = User::from_url(conn, announce.announce_props.actor_link::<Id>().expect("Reshare::from_activity: actor error").into()); let user = User::from_url(conn, announce.announce_props.actor_link::<Id>().expect("Reshare::from_activity: actor error").into());
let post = Post::find_by_ap_url(conn, announce.announce_props.object_link::<Id>().expect("Reshare::from_activity: object error").into()); let post = Post::find_by_ap_url(conn, announce.announce_props.object_link::<Id>().expect("Reshare::from_activity: object error").into());
let reshare = Reshare::insert(conn, NewReshare { let reshare = Reshare::insert(conn, NewReshare {
post_id: post.unwrap().id, post_id: post.expect("Reshare::from_activity: post error").id,
user_id: user.unwrap().id, user_id: user.expect("Reshare::from_activity: user error").id,
ap_url: announce.object_props.id_string().unwrap_or(String::from("")) ap_url: announce.object_props.id_string().unwrap_or(String::from(""))
}); });
reshare.notify(conn); reshare.notify(conn);
@ -88,7 +90,7 @@ impl FromActivity<Announce, Connection> for Reshare {
impl Notify<Connection> for Reshare { impl Notify<Connection> for Reshare {
fn notify(&self, conn: &Connection) { fn notify(&self, conn: &Connection) {
let post = self.get_post(conn).unwrap(); let post = self.get_post(conn).expect("Reshare::notify: post error");
for author in post.get_authors(conn) { for author in post.get_authors(conn) {
Notification::insert(conn, NewNotification { Notification::insert(conn, NewNotification {
kind: notification_kind::RESHARE.to_string(), kind: notification_kind::RESHARE.to_string(),
@ -101,16 +103,16 @@ impl Notify<Connection> for Reshare {
impl Deletable<Connection, Undo> for Reshare { impl Deletable<Connection, Undo> for Reshare {
fn delete(&self, conn: &Connection) -> Undo { fn delete(&self, conn: &Connection) -> Undo {
diesel::delete(self).execute(conn).unwrap(); diesel::delete(self).execute(conn).expect("Reshare::delete: delete error");
// delete associated notification if any // delete associated notification if any
if let Some(notif) = Notification::find(conn, notification_kind::RESHARE, self.id) { if let Some(notif) = Notification::find(conn, notification_kind::RESHARE, self.id) {
diesel::delete(&notif).execute(conn).expect("Couldn't delete reshare notification"); diesel::delete(&notif).execute(conn).expect("Reshare::delete: notification error");
} }
let mut act = Undo::default(); let mut act = Undo::default();
act.undo_props.set_actor_link(User::get(conn, self.user_id).unwrap().into_id()).unwrap(); act.undo_props.set_actor_link(User::get(conn, self.user_id).expect("Reshare::delete: user error").into_id()).expect("Reshare::delete: actor error");
act.undo_props.set_object_object(self.into_activity(conn)).unwrap(); act.undo_props.set_object_object(self.into_activity(conn)).expect("Reshare::delete: object error");
act.object_props.set_id_string(format!("{}#delete", self.ap_url)).expect("Reshare::delete: id error"); act.object_props.set_id_string(format!("{}#delete", self.ap_url)).expect("Reshare::delete: id error");
act.object_props.set_to_link(Id::new(PUBLIC_VISIBILTY.to_string())).expect("Reshare::delete: to error"); act.object_props.set_to_link(Id::new(PUBLIC_VISIBILTY.to_string())).expect("Reshare::delete: to error");
act.object_props.set_cc_link_vec::<Id>(vec![]).expect("Reshare::delete: cc error"); act.object_props.set_cc_link_vec::<Id>(vec![]).expect("Reshare::delete: cc error");

5
plume-models/src/tags.rs
View File

@ -29,7 +29,10 @@ impl Tag {
pub fn into_activity(&self, conn: &Connection) -> Hashtag { pub fn into_activity(&self, conn: &Connection) -> Hashtag {
let mut ht = Hashtag::default(); let mut ht = Hashtag::default();
ht.set_href_string(ap_url(format!("{}/tag/{}", Instance::get_local(conn).unwrap().public_domain, self.tag))).expect("Tag::into_activity: href error"); ht.set_href_string(ap_url(format!("{}/tag/{}",
Instance::get_local(conn).expect("Tag::into_activity: local instance not found error").public_domain,
self.tag)
)).expect("Tag::into_activity: href error");
ht.set_name_string(self.tag.clone()).expect("Tag::into_activity: name error"); ht.set_name_string(self.tag.clone()).expect("Tag::into_activity: name error");
ht ht
} }

133
plume-models/src/users.rs
View File

@ -102,7 +102,7 @@ impl User {
pub fn one_by_instance(conn: &Connection) -> Vec<User> { pub fn one_by_instance(conn: &Connection) -> Vec<User> {
users::table.filter(users::instance_id.eq_any(users::table.select(users::instance_id).distinct())) users::table.filter(users::instance_id.eq_any(users::table.select(users::instance_id).distinct()))
.load::<User>(conn) .load::<User>(conn)
.expect("Error in User::on_by_instance") .expect("User::one_by_instance: loading error")
} }
pub fn delete(&self, conn: &Connection) { pub fn delete(&self, conn: &Connection) {
@ -113,31 +113,31 @@ impl User {
.filter(post_authors::author_id.eq(self.id)) .filter(post_authors::author_id.eq(self.id))
.select(post_authors::post_id) .select(post_authors::post_id)
.load(conn) .load(conn)
.expect("Couldn't load posts IDs"); .expect("User::delete: post loading error");
for post_id in all_their_posts_ids { for post_id in all_their_posts_ids {
let has_other_authors = post_authors::table let has_other_authors = post_authors::table
.filter(post_authors::post_id.eq(post_id)) .filter(post_authors::post_id.eq(post_id))
.filter(post_authors::author_id.ne(self.id)) .filter(post_authors::author_id.ne(self.id))
.count() .count()
.load(conn) .load(conn)
.expect("Couldn't count other authors").iter().next().unwrap_or(&0) > &0; .expect("User::delete: count author error").iter().next().unwrap_or(&0) > &0;
if !has_other_authors { if !has_other_authors {
Post::get(conn, post_id).expect("Post is already gone").delete(conn); Post::get(conn, post_id).expect("User::delete: post not found error").delete(conn);
} }
} }
diesel::delete(self).execute(conn).expect("Couldn't remove user from DB"); diesel::delete(self).execute(conn).expect("User::delete: user deletion error");
} }
pub fn get_instance(&self, conn: &Connection) -> Instance { pub fn get_instance(&self, conn: &Connection) -> Instance {
Instance::get(conn, self.instance_id).expect("Couldn't find instance") Instance::get(conn, self.instance_id).expect("User::get_instance: instance not found error")
} }
pub fn grant_admin_rights(&self, conn: &Connection) { pub fn grant_admin_rights(&self, conn: &Connection) {
diesel::update(self) diesel::update(self)
.set(users::is_admin.eq(true)) .set(users::is_admin.eq(true))
.execute(conn) .execute(conn)
.expect("Couldn't grant admin rights"); .expect("User::grand_admin_rights: update error");
} }
pub fn update(&self, conn: &Connection, name: String, email: String, summary: String) -> User { pub fn update(&self, conn: &Connection, name: String, email: String, summary: String) -> User {
@ -147,15 +147,15 @@ impl User {
users::email.eq(email), users::email.eq(email),
users::summary.eq(summary), users::summary.eq(summary),
)).execute(conn) )).execute(conn)
.expect("Couldn't update user"); .expect("User::update: update error");
User::get(conn, self.id).unwrap() User::get(conn, self.id).expect("User::update: get error")
} }
pub fn count_local(conn: &Connection) -> usize { pub fn count_local(conn: &Connection) -> usize {
users::table.filter(users::instance_id.eq(Instance::local_id(conn))) users::table.filter(users::instance_id.eq(Instance::local_id(conn)))
.load::<User>(conn) .load::<User>(conn)
.expect("Couldn't load local users") .expect("User::count_local: loading error")
.len() .len()// TODO count in database?
} }
pub fn find_local(conn: &Connection, username: String) -> Option<User> { pub fn find_local(conn: &Connection, username: String) -> Option<User> {
@ -164,9 +164,9 @@ impl User {
pub fn find_by_fqn(conn: &Connection, fqn: String) -> Option<User> { pub fn find_by_fqn(conn: &Connection, fqn: String) -> Option<User> {
if fqn.contains("@") { // remote user if fqn.contains("@") { // remote user
match Instance::find_by_domain(conn, String::from(fqn.split("@").last().unwrap())) { match Instance::find_by_domain(conn, String::from(fqn.split("@").last().expect("User::find_by_fqn: host error"))) {
Some(instance) => { Some(instance) => {
match User::find_by_name(conn, String::from(fqn.split("@").nth(0).unwrap()), instance.id) { match User::find_by_name(conn, String::from(fqn.split("@").nth(0).expect("User::find_by_fqn: name error")), instance.id) {
Some(u) => Some(u), Some(u) => Some(u),
None => User::fetch_from_webfinger(conn, fqn) None => User::fetch_from_webfinger(conn, fqn)
} }
@ -180,7 +180,7 @@ impl User {
fn fetch_from_webfinger(conn: &Connection, acct: String) -> Option<User> { fn fetch_from_webfinger(conn: &Connection, acct: String) -> Option<User> {
match resolve(acct.clone(), *USE_HTTPS) { match resolve(acct.clone(), *USE_HTTPS) {
Ok(wf) => wf.links.into_iter().find(|l| l.mime_type == Some(String::from("application/activity+json"))).and_then(|l| User::fetch_from_url(conn, l.href.expect("No href for AP WF link"))), Ok(wf) => wf.links.into_iter().find(|l| l.mime_type == Some(String::from("application/activity+json"))).and_then(|l| User::fetch_from_url(conn, l.href.expect("User::fetch_from_webginfer: href not found error"))),
Err(details) => { Err(details) => {
println!("WF Error: {:?}", details); println!("WF Error: {:?}", details);
None None
@ -191,7 +191,7 @@ impl User {
fn fetch(url: String) -> Option<CustomPerson> { fn fetch(url: String) -> Option<CustomPerson> {
let req = Client::new() let req = Client::new()
.get(&url[..]) .get(&url[..])
.header(ACCEPT, HeaderValue::from_str(&ap_accept_header().into_iter().collect::<Vec<_>>().join(", ")).unwrap()) .header(ACCEPT, HeaderValue::from_str(&ap_accept_header().into_iter().collect::<Vec<_>>().join(", ")).expect("User::fetch: accept header error"))
.send(); .send();
match req { match req {
Ok(mut res) => { Ok(mut res) => {
@ -212,7 +212,9 @@ impl User {
} }
pub fn fetch_from_url(conn: &Connection, url: String) -> Option<User> { pub fn fetch_from_url(conn: &Connection, url: String) -> Option<User> {
User::fetch(url.clone()).map(|json| (User::from_activity(conn, json, Url::parse(url.as_ref()).unwrap().host_str().unwrap().to_string()))) User::fetch(url.clone()).map(|json| (User::from_activity(conn, json, Url::parse(url.as_ref())
.expect("User::fetch_from_url: url error").host_str()
.expect("User::fetch_from_url: host error").to_string())))
} }
fn from_activity(conn: &Connection, acct: CustomPerson, inst: String) -> User { fn from_activity(conn: &Connection, acct: CustomPerson, inst: String) -> User {
@ -277,16 +279,16 @@ impl User {
users::avatar_id.eq(Some(avatar.id)), users::avatar_id.eq(Some(avatar.id)),
users::last_fetched_date.eq(Utc::now().naive_utc()) users::last_fetched_date.eq(Utc::now().naive_utc())
)).execute(conn) )).execute(conn)
.expect("Couldn't update user") .expect("User::refetch: update error")
}); });
} }
pub fn hash_pass(pass: String) -> String { pub fn hash_pass(pass: String) -> String {
bcrypt::hash(pass.as_str(), 10).unwrap() bcrypt::hash(pass.as_str(), 10).expect("User::hash_pass: hashing error")
} }
pub fn auth(&self, pass: String) -> bool { pub fn auth(&self, pass: String) -> bool {
if let Ok(valid) = bcrypt::verify(pass.as_str(), self.hashed_password.clone().unwrap().as_str()) { if let Ok(valid) = bcrypt::verify(pass.as_str(), self.hashed_password.clone().expect("User::auth: no password error").as_str()) {
valid valid
} else { } else {
false false
@ -298,31 +300,31 @@ impl User {
if self.outbox_url.len() == 0 { if self.outbox_url.len() == 0 {
diesel::update(self) diesel::update(self)
.set(users::outbox_url.eq(instance.compute_box(USER_PREFIX, self.username.clone(), "outbox"))) .set(users::outbox_url.eq(instance.compute_box(USER_PREFIX, self.username.clone(), "outbox")))
.execute(conn).expect("Couldn't update outbox URL"); .execute(conn).expect("User::update_boxes: outbox update error");
} }
if self.inbox_url.len() == 0 { if self.inbox_url.len() == 0 {
diesel::update(self) diesel::update(self)
.set(users::inbox_url.eq(instance.compute_box(USER_PREFIX, self.username.clone(), "inbox"))) .set(users::inbox_url.eq(instance.compute_box(USER_PREFIX, self.username.clone(), "inbox")))
.execute(conn).expect("Couldn't update inbox URL"); .execute(conn).expect("User::update_boxes: inbox update error");
} }
if self.ap_url.len() == 0 { if self.ap_url.len() == 0 {
diesel::update(self) diesel::update(self)
.set(users::ap_url.eq(instance.compute_box(USER_PREFIX, self.username.clone(), ""))) .set(users::ap_url.eq(instance.compute_box(USER_PREFIX, self.username.clone(), "")))
.execute(conn).expect("Couldn't update AP URL"); .execute(conn).expect("User::update_boxes: ap_url update error");
} }
if self.shared_inbox_url.is_none() { if self.shared_inbox_url.is_none() {
diesel::update(self) diesel::update(self)
.set(users::shared_inbox_url.eq(ap_url(format!("{}/inbox", Instance::get_local(conn).unwrap().public_domain)))) .set(users::shared_inbox_url.eq(ap_url(format!("{}/inbox", Instance::get_local(conn).expect("User::update_boxes: local instance not found error").public_domain))))
.execute(conn).expect("Couldn't update shared inbox URL"); .execute(conn).expect("User::update_boxes: shared inbox update error");
} }
if self.followers_endpoint.len() == 0 { if self.followers_endpoint.len() == 0 {
diesel::update(self) diesel::update(self)
.set(users::followers_endpoint.eq(instance.compute_box(USER_PREFIX, self.username.clone(), "followers"))) .set(users::followers_endpoint.eq(instance.compute_box(USER_PREFIX, self.username.clone(), "followers")))
.execute(conn).expect("Couldn't update followers endpoint"); .execute(conn).expect("User::update_boxes: follower update error");
} }
} }
@ -332,27 +334,27 @@ impl User {
.offset(min.into()) .offset(min.into())
.limit((max - min).into()) .limit((max - min).into())
.load::<User>(conn) .load::<User>(conn)
.expect("Error getting local users page") .expect("User::get_local_page: loading error")
} }
pub fn outbox(&self, conn: &Connection) -> ActivityStream<OrderedCollection> { pub fn outbox(&self, conn: &Connection) -> ActivityStream<OrderedCollection> {
let acts = self.get_activities(conn); let acts = self.get_activities(conn);
let n_acts = acts.len(); let n_acts = acts.len();
let mut coll = OrderedCollection::default(); let mut coll = OrderedCollection::default();
coll.collection_props.items = serde_json::to_value(acts).unwrap(); coll.collection_props.items = serde_json::to_value(acts).expect("User::outbox: activity error");
coll.collection_props.set_total_items_u64(n_acts as u64).unwrap(); coll.collection_props.set_total_items_u64(n_acts as u64).expect("User::outbox: count error");
ActivityStream::new(coll) ActivityStream::new(coll)
} }
pub fn fetch_outbox<T: Activity>(&self) -> Vec<T> { pub fn fetch_outbox<T: Activity>(&self) -> Vec<T> {
let req = Client::new() let req = Client::new()
.get(&self.outbox_url[..]) .get(&self.outbox_url[..])
.header(ACCEPT, HeaderValue::from_str(&ap_accept_header().into_iter().collect::<Vec<_>>().join(", ")).unwrap()) .header(ACCEPT, HeaderValue::from_str(&ap_accept_header().into_iter().collect::<Vec<_>>().join(", ")).expect("User::fetch_outbox: accept header error"))
.send(); .send();
match req { match req {
Ok(mut res) => { Ok(mut res) => {
let text = &res.text().unwrap(); let text = &res.text().expect("User::fetch_outbox: body error");
let json: serde_json::Value = serde_json::from_str(text).unwrap(); let json: serde_json::Value = serde_json::from_str(text).expect("User::fetch_outbox: parsing error");
json["items"].as_array() json["items"].as_array()
.expect("Outbox.items is not an array") .expect("Outbox.items is not an array")
.into_iter() .into_iter()
@ -369,14 +371,14 @@ impl User {
pub fn fetch_followers_ids(&self) -> Vec<String> { pub fn fetch_followers_ids(&self) -> Vec<String> {
let req = Client::new() let req = Client::new()
.get(&self.followers_endpoint[..]) .get(&self.followers_endpoint[..])
.header(ACCEPT, HeaderValue::from_str(&ap_accept_header().into_iter().collect::<Vec<_>>().join(", ")).unwrap()) .header(ACCEPT, HeaderValue::from_str(&ap_accept_header().into_iter().collect::<Vec<_>>().join(", ")).expect("User::fetch_followers_ids: accept header error"))
.send(); .send();
match req { match req {
Ok(mut res) => { Ok(mut res) => {
let text = &res.text().unwrap(); let text = &res.text().expect("User::fetch_followers_ids: body error");
let json: serde_json::Value = serde_json::from_str(text).unwrap(); let json: serde_json::Value = serde_json::from_str(text).expect("User::fetch_followers_ids: parsing error");
json["items"].as_array() json["items"].as_array()
.expect("Followers.items is not an array") .expect("User::fetch_followers_ids: not an array error")
.into_iter() .into_iter()
.filter_map(|j| serde_json::from_value(j.clone()).ok()) .filter_map(|j| serde_json::from_value(j.clone()).ok())
.collect::<Vec<String>>() .collect::<Vec<String>>()
@ -395,9 +397,9 @@ impl User {
let posts = posts::table let posts = posts::table
.filter(posts::published.eq(true)) .filter(posts::published.eq(true))
.filter(posts::id.eq_any(posts_by_self)) .filter(posts::id.eq_any(posts_by_self))
.load::<Post>(conn).unwrap(); .load::<Post>(conn).expect("User::get_activities: loading error");
posts.into_iter().map(|p| { posts.into_iter().map(|p| {
serde_json::to_value(p.create_activity(conn)).unwrap() serde_json::to_value(p.create_activity(conn)).expect("User::get_activities: creation error")
}).collect::<Vec<serde_json::Value>>() }).collect::<Vec<serde_json::Value>>()
} }
@ -412,7 +414,7 @@ impl User {
pub fn get_followers(&self, conn: &Connection) -> Vec<User> { pub fn get_followers(&self, conn: &Connection) -> Vec<User> {
use schema::follows; use schema::follows;
let follows = Follow::belonging_to(self).select(follows::follower_id); let follows = Follow::belonging_to(self).select(follows::follower_id);
users::table.filter(users::id.eq_any(follows)).load::<User>(conn).unwrap() users::table.filter(users::id.eq_any(follows)).load::<User>(conn).expect("User::get_followers: loading error")
} }
pub fn get_followers_page(&self, conn: &Connection, (min, max): (i32, i32)) -> Vec<User> { pub fn get_followers_page(&self, conn: &Connection, (min, max): (i32, i32)) -> Vec<User> {
@ -421,13 +423,13 @@ impl User {
users::table.filter(users::id.eq_any(follows)) users::table.filter(users::id.eq_any(follows))
.offset(min.into()) .offset(min.into())
.limit((max - min).into()) .limit((max - min).into())
.load::<User>(conn).unwrap() .load::<User>(conn).expect("User::get_followers_page: loading error")
} }
pub fn get_following(&self, conn: &Connection) -> Vec<User> { pub fn get_following(&self, conn: &Connection) -> Vec<User> {
use schema::follows::dsl::*; use schema::follows::dsl::*;
let f = follows.filter(follower_id.eq(self.id)).select(following_id); let f = follows.filter(follower_id.eq(self.id)).select(following_id);
users::table.filter(users::id.eq_any(f)).load::<User>(conn).unwrap() users::table.filter(users::id.eq_any(f)).load::<User>(conn).expect("User::get_following: loading error")
} }
pub fn is_followed_by(&self, conn: &Connection, other_id: i32) -> bool { pub fn is_followed_by(&self, conn: &Connection, other_id: i32) -> bool {
@ -436,8 +438,8 @@ impl User {
.filter(follows::follower_id.eq(other_id)) .filter(follows::follower_id.eq(other_id))
.filter(follows::following_id.eq(self.id)) .filter(follows::following_id.eq(self.id))
.load::<Follow>(conn) .load::<Follow>(conn)
.expect("Couldn't load follow relationship") .expect("User::is_followed_by: loading error")
.len() > 0 .len() > 0// TODO count in database?
} }
pub fn is_following(&self, conn: &Connection, other_id: i32) -> bool { pub fn is_following(&self, conn: &Connection, other_id: i32) -> bool {
@ -446,8 +448,8 @@ impl User {
.filter(follows::follower_id.eq(self.id)) .filter(follows::follower_id.eq(self.id))
.filter(follows::following_id.eq(other_id)) .filter(follows::following_id.eq(other_id))
.load::<Follow>(conn) .load::<Follow>(conn)
.expect("Couldn't load follow relationship") .expect("User::is_following: loading error")
.len() > 0 .len() > 0// TODO count in database?
} }
pub fn has_liked(&self, conn: &Connection, post: &Post) -> bool { pub fn has_liked(&self, conn: &Connection, post: &Post) -> bool {
@ -456,8 +458,8 @@ impl User {
.filter(likes::post_id.eq(post.id)) .filter(likes::post_id.eq(post.id))
.filter(likes::user_id.eq(self.id)) .filter(likes::user_id.eq(self.id))
.load::<Like>(conn) .load::<Like>(conn)
.expect("Couldn't load likes") .expect("User::has_liked: loading error")
.len() > 0 .len() > 0// TODO count in database?
} }
pub fn has_reshared(&self, conn: &Connection, post: &Post) -> bool { pub fn has_reshared(&self, conn: &Connection, post: &Post) -> bool {
@ -466,8 +468,8 @@ impl User {
.filter(reshares::post_id.eq(post.id)) .filter(reshares::post_id.eq(post.id))
.filter(reshares::user_id.eq(self.id)) .filter(reshares::user_id.eq(self.id))
.load::<Reshare>(conn) .load::<Reshare>(conn)
.expect("Couldn't load reshares") .expect("User::has_reshared: loading error")
.len() > 0 .len() > 0// TODO count in database?
} }
pub fn is_author_in(&self, conn: &Connection, blog: Blog) -> bool { pub fn is_author_in(&self, conn: &Connection, blog: Blog) -> bool {
@ -475,12 +477,14 @@ impl User {
blog_authors::table.filter(blog_authors::author_id.eq(self.id)) blog_authors::table.filter(blog_authors::author_id.eq(self.id))
.filter(blog_authors::blog_id.eq(blog.id)) .filter(blog_authors::blog_id.eq(blog.id))
.load::<BlogAuthor>(conn) .load::<BlogAuthor>(conn)
.expect("Couldn't load blog/author relationship") .expect("User::is_author_in: loading error")
.len() > 0 .len() > 0// TODO count in database?
} }
pub fn get_keypair(&self) -> PKey<Private> { pub fn get_keypair(&self) -> PKey<Private> {
PKey::from_rsa(Rsa::private_key_from_pem(self.private_key.clone().unwrap().as_ref()).unwrap()).unwrap() PKey::from_rsa(Rsa::private_key_from_pem(self.private_key.clone().expect("User::get_keypair: private key not found error").as_ref())
.expect("User::get_keypair: pem parsing error"))
.expect("User::get_keypair: private key deserialization error")
} }
pub fn into_activity(&self, conn: &Connection) -> CustomPerson { pub fn into_activity(&self, conn: &Connection) -> CustomPerson {
@ -514,7 +518,7 @@ impl User {
} }
pub fn to_json(&self, conn: &Connection) -> serde_json::Value { pub fn to_json(&self, conn: &Connection) -> serde_json::Value {
let mut json = serde_json::to_value(self).unwrap(); let mut json = serde_json::to_value(self).expect("User::to_json: serializing error");
json["fqn"] = serde_json::Value::String(self.get_fqn(conn)); json["fqn"] = serde_json::Value::String(self.get_fqn(conn));
json["name"] = if self.display_name.len() > 0 { json["name"] = if self.display_name.len() > 0 {
json!(self.display_name) json!(self.display_name)
@ -556,7 +560,7 @@ impl User {
User::find_by_ap_url(conn, url.clone()).or_else(|| { User::find_by_ap_url(conn, url.clone()).or_else(|| {
// The requested user was not in the DB // The requested user was not in the DB
// We try to fetch it if it is remote // We try to fetch it if it is remote
if Url::parse(url.as_ref()).unwrap().host_str().unwrap() != BASE_URL.as_str() { if Url::parse(url.as_ref()).expect("User::from_url: url error").host_str().expect("User::from_url: host error") != BASE_URL.as_str() {
User::fetch_from_url(conn, url) User::fetch_from_url(conn, url)
} else { } else {
None None
@ -568,7 +572,7 @@ impl User {
diesel::update(self) diesel::update(self)
.set(users::avatar_id.eq(id)) .set(users::avatar_id.eq(id))
.execute(conn) .execute(conn)
.expect("Couldn't update user avatar"); .expect("User::set_avatar: update error");
} }
pub fn needs_update(&self) -> bool { pub fn needs_update(&self) -> bool {
@ -584,7 +588,7 @@ impl<'a, 'r> FromRequest<'a, 'r> for User {
request.cookies() request.cookies()
.get_private(AUTH_COOKIE) .get_private(AUTH_COOKIE)
.and_then(|cookie| cookie.value().parse().ok()) .and_then(|cookie| cookie.value().parse().ok())
.map(|id| User::get(&*conn, id).unwrap()) .map(|id| User::get(&*conn, id).expect("User::from_request: user not found error"))
.or_forward(()) .or_forward(())
} }
} }
@ -619,16 +623,17 @@ impl Signer for User {
fn sign(&self, to_sign: String) -> Vec<u8> { fn sign(&self, to_sign: String) -> Vec<u8> {
let key = self.get_keypair(); let key = self.get_keypair();
let mut signer = sign::Signer::new(MessageDigest::sha256(), &key).unwrap(); let mut signer = sign::Signer::new(MessageDigest::sha256(), &key).expect("User::sign: initialization error");
signer.update(to_sign.as_bytes()).unwrap(); signer.update(to_sign.as_bytes()).expect("User::sign: content insertion error");
signer.sign_to_vec().unwrap() signer.sign_to_vec().expect("User::sign: finalization error")
} }
fn verify(&self, data: String, signature: Vec<u8>) -> bool { fn verify(&self, data: String, signature: Vec<u8>) -> bool {
let key = PKey::from_rsa(Rsa::public_key_from_pem(self.public_key.as_ref()).unwrap()).unwrap(); let key = PKey::from_rsa(Rsa::public_key_from_pem(self.public_key.as_ref()).expect("User::verify: pem parsing error"))
let mut verifier = sign::Verifier::new(MessageDigest::sha256(), &key).unwrap(); .expect("User::verify: deserialization error");
verifier.update(data.as_bytes()).unwrap(); let mut verifier = sign::Verifier::new(MessageDigest::sha256(), &key).expect("User::verify: initialization error");
verifier.verify(&signature).unwrap() verifier.update(data.as_bytes()).expect("User::verify: content insertion error");
verifier.verify(&signature).expect("User::verify: finalization error")
} }
} }
@ -655,8 +660,8 @@ impl NewUser {
hashed_password: Some(password), hashed_password: Some(password),
instance_id: Instance::local_id(conn), instance_id: Instance::local_id(conn),
ap_url: String::from(""), ap_url: String::from(""),
public_key: String::from_utf8(pub_key).unwrap(), public_key: String::from_utf8(pub_key).expect("NewUser::new_local: public key error"),
private_key: Some(String::from_utf8(priv_key).unwrap()), private_key: Some(String::from_utf8(priv_key).expect("NewUser::new_local: private key error")),
shared_inbox_url: None, shared_inbox_url: None,
followers_endpoint: String::from(""), followers_endpoint: String::from(""),
avatar_id: None avatar_id: None