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