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