678 lines
28 KiB
Python
678 lines
28 KiB
Python
import json
|
|
import csv
|
|
import os
|
|
import struct
|
|
from datetime import datetime, date
|
|
|
|
# ===== CONFIG DATEIEN ERSTELLEN/LADEN =====
|
|
|
|
def create_default_configs():
|
|
"""Erstellt Standard-Config-Dateien falls nicht vorhanden"""
|
|
|
|
# Mandanten Config
|
|
if not os.path.exists('mandanten_config.json'):
|
|
mandanten_config = {
|
|
"mandanten": [
|
|
{
|
|
"name": "Mustermann GmbH",
|
|
"nummer": "001",
|
|
"konto": "1200",
|
|
"standard_gegenkonto": "8400",
|
|
"beleg_index": 1
|
|
},
|
|
{
|
|
"name": "Beispiel AG",
|
|
"nummer": "002",
|
|
"konto": "1800",
|
|
"standard_gegenkonto": "8500",
|
|
"beleg_index": 1
|
|
}
|
|
]
|
|
}
|
|
with open('mandanten_config.json', 'w', encoding='utf-8') as f:
|
|
json.dump(mandanten_config, f, indent=4, ensure_ascii=False)
|
|
print("✓ mandanten_config.json erstellt")
|
|
|
|
# Prüfe ob Identitäten-Dateien für jeden Mandanten existieren
|
|
mandanten = load_mandanten()
|
|
for mandant in mandanten:
|
|
# Mieter-Identitäten
|
|
mieter_datei = f"identitaeten_mieter_{mandant['nummer']}.json"
|
|
if not os.path.exists(mieter_datei):
|
|
mieter_config = {
|
|
"mandant": mandant['name'],
|
|
"mandantennummer": mandant['nummer'],
|
|
"mieter": [
|
|
{
|
|
"suchbegriffe": ["Thomas Müller", "Müller", "T. Müller"],
|
|
"konto": "1210",
|
|
"beschreibung": "Miete Thomas Müller"
|
|
},
|
|
{
|
|
"suchbegriffe": ["Schmidt", "Anna Schmidt", "A. Schmidt"],
|
|
"konto": "1220",
|
|
"beschreibung": "Miete Anna Schmidt"
|
|
},
|
|
{
|
|
"suchbegriffe": ["Weber GmbH", "Weber"],
|
|
"konto": "1230",
|
|
"beschreibung": "Miete Weber GmbH"
|
|
}
|
|
]
|
|
}
|
|
with open(mieter_datei, 'w', encoding='utf-8') as f:
|
|
json.dump(mieter_config, f, indent=4, ensure_ascii=False)
|
|
print(f"✓ {mieter_datei} erstellt")
|
|
|
|
# Kostenkonten-Identitäten
|
|
kosten_datei = f"identitaeten_kosten_{mandant['nummer']}.json"
|
|
if not os.path.exists(kosten_datei):
|
|
kosten_config = {
|
|
"mandant": mandant['name'],
|
|
"mandantennummer": mandant['nummer'],
|
|
"kostenkonten": [
|
|
{
|
|
"suchbegriffe": ["Wasser", "Wasserbetriebe", "Berliner Wasserbetriebe"],
|
|
"gegenkonto": "6300",
|
|
"beschreibung": "Wasserkosten"
|
|
},
|
|
{
|
|
"suchbegriffe": ["Strom", "Vattenfall", "Stromversorgung"],
|
|
"gegenkonto": "6310",
|
|
"beschreibung": "Stromkosten"
|
|
},
|
|
{
|
|
"suchbegriffe": ["Gas", "Gasag", "Gasversorgung"],
|
|
"gegenkonto": "6320",
|
|
"beschreibung": "Gaskosten"
|
|
},
|
|
{
|
|
"suchbegriffe": ["Versicherung", "Allianz", "Gebäudeversicherung"],
|
|
"gegenkonto": "6500",
|
|
"beschreibung": "Versicherung"
|
|
},
|
|
{
|
|
"suchbegriffe": ["Hausverwaltung", "Verwaltung", "Verwaltungsgebühr"],
|
|
"gegenkonto": "6700",
|
|
"beschreibung": "Hausverwaltungskosten"
|
|
}
|
|
]
|
|
}
|
|
with open(kosten_datei, 'w', encoding='utf-8') as f:
|
|
json.dump(kosten_config, f, indent=4, ensure_ascii=False)
|
|
print(f"✓ {kosten_datei} erstellt")
|
|
|
|
# Projekte-Datei
|
|
projekte_datei = f"projekte_{mandant['nummer']}.json"
|
|
if not os.path.exists(projekte_datei):
|
|
projekte_config = {
|
|
"mandant": mandant['name'],
|
|
"mandantennummer": mandant['nummer'],
|
|
"default_projekt": "ALLG001",
|
|
"projekte": [
|
|
{
|
|
"suchbegriffe": ["Projekt Alpha", "Alpha"],
|
|
"kst": "PRJ001",
|
|
"beschreibung": "Projekt Alpha"
|
|
},
|
|
{
|
|
"suchbegriffe": ["Hausverwaltung", "HV2024"],
|
|
"kst": "HV2024",
|
|
"beschreibung": "Hausverwaltung 2024"
|
|
},
|
|
{
|
|
"suchbegriffe": ["Musterstraße 10", "Musterstr. 10"],
|
|
"kst": "HAUS01",
|
|
"beschreibung": "Musterstraße 10"
|
|
}
|
|
]
|
|
}
|
|
with open(projekte_datei, 'w', encoding='utf-8') as f:
|
|
json.dump(projekte_config, f, indent=4, ensure_ascii=False)
|
|
print(f"✓ {projekte_datei} erstellt")
|
|
|
|
def load_mandanten():
|
|
"""Lädt Mandanten aus Config"""
|
|
with open('mandanten_config.json', 'r', encoding='utf-8') as f:
|
|
return json.load(f)['mandanten']
|
|
|
|
def save_mandanten(mandanten):
|
|
"""Speichert Mandanten in Config"""
|
|
with open('mandanten_config.json', 'w', encoding='utf-8') as f:
|
|
json.dump({"mandanten": mandanten}, f, indent=4, ensure_ascii=False)
|
|
|
|
def load_mieter(mandantennummer):
|
|
"""Lädt Mieter für einen bestimmten Mandanten"""
|
|
mieter_datei = f"identitaeten_mieter_{mandantennummer}.json"
|
|
with open(mieter_datei, 'r', encoding='utf-8') as f:
|
|
return json.load(f)['mieter']
|
|
|
|
def load_kostenkonten(mandantennummer):
|
|
"""Lädt Kostenkonten für einen bestimmten Mandanten"""
|
|
kosten_datei = f"identitaeten_kosten_{mandantennummer}.json"
|
|
with open(kosten_datei, 'r', encoding='utf-8') as f:
|
|
return json.load(f)['kostenkonten']
|
|
|
|
def load_projekte(mandantennummer):
|
|
"""Lädt Projekte/Kostenstellen für einen bestimmten Mandanten"""
|
|
projekte_datei = f"projekte_{mandantennummer}.json"
|
|
with open(projekte_datei, 'r', encoding='utf-8') as f:
|
|
config = json.load(f)
|
|
return config['projekte'], config.get('default_projekt', '')
|
|
|
|
def normalize_text(text):
|
|
"""
|
|
Normalisiert Text für Vergleiche:
|
|
- Kleinbuchstaben
|
|
- ü → ue, ö → oe, ä → ae, ß → ss
|
|
"""
|
|
text = text.lower()
|
|
replacements = {
|
|
'ü': 'ue', 'ö': 'oe', 'ä': 'ae', 'ß': 'ss',
|
|
'é': 'e', 'è': 'e', 'ê': 'e', 'à': 'a', 'â': 'a'
|
|
}
|
|
for old, new in replacements.items():
|
|
text = text.replace(old, new)
|
|
return text
|
|
|
|
# ===== PARSING LOGIK =====
|
|
|
|
def parse_mieter(buchungstext, mieter):
|
|
"""
|
|
Sucht nach Mietern im Buchungstext (OHNE Projektnummer)
|
|
Returns: (konto, beschreibung) oder (None, None)
|
|
"""
|
|
buchungstext_norm = normalize_text(buchungstext)
|
|
|
|
for mieter_entry in mieter:
|
|
for suchbegriff in mieter_entry['suchbegriffe']:
|
|
suchbegriff_norm = normalize_text(suchbegriff)
|
|
if suchbegriff_norm in buchungstext_norm:
|
|
print(f" → Mieter gefunden: '{suchbegriff}' → Konto {mieter_entry['konto']}")
|
|
return mieter_entry['konto'], mieter_entry.get('beschreibung', '')
|
|
|
|
return None, None
|
|
|
|
def parse_kostenkonten(buchungstext, kostenkonten):
|
|
"""
|
|
Sucht nach Kostenkonten im Buchungstext
|
|
Returns: (gegenkonto, beschreibung) oder (None, None)
|
|
"""
|
|
buchungstext_norm = normalize_text(buchungstext)
|
|
|
|
for kosten_entry in kostenkonten:
|
|
for suchbegriff in kosten_entry['suchbegriffe']:
|
|
suchbegriff_norm = normalize_text(suchbegriff)
|
|
if suchbegriff_norm in buchungstext_norm:
|
|
print(f" → Kostenkonto gefunden: '{suchbegriff}' → Gegenkonto {kosten_entry['gegenkonto']}")
|
|
return kosten_entry['gegenkonto'], kosten_entry.get('beschreibung', '')
|
|
|
|
return None, None
|
|
|
|
def parse_projekt(buchungstext, projekte, default_projekt):
|
|
"""
|
|
Sucht nach Projekten im Buchungstext
|
|
Wird NUR aufgerufen wenn Kostenkonto gefunden wurde!
|
|
Returns: kostenstelle
|
|
"""
|
|
buchungstext_norm = normalize_text(buchungstext)
|
|
|
|
for projekt in projekte:
|
|
for suchbegriff in projekt['suchbegriffe']:
|
|
suchbegriff_norm = normalize_text(suchbegriff)
|
|
if suchbegriff_norm in buchungstext_norm:
|
|
print(f" → Projekt gefunden: '{suchbegriff}' → KST {projekt['kst']}")
|
|
return projekt['kst']
|
|
|
|
# Kein Projekt gefunden → Default verwenden
|
|
if default_projekt:
|
|
print(f" → Kein Projekt gefunden → Default-KST {default_projekt}")
|
|
return default_projekt
|
|
|
|
return ''
|
|
|
|
def bestimme_konten_und_kst(buchungstext, mandant, mieter, kostenkonten, projekte, default_projekt):
|
|
"""
|
|
Bestimmt Konten, Kostenstelle und Beschreibung basierend auf dem Buchungstext.
|
|
Mit Mieternummer-Parsing für Konten beginnend mit "1".
|
|
"""
|
|
norm_buchungstext = normalize_text(buchungstext)
|
|
|
|
# --- TEIL 0: ZUERST NACH MIETERNUMMER SUCHEN (nur für Konten mit "1") ---
|
|
import re
|
|
buchungstyp = 'unbekannt'
|
|
gegenkonto = None
|
|
beschreibung = None
|
|
|
|
# Suche nach 5-stelligen Zahlen im Buchungstext (potenzielle Mieternummern)
|
|
mieternummer_pattern = r'\b(1\d{4})\b' # 5-stellige Zahl beginnend mit 1
|
|
gefundene_nummern = re.findall(mieternummer_pattern, buchungstext)
|
|
|
|
if gefundene_nummern:
|
|
print(f" 🔍 Gefundene potenzielle Mieternummern: {gefundene_nummern}")
|
|
|
|
# Prüfe ob eine der gefundenen Nummern ein Mieterkonto ist
|
|
for nummer in gefundene_nummern:
|
|
for mieter_entry in mieter:
|
|
if mieter_entry.get('konto') == nummer:
|
|
gegenkonto = mieter_entry.get('konto')
|
|
beschreibung = mieter_entry.get('beschreibung')
|
|
buchungstyp = 'mieter'
|
|
print(f" ✓ Mieter über Kontonummer gefunden: {nummer} → {beschreibung}")
|
|
break
|
|
if buchungstyp == 'mieter':
|
|
break
|
|
|
|
# --- TEIL 1: NUR WENN KEINE MIETERNUMMER GEFUNDEN, NORMALES PARSING ---
|
|
if buchungstyp == 'unbekannt':
|
|
# Standard-Gegenkonto aus Mandanten-Config verwenden
|
|
gegenkonto = mandant.get('standard_gegenkonto', '1300') # KORRIGIERT!
|
|
beschreibung = "Unbekannte Buchung"
|
|
|
|
# Suche nach Mietern über Suchbegriffe
|
|
for mieter_entry in mieter:
|
|
for suchbegriff in mieter_entry.get('suchbegriffe', []):
|
|
if normalize_text(suchbegriff) in norm_buchungstext:
|
|
gegenkonto = mieter_entry.get('konto')
|
|
beschreibung = mieter_entry.get('beschreibung')
|
|
buchungstyp = 'mieter'
|
|
print(f" ✓ Buchungstyp: Mieter (gefunden über '{suchbegriff}')")
|
|
break
|
|
if buchungstyp == 'mieter':
|
|
break
|
|
|
|
# --- TEIL 1b: KOSTENKONTEN PRÜFEN ---
|
|
if buchungstyp == 'unbekannt':
|
|
for kosten_entry in kostenkonten:
|
|
for suchbegriff in kosten_entry.get('suchbegriffe', []):
|
|
if normalize_text(suchbegriff) in norm_buchungstext:
|
|
gegenkonto = kosten_entry.get('gegenkonto')
|
|
beschreibung = kosten_entry.get('bezeichnung', '')
|
|
buchungstyp = 'kosten'
|
|
print(f" ✓ Buchungstyp: Kosten (gefunden über '{suchbegriff}')")
|
|
break
|
|
if buchungstyp == 'kosten':
|
|
break
|
|
|
|
# --- TEIL 2: KOSTENSTELLE BESTIMMEN (nur bei Kostenkonten) ---
|
|
gefundene_kst = ''
|
|
if buchungstyp == 'kosten':
|
|
for projekt in projekte:
|
|
for suchbegriff in projekt.get('suchbegriffe', []):
|
|
if normalize_text(suchbegriff) in norm_buchungstext:
|
|
gefundene_kst = projekt.get('kst', '')
|
|
print(f" ✓ Projekt-Kostenstelle gefunden: '{gefundene_kst}' (über '{suchbegriff}')")
|
|
break
|
|
if gefundene_kst:
|
|
break
|
|
|
|
# Default-Kostenstelle nur bei Kostenkonten
|
|
if not gefundene_kst and default_projekt:
|
|
gefundene_kst = default_projekt
|
|
print(f" → Keine Kostenstelle gefunden → Default-KST {default_projekt}")
|
|
|
|
# --- TEIL 3: ERGEBNISSE ZUSAMMENFÜHREN ---
|
|
konto = mandant.get('standard_bank_kto', mandant.get('konto', '1200'))
|
|
kostenstelle = gefundene_kst
|
|
|
|
# DIAGNOSE-AUSGABE
|
|
print("\n" + "="*25 + " FINALES ZUORDNUNGSERGEBNIS " + "="*25)
|
|
print(f" - KONTO: {konto}")
|
|
print(f" - GEGENKONTO: {gegenkonto}")
|
|
print(f" - KOSTENSTELLE: '{kostenstelle}'")
|
|
print(f" - BESCHREIBUNG: {beschreibung}")
|
|
print(f" - BUCHUNGSTYP: {buchungstyp}")
|
|
print("="*70 + "\n")
|
|
|
|
return str(konto), str(gegenkonto), str(kostenstelle), beschreibung
|
|
|
|
|
|
|
|
# ===== CSV EINLESEN =====
|
|
|
|
def lese_csv(csv_datei):
|
|
"""Liest CSV-Datei ein und gibt Liste von Buchungen zurück"""
|
|
buchungen = []
|
|
|
|
with open(csv_datei, 'r', encoding='utf-8') as f:
|
|
reader = csv.DictReader(f, delimiter=';')
|
|
|
|
# Spaltennamen bereinigen (Leerzeichen UND BOM entfernen)
|
|
reader.fieldnames = [name.strip().lstrip('\ufeff') if name else name for name in reader.fieldnames]
|
|
|
|
# Debug: Spaltennamen anzeigen
|
|
print(f"\n📋 Gefundene CSV-Spalten: {reader.fieldnames}")
|
|
|
|
# Flexible Spaltenerkennung
|
|
datum_spalte = None
|
|
text_spalte = None
|
|
betrag_spalte = None
|
|
|
|
for name in reader.fieldnames:
|
|
name_lower = name.lower()
|
|
if 'buchungstag' in name_lower or 'datum' in name_lower:
|
|
datum_spalte = name
|
|
if 'buchungstext' in name_lower or 'verwendungszweck' in name_lower or 'text' in name_lower:
|
|
text_spalte = name
|
|
if 'betrag' in name_lower or 'amount' in name_lower:
|
|
betrag_spalte = name
|
|
|
|
if not datum_spalte:
|
|
raise ValueError(f"Keine Datums-Spalte gefunden! Verfügbare Spalten: {reader.fieldnames}")
|
|
if not text_spalte:
|
|
raise ValueError(f"Keine Text-Spalte gefunden! Verfügbare Spalten: {reader.fieldnames}")
|
|
if not betrag_spalte:
|
|
raise ValueError(f"Keine Betrags-Spalte gefunden! Verfügbare Spalten: {reader.fieldnames}")
|
|
|
|
print(f"✓ Verwende Spalten: Datum='{datum_spalte}', Text='{text_spalte}', Betrag='{betrag_spalte}'")
|
|
|
|
for row in reader:
|
|
try:
|
|
# Datum parsen (Format: DD.MM.YYYY)
|
|
datum_str = row[datum_spalte].strip()
|
|
datum = datetime.strptime(datum_str, '%d.%m.%Y')
|
|
|
|
# Betrag konvertieren (Format: -123,45 → -123.45)
|
|
betrag_str = row[betrag_spalte].strip().replace('.', '').replace(',', '.')
|
|
betrag = float(betrag_str)
|
|
|
|
# Buchungstext
|
|
buchungstext = row[text_spalte].strip() if row[text_spalte] else ''
|
|
|
|
buchung = {
|
|
'datum': datum,
|
|
'buchungstext': buchungstext,
|
|
'betrag': betrag,
|
|
'umsatzart': row.get('Umsatzart', '').strip() if row.get('Umsatzart') else ''
|
|
}
|
|
buchungen.append(buchung)
|
|
except Exception as e:
|
|
print(f"⚠️ Zeile übersprungen (Fehler: {e}): {row}")
|
|
continue
|
|
|
|
return buchungen
|
|
|
|
def filtere_buchungen(buchungen, monate, jahre):
|
|
"""Filtert Buchungen nach ausgewählten Monaten und Jahren"""
|
|
gefiltert = []
|
|
for buchung in buchungen:
|
|
if buchung['datum'].month in monate and buchung['datum'].year in jahre:
|
|
gefiltert.append(buchung)
|
|
return gefiltert
|
|
|
|
# ===== DBF MANUELL ERSTELLEN =====
|
|
|
|
# --- START: ERSETZEN SIE IHRE ALTE FUNKTION DURCH DIESE ---
|
|
|
|
def erstelle_dbf_manuell(mandant, buchungen, mieter, kostenkonten, projekte, default_projekt, ausgabe_datei_praefix, start_beleg_nr):
|
|
"""
|
|
Gruppiert Buchungen nach Monat und erstellt für jeden Monat eine eigene,
|
|
Byte-genaue DBF-Datei.
|
|
Returns: letzte_beleg_nr
|
|
"""
|
|
|
|
# NEU: Schritt 1 - Buchungen nach Monat gruppieren
|
|
buchungen_pro_monat = {}
|
|
for buchung in buchungen:
|
|
monats_schluessel = buchung['datum'].strftime('%Y-%m') # z.B. '2023-10'
|
|
if monats_schluessel not in buchungen_pro_monat:
|
|
buchungen_pro_monat[monats_schluessel] = []
|
|
buchungen_pro_monat[monats_schluessel].append(buchung)
|
|
|
|
print(f"\nFunde {len(buchungen_pro_monat)} verschiedene Monate in den Buchungsdaten.")
|
|
|
|
beleg_nr = start_beleg_nr
|
|
|
|
# NEU: Schritt 2 - Für jeden Monat eine eigene DBF-Datei erstellen
|
|
for monat_key, monats_buchungen in buchungen_pro_monat.items():
|
|
|
|
jahr, monat = map(int, monat_key.split('-'))
|
|
jahr_kurz = str(jahr)[-2:]
|
|
|
|
# NEU: Dateinamen für diesen Monat generieren
|
|
ausgabe_datei = f"{ausgabe_datei_praefix}_{monat:02d}{jahr_kurz}.dbf"
|
|
print(f"\n{'='*70}")
|
|
print(f"Erstelle DBF-Datei für Monat {monat_key}: {ausgabe_datei}")
|
|
print(f"{'='*70}")
|
|
|
|
# --- AB HIER BEGINNT IHRE BEWÄHRTE LOGIK, ANGEPASST FÜR EINE DATEI ---
|
|
|
|
# DBF Header (32 bytes) - angepasst für die Anzahl der Monatsbuchungen
|
|
heute = datetime.now()
|
|
num_records = len(monats_buchungen)
|
|
header_len = 32 + 43 * 32 + 1 # 32 Header + 43 Felder * 32 + 1 Terminator
|
|
record_len = 368 # 1 (deletion) + 367 (fields)
|
|
|
|
header = bytearray(32)
|
|
header[0] = 0x03 # dBase III
|
|
header[1] = heute.year - 1900
|
|
header[2] = heute.month
|
|
header[3] = heute.day
|
|
struct.pack_into('<I', header, 4, num_records)
|
|
struct.pack_into('<H', header, 8, header_len)
|
|
struct.pack_into('<H', header, 10, record_len)
|
|
|
|
# Field Descriptors (exakte Struktur aus Ihrer Funktion)
|
|
fields = [
|
|
('BTT', 'N', 2, 0), ('BMM', 'N', 2, 0), ('BELEG', 'C', 10, 0),
|
|
('KONTO', 'N', 8, 0), ('GEGENKONTO', 'N', 8, 0), ('KST', 'C', 8, 0),
|
|
('KTG', 'C', 10, 0), ('BETRAG', 'N', 14, 2), ('STEUER', 'N', 5, 2),
|
|
('SKONTO', 'N', 14, 2), ('TEXT', 'C', 30, 0), ('BEZAHLT', 'N', 14, 2),
|
|
('KZ', 'C', 3, 0), ('LFDNR', 'N', 8, 0), ('EURO', 'L', 1, 0),
|
|
('ZAHLBETRAG', 'N', 14, 2), ('BEZAHLT_NK', 'N', 14, 2), ('FAELLIG', 'L', 1, 0),
|
|
('TEXT2', 'C', 30, 0), ('DATEV', 'L', 1, 0), ('FAELLIG_AM', 'D', 8, 0),
|
|
('STORNO', 'L', 1, 0), ('BJJ', 'N', 4, 0), ('TEMP1', 'C', 20, 0),
|
|
('HNDLNR', 'N', 8, 0), ('GBLFDNR', 'N', 15, 0), ('SKONTO2', 'N', 14, 2),
|
|
('DATUM2', 'D', 8, 0), ('KEIN_ZV', 'L', 1, 0), ('MANUELL', 'L', 1, 0),
|
|
('SOLLKONTO', 'N', 8, 0), ('STAPEL', 'C', 20, 0), ('SKONTSTFR', 'N', 14, 2),
|
|
('REB_LFDNR', 'N', 6, 0), ('RECHART', 'C', 3, 0), ('ZAHLART', 'N', 1, 0),
|
|
('LDATUM', 'D', 8, 0), ('XFINANZ', 'L', 1, 0), ('INZV', 'L', 1, 0),
|
|
('DUMMY', 'C', 1, 0), ('ABRJAHR', 'N', 4, 0), ('EDATUM', 'D', 8, 0),
|
|
('ENAME', 'C', 15, 0)
|
|
]
|
|
|
|
field_descriptors = bytearray()
|
|
for name, ftype, flen, fdec in fields:
|
|
fd = bytearray(32)
|
|
name_bytes = name.encode('cp850')[:11]
|
|
fd[0:len(name_bytes)] = name_bytes
|
|
fd[11] = ord(ftype)
|
|
fd[16] = flen
|
|
fd[17] = fdec
|
|
field_descriptors.extend(fd)
|
|
field_descriptors.append(0x0D)
|
|
|
|
# Datei für den aktuellen Monat schreiben
|
|
with open(ausgabe_datei, 'wb') as f:
|
|
f.write(header)
|
|
f.write(field_descriptors)
|
|
|
|
standard_datum = date(1899, 12, 30)
|
|
|
|
# NEU: Nur die Buchungen für DIESEN Monat verarbeiten
|
|
for idx, buchung in enumerate(monats_buchungen, 1):
|
|
datum = buchung['datum']
|
|
buchungstext = buchung['buchungstext'][:30]
|
|
betrag = buchung['betrag']
|
|
|
|
print(f"\nVerarbeite Buchung {idx}/{num_records} für {monat_key}...")
|
|
|
|
konto, gegenkonto, kostenstelle, beschreibung = bestimme_konten_und_kst(
|
|
buchung['buchungstext'], mandant, mieter, kostenkonten, projekte, default_projekt
|
|
)
|
|
|
|
text2 = beschreibung[:30] if beschreibung else ''
|
|
konto_num = int(konto)
|
|
gegenkonto_num = int(gegenkonto)
|
|
beleg_str = str(beleg_nr)
|
|
|
|
record = bytearray(368)
|
|
record[0] = 0x20
|
|
pos = 1
|
|
|
|
def write_field(value, length, decimals=0, is_numeric=False, is_logical=False, is_date=False, empty=False):
|
|
nonlocal pos
|
|
if empty: record[pos:pos+length] = b' ' * length
|
|
elif is_date: record[pos:pos+8] = value.strftime('%Y%m%d').encode('ascii') if value else b' ' * 8
|
|
elif is_logical: record[pos] = ord('T') if value else ord('F')
|
|
elif is_numeric:
|
|
formatted = f"{value:{length}.{decimals}f}" if decimals > 0 else f"{int(value):{length}d}"
|
|
record[pos:pos+length] = formatted.rjust(length)[:length].encode('ascii')
|
|
else:
|
|
encoded = value.encode('cp850')[:length]
|
|
record[pos:pos+length] = encoded.ljust(length)
|
|
pos += length
|
|
|
|
# Felder schreiben (Ihre exakte Reihenfolge)
|
|
write_field(datum.day, 2, is_numeric=True); write_field(datum.month, 2, is_numeric=True)
|
|
write_field(beleg_str, 10); write_field(konto_num, 8, is_numeric=True)
|
|
write_field(gegenkonto_num, 8, is_numeric=True); write_field(kostenstelle, 8)
|
|
write_field('', 10); write_field(betrag, 14, decimals=2, is_numeric=True)
|
|
write_field(0.00, 5, decimals=2, is_numeric=True); write_field(0.00, 14, decimals=2, is_numeric=True)
|
|
write_field(buchungstext, 30); write_field(0.00, 14, decimals=2, is_numeric=True)
|
|
write_field('', 3); write_field(0, 8, is_numeric=True); write_field(True, 1, is_logical=True)
|
|
write_field(betrag, 14, decimals=2, is_numeric=True); write_field(None, 14, empty=True)
|
|
write_field(None, 1, empty=True); write_field(text2, 30); write_field(None, 1, empty=True)
|
|
write_field(standard_datum, 8, is_date=True); write_field(False, 1, is_logical=True)
|
|
write_field(datum.year, 4, is_numeric=True); write_field('', 20); write_field(None, 8, empty=True)
|
|
write_field(None, 15, empty=True); write_field(0.00, 14, decimals=2, is_numeric=True)
|
|
write_field(standard_datum, 8, is_date=True); write_field(None, 1, empty=True)
|
|
write_field(False, 1, is_logical=True); write_field(0, 8, is_numeric=True)
|
|
write_field('', 20); write_field(0.00, 14, decimals=2, is_numeric=True)
|
|
write_field(None, 6, empty=True); write_field('', 3); write_field(0, 1, is_numeric=True)
|
|
write_field(standard_datum, 8, is_date=True); write_field(None, 1, empty=True)
|
|
write_field(None, 1, empty=True); write_field('', 1); write_field(0, 4, is_numeric=True)
|
|
write_field(None, 8, empty=True); write_field('', 15)
|
|
|
|
f.write(record)
|
|
beleg_nr += 1
|
|
|
|
f.write(b'\x1A') # EOF
|
|
|
|
print(f"✓ DBF-Datei '{ausgabe_datei}' erfolgreich mit {num_records} Einträgen erstellt.")
|
|
|
|
letzte_beleg_nr = beleg_nr - 1
|
|
return letzte_beleg_nr
|
|
|
|
# --- ENDE: BIS HIER ALLES ERSETZEN ---
|
|
|
|
# ===== HILFSFUNKTIONEN =====
|
|
|
|
def parse_monatseingabe(eingabe):
|
|
"""Parst Monatseingabe wie '1,2,3' oder '1-3' oder '12' """
|
|
monate = set()
|
|
teile = eingabe.split(',')
|
|
|
|
for teil in teile:
|
|
teil = teil.strip()
|
|
if '-' in teil:
|
|
start, ende = map(int, teil.split('-'))
|
|
monate.update(range(start, ende + 1))
|
|
else:
|
|
monate.add(int(teil))
|
|
|
|
return sorted(list(monate))
|
|
|
|
def parse_jahreseingabe(eingabe):
|
|
"""Parst Jahreseingabe wie '2024' oder '2023,2024' """
|
|
jahre = set()
|
|
teile = eingabe.split(',')
|
|
|
|
for teil in teile:
|
|
teil = teil.strip()
|
|
if '-' in teil:
|
|
start, ende = map(int, teil.split('-'))
|
|
jahre.update(range(start, ende + 1))
|
|
else:
|
|
jahre.add(int(teil))
|
|
|
|
return sorted(list(jahre))
|
|
|
|
# ===== HAUPTPROGRAMM =====
|
|
|
|
def main():
|
|
print("=" * 70)
|
|
print(" CSV zu DBF Konverter für Hausverwaltung (v2)")
|
|
print("=" * 70)
|
|
|
|
create_default_configs()
|
|
|
|
mandanten = load_mandanten()
|
|
|
|
print("\n📋 Verfügbare Mandanten:")
|
|
for idx, m in enumerate(mandanten, 1):
|
|
print(f" {idx}. {m['name']} (Nr. {m['nummer']}, Konto {m['konto']}, nächster Beleg: {m.get('beleg_index', 1)})")
|
|
|
|
auswahl = int(input("\n➤ Mandant auswählen (Nummer): ")) - 1
|
|
mandant = mandanten[auswahl]
|
|
|
|
print(f"\n✓ Mandant gewählt: {mandant['name']}")
|
|
print(f" Mandantennummer: {mandant['nummer']}")
|
|
print(f" Konto: {mandant['konto']}")
|
|
print(f" Standard-Gegenkonto: {mandant['standard_gegenkonto']}")
|
|
print(f" Start-Belegnummer: {mandant.get('beleg_index', 1)}")
|
|
|
|
mieter = load_mieter(mandant['nummer'])
|
|
print(f" Mieter geladen: {len(mieter)} Einträge")
|
|
|
|
kostenkonten = load_kostenkonten(mandant['nummer'])
|
|
print(f" Kostenkonten geladen: {len(kostenkonten)} Einträge")
|
|
|
|
projekte, default_projekt = load_projekte(mandant['nummer'])
|
|
print(f" Projekte geladen: {len(projekte)} Einträge")
|
|
print(f" Default-Projekt: {default_projekt}")
|
|
|
|
csv_datei = input("\n➤ CSV-Datei Pfad: ")
|
|
alle_buchungen = lese_csv(csv_datei)
|
|
print(f"\n✓ {len(alle_buchungen)} Buchungen aus CSV geladen")
|
|
|
|
print("\n📅 Für welche Monate sollen DBF-Dateien erstellt werden?")
|
|
print(" Beispiele: '12' oder '1,2,3' oder '1-12'")
|
|
monate_eingabe = input("➤ Monate: ")
|
|
monate = parse_monatseingabe(monate_eingabe)
|
|
print(f"✓ Ausgewählte Monate: {', '.join(map(str, monate))}")
|
|
|
|
print("\n📅 Für welche Jahre sollen DBF-Dateien erstellt werden?")
|
|
print(" Beispiele: '2024' oder '2023,2024' oder '2023-2024'")
|
|
jahre_eingabe = input("➤ Jahre: ")
|
|
jahre = parse_jahreseingabe(jahre_eingabe)
|
|
print(f"✓ Ausgewählte Jahre: {', '.join(map(str, jahre))}")
|
|
|
|
gefilterte_buchungen = filtere_buchungen(alle_buchungen, monate, jahre)
|
|
print(f"\n✓ {len(gefilterte_buchungen)} Buchungen gefiltert (von {len(alle_buchungen)} gesamt)")
|
|
|
|
if len(gefilterte_buchungen) == 0:
|
|
print("\n⚠️ Keine Buchungen für die ausgewählten Monate/Jahre gefunden!")
|
|
return
|
|
|
|
monate_str = '_'.join(map(str, monate)) if len(monate) <= 3 else f"{min(monate)}-{max(monate)}"
|
|
jahre_str = '_'.join(map(str, jahre))
|
|
ausgabe_datei = f"buchungen_{mandant['nummer']}_M{monate_str}_J{jahre_str}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.dbf"
|
|
|
|
print(f"\n🔨 Erstelle DBF-Datei: {ausgabe_datei}")
|
|
print("-" * 70)
|
|
|
|
start_beleg_nr = mandant.get('beleg_index', 1)
|
|
letzte_beleg_nr = erstelle_dbf_manuell(
|
|
mandant, gefilterte_buchungen, mieter, kostenkonten,
|
|
projekte, default_projekt, ausgabe_datei, start_beleg_nr
|
|
)
|
|
|
|
# Beleg-Index in Config aktualisieren
|
|
mandant['beleg_index'] = letzte_beleg_nr + 1
|
|
save_mandanten(mandanten)
|
|
print(f"\n✓ Mandanten-Config aktualisiert: Nächster Beleg startet bei {mandant['beleg_index']}")
|
|
|
|
print("\n" + "=" * 70)
|
|
print("✅ Fertig! DBF-Datei erfolgreich erstellt.")
|
|
print("=" * 70)
|
|
print(f"\n💾 Datei: {ausgabe_datei}")
|
|
print(f"📊 Buchungen: {len(gefilterte_buchungen)}")
|
|
print(f"🔢 Belegnummern: {start_beleg_nr} bis {letzte_beleg_nr}")
|
|
print(f"📄 Mieter-Config: identitaeten_mieter_{mandant['nummer']}.json")
|
|
print(f"📄 Kosten-Config: identitaeten_kosten_{mandant['nummer']}.json")
|
|
print(f"📄 Projekte-Config: projekte_{mandant['nummer']}.json")
|
|
|
|
if __name__ == "__main__":
|
|
main()
|