git.squeep.com Git - akkoma/blob - lib/pleroma/user/query.ex

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.User.Query do
   6   @moduledoc """
   7   User query builder module. Builds query from new query or another user query.
   8
   9     ## Example:
  10         query = Pleroma.User.Query.build(%{nickname: "nickname"})
  11         another_query = Pleroma.User.Query.build(query, %{email: "email@example.com"})
  12         Pleroma.Repo.all(query)
  13         Pleroma.Repo.all(another_query)
  14
  15   Adding new rules:
  16     - *ilike criteria*
  17       - add field to @ilike_criteria list
  18       - pass non empty string
  19       - e.g. Pleroma.User.Query.build(%{nickname: "nickname"})
  20     - *equal criteria*
  21       - add field to @equal_criteria list
  22       - pass non empty string
  23       - e.g. Pleroma.User.Query.build(%{email: "email@example.com"})
  24     - *contains criteria*
  25       - add field to @containns_criteria list
  26       - pass values list
  27       - e.g. Pleroma.User.Query.build(%{ap_id: ["http://ap_id1", "http://ap_id2"]})
  28   """
  29   import Ecto.Query
  30   import Pleroma.Web.AdminAPI.Search, only: [not_empty_string: 1]
  31   alias Pleroma.User
  32
  33   @type criteria ::
  34           %{
  35             query: String.t(),
  36             tags: [String.t()],
  37             name: String.t(),
  38             email: String.t(),
  39             local: boolean(),
  40             external: boolean(),
  41             active: boolean(),
  42             deactivated: boolean(),
  43             is_admin: boolean(),
  44             is_moderator: boolean(),
  45             super_users: boolean(),
  46             followers: User.t(),
  47             friends: User.t(),
  48             recipients_from_activity: [String.t()],
  49             nickname: [String.t()],
  50             ap_id: [String.t()],
  51             order_by: term(),
  52             select: term(),
  53             limit: pos_integer()
  54           }
  55           | %{}
  56
  57   @ilike_criteria [:nickname, :name, :query]
  58   @equal_criteria [:email]
  59   @role_criteria [:is_admin, :is_moderator]
  60   @contains_criteria [:ap_id, :nickname]
  61
  62   @spec build(criteria()) :: Query.t()
  63   def build(query \\ base_query(), criteria) do
  64     prepare_query(query, criteria)
  65   end
  66
  67   @spec paginate(Ecto.Query.t(), pos_integer(), pos_integer()) :: Ecto.Query.t()
  68   def paginate(query, page, page_size) do
  69     from(u in query,
  70       limit: ^page_size,
  71       offset: ^((page - 1) * page_size)
  72     )
  73   end
  74
  75   defp base_query do
  76     from(u in User)
  77   end
  78
  79   defp prepare_query(query, criteria) do
  80     Enum.reduce(criteria, query, &compose_query/2)
  81   end
  82
  83   defp compose_query({key, value}, query)
  84        when key in @ilike_criteria and not_empty_string(value) do
  85     # hack for :query key
  86     key = if key == :query, do: :nickname, else: key
  87     where(query, [u], ilike(field(u, ^key), ^"%#{value}%"))
  88   end
  89
  90   defp compose_query({key, value}, query)
  91        when key in @equal_criteria and not_empty_string(value) do
  92     where(query, [u], ^[{key, value}])
  93   end
  94
  95   defp compose_query({key, values}, query) when key in @contains_criteria and is_list(values) do
  96     where(query, [u], field(u, ^key) in ^values)
  97   end
  98
  99   defp compose_query({:tags, tags}, query) when is_list(tags) and length(tags) > 0 do
 100     Enum.reduce(tags, query, &prepare_tag_criteria/2)
 101   end
 102
 103   defp compose_query({key, _}, query) when key in @role_criteria do
 104     where(query, [u], fragment("(?->? @> 'true')", u.info, ^to_string(key)))
 105   end
 106
 107   defp compose_query({:super_users, _}, query) do
 108     where(
 109       query,
 110       [u],
 111       fragment("?->'is_admin' @> 'true' OR ?->'is_moderator' @> 'true'", u.info, u.info)
 112     )
 113   end
 114
 115   defp compose_query({:local, _}, query), do: location_query(query, true)
 116
 117   defp compose_query({:external, _}, query), do: location_query(query, false)
 118
 119   defp compose_query({:active, _}, query) do
 120     where(query, [u], fragment("not (?->'deactivated' @> 'true')", u.info))
 121     |> where([u], not is_nil(u.nickname))
 122   end
 123
 124   defp compose_query({:deactivated, false}, query) do
 125     User.restrict_deactivated(query)
 126   end
 127
 128   defp compose_query({:deactivated, true}, query) do
 129     where(query, [u], fragment("?->'deactivated' @> 'true'", u.info))
 130     |> where([u], not is_nil(u.nickname))
 131   end
 132
 133   defp compose_query({:followers, %User{id: id, follower_address: follower_address}}, query) do
 134     where(query, [u], fragment("? <@ ?", ^[follower_address], u.following))
 135     |> where([u], u.id != ^id)
 136   end
 137
 138   defp compose_query({:friends, %User{id: id, following: following}}, query) do
 139     where(query, [u], u.follower_address in ^following)
 140     |> where([u], u.id != ^id)
 141   end
 142
 143   defp compose_query({:recipients_from_activity, to}, query) do
 144     where(query, [u], u.ap_id in ^to or fragment("? && ?", u.following, ^to))
 145   end
 146
 147   defp compose_query({:order_by, key}, query) do
 148     order_by(query, [u], field(u, ^key))
 149   end
 150
 151   defp compose_query({:select, keys}, query) do
 152     select(query, [u], ^keys)
 153   end
 154
 155   defp compose_query({:limit, limit}, query) do
 156     limit(query, ^limit)
 157   end
 158
 159   defp compose_query(_unsupported_param, query), do: query
 160
 161   defp prepare_tag_criteria(tag, query) do
 162     or_where(query, [u], fragment("? = any(?)", ^tag, u.tags))
 163   end
 164
 165   defp location_query(query, local) do
 166     where(query, [u], u.local == ^local)
 167     |> where([u], not is_nil(u.nickname))
 168   end
 169 end