fe40a29f35
Eine Umbuchung war auf dem Gegenkonto nicht mehr zuzuordnen: Die Zeile trug die
Marke „Umbuchung“, die Kategoriespalte daneben blieb leer. Die Daten waren
richtig, die Anzeige verschwieg sie. In der Kategoriespalte steht jetzt auch in
der Gegensicht das Konto in eckigen Klammern, von dem die Umbuchung kommt – die
Abfrage lieferte es längst mit.
Kategorie und Gegenkonto stehen in einem Feld (`Views/buchungen/zuordnungsliste.php`):
Unter den Kategorien stehen die eigenen Konten in eckigen Klammern, wie im
FinanzManager, dessen Kategoriefeld `[Konto]` annimmt. Eines davon macht die
Buchung zur Umbuchung; die Auswahl „Ausgabe / Einnahme“ bestimmt seither nur
noch die Richtung. Dieselbe Liste steht in den Splitzeilen – eine Splitzeile mit
Gegenkonto ließ sich bisher nur im Import anlegen und ging beim Bearbeiten der
Buchung stillschweigend verloren.
Schnellzuordnung: Ein Klick auf die Kategoriespalte öffnet die Liste in der
Zelle, die Auswahl speichert sofort (POST /buchungen/{id}/zuordnung) und kommt
in dieselbe Ansicht zurück. Die Liste gibt es einmal und wandert in die
angeklickte Zelle – eine Liste je Zeile wären bei hundert Zeilen ebenso viele
vollständige Kategoriebäume im HTML. Feld und Liste sind gleich breit und gleich
hoch, sonst rückte beim Anklicken die halbe Zeile. Ohne JavaScript führt
derselbe Klick in die Buchungsmaske: Die Zelle ist ein Link. Die Gegenseite
einer fremden Umbuchung führt zu ihrer Buchung auf dem anderen Konto.
Der Eintrag „Splitbuchung“ öffnet ein modales Fenster mit Zeilen für Kategorie
oder Gegenkonto, Klasse, Notiz und Betrag; der Restbetrag wird mitgerechnet. Ein
Klick auf eine bereits gesplittete Buchung öffnet direkt den Dialog. „Splitbuchung
löschen“ verwirft alle Zeilen samt ihren Zuordnungen – auch die Gegenseite einer
Splitzeile mit Gegenkonto –, die Buchung steht danach unzugeordnet im Kontoblatt.
Beide Wege gehen über `Buchung::zuordnen()` und `Buchung::splitsErsetzen()`,
achten den Monatsabschluss und lassen den Rest der Buchung unberührt.
`public/static/betrag.js` bündelt das Lesen deutscher Beträge und die
Restbetragsrechnung für Maske und Kontoblatt.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
417 lines
14 KiB
PHP
417 lines
14 KiB
PHP
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace Finanzmanager\Controllers;
|
||
|
||
use Finanzmanager\Models\Buchung;
|
||
use Finanzmanager\Models\Einstellung;
|
||
use Finanzmanager\Models\Kategorie;
|
||
use Finanzmanager\Models\Klasse;
|
||
use Finanzmanager\Models\Konto;
|
||
use Finanzmanager\View;
|
||
|
||
/**
|
||
* Kontoblatt und Buchungsmaske.
|
||
*
|
||
* Das Kontoblatt zeigt eigene Buchungen und die Gegenseiten fremder
|
||
* Umbuchungen; Letztere lassen sich nur auf ihrem Ursprungskonto bearbeiten,
|
||
* damit eine Umbuchung nicht aus zwei Richtungen widersprüchlich geändert wird.
|
||
*/
|
||
class BuchungenController extends BaseController
|
||
{
|
||
/** @param array<string,string> $params */
|
||
public function kontoblatt(array $params): void
|
||
{
|
||
$this->verlangeAnmeldung();
|
||
|
||
$konto = Konto::find((int)$params['id']);
|
||
if ($konto === null) {
|
||
$this->nichtGefunden('/konten/' . $params['id']);
|
||
return;
|
||
}
|
||
|
||
$filter = [
|
||
'suche' => $this->query('suche'),
|
||
'von' => $this->query('von'),
|
||
'bis' => $this->query('bis'),
|
||
'kategorie_id' => $this->query('kategorie_id'),
|
||
'klasse_id' => $this->query('klasse_id'),
|
||
'nur_offene' => $this->query('nur_offene') === '1',
|
||
];
|
||
|
||
$zeilen = Buchung::kontoblatt((int)$konto['id'], $filter);
|
||
|
||
// Die neuesten Buchungen zuerst zeigen, den Saldo aber chronologisch
|
||
// aufbauen – deshalb erst rechnen, dann umdrehen.
|
||
$zeilen = array_reverse($zeilen);
|
||
$grenze = Einstellung::getInt('zeilen_pro_seite', 100);
|
||
$gesamt = count($zeilen);
|
||
$seite = max(1, (int)$this->query('seite', '1'));
|
||
$zeilen = array_slice($zeilen, ($seite - 1) * $grenze, $grenze);
|
||
|
||
// Die Splitzeilen der angezeigten Buchungen in einer Abfrage – der
|
||
// Splitdialog zeigt damit eine bestehende Aufteilung, ohne sie
|
||
// nachzuladen.
|
||
$gesplittete = [];
|
||
foreach ($zeilen as $zeile) {
|
||
if ((int)$zeile['gesplittet'] === 1 && !$zeile['gegensicht']) {
|
||
$gesplittete[] = (int)$zeile['id'];
|
||
}
|
||
}
|
||
|
||
$this->render('buchungen/kontoblatt.php', [
|
||
'titel' => 'Kontoblatt: ' . $konto['name'],
|
||
'konto' => Konto::mitSalden($konto),
|
||
'zeilen' => $zeilen,
|
||
'gesamt' => $gesamt,
|
||
'seite' => $seite,
|
||
'seiten' => max(1, (int)ceil($gesamt / max(1, $grenze))),
|
||
'filter' => $filter,
|
||
'kategorien' => Kategorie::baumFlach(),
|
||
'klassen' => Klasse::alle(),
|
||
'konten' => Konto::alle(),
|
||
'splits' => Buchung::splitsJeBuchung($gesplittete),
|
||
]);
|
||
}
|
||
|
||
/** @param array<string,string> $params */
|
||
public function neu(array $params): void
|
||
{
|
||
$this->verlangeAnmeldung();
|
||
|
||
$konto = Konto::find((int)$params['id']);
|
||
if ($konto === null) {
|
||
$this->nichtGefunden('/konten/' . $params['id']);
|
||
return;
|
||
}
|
||
|
||
$this->maske($konto, null);
|
||
}
|
||
|
||
/** @param array<string,string> $params */
|
||
public function anlegen(array $params): void
|
||
{
|
||
$this->verlangeAnmeldung();
|
||
|
||
$kontoId = (int)$params['id'];
|
||
if (Konto::find($kontoId) === null) {
|
||
$this->nichtGefunden('/konten/' . $params['id']);
|
||
return;
|
||
}
|
||
|
||
try {
|
||
[$daten, $splits] = $this->formulardaten($kontoId);
|
||
Buchung::anlegen($daten, $splits);
|
||
} catch (\Throwable $e) {
|
||
View::redirect('/konten/' . $kontoId . '/buchung', $e->getMessage(), 'fehler');
|
||
return;
|
||
}
|
||
|
||
View::redirect('/konten/' . $kontoId, 'Buchung angelegt.');
|
||
}
|
||
|
||
/** @param array<string,string> $params */
|
||
public function bearbeiten(array $params): void
|
||
{
|
||
$this->verlangeAnmeldung();
|
||
|
||
$buchung = Buchung::find((int)$params['id']);
|
||
if ($buchung === null) {
|
||
$this->nichtGefunden('/buchungen/' . $params['id']);
|
||
return;
|
||
}
|
||
|
||
$this->maske(Konto::find((int)$buchung['konto_id']), $buchung);
|
||
}
|
||
|
||
/** @param array<string,string> $params */
|
||
public function speichern(array $params): void
|
||
{
|
||
$this->verlangeAnmeldung();
|
||
|
||
$id = (int)$params['id'];
|
||
$buchung = Buchung::find($id);
|
||
if ($buchung === null) {
|
||
$this->nichtGefunden('/buchungen/' . $params['id']);
|
||
return;
|
||
}
|
||
|
||
try {
|
||
[$daten, $splits] = $this->formulardaten((int)$buchung['konto_id']);
|
||
Buchung::speichern($id, $daten, $splits);
|
||
} catch (\Throwable $e) {
|
||
View::redirect('/buchungen/' . $id, $e->getMessage(), 'fehler');
|
||
return;
|
||
}
|
||
|
||
View::redirect('/konten/' . $buchung['konto_id'], 'Buchung gespeichert.');
|
||
}
|
||
|
||
/** @param array<string,string> $params */
|
||
public function loeschen(array $params): void
|
||
{
|
||
$this->verlangeAnmeldung();
|
||
|
||
$buchung = Buchung::find((int)$params['id']);
|
||
if ($buchung === null) {
|
||
$this->nichtGefunden('/buchungen/' . $params['id']);
|
||
return;
|
||
}
|
||
|
||
Buchung::loeschen((int)$buchung['id']);
|
||
View::redirect('/konten/' . $buchung['konto_id'], 'Buchung gelöscht.');
|
||
}
|
||
|
||
/**
|
||
* Schnellzuordnung aus dem Kontoblatt: Kategorie oder Gegenkonto einer
|
||
* Buchung setzen, ohne die Maske zu öffnen.
|
||
*
|
||
* @param array<string,string> $params
|
||
*/
|
||
public function zuordnung(array $params): void
|
||
{
|
||
$this->verlangeAnmeldung();
|
||
|
||
$buchung = Buchung::find((int)$params['id']);
|
||
if ($buchung === null) {
|
||
$this->nichtGefunden('/buchungen/' . $params['id']);
|
||
return;
|
||
}
|
||
|
||
$ziel = $this->kontoblattPfad((int)$buchung['konto_id']);
|
||
|
||
try {
|
||
$zuordnung = self::zuordnungAus($this->post('zuordnung'));
|
||
Buchung::zuordnen(
|
||
(int)$buchung['id'],
|
||
$zuordnung['kategorie_id'],
|
||
$zuordnung['gegenkonto_id']
|
||
);
|
||
} catch (\Throwable $e) {
|
||
View::redirect($ziel, $e->getMessage(), 'fehler');
|
||
return;
|
||
}
|
||
|
||
View::redirect($ziel, 'Zuordnung gespeichert.');
|
||
}
|
||
|
||
/**
|
||
* Der Splitdialog des Kontoblatts: die Zeilen einer Buchung ersetzen.
|
||
* Ohne Zeilen wird die Splitbuchung aufgehoben.
|
||
*
|
||
* Der Knopf „Splitbuchung löschen“ schickt dasselbe Formular mit
|
||
* `aktion=loeschen`. Seine Zeilen zählen dann nicht: Gelöscht wird die
|
||
* Aufteilung, und die Buchung steht danach ohne Zuordnung da.
|
||
*
|
||
* @param array<string,string> $params
|
||
*/
|
||
public function splitbuchung(array $params): void
|
||
{
|
||
$this->verlangeAnmeldung();
|
||
|
||
$buchung = Buchung::find((int)$params['id']);
|
||
if ($buchung === null) {
|
||
$this->nichtGefunden('/buchungen/' . $params['id']);
|
||
return;
|
||
}
|
||
|
||
$ziel = $this->kontoblattPfad((int)$buchung['konto_id']);
|
||
$loeschen = $this->post('aktion') === 'loeschen';
|
||
|
||
try {
|
||
Buchung::splitsErsetzen((int)$buchung['id'], $loeschen ? [] : $this->splitzeilen());
|
||
} catch (\Throwable $e) {
|
||
View::redirect($ziel, $e->getMessage(), 'fehler');
|
||
return;
|
||
}
|
||
|
||
View::redirect($ziel, $loeschen ? 'Splitbuchung gelöscht.' : 'Splitbuchung gespeichert.');
|
||
}
|
||
|
||
/**
|
||
* Mehrere im Kontoblatt angekreuzte Buchungen auf einmal löschen.
|
||
*
|
||
* @param array<string,string> $params
|
||
*/
|
||
public function auswahlLoeschen(array $params): void
|
||
{
|
||
$this->verlangeAnmeldung();
|
||
|
||
$kontoId = (int)$params['id'];
|
||
if (Konto::find($kontoId) === null) {
|
||
$this->nichtGefunden('/konten/' . $params['id']);
|
||
return;
|
||
}
|
||
|
||
$ziel = $this->kontoblattPfad($kontoId);
|
||
$ids = $this->postIds('buchungen');
|
||
if ($ids === []) {
|
||
View::redirect($ziel, 'Keine Buchung ausgewählt.', 'warnung');
|
||
return;
|
||
}
|
||
|
||
$anzahl = 0;
|
||
foreach ($ids as $id) {
|
||
$buchung = Buchung::find($id);
|
||
// Nur eigene Buchungen dieses Kontos: Die Gegenseite einer fremden
|
||
// Umbuchung gehört dem Ursprungskonto und wird auch nur dort
|
||
// gelöscht.
|
||
if ($buchung === null || (int)$buchung['konto_id'] !== $kontoId) {
|
||
continue;
|
||
}
|
||
|
||
try {
|
||
Buchung::loeschen($id);
|
||
} catch (\Throwable $e) {
|
||
View::redirect($ziel, $e->getMessage(), 'fehler');
|
||
return;
|
||
}
|
||
$anzahl++;
|
||
}
|
||
|
||
View::redirect($ziel, $anzahl === 1
|
||
? 'Buchung gelöscht.'
|
||
: $anzahl . ' Buchungen gelöscht.');
|
||
}
|
||
|
||
/**
|
||
* Weg zurück ins Kontoblatt – mit demselben Filter und derselben Seite.
|
||
*
|
||
* Die Werte kommen aus der Abfragezeichenfolge des Formularziels und werden
|
||
* hier neu zusammengesetzt statt übernommen: So kann kein fremdes Ziel
|
||
* eingeschleust werden.
|
||
*/
|
||
private function kontoblattPfad(int $kontoId): string
|
||
{
|
||
$query = array_filter([
|
||
'suche' => $this->query('suche'),
|
||
'von' => $this->query('von'),
|
||
'bis' => $this->query('bis'),
|
||
'kategorie_id' => $this->query('kategorie_id'),
|
||
'klasse_id' => $this->query('klasse_id'),
|
||
'nur_offene' => $this->query('nur_offene') === '1' ? '1' : '',
|
||
'seite' => $this->query('seite'),
|
||
], static fn(string $wert): bool => $wert !== '');
|
||
|
||
return '/konten/' . $kontoId . ($query === [] ? '' : '?' . http_build_query($query));
|
||
}
|
||
|
||
/** @param array<string,mixed>|null $konto */
|
||
private function maske(?array $konto, ?array $buchung): void
|
||
{
|
||
if ($konto === null) {
|
||
$this->nichtGefunden('/konten');
|
||
return;
|
||
}
|
||
|
||
$this->render('buchungen/formular.php', [
|
||
'titel' => $buchung === null ? 'Neue Buchung' : 'Buchung bearbeiten',
|
||
'konto' => $konto,
|
||
'buchung' => $buchung,
|
||
'splits' => $buchung === null ? [] : Buchung::splits((int)$buchung['id']),
|
||
'kategorien' => Kategorie::baumFlach(),
|
||
'klassen' => Klasse::alle(),
|
||
'konten' => Konto::alle(),
|
||
]);
|
||
}
|
||
|
||
/**
|
||
* @return array{0: array<string,mixed>, 1: list<array<string,mixed>>}
|
||
*/
|
||
private function formulardaten(int $kontoId): array
|
||
{
|
||
// In der Maske wird ein positiver Betrag eingegeben; die Richtung
|
||
// bestimmt die Auswahl Einnahme / Ausgabe.
|
||
$betrag = abs(KontenController::zahl($this->post('betrag', '0')));
|
||
if ($this->post('art', 'ausgabe') !== 'einnahme') {
|
||
$betrag = -$betrag;
|
||
}
|
||
|
||
// Kategorie und Gegenkonto stehen in einem Feld: Ein Konto in der Liste
|
||
// macht die Buchung zur Umbuchung – wie das Kategoriefeld im
|
||
// FinanzManager, das `[Konto]` annimmt.
|
||
$zuordnung = self::zuordnungAus($this->post('zuordnung'));
|
||
|
||
$daten = [
|
||
'konto_id' => $kontoId,
|
||
'datum' => $this->post('datum'),
|
||
'valuta' => $this->post('valuta'),
|
||
'betrag' => $betrag,
|
||
'empfaenger' => $this->post('empfaenger'),
|
||
'buchungstext' => $this->post('buchungstext'),
|
||
'nummer' => $this->post('nummer'),
|
||
'abgeglichen' => isset($_POST['abgeglichen']),
|
||
'kategorie_id' => $zuordnung['kategorie_id'],
|
||
'klasse_id' => $this->post('klasse_id'),
|
||
'gegenkonto_id' => $zuordnung['gegenkonto_id'],
|
||
'quelle' => 'manuell',
|
||
];
|
||
|
||
return [$daten, $this->splitzeilen()];
|
||
}
|
||
|
||
/**
|
||
* Die ausgefüllten Splitzeilen eines Formulars. Zeilen ohne Betrag zählen
|
||
* nicht – so bleiben die leeren Zeilen der Maske folgenlos.
|
||
*
|
||
* @return list<array<string,mixed>>
|
||
*/
|
||
private function splitzeilen(): array
|
||
{
|
||
$zeilen = $_POST['split'] ?? [];
|
||
if (!is_array($zeilen)) {
|
||
return [];
|
||
}
|
||
|
||
$splits = [];
|
||
foreach ($zeilen as $zeile) {
|
||
if (!is_array($zeile)) {
|
||
continue;
|
||
}
|
||
$wert = trim((string)($zeile['betrag'] ?? ''));
|
||
if ($wert === '') {
|
||
continue;
|
||
}
|
||
|
||
$zuordnung = self::zuordnungAus((string)($zeile['zuordnung'] ?? ''));
|
||
$splits[] = [
|
||
'kategorie_id' => $zuordnung['kategorie_id'],
|
||
'gegenkonto_id' => $zuordnung['gegenkonto_id'],
|
||
'klasse_id' => $zeile['klasse_id'] ?? null,
|
||
'betrag' => KontenController::zahl($wert),
|
||
'notiz' => (string)($zeile['notiz'] ?? ''),
|
||
];
|
||
}
|
||
|
||
return $splits;
|
||
}
|
||
|
||
/**
|
||
* Ein Auswahlwert aus der gemeinsamen Liste „Kategorie oder Gegenkonto“:
|
||
* `kategorie:12`, `konto:7` oder leer.
|
||
*
|
||
* @return array{kategorie_id: ?int, gegenkonto_id: ?int}
|
||
*/
|
||
public static function zuordnungAus(string $wert): array
|
||
{
|
||
$leer = ['kategorie_id' => null, 'gegenkonto_id' => null];
|
||
|
||
[$art, $id] = array_pad(explode(':', $wert, 2), 2, '');
|
||
if ((int)$id <= 0) {
|
||
return $leer;
|
||
}
|
||
|
||
return match ($art) {
|
||
'kategorie' => ['kategorie_id' => (int)$id, 'gegenkonto_id' => null],
|
||
'konto' => ['kategorie_id' => null, 'gegenkonto_id' => (int)$id],
|
||
default => $leer,
|
||
};
|
||
}
|
||
|
||
private function nichtGefunden(string $pfad): void
|
||
{
|
||
http_response_code(404);
|
||
$this->render('layout/404.php', ['pfad' => $pfad, 'titel' => 'Nicht gefunden']);
|
||
}
|
||
}
|