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(participation) do
  52     participation
  53     |> read_cng(%{read: true})
  54     |> Repo.update()
  55     |> case do
  56       {:ok, participation} ->
  57         participation = Repo.preload(participation, :user)
  58         User.set_unread_conversation_count(participation.user)
  59         {:ok, participation}
  60
  61       error ->
  62         error
  63     end
  64   end
  65
  66   def mark_as_unread(participation) do
  67     participation
  68     |> read_cng(%{read: false})
  69     |> Repo.update()
  70   end
  71
  72   def for_user(user, params \\ %{}) do
  73     from(p in __MODULE__,
  74       where: p.user_id == ^user.id,
  75       order_by: [desc: p.updated_at],
  76       preload: [conversation: [:users]]
  77     )
  78     |> Pleroma.Pagination.fetch_paginated(params)
  79   end
  80
  81   def for_user_and_conversation(user, conversation) do
  82     from(p in __MODULE__,
  83       where: p.user_id == ^user.id,
  84       where: p.conversation_id == ^conversation.id
  85     )
  86     |> Repo.one()
  87   end
  88
  89   def for_user_with_last_activity_id(user, params \\ %{}) do
  90     for_user(user, params)
  91     |> Enum.map(fn participation ->
  92       activity_id =
  93         ActivityPub.fetch_latest_activity_id_for_context(participation.conversation.ap_id, %{
  94           "user" => user,
  95           "blocking_user" => user
  96         })
  97
  98       %{
  99         participation
 100         | last_activity_id: activity_id
 101       }
 102     end)
 103     |> Enum.filter(& &1.last_activity_id)
 104   end
 105
 106   def get(_, _ \\ [])
 107   def get(nil, _), do: nil
 108
 109   def get(id, params) do
 110     query =
 111       if preload = params[:preload] do
 112         from(p in __MODULE__,
 113           preload: ^preload
 114         )
 115       else
 116         __MODULE__
 117       end
 118
 119     Repo.get(query, id)
 120   end
 121
 122   def set_recipients(participation, user_ids) do
 123     user_ids =
 124       [participation.user_id | user_ids]
 125       |> Enum.uniq()
 126
 127     Repo.transaction(fn ->
 128       query =
 129         from(r in RecipientShip,
 130           where: r.participation_id == ^participation.id
 131         )
 132
 133       Repo.delete_all(query)
 134
 135       users =
 136         from(u in User,
 137           where: u.id in ^user_ids
 138         )
 139         |> Repo.all()
 140
 141       RecipientShip.create(users, participation)
 142       :ok
 143     end)
 144
 145     {:ok, Repo.preload(participation, :recipients, force: true)}
 146   end
 147
 148   def unread_conversation_count_for_user(user) do
 149     from(p in __MODULE__,
 150       where: p.user_id == ^user.id,
 151       where: not p.read,
 152       select: %{count: count(p.id)}
 153     )
 154   end
 155 end