1078 lines
33 KiB
Rust
1078 lines
33 KiB
Rust
use std::mem;
|
|
use std::str::FromStr;
|
|
|
|
use async_trait::async_trait;
|
|
use cookie::{Cookie, CookieJar};
|
|
use euphoxide::api::{Message, SessionView, Snowflake, Time, UserId};
|
|
use rusqlite::types::{FromSql, FromSqlError, ToSqlOutput, Value, ValueRef};
|
|
use rusqlite::{named_params, params, Connection, OptionalExtension, ToSql, Transaction};
|
|
use time::OffsetDateTime;
|
|
use tokio::sync::oneshot;
|
|
|
|
use crate::euph::SmallMessage;
|
|
use crate::store::{MsgStore, Path, Tree};
|
|
|
|
/// Wrapper for [`Snowflake`] that implements useful rusqlite traits.
|
|
struct WSnowflake(Snowflake);
|
|
|
|
impl ToSql for WSnowflake {
|
|
fn to_sql(&self) -> rusqlite::Result<ToSqlOutput<'_>> {
|
|
self.0 .0.to_sql()
|
|
}
|
|
}
|
|
|
|
impl FromSql for WSnowflake {
|
|
fn column_result(value: ValueRef<'_>) -> Result<Self, FromSqlError> {
|
|
u64::column_result(value).map(|v| Self(Snowflake(v)))
|
|
}
|
|
}
|
|
|
|
/// Wrapper for [`Time`] that implements useful rusqlite traits.
|
|
struct WTime(Time);
|
|
|
|
impl ToSql for WTime {
|
|
fn to_sql(&self) -> rusqlite::Result<ToSqlOutput<'_>> {
|
|
let timestamp = self.0 .0.unix_timestamp();
|
|
Ok(ToSqlOutput::Owned(Value::Integer(timestamp)))
|
|
}
|
|
}
|
|
|
|
impl FromSql for WTime {
|
|
fn column_result(value: ValueRef<'_>) -> rusqlite::types::FromSqlResult<Self> {
|
|
let timestamp = i64::column_result(value)?;
|
|
Ok(Self(Time(
|
|
OffsetDateTime::from_unix_timestamp(timestamp).expect("timestamp in range"),
|
|
)))
|
|
}
|
|
}
|
|
|
|
impl From<EuphRequest> for super::Request {
|
|
fn from(r: EuphRequest) -> Self {
|
|
Self::Euph(r)
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct EuphVault {
|
|
pub(super) vault: super::Vault,
|
|
pub(super) room: String,
|
|
}
|
|
|
|
impl EuphVault {
|
|
pub fn vault(&self) -> &super::Vault {
|
|
&self.vault
|
|
}
|
|
|
|
pub fn room(&self) -> &str {
|
|
&self.room
|
|
}
|
|
|
|
pub fn join(&self, time: Time) {
|
|
self.vault.euph_join(self.room.clone(), time);
|
|
}
|
|
|
|
pub fn delete(self) {
|
|
self.vault.euph_delete(self.room.clone());
|
|
}
|
|
|
|
pub fn add_message(
|
|
&self,
|
|
msg: Message,
|
|
prev_msg_id: Option<Snowflake>,
|
|
own_user_id: Option<UserId>,
|
|
) {
|
|
self.vault
|
|
.euph_add_msg(self.room.clone(), Box::new(msg), prev_msg_id, own_user_id);
|
|
}
|
|
|
|
pub fn add_messages(
|
|
&self,
|
|
msgs: Vec<Message>,
|
|
next_msg_id: Option<Snowflake>,
|
|
own_user_id: Option<UserId>,
|
|
) {
|
|
self.vault
|
|
.euph_add_msgs(self.room.clone(), msgs, next_msg_id, own_user_id);
|
|
}
|
|
|
|
pub async fn last_span(&self) -> Option<(Option<Snowflake>, Option<Snowflake>)> {
|
|
self.vault.euph_last_span(self.room.clone()).await
|
|
}
|
|
|
|
pub async fn full_msg(&self, id: Snowflake) -> Option<Message> {
|
|
self.vault.euph_full_msg(self.room.clone(), id).await
|
|
}
|
|
|
|
pub async fn chunk_at_offset(&self, amount: usize, offset: usize) -> Vec<Message> {
|
|
self.vault
|
|
.euph_chunk_at_offset(self.room.clone(), amount, offset)
|
|
.await
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl MsgStore<SmallMessage> for EuphVault {
|
|
async fn path(&self, id: &Snowflake) -> Path<Snowflake> {
|
|
self.vault.euph_path(self.room.clone(), *id).await
|
|
}
|
|
|
|
async fn msg(&self, id: &Snowflake) -> Option<SmallMessage> {
|
|
self.vault.euph_msg(self.room.clone(), *id).await
|
|
}
|
|
|
|
async fn tree(&self, tree_id: &Snowflake) -> Tree<SmallMessage> {
|
|
self.vault.euph_tree(self.room.clone(), *tree_id).await
|
|
}
|
|
|
|
async fn first_tree_id(&self) -> Option<Snowflake> {
|
|
self.vault.euph_first_tree_id(self.room.clone()).await
|
|
}
|
|
|
|
async fn last_tree_id(&self) -> Option<Snowflake> {
|
|
self.vault.euph_last_tree_id(self.room.clone()).await
|
|
}
|
|
|
|
async fn prev_tree_id(&self, tree_id: &Snowflake) -> Option<Snowflake> {
|
|
self.vault
|
|
.euph_prev_tree_id(self.room.clone(), *tree_id)
|
|
.await
|
|
}
|
|
|
|
async fn next_tree_id(&self, tree_id: &Snowflake) -> Option<Snowflake> {
|
|
self.vault
|
|
.euph_next_tree_id(self.room.clone(), *tree_id)
|
|
.await
|
|
}
|
|
|
|
async fn oldest_msg_id(&self) -> Option<Snowflake> {
|
|
self.vault.euph_oldest_msg_id(self.room.clone()).await
|
|
}
|
|
|
|
async fn newest_msg_id(&self) -> Option<Snowflake> {
|
|
self.vault.euph_newest_msg_id(self.room.clone()).await
|
|
}
|
|
|
|
async fn older_msg_id(&self, id: &Snowflake) -> Option<Snowflake> {
|
|
self.vault.euph_older_msg_id(self.room.clone(), *id).await
|
|
}
|
|
|
|
async fn newer_msg_id(&self, id: &Snowflake) -> Option<Snowflake> {
|
|
self.vault.euph_newer_msg_id(self.room.clone(), *id).await
|
|
}
|
|
|
|
async fn oldest_unseen_msg_id(&self) -> Option<Snowflake> {
|
|
self.vault
|
|
.euph_oldest_unseen_msg_id(self.room.clone())
|
|
.await
|
|
}
|
|
|
|
async fn newest_unseen_msg_id(&self) -> Option<Snowflake> {
|
|
self.vault
|
|
.euph_newest_unseen_msg_id(self.room.clone())
|
|
.await
|
|
}
|
|
|
|
async fn older_unseen_msg_id(&self, id: &Snowflake) -> Option<Snowflake> {
|
|
self.vault
|
|
.euph_older_unseen_msg_id(self.room.clone(), *id)
|
|
.await
|
|
}
|
|
|
|
async fn newer_unseen_msg_id(&self, id: &Snowflake) -> Option<Snowflake> {
|
|
self.vault
|
|
.euph_newer_unseen_msg_id(self.room.clone(), *id)
|
|
.await
|
|
}
|
|
|
|
async fn unseen_msgs_count(&self) -> usize {
|
|
self.vault.euph_unseen_msgs_count(self.room.clone()).await
|
|
}
|
|
|
|
async fn set_seen(&self, id: &Snowflake, seen: bool) {
|
|
self.vault.euph_set_seen(self.room.clone(), *id, seen);
|
|
}
|
|
|
|
async fn set_older_seen(&self, id: &Snowflake, seen: bool) {
|
|
self.vault.euph_set_older_seen(self.room.clone(), *id, seen);
|
|
}
|
|
}
|
|
|
|
trait Request {
|
|
fn perform(self, conn: &mut Connection) -> rusqlite::Result<()>;
|
|
}
|
|
|
|
macro_rules! requests_helper {
|
|
( $var:ident : $fn:ident( $( $arg:ident : $ty:ty ),* ) ) => {
|
|
pub fn $fn(&self, $( $arg: $ty ),* ) {
|
|
let request = EuphRequest::$var($var { $( $arg, )* });
|
|
let _ = self.tx.send(request.into());
|
|
}
|
|
};
|
|
( $var:ident : $fn:ident( $( $arg:ident : $ty:ty ),* ) -> $res:ty ) => {
|
|
pub async fn $fn(&self, $( $arg: $ty ),* ) -> $res {
|
|
let (tx, rx) = oneshot::channel();
|
|
let request = EuphRequest::$var($var {
|
|
$( $arg, )*
|
|
result: tx,
|
|
});
|
|
let _ = self.tx.send(request.into());
|
|
rx.await.unwrap()
|
|
}
|
|
};
|
|
}
|
|
|
|
macro_rules! requests {
|
|
( $(
|
|
$var:ident : $fn:ident( $( $arg:ident : $ty:ty ),* ) $( -> $res:ty )? ;
|
|
)* ) => {
|
|
$(
|
|
pub(super) struct $var {
|
|
$( $arg: $ty, )*
|
|
$( result: oneshot::Sender<$res>, )?
|
|
}
|
|
)*
|
|
|
|
pub(super) enum EuphRequest {
|
|
$( $var($var), )*
|
|
}
|
|
|
|
impl EuphRequest {
|
|
pub(super) fn perform(self, conn: &mut Connection) {
|
|
// TODO Handle this result
|
|
let _ = match self {
|
|
$( Self::$var(request) => request.perform(conn), )*
|
|
};
|
|
}
|
|
}
|
|
|
|
impl super::Vault {
|
|
$( requests_helper!($var : $fn( $( $arg: $ty ),* ) $( -> $res )? );)*
|
|
}
|
|
};
|
|
}
|
|
|
|
requests! {
|
|
// Cookies
|
|
GetCookies : euph_cookies() -> CookieJar;
|
|
SetCookies : euph_set_cookies(cookies: CookieJar);
|
|
|
|
// Rooms
|
|
GetRooms : euph_rooms() -> Vec<String>;
|
|
Join : euph_join(room: String, time: Time);
|
|
Delete : euph_delete(room: String);
|
|
|
|
// Message
|
|
AddMsg : euph_add_msg(room: String, msg: Box<Message>, prev_msg_id: Option<Snowflake>, own_user_id: Option<UserId>);
|
|
AddMsgs : euph_add_msgs(room: String, msgs: Vec<Message>, next_msg_id: Option<Snowflake>, own_user_id: Option<UserId>);
|
|
GetLastSpan : euph_last_span(room: String) -> Option<(Option<Snowflake>, Option<Snowflake>)>;
|
|
GetPath : euph_path(room: String, id: Snowflake) -> Path<Snowflake>;
|
|
GetMsg : euph_msg(room: String, id: Snowflake) -> Option<SmallMessage>;
|
|
GetFullMsg : euph_full_msg(room: String, id: Snowflake) -> Option<Message>;
|
|
GetTree : euph_tree(room: String, root: Snowflake) -> Tree<SmallMessage>;
|
|
GetFirstTreeId : euph_first_tree_id(room: String) -> Option<Snowflake>;
|
|
GetLastTreeId : euph_last_tree_id(room: String) -> Option<Snowflake>;
|
|
GetPrevTreeId : euph_prev_tree_id(room: String, root: Snowflake) -> Option<Snowflake>;
|
|
GetNextTreeId : euph_next_tree_id(room: String, root: Snowflake) -> Option<Snowflake>;
|
|
GetOldestMsgId : euph_oldest_msg_id(room: String) -> Option<Snowflake>;
|
|
GetNewestMsgId : euph_newest_msg_id(room: String) -> Option<Snowflake>;
|
|
GetOlderMsgId : euph_older_msg_id(room: String, id: Snowflake) -> Option<Snowflake>;
|
|
GetNewerMsgId : euph_newer_msg_id(room: String, id: Snowflake) -> Option<Snowflake>;
|
|
GetOldestUnseenMsgId : euph_oldest_unseen_msg_id(room: String) -> Option<Snowflake>;
|
|
GetNewestUnseenMsgId : euph_newest_unseen_msg_id(room: String) -> Option<Snowflake>;
|
|
GetOlderUnseenMsgId : euph_older_unseen_msg_id(room: String, id: Snowflake) -> Option<Snowflake>;
|
|
GetNewerUnseenMsgId : euph_newer_unseen_msg_id(room: String, id: Snowflake) -> Option<Snowflake>;
|
|
GetUnseenMsgsCount : euph_unseen_msgs_count(room: String) -> usize;
|
|
SetSeen : euph_set_seen(room: String, id: Snowflake, seen: bool);
|
|
SetOlderSeen : euph_set_older_seen(room: String, id: Snowflake, seen: bool);
|
|
GetChunkAtOffset : euph_chunk_at_offset(room: String, amount: usize, offset: usize) -> Vec<Message>;
|
|
}
|
|
|
|
impl Request for GetCookies {
|
|
fn perform(self, conn: &mut Connection) -> rusqlite::Result<()> {
|
|
let cookies = conn
|
|
.prepare(
|
|
"
|
|
SELECT cookie
|
|
FROM euph_cookies
|
|
",
|
|
)?
|
|
.query_map([], |row| {
|
|
let cookie_str: String = row.get(0)?;
|
|
Ok(Cookie::from_str(&cookie_str).expect("cookie in db is valid"))
|
|
})?
|
|
.collect::<rusqlite::Result<Vec<_>>>()?;
|
|
|
|
let mut cookie_jar = CookieJar::new();
|
|
for cookie in cookies {
|
|
cookie_jar.add_original(cookie);
|
|
}
|
|
|
|
let _ = self.result.send(cookie_jar);
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl Request for SetCookies {
|
|
fn perform(self, conn: &mut Connection) -> rusqlite::Result<()> {
|
|
let tx = conn.transaction()?;
|
|
|
|
// Since euphoria sets all cookies on every response, we can just delete
|
|
// all previous cookies.
|
|
tx.execute_batch("DELETE FROM euph_cookies")?;
|
|
|
|
let mut insert_cookie = tx.prepare(
|
|
"
|
|
INSERT INTO euph_cookies (cookie)
|
|
VALUES (?)
|
|
",
|
|
)?;
|
|
for cookie in self.cookies.iter() {
|
|
insert_cookie.execute([format!("{cookie}")])?;
|
|
}
|
|
drop(insert_cookie);
|
|
|
|
tx.commit()?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl Request for GetRooms {
|
|
fn perform(self, conn: &mut Connection) -> rusqlite::Result<()> {
|
|
let rooms = conn
|
|
.prepare(
|
|
"
|
|
SELECT room
|
|
FROM euph_rooms
|
|
",
|
|
)?
|
|
.query_map([], |row| row.get(0))?
|
|
.collect::<rusqlite::Result<_>>()?;
|
|
let _ = self.result.send(rooms);
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl Request for Join {
|
|
fn perform(self, conn: &mut Connection) -> rusqlite::Result<()> {
|
|
conn.execute(
|
|
"
|
|
INSERT INTO euph_rooms (room, first_joined, last_joined)
|
|
VALUES (:room, :time, :time)
|
|
ON CONFLICT (room) DO UPDATE
|
|
SET last_joined = :time
|
|
",
|
|
named_params! {":room": self.room, ":time": WTime(self.time)},
|
|
)?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl Request for Delete {
|
|
fn perform(self, conn: &mut Connection) -> rusqlite::Result<()> {
|
|
// TODO Clean up
|
|
let tx = conn.transaction()?;
|
|
|
|
tx.execute(
|
|
"
|
|
DELETE FROM euph_rooms
|
|
WHERE room = ?
|
|
",
|
|
[&self.room],
|
|
)?;
|
|
|
|
tx.commit()?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
fn insert_msgs(
|
|
tx: &Transaction<'_>,
|
|
room: &str,
|
|
own_user_id: &Option<UserId>,
|
|
msgs: Vec<Message>,
|
|
) -> rusqlite::Result<()> {
|
|
let mut insert_msg = tx.prepare(
|
|
"
|
|
INSERT INTO euph_msgs (
|
|
room, id, parent, previous_edit_id, time, content, encryption_key_id, edited, deleted, truncated,
|
|
user_id, name, server_id, server_era, session_id, is_staff, is_manager, client_address, real_client_address,
|
|
seen
|
|
)
|
|
VALUES (
|
|
:room, :id, :parent, :previous_edit_id, :time, :content, :encryption_key_id, :edited, :deleted, :truncated,
|
|
:user_id, :name, :server_id, :server_era, :session_id, :is_staff, :is_manager, :client_address, :real_client_address,
|
|
(:user_id == :own_user_id OR EXISTS(
|
|
SELECT 1
|
|
FROM euph_rooms
|
|
WHERE room = :room
|
|
AND :time < first_joined
|
|
))
|
|
)
|
|
ON CONFLICT (room, id) DO UPDATE
|
|
SET
|
|
room = :room,
|
|
id = :id,
|
|
parent = :parent,
|
|
previous_edit_id = :previous_edit_id,
|
|
time = :time,
|
|
content = :content,
|
|
encryption_key_id = :encryption_key_id,
|
|
edited = :edited,
|
|
deleted = :deleted,
|
|
truncated = :truncated,
|
|
|
|
user_id = :user_id,
|
|
name = :name,
|
|
server_id = :server_id,
|
|
server_era = :server_era,
|
|
session_id = :session_id,
|
|
is_staff = :is_staff,
|
|
is_manager = :is_manager,
|
|
client_address = :client_address,
|
|
real_client_address = :real_client_address
|
|
"
|
|
)?;
|
|
|
|
let own_user_id = own_user_id.as_ref().map(|u| &u.0);
|
|
for msg in msgs {
|
|
insert_msg.execute(named_params! {
|
|
":room": room,
|
|
":id": WSnowflake(msg.id),
|
|
":parent": msg.parent.map(WSnowflake),
|
|
":previous_edit_id": msg.previous_edit_id.map(WSnowflake),
|
|
":time": WTime(msg.time),
|
|
":content": msg.content,
|
|
":encryption_key_id": msg.encryption_key_id,
|
|
":edited": msg.edited.map(WTime),
|
|
":deleted": msg.deleted.map(WTime),
|
|
":truncated": msg.truncated,
|
|
":user_id": msg.sender.id.0,
|
|
":name": msg.sender.name,
|
|
":server_id": msg.sender.server_id,
|
|
":server_era": msg.sender.server_era,
|
|
":session_id": msg.sender.session_id,
|
|
":is_staff": msg.sender.is_staff,
|
|
":is_manager": msg.sender.is_manager,
|
|
":client_address": msg.sender.client_address,
|
|
":real_client_address": msg.sender.real_client_address,
|
|
":own_user_id": own_user_id, // May be NULL
|
|
})?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn add_span(
|
|
tx: &Transaction<'_>,
|
|
room: &str,
|
|
start: Option<Snowflake>,
|
|
end: Option<Snowflake>,
|
|
) -> rusqlite::Result<()> {
|
|
// Retrieve all spans for the room
|
|
let mut spans = tx
|
|
.prepare(
|
|
"
|
|
SELECT start, end
|
|
FROM euph_spans
|
|
WHERE room = ?
|
|
",
|
|
)?
|
|
.query_map([room], |row| {
|
|
let start = row.get::<_, Option<WSnowflake>>(0)?.map(|s| s.0);
|
|
let end = row.get::<_, Option<WSnowflake>>(1)?.map(|s| s.0);
|
|
Ok((start, end))
|
|
})?
|
|
.collect::<Result<Vec<_>, _>>()?;
|
|
|
|
// Add new span and sort spans lexicographically
|
|
spans.push((start, end));
|
|
spans.sort_unstable();
|
|
|
|
// Combine overlapping spans (including newly added span)
|
|
let mut cur_span: Option<(Option<Snowflake>, Option<Snowflake>)> = None;
|
|
let mut result = vec![];
|
|
for mut span in spans {
|
|
if let Some(cur_span) = &mut cur_span {
|
|
if span.0 <= cur_span.1 {
|
|
// Since spans are sorted lexicographically, we know that
|
|
// cur_span.0 <= span.0, which means that span starts inside
|
|
// of cur_span.
|
|
cur_span.1 = cur_span.1.max(span.1);
|
|
} else {
|
|
// Since span doesn't overlap cur_span, we know that no
|
|
// later span will overlap cur_span either. The size of
|
|
// cur_span is thus final.
|
|
mem::swap(cur_span, &mut span);
|
|
result.push(span);
|
|
}
|
|
} else {
|
|
cur_span = Some(span);
|
|
}
|
|
}
|
|
if let Some(cur_span) = cur_span {
|
|
result.push(cur_span);
|
|
}
|
|
|
|
// Delete all spans for the room
|
|
tx.execute(
|
|
"
|
|
DELETE FROM euph_spans
|
|
WHERE room = ?
|
|
",
|
|
[room],
|
|
)?;
|
|
|
|
// Re-insert combined spans for the room
|
|
let mut stmt = tx.prepare(
|
|
"
|
|
INSERT INTO euph_spans (room, start, end)
|
|
VALUES (?, ?, ?)
|
|
",
|
|
)?;
|
|
for (start, end) in result {
|
|
stmt.execute(params![room, start.map(WSnowflake), end.map(WSnowflake)])?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
impl Request for AddMsg {
|
|
fn perform(self, conn: &mut Connection) -> rusqlite::Result<()> {
|
|
let tx = conn.transaction()?;
|
|
|
|
let end = self.msg.id;
|
|
insert_msgs(&tx, &self.room, &self.own_user_id, vec![*self.msg])?;
|
|
add_span(&tx, &self.room, self.prev_msg_id, Some(end))?;
|
|
|
|
tx.commit()?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl Request for AddMsgs {
|
|
fn perform(self, conn: &mut Connection) -> rusqlite::Result<()> {
|
|
let tx = conn.transaction()?;
|
|
|
|
if self.msgs.is_empty() {
|
|
add_span(&tx, &self.room, None, self.next_msg_id)?;
|
|
} else {
|
|
let first_msg_id = self.msgs.first().unwrap().id;
|
|
let last_msg_id = self.msgs.last().unwrap().id;
|
|
|
|
insert_msgs(&tx, &self.room, &self.own_user_id, self.msgs)?;
|
|
|
|
let end = self.next_msg_id.unwrap_or(last_msg_id);
|
|
add_span(&tx, &self.room, Some(first_msg_id), Some(end))?;
|
|
}
|
|
|
|
tx.commit()?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl Request for GetLastSpan {
|
|
fn perform(self, conn: &mut Connection) -> rusqlite::Result<()> {
|
|
let span = conn
|
|
.prepare(
|
|
"
|
|
SELECT start, end
|
|
FROM euph_spans
|
|
WHERE room = ?
|
|
ORDER BY start DESC
|
|
LIMIT 1
|
|
",
|
|
)?
|
|
.query_row([self.room], |row| {
|
|
Ok((
|
|
row.get::<_, Option<WSnowflake>>(0)?.map(|s| s.0),
|
|
row.get::<_, Option<WSnowflake>>(1)?.map(|s| s.0),
|
|
))
|
|
})
|
|
.optional()?;
|
|
let _ = self.result.send(span);
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl Request for GetPath {
|
|
fn perform(self, conn: &mut Connection) -> rusqlite::Result<()> {
|
|
let path = conn
|
|
.prepare(
|
|
"
|
|
WITH RECURSIVE
|
|
path (room, id) AS (
|
|
VALUES (?, ?)
|
|
UNION
|
|
SELECT room, parent
|
|
FROM euph_msgs
|
|
JOIN path USING (room, id)
|
|
)
|
|
SELECT id
|
|
FROM path
|
|
WHERE id IS NOT NULL
|
|
ORDER BY id ASC
|
|
",
|
|
)?
|
|
.query_map(params![self.room, WSnowflake(self.id)], |row| {
|
|
row.get::<_, WSnowflake>(0).map(|s| s.0)
|
|
})?
|
|
.collect::<rusqlite::Result<_>>()?;
|
|
let path = Path::new(path);
|
|
let _ = self.result.send(path);
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl Request for GetMsg {
|
|
fn perform(self, conn: &mut Connection) -> rusqlite::Result<()> {
|
|
let msg = conn
|
|
.query_row(
|
|
"
|
|
SELECT id, parent, time, name, content, seen
|
|
FROM euph_msgs
|
|
WHERE room = ?
|
|
AND id = ?
|
|
",
|
|
params![self.room, WSnowflake(self.id)],
|
|
|row| {
|
|
Ok(SmallMessage {
|
|
id: row.get::<_, WSnowflake>(0)?.0,
|
|
parent: row.get::<_, Option<WSnowflake>>(1)?.map(|s| s.0),
|
|
time: row.get::<_, WTime>(2)?.0,
|
|
nick: row.get(3)?,
|
|
content: row.get(4)?,
|
|
seen: row.get(5)?,
|
|
})
|
|
},
|
|
)
|
|
.optional()?;
|
|
let _ = self.result.send(msg);
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl Request for GetFullMsg {
|
|
fn perform(self, conn: &mut Connection) -> rusqlite::Result<()> {
|
|
let mut query = conn.prepare(
|
|
"
|
|
SELECT
|
|
id, parent, previous_edit_id, time, content, encryption_key_id, edited, deleted, truncated,
|
|
user_id, name, server_id, server_era, session_id, is_staff, is_manager, client_address, real_client_address
|
|
FROM euph_msgs
|
|
WHERE room = ?
|
|
AND id = ?
|
|
"
|
|
)?;
|
|
|
|
let msg = query
|
|
.query_row(params![self.room, WSnowflake(self.id)], |row| {
|
|
Ok(Message {
|
|
id: row.get::<_, WSnowflake>(0)?.0,
|
|
parent: row.get::<_, Option<WSnowflake>>(1)?.map(|s| s.0),
|
|
previous_edit_id: row.get::<_, Option<WSnowflake>>(2)?.map(|s| s.0),
|
|
time: row.get::<_, WTime>(3)?.0,
|
|
content: row.get(4)?,
|
|
encryption_key_id: row.get(5)?,
|
|
edited: row.get::<_, Option<WTime>>(6)?.map(|t| t.0),
|
|
deleted: row.get::<_, Option<WTime>>(7)?.map(|t| t.0),
|
|
truncated: row.get(8)?,
|
|
sender: SessionView {
|
|
id: UserId(row.get(9)?),
|
|
name: row.get(10)?,
|
|
server_id: row.get(11)?,
|
|
server_era: row.get(12)?,
|
|
session_id: row.get(13)?,
|
|
is_staff: row.get(14)?,
|
|
is_manager: row.get(15)?,
|
|
client_address: row.get(16)?,
|
|
real_client_address: row.get(17)?,
|
|
},
|
|
})
|
|
})
|
|
.optional()?;
|
|
let _ = self.result.send(msg);
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl Request for GetTree {
|
|
fn perform(self, conn: &mut Connection) -> rusqlite::Result<()> {
|
|
let msgs = conn
|
|
.prepare(
|
|
"
|
|
WITH RECURSIVE
|
|
tree (room, id) AS (
|
|
VALUES (?, ?)
|
|
UNION
|
|
SELECT euph_msgs.room, euph_msgs.id
|
|
FROM euph_msgs
|
|
JOIN tree
|
|
ON tree.room = euph_msgs.room
|
|
AND tree.id = euph_msgs.parent
|
|
)
|
|
SELECT id, parent, time, name, content, seen
|
|
FROM euph_msgs
|
|
JOIN tree USING (room, id)
|
|
ORDER BY id ASC
|
|
",
|
|
)?
|
|
.query_map(params![self.room, WSnowflake(self.root)], |row| {
|
|
Ok(SmallMessage {
|
|
id: row.get::<_, WSnowflake>(0)?.0,
|
|
parent: row.get::<_, Option<WSnowflake>>(1)?.map(|s| s.0),
|
|
time: row.get::<_, WTime>(2)?.0,
|
|
nick: row.get(3)?,
|
|
content: row.get(4)?,
|
|
seen: row.get(5)?,
|
|
})
|
|
})?
|
|
.collect::<rusqlite::Result<_>>()?;
|
|
let tree = Tree::new(self.root, msgs);
|
|
let _ = self.result.send(tree);
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl Request for GetFirstTreeId {
|
|
fn perform(self, conn: &mut Connection) -> rusqlite::Result<()> {
|
|
let tree = conn
|
|
.prepare(
|
|
"
|
|
SELECT id
|
|
FROM euph_trees
|
|
WHERE room = ?
|
|
ORDER BY id ASC
|
|
LIMIT 1
|
|
",
|
|
)?
|
|
.query_row([self.room], |row| row.get::<_, WSnowflake>(0).map(|s| s.0))
|
|
.optional()?;
|
|
let _ = self.result.send(tree);
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl Request for GetLastTreeId {
|
|
fn perform(self, conn: &mut Connection) -> rusqlite::Result<()> {
|
|
let tree = conn
|
|
.prepare(
|
|
"
|
|
SELECT id
|
|
FROM euph_trees
|
|
WHERE room = ?
|
|
ORDER BY id DESC
|
|
LIMIT 1
|
|
",
|
|
)?
|
|
.query_row([self.room], |row| row.get::<_, WSnowflake>(0).map(|s| s.0))
|
|
.optional()?;
|
|
let _ = self.result.send(tree);
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl Request for GetPrevTreeId {
|
|
fn perform(self, conn: &mut Connection) -> rusqlite::Result<()> {
|
|
let tree = conn
|
|
.prepare(
|
|
"
|
|
SELECT id
|
|
FROM euph_trees
|
|
WHERE room = ?
|
|
AND id < ?
|
|
ORDER BY id DESC
|
|
LIMIT 1
|
|
",
|
|
)?
|
|
.query_row(params![self.room, WSnowflake(self.root)], |row| {
|
|
row.get::<_, WSnowflake>(0).map(|s| s.0)
|
|
})
|
|
.optional()?;
|
|
let _ = self.result.send(tree);
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl Request for GetNextTreeId {
|
|
fn perform(self, conn: &mut Connection) -> rusqlite::Result<()> {
|
|
let tree = conn
|
|
.prepare(
|
|
"
|
|
SELECT id
|
|
FROM euph_trees
|
|
WHERE room = ?
|
|
AND id > ?
|
|
ORDER BY id ASC
|
|
LIMIT 1
|
|
",
|
|
)?
|
|
.query_row(params![self.room, WSnowflake(self.root)], |row| {
|
|
row.get::<_, WSnowflake>(0).map(|s| s.0)
|
|
})
|
|
.optional()?;
|
|
let _ = self.result.send(tree);
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl Request for GetOldestMsgId {
|
|
fn perform(self, conn: &mut Connection) -> rusqlite::Result<()> {
|
|
let tree = conn
|
|
.prepare(
|
|
"
|
|
SELECT id
|
|
FROM euph_msgs
|
|
WHERE room = ?
|
|
ORDER BY id ASC
|
|
LIMIT 1
|
|
",
|
|
)?
|
|
.query_row([self.room], |row| row.get::<_, WSnowflake>(0).map(|s| s.0))
|
|
.optional()?;
|
|
let _ = self.result.send(tree);
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl Request for GetNewestMsgId {
|
|
fn perform(self, conn: &mut Connection) -> rusqlite::Result<()> {
|
|
let tree = conn
|
|
.prepare(
|
|
"
|
|
SELECT id
|
|
FROM euph_msgs
|
|
WHERE room = ?
|
|
ORDER BY id DESC
|
|
LIMIT 1
|
|
",
|
|
)?
|
|
.query_row([self.room], |row| row.get::<_, WSnowflake>(0).map(|s| s.0))
|
|
.optional()?;
|
|
let _ = self.result.send(tree);
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl Request for GetOlderMsgId {
|
|
fn perform(self, conn: &mut Connection) -> rusqlite::Result<()> {
|
|
let tree = conn
|
|
.prepare(
|
|
"
|
|
SELECT id
|
|
FROM euph_msgs
|
|
WHERE room = ?
|
|
AND id < ?
|
|
ORDER BY id DESC
|
|
LIMIT 1
|
|
",
|
|
)?
|
|
.query_row(params![self.room, WSnowflake(self.id)], |row| {
|
|
row.get::<_, WSnowflake>(0).map(|s| s.0)
|
|
})
|
|
.optional()?;
|
|
let _ = self.result.send(tree);
|
|
Ok(())
|
|
}
|
|
}
|
|
impl Request for GetNewerMsgId {
|
|
fn perform(self, conn: &mut Connection) -> rusqlite::Result<()> {
|
|
let tree = conn
|
|
.prepare(
|
|
"
|
|
SELECT id
|
|
FROM euph_msgs
|
|
WHERE room = ?
|
|
AND id > ?
|
|
ORDER BY id ASC
|
|
LIMIT 1
|
|
",
|
|
)?
|
|
.query_row(params![self.room, WSnowflake(self.id)], |row| {
|
|
row.get::<_, WSnowflake>(0).map(|s| s.0)
|
|
})
|
|
.optional()?;
|
|
let _ = self.result.send(tree);
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl Request for GetOldestUnseenMsgId {
|
|
fn perform(self, conn: &mut Connection) -> rusqlite::Result<()> {
|
|
let tree = conn
|
|
.prepare(
|
|
"
|
|
SELECT id
|
|
FROM euph_msgs
|
|
WHERE room = ?
|
|
AND NOT seen
|
|
ORDER BY id ASC
|
|
LIMIT 1
|
|
",
|
|
)?
|
|
.query_row([self.room], |row| row.get::<_, WSnowflake>(0).map(|s| s.0))
|
|
.optional()?;
|
|
let _ = self.result.send(tree);
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl Request for GetNewestUnseenMsgId {
|
|
fn perform(self, conn: &mut Connection) -> rusqlite::Result<()> {
|
|
let tree = conn
|
|
.prepare(
|
|
"
|
|
SELECT id
|
|
FROM euph_msgs
|
|
WHERE room = ?
|
|
AND NOT seen
|
|
ORDER BY id DESC
|
|
LIMIT 1
|
|
",
|
|
)?
|
|
.query_row([self.room], |row| row.get::<_, WSnowflake>(0).map(|s| s.0))
|
|
.optional()?;
|
|
let _ = self.result.send(tree);
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl Request for GetOlderUnseenMsgId {
|
|
fn perform(self, conn: &mut Connection) -> rusqlite::Result<()> {
|
|
let tree = conn
|
|
.prepare(
|
|
"
|
|
SELECT id
|
|
FROM euph_msgs
|
|
WHERE room = ?
|
|
AND NOT seen
|
|
AND id < ?
|
|
ORDER BY id DESC
|
|
LIMIT 1
|
|
",
|
|
)?
|
|
.query_row(params![self.room, WSnowflake(self.id)], |row| {
|
|
row.get::<_, WSnowflake>(0).map(|s| s.0)
|
|
})
|
|
.optional()?;
|
|
let _ = self.result.send(tree);
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl Request for GetNewerUnseenMsgId {
|
|
fn perform(self, conn: &mut Connection) -> rusqlite::Result<()> {
|
|
let tree = conn
|
|
.prepare(
|
|
"
|
|
SELECT id
|
|
FROM euph_msgs
|
|
WHERE room = ?
|
|
AND NOT seen
|
|
AND id > ?
|
|
ORDER BY id ASC
|
|
LIMIT 1
|
|
",
|
|
)?
|
|
.query_row(params![self.room, WSnowflake(self.id)], |row| {
|
|
row.get::<_, WSnowflake>(0).map(|s| s.0)
|
|
})
|
|
.optional()?;
|
|
let _ = self.result.send(tree);
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl Request for GetUnseenMsgsCount {
|
|
fn perform(self, conn: &mut Connection) -> rusqlite::Result<()> {
|
|
let amount = conn
|
|
.prepare(
|
|
"
|
|
SELECT amount
|
|
FROM euph_unseen_counts
|
|
WHERE room = ?
|
|
",
|
|
)?
|
|
.query_row(params![self.room], |row| row.get(0))
|
|
.optional()?
|
|
.unwrap_or(0);
|
|
let _ = self.result.send(amount);
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl Request for SetSeen {
|
|
fn perform(self, conn: &mut Connection) -> rusqlite::Result<()> {
|
|
conn.execute(
|
|
"
|
|
UPDATE euph_msgs
|
|
SET seen = :seen
|
|
WHERE room = :room
|
|
AND id = :id
|
|
",
|
|
named_params! { ":room": self.room, ":id": WSnowflake(self.id), ":seen": self.seen },
|
|
)?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl Request for SetOlderSeen {
|
|
fn perform(self, conn: &mut Connection) -> rusqlite::Result<()> {
|
|
conn.execute(
|
|
"
|
|
UPDATE euph_msgs
|
|
SET seen = :seen
|
|
WHERE room = :room
|
|
AND id <= :id
|
|
AND seen != :seen
|
|
",
|
|
named_params! { ":room": self.room, ":id": WSnowflake(self.id), ":seen": self.seen },
|
|
)?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl Request for GetChunkAtOffset {
|
|
fn perform(self, conn: &mut Connection) -> rusqlite::Result<()> {
|
|
let mut query = conn.prepare(
|
|
"
|
|
SELECT
|
|
id, parent, previous_edit_id, time, content, encryption_key_id, edited, deleted, truncated,
|
|
user_id, name, server_id, server_era, session_id, is_staff, is_manager, client_address, real_client_address
|
|
FROM euph_msgs
|
|
WHERE room = ?
|
|
ORDER BY id ASC
|
|
LIMIT ?
|
|
OFFSET ?
|
|
",
|
|
)?;
|
|
|
|
let messages = query
|
|
.query_map(params![self.room, self.amount, self.offset], |row| {
|
|
Ok(Message {
|
|
id: row.get::<_, WSnowflake>(0)?.0,
|
|
parent: row.get::<_, Option<WSnowflake>>(1)?.map(|s| s.0),
|
|
previous_edit_id: row.get::<_, Option<WSnowflake>>(2)?.map(|s| s.0),
|
|
time: row.get::<_, WTime>(3)?.0,
|
|
content: row.get(4)?,
|
|
encryption_key_id: row.get(5)?,
|
|
edited: row.get::<_, Option<WTime>>(6)?.map(|t| t.0),
|
|
deleted: row.get::<_, Option<WTime>>(7)?.map(|t| t.0),
|
|
truncated: row.get(8)?,
|
|
sender: SessionView {
|
|
id: UserId(row.get(9)?),
|
|
name: row.get(10)?,
|
|
server_id: row.get(11)?,
|
|
server_era: row.get(12)?,
|
|
session_id: row.get(13)?,
|
|
is_staff: row.get(14)?,
|
|
is_manager: row.get(15)?,
|
|
client_address: row.get(16)?,
|
|
real_client_address: row.get(17)?,
|
|
},
|
|
})
|
|
})?
|
|
.collect::<rusqlite::Result<_>>()?;
|
|
let _ = self.result.send(messages);
|
|
Ok(())
|
|
}
|
|
}
|