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   embedded_schema do
  10     field(:banner, :map, default: %{})
  11     field(:background, :map, default: %{})
  12     field(:source_data, :map, default: %{})
  13     field(:note_count, :integer, default: 0)
  14     field(:follower_count, :integer, default: 0)
  15     field(:locked, :boolean, default: false)
  16     field(:confirmation_pending, :boolean, default: false)
  17     field(:confirmation_token, :string, default: nil)
  18     field(:default_scope, :string, default: "public")
  19     field(:blocks, {:array, :string}, default: [])
  20     field(:domain_blocks, {:array, :string}, default: [])
  21     field(:deactivated, :boolean, default: false)
  22     field(:no_rich_text, :boolean, default: false)
  23     field(:ap_enabled, :boolean, default: false)
  24     field(:is_moderator, :boolean, default: false)
  25     field(:is_admin, :boolean, default: false)
  26     field(:keys, :string, default: nil)
  27     field(:settings, :map, default: nil)
  28     field(:magic_key, :string, default: nil)
  29     field(:uri, :string, default: nil)
  30     field(:topic, :string, default: nil)
  31     field(:hub, :string, default: nil)
  32     field(:salmon, :string, default: nil)
  33     field(:hide_network, :boolean, default: false)
  34     field(:pinned_activities, {:array, :string}, default: [])
  35
  36     # Found in the wild
  37     # ap_id -> Where is this used?
  38     # bio -> Where is this used?
  39     # avatar -> Where is this used?
  40     # fqn -> Where is this used?
  41     # host -> Where is this used?
  42     # subject _> Where is this used?
  43   end
  44
  45   def set_activation_status(info, deactivated) do
  46     params = %{deactivated: deactivated}
  47
  48     info
  49     |> cast(params, [:deactivated])
  50     |> validate_required([:deactivated])
  51   end
  52
  53   def add_to_note_count(info, number) do
  54     set_note_count(info, info.note_count + number)
  55   end
  56
  57   def set_note_count(info, number) do
  58     params = %{note_count: Enum.max([0, number])}
  59
  60     info
  61     |> cast(params, [:note_count])
  62     |> validate_required([:note_count])
  63   end
  64
  65   def set_follower_count(info, number) do
  66     params = %{follower_count: Enum.max([0, number])}
  67
  68     info
  69     |> cast(params, [:follower_count])
  70     |> validate_required([:follower_count])
  71   end
  72
  73   def set_blocks(info, blocks) do
  74     params = %{blocks: blocks}
  75
  76     info
  77     |> cast(params, [:blocks])
  78     |> validate_required([:blocks])
  79   end
  80
  81   def add_to_block(info, blocked) do
  82     set_blocks(info, Enum.uniq([blocked | info.blocks]))
  83   end
  84
  85   def remove_from_block(info, blocked) do
  86     set_blocks(info, List.delete(info.blocks, blocked))
  87   end
  88
  89   def set_domain_blocks(info, domain_blocks) do
  90     params = %{domain_blocks: domain_blocks}
  91
  92     info
  93     |> cast(params, [:domain_blocks])
  94     |> validate_required([:domain_blocks])
  95   end
  96
  97   def add_to_domain_block(info, domain_blocked) do
  98     set_domain_blocks(info, Enum.uniq([domain_blocked | info.domain_blocks]))
  99   end
 100
 101   def remove_from_domain_block(info, domain_blocked) do
 102     set_domain_blocks(info, List.delete(info.domain_blocks, domain_blocked))
 103   end
 104
 105   def set_keys(info, keys) do
 106     params = %{keys: keys}
 107
 108     info
 109     |> cast(params, [:keys])
 110     |> validate_required([:keys])
 111   end
 112
 113   def remote_user_creation(info, params) do
 114     info
 115     |> cast(params, [
 116       :ap_enabled,
 117       :source_data,
 118       :banner,
 119       :locked,
 120       :magic_key,
 121       :uri,
 122       :hub,
 123       :topic,
 124       :salmon
 125     ])
 126   end
 127
 128   def user_upgrade(info, params) do
 129     info
 130     |> cast(params, [
 131       :ap_enabled,
 132       :source_data,
 133       :banner,
 134       :locked,
 135       :magic_key
 136     ])
 137   end
 138
 139   def profile_update(info, params) do
 140     info
 141     |> cast(params, [
 142       :locked,
 143       :no_rich_text,
 144       :default_scope,
 145       :banner,
 146       :hide_network,
 147       :background
 148     ])
 149   end
 150
 151   def confirmation_changeset(info, :confirmed) do
 152     confirmation_changeset(info, %{
 153       confirmation_pending: false,
 154       confirmation_token: nil
 155     })
 156   end
 157
 158   def confirmation_changeset(info, :unconfirmed) do
 159     confirmation_changeset(info, %{
 160       confirmation_pending: true,
 161       confirmation_token: :crypto.strong_rand_bytes(32) |> Base.url_encode64()
 162     })
 163   end
 164
 165   def confirmation_changeset(info, params) do
 166     cast(info, params, [:confirmation_pending, :confirmation_token])
 167   end
 168
 169   def mastodon_profile_update(info, params) do
 170     info
 171     |> cast(params, [
 172       :locked,
 173       :banner
 174     ])
 175   end
 176
 177   def mastodon_settings_update(info, settings) do
 178     params = %{settings: settings}
 179
 180     info
 181     |> cast(params, [:settings])
 182     |> validate_required([:settings])
 183   end
 184
 185   def set_source_data(info, source_data) do
 186     params = %{source_data: source_data}
 187
 188     info
 189     |> cast(params, [:source_data])
 190     |> validate_required([:source_data])
 191   end
 192
 193   def admin_api_update(info, params) do
 194     info
 195     |> cast(params, [
 196       :is_moderator,
 197       :is_admin
 198     ])
 199   end
 200
 201   def add_pinnned_activity(info, %Pleroma.Activity{id: id}) do
 202     if id not in info.pinned_activities do
 203       max_pinned_statuses = Pleroma.Config.get([:instance, :max_pinned_statuses], 0)
 204       params = %{pinned_activities: info.pinned_activities ++ [id]}
 205
 206       info
 207       |> cast(params, [:pinned_activities])
 208       |> validate_length(:pinned_activities,
 209         max: max_pinned_statuses,
 210         message: "You have already pinned the maximum number of statuses"
 211       )
 212     else
 213       change(info)
 214     end
 215   end
 216
 217   def remove_pinnned_activity(info, %Pleroma.Activity{id: id}) do
 218     params = %{pinned_activities: List.delete(info.pinned_activities, id)}
 219
 220     cast(info, params, [:pinned_activities])
 221   end
 222 end