mirror of
https://github.com/philomena-dev/philomena.git
synced 2024-11-23 20:18:00 +01:00
136 lines
4.1 KiB
Elixir
136 lines
4.1 KiB
Elixir
defmodule PhilomenaWeb.ImageLoader do
|
|
alias Philomena.Elasticsearch
|
|
alias Philomena.Images.{Image, Query}
|
|
alias Philomena.Textile.Renderer
|
|
alias Philomena.Tags.Tag
|
|
alias Philomena.Repo
|
|
import Ecto.Query
|
|
|
|
def search_string(conn, search_string, options \\ []) do
|
|
user = conn.assigns.current_user
|
|
|
|
with {:ok, tree} <- Query.compile(user, search_string) do
|
|
{:ok, query(conn, tree, options)}
|
|
else
|
|
error ->
|
|
error
|
|
end
|
|
end
|
|
|
|
def query(conn, body, options \\ []) do
|
|
sort_queries = Keyword.get(options, :queries, [])
|
|
sort_sorts = Keyword.get(options, :sorts, [%{created_at: :desc}])
|
|
pagination = Keyword.get(options, :pagination, conn.assigns.image_pagination)
|
|
queryable = Keyword.get(options, :queryable, Image |> preload(:tags))
|
|
constant_score = Keyword.get(options, :constant_score, true)
|
|
|
|
user = conn.assigns.current_user
|
|
filter = conn.assigns.compiled_filter
|
|
filters = create_filters(conn, user, filter)
|
|
body = maybe_constant_score(body, constant_score)
|
|
|
|
records =
|
|
Elasticsearch.search_records(
|
|
Image,
|
|
%{
|
|
query: %{
|
|
bool: %{
|
|
must: List.flatten([body, sort_queries]),
|
|
must_not: filters
|
|
}
|
|
},
|
|
sort: sort_sorts
|
|
},
|
|
pagination,
|
|
queryable
|
|
)
|
|
|
|
tags =
|
|
body
|
|
|> search_tag_names()
|
|
|> load_tags()
|
|
|> render_bodies(conn)
|
|
|
|
{records, tags}
|
|
end
|
|
|
|
defp create_filters(conn, user, filter) do
|
|
show_hidden? = Canada.Can.can?(user, :hide, %Image{})
|
|
del = conn.params["del"]
|
|
hidden = conn.params["hidden"]
|
|
|
|
[
|
|
filter
|
|
]
|
|
|> maybe_show_deleted(show_hidden?, del)
|
|
|> maybe_custom_hide(user, hidden)
|
|
end
|
|
|
|
# Allow moderators to index hidden images
|
|
|
|
defp maybe_show_deleted(filters, false, _param),
|
|
do: [%{term: %{hidden_from_users: true}} | filters]
|
|
|
|
defp maybe_show_deleted(filters, true, "1"),
|
|
do: filters
|
|
|
|
defp maybe_show_deleted(filters, true, "only"),
|
|
do: [%{term: %{hidden_from_users: false}} | filters]
|
|
|
|
defp maybe_show_deleted(filters, true, "deleted"),
|
|
do: [%{term: %{hidden_from_users: false}}, %{exists: %{field: :duplicate_id}} | filters]
|
|
|
|
defp maybe_show_deleted(filters, true, _param),
|
|
do: [%{term: %{hidden_from_users: true}} | filters]
|
|
|
|
# Allow users to reverse the effect of hiding images,
|
|
# if desired
|
|
|
|
defp maybe_custom_hide(filters, %{id: _id}, "1"),
|
|
do: filters
|
|
|
|
defp maybe_custom_hide(filters, %{id: id}, _param),
|
|
do: [%{term: %{hidden_by_user_ids: id}} | filters]
|
|
|
|
defp maybe_custom_hide(filters, _user, _param),
|
|
do: filters
|
|
|
|
defp maybe_constant_score(body, false), do: body
|
|
defp maybe_constant_score(body, _), do: %{bool: %{filter: body}}
|
|
|
|
# TODO: the search parser should try to optimize queries
|
|
defp search_tag_name(%{term: %{"namespaced_tags.name" => tag_name}}), do: [tag_name]
|
|
defp search_tag_name(_other_query), do: []
|
|
|
|
defp search_tag_names(%{bool: %{must: musts}}), do: Enum.flat_map(musts, &search_tag_name(&1))
|
|
defp search_tag_names(%{bool: %{should: shoulds}}), do: Enum.flat_map(shoulds, &search_tag_name(&1))
|
|
defp search_tag_names(%{term: %{"namespaced_tags.name" => tag_name}}), do: [tag_name]
|
|
defp search_tag_names(_other_query), do: []
|
|
|
|
defp load_tags([]), do: []
|
|
defp load_tags(tags) do
|
|
Tag
|
|
|> join(:left, [t], at in Tag, on: t.id == at.aliased_tag_id)
|
|
|> where([t, at], t.name in ^tags or at.name in ^tags)
|
|
|> preload([:aliases, :aliased_tag, :implied_tags, :implied_by_tags, :dnp_entries, public_links: :user])
|
|
|> Repo.all()
|
|
|> Enum.uniq_by(& &1.id)
|
|
|> Enum.filter(&is_nil(&1.aliased_tag))
|
|
|> Tag.display_order()
|
|
end
|
|
|
|
defp render_bodies([], _conn), do: []
|
|
defp render_bodies([tag], conn) do
|
|
dnp_bodies =
|
|
Renderer.render_collection(Enum.map(tag.dnp_entries, &%{body: &1.conditions || ""}), conn)
|
|
|
|
dnp_entries =
|
|
Enum.zip(dnp_bodies, tag.dnp_entries)
|
|
|
|
description =
|
|
Renderer.render_one(%{body: tag.description || ""}, conn)
|
|
|
|
[{tag, description, dnp_entries}]
|
|
end
|
|
defp render_bodies(tags, _conn), do: tags
|
|
end
|