fix: paying an invoice does not send a webhook. #2472 (#2999)

* fix: paying an invoice does not send a webhook. #2472
closes #2472

lnbits/core/services/notifications.py

@@ -1,15 +1,27 @@
 import asyncio
+import json
+from http import HTTPStatus
 from typing import Optional, Tuple
 
 import httpx
 from loguru import logger
+from py_vapid import Vapid
+from pywebpush import WebPushException, webpush
 
+from lnbits.core.crud import (
+    delete_webpush_subscriptions,
+    get_webpush_subscriptions_for_user,
+    mark_webhook_sent,
+)
+from lnbits.core.models import Payment, Wallet
 from lnbits.core.models.notifications import (
     NOTIFICATION_TEMPLATES,
     NotificationMessage,
     NotificationType,
 )
 from lnbits.core.services.nostr import fetch_nip5_details, send_nostr_dm
+from lnbits.core.services.websockets import websocket_manager
+from lnbits.helpers import check_callback_url
 from lnbits.settings import settings
 from lnbits.utils.nostr import normalize_private_key
 
@@ -123,3 +135,134 @@ def _notification_message_to_text(
         text = meesage_value
     text = f"""[{settings.lnbits_site_title}]\n{text}"""
     return message_type, text
+
+
+async def dispatch_webhook(payment: Payment):
+    """
+    Dispatches the webhook to the webhook url.
+    """
+    logger.debug("sending webhook", payment.webhook)
+
+    if not payment.webhook:
+        return await mark_webhook_sent(payment.payment_hash, -1)
+
+    headers = {"User-Agent": settings.user_agent}
+    async with httpx.AsyncClient(headers=headers) as client:
+        data = payment.dict()
+        try:
+            check_callback_url(payment.webhook)
+            r = await client.post(payment.webhook, json=data, timeout=40)
+            r.raise_for_status()
+            await mark_webhook_sent(payment.payment_hash, r.status_code)
+        except httpx.HTTPStatusError as exc:
+            await mark_webhook_sent(payment.payment_hash, exc.response.status_code)
+            logger.warning(
+                f"webhook returned a bad status_code: {exc.response.status_code} "
+                f"while requesting {exc.request.url!r}."
+            )
+        except httpx.RequestError:
+            await mark_webhook_sent(payment.payment_hash, -1)
+            logger.warning(f"Could not send webhook to {payment.webhook}")
+
+
+async def send_payment_notification(wallet: Wallet, payment: Payment):
+    try:
+        await send_ws_payment_notification(wallet, payment)
+    except Exception as e:
+        logger.error("Error sending websocket payment notification", e)
+    try:
+        send_chat_payment_notification(wallet, payment)
+    except Exception as e:
+        logger.error("Error sending chat payment notification", e)
+    try:
+        await send_payment_push_notification(wallet, payment)
+    except Exception as e:
+        logger.error("Error sending push payment notification", e)
+
+    if payment.webhook and not payment.webhook_status:
+        await dispatch_webhook(payment)
+
+
+async def send_ws_payment_notification(wallet: Wallet, payment: Payment):
+    # TODO: websocket message should be a clean payment model
+    # await websocket_manager.send_data(payment.json(), wallet.inkey)
+    # TODO: figure out why we send the balance with the payment here.
+    # cleaner would be to have a separate message for the balance
+    # and send it with the id of the wallet so wallets can subscribe to it
+    payment_notification = json.dumps(
+        {
+            "wallet_balance": wallet.balance,
+            # use pydantic json serialization to get the correct datetime format
+            "payment": json.loads(payment.json()),
+        },
+    )
+    await websocket_manager.send_data(payment_notification, wallet.inkey)
+    await websocket_manager.send_data(payment_notification, wallet.adminkey)
+
+    await websocket_manager.send_data(
+        json.dumps({"pending": payment.pending}), payment.payment_hash
+    )
+
+
+def send_chat_payment_notification(wallet: Wallet, payment: Payment):
+    amount_sats = abs(payment.sat)
+    values: dict = {
+        "wallet_id": wallet.id,
+        "wallet_name": wallet.name,
+        "amount_sats": amount_sats,
+        "fiat_value_fmt": "",
+    }
+    if payment.extra.get("wallet_fiat_currency", None):
+        amount_fiat = payment.extra.get("wallet_fiat_amount", None)
+        currency = payment.extra.get("wallet_fiat_currency", None)
+        values["fiat_value_fmt"] = f"`{amount_fiat}`*{currency}* / "
+
+    if payment.is_out:
+        if amount_sats >= settings.lnbits_notification_outgoing_payment_amount_sats:
+            enqueue_notification(NotificationType.outgoing_payment, values)
+    else:
+        if amount_sats >= settings.lnbits_notification_incoming_payment_amount_sats:
+            enqueue_notification(NotificationType.incoming_payment, values)
+
+
+async def send_payment_push_notification(wallet: Wallet, payment: Payment):
+    subscriptions = await get_webpush_subscriptions_for_user(wallet.user)
+
+    amount = int(payment.amount / 1000)
+
+    title = f"LNbits: {wallet.name}"
+    body = f"You just received {amount} sat{'s'[:amount^1]}!"
+
+    if payment.memo:
+        body += f"\r\n{payment.memo}"
+
+    for subscription in subscriptions:
+        # todo: review permissions when user-id-only not allowed
+        # todo: replace all this logic with websockets?
+        url = f"https://{subscription.host}/wallet?usr={wallet.user}&wal={wallet.id}"
+        await send_push_notification(subscription, title, body, url)
+
+
+async def send_push_notification(subscription, title, body, url=""):
+    vapid = Vapid()
+    try:
+        logger.debug("sending push notification")
+        webpush(
+            json.loads(subscription.data),
+            json.dumps({"title": title, "body": body, "url": url}),
+            (
+                vapid.from_pem(bytes(settings.lnbits_webpush_privkey, "utf-8"))
+                if settings.lnbits_webpush_privkey
+                else None
+            ),
+            {"aud": "", "sub": "mailto:alan@lnbits.com"},
+        )
+    except WebPushException as e:
+        if e.response and e.response.status_code == HTTPStatus.GONE:
+            # cleanup unsubscribed or expired push subscriptions
+            await delete_webpush_subscriptions(subscription.endpoint)
+        else:
+            logger.error(
+                f"failed sending push notification: "
+                f"{e.response.text if e.response else e}"
+            )