1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
5 defmodule Pleroma.Web.AdminAPI.AdminAPIController do
6 use Pleroma.Web, :controller
8 import Pleroma.Web.ControllerHelper, only: [json_response: 3]
10 alias Pleroma.Activity
12 alias Pleroma.ConfigDB
13 alias Pleroma.ModerationLog
14 alias Pleroma.Plugs.OAuthScopesPlug
15 alias Pleroma.ReportNote
18 alias Pleroma.UserInviteToken
19 alias Pleroma.Web.ActivityPub.ActivityPub
20 alias Pleroma.Web.ActivityPub.Builder
21 alias Pleroma.Web.ActivityPub.Pipeline
22 alias Pleroma.Web.ActivityPub.Relay
23 alias Pleroma.Web.ActivityPub.Utils
24 alias Pleroma.Web.AdminAPI.AccountView
25 alias Pleroma.Web.AdminAPI.ConfigView
26 alias Pleroma.Web.AdminAPI.ModerationLogView
27 alias Pleroma.Web.AdminAPI.Report
28 alias Pleroma.Web.AdminAPI.ReportView
29 alias Pleroma.Web.AdminAPI.Search
30 alias Pleroma.Web.CommonAPI
31 alias Pleroma.Web.Endpoint
32 alias Pleroma.Web.MastodonAPI.AppView
33 alias Pleroma.Web.MastodonAPI.StatusView
34 alias Pleroma.Web.OAuth.App
35 alias Pleroma.Web.Router
39 @descriptions_json Pleroma.Docs.JSON.compile()
44 %{scopes: ["read:accounts"], admin: true}
45 when action in [:list_users, :user_show, :right_get, :show_user_credentials]
50 %{scopes: ["write:accounts"], admin: true}
53 :force_password_reset,
56 :user_toggle_activation,
64 :right_delete_multiple,
65 :update_user_credentials
69 plug(OAuthScopesPlug, %{scopes: ["read:invites"], admin: true} when action == :invites)
73 %{scopes: ["write:invites"], admin: true}
74 when action in [:create_invite_token, :revoke_invite, :email_invite]
79 %{scopes: ["write:follows"], admin: true}
80 when action in [:user_follow, :user_unfollow, :relay_follow, :relay_unfollow]
85 %{scopes: ["read:reports"], admin: true}
86 when action in [:list_reports, :report_show]
91 %{scopes: ["write:reports"], admin: true}
92 when action in [:reports_update, :report_notes_create, :report_notes_delete]
97 %{scopes: ["read:statuses"], admin: true}
98 when action in [:list_statuses, :list_user_statuses, :list_instance_statuses, :status_show]
103 %{scopes: ["write:statuses"], admin: true}
104 when action in [:status_update, :status_delete]
109 %{scopes: ["read"], admin: true}
115 :config_descriptions,
122 %{scopes: ["write"], admin: true}
126 :resend_confirmation_email,
136 action_fallback(:errors)
138 def user_delete(conn, %{"nickname" => nickname}) do
139 user_delete(conn, %{"nicknames" => [nickname]})
142 def user_delete(%{assigns: %{user: admin}} = conn, %{"nicknames" => nicknames}) do
145 |> Enum.map(&User.get_cached_by_nickname/1)
148 |> Enum.each(fn user ->
149 {:ok, delete_data, _} = Builder.delete(admin, user.ap_id)
150 Pipeline.common_pipeline(delete_data, local: true)
153 ModerationLog.insert_log(%{
163 def user_follow(%{assigns: %{user: admin}} = conn, %{
164 "follower" => follower_nick,
165 "followed" => followed_nick
167 with %User{} = follower <- User.get_cached_by_nickname(follower_nick),
168 %User{} = followed <- User.get_cached_by_nickname(followed_nick) do
169 User.follow(follower, followed)
171 ModerationLog.insert_log(%{
183 def user_unfollow(%{assigns: %{user: admin}} = conn, %{
184 "follower" => follower_nick,
185 "followed" => followed_nick
187 with %User{} = follower <- User.get_cached_by_nickname(follower_nick),
188 %User{} = followed <- User.get_cached_by_nickname(followed_nick) do
189 User.unfollow(follower, followed)
191 ModerationLog.insert_log(%{
203 def users_create(%{assigns: %{user: admin}} = conn, %{"users" => users}) do
205 Enum.map(users, fn %{"nickname" => nickname, "email" => email, "password" => password} ->
211 password_confirmation: password,
215 User.register_changeset(%User{}, user_data, need_confirmation: false)
217 |> Enum.reduce(Ecto.Multi.new(), fn changeset, multi ->
218 Ecto.Multi.insert(multi, Ecto.UUID.generate(), changeset)
221 case Pleroma.Repo.transaction(changesets) do
226 |> Enum.map(fn user ->
227 {:ok, user} = User.post_register_action(user)
231 |> Enum.map(&AccountView.render("created.json", %{user: &1}))
233 ModerationLog.insert_log(%{
235 subjects: Map.values(users),
242 {:error, id, changeset, _} ->
244 Enum.map(changesets.operations, fn
245 {current_id, {:changeset, _current_changeset, _}} when current_id == id ->
246 AccountView.render("create-error.json", %{changeset: changeset})
248 {_, {:changeset, current_changeset, _}} ->
249 AccountView.render("create-error.json", %{changeset: current_changeset})
253 |> put_status(:conflict)
258 def user_show(conn, %{"nickname" => nickname}) do
259 with %User{} = user <- User.get_cached_by_nickname_or_id(nickname) do
261 |> put_view(AccountView)
262 |> render("show.json", %{user: user})
264 _ -> {:error, :not_found}
268 def list_instance_statuses(conn, %{"instance" => instance} = params) do
269 with_reblogs = params["with_reblogs"] == "true" || params["with_reblogs"] == true
270 {page, page_size} = page_params(params)
273 ActivityPub.fetch_statuses(nil, %{
274 "instance" => instance,
275 "limit" => page_size,
276 "offset" => (page - 1) * page_size,
277 "exclude_reblogs" => !with_reblogs && "true"
281 |> put_view(Pleroma.Web.AdminAPI.StatusView)
282 |> render("index.json", %{activities: activities, as: :activity, skip_relationships: false})
285 def list_user_statuses(conn, %{"nickname" => nickname} = params) do
286 with_reblogs = params["with_reblogs"] == "true" || params["with_reblogs"] == true
287 godmode = params["godmode"] == "true" || params["godmode"] == true
289 with %User{} = user <- User.get_cached_by_nickname_or_id(nickname) do
290 {_, page_size} = page_params(params)
293 ActivityPub.fetch_user_activities(user, nil, %{
294 "limit" => page_size,
295 "godmode" => godmode,
296 "exclude_reblogs" => !with_reblogs && "true"
300 |> put_view(StatusView)
301 |> render("index.json", %{activities: activities, as: :activity, skip_relationships: false})
303 _ -> {:error, :not_found}
307 def user_toggle_activation(%{assigns: %{user: admin}} = conn, %{"nickname" => nickname}) do
308 user = User.get_cached_by_nickname(nickname)
310 {:ok, updated_user} = User.deactivate(user, !user.deactivated)
312 action = if user.deactivated, do: "activate", else: "deactivate"
314 ModerationLog.insert_log(%{
321 |> put_view(AccountView)
322 |> render("show.json", %{user: updated_user})
325 def user_activate(%{assigns: %{user: admin}} = conn, %{"nicknames" => nicknames}) do
326 users = Enum.map(nicknames, &User.get_cached_by_nickname/1)
327 {:ok, updated_users} = User.deactivate(users, false)
329 ModerationLog.insert_log(%{
336 |> put_view(AccountView)
337 |> render("index.json", %{users: Keyword.values(updated_users)})
340 def user_deactivate(%{assigns: %{user: admin}} = conn, %{"nicknames" => nicknames}) do
341 users = Enum.map(nicknames, &User.get_cached_by_nickname/1)
342 {:ok, updated_users} = User.deactivate(users, true)
344 ModerationLog.insert_log(%{
351 |> put_view(AccountView)
352 |> render("index.json", %{users: Keyword.values(updated_users)})
355 def tag_users(%{assigns: %{user: admin}} = conn, %{"nicknames" => nicknames, "tags" => tags}) do
356 with {:ok, _} <- User.tag(nicknames, tags) do
357 ModerationLog.insert_log(%{
359 nicknames: nicknames,
364 json_response(conn, :no_content, "")
368 def untag_users(%{assigns: %{user: admin}} = conn, %{"nicknames" => nicknames, "tags" => tags}) do
369 with {:ok, _} <- User.untag(nicknames, tags) do
370 ModerationLog.insert_log(%{
372 nicknames: nicknames,
377 json_response(conn, :no_content, "")
381 def list_users(conn, params) do
382 {page, page_size} = page_params(params)
383 filters = maybe_parse_filters(params["filters"])
386 query: params["query"],
388 page_size: page_size,
389 tags: params["tags"],
390 name: params["name"],
391 email: params["email"]
394 with {:ok, users, count} <- Search.user(Map.merge(search_params, filters)) do
397 AccountView.render("index.json", users: users, count: count, page_size: page_size)
402 @filters ~w(local external active deactivated is_admin is_moderator)
404 @spec maybe_parse_filters(String.t()) :: %{required(String.t()) => true} | %{}
405 defp maybe_parse_filters(filters) when is_nil(filters) or filters == "", do: %{}
407 defp maybe_parse_filters(filters) do
410 |> Enum.filter(&Enum.member?(@filters, &1))
411 |> Enum.map(&String.to_atom(&1))
412 |> Enum.into(%{}, &{&1, true})
415 def right_add_multiple(%{assigns: %{user: admin}} = conn, %{
416 "permission_group" => permission_group,
417 "nicknames" => nicknames
419 when permission_group in ["moderator", "admin"] do
420 update = %{:"is_#{permission_group}" => true}
422 users = nicknames |> Enum.map(&User.get_cached_by_nickname/1)
424 for u <- users, do: User.admin_api_update(u, update)
426 ModerationLog.insert_log(%{
430 permission: permission_group
436 def right_add_multiple(conn, _) do
437 render_error(conn, :not_found, "No such permission_group")
440 def right_add(%{assigns: %{user: admin}} = conn, %{
441 "permission_group" => permission_group,
442 "nickname" => nickname
444 when permission_group in ["moderator", "admin"] do
445 fields = %{:"is_#{permission_group}" => true}
449 |> User.get_cached_by_nickname()
450 |> User.admin_api_update(fields)
452 ModerationLog.insert_log(%{
456 permission: permission_group
462 def right_add(conn, _) do
463 render_error(conn, :not_found, "No such permission_group")
466 def right_get(conn, %{"nickname" => nickname}) do
467 user = User.get_cached_by_nickname(nickname)
471 is_moderator: user.is_moderator,
472 is_admin: user.is_admin
476 def right_delete_multiple(
477 %{assigns: %{user: %{nickname: admin_nickname} = admin}} = conn,
479 "permission_group" => permission_group,
480 "nicknames" => nicknames
483 when permission_group in ["moderator", "admin"] do
484 with false <- Enum.member?(nicknames, admin_nickname) do
485 update = %{:"is_#{permission_group}" => false}
487 users = nicknames |> Enum.map(&User.get_cached_by_nickname/1)
489 for u <- users, do: User.admin_api_update(u, update)
491 ModerationLog.insert_log(%{
495 permission: permission_group
500 _ -> render_error(conn, :forbidden, "You can't revoke your own admin/moderator status.")
504 def right_delete_multiple(conn, _) do
505 render_error(conn, :not_found, "No such permission_group")
509 %{assigns: %{user: admin}} = conn,
511 "permission_group" => permission_group,
512 "nickname" => nickname
515 when permission_group in ["moderator", "admin"] do
516 fields = %{:"is_#{permission_group}" => false}
520 |> User.get_cached_by_nickname()
521 |> User.admin_api_update(fields)
523 ModerationLog.insert_log(%{
527 permission: permission_group
533 def right_delete(%{assigns: %{user: %{nickname: nickname}}} = conn, %{"nickname" => nickname}) do
534 render_error(conn, :forbidden, "You can't revoke your own admin status.")
537 def relay_list(conn, _params) do
538 with {:ok, list} <- Relay.list() do
539 json(conn, %{relays: list})
547 def relay_follow(%{assigns: %{user: admin}} = conn, %{"relay_url" => target}) do
548 with {:ok, _message} <- Relay.follow(target) do
549 ModerationLog.insert_log(%{
550 action: "relay_follow",
564 def relay_unfollow(%{assigns: %{user: admin}} = conn, %{"relay_url" => target}) do
565 with {:ok, _message} <- Relay.unfollow(target) do
566 ModerationLog.insert_log(%{
567 action: "relay_unfollow",
581 @doc "Sends registration invite via email"
582 def email_invite(%{assigns: %{user: user}} = conn, %{"email" => email} = params) do
583 with {_, false} <- {:registrations_open, Config.get([:instance, :registrations_open])},
584 {_, true} <- {:invites_enabled, Config.get([:instance, :invites_enabled])},
585 {:ok, invite_token} <- UserInviteToken.create_invite(),
587 Pleroma.Emails.UserEmail.user_invitation_email(
593 {:ok, _} <- Pleroma.Emails.Mailer.deliver(email) do
594 json_response(conn, :no_content, "")
596 {:registrations_open, _} ->
599 {:error, "To send invites you need to set the `registrations_open` option to false."}
602 {:invites_enabled, _} ->
605 {:error, "To send invites you need to set the `invites_enabled` option to true."}
610 @doc "Create an account registration invite token"
611 def create_invite_token(conn, params) do
615 if params["max_use"],
616 do: Map.put(opts, :max_use, params["max_use"]),
620 if params["expires_at"],
621 do: Map.put(opts, :expires_at, params["expires_at"]),
624 {:ok, invite} = UserInviteToken.create_invite(opts)
626 json(conn, AccountView.render("invite.json", %{invite: invite}))
629 @doc "Get list of created invites"
630 def invites(conn, _params) do
631 invites = UserInviteToken.list_invites()
634 |> put_view(AccountView)
635 |> render("invites.json", %{invites: invites})
638 @doc "Revokes invite by token"
639 def revoke_invite(conn, %{"token" => token}) do
640 with {:ok, invite} <- UserInviteToken.find_by_token(token),
641 {:ok, updated_invite} = UserInviteToken.update_invite(invite, %{used: true}) do
643 |> put_view(AccountView)
644 |> render("invite.json", %{invite: updated_invite})
646 nil -> {:error, :not_found}
650 @doc "Get a password reset token (base64 string) for given nickname"
651 def get_password_reset(conn, %{"nickname" => nickname}) do
652 (%User{local: true} = user) = User.get_cached_by_nickname(nickname)
653 {:ok, token} = Pleroma.PasswordResetToken.create_token(user)
658 link: Router.Helpers.reset_password_url(Endpoint, :reset, token.token)
662 @doc "Force password reset for a given user"
663 def force_password_reset(%{assigns: %{user: admin}} = conn, %{"nicknames" => nicknames}) do
664 users = nicknames |> Enum.map(&User.get_cached_by_nickname/1)
666 Enum.each(users, &User.force_password_reset_async/1)
668 ModerationLog.insert_log(%{
671 action: "force_password_reset"
674 json_response(conn, :no_content, "")
677 @doc "Show a given user's credentials"
678 def show_user_credentials(%{assigns: %{user: admin}} = conn, %{"nickname" => nickname}) do
679 with %User{} = user <- User.get_cached_by_nickname_or_id(nickname) do
681 |> put_view(AccountView)
682 |> render("credentials.json", %{user: user, for: admin})
684 _ -> {:error, :not_found}
688 @doc "Updates a given user"
689 def update_user_credentials(
690 %{assigns: %{user: admin}} = conn,
691 %{"nickname" => nickname} = params
693 with {_, user} <- {:user, User.get_cached_by_nickname(nickname)},
695 User.update_as_admin(user, params) do
696 ModerationLog.insert_log(%{
699 action: "updated_users"
702 if params["password"] do
703 User.force_password_reset_async(user)
706 ModerationLog.insert_log(%{
709 action: "force_password_reset"
712 json(conn, %{status: "success"})
714 {:error, changeset} ->
715 {_, {error, _}} = Enum.at(changeset.errors, 0)
716 json(conn, %{error: "New password #{error}."})
719 json(conn, %{error: "Unable to change password."})
723 def list_reports(conn, params) do
724 {page, page_size} = page_params(params)
726 reports = Utils.get_reports(params, page, page_size)
729 |> put_view(ReportView)
730 |> render("index.json", %{reports: reports})
733 def report_show(conn, %{"id" => id}) do
734 with %Activity{} = report <- Activity.get_by_id(id) do
736 |> put_view(ReportView)
737 |> render("show.json", Report.extract_report_info(report))
739 _ -> {:error, :not_found}
743 def reports_update(%{assigns: %{user: admin}} = conn, %{"reports" => reports}) do
746 |> Enum.map(fn report ->
747 with {:ok, activity} <- CommonAPI.update_report_state(report["id"], report["state"]) do
748 ModerationLog.insert_log(%{
749 action: "report_update",
756 {:error, message} -> %{id: report["id"], error: message}
760 case Enum.any?(result, &Map.has_key?(&1, :error)) do
761 true -> json_response(conn, :bad_request, result)
762 false -> json_response(conn, :no_content, "")
766 def report_notes_create(%{assigns: %{user: user}} = conn, %{
770 with {:ok, _} <- ReportNote.create(user.id, report_id, content) do
771 ModerationLog.insert_log(%{
772 action: "report_note",
774 subject: Activity.get_by_id(report_id),
778 json_response(conn, :no_content, "")
780 _ -> json_response(conn, :bad_request, "")
784 def report_notes_delete(%{assigns: %{user: user}} = conn, %{
786 "report_id" => report_id
788 with {:ok, note} <- ReportNote.destroy(note_id) do
789 ModerationLog.insert_log(%{
790 action: "report_note_delete",
792 subject: Activity.get_by_id(report_id),
796 json_response(conn, :no_content, "")
798 _ -> json_response(conn, :bad_request, "")
802 def list_statuses(%{assigns: %{user: _admin}} = conn, params) do
803 godmode = params["godmode"] == "true" || params["godmode"] == true
804 local_only = params["local_only"] == "true" || params["local_only"] == true
805 with_reblogs = params["with_reblogs"] == "true" || params["with_reblogs"] == true
806 {page, page_size} = page_params(params)
809 ActivityPub.fetch_statuses(nil, %{
810 "godmode" => godmode,
811 "local_only" => local_only,
812 "limit" => page_size,
813 "offset" => (page - 1) * page_size,
814 "exclude_reblogs" => !with_reblogs && "true"
818 |> put_view(Pleroma.Web.AdminAPI.StatusView)
819 |> render("index.json", %{activities: activities, as: :activity, skip_relationships: false})
822 def status_show(conn, %{"id" => id}) do
823 with %Activity{} = activity <- Activity.get_by_id(id) do
825 |> put_view(StatusView)
826 |> render("show.json", %{activity: activity})
828 _ -> errors(conn, {:error, :not_found})
832 def status_update(%{assigns: %{user: admin}} = conn, %{"id" => id} = params) do
833 with {:ok, activity} <- CommonAPI.update_activity_scope(id, params) do
834 {:ok, sensitive} = Ecto.Type.cast(:boolean, params["sensitive"])
836 ModerationLog.insert_log(%{
837 action: "status_update",
840 sensitive: sensitive,
841 visibility: params["visibility"]
845 |> put_view(StatusView)
846 |> render("show.json", %{activity: activity})
850 def status_delete(%{assigns: %{user: user}} = conn, %{"id" => id}) do
851 with {:ok, %Activity{}} <- CommonAPI.delete(id, user) do
852 ModerationLog.insert_log(%{
853 action: "status_delete",
862 def list_log(conn, params) do
863 {page, page_size} = page_params(params)
866 ModerationLog.get_all(%{
868 page_size: page_size,
869 start_date: params["start_date"],
870 end_date: params["end_date"],
871 user_id: params["user_id"],
872 search: params["search"]
876 |> put_view(ModerationLogView)
877 |> render("index.json", %{log: log})
880 def config_descriptions(conn, _params) do
882 |> Plug.Conn.put_resp_content_type("application/json")
883 |> Plug.Conn.send_resp(200, @descriptions_json)
886 def config_show(conn, %{"only_db" => true}) do
887 with :ok <- configurable_from_database(conn) do
888 configs = Pleroma.Repo.all(ConfigDB)
891 |> put_view(ConfigView)
892 |> render("index.json", %{configs: configs})
896 def config_show(conn, _params) do
897 with :ok <- configurable_from_database(conn) do
898 configs = ConfigDB.get_all_as_keyword()
901 Config.Holder.default_config()
902 |> ConfigDB.merge(configs)
903 |> Enum.map(fn {group, values} ->
904 Enum.map(values, fn {key, value} ->
906 if configs[group][key] do
907 ConfigDB.get_db_keys(configs[group][key], key)
910 db_value = configs[group][key]
913 if !is_nil(db_value) and Keyword.keyword?(db_value) and
914 ConfigDB.sub_key_full_update?(group, key, Keyword.keys(db_value)) do
915 ConfigDB.merge_group(group, key, value, db_value)
921 group: ConfigDB.convert(group),
922 key: ConfigDB.convert(key),
923 value: ConfigDB.convert(merged_value)
926 if db, do: Map.put(setting, :db, db), else: setting
931 json(conn, %{configs: merged, need_reboot: Restarter.Pleroma.need_reboot?()})
935 def config_update(conn, %{"configs" => configs}) do
936 with :ok <- configurable_from_database(conn) do
939 %{"group" => group, "key" => key, "delete" => true} = params ->
940 ConfigDB.delete(%{group: group, key: key, subkeys: params["subkeys"]})
942 %{"group" => group, "key" => key, "value" => value} ->
943 ConfigDB.update_or_create(%{group: group, key: key, value: value})
945 |> Enum.split_with(fn result -> elem(result, 0) == :error end)
949 |> Enum.map(fn {:ok, config} ->
950 Map.put(config, :db, ConfigDB.get_db_keys(config))
952 |> Enum.split_with(fn config ->
953 Ecto.get_meta(config, :state) == :deleted
956 Config.TransferTask.load_and_update_env(deleted, false)
958 if !Restarter.Pleroma.need_reboot?() do
959 changed_reboot_settings? =
961 |> Enum.any?(fn config ->
962 group = ConfigDB.from_string(config.group)
963 key = ConfigDB.from_string(config.key)
964 value = ConfigDB.from_binary(config.value)
965 Config.TransferTask.pleroma_need_restart?(group, key, value)
968 if changed_reboot_settings?, do: Restarter.Pleroma.need_reboot()
972 |> put_view(ConfigView)
973 |> render("index.json", %{configs: updated, need_reboot: Restarter.Pleroma.need_reboot?()})
977 def restart(conn, _params) do
978 with :ok <- configurable_from_database(conn) do
979 Restarter.Pleroma.restart(Config.get(:env), 50)
985 def need_reboot(conn, _params) do
986 json(conn, %{need_reboot: Restarter.Pleroma.need_reboot?()})
989 defp configurable_from_database(conn) do
990 if Config.get(:configurable_from_database) do
995 {:error, "To use this endpoint you need to enable configuration from database."}
1000 def reload_emoji(conn, _params) do
1001 Pleroma.Emoji.reload()
1006 def confirm_email(%{assigns: %{user: admin}} = conn, %{"nicknames" => nicknames}) do
1007 users = nicknames |> Enum.map(&User.get_cached_by_nickname/1)
1009 User.toggle_confirmation(users)
1011 ModerationLog.insert_log(%{
1014 action: "confirm_email"
1020 def resend_confirmation_email(%{assigns: %{user: admin}} = conn, %{"nicknames" => nicknames}) do
1021 users = nicknames |> Enum.map(&User.get_cached_by_nickname/1)
1023 User.try_send_confirmation_email(users)
1025 ModerationLog.insert_log(%{
1028 action: "resend_confirmation_email"
1034 def oauth_app_create(conn, params) do
1036 if params["name"] do
1037 Map.put(params, "client_name", params["name"])
1043 case App.create(params) do
1045 AppView.render("show.json", %{app: app, admin: true})
1047 {:error, changeset} ->
1048 App.errors(changeset)
1054 def oauth_app_update(conn, params) do
1056 if params["name"] do
1057 Map.put(params, "client_name", params["name"])
1062 with {:ok, app} <- App.update(params) do
1063 json(conn, AppView.render("show.json", %{app: app, admin: true}))
1065 {:error, changeset} ->
1066 json(conn, App.errors(changeset))
1069 json_response(conn, :bad_request, "")
1073 def oauth_app_list(conn, params) do
1074 {page, page_size} = page_params(params)
1077 client_name: params["name"],
1078 client_id: params["client_id"],
1080 page_size: page_size
1084 if Map.has_key?(params, "trusted") do
1085 Map.put(search_params, :trusted, params["trusted"])
1090 with {:ok, apps, count} <- App.search(search_params) do
1093 AppView.render("index.json",
1096 page_size: page_size,
1103 def oauth_app_delete(conn, params) do
1104 with {:ok, _app} <- App.destroy(params["id"]) do
1105 json_response(conn, :no_content, "")
1107 _ -> json_response(conn, :bad_request, "")
1111 def stats(conn, _) do
1112 count = Stats.get_status_visibility_count()
1115 |> json(%{"status_visibility" => count})
1118 defp errors(conn, {:error, :not_found}) do
1120 |> put_status(:not_found)
1121 |> json(dgettext("errors", "Not found"))
1124 defp errors(conn, {:error, reason}) do
1126 |> put_status(:bad_request)
1130 defp errors(conn, {:param_cast, _}) do
1132 |> put_status(:bad_request)
1133 |> json(dgettext("errors", "Invalid parameters"))
1136 defp errors(conn, _) do
1138 |> put_status(:internal_server_error)
1139 |> json(dgettext("errors", "Something went wrong"))
1142 defp page_params(params) do
1143 {get_page(params["page"]), get_page_size(params["page_size"])}
1146 defp get_page(page_string) when is_nil(page_string), do: 1
1148 defp get_page(page_string) do
1149 case Integer.parse(page_string) do
1155 defp get_page_size(page_size_string) when is_nil(page_size_string), do: @users_page_size
1157 defp get_page_size(page_size_string) do
1158 case Integer.parse(page_size_string) do
1159 {page_size, _} -> page_size
1160 :error -> @users_page_size