def _handle_request(_):
einzelbuchungen = viewcore.database_instance().einzelbuchungen
selector = einzelbuchungen.select()
ausgaben_liste = []
for row_index, row in selector.select_aktueller_monat().raw_table(
).iterrows():
ausgaben_liste.append({
'index': row_index,
'datum': datum_to_german(row.Datum),
'name': row.Name,
'kategorie': row.Kategorie,
'wert': '%.2f' % row.Wert
})
context = {
'zusammenfassung_monatsliste':
_monatsliste(),
'zusammenfassung_einnahmenliste':
_list_to_json(
selector.select_einnahmen().inject_zeros_for_last_6_months(
).select_letzte_6_montate().sum_monthly()),
'zusammenfassung_ausgabenliste':
_list_to_json(
selector.select_ausgaben().inject_zeros_for_last_6_months(
).select_letzte_6_montate().sum_monthly()),
'ausgaben_des_aktuellen_monats':
ausgaben_liste,
}
context = {**context, **viewcore.generate_base_context('dashboard')}
return context
def _handle_request(_):
name_self = viewcore.database_instance().name
name_partner = viewcore.name_of_partner()
ausgabe_sebastian = viewcore.database_instance().gemeinsamebuchungen.fuer(
name_self)
ausgabe_maureen = viewcore.database_instance().gemeinsamebuchungen.fuer(
name_partner)
ausgabe_sebastian = _sum(ausgabe_sebastian.Wert)
ausgabe_maureen = _sum(ausgabe_maureen.Wert)
ausgabe_gesamt = ausgabe_maureen + ausgabe_sebastian
dif_sebastian = (ausgabe_gesamt / 2) - ausgabe_sebastian
dif_maureen = (ausgabe_gesamt / 2) - ausgabe_maureen
ergebnis = 'Die gemeinsamen Ausgaben sind ausgeglichen.'
if dif_maureen > 0:
ergebnis = name_partner + ' bekommt von ' + name_self + ' noch ' + str(
'%.2f' % dif_maureen) + '€.'
if dif_sebastian > 0:
ergebnis = name_self + ' bekommt von ' + name_partner + ' noch ' + str(
'%.2f' % dif_sebastian) + '€.'
print("ergebnis:", ergebnis)
context = viewcore.generate_base_context('gemeinsamabrechnen')
context['ausgabe_maureen'] = "%.2f" % abs(ausgabe_maureen)
context['ausgabe_sebastian'] = "%.2f" % abs(ausgabe_sebastian)
context['ausgabe_gesamt'] = "%.2f" % abs(ausgabe_gesamt)
context['ergebnis'] = ergebnis
context['myname'] = name_self
context['partnername'] = name_partner
return context
def _handle_abrechnen_request(_):
print("Abrechnen")
context = viewcore.generate_base_context('gemeinsamabrechnen')
abrechnungs_text = viewcore.database_instance().abrechnen()
context['abrechnungstext'] = abrechnungs_text.replace('\n', '<br>')
viewcore.database_instance().einzelbuchungen.taint()
viewcore.database_instance().gemeinsamebuchungen.taint()
return context
def _handle_request(request):
if post_action_is(request, 'delete'):
print("Delete: ", request.values['delete_index'])
viewcore.database_instance().gemeinsamebuchungen.delete(int(request.values['delete_index']))
ausgaben_liste = []
data = viewcore.database_instance().gemeinsamebuchungen.content.sort_values(by='Datum')
for row_index, row in data.iterrows():
ausgaben_liste.append((row_index, row.Datum, row.Name, row.Kategorie, '%.2f' % row.Wert, row.Person))
context = viewcore.generate_base_context('gemeinsameuebersicht')
context['ausgaben'] = ausgaben_liste
context['transaction_key'] = 'requested'
return context
def _handle_request(request):
dauerauftraege = viewcore.database_instance().dauerauftraege
if post_action_is(request, 'delete'):
print("Delete: ", request.values['delete_index'])
dauerauftraege.delete(int(request.values['delete_index']))
context = viewcore.generate_base_context('dauerauftraguebersicht')
data = collections.OrderedDict()
data['Aktuelle Daueraufträge'] = _format_dauerauftrag_floatpoint(
dauerauftraege.aktuelle())
data['Zukünftige Daueraufträge'] = _format_dauerauftrag_floatpoint(
dauerauftraege.future())
data['Vergangene Daueraufträge'] = _format_dauerauftrag_floatpoint(
dauerauftraege.past())
context['dauerauftraege'] = data
context['transaction_key'] = 'requested'
return context
def _handle_request(request):
einzelbuchungen = viewcore.database_instance().einzelbuchungen
if post_action_is(request, 'delete'):
print("Delete: ", request.values['delete_index'])
einzelbuchungen.delete(int(request.values['delete_index']))
db = einzelbuchungen.get_all()
ausgaben_monatlich = {}
datum_alt = None
ausgaben_liste = []
for row_index, row in db.iterrows():
if datum_alt == None:
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': '%.2f' % row.Wert,
'dynamisch': row.Dynamisch,
'link': link,
'tags': str(row.Tags)
})
if datum_alt != None:
ausgaben_monatlich["" + str(datum_alt.year) + "." +
str(datum_alt.month)] = ausgaben_liste
context = viewcore.generate_base_context('uebersicht')
context['alles'] = ausgaben_monatlich
context['transaction_key'] = 'requested'
return context
def handle_request(request, request_action, html_base_page):
if request.method == 'POST' and 'ID' in request.values:
print('transactional request found')
if request.values['ID'] != current_key():
print('transaction rejected (requested:' + current_key() +
", got:" + request.values['ID'] + ')')
context = viewcore.generate_base_context('Fehler')
rendered_content = request_handler.request_handler.RENDER_FULL_FUNC(
theme('error_race.html'), **{})
context['content'] = rendered_content
return request_handler.RENDER_FULL_FUNC(theme('index.html'),
**context)
print('transaction allowed')
request_handler.DATABASE_VERSION = request_handler.DATABASE_VERSION + 1
print('new db version: ' + str(request_handler.DATABASE_VERSION))
context = request_action(request)
viewcore.save_tainted()
if request.method == 'POST' and 'redirect' in request.values:
return request_handler.REDIRECTOR('/' +
str(request.values['redirect']) +
'/')
if 'transaction_key' in context:
context['ID'] = current_key()
if '%Errortext' in context:
rendered_content = context['%Errortext']
else:
rendered_content = request_handler.RENDER_FULL_FUNC(
theme(html_base_page), **context)
context['content'] = rendered_content
response = request_handler.RENDER_FULL_FUNC(theme('index.html'), **context)
return response
def handle_request(request, import_prefix='', gemeinsam=False):
print(request)
imported_values = pandas.DataFrame([],
columns=('Datum', 'Kategorie', 'Name',
'Wert', ''))
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'])
r = requests.post(serverurl + '/getabrechnung.php',
data={
'email': request.values['email'],
'password': request.values['password']
})
print(r.content)
response = handle_request(PostRequest(
{'import': r.content.decode("utf-8")}),
import_prefix='Internet')
r = requests.post(serverurl + '/deleteitems.php',
data={
'email': request.values['email'],
'password': request.values['password']
})
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)
online_username = requester.instance().post(
serverurl + '/getusername.php',
data={
'email': request.values['email'],
'password': request.values['password']
})
print('online username: '******'/getgemeinsam.php',
data={
'email': request.values['email'],
'password': request.values['password']
})
print(online_content)
table = _parse_table(online_content)
print('table before person mapping', table)
table.Person = table.Person.map(
lambda x: viewcore.database_instance().name
if x == online_username else configuration_provider.
get_configuration('PARTNERNAME'))
online_content = "#######MaschinenimportStart\n"
online_content = online_content + table.to_csv(index=False)
online_content = online_content + "#######MaschinenimportEnd\n"
response = handle_request(PostRequest({'import': online_content}),
import_prefix='Internet_Gemeinsam',
gemeinsam=True)
requester.instance().post(serverurl + '/deletegemeinsam.php',
data={
'email': request.values['email'],
'password':
request.values['password']
})
return response
elif post_action_is(request, 'set_kategorien'):
kategorien = ','.join(
sorted(viewcore.database_instance().einzelbuchungen.
get_kategorien_ausgaben(
hide_ausgeschlossene_kategorien=True)))
serverurl = request.values['server']
serverurl = _add_protokoll_if_needed(serverurl)
_save_server_creds(serverurl, request.values['email'])
serverurl = serverurl + '/setkategorien.php'
requester.instance().post(serverurl,
data={
'email': request.values['email'],
'password':
request.values['password'],
'kategorien': kategorien
})
else:
print(request.values)
content = request.values['import'].replace('\r', '')
FileSystem.instance().write(
'../Import/' + import_prefix + 'Import_' + str(datetime.now()),
content)
imported_values = _parse_table(content)
datenbank_kategorien = set(viewcore.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)
context = viewcore.generate_base_context('import')
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
return 'import.html', context
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)
context = viewcore.generate_base_context('import')
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
return 'import.html', context
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 = viewcore.generate_base_context('import')
context['element_titel'] = 'Kategorien zuweisen'
context['unpassende_kategorien'] = nicht_passende_kategorien
context['optionen'] = options
context['import'] = request.values['import']
context['transaction_id'] = 'requested'
return 'import_mapping.html', context
context = viewcore.generate_base_context('import')
context[
'ONLINE_DEFAULT_SERVER'] = configuration_provider.get_configuration(
'ONLINE_DEFAULT_SERVER')
context['ONLINE_DEFAULT_USER'] = configuration_provider.get_configuration(
'ONLINE_DEFAULT_USER')
return 'import.html', context
def handle_request(request):
if request.method == 'POST' and request.values['action'] == 'add':
value = dezimal_float(request.values['wert'])
if request.values['typ'] == 'Ausgabe':
value = value * -1
if 'edit_index' in request.values:
startdatum = datum(request.values['startdatum'])
endedatum = datum(request.values['endedatum'])
viewcore.database_instance().dauerauftraege.edit(
int(request.values['edit_index']),
startdatum,
endedatum,
request.values['kategorie'],
request.values['name'],
request.values['rhythmus'],
value)
viewcore.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'])
viewcore.database_instance().dauerauftraege.add(
startdatum,
endedatum,
request.values['kategorie'],
request.values['name'],
request.values['rhythmus'],
value)
viewcore.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_base_context('adddauerauftrag')
context['approve_title'] = 'Dauerauftrag hinzufügen'
if post_action_is(request, 'edit'):
db_index = int(request.values['edit_index'])
default_item = viewcore.database_instance().dauerauftraege.get(db_index)
default_item['Startdatum'] = datum_to_string(default_item['Startdatum'])
default_item['Endedatum'] = datum_to_string(default_item['Endedatum'])
if default_item['Wert'] < 0:
default_item['typ'] = 'Ausgabe'
else:
default_item['typ'] = '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': 'Ausgabe',
'Wert': '',
'Name': ''
}
context['transaction_key'] = 'requested'
context['kategorien'] = sorted(viewcore.database_instance().einzelbuchungen.get_alle_kategorien(hide_ausgeschlossene_kategorien=True))
context['letzte_erfassung'] = reversed(viewcore.get_changed_dauerauftraege())
context['rhythmen'] = ['monatlich']
return context
def _handle_request(request):
today = datetime.date.today()
year = today.year
if request.method == 'POST' and 'date' in request.values:
year = int(float(request.values['date']))
einzelbuchungen = viewcore.database_instance().einzelbuchungen
jahresbuchungs_tabelle = einzelbuchungen.select().select_year(year)
jahres_ausgaben = jahresbuchungs_tabelle.select_ausgaben()
jahres_einnahmen = jahresbuchungs_tabelle.select_einnahmen()
jahresausgaben = []
for kategorie, jahresblock in jahres_ausgaben.group_by_kategorie(
).iterrows():
jahresausgaben.append([
kategorie,
'%.2f' % jahresblock.Wert,
einzelbuchungen.get_farbe_fuer(kategorie)
])
jahreseinnahmen = []
for kategorie, jahresblock in jahres_einnahmen.group_by_kategorie(
).iterrows():
jahreseinnahmen.append([
kategorie,
'%.2f' % jahresblock.Wert,
einzelbuchungen.get_farbe_fuer(kategorie)
])
monats_namen = []
num_monate = sorted(
list(
set(jahresbuchungs_tabelle.raw_table().Datum.map(
lambda x: x.month))))
for num_monat in num_monate:
monats_namen.append(get_monats_namen(num_monat))
context = viewcore.generate_base_context('jahresuebersicht')
context['durchschnitt_monat_kategorien'] = str(
list(
einzelbuchungen.durchschnittliche_ausgaben_pro_monat(year).keys()))
context['durchschnittlich_monat_wert'] = str(
list(
einzelbuchungen.durchschnittliche_ausgaben_pro_monat(
year).values()))
context = _computePieChartProzentual(context, year)
laenge = 12
if year == today.year:
laenge = today.month
context['buchungen'] = [{
'kategorie':
'Einnahmen',
'farbe':
'rgb(210, 214, 222)',
'wert':
_filter(
jahres_einnahmen.inject_zeros_for_year(year, laenge).sum_monthly(),
num_monate)
}, {
'kategorie':
'Ausgaben',
'farbe':
'rgba(60,141,188,0.8)',
'wert':
_filter(
jahres_ausgaben.inject_zeros_for_year(year, laenge).sum_monthly(),
num_monate)
}]
context['zusammenfassung_ausgaben'] = jahresausgaben
context['zusammenfassung_einnahmen'] = jahreseinnahmen
context['monats_namen'] = monats_namen
context['selected_date'] = year
context['einnahmen'] = _compile_colors(
jahres_einnahmen.inject_zeroes_for_year_and_kategories(
2017).sum_kategorien_monthly(), einzelbuchungen, num_monate)
context['ausgaben'] = _compile_colors(
jahres_ausgaben.inject_zeroes_for_year_and_kategories(
2017).sum_kategorien_monthly(), einzelbuchungen, num_monate)
context['jahre'] = sorted(einzelbuchungen.get_jahre(), reverse=True)
context['gesamt_ausgaben'] = '%.2f' % einzelbuchungen.select().select_year(
year).select_ausgaben().sum()
context['gesamt_einnahmen'] = '%.2f' % einzelbuchungen.select(
).select_year(year).select_einnahmen().sum()
return context
def handle_request(request):
context = viewcore.generate_base_context('addeinzelbuchung')
context['element_titel'] = 'Neue Ausgabe'
context['approve_title'] = 'Ausgabe hinzufügen'
einzelbuchungen = viewcore.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)
viewcore.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)
viewcore.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'):
print('Please edit:', request.values['edit_index'])
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['transaction_key'] = 'requested'
context['kategorien'] = sorted(
einzelbuchungen.get_kategorien_ausgaben(
hide_ausgeschlossene_kategorien=True))
context['letzte_erfassung'] = reversed(
viewcore.get_changed_einzelbuchungen())
return context
def _handle_request(request):
context = viewcore.generate_base_context('monatsuebersicht')
einzelbuchungen = viewcore.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()
'''
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("#" + einzelbuchungen.get_farbe_fuer(kategorie))
ausgaben_liste.append((kategorie, "%.2f" % row.Wert,
einzelbuchungen.get_farbe_fuer(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("#" +
einzelbuchungen.get_farbe_fuer(kategorie))
einnahmen_liste.append((kategorie, "%.2f" % row.Wert,
einzelbuchungen.get_farbe_fuer(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'] = einzelbuchungen.get_farbe_fuer(
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 _abrechnen(request):
context = viewcore.generate_base_context('monatsuebersicht')
date = viewcore.today()
year = date.year
month = date.month
quantity = 60
if request.method == 'POST':
if 'date' in request.values:
str_year, str_month = request.values['date'].split('_')
year = int(str_year)
month = int(str_month)
if 'quantity' in request.values:
quantity = int(request.values['quantity'])
einzelbuchungen = viewcore.database_instance().einzelbuchungen
generator = ReportGenerator(
'Monatsübersicht für ' + str(month) + '/' + str(year), quantity)
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()
if _is_selected(request, 'zusammenfassung_einnahmen'):
data = {}
for kategorie, row in table_einnahmen.group_by_kategorie().iterrows():
data[kategorie] = row.Wert
generator.add_half_line_elements({'Einnahmen': data})
if _is_selected(request, 'zusammenfassung_ausgaben'):
data = {}
for kategorie, row in table_ausgaben.group_by_kategorie().iterrows():
data[kategorie] = row.Wert
generator.add_half_line_elements({'Ausgaben': data})
if _is_selected(request, 'einnahmen'):
generator.add_halfline('')
generator.add_halfline('')
generator.add_halfline('----Einnahmen----')
zusammenfassung = table_einnahmen.zusammenfassung()
compiled_zusammenfassung = {}
for tag, kategorien_liste in zusammenfassung:
compiled_zusammenfassung[datum_to_string(tag)] = {}
for einheit in kategorien_liste:
compiled_zusammenfassung[datum_to_string(tag)][
einheit['name']] = float(einheit['summe'])
generator.add_half_line_elements(compiled_zusammenfassung)
if _is_selected(request, 'ausgaben'):
generator.add_halfline('')
generator.add_halfline('')
generator.add_halfline('----Ausgaben----')
zusammenfassung = table_ausgaben.zusammenfassung()
compiled_zusammenfassung = {}
for tag, kategorien_liste in zusammenfassung:
compiled_zusammenfassung[datum_to_string(tag)] = {}
for einheit in kategorien_liste:
compiled_zusammenfassung[datum_to_string(tag)][
einheit['name']] = float(einheit['summe'])
generator.add_half_line_elements(compiled_zusammenfassung)
page = ''
for line in generator.generate_pages():
page = page + '<br>' + line
context['abrechnungstext'] = '<pre>' + page + '</pre>'
context['element_titel'] = 'Abrechnung vom {month}/{year}'.format(
month=month, year=year)
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:
viewcore.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'])
viewcore.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:
viewcore.database_instance().gemeinsamebuchungen.add(
ausgaben_datum=date,
kategorie=request.values['kategorie'],
ausgaben_name=request.values['name'],
wert="%.2f" % value,
person=request.values['person'])
viewcore.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_base_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 = viewcore.database_instance(
).gemeinsamebuchungen.content.iloc[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'] = [
viewcore.database_instance().name,
viewcore.name_of_partner()
]
context['kategorien'] = sorted(
viewcore.database_instance().einzelbuchungen.get_kategorien_ausgaben(
hide_ausgeschlossene_kategorien=True))
context['letzte_erfassung'] = reversed(
viewcore.get_changed_gemeinsamebuchungen())
context['transaction_key'] = 'requested'
return context