debianize-mobilizon/lib/graphql/resolvers/picture.ex

89 lines
2.7 KiB
Elixir
Raw Normal View History

2020-01-26 20:34:25 +01:00
defmodule Mobilizon.GraphQL.Resolvers.Picture do
@moduledoc """
Handles the picture-related GraphQL calls
"""
2020-01-26 21:11:16 +01:00
2019-09-07 19:54:11 +02:00
alias Mobilizon.Actors.Actor
alias Mobilizon.Media
alias Mobilizon.Media.Picture
2019-05-31 17:58:03 +02:00
alias Mobilizon.Users.User
import Mobilizon.Web.Gettext
@doc """
Get picture for an event's pic
"""
def picture(%{picture_id: picture_id} = _parent, _args, _resolution) do
2019-09-07 19:54:11 +02:00
with {:ok, picture} <- do_fetch_picture(picture_id), do: {:ok, picture}
end
@doc """
Get picture for an event that has an attached
2020-01-26 21:36:50 +01:00
See Mobilizon.Web.Resolvers.Event.create_event/3
"""
2019-09-07 19:54:11 +02:00
def picture(%{picture: picture} = _parent, _args, _resolution), do: {:ok, picture}
def picture(_parent, %{id: picture_id}, _resolution), do: do_fetch_picture(picture_id)
2019-09-07 19:54:11 +02:00
def picture(_parent, _args, _resolution), do: {:ok, nil}
@spec do_fetch_picture(nil) :: {:error, nil}
defp do_fetch_picture(nil), do: {:error, nil}
@spec do_fetch_picture(String.t()) :: {:ok, Picture.t()} | {:error, :not_found}
defp do_fetch_picture(picture_id) do
case Media.get_picture(picture_id) do
2019-09-07 19:54:11 +02:00
%Picture{id: id, file: file} ->
{:ok,
%{
name: file.name,
url: file.url,
id: id,
content_type: file.content_type,
size: file.size
}}
2019-09-07 19:54:11 +02:00
_error ->
{:error, dgettext("errors", "Picture with ID %{id} was not found", id: picture_id)}
end
end
2020-01-26 20:34:25 +01:00
@spec upload_picture(map, map, map) :: {:ok, Picture.t()} | {:error, any}
2019-09-07 19:54:11 +02:00
def upload_picture(
_parent,
%{file: %Plug.Upload{} = file, actor_id: actor_id} = args,
%{context: %{current_user: user}}
) do
with {:is_owned, %Actor{}} <- User.owns_actor(user, actor_id),
{:ok, %{name: _name, url: url, content_type: content_type, size: size}} <-
2020-01-26 21:36:50 +01:00
Mobilizon.Web.Upload.store(file),
args <-
args
|> Map.put(:url, url)
|> Map.put(:size, size)
|> Map.put(:content_type, content_type),
2019-05-31 17:58:03 +02:00
{:ok, picture = %Picture{}} <-
Media.create_picture(%{"file" => args, "actor_id" => actor_id}) do
{:ok,
%{
name: picture.file.name,
url: picture.file.url,
id: picture.id,
content_type: picture.file.content_type,
size: picture.file.size
}}
else
2019-09-07 19:54:11 +02:00
{:is_owned, nil} ->
{:error, dgettext("errors", "Profile is not owned by authenticated user")}
2019-05-31 17:58:03 +02:00
{:error, :mime_type_not_allowed} ->
{:error, dgettext("errors", "File doesn't have an allowed MIME type.")}
2019-09-07 19:54:11 +02:00
error ->
{:error, error}
end
end
def upload_picture(_parent, _args, _resolution) do
{:error, dgettext("errors", "You need to login to upload a picture")}
end
end