git.squeep.com Git - akkoma/blob - lib/pleroma/search/meilisearch.ex

   1 defmodule Pleroma.Search.Meilisearch do
   2   require Logger
   3   require Pleroma.Constants
   4
   5   alias Pleroma.Activity
   6
   7   import Pleroma.Activity.Search
   8   import Ecto.Query
   9
  10   defp meili_headers() do
  11     private_key = Pleroma.Config.get([Pleroma.Search.Meilisearch, :private_key])
  12
  13     if is_nil(private_key), do: [], else: [{"X-Meili-API-Key", private_key}]
  14   end
  15
  16   def meili_post!(path, params) do
  17     endpoint = Pleroma.Config.get([Pleroma.Search.Meilisearch, :url])
  18
  19     {:ok, result} =
  20       Pleroma.HTTP.post(
  21         Path.join(endpoint, path),
  22         Jason.encode!(params),
  23         meili_headers()
  24       )
  25
  26     Jason.decode!(result.body)
  27   end
  28
  29   def meili_delete!(path) do
  30     endpoint = Pleroma.Config.get([Pleroma.Search.Meilisearch, :url])
  31
  32     {:ok, _} =
  33       Pleroma.HTTP.request(
  34         :delete,
  35         Path.join(endpoint, path),
  36         "",
  37         meili_headers(),
  38         timeout: :infinity
  39       )
  40   end
  41
  42   def search(user, query, options \\ []) do
  43     limit = Enum.min([Keyword.get(options, :limit), 40])
  44     offset = Keyword.get(options, :offset, 0)
  45     author = Keyword.get(options, :author)
  46
  47     result =
  48       meili_post!(
  49         "/indexes/objects/search",
  50         %{q: query, offset: offset, limit: limit}
  51       )
  52
  53     hits = result["hits"] |> Enum.map(& &1["ap"])
  54
  55     try do
  56       hits
  57       |> Activity.create_by_object_ap_id()
  58       |> Activity.with_preloaded_object()
  59       |> Activity.with_preloaded_object()
  60       |> Activity.restrict_deactivated_users()
  61       |> maybe_restrict_local(user)
  62       |> maybe_restrict_author(author)
  63       |> maybe_restrict_blocked(user)
  64       |> maybe_fetch(user, query)
  65       |> order_by([object: obj], desc: obj.data["published"])
  66       |> Pleroma.Repo.all()
  67     rescue
  68       _ -> maybe_fetch([], user, query)
  69     end
  70   end
  71
  72   def object_to_search_data(object) do
  73     if not is_nil(object) and object.data["type"] == "Note" and
  74          Pleroma.Constants.as_public() in object.data["to"] do
  75       data = object.data
  76
  77       content_str =
  78         case data["content"] do
  79           [nil | rest] -> to_string(rest)
  80           str -> str
  81         end
  82
  83       content =
  84         with {:ok, scrubbed} <- FastSanitize.strip_tags(content_str),
  85              trimmed <- String.trim(scrubbed) do
  86           trimmed
  87         end
  88
  89       if String.length(content) > 1 do
  90         {:ok, published, _} = DateTime.from_iso8601(data["published"])
  91
  92         %{
  93           id: object.id,
  94           content: content,
  95           ap: data["id"],
  96           published: published |> DateTime.to_unix()
  97         }
  98       end
  99     end
 100   end
 101
 102   def add_to_index(activity) do
 103     maybe_search_data = object_to_search_data(activity)
 104
 105     if activity.data["type"] == "Create" and maybe_search_data do
 106       result =
 107         meili_post!(
 108           "/indexes/objects/documents",
 109           [maybe_search_data]
 110         )
 111
 112       if not Map.has_key?(result, "updateId") do
 113         Logger.error("Failed to add activity #{activity.id} to index: #{inspect(result)}")
 114       end
 115     end
 116   end
 117
 118   def remove_from_index(object) do
 119     meili_delete!("/indexes/objects/documents/#{object.id}")
 120   end
 121 end