Improvements to group page

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

lib/federation/activity_pub/types/actors.ex

@@ -89,12 +89,27 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Actors do
   def group_actor(%Actor{} = actor), do: actor
 
   defp prepare_args_for_actor(args) do
-    with preferred_username <-
-           args |> Map.get(:preferred_username) |> HTML.strip_tags() |> String.trim(),
-         summary <- args |> Map.get(:summary, "") |> String.trim(),
-         {summary, _mentions, _tags} <-
-           summary |> String.trim() |> APIUtils.make_content_html([], "text/html") do
-      %{args | preferred_username: preferred_username, summary: summary}
-    end
+    args
+    |> maybe_sanitize_username()
+    |> maybe_sanitize_summary()
   end
+
+  @spec maybe_sanitize_username(map()) :: map()
+  defp maybe_sanitize_username(%{preferred_username: preferred_username} = args) do
+    Map.put(args, :preferred_username, preferred_username |> HTML.strip_tags() |> String.trim())
+  end
+
+  defp maybe_sanitize_username(args), do: args
+
+  @spec maybe_sanitize_summary(map()) :: map()
+  defp maybe_sanitize_summary(%{summary: summary} = args) do
+    {summary, _mentions, _tags} =
+      summary
+      |> String.trim()
+      |> APIUtils.make_content_html([], "text/html")
+
+    Map.put(args, :summary, summary)
+  end
+
+  defp maybe_sanitize_summary(args), do: args
 end

lib/graphql/resolvers/group.ex

@@ -9,7 +9,6 @@ defmodule Mobilizon.GraphQL.Resolvers.Group do
   alias Mobilizon.Federation.ActivityPub
   alias Mobilizon.GraphQL.API
   alias Mobilizon.GraphQL.Resolvers.Person
-  alias Mobilizon.Storage.Page
   alias Mobilizon.Users.User
 
   require Logger
@@ -271,7 +270,10 @@ defmodule Mobilizon.GraphQL.Resolvers.Group do
 
   def find_events_for_group(
         %Actor{id: group_id} = group,
-        _args,
+        %{
+          page: page,
+          limit: limit
+        } = args,
         %{
           context: %{
             current_user: %User{role: user_role} = user
@@ -282,15 +284,38 @@ defmodule Mobilizon.GraphQL.Resolvers.Group do
          {:member, true} <-
            {:member, Actors.is_member?(actor_id, group_id) or is_moderator(user_role)} do
       # TODO : Handle public / restricted to group members events
-      {:ok, Events.list_organized_events_for_group(group)}
+      {:ok,
+       Events.list_organized_events_for_group(
+         group,
+         :all,
+         Map.get(args, :after_datetime),
+         Map.get(args, :before_datetime),
+         page,
+         limit
+       )}
     else
       {:member, false} ->
-        {:ok, %Page{total: 0, elements: []}}
+        find_events_for_group(group, args, nil)
     end
   end
 
-  def find_events_for_group(_parent, _args, _resolution) do
-    {:ok, %Page{total: 0, elements: []}}
+  def find_events_for_group(
+        %Actor{} = group,
+        %{
+          page: page,
+          limit: limit
+        } = args,
+        _resolution
+      ) do
+    {:ok,
+     Events.list_organized_events_for_group(
+       group,
+       :public,
+       Map.get(args, :after_datetime),
+       Map.get(args, :before_datetime),
+       page,
+       limit
+     )}
   end
 
   defp restrict_fields_for_non_member_request(%Actor{} = group) do

lib/graphql/schema/actors/group.ex

@@ -54,6 +54,10 @@ defmodule Mobilizon.GraphQL.Schema.Actors.GroupType do
 
     # This one should have a privacy setting
     field :organized_events, :paginated_event_list do
+      arg(:after_datetime, :datetime, default_value: nil)
+      arg(:before_datetime, :datetime, default_value: nil)
+      arg(:page, :integer, default_value: 1)
+      arg(:limit, :integer, default_value: 10)
       resolve(&Group.find_events_for_group/3)
       description("A list of the events this actor has organized")
     end

lib/mobilizon/actors/actor.ex

@@ -179,8 +179,8 @@ defmodule Mobilizon.Actors.Actor do
   @doc """
   Checks whether actor visibility is public.
   """
-  @spec is_public_visibility(t) :: boolean
-  def is_public_visibility(%__MODULE__{visibility: visibility}) do
+  @spec is_public_visibility?(t) :: boolean
+  def is_public_visibility?(%__MODULE__{visibility: visibility}) do
     visibility in [:public, :unlisted]
   end
 

lib/mobilizon/events/events.ex

@@ -405,7 +405,7 @@ defmodule Mobilizon.Events do
   def list_public_events_for_actor(actor, page \\ nil, limit \\ nil)
 
   def list_public_events_for_actor(%Actor{type: :Group} = group, page, limit),
-    do: list_organized_events_for_group(group, page, limit)
+    do: list_organized_events_for_group(group, :public, nil, page, limit)
 
   def list_public_events_for_actor(%Actor{id: actor_id}, page, limit) do
     actor_id
@@ -424,10 +424,25 @@ defmodule Mobilizon.Events do
     |> Page.build_page(page, limit)
   end
 
-  @spec list_organized_events_for_group(Actor.t(), integer | nil, integer | nil) :: Page.t()
-  def list_organized_events_for_group(%Actor{id: group_id}, page \\ nil, limit \\ nil) do
+  @spec list_organized_events_for_group(
+          Actor.t(),
+          DateTime.t() | nil,
+          DateTime.t() | nil,
+          integer | nil,
+          integer | nil
+        ) :: Page.t()
+  def list_organized_events_for_group(
+        %Actor{id: group_id},
+        visibility \\ :public,
+        after_datetime \\ nil,
+        before_datetime \\ nil,
+        page \\ nil,
+        limit \\ nil
+      ) do
     group_id
     |> event_for_group_query()
+    |> event_filter_visibility(visibility)
+    |> event_filter_begins_on(after_datetime, before_datetime)
     |> preload_for_event()
     |> Page.build_page(page, limit)
   end
@@ -1643,6 +1658,45 @@ defmodule Mobilizon.Events do
     from(p in query, where: p.role == ^role)
   end
 
+  defp event_filter_visibility(query, :all), do: query
+
+  defp event_filter_visibility(query, :public) do
+    query
+    |> where(visibility: ^:public)
+  end
+
+  defp event_filter_begins_on(query, nil, nil),
+    do: event_order_begins_on_desc(query)
+
+  defp event_filter_begins_on(query, %DateTime{} = after_datetime, nil) do
+    query
+    |> where([e], e.begins_on > ^after_datetime)
+    |> event_order_begins_on_asc()
+  end
+
+  defp event_filter_begins_on(query, nil, %DateTime{} = before_datetime) do
+    query
+    |> where([e], e.begins_on < ^before_datetime)
+    |> event_order_begins_on_desc()
+  end
+
+  defp event_filter_begins_on(
+         query,
+         %DateTime{} = after_datetime,
+         %DateTime{} = before_datetime
+       ) do
+    query
+    |> where([e], e.begins_on < ^before_datetime)
+    |> where([e], e.begins_on > ^after_datetime)
+    |> event_order_begins_on_asc()
+  end
+
+  defp event_order_begins_on_asc(query),
+    do: order_by(query, [e], asc: e.begins_on)
+
+  defp event_order_begins_on_desc(query),
+    do: order_by(query, [e], desc: e.begins_on)
+
   defp participation_filter_begins_on(query, nil, nil),
     do: participation_order_begins_on_desc(query)
 

lib/service/export/feed.ex

@@ -46,7 +46,7 @@ defmodule Mobilizon.Service.Export.Feed do
   @spec fetch_actor_event_feed(String.t()) :: String.t()
   defp fetch_actor_event_feed(name) do
     with %Actor{} = actor <- Actors.get_local_actor_by_name(name),
-         {:visibility, true} <- {:visibility, Actor.is_public_visibility(actor)},
+         {:visibility, true} <- {:visibility, Actor.is_public_visibility?(actor)},
          %Page{elements: events} <- Events.list_public_events_for_actor(actor) do
       {:ok, build_actor_feed(actor, events)}
     else

lib/service/export/icalendar.ex

@@ -48,7 +48,7 @@ defmodule Mobilizon.Service.Export.ICalendar do
   """
   @spec export_public_actor(Actor.t()) :: String.t()
   def export_public_actor(%Actor{} = actor) do
-    with true <- Actor.is_public_visibility(actor),
+    with {:visibility, true} <- {:visibility, Actor.is_public_visibility?(actor)},
          %Page{elements: events} <-
            Events.list_public_events_for_actor(actor) do
       {:ok, %ICalendar{events: events |> Enum.map(&do_export_event/1)} |> ICalendar.to_ics()}

lib/web/controllers/feed_controller.ex

@@ -25,7 +25,7 @@ defmodule Mobilizon.Web.FeedController do
         |> put_resp_content_type("text/calendar")
         |> send_resp(200, data)
 
-      _ ->
+      _err ->
         {:error, :not_found}
     end
   end

lib/web/views/json_ld/object_view.ex

@@ -5,8 +5,8 @@ defmodule Mobilizon.Web.JsonLD.ObjectView do
   alias Mobilizon.Addresses.Address
   alias Mobilizon.Events.Event
   alias Mobilizon.Posts.Post
+  alias Mobilizon.Web.{Endpoint, MediaProxy}
   alias Mobilizon.Web.JsonLD.ObjectView
-  alias Mobilizon.Web.MediaProxy
 
   def render("group.json", %{group: %Actor{} = group}) do
     %{
@@ -37,18 +37,16 @@ defmodule Mobilizon.Web.JsonLD.ObjectView do
         if(event.status == :cancelled,
           do: "https://schema.org/EventCancelled",
           else: "https://schema.org/EventScheduled"
+        ),
+      "image" =>
+        if(event.picture,
+          do: [
+            event.picture.file.url |> MediaProxy.url()
+          ],
+          else: ["#{Endpoint.url()}/img/mobilizon_default_card.png"]
         )
     }
 
-    json_ld =
-      if event.picture do
-        Map.put(json_ld, "image", [
-          event.picture.file.url |> MediaProxy.url()
-        ])
-      else
-        json_ld
-      end
-
     json_ld =
       if event.begins_on,
         do: Map.put(json_ld, "startDate", DateTime.to_iso8601(event.begins_on)),