Merge branch 'develop' of git.pleroma.social:pleroma/pleroma into emoji-pack-upload

lib/pleroma/gopher/server.ex

@@ -22,14 +22,18 @@ defmodule Pleroma.Gopher.Server do
   def init([ip, port]) do
     Logger.info("Starting gopher server on #{port}")
 
-    :ranch.start_listener(
-      :gopher,
-      100,
-      :ranch_tcp,
-      [ip: ip, port: port],
-      __MODULE__.ProtocolHandler,
-      []
-    )
+    {:ok, _pid} =
+      :ranch.start_listener(
+        :gopher,
+        :ranch_tcp,
+        %{
+          num_acceptors: 100,
+          max_connections: 100,
+          socket_opts: [ip: ip, port: port]
+        },
+        __MODULE__.ProtocolHandler,
+        []
+      )
 
     {:ok, %{ip: ip, port: port}}
   end
@@ -43,13 +47,13 @@ defmodule Pleroma.Gopher.Server.ProtocolHandler do
   alias Pleroma.Web.ActivityPub.ActivityPub
   alias Pleroma.Web.ActivityPub.Visibility
 
-  def start_link(ref, socket, transport, opts) do
-    pid = spawn_link(__MODULE__, :init, [ref, socket, transport, opts])
+  def start_link(ref, transport, opts) do
+    pid = spawn_link(__MODULE__, :init, [ref, transport, opts])
     {:ok, pid}
   end
 
-  def init(ref, socket, transport, [] = _Opts) do
-    :ok = :ranch.accept_ack(ref)
+  def init(ref, transport, opts \\ []) do
+    {:ok, socket} = :ranch.handshake(ref, opts)
     loop(socket, transport)
   end
 

lib/pleroma/hashtag.ex

@@ -130,4 +130,66 @@ defmodule Pleroma.Hashtag do
   end
 
   def get_recipients_for_activity(_activity), do: []
+
+  def search(query, options \\ []) do
+    limit = Keyword.get(options, :limit, 20)
+    offset = Keyword.get(options, :offset, 0)
+
+    search_terms =
+      query
+      |> String.downcase()
+      |> String.trim()
+      |> String.split(~r/\s+/)
+      |> Enum.filter(&(&1 != ""))
+      |> Enum.map(&String.trim_leading(&1, "#"))
+      |> Enum.filter(&(&1 != ""))
+
+    if Enum.empty?(search_terms) do
+      []
+    else
+      # Use PostgreSQL's ANY operator with array for efficient multi-term search
+      # This is much more efficient than multiple OR clauses
+      search_patterns = Enum.map(search_terms, &"%#{&1}%")
+
+      # Create ranking query that prioritizes exact matches and closer matches
+      # Use a subquery to properly handle computed columns in ORDER BY
+      base_query =
+        from(ht in Hashtag,
+          where: fragment("LOWER(?) LIKE ANY(?)", ht.name, ^search_patterns),
+          select: %{
+            name: ht.name,
+            # Ranking: exact matches get highest priority (0)
+            # then prefix matches (1), then contains (2)
+            match_rank:
+              fragment(
+                """
+                  CASE
+                    WHEN LOWER(?) = ANY(?) THEN 0
+                    WHEN LOWER(?) LIKE ANY(?) THEN 1
+                    ELSE 2
+                  END
+                """,
+                ht.name,
+                ^search_terms,
+                ht.name,
+                ^Enum.map(search_terms, &"#{&1}%")
+              ),
+            # Secondary sort by name length (shorter names first)
+            name_length: fragment("LENGTH(?)", ht.name)
+          }
+        )
+
+      from(result in subquery(base_query),
+        order_by: [
+          asc: result.match_rank,
+          asc: result.name_length,
+          asc: result.name
+        ],
+        limit: ^limit,
+        offset: ^offset
+      )
+      |> Repo.all()
+      |> Enum.map(& &1.name)
+    end
+  end
 end

lib/pleroma/search/qdrant_search.ex

@@ -157,26 +157,55 @@ defmodule Pleroma.Search.QdrantSearch do
 end
 
 defmodule Pleroma.Search.QdrantSearch.OpenAIClient do
-  use Tesla
   alias Pleroma.Config.Getting, as: Config
 
-  plug(Tesla.Middleware.BaseUrl, Config.get([Pleroma.Search.QdrantSearch, :openai_url]))
-  plug(Tesla.Middleware.JSON)
+  def post(path, body) do
+    Tesla.post(client(), path, body)
+  end
 
-  plug(Tesla.Middleware.Headers, [
-    {"Authorization",
-     "Bearer #{Pleroma.Config.get([Pleroma.Search.QdrantSearch, :openai_api_key])}"}
-  ])
+  defp client do
+    Tesla.client(middleware())
+  end
+
+  defp middleware do
+    [
+      {Tesla.Middleware.BaseUrl, Config.get([Pleroma.Search.QdrantSearch, :openai_url])},
+      Tesla.Middleware.JSON,
+      {Tesla.Middleware.Headers,
+       [
+         {"Authorization", "Bearer #{Config.get([Pleroma.Search.QdrantSearch, :openai_api_key])}"}
+       ]}
+    ]
+  end
 end
 
 defmodule Pleroma.Search.QdrantSearch.QdrantClient do
-  use Tesla
   alias Pleroma.Config.Getting, as: Config
 
-  plug(Tesla.Middleware.BaseUrl, Config.get([Pleroma.Search.QdrantSearch, :qdrant_url]))
-  plug(Tesla.Middleware.JSON)
+  def delete(path) do
+    Tesla.delete(client(), path)
+  end
 
-  plug(Tesla.Middleware.Headers, [
-    {"api-key", Pleroma.Config.get([Pleroma.Search.QdrantSearch, :qdrant_api_key])}
-  ])
+  def post(path, body) do
+    Tesla.post(client(), path, body)
+  end
+
+  def put(path, body) do
+    Tesla.put(client(), path, body)
+  end
+
+  defp client do
+    Tesla.client(middleware())
+  end
+
+  defp middleware do
+    [
+      {Tesla.Middleware.BaseUrl, Config.get([Pleroma.Search.QdrantSearch, :qdrant_url])},
+      Tesla.Middleware.JSON,
+      {Tesla.Middleware.Headers,
+       [
+         {"api-key", Pleroma.Config.get([Pleroma.Search.QdrantSearch, :qdrant_api_key])}
+       ]}
+    ]
+  end
 end

lib/pleroma/web/activity_pub/activity_pub_controller.ex

@@ -273,13 +273,37 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubController do
   end
 
   def inbox(%{assigns: %{valid_signature: true}} = conn, %{"nickname" => nickname} = params) do
-    with %User{is_active: true} = recipient <- User.get_cached_by_nickname(nickname),
-         {:ok, %User{is_active: true} = actor} <- User.get_or_fetch_by_ap_id(params["actor"]),
+    with {:recipient_exists, %User{} = recipient} <-
+           {:recipient_exists, User.get_cached_by_nickname(nickname)},
+         {:sender_exists, {:ok, %User{} = actor}} <-
+           {:sender_exists, User.get_or_fetch_by_ap_id(params["actor"])},
+         {:recipient_active, true} <- {:recipient_active, recipient.is_active},
+         {:sender_active, true} <- {:sender_active, actor.is_active},
          true <- Utils.recipient_in_message(recipient, actor, params),
          params <- Utils.maybe_splice_recipient(recipient.ap_id, params) do
       Federator.incoming_ap_doc(params)
       json(conn, "ok")
     else
+      {:recipient_exists, _} ->
+        conn
+        |> put_status(:not_found)
+        |> json("User does not exist")
+
+      {:sender_exists, _} ->
+        conn
+        |> put_status(:not_found)
+        |> json("Sender does not exist")
+
+      {:recipient_active, _} ->
+        conn
+        |> put_status(:not_found)
+        |> json("User deactivated")
+
+      {:sender_active, _} ->
+        conn
+        |> put_status(:not_found)
+        |> json("Sender deactivated")
+
       _ ->
         conn
         |> put_status(:bad_request)

lib/pleroma/web/mastodon_api/controllers/search_controller.ex

@@ -5,6 +5,7 @@
 defmodule Pleroma.Web.MastodonAPI.SearchController do
   use Pleroma.Web, :controller
 
+  alias Pleroma.Hashtag
   alias Pleroma.Repo
   alias Pleroma.User
   alias Pleroma.Web.ControllerHelper
@@ -120,69 +121,14 @@ defmodule Pleroma.Web.MastodonAPI.SearchController do
   defp resource_search(:v2, "hashtags", query, options) do
     tags_path = Endpoint.url() <> "/tag/"
 
-    query
-    |> prepare_tags(options)
+    Hashtag.search(query, options)
     |> Enum.map(fn tag ->
       %{name: tag, url: tags_path <> tag}
     end)
   end
 
   defp resource_search(:v1, "hashtags", query, options) do
-    prepare_tags(query, options)
-  end
-
-  defp prepare_tags(query, options) do
-    tags =
-      query
-      |> preprocess_uri_query()
-      |> String.split(~r/[^#\w]+/u, trim: true)
-      |> Enum.uniq_by(&String.downcase/1)
-
-    explicit_tags = Enum.filter(tags, fn tag -> String.starts_with?(tag, "#") end)
-
-    tags =
-      if Enum.any?(explicit_tags) do
-        explicit_tags
-      else
-        tags
-      end
-
-    tags = Enum.map(tags, fn tag -> String.trim_leading(tag, "#") end)
-
-    tags =
-      if Enum.empty?(explicit_tags) && !options[:skip_joined_tag] do
-        add_joined_tag(tags)
-      else
-        tags
-      end
-
-    Pleroma.Pagination.paginate_list(tags, options)
-  end
-
-  defp add_joined_tag(tags) do
-    tags
-    |> Kernel.++([joined_tag(tags)])
-    |> Enum.uniq_by(&String.downcase/1)
-  end
-
-  # If `query` is a URI, returns last component of its path, otherwise returns `query`
-  defp preprocess_uri_query(query) do
-    if query =~ ~r/https?:\/\// do
-      query
-      |> String.trim_trailing("/")
-      |> URI.parse()
-      |> Map.get(:path)
-      |> String.split("/")
-      |> Enum.at(-1)
-    else
-      query
-    end
-  end
-
-  defp joined_tag(tags) do
-    tags
-    |> Enum.map(fn tag -> String.capitalize(tag) end)
-    |> Enum.join()
+    Hashtag.search(query, options)
   end
 
   defp with_fallback(f, fallback \\ []) do