use std::collections::{BTreeMap, BTreeSet, HashMap};
use bincode::{Decode, Encode};
use rostra_core::event::{EventExt as _, PersonaId, PersonaTag, SocialPost, content_kind};
use rostra_core::id::RostraId;
use rostra_core::{ExternalEventId, ShortEventId, Timestamp};
use serde::{Deserialize, Serialize};
use tracing::{debug, warn};
use super::Database;
use crate::event::ContentStoreRecord;
use crate::{
DbResult, LOG_TARGET, content_store, events, events_content_state,
shoutbox_posts_by_received_at, social_posts, social_posts_by_received_at, social_posts_by_time,
social_posts_reactions, social_posts_replaced_by, social_posts_replaces, social_posts_replies,
tables,
};
#[derive(
Encode, Decode, Serialize, Deserialize, Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord,
)]
pub struct EventPaginationCursor {
pub ts: Timestamp,
pub event_id: ShortEventId,
}
impl EventPaginationCursor {
pub const ZERO: Self = Self {
ts: Timestamp::ZERO,
event_id: ShortEventId::ZERO,
};
pub const MAX: Self = Self {
ts: Timestamp::MAX,
event_id: ShortEventId::MAX,
};
}
#[derive(
Encode, Decode, Serialize, Deserialize, Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord,
)]
pub struct ReceivedAtPaginationCursor {
pub ts: Timestamp,
#[serde(alias = "reception_order")]
pub seq: u64,
}
impl ReceivedAtPaginationCursor {
pub const ZERO: Self = Self {
ts: Timestamp::ZERO,
seq: 0,
};
pub const MAX: Self = Self {
ts: Timestamp::MAX,
seq: u64::MAX,
};
pub fn next(self) -> Self {
if self.seq < u64::MAX {
Self {
ts: self.ts,
seq: self.seq + 1,
}
} else {
Self {
ts: self.ts.saturating_add_secs(1),
seq: 0,
}
}
}
}
#[derive(Clone, Debug)]
pub struct SocialPostRecord<C> {
pub ts: Timestamp,
pub event_id: ShortEventId,
pub author: RostraId,
pub reply_to: Option<ExternalEventId>,
pub content: C,
pub reply_count: u64,
}
#[derive(Clone, Debug)]
pub struct ShoutboxPostRecord {
pub received_ts: Timestamp,
pub event_id: ShortEventId,
pub author: RostraId,
pub content: content_kind::Shoutbox,
}
impl Database {
pub(crate) fn is_social_post_replaced_tx(
author: RostraId,
event_id: ShortEventId,
social_posts_replaced_by_table: &impl social_posts_replaced_by::ReadableTable,
) -> DbResult<bool> {
Ok(social_posts_replaced_by_table
.range(
&(author, event_id, ShortEventId::ZERO)..=&(author, event_id, ShortEventId::MAX),
)?
.next()
.transpose()?
.is_some())
}
fn latest_social_post_version_tx(
author: RostraId,
event_id: ShortEventId,
social_posts_replaced_by_table: &impl social_posts_replaced_by::ReadableTable,
) -> DbResult<ShortEventId> {
let mut current = event_id;
while let Some(record) = social_posts_replaced_by_table
.range(&(author, current, ShortEventId::ZERO)..=&(author, current, ShortEventId::MAX))?
.next()
.transpose()?
{
let (_, _, new_event_id) = record.0.value();
current = new_event_id;
}
Ok(current)
}
fn social_post_versions_tx(
author: RostraId,
event_id: ShortEventId,
social_posts_replaces_table: &impl social_posts_replaces::ReadableTable,
) -> DbResult<Vec<ShortEventId>> {
let mut versions = vec![event_id];
let mut current = event_id;
while let Some(record) = social_posts_replaces_table
.range(&(author, current, ShortEventId::ZERO)..=&(author, current, ShortEventId::MAX))?
.next()
.transpose()?
{
let (_, _, old_event_id) = record.0.value();
versions.push(old_event_id);
current = old_event_id;
}
Ok(versions)
}
fn social_post_reply_count_tx(
author: RostraId,
event_id: ShortEventId,
social_posts_table: &impl social_posts::ReadableTable,
social_posts_replaces_table: &impl social_posts_replaces::ReadableTable,
) -> DbResult<u64> {
let mut reply_count = 0u64;
for version in Self::social_post_versions_tx(author, event_id, social_posts_replaces_table)?
{
reply_count = reply_count.saturating_add(
Database::get_social_post_tx(version, social_posts_table)?
.unwrap_or_default()
.reply_count,
);
}
Ok(reply_count)
}
fn social_post_record_by_id_tx(
event_id: ShortEventId,
ts: Timestamp,
events_table: &impl events::ReadableTable,
social_posts_table: &impl social_posts::ReadableTable,
events_content_state_table: &impl events_content_state::ReadableTable,
content_store_table: &impl content_store::ReadableTable,
social_posts_replaces_table: &impl social_posts_replaces::ReadableTable,
) -> DbResult<Option<SocialPostRecord<content_kind::SocialPost>>> {
let Some(event) = Database::get_event_tx(event_id, events_table)? else {
warn!(target: LOG_TARGET, %event_id, "Missing event for a post with social_post_record?!");
return Ok(None);
};
let author = event.author();
let content_hash = event.content_hash();
if Database::get_event_content_state_tx(event_id, events_content_state_table)?.is_some() {
debug!(target: LOG_TARGET, %event_id, "Skipping post without content present");
return Ok(None);
}
let Some(store_record) = content_store_table.get(&content_hash)?.map(|g| g.value()) else {
debug!(target: LOG_TARGET, %event_id, "Skipping post without content present");
return Ok(None);
};
let ContentStoreRecord(content) = store_record;
let Ok(social_post) = content.deserialize_cbor::<content_kind::SocialPost>() else {
debug!(target: LOG_TARGET, %event_id, "Skipping post with invalid content");
return Ok(None);
};
let reply_count = Self::social_post_reply_count_tx(
author,
event_id,
social_posts_table,
social_posts_replaces_table,
)?;
Ok(Some(SocialPostRecord {
ts,
author,
event_id,
reply_to: social_post.reply_to,
reply_count,
content: social_post,
}))
}
pub async fn paginate_social_posts(
&self,
cursor: Option<EventPaginationCursor>,
limit: usize,
filter_fn: impl Fn(&SocialPostRecord<SocialPost>) -> bool + Send + 'static,
) -> (
Vec<SocialPostRecord<content_kind::SocialPost>>,
Option<EventPaginationCursor>,
) {
self.read_with(|tx| {
let events_table = tx.open_table(&events::TABLE)?;
let social_posts_table = tx.open_table(&social_posts::TABLE)?;
let social_posts_by_time_table = tx.open_table(&social_posts_by_time::TABLE)?;
let events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let content_store_table = tx.open_table(&content_store::TABLE)?;
let social_posts_replaced_by_table = tx.open_table(&social_posts_replaced_by::TABLE)?;
let social_posts_replaces_table = tx.open_table(&social_posts_replaces::TABLE)?;
let (ret, cursor) = Self::paginate_table(&social_posts_by_time_table,
cursor.map(|c| (c.ts, c.event_id)),
limit,
move |(ts, event_id), _| {
let Some(event) = Database::get_event_tx(event_id, &events_table)? else {
warn!(target: LOG_TARGET, %event_id, "Missing event for a post with social_post_record?!");
return Ok(None);
};
let author = event.author();
if Self::is_social_post_replaced_tx(author, event_id, &social_posts_replaced_by_table)? {
return Ok(None);
}
let content_hash = event.content_hash();
if Database::get_event_content_state_tx(event_id, &events_content_state_table)?
.is_some()
{
return Ok(None);
}
let Some(store_record) =
content_store_table.get(&content_hash)?.map(|g| g.value())
else {
return Ok(None);
};
let ContentStoreRecord(content) = store_record;
let Ok(social_post) = content.deserialize_cbor::<content_kind::SocialPost>() else {
debug!(target: LOG_TARGET, %event_id, "Content invalid");
return Ok(None);
};
let reply_count = Self::social_post_reply_count_tx(
author,
event_id,
&social_posts_table,
&social_posts_replaces_table,
)?;
let social_post_record = SocialPostRecord {
ts,
author,
event_id,
reply_count,
reply_to: social_post.reply_to,
content: social_post,
};
if !filter_fn(&social_post_record) {
return Ok(None);
}
Ok(Some(social_post_record))
})?;
Ok((
ret,
cursor.map(|(ts, event_id)| EventPaginationCursor { ts, event_id }),
))
})
.await
.expect("Storage error")
}
pub async fn paginate_social_posts_rev(
&self,
cursor: Option<EventPaginationCursor>,
limit: usize,
filter_fn: impl Fn(&SocialPostRecord<SocialPost>) -> bool + Send + 'static,
) -> (
Vec<SocialPostRecord<content_kind::SocialPost>>,
Option<EventPaginationCursor>,
) {
self.read_with(|tx| {
let events_table = tx.open_table(&events::TABLE)?;
let social_posts_table = tx.open_table(&social_posts::TABLE)?;
let social_posts_by_time_table = tx.open_table(&social_posts_by_time::TABLE)?;
let events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let content_store_table = tx.open_table(&content_store::TABLE)?;
let social_posts_replaced_by_table = tx.open_table(&social_posts_replaced_by::TABLE)?;
let social_posts_replaces_table = tx.open_table(&social_posts_replaces::TABLE)?;
let (ret, cursor) = Self::paginate_table_rev(&social_posts_by_time_table,
cursor.map(|c| (c.ts, c.event_id)),
limit,
move |(ts, event_id), _| {
let Some(event) = Database::get_event_tx(event_id, &events_table)? else {
warn!(target: LOG_TARGET, %event_id, "Missing event for a post with social_post_record?!");
return Ok(None);
};
let author = event.author();
if Self::is_social_post_replaced_tx(author, event_id, &social_posts_replaced_by_table)? {
return Ok(None);
}
let content_hash = event.content_hash();
if Database::get_event_content_state_tx(event_id, &events_content_state_table)?
.is_some()
{
return Ok(None);
}
let Some(store_record) =
content_store_table.get(&content_hash)?.map(|g| g.value())
else {
return Ok(None);
};
let ContentStoreRecord(content) = store_record;
let Ok(social_post) = content.deserialize_cbor::<content_kind::SocialPost>() else {
debug!(target: LOG_TARGET, %event_id, "Content invalid");
return Ok(None);
};
let reply_count = Self::social_post_reply_count_tx(
author,
event_id,
&social_posts_table,
&social_posts_replaces_table,
)?;
let social_post_record = SocialPostRecord {
ts,
author,
event_id,
reply_count,
reply_to: social_post.reply_to,
content: social_post,
};
if !filter_fn(&social_post_record) {
return Ok(None);
}
Ok(Some(social_post_record))
})?;
Ok((
ret,
cursor.map(|(ts, event_id)| EventPaginationCursor { ts, event_id }),
))
})
.await
.expect("Storage error")
}
pub async fn get_latest_social_post_received_at_cursor(
&self,
) -> Option<ReceivedAtPaginationCursor> {
self.read_with(|tx| {
let social_posts_by_received_at_table =
tx.open_table(&social_posts_by_received_at::TABLE)?;
if let Some(entry) = social_posts_by_received_at_table.last()? {
let (ts, seq) = entry.0.value();
Ok(Some(ReceivedAtPaginationCursor { ts, seq }))
} else {
Ok(None)
}
})
.await
.expect("Storage error")
}
pub async fn paginate_social_posts_by_received_at(
&self,
cursor: Option<ReceivedAtPaginationCursor>,
limit: usize,
filter_fn: impl Fn(&SocialPostRecord<SocialPost>) -> bool + Send + 'static,
) -> (
Vec<SocialPostRecord<content_kind::SocialPost>>,
Option<ReceivedAtPaginationCursor>,
) {
self.read_with(|tx| {
let events_table = tx.open_table(&events::TABLE)?;
let social_posts_table = tx.open_table(&social_posts::TABLE)?;
let social_posts_by_received_at_table =
tx.open_table(&social_posts_by_received_at::TABLE)?;
let events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let content_store_table = tx.open_table(&content_store::TABLE)?;
let social_posts_replaced_by_table = tx.open_table(&social_posts_replaced_by::TABLE)?;
let social_posts_replaces_table = tx.open_table(&social_posts_replaces::TABLE)?;
let (ret, cursor) = Self::paginate_table(
&social_posts_by_received_at_table,
cursor.map(|c| (c.ts, c.seq)),
limit,
move |(ts, _seq), event_id| {
let Some(event) = Database::get_event_tx(event_id, &events_table)? else {
warn!(target: LOG_TARGET, %event_id, "Missing event for a post with social_post_record?!");
return Ok(None);
};
let author = event.author();
if Self::is_social_post_replaced_tx(
author,
event_id,
&social_posts_replaced_by_table,
)? {
return Ok(None);
}
let content_hash = event.content_hash();
if Database::get_event_content_state_tx(event_id, &events_content_state_table)?
.is_some()
{
return Ok(None);
}
let Some(store_record) =
content_store_table.get(&content_hash)?.map(|g| g.value())
else {
return Ok(None);
};
let ContentStoreRecord(content) = store_record;
let Ok(social_post) = content.deserialize_cbor::<content_kind::SocialPost>()
else {
debug!(target: LOG_TARGET, %event_id, "Content invalid");
return Ok(None);
};
let reply_count = Self::social_post_reply_count_tx(
author,
event_id,
&social_posts_table,
&social_posts_replaces_table,
)?;
let social_post_record = SocialPostRecord {
ts,
author,
event_id,
reply_count,
reply_to: social_post.reply_to,
content: social_post,
};
if !filter_fn(&social_post_record) {
return Ok(None);
}
Ok(Some(social_post_record))
},
)?;
Ok((
ret,
cursor.map(|(ts, seq)| ReceivedAtPaginationCursor {
ts,
seq,
}),
))
})
.await
.expect("Storage error")
}
pub async fn paginate_social_posts_by_received_at_rev(
&self,
cursor: Option<ReceivedAtPaginationCursor>,
limit: usize,
filter_fn: impl Fn(&SocialPostRecord<SocialPost>) -> bool + Send + 'static,
) -> (
Vec<SocialPostRecord<content_kind::SocialPost>>,
Option<ReceivedAtPaginationCursor>,
) {
self.read_with(|tx| {
let events_table = tx.open_table(&events::TABLE)?;
let social_posts_table = tx.open_table(&social_posts::TABLE)?;
let social_posts_by_received_at_table =
tx.open_table(&social_posts_by_received_at::TABLE)?;
let events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let content_store_table = tx.open_table(&content_store::TABLE)?;
let social_posts_replaced_by_table = tx.open_table(&social_posts_replaced_by::TABLE)?;
let social_posts_replaces_table = tx.open_table(&social_posts_replaces::TABLE)?;
let (ret, cursor) = Self::paginate_table_rev(
&social_posts_by_received_at_table,
cursor.map(|c| (c.ts, c.seq)),
limit,
move |(ts, _seq), event_id| {
let Some(event) = Database::get_event_tx(event_id, &events_table)? else {
warn!(target: LOG_TARGET, %event_id, "Missing event for a post with social_post_record?!");
return Ok(None);
};
let author = event.author();
if Self::is_social_post_replaced_tx(
author,
event_id,
&social_posts_replaced_by_table,
)? {
return Ok(None);
}
let content_hash = event.content_hash();
if Database::get_event_content_state_tx(event_id, &events_content_state_table)?
.is_some()
{
return Ok(None);
}
let Some(store_record) =
content_store_table.get(&content_hash)?.map(|g| g.value())
else {
return Ok(None);
};
let ContentStoreRecord(content) = store_record;
let Ok(social_post) = content.deserialize_cbor::<content_kind::SocialPost>()
else {
debug!(target: LOG_TARGET, %event_id, "Content invalid");
return Ok(None);
};
let reply_count = Self::social_post_reply_count_tx(
author,
event_id,
&social_posts_table,
&social_posts_replaces_table,
)?;
let social_post_record = SocialPostRecord {
ts,
author,
event_id,
reply_count,
reply_to: social_post.reply_to,
content: social_post,
};
if !filter_fn(&social_post_record) {
return Ok(None);
}
Ok(Some(social_post_record))
},
)?;
Ok((
ret,
cursor.map(|(ts, seq)| ReceivedAtPaginationCursor {
ts,
seq,
}),
))
})
.await
.expect("Storage error")
}
pub async fn paginate_social_post_comments_rev(
&self,
post_event_id: ShortEventId,
cursor: Option<EventPaginationCursor>,
limit: usize,
) -> (
Vec<SocialPostRecord<content_kind::SocialPost>>,
Option<EventPaginationCursor>,
) {
self.read_with(|tx| {
let events_table = tx.open_table(&events::TABLE)?;
let social_posts_tbl = tx.open_table(&social_posts::TABLE)?;
let social_post_replies_tbl = tx.open_table(&social_posts_replies::TABLE)?;
let events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let content_store_table = tx.open_table(&content_store::TABLE)?;
let social_posts_replaces_table = tx.open_table(&social_posts_replaces::TABLE)?;
let versions =
if let Some(event) = Database::get_event_tx(post_event_id, &events_table)? {
Self::social_post_versions_tx(
event.author(),
post_event_id,
&social_posts_replaces_table,
)?
} else {
vec![post_event_id]
};
let mut records = vec![];
for version in versions {
for entry in social_post_replies_tbl.range(
&(version, Timestamp::ZERO, ShortEventId::ZERO)
..=&(version, Timestamp::MAX, ShortEventId::MAX),
)? {
let (key, _) = entry?;
let (_, ts, event_id) = key.value();
if cursor.is_some_and(|cursor| (cursor.ts, cursor.event_id) <= (ts, event_id)) {
continue;
}
let Some(record) = Self::social_post_record_by_id_tx(
event_id,
ts,
&events_table,
&social_posts_tbl,
&events_content_state_table,
&content_store_table,
&social_posts_replaces_table,
)?
else {
continue;
};
records.push(record);
}
}
records.sort_by_key(|record| std::cmp::Reverse((record.ts, record.event_id)));
records.truncate(limit);
let cursor = records.last().map(|record| EventPaginationCursor {
ts: record.ts,
event_id: record.event_id,
});
Ok((records, cursor))
})
.await
.expect("Storage error")
}
pub async fn paginate_social_post_reactions_rev(
&self,
post_event_id: ShortEventId,
cursor: Option<EventPaginationCursor>,
limit: usize,
) -> (
Vec<SocialPostRecord<content_kind::SocialPost>>,
Option<EventPaginationCursor>,
) {
self.read_with(|tx| {
let events_table = tx.open_table(&events::TABLE)?;
let social_posts_tbl = tx.open_table(&social_posts::TABLE)?;
let social_post_reactions_tbl = tx.open_table(&social_posts_reactions::TABLE)?;
let events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let content_store_table = tx.open_table(&content_store::TABLE)?;
let social_posts_replaces_table = tx.open_table(&social_posts_replaces::TABLE)?;
let versions =
if let Some(event) = Database::get_event_tx(post_event_id, &events_table)? {
Self::social_post_versions_tx(
event.author(),
post_event_id,
&social_posts_replaces_table,
)?
} else {
vec![post_event_id]
};
let mut records = vec![];
for version in versions {
for entry in social_post_reactions_tbl.range(
&(version, Timestamp::ZERO, ShortEventId::ZERO)
..=&(version, Timestamp::MAX, ShortEventId::MAX),
)? {
let (key, _) = entry?;
let (_, ts, event_id) = key.value();
if cursor.is_some_and(|cursor| (cursor.ts, cursor.event_id) <= (ts, event_id)) {
continue;
}
let Some(record) = Self::social_post_record_by_id_tx(
event_id,
ts,
&events_table,
&social_posts_tbl,
&events_content_state_table,
&content_store_table,
&social_posts_replaces_table,
)?
else {
continue;
};
records.push(record);
}
}
records.sort_by_key(|record| std::cmp::Reverse((record.ts, record.event_id)));
records.truncate(limit);
let cursor = records.last().map(|record| EventPaginationCursor {
ts: record.ts,
event_id: record.event_id,
});
Ok((records, cursor))
})
.await
.expect("Storage error")
}
pub async fn get_posts_by_id(
&self,
post_ids: impl Iterator<Item = ShortEventId>,
) -> HashMap<ShortEventId, SocialPostRecord<content_kind::SocialPost>> {
self.read_with(|tx| {
let events_table = tx.open_table(&events::TABLE)?;
let social_posts_table = tx.open_table(&social_posts::TABLE)?;
let events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let content_store_table = tx.open_table(&content_store::TABLE)?;
let social_posts_replaces_table = tx.open_table(&social_posts_replaces::TABLE)?;
let social_posts_replaced_by_table = tx.open_table(&social_posts_replaced_by::TABLE)?;
let mut ret = HashMap::new();
for requested_event_id in post_ids {
let event_id = if let Some(event) =
Database::get_event_tx(requested_event_id, &events_table)?
{
Self::latest_social_post_version_tx(
event.author(),
requested_event_id,
&social_posts_replaced_by_table,
)?
} else {
requested_event_id
};
let Some((social_post, event, _social_post_record)) =
Self::get_social_post_record_tx(
&events_table,
&social_posts_table,
&events_content_state_table,
&content_store_table,
event_id,
)?
else {
continue;
};
ret.insert(
requested_event_id,
SocialPostRecord {
ts: event.timestamp(),
author: event.author(),
event_id,
reply_count: Self::social_post_reply_count_tx(
event.author(),
event_id,
&social_posts_table,
&social_posts_replaces_table,
)?,
reply_to: social_post.reply_to,
content: social_post,
},
);
}
Ok(ret)
})
.await
.expect("Storage error")
}
pub async fn get_persona_tags_for_id(&self, id: RostraId) -> BTreeSet<PersonaTag> {
self.read_with(|tx| {
let social_posts_by_time_table = tx.open_table(&social_posts_by_time::TABLE)?;
let events_table = tx.open_table(&events::TABLE)?;
let events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let content_store_table = tx.open_table(&content_store::TABLE)?;
let mut tags = BTreeSet::new();
for entry in social_posts_by_time_table.range(..)?.rev() {
let entry = entry?;
let (_ts, event_id) = entry.0.value();
let Some(event) = Database::get_event_tx(event_id, &events_table)? else {
continue;
};
if event.author() != id {
continue;
}
let content_hash = event.content_hash();
if Database::get_event_content_state_tx(event_id, &events_content_state_table)?
.is_some()
{
continue;
}
let Some(store_record) = content_store_table.get(&content_hash)?.map(|g| g.value())
else {
continue;
};
let crate::event::ContentStoreRecord(content) = store_record;
if let Ok(social_post) = content.deserialize_cbor::<content_kind::SocialPost>() {
tags.extend(social_post.persona_tags());
}
if 500 < tags.len() {
break;
}
}
Ok(tags)
})
.await
.expect("Storage error")
}
pub async fn get_personas_for_id(&self, id: RostraId) -> BTreeMap<PersonaId, String> {
self.read_with(|tx| {
let personas = tx.open_table(&tables::ids_personas::TABLE)?;
let mut ret = BTreeMap::from([
(PersonaId(0), "Personal".into()),
(PersonaId(1), "Professional".into()),
(PersonaId(2), "Civic".into()),
]);
for record in personas.range(&(id, PersonaId::MIN)..=&(id, PersonaId::MAX))? {
let (k, v) = record?;
ret.insert(k.value().1, v.value().display_name);
}
Ok(ret)
})
.await
.expect("Storage error")
}
pub async fn get_personas(
&self,
iter: impl Iterator<Item = (RostraId, PersonaId)>,
) -> BTreeMap<(RostraId, PersonaId), String> {
self.read_with(|tx| {
let personas = tx.open_table(&tables::ids_personas::TABLE)?;
let default_personas: BTreeMap<PersonaId, String> = BTreeMap::from([
(PersonaId(0), "Personal".into()),
(PersonaId(1), "Professional".into()),
(PersonaId(2), "Civic".into()),
]);
let mut ret = BTreeMap::new();
for (rostra_id, persona_id) in iter {
if let Some(record) = personas.get(&(rostra_id, persona_id))? {
ret.insert((rostra_id, persona_id), record.value().display_name);
} else {
if let Some(d) = default_personas.get(&persona_id) {
ret.insert((rostra_id, persona_id), d.clone());
}
}
}
Ok(ret)
})
.await
.expect("Storage error")
}
pub async fn get_social_post(
&self,
event_id: ShortEventId,
) -> Option<SocialPostRecord<content_kind::SocialPost>> {
self.read_with(|tx| {
let events_table = tx.open_table(&events::TABLE)?;
let social_posts_table = tx.open_table(&social_posts::TABLE)?;
let events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let content_store_table = tx.open_table(&content_store::TABLE)?;
let social_posts_replaces_table = tx.open_table(&social_posts_replaces::TABLE)?;
let social_posts_replaced_by_table = tx.open_table(&social_posts_replaced_by::TABLE)?;
let event_id = if let Some(event) = Database::get_event_tx(event_id, &events_table)? {
Self::latest_social_post_version_tx(
event.author(),
event_id,
&social_posts_replaced_by_table,
)?
} else {
event_id
};
let Some((social_post, event, _social_post_record)) = Self::get_social_post_record_tx(
&events_table,
&social_posts_table,
&events_content_state_table,
&content_store_table,
event_id,
)?
else {
return Ok(None);
};
if event.is_delete_parent_aux_content_set()
&& social_post
.djot_content
.as_deref()
.is_none_or(|text| text.trim().is_empty())
{
return Ok(None);
}
Ok(Some(SocialPostRecord {
ts: event.timestamp(),
author: event.author(),
event_id,
reply_count: Self::social_post_reply_count_tx(
event.author(),
event_id,
&social_posts_table,
&social_posts_replaces_table,
)?,
reply_to: social_post.reply_to,
content: social_post,
}))
})
.await
.expect("Storage error")
}
pub(crate) fn get_social_post_record_tx(
events_table: &impl events::ReadableTable,
social_posts_table: &impl social_posts::ReadableTable,
events_content_state_table: &impl events_content_state::ReadableTable,
content_store_table: &impl content_store::ReadableTable,
event_id: ShortEventId,
) -> DbResult<Option<(SocialPost, crate::EventRecord, crate::SocialPostRecord)>> {
let Some(event) = Database::get_event_tx(event_id, events_table)? else {
warn!(target: LOG_TARGET, %event_id, "Missing event for a post with social_post_record?!");
return Ok(None);
};
let content_hash = event.content_hash();
if Database::get_event_content_state_tx(event_id, events_content_state_table)?.is_some() {
return Ok(None);
}
let Some(store_record) = content_store_table.get(&content_hash)?.map(|g| g.value()) else {
return Ok(None);
};
let ContentStoreRecord(content) = store_record;
let Ok(social_post) = content.deserialize_cbor::<content_kind::SocialPost>() else {
debug!(target: LOG_TARGET, %event_id, "Content invalid");
return Ok(None);
};
let social_post_record =
Database::get_social_post_tx(event_id, social_posts_table)?.unwrap_or_default();
Ok(Some((social_post, event, social_post_record)))
}
pub async fn is_self_mention(&self, event_id: ShortEventId) -> bool {
self.read_with(|tx| {
let self_mention_table = tx.open_table(&crate::social_posts_self_mention::TABLE)?;
Ok(self_mention_table.get(&event_id)?.is_some())
})
.await
.unwrap_or(false)
}
pub async fn get_self_mentions(&self) -> std::collections::HashSet<ShortEventId> {
self.read_with(|tx| {
let self_mention_table = tx.open_table(&crate::social_posts_self_mention::TABLE)?;
let mut mentions = std::collections::HashSet::new();
for entry in self_mention_table.range(..)? {
let (key, _) = entry?;
mentions.insert(key.value());
}
Ok(mentions)
})
.await
.unwrap_or_default()
}
pub async fn get_latest_shoutbox_received_at_cursor(
&self,
) -> Option<ReceivedAtPaginationCursor> {
self.read_with(|tx| {
let shoutbox_by_received_at_table =
tx.open_table(&shoutbox_posts_by_received_at::TABLE)?;
if let Some(entry) = shoutbox_by_received_at_table.last()? {
let (ts, seq) = entry.0.value();
Ok(Some(ReceivedAtPaginationCursor { ts, seq }))
} else {
Ok(None)
}
})
.await
.expect("Storage error")
}
pub async fn paginate_shoutbox_posts_by_received_at_rev(
&self,
cursor: Option<ReceivedAtPaginationCursor>,
limit: usize,
) -> (Vec<ShoutboxPostRecord>, Option<ReceivedAtPaginationCursor>) {
self.read_with(|tx| {
let events_table = tx.open_table(&events::TABLE)?;
let shoutbox_by_received_at_table =
tx.open_table(&shoutbox_posts_by_received_at::TABLE)?;
let events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
let content_store_table = tx.open_table(&content_store::TABLE)?;
let (ret, cursor) = Self::paginate_table_rev(
&shoutbox_by_received_at_table,
cursor.map(|c| (c.ts, c.seq)),
limit,
move |(ts, _seq), event_id| {
let Some(event) = Database::get_event_tx(event_id, &events_table)? else {
warn!(target: LOG_TARGET, %event_id, "Missing event for shoutbox post");
return Ok(None);
};
let content_hash = event.content_hash();
if Database::get_event_content_state_tx(event_id, &events_content_state_table)?
.is_some()
{
return Ok(None);
}
let Some(store_record) =
content_store_table.get(&content_hash)?.map(|g| g.value())
else {
return Ok(None);
};
let ContentStoreRecord(content) = store_record;
let Ok(shoutbox) = content.deserialize_cbor::<content_kind::Shoutbox>() else {
debug!(target: LOG_TARGET, %event_id, "Shoutbox content invalid");
return Ok(None);
};
Ok(Some(ShoutboxPostRecord {
received_ts: ts,
author: event.author(),
event_id,
content: shoutbox,
}))
},
)?;
Ok((
ret,
cursor.map(|(ts, seq)| ReceivedAtPaginationCursor { ts, seq }),
))
})
.await
.expect("Storage error")
}
pub async fn count_shoutbox_posts_since(
&self,
cursor: Option<ReceivedAtPaginationCursor>,
limit: usize,
) -> usize {
self.read_with(|tx| {
let shoutbox_by_received_at_table =
tx.open_table(&shoutbox_posts_by_received_at::TABLE)?;
let start = cursor.map(|c| c.next());
let mut count = 0;
for entry in if let Some(start) = start {
shoutbox_by_received_at_table.range(&(start.ts, start.seq)..)?
} else {
shoutbox_by_received_at_table.range(..)?
} {
let _ = entry?;
count += 1;
if limit <= count {
break;
}
}
Ok(count)
})
.await
.expect("Storage error")
}
}