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):
all_files = all_abrechnungen()
text_report_reader = TextReportReader()
all_content = Einzelbuchungen()
abrechnungen = []
for file in all_files:
report = text_report_reader.read(''.join(file['content']))
all_content.parse(report)
abrechnungen.append({
'name': file['name'],
'content': ''.join(file['content'])
})
jahre = all_content.get_jahre()
zusammenfassungen = []
for jahr in sorted(jahre):
year_selection = all_content.select().select_year(jahr)
monate = []
for monat in range(1, 13):
monate.append(year_selection.select_month(monat).count())
zusammenfassungen.append({'jahr': jahr, 'monate': monate})
context = viewcore.generate_transactional_context('uebersichtabrechnungen')
context['zusammenfassungen'] = zusammenfassungen
context['abrechnungen'] = abrechnungen
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, 'delete'):
database_instance().gemeinsamebuchungen.delete(int(request.values['delete_index']))
return request_handler.create_redirect_context('/gemeinsameuebersicht/')
context = viewcore.generate_transactional_context('gemeinsameuebersicht')
context['ausgaben'] = to_descriptive_list(
database_instance().gemeinsamebuchungen.select().to_list())
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 _handle_request(request):
orderdauerauftrag = persisted_state.database_instance().orderdauerauftrag
if post_action_is(request, 'delete'):
print("Delete: ", request.values['delete_index'])
orderdauerauftrag.delete(int(request.values['delete_index']))
return request_handler.create_redirect_context('/uebersicht_orderdauerauftrag/')
context = viewcore.generate_transactional_context('uebersicht_orderdauerauftrag')
data = collections.OrderedDict()
data['Aktuelle Daueraufträge'] = _format_dauerauftrag_floatpoint(orderdauerauftrag.aktuelle())
data['Zukünftige Daueraufträge'] = _format_dauerauftrag_floatpoint(orderdauerauftrag.future())
data['Vergangene Daueraufträge'] = _format_dauerauftrag_floatpoint(orderdauerauftrag.past())
context['dauerauftraege'] = data
return context
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):
if post_action_is(request, 'edit_databases'):
dbs = request.values['dbs']
configuration_provider.set_configuration('DATABASES', dbs)
persisted_state.DATABASES = []
persisted_state.DATABASE_INSTANCE = None
if post_action_is(request, 'add_kategorie'):
persisted_state.database_instance().einzelbuchungen.add_kategorie(
request.values['neue_kategorie'])
if post_action_is(request, 'change_themecolor'):
configuration_provider.set_configuration('THEME_COLOR',
request.values['themecolor'])
if post_action_is(request, 'change_colorpalette'):
request_colors = []
for colornumber in range(0, 20):
if str(colornumber) + '_checked' in request.values:
request_colors.append(request.values[str(colornumber) +
'_farbe'][1:])
configuration_provider.set_configuration('DESIGN_COLORS',
','.join(request_colors))
if post_action_is(request, 'set_partnername'):
persisted_state.database_instance().gemeinsamebuchungen.rename(
viewcore.name_of_partner(), request.values['partnername'])
configuration_provider.set_configuration('PARTNERNAME',
request.values['partnername'])
if post_action_is(request, 'set_ausgeschlossene_kategorien'):
configuration_provider.set_configuration(
'AUSGESCHLOSSENE_KATEGORIEN',
request.values['ausgeschlossene_kategorien'])
new_set = set(
list(request.values['ausgeschlossene_kategorien'].split(',')))
persisted_state.database_instance(
).einzelbuchungen.ausgeschlossene_kategorien = new_set
farbmapping = []
kategorien = sorted(
list(persisted_state.database_instance().einzelbuchungen.
get_alle_kategorien()))
for colornumber in range(0, 20):
checked = False
kategorie = 'keine'
color = viewcore.design_colors()[colornumber %
len(viewcore.design_colors())]
len_kategorien = len(kategorien)
if colornumber < len_kategorien:
kategorie = kategorien[colornumber % len_kategorien]
if colornumber < len(viewcore.design_colors()):
checked = True
farbmapping.append({
'nummer': colornumber,
'checked': checked,
'farbe': color,
'kategorie': kategorie
})
context = viewcore.generate_transactional_context('configuration')
context['palette'] = farbmapping
default_databases = ''
for db in persisted_state.DATABASES:
if len(default_databases) != 0:
default_databases = default_databases + ','
default_databases = default_databases + db
context['default_databases'] = default_databases
context['partnername'] = viewcore.name_of_partner()
context['themecolor'] = configuration_provider.get_configuration(
'THEME_COLOR')
context[
'ausgeschlossene_kategorien'] = configuration_provider.get_configuration(
'AUSGESCHLOSSENE_KATEGORIEN')
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, import_prefix='', gemeinsam=False):
context = viewcore.generate_transactional_context('import')
if request.method == "POST":
if post_action_is(request, 'load_online_transactions'):
serverurl = request.values['server']
serverurl = _add_protokoll_if_needed(serverurl)
_save_server_creds(serverurl, request.values['email'])
auth_container = login(serverurl, request.values['email'],
request.values['password'])
json_report = get_einzelbuchungen(serverurl, auth_container)
print(json_report)
print('Mapping to text report')
text_report = JSONToTextMapper().map(json_report)
print(text_report)
response = handle_request(PostRequest({'import': text_report}),
import_prefix='Internet')
delete_einzelbuchungen(serverurl, auth_container=auth_container)
return response
if post_action_is(request, 'load_online_gemeinsame_transactions'):
serverurl = request.values['server']
serverurl = _add_protokoll_if_needed(serverurl)
_save_server_creds(serverurl, request.values['email'])
print(serverurl)
auth_container = login(serverurl, request.values['email'],
request.values['password'])
online_username = auth_container.online_name()
print('butler_online username: '******'table before person mapping', table)
table.Person = table.Person.map(
lambda x: database_instance().name if x == online_username else
configuration_provider.get_configuration('PARTNERNAME'))
online_content = TextReportWriter().generate_report(table)
response = handle_request(PostRequest({'import': online_content}),
import_prefix='Internet_Gemeinsam',
gemeinsam=True)
delete_gemeinsame_buchungen(serverurl,
auth_container=auth_container)
return response
elif post_action_is(request, 'set_kategorien'):
kategorien = ','.join(
sorted(database_instance().einzelbuchungen.get_alle_kategorien(
hide_ausgeschlossene_kategorien=True)))
serverurl = request.values['server']
serverurl = _add_protokoll_if_needed(serverurl)
_save_server_creds(serverurl, request.values['email'])
auth_container = login(serverurl, request.values['email'],
request.values['password'])
set_kategorien(serverurl,
kategorien=kategorien,
auth_container=auth_container)
set_success_message(
context,
'Kategorien erfolgreich in die Online-Version übertragen.')
elif post_action_is(request, 'upload_gemeinsame_transactions'):
serverurl = request.values['server']
serverurl = _add_protokoll_if_needed(serverurl)
_save_server_creds(serverurl, request.values['email'])
print(serverurl)
auth_container = login(serverurl, request.values['email'],
request.values['password'])
online_username = auth_container.online_name()
print('butler_online username:'******'butler offline username:'******'butler online partnername:', online_partnername)
offline_partnername = configuration_provider.get_configuration(
'PARTNERNAME')
print('butler offline partnername:', offline_partnername)
buchungen = database_instance(
).gemeinsamebuchungen.get_renamed_list(offline_username,
online_username,
offline_partnername,
online_partnername)
request_data = []
for buchung in buchungen:
request_data.append({
'datum': datum_to_string(buchung['Datum']),
'name': buchung['Name'],
'wert': buchung['Wert'],
'kategorie': buchung['Kategorie'],
'zielperson': buchung['Person']
})
anzahl_buchungen = len(buchungen)
result = upload_gemeinsame_buchungen(serverurl, request_data,
auth_container)
if result:
set_success_message(
context,
'{anzahl_buchungen} Buchungen wurden erfolgreich hochgeladen.'
.format(anzahl_buchungen=anzahl_buchungen))
database_instance().gemeinsamebuchungen.drop_all()
else:
set_error_message(
context,
'Fehler beim Hochladen der gemeinsamen Buchungen.')
else:
print(request.values)
content = request.values['import'].replace('\r', '')
write_import(import_prefix + 'Import_' + str(datetime.now()),
content)
imported_values = TextReportReader().read(content)
datenbank_kategorien = set(
database_instance().einzelbuchungen.get_alle_kategorien())
nicht_passende_kategorien = []
for imported_kategorie in set(imported_values.Kategorie):
if imported_kategorie not in datenbank_kategorien:
nicht_passende_kategorien.append(imported_kategorie)
if 'Person' in imported_values.columns:
gemeinsam = True
if not nicht_passende_kategorien:
print('keine unpassenden kategorien gefunden')
print('beginne mit dem direkten import')
_import(imported_values, gemeinsam)
last_elements = []
for row_index, row in imported_values.iterrows():
last_elements.append((row_index, row.Datum, row.Name,
row.Kategorie, row.Wert))
context['ausgaben'] = last_elements
context = set_success_message(
context, _get_success_message(last_elements))
elif _mapping_passt(request.values, nicht_passende_kategorien):
print(
'import kann durchgeführt werden, weil mapping vorhanden')
imported_values = _map_kategorien(imported_values,
nicht_passende_kategorien,
request.values)
_import(imported_values, gemeinsam)
last_elements = []
for row_index, row in imported_values.iterrows():
last_elements.append((row_index, row.Datum, row.Name,
row.Kategorie, row.Wert))
context['ausgaben'] = last_elements
context = set_success_message(
context, _get_success_message(last_elements))
else:
print("Nicht passende Kategorien: ", nicht_passende_kategorien)
options = ['neue Kategorie anlegen']
for kategorie_option in datenbank_kategorien:
options.append('als ' + str(kategorie_option) +
' importieren')
options = sorted(options)
options.insert(0, 'neue Kategorie anlegen')
context['element_titel'] = 'Kategorien zuweisen'
context['unpassende_kategorien'] = nicht_passende_kategorien
context['optionen'] = options
context['import'] = request.values['import']
context['special_page'] = 'shared/import_mapping.html'
context[
'ONLINE_DEFAULT_SERVER'] = configuration_provider.get_configuration(
'ONLINE_DEFAULT_SERVER')
context['ONLINE_DEFAULT_USER'] = configuration_provider.get_configuration(
'ONLINE_DEFAULT_USER')
return context
def _handle_request(request):
context = viewcore.generate_transactional_context(PAGE_NAME)
if post_action_is(request, 'update_data'):
context = _update_data(request.values['isin'], context)
return _generate_content(context)
def _handle_request(request):
depotauszuege = persisted_state.database_instance().depotauszuege
if post_action_is(request, 'delete'):
delete_index = int(request.values['delete_index'])
delete_konto = depotauszuege.resolve_konto(delete_index)
delete_datum = depotauszuege.resolve_datum(delete_index)
depotauszuege.delete_depotauszug(delete_datum, delete_konto)
return request_handler.create_redirect_context(
'/uebersicht_depotauszuege/')
depotwerte = persisted_state.database_instance().depotwerte
db = depotauszuege.get_all()
gesamt = []
datum_alt = None
konto_alt = None
index_alt = None
buchungen = []
for row_index, row in db.iterrows():
if not datum_alt:
datum_alt = row.Datum
if not konto_alt:
konto_alt = row.Konto
if index_alt == None:
index_alt = row_index
if datum_alt != row.Datum or konto_alt != row.Konto:
gesamt.append({
'name':
'{} vom {}'.format(konto_alt, datum_to_german(datum_alt)),
'index':
index_alt,
'buchungen':
buchungen
})
buchungen = []
datum_alt = row.Datum
konto_alt = row.Konto
index_alt = row_index
buchungen.append({
'depotwert':
depotwerte.get_description_for(row.Depotwert),
'wert':
row.Wert
})
if index_alt:
gesamt.append({
'name':
'{} vom {}'.format(konto_alt, datum_to_german(datum_alt)),
'index':
index_alt,
'buchungen':
buchungen
})
context = viewcore.generate_transactional_context(
'uebersicht_depotauszuege')
context['gesamt'] = gesamt
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 _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_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
