git.squeep.com Git - akkoma/blob - lib/pleroma/web/activity_pub/views/user_view.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.Web.ActivityPub.UserView do
   6   use Pleroma.Web, :view
   7
   8   alias Pleroma.Web.{WebFinger, Salmon}
   9   alias Pleroma.{User, Repo}
  10   alias Pleroma.Web.ActivityPub.{ActivityPub, Transmogrifier, Utils}
  11
  12   import Ecto.Query
  13
  14   # the instance itself is not a Person, but instead an Application
  15   def render("user.json", %{user: %{nickname: nil} = user}) do
  16     {:ok, user} = WebFinger.ensure_keys_present(user)
  17     {:ok, _, public_key} = Salmon.keys_from_pem(user.info.keys)
  18     public_key = :public_key.pem_entry_encode(:SubjectPublicKeyInfo, public_key)
  19     public_key = :public_key.pem_encode([public_key])
  20
  21     %{
  22       "id" => user.ap_id,
  23       "type" => "Application",
  24       "following" => "#{user.ap_id}/following",
  25       "followers" => "#{user.ap_id}/followers",
  26       "inbox" => "#{user.ap_id}/inbox",
  27       "name" => "Pleroma",
  28       "summary" => "Virtual actor for Pleroma relay",
  29       "url" => user.ap_id,
  30       "manuallyApprovesFollowers" => false,
  31       "publicKey" => %{
  32         "id" => "#{user.ap_id}#main-key",
  33         "owner" => user.ap_id,
  34         "publicKeyPem" => public_key
  35       },
  36       "endpoints" => %{
  37         "sharedInbox" => "#{Pleroma.Web.Endpoint.url()}/inbox"
  38       }
  39     }
  40     |> Map.merge(Utils.make_json_ld_header())
  41   end
  42
  43   def render("user.json", %{user: user}) do
  44     {:ok, user} = WebFinger.ensure_keys_present(user)
  45     {:ok, _, public_key} = Salmon.keys_from_pem(user.info.keys)
  46     public_key = :public_key.pem_entry_encode(:SubjectPublicKeyInfo, public_key)
  47     public_key = :public_key.pem_encode([public_key])
  48
  49     %{
  50       "id" => user.ap_id,
  51       "type" => "Person",
  52       "following" => "#{user.ap_id}/following",
  53       "followers" => "#{user.ap_id}/followers",
  54       "inbox" => "#{user.ap_id}/inbox",
  55       "outbox" => "#{user.ap_id}/outbox",
  56       "preferredUsername" => user.nickname,
  57       "name" => user.name,
  58       "summary" => user.bio,
  59       "url" => user.ap_id,
  60       "manuallyApprovesFollowers" => user.info.locked,
  61       "publicKey" => %{
  62         "id" => "#{user.ap_id}#main-key",
  63         "owner" => user.ap_id,
  64         "publicKeyPem" => public_key
  65       },
  66       "endpoints" => %{
  67         "sharedInbox" => "#{Pleroma.Web.Endpoint.url()}/inbox"
  68       },
  69       "icon" => %{
  70         "type" => "Image",
  71         "url" => User.avatar_url(user)
  72       },
  73       "image" => %{
  74         "type" => "Image",
  75         "url" => User.banner_url(user)
  76       },
  77       "tag" => user.info.source_data["tag"] || []
  78     }
  79     |> Map.merge(Utils.make_json_ld_header())
  80   end
  81
  82   def render("following.json", %{user: user, page: page}) do
  83     query = User.get_friends_query(user)
  84     query = from(user in query, select: [:ap_id])
  85     following = Repo.all(query)
  86
  87     collection(following, "#{user.ap_id}/following", page, !user.info.hide_follows)
  88     |> Map.merge(Utils.make_json_ld_header())
  89   end
  90
  91   def render("following.json", %{user: user}) do
  92     query = User.get_friends_query(user)
  93     query = from(user in query, select: [:ap_id])
  94     following = Repo.all(query)
  95
  96     %{
  97       "id" => "#{user.ap_id}/following",
  98       "type" => "OrderedCollection",
  99       "totalItems" => length(following),
 100       "first" => collection(following, "#{user.ap_id}/following", 1, !user.info.hide_follows)
 101     }
 102     |> Map.merge(Utils.make_json_ld_header())
 103   end
 104
 105   def render("followers.json", %{user: user, page: page}) do
 106     query = User.get_followers_query(user)
 107     query = from(user in query, select: [:ap_id])
 108     followers = Repo.all(query)
 109
 110     collection(followers, "#{user.ap_id}/followers", page, !user.info.hide_followers)
 111     |> Map.merge(Utils.make_json_ld_header())
 112   end
 113
 114   def render("followers.json", %{user: user}) do
 115     query = User.get_followers_query(user)
 116     query = from(user in query, select: [:ap_id])
 117     followers = Repo.all(query)
 118
 119     %{
 120       "id" => "#{user.ap_id}/followers",
 121       "type" => "OrderedCollection",
 122       "totalItems" => length(followers),
 123       "first" => collection(followers, "#{user.ap_id}/followers", 1, !user.info.hide_followers)
 124     }
 125     |> Map.merge(Utils.make_json_ld_header())
 126   end
 127
 128   def render("outbox.json", %{user: user, max_id: max_qid}) do
 129     # XXX: technically note_count is wrong for this, but it's better than nothing
 130     info = User.user_info(user)
 131
 132     params = %{
 133       "limit" => "10"
 134     }
 135
 136     params =
 137       if max_qid != nil do
 138         Map.put(params, "max_id", max_qid)
 139       else
 140         params
 141       end
 142
 143     activities = ActivityPub.fetch_user_activities(user, nil, params)
 144     min_id = Enum.at(Enum.reverse(activities), 0).id
 145     max_id = Enum.at(activities, 0).id
 146
 147     collection =
 148       Enum.map(activities, fn act ->
 149         {:ok, data} = Transmogrifier.prepare_outgoing(act.data)
 150         data
 151       end)
 152
 153     iri = "#{user.ap_id}/outbox"
 154
 155     page = %{
 156       "id" => "#{iri}?max_id=#{max_id}",
 157       "type" => "OrderedCollectionPage",
 158       "partOf" => iri,
 159       "totalItems" => info.note_count,
 160       "orderedItems" => collection,
 161       "next" => "#{iri}?max_id=#{min_id}"
 162     }
 163
 164     if max_qid == nil do
 165       %{
 166         "id" => iri,
 167         "type" => "OrderedCollection",
 168         "totalItems" => info.note_count,
 169         "first" => page
 170       }
 171       |> Map.merge(Utils.make_json_ld_header())
 172     else
 173       page |> Map.merge(Utils.make_json_ld_header())
 174     end
 175   end
 176
 177   def render("inbox.json", %{user: user, max_id: max_qid}) do
 178     params = %{
 179       "limit" => "10"
 180     }
 181
 182     params =
 183       if max_qid != nil do
 184         Map.put(params, "max_id", max_qid)
 185       else
 186         params
 187       end
 188
 189     activities = ActivityPub.fetch_activities([user.ap_id | user.following], params)
 190
 191     min_id = Enum.at(Enum.reverse(activities), 0).id
 192     max_id = Enum.at(activities, 0).id
 193
 194     collection =
 195       Enum.map(activities, fn act ->
 196         {:ok, data} = Transmogrifier.prepare_outgoing(act.data)
 197         data
 198       end)
 199
 200     iri = "#{user.ap_id}/inbox"
 201
 202     page = %{
 203       "id" => "#{iri}?max_id=#{max_id}",
 204       "type" => "OrderedCollectionPage",
 205       "partOf" => iri,
 206       "totalItems" => -1,
 207       "orderedItems" => collection,
 208       "next" => "#{iri}?max_id=#{min_id}"
 209     }
 210
 211     if max_qid == nil do
 212       %{
 213         "id" => iri,
 214         "type" => "OrderedCollection",
 215         "totalItems" => -1,
 216         "first" => page
 217       }
 218       |> Map.merge(Utils.make_json_ld_header())
 219     else
 220       page |> Map.merge(Utils.make_json_ld_header())
 221     end
 222   end
 223
 224   def collection(collection, iri, page, show_items \\ true, total \\ nil) do
 225     offset = (page - 1) * 10
 226     items = Enum.slice(collection, offset, 10)
 227     items = Enum.map(items, fn user -> user.ap_id end)
 228     total = total || length(collection)
 229
 230     map = %{
 231       "id" => "#{iri}?page=#{page}",
 232       "type" => "OrderedCollectionPage",
 233       "partOf" => iri,
 234       "totalItems" => total,
 235       "orderedItems" => if(show_items, do: items, else: [])
 236     }
 237
 238     if offset < total do
 239       Map.put(map, "next", "#{iri}?page=#{page + 1}")
 240     else
 241       map
 242     end
 243   end
 244 end