Files
place4bees.com/backend/apps/backend/src/jobs/process-subscriptions.ts
T
torbinus ad75738c07 Abo-Folgelieferungen zum vereinbarten Glaspreis
Der Abo-Job rechnete jede Folgelieferung zum Ladenpreis der gezogenen
Sorte ab. Im Test kostete die erste Lieferung 12,39 €, die zweite
11,39 € (Frühlingsblütenhonig 5,90 € statt Abo-Preis 6,90 €). Der Kunde
hat aber dem Preis auf der Abo-Seite zugestimmt.

Jetzt merkt sich das Abo den Bestellposten aus dem Abschluss
(source_line_item_id, bisher nur bei Geschenken gefüllt), und der Job
übernimmt dessen Glaspreis. Bewusst nicht der aktuelle Abo-Preis: eine
Preisänderung im Admin soll laufende Verträge nicht still verteuern.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-26 10:15:23 +01:00

327 lines
12 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import type { MedusaContainer } from "@medusajs/framework/types";
import { Modules } from "@medusajs/framework/utils";
import {
createCartWorkflow,
addShippingMethodToCartWorkflow,
createPaymentCollectionForCartWorkflow,
createPaymentSessionsWorkflow,
completeCartWorkflow,
updateCartPromotionsWorkflow,
} from "@medusajs/core-flows";
import { SUBSCRIPTION_MODULE } from "../modules/subscription";
import { pickHoneyVariant } from "../lib/honey-picker";
import { varietyPerGlass, groupByVariant } from "../lib/subscription-varieties";
import { chargeRecurring, isMollieConfigured } from "../lib/mollie";
import { SUBSCRIPTION_PROMO_CODE } from "../lib/subscription-promotion";
import { ensureGiftPromotions, GIFT_ITEMS_CODE, GIFT_SHIPPING_CODE } from "../lib/gift-promotion";
/** Nach so vielen Fehlversuchen wird das Abo pausiert statt endlos zu wiederholen. */
const MAX_FAILED_ATTEMPTS = 3;
/**
* Lesbarer Text zu einem Fehler.
*
* Medusas Workflows werfen nicht immer `Error`, sondern auch Listen und
* einfache Objekte — `String(fehler)` ergab dann "[object Object]" und das
* Protokoll war wertlos.
*/
/**
* Die Lieferadresse so, wie ein neuer Warenkorb sie annimmt.
*
* Im Abo liegt die Adresse so, wie sie an der Bestellung stand — mitsamt
* ihrer ID. Gibt man die unverändert weiter, versucht Medusa eine Adresse
* mit derselben ID anzulegen und bricht mit "already exists" ab. Es gehen
* deshalb nur die Felder mit, die eine Anschrift ausmachen.
*/
const ADRESSFELDER = [
"first_name",
"last_name",
"company",
"address_1",
"address_2",
"city",
"postal_code",
"province",
"country_code",
"phone",
] as const;
function adresseFuerWarenkorb(adresse: any): Record<string, any> | undefined {
if (!adresse || typeof adresse !== "object") return undefined;
const sauber: Record<string, any> = {};
for (const feld of ADRESSFELDER) {
const wert = adresse[feld];
if (wert !== undefined && wert !== null && wert !== "") sauber[feld] = wert;
}
return Object.keys(sauber).length ? sauber : undefined;
}
/** Glaspreis aus dem Bestellposten, mit dem das Abo abgeschlossen wurde. */
async function vereinbarterGlaspreis(
container: MedusaContainer,
lineItemId: string | null | undefined
): Promise<number | null> {
if (!lineItemId) return null;
const orders: any = container.resolve(Modules.ORDER);
const [item] = await orders.listOrderLineItems({ id: lineItemId }, { select: ["unit_price"] });
return item ? Number(item.unit_price) : null;
}
function fehlertext(fehler: unknown): string {
if (fehler instanceof Error) return fehler.message;
if (Array.isArray(fehler)) return fehler.map(fehlertext).join(" | ");
if (fehler && typeof fehler === "object") {
const o = fehler as Record<string, any>;
if (typeof o.message === "string") return o.message;
if (o.error) return fehlertext(o.error);
try {
return JSON.stringify(fehler);
} catch {
return Object.prototype.toString.call(fehler);
}
}
return String(fehler);
}
/**
* Erzeugt die fälligen Abo-Bestellungen.
*
* Ablauf je Abo:
* 1. Sorte bestimmen (fest oder Zufall ohne Wiederholung)
* 2. Warenkorb bauen und abschließen -> Bestellung entsteht sofort
* 3. Bei Mollie wiederkehrend abbuchen
* 4. Der Mollie-Webhook erfasst die Zahlung, sobald sie eingeht
* -> der Subscriber auto-fulfill-on-payment erzeugt das Label
*
* Die Bestellung entsteht bewusst VOR der Abbuchung: SEPA-Lastschrift
* bestätigt erst nach Tagen. So sieht der Kunde die Bestellung sofort, und
* das Label entsteht trotzdem erst mit dem Geldeingang.
*/
export default async function processSubscriptions(container: MedusaContainer) {
const logger = container.resolve("logger");
const query = container.resolve("query");
const subscriptions: any = container.resolve(SUBSCRIPTION_MODULE);
let due = await subscriptions.listDue(new Date());
// Vorausbezahlte Geschenke brauchen kein Mollie — sie werden nie
// abgebucht. Fehlt der Schlüssel, laufen deshalb nur sie weiter, statt
// den ganzen Job stillzulegen.
if (!isMollieConfigured()) {
const abgebucht = due.filter((sub: any) => !sub.prepaid).length;
due = due.filter((sub: any) => sub.prepaid);
if (abgebucht) {
logger.warn(
`[abo] MOLLIE_API_KEY fehlt — ${abgebucht} abzubuchende(s) Abo(s) übersprungen.`
);
}
}
if (!due.length) {
logger.info("[abo] Keine fälligen Abos.");
return;
}
logger.info(`[abo] ${due.length} fällige Abo(s).`);
// Die Nachlässe für Geschenke einmal je Lauf sicherstellen.
if (due.some((sub: any) => sub.prepaid)) {
await ensureGiftPromotions(container);
}
for (const sub of due) {
try {
// Bei fester Sorte steht für jedes Glas eine Variante fest; gleiche
// Sorten werden zu einem Posten zusammengefasst. Geprüft wird jede
// Sorte einmal, nicht je Glas — sonst liefe dieselbe Abfrage mehrfach.
const perGlass = varietyPerGlass(sub);
let items: { variant_id: string; quantity: number; unit_price?: number }[];
let lastVariantId: string;
let delivered: string;
if (perGlass.length) {
items = groupByVariant(perGlass);
const checked = await Promise.all(
items.map((item) =>
pickHoneyVariant({ query, fixedVariantId: item.variant_id, size: sub.size })
)
);
delivered = checked
.map((variant, index) => `${items[index].quantity}× ${variant.productTitle} – ${variant.title}`)
.join(", ");
lastVariantId = items[0].variant_id;
} else {
const picked = await pickHoneyVariant({
query,
excludeVariantId: sub.last_variant_id,
size: sub.size,
});
items = [{ variant_id: picked.variantId, quantity: sub.quantity }];
delivered = `${sub.quantity}× ${picked.productTitle} – ${picked.title}`;
lastVariantId = picked.variantId;
}
// Abgerechnet wird der Glaspreis aus dem Abschluss, nicht der Ladenpreis
// der gezogenen Sorte — sonst schwankt der Betrag je nach Sorte und
// weicht vom Preis ab, dem der Kunde zugestimmt hat.
if (!sub.prepaid) {
const agreed = await vereinbarterGlaspreis(container, sub.source_line_item_id);
if (agreed === null) {
logger.warn(
`[abo] ${sub.id}: kein vereinbarter Glaspreis hinterlegt — es gilt der Preis der Sorte.`
);
} else {
items = items.map((item) => ({ ...item, unit_price: agreed }));
}
}
const { result: cart } = await createCartWorkflow(container).run({
input: {
region_id: sub.region_id,
email: sub.email,
currency_code: sub.currency_code,
customer_id: sub.customer_id ?? undefined,
sales_channel_id: sub.sales_channel_id ?? undefined,
shipping_address: adresseFuerWarenkorb(sub.shipping_address),
items,
metadata: { subscription_id: sub.id },
} as any,
});
// Abo-Rabatt anwenden, falls im Admin eingestellt. Läuft über die
// Rabatt-Engine, damit Steuer und Summen stimmen.
if (sub.shipping_option_id) {
await addShippingMethodToCartWorkflow(container).run({
input: { cart_id: (cart as any).id, options: [{ id: sub.shipping_option_id }] },
});
}
// Erst jetzt, mit Versandart im Warenkorb: ein Versandnachlass kann
// sonst nichts finden, worauf er wirken soll.
const settings = await subscriptions.getSettings();
// Beim Geschenk ist alles bezahlt: Ware und Versand gehen auf 0, ein
// Abo-Rabatt hätte darauf keine Wirkung mehr.
const codes = sub.prepaid
? [GIFT_ITEMS_CODE, GIFT_SHIPPING_CODE]
: (settings?.discount_percent ?? 0) > 0
? [SUBSCRIPTION_PROMO_CODE]
: [];
if (codes.length) {
await updateCartPromotionsWorkflow(container).run({
input: { cart_id: (cart as any).id, promo_codes: codes, action: "add" },
} as any);
}
const { result: sammlung } = await createPaymentCollectionForCartWorkflow(container).run({
input: { cart_id: (cart as any).id },
});
// Ohne Zahlungssitzung lässt sich der Warenkorb nicht abschließen.
// Sie läuft über den manuellen Anbieter — beim Geschenk ist der Betrag
// ohnehin 0, beim laufenden Abo bucht Mollie außerhalb von Medusa ab
// und der Webhook trägt die Zahlung nach.
await createPaymentSessionsWorkflow(container).run({
input: {
payment_collection_id: (sammlung as any).id,
provider_id: "pp_system_default",
},
});
const { result: completed } = await completeCartWorkflow(container).run({
input: { id: (cart as any).id },
});
const orderId = (completed as any)?.id;
// Betrag aus der fertigen Bestellung, nicht aus dem Warenkorb: erst
// dort stehen Steuer und Versand endgültig fest.
const { data: orders } = await query.graph({
entity: "order",
fields: ["id", "display_id", "total", "currency_code"],
filters: { id: orderId },
});
const order = orders?.[0];
if (sub.prepaid) {
// Nichts abzubuchen. Damit trotzdem ein Label entsteht, muss die
// Zahlung als erledigt gelten — der Nachlass hat den Betrag auf 0
// gesetzt, es gibt also nichts einzuziehen.
const verbleibend = Math.max(0, (sub.remaining_deliveries ?? 1) - 1);
const beendet = verbleibend === 0;
await subscriptions.updateSubscriptions({
id: sub.id,
last_order_at: new Date(),
last_variant_id: lastVariantId,
remaining_deliveries: verbleibend,
failed_attempts: 0,
last_error: null,
...(beendet
? {
status: "canceled",
canceled_at: new Date(),
cancel_reason: "Laufzeit des Geschenk-Abos beendet",
}
: {
next_order_at: subscriptions.computeNextOrderDate(sub.interval, new Date()),
}),
});
logger.info(
`[abo] ${sub.id}: Geschenk-Lieferung ${order.display_id} angelegt, ${delivered}, ` +
(beendet ? "letzte Lieferung." : `noch ${verbleibend} Lieferung(en).`)
);
} else {
const payment = await chargeRecurring({
customerId: sub.mollie_customer_id,
mandateId: sub.mollie_mandate_id,
amount: Number(order.total),
currency: String(order.currency_code ?? "eur").toUpperCase(),
description: `place4bees Honig-Abo – Bestellung ${order.display_id}`,
webhookUrl: process.env.MOLLIE_WEBHOOK_URL,
metadata: { subscription_id: sub.id, order_id: orderId },
});
await subscriptions.updateSubscriptions({
id: sub.id,
last_order_at: new Date(),
last_variant_id: lastVariantId,
next_order_at: subscriptions.computeNextOrderDate(sub.interval, new Date()),
failed_attempts: 0,
last_error: null,
});
logger.info(
`[abo] ${sub.id}: Bestellung ${order.display_id} angelegt, ${delivered}, ` +
`Mollie-Zahlung ${payment.id} (${payment.status}). Label folgt mit dem Zahlungseingang.`
);
}
} catch (error) {
const message = fehlertext(error);
const attempts = (sub.failed_attempts ?? 0) + 1;
const pause = attempts >= MAX_FAILED_ATTEMPTS;
await subscriptions.updateSubscriptions({
id: sub.id,
failed_attempts: attempts,
last_error: message.slice(0, 500),
...(pause
? { status: "paused", paused_at: new Date() }
: // In drei Tagen erneut versuchen, nicht im nächsten Lauf.
{ next_order_at: new Date(Date.now() + 3 * 24 * 60 * 60 * 1000) }),
});
logger.error(
`[abo] ${sub.id}: Versuch ${attempts} fehlgeschlagen — ${message}` +
(pause ? " Abo pausiert, Kunde informieren." : "")
);
}
}
}
export const config = {
name: "process-subscriptions",
// Täglich um 06:00. Fällige Abos werden dabei nachgeholt, ein verpasster
// Lauf verliert also nichts.
schedule: "0 6 * * *",
};