presseportale/app/Services/PressRelease/CanonicalAssigner.php

<?php

namespace App\Services\PressRelease;

use App\Enums\Portal;
use App\Http\Middleware\SetEdition;
use App\Models\Category;
use App\Models\PressRelease;
use App\Scopes\PortalScope;
use Illuminate\Database\Query\Builder as QueryBuilder;
use Illuminate\Support\Facades\DB;

/**
 * Kanonische Zuordnung bei Doppelveröffentlichung (Anhang 2, 1c.8).
 *
 * Liegt derselbe Text (content_hash) derselben Firma auf beiden Portalen,
 * bestimmt das Portal die Erstquelle statt Google: die zweite Fassung
 * bekommt `canonical_press_release_id` auf die erste und verweist per
 * rel=canonical dorthin. Welche Fassung Erstquelle ist, folgt der Kategorie
 * (config/canonical.php, E9); ohne Eintrag gewinnt die zuerst
 * veröffentlichte. Meldungen mit portal=both (eine Zeile, zwei Adressen)
 * folgen derselben Kategorie-Zuordnung beim Rendern.
 *
 * Schreibt über den Query-Builder, damit weder Suchindex noch Aktivitäts-
 * log anspringen — es ändert sich nur die Zuordnung, kein Inhalt.
 */
class CanonicalAssigner
{
    /** @var array<int, string|null> Kategorie-ID → DE-Slug der Hauptkategorie */
    private array $categorySlugs = [];

    public function enabled(): bool
    {
        return (bool) config('canonical.enabled');
    }

    /**
     * Portal, das für die Kategorie der Meldung die Erstquelle führt — null
     * ohne Eintrag in der Zuordnung.
     */
    public function preferredPortal(PressRelease $pressRelease): ?Portal
    {
        if (! $pressRelease->category_id) {
            return null;
        }

        $slug = $this->categorySlug((int) $pressRelease->category_id);
        $portal = $slug !== null ? config('canonical.portal_by_category.'.$slug) : null;

        return is_string($portal) ? Portal::tryFrom($portal) : null;
    }

    /**
     * Öffentliche Adresse, auf die rel=canonical der Meldung zeigt, wenn sie
     * auf `$viewedOn` ausgeliefert wird. Ohne Freigabe (config) oder ohne
     * Zuordnung: die eigene Adresse auf dem aufgerufenen Portal.
     */
    public function canonicalUrlFor(PressRelease $pressRelease, Portal $viewedOn): string
    {
        $self = $this->publicUrl($pressRelease, $viewedOn);

        if (! $this->enabled()) {
            return $self;
        }

        if ($pressRelease->canonical_press_release_id !== null) {
            $canonical = PressRelease::query()->withoutGlobalScopes()->find($pressRelease->canonical_press_release_id);

            if ($canonical !== null && $canonical->isVisibleInArchive()) {
                return $this->publicUrl($canonical, $canonical->portal === Portal::Both ? ($this->preferredPortal($canonical) ?? $viewedOn) : $canonical->portal);
            }

            return $self;
        }

        if ($pressRelease->portal === Portal::Both) {
            return $this->publicUrl($pressRelease, $this->preferredPortal($pressRelease) ?? $viewedOn);
        }

        return $self;
    }

    /**
     * Ob die Meldung auf `$portal` als Erstquelle gilt — nur die gehört in
     * Sitemap und News-Sitemap dieses Portals.
     */
    public function isCanonicalOn(PressRelease $pressRelease, Portal $portal): bool
    {
        if (! $this->enabled()) {
            return true;
        }

        if ($pressRelease->canonical_press_release_id !== null) {
            return false;
        }

        if ($pressRelease->portal === Portal::Both) {
            return ($this->preferredPortal($pressRelease) ?? $portal) === $portal;
        }

        return true;
    }

    /**
     * Zuordnung für eine Meldung und ihre Gegenstücke auf dem anderen Portal
     * neu bestimmen — nach jeder Veröffentlichung.
     */
    public function assignFor(PressRelease $pressRelease): void
    {
        if (! $this->enabled() || $pressRelease->content_hash === null || $pressRelease->portal === Portal::Both) {
            return;
        }

        $counterparts = PressRelease::query()
            ->withoutGlobalScope(PortalScope::class)
            ->published()
            ->where('content_hash', $pressRelease->content_hash)
            ->where('company_id', $pressRelease->company_id)
            ->whereKeyNot($pressRelease->getKey())
            ->where('portal', '!=', $pressRelease->portal->value)
            ->get();

        if ($counterparts->isEmpty()) {
            $this->write($pressRelease->getKey(), null);

            return;
        }

        foreach ($counterparts as $counterpart) {
            $this->assignPair($pressRelease, $counterpart);
        }
    }

    /**
     * Alle Paare im Bestand zuordnen.
     *
     * @param  callable(int $canonicalId, int $duplicateId, bool $changed): void|null  $each
     * @return array{pairs: int, changed: int}
     */
    public function assignAll(bool $dryRun = false, ?callable $each = null): array
    {
        $pairs = 0;
        $changed = 0;

        $this->pairsQuery()->orderBy('a.id')->chunk(500, function ($rows) use ($dryRun, $each, &$pairs, &$changed): void {
            $ids = $rows->flatMap(fn (object $row): array => [(int) $row->a_id, (int) $row->b_id])->unique()->all();
            $releases = PressRelease::query()->withoutGlobalScopes()->findMany($ids)->keyBy('id');

            foreach ($rows as $row) {
                $a = $releases->get((int) $row->a_id);
                $b = $releases->get((int) $row->b_id);

                if (! $a || ! $b) {
                    continue;
                }

                $pairs++;
                $canonical = $this->resolveCanonical($a, $b);
                $duplicate = $canonical->is($a) ? $b : $a;
                $wouldChange = $duplicate->canonical_press_release_id !== $canonical->getKey() || $canonical->canonical_press_release_id !== null;

                if ($wouldChange) {
                    $changed++;

                    if (! $dryRun) {
                        $this->write($duplicate->getKey(), $canonical->getKey());
                        $this->write($canonical->getKey(), null);
                    }
                }

                if ($each !== null) {
                    $each($canonical->getKey(), $duplicate->getKey(), $wouldChange);
                }
            }
        });

        return ['pairs' => $pairs, 'changed' => $changed];
    }

    /**
     * Veröffentlichte Paare gleichen Inhalts derselben Firma auf verschiedenen
     * Portalen (a = kleinere ID).
     */
    public function pairsQuery(): QueryBuilder
    {
        return DB::table('press_releases as a')
            ->join('press_releases as b', function ($join): void {
                $join->on('a.content_hash', '=', 'b.content_hash')
                    ->on('a.company_id', '=', 'b.company_id')
                    ->whereColumn('a.id', '<', 'b.id')
                    ->whereColumn('a.portal', '!=', 'b.portal');
            })
            ->whereNotNull('a.content_hash')
            ->whereNull('a.deleted_at')->whereNull('b.deleted_at')
            ->where('a.status', 'published')->where('b.status', 'published')
            ->whereNull('a.gone_at')->whereNull('b.gone_at')
            ->whereNotIn('a.portal', ['both'])->whereNotIn('b.portal', ['both'])
            ->select(['a.id as a_id', 'b.id as b_id', 'a.category_id', 'a.company_id', 'a.published_at as a_published_at', 'b.published_at as b_published_at']);
    }

    /**
     * Welche der beiden Fassungen Erstquelle ist: die auf dem Kategorie-
     * Portal, sonst die zuerst veröffentlichte (bei Gleichstand die ältere ID).
     */
    public function resolveCanonical(PressRelease $a, PressRelease $b): PressRelease
    {
        $preferred = $this->preferredPortal($a);

        if ($preferred !== null) {
            if ($a->portal === $preferred && $b->portal !== $preferred) {
                return $a;
            }

            if ($b->portal === $preferred && $a->portal !== $preferred) {
                return $b;
            }
        }

        $fallback = (string) config('canonical.fallback', 'first');
        $fallbackPortal = Portal::tryFrom($fallback);

        if ($fallbackPortal !== null) {
            if ($a->portal === $fallbackPortal) {
                return $a;
            }

            if ($b->portal === $fallbackPortal) {
                return $b;
            }
        }

        $aAt = $a->published_at?->getTimestamp() ?? PHP_INT_MAX;
        $bAt = $b->published_at?->getTimestamp() ?? PHP_INT_MAX;

        if ($aAt !== $bAt) {
            return $aAt < $bAt ? $a : $b;
        }

        return $a->getKey() < $b->getKey() ? $a : $b;
    }

    private function assignPair(PressRelease $a, PressRelease $b): void
    {
        $canonical = $this->resolveCanonical($a, $b);
        $duplicate = $canonical->is($a) ? $b : $a;

        $this->write($duplicate->getKey(), $canonical->getKey());
        $this->write($canonical->getKey(), null);
    }

    private function write(int $id, ?int $canonicalId): void
    {
        DB::table('press_releases')
            ->where('id', $id)
            ->where(fn ($query) => $canonicalId === null
                ? $query->whereNotNull('canonical_press_release_id')
                : $query->where('canonical_press_release_id', '!=', $canonicalId)->orWhereNull('canonical_press_release_id'))
            ->update(['canonical_press_release_id' => $canonicalId]);
    }

    private function publicUrl(PressRelease $pressRelease, Portal $portal): string
    {
        if ($portal === Portal::Both) {
            $portal = Portal::Presseecho;
        }

        $edition = in_array($pressRelease->language, SetEdition::EDITIONS, true) ? $pressRelease->language : 'de';
        $base = rtrim((string) match ($portal) {
            Portal::Presseecho => config('domains.domain_presseecho_url'),
            default => config('domains.domain_businessportal_url'),
        }, '/');

        return sprintf('%s/%s/press-release/%s', $base, $edition, $pressRelease->slug);
    }

    private function categorySlug(int $categoryId): ?string
    {
        if (array_key_exists($categoryId, $this->categorySlugs)) {
            return $this->categorySlugs[$categoryId];
        }

        $category = Category::query()->withoutGlobalScopes()->with(['parent.translations', 'translations'])->find($categoryId);
        $root = $category !== null && $category->parent !== null ? $category->parent : $category;
        $slug = $root?->translations->firstWhere('locale', 'de')?->slug;

        return $this->categorySlugs[$categoryId] = is_string($slug) ? $slug : null;
    }
}