Merge pull request #265 from adamspd/send-ics-file-to-users-on-appointment-creation

Send ics file to users on appointment creation/reschedule

Author: adamspd

.gitignore

@@ -4,7 +4,7 @@
 *.pyc
 __pycache__/
 local_settings.py
-db.sqlite3
+db.sqlite3*
 db.sqlite3-journal
 db.sqlite3.init
 media

appointment/email_sender/email_sender.py

@@ -1,21 +1,30 @@
 # email_sender.py
 # Path: appointment/email_sender/email_sender.py
 import os
+from datetime import datetime, timedelta
+from typing import Any, Optional, Tuple
 
-from django.core.mail import mail_admins, send_mail
+from django.conf import settings
+from django.core.mail import send_mail
 from django.template import loader
+from django.utils import timezone
 
 from appointment.logger_config import get_logger
 from appointment.settings import APP_DEFAULT_FROM_EMAIL, check_q_cluster
 
 logger = get_logger(__name__)
 
 try:
-    from django_q.tasks import async_task
+    from django_q.tasks import async_task, schedule
+    from django_q.models import Schedule
+
 
     DJANGO_Q_AVAILABLE = True
 except ImportError:
     async_task = None
+    schedule = None
+    Schedule = None
+
     DJANGO_Q_AVAILABLE = False
     logger.warning("django-q is not installed. Email will be sent synchronously.")
 
@@ -53,49 +62,210 @@ def render_email_template(template_url, context):
 
 
 def send_email(recipient_list, subject: str, template_url: str = None, context: dict = None, from_email=None,
-               message: str = None):
+               message: str = None, attachments=None):
     if not has_required_email_settings():
         return
 
     from_email = from_email or APP_DEFAULT_FROM_EMAIL
     html_message = render_email_template(template_url, context)
 
     if get_use_django_q_for_emails() and check_q_cluster() and DJANGO_Q_AVAILABLE:
-        # Asynchronously send the email using Django-Q
+        # Pass only the necessary data to construct the email
         async_task(
-                "appointment.tasks.send_email_task", recipient_list=recipient_list, subject=subject,
-                message=message, html_message=html_message if template_url else None, from_email=from_email
+                'appointment.tasks.send_email_task',
+                recipient_list=recipient_list,
+                subject=subject,
+                message=message,
+                html_message=html_message,
+                from_email=from_email,
+                attachments=attachments
         )
     else:
         # Synchronously send the email
         try:
             send_mail(
-                    subject=subject, message=message if not template_url else "",
-                    html_message=html_message if template_url else None, from_email=from_email,
-                    recipient_list=recipient_list, fail_silently=False,
+                    subject=subject,
+                    message=message if not template_url else "",
+                    html_message=html_message if template_url else None,
+                    from_email=from_email,
+                    recipient_list=recipient_list,
+                    fail_silently=False,
             )
         except Exception as e:
             logger.error(f"Error sending email: {e}")
 
 
-def notify_admin(subject: str, template_url: str = None, context: dict = None, message: str = None):
+def validate_required_fields(recipient_list: list, subject: str) -> Tuple[bool, str]:
+    if not recipient_list or not subject:
+        return False, "Recipient list and subject are required."
+    return True, ""
+
+
+def validate_and_process_datetime(dt: Optional[datetime], field_name: str) -> Tuple[bool, str, Optional[datetime]]:
+    if not dt:
+        return True, "", None
+
+    if not isinstance(dt, datetime):
+        try:
+            dt = datetime.fromisoformat(dt)
+        except ValueError:
+            return False, f"Invalid {field_name} format. Use ISO format or datetime object.", None
+
+    if dt.tzinfo is None:
+        dt = timezone.make_aware(dt)
+
+    return True, "", dt
+
+
+def validate_send_at(send_at: Optional[datetime]) -> tuple[bool, str, None] | tuple[
+    bool, str, datetime | None | timedelta | Any]:
+    success, message, processed_send_at = validate_and_process_datetime(send_at, "send_at")
+    if not success:
+        return success, message, None
+
+    if processed_send_at and processed_send_at <= timezone.now():
+        return False, "send_at must be in the future.", None
+
+    return True, "", processed_send_at or (timezone.now() + timedelta(minutes=1))
+
+
+def validate_repeat_until(repeat_until: Optional[datetime], send_at: datetime) -> Tuple[bool, str, Optional[datetime]]:
+    success, message, processed_repeat_until = validate_and_process_datetime(repeat_until, "repeat_until")
+    if not success:
+        return success, message, None
+
+    if processed_repeat_until and processed_repeat_until <= send_at:
+        return False, "repeat_until must be after send_at.", None
+
+    return True, "", processed_repeat_until
+
+
+def validate_repeat_option(repeat: Optional[str]) -> Tuple[bool, str, Optional[str]]:
+    valid_options = ['HOURLY', 'DAILY', 'WEEKLY', 'MONTHLY', 'QUARTERLY', 'YEARLY']
+    if repeat and repeat not in valid_options:
+        return False, f"Invalid repeat option. Choose from {', '.join(valid_options)}.", None
+    return True, "", repeat
+
+
+def schedule_email_task(
+        recipient_list: list,
+        subject: str,
+        html_message: str,
+        from_email: str,
+        attachments: Optional[list],
+        schedule_type: str,
+        send_at: datetime,
+        name: Optional[str],
+        repeat_until: Optional[datetime]
+) -> Tuple[bool, str]:
+    try:
+        schedule(
+                'appointment.tasks.send_email_task',
+                recipient_list=recipient_list,
+                subject=subject,
+                message=None,
+                html_message=html_message,
+                from_email=from_email,
+                attachments=attachments,
+                schedule_type=schedule_type,
+                next_run=send_at,
+                name=name,
+                repeats=-1 if schedule_type != Schedule.ONCE and not repeat_until else None,
+                end_date=repeat_until
+        )
+        return True, "Email scheduled successfully."
+    except Exception as e:
+        logger.error(f"Error scheduling email: {e}")
+        return False, f"Error scheduling email: {str(e)}"
+
+
+def schedule_email_sending(
+        recipient_list: list,
+        subject: str,
+        template_url: Optional[str] = None,
+        context: Optional[dict] = None,
+        from_email: Optional[str] = None,
+        attachments: Optional[list] = None,
+        send_at: Optional[datetime] = None,
+        name: Optional[str] = None,
+        repeat: Optional[str] = None,
+        repeat_until: Optional[datetime] = None
+) -> Tuple[bool, str]:
+    if not has_required_email_settings():
+        return False, "Email settings are not configured."
+
+    if not check_q_cluster() or not DJANGO_Q_AVAILABLE:
+        return False, "Django-Q is not available."
+
+    # Validate required fields
+    success, message = validate_required_fields(recipient_list, subject)
+    if not success:
+        return success, message
+
+    # Validate and process send_at
+    success, message, processed_send_at = validate_send_at(send_at)
+    if not success:
+        return success, message
+
+    # Validate repeat option
+    success, message, validated_repeat = validate_repeat_option(repeat)
+    if not success:
+        return success, message
+
+    # Validate repeat_until
+    success, message, processed_repeat_until = validate_repeat_until(repeat_until, processed_send_at)
+    if not success:
+        return success, message
+
+    from_email = from_email or APP_DEFAULT_FROM_EMAIL
+    html_message = render_email_template(template_url, context)
+
+    schedule_type = getattr(Schedule, validated_repeat or 'ONCE')
+
+    return schedule_email_task(
+            recipient_list,
+            subject,
+            html_message,
+            from_email,
+            attachments,
+            schedule_type,
+            processed_send_at,
+            name,
+            processed_repeat_until
+    )
+
+
+def notify_admin(subject: str, template_url: str = None, context: dict = None, message: str = None,
+                 recipient_email: str = None, attachments=None):
     if not has_required_email_settings():
         return
 
     html_message = render_email_template(template_url, context)
 
+    recipients = [recipient_email] if recipient_email else [email for name, email in settings.ADMINS]
+
     if get_use_django_q_for_emails() and check_q_cluster() and DJANGO_Q_AVAILABLE:
-        # Enqueue the task to send admin email asynchronously
-        async_task('appointment.tasks.notify_admin_task', subject=subject, message=message, html_message=html_message)
+        # Asynchronously send the email using Django-Q
+        async_task("appointment.tasks.send_email_task",
+                   subject=subject,
+                   message=message,
+                   html_message=html_message,
+                   from_email=settings.DEFAULT_FROM_EMAIL,
+                   recipient_list=recipients,
+                   attachments=attachments)
     else:
-        # Synchronously send admin email
+        # Synchronously send the email
         try:
-            mail_admins(
-                    subject=subject, message=message if not template_url else "",
-                    html_message=html_message if template_url else None
+            send_mail(
+                    subject=subject,
+                    message=message if not template_url else "",
+                    html_message=html_message if template_url else None,
+                    from_email=settings.DEFAULT_FROM_EMAIL,
+                    recipient_list=recipients,
+                    fail_silently=False,
             )
         except Exception as e:
-            logger.error(f"Error sending email to admin: {e}")
+            logger.error(f"Error sending email: {e}")
 
 
 def get_use_django_q_for_emails():

appointment/tasks.py

@@ -5,6 +5,7 @@
 Author: Adams Pierre David
 Since: 3.1.0
 """
+from django.core.mail import EmailMessage
 from django.utils.translation import gettext as _
 
 from appointment.email_sender import notify_admin, send_email
@@ -42,18 +43,23 @@ def send_email_reminder(to_email, first_name, reschedule_link, appointment_id):
     )
 
 
-def send_email_task(recipient_list, subject, message, html_message, from_email):
-    """
-   Task function to send an email asynchronously using Django's send_mail function.
-   This function tries to send an email and logs an error if it fails.
-   """
+def send_email_task(recipient_list, subject, message, html_message, from_email, attachments=None):
     try:
-        from django.core.mail import send_mail
-        logger.info(f"Sending email to {recipient_list} with subject: {subject}")
-        send_mail(
-                subject=subject, message=message, html_message=html_message, from_email=from_email,
-                recipient_list=recipient_list, fail_silently=False,
+        email = EmailMessage(
+                subject=subject,
+                body=message if not html_message else html_message,
+                from_email=from_email,
+                to=recipient_list
         )
+
+        if html_message:
+            email.content_subtype = "html"
+
+        if attachments:
+            for attachment in attachments:
+                email.attach(*attachment)
+
+        email.send(fail_silently=False)
     except Exception as e:
         logger.error(f"Error sending email from task: {e}")
 

appointment/templates/email_sender/admin_new_appointment_email.html

@@ -51,20 +51,29 @@
 <body>
 <div class="email-container">
     <h1>{% translate 'New Appointment Request' %}</h1>
-    <p>{% translate 'Dear Admin,' %}</p>
-    <p>{% translate 'You have received a new appointment request. Here are the details:' %}</p>
+    <p>{% translate 'Dear' %} {{ recipient_name }},</p>
+    {% if is_staff_member %}
+        <p>{% translate 'You have received a new appointment request. Here are the details:' %}</p>
+    {% else %}
+        <p>{% translate 'A new appointment request has been received for' %} {{ staff_member_name }}. {% translate 'Here are the details:' %}</p>
+    {% endif %}
 
     <div class="appointment-details">
         <p><strong>{% translate 'Client Name' %}:</strong> {{ client_name }}</p>
         <p><strong>{% translate 'Service Requested' %}:</strong> {{ appointment.get_service_name }}</p>
         <p><strong>{% translate 'Appointment Date' %}:</strong> {{ appointment.appointment_request.date }}</p>
         <p><strong>{% translate 'Time' %}:</strong> {{ appointment.appointment_request.start_time }}
             - {{ appointment.appointment_request.end_time }}</p>
-        <p><strong>{% translate 'Contact Details' %}:</strong> {{ appointment.phone }} | {{ appointment.client.email }}</p>
+        <p><strong>{% translate 'Contact Details' %}:</strong> {{ appointment.phone }} | {{ appointment.client.email }}
+        </p>
         <p><strong>{% translate 'Additional Info' %}:</strong> {{ appointment.additional_info|default:"N/A" }}</p>
     </div>
 
-    <p>{% translate 'Please review the appointment request and take the necessary action.' %}</p>
+    {% if is_staff_member %}
+        <p>{% translate 'Please review the appointment request and take the necessary action.' %}</p>
+    {% else %}
+        <p>{% translate 'Please ensure that' %} {{ staff_member_name }} {% translate 'reviews this appointment request and takes the necessary action.' %}</p>
+    {% endif %}
 
     <div class="footer">
         <p>{% translate 'This is an automated message. Please do not reply directly to this email.' %}</p>