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

   1 defmodule Pleroma.User.Info do
   2   use Ecto.Schema
   3   import Ecto.Changeset
   4
   5   embedded_schema do
   6     field(:banner, :map, default: %{})
   7     field(:background, :string, default: nil)
   8     field(:source_data, :map, default: %{})
   9     field(:note_count, :integer, default: 0)
  10     field(:follower_count, :integer, default: 0)
  11     field(:locked, :boolean, default: false)
  12     field(:default_scope, :string, default: "public")
  13     field(:blocks, {:array, :string}, default: [])
  14     field(:domain_blocks, {:array, :string}, default: [])
  15     field(:deactivated, :boolean, default: false)
  16     field(:no_rich_text, :boolean, default: false)
  17     field(:ap_enabled, :boolean, default: false)
  18     field(:is_moderator, :boolean, default: false)
  19     field(:keys, :string, default: nil)
  20     field(:settings, :map, default: nil)
  21     field(:magic_key, :string, default: nil)
  22     field(:uri, :string, default: nil)
  23     field(:topic, :string, default: nil)
  24     field(:hub, :string, default: nil)
  25     # topic, subject, salmon, subscribe_address, uri
  26   end
  27
  28   def set_activation_status(info, deactivated) do
  29     params = %{deactivated: deactivated}
  30
  31     info
  32     |> cast(params, [:deactivated])
  33     |> validate_required([:deactivated])
  34   end
  35
  36   def add_to_note_count(info, number) do
  37     set_note_count(info, info.note_count + number)
  38   end
  39
  40   def set_note_count(info, number) do
  41     params = %{note_count: Enum.max([0, number])}
  42
  43     info
  44     |> cast(params, [:note_count])
  45     |> validate_required([:note_count])
  46   end
  47
  48   def set_follower_count(info, number) do
  49     params = %{follower_count: Enum.max([0, number])}
  50
  51     info
  52     |> cast(params, [:follower_count])
  53     |> validate_required([:follower_count])
  54   end
  55
  56   def set_blocks(info, blocks) do
  57     params = %{blocks: blocks}
  58
  59     info
  60     |> cast(params, [:blocks])
  61     |> validate_required([:blocks])
  62   end
  63
  64   def add_to_block(info, blocked) do
  65     set_blocks(info, Enum.uniq([blocked | info.blocks]))
  66   end
  67
  68   def remove_from_block(info, blocked) do
  69     set_blocks(info, List.delete(info.blocks, blocked))
  70   end
  71
  72   def set_domain_blocks(info, domain_blocks) do
  73     params = %{domain_blocks: domain_blocks}
  74
  75     info
  76     |> cast(params, [:domain_blocks])
  77     |> validate_required([:domain_blocks])
  78   end
  79
  80   def add_to_domain_block(info, domain_blocked) do
  81     set_domain_blocks(info, Enum.uniq([domain_blocked | info.domain_blocks]))
  82   end
  83
  84   def remove_from_domain_block(info, domain_blocked) do
  85     set_domain_blocks(info, List.delete(info.domain_blocks, domain_blocked))
  86   end
  87
  88   def set_keys(info, keys) do
  89     params = %{keys: keys}
  90
  91     info
  92     |> cast(params, [:keys])
  93     |> validate_required([:keys])
  94   end
  95
  96   def remote_user_creation(info, params) do
  97     info
  98     |> cast(params, [
  99       :ap_enabled,
 100       :source_data,
 101       :banner,
 102       :locked,
 103       :magic_key,
 104       :uri,
 105       :hub,
 106       :topic
 107     ])
 108   end
 109
 110   def user_upgrade(info, params) do
 111     info
 112     |> cast(params, [
 113       :ap_enabled,
 114       :source_data,
 115       :banner,
 116       :locked,
 117       :magic_key
 118     ])
 119   end
 120
 121   def profile_update(info, params) do
 122     info
 123     |> cast(params, [
 124       :locked,
 125       :no_rich_text,
 126       :default_scope
 127     ])
 128   end
 129
 130   def set_source_data(info, source_data) do
 131     params = %{source_data: source_data}
 132
 133     info
 134     |> cast(params, [:source_data])
 135     |> validate_required([:source_data])
 136   end
 137 end