mirror of
https://framagit.org/framasoft/mobilizon.git
synced 2024-12-23 00:14:48 +00:00
999a33c7c3
Signed-off-by: Thomas Citharel <tcit@tcit.fr>
329 lines
10 KiB
Elixir
329 lines
10 KiB
Elixir
defmodule Mobilizon.Service.Notifications.Scheduler do
|
|
@moduledoc """
|
|
Allows to insert jobs
|
|
"""
|
|
|
|
alias Mobilizon.{Actors, Users}
|
|
alias Mobilizon.Actors.{Actor, Member}
|
|
alias Mobilizon.Events.{Event, Participant}
|
|
alias Mobilizon.Service.Workers.Notification
|
|
alias Mobilizon.Users.{Setting, User}
|
|
|
|
import Mobilizon.Service.DateTime,
|
|
only: [
|
|
datetime_tz_convert: 2,
|
|
calculate_first_day_of_week: 2,
|
|
calculate_next_day_notification: 2,
|
|
calculate_next_week_notification: 2
|
|
]
|
|
|
|
require Logger
|
|
|
|
@spec trigger_notifications_for_participant(Participant.t()) :: {:ok, Oban.Job.t() | nil}
|
|
def trigger_notifications_for_participant(%Participant{} = participant) do
|
|
before_event_notification(participant)
|
|
on_day_notification(participant)
|
|
weekly_notification(participant)
|
|
{:ok, nil}
|
|
end
|
|
|
|
@spec before_event_notification(Participant.t()) :: {:ok, nil}
|
|
def before_event_notification(%Participant{
|
|
id: participant_id,
|
|
event: %Event{begins_on: begins_on},
|
|
actor: %Actor{user_id: user_id}
|
|
})
|
|
when not is_nil(user_id) do
|
|
case Users.get_setting(user_id) do
|
|
%Setting{notification_before_event: true} ->
|
|
Notification.enqueue(:before_event_notification, %{participant_id: participant_id},
|
|
scheduled_at: DateTime.add(begins_on, -3600, :second)
|
|
)
|
|
|
|
_ ->
|
|
{:ok, nil}
|
|
end
|
|
end
|
|
|
|
def before_event_notification(_), do: {:ok, nil}
|
|
|
|
@spec on_day_notification(Participant.t()) :: {:ok, Oban.Job.t() | nil | String.t()}
|
|
def on_day_notification(%Participant{
|
|
event: %Event{begins_on: begins_on},
|
|
actor: %Actor{user_id: user_id}
|
|
})
|
|
when not is_nil(user_id) do
|
|
case Users.get_setting(user_id) do
|
|
%Setting{notification_on_day: true, timezone: timezone} ->
|
|
%DateTime{hour: hour} = begins_on_shifted = datetime_tz_convert(begins_on, timezone)
|
|
Logger.debug("Participation event start at #{inspect(begins_on_shifted)} (user timezone)")
|
|
|
|
send_date =
|
|
cond do
|
|
DateTime.compare(begins_on, DateTime.utc_now()) == :lt ->
|
|
nil
|
|
|
|
hour > 8 ->
|
|
# If the event is after 8 o'clock
|
|
%{begins_on_shifted | hour: 8, minute: 0, second: 0, microsecond: {0, 0}}
|
|
|
|
true ->
|
|
# If the event is before 8 o'clock, we send the notification the day before,
|
|
# unless this is already passed
|
|
begins_on_shifted
|
|
|> DateTime.add(-24 * 3_600)
|
|
|> (&%{&1 | hour: 8, minute: 0, second: 0, microsecond: {0, 0}}).()
|
|
end
|
|
|
|
Logger.debug(
|
|
"Participation notification should be sent at #{inspect(send_date)} (user timezone)"
|
|
)
|
|
|
|
if is_nil(send_date) or DateTime.compare(DateTime.utc_now(), send_date) == :gt do
|
|
{:ok, "Too late to send same day notifications"}
|
|
else
|
|
Notification.enqueue(:on_day_notification, %{user_id: user_id}, scheduled_at: send_date)
|
|
end
|
|
|
|
_ ->
|
|
{:ok, "User has disable on day notifications"}
|
|
end
|
|
end
|
|
|
|
def on_day_notification(_), do: {:ok, nil}
|
|
|
|
@spec weekly_notification(Participant.t()) :: {:ok, Oban.Job.t() | nil | String.t()}
|
|
def weekly_notification(%Participant{
|
|
event: %Event{begins_on: begins_on},
|
|
actor: %Actor{user_id: user_id}
|
|
})
|
|
when not is_nil(user_id) do
|
|
%User{settings: settings, locale: locale} = Users.get_user_with_settings!(user_id)
|
|
|
|
case settings do
|
|
%Setting{notification_each_week: true, timezone: timezone} ->
|
|
%DateTime{} = begins_on_shifted = datetime_tz_convert(begins_on, timezone)
|
|
|
|
Logger.debug(
|
|
"Participation event start at #{inspect(begins_on_shifted)} (user timezone is #{timezone})"
|
|
)
|
|
|
|
notification_date =
|
|
if Date.compare(begins_on, DateTime.utc_now()) == :gt do
|
|
notification_day = calculate_first_day_of_week(DateTime.to_date(begins_on), locale)
|
|
|
|
{:ok, %NaiveDateTime{} = notification_date} =
|
|
notification_day |> NaiveDateTime.new(~T[08:00:00])
|
|
|
|
# This is the datetime when the notification should be sent
|
|
{:ok, %DateTime{} = notification_date} =
|
|
DateTime.from_naive(notification_date, timezone)
|
|
|
|
if Date.compare(notification_date, DateTime.utc_now()) == :gt do
|
|
notification_date
|
|
else
|
|
nil
|
|
end
|
|
else
|
|
nil
|
|
end
|
|
|
|
Logger.debug(
|
|
"Participation notification should be sent at #{inspect(notification_date)} (user timezone)"
|
|
)
|
|
|
|
if is_nil(notification_date) do
|
|
{:ok, "Too late to send weekly notifications"}
|
|
else
|
|
Notification.enqueue(:weekly_notification, %{user_id: user_id},
|
|
scheduled_at: notification_date
|
|
)
|
|
end
|
|
|
|
_ ->
|
|
{:ok, "User has disabled weekly notifications"}
|
|
end
|
|
end
|
|
|
|
def weekly_notification(_), do: {:ok, nil}
|
|
|
|
@spec pending_participation_notification(Event.t(), Keyword.t()) :: {:ok, Oban.Job.t() | nil}
|
|
def pending_participation_notification(event, options \\ [])
|
|
|
|
def pending_participation_notification(
|
|
%Event{
|
|
id: event_id,
|
|
organizer_actor_id: organizer_actor_id,
|
|
local: true,
|
|
begins_on: begins_on
|
|
},
|
|
options
|
|
) do
|
|
with %Actor{user_id: user_id} when not is_nil(user_id) <-
|
|
Actors.get_actor(organizer_actor_id),
|
|
%User{
|
|
locale: locale,
|
|
settings: %Setting{
|
|
notification_pending_participation: notification_pending_participation,
|
|
timezone: timezone
|
|
}
|
|
} <- Users.get_user_with_settings!(user_id) do
|
|
compare_to = Keyword.get(options, :compare_to, DateTime.utc_now())
|
|
|
|
send_at =
|
|
determine_send_at(notification_pending_participation, begins_on,
|
|
compare_to: compare_to,
|
|
timezone: timezone,
|
|
locale: locale
|
|
)
|
|
|
|
params = %{
|
|
user_id: user_id,
|
|
event_id: event_id
|
|
}
|
|
|
|
Logger.debug("Determining when we should send the pending participation notification")
|
|
|
|
cond do
|
|
# Sending directly
|
|
send_at == :direct ->
|
|
Logger.debug("The notification will be sent straight away!")
|
|
|
|
{:ok, %Oban.Job{id: job_id}} =
|
|
Notification.enqueue(:pending_participation_notification, params)
|
|
|
|
Logger.debug("Job scheduled with ID #{job_id}")
|
|
|
|
# Not sending
|
|
is_nil(send_at) ->
|
|
Logger.debug("We will not send any notification")
|
|
{:ok, nil}
|
|
|
|
# Sending to calculated time
|
|
DateTime.compare(begins_on, send_at) == :gt ->
|
|
Logger.debug("We will send the notification on #{send_at}")
|
|
|
|
{:ok, %Oban.Job{id: job_id}} =
|
|
Notification.enqueue(:pending_participation_notification, params,
|
|
scheduled_at: send_at
|
|
)
|
|
|
|
Logger.debug("Job scheduled with ID #{job_id}")
|
|
|
|
true ->
|
|
Logger.debug(
|
|
"Something went wrong when determining when to send the pending participation notification"
|
|
)
|
|
|
|
{:ok, nil}
|
|
end
|
|
else
|
|
_ -> {:ok, nil}
|
|
end
|
|
end
|
|
|
|
def pending_participation_notification(_, _), do: {:ok, nil}
|
|
|
|
def pending_membership_notification(%Actor{type: :Group, id: group_id}) do
|
|
group_id
|
|
|> Actors.list_all_administrator_members_for_group()
|
|
|> Enum.map(fn %Member{actor: %Actor{id: actor_id}} ->
|
|
Actors.get_actor(actor_id)
|
|
end)
|
|
|> Enum.each(fn actor -> pending_membership_admin_notification(actor, group_id) end)
|
|
end
|
|
|
|
def pending_membership_notification(_), do: {:ok, nil}
|
|
|
|
defp pending_membership_admin_notification(%Actor{user_id: user_id}, group_id)
|
|
when not is_nil(user_id) do
|
|
case Users.get_user_with_settings!(user_id) do
|
|
%User{} = user ->
|
|
pending_membership_admin_notification_user(user, group_id)
|
|
|
|
# No user for actor, probably a remote actor, ignore
|
|
_ ->
|
|
{:ok, nil}
|
|
end
|
|
end
|
|
|
|
defp pending_membership_admin_notification_user(
|
|
%User{
|
|
id: user_id,
|
|
settings: %Setting{
|
|
notification_pending_membership: notification_pending_membership,
|
|
timezone: timezone
|
|
}
|
|
},
|
|
group_id
|
|
) do
|
|
send_at =
|
|
case notification_pending_membership do
|
|
:none ->
|
|
nil
|
|
|
|
:direct ->
|
|
:direct
|
|
|
|
:one_day ->
|
|
calculate_next_day_notification(Date.utc_today(), timezone: timezone)
|
|
|
|
:one_hour ->
|
|
DateTime.utc_now()
|
|
|> DateTime.shift_zone!(timezone)
|
|
|> (&%{&1 | minute: 0, second: 0, microsecond: {0, 0}}).()
|
|
end
|
|
|
|
params = %{
|
|
user_id: user_id,
|
|
group_id: group_id
|
|
}
|
|
|
|
cond do
|
|
# Sending directly
|
|
send_at == :direct ->
|
|
Notification.enqueue(:pending_membership_notification, params)
|
|
|
|
# Not sending
|
|
is_nil(send_at) ->
|
|
{:ok, nil}
|
|
|
|
# Sending to calculated time
|
|
match?(%DateTime{}, send_at) ->
|
|
Notification.enqueue(:pending_membership_notification, params, scheduled_at: send_at)
|
|
end
|
|
end
|
|
|
|
defp determine_send_at(notification_pending_participation, begins_on, options) do
|
|
timezone = Keyword.get(options, :timezone, "Etc/UTC")
|
|
locale = Keyword.get(options, :locale, "en")
|
|
compare_to = Keyword.get(options, :compare_to, DateTime.utc_now())
|
|
|
|
case notification_pending_participation do
|
|
:none ->
|
|
nil
|
|
|
|
:direct ->
|
|
:direct
|
|
|
|
:one_day ->
|
|
calculate_next_day_notification(DateTime.to_date(compare_to),
|
|
timezone: timezone,
|
|
compare_to: compare_to
|
|
)
|
|
|
|
:one_week ->
|
|
calculate_next_week_notification(begins_on,
|
|
timezone: timezone,
|
|
locale: locale,
|
|
compare_to: compare_to
|
|
)
|
|
|
|
:one_hour ->
|
|
compare_to
|
|
|> DateTime.add(3600)
|
|
|> DateTime.shift_zone!(timezone)
|
|
|> (&%{&1 | minute: 0, second: 0, microsecond: {0, 0}}).()
|
|
end
|
|
end
|
|
end
|