Struct UserDetails 

pub struct UserDetails {
    pub name: String,
    pub bio: Option<String>,
    pub id: PubkyId,
    pub links: Option<Vec<PubkyAppUserLink>>,
    pub status: Option<String>,
    pub image: Option<String>,
    pub indexed_at: i64,
}

Represents user data with name, bio, image, links, and status.

Fields

name: String

bio: Option<String>

id: PubkyId

links: Option<Vec<PubkyAppUserLink>>

status: Option<String>

image: Option<String>

indexed_at: i64

Implementations

impl UserDetails

pub async fn get_by_id(user_id: &str) -> Result<Option<Self>, DynError>

Retrieves details by user ID, first trying to get from Redis, then from Neo4j if not found.

pub async fn from_homeserver( homeserver_user: PubkyAppUser, user_id: &PubkyId, ) -> Result<Self, DynError>

pub async fn delete(user_id: &str) -> Result<(), DynError>

Trait Implementations

impl Clone for UserDetails

fn clone(&self) -> UserDetails

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Collection<&str> for UserDetails

fn collection_details_graph_query(id_list: &[&str]) -> Query

Returns the neo4j query to return a list records by passing a list of ids. The query should return each record in the “record” attribute of the node.

fn put_graph_query(&self) -> Result<Query, DynError>

Returns the neo4j query to put a record into the graph.

fn extend_on_index_miss<'life0, 'async_trait>( details: &'life0 [Option<Self>], ) -> Pin<Box<dyn Future<Output = Result<(), DynError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_by_ids<'life0, 'async_trait>( ids: &'life0 [T], ) -> Pin<Box<dyn Future<Output = Result<Vec<Option<Self>>, DynError>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait,

Retrieves records by their IDs, first attempting to fetch them from a cache (e.g., Redis), and then querying a graph database (e.g., Neo4j) if necessary.

fn get_from_graph<'life0, 'async_trait>( ids: &'life0 [T], ) -> Pin<Box<dyn Future<Output = Result<Vec<Option<Self>>, DynError>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait,

Queries a Neo4j graph database to retrieve records based on the provided IDs and collection type.

fn get_from_index<'life0, 'life1, 'async_trait>( keys: Vec<&'life0 [&'life1 str]>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Option<Self>>, DynError>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn put_to_index<'life0, 'async_trait>( ids: &'life0 [T], records: Vec<Option<Self>>, ) -> Pin<Box<dyn Future<Output = Result<(), DynError>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait,

Indexes collection of records in Redis for faster access in future queries.

fn put_to_graph<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), DynError>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

fn reindex<'life0, 'async_trait>( collection_ids: &'life0 [T], ) -> Pin<Box<dyn Future<Output = Result<(), DynError>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait,

impl ComposeSchema for UserDetails

fn compose(generics: Vec<RefOr<Schema>>) -> RefOr<Schema>

impl Debug for UserDetails

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for UserDetails

fn default() -> UserDetails

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for UserDetails

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl RedisOps for UserDetails

fn prefix<'async_trait>() -> Pin<Box<dyn Future<Output = String> + Send + 'async_trait>>

where Self: 'async_trait,

Provides a prefix string for the Redis key.

fn put_index_json<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, key_parts: &'life1 [&'life2 str], prefix: Option<String>, expiration: Option<i64>, ) -> Pin<Box<dyn Future<Output = Result<(), DynError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Sets the data in Redis using the provided key parts.

fn try_from_index_json<'life0, 'life1, 'async_trait>( key_parts: &'life0 [&'life1 str], prefix: Option<String>, ) -> Pin<Box<dyn Future<Output = Result<Option<Self>, DynError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Retrieves data from Redis using the provided key parts.

fn try_from_index_multiple_json<'life0, 'life1, 'life2, 'async_trait>( key_parts_list: &'life0 [&'life1 [&'life2 str]], ) -> Pin<Box<dyn Future<Output = Result<Vec<Option<Self>>, DynError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Retrieves multiple JSON objects from Redis using the provided key parts.

fn put_multiple_json_indexes<'life0, 'life1, 'life2, 'async_trait>( key_parts_list: &'life0 [&'life1 [&'life2 str]], collection: Vec<Option<Self>>, ) -> Pin<Box<dyn Future<Output = Result<(), DynError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Stores multiple key-value pairs in Redis, where each key is constructed from the provided key parts and each value is an item from the given collection.

fn remove_from_index_multiple_json<'life0, 'life1, 'life2, 'async_trait>( key_parts_list: &'life0 [&'life1 [&'life2 str]], ) -> Pin<Box<dyn Future<Output = Result<(), DynError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Removes multiple JSON objects from Redis using the provided key parts.

fn modify_json_field<'life0, 'life1, 'life2, 'async_trait>( key_parts: &'life0 [&'life1 str], field: &'life2 str, action: JsonAction, ) -> Pin<Box<dyn Future<Output = Result<(), DynError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Modifies a numeric field in a Redis JSON object by either incrementing or decrementing it.

fn put_index_list<'life0, 'life1, 'life2, 'async_trait, T>( &'life0 self, key_parts: &'life1 [&'life2 str], ) -> Pin<Box<dyn Future<Output = Result<(), DynError>> + Send + 'async_trait>>

where Self: AsRef<[T]> + 'async_trait, T: AsRef<str> + Send + Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Adds elements to a Redis list using the provided key parts.

fn try_from_index_list<'life0, 'life1, 'async_trait>( key_parts: &'life0 [&'life1 str], skip: Option<usize>, limit: Option<usize>, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<String>>, DynError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Retrieves a range of elements from a Redis list using the provided key parts.

fn put_index_set<'life0, 'life1, 'life2, 'life3, 'async_trait>( key_parts: &'life0 [&'life1 str], values: &'life2 [&'life3 str], expiration: Option<i64>, prefix: Option<String>, ) -> Pin<Box<dyn Future<Output = Result<(), DynError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Adds elements to a Redis set using the provided key parts.

fn remove_from_index_set<'life0, 'life1, 'life2, 'async_trait, T>( &'life0 self, key_parts: &'life1 [&'life2 str], ) -> Pin<Box<dyn Future<Output = Result<(), DynError>> + Send + 'async_trait>>

where Self: AsRef<[T]> + 'async_trait, T: AsRef<str> + Send + Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Removes elements from a Redis set using the provided key parts.

fn try_from_index_set<'life0, 'life1, 'async_trait>( key_parts: &'life0 [&'life1 str], skip: Option<usize>, limit: Option<usize>, prefix: Option<String>, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<String>>, DynError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Retrieves a range of elements from a Redis set using the provided key parts.

fn check_set_member<'life0, 'life1, 'life2, 'async_trait>( key_parts: &'life0 [&'life1 str], member: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<(bool, bool), DynError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Checks if a member exists in a Redis set and if the set exists using the provided key parts.

fn get_set_size<'life0, 'life1, 'async_trait>( key_parts: &'life0 [&'life1 str], ) -> Pin<Box<dyn Future<Output = Result<Option<usize>, DynError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Retrieves the size of a Redis set using the provided key parts.

fn try_from_multiple_sets<'life0, 'life1, 'life2, 'async_trait>( key_parts_list: &'life0 [&'life1 str], prefix: Option<String>, member: Option<&'life2 str>, limit: Option<usize>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Option<(Vec<String>, usize, bool)>>, DynError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Fetches multiple sets from Redis using the specified key components.

fn put_multiple_set_indexes<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>( common_key: &'life0 [&'life1 str], index: &'life2 [&'life3 str], collections_refs: &'life4 [Vec<&'life5 str>], prefix: Option<String>, expiration: Option<i64>, ) -> Pin<Box<dyn Future<Output = Result<(), DynError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, 'life5: 'async_trait,

Adds elements to multiple Redis sets using the provided keys and collections.

fn try_get_random_from_index_set<'life0, 'life1, 'async_trait>( key_parts: &'life0 [&'life1 str], count: isize, prefix: Option<String>, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<String>>, DynError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Retrieves random elements from a Redis set using the provided key parts.

fn check_sorted_set_member<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( prefix: Option<&'life0 str>, key_parts: &'life1 [&'life2 str], member: &'life3 [&'life4 str], ) -> Pin<Box<dyn Future<Output = Result<Option<isize>, DynError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Checks if a member exists in a Redis sorted set and retrieves its score if it exists.

fn put_index_sorted_set<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( key_parts: &'life0 [&'life1 str], elements: &'life2 [(f64, &'life3 str)], prefix: Option<&'life4 str>, expiration: Option<i64>, ) -> Pin<Box<dyn Future<Output = Result<(), DynError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Adds elements to a Redis sorted set using the provided key parts.

fn put_score_index_sorted_set<'life0, 'life1, 'life2, 'life3, 'async_trait>( key_parts: &'life0 [&'life1 str], member: &'life2 [&'life3 str], score_mutation: ScoreAction, ) -> Pin<Box<dyn Future<Output = Result<(), DynError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Updates the score of a member in a Redis sorted set.

fn remove_from_index_sorted_set<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( prefix: Option<&'life0 str>, key_parts: &'life1 [&'life2 str], items: &'life3 [&'life4 str], ) -> Pin<Box<dyn Future<Output = Result<(), DynError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Removes elements from a Redis sorted set using the provided key parts.

fn try_from_index_sorted_set<'life0, 'life1, 'life2, 'async_trait>( key_parts: &'life0 [&'life1 str], start: Option<f64>, end: Option<f64>, skip: Option<usize>, limit: Option<usize>, sorting: SortOrder, prefix: Option<&'life2 str>, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<(String, f64)>>, DynError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Retrieves a range of elements from a Redis sorted set using the provided key parts.

fn try_from_index_sorted_set_lex<'life0, 'life1, 'life2, 'life3, 'async_trait>( key_parts: &'life0 [&'life1 str], min: &'life2 str, max: &'life3 str, skip: Option<usize>, limit: Option<usize>, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<String>>, DynError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Retrieves a lexicographical range of elements from a Redis sorted set using the provided key parts.

impl Serialize for UserDetails

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl ToSchema for UserDetails

fn name() -> Cow<'static, str>

Return name of the schema.

fn schemas(schemas: &mut Vec<(String, RefOr<Schema>)>)

Implement reference utoipa::openapi::schema::Schemas for this type.