mirror of
https://github.com/philomena-dev/philomena.git
synced 2025-02-13 17:34:23 +01:00
395 lines
9 KiB
Elixir
395 lines
9 KiB
Elixir
defmodule Philomena.Comments do
|
|
@moduledoc """
|
|
The Comments context.
|
|
"""
|
|
|
|
import Ecto.Query, warn: false
|
|
alias Ecto.Multi
|
|
alias Philomena.Repo
|
|
|
|
alias PhilomenaQuery.Search
|
|
alias Philomena.UserStatistics
|
|
alias Philomena.Users.User
|
|
alias Philomena.Comments.Comment
|
|
alias Philomena.Comments.SearchIndex, as: CommentIndex
|
|
alias Philomena.IndexWorker
|
|
alias Philomena.Images.Image
|
|
alias Philomena.Images
|
|
alias Philomena.Tags.Tag
|
|
alias Philomena.Notifications
|
|
alias Philomena.Versions
|
|
alias Philomena.Reports
|
|
|
|
@doc """
|
|
Gets a single comment.
|
|
|
|
Raises `Ecto.NoResultsError` if the Comment does not exist.
|
|
|
|
## Examples
|
|
|
|
iex> get_comment!(123)
|
|
%Comment{}
|
|
|
|
iex> get_comment!(456)
|
|
** (Ecto.NoResultsError)
|
|
|
|
"""
|
|
def get_comment!(id), do: Repo.get!(Comment, id)
|
|
|
|
@doc """
|
|
Creates a comment.
|
|
|
|
## Examples
|
|
|
|
iex> create_comment(%{field: value})
|
|
{:ok, %Comment{}}
|
|
|
|
iex> create_comment(%{field: bad_value})
|
|
{:error, %Ecto.Changeset{}}
|
|
|
|
"""
|
|
def create_comment(image, attribution, params \\ %{}) do
|
|
comment =
|
|
Ecto.build_assoc(image, :comments)
|
|
|> Comment.creation_changeset(params, attribution)
|
|
|
|
image_query =
|
|
Image
|
|
|> where(id: ^image.id)
|
|
|
|
image_lock_query =
|
|
lock(image_query, "FOR UPDATE")
|
|
|
|
Multi.new()
|
|
|> Multi.one(:image, image_lock_query)
|
|
|> Multi.insert(:comment, comment)
|
|
|> Multi.update_all(:update_image, image_query, inc: [comments_count: 1])
|
|
|> Multi.run(:notification, ¬ify_comment/2)
|
|
|> Images.maybe_subscribe_on(:image, attribution[:user], :watch_on_reply)
|
|
|> Repo.transaction()
|
|
end
|
|
|
|
defp notify_comment(_repo, %{image: image, comment: comment}) do
|
|
Notifications.create_image_comment_notification(comment.user, image, comment)
|
|
end
|
|
|
|
@doc """
|
|
Updates a comment.
|
|
|
|
## Examples
|
|
|
|
iex> update_comment(comment, %{field: new_value})
|
|
{:ok, %Comment{}}
|
|
|
|
iex> update_comment(comment, %{field: bad_value})
|
|
{:error, %Ecto.Changeset{}}
|
|
|
|
"""
|
|
def update_comment(%Comment{} = comment, editor, attrs) do
|
|
now = DateTime.utc_now(:second)
|
|
current_body = comment.body
|
|
current_reason = comment.edit_reason
|
|
|
|
comment_changes = Comment.changeset(comment, attrs, now)
|
|
|
|
Multi.new()
|
|
|> Multi.update(:comment, comment_changes)
|
|
|> Multi.run(:version, fn _repo, _changes ->
|
|
Versions.create_version("Comment", comment.id, editor.id, %{
|
|
"body" => current_body,
|
|
"edit_reason" => current_reason
|
|
})
|
|
end)
|
|
|> Repo.transaction()
|
|
end
|
|
|
|
@doc """
|
|
Deletes a Comment.
|
|
|
|
## Examples
|
|
|
|
iex> delete_comment(comment)
|
|
{:ok, %Comment{}}
|
|
|
|
iex> delete_comment(comment)
|
|
{:error, %Ecto.Changeset{}}
|
|
|
|
"""
|
|
def delete_comment(%Comment{} = comment) do
|
|
Repo.delete(comment)
|
|
end
|
|
|
|
@doc """
|
|
Hides a comment and handles associated reports.
|
|
|
|
## Parameters
|
|
- comment: The comment to hide
|
|
- attrs: Attributes for the hide operation
|
|
- user: The user performing the hide action
|
|
|
|
## Examples
|
|
|
|
iex> hide_comment(comment, %{staff_note: "Rule violation"}, user)
|
|
{:ok, %Comment{}}
|
|
|
|
"""
|
|
def hide_comment(%Comment{} = comment, attrs, user) do
|
|
report_query = Reports.close_report_query({"Comment", comment.id}, user)
|
|
comment = Comment.hide_changeset(comment, attrs, user)
|
|
|
|
Multi.new()
|
|
|> Multi.update(:comment, comment)
|
|
|> Multi.update_all(:reports, report_query, [])
|
|
|> Repo.transaction()
|
|
|> case do
|
|
{:ok, %{comment: comment, reports: {_count, reports}}} ->
|
|
Reports.reindex_reports(reports)
|
|
reindex_comment(comment)
|
|
|
|
{:ok, comment}
|
|
|
|
error ->
|
|
error
|
|
end
|
|
end
|
|
|
|
@doc """
|
|
Unhides a previously hidden comment.
|
|
|
|
## Examples
|
|
|
|
iex> unhide_comment(comment)
|
|
{:ok, %Comment{}}
|
|
|
|
"""
|
|
def unhide_comment(%Comment{} = comment) do
|
|
comment
|
|
|> Comment.unhide_changeset()
|
|
|> Repo.update()
|
|
|> reindex_after_update()
|
|
end
|
|
|
|
@doc """
|
|
Marks a comment as destroyed and removes its text (hard deletion).
|
|
|
|
## Examples
|
|
|
|
iex> destroy_comment(comment)
|
|
{:ok, %Comment{}}
|
|
|
|
"""
|
|
def destroy_comment(%Comment{} = comment) do
|
|
comment
|
|
|> Comment.destroy_changeset()
|
|
|> Repo.update()
|
|
|> reindex_after_update()
|
|
end
|
|
|
|
defp reindex_after_update(result) do
|
|
case result do
|
|
{:ok, comment} ->
|
|
reindex_comment(comment)
|
|
|
|
{:ok, comment}
|
|
|
|
error ->
|
|
error
|
|
end
|
|
end
|
|
|
|
@doc """
|
|
Approves a comment, closes associated reports, and increments the user comments
|
|
posted count.
|
|
|
|
## Parameters
|
|
- comment: The comment to approve
|
|
- user: The user performing the approval
|
|
|
|
## Examples
|
|
|
|
iex> approve_comment(comment, user)
|
|
{:ok, %Comment{}}
|
|
|
|
"""
|
|
def approve_comment(%Comment{} = comment, user) do
|
|
report_query = Reports.close_report_query({"Comment", comment.id}, user)
|
|
comment = Comment.approve_changeset(comment)
|
|
|
|
Multi.new()
|
|
|> Multi.update(:comment, comment)
|
|
|> Multi.update_all(:reports, report_query, [])
|
|
|> Repo.transaction()
|
|
|> case do
|
|
{:ok, %{comment: comment, reports: {_count, reports}}} ->
|
|
UserStatistics.inc_stat(comment.user, :comments_posted)
|
|
Reports.reindex_reports(reports)
|
|
reindex_comment(comment)
|
|
|
|
{:ok, comment}
|
|
|
|
error ->
|
|
error
|
|
end
|
|
end
|
|
|
|
@doc """
|
|
Creates a system report for non-approved comments containing external images.
|
|
Returns false for already approved comments.
|
|
|
|
## Returns
|
|
- `false`: If the comment is already approved
|
|
- `{:ok, %Report{}}`: If a system report was created
|
|
|
|
## Examples
|
|
|
|
iex> report_non_approved(approved_comment)
|
|
false
|
|
|
|
iex> report_non_approved(unapproved_comment)
|
|
{:ok, %Report{}}
|
|
|
|
"""
|
|
def report_non_approved(%Comment{approved: true}), do: false
|
|
|
|
def report_non_approved(comment) do
|
|
Reports.create_system_report(
|
|
{"Comment", comment.id},
|
|
"Approval",
|
|
"Comment contains externally-embedded images and has been flagged for review."
|
|
)
|
|
end
|
|
|
|
@doc """
|
|
Migrates comments from one image to another when handling duplicate images.
|
|
Returns the duplicate image parameter unchanged, for use in a pipeline.
|
|
|
|
## Parameters
|
|
- image: The source image whose comments will be moved
|
|
- duplicate_of_image: The target image that will receive the comments
|
|
|
|
## Examples
|
|
|
|
iex> migrate_comments(source_image, target_image)
|
|
%Image{}
|
|
|
|
"""
|
|
def migrate_comments(image, duplicate_of_image) do
|
|
{count, nil} =
|
|
Comment
|
|
|> where(image_id: ^image.id)
|
|
|> Repo.update_all(set: [image_id: duplicate_of_image.id])
|
|
|
|
Image
|
|
|> where(id: ^duplicate_of_image.id)
|
|
|> Repo.update_all(inc: [comments_count: count])
|
|
|
|
reindex_comments(duplicate_of_image)
|
|
end
|
|
|
|
@doc """
|
|
Returns an `%Ecto.Changeset{}` for tracking comment changes.
|
|
|
|
## Examples
|
|
|
|
iex> change_comment(comment)
|
|
%Ecto.Changeset{source: %Comment{}}
|
|
|
|
"""
|
|
def change_comment(%Comment{} = comment) do
|
|
Comment.changeset(comment, %{})
|
|
end
|
|
|
|
@doc """
|
|
Updates comment search indices when a user's name changes.
|
|
|
|
## Examples
|
|
|
|
iex> user_name_reindex("old_username", "new_username")
|
|
:ok
|
|
|
|
"""
|
|
def user_name_reindex(old_name, new_name) do
|
|
data = CommentIndex.user_name_update_by_query(old_name, new_name)
|
|
|
|
Search.update_by_query(Comment, data.query, data.set_replacements, data.replacements)
|
|
end
|
|
|
|
@doc """
|
|
Queues a single comment for search index updates.
|
|
Returns the comment struct unchanged, for use in a pipeline.
|
|
|
|
## Examples
|
|
|
|
iex> reindex_comment(comment)
|
|
%Comment{}
|
|
|
|
"""
|
|
def reindex_comment(%Comment{} = comment) do
|
|
Exq.enqueue(Exq, "indexing", IndexWorker, ["Comments", "id", [comment.id]])
|
|
|
|
comment
|
|
end
|
|
|
|
@doc """
|
|
Queues all comments associated with an image for search index updates.
|
|
Returns the image struct unchanged, for use in a pipeline.
|
|
|
|
## Examples
|
|
|
|
iex> reindex_comments(image)
|
|
%Image{}
|
|
|
|
"""
|
|
def reindex_comments(image) do
|
|
Exq.enqueue(Exq, "indexing", IndexWorker, ["Comments", "image_id", [image.id]])
|
|
|
|
image
|
|
end
|
|
|
|
@doc """
|
|
Provides preload queries for comment indexing operations.
|
|
|
|
## Examples
|
|
|
|
iex> indexing_preloads()
|
|
[user: user_query, image: image_query]
|
|
|
|
"""
|
|
def indexing_preloads do
|
|
user_query = select(User, [u], map(u, [:id, :name]))
|
|
tag_query = select(Tag, [t], map(t, [:id]))
|
|
|
|
image_query =
|
|
Image
|
|
|> select([i], struct(i, [:approved, :hidden_from_users, :id]))
|
|
|> preload(tags: ^tag_query)
|
|
|
|
[
|
|
user: user_query,
|
|
image: image_query
|
|
]
|
|
end
|
|
|
|
@doc """
|
|
Performs a search reindex operation on comments matching the given criteria.
|
|
|
|
## Parameters
|
|
- column: The database column to filter on (e.g., :id, :image_id)
|
|
- condition: A list of values to match against the column
|
|
|
|
## Examples
|
|
|
|
iex> perform_reindex(:id, [1, 2, 3])
|
|
:ok
|
|
|
|
iex> perform_reindex(:image_id, [123])
|
|
:ok
|
|
|
|
"""
|
|
def perform_reindex(column, condition) do
|
|
Comment
|
|
|> preload(^indexing_preloads())
|
|
|> where([c], field(c, ^column) in ^condition)
|
|
|> Search.reindex(Comment)
|
|
end
|
|
end
|