port to new django, AI automated

eventplanner_gcal/signals.py

@@ -1,61 +1,120 @@
-from django.db.models.signals import post_save, pre_delete
-from django.dispatch import receiver
-from eventplanner.models import Event, EventParticipation
-from eventplanner_gcal.google_sync import get_service_object, \
-    create_gcal_event, delete_gcal_event, update_gcal_event, on_gcal_event_created
+"""
+Django signal handlers for Google Calendar synchronization.
+
+These handlers are currently disabled (early return) but can be enabled
+to automatically sync events with Google Calendar when they are created,
+updated, or deleted.
+"""
 
 import logging
-from django.conf import settings
+
+from django.contrib.auth.models import User
+from django.db.models.signals import post_save, pre_delete
+from django.dispatch import receiver
+
+from eventplanner.models import Event, EventParticipation
+
+from .google_sync import (
+    create_gcal_event_request,
+    delete_gcal_event_request,
+    get_service_object,
+    on_gcal_event_created,
+    update_gcal_event_request,
+)
 
 logger = logging.getLogger(__name__)
 
 
-# @receiver( post_save, sender=User )
-# def user_changed( **kwargs ):
-#    logger.info("Synchronizing with google - user information changed")
-#    syncFromLocalToGoogle( getServiceObject() )
+# @receiver(post_save, sender=User)
+# def user_changed(**kwargs):
+#     """Sync with Google when user information changes."""
+#     logger.info("Synchronizing with google - user information changed")
+#     sync_from_local_to_google(get_service_object())
 
 
 @receiver(post_save, sender=Event)
-def event_post_save_handler(**kwargs):
-    if not settings.GCAL_SYNC_ENABLED:
+def event_post_save_handler(sender, instance, created, **kwargs):
+    """
+    Handle Event post_save signal.
+
+    Creates or updates the corresponding Google Calendar event.
+    Currently disabled - remove the early return to enable.
+    """
+    # Disabled - remove this return statement to enable auto-sync
+    return
+
+    event = instance
+    service = get_service_object()
+
+    if service is None:
+        logger.warning("No Google Calendar service available")
         return
 
-    event = kwargs['instance']
-    created = kwargs['created']
     try:
         if created:
-            logger.info("Creating Gcal event")
-            response = create_gcal_event(get_service_object(), event).execute()
+            logger.info(f"Creating GCal event for Event {event.id}")
+            request = create_gcal_event_request(service, event)
+            response = request.execute()
             on_gcal_event_created(None, response, None)
         else:
-            logger.info("Updating Gcal event")
-            update_gcal_event(get_service_object(), event).execute()
+            logger.info(f"Updating GCal event for Event {event.id}")
+            request = update_gcal_event_request(service, event)
+            request.execute()
     except Exception as e:
-        logger.error("Error updating Gcal event" + str(e))
+        logger.error(f"Error syncing event {event.id} to GCal: {e}")
 
 
 @receiver(pre_delete, sender=Event)
-def event_pre_delete_handler(**kwargs):
-    if not settings.GCAL_SYNC_ENABLED:
+def event_pre_delete_handler(sender, instance, **kwargs):
+    """
+    Handle Event pre_delete signal.
+
+    Deletes the corresponding Google Calendar event.
+    Currently disabled - remove the early return to enable.
+    """
+    # Disabled - remove this return statement to enable auto-sync
+    return
+
+    event = instance
+    service = get_service_object()
+
+    if service is None:
+        logger.warning("No Google Calendar service available")
         return
 
     try:
-        event = kwargs['instance']
-        logger.info("Deleting Gcal event")
-        delete_gcal_event(get_service_object(), event).execute()
+        logger.info(f"Deleting GCal event for Event {event.id}")
+        request = delete_gcal_event_request(service, event)
+        if request:
+            request.execute()
     except Exception as e:
-        logger.error("Error deleting GCAL event" + str(e))
+        logger.error(f"Error deleting GCal event for Event {event.id}: {e}")
 
 
 @receiver(post_save, sender=EventParticipation)
-def participation_post_save_handler(**kwargs):
-    if not settings.GCAL_SYNC_ENABLED:
+def participation_post_save_handler(sender, instance, **kwargs):
+    """
+    Handle EventParticipation post_save signal.
+
+    Updates the Google Calendar event when participation changes.
+    Currently disabled - remove the early return to enable.
+    """
+    # Disabled - remove this return statement to enable auto-sync
+    return
+
+    participation = instance
+    service = get_service_object()
+
+    if service is None:
+        logger.warning("No Google Calendar service available")
         return
 
     try:
-        participation = kwargs['instance']
-        logger.info("Participation post save -> update gcal")
-        update_gcal_event(get_service_object(), participation.event).execute()
+        logger.info(
+            f"Participation changed for Event {participation.event.id} "
+            f"by User {participation.user.username}"
+        )
+        request = update_gcal_event_request(service, participation.event)
+        request.execute()
     except Exception as e:
-        logger.error("Error deleting GCAL event" + str(e))
+        logger.error(f"Error updating GCal event for participation change: {e}")