git.squeep.com Git - akkoma/blob - lib/pleroma/user/info.ex

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.User.Info do
   6   use Ecto.Schema
   7   import Ecto.Changeset
   8
   9   alias Pleroma.User.Info
  10
  11   @type t :: %__MODULE__{}
  12
  13   embedded_schema do
  14     field(:banner, :map, default: %{})
  15     field(:background, :map, default: %{})
  16     field(:source_data, :map, default: %{})
  17     field(:note_count, :integer, default: 0)
  18     field(:follower_count, :integer, default: 0)
  19     field(:locked, :boolean, default: false)
  20     field(:confirmation_pending, :boolean, default: false)
  21     field(:confirmation_token, :string, default: nil)
  22     field(:default_scope, :string, default: "public")
  23     field(:blocks, {:array, :string}, default: [])
  24     field(:domain_blocks, {:array, :string}, default: [])
  25     field(:mutes, {:array, :string}, default: [])
  26     field(:muted_reblogs, {:array, :string}, default: [])
  27     field(:subscribers, {:array, :string}, default: [])
  28     field(:deactivated, :boolean, default: false)
  29     field(:no_rich_text, :boolean, default: false)
  30     field(:ap_enabled, :boolean, default: false)
  31     field(:is_moderator, :boolean, default: false)
  32     field(:is_admin, :boolean, default: false)
  33     field(:show_role, :boolean, default: true)
  34     field(:keys, :string, default: nil)
  35     field(:settings, :map, default: nil)
  36     field(:magic_key, :string, default: nil)
  37     field(:uri, :string, default: nil)
  38     field(:topic, :string, default: nil)
  39     field(:hub, :string, default: nil)
  40     field(:salmon, :string, default: nil)
  41     field(:hide_followers, :boolean, default: false)
  42     field(:hide_follows, :boolean, default: false)
  43     field(:hide_favorites, :boolean, default: true)
  44     field(:pinned_activities, {:array, :string}, default: [])
  45     field(:flavour, :string, default: nil)
  46     field(:email_notifications, :map, default: %{"digest" => false})
  47     field(:mascot, :map, default: nil)
  48     field(:emoji, {:array, :map}, default: [])
  49
  50     field(:notification_settings, :map,
  51       default: %{"remote" => true, "local" => true, "followers" => true, "follows" => true}
  52     )
  53
  54     # Found in the wild
  55     # ap_id -> Where is this used?
  56     # bio -> Where is this used?
  57     # avatar -> Where is this used?
  58     # fqn -> Where is this used?
  59     # host -> Where is this used?
  60     # subject _> Where is this used?
  61   end
  62
  63   def set_activation_status(info, deactivated) do
  64     params = %{deactivated: deactivated}
  65
  66     info
  67     |> cast(params, [:deactivated])
  68     |> validate_required([:deactivated])
  69   end
  70
  71   def update_notification_settings(info, settings) do
  72     notification_settings =
  73       info.notification_settings
  74       |> Map.merge(settings)
  75       |> Map.take(["remote", "local", "followers", "follows"])
  76
  77     params = %{notification_settings: notification_settings}
  78
  79     info
  80     |> cast(params, [:notification_settings])
  81     |> validate_required([:notification_settings])
  82   end
  83
  84   @doc """
  85   Update email notifications in the given User.Info struct.
  86
  87   Examples:
  88
  89       iex> update_email_notifications(%Pleroma.User.Info{email_notifications: %{"digest" => false}}, %{"digest" => true})
  90       %Pleroma.User.Info{email_notifications: %{"digest" => true}}
  91
  92   """
  93   @spec update_email_notifications(t(), map()) :: Ecto.Changeset.t()
  94   def update_email_notifications(info, settings) do
  95     email_notifications =
  96       info.email_notifications
  97       |> Map.merge(settings)
  98       |> Map.take(["digest"])
  99
 100     params = %{email_notifications: email_notifications}
 101     fields = [:email_notifications]
 102
 103     info
 104     |> cast(params, fields)
 105     |> validate_required(fields)
 106   end
 107
 108   def add_to_note_count(info, number) do
 109     set_note_count(info, info.note_count + number)
 110   end
 111
 112   def set_note_count(info, number) do
 113     params = %{note_count: Enum.max([0, number])}
 114
 115     info
 116     |> cast(params, [:note_count])
 117     |> validate_required([:note_count])
 118   end
 119
 120   def set_follower_count(info, number) do
 121     params = %{follower_count: Enum.max([0, number])}
 122
 123     info
 124     |> cast(params, [:follower_count])
 125     |> validate_required([:follower_count])
 126   end
 127
 128   def set_mutes(info, mutes) do
 129     params = %{mutes: mutes}
 130
 131     info
 132     |> cast(params, [:mutes])
 133     |> validate_required([:mutes])
 134   end
 135
 136   def set_blocks(info, blocks) do
 137     params = %{blocks: blocks}
 138
 139     info
 140     |> cast(params, [:blocks])
 141     |> validate_required([:blocks])
 142   end
 143
 144   def set_subscribers(info, subscribers) do
 145     params = %{subscribers: subscribers}
 146
 147     info
 148     |> cast(params, [:subscribers])
 149     |> validate_required([:subscribers])
 150   end
 151
 152   def add_to_mutes(info, muted) do
 153     set_mutes(info, Enum.uniq([muted | info.mutes]))
 154   end
 155
 156   def remove_from_mutes(info, muted) do
 157     set_mutes(info, List.delete(info.mutes, muted))
 158   end
 159
 160   def add_to_block(info, blocked) do
 161     set_blocks(info, Enum.uniq([blocked | info.blocks]))
 162   end
 163
 164   def remove_from_block(info, blocked) do
 165     set_blocks(info, List.delete(info.blocks, blocked))
 166   end
 167
 168   def add_to_subscribers(info, subscribed) do
 169     set_subscribers(info, Enum.uniq([subscribed | info.subscribers]))
 170   end
 171
 172   def remove_from_subscribers(info, subscribed) do
 173     set_subscribers(info, List.delete(info.subscribers, subscribed))
 174   end
 175
 176   def set_domain_blocks(info, domain_blocks) do
 177     params = %{domain_blocks: domain_blocks}
 178
 179     info
 180     |> cast(params, [:domain_blocks])
 181     |> validate_required([:domain_blocks])
 182   end
 183
 184   def add_to_domain_block(info, domain_blocked) do
 185     set_domain_blocks(info, Enum.uniq([domain_blocked | info.domain_blocks]))
 186   end
 187
 188   def remove_from_domain_block(info, domain_blocked) do
 189     set_domain_blocks(info, List.delete(info.domain_blocks, domain_blocked))
 190   end
 191
 192   def set_keys(info, keys) do
 193     params = %{keys: keys}
 194
 195     info
 196     |> cast(params, [:keys])
 197     |> validate_required([:keys])
 198   end
 199
 200   def remote_user_creation(info, params) do
 201     info
 202     |> cast(params, [
 203       :ap_enabled,
 204       :source_data,
 205       :banner,
 206       :locked,
 207       :magic_key,
 208       :uri,
 209       :hub,
 210       :topic,
 211       :salmon
 212     ])
 213   end
 214
 215   def user_upgrade(info, params) do
 216     info
 217     |> cast(params, [
 218       :ap_enabled,
 219       :source_data,
 220       :banner,
 221       :locked,
 222       :magic_key
 223     ])
 224   end
 225
 226   def profile_update(info, params) do
 227     info
 228     |> cast(params, [
 229       :locked,
 230       :no_rich_text,
 231       :default_scope,
 232       :banner,
 233       :hide_follows,
 234       :hide_followers,
 235       :hide_favorites,
 236       :background,
 237       :show_role
 238     ])
 239   end
 240
 241   @spec confirmation_changeset(Info.t(), keyword()) :: Changeset.t()
 242   def confirmation_changeset(info, opts) do
 243     need_confirmation? = Keyword.get(opts, :need_confirmation)
 244
 245     params =
 246       if need_confirmation? do
 247         %{
 248           confirmation_pending: true,
 249           confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
 250         }
 251       else
 252         %{
 253           confirmation_pending: false,
 254           confirmation_token: nil
 255         }
 256       end
 257
 258     cast(info, params, [:confirmation_pending, :confirmation_token])
 259   end
 260
 261   def mastodon_settings_update(info, settings) do
 262     params = %{settings: settings}
 263
 264     info
 265     |> cast(params, [:settings])
 266     |> validate_required([:settings])
 267   end
 268
 269   def mastodon_flavour_update(info, flavour) do
 270     params = %{flavour: flavour}
 271
 272     info
 273     |> cast(params, [:flavour])
 274     |> validate_required([:flavour])
 275   end
 276
 277   def mascot_update(info, url) do
 278     params = %{mascot: url}
 279
 280     info
 281     |> cast(params, [:mascot])
 282     |> validate_required([:mascot])
 283   end
 284
 285   def set_source_data(info, source_data) do
 286     params = %{source_data: source_data}
 287
 288     info
 289     |> cast(params, [:source_data])
 290     |> validate_required([:source_data])
 291   end
 292
 293   def admin_api_update(info, params) do
 294     info
 295     |> cast(params, [
 296       :is_moderator,
 297       :is_admin,
 298       :show_role
 299     ])
 300   end
 301
 302   def add_pinnned_activity(info, %Pleroma.Activity{id: id}) do
 303     if id not in info.pinned_activities do
 304       max_pinned_statuses = Pleroma.Config.get([:instance, :max_pinned_statuses], 0)
 305       params = %{pinned_activities: info.pinned_activities ++ [id]}
 306
 307       info
 308       |> cast(params, [:pinned_activities])
 309       |> validate_length(:pinned_activities,
 310         max: max_pinned_statuses,
 311         message: "You have already pinned the maximum number of statuses"
 312       )
 313     else
 314       change(info)
 315     end
 316   end
 317
 318   def remove_pinnned_activity(info, %Pleroma.Activity{id: id}) do
 319     params = %{pinned_activities: List.delete(info.pinned_activities, id)}
 320
 321     cast(info, params, [:pinned_activities])
 322   end
 323
 324   def roles(%Info{is_moderator: is_moderator, is_admin: is_admin}) do
 325     %{
 326       admin: is_admin,
 327       moderator: is_moderator
 328     }
 329   end
 330
 331   def add_reblog_mute(info, ap_id) do
 332     params = %{muted_reblogs: info.muted_reblogs ++ [ap_id]}
 333
 334     cast(info, params, [:muted_reblogs])
 335   end
 336
 337   def remove_reblog_mute(info, ap_id) do
 338     params = %{muted_reblogs: List.delete(info.muted_reblogs, ap_id)}
 339
 340     cast(info, params, [:muted_reblogs])
 341   end
 342 end