defmodule Mobilizon.Web.JsonLD.ObjectView do use Mobilizon.Web, :view alias Mobilizon.Actors.Actor alias Mobilizon.Addresses.Address alias Mobilizon.Events.{Event, EventOptions, Participant} alias Mobilizon.Posts.Post alias Mobilizon.Web.Endpoint alias Mobilizon.Web.JsonLD.ObjectView alias Mobilizon.Web.Router.Helpers, as: Routes import Mobilizon.Service.Metadata.Utils, only: [process_description: 3] @spec render(String.t(), map()) :: map() def render("group.json", %{group: %Actor{} = group}) do res = %{ "@context" => "http://schema.org", "@type" => "Organization", "url" => group.url, "name" => group.name || group.preferred_username, "address" => render_address(group) } res = if group.banner do Map.put(res, "image", group.banner.url) else res end if group.physical_address do Map.put( res, "address", render_one(group.physical_address, ObjectView, "address.json", as: :address) ) else res end end def render("event.json", %{event: %Event{} = event}) do organizer = %{ "@type" => if(event.organizer_actor.type == :Group, do: "Organization", else: "Person"), "name" => Actor.display_name(event.organizer_actor) } organizer = if event.organizer_actor.avatar do Map.put(organizer, "image", event.organizer_actor.avatar.url) else organizer end participant_count = Mobilizon.Events.count_participant_participants(event.id) json_ld = %{ "@context" => "https://schema.org", "@type" => "Event", "name" => event.title, "description" => process_description(event.description, "en", nil), # We assume for now performer == organizer "performer" => organizer, "organizer" => organizer, "location" => render_all_locations(event), "eventAttendanceMode" => event |> attendance_mode() |> event_attendance_mode(), "maximumAttendeeCapacity" => event.options.maximum_attendee_capacity, "remainingAttendeeCapacity" => remaining_attendee_capacity(event.options, participant_count), "eventStatus" => if(event.status == :cancelled, do: "https://schema.org/EventCancelled", else: "https://schema.org/EventScheduled" ), "image" => if(event.picture, do: [ event.picture.file.url ], else: ["#{Endpoint.url()}/img/mobilizon_default_card.png"] ) } json_ld = if event.begins_on, do: Map.put(json_ld, "startDate", DateTime.to_iso8601(event.begins_on)), else: json_ld json_ld = if event.ends_on, do: Map.put(json_ld, "endDate", DateTime.to_iso8601(event.ends_on)), else: json_ld json_ld end def render("place.json", %{address: %Address{} = address}) do %{ "@type" => "Place", "name" => address.description, "address" => render_one(address, ObjectView, "address.json", as: :address) } end def render("address.json", %{address: %Address{} = address}) do %{ "@type" => "PostalAddress", "streetAddress" => address.street, "addressLocality" => address.locality, "postalCode" => address.postal_code, "addressRegion" => address.region, "addressCountry" => address.country } end def render("post.json", %{post: %Post{} = post}) do %{ "@context" => "https://schema.org", "@type" => "Article", "name" => post.title, "headline" => post.title, "author" => %{ "@type" => "Organization", "name" => Actor.display_name(post.attributed_to), "url" => Endpoint |> Routes.page_url( :actor, Actor.preferred_username_and_domain(post.attributed_to) ) |> URI.decode() }, "datePublished" => post.publish_at, "dateModified" => post.updated_at, "image" => if(post.picture, do: [ post.picture.file.url ], else: ["#{Endpoint.url()}/img/mobilizon_default_card.png"] ) } end def render("participation.json", %{ participant: %Participant{} = participant }) do res = %{ "@context" => "http://schema.org", "@type" => "EventReservation", "underName" => %{ "@type" => "Person", "name" => participant.actor.name || participant.actor.preferred_username }, "reservationFor" => render("event.json", %{event: participant.event}), "reservationStatus" => reservation_status(participant.role), "modifiedTime" => participant.updated_at, "modifyReservationUrl" => Routes.page_url(Endpoint, :event, participant.event.uuid) } if participant.code do Map.put(res, "reservationNumber", participant.code) else res end end @spec reservation_status(atom()) :: String.t() defp reservation_status(:rejected), do: "https://schema.org/ReservationCancelled" defp reservation_status(:not_confirmed), do: "https://schema.org/ReservationPending" defp reservation_status(:not_approved), do: "https://schema.org/ReservationHold" defp reservation_status(_), do: "https://schema.org/ReservationConfirmed" defp render_all_locations(%Event{} = event) do [] |> render_location(event) |> render_virtual_location(event) |> maybe_render_single_element() end @spec render_location(list(), map()) :: list() defp render_location(locations, %{physical_address: %Address{} = address}), do: locations ++ [render_one(address, ObjectView, "place.json", as: :address)] defp render_location(locations, _), do: locations # For now the Virtual Location of an event is it's own URL, # but in the future it will be a special field defp render_virtual_location(locations, %Event{ url: event_url, metadata: metadata, options: %EventOptions{is_online: is_online} }) do links = virtual_location_links(metadata) fallback_links = if is_online, do: [event_url], else: [] links = if length(links) > 0, do: Enum.map(links, & &1.value), else: fallback_links locations ++ Enum.map( links, &%{ "@type" => "VirtualLocation", "url" => &1 } ) end defp render_virtual_location(locations, _), do: locations @spec maybe_render_single_element(list(map())) :: list(map()) | map() defp maybe_render_single_element([location]), do: location defp maybe_render_single_element(locations), do: locations defp render_address(%{physical_address: %Address{} = address}), do: render_one(address, ObjectView, "address.json", as: :address) defp render_address(_), do: nil defp event_attendance_mode(:online), do: "https://schema.org/OnlineEventAttendanceMode" defp event_attendance_mode(:offline), do: "https://schema.org/OfflineEventAttendanceMode" defp event_attendance_mode(:mixed), do: "https://schema.org/MixedEventAttendanceMode" defp attendance_mode(%Event{options: %EventOptions{is_online: true}}), do: :online defp attendance_mode(%Event{physical_address: %Address{}, metadata: metadata}) do if metadata |> virtual_location_links() |> length() > 0 do :mixed else :offline end end defp attendance_mode(%Event{}), do: :offline @livestream_keys ["mz:live", "mz:visio"] @spec virtual_location_links(list()) :: list() defp virtual_location_links(metadata), do: Enum.filter(metadata, &String.contains?(&1.key, @livestream_keys)) # TODO: Make this in common with Mobilizon.Federation.ActivityStream.Converter.Event @spec remaining_attendee_capacity(map(), integer()) :: integer() | nil defp remaining_attendee_capacity( %{maximum_attendee_capacity: maximum_attendee_capacity}, participant_count ) when is_integer(maximum_attendee_capacity) and maximum_attendee_capacity > 0 do maximum_attendee_capacity - participant_count end defp remaining_attendee_capacity( %{maximum_attendee_capacity: _}, _participant_count ), do: nil end