393 lines
16 KiB
PHP
393 lines
16 KiB
PHP
<?php
|
|
|
|
namespace App\EventPaymentModules\Modules;
|
|
|
|
use App\Enumerations\RefundAccountSource;
|
|
use App\EventPaymentModules\AbstractEventPaymentModule;
|
|
use App\EventPaymentModules\DTO\CreateInvoiceRequest;
|
|
use App\EventPaymentModules\DTO\GetRefundDataRequest;
|
|
use App\EventPaymentModules\DTO\GetRefundDataResponse;
|
|
use App\EventPaymentModules\DTO\RegistrationRenderContext;
|
|
use App\EventPaymentModules\DTO\RegistrationSummaryRequest;
|
|
use App\EventPaymentModules\DTO\RegistrationSummaryResponse;
|
|
use App\EventPaymentModules\DTO\TransactionMatch;
|
|
use App\EventPaymentModules\ProvidesGiroCode;
|
|
use App\EventPaymentModules\ProvidesStatementRuleset;
|
|
use App\EventPaymentModules\ReadsBankStatements;
|
|
use App\Models\EventParticipant;
|
|
use App\Models\PaymentMethod;
|
|
use App\Providers\GiroCodeProvider;
|
|
use App\Support\Iban;
|
|
use App\ValueObjects\Amount;
|
|
use App\ValueObjects\BankStatementRuleset;
|
|
use App\ValueObjects\BankTransaction;
|
|
use Illuminate\Support\Collection;
|
|
|
|
/**
|
|
* Überweisung auf das Veranstaltungskonto -- die Zahlung erfolgt manuell durch die teilnehmende Person.
|
|
*/
|
|
class AccountTransferPaymentModule extends AbstractEventPaymentModule implements
|
|
ProvidesGiroCode,
|
|
ProvidesStatementRuleset,
|
|
ReadsBankStatements
|
|
{
|
|
/** Admin-Option, unter der das Kontoauszug-Format des Mandanten liegt. */
|
|
public const string OPTION_STATEMENT_RULESET = 'statement_ruleset';
|
|
|
|
/** Teilnehmer-Optionen, die der Zahlungsimport nachträgt (nicht im Anmeldeformular). */
|
|
public const string OPTION_PAYER_ACCOUNT_OWNER = 'payer_account_owner';
|
|
public const string OPTION_PAYER_IBAN = 'payer_iban';
|
|
|
|
public static function slug(): string
|
|
{
|
|
return PaymentMethod::PAYMENT_ACCOUNT_TRANSACTION;
|
|
}
|
|
|
|
public function defaultName(): string
|
|
{
|
|
return 'Überweisung auf Veranstaltungskonto';
|
|
}
|
|
|
|
public function defaultConfiguration(): array
|
|
{
|
|
return ['icon' => 'building-columns'];
|
|
}
|
|
|
|
public function getOptions(): array
|
|
{
|
|
return [
|
|
['name' => 'account_owner', 'label' => 'Kontoinhaber', 'type' => 'string', 'required' => true],
|
|
['name' => 'iban', 'label' => 'IBAN', 'type' => 'string', 'required' => true],
|
|
['name' => 'bic', 'label' => 'BIC', 'type' => 'string', 'required' => false],
|
|
['name' => 'summary_confirmation_text', 'label' => 'Bestätigung durch Teilnehmende (Zusammenfassung, {amount} als Platzhalter)', 'type' => 'string', 'required' => false],
|
|
['name' => 'icon', 'label' => 'Symbol', 'type' => 'icon', 'required' => false],
|
|
[
|
|
'name' => self::OPTION_STATEMENT_RULESET,
|
|
'label' => 'Format des Kontoauszugs (CSV)',
|
|
'type' => 'bank-ruleset',
|
|
'required' => false,
|
|
'scope' => 'tenant',
|
|
'hint' => 'Nur ausfüllen, wenn eure Bank ein anderes Format liefert als der App-Standard. '
|
|
. 'Die Einstellung gilt für alle Aktionen -- auch für bereits laufende.',
|
|
],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Beim Zahlungsimport nachgetragen, nicht beim Anmelden abgefragt: `system => true` blendet die
|
|
* Felder im Anmeldeformular aus. Im Schema müssen sie trotzdem stehen, sonst verwirft
|
|
* {@see sanitizeParticipantOptions()} sie als unbekannte Schlüssel.
|
|
*/
|
|
public function getParticipantOptions(): array
|
|
{
|
|
return [
|
|
[
|
|
'name' => self::OPTION_PAYER_ACCOUNT_OWNER,
|
|
'label' => 'Kontoinhaber*in der Zahlung',
|
|
'type' => 'string',
|
|
'required' => false,
|
|
'system' => true,
|
|
],
|
|
[
|
|
'name' => self::OPTION_PAYER_IBAN,
|
|
'label' => 'IBAN der Zahlung',
|
|
'type' => 'string',
|
|
'required' => false,
|
|
'system' => true,
|
|
],
|
|
];
|
|
}
|
|
|
|
public function statementRuleset(array $configuration): BankStatementRuleset
|
|
{
|
|
$override = $configuration[self::OPTION_STATEMENT_RULESET] ?? null;
|
|
|
|
// Das Frontend schickt das Ruleset als JSON-String durch das generische Options-Formular.
|
|
if (is_string($override)) {
|
|
$decoded = json_decode($override, true);
|
|
$override = is_array($decoded) ? $decoded : null;
|
|
}
|
|
|
|
return BankStatementRuleset::fromConfiguration(is_array($override) ? $override : null);
|
|
}
|
|
|
|
/**
|
|
* Erstattet wird auf das Konto, von dem der Beitrag kam -- und genau das steht seit dem
|
|
* Zahlungsimport in den Teilnehmer-Optionen.
|
|
*
|
|
* Gelesen wird ausschließlich aus `payment_options`, nicht aus dem Kennzeichen `refund_data`:
|
|
* Das ist ein abgeleitetes Merkmal für Listen und Abfragen. Zwei Quellen für dieselbe Wahrheit
|
|
* driften früher oder später auseinander, und die falsche gewänne dann eine Auszahlung.
|
|
*
|
|
* Eine IBAN, die die Prüfziffer nicht besteht, wird nicht gemeldet: Sie würde ungeprüft
|
|
* übernommen und das Geld ginge im Zweifel an eine fremde Person. Lieber wie bisher nachfragen.
|
|
*/
|
|
public function getRefundData(GetRefundDataRequest $request): GetRefundDataResponse
|
|
{
|
|
$response = new GetRefundDataResponse();
|
|
|
|
$options = $request->participant->payment_options ?? [];
|
|
$iban = Iban::normalize((string) ($options[self::OPTION_PAYER_IBAN] ?? ''));
|
|
$owner = trim((string) ($options[self::OPTION_PAYER_ACCOUNT_OWNER] ?? ''));
|
|
|
|
if ($iban === '' || $owner === '' || !Iban::isValid($iban)) {
|
|
return $response;
|
|
}
|
|
|
|
$response->source = RefundAccountSource::Known;
|
|
$response->accountOwner = $owner;
|
|
$response->accountIban = $iban;
|
|
|
|
$paidOn = $request->participant->last_payment_date?->format('d.m.Y');
|
|
$response->sourceNote = $paidOn === null
|
|
? 'Zahlungseingang'
|
|
: 'Zahlungseingang vom ' . $paidOn;
|
|
|
|
return $response;
|
|
}
|
|
|
|
/** Bei der Überweisung zählen Gutschriften -- Belastungen sind Ausgaben der Aktion. */
|
|
public function isRelevantTransaction(BankTransaction $transaction): bool
|
|
{
|
|
return $transaction->isCredit();
|
|
}
|
|
|
|
/**
|
|
* Erkennt die Anmeldung zu einem Zahlungseingang.
|
|
*
|
|
* Die Regeln greifen in fester Reihenfolge und liefern nur dann etwas, wenn **genau eine**
|
|
* Anmeldung passt. Bei zwei Treffern -- zwei Geschwister mit gleichem Nachnamen, zwei
|
|
* Namensgleiche im selben Lager -- gibt es bewusst keinen Vorschlag: die falsche Zuordnung wäre
|
|
* in der Prüfansicht nicht zu erkennen und würde durchgewinkt.
|
|
*
|
|
* @param Collection<int, EventParticipant> $candidates
|
|
*/
|
|
public function matchTransaction(BankTransaction $transaction, Collection $candidates): ?TransactionMatch
|
|
{
|
|
$purpose = $this->normalize($transaction->purpose);
|
|
$payerName = $this->normalize($transaction->payerName);
|
|
$payerIban = Iban::normalize($transaction->payerIban);
|
|
|
|
// 1) Der beim Anmelden erzeugte Verwendungszweck steht unverändert im Auszug -- der Normalfall.
|
|
$match = $this->onlyOne($candidates, function (EventParticipant $participant) use ($purpose): bool {
|
|
$reference = $this->normalize((string) $participant->payment_purpose);
|
|
|
|
return $reference !== '' && str_contains($purpose, $reference);
|
|
});
|
|
if ($match !== null) {
|
|
return new TransactionMatch($match);
|
|
}
|
|
|
|
// 2) Verwendungszweck abgetippt oder gekürzt, aber beide Namen sind noch drin.
|
|
$match = $this->onlyOne($candidates, function (EventParticipant $participant) use ($purpose): bool {
|
|
$firstname = $this->normalize((string) $participant->firstname);
|
|
$lastname = $this->normalize((string) $participant->lastname);
|
|
|
|
return $firstname !== '' && $lastname !== ''
|
|
&& str_contains($purpose, $firstname) && str_contains($purpose, $lastname);
|
|
});
|
|
if ($match !== null) {
|
|
return new TransactionMatch($match);
|
|
}
|
|
|
|
// 3) Folgezahlung: Von diesem Konto kam bereits ein Beitrag für genau eine Anmeldung.
|
|
if ($payerIban !== '') {
|
|
$match = $this->onlyOne($candidates, static function (EventParticipant $participant) use ($payerIban): bool {
|
|
$known = (string) (($participant->payment_options ?? [])[self::OPTION_PAYER_IBAN] ?? '');
|
|
|
|
return $known !== '' && Iban::normalize($known) === $payerIban;
|
|
});
|
|
if ($match !== null) {
|
|
return new TransactionMatch($match);
|
|
}
|
|
}
|
|
|
|
// 4) Nur der Nachname im Zweck, aber der Betrag trifft den offenen Rest auf den Cent.
|
|
$match = $this->onlyOne($candidates, function (EventParticipant $participant) use ($purpose, $transaction): bool {
|
|
$lastname = $this->normalize((string) $participant->lastname);
|
|
if ($lastname === '' || !str_contains($purpose, $lastname)) {
|
|
return false;
|
|
}
|
|
|
|
return round($this->amountLeft($participant)->getAmount(), 2) === round($transaction->amount->getAmount(), 2);
|
|
});
|
|
if ($match !== null) {
|
|
return new TransactionMatch($match);
|
|
}
|
|
|
|
// 5) Der Zweck sagt nichts, aber das Konto läuft auf den Namen der Anmeldung. Das trägt oft,
|
|
// liegt aber bei Eltern- und Gemeinschaftskonten auch daneben -- deshalb nur „unsicher".
|
|
if ($payerName !== '') {
|
|
$match = $this->onlyOne($candidates, function (EventParticipant $participant) use ($payerName): bool {
|
|
$firstname = $this->normalize((string) $participant->firstname);
|
|
$lastname = $this->normalize((string) $participant->lastname);
|
|
|
|
return $lastname !== '' && $payerName === $firstname . $lastname;
|
|
});
|
|
if ($match !== null) {
|
|
return new TransactionMatch($match, TransactionMatch::CONFIDENCE_UNCERTAIN);
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Hält fest, von welchem Konto der Beitrag kam.
|
|
*
|
|
* Das ist mehr als eine Notiz: Erstattet wird ausschließlich auf das Konto, von dem der Beitrag
|
|
* gezahlt wurde. Bisher muss die teilnehmende Person das selbst zusichern, weil die App es nicht
|
|
* weiß -- mit `refund_data` weiß sie es.
|
|
*
|
|
* Eine IBAN, die die Prüfziffer nicht besteht, wird nicht übernommen: Auf ein Konto mit
|
|
* Zahlendreher zu erstatten hieße, das Geld an eine fremde Person zu überweisen.
|
|
*/
|
|
public function recordTransaction(EventParticipant $participant, BankTransaction $transaction): void
|
|
{
|
|
$iban = Iban::normalize($transaction->payerIban);
|
|
$owner = trim($transaction->payerName);
|
|
|
|
if ($iban === '' || !Iban::isValid($iban)) {
|
|
return;
|
|
}
|
|
|
|
$options = $participant->payment_options ?? [];
|
|
|
|
// Die jüngste Zahlung gewinnt: Erstattet wird auf das Konto, von dem der Beitrag kam --
|
|
// zahlt jemand die zweite Rate von einem anderen Konto, ist das nun dieses.
|
|
$options[self::OPTION_PAYER_IBAN] = $iban;
|
|
|
|
// Einen bereits bekannten Kontoinhaber nicht durch einen leeren Namen ersetzen: Manche Banken
|
|
// lassen das Feld bei Folgezahlungen leer, und ohne Inhaber ist die IBAN für die Erstattung
|
|
// wertlos.
|
|
if ($owner !== '') {
|
|
$options[self::OPTION_PAYER_ACCOUNT_OWNER] = $owner;
|
|
}
|
|
|
|
$participant->payment_options = $options;
|
|
|
|
// Nur hochsetzen, nie zurück: Was wir einmal wissen, wissen wir.
|
|
if (($options[self::OPTION_PAYER_ACCOUNT_OWNER] ?? '') !== '') {
|
|
$participant->refund_data = true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Genau ein Treffer oder nichts.
|
|
*
|
|
* @param Collection<int, EventParticipant> $candidates
|
|
* @param callable(EventParticipant): bool $matches
|
|
*/
|
|
private function onlyOne(Collection $candidates, callable $matches): ?EventParticipant
|
|
{
|
|
$hits = $candidates->filter($matches);
|
|
|
|
return $hits->count() === 1 ? $hits->first() : null;
|
|
}
|
|
|
|
/** Noch offener Beitrag. `clone`, weil Amount seine Rechenoperationen auf sich selbst ausführt. */
|
|
private function amountLeft(EventParticipant $participant): Amount
|
|
{
|
|
$amountLeft = clone $participant->amount;
|
|
|
|
if ($participant->amount_paid !== null) {
|
|
$amountLeft->subtractAmount($participant->amount_paid);
|
|
}
|
|
|
|
return $amountLeft;
|
|
}
|
|
|
|
/** Kleinschreibung, Umlaute aufgelöst, alles außer [a-z0-9] raus. */
|
|
private function normalize(string $value): string
|
|
{
|
|
$value = mb_strtolower(trim($value));
|
|
|
|
$value = strtr($value, [
|
|
'ä' => 'ae', 'ö' => 'oe', 'ü' => 'ue', 'ß' => 'ss',
|
|
'á' => 'a', 'à' => 'a', 'â' => 'a', 'é' => 'e', 'è' => 'e', 'ê' => 'e',
|
|
'í' => 'i', 'ì' => 'i', 'ó' => 'o', 'ò' => 'o', 'ô' => 'o', 'ú' => 'u', 'ù' => 'u',
|
|
'ç' => 'c', 'ñ' => 'n',
|
|
]);
|
|
|
|
return preg_replace('/[^a-z0-9]/', '', $value) ?? '';
|
|
}
|
|
|
|
public function registrationSummary(RegistrationSummaryRequest $request): RegistrationSummaryResponse
|
|
{
|
|
$participant = $request->participant;
|
|
$config = $request->configuration;
|
|
|
|
$amountLeft = $this->amountLeft($participant);
|
|
|
|
$hasPaymentInformation = $amountLeft->getAmount() > 0;
|
|
|
|
// GiroCode nur bei offenem Betrag; Bildquelle je Render-Kontext (Web-Endpoint vs. Mail-CID).
|
|
$giroCodeSrc = null;
|
|
if ($hasPaymentInformation) {
|
|
$giroCodeSrc = $request->context === RegistrationRenderContext::Mail
|
|
? 'cid:girocode.png'
|
|
: '/print-girocode/' . $participant->identifier;
|
|
}
|
|
|
|
// Medien-gerechtes Template je Render-Kontext (Web: SPA-Klassen, Mail: E-Mail-tauglich).
|
|
$view = $request->context === RegistrationRenderContext::Mail
|
|
? 'payment-modules.account-transfer.mail'
|
|
: 'payment-modules.account-transfer.web';
|
|
|
|
$response = new RegistrationSummaryResponse();
|
|
$response->hasPaymentInformation = $hasPaymentInformation;
|
|
$response->html = view($view, [
|
|
'accountOwner' => (string)($config['account_owner'] ?? ''),
|
|
'iban' => (string)($config['iban'] ?? ''),
|
|
'paymentPurpose' => (string)$participant->payment_purpose,
|
|
'amount' => $amountLeft->toString(),
|
|
'giroCodeSrc' => $giroCodeSrc,
|
|
'reminderUrl' => url('/api/v1/event/participant/' . $participant->identifier . '/ical-payment'),
|
|
'paymentDeadline' => $participant->event?->registration_final_end?->format('d.m.Y'),
|
|
])->render();
|
|
|
|
return $response;
|
|
}
|
|
|
|
public function giroCode(EventParticipant $participant, array $configuration): ?string
|
|
{
|
|
$amountLeft = $this->amountLeft($participant);
|
|
|
|
if ($amountLeft->getAmount() <= 0) {
|
|
return null;
|
|
}
|
|
|
|
$provider = new GiroCodeProvider(
|
|
(string)($configuration['account_owner'] ?? ''),
|
|
(string)($configuration['iban'] ?? ''),
|
|
$amountLeft->getAmount(),
|
|
(string)$participant->payment_purpose,
|
|
);
|
|
|
|
return (string)$provider->create();
|
|
}
|
|
|
|
protected function invoiceClosingStatement(CreateInvoiceRequest $request): string
|
|
{
|
|
$config = $request->configuration;
|
|
$deadline = $request->event->registration_final_end?->format('d.m.Y');
|
|
|
|
$sentence = $deadline !== null
|
|
? sprintf('Bitte überweise %s bis zum %s auf folgendes Konto:', $request->amount->toString(), $deadline)
|
|
: sprintf('Bitte überweise %s auf folgendes Konto:', $request->amount->toString());
|
|
|
|
$lines = [
|
|
'Kontoinhaber*in: ' . (string) ($config['account_owner'] ?? ''),
|
|
'IBAN: ' . (string) ($config['iban'] ?? ''),
|
|
];
|
|
|
|
if (($config['bic'] ?? '') !== '') {
|
|
$lines[] = 'BIC: ' . (string) $config['bic'];
|
|
}
|
|
|
|
$lines[] = 'Verwendungszweck: ' . (string) $request->participant->payment_purpose;
|
|
|
|
return $sentence . '<br />' . implode('<br />', array_map(e(...), $lines));
|
|
}
|
|
}
|