ad75738c07
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>
327 lines
12 KiB
TypeScript
327 lines
12 KiB
TypeScript
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 * * *",
|
||
};
|