Adds public events endpoint and user tickets

Adds a public events endpoint that allows read-only access to all events.
Improves ticket management by adding support for user IDs as an identifier, alongside name and email.
This simplifies ticket creation for authenticated users and enhances security.
Also introduces an API endpoint to fetch tickets by user ID.

.github/workflows/release.yml

@@ -19,7 +19,7 @@ jobs:
     needs: [release]
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           token: ${{ secrets.EXT_GITHUB }}
           repository: lnbits/lnbits-extensions

API_DOCUMENTATION.md

@@ -0,0 +1,56 @@
+# Events API Documentation
+
+## Public Events Endpoint
+
+### GET `/api/v1/events/public`
+
+Retrieve all events in the database with read-only access. No authentication required.
+
+**Authentication:** None required (public endpoint)
+
+**Headers:**
+```
+None required
+```
+
+**Query Parameters:**
+- None
+
+**Response:**
+```json
+[
+  {
+    "id": "event_id",
+    "wallet": "wallet_id",
+    "name": "Event Name",
+    "info": "Event description",
+    "closing_date": "2024-12-31",
+    "event_start_date": "2024-12-01",
+    "event_end_date": "2024-12-02",
+    "currency": "sat",
+    "amount_tickets": 100,
+    "price_per_ticket": 1000.0,
+    "time": "2024-01-01T00:00:00Z",
+    "sold": 0,
+    "banner": null
+  }
+]
+```
+
+**Example Usage:**
+```bash
+curl http://your-lnbits-instance/events/api/v1/events/public
+```
+
+**Notes:**
+- This endpoint allows read-only access to all events in the database
+- No authentication required (truly public endpoint)
+- Returns events ordered by creation time (newest first)
+- Suitable for public event listings or read-only integrations
+
+## Comparison with Existing Endpoints
+
+| Endpoint | Authentication | Scope | Use Case |
+|----------|---------------|-------|----------|
+| `/api/v1/events` | Invoice Key | User's wallets only | Private event management |
+| `/api/v1/events/public` | None | All events | Public event browsing | 

Makefile

@@ -5,27 +5,27 @@ format: prettier black ruff
 check: mypy pyright checkblack checkruff checkprettier
 
 prettier:
-	poetry run ./node_modules/.bin/prettier --write .
+	uv run ./node_modules/.bin/prettier --write .
 pyright:
-	poetry run ./node_modules/.bin/pyright
+	uv run ./node_modules/.bin/pyright
 
 mypy:
-	poetry run mypy .
+	uv run mypy .
 
 black:
-	poetry run black .
+	uv run black .
 
 ruff:
-	poetry run ruff check . --fix
+	uv run ruff check . --fix
 
 checkruff:
-	poetry run ruff check .
+	uv run ruff check .
 
 checkprettier:
-	poetry run ./node_modules/.bin/prettier --check .
+	uv run ./node_modules/.bin/prettier --check .
 
 checkblack:
-	poetry run black --check .
+	uv run black --check .
 
 checkeditorconfig:
 	editorconfig-checker
@@ -33,14 +33,14 @@ checkeditorconfig:
 test:
 	PYTHONUNBUFFERED=1 \
 	DEBUG=true \
-	poetry run pytest
+	uv run pytest
 install-pre-commit-hook:
 	@echo "Installing pre-commit hook to git"
-	@echo "Uninstall the hook with poetry run pre-commit uninstall"
-	poetry run pre-commit install
+	@echo "Uninstall the hook with uv run pre-commit uninstall"
+	uv run pre-commit install
 
 pre-commit:
-	poetry run pre-commit run --all-files
+	uv run pre-commit run --all-files
 
 
 checkbundle:

README.md

@@ -2,9 +2,9 @@
 
 <small>For more about LNBits extension check [this tutorial](https://github.com/lnbits/lnbits/wiki/LNbits-Extensions)</small>
 
-## Sell tickets for events and use the built-in scanner for registering attendants
+## Sell tickets for events and use the built-in scanner for registering attendees
 
-Events alows you to make tickets for an event. Each ticket is in the form of a uniqque QR code. After registering, and paying for ticket, the user gets a QR code to present at registration/entrance.
+Events alows you to make tickets for an event. Each ticket is in the form of a unique QR code. After registering, and paying for ticket, the user gets a QR code to present at registration/entrance.
 
 Events includes a shareable ticket scanner, which can be used to register attendees.
 

__init__.py

@@ -37,4 +37,4 @@ def events_start():
     scheduled_tasks.append(task)
 
 
-__all__ = ["db", "events_ext", "events_static_files", "events_start", "events_stop"]
+__all__ = ["db", "events_ext", "events_start", "events_static_files", "events_stop"]

config.json

@@ -2,7 +2,8 @@
   "name": "Events",
   "short_description": "Sell and register event tickets",
   "tile": "/events/static/image/events.png",
-  "min_lnbits_version": "0.12.5",
+  "lnbits": "1.1.0",
+  "min_lnbits_version": "1.3.0",
   "contributors": [
     {
       "name": "talvasconcelos",

crud.py

@@ -1,188 +1,213 @@
-from datetime import datetime, timedelta
-from typing import List, Optional, Union
+from datetime import datetime, timedelta, timezone
+from typing import Optional
 
 from lnbits.db import Database
 from lnbits.helpers import urlsafe_short_hash
 
-from .models import CreateEvent, Event, Ticket
+from .models import CreateEvent, Event, Ticket, TicketExtra
 
 db = Database("ext_events")
 
 
 async def create_ticket(
-    payment_hash: str, wallet: str, event: str, name: str, email: str
+    payment_hash: str,
+    wallet: str,
+    event: str,
+    name: Optional[str] = None,
+    email: Optional[str] = None,
+    user_id: Optional[str] = None,
+    extra: Optional[dict] = None,
 ) -> Ticket:
-    await db.execute(
-        """
-        INSERT INTO events.ticket (id, wallet, event, name, email, registered, paid)
-        VALUES (?, ?, ?, ?, ?, ?, ?)
-        """,
-        (payment_hash, wallet, event, name, email, False, False),
+    now = datetime.now(timezone.utc)
+
+    # Handle database constraints: if user_id is provided, use empty strings for name/email
+    if user_id:
+        db_name = ""
+        db_email = ""
+    else:
+        db_name = name or ""
+        db_email = email or ""
+
+    ticket = Ticket(
+        id=payment_hash,
+        wallet=wallet,
+        event=event,
+        name=name,
+        email=email,
+        user_id=user_id,
+        registered=False,
+        paid=False,
+        reg_timestamp=now,
+        time=now,
+        extra=TicketExtra(**extra) if extra else TicketExtra(),
     )
 
-    ticket = await get_ticket(payment_hash)
-    assert ticket, "Newly created ticket couldn't be retrieved"
+    # Create a dict for database insertion with proper handling of constraints
+    ticket_dict = ticket.dict()
+    ticket_dict["name"] = db_name
+    ticket_dict["email"] = db_email
+
+    await db.execute(
+        """
+        INSERT INTO events.ticket (id, wallet, event, name, email, user_id, registered, paid, time, reg_timestamp, extra)
+        VALUES (:id, :wallet, :event, :name, :email, :user_id, :registered, :paid, :time, :reg_timestamp, :extra)
+        """,
+        ticket_dict
+    )
     return ticket
 
 
-async def set_ticket_paid(payment_hash: str) -> Ticket:
-    ticket = await get_ticket(payment_hash)
-    assert ticket, "Ticket couldn't be retrieved"
-    if ticket.paid:
-        return ticket
+async def update_ticket(ticket: Ticket) -> Ticket:
+    # Create a new Ticket object with corrected values for database constraints
+    ticket_dict = ticket.dict()
 
-    await db.execute(
-        """
-        UPDATE events.ticket
-        SET paid = ?
-        WHERE id = ?
-        """,
-        (True, ticket.id),
-    )
+    # Convert None values to empty strings for database constraints
+    if ticket_dict.get("name") is None:
+        ticket_dict["name"] = ""
+    if ticket_dict.get("email") is None:
+        ticket_dict["email"] = ""
 
-    await update_event_sold(ticket.event)
+    # Create a new Ticket object with the corrected values
+    corrected_ticket = Ticket(**ticket_dict)
 
+    await db.update("events.ticket", corrected_ticket)
     return ticket
 
 
-async def update_event_sold(event_id: str):
-    event = await get_event(event_id)
-    assert event, "Couldn't get event from ticket being paid"
-    sold = event.sold + 1
-    amount_tickets = event.amount_tickets - 1
-    await db.execute(
-        """
-        UPDATE events.events
-        SET sold = ?, amount_tickets = ?
-        WHERE id = ?
-        """,
-        (sold, amount_tickets, event_id),
-    )
-
-    return
-
-
 async def get_ticket(payment_hash: str) -> Optional[Ticket]:
-    row = await db.fetchone("SELECT * FROM events.ticket WHERE id = ?", (payment_hash,))
-    return Ticket(**row) if row else None
+    row = await db.fetchone(
+        "SELECT * FROM events.ticket WHERE id = :id",
+        {"id": payment_hash},
+    )
+    if not row:
+        return None
+
+    # Convert empty strings back to None for the model
+    ticket_data = dict(row)
+    if ticket_data.get("name") == "":
+        ticket_data["name"] = None
+    if ticket_data.get("email") == "":
+        ticket_data["email"] = None
+
+    return Ticket(**ticket_data)
 
 
-async def get_tickets(wallet_ids: Union[str, List[str]]) -> List[Ticket]:
+async def get_tickets(wallet_ids: str | list[str]) -> list[Ticket]:
     if isinstance(wallet_ids, str):
         wallet_ids = [wallet_ids]
+    q = ",".join([f"'{wallet_id}'" for wallet_id in wallet_ids])
+    rows = await db.fetchall(f"SELECT * FROM events.ticket WHERE wallet IN ({q})")
 
-    q = ",".join(["?"] * len(wallet_ids))
+    tickets = []
+    for row in rows:
+        # Convert empty strings back to None for the model
+        ticket_data = dict(row)
+        if ticket_data.get("name") == "":
+            ticket_data["name"] = None
+        if ticket_data.get("email") == "":
+            ticket_data["email"] = None
+        tickets.append(Ticket(**ticket_data))
+
+    return tickets
+
+
+async def get_tickets_by_user_id(user_id: str) -> list[Ticket]:
+    """Get all tickets for a specific user by their user_id"""
     rows = await db.fetchall(
-        f"SELECT * FROM events.ticket WHERE wallet IN ({q})", (*wallet_ids,)
+        "SELECT * FROM events.ticket WHERE user_id = :user_id ORDER BY time DESC",
+        {"user_id": user_id}
     )
-    return [Ticket(**row) for row in rows]
+
+    tickets = []
+    for row in rows:
+        # Convert empty strings back to None for the model
+        ticket_data = dict(row)
+        if ticket_data.get("name") == "":
+            ticket_data["name"] = None
+        if ticket_data.get("email") == "":
+            ticket_data["email"] = None
+        tickets.append(Ticket(**ticket_data))
+
+    return tickets
 
 
 async def delete_ticket(payment_hash: str) -> None:
-    await db.execute("DELETE FROM events.ticket WHERE id = ?", (payment_hash,))
+    await db.execute("DELETE FROM events.ticket WHERE id = :id", {"id": payment_hash})
 
 
 async def delete_event_tickets(event_id: str) -> None:
-    await db.execute("DELETE FROM events.ticket WHERE event = ?", (event_id,))
+    await db.execute(
+        "DELETE FROM events.ticket WHERE event = :event", {"event": event_id}
+    )
 
 
 async def purge_unpaid_tickets(event_id: str) -> None:
     time_diff = datetime.now() - timedelta(hours=24)
     await db.execute(
         f"""
-        DELETE FROM events.ticket WHERE event = ? AND paid = false
-        AND time < {db.timestamp_placeholder}
+        DELETE FROM events.ticket WHERE event = :event AND paid = false
+        AND time < {db.timestamp_placeholder("time")}
         """,
-        (
-            event_id,
-            time_diff.timestamp(),
-        ),
+        {"time": time_diff.timestamp(), "event": event_id},
     )
 
 
 async def create_event(data: CreateEvent) -> Event:
     event_id = urlsafe_short_hash()
-    await db.execute(
-        """
-        INSERT INTO events.events (
-            id, wallet, name, info, banner, closing_date, event_start_date,
-            event_end_date, currency, amount_tickets, price_per_ticket, sold
-        )
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-        """,
-        (
-            event_id,
-            data.wallet,
-            data.name,
-            data.info,
-            data.banner,
-            data.closing_date,
-            data.event_start_date,
-            data.event_end_date,
-            data.currency,
-            data.amount_tickets,
-            data.price_per_ticket,
-            0,
-        ),
-    )
-
-    event = await get_event(event_id)
-    assert event, "Newly created event couldn't be retrieved"
+    event = Event(id=event_id, time=datetime.now(timezone.utc), **data.dict())
+    await db.insert("events.events", event)
     return event
 
 
-async def update_event(event_id: str, **kwargs) -> Event:
-    q = ", ".join([f"{field[0]} = ?" for field in kwargs.items()])
-    await db.execute(
-        f"UPDATE events.events SET {q} WHERE id = ?", (*kwargs.values(), event_id)
-    )
-    event = await get_event(event_id)
-    assert event, "Newly updated event couldn't be retrieved"
+async def update_event(event: Event) -> Event:
+    await db.update("events.events", event)
     return event
 
 
-async def get_event(event_id: str) -> Optional[Event]:
-    row = await db.fetchone("SELECT * FROM events.events WHERE id = ?", (event_id,))
-    return Event(**row) if row else None
+async def get_event(event_id: str) -> Event | None:
+    return await db.fetchone(
+        "SELECT * FROM events.events WHERE id = :id",
+        {"id": event_id},
+        Event,
+    )
 
 
-async def get_events(wallet_ids: Union[str, List[str]]) -> List[Event]:
+async def get_events(wallet_ids: str | list[str]) -> list[Event]:
     if isinstance(wallet_ids, str):
         wallet_ids = [wallet_ids]
-
-    q = ",".join(["?"] * len(wallet_ids))
-    rows = await db.fetchall(
-        f"SELECT * FROM events.events WHERE wallet IN ({q})", (*wallet_ids,)
+    q = ",".join([f"'{wallet_id}'" for wallet_id in wallet_ids])
+    return await db.fetchall(
+        f"SELECT * FROM events.events WHERE wallet IN ({q})",
+        model=Event,
     )
 
-    return [Event(**row) for row in rows]
+
+async def get_all_events() -> list[Event]:
+    """Get all events from the database without wallet filtering."""
+    return await db.fetchall(
+        "SELECT * FROM events.events ORDER BY time DESC",
+        model=Event,
+    )
 
 
 async def delete_event(event_id: str) -> None:
-    await db.execute("DELETE FROM events.events WHERE id = ?", (event_id,))
+    await db.execute("DELETE FROM events.events WHERE id = :id", {"id": event_id})
 
 
-# EVENTTICKETS
-
-
-async def get_event_tickets(event_id: str, wallet_id: str) -> List[Ticket]:
+async def get_event_tickets(event_id: str) -> list[Ticket]:
     rows = await db.fetchall(
-        "SELECT * FROM events.ticket WHERE wallet = ? AND event = ?",
-        (wallet_id, event_id),
+        "SELECT * FROM events.ticket WHERE event = :event",
+        {"event": event_id},
     )
-    return [Ticket(**row) for row in rows]
 
+    tickets = []
+    for row in rows:
+        # Convert empty strings back to None for the model
+        ticket_data = dict(row)
+        if ticket_data.get("name") == "":
+            ticket_data["name"] = None
+        if ticket_data.get("email") == "":
+            ticket_data["email"] = None
+        tickets.append(Ticket(**ticket_data))
 
-async def reg_ticket(ticket_id: str) -> List[Ticket]:
-    await db.execute(
-        f"""
-        UPDATE events.ticket SET registered = ?,
-        reg_timestamp = {db.timestamp_now} WHERE id = ?
-        """,
-        (True, ticket_id),
-    )
-    ticket = await db.fetchone("SELECT * FROM events.ticket WHERE id = ?", (ticket_id,))
-    rows = await db.fetchall(
-        "SELECT * FROM events.ticket WHERE event = ?", (ticket[1],)
-    )
-    return [Ticket(**row) for row in rows]
+    return tickets

migrations.py

@@ -160,3 +160,34 @@ async def m005_add_image_banner(db):
     Add a column to allow an image banner for the event
     """
     await db.execute("ALTER TABLE events.events ADD COLUMN banner TEXT;")
+
+
+async def m006_add_user_id_support(db):
+    """
+    Add user_id column to tickets table to support LNbits user-id as identifier
+    Make name and email optional when user_id is provided
+    """
+    await db.execute("ALTER TABLE events.ticket ADD COLUMN user_id TEXT;")
+    
+    # Since SQLite doesn't support changing column constraints directly,
+    # we'll work around this by allowing the application logic to handle
+    # the validation that either (name AND email) OR user_id is provided
+    # The database will continue to expect name and email as NOT NULL
+    # but we'll insert empty strings for user_id tickets
+
+async def m007_add_extra_fields(db):
+    """
+    Add a canceled and 'extra' column to events and ticket tables
+    to support promo codes and ticket metadata.
+    """
+    # Add canceled and 'extra' columns to events table
+    await db.execute(
+        """
+        ALTER TABLE events.events
+        ADD COLUMN canceled BOOLEAN NOT NULL DEFAULT FALSE,
+        ADD COLUMN extra TEXT;
+        """
+    )
+
+    # Add 'extra' column to ticket table
+    await db.execute("ALTER TABLE events.ticket ADD COLUMN extra TEXT;")

models.py

@@ -1,25 +1,65 @@
+from datetime import datetime
 from typing import Optional
 
 from fastapi import Query
-from pydantic import BaseModel, EmailStr
+from pydantic import BaseModel, EmailStr, Field, root_validator, validator
+
+
+class PromoCode(BaseModel):
+    code: str
+    discount_percent: float = 0.0
+    active: bool = True
+
+    # make the promo code uppercase
+    @validator("code")
+    def uppercase_code(cls, v):
+        return v.upper()
+
+    @validator("discount_percent")
+    def validate_discount_percent(cls, v):
+        assert 0 <= v <= 100, "Discount must be between 0 and 100."
+        return v
+
+
+class EventExtra(BaseModel):
+    promo_codes: list[PromoCode] = Field(default_factory=list)
+    conditional: bool = False
+    min_tickets: int = 1
 
 
 class CreateEvent(BaseModel):
     wallet: str
     name: str
     info: str
-    banner: Optional[str]
     closing_date: str
     event_start_date: str
     event_end_date: str
     currency: str = "sat"
     amount_tickets: int = Query(..., ge=0)
     price_per_ticket: float = Query(..., ge=0)
+    banner: Optional[str] = None
+    extra: EventExtra = Field(default_factory=EventExtra)
 
 
 class CreateTicket(BaseModel):
-    name: str
-    email: EmailStr
+    name: Optional[str] = None
+    email: Optional[EmailStr] = None
+    user_id: Optional[str] = None
+    promo_code: Optional[str] = None
+    refund_address: Optional[str] = None
+
+    @root_validator
+    def validate_identifiers(cls, values):
+        # Ensure either (name AND email) OR user_id is provided
+        name = values.get('name')
+        email = values.get('email')
+        user_id = values.get('user_id')
+
+        if not user_id and not (name and email):
+            raise ValueError("Either user_id or both name and email must be provided")
+        if user_id and (name or email):
+            raise ValueError("Cannot provide both user_id and name/email")
+        return values
 
 
 class Event(BaseModel):
@@ -27,24 +67,35 @@ class Event(BaseModel):
     wallet: str
     name: str
     info: str
-    banner: Optional[str]
     closing_date: str
+    canceled: bool = False
     event_start_date: str
     event_end_date: str
     currency: str
     amount_tickets: int
     price_per_ticket: float
-    sold: int
-    time: int
+    time: datetime
+    sold: int = 0
+    banner: str | None = None
+    extra: EventExtra = Field(default_factory=EventExtra)
+
+
+class TicketExtra(BaseModel):
+    applied_promo_code: str | None = None
+    sats_paid: int | None = None
+    refund_address: str | None = None
+    refunded: bool = False
 
 
 class Ticket(BaseModel):
     id: str
     wallet: str
     event: str
-    name: str
-    email: str
+    name: Optional[str] = None
+    email: Optional[str] = None
+    user_id: Optional[str] = None
     registered: bool
-    reg_timestamp: Optional[int]
     paid: bool
-    time: int
+    time: datetime
+    reg_timestamp: datetime
+    extra: TicketExtra = Field(default_factory=TicketExtra)

pyproject.toml

@@ -1,39 +1,34 @@
-[tool.poetry]
+[project]
 name = "lnbits-events"
 version = "0.0.0"
+requires-python = ">=3.10,<3.13"
 description = "LNbits, free and open-source Lightning wallet and accounts system."
-authors = ["Alan Bits <alan@lnbits.com>"]
+authors = [{ name = "Alan Bits", email = "alan@lnbits.com" }]
+urls = { Homepage = "https://lnbits.com", Repository = "https://github.com/lnbits/events" }
+dependencies = [ "lnbits>1" ]
 
-[tool.poetry.dependencies]
-python = "^3.10 | ^3.9"
-lnbits = "*"
+[tool.poetry]
+package-mode = false
 
-[tool.poetry.group.dev.dependencies]
-black = "^24.3.0"
-pytest-asyncio = "^0.21.0"
-pytest = "^7.3.2"
-mypy = "^1.5.1"
-pre-commit = "^3.2.2"
-ruff = "^0.3.2"
-
-[build-system]
-requires = ["poetry-core>=1.0.0"]
-build-backend = "poetry.core.masonry.api"
+[tool.uv]
+dev-dependencies = [
+    "black",
+    "pytest-asyncio",
+    "pytest",
+    "mypy",
+    "pre-commit",
+    "ruff",
+]
 
 [tool.mypy]
 exclude = "(nostr/*)"
-[[tool.mypy.overrides]]
-module = [
-  "lnbits.*",
-  "lnurl.*",
-  "loguru.*",
-  "fastapi.*",
-  "pydantic.*",
-  "pyqrcode.*",
-  "shortuuid.*",
-  "httpx.*",
-]
-ignore_missing_imports = "True"
+plugins = ["pydantic.mypy"]
+
+[tool.pydantic-mypy]
+init_forbid_extra = true
+init_typed = true
+warn_required_dynamic_aliases = true
+warn_untyped_fields = true
 
 [tool.pytest.ini_options]
 log_cli = false
@@ -76,6 +71,7 @@ dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
 # needed for pydantic
 [tool.ruff.lint.pep8-naming]
 classmethod-decorators = [
+    "validator",
     "root_validator",
 ]
 

services.py

@@ -0,0 +1,54 @@
+from lnurl import execute
+from loguru import logger
+
+from .crud import (
+    get_event,
+    get_event_tickets,
+    purge_unpaid_tickets,
+    update_event,
+    update_ticket,
+)
+from .models import Ticket
+
+
+async def set_ticket_paid(ticket: Ticket) -> Ticket:
+    if ticket.paid:
+        return ticket
+
+    ticket.paid = True
+    await update_ticket(ticket)
+
+    event = await get_event(ticket.event)
+    assert event, "Couldn't get event from ticket being paid"
+    event.sold += 1
+    event.amount_tickets -= 1
+    await update_event(event)
+
+    return ticket
+
+
+async def refund_tickets(event_id: str):
+    """
+    Refund tickets for an event that has not met the minimum ticket requirement.
+    This function should be called when the event is closed and the minimum ticket
+    condition is not met.
+    """
+    await purge_unpaid_tickets(event_id)
+    tickets = await get_event_tickets(event_id)
+
+    if not tickets:
+        return
+
+    for ticket in tickets:
+        if ticket.extra.refunded:
+            continue
+        if ticket.paid and ticket.extra.refund_address and ticket.extra.sats_paid:
+            try:
+                res = await execute(
+                    ticket.extra.refund_address, str(ticket.extra.sats_paid)
+                )
+                if res:
+                    ticket.extra.refunded = True
+                    await update_ticket(ticket)
+            except Exception as e:
+                logger.error(f"Error refunding ticket {ticket.id}: {e}")

static/js/display.js

@@ -0,0 +1,130 @@
+window.app = Vue.createApp({
+  el: '#vue',
+  mixins: [windowMixin],
+  data() {
+    return {
+      paymentReq: null,
+      redirectUrl: null,
+      formDialog: {
+        show: false,
+        data: {
+          name: '',
+          email: '',
+          refund: ''
+        }
+      },
+      ticketLink: {
+        show: false,
+        data: {
+          link: ''
+        }
+      },
+      receive: {
+        show: false,
+        status: 'pending',
+        paymentReq: null
+      }
+    }
+  },
+  async created() {
+    this.info = event_info
+    this.info = this.info.substring(1, this.info.length - 1)
+    this.banner = event_banner
+    this.extra = event_extra
+    this.hasPromoCodes = has_promoCodes
+  },
+  computed: {
+    formatDescription() {
+      return LNbits.utils.convertMarkdown(this.info)
+    }
+  },
+  methods: {
+    resetForm(e) {
+      e.preventDefault()
+      this.formDialog.data.name = ''
+      this.formDialog.data.email = ''
+      this.formDialog.data.refund = ''
+    },
+
+    closeReceiveDialog() {
+      const checker = this.receive.paymentChecker
+      dismissMsg()
+      clearInterval(paymentChecker)
+      setTimeout(() => {}, 10000)
+    },
+    nameValidation(val) {
+      const regex = /[`!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?~]/g
+      return (
+        !regex.test(val) ||
+        'Please enter valid name. No special character allowed.'
+      )
+    },
+    emailValidation(val) {
+      const regex = /^[\w\.-]+@[a-zA-Z\d\.-]+\.[a-zA-Z]{2,}$/
+      return regex.test(val) || 'Please enter valid email.'
+    },
+    Invoice() {
+      axios
+        .post(`/events/api/v1/tickets/${event_id}`, {
+          name: this.formDialog.data.name,
+          email: this.formDialog.data.email,
+          promo_code: this.formDialog.data.promo_code || null
+        })
+        .then(response => {
+          this.paymentReq = response.data.payment_request
+          this.paymentCheck = response.data.payment_hash
+
+          dismissMsg = Quasar.Notify.create({
+            timeout: 0,
+            message: 'Waiting for payment...'
+          })
+
+          this.receive = {
+            show: true,
+            status: 'pending',
+            paymentReq: this.paymentReq
+          }
+          paymentChecker = setInterval(() => {
+            axios
+              .post(`/events/api/v1/tickets/${event_id}/${this.paymentCheck}`, {
+                event: event_id,
+                event_name: event_name,
+                name: this.formDialog.data.name,
+                email: this.formDialog.data.email
+              })
+              .then(res => {
+                if (res.data.paid) {
+                  clearInterval(paymentChecker)
+                  dismissMsg()
+                  this.formDialog.data.name = ''
+                  this.formDialog.data.email = ''
+
+                  Quasar.Notify.create({
+                    type: 'positive',
+                    message: 'Sent, thank you!',
+                    icon: null
+                  })
+                  this.receive = {
+                    show: false,
+                    status: 'complete',
+                    paymentReq: null
+                  }
+
+                  this.ticketLink = {
+                    show: true,
+                    data: {
+                      link: `/events/ticket/${res.data.ticket_id}`
+                    }
+                  }
+                  setTimeout(() => {
+                    window.location.href = `/events/ticket/${res.data.ticket_id}`
+                  }, 5000)
+                }
+              })
+              .catch(LNbits.utils.notifyApiError)
+          }, 2000)
+        })
+        .catch(LNbits.utils.notifyApiError)
+    }
+  }
+})

static/js/index.js

@@ -0,0 +1,296 @@
+const mapEvents = function (obj) {
+  obj.date = LNbits.utils.formatTimestamp(obj.time)
+  obj.fsat = new Intl.NumberFormat(window.g.locale).format(obj.price_per_ticket)
+  obj.displayUrl = ['/events/', obj.id].join('')
+  return obj
+}
+
+window.app = Vue.createApp({
+  el: '#vue',
+  mixins: [windowMixin],
+  data() {
+    return {
+      events: [],
+      tickets: [],
+      currencies: [],
+      eventsTable: {
+        columns: [
+          {name: 'id', align: 'left', label: 'ID', field: 'id'},
+          {name: 'name', align: 'left', label: 'Name', field: 'name'},
+          {
+            name: 'event_start_date',
+            align: 'left',
+            label: 'Start date',
+            field: 'event_start_date'
+          },
+          {
+            name: 'event_end_date',
+            align: 'left',
+            label: 'End date',
+            field: 'event_end_date'
+          },
+          {
+            name: 'closing_date',
+            align: 'left',
+            label: 'Ticket close',
+            field: 'closing_date'
+          },
+          {
+            name: 'canceled',
+            align: 'left',
+            label: 'Canceled',
+            field: row => {
+              if (row.extra.conditional && row.canceled) {
+                return 'Yes'
+              }
+              return 'No'
+            }
+          },
+          {
+            name: 'price_per_ticket',
+            align: 'left',
+            label: 'Price',
+            field: row => {
+              if (row.currency != 'sats') {
+                return LNbits.utils.formatCurrency(
+                  row.price_per_ticket.toFixed(2),
+                  row.currency
+                )
+              }
+              return row.price_per_ticket
+            }
+          },
+          {
+            name: 'amount_tickets',
+            align: 'left',
+            label: 'No tickets',
+            field: 'amount_tickets'
+          },
+          {
+            name: 'sold',
+            align: 'left',
+            label: 'Sold',
+            field: 'sold'
+          },
+          {name: 'info', align: 'left', label: 'Info', field: 'info'},
+          {name: 'banner', align: 'left', label: 'Banner', field: 'banner'}
+        ],
+        pagination: {
+          rowsPerPage: 10
+        }
+      },
+      ticketsTable: {
+        columns: [
+          {name: 'event', align: 'left', label: 'Event', field: 'event'},
+          {name: 'name', align: 'left', label: 'Name', field: 'name'},
+          {name: 'email', align: 'left', label: 'Email', field: 'email'},
+          {
+            name: 'registered',
+            align: 'left',
+            label: 'Registered',
+            field: 'registered'
+          },
+          {
+            name: 'promo_code',
+            align: 'left',
+            label: 'Promo Code',
+            field: row => row.extra.applied_promo_code || ''
+          },
+          {name: 'id', align: 'left', label: 'ID', field: 'id'}
+        ],
+        pagination: {
+          rowsPerPage: 10
+        }
+      },
+      formDialog: {
+        show: false,
+        data: {
+          extra: {
+            promo_codes: []
+          }
+        }
+      }
+    }
+  },
+  methods: {
+    getTickets() {
+      LNbits.api
+        .request(
+          'GET',
+          '/events/api/v1/tickets?all_wallets=true',
+          this.g.user.wallets[0].inkey
+        )
+        .then(response => {
+          this.tickets = response.data
+            .map(function (obj) {
+              return mapEvents(obj)
+            })
+            .filter(e => e.paid)
+        })
+    },
+    deleteTicket(ticketId) {
+      const tickets = _.findWhere(this.tickets, {id: ticketId})
+
+      LNbits.utils
+        .confirmDialog('Are you sure you want to delete this ticket')
+        .onOk(() => {
+          LNbits.api
+            .request(
+              'DELETE',
+              '/events/api/v1/tickets/' + ticketId,
+              _.findWhere(this.g.user.wallets, {id: tickets.wallet}).inkey
+            )
+            .then(response => {
+              this.tickets = _.reject(this.tickets, function (obj) {
+                return obj.id == ticketId
+              })
+            })
+            .catch(function (error) {
+              LNbits.utils.notifyApiError(error)
+            })
+        })
+    },
+    exportticketsCSV() {
+      LNbits.utils.exportCSV(this.ticketsTable.columns, this.tickets)
+    },
+    getEvents() {
+      LNbits.api
+        .request(
+          'GET',
+          '/events/api/v1/events?all_wallets=true',
+          this.g.user.wallets[0].inkey
+        )
+        .then(response => {
+          this.events = response.data.map(obj => {
+            return mapEvents(obj)
+          })
+          this.checkCanceledEvents()
+        })
+    },
+    sendEventData() {
+      const wallet = _.findWhere(this.g.user.wallets, {
+        id: this.formDialog.data.wallet
+      })
+      const data = this.formDialog.data
+      if (data.extra && !data.extra.promo_codes) {
+        data.extra.promo_codes = data.extra.promo_codes
+          .filter(code => code.trim() !== '')
+          .map(code => code.trim().toUpperCase())
+      }
+
+      if (data.id) {
+        this.updateEvent(wallet, data)
+      } else {
+        this.createEvent(wallet, data)
+      }
+    },
+
+    openEventDialog(data = false) {
+      if (data && data.id) {
+        this.formDialog.data = {...data}
+      } else {
+        this.formDialog.data = {
+          extra: {
+            conditional: false,
+            min_tickets: 1,
+            promo_codes: []
+          }
+        }
+      }
+      this.formDialog.show = true
+    },
+    resetEventDialog() {
+      this.formDialog.show = false
+      this.formDialog.data = {
+        extra: {
+          promo_codes: []
+        }
+      }
+    },
+
+    createEvent(wallet, data) {
+      LNbits.api
+        .request('POST', '/events/api/v1/events', wallet.adminkey, data)
+        .then(response => {
+          this.events.push(mapEvents(response.data))
+          this.resetEventDialog()
+        })
+        .catch(LNbits.utils.notifyApiError)
+    },
+    updateformDialog(formId) {
+      const link = _.findWhere(this.events, {id: formId})
+      this.openEventDialog(link)
+    },
+    updateEvent(wallet, data) {
+      LNbits.api
+        .request(
+          'PUT',
+          '/events/api/v1/events/' + data.id,
+          wallet.adminkey,
+          data
+        )
+        .then(response => {
+          this.events = _.reject(this.events, function (obj) {
+            return obj.id == data.id
+          })
+          this.events.push(mapEvents(response.data))
+          this.resetEventDialog()
+        })
+        .catch(LNbits.utils.notifyApiError)
+    },
+    deleteEvent(eventsId) {
+      const events = _.findWhere(this.events, {id: eventsId})
+
+      LNbits.utils
+        .confirmDialog('Are you sure you want to delete this form link?')
+        .onOk(() => {
+          LNbits.api
+            .request(
+              'DELETE',
+              '/events/api/v1/events/' + eventsId,
+              _.findWhere(this.g.user.wallets, {id: events.wallet}).adminkey
+            )
+            .then(response => {
+              this.events = _.reject(this.events, function (obj) {
+                return obj.id == eventsId
+              })
+            })
+            .catch(LNbits.utils.notifyApiError(error))
+        })
+    },
+    exporteventsCSV() {
+      LNbits.utils.exportCSV(this.eventsTable.columns, this.events)
+    },
+    async checkCanceledEvents() {
+      const events = this.events
+        .filter(event => event.extra.conditional)
+        .filter(e => !e.canceled)
+      if (!events.length) return
+      const now = new Date()
+      events.forEach(async ev => {
+        if (new Date(ev.closing_date) < now && ev.sold < ev.extra.min_tickets) {
+          const {data} = await LNbits.api.request(
+            'PUT',
+            '/events/api/v1/events/' + ev.id + '/cancel',
+            _.findWhere(this.g.user.wallets, {id: ev.wallet}).adminkey
+          )
+          Quasar.Notify.create({
+            type: 'warning',
+            message: `Event ${ev.name} has been canceled and refunds have been issued.`,
+            icon: null
+          })
+          this.events = this.events.map(e =>
+            e.id === ev.id ? mapEvents(data) : e
+          )
+        }
+      })
+    }
+  },
+  async created() {
+    if (this.g.user.wallets.length) {
+      this.getTickets()
+      this.getEvents()
+      this.currencies = await LNbits.api.getCurrencies()
+    }
+  }
+})

static/js/register.js

@@ -0,0 +1,78 @@
+const mapEvents = function (obj) {
+  obj.date = Quasar.date.formatDate(
+    new Date(obj.time * 1000),
+    'YYYY-MM-DD HH:mm'
+  )
+  obj.fsat = new Intl.NumberFormat(LOCALE).format(obj.amount)
+  obj.displayUrl = ['/events/', obj.id].join('')
+  return obj
+}
+
+window.app = Vue.createApp({
+  el: '#vue',
+  mixins: [windowMixin],
+  data() {
+    return {
+      tickets: [],
+      ticketsTable: {
+        columns: [
+          {name: 'id', align: 'left', label: 'ID', field: 'id'},
+          {name: 'name', align: 'left', label: 'Name', field: 'name'},
+          {
+            name: 'registered',
+            align: 'left',
+            label: 'Registered',
+            field: 'registered'
+          }
+        ],
+        pagination: {
+          rowsPerPage: 10
+        }
+      },
+      sendCamera: {
+        show: false,
+        camera: 'auto'
+      }
+    }
+  },
+  methods: {
+    hoverEmail(tmp) {
+      this.tickets.data.emailtemp = tmp
+    },
+    closeCamera() {
+      this.sendCamera.show = false
+    },
+    showCamera() {
+      this.sendCamera.show = true
+    },
+    decodeQR(res) {
+      this.sendCamera.show = false
+      const value = res[0].rawValue.split('//')[1]
+      LNbits.api
+        .request('GET', `/events/api/v1/register/ticket/${value}`)
+        .then(() => {
+          Quasar.Notify.create({
+            type: 'positive',
+            message: 'Registered!'
+          })
+          setTimeout(() => {
+            window.location.reload()
+          }, 2000)
+        })
+        .catch(LNbits.utils.notifyApiError)
+    },
+    getEventTickets() {
+      LNbits.api
+        .request('GET', `/events/api/v1/eventtickets/${event_id}`)
+        .then(response => {
+          this.tickets = response.data.map(obj => {
+            return mapEvents(obj)
+          })
+        })
+        .catch(LNbits.utils.notifyApiError)
+    }
+  },
+  created() {
+    this.getEventTickets()
+  }
+})

tasks.py

@@ -2,8 +2,10 @@ import asyncio
 
 from lnbits.core.models import Payment
 from lnbits.tasks import register_invoice_listener
+from loguru import logger
 
-from .crud import set_ticket_paid
+from .crud import get_ticket
+from .services import set_ticket_paid
 
 
 async def wait_for_paid_invoices():
@@ -16,12 +18,20 @@ async def wait_for_paid_invoices():
 
 
 async def on_invoice_paid(payment: Payment) -> None:
-    # (avoid loops)
-    if (
-        payment.extra
-        and "events" == payment.extra.get("tag")
-        and payment.extra.get("name")
-        and payment.extra.get("email")
-    ):
-        await set_ticket_paid(payment.payment_hash)
-    return
+    if not payment.extra or "events" != payment.extra.get("tag"):
+        return
+
+    # Check if ticket has either name/email or user_id
+    has_name_email = payment.extra.get("name") and payment.extra.get("email")
+    has_user_id = payment.extra.get("user_id")
+    
+    if not has_name_email and not has_user_id:
+        logger.warning(f"Ticket {payment.payment_hash} missing name/email or user_id.")
+        return
+
+    ticket = await get_ticket(payment.payment_hash)
+    if not ticket:
+        logger.warning(f"Ticket for payment {payment.payment_hash} not found.")
+        return
+
+    await set_ticket_paid(ticket)

templates/events/display.html

@@ -6,7 +6,7 @@
       <q-card-section class="q-pa-none">
         <h3 class="q-my-none q-pa-lg">{{ event_name }}</h3>
         <br />
-        <div v-html="formatDescription"></div>
+        <div v-html="formatDescription" class="q-pa-md"></div>
         <br />
       </q-card-section>
     </q-card>
@@ -30,7 +30,23 @@
             :rules="[val => !!val || '* Required', val => emailValidation(val)]"
             lazy-rules
           ></q-input>
-
+          <q-input
+            v-if="this.extra?.conditional"
+            filled
+            dense
+            v-model.trim="formDialog.data.refund"
+            label="Refund lnadress or LNURL "
+            :rules="[val => !!val || '* Required']"
+            lazy-rules
+            :hint="`If minimum tickets (${this.extra?.min_tickets}) are not met, refund will be sent.`"
+          ></q-input>
+          <q-input
+            v-if="hasPromoCodes"
+            filled
+            dense
+            v-model.trim="formDialog.data.promo_code"
+            label="Apply Promo Code "
+          ></q-input>
           <div class="row q-mt-lg">
             <q-btn
               unelevated
@@ -72,15 +88,10 @@
     </q-card>
     <q-card v-else class="q-pa-lg q-pt-xl lnbits__dialog-card">
       <div class="text-center q-mb-lg">
-        <a class="text-secondary" :href="'lightning:' + receive.paymentReq">
-          <q-responsive :ratio="1" class="q-mx-xl">
-            <qrcode
-              :value="'lightning:' + receive.paymentReq.toUpperCase()"
-              :options="{width: 340}"
-              class="rounded-borders"
-            ></qrcode>
-          </q-responsive>
-        </a>
+        <lnbits-qrcode
+          :href="'lightning:' + receive.paymentReq"
+          :value="'lightning:' + receive.paymentReq.toUpperCase()"
+        ></lnbits-qrcode>
       </div>
       <div class="row q-mt-lg">
         <q-btn outline color="grey" @click="copyText(receive.paymentReq)"
@@ -94,152 +105,12 @@
 
 {% endblock %} {% block scripts %}
 <script>
-  Vue.component(VueQrcode.name, VueQrcode)
-
-  new Vue({
-    el: '#vue',
-    mixins: [windowMixin],
-    data: function () {
-      return {
-        paymentReq: null,
-        redirectUrl: null,
-        formDialog: {
-          show: false,
-          data: {
-            name: '',
-            email: ''
-          }
-        },
-        ticketLink: {
-          show: false,
-          data: {
-            link: ''
-          }
-        },
-        receive: {
-          show: false,
-          status: 'pending',
-          paymentReq: null
-        }
-      }
-    },
-    async created() {
-      this.info = '{{ event_info | tojson }}'
-      this.info = this.info.substring(1, this.info.length - 1)
-      this.banner = JSON.parse('{{ event_banner | tojson |safe }}')
-      await this.purgeUnpaidTickets()
-    },
-    computed: {
-      formatDescription() {
-        return LNbits.utils.convertMarkdown(this.info)
-      }
-    },
-    methods: {
-      resetForm: function (e) {
-        e.preventDefault()
-        this.formDialog.data.name = ''
-        this.formDialog.data.email = ''
-      },
-
-      closeReceiveDialog: function () {
-        var checker = this.receive.paymentChecker
-        dismissMsg()
-
-        clearInterval(paymentChecker)
-        setTimeout(function () {}, 10000)
-      },
-      nameValidation(val) {
-        const regex = /[`!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?~]/g
-        return (
-          !regex.test(val) ||
-          'Please enter valid name. No special character allowed.'
-        )
-      },
-      emailValidation(val) {
-        let regex = /^[\w\.-]+@[a-zA-Z\d\.-]+\.[a-zA-Z]{2,}$/
-        return regex.test(val) || 'Please enter valid email.'
-      },
-
-      Invoice: function () {
-        var self = this
-        axios
-          .post(`/events/api/v1/tickets/{{ event_id }}`, {
-            name: self.formDialog.data.name,
-            email: self.formDialog.data.email
-          })
-          .then(function (response) {
-            self.paymentReq = response.data.payment_request
-            self.paymentCheck = response.data.payment_hash
-
-            dismissMsg = self.$q.notify({
-              timeout: 0,
-              message: 'Waiting for payment...'
-            })
-
-            self.receive = {
-              show: true,
-              status: 'pending',
-              paymentReq: self.paymentReq
-            }
-
-            paymentChecker = setInterval(function () {
-              axios
-                .post(
-                  `/events/api/v1/tickets/{{ event_id }}/${self.paymentCheck}`,
-                  {
-                    event: '{{ event_id }}',
-                    event_name: '{{ event_name }}',
-                    name: self.formDialog.data.name,
-                    email: self.formDialog.data.email
-                  }
-                )
-                .then(function (res) {
-                  if (res.data.paid) {
-                    clearInterval(paymentChecker)
-                    dismissMsg()
-                    self.formDialog.data.name = ''
-                    self.formDialog.data.email = ''
-
-                    self.$q.notify({
-                      type: 'positive',
-                      message: 'Sent, thank you!',
-                      icon: null
-                    })
-                    self.receive = {
-                      show: false,
-                      status: 'complete',
-                      paymentReq: null
-                    }
-
-                    self.ticketLink = {
-                      show: true,
-                      data: {
-                        link: `/events/ticket/${res.data.ticket_id}`
-                      }
-                    }
-                    setTimeout(function () {
-                      window.location.href = `/events/ticket/${res.data.ticket_id}`
-                    }, 5000)
-                  }
-                })
-                .catch(function (error) {
-                  LNbits.utils.notifyApiError(error)
-                })
-            }, 2000)
-          })
-          .catch(function (error) {
-            LNbits.utils.notifyApiError(error)
-          })
-      },
-      async purgeUnpaidTickets() {
-        try {
-          await LNbits.api.request('GET', `/events/api/v1/purge/{{ event_id }}`)
-        } catch (error) {
-          console.warn(error)
-          LNbits.utils.notifyApiError(error)
-        }
-      }
-    }
-  })
+  const event_id = '{{ event_id }}'
+  const event_name = '{{ event_name }}'
+  const event_info = '{{ event_info | tojson }}'
+  const event_banner = JSON.parse('{{ event_banner | tojson | safe }}')
+  const event_extra = JSON.parse('{{ event_extra | safe }}')
+  const has_promoCodes = {{ has_promo_codes | tojson }}
 </script>
+<script src="{{ static_url_for('events/static', path='js/display.js') }}"></script>
 {% endblock %}

templates/events/error.html

@@ -18,18 +18,14 @@
       </q-card-section>
     </q-card>
   </div>
-
-  {% endblock %} {% block scripts %}
-
-  <script>
-    new Vue({
-      el: '#vue',
-      mixins: [windowMixin],
-      data: function () {
-        return {}
-      }
-    })
-  </script>
-
-  {% endblock %}
 </div>
+{% endblock %} {% block scripts %}
+
+<script>
+  window.app = Vue.createApp({
+    el: '#vue',
+    mixins: [windowMixin]
+  })
+</script>
+
+{% endblock %}

templates/events/index.html

@@ -4,7 +4,7 @@
   <div class="col-12 col-md-8 col-lg-7 q-gutter-y-md">
     <q-card>
       <q-card-section>
-        <q-btn unelevated color="primary" @click="formDialog.show = true"
+        <q-btn unelevated color="primary" @click="openEventDialog"
           >New Event</q-btn
         >
       </q-card-section>
@@ -25,18 +25,17 @@
         <q-table
           dense
           flat
-          :data="events"
+          :rows="events"
           row-key="id"
           :columns="eventsTable.columns"
-          :pagination.sync="eventsTable.pagination"
+          v-model:pagination="eventsTable.pagination"
         >
-          {% raw %}
           <template v-slot:header="props">
             <q-tr :props="props">
               <q-th auto-width></q-th>
-
+              <q-th auto-width></q-th>
               <q-th v-for="col in props.cols" :key="col.name" :props="props">
-                {{ col.label }}
+                <span v-text="col.label"></span>
               </q-th>
 
               <q-th auto-width></q-th>
@@ -44,6 +43,16 @@
           </template>
           <template v-slot:body="props">
             <q-tr :props="props">
+              <q-td auto-width>
+                <q-btn
+                  size="sm"
+                  color="accent"
+                  round
+                  dense
+                  @click="props.expand = !props.expand"
+                  :icon="props.expand ? 'expand_less' : 'expand_more'"
+                />
+              </q-td>
               <q-td auto-width>
                 <q-btn
                   unelevated
@@ -67,7 +76,7 @@
                 ></q-btn>
               </q-td>
               <q-td v-for="col in props.cols" :key="col.name" :props="props">
-                {{ col.value }}
+                <span v-text="col.value"></span>
               </q-td>
               <q-td auto-width>
                 <q-btn
@@ -90,8 +99,53 @@
                 ></q-btn>
               </q-td>
             </q-tr>
+            <q-tr v-show="props.expand" :props="props">
+              <q-td colspan="100%">
+                <div class="q-pa-md">
+                  <div class="text-subtitle1 q-mb-md">Promo codes</div>
+                  <div class="column">
+                    <div
+                      v-if="props.row.extra.promo_codes.length == 0"
+                      class="text-caption"
+                    >
+                      No promo codes for this event.
+                    </div>
+                    <div
+                      v-for="(code, index) in props.row.extra.promo_codes"
+                      :key="index"
+                      class="row items-center q-col-gutter-sm q-mb-sm"
+                    >
+                      <div class="col-auto">
+                        <q-chip
+                          square
+                          size="md"
+                          clickable
+                          @click="utils.copyText(code.code.toUpperCase())"
+                        >
+                          <q-avatar
+                            icon="bookmark"
+                            :color="code.active ? 'green' : 'grey'"
+                            text-color="white"
+                          ></q-avatar>
+                          <span v-text="code.code.toUpperCase()"></span>
+                        </q-chip>
+                      </div>
+                      <div class="col-auto">
+                        Discount: <span v-text="code.discount_percent"></span>%
+                      </div>
+                      <div class="col-auto">
+                        Status:
+                        <span
+                          :class="code.active ? 'text-green' : 'text-grey'"
+                          v-text="code.active ? 'Active' : 'Inactive'"
+                        ></span>
+                      </div>
+                    </div>
+                  </div>
+                </div>
+              </q-td>
+            </q-tr>
           </template>
-          {% endraw %}
         </q-table>
       </q-card-section>
     </q-card>
@@ -111,17 +165,16 @@
         <q-table
           dense
           flat
-          :data="tickets"
+          :rows="tickets"
           row-key="id"
           :columns="ticketsTable.columns"
-          :pagination.sync="ticketsTable.pagination"
+          v-model:pagination="ticketsTable.pagination"
         >
-          {% raw %}
           <template v-slot:header="props">
             <q-tr :props="props">
               <q-th auto-width></q-th>
               <q-th v-for="col in props.cols" :key="col.name" :props="props">
-                {{ col.label }}
+                <span v-text="col.label"></span>
               </q-th>
             </q-tr>
           </template>
@@ -141,7 +194,7 @@
               </q-td>
 
               <q-td v-for="col in props.cols" :key="col.name" :props="props">
-                {{ col.value }}
+                <span v-text="col.value"></span>
               </q-td>
 
               <q-td auto-width>
@@ -156,7 +209,6 @@
               </q-td>
             </q-tr>
           </template>
-          {% endraw %}
         </q-table>
       </q-card-section>
     </q-card>
@@ -228,7 +280,6 @@
             ></q-input>
           </div>
         </div>
-
         <div class="row">
           <div class="col-4">Event begins</div>
           <div class="col-8">
@@ -252,7 +303,6 @@
             ></q-input>
           </div>
         </div>
-
         <div class="row q-col-gutter-sm">
           <div class="col">
             <q-select
@@ -280,13 +330,105 @@
               v-model.number="formDialog.data.price_per_ticket"
               type="number"
               :label="'Price (' + formDialog.data.currency + ') *'"
-              :step="formDialog.data.currency != 'sat' ? '0.01' : '1'"
-              :mask="formDialog.data.currency != 'sat' ? '#.##' : '#'"
+              :step="formDialog.data.currency != 'sats' ? '0.01' : '1'"
+              :mask="formDialog.data.currency != 'sats' ? '#.##' : '#'"
               fill-mask="0"
               reverse-fill-mask
+              :disable="formDialog.data.currency == null"
             ></q-input>
           </div>
         </div>
+        <q-expansion-item
+          group="advanced"
+          icon="settings"
+          label="Advanced options"
+        >
+          <div class="row q-mt-lg">
+            <div class="text-subtitle1 q-mb-md">Conditional Events</div>
+            <div class="text-caption">
+              Make this event conditional if
+              <strong>minimum tickets</strong> are sold. User will be asked to
+              provide a Lightning Address or LNURL pay for refunds.
+            </div>
+            <div class="col-8">
+              <q-toggle
+                v-model="formDialog.data.extra.conditional"
+                label="Conditional Event"
+                left-label
+              ></q-toggle>
+            </div>
+            <div class="col-4">
+              <q-input
+                filled
+                dense
+                v-model.number="formDialog.data.extra.min_tickets"
+                type="number"
+                label="Minimum Tickets"
+                :disable="!formDialog.data.extra.conditional"
+              ></q-input>
+            </div>
+          </div>
+          <q-separator class="q-my-md"></q-separator>
+          <div class="text-subtitle1 q-mb-md">Promo Codes</div>
+          <div class="text-caption">
+            Allow users to enter a promo code for discounts.
+          </div>
+
+          <div
+            v-for="(code, index) in formDialog.data.extra.promo_codes"
+            :key="index"
+            class="row q-col-gutter-sm q-mt-md"
+          >
+            <q-input
+              class="col-8"
+              filled
+              dense
+              v-model.trim="formDialog.data.extra.promo_codes[index].code"
+              type="text"
+              label="Promo Code"
+            >
+              <template v-slot:before>
+                <q-checkbox
+                  left-label
+                  v-model="formDialog.data.extra.promo_codes[index].active"
+                  checked-icon="radio_button_checked"
+                  unchecked-icon="radio_button_unchecked"
+                ></q-checkbox>
+                <q-tooltip>
+                  <span
+                    v-text="formDialog.data.extra.promo_codes[index].active ? 'Active' : 'Inactive'"
+                  ></span>
+                </q-tooltip>
+              </template>
+            </q-input>
+            <q-input
+              class="col-4"
+              filled
+              dense
+              v-model.number="formDialog.data.extra.promo_codes[index].discount_percent"
+              type="number"
+              label="Discount (%)"
+              min="0"
+              max="100"
+            >
+              <template v-slot:after>
+                <q-btn
+                  round
+                  dense
+                  flat
+                  icon="delete"
+                  @click="formDialog.data.extra.promo_codes.splice(index, 1)"
+                ></q-btn>
+              </template>
+            </q-input>
+          </div>
+          <div class="col-12 q-mt-md">
+            <q-btn
+              @click="formDialog.data.extra.promo_codes.push({code: '', discount_percent: 0, active: true})"
+              >Add Promo Code</q-btn
+            >
+          </div>
+        </q-expansion-item>
 
         <div class="row q-mt-lg">
           <q-btn
@@ -318,264 +460,5 @@
     overflow-x: hidden;
   }
 </style>
-<script>
-  var mapEvents = function (obj) {
-    obj.date = Quasar.utils.date.formatDate(
-      new Date(obj.time * 1000),
-      'YYYY-MM-DD HH:mm'
-    )
-    obj.fsat = new Intl.NumberFormat(LOCALE).format(obj.amount)
-    obj.displayUrl = ['/events/', obj.id].join('')
-    return obj
-  }
-
-  new Vue({
-    el: '#vue',
-    mixins: [windowMixin],
-    data: function () {
-      return {
-        events: [],
-        tickets: [],
-        currencies: [],
-        eventsTable: {
-          columns: [
-            {name: 'id', align: 'left', label: 'ID', field: 'id'},
-            {name: 'name', align: 'left', label: 'Name', field: 'name'},
-            {name: 'info', align: 'left', label: 'Info', field: 'info'},
-            {name: 'banner', align: 'left', label: 'Banner', field: 'banner'},
-            {
-              name: 'event_start_date',
-              align: 'left',
-              label: 'Start date',
-              field: 'event_start_date'
-            },
-            {
-              name: 'event_end_date',
-              align: 'left',
-              label: 'End date',
-              field: 'event_end_date'
-            },
-            {
-              name: 'closing_date',
-              align: 'left',
-              label: 'Ticket close',
-              field: 'closing_date'
-            },
-            {
-              name: 'price_per_ticket',
-              align: 'left',
-              label: 'Price',
-              field: row => {
-                if (row.currency != 'sat') {
-                  return LNbits.utils.formatCurrency(
-                    row.price_per_ticket.toFixed(2),
-                    row.currency
-                  )
-                }
-                return row.price_per_ticket
-              }
-            },
-            {
-              name: 'amount_tickets',
-              align: 'left',
-              label: 'No tickets',
-              field: 'amount_tickets'
-            },
-            {
-              name: 'sold',
-              align: 'left',
-              label: 'Sold',
-              field: 'sold'
-            }
-          ],
-          pagination: {
-            rowsPerPage: 10
-          }
-        },
-        ticketsTable: {
-          columns: [
-            {name: 'id', align: 'left', label: 'ID', field: 'id'},
-            {name: 'event', align: 'left', label: 'Event', field: 'event'},
-            {name: 'name', align: 'left', label: 'Name', field: 'name'},
-            {name: 'email', align: 'left', label: 'Email', field: 'email'},
-            {
-              name: 'registered',
-              align: 'left',
-              label: 'Registered',
-              field: 'registered'
-            }
-          ],
-          pagination: {
-            rowsPerPage: 10
-          }
-        },
-        formDialog: {
-          show: false,
-          data: {}
-        }
-      }
-    },
-    methods: {
-      getTickets: function () {
-        var self = this
-        LNbits.api
-          .request(
-            'GET',
-            '/events/api/v1/tickets?all_wallets=true',
-            this.g.user.wallets[0].inkey
-          )
-          .then(function (response) {
-            self.tickets = response.data
-              .map(function (obj) {
-                return mapEvents(obj)
-              })
-              .filter(e => e.paid)
-          })
-      },
-      deleteTicket: function (ticketId) {
-        var self = this
-        var tickets = _.findWhere(this.tickets, {id: ticketId})
-
-        LNbits.utils
-          .confirmDialog('Are you sure you want to delete this ticket')
-          .onOk(function () {
-            LNbits.api
-              .request(
-                'DELETE',
-                '/events/api/v1/tickets/' + ticketId,
-                _.findWhere(self.g.user.wallets, {id: tickets.wallet}).inkey
-              )
-              .then(function (response) {
-                self.tickets = _.reject(self.tickets, function (obj) {
-                  return obj.id == ticketId
-                })
-              })
-              .catch(function (error) {
-                LNbits.utils.notifyApiError(error)
-              })
-          })
-      },
-      exportticketsCSV: function () {
-        LNbits.utils.exportCSV(this.ticketsTable.columns, this.tickets)
-      },
-      getEvents: function () {
-        var self = this
-
-        LNbits.api
-          .request(
-            'GET',
-            '/events/api/v1/events?all_wallets=true',
-            this.g.user.wallets[0].inkey
-          )
-          .then(function (response) {
-            self.events = response.data.map(function (obj) {
-              return mapEvents(obj)
-            })
-          })
-      },
-      sendEventData: function () {
-        var wallet = _.findWhere(this.g.user.wallets, {
-          id: this.formDialog.data.wallet
-        })
-        var data = this.formDialog.data
-
-        if (data.id) {
-          this.updateEvent(wallet, data)
-        } else {
-          this.createEvent(wallet, data)
-        }
-      },
-
-      createEvent: function (wallet, data) {
-        var self = this
-        LNbits.api
-          .request('POST', '/events/api/v1/events', wallet.adminkey, data)
-          .then(function (response) {
-            self.events.push(mapEvents(response.data))
-            self.formDialog.show = false
-            self.formDialog.data = {}
-          })
-          .catch(function (error) {
-            LNbits.utils.notifyApiError(error)
-          })
-      },
-      updateformDialog: function (formId) {
-        var link = _.findWhere(this.events, {id: formId})
-
-        this.formDialog.data = {...link}
-
-        this.formDialog.show = true
-      },
-      updateEvent: function (wallet, data) {
-        var self = this
-
-        LNbits.api
-          .request(
-            'PUT',
-            '/events/api/v1/events/' + data.id,
-            wallet.adminkey,
-            data
-          )
-          .then(function (response) {
-            self.events = _.reject(self.events, function (obj) {
-              return obj.id == data.id
-            })
-            self.events.push(mapEvents(response.data))
-            self.formDialog.show = false
-            self.formDialog.data = {}
-          })
-          .catch(function (error) {
-            LNbits.utils.notifyApiError(error)
-          })
-      },
-      deleteEvent: function (eventsId) {
-        var self = this
-        var events = _.findWhere(this.events, {id: eventsId})
-
-        LNbits.utils
-          .confirmDialog('Are you sure you want to delete this form link?')
-          .onOk(function () {
-            LNbits.api
-              .request(
-                'DELETE',
-                '/events/api/v1/events/' + eventsId,
-                _.findWhere(self.g.user.wallets, {id: events.wallet}).adminkey
-              )
-              .then(function (response) {
-                self.events = _.reject(self.events, function (obj) {
-                  return obj.id == eventsId
-                })
-              })
-              .catch(function (error) {
-                LNbits.utils.notifyApiError(error)
-              })
-          })
-      },
-      exporteventsCSV: function () {
-        LNbits.utils.exportCSV(this.eventsTable.columns, this.events)
-      },
-      async getCurrencies() {
-        try {
-          const {data} = await LNbits.api.request(
-            'GET',
-            '/events/api/v1/currencies',
-            this.inkey
-          )
-
-          this.currencies = ['sat', ...data]
-        } catch (error) {
-          LNbits.utils.notifyApiError(error)
-        }
-      }
-    },
-
-    created: async function () {
-      if (this.g.user.wallets.length) {
-        this.getTickets()
-        this.getEvents()
-        await this.getCurrencies()
-      }
-    }
-  })
-</script>
+<script src="{{ static_url_for('events/static', path='js/index.js') }}"></script>
 {% endblock %}

templates/events/register.html

@@ -22,17 +22,16 @@
         <q-table
           dense
           flat
-          :data="tickets"
+          :rows="tickets"
           row-key="id"
           :columns="ticketsTable.columns"
-          :pagination.sync="ticketsTable.pagination"
+          v-model:pagination="ticketsTable.pagination"
         >
-          {% raw %}
           <template v-slot:header="props">
             <q-tr :props="props">
               <q-th auto-width></q-th>
               <q-th v-for="col in props.cols" :key="col.name" :props="props">
-                {{ col.label }}
+                <span v-text="col.label"></span>
               </q-th>
             </q-tr>
           </template>
@@ -52,11 +51,10 @@
               </q-td>
 
               <q-td v-for="col in props.cols" :key="col.name" :props="props">
-                {{ col.value }}
+                <span v-text="col.value"></span>
               </q-td>
             </q-tr>
           </template>
-          {% endraw %}
         </q-table>
       </q-card-section>
     </q-card>
@@ -66,7 +64,7 @@
     <q-card class="q-pa-lg q-pt-xl">
       <div class="text-center q-mb-lg">
         <qrcode-stream
-          @decode="decodeQR"
+          @detect="decodeQR"
           class="rounded-borders"
         ></qrcode-stream>
       </div>
@@ -80,96 +78,7 @@
 </div>
 {% endblock %} {% block scripts %}
 <script>
-  Vue.component(VueQrcode.name, VueQrcode)
-  Vue.use(VueQrcodeReader)
-  var mapEvents = function (obj) {
-    obj.date = Quasar.utils.date.formatDate(
-      new Date(obj.time * 1000),
-      'YYYY-MM-DD HH:mm'
-    )
-    obj.fsat = new Intl.NumberFormat(LOCALE).format(obj.amount)
-    obj.displayUrl = ['/events/', obj.id].join('')
-    return obj
-  }
-  new Vue({
-    el: '#vue',
-    mixins: [windowMixin],
-    data: function () {
-      return {
-        tickets: [],
-        ticketsTable: {
-          columns: [
-            {name: 'id', align: 'left', label: 'ID', field: 'id'},
-            {name: 'name', align: 'left', label: 'Name', field: 'name'},
-            {
-              name: 'registered',
-              align: 'left',
-              label: 'Registered',
-              field: 'registered'
-            }
-          ],
-          pagination: {
-            rowsPerPage: 10
-          }
-        },
-        sendCamera: {
-          show: false,
-          camera: 'auto'
-        }
-      }
-    },
-    methods: {
-      hoverEmail: function (tmp) {
-        this.tickets.data.emailtemp = tmp
-      },
-      closeCamera: function () {
-        this.sendCamera.show = false
-      },
-      showCamera: function () {
-        this.sendCamera.show = true
-      },
-      decodeQR: function (res) {
-        this.sendCamera.show = false
-        var self = this
-
-        LNbits.api
-          .request(
-            'GET',
-            '/events/api/v1/register/ticket/' + res.split('//')[1]
-          )
-          .then(function (response) {
-            self.$q.notify({
-              type: 'positive',
-              message: 'Registered!'
-            })
-            setTimeout(function () {
-              window.location.reload()
-            }, 2000)
-          })
-          .catch(function (error) {
-            LNbits.utils.notifyApiError(error)
-          })
-      },
-      getEventTickets: function () {
-        var self = this
-        LNbits.api
-          .request(
-            'GET',
-            '/events/api/v1/eventtickets/{{ wallet_id }}/{{ event_id }}'
-          )
-          .then(function (response) {
-            self.tickets = response.data.map(function (obj) {
-              return mapEvents(obj)
-            })
-          })
-          .catch(function (error) {
-            LNbits.utils.notifyApiError(error)
-          })
-      }
-    },
-    created: function () {
-      this.getEventTickets()
-    }
-  })
+  const event_id = '{{ event_id }}'
 </script>
+<script src="{{ static_url_for('events/static', path='js/register.js') }}"></script>
 {% endblock %}

templates/events/ticket.html

@@ -11,12 +11,10 @@
             and present it for registration!
           </h5>
           <br />
-          <q-responsive :ratio="1" class="q-mb-md" style="max-width: 300px">
-            <qrcode
-              :value="'ticket://{{ ticket_id }}'"
-              :options="{width: 500}"
-            ></qrcode>
-          </q-responsive>
+          <lnbits-qrcode
+            :value="'ticket://{{ ticket_id }}'"
+            :options="{width: 500}"
+          ></lnbits-qrcode>
           <br />
           <q-btn @click="printWindow" color="grey" class="q-ml-auto">
             <q-icon left size="3em" name="print"></q-icon> Print</q-btn
@@ -28,15 +26,11 @@
 </div>
 {% endblock %} {% block scripts %}
 <script>
-  Vue.component(VueQrcode.name, VueQrcode)
-  new Vue({
+  window.app = Vue.createApp({
     el: '#vue',
     mixins: [windowMixin],
-    data: function () {
-      return {}
-    },
     methods: {
-      printWindow: function () {
+      printWindow() {
         window.print()
       }
     }

tests/test_api.py

@@ -0,0 +1,108 @@
+import pytest
+from fastapi.testclient import TestClient
+from unittest.mock import AsyncMock, patch
+
+from ..views_api import events_api_router
+from ..models import Event
+from datetime import datetime, timezone
+
+
+@pytest.mark.asyncio
+async def test_api_events_public():
+    """Test the new public events API endpoint"""
+    from fastapi import FastAPI
+    
+    app = FastAPI()
+    app.include_router(events_api_router)
+    
+    # Mock the database
+    with patch('events.crud.get_all_events') as mock_get_all_events:
+        # Create mock events
+        mock_events = [
+            Event(
+                id="test_event_1",
+                wallet="test_wallet_1",
+                name="Test Event 1",
+                info="Test event description",
+                closing_date="2024-12-31",
+                event_start_date="2024-12-01",
+                event_end_date="2024-12-02",
+                currency="sat",
+                amount_tickets=100,
+                price_per_ticket=1000.0,
+                time=datetime.now(timezone.utc),
+                sold=0,
+                banner=None
+            ),
+            Event(
+                id="test_event_2",
+                wallet="test_wallet_2",
+                name="Test Event 2",
+                info="Another test event",
+                closing_date="2024-12-31",
+                event_start_date="2024-12-03",
+                event_end_date="2024-12-04",
+                currency="sat",
+                amount_tickets=50,
+                price_per_ticket=500.0,
+                time=datetime.now(timezone.utc),
+                sold=0,
+                banner=None
+            )
+        ]
+        
+        mock_get_all_events.return_value = mock_events
+        
+        client = TestClient(app)
+        
+        # Test the endpoint without any authentication
+        response = client.get("/api/v1/events/public")
+        
+        # Verify the response
+        assert response.status_code == 200
+        data = response.json()
+        assert len(data) == 2
+        assert data[0]["id"] == "test_event_1"
+        assert data[1]["id"] == "test_event_2"
+        assert data[0]["name"] == "Test Event 1"
+        assert data[1]["name"] == "Test Event 2"
+
+
+@pytest.mark.asyncio
+async def test_get_all_events_crud():
+    """Test the get_all_events CRUD function"""
+    from events.crud import get_all_events
+    
+    with patch('events.crud.db.fetchall') as mock_fetchall:
+        # Mock database response
+        mock_events = [
+            {
+                "id": "test_event_1",
+                "wallet": "test_wallet_1",
+                "name": "Test Event 1",
+                "info": "Test event description",
+                "closing_date": "2024-12-31",
+                "event_start_date": "2024-12-01",
+                "event_end_date": "2024-12-02",
+                "currency": "sat",
+                "amount_tickets": 100,
+                "price_per_ticket": 1000.0,
+                "time": datetime.now(timezone.utc),
+                "sold": 0,
+                "banner": None
+            }
+        ]
+        
+        mock_fetchall.return_value = mock_events
+        
+        events = await get_all_events()
+        
+        # Verify the function was called with correct parameters
+        mock_fetchall.assert_called_once_with(
+            "SELECT * FROM events.events ORDER BY time DESC",
+            model=Event,
+        )
+        
+        # Verify the result
+        assert len(events) == 1
+        assert events[0]["id"] == "test_event_1" 

views.py

@@ -2,17 +2,16 @@ from datetime import date, datetime
 from http import HTTPStatus
 
 from fastapi import APIRouter, Depends, Request
-from fastapi.templating import Jinja2Templates
 from lnbits.core.models import User
 from lnbits.decorators import check_user_exists
 from lnbits.helpers import template_renderer
 from starlette.exceptions import HTTPException
 from starlette.responses import HTMLResponse
 
-from .crud import get_event, get_ticket
+from .crud import get_event, get_ticket, purge_unpaid_tickets, update_event
+from .services import refund_tickets
 
 events_generic_router = APIRouter()
-templates = Jinja2Templates(directory="templates")
 
 
 def events_renderer():
@@ -22,7 +21,7 @@ def events_renderer():
 @events_generic_router.get("/", response_class=HTMLResponse)
 async def index(request: Request, user: User = Depends(check_user_exists)):
     return events_renderer().TemplateResponse(
-        "events/index.html", {"request": request, "user": user.dict()}
+        "events/index.html", {"request": request, "user": user.json()}
     )
 
 
@@ -34,6 +33,15 @@ async def display(request: Request, event_id):
             status_code=HTTPStatus.NOT_FOUND, detail="Event does not exist."
         )
 
+    await purge_unpaid_tickets(event_id)
+
+    is_window_open = (
+        date.today() < datetime.strptime(event.closing_date, "%Y-%m-%d").date()
+    )
+    is_min_tickets_met = (
+        event.sold >= event.extra.min_tickets if event.extra.conditional else True
+    )
+
     if event.amount_tickets < 1:
         return events_renderer().TemplateResponse(
             "events/error.html",
@@ -43,8 +51,20 @@ async def display(request: Request, event_id):
                 "event_error": "Sorry, tickets are sold out :(",
             },
         )
-    datetime_object = datetime.strptime(event.closing_date, "%Y-%m-%d").date()
-    if date.today() > datetime_object:
+    if event.extra.conditional and not is_min_tickets_met and not is_window_open:
+        event.canceled = True
+        await update_event(event)
+        await refund_tickets(event_id)
+
+        return events_renderer().TemplateResponse(
+            "events/error.html",
+            {
+                "request": request,
+                "event_name": event.name,
+                "event_error": "Sorry, event was cancelled.",
+            },
+        )
+    if not is_window_open:
         return events_renderer().TemplateResponse(
             "events/error.html",
             {
@@ -54,6 +74,12 @@ async def display(request: Request, event_id):
             },
         )
 
+    if len(event.extra.promo_codes) > 0:
+        has_promo_codes = True
+    else:
+        has_promo_codes = False
+
+    event.extra.promo_codes = []
     return events_renderer().TemplateResponse(
         "events/display.html",
         {
@@ -63,6 +89,8 @@ async def display(request: Request, event_id):
             "event_info": event.info,
             "event_price": event.price_per_ticket,
             "event_banner": event.banner,
+            "event_extra": event.extra.json(),
+            "has_promo_codes": has_promo_codes,
         },
     )
 

views_api.py

@@ -1,3 +1,4 @@
+from datetime import datetime, timezone
 from http import HTTPStatus
 
 from fastapi import APIRouter, Depends, Query
@@ -5,11 +6,10 @@ from lnbits.core.crud import get_standalone_payment, get_user
 from lnbits.core.models import WalletTypeInfo
 from lnbits.core.services import create_invoice
 from lnbits.decorators import (
-    get_key_type,
     require_admin_key,
+    require_invoice_key,
 )
 from lnbits.utils.exchange_rates import (
-    currencies,
     fiat_amount_as_satoshis,
     get_fiat_rate_satoshis,
 )
@@ -26,19 +26,21 @@ from .crud import (
     get_events,
     get_ticket,
     get_tickets,
+    get_tickets_by_user_id,
     purge_unpaid_tickets,
-    reg_ticket,
-    set_ticket_paid,
     update_event,
+    update_ticket,
 )
-from .models import CreateEvent, CreateTicket
+from .models import CreateEvent, CreateTicket, Ticket
+from .services import refund_tickets, set_ticket_paid
 
 events_api_router = APIRouter()
 
 
 @events_api_router.get("/api/v1/events")
 async def api_events(
-    all_wallets: bool = Query(False), wallet: WalletTypeInfo = Depends(get_key_type)
+    all_wallets: bool = Query(False),
+    wallet: WalletTypeInfo = Depends(require_invoice_key),
 ):
     wallet_ids = [wallet.wallet.id]
 
@@ -49,12 +51,24 @@ async def api_events(
     return [event.dict() for event in await get_events(wallet_ids)]
 
 
+@events_api_router.get("/api/v1/events/public")
+async def api_events_public():
+    """
+    Retrieve all events in the database with read-only access.
+    This endpoint allows access to all events using any valid API key (read access).
+    """
+    # Get all events from the database without wallet filtering
+    from .crud import get_all_events
+    events = await get_all_events()
+    return [event.dict() for event in events]
+
+
 @events_api_router.post("/api/v1/events")
 @events_api_router.put("/api/v1/events/{event_id}")
 async def api_event_create(
     data: CreateEvent,
-    event_id=None,
     wallet: WalletTypeInfo = Depends(require_admin_key),
+    event_id: str | None = None,
 ):
     if event_id:
         event = await get_event(event_id)
@@ -67,16 +81,38 @@ async def api_event_create(
             raise HTTPException(
                 status_code=HTTPStatus.FORBIDDEN, detail="Not your event."
             )
-        event = await update_event(event_id, **data.dict())
+        for k, v in data.dict().items():
+            setattr(event, k, v)
+        event = await update_event(event)
     else:
-        event = await create_event(data=data)
+        event = await create_event(data)
+
+    return event.dict()
+
+
+@events_api_router.put("/api/v1/events/{event_id}/cancel")
+async def api_event_cancel(
+    event_id: str,
+    wallet: WalletTypeInfo = Depends(require_admin_key),
+):
+    event = await get_event(event_id)
+    if not event:
+        raise HTTPException(
+            status_code=HTTPStatus.NOT_FOUND, detail="Event does not exist."
+        )
+
+    if event.wallet != wallet.wallet.id:
+        raise HTTPException(status_code=HTTPStatus.FORBIDDEN, detail="Not your event.")
+    event.canceled = True
+    event = await update_event(event)
+    await refund_tickets(event.id)
 
     return event.dict()
 
 
 @events_api_router.delete("/api/v1/events/{event_id}")
 async def api_form_delete(
-    event_id, wallet: WalletTypeInfo = Depends(require_admin_key)
+    event_id: str, wallet: WalletTypeInfo = Depends(require_admin_key)
 ):
     event = await get_event(event_id)
     if not event:
@@ -97,26 +133,81 @@ async def api_form_delete(
 
 @events_api_router.get("/api/v1/tickets")
 async def api_tickets(
-    all_wallets: bool = Query(False), wallet: WalletTypeInfo = Depends(get_key_type)
-):
+    all_wallets: bool = Query(False),
+    wallet: WalletTypeInfo = Depends(require_invoice_key),
+) -> list[Ticket]:
     wallet_ids = [wallet.wallet.id]
 
     if all_wallets:
         user = await get_user(wallet.wallet.user)
         wallet_ids = user.wallet_ids if user else []
 
-    return [ticket.dict() for ticket in await get_tickets(wallet_ids)]
+    return await get_tickets(wallet_ids)
+
+
+@events_api_router.get("/api/v1/tickets/user/{user_id}")
+async def api_tickets_by_user_id(user_id: str) -> list[Ticket]:
+    """Get all tickets for a specific user by their user_id"""
+    return await get_tickets_by_user_id(user_id)
 
 
 @events_api_router.post("/api/v1/tickets/{event_id}")
 async def api_ticket_create(event_id: str, data: CreateTicket):
-    name = data.name
-    email = data.email
-    return await api_ticket_make_ticket(event_id, name, email)
+    if data.user_id:
+        return await api_ticket_make_ticket_with_user_id(event_id, data.user_id)
+    else:
+        promo_code = data.promo_code.upper() if data.promo_code else None
+        refund_address = data.refund_address
+        return await api_ticket_make_ticket(
+            event_id, data.name, data.email, promo_code, refund_address
+        )
+
+
+async def api_ticket_make_ticket_with_user_id(event_id: str, user_id: str):
+    event = await get_event(event_id)
+    if not event:
+        raise HTTPException(
+            status_code=HTTPStatus.NOT_FOUND, detail="Event does not exist."
+        )
+
+    price = event.price_per_ticket
+    extra = {"tag": "events", "user_id": user_id}
+
+    if event.currency != "sats":
+        price = await fiat_amount_as_satoshis(event.price_per_ticket, event.currency)
+
+        extra["fiat"] = True
+        extra["currency"] = event.currency
+        extra["fiatAmount"] = event.price_per_ticket
+        extra["rate"] = await get_fiat_rate_satoshis(event.currency)
+
+    try:
+        payment = await create_invoice(
+            wallet_id=event.wallet,
+            amount=price,
+            memo=f"{event_id}",
+            extra=extra,
+        )
+        await create_ticket(
+            payment_hash=payment.payment_hash,
+            wallet=event.wallet,
+            event=event.id,
+            user_id=user_id,
+        )
+    except Exception as exc:
+        raise HTTPException(
+            status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=str(exc)
+        ) from exc
+    return {"payment_hash": payment.payment_hash, "payment_request": payment.bolt11}
+
+
+@events_api_router.get("/api/v1/tickets/{event_id}/user/{user_id}")
+async def api_ticket_make_ticket_user_id(event_id: str, user_id: str):
+    return await api_ticket_make_ticket_with_user_id(event_id, user_id)
 
 
 @events_api_router.get("/api/v1/tickets/{event_id}/{name}/{email}")
-async def api_ticket_make_ticket(event_id, name, email):
+async def api_ticket_make_ticket(event_id, name, email, promo_code, refund_address):
     event = await get_event(event_id)
     if not event:
         raise HTTPException(
@@ -126,33 +217,49 @@ async def api_ticket_make_ticket(event_id, name, email):
     price = event.price_per_ticket
     extra = {"tag": "events", "name": name, "email": email}
 
-    if event.currency != "sat":
-        price = await fiat_amount_as_satoshis(event.price_per_ticket, event.currency)
+    if promo_code:
+        # check if promo_code exists in event.extra.promo_codes
+        if promo_code not in [pc.code for pc in event.extra.promo_codes]:
+            raise HTTPException(
+                status_code=HTTPStatus.BAD_REQUEST, detail="Invalid promo code."
+            )
+        # get the promocode
+        promo = next(pc for pc in event.extra.promo_codes if pc.code == promo_code)
+        extra["promo_code"] = promo.code
+        price = event.price_per_ticket * (1 - promo.discount_percent / 100)
 
+    if event.currency != "sats":
         extra["fiat"] = True
         extra["currency"] = event.currency
-        extra["fiatAmount"] = event.price_per_ticket
+        extra["fiatAmount"] = price
         extra["rate"] = await get_fiat_rate_satoshis(event.currency)
 
+        price = await fiat_amount_as_satoshis(price, event.currency)
+
     try:
-        payment_hash, payment_request = await create_invoice(
+        payment = await create_invoice(
             wallet_id=event.wallet,
-            amount=price,  # type: ignore
+            amount=price,
             memo=f"{event_id}",
             extra=extra,
         )
         await create_ticket(
-            payment_hash=payment_hash,
+            payment_hash=payment.payment_hash,
             wallet=event.wallet,
             event=event.id,
             name=name,
             email=email,
+            extra={
+                "applied_promo_code": promo_code,
+                "refund_address": refund_address,
+                "sats_paid": int(price),
+            },
         )
     except Exception as exc:
         raise HTTPException(
             status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=str(exc)
         ) from exc
-    return {"payment_hash": payment_hash, "payment_request": payment_request}
+    return {"payment_hash": payment.payment_hash, "payment_request": payment.bolt11}
 
 
 @events_api_router.post("/api/v1/tickets/{event_id}/{payment_hash}")
@@ -172,24 +279,41 @@ async def api_ticket_send_ticket(event_id, payment_hash):
         )
     payment = await get_standalone_payment(payment_hash, incoming=True)
     assert payment
+
+    if ticket.extra.applied_promo_code:
+        promo = next(
+            (
+                pc
+                for pc in event.extra.promo_codes
+                if pc.code == ticket.extra.applied_promo_code
+            ),
+            None,
+        )
+        if promo:
+            event.price_per_ticket *= 1 - promo.discount_percent / 100
+
     price = (
         event.price_per_ticket * 1000
-        if event.currency == "sat"
+        if event.currency == "sats"
         else await fiat_amount_as_satoshis(event.price_per_ticket, event.currency)
         * 1000
     )
+
     # check if price is equal to payment.amount
     lower_bound = price * 0.99  # 1% decrease
 
     if not payment.pending and abs(payment.amount) >= lower_bound:  # allow 1% error
-        await set_ticket_paid(payment_hash)
+        ticket.extra.sats_paid = int(payment.amount / 1000)
+        await set_ticket_paid(ticket)
         return {"paid": True, "ticket_id": ticket.id}
 
     return {"paid": False}
 
 
 @events_api_router.delete("/api/v1/tickets/{ticket_id}")
-async def api_ticket_delete(ticket_id, wallet: WalletTypeInfo = Depends(get_key_type)):
+async def api_ticket_delete(
+    ticket_id: str, wallet: WalletTypeInfo = Depends(require_invoice_key)
+):
     ticket = await get_ticket(ticket_id)
     if not ticket:
         raise HTTPException(
@@ -200,32 +324,16 @@ async def api_ticket_delete(ticket_id, wallet: WalletTypeInfo = Depends(get_key_
         raise HTTPException(status_code=HTTPStatus.FORBIDDEN, detail="Not your ticket.")
 
     await delete_ticket(ticket_id)
-    return "", HTTPStatus.NO_CONTENT
 
 
-@events_api_router.get("/api/v1/purge/{event_id}")
-async def api_event_purge_tickets(event_id):
-    event = await get_event(event_id)
-    if not event:
-        raise HTTPException(
-            status_code=HTTPStatus.NOT_FOUND, detail="Event does not exist."
-        )
-    return await purge_unpaid_tickets(event_id)
-
-
-# Event Tickets
-
-
-@events_api_router.get("/api/v1/eventtickets/{wallet_id}/{event_id}")
-async def api_event_tickets(wallet_id, event_id):
-    return [
-        ticket.dict()
-        for ticket in await get_event_tickets(wallet_id=wallet_id, event_id=event_id)
-    ]
+@events_api_router.get("/api/v1/eventtickets/{event_id}")
+async def api_event_tickets(event_id: str) -> list[Ticket]:
+    return await get_event_tickets(event_id)
 
 
+# TODO: PUT, updates db! @tal
 @events_api_router.get("/api/v1/register/ticket/{ticket_id}")
-async def api_event_register_ticket(ticket_id):
+async def api_event_register_ticket(ticket_id) -> list[Ticket]:
     ticket = await get_ticket(ticket_id)
 
     if not ticket:
@@ -243,9 +351,7 @@ async def api_event_register_ticket(ticket_id):
             status_code=HTTPStatus.FORBIDDEN, detail="Ticket already registered"
         )
 
-    return [ticket.dict() for ticket in await reg_ticket(ticket_id)]
-
-
-@events_api_router.get("/api/v1/currencies")
-async def api_list_currencies_available():
-    return list(currencies.keys())
+    ticket.registered = True
+    ticket.reg_timestamp = datetime.now(timezone.utc)
+    await update_ticket(ticket)
+    return await get_event_tickets(ticket.event)