Pleroma v1.1.9-10-g42f76306+dev Pleroma.User View Source

The function returns a query to get users with no activity for given interval of days. Inactive users are those who didn't read any notification, or had any activity where the user is the activity's actor, during inactivity_threshold days. Deactivated users will not appear in this list.

local_nickname(nickname_or_mention)

locked?(user)

maybe_direct_follow(follower, followed)

maybe_fetch_follow_information(user)

maybe_update_following_count(user)

mute(muter, user, notifications? \\ true)

muted_notifications?(user, arg2)

muted_users(user)

mutes?(user, arg2)

needs_update?(user)

parse_bio(bio)

parse_bio(bio, user)

password_update_changeset(struct, params)

perform(atom, user)

perform(atom, user, status)

post_register_action(user)

profile_url(arg1)

public_key_from_info(arg1)

Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)

register_changeset(struct, params \\ %{}, opts \\ [])

remote_user_creation(params)

remove_duplicated_following(user)

reset_password(user, data)

restrict_deactivated(query)

search(query, opts \\ [])

See Pleroma.User.Search.search/2.

set_cache(user)

set_follow_state_cache(user_ap_id, target_ap_id, state)

set_info_cache(user, args)

showing_reblogs?(user, target)

subscribe(subscriber, map)

subscribed_to?(user, map)

subscribers(user)

superuser?(arg1)

switch_email_notifications(user, type, status)

Enable or disable email notifications for user

tag(user_identifiers, tags)

toggle_confirmation(user)

touch_last_digest_emailed_at(user)

Set last_digest_emailed_at value for the user to current time

try_send_confirmation_email(user)

unblock(blocker, map)

unblock_domain(user, domain)

unfollow(follower, followed)

unmute(muter, map)

unsubscribe(unsubscriber, map)

untag(user_identifiers, tags)

update_and_set_cache(changeset)

update_changeset(struct, params \\ %{})

update_follower_count(user)

update_note_count(user)

update_notification_settings(user, settings \\ %{})

upgrade_changeset(struct, params \\ %{}, remote? \\ false)

user_info(user, args \\ %{})

visible_for?(user, for_user \\ nil)

wait_and_refresh(timeout, a, b)

Link to this section Types

t()

t() :: %Pleroma.User{
  __meta__: term(),
  ap_id: term(),
  avatar: term(),
  bio: term(),
  email: term(),
  follower_address: term(),
  following: term(),
  following_address: term(),
  id: term(),
  info: term(),
  inserted_at: term(),
  keys: term(),
  last_digest_emailed_at: term(),
  last_refreshed_at: term(),
  local: term(),
  name: term(),
  nickname: term(),
  notifications: term(),
  password: term(),
  password_confirmation: term(),
  password_hash: term(),
  registrations: term(),
  search_rank: term(),
  search_type: term(),
  tags: term(),
  updated_at: term()
}

Link to this section Functions

all_superusers()

all_superusers() :: [Pleroma.User.t()]

ap_enabled?(arg1)

ap_followers(user)

ap_following(user)

ap_following(Pleroma.User.t()) :: Sring.t()

ap_id(user)

auth_active?(user)

avatar_url(user, options \\ [])

banner_url(user, options \\ [])

block(blocker, blocked)

block_domain(user, domain)

blocked_users(user)

blocked_users(Pleroma.User.t()) :: [Pleroma.User.t()]

blocks?(user, target)

blocks_ap_id?(user, target)

blocks_domain?(user, target)

blocks_import(blocker, blocked_identifiers)

change_email(user, email)

deactivate(user, status \\ true)

deactivate_async(user, status \\ true)

decrease_note_count(user)

delete(user)

delete(Pleroma.User.t()) :: :ok

delete_user_activities(user)

ensure_keys_present(user)

error_user(ap_id)

external_users(opts \\ [])

external_users(keyword()) :: [Pleroma.User.t()]

external_users_query()

external_users_query() :: Ecto.Query.t()

fetch_by_ap_id(ap_id)

fetch_by_nickname(nickname)

fetch_follow_information(user)

fetch_initial_posts(user)

Fetch some posts when the user has just been federated with

follow(follower, followed)

follow_all(follower, followeds)

follow_all(Pleroma.User.t(), [Pleroma.User.t()]) :: {atom(), Pleroma.User.t()}

A mass follow for local users. Respects blocks in both directions but does not create activities.

follow_import(follower, followed_identifiers)

follow_state(user, target)

following?(follower, followed)

following?(Pleroma.User.t(), Pleroma.User.t()) :: boolean()

following_count(user)

full_nickname(nickname_or_mention)

get_all_by_ap_id(ap_ids)

get_ap_ids_by_nicknames(nicknames)

get_by_ap_id(ap_id)

get_by_email(email)

get_by_guessed_nickname(ap_id)

get_by_id(id)

get_by_nickname(nickname)

get_by_nickname_or_email(nickname_or_email)

get_cached_by_ap_id(ap_id)

get_cached_by_id(id)

get_cached_by_nickname(nickname)

get_cached_by_nickname_or_id(nickname_or_id, opts \\ [])

get_cached_follow_state(user, target)

get_cached_user_info(user)

get_external_followers(user, page \\ nil)

get_external_followers(Pleroma.User.t(), pos_integer()) ::
  {:ok, [Pleroma.User.t()]}

get_follow_requests(user)

get_follow_requests(Pleroma.User.t()) :: {:ok, [Pleroma.User.t()]}

get_followers(user, page \\ nil)

get_followers(Pleroma.User.t(), pos_integer()) :: {:ok, [Pleroma.User.t()]}

get_followers_ids(user, page \\ nil)

get_followers_query(user)

get_followers_query(Pleroma.User.t()) :: Ecto.Query.t()

get_followers_query(user, page)

get_followers_query(Pleroma.User.t(), pos_integer() | nil) :: Ecto.Query.t()

get_friends(user, page \\ nil)

get_friends_ids(user, page \\ nil)

get_friends_query(user)

get_friends_query(Pleroma.User.t()) :: Ecto.Query.t()

get_friends_query(user, page)

get_friends_query(Pleroma.User.t(), pos_integer() | nil) :: Ecto.Query.t()

get_mascot(map)

get_or_create_service_actor_by_ap_id(uri, nickname \\ nil)

Creates an internal service actor by URI if missing. Optionally takes nickname for addressing.

get_or_fetch(uri)

get_or_fetch(String.t()) :: {:ok, Pleroma.User.t()} | {:error, String.t()}

Gets or fetch a user by uri or nickname.

get_or_fetch_by_ap_id(ap_id)

get_or_fetch_by_nickname(nickname)

get_public_key_for_ap_id(ap_id)

get_recipients_from_activity(activity)

get_recipients_from_activity(Pleroma.Activity.t()) :: [Pleroma.User.t()]

get_users_from_set(ap_ids, local_only \\ true)

get_users_from_set([String.t()], boolean()) :: [Pleroma.User.t()]

html_filter_policy(arg1)

increase_note_count(user)

insert_or_update_user(data)

invalidate_cache(user)

is_internal_user?(arg1)

list_inactive_users_query(inactivity_threshold \\ 7)

list_inactive_users_query(integer()) :: Ecto.Query.t()

Examples

iex> Pleroma.User.list_inactive_users()
%Ecto.Query{}