Compare commits

..
Author SHA1 Message Date
LarsandClaude Sonnet 5.5 69a22deb1f Sichere Rechnungs- und Livepfad ab und dokumentiere die Entscheidungen zum Verkaufsstart
CI Feature / test (push) Successful in 2m52s
Eine Bestellung auf Rechnung lässt sich auch mit dem Stripe-Treiber nicht per Karte
bezahlen; der Betreiber, der den Zahlungseingang bestätigt, wird an der Zahlung
festgehalten; im Livebetrieb ist der alte Einzelkauf ohne Pflichtangaben gesperrt und
placeFromCart verlangt die Zustimmungen. ADR-47, Domänenmodell, Lizenzlogik,
Kernabläufe, Szenarien, Fachanforderungen und DEPLOYMENT nachgeführt.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-22 20:11:24 +01:00
LarsandClaude Sonnet 5.5 f0287eec2f Mache den Anmeldetest deterministisch und entferne die doppelte Meldung in der Kasse
CI Feature / test (push) Successful in 3m26s
RegistrationTest: Der Name kam aus dem Faker und enthielt gelegentlich ein
Apostroph (O'Hara), das im HTML maskiert wird; der Test schlug dadurch zufällig im
Gitea-Lauf fehl. Der Name ist jetzt fest, die Assertion unverändert.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-22 20:02:41 +01:00
LarsandClaude Sonnet 5.5 42e0a6bb93 Mache den Download bei reiner Download-Lizenz erreichbar und zeige den Stand zum Verkaufsstart
CI Feature / test (push) Failing after 3m2s
Die Artikelseite zeigte bei einer Lizenz nur zum Herunterladen (kein Streamen oder
Ansehen) "Nicht enthalten"; jetzt bietet sie den Download. Tests belegen Einzelfilm
und Begleit-PDF aus der Bibliothek mit Dateiname und Zugriffsgrenzen. Neue
Verwaltungsseite Verkaufsstart nennt fehlende Rechtstexte und den Zustand der
Zahlungseinrichtung, ohne Schlüssel zu zeigen.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-22 19:58:22 +01:00
LarsandClaude Sonnet 5.5 76fab81386 Verwalte Rabattcodes mit Kontofreigabe und Bestellungen mit Rechnungsweg und Erstattung
Neue Verwaltungsseiten Rabattcodes (Anlegen und Bearbeiten in einer Maske, Konten
für genau diesen Code freischalten und entziehen) und Bestellungen (Zahlungseingang
bei Rechnung bestätigen, vollständig erstatten). Der Nutzerkreis ist in der
Angebotsmaske ein Pflichtfeld. BestandslisteTest: die Fassung ohne Nutzerkreis
verlangt jetzt dessen Angabe beim Bearbeiten; die geprüfte Aussage (verdeckte
Konditionen bleiben erhalten) ist unverändert.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-22 19:53:56 +01:00
LarsandClaude Sonnet 5.5 1ce2e1e51f Gib Paketen eine eigene Produktseite und ergänze Tests zu Nutzerkreis und Verkaufsstart
Ein eigenständig vermarktetes Paket (offers.standalone_bundle) erhält /pakete/{id}
mit seinem tatsächlichen Umfang, Shop-Kachel und Suche. Die Angebotsmaske kennt
Nutzerkreis und Anzahl Trainer. Zwei Bestandstests (CartTest, Vergleich der
Rechte und Erwerbsarten) legen die Vergleichsangebote jetzt als Einzellizenz an,
weil der Nutzerkreis zum identischen Umfang gehört; ihre Aussagen bleiben.
Eine Rechnungs- oder Stripe-Bestellung lässt sich nicht mit der Testzahlung bestätigen.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-22 19:47:15 +01:00
LarsandClaude Sonnet 5.5 0154182f3b Führe Rabattcodes, Nutzerkreis der Lizenzoption und Pflichtangaben der Kasse ein
Domäne: Rabattcodes mit Geltungsbereich (Warenkorb oder gewählte Ziele) und
Einlösungsberechtigung (allgemein oder freigeschaltete Konten) unabhängig
voneinander; Prüfung bei Eingabe, in jeder Übersicht und unter Sperre vor
Bestellabschluss (Prüfsumme der Übersicht enthält den Rabatt). Rabatt je
Position, Zwischensumme und Zahlbetrag in der Bestellung; Stripe erhält den
Preis nach Rabatt. Nutzerkreis (Einzel-/Mehrfachlizenz, Trainerzahl) an der
Angebotsfassung, kopiert in Bestellposition und Erwerb, Teil der Prüfung
"Bereits erworben". OfferService::activate lehnt Angebote ohne veröffentlichten
Artikelstand ab. Kasse: Zustimmungen als Pflichtangabe mit Nachweis,
"Zahlungspflichtig bestellen", Rechnungsweg für Organisationen, Erstattung über
Stripe, Widerruf erklären. Produktivfreigabe SHOP_LIVE_RELEASE standardmäßig aus.

Bestandstests geändert (fachlich überholt, Assertions nicht abgeschwächt): die
Schaltfläche heißt "Zahlungspflichtig bestellen" (§ 312j BGB), die Summe heißt
"Zu zahlen", der Vereinshinweis steht als Rollenliste; Bestellungen über die
Kasse senden jetzt die Zustimmungen.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-22 19:42:02 +01:00
80 changed files with 4986 additions and 132 deletions

No files matched your search

+90
View File
@@ -0,0 +1,90 @@
<?php
namespace App\Domain\Catalog;
/**
* Berechtigter Nutzerkreis einer Lizenzoption: Einzellizenz (ein Trainer) oder Mehrfachlizenz (festgelegte Zahl von
* Trainern). Das ist eine vertragliche Angabe der Lizenzoption. Sie ist unabhängig vom Lizenzinhaber (Person oder
* Verein), vom technischen Downloadzugriff (nur das bestellende Konto) und vom Nutzungszweck (ehrenamtlich,
* kommerziell, institutionell). Sie wird weder aus dem Zweck noch aus dem Preis abgeleitet.
*/
final class LicenceScope
{
public const SINGLE = 'einzel';
public const MULTI = 'mehrfach';
/** Obergrenze der Trainerzahl einer Mehrfachlizenz (Eingabeschutz). */
public const MAX_TRAINERS = 999;
/**
* @return array{0: ?string, 1: ?int} Nutzerkreis und Trainerzahl, geprüft und vereinheitlicht
*/
public static function normalise(?string $scope, mixed $trainers): array
{
$scope = filled($scope) ? (string) $scope : null;
if ($scope === null) {
if (filled($trainers)) {
throw new DomainRuleException('Die Trainerzahl gehört zu einer Einzel- oder Mehrfachlizenz. Wähle zuerst den Nutzerkreis.');
}
return [null, null];
}
if ($scope === self::SINGLE) {
if (filled($trainers) && (int) $trainers !== 1) {
throw new DomainRuleException('Eine Einzellizenz gilt für genau einen Trainer.');
}
return [self::SINGLE, 1];
}
if ($scope === self::MULTI) {
$count = filled($trainers) ? (int) $trainers : 0;
if ($count < 2 || $count > self::MAX_TRAINERS) {
throw new DomainRuleException('Eine Mehrfachlizenz gilt für mindestens 2 und höchstens '.self::MAX_TRAINERS.' Trainer. Gib die Zahl der Trainer an.');
}
return [self::MULTI, $count];
}
throw new DomainRuleException('Der Nutzerkreis ist Einzellizenz oder Mehrfachlizenz.');
}
/** Kurzform: „Einzellizenz · 1 Trainer“, „Mehrfachlizenz · bis zu 5 Trainer“ oder „keine Angabe“. */
public static function label(?string $scope, ?int $trainers): string
{
return match ($scope) {
self::SINGLE => 'Einzellizenz · 1 Trainer',
self::MULTI => 'Mehrfachlizenz · bis zu '.(int) $trainers.' Trainer',
default => 'Nutzerkreis nicht festgelegt',
};
}
/** Erklärung für Käufer: was der Umfang bedeutet und was er nicht bedeutet. */
public static function explanation(?string $scope, ?int $trainers): ?string
{
return match ($scope) {
self::SINGLE => 'Die Inhalte dürfen von einem Trainer eingesetzt werden.',
self::MULTI => 'Die Inhalte dürfen von bis zu '.(int) $trainers.' Trainern eingesetzt werden. Zugriff und Download erhält zum Start nur das bestellende Konto.',
default => null,
};
}
/** Wert für Vergleich identischer Lizenzen („Bereits erworben“). */
public static function key(?string $scope, ?int $trainers): string
{
return ($scope ?? '-').'|'.($trainers ?? 0);
}
/** @return array<string, string> */
public static function options(): array
{
return [
self::SINGLE => 'Einzellizenz (ein Trainer)',
self::MULTI => 'Mehrfachlizenz (mehrere Trainer)',
];
}
}
+8
View File
@@ -12,8 +12,16 @@ class Offer extends Model
'name', 'name',
'composition_id', 'composition_id',
'option_label', 'option_label',
'standalone_bundle',
]; ];
protected function casts(): array
{
return [
'standalone_bundle' => 'boolean',
];
}
/** Komposition, deren öffentliche Seite die Produktseite dieser Lizenzoption ist. */ /** Komposition, deren öffentliche Seite die Produktseite dieser Lizenzoption ist. */
public function composition(): BelongsTo public function composition(): BelongsTo
{ {
+42 -1
View File
@@ -102,10 +102,18 @@ public function activate(Offer $offer, array $lines, array $attributes = []): Of
'dynamic' => false, 'dynamic' => false,
'grant_kind' => 'kauf', 'grant_kind' => 'kauf',
'holder_kind' => 'person', 'holder_kind' => 'person',
'licence_scope' => null,
'trainer_count' => null,
], $attributes); ], $attributes);
if ($offer->standalone_bundle && (count($lines) !== 1 || ! $lines[0]['target'] instanceof BundleVersion)) {
throw new DomainRuleException('Ein Angebot mit eigener Paketseite besteht aus genau einer Paketfassung. Wähle eine Paketfassung oder ordne das Angebot der Seite eines Programms zu.');
}
$this->assertAttributes($attributes); $this->assertAttributes($attributes);
[$attributes['licence_scope'], $attributes['trainer_count']] = LicenceScope::normalise($attributes['licence_scope'], $attributes['trainer_count']);
$scope = $this->scopeFor($lines); $scope = $this->scopeFor($lines);
$this->assertSellableContent($scope);
$this->assertCoverage($lines, $attributes); $this->assertCoverage($lines, $attributes);
return DB::transaction(function () use ($offer, $lines, $attributes, $scope): OfferVersion { return DB::transaction(function () use ($offer, $lines, $attributes, $scope): OfferVersion {
@@ -126,6 +134,8 @@ public function activate(Offer $offer, array $lines, array $attributes = []): Of
'dynamic' => $attributes['dynamic'], 'dynamic' => $attributes['dynamic'],
'grant_kind' => $attributes['grant_kind'], 'grant_kind' => $attributes['grant_kind'],
'holder_kind' => $attributes['holder_kind'], 'holder_kind' => $attributes['holder_kind'],
'licence_scope' => $attributes['licence_scope'],
'trainer_count' => $attributes['trainer_count'],
]); ]);
foreach (array_values($lines) as $index => $line) { foreach (array_values($lines) as $index => $line) {
@@ -176,13 +186,18 @@ public function end(Offer $offer): OfferVersion
* Produktzuordnung der Option: Die Komposition bestimmt die öffentliche Produktseite und die Alternativgruppe, * Produktzuordnung der Option: Die Komposition bestimmt die öffentliche Produktseite und die Alternativgruppe,
* die Bezeichnung benennt die Option auf dieser Seite. Beides sind keine bindenden Konditionen. * die Bezeichnung benennt die Option auf dieser Seite. Beides sind keine bindenden Konditionen.
*/ */
public function assignProduct(Offer $offer, ?int $compositionId, ?string $optionLabel): Offer public function assignProduct(Offer $offer, ?int $compositionId, ?string $optionLabel, bool $ownBundlePage = false): Offer
{ {
if ($compositionId !== null) { if ($compositionId !== null) {
Composition::query()->findOrFail($compositionId); Composition::query()->findOrFail($compositionId);
} }
if ($ownBundlePage && $compositionId !== null) {
throw new DomainRuleException('Ein Paket hat entweder eine eigene Paketseite oder die Seite eines Programms, nicht beides.');
}
$offer->composition_id = $compositionId; $offer->composition_id = $compositionId;
$offer->standalone_bundle = $ownBundlePage;
$offer->option_label = filled($optionLabel) ? trim((string) $optionLabel) : null; $offer->option_label = filled($optionLabel) ? trim((string) $optionLabel) : null;
$offer->save(); $offer->save();
@@ -219,6 +234,32 @@ private function assertAttributes(array $attributes): void
} }
} }
/**
* Ein Angebot ohne verkaufbaren Inhalt wird nicht aktiviert: Jeder Lizenzartikel des Umfangs braucht einen
* veröffentlichten Stand, sonst erhielten Käufer nichts. Die Prüfung liegt im Domänenmodell, nicht nur in der
* Maske, damit auch jeder andere Weg (Skript, Import) sie durchläuft.
*
* @param list<array{license_article_id: int, rights_profile_version_id: int}> $scope
*/
private function assertSellableContent(array $scope): void
{
$ids = array_values(array_unique(array_column($scope, 'license_article_id')));
$missing = LicenseArticle::query()->with('currentRelease')->whereIn('id', $ids)->orderBy('code')->get()
->filter(fn (LicenseArticle $article): bool => ! ($article->currentRelease instanceof ArticleRelease
&& StatusValue::of($article->currentRelease->status) === ReleaseStatus::Veroeffentlicht->value));
if ($missing->isEmpty()) {
return;
}
$names = $missing->map(fn (LicenseArticle $article): string => '„'.($article->working_title ?: $article->code).'“ ('.$article->code.')')->implode(', ');
throw new DomainRuleException(($missing->count() === 1 ? 'Der Lizenzartikel ' : 'Die Lizenzartikel ').$names
.($missing->count() === 1 ? ' hat' : ' haben')
.' noch keinen veröffentlichten Stand und vergibt'.($missing->count() === 1 ? '' : ' keine').' keine Inhalte. '
.'Lege zuerst am Artikel den Inhalt fest, bevor das Angebot aktiviert wird.');
}
/** /**
* @param list<array{target: LicenseArticle|BundleVersion, rights: RightsProfileVersion}> $lines * @param list<array{target: LicenseArticle|BundleVersion, rights: RightsProfileVersion}> $lines
* @return list<array{license_article_id: int, rights_profile_version_id: int}> * @return list<array{license_article_id: int, rights_profile_version_id: int}>
+2
View File
@@ -19,6 +19,8 @@ class OfferVersion extends Model
'dynamic', 'dynamic',
'grant_kind', 'grant_kind',
'holder_kind', 'holder_kind',
'licence_scope',
'trainer_count',
'activated_at', 'activated_at',
]; ];
+62 -6
View File
@@ -6,6 +6,9 @@
use App\Domain\Catalog\Offer; use App\Domain\Catalog\Offer;
use App\Domain\Catalog\OfferService; use App\Domain\Catalog\OfferService;
use App\Domain\Catalog\OfferVersion; use App\Domain\Catalog\OfferVersion;
use App\Domain\Commerce\Discount\DiscountCode;
use App\Domain\Commerce\Discount\DiscountResult;
use App\Domain\Commerce\Discount\DiscountService;
use App\Domain\Identity\Party; use App\Domain\Identity\Party;
use App\Domain\Identity\PartyType; use App\Domain\Identity\PartyType;
use App\Models\User; use App\Models\User;
@@ -20,6 +23,9 @@ class Cart
{ {
public const KEY = 'shop.cart'; public const KEY = 'shop.cart';
/** Eingelöster Rabattcode (Kennung); höchstens einer je Bestellung. */
public const DISCOUNT_KEY = 'shop.discount';
public const ADDED = 'added'; public const ADDED = 'added';
public const PRESENT = 'present'; public const PRESENT = 'present';
@@ -32,6 +38,7 @@ public function __construct(
private readonly OwnershipCheck $ownership, private readonly OwnershipCheck $ownership,
private readonly OrderHolders $holders, private readonly OrderHolders $holders,
private readonly OfferService $offers, private readonly OfferService $offers,
private readonly DiscountService $discounts,
) {} ) {}
/** /**
@@ -57,7 +64,10 @@ public function has(Offer $offer): bool
*/ */
public function alternativeTo(Offer $offer): ?Offer public function alternativeTo(Offer $offer): ?Offer
{ {
if ($offer->composition_id === null) { $products = app(ProductOptions::class);
$group = $products->groupKey($offer);
if ($group === null) {
return null; return null;
} }
@@ -65,8 +75,8 @@ public function alternativeTo(Offer $offer): ?Offer
return $ids === [] ? null : Offer::query() return $ids === [] ? null : Offer::query()
->whereIn('id', $ids) ->whereIn('id', $ids)
->where('composition_id', $offer->composition_id) ->get()
->first(); ->first(fn (Offer $other): bool => $products->groupKey($other) === $group);
} }
public function add(Offer $offer): string public function add(Offer $offer): string
@@ -133,13 +143,51 @@ public function acceptCurrent(Offer $offer): void
public function clear(): void public function clear(): void
{ {
session()->forget(self::KEY); session()->forget([self::KEY, self::DISCOUNT_KEY]);
}
/** Der im Warenkorb eingelöste Code, auch wenn er gerade nicht (mehr) gilt. */
public function discountCode(): ?DiscountCode
{
$id = session()->get(self::DISCOUNT_KEY);
return is_numeric($id) ? DiscountCode::query()->with('targets')->find((int) $id) : null;
}
/**
* Löst einen Code ein. Er wird nur vorgemerkt, wenn er für diesen Warenkorb und dieses Konto gilt; sonst bleibt
* der bisherige Stand und das Ergebnis nennt den Grund. Ein zweiter Code ersetzt den ersten (höchstens ein Code).
*/
public function applyCode(string $input, ?User $user, ?int $holderPartyId = null): DiscountResult
{
$code = $this->discounts->find($input);
if ($code === null) {
return new DiscountResult(null, DiscountResult::UNKNOWN, 'Diesen Code kennen wir nicht. Prüfe die Schreibweise.');
}
$previous = session()->get(self::DISCOUNT_KEY);
session()->put(self::DISCOUNT_KEY, $code->id);
$result = $this->review($user, $holderPartyId)->discount;
if ($result === null || ! $result->applied()) {
$previous === null ? session()->forget(self::DISCOUNT_KEY) : session()->put(self::DISCOUNT_KEY, $previous);
return $result ?? new DiscountResult($code, DiscountResult::NO_MATCH, 'Der Code kann auf diese Bestellung nicht angewendet werden.');
}
return $result;
}
public function removeCode(): void
{
session()->forget(self::DISCOUNT_KEY);
} }
/** /**
* Serverseitige Prüfung: aktuelle Fassung, Preis, Kaufbarkeit, passende Inhaberart, vorhandene Rechte. * Serverseitige Prüfung: aktuelle Fassung, Preis, Kaufbarkeit, passende Inhaberart, vorhandene Rechte.
*/ */
public function review(?User $user = null, ?int $holderPartyId = null): CartReview public function review(?User $user = null, ?int $holderPartyId = null, bool $lockDiscount = false): CartReview
{ {
$offers = Offer::query() $offers = Offer::query()
->whereIn('id', array_keys($this->items())) ->whereIn('id', array_keys($this->items()))
@@ -203,7 +251,15 @@ public function review(?User $user = null, ?int $holderPartyId = null): CartRevi
} }
} }
return new CartReview($lines, $holder); $code = $this->discountCode();
$discount = null;
if ($code !== null) {
$orderable = array_values(array_filter($lines, fn (CartLine $line): bool => $line->orderable()));
$discount = $this->discounts->evaluate($code, $user, $orderable, lock: $lockDiscount);
}
return new CartReview($lines, $holder, $discount);
} }
/** /**
+8
View File
@@ -45,6 +45,14 @@ public function blocks(): bool
public function title(): string public function title(): string
{ {
if ($this->offer->standalone_bundle && $this->version !== null) {
$bundle = app(ProductOptions::class)->bundleOf($this->version);
if ($bundle !== null) {
return (string) $bundle->name;
}
}
$composition = $this->offer->composition; $composition = $this->offer->composition;
return $composition !== null return $composition !== null
+29 -3
View File
@@ -2,6 +2,7 @@
namespace App\Domain\Commerce; namespace App\Domain\Commerce;
use App\Domain\Commerce\Discount\DiscountResult;
use App\Domain\Identity\Party; use App\Domain\Identity\Party;
/** /**
@@ -16,6 +17,7 @@ final class CartReview
public function __construct( public function __construct(
public readonly array $lines, public readonly array $lines,
public readonly ?Party $holder, public readonly ?Party $holder,
public readonly ?DiscountResult $discount = null,
) {} ) {}
/** @return list<CartLine> */ /** @return list<CartLine> */
@@ -24,11 +26,35 @@ public function orderable(): array
return array_values(array_filter($this->lines, fn (CartLine $line): bool => $line->orderable())); return array_values(array_filter($this->lines, fn (CartLine $line): bool => $line->orderable()));
} }
public function totalCents(): int /** Summe der Listenpreise der Positionen, die in die Bestellung eingehen. */
public function subtotalCents(): int
{ {
return array_sum(array_map(fn (CartLine $line): int => (int) $line->currentPriceCents, $this->orderable())); return array_sum(array_map(fn (CartLine $line): int => (int) $line->currentPriceCents, $this->orderable()));
} }
public function discountCents(): int
{
return $this->discount?->totalCents() ?? 0;
}
/** Endgültiger Zahlbetrag: Listenpreise abzüglich Rabatt. */
public function totalCents(): int
{
return $this->subtotalCents() - $this->discountCents();
}
/** Rabatt einer Position in Cent. */
public function discountFor(CartLine $line): int
{
return $this->discount?->forOffer($line->offer->id) ?? 0;
}
/** Ein vorgemerkter Code, der jetzt nicht gilt, hält die Bestellung an, bis er entfernt wird. */
public function discountBlocks(): bool
{
return $this->discount !== null && ! $this->discount->applied();
}
public function blocked(): bool public function blocked(): bool
{ {
foreach ($this->lines as $line) { foreach ($this->lines as $line) {
@@ -47,7 +73,7 @@ public function empty(): bool
public function canOrder(): bool public function canOrder(): bool
{ {
return $this->holder !== null && ! $this->blocked() && ! $this->empty(); return $this->holder !== null && ! $this->blocked() && ! $this->empty() && ! $this->discountBlocks();
} }
public function digest(): string public function digest(): string
@@ -60,6 +86,6 @@ public function digest(): string
sort($parts); sort($parts);
return hash('sha256', ($this->holder?->id ?? 0).'|'.implode(',', $parts)); return hash('sha256', ($this->holder?->id ?? 0).'|'.implode(',', $parts).'|'.($this->discount?->digestPart() ?? '-'));
} }
} }
+116 -14
View File
@@ -6,12 +6,15 @@
use App\Domain\Catalog\Offer; use App\Domain\Catalog\Offer;
use App\Domain\Catalog\OfferService; use App\Domain\Catalog\OfferService;
use App\Domain\Catalog\OfferVersion; use App\Domain\Catalog\OfferVersion;
use App\Domain\Commerce\Discount\DiscountCode;
use App\Domain\Commerce\Stripe\StripeGateway;
use App\Domain\Entitlement\Acquisition; use App\Domain\Entitlement\Acquisition;
use App\Domain\Entitlement\AcquisitionType; use App\Domain\Entitlement\AcquisitionType;
use App\Domain\Entitlement\GrantIssuer; use App\Domain\Entitlement\GrantIssuer;
use App\Domain\Entitlement\GrantStatus; use App\Domain\Entitlement\GrantStatus;
use App\Domain\Identity\AccountStatus; use App\Domain\Identity\AccountStatus;
use App\Domain\Identity\Party; use App\Domain\Identity\Party;
use App\Domain\Identity\PartyType;
use App\Mail\OrderConfirmed; use App\Mail\OrderConfirmed;
use App\Models\User; use App\Models\User;
use Illuminate\Support\Facades\DB; use Illuminate\Support\Facades\DB;
@@ -32,6 +35,12 @@ public function place(User $user, Offer $offer): Order
{ {
$this->assertActive($user); $this->assertActive($user);
// Dieser Einzelkauf kennt weder Zustimmungen noch „Zahlungspflichtig bestellen“. Im Livebetrieb gibt es nur den
// Weg über die Kasse mit Pflichtangaben.
if (Shop::live()) {
throw new DomainRuleException('Bestelle über den Warenkorb und die Kasse.');
}
$version = $this->offers->currentActiveVersion($offer); $version = $this->offers->currentActiveVersion($offer);
if ($version->grant_kind !== 'kauf' || $version->holder_kind !== 'person') { if ($version->grant_kind !== 'kauf' || $version->holder_kind !== 'person') {
@@ -44,7 +53,7 @@ public function place(User $user, Offer $offer): Order
$holder = $this->holders->resolve($user, null); $holder = $this->holders->resolve($user, null);
return DB::transaction(fn (): Order => $this->createOrder($user, $holder, [[$offer, $version]])); return DB::transaction(fn (): Order => $this->createOrder($user, $holder, [[$offer, $version]], null, null, Shop::driver() === 'stripe' ? 'stripe' : 'test'));
} }
/** /**
@@ -53,14 +62,25 @@ public function place(User $user, Offer $offer): Order
* Bestellung und der Käufer sieht zuerst die aktualisierte Übersicht. Positionen, deren Umfang der Inhaber bereits * Bestellung und der Käufer sieht zuerst die aktualisierte Übersicht. Positionen, deren Umfang der Inhaber bereits
* mit denselben Rechten besitzt, erzeugen keine Bestellposition. * mit denselben Rechten besitzt, erzeugen keine Bestellposition.
*/ */
public function placeFromCart(User $user, Cart $cart, ?int $holderPartyId, string $digest): Order public function placeFromCart(User $user, Cart $cart, ?int $holderPartyId, string $digest, ?array $consent = null, ?string $paymentMethod = null): Order
{ {
$this->assertActive($user); $this->assertActive($user);
$order = DB::transaction(function () use ($user, $cart, $holderPartyId, $digest): Order { if ($consent === null && Shop::live()) {
// Optionen sperren, damit eine gleichzeitige Aktivierung die Prüfung nicht unterläuft. throw new DomainRuleException('Bitte bestätige die Zustimmungen vor dem verbindlichen Abschluss.');
}
$order = DB::transaction(function () use ($user, $cart, $holderPartyId, $digest, $consent, $paymentMethod): Order {
// Optionen und den Rabattcode sperren, damit eine gleichzeitige Aktivierung, Deaktivierung oder ein Entzug
// der Freigabe die Prüfung nicht unterläuft.
Offer::query()->whereIn('id', array_keys($cart->items()))->orderBy('id')->lockForUpdate()->get(); Offer::query()->whereIn('id', array_keys($cart->items()))->orderBy('id')->lockForUpdate()->get();
$review = $cart->review($user, $holderPartyId); $discountId = session()->get(Cart::DISCOUNT_KEY);
if (is_numeric($discountId)) {
DiscountCode::query()->whereKey((int) $discountId)->lockForUpdate()->first();
}
$review = $cart->review($user, $holderPartyId, lockDiscount: true);
if ($review->holder === null) { if ($review->holder === null) {
throw new DomainRuleException('Für diesen Lizenzinhaber ist das Konto nicht bestellberechtigt.'); throw new DomainRuleException('Für diesen Lizenzinhaber ist das Konto nicht bestellberechtigt.');
@@ -78,9 +98,19 @@ public function placeFromCart(User $user, Cart $cart, ?int $holderPartyId, strin
throw new DomainRuleException('Es gibt nichts zu bestellen. Alle Positionen sind bereits erworben.'); throw new DomainRuleException('Es gibt nichts zu bestellen. Alle Positionen sind bereits erworben.');
} }
if ($review->discountBlocks()) {
throw new DomainRuleException(($review->discount?->message ?? 'Der Rabattcode gilt nicht.').' Entferne den Code, um ohne Rabatt zu bestellen.');
}
$method = $paymentMethod ?? (Shop::driver() === 'stripe' ? 'stripe' : 'test');
if ($method === 'rechnung' && ! ($review->holder->type === PartyType::Organisation && Shop::invoice())) {
throw new DomainRuleException('Der Kauf auf Rechnung ist nur für Vereine und Organisationen auf Anfrage möglich.');
}
$pairs = array_map(fn (CartLine $line): array => [$line->offer, $line->version], $review->orderable()); $pairs = array_map(fn (CartLine $line): array => [$line->offer, $line->version], $review->orderable());
return $this->createOrder($user, $review->holder, $pairs); return $this->createOrder($user, $review->holder, $pairs, $review, $consent === null ? null : SalesTerms::proof($consent), $method);
}); });
$cart->clear(); $cart->clear();
@@ -90,16 +120,28 @@ public function placeFromCart(User $user, Cart $cart, ?int $holderPartyId, strin
/** /**
* @param list<array{0: Offer, 1: OfferVersion}> $pairs * @param list<array{0: Offer, 1: OfferVersion}> $pairs
* @param array<string, mixed>|null $terms Nachweis der Zustimmungen (SalesTerms::proof)
*/ */
private function createOrder(User $user, Party $holder, array $pairs): Order private function createOrder(User $user, Party $holder, array $pairs, ?CartReview $review, ?array $terms, string $method): Order
{ {
$subtotal = array_sum(array_map(fn (array $pair): int => (int) $pair[1]->price_cents, $pairs));
$discount = $review?->discount;
$discountCents = $review?->discountCents() ?? 0;
$order = Order::query()->create([ $order = Order::query()->create([
'user_id' => $user->id, 'user_id' => $user->id,
'party_id' => $holder->id, 'party_id' => $holder->id,
'status' => 'offen', 'status' => 'offen',
'holder_kind' => $holder->type->value, 'holder_kind' => $holder->type->value,
'total_cents' => array_sum(array_map(fn (array $pair): int => (int) $pair[1]->price_cents, $pairs)), 'subtotal_cents' => $subtotal,
'discount_cents' => $discountCents,
'total_cents' => $subtotal - $discountCents,
'currency' => 'EUR', 'currency' => 'EUR',
'discount_code_id' => $discountCents > 0 ? $discount?->code?->id : null,
'discount_snapshot' => $discountCents > 0 ? $discount?->snapshot() : null,
'payment_method' => $method,
'terms_accepted_at' => $terms === null ? null : now(),
'terms_snapshot' => $terms,
]); ]);
foreach ($pairs as [$offer, $version]) { foreach ($pairs as [$offer, $version]) {
@@ -114,6 +156,9 @@ private function createOrder(User $user, Party $holder, array $pairs): Order
'tax_class' => $version->tax_class, 'tax_class' => $version->tax_class,
'grant_kind' => $version->grant_kind, 'grant_kind' => $version->grant_kind,
'holder_party_id' => $holder->id, 'holder_party_id' => $holder->id,
'licence_scope' => $version->licence_scope,
'trainer_count' => $version->trainer_count,
'discount_cents' => $discountCents > 0 ? $discount->forOffer($offer->id) : 0,
]); ]);
$version->load('resolvedScopes.rights'); $version->load('resolvedScopes.rights');
@@ -140,6 +185,7 @@ private function createOrder(User $user, Party $holder, array $pairs): Order
public function confirmTestPayment(Order $order, string $reference): Order public function confirmTestPayment(Order $order, string $reference): Order
{ {
$this->assertTestDriver(); $this->assertTestDriver();
$this->assertTestOrder($order);
return $this->settle($order, 'test', $reference); return $this->settle($order, 'test', $reference);
} }
@@ -150,7 +196,7 @@ public function confirmTestPayment(Order $order, string $reference): Order
*/ */
public function confirmProviderPayment(Order $order, string $provider, string $reference, int $amountCents, string $currency): Order public function confirmProviderPayment(Order $order, string $provider, string $reference, int $amountCents, string $currency): Order
{ {
$expected = (int) ($order->total_cents ?? $order->lines()->sum('price_cents')); $expected = (int) ($order->total_cents ?? $order->lines()->sum('price_cents') - $order->lines()->sum('discount_cents'));
if ($amountCents !== $expected || strtoupper($currency) !== strtoupper((string) ($order->currency ?? 'EUR'))) { if ($amountCents !== $expected || strtoupper($currency) !== strtoupper((string) ($order->currency ?? 'EUR'))) {
throw new DomainRuleException('Der gezahlte Betrag weicht von der Bestellung ab.'); throw new DomainRuleException('Der gezahlte Betrag weicht von der Bestellung ab.');
@@ -159,7 +205,23 @@ public function confirmProviderPayment(Order $order, string $provider, string $r
return $this->settle($order, $provider, $reference); return $this->settle($order, $provider, $reference);
} }
private function settle(Order $order, string $provider, string $reference): Order /**
* Kauf auf Rechnung (PAY-006): Der Betreiber hat die Rechnung manuell erstellt und bestätigt den Zahlungseingang.
* Nur für Bestellungen mit Zahlungsweg „Rechnung“; das Mitglied kann das nicht selbst auslösen. Die Referenz
* (Rechnungsnummer oder Buchung) wird an der Zahlung festgehalten.
*/
public function confirmInvoicePayment(Order $order, string $reference, User $actor): Order
{
$order->refresh();
if ($order->payment_method !== 'rechnung') {
throw new DomainRuleException('Nur eine Bestellung auf Rechnung wird manuell als bezahlt bestätigt.');
}
return $this->settle($order, 'ueberweisung', 'rechnung-'.trim($reference), $actor);
}
private function settle(Order $order, string $provider, string $reference, ?User $confirmedBy = null): Order
{ {
$reference = trim($reference); $reference = trim($reference);
@@ -168,7 +230,7 @@ private function settle(Order $order, string $provider, string $reference): Orde
} }
$paidNow = false; $paidNow = false;
$order = DB::transaction(function () use ($order, $provider, $reference, &$paidNow): Order { $order = DB::transaction(function () use ($order, $provider, $reference, $confirmedBy, &$paidNow): Order {
$order = Order::query()->lockForUpdate()->findOrFail($order->id); $order = Order::query()->lockForUpdate()->findOrFail($order->id);
if ($order->status === 'bezahlt') { if ($order->status === 'bezahlt') {
@@ -182,7 +244,7 @@ private function settle(Order $order, string $provider, string $reference): Orde
// Eine bei Stripe angelegte offene Zahlung mit derselben Referenz wird bestätigt statt doppelt geführt. // Eine bei Stripe angelegte offene Zahlung mit derselben Referenz wird bestätigt statt doppelt geführt.
$order->payments()->updateOrCreate( $order->payments()->updateOrCreate(
['provider_reference' => $reference], ['provider_reference' => $reference],
['provider' => $provider, 'status' => 'bestaetigt'], ['provider' => $provider, 'status' => 'bestaetigt', 'amount_cents' => $order->payable(), 'confirmed_by' => $confirmedBy?->id],
); );
$order->status = 'bezahlt'; $order->status = 'bezahlt';
$order->save(); $order->save();
@@ -207,6 +269,7 @@ private function settle(Order $order, string $provider, string $reference): Orde
public function failTestPayment(Order $order, string $reference): Order public function failTestPayment(Order $order, string $reference): Order
{ {
$this->assertTestDriver(); $this->assertTestDriver();
$this->assertTestOrder($order);
return DB::transaction(function () use ($order, $reference): Order { return DB::transaction(function () use ($order, $reference): Order {
$order = Order::query()->lockForUpdate()->findOrFail($order->id); $order = Order::query()->lockForUpdate()->findOrFail($order->id);
@@ -229,9 +292,11 @@ public function failTestPayment(Order $order, string $reference): Order
/** /**
* Vollerstattung: widerruft die Berechtigungen aller Positionen dieser Bestellung. Andere Erwerbsquellen * Vollerstattung: widerruft die Berechtigungen aller Positionen dieser Bestellung. Andere Erwerbsquellen
* (kostenlose Vergabe, frühere Käufe) bleiben unberührt. * (kostenlose Vergabe, frühere Käufe) bleiben unberührt. Bundles sind Rückgabeeinheiten; freiwillige
* Teilerstattungen gibt es zum Start nicht. Bei einer Zahlung über Stripe wird die Rückzahlung zuerst bei Stripe
* veranlasst; erst wenn Stripe sie annimmt, werden Rechte entzogen. Wirkt sie dort nicht, bleibt alles unverändert.
*/ */
public function refund(Order $order, string $reason): Order public function refund(Order $order, string $reason, ?StripeGateway $stripe = null): Order
{ {
$reason = trim($reason); $reason = trim($reason);
@@ -239,6 +304,13 @@ public function refund(Order $order, string $reason): Order
throw new DomainRuleException('Eine Erstattung braucht eine Begründung.'); throw new DomainRuleException('Eine Erstattung braucht eine Begründung.');
} }
$current = Order::query()->findOrFail($order->id);
$stripePayment = $current->payments()->where('provider', 'stripe')->where('status', 'bestaetigt')->latest('id')->first();
if ($current->status === 'bezahlt' && $stripePayment !== null) {
($stripe ?? app(StripeGateway::class))->refund($current, $stripePayment, $reason);
}
return DB::transaction(function () use ($order, $reason): Order { return DB::transaction(function () use ($order, $reason): Order {
$order = Order::query()->lockForUpdate()->findOrFail($order->id); $order = Order::query()->lockForUpdate()->findOrFail($order->id);
@@ -270,6 +342,28 @@ public function refund(Order $order, string $reason): Order
}); });
} }
/**
* Das Mitglied erklärt den Widerruf (Verkaufsstart: kein Selbstbedienungs-Widerruf). Es entzieht nichts und
* erstattet nichts; der Betreiber prüft den Fall (Erlöschen des Widerrufsrechts bei sofortiger Bereitstellung mit
* ausdrücklicher Zustimmung) und erstattet bei Bedarf in der Bestellverwaltung.
*/
public function requestWithdrawal(Order $order, string $note): Order
{
if (! in_array($order->status, ['bezahlt', 'offen'], true)) {
throw new DomainRuleException('Für diese Bestellung kann kein Widerruf erklärt werden.');
}
if ($order->withdrawal_requested_at !== null) {
return $order;
}
$order->withdrawal_requested_at = now();
$order->withdrawal_note = trim($note) !== '' ? trim($note) : null;
$order->save();
return $order;
}
private function assertActive(User $user): void private function assertActive(User $user): void
{ {
if ($user->status !== AccountStatus::Aktiv || $user->party_id === null) { if ($user->status !== AccountStatus::Aktiv || $user->party_id === null) {
@@ -277,6 +371,14 @@ private function assertActive(User $user): void
} }
} }
/** Eine Bestellung auf Rechnung oder über Stripe wird nie mit der Testzahlung bestätigt. */
private function assertTestOrder(Order $order): void
{
if (in_array(Order::query()->whereKey($order->id)->value('payment_method'), ['rechnung', 'stripe'], true)) {
throw new DomainRuleException('Diese Bestellung wird nicht mit der Testzahlung bezahlt.');
}
}
private function assertTestDriver(): void private function assertTestDriver(): void
{ {
if (app()->isProduction() || config('services.payment.driver') !== 'test') { if (app()->isProduction() || config('services.payment.driver') !== 'test') {
@@ -0,0 +1,74 @@
<?php
namespace App\Domain\Commerce\Discount;
/**
* Reine Rechenregel für den Rabatt je Position (ganze Cent, keine Datenbank, keine Uhr).
*
* Prozent: je Position gerundet (kaufmännisch, ab 0,5 Cent nach oben), höchstens der Positionspreis. Die Summe ist
* die Summe der gerundeten Positionsrabatte. Das kann um bis zu einen Cent je Position von der Rundung auf der
* Warenkorbsumme abweichen (Rechenbeispiel in der Abnahme zum Verkaufsstart, Fachfrage).
*
* Betrag: Der Festbetrag gilt je Bestellung, höchstens bis zur Summe der betroffenen Positionen. Er wird anteilig
* zum Positionspreis verteilt; verbleibende Cent erhalten die Positionen mit dem größten Rest, bei Gleichstand die
* frühere Position.
*/
final class DiscountCalculator
{
/**
* @param array<int|string, int> $prices Schlüssel der Position => Preis in Cent (nur betroffene Positionen)
* @return array<int|string, int> Schlüssel => Rabatt in Cent
*/
public static function allocate(string $kind, ?int $percent, ?int $amountCents, array $prices): array
{
$discounts = array_fill_keys(array_keys($prices), 0);
if ($prices === []) {
return $discounts;
}
if ($kind === DiscountCode::PERCENT) {
$percent = max(0, min(100, (int) $percent));
foreach ($prices as $key => $price) {
$discounts[$key] = min($price, intdiv($price * $percent + 50, 100));
}
return $discounts;
}
$sum = array_sum($prices);
$total = min(max(0, (int) $amountCents), $sum);
if ($total === 0 || $sum === 0) {
return $discounts;
}
$remainders = [];
$given = 0;
foreach ($prices as $key => $price) {
$share = intdiv($total * $price, $sum);
$discounts[$key] = $share;
$remainders[$key] = ($total * $price) % $sum;
$given += $share;
}
$rest = $total - $given;
$order = array_keys($prices);
usort($order, fn ($left, $right): int => $remainders[$right] <=> $remainders[$left]);
foreach ($order as $key) {
if ($rest === 0) {
break;
}
if ($discounts[$key] < $prices[$key]) {
$discounts[$key]++;
$rest--;
}
}
return $discounts;
}
}
@@ -0,0 +1,103 @@
<?php
namespace App\Domain\Commerce\Discount;
use App\Domain\Commerce\Money;
use Carbon\CarbonInterface;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\HasMany;
/**
* Rabattcode (PAY-008, FACH-14). Zwei voneinander unabhängige Einstellungen:
* - Geltungsbereich: gesamter Warenkorb oder nur ausdrücklich gewählte Ziele (Angebot, Lizenzartikel, Paket);
* - Einlösungsberechtigung: allgemein oder nur für ausdrücklich freigeschaltete Konten (Freigabe gilt nur für diesen Code).
* Der Rabatt ändert den Preis, nie den Nutzungsumfang.
*/
class DiscountCode extends Model
{
public const PERCENT = 'prozent';
public const AMOUNT = 'betrag';
public const SCOPE_CART = 'warenkorb';
public const SCOPE_SELECTED = 'auswahl';
public const OPEN = 'allgemein';
public const RESTRICTED = 'freigabe';
public const TARGET_OFFER = 'angebot';
public const TARGET_ARTICLE = 'lizenzartikel';
public const TARGET_BUNDLE = 'paket';
protected $fillable = [
'code',
'label',
'kind',
'percent',
'amount_cents',
'scope',
'eligibility',
'valid_from',
'valid_until',
'active',
'note',
];
protected function casts(): array
{
return [
'valid_from' => 'datetime',
'valid_until' => 'datetime',
'active' => 'boolean',
];
}
/** Eingabe und Speicherung vereinheitlicht: ohne Leerzeichen, Großschreibung. */
public static function normalise(string $input): string
{
return mb_strtoupper((string) preg_replace('/\s+/u', '', $input));
}
public function targets(): HasMany
{
return $this->hasMany(DiscountCodeTarget::class);
}
public function releases(): HasMany
{
return $this->hasMany(DiscountRelease::class)->latest('id');
}
public function restricted(): bool
{
return $this->eligibility === self::RESTRICTED;
}
public function forSelection(): bool
{
return $this->scope === self::SCOPE_SELECTED;
}
/** Lesbare Höhe: „10 %“ oder „5,00 €“. */
public function valueLabel(): string
{
return $this->kind === self::PERCENT
? (int) $this->percent.' %'
: Money::format((int) $this->amount_cents);
}
/** Zeitlicher Zustand zum Zeitpunkt: 'aktiv', 'abgelaufen', 'noch_nicht' oder 'deaktiviert'. */
public function stateAt(CarbonInterface $now): string
{
return match (true) {
! $this->active => 'deaktiviert',
$this->valid_from !== null && $this->valid_from->greaterThan($now) => 'noch_nicht',
$this->valid_until !== null && ! $this->valid_until->greaterThan($now) => 'abgelaufen',
default => 'aktiv',
};
}
}
@@ -0,0 +1,24 @@
<?php
namespace App\Domain\Commerce\Discount;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
/**
* Ausdrücklich gewähltes Ziel eines Codes mit Geltungsbereich „Auswahl“. Ein Paket ist ein eigenes Ziel; seine
* Rabattfähigkeit folgt nie aus einem enthaltenen Lizenzartikel und umgekehrt.
*/
class DiscountCodeTarget extends Model
{
protected $fillable = [
'discount_code_id',
'target_type',
'target_id',
];
public function code(): BelongsTo
{
return $this->belongsTo(DiscountCode::class, 'discount_code_id');
}
}
@@ -0,0 +1,59 @@
<?php
namespace App\Domain\Commerce\Discount;
use App\Models\User;
use Carbon\CarbonInterface;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
/**
* Freigabe eines Mitgliedskontos für genau einen Code. Freigaben werden nie gelöscht, nur entzogen; Verlauf und
* Begründung bleiben erhalten. Eine Freigabe für Code X berechtigt nicht zur Nutzung von Code Y.
*/
class DiscountRelease extends Model
{
protected $table = 'discount_code_releases';
protected $fillable = [
'discount_code_id',
'user_id',
'granted_by',
'granted_at',
'valid_until',
'revoked_by',
'revoked_at',
'reason',
];
protected function casts(): array
{
return [
'granted_at' => 'datetime',
'valid_until' => 'datetime',
'revoked_at' => 'datetime',
];
}
public function code(): BelongsTo
{
return $this->belongsTo(DiscountCode::class, 'discount_code_id');
}
public function user(): BelongsTo
{
return $this->belongsTo(User::class);
}
public function grantor(): BelongsTo
{
return $this->belongsTo(User::class, 'granted_by');
}
public function isActiveAt(CarbonInterface $now): bool
{
return $this->revoked_at === null
&& $this->granted_at->lessThanOrEqualTo($now)
&& ($this->valid_until === null || $this->valid_until->greaterThan($now));
}
}
@@ -0,0 +1,83 @@
<?php
namespace App\Domain\Commerce\Discount;
/**
* Ergebnis der Prüfung eines Codes gegen einen Warenkorb: angewandt (Rabatt je Option) oder nicht angewandt mit
* einer verständlichen Begründung. Ein Code, der gerade nicht gilt, bleibt als Ergebnis sichtbar, damit der Käufer
* den Grund erfährt.
*/
final class DiscountResult
{
public const OK = 'ok';
public const UNKNOWN = 'unbekannt';
public const INACTIVE = 'deaktiviert';
public const NOT_YET = 'noch_nicht';
public const EXPIRED = 'abgelaufen';
public const LOGIN = 'anmeldung';
public const NO_RELEASE = 'keine_freigabe';
public const NO_MATCH = 'keine_position';
public const TOO_HIGH = 'zu_hoch';
/**
* @param array<int, int> $perOffer Kennung der Option => Rabatt in Cent
*/
public function __construct(
public readonly ?DiscountCode $code,
public readonly string $state,
public readonly ?string $message = null,
public readonly array $perOffer = [],
) {}
public function applied(): bool
{
return $this->state === self::OK && $this->totalCents() > 0;
}
public function totalCents(): int
{
return $this->state === self::OK ? array_sum($this->perOffer) : 0;
}
public function forOffer(int $offerId): int
{
return $this->state === self::OK ? (int) ($this->perOffer[$offerId] ?? 0) : 0;
}
/** Für die Bestellung festgehaltene Angaben zum Zeitpunkt der Bestellung. */
public function snapshot(): array
{
return [
'code' => $this->code?->code,
'label' => $this->code?->label,
'kind' => $this->code?->kind,
'percent' => $this->code?->percent,
'amount_cents' => $this->code?->amount_cents,
'scope' => $this->code?->scope,
'eligibility' => $this->code?->eligibility,
'discount_cents' => $this->totalCents(),
];
}
/** Teil der Prüfsumme der Bestellübersicht. */
public function digestPart(): string
{
$parts = [];
$perOffer = $this->perOffer;
ksort($perOffer);
foreach ($perOffer as $offerId => $cents) {
$parts[] = $offerId.'='.$cents;
}
return ($this->code?->id ?? 0).':'.$this->state.':'.implode(',', $parts);
}
}
@@ -0,0 +1,327 @@
<?php
namespace App\Domain\Commerce\Discount;
use App\Domain\Catalog\Bundle;
use App\Domain\Catalog\DomainRuleException;
use App\Domain\Catalog\LicenseArticle;
use App\Domain\Catalog\Offer;
use App\Domain\Catalog\OfferVersion;
use App\Domain\Commerce\CartLine;
use App\Domain\Commerce\Money;
use App\Models\User;
use Carbon\CarbonInterface;
use Illuminate\Support\Carbon;
use Illuminate\Support\Facades\DB;
/**
* Prüfung und Pflege von Rabattcodes. Die Prüfung läuft serverseitig bei der Eingabe, in jeder Übersicht und
* unmittelbar vor Bestellabschluss (unter Sperre); sie liest nur und ändert keine Bestellung.
*/
class DiscountService
{
/** Kleinster Zahlbetrag einer Bestellung mit Rabatt (Mindestbetrag der Kartenzahlung bei Stripe: 0,50 EUR). */
public const MIN_PAYABLE_CENTS = 50;
public function find(string $input): ?DiscountCode
{
$code = DiscountCode::normalise($input);
return $code === '' ? null : DiscountCode::query()->where('code', $code)->first();
}
/**
* @param list<CartLine> $lines nur Positionen, die in die Bestellung eingehen
*/
public function evaluate(DiscountCode $code, ?User $user, array $lines, ?CarbonInterface $now = null, bool $lock = false): DiscountResult
{
$now ??= now();
$timing = $code->stateAt($now);
if ($timing !== 'aktiv') {
return new DiscountResult($code, $timing, match ($timing) {
'deaktiviert' => 'Dieser Code ist nicht mehr gültig, der Betreiber hat ihn deaktiviert.',
'noch_nicht' => 'Dieser Code gilt erst ab dem '.$code->valid_from?->timezone(config('app.timezone'))->format('d.m.Y').'.',
default => 'Dieser Code ist abgelaufen (gültig bis '.$code->valid_until?->timezone(config('app.timezone'))->format('d.m.Y').').',
});
}
if ($code->restricted()) {
if ($user === null) {
return new DiscountResult($code, DiscountResult::LOGIN, 'Dieser Code gilt nur für freigeschaltete Konten. Melde dich an, damit wir prüfen können, ob er für dein Konto gilt.');
}
if ($this->activeRelease($code, $user, $now, $lock) === null) {
return new DiscountResult($code, DiscountResult::NO_RELEASE, 'Dieser Code ist für dein Konto nicht freigeschaltet. Er gilt nur für Konten, die der Betreiber ausdrücklich dafür freigegeben hat. Wenn du denkst, dass dir die Freigabe zusteht, wende dich an den Betreiber.');
}
}
$matching = [];
foreach ($lines as $line) {
if ($line->version !== null && $this->matches($code, $line->offer, $line->version)) {
$matching[$line->offer->id] = (int) $line->currentPriceCents;
}
}
if ($matching === []) {
return new DiscountResult($code, DiscountResult::NO_MATCH, $code->forSelection()
? 'Dieser Code gilt nur für bestimmte Angebote, und keines davon liegt in deiner Bestellung.'
: 'In deiner Bestellung gibt es keine Position, auf die der Code angewendet werden kann.');
}
$perOffer = DiscountCalculator::allocate($code->kind, $code->percent, $code->amount_cents, $matching);
$payable = array_sum(array_map(fn (CartLine $line): int => (int) $line->currentPriceCents, $lines)) - array_sum($perOffer);
if ($payable < self::MIN_PAYABLE_CENTS) {
return new DiscountResult($code, DiscountResult::TOO_HIGH, 'Mit diesem Code läge der Zahlbetrag unter '.Money::format(self::MIN_PAYABLE_CENTS).'. Das ist beim Start nicht vorgesehen. Wähle zusätzlich eine weitere Position oder verzichte auf den Code.');
}
return new DiscountResult($code, DiscountResult::OK, null, $perOffer);
}
/**
* Passt die Position? Verglichen werden nur die ausdrücklich gewählten Ziele mit den unmittelbaren Positionen der
* Angebotsfassung. Ein Paket gilt nur, wenn es selbst gewählt ist; ein enthaltener Artikel macht es nicht
* rabattfähig, und ein Artikel in einem Paket macht das Angebot nicht rabattfähig.
*/
public function matches(DiscountCode $code, Offer $offer, OfferVersion $version): bool
{
if (! $code->forSelection()) {
return true;
}
$targets = $code->targets->groupBy('target_type')->map(fn ($rows) => $rows->pluck('target_id')->map(fn ($id): int => (int) $id)->all());
if (in_array($offer->id, $targets->get(DiscountCode::TARGET_OFFER, []), true)) {
return true;
}
$version->loadMissing('lines.bundleVersion');
foreach ($version->lines as $line) {
if ($line->license_article_id !== null && in_array((int) $line->license_article_id, $targets->get(DiscountCode::TARGET_ARTICLE, []), true)) {
return true;
}
if ($line->bundleVersion !== null && in_array((int) $line->bundleVersion->bundle_id, $targets->get(DiscountCode::TARGET_BUNDLE, []), true)) {
return true;
}
}
return false;
}
public function activeRelease(DiscountCode $code, User $user, ?CarbonInterface $now = null, bool $lock = false): ?DiscountRelease
{
$now ??= now();
$query = DiscountRelease::query()->where('discount_code_id', $code->id)->where('user_id', $user->id)->whereNull('revoked_at');
if ($lock) {
$query->lockForUpdate();
}
return $query->get()->first(fn (DiscountRelease $release): bool => $release->isActiveAt($now));
}
/**
* Legt einen Code an oder ändert ihn. Gleiche Prüfung für Anlegen und Bearbeiten.
*
* @param array<string, mixed> $data
* @param list<array{type: string, id: int}> $targets
*/
public function save(array $data, array $targets, ?DiscountCode $existing = null): DiscountCode
{
$code = DiscountCode::normalise((string) ($data['code'] ?? ''));
$label = trim((string) ($data['label'] ?? ''));
if (preg_match('/^[A-Z0-9][A-Z0-9_-]{2,39}$/', $code) !== 1) {
throw new DomainRuleException('Der Code besteht aus 3 bis 40 Zeichen: Buchstaben, Ziffern, Bindestrich oder Unterstrich, ohne Leerzeichen.');
}
if ($label === '') {
throw new DomainRuleException('Der Name des Codes fehlt. Er ist nur für die Verwaltung und erscheint nicht im Shop.');
}
if (DiscountCode::query()->where('code', $code)->when($existing !== null, fn ($query) => $query->whereKeyNot($existing->id))->exists()) {
throw new DomainRuleException('Diesen Code gibt es schon.');
}
$kind = (string) ($data['kind'] ?? '');
$percent = null;
$amount = null;
if ($kind === DiscountCode::PERCENT) {
$percent = (int) ($data['percent'] ?? 0);
if ($percent < 1 || $percent > 100) {
throw new DomainRuleException('Der Prozentsatz liegt zwischen 1 und 100.');
}
} elseif ($kind === DiscountCode::AMOUNT) {
$amount = Money::parse($data['amount_euro'] ?? ($data['amount_cents'] ?? null));
if ($amount === null || $amount <= 0) {
throw new DomainRuleException('Der Rabattbetrag ist ein Eurobetrag über 0,00 €.');
}
} else {
throw new DomainRuleException('Die Art des Rabatts ist Prozent oder fester Betrag.');
}
$scope = (string) ($data['scope'] ?? '');
$eligibility = (string) ($data['eligibility'] ?? '');
if (! in_array($scope, [DiscountCode::SCOPE_CART, DiscountCode::SCOPE_SELECTED], true)) {
throw new DomainRuleException('Der Geltungsbereich ist der gesamte Warenkorb oder eine Auswahl.');
}
if (! in_array($eligibility, [DiscountCode::OPEN, DiscountCode::RESTRICTED], true)) {
throw new DomainRuleException('Die Einlösung ist allgemein oder auf freigeschaltete Konten beschränkt.');
}
$targets = $this->cleanTargets($targets);
if ($scope === DiscountCode::SCOPE_SELECTED && $targets === []) {
throw new DomainRuleException('Wähle mindestens ein Angebot, einen Lizenzartikel oder ein Paket, für das der Code gilt, oder lass ihn für den gesamten Warenkorb gelten.');
}
$from = $this->date($data['valid_from'] ?? null);
$until = $this->date($data['valid_until'] ?? null, true);
if ($from !== null && $until !== null && $until->lessThanOrEqualTo($from)) {
throw new DomainRuleException('Das Ende der Gültigkeit liegt vor dem Beginn.');
}
return DB::transaction(function () use ($existing, $code, $label, $kind, $percent, $amount, $scope, $eligibility, $from, $until, $data, $targets): DiscountCode {
$model = $existing ?? new DiscountCode;
$model->fill([
'code' => $code,
'label' => $label,
'kind' => $kind,
'percent' => $percent,
'amount_cents' => $amount,
'scope' => $scope,
'eligibility' => $eligibility,
'valid_from' => $from,
'valid_until' => $until,
'active' => (bool) ($data['active'] ?? true),
'note' => filled($data['note'] ?? null) ? trim((string) $data['note']) : null,
]);
$model->save();
$model->targets()->delete();
if ($scope === DiscountCode::SCOPE_SELECTED) {
foreach ($targets as $target) {
$model->targets()->create(['target_type' => $target['type'], 'target_id' => $target['id']]);
}
}
return $model->load('targets');
});
}
public function setActive(DiscountCode $code, bool $active): DiscountCode
{
$code->active = $active;
$code->save();
return $code;
}
/**
* Schaltet ein Konto für genau diesen Code frei. Eine zweite aktive Freigabe desselben Kontos gibt es nicht.
*/
public function release(DiscountCode $code, User $member, ?User $actor, ?CarbonInterface $until = null, ?string $reason = null): DiscountRelease
{
if (! $code->restricted()) {
throw new DomainRuleException('Dieser Code ist allgemein einlösbar. Freigaben gibt es nur für Codes mit beschränkter Einlösung.');
}
if ($member->party_id === null) {
throw new DomainRuleException('Nur ein Mitgliedskonto kann für einen Code freigeschaltet werden.');
}
return DB::transaction(function () use ($code, $member, $actor, $until, $reason): DiscountRelease {
DiscountCode::query()->whereKey($code->id)->lockForUpdate()->firstOrFail();
if ($this->activeRelease($code, $member) !== null) {
throw new DomainRuleException('Dieses Konto ist für den Code bereits freigeschaltet.');
}
if ($until !== null && $until->lessThanOrEqualTo(now())) {
throw new DomainRuleException('Das Ende der Freigabe liegt in der Vergangenheit.');
}
return DiscountRelease::query()->create([
'discount_code_id' => $code->id,
'user_id' => $member->id,
'granted_by' => $actor?->id,
'granted_at' => now(),
'valid_until' => $until,
'reason' => filled($reason) ? trim((string) $reason) : null,
]);
});
}
/**
* Entzieht die Freigabe. Sie bleibt mit Zeitpunkt, Person und Begründung gespeichert.
*/
public function revoke(DiscountRelease $release, ?User $actor, ?string $reason = null): DiscountRelease
{
return DB::transaction(function () use ($release, $actor, $reason): DiscountRelease {
$release = DiscountRelease::query()->lockForUpdate()->findOrFail($release->id);
if ($release->revoked_at !== null) {
throw new DomainRuleException('Diese Freigabe ist bereits entzogen.');
}
$release->revoked_at = now();
$release->revoked_by = $actor?->id;
$release->reason = filled($reason) ? trim((string) $reason) : $release->reason;
$release->save();
return $release;
});
}
/**
* @param list<array{type: string, id: int}> $targets
* @return list<array{type: string, id: int}>
*/
private function cleanTargets(array $targets): array
{
$clean = [];
foreach ($targets as $target) {
$type = (string) ($target['type'] ?? '');
$id = (int) ($target['id'] ?? 0);
$exists = match ($type) {
DiscountCode::TARGET_OFFER => Offer::query()->whereKey($id)->exists(),
DiscountCode::TARGET_ARTICLE => LicenseArticle::query()->whereKey($id)->exists(),
DiscountCode::TARGET_BUNDLE => Bundle::query()->whereKey($id)->exists(),
default => false,
};
if (! $exists) {
throw new DomainRuleException('Ein gewähltes Ziel des Codes gibt es nicht (mehr).');
}
$clean[$type.':'.$id] = ['type' => $type, 'id' => $id];
}
return array_values($clean);
}
/** Ein Datum ohne Uhrzeit gilt als Tag: ab Tagesbeginn, als Ende einschließlich des ganzen Tages. */
private function date(mixed $value, bool $endOfDay = false): ?CarbonInterface
{
if (! filled($value)) {
return null;
}
$date = Carbon::parse((string) $value, config('app.timezone'));
return $endOfDay && strlen(trim((string) $value)) <= 10 ? $date->endOfDay() : $date;
}
}
+31
View File
@@ -17,8 +17,39 @@ class Order extends Model
'holder_kind', 'holder_kind',
'total_cents', 'total_cents',
'currency', 'currency',
'subtotal_cents',
'discount_cents',
'discount_code_id',
'discount_snapshot',
'payment_method',
'terms_accepted_at',
'terms_snapshot',
'withdrawal_requested_at',
'withdrawal_note',
]; ];
protected function casts(): array
{
return [
'discount_snapshot' => 'array',
'terms_snapshot' => 'array',
'terms_accepted_at' => 'datetime',
'withdrawal_requested_at' => 'datetime',
];
}
/** Listenpreise vor Rabatt; bei älteren Bestellungen die Summe der Positionen. */
public function subtotal(): int
{
return (int) ($this->subtotal_cents ?? $this->total_cents ?? $this->lines->sum('price_cents'));
}
/** Endgültiger Zahlbetrag. */
public function payable(): int
{
return (int) ($this->total_cents ?? $this->lines->sum('price_cents'));
}
public function user(): BelongsTo public function user(): BelongsTo
{ {
return $this->belongsTo(User::class); return $this->belongsTo(User::class);
+9
View File
@@ -22,8 +22,17 @@ class OrderLine extends Model
'tax_class', 'tax_class',
'grant_kind', 'grant_kind',
'holder_party_id', 'holder_party_id',
'licence_scope',
'trainer_count',
'discount_cents',
]; ];
/** Preis dieser Position nach Rabatt. */
public function payable(): int
{
return (int) $this->price_cents - (int) $this->discount_cents;
}
public function order(): BelongsTo public function order(): BelongsTo
{ {
return $this->belongsTo(Order::class); return $this->belongsTo(Order::class);
+12
View File
@@ -2,6 +2,7 @@
namespace App\Domain\Commerce; namespace App\Domain\Commerce;
use App\Domain\Catalog\LicenceScope;
use App\Domain\Catalog\OfferVersion; use App\Domain\Catalog\OfferVersion;
use App\Domain\Entitlement\Grant; use App\Domain\Entitlement\Grant;
use App\Domain\Entitlement\GrantStatus; use App\Domain\Entitlement\GrantStatus;
@@ -27,12 +28,23 @@ public function covers(Party $holder, OfferVersion $version): bool
$byAcquisition = Grant::query() $byAcquisition = Grant::query()
->where('status', GrantStatus::Aktiv) ->where('status', GrantStatus::Aktiv)
->whereHas('acquisition', fn ($query) => $query->where('party_id', $holder->id)) ->whereHas('acquisition', fn ($query) => $query->where('party_id', $holder->id))
->with('acquisition')
->get() ->get()
->filter(fn (Grant $grant): bool => ($grant->valid_from === null || ! $grant->valid_from->greaterThan($now)) ->filter(fn (Grant $grant): bool => ($grant->valid_from === null || ! $grant->valid_from->greaterThan($now))
&& ($grant->valid_until === null || $grant->valid_until->greaterThan($now))) && ($grant->valid_until === null || $grant->valid_until->greaterThan($now)))
->groupBy('acquisition_id'); ->groupBy('acquisition_id');
$wanted = LicenceScope::key($version->licence_scope, $version->trainer_count);
foreach ($byAcquisition as $grants) { foreach ($byAcquisition as $grants) {
$conditions = (array) ($grants->first()->acquisition?->conditions ?? []);
// Gleicher Umfang heißt auch gleicher Nutzerkreis: Eine Einzellizenz deckt keine Mehrfachlizenz ab und
// umgekehrt (der Nutzerkreis wird nicht aus Zweck oder Preis abgeleitet).
if (LicenceScope::key($conditions['licence_scope'] ?? null, isset($conditions['trainer_count']) ? (int) $conditions['trainer_count'] : null) !== $wanted) {
continue;
}
$have = []; $have = [];
foreach ($grants as $grant) { foreach ($grants as $grant) {
+3
View File
@@ -12,6 +12,9 @@ class Payment extends Model
'provider', 'provider',
'status', 'status',
'provider_reference', 'provider_reference',
'provider_payment_ref',
'amount_cents',
'confirmed_by',
]; ];
public function order(): BelongsTo public function order(): BelongsTo
+125
View File
@@ -2,8 +2,10 @@
namespace App\Domain\Commerce; namespace App\Domain\Commerce;
use App\Domain\Catalog\Bundle;
use App\Domain\Catalog\Composition; use App\Domain\Catalog\Composition;
use App\Domain\Catalog\EditorialProfileReader; use App\Domain\Catalog\EditorialProfileReader;
use App\Domain\Catalog\LicenceScope;
use App\Domain\Catalog\LicenseArticle; use App\Domain\Catalog\LicenseArticle;
use App\Domain\Catalog\Offer; use App\Domain\Catalog\Offer;
use App\Domain\Catalog\OfferService; use App\Domain\Catalog\OfferService;
@@ -37,6 +39,125 @@ public function forComposition(Composition $composition): array
return $options; return $options;
} }
/**
* Kaufbare Optionen der eigenen Produktseite eines Pakets: Angebote mit eigener Paketseite, deren aktive Fassung
* dieses Paket verkauft.
*
* @return list<array<string, mixed>>
*/
public function forBundle(Bundle $bundle): array
{
$options = [];
foreach (Offer::query()->where('standalone_bundle', true)->orderBy('id')->get() as $offer) {
$version = $this->offers->purchasableVersion($offer);
if ($version !== null && $this->bundleOf($version)?->id === $bundle->id) {
$options[] = $this->describe($offer, $version);
}
}
return $options;
}
/**
* Das Paket, das die Fassung unmittelbar verkauft (erste Paketposition), sonst null.
*/
public function bundleOf(OfferVersion $version): ?Bundle
{
$version->loadMissing('lines.bundleVersion.bundle');
return $version->lines->first(fn ($line): bool => $line->bundleVersion !== null)?->bundleVersion?->bundle;
}
/** Gruppenschlüssel der Alternativen: Produktseite eines Programms oder eigene Paketseite. */
public function groupKey(Offer $offer): ?string
{
if ($offer->composition_id !== null) {
return 'c:'.$offer->composition_id;
}
if ($offer->standalone_bundle) {
$version = $this->offers->purchasableVersion($offer) ?? $offer->versions()->orderByDesc('number')->first();
$bundle = $version === null ? null : $this->bundleOf($version);
return $bundle === null ? null : 'b:'.$bundle->id;
}
return null;
}
/** Adresse der Produktseite, auf der die Option angeboten wird, sonst null. */
public function pageUrl(Offer $offer): ?string
{
if ($offer->composition_id !== null) {
return route('public.program', $offer->composition_id);
}
$key = $this->groupKey($offer);
return $key !== null && str_starts_with($key, 'b:') ? route('public.package', (int) substr($key, 2)) : null;
}
/**
* Pakete mit eigener Produktseite und kaufbarer Option: Paketkennung => günstigster Preis und Zahl der Optionen.
*
* @return array<int, array{from_cents: int, count: int}>
*/
public function bundleSummaries(): array
{
$summary = [];
foreach (Offer::query()->where('standalone_bundle', true)->orderBy('id')->get() as $offer) {
$version = $this->offers->purchasableVersion($offer);
$bundle = $version === null ? null : $this->bundleOf($version);
if ($bundle === null) {
continue;
}
$current = $summary[$bundle->id] ?? ['from_cents' => PHP_INT_MAX, 'count' => 0];
$summary[$bundle->id] = [
'from_cents' => min($current['from_cents'], (int) $version->price_cents),
'count' => $current['count'] + 1,
];
}
return $summary;
}
/**
* Der tatsächliche Umfang einer Paketseite: die Artikel aller Optionen ohne Doppelte, in der Reihenfolge der
* Optionen, mit Name und Kurzbeschreibung aus der Redaktion.
*
* @param list<array<string, mixed>> $options
* @return list<array{title: string, teaser: string}>
*/
public function bundleContents(array $options): array
{
$contents = [];
foreach ($options as $option) {
$option['version']->loadMissing('resolvedScopes.article');
foreach ($option['version']->resolvedScopes as $item) {
$article = $item->article;
if ($article === null || isset($contents[$article->id])) {
continue;
}
$profile = app(EditorialProfileReader::class)->read($article, 'detail');
$contents[$article->id] = [
'title' => $this->articleTitle($article),
'teaser' => trim((string) ($profile->value('teaser') ?? '')),
];
}
}
return array_values($contents);
}
/** /**
* Zeilen für Shop-Suche und Kacheln: je Komposition die günstigste Option. * Zeilen für Shop-Suche und Kacheln: je Komposition die günstigste Option.
* *
@@ -89,6 +210,10 @@ public function describe(Offer $offer, OfferVersion $version): array
'for' => $version->holder_kind === 'organisation' ? 'Organisationen und Vereine' : 'Privatpersonen', 'for' => $version->holder_kind === 'organisation' ? 'Organisationen und Vereine' : 'Privatpersonen',
'holder_kind' => $version->holder_kind, 'holder_kind' => $version->holder_kind,
'term' => self::termLabel($version), 'term' => self::termLabel($version),
'licence' => LicenceScope::label($version->licence_scope, $version->trainer_count),
'licence_scope' => $version->licence_scope,
'trainer_count' => $version->trainer_count,
'licence_note' => LicenceScope::explanation($version->licence_scope, $version->trainer_count),
'scope' => $scope, 'scope' => $scope,
]; ];
} }
+127
View File
@@ -0,0 +1,127 @@
<?php
namespace App\Domain\Commerce;
use App\Domain\Catalog\DomainRuleException;
use App\Domain\Cms\Page;
/**
* Pflichtangaben und Zustimmungen im Bestellablauf (Verkaufsstart Deutschland, PAY-005, PAY-009).
*
* Die finalen Rechtstexte (AGB, Lizenzbedingungen, Widerrufsbelehrung, Impressum, Datenschutz) liegen als Seiten im
* CMS und werden hier nur verlinkt. Der Wortlaut der Zustimmungen unten ist ein ENTWURF zur Prüfung durch die
* Rechtsberatung. Er ist nicht rechtlich freigegeben; `VERSION` hält fest, welcher Wortlaut galt, damit die Zustimmung
* je Bestellung nachvollziehbar bleibt.
*/
final class SalesTerms
{
public const VERSION = '2026-11-24-entwurf';
/** Schaltfläche zum verbindlichen Abschluss (Button-Lösung, § 312j Abs. 3 BGB). */
public const ORDER_BUTTON = 'Zahlungspflichtig bestellen';
public const ORDER_BUTTON_INVOICE = 'Zahlungspflichtig auf Rechnung bestellen';
/**
* Seiten der Rechtstexte: Schlüssel => Bezeichnung und mögliche Pfade im CMS (erste veröffentlichte Seite gilt).
*
* @return array<string, array{label: string, paths: list<string>, required: bool}>
*/
public static function pages(): array
{
return [
'agb' => ['label' => 'Allgemeine Geschäftsbedingungen', 'paths' => ['/agb'], 'required' => true],
'lizenz' => ['label' => 'Lizenzbedingungen', 'paths' => ['/lizenzbedingungen', '/lizenz'], 'required' => true],
'widerruf' => ['label' => 'Widerrufsbelehrung', 'paths' => ['/widerruf', '/widerrufsbelehrung'], 'required' => true],
'impressum' => ['label' => 'Impressum', 'paths' => ['/impressum'], 'required' => true],
'datenschutz' => ['label' => 'Datenschutzerklärung', 'paths' => ['/datenschutz'], 'required' => true],
];
}
/**
* Veröffentlichte Seite des Rechtstextes oder null.
*/
public static function page(string $key): ?Page
{
$definition = self::pages()[$key] ?? null;
if ($definition === null) {
return null;
}
return Page::query()
->whereIn('path', $definition['paths'])
->whereNotNull('published_revision_id')
->orderBy('id')
->first();
}
public static function url(string $key): ?string
{
return self::page($key)?->publicUrl();
}
/**
* Fehlende oder unveröffentlichte Rechtstexte (Schlüssel => Bezeichnung).
*
* @return array<string, string>
*/
public static function missingPages(): array
{
$missing = [];
foreach (self::pages() as $key => $definition) {
if ($definition['required'] && self::page($key) === null) {
$missing[$key] = $definition['label'];
}
}
return $missing;
}
/**
* Zustimmungen im Checkout: Schlüssel => Wortlaut (ENTWURF).
*
* @return array<string, string>
*/
public static function consents(): array
{
return [
'agb' => 'Ich habe die Allgemeinen Geschäftsbedingungen und die Lizenzbedingungen gelesen und stimme ihnen zu.',
'sofort' => 'Ich verlange ausdrücklich, dass mit der Ausführung des Vertrags vor Ablauf der Widerrufsfrist begonnen wird und die digitalen Inhalte sofort nach Zahlungseingang bereitgestellt werden. Mir ist bekannt, dass ich mein Widerrufsrecht verliere, sobald die Ausführung begonnen hat.',
];
}
/**
* Prüft die Zustimmungen und liefert den Nachweis für die Bestellung (Wortlaut, Fassung, Seiten, Zeit).
*
* @param array<string, mixed> $accepted Schlüssel => angekreuzt
* @return array<string, mixed>
*/
public static function proof(array $accepted): array
{
$texts = [];
foreach (self::consents() as $key => $wording) {
if (empty($accepted[$key])) {
throw new DomainRuleException('Bitte bestätige die Zustimmungen vor dem verbindlichen Abschluss.');
}
$texts[$key] = $wording;
}
$pages = [];
foreach (array_keys(self::pages()) as $key) {
$page = self::page($key);
$pages[$key] = $page === null ? null : ['path' => $page->path, 'revision_id' => $page->published_revision_id];
}
return [
'version' => self::VERSION,
'consents' => $texts,
'pages' => $pages,
'recorded_at' => now()->toIso8601String(),
];
}
}
+41 -7
View File
@@ -3,9 +3,12 @@
namespace App\Domain\Commerce; namespace App\Domain\Commerce;
/** /**
* Etappe 1 verwendet ausschließlich Testzahlung und erteilt keine Produktivfreigabe. Der Shop (Warenkorb, Kasse, * Wann der Shop (Warenkorb, Kasse, Kopflink) aktiv ist.
* Kopflink) ist deshalb nur aktiv, wenn die Umgebung nicht Produktion ist und der Zahlungstreiber „test“ gilt. *
* Dieselbe Bedingung gilt für die Testzahlung der Bestellseite. * Test und Sandbox: nicht in Produktion, Zahlungstreiber „test“ oder „stripe“ (Testschlüssel).
* Produktion: nur mit der ausdrücklichen Produktivfreigabe (`SHOP_LIVE_RELEASE`, Entscheidung von Lars), dem
* Zahlungstreiber „stripe“ mit Live-Schlüssel und veröffentlichten Rechtstexten. Fehlt eines davon, bleibt der Shop in
* Produktion abgeschaltet. Die Freigabe ist standardmäßig aus.
*/ */
final class Shop final class Shop
{ {
@@ -14,14 +17,45 @@ public static function driver(): string
return (string) config('services.payment.driver'); return (string) config('services.payment.driver');
} }
public static function enabled(): bool /** Produktivbetrieb ist freigegeben und vollständig vorbereitet (Freigabe, Live-Schlüssel, Rechtstexte). */
public static function live(): bool
{ {
return ! app()->isProduction() && in_array(self::driver(), ['test', 'stripe'], true); return app()->isProduction()
&& config('shop.live_release') === true
&& self::driver() === 'stripe'
&& self::liveKey()
&& SalesTerms::missingPages() === [];
} }
/** Stripe-Kasse (Etappe 1: nur Testmodus, nie in Produktion). */ public static function enabled(): bool
{
if (app()->isProduction()) {
return self::live();
}
return in_array(self::driver(), ['test', 'stripe'], true);
}
/** Stripe-Kasse: im Test nur mit Testschlüsseln, in Produktion nur nach der Produktivfreigabe. */
public static function stripe(): bool public static function stripe(): bool
{ {
return ! app()->isProduction() && self::driver() === 'stripe'; if (app()->isProduction()) {
return self::live();
}
return self::driver() === 'stripe';
}
/** Kauf auf Rechnung für Organisationen (manuelle Rechnung, Zahlungseingang durch den Betreiber). */
public static function invoice(): bool
{
return self::enabled() && (bool) config('shop.invoice', true);
}
private static function liveKey(): bool
{
$secret = (string) config('services.stripe.secret');
return str_starts_with($secret, 'sk_live_') || str_starts_with($secret, 'rk_live_');
} }
} }
+66 -13
View File
@@ -3,7 +3,10 @@
namespace App\Domain\Commerce\Stripe; namespace App\Domain\Commerce\Stripe;
use App\Domain\Catalog\DomainRuleException; use App\Domain\Catalog\DomainRuleException;
use App\Domain\Commerce\Money;
use App\Domain\Commerce\Order; use App\Domain\Commerce\Order;
use App\Domain\Commerce\Payment;
use App\Domain\Commerce\Shop;
use Illuminate\Http\Client\ConnectionException; use Illuminate\Http\Client\ConnectionException;
use Illuminate\Http\Client\PendingRequest; use Illuminate\Http\Client\PendingRequest;
use Illuminate\Http\Client\Response; use Illuminate\Http\Client\Response;
@@ -11,9 +14,11 @@
use Illuminate\Support\Facades\Log; use Illuminate\Support\Facades\Log;
/** /**
* Stripe-Kasse (Checkout Session) für die Testzahlung in Etappe 1. Ausschließlich Testschlüssel: Ein Live-Schlüssel * Stripe-Kasse (Checkout Session). Außerhalb der Produktion nur mit Testschlüsseln; ein Live-Schlüssel wird dort
* oder die Produktionsumgebung werden abgewiesen, bevor ein Aufruf an Stripe geht. Bezahlt wird bei Stripe; Kartendaten * abgewiesen. In Produktion nur nach der Produktivfreigabe (Shop::live) und nur mit Live-Schlüssel; in jedem anderen
* berühren diese Anwendung nie. Die Freischaltung erfolgt allein über die signierte Meldung (StripeWebhook). * Fall wird abgewiesen, bevor ein Aufruf an Stripe geht. Bezahlt wird bei Stripe; Kartendaten berühren diese Anwendung
* nie. Die Freischaltung erfolgt allein über die signierte Meldung (StripeWebhook). Der Betrag je Position ist der
* Preis nach Rabatt, damit die Summe bei Stripe genau dem gespeicherten Zahlbetrag der Bestellung entspricht.
*/ */
class StripeGateway class StripeGateway
{ {
@@ -24,7 +29,7 @@ class StripeGateway
*/ */
public function checkoutFor(Order $order): array public function checkoutFor(Order $order): array
{ {
$this->assertSandbox(); $this->assertAllowed();
$order->loadMissing('lines', 'user'); $order->loadMissing('lines', 'user');
$taxRate = $this->taxRate(); $taxRate = $this->taxRate();
@@ -32,6 +37,10 @@ public function checkoutFor(Order $order): array
throw new DomainRuleException('Diese Bestellung nimmt keine Zahlung mehr an.'); throw new DomainRuleException('Diese Bestellung nimmt keine Zahlung mehr an.');
} }
if ($order->payment_method === 'rechnung') {
throw new DomainRuleException('Diese Bestellung wird auf Rechnung bezahlt, nicht bei Stripe.');
}
$open = $this->reusableSession($order); $open = $this->reusableSession($order);
if ($open !== null) { if ($open !== null) {
@@ -51,12 +60,18 @@ public function checkoutFor(Order $order): array
]; ];
foreach ($order->lines->values() as $index => $line) { foreach ($order->lines->values() as $index => $line) {
$productData = ['name' => filled($line->offer_name) ? (string) $line->offer_name : 'Lizenz'];
if ((int) $line->discount_cents > 0) {
$productData['description'] = 'Listenpreis '.Money::format((int) $line->price_cents).', Rabatt '.Money::format((int) $line->discount_cents);
}
$params['line_items'][$index] = [ $params['line_items'][$index] = [
'quantity' => 1, 'quantity' => 1,
'price_data' => [ 'price_data' => [
'currency' => strtolower((string) ($line->currency ?? $order->currency ?? 'EUR')), 'currency' => strtolower((string) ($line->currency ?? $order->currency ?? 'EUR')),
'unit_amount' => (int) $line->price_cents, 'unit_amount' => $line->payable(),
'product_data' => ['name' => filled($line->offer_name) ? (string) $line->offer_name : 'Lizenz'], 'product_data' => $productData,
], ],
]; ];
@@ -82,21 +97,59 @@ public function checkoutFor(Order $order): array
return ['id' => $id, 'url' => $url]; return ['id' => $id, 'url' => $url];
} }
public function assertSandbox(): void public function assertAllowed(): void
{ {
$secret = (string) config('services.stripe.secret'); $secret = (string) config('services.stripe.secret');
if (app()->isProduction()) {
throw new DomainRuleException('Stripe ist in Produktion nicht freigegeben.');
}
if ($secret === '') { if ($secret === '') {
throw new DomainRuleException('Stripe ist nicht eingerichtet: Der Schlüssel fehlt.'); throw new DomainRuleException('Stripe ist nicht eingerichtet: Der Schlüssel fehlt.');
} }
if (! str_starts_with($secret, 'sk_test_') && ! str_starts_with($secret, 'rk_test_')) { if (app()->isProduction()) {
throw new DomainRuleException('Etappe 1 erlaubt nur den Stripe-Testmodus (Schlüssel sk_test_).'); if (! Shop::live()) {
throw new DomainRuleException('Stripe ist in Produktion nicht freigegeben.');
} }
return;
}
if (! str_starts_with($secret, 'sk_test_') && ! str_starts_with($secret, 'rk_test_')) {
throw new DomainRuleException('Außerhalb der Produktion erlaubt Stripe nur den Testmodus (Schlüssel sk_test_).');
}
}
/**
* Vollerstattung der bezahlten Bestellung bei Stripe. Der Betrag ist der gespeicherte Zahlbetrag. Der
* Idempotenzschlüssel verhindert eine doppelte Rückzahlung bei Wiederholung. Schlägt sie fehl, wird nichts
* entzogen (Aufrufer: Checkout::refund).
*/
public function refund(Order $order, Payment $payment, string $reason): void
{
$this->assertAllowed();
$intent = (string) $payment->provider_payment_ref;
if ($intent === '') {
$session = $this->request()->get('/v1/checkout/sessions/'.$payment->provider_reference);
$this->assertOk($session, 'abgefragt');
$intent = (string) $session->json('payment_intent');
}
if ($intent === '') {
throw new DomainRuleException('Zu dieser Zahlung gibt es bei Stripe keinen Zahlungsvorgang. Erstatte sie im Stripe-Dashboard und prüfe den Fall.');
}
$response = $this->request()
->withHeaders(['Idempotency-Key' => 'luf-refund-'.$order->id.'-'.$payment->id])
->post('/v1/refunds', [
'payment_intent' => $intent,
'amount' => $order->payable(),
'reason' => 'requested_by_customer',
'metadata' => ['order_id' => (string) $order->id, 'grund' => mb_substr($reason, 0, 200)],
]);
$this->assertOk($response, 'erstattet');
$payment->provider_payment_ref = $intent;
$payment->save();
} }
/** /**
+6
View File
@@ -101,6 +101,10 @@ public function issueFromOrderLine(OrderLine $line, Party $holder, User $actor):
'update_promise' => $line->update_promise, 'update_promise' => $line->update_promise,
'holder_kind' => $line->holder_kind, 'holder_kind' => $line->holder_kind,
'offer_version_id' => $line->offer_version_id, 'offer_version_id' => $line->offer_version_id,
'licence_scope' => $line->licence_scope,
'trainer_count' => $line->trainer_count,
'price_cents' => (int) $line->price_cents,
'discount_cents' => (int) $line->discount_cents,
], ],
]); ]);
@@ -150,6 +154,8 @@ public function issue(
'update_promise' => $version->update_promise, 'update_promise' => $version->update_promise,
'holder_kind' => $version->holder_kind, 'holder_kind' => $version->holder_kind,
'offer_version_id' => $version->id, 'offer_version_id' => $version->id,
'licence_scope' => $version->licence_scope,
'trainer_count' => $version->trainer_count,
], ],
]); ]);
+107
View File
@@ -0,0 +1,107 @@
<?php
namespace App\Filament\Pages;
use App\Domain\Commerce\SalesTerms;
use App\Domain\Commerce\Shop;
use App\Filament\Support\ShopAccess;
use Filament\Pages\Page;
use Filament\Support\Enums\Width;
use Illuminate\Contracts\Support\Htmlable;
use Illuminate\Support\Facades\DB;
/**
* Verkaufsstart: Was ist bereit, was fehlt noch? Die Seite liest nur. Sie nennt die fehlenden Rechtstexte, den
* Zustand der Zahlungseinrichtung und der Produktivfreigabe, ohne Schlüssel oder Werte zu zeigen. Die Produktivfreigabe
* ist eine Entscheidung von Lars und wird nicht hier, sondern in der Umgebungsdatei des Servers gesetzt.
*/
class Verkaufsstart extends Page
{
protected static string|\UnitEnum|null $navigationGroup = 'Verkauf';
protected static ?string $navigationLabel = 'Verkaufsstart';
protected static ?int $navigationSort = 3;
protected static ?string $slug = 'verkaufsstart';
protected static ?string $title = 'Verkaufsstart';
protected string $view = 'filament.pages.verkaufsstart';
public static function canAccess(): bool
{
return ShopAccess::allowed();
}
public function getHeading(): string|Htmlable|null
{
return null;
}
public function getMaxContentWidth(): Width|string|null
{
return Width::Full;
}
/**
* @return array<string, mixed>
*/
public function daten(): array
{
$legal = [];
foreach (SalesTerms::pages() as $key => $definition) {
$page = SalesTerms::page($key);
$legal[] = [
'text' => $definition['label'],
'neben' => $page === null
? 'Fehlt: Es gibt keine veröffentlichte Seite unter '.implode(' oder ', $definition['paths']).'. Die Seite pflegst du in der Webpräsenz; den Text liefert die Rechtsberatung.'
: 'Veröffentlicht unter '.$page->path.'. Inhalt und Vollständigkeit prüft die Rechtsberatung.',
'zustand' => $page === null ? ['label' => 'Fehlt', 'ton' => 'offen'] : ['label' => 'Veröffentlicht', 'ton' => 'gut'],
];
}
$secret = (string) config('services.stripe.secret');
$mode = match (true) {
$secret === '' => 'nicht eingerichtet',
str_starts_with($secret, 'sk_test_'), str_starts_with($secret, 'rk_test_') => 'Testmodus',
str_starts_with($secret, 'sk_live_'), str_starts_with($secret, 'rk_live_') => 'Live-Schlüssel',
default => 'unbekanntes Format',
};
$withoutScope = DB::table('offer_versions')->where('status', 'aktiv')->where('grant_kind', 'kauf')->whereNull('licence_scope')->count();
$zahlung = [
['text' => 'Zahlungsweg: '.Shop::driver(), 'neben' => 'Test: Testzahlung ohne Anbieter. Stripe: Kasse bei Stripe.', 'zustand' => Shop::driver() === 'stripe' ? ['label' => 'Stripe', 'ton' => 'gut'] : ['label' => 'Test', 'ton' => 'neutral']],
['text' => 'Stripe-Schlüssel: '.$mode, 'neben' => 'Der Schlüssel steht nur in der Umgebungsdatei des Servers und wird hier nie angezeigt.', 'zustand' => $mode === 'nicht eingerichtet' ? ['label' => 'Fehlt', 'ton' => 'offen'] : ['label' => $mode, 'ton' => 'neutral']],
['text' => 'Signaturschlüssel für Stripe-Meldungen: '.(filled(config('services.stripe.webhook_secret')) ? 'gesetzt' : 'fehlt'), 'neben' => 'Ohne ihn weist die Anwendung jede Meldung von Stripe ab; Zahlungen schalten dann nichts frei.', 'zustand' => filled(config('services.stripe.webhook_secret')) ? ['label' => 'Gesetzt', 'ton' => 'gut'] : ['label' => 'Fehlt', 'ton' => 'offen']],
['text' => 'Steuersatz bei Stripe: '.(filled(config('services.stripe.tax_rate')) ? 'hinterlegt' : 'nicht hinterlegt'), 'neben' => 'Steuerstatus und Belegangaben sind noch nicht entschieden (OPEN-06). Ohne sie gibt es keinen Steuerausweis auf der Stripe-Kasse und keine Rechnungsvorlage.', 'zustand' => filled(config('services.stripe.tax_rate')) ? ['label' => 'Hinterlegt', 'ton' => 'gut'] : ['label' => 'Offen', 'ton' => 'offen']],
['text' => 'Kauf auf Rechnung für Vereine: '.(Shop::invoice() ? 'angeboten' : 'aus'), 'neben' => 'Die Rechnung erstellt der Betreiber manuell; den Zahlungseingang bestätigst du in der Bestellverwaltung.', 'zustand' => ['label' => Shop::invoice() ? 'Bereit' : 'Aus', 'ton' => 'neutral']],
];
$freigabe = [
['text' => 'Produktivfreigabe (SHOP_LIVE_RELEASE): '.(config('shop.live_release') === true ? 'gesetzt' : 'nicht gesetzt'), 'neben' => 'Standardmäßig aus. Setzt Lars in der Umgebungsdatei des Servers, wenn er den Verkauf freigibt. Ohne sie bleibt der Shop in Produktion abgeschaltet und Stripe nimmt dort keine Zahlung an.', 'zustand' => config('shop.live_release') === true ? ['label' => 'Gesetzt', 'ton' => 'gut'] : ['label' => 'Aus', 'ton' => 'neutral']],
['text' => 'Umgebung: '.(app()->isProduction() ? 'Produktion' : 'Test oder lokal'), 'neben' => app()->isProduction() ? 'Der Shop ist hier '.(Shop::enabled() ? 'aktiv.' : 'abgeschaltet.') : 'Hier läuft der Shop mit Test- oder Sandbox-Zahlung.', 'zustand' => app()->isProduction() ? (Shop::enabled() ? ['label' => 'Live', 'ton' => 'gut'] : ['label' => 'Abgeschaltet', 'ton' => 'neutral']) : ['label' => 'Test', 'ton' => 'neutral']],
];
$angebote = [
['text' => $withoutScope === 0 ? 'Alle aktiven Käufe haben einen Nutzerkreis.' : $withoutScope.' aktive Kaufangebote ohne festgelegten Nutzerkreis', 'neben' => $withoutScope === 0 ? null : 'Käufer sähen „Nutzerkreis nicht festgelegt“. Lege Einzel- oder Mehrfachlizenz mit „Geänderte Fassung aktivieren“ am Angebot fest.', 'zustand' => $withoutScope === 0 ? ['label' => 'Vollständig', 'ton' => 'gut'] : ['label' => 'Offen', 'ton' => 'offen']],
];
return [
'kopf' => [
'titel' => 'Verkaufsstart',
'typ' => 'Bereitschaft für den Verkauf in Deutschland',
'status' => ['text' => SalesTerms::missingPages() === [] ? 'Alle Rechtstexte sind veröffentlicht. Die rechtliche Freigabe der Inhalte steht aus, bis die Rechtsberatung sie bestätigt.' : 'Es fehlen veröffentlichte Rechtstexte. Ohne sie bleibt der Shop in Produktion abgeschaltet.', 'ton' => SalesTerms::missingPages() === [] ? 'gut' : 'offen'],
],
'haupt' => [
['titel' => 'Rechtstexte im Bestellablauf', 'hilfe' => 'Der Checkout verlinkt diese Seiten und hält mit jeder Bestellung fest, welche Fassung galt. Den Wortlaut der Zustimmungen im Checkout hat der Betreiber noch rechtlich zu prüfen (Entwurf '.SalesTerms::VERSION.').', 'zeilen' => $legal],
['titel' => 'Zahlung und Belege', 'zeilen' => $zahlung],
],
'seite' => [
['titel' => 'Freigabe', 'zeilen' => $freigabe, 'hilfe' => 'Die Produktivfreigabe liegt bei Lars. Sie wird nicht über diese Oberfläche gesetzt.'],
['titel' => 'Angebote', 'zeilen' => $angebote],
],
];
}
}
@@ -0,0 +1,65 @@
<?php
namespace App\Filament\Resources\DiscountCodes;
use App\Domain\Commerce\Discount\DiscountCode;
use App\Filament\Resources\DiscountCodes\Pages\ListDiscountCodes;
use App\Filament\Resources\DiscountCodes\Pages\ViewDiscountCode;
use App\Filament\Support\ShopAccess;
use Filament\Resources\Resource;
use Filament\Schemas\Schema;
use Filament\Tables\Columns\TextColumn;
use Filament\Tables\Table;
use Illuminate\Auth\Access\Response;
use Illuminate\Database\Eloquent\Model;
/**
* Rabattcodes (FACH-14): anlegen, bearbeiten, zeitlich begrenzen, deaktivieren und einzelne Konten freischalten.
* Die Seiten nutzen die gemeinsamen Bausteine (Bestandsliste, Objektseite, Dialoge) wie die übrigen Kataloglisten.
*/
class DiscountCodeResource extends Resource
{
protected static ?string $model = DiscountCode::class;
protected static string|\UnitEnum|null $navigationGroup = 'Verkauf';
protected static ?string $navigationLabel = 'Rabattcodes';
protected static ?string $modelLabel = 'Rabattcode';
protected static ?string $pluralModelLabel = 'Rabattcodes';
protected static ?string $recordTitleAttribute = 'code';
protected static ?int $navigationSort = 2;
public static function canViewAny(): bool
{
return ShopAccess::allowed();
}
public static function getViewAuthorizationResponse(Model $record): Response
{
return ShopAccess::allowed() ? Response::allow() : Response::deny();
}
public static function form(Schema $schema): Schema
{
return $schema;
}
public static function table(Table $table): Table
{
return $table->columns([
TextColumn::make('code')->label('Code')->searchable(),
]);
}
public static function getPages(): array
{
return [
'index' => ListDiscountCodes::route('/'),
'view' => ViewDiscountCode::route('/{record}'),
];
}
}
@@ -0,0 +1,103 @@
<?php
namespace App\Filament\Resources\DiscountCodes\Pages;
use App\Domain\Commerce\Discount\DiscountCode;
use App\Domain\Commerce\Discount\DiscountService;
use App\Filament\Resources\DiscountCodes\DiscountCodeResource;
use App\Filament\Support\DiscountCodeForm;
use App\Filament\Support\ListsCatalog;
use App\Filament\Support\ReportsDomainRules;
use Filament\Actions\Action;
use Filament\Resources\Pages\ListRecords;
use Illuminate\Contracts\Support\Htmlable;
class ListDiscountCodes extends ListRecords
{
use ListsCatalog;
use ReportsDomainRules;
protected static string $resource = DiscountCodeResource::class;
public function getSubheading(): string|Htmlable|null
{
return 'Ein Code gilt für den ganzen Warenkorb oder nur für ausgewählte Ziele, und er ist allgemein einlösbar oder nur für freigeschaltete Konten. Beides stellst du unabhängig voneinander ein. Pro Bestellung gilt höchstens ein Code.';
}
protected function getHeaderActions(): array
{
return [
Action::make('create')->label('Code anlegen')
->modalHeading('Neuer Rabattcode')
->modalDescription('Dieselbe Maske öffnet sich später beim Bearbeiten. Freigaben für einzelne Konten verwaltest du danach auf der Seite des Codes.')
->modalSubmitActionLabel('Code anlegen')
->modalWidth('3xl')
->fillForm(['kind' => DiscountCode::PERCENT, 'scope' => DiscountCode::SCOPE_CART, 'eligibility' => DiscountCode::OPEN, 'active' => true])
->schema(DiscountCodeForm::schema())
->action(function (array $data): void {
$code = null;
$this->report(function () use ($data, &$code): void {
[$fields, $targets] = DiscountCodeForm::fromForm($data);
$code = app(DiscountService::class)->save($fields, $targets);
}, 'Der Rabattcode ist angelegt.');
if ($code instanceof DiscountCode) {
$this->redirect(DiscountCodeResource::getUrl('view', ['record' => $code]));
}
}),
];
}
protected function catalogRows(): array
{
$rows = [];
$now = now();
foreach (DiscountCode::query()->with('targets')->withCount(['releases as active_releases_count' => fn ($query) => $query->whereNull('revoked_at')])->orderByDesc('id')->get() as $code) {
$state = $code->stateAt($now);
$url = DiscountCodeResource::getUrl('view', ['record' => $code]);
$rows[] = [
'schluessel' => 'c'.$code->id,
'titel' => $code->code,
'meta' => 'Rabattcode · '.$code->label,
'text' => $code->valueLabel().' · '.($code->forSelection() ? 'ausgewählte Ziele ('.$code->targets->count().')' : 'gesamter Warenkorb').' · '.($code->restricted() ? 'nur freigeschaltete Konten' : 'allgemein einlösbar'),
'symbol' => 'etikett',
'url' => $url,
'chips' => [
match ($state) {
'aktiv' => ['label' => 'Gültig', 'ton' => 'gut'],
'abgelaufen' => ['label' => 'Abgelaufen', 'ton' => 'leise'],
'noch_nicht' => ['label' => 'Noch nicht gültig', 'ton' => 'offen'],
default => ['label' => 'Deaktiviert', 'ton' => 'leise'],
},
['label' => $code->valueLabel(), 'ton' => 'neutral'],
['label' => $code->restricted() ? $code->active_releases_count.' freigeschaltet' : 'Allgemein', 'ton' => 'neutral'],
],
'zustand' => [$state === 'aktiv' ? 'aktiv' : 'inaktiv'],
'aktionen' => [['label' => 'Öffnen', 'href' => $url]],
];
}
return $rows;
}
protected function zustandOptionen(): array
{
return ['alle' => 'Jeder Zustand', 'aktiv' => 'Gerade gültig', 'inaktiv' => 'Abgelaufen, deaktiviert oder noch nicht gültig'];
}
protected function suchPlatzhalter(): string
{
return 'Code oder Name';
}
protected function einheit(): array
{
return ['Rabattcode', 'Rabattcodes'];
}
protected function leer(): array
{
return ['titel' => 'Noch keine Rabattcodes', 'text' => 'Mit „Code anlegen“ oben entsteht der erste Rabattcode, zum Beispiel der gemeinsame Zertifizierungscode.'];
}
}
@@ -0,0 +1,293 @@
<?php
namespace App\Filament\Resources\DiscountCodes\Pages;
use App\Domain\Catalog\Bundle;
use App\Domain\Catalog\LicenseArticle;
use App\Domain\Catalog\Offer;
use App\Domain\Commerce\Discount\DiscountCode;
use App\Domain\Commerce\Discount\DiscountRelease;
use App\Domain\Commerce\Discount\DiscountService;
use App\Domain\Commerce\Money;
use App\Domain\Commerce\Order;
use App\Filament\Resources\DiscountCodes\DiscountCodeResource;
use App\Filament\Support\DiscountCodeForm;
use App\Filament\Support\ReportsDomainRules;
use App\Models\User;
use Filament\Actions\Action;
use Filament\Forms\Components\DatePicker;
use Filament\Forms\Components\Select;
use Filament\Forms\Components\Textarea;
use Filament\Resources\Pages\ViewRecord;
use Filament\Schemas\Components\View;
use Filament\Schemas\Schema;
use Filament\Support\Enums\Width;
use Illuminate\Contracts\Support\Htmlable;
use Illuminate\Support\Carbon;
/**
* Rabattcode im gemeinsamen Rahmen. Bearbeiten nutzt dieselbe Maske wie Anlegen. Konten werden für genau diesen Code
* freigeschaltet und die Freigabe wird mit Begründung entzogen; der Verlauf bleibt stehen.
*/
class ViewDiscountCode extends ViewRecord
{
use ReportsDomainRules;
protected static string $resource = DiscountCodeResource::class;
public function getTitle(): string|Htmlable
{
return (string) $this->getRecord()->code;
}
public function getHeading(): string|Htmlable
{
return '';
}
public function getMaxContentWidth(): Width|string|null
{
return Width::Full;
}
protected function getHeaderActions(): array
{
return [];
}
/**
* @return array<string, string>
*/
public function getBreadcrumbs(): array
{
return [];
}
public function infolist(Schema $schema): Schema
{
return $schema->components([
View::make('filament.catalog.objekt')->viewData(fn (): array => $this->codeDaten())->columnSpanFull(),
])->columns(1);
}
private function code(): DiscountCode
{
/** @var DiscountCode $code */
$code = $this->getRecord();
return $code;
}
public function editAction(): Action
{
return Action::make('edit')
->label('Code bearbeiten')
->modalHeading(fn (): string => 'Rabattcode „'.$this->code()->code.'“ bearbeiten')
->modalDescription('Bestellungen, die schon aufgegeben sind, behalten ihren gespeicherten Rabatt. Eine Änderung wirkt auf künftige Einlösungen und auf offene Warenkörbe. „Abbrechen“ verwirft die Eingaben.')
->modalSubmitActionLabel('Änderungen speichern')
->modalWidth('3xl')
->fillForm(fn (): array => DiscountCodeForm::fill($this->code()))
->schema(DiscountCodeForm::schema())
->action(function (array $data): void {
$this->report(function () use ($data): void {
[$fields, $targets] = DiscountCodeForm::fromForm($data);
app(DiscountService::class)->save($fields, $targets, $this->code());
}, 'Der Rabattcode ist gespeichert.');
$this->refreshRecord();
});
}
public function toggleAction(): Action
{
return Action::make('toggle')
->label(fn (): string => $this->code()->active ? 'Code deaktivieren' : 'Code aktivieren')
->color(fn (): string => $this->code()->active ? 'danger' : 'success')
->requiresConfirmation()
->modalHeading(fn (): string => $this->code()->active ? 'Code „'.$this->code()->code.'“ deaktivieren?' : 'Code „'.$this->code()->code.'“ aktivieren?')
->modalDescription(fn (): string => $this->code()->active
? 'Der Code lässt sich danach nicht mehr einlösen. In offenen Warenkörben zeigt die Bestellübersicht den Grund; bereits aufgegebene Bestellungen bleiben unverändert. Freigaben und Einstellungen bleiben erhalten.'
: 'Der Code lässt sich danach wieder einlösen, soweit sein Gültigkeitszeitraum und die Freigaben es zulassen.')
->modalSubmitActionLabel(fn (): string => $this->code()->active ? 'Deaktivieren' : 'Aktivieren')
->action(function (): void {
$code = $this->code();
$this->report(function () use ($code): string {
app(DiscountService::class)->setActive($code, ! $code->active);
return $code->active ? 'Der Code ist aktiviert.' : 'Der Code ist deaktiviert.';
}, 'Gespeichert.');
$this->refreshRecord();
});
}
public function releaseAction(): Action
{
return Action::make('release')
->label('Konto freischalten')
->modalHeading(fn (): string => 'Konto für den Code „'.$this->code()->code.'“ freischalten')
->modalDescription('Das Konto darf genau diesen Code einlösen, solange Code und Freigabe gültig sind, auch bei späteren Bestellungen. Die Freigabe gilt nicht für andere Codes. Prüfe vorher die Zertifizierung des Kontos.')
->modalSubmitActionLabel('Konto freischalten')
->schema([
Select::make('user_id')->label('Mitgliedskonto')->required()->searchable()
->getSearchResultsUsing(fn (string $search): array => $this->searchMembers($search))
->getOptionLabelUsing(fn ($value): ?string => ($user = User::query()->find($value)) === null ? null : $user->name.' ('.$user->email.')')
->helperText('Suche nach Name oder E-Mail-Adresse. Nur Konten mit Mitgliedsprofil.'),
DatePicker::make('valid_until')->label('Freigabe gültig bis einschließlich')->native(false)->displayFormat('d.m.Y')
->helperText('Leer: ohne Ende. Danach gilt der Code für dieses Konto nicht mehr.'),
Textarea::make('reason')->label('Grundlage der Freigabe')->rows(2)->maxLength(500)
->helperText('Zum Beispiel „Zertifikat vom 12.11.2026 geprüft“. Bleibt im Verlauf stehen.'),
])
->visible(fn (): bool => $this->code()->restricted())
->action(function (array $data): void {
$this->report(function () use ($data): string {
$member = User::query()->findOrFail($data['user_id']);
$until = filled($data['valid_until'] ?? null) ? Carbon::parse((string) $data['valid_until'], config('app.timezone'))->endOfDay() : null;
app(DiscountService::class)->release($this->code(), $member, auth('staff')->user() ?? auth()->user(), $until, $data['reason'] ?? null);
return 'Das Konto von '.$member->name.' ist für den Code freigeschaltet.';
}, 'Das Konto ist freigeschaltet.');
$this->refreshRecord();
});
}
public function revokeAction(): Action
{
return Action::make('revoke')
->label('Freigabe entziehen')
->color('danger')
->requiresConfirmation()
->modalHeading('Freigabe entziehen?')
->modalDescription('Das Konto kann diesen Code danach nicht mehr einlösen. Offene Warenkörbe des Kontos zeigen den Grund und lassen sich erst ohne Code bestellen. Aufgegebene Bestellungen bleiben unverändert; die Freigabe bleibt mit dem Entzug im Verlauf stehen.')
->modalSubmitActionLabel('Freigabe entziehen')
->schema([
Textarea::make('reason')->label('Grund')->rows(2)->maxLength(500),
])
->action(function (array $data, array $arguments): void {
$this->report(function () use ($data, $arguments): string {
$release = DiscountRelease::query()->where('discount_code_id', $this->code()->id)->findOrFail((int) ($arguments['release'] ?? 0));
app(DiscountService::class)->revoke($release, auth('staff')->user() ?? auth()->user(), $data['reason'] ?? null);
return 'Die Freigabe ist entzogen.';
}, 'Die Freigabe ist entzogen.');
$this->refreshRecord();
});
}
private function refreshRecord(): void
{
$this->getRecord()->unsetRelations();
$this->getRecord()->refresh();
}
/**
* @return array<int, string>
*/
private function searchMembers(string $search): array
{
$like = '%'.mb_strtolower(trim($search)).'%';
return User::query()
->whereNotNull('party_id')
->where(fn ($query) => $query->whereRaw('LOWER(name) LIKE ?', [$like])->orWhereRaw('LOWER(email) LIKE ?', [$like]))
->orderBy('name')
->limit(20)
->get()
->mapWithKeys(fn (User $user): array => [$user->id => $user->name.' ('.$user->email.')'])
->all();
}
/**
* @return array<string, mixed>
*/
private function codeDaten(): array
{
$code = $this->code();
$code->loadMissing('targets');
$state = $code->stateAt(now());
$date = fn (?Carbon $value): string => $value === null ? '' : $value->timezone(config('app.timezone'))->format('d.m.Y');
$targets = [];
foreach ($code->targets as $target) {
$targets[] = match ($target->target_type) {
DiscountCode::TARGET_OFFER => 'Angebot „'.(Offer::query()->find($target->target_id)?->name ?? 'gelöscht').'“',
DiscountCode::TARGET_ARTICLE => 'Lizenzartikel '.(LicenseArticle::query()->find($target->target_id)?->code ?? 'gelöscht'),
DiscountCode::TARGET_BUNDLE => 'Paket „'.(Bundle::query()->find($target->target_id)?->name ?? 'gelöscht').'“',
default => 'Ziel',
};
}
$releases = $code->releases()->with(['user', 'grantor'])->get();
$active = $releases->filter(fn (DiscountRelease $release): bool => $release->revoked_at === null);
$past = $releases->filter(fn (DiscountRelease $release): bool => $release->revoked_at !== null);
$orders = Order::query()->where('discount_code_id', $code->id)->with('user')->latest('id')->limit(10)->get();
$paid = Order::query()->where('discount_code_id', $code->id)->where('status', 'bezahlt')->count();
return [
'kopf' => [
'brot' => [['label' => 'Rabattcodes', 'href' => DiscountCodeResource::getUrl('index')], $code->code],
'titel' => $code->code,
'typ' => 'Rabattcode · '.$code->label,
'status' => match ($state) {
'aktiv' => ['text' => 'Gerade gültig'.($code->valid_until ? ' bis einschließlich '.$date($code->valid_until) : ''), 'ton' => 'gut'],
'abgelaufen' => ['text' => 'Abgelaufen am '.$date($code->valid_until).'. Der Code lässt sich nicht mehr einlösen.', 'ton' => 'offen'],
'noch_nicht' => ['text' => 'Gilt erst ab dem '.$date($code->valid_from).'.', 'ton' => 'offen'],
default => ['text' => 'Deaktiviert. Der Code lässt sich nicht einlösen.', 'ton' => 'offen'],
},
'aktionen' => [
['label' => 'Code bearbeiten', 'wire' => "mountAction('edit')", 'art' => 'primary'],
...($code->restricted() ? [['label' => 'Konto freischalten', 'wire' => "mountAction('release')", 'art' => 'line']] : []),
['label' => $code->active ? 'Code deaktivieren' : 'Code aktivieren', 'wire' => "mountAction('toggle')", 'art' => 'line'],
],
],
'haupt' => [
[
'titel' => 'Der Code auf einen Blick',
'hilfe' => 'Geltungsbereich und Einlösungsberechtigung sind zwei getrennte Einstellungen. Der Rabatt ändert den Preis, nie den Nutzungsumfang.',
'zeilen' => [
['text' => 'Rabatt: '.$code->valueLabel(), 'neben' => $code->kind === DiscountCode::PERCENT ? 'Je Position gerundet.' : 'Je Bestellung, anteilig auf die betroffenen Positionen verteilt.'],
['text' => 'Geltungsbereich: '.($code->forSelection() ? 'nur ausgewählte Ziele' : 'gesamter Warenkorb'), 'neben' => $code->forSelection() ? 'Ein Paket ist ein eigenes Ziel und folgt nicht aus einem enthaltenen Artikel.' : null],
...array_map(fn (string $target): array => ['text' => '· '.$target, 'neben' => null], $targets),
['text' => 'Einlösung: '.($code->restricted() ? 'nur freigeschaltete Konten' : 'allgemein, für alle angemeldeten Käufer'), 'neben' => 'Pro Bestellung gilt höchstens ein Code.'],
['text' => 'Gültigkeit: '.($code->valid_from ? 'ab '.$date($code->valid_from) : 'sofort').($code->valid_until ? ' bis einschließlich '.$date($code->valid_until) : ', unbegrenzt'), 'neben' => $code->active ? 'Aktiv' : 'Deaktiviert'],
...(filled($code->note) ? [['text' => 'Notiz: '.$code->note, 'neben' => null]] : []),
],
],
[
'titel' => $code->restricted() ? 'Freigeschaltete Konten' : 'Freigaben',
'zusatz' => $code->restricted() ? $active->count().' aktiv' : null,
'hilfe' => $code->restricted()
? 'Nur diese Konten können den Code einlösen. Die Freigabe gilt nur für diesen Code und wiederholt, solange Code und Freigabe gültig sind.'
: 'Der Code ist allgemein einlösbar. Freigaben sind nicht nötig. Stelle „Einlösung“ auf freigeschaltete Konten, um den Code zu beschränken.',
'zeilen' => $code->restricted() ? $active->map(fn (DiscountRelease $release): array => [
'text' => ($release->user?->name ?? 'Konto').' ('.($release->user?->email ?? '').')',
'neben' => 'freigeschaltet am '.$date($release->granted_at).($release->grantor ? ' von '.$release->grantor->name : '').($release->valid_until ? ', gültig bis einschließlich '.$date($release->valid_until) : '').(filled($release->reason) ? ' · '.$release->reason : ''),
'aktion' => ['label' => 'Entziehen', 'wire' => "mountAction('revoke', { release: ".$release->id.' })'],
])->values()->all() : [],
'leer' => ['titel' => $code->restricted() ? 'Noch kein Konto freigeschaltet' : 'Keine Freigaben nötig', 'text' => $code->restricted() ? 'Mit „Konto freischalten“ oben gibst du ein Konto für diesen Code frei, zum Beispiel nach der Prüfung eines Zertifikats.' : 'Jeder angemeldete Käufer kann den Code einlösen.'],
],
],
'seite' => [
[
'titel' => 'Verwendung',
'zeilen' => $orders->map(fn (Order $order): array => [
'text' => 'Bestellung '.$order->id.' · −'.Money::format((int) $order->discount_cents),
'zustand' => ['label' => match ($order->status) {
'bezahlt' => 'Bezahlt', 'erstattet' => 'Erstattet', 'fehlgeschlagen' => 'Fehlgeschlagen', default => 'Offen'
}, 'ton' => $order->status === 'bezahlt' ? 'gut' : 'leise'],
'neben' => ($order->user?->name ?? '').' · '.$date($order->created_at),
])->all(),
'leer' => 'Der Code wurde noch in keiner Bestellung verwendet.',
'hilfe' => $orders->isEmpty() ? null : $paid.' bezahlte Bestellung'.($paid === 1 ? '' : 'en').' mit diesem Code. Gezeigt werden die letzten zehn.',
],
[
'titel' => 'Entzogene Freigaben',
'zeilen' => $past->map(fn (DiscountRelease $release): array => [
'text' => ($release->user?->name ?? 'Konto'),
'neben' => 'entzogen am '.$date($release->revoked_at).(filled($release->reason) ? ' · '.$release->reason : ''),
])->values()->all(),
'leer' => 'Keine Freigabe wurde entzogen.',
'hilfe' => 'Der Verlauf bleibt erhalten.',
],
],
];
}
}
@@ -7,6 +7,7 @@
use App\Domain\Catalog\Composition; use App\Domain\Catalog\Composition;
use App\Domain\Catalog\CompositionVersion; use App\Domain\Catalog\CompositionVersion;
use App\Domain\Catalog\DomainRuleException; use App\Domain\Catalog\DomainRuleException;
use App\Domain\Catalog\LicenceScope;
use App\Domain\Catalog\LicenseArticle; use App\Domain\Catalog\LicenseArticle;
use App\Domain\Catalog\Offer; use App\Domain\Catalog\Offer;
use App\Domain\Catalog\OfferService; use App\Domain\Catalog\OfferService;
@@ -45,6 +46,9 @@ class ViewOffer extends ViewRecord
protected static string $resource = OfferResource::class; protected static string $resource = OfferResource::class;
/** Wert der Auswahl „Produktseite“ für ein Paket mit eigener Seite. */
private const OWN_BUNDLE_PAGE = '__paket';
public function getTitle(): string|Htmlable public function getTitle(): string|Htmlable
{ {
return (string) $this->getRecord()->name; return (string) $this->getRecord()->name;
@@ -120,6 +124,16 @@ public function activateAction(): Action
'organisation' => 'Organisationen und Vereine', 'organisation' => 'Organisationen und Vereine',
])->required() ])->required()
->helperText('Wähle die Eignung passend zu den Rechten: Organisationslizenzen brauchen institutionelle Rechte. Das System erzwingt diese Kopplung nicht.'), ->helperText('Wähle die Eignung passend zu den Rechten: Organisationslizenzen brauchen institutionelle Rechte. Das System erzwingt diese Kopplung nicht.'),
Select::make('licence_scope')->label('Nutzerkreis')
->options(LicenceScope::options())
->required()
->live()
->helperText('Wie viele Trainer die Inhalte einsetzen dürfen. Das ist unabhängig vom Lizenzinhaber (Person oder Verein), vom Nutzungszweck der Rechte und vom Preis; es wird aus keinem davon abgeleitet. Der Download bleibt zum Start beim bestellenden Konto. Der Wert wird mit der Bestellung festgehalten.'),
TextInput::make('trainer_count')->label('Anzahl Trainer')
->numeric()->minValue(2)->maxValue(LicenceScope::MAX_TRAINERS)->integer()
->required(fn (Get $get): bool => $get('licence_scope') === LicenceScope::MULTI)
->visible(fn (Get $get): bool => $get('licence_scope') === LicenceScope::MULTI)
->helperText('Höchstzahl der Trainer, die die Inhalte einsetzen dürfen, mindestens 2. Eine Einzellizenz gilt immer für genau einen Trainer.'),
Select::make('grant_kind')->label('Vergabe')->options([ Select::make('grant_kind')->label('Vergabe')->options([
'kauf' => 'Kauf', 'kauf' => 'Kauf',
'auf_abruf' => 'Auf Abruf', 'auf_abruf' => 'Auf Abruf',
@@ -201,13 +215,16 @@ public function activateAction(): Action
$version = DB::transaction(function () use ($service, $offer, $data, $lines, $kept, $price) { $version = DB::transaction(function () use ($service, $offer, $data, $lines, $kept, $price) {
$service->assignProduct( $service->assignProduct(
$offer, $offer,
filled($data['composition_id'] ?? null) ? (int) $data['composition_id'] : null, filled($data['composition_id'] ?? null) && $data['composition_id'] !== self::OWN_BUNDLE_PAGE ? (int) $data['composition_id'] : null,
$data['option_label'] ?? null, $data['option_label'] ?? null,
($data['composition_id'] ?? null) === self::OWN_BUNDLE_PAGE,
); );
return $service->activate($offer, $lines, [ return $service->activate($offer, $lines, [
...$kept, ...$kept,
'holder_kind' => $data['holder_kind'], 'holder_kind' => $data['holder_kind'],
'licence_scope' => $data['licence_scope'] ?? null,
'trainer_count' => $data['trainer_count'] ?? null,
'grant_kind' => $data['grant_kind'], 'grant_kind' => $data['grant_kind'],
'price_cents' => $price, 'price_cents' => $price,
'composition_version_id' => filled($data['composition_version_id'] ?? null) ? (int) $data['composition_version_id'] : null, 'composition_version_id' => filled($data['composition_version_id'] ?? null) ? (int) $data['composition_version_id'] : null,
@@ -267,7 +284,7 @@ private function productPages(): array
{ {
$catalog = app(PublicCatalogReader::class); $catalog = app(PublicCatalogReader::class);
return Composition::query() return [self::OWN_BUNDLE_PAGE => 'Eigene Paketseite · zeigt den Umfang des Pakets (nur für ein Angebot aus genau einer Paketfassung)'] + Composition::query()
->with('editorialContentKind') ->with('editorialContentKind')
->whereNull('archived_at') ->whereNull('archived_at')
->orderBy('designation') ->orderBy('designation')
@@ -291,15 +308,17 @@ private function formFromActive(): array
$active = $this->activeVersion(); $active = $this->activeVersion();
/** @var Offer $offer */ /** @var Offer $offer */
$offer = $this->getRecord(); $offer = $this->getRecord();
$option = ['option_label' => $offer->option_label, 'composition_id' => $offer->composition_id]; $option = ['option_label' => $offer->option_label, 'composition_id' => $offer->standalone_bundle ? self::OWN_BUNDLE_PAGE : $offer->composition_id];
if ($active === null) { if ($active === null) {
return [...$option, 'holder_kind' => 'person', 'grant_kind' => 'kauf', 'lines' => [['kind' => 'article']]]; return [...$option, 'holder_kind' => 'person', 'licence_scope' => LicenceScope::SINGLE, 'grant_kind' => 'kauf', 'lines' => [['kind' => 'article']]];
} }
return [ return [
...$option, ...$option,
'holder_kind' => $active->holder_kind, 'holder_kind' => $active->holder_kind,
'licence_scope' => $active->licence_scope,
'trainer_count' => $active->trainer_count,
'grant_kind' => $active->grant_kind, 'grant_kind' => $active->grant_kind,
'price_euro' => $active->price_cents === null ? null : number_format($active->price_cents / 100, 2, ',', ''), 'price_euro' => $active->price_cents === null ? null : number_format($active->price_cents / 100, 2, ',', ''),
'lines' => $active->lines->sortBy('position')->map(fn ($line): array => [ 'lines' => $active->lines->sortBy('position')->map(fn ($line): array => [
@@ -400,6 +419,7 @@ private function optionAbschnitt(Offer $offer, OfferVersion $active): array
->unique() ->unique()
->implode('; '); ->implode('; ');
$seite = $offer->composition; $seite = $offer->composition;
$eigeneSeite = $offer->standalone_bundle;
$kaufbar = app(OfferService::class)->purchasableVersion($offer) !== null; $kaufbar = app(OfferService::class)->purchasableVersion($offer) !== null;
return [ return [
@@ -409,10 +429,11 @@ private function optionAbschnitt(Offer $offer, OfferVersion $active): array
'zeilen' => [ 'zeilen' => [
['text' => 'Preis: '.$option['price'], 'neben' => $active->grant_kind === 'kauf' ? 'Kauf mit Testzahlung' : CatalogLabels::vergabe($active)], ['text' => 'Preis: '.$option['price'], 'neben' => $active->grant_kind === 'kauf' ? 'Kauf mit Testzahlung' : CatalogLabels::vergabe($active)],
['text' => 'Geeignet für: '.$option['for'], 'neben' => $option['term']], ['text' => 'Geeignet für: '.$option['for'], 'neben' => $option['term']],
['text' => 'Nutzerkreis: '.$option['licence'], 'neben' => $option['licence_scope'] === null ? 'Mit „Geänderte Fassung aktivieren“ festlegen.' : 'Lizenzinhaber, Nutzerkreis und Downloadkonto sind getrennte Angaben.'],
['text' => 'Rechte: '.($rechte !== '' ? $rechte : 'keine'), 'neben' => null], ['text' => 'Rechte: '.($rechte !== '' ? $rechte : 'keine'), 'neben' => null],
['text' => 'Zugrunde liegender Inhalt: '.($inhalt !== '' ? $inhalt : '–'), 'neben' => null], ['text' => 'Zugrunde liegender Inhalt: '.($inhalt !== '' ? $inhalt : '–'), 'neben' => null],
['text' => 'Status: '.($kaufbar ? 'Öffentlich kaufbar' : 'Nicht als Kauf angeboten'), 'neben' => $kaufbar ? 'Aktive Fassung '.$active->number : null], ['text' => 'Status: '.($kaufbar ? 'Öffentlich kaufbar' : 'Nicht als Kauf angeboten'), 'neben' => $kaufbar ? 'Aktive Fassung '.$active->number : null],
['text' => 'Produktseite: '.($seite !== null ? ($seite->display_title ?: $seite->designation) : 'noch nicht zugeordnet'), 'neben' => $seite !== null ? 'Option „'.$offer->optionName().'“' : 'Mit „Geänderte Fassung aktivieren“ zuordnen.'], ['text' => 'Produktseite: '.($eigeneSeite ? 'eigene Paketseite mit dem Umfang des Pakets' : ($seite !== null ? ($seite->display_title ?: $seite->designation) : 'noch nicht zugeordnet')), 'neben' => $eigeneSeite || $seite !== null ? 'Option „'.$offer->optionName().'“' : 'Mit „Geänderte Fassung aktivieren“ zuordnen.'],
], ],
]; ];
} }
@@ -0,0 +1,68 @@
<?php
namespace App\Filament\Resources\Orders;
use App\Domain\Commerce\Order;
use App\Filament\Resources\Orders\Pages\ListOrders;
use App\Filament\Resources\Orders\Pages\ViewOrder;
use App\Filament\Support\ShopAccess;
use Filament\Resources\Resource;
use Filament\Schemas\Schema;
use Filament\Tables\Columns\TextColumn;
use Filament\Tables\Table;
use Illuminate\Auth\Access\Response;
use Illuminate\Database\Eloquent\Model;
/**
* Bestellverwaltung (PAY-006): Bestellungen lesen, bei Kauf auf Rechnung den Zahlungseingang bestätigen und
* bezahlte Bestellungen vollständig erstatten. Es gibt keine Bearbeitung der gespeicherten Konditionen.
*/
class OrderResource extends Resource
{
protected static ?string $model = Order::class;
protected static string|\UnitEnum|null $navigationGroup = 'Verkauf';
protected static ?string $navigationLabel = 'Bestellungen';
protected static ?string $modelLabel = 'Bestellung';
protected static ?string $pluralModelLabel = 'Bestellungen';
protected static ?int $navigationSort = 1;
public static function canViewAny(): bool
{
return ShopAccess::allowed();
}
public static function canCreate(): bool
{
return false;
}
public static function getViewAuthorizationResponse(Model $record): Response
{
return ShopAccess::allowed() ? Response::allow() : Response::deny();
}
public static function form(Schema $schema): Schema
{
return $schema;
}
public static function table(Table $table): Table
{
return $table->columns([
TextColumn::make('id')->label('Bestellung'),
]);
}
public static function getPages(): array
{
return [
'index' => ListOrders::route('/'),
'view' => ViewOrder::route('/{record}'),
];
}
}
@@ -0,0 +1,104 @@
<?php
namespace App\Filament\Resources\Orders\Pages;
use App\Domain\Commerce\Money;
use App\Domain\Commerce\Order;
use App\Filament\Resources\Orders\OrderResource;
use App\Filament\Support\ListsCatalog;
use Filament\Resources\Pages\ListRecords;
use Illuminate\Contracts\Support\Htmlable;
class ListOrders extends ListRecords
{
use ListsCatalog;
protected static string $resource = OrderResource::class;
public function getSubheading(): string|Htmlable|null
{
return 'Bestellungen mit Lizenzinhaber, Zahlungsweg und Zahlbetrag. Bei Kauf auf Rechnung bestätigst du hier den Zahlungseingang; bezahlte Bestellungen erstattest du vollständig.';
}
protected function getHeaderActions(): array
{
return [];
}
protected function catalogRows(): array
{
$rows = [];
foreach (Order::query()->with(['lines', 'user', 'party'])->orderByDesc('id')->limit(300)->get() as $order) {
$url = OrderResource::getUrl('view', ['record' => $order]);
$zustand = [$order->status];
$chips = [
match ($order->status) {
'bezahlt' => ['label' => 'Bezahlt', 'ton' => 'gut'],
'erstattet' => ['label' => 'Erstattet', 'ton' => 'leise'],
'fehlgeschlagen' => ['label' => 'Fehlgeschlagen', 'ton' => 'leise'],
default => ['label' => $order->payment_method === 'rechnung' ? 'Offen: wartet auf Zahlungseingang' : 'Offen', 'ton' => 'offen'],
},
['label' => match ($order->payment_method) {
'rechnung' => 'Rechnung', 'stripe' => 'Stripe', default => 'Testzahlung'
}, 'ton' => 'neutral'],
['label' => Money::format($order->payable()), 'ton' => 'neutral'],
];
if ($order->discount_cents > 0) {
$chips[] = ['label' => 'Rabatt '.($order->discount_snapshot['code'] ?? ''), 'ton' => 'neutral'];
}
if ($order->withdrawal_requested_at !== null) {
$chips[] = ['label' => 'Widerruf erklärt', 'ton' => 'offen'];
$zustand[] = 'widerruf';
}
if ($order->payment_method === 'rechnung' && $order->status === 'offen') {
$zustand[] = 'rechnung_offen';
}
$rows[] = [
'schluessel' => 'o'.$order->id,
'titel' => 'Bestellung '.$order->id,
'meta' => ($order->party?->display_name ?? '–').' · bestellt von '.($order->user?->name ?? '–'),
'text' => $order->lines->pluck('offer_name')->implode('; '),
'suchtext' => (string) ($order->user?->email ?? ''),
'symbol' => 'etikett',
'url' => $url,
'chips' => $chips,
'zustand' => $zustand,
'aktionen' => [['label' => 'Öffnen', 'href' => $url]],
];
}
return $rows;
}
protected function zustandOptionen(): array
{
return [
'alle' => 'Jeder Zustand',
'rechnung_offen' => 'Rechnung: wartet auf Zahlungseingang',
'widerruf' => 'Widerruf erklärt',
'offen' => 'Offen',
'bezahlt' => 'Bezahlt',
'erstattet' => 'Erstattet',
];
}
protected function suchPlatzhalter(): string
{
return 'Nummer, Name, E-Mail oder Angebot';
}
protected function einheit(): array
{
return ['Bestellung', 'Bestellungen'];
}
protected function leer(): array
{
return ['titel' => 'Noch keine Bestellungen', 'text' => 'Sobald im Shop bestellt wird, erscheinen die Bestellungen hier.'];
}
}
@@ -0,0 +1,212 @@
<?php
namespace App\Filament\Resources\Orders\Pages;
use App\Domain\Catalog\LicenceScope;
use App\Domain\Commerce\Checkout;
use App\Domain\Commerce\Money;
use App\Domain\Commerce\Order;
use App\Domain\Commerce\OrderLine;
use App\Domain\Commerce\Payment;
use App\Filament\Resources\Orders\OrderResource;
use App\Filament\Support\ReportsDomainRules;
use Filament\Actions\Action;
use Filament\Facades\Filament;
use Filament\Forms\Components\Textarea;
use Filament\Forms\Components\TextInput;
use Filament\Resources\Pages\ViewRecord;
use Filament\Schemas\Components\View;
use Filament\Schemas\Schema;
use Filament\Support\Enums\Width;
use Illuminate\Contracts\Support\Htmlable;
use Illuminate\Support\Carbon;
/**
* Bestellung im gemeinsamen Rahmen. Die gespeicherten Konditionen sind unveränderlich; der Betreiber bestätigt bei
* Kauf auf Rechnung den Zahlungseingang und erstattet bezahlte Bestellungen vollständig (Bundles als Einheit).
*/
class ViewOrder extends ViewRecord
{
use ReportsDomainRules;
protected static string $resource = OrderResource::class;
public function getTitle(): string|Htmlable
{
return 'Bestellung '.$this->order()->id;
}
public function getHeading(): string|Htmlable
{
return '';
}
public function getMaxContentWidth(): Width|string|null
{
return Width::Full;
}
protected function getHeaderActions(): array
{
return [];
}
/**
* @return array<string, string>
*/
public function getBreadcrumbs(): array
{
return [];
}
public function infolist(Schema $schema): Schema
{
return $schema->components([
View::make('filament.catalog.objekt')->viewData(fn (): array => $this->bestellDaten())->columnSpanFull(),
])->columns(1);
}
private function order(): Order
{
/** @var Order $order */
$order = $this->getRecord();
return $order;
}
public function confirmInvoiceAction(): Action
{
return Action::make('confirmInvoice')
->label('Zahlungseingang bestätigen')
->modalHeading(fn (): string => 'Zahlungseingang für Bestellung '.$this->order()->id.' bestätigen')
->modalDescription(fn (): string => 'Du bestätigst, dass '.Money::format($this->order()->payable()).' für die Rechnung eingegangen sind. Die Inhalte werden sofort für das bestellende Konto freigeschaltet; Lizenzinhaber bleibt '.($this->order()->party?->display_name ?? 'der Käufer').'. Die Bestätigung lässt sich nicht zurücknehmen, nur die Bestellung erstatten.')
->modalSubmitActionLabel('Zahlungseingang bestätigen')
->schema([
TextInput::make('reference')->label('Rechnungsnummer oder Buchungsreferenz')->required()->maxLength(120)
->helperText('Bleibt an der Zahlung gespeichert, zum Beispiel „RE-2026-014“.'),
])
->visible(fn (): bool => $this->order()->payment_method === 'rechnung' && $this->order()->status === 'offen')
->action(function (array $data): void {
$this->report(function () use ($data): string {
app(Checkout::class)->confirmInvoicePayment($this->order(), (string) $data['reference'], Filament::auth()->user());
return 'Der Zahlungseingang ist bestätigt. Die Inhalte sind freigeschaltet.';
}, 'Bestätigt.');
$this->order()->unsetRelations();
$this->order()->refresh();
});
}
public function refundAction(): Action
{
return Action::make('refund')
->label('Bestellung erstatten')
->color('danger')
->modalHeading(fn (): string => 'Bestellung '.$this->order()->id.' vollständig erstatten?')
->modalDescription(fn (): string => 'Alle Positionen dieser Bestellung werden zurückgegeben: Die Berechtigungen daraus werden widerrufen, andere Erwerbsquellen (kostenlose Vergabe, frühere Käufe) bleiben unberührt. Pakete sind eine Einheit; Teilerstattungen gibt es zum Start nicht. '.(
$this->order()->payments()->where('provider', 'stripe')->where('status', 'bestaetigt')->exists()
? 'Die Rückzahlung von '.Money::format($this->order()->payable()).' wird bei Stripe veranlasst; nur wenn Stripe sie annimmt, werden die Rechte entzogen.'
: 'Die Rückzahlung selbst veranlasst du außerhalb dieser Anwendung, zum Beispiel per Überweisung.'
))
->modalSubmitActionLabel('Vollständig erstatten')
->schema([
Textarea::make('reason')->label('Begründung')->required()->rows(2)->maxLength(500)
->helperText('Bleibt am Widerruf der Berechtigungen stehen, zum Beispiel „Widerruf geprüft, Frist gewahrt“.'),
])
->visible(fn (): bool => $this->order()->status === 'bezahlt')
->action(function (array $data): void {
$this->report(function () use ($data): string {
app(Checkout::class)->refund($this->order(), (string) $data['reason']);
return 'Die Bestellung ist erstattet. Die Berechtigungen sind widerrufen.';
}, 'Erstattet.');
$this->order()->unsetRelations();
$this->order()->refresh();
});
}
/**
* @return array<string, mixed>
*/
private function bestellDaten(): array
{
$order = $this->order();
$order->loadMissing(['lines', 'user', 'party', 'payments']);
$date = fn (?Carbon $value): string => $value === null ? '' : $value->timezone(config('app.timezone'))->format('d.m.Y H:i');
$method = match ($order->payment_method) {
'rechnung' => 'Überweisung auf Rechnung (manuell)',
'stripe' => 'Stripe',
default => 'Testzahlung',
};
return [
'kopf' => [
'brot' => [['label' => 'Bestellungen', 'href' => OrderResource::getUrl('index')], 'Bestellung '.$order->id],
'titel' => 'Bestellung '.$order->id,
'typ' => 'Lizenzinhaber: '.($order->party?->display_name ?? '–').' · bestellt von '.($order->user?->name ?? '–').' ('.($order->user?->email ?? '').')',
'status' => [
['text' => match ($order->status) {
'bezahlt' => 'Bezahlt ('.$method.')',
'erstattet' => 'Erstattet. Die Berechtigungen sind widerrufen.',
'fehlgeschlagen' => 'Zahlung fehlgeschlagen. Es wurde nichts freigeschaltet.',
default => $order->payment_method === 'rechnung' ? 'Offen: Rechnung erstellen und Zahlungseingang bestätigen.' : 'Offen: Zahlung steht aus.',
}, 'ton' => $order->status === 'bezahlt' ? 'gut' : 'offen'],
$order->withdrawal_requested_at !== null ? ['text' => 'Widerruf erklärt am '.$date($order->withdrawal_requested_at).'. Prüfen und gegebenenfalls erstatten.', 'ton' => 'offen'] : null,
],
'aktionen' => [
...($order->payment_method === 'rechnung' && $order->status === 'offen' ? [['label' => 'Zahlungseingang bestätigen', 'wire' => "mountAction('confirmInvoice')", 'art' => 'primary']] : []),
...($order->status === 'bezahlt' ? [['label' => 'Bestellung erstatten', 'wire' => "mountAction('refund')", 'art' => 'line']] : []),
],
],
'haupt' => [
[
'titel' => 'Positionen',
'hilfe' => 'Fassung, Preis, Rabatt, Nutzerkreis und Umfang sind beim Kauf festgehalten und ändern sich nicht.',
'zeilen' => $order->lines->map(fn (OrderLine $line): array => [
'text' => ($line->offer_name ?: 'Angebot').': '.Money::format((int) $line->price_cents).($line->discount_cents > 0 ? ' − Rabatt '.Money::format((int) $line->discount_cents).' = '.Money::format($line->payable()) : ''),
'neben' => LicenceScope::label($line->licence_scope, $line->trainer_count).' · Angebotsfassung '.($line->offerVersion?->number ?? '–'),
])->values()->all(),
'leer' => ['titel' => 'Keine Positionen', 'text' => 'Diese Bestellung hat keine Positionen.'],
],
[
'titel' => 'Beträge',
'zeilen' => [
['text' => 'Zwischensumme (Listenpreise): '.Money::format($order->subtotal()), 'neben' => null],
...($order->discount_cents > 0 ? [['text' => 'Rabatt: −'.Money::format((int) $order->discount_cents), 'neben' => 'Code '.($order->discount_snapshot['code'] ?? '').' · '.($order->discount_snapshot['label'] ?? '')]] : []),
['text' => 'Zahlbetrag: '.Money::format($order->payable()), 'neben' => 'Dieser Betrag ging an '.$method.'.'],
],
],
[
'titel' => 'Zahlungen',
'zeilen' => $order->payments->map(fn (Payment $payment): array => [
'text' => match ($payment->provider) {
'stripe' => 'Stripe', 'ueberweisung' => 'Überweisung', default => 'Testzahlung'
}.' · '.match ($payment->status) {
'bestaetigt' => 'bestätigt', 'erstattet' => 'erstattet', 'offen' => 'offen', 'abgelaufen' => 'abgelaufen', 'zu_pruefen' => 'zu prüfen', 'fehlgeschlagen' => 'fehlgeschlagen', default => $payment->status
},
'neben' => $payment->provider_reference.($payment->amount_cents !== null ? ' · '.Money::format((int) $payment->amount_cents) : ''),
])->values()->all(),
'leer' => ['titel' => 'Noch keine Zahlung', 'text' => 'Es gibt noch keinen Zahlungsvorgang zu dieser Bestellung.'],
],
],
'seite' => [
[
'titel' => 'Zustimmung',
'zeilen' => $order->terms_accepted_at === null ? [] : [
['text' => 'Zugestimmt am '.$date($order->terms_accepted_at), 'neben' => 'Fassung der Texte: '.($order->terms_snapshot['version'] ?? '–')],
...collect($order->terms_snapshot['consents'] ?? [])->map(fn (string $wording): array => ['text' => $wording, 'neben' => null])->values()->all(),
],
'leer' => 'Zu dieser Bestellung ist keine Zustimmung festgehalten (Bestellung vor dem Verkaufsstart oder über den Testweg).',
],
[
'titel' => 'Widerruf',
'zeilen' => $order->withdrawal_requested_at === null ? [] : [
['text' => 'Erklärt am '.$date($order->withdrawal_requested_at), 'neben' => filled($order->withdrawal_note) ? $order->withdrawal_note : null],
],
'leer' => 'Kein Widerruf erklärt.',
'hilfe' => 'Der Widerruf entzieht nichts. Du prüfst ihn (bei sofortiger Bereitstellung mit Zustimmung kann das Recht erloschen sein) und erstattest bei Bedarf über „Bestellung erstatten“.',
],
],
];
}
}
+126
View File
@@ -0,0 +1,126 @@
<?php
namespace App\Filament\Support;
use App\Domain\Catalog\Bundle;
use App\Domain\Catalog\Offer;
use App\Domain\Commerce\Discount\DiscountCode;
use Filament\Forms\Components\DatePicker;
use Filament\Forms\Components\Select;
use Filament\Forms\Components\Textarea;
use Filament\Forms\Components\TextInput;
use Filament\Forms\Components\Toggle;
use Filament\Schemas\Components\Utilities\Get;
/**
* Die eine Maske für Rabattcodes: Anlegen und Bearbeiten nutzen dieselben Felder (FACH-20). Geltungsbereich und
* Einlösungsberechtigung sind zwei voneinander unabhängige Einstellungen.
*/
final class DiscountCodeForm
{
/**
* @return list<mixed>
*/
public static function schema(): array
{
return [
TextInput::make('code')->label('Code')->required()->maxLength(40)
->helperText('So gibt ihn der Käufer ein, 3 bis 40 Zeichen: Buchstaben, Ziffern, Bindestrich. Groß- und Kleinschreibung spielen keine Rolle.'),
TextInput::make('label')->label('Name für die Verwaltung')->required()->maxLength(120)
->helperText('Nur intern, zum Beispiel „Zertifizierungscode 2026“. Der Käufer sieht ihn nicht.'),
Select::make('kind')->label('Art des Rabatts')->options([
DiscountCode::PERCENT => 'Prozent',
DiscountCode::AMOUNT => 'Fester Betrag in Euro',
])->required()->live(),
TextInput::make('percent')->label('Prozent')->numeric()->minValue(1)->maxValue(100)->integer()->suffix('%')
->required(fn (Get $get): bool => $get('kind') === DiscountCode::PERCENT)
->visible(fn (Get $get): bool => $get('kind') === DiscountCode::PERCENT)
->helperText('Je Position gerundet. Der Zahlbetrag der Bestellung darf 0,50 € nicht unterschreiten.'),
TextInput::make('amount_euro')->label('Rabattbetrag')->suffix('€')
->required(fn (Get $get): bool => $get('kind') === DiscountCode::AMOUNT)
->visible(fn (Get $get): bool => $get('kind') === DiscountCode::AMOUNT)
->helperText('Gilt je Bestellung und wird anteilig auf die betroffenen Positionen verteilt, zum Beispiel 5,00.'),
Select::make('scope')->label('Geltungsbereich')->options([
DiscountCode::SCOPE_CART => 'Gesamter Warenkorb',
DiscountCode::SCOPE_SELECTED => 'Nur ausdrücklich ausgewählte Angebote, Lizenzartikel oder Pakete',
])->required()->live()
->helperText('Wofür der Rabatt gilt. Unabhängig davon legst du unten fest, wer den Code einlösen darf.'),
Select::make('offer_ids')->label('Angebote')->multiple()->searchable()
->options(fn (): array => Offer::query()->orderBy('name')->pluck('name', 'id')->all())
->visible(fn (Get $get): bool => $get('scope') === DiscountCode::SCOPE_SELECTED)
->helperText('Die gewählte Lizenzoption selbst (Fassung egal).'),
Select::make('article_ids')->label('Lizenzartikel')->multiple()->searchable()
->options(fn (): array => app(PublicationReadiness::class)->articleOptions())
->visible(fn (Get $get): bool => $get('scope') === DiscountCode::SCOPE_SELECTED)
->helperText('Gilt für Angebote, die diesen Artikel unmittelbar als Position führen. Ein Artikel in einem Paket macht das Paket nicht rabattfähig.'),
Select::make('bundle_ids')->label('Pakete')->multiple()->searchable()
->options(fn (): array => Bundle::query()->orderBy('name')->pluck('name', 'id')->all())
->visible(fn (Get $get): bool => $get('scope') === DiscountCode::SCOPE_SELECTED)
->helperText('Ein Paket wird gezielt gewählt. Es folgt nicht aus einem enthaltenen Artikel.'),
Select::make('eligibility')->label('Wer darf den Code einlösen?')->options([
DiscountCode::OPEN => 'Alle angemeldeten Käufer (allgemein einlösbar)',
DiscountCode::RESTRICTED => 'Nur ausdrücklich freigeschaltete Konten',
])->required()
->helperText('Bei „freigeschaltete Konten“ schaltest du einzelne Konten auf der Seite des Codes frei und entziehst die Freigabe wieder. Eine Freigabe gilt nur für diesen Code.'),
DatePicker::make('valid_from')->label('Gültig ab')->native(false)->displayFormat('d.m.Y')
->helperText('Leer: sofort.'),
DatePicker::make('valid_until')->label('Gültig bis einschließlich')->native(false)->displayFormat('d.m.Y')
->helperText('Leer: unbegrenzt. Am Tag danach gilt der Code nicht mehr.'),
Toggle::make('active')->label('Aktiv')->default(true)
->helperText('Deaktivierte Codes lassen sich nicht einlösen; bereits aufgegebene Bestellungen bleiben unverändert.'),
Textarea::make('note')->label('Notiz')->rows(2)->maxLength(500)
->helperText('Zum Beispiel, woran die Berechtigung geprüft wird.'),
];
}
/**
* Formularwerte → Angaben und Ziele des Dienstes.
*
* @param array<string, mixed> $data
* @return array{0: array<string, mixed>, 1: list<array{type: string, id: int}>}
*/
public static function fromForm(array $data): array
{
$targets = [];
foreach ([
DiscountCode::TARGET_OFFER => 'offer_ids',
DiscountCode::TARGET_ARTICLE => 'article_ids',
DiscountCode::TARGET_BUNDLE => 'bundle_ids',
] as $type => $key) {
foreach ((array) ($data[$key] ?? []) as $id) {
$targets[] = ['type' => $type, 'id' => (int) $id];
}
}
return [$data, $targets];
}
/**
* Vorbelegung der Maske aus einem vorhandenen Code.
*
* @return array<string, mixed>
*/
public static function fill(DiscountCode $code): array
{
$code->loadMissing('targets');
$ids = fn (string $type): array => $code->targets->where('target_type', $type)->pluck('target_id')->map(fn ($id): int => (int) $id)->values()->all();
return [
'code' => $code->code,
'label' => $code->label,
'kind' => $code->kind,
'percent' => $code->percent,
'amount_euro' => $code->amount_cents === null ? null : number_format($code->amount_cents / 100, 2, ',', ''),
'scope' => $code->scope,
'offer_ids' => $ids(DiscountCode::TARGET_OFFER),
'article_ids' => $ids(DiscountCode::TARGET_ARTICLE),
'bundle_ids' => $ids(DiscountCode::TARGET_BUNDLE),
'eligibility' => $code->eligibility,
'valid_from' => $code->valid_from?->timezone(config('app.timezone'))->toDateString(),
'valid_until' => $code->valid_until?->timezone(config('app.timezone'))->toDateString(),
'active' => $code->active,
'note' => $code->note,
];
}
}
+24 -7
View File
@@ -8,6 +8,7 @@
use App\Domain\Catalog\BundleStatus; use App\Domain\Catalog\BundleStatus;
use App\Domain\Catalog\BundleVersion; use App\Domain\Catalog\BundleVersion;
use App\Domain\Catalog\DomainRuleException; use App\Domain\Catalog\DomainRuleException;
use App\Domain\Catalog\LicenceScope;
use App\Domain\Catalog\LicenseArticle; use App\Domain\Catalog\LicenseArticle;
use App\Domain\Catalog\Offer; use App\Domain\Catalog\Offer;
use App\Domain\Catalog\OfferService; use App\Domain\Catalog\OfferService;
@@ -227,7 +228,8 @@ public function forOffer(Offer $offer): array
$missing = $this->unusableArticles($articleIds); $missing = $this->unusableArticles($articleIds);
$buyable = $hasActive && $this->offers->purchasableVersion($offer) !== null; $buyable = $hasActive && $this->offers->purchasableVersion($offer) !== null;
$page = $offer->composition; $page = $offer->composition;
$shown = $page !== null && $this->catalog->shownVersion($page) !== null; $own = (bool) $offer->standalone_bundle;
$shown = $own || ($page !== null && $this->catalog->shownVersion($page) !== null);
$pageName = $page !== null ? (string) ($page->display_title ?: $page->designation) : ''; $pageName = $page !== null ? (string) ($page->display_title ?: $page->designation) : '';
$activate = ['label' => $hasActive ? 'Geänderte Fassung aktivieren' : 'Angebot konfigurieren', 'wire' => "mountAction('activate')"]; $activate = ['label' => $hasActive ? 'Geänderte Fassung aktivieren' : 'Angebot konfigurieren', 'wire' => "mountAction('activate')"];
@@ -258,21 +260,36 @@ public function forOffer(Offer $offer): array
'stand' => $buyable ? 'erledigt' : 'offen', 'stand' => $buyable ? 'erledigt' : 'offen',
'aktion' => $buyable ? null : ($hasActive ? $activate : null), 'aktion' => $buyable ? null : ($hasActive ? $activate : null),
], ],
[
'titel' => 'Nutzerkreis festlegen',
'text' => ! $hasActive
? 'Wird mit der Fassung festgelegt: Einzellizenz (ein Trainer) oder Mehrfachlizenz (Zahl der Trainer).'
: ($active->licence_scope !== null
? LicenceScope::label($active->licence_scope, $active->trainer_count).'. Der Käufer sieht das auf der Produktseite und in der Bestellung.'
: 'Diese Fassung hat keinen festgelegten Nutzerkreis. Käufer sehen „Nutzerkreis nicht festgelegt“. Lege ihn mit „Geänderte Fassung aktivieren“ fest.'),
'stand' => $hasActive && $active->licence_scope !== null ? 'erledigt' : 'offen',
'aktion' => $hasActive && $active->licence_scope === null ? $activate : null,
'pflicht' => false,
],
[ [
'titel' => 'Produktseite zuordnen', 'titel' => 'Produktseite zuordnen',
'text' => $page !== null 'text' => $own
? 'Eigene Paketseite: Sie zeigt den Umfang des Pakets. Optionen desselben Pakets sind Alternativen im Warenkorb.'
: ($page !== null
? 'Zugeordnet: „'.$pageName.'“. Optionen derselben Produktseite sind Alternativen im Warenkorb.' ? 'Zugeordnet: „'.$pageName.'“. Optionen derselben Produktseite sind Alternativen im Warenkorb.'
: 'Der Shop zeigt ein Angebot auf der Seite eines Programms. Wähle in der Maske die Produktseite. Ein Paket braucht eine eigene Produktseite, sonst ist es Alternative zu den Einzelangeboten dieser Seite.', : 'Der Shop zeigt ein Angebot auf der Seite eines Programms. Wähle in der Maske die Produktseite. Ein Paket, das für sich verkauft wird, erhält dort „Eigene Paketseite“ und zeigt seinen Umfang; sonst erscheint es auf der Seite eines fremden Programms.'),
'stand' => $page !== null ? 'erledigt' : 'offen', 'stand' => $own || $page !== null ? 'erledigt' : 'offen',
'aktion' => $page !== null ? null : $activate, 'aktion' => $own || $page !== null ? null : $activate,
], ],
[ [
'titel' => 'Produktseite öffentlich', 'titel' => 'Produktseite öffentlich',
'text' => $page === null 'text' => ! $own && $page === null
? 'Wird geprüft, sobald eine Produktseite zugeordnet ist.' ? 'Wird geprüft, sobald eine Produktseite zugeordnet ist.'
: ($own
? 'Die eigene Paketseite ist öffentlich, sobald die aktive Fassung ein Kauf mit Preis ist.'
: ($shown : ($shown
? 'Das Programm ist zur Anzeige freigegeben. Das Angebot erscheint in der Shop-Suche und auf der Produktseite.' ? 'Das Programm ist zur Anzeige freigegeben. Das Angebot erscheint in der Shop-Suche und auf der Produktseite.'
: 'Das Programm „'.$pageName.'“ ist nicht zur Anzeige freigegeben oder kein Programm. Das Angebot ist dort nicht auffindbar.'), : 'Das Programm „'.$pageName.'“ ist nicht zur Anzeige freigegeben oder kein Programm. Das Angebot ist dort nicht auffindbar.')),
'stand' => $shown ? 'erledigt' : 'offen', 'stand' => $shown ? 'erledigt' : 'offen',
'aktion' => $page === null || $shown ? null : ['label' => 'Programm öffnen', 'href' => EditorialCatalog::editUrl($page)], 'aktion' => $page === null || $shown ? null : ['label' => 'Programm öffnen', 'href' => EditorialCatalog::editUrl($page)],
], ],
+22
View File
@@ -0,0 +1,22 @@
<?php
namespace App\Filament\Support;
use App\Domain\Identity\StaffRole;
use App\Models\User;
use Filament\Facades\Filament;
/**
* Wer Rabattcodes, Freigaben und Bestellungen verwalten darf: Katalogverwalter und Kundenbetreuung. Die
* Berechtigung zum Verkaufen und Erstatten ist eine Betreiberaufgabe, nicht die der Redaktion.
*/
final class ShopAccess
{
public static function allowed(): bool
{
$user = Filament::auth()->user();
return $user instanceof User
&& ($user->hasStaffRole(StaffRole::Katalogverwalter) || $user->hasStaffRole(StaffRole::Kundenbetreuung));
}
}
+6 -6
View File
@@ -7,6 +7,7 @@
use App\Domain\Commerce\Cart; use App\Domain\Commerce\Cart;
use App\Domain\Commerce\Money; use App\Domain\Commerce\Money;
use App\Domain\Commerce\OrderHolders; use App\Domain\Commerce\OrderHolders;
use App\Domain\Commerce\ProductOptions;
use Illuminate\Http\RedirectResponse; use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request; use Illuminate\Http\Request;
use Illuminate\View\View; use Illuminate\View\View;
@@ -31,9 +32,8 @@ public function show(Request $request, Cart $cart, OrderHolders $holders): View
public function add(Offer $offer, Cart $cart, PublicCatalogReader $catalog): RedirectResponse public function add(Offer $offer, Cart $cart, PublicCatalogReader $catalog): RedirectResponse
{ {
$page = $offer->composition; $page = $offer->composition;
$result = $page !== null && $catalog->shownVersion($page) !== null $listed = $offer->standalone_bundle || ($page !== null && $catalog->shownVersion($page) !== null);
? $cart->add($offer) $result = $listed ? $cart->add($offer) : Cart::UNAVAILABLE;
: Cart::UNAVAILABLE;
$back = $this->productPage($offer); $back = $this->productPage($offer);
return match ($result) { return match ($result) {
@@ -81,8 +81,8 @@ public function accept(Offer $offer, Cart $cart): RedirectResponse
private function productPage(Offer $offer): RedirectResponse private function productPage(Offer $offer): RedirectResponse
{ {
return $offer->composition_id !== null $url = app(ProductOptions::class)->pageUrl($offer);
? redirect()->route('public.program', $offer->composition_id)
: redirect()->route('cart'); return $url !== null ? redirect()->to($url) : redirect()->route('cart');
} }
} }
@@ -9,10 +9,12 @@
use App\Domain\Commerce\Checkout; use App\Domain\Commerce\Checkout;
use App\Domain\Commerce\Order; use App\Domain\Commerce\Order;
use App\Domain\Commerce\OrderHolders; use App\Domain\Commerce\OrderHolders;
use App\Domain\Commerce\SalesTerms;
use App\Domain\Commerce\Shop; use App\Domain\Commerce\Shop;
use App\Domain\Commerce\StaleOverview; use App\Domain\Commerce\StaleOverview;
use App\Domain\Commerce\Stripe\StripeGateway; use App\Domain\Commerce\Stripe\StripeGateway;
use App\Domain\Entitlement\GrantIssuer; use App\Domain\Entitlement\GrantIssuer;
use App\Domain\Identity\PartyType;
use App\Http\Controllers\Controller; use App\Http\Controllers\Controller;
use Illuminate\Http\RedirectResponse; use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request; use Illuminate\Http\Request;
@@ -67,9 +69,38 @@ public function checkout(Request $request, Cart $cart, OrderHolders $holders): V
return view('shop.checkout', [ return view('shop.checkout', [
'review' => $review, 'review' => $review,
'holders' => $holders->for($request->user()), 'holders' => $holders->for($request->user()),
'consents' => SalesTerms::consents(),
'legalPages' => SalesTerms::pages(),
'invoice' => Shop::invoice() && $review->holder?->type === PartyType::Organisation,
]); ]);
} }
/**
* Rabattcode einlösen. Höchstens ein Code je Bestellung; ein zweiter ersetzt den ersten. Gilt der Code nicht,
* bleibt der bisherige Stand und die Meldung nennt den Grund.
*/
public function applyCode(Request $request, Cart $cart): RedirectResponse
{
$data = $request->validate(['code' => ['required', 'string', 'max:60'], 'bestellen_als' => ['nullable', 'integer']], [
'code.required' => 'Gib einen Rabattcode ein.',
]);
$holderId = isset($data['bestellen_als']) ? (int) $data['bestellen_als'] : null;
$result = $cart->applyCode($data['code'], $request->user(), $holderId);
$back = redirect()->route('checkout', array_filter(['bestellen_als' => $holderId]));
return $result->applied()
? $back->with('status', 'Der Rabattcode '.$result->code->code.' ist angewendet.')
: $back->withErrors(['code' => $result->message ?? 'Der Code kann nicht angewendet werden.']);
}
public function removeCode(Request $request, Cart $cart): RedirectResponse
{
$cart->removeCode();
$holderId = $request->integer('bestellen_als') ?: null;
return redirect()->route('checkout', array_filter(['bestellen_als' => $holderId]))->with('status', 'Der Rabattcode ist entfernt.');
}
/** /**
* Legt die Bestellung an, aber nur, wenn die serverseitige Prüfung zur gezeigten Übersicht passt. * Legt die Bestellung an, aber nur, wenn die serverseitige Prüfung zur gezeigten Übersicht passt.
*/ */
@@ -78,19 +109,28 @@ public function placeOrder(Request $request, Cart $cart, Checkout $checkout): Re
$data = $request->validate([ $data = $request->validate([
'digest' => ['required', 'string'], 'digest' => ['required', 'string'],
'bestellen_als' => ['nullable', 'integer'], 'bestellen_als' => ['nullable', 'integer'],
'zahlungsweg' => ['nullable', 'in:online,rechnung'],
'zustimmung' => ['nullable', 'array'],
]); ]);
$holderId = isset($data['bestellen_als']) ? (int) $data['bestellen_als'] : null; $holderId = isset($data['bestellen_als']) ? (int) $data['bestellen_als'] : null;
$back = redirect()->route('checkout', array_filter(['bestellen_als' => $holderId])); $back = redirect()->route('checkout', array_filter(['bestellen_als' => $holderId]));
$method = ($data['zahlungsweg'] ?? 'online') === 'rechnung' ? 'rechnung' : null;
try { try {
$order = $checkout->placeFromCart($request->user(), $cart, $holderId, $data['digest']); // Die Zustimmungen sind eine Pflichtangabe und werden serverseitig geprüft, nicht nur im Formular.
SalesTerms::proof((array) ($data['zustimmung'] ?? []));
$order = $checkout->placeFromCart($request->user(), $cart, $holderId, $data['digest'], (array) ($data['zustimmung'] ?? []), $method);
} catch (StaleOverview $exception) { } catch (StaleOverview $exception) {
return $back->withErrors(['checkout' => $exception->getMessage()]); return $back->withErrors(['checkout' => $exception->getMessage()]);
} catch (DomainRuleException $exception) { } catch (DomainRuleException $exception) {
return $back->withErrors(['checkout' => $exception->getMessage()]); return $back->withErrors(['checkout' => $exception->getMessage()]);
} }
return redirect()->route('member.order', $order)->with('status', 'Die Bestellung ist angelegt. Bestätige jetzt die Testzahlung.'); return redirect()->route('member.order', $order)->with('status', match (true) {
$order->payment_method === 'rechnung' => 'Deine Bestellung auf Rechnung ist eingegangen. Wir senden dir die Rechnung. Die Inhalte sind nach Zahlungseingang in der Bibliothek.',
Shop::stripe() => 'Die Bestellung ist angelegt. Bezahle jetzt sicher bei Stripe.',
default => 'Die Bestellung ist angelegt. Bestätige jetzt die Testzahlung.',
});
} }
public function show(Request $request, Order $order): View public function show(Request $request, Order $order): View
@@ -103,9 +143,25 @@ public function show(Request $request, Order $order): View
'testPayment' => ! app()->isProduction() && config('services.payment.driver') === 'test', 'testPayment' => ! app()->isProduction() && config('services.payment.driver') === 'test',
'stripePayment' => Shop::stripe(), 'stripePayment' => Shop::stripe(),
'zahlung' => $request->query('zahlung'), 'zahlung' => $request->query('zahlung'),
'live' => Shop::live(),
]); ]);
} }
/** Erklärt den Widerruf; der Betreiber prüft und erstattet gegebenenfalls in der Bestellverwaltung. */
public function withdraw(Request $request, Order $order, Checkout $checkout): RedirectResponse
{
abort_unless($order->user_id === $request->user()->id, 403);
$data = $request->validate(['note' => ['nullable', 'string', 'max:1000']]);
try {
$checkout->requestWithdrawal($order, (string) ($data['note'] ?? ''));
} catch (DomainRuleException $exception) {
return back()->withErrors(['payment' => $exception->getMessage()]);
}
return redirect()->route('member.order', $order)->with('status', 'Dein Widerruf ist eingegangen. Wir prüfen ihn und melden uns per E-Mail.');
}
/** Leitet zur Stripe-Kasse (Testmodus). Freigeschaltet wird erst durch die signierte Meldung von Stripe. */ /** Leitet zur Stripe-Kasse (Testmodus). Freigeschaltet wird erst durch die signierte Meldung von Stripe. */
public function pay(Request $request, Order $order, StripeGateway $stripe): RedirectResponse public function pay(Request $request, Order $order, StripeGateway $stripe): RedirectResponse
{ {
@@ -150,6 +206,8 @@ public function fail(Request $request, Order $order, Checkout $checkout): Redire
public function refund(Request $request, Order $order, Checkout $checkout): RedirectResponse public function refund(Request $request, Order $order, Checkout $checkout): RedirectResponse
{ {
abort_unless($order->user_id === $request->user()->id, 403); abort_unless($order->user_id === $request->user()->id, 403);
// Nur der Testzahlungsweg erstattet auf Knopfdruck. Echte Zahlungen erstattet der Betreiber nach Prüfung.
abort_unless(! app()->isProduction() && Shop::driver() === 'test', 404);
try { try {
$checkout->refund($order, 'Widerruf durch das Mitglied im Testmodus'); $checkout->refund($order, 'Widerruf durch das Mitglied im Testmodus');
@@ -2,6 +2,7 @@
namespace App\Http\Controllers; namespace App\Http\Controllers;
use App\Domain\Catalog\Bundle;
use App\Domain\Catalog\Composition; use App\Domain\Catalog\Composition;
use App\Domain\Catalog\CompositionStructureReader; use App\Domain\Catalog\CompositionStructureReader;
use App\Domain\Cms\Catalog\PublicCatalogReader; use App\Domain\Cms\Catalog\PublicCatalogReader;
@@ -17,6 +18,25 @@ public function index(PublicCatalogReader $catalog): View
return view('public.programs', ['programs' => $catalog->publicPrograms()]); return view('public.programs', ['programs' => $catalog->publicPrograms()]);
} }
/**
* Eigene Produktseite eines Pakets, das für sich vermarktet wird: Sie zeigt den tatsächlichen Umfang des Pakets
* (die enthaltenen Artikel) und darunter die kaufbaren Lizenzoptionen. Ohne kaufbare Option gibt es sie nicht.
*/
public function package(Bundle $bundle, ProductOptions $products, Cart $cart): View
{
abort_unless(Shop::enabled(), 404);
$options = $products->forBundle($bundle);
abort_if($options === [], 404);
return view('public.package', [
'bundle' => $bundle,
'contents' => $products->bundleContents($options),
'options' => $options,
'cart' => $cart,
'switchTo' => session('shop.switch'),
]);
}
public function program(Composition $composition, PublicCatalogReader $catalog, ProductOptions $products, Cart $cart): View public function program(Composition $composition, PublicCatalogReader $catalog, ProductOptions $products, Cart $cart): View
{ {
$version = $catalog->shownVersion($composition); $version = $catalog->shownVersion($composition);
+22 -1
View File
@@ -2,6 +2,7 @@
namespace App\Http\Controllers; namespace App\Http\Controllers;
use App\Domain\Catalog\Bundle;
use App\Domain\Catalog\Composition; use App\Domain\Catalog\Composition;
use App\Domain\Cms\Catalog\PublicCatalogReader; use App\Domain\Cms\Catalog\PublicCatalogReader;
use App\Domain\Commerce\Money; use App\Domain\Commerce\Money;
@@ -37,7 +38,7 @@ public function index(Request $request, ProductOptions $products, PublicCatalogR
$summary = $summaries[$composition->id]; $summary = $summaries[$composition->id];
$cards[] = [ $cards[] = [
'composition' => $composition, 'url' => route('public.program', $composition),
'title' => $title, 'title' => $title,
'teaser' => (string) ($composition->teaser ?: $composition->summary), 'teaser' => (string) ($composition->teaser ?: $composition->summary),
'from' => Money::format($summary['from_cents']), 'from' => Money::format($summary['from_cents']),
@@ -45,6 +46,26 @@ public function index(Request $request, ProductOptions $products, PublicCatalogR
]; ];
} }
// Pakete mit eigener Produktseite: gelistet mit Name und enthaltenen Artikeln.
foreach (Bundle::query()->whereIn('id', array_keys($products->bundleSummaries()))->orderBy('name')->get() as $bundle) {
$options = $products->forBundle($bundle);
$contents = $products->bundleContents($options);
$names = implode(', ', array_column($contents, 'title'));
if ($term !== '' && ! str_contains(mb_strtolower($bundle->name.' '.$names), mb_strtolower($term))) {
continue;
}
$summary = $products->bundleSummaries()[$bundle->id];
$cards[] = [
'url' => route('public.package', $bundle),
'title' => (string) $bundle->name,
'teaser' => 'Paket mit '.count($contents).' '.(count($contents) === 1 ? 'Inhalt' : 'Inhalten').($names !== '' ? ': '.$names : ''),
'from' => Money::format($summary['from_cents']),
'count' => $summary['count'],
];
}
return view('shop.index', ['cards' => $cards, 'term' => $term]); return view('shop.index', ['cards' => $cards, 'term' => $term]);
} }
} }
@@ -83,6 +83,10 @@ private function paid(array $session, Checkout $checkout): JsonResponse
return response()->json(['received' => true, 'handled' => false]); return response()->json(['received' => true, 'handled' => false]);
} }
if (filled($session['payment_intent'] ?? null)) {
$order->payments()->where('provider_reference', $reference)->update(['provider_payment_ref' => (string) $session['payment_intent']]);
}
return response()->json(['received' => true, 'handled' => true]); return response()->json(['received' => true, 'handled' => true]);
} }
+2
View File
@@ -158,6 +158,8 @@ private function entry(User $user, Grant $grant): array
? 'Spätere freigegebene Fassungen sind eingeschlossen.' ? 'Spätere freigegebene Fassungen sind eingeschlossen.'
: null, : null,
'source' => $this->source($user, $grant), 'source' => $this->source($user, $grant),
'licence_scope' => $conditions['licence_scope'] ?? null,
'trainer_count' => isset($conditions['trainer_count']) ? (int) $conditions['trainer_count'] : null,
'holder_kind' => $holderKind, 'holder_kind' => $holderKind,
'holder' => $holderKind === 'organisation' ? (string) ($grant->acquisition?->party?->display_name ?? 'Organisation') : 'Persönlich', 'holder' => $holderKind === 'organisation' ? (string) ($grant->acquisition?->party?->display_name ?? 'Organisation') : 'Persönlich',
'url' => route('member.grant', $grant), 'url' => route('member.grant', $grant),
+32
View File
@@ -0,0 +1,32 @@
<?php
return [
/*
|--------------------------------------------------------------------------
| Produktivfreigabe des Shops (Verkaufsstart Deutschland)
|--------------------------------------------------------------------------
|
| Ohne diese Freigabe bleibt der Shop in Produktion abgeschaltet, und Stripe nimmt dort keine Zahlung an. Die
| Freigabe ist eine Entscheidung von Lars; sie wird ausschließlich in /etc/luf/prod.env gesetzt (SHOP_LIVE_RELEASE=true),
| nie im Repository. Zusätzlich verlangt Shop::live() einen Live-Schlüssel (sk_live_), den Zahlungstreiber „stripe“
| und veröffentlichte Rechtstexte (SalesTerms::missingPages()).
|
*/
'live_release' => (bool) env('SHOP_LIVE_RELEASE', false),
/*
| Kauf auf Rechnung für Vereine und Organisationen (PAY-006): auf Anfrage, Rechnung manuell durch den Betreiber.
*/
'invoice' => (bool) env('SHOP_INVOICE', true),
/*
| Preis- und Steuerhinweis im Warenkorb und in der Bestellübersicht. Der Wortlaut hängt an der Steuerentscheidung
| (OPEN-06) und wird erst mit ihr festgelegt (Umgebungsvariable SHOP_PRICE_NOTE).
*/
'price_note' => env('SHOP_PRICE_NOTE', 'Alle Preise in Euro.'),
];
+7
View File
@@ -70,6 +70,13 @@ public function katalogverwalter(): static
}); });
} }
public function kundenbetreuung(): static
{
return $this->afterCreating(function (User $user): void {
$user->staffRoles()->create(['role' => StaffRole::Kundenbetreuung]);
});
}
public function redakteur(): static public function redakteur(): static
{ {
return $this->afterCreating(function (User $user): void { return $this->afterCreating(function (User $user): void {
@@ -0,0 +1,123 @@
<?php
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
/**
* Verkaufsstart Deutschland (A1): nur ergänzend, nichts wird gelöscht oder umbenannt; ein Rollback des Codes lässt
* die neuen Spalten und Tabellen liegen (der frühere Code kennt sie nicht).
*
* - Rabattcodes mit Geltungsbereich (Warenkorb oder ausgewählte Ziele) und Einlösungsberechtigung (allgemein oder
* nur für freigeschaltete Konten). Freigaben werden nie gelöscht, nur entzogen.
* - Nutzerkreis der Lizenzoption (Einzel- oder Mehrfachlizenz, Zahl der Trainer) an der Angebotsfassung, kopiert in
* die Bestellposition. Lizenzinhaber, berechtigte Trainer und Downloadzugriff sind getrennte Angaben.
* - Rabatt, Zahlbetrag, Zahlungsweg und Zustimmungsnachweis an der Bestellung.
* - Ein eigenständig vermarktetes Paket hat eine eigene Produktseite (offers.standalone_bundle), die seinen Umfang zeigt.
*/
return new class extends Migration
{
public function up(): void
{
Schema::create('discount_codes', function (Blueprint $table) {
$table->id();
$table->string('code')->unique();
$table->string('label');
$table->string('kind', 12);
$table->unsignedTinyInteger('percent')->nullable();
$table->unsignedInteger('amount_cents')->nullable();
$table->string('scope', 12)->default('warenkorb');
$table->string('eligibility', 12)->default('allgemein');
$table->timestamp('valid_from')->nullable();
$table->timestamp('valid_until')->nullable();
$table->boolean('active')->default(true);
$table->text('note')->nullable();
$table->timestamps();
});
Schema::create('discount_code_targets', function (Blueprint $table) {
$table->id();
$table->foreignId('discount_code_id')->constrained('discount_codes')->cascadeOnDelete();
$table->string('target_type', 16);
$table->unsignedBigInteger('target_id');
$table->timestamps();
$table->unique(['discount_code_id', 'target_type', 'target_id']);
});
Schema::create('discount_code_releases', function (Blueprint $table) {
$table->id();
$table->foreignId('discount_code_id')->constrained('discount_codes')->cascadeOnDelete();
$table->foreignId('user_id')->constrained('users')->cascadeOnDelete();
$table->foreignId('granted_by')->nullable()->constrained('users')->nullOnDelete();
$table->timestamp('granted_at');
$table->timestamp('valid_until')->nullable();
$table->foreignId('revoked_by')->nullable()->constrained('users')->nullOnDelete();
$table->timestamp('revoked_at')->nullable();
$table->text('reason')->nullable();
$table->timestamps();
$table->index(['discount_code_id', 'user_id']);
});
Schema::table('offers', function (Blueprint $table) {
$table->boolean('standalone_bundle')->default(false);
});
Schema::table('offer_versions', function (Blueprint $table) {
$table->string('licence_scope', 12)->nullable();
$table->unsignedSmallInteger('trainer_count')->nullable();
});
Schema::table('order_lines', function (Blueprint $table) {
$table->string('licence_scope', 12)->nullable();
$table->unsignedSmallInteger('trainer_count')->nullable();
$table->unsignedInteger('discount_cents')->default(0);
});
Schema::table('orders', function (Blueprint $table) {
$table->unsignedInteger('subtotal_cents')->nullable();
$table->unsignedInteger('discount_cents')->default(0);
$table->foreignId('discount_code_id')->nullable()->constrained('discount_codes')->nullOnDelete();
$table->json('discount_snapshot')->nullable();
$table->string('payment_method', 16)->nullable();
$table->timestamp('terms_accepted_at')->nullable();
$table->json('terms_snapshot')->nullable();
$table->timestamp('withdrawal_requested_at')->nullable();
$table->text('withdrawal_note')->nullable();
});
Schema::table('payments', function (Blueprint $table) {
$table->string('provider_payment_ref')->nullable();
$table->unsignedInteger('amount_cents')->nullable();
$table->foreignId('confirmed_by')->nullable()->constrained('users')->nullOnDelete();
});
}
public function down(): void
{
Schema::table('payments', function (Blueprint $table) {
$table->dropConstrainedForeignId('confirmed_by');
$table->dropColumn(['provider_payment_ref', 'amount_cents']);
});
Schema::table('orders', function (Blueprint $table) {
$table->dropConstrainedForeignId('discount_code_id');
$table->dropColumn([
'subtotal_cents', 'discount_cents', 'discount_snapshot', 'payment_method',
'terms_accepted_at', 'terms_snapshot', 'withdrawal_requested_at', 'withdrawal_note',
]);
});
Schema::table('order_lines', function (Blueprint $table) {
$table->dropColumn(['licence_scope', 'trainer_count', 'discount_cents']);
});
Schema::table('offer_versions', function (Blueprint $table) {
$table->dropColumn(['licence_scope', 'trainer_count']);
});
Schema::table('offers', function (Blueprint $table) {
$table->dropColumn('standalone_bundle');
});
Schema::dropIfExists('discount_code_releases');
Schema::dropIfExists('discount_code_targets');
Schema::dropIfExists('discount_codes');
}
};
+8 -5
View File
@@ -8,6 +8,7 @@
use App\Domain\Catalog\CompositionVersion; use App\Domain\Catalog\CompositionVersion;
use App\Domain\Catalog\ContentService; use App\Domain\Catalog\ContentService;
use App\Domain\Catalog\EditorialContentKind; use App\Domain\Catalog\EditorialContentKind;
use App\Domain\Catalog\LicenceScope;
use App\Domain\Catalog\LicenseArticle; use App\Domain\Catalog\LicenseArticle;
use App\Domain\Catalog\Offer; use App\Domain\Catalog\Offer;
use App\Domain\Catalog\OfferService; use App\Domain\Catalog\OfferService;
@@ -78,14 +79,14 @@ public function run(): void
'pdf' => ['ansehen', 'laden'], 'pdf' => ['ansehen', 'laden'],
]); ]);
$this->offer($offers, 'Konflikte im Training: Privatlizenz', 'Privatlizenz', $konflikteVersion, [$konflikteArticle, $privat], 4900, 'person'); $this->offer($offers, 'Konflikte im Training: Privatlizenz', 'Privatlizenz', $konflikteVersion, [$konflikteArticle, $privat], 4900, 'person', LicenceScope::SINGLE, 1);
$this->offer($offers, 'Konflikte im Training: Vereinslizenz', 'Mehrfachlizenz für Vereine', $konflikteVersion, [$konflikteArticle, $verein], 14900, 'organisation'); $this->offer($offers, 'Konflikte im Training: Vereinslizenz', 'Mehrfachlizenz für Vereine', $konflikteVersion, [$konflikteArticle, $verein], 14900, 'organisation', LicenceScope::MULTI, 5);
$this->offer($offers, 'Grenzen setzen: Privatlizenz', 'Privatlizenz', $grenzenVersion, [$grenzenArticle, $privat], 2900, 'person'); $this->offer($offers, 'Grenzen setzen: Privatlizenz', 'Privatlizenz', $grenzenVersion, [$grenzenArticle, $privat], 2900, 'person', LicenceScope::SINGLE, 1);
$bundle = $bundles->create('Starterpaket'); $bundle = $bundles->create('Starterpaket');
$starter = $bundles->publish($bundle, [$konflikteArticle->fresh(), $grenzenArticle->fresh(), $starterArticle->fresh()]); $starter = $bundles->publish($bundle, [$konflikteArticle->fresh(), $grenzenArticle->fresh(), $starterArticle->fresh()]);
$paket = $offers->create('Starterpaket: Privatlizenz'); $paket = $offers->create('Starterpaket: Privatlizenz');
$offers->activate($paket, [['target' => $starter, 'rights' => $privat]], ['grant_kind' => 'kauf', 'price_cents' => 5900, 'holder_kind' => 'person']); $offers->activate($paket, [['target' => $starter, 'rights' => $privat]], ['grant_kind' => 'kauf', 'price_cents' => 5900, 'holder_kind' => 'person', 'licence_scope' => LicenceScope::SINGLE, 'trainer_count' => 1]);
$offers->assignProduct($paket, $starterVersion->composition_id, 'Starterpaket (zwei Programme und Einführung)'); $offers->assignProduct($paket, $starterVersion->composition_id, 'Starterpaket (zwei Programme und Einführung)');
$tina = $this->account('Tina Trainerin', 'tina.trainerin@example.test'); $tina = $this->account('Tina Trainerin', 'tina.trainerin@example.test');
@@ -160,13 +161,15 @@ private function program(
/** /**
* @param array{0: LicenseArticle, 1: RightsProfileVersion} $line * @param array{0: LicenseArticle, 1: RightsProfileVersion} $line
*/ */
private function offer(OfferService $offers, string $name, string $label, CompositionVersion $version, array $line, int $cents, string $holder): Offer private function offer(OfferService $offers, string $name, string $label, CompositionVersion $version, array $line, int $cents, string $holder, ?string $scope = null, ?int $trainers = null): Offer
{ {
$offer = $offers->create($name); $offer = $offers->create($name);
$offers->activate($offer, [['target' => $line[0], 'rights' => $line[1]]], [ $offers->activate($offer, [['target' => $line[0], 'rights' => $line[1]]], [
'grant_kind' => 'kauf', 'grant_kind' => 'kauf',
'price_cents' => $cents, 'price_cents' => $cents,
'holder_kind' => $holder, 'holder_kind' => $holder,
'licence_scope' => $scope,
'trainer_count' => $trainers,
]); ]);
$offers->assignProduct($offer, $version->composition_id, $label); $offers->assignProduct($offer, $version->composition_id, $label);
+3 -1
View File
@@ -375,7 +375,9 @@ ### 5.1 Der Vertragsdatensatz: was zur Rekonstruktion des gekauften Angebots nö
**Nicht** Teil des Vertragsdatensatzes ist das Aussehen der damaligen Marketingseite. Seitenrevisionen des CMS sind eine Bearbeitungshilfe der Redaktion mit eigener, kürzerer Aufbewahrung; ihre pixelgenaue Wiederherstellung wird nicht zugesichert und nicht benötigt. **Nicht** Teil des Vertragsdatensatzes ist das Aussehen der damaligen Marketingseite. Seitenrevisionen des CMS sind eine Bearbeitungshilfe der Redaktion mit eigener, kürzerer Aufbewahrung; ihre pixelgenaue Wiederherstellung wird nicht zugesichert und nicht benötigt.
Der Warenkorb fasst die ausgewählten kaufbaren Angebote oder Optionen zusammen. Er reserviert keine Preise oder Lizenzkonditionen. Bei Bestellabschluss werden je Position die vereinbarte Angebotsfassung, der Preis, die Konditionen und der aufgelöste Lizenzumfang gespeichert. Eine Bestellung kann höchstens einen Rabattcode verwenden. Ein allgemeiner Code ist auf Warenkorbebene anwendbar, ein produktspezifischer Code nur auf berechtigte Positionen. Die Berechtigung für den Zertifizierungsrabatt kommt aus dem geprüften Kundenkonto. Nach der Bestellung bleibt der berechnete Zahlbetrag nachvollziehbar. Die Verteilung eines Bestellrabatts auf Positionen im Erstattungsfall ist noch festzulegen. Der Warenkorb fasst die ausgewählten kaufbaren Angebote oder Optionen zusammen. Er reserviert keine Preise oder Lizenzkonditionen. Bei Bestellabschluss werden je Position die vereinbarte Angebotsfassung, der Preis, die Konditionen und der aufgelöste Lizenzumfang gespeichert. Eine Bestellung kann höchstens einen Rabattcode verwenden. Ein allgemeiner Code ist auf Warenkorbebene anwendbar, ein produktspezifischer Code nur auf berechtigte Positionen. Die Berechtigung für den Zertifizierungsrabatt kommt aus dem geprüften Kundenkonto. Nach der Bestellung bleibt der berechnete Zahlbetrag nachvollziehbar: Die Bestellung hält Zwischensumme, Rabatt, Zahlbetrag und einen Abzug des Codes fest, die Bestellposition Listenpreis und den auf sie entfallenden Rabatt. Geltungsbereich (Warenkorb oder ausgewählte Ziele: Angebot, Lizenzartikel, Paket) und Einlösungsberechtigung (allgemein oder freigeschaltete Konten) sind unabhängige Eigenschaften des Codes; Freigaben gelten je Code und Konto und werden nur entzogen, nie gelöscht (ADR-47). Die Verteilung eines Bestellrabatts auf Positionen im Erstattungsfall bei Einzelrückgabe ist noch festzulegen (Rechenbeispiel in ADR-47); zum Start gibt es nur Vollerstattungen.
Der **Nutzerkreis** der Lizenzoption (Einzellizenz = ein Trainer, Mehrfachlizenz = festgelegte Trainerzahl) gehört zur Angebotsfassung, wird in Bestellposition und Erwerb kopiert und ist getrennt von Lizenzinhaber, Nutzungszweck und Downloadkonto.
## 6. Stabile Identitäten im Überblick ## 6. Stabile Identitäten im Überblick
@@ -239,7 +239,7 @@ ## 7. Überlappung, Entzug und Erstattung (LIC-005, SC-12)
Für den Start sind keine freiwilligen Teilerstattungen vorgesehen. Ein Bundle bildet eine Erwerbseinheit für die Rückgabe. Bei einer vollständigen Erstattung werden die betroffenen Erwerbe anhand der Bestellpositionen entzogen. Rechte aus anderen Erwerbsquellen werden weiter berücksichtigt. Extern ausgelöste Teilbeträge und rechtlich gebotene Sonderfälle laufen über die Betreiberprüfung in `07`, Ablauf 5. Für den Start sind keine freiwilligen Teilerstattungen vorgesehen. Ein Bundle bildet eine Erwerbseinheit für die Rückgabe. Bei einer vollständigen Erstattung werden die betroffenen Erwerbe anhand der Bestellpositionen entzogen. Rechte aus anderen Erwerbsquellen werden weiter berücksichtigt. Extern ausgelöste Teilbeträge und rechtlich gebotene Sonderfälle laufen über die Betreiberprüfung in `07`, Ablauf 5.
Eine geprüfte Trainerzertifizierung am Konto kann für einen gemeinsamen Rabattcode qualifizieren. Berechtigte Konten können diesen Code bei weiteren Bestellungen wiederverwenden. Der Rabatt ändert den Zahlbetrag. Der erworbene Lizenzumfang ergibt sich aus der bestellten Angebotsoption. Eine geprüfte Trainerzertifizierung am Konto kann für einen gemeinsamen Rabattcode qualifizieren. Berechtigte Konten können diesen Code bei weiteren Bestellungen wiederverwenden. Der Rabatt ändert den Zahlbetrag. Der erworbene Lizenzumfang ergibt sich aus der bestellten Angebotsoption. Die Berechtigung ist eine Freigabe des Kontos für genau diesen Code (nicht für andere Codes), vom Betreiber nach manueller Prüfung des Zertifikats erteilt und entziehbar; sie wird bei der Einlösung und unmittelbar vor Bestellabschluss geprüft (ADR-47).
## 8. Gezieltes Upgrade (LIC-007, LIC-012, SC-09) ## 8. Gezieltes Upgrade (LIC-007, LIC-012, SC-09)
@@ -287,7 +287,7 @@ ### 8.4 Verworfene Alternativen
## 9. Organisationen und Sitze (ID-003, SC-14) ## 9. Organisationen und Sitze (ID-003, SC-14)
**Vereinskauf zum Download-Start:** Einzel- und Mehrfachlizenz bestimmen den vertraglichen Nutzungsumfang. Eine Vereinslizenz gehört dem Verein. Die Berechtigung zum Download aus der Bestellung ist ausschließlich an das Mitgliederkonto gebunden, das die Bestellung ausgelöst hat. Bestellendes Konto und Lizenzinhaber werden im Kauf festgehalten. Die zentrale Rechteprüfung berücksichtigt bei Vereinskäufen diese ausdrückliche Kontobindung. Mehrfachlizenzen erzeugen zum Start keine weiteren Downloadkonten. Die nachstehende Sitzverwaltung beschreibt den möglichen Ausbau. Für den Online-Player ist offen, ob zugeordnete Trainerprofile verwendet werden oder das bestellende Profil autorisierte Streaming-Links erzeugt. **Vereinskauf zum Download-Start:** Einzel- und Mehrfachlizenz bestimmen den vertraglichen Nutzungsumfang. Eine Vereinslizenz gehört dem Verein. Die Berechtigung zum Download aus der Bestellung ist ausschließlich an das Mitgliederkonto gebunden, das die Bestellung ausgelöst hat. Bestellendes Konto und Lizenzinhaber werden im Kauf festgehalten. Die zentrale Rechteprüfung berücksichtigt bei Vereinskäufen diese ausdrückliche Kontobindung. Mehrfachlizenzen erzeugen zum Start keine weiteren Downloadkonten. Der Nutzerkreis (Einzellizenz: ein Trainer; Mehrfachlizenz: festgelegte Trainerzahl) ist eine vertragliche Angabe der Lizenzoption und wird bei Kauf in Bestellposition und Erwerb festgehalten. Er wird weder aus dem Nutzungszweck noch aus Preis oder Rabattfreigabe abgeleitet; Lizenzinhaber, berechtigte Trainer und technischer Downloadzugriff bleiben getrennte Angaben. Die Trainerzahl ist zum Start rein vertraglich (Anzeige und Nachvollziehbarkeit), keine technische Sperre. Die nachstehende Sitzverwaltung beschreibt den möglichen Ausbau. Für den Online-Player ist offen, ob zugeordnete Trainerprofile verwendet werden oder das bestellende Profil autorisierte Streaming-Links erzeugt.
```text ```text
weise_sitz_zu(pool, konto, ausführender): weise_sitz_zu(pool, konto, ausführender):
+1 -1
View File
@@ -100,7 +100,7 @@ ## Ablauf 3 – Kauf mit Zahlungsbestätigung (PAY-002)
**Warenkorbzustände.** Die gewählten Optionen bleiben in derselben Browsersitzung über Anmeldung, Registrierung und E-Mail-Bestätigung hinweg erhalten. Je Option gibt es eine Position. Alternativoptionen derselben Angebotsgruppe werden nur nach ausdrücklichem Wechsel ersetzt. Ein bereits erworbener Umfang mit denselben Rechten für den vorgesehenen Lizenzinhaber bleibt mit dem Hinweis „Bereits erworben · Wird nicht mitbestellt“ sichtbar. Diese Position gehört nicht zur Kaufsumme und erzeugt keine Bestellposition. Der Käufer kann sie entfernen, die Bibliothek öffnen oder mit den übrigen Positionen fortfahren. Die Entscheidung wird beim Abschluss serverseitig erneut geprüft. Das Verhalten bei zurückgezogenen Angeboten richtet sich nach FACH-59. **Warenkorbzustände.** Die gewählten Optionen bleiben in derselben Browsersitzung über Anmeldung, Registrierung und E-Mail-Bestätigung hinweg erhalten. Je Option gibt es eine Position. Alternativoptionen derselben Angebotsgruppe werden nur nach ausdrücklichem Wechsel ersetzt. Ein bereits erworbener Umfang mit denselben Rechten für den vorgesehenen Lizenzinhaber bleibt mit dem Hinweis „Bereits erworben · Wird nicht mitbestellt“ sichtbar. Diese Position gehört nicht zur Kaufsumme und erzeugt keine Bestellposition. Der Käufer kann sie entfernen, die Bibliothek öffnen oder mit den übrigen Positionen fortfahren. Die Entscheidung wird beim Abschluss serverseitig erneut geprüft. Das Verhalten bei zurückgezogenen Angeboten richtet sich nach FACH-59.
**Rabatt.** Höchstens ein Code je Bestellung. Allgemeine Codes können den gesamten Warenkorb betreffen, produktspezifische nur die dazugehörigen Positionen. Für den gemeinsamen Zertifizierungscode prüft der Betreiber die angegebene Zertifizierung anhand der Liste und vermerkt die Berechtigung am Konto. Berechtigte Konten können den Code wiederholt bei späteren Bestellungen einlösen. **Rabatt.** Höchstens ein Code je Bestellung. Allgemeine Codes können den gesamten Warenkorb betreffen, produktspezifische nur die dazugehörigen Positionen. Für den gemeinsamen Zertifizierungscode prüft der Betreiber die angegebene Zertifizierung anhand der Liste und vermerkt die Berechtigung am Konto. Berechtigte Konten können den Code wiederholt bei späteren Bestellungen einlösen. Im Checkout gibt der Käufer den Code ein und kann ihn entfernen; die Übersicht zeigt rabattierte Positionen, Rabattbetrag und endgültigen Zahlbetrag und erklärt, wenn der Code abgelaufen ist, keine Position passt oder für das Konto keine Freigabe vorliegt. Stripe erhält den Zahlbetrag nach Rabatt (ADR-47).
Entscheidende Punkte: Entscheidende Punkte:
@@ -626,7 +626,32 @@ ## ADR-46 – Mitgliederprofil, Fußzeile und Dateiname
- **Fußzeile** `x-member.footer`: Links aus der CMS-Navigation (Plätze Rechtliches und Kontakt), ersatzweise die veröffentlichten Seiten `/impressum` und `/datenschutz`; keine fest codierten Texte. - **Fußzeile** `x-member.footer`: Links aus der CMS-Navigation (Plätze Rechtliches und Kontakt), ersatzweise die veröffentlichten Seiten `/impressum` und `/datenschutz`; keine fest codierten Texte.
- **Dateiname** von Download und Ansicht aus dem Anzeigetitel des Mediums plus Dateiendung; ein eigenes Feld im Medienmanager ist nicht beschlossen. - **Dateiname** von Download und Ansicht aus dem Anzeigetitel des Mediums plus Dateiendung; ein eigenes Feld im Medienmanager ist nicht beschlossen.
- **Player:** Der Anfangsscan von `app.js` bindet auch im Quelltext stehende HLS-Videos an hls.js an (bisher übersprungen, weil `document` kein `Element` ist). - **Player:** Der Anfangsscan von `app.js` bindet auch im Quelltext stehende HLS-Videos an hls.js an (bisher übersprungen, weil `document` kein `Element` ist).
- **Einzel-/Mehrfachlizenz:** nicht vorhanden; die Lizenzdetailseite benennt das offen. Ein Vorschlag steht in `docs/ux/mitgliederbereich/nachbesserung-2026-11-23.md`. - **Einzel-/Mehrfachlizenz:** zum Zeitpunkt dieser Entscheidung nicht vorhanden; seit ADR-47 gibt es den Nutzerkreis je Lizenzoption.
**Alternativen.** E-Mail sofort ändern (verworfen: Tippfehler sperrt das Konto aus, Kontoübernahme ohne Gegenprobe); Adresse als Freitext am Konto (verworfen: Rechnungsadresse gehört zum Lizenzinhaber, auch für Organisationen); Fußzeile des Website-Gerüsts übernehmen (verworfen: zu groß für die Arbeitsoberfläche). **Alternativen.** E-Mail sofort ändern (verworfen: Tippfehler sperrt das Konto aus, Kontoübernahme ohne Gegenprobe); Adresse als Freitext am Konto (verworfen: Rechnungsadresse gehört zum Lizenzinhaber, auch für Organisationen); Fußzeile des Website-Gerüsts übernehmen (verworfen: zu groß für die Arbeitsoberfläche).
**Folgen.** Rechnungsstellung und Bestellübersicht müssen die Adresse später in die Bestellung kopieren (Stand zum Kaufzeitpunkt). Pflege der Rechtsseiten bleibt Aufgabe der Redaktion im CMS. **Folgen.** Rechnungsstellung und Bestellübersicht müssen die Adresse später in die Bestellung kopieren (Stand zum Kaufzeitpunkt). Pflege der Rechtsseiten bleibt Aufgabe der Redaktion im CMS.
**Quelle.** Rückmeldung des Betreibers vom 23.11.2026; ADR-45; `05_Lizenz_und_Berechtigungslogik.md` §9. **Quelle.** Rückmeldung des Betreibers vom 23.11.2026; ADR-45; `05_Lizenz_und_Berechtigungslogik.md` §9.
## ADR-47 – Rabattcodes, Nutzerkreis der Lizenzoption und Verkaufsstart-Vorbereitung
**Status am 24.11.2026:** Umgesetzt auf `feature/shop-rabatt-lizenz` (Abnahme siehe `docs/ux/verwaltung/abnahme/etappe-1.md`, Abschnitt „Verkaufsstart-Etappe“). Die Produktivfreigabe ist **nicht** erteilt und bleibt bei Lars.
**Kontext.** PAY-006 bis PAY-009 und ID-004 legen den Verkaufsstart fest; Rabattcodes, Einzel-/Mehrfachlizenz und die Pflichtangaben im Bestellablauf fehlten. Aus Etappe 1 waren drei Download-Befunde und die Frage nach der Produktseite eines Pakets offen.
**Bestätigt durch den Auftrag von Lars (21.11. bis 24.11.2026).**
- **Rabattcode, zwei voneinander unabhängige Einstellungen.** Geltungsbereich: gesamter Warenkorb oder ausdrücklich gewählte Lizenzartikel, Angebote oder Pakete. Ein Paket ist ein eigenes Ziel; seine Rabattfähigkeit folgt nie aus einem enthaltenen Artikel (und umgekehrt). Einlösungsberechtigung: allgemein oder nur für ausdrücklich freigeschaltete Konten. Freigaben gelten je Code und Konto (Freigabe für X ist keine für Y), werden nie gelöscht, nur entzogen. Pro Bestellung höchstens ein Code. Der Rabatt ändert den Preis, nie den Nutzungsumfang.
- **Prüfung** bei Eingabe, in jeder Übersicht und unter Sperre unmittelbar vor Bestellabschluss; die Prüfsumme der Übersicht enthält Code, Zustand und Rabatt je Position, ein zwischenzeitlich entzogener Code ergibt `StaleOverview` statt einer Bestellung zum falschen Preis. Ein vorgemerkter, aber nicht mehr gültiger Code hält die Bestellung an, bis er entfernt wird.
- **Nutzerkreis je Lizenzoption** (`offer_versions.licence_scope`, `trainer_count`): Einzellizenz = ein Trainer, Mehrfachlizenz = festgelegte Zahl (2 bis 999). Er wird weder aus dem Nutzungszweck (ehrenamtlich, kommerziell, institutionell) noch aus Preis oder Rabattfreigabe abgeleitet. Lizenzinhaber, berechtigte Trainer und technischer Downloadzugriff sind getrennte Angaben; beim Vereinskauf bleibt der Verein Lizenzinhaber und nur das bestellende Konto lädt herunter. Der Wert wird in Bestellposition und Erwerb (Bedingungen) kopiert und gehört zur Prüfung „Bereits erworben“ (eine Einzellizenz deckt keine Mehrfachlizenz ab). Ältere Fassungen und Bestellungen zeigen „Nutzerkreis nicht festgelegt“, es gibt keine Rückfüllung. Zusätzliche Trainerkonten und Sitzzuweisungen bleiben A4.
- **Ein Angebot ohne verkaufbaren Inhalt** (Artikel ohne veröffentlichten Stand) lässt sich im Domänenmodell (`OfferService::activate`) nicht aktivieren, nicht nur in der Maske.
- **Ein eigenständig vermarktetes Paket** erhält eine eigene Produktseite `/pakete/{id}` mit seinem tatsächlichen Umfang (`offers.standalone_bundle`), eine Kachel im Shop und die Suche über die enthaltenen Artikel.
**Von mir gewählt, bitte bestätigen.**
- **Rechenregel:** Prozent je Position kaufmännisch gerundet; Festbetrag je Bestellung, höchstens bis zur Summe der betroffenen Positionen, anteilig zum Positionspreis verteilt (größter Rest zuerst). Gespeichert werden Listenpreis und Rabatt je Position, Zwischensumme, Rabatt, Zahlbetrag und ein Abzug des Codes zum Bestellzeitpunkt. Stripe erhält je Position den Preis nach Rabatt, damit der Betrag bei Stripe dem gespeicherten Zahlbetrag entspricht.
- **Mindestzahlbetrag 0,50 €** mit Rabatt (Mindestbetrag der Kartenzahlung); ein 100-Prozent-Code ist beim Start nicht möglich.
- **Freigabe mit optionalem Ende** („solange … Freigabe gültig“); Pflege durch Katalogverwalter und Kundenbetreuung.
- **Kauf auf Rechnung** für Organisationen: Bestellung mit Zahlungsweg „Rechnung“, Betreiber erstellt die Rechnung manuell und bestätigt den Zahlungseingang in der Bestellverwaltung; erst danach Freischaltung. Mitglieder können das nicht selbst auslösen.
- **Widerruf:** Das Mitglied erklärt ihn (Datum, Anmerkung); die Erklärung entzieht nichts. Der Betreiber prüft (bei sofortiger Bereitstellung mit ausdrücklicher Zustimmung kann das Recht erloschen sein) und erstattet in der Bestellverwaltung vollständig; bei Stripe wird zuerst die Rückzahlung bei Stripe veranlasst, erst bei Erfolg werden Rechte entzogen. Die Selbstbedienungs-Erstattung gibt es nur im Testzahlungsweg.
- **Pflichtangaben:** Schaltfläche „Zahlungspflichtig bestellen“, zwei Zustimmungen (AGB und Lizenzbedingungen; ausdrücklicher Wunsch nach sofortiger Bereitstellung mit Hinweis auf das Erlöschen des Widerrufsrechts) als Pflichtfelder, serverseitig geprüft und mit Wortlaut, Fassung (`SalesTerms::VERSION`) und Seitenständen an der Bestellung festgehalten; Vertragsbestätigung per Mail mit Nutzerkreis, Rabatt und Zustimmung. **Der Wortlaut ist ein Entwurf und rechtlich nicht geprüft.**
- **Produktivfreigabe** nur mit `SHOP_LIVE_RELEASE=true` in `/etc/luf/prod.env`, Zahlungstreiber `stripe`, Live-Schlüssel und veröffentlichten Rechtstexten (`Shop::live()`); standardmäßig aus. Ohne sie bleibt der Shop in Produktion abgeschaltet und Stripe lehnt dort jeden Aufruf ab. Außerhalb der Produktion bleiben Live-Schlüssel verboten.
**Offene Fachfrage mit Rechenbeispiel (nicht entschieden, siehe auch `13_Risiken_Annahmen_offene_Entscheidungen.md`).**
1. *Rundung.* Drei Positionen zu je 0,99 €, Code 50 %. Je Position gerundet: 3 × 0,50 € = 1,50 € Rabatt, Zahlbetrag 1,47 €. Auf der Warenkorbsumme gerundet: 2,97 € × 50 % = 1,485 € → 1,49 € Rabatt, Zahlbetrag 1,48 €. Heute gilt die Rundung je Position. Welche gilt rechtlich und buchhalterisch?
2. *Verteilung eines Warenkorbrabatts bei späterer Einzelrückgabe.* Warenkorb Position A 60,00 € und B 40,00 €, Festbetrag 10,00 € (Zahlbetrag 90,00 €). Heute verteilt das System anteilig (A 6,00 €, B 4,00 €). Gäbe der Käufer später nur B zurück: Erstattung 36,00 € (anteilig), 40,00 € (voller Listenpreis, der Rabatt bliebe auf A) oder 30,00 € (B trägt den Rabatt zuerst ab)? Zum Start gibt es nur die Vollerstattung der Bestellung (90,00 €) und Bundles als Einheit; die Frage wird mit freiwilligen Teilerstattungen (A2) relevant. Die Daten (Rabatt je Position) liegen vor.
3. *Rabatt und Steuer.* Wie der Rabatt in der Rechnung auf Steuersätze verteilt wird, hängt am Steuerstatus (OPEN-06).
**Folgen.** Neue Tabellen und Spalten sind rein ergänzend; bei einem Code-Rollback bleiben sie liegen. **Vor einem Rollback offene Bestellungen mit Rabatt oder Rechnungsweg prüfen**: der alte Code kennt den Rabatt nicht und würde den Listenpreis gegen den Zahlbetrag prüfen.
**Quelle.** Auftrag „Shop bis zum Verkaufsstart in Deutschland“; PAY-006 bis PAY-009, ID-004, FACH-14, FACH-59; ADR-42, ADR-45, ADR-46.
@@ -123,7 +123,7 @@ ## 4. Offene fachliche Entscheidungen
| E-23 | Organisationskauf | Verkauf an Organisationen gehört zum bestätigten Käuferkreis. Vor dem ersten Verkauf vorbereiten, welche Angebote einer Organisation als Inhaberin zugewiesen werden und welche Verwaltung dafür benötigt wird. | Erwerb für Organisation mit Sitzpool, falls das Angebot Sitze umfasst | vor dem ersten Organisationsverkauf | | E-23 | Organisationskauf | Verkauf an Organisationen gehört zum bestätigten Käuferkreis. Vor dem ersten Verkauf vorbereiten, welche Angebote einer Organisation als Inhaberin zugewiesen werden und welche Verwaltung dafür benötigt wird. | Erwerb für Organisation mit Sitzpool, falls das Angebot Sitze umfasst | vor dem ersten Organisationsverkauf |
| E-24 | Community-Produkt und Betriebsform (selbst betrieben oder gehostet) | `10`, Abschnitt 4 | ADR-12 | vor A3, nach dem kleinen Nachweis aus `10`, Abschnitt 11 Nr. 2 | | E-24 | Community-Produkt und Betriebsform (selbst betrieben oder gehostet) | `10`, Abschnitt 4 | ADR-12 | vor A3, nach dem kleinen Nachweis aus `10`, Abschnitt 11 Nr. 2 |
**Vor dem Verkaufsstart zu klären:** Steuer- und Belegdetails (OPEN-06), Bedingungen und Preise der Startangebote (OPEN-03), der konkrete Widerrufsprozess (E-11) und Wiederherstellungsziele (E-22). Rabattformeln und die Verteilung etwaiger Bestellrabatte auf Positionen sind zu konkretisieren. Der Käuferkreis (E-09) ist entschieden. **Vor dem Verkaufsstart zu klären:** Steuer- und Belegdetails (OPEN-06), Bedingungen und Preise der Startangebote (OPEN-03), der konkrete Widerrufsprozess (E-11) und Wiederherstellungsziele (E-22). Rabattformeln und die Verteilung etwaiger Bestellrabatte auf Positionen sind zu konkretisieren (umgesetzte Regel und Rechenbeispiele zur Entscheidung: ADR-47). Der Käuferkreis (E-09) ist entschieden.
## 5. Wie weit trägt die technische Planung ohne die Geschäftsentscheidungen? ## 5. Wie weit trägt die technische Planung ohne die Geschäftsentscheidungen?
+2 -1
View File
@@ -225,7 +225,8 @@ ### Shop-Abnahme
| Identische Lizenz bereits erworben | Hinweis und Entfernen bleiben sichtbar. Die Position fehlt in Kaufsumme und Bestellung. Der Rest ist weiterhin kaufbar. Ein Bundle mit zusätzlichem Inhalt bleibt kaufbar und wird als Einheit behandelt. | Testkauf | | Identische Lizenz bereits erworben | Hinweis und Entfernen bleiben sichtbar. Die Position fehlt in Kaufsumme und Bestellung. Der Rest ist weiterhin kaufbar. Ein Bundle mit zusätzlichem Inhalt bleibt kaufbar und wird als Einheit behandelt. | Testkauf |
| Testzahlung scheitert, wird abgebrochen oder wiederholt bestätigt | Ohne bestätigte Zahlung keine Auslieferung. Nach erfolgreicher Bestätigung entstehen Rechte für alle Bestellpositionen, genau einmal je Erwerbsquelle. | Testkauf | | Testzahlung scheitert, wird abgebrochen oder wiederholt bestätigt | Ohne bestätigte Zahlung keine Auslieferung. Nach erfolgreicher Bestätigung entstehen Rechte für alle Bestellpositionen, genau einmal je Erwerbsquelle. | Testkauf |
| Lizenzoption im bestehenden Arbeitsplatz bearbeiten | Maske ist vorbelegt, Preis erscheint in Euro, Abbrechen verwirft Eingaben. Bei Aktivierung wirkt die Änderung für diese Option. Andere Optionen bleiben kaufbar. | Testkauf | | Lizenzoption im bestehenden Arbeitsplatz bearbeiten | Maske ist vorbelegt, Preis erscheint in Euro, Abbrechen verwirft Eingaben. Bei Aktivierung wirkt die Änderung für diese Option. Andere Optionen bleiben kaufbar. | Testkauf |
| Allgemeiner oder produktspezifischer Rabattcode | Ein Code je Bestellung; nur passender Geltungsbereich; berechtigtes Konto kann gemeinsamen Zertifizierungscode erneut verwenden | Verkaufsstart | | Allgemeiner oder produktspezifischer Rabattcode | Ein Code je Bestellung; nur passender Geltungsbereich; berechtigtes Konto kann gemeinsamen Zertifizierungscode erneut verwenden. Wer den Code kennt, aber keine Freigabe für genau diesen Code hat, erhält keinen Rabatt. Prüfung bei Einlösung und vor Bestellabschluss, Zahlbetrag in Bestellung und bei Stripe gleich. (umgesetzt, ADR-47; Abnahme in `etappe-1.md`) | Verkaufsstart |
| Einzel- und Mehrfachlizenz unterscheiden | Nutzerkreis (ein Trainer oder festgelegte Zahl) auf Produktseite und in der Bestellung; mit den Konditionen gespeichert; unabhängig von Zweck, Preis, Lizenzinhaber und Downloadkonto (umgesetzt, ADR-47) | Verkaufsstart |
| Vereinsrechnung bezahlen | Rechte bis zur bestätigten Überweisung gesperrt, danach Vergabe aus Bestellung | Verkaufsstart | | Vereinsrechnung bezahlen | Rechte bis zur bestätigten Überweisung gesperrt, danach Vergabe aus Bestellung | Verkaufsstart |
| Vereins-Mehrfachlizenz erwerben | Verein als Lizenzinhaber und bestellendes Profil getrennt festgehalten. Nur dieses Profil erhält nach Testzahlung Downloadzugriff aus der Bestellung. Mit einem zweiten Konto desselben Vereins ist auch der direkte Abruf aus dieser Bestellung nicht möglich. | Testkauf | | Vereins-Mehrfachlizenz erwerben | Verein als Lizenzinhaber und bestellendes Profil getrennt festgehalten. Nur dieses Profil erhält nach Testzahlung Downloadzugriff aus der Bestellung. Mit einem zweiten Konto desselben Vereins ist auch der direkte Abruf aus dieser Bestellung nicht möglich. | Testkauf |
| Vollerstattung und Bundle-Rückgabe | Rechte der betroffenen Erwerbe entzogen; andere Quellen weiterhin wirksam; Bundle als Einheit | Verkaufsstart | | Vollerstattung und Bundle-Rückgabe | Rechte der betroffenen Erwerbe entzogen; andere Quellen weiterhin wirksam; Bundle als Einheit | Verkaufsstart |
+21 -1
View File
@@ -61,7 +61,7 @@ ## Stripe-Sandbox (nur Test, Etappe 1)
**Zurück zum Testweg:** `PAYMENT_DRIVER=test` setzen und neu ausrollen. Offene Stripe-Bestellungen bleiben offen. **Zurück zum Testweg:** `PAYMENT_DRIVER=test` setzen und neu ausrollen. Offene Stripe-Bestellungen bleiben offen.
**Grenzen:** Erstattungen laufen nicht über Stripe. Die Schaltfläche „Widerrufen“ ist im Stripe-Modus ausgeblendet; die Rückzahlung gehört zum Verkaufsstart (Live-Stripe, Belegprozess, Rückabwicklung). Steuer, Rechnung, Rabattcodes und Rechtstexte sind nicht Teil der Sandbox. **Grenzen (Stand Etappe 1; die Erstattung ist seit dem Verkaufsstart-Stand vorbereitet, siehe „Verkaufsstart: Freigabe und Betrieb“):** Erstattungen liefen nicht über Stripe. Die Schaltfläche „Widerrufen“ ist im Stripe-Modus ausgeblendet; die Rückzahlung gehört zum Verkaufsstart (Live-Stripe, Belegprozess, Rückabwicklung). Steuer, Rechnung, Rabattcodes und Rechtstexte sind nicht Teil der Sandbox.
## Trennung Test und Prod (beide auf llm-node) ## Trennung Test und Prod (beide auf llm-node)
| | Test | Prod | | | Test | Prod |
@@ -142,3 +142,23 @@ ## Annahmen und offene Punkte
- **Queue:** Datenbank-Queue (`QUEUE_CONNECTION=database`), kein Redis. Reicht für den Start. Der Worker erlaubt einem Auftrag bis zu einer Stunde (`--timeout=3600`). Das App-Image enthält `ffmpeg`. Die Queue leitet daraus Vorschaubilder und, wenn die Datei lesbar ist, drei HLS-Qualitätsstufen nach `derived/` ab. Fehlt die Ableitung, bleibt die gespeicherte Datei über den bisherigen berechtigten Abruf lesbar. Der Web-Prozess schreibt diese Ableitungen nicht. - **Queue:** Datenbank-Queue (`QUEUE_CONNECTION=database`), kein Redis. Reicht für den Start. Der Worker erlaubt einem Auftrag bis zu einer Stunde (`--timeout=3600`). Das App-Image enthält `ffmpeg`. Die Queue leitet daraus Vorschaubilder und, wenn die Datei lesbar ist, drei HLS-Qualitätsstufen nach `derived/` ab. Fehlt die Ableitung, bleibt die gespeicherte Datei über den bisherigen berechtigten Abruf lesbar. Der Web-Prozess schreibt diese Ableitungen nicht.
- **Gate vor Prod:** Merge-Schutz ist eine Gitea-Einstellung und gehört nicht in die Workflows. - **Gate vor Prod:** Merge-Schutz ist eine Gitea-Einstellung und gehört nicht in die Workflows.
- **Umzug Test auf den Pi:** Werte oben in `deploy-test.yml` ändern (Label `ubuntu-latest`, Guard auf `raspberrypi5`/`aarch64`, Pfade, Port). Das Dockerfile baut auch für ARM64. Vorher Speicherlage auf dem Pi klären. - **Umzug Test auf den Pi:** Werte oben in `deploy-test.yml` ändern (Label `ubuntu-latest`, Guard auf `raspberrypi5`/`aarch64`, Pfade, Port). Das Dockerfile baut auch für ARM64. Vorher Speicherlage auf dem Pi klären.
## Verkaufsstart: Freigabe und Betrieb (Stand 24.11.2026, vorbereitet, nicht freigegeben)
Die Produktivfreigabe liegt bei Lars. Der Code enthält sie nicht; er erlaubt sie nur, wenn **alle** Bedingungen erfüllt sind (`App\Domain\Commerce\Shop::live()`):
| Bedingung | Wo gesetzt |
|---|---|
| `SHOP_LIVE_RELEASE=true` | `/etc/luf/prod.env` (Standard: aus; nie im Repository) |
| `PAYMENT_DRIVER=stripe` | `/etc/luf/prod.env` |
| `STRIPE_SECRET=sk_live_…` (Live-Schlüssel; in Produktion sind Testschlüssel nie live, außerhalb der Produktion sind Live-Schlüssel verboten) | `/etc/luf/prod.env` |
| `STRIPE_WEBHOOK_SECRET` des Live-Endpunkts, Adresse `https://lara-und-felix.de/stripe/webhook` (Ereignisse mindestens `checkout.session.completed`, `checkout.session.expired`, `checkout.session.async_payment_succeeded`, `checkout.session.async_payment_failed`) | `/etc/luf/prod.env`, Stripe-Dashboard |
| Veröffentlichte CMS-Seiten `/agb`, `/lizenzbedingungen`, `/widerruf`, `/impressum`, `/datenschutz` | Webpräsenz (Redaktion, Text von der Rechtsberatung) |
Weitere Einstellungen: `SHOP_INVOICE` (Standard an: Kauf auf Rechnung für Organisationen), `SHOP_PRICE_NOTE` (Preis- und Steuerhinweis im Warenkorb, Standard „Alle Preise in Euro.“), `STRIPE_TAX_RATE_ID` (im Preis enthaltener Steuersatz; Steuerstatus offen, OPEN-06). Die Verwaltungsseite **Verkauf → Verkaufsstart** zeigt den Zustand ohne Schlüssel.
- **Erstattung bei Stripe:** `Checkout::refund` ruft vor dem Entzug der Rechte `POST /v1/refunds` (Vollbetrag, Idempotenzschlüssel `luf-refund-<Bestellung>-<Zahlung>`) auf; schlägt das fehl, bleibt die Bestellung unverändert. Dafür muss der API-Schlüssel das Recht „Refunds: write“ haben (bei eingeschränktem Schlüssel `rk_…` prüfen). Die Zahlungsabsicht (`payment_intent`) wird aus der signierten Meldung gespeichert, sonst bei Stripe abgefragt.
- **Rechnungsweg:** Vereine bestellen „auf Rechnung“; der Betreiber erstellt die Rechnung manuell und bestätigt den Zahlungseingang unter **Verkauf → Bestellungen**.
- **Migration** `2026_11_24_100000_add_discounts_licence_scope_and_sales_start`: rein ergänzend (neue Tabellen `discount_codes`, `discount_code_targets`, `discount_code_releases`; neue Spalten an `offers`, `offer_versions`, `orders`, `order_lines`, `payments`). Nichts wird gelöscht oder umbenannt.
- **Rollback:** setzt nur den Code zurück. Der frühere Code kennt Rabatt und Rechnungsweg nicht; vorher offene Bestellungen mit Rabatt oder Zahlungsweg „Rechnung“ stornieren oder abwickeln.
- **Was vor der Freigabe fehlt (Lars bzw. Rechtsberatung):** finale Texte (AGB, Lizenzbedingungen je Zweck, Widerrufsbelehrung samt Muster-Widerrufsformular, Impressum, Datenschutzerklärung), Prüfung des Wortlauts der Zustimmungen im Checkout (Entwurf `2026-11-24-entwurf`), Steuerstatus und Belegangaben (OPEN-06, E-11: Rechnungsvorlage mit Pflichtangaben, Rechnungsnummernkreis, Steuerausweis), Live-Stripe-Konto mit Webhook, Aufbewahrungsfristen (E-16), Auftragsverarbeitung mit Stripe, ein gesondert beauftragter Sicherheitstest (16, Abschnitt 6.3).
@@ -207,7 +207,7 @@ ## 8. Verkauf, Zahlung und Freischaltung
**PAY-007 [FESTGELEGT]** Mehrere Angebote beziehungsweise gewählte Lizenzoptionen können gemeinsam bestellt werden. Preisänderungen im Warenkorb werden vor dem Abschluss sichtbar. Nicht mehr kaufbare Positionen bleiben mit Hinweis sichtbar und sind vom Käufer zu entfernen, bevor er mit den übrigen Positionen bestellt. Je Position bleiben die vereinbarte Fassung mit Preis, Konditionen und Lizenzumfang festgehalten. **PAY-007 [FESTGELEGT]** Mehrere Angebote beziehungsweise gewählte Lizenzoptionen können gemeinsam bestellt werden. Preisänderungen im Warenkorb werden vor dem Abschluss sichtbar. Nicht mehr kaufbare Positionen bleiben mit Hinweis sichtbar und sind vom Käufer zu entfernen, bevor er mit den übrigen Positionen bestellt. Je Position bleiben die vereinbarte Fassung mit Preis, Konditionen und Lizenzumfang festgehalten.
**PAY-008 [FESTGELEGT]** Pro Bestellung ist ein Rabattcode zulässig. Allgemeine Codes können für den ganzen Warenkorb, produktspezifische für ausgewählte Produkte gelten. Ein gemeinsamer Zertifizierungscode kann nach Prüfung und Freigabe am Konto auch bei weiteren Bestellungen eingesetzt werden. Für den Start sind keine freiwilligen Teilerstattungen vorgesehen. Bundles sind Rückgabeeinheiten. **PAY-008 [FESTGELEGT]** Pro Bestellung ist ein Rabattcode zulässig. Allgemeine Codes können für den ganzen Warenkorb, produktspezifische für ausgewählte Produkte gelten. Ein gemeinsamer Zertifizierungscode kann nach Prüfung und Freigabe am Konto auch bei weiteren Bestellungen eingesetzt werden. Für den Start sind keine freiwilligen Teilerstattungen vorgesehen. Bundles sind Rückgabeeinheiten. Der Geltungsbereich eines Codes (Warenkorb oder ausgewählte Ziele) und seine Einlösungsberechtigung (allgemein oder freigeschaltete Konten) sind unabhängige Einstellungen; eine Freigabe gilt nur für den jeweiligen Code. Einzel- und Mehrfachlizenz (Nutzerkreis je Lizenzoption) sind seit ADR-47 umgesetzt.
**PAY-009 [ZU KLÄREN]** Rechnungs- und Steuerdetails, Preisgestaltung, genaue Rabattberechnung sowie die rechtliche und operative Ausgestaltung des Widerrufs vor dem Verkaufsstart. **PAY-009 [ZU KLÄREN]** Rechnungs- und Steuerdetails, Preisgestaltung, genaue Rabattberechnung sowie die rechtliche und operative Ausgestaltung des Widerrufs vor dem Verkaufsstart.
@@ -14,6 +14,8 @@ # Mitgliederbereich – Nachbesserung 23.11.2026
## Prüfung der Frage „Haben wir Einzel- und Mehrfachlizenz schon?“ ## Prüfung der Frage „Haben wir Einzel- und Mehrfachlizenz schon?“
**Stand 24.11.2026: Seit ADR-47 gibt es den Nutzerkreis je Lizenzoption (am Angebot, nicht am Rechteprofil), kopiert in Bestellung und Erwerb, sichtbar in „Meine Lizenzen“.** Der folgende Befund beschreibt den Stand vom 23.11.2026.
**Nein, nicht als Funktion.** Befund im Code und in den Dokumenten: **Nein, nicht als Funktion.** Befund im Code und in den Dokumenten:
- `docs/architektur/05_Lizenz_und_Berechtigungslogik.md` §9 nennt „Einzel- und Mehrfachlizenz“ als vertraglichen Nutzungsumfang und Sitzzahlen (Beispiel „I-Stream-5, 5 Sitze“) als Option eines Rechteprofils. Sitzpools und Selbstverwaltung sind ausdrücklich „mit A4“ geplant, nicht gebaut. „Mehrfachlizenzen erzeugen zum Start keine weiteren Downloadkonten.“ - `docs/architektur/05_Lizenz_und_Berechtigungslogik.md` §9 nennt „Einzel- und Mehrfachlizenz“ als vertraglichen Nutzungsumfang und Sitzzahlen (Beispiel „I-Stream-5, 5 Sitze“) als Option eines Rechteprofils. Sitzpools und Selbstverwaltung sind ausdrücklich „mit A4“ geplant, nicht gebaut. „Mehrfachlizenzen erzeugen zum Start keine weiteren Downloadkonten.“
@@ -25,7 +25,7 @@ ## Kontext und Anforderungen
| FACH-11 | Das Produkt kann mehrere kaufbare Lizenzoptionen haben | Bestätigt | Die gemeinsame Angebotsseite zeigt die Optionen mit Preis und Konditionen. | | FACH-11 | Das Produkt kann mehrere kaufbare Lizenzoptionen haben | Bestätigt | Die gemeinsame Angebotsseite zeigt die Optionen mit Preis und Konditionen. |
| FACH-12 | Alternativ können Lizenzvarianten als parallele Angebote geführt werden, etwa bei anderen Laufzeiten oder Beschreibungen | Alternative ausdrücklich offen | Nicht durch Navigation oder Auswahlmaske ausschließen; keine automatische Entscheidung zwischen Variante und eigenständigem Angebot | | FACH-12 | Alternativ können Lizenzvarianten als parallele Angebote geführt werden, etwa bei anderen Laufzeiten oder Beschreibungen | Alternative ausdrücklich offen | Nicht durch Navigation oder Auswahlmaske ausschließen; keine automatische Entscheidung zwischen Variante und eigenständigem Angebot |
| FACH-13 | Angebote können Laufzeiten haben | Bedarf bestätigt; genaue Regeln offen | Lizenzdauer, Verkaufs-/Angebotszeitraum und gegebenenfalls Aktionszeitraum begrifflich unterscheidbar halten; vorhandenes Modell abgleichen | | FACH-13 | Angebote können Laufzeiten haben | Bedarf bestätigt; genaue Regeln offen | Lizenzdauer, Verkaufs-/Angebotszeitraum und gegebenenfalls Aktionszeitraum begrifflich unterscheidbar halten; vorhandenes Modell abgleichen |
| FACH-14 | Verwaltung von Rabattcodes und Zertifizierungsberechtigung | Bestätigt | Ein Code je Bestellung. Geltung für Warenkorb oder bestimmte Produkte. Gemeinsamer Zertifizierungscode ist nach Prüfung und Kontofreigabe wiederholt einlösbar. | | FACH-14 | Verwaltung von Rabattcodes und Zertifizierungsberechtigung | Bestätigt | Ein Code je Bestellung. Geltung für Warenkorb oder bestimmte Produkte. Gemeinsamer Zertifizierungscode ist nach Prüfung und Kontofreigabe wiederholt einlösbar. **Umgesetzt (ADR-47):** Geltungsbereich und Einlösungsberechtigung sind getrennte Einstellungen; Freigaben je Konto und Code; Rechenregel und Rundung zur Bestätigung durch Lars offen (Rechenbeispiele in ADR-47). |
| FACH-15 | Mehrere Präsentationsformen: ausführliche Produktseite, Kacheln mit Kurzangaben und weitere Ansichten | Bedarf bestätigt | Präsentation eigenständig, ausgabespezifisch prüfbar; keine einzelne Shopvorschau zum zentralen Angebotseditor machen | | FACH-15 | Mehrere Präsentationsformen: ausführliche Produktseite, Kacheln mit Kurzangaben und weitere Ansichten | Bedarf bestätigt | Präsentation eigenständig, ausgabespezifisch prüfbar; keine einzelne Shopvorschau zum zentralen Angebotseditor machen |
| FACH-16 | Präsentation speist sich hauptsächlich aus Beschreibungen des jeweiligen Einzelprodukts, etwa Programm, Modul oder Sammlung | Bedarf bestätigt; Detailauflösung abzugleichen | Quelle und wirksamen Text erkennbar machen. Bei mehreren Produkten keine automatische gemeinsame Beschreibung unterstellen | | FACH-16 | Präsentation speist sich hauptsächlich aus Beschreibungen des jeweiligen Einzelprodukts, etwa Programm, Modul oder Sammlung | Bedarf bestätigt; Detailauflösung abzugleichen | Quelle und wirksamen Text erkennbar machen. Bei mehreren Produkten keine automatische gemeinsame Beschreibung unterstellen |
| FACH-17 | Beschreibungen sollen überarbeitbar bleiben | Bedarf bestätigt; Geltungsbereich je Änderung prüfen | Eigene Abweichung, Produktangabe und ausgabespezifische Formulierung verständlich unterscheiden; Rückkehr zur Quelle gestalterisch berücksichtigen | | FACH-17 | Beschreibungen sollen überarbeitbar bleiben | Bedarf bestätigt; Geltungsbereich je Änderung prüfen | Eigene Abweichung, Produktangabe und ausgabespezifische Formulierung verständlich unterscheiden; Rückkehr zur Quelle gestalterisch berücksichtigen |
+139
View File
@@ -282,3 +282,142 @@ @media (min-width: 48rem) {
justify-content: flex-end; justify-content: flex-end;
} }
} }
/* Verkaufsstart: Nutzerkreis, Rabattcode, Summen, Pflichtangaben und Zustimmungen */
.shop-licence {
margin: 0 0 var(--space-2);
}
.shop-draft {
padding: var(--space-3) var(--space-4);
border: 2px dashed var(--color-warning);
border-radius: var(--radius-card, 0.5rem);
background: var(--color-warning-surface);
color: var(--color-text);
}
.shop-badge-discount {
color: var(--color-success);
background: var(--color-success-surface);
}
.shop-roles {
display: grid;
gap: var(--space-2);
max-width: 40rem;
margin: 0 0 var(--space-5);
}
.shop-roles div {
display: grid;
gap: 0.15rem;
}
.shop-roles dt {
font-weight: 700;
}
.shop-roles dd {
margin: 0;
}
.shop-code,
.shop-pay,
.shop-legal {
max-width: 40rem;
margin: var(--space-5) 0;
}
.shop-code-row {
display: flex;
flex-wrap: wrap;
gap: var(--space-3);
align-items: stretch;
}
.shop-code-row input {
flex: 1 1 12rem;
min-height: 2.75rem;
padding: 0 var(--space-3);
border: 2px solid var(--color-border-strong);
border-radius: var(--radius-control, 0.4rem);
font: inherit;
text-transform: uppercase;
}
.shop-code-applied {
font-weight: 600;
}
.shop-total-table {
max-width: 32rem;
display: grid;
gap: var(--space-2);
}
.shop-total-table div {
display: flex;
justify-content: space-between;
gap: var(--space-4);
}
.shop-total-table dt,
.shop-total-table dd {
margin: 0;
}
.shop-total-final {
font-size: var(--text-h3);
padding-top: var(--space-2);
border-top: 1px solid var(--color-border-strong);
}
.shop-pay,
.shop-legal {
border: 0;
padding: 0;
}
.shop-pay legend,
.shop-legal legend {
font-weight: 700;
padding: 0;
margin-bottom: var(--space-3);
}
.shop-pay label,
.shop-consent {
display: flex;
gap: var(--space-3);
align-items: flex-start;
margin: 0 0 var(--space-3);
}
.shop-pay input,
.shop-consent input {
flex: none;
width: 1.35rem;
height: 1.35rem;
margin-top: 0.15rem;
}
.shop-legal-missing {
color: var(--color-danger);
font-weight: 600;
}
.mb-withdraw {
margin-top: var(--space-5);
max-width: 40rem;
}
.mb-withdraw summary {
cursor: pointer;
font-weight: 600;
}
.mb-withdraw textarea {
display: block;
width: 100%;
margin: var(--space-2) 0 var(--space-3);
}
@@ -2,7 +2,7 @@
Gemeinsame Katalog-Objektseite (Angebot, Paket, Rechteprofil): gemeinsamer Kopf, Hauptabschnitte links, Gemeinsame Katalog-Objektseite (Angebot, Paket, Rechteprofil): gemeinsamer Kopf, Hauptabschnitte links,
Begleitinformation rechts. Parameter: Begleitinformation rechts. Parameter:
kopf Parameter für filament.verwaltung.kopf kopf Parameter für filament.verwaltung.kopf
haupt Liste ['titel', 'zusatz' => kleiner Titelzusatz, 'hilfe', 'zeilen' => [['text', 'neben']], 'leer' => ['titel', 'text']] haupt Liste ['titel', 'zusatz' => kleiner Titelzusatz, 'hilfe', 'zeilen' => [['text', 'neben', 'aktion' => ['label', 'wire']]], 'leer' => ['titel', 'text']]
voraussetzungen optional: Ergebnis von PublicationReadiness, erscheint als „Bis zur Veröffentlichung“ über den Abschnitten voraussetzungen optional: Ergebnis von PublicationReadiness, erscheint als „Bis zur Veröffentlichung“ über den Abschnitten
seite Liste ['titel', 'zeilen' => [['text', 'zustand' => ['label', 'ton'], 'neben']], 'hilfe', 'leer' => Text] seite Liste ['titel', 'zeilen' => [['text', 'zustand' => ['label', 'ton'], 'neben']], 'hilfe', 'leer' => Text]
--}} --}}
@@ -28,7 +28,7 @@
@elseif (($abschnitt['zeilen'] ?? []) !== []) @elseif (($abschnitt['zeilen'] ?? []) !== [])
<ul class="vw-verwendungsliste"> <ul class="vw-verwendungsliste">
@foreach ($abschnitt['zeilen'] as $zeile) @foreach ($abschnitt['zeilen'] as $zeile)
<li><strong>{{ $zeile['text'] }}</strong>@if (filled($zeile['neben'] ?? null)) <span class="vw-feld-hilfe">{{ $zeile['neben'] }}</span>@endif</li> <li><strong>{{ $zeile['text'] }}</strong>@if (filled($zeile['neben'] ?? null)) <span class="vw-feld-hilfe">{{ $zeile['neben'] }}</span>@endif @if (! empty($zeile['aktion'])) <button type="button" class="vw-link is-quiet" wire:click="{{ $zeile['aktion']['wire'] }}">{{ $zeile['aktion']['label'] }}</button>@endif</li>
@endforeach @endforeach
</ul> </ul>
@endif @endif
@@ -0,0 +1,3 @@
<x-filament-panels::page>
@include('filament.catalog.objekt', $this->daten())
</x-filament-panels::page>
+30 -2
View File
@@ -1,4 +1,32 @@
Ihre Bestellung {{ $order->id }} ist bezahlt. Die dazugehörigen Inhalte liegen in der Bibliothek. Vertragsbestätigung zu Ihrer Bestellung {{ $order->id }}
Ihre Bestellung ist bezahlt. Die dazugehörigen Inhalte liegen in der Bibliothek.
Lizenzinhaber: {{ $order->party?->display_name }}
Bestellendes Konto (einziger Downloadzugriff aus dieser Bestellung): {{ $order->user?->name }}
Zahlungsweg: {{ $order->payment_method === 'rechnung' ? 'Überweisung auf Rechnung' : ($order->payment_method === 'stripe' ? 'Stripe' : 'Testzahlung') }}
@foreach ($order->lines as $line) @foreach ($order->lines as $line)
- {{ $line->offer_name }}: {{ number_format($line->price_cents / 100, 2, ',', '.') }} € - {{ $line->offer_name }}
Nutzerkreis: {{ \App\Domain\Catalog\LicenceScope::label($line->licence_scope, $line->trainer_count) }}
@if ($line->discount_cents > 0)
Preis: {{ number_format($line->price_cents / 100, 2, ',', '.') }} € abzüglich Rabatt {{ number_format($line->discount_cents / 100, 2, ',', '.') }} € = {{ number_format($line->payable() / 100, 2, ',', '.') }} €
@else
Preis: {{ number_format($line->price_cents / 100, 2, ',', '.') }} €
@endif
@endforeach @endforeach
@if ($order->discount_cents > 0)
Zwischensumme: {{ number_format($order->subtotal() / 100, 2, ',', '.') }} €
Rabattcode {{ $order->discount_snapshot['code'] ?? '' }}: −{{ number_format($order->discount_cents / 100, 2, ',', '.') }} €
@endif
Gezahlter Betrag: {{ number_format($order->payable() / 100, 2, ',', '.') }} €
@if ($order->terms_accepted_at)
Ihre Zustimmungen am {{ $order->terms_accepted_at->timezone(config('app.timezone'))->format('d.m.Y H:i') }} Uhr (Fassung {{ $order->terms_snapshot['version'] ?? '' }}):
@foreach (($order->terms_snapshot['consents'] ?? []) as $wording)
- {{ $wording }}
@endforeach
@endif
Die Inhalte wurden Ihnen sofort nach Zahlungseingang bereitgestellt. Hinweise zum Widerruf stehen in der Widerrufsbelehrung.
+5
View File
@@ -50,6 +50,11 @@
<a class="button button-secondary" href="{{ $entry['download_url'] }}"><x-heroicon-o-arrow-down-tray aria-hidden="true" /> Herunterladen</a> <a class="button button-secondary" href="{{ $entry['download_url'] }}"><x-heroicon-o-arrow-down-tray aria-hidden="true" /> Herunterladen</a>
@endif @endif
</div> </div>
@elseif ($entry['download_url'])
{{-- Lizenz nur zum Herunterladen (kein Streamen oder Ansehen): der Download bleibt erreichbar. --}}
<div class="mb-actions">
<a class="button" href="{{ $entry['download_url'] }}"><x-heroicon-o-arrow-down-tray aria-hidden="true" /> Herunterladen</a>
</div>
@else @else
<p class="mb-outline-locked">Nicht enthalten. Für diesen Teil liegt keine Freigabe vor.</p> <p class="mb-outline-locked">Nicht enthalten. Für diesen Teil liegt keine Freigabe vor.</p>
@endif @endif
+4
View File
@@ -102,7 +102,11 @@
@endif @endif
<div> <div>
<dt>Einzel- oder Mehrfachlizenz</dt> <dt>Einzel- oder Mehrfachlizenz</dt>
@if ($licence_scope)
<dd>{{ \App\Domain\Catalog\LicenceScope::label($licence_scope, $trainer_count) }}. {{ \App\Domain\Catalog\LicenceScope::explanation($licence_scope, $trainer_count) }} Lizenzinhaber ist {{ $holder_kind === 'organisation' ? 'die Organisation '.$holder : 'dein Konto' }}; Downloadzugriff hat das Konto, das bestellt hat.</dd>
@else
<dd>Nicht festgelegt. Die Lizenz enthält keine Angabe zur Nutzerzahl; sie gilt für {{ $holder_kind === 'organisation' ? 'die Organisation '.$holder : 'dein Konto' }}.</dd> <dd>Nicht festgelegt. Die Lizenz enthält keine Angabe zur Nutzerzahl; sie gilt für {{ $holder_kind === 'organisation' ? 'die Organisation '.$holder : 'dein Konto' }}.</dd>
@endif
</div> </div>
<div> <div>
<dt>Artikel</dt> <dt>Artikel</dt>
+49 -12
View File
@@ -5,14 +5,19 @@
@section('content') @section('content')
@php @php
$invoiceOrder = $order->payment_method === 'rechnung';
$paidWith = $invoiceOrder ? 'Überweisung auf Rechnung' : ($order->payment_method === 'stripe' ? 'Stripe' : 'Testzahlung');
$statusText = [ $statusText = [
'offen' => 'Offen. Die Testzahlung steht noch aus, Rechte gibt es erst nach bestätigter Zahlung.', 'offen' => $invoiceOrder
'bezahlt' => 'Bezahlt (Testzahlung). Die Inhalte liegen in der Bibliothek.', ? 'Offen. Wir erstellen die Rechnung manuell und senden sie dir. Rechte gibt es erst nach Zahlungseingang.'
'fehlgeschlagen' => 'Die Testzahlung wurde abgelehnt. Es wurde keine Berechtigung vergeben.', : 'Offen. Die Zahlung steht noch aus, Rechte gibt es erst nach bestätigter Zahlung.',
'bezahlt' => 'Bezahlt ('.$paidWith.'). Die Inhalte liegen in der Bibliothek.',
'fehlgeschlagen' => 'Die Zahlung wurde abgelehnt. Es wurde keine Berechtigung vergeben.',
'erstattet' => 'Erstattet. Die Berechtigungen dieser Bestellung sind widerrufen.', 'erstattet' => 'Erstattet. Die Berechtigungen dieser Bestellung sind widerrufen.',
][$order->status] ?? $order->status; ][$order->status] ?? $order->status;
$money = fn (?int $cents): string => \App\Domain\Commerce\Money::format($cents);
@endphp @endphp
<x-member.hero kicker="Testzahlung" :title="'Bestellung '.$order->id" /> <x-member.hero :kicker="$invoiceOrder ? 'Rechnung' : ($stripePayment ? 'Zahlung' : 'Testzahlung')" :title="'Bestellung '.$order->id" />
@if ($errors->any()) @if ($errors->any())
<div class="errors" role="alert">{{ $errors->first() }}</div> <div class="errors" role="alert">{{ $errors->first() }}</div>
@endif @endif
@@ -24,24 +29,40 @@
@endif @endif
<dl class="mb-dl mb-dl-cards"> <dl class="mb-dl mb-dl-cards">
<div><dt>Lizenzinhaber</dt><dd>{{ $order->party?->display_name }}</dd></div> <div><dt>Lizenzinhaber</dt><dd>{{ $order->party?->display_name }}</dd></div>
<div><dt>Bestellt von</dt><dd>{{ $order->user?->name }}</dd></div> <div><dt>Bestellt von (Konto mit Downloadzugriff)</dt><dd>{{ $order->user?->name }}</dd></div>
<div><dt>Zahlungsweg</dt><dd>{{ $paidWith }}</dd></div>
</dl> </dl>
<ul class="mb-offers"> <ul class="mb-offers">
@foreach ($order->lines as $line) @foreach ($order->lines as $line)
<li class="mb-offer"> <li class="mb-offer">
<h2>{{ filled($line->offer_name) ? $line->offer_name : ($line->offerVersion->offer->name ?? 'Angebot') }}</h2> <h2>{{ filled($line->offer_name) ? $line->offer_name : ($line->offerVersion->offer->name ?? 'Angebot') }}</h2>
<p>{{ \App\Domain\Commerce\Money::format($line->price_cents) }}</p> <p class="shop-licence"><strong>Nutzerkreis:</strong> {{ \App\Domain\Catalog\LicenceScope::label($line->licence_scope, $line->trainer_count) }}</p>
@if ($line->discount_cents > 0)
<p><s>{{ $money($line->price_cents) }}</s> {{ $money($line->payable()) }} <span class="shop-badge shop-badge-discount">Rabatt −{{ $money($line->discount_cents) }}</span></p>
@else
<p>{{ $money($line->price_cents) }}</p>
@endif
</li> </li>
@endforeach @endforeach
</ul> </ul>
<p class="state">Summe: {{ \App\Domain\Commerce\Money::format($order->total_cents ?? $order->lines->sum('price_cents')) }}</p> @if ($order->discount_cents > 0)
@if ($stripePayment && $order->status === 'offen') <dl class="mb-dl">
<div><dt>Zwischensumme</dt><dd>{{ $money($order->subtotal()) }}</dd></div>
<div><dt>Rabattcode</dt><dd>{{ $order->discount_snapshot['code'] ?? '' }}</dd></div>
<div><dt>Rabatt</dt><dd>−{{ $money($order->discount_cents) }}</dd></div>
</dl>
@endif
<p class="state">Zu zahlen: <strong>{{ $money($order->payable()) }}</strong></p>
@if ($order->terms_accepted_at)
<p class="mb-muted">Zustimmung zu Bedingungen und sofortiger Bereitstellung am {{ $order->terms_accepted_at->timezone(config('app.timezone'))->format('d.m.Y H:i') }} Uhr (Fassung {{ $order->terms_snapshot['version'] ?? '' }}).</p>
@endif
@if ($stripePayment && $order->status === 'offen' && ! $invoiceOrder)
<form method="post" action="{{ route('member.order.pay', $order) }}"> <form method="post" action="{{ route('member.order.pay', $order) }}">
@csrf @csrf
<button class="button" type="submit">Jetzt bezahlen (Stripe-Testmodus)</button> <button class="button" type="submit">{{ $live ? 'Jetzt bezahlen' : 'Jetzt bezahlen (Stripe-Testmodus)' }}</button>
</form> </form>
@endif @endif
@if ($testPayment && $order->status === 'offen') @if ($testPayment && $order->status === 'offen' && ! $invoiceOrder && $order->payment_method !== 'stripe')
<form method="post" action="{{ route('member.order.confirm', $order) }}"> <form method="post" action="{{ route('member.order.confirm', $order) }}">
@csrf @csrf
<button class="button" type="submit">Testzahlung bestätigen</button> <button class="button" type="submit">Testzahlung bestätigen</button>
@@ -53,11 +74,27 @@
@endif @endif
@if ($order->status === 'bezahlt') @if ($order->status === 'bezahlt')
<p><a class="button" href="{{ route('member.library') }}">Zur Bibliothek</a></p> <p><a class="button" href="{{ route('member.library') }}">Zur Bibliothek</a></p>
@if (! $stripePayment) @if (! $stripePayment && ! $invoiceOrder && ! app()->isProduction() && config('services.payment.driver') === 'test')
<form method="post" action="{{ route('member.order.refund', $order) }}"> <form method="post" action="{{ route('member.order.refund', $order) }}">
@csrf @csrf
<button class="button button-quiet" type="submit">Widerrufen</button> <button class="button button-quiet" type="submit">Widerrufen (Testzahlung)</button>
</form> </form>
@endif @endif
@endif @endif
@if (in_array($order->status, ['bezahlt', 'offen'], true) && ($stripePayment || $invoiceOrder))
@if ($order->withdrawal_requested_at)
<p class="state" role="status">Du hast den Widerruf am {{ $order->withdrawal_requested_at->timezone(config('app.timezone'))->format('d.m.Y') }} erklärt. Wir prüfen ihn und melden uns per E-Mail.</p>
@else
<details class="mb-withdraw">
<summary>Widerruf erklären</summary>
<form method="post" action="{{ route('member.order.withdraw', $order) }}">
@csrf
<p class="mb-muted">Mit dem Absenden erklärst du den Widerruf dieser Bestellung. Wir prüfen ihn und melden uns. Bei sofortiger Bereitstellung der digitalen Inhalte mit deiner ausdrücklichen Zustimmung kann das Widerrufsrecht erloschen sein; die Widerrufsbelehrung beschreibt das.</p>
<label for="widerruf-notiz">Anmerkung (freiwillig)</label>
<textarea id="widerruf-notiz" name="note" rows="3" maxlength="1000"></textarea>
<button class="button button-secondary" type="submit">Widerruf erklären</button>
</form>
</details>
@endif
@endif
@endsection @endsection
+21
View File
@@ -0,0 +1,21 @@
@extends('layouts.site')
@section('title', $bundle->name)
@section('content')
<p><a href="{{ route('shop') }}">Shop</a></p>
<h1>{{ $bundle->name }}</h1>
<p class="lede">Ein Paket mit {{ count($contents) }} {{ count($contents) === 1 ? 'Inhalt' : 'Inhalten' }}. Es wird nur zusammen gekauft.</p>
<section class="shop-package-contents" aria-labelledby="paket-umfang">
<h2 id="paket-umfang">Das ist im Paket enthalten</h2>
<ul class="shop-scope">
@foreach ($contents as $item)
<li>
<strong>{{ $item['title'] }}</strong>
@if ($item['teaser'] !== '')<span>{{ $item['teaser'] }}</span>@endif
</li>
@endforeach
</ul>
</section>
@include('shop.optionen', ['options' => $options, 'cart' => $cart, 'switchTo' => $switchTo])
@endsection
+11 -4
View File
@@ -34,6 +34,9 @@
<div class="shop-line-main"> <div class="shop-line-main">
<h2>{{ $line->title() }}</h2> <h2>{{ $line->title() }}</h2>
<p class="shop-line-option">{{ $line->offer->optionName() }}</p> <p class="shop-line-option">{{ $line->offer->optionName() }}</p>
@if ($line->version)
<p class="shop-licence"><strong>Nutzerkreis:</strong> {{ \App\Domain\Catalog\LicenceScope::label($line->version->licence_scope, $line->version->trainer_count) }}</p>
@endif
@if ($line->state === 'bereits_erworben') @if ($line->state === 'bereits_erworben')
<p class="shop-badge shop-badge-owned">Bereits erworben · Wird nicht mitbestellt</p> <p class="shop-badge shop-badge-owned">Bereits erworben · Wird nicht mitbestellt</p>
@@ -86,10 +89,14 @@
@endforeach @endforeach
</ul> </ul>
<div class="shop-total"> <dl class="shop-total shop-total-table">
<p><span>Summe</span> <strong>{{ \App\Domain\Commerce\Money::format($review->totalCents()) }}</strong></p> @if ($review->discountCents() > 0)
<p class="shop-note">Testzahlung. Es wird kein echtes Geld bewegt.</p> <div><dt>Zwischensumme</dt><dd>{{ \App\Domain\Commerce\Money::format($review->subtotalCents()) }}</dd></div>
</div> <div><dt>Rabatt ({{ $review->discount->code->code }})</dt><dd>−{{ \App\Domain\Commerce\Money::format($review->discountCents()) }}</dd></div>
@endif
<div class="shop-total-final"><dt>{{ $review->discountCents() > 0 ? 'Zu zahlen' : 'Summe' }}</dt><dd><strong>{{ \App\Domain\Commerce\Money::format($review->totalCents()) }}</strong></dd></div>
</dl>
<p class="shop-note">{{ config('shop.price_note') }} Einen Rabattcode gibst du in der Bestellübersicht ein.</p>
@if ($review->blocked()) @if ($review->blocked())
<p class="shop-note" role="status">Entferne die Positionen, die nicht bestellt werden können, oder wähle einen passenden Lizenzinhaber. Die übrigen Positionen bleiben bestellbar.</p> <p class="shop-note" role="status">Entferne die Positionen, die nicht bestellt werden können, oder wähle einen passenden Lizenzinhaber. Die übrigen Positionen bleiben bestellbar.</p>
+122 -19
View File
@@ -3,11 +3,21 @@
@section('title', 'Bestellübersicht') @section('title', 'Bestellübersicht')
@section('content') @section('content')
@php
$money = fn (?int $cents): string => \App\Domain\Commerce\Money::format($cents);
$live = \App\Domain\Commerce\Shop::live();
$missingLegal = \App\Domain\Commerce\SalesTerms::missingPages();
$holderQuery = array_filter(['bestellen_als' => $review->holder?->id]);
@endphp
<h1>Bestellübersicht</h1> <h1>Bestellübersicht</h1>
<p class="lede">Prüfe deine Bestellung. Preis und Bedingungen gelten so, wie sie hier stehen. Bezahlt wird im nächsten Schritt mit der Testzahlung.</p> <p class="lede">Prüfe deine Bestellung. Preis und Bedingungen gelten so, wie sie hier stehen.</p>
@if ($errors->any()) @unless ($live)
<p class="errors" role="alert">{{ $errors->first() }}</p> <p class="shop-note shop-draft" role="note">Testbetrieb: Es wird kein echtes Geld bewegt. Rechtstexte und Steuerangaben sind noch nicht freigegeben.</p>
@endunless
@if ($errors->has('checkout') || $errors->has('zustimmung'))
<p class="errors" role="alert">{{ $errors->first('checkout') ?: $errors->first('zustimmung') }}</p>
@endif @endif
@if ($holders->count() > 1) @if ($holders->count() > 1)
@@ -20,20 +30,29 @@
</select> </select>
<button class="button button-secondary" type="submit">Übernehmen</button> <button class="button button-secondary" type="submit">Übernehmen</button>
</form> </form>
@elseif ($review->holder)
<p>Lizenzinhaber: <strong>{{ $review->holder->display_name }}</strong></p>
@endif @endif
@if ($review->holder?->type->value === 'organisation') @if ($review->holder)
<p class="shop-note">Der Verein ist Lizenzinhaber. Herunterladen kann nur dieses Konto, das die Bestellung auslöst.</p> <dl class="shop-roles">
<div><dt>Lizenzinhaber</dt><dd>{{ $review->holder->display_name }}@if ($review->holder->type->value === 'organisation') (Verein oder Organisation)@endif</dd></div>
<div><dt>Bestellendes Konto</dt><dd>{{ auth()->user()->name }}</dd></div>
<div><dt>Downloadzugriff aus dieser Bestellung</dt><dd>@if ($review->holder->type->value === 'organisation')Nur dieses Konto, nicht weitere Mitglieder des Vereins.@else Dieses Konto.@endif</dd></div>
</dl>
@endif @endif
<ul class="shop-lines shop-order-summary"> <ul class="shop-lines shop-order-summary">
@foreach ($review->lines as $line) @foreach ($review->lines as $line)
@php
$lineDiscount = $review->discountFor($line);
$licence = $line->version ? \App\Domain\Catalog\LicenceScope::label($line->version->licence_scope, $line->version->trainer_count) : null;
@endphp
<li @class(['shop-line', 'is-owned' => $line->state === 'bereits_erworben', 'is-blocked' => $line->blocks()])> <li @class(['shop-line', 'is-owned' => $line->state === 'bereits_erworben', 'is-blocked' => $line->blocks()])>
<div class="shop-line-main"> <div class="shop-line-main">
<h2>{{ $line->title() }}</h2> <h2>{{ $line->title() }}</h2>
<p class="shop-line-option">{{ $line->offer->optionName() }}</p> <p class="shop-line-option">{{ $line->offer->optionName() }}</p>
@if ($licence)
<p class="shop-licence"><strong>Nutzerkreis:</strong> {{ $licence }}</p>
@endif
@if ($line->state === 'bereits_erworben') @if ($line->state === 'bereits_erworben')
<p class="shop-badge shop-badge-owned">Bereits erworben · Wird nicht mitbestellt</p> <p class="shop-badge shop-badge-owned">Bereits erworben · Wird nicht mitbestellt</p>
@elseif ($line->blocks()) @elseif ($line->blocks())
@@ -41,45 +60,129 @@
<p class="shop-note">{{ $line->note }}</p> <p class="shop-note">{{ $line->note }}</p>
@elseif ($line->state === 'preis_geaendert') @elseif ($line->state === 'preis_geaendert')
<p class="shop-badge shop-badge-changed">Preis geändert</p> <p class="shop-badge shop-badge-changed">Preis geändert</p>
<p class="shop-note">Bisher {{ \App\Domain\Commerce\Money::format($line->seenPriceCents) }}, jetzt {{ \App\Domain\Commerce\Money::format($line->currentPriceCents) }}.</p> <p class="shop-note">Bisher {{ $money($line->seenPriceCents) }}, jetzt {{ $money($line->currentPriceCents) }}.</p>
@elseif ($line->state === 'bedingungen_geaendert') @elseif ($line->state === 'bedingungen_geaendert')
<p class="shop-badge shop-badge-changed">Bedingungen aktualisiert</p> <p class="shop-badge shop-badge-changed">Bedingungen aktualisiert</p>
<p class="shop-note">{{ $line->note }}</p> <p class="shop-note">{{ $line->note }}</p>
@endif @endif
@if ($lineDiscount > 0)
<p class="shop-badge shop-badge-discount">Rabatt {{ $review->discount->code->code }}: −{{ $money($lineDiscount) }}</p>
@endif
</div> </div>
<div class="shop-line-side"> <div class="shop-line-side">
@if ($line->currentPriceCents !== null) @if ($line->currentPriceCents !== null)
<p @class(['shop-price', 'is-struck' => $line->state === 'bereits_erworben'])><span class="sr-only">Preis: </span>{{ \App\Domain\Commerce\Money::format($line->currentPriceCents) }}</p> <p @class(['shop-price', 'is-struck' => $line->state === 'bereits_erworben'])>
@if ($lineDiscount > 0)
<s class="shop-price-old"><span class="sr-only">Listenpreis: </span>{{ $money($line->currentPriceCents) }}</s>
<span class="sr-only">Preis nach Rabatt: </span>{{ $money($line->currentPriceCents - $lineDiscount) }}
@else
<span class="sr-only">Preis: </span>{{ $money($line->currentPriceCents) }}
@endif
</p>
@endif @endif
</div> </div>
</li> </li>
@endforeach @endforeach
</ul> </ul>
<div class="shop-total"> <section class="shop-code" aria-labelledby="shop-code-title">
<p><span>Summe</span> <strong>{{ \App\Domain\Commerce\Money::format($review->totalCents()) }}</strong></p> <h2 id="shop-code-title">Rabattcode</h2>
<p class="shop-note">Testzahlung. Es wird kein echtes Geld bewegt.</p> @if ($review->discount?->applied())
<p class="shop-code-applied" role="status">
<strong>{{ $review->discount->code->code }}</strong> ist angewendet
({{ $review->discount->code->valueLabel() }}{{ $review->discount->code->forSelection() ? ', gilt nur für ausgewählte Angebote' : '' }}).
</p>
<form method="post" action="{{ route('checkout.code.remove') }}">
@csrf
@if ($review->holder)<input type="hidden" name="bestellen_als" value="{{ $review->holder->id }}">@endif
<button class="button button-quiet" type="submit">Code entfernen</button>
</form>
@else
@if ($review->discount !== null)
<p class="errors" role="alert">Der Code {{ $review->discount->code?->code }} gilt gerade nicht. {{ $review->discount->message }}</p>
<form method="post" action="{{ route('checkout.code.remove') }}">
@csrf
@if ($review->holder)<input type="hidden" name="bestellen_als" value="{{ $review->holder->id }}">@endif
<button class="button button-secondary" type="submit">Code entfernen</button>
</form>
@endif
<form class="shop-code-form" method="post" action="{{ route('checkout.code') }}">
@csrf
@if ($review->holder)<input type="hidden" name="bestellen_als" value="{{ $review->holder->id }}">@endif
<label for="rabattcode">{{ $review->discount !== null ? 'Anderen Code eingeben' : 'Hast du einen Rabattcode?' }}</label>
<div class="shop-code-row">
<input id="rabattcode" name="code" type="text" autocomplete="off" autocapitalize="characters" spellcheck="false" maxlength="60" aria-describedby="rabattcode-hinweis @error('code') rabattcode-fehler @enderror" value="{{ old('code') }}">
<button class="button button-secondary" type="submit">Code einlösen</button>
</div> </div>
@error('code')
<p class="errors" id="rabattcode-fehler" role="alert">{{ $message }}</p>
@enderror
<p class="shop-note" id="rabattcode-hinweis">Pro Bestellung gilt höchstens ein Code. Er ändert den Preis, nicht den Nutzungsumfang.</p>
</form>
@endif
</section>
<dl class="shop-total shop-total-table">
@if ($review->discountCents() > 0)
<div><dt>Zwischensumme</dt><dd>{{ $money($review->subtotalCents()) }}</dd></div>
<div><dt>Rabatt ({{ $review->discount->code->code }})</dt><dd>−{{ $money($review->discountCents()) }}</dd></div>
@endif
<div class="shop-total-final"><dt>Zu zahlen</dt><dd><strong>{{ $money($review->totalCents()) }}</strong></dd></div>
</dl>
<p class="shop-note">{{ config('shop.price_note') }}</p>
<div class="shop-actions">
@if ($review->canOrder()) @if ($review->canOrder())
<form method="post" action="{{ route('checkout.place') }}"> <form class="shop-order-form" method="post" action="{{ route('checkout.place') }}">
@csrf @csrf
<input type="hidden" name="digest" value="{{ $review->digest() }}"> <input type="hidden" name="digest" value="{{ $review->digest() }}">
@if ($review->holder)<input type="hidden" name="bestellen_als" value="{{ $review->holder->id }}">@endif @if ($review->holder)<input type="hidden" name="bestellen_als" value="{{ $review->holder->id }}">@endif
<button class="button" type="submit">Bestellung anlegen</button>
</form> @if ($invoice)
@else <fieldset class="shop-pay">
<button class="button" type="button" disabled aria-disabled="true">Bestellung anlegen</button> <legend>Zahlungsweg</legend>
<label><input type="radio" name="zahlungsweg" value="online" @checked(old('zahlungsweg', 'online') === 'online')> {{ \App\Domain\Commerce\Shop::stripe() ? 'Online bezahlen (Stripe)' : 'Testzahlung' }}</label>
<label><input type="radio" name="zahlungsweg" value="rechnung" @checked(old('zahlungsweg') === 'rechnung')> Auf Rechnung (Überweisung, auf Anfrage)</label>
<p class="shop-note">Bei Rechnung erstellen wir die Rechnung manuell und senden sie dir. Die Inhalte werden nach Zahlungseingang freigeschaltet.</p>
</fieldset>
@endif @endif
<fieldset class="shop-legal">
<legend>Dein Vertrag</legend>
<p class="shop-note">
Bitte lies vor dem Bestellen:
@foreach ($legalPages as $key => $page)
@php $url = \App\Domain\Commerce\SalesTerms::url($key); @endphp
@if ($url)<a href="{{ $url }}" target="_blank" rel="noopener">{{ $page['label'] }}</a>@else<span class="shop-legal-missing">{{ $page['label'] }} (noch nicht veröffentlicht)</span>@endif{{ $loop->last ? '.' : ',' }}
@endforeach
</p>
@foreach ($consents as $key => $wording)
<label class="shop-consent">
<input type="checkbox" name="zustimmung[{{ $key }}]" value="1" required @checked(old('zustimmung.'.$key))>
<span>{{ $wording }}</span>
</label>
@endforeach
@unless ($live)
<p class="shop-note shop-draft">Entwurf: Der Wortlaut der Zustimmungen ist noch nicht rechtlich geprüft.@if ($missingLegal !== []) Es fehlen veröffentlichte Seiten: {{ implode(', ', $missingLegal) }}.@endif</p>
@endunless
</fieldset>
<div class="shop-actions">
<button class="button" type="submit">{{ \App\Domain\Commerce\SalesTerms::ORDER_BUTTON }}</button>
<a class="button button-secondary" href="{{ route('cart') }}">Zurück zum Warenkorb</a>
</div>
</form>
@else
<div class="shop-actions">
<button class="button" type="button" disabled aria-disabled="true">{{ \App\Domain\Commerce\SalesTerms::ORDER_BUTTON }}</button>
<a class="button button-secondary" href="{{ route('cart') }}">Zurück zum Warenkorb</a> <a class="button button-secondary" href="{{ route('cart') }}">Zurück zum Warenkorb</a>
</div> </div>
@if (! $review->canOrder())
<p class="shop-note" role="status"> <p class="shop-note" role="status">
@if ($review->holder === null) @if ($review->holder === null)
Für diesen Lizenzinhaber kannst du nicht bestellen. Wähle oben einen anderen Lizenzinhaber oder bestelle als Privatperson. Für diesen Lizenzinhaber kannst du nicht bestellen. Wähle oben einen anderen Lizenzinhaber oder bestelle als Privatperson.
@elseif ($review->blocked()) @elseif ($review->blocked())
Entferne zuerst die Positionen, die nicht bestellt werden können, oder wähle einen passenden Lizenzinhaber. Entferne zuerst die Positionen, die nicht bestellt werden können, oder wähle einen passenden Lizenzinhaber.
@elseif ($review->discountBlocks())
Entferne den Rabattcode oder ändere den Warenkorb, damit er passt. Erst dann kannst du bestellen.
@else @else
Es gibt nichts zu bestellen. Alle Positionen sind bereits erworben. Es gibt nichts zu bestellen. Alle Positionen sind bereits erworben.
@endif @endif
+2 -2
View File
@@ -4,7 +4,7 @@
@section('content') @section('content')
<h1>Shop</h1> <h1>Shop</h1>
<p class="lede">Hier findest du kaufbare Programme. Jede Kachel öffnet die Produktseite mit Inhalt und den verfügbaren Lizenzoptionen.</p> <p class="lede">Hier findest du kaufbare Programme und Pakete. Jede Kachel öffnet die Produktseite mit Inhalt und den verfügbaren Lizenzoptionen.</p>
<form class="shop-search" method="get" action="{{ route('shop') }}" role="search"> <form class="shop-search" method="get" action="{{ route('shop') }}" role="search">
<label for="shop-suche">Shop durchsuchen</label> <label for="shop-suche">Shop durchsuchen</label>
@@ -25,7 +25,7 @@
<ul class="shop-tiles"> <ul class="shop-tiles">
@foreach ($cards as $card) @foreach ($cards as $card)
<li class="shop-tile"> <li class="shop-tile">
<h2><a href="{{ route('public.program', $card['composition']) }}">{{ $card['title'] }}</a></h2> <h2><a href="{{ $card['url'] }}">{{ $card['title'] }}</a></h2>
@if ($card['teaser'] !== '')<p>{{ $card['teaser'] }}</p>@endif @if ($card['teaser'] !== '')<p>{{ $card['teaser'] }}</p>@endif
<p class="shop-tile-price">ab {{ $card['from'] }} · {{ $card['count'] }} {{ $card['count'] === 1 ? 'Lizenzoption' : 'Lizenzoptionen' }}</p> <p class="shop-tile-price">ab {{ $card['from'] }} · {{ $card['count'] }} {{ $card['count'] === 1 ? 'Lizenzoption' : 'Lizenzoptionen' }}</p>
</li> </li>
+5 -1
View File
@@ -25,7 +25,7 @@
@csrf @csrf
<button class="button" type="submit">Zu „{{ $wanted['name'] }}“ wechseln</button> <button class="button" type="submit">Zu „{{ $wanted['name'] }}“ wechseln</button>
</form> </form>
<a class="button button-secondary" href="{{ route('public.program', $wanted['offer']->composition_id) }}">Bei „{{ $current->optionName() }}“ bleiben</a> <a class="button button-secondary" href="{{ app(\App\Domain\Commerce\ProductOptions::class)->pageUrl($wanted['offer']) }}">Bei „{{ $current->optionName() }}“ bleiben</a>
</div> </div>
</div> </div>
@endif @endif
@@ -39,7 +39,11 @@
<dl class="shop-facts"> <dl class="shop-facts">
<div><dt>Geeignet für</dt><dd>{{ $option['for'] }}</dd></div> <div><dt>Geeignet für</dt><dd>{{ $option['for'] }}</dd></div>
<div><dt>Laufzeit</dt><dd>{{ $option['term'] }}</dd></div> <div><dt>Laufzeit</dt><dd>{{ $option['term'] }}</dd></div>
<div><dt>Nutzerkreis</dt><dd>{{ $option['licence'] }}</dd></div>
</dl> </dl>
@if ($option['licence_note'])
<p class="shop-note">{{ $option['licence_note'] }}</p>
@endif
<h4>Umfang und Nutzungsrechte</h4> <h4>Umfang und Nutzungsrechte</h4>
<ul class="shop-scope"> <ul class="shop-scope">
@foreach ($option['scope'] as $item) @foreach ($option['scope'] as $item)
+4
View File
@@ -26,6 +26,7 @@
Route::get('/themen', [ThemeController::class, 'index'])->name('themes'); Route::get('/themen', [ThemeController::class, 'index'])->name('themes');
Route::get('/programme', [PublicCatalogController::class, 'index'])->name('public.programs'); Route::get('/programme', [PublicCatalogController::class, 'index'])->name('public.programs');
Route::get('/programme/{composition}', [PublicCatalogController::class, 'program'])->name('public.program'); Route::get('/programme/{composition}', [PublicCatalogController::class, 'program'])->name('public.program');
Route::get('/pakete/{bundle}', [PublicCatalogController::class, 'package'])->whereNumber('bundle')->name('public.package');
Route::get('/themen/{slug}', [ThemeController::class, 'show'])->name('theme')->where('slug', '[a-z0-9]+(?:-[a-z0-9]+)*'); Route::get('/themen/{slug}', [ThemeController::class, 'show'])->name('theme')->where('slug', '[a-z0-9]+(?:-[a-z0-9]+)*');
Route::get('/medien/{path}', [PublicMediaController::class, 'show'])->where('path', '.*')->name('media.public'); Route::get('/medien/{path}', [PublicMediaController::class, 'show'])->where('path', '.*')->name('media.public');
Route::get('/website-medien/{element}', [WebsiteMediaController::class, 'show'])->whereNumber('element')->name('website.media'); Route::get('/website-medien/{element}', [WebsiteMediaController::class, 'show'])->whereNumber('element')->name('website.media');
@@ -41,6 +42,8 @@
Route::middleware(['auth', 'verified'])->group(function () { Route::middleware(['auth', 'verified'])->group(function () {
Route::get('/kasse', [CheckoutController::class, 'checkout'])->name('checkout'); Route::get('/kasse', [CheckoutController::class, 'checkout'])->name('checkout');
Route::post('/kasse', [CheckoutController::class, 'placeOrder'])->name('checkout.place'); Route::post('/kasse', [CheckoutController::class, 'placeOrder'])->name('checkout.place');
Route::post('/kasse/rabattcode', [CheckoutController::class, 'applyCode'])->name('checkout.code');
Route::post('/kasse/rabattcode/entfernen', [CheckoutController::class, 'removeCode'])->name('checkout.code.remove');
}); });
}); });
@@ -141,6 +144,7 @@
Route::post('/bestellung/{order}/bestaetigen', [CheckoutController::class, 'confirm'])->name('order.confirm'); Route::post('/bestellung/{order}/bestaetigen', [CheckoutController::class, 'confirm'])->name('order.confirm');
Route::post('/bestellung/{order}/ablehnen', [CheckoutController::class, 'fail'])->name('order.fail'); Route::post('/bestellung/{order}/ablehnen', [CheckoutController::class, 'fail'])->name('order.fail');
Route::post('/bestellung/{order}/widerrufen', [CheckoutController::class, 'refund'])->name('order.refund'); Route::post('/bestellung/{order}/widerrufen', [CheckoutController::class, 'refund'])->name('order.refund');
Route::post('/bestellung/{order}/widerruf-erklaeren', [CheckoutController::class, 'withdraw'])->name('order.withdraw');
Route::get('/profil', [ProfileController::class, 'show'])->name('profile'); Route::get('/profil', [ProfileController::class, 'show'])->name('profile');
Route::post('/profil', [ProfileController::class, 'updateName'])->name('profile.update'); Route::post('/profil', [ProfileController::class, 'updateName'])->name('profile.update');
Route::post('/profil/email', [ProfileController::class, 'requestEmail'])->middleware('throttle:6,1')->name('profile.email'); Route::post('/profil/email', [ProfileController::class, 'requestEmail'])->middleware('throttle:6,1')->name('profile.email');
+1 -1
View File
@@ -385,7 +385,7 @@ public function test_changing_an_offer_keeps_terms_the_mask_does_not_show(): voi
Livewire::actingAs($this->keeper(), 'staff') Livewire::actingAs($this->keeper(), 'staff')
->test(ViewOffer::class, ['record' => $offer->getKey()]) ->test(ViewOffer::class, ['record' => $offer->getKey()])
->mountAction('activate') ->mountAction('activate')
->fillForm(['price_euro' => '12,00']) ->fillForm(['price_euro' => '12,00', 'licence_scope' => 'einzel'])
->callMountedAction() ->callMountedAction()
->assertHasNoFormErrors() ->assertHasNoFormErrors()
->assertSee('Fassung 2 aktiv · Kauf · 12,00 €'); ->assertSee('Fassung 2 aktiv · Kauf · 12,00 €');
+134
View File
@@ -0,0 +1,134 @@
<?php
namespace Tests\Feature;
use App\Domain\Catalog\Bundle;
use App\Domain\Catalog\DomainRuleException;
use App\Domain\Catalog\Offer;
use App\Domain\Catalog\OfferService;
use App\Domain\Commerce\Cart;
use App\Domain\Commerce\CartLine;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\Support\BuildsShop;
use Tests\TestCase;
/**
* Ein eigenständig vermarktetes Paket hat eine eigene Produktseite, die seinen tatsächlichen Umfang zeigt, statt auf
* der Seite eines fremden Programms zu hängen.
*/
class BundleProductPageTest extends TestCase
{
use BuildsShop;
use RefreshDatabase;
protected function setUp(): void
{
parent::setUp();
$this->seedShop();
}
private function bundle(): Bundle
{
return Bundle::query()->where('name', 'Starterpaket')->firstOrFail();
}
private function standaloneOffer(string $name, int $cents, string $scope = 'einzel', ?int $trainers = null): Offer
{
$version = $this->bundle()->versions()->firstOrFail();
$rights = app(OfferService::class)->currentActiveVersion($this->privateKonflikte())->lines()->first()->rights;
$offers = app(OfferService::class);
$offer = $offers->create($name);
$offers->assignProduct($offer, null, $name, true);
$offers->activate($offer, [['target' => $version, 'rights' => $rights]], [
'grant_kind' => 'kauf', 'price_cents' => $cents, 'holder_kind' => 'person', 'licence_scope' => $scope, 'trainer_count' => $trainers,
]);
return $offer->refresh();
}
public function test_the_package_page_shows_what_the_package_actually_contains(): void
{
$this->standaloneOffer('Starterpaket solo', 5500);
$this->get(route('public.package', $this->bundle()))
->assertOk()
->assertSee('Starterpaket')
->assertSee('Das ist im Paket enthalten')
->assertSee('Konflikte im Training')
->assertSee('Grenzen setzen im Verein')
->assertSee('Starterpaket für neue Trainer')
->assertSee('Ein Paket mit 3 Inhalten')
->assertSee('55,00 €')
->assertSee('Einzellizenz · 1 Trainer')
->assertSee('In den Warenkorb');
}
public function test_the_shop_lists_the_package_with_its_contents_and_finds_it_by_a_content_name(): void
{
$this->standaloneOffer('Starterpaket solo', 5500);
$this->get(route('shop'))->assertOk()
->assertSee(route('public.package', $this->bundle()), false)
->assertSee('Paket mit 3 Inhalten')
->assertSee('ab 55,00 €');
$this->get(route('shop', ['suche' => 'Grenzen setzen']))->assertSee(route('public.package', $this->bundle()), false);
$this->get(route('shop', ['suche' => 'gibtesnicht']))->assertDontSee(route('public.package', $this->bundle()), false);
}
public function test_the_package_offer_is_added_under_the_package_name_and_alternatives_need_a_switch(): void
{
$first = $this->standaloneOffer('Starterpaket Einzel', 5500);
$second = $this->standaloneOffer('Starterpaket Mehrfach', 9900, 'mehrfach', 3);
$tina = $this->tina();
$this->actingAs($tina)->post(route('cart.add', $first))->assertRedirect(route('public.package', $this->bundle()));
$this->post(route('cart.add', $second))->assertSessionHas('shop.switch', $second->id);
$cart = app(Cart::class);
$review = $cart->review($tina);
$this->assertSame(CartLine::OK, $review->lines[0]->state);
$this->assertSame('Starterpaket', $review->lines[0]->title());
$this->assertSame($first->id, $cart->alternativeTo($second)?->id);
$this->post(route('cart.switch', $second))->assertRedirect(route('cart'));
$this->get(route('cart'))->assertSee('Mehrfachlizenz · bis zu 3 Trainer')->assertDontSee('Starterpaket Einzel');
}
public function test_the_package_page_is_gone_without_a_purchasable_option(): void
{
$offer = $this->standaloneOffer('Starterpaket solo', 5500);
$this->get(route('public.package', $this->bundle()))->assertOk();
app(OfferService::class)->end($offer);
$this->get(route('public.package', $this->bundle()))->assertNotFound();
$this->get(route('shop'))->assertDontSee(route('public.package', $this->bundle()), false);
}
public function test_an_offer_with_an_own_package_page_consists_of_exactly_one_package_version(): void
{
$offers = app(OfferService::class);
$offer = $offers->create('Falsch');
$offers->assignProduct($offer, null, 'Falsch', true);
$rights = $offers->currentActiveVersion($this->privateKonflikte())->lines()->first()->rights;
$this->expectException(DomainRuleException::class);
$offers->activate($offer, [['target' => $this->article('shop-konflikte'), 'rights' => $rights]], ['grant_kind' => 'kauf', 'price_cents' => 1000]);
}
public function test_a_package_has_either_an_own_page_or_a_program_page(): void
{
$offer = app(OfferService::class)->create('Beides');
$this->expectException(DomainRuleException::class);
app(OfferService::class)->assignProduct($offer, $this->program('Konflikte im Training')->id, 'Beides', true);
}
public function test_the_package_page_does_not_exist_outside_the_shop(): void
{
$this->standaloneOffer('Starterpaket solo', 5500);
$this->app['env'] = 'production';
$this->get(route('public.package', $this->bundle()))->assertNotFound();
}
}
+7 -6
View File
@@ -3,6 +3,7 @@
namespace Tests\Feature; namespace Tests\Feature;
use App\Domain\Catalog\CompositionVersionDisplayEvent; use App\Domain\Catalog\CompositionVersionDisplayEvent;
use App\Domain\Catalog\LicenceScope;
use App\Domain\Catalog\Offer; use App\Domain\Catalog\Offer;
use App\Domain\Catalog\OfferService; use App\Domain\Catalog\OfferService;
use App\Domain\Commerce\Cart; use App\Domain\Commerce\Cart;
@@ -146,7 +147,7 @@ public function test_a_change_after_the_overview_was_shown_creates_no_order_and_
$this->reprice($offer, 3500); $this->reprice($offer, 3500);
$this->actingAs($tina) $this->actingAs($tina)
->post(route('checkout.place'), ['digest' => $shown]) ->post(route('checkout.place'), ['digest' => $shown, ...$this->consentFields()])
->assertRedirect(route('checkout')) ->assertRedirect(route('checkout'))
->assertSessionHasErrors('checkout'); ->assertSessionHasErrors('checkout');
@@ -172,7 +173,7 @@ public function test_a_withdrawn_position_stays_visible_blocks_the_order_and_lea
->assertSee('Nicht mehr erhältlich') ->assertSee('Nicht mehr erhältlich')
->assertSee('Konflikte im Training') ->assertSee('Konflikte im Training')
->assertSee('Entferne die Positionen, die nicht bestellt werden können'); ->assertSee('Entferne die Positionen, die nicht bestellt werden können');
$this->post(route('checkout.place'), ['digest' => $review->digest()])->assertSessionHasErrors('checkout'); $this->post(route('checkout.place'), ['digest' => $review->digest(), ...$this->consentFields()])->assertSessionHasErrors('checkout');
$this->assertSame(0, Order::query()->count()); $this->assertSame(0, Order::query()->count());
$cart->remove($withdrawn); $cart->remove($withdrawn);
@@ -217,7 +218,7 @@ public function test_when_everything_is_already_owned_the_checkout_stays_blocked
$this->assertTrue($review->empty()); $this->assertTrue($review->empty());
$this->assertFalse($review->canOrder()); $this->assertFalse($review->canOrder());
$this->actingAs($tina)->get(route('cart'))->assertSee('Es gibt nichts zu bestellen'); $this->actingAs($tina)->get(route('cart'))->assertSee('Es gibt nichts zu bestellen');
$this->actingAs($tina)->post(route('checkout.place'), ['digest' => $review->digest()])->assertSessionHasErrors('checkout'); $this->actingAs($tina)->post(route('checkout.place'), ['digest' => $review->digest(), ...$this->consentFields()])->assertSessionHasErrors('checkout');
$this->assertSame(1, Order::query()->count(), 'Nur die Vorbestellung existiert.'); $this->assertSame(1, Order::query()->count(), 'Nur die Vorbestellung existiert.');
} }
@@ -293,7 +294,7 @@ public function test_the_rights_order_does_not_matter_when_comparing_owned_scope
]); ]);
$this->ownByPurchase($tina, $this->privateGrenzen()); $this->ownByPurchase($tina, $this->privateGrenzen());
$same = $offers->create('Grenzen gleiche Rechte'); $same = $offers->create('Grenzen gleiche Rechte');
$offers->activate($same, [['target' => $this->article('shop-grenzen'), 'rights' => $reordered]], ['grant_kind' => 'kauf', 'price_cents' => 1900]); $offers->activate($same, [['target' => $this->article('shop-grenzen'), 'rights' => $reordered]], ['grant_kind' => 'kauf', 'price_cents' => 1900, 'licence_scope' => LicenceScope::SINGLE]);
$cart = app(Cart::class); $cart = app(Cart::class);
$cart->add($same); $cart->add($same);
@@ -310,7 +311,7 @@ public function test_free_grants_and_manual_grants_count_as_owned_but_expired_or
'pdf' => ['ansehen', 'laden'], 'pdf' => ['ansehen', 'laden'],
]); ]);
$free = $offers->create('Grenzen gratis'); $free = $offers->create('Grenzen gratis');
$offers->activate($free, [['target' => $this->article('shop-grenzen'), 'rights' => $rights]], ['grant_kind' => 'auf_abruf']); $offers->activate($free, [['target' => $this->article('shop-grenzen'), 'rights' => $rights]], ['grant_kind' => 'auf_abruf', 'licence_scope' => LicenceScope::SINGLE]);
$acquisition = app(GrantIssuer::class)->claim($tina, $free); $acquisition = app(GrantIssuer::class)->claim($tina, $free);
$cart = app(Cart::class); $cart = app(Cart::class);
@@ -333,7 +334,7 @@ public function test_the_cart_survives_login_and_the_checkout_is_reached_in_the_
$this->post('/anmelden', ['email' => 'tina.trainerin@example.test', 'password' => ShopDemoSeeder::PASSWORD]) $this->post('/anmelden', ['email' => 'tina.trainerin@example.test', 'password' => ShopDemoSeeder::PASSWORD])
->assertRedirect(route('checkout')); ->assertRedirect(route('checkout'));
$this->get(route('checkout'))->assertOk()->assertSee('Konflikte im Training')->assertSee('Bestellung anlegen'); $this->get(route('checkout'))->assertOk()->assertSee('Konflikte im Training')->assertSee('Zahlungspflichtig bestellen');
} }
public function test_the_cart_survives_registration_and_email_confirmation(): void public function test_the_cart_survives_registration_and_email_confirmation(): void
+366
View File
@@ -0,0 +1,366 @@
<?php
namespace Tests\Feature;
use App\Domain\Catalog\Bundle;
use App\Domain\Catalog\DomainRuleException;
use App\Domain\Commerce\Cart;
use App\Domain\Commerce\Checkout;
use App\Domain\Commerce\Discount\DiscountCode;
use App\Domain\Commerce\Discount\DiscountRelease;
use App\Domain\Commerce\Discount\DiscountResult;
use App\Domain\Commerce\Discount\DiscountService;
use App\Domain\Commerce\Order;
use App\Domain\Commerce\StaleOverview;
use App\Models\User;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\Support\BuildsShop;
use Tests\TestCase;
/**
* Rabattcodes (PAY-008, FACH-14): Geltungsbereich und Einlösungsberechtigung sind unabhängig, die Prüfung läuft
* serverseitig bei der Einlösung und erneut vor Bestellabschluss, der Rabatt bleibt in der Bestellung nachvollziehbar.
*/
class DiscountCodeTest extends TestCase
{
use BuildsShop;
use RefreshDatabase;
protected function setUp(): void
{
parent::setUp();
$this->seedShop();
$this->travelTo('2026-11-24 10:00:00');
}
/**
* @param array<string, mixed> $data
* @param list<array{type: string, id: int}> $targets
*/
private function code(string $code, array $data = [], array $targets = []): DiscountCode
{
return app(DiscountService::class)->save([
'code' => $code,
'label' => 'Test '.$code,
'kind' => DiscountCode::PERCENT,
'percent' => 10,
'scope' => DiscountCode::SCOPE_CART,
'eligibility' => DiscountCode::OPEN,
'active' => true,
...$data,
], $targets);
}
private function release(DiscountCode $code, User $member): DiscountRelease
{
return app(DiscountService::class)->release($code, $member, $this->vera(), null, 'Zertifikat geprüft');
}
private function cartFor(User $user, array $offers, ?string $code = null): Cart
{
$cart = app(Cart::class);
$cart->clear();
foreach ($offers as $offer) {
$cart->add($offer);
}
if ($code !== null) {
$cart->applyCode($code, $user);
}
return $cart;
}
public function test_a_general_code_reduces_the_whole_cart(): void
{
$this->code('SOMMER10');
$tina = $this->tina();
$cart = $this->cartFor($tina, [$this->privateKonflikte(), $this->privateGrenzen()], 'sommer10');
$review = $cart->review($tina);
$this->assertSame(7800, $review->subtotalCents());
$this->assertSame(780, $review->discountCents());
$this->assertSame(7020, $review->totalCents());
$order = app(Checkout::class)->placeFromCart($tina, $cart, null, $review->digest());
$this->assertSame(7800, $order->subtotal_cents);
$this->assertSame(780, $order->discount_cents);
$this->assertSame(7020, $order->total_cents);
$this->assertSame('SOMMER10', $order->discount_snapshot['code']);
$this->assertSame([490, 290], $order->lines->pluck('discount_cents')->all());
$this->assertSame([4900, 2900], $order->lines->pluck('price_cents')->all(), 'Die Listenpreise bleiben unverändert gespeichert.');
$this->assertSame(0, app(Cart::class)->count());
$this->assertNull(session(Cart::DISCOUNT_KEY), 'Der Code gehört zur Bestellung und ist danach aus dem Warenkorb entfernt.');
}
public function test_an_item_specific_code_reduces_only_the_selected_position_in_a_mixed_cart(): void
{
$konflikte = $this->privateKonflikte();
$this->code('NURKONFLIKT', targets: [['type' => DiscountCode::TARGET_OFFER, 'id' => $konflikte->id]], data: ['scope' => DiscountCode::SCOPE_SELECTED]);
$tina = $this->tina();
$cart = $this->cartFor($tina, [$konflikte, $this->privateGrenzen()], 'NURKONFLIKT');
$review = $cart->review($tina);
$this->assertSame(490, $review->discountCents());
$this->assertSame(490, $review->discountFor($review->lines[0]));
$this->assertSame(0, $review->discountFor($review->lines[1]), 'Die nicht gewählte Position bleibt zum Listenpreis.');
$this->assertSame(7310, $review->totalCents());
}
public function test_a_license_article_target_does_not_make_a_bundle_containing_it_discountable_and_vice_versa(): void
{
$article = $this->article('shop-konflikte');
$bundle = Bundle::query()->where('name', 'Starterpaket')->firstOrFail();
$tina = $this->tina();
$this->code('ARTIKEL', ['scope' => DiscountCode::SCOPE_SELECTED], [['type' => DiscountCode::TARGET_ARTICLE, 'id' => $article->id]]);
$cart = $this->cartFor($tina, [$this->privateKonflikte(), $this->starter()], 'ARTIKEL');
$review = $cart->review($tina);
$this->assertSame(490, $review->discountCents(), 'Zehn Prozent nur auf das Angebot, dessen Position der Artikel selbst ist.');
$this->assertSame(0, $review->discountFor($review->lines[1]), 'Das Starterpaket enthält den Artikel, ist aber nicht als Ziel gewählt.');
$this->code('PAKET', ['scope' => DiscountCode::SCOPE_SELECTED], [['type' => DiscountCode::TARGET_BUNDLE, 'id' => $bundle->id]]);
$cart = $this->cartFor($tina, [$this->privateKonflikte(), $this->starter()], 'PAKET');
$review = $cart->review($tina);
$this->assertSame(0, $review->discountFor($review->lines[0]), 'Der enthaltene Artikel wird durch ein Paketziel nicht rabattfähig.');
$this->assertSame(590, $review->discountFor($review->lines[1]));
}
public function test_a_restricted_code_works_repeatedly_for_a_released_account_only(): void
{
$x = $this->code('ZERT', ['eligibility' => DiscountCode::RESTRICTED, 'percent' => 20]);
$this->release($x, $this->tina());
$first = $this->orderWithCode($this->tina(), 'ZERT');
$second = $this->orderWithCode($this->tina(), 'ZERT');
$this->assertSame(980, $first->discount_cents);
$this->assertSame(980, $second->discount_cents, 'Das freigeschaltete Konto löst den Code bei späteren Bestellungen erneut ein.');
$result = $this->cartFor($this->max(), [$this->privateKonflikte()])->applyCode('ZERT', $this->max());
$this->assertSame(DiscountResult::NO_RELEASE, $result->state);
$this->assertStringContainsString('nicht freigeschaltet', (string) $result->message);
$this->assertSame(0, app(Cart::class)->review($this->max())->discountCents(), 'Wer den Code kennt, aber keine Freigabe hat, erhält keinen Rabatt.');
}
public function test_a_release_for_one_code_does_not_entitle_to_another_code(): void
{
$x = $this->code('CODEX', ['eligibility' => DiscountCode::RESTRICTED]);
$y = $this->code('CODEY', ['eligibility' => DiscountCode::RESTRICTED]);
$tina = $this->tina();
$this->release($x, $tina);
$this->cartFor($tina, [$this->privateKonflikte()]);
$this->assertTrue(app(Cart::class)->applyCode('CODEX', $tina)->applied());
$blocked = app(Cart::class)->applyCode('CODEY', $tina);
$this->assertSame(DiscountResult::NO_RELEASE, $blocked->state);
$this->assertSame($x->id, app(Cart::class)->discountCode()?->id, 'Der abgelehnte zweite Code ändert den bisherigen nicht.');
$this->release($y, $tina);
$this->assertTrue(app(Cart::class)->applyCode('CODEY', $tina)->applied());
$this->assertSame($y->id, app(Cart::class)->discountCode()?->id, 'Pro Bestellung gilt höchstens ein Code: der zweite ersetzt den ersten.');
}
public function test_a_revoked_release_stops_the_discount_and_keeps_the_history(): void
{
$code = $this->code('ZERT', ['eligibility' => DiscountCode::RESTRICTED]);
$release = $this->release($code, $this->tina());
$this->assertTrue($this->cartFor($this->tina(), [$this->privateKonflikte()])->applyCode('ZERT', $this->tina())->applied());
app(DiscountService::class)->revoke($release, $this->vera(), 'Zertifikat abgelaufen');
$review = app(Cart::class)->review($this->tina());
$this->assertSame(DiscountResult::NO_RELEASE, $review->discount?->state);
$this->assertSame(0, $review->discountCents());
$this->assertTrue($review->discountBlocks());
$this->assertFalse($review->canOrder(), 'Ein vorgemerkter Code, der nicht mehr gilt, hält die Bestellung an.');
$this->assertNotNull($release->fresh()->revoked_at);
$this->assertSame($this->vera()->id, $release->fresh()->revoked_by);
$this->assertSame(1, DiscountRelease::query()->count(), 'Freigaben werden nie gelöscht.');
$this->assertSame(DiscountResult::NO_RELEASE, app(Cart::class)->applyCode('ZERT', $this->tina())->state);
}
public function test_a_release_can_have_an_end_date_and_cannot_be_granted_twice_or_for_an_open_code(): void
{
$code = $this->code('BEFRISTET', ['eligibility' => DiscountCode::RESTRICTED]);
$service = app(DiscountService::class);
$service->release($code, $this->tina(), $this->vera(), now()->addDays(2));
$this->assertTrue($this->cartFor($this->tina(), [$this->privateKonflikte()])->applyCode('BEFRISTET', $this->tina())->applied());
$this->travelTo(now()->addDays(3));
$this->assertSame(DiscountResult::NO_RELEASE, app(Cart::class)->review($this->tina())->discount?->state);
$this->expectException(DomainRuleException::class);
$service->release($this->code('OFFEN'), $this->tina(), $this->vera());
}
public function test_an_expired_deactivated_or_not_yet_valid_code_explains_itself(): void
{
$tina = $this->tina();
$this->code('ALT', ['valid_until' => '2026-11-20']);
$this->code('AUS', ['active' => false]);
$this->code('SPAETER', ['valid_from' => '2026-12-01']);
$cart = $this->cartFor($tina, [$this->privateKonflikte()]);
$expired = $cart->applyCode('ALT', $tina);
$this->assertSame(DiscountResult::EXPIRED, $expired->state);
$this->assertStringContainsString('abgelaufen', (string) $expired->message);
$this->assertStringContainsString('20.11.2026', (string) $expired->message);
$this->assertSame(DiscountResult::INACTIVE, $cart->applyCode('AUS', $tina)->state);
$this->assertStringContainsString('01.12.2026', (string) $cart->applyCode('SPAETER', $tina)->message);
$this->assertSame(DiscountResult::UNKNOWN, $cart->applyCode('GIBTESNICHT', $tina)->state);
$this->assertNull($cart->discountCode());
}
public function test_a_code_that_matches_no_position_says_so(): void
{
$this->code('NURGRENZEN', ['scope' => DiscountCode::SCOPE_SELECTED], [['type' => DiscountCode::TARGET_OFFER, 'id' => $this->privateGrenzen()->id]]);
$tina = $this->tina();
$cart = $this->cartFor($tina, [$this->privateKonflikte()]);
$result = $cart->applyCode('NURGRENZEN', $tina);
$this->assertSame(DiscountResult::NO_MATCH, $result->state);
$this->assertStringContainsString('keines davon liegt in deiner Bestellung', (string) $result->message);
}
public function test_an_owned_position_is_not_discounted_and_does_not_count_as_a_match(): void
{
$tina = $this->tina();
$order = $this->orderOf($tina, [$this->privateKonflikte()]);
app(Checkout::class)->confirmTestPayment($order, 'test-own');
$this->code('NURKONFLIKT', ['scope' => DiscountCode::SCOPE_SELECTED], [['type' => DiscountCode::TARGET_OFFER, 'id' => $this->privateKonflikte()->id]]);
$result = $this->cartFor($tina, [$this->privateKonflikte(), $this->privateGrenzen()])->applyCode('NURKONFLIKT', $tina);
$this->assertSame(DiscountResult::NO_MATCH, $result->state, 'Die bereits erworbene Position geht nicht in die Bestellung ein.');
}
public function test_a_revoked_release_between_overview_and_order_creates_no_order(): void
{
$code = $this->code('ZERT', ['eligibility' => DiscountCode::RESTRICTED]);
$release = $this->release($code, $this->tina());
$tina = $this->tina();
$cart = $this->cartFor($tina, [$this->privateKonflikte()], 'ZERT');
$shown = $cart->review($tina)->digest();
app(DiscountService::class)->revoke($release, $this->vera());
try {
app(Checkout::class)->placeFromCart($tina, $cart, null, $shown);
$this->fail('Die Bestellung zum rabattierten Preis darf nicht entstehen.');
} catch (StaleOverview) {
$this->assertSame(0, Order::query()->count());
}
}
public function test_a_code_deactivated_between_overview_and_order_creates_no_order(): void
{
$code = $this->code('SOMMER10');
$tina = $this->tina();
$cart = $this->cartFor($tina, [$this->privateKonflikte()], 'SOMMER10');
$shown = $cart->review($tina)->digest();
app(DiscountService::class)->setActive($code, false);
$this->expectException(StaleOverview::class);
app(Checkout::class)->placeFromCart($tina, $cart, null, $shown);
}
public function test_a_blocked_code_must_be_removed_before_ordering_at_full_price(): void
{
$code = $this->code('SOMMER10');
$tina = $this->tina();
$cart = $this->cartFor($tina, [$this->privateKonflikte()], 'SOMMER10');
app(DiscountService::class)->setActive($code, false);
$review = $cart->review($tina);
$this->assertFalse($review->canOrder());
$this->expectException(DomainRuleException::class);
app(Checkout::class)->placeFromCart($tina, $cart, null, $review->digest());
}
public function test_the_discount_may_not_push_the_payable_amount_below_the_payment_minimum(): void
{
$this->code('GRATIS', ['percent' => 100]);
$tina = $this->tina();
$result = $this->cartFor($tina, [$this->privateGrenzen()])->applyCode('GRATIS', $tina);
$this->assertSame(DiscountResult::TOO_HIGH, $result->state);
$this->assertStringContainsString('0,50 €', (string) $result->message);
}
public function test_the_checkout_page_applies_and_removes_a_code_and_shows_the_discount_and_payable_amount(): void
{
$this->code('SOMMER10');
$tina = $this->tina();
$this->actingAs($tina)->post(route('cart.add', $this->privateKonflikte()));
$this->post(route('checkout.code'), ['code' => 'sommer10'])->assertRedirect(route('checkout'));
$this->get(route('checkout'))
->assertOk()
->assertSee('SOMMER10')
->assertSee('Zwischensumme')
->assertSee('−4,90 €')
->assertSee('44,10 €')
->assertSee('Code entfernen');
$this->post(route('checkout.code.remove'))->assertRedirect(route('checkout'));
$this->get(route('checkout'))->assertOk()->assertDontSee('Zwischensumme')->assertSee('49,00 €');
$this->post(route('checkout.code'), ['code' => 'GIBTESNICHT'])->assertSessionHasErrors('code');
$this->post(route('checkout.code'), ['code' => ''])->assertSessionHasErrors('code');
}
public function test_the_checkout_page_explains_a_missing_release_in_plain_words(): void
{
$this->code('ZERT', ['eligibility' => DiscountCode::RESTRICTED]);
$this->actingAs($this->max())->post(route('cart.add', $this->privateKonflikte()));
$response = $this->post(route('checkout.code'), ['code' => 'ZERT'])->assertSessionHasErrors('code');
$this->assertStringContainsString('nicht freigeschaltet', $response->getSession()->get('errors')->first('code'));
$this->get(route('checkout'))->assertOk()->assertSee('49,00 €')->assertDontSee('Zwischensumme');
}
public function test_codes_are_validated_when_saved(): void
{
$service = app(DiscountService::class);
$base = ['label' => 'x', 'kind' => 'prozent', 'percent' => 10, 'scope' => 'warenkorb', 'eligibility' => 'allgemein'];
foreach ([
['code' => 'a b'],
['code' => 'OK1', 'label' => ''],
['code' => 'OK1', 'percent' => 0],
['code' => 'OK1', 'percent' => 101],
['code' => 'OK1', 'kind' => 'betrag', 'amount_euro' => '0'],
['code' => 'OK1', 'scope' => 'auswahl'],
['code' => 'OK1', 'valid_from' => '2026-12-01', 'valid_until' => '2026-11-01'],
] as $override) {
try {
$service->save([...$base, ...$override], []);
$this->fail('Ungültige Angaben müssen abgewiesen werden: '.json_encode($override));
} catch (DomainRuleException) {
$this->assertSame(0, DiscountCode::query()->count());
}
}
$service->save([...$base, 'code' => 'ok1'], []);
$this->expectException(DomainRuleException::class);
$service->save([...$base, 'code' => 'OK1'], []);
}
private function orderWithCode(User $user, string $code): Order
{
$cart = $this->cartFor($user, [$this->privateKonflikte()], $code);
return app(Checkout::class)->placeFromCart($user, $cart, null, $cart->review($user)->digest());
}
}
+142
View File
@@ -0,0 +1,142 @@
<?php
namespace Tests\Feature;
use App\Domain\Catalog\ArticleService;
use App\Domain\Catalog\ContentService;
use App\Domain\Catalog\LicenseArticle;
use App\Domain\Catalog\Offer;
use App\Domain\Catalog\OfferService;
use App\Domain\Commerce\Checkout;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Support\Facades\Storage;
use Tests\Support\BuildsShop;
use Tests\TestCase;
/**
* Startangebote: Ein einzeln gekaufter Film und ein tatsächlich herunterladbares Begleit-PDF sind mit passender
* Lizenz aus der Bibliothek erreichbar (Verkaufsstart, Download-Befunde der Etappe 1).
*/
class LibraryDownloadTest extends TestCase
{
use BuildsShop;
use RefreshDatabase;
protected function setUp(): void
{
parent::setUp();
$this->seedShop();
}
/**
* Ein Artikel aus genau einem Medium samt Angebot mit den gewünschten Rechten.
*
* @param array<string, list<string>> $capabilities
* @return array{0: LicenseArticle, 1: Offer}
*/
private function singleMedium(string $class, string $title, string $file, string $body, array $capabilities): array
{
Storage::disk('media_derived')->put($file, $body);
$content = app(ContentService::class);
$element = $content->createElement($class, $class, $title);
$element->description = 'Beschreibung '.$title;
$element->save();
$version = $content->publishElementVersion($element, null, ['file' => $file]);
$articles = app(ArticleService::class);
$article = $articles->create('einzel-'.$class.'-'.count($capabilities).'-'.md5($title), 'Testkauf');
$article->working_title = $title;
$article->save();
$articles->publishRelease($article, $version, 'Einzelmedium.');
$offers = app(OfferService::class);
$rights = $offers->createRightsProfile('Rechte '.$title, 'ehrenamtlich', $capabilities);
$offer = $offers->create('Einzelkauf '.$title);
$offers->activate($offer, [['target' => $article->fresh(), 'rights' => $rights]], [
'grant_kind' => 'kauf', 'price_cents' => 1200, 'holder_kind' => 'person', 'licence_scope' => 'einzel',
]);
return [$article->fresh(), $offer];
}
private function buy(Offer $offer): void
{
$order = $this->orderOf($this->tina(), [$offer]);
app(Checkout::class)->confirmTestPayment($order, 'test-dl-'.$offer->id);
}
public function test_a_single_film_is_in_the_library_and_downloads_with_its_title_as_file_name(): void
{
[$article, $offer] = $this->singleMedium('film', 'Lara im Park', 'inhalte/einzel/film.mp4', 'FILMINHALT', ['film' => ['streamen', 'laden']]);
$this->buy($offer);
$this->actingAs($this->tina())->get(route('member.library'))->assertOk()->assertSee('Lara im Park')->assertSee(route('member.article', $article), false);
$this->get(route('member.article', $article))->assertOk()->assertSee('Herunterladen');
$link = $this->downloadUrl($article);
$this->assertNotSame('', $link, 'Der Film bietet „Herunterladen“.');
$download = $this->get($link);
$download->assertOk();
$this->assertStringContainsString('attachment', (string) $download->headers->get('Content-Disposition'));
$this->assertStringContainsString('Lara im Park.mp4', rawurldecode((string) $download->headers->get('Content-Disposition')));
$this->assertSame('FILMINHALT', $download->streamedContent());
}
public function test_a_single_film_with_download_only_rights_offers_the_download_and_no_dead_end(): void
{
[$article, $offer] = $this->singleMedium('film', 'Nur Download', 'inhalte/einzel/nur.mp4', 'NURDOWNLOAD', ['film' => ['laden']]);
$this->buy($offer);
$this->actingAs($this->tina())->get(route('member.article', $article))
->assertOk()
->assertSee('Herunterladen')
->assertDontSee('Nicht enthalten. Für diesen Teil liegt keine Freigabe vor.');
}
public function test_a_companion_pdf_downloads_as_a_real_pdf_with_view_and_download_decided_separately(): void
{
[$article, $offer] = $this->singleMedium('pdf', 'Begleitmaterial Abstand', 'inhalte/einzel/material.pdf', "%PDF-1.4\n%Abstand\n%%EOF\n", ['pdf' => ['ansehen', 'laden']]);
$this->buy($offer);
$page = $this->actingAs($this->tina())->get(route('member.article', $article))->assertOk()->assertSee('Ansehen')->assertSee('Herunterladen');
preg_match_all('/href="([^"]+)"/', $page->getContent(), $links);
$download = collect($links[1])->map(fn (string $href): string => html_entity_decode($href))->first(fn (string $href): bool => str_contains($href, '/laden?'));
$this->assertNotNull($download, 'Das PDF bietet einen Downloadlink.');
$response = $this->get($download)->assertOk();
$this->assertStringContainsString('attachment', (string) $response->headers->get('Content-Disposition'));
$this->assertStringContainsString('Begleitmaterial Abstand.pdf', rawurldecode((string) $response->headers->get('Content-Disposition')));
$this->assertStringStartsWith('%PDF-1.4', $response->streamedContent());
}
public function test_a_pdf_without_the_download_right_shows_no_download(): void
{
[$article, $offer] = $this->singleMedium('pdf', 'Nur ansehen', 'inhalte/einzel/ansehen.pdf', "%PDF-1.4\n%A\n%%EOF\n", ['pdf' => ['ansehen']]);
$this->buy($offer);
$this->actingAs($this->tina())->get(route('member.article', $article))->assertOk()->assertSee('Ansehen')->assertDontSee('Herunterladen');
}
public function test_the_download_needs_payment_and_the_buying_account(): void
{
[$article, $offer] = $this->singleMedium('film', 'Gesperrt', 'inhalte/einzel/gesperrt.mp4', 'GESPERRT', ['film' => ['streamen', 'laden']]);
$order = $this->orderOf($this->tina(), [$offer]);
$this->actingAs($this->tina())->get(route('member.article', $article))->assertOk()->assertDontSee('Herunterladen');
app(Checkout::class)->confirmTestPayment($order, 'test-lock');
$this->get(route('member.article', $article))->assertSee('Herunterladen');
$url = $this->downloadUrl($article);
auth()->logout();
$this->actingAs($this->max())->get($url)->assertForbidden();
$this->actingAs($this->max())->get(route('member.article', $article))->assertDontSee('Herunterladen');
}
private function downloadUrl(LicenseArticle $article): string
{
$page = $this->get(route('member.article', $article));
preg_match_all('/href="([^"]+)"/', $page->getContent(), $links);
return (string) collect($links[1])->map(fn (string $href): string => html_entity_decode($href))->first(fn (string $href): bool => str_contains($href, '/laden?'));
}
}
+221
View File
@@ -0,0 +1,221 @@
<?php
namespace Tests\Feature;
use App\Domain\Catalog\ArticleService;
use App\Domain\Catalog\BundleService;
use App\Domain\Catalog\DomainRuleException;
use App\Domain\Catalog\LicenceScope;
use App\Domain\Catalog\Offer;
use App\Domain\Catalog\OfferService;
use App\Domain\Commerce\Cart;
use App\Domain\Commerce\CartLine;
use App\Domain\Commerce\Checkout;
use App\Domain\Entitlement\Acquisition;
use App\Domain\Entitlement\Grant;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\Support\BuildsShop;
use Tests\TestCase;
/**
* Einzel- und Mehrfachlizenz: Der Nutzerkreis gehört zur Lizenzoption, wird mit der Bestellung festgehalten und ist
* getrennt von Lizenzinhaber, Nutzungszweck, Preis und Downloadzugriff.
*/
class LicenceScopeTest extends TestCase
{
use BuildsShop;
use RefreshDatabase;
protected function setUp(): void
{
parent::setUp();
$this->seedShop();
}
/**
* Eine weitere Option mit denselben Positionen und Rechten wie die Quelle.
*
* @param array<string, mixed> $attributes
*/
private function variant(Offer $source, string $name, array $attributes): Offer
{
$active = app(OfferService::class)->currentActiveVersion($source);
$lines = $active->lines()->with('article', 'bundleVersion', 'rights')->get()->map(fn ($line): array => [
'target' => $line->article ?? $line->bundleVersion,
'rights' => $line->rights,
])->all();
$offer = app(OfferService::class)->create($name);
app(OfferService::class)->activate($offer, $lines, [
'grant_kind' => 'kauf',
'price_cents' => 4900,
'holder_kind' => $active->holder_kind,
...$attributes,
]);
$offer->update(['composition_id' => $source->composition_id]);
return $offer->refresh();
}
public function test_the_scope_is_validated_when_a_version_is_activated(): void
{
$source = $this->privateKonflikte();
foreach ([
['licence_scope' => 'einzel', 'trainer_count' => 3],
['licence_scope' => 'mehrfach', 'trainer_count' => 1],
['licence_scope' => 'mehrfach', 'trainer_count' => null],
['licence_scope' => 'mehrfach', 'trainer_count' => 100000],
['licence_scope' => null, 'trainer_count' => 4],
['licence_scope' => 'gruppe', 'trainer_count' => 2],
] as $attributes) {
try {
$this->variant($source, 'Ungültig', $attributes);
$this->fail('Ungültiger Nutzerkreis muss abgewiesen werden: '.json_encode($attributes));
} catch (DomainRuleException) {
$this->assertNull(Offer::query()->where('name', 'Ungültig')->first()?->versions()->where('status', 'aktiv')->first());
}
}
}
public function test_a_single_license_always_means_exactly_one_trainer(): void
{
$offer = $this->variant($this->privateKonflikte(), 'Einzel ohne Zahl', ['licence_scope' => 'einzel']);
$version = app(OfferService::class)->currentActiveVersion($offer);
$this->assertSame('einzel', $version->licence_scope);
$this->assertSame(1, $version->trainer_count);
}
public function test_the_scope_is_not_derived_from_purpose_price_or_discount(): void
{
$institutional = app(OfferService::class)->currentActiveVersion($this->clubKonflikte())->lines()->first()->rights;
$this->assertSame('institutionell', $institutional->purpose);
$single = $this->variant($this->clubKonflikte(), 'Institutionell, ein Trainer', ['licence_scope' => 'einzel', 'holder_kind' => 'organisation', 'price_cents' => 99900]);
$legacy = $this->variant($this->privateGrenzen(), 'Ohne Angabe', ['price_cents' => 1900]);
$this->assertSame('Einzellizenz · 1 Trainer', LicenceScope::label($single->versions()->first()->licence_scope, $single->versions()->first()->trainer_count));
$this->assertNull($legacy->versions()->first()->licence_scope, 'Ohne Angabe bleibt es ohne Angabe, auch bei anderem Preis oder Zweck.');
$this->assertNull($legacy->versions()->first()->trainer_count);
}
public function test_the_product_page_tells_single_and_multi_licenses_apart(): void
{
$page = $this->program('Konflikte im Training');
$this->variant($this->privateKonflikte(), 'Ohne Angabe', ['price_cents' => 1900]);
$this->get(route('public.program', $page))
->assertOk()
->assertSee('Nutzerkreis')
->assertSee('Einzellizenz · 1 Trainer')
->assertSee('Mehrfachlizenz · bis zu 5 Trainer')
->assertSee('Die Inhalte dürfen von einem Trainer eingesetzt werden.')
->assertSee('Die Inhalte dürfen von bis zu 5 Trainern eingesetzt werden.')
->assertSee('Nutzerkreis nicht festgelegt');
}
public function test_cart_checkout_and_order_show_the_scope_and_keep_the_agreed_one(): void
{
$tina = $this->tina();
$offer = $this->privateKonflikte();
$this->actingAs($tina)->post(route('cart.add', $offer));
$this->get(route('cart'))->assertSee('Einzellizenz · 1 Trainer');
$this->get(route('checkout'))->assertSee('Einzellizenz · 1 Trainer');
$order = $this->orderOf($tina, [$offer]);
$line = $order->lines->first();
$this->assertSame('einzel', $line->licence_scope);
$this->assertSame(1, $line->trainer_count);
app(Checkout::class)->confirmTestPayment($order, 'test-scope');
$conditions = Acquisition::query()->where('reference_type', 'order_line')->firstOrFail()->conditions;
$this->assertSame('einzel', $conditions['licence_scope']);
$this->assertSame(1, $conditions['trainer_count']);
// Eine spätere Fassung mit anderem Nutzerkreis ändert den gekauften Umfang nicht.
$lines = app(OfferService::class)->currentActiveVersion($offer)->lines()->with('article', 'rights')->get()->map(fn ($l): array => ['target' => $l->article, 'rights' => $l->rights])->all();
app(OfferService::class)->activate($offer, $lines, ['grant_kind' => 'kauf', 'price_cents' => 4900, 'licence_scope' => 'mehrfach', 'trainer_count' => 3]);
$this->assertSame('einzel', $line->fresh()->licence_scope);
$this->assertSame('einzel', Acquisition::query()->where('reference_type', 'order_line')->firstOrFail()->conditions['licence_scope']);
$this->get(route('member.order', $order))->assertOk()->assertSee('Einzellizenz · 1 Trainer')->assertDontSee('bis zu 3 Trainer');
}
public function test_a_club_purchase_keeps_the_club_as_holder_and_only_the_ordering_account_downloads(): void
{
$vera = $this->vera();
$order = $this->orderOf($vera, [$this->clubKonflikte()], $this->club()->id);
app(Checkout::class)->confirmTestPayment($order, 'test-club');
$order = $order->fresh(['lines']);
$this->assertSame($this->club()->id, $order->party_id, 'Lizenzinhaber ist der Verein.');
$this->assertSame($vera->id, $order->user_id, 'Das bestellende Konto bleibt davon getrennt festgehalten.');
$this->assertSame('mehrfach', $order->lines->first()->licence_scope);
$this->assertSame(5, $order->lines->first()->trainer_count);
$acquisition = Acquisition::query()->where('reference_type', 'order_line')->firstOrFail();
$this->assertSame($this->club()->id, $acquisition->party_id);
$this->assertSame($vera->id, $acquisition->acting_user_id);
$this->assertSame(5, $acquisition->conditions['trainer_count']);
$this->assertSame(1, Acquisition::query()->count(), 'Eine Mehrfachlizenz erzeugt zum Start keine weiteren Downloadkonten.');
$this->assertTrue(Grant::query()->usableBy($vera)->exists());
$this->assertFalse(Grant::query()->usableBy($this->max())->exists());
$this->assertFalse(Grant::query()->usableBy($this->tina())->exists());
$this->actingAs($vera)->get(route('member.order', $order))->assertOk()
->assertSee('Testverein Musterstadt e. V.')
->assertSee('Mehrfachlizenz · bis zu 5 Trainer');
}
public function test_an_owned_single_license_does_not_cover_a_multi_license_with_the_same_rights(): void
{
$tina = $this->tina();
$owned = $this->privateKonflikte();
$order = $this->orderOf($tina, [$owned]);
app(Checkout::class)->confirmTestPayment($order, 'test-own');
$multi = $this->variant($owned, 'Konflikte Mehrfach 3', ['licence_scope' => 'mehrfach', 'trainer_count' => 3]);
$single = $this->variant($owned, 'Konflikte Einzel nochmal', ['licence_scope' => 'einzel']);
$cart = app(Cart::class);
$cart->clear();
$cart->add($multi);
$this->assertSame(CartLine::OK, $cart->review($tina)->lines[0]->state, 'Eine Einzellizenz macht eine Mehrfachlizenz nicht zur „bereits erworben“.');
$cart->clear();
$cart->add($single);
$this->assertSame(CartLine::OWNED, $cart->review($tina)->lines[0]->state);
}
public function test_an_offer_without_published_content_cannot_be_activated(): void
{
$empty = app(ArticleService::class)->create('leer-ohne-stand');
$rights = app(OfferService::class)->currentActiveVersion($this->privateKonflikte())->lines()->first()->rights;
$offers = app(OfferService::class);
$offer = $offers->create('Ohne Inhalt');
try {
$offers->activate($offer, [['target' => $empty, 'rights' => $rights]], ['grant_kind' => 'kauf', 'price_cents' => 1000]);
$this->fail('Ein Artikel ohne veröffentlichten Stand darf nicht verkauft werden.');
} catch (DomainRuleException $exception) {
$this->assertStringContainsString('leer-ohne-stand', $exception->getMessage());
$this->assertStringContainsString('keinen veröffentlichten Stand', $exception->getMessage());
}
$bundles = app(BundleService::class);
$bundle = $bundles->publish($bundles->create('Leeres Paket'), [$empty]);
try {
$offers->activate($offer, [['target' => $bundle, 'rights' => $rights]], ['grant_kind' => 'kauf', 'price_cents' => 1000]);
$this->fail('Auch ein Paket mit einem Artikel ohne Stand darf nicht verkauft werden.');
} catch (DomainRuleException) {
$this->assertSame(0, $offer->versions()->count(), 'Es entsteht keine halbe Fassung.');
}
$offers->activate($offer, [['target' => $this->article('shop-konflikte'), 'rights' => $rights]], ['grant_kind' => 'kauf', 'price_cents' => 1000]);
$this->assertSame(1, $offer->versions()->count());
}
}
+2 -2
View File
@@ -273,11 +273,11 @@ public function test_the_checkout_page_places_the_order_through_the_http_flow():
$this->actingAs($tina)->post(route('cart.add', $this->privateKonflikte())); $this->actingAs($tina)->post(route('cart.add', $this->privateKonflikte()));
$this->post(route('cart.add', $this->privateGrenzen())); $this->post(route('cart.add', $this->privateGrenzen()));
$page = $this->get(route('checkout'))->assertOk()->assertSee('Summe')->assertSee('78,00 €'); $page = $this->get(route('checkout'))->assertOk()->assertSee('Zu zahlen')->assertSee('78,00 €');
preg_match('/name="digest" value="([a-f0-9]{64})"/', $page->getContent(), $match); preg_match('/name="digest" value="([a-f0-9]{64})"/', $page->getContent(), $match);
$this->assertNotEmpty($match); $this->assertNotEmpty($match);
$this->post(route('checkout.place'), ['digest' => $match[1]])->assertRedirect(route('member.order', Order::query()->latest('id')->first() ?? 1)); $this->post(route('checkout.place'), ['digest' => $match[1], ...$this->consentFields()])->assertRedirect(route('member.order', Order::query()->latest('id')->first() ?? 1));
$order = Order::query()->latest('id')->firstOrFail(); $order = Order::query()->latest('id')->firstOrFail();
$this->post(route('member.order.confirm', $order))->assertRedirect(route('member.library')); $this->post(route('member.order.confirm', $order))->assertRedirect(route('member.library'));
+2 -1
View File
@@ -232,7 +232,8 @@ public function test_the_checkout_offers_the_choice_between_person_and_club_and_
->assertOk() ->assertOk()
->assertSee('Testverein Musterstadt e. V.') ->assertSee('Testverein Musterstadt e. V.')
->assertSee('Verein oder Organisation') ->assertSee('Verein oder Organisation')
->assertSee('Der Verein ist Lizenzinhaber') ->assertSee('Lizenzinhaber')
->assertSee('Nur dieses Konto, nicht weitere Mitglieder des Vereins.')
->assertSee('149,00 €'); ->assertSee('149,00 €');
$this->get(route('checkout', ['bestellen_als' => $vera->party_id])) $this->get(route('checkout', ['bestellen_als' => $vera->party_id]))
->assertOk() ->assertOk()
+1
View File
@@ -83,6 +83,7 @@ public function test_placeholder_app_url_uses_the_address_opened_in_the_browser(
public function test_verified_member_can_log_in_and_reaches_the_dashboard(): void public function test_verified_member_can_log_in_and_reaches_the_dashboard(): void
{ {
$user = User::factory()->create([ $user = User::factory()->create([
'name' => 'Ada Trainer',
'email' => 'ada@example.com', 'email' => 'ada@example.com',
'password' => 'password-pass', 'password' => 'password-pass',
]); ]);
+402
View File
@@ -0,0 +1,402 @@
<?php
namespace Tests\Feature;
use App\Domain\Catalog\DomainRuleException;
use App\Domain\Cms\Page;
use App\Domain\Cms\PageRevision;
use App\Domain\Commerce\Cart;
use App\Domain\Commerce\Checkout;
use App\Domain\Commerce\Discount\DiscountCode;
use App\Domain\Commerce\Discount\DiscountService;
use App\Domain\Commerce\Order;
use App\Domain\Commerce\SalesTerms;
use App\Domain\Commerce\Shop;
use App\Domain\Commerce\Stripe\StripeGateway;
use App\Domain\Entitlement\Acquisition;
use App\Domain\Entitlement\Grant;
use App\Domain\Entitlement\GrantStatus;
use App\Mail\OrderConfirmed;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Http\Client\Request as HttpRequest;
use Illuminate\Support\Facades\Http;
use Illuminate\Support\Facades\Mail;
use Tests\Support\BuildsShop;
use Tests\TestCase;
/**
* Verkaufsstart Deutschland: Pflichtangaben und Zustimmungen im Checkout, Kauf auf Rechnung für Vereine, Erstattung,
* Widerruf, Mail zur Vertragsbestätigung und die Produktivfreigabe (standardmäßig aus).
*/
class SalesStartTest extends TestCase
{
use BuildsShop;
use RefreshDatabase;
protected function setUp(): void
{
parent::setUp();
$this->seedShop();
$this->travelTo('2026-11-24 10:00:00');
}
private function publishLegalPage(string $path): void
{
$page = Page::query()->firstOrCreate(['path' => $path]);
$revision = PageRevision::query()->create(['page_id' => $page->id, 'blocks' => [], 'sections' => [], 'seo_title' => ltrim($path, '/')]);
$page->published_revision_id = $revision->id;
$page->save();
}
private function checkoutDigest(): string
{
$page = $this->get(route('checkout'))->assertOk();
preg_match('/name="digest" value="([a-f0-9]{64})"/', $page->getContent(), $match);
$this->assertNotEmpty($match, 'Die Bestellübersicht muss bestellbar sein.');
return $match[1];
}
public function test_the_checkout_shows_the_mandatory_information_and_the_order_button(): void
{
$this->actingAs($this->tina())->post(route('cart.add', $this->privateKonflikte()));
$this->publishLegalPage('/agb');
$this->get(route('checkout'))->assertOk()
->assertSee('Zahlungspflichtig bestellen')
->assertSee('Dein Vertrag')
->assertSee('Allgemeine Geschäftsbedingungen')
->assertSee('Widerrufsbelehrung (noch nicht veröffentlicht)')
->assertSee('Ich verlange ausdrücklich, dass mit der Ausführung des Vertrags vor Ablauf der Widerrufsfrist begonnen wird')
->assertSee('Mir ist bekannt, dass ich mein Widerrufsrecht verliere')
->assertSee('Testbetrieb')
->assertSee('Entwurf: Der Wortlaut der Zustimmungen ist noch nicht rechtlich geprüft.')
->assertSee('Es fehlen veröffentlichte Seiten')
->assertSee(url('/agb'), false);
}
public function test_an_order_needs_both_consents_and_keeps_the_proof(): void
{
$tina = $this->tina();
$this->actingAs($tina)->post(route('cart.add', $this->privateKonflikte()));
$digest = $this->checkoutDigest();
$this->post(route('checkout.place'), ['digest' => $digest])->assertSessionHasErrors('checkout');
$this->post(route('checkout.place'), ['digest' => $digest, 'zustimmung' => ['agb' => '1']])->assertSessionHasErrors('checkout');
$this->assertSame(0, Order::query()->count(), 'Ohne beide Zustimmungen entsteht keine Bestellung.');
$this->post(route('checkout.place'), ['digest' => $digest, ...$this->consentFields()])->assertRedirect();
$order = Order::query()->firstOrFail();
$this->assertSame($tina->id, $order->user_id);
$this->assertSame('2026-11-24 10:00:00', $order->terms_accepted_at->format('Y-m-d H:i:s'));
$this->assertSame(SalesTerms::VERSION, $order->terms_snapshot['version']);
$this->assertSame(SalesTerms::consents()['sofort'], $order->terms_snapshot['consents']['sofort']);
$this->assertSame(SalesTerms::consents()['agb'], $order->terms_snapshot['consents']['agb']);
$this->assertArrayHasKey('widerruf', $order->terms_snapshot['pages']);
}
public function test_the_confirmation_mail_repeats_scope_discount_and_consent(): void
{
Mail::fake();
app(DiscountService::class)->save(['code' => 'SOMMER10', 'label' => 'Sommer', 'kind' => 'prozent', 'percent' => 10, 'scope' => 'warenkorb', 'eligibility' => 'allgemein'], []);
$tina = $this->tina();
$cart = app(Cart::class);
$cart->add($this->privateKonflikte());
$cart->applyCode('SOMMER10', $tina);
$order = app(Checkout::class)->placeFromCart($tina, $cart, null, $cart->review($tina)->digest(), ['agb' => 1, 'sofort' => 1]);
app(Checkout::class)->confirmTestPayment($order, 'test-mail');
Mail::assertSent(OrderConfirmed::class, function (OrderConfirmed $mail): bool {
$text = $mail->render();
return str_contains($text, 'Vertragsbestätigung')
&& str_contains($text, 'Einzellizenz · 1 Trainer')
&& str_contains($text, 'Rabattcode SOMMER10')
&& str_contains($text, 'Gezahlter Betrag: 44,10 €')
&& str_contains($text, 'Mir ist bekannt, dass ich mein Widerrufsrecht verliere');
});
}
public function test_the_order_page_shows_discount_and_payable_amount_and_stripe_receives_the_discounted_amount(): void
{
config([
'services.payment.driver' => 'stripe', 'services.stripe.secret' => 'sk_test_nur_fuer_tests',
'services.stripe.webhook_secret' => 'whsec_x', 'services.stripe.api_base' => 'https://stripe.test',
]);
app(DiscountService::class)->save(['code' => 'SOMMER10', 'label' => 'Sommer', 'kind' => 'prozent', 'percent' => 10, 'scope' => 'warenkorb', 'eligibility' => 'allgemein'], []);
$tina = $this->tina();
$cart = app(Cart::class);
$cart->add($this->privateKonflikte());
$cart->add($this->privateGrenzen());
$cart->applyCode('SOMMER10', $tina);
$order = app(Checkout::class)->placeFromCart($tina, $cart, null, $cart->review($tina)->digest(), ['agb' => 1, 'sofort' => 1]);
Http::fake(['stripe.test/v1/checkout/sessions' => Http::response(['id' => 'cs_test_d', 'url' => 'https://checkout.stripe.test/c/pay/cs_test_d'])]);
$this->actingAs($tina)->get(route('member.order', $order))->assertOk()
->assertSee('Zu zahlen')->assertSee('70,20 €')->assertSee('Rabattcode')->assertSee('SOMMER10')->assertSee('−7,80 €');
$this->post(route('member.order.pay', $order))->assertRedirect('https://checkout.stripe.test/c/pay/cs_test_d');
Http::assertSent(function (HttpRequest $request): bool {
parse_str($request->body(), $body);
return (int) $body['line_items'][0]['price_data']['unit_amount'] === 4410
&& (int) $body['line_items'][1]['price_data']['unit_amount'] === 2610
&& str_contains((string) $body['line_items'][0]['price_data']['product_data']['description'], 'Listenpreis 49,00 €');
});
// Die Summe bei Stripe ist der gespeicherte Zahlbetrag; der Listenpreis wird nicht akzeptiert.
$checkout = app(Checkout::class);
try {
$checkout->confirmProviderPayment($order, 'stripe', 'cs_test_d', 7800, 'eur');
$this->fail('Der Listenpreis weicht vom Zahlbetrag ab.');
} catch (DomainRuleException) {
$this->assertSame('offen', $order->fresh()->status);
$this->assertSame(0, Acquisition::query()->count());
}
$checkout->confirmProviderPayment($order, 'stripe', 'cs_test_d', 7020, 'eur');
$checkout->confirmProviderPayment($order, 'stripe', 'cs_test_d', 7020, 'eur');
$this->assertSame('bezahlt', $order->fresh()->status);
$this->assertSame(2, Acquisition::query()->count(), 'Eine wiederholte Bestätigung schaltet nichts doppelt frei.');
}
public function test_a_club_can_order_on_invoice_and_only_the_operator_confirms_the_payment(): void
{
$vera = $this->vera();
$this->actingAs($vera)->post(route('cart.add', $this->clubKonflikte()));
$this->get(route('checkout'))->assertOk()->assertSee('Auf Rechnung (Überweisung, auf Anfrage)');
$this->post(route('checkout.place'), ['digest' => $this->checkoutDigest(), 'zahlungsweg' => 'rechnung', ...$this->consentFields()])->assertRedirect();
$order = Order::query()->firstOrFail();
$this->assertSame('rechnung', $order->payment_method);
$this->assertSame('offen', $order->status);
$this->assertSame($this->club()->id, $order->party_id);
$this->get(route('member.order', $order))->assertOk()
->assertSee('Wir erstellen die Rechnung manuell')
->assertDontSee('Testzahlung bestätigen')
->assertDontSee('Jetzt bezahlen');
$this->post(route('member.order.confirm', $order))->assertSessionHasErrors('payment');
$this->assertSame('offen', $order->fresh()->status, 'Das Mitglied kann den Zahlungseingang nicht selbst bestätigen.');
$this->assertFalse(Grant::query()->usableBy($vera)->exists());
app(Checkout::class)->confirmInvoicePayment($order, 'RE-2026-001', $this->tina());
app(Checkout::class)->confirmInvoicePayment($order, 'RE-2026-001', $this->tina());
$this->assertSame('bezahlt', $order->fresh()->status);
$this->assertSame('ueberweisung', $order->payments()->firstOrFail()->provider);
$this->assertSame(1, Acquisition::query()->count());
$this->assertTrue(Grant::query()->usableBy($vera)->exists());
$this->assertFalse(Grant::query()->usableBy($this->max())->exists());
}
public function test_a_private_buyer_cannot_order_on_invoice_and_a_test_order_cannot_be_confirmed_as_invoice(): void
{
$tina = $this->tina();
$this->actingAs($tina)->post(route('cart.add', $this->privateKonflikte()));
$this->get(route('checkout'))->assertOk()->assertDontSee('Auf Rechnung');
$this->post(route('checkout.place'), ['digest' => $this->checkoutDigest(), 'zahlungsweg' => 'rechnung', ...$this->consentFields()])->assertSessionHasErrors('checkout');
$this->assertSame(0, Order::query()->count());
$order = $this->orderOf($tina, [$this->privateKonflikte()]);
$this->expectException(DomainRuleException::class);
app(Checkout::class)->confirmInvoicePayment($order, 'RE-1', $this->vera());
}
public function test_a_paid_stripe_order_is_refunded_at_stripe_before_rights_are_revoked(): void
{
config(['services.payment.driver' => 'stripe', 'services.stripe.secret' => 'sk_test_nur_fuer_tests', 'services.stripe.api_base' => 'https://stripe.test']);
$order = $this->orderOf($this->tina(), [$this->privateKonflikte(), $this->privateGrenzen()]);
app(Checkout::class)->confirmProviderPayment($order, 'stripe', 'cs_test_r', 7800, 'eur');
$order->payments()->update(['provider_payment_ref' => 'pi_test_r']);
Http::fake(['stripe.test/v1/refunds' => Http::response(['id' => 're_1', 'status' => 'succeeded'])]);
app(Checkout::class)->refund($order, 'Widerruf geprüft');
Http::assertSent(function (HttpRequest $request) use ($order): bool {
parse_str($request->body(), $body);
return $request->url() === 'https://stripe.test/v1/refunds'
&& $body['payment_intent'] === 'pi_test_r'
&& (int) $body['amount'] === 7800
&& $request->header('Idempotency-Key')[0] === 'luf-refund-'.$order->id.'-'.$order->payments()->firstOrFail()->id;
});
$this->assertSame('erstattet', $order->fresh()->status);
$this->assertSame(0, Grant::query()->where('status', GrantStatus::Aktiv)->count());
}
public function test_a_failed_refund_at_stripe_revokes_nothing(): void
{
config(['services.payment.driver' => 'stripe', 'services.stripe.secret' => 'sk_test_nur_fuer_tests', 'services.stripe.api_base' => 'https://stripe.test']);
$order = $this->orderOf($this->tina(), [$this->privateKonflikte()]);
app(Checkout::class)->confirmProviderPayment($order, 'stripe', 'cs_test_f', 4900, 'eur');
$order->payments()->update(['provider_payment_ref' => 'pi_test_f']);
Http::fake(['stripe.test/v1/refunds' => Http::response(['error' => ['type' => 'invalid_request_error', 'message' => 'x']], 400)]);
try {
app(Checkout::class)->refund($order, 'Widerruf geprüft');
$this->fail('Ohne Rückzahlung bei Stripe darf nichts entzogen werden.');
} catch (DomainRuleException) {
$this->assertSame('bezahlt', $order->fresh()->status);
$this->assertSame(1, Grant::query()->where('status', GrantStatus::Aktiv)->count());
}
}
public function test_an_invoice_order_is_refunded_without_stripe_and_free_grants_stay(): void
{
$vera = $this->vera();
$order = $this->orderOf($vera, [$this->clubKonflikte()], $this->club()->id);
$order->update(['payment_method' => 'rechnung']);
app(Checkout::class)->confirmInvoicePayment($order, 'RE-9', $this->tina());
Http::fake();
app(Checkout::class)->refund($order, 'Storno nach Rücksprache');
Http::assertNothingSent();
$this->assertSame('erstattet', $order->fresh()->status);
$this->assertFalse(Grant::query()->usableBy($vera)->where('status', GrantStatus::Aktiv)->exists());
}
public function test_the_member_declares_a_withdrawal_and_the_operator_decides(): void
{
config(['services.payment.driver' => 'stripe', 'services.stripe.secret' => 'sk_test_nur_fuer_tests']);
$tina = $this->tina();
$order = $this->orderOf($tina, [$this->privateKonflikte()]);
app(Checkout::class)->confirmProviderPayment($order, 'stripe', 'cs_test_w', 4900, 'eur');
$this->actingAs($tina)->get(route('member.order', $order))->assertOk()->assertSee('Widerruf erklären')->assertDontSee('Widerrufen (Testzahlung)');
$this->post(route('member.order.refund', $order))->assertNotFound();
$this->post(route('member.order.withdraw', $order), ['note' => 'Passt nicht'])->assertRedirect(route('member.order', $order));
$this->assertNotNull($order->fresh()->withdrawal_requested_at);
$this->assertSame('Passt nicht', $order->fresh()->withdrawal_note);
$this->assertSame('bezahlt', $order->fresh()->status, 'Die Erklärung entzieht und erstattet nichts; der Betreiber prüft.');
$this->assertSame(1, Grant::query()->where('status', GrantStatus::Aktiv)->count());
$this->actingAs($this->max())->post(route('member.order.withdraw', $order))->assertForbidden();
}
public function test_the_shop_stays_off_in_production_unless_released_keyed_and_documented(): void
{
$this->app['env'] = 'production';
config(['services.payment.driver' => 'stripe', 'services.stripe.secret' => 'sk_live_nur_fuer_tests']);
$this->assertFalse(config('shop.live_release'), 'Die Freigabe ist standardmäßig aus.');
$this->assertFalse(Shop::enabled());
$this->assertFalse(Shop::stripe());
config(['shop.live_release' => true]);
$this->assertFalse(Shop::live(), 'Ohne veröffentlichte Rechtstexte bleibt der Shop aus.');
foreach (['/agb', '/lizenzbedingungen', '/widerruf', '/impressum', '/datenschutz'] as $path) {
$this->publishLegalPage($path);
}
$this->assertTrue(Shop::live());
$this->assertTrue(Shop::enabled());
$this->assertTrue(Shop::stripe());
config(['services.stripe.secret' => 'sk_test_nur_fuer_tests']);
$this->assertFalse(Shop::live(), 'Mit einem Testschlüssel ist Produktion nie live.');
config(['services.stripe.secret' => 'sk_live_nur_fuer_tests', 'services.payment.driver' => 'test']);
$this->assertFalse(Shop::live(), 'Der Testzahlungsweg gibt Produktion nie frei.');
config(['services.payment.driver' => 'stripe', 'shop.live_release' => false]);
$this->assertFalse(Shop::live());
}
public function test_stripe_refuses_a_live_key_outside_production_and_any_call_in_production_without_release(): void
{
$order = $this->orderOf($this->tina(), [$this->privateKonflikte()]);
config(['services.payment.driver' => 'stripe', 'services.stripe.secret' => 'sk_live_nur_fuer_tests']);
Http::fake();
try {
app(StripeGateway::class)->checkoutFor($order);
$this->fail('Ein Live-Schlüssel darf außerhalb der Produktion nicht verwendet werden.');
} catch (DomainRuleException $exception) {
$this->assertStringContainsString('Testmodus', $exception->getMessage());
}
$this->app['env'] = 'production';
try {
app(StripeGateway::class)->checkoutFor($order);
$this->fail('Ohne Produktivfreigabe geht kein Aufruf an Stripe.');
} catch (DomainRuleException $exception) {
$this->assertStringContainsString('nicht freigegeben', $exception->getMessage());
}
Http::assertNothingSent();
}
public function test_the_checkout_and_the_order_say_that_the_code_changes_the_price_not_the_scope(): void
{
$code = DiscountCode::query()->count();
$this->assertSame(0, $code);
$this->actingAs($this->tina())->post(route('cart.add', $this->privateKonflikte()));
$this->get(route('checkout'))->assertOk()->assertSee('Pro Bestellung gilt höchstens ein Code. Er ändert den Preis, nicht den Nutzungsumfang.');
}
public function test_an_invoice_order_is_never_paid_by_card_even_when_stripe_is_the_driver(): void
{
config(['services.payment.driver' => 'stripe', 'services.stripe.secret' => 'sk_test_nur_fuer_tests', 'services.stripe.api_base' => 'https://stripe.test']);
$vera = $this->vera();
$cart = app(Cart::class);
$cart->add($this->clubKonflikte());
$order = app(Checkout::class)->placeFromCart($vera, $cart, $this->club()->id, $cart->review($vera, $this->club()->id)->digest(), ['agb' => 1, 'sofort' => 1], 'rechnung');
Http::fake();
$this->actingAs($vera)->get(route('member.order', $order))->assertOk()->assertDontSee('Jetzt bezahlen');
$this->post(route('member.order.pay', $order))->assertSessionHasErrors('payment');
Http::assertNothingSent();
}
public function test_the_operator_who_confirmed_an_invoice_payment_is_recorded(): void
{
$order = $this->orderOf($this->vera(), [$this->clubKonflikte()], $this->club()->id);
$order->update(['payment_method' => 'rechnung']);
$operator = $this->tina();
app(Checkout::class)->confirmInvoicePayment($order, 'RE-77', $operator);
$this->assertSame($operator->id, $order->payments()->firstOrFail()->confirmed_by);
}
public function test_in_live_mode_only_the_checkout_with_consents_creates_an_order(): void
{
$this->app['env'] = 'production';
config(['shop.live_release' => true, 'services.payment.driver' => 'stripe', 'services.stripe.secret' => 'sk_live_nur_fuer_tests']);
foreach (['/agb', '/lizenzbedingungen', '/widerruf', '/impressum', '/datenschutz'] as $path) {
$this->publishLegalPage($path);
}
$this->assertTrue(Shop::live());
$tina = $this->tina();
try {
app(Checkout::class)->place($tina, $this->privateKonflikte());
$this->fail('Der alte Einzelkauf kennt keine Pflichtangaben und ist im Livebetrieb gesperrt.');
} catch (DomainRuleException) {
$this->assertSame(0, Order::query()->count());
}
$cart = app(Cart::class);
$cart->add($this->privateKonflikte());
try {
app(Checkout::class)->placeFromCart($tina, $cart, null, $cart->review($tina)->digest());
$this->fail('Ohne Zustimmungen entsteht im Livebetrieb keine Bestellung.');
} catch (DomainRuleException $exception) {
$this->assertStringContainsString('Zustimmungen', $exception->getMessage());
$this->assertSame(0, Order::query()->count());
}
$order = app(Checkout::class)->placeFromCart($tina, $cart, null, $cart->review($tina)->digest(), ['agb' => 1, 'sofort' => 1]);
$this->assertNotNull($order->terms_accepted_at);
}
}
+302
View File
@@ -0,0 +1,302 @@
<?php
namespace Tests\Feature;
use App\Domain\Commerce\Checkout;
use App\Domain\Commerce\Discount\DiscountCode;
use App\Domain\Commerce\Discount\DiscountRelease;
use App\Domain\Commerce\Discount\DiscountService;
use App\Domain\Entitlement\Grant;
use App\Domain\Entitlement\GrantStatus;
use App\Filament\Resources\DiscountCodes\Pages\ListDiscountCodes;
use App\Filament\Resources\DiscountCodes\Pages\ViewDiscountCode;
use App\Filament\Resources\Offers\Pages\ViewOffer;
use App\Filament\Resources\Orders\Pages\ListOrders;
use App\Filament\Resources\Orders\Pages\ViewOrder;
use App\Models\User;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Support\Facades\DB;
use Livewire\Livewire;
use Tests\Support\BuildsShop;
use Tests\TestCase;
/**
* Verwaltung des Verkaufsstarts: Rabattcodes mit Freigabe einzelner Konten, Bestellverwaltung mit Zahlungseingang
* auf Rechnung und Erstattung, Nutzerkreis in der Angebotsmaske.
*/
class ShopSalesAdminTest extends TestCase
{
use BuildsShop;
use RefreshDatabase;
protected function setUp(): void
{
parent::setUp();
$this->seedShop();
$this->travelTo('2026-11-24 10:00:00');
}
private function staff(string $state = 'katalogverwalter'): User
{
$user = User::factory()->{$state}()->create();
$user->saveAppAuthenticationSecret('JBSWY3DPEHPK3PXP');
return $user;
}
public function test_the_operator_creates_a_code_in_the_mask_and_edits_it_with_the_same_mask(): void
{
$keeper = $this->staff();
$offer = $this->privateKonflikte();
Livewire::actingAs($keeper, 'staff')
->test(ListDiscountCodes::class)
->assertSee('Noch keine Rabattcodes')
->mountAction('create')
->fillForm([
'code' => 'zert 2026', 'label' => 'Zertifizierungscode', 'kind' => 'prozent', 'percent' => 15,
'scope' => 'auswahl', 'offer_ids' => [$offer->id], 'eligibility' => 'freigabe',
'valid_from' => '2026-11-01', 'valid_until' => '2026-12-31', 'active' => true,
])
->callMountedAction()
->assertHasNoActionErrors();
$code = DiscountCode::query()->firstOrFail();
$this->assertSame('ZERT2026', $code->code);
$this->assertSame('auswahl', $code->scope);
$this->assertSame('freigabe', $code->eligibility, 'Geltungsbereich und Einlösung sind getrennte Einstellungen.');
$this->assertSame([$offer->id], $code->targets->pluck('target_id')->map(fn ($id): int => (int) $id)->all());
$this->assertSame('2026-12-31 23:59:59', $code->valid_until->timezone(config('app.timezone'))->format('Y-m-d H:i:s'), 'Das Ende gilt einschließlich des ganzen Tages.');
$component = Livewire::actingAs($keeper, 'staff')
->test(ViewDiscountCode::class, ['record' => $code->getKey()])
->assertSee('ZERT2026')
->assertSee('nur freigeschaltete Konten')
->assertSee('Angebot „Konflikte im Training: Privatlizenz“')
->mountAction('edit');
$data = $component->get('mountedActions.0.data');
$this->assertSame('ZERT2026', $data['code']);
$this->assertSame(15, (int) $data['percent']);
$component->fillForm(['percent' => 25, 'scope' => 'warenkorb'])->callMountedAction()->assertHasNoActionErrors();
$code->refresh();
$this->assertSame(25, $code->percent);
$this->assertSame('warenkorb', $code->scope);
$this->assertSame(0, $code->targets()->count());
}
public function test_a_code_can_be_deactivated_and_reactivated_with_confirmation(): void
{
$code = app(DiscountService::class)->save(['code' => 'SOMMER10', 'label' => 'Sommer', 'kind' => 'prozent', 'percent' => 10, 'scope' => 'warenkorb', 'eligibility' => 'allgemein'], []);
$component = Livewire::actingAs($this->staff(), 'staff')
->test(ViewDiscountCode::class, ['record' => $code->getKey()])
->assertSee('Gerade gültig')
->mountAction('toggle')
->callMountedAction();
$this->assertFalse($code->fresh()->active);
$component->assertSee('Deaktiviert');
$component->mountAction('toggle')->callMountedAction();
$this->assertTrue($code->fresh()->active);
}
public function test_individual_accounts_are_released_and_revoked_for_exactly_this_code(): void
{
$service = app(DiscountService::class);
$x = $service->save(['code' => 'CODEX', 'label' => 'X', 'kind' => 'prozent', 'percent' => 10, 'scope' => 'warenkorb', 'eligibility' => 'freigabe'], []);
$y = $service->save(['code' => 'CODEY', 'label' => 'Y', 'kind' => 'prozent', 'percent' => 10, 'scope' => 'warenkorb', 'eligibility' => 'freigabe'], []);
$keeper = $this->staff();
$tina = $this->tina();
$component = Livewire::actingAs($keeper, 'staff')
->test(ViewDiscountCode::class, ['record' => $x->getKey()])
->assertSee('Noch kein Konto freigeschaltet')
->mountAction('release')
->fillForm(['user_id' => $tina->id, 'reason' => 'Zertifikat geprüft'])
->callMountedAction()
->assertHasNoActionErrors()
->assertSee('Tina Trainerin')
->assertSee('Zertifikat geprüft')
->assertSee('Entziehen');
$release = DiscountRelease::query()->firstOrFail();
$this->assertSame($x->id, $release->discount_code_id);
$this->assertSame($keeper->id, $release->granted_by);
$this->assertNotNull($service->activeRelease($x, $tina));
$this->assertNull($service->activeRelease($y, $tina), 'Eine Freigabe für Code X berechtigt nicht zu Code Y.');
$component->mountAction('revoke', ['release' => $release->id])->fillForm(['reason' => 'Zertifikat abgelaufen'])->callMountedAction();
$this->assertNotNull($release->fresh()->revoked_at);
$this->assertNull($service->activeRelease($x, $tina));
$component->assertSee('Entzogene Freigaben')->assertSee('Zertifikat abgelaufen');
}
public function test_an_open_code_offers_no_release_action(): void
{
$code = app(DiscountService::class)->save(['code' => 'OFFEN', 'label' => 'Offen', 'kind' => 'prozent', 'percent' => 10, 'scope' => 'warenkorb', 'eligibility' => 'allgemein'], []);
Livewire::actingAs($this->staff(), 'staff')
->test(ViewDiscountCode::class, ['record' => $code->getKey()])
->assertSee('Keine Freigaben nötig')
->assertActionHidden('release');
}
public function test_the_list_shows_state_and_value_and_filters(): void
{
$service = app(DiscountService::class);
$service->save(['code' => 'GUELTIG', 'label' => 'Gültig', 'kind' => 'prozent', 'percent' => 10, 'scope' => 'warenkorb', 'eligibility' => 'allgemein'], []);
$service->save(['code' => 'ALT', 'label' => 'Alt', 'kind' => 'betrag', 'amount_euro' => '5,00', 'scope' => 'warenkorb', 'eligibility' => 'allgemein', 'valid_until' => '2026-11-01'], []);
Livewire::actingAs($this->staff(), 'staff')
->test(ListDiscountCodes::class)
->assertSee('GUELTIG')->assertSee('Gültig')->assertSee('10 %')
->assertSee('ALT')->assertSee('Abgelaufen')->assertSee('5,00 €')
->set('zustand', 'aktiv')
->assertSee('GUELTIG')->assertDontSee('ALT');
}
public function test_only_catalog_keepers_and_customer_service_may_manage_codes_and_orders(): void
{
$code = app(DiscountService::class)->save(['code' => 'SOMMER10', 'label' => 'Sommer', 'kind' => 'prozent', 'percent' => 10, 'scope' => 'warenkorb', 'eligibility' => 'allgemein'], []);
$order = $this->orderOf($this->tina(), [$this->privateKonflikte()]);
foreach (['katalogverwalter', 'kundenbetreuung'] as $role) {
$this->actingAs($this->staff($role), 'staff')->get('/verwaltung/discount-codes')->assertOk();
$this->get('/verwaltung/orders')->assertOk();
$this->get('/verwaltung/orders/'.$order->id)->assertOk();
$this->get('/verwaltung/discount-codes/'.$code->id)->assertOk();
}
$this->actingAs($this->staff('redakteur'), 'staff')->get('/verwaltung/discount-codes')->assertForbidden();
$this->get('/verwaltung/orders')->assertForbidden();
}
public function test_the_operator_confirms_the_payment_of_an_invoice_order(): void
{
$vera = $this->vera();
$order = $this->orderOf($vera, [$this->clubKonflikte()], $this->club()->id);
$order->update(['payment_method' => 'rechnung']);
$staff = $this->staff('kundenbetreuung');
Livewire::actingAs($staff, 'staff')
->test(ListOrders::class)
->assertSee('Bestellung '.$order->id)
->assertSee('Offen: wartet auf Zahlungseingang')
->set('zustand', 'rechnung_offen')
->assertSee('Bestellung '.$order->id);
Livewire::actingAs($staff, 'staff')
->test(ViewOrder::class, ['record' => $order->getKey()])
->assertSee('Testverein Musterstadt e. V.')
->assertSee('Mehrfachlizenz · bis zu 5 Trainer')
->assertSee('Offen: Rechnung erstellen und Zahlungseingang bestätigen.')
->assertActionHidden('refund')
->mountAction('confirmInvoice')
->fillForm(['reference' => ''])
->callMountedAction()
->assertHasActionErrors(['reference' => 'required']);
$this->assertSame('offen', $order->fresh()->status);
Livewire::actingAs($staff, 'staff')
->test(ViewOrder::class, ['record' => $order->getKey()])
->mountAction('confirmInvoice')
->fillForm(['reference' => 'RE-2026-014'])
->callMountedAction()
->assertHasNoActionErrors()
->assertSee('Bezahlt (Überweisung auf Rechnung (manuell))');
$this->assertSame('bezahlt', $order->fresh()->status);
$this->assertTrue(Grant::query()->usableBy($vera)->exists());
$this->assertFalse(Grant::query()->usableBy($this->max())->exists());
$this->assertSame('rechnung-RE-2026-014', $order->payments()->firstOrFail()->provider_reference);
}
public function test_the_operator_refunds_a_paid_order_completely_with_a_reason(): void
{
$tina = $this->tina();
$order = $this->orderOf($tina, [$this->privateKonflikte()]);
app(Checkout::class)->confirmTestPayment($order, 'test-r');
$order->forceFill(['withdrawal_requested_at' => now(), 'withdrawal_note' => 'Passt nicht'])->save();
$component = Livewire::actingAs($this->staff('kundenbetreuung'), 'staff')
->test(ViewOrder::class, ['record' => $order->getKey()])
->assertSee('Widerruf erklärt am')
->assertSee('Passt nicht')
->mountAction('refund')
->fillForm(['reason' => ''])
->callMountedAction()
->assertHasActionErrors(['reason' => 'required']);
$this->assertSame('bezahlt', $order->fresh()->status);
$component->fillForm(['reason' => 'Widerruf geprüft'])->callMountedAction()->assertHasNoActionErrors();
$this->assertSame('erstattet', $order->fresh()->status);
$this->assertSame(0, Grant::query()->where('status', GrantStatus::Aktiv)->count());
$this->assertSame('Widerruf geprüft', Grant::query()->firstOrFail()->status_reason);
}
public function test_the_offer_mask_asks_for_the_scope_and_stores_trainer_count_with_the_version(): void
{
$offer = $this->clubKonflikte();
$component = Livewire::actingAs($this->staff(), 'staff')
->test(ViewOffer::class, ['record' => $offer->getKey()])
->assertSee('Mehrfachlizenz · bis zu 5 Trainer')
->mountAction('activate');
$data = $component->get('mountedActions.0.data');
$this->assertSame('mehrfach', $data['licence_scope']);
$this->assertSame(5, (int) $data['trainer_count']);
$component->fillForm(['trainer_count' => 12])->callMountedAction()->assertHasNoActionErrors();
$version = $offer->versions()->orderByDesc('number')->firstOrFail();
$this->assertSame('mehrfach', $version->licence_scope);
$this->assertSame(12, $version->trainer_count);
$this->assertSame(5, $offer->versions()->orderBy('number')->firstOrFail()->trainer_count, 'Die frühere Fassung bleibt unverändert.');
Livewire::actingAs($this->staff(), 'staff')
->test(ViewOffer::class, ['record' => $offer->getKey()])
->mountAction('activate')
->fillForm(['licence_scope' => 'mehrfach', 'trainer_count' => 1])
->callMountedAction()
->assertHasActionErrors(['trainer_count']);
}
public function test_the_offer_page_flags_a_version_without_scope(): void
{
$offer = $this->privateGrenzen();
// Eine Fassung vor der Einführung des Nutzerkreises: aktive Fassungen sind sonst unveränderlich.
DB::table('offer_versions')->where('offer_id', $offer->id)->update(['licence_scope' => null, 'trainer_count' => null]);
Livewire::actingAs($this->staff(), 'staff')
->test(ViewOffer::class, ['record' => $offer->getKey()])
->assertSee('Nutzerkreis nicht festgelegt')
->assertSee('Diese Fassung hat keinen festgelegten Nutzerkreis.')
->mountAction('activate')
->fillForm(['price_euro' => '31,00'])
->callMountedAction()
->assertHasActionErrors(['licence_scope' => 'required']);
$this->assertSame(1, $offer->versions()->count(), 'Ohne Nutzerkreis entsteht keine neue Fassung.');
}
public function test_the_sales_start_page_names_what_is_missing_without_showing_secrets(): void
{
config(['services.stripe.secret' => 'sk_test_geheim_nicht_zeigen', 'services.stripe.webhook_secret' => 'whsec_geheim']);
$this->actingAs($this->staff('kundenbetreuung'), 'staff')->get('/verwaltung/verkaufsstart')
->assertOk()
->assertSee('Allgemeine Geschäftsbedingungen')
->assertSee('Widerrufsbelehrung')
->assertSee('Fehlt')
->assertSee('Produktivfreigabe (SHOP_LIVE_RELEASE): nicht gesetzt')
->assertSee('Stripe-Schlüssel: Testmodus')
->assertSee('Steuerstatus und Belegangaben sind noch nicht entschieden')
->assertDontSee('sk_test_geheim_nicht_zeigen')
->assertDontSee('whsec_geheim');
$this->actingAs($this->staff('redakteur'), 'staff')->get('/verwaltung/verkaufsstart')->assertForbidden();
}
}
+6
View File
@@ -27,6 +27,12 @@ protected function seedShop(): void
$this->seed(ShopDemoSeeder::class); $this->seed(ShopDemoSeeder::class);
} }
/** Die Zustimmungen der Kasse (Pflichtangabe), wie das Formular sie sendet. */
protected function consentFields(): array
{
return ['zustimmung' => ['agb' => '1', 'sofort' => '1']];
}
protected function offerNamed(string $name): Offer protected function offerNamed(string $name): Offer
{ {
return Offer::query()->where('name', $name)->firstOrFail(); return Offer::query()->where('name', $name)->firstOrFail();
+62
View File
@@ -0,0 +1,62 @@
<?php
namespace Tests\Unit;
use App\Domain\Commerce\Discount\DiscountCalculator;
use App\Domain\Commerce\Discount\DiscountCode;
use PHPUnit\Framework\TestCase;
/**
* Rechenregel des Rabatts je Position (ganze Cent). Die Rundung ist eine Entscheidung zur Bestätigung durch Lars;
* die Tests halten fest, was heute gilt.
*/
class DiscountCalculatorTest extends TestCase
{
public function test_a_percentage_is_rounded_per_line_half_up(): void
{
// Drei Positionen zu je 0,99 €, 50 %: je Position 49,5 Cent, aufgerundet auf 50 Cent.
$discounts = DiscountCalculator::allocate(DiscountCode::PERCENT, 50, null, [1 => 99, 2 => 99, 3 => 99]);
$this->assertSame([1 => 50, 2 => 50, 3 => 50], $discounts);
$this->assertSame(150, array_sum($discounts), 'Auf der Warenkorbsumme gerundet wären es 149 Cent.');
}
public function test_a_percentage_never_exceeds_the_line_price(): void
{
$this->assertSame([1 => 4900], DiscountCalculator::allocate(DiscountCode::PERCENT, 100, null, [1 => 4900]));
$this->assertSame([1 => 4900], DiscountCalculator::allocate(DiscountCode::PERCENT, 250, null, [1 => 4900]));
$this->assertSame([1 => 0], DiscountCalculator::allocate(DiscountCode::PERCENT, 0, null, [1 => 4900]));
}
public function test_a_fixed_amount_is_distributed_in_proportion_to_the_prices(): void
{
$this->assertSame([1 => 600, 2 => 400], DiscountCalculator::allocate(DiscountCode::AMOUNT, null, 1000, [1 => 3000, 2 => 2000]));
}
public function test_the_remaining_cents_go_to_the_largest_remainder_and_the_sum_is_exact(): void
{
$discounts = DiscountCalculator::allocate(DiscountCode::AMOUNT, null, 100, [1 => 3333, 2 => 3333, 3 => 3334]);
$this->assertSame([1 => 33, 2 => 33, 3 => 34], $discounts);
$this->assertSame(100, array_sum($discounts));
}
public function test_a_fixed_amount_is_capped_at_the_affected_total(): void
{
$discounts = DiscountCalculator::allocate(DiscountCode::AMOUNT, null, 99999, [1 => 2900, 2 => 4900]);
$this->assertSame([1 => 2900, 2 => 4900], $discounts);
}
public function test_nothing_to_discount_yields_nothing(): void
{
$this->assertSame([], DiscountCalculator::allocate(DiscountCode::PERCENT, 10, null, []));
$this->assertSame([1 => 0], DiscountCalculator::allocate(DiscountCode::AMOUNT, null, 0, [1 => 100]));
}
public function test_codes_are_normalised_without_spaces_and_in_capitals(): void
{
$this->assertSame('ZERT-2026', DiscountCode::normalise(' zert-2026 '));
$this->assertSame('SOMMER10', DiscountCode::normalise('sommer 10'));
}
}