Tickets: delete and update events, categories, sessions and questions

app/core/feed/cruds_feed.py

@@ -92,3 +92,17 @@ async def edit_news_by_module_object_id(
         )
         .values(**news_edit.model_dump(exclude_unset=True)),
     )
+
+
+async def get_news_by_module_object_id(
+    module: str,
+    module_object_id: UUID,
+    db: AsyncSession,
+) -> models_feed.News | None:
+    result = await db.execute(
+        select(models_feed.News).where(
+            models_feed.News.module == module,
+            models_feed.News.module_object_id == module_object_id,
+        ),
+    )
+    return result.scalars().first()

app/core/feed/utils_feed.py

@@ -123,3 +123,16 @@ async def edit_feed_news(
                 group_id=group,
                 message=message,
             )
+
+
+async def check_if_module_object_id_is_linked_to_feed(
+    module: str,
+    module_object_id: uuid.UUID,
+    db: AsyncSession,
+) -> bool:
+    result = await cruds_feed.get_news_by_module_object_id(
+        module=module,
+        module_object_id=module_object_id,
+        db=db,
+    )
+    return result is not None

app/core/mypayment/utils_mypayment.py

@@ -425,3 +425,18 @@ async def can_user_manage_events(
         db=db,
     )
     return seller is not None and seller.can_manage_events
+
+
+async def ensure_user_can_manage_events(
+    user_id: str,
+    store_id: UUID,
+    db: AsyncSession,
+):
+    """
+    Will raise a 403 HTTPException if the user is not authorized to manage events for the store.
+    """
+    if not await can_user_manage_events(user_id, store_id, db):
+        raise HTTPException(
+            403,
+            detail="User is not authorized to manage store's events",
+        )

app/core/tickets/cruds_tickets.py

@@ -345,6 +345,24 @@ async def create_event_category(
     db.add(db_category)
 
 
+async def create_event_question(
+    question_id: UUID,
+    event_id: UUID,
+    question: schemas_tickets.QuestionCreate,
+    db: AsyncSession,
+):
+    db_question = models_tickets.Question(
+        id=question_id,
+        event_id=event_id,
+        question=question.question,
+        answer_type=question.answer_type,
+        price=question.price,
+        required=question.required,
+        disabled=False,
+    )
+    db.add(db_question)
+
+
 async def get_category_by_id(
     category_id: UUID,
     db: AsyncSession,
@@ -726,52 +744,56 @@ async def count_valid_checkouts_by_event_id(
     return result.scalar() or 0
 
 
-async def count_valid_checkouts_by_category_id(
-    category_id: UUID,
+async def count_valid_checkouts_and_tickets_by_event_id(
+    event_id: UUID,
     db: AsyncSession,
 ) -> int:
     """
-    Count only unpaid checkouts that are not expired
+    Count unpaid checkouts that are not expired and paid tickets
     """
     result = await db.execute(
         select(func.count()).where(
-            models_tickets.Checkout.category_id == category_id,
-            models_tickets.Checkout.expiration >= datetime.now(UTC),
-            not_(models_tickets.Checkout.paid),
+            models_tickets.Checkout.event_id == event_id,
+            or_(
+                models_tickets.Checkout.paid,
+                models_tickets.Checkout.expiration >= datetime.now(UTC),
+            ),
         ),
     )
 
     return result.scalar() or 0
 
 
-async def count_valid_checkouts_by_session_id(
+async def count_valid_checkouts_and_tickets_by_session_id(
     session_id: UUID,
     db: AsyncSession,
 ) -> int:
     """
-    Count only unpaid checkouts that are not expired
+    Count unpaid checkouts that are not expired and paid tickets
     """
     result = await db.execute(
         select(func.count()).where(
             models_tickets.Checkout.session_id == session_id,
-            models_tickets.Checkout.expiration >= datetime.now(UTC),
-            not_(models_tickets.Checkout.paid),
+            or_(
+                models_tickets.Checkout.paid,
+                models_tickets.Checkout.expiration >= datetime.now(UTC),
+            ),
         ),
     )
 
     return result.scalar() or 0
 
 
-async def count_valid_checkouts_and_tickets_by_event_id(
-    event_id: UUID,
+async def count_valid_checkouts_and_tickets_by_category_id(
+    category_id: UUID,
     db: AsyncSession,
 ) -> int:
     """
     Count unpaid checkouts that are not expired and paid tickets
     """
     result = await db.execute(
         select(func.count()).where(
-            models_tickets.Checkout.event_id == event_id,
+            models_tickets.Checkout.category_id == category_id,
             or_(
                 models_tickets.Checkout.paid,
                 models_tickets.Checkout.expiration >= datetime.now(UTC),
@@ -782,40 +804,36 @@ async def count_valid_checkouts_and_tickets_by_event_id(
     return result.scalar() or 0
 
 
-async def count_valid_checkouts_and_tickets_by_category_id(
+async def count_valid_checkouts_by_category_id(
     category_id: UUID,
     db: AsyncSession,
 ) -> int:
     """
-    Count unpaid checkouts that are not expired and paid tickets
+    Count only unpaid checkouts that are not expired
     """
     result = await db.execute(
         select(func.count()).where(
             models_tickets.Checkout.category_id == category_id,
-            or_(
-                models_tickets.Checkout.paid,
-                models_tickets.Checkout.expiration >= datetime.now(UTC),
-            ),
+            models_tickets.Checkout.expiration >= datetime.now(UTC),
+            not_(models_tickets.Checkout.paid),
         ),
     )
 
     return result.scalar() or 0
 
 
-async def count_valid_checkouts_and_tickets_by_session_id(
+async def count_valid_checkouts_by_session_id(
     session_id: UUID,
     db: AsyncSession,
 ) -> int:
     """
-    Count unpaid checkouts that are not expired and paid tickets
+    Count only unpaid checkouts that are not expired
     """
     result = await db.execute(
         select(func.count()).where(
             models_tickets.Checkout.session_id == session_id,
-            or_(
-                models_tickets.Checkout.paid,
-                models_tickets.Checkout.expiration >= datetime.now(UTC),
-            ),
+            models_tickets.Checkout.expiration >= datetime.now(UTC),
+            not_(models_tickets.Checkout.paid),
         ),
     )
 
@@ -926,3 +944,89 @@ async def get_ticket_change_over_invitation_by_token(
         new_user_id=invitation.new_user_id,
         token=invitation.token,
     )
+
+
+async def delete_question(
+    question_id: UUID,
+    db: AsyncSession,
+):
+    await db.execute(
+        delete(models_tickets.Question).where(
+            models_tickets.Question.id == question_id,
+        ),
+    )
+
+
+async def delete_session(
+    session_id: UUID,
+    db: AsyncSession,
+):
+    # Delete all expired unpaid checkouts for the session before deleting the session itself
+    await db.execute(
+        delete(models_tickets.Checkout).where(
+            models_tickets.Checkout.session_id == session_id,
+            not_(models_tickets.Checkout.paid),
+            models_tickets.Checkout.expiration < datetime.now(UTC),
+        ),
+    )
+
+    await db.execute(
+        delete(models_tickets.EventSession).where(
+            models_tickets.EventSession.id == session_id,
+        ),
+    )
+
+
+async def delete_category(
+    category_id: UUID,
+    db: AsyncSession,
+):
+    # Delete all expired unpaid checkouts for the category before deleting the category itself
+    await db.execute(
+        delete(models_tickets.Checkout).where(
+            models_tickets.Checkout.category_id == category_id,
+            not_(models_tickets.Checkout.paid),
+            models_tickets.Checkout.expiration < datetime.now(UTC),
+        ),
+    )
+
+    await db.execute(
+        delete(models_tickets.Category).where(
+            models_tickets.Category.id == category_id,
+        ),
+    )
+
+
+async def delete_event(
+    event_id: UUID,
+    db: AsyncSession,
+):
+    # Delete all expired unpaid checkouts for the event before deleting the event itself
+    await db.execute(
+        delete(models_tickets.Checkout).where(
+            models_tickets.Checkout.event_id == event_id,
+            not_(models_tickets.Checkout.paid),
+            models_tickets.Checkout.expiration < datetime.now(UTC),
+        ),
+    )
+
+    await db.execute(
+        delete(models_tickets.Question).where(
+            models_tickets.Question.event_id == event_id,
+        ),
+    )
+    await db.execute(
+        delete(models_tickets.EventSession).where(
+            models_tickets.EventSession.event_id == event_id,
+        ),
+    )
+    await db.execute(
+        delete(models_tickets.Category).where(
+            models_tickets.Category.event_id == event_id,
+        ),
+    )
+    await db.execute(
+        delete(models_tickets.TicketEvent).where(
+            models_tickets.TicketEvent.id == event_id,
+        ),
+    )