154 lines
4.0 KiB
Rust
154 lines
4.0 KiB
Rust
use bson::{doc, from_bson, Bson, Document};
|
|
use mongodb::options::FindOneOptions;
|
|
use rocket::http::RawStr;
|
|
use rocket::request::FromParam;
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
use crate::database;
|
|
use crate::database::guild::{Ban, Invite, Member};
|
|
|
|
#[derive(Serialize, Deserialize, Debug, Clone)]
|
|
pub struct GuildRef {
|
|
#[serde(rename = "_id")]
|
|
pub id: String,
|
|
pub name: String,
|
|
pub description: String,
|
|
pub owner: String,
|
|
|
|
pub bans: Vec<Ban>,
|
|
|
|
pub default_permissions: i32,
|
|
}
|
|
|
|
impl GuildRef {
|
|
pub fn from(id: String) -> Option<GuildRef> {
|
|
match database::get_collection("guilds").find_one(
|
|
doc! { "_id": id },
|
|
FindOneOptions::builder()
|
|
.projection(doc! {
|
|
"name": 1,
|
|
"description": 1,
|
|
"owner": 1,
|
|
"bans": 1,
|
|
"default_permissions": 1
|
|
})
|
|
.build(),
|
|
) {
|
|
Ok(result) => match result {
|
|
Some(doc) => {
|
|
Some(from_bson(bson::Bson::Document(doc)).expect("Failed to unwrap guild."))
|
|
}
|
|
None => None,
|
|
},
|
|
Err(_) => None,
|
|
}
|
|
}
|
|
|
|
pub fn fetch_data(&self, projection: Document) -> Option<Document> {
|
|
database::get_collection("guilds")
|
|
.find_one(
|
|
doc! { "_id": &self.id },
|
|
FindOneOptions::builder().projection(projection).build(),
|
|
)
|
|
.expect("Failed to fetch guild from database.")
|
|
}
|
|
|
|
pub fn fetch_data_given(&self, mut filter: Document, projection: Document) -> Option<Document> {
|
|
filter.insert("_id", self.id.clone());
|
|
database::get_collection("guilds")
|
|
.find_one(
|
|
filter,
|
|
FindOneOptions::builder().projection(projection).build(),
|
|
)
|
|
.expect("Failed to fetch guild from database.")
|
|
}
|
|
}
|
|
|
|
impl<'r> FromParam<'r> for GuildRef {
|
|
type Error = &'r RawStr;
|
|
|
|
fn from_param(param: &'r RawStr) -> Result<Self, Self::Error> {
|
|
if let Some(guild) = GuildRef::from(param.to_string()) {
|
|
Ok(guild)
|
|
} else {
|
|
Err(param)
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn get_member(guild_id: &String, member: &String) -> Option<Member> {
|
|
if let Ok(result) = database::get_collection("members").find_one(
|
|
doc! {
|
|
"_id.guild": &guild_id,
|
|
"_id.user": &member,
|
|
},
|
|
None,
|
|
) {
|
|
if let Some(doc) = result {
|
|
Some(from_bson(Bson::Document(doc)).expect("Failed to unwrap member."))
|
|
} else {
|
|
None
|
|
}
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
pub fn get_invite<U: Into<Option<String>>>(
|
|
code: &String,
|
|
user: U,
|
|
) -> Option<(String, String, Invite)> {
|
|
let mut doc = doc! {
|
|
"invites": {
|
|
"$elemMatch": {
|
|
"code": &code
|
|
}
|
|
}
|
|
};
|
|
|
|
if let Some(user_id) = user.into() {
|
|
doc.insert(
|
|
"bans",
|
|
doc! {
|
|
"$not": {
|
|
"$elemMatch": {
|
|
"id": user_id
|
|
}
|
|
}
|
|
},
|
|
);
|
|
}
|
|
|
|
if let Ok(result) = database::get_collection("guilds").find_one(
|
|
doc,
|
|
FindOneOptions::builder()
|
|
.projection(doc! {
|
|
"_id": 1,
|
|
"name": 1,
|
|
"invites.$": 1,
|
|
})
|
|
.build(),
|
|
) {
|
|
if let Some(doc) = result {
|
|
let invite = doc
|
|
.get_array("invites")
|
|
.unwrap()
|
|
.iter()
|
|
.next()
|
|
.unwrap()
|
|
.as_document()
|
|
.unwrap();
|
|
|
|
Some((
|
|
doc.get_str("_id").unwrap().to_string(),
|
|
doc.get_str("name").unwrap().to_string(),
|
|
from_bson(Bson::Document(invite.clone())).unwrap(),
|
|
))
|
|
} else {
|
|
None
|
|
}
|
|
} else {
|
|
None
|
|
}
|
|
}
|