First
[anni] / lib / pleroma / web / api_spec / operations / twitter_util_operation.ex
1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2022 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{
125           type: :string,
126           description: "New email. Set to blank to remove the user's email."
127         },
128         password: %Schema{type: :string, description: "Current password"}
129       }
130     }
131   end
132
133   def update_notificaton_settings_operation do
134     %Operation{
135       tags: ["Accounts"],
136       summary: "Update Notification Settings",
137       security: [%{"oAuth" => ["write:accounts"]}],
138       operationId: "UtilController.update_notificaton_settings",
139       parameters: [
140         Operation.parameter(
141           :block_from_strangers,
142           :query,
143           BooleanLike,
144           "blocks notifications from accounts you do not follow"
145         ),
146         Operation.parameter(
147           :hide_notification_contents,
148           :query,
149           BooleanLike,
150           "removes the contents of a message from the push notification"
151         )
152       ],
153       requestBody: nil,
154       responses: %{
155         200 =>
156           Operation.response("Success", "application/json", %Schema{
157             type: :object,
158             properties: %{status: %Schema{type: :string, example: "success"}}
159           }),
160         400 => Operation.response("Error", "application/json", ApiError)
161       }
162     }
163   end
164
165   def disable_account_operation do
166     %Operation{
167       tags: ["Account credentials"],
168       summary: "Disable Account",
169       security: [%{"oAuth" => ["write:accounts"]}],
170       operationId: "UtilController.disable_account",
171       parameters: [
172         Operation.parameter(:password, :query, :string, "Password")
173       ],
174       responses: %{
175         200 =>
176           Operation.response("Success", "application/json", %Schema{
177             type: :object,
178             properties: %{status: %Schema{type: :string, example: "success"}}
179           }),
180         403 => Operation.response("Error", "application/json", ApiError)
181       }
182     }
183   end
184
185   def delete_account_operation do
186     %Operation{
187       tags: ["Account credentials"],
188       summary: "Delete Account",
189       security: [%{"oAuth" => ["write:accounts"]}],
190       operationId: "UtilController.delete_account",
191       parameters: [
192         Operation.parameter(:password, :query, :string, "Password")
193       ],
194       requestBody: request_body("Parameters", delete_account_request(), required: false),
195       responses: %{
196         200 =>
197           Operation.response("Success", "application/json", %Schema{
198             type: :object,
199             properties: %{status: %Schema{type: :string, example: "success"}}
200           }),
201         403 => Operation.response("Error", "application/json", ApiError)
202       }
203     }
204   end
205
206   def captcha_operation do
207     %Operation{
208       summary: "Get a captcha",
209       operationId: "UtilController.captcha",
210       parameters: [],
211       responses: %{
212         200 => Operation.response("Success", "application/json", %Schema{type: :object})
213       }
214     }
215   end
216
217   def move_account_operation do
218     %Operation{
219       tags: ["Account credentials"],
220       summary: "Move account",
221       security: [%{"oAuth" => ["write:accounts"]}],
222       operationId: "UtilController.move_account",
223       requestBody: request_body("Parameters", move_account_request(), required: true),
224       responses: %{
225         200 =>
226           Operation.response("Success", "application/json", %Schema{
227             type: :object,
228             properties: %{status: %Schema{type: :string, example: "success"}}
229           }),
230         400 => Operation.response("Error", "application/json", ApiError),
231         403 => Operation.response("Error", "application/json", ApiError),
232         404 => Operation.response("Error", "application/json", ApiError)
233       }
234     }
235   end
236
237   defp move_account_request do
238     %Schema{
239       title: "MoveAccountRequest",
240       description: "POST body for moving the account",
241       type: :object,
242       required: [:password, :target_account],
243       properties: %{
244         password: %Schema{type: :string, description: "Current password"},
245         target_account: %Schema{
246           type: :string,
247           description: "The nickname of the target account to move to"
248         }
249       }
250     }
251   end
252
253   def list_aliases_operation do
254     %Operation{
255       tags: ["Account credentials"],
256       summary: "List account aliases",
257       security: [%{"oAuth" => ["read:accounts"]}],
258       operationId: "UtilController.list_aliases",
259       responses: %{
260         200 =>
261           Operation.response("Success", "application/json", %Schema{
262             type: :object,
263             properties: %{
264               aliases: %Schema{
265                 type: :array,
266                 items: %Schema{type: :string},
267                 example: ["foo@example.org"]
268               }
269             }
270           }),
271         400 => Operation.response("Error", "application/json", ApiError),
272         403 => Operation.response("Error", "application/json", ApiError)
273       }
274     }
275   end
276
277   def add_alias_operation do
278     %Operation{
279       tags: ["Account credentials"],
280       summary: "Add an alias to this account",
281       security: [%{"oAuth" => ["write:accounts"]}],
282       operationId: "UtilController.add_alias",
283       requestBody: request_body("Parameters", add_alias_request(), required: true),
284       responses: %{
285         200 =>
286           Operation.response("Success", "application/json", %Schema{
287             type: :object,
288             properties: %{
289               status: %Schema{
290                 type: :string,
291                 example: "success"
292               }
293             }
294           }),
295         400 => Operation.response("Error", "application/json", ApiError),
296         403 => Operation.response("Error", "application/json", ApiError),
297         404 => Operation.response("Error", "application/json", ApiError)
298       }
299     }
300   end
301
302   defp add_alias_request do
303     %Schema{
304       title: "AddAliasRequest",
305       description: "PUT body for adding aliases",
306       type: :object,
307       required: [:alias],
308       properties: %{
309         alias: %Schema{
310           type: :string,
311           description: "The nickname of the account to add to aliases"
312         }
313       }
314     }
315   end
316
317   def delete_alias_operation do
318     %Operation{
319       tags: ["Account credentials"],
320       summary: "Delete an alias from this account",
321       security: [%{"oAuth" => ["write:accounts"]}],
322       operationId: "UtilController.delete_alias",
323       requestBody: request_body("Parameters", delete_alias_request(), required: true),
324       responses: %{
325         200 =>
326           Operation.response("Success", "application/json", %Schema{
327             type: :object,
328             properties: %{
329               status: %Schema{
330                 type: :string,
331                 example: "success"
332               }
333             }
334           }),
335         400 => Operation.response("Error", "application/json", ApiError),
336         403 => Operation.response("Error", "application/json", ApiError),
337         404 => Operation.response("Error", "application/json", ApiError)
338       }
339     }
340   end
341
342   defp delete_alias_request do
343     %Schema{
344       title: "DeleteAliasRequest",
345       description: "PUT body for deleting aliases",
346       type: :object,
347       required: [:alias],
348       properties: %{
349         alias: %Schema{
350           type: :string,
351           description: "The nickname of the account to delete from aliases"
352         }
353       }
354     }
355   end
356
357   def healthcheck_operation do
358     %Operation{
359       tags: ["Accounts"],
360       summary: "Quick status check on the instance",
361       security: [%{"oAuth" => ["write:accounts"]}],
362       operationId: "UtilController.healthcheck",
363       parameters: [],
364       responses: %{
365         200 => Operation.response("Healthy", "application/json", %Schema{type: :object}),
366         503 =>
367           Operation.response("Disabled or Unhealthy", "application/json", %Schema{type: :object})
368       }
369     }
370   end
371
372   def remote_subscribe_operation do
373     %Operation{
374       tags: ["Accounts"],
375       summary: "Remote Subscribe",
376       operationId: "UtilController.remote_subscribe",
377       parameters: [],
378       responses: %{200 => Operation.response("Web Page", "test/html", %Schema{type: :string})}
379     }
380   end
381
382   def remote_interaction_operation do
383     %Operation{
384       tags: ["Accounts"],
385       summary: "Remote interaction",
386       operationId: "UtilController.remote_interaction",
387       requestBody: request_body("Parameters", remote_interaction_request(), required: true),
388       responses: %{
389         200 =>
390           Operation.response("Remote interaction URL", "application/json", %Schema{type: :object})
391       }
392     }
393   end
394
395   defp remote_interaction_request do
396     %Schema{
397       title: "RemoteInteractionRequest",
398       description: "POST body for remote interaction",
399       type: :object,
400       required: [:ap_id, :profile],
401       properties: %{
402         ap_id: %Schema{type: :string, description: "Profile or status ActivityPub ID"},
403         profile: %Schema{type: :string, description: "Remote profile webfinger"}
404       }
405     }
406   end
407
408   def show_subscribe_form_operation do
409     %Operation{
410       tags: ["Accounts"],
411       summary: "Show remote subscribe form",
412       operationId: "UtilController.show_subscribe_form",
413       parameters: [],
414       responses: %{200 => Operation.response("Web Page", "test/html", %Schema{type: :string})}
415     }
416   end
417
418   defp delete_account_request do
419     %Schema{
420       title: "AccountDeleteRequest",
421       description: "POST body for deleting one's own account",
422       type: :object,
423       properties: %{
424         password: %Schema{
425           type: :string,
426           description: "The user's own password for confirmation.",
427           format: :password
428         }
429       },
430       example: %{
431         "password" => "prettyp0ony1313"
432       }
433     }
434   end
435 end