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