def berechne_order_typ(dauerauftrag_order):
order_gesamt_raw = persisted_state.database_instance().order.content.copy()
order_summe = get_wert_sum(order_gesamt_raw)
dauerauftrag_order = get_wert_sum(dauerauftrag_order)
return {
'manual': from_double_to_german(order_summe - dauerauftrag_order),
'dauerauftrag': from_double_to_german(dauerauftrag_order),
'manual_raw': '%.2f' % (order_summe - dauerauftrag_order),
'dauerauftrag_raw': '%.2f' % dauerauftrag_order
}
def berechne_monatlich():
aktuelle_dauerauftraege = persisted_state.database_instance().orderdauerauftrag.aktuelle_raw().copy()
aktuelle_dauerauftraege = aktuelle_dauerauftraege[aktuelle_dauerauftraege.Wert > 0]
isins = set(aktuelle_dauerauftraege.Depotwert.tolist())
namen = []
colors = []
werte = []
monatlich = []
color_chooser = viewcore.get_generic_color_chooser(list(sorted(isins)))
for isin in sorted(isins):
name = persisted_state.database_instance().depotwerte.get_description_for(isin)
wert = get_sum(aktuelle_dauerauftraege[aktuelle_dauerauftraege.Depotwert == isin])
color = color_chooser.get_for_value(isin)
namen.append(name)
werte.append('%.2f' % wert)
colors.append(color)
monatlich.append({
'name': name,
'wert': from_double_to_german(wert),
'color': color
})
return {
'einzelwerte': monatlich,
'colors': colors,
'namen': namen,
'werte': werte
}
def _handle_request(request):
depotwerte = persisted_state.database_instance().depotwerte
order = persisted_state.database_instance().order
depotauszuege = persisted_state.database_instance().depotauszuege
if post_action_is(request, 'delete'):
depotwerte.delete(int(request.values['delete_index']))
return request_handler.create_redirect_context(
'/uebersicht_depotwerte/')
db = depotwerte.get_all()
depotwerte_liste = []
gesamt_buchungen = 0
gesamt_wert = 0
for row_index, row in db.iterrows():
isin = row.ISIN
buchungen = order.get_order_fuer_depotwert(isin)
wert = depotauszuege.get_depotwert_by(isin)
differenz = wert - buchungen
typ = row.Typ
depotwerte_liste.append({
'index': row_index,
'name': row.Name,
'isin': isin,
'typ': typ,
'buchung': from_double_to_german(buchungen),
'difference': from_double_to_german(differenz),
'difference_is_negativ': differenz < 0,
'wert': from_double_to_german(wert)
})
gesamt_buchungen += buchungen
gesamt_wert += wert
gesamt_difference = gesamt_wert - gesamt_buchungen
gesamt = {
'wert': from_double_to_german(gesamt_wert),
'difference': from_double_to_german(gesamt_difference),
'difference_is_negativ': gesamt_difference < 0,
'buchung': from_double_to_german(gesamt_buchungen)
}
context = viewcore.generate_transactional_context('uebersicht_depotwerte')
context['depotwerte'] = depotwerte_liste
context['gesamt'] = gesamt
return context
def _handle_request(request):
sparbuchungen = persisted_state.database_instance().sparbuchungen
if post_action_is(request, 'delete'):
sparbuchungen.delete(int(request.values['delete_index']))
return request_handler.create_redirect_context(
'/uebersicht_sparbuchungen/')
db = sparbuchungen.get_all()
sparbuchungen_monatlich = {}
datum_alt = None
sparbuchungen_liste = []
for row_index, row in db.iterrows():
if not datum_alt:
datum_alt = row.Datum
if datum_alt.month != row.Datum.month or datum_alt.year != row.Datum.year:
sparbuchungen_monatlich["" + str(datum_alt.year) + "." +
str(datum_alt.month)] = sparbuchungen_liste
sparbuchungen_liste = []
datum_alt = row.Datum
sparbuchungen_liste.append({
'index': row_index,
'datum': datum_to_german(row.Datum),
'name': row.Name,
'konto': row.Konto,
'wert': from_double_to_german(row.Wert),
'typ': row.Typ,
'dynamisch': row.Dynamisch
})
if datum_alt:
sparbuchungen_monatlich["" + str(datum_alt.year) + "." +
str(datum_alt.month)] = sparbuchungen_liste
context = viewcore.generate_transactional_context(
'uebersicht_sparbuchungen')
context['alles'] = sparbuchungen_monatlich
return context
def _handle_request(request):
order = persisted_state.database_instance().order
depotwerte = persisted_state.database_instance().depotwerte
if post_action_is(request, 'delete'):
order.delete(int(request.values['delete_index']))
return request_handler.create_redirect_context('/uebersicht_order/')
db = order.get_all()
order_liste = []
for row_index, row in db.iterrows():
if row.Wert > 0:
typ = TYP_KAUF
else:
typ = TYP_VERKAUF
order_liste.append({
'index':
row_index,
'Datum':
datum_to_german(row.Datum),
'Name':
row.Name,
'Konto':
row.Konto,
'Typ':
typ,
'Depotwert':
depotwerte.get_description_for(row.Depotwert),
'Wert':
from_double_to_german(abs(row.Wert)),
'Dynamisch':
row.Dynamisch
})
context = viewcore.generate_transactional_context('uebersicht_order')
context['order'] = order_liste
return context
def _handle_request(request):
einzelbuchungen = persisted_state.database_instance().einzelbuchungen
if post_action_is(request, 'delete'):
einzelbuchungen.delete(int(request.values['delete_index']))
return request_handler.create_redirect_context('/uebersicht/')
db = einzelbuchungen.get_all()
ausgaben_monatlich = {}
datum_alt = None
ausgaben_liste = []
for row_index, row in db.iterrows():
if not datum_alt:
datum_alt = row.Datum
if datum_alt.month != row.Datum.month or datum_alt.year != row.Datum.year:
ausgaben_monatlich["" + str(datum_alt.year) + "." + str(datum_alt.month)] = ausgaben_liste
ausgaben_liste = []
datum_alt = row.Datum
link = 'addeinnahme'
if row.Wert < 0:
link = 'addausgabe'
ausgaben_liste.append({
'index': row_index,
'datum': datum_to_german(row.Datum),
'name': row.Name,
'kategorie': row.Kategorie,
'wert': from_double_to_german(row.Wert),
'dynamisch': row.Dynamisch,
'link': link,
'tags': str(row.Tags)})
if datum_alt:
ausgaben_monatlich["" + str(datum_alt.year) + "." + str(datum_alt.month)] = ausgaben_liste
context = viewcore.generate_transactional_context('uebersicht')
context['alles'] = ausgaben_monatlich
return context
def _handle_request(request):
sparkontos = persisted_state.database_instance().sparkontos
if post_action_is(request, 'delete'):
sparkontos.delete(int(request.values['delete_index']))
return request_handler.create_redirect_context(
'/uebersicht_sparkontos/')
db = sparkontos.get_all()
gesamt_kontostand = 0
gesamt_aufbuchungen = 0
sparkonto_liste = []
for row_index, row in db.iterrows():
aktueller_kontostand = 0
aufbuchungen = 0
kontoname = row.Kontoname
kontotyp = row.Kontotyp
if kontotyp == sparkontos.TYP_SPARKONTO or kontotyp == sparkontos.TYP_GENOSSENSCHAFTSANTEILE:
aktueller_kontostand = persisted_state.database_instance(
).sparbuchungen.get_kontostand_fuer(kontoname)
aufbuchungen = persisted_state.database_instance(
).sparbuchungen.get_aufbuchungen_fuer(kontoname)
if kontotyp == sparkontos.TYP_DEPOT:
aufbuchungen = persisted_state.database_instance(
).order.get_order_fuer(kontoname)
aktueller_kontostand = persisted_state.database_instance(
).depotauszuege.get_kontostand_by(kontoname)
gesamt_kontostand += aktueller_kontostand
gesamt_aufbuchungen += aufbuchungen
diff = aktueller_kontostand - aufbuchungen
sparkonto_liste.append({
'index':
row_index,
'kontoname':
kontoname,
'kontotyp':
kontotyp,
'wert':
from_double_to_german(aktueller_kontostand),
'difference':
from_double_to_german(diff),
'aufbuchungen':
from_double_to_german(aufbuchungen),
'difference_is_negativ':
diff < 0
})
gesamt_diff = gesamt_kontostand - gesamt_aufbuchungen
gesamt = {
'wert': from_double_to_german(gesamt_kontostand),
'difference': from_double_to_german(gesamt_diff),
'aufbuchungen': from_double_to_german(gesamt_aufbuchungen),
'difference_is_negativ': gesamt_diff < 0
}
context = viewcore.generate_transactional_context('uebersicht_sparkontos')
context['sparkontos'] = sparkonto_liste
context['gesamt'] = gesamt
return context
def handle_request(request):
if not database_instance().sparkontos.get_depots():
return viewcore.generate_error_context('add_depotauszug', NO_VALID_DEPOT_IN_DB)
if not database_instance().depotwerte.get_depotwerte():
return viewcore.generate_error_context('add_depotauszug', NO_VALID_SHARE_IN_DB)
if post_action_is(request, 'add'):
current_date = None
for element in request.values:
if element.startswith('datum_'):
current_date = datum(request.values[element])
if not current_date:
return viewcore.generate_error_context('add_depotauszug', 'Interner Fehler <Kein Datum gefunden>.')
konto = request.values['konto']
if "edit_index" in request.values:
for element in request.values:
if element.startswith(KEY_WERT):
depotwert = element.split('_')[-1]
db_index = database_instance().depotauszuege.resolve_index(current_date, konto, depotwert)
value = request.values[element].replace(",", ".")
value = float(value)
if db_index is not None:
database_instance().depotauszuege.edit(db_index,
datum=current_date,
depotwert=depotwert,
wert="%.2f" % value,
konto=konto)
non_persisted_state.add_changed_depotauszuege(
{
'fa': 'pencil',
'datum': datum_to_german(current_date),
'wert': from_double_to_german(value),
'depotwert': depotwert,
'konto': konto
})
else:
database_instance().depotauszuege.add(datum=current_date,
depotwert=depotwert,
wert="%.2f" % value,
konto=konto)
non_persisted_state.add_changed_depotauszuege(
{
'fa': 'plus',
'datum': datum_to_german(current_date),
'wert': from_double_to_german(value),
'depotwert': depotwert,
'konto': konto
})
else:
result = database_instance().depotauszuege.get_by(current_date, konto)
if len(result) > 0:
return viewcore.generate_error_context('add_depotauszug',
'Für es besteht bereits ein Kontoauszug für {} am {}'.format(
konto,
datum_to_german(current_date)))
for element in request.values:
if element.startswith(KEY_WERT):
depotwert = element.split('_')[-1]
value = request.values[element].replace(",", ".")
value = float(value)
if value == 0 and not database_instance().depotauszuege.exists_wert(konto, depotwert):
continue
database_instance().depotauszuege.add(datum=current_date,
depotwert=depotwert,
wert="%.2f" % value,
konto=konto)
non_persisted_state.add_changed_depotauszuege(
{
'fa': 'plus',
'datum': datum_to_german(current_date),
'wert': from_double_to_german(value),
'depotwert': depotwert,
'konto': konto
})
context = viewcore.generate_transactional_context('add_depotauszug')
context['approve_title'] = 'Depotauszug hinzufügen'
depotwerte = database_instance().depotwerte.get_depotwerte_descriptions()
if post_action_is(request, 'edit'):
print("Please edit:", request.values['edit_index'])
db_index = int(request.values['edit_index'])
db_row = database_instance().depotauszuege.get(db_index)
edit_datum = db_row['Datum']
edit_konto = db_row['Konto']
db_row = database_instance().depotauszuege.get_by(edit_datum, edit_konto)
filled_items = calculate_filled_items(db_row, depotwerte)
empty_items = calculate_empty_items(depotwerte, filled_items)
default_item = [{
'datum': datum_to_string(edit_datum),
'konto': edit_konto,
'filled_items': filled_items,
'empty_items': empty_items
}]
context['default_items'] = default_item
context['bearbeitungsmodus'] = True
context['edit_index'] = db_index
context['approve_title'] = 'Depotauszug aktualisieren'
if 'default_items' not in context:
context['default_items'] = []
for konto in database_instance().sparkontos.get_depots():
default_datum = database_instance().depotauszuege.get_latest_datum_by(konto)
if not default_datum:
default_datum = date.today()
db_row = database_instance().depotauszuege.get_by(default_datum, konto)
filled_items = calculate_filled_items(db_row, depotwerte)
empty_items = calculate_empty_items(depotwerte, filled_items)
if len(filled_items) == 0:
filled_items = empty_items
empty_items = []
default_item = {
'datum': datum_to_string(date.today()),
'konto': konto,
'filled_items': filled_items,
'empty_items': empty_items
}
context['default_items'].append(default_item)
context['letzte_erfassung'] = reversed(non_persisted_state.get_changed_depotauszuege())
return context
def handle_request(request):
context = viewcore.generate_transactional_context('addeinzelbuchung')
context['element_titel'] = 'Neue Ausgabe'
context['approve_title'] = 'Ausgabe hinzufügen'
einzelbuchungen = persisted_state.database_instance().einzelbuchungen
if post_action_is(request, 'add'):
value = dezimal_float(request.values['wert']) * -1
if 'edit_index' in request.values:
database_index = int(request.values['edit_index'])
datum_object = datum(request.values['date'])
einzelbuchungen.edit(database_index, datum_object,
request.values['kategorie'],
request.values['name'], value)
non_persisted_state.add_changed_einzelbuchungen({
'fa':
'pencil',
'datum':
datum_to_german(datum_object),
'kategorie':
request.values['kategorie'],
'name':
request.values['name'],
'wert':
from_double_to_german(value)
})
else:
datum_object = datum(request.values['date'])
einzelbuchungen.add(datum_object, request.values['kategorie'],
request.values['name'], value)
non_persisted_state.add_changed_einzelbuchungen({
'fa':
'plus',
'datum':
datum_to_german(datum_object),
'kategorie':
request.values['kategorie'],
'name':
request.values['name'],
'wert':
from_double_to_german(value)
})
if post_action_is(request, 'edit'):
db_index = int(request.values['edit_index'])
selected_item = einzelbuchungen.get(db_index)
selected_item['Datum'] = datum_to_string(selected_item['Datum'])
selected_item['Wert'] = from_double_to_german(selected_item['Wert'] *
-1)
context['default_item'] = selected_item
context['bearbeitungsmodus'] = True
context['edit_index'] = db_index
context['set_kategorie'] = True
context['element_titel'] = 'Einzelbuchung bearbeiten'
context['active_name'] = 'Einzelbuchung bearbeiten'
context['approve_title'] = 'Ausgabe aktualisieren'
if 'default_item' not in context:
context['default_item'] = {
'Name': '',
'Datum': '',
'Wert': '',
}
context['kategorien'] = sorted(
einzelbuchungen.get_kategorien_ausgaben(
hide_ausgeschlossene_kategorien=True))
context['letzte_erfassung'] = reversed(
non_persisted_state.get_changed_einzelbuchungen())
return context
def handle_request(request):
if request.method == 'POST' and request.values['action'] == 'add':
value = dezimal_float(request.values['wert'])
if request.values['typ'] == TYP_AUSGABE:
value = value * -1
if 'edit_index' in request.values:
startdatum = datum(request.values['startdatum'])
endedatum = datum(request.values['endedatum'])
database_instance().dauerauftraege.edit(
int(request.values['edit_index']), startdatum, endedatum,
request.values['kategorie'], request.values['name'],
request.values['rhythmus'], value)
non_persisted_state.add_changed_dauerauftraege({
'fa':
'pencil',
'startdatum':
datum_to_german(startdatum),
'endedatum':
datum_to_german(endedatum),
'kategorie':
request.values['kategorie'],
'name':
request.values['name'],
'rhythmus':
request.values['rhythmus'],
'wert':
from_double_to_german(value)
})
else:
startdatum = datum(request.values['startdatum'])
endedatum = datum(request.values['endedatum'])
database_instance().dauerauftraege.add(startdatum, endedatum,
request.values['kategorie'],
request.values['name'],
request.values['rhythmus'],
value)
non_persisted_state.add_changed_dauerauftraege({
'fa':
'plus',
'startdatum':
datum_to_german(startdatum),
'endedatum':
datum_to_german(endedatum),
'kategorie':
request.values['kategorie'],
'name':
request.values['name'],
'rhythmus':
request.values['rhythmus'],
'wert':
from_double_to_german(value)
})
context = viewcore.generate_transactional_context('adddauerauftrag')
context['approve_title'] = 'Dauerauftrag hinzufügen'
if post_action_is(request, 'edit'):
db_index = int(request.values['edit_index'])
default_item = database_instance().dauerauftraege.get(db_index)
default_item['Startdatum'] = datum_to_string(
default_item['Startdatum'])
default_item['Endedatum'] = datum_to_string(default_item['Endedatum'])
default_item['Rhythmus'] = default_item['Rhythmus']
if default_item['Wert'] < 0:
default_item['typ'] = TYP_AUSGABE
else:
default_item['typ'] = TYPE_EINNAHME
default_item['Wert'] = from_double_to_german(abs(default_item['Wert']))
context['default_item'] = default_item
context['bearbeitungsmodus'] = True
context['edit_index'] = db_index
context['approve_title'] = 'Dauerauftrag aktualisieren'
context['element_titel'] = 'Dauerauftrag bearbeiten'
context['active_name'] = 'Dauerauftrag bearbeiten'
if 'default_item' not in context:
context['default_item'] = {
'Startdatum': '',
'Endedatum': '',
'typ': TYP_AUSGABE,
'Rhythmus': ALL_FREQUENCY_NAMES[0],
'Wert': '',
'Name': ''
}
context['kategorien'] = sorted(
database_instance().einzelbuchungen.get_alle_kategorien(
hide_ausgeschlossene_kategorien=True))
context['letzte_erfassung'] = reversed(
non_persisted_state.get_changed_dauerauftraege())
context['rhythmen'] = ALL_FREQUENCY_NAMES
return context
def handle_request(request):
if not database_instance().sparkontos.get_sparfaehige_kontos():
return viewcore.generate_error_context('add_sparbuchung',
NO_VALID_SAVINGS_ACCOUNT_IN_DB)
if post_action_is(request, 'add'):
date = datum(request.values['datum'])
value = request.values['wert'].replace(",", ".")
value = float(value)
if request.values[EIGENSCHAFT] == EIGENSCHAFT_AUSZAHLUNG:
value = value * -1
if "edit_index" in request.values:
database_instance().sparbuchungen.edit(
int(request.values['edit_index']),
datum=date,
name=request.values['name'],
wert="%.2f" % value,
typ=request.values['typ'],
konto=request.values['konto'])
non_persisted_state.add_changed_sparbuchungen({
'fa':
'pencil',
'datum':
datum_to_german(date),
'wert':
from_double_to_german(value),
'name':
request.values['name'],
'typ':
request.values['typ'],
'konto':
request.values['konto']
})
else:
database_instance().sparbuchungen.add(
datum=date,
name=request.values['name'],
wert="%.2f" % value,
typ=request.values['typ'],
konto=request.values['konto'])
non_persisted_state.add_changed_sparbuchungen({
'fa':
'plus',
'datum':
datum_to_german(date),
'wert':
from_double_to_german(value),
'name':
request.values['name'],
'typ':
request.values['typ'],
'konto':
request.values['konto']
})
context = viewcore.generate_transactional_context('add_sparbuchung')
context['approve_title'] = 'Sparbuchung hinzufügen'
if post_action_is(request, 'edit'):
print("Please edit:", request.values['edit_index'])
db_index = int(request.values['edit_index'])
db_row = database_instance().sparbuchungen.get(db_index)
if db_row['Wert'] > 0:
eigenschaft = EIGENSCHAFT_EINZAHLUNG
else:
eigenschaft = EIGENSCHAFT_AUSZAHLUNG
default_item = {
'edit_index': str(db_index),
'datum': datum_to_string(db_row['Datum']),
'name': db_row['Name'],
'wert': from_double_to_german(abs(db_row['Wert'])),
'typ': db_row['Typ'],
'eigenschaft': eigenschaft,
'konto': db_row['Konto']
}
context['default_item'] = default_item
context['bearbeitungsmodus'] = True
context['edit_index'] = db_index
context['approve_title'] = 'Sparbuchung aktualisieren'
if 'default_item' not in context:
context['default_item'] = {
'name': '',
'wert': '',
'datum': '',
'typ': '',
'konto': ''
}
context['kontos'] = database_instance().sparkontos.get_sparfaehige_kontos()
context['typen'] = database_instance().sparbuchungen.AUFTRAGS_TYPEN
context[EIGENSCHAFTEN] = [EIGENSCHAFT_EINZAHLUNG, EIGENSCHAFT_AUSZAHLUNG]
context['letzte_erfassung'] = reversed(
non_persisted_state.get_changed_sparbuchungen())
return context
def handle_request(request):
if not database_instance().sparkontos.get_depots():
return viewcore.generate_error_context('add_order',
NO_VALID_DEPOT_IN_DB)
if not database_instance().depotwerte.get_depotwerte():
return viewcore.generate_error_context('add_order',
NO_VALID_SHARE_IN_DB)
if post_action_is(request, 'add'):
date = datum(request.values['datum'])
value = request.values['wert'].replace(",", ".")
value = float(value)
if request.values[TYP] == TYP_VERKAUF:
value = value * -1
if "edit_index" in request.values:
database_instance().order.edit(
int(request.values['edit_index']),
datum=date,
name=request.values['name'],
wert="%.2f" % value,
depotwert=request.values['depotwert'],
konto=request.values['konto'])
non_persisted_state.add_changed_order({
'fa':
'pencil',
'datum':
datum_to_german(date),
'wert':
from_double_to_german(abs(value)),
'name':
request.values['name'],
TYP:
request.values[TYP],
'depotwert':
request.values['depotwert'],
'konto':
request.values['konto']
})
else:
database_instance().order.add(
datum=date,
name=request.values['name'],
wert="%.2f" % value,
depotwert=request.values['depotwert'],
konto=request.values['konto'])
non_persisted_state.add_changed_order({
'fa':
'plus',
'datum':
datum_to_german(date),
'wert':
from_double_to_german(value),
'name':
request.values['name'],
TYP:
request.values[TYP],
'value':
'%.2f' % abs(value),
'depotwert':
request.values['depotwert'],
'konto':
request.values['konto']
})
context = viewcore.generate_transactional_context('add_order')
context['approve_title'] = 'Order hinzufügen'
if post_action_is(request, 'edit'):
print("Please edit:", request.values['edit_index'])
db_index = int(request.values['edit_index'])
db_row = database_instance().order.get(db_index)
if db_row['Wert'] > 0:
typ = TYP_KAUF
else:
typ = TYP_VERKAUF
default_item = {
'edit_index': str(db_index),
'datum': datum_to_string(db_row['Datum']),
'name': db_row['Name'],
'wert': from_double_to_german(abs(db_row['Wert'])),
'depotwert': db_row['Depotwert'],
'typ': typ,
'konto': db_row['Konto']
}
context['default_item'] = default_item
context['bearbeitungsmodus'] = True
context['edit_index'] = db_index
context['approve_title'] = 'Order aktualisieren'
if 'default_item' not in context:
context['default_item'] = {
'name': '',
'wert': '',
'datum': '',
'depotwert': '',
'konto': ''
}
context['kontos'] = database_instance().sparkontos.get_depots()
context[TYPEN] = [TYP_KAUF, TYP_VERKAUF]
context['depotwerte'] = database_instance(
).depotwerte.get_depotwerte_descriptions()
context['letzte_erfassung'] = reversed(
non_persisted_state.get_changed_order())
return context
def handle_request(request):
if post_action_is(request, 'add'):
date = datum(request.values['date'])
value = request.values['wert'].replace(",", ".")
value = float(value)
value = value * -1
if "edit_index" in request.values:
database_instance().gemeinsamebuchungen.edit(
int(request.values['edit_index']),
datum=date,
name=str(request.values['name']),
kategorie=request.values['kategorie'],
wert=value,
person=request.values['person'])
non_persisted_state.add_changed_gemeinsamebuchungen({
'fa':
'pencil',
'datum':
datum_to_german(date),
'kategorie':
request.values['kategorie'],
'name':
request.values['name'],
'wert':
from_double_to_german(value),
'person':
request.values['person']
})
else:
database_instance().gemeinsamebuchungen.add(
ausgaben_datum=date,
kategorie=request.values['kategorie'],
ausgaben_name=request.values['name'],
wert="%.2f" % value,
person=request.values['person'])
non_persisted_state.add_changed_gemeinsamebuchungen({
'fa':
'plus',
'datum':
datum_to_german(date),
'kategorie':
request.values['kategorie'],
'name':
request.values['name'],
'wert':
from_double_to_german(value),
'person':
request.values['person']
})
context = viewcore.generate_transactional_context("addgemeinsam")
context['approve_title'] = 'Gemeinsame Ausgabe hinzufügen'
if post_action_is(request, 'edit'):
print("Please edit:", request.values['edit_index'])
db_index = int(request.values['edit_index'])
db_row = database_instance().gemeinsamebuchungen.get(db_index)
default_item = {
'edit_index': str(db_index),
'datum': datum_to_string(db_row['Datum']),
'name': db_row['Name'],
'wert': from_double_to_german(db_row['Wert'] * -1),
'kategorie': db_row['Kategorie'],
'person': db_row['Person']
}
context['default_item'] = default_item
context['bearbeitungsmodus'] = True
context['edit_index'] = db_index
context['approve_title'] = 'Gemeinsame Ausgabe aktualisieren'
if 'default_item' not in context:
context['default_item'] = {'name': '', 'wert': '', 'datum': ''}
context['personen'] = [
database_instance().name,
viewcore.name_of_partner()
]
context['kategorien'] = sorted(
database_instance().einzelbuchungen.get_kategorien_ausgaben(
hide_ausgeschlossene_kategorien=True))
context['letzte_erfassung'] = reversed(
non_persisted_state.get_changed_gemeinsamebuchungen())
return context
def generate_konto_uebersicht(color_kontos, color_typen):
sparkontos = persisted_state.database_instance().sparkontos
gesamt_kontostand = 0
gesamt_aufbuchungen = 0
sparkonto_liste = []
kontotypen_werte = dict.fromkeys(sparkontos.KONTO_TYPEN, 0)
for typ in kontotypen_werte:
kontotypen_werte[typ] = {'gesamt': 0, 'aufbuchungen': 0}
db = sparkontos.get_all()
for row_index, row in db.iterrows():
aktueller_kontostand = 0
aufbuchungen = 0
kontoname = row.Kontoname
kontotyp = row.Kontotyp
if kontotyp == sparkontos.TYP_SPARKONTO or kontotyp == sparkontos.TYP_GENOSSENSCHAFTSANTEILE:
aktueller_kontostand = persisted_state.database_instance(
).sparbuchungen.get_kontostand_fuer(kontoname)
aufbuchungen = persisted_state.database_instance(
).sparbuchungen.get_aufbuchungen_fuer(kontoname)
if kontotyp == sparkontos.TYP_DEPOT:
aufbuchungen = persisted_state.database_instance(
).order.get_order_fuer(kontoname)
aktueller_kontostand = persisted_state.database_instance(
).depotauszuege.get_kontostand_by(kontoname)
gesamt_kontostand += aktueller_kontostand
gesamt_aufbuchungen += aufbuchungen
diff = aktueller_kontostand - aufbuchungen
kontotypen_werte[kontotyp]['gesamt'] += aktueller_kontostand
kontotypen_werte[kontotyp]['aufbuchungen'] += aufbuchungen
sparkonto_liste.append({
'index':
row_index,
'color':
color_kontos.get_for_value(kontoname),
'name':
kontoname,
'kontotyp':
kontotyp,
'wert':
aktueller_kontostand,
'difference':
diff,
'aufbuchungen':
aufbuchungen,
'wert_str':
from_double_to_german(aktueller_kontostand),
'difference_str':
from_double_to_german(diff),
'aufbuchungen_str':
from_double_to_german(aufbuchungen),
'difference_is_negativ':
diff < 0
})
kontotypen_liste = []
for kontotyp in kontotypen_werte:
diff = kontotypen_werte[kontotyp]['gesamt'] - kontotypen_werte[
kontotyp]['aufbuchungen']
kontotypen_liste.append({
'name':
kontotyp,
'color':
color_typen.get_for_value(kontotyp),
'wert':
kontotypen_werte[kontotyp]['gesamt'],
'wert_str':
from_double_to_german(kontotypen_werte[kontotyp]['gesamt']),
'aufbuchungen':
kontotypen_werte[kontotyp]['aufbuchungen'],
'aufbuchungen_str':
from_double_to_german(kontotypen_werte[kontotyp]['aufbuchungen']),
'difference':
diff,
'difference_str':
from_double_to_german(diff)
})
gesamt_diff = gesamt_kontostand - gesamt_aufbuchungen
gesamt = {
'wert': gesamt_kontostand,
'difference': gesamt_diff,
'aufbuchungen': gesamt_aufbuchungen,
'wert_str': from_double_to_german(gesamt_kontostand),
'difference_str': from_double_to_german(gesamt_diff),
'aufbuchungen_str': from_double_to_german(gesamt_aufbuchungen),
'difference_is_negativ': gesamt_diff < 0
}
return gesamt, sparkonto_liste, kontotypen_liste
def gesamt_uebersicht():
einzelbuchungen = persisted_state.database_instance().einzelbuchungen
sparkontos = persisted_state.database_instance().sparkontos
min_jahr = einzelbuchungen.content.copy()[
einzelbuchungen.content.copy().Kategorie != 'Sparen'].Datum.min().year
max_jahr = date.today().year
year_kontostaende = []
gesamt_uebersicht = []
for jahr in range(min_jahr, max_jahr + 1):
buchungen_jahr = einzelbuchungen.select().select_year(
jahr).content.copy()
ausgaben = buchungen_jahr[buchungen_jahr.Wert < 0].copy()
ausgaben = ausgaben[ausgaben.Kategorie != 'Sparen'].Wert.sum()
einnahmen = buchungen_jahr[buchungen_jahr.Wert > 0].copy()
einnahmen = einnahmen[einnahmen.Kategorie != 'Sparen'].Wert.sum()
db = sparkontos.get_all()
sparen_aufbuchung = 0
gesamt_sparen = 0
year_kontos = {}
for row_index, row in db.iterrows():
kontostand = 0
aufbuchungen = 0
sparbuchungen_year = persisted_state.database_instance(
).sparbuchungen.select_year(jahr)
sparbuchungen_max_year = persisted_state.database_instance(
).sparbuchungen.select_max_year(jahr)
depotauszuege_year = persisted_state.database_instance(
).depotauszuege.select_max_year(jahr)
order_year = persisted_state.database_instance().order.select_year(
jahr)
kontoname = row.Kontoname
kontotyp = row.Kontotyp
if kontotyp == sparkontos.TYP_SPARKONTO or kontotyp == sparkontos.TYP_GENOSSENSCHAFTSANTEILE:
kontostand = sparbuchungen_max_year.get_kontostand_fuer(
kontoname)
aufbuchungen = sparbuchungen_year.get_aufbuchungen_fuer(
kontoname)
if kontotyp == sparkontos.TYP_DEPOT:
aufbuchungen = order_year.get_order_fuer(kontoname)
kontostand = depotauszuege_year.get_kontostand_by(kontoname)
year_kontos[kontoname] = {
'kontostand': kontostand,
'kontostand_str': from_double_to_german(kontostand),
'aufbuchungen': aufbuchungen,
'aufbuchungen_str': from_double_to_german(aufbuchungen),
'name': kontoname
}
gesamt_sparen += kontostand
sparen_aufbuchung += aufbuchungen
year_kontos['Gesamt'] = {
'kontostand': gesamt_sparen,
'aufbuchungen': sparen_aufbuchung,
'kontostand_str': from_double_to_german(gesamt_sparen),
'aufbuchungen_str': from_double_to_german(sparen_aufbuchung),
'name': 'Gesamt'
}
year_kontostaende.append(year_kontos)
gesamt_uebersicht.append({
'jahr': jahr,
'ausgaben': ausgaben,
'einnahmen': einnahmen,
'sparen_aufbuchung': sparen_aufbuchung,
'gesamt_sparen': gesamt_sparen,
})
return gesamt_uebersicht, year_kontostaende