2018-12-23 21:04:54 +01:00
|
|
|
# Pleroma: A lightweight social networking server
|
2018-12-31 16:41:47 +01:00
|
|
|
# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
|
2018-12-23 21:04:54 +01:00
|
|
|
# SPDX-License-Identifier: AGPL-3.0-only
|
|
|
|
|
2017-09-06 19:06:25 +02:00
|
|
|
defmodule Pleroma.Web.MastodonAPI.MastodonAPIController do
|
|
|
|
use Pleroma.Web, :controller
|
2019-07-28 22:30:10 +02:00
|
|
|
|
2019-09-30 10:47:01 +02:00
|
|
|
import Pleroma.Web.ControllerHelper, only: [add_link_headers: 2]
|
2019-07-28 22:30:10 +02:00
|
|
|
|
2019-04-14 14:45:56 +02:00
|
|
|
alias Pleroma.Bookmark
|
2019-02-09 16:16:26 +01:00
|
|
|
alias Pleroma.Config
|
2019-03-25 23:13:58 +01:00
|
|
|
alias Pleroma.Pagination
|
2019-07-13 13:49:39 +02:00
|
|
|
alias Pleroma.Plugs.RateLimiter
|
2019-02-09 16:16:26 +01:00
|
|
|
alias Pleroma.Repo
|
|
|
|
alias Pleroma.Stats
|
|
|
|
alias Pleroma.User
|
2017-09-07 08:58:10 +02:00
|
|
|
alias Pleroma.Web
|
2019-03-05 03:52:23 +01:00
|
|
|
alias Pleroma.Web.ActivityPub.ActivityPub
|
2018-03-25 17:00:30 +02:00
|
|
|
alias Pleroma.Web.CommonAPI
|
2019-02-09 16:16:26 +01:00
|
|
|
alias Pleroma.Web.MastodonAPI.AccountView
|
2019-03-26 19:42:03 +01:00
|
|
|
alias Pleroma.Web.MastodonAPI.AppView
|
2019-02-09 16:16:26 +01:00
|
|
|
alias Pleroma.Web.MastodonAPI.MastodonView
|
2019-03-05 03:52:23 +01:00
|
|
|
alias Pleroma.Web.MastodonAPI.StatusView
|
2019-02-09 16:16:26 +01:00
|
|
|
alias Pleroma.Web.OAuth.App
|
|
|
|
alias Pleroma.Web.OAuth.Authorization
|
2019-05-08 12:52:13 +02:00
|
|
|
alias Pleroma.Web.OAuth.Scopes
|
2019-02-09 16:16:26 +01:00
|
|
|
alias Pleroma.Web.OAuth.Token
|
2019-05-13 20:35:45 +02:00
|
|
|
alias Pleroma.Web.TwitterAPI.TwitterAPI
|
2018-12-06 14:50:20 +01:00
|
|
|
|
2017-11-19 02:22:07 +01:00
|
|
|
require Logger
|
2017-09-06 19:06:25 +02:00
|
|
|
|
2019-07-16 23:44:50 +02:00
|
|
|
plug(RateLimiter, :password_reset when action == :password_reset)
|
2019-06-11 09:28:39 +02:00
|
|
|
|
2019-02-07 20:14:06 +01:00
|
|
|
@local_mastodon_name "Mastodon-Local"
|
2018-07-14 03:04:37 +02:00
|
|
|
|
2019-08-26 14:16:40 +02:00
|
|
|
action_fallback(Pleroma.Web.MastodonAPI.FallbackController)
|
2018-06-03 19:28:11 +02:00
|
|
|
|
2017-09-06 19:06:25 +02:00
|
|
|
def create_app(conn, params) do
|
2019-05-08 12:52:13 +02:00
|
|
|
scopes = Scopes.fetch_scopes(params, ["read"])
|
2019-02-14 15:03:19 +01:00
|
|
|
|
|
|
|
app_attrs =
|
|
|
|
params
|
|
|
|
|> Map.drop(["scope", "scopes"])
|
|
|
|
|> Map.put("scopes", scopes)
|
2019-02-13 22:29:29 +01:00
|
|
|
|
|
|
|
with cs <- App.register_changeset(%App{}, app_attrs),
|
2019-02-07 20:14:06 +01:00
|
|
|
false <- cs.changes[:client_name] == @local_mastodon_name,
|
|
|
|
{:ok, app} <- Repo.insert(cs) do
|
2019-03-26 21:21:31 +01:00
|
|
|
conn
|
|
|
|
|> put_view(AppView)
|
|
|
|
|> render("show.json", %{app: app})
|
2017-09-06 19:06:25 +02:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2019-03-26 19:42:03 +01:00
|
|
|
def verify_app_credentials(%{assigns: %{user: _user, token: token}} = conn, _) do
|
|
|
|
with %Token{app: %App{} = app} <- Repo.preload(token, :app) do
|
|
|
|
conn
|
|
|
|
|> put_view(AppView)
|
2019-03-26 21:21:31 +01:00
|
|
|
|> render("short.json", %{app: app})
|
2019-03-26 19:42:03 +01:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2019-05-13 22:52:16 +02:00
|
|
|
@mastodon_api_level "2.7.2"
|
2017-09-15 10:26:28 +02:00
|
|
|
|
2017-09-07 08:58:10 +02:00
|
|
|
def masto_instance(conn, _params) do
|
2019-02-03 18:44:18 +01:00
|
|
|
instance = Config.get(:instance)
|
2018-11-06 19:34:57 +01:00
|
|
|
|
2017-09-07 08:58:10 +02:00
|
|
|
response = %{
|
2018-03-30 15:01:53 +02:00
|
|
|
uri: Web.base_url(),
|
2018-11-06 19:34:57 +01:00
|
|
|
title: Keyword.get(instance, :name),
|
|
|
|
description: Keyword.get(instance, :description),
|
2018-11-20 17:55:03 +01:00
|
|
|
version: "#{@mastodon_api_level} (compatible; #{Pleroma.Application.named_version()})",
|
2018-11-06 19:34:57 +01:00
|
|
|
email: Keyword.get(instance, :email),
|
2017-09-15 10:26:28 +02:00
|
|
|
urls: %{
|
2019-02-01 19:56:18 +01:00
|
|
|
streaming_api: Pleroma.Web.Endpoint.websocket_url()
|
2017-09-15 10:26:28 +02:00
|
|
|
},
|
2018-03-30 15:01:53 +02:00
|
|
|
stats: Stats.get_stats(),
|
|
|
|
thumbnail: Web.base_url() <> "/instance/thumbnail.jpeg",
|
2019-03-26 14:27:17 +01:00
|
|
|
languages: ["en"],
|
|
|
|
registrations: Pleroma.Config.get([:instance, :registrations_open]),
|
|
|
|
# Extra (not present in Mastodon):
|
2019-05-21 08:13:10 +02:00
|
|
|
max_toot_chars: Keyword.get(instance, :limit),
|
|
|
|
poll_limits: Keyword.get(instance, :poll_limits)
|
2017-09-06 19:06:25 +02:00
|
|
|
}
|
|
|
|
|
2017-09-07 08:58:10 +02:00
|
|
|
json(conn, response)
|
2017-09-06 19:06:25 +02:00
|
|
|
end
|
2017-09-09 13:15:01 +02:00
|
|
|
|
2018-01-13 17:24:16 +01:00
|
|
|
def peers(conn, _params) do
|
2018-03-30 15:01:53 +02:00
|
|
|
json(conn, Stats.get_peers())
|
2018-01-13 17:24:16 +01:00
|
|
|
end
|
|
|
|
|
2017-11-16 09:40:06 +01:00
|
|
|
defp mastodonized_emoji do
|
2018-11-05 13:24:00 +01:00
|
|
|
Pleroma.Emoji.get_all()
|
2019-08-31 09:14:53 +02:00
|
|
|
|> Enum.map(fn {shortcode, %Pleroma.Emoji{file: relative_url, tags: tags}} ->
|
2018-03-30 15:01:53 +02:00
|
|
|
url = to_string(URI.merge(Web.base_url(), relative_url))
|
|
|
|
|
2017-11-07 20:28:31 +01:00
|
|
|
%{
|
|
|
|
"shortcode" => shortcode,
|
|
|
|
"static_url" => url,
|
2018-05-01 08:24:30 +02:00
|
|
|
"visible_in_picker" => true,
|
2019-04-01 12:17:57 +02:00
|
|
|
"url" => url,
|
2019-06-30 01:05:28 +02:00
|
|
|
"tags" => tags,
|
|
|
|
# Assuming that a comma is authorized in the category name
|
|
|
|
"category" => (tags -- ["Custom"]) |> Enum.join(",")
|
2017-11-07 20:28:31 +01:00
|
|
|
}
|
|
|
|
end)
|
2017-11-16 09:40:06 +01:00
|
|
|
end
|
|
|
|
|
|
|
|
def custom_emojis(conn, _params) do
|
|
|
|
mastodon_emoji = mastodonized_emoji()
|
2018-03-30 15:01:53 +02:00
|
|
|
json(conn, mastodon_emoji)
|
2017-11-07 20:28:31 +01:00
|
|
|
end
|
|
|
|
|
2019-09-30 14:10:54 +02:00
|
|
|
def follows(%{assigns: %{user: follower}} = conn, %{"uri" => uri}) do
|
2019-04-15 11:37:49 +02:00
|
|
|
with {_, %User{} = followed} <- {:followed, User.get_cached_by_nickname(uri)},
|
2019-04-15 08:44:16 +02:00
|
|
|
{_, true} <- {:followed, follower.id != followed.id},
|
2019-03-03 22:50:00 +01:00
|
|
|
{:ok, follower, followed, _} <- CommonAPI.follow(follower, followed) do
|
2018-12-16 17:49:42 +01:00
|
|
|
conn
|
|
|
|
|> put_view(AccountView)
|
2019-09-30 14:10:54 +02:00
|
|
|
|> render("show.json", %{user: followed, for: follower})
|
2017-10-28 23:07:38 +02:00
|
|
|
else
|
2019-04-15 08:44:16 +02:00
|
|
|
{:followed, _} ->
|
|
|
|
{:error, :not_found}
|
|
|
|
|
2017-11-19 02:22:07 +01:00
|
|
|
{:error, message} ->
|
2017-10-28 23:07:38 +02:00
|
|
|
conn
|
2019-07-10 11:25:58 +02:00
|
|
|
|> put_status(:forbidden)
|
|
|
|
|> json(%{error: message})
|
2017-10-28 23:07:38 +02:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2018-09-01 23:33:13 +02:00
|
|
|
def mutes(%{assigns: %{user: user}} = conn, _) do
|
2019-02-19 21:09:16 +01:00
|
|
|
with muted_accounts <- User.muted_users(user) do
|
2019-09-30 14:10:54 +02:00
|
|
|
res = AccountView.render("index.json", users: muted_accounts, for: user, as: :user)
|
2018-09-01 23:33:13 +02:00
|
|
|
json(conn, res)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-11-03 08:51:17 +01:00
|
|
|
def blocks(%{assigns: %{user: user}} = conn, _) do
|
2018-12-28 19:08:07 +01:00
|
|
|
with blocked_accounts <- User.blocked_users(user) do
|
2019-09-30 14:10:54 +02:00
|
|
|
res = AccountView.render("index.json", users: blocked_accounts, for: user, as: :user)
|
2017-11-03 08:51:17 +01:00
|
|
|
json(conn, res)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2019-01-12 15:42:52 +01:00
|
|
|
def favourites(%{assigns: %{user: user}} = conn, params) do
|
2018-03-30 15:01:53 +02:00
|
|
|
params =
|
2019-01-12 15:42:52 +01:00
|
|
|
params
|
2018-03-30 15:01:53 +02:00
|
|
|
|> Map.put("type", "Create")
|
|
|
|
|> Map.put("favorited_by", user.ap_id)
|
|
|
|
|> Map.put("blocking_user", user)
|
2017-09-17 13:09:49 +02:00
|
|
|
|
2018-03-30 15:01:53 +02:00
|
|
|
activities =
|
2019-03-25 00:15:45 +01:00
|
|
|
ActivityPub.fetch_activities([], params)
|
2018-03-30 15:01:53 +02:00
|
|
|
|> Enum.reverse()
|
2017-09-17 13:09:49 +02:00
|
|
|
|
|
|
|
conn
|
2019-09-06 12:08:47 +02:00
|
|
|
|> add_link_headers(activities)
|
2018-12-16 17:49:42 +01:00
|
|
|
|> put_view(StatusView)
|
|
|
|
|> render("index.json", %{activities: activities, for: user, as: :activity})
|
2017-09-17 13:09:49 +02:00
|
|
|
end
|
|
|
|
|
2019-04-14 14:45:56 +02:00
|
|
|
def bookmarks(%{assigns: %{user: user}} = conn, params) do
|
2019-04-22 09:20:43 +02:00
|
|
|
user = User.get_cached_by_id(user.id)
|
2019-04-14 14:45:56 +02:00
|
|
|
|
|
|
|
bookmarks =
|
|
|
|
Bookmark.for_user_query(user.id)
|
|
|
|
|> Pagination.fetch_paginated(params)
|
2018-09-19 02:04:56 +02:00
|
|
|
|
|
|
|
activities =
|
2019-04-14 14:45:56 +02:00
|
|
|
bookmarks
|
2019-05-07 17:00:50 +02:00
|
|
|
|> Enum.map(fn b -> Map.put(b.activity, :bookmark, Map.delete(b, :activity)) end)
|
2018-09-19 02:04:56 +02:00
|
|
|
|
|
|
|
conn
|
2019-09-06 12:08:47 +02:00
|
|
|
|> add_link_headers(bookmarks)
|
2018-09-19 02:04:56 +02:00
|
|
|
|> put_view(StatusView)
|
|
|
|
|> render("index.json", %{activities: activities, for: user, as: :activity})
|
|
|
|
end
|
|
|
|
|
2017-11-12 14:23:05 +01:00
|
|
|
def index(%{assigns: %{user: user}} = conn, _params) do
|
2019-04-06 01:36:42 +02:00
|
|
|
token = get_session(conn, :oauth_token)
|
2017-11-12 14:23:05 +01:00
|
|
|
|
|
|
|
if user && token do
|
2017-11-16 09:40:06 +01:00
|
|
|
mastodon_emoji = mastodonized_emoji()
|
2018-09-22 04:48:42 +02:00
|
|
|
|
2019-02-03 18:44:18 +01:00
|
|
|
limit = Config.get([:instance, :limit])
|
2018-11-06 19:34:57 +01:00
|
|
|
|
2019-09-30 14:10:54 +02:00
|
|
|
accounts = Map.put(%{}, user.id, AccountView.render("show.json", %{user: user, for: user}))
|
2018-03-30 15:01:53 +02:00
|
|
|
|
|
|
|
initial_state =
|
|
|
|
%{
|
|
|
|
meta: %{
|
2019-05-03 13:45:04 +02:00
|
|
|
streaming_api_base_url: Pleroma.Web.Endpoint.websocket_url(),
|
2018-03-30 15:01:53 +02:00
|
|
|
access_token: token,
|
|
|
|
locale: "en",
|
|
|
|
domain: Pleroma.Web.Endpoint.host(),
|
|
|
|
admin: "1",
|
|
|
|
me: "#{user.id}",
|
|
|
|
unfollow_modal: false,
|
|
|
|
boost_modal: false,
|
|
|
|
delete_modal: true,
|
|
|
|
auto_play_gif: false,
|
2018-06-04 17:44:08 +02:00
|
|
|
display_sensitive_media: false,
|
2018-06-23 11:54:04 +02:00
|
|
|
reduce_motion: false,
|
2019-04-04 09:07:25 +02:00
|
|
|
max_toot_chars: limit,
|
2019-05-20 17:12:55 +02:00
|
|
|
mascot: User.get_mascot(user)["url"]
|
2017-11-12 14:23:05 +01:00
|
|
|
},
|
2019-05-21 08:13:10 +02:00
|
|
|
poll_limits: Config.get([:instance, :poll_limits]),
|
2018-06-26 20:48:35 +02:00
|
|
|
rights: %{
|
2019-02-03 18:44:18 +01:00
|
|
|
delete_others_notice: present?(user.info.is_moderator),
|
|
|
|
admin: present?(user.info.is_admin)
|
2018-06-26 20:48:35 +02:00
|
|
|
},
|
2018-03-30 15:01:53 +02:00
|
|
|
compose: %{
|
|
|
|
me: "#{user.id}",
|
2018-11-20 20:12:39 +01:00
|
|
|
default_privacy: user.info.default_scope,
|
2019-02-18 00:21:13 +01:00
|
|
|
default_sensitive: false,
|
|
|
|
allow_content_types: Config.get([:instance, :allowed_post_formats])
|
2018-03-30 15:01:53 +02:00
|
|
|
},
|
|
|
|
media_attachments: %{
|
|
|
|
accept_content_types: [
|
|
|
|
".jpg",
|
|
|
|
".jpeg",
|
|
|
|
".png",
|
|
|
|
".gif",
|
|
|
|
".webm",
|
|
|
|
".mp4",
|
|
|
|
".m4v",
|
|
|
|
"image\/jpeg",
|
|
|
|
"image\/png",
|
|
|
|
"image\/gif",
|
|
|
|
"video\/webm",
|
|
|
|
"video\/mp4"
|
|
|
|
]
|
|
|
|
},
|
2018-04-10 18:38:52 +02:00
|
|
|
settings:
|
2018-12-16 12:15:34 +01:00
|
|
|
user.info.settings ||
|
2018-04-10 18:38:52 +02:00
|
|
|
%{
|
|
|
|
onboarded: true,
|
|
|
|
home: %{
|
|
|
|
shows: %{
|
|
|
|
reblog: true,
|
|
|
|
reply: true
|
|
|
|
}
|
|
|
|
},
|
|
|
|
notifications: %{
|
|
|
|
alerts: %{
|
|
|
|
follow: true,
|
|
|
|
favourite: true,
|
|
|
|
reblog: true,
|
|
|
|
mention: true
|
|
|
|
},
|
|
|
|
shows: %{
|
|
|
|
follow: true,
|
|
|
|
favourite: true,
|
|
|
|
reblog: true,
|
|
|
|
mention: true
|
|
|
|
},
|
|
|
|
sounds: %{
|
|
|
|
follow: true,
|
|
|
|
favourite: true,
|
|
|
|
reblog: true,
|
|
|
|
mention: true
|
|
|
|
}
|
|
|
|
}
|
2018-03-30 15:01:53 +02:00
|
|
|
},
|
|
|
|
push_subscription: nil,
|
|
|
|
accounts: accounts,
|
|
|
|
custom_emojis: mastodon_emoji,
|
2018-11-06 19:34:57 +01:00
|
|
|
char_limit: limit
|
2018-03-30 15:01:53 +02:00
|
|
|
}
|
|
|
|
|> Jason.encode!()
|
|
|
|
|
2017-11-12 14:23:05 +01:00
|
|
|
conn
|
|
|
|
|> put_layout(false)
|
2018-12-16 17:49:42 +01:00
|
|
|
|> put_view(MastodonView)
|
2019-06-01 01:42:46 +02:00
|
|
|
|> render("index.html", %{initial_state: initial_state})
|
2017-11-12 14:23:05 +01:00
|
|
|
else
|
|
|
|
conn
|
2019-04-06 01:36:42 +02:00
|
|
|
|> put_session(:return_to, conn.request_path)
|
2017-11-12 14:23:05 +01:00
|
|
|
|> redirect(to: "/web/login")
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2018-04-07 16:26:56 +02:00
|
|
|
def put_settings(%{assigns: %{user: user}} = conn, %{"data" => settings} = _params) do
|
2019-09-24 09:49:02 +02:00
|
|
|
with {:ok, _} <- User.update_info(user, &User.Info.mastodon_settings_update(&1, settings)) do
|
2018-12-09 10:12:48 +01:00
|
|
|
json(conn, %{})
|
2018-04-10 18:38:52 +02:00
|
|
|
else
|
|
|
|
e ->
|
2018-12-16 12:15:34 +01:00
|
|
|
conn
|
2019-07-10 11:25:58 +02:00
|
|
|
|> put_status(:internal_server_error)
|
|
|
|
|> json(%{error: inspect(e)})
|
2018-04-07 16:26:56 +02:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2019-04-01 16:25:25 +02:00
|
|
|
def login(%{assigns: %{user: %User{}}} = conn, _params) do
|
|
|
|
redirect(conn, to: local_mastodon_root_path(conn))
|
|
|
|
end
|
|
|
|
|
|
|
|
@doc "Local Mastodon FE login init action"
|
|
|
|
def login(conn, %{"code" => auth_token}) do
|
2018-11-06 15:19:11 +01:00
|
|
|
with {:ok, app} <- get_or_make_app(),
|
2019-09-06 20:50:00 +02:00
|
|
|
{:ok, auth} <- Authorization.get_by_token(app, auth_token),
|
2018-11-06 15:19:11 +01:00
|
|
|
{:ok, token} <- Token.exchange_token(app, auth) do
|
|
|
|
conn
|
|
|
|
|> put_session(:oauth_token, token.token)
|
2019-04-01 16:25:25 +02:00
|
|
|
|> redirect(to: local_mastodon_root_path(conn))
|
2018-11-06 15:19:11 +01:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2019-04-01 16:25:25 +02:00
|
|
|
@doc "Local Mastodon FE callback action"
|
2017-11-19 02:22:07 +01:00
|
|
|
def login(conn, _) do
|
2018-11-06 15:19:11 +01:00
|
|
|
with {:ok, app} <- get_or_make_app() do
|
|
|
|
path =
|
2019-09-06 20:50:00 +02:00
|
|
|
o_auth_path(conn, :authorize,
|
2018-11-06 15:19:11 +01:00
|
|
|
response_type: "code",
|
|
|
|
client_id: app.client_id,
|
|
|
|
redirect_uri: ".",
|
2019-02-17 11:49:14 +01:00
|
|
|
scope: Enum.join(app.scopes, " ")
|
2018-11-06 15:19:11 +01:00
|
|
|
)
|
|
|
|
|
2019-04-06 01:36:42 +02:00
|
|
|
redirect(conn, to: path)
|
2018-11-06 15:19:11 +01:00
|
|
|
end
|
2017-11-12 14:23:05 +01:00
|
|
|
end
|
|
|
|
|
2019-04-06 01:36:42 +02:00
|
|
|
defp local_mastodon_root_path(conn) do
|
|
|
|
case get_session(conn, :return_to) do
|
|
|
|
nil ->
|
|
|
|
mastodon_api_path(conn, :index, ["getting-started"])
|
|
|
|
|
|
|
|
return_to ->
|
|
|
|
delete_session(conn, :return_to)
|
|
|
|
return_to
|
2018-11-06 15:19:11 +01:00
|
|
|
end
|
2017-11-12 14:23:05 +01:00
|
|
|
end
|
|
|
|
|
2019-09-06 20:50:00 +02:00
|
|
|
@spec get_or_make_app() :: {:ok, App.t()} | {:error, Ecto.Changeset.t()}
|
2019-03-05 04:18:43 +01:00
|
|
|
defp get_or_make_app do
|
2019-09-06 20:50:00 +02:00
|
|
|
App.get_or_make(
|
|
|
|
%{client_name: @local_mastodon_name, redirect_uris: "."},
|
|
|
|
["read", "write", "follow", "push"]
|
|
|
|
)
|
2017-11-12 14:23:05 +01:00
|
|
|
end
|
|
|
|
|
2017-11-19 13:23:16 +01:00
|
|
|
def logout(conn, _) do
|
|
|
|
conn
|
|
|
|
|> clear_session
|
|
|
|
|> redirect(to: "/")
|
|
|
|
end
|
|
|
|
|
2019-09-06 20:50:00 +02:00
|
|
|
# Stubs for unimplemented mastodon api
|
|
|
|
#
|
2017-09-09 19:19:13 +02:00
|
|
|
def empty_array(conn, _) do
|
|
|
|
Logger.debug("Unimplemented, returning an empty array")
|
|
|
|
json(conn, [])
|
|
|
|
end
|
2017-11-10 14:24:39 +01:00
|
|
|
|
2018-03-09 19:56:21 +01:00
|
|
|
def empty_object(conn, _) do
|
|
|
|
Logger.debug("Unimplemented, returning an empty object")
|
2018-08-14 04:27:28 +02:00
|
|
|
json(conn, %{})
|
|
|
|
end
|
|
|
|
|
2019-07-16 23:44:50 +02:00
|
|
|
def password_reset(conn, params) do
|
|
|
|
nickname_or_email = params["email"] || params["nickname"]
|
|
|
|
|
|
|
|
with {:ok, _} <- TwitterAPI.password_reset(nickname_or_email) do
|
|
|
|
conn
|
|
|
|
|> put_status(:no_content)
|
|
|
|
|> json("")
|
|
|
|
else
|
|
|
|
{:error, "unknown user"} ->
|
2019-07-17 20:09:31 +02:00
|
|
|
send_resp(conn, :not_found, "")
|
2019-07-16 23:44:50 +02:00
|
|
|
|
|
|
|
{:error, _} ->
|
2019-07-17 20:09:31 +02:00
|
|
|
send_resp(conn, :bad_request, "")
|
2019-07-16 23:44:50 +02:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2019-02-03 18:44:18 +01:00
|
|
|
defp present?(nil), do: false
|
|
|
|
defp present?(false), do: false
|
|
|
|
defp present?(_), do: true
|
2017-09-06 19:06:25 +02:00
|
|
|
end
|