057075368c
Toggle „Regel anlegen“ in der Buchungsmaske (Fix #94); beim Speichern entsteht daraus eine Regel (AbgleichRegel::ausBuchung()), die das Kontoblatt danach in einem modalen Dialog zum Prüfen und Anpassen zeigt. Abbruch (auch per Escape) verwirft die Regel wieder, Speichern übernimmt Änderungen. Die Regelfelder sind aus regeln.php in regelfelder.php ausgelagert, damit beide Formulare dieselbe Bauart teilen. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
454 lines
16 KiB
PHP
454 lines
16 KiB
PHP
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace Finanzmanager\Models;
|
||
|
||
use Finanzmanager\Database;
|
||
use Finanzmanager\Mandant;
|
||
|
||
/**
|
||
* Regeln, die abgerufenen Umsätzen ihre Kategorie geben.
|
||
*
|
||
* Eine Regel prüft ein Muster gegen Empfänger und/oder Verwendungszweck und
|
||
* hängt bei einem Treffer Kategorie, Klasse, Gegenkonto oder ein festes
|
||
* Split-Schema an. Die erste passende Regel gewinnt – sortiert nach Priorität,
|
||
* bei Gleichstand nach Name. Kein Sammeln über mehrere Regeln: Wenn zwei Regeln
|
||
* verschiedene Kategorien setzen wollten, wäre nicht mehr nachvollziehbar,
|
||
* warum am Ende die eine dasteht.
|
||
*/
|
||
class AbgleichRegel
|
||
{
|
||
public const FELDER = [
|
||
'beides' => 'Empfänger und Verwendungszweck',
|
||
'empfaenger' => 'Nur Empfänger',
|
||
'verwendungszweck' => 'Nur Verwendungszweck',
|
||
];
|
||
|
||
public const VERGLEICHE = [
|
||
'enthaelt' => 'enthält',
|
||
'beginnt' => 'beginnt mit',
|
||
'endet' => 'endet auf',
|
||
'regex' => 'regulärer Ausdruck',
|
||
];
|
||
|
||
/** @return list<array<string,mixed>> */
|
||
public static function alle(bool $nurAktive = false): array
|
||
{
|
||
$sql = 'SELECT r.*, k.pfad AS kategorie_pfad, kl.name AS klassenname, g.name AS gegenkontoname
|
||
FROM abgleich_regeln r
|
||
LEFT JOIN kategorien k ON k.id = r.kategorie_id
|
||
LEFT JOIN klassen kl ON kl.id = r.klasse_id
|
||
LEFT JOIN konten g ON g.id = r.gegenkonto_id
|
||
WHERE r.benutzer_id = ?';
|
||
if ($nurAktive) {
|
||
$sql .= ' AND r.aktiv = 1';
|
||
}
|
||
|
||
return Database::fetchAll($sql . ' ORDER BY r.prioritaet, r.name', [Mandant::id()]);
|
||
}
|
||
|
||
public static function find(int $id): ?array
|
||
{
|
||
$zeile = Database::fetchOne(
|
||
'SELECT * FROM abgleich_regeln WHERE id = ? AND benutzer_id = ?',
|
||
[$id, Mandant::id()]
|
||
);
|
||
return $zeile === false ? null : $zeile;
|
||
}
|
||
|
||
/** @param array<string,mixed> $daten */
|
||
public static function anlegen(array $daten): int
|
||
{
|
||
$f = self::normalisiere($daten);
|
||
|
||
Database::execute(
|
||
'INSERT INTO abgleich_regeln
|
||
(benutzer_id, name, feld, vergleich, muster, betrag_von, betrag_bis,
|
||
kategorie_id, klasse_id, gegenkonto_id, splits, prioritaet, aktiv)
|
||
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)',
|
||
[
|
||
Mandant::id(), $f['name'], $f['feld'], $f['vergleich'], $f['muster'],
|
||
$f['betrag_von'], $f['betrag_bis'], $f['kategorie_id'], $f['klasse_id'],
|
||
$f['gegenkonto_id'], $f['splits'], $f['prioritaet'], $f['aktiv'],
|
||
]
|
||
);
|
||
|
||
return Database::lastInsertId();
|
||
}
|
||
|
||
/** @param array<string,mixed> $daten */
|
||
public static function speichern(int $id, array $daten): void
|
||
{
|
||
$f = self::normalisiere($daten);
|
||
|
||
Database::execute(
|
||
'UPDATE abgleich_regeln SET name = ?, feld = ?, vergleich = ?, muster = ?,
|
||
betrag_von = ?, betrag_bis = ?, kategorie_id = ?, klasse_id = ?,
|
||
gegenkonto_id = ?, splits = ?, prioritaet = ?, aktiv = ?
|
||
WHERE id = ? AND benutzer_id = ?',
|
||
[
|
||
$f['name'], $f['feld'], $f['vergleich'], $f['muster'], $f['betrag_von'],
|
||
$f['betrag_bis'], $f['kategorie_id'], $f['klasse_id'], $f['gegenkonto_id'],
|
||
$f['splits'], $f['prioritaet'], $f['aktiv'], $id, Mandant::id(),
|
||
]
|
||
);
|
||
}
|
||
|
||
public static function loeschen(int $id): void
|
||
{
|
||
Database::execute('DELETE FROM abgleich_regeln WHERE id = ? AND benutzer_id = ?', [$id, Mandant::id()]);
|
||
}
|
||
|
||
/**
|
||
* Baut aus einer bestehenden Buchung eine neue Regel – der Ausgangspunkt für
|
||
* die Buchungsmaske, die eine Buchung direkt in eine Regel verwandeln kann.
|
||
* Das Muster kommt vom Empfänger, ersatzweise vom Buchungstext; ist beides
|
||
* leer, gibt es kein sinnvolles Muster und keine Regel entsteht.
|
||
*
|
||
* @return int|null Die id der neuen Regel, oder null ohne Muster
|
||
*/
|
||
public static function ausBuchung(int $buchungId): ?int
|
||
{
|
||
$buchung = Buchung::find($buchungId);
|
||
if ($buchung === null) {
|
||
throw new \RuntimeException('Die Buchung gibt es nicht.');
|
||
}
|
||
|
||
$empfaenger = trim((string)($buchung['empfaenger'] ?? ''));
|
||
$zweck = trim((string)($buchung['buchungstext'] ?? ''));
|
||
|
||
if ($empfaenger !== '') {
|
||
$feld = 'empfaenger';
|
||
} elseif ($zweck !== '') {
|
||
$feld = 'verwendungszweck';
|
||
} else {
|
||
return null;
|
||
}
|
||
|
||
$splitzeilen = array_values(array_filter(
|
||
Buchung::splits($buchungId),
|
||
static fn(array $zeile): bool => (int)($zeile['kategorie_id'] ?? 0) !== 0
|
||
));
|
||
|
||
// Anteile am Buchungsbetrag statt roher Beträge: So zeigt der Dialog
|
||
// gleich sinnvolle Prozentwerte statt der Centbeträge der Buchung –
|
||
// splitzeilen() liest den Anteil als Bruchteil von 1.
|
||
$gesamt = array_sum(array_map(
|
||
static fn(array $zeile): float => abs((float)$zeile['betrag']),
|
||
$splitzeilen
|
||
));
|
||
|
||
$splits = [];
|
||
foreach ($splitzeilen as $zeile) {
|
||
$splits[] = [
|
||
'kategorie_id' => (int)$zeile['kategorie_id'],
|
||
'klasse_id' => $zeile['klasse_id'],
|
||
'anteil' => $gesamt > 0.0 ? round(abs((float)$zeile['betrag']) / $gesamt, 4) : 0,
|
||
'notiz' => (string)($zeile['notiz'] ?? ''),
|
||
];
|
||
}
|
||
|
||
return self::anlegen([
|
||
'name' => $empfaenger !== '' ? $empfaenger : $zweck,
|
||
'feld' => $feld,
|
||
'vergleich' => 'enthaelt',
|
||
'muster' => $empfaenger !== '' ? $empfaenger : $zweck,
|
||
'kategorie_id' => $buchung['kategorie_id'],
|
||
'klasse_id' => $buchung['klasse_id'],
|
||
'gegenkonto_id' => $buchung['gegenkonto_id'],
|
||
'splits' => $splits === [] ? null : $splits,
|
||
'prioritaet' => 100,
|
||
'aktiv' => 1,
|
||
]);
|
||
}
|
||
|
||
/**
|
||
* Die erste Regel, die auf den Umsatz passt.
|
||
*
|
||
* @param array<string,mixed> $umsatz
|
||
* @param list<array<string,mixed>>|null $regeln vorgeladene Regeln, sonst werden sie geholt
|
||
* @return array<string,mixed>|null
|
||
*/
|
||
public static function passendeRegel(array $umsatz, ?array $regeln = null): ?array
|
||
{
|
||
foreach ($regeln ?? self::alle(true) as $regel) {
|
||
if (self::passt($regel, $umsatz)) {
|
||
return $regel;
|
||
}
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
/**
|
||
* @param array<string,mixed> $regel
|
||
* @param array<string,mixed> $umsatz
|
||
*/
|
||
public static function passt(array $regel, array $umsatz): bool
|
||
{
|
||
$betrag = round((float)($umsatz['betrag'] ?? 0), 2);
|
||
|
||
// Betragsgrenzen vergleichen den Wert mit Vorzeichen: „von −60 bis −40“
|
||
// trifft Lastschriften zwischen 40 und 60 Euro.
|
||
if ($regel['betrag_von'] !== null && $betrag < (float)$regel['betrag_von']) {
|
||
return false;
|
||
}
|
||
if ($regel['betrag_bis'] !== null && $betrag > (float)$regel['betrag_bis']) {
|
||
return false;
|
||
}
|
||
|
||
$muster = (string)$regel['muster'];
|
||
if ($muster === '') {
|
||
return false;
|
||
}
|
||
|
||
foreach (self::felderZumVergleich($regel, $umsatz) as $text) {
|
||
if (self::trifft((string)$regel['vergleich'], $muster, $text)) {
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* Was eine Regel dem Umsatz mitgibt. Splits werden erst hier aus dem
|
||
* Prozentschema in Beträge umgerechnet – dieselbe Regel passt so auf
|
||
* Rechnungen jeder Höhe.
|
||
*
|
||
* Die Anteile gelten dabei **zueinander**, nicht absolut: Sie werden auf
|
||
* ihre eigene Summe bezogen. Wer 60 zu 30 einträgt, meint zwei Drittel zu
|
||
* einem Drittel – bei absoluter Rechnung bekäme die letzte Zeile als Rest
|
||
* plötzlich 40 statt 30 Prozent, und niemand fände den Fehler wieder.
|
||
*
|
||
* @param array<string,mixed> $regel
|
||
* @param array<string,mixed> $umsatz
|
||
* @return array{kategorie_id: ?int, klasse_id: ?int, gegenkonto_id: ?int, splits: list<array<string,mixed>>}
|
||
*/
|
||
public static function anwenden(array $regel, array $umsatz): array
|
||
{
|
||
$betrag = round((float)($umsatz['betrag'] ?? 0), 2);
|
||
$splits = [];
|
||
|
||
$schema = json_decode((string)($regel['splits'] ?? ''), true);
|
||
$schema = is_array($schema) ? $schema : [];
|
||
|
||
$gesamt = 0.0;
|
||
foreach ($schema as $zeile) {
|
||
$gesamt += max(0.0, (float)($zeile['anteil'] ?? 0));
|
||
}
|
||
|
||
if ($gesamt > 0.0) {
|
||
$summe = 0.0;
|
||
foreach ($schema as $nummer => $zeile) {
|
||
$anteil = max(0.0, (float)($zeile['anteil'] ?? 0));
|
||
$teil = round($betrag * $anteil / $gesamt, 2);
|
||
|
||
// Die letzte Zeile bekommt den Rest, damit die Summe der Splits
|
||
// auf den Cent zum Buchungsbetrag passt – bei 1/3 zu 2/3 ginge
|
||
// sonst ein Cent verloren, und die Buchung ließe sich nicht
|
||
// speichern.
|
||
if ($nummer === array_key_last($schema)) {
|
||
$teil = round($betrag - $summe, 2);
|
||
}
|
||
$summe += $teil;
|
||
|
||
$splits[] = [
|
||
'kategorie_id' => ($zeile['kategorie_id'] ?? null) ?: null,
|
||
'klasse_id' => ($zeile['klasse_id'] ?? null) ?: null,
|
||
'betrag' => $teil,
|
||
'notiz' => (string)($zeile['notiz'] ?? ''),
|
||
];
|
||
}
|
||
}
|
||
|
||
return [
|
||
'kategorie_id' => $regel['kategorie_id'] === null ? null : (int)$regel['kategorie_id'],
|
||
'klasse_id' => $regel['klasse_id'] === null ? null : (int)$regel['klasse_id'],
|
||
'gegenkonto_id' => $regel['gegenkonto_id'] === null ? null : (int)$regel['gegenkonto_id'],
|
||
'splits' => $splits,
|
||
];
|
||
}
|
||
|
||
/**
|
||
* Das gespeicherte Schema zurück in Formularzeilen – Anteile als Prozent,
|
||
* denn in Prozent wird auch eingegeben.
|
||
*
|
||
* @param array<string,mixed> $regel
|
||
* @return list<array<string,mixed>>
|
||
*/
|
||
public static function splitzeilen(array $regel): array
|
||
{
|
||
$schema = json_decode((string)($regel['splits'] ?? ''), true);
|
||
if (!is_array($schema)) {
|
||
return [];
|
||
}
|
||
|
||
$zeilen = [];
|
||
foreach ($schema as $zeile) {
|
||
if (!is_array($zeile)) {
|
||
continue;
|
||
}
|
||
|
||
$zeilen[] = [
|
||
'kategorie_id' => (int)($zeile['kategorie_id'] ?? 0) ?: null,
|
||
'klasse_id' => (int)($zeile['klasse_id'] ?? 0) ?: null,
|
||
'prozent' => round((float)($zeile['anteil'] ?? 0) * 100, 2),
|
||
'notiz' => (string)($zeile['notiz'] ?? ''),
|
||
];
|
||
}
|
||
|
||
return $zeilen;
|
||
}
|
||
|
||
public static function zaehleTreffer(int $id): void
|
||
{
|
||
Database::execute('UPDATE abgleich_regeln SET treffer = treffer + 1 WHERE id = ?', [$id]);
|
||
}
|
||
|
||
/**
|
||
* Prüft ein Muster, bevor es gespeichert wird. Ein ungültiger regulärer
|
||
* Ausdruck brächte sonst jeden Abruf zum Stehen.
|
||
*/
|
||
public static function musterIstGueltig(string $vergleich, string $muster): bool
|
||
{
|
||
if ($vergleich !== 'regex') {
|
||
return $muster !== '';
|
||
}
|
||
|
||
return @preg_match(self::alsRegex($muster), '') !== false;
|
||
}
|
||
|
||
/**
|
||
* @param array<string,mixed> $regel
|
||
* @param array<string,mixed> $umsatz
|
||
* @return list<string>
|
||
*/
|
||
private static function felderZumVergleich(array $regel, array $umsatz): array
|
||
{
|
||
$empfaenger = (string)($umsatz['empfaenger'] ?? '');
|
||
$zweck = (string)($umsatz['verwendungszweck'] ?? '');
|
||
|
||
return match ((string)$regel['feld']) {
|
||
'empfaenger' => [$empfaenger],
|
||
'verwendungszweck' => [$zweck],
|
||
default => [$empfaenger, $zweck],
|
||
};
|
||
}
|
||
|
||
private static function trifft(string $vergleich, string $muster, string $text): bool
|
||
{
|
||
if ($text === '') {
|
||
return false;
|
||
}
|
||
|
||
// Groß- und Kleinschreibung spielt keine Rolle: Banken schreiben denselben
|
||
// Empfänger mal in Versalien, mal gemischt.
|
||
$textKlein = mb_strtolower($text);
|
||
$musterKlein = mb_strtolower($muster);
|
||
|
||
return match ($vergleich) {
|
||
'beginnt' => str_starts_with($textKlein, $musterKlein),
|
||
'endet' => str_ends_with($textKlein, $musterKlein),
|
||
'regex' => @preg_match(self::alsRegex($muster), $text) === 1,
|
||
default => str_contains($textKlein, $musterKlein),
|
||
};
|
||
}
|
||
|
||
/** Das Muster wird als Ausdruck ohne Trenner erwartet – die setzt erst diese Methode. */
|
||
private static function alsRegex(string $muster): string
|
||
{
|
||
return '/' . str_replace('/', '\/', $muster) . '/iu';
|
||
}
|
||
|
||
/**
|
||
* @param array<string,mixed> $daten
|
||
* @return array<string,mixed>
|
||
*/
|
||
private static function normalisiere(array $daten): array
|
||
{
|
||
$name = trim((string)($daten['name'] ?? ''));
|
||
if ($name === '') {
|
||
throw new \InvalidArgumentException('Die Regel braucht einen Namen.');
|
||
}
|
||
|
||
$feld = (string)($daten['feld'] ?? 'beides');
|
||
$vergleich = (string)($daten['vergleich'] ?? 'enthaelt');
|
||
$muster = trim((string)($daten['muster'] ?? ''));
|
||
|
||
if ($muster === '') {
|
||
throw new \InvalidArgumentException('Die Regel braucht ein Muster.');
|
||
}
|
||
if (!self::musterIstGueltig($vergleich, $muster)) {
|
||
throw new \InvalidArgumentException('Das Muster ist kein gültiger regulärer Ausdruck.');
|
||
}
|
||
|
||
$grenze = static function (mixed $wert): ?float {
|
||
return ($wert === null || $wert === '') ? null : round((float)$wert, 2);
|
||
};
|
||
|
||
$id = static function (mixed $wert): ?int {
|
||
return ($wert === null || $wert === '' || (int)$wert === 0) ? null : (int)$wert;
|
||
};
|
||
|
||
$splits = $daten['splits'] ?? null;
|
||
if (is_array($splits)) {
|
||
$splits = self::splitschema($splits);
|
||
} elseif (is_string($splits) && trim($splits) !== '') {
|
||
$splits = self::splitschema((array)json_decode($splits, true));
|
||
} else {
|
||
$splits = null;
|
||
}
|
||
|
||
return [
|
||
'name' => mb_substr($name, 0, 128),
|
||
'feld' => array_key_exists($feld, self::FELDER) ? $feld : 'beides',
|
||
'vergleich' => array_key_exists($vergleich, self::VERGLEICHE) ? $vergleich : 'enthaelt',
|
||
'muster' => mb_substr($muster, 0, 255),
|
||
'betrag_von' => $grenze($daten['betrag_von'] ?? null),
|
||
'betrag_bis' => $grenze($daten['betrag_bis'] ?? null),
|
||
'kategorie_id' => $id($daten['kategorie_id'] ?? null),
|
||
'klasse_id' => $id($daten['klasse_id'] ?? null),
|
||
'gegenkonto_id' => $id($daten['gegenkonto_id'] ?? null),
|
||
'splits' => $splits,
|
||
'prioritaet' => (int)($daten['prioritaet'] ?? 100),
|
||
'aktiv' => !empty($daten['aktiv']) ? 1 : 0,
|
||
];
|
||
}
|
||
|
||
/**
|
||
* Bringt ein Split-Schema in Form: je Zeile eine Kategorie und ein Anteil.
|
||
* Zeilen ohne Kategorie oder ohne Anteil fallen weg.
|
||
*
|
||
* Der Anteil wird nicht auf 1 gedeckelt: Er gilt im Verhältnis zu den
|
||
* übrigen Zeilen (siehe `anwenden()`), 100 Prozent sind also keine Grenze,
|
||
* sondern nur der bequemste Weg, ein Verhältnis aufzuschreiben.
|
||
*
|
||
* @param array<int|string, mixed> $roh
|
||
*/
|
||
private static function splitschema(array $roh): ?string
|
||
{
|
||
$zeilen = [];
|
||
foreach ($roh as $zeile) {
|
||
if (!is_array($zeile)) {
|
||
continue;
|
||
}
|
||
$kategorie = (int)($zeile['kategorie_id'] ?? 0);
|
||
$anteil = (float)($zeile['anteil'] ?? 0);
|
||
|
||
if ($kategorie === 0 || $anteil <= 0.0) {
|
||
continue;
|
||
}
|
||
|
||
$zeilen[] = [
|
||
'kategorie_id' => $kategorie,
|
||
'klasse_id' => (int)($zeile['klasse_id'] ?? 0) ?: null,
|
||
'anteil' => round($anteil, 4),
|
||
'notiz' => mb_substr(trim((string)($zeile['notiz'] ?? '')), 0, 255),
|
||
];
|
||
}
|
||
|
||
return $zeilen === [] ? null : json_encode($zeilen, JSON_UNESCAPED_UNICODE);
|
||
}
|
||
}
|