use uuid::Uuid;
#[cfg(feature = "encryption")]
use zeroize::Zeroizing;
use crate::events::{EventType, RoomId};
const DEFAULT_LOAD_LIMIT: usize = 20;
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
#[serde(default)]
pub struct SearchConfig {
pub(crate) limit: usize,
pub(crate) before_limit: usize,
pub(crate) after_limit: usize,
pub(crate) order_by_recency: bool,
pub(crate) room_id: Option<RoomId>,
pub(crate) keys: Vec<EventType>,
pub(crate) next_batch: Option<Uuid>,
}
impl SearchConfig {
pub fn new() -> Self {
Default::default()
}
pub fn for_room(&mut self, room_id: &str) -> &mut Self {
self.room_id = Some(room_id.to_owned());
self
}
pub fn limit(&mut self, limit: usize) -> &mut Self {
self.limit = limit;
self
}
pub fn before_limit(&mut self, limit: usize) -> &mut Self {
self.before_limit = limit;
self
}
pub fn after_limit(&mut self, limit: usize) -> &mut Self {
self.after_limit = limit;
self
}
pub fn order_by_recency(&mut self, order_by_recency: bool) -> &mut Self {
self.order_by_recency = order_by_recency;
self
}
pub fn with_key(&mut self, key: EventType) -> &mut Self {
self.keys.push(key);
self.keys.sort();
self.keys.dedup();
self
}
pub fn next_batch(&mut self, token: Uuid) -> &mut Self {
self.next_batch = Some(token);
self
}
}
impl Default for SearchConfig {
fn default() -> Self {
SearchConfig {
limit: 10,
before_limit: 0,
after_limit: 0,
order_by_recency: false,
room_id: None,
keys: Vec::new(),
next_batch: None,
}
}
}
#[derive(Debug, PartialEq, Clone)]
#[allow(missing_docs)]
pub enum Language {
Arabic,
Danish,
Dutch,
English,
Finnish,
French,
German,
Greek,
Hungarian,
Italian,
Portuguese,
Romanian,
Russian,
Spanish,
Swedish,
Tamil,
Turkish,
Japanese,
Unknown,
}
impl Language {
pub(crate) fn as_tokenizer_name(&self) -> String {
match self {
Language::Unknown => "default".to_owned(),
lang => format!("seshat_{:?}", lang),
}
}
pub(crate) fn as_tantivy(&self) -> tantivy::tokenizer::Language {
match self {
Language::Arabic => tantivy::tokenizer::Language::Arabic,
Language::Danish => tantivy::tokenizer::Language::Danish,
Language::Dutch => tantivy::tokenizer::Language::Dutch,
Language::English => tantivy::tokenizer::Language::English,
Language::Finnish => tantivy::tokenizer::Language::Finnish,
Language::French => tantivy::tokenizer::Language::French,
Language::German => tantivy::tokenizer::Language::German,
Language::Greek => tantivy::tokenizer::Language::Greek,
Language::Hungarian => tantivy::tokenizer::Language::Hungarian,
Language::Italian => tantivy::tokenizer::Language::Italian,
Language::Portuguese => tantivy::tokenizer::Language::Portuguese,
Language::Romanian => tantivy::tokenizer::Language::Romanian,
Language::Russian => tantivy::tokenizer::Language::Russian,
Language::Spanish => tantivy::tokenizer::Language::Spanish,
Language::Swedish => tantivy::tokenizer::Language::Swedish,
Language::Tamil => tantivy::tokenizer::Language::Tamil,
Language::Turkish => tantivy::tokenizer::Language::Turkish,
_ => panic!("Unsuported language by tantivy"),
}
}
}
impl From<&str> for Language {
fn from(string: &str) -> Self {
match string.to_lowercase().as_ref() {
"arabic" => Language::Arabic,
"danish" => Language::Danish,
"dutch" => Language::Dutch,
"english" => Language::English,
"finnish" => Language::Finnish,
"french" => Language::French,
"german" => Language::German,
"greek" => Language::Greek,
"hungarian" => Language::Hungarian,
"italian" => Language::Italian,
"japanese" => Language::Japanese,
"portuguese" => Language::Portuguese,
"romanian" => Language::Romanian,
"russian" => Language::Russian,
"spanish" => Language::Spanish,
"swedish" => Language::Swedish,
"tamil" => Language::Tamil,
"turkish" => Language::Turkish,
_ => Language::Unknown,
}
}
}
#[derive(Debug, PartialEq, Clone)]
pub struct Config {
pub(crate) language: Language,
#[cfg(feature = "encryption")]
pub(crate) passphrase: Option<Zeroizing<String>>,
}
impl Config {
pub fn new() -> Self {
Default::default()
}
pub fn set_language(mut self, language: &Language) -> Self {
self.language = language.clone();
self
}
#[cfg(feature = "encryption")]
pub fn set_passphrase<P: Into<String>>(mut self, passphrase: P) -> Self {
self.passphrase = Some(Zeroizing::new(passphrase.into()));
self
}
}
impl Default for Config {
fn default() -> Config {
Config {
language: Language::Unknown,
#[cfg(feature = "encryption")]
passphrase: None,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[allow(missing_docs)]
pub enum LoadDirection {
#[serde(rename = "b", alias = "backwards", alias = "backward")]
Backwards,
#[serde(rename = "f", alias = "forwards", alias = "forward")]
Forwards,
}
impl Default for LoadDirection {
fn default() -> LoadDirection {
LoadDirection::Backwards
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct LoadConfig {
pub(crate) room_id: String,
pub(crate) limit: usize,
pub(crate) from_event: Option<String>,
#[serde(default)]
pub(crate) direction: LoadDirection,
}
impl LoadConfig {
pub fn new<R: Into<String>>(room_id: R) -> Self {
LoadConfig {
room_id: room_id.into(),
limit: DEFAULT_LOAD_LIMIT,
from_event: None,
direction: LoadDirection::default(),
}
}
pub fn limit(mut self, limit: usize) -> Self {
self.limit = limit;
self
}
#[allow(clippy::wrong_self_convention)]
pub fn from_event<E: Into<String>>(mut self, event_id: E) -> Self {
self.from_event = Some(event_id.into());
self
}
pub fn direction(mut self, direction: LoadDirection) -> Self {
self.direction = direction;
self
}
}