Rename project to Mobilizon

Signed-off-by: Thomas Citharel <tcit@tcit.fr>

lib/mobilizon_web/views/activity_pub/actor_view.ex

@@ -0,0 +1,169 @@
+defmodule MobilizonWeb.ActivityPub.ActorView do
+  use MobilizonWeb, :view
+
+  alias MobilizonWeb.ActivityPub.ActorView
+  alias MobilizonWeb.ActivityPub.ObjectView
+  alias MobilizonWeb.WebFinger
+  alias Mobilizon.Actors.Actor
+  alias Mobilizon.Repo
+  alias Mobilizon.Service.ActivityPub
+  alias Mobilizon.Service.ActivityPub.Transmogrifier
+  alias Mobilizon.Service.ActivityPub.Utils
+  alias Mobilizon.Activity
+  import Ecto.Query
+
+  def render("actor.json", %{actor: actor}) do
+    public_key = Mobilizon.Service.ActivityPub.Utils.pem_to_public_key_pem(actor.keys)
+
+    %{
+      "id" => actor.url,
+      "type" => "Person",
+      "following" => actor.following_url,
+      "followers" => actor.followers_url,
+      "inbox" => actor.inbox_url,
+      "outbox" => actor.outbox_url,
+      "preferredUsername" => actor.preferred_username,
+      "name" => actor.name,
+      "summary" => actor.summary,
+      "url" => actor.url,
+      "manuallyApprovesFollowers" => actor.manually_approves_followers,
+      "publicKey" => %{
+        "id" => "#{actor.url}#main-key",
+        "owner" => actor.url,
+        "publicKeyPem" => public_key
+      },
+      "endpoints" => %{
+        "sharedInbox" => actor.shared_inbox_url
+      }
+      #      "icon" => %{
+      #        "type" => "Image",
+      #        "url" => User.avatar_url(actor)
+      #      },
+      #      "image" => %{
+      #        "type" => "Image",
+      #        "url" => User.banner_url(actor)
+      #      }
+    }
+    |> Map.merge(Utils.make_json_ld_header())
+  end
+
+  def render("following.json", %{actor: actor, page: page}) do
+    actor
+    |> Actor.get_followings()
+    |> collection(actor.following_url, page)
+    |> Map.merge(Utils.make_json_ld_header())
+  end
+
+  def render("following.json", %{actor: actor}) do
+    following = Actor.get_followings(actor)
+
+    %{
+      "id" => actor.following_url,
+      "type" => "OrderedCollection",
+      "totalItems" => length(following),
+      "first" => collection(following, actor.following_url, 1)
+    }
+    |> Map.merge(Utils.make_json_ld_header())
+  end
+
+  def render("followers.json", %{actor: actor, page: page}) do
+    actor
+    |> Actor.get_followers()
+    |> collection(actor.followers_url, page)
+    |> Map.merge(Utils.make_json_ld_header())
+  end
+
+  def render("followers.json", %{actor: actor}) do
+    followers = Actor.get_followers(actor)
+
+    %{
+      "id" => actor.followers_url,
+      "type" => "OrderedCollection",
+      "totalItems" => length(followers),
+      "first" => collection(followers, actor.followers_url, 1)
+    }
+    |> Map.merge(Utils.make_json_ld_header())
+  end
+
+  def render("outbox.json", %{actor: actor, page: page}) do
+    {page, no_page} =
+      if page == 0 do
+        {1, true}
+      else
+        {page, false}
+      end
+
+    {activities, total} = ActivityPub.fetch_public_activities_for_actor(actor, page)
+
+    collection =
+      Enum.map(activities, fn act ->
+        {:ok, data} = Transmogrifier.prepare_outgoing(act.data)
+        data
+      end)
+
+    iri = "#{actor.url}/outbox"
+
+    page = %{
+      "id" => "#{iri}?page=#{page}",
+      "type" => "OrderedCollectionPage",
+      "partOf" => iri,
+      "totalItems" => total,
+      "orderedItems" => render_many(activities, ActorView, "activity.json", as: :activity),
+      "next" => "#{iri}?page=#{page + 1}"
+    }
+
+    if no_page do
+      %{
+        "id" => iri,
+        "type" => "OrderedCollection",
+        "totalItems" => total,
+        "first" => page
+      }
+      |> Map.merge(Utils.make_json_ld_header())
+    else
+      page |> Map.merge(Utils.make_json_ld_header())
+    end
+  end
+
+  def render("activity.json", %{activity: %Activity{local: local} = activity}) do
+    %{
+      "id" => activity.data.url <> "/activity",
+      "type" =>
+        if local do
+          "Create"
+        else
+          "Announce"
+        end,
+      "actor" => activity.actor,
+      "published" => Timex.now(),
+      "to" => ["https://www.w3.org/ns/activitystreams#Public"],
+      "object" =>
+        case activity.type do
+          :Event ->
+            render_one(activity.data, ObjectView, "event.json", as: :event)
+
+          :Comment ->
+            render_one(activity.data, ObjectView, "note.json", as: :note)
+        end
+    }
+  end
+
+  def collection(collection, iri, page, total \\ nil) do
+    offset = (page - 1) * 10
+    items = Enum.slice(collection, offset, 10)
+    items = Enum.map(items, fn account -> account.url end)
+    total = total || length(collection)
+
+    map = %{
+      "id" => "#{iri}?page=#{page}",
+      "type" => "OrderedCollectionPage",
+      "partOf" => iri,
+      "totalItems" => total,
+      "orderedItems" => items
+    }
+
+    if offset < total do
+      Map.put(map, "next", "#{iri}?page=#{page + 1}")
+    end
+  end
+end

lib/mobilizon_web/views/activity_pub/object_view.ex

@@ -0,0 +1,55 @@
+defmodule MobilizonWeb.ActivityPub.ObjectView do
+  use MobilizonWeb, :view
+  alias MobilizonWeb.ActivityPub.ObjectView
+  alias Mobilizon.Service.ActivityPub.Transmogrifier
+
+  @base %{
+    "@context" => [
+      "https://www.w3.org/ns/activitystreams",
+      "https://w3id.org/security/v1",
+      %{
+        "manuallyApprovesFollowers" => "as:manuallyApprovesFollowers",
+        "sensitive" => "as:sensitive",
+        "Hashtag" => "as:Hashtag",
+        "toot" => "http://joinmastodon.org/ns#",
+        "Emoji" => "toot:Emoji"
+      }
+    ]
+  }
+
+  def render("event.json", %{event: event}) do
+    event = %{
+      "type" => "Event",
+      "id" => event.url,
+      "name" => event.title,
+      "category" => render_one(event.category, ObjectView, "category.json", as: :category),
+      "content" => event.description,
+      "mediaType" => "text/markdown",
+      "published" => Timex.format!(event.inserted_at, "{ISO:Extended}"),
+      "updated" => Timex.format!(event.updated_at, "{ISO:Extended}")
+    }
+
+    Map.merge(event, @base)
+  end
+
+  def render("note.json", %{note: note}) do
+    event = %{
+      "type" => "Note",
+      "id" => note.url,
+      "content" => note.text,
+      "mediaType" => "text/markdown",
+      "published" => Timex.format!(note.inserted_at, "{ISO:Extended}"),
+      "updated" => Timex.format!(note.updated_at, "{ISO:Extended}")
+    }
+
+    Map.merge(event, @base)
+  end
+
+  def render("category.json", %{category: category}) do
+    %{"title" => category.title}
+  end
+
+  def render("category.json", %{category: nil}) do
+    nil
+  end
+end

lib/mobilizon_web/views/actor_view.ex

@@ -0,0 +1,68 @@
+defmodule MobilizonWeb.ActorView do
+  @moduledoc """
+  View for Actors
+  """
+  use MobilizonWeb, :view
+  alias MobilizonWeb.{ActorView, EventView, MemberView}
+  alias Mobilizon.Actors
+
+  def render("index.json", %{actors: actors}) do
+    %{data: render_many(actors, ActorView, "actor_basic.json")}
+  end
+
+  def render("show.json", %{actor: actor}) do
+    %{data: render_one(actor, ActorView, "actor.json")}
+  end
+
+  def render("show_basic.json", %{actor: actor}) do
+    %{data: render_one(actor, ActorView, "actor_basic.json")}
+  end
+
+  def render("actor_basic.json", %{actor: actor}) do
+    %{
+      id: actor.id,
+      username: actor.preferred_username,
+      domain: actor.domain,
+      display_name: actor.name,
+      description: actor.summary,
+      type: actor.type,
+      # public_key: actor.public_key,
+      suspended: actor.suspended,
+      url: actor.url,
+      avatar: actor.avatar_url
+    }
+  end
+
+  def render("actor.json", %{actor: actor}) do
+    output = %{
+      id: actor.id,
+      username: actor.preferred_username,
+      domain: actor.domain,
+      display_name: actor.name,
+      description: actor.summary,
+      type: actor.type,
+      # public_key: actor.public_key,
+      suspended: actor.suspended,
+      url: actor.url,
+      avatar: actor.avatar_url,
+      banner: actor.banner_url,
+      organized_events: render_many(actor.organized_events, EventView, "event_for_actor.json")
+    }
+
+    import Logger
+    Logger.debug(inspect(actor.type))
+
+    if actor.type == :Group do
+      Logger.debug("I'm a group !")
+
+      Map.put(
+        output,
+        :members,
+        render_many(Actors.members_for_group(actor), MemberView, "member.json")
+      )
+    else
+      Logger.debug("not a group")
+      output
+    end
+  end
+end

lib/mobilizon_web/views/address_view.ex

@@ -0,0 +1,42 @@
+defmodule MobilizonWeb.AddressView do
+  @moduledoc """
+  View for addresses
+  """
+
+  use MobilizonWeb, :view
+  alias MobilizonWeb.AddressView
+
+  def render("index.json", %{addresses: addresses}) do
+    %{data: render_many(addresses, AddressView, "address.json")}
+  end
+
+  def render("show.json", %{address: address}) do
+    %{data: render_one(address, AddressView, "address.json")}
+  end
+
+  def render("address.json", %{address: address}) do
+    %{
+      id: address.id,
+      description: address.description,
+      floor: address.floor,
+      addressCountry: address.addressCountry,
+      addressLocality: address.addressLocality,
+      addressRegion: address.addressRegion,
+      postalCode: address.postalCode,
+      streetAddress: address.streetAddress,
+      geom: render_one(address.geom, AddressView, "geom.json")
+    }
+  end
+
+  def render("geom.json", %{address: %Geo.Point{} = point}) do
+    [lat, lon] = Tuple.to_list(point.coordinates)
+
+    %{
+      type: "point",
+      data: %{
+        latitude: lat,
+        longitude: lon
+      }
+    }
+  end
+end

lib/mobilizon_web/views/bot_view.ex

@@ -0,0 +1,16 @@
+defmodule MobilizonWeb.BotView do
+  use MobilizonWeb, :view
+  alias MobilizonWeb.BotView
+
+  def render("index.json", %{bots: bots}) do
+    %{data: render_many(bots, BotView, "bot.json")}
+  end
+
+  def render("show.json", %{bot: bot}) do
+    %{data: render_one(bot, BotView, "bot.json")}
+  end
+
+  def render("bot.json", %{bot: bot}) do
+    %{id: bot.id, source: bot.source, type: bot.type}
+  end
+end

lib/mobilizon_web/views/category_view.ex

@@ -0,0 +1,24 @@
+defmodule MobilizonWeb.CategoryView do
+  @moduledoc """
+  View for Categories
+  """
+  use MobilizonWeb, :view
+  alias MobilizonWeb.CategoryView
+
+  def render("index.json", %{categories: categories}) do
+    %{data: render_many(categories, CategoryView, "category.json")}
+  end
+
+  def render("show.json", %{category: category}) do
+    %{data: render_one(category, CategoryView, "category.json")}
+  end
+
+  def render("category.json", %{category: category}) do
+    %{
+      id: category.id,
+      title: category.title,
+      description: category.description,
+      picture: category.picture
+    }
+  end
+end

lib/mobilizon_web/views/changeset_view.ex

@@ -0,0 +1,22 @@
+defmodule MobilizonWeb.ChangesetView do
+  @moduledoc """
+  View for changesets in case of errors
+  """
+  use MobilizonWeb, :view
+
+  @doc """
+  Traverses and translates changeset errors.
+
+  See `Ecto.Changeset.traverse_errors/2` and
+  `MobilizonWeb.ErrorHelpers.translate_error/1` for more details.
+  """
+  def translate_errors(changeset) do
+    Ecto.Changeset.traverse_errors(changeset, &translate_error/1)
+  end
+
+  def render("error.json", %{changeset: changeset}) do
+    # When encoded, the changeset returns its errors
+    # as a JSON object. So we just pass it forward.
+    %{errors: translate_errors(changeset)}
+  end
+end

lib/mobilizon_web/views/comment_view.ex

@@ -0,0 +1,16 @@
+defmodule MobilizonWeb.CommentView do
+  use MobilizonWeb, :view
+  alias MobilizonWeb.CommentView
+
+  def render("index.json", %{comments: comments}) do
+    %{data: render_many(comments, CommentView, "comment.json")}
+  end
+
+  def render("show.json", %{comment: comment}) do
+    %{data: render_one(comment, CommentView, "comment.json")}
+  end
+
+  def render("comment.json", %{comment: comment}) do
+    %{id: comment.id, uuid: comment.uuid, url: comment.url, text: comment.text}
+  end
+end

lib/mobilizon_web/views/email_view.ex

@@ -0,0 +1,3 @@
+defmodule Mobilizon.EmailView do
+  use MobilizonWeb, :view
+end

lib/mobilizon_web/views/error_helpers.ex

@@ -0,0 +1,40 @@
+defmodule MobilizonWeb.ErrorHelpers do
+  @moduledoc """
+  Conveniences for translating and building error messages.
+  """
+
+  use Phoenix.HTML
+
+  @doc """
+  Generates tag for inlined form input errors.
+  """
+  def error_tag(form, field) do
+    Enum.map(Keyword.get_values(form.errors, field), fn error ->
+      content_tag(:span, translate_error(error), class: "help-block")
+    end)
+  end
+
+  @doc """
+  Translates an error message using gettext.
+  """
+  def translate_error({msg, opts}) do
+    # Because error messages were defined within Ecto, we must
+    # call the Gettext module passing our Gettext backend. We
+    # also use the "errors" domain as translations are placed
+    # in the errors.po file.
+    # Ecto will pass the :count keyword if the error message is
+    # meant to be pluralized.
+    # On your own code and templates, depending on whether you
+    # need the message to be pluralized or not, this could be
+    # written simply as:
+    #
+    #     dngettext "errors", "1 file", "%{count} files", count
+    #     dgettext "errors", "is invalid"
+    #
+    if count = opts[:count] do
+      Gettext.dngettext(MobilizonWeb.Gettext, "errors", msg, msg, count, opts)
+    else
+      Gettext.dgettext(MobilizonWeb.Gettext, "errors", msg, opts)
+    end
+  end
+end

lib/mobilizon_web/views/error_view.ex

@@ -0,0 +1,31 @@
+defmodule MobilizonWeb.ErrorView do
+  @moduledoc """
+  View for errors
+  """
+  use MobilizonWeb, :view
+
+  def render("404.html", _assigns) do
+    "Page not found"
+  end
+
+  def render("invalid_request.json", _assigns) do
+    %{errors: "Invalid request"}
+  end
+
+  def render("not_found.json", %{details: details}) do
+    %{
+      msg: "Resource not found",
+      details: details
+    }
+  end
+
+  def render("500.html", _assigns) do
+    "Internal server error"
+  end
+
+  # In case no render clause matches or no
+  # template is found, let's render it as 500
+  def template_not_found(_template, assigns) do
+    render("500.html", assigns)
+  end
+end

lib/mobilizon_web/views/event_view.ex

@@ -0,0 +1,68 @@
+defmodule MobilizonWeb.EventView do
+  @moduledoc """
+  View for Events
+  """
+  use MobilizonWeb, :view
+  alias MobilizonWeb.{EventView, ActorView, GroupView, AddressView}
+
+  def render("index.json", %{events: events, coord: coord, city: city, country: country}) do
+    %{
+      data: render_many(events, EventView, "event_simple.json"),
+      coord: coord,
+      city: city,
+      country: country
+    }
+  end
+
+  def render("index_all.json", %{events: events}) do
+    %{
+      data: render_many(events, EventView, "event_simple.json")
+    }
+  end
+
+  def render("show_simple.json", %{event: event}) do
+    %{data: render_one(event, EventView, "event_simple.json")}
+  end
+
+  def render("show.json", %{event: event}) do
+    %{data: render_one(event, EventView, "event.json")}
+  end
+
+  def render("event_for_actor.json", %{event: event}) do
+    %{id: event.id, title: event.title, uuid: event.uuid}
+  end
+
+  def render("event_simple.json", %{event: event}) do
+    %{
+      id: event.id,
+      title: event.title,
+      description: event.description,
+      begins_on: event.begins_on,
+      ends_on: event.ends_on,
+      uuid: event.uuid,
+      organizer: %{
+        username: event.organizer_actor.preferred_username,
+        display_name: event.organizer_actor.name,
+        avatar: event.organizer_actor.avatar_url
+      },
+      type: "Event",
+      address_type: event.address_type
+    }
+  end
+
+  def render("event.json", %{event: event}) do
+    %{
+      id: event.id,
+      title: event.title,
+      description: event.description,
+      begins_on: event.begins_on,
+      ends_on: event.ends_on,
+      uuid: event.uuid,
+      organizer: render_one(event.organizer_actor, ActorView, "actor_basic.json"),
+      participants: render_many(event.participants, ActorView, "actor_basic.json"),
+      physical_address: render_one(event.physical_address, AddressView, "address.json"),
+      type: "Event",
+      address_type: event.address_type
+    }
+  end
+end

lib/mobilizon_web/views/follower_view.ex

@@ -0,0 +1,16 @@
+defmodule MobilizonWeb.FollowerView do
+  use MobilizonWeb, :view
+  alias MobilizonWeb.FollowerView
+
+  def render("index.json", %{followers: followers}) do
+    %{data: render_many(followers, FollowerView, "follower.json")}
+  end
+
+  def render("show.json", %{follower: follower}) do
+    %{data: render_one(follower, FollowerView, "follower.json")}
+  end
+
+  def render("follower.json", %{follower: follower}) do
+    %{id: follower.id, approved: follower.approved, score: follower.score}
+  end
+end

lib/mobilizon_web/views/group_view.ex

@@ -0,0 +1,41 @@
+defmodule MobilizonWeb.GroupView do
+  @moduledoc """
+  View for Groups
+  """
+  use MobilizonWeb, :view
+  alias MobilizonWeb.{GroupView, ActorView}
+
+  def render("index.json", %{groups: groups}) do
+    %{data: render_many(groups, GroupView, "group_simple.json")}
+  end
+
+  def render("show.json", %{group: group}) do
+    %{data: render_one(group, GroupView, "group.json")}
+  end
+
+  def render("show_simple.json", %{group: group}) do
+    %{data: render_one(group, GroupView, "group_simple.json")}
+  end
+
+  def render("group_simple.json", %{group: group}) do
+    %{
+      id: group.id,
+      title: group.title,
+      description: group.description,
+      suspended: group.suspended,
+      url: group.url
+    }
+  end
+
+  def render("group.json", %{group: group}) do
+    %{
+      id: group.id,
+      title: group.title,
+      description: group.description,
+      suspended: group.suspended,
+      url: group.url,
+      members: render_many(group.members, ActorView, "actor_basic.json"),
+      events: render_many(group.organized_events, EventView, "event_simple.json")
+    }
+  end
+end

lib/mobilizon_web/views/member_view.ex

@@ -0,0 +1,23 @@
+defmodule MobilizonWeb.MemberView do
+  @moduledoc """
+  View for Members
+  """
+  use MobilizonWeb, :view
+  alias MobilizonWeb.{MemberView, ActorView}
+
+  def render("index.json", %{members: members}) do
+    %{data: render_many(members, MemberView, "member.json")}
+  end
+
+  def render("show.json", %{member: member}) do
+    %{data: render_one(member, MemberView, "member.json")}
+  end
+
+  def render("member.json", %{member: member}) do
+    %{
+      role: member.role,
+      actor: render_one(member.actor, ActorView, "actor_basic.json"),
+      group: render_one(member.parent, ActorView, "actor_basic.json")
+    }
+  end
+end

lib/mobilizon_web/views/page_view.ex

@@ -0,0 +1,6 @@
+defmodule MobilizonWeb.PageView do
+  @moduledoc """
+  View for our webapp
+  """
+  use MobilizonWeb, :view
+end

lib/mobilizon_web/views/participant_view.ex

@@ -0,0 +1,19 @@
+defmodule MobilizonWeb.ParticipantView do
+  @moduledoc """
+  View for Participants
+  """
+  use MobilizonWeb, :view
+  alias MobilizonWeb.ParticipantView
+
+  def render("index.json", %{participants: participants}) do
+    %{data: render_many(participants, ParticipantView, "participant.json")}
+  end
+
+  def render("show.json", %{participant: participant}) do
+    %{data: render_one(participant, ParticipantView, "participant.json")}
+  end
+
+  def render("participant.json", %{participant: participant}) do
+    %{id: participant.id, role: participant.role}
+  end
+end

lib/mobilizon_web/views/search_view.ex

@@ -0,0 +1,16 @@
+defmodule MobilizonWeb.SearchView do
+  @moduledoc """
+  View for Events
+  """
+  use MobilizonWeb, :view
+  alias MobilizonWeb.{EventView, ActorView, GroupView, AddressView}
+
+  def render("search.json", %{events: events, actors: actors}) do
+    %{
+      data: %{
+        events: render_many(events, EventView, "event_simple.json"),
+        actors: render_many(actors, ActorView, "actor_basic.json")
+      }
+    }
+  end
+end

lib/mobilizon_web/views/session_view.ex

@@ -0,0 +1,29 @@
+defmodule MobilizonWeb.SessionView do
+  @moduledoc """
+  View for event Sessions
+  """
+  use MobilizonWeb, :view
+  alias MobilizonWeb.SessionView
+
+  def render("index.json", %{sessions: sessions}) do
+    %{data: render_many(sessions, SessionView, "session.json")}
+  end
+
+  def render("show.json", %{session: session}) do
+    %{data: render_one(session, SessionView, "session.json")}
+  end
+
+  def render("session.json", %{session: session}) do
+    %{
+      id: session.id,
+      title: session.title,
+      subtitle: session.subtitle,
+      short_abstract: session.short_abstract,
+      long_abstract: session.long_abstract,
+      language: session.language,
+      slides_url: session.slides_url,
+      videos_urls: session.videos_urls,
+      audios_urls: session.audios_urls
+    }
+  end
+end

lib/mobilizon_web/views/tag_view.ex

@@ -0,0 +1,19 @@
+defmodule MobilizonWeb.TagView do
+  @moduledoc """
+  View for Tags
+  """
+  use MobilizonWeb, :view
+  alias MobilizonWeb.TagView
+
+  def render("index.json", %{tags: tags}) do
+    %{data: render_many(tags, TagView, "tag.json")}
+  end
+
+  def render("show.json", %{tag: tag}) do
+    %{data: render_one(tag, TagView, "tag.json")}
+  end
+
+  def render("tag.json", %{tag: tag}) do
+    %{id: tag.id, title: tag.title}
+  end
+end

lib/mobilizon_web/views/track_view.ex

@@ -0,0 +1,19 @@
+defmodule MobilizonWeb.TrackView do
+  @moduledoc """
+  View for Tracks
+  """
+  use MobilizonWeb, :view
+  alias MobilizonWeb.TrackView
+
+  def render("index.json", %{tracks: tracks}) do
+    %{data: render_many(tracks, TrackView, "track.json")}
+  end
+
+  def render("show.json", %{track: track}) do
+    %{data: render_one(track, TrackView, "track.json")}
+  end
+
+  def render("track.json", %{track: track}) do
+    %{id: track.id, name: track.name, description: track.description, color: track.color}
+  end
+end

lib/mobilizon_web/views/user_session_view.ex

@@ -0,0 +1,10 @@
+defmodule MobilizonWeb.UserSessionView do
+  @moduledoc """
+  View for user Sessions
+  """
+  use MobilizonWeb, :view
+
+  def render("token.json", %{token: token, user: user}) do
+    %{token: token, user: render_one(user, MobilizonWeb.UserView, "user_simple.json")}
+  end
+end

lib/mobilizon_web/views/user_view.ex

@@ -0,0 +1,55 @@
+defmodule MobilizonWeb.UserView do
+  @moduledoc """
+  View for Users
+  """
+  use MobilizonWeb, :view
+  alias MobilizonWeb.UserView
+  alias MobilizonWeb.ActorView
+
+  def render("index.json", %{users: users}) do
+    %{data: render_many(users, UserView, "user_simple.json")}
+  end
+
+  def render("show.json", %{user: user}) do
+    %{data: render_one(user, UserView, "user.json")}
+  end
+
+  def render("show_simple.json", %{user: user}) do
+    %{data: render_one(user, UserView, "user_simple.json")}
+  end
+
+  def render("show_with_token.json", %{user: user, token: token}) do
+    %{
+      user: render_one(user, UserView, "user_simple.json"),
+      token: token
+    }
+  end
+
+  def render("user_simple.json", %{user: user}) do
+    %{
+      id: user.id,
+      role: user.role,
+      actors: render_many(user.actors, ActorView, "actor_basic.json")
+    }
+  end
+
+  def render("user.json", %{user: user}) do
+    %{id: user.id, role: user.role, actors: render_many(user.actors, ActorView, "actor.json")}
+  end
+
+  def render("user_private.json", %{user: user}) do
+    %{id: user.id, email: user.email, role: user.role}
+  end
+
+  def render("confirmation.json", %{user: user}) do
+    %{
+      email: user.email
+    }
+  end
+
+  def render("password_reset.json", %{user: user}) do
+    %{
+      email: user.email
+    }
+  end
+end