Files
laraundfelix/app/Domain/Catalog/OfferService.php
T
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

325 lines
12 KiB
PHP

<?php
namespace App\Domain\Catalog;
use Illuminate\Support\Facades\DB;
class OfferService
{
public function __construct(private readonly BundleService $bundles) {}
public function currentActiveVersion(Offer $offer): OfferVersion
{
$version = $offer->versions()
->where('status', OfferStatus::Aktiv)
->orderByDesc('number')
->first();
if ($version === null) {
throw new DomainRuleException('Das Angebot hat keine aktive Fassung.');
}
return $version;
}
/**
* Die aktive, als Kauf angebotene Fassung mit Preis; sonst null (nicht kaufbar, zurückgezogen oder kostenlos).
*/
public function purchasableVersion(Offer $offer): ?OfferVersion
{
$version = $offer->versions()
->where('status', OfferStatus::Aktiv)
->orderByDesc('number')
->first();
if ($version === null || $version->grant_kind !== 'kauf' || $version->price_cents === null) {
return null;
}
return $version;
}
/**
* @param array<string, mixed> $capabilities
* @param array<string, mixed> $options
*/
public function createRightsProfile(
string $name,
string $purpose,
array $capabilities,
array $options = [],
): RightsProfileVersion {
$purpose = trim($purpose);
if (! in_array($purpose, ['ehrenamtlich', 'kommerziell', 'institutionell'], true)) {
throw new DomainRuleException('Der Nutzungszweck eines Rechteprofils ist ehrenamtlich, kommerziell oder institutionell.');
}
if ($capabilities === []) {
throw new DomainRuleException('Ein Rechteprofil braucht mindestens eine Fähigkeit.');
}
$profile = RightsProfile::query()->create([
'name' => trim($name) !== '' ? trim($name) : throw new DomainRuleException('Der Name des Rechteprofils fehlt.'),
]);
return $profile->versions()->create([
'number' => 1,
'purpose' => $purpose,
'capabilities' => $capabilities,
'options' => $options,
]);
}
public function create(string $name): Offer
{
$name = trim($name);
if ($name === '') {
throw new DomainRuleException('Der Name des Angebots fehlt.');
}
return Offer::query()->create([
'name' => $name,
]);
}
/**
* @param list<array{target: LicenseArticle|BundleVersion, rights: RightsProfileVersion}> $lines
* @param array<string, mixed> $attributes
*/
public function activate(Offer $offer, array $lines, array $attributes = []): OfferVersion
{
if ($lines === []) {
throw new DomainRuleException('Eine Angebotsfassung braucht mindestens eine Position.');
}
$attributes = array_merge([
'price_cents' => null,
'tax_class' => null,
'term_rule' => 'dauerhaft',
'update_promise' => 'alle_freigegebenen_fassungen',
'dynamic' => false,
'grant_kind' => 'kauf',
'holder_kind' => 'person',
'licence_scope' => null,
'trainer_count' => null,
], $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);
[$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 {
$offer = Offer::query()->lockForUpdate()->findOrFail($offer->id);
OfferVersion::query()
->where('offer_id', $offer->id)
->where('status', OfferStatus::Aktiv)
->update(['status' => OfferStatus::Beendet->value]);
$version = $offer->versions()->create([
'number' => ((int) $offer->versions()->max('number')) + 1,
'status' => OfferStatus::Entwurf,
'price_cents' => $attributes['price_cents'],
'tax_class' => $attributes['tax_class'],
'term_rule' => $attributes['term_rule'],
'update_promise' => $attributes['update_promise'],
'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) {
$target = $line['target'];
$version->lines()->create([
'position' => $index + 1,
'license_article_id' => $target instanceof LicenseArticle ? $target->id : null,
'bundle_version_id' => $target instanceof BundleVersion ? $target->id : null,
'rights_profile_version_id' => $line['rights']->id,
]);
}
foreach ($scope as $entry) {
$version->resolvedScopes()->create($entry);
}
RightsProfileVersion::query()
->whereIn('id', array_column($scope, 'rights_profile_version_id'))
->whereNull('locked_at')
->update(['locked_at' => now()]);
$version->status = OfferStatus::Aktiv;
$version->activated_at = now();
$version->save();
return $version->load('resolvedScopes');
});
}
/**
* Zieht die Option aus dem Verkauf zurück: Die aktive Fassung wird beendet und bleibt gespeichert. Bereits
* begründete Berechtigungen und Bestellungen ändern sich nicht; offene Warenkörbe zeigen die Position als
* zurückgezogen und blockieren den Abschluss, bis der Käufer sie entfernt.
*/
public function end(Offer $offer): OfferVersion
{
return DB::transaction(function () use ($offer): OfferVersion {
$offer = Offer::query()->lockForUpdate()->findOrFail($offer->id);
$version = $this->currentActiveVersion($offer);
$version->status = OfferStatus::Beendet;
$version->save();
return $version;
});
}
/**
* 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.
*/
public function assignProduct(Offer $offer, ?int $compositionId, ?string $optionLabel, bool $ownBundlePage = false): Offer
{
if ($compositionId !== null) {
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->standalone_bundle = $ownBundlePage;
$offer->option_label = filled($optionLabel) ? trim((string) $optionLabel) : null;
$offer->save();
return $offer;
}
/**
* @return list<int>
*/
public function scopeArticleIds(OfferVersion $version): array
{
return $version->resolvedScopes()->orderBy('id')->pluck('license_article_id')->all();
}
/**
* @param array<string, mixed> $attributes
*/
private function assertAttributes(array $attributes): void
{
if (! in_array($attributes['term_rule'], ['dauerhaft', 'befristet', 'solange_angebot_aktiv', 'periodisch'], true)) {
throw new DomainRuleException('Die Laufzeitregel der Angebotsfassung ist unbekannt.');
}
if (! in_array($attributes['grant_kind'], ['kauf', 'bei_registrierung', 'auf_abruf'], true)) {
throw new DomainRuleException('Die Vergabeart der Angebotsfassung ist unbekannt.');
}
if (! in_array($attributes['holder_kind'], ['person', 'organisation'], true)) {
throw new DomainRuleException('Die Inhaberart der Angebotsfassung ist Person oder Organisation.');
}
if ($attributes['update_promise'] !== 'alle_freigegebenen_fassungen') {
throw new DomainRuleException('Die Updatezusage umfasst alle später freigegebenen Fassungen des Artikels.');
}
}
/**
* 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}>
*/
/**
* @param list<array{target: LicenseArticle|BundleVersion, rights: RightsProfileVersion}> $lines
* @param array<string, mixed> $attributes
*/
private function assertCoverage(array $lines, array $attributes): void
{
$versionId = $attributes['composition_version_id'] ?? null;
if ($versionId === null) {
return;
}
$version = CompositionVersion::query()->findOrFail($versionId);
$articles = [];
foreach ($lines as $line) {
if ($line['target'] instanceof LicenseArticle) {
$articles[] = $line['target'];
}
}
$missing = app(OfferCoverage::class)->missingLeaves($version, $articles);
if ($missing !== []) {
throw new DomainRuleException('Das Angebot deckt nicht alle Blätter: '.implode(', ', $missing));
}
}
private function scopeFor(array $lines): array
{
$scope = [];
foreach ($lines as $line) {
$target = $line['target'];
$rights = $line['rights'];
if ($target instanceof BundleVersion && $target->status !== BundleStatus::Veroeffentlicht) {
throw new DomainRuleException('Eine Angebotsfassung enthält nur veröffentlichte Paketfassungen.');
}
$articleIds = match (true) {
$target instanceof LicenseArticle => [$target->id],
$target instanceof BundleVersion => $this->bundles->articleIds($target),
default => throw new DomainRuleException('Eine Angebotsposition zeigt auf einen Lizenzartikel oder eine Paketfassung.'),
};
foreach ($articleIds as $articleId) {
$key = $articleId.'-'.$rights->id;
$scope[$key] = [
'license_article_id' => $articleId,
'rights_profile_version_id' => $rights->id,
];
}
}
return array_values($scope);
}
}