Struct UserCounts 

pub struct UserCounts {
    pub tagged: u32,
    pub tags: u32,
    pub unique_tags: u32,
    pub posts: u32,
    pub replies: u32,
    pub following: u32,
    pub followers: u32,
    pub friends: u32,
    pub bookmarks: u32,
}

Represents total counts of relationships of a user.

Fields

tagged: u32

tags: u32

unique_tags: u32

posts: u32

replies: u32

following: u32

followers: u32

friends: u32

bookmarks: u32

Implementations

impl UserCounts

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

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

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

Retrieves the counts from Neo4j.

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

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

pub async fn update_index_field( author_id: &str, field: &str, action: JsonAction, ) -> Result<(), DynError>

pub async fn update( user_id: &str, field: &str, action: JsonAction, tag_label: Option<&str>, ) -> Result<(), DynError>

Updates a user’s counts index field and conditionally updates ranking sets based on follower, tag, or post counts.

Arguments

• user_id - The unique identifier of the user whose index field is being updated.
• field - The name of the user-related field to update (e.g., "followers", "tags", "posts").
• action - The action to perform on the field (increment or decrement).
• tag_label - An optional tag label used to check membership in the user’s tag-related sorted set. Important if we want to update the unique_tags field

Behavior

• Conditional Update Based on tag_label
• Update User Counts Index
• Update Ranking Sets for Specific Fields

pub async fn reindex(author_id: &str) -> Result<(), DynError>

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

Trait Implementations

impl ComposeSchema for UserCounts

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

impl Debug for UserCounts

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

Formats the value using the given formatter.

impl Default for UserCounts

fn default() -> UserCounts

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for UserCounts

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl RedisOps for UserCounts

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 UserCounts

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 UserCounts

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.