ponzischeme89
615 lines
21 KiB
Python
615 lines
21 KiB
Python
import asyncio
|
|
import logging
|
|
import re
|
|
from copy import deepcopy
|
|
from dataclasses import dataclass
|
|
from datetime import date, datetime, timedelta, timezone
|
|
from zoneinfo import ZoneInfo
|
|
|
|
from sqlalchemy import select
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
from app.database import AsyncSessionLocal
|
|
from app.models.member import AdminMessage, Booking, Member, MemberNotificationDispatch, Walk
|
|
from app.models.settings import SiteSettings
|
|
from app.services.sections import get_section
|
|
from app.services.settings import get_feature_settings_snapshot, get_settings
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
NZ_TZ = ZoneInfo("Pacific/Auckland")
|
|
AUTOMATION_INTERVAL_SECONDS = 3600
|
|
SERVICE_LABELS = {
|
|
"pack_walk": "Pack Walk",
|
|
"1_1_walk": "1-1 Walk",
|
|
"puppy_visit": "Puppy Visit",
|
|
}
|
|
DEFAULT_SENT_BY = "Goodwalk"
|
|
DEFAULT_INVOICE_DAY = 1
|
|
MATARIKI_DATES = {
|
|
2025: date(2025, 6, 20),
|
|
2026: date(2026, 7, 10),
|
|
2027: date(2027, 6, 25),
|
|
2028: date(2028, 7, 14),
|
|
2029: date(2029, 7, 6),
|
|
2030: date(2030, 6, 21),
|
|
2031: date(2031, 7, 11),
|
|
2032: date(2032, 7, 2),
|
|
2033: date(2033, 6, 24),
|
|
2034: date(2034, 7, 7),
|
|
2035: date(2035, 6, 29),
|
|
}
|
|
AUTOMATIC_NOTIFICATION_SECTION_KEY = "notifications.automaticMessages"
|
|
PUBLIC_HOLIDAY_NOTIFICATION_SECTION_KEY = "notifications.publicHolidays"
|
|
INVOICE_REMINDER_NOTIFICATION_SECTION_KEY = "notifications.invoiceReminders"
|
|
TEMPLATE_TOKEN_PATTERN = re.compile(r"{{\s*([a-zA-Z0-9_]+)\s*}}")
|
|
DEFAULT_AUTOMATIC_NOTIFICATION_TEMPLATES = {
|
|
"member_activated": {
|
|
"subject": "Your Goodwalk members account is now active",
|
|
"body": "Your onboarding is complete and your full members area is now ready. You can log in to view bookings, messages, walks, and your contract.",
|
|
},
|
|
"booking_confirmed": {
|
|
"subject": "Your Goodwalk booking has been confirmed",
|
|
"body": "Your {{service_label}} booking for {{requested_date_label}} has been confirmed. If anything changes, we will message you here.",
|
|
},
|
|
"booking_rescheduled": {
|
|
"subject": "Your Goodwalk booking has been rescheduled",
|
|
"body": "Your {{service_label}} has been moved to {{requested_date_label}}. If you have any questions, please get in touch.",
|
|
},
|
|
"booking_cancelled": {
|
|
"subject": "Your Goodwalk booking has been cancelled",
|
|
"body": "Your {{service_label}} booking for {{requested_date_label}} has been cancelled. Please contact us if you would like to arrange another time.",
|
|
},
|
|
"walk_completed": {
|
|
"subject": "Your Goodwalk walk is complete",
|
|
"body": "{{member_first_name}}, your {{service_label}} on {{walked_on_label}} has been marked as complete.{{walk_notes_sentence}}",
|
|
},
|
|
}
|
|
DEFAULT_PUBLIC_HOLIDAY_NOTIFICATION_TEMPLATE = {
|
|
"subject": "Goodwalk public holiday update: {{holiday_name}}",
|
|
"body": "Today is {{holiday_name}} in New Zealand. If you were expecting service changes or slower replies today, this is why. We will confirm any booking adjustments directly in your messages.",
|
|
}
|
|
DEFAULT_INVOICE_REMINDER_NOTIFICATION_TEMPLATE = {
|
|
"subject": "Invoice reminder from Goodwalk",
|
|
"body": "A quick reminder that invoices are scheduled to go out on {{weekday_label}}. This week that falls on {{invoice_date_label}}.",
|
|
}
|
|
|
|
|
|
@dataclass
|
|
class NotificationSettingsSnapshot:
|
|
automatic_member_notifications_enabled: bool = True
|
|
nz_public_holiday_notifications_enabled: bool = True
|
|
invoice_reminder_notifications_enabled: bool = True
|
|
invoice_day_of_week: int = DEFAULT_INVOICE_DAY
|
|
admin_notifications_cleared_before: datetime | None = None
|
|
|
|
|
|
@dataclass
|
|
class NotificationRunSummary:
|
|
automatic_member_notifications_enabled: bool
|
|
public_holiday_messages_sent: int = 0
|
|
invoice_reminders_sent: int = 0
|
|
|
|
|
|
@dataclass
|
|
class NotificationTemplateSnapshot:
|
|
automatic_messages: dict[str, dict[str, str]]
|
|
public_holidays: dict[str, str]
|
|
invoice_reminders: dict[str, str]
|
|
|
|
|
|
def _service_label(service_type: str | None) -> str:
|
|
return SERVICE_LABELS.get(service_type or "", service_type or "service")
|
|
|
|
|
|
def _weekday_label(weekday: int) -> str:
|
|
labels = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
|
|
return labels[weekday] if 0 <= weekday < len(labels) else labels[DEFAULT_INVOICE_DAY]
|
|
|
|
|
|
def _format_nz_date(day: datetime | date, *, include_year: bool = False) -> str:
|
|
if isinstance(day, datetime):
|
|
local_day = day.astimezone(NZ_TZ)
|
|
base = local_day.date()
|
|
else:
|
|
base = day
|
|
|
|
month = base.strftime("%B")
|
|
weekday = base.strftime("%A")
|
|
if include_year:
|
|
return f"{weekday} {base.day} {month} {base.year}"
|
|
return f"{weekday} {base.day} {month}"
|
|
|
|
|
|
def _shift_single_holiday(day: date) -> date:
|
|
if day.weekday() == 5:
|
|
return day + timedelta(days=2)
|
|
if day.weekday() == 6:
|
|
return day + timedelta(days=1)
|
|
return day
|
|
|
|
|
|
def _observed_pair(day_one: date, day_two: date) -> list[date]:
|
|
observed: list[date] = []
|
|
|
|
for actual in [day_one, day_two]:
|
|
candidate = actual
|
|
if candidate.weekday() >= 5:
|
|
candidate += timedelta(days=7 - candidate.weekday())
|
|
while candidate in observed:
|
|
candidate += timedelta(days=1)
|
|
observed.append(candidate)
|
|
|
|
return observed
|
|
|
|
|
|
def _nth_weekday(year: int, month: int, weekday: int, occurrence: int) -> date:
|
|
first = date(year, month, 1)
|
|
offset = (weekday - first.weekday()) % 7
|
|
return first + timedelta(days=offset + (occurrence - 1) * 7)
|
|
|
|
|
|
def _easter_sunday(year: int) -> date:
|
|
a = year % 19
|
|
b = year // 100
|
|
c = year % 100
|
|
d = b // 4
|
|
e = b % 4
|
|
f = (b + 8) // 25
|
|
g = (b - f + 1) // 3
|
|
h = (19 * a + b - d - g + 15) % 30
|
|
i = c // 4
|
|
k = c % 4
|
|
l = (32 + 2 * e + 2 * i - h - k) % 7
|
|
m = (a + 11 * h + 22 * l) // 451
|
|
month = (h + l - 7 * m + 114) // 31
|
|
day = ((h + l - 7 * m + 114) % 31) + 1
|
|
return date(year, month, day)
|
|
|
|
|
|
def nz_public_holidays_for_year(year: int) -> dict[date, str]:
|
|
easter = _easter_sunday(year)
|
|
new_year, day_after = _observed_pair(date(year, 1, 1), date(year, 1, 2))
|
|
christmas, boxing = _observed_pair(date(year, 12, 25), date(year, 12, 26))
|
|
|
|
holidays = {
|
|
new_year: "New Year's Day",
|
|
day_after: "Day after New Year's Day",
|
|
_shift_single_holiday(date(year, 2, 6)): "Waitangi Day",
|
|
easter - timedelta(days=2): "Good Friday",
|
|
easter + timedelta(days=1): "Easter Monday",
|
|
_shift_single_holiday(date(year, 4, 25)): "ANZAC Day",
|
|
_nth_weekday(year, 6, 0, 1): "King's Birthday",
|
|
_nth_weekday(year, 10, 0, 4): "Labour Day",
|
|
christmas: "Christmas Day",
|
|
boxing: "Boxing Day",
|
|
}
|
|
|
|
matariki = MATARIKI_DATES.get(year)
|
|
if matariki is not None:
|
|
holidays[matariki] = "Matariki"
|
|
|
|
return holidays
|
|
|
|
|
|
def nz_public_holiday_name(day: date) -> str | None:
|
|
return nz_public_holidays_for_year(day.year).get(day)
|
|
|
|
|
|
def _normalize_template_text(value: object, fallback: str) -> str:
|
|
if isinstance(value, str):
|
|
trimmed = value.strip()
|
|
if trimmed:
|
|
return trimmed
|
|
return fallback
|
|
|
|
|
|
def _normalize_subject_body_template(data: object, fallback: dict[str, str]) -> dict[str, str]:
|
|
source = data if isinstance(data, dict) else {}
|
|
return {
|
|
"subject": _normalize_template_text(source.get("subject"), fallback["subject"]),
|
|
"body": _normalize_template_text(source.get("body"), fallback["body"]),
|
|
}
|
|
|
|
|
|
async def get_notification_template_snapshot(db: AsyncSession) -> NotificationTemplateSnapshot:
|
|
automatic_section = await get_section(db, AUTOMATIC_NOTIFICATION_SECTION_KEY)
|
|
automatic_templates = deepcopy(DEFAULT_AUTOMATIC_NOTIFICATION_TEMPLATES)
|
|
automatic_source = automatic_section.get("templates") if isinstance(automatic_section, dict) else {}
|
|
if isinstance(automatic_source, dict):
|
|
for template_key, fallback in DEFAULT_AUTOMATIC_NOTIFICATION_TEMPLATES.items():
|
|
automatic_templates[template_key] = _normalize_subject_body_template(
|
|
automatic_source.get(template_key),
|
|
fallback,
|
|
)
|
|
|
|
public_holiday_section = await get_section(db, PUBLIC_HOLIDAY_NOTIFICATION_SECTION_KEY)
|
|
invoice_reminder_section = await get_section(db, INVOICE_REMINDER_NOTIFICATION_SECTION_KEY)
|
|
|
|
return NotificationTemplateSnapshot(
|
|
automatic_messages=automatic_templates,
|
|
public_holidays=_normalize_subject_body_template(
|
|
public_holiday_section,
|
|
DEFAULT_PUBLIC_HOLIDAY_NOTIFICATION_TEMPLATE,
|
|
),
|
|
invoice_reminders=_normalize_subject_body_template(
|
|
invoice_reminder_section,
|
|
DEFAULT_INVOICE_REMINDER_NOTIFICATION_TEMPLATE,
|
|
),
|
|
)
|
|
|
|
|
|
def _render_template_text(template: str, context: dict[str, object]) -> str:
|
|
def replace(match: re.Match[str]) -> str:
|
|
return str(context.get(match.group(1), ""))
|
|
|
|
return TEMPLATE_TOKEN_PATTERN.sub(replace, template).strip()
|
|
|
|
|
|
def _render_subject_body_template(template: dict[str, str], context: dict[str, object]) -> tuple[str, str]:
|
|
return (
|
|
_render_template_text(template["subject"], context),
|
|
_render_template_text(template["body"], context),
|
|
)
|
|
|
|
|
|
async def get_notification_settings_snapshot(db: AsyncSession) -> NotificationSettingsSnapshot:
|
|
row = await get_settings(db)
|
|
if row is None:
|
|
return NotificationSettingsSnapshot()
|
|
|
|
return NotificationSettingsSnapshot(
|
|
automatic_member_notifications_enabled=row.automatic_member_notifications_enabled,
|
|
nz_public_holiday_notifications_enabled=row.nz_public_holiday_notifications_enabled,
|
|
invoice_reminder_notifications_enabled=row.invoice_reminder_notifications_enabled,
|
|
invoice_day_of_week=row.invoice_day_of_week,
|
|
admin_notifications_cleared_before=row.admin_notifications_cleared_before,
|
|
)
|
|
|
|
|
|
async def update_notification_settings_snapshot(
|
|
db: AsyncSession,
|
|
*,
|
|
automatic_member_notifications_enabled: bool | None = None,
|
|
nz_public_holiday_notifications_enabled: bool | None = None,
|
|
invoice_reminder_notifications_enabled: bool | None = None,
|
|
invoice_day_of_week: int | None = None,
|
|
admin_notifications_cleared_before: datetime | None = None,
|
|
) -> NotificationSettingsSnapshot:
|
|
row = await get_settings(db)
|
|
if row is None:
|
|
row = SiteSettings(site_name="")
|
|
db.add(row)
|
|
await db.flush()
|
|
|
|
if automatic_member_notifications_enabled is not None:
|
|
row.automatic_member_notifications_enabled = automatic_member_notifications_enabled
|
|
if nz_public_holiday_notifications_enabled is not None:
|
|
row.nz_public_holiday_notifications_enabled = nz_public_holiday_notifications_enabled
|
|
if invoice_reminder_notifications_enabled is not None:
|
|
row.invoice_reminder_notifications_enabled = invoice_reminder_notifications_enabled
|
|
if invoice_day_of_week is not None:
|
|
if invoice_day_of_week < 0 or invoice_day_of_week > 6:
|
|
raise ValueError("invoice_day_of_week must be between 0 and 6")
|
|
row.invoice_day_of_week = invoice_day_of_week
|
|
if admin_notifications_cleared_before is not None:
|
|
row.admin_notifications_cleared_before = admin_notifications_cleared_before
|
|
|
|
await db.flush()
|
|
await db.refresh(row)
|
|
return await get_notification_settings_snapshot(db)
|
|
|
|
|
|
async def create_member_message(
|
|
db: AsyncSession,
|
|
*,
|
|
member: Member,
|
|
subject: str,
|
|
body: str,
|
|
sent_by: str = DEFAULT_SENT_BY,
|
|
automatic: bool = False,
|
|
dispatch_key: str | None = None,
|
|
notification_type: str | None = None,
|
|
respect_preferences: bool = True,
|
|
) -> AdminMessage | None:
|
|
feature_settings = await get_feature_settings_snapshot(db)
|
|
if not feature_settings.messages_enabled:
|
|
return None
|
|
|
|
if respect_preferences and not member.notifications_enabled:
|
|
return None
|
|
|
|
if automatic:
|
|
settings = await get_notification_settings_snapshot(db)
|
|
if not settings.automatic_member_notifications_enabled:
|
|
return None
|
|
|
|
if dispatch_key is not None:
|
|
existing = await db.execute(
|
|
select(MemberNotificationDispatch).where(
|
|
MemberNotificationDispatch.member_id == member.id,
|
|
MemberNotificationDispatch.dispatch_key == dispatch_key,
|
|
)
|
|
)
|
|
if existing.scalars().first() is not None:
|
|
return None
|
|
|
|
db.add(
|
|
MemberNotificationDispatch(
|
|
member_id=member.id,
|
|
notification_type=notification_type or "notification",
|
|
dispatch_key=dispatch_key,
|
|
metadata_json={"automatic": automatic},
|
|
)
|
|
)
|
|
|
|
message = AdminMessage(
|
|
member_id=member.id,
|
|
subject=subject,
|
|
body=body,
|
|
sent_by=sent_by,
|
|
)
|
|
db.add(message)
|
|
await db.flush()
|
|
return message
|
|
|
|
|
|
async def send_account_activated_notification(
|
|
db: AsyncSession,
|
|
member: Member,
|
|
*,
|
|
templates: NotificationTemplateSnapshot | None = None,
|
|
) -> AdminMessage | None:
|
|
templates = templates or await get_notification_template_snapshot(db)
|
|
subject, body = _render_subject_body_template(
|
|
templates.automatic_messages["member_activated"],
|
|
{
|
|
"member_first_name": member.first_name,
|
|
"member_last_name": member.last_name,
|
|
},
|
|
)
|
|
return await create_member_message(
|
|
db,
|
|
member=member,
|
|
subject=subject,
|
|
body=body,
|
|
automatic=True,
|
|
dispatch_key=f"member_activated:{member.id}:{member.activated_at.isoformat() if member.activated_at else 'pending'}",
|
|
notification_type="member_activated",
|
|
)
|
|
|
|
|
|
async def send_booking_status_notification(
|
|
db: AsyncSession,
|
|
member: Member,
|
|
booking: Booking,
|
|
*,
|
|
templates: NotificationTemplateSnapshot | None = None,
|
|
) -> AdminMessage | None:
|
|
if booking.status not in {"confirmed", "cancelled"}:
|
|
return None
|
|
|
|
templates = templates or await get_notification_template_snapshot(db)
|
|
requested = _format_nz_date(booking.requested_date, include_year=True) if booking.requested_date else "the requested date"
|
|
service_name = _service_label(booking.service_type)
|
|
|
|
if booking.status == "confirmed":
|
|
template = templates.automatic_messages["booking_confirmed"]
|
|
else:
|
|
template = templates.automatic_messages["booking_cancelled"]
|
|
|
|
subject, body = _render_subject_body_template(
|
|
template,
|
|
{
|
|
"member_first_name": member.first_name,
|
|
"member_last_name": member.last_name,
|
|
"service_label": service_name,
|
|
"requested_date_label": requested,
|
|
"booking_status": booking.status,
|
|
},
|
|
)
|
|
|
|
return await create_member_message(
|
|
db,
|
|
member=member,
|
|
subject=subject,
|
|
body=body,
|
|
automatic=True,
|
|
dispatch_key=f"booking_status:{booking.id}:{booking.status}",
|
|
notification_type="booking_status",
|
|
)
|
|
|
|
|
|
async def send_booking_rescheduled_notification(
|
|
db: AsyncSession,
|
|
member: Member,
|
|
booking: Booking,
|
|
*,
|
|
templates: NotificationTemplateSnapshot | None = None,
|
|
) -> AdminMessage | None:
|
|
templates = templates or await get_notification_template_snapshot(db)
|
|
requested = _format_nz_date(booking.requested_date, include_year=True) if booking.requested_date else "a new date"
|
|
service_name = _service_label(booking.service_type)
|
|
|
|
subject, body = _render_subject_body_template(
|
|
templates.automatic_messages["booking_rescheduled"],
|
|
{
|
|
"member_first_name": member.first_name,
|
|
"member_last_name": member.last_name,
|
|
"service_label": service_name,
|
|
"requested_date_label": requested,
|
|
},
|
|
)
|
|
|
|
return await create_member_message(
|
|
db,
|
|
member=member,
|
|
subject=subject,
|
|
body=body,
|
|
automatic=True,
|
|
dispatch_key=f"booking_rescheduled:{booking.id}:{booking.requested_date.isoformat() if booking.requested_date else 'none'}",
|
|
notification_type="booking_rescheduled",
|
|
)
|
|
|
|
|
|
async def send_walk_completed_notification(
|
|
db: AsyncSession,
|
|
member: Member,
|
|
walk: Walk,
|
|
*,
|
|
templates: NotificationTemplateSnapshot | None = None,
|
|
) -> AdminMessage | None:
|
|
templates = templates or await get_notification_template_snapshot(db)
|
|
walked_on = _format_nz_date(walk.walked_at)
|
|
service_name = _service_label(walk.service_type)
|
|
subject, body = _render_subject_body_template(
|
|
templates.automatic_messages["walk_completed"],
|
|
{
|
|
"member_first_name": member.first_name,
|
|
"member_last_name": member.last_name,
|
|
"service_label": service_name,
|
|
"walked_on_label": walked_on,
|
|
"walk_notes": walk.notes or "",
|
|
"walk_notes_sentence": f" Notes from the team: {walk.notes}" if walk.notes else "",
|
|
},
|
|
)
|
|
|
|
return await create_member_message(
|
|
db,
|
|
member=member,
|
|
subject=subject,
|
|
body=body,
|
|
automatic=True,
|
|
dispatch_key=f"walk_completed:{walk.id}",
|
|
notification_type="walk_completed",
|
|
)
|
|
|
|
|
|
async def send_public_holiday_notification(
|
|
db: AsyncSession,
|
|
member: Member,
|
|
holiday_date: date,
|
|
holiday_name: str,
|
|
*,
|
|
templates: NotificationTemplateSnapshot | None = None,
|
|
) -> AdminMessage | None:
|
|
templates = templates or await get_notification_template_snapshot(db)
|
|
subject, body = _render_subject_body_template(
|
|
templates.public_holidays,
|
|
{
|
|
"member_first_name": member.first_name,
|
|
"member_last_name": member.last_name,
|
|
"holiday_name": holiday_name,
|
|
"holiday_date_label": _format_nz_date(holiday_date, include_year=True),
|
|
},
|
|
)
|
|
return await create_member_message(
|
|
db,
|
|
member=member,
|
|
subject=subject,
|
|
body=body,
|
|
automatic=True,
|
|
dispatch_key=f"public_holiday:{holiday_date.isoformat()}",
|
|
notification_type="public_holiday",
|
|
)
|
|
|
|
|
|
async def send_invoice_day_notification(
|
|
db: AsyncSession,
|
|
member: Member,
|
|
invoice_date: date,
|
|
weekday_label: str,
|
|
*,
|
|
templates: NotificationTemplateSnapshot | None = None,
|
|
) -> AdminMessage | None:
|
|
templates = templates or await get_notification_template_snapshot(db)
|
|
subject, body = _render_subject_body_template(
|
|
templates.invoice_reminders,
|
|
{
|
|
"member_first_name": member.first_name,
|
|
"member_last_name": member.last_name,
|
|
"weekday_label": weekday_label,
|
|
"invoice_date_label": _format_nz_date(invoice_date),
|
|
},
|
|
)
|
|
return await create_member_message(
|
|
db,
|
|
member=member,
|
|
subject=subject,
|
|
body=body,
|
|
automatic=True,
|
|
dispatch_key=f"invoice_reminder:{invoice_date.isoformat()}",
|
|
notification_type="invoice_reminder",
|
|
)
|
|
|
|
|
|
async def run_automatic_notifications(
|
|
db: AsyncSession,
|
|
*,
|
|
now: datetime | None = None,
|
|
) -> NotificationRunSummary:
|
|
settings = await get_notification_settings_snapshot(db)
|
|
summary = NotificationRunSummary(
|
|
automatic_member_notifications_enabled=settings.automatic_member_notifications_enabled,
|
|
)
|
|
|
|
if not settings.automatic_member_notifications_enabled:
|
|
return summary
|
|
|
|
templates = await get_notification_template_snapshot(db)
|
|
|
|
local_now = (now or datetime.now(timezone.utc)).astimezone(NZ_TZ)
|
|
local_date = local_now.date()
|
|
|
|
result = await db.execute(
|
|
select(Member).where(
|
|
Member.is_active == True, # noqa: E712
|
|
Member.member_status == "active",
|
|
Member.notifications_enabled == True, # noqa: E712
|
|
)
|
|
)
|
|
members = result.scalars().all()
|
|
|
|
if settings.nz_public_holiday_notifications_enabled:
|
|
holiday_name = nz_public_holiday_name(local_date)
|
|
if holiday_name:
|
|
for member in members:
|
|
created = await send_public_holiday_notification(
|
|
db,
|
|
member,
|
|
local_date,
|
|
holiday_name,
|
|
templates=templates,
|
|
)
|
|
if created is not None:
|
|
summary.public_holiday_messages_sent += 1
|
|
|
|
if settings.invoice_reminder_notifications_enabled and local_date.weekday() == settings.invoice_day_of_week:
|
|
weekday_label = _weekday_label(settings.invoice_day_of_week)
|
|
for member in members:
|
|
created = await send_invoice_day_notification(
|
|
db,
|
|
member,
|
|
local_date,
|
|
weekday_label,
|
|
templates=templates,
|
|
)
|
|
if created is not None:
|
|
summary.invoice_reminders_sent += 1
|
|
|
|
return summary
|
|
|
|
|
|
async def notification_automation_loop() -> None:
|
|
while True:
|
|
try:
|
|
async with AsyncSessionLocal() as session:
|
|
await run_automatic_notifications(session)
|
|
await session.commit()
|
|
except asyncio.CancelledError:
|
|
raise
|
|
except Exception:
|
|
logger.exception("Automatic member notification loop failed.")
|
|
|
|
await asyncio.sleep(AUTOMATION_INTERVAL_SECONDS)
|