marc
/
room-booking
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: marc:1.3.0
Branches Tags
marc:main
marc:1.4.0
marc:1.3.0
marc:1.2.3
marc:1.1.0
marc:1.0.4
marc:1.0.3
marc:1.0.2
marc:1.0.1
marc:1.0.0
..
compare: marc:main
Branches Tags
marc:main
marc:1.4.0
marc:1.3.0
marc:1.2.3
marc:1.1.0
marc:1.0.4
marc:1.0.3
marc:1.0.2
marc:1.0.1
marc:1.0.0

No commits in common. "1.3.0" and "main" have entirely different histories.
1.3.0 ... main

6 changed files with 274 additions and 483 deletions
Show Stats Expand all files Collapse all files

40
README.md
View File

@ -35,7 +35,6 @@ with the following JSON payload:
```
Curl example:
```bash
curl -s \
-H "Authorization: Bearer secrettoken" \
@ -47,18 +46,14 @@ Curl example:
The response will contain the event ID:
```json
{
"id": "4zx3QAFzoxV3vaZSKGaH2S"
}
{"id": "4zx3QAFzoxV3vaZSKGaH2S"}
```
### Delete an event
To delete an event, you need to send a DELETE request to
`/api/{calendar}/events/{event_id}`.
To delete an event, you need to send a DELETE request to `/api/{calendar}/events/{event_id}`.
Curl example:
```bash
curl -s -X DELETE \
-H "Authorization: Bearer secrettoken" \
@ -81,7 +76,6 @@ The following parameters can be passed as query parameters:
return what would be deleted.
Curl example:
```bash
curl -s -X DELETE \
-H "Authorization: Bearer secrettoken" \
@ -165,30 +159,22 @@ Email templates can be configured in the Django Admin interface. Jinja2 syntax
is used for the templates. The following variables are available in the
templates:
- `booking` - The booking that was declined
- `calendar_name` - The name of the calendar
**Lists**
- `overlap_bookings` - A list of overlap bookings, each containing:
- `other_bookings` - A list of other bookings at the same day(s) as the declined
- `overview` - A list of all bookings in the calendar for the day(s) of the
declined booking
- `alternatives` - List of alternative calendars (rooms) for the time slot of
the
**Attributes**
Each event has the following attributes:
- `uid` - The unique ID of the event
- `name` - The name of the event
- `start` - The start time (datetime) of the event
- `end` - The end time (datetime) of the event
- `duration` - The duration of the event (timedelta)
- `created` - The datetime the event was created
- `status` - The status of the event
- `organizer` - The organizer of the event
- `is_deleted` - Whether the event was deleted
- `is_cancelled` - Whether the event was cancelled
- `is_recurring` - Whether the event is recurring
- `is_prioritized` - Whether the event is prioritized
- `is_deleted` - Whether the event was deleted
- `is_priorized` - Whether the event is prioritized
- `is_deprioritized` - Whether the event is deprioritized in favor of another
event
- `organizer` - The organizer of the event
- `overlap_events` - A list of overlap events, each containing:
- `name` - The name of the overlap event
- `start` - The start time (datetime) of the overlap event
- `end` - The end time (datetime) of the overlap event
- `created` - The datetime the overlap event was created
- `organizer` - The organizer of the overlap event
- `is_priorized` - Whether the overlap event is prioritized
- `calendar_name` - The name of the calendar

45
src/booking.py
View File

@ -74,12 +74,29 @@ class EmailTemplate(models.Model):
id = models.AutoField(primary_key=True)
name = models.CharField(max_length=100, unique=True)
subject = models.CharField(max_length=200)
plaintext = models.TextField(blank=True, help_text="""\
body = models.TextField(help_text="""\
Email template to use for sending notifications about deleted events.<br>
If not set, no email will be sent.<br>
Jinja2 template syntax can be used in the subject and body.<br>
See README.md for a list of available variables.""")
html = models.TextField(blank=True, help_text="""\
Jinja2 template syntax can be used in the subject and body.<br>
See README.md for a list of available variables.""")
Available variables:<br>
- name: The name of the event<br>
- start: The start time (datetime) of the event<br>
- end: The end time (datetime) of the event<br>
- created: The datetime the event was created<br>
- is_deleted: Whether the event was deleted<br>
- is_cancelled: Whether the event was cancelled<br>
- is_recurring: Whether the event is recurring<br>
- organizer: The organizer of the event<br>
- is_prioritized: Whether the event is prioritized<br>
- is_deprioritized: Whether the event was deprioritized in favor of another event<br>
- overlap_events: List of overlap events, each with:<br>
- name: The name of the overlap event<br>
- start: The start time (datetime) of the overlap event<br>
- end: The end time (datetime) of the overlap event<br>
- created: The datetime the overlap event was created<br>
- organizer: The organizer of the overlap event<br>
- is_prioritized: Whether the overlap event is prioritized<br>
- calendar_name: The name of the calendar""")
def __str__(self):
return self.name
@ -87,8 +104,7 @@ class EmailTemplate(models.Model):
@app.admin(
list_display=("name", "all_users", "auto_clear_bookings",
"auto_clear_overlap_horizon_days", "email_template",
"all_alternatives"),
"auto_clear_overlap_horizon_days", "email_template"),
list_filter=("auto_clear_bookings",))
class Calendar(models.Model):
"""
@ -108,10 +124,6 @@ class Calendar(models.Model):
help_text="""\
Email template to use for sending notifications about deleted events.<br>
If not set, no email will be sent.""")
alternatives = models.ManyToManyField("self", blank=True,
help_text="Calendars (rooms) to be "
"considered as alternatives"
" for this one.")
def save(self, *args, **kwargs):
self.url = self.url.rstrip("/")
@ -136,14 +148,6 @@ class Calendar(models.Model):
"""
return ", ".join([u.username for u in self.users.all()])
def all_alternatives(self) -> str:
"""
Get the alternatives of the calendar.
It's kind of inefficient, but in small databases it should be fine.
:return: A list of alternatives.
"""
return ", ".join([a.name for a in self.alternatives.all()])
@app.admin(ordering=("start", "end", "calendar", "name"),
list_filter=("cancelled",),
@ -172,9 +176,6 @@ class Event(models.Model):
self.created = datetime.now(tz=timezone.get_current_timezone())
self.ics = self.create_ics()
# Round down to the nearest minute to avoid collisions between events
self.end = self.end.replace(second=0, microsecond=0)
# Send the event to the CalDAV server if it has not been cancelled yet
if not self.cancelled:
try:

600
src/clear_bookings.py
View File

@ -1,4 +1,3 @@
import email.utils
import os
import re
import smtplib
@ -8,192 +7,28 @@ from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.utils import format_datetime
from pprint import pprint
from typing import NamedTuple
import caldav
import pytz
from caldav import CalendarObjectResource, Principal, Calendar
from caldav import CalendarObjectResource
from jinja2 import Template
tz = pytz.timezone(os.getenv("TIME_ZONE", "Europe/Berlin"))
class DavEvent:
"""
Wrapper for calendar events fetched from a CalDAV server.
"""
uid: str
name: str
start: datetime
end: datetime
duration: timedelta
created: datetime
status: str
organizer: str
calendar: Calendar
obj: CalendarObjectResource
is_cancelled: bool
is_recurring: bool
is_prioritized: bool
missing_required_fields: list
def __init__(self, event: CalendarObjectResource):
"""
Initialize a DavEvent object.
:param event: CalendarObjectResource object representing the event.
"""
for component in event.icalendar_instance.walk():
if component.name == "VEVENT":
# Check if the event has all required fields
required = {
"uid": component.get("uid", False),
"dtstart": component.get("dtstart", False),
"dtend": component.get("dtend", False),
"dtstamp": component.get("dtstamp", False),
}
if not all(required.values()):
self.missing_required_fields = [k for k, v in required.items() if v is False]
else:
self.missing_required_fields = []
self.uid = event.icalendar_component.get("uid")
self.name = event.icalendar_component.get("summary", "No Name")
self.start = self._handle_date(event.icalendar_component.get("dtstart").dt)
self.end = self._handle_date(event.icalendar_component.get("dtend").dt)
self.duration = self.end - self.start
self.created = self._handle_date(event.icalendar_component.get("dtstamp").dt)
self.status = event.icalendar_component.get("status", "CONFIRMED")
self.organizer = event.icalendar_component.get("organizer", "").replace("mailto:", "").strip()
self.calendar = event.parent
self.obj = event
self.is_deprioritized = False
self.is_deleted = False
def __hash__(self):
return hash(self.extended_uid)
def __eq__(self, other):
if not isinstance(other, DavEvent):
return NotImplemented
return self.extended_uid == other.extended_uid
@property
def extended_uid(self):
"""
Create a more unique identifier for the event.
This is necessary to distinguish between events of the same series, which
have the same UID but different start and end times.
:return: Unique identifier string
"""
# Fallback to calendar id if UID is not set
uid = self.uid if self.uid else self.calendar.id
return f"{uid}_{int(self.start.timestamp())}_{int(self.end.timestamp())}"
@property
def is_recurring(self) -> bool:
"""
Check if the event is a recurring event.
:return: True if the event is recurring, False otherwise.
"""
return 'RECURRENCE-ID' in self.obj.icalendar_component
@property
def is_cancelled(self) -> bool:
"""
Check if the event is a cancelled event.
:return: True if the event is cancelled, False otherwise.
"""
return self.obj.icalendar_component.get("status") == "CANCELLED"
@property
def is_prioritized(self) -> bool:
"""
Check if the event is a prioritized event by finding and validating the
priority token.
:return:
"""
from booking import PriorityEventToken
description = self.obj.icalendar_component.get("DESCRIPTION", "")
uid = self.uid
# Check if there is a token in the event description
token_pattern = r"\#[A-Z1-9]{12}\#"
match = re.search(token_pattern, description)
if match:
token = match.group()
print(f"Priority token found in event description: {token}")
token_obj = PriorityEventToken.objects.get(token=token)
# Check if the token object exists in the database
if not token_obj:
print(f"Priority token '{token}' not found in database.")
return False
# If token is already used, verify signature
if token_obj.is_used:
# Check if the signature is valid
if token_obj.validate_signature(uid):
print(f"Priority token '{token}' is valid.")
return True
else:
print(f"Priority token '{token}' is invalid.")
# TODO: Notify about invalid token usage
return False
# If the token hasn't been used yet, redeem it
else:
print(f"Redeeming priority token '{token}' for event '{uid}'.")
token_obj.redeem(uid)
# TODO: Notify about token redemption
return True
# If no token is found, return False
return False
def delete(self):
"""
Delete the event from the calendar.
:return:
"""
self.is_deleted = True
self.obj.delete()
def serialize(self) -> dict[str, str | datetime | timedelta]:
"""
Serialize the event to a dictionary.
:return:
"""
return {
"uid": self.uid,
"name": self.name,
"start": self.start,
"end": self.end,
"duration": self.duration,
"created": self.created,
"status": self.status,
"organizer": self.organizer,
"calendar_id": self.calendar.id,
"calendar_name": self.calendar.name,
"is_cancelled": self.is_cancelled,
"is_recurring": self.is_recurring,
"is_prioritized": self.is_prioritized,
"missing_required_fields": self.missing_required_fields,
}
@staticmethod
def _handle_date(date_value: datetime | date) -> datetime:
"""
Date objects will be converted to datetime objects in the specified timezone.
"""
if isinstance(date_value, datetime):
date_value = date_value.astimezone(tz)
elif isinstance(date_value, date):
date_value = tz.localize(datetime.combine(date_value, datetime.min.time()))
else:
raise ValueError(f"date_value must be a datetime or date object, {type(date_value)} given.")
return date_value
DavEvent = NamedTuple("DavEvent", [
("uid", str),
("name", str),
("start", datetime),
("end", datetime),
("created", datetime),
("status", str),
("organizer", str),
("obj", caldav.Event),
("is_cancelled", bool),
("is_recurring", bool),
("is_prioritized", bool),
])
def clear(target_calendars: list, is_test: bool=False) -> dict:
"""
@ -244,47 +79,66 @@ def clear(target_calendars: list, is_test: bool=False) -> dict:
split_expanded=True,
)
# Create DavEvent objects from fetched events
events = []
for event in events_fetched:
try:
events.append(DavEvent(event))
except ValueError as e:
print(f"Error creating DavEvent object: {e}")
continue
for component in event.icalendar_instance.walk():
# Filter out events that are missing required fields
events_missing_required_fields = [
event for event in events if event.missing_required_fields
]
for event in events_missing_required_fields:
result = {
"uid": event.uid or "No UID",
"name": event.name or "No Name",
"reason": f"Missing required fields: {', '.join(event.missing_required_fields)}",
"calendar": calendar.id,
}
results["ignored_overlapping_events"].append(result)
print("Skipping event:")
pprint(result)
print("------")
continue
events = [event for event in events if not event.missing_required_fields]
# Delete cancelled non-recurring events if not in test mode
if (component.name == "VEVENT"
and is_cancelled_event(event)
and not is_recurring_event(event)):
# Delete cancelled non-recurring events if not in test mode
for event in events:
if event.is_cancelled and not event.is_recurring:
if not is_test:
event.obj.delete()
result = {
"uid": event.uid,
"name": event.name or "No Name",
"calendar": event.calendar.id,
}
results["deleted_cancelled_events"].append(result)
print("Deleted cancelled event:")
pprint(result)
print("------")
if not is_test:
event.delete()
result = {
"uid": component.get("uid"),
"name": component.get("summary", "No Name"),
"calendar": calendar.id,
}
results["deleted_cancelled_events"].append(result)
print("Deleted cancelled event:")
pprint(result)
print("------")
# Create DavEvent objects for not cancelled events
elif component.name == "VEVENT" and not is_cancelled_event(event):
# Skip events which miss required fields
required = {
"uid": component.get("uid", False),
"dtstart": component.get("dtstart", False),
"dtend": component.get("dtend", False),
"dtstamp": component.get("dtstamp", False),
}
if not all(required.values()):
result = {
"uid": component.get("uid"),
"name": component.get("summary", "No Name"),
"calendar": calendar.id,
"reason": f"Missing required fields: {', '.join([k for k, v in required.items() if v is False])}",
}
results["ignored_overlapping_events"].append(result)
print("Skipping event:")
pprint(result)
print("------")
continue
# Create DavEvent object
events.append(
DavEvent(
uid=component.get("uid"),
name=component.get("summary", "No Name"),
start=handle_date(component.get("dtstart").dt),
end=handle_date(component.get("dtend").dt),
created=component.get("dtstamp").dt.astimezone(tz),
status=component.get("status", "CONFIRMED"),
organizer=component.get("organizer", "").replace("mailto:", "").strip(),
obj=event,
is_cancelled=is_cancelled_event(event),
is_recurring=is_recurring_event(event),
is_prioritized=is_prioritized_event(event),
)
)
# Find overlapping events
overlapping_events = find_overlapping_events(events)
@ -293,10 +147,31 @@ def clear(target_calendars: list, is_test: bool=False) -> dict:
for overlap in overlapping_events.values():
event = overlap["event"]
overlaps_with = overlap["overlaps_with"]
event.is_deprioritized = any(ov.is_prioritized for ov in overlaps_with)
is_deleted = False
is_cancelled = False
is_deprioritized = any(ov.is_prioritized for ov in overlaps_with)
result = {
"event": event.serialize(),
"overlaps_with": [ov.serialize() for ov in overlaps_with],
"event": {
"uid": event.uid,
"name": event.name,
"start": event.start,
"end": event.end,
"created": event.created,
"organizer": event.organizer,
"is_recurring": event.is_recurring,
"is_prioritized": event.is_prioritized,
"is_deprioritized": is_deprioritized,
},
"overlaps_with": [{
"uid": ov.uid,
"name": ov.name,
"start": ov.start,
"end": ov.end,
"created": ov.created,
"organizer": ov.organizer,
"is_recurring": ov.is_recurring,
"is_prioritized": ov.is_prioritized,
} for ov in overlaps_with],
"calendar": calendar.id,
}
try:
@ -304,8 +179,8 @@ def clear(target_calendars: list, is_test: bool=False) -> dict:
if not event.is_recurring:
# but only if we are not in test mode
if not is_test:
event.delete()
event.obj.delete()
is_deleted = True
result["cancellation_type"] = "deleted"
results["deleted_overlapping_events"].append(result)
print("Deleted overlapping event:")
@ -314,6 +189,7 @@ def clear(target_calendars: list, is_test: bool=False) -> dict:
# we need to cancel it now
elif not event.is_cancelled:
if not is_test:
event.obj.decline_invite()
event.obj.icalendar_component["status"] = "CANCELLED"
event.obj.save()
is_cancelled = True
@ -321,61 +197,27 @@ def clear(target_calendars: list, is_test: bool=False) -> dict:
results["cancelled_overlapping_recurring_events"].append(result)
print("Cancelled overlapping recurring event:")
# Get all events of the affected calendar for the days of the
# declined event
other_bookings = find_other_bookings(event, calendar)
# Find free alternative rooms for the time slot of the declined event
alternatives = find_alternatives(event, principal)
# Create a set for all events as an overview
event.is_declined = True
event.is_overlapping = False
event.is_other_booking = False
overview = {event}
# Add the overlapping events to the overview
for ov in overlaps_with:
ov.is_declined = False
ov.is_overlapping = True
ov.is_other_booking = False
overview.add(ov)
# Add the other bookings to the overview
for ob in other_bookings:
ob.is_declined = True
ob.is_overlapping = False
ob.is_other_booking = True
overview.add(ob)
# Make a list from the set to ensure order
overview = list(overview)
# Sort the overview by start time
overview.sort(key=lambda ev: ev.start)
# Send email to organizer of the event if not in test mode
email_template = tcal_by_name[calendar.id].email_template
if email_template:
if email_template and not is_test:
try:
send_mail_to_organizer(
booking=event,
overlap_bookings=overlaps_with,
event_overview=overview,
other_bookings=other_bookings,
alternatives=alternatives,
calendar=calendar,
email_template=email_template,
is_test=is_test,
)
send_mail_to_organizer(event, overlaps_with, calendar,
is_deleted, is_cancelled,
is_deprioritized, email_template)
result["email_sent"] = True
except Exception as e:
print("Failed to send email to organizer for event "
f"{event.name}: {e}")
result["email_sent"] = False
elif email_template and is_test:
print("Email template found, but not sending email in test mode.")
send_mail_to_organizer(event, overlaps_with, calendar,
is_deleted, is_cancelled,
is_deprioritized, email_template,
is_test=True)
result["email_sent"] = True
else:
print(f"No email template found for calendar {calendar.id}. "
"Skipping email sending.")
result["email_sent"] = False
# Print results
@ -412,7 +254,7 @@ def find_overlapping_events(events: list[DavEvent]) -> dict:
for event in events:
# Skip if the event is already in the overlapping events dictionary
if overlapping_events.get(event.extended_uid):
if overlapping_events.get(create_event_identifier(event)):
continue
for compare_event in events:
@ -421,11 +263,6 @@ def find_overlapping_events(events: list[DavEvent]) -> dict:
if event.uid == compare_event.uid:
continue
# Skip if the compare_event is already in the overlapping events
# dictionary
if overlapping_events.get(compare_event.extended_uid):
continue
# Check if the events overlap
if event_starts_later(event, compare_event) or \
event_starts_earlier(event, compare_event) or \
@ -445,44 +282,114 @@ def find_overlapping_events(events: list[DavEvent]) -> dict:
continue
# Add to overlapping events dictionary
if e := overlapping_events.get(event.extended_uid):
event_identifier = create_event_identifier(compare_event)
if e := overlapping_events.get(event_identifier):
# If the event is already in the dictionary, extend the overlaps
e["overlaps_with"].append(event)
else:
# Create a new entry for the overlapping event
overlapping_events[event.extended_uid] = {
overlapping_events[event_identifier] = {
"event": compare_event,
"overlaps_with": [event]
}
return overlapping_events
def create_event_identifier(event: DavEvent) -> str:
"""
Create a unique identifier for the event.
This is necessary to distinguish between events of the same series, which
have the same UID but different start and end times.
:param event: DavEvent object
:return: Unique identifier string
"""
return f"{event.uid}_{int(event.start.timestamp())}_{int(event.end.timestamp())}"
def is_recurring_event(event: CalendarObjectResource) -> bool:
"""
Check if the event is a recurring event.
:param event: CalendarObjectResource object representing the event.
:return: True if the event is recurring, False otherwise.
"""
return 'RECURRENCE-ID' in event.icalendar_component
def is_cancelled_event(event: CalendarObjectResource) -> bool:
"""
Check if the event is a cancelled event.
:param event: CalendarObjectResource object representing the event.
:return: True if the event is cancelled, False otherwise.
"""
return event.icalendar_component.get("status") == "CANCELLED"
def is_prioritized_event(event: CalendarObjectResource) -> bool:
"""
Check if the event is a prioritized event by finding and validating the
priority token.
:param event:
:return:
"""
from booking import PriorityEventToken
description = event.icalendar_component.get("DESCRIPTION", "")
uid = event.icalendar_component.get("uid")
# Check if there is a token in the event description
token_pattern = r"\#[A-Z1-9]{12}\#"
match = re.search(token_pattern, description)
if match:
token = match.group()
print(f"Priority token found in event description: {token}")
token_obj = PriorityEventToken.objects.get(token=token)
# Check if the token object exists in the database
if not token_obj:
print(f"Priority token '{token}' not found in database.")
return False
# If token is already used, verify signature
if token_obj.is_used:
# Check if the signature is valid
if token_obj.validate_signature(uid):
print(f"Priority token '{token}' is valid.")
return True
else:
print(f"Priority token '{token}' is invalid.")
# TODO: Notify about invalid token usage
return False
# If the token hasn't been used yet, redeem it
else:
print(f"Redeeming priority token '{token}' for event '{uid}'.")
token_obj.redeem(uid)
# TODO: Notify about token redemption
return True
# If no token is found, return False
return False
def send_mail_to_organizer(
booking: DavEvent,
overlap_bookings: list[DavEvent],
event_overview: list[DavEvent],
event: DavEvent,
overlap_events: list[DavEvent],
calendar: caldav.Calendar,
is_deleted: bool,
is_cancelled: bool,
is_deprioritized: bool,
email_template,
other_bookings: list[DavEvent]=None,
alternatives: list[Calendar]=None,
is_test: bool=False
):
"""
Send email to organizer of the event.
:param booking: Booking that was declined
:param overlap_bookings: List of bookings which overlap with the declined event
:param event_overview: Sorted list of all events in the calendar, including the declined event and overlaps
:param event: Event that was declined
:param overlap_events: List of events which overlap with the declined event
:param calendar: Calendar to send the email from
:param is_deleted: True if the event was deleted, False otherwise
:param is_cancelled: True if the event was cancelled, False otherwise
:param is_deprioritized: True if the event was deprioritized in favor of
another event, False otherwise
:param email_template: Email template to use for the email
:param other_bookings: List of other bookings at the same day(s) as the declined booking
:param alternatives: List of alternative calendars (rooms) for the time slot of the declined booking
:param is_test: If True, do not send the email, just print it
"""
if is_test:
print("Not sending email in test mode.")
# Check if environment variables for SMTP are set
if not all([
os.getenv('SMTP_EMAIL'),
@ -491,15 +398,28 @@ def send_mail_to_organizer(
]):
raise Exception("SMTP environment variables are not set.")
recipient = booking.organizer
recipient = event.organizer
# Prepare the email content
context = {
"booking": booking,
"overlap_bookings": overlap_bookings,
"other_bookings": other_bookings if other_bookings else [],
"overview": event_overview,
"alternatives": alternatives if alternatives else [],
"name": event.name,
"start": event.start,
"end": event.end,
"created": event.created,
"is_deleted": is_deleted,
"is_cancelled": is_cancelled,
"is_recurring": is_recurring_event(event.obj),
"organizer": event.organizer,
"is_prioritized": event.is_prioritized,
"is_deprioritized": is_deprioritized,
"overlap_events": [{
"name": overlap_event.name,
"start": overlap_event.start,
"end": overlap_event.end,
"created": overlap_event.created,
"organizer": overlap_event.organizer,
"is_prioritized": overlap_event.is_prioritized,
} for overlap_event in overlap_events],
"calendar_name": calendar.get_display_name(),
}
@ -507,8 +427,8 @@ def send_mail_to_organizer(
# Create the email message
message = MIMEMultipart("alternative")
message["From"] = email.utils.formataddr((os.getenv('SMTP_SENDER_NAME', 'Room Booking'), os.getenv('SMTP_EMAIL')))
message["To"] = email.utils.formataddr((None, recipient))
message["From"] = f"{os.getenv('SMTP_SENDER_NAME', 'Room Booking')} <{os.getenv('SMTP_EMAIL')}>"
message["To"] = recipient
if bcc := os.getenv("SMTP_BCC"):
message["Bcc"] = bcc
recipients += bcc.split(",")
@ -516,16 +436,18 @@ def send_mail_to_organizer(
# Try to render subject and body from the email template
message["Subject"] = Template(email_template.subject).render(**context)
plaintext = Template(email_template.plaintext).render(**context)
html = Template(email_template.html).render(**context)
message.attach(MIMEText(plaintext, "plain", "utf-8"))
message.attach(MIMEText(html, "html", "utf-8"))
body = Template(email_template.body).render(**context)
message.attach(MIMEText(body, "plain"))
# Create a secure SSL context
ssl_context = ssl.create_default_context()
# Send the email with starttls or SSL based on environment variable
print(f"Sending email to {', '.join(recipients)} with subject: {message['Subject']}")
overlaps = ", ".join([f"'{overlap.name}'" for overlap in overlap_events])
print(f"Sending email to {', '.join(recipients)} with subject: {message['Subject']}:")
print('"""')
print(body)
print('"""')
if os.getenv('SMTP_STARTTLS', False):
print("Using STARTTLS for SMTP connection.")
if not is_test:
@ -537,77 +459,21 @@ def send_mail_to_organizer(
else:
print("Using SSL for SMTP connection.")
if not is_test:
with smtplib.SMTP_SSL(os.getenv('SMTP_SERVER'),
with smtplib.SMTP_SSL("mail.extrasolar.space",
os.getenv('SMTP_PORT', 465),
context=ssl_context) as server:
server.login(os.getenv("SMTP_USER_NAME", os.getenv("SMTP_EMAIL")), os.getenv("SMTP_PASSWORD"))
server.sendmail(os.getenv("SMTP_EMAIL"), recipients, message.as_string())
def find_other_bookings(event: DavEvent, calendar: caldav.Calendar) -> list[DavEvent]:
def handle_date(date_value: datetime | date) -> datetime:
"""
Find other bookings in the calendar that are at the same day(s) as the declined event.
:param event: The event to check for overlaps.
:param calendar: The calendar to search in.
:return: List of DavEvent objects.
Date objects will be converted to datetime objects in the specified timezone.
"""
# Get all events in the calendar for the days of the declined event
start_date = event.start.date()
end_date = event.end.date()
events_fetched = calendar.search(
start=start_date,
end=end_date + timedelta(days=1),
event=True,
expand=True,
split_expanded=True,
)
# Create DavEvent objects from fetched events
all_events = [DavEvent(event) for event in events_fetched]
# Filter out cancelled events and events that are
# - the exact same as the given event
# - that do not have all required fields
return [e for e in all_events if not e.is_cancelled
and e.extended_uid != event.extended_uid
and not e.missing_required_fields]
def find_alternatives(event: DavEvent, principal: Principal) -> list[Calendar]:
"""
Find alternative rooms for the time slot of the declined event.
:param event: The event to find alternatives for.
:param principal: The principal to search for alternative rooms.
:return: List of alternative calendars that are available for the time slot.
"""
# Get all calendars of the principal
calendars = principal.calendars()
alternatives = []
for calendar in calendars:
# Skip the calendar of the declined event
if calendar.id == event.obj.parent.id:
continue
# Search for events in the alternative calendar that overlap with the
# declined event
events_fetched = calendar.search(
start=event.start,
end=event.end,
event=True,
expand=True,
split_expanded=True,
)
# Create DavEvent objects from fetched events
all_events = [DavEvent(event) for event in events_fetched]
# Filter out cancelled events and events that are missing required fields
blocked = [e for e in all_events if not e.is_cancelled
and not e.missing_required_fields]
# If there are no blocked events, the calendar is available
if not blocked:
alternatives.append(calendar)
return alternatives
if isinstance(date_value, datetime):
date_value = date_value.astimezone(tz)
elif isinstance(date_value, date):
date_value = tz.localize(datetime.combine(date_value, datetime.min.time()))
else:
raise ValueError(f"date_value must be a datetime or date object, {type(date_value)} given.")
return date_value

29
src/migrations/0012_calendar_alternatives_alter_emailtemplate_body.py
View File

@ -1,29 +0,0 @@
# Generated by Django 5.1.4 on 2025-07-21 14:10
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
("booking", "0011_alter_emailtemplate_body_and_more"),
]
operations = [
migrations.AddField(
model_name="calendar",
name="alternatives",
field=models.ManyToManyField(
blank=True,
help_text="Calendars (rooms) to be considered as alternatives for this one.",
to="booking.calendar",
),
),
migrations.AlterField(
model_name="emailtemplate",
name="body",
field=models.TextField(
help_text=" Email template to use for sending notifications about deleted events.<br>\n If not set, no email will be sent.<br>\n Jinja2 template syntax can be used in the subject and body.<br>\n See README.md for a list of available variables."
),
),
]

33
src/migrations/0013_remove_emailtemplate_body_emailtemplate_html_and_more.py
View File

@ -1,33 +0,0 @@
# Generated by Django 5.1.4 on 2025-07-22 13:49
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
("booking", "0012_calendar_alternatives_alter_emailtemplate_body"),
]
operations = [
migrations.RemoveField(
model_name="emailtemplate",
name="body",
),
migrations.AddField(
model_name="emailtemplate",
name="html",
field=models.TextField(
blank=True,
help_text=" Jinja2 template syntax can be used in the subject and body.<br>\n See README.md for a list of available variables.",
),
),
migrations.AddField(
model_name="emailtemplate",
name="plaintext",
field=models.TextField(
blank=True,
help_text=" Jinja2 template syntax can be used in the subject and body.<br>\n See README.md for a list of available variables.",
),
),
]

2
version.txt
View File

@ -1 +1 @@
1.3.0
1.2.0