def handle_request(request):
if post_action_is(request, 'add'):
isin = request.values['isin']
if '_' in isin:
return viewcore.generate_error_context(
'add_depotwert', 'ISIN darf kein Unterstrich "_" enthalten.')
name = request.values['name']
typ = request.values['typ']
if "edit_index" in request.values:
database_instance().depotwerte.edit(int(
request.values['edit_index']),
name=name,
isin=isin,
typ=typ)
non_persisted_state.add_changed_depotwerte({
'fa': 'pencil',
'Name': name,
'Isin': isin,
'Typ': typ
})
else:
database_instance().depotwerte.add(name=name, isin=isin, typ=typ)
non_persisted_state.add_changed_depotwerte({
'fa': 'plus',
'Name': name,
'Isin': isin,
'Typ': typ
})
context = viewcore.generate_transactional_context('add_depotwert')
context['approve_title'] = 'Depotwert hinzufügen'
if post_action_is(request, 'edit'):
db_index = int(request.values['edit_index'])
db_row = database_instance().depotwerte.get(db_index)
default_item = {
'edit_index': str(db_index),
'name': db_row['Name'],
'isin': db_row['ISIN'],
'typ': db_row['Typ']
}
context['default_item'] = default_item
context['bearbeitungsmodus'] = True
context['edit_index'] = db_index
context['approve_title'] = 'Depotwert aktualisieren'
if 'default_item' not in context:
context['default_item'] = {
'name': '',
'isin': '',
'typ': database_instance().depotwerte.TYP_ETF
}
context['letzte_erfassung'] = reversed(
non_persisted_state.get_changed_depotwerte())
context['types'] = database_instance().depotwerte.TYPES
return context
def _handle_request(request):
if persisted_state.database_instance().einzelbuchungen.anzahl() == 0:
return viewcore.generate_error_context('uebersicht_sparen', 'Bitte erfassen Sie zuerst eine Einzelbuchung.')
context = viewcore.generate_transactional_context('sparen')
kontos = persisted_state.database_instance().sparkontos.get_all().Kontoname.tolist()
typen = persisted_state.database_instance().sparkontos.KONTO_TYPEN
depot_typen = persisted_state.database_instance().depotwerte.TYPES
color_kontos = viewcore.get_generic_color_chooser(kontos)
color_typen = viewcore.get_generic_color_chooser(typen + depot_typen)
gesamt, kontos, typen = generate_konto_uebersicht(color_kontos, color_typen)
diagramm_uebersicht, year_kontostaende = gesamt_uebersicht()
gesamt_tabelle = berechne_gesamt_tabelle(year_kontostaende)
gesamt_diagramm_labels, gesamt_diagramm_data = berechne_diagramm(diagramm_uebersicht)
gesamt_linechart = berechne_kontogesamt(gesamt_tabelle)
order_until_today = persisted_state.database_instance().orderdauerauftrag.get_all_order_until_today()
context['kontos'] = kontos
context['typen'] = typen
context['gesamt'] = gesamt
context['monatlich'] = berechne_monatlich()
context['order_typ'] = berechne_order_typ(order_until_today)
context['general_infos'] = general_infos()
context['konto_diagramm'] = to_piechart(kontos, gesamt['wert'])
context['typen_diagramm'] = to_piechart(typen, gesamt['wert'])
context['gesamt_diagramm_labels'] = gesamt_diagramm_labels
context['gesamt_diagramm_data'] = gesamt_diagramm_data
context['gesamt_linechart'] = gesamt_linechart
return context
def handle_request(request):
if post_action_is(request, 'add'):
kontoname = request.values['kontoname']
if '_' in kontoname:
return viewcore.generate_error_context(
'add_depotwert',
'Kontoname darf kein Unterstrich "_" enthalten.')
kontotyp = request.values['kontotyp']
if "edit_index" in request.values:
database_instance().sparkontos.edit(int(
request.values['edit_index']),
kontoname=kontoname,
kontotyp=kontotyp)
non_persisted_state.add_changed_sparkontos({
'fa': 'pencil',
'Kontoname': kontoname,
'Kontotyp': kontotyp
})
else:
database_instance().sparkontos.add(kontoname=kontoname,
kontotyp=kontotyp)
non_persisted_state.add_changed_sparkontos({
'fa': 'plus',
'Kontoname': kontoname,
'Kontotyp': kontotyp
})
context = viewcore.generate_transactional_context('add_sparkonto')
context['approve_title'] = 'Sparkonto 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().sparkontos.get(db_index)
default_item = {
'edit_index': str(db_index),
'kontotyp': db_row['Kontotyp'],
'kontoname': db_row['Kontoname']
}
context['default_item'] = default_item
context['bearbeitungsmodus'] = True
context['edit_index'] = db_index
context['approve_title'] = 'Sparkonto aktualisieren'
if 'default_item' not in context:
context['default_item'] = {'kontoname': '', 'kontotyp': ''}
context['kontotypen'] = database_instance().sparkontos.KONTO_TYPEN
context['letzte_erfassung'] = reversed(
non_persisted_state.get_changed_sparkontos())
return context
def _generate_content(context):
depotwerte = persisted_state.database_instance().depotwerte
shares_info = persisted_state.shares_data()
depotauszuege = persisted_state.database_instance().depotauszuege
isins = depotwerte.get_valid_isins()
if not isins:
return viewcore.generate_error_context(PAGE_NAME, NO_VALID_ISIN_IN_DB)
etfs = []
for isin in isins:
isin_datum = 'Noch keine Daten'
if shares_info.get_last_changed_date_for(isin):
isin_datum = shares_info.get_last_changed_date_for(isin)
etfs.append(
{
'Name': depotwerte.get_description_for(isin),
'Datum': isin_datum,
'ISIN': isin
}
)
all_relevant_isins = depotauszuege.get_isins_invested_by()
isins_with_data = shares_info.filter_out_isins_without_data(all_relevant_isins)
german = gettext.translation('iso3166', pycountry.LOCALES_DIR, languages=['de'])
context['etfs'] = etfs
context['regions'] = get_data(
lambda x: shares_info.get_latest_data_for(x)[SharesInfo.REGIONEN],
isins_with_data,
lambda x: depotauszuege.get_depotwert_by(x),
depotwerte,
lambda x: _translate(x, german)
)
context['sectors'] = get_data(
lambda x: shares_info.get_latest_data_for(x)[SharesInfo.SEKTOREN],
isins_with_data,
lambda x: depotauszuege.get_depotwert_by(x),
depotwerte,
lambda x: x
)
context['costs'] = _get_costs(shares_info, isins_with_data, lambda x: depotauszuege.get_depotwert_by(x), depotwerte)
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_base_context('monatsuebersicht')
einzelbuchungen = persisted_state.database_instance().einzelbuchungen
monate = sorted(einzelbuchungen.get_monate(), reverse=True)
context['monate'] = monate
if not monate:
return viewcore.generate_error_context('monatsuebersicht',
'Keine Ausgaben erfasst')
selected_item = context['monate'][0]
if request.method == "POST":
selected_item = request.values['date']
month = int(float(selected_item.split("_")[1]))
year = int(float(selected_item.split("_")[0]))
table_data_selection = einzelbuchungen.select().select_month(
month).select_year(year)
table_ausgaben = table_data_selection.select_ausgaben()
table_einnahmen = table_data_selection.select_einnahmen()
kategorien = einzelbuchungen.get_alle_kategorien()
color_chooser = viewcore.get_generic_color_chooser(list(kategorien))
'''
Berechnung der Ausgaben für das Kreisdiagramm
'''
ausgaben_liste = []
ausgaben_labels = []
ausgaben_data = []
ausgaben_colors = []
for kategorie, row in table_ausgaben.group_by_kategorie().iterrows():
ausgaben_labels.append(kategorie)
ausgaben_data.append("%.2f" % abs(row.Wert))
ausgaben_colors.append(color_chooser.get_for_value(kategorie))
ausgaben_liste.append((kategorie, "%.2f" % row.Wert,
color_chooser.get_for_value(kategorie)))
context['ausgaben'] = ausgaben_liste
context['ausgaben_labels'] = ausgaben_labels
context['ausgaben_data'] = ausgaben_data
context['ausgaben_colors'] = ausgaben_colors
'''
Berechnung der Einnahmen für das Kreisdiagramm
'''
einnahmen_liste = []
einnahmen_labels = []
einnahmen_data = []
einnahmen_colors = []
for kategorie, row in table_einnahmen.group_by_kategorie().iterrows():
einnahmen_labels.append(kategorie)
einnahmen_data.append("%.2f" % abs(row.Wert))
einnahmen_colors.append(color_chooser.get_for_value(kategorie))
einnahmen_liste.append((kategorie, "%.2f" % row.Wert,
color_chooser.get_for_value(kategorie)))
context['einnahmen'] = einnahmen_liste
context['einnahmen_labels'] = einnahmen_labels
context['einnahmen_data'] = einnahmen_data
context['einnahmen_colors'] = einnahmen_colors
zusammenfassung = table_data_selection.get_month_summary()
for tag, kategorien_liste in zusammenfassung:
for einheit in kategorien_liste:
einheit['farbe'] = color_chooser.get_for_value(
einheit['kategorie'])
context['zusammenfassung'] = zusammenfassung
ausgaben_monat = table_ausgaben.sum()
context['gesamt'] = "%.2f" % ausgaben_monat
einnahmen_monat = table_einnahmen.sum()
context['gesamt_einnahmen'] = "%.2f" % einnahmen_monat
selected_date = str(year) + "_" + str(month).rjust(2, "0")
context['selected_date'] = selected_date
context['selected_year'] = year
if einnahmen_monat >= abs(ausgaben_monat):
context['color_uebersicht_gruppe_1'] = "gray"
context['name_uebersicht_gruppe_1'] = 'Gedeckte Ausgaben'
context['wert_uebersicht_gruppe_1'] = '%.2f' % abs(ausgaben_monat)
context['color_uebersicht_gruppe_2'] = "lightgreen"
context['name_uebersicht_gruppe_2'] = 'Einnahmenüberschuss'
context['wert_uebersicht_gruppe_2'] = '%.2f' % (einnahmen_monat +
ausgaben_monat)
else:
context['color_uebersicht_gruppe_1'] = "gray"
context['name_uebersicht_gruppe_1'] = 'Gedeckte Ausgaben'
context['wert_uebersicht_gruppe_1'] = '%.2f' % einnahmen_monat
context['color_uebersicht_gruppe_2'] = "red"
context['name_uebersicht_gruppe_2'] = 'Ungedeckte Ausgaben'
context['wert_uebersicht_gruppe_2'] = '%.2f' % (
(ausgaben_monat + einnahmen_monat) * -1)
einnahmen_jahr = einzelbuchungen.select().select_einnahmen().select_year(
year).sum()
ausgaben_jahr = einzelbuchungen.select().select_ausgaben().select_year(
year).sum()
if einnahmen_jahr >= abs(ausgaben_jahr):
context['color_uebersicht_jahr_gruppe_1'] = "gray"
context['name_uebersicht_jahr_gruppe_1'] = 'Gedeckte Einnahmen'
context['wert_uebersicht_jahr_gruppe_1'] = '%.2f' % abs(ausgaben_jahr)
context['color_uebersicht_jahr_gruppe_2'] = "lightgreen"
context['name_uebersicht_jahr_gruppe_2'] = 'Einnahmenüberschuss'
context['wert_uebersicht_jahr_gruppe_2'] = '%.2f' % (einnahmen_jahr +
ausgaben_jahr)
else:
context['color_uebersicht_jahr_gruppe_1'] = "gray"
context['name_uebersicht_jahr_gruppe_1'] = 'Gedeckte Ausgaben'
context['wert_uebersicht_jahr_gruppe_1'] = '%.2f' % einnahmen_jahr
context['color_uebersicht_jahr_gruppe_2'] = "red"
context['name_uebersicht_jahr_gruppe_2'] = 'Ungedeckte Ausgaben'
context['wert_uebersicht_jahr_gruppe_2'] = '%.2f' % (
(ausgaben_jahr + einnahmen_jahr) * -1)
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