jmug/stoatchat
1
0
Fork 1
mirror of https://github.com/stoatchat/stoatchat.git synced 2026-07-14 13:36:59 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add serialisation, ready payload and GET guilds.

Browse Source
This commit is contained in:
Paul Makles
2020-08-12 15:40:56 +02:00
parent 74b4238f04
commit d06017e712
7 changed files with 314 additions and 125 deletions
Download Patch File Download Diff File Expand all files Collapse all files

41
src/database/channel.rs
View File

@@ -4,6 +4,7 @@ use lru::LruCache;
use mongodb::bson::{doc, from_bson, Bson};
use rocket::http::RawStr;
use rocket::request::FromParam;
use rocket_contrib::json::JsonValue;
use serde::{Deserialize, Serialize};
use std::sync::{Arc, Mutex};
@@ -40,6 +41,40 @@ pub struct Channel {
pub description: Option<String>,
}
impl Channel {
pub fn serialise(self) -> JsonValue {
match self.channel_type {
0 => json!({
"id": self.id,
"type": self.channel_type,
"last_message": self.last_message,
"recipients": self.recipients,
}),
1 => {
json!({
"id": self.id,
"type": self.channel_type,
"last_message": self.last_message,
"recipients": self.recipients,
"name": self.name,
"owner": self.owner,
"description": self.description,
})
}
2 => {
json!({
"id": self.id,
"type": self.channel_type,
"guild": self.guild,
"name": self.name,
"description": self.description,
})
}
_ => unreachable!(),
}
}
}
lazy_static! {
static ref CACHE: Arc<Mutex<LruCache<String, Channel>>> =
Arc::new(Mutex::new(LruCache::new(4_000_000)));
@@ -83,13 +118,13 @@ pub fn fetch_channels(ids: &Vec<String>) -> Result<Vec<Channel>, String> {
{
if let Ok(mut cache) = CACHE.lock() {
for gid in ids {
let existing = cache.get(gid);
for id in ids {
let existing = cache.get(id);
if let Some(channel) = existing {
channels.push((*channel).clone());
} else {
missing.push(gid);
missing.push(id);
}
}
} else {

73
src/database/guild.rs
View File

@@ -4,6 +4,7 @@ use lru::LruCache;
use mongodb::bson::{doc, from_bson, Bson};
use rocket::http::RawStr;
use rocket::request::FromParam;
use rocket_contrib::json::JsonValue;
use serde::{Deserialize, Serialize};
use std::sync::{Arc, Mutex};
@@ -49,6 +50,32 @@ pub struct Guild {
pub default_permissions: u32,
}
impl Guild {
pub fn serialise(self) -> JsonValue {
json!({
"id": self.id,
"name": self.name,
"description": self.description,
"owner": self.owner
})
}
pub fn fetch_channels(&self) -> Result<Vec<super::channel::Channel>, String> {
super::channel::fetch_channels(&self.channels)
}
pub fn seralise_with_channels(self) -> Result<JsonValue, String> {
let channels = self.fetch_channels()?
.into_iter()
.map(|x| x.serialise())
.collect();
let mut value = self.serialise();
value.as_object_mut().unwrap().insert("channels".to_string(), channels);
Ok(value)
}
}
#[derive(Hash, Eq, PartialEq)]
pub struct MemberKey(pub String, pub String);
@@ -91,6 +118,52 @@ pub fn fetch_guild(id: &str) -> Result<Option<Guild>, String> {
}
}
pub fn fetch_guilds(ids: &Vec<String>) -> Result<Vec<Guild>, String> {
let mut missing = vec![];
let mut guilds = vec![];
{
if let Ok(mut cache) = CACHE.lock() {
for id in ids {
let existing = cache.get(id);
if let Some(guild) = existing {
guilds.push((*guild).clone());
} else {
missing.push(id);
}
}
} else {
return Err("Failed to lock cache.".to_string());
}
}
if missing.len() == 0 {
return Ok(guilds);
}
let col = get_collection("guilds");
if let Ok(result) = col.find(doc! { "_id": { "$in": missing } }, None) {
for item in result {
let mut cache = CACHE.lock().unwrap();
if let Ok(doc) = item {
if let Ok(guild) = from_bson(Bson::Document(doc)) as Result<Guild, _> {
cache.put(guild.id.clone(), guild.clone());
guilds.push(guild);
} else {
return Err("Failed to deserialize guild!".to_string());
}
} else {
return Err("Failed to fetch guild.".to_string());
}
}
Ok(guilds)
} else {
Err("Failed to fetch channel from database.".to_string())
}
}
pub fn fetch_member(key: MemberKey) -> Result<Option<Member>, String> {
{
if let Ok(mut cache) = MEMBER_CACHE.lock() {

160
src/database/user.rs
View File

@@ -1,9 +1,13 @@
use super::get_collection;
use super::guild::{Guild, fetch_guilds};
use super::channel::{Channel, fetch_channels};
use lru::LruCache;
use mongodb::bson::{doc, from_bson, Bson, DateTime};
use mongodb::options::FindOptions;
use rocket::http::{RawStr, Status};
use rocket::request::{self, FromParam, FromRequest, Request};
use rocket_contrib::json::JsonValue;
use rocket::Outcome;
use std::sync::{Arc, Mutex};
use serde::{Deserialize, Serialize};
@@ -36,6 +40,116 @@ pub struct User {
pub relations: Option<Vec<UserRelationship>>,
}
impl User {
pub fn serialise(self, relationship: i32) -> JsonValue {
if relationship == super::Relationship::SELF as i32 {
json!({
"id": self.id,
"username": self.username,
"display_name": self.display_name,
"email": self.email,
"verified": self.email_verification.verified,
})
} else {
json!({
"id": self.id,
"username": self.username,
"display_name": self.display_name,
"relationship": relationship
})
}
}
pub fn find_guilds(&self) -> Result<Vec<String>, String> {
let members = get_collection("members")
.find(
doc! {
"_id.user": &self.id
},
None
).map_err(|_| "Failed to fetch members.")?;
Ok(members.into_iter()
.filter_map(|x| match x {
Ok(doc) => {
match doc.get_document("_id") {
Ok(id) => {
match id.get_str("guild") {
Ok(value) => Some(value.to_string()),
Err(_) => None
}
}
Err(_) => None
}
}
Err(_) => None
})
.collect())
}
pub fn find_dms(&self) -> Result<Vec<String>, String> {
let channels = get_collection("channels")
.find(
doc! {
"recipients": &self.id
},
FindOptions::builder()
.projection(doc! { "_id": 1 })
.build()
).map_err(|_| "Failed to fetch channel ids.")?;
Ok(channels.into_iter()
.filter_map(|x| x.ok())
.filter_map(|x| {
match x.get_str("_id") {
Ok(value) => Some(value.to_string()),
Err(_) => None
}
})
.collect())
}
pub fn create_payload(self) -> Result<JsonValue, String> {
let v = vec![];
let relations = self.relations.as_ref().unwrap_or(&v);
let users: Vec<JsonValue> = fetch_users(
&relations
.iter()
.map(|x| x.id.clone())
.collect()
)?
.into_iter()
.map(|x| {
let id = x.id.clone();
x.serialise(
relations.iter()
.find(|y| y.id == id)
.unwrap()
.status as i32
)
})
.collect();
let channels: Vec<JsonValue> = fetch_channels(&self.find_dms()?)?
.into_iter()
.map(|x| x.serialise())
.collect();
let guilds: Vec<JsonValue> = fetch_guilds(&self.find_guilds()?)?
.into_iter()
.map(|x| x.serialise())
.collect();
Ok(json!({
"users": users,
"channels": channels,
"guilds": guilds,
"user": self.serialise(super::Relationship::SELF as i32)
}))
}
}
lazy_static! {
static ref CACHE: Arc<Mutex<LruCache<String, User>>> =
Arc::new(Mutex::new(LruCache::new(4_000_000)));
@@ -73,6 +187,52 @@ pub fn fetch_user(id: &str) -> Result<Option<User>, String> {
}
}
pub fn fetch_users(ids: &Vec<String>) -> Result<Vec<User>, String> {
let mut missing = vec![];
let mut users = vec![];
{
if let Ok(mut cache) = CACHE.lock() {
for id in ids {
let existing = cache.get(id);
if let Some(user) = existing {
users.push((*user).clone());
} else {
missing.push(id);
}
}
} else {
return Err("Failed to lock cache.".to_string());
}
}
if missing.len() == 0 {
return Ok(users);
}
let col = get_collection("users");
if let Ok(result) = col.find(doc! { "_id": { "$in": missing } }, None) {
for item in result {
let mut cache = CACHE.lock().unwrap();
if let Ok(doc) = item {
if let Ok(user) = from_bson(Bson::Document(doc)) as Result<User, _> {
cache.put(user.id.clone(), user.clone());
users.push(user);
} else {
return Err("Failed to deserialize user!".to_string());
}
} else {
return Err("Failed to fetch user.".to_string());
}
}
Ok(users)
} else {
Err("Failed to fetch user from database.".to_string())
}
}
#[derive(Debug)]
pub enum AuthError {
Failed,

7
src/notifications/ws.rs
View File

@@ -37,6 +37,7 @@ impl Handler for Server {
match state.try_authenticate(self.id.clone(), token.to_string()) {
StateResult::Success(user_id) => {
let user = crate::database::user::fetch_user(&user_id).unwrap().unwrap();
self.user_id = Some(user_id);
self.sender.send(
json!({
@@ -46,14 +47,10 @@ impl Handler for Server {
.to_string(),
)?;
self.user_id = Some(user_id);
self.sender.send(
json!({
"type": "ready",
"data": {
// ! FIXME: rewrite
"user": user,
}
"data": user.create_payload()
})
.to_string(),
)

31
src/routes/channel.rs
View File

@@ -129,36 +129,7 @@ pub fn create_group(user: User, info: Json<CreateGroup>) -> Response {
#[get("/<target>")]
pub fn channel(user: User, target: Channel) -> Option<Response> {
with_permissions!(user, target);
match target.channel_type {
0 => Some(Response::Success(json!({
"id": target.id,
"type": target.channel_type,
"last_message": target.last_message,
"recipients": target.recipients,
}))),
1 => {
Some(Response::Success(json!({
"id": target.id,
"type": target.channel_type,
"last_message": target.last_message,
"recipients": target.recipients,
"name": target.name,
"owner": target.owner,
"description": target.description,
})))
}
2 => {
Some(Response::Success(json!({
"id": target.id,
"type": target.channel_type,
"guild": target.guild,
"name": target.name,
"description": target.description,
})))
}
_ => unreachable!(),
}
Some(Response::Success(target.serialise()))
}
/// [groups] add user to channel

102
src/routes/guild.rs
View File

@@ -2,7 +2,7 @@ use super::channel::ChannelType;
use super::Response;
use crate::database::guild::{fetch_member as get_member, get_invite, Guild, MemberKey};
use crate::database::{
self, channel::{fetch_channel, fetch_channels}, channel::Channel, Permission, PermissionCalculator, user::User
self, channel::fetch_channel, guild::fetch_guilds, channel::Channel, Permission, PermissionCalculator, user::User
};
use crate::notifications::{
self,
@@ -17,6 +17,7 @@ use rocket_contrib::json::Json;
use serde::{Deserialize, Serialize};
use ulid::Ulid;
// ! FIXME: GET RID OF THIS
macro_rules! with_permissions {
($user: expr, $target: expr) => {{
let permissions = PermissionCalculator::new($user.clone())
@@ -35,53 +36,34 @@ macro_rules! with_permissions {
/// fetch your guilds
#[get("/@me")]
pub fn my_guilds(user: User) -> Response {
if let Ok(result) = database::get_collection("members").find(
doc! {
"_id.user": &user.id
},
None,
) {
let mut guilds = vec![];
for item in result {
if let Ok(entry) = item {
guilds.push(Bson::String(
entry
.get_document("_id")
.unwrap()
.get_str("guild")
.unwrap()
.to_string(),
));
}
}
if let Ok(gids) = user.find_guilds() {
if let Ok(guilds) = fetch_guilds(&gids) {
let cids: Vec<String> = guilds
.iter()
.flat_map(|x| x.channels.clone())
.collect();
if let Ok(result) = database::get_collection("guilds").find(
doc! {
"_id": {
"$in": guilds
}
},
FindOptions::builder()
.projection(doc! {
"_id": 1,
"name": 1,
"description": 1,
"owner": 1,
})
.build(),
) {
let mut parsed = vec![];
for item in result {
let doc = item.unwrap();
parsed.push(json!({
"id": doc.get_str("_id").unwrap(),
"name": doc.get_str("name").unwrap(),
"description": doc.get_str("description").unwrap(),
"owner": doc.get_str("owner").unwrap(),
}));
if let Ok(channels) = database::channel::fetch_channels(&cids) {
let data: Vec<rocket_contrib::json::JsonValue> = guilds
.into_iter()
.map(|x| {
let id = x.id.clone();
let mut obj = x.serialise();
obj.as_object_mut().unwrap().insert(
"channels".to_string(),
channels.iter()
.filter(|x| x.guild.is_some() && x.guild.as_ref().unwrap() == &id)
.map(|x| x.clone().serialise())
.collect()
);
obj
})
.collect();
Response::Success(json!(data))
} else {
Response::InternalServerError(json!({ "error": "Failed to fetch channels." }))
}
Response::Success(json!(parsed))
} else {
Response::InternalServerError(json!({ "error": "Failed to fetch guilds." }))
}
@@ -94,29 +76,11 @@ pub fn my_guilds(user: User) -> Response {
#[get("/<target>")]
pub fn guild(user: User, target: Guild) -> Option<Response> {
with_permissions!(user, target);
match fetch_channels(&target.channels) {
Ok(results) => {
let mut channels = vec![];
for item in results {
channels.push(json!({
"id": item.id,
"name": item.name,
"description": item.description,
}));
}
Some(Response::Success(json!({
"id": target.id,
"name": target.name,
"description": target.description,
"owner": target.owner,
"channels": channels,
})))
}
Err(_) => Some(Response::InternalServerError(
json!({ "error": "Failed to fetch channels." }),
))
if let Ok(result) = target.seralise_with_channels() {
Some(Response::Success(result))
} else {
Some(Response::InternalServerError(json!({ "error": "Failed to fetch channels!" })))
}
}

25
src/routes/user.rs
View File

@@ -15,29 +15,18 @@ use ulid::Ulid;
/// retrieve your user information
#[get("/@me")]
pub fn me(user: User) -> Response {
Response::Success(json!({
"id": user.id,
"username": user.username,
"display_name": user.display_name,
"email": user.email,
"verified": user.email_verification.verified,
}))
Response::Success(
user.serialise(Relationship::SELF as i32)
)
}
/// retrieve another user's information
#[get("/<target>")]
pub fn user(user: User, target: User) -> Response {
Response::Success(json!({
"id": target.id,
"username": target.username,
"display_name": target.display_name,
"relationship": get_relationship(&user, &target) as i32,
"mutual": {
"guilds": mutual::find_mutual_guilds(&user.id, &target.id),
"friends": mutual::find_mutual_friends(&user.id, &target.id),
"groups": mutual::find_mutual_groups(&user.id, &target.id),
}
}))
let relationship = get_relationship(&user, &target) as i32;
Response::Success(
user.serialise(relationship)
)
}
#[derive(Serialize, Deserialize)]