feat: UI fixes, ticket waves, ticket image

__init__.py

@@ -6,12 +6,13 @@
 from .crud import db
 from .tasks import wait_for_paid_invoices
 from .views import events_generic_router
-from .views_api import events_api_router, tickets_api_router
+from .views_api import events_api_router, qr_api_router, tickets_api_router
 
 events_ext: APIRouter = APIRouter(prefix="/events", tags=["Events"])
 events_ext.include_router(events_generic_router)
 events_ext.include_router(events_api_router)
 events_ext.include_router(tickets_api_router)
+events_ext.include_router(qr_api_router)
 
 events_static_files = [
     {

crud.py

@@ -1,9 +1,17 @@
 from datetime import datetime, timedelta, timezone
+from typing import cast
 
-from lnbits.db import Database
+from lnbits.db import Database, Filters, Page
 from lnbits.helpers import urlsafe_short_hash
 
-from .models import CreateEvent, Event, Ticket, TicketExtra
+from .models import (
+    CreateEvent,
+    Event,
+    Ticket,
+    TicketExtra,
+    TicketFilters,
+    sync_event_ticket_waves,
+)
 
 db = Database("ext_events")
 
@@ -51,6 +59,31 @@ async def get_tickets(wallet_ids: str | list[str]) -> list[Ticket]:
     )
 
 
+async def get_tickets_paginated(
+    wallet_ids: str | list[str], filters: Filters[TicketFilters] | None = None
+) -> Page[Ticket]:
+    if isinstance(wallet_ids, str):
+        wallet_ids = [wallet_ids]
+
+    wallet_where = []
+    values = {}
+    for idx, wallet_id in enumerate(wallet_ids):
+        key = f"wallet_id_{idx}"
+        wallet_where.append(f":{key}")
+        values[key] = wallet_id
+
+    where = [f"wallet IN ({', '.join(wallet_where)})", "paid = true"]
+
+    return await db.fetch_page(
+        "SELECT * FROM events.ticket",
+        where=where,
+        values=values,
+        filters=filters,
+        model=Ticket,
+        table_name="events.ticket",
+    )
+
+
 async def delete_ticket(payment_hash: str) -> None:
     await db.execute("DELETE FROM events.ticket WHERE id = :id", {"id": payment_hash})
 
@@ -75,31 +108,35 @@ async def purge_unpaid_tickets(event_id: str) -> None:
 async def create_event(data: CreateEvent) -> Event:
     event_id = urlsafe_short_hash()
     event = Event(id=event_id, time=datetime.now(timezone.utc), **data.dict())
+    event = cast(Event, sync_event_ticket_waves(event))
     await db.insert("events.events", event)
     return event
 
 
 async def update_event(event: Event) -> Event:
+    event = cast(Event, sync_event_ticket_waves(event))
     await db.update("events.events", event)
     return event
 
 
 async def get_event(event_id: str) -> Event | None:
-    return await db.fetchone(
+    event = await db.fetchone(
         "SELECT * FROM events.events WHERE id = :id",
         {"id": event_id},
         Event,
     )
+    return cast(Event, sync_event_ticket_waves(event)) if event else None
 
 
 async def get_events(wallet_ids: str | list[str]) -> list[Event]:
     if isinstance(wallet_ids, str):
         wallet_ids = [wallet_ids]
     q = ",".join([f"'{wallet_id}'" for wallet_id in wallet_ids])
-    return await db.fetchall(
+    events = await db.fetchall(
         f"SELECT * FROM events.events WHERE wallet IN ({q})",
         model=Event,
     )
+    return [cast(Event, sync_event_ticket_waves(event)) for event in events]
 
 
 async def delete_event(event_id: str) -> None:

models.py

@@ -1,6 +1,8 @@
-from datetime import datetime
+from datetime import date, datetime
+from uuid import uuid4
 
 from fastapi import Query
+from lnbits.db import FilterModel
 from pydantic import BaseModel, EmailStr, Field, validator
 
 
@@ -20,8 +22,23 @@ def validate_discount_percent(cls, v):
         return v
 
 
+class TicketWave(BaseModel):
+    id: str = Field(default_factory=lambda: uuid4().hex[:8])
+    title: str = "Primary wave"
+    opening_date: str
+    closing_date: str
+    currency: str = "sat"
+    use_ticket_image: bool = False
+    ticket_image_id: str | None = None
+    allow_fiat: bool = False
+    fiat_currency: str = "GBP"
+    amount_tickets: int = Field(default=0, ge=0)
+    price_per_ticket: float = Field(default=0, ge=0)
+
+
 class EventExtra(BaseModel):
     promo_codes: list[PromoCode] = Field(default_factory=list)
+    ticket_waves: list[TicketWave] = Field(default_factory=list)
     conditional: bool = False
     min_tickets: int = 1
     email_notifications: bool = False
@@ -84,6 +101,8 @@ class PublicEvent(BaseModel):
 
 class TicketExtra(BaseModel):
     applied_promo_code: str | None = None
+    ticket_wave_id: str | None = None
+    ticket_wave_title: str | None = None
     sats_paid: int | None = None
     refund_address: str | None = None
     nostr_identifier: str | None = None
@@ -96,6 +115,7 @@ class TicketExtra(BaseModel):
 class CreateTicket(BaseModel):
     name: str
     email: EmailStr
+    ticket_wave_id: str | None = None
     promo_code: str | None = None
     refund_address: str | None = None
     nostr_identifier: str | None = None
@@ -116,6 +136,22 @@ class Ticket(BaseModel):
     extra: TicketExtra = Field(default_factory=TicketExtra)
 
 
+class NotificationDeliveryResult(BaseModel):
+    attempted: bool = False
+    sent: bool = False
+    error: str | None = None
+
+
+class TicketResendResult(BaseModel):
+    ticket: Ticket
+    email: NotificationDeliveryResult = Field(
+        default_factory=NotificationDeliveryResult
+    )
+    nostr: NotificationDeliveryResult = Field(
+        default_factory=NotificationDeliveryResult
+    )
+
+
 class PublicTicket(BaseModel):
     event: str
     name: str
@@ -131,3 +167,82 @@ class TicketPaymentRequest(BaseModel):
     fiat_payment_request: str | None = None
     fiat_provider: str | None = None
     is_fiat: bool = False
+
+
+class TicketFilters(FilterModel):
+    __search_fields__ = ["event", "name", "email", "id"]  # noqa: RUF012
+    __sort_fields__ = [  # noqa: RUF012
+        "time",
+        "event",
+        "name",
+        "email",
+        "registered",
+        "id",
+    ]
+
+    event: str | None = None
+    name: str | None = None
+    email: str | None = None
+    registered: bool | None = None
+    paid: bool | None = None
+    id: str | None = None
+
+
+def _parse_date(value: str) -> date:
+    return datetime.strptime(value, "%Y-%m-%d").date()
+
+
+def ensure_ticket_waves(event: Event | PublicEvent | CreateEvent) -> list[TicketWave]:
+    ticket_waves = list(getattr(event.extra, "ticket_waves", []) or [])
+    if ticket_waves:
+        return ticket_waves
+
+    fallback_opening_date = None
+    event_time = getattr(event, "time", None)
+    if event_time:
+        fallback_opening_date = event_time.date().isoformat()
+    if not fallback_opening_date:
+        fallback_opening_date = event.closing_date
+
+    return [
+        TicketWave(
+            id="primary",
+            title="Primary wave",
+            opening_date=fallback_opening_date,
+            closing_date=event.closing_date,
+            currency=event.currency,
+            allow_fiat=event.allow_fiat,
+            fiat_currency=event.fiat_currency,
+            amount_tickets=getattr(event, "amount_tickets", 0),
+            price_per_ticket=event.price_per_ticket,
+        )
+    ]
+
+
+def sync_event_ticket_waves(event: Event | CreateEvent) -> Event | CreateEvent:
+    ticket_waves = ensure_ticket_waves(event)
+    event.extra.ticket_waves = ticket_waves
+
+    primary_wave = ticket_waves[0]
+    event.closing_date = max(wave.closing_date for wave in ticket_waves)
+    event.currency = primary_wave.currency
+    event.allow_fiat = primary_wave.allow_fiat
+    event.fiat_currency = primary_wave.fiat_currency
+    event.amount_tickets = sum(wave.amount_tickets for wave in ticket_waves)
+    event.price_per_ticket = primary_wave.price_per_ticket
+
+    return event
+
+
+def get_active_ticket_waves(
+    event: Event | PublicEvent, today: date | None = None
+) -> list[TicketWave]:
+    current_day = today or datetime.utcnow().date()
+    return [
+        wave
+        for wave in ensure_ticket_waves(event)
+        if _parse_date(wave.opening_date)
+        <= current_day
+        <= _parse_date(wave.closing_date)
+        and wave.amount_tickets > 0
+    ]