- RichMedia: add the rich media ttl based on image expiration time.
### Removed
+- GNU Social API with Qvitter extensions support
- Emoji: Remove longfox emojis.
- Remove `Reply-To` header from report emails for admins.
- ActivityPub: The `accept_blocks` configuration setting.
Pleroma is written in Elixir, high-performance and can run on small devices like a Raspberry Pi.
-For clients it supports both the [GNU Social API with Qvitter extensions](https://twitter-api.readthedocs.io/en/latest/index.html) and the [Mastodon client API](https://docs.joinmastodon.org/api/guidelines/).
+For clients it supports the [Mastodon client API](https://docs.joinmastodon.org/api/guidelines/) with Pleroma extensions (see "Pleroma's APIs and Mastodon API extensions" section on <https://docs-develop.pleroma.social>).
- [Client Applications for Pleroma](https://docs-develop.pleroma.social/clients.html)
scope "/api", Pleroma.Web do
pipe_through(:api)
- post("/account/register", TwitterAPI.Controller, :register)
- post("/account/password_reset", TwitterAPI.Controller, :password_reset)
-
- post("/account/resend_confirmation_email", TwitterAPI.Controller, :resend_confirmation_email)
-
get(
"/account/confirm_email/:user_id/:token",
TwitterAPI.Controller,
:confirm_email,
as: :confirm_email
)
-
- scope [] do
- pipe_through(:oauth_read_or_public)
-
- get("/statuses/user_timeline", TwitterAPI.Controller, :user_timeline)
- get("/qvitter/statuses/user_timeline", TwitterAPI.Controller, :user_timeline)
- get("/users/show", TwitterAPI.Controller, :show_user)
-
- get("/statuses/followers", TwitterAPI.Controller, :followers)
- get("/statuses/friends", TwitterAPI.Controller, :friends)
- get("/statuses/blocks", TwitterAPI.Controller, :blocks)
- get("/statuses/show/:id", TwitterAPI.Controller, :fetch_status)
- get("/statusnet/conversation/:id", TwitterAPI.Controller, :fetch_conversation)
-
- get("/search", TwitterAPI.Controller, :search)
- get("/statusnet/tags/timeline/:tag", TwitterAPI.Controller, :public_and_external_timeline)
- end
- end
-
- scope "/api", Pleroma.Web do
- pipe_through([:api, :oauth_read_or_public])
-
- get("/statuses/public_timeline", TwitterAPI.Controller, :public_timeline)
-
- get(
- "/statuses/public_and_external_timeline",
- TwitterAPI.Controller,
- :public_and_external_timeline
- )
-
- get("/statuses/networkpublic_timeline", TwitterAPI.Controller, :public_and_external_timeline)
- end
-
- scope "/api", Pleroma.Web, as: :twitter_api_search do
- pipe_through([:api, :oauth_read_or_public])
- get("/pleroma/search_user", TwitterAPI.Controller, :search_user)
end
scope "/api", Pleroma.Web, as: :authenticated_twitter_api do
scope [] do
pipe_through(:oauth_read)
- get("/account/verify_credentials", TwitterAPI.Controller, :verify_credentials)
- post("/account/verify_credentials", TwitterAPI.Controller, :verify_credentials)
-
- get("/statuses/home_timeline", TwitterAPI.Controller, :friends_timeline)
- get("/statuses/friends_timeline", TwitterAPI.Controller, :friends_timeline)
- get("/statuses/mentions", TwitterAPI.Controller, :mentions_timeline)
- get("/statuses/mentions_timeline", TwitterAPI.Controller, :mentions_timeline)
- get("/statuses/dm_timeline", TwitterAPI.Controller, :dm_timeline)
- get("/qvitter/statuses/notifications", TwitterAPI.Controller, :notifications)
-
- get("/pleroma/friend_requests", TwitterAPI.Controller, :friend_requests)
-
- get("/friends/ids", TwitterAPI.Controller, :friends_ids)
- get("/friendships/no_retweets/ids", TwitterAPI.Controller, :empty_array)
-
- get("/mutes/users/ids", TwitterAPI.Controller, :empty_array)
- get("/qvitter/mutes", TwitterAPI.Controller, :raw_empty_array)
-
- get("/externalprofile/show", TwitterAPI.Controller, :external_profile)
-
post("/qvitter/statuses/notifications/read", TwitterAPI.Controller, :notifications_read)
end
-
- scope [] do
- pipe_through(:oauth_write)
-
- post("/account/update_profile", TwitterAPI.Controller, :update_profile)
- post("/account/update_profile_banner", TwitterAPI.Controller, :update_banner)
- post("/qvitter/update_background_image", TwitterAPI.Controller, :update_background)
-
- post("/statuses/update", TwitterAPI.Controller, :status_update)
- post("/statuses/retweet/:id", TwitterAPI.Controller, :retweet)
- post("/statuses/unretweet/:id", TwitterAPI.Controller, :unretweet)
- post("/statuses/destroy/:id", TwitterAPI.Controller, :delete_post)
-
- post("/statuses/pin/:id", TwitterAPI.Controller, :pin)
- post("/statuses/unpin/:id", TwitterAPI.Controller, :unpin)
-
- post("/statusnet/media/upload", TwitterAPI.Controller, :upload)
- post("/media/upload", TwitterAPI.Controller, :upload_json)
- post("/media/metadata/create", TwitterAPI.Controller, :update_media)
-
- post("/favorites/create/:id", TwitterAPI.Controller, :favorite)
- post("/favorites/create", TwitterAPI.Controller, :favorite)
- post("/favorites/destroy/:id", TwitterAPI.Controller, :unfavorite)
-
- post("/qvitter/update_avatar", TwitterAPI.Controller, :update_avatar)
- end
-
- scope [] do
- pipe_through(:oauth_follow)
-
- post("/pleroma/friendships/approve", TwitterAPI.Controller, :approve_friend_request)
- post("/pleroma/friendships/deny", TwitterAPI.Controller, :deny_friend_request)
-
- post("/friendships/create", TwitterAPI.Controller, :follow)
- post("/friendships/destroy", TwitterAPI.Controller, :unfollow)
-
- post("/blocks/create", TwitterAPI.Controller, :block)
- post("/blocks/destroy", TwitterAPI.Controller, :unblock)
- end
end
pipeline :ap_service_actor do
+++ /dev/null
-# Pleroma: A lightweight social networking server
-# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
-# SPDX-License-Identifier: AGPL-3.0-only
-
-defmodule Pleroma.Web.TwitterAPI.Representers.BaseRepresenter do
- defmacro __using__(_opts) do
- quote do
- def to_json(object) do
- to_json(object, %{})
- end
-
- def to_json(object, options) do
- object
- |> to_map(options)
- |> Jason.encode!()
- end
-
- def enum_to_list(enum, options) do
- mapping = fn el -> to_map(el, options) end
- Enum.map(enum, mapping)
- end
-
- def to_map(object) do
- to_map(object, %{})
- end
-
- def enum_to_json(enum) do
- enum_to_json(enum, %{})
- end
-
- def enum_to_json(enum, options) do
- enum
- |> enum_to_list(options)
- |> Jason.encode!()
- end
- end
- end
-end
+++ /dev/null
-# Pleroma: A lightweight social networking server
-# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
-# SPDX-License-Identifier: AGPL-3.0-only
-
-defmodule Pleroma.Web.TwitterAPI.Representers.ObjectRepresenter do
- use Pleroma.Web.TwitterAPI.Representers.BaseRepresenter
- alias Pleroma.Object
-
- def to_map(%Object{data: %{"url" => [url | _]}} = object, _opts) do
- data = object.data
-
- %{
- url: url["href"] |> Pleroma.Web.MediaProxy.url(),
- mimetype: url["mediaType"] || url["mimeType"],
- id: data["uuid"],
- oembed: false,
- description: data["name"]
- }
- end
-
- def to_map(%Object{data: %{"url" => url} = data}, _opts) when is_binary(url) do
- %{
- url: url |> Pleroma.Web.MediaProxy.url(),
- mimetype: data["mediaType"] || data["mimeType"],
- id: data["uuid"],
- oembed: false,
- description: data["name"]
- }
- end
-
- def to_map(%Object{}, _opts) do
- %{}
- end
-
- # If we only get the naked data, wrap in an object
- def to_map(%{} = data, opts) do
- to_map(%Object{data: data}, opts)
- end
-end
# SPDX-License-Identifier: AGPL-3.0-only
defmodule Pleroma.Web.TwitterAPI.TwitterAPI do
- alias Pleroma.Activity
alias Pleroma.Emails.Mailer
alias Pleroma.Emails.UserEmail
alias Pleroma.Repo
alias Pleroma.User
alias Pleroma.UserInviteToken
- alias Pleroma.Web.ActivityPub.ActivityPub
- alias Pleroma.Web.CommonAPI
- alias Pleroma.Web.TwitterAPI.UserView
-
- import Ecto.Query
require Pleroma.Constants
- def create_status(%User{} = user, %{"status" => _} = data) do
- CommonAPI.post(user, data)
- end
-
- def delete(%User{} = user, id) do
- with %Activity{data: %{"type" => _type}} <- Activity.get_by_id(id),
- {:ok, activity} <- CommonAPI.delete(id, user) do
- {:ok, activity}
- end
- end
-
- def follow(%User{} = follower, params) do
- with {:ok, %User{} = followed} <- get_user(params) do
- CommonAPI.follow(follower, followed)
- end
- end
-
- def unfollow(%User{} = follower, params) do
- with {:ok, %User{} = unfollowed} <- get_user(params),
- {:ok, follower} <- CommonAPI.unfollow(follower, unfollowed) do
- {:ok, follower, unfollowed}
- end
- end
-
- def block(%User{} = blocker, params) do
- with {:ok, %User{} = blocked} <- get_user(params),
- {:ok, blocker} <- User.block(blocker, blocked),
- {:ok, _activity} <- ActivityPub.block(blocker, blocked) do
- {:ok, blocker, blocked}
- else
- err -> err
- end
- end
-
- def unblock(%User{} = blocker, params) do
- with {:ok, %User{} = blocked} <- get_user(params),
- {:ok, blocker} <- User.unblock(blocker, blocked),
- {:ok, _activity} <- ActivityPub.unblock(blocker, blocked) do
- {:ok, blocker, blocked}
- else
- err -> err
- end
- end
-
- def repeat(%User{} = user, ap_id_or_id) do
- with {:ok, _announce, %{data: %{"id" => id}}} <- CommonAPI.repeat(ap_id_or_id, user),
- %Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
- {:ok, activity}
- end
- end
-
- def unrepeat(%User{} = user, ap_id_or_id) do
- with {:ok, _unannounce, %{data: %{"id" => id}}} <- CommonAPI.unrepeat(ap_id_or_id, user),
- %Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
- {:ok, activity}
- end
- end
-
- def pin(%User{} = user, ap_id_or_id) do
- CommonAPI.pin(ap_id_or_id, user)
- end
-
- def unpin(%User{} = user, ap_id_or_id) do
- CommonAPI.unpin(ap_id_or_id, user)
- end
-
- def fav(%User{} = user, ap_id_or_id) do
- with {:ok, _fav, %{data: %{"id" => id}}} <- CommonAPI.favorite(ap_id_or_id, user),
- %Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
- {:ok, activity}
- end
- end
-
- def unfav(%User{} = user, ap_id_or_id) do
- with {:ok, _unfav, _fav, %{data: %{"id" => id}}} <- CommonAPI.unfavorite(ap_id_or_id, user),
- %Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
- {:ok, activity}
- end
- end
-
- def upload(%Plug.Upload{} = file, %User{} = user, format \\ "xml") do
- {:ok, object} = ActivityPub.upload(file, actor: User.ap_id(user))
-
- url = List.first(object.data["url"])
- href = url["href"]
- type = url["mediaType"]
-
- case format do
- "xml" ->
- # Fake this as good as possible...
- """
- <?xml version="1.0" encoding="UTF-8"?>
- <rsp stat="ok" xmlns:atom="http://www.w3.org/2005/Atom">
- <mediaid>#{object.id}</mediaid>
- <media_id>#{object.id}</media_id>
- <media_id_string>#{object.id}</media_id_string>
- <media_url>#{href}</media_url>
- <mediaurl>#{href}</mediaurl>
- <atom:link rel="enclosure" href="#{href}" type="#{type}"></atom:link>
- </rsp>
- """
-
- "json" ->
- %{
- media_id: object.id,
- media_id_string: "#{object.id}}",
- media_url: href,
- size: 0
- }
- |> Jason.encode!()
- end
- end
-
def register_user(params, opts \\ []) do
token = params["token"]
{:error, "unknown user"}
end
end
-
- def get_user(user \\ nil, params) do
- case params do
- %{"user_id" => user_id} ->
- case User.get_cached_by_nickname_or_id(user_id) do
- nil ->
- {:error, "No user with such user_id"}
-
- %User{info: %{deactivated: true}} ->
- {:error, "User has been disabled"}
-
- user ->
- {:ok, user}
- end
-
- %{"screen_name" => nickname} ->
- case User.get_cached_by_nickname(nickname) do
- nil -> {:error, "No user with such screen_name"}
- target -> {:ok, target}
- end
-
- _ ->
- if user do
- {:ok, user}
- else
- {:error, "You need to specify screen_name or user_id"}
- end
- end
- end
-
- defp parse_int(string, default)
-
- defp parse_int(string, default) when is_binary(string) do
- with {n, _} <- Integer.parse(string) do
- n
- else
- _e -> default
- end
- end
-
- defp parse_int(_, default), do: default
-
- # TODO: unify the search query with MastoAPI one and do only pagination here
- def search(_user, %{"q" => query} = params) do
- limit = parse_int(params["rpp"], 20)
- page = parse_int(params["page"], 1)
- offset = (page - 1) * limit
-
- q =
- from(
- [a, o] in Activity.with_preloaded_object(Activity),
- where: fragment("?->>'type' = 'Create'", a.data),
- where: ^Pleroma.Constants.as_public() in a.recipients,
- where:
- fragment(
- "to_tsvector('english', ?->>'content') @@ plainto_tsquery('english', ?)",
- o.data,
- ^query
- ),
- limit: ^limit,
- offset: ^offset,
- # this one isn't indexed so psql won't take the wrong index.
- order_by: [desc: :inserted_at]
- )
-
- _activities = Repo.all(q)
- end
-
- def get_external_profile(for_user, uri) do
- with {:ok, %User{} = user} <- User.get_or_fetch(uri) do
- {:ok, UserView.render("show.json", %{user: user, for: for_user})}
- else
- _e ->
- {:error, "Couldn't find user"}
- end
- end
end
defmodule Pleroma.Web.TwitterAPI.Controller do
use Pleroma.Web, :controller
- import Pleroma.Web.ControllerHelper, only: [json_response: 3]
-
alias Ecto.Changeset
- alias Pleroma.Activity
- alias Pleroma.Formatter
alias Pleroma.Notification
- alias Pleroma.Object
- alias Pleroma.Repo
alias Pleroma.User
- alias Pleroma.Web.ActivityPub.ActivityPub
- alias Pleroma.Web.ActivityPub.Visibility
- alias Pleroma.Web.CommonAPI
- alias Pleroma.Web.CommonAPI.Utils
alias Pleroma.Web.OAuth.Token
- alias Pleroma.Web.TwitterAPI.ActivityView
- alias Pleroma.Web.TwitterAPI.NotificationView
alias Pleroma.Web.TwitterAPI.TokenView
- alias Pleroma.Web.TwitterAPI.TwitterAPI
- alias Pleroma.Web.TwitterAPI.UserView
require Logger
- plug(Pleroma.Plugs.RateLimiter, :password_reset when action == :password_reset)
- plug(:only_if_public_instance when action in [:public_timeline, :public_and_external_timeline])
action_fallback(:errors)
- def verify_credentials(%{assigns: %{user: user}} = conn, _params) do
- token = Phoenix.Token.sign(conn, "user socket", user.id)
-
- conn
- |> put_view(UserView)
- |> render("show.json", %{user: user, token: token, for: user})
- end
-
- def status_update(%{assigns: %{user: user}} = conn, %{"status" => _} = status_data) do
- with media_ids <- extract_media_ids(status_data),
- {:ok, activity} <-
- TwitterAPI.create_status(user, Map.put(status_data, "media_ids", media_ids)) do
- conn
- |> json(ActivityView.render("activity.json", activity: activity, for: user))
- else
- _ -> empty_status_reply(conn)
- end
- end
-
- def status_update(conn, _status_data) do
- empty_status_reply(conn)
- end
-
- defp empty_status_reply(conn) do
- bad_request_reply(conn, "Client must provide a 'status' parameter with a value.")
- end
-
- defp extract_media_ids(status_data) do
- with media_ids when not is_nil(media_ids) <- status_data["media_ids"],
- split_ids <- String.split(media_ids, ","),
- clean_ids <- Enum.reject(split_ids, fn id -> String.length(id) == 0 end) do
- clean_ids
- else
- _e -> []
- end
- end
-
- def public_and_external_timeline(%{assigns: %{user: user}} = conn, params) do
- params =
- params
- |> Map.put("type", ["Create", "Announce"])
- |> Map.put("blocking_user", user)
-
- activities = ActivityPub.fetch_public_activities(params)
-
- conn
- |> put_view(ActivityView)
- |> render("index.json", %{activities: activities, for: user})
- end
-
- def public_timeline(%{assigns: %{user: user}} = conn, params) do
- params =
- params
- |> Map.put("type", ["Create", "Announce"])
- |> Map.put("local_only", true)
- |> Map.put("blocking_user", user)
-
- activities = ActivityPub.fetch_public_activities(params)
-
- conn
- |> put_view(ActivityView)
- |> render("index.json", %{activities: activities, for: user})
- end
-
- def friends_timeline(%{assigns: %{user: user}} = conn, params) do
- params =
- params
- |> Map.put("type", ["Create", "Announce", "Follow", "Like"])
- |> Map.put("blocking_user", user)
- |> Map.put("user", user)
-
- activities = ActivityPub.fetch_activities([user.ap_id | user.following], params)
-
- conn
- |> put_view(ActivityView)
- |> render("index.json", %{activities: activities, for: user})
- end
-
- def show_user(conn, params) do
- for_user = conn.assigns.user
-
- with {:ok, shown} <- TwitterAPI.get_user(params),
- true <-
- User.auth_active?(shown) ||
- (for_user && (for_user.id == shown.id || User.superuser?(for_user))) do
- params =
- if for_user do
- %{user: shown, for: for_user}
- else
- %{user: shown}
- end
-
- conn
- |> put_view(UserView)
- |> render("show.json", params)
- else
- {:error, msg} ->
- bad_request_reply(conn, msg)
-
- false ->
- conn
- |> put_status(404)
- |> json(%{error: "Unconfirmed user"})
- end
- end
-
- def user_timeline(%{assigns: %{user: user}} = conn, params) do
- case TwitterAPI.get_user(user, params) do
- {:ok, target_user} ->
- # Twitter and ActivityPub use a different name and sense for this parameter.
- {include_rts, params} = Map.pop(params, "include_rts")
-
- params =
- case include_rts do
- x when x == "false" or x == "0" -> Map.put(params, "exclude_reblogs", "true")
- _ -> params
- end
-
- activities = ActivityPub.fetch_user_activities(target_user, user, params)
-
- conn
- |> put_view(ActivityView)
- |> render("index.json", %{activities: activities, for: user})
-
- {:error, msg} ->
- bad_request_reply(conn, msg)
- end
- end
-
- def mentions_timeline(%{assigns: %{user: user}} = conn, params) do
- params =
- params
- |> Map.put("type", ["Create", "Announce", "Follow", "Like"])
- |> Map.put("blocking_user", user)
- |> Map.put(:visibility, ~w[unlisted public private])
-
- activities = ActivityPub.fetch_activities([user.ap_id], params)
-
- conn
- |> put_view(ActivityView)
- |> render("index.json", %{activities: activities, for: user})
- end
-
- def dm_timeline(%{assigns: %{user: user}} = conn, params) do
- params =
- params
- |> Map.put("type", "Create")
- |> Map.put("blocking_user", user)
- |> Map.put("user", user)
- |> Map.put(:visibility, "direct")
- |> Map.put(:order, :desc)
-
- activities =
- ActivityPub.fetch_activities_query([user.ap_id], params)
- |> Repo.all()
-
- conn
- |> put_view(ActivityView)
- |> render("index.json", %{activities: activities, for: user})
- end
-
- def notifications(%{assigns: %{user: user}} = conn, params) do
- params =
- if Map.has_key?(params, "with_muted") do
- Map.put(params, :with_muted, params["with_muted"] in [true, "True", "true", "1"])
- else
- params
- end
-
- notifications = Notification.for_user(user, params)
-
- conn
- |> put_view(NotificationView)
- |> render("notification.json", %{notifications: notifications, for: user})
- end
-
- def notifications_read(%{assigns: %{user: user}} = conn, %{"latest_id" => latest_id} = params) do
- Notification.set_read_up_to(user, latest_id)
-
- notifications = Notification.for_user(user, params)
-
- conn
- |> put_view(NotificationView)
- |> render("notification.json", %{notifications: notifications, for: user})
- end
-
- def notifications_read(%{assigns: %{user: _user}} = conn, _) do
- bad_request_reply(conn, "You need to specify latest_id")
- end
-
- def follow(%{assigns: %{user: user}} = conn, params) do
- case TwitterAPI.follow(user, params) do
- {:ok, user, followed, _activity} ->
- conn
- |> put_view(UserView)
- |> render("show.json", %{user: followed, for: user})
-
- {:error, msg} ->
- forbidden_json_reply(conn, msg)
- end
- end
-
- def block(%{assigns: %{user: user}} = conn, params) do
- case TwitterAPI.block(user, params) do
- {:ok, user, blocked} ->
- conn
- |> put_view(UserView)
- |> render("show.json", %{user: blocked, for: user})
-
- {:error, msg} ->
- forbidden_json_reply(conn, msg)
- end
- end
-
- def unblock(%{assigns: %{user: user}} = conn, params) do
- case TwitterAPI.unblock(user, params) do
- {:ok, user, blocked} ->
- conn
- |> put_view(UserView)
- |> render("show.json", %{user: blocked, for: user})
-
- {:error, msg} ->
- forbidden_json_reply(conn, msg)
- end
- end
-
- def delete_post(%{assigns: %{user: user}} = conn, %{"id" => id}) do
- with {:ok, activity} <- TwitterAPI.delete(user, id) do
- conn
- |> put_view(ActivityView)
- |> render("activity.json", %{activity: activity, for: user})
- end
- end
-
- def unfollow(%{assigns: %{user: user}} = conn, params) do
- case TwitterAPI.unfollow(user, params) do
- {:ok, user, unfollowed} ->
- conn
- |> put_view(UserView)
- |> render("show.json", %{user: unfollowed, for: user})
-
- {:error, msg} ->
- forbidden_json_reply(conn, msg)
- end
- end
-
- def fetch_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
- with %Activity{} = activity <- Activity.get_by_id(id),
- true <- Visibility.visible_for_user?(activity, user) do
- conn
- |> put_view(ActivityView)
- |> render("activity.json", %{activity: activity, for: user})
- end
- end
-
- def fetch_conversation(%{assigns: %{user: user}} = conn, %{"id" => id}) do
- with context when is_binary(context) <- Utils.conversation_id_to_context(id),
- activities <-
- ActivityPub.fetch_activities_for_context(context, %{
- "blocking_user" => user,
- "user" => user
- }) do
- conn
- |> put_view(ActivityView)
- |> render("index.json", %{activities: activities, for: user})
- end
- end
-
- @doc """
- Updates metadata of uploaded media object.
- Derived from [Twitter API endpoint](https://developer.twitter.com/en/docs/media/upload-media/api-reference/post-media-metadata-create).
- """
- def update_media(%{assigns: %{user: user}} = conn, %{"media_id" => id} = data) do
- object = Repo.get(Object, id)
- description = get_in(data, ["alt_text", "text"]) || data["name"] || data["description"]
-
- {conn, status, response_body} =
- cond do
- !object ->
- {halt(conn), :not_found, ""}
-
- !Object.authorize_mutation(object, user) ->
- {halt(conn), :forbidden, "You can only update your own uploads."}
-
- !is_binary(description) ->
- {conn, :not_modified, ""}
-
- true ->
- new_data = Map.put(object.data, "name", description)
-
- {:ok, _} =
- object
- |> Object.change(%{data: new_data})
- |> Repo.update()
-
- {conn, :no_content, ""}
- end
-
- conn
- |> put_status(status)
- |> json(response_body)
- end
-
- def upload(%{assigns: %{user: user}} = conn, %{"media" => media}) do
- response = TwitterAPI.upload(media, user)
-
- conn
- |> put_resp_content_type("application/atom+xml")
- |> send_resp(200, response)
- end
-
- def upload_json(%{assigns: %{user: user}} = conn, %{"media" => media}) do
- response = TwitterAPI.upload(media, user, "json")
-
- conn
- |> json_reply(200, response)
- end
-
- def get_by_id_or_ap_id(id) do
- activity = Activity.get_by_id(id) || Activity.get_create_by_object_ap_id(id)
-
- if activity.data["type"] == "Create" do
- activity
- else
- Activity.get_create_by_object_ap_id(activity.data["object"])
- end
- end
-
- def favorite(%{assigns: %{user: user}} = conn, %{"id" => id}) do
- with {:ok, activity} <- TwitterAPI.fav(user, id) do
- conn
- |> put_view(ActivityView)
- |> render("activity.json", %{activity: activity, for: user})
- else
- _ -> json_reply(conn, 400, Jason.encode!(%{}))
- end
- end
-
- def unfavorite(%{assigns: %{user: user}} = conn, %{"id" => id}) do
- with {:ok, activity} <- TwitterAPI.unfav(user, id) do
- conn
- |> put_view(ActivityView)
- |> render("activity.json", %{activity: activity, for: user})
- else
- _ -> json_reply(conn, 400, Jason.encode!(%{}))
- end
- end
-
- def retweet(%{assigns: %{user: user}} = conn, %{"id" => id}) do
- with {:ok, activity} <- TwitterAPI.repeat(user, id) do
- conn
- |> put_view(ActivityView)
- |> render("activity.json", %{activity: activity, for: user})
- else
- _ -> json_reply(conn, 400, Jason.encode!(%{}))
- end
- end
-
- def unretweet(%{assigns: %{user: user}} = conn, %{"id" => id}) do
- with {:ok, activity} <- TwitterAPI.unrepeat(user, id) do
- conn
- |> put_view(ActivityView)
- |> render("activity.json", %{activity: activity, for: user})
- else
- _ -> json_reply(conn, 400, Jason.encode!(%{}))
- end
- end
-
- def pin(%{assigns: %{user: user}} = conn, %{"id" => id}) do
- with {:ok, activity} <- TwitterAPI.pin(user, id) do
- conn
- |> put_view(ActivityView)
- |> render("activity.json", %{activity: activity, for: user})
- else
- {:error, message} -> bad_request_reply(conn, message)
- err -> err
- end
- end
-
- def unpin(%{assigns: %{user: user}} = conn, %{"id" => id}) do
- with {:ok, activity} <- TwitterAPI.unpin(user, id) do
- conn
- |> put_view(ActivityView)
- |> render("activity.json", %{activity: activity, for: user})
- else
- {:error, message} -> bad_request_reply(conn, message)
- err -> err
- end
- end
-
- def register(conn, params) do
- with {:ok, user} <- TwitterAPI.register_user(params) do
- conn
- |> put_view(UserView)
- |> render("show.json", %{user: user})
- else
- {:error, errors} ->
- conn
- |> json_reply(400, Jason.encode!(errors))
- end
- end
-
- def password_reset(conn, params) do
- nickname_or_email = params["email"] || params["nickname"]
-
- with {:ok, _} <- TwitterAPI.password_reset(nickname_or_email) do
- json_response(conn, :no_content, "")
- else
- {:error, "unknown user"} ->
- send_resp(conn, :not_found, "")
-
- {:error, _} ->
- send_resp(conn, :bad_request, "")
- end
- end
-
def confirm_email(conn, %{"user_id" => uid, "token" => token}) do
with %User{} = user <- User.get_cached_by_id(uid),
true <- user.local,
end
end
- def resend_confirmation_email(conn, params) do
- nickname_or_email = params["email"] || params["nickname"]
-
- with %User{} = user <- User.get_by_nickname_or_email(nickname_or_email),
- {:ok, _} <- User.try_send_confirmation_email(user) do
- conn
- |> json_response(:no_content, "")
- end
- end
-
- def update_avatar(%{assigns: %{user: user}} = conn, %{"img" => ""}) do
- change = Changeset.change(user, %{avatar: nil})
- {:ok, user} = User.update_and_set_cache(change)
- CommonAPI.update(user)
-
- conn
- |> put_view(UserView)
- |> render("show.json", %{user: user, for: user})
- end
-
- def update_avatar(%{assigns: %{user: user}} = conn, params) do
- {:ok, object} = ActivityPub.upload(params, type: :avatar)
- change = Changeset.change(user, %{avatar: object.data})
- {:ok, user} = User.update_and_set_cache(change)
- CommonAPI.update(user)
-
- conn
- |> put_view(UserView)
- |> render("show.json", %{user: user, for: user})
- end
-
- def update_banner(%{assigns: %{user: user}} = conn, %{"banner" => ""}) do
- with new_info <- %{"banner" => %{}},
- info_cng <- User.Info.profile_update(user.info, new_info),
- changeset <- Ecto.Changeset.change(user) |> Ecto.Changeset.put_embed(:info, info_cng),
- {:ok, user} <- User.update_and_set_cache(changeset) do
- CommonAPI.update(user)
- response = %{url: nil} |> Jason.encode!()
-
- conn
- |> json_reply(200, response)
- end
- end
-
- def update_banner(%{assigns: %{user: user}} = conn, params) do
- with {:ok, object} <- ActivityPub.upload(%{"img" => params["banner"]}, type: :banner),
- new_info <- %{"banner" => object.data},
- info_cng <- User.Info.profile_update(user.info, new_info),
- changeset <- Ecto.Changeset.change(user) |> Ecto.Changeset.put_embed(:info, info_cng),
- {:ok, user} <- User.update_and_set_cache(changeset) do
- CommonAPI.update(user)
- %{"url" => [%{"href" => href} | _]} = object.data
- response = %{url: href} |> Jason.encode!()
-
- conn
- |> json_reply(200, response)
- end
- end
-
- def update_background(%{assigns: %{user: user}} = conn, %{"img" => ""}) do
- with new_info <- %{"background" => %{}},
- info_cng <- User.Info.profile_update(user.info, new_info),
- changeset <- Ecto.Changeset.change(user) |> Ecto.Changeset.put_embed(:info, info_cng),
- {:ok, _user} <- User.update_and_set_cache(changeset) do
- response = %{url: nil} |> Jason.encode!()
-
- conn
- |> json_reply(200, response)
- end
- end
-
- def update_background(%{assigns: %{user: user}} = conn, params) do
- with {:ok, object} <- ActivityPub.upload(params, type: :background),
- new_info <- %{"background" => object.data},
- info_cng <- User.Info.profile_update(user.info, new_info),
- changeset <- Ecto.Changeset.change(user) |> Ecto.Changeset.put_embed(:info, info_cng),
- {:ok, _user} <- User.update_and_set_cache(changeset) do
- %{"url" => [%{"href" => href} | _]} = object.data
- response = %{url: href} |> Jason.encode!()
-
- conn
- |> json_reply(200, response)
- end
- end
-
- def external_profile(%{assigns: %{user: current_user}} = conn, %{"profileurl" => uri}) do
- with {:ok, user_map} <- TwitterAPI.get_external_profile(current_user, uri),
- response <- Jason.encode!(user_map) do
- conn
- |> json_reply(200, response)
- else
- _e ->
- conn
- |> put_status(404)
- |> json(%{error: "Can't find user"})
- end
- end
-
- def followers(%{assigns: %{user: for_user}} = conn, params) do
- {:ok, page} = Ecto.Type.cast(:integer, params["page"] || 1)
-
- with {:ok, user} <- TwitterAPI.get_user(for_user, params),
- {:ok, followers} <- User.get_followers(user, page) do
- followers =
- cond do
- for_user && user.id == for_user.id -> followers
- user.info.hide_followers -> []
- true -> followers
- end
-
- conn
- |> put_view(UserView)
- |> render("index.json", %{users: followers, for: conn.assigns[:user]})
- else
- _e -> bad_request_reply(conn, "Can't get followers")
- end
- end
-
- def friends(%{assigns: %{user: for_user}} = conn, params) do
- {:ok, page} = Ecto.Type.cast(:integer, params["page"] || 1)
- {:ok, export} = Ecto.Type.cast(:boolean, params["all"] || false)
-
- page = if export, do: nil, else: page
-
- with {:ok, user} <- TwitterAPI.get_user(conn.assigns[:user], params),
- {:ok, friends} <- User.get_friends(user, page) do
- friends =
- cond do
- for_user && user.id == for_user.id -> friends
- user.info.hide_follows -> []
- true -> friends
- end
-
- conn
- |> put_view(UserView)
- |> render("index.json", %{users: friends, for: conn.assigns[:user]})
- else
- _e -> bad_request_reply(conn, "Can't get friends")
- end
- end
-
def oauth_tokens(%{assigns: %{user: user}} = conn, _params) do
with oauth_tokens <- Token.get_user_tokens(user) do
conn
json_reply(conn, 201, "")
end
- def blocks(%{assigns: %{user: user}} = conn, _params) do
- with blocked_users <- User.blocked_users(user) do
- conn
- |> put_view(UserView)
- |> render("index.json", %{users: blocked_users, for: user})
- end
- end
-
- def friend_requests(conn, params) do
- with {:ok, user} <- TwitterAPI.get_user(conn.assigns[:user], params),
- {:ok, friend_requests} <- User.get_follow_requests(user) do
- conn
- |> put_view(UserView)
- |> render("index.json", %{users: friend_requests, for: conn.assigns[:user]})
- else
- _e -> bad_request_reply(conn, "Can't get friend requests")
- end
- end
-
- def approve_friend_request(conn, %{"user_id" => uid} = _params) do
- with followed <- conn.assigns[:user],
- %User{} = follower <- User.get_cached_by_id(uid),
- {:ok, follower} <- CommonAPI.accept_follow_request(follower, followed) do
- conn
- |> put_view(UserView)
- |> render("show.json", %{user: follower, for: followed})
- else
- e -> bad_request_reply(conn, "Can't approve user: #{inspect(e)}")
- end
- end
-
- def deny_friend_request(conn, %{"user_id" => uid} = _params) do
- with followed <- conn.assigns[:user],
- %User{} = follower <- User.get_cached_by_id(uid),
- {:ok, follower} <- CommonAPI.reject_follow_request(follower, followed) do
- conn
- |> put_view(UserView)
- |> render("show.json", %{user: follower, for: followed})
- else
- e -> bad_request_reply(conn, "Can't deny user: #{inspect(e)}")
- end
- end
-
- def friends_ids(%{assigns: %{user: user}} = conn, _params) do
- with {:ok, friends} <- User.get_friends(user) do
- ids =
- friends
- |> Enum.map(fn x -> x.id end)
- |> Jason.encode!()
-
- json(conn, ids)
- else
- _e -> bad_request_reply(conn, "Can't get friends")
- end
- end
-
- def empty_array(conn, _params) do
- json(conn, Jason.encode!([]))
- end
-
- def raw_empty_array(conn, _params) do
- json(conn, [])
- end
-
- defp build_info_cng(user, params) do
- info_params =
- [
- "no_rich_text",
- "locked",
- "hide_followers",
- "hide_follows",
- "hide_favorites",
- "show_role",
- "skip_thread_containment"
- ]
- |> Enum.reduce(%{}, fn key, res ->
- if value = params[key] do
- Map.put(res, key, value == "true")
- else
- res
- end
- end)
-
- info_params =
- if value = params["default_scope"] do
- Map.put(info_params, "default_scope", value)
- else
- info_params
- end
-
- User.Info.profile_update(user.info, info_params)
- end
-
- defp parse_profile_bio(user, params) do
- if bio = params["description"] do
- emojis_text = (params["description"] || "") <> " " <> (params["name"] || "")
-
- emojis =
- ((user.info.emoji || []) ++ Formatter.get_emoji_map(emojis_text))
- |> Enum.dedup()
-
- user_info =
- user.info
- |> Map.put(
- "emoji",
- emojis
- )
-
- params
- |> Map.put("bio", User.parse_bio(bio, user))
- |> Map.put("info", user_info)
- else
- params
- end
- end
-
- def update_profile(%{assigns: %{user: user}} = conn, params) do
- params = parse_profile_bio(user, params)
- info_cng = build_info_cng(user, params)
-
- with changeset <- User.update_changeset(user, params),
- changeset <- Ecto.Changeset.put_embed(changeset, :info, info_cng),
- {:ok, user} <- User.update_and_set_cache(changeset) do
- CommonAPI.update(user)
-
- conn
- |> put_view(UserView)
- |> render("user.json", %{user: user, for: user})
- else
- error ->
- Logger.debug("Can't update user: #{inspect(error)}")
- bad_request_reply(conn, "Can't update user")
- end
- end
-
- def search(%{assigns: %{user: user}} = conn, %{"q" => _query} = params) do
- activities = TwitterAPI.search(user, params)
-
+ def errors(conn, {:param_cast, _}) do
conn
- |> put_view(ActivityView)
- |> render("index.json", %{activities: activities, for: user})
+ |> put_status(400)
+ |> json("Invalid parameters")
end
- def search_user(%{assigns: %{user: user}} = conn, %{"query" => query}) do
- users = User.search(query, resolve: true, for_user: user)
-
+ def errors(conn, _) do
conn
- |> put_view(UserView)
- |> render("index.json", %{users: users, for: user})
- end
-
- defp bad_request_reply(conn, error_message) do
- json = error_json(conn, error_message)
- json_reply(conn, 400, json)
+ |> put_status(500)
+ |> json("Something went wrong")
end
defp json_reply(conn, status, json) do
|> send_resp(status, json)
end
- defp forbidden_json_reply(conn, error_message) do
- json = error_json(conn, error_message)
- json_reply(conn, 403, json)
- end
+ def notifications_read(%{assigns: %{user: user}} = conn, %{"latest_id" => latest_id} = params) do
+ Notification.set_read_up_to(user, latest_id)
- def only_if_public_instance(%{assigns: %{user: %User{}}} = conn, _), do: conn
+ notifications = Notification.for_user(user, params)
- def only_if_public_instance(conn, _) do
- if Pleroma.Config.get([:instance, :public]) do
- conn
- else
- conn
- |> forbidden_json_reply("Invalid credentials.")
- |> halt()
- end
+ conn
+ # XXX: This is a hack because pleroma-fe still uses that API.
+ |> put_view(Pleroma.Web.MastodonAPI.NotificationView)
+ |> render("index.json", %{notifications: notifications, for: user})
end
- defp error_json(conn, error_message) do
- %{"error" => error_message, "request" => conn.request_path} |> Jason.encode!()
+ def notifications_read(%{assigns: %{user: _user}} = conn, _) do
+ bad_request_reply(conn, "You need to specify latest_id")
end
- def errors(conn, {:param_cast, _}) do
- conn
- |> put_status(400)
- |> json("Invalid parameters")
+ defp bad_request_reply(conn, error_message) do
+ json = error_json(conn, error_message)
+ json_reply(conn, 400, json)
end
- def errors(conn, _) do
- conn
- |> put_status(500)
- |> json("Something went wrong")
+ defp error_json(conn, error_message) do
+ %{"error" => error_message, "request" => conn.request_path} |> Jason.encode!()
end
end
+++ /dev/null
-# Pleroma: A lightweight social networking server
-# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
-# SPDX-License-Identifier: AGPL-3.0-only
-
-defmodule Pleroma.Web.TwitterAPI.ActivityView do
- use Pleroma.Web, :view
- alias Pleroma.Activity
- alias Pleroma.Formatter
- alias Pleroma.HTML
- alias Pleroma.Object
- alias Pleroma.Repo
- alias Pleroma.User
- alias Pleroma.Web.CommonAPI
- alias Pleroma.Web.CommonAPI.Utils
- alias Pleroma.Web.MastodonAPI.StatusView
- alias Pleroma.Web.TwitterAPI.ActivityView
- alias Pleroma.Web.TwitterAPI.Representers.ObjectRepresenter
- alias Pleroma.Web.TwitterAPI.UserView
-
- import Ecto.Query
- require Logger
- require Pleroma.Constants
-
- defp query_context_ids([]), do: []
-
- defp query_context_ids(contexts) do
- query = from(o in Object, where: fragment("(?)->>'id' = ANY(?)", o.data, ^contexts))
-
- Repo.all(query)
- end
-
- defp query_users([]), do: []
-
- defp query_users(user_ids) do
- query = from(user in User, where: user.ap_id in ^user_ids)
-
- Repo.all(query)
- end
-
- defp collect_context_ids(activities) do
- _contexts =
- activities
- |> Enum.reject(& &1.data["context_id"])
- |> Enum.map(fn %{data: data} ->
- data["context"]
- end)
- |> Enum.filter(& &1)
- |> query_context_ids()
- |> Enum.reduce(%{}, fn %{data: %{"id" => ap_id}, id: id}, acc ->
- Map.put(acc, ap_id, id)
- end)
- end
-
- defp collect_users(activities) do
- activities
- |> Enum.map(fn activity ->
- case activity.data do
- data = %{"type" => "Follow"} ->
- [data["actor"], data["object"]]
-
- data ->
- [data["actor"]]
- end ++ activity.recipients
- end)
- |> List.flatten()
- |> Enum.uniq()
- |> query_users()
- |> Enum.reduce(%{}, fn user, acc ->
- Map.put(acc, user.ap_id, user)
- end)
- end
-
- defp get_context_id(%{data: %{"context_id" => context_id}}, _) when not is_nil(context_id),
- do: context_id
-
- defp get_context_id(%{data: %{"context" => nil}}, _), do: nil
-
- defp get_context_id(%{data: %{"context" => context}}, options) do
- cond do
- id = options[:context_ids][context] -> id
- true -> Utils.context_to_conversation_id(context)
- end
- end
-
- defp get_context_id(_, _), do: nil
-
- defp get_user(ap_id, opts) do
- cond do
- user = opts[:users][ap_id] ->
- user
-
- String.ends_with?(ap_id, "/followers") ->
- nil
-
- ap_id == Pleroma.Constants.as_public() ->
- nil
-
- user = User.get_cached_by_ap_id(ap_id) ->
- user
-
- user = User.get_by_guessed_nickname(ap_id) ->
- user
-
- true ->
- User.error_user(ap_id)
- end
- end
-
- def render("index.json", opts) do
- context_ids = collect_context_ids(opts.activities)
- users = collect_users(opts.activities)
-
- opts =
- opts
- |> Map.put(:context_ids, context_ids)
- |> Map.put(:users, users)
-
- safe_render_many(
- opts.activities,
- ActivityView,
- "activity.json",
- opts
- )
- end
-
- def render("activity.json", %{activity: %{data: %{"type" => "Delete"}} = activity} = opts) do
- user = get_user(activity.data["actor"], opts)
- created_at = activity.data["published"] |> Utils.date_to_asctime()
-
- %{
- "id" => activity.id,
- "uri" => activity.data["object"],
- "user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
- "attentions" => [],
- "statusnet_html" => "deleted notice {{tag",
- "text" => "deleted notice {{tag",
- "is_local" => activity.local,
- "is_post_verb" => false,
- "created_at" => created_at,
- "in_reply_to_status_id" => nil,
- "external_url" => activity.data["id"],
- "activity_type" => "delete"
- }
- end
-
- def render("activity.json", %{activity: %{data: %{"type" => "Follow"}} = activity} = opts) do
- user = get_user(activity.data["actor"], opts)
- created_at = activity.data["published"] || DateTime.to_iso8601(activity.inserted_at)
- created_at = created_at |> Utils.date_to_asctime()
-
- followed = get_user(activity.data["object"], opts)
- text = "#{user.nickname} started following #{followed.nickname}"
-
- %{
- "id" => activity.id,
- "user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
- "attentions" => [],
- "statusnet_html" => text,
- "text" => text,
- "is_local" => activity.local,
- "is_post_verb" => false,
- "created_at" => created_at,
- "in_reply_to_status_id" => nil,
- "external_url" => activity.data["id"],
- "activity_type" => "follow"
- }
- end
-
- def render("activity.json", %{activity: %{data: %{"type" => "Announce"}} = activity} = opts) do
- user = get_user(activity.data["actor"], opts)
- created_at = activity.data["published"] |> Utils.date_to_asctime()
- announced_activity = Activity.get_create_by_object_ap_id(activity.data["object"])
-
- text = "#{user.nickname} repeated a status."
-
- retweeted_status = render("activity.json", Map.merge(opts, %{activity: announced_activity}))
-
- %{
- "id" => activity.id,
- "user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
- "statusnet_html" => text,
- "text" => text,
- "is_local" => activity.local,
- "is_post_verb" => false,
- "uri" => "tag:#{activity.data["id"]}:objectType=note",
- "created_at" => created_at,
- "retweeted_status" => retweeted_status,
- "statusnet_conversation_id" => get_context_id(announced_activity, opts),
- "external_url" => activity.data["id"],
- "activity_type" => "repeat"
- }
- end
-
- def render("activity.json", %{activity: %{data: %{"type" => "Like"}} = activity} = opts) do
- user = get_user(activity.data["actor"], opts)
- liked_activity = Activity.get_create_by_object_ap_id(activity.data["object"])
- liked_activity_id = if liked_activity, do: liked_activity.id, else: nil
-
- created_at =
- activity.data["published"]
- |> Utils.date_to_asctime()
-
- text = "#{user.nickname} favorited a status."
-
- favorited_status =
- if liked_activity,
- do: render("activity.json", Map.merge(opts, %{activity: liked_activity})),
- else: nil
-
- %{
- "id" => activity.id,
- "user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
- "statusnet_html" => text,
- "text" => text,
- "is_local" => activity.local,
- "is_post_verb" => false,
- "uri" => "tag:#{activity.data["id"]}:objectType=Favourite",
- "created_at" => created_at,
- "favorited_status" => favorited_status,
- "in_reply_to_status_id" => liked_activity_id,
- "external_url" => activity.data["id"],
- "activity_type" => "like"
- }
- end
-
- def render(
- "activity.json",
- %{activity: %{data: %{"type" => "Create", "object" => object_id}} = activity} = opts
- ) do
- user = get_user(activity.data["actor"], opts)
-
- object = Object.normalize(object_id)
-
- created_at = object.data["published"] |> Utils.date_to_asctime()
- like_count = object.data["like_count"] || 0
- announcement_count = object.data["announcement_count"] || 0
- favorited = opts[:for] && opts[:for].ap_id in (object.data["likes"] || [])
- repeated = opts[:for] && opts[:for].ap_id in (object.data["announcements"] || [])
- pinned = activity.id in user.info.pinned_activities
-
- attentions =
- []
- |> Utils.maybe_notify_to_recipients(activity)
- |> Utils.maybe_notify_mentioned_recipients(activity)
- |> Enum.map(fn ap_id -> get_user(ap_id, opts) end)
- |> Enum.filter(& &1)
- |> Enum.map(fn user -> UserView.render("show.json", %{user: user, for: opts[:for]}) end)
-
- conversation_id = get_context_id(activity, opts)
-
- tags = object.data["tag"] || []
- possibly_sensitive = object.data["sensitive"] || Enum.member?(tags, "nsfw")
-
- tags = if possibly_sensitive, do: Enum.uniq(["nsfw" | tags]), else: tags
-
- {summary, content} = render_content(object.data)
-
- html =
- content
- |> HTML.get_cached_scrubbed_html_for_activity(
- User.html_filter_policy(opts[:for]),
- activity,
- "twitterapi:content"
- )
- |> Formatter.emojify(object.data["emoji"])
-
- text =
- if content do
- content
- |> String.replace(~r/<br\s?\/?>/, "\n")
- |> HTML.get_cached_stripped_html_for_activity(activity, "twitterapi:content")
- else
- ""
- end
-
- reply_parent = Activity.get_in_reply_to_activity(activity)
-
- reply_user = reply_parent && User.get_cached_by_ap_id(reply_parent.actor)
-
- summary = HTML.strip_tags(summary)
-
- card =
- StatusView.render(
- "card.json",
- Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
- )
-
- thread_muted? =
- case activity.thread_muted? do
- thread_muted? when is_boolean(thread_muted?) -> thread_muted?
- nil -> CommonAPI.thread_muted?(user, activity)
- end
-
- %{
- "id" => activity.id,
- "uri" => object.data["id"],
- "user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
- "statusnet_html" => html,
- "text" => text,
- "is_local" => activity.local,
- "is_post_verb" => true,
- "created_at" => created_at,
- "in_reply_to_status_id" => reply_parent && reply_parent.id,
- "in_reply_to_screen_name" => reply_user && reply_user.nickname,
- "in_reply_to_profileurl" => User.profile_url(reply_user),
- "in_reply_to_ostatus_uri" => reply_user && reply_user.ap_id,
- "in_reply_to_user_id" => reply_user && reply_user.id,
- "statusnet_conversation_id" => conversation_id,
- "attachments" => (object.data["attachment"] || []) |> ObjectRepresenter.enum_to_list(opts),
- "attentions" => attentions,
- "fave_num" => like_count,
- "repeat_num" => announcement_count,
- "favorited" => !!favorited,
- "repeated" => !!repeated,
- "pinned" => pinned,
- "external_url" => object.data["external_url"] || object.data["id"],
- "tags" => tags,
- "activity_type" => "post",
- "possibly_sensitive" => possibly_sensitive,
- "visibility" => Pleroma.Web.ActivityPub.Visibility.get_visibility(object),
- "summary" => summary,
- "summary_html" => summary |> Formatter.emojify(object.data["emoji"]),
- "card" => card,
- "muted" => thread_muted? || User.mutes?(opts[:for], user)
- }
- end
-
- def render("activity.json", %{activity: unhandled_activity}) do
- Logger.warn("#{__MODULE__} unhandled activity: #{inspect(unhandled_activity)}")
- nil
- end
-
- def render_content(%{"type" => "Note"} = object) do
- summary = object["summary"]
-
- content =
- if !!summary and summary != "" do
- "<p>#{summary}</p>#{object["content"]}"
- else
- object["content"]
- end
-
- {summary, content}
- end
-
- def render_content(%{"type" => object_type} = object)
- when object_type in ["Article", "Page", "Video"] do
- summary = object["name"] || object["summary"]
-
- content =
- if !!summary and summary != "" and is_bitstring(object["url"]) do
- "<p><a href=\"#{object["url"]}\">#{summary}</a></p>#{object["content"]}"
- else
- object["content"]
- end
-
- {summary, content}
- end
-
- def render_content(object) do
- summary = object["summary"] || "Unhandled activity type: #{object["type"]}"
- content = "<p>#{summary}</p>#{object["content"]}"
-
- {summary, content}
- end
-end
+++ /dev/null
-# Pleroma: A lightweight social networking server
-# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
-# SPDX-License-Identifier: AGPL-3.0-only
-
-defmodule Pleroma.Web.TwitterAPI.NotificationView do
- use Pleroma.Web, :view
- alias Pleroma.Notification
- alias Pleroma.User
- alias Pleroma.Web.CommonAPI.Utils
- alias Pleroma.Web.TwitterAPI.ActivityView
- alias Pleroma.Web.TwitterAPI.UserView
-
- require Pleroma.Constants
-
- defp get_user(ap_id, opts) do
- cond do
- user = opts[:users][ap_id] ->
- user
-
- String.ends_with?(ap_id, "/followers") ->
- nil
-
- ap_id == Pleroma.Constants.as_public() ->
- nil
-
- true ->
- User.get_cached_by_ap_id(ap_id)
- end
- end
-
- def render("notification.json", %{notifications: notifications, for: user}) do
- render_many(
- notifications,
- Pleroma.Web.TwitterAPI.NotificationView,
- "notification.json",
- for: user
- )
- end
-
- def render(
- "notification.json",
- %{
- notification: %Notification{
- id: id,
- seen: seen,
- activity: activity,
- inserted_at: created_at
- },
- for: user
- } = opts
- ) do
- ntype =
- case activity.data["type"] do
- "Create" -> "mention"
- "Like" -> "like"
- "Announce" -> "repeat"
- "Follow" -> "follow"
- end
-
- from = get_user(activity.data["actor"], opts)
-
- %{
- "id" => id,
- "ntype" => ntype,
- "notice" => ActivityView.render("activity.json", %{activity: activity, for: user}),
- "from_profile" => UserView.render("show.json", %{user: from, for: user}),
- "is_seen" => if(seen, do: 1, else: 0),
- "created_at" => created_at |> Utils.format_naive_asctime()
- }
- end
-end
+++ /dev/null
-# Pleroma: A lightweight social networking server
-# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
-# SPDX-License-Identifier: AGPL-3.0-only
-
-defmodule Pleroma.Web.TwitterAPI.UserView do
- use Pleroma.Web, :view
- alias Pleroma.Formatter
- alias Pleroma.HTML
- alias Pleroma.User
- alias Pleroma.Web.CommonAPI.Utils
- alias Pleroma.Web.MediaProxy
-
- def render("show.json", %{user: user = %User{}} = assigns) do
- render_one(user, Pleroma.Web.TwitterAPI.UserView, "user.json", assigns)
- end
-
- def render("index.json", %{users: users, for: user}) do
- users
- |> render_many(Pleroma.Web.TwitterAPI.UserView, "user.json", for: user)
- |> Enum.filter(&Enum.any?/1)
- end
-
- def render("user.json", %{user: user = %User{}} = assigns) do
- if User.visible_for?(user, assigns[:for]),
- do: do_render("user.json", assigns),
- else: %{}
- end
-
- def render("short.json", %{
- user: %User{
- nickname: nickname,
- id: id,
- ap_id: ap_id,
- name: name
- }
- }) do
- %{
- "fullname" => name,
- "id" => id,
- "ostatus_uri" => ap_id,
- "profile_url" => ap_id,
- "screen_name" => nickname
- }
- end
-
- defp do_render("user.json", %{user: user = %User{}} = assigns) do
- for_user = assigns[:for]
- image = User.avatar_url(user) |> MediaProxy.url()
-
- {following, follows_you, statusnet_blocking} =
- if for_user do
- {
- User.following?(for_user, user),
- User.following?(user, for_user),
- User.blocks?(for_user, user)
- }
- else
- {false, false, false}
- end
-
- user_info = User.get_cached_user_info(user)
-
- emoji =
- (user.info.source_data["tag"] || [])
- |> Enum.filter(fn %{"type" => t} -> t == "Emoji" end)
- |> Enum.map(fn %{"icon" => %{"url" => url}, "name" => name} ->
- {String.trim(name, ":"), url}
- end)
-
- emoji = Enum.dedup(emoji ++ user.info.emoji)
-
- description_html =
- (user.bio || "")
- |> HTML.filter_tags(User.html_filter_policy(for_user))
- |> Formatter.emojify(emoji)
-
- fields =
- user.info
- |> User.Info.fields()
- |> Enum.map(fn %{"name" => name, "value" => value} ->
- %{
- "name" => Pleroma.HTML.strip_tags(name),
- "value" => Pleroma.HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
- }
- end)
-
- data =
- %{
- "created_at" => user.inserted_at |> Utils.format_naive_asctime(),
- "description" => HTML.strip_tags((user.bio || "") |> String.replace("<br>", "\n")),
- "description_html" => description_html,
- "favourites_count" => 0,
- "followers_count" => user_info[:follower_count],
- "following" => following,
- "follows_you" => follows_you,
- "statusnet_blocking" => statusnet_blocking,
- "friends_count" => user_info[:following_count],
- "id" => user.id,
- "name" => user.name || user.nickname,
- "name_html" =>
- if(user.name,
- do: HTML.strip_tags(user.name) |> Formatter.emojify(emoji),
- else: user.nickname
- ),
- "profile_image_url" => image,
- "profile_image_url_https" => image,
- "profile_image_url_profile_size" => image,
- "profile_image_url_original" => image,
- "screen_name" => user.nickname,
- "statuses_count" => user_info[:note_count],
- "statusnet_profile_url" => user.ap_id,
- "cover_photo" => User.banner_url(user) |> MediaProxy.url(),
- "background_image" => image_url(user.info.background) |> MediaProxy.url(),
- "is_local" => user.local,
- "locked" => user.info.locked,
- "hide_followers" => user.info.hide_followers,
- "hide_follows" => user.info.hide_follows,
- "fields" => fields,
-
- # Pleroma extension
- "pleroma" =>
- %{
- "confirmation_pending" => user_info.confirmation_pending,
- "tags" => user.tags,
- "skip_thread_containment" => user.info.skip_thread_containment
- }
- |> maybe_with_activation_status(user, for_user)
- |> with_notification_settings(user, for_user)
- }
- |> maybe_with_user_settings(user, for_user)
- |> maybe_with_role(user, for_user)
-
- if assigns[:token] do
- Map.put(data, "token", token_string(assigns[:token]))
- else
- data
- end
- end
-
- defp with_notification_settings(data, %User{id: user_id} = user, %User{id: user_id}) do
- Map.put(data, "notification_settings", user.info.notification_settings)
- end
-
- defp with_notification_settings(data, _, _), do: data
-
- defp maybe_with_activation_status(data, user, %User{info: %{is_admin: true}}) do
- Map.put(data, "deactivated", user.info.deactivated)
- end
-
- defp maybe_with_activation_status(data, _, _), do: data
-
- defp maybe_with_role(data, %User{id: id} = user, %User{id: id}) do
- Map.merge(data, %{
- "role" => role(user),
- "show_role" => user.info.show_role,
- "rights" => %{
- "delete_others_notice" => !!user.info.is_moderator,
- "admin" => !!user.info.is_admin
- }
- })
- end
-
- defp maybe_with_role(data, %User{info: %{show_role: true}} = user, _user) do
- Map.merge(data, %{
- "role" => role(user),
- "rights" => %{
- "delete_others_notice" => !!user.info.is_moderator,
- "admin" => !!user.info.is_admin
- }
- })
- end
-
- defp maybe_with_role(data, _, _), do: data
-
- defp maybe_with_user_settings(data, %User{info: info, id: id} = _user, %User{id: id}) do
- data
- |> Kernel.put_in(["default_scope"], info.default_scope)
- |> Kernel.put_in(["no_rich_text"], info.no_rich_text)
- end
-
- defp maybe_with_user_settings(data, _, _), do: data
- defp role(%User{info: %{:is_admin => true}}), do: "admin"
- defp role(%User{info: %{:is_moderator => true}}), do: "moderator"
- defp role(_), do: "member"
-
- defp image_url(%{"url" => [%{"href" => href} | _]}), do: href
- defp image_url(_), do: nil
-
- defp token_string(%Pleroma.Web.OAuth.Token{token: token_str}), do: token_str
- defp token_string(token), do: token
-end
alias Pleroma.Web.ActivityPub.Transmogrifier
alias Pleroma.Web.CommonAPI
alias Pleroma.Web.Streamer
- alias Pleroma.Web.TwitterAPI.TwitterAPI
describe "create_notifications" do
test "notifies someone when they are directly addressed" do
third_user = insert(:user)
{:ok, activity} =
- TwitterAPI.create_status(user, %{
+ CommonAPI.post(user, %{
"status" => "hey @#{other_user.nickname} and @#{third_user.nickname}"
})
User.subscribe(subscriber, user)
- {:ok, status} = TwitterAPI.create_status(user, %{"status" => "Akariiiin"})
+ {:ok, status} = CommonAPI.post(user, %{"status" => "Akariiiin"})
{:ok, [notification]} = Notification.create_notifications(status)
assert notification.user_id == subscriber.id
test "it doesn't create a notification for follow-unfollow-follow chains" do
user = insert(:user)
followed_user = insert(:user)
- {:ok, _, _, activity} = TwitterAPI.follow(user, %{"user_id" => followed_user.id})
+ {:ok, _, _, activity} = CommonAPI.follow(user, followed_user)
Notification.create_notification(activity, followed_user)
- TwitterAPI.unfollow(user, %{"user_id" => followed_user.id})
- {:ok, _, _, activity_dupe} = TwitterAPI.follow(user, %{"user_id" => followed_user.id})
+ CommonAPI.unfollow(user, followed_user)
+ {:ok, _, _, activity_dupe} = CommonAPI.follow(user, followed_user)
refute Notification.create_notification(activity_dupe, followed_user)
end
- test "it doesn't create a notification for like-unlike-like chains" do
- user = insert(:user)
- liked_user = insert(:user)
- {:ok, status} = TwitterAPI.create_status(liked_user, %{"status" => "Yui is best yuru"})
- {:ok, fav_status} = TwitterAPI.fav(user, status.id)
- Notification.create_notification(fav_status, liked_user)
- TwitterAPI.unfav(user, status.id)
- {:ok, dupe} = TwitterAPI.fav(user, status.id)
- refute Notification.create_notification(dupe, liked_user)
- end
-
- test "it doesn't create a notification for repeat-unrepeat-repeat chains" do
- user = insert(:user)
- retweeted_user = insert(:user)
-
- {:ok, status} =
- TwitterAPI.create_status(retweeted_user, %{
- "status" => "Send dupe notifications to the shadow realm"
- })
-
- {:ok, retweeted_activity} = TwitterAPI.repeat(user, status.id)
- Notification.create_notification(retweeted_activity, retweeted_user)
- TwitterAPI.unrepeat(user, status.id)
- {:ok, dupe} = TwitterAPI.repeat(user, status.id)
- refute Notification.create_notification(dupe, retweeted_user)
- end
-
test "it doesn't create duplicate notifications for follow+subscribed users" do
user = insert(:user)
subscriber = insert(:user)
- {:ok, _, _, _} = TwitterAPI.follow(subscriber, %{"user_id" => user.id})
+ {:ok, _, _, _} = CommonAPI.follow(subscriber, user)
User.subscribe(subscriber, user)
- {:ok, status} = TwitterAPI.create_status(user, %{"status" => "Akariiiin"})
+ {:ok, status} = CommonAPI.post(user, %{"status" => "Akariiiin"})
{:ok, [_notif]} = Notification.create_notifications(status)
end
User.subscribe(subscriber, user)
- {:ok, status} =
- TwitterAPI.create_status(user, %{"status" => "inwisible", "visibility" => "direct"})
+ {:ok, status} = CommonAPI.post(user, %{"status" => "inwisible", "visibility" => "direct"})
assert {:ok, []} == Notification.create_notifications(status)
end
user = insert(:user)
other_user = insert(:user)
- {:ok, activity} =
- TwitterAPI.create_status(user, %{"status" => "hey @#{other_user.nickname}"})
+ {:ok, activity} = CommonAPI.post(user, %{"status" => "hey @#{other_user.nickname}"})
{:ok, [notification]} = Notification.create_notifications(activity)
{:ok, notification} = Notification.get(other_user, notification.id)
user = insert(:user)
other_user = insert(:user)
- {:ok, activity} =
- TwitterAPI.create_status(user, %{"status" => "hey @#{other_user.nickname}"})
+ {:ok, activity} = CommonAPI.post(user, %{"status" => "hey @#{other_user.nickname}"})
{:ok, [notification]} = Notification.create_notifications(activity)
{:error, _notification} = Notification.get(user, notification.id)
user = insert(:user)
other_user = insert(:user)
- {:ok, activity} =
- TwitterAPI.create_status(user, %{"status" => "hey @#{other_user.nickname}"})
+ {:ok, activity} = CommonAPI.post(user, %{"status" => "hey @#{other_user.nickname}"})
{:ok, [notification]} = Notification.create_notifications(activity)
{:ok, notification} = Notification.dismiss(other_user, notification.id)
user = insert(:user)
other_user = insert(:user)
- {:ok, activity} =
- TwitterAPI.create_status(user, %{"status" => "hey @#{other_user.nickname}"})
+ {:ok, activity} = CommonAPI.post(user, %{"status" => "hey @#{other_user.nickname}"})
{:ok, [notification]} = Notification.create_notifications(activity)
{:error, _notification} = Notification.dismiss(user, notification.id)
third_user = insert(:user)
{:ok, activity} =
- TwitterAPI.create_status(user, %{
+ CommonAPI.post(user, %{
"status" => "hey @#{other_user.nickname} and @#{third_user.nickname} !"
})
{:ok, _notifs} = Notification.create_notifications(activity)
{:ok, activity} =
- TwitterAPI.create_status(user, %{
+ CommonAPI.post(user, %{
"status" => "hey again @#{other_user.nickname} and @#{third_user.nickname} !"
})
other_user = insert(:user)
{:ok, _activity} =
- TwitterAPI.create_status(user, %{
+ CommonAPI.post(user, %{
"status" => "hey @#{other_user.nickname}!"
})
{:ok, _activity} =
- TwitterAPI.create_status(user, %{
+ CommonAPI.post(user, %{
"status" => "hey again @#{other_user.nickname}!"
})
assert n2.id > n1.id
{:ok, _activity} =
- TwitterAPI.create_status(user, %{
+ CommonAPI.post(user, %{
"status" => "hey yet again @#{other_user.nickname}!"
})
muted = insert(:user)
{:ok, user} = User.mute(user, muted, false)
- {:ok, _activity} = TwitterAPI.create_status(muted, %{"status" => "hey @#{user.nickname}"})
+ {:ok, _activity} = CommonAPI.post(muted, %{"status" => "hey @#{user.nickname}"})
assert length(Notification.for_user(user)) == 1
end
muted = insert(:user)
{:ok, user} = User.mute(user, muted)
- {:ok, _activity} = TwitterAPI.create_status(muted, %{"status" => "hey @#{user.nickname}"})
+ {:ok, _activity} = CommonAPI.post(muted, %{"status" => "hey @#{user.nickname}"})
assert Notification.for_user(user) == []
end
blocked = insert(:user)
{:ok, user} = User.block(user, blocked)
- {:ok, _activity} = TwitterAPI.create_status(blocked, %{"status" => "hey @#{user.nickname}"})
+ {:ok, _activity} = CommonAPI.post(blocked, %{"status" => "hey @#{user.nickname}"})
assert Notification.for_user(user) == []
end
blocked = insert(:user, ap_id: "http://some-domain.com")
{:ok, user} = User.block_domain(user, "some-domain.com")
- {:ok, _activity} = TwitterAPI.create_status(blocked, %{"status" => "hey @#{user.nickname}"})
+ {:ok, _activity} = CommonAPI.post(blocked, %{"status" => "hey @#{user.nickname}"})
assert Notification.for_user(user) == []
end
user = insert(:user)
another_user = insert(:user)
- {:ok, activity} =
- TwitterAPI.create_status(another_user, %{"status" => "hey @#{user.nickname}"})
+ {:ok, activity} = CommonAPI.post(another_user, %{"status" => "hey @#{user.nickname}"})
{:ok, _} = Pleroma.ThreadMute.add_mute(user.id, activity.data["context"])
assert Notification.for_user(user) == []
muted = insert(:user)
{:ok, user} = User.mute(user, muted)
- {:ok, _activity} = TwitterAPI.create_status(muted, %{"status" => "hey @#{user.nickname}"})
+ {:ok, _activity} = CommonAPI.post(muted, %{"status" => "hey @#{user.nickname}"})
assert length(Notification.for_user(user, %{with_muted: true})) == 1
end
blocked = insert(:user)
{:ok, user} = User.block(user, blocked)
- {:ok, _activity} = TwitterAPI.create_status(blocked, %{"status" => "hey @#{user.nickname}"})
+ {:ok, _activity} = CommonAPI.post(blocked, %{"status" => "hey @#{user.nickname}"})
assert length(Notification.for_user(user, %{with_muted: true})) == 1
end
blocked = insert(:user, ap_id: "http://some-domain.com")
{:ok, user} = User.block_domain(user, "some-domain.com")
- {:ok, _activity} = TwitterAPI.create_status(blocked, %{"status" => "hey @#{user.nickname}"})
+ {:ok, _activity} = CommonAPI.post(blocked, %{"status" => "hey @#{user.nickname}"})
assert length(Notification.for_user(user, %{with_muted: true})) == 1
end
user = insert(:user)
another_user = insert(:user)
- {:ok, activity} =
- TwitterAPI.create_status(another_user, %{"status" => "hey @#{user.nickname}"})
+ {:ok, activity} = CommonAPI.post(another_user, %{"status" => "hey @#{user.nickname}"})
{:ok, _} = Pleroma.ThreadMute.add_mute(user.id, activity.data["context"])
assert length(Notification.for_user(user, %{with_muted: true})) == 1
locked = insert(:user, %{info: %{locked: true}})
follower = insert(:user)
- Pleroma.Web.TwitterAPI.TwitterAPI.follow(follower, %{"user_id" => unlocked.id})
- Pleroma.Web.TwitterAPI.TwitterAPI.follow(follower, %{"user_id" => locked.id})
+ CommonAPI.follow(follower, unlocked)
+ CommonAPI.follow(follower, locked)
assert {:ok, []} = User.get_follow_requests(unlocked)
assert {:ok, [activity]} = User.get_follow_requests(locked)
pending_follower = insert(:user)
accepted_follower = insert(:user)
- Pleroma.Web.TwitterAPI.TwitterAPI.follow(pending_follower, %{"user_id" => locked.id})
- Pleroma.Web.TwitterAPI.TwitterAPI.follow(pending_follower, %{"user_id" => locked.id})
- Pleroma.Web.TwitterAPI.TwitterAPI.follow(accepted_follower, %{"user_id" => locked.id})
+ CommonAPI.follow(pending_follower, locked)
+ CommonAPI.follow(pending_follower, locked)
+ CommonAPI.follow(accepted_follower, locked)
User.follow(accepted_follower, locked)
assert {:ok, [activity]} = User.get_follow_requests(locked)
{:ok, _follower2} = User.follow(follower2, user)
{:ok, _follower3} = User.follow(follower3, user)
- {:ok, _} = User.block(user, follower)
+ {:ok, user} = User.block(user, follower)
- user_show = Pleroma.Web.TwitterAPI.UserView.render("show.json", %{user: user})
-
- assert Map.get(user_show, "followers_count") == 2
+ assert User.user_info(user).follower_count == 2
end
describe "list_inactive_users_query/1" do
to = Enum.random(users -- [user])
{:ok, _} =
- Pleroma.Web.TwitterAPI.TwitterAPI.create_status(user, %{
+ CommonAPI.post(user, %{
"status" => "hey @#{to.nickname}"
})
end)
Enum.each(recipients, fn to ->
{:ok, _} =
- Pleroma.Web.TwitterAPI.TwitterAPI.create_status(sender, %{
+ CommonAPI.post(sender, %{
"status" => "hey @#{to.nickname}"
})
{:ok, _} =
- Pleroma.Web.TwitterAPI.TwitterAPI.create_status(sender, %{
+ CommonAPI.post(sender, %{
"status" => "hey again @#{to.nickname}"
})
end)
alias Pleroma.Web.OAuth.Token
alias Pleroma.Web.OStatus
alias Pleroma.Web.Push
- alias Pleroma.Web.TwitterAPI.TwitterAPI
import Pleroma.Factory
import ExUnit.CaptureLog
import Tesla.Mock
filename: "an_image.jpg"
}
- media =
- TwitterAPI.upload(file, user, "json")
- |> Jason.decode!()
+ {:ok, %{id: media_id}} = ActivityPub.upload(file, actor: user.ap_id)
- {:ok, image_post} =
- CommonAPI.post(user, %{"status" => "cofe", "media_ids" => [media["media_id"]]})
+ {:ok, image_post} = CommonAPI.post(user, %{"status" => "cofe", "media_ids" => [media_id]})
conn =
conn
alias Pleroma.Notification
alias Pleroma.ScheduledActivity
alias Pleroma.User
+ alias Pleroma.Web.CommonAPI
alias Pleroma.Web.MastodonAPI.MastodonAPI
- alias Pleroma.Web.TwitterAPI.TwitterAPI
import Pleroma.Factory
User.subscribe(subscriber, user)
- {:ok, status} = TwitterAPI.create_status(user, %{"status" => "Akariiiin"})
- {:ok, status1} = TwitterAPI.create_status(user, %{"status" => "Magi"})
+ {:ok, status} = CommonAPI.post(user, %{"status" => "Akariiiin"})
+
+ {:ok, status1} = CommonAPI.post(user, %{"status" => "Magi"})
{:ok, [notification]} = Notification.create_notifications(status)
{:ok, [notification1]} = Notification.create_notifications(status1)
res = MastodonAPI.get_notifications(subscriber)
+++ /dev/null
-# Pleroma: A lightweight social networking server
-# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
-# SPDX-License-Identifier: AGPL-3.0-only
-
-defmodule Pleroma.Web.TwitterAPI.Representers.ObjectReprenterTest do
- use Pleroma.DataCase
-
- alias Pleroma.Object
- alias Pleroma.Web.TwitterAPI.Representers.ObjectRepresenter
-
- test "represent an image attachment" do
- object = %Object{
- id: 5,
- data: %{
- "type" => "Image",
- "url" => [
- %{
- "mediaType" => "sometype",
- "href" => "someurl"
- }
- ],
- "uuid" => 6
- }
- }
-
- expected_object = %{
- id: 6,
- url: "someurl",
- mimetype: "sometype",
- oembed: false,
- description: nil
- }
-
- assert expected_object == ObjectRepresenter.to_map(object)
- end
-
- test "represents mastodon-style attachments" do
- object = %Object{
- id: nil,
- data: %{
- "mediaType" => "image/png",
- "name" => "blabla",
- "type" => "Document",
- "url" =>
- "http://mastodon.example.org/system/media_attachments/files/000/000/001/original/8619f31c6edec470.png"
- }
- }
-
- expected_object = %{
- url:
- "http://mastodon.example.org/system/media_attachments/files/000/000/001/original/8619f31c6edec470.png",
- mimetype: "image/png",
- oembed: false,
- id: nil,
- description: "blabla"
- }
-
- assert expected_object == ObjectRepresenter.to_map(object)
- end
-end
+++ /dev/null
-# Pleroma: A lightweight social networking server
-# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
-# SPDX-License-Identifier: AGPL-3.0-only
-
-defmodule Pleroma.Web.TwitterAPI.ControllerTest do
- use Pleroma.Web.ConnCase
- alias Comeonin.Pbkdf2
- alias Ecto.Changeset
- alias Pleroma.Activity
- alias Pleroma.Builders.ActivityBuilder
- alias Pleroma.Builders.UserBuilder
- alias Pleroma.Notification
- alias Pleroma.Object
- alias Pleroma.Repo
- alias Pleroma.User
- alias Pleroma.Web.ActivityPub.ActivityPub
- alias Pleroma.Web.CommonAPI
- alias Pleroma.Web.OAuth.Token
- alias Pleroma.Web.TwitterAPI.ActivityView
- alias Pleroma.Web.TwitterAPI.Controller
- alias Pleroma.Web.TwitterAPI.NotificationView
- alias Pleroma.Web.TwitterAPI.TwitterAPI
- alias Pleroma.Web.TwitterAPI.UserView
-
- import Mock
- import Pleroma.Factory
- import Swoosh.TestAssertions
-
- @banner "data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7"
-
- describe "POST /api/account/update_profile_banner" do
- test "it updates the banner", %{conn: conn} do
- user = insert(:user)
-
- conn
- |> assign(:user, user)
- |> post(authenticated_twitter_api__path(conn, :update_banner), %{"banner" => @banner})
- |> json_response(200)
-
- user = refresh_record(user)
- assert user.info.banner["type"] == "Image"
- end
-
- test "profile banner can be reset", %{conn: conn} do
- user = insert(:user)
-
- conn
- |> assign(:user, user)
- |> post(authenticated_twitter_api__path(conn, :update_banner), %{"banner" => ""})
- |> json_response(200)
-
- user = refresh_record(user)
- assert user.info.banner == %{}
- end
- end
-
- describe "POST /api/qvitter/update_background_image" do
- test "it updates the background", %{conn: conn} do
- user = insert(:user)
-
- conn
- |> assign(:user, user)
- |> post(authenticated_twitter_api__path(conn, :update_background), %{"img" => @banner})
- |> json_response(200)
-
- user = refresh_record(user)
- assert user.info.background["type"] == "Image"
- end
-
- test "background can be reset", %{conn: conn} do
- user = insert(:user)
-
- conn
- |> assign(:user, user)
- |> post(authenticated_twitter_api__path(conn, :update_background), %{"img" => ""})
- |> json_response(200)
-
- user = refresh_record(user)
- assert user.info.background == %{}
- end
- end
-
- describe "POST /api/account/verify_credentials" do
- setup [:valid_user]
-
- test "without valid credentials", %{conn: conn} do
- conn = post(conn, "/api/account/verify_credentials.json")
- assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
- end
-
- test "with credentials", %{conn: conn, user: user} do
- response =
- conn
- |> with_credentials(user.nickname, "test")
- |> post("/api/account/verify_credentials.json")
- |> json_response(200)
-
- assert response ==
- UserView.render("show.json", %{user: user, token: response["token"], for: user})
- end
- end
-
- describe "POST /statuses/update.json" do
- setup [:valid_user]
-
- test "without valid credentials", %{conn: conn} do
- conn = post(conn, "/api/statuses/update.json")
- assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
- end
-
- test "with credentials", %{conn: conn, user: user} do
- conn_with_creds = conn |> with_credentials(user.nickname, "test")
- request_path = "/api/statuses/update.json"
-
- error_response = %{
- "request" => request_path,
- "error" => "Client must provide a 'status' parameter with a value."
- }
-
- conn =
- conn_with_creds
- |> post(request_path)
-
- assert json_response(conn, 400) == error_response
-
- conn =
- conn_with_creds
- |> post(request_path, %{status: ""})
-
- assert json_response(conn, 400) == error_response
-
- conn =
- conn_with_creds
- |> post(request_path, %{status: " "})
-
- assert json_response(conn, 400) == error_response
-
- # we post with visibility private in order to avoid triggering relay
- conn =
- conn_with_creds
- |> post(request_path, %{status: "Nice meme.", visibility: "private"})
-
- assert json_response(conn, 200) ==
- ActivityView.render("activity.json", %{
- activity: Repo.one(Activity),
- user: user,
- for: user
- })
- end
- end
-
- describe "GET /statuses/public_timeline.json" do
- setup [:valid_user]
- clear_config([:instance, :public])
-
- test "returns statuses", %{conn: conn} do
- user = insert(:user)
- activities = ActivityBuilder.insert_list(30, %{}, %{user: user})
- ActivityBuilder.insert_list(10, %{}, %{user: user})
- since_id = List.last(activities).id
-
- conn =
- conn
- |> get("/api/statuses/public_timeline.json", %{since_id: since_id})
-
- response = json_response(conn, 200)
-
- assert length(response) == 10
- end
-
- test "returns 403 to unauthenticated request when the instance is not public", %{conn: conn} do
- Pleroma.Config.put([:instance, :public], false)
-
- conn
- |> get("/api/statuses/public_timeline.json")
- |> json_response(403)
- end
-
- test "returns 200 to authenticated request when the instance is not public",
- %{conn: conn, user: user} do
- Pleroma.Config.put([:instance, :public], false)
-
- conn
- |> with_credentials(user.nickname, "test")
- |> get("/api/statuses/public_timeline.json")
- |> json_response(200)
- end
-
- test "returns 200 to unauthenticated request when the instance is public", %{conn: conn} do
- conn
- |> get("/api/statuses/public_timeline.json")
- |> json_response(200)
- end
-
- test "returns 200 to authenticated request when the instance is public",
- %{conn: conn, user: user} do
- conn
- |> with_credentials(user.nickname, "test")
- |> get("/api/statuses/public_timeline.json")
- |> json_response(200)
- end
-
- test_with_mock "treats user as unauthenticated if `assigns[:token]` is present but lacks `read` permission",
- Controller,
- [:passthrough],
- [] do
- token = insert(:oauth_token, scopes: ["write"])
-
- build_conn()
- |> put_req_header("authorization", "Bearer #{token.token}")
- |> get("/api/statuses/public_timeline.json")
- |> json_response(200)
-
- assert called(Controller.public_timeline(%{assigns: %{user: nil}}, :_))
- end
- end
-
- describe "GET /statuses/public_and_external_timeline.json" do
- setup [:valid_user]
- clear_config([:instance, :public])
-
- test "returns 403 to unauthenticated request when the instance is not public", %{conn: conn} do
- Pleroma.Config.put([:instance, :public], false)
-
- conn
- |> get("/api/statuses/public_and_external_timeline.json")
- |> json_response(403)
- end
-
- test "returns 200 to authenticated request when the instance is not public",
- %{conn: conn, user: user} do
- Pleroma.Config.put([:instance, :public], false)
-
- conn
- |> with_credentials(user.nickname, "test")
- |> get("/api/statuses/public_and_external_timeline.json")
- |> json_response(200)
- end
-
- test "returns 200 to unauthenticated request when the instance is public", %{conn: conn} do
- conn
- |> get("/api/statuses/public_and_external_timeline.json")
- |> json_response(200)
- end
-
- test "returns 200 to authenticated request when the instance is public",
- %{conn: conn, user: user} do
- conn
- |> with_credentials(user.nickname, "test")
- |> get("/api/statuses/public_and_external_timeline.json")
- |> json_response(200)
- end
- end
-
- describe "GET /statuses/show/:id.json" do
- test "returns one status", %{conn: conn} do
- user = insert(:user)
- {:ok, activity} = CommonAPI.post(user, %{"status" => "Hey!"})
- actor = User.get_cached_by_ap_id(activity.data["actor"])
-
- conn =
- conn
- |> get("/api/statuses/show/#{activity.id}.json")
-
- response = json_response(conn, 200)
-
- assert response == ActivityView.render("activity.json", %{activity: activity, user: actor})
- end
- end
-
- describe "GET /users/show.json" do
- test "gets user with screen_name", %{conn: conn} do
- user = insert(:user)
-
- conn =
- conn
- |> get("/api/users/show.json", %{"screen_name" => user.nickname})
-
- response = json_response(conn, 200)
-
- assert response["id"] == user.id
- end
-
- test "gets user with user_id", %{conn: conn} do
- user = insert(:user)
-
- conn =
- conn
- |> get("/api/users/show.json", %{"user_id" => user.id})
-
- response = json_response(conn, 200)
-
- assert response["id"] == user.id
- end
-
- test "gets a user for a logged in user", %{conn: conn} do
- user = insert(:user)
- logged_in = insert(:user)
-
- {:ok, logged_in, user, _activity} = TwitterAPI.follow(logged_in, %{"user_id" => user.id})
-
- conn =
- conn
- |> with_credentials(logged_in.nickname, "test")
- |> get("/api/users/show.json", %{"user_id" => user.id})
-
- response = json_response(conn, 200)
-
- assert response["following"] == true
- end
- end
-
- describe "GET /statusnet/conversation/:id.json" do
- test "returns the statuses in the conversation", %{conn: conn} do
- {:ok, _user} = UserBuilder.insert()
- {:ok, activity} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
- {:ok, _activity_two} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
- {:ok, _activity_three} = ActivityBuilder.insert(%{"type" => "Create", "context" => "3hu"})
-
- conn =
- conn
- |> get("/api/statusnet/conversation/#{activity.data["context_id"]}.json")
-
- response = json_response(conn, 200)
-
- assert length(response) == 2
- end
- end
-
- describe "GET /statuses/friends_timeline.json" do
- setup [:valid_user]
-
- test "without valid credentials", %{conn: conn} do
- conn = get(conn, "/api/statuses/friends_timeline.json")
- assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
- end
-
- test "with credentials", %{conn: conn, user: current_user} do
- user = insert(:user)
-
- activities =
- ActivityBuilder.insert_list(30, %{"to" => [User.ap_followers(user)]}, %{user: user})
-
- returned_activities =
- ActivityBuilder.insert_list(10, %{"to" => [User.ap_followers(user)]}, %{user: user})
-
- other_user = insert(:user)
- ActivityBuilder.insert_list(10, %{}, %{user: other_user})
- since_id = List.last(activities).id
-
- current_user =
- Changeset.change(current_user, following: [User.ap_followers(user)])
- |> Repo.update!()
-
- conn =
- conn
- |> with_credentials(current_user.nickname, "test")
- |> get("/api/statuses/friends_timeline.json", %{since_id: since_id})
-
- response = json_response(conn, 200)
-
- assert length(response) == 10
-
- assert response ==
- Enum.map(returned_activities, fn activity ->
- ActivityView.render("activity.json", %{
- activity: activity,
- user: User.get_cached_by_ap_id(activity.data["actor"]),
- for: current_user
- })
- end)
- end
- end
-
- describe "GET /statuses/dm_timeline.json" do
- test "it show direct messages", %{conn: conn} do
- user_one = insert(:user)
- user_two = insert(:user)
-
- {:ok, user_two} = User.follow(user_two, user_one)
-
- {:ok, direct} =
- CommonAPI.post(user_one, %{
- "status" => "Hi @#{user_two.nickname}!",
- "visibility" => "direct"
- })
-
- {:ok, direct_two} =
- CommonAPI.post(user_two, %{
- "status" => "Hi @#{user_one.nickname}!",
- "visibility" => "direct"
- })
-
- {:ok, _follower_only} =
- CommonAPI.post(user_one, %{
- "status" => "Hi @#{user_two.nickname}!",
- "visibility" => "private"
- })
-
- # Only direct should be visible here
- res_conn =
- conn
- |> assign(:user, user_two)
- |> get("/api/statuses/dm_timeline.json")
-
- [status, status_two] = json_response(res_conn, 200)
- assert status["id"] == direct_two.id
- assert status_two["id"] == direct.id
- end
-
- test "doesn't include DMs from blocked users", %{conn: conn} do
- blocker = insert(:user)
- blocked = insert(:user)
- user = insert(:user)
- {:ok, blocker} = User.block(blocker, blocked)
-
- {:ok, _blocked_direct} =
- CommonAPI.post(blocked, %{
- "status" => "Hi @#{blocker.nickname}!",
- "visibility" => "direct"
- })
-
- {:ok, direct} =
- CommonAPI.post(user, %{
- "status" => "Hi @#{blocker.nickname}!",
- "visibility" => "direct"
- })
-
- res_conn =
- conn
- |> assign(:user, blocker)
- |> get("/api/statuses/dm_timeline.json")
-
- [status] = json_response(res_conn, 200)
- assert status["id"] == direct.id
- end
- end
-
- describe "GET /statuses/mentions.json" do
- setup [:valid_user]
-
- test "without valid credentials", %{conn: conn} do
- conn = get(conn, "/api/statuses/mentions.json")
- assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
- end
-
- test "with credentials", %{conn: conn, user: current_user} do
- {:ok, activity} =
- CommonAPI.post(current_user, %{
- "status" => "why is tenshi eating a corndog so cute?",
- "visibility" => "public"
- })
-
- conn =
- conn
- |> with_credentials(current_user.nickname, "test")
- |> get("/api/statuses/mentions.json")
-
- response = json_response(conn, 200)
-
- assert length(response) == 1
-
- assert Enum.at(response, 0) ==
- ActivityView.render("activity.json", %{
- user: current_user,
- for: current_user,
- activity: activity
- })
- end
-
- test "does not show DMs in mentions timeline", %{conn: conn, user: current_user} do
- {:ok, _activity} =
- CommonAPI.post(current_user, %{
- "status" => "Have you guys ever seen how cute tenshi eating a corndog is?",
- "visibility" => "direct"
- })
-
- conn =
- conn
- |> with_credentials(current_user.nickname, "test")
- |> get("/api/statuses/mentions.json")
-
- response = json_response(conn, 200)
-
- assert Enum.empty?(response)
- end
- end
-
- describe "GET /api/qvitter/statuses/notifications.json" do
- setup [:valid_user]
-
- test "without valid credentials", %{conn: conn} do
- conn = get(conn, "/api/qvitter/statuses/notifications.json")
- assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
- end
-
- test "with credentials", %{conn: conn, user: current_user} do
- other_user = insert(:user)
-
- {:ok, _activity} =
- ActivityBuilder.insert(%{"to" => [current_user.ap_id]}, %{user: other_user})
-
- conn =
- conn
- |> with_credentials(current_user.nickname, "test")
- |> get("/api/qvitter/statuses/notifications.json")
-
- response = json_response(conn, 200)
-
- assert length(response) == 1
-
- assert response ==
- NotificationView.render("notification.json", %{
- notifications: Notification.for_user(current_user),
- for: current_user
- })
- end
-
- test "muted user", %{conn: conn, user: current_user} do
- other_user = insert(:user)
-
- {:ok, current_user} = User.mute(current_user, other_user)
-
- {:ok, _activity} =
- ActivityBuilder.insert(%{"to" => [current_user.ap_id]}, %{user: other_user})
-
- conn =
- conn
- |> with_credentials(current_user.nickname, "test")
- |> get("/api/qvitter/statuses/notifications.json")
-
- assert json_response(conn, 200) == []
- end
-
- test "muted user with with_muted parameter", %{conn: conn, user: current_user} do
- other_user = insert(:user)
-
- {:ok, current_user} = User.mute(current_user, other_user)
-
- {:ok, _activity} =
- ActivityBuilder.insert(%{"to" => [current_user.ap_id]}, %{user: other_user})
-
- conn =
- conn
- |> with_credentials(current_user.nickname, "test")
- |> get("/api/qvitter/statuses/notifications.json", %{"with_muted" => "true"})
-
- assert length(json_response(conn, 200)) == 1
- end
- end
-
- describe "POST /api/qvitter/statuses/notifications/read" do
- setup [:valid_user]
-
- test "without valid credentials", %{conn: conn} do
- conn = post(conn, "/api/qvitter/statuses/notifications/read", %{"latest_id" => 1_234_567})
- assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
- end
-
- test "with credentials, without any params", %{conn: conn, user: current_user} do
- conn =
- conn
- |> with_credentials(current_user.nickname, "test")
- |> post("/api/qvitter/statuses/notifications/read")
-
- assert json_response(conn, 400) == %{
- "error" => "You need to specify latest_id",
- "request" => "/api/qvitter/statuses/notifications/read"
- }
- end
-
- test "with credentials, with params", %{conn: conn, user: current_user} do
- other_user = insert(:user)
-
- {:ok, _activity} =
- ActivityBuilder.insert(%{"to" => [current_user.ap_id]}, %{user: other_user})
-
- response_conn =
- conn
- |> with_credentials(current_user.nickname, "test")
- |> get("/api/qvitter/statuses/notifications.json")
-
- [notification] = response = json_response(response_conn, 200)
-
- assert length(response) == 1
-
- assert notification["is_seen"] == 0
-
- response_conn =
- conn
- |> with_credentials(current_user.nickname, "test")
- |> post("/api/qvitter/statuses/notifications/read", %{"latest_id" => notification["id"]})
-
- [notification] = response = json_response(response_conn, 200)
-
- assert length(response) == 1
-
- assert notification["is_seen"] == 1
- end
- end
-
- describe "GET /statuses/user_timeline.json" do
- setup [:valid_user]
-
- test "without any params", %{conn: conn} do
- conn = get(conn, "/api/statuses/user_timeline.json")
-
- assert json_response(conn, 400) == %{
- "error" => "You need to specify screen_name or user_id",
- "request" => "/api/statuses/user_timeline.json"
- }
- end
-
- test "with user_id", %{conn: conn} do
- user = insert(:user)
- {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
-
- conn = get(conn, "/api/statuses/user_timeline.json", %{"user_id" => user.id})
- response = json_response(conn, 200)
- assert length(response) == 1
-
- assert Enum.at(response, 0) ==
- ActivityView.render("activity.json", %{user: user, activity: activity})
- end
-
- test "with screen_name", %{conn: conn} do
- user = insert(:user)
- {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
-
- conn = get(conn, "/api/statuses/user_timeline.json", %{"screen_name" => user.nickname})
- response = json_response(conn, 200)
- assert length(response) == 1
-
- assert Enum.at(response, 0) ==
- ActivityView.render("activity.json", %{user: user, activity: activity})
- end
-
- test "with credentials", %{conn: conn, user: current_user} do
- {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: current_user})
-
- conn =
- conn
- |> with_credentials(current_user.nickname, "test")
- |> get("/api/statuses/user_timeline.json")
-
- response = json_response(conn, 200)
-
- assert length(response) == 1
-
- assert Enum.at(response, 0) ==
- ActivityView.render("activity.json", %{
- user: current_user,
- for: current_user,
- activity: activity
- })
- end
-
- test "with credentials with user_id", %{conn: conn, user: current_user} do
- user = insert(:user)
- {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
-
- conn =
- conn
- |> with_credentials(current_user.nickname, "test")
- |> get("/api/statuses/user_timeline.json", %{"user_id" => user.id})
-
- response = json_response(conn, 200)
-
- assert length(response) == 1
-
- assert Enum.at(response, 0) ==
- ActivityView.render("activity.json", %{user: user, activity: activity})
- end
-
- test "with credentials screen_name", %{conn: conn, user: current_user} do
- user = insert(:user)
- {:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})
-
- conn =
- conn
- |> with_credentials(current_user.nickname, "test")
- |> get("/api/statuses/user_timeline.json", %{"screen_name" => user.nickname})
-
- response = json_response(conn, 200)
-
- assert length(response) == 1
-
- assert Enum.at(response, 0) ==
- ActivityView.render("activity.json", %{user: user, activity: activity})
- end
-
- test "with credentials with user_id, excluding RTs", %{conn: conn, user: current_user} do
- user = insert(:user)
- {:ok, activity} = ActivityBuilder.insert(%{"id" => 1, "type" => "Create"}, %{user: user})
- {:ok, _} = ActivityBuilder.insert(%{"id" => 2, "type" => "Announce"}, %{user: user})
-
- conn =
- conn
- |> with_credentials(current_user.nickname, "test")
- |> get("/api/statuses/user_timeline.json", %{
- "user_id" => user.id,
- "include_rts" => "false"
- })
-
- response = json_response(conn, 200)
-
- assert length(response) == 1
-
- assert Enum.at(response, 0) ==
- ActivityView.render("activity.json", %{user: user, activity: activity})
-
- conn =
- conn
- |> get("/api/statuses/user_timeline.json", %{"user_id" => user.id, "include_rts" => "0"})
-
- response = json_response(conn, 200)
-
- assert length(response) == 1
-
- assert Enum.at(response, 0) ==
- ActivityView.render("activity.json", %{user: user, activity: activity})
- end
- end
-
- describe "POST /friendships/create.json" do
- setup [:valid_user]
-
- test "without valid credentials", %{conn: conn} do
- conn = post(conn, "/api/friendships/create.json")
- assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
- end
-
- test "with credentials", %{conn: conn, user: current_user} do
- followed = insert(:user)
-
- conn =
- conn
- |> with_credentials(current_user.nickname, "test")
- |> post("/api/friendships/create.json", %{user_id: followed.id})
-
- current_user = User.get_cached_by_id(current_user.id)
- assert User.ap_followers(followed) in current_user.following
-
- assert json_response(conn, 200) ==
- UserView.render("show.json", %{user: followed, for: current_user})
- end
-
- test "for restricted account", %{conn: conn, user: current_user} do
- followed = insert(:user, info: %User.Info{locked: true})
-
- conn =
- conn
- |> with_credentials(current_user.nickname, "test")
- |> post("/api/friendships/create.json", %{user_id: followed.id})
-
- current_user = User.get_cached_by_id(current_user.id)
- followed = User.get_cached_by_id(followed.id)
-
- refute User.ap_followers(followed) in current_user.following
-
- assert json_response(conn, 200) ==
- UserView.render("show.json", %{user: followed, for: current_user})
- end
- end
-
- describe "POST /friendships/destroy.json" do
- setup [:valid_user]
-
- test "without valid credentials", %{conn: conn} do
- conn = post(conn, "/api/friendships/destroy.json")
- assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
- end
-
- test "with credentials", %{conn: conn, user: current_user} do
- followed = insert(:user)
-
- {:ok, current_user} = User.follow(current_user, followed)
- assert User.ap_followers(followed) in current_user.following
- ActivityPub.follow(current_user, followed)
-
- conn =
- conn
- |> with_credentials(current_user.nickname, "test")
- |> post("/api/friendships/destroy.json", %{user_id: followed.id})
-
- current_user = User.get_cached_by_id(current_user.id)
- assert current_user.following == [current_user.ap_id]
-
- assert json_response(conn, 200) ==
- UserView.render("show.json", %{user: followed, for: current_user})
- end
- end
-
- describe "POST /blocks/create.json" do
- setup [:valid_user]
-
- test "without valid credentials", %{conn: conn} do
- conn = post(conn, "/api/blocks/create.json")
- assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
- end
-
- test "with credentials", %{conn: conn, user: current_user} do
- blocked = insert(:user)
-
- conn =
- conn
- |> with_credentials(current_user.nickname, "test")
- |> post("/api/blocks/create.json", %{user_id: blocked.id})
-
- current_user = User.get_cached_by_id(current_user.id)
- assert User.blocks?(current_user, blocked)
-
- assert json_response(conn, 200) ==
- UserView.render("show.json", %{user: blocked, for: current_user})
- end
- end
-
- describe "POST /blocks/destroy.json" do
- setup [:valid_user]
-
- test "without valid credentials", %{conn: conn} do
- conn = post(conn, "/api/blocks/destroy.json")
- assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
- end
-
- test "with credentials", %{conn: conn, user: current_user} do
- blocked = insert(:user)
-
- {:ok, current_user, blocked} = TwitterAPI.block(current_user, %{"user_id" => blocked.id})
- assert User.blocks?(current_user, blocked)
-
- conn =
- conn
- |> with_credentials(current_user.nickname, "test")
- |> post("/api/blocks/destroy.json", %{user_id: blocked.id})
-
- current_user = User.get_cached_by_id(current_user.id)
- assert current_user.info.blocks == []
-
- assert json_response(conn, 200) ==
- UserView.render("show.json", %{user: blocked, for: current_user})
- end
- end
-
- describe "GET /help/test.json" do
- test "returns \"ok\"", %{conn: conn} do
- conn = get(conn, "/api/help/test.json")
- assert json_response(conn, 200) == "ok"
- end
- end
-
- describe "POST /api/qvitter/update_avatar.json" do
- setup [:valid_user]
-
- test "without valid credentials", %{conn: conn} do
- conn = post(conn, "/api/qvitter/update_avatar.json")
- assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
- end
-
- test "with credentials", %{conn: conn, user: current_user} do
- avatar_image = File.read!("test/fixtures/avatar_data_uri")
-
- conn =
- conn
- |> with_credentials(current_user.nickname, "test")
- |> post("/api/qvitter/update_avatar.json", %{img: avatar_image})
-
- current_user = User.get_cached_by_id(current_user.id)
- assert is_map(current_user.avatar)
-
- assert json_response(conn, 200) ==
- UserView.render("show.json", %{user: current_user, for: current_user})
- end
-
- test "user avatar can be reset", %{conn: conn, user: current_user} do
- conn =
- conn
- |> with_credentials(current_user.nickname, "test")
- |> post("/api/qvitter/update_avatar.json", %{img: ""})
-
- current_user = User.get_cached_by_id(current_user.id)
- assert current_user.avatar == nil
-
- assert json_response(conn, 200) ==
- UserView.render("show.json", %{user: current_user, for: current_user})
- end
- end
-
- describe "GET /api/qvitter/mutes.json" do
- setup [:valid_user]
-
- test "unimplemented mutes without valid credentials", %{conn: conn} do
- conn = get(conn, "/api/qvitter/mutes.json")
- assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
- end
-
- test "unimplemented mutes with credentials", %{conn: conn, user: current_user} do
- response =
- conn
- |> with_credentials(current_user.nickname, "test")
- |> get("/api/qvitter/mutes.json")
- |> json_response(200)
-
- assert [] = response
- end
- end
-
- describe "POST /api/favorites/create/:id" do
- setup [:valid_user]
-
- test "without valid credentials", %{conn: conn} do
- note_activity = insert(:note_activity)
- conn = post(conn, "/api/favorites/create/#{note_activity.id}.json")
- assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
- end
-
- test "with credentials", %{conn: conn, user: current_user} do
- note_activity = insert(:note_activity)
-
- conn =
- conn
- |> with_credentials(current_user.nickname, "test")
- |> post("/api/favorites/create/#{note_activity.id}.json")
-
- assert json_response(conn, 200)
- end
-
- test "with credentials, invalid param", %{conn: conn, user: current_user} do
- conn =
- conn
- |> with_credentials(current_user.nickname, "test")
- |> post("/api/favorites/create/wrong.json")
-
- assert json_response(conn, 400)
- end
-
- test "with credentials, invalid activity", %{conn: conn, user: current_user} do
- conn =
- conn
- |> with_credentials(current_user.nickname, "test")
- |> post("/api/favorites/create/1.json")
-
- assert json_response(conn, 400)
- end
- end
-
- describe "POST /api/favorites/destroy/:id" do
- setup [:valid_user]
-
- test "without valid credentials", %{conn: conn} do
- note_activity = insert(:note_activity)
- conn = post(conn, "/api/favorites/destroy/#{note_activity.id}.json")
- assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
- end
-
- test "with credentials", %{conn: conn, user: current_user} do
- note_activity = insert(:note_activity)
- object = Object.normalize(note_activity)
- ActivityPub.like(current_user, object)
-
- conn =
- conn
- |> with_credentials(current_user.nickname, "test")
- |> post("/api/favorites/destroy/#{note_activity.id}.json")
-
- assert json_response(conn, 200)
- end
- end
-
- describe "POST /api/statuses/retweet/:id" do
- setup [:valid_user]
-
- test "without valid credentials", %{conn: conn} do
- note_activity = insert(:note_activity)
- conn = post(conn, "/api/statuses/retweet/#{note_activity.id}.json")
- assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
- end
-
- test "with credentials", %{conn: conn, user: current_user} do
- note_activity = insert(:note_activity)
-
- request_path = "/api/statuses/retweet/#{note_activity.id}.json"
-
- response =
- conn
- |> with_credentials(current_user.nickname, "test")
- |> post(request_path)
-
- activity = Activity.get_by_id(note_activity.id)
- activity_user = User.get_cached_by_ap_id(note_activity.data["actor"])
-
- assert json_response(response, 200) ==
- ActivityView.render("activity.json", %{
- user: activity_user,
- for: current_user,
- activity: activity
- })
- end
- end
-
- describe "POST /api/statuses/unretweet/:id" do
- setup [:valid_user]
-
- test "without valid credentials", %{conn: conn} do
- note_activity = insert(:note_activity)
- conn = post(conn, "/api/statuses/unretweet/#{note_activity.id}.json")
- assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
- end
-
- test "with credentials", %{conn: conn, user: current_user} do
- note_activity = insert(:note_activity)
-
- request_path = "/api/statuses/retweet/#{note_activity.id}.json"
-
- _response =
- conn
- |> with_credentials(current_user.nickname, "test")
- |> post(request_path)
-
- request_path = String.replace(request_path, "retweet", "unretweet")
-
- response =
- conn
- |> with_credentials(current_user.nickname, "test")
- |> post(request_path)
-
- activity = Activity.get_by_id(note_activity.id)
- activity_user = User.get_cached_by_ap_id(note_activity.data["actor"])
-
- assert json_response(response, 200) ==
- ActivityView.render("activity.json", %{
- user: activity_user,
- for: current_user,
- activity: activity
- })
- end
- end
-
- describe "POST /api/account/register" do
- test "it creates a new user", %{conn: conn} do
- data = %{
- "nickname" => "lain",
- "email" => "lain@wired.jp",
- "fullname" => "lain iwakura",
- "bio" => "close the world.",
- "password" => "bear",
- "confirm" => "bear"
- }
-
- conn =
- conn
- |> post("/api/account/register", data)
-
- user = json_response(conn, 200)
-
- fetched_user = User.get_cached_by_nickname("lain")
- assert user == UserView.render("show.json", %{user: fetched_user})
- end
-
- test "it returns errors on a problem", %{conn: conn} do
- data = %{
- "email" => "lain@wired.jp",
- "fullname" => "lain iwakura",
- "bio" => "close the world.",
- "password" => "bear",
- "confirm" => "bear"
- }
-
- conn =
- conn
- |> post("/api/account/register", data)
-
- errors = json_response(conn, 400)
-
- assert is_binary(errors["error"])
- end
- end
-
- describe "POST /api/account/password_reset, with valid parameters" do
- setup %{conn: conn} do
- user = insert(:user)
- conn = post(conn, "/api/account/password_reset?email=#{user.email}")
- %{conn: conn, user: user}
- end
-
- test "it returns 204", %{conn: conn} do
- assert json_response(conn, :no_content)
- end
-
- test "it creates a PasswordResetToken record for user", %{user: user} do
- token_record = Repo.get_by(Pleroma.PasswordResetToken, user_id: user.id)
- assert token_record
- end
-
- test "it sends an email to user", %{user: user} do
- token_record = Repo.get_by(Pleroma.PasswordResetToken, user_id: user.id)
-
- email = Pleroma.Emails.UserEmail.password_reset_email(user, token_record.token)
- notify_email = Pleroma.Config.get([:instance, :notify_email])
- instance_name = Pleroma.Config.get([:instance, :name])
-
- assert_email_sent(
- from: {instance_name, notify_email},
- to: {user.name, user.email},
- html_body: email.html_body
- )
- end
- end
-
- describe "POST /api/account/password_reset, with invalid parameters" do
- setup [:valid_user]
-
- test "it returns 404 when user is not found", %{conn: conn, user: user} do
- conn = post(conn, "/api/account/password_reset?email=nonexisting_#{user.email}")
- assert conn.status == 404
- assert conn.resp_body == ""
- end
-
- test "it returns 400 when user is not local", %{conn: conn, user: user} do
- {:ok, user} = Repo.update(Changeset.change(user, local: false))
- conn = post(conn, "/api/account/password_reset?email=#{user.email}")
- assert conn.status == 400
- assert conn.resp_body == ""
- end
- end
-
- describe "GET /api/account/confirm_email/:id/:token" do
- setup do
- user = insert(:user)
- info_change = User.Info.confirmation_changeset(user.info, need_confirmation: true)
-
- {:ok, user} =
- user
- |> Changeset.change()
- |> Changeset.put_embed(:info, info_change)
- |> Repo.update()
-
- assert user.info.confirmation_pending
-
- [user: user]
- end
-
- test "it redirects to root url", %{conn: conn, user: user} do
- conn = get(conn, "/api/account/confirm_email/#{user.id}/#{user.info.confirmation_token}")
-
- assert 302 == conn.status
- end
-
- test "it confirms the user account", %{conn: conn, user: user} do
- get(conn, "/api/account/confirm_email/#{user.id}/#{user.info.confirmation_token}")
-
- user = User.get_cached_by_id(user.id)
-
- refute user.info.confirmation_pending
- refute user.info.confirmation_token
- end
-
- test "it returns 500 if user cannot be found by id", %{conn: conn, user: user} do
- conn = get(conn, "/api/account/confirm_email/0/#{user.info.confirmation_token}")
-
- assert 500 == conn.status
- end
-
- test "it returns 500 if token is invalid", %{conn: conn, user: user} do
- conn = get(conn, "/api/account/confirm_email/#{user.id}/wrong_token")
-
- assert 500 == conn.status
- end
- end
-
- describe "POST /api/account/resend_confirmation_email" do
- setup do
- user = insert(:user)
- info_change = User.Info.confirmation_changeset(user.info, need_confirmation: true)
-
- {:ok, user} =
- user
- |> Changeset.change()
- |> Changeset.put_embed(:info, info_change)
- |> Repo.update()
-
- assert user.info.confirmation_pending
-
- [user: user]
- end
-
- clear_config([:instance, :account_activation_required]) do
- Pleroma.Config.put([:instance, :account_activation_required], true)
- end
-
- test "it returns 204 No Content", %{conn: conn, user: user} do
- conn
- |> assign(:user, user)
- |> post("/api/account/resend_confirmation_email?email=#{user.email}")
- |> json_response(:no_content)
- end
-
- test "it sends confirmation email", %{conn: conn, user: user} do
- conn
- |> assign(:user, user)
- |> post("/api/account/resend_confirmation_email?email=#{user.email}")
-
- email = Pleroma.Emails.UserEmail.account_confirmation_email(user)
- notify_email = Pleroma.Config.get([:instance, :notify_email])
- instance_name = Pleroma.Config.get([:instance, :name])
-
- assert_email_sent(
- from: {instance_name, notify_email},
- to: {user.name, user.email},
- html_body: email.html_body
- )
- end
- end
-
- describe "GET /api/externalprofile/show" do
- test "it returns the user", %{conn: conn} do
- user = insert(:user)
- other_user = insert(:user)
-
- conn =
- conn
- |> assign(:user, user)
- |> get("/api/externalprofile/show", %{profileurl: other_user.ap_id})
-
- assert json_response(conn, 200) == UserView.render("show.json", %{user: other_user})
- end
- end
-
- describe "GET /api/statuses/followers" do
- test "it returns a user's followers", %{conn: conn} do
- user = insert(:user)
- follower_one = insert(:user)
- follower_two = insert(:user)
- _not_follower = insert(:user)
-
- {:ok, follower_one} = User.follow(follower_one, user)
- {:ok, follower_two} = User.follow(follower_two, user)
-
- conn =
- conn
- |> assign(:user, user)
- |> get("/api/statuses/followers")
-
- expected = UserView.render("index.json", %{users: [follower_one, follower_two], for: user})
- result = json_response(conn, 200)
- assert Enum.sort(expected) == Enum.sort(result)
- end
-
- test "it returns 20 followers per page", %{conn: conn} do
- user = insert(:user)
- followers = insert_list(21, :user)
-
- Enum.each(followers, fn follower ->
- User.follow(follower, user)
- end)
-
- res_conn =
- conn
- |> assign(:user, user)
- |> get("/api/statuses/followers")
-
- result = json_response(res_conn, 200)
- assert length(result) == 20
-
- res_conn =
- conn
- |> assign(:user, user)
- |> get("/api/statuses/followers?page=2")
-
- result = json_response(res_conn, 200)
- assert length(result) == 1
- end
-
- test "it returns a given user's followers with user_id", %{conn: conn} do
- user = insert(:user)
- follower_one = insert(:user)
- follower_two = insert(:user)
- not_follower = insert(:user)
-
- {:ok, follower_one} = User.follow(follower_one, user)
- {:ok, follower_two} = User.follow(follower_two, user)
-
- conn =
- conn
- |> assign(:user, not_follower)
- |> get("/api/statuses/followers", %{"user_id" => user.id})
-
- assert MapSet.equal?(
- MapSet.new(json_response(conn, 200)),
- MapSet.new(
- UserView.render("index.json", %{
- users: [follower_one, follower_two],
- for: not_follower
- })
- )
- )
- end
-
- test "it returns empty when hide_followers is set to true", %{conn: conn} do
- user = insert(:user, %{info: %{hide_followers: true}})
- follower_one = insert(:user)
- follower_two = insert(:user)
- not_follower = insert(:user)
-
- {:ok, _follower_one} = User.follow(follower_one, user)
- {:ok, _follower_two} = User.follow(follower_two, user)
-
- response =
- conn
- |> assign(:user, not_follower)
- |> get("/api/statuses/followers", %{"user_id" => user.id})
- |> json_response(200)
-
- assert [] == response
- end
-
- test "it returns the followers when hide_followers is set to true if requested by the user themselves",
- %{
- conn: conn
- } do
- user = insert(:user, %{info: %{hide_followers: true}})
- follower_one = insert(:user)
- follower_two = insert(:user)
- _not_follower = insert(:user)
-
- {:ok, _follower_one} = User.follow(follower_one, user)
- {:ok, _follower_two} = User.follow(follower_two, user)
-
- conn =
- conn
- |> assign(:user, user)
- |> get("/api/statuses/followers", %{"user_id" => user.id})
-
- refute [] == json_response(conn, 200)
- end
- end
-
- describe "GET /api/statuses/blocks" do
- test "it returns the list of users blocked by requester", %{conn: conn} do
- user = insert(:user)
- other_user = insert(:user)
-
- {:ok, user} = User.block(user, other_user)
-
- conn =
- conn
- |> assign(:user, user)
- |> get("/api/statuses/blocks")
-
- expected = UserView.render("index.json", %{users: [other_user], for: user})
- result = json_response(conn, 200)
- assert Enum.sort(expected) == Enum.sort(result)
- end
- end
-
- describe "GET /api/statuses/friends" do
- test "it returns the logged in user's friends", %{conn: conn} do
- user = insert(:user)
- followed_one = insert(:user)
- followed_two = insert(:user)
- _not_followed = insert(:user)
-
- {:ok, user} = User.follow(user, followed_one)
- {:ok, user} = User.follow(user, followed_two)
-
- conn =
- conn
- |> assign(:user, user)
- |> get("/api/statuses/friends")
-
- expected = UserView.render("index.json", %{users: [followed_one, followed_two], for: user})
- result = json_response(conn, 200)
- assert Enum.sort(expected) == Enum.sort(result)
- end
-
- test "it returns 20 friends per page, except if 'export' is set to true", %{conn: conn} do
- user = insert(:user)
- followeds = insert_list(21, :user)
-
- {:ok, user} =
- Enum.reduce(followeds, {:ok, user}, fn followed, {:ok, user} ->
- User.follow(user, followed)
- end)
-
- res_conn =
- conn
- |> assign(:user, user)
- |> get("/api/statuses/friends")
-
- result = json_response(res_conn, 200)
- assert length(result) == 20
-
- res_conn =
- conn
- |> assign(:user, user)
- |> get("/api/statuses/friends", %{page: 2})
-
- result = json_response(res_conn, 200)
- assert length(result) == 1
-
- res_conn =
- conn
- |> assign(:user, user)
- |> get("/api/statuses/friends", %{all: true})
-
- result = json_response(res_conn, 200)
- assert length(result) == 21
- end
-
- test "it returns a given user's friends with user_id", %{conn: conn} do
- user = insert(:user)
- followed_one = insert(:user)
- followed_two = insert(:user)
- _not_followed = insert(:user)
-
- {:ok, user} = User.follow(user, followed_one)
- {:ok, user} = User.follow(user, followed_two)
-
- conn =
- conn
- |> assign(:user, user)
- |> get("/api/statuses/friends", %{"user_id" => user.id})
-
- assert MapSet.equal?(
- MapSet.new(json_response(conn, 200)),
- MapSet.new(
- UserView.render("index.json", %{users: [followed_one, followed_two], for: user})
- )
- )
- end
-
- test "it returns empty when hide_follows is set to true", %{conn: conn} do
- user = insert(:user, %{info: %{hide_follows: true}})
- followed_one = insert(:user)
- followed_two = insert(:user)
- not_followed = insert(:user)
-
- {:ok, user} = User.follow(user, followed_one)
- {:ok, user} = User.follow(user, followed_two)
-
- conn =
- conn
- |> assign(:user, not_followed)
- |> get("/api/statuses/friends", %{"user_id" => user.id})
-
- assert [] == json_response(conn, 200)
- end
-
- test "it returns friends when hide_follows is set to true if the user themselves request it",
- %{
- conn: conn
- } do
- user = insert(:user, %{info: %{hide_follows: true}})
- followed_one = insert(:user)
- followed_two = insert(:user)
- _not_followed = insert(:user)
-
- {:ok, _user} = User.follow(user, followed_one)
- {:ok, _user} = User.follow(user, followed_two)
-
- response =
- conn
- |> assign(:user, user)
- |> get("/api/statuses/friends", %{"user_id" => user.id})
- |> json_response(200)
-
- refute [] == response
- end
-
- test "it returns a given user's friends with screen_name", %{conn: conn} do
- user = insert(:user)
- followed_one = insert(:user)
- followed_two = insert(:user)
- _not_followed = insert(:user)
-
- {:ok, user} = User.follow(user, followed_one)
- {:ok, user} = User.follow(user, followed_two)
-
- conn =
- conn
- |> assign(:user, user)
- |> get("/api/statuses/friends", %{"screen_name" => user.nickname})
-
- assert MapSet.equal?(
- MapSet.new(json_response(conn, 200)),
- MapSet.new(
- UserView.render("index.json", %{users: [followed_one, followed_two], for: user})
- )
- )
- end
- end
-
- describe "GET /friends/ids" do
- test "it returns a user's friends", %{conn: conn} do
- user = insert(:user)
- followed_one = insert(:user)
- followed_two = insert(:user)
- _not_followed = insert(:user)
-
- {:ok, user} = User.follow(user, followed_one)
- {:ok, user} = User.follow(user, followed_two)
-
- conn =
- conn
- |> assign(:user, user)
- |> get("/api/friends/ids")
-
- expected = [followed_one.id, followed_two.id]
-
- assert MapSet.equal?(
- MapSet.new(Poison.decode!(json_response(conn, 200))),
- MapSet.new(expected)
- )
- end
- end
-
- describe "POST /api/account/update_profile.json" do
- test "it updates a user's profile", %{conn: conn} do
- user = insert(:user)
- user2 = insert(:user)
-
- conn =
- conn
- |> assign(:user, user)
- |> post("/api/account/update_profile.json", %{
- "name" => "new name",
- "description" => "hi @#{user2.nickname}"
- })
-
- user = Repo.get!(User, user.id)
- assert user.name == "new name"
-
- assert user.bio ==
- "hi <span class='h-card'><a data-user='#{user2.id}' class='u-url mention' href='#{
- user2.ap_id
- }'>@<span>#{user2.nickname}</span></a></span>"
-
- assert json_response(conn, 200) == UserView.render("user.json", %{user: user, for: user})
- end
-
- test "it sets and un-sets hide_follows", %{conn: conn} do
- user = insert(:user)
-
- conn
- |> assign(:user, user)
- |> post("/api/account/update_profile.json", %{
- "hide_follows" => "true"
- })
-
- user = Repo.get!(User, user.id)
- assert user.info.hide_follows == true
-
- conn =
- conn
- |> assign(:user, user)
- |> post("/api/account/update_profile.json", %{
- "hide_follows" => "false"
- })
-
- user = refresh_record(user)
- assert user.info.hide_follows == false
- assert json_response(conn, 200) == UserView.render("user.json", %{user: user, for: user})
- end
-
- test "it sets and un-sets hide_followers", %{conn: conn} do
- user = insert(:user)
-
- conn
- |> assign(:user, user)
- |> post("/api/account/update_profile.json", %{
- "hide_followers" => "true"
- })
-
- user = Repo.get!(User, user.id)
- assert user.info.hide_followers == true
-
- conn =
- conn
- |> assign(:user, user)
- |> post("/api/account/update_profile.json", %{
- "hide_followers" => "false"
- })
-
- user = Repo.get!(User, user.id)
- assert user.info.hide_followers == false
- assert json_response(conn, 200) == UserView.render("user.json", %{user: user, for: user})
- end
-
- test "it sets and un-sets show_role", %{conn: conn} do
- user = insert(:user)
-
- conn
- |> assign(:user, user)
- |> post("/api/account/update_profile.json", %{
- "show_role" => "true"
- })
-
- user = Repo.get!(User, user.id)
- assert user.info.show_role == true
-
- conn =
- conn
- |> assign(:user, user)
- |> post("/api/account/update_profile.json", %{
- "show_role" => "false"
- })
-
- user = Repo.get!(User, user.id)
- assert user.info.show_role == false
- assert json_response(conn, 200) == UserView.render("user.json", %{user: user, for: user})
- end
-
- test "it sets and un-sets skip_thread_containment", %{conn: conn} do
- user = insert(:user)
-
- response =
- conn
- |> assign(:user, user)
- |> post("/api/account/update_profile.json", %{"skip_thread_containment" => "true"})
- |> json_response(200)
-
- assert response["pleroma"]["skip_thread_containment"] == true
- user = refresh_record(user)
- assert user.info.skip_thread_containment
-
- response =
- conn
- |> assign(:user, user)
- |> post("/api/account/update_profile.json", %{"skip_thread_containment" => "false"})
- |> json_response(200)
-
- assert response["pleroma"]["skip_thread_containment"] == false
- refute refresh_record(user).info.skip_thread_containment
- end
-
- test "it locks an account", %{conn: conn} do
- user = insert(:user)
-
- conn =
- conn
- |> assign(:user, user)
- |> post("/api/account/update_profile.json", %{
- "locked" => "true"
- })
-
- user = Repo.get!(User, user.id)
- assert user.info.locked == true
-
- assert json_response(conn, 200) == UserView.render("user.json", %{user: user, for: user})
- end
-
- test "it unlocks an account", %{conn: conn} do
- user = insert(:user)
-
- conn =
- conn
- |> assign(:user, user)
- |> post("/api/account/update_profile.json", %{
- "locked" => "false"
- })
-
- user = Repo.get!(User, user.id)
- assert user.info.locked == false
-
- assert json_response(conn, 200) == UserView.render("user.json", %{user: user, for: user})
- end
-
- # Broken before the change to class="emoji" and non-<img/> in the DB
- @tag :skip
- test "it formats emojos", %{conn: conn} do
- user = insert(:user)
-
- conn =
- conn
- |> assign(:user, user)
- |> post("/api/account/update_profile.json", %{
- "bio" => "I love our :moominmamma:"
- })
-
- assert response = json_response(conn, 200)
-
- assert %{
- "description" => "I love our :moominmamma:",
- "description_html" =>
- ~s{I love our <img class="emoji" alt="moominmamma" title="moominmamma" src="} <>
- _
- } = response
-
- conn =
- conn
- |> get("/api/users/show.json?user_id=#{user.nickname}")
-
- assert response == json_response(conn, 200)
- end
- end
-
- defp valid_user(_context) do
- user = insert(:user)
- [user: user]
- end
-
- defp with_credentials(conn, username, password) do
- header_content = "Basic " <> Base.encode64("#{username}:#{password}")
- put_req_header(conn, "authorization", header_content)
- end
-
- describe "GET /api/search.json" do
- test "it returns search results", %{conn: conn} do
- user = insert(:user)
- user_two = insert(:user, %{nickname: "shp@shitposter.club"})
-
- {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
- {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
-
- conn =
- conn
- |> get("/api/search.json", %{"q" => "2hu", "page" => "1", "rpp" => "1"})
-
- assert [status] = json_response(conn, 200)
- assert status["id"] == activity.id
- end
- end
-
- describe "GET /api/statusnet/tags/timeline/:tag.json" do
- test "it returns the tags timeline", %{conn: conn} do
- user = insert(:user)
- user_two = insert(:user, %{nickname: "shp@shitposter.club"})
-
- {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about #2hu"})
- {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
-
- conn =
- conn
- |> get("/api/statusnet/tags/timeline/2hu.json")
-
- assert [status] = json_response(conn, 200)
- assert status["id"] == activity.id
- end
- end
-
- test "Convert newlines to <br> in bio", %{conn: conn} do
- user = insert(:user)
-
- _conn =
- conn
- |> assign(:user, user)
- |> post("/api/account/update_profile.json", %{
- "description" => "Hello,\r\nWorld! I\n am a test."
- })
-
- user = Repo.get!(User, user.id)
- assert user.bio == "Hello,<br>World! I<br> am a test."
- end
-
- describe "POST /api/pleroma/change_password" do
- setup [:valid_user]
-
- test "without credentials", %{conn: conn} do
- conn = post(conn, "/api/pleroma/change_password")
- assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
- end
-
- test "with credentials and invalid password", %{conn: conn, user: current_user} do
- conn =
- conn
- |> with_credentials(current_user.nickname, "test")
- |> post("/api/pleroma/change_password", %{
- "password" => "hi",
- "new_password" => "newpass",
- "new_password_confirmation" => "newpass"
- })
-
- assert json_response(conn, 200) == %{"error" => "Invalid password."}
- end
-
- test "with credentials, valid password and new password and confirmation not matching", %{
- conn: conn,
- user: current_user
- } do
- conn =
- conn
- |> with_credentials(current_user.nickname, "test")
- |> post("/api/pleroma/change_password", %{
- "password" => "test",
- "new_password" => "newpass",
- "new_password_confirmation" => "notnewpass"
- })
-
- assert json_response(conn, 200) == %{
- "error" => "New password does not match confirmation."
- }
- end
-
- test "with credentials, valid password and invalid new password", %{
- conn: conn,
- user: current_user
- } do
- conn =
- conn
- |> with_credentials(current_user.nickname, "test")
- |> post("/api/pleroma/change_password", %{
- "password" => "test",
- "new_password" => "",
- "new_password_confirmation" => ""
- })
-
- assert json_response(conn, 200) == %{
- "error" => "New password can't be blank."
- }
- end
-
- test "with credentials, valid password and matching new password and confirmation", %{
- conn: conn,
- user: current_user
- } do
- conn =
- conn
- |> with_credentials(current_user.nickname, "test")
- |> post("/api/pleroma/change_password", %{
- "password" => "test",
- "new_password" => "newpass",
- "new_password_confirmation" => "newpass"
- })
-
- assert json_response(conn, 200) == %{"status" => "success"}
- fetched_user = User.get_cached_by_id(current_user.id)
- assert Pbkdf2.checkpw("newpass", fetched_user.password_hash) == true
- end
- end
-
- describe "POST /api/pleroma/delete_account" do
- setup [:valid_user]
-
- test "without credentials", %{conn: conn} do
- conn = post(conn, "/api/pleroma/delete_account")
- assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
- end
-
- test "with credentials and invalid password", %{conn: conn, user: current_user} do
- conn =
- conn
- |> with_credentials(current_user.nickname, "test")
- |> post("/api/pleroma/delete_account", %{"password" => "hi"})
-
- assert json_response(conn, 200) == %{"error" => "Invalid password."}
- end
-
- test "with credentials and valid password", %{conn: conn, user: current_user} do
- conn =
- conn
- |> with_credentials(current_user.nickname, "test")
- |> post("/api/pleroma/delete_account", %{"password" => "test"})
-
- assert json_response(conn, 200) == %{"status" => "success"}
- # Wait a second for the started task to end
- :timer.sleep(1000)
- end
- end
-
- describe "GET /api/pleroma/friend_requests" do
- test "it lists friend requests" do
- user = insert(:user)
- other_user = insert(:user)
-
- {:ok, _activity} = ActivityPub.follow(other_user, user)
-
- user = User.get_cached_by_id(user.id)
- other_user = User.get_cached_by_id(other_user.id)
-
- assert User.following?(other_user, user) == false
-
- conn =
- build_conn()
- |> assign(:user, user)
- |> get("/api/pleroma/friend_requests")
-
- assert [relationship] = json_response(conn, 200)
- assert other_user.id == relationship["id"]
- end
-
- test "requires 'read' permission", %{conn: conn} do
- token1 = insert(:oauth_token, scopes: ["write"])
- token2 = insert(:oauth_token, scopes: ["read"])
-
- for token <- [token1, token2] do
- conn =
- conn
- |> put_req_header("authorization", "Bearer #{token.token}")
- |> get("/api/pleroma/friend_requests")
-
- if token == token1 do
- assert %{"error" => "Insufficient permissions: read."} == json_response(conn, 403)
- else
- assert json_response(conn, 200)
- end
- end
- end
- end
-
- describe "POST /api/pleroma/friendships/approve" do
- test "it approves a friend request" do
- user = insert(:user)
- other_user = insert(:user)
-
- {:ok, _activity} = ActivityPub.follow(other_user, user)
-
- user = User.get_cached_by_id(user.id)
- other_user = User.get_cached_by_id(other_user.id)
-
- assert User.following?(other_user, user) == false
-
- conn =
- build_conn()
- |> assign(:user, user)
- |> post("/api/pleroma/friendships/approve", %{"user_id" => other_user.id})
-
- assert relationship = json_response(conn, 200)
- assert other_user.id == relationship["id"]
- assert relationship["follows_you"] == true
- end
- end
-
- describe "POST /api/pleroma/friendships/deny" do
- test "it denies a friend request" do
- user = insert(:user)
- other_user = insert(:user)
-
- {:ok, _activity} = ActivityPub.follow(other_user, user)
-
- user = User.get_cached_by_id(user.id)
- other_user = User.get_cached_by_id(other_user.id)
-
- assert User.following?(other_user, user) == false
-
- conn =
- build_conn()
- |> assign(:user, user)
- |> post("/api/pleroma/friendships/deny", %{"user_id" => other_user.id})
-
- assert relationship = json_response(conn, 200)
- assert other_user.id == relationship["id"]
- assert relationship["follows_you"] == false
- end
- end
-
- describe "GET /api/pleroma/search_user" do
- test "it returns users, ordered by similarity", %{conn: conn} do
- user = insert(:user, %{name: "eal"})
- user_two = insert(:user, %{name: "eal me"})
- _user_three = insert(:user, %{name: "zzz"})
-
- resp =
- conn
- |> get(twitter_api_search__path(conn, :search_user), query: "eal me")
- |> json_response(200)
-
- assert length(resp) == 2
- assert [user_two.id, user.id] == Enum.map(resp, fn %{"id" => id} -> id end)
- end
- end
-
- describe "POST /api/media/upload" do
- setup context do
- Pleroma.DataCase.ensure_local_uploader(context)
- end
-
- test "it performs the upload and sets `data[actor]` with AP id of uploader user", %{
- conn: conn
- } do
- user = insert(:user)
-
- upload_filename = "test/fixtures/image_tmp.jpg"
- File.cp!("test/fixtures/image.jpg", upload_filename)
-
- file = %Plug.Upload{
- content_type: "image/jpg",
- path: Path.absname(upload_filename),
- filename: "image.jpg"
- }
-
- response =
- conn
- |> assign(:user, user)
- |> put_req_header("content-type", "application/octet-stream")
- |> post("/api/media/upload", %{
- "media" => file
- })
- |> json_response(:ok)
-
- assert response["media_id"]
- object = Repo.get(Object, response["media_id"])
- assert object
- assert object.data["actor"] == User.ap_id(user)
- end
- end
-
- describe "POST /api/media/metadata/create" do
- setup do
- object = insert(:note)
- user = User.get_cached_by_ap_id(object.data["actor"])
- %{object: object, user: user}
- end
-
- test "it returns :forbidden status on attempt to modify someone else's upload", %{
- conn: conn,
- object: object
- } do
- initial_description = object.data["name"]
- another_user = insert(:user)
-
- conn
- |> assign(:user, another_user)
- |> post("/api/media/metadata/create", %{"media_id" => object.id})
- |> json_response(:forbidden)
-
- object = Repo.get(Object, object.id)
- assert object.data["name"] == initial_description
- end
-
- test "it updates `data[name]` of referenced Object with provided value", %{
- conn: conn,
- object: object,
- user: user
- } do
- description = "Informative description of the image. Initial value: #{object.data["name"]}}"
-
- conn
- |> assign(:user, user)
- |> post("/api/media/metadata/create", %{
- "media_id" => object.id,
- "alt_text" => %{"text" => description}
- })
- |> json_response(:no_content)
-
- object = Repo.get(Object, object.id)
- assert object.data["name"] == description
- end
- end
-
- describe "POST /api/statuses/user_timeline.json?user_id=:user_id&pinned=true" do
- test "it returns a list of pinned statuses", %{conn: conn} do
- Pleroma.Config.put([:instance, :max_pinned_statuses], 1)
-
- user = insert(:user, %{name: "egor"})
- {:ok, %{id: activity_id}} = CommonAPI.post(user, %{"status" => "HI!!!"})
- {:ok, _} = CommonAPI.pin(activity_id, user)
-
- resp =
- conn
- |> get("/api/statuses/user_timeline.json", %{user_id: user.id, pinned: true})
- |> json_response(200)
-
- assert length(resp) == 1
- assert [%{"id" => ^activity_id, "pinned" => true}] = resp
- end
- end
-
- describe "POST /api/statuses/pin/:id" do
- setup do
- Pleroma.Config.put([:instance, :max_pinned_statuses], 1)
- [user: insert(:user)]
- end
-
- test "without valid credentials", %{conn: conn} do
- note_activity = insert(:note_activity)
- conn = post(conn, "/api/statuses/pin/#{note_activity.id}.json")
- assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
- end
-
- test "with credentials", %{conn: conn, user: user} do
- {:ok, activity} = CommonAPI.post(user, %{"status" => "test!"})
-
- request_path = "/api/statuses/pin/#{activity.id}.json"
-
- response =
- conn
- |> with_credentials(user.nickname, "test")
- |> post(request_path)
-
- user = refresh_record(user)
-
- assert json_response(response, 200) ==
- ActivityView.render("activity.json", %{user: user, for: user, activity: activity})
- end
- end
-
- describe "POST /api/statuses/unpin/:id" do
- setup do
- Pleroma.Config.put([:instance, :max_pinned_statuses], 1)
- [user: insert(:user)]
- end
-
- test "without valid credentials", %{conn: conn} do
- note_activity = insert(:note_activity)
- conn = post(conn, "/api/statuses/unpin/#{note_activity.id}.json")
- assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
- end
-
- test "with credentials", %{conn: conn, user: user} do
- {:ok, activity} = CommonAPI.post(user, %{"status" => "test!"})
- {:ok, activity} = CommonAPI.pin(activity.id, user)
-
- request_path = "/api/statuses/unpin/#{activity.id}.json"
-
- response =
- conn
- |> with_credentials(user.nickname, "test")
- |> post(request_path)
-
- user = refresh_record(user)
-
- assert json_response(response, 200) ==
- ActivityView.render("activity.json", %{user: user, for: user, activity: activity})
- end
- end
-
- describe "GET /api/oauth_tokens" do
- setup do
- token = insert(:oauth_token) |> Repo.preload(:user)
-
- %{token: token}
- end
-
- test "renders list", %{token: token} do
- response =
- build_conn()
- |> assign(:user, token.user)
- |> get("/api/oauth_tokens")
-
- keys =
- json_response(response, 200)
- |> hd()
- |> Map.keys()
-
- assert keys -- ["id", "app_name", "valid_until"] == []
- end
-
- test "revoke token", %{token: token} do
- response =
- build_conn()
- |> assign(:user, token.user)
- |> delete("/api/oauth_tokens/#{token.id}")
-
- tokens = Token.get_user_tokens(token.user)
-
- assert tokens == []
- assert response.status == 201
- end
- end
-end
defmodule Pleroma.Web.TwitterAPI.TwitterAPITest do
use Pleroma.DataCase
- alias Pleroma.Activity
- alias Pleroma.Object
alias Pleroma.Repo
alias Pleroma.User
alias Pleroma.UserInviteToken
- alias Pleroma.Web.ActivityPub.ActivityPub
- alias Pleroma.Web.TwitterAPI.ActivityView
+ alias Pleroma.Web.MastodonAPI.AccountView
alias Pleroma.Web.TwitterAPI.TwitterAPI
- alias Pleroma.Web.TwitterAPI.UserView
-
- import Pleroma.Factory
setup_all do
Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
:ok
end
- test "create a status" do
- user = insert(:user)
- mentioned_user = insert(:user, %{nickname: "shp", ap_id: "shp"})
-
- object_data = %{
- "type" => "Image",
- "url" => [
- %{
- "type" => "Link",
- "mediaType" => "image/jpg",
- "href" => "http://example.org/image.jpg"
- }
- ],
- "uuid" => 1
- }
-
- object = Repo.insert!(%Object{data: object_data})
-
- input = %{
- "status" =>
- "Hello again, @shp.<script></script>\nThis is on another :firefox: line. #2hu #epic #phantasmagoric",
- "media_ids" => [object.id]
- }
-
- {:ok, activity = %Activity{}} = TwitterAPI.create_status(user, input)
- object = Object.normalize(activity)
-
- expected_text =
- "Hello again, <span class='h-card'><a data-user='#{mentioned_user.id}' class='u-url mention' href='shp'>@<span>shp</span></a></span>.<script></script><br>This is on another :firefox: line. <a class='hashtag' data-tag='2hu' href='http://localhost:4001/tag/2hu' rel='tag'>#2hu</a> <a class='hashtag' data-tag='epic' href='http://localhost:4001/tag/epic' rel='tag'>#epic</a> <a class='hashtag' data-tag='phantasmagoric' href='http://localhost:4001/tag/phantasmagoric' rel='tag'>#phantasmagoric</a><br><a href=\"http://example.org/image.jpg\" class='attachment'>image.jpg</a>"
-
- assert get_in(object.data, ["content"]) == expected_text
- assert get_in(object.data, ["type"]) == "Note"
- assert get_in(object.data, ["actor"]) == user.ap_id
- assert get_in(activity.data, ["actor"]) == user.ap_id
- assert Enum.member?(get_in(activity.data, ["cc"]), User.ap_followers(user))
-
- assert Enum.member?(
- get_in(activity.data, ["to"]),
- "https://www.w3.org/ns/activitystreams#Public"
- )
-
- assert Enum.member?(get_in(activity.data, ["to"]), "shp")
- assert activity.local == true
-
- assert %{"firefox" => "http://localhost:4001/emoji/Firefox.gif"} = object.data["emoji"]
-
- # hashtags
- assert object.data["tag"] == ["2hu", "epic", "phantasmagoric"]
-
- # Add a context
- assert is_binary(get_in(activity.data, ["context"]))
- assert is_binary(get_in(object.data, ["context"]))
-
- assert is_list(object.data["attachment"])
-
- assert activity.data["object"] == object.data["id"]
-
- user = User.get_cached_by_ap_id(user.ap_id)
-
- assert user.info.note_count == 1
- end
-
- test "create a status that is a reply" do
- user = insert(:user)
-
- input = %{
- "status" => "Hello again."
- }
-
- {:ok, activity = %Activity{}} = TwitterAPI.create_status(user, input)
- object = Object.normalize(activity)
-
- input = %{
- "status" => "Here's your (you).",
- "in_reply_to_status_id" => activity.id
- }
-
- {:ok, reply = %Activity{}} = TwitterAPI.create_status(user, input)
- reply_object = Object.normalize(reply)
-
- assert get_in(reply.data, ["context"]) == get_in(activity.data, ["context"])
-
- assert get_in(reply_object.data, ["context"]) == get_in(object.data, ["context"])
-
- assert get_in(reply_object.data, ["inReplyTo"]) == get_in(activity.data, ["object"])
- assert Activity.get_in_reply_to_activity(reply).id == activity.id
- end
-
- test "Follow another user using user_id" do
- user = insert(:user)
- followed = insert(:user)
-
- {:ok, user, followed, _activity} = TwitterAPI.follow(user, %{"user_id" => followed.id})
- assert User.ap_followers(followed) in user.following
-
- {:ok, _, _, _} = TwitterAPI.follow(user, %{"user_id" => followed.id})
- end
-
- test "Follow another user using screen_name" do
- user = insert(:user)
- followed = insert(:user)
-
- {:ok, user, followed, _activity} =
- TwitterAPI.follow(user, %{"screen_name" => followed.nickname})
-
- assert User.ap_followers(followed) in user.following
-
- followed = User.get_cached_by_ap_id(followed.ap_id)
- assert followed.info.follower_count == 1
-
- {:ok, _, _, _} = TwitterAPI.follow(user, %{"screen_name" => followed.nickname})
- end
-
- test "Unfollow another user using user_id" do
- unfollowed = insert(:user)
- user = insert(:user, %{following: [User.ap_followers(unfollowed)]})
- ActivityPub.follow(user, unfollowed)
-
- {:ok, user, unfollowed} = TwitterAPI.unfollow(user, %{"user_id" => unfollowed.id})
- assert user.following == []
-
- {:error, msg} = TwitterAPI.unfollow(user, %{"user_id" => unfollowed.id})
- assert msg == "Not subscribed!"
- end
-
- test "Unfollow another user using screen_name" do
- unfollowed = insert(:user)
- user = insert(:user, %{following: [User.ap_followers(unfollowed)]})
-
- ActivityPub.follow(user, unfollowed)
-
- {:ok, user, unfollowed} = TwitterAPI.unfollow(user, %{"screen_name" => unfollowed.nickname})
- assert user.following == []
-
- {:error, msg} = TwitterAPI.unfollow(user, %{"screen_name" => unfollowed.nickname})
- assert msg == "Not subscribed!"
- end
-
- test "Block another user using user_id" do
- user = insert(:user)
- blocked = insert(:user)
-
- {:ok, user, blocked} = TwitterAPI.block(user, %{"user_id" => blocked.id})
- assert User.blocks?(user, blocked)
- end
-
- test "Block another user using screen_name" do
- user = insert(:user)
- blocked = insert(:user)
-
- {:ok, user, blocked} = TwitterAPI.block(user, %{"screen_name" => blocked.nickname})
- assert User.blocks?(user, blocked)
- end
-
- test "Unblock another user using user_id" do
- unblocked = insert(:user)
- user = insert(:user)
- {:ok, user, _unblocked} = TwitterAPI.block(user, %{"user_id" => unblocked.id})
-
- {:ok, user, _unblocked} = TwitterAPI.unblock(user, %{"user_id" => unblocked.id})
- assert user.info.blocks == []
- end
-
- test "Unblock another user using screen_name" do
- unblocked = insert(:user)
- user = insert(:user)
- {:ok, user, _unblocked} = TwitterAPI.block(user, %{"screen_name" => unblocked.nickname})
-
- {:ok, user, _unblocked} = TwitterAPI.unblock(user, %{"screen_name" => unblocked.nickname})
- assert user.info.blocks == []
- end
-
- test "upload a file" do
- user = insert(:user)
-
- file = %Plug.Upload{
- content_type: "image/jpg",
- path: Path.absname("test/fixtures/image.jpg"),
- filename: "an_image.jpg"
- }
-
- response = TwitterAPI.upload(file, user)
-
- assert is_binary(response)
- end
-
- test "it favorites a status, returns the updated activity" do
- user = insert(:user)
- other_user = insert(:user)
- note_activity = insert(:note_activity)
-
- {:ok, status} = TwitterAPI.fav(user, note_activity.id)
- updated_activity = Activity.get_by_ap_id(note_activity.data["id"])
- assert ActivityView.render("activity.json", %{activity: updated_activity})["fave_num"] == 1
-
- object = Object.normalize(note_activity)
-
- assert object.data["like_count"] == 1
-
- assert status == updated_activity
-
- {:ok, _status} = TwitterAPI.fav(other_user, note_activity.id)
-
- object = Object.normalize(note_activity)
-
- assert object.data["like_count"] == 2
-
- updated_activity = Activity.get_by_ap_id(note_activity.data["id"])
- assert ActivityView.render("activity.json", %{activity: updated_activity})["fave_num"] == 2
- end
-
- test "it unfavorites a status, returns the updated activity" do
- user = insert(:user)
- note_activity = insert(:note_activity)
- object = Object.normalize(note_activity)
-
- {:ok, _like_activity, _object} = ActivityPub.like(user, object)
- updated_activity = Activity.get_by_ap_id(note_activity.data["id"])
-
- assert ActivityView.render("activity.json", activity: updated_activity)["fave_num"] == 1
-
- {:ok, activity} = TwitterAPI.unfav(user, note_activity.id)
-
- assert ActivityView.render("activity.json", activity: activity)["fave_num"] == 0
- end
-
- test "it retweets a status and returns the retweet" do
- user = insert(:user)
- note_activity = insert(:note_activity)
-
- {:ok, status} = TwitterAPI.repeat(user, note_activity.id)
- updated_activity = Activity.get_by_ap_id(note_activity.data["id"])
-
- assert status == updated_activity
- end
-
- test "it unretweets an already retweeted status" do
- user = insert(:user)
- note_activity = insert(:note_activity)
-
- {:ok, _status} = TwitterAPI.repeat(user, note_activity.id)
- {:ok, status} = TwitterAPI.unrepeat(user, note_activity.id)
- updated_activity = Activity.get_by_ap_id(note_activity.data["id"])
-
- assert status == updated_activity
- end
-
test "it registers a new user and returns the user." do
data = %{
"nickname" => "lain",
fetched_user = User.get_cached_by_nickname("lain")
- assert UserView.render("show.json", %{user: user}) ==
- UserView.render("show.json", %{user: fetched_user})
+ assert AccountView.render("account.json", %{user: user}) ==
+ AccountView.render("account.json", %{user: fetched_user})
end
test "it registers a new user with empty string in bio and returns the user." do
fetched_user = User.get_cached_by_nickname("lain")
- assert UserView.render("show.json", %{user: user}) ==
- UserView.render("show.json", %{user: fetched_user})
+ assert AccountView.render("account.json", %{user: user}) ==
+ AccountView.render("account.json", %{user: fetched_user})
end
test "it sends confirmation email if :account_activation_required is specified in instance config" do
assert invite.used == true
- assert UserView.render("show.json", %{user: user}) ==
- UserView.render("show.json", %{user: fetched_user})
+ assert AccountView.render("account.json", %{user: user}) ==
+ AccountView.render("account.json", %{user: fetched_user})
end
test "returns error on invalid token" do
{:ok, user} = TwitterAPI.register_user(data)
fetched_user = User.get_cached_by_nickname("vinny")
- assert UserView.render("show.json", %{user: user}) ==
- UserView.render("show.json", %{user: fetched_user})
+ assert AccountView.render("account.json", %{user: user}) ==
+ AccountView.render("account.json", %{user: fetched_user})
end
{:ok, data: data, check_fn: check_fn}
assert invite.used == true
- assert UserView.render("show.json", %{user: user}) ==
- UserView.render("show.json", %{user: fetched_user})
+ assert AccountView.render("account.json", %{user: user}) ==
+ AccountView.render("account.json", %{user: fetched_user})
data = %{
"nickname" => "GrimReaper",
refute invite.used
- assert UserView.render("show.json", %{user: user}) ==
- UserView.render("show.json", %{user: fetched_user})
+ assert AccountView.render("account.json", %{user: user}) ==
+ AccountView.render("account.json", %{user: fetched_user})
end
test "error after max uses" do
invite = Repo.get_by(UserInviteToken, token: invite.token)
assert invite.used == true
- assert UserView.render("show.json", %{user: user}) ==
- UserView.render("show.json", %{user: fetched_user})
+ assert AccountView.render("account.json", %{user: user}) ==
+ AccountView.render("account.json", %{user: fetched_user})
data = %{
"nickname" => "GrimReaper",
refute User.get_cached_by_nickname("lain")
end
- test "it assigns an integer conversation_id" do
- note_activity = insert(:note_activity)
- status = ActivityView.render("activity.json", activity: note_activity)
-
- assert is_number(status["statusnet_conversation_id"])
- end
-
setup do
Supervisor.terminate_child(Pleroma.Supervisor, Cachex)
Supervisor.restart_child(Pleroma.Supervisor, Cachex)
:ok
end
-
- describe "fetching a user by uri" do
- test "fetches a user by uri" do
- id = "https://mastodon.social/users/lambadalambda"
- user = insert(:user)
- {:ok, represented} = TwitterAPI.get_external_profile(user, id)
- remote = User.get_cached_by_ap_id(id)
-
- assert represented["id"] == UserView.render("show.json", %{user: remote, for: user})["id"]
-
- # Also fetches the feed.
- # assert Activity.get_create_by_object_ap_id("tag:mastodon.social,2017-04-05:objectId=1641750:objectType=Status")
- # credo:disable-for-previous-line Credo.Check.Readability.MaxLineLength
- end
- end
end
+++ /dev/null
-# Pleroma: A lightweight social networking server
-# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
-# SPDX-License-Identifier: AGPL-3.0-only
-
-defmodule Pleroma.Web.TwitterAPI.ActivityViewTest do
- use Pleroma.DataCase
-
- alias Pleroma.Activity
- alias Pleroma.Object
- alias Pleroma.Repo
- alias Pleroma.User
- alias Pleroma.Web.ActivityPub.ActivityPub
- alias Pleroma.Web.CommonAPI
- alias Pleroma.Web.CommonAPI.Utils
- alias Pleroma.Web.TwitterAPI.ActivityView
- alias Pleroma.Web.TwitterAPI.UserView
-
- import Pleroma.Factory
- import Tesla.Mock
-
- setup do
- mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
- :ok
- end
-
- import Mock
-
- test "returns a temporary ap_id based user for activities missing db users" do
- user = insert(:user)
-
- {:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!", "visibility" => "direct"})
-
- Repo.delete(user)
- Cachex.clear(:user_cache)
-
- %{"user" => tw_user} = ActivityView.render("activity.json", activity: activity)
-
- assert tw_user["screen_name"] == "erroruser@example.com"
- assert tw_user["name"] == user.ap_id
- assert tw_user["statusnet_profile_url"] == user.ap_id
- end
-
- test "tries to get a user by nickname if fetching by ap_id doesn't work" do
- user = insert(:user)
-
- {:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!", "visibility" => "direct"})
-
- {:ok, user} =
- user
- |> Ecto.Changeset.change(%{ap_id: "#{user.ap_id}/extension/#{user.nickname}"})
- |> Repo.update()
-
- Cachex.clear(:user_cache)
-
- result = ActivityView.render("activity.json", activity: activity)
- assert result["user"]["id"] == user.id
- end
-
- test "tells if the message is muted for some reason" do
- user = insert(:user)
- other_user = insert(:user)
-
- {:ok, user} = User.mute(user, other_user)
-
- {:ok, activity} = CommonAPI.post(other_user, %{"status" => "test"})
- status = ActivityView.render("activity.json", %{activity: activity})
-
- assert status["muted"] == false
-
- status = ActivityView.render("activity.json", %{activity: activity, for: user})
-
- assert status["muted"] == true
- end
-
- test "a create activity with a html status" do
- text = """
- #Bike log - Commute Tuesday\nhttps://pla.bike/posts/20181211/\n#cycling #CHScycling #commute\nMVIMG_20181211_054020.jpg
- """
-
- {:ok, activity} = CommonAPI.post(insert(:user), %{"status" => text})
-
- result = ActivityView.render("activity.json", activity: activity)
-
- assert result["statusnet_html"] ==
- "<a class=\"hashtag\" data-tag=\"bike\" href=\"http://localhost:4001/tag/bike\" rel=\"tag\">#Bike</a> log - Commute Tuesday<br /><a href=\"https://pla.bike/posts/20181211/\">https://pla.bike/posts/20181211/</a><br /><a class=\"hashtag\" data-tag=\"cycling\" href=\"http://localhost:4001/tag/cycling\" rel=\"tag\">#cycling</a> <a class=\"hashtag\" data-tag=\"chscycling\" href=\"http://localhost:4001/tag/chscycling\" rel=\"tag\">#CHScycling</a> <a class=\"hashtag\" data-tag=\"commute\" href=\"http://localhost:4001/tag/commute\" rel=\"tag\">#commute</a><br />MVIMG_20181211_054020.jpg"
-
- assert result["text"] ==
- "#Bike log - Commute Tuesday\nhttps://pla.bike/posts/20181211/\n#cycling #CHScycling #commute\nMVIMG_20181211_054020.jpg"
- end
-
- test "a create activity with a summary containing emoji" do
- {:ok, activity} =
- CommonAPI.post(insert(:user), %{
- "spoiler_text" => ":firefox: meow",
- "status" => "."
- })
-
- result = ActivityView.render("activity.json", activity: activity)
-
- expected = ":firefox: meow"
-
- expected_html =
- "<img class=\"emoji\" alt=\"firefox\" title=\"firefox\" src=\"http://localhost:4001/emoji/Firefox.gif\" /> meow"
-
- assert result["summary"] == expected
- assert result["summary_html"] == expected_html
- end
-
- test "a create activity with a summary containing invalid HTML" do
- {:ok, activity} =
- CommonAPI.post(insert(:user), %{
- "spoiler_text" => "<span style=\"color: magenta; font-size: 32px;\">meow</span>",
- "status" => "."
- })
-
- result = ActivityView.render("activity.json", activity: activity)
-
- expected = "meow"
-
- assert result["summary"] == expected
- assert result["summary_html"] == expected
- end
-
- test "a create activity with a note" do
- user = insert(:user)
- other_user = insert(:user, %{nickname: "shp"})
-
- {:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!", "visibility" => "direct"})
- object = Object.normalize(activity)
-
- result = ActivityView.render("activity.json", activity: activity)
-
- convo_id = Utils.context_to_conversation_id(object.data["context"])
-
- expected = %{
- "activity_type" => "post",
- "attachments" => [],
- "attentions" => [
- UserView.render("show.json", %{user: other_user})
- ],
- "created_at" => object.data["published"] |> Utils.date_to_asctime(),
- "external_url" => object.data["id"],
- "fave_num" => 0,
- "favorited" => false,
- "id" => activity.id,
- "in_reply_to_status_id" => nil,
- "in_reply_to_screen_name" => nil,
- "in_reply_to_user_id" => nil,
- "in_reply_to_profileurl" => nil,
- "in_reply_to_ostatus_uri" => nil,
- "is_local" => true,
- "is_post_verb" => true,
- "possibly_sensitive" => false,
- "repeat_num" => 0,
- "repeated" => false,
- "pinned" => false,
- "statusnet_conversation_id" => convo_id,
- "summary" => "",
- "summary_html" => "",
- "statusnet_html" =>
- "Hey <span class=\"h-card\"><a data-user=\"#{other_user.id}\" class=\"u-url mention\" href=\"#{
- other_user.ap_id
- }\">@<span>shp</span></a></span>!",
- "tags" => [],
- "text" => "Hey @shp!",
- "uri" => object.data["id"],
- "user" => UserView.render("show.json", %{user: user}),
- "visibility" => "direct",
- "card" => nil,
- "muted" => false
- }
-
- assert result == expected
- end
-
- test "a list of activities" do
- user = insert(:user)
- other_user = insert(:user, %{nickname: "shp"})
- {:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!"})
- object = Object.normalize(activity)
-
- convo_id = Utils.context_to_conversation_id(object.data["context"])
-
- mocks = [
- {
- Utils,
- [:passthrough],
- [context_to_conversation_id: fn _ -> false end]
- },
- {
- User,
- [:passthrough],
- [get_cached_by_ap_id: fn _ -> nil end]
- }
- ]
-
- with_mocks mocks do
- [result] = ActivityView.render("index.json", activities: [activity])
-
- assert result["statusnet_conversation_id"] == convo_id
- assert result["user"]
- refute called(Utils.context_to_conversation_id(:_))
- refute called(User.get_cached_by_ap_id(user.ap_id))
- refute called(User.get_cached_by_ap_id(other_user.ap_id))
- end
- end
-
- test "an activity that is a reply" do
- user = insert(:user)
- other_user = insert(:user, %{nickname: "shp"})
-
- {:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!"})
-
- {:ok, answer} =
- CommonAPI.post(other_user, %{"status" => "Hi!", "in_reply_to_status_id" => activity.id})
-
- result = ActivityView.render("activity.json", %{activity: answer})
-
- assert result["in_reply_to_status_id"] == activity.id
- end
-
- test "a like activity" do
- user = insert(:user)
- other_user = insert(:user, %{nickname: "shp"})
-
- {:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!"})
- {:ok, like, _object} = CommonAPI.favorite(activity.id, other_user)
-
- result = ActivityView.render("activity.json", activity: like)
- activity = Pleroma.Activity.get_by_ap_id(activity.data["id"])
-
- expected = %{
- "activity_type" => "like",
- "created_at" => like.data["published"] |> Utils.date_to_asctime(),
- "external_url" => like.data["id"],
- "id" => like.id,
- "in_reply_to_status_id" => activity.id,
- "is_local" => true,
- "is_post_verb" => false,
- "favorited_status" => ActivityView.render("activity.json", activity: activity),
- "statusnet_html" => "shp favorited a status.",
- "text" => "shp favorited a status.",
- "uri" => "tag:#{like.data["id"]}:objectType=Favourite",
- "user" => UserView.render("show.json", user: other_user)
- }
-
- assert result == expected
- end
-
- test "a like activity for deleted post" do
- user = insert(:user)
- other_user = insert(:user, %{nickname: "shp"})
-
- {:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!"})
- {:ok, like, _object} = CommonAPI.favorite(activity.id, other_user)
- CommonAPI.delete(activity.id, user)
-
- result = ActivityView.render("activity.json", activity: like)
-
- expected = %{
- "activity_type" => "like",
- "created_at" => like.data["published"] |> Utils.date_to_asctime(),
- "external_url" => like.data["id"],
- "id" => like.id,
- "in_reply_to_status_id" => nil,
- "is_local" => true,
- "is_post_verb" => false,
- "favorited_status" => nil,
- "statusnet_html" => "shp favorited a status.",
- "text" => "shp favorited a status.",
- "uri" => "tag:#{like.data["id"]}:objectType=Favourite",
- "user" => UserView.render("show.json", user: other_user)
- }
-
- assert result == expected
- end
-
- test "an announce activity" do
- user = insert(:user)
- other_user = insert(:user, %{nickname: "shp"})
-
- {:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!"})
- {:ok, announce, object} = CommonAPI.repeat(activity.id, other_user)
-
- convo_id = Utils.context_to_conversation_id(object.data["context"])
-
- activity = Activity.get_by_id(activity.id)
-
- result = ActivityView.render("activity.json", activity: announce)
-
- expected = %{
- "activity_type" => "repeat",
- "created_at" => announce.data["published"] |> Utils.date_to_asctime(),
- "external_url" => announce.data["id"],
- "id" => announce.id,
- "is_local" => true,
- "is_post_verb" => false,
- "statusnet_html" => "shp repeated a status.",
- "text" => "shp repeated a status.",
- "uri" => "tag:#{announce.data["id"]}:objectType=note",
- "user" => UserView.render("show.json", user: other_user),
- "retweeted_status" => ActivityView.render("activity.json", activity: activity),
- "statusnet_conversation_id" => convo_id
- }
-
- assert result == expected
- end
-
- test "A follow activity" do
- user = insert(:user)
- other_user = insert(:user, %{nickname: "shp"})
-
- {:ok, follower} = User.follow(user, other_user)
- {:ok, follow} = ActivityPub.follow(follower, other_user)
-
- result = ActivityView.render("activity.json", activity: follow)
-
- expected = %{
- "activity_type" => "follow",
- "attentions" => [],
- "created_at" => follow.data["published"] |> Utils.date_to_asctime(),
- "external_url" => follow.data["id"],
- "id" => follow.id,
- "in_reply_to_status_id" => nil,
- "is_local" => true,
- "is_post_verb" => false,
- "statusnet_html" => "#{user.nickname} started following shp",
- "text" => "#{user.nickname} started following shp",
- "user" => UserView.render("show.json", user: user)
- }
-
- assert result == expected
- end
-
- test "a delete activity" do
- user = insert(:user)
-
- {:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!"})
- {:ok, delete} = CommonAPI.delete(activity.id, user)
-
- result = ActivityView.render("activity.json", activity: delete)
-
- expected = %{
- "activity_type" => "delete",
- "attentions" => [],
- "created_at" => delete.data["published"] |> Utils.date_to_asctime(),
- "external_url" => delete.data["id"],
- "id" => delete.id,
- "in_reply_to_status_id" => nil,
- "is_local" => true,
- "is_post_verb" => false,
- "statusnet_html" => "deleted notice {{tag",
- "text" => "deleted notice {{tag",
- "uri" => Object.normalize(delete).data["id"],
- "user" => UserView.render("show.json", user: user)
- }
-
- assert result == expected
- end
-
- test "a peertube video" do
- {:ok, object} =
- Pleroma.Object.Fetcher.fetch_object_from_id(
- "https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"
- )
-
- %Activity{} = activity = Activity.get_create_by_object_ap_id(object.data["id"])
-
- result = ActivityView.render("activity.json", activity: activity)
-
- assert length(result["attachments"]) == 1
- assert result["summary"] == "Friday Night"
- end
-
- test "special characters are not escaped in text field for status created" do
- text = "<3 is on the way"
-
- {:ok, activity} = CommonAPI.post(insert(:user), %{"status" => text})
-
- result = ActivityView.render("activity.json", activity: activity)
-
- assert result["text"] == text
- end
-end
+++ /dev/null
-# Pleroma: A lightweight social networking server
-# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
-# SPDX-License-Identifier: AGPL-3.0-only
-
-defmodule Pleroma.Web.TwitterAPI.NotificationViewTest do
- use Pleroma.DataCase
-
- alias Pleroma.Notification
- alias Pleroma.User
- alias Pleroma.Web.ActivityPub.ActivityPub
- alias Pleroma.Web.CommonAPI.Utils
- alias Pleroma.Web.TwitterAPI.ActivityView
- alias Pleroma.Web.TwitterAPI.NotificationView
- alias Pleroma.Web.TwitterAPI.TwitterAPI
- alias Pleroma.Web.TwitterAPI.UserView
-
- import Pleroma.Factory
-
- setup do
- user = insert(:user, bio: "<span>Here's some html</span>")
- [user: user]
- end
-
- test "A follow notification" do
- note_activity = insert(:note_activity)
- user = User.get_cached_by_ap_id(note_activity.data["actor"])
- follower = insert(:user)
-
- {:ok, follower} = User.follow(follower, user)
- {:ok, activity} = ActivityPub.follow(follower, user)
- Cachex.put(:user_cache, "user_info:#{user.id}", User.user_info(Repo.get!(User, user.id)))
- [follow_notif] = Notification.for_user(user)
-
- represented = %{
- "created_at" => follow_notif.inserted_at |> Utils.format_naive_asctime(),
- "from_profile" => UserView.render("show.json", %{user: follower, for: user}),
- "id" => follow_notif.id,
- "is_seen" => 0,
- "notice" => ActivityView.render("activity.json", %{activity: activity, for: user}),
- "ntype" => "follow"
- }
-
- assert represented ==
- NotificationView.render("notification.json", %{notification: follow_notif, for: user})
- end
-
- test "A mention notification" do
- user = insert(:user)
- other_user = insert(:user)
-
- {:ok, activity} =
- TwitterAPI.create_status(other_user, %{"status" => "Päivää, @#{user.nickname}"})
-
- [notification] = Notification.for_user(user)
-
- represented = %{
- "created_at" => notification.inserted_at |> Utils.format_naive_asctime(),
- "from_profile" => UserView.render("show.json", %{user: other_user, for: user}),
- "id" => notification.id,
- "is_seen" => 0,
- "notice" => ActivityView.render("activity.json", %{activity: activity, for: user}),
- "ntype" => "mention"
- }
-
- assert represented ==
- NotificationView.render("notification.json", %{notification: notification, for: user})
- end
-
- test "A retweet notification" do
- note_activity = insert(:note_activity)
- user = User.get_cached_by_ap_id(note_activity.data["actor"])
- repeater = insert(:user)
-
- {:ok, _activity} = TwitterAPI.repeat(repeater, note_activity.id)
- [notification] = Notification.for_user(user)
-
- represented = %{
- "created_at" => notification.inserted_at |> Utils.format_naive_asctime(),
- "from_profile" => UserView.render("show.json", %{user: repeater, for: user}),
- "id" => notification.id,
- "is_seen" => 0,
- "notice" =>
- ActivityView.render("activity.json", %{activity: notification.activity, for: user}),
- "ntype" => "repeat"
- }
-
- assert represented ==
- NotificationView.render("notification.json", %{notification: notification, for: user})
- end
-
- test "A like notification" do
- note_activity = insert(:note_activity)
- user = User.get_cached_by_ap_id(note_activity.data["actor"])
- liker = insert(:user)
-
- {:ok, _activity} = TwitterAPI.fav(liker, note_activity.id)
- [notification] = Notification.for_user(user)
-
- represented = %{
- "created_at" => notification.inserted_at |> Utils.format_naive_asctime(),
- "from_profile" => UserView.render("show.json", %{user: liker, for: user}),
- "id" => notification.id,
- "is_seen" => 0,
- "notice" =>
- ActivityView.render("activity.json", %{activity: notification.activity, for: user}),
- "ntype" => "like"
- }
-
- assert represented ==
- NotificationView.render("notification.json", %{notification: notification, for: user})
- end
-end
+++ /dev/null
-# Pleroma: A lightweight social networking server
-# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
-# SPDX-License-Identifier: AGPL-3.0-only
-
-defmodule Pleroma.Web.TwitterAPI.UserViewTest do
- use Pleroma.DataCase
-
- alias Pleroma.User
- alias Pleroma.Web.CommonAPI.Utils
- alias Pleroma.Web.TwitterAPI.UserView
-
- import Pleroma.Factory
-
- setup do
- user = insert(:user, bio: "<span>Here's some html</span>")
- [user: user]
- end
-
- test "A user with only a nickname", %{user: user} do
- user = %{user | name: nil, nickname: "scarlett@catgirl.science"}
- represented = UserView.render("show.json", %{user: user})
- assert represented["name"] == user.nickname
- assert represented["name_html"] == user.nickname
- end
-
- test "A user with an avatar object", %{user: user} do
- image = "image"
- user = %{user | avatar: %{"url" => [%{"href" => image}]}}
- represented = UserView.render("show.json", %{user: user})
- assert represented["profile_image_url"] == image
- end
-
- test "A user with emoji in username" do
- expected =
- "<img class=\"emoji\" alt=\"karjalanpiirakka\" title=\"karjalanpiirakka\" src=\"/file.png\" /> man"
-
- user =
- insert(:user, %{
- info: %{
- source_data: %{
- "tag" => [
- %{
- "type" => "Emoji",
- "icon" => %{"url" => "/file.png"},
- "name" => ":karjalanpiirakka:"
- }
- ]
- }
- },
- name: ":karjalanpiirakka: man"
- })
-
- represented = UserView.render("show.json", %{user: user})
- assert represented["name_html"] == expected
- end
-
- test "A user" do
- note_activity = insert(:note_activity)
- user = User.get_cached_by_ap_id(note_activity.data["actor"])
- {:ok, user} = User.update_note_count(user)
- follower = insert(:user)
- second_follower = insert(:user)
-
- User.follow(follower, user)
- User.follow(second_follower, user)
- User.follow(user, follower)
- {:ok, user} = User.update_follower_count(user)
- Cachex.put(:user_cache, "user_info:#{user.id}", User.user_info(Repo.get!(User, user.id)))
-
- image = "http://localhost:4001/images/avi.png"
- banner = "http://localhost:4001/images/banner.png"
-
- represented = %{
- "id" => user.id,
- "name" => user.name,
- "screen_name" => user.nickname,
- "name_html" => user.name,
- "description" => HtmlSanitizeEx.strip_tags(user.bio |> String.replace("<br>", "\n")),
- "description_html" => HtmlSanitizeEx.basic_html(user.bio),
- "created_at" => user.inserted_at |> Utils.format_naive_asctime(),
- "favourites_count" => 0,
- "statuses_count" => 1,
- "friends_count" => 1,
- "followers_count" => 2,
- "profile_image_url" => image,
- "profile_image_url_https" => image,
- "profile_image_url_profile_size" => image,
- "profile_image_url_original" => image,
- "following" => false,
- "follows_you" => false,
- "statusnet_blocking" => false,
- "statusnet_profile_url" => user.ap_id,
- "cover_photo" => banner,
- "background_image" => nil,
- "is_local" => true,
- "locked" => false,
- "hide_follows" => false,
- "hide_followers" => false,
- "fields" => [],
- "pleroma" => %{
- "confirmation_pending" => false,
- "tags" => [],
- "skip_thread_containment" => false
- },
- "rights" => %{"admin" => false, "delete_others_notice" => false},
- "role" => "member"
- }
-
- assert represented == UserView.render("show.json", %{user: user})
- end
-
- test "User exposes settings for themselves and only for themselves", %{user: user} do
- as_user = UserView.render("show.json", %{user: user, for: user})
- assert as_user["default_scope"] == user.info.default_scope
- assert as_user["no_rich_text"] == user.info.no_rich_text
- assert as_user["pleroma"]["notification_settings"] == user.info.notification_settings
- as_stranger = UserView.render("show.json", %{user: user})
- refute as_stranger["default_scope"]
- refute as_stranger["no_rich_text"]
- refute as_stranger["pleroma"]["notification_settings"]
- end
-
- test "A user for a given other follower", %{user: user} do
- follower = insert(:user, %{following: [User.ap_followers(user)]})
- {:ok, user} = User.update_follower_count(user)
- image = "http://localhost:4001/images/avi.png"
- banner = "http://localhost:4001/images/banner.png"
-
- represented = %{
- "id" => user.id,
- "name" => user.name,
- "screen_name" => user.nickname,
- "name_html" => user.name,
- "description" => HtmlSanitizeEx.strip_tags(user.bio |> String.replace("<br>", "\n")),
- "description_html" => HtmlSanitizeEx.basic_html(user.bio),
- "created_at" => user.inserted_at |> Utils.format_naive_asctime(),
- "favourites_count" => 0,
- "statuses_count" => 0,
- "friends_count" => 0,
- "followers_count" => 1,
- "profile_image_url" => image,
- "profile_image_url_https" => image,
- "profile_image_url_profile_size" => image,
- "profile_image_url_original" => image,
- "following" => true,
- "follows_you" => false,
- "statusnet_blocking" => false,
- "statusnet_profile_url" => user.ap_id,
- "cover_photo" => banner,
- "background_image" => nil,
- "is_local" => true,
- "locked" => false,
- "hide_follows" => false,
- "hide_followers" => false,
- "fields" => [],
- "pleroma" => %{
- "confirmation_pending" => false,
- "tags" => [],
- "skip_thread_containment" => false
- },
- "rights" => %{"admin" => false, "delete_others_notice" => false},
- "role" => "member"
- }
-
- assert represented == UserView.render("show.json", %{user: user, for: follower})
- end
-
- test "A user that follows you", %{user: user} do
- follower = insert(:user)
- {:ok, follower} = User.follow(follower, user)
- {:ok, user} = User.update_follower_count(user)
- image = "http://localhost:4001/images/avi.png"
- banner = "http://localhost:4001/images/banner.png"
-
- represented = %{
- "id" => follower.id,
- "name" => follower.name,
- "screen_name" => follower.nickname,
- "name_html" => follower.name,
- "description" => HtmlSanitizeEx.strip_tags(follower.bio |> String.replace("<br>", "\n")),
- "description_html" => HtmlSanitizeEx.basic_html(follower.bio),
- "created_at" => follower.inserted_at |> Utils.format_naive_asctime(),
- "favourites_count" => 0,
- "statuses_count" => 0,
- "friends_count" => 1,
- "followers_count" => 0,
- "profile_image_url" => image,
- "profile_image_url_https" => image,
- "profile_image_url_profile_size" => image,
- "profile_image_url_original" => image,
- "following" => false,
- "follows_you" => true,
- "statusnet_blocking" => false,
- "statusnet_profile_url" => follower.ap_id,
- "cover_photo" => banner,
- "background_image" => nil,
- "is_local" => true,
- "locked" => false,
- "hide_follows" => false,
- "hide_followers" => false,
- "fields" => [],
- "pleroma" => %{
- "confirmation_pending" => false,
- "tags" => [],
- "skip_thread_containment" => false
- },
- "rights" => %{"admin" => false, "delete_others_notice" => false},
- "role" => "member"
- }
-
- assert represented == UserView.render("show.json", %{user: follower, for: user})
- end
-
- test "a user that is a moderator" do
- user = insert(:user, %{info: %{is_moderator: true}})
- represented = UserView.render("show.json", %{user: user, for: user})
-
- assert represented["rights"]["delete_others_notice"]
- assert represented["role"] == "moderator"
- end
-
- test "a user that is a admin" do
- user = insert(:user, %{info: %{is_admin: true}})
- represented = UserView.render("show.json", %{user: user, for: user})
-
- assert represented["rights"]["admin"]
- assert represented["role"] == "admin"
- end
-
- test "A moderator with hidden role for another user", %{user: user} do
- admin = insert(:user, %{info: %{is_moderator: true, show_role: false}})
- represented = UserView.render("show.json", %{user: admin, for: user})
-
- assert represented["role"] == nil
- end
-
- test "An admin with hidden role for another user", %{user: user} do
- admin = insert(:user, %{info: %{is_admin: true, show_role: false}})
- represented = UserView.render("show.json", %{user: admin, for: user})
-
- assert represented["role"] == nil
- end
-
- test "A regular user for the admin", %{user: user} do
- admin = insert(:user, %{info: %{is_admin: true}})
- represented = UserView.render("show.json", %{user: user, for: admin})
-
- assert represented["pleroma"]["deactivated"] == false
- end
-
- test "A blocked user for the blocker" do
- user = insert(:user)
- blocker = insert(:user)
- User.block(blocker, user)
- image = "http://localhost:4001/images/avi.png"
- banner = "http://localhost:4001/images/banner.png"
-
- represented = %{
- "id" => user.id,
- "name" => user.name,
- "screen_name" => user.nickname,
- "name_html" => user.name,
- "description" => HtmlSanitizeEx.strip_tags(user.bio |> String.replace("<br>", "\n")),
- "description_html" => HtmlSanitizeEx.basic_html(user.bio),
- "created_at" => user.inserted_at |> Utils.format_naive_asctime(),
- "favourites_count" => 0,
- "statuses_count" => 0,
- "friends_count" => 0,
- "followers_count" => 0,
- "profile_image_url" => image,
- "profile_image_url_https" => image,
- "profile_image_url_profile_size" => image,
- "profile_image_url_original" => image,
- "following" => false,
- "follows_you" => false,
- "statusnet_blocking" => true,
- "statusnet_profile_url" => user.ap_id,
- "cover_photo" => banner,
- "background_image" => nil,
- "is_local" => true,
- "locked" => false,
- "hide_follows" => false,
- "hide_followers" => false,
- "fields" => [],
- "pleroma" => %{
- "confirmation_pending" => false,
- "tags" => [],
- "skip_thread_containment" => false
- },
- "rights" => %{"admin" => false, "delete_others_notice" => false},
- "role" => "member"
- }
-
- blocker = User.get_cached_by_id(blocker.id)
- assert represented == UserView.render("show.json", %{user: user, for: blocker})
- end
-
- test "a user with mastodon fields" do
- fields = [
- %{
- "name" => "Pronouns",
- "value" => "she/her"
- },
- %{
- "name" => "Website",
- "value" => "https://example.org/"
- }
- ]
-
- user =
- insert(:user, %{
- info: %{
- source_data: %{
- "attachment" =>
- Enum.map(fields, fn field -> Map.put(field, "type", "PropertyValue") end)
- }
- }
- })
-
- userview = UserView.render("show.json", %{user: user})
- assert userview["fields"] == fields
- end
-end
projects / akkoma / commitdiff