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     # topic, subject, salmon, subscribe_address, uri
  24   end
  25
  26   def set_activation_status(info, deactivated) do
  27     params = %{deactivated: deactivated}
  28
  29     info
  30     |> cast(params, [:deactivated])
  31     |> validate_required([:deactivated])
  32   end
  33
  34   def add_to_note_count(info, number) do
  35     set_note_count(info, info.note_count + number)
  36   end
  37
  38   def set_note_count(info, number) do
  39     params = %{note_count: Enum.max([0, number])}
  40
  41     info
  42     |> cast(params, [:note_count])
  43     |> validate_required([:note_count])
  44   end
  45
  46   def set_follower_count(info, number) do
  47     params = %{follower_count: Enum.max([0, number])}
  48
  49     info
  50     |> cast(params, [:follower_count])
  51     |> validate_required([:follower_count])
  52   end
  53
  54   def set_blocks(info, blocks) do
  55     params = %{blocks: blocks}
  56
  57     info
  58     |> cast(params, [:blocks])
  59     |> validate_required([:blocks])
  60   end
  61
  62   def add_to_block(info, blocked) do
  63     set_blocks(info, Enum.uniq([blocked | info.blocks]))
  64   end
  65
  66   def remove_from_block(info, blocked) do
  67     set_blocks(info, List.delete(info.blocks, blocked))
  68   end
  69
  70   def set_domain_blocks(info, domain_blocks) do
  71     params = %{domain_blocks: domain_blocks}
  72
  73     info
  74     |> cast(params, [:domain_blocks])
  75     |> validate_required([:domain_blocks])
  76   end
  77
  78   def add_to_domain_block(info, domain_blocked) do
  79     set_domain_blocks(info, Enum.uniq([domain_blocked | info.domain_blocks]))
  80   end
  81
  82   def remove_from_domain_block(info, domain_blocked) do
  83     set_domain_blocks(info, List.delete(info.domain_blocks, domain_blocked))
  84   end
  85
  86   def set_keys(info, keys) do
  87     params = %{keys: keys}
  88
  89     info
  90     |> cast(params, [:keys])
  91     |> validate_required([:keys])
  92   end
  93
  94   def remote_user_creation(info, params) do
  95     info
  96     |> cast(params, [
  97       :ap_enabled,
  98       :source_data,
  99       :banner,
 100       :locked,
 101       :magic_key,
 102       :uri
 103     ])
 104   end
 105
 106   def user_upgrade(info, params) do
 107     info
 108     |> cast(params, [
 109       :ap_enabled,
 110       :source_data,
 111       :banner,
 112       :locked,
 113       :magic_key
 114     ])
 115   end
 116
 117   def set_source_data(info, source_data) do
 118     params = %{source_data: source_data}
 119
 120     info
 121     |> cast(params, [:source_data])
 122     |> validate_required([:source_data])
 123   end
 124 end