git.squeep.com Git - akkoma/blob - lib/pleroma/elasticsearch/store.ex

   1 defmodule Pleroma.Elasticsearch do
   2   alias Pleroma.Activity
   3   alias Pleroma.User
   4   alias Pleroma.Elasticsearch.DocumentMappings
   5   alias Pleroma.Config
   6   require Logger
   7
   8   defp url do
   9     Config.get([:elasticsearch, :url])
  10   end
  11
  12   defp enabled? do
  13     Config.get([:search, :provider]) == Pleroma.Search.Elasticsearch
  14   end
  15
  16   def put_by_id(:activity, id) do
  17     id
  18     |> Activity.get_by_id_with_object()
  19     |> maybe_put_into_elasticsearch()
  20   end
  21
  22   def maybe_put_into_elasticsearch({:ok, item}) do
  23     maybe_put_into_elasticsearch(item)
  24   end
  25
  26   def maybe_put_into_elasticsearch(
  27         %{data: %{"type" => "Create"}, object: %{data: %{"type" => "Note"}}} = activity
  28       ) do
  29     if enabled?() do
  30       actor = Pleroma.Activity.user_actor(activity)
  31
  32       activity
  33       |> Map.put(:user_actor, actor)
  34       |> put()
  35     end
  36   end
  37
  38   def maybe_put_into_elasticsearch(%User{} = user) do
  39     if enabled?() do
  40       put(user)
  41     end
  42   end
  43
  44   def maybe_put_into_elasticsearch(_) do
  45     {:ok, :skipped}
  46   end
  47
  48   def put(%Activity{} = activity) do
  49     {:ok, _} = Elastix.Document.index(
  50       url(),
  51       "activities",
  52       "activity",
  53       DocumentMappings.Activity.id(activity),
  54       DocumentMappings.Activity.encode(activity)
  55     )
  56     {:ok, _} = bulk_post(
  57         activity.object.hashtags, :hashtags
  58     )
  59   end
  60
  61   def put(%User{} = user) do
  62     {:ok, _ } = Elastix.Document.index(
  63       url(),
  64       "users",
  65       "user",
  66       DocumentMappings.User.id(user),
  67       DocumentMappings.User.encode(user)
  68     )
  69   end
  70
  71   def bulk_post(data, :activities) do
  72     d =
  73       data
  74       |> Enum.filter(fn x ->
  75         t =
  76           x.object
  77           |> Map.get(:data, %{})
  78           |> Map.get("type", "")
  79
  80         t == "Note"
  81       end)
  82       |> Enum.map(fn d ->
  83         [
  84           %{index: %{_id: DocumentMappings.Activity.id(d)}},
  85           DocumentMappings.Activity.encode(d)
  86         ]
  87       end)
  88       |> List.flatten()
  89
  90     {:ok, %{body: %{"errors" => false}}} = Elastix.Bulk.post(
  91       url(),
  92       d,
  93       index: "activities",
  94       type: "activity"
  95     )
  96   end
  97
  98   def bulk_post(data, :users) do
  99     d =
 100       data
 101       |> Enum.filter(fn x -> x.actor_type == "Person" end)
 102       |> Enum.map(fn d ->
 103         [
 104           %{index: %{_id: DocumentMappings.User.id(d)}},
 105           DocumentMappings.User.encode(d)
 106         ]
 107       end)
 108       |> List.flatten()
 109
 110     Elastix.Bulk.post(
 111       url(),
 112       d,
 113       index: "users",
 114       type: "user"
 115     )
 116   end
 117
 118   def bulk_post(data, :hashtags) do
 119     d =
 120       data
 121       |> Enum.map(fn d ->
 122         [
 123           %{index: %{_id: DocumentMappings.Hashtag.id(d)}},
 124           DocumentMappings.Hashtag.encode(d)
 125         ]
 126       end)
 127       |> List.flatten()
 128
 129     Elastix.Bulk.post(
 130       url(),
 131       d,
 132       index: "hashtags",
 133       type: "hashtag"
 134     )
 135   end
 136
 137   def search(:raw, index, type, q) do
 138     with {:ok, raw_results} <- Elastix.Search.search(url(), index, [type], q) do
 139       results =
 140         raw_results
 141         |> Map.get(:body, %{})
 142         |> Map.get("hits", %{})
 143         |> Map.get("hits", [])
 144
 145       {:ok, results}
 146     else
 147       {:error, e} ->
 148         Logger.error(e)
 149         {:error, e}
 150     end
 151   end
 152
 153   def search(:activities, q) do
 154     with {:ok, results} <- search(:raw, "activities", "activity", q) do
 155       results
 156       |> Enum.map(fn result -> result["_id"] end)
 157       |> Pleroma.Activity.all_by_ids_with_object()
 158     else
 159       e ->
 160         Logger.error(e)
 161         []
 162     end
 163   end
 164
 165   def search(:users, q) do
 166     with {:ok, results} <- search(:raw, "users", "user", q) do
 167       results
 168       |> Enum.map(fn result -> result["_id"] end)
 169       |> Pleroma.User.get_all_by_ids()
 170     else
 171       e ->
 172         Logger.error(e)
 173         []
 174     end
 175   end
 176
 177   def search(:hashtags, q) do
 178     with {:ok, results} <- search(:raw, "hashtags", "hashtag", q) do
 179       results
 180       |> Enum.map(fn result -> result["_source"]["hashtag"] end)
 181     else
 182       e ->
 183         Logger.error(e)
 184         []
 185     end
 186   end
 187 end