git.squeep.com Git - akkoma/blob - lib/pleroma/web/api_spec/operations/twitter_util_operation.ex

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.ApiSpec.TwitterUtilOperation do
   6   alias OpenApiSpex.Operation
   7   alias OpenApiSpex.Schema
   8   alias Pleroma.Web.ApiSpec.Schemas.ApiError
   9   alias Pleroma.Web.ApiSpec.Schemas.BooleanLike
  10
  11   import Pleroma.Web.ApiSpec.Helpers
  12
  13   def open_api_operation(action) do
  14     operation = String.to_existing_atom("#{action}_operation")
  15     apply(__MODULE__, operation, [])
  16   end
  17
  18   def emoji_operation do
  19     %Operation{
  20       tags: ["Emojis"],
  21       summary: "List all custom emojis",
  22       operationId: "UtilController.emoji",
  23       parameters: [],
  24       responses: %{
  25         200 =>
  26           Operation.response("List", "application/json", %Schema{
  27             type: :object,
  28             additionalProperties: %Schema{
  29               type: :object,
  30               properties: %{
  31                 image_url: %Schema{type: :string},
  32                 tags: %Schema{type: :array, items: %Schema{type: :string}}
  33               }
  34             },
  35             example: %{
  36               "firefox" => %{
  37                 "image_url" => "/emoji/firefox.png",
  38                 "tag" => ["Fun"]
  39               }
  40             }
  41           })
  42       }
  43     }
  44   end
  45
  46   def frontend_configurations_operation do
  47     %Operation{
  48       tags: ["Configuration"],
  49       summary: "Dump frontend configurations",
  50       operationId: "UtilController.frontend_configurations",
  51       parameters: [],
  52       responses: %{
  53         200 =>
  54           Operation.response("List", "application/json", %Schema{
  55             type: :object,
  56             additionalProperties: %Schema{type: :object}
  57           })
  58       }
  59     }
  60   end
  61
  62   def change_password_operation do
  63     %Operation{
  64       tags: ["Account credentials"],
  65       summary: "Change account password",
  66       security: [%{"oAuth" => ["write:accounts"]}],
  67       operationId: "UtilController.change_password",
  68       requestBody: request_body("Parameters", change_password_request(), required: true),
  69       responses: %{
  70         200 =>
  71           Operation.response("Success", "application/json", %Schema{
  72             type: :object,
  73             properties: %{status: %Schema{type: :string, example: "success"}}
  74           }),
  75         400 => Operation.response("Error", "application/json", ApiError),
  76         403 => Operation.response("Error", "application/json", ApiError)
  77       }
  78     }
  79   end
  80
  81   defp change_password_request do
  82     %Schema{
  83       title: "ChangePasswordRequest",
  84       description: "POST body for changing the account's passowrd",
  85       type: :object,
  86       required: [:password, :new_password, :new_password_confirmation],
  87       properties: %{
  88         password: %Schema{type: :string, description: "Current password"},
  89         new_password: %Schema{type: :string, description: "New password"},
  90         new_password_confirmation: %Schema{
  91           type: :string,
  92           description: "New password, confirmation"
  93         }
  94       }
  95     }
  96   end
  97
  98   def change_email_operation do
  99     %Operation{
 100       tags: ["Account credentials"],
 101       summary: "Change account email",
 102       security: [%{"oAuth" => ["write:accounts"]}],
 103       operationId: "UtilController.change_email",
 104       requestBody: request_body("Parameters", change_email_request(), required: true),
 105       responses: %{
 106         200 =>
 107           Operation.response("Success", "application/json", %Schema{
 108             type: :object,
 109             properties: %{status: %Schema{type: :string, example: "success"}}
 110           }),
 111         400 => Operation.response("Error", "application/json", ApiError),
 112         403 => Operation.response("Error", "application/json", ApiError)
 113       }
 114     }
 115   end
 116
 117   defp change_email_request do
 118     %Schema{
 119       title: "ChangeEmailRequest",
 120       description: "POST body for changing the account's email",
 121       type: :object,
 122       required: [:email, :password],
 123       properties: %{
 124         email: %Schema{type: :string, description: "New email"},
 125         password: %Schema{type: :string, description: "Current password"}
 126       }
 127     }
 128   end
 129
 130   def update_notificaton_settings_operation do
 131     %Operation{
 132       tags: ["Accounts"],
 133       summary: "Update Notification Settings",
 134       security: [%{"oAuth" => ["write:accounts"]}],
 135       operationId: "UtilController.update_notificaton_settings",
 136       parameters: [
 137         Operation.parameter(
 138           :block_from_strangers,
 139           :query,
 140           BooleanLike,
 141           "blocks notifications from accounts you do not follow"
 142         ),
 143         Operation.parameter(
 144           :hide_notification_contents,
 145           :query,
 146           BooleanLike,
 147           "removes the contents of a message from the push notification"
 148         )
 149       ],
 150       requestBody: nil,
 151       responses: %{
 152         200 =>
 153           Operation.response("Success", "application/json", %Schema{
 154             type: :object,
 155             properties: %{status: %Schema{type: :string, example: "success"}}
 156           }),
 157         400 => Operation.response("Error", "application/json", ApiError)
 158       }
 159     }
 160   end
 161
 162   def disable_account_operation do
 163     %Operation{
 164       tags: ["Account credentials"],
 165       summary: "Disable Account",
 166       security: [%{"oAuth" => ["write:accounts"]}],
 167       operationId: "UtilController.disable_account",
 168       parameters: [
 169         Operation.parameter(:password, :query, :string, "Password")
 170       ],
 171       responses: %{
 172         200 =>
 173           Operation.response("Success", "application/json", %Schema{
 174             type: :object,
 175             properties: %{status: %Schema{type: :string, example: "success"}}
 176           }),
 177         403 => Operation.response("Error", "application/json", ApiError)
 178       }
 179     }
 180   end
 181
 182   def delete_account_operation do
 183     %Operation{
 184       tags: ["Account credentials"],
 185       summary: "Delete Account",
 186       security: [%{"oAuth" => ["write:accounts"]}],
 187       operationId: "UtilController.delete_account",
 188       parameters: [
 189         Operation.parameter(:password, :query, :string, "Password")
 190       ],
 191       responses: %{
 192         200 =>
 193           Operation.response("Success", "application/json", %Schema{
 194             type: :object,
 195             properties: %{status: %Schema{type: :string, example: "success"}}
 196           }),
 197         403 => Operation.response("Error", "application/json", ApiError)
 198       }
 199     }
 200   end
 201
 202   def captcha_operation do
 203     %Operation{
 204       summary: "Get a captcha",
 205       operationId: "UtilController.captcha",
 206       parameters: [],
 207       responses: %{
 208         200 => Operation.response("Success", "application/json", %Schema{type: :object})
 209       }
 210     }
 211   end
 212
 213   def healthcheck_operation do
 214     %Operation{
 215       tags: ["Accounts"],
 216       summary: "Quick status check on the instance",
 217       security: [%{"oAuth" => ["write:accounts"]}],
 218       operationId: "UtilController.healthcheck",
 219       parameters: [],
 220       responses: %{
 221         200 => Operation.response("Healthy", "application/json", %Schema{type: :object}),
 222         503 =>
 223           Operation.response("Disabled or Unhealthy", "application/json", %Schema{type: :object})
 224       }
 225     }
 226   end
 227
 228   def remote_subscribe_operation do
 229     %Operation{
 230       tags: ["Accounts"],
 231       summary: "Remote Subscribe",
 232       operationId: "UtilController.remote_subscribe",
 233       parameters: [],
 234       responses: %{200 => Operation.response("Web Page", "test/html", %Schema{type: :string})}
 235     }
 236   end
 237 end