git.squeep.com Git - akkoma/blob - lib/pleroma/conversation/participation.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.Conversation.Participation do
   6   use Ecto.Schema
   7   alias Pleroma.Conversation
   8   alias Pleroma.Conversation.Participation.RecipientShip
   9   alias Pleroma.Repo
  10   alias Pleroma.User
  11   alias Pleroma.Web.ActivityPub.ActivityPub
  12   import Ecto.Changeset
  13   import Ecto.Query
  14
  15   schema "conversation_participations" do
  16     belongs_to(:user, User, type: FlakeId.Ecto.CompatType)
  17     belongs_to(:conversation, Conversation)
  18     field(:read, :boolean, default: false)
  19     field(:last_activity_id, FlakeId.Ecto.CompatType, virtual: true)
  20
  21     has_many(:recipient_ships, RecipientShip)
  22     has_many(:recipients, through: [:recipient_ships, :user])
  23
  24     timestamps()
  25   end
  26
  27   def creation_cng(struct, params) do
  28     struct
  29     |> cast(params, [:user_id, :conversation_id, :read])
  30     |> validate_required([:user_id, :conversation_id])
  31   end
  32
  33   def create_for_user_and_conversation(user, conversation, opts \\ []) do
  34     read = !!opts[:read]
  35
  36     %__MODULE__{}
  37     |> creation_cng(%{user_id: user.id, conversation_id: conversation.id, read: read})
  38     |> Repo.insert(
  39       on_conflict: [set: [read: read, updated_at: NaiveDateTime.utc_now()]],
  40       returning: true,
  41       conflict_target: [:user_id, :conversation_id]
  42     )
  43   end
  44
  45   def read_cng(struct, params) do
  46     struct
  47     |> cast(params, [:read])
  48     |> validate_required([:read])
  49   end
  50
  51   def mark_as_read(%User{} = user, %Conversation{} = conversation) do
  52     with %__MODULE__{} = participation <- for_user_and_conversation(user, conversation) do
  53       mark_as_read(participation)
  54     end
  55   end
  56
  57   def mark_as_read(participation) do
  58     participation
  59     |> read_cng(%{read: true})
  60     |> Repo.update()
  61     |> case do
  62       {:ok, participation} ->
  63         participation = Repo.preload(participation, :user)
  64         User.set_unread_conversation_count(participation.user)
  65         {:ok, participation}
  66
  67       error ->
  68         error
  69     end
  70   end
  71
  72   def mark_as_unread(participation) do
  73     participation
  74     |> read_cng(%{read: false})
  75     |> Repo.update()
  76   end
  77
  78   def for_user(user, params \\ %{}) do
  79     from(p in __MODULE__,
  80       where: p.user_id == ^user.id,
  81       order_by: [desc: p.updated_at],
  82       preload: [conversation: [:users]]
  83     )
  84     |> Pleroma.Pagination.fetch_paginated(params)
  85   end
  86
  87   def for_user_and_conversation(user, conversation) do
  88     from(p in __MODULE__,
  89       where: p.user_id == ^user.id,
  90       where: p.conversation_id == ^conversation.id
  91     )
  92     |> Repo.one()
  93   end
  94
  95   def for_user_with_last_activity_id(user, params \\ %{}) do
  96     for_user(user, params)
  97     |> Enum.map(fn participation ->
  98       activity_id =
  99         ActivityPub.fetch_latest_activity_id_for_context(participation.conversation.ap_id, %{
 100           "user" => user,
 101           "blocking_user" => user
 102         })
 103
 104       %{
 105         participation
 106         | last_activity_id: activity_id
 107       }
 108     end)
 109     |> Enum.filter(& &1.last_activity_id)
 110   end
 111
 112   def get(_, _ \\ [])
 113   def get(nil, _), do: nil
 114
 115   def get(id, params) do
 116     query =
 117       if preload = params[:preload] do
 118         from(p in __MODULE__,
 119           preload: ^preload
 120         )
 121       else
 122         __MODULE__
 123       end
 124
 125     Repo.get(query, id)
 126   end
 127
 128   def set_recipients(participation, user_ids) do
 129     user_ids =
 130       [participation.user_id | user_ids]
 131       |> Enum.uniq()
 132
 133     Repo.transaction(fn ->
 134       query =
 135         from(r in RecipientShip,
 136           where: r.participation_id == ^participation.id
 137         )
 138
 139       Repo.delete_all(query)
 140
 141       users =
 142         from(u in User,
 143           where: u.id in ^user_ids
 144         )
 145         |> Repo.all()
 146
 147       RecipientShip.create(users, participation)
 148       :ok
 149     end)
 150
 151     {:ok, Repo.preload(participation, :recipients, force: true)}
 152   end
 153
 154   def unread_conversation_count_for_user(user) do
 155     from(p in __MODULE__,
 156       where: p.user_id == ^user.id,
 157       where: not p.read,
 158       select: %{count: count(p.id)}
 159     )
 160   end
 161 end