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>
This commit is contained in:
LarsandClaude Sonnet 5.5 committed 2026-11-22 19:42:02 +01:00
1 parent cb80835c92
commit 0154182f3b
40 files changed
+2151 -92

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)',
];
}
}
+32
View File
@@ -102,10 +102,14 @@ public function activate(Offer $offer, array $lines, array $attributes = []): Of
'dynamic' => false,
'grant_kind' => 'kauf',
'holder_kind' => 'person',
'licence_scope' => null,
'trainer_count' => null,
], $attributes);
$this->assertAttributes($attributes);
[$attributes['licence_scope'], $attributes['trainer_count']] = LicenceScope::normalise($attributes['licence_scope'], $attributes['trainer_count']);
$scope = $this->scopeFor($lines);
$this->assertSellableContent($scope);
$this->assertCoverage($lines, $attributes);
return DB::transaction(function () use ($offer, $lines, $attributes, $scope): OfferVersion {
@@ -126,6 +130,8 @@ public function activate(Offer $offer, array $lines, array $attributes = []): Of
'dynamic' => $attributes['dynamic'],
'grant_kind' => $attributes['grant_kind'],
'holder_kind' => $attributes['holder_kind'],
'licence_scope' => $attributes['licence_scope'],
'trainer_count' => $attributes['trainer_count'],
]);
foreach (array_values($lines) as $index => $line) {
@@ -219,6 +225,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
* @return list<array{license_article_id: int, rights_profile_version_id: int}>
+2
View File
@@ -19,6 +19,8 @@ class OfferVersion extends Model
'dynamic',
'grant_kind',
'holder_kind',
'licence_scope',
'trainer_count',
'activated_at',
];