def general_infos():
kontos = persisted_state.database_instance().sparkontos.get_depots()
info = []
for konto in kontos:
latest_depotauszug = persisted_state.database_instance(
).depotauszuege.get_latest_datum_by(konto)
latest_order = get_last_order_for(konto)
warning = False
print('order', latest_order, 'auszug', latest_depotauszug)
if latest_order and latest_depotauszug and latest_depotauszug < latest_order:
warning = True
if not latest_order:
latest_order = ''
else:
latest_order = datum_to_german(latest_order)
if not latest_depotauszug:
latest_depotauszug = 'fehlend'
warning = True
else:
latest_depotauszug = datum_to_german(latest_depotauszug)
info.append({
'konto': konto,
'letzter_auszug': latest_depotauszug,
'letzte_order': latest_order,
'warning': warning
})
return {'kontos': info}
def _format_dauerauftrag_floatpoint(dauerauftraege):
for dauerauftrag in dauerauftraege:
dauerauftrag['Wert'] = '%.2f' % dauerauftrag['Wert']
dauerauftrag['Startdatum'] = datum_to_german(dauerauftrag['Startdatum'])
dauerauftrag['Endedatum'] = datum_to_german(dauerauftrag['Endedatum'])
return dauerauftraege
def get_month_summary(self):
kopierte_tabelle = self.content.copy()[[
'Datum', 'Wert', 'Kategorie', 'Name'
]]
kopierte_tabelle = kopierte_tabelle.sort_values(
by=['Datum', 'Kategorie'])
zusammenfassung = []
kategorie_alt = ''
summe_alt = 0
name_alt = ''
datum_alt = ''
tag_liste = []
more_than_one = False
for _, row in kopierte_tabelle.iterrows():
if (kategorie_alt != row.Kategorie or datum_alt != row.Datum
) and kategorie_alt != '': # next cat or day
if datum_alt != row.Datum:
zusammenfassung.append(
(datum_to_german(datum_alt), tag_liste))
tag_liste = []
tag_liste.append({
'kategorie': kategorie_alt,
'name': name_alt,
'summe': '%.2f' % summe_alt
})
datum_alt = row.Datum
summe_alt = row.Wert
kategorie_alt = row.Kategorie
name_alt = row.Name
more_than_one = False
elif kategorie_alt == '': # initial state
datum_alt = row.Datum
kategorie_alt = row.Kategorie
summe_alt = row.Wert
name_alt = row.Name
else:
if not more_than_one:
name_alt = name_alt + '(' + str(summe_alt) + '€)'
more_than_one = True
name_alt = name_alt + ', ' + row.Name + '(' + str(
row.Wert) + '€)'
summe_alt += row.Wert
tag_liste.append({
'kategorie': kategorie_alt,
'name': name_alt,
'summe': '%.2f' % summe_alt
})
zusammenfassung.append([datum_to_german(datum_alt), tag_liste])
return zusammenfassung
def _write_tabelle(self, writer, tabelle):
writer.write_line(
self._to_left("Datum", 10) + self._to_left(" Kategorie", 14) +
self._to_left("Name", 21) + self._to_right("Wert", 7))
for row in tabelle:
writer.write_line(
datum_to_german(row['Datum']) + " " +
row['Kategorie'].ljust(len("Kategorie "), " ") + " " +
row['Name'].ljust(20, " ") + " " +
str("%.2f" % (row['Wert'])).rjust(7, " "))
def _update_data(isin, context):
try:
data = etf_data.get_data_for(isin)
date = datum_to_german(time.today())
persisted_state.shares_data().save(isin, date, etf_data.SOURCE, data)
return base_html.set_success_message(context, language.SHARES_DATA_UPDATED.format(isin=isin))
except:
traceback.print_exc()
return base_html.set_error_message(
context,
language.SHARES_DATA_NOT_UPDATED.format(isin=isin))
def test_refresh_data():
requester.INSTANCE = RequesterStub(
{'https://api.etf-data.com/product/DE000A14ND46': DEMO_DATA})
result = index(PostRequestAction('update_data', {'isin': 'DE000A14ND46'}))
assert result['message']
assert result['message_type'] == 'success'
assert result['message_content'] == language.SHARES_DATA_UPDATED.format(
isin='DE000A14ND46')
assert persisted_state.shares_data().get_last_changed_date_for(
'DE000A14ND46') == datum_to_german(today())
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 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):
context = viewcore.generate_base_context('gemeinsamabrechnen')
db = database_instance()
alle_gemeinsamen_buchungen = db.gemeinsamebuchungen
if alle_gemeinsamen_buchungen.is_empty():
context['%Errortext'] = 'Keine gemeinsame Buchungen erfasst'
return context
name_self = db.name
name_partner = name_of_partner()
mindate = alle_gemeinsamen_buchungen.min_date()
maxdate = alle_gemeinsamen_buchungen.max_date()
set_mindate = get_post_parameter_or_default(request,
'set_mindate',
mindate,
mapping_function=datum)
set_maxdate = get_post_parameter_or_default(request,
'set_maxdate',
maxdate,
mapping_function=datum)
selector = alle_gemeinsamen_buchungen.select().select_range(
set_mindate, set_maxdate)
replay_value_if_defined(context, 'set_verhaeltnis', request, default=50)
set_verhaeltnis = int(context['set_verhaeltnis'])
replay_value_if_defined(context, 'set_limit', request)
replay_value_if_defined(context, 'set_limit_value', request, default=50)
replay_value_if_defined(context, 'set_limit_fuer', request)
replay_value_if_defined(context, 'set_self_kategorie', request)
replay_value_if_defined(context, 'set_self_kategorie_value', request)
replay_value_if_defined(context, 'set_other_kategorie', request)
replay_value_if_defined(context, 'set_other_kategorie_value', request,
'Korrekturbuchung')
select_self = selector.fuer(name_self)
select_partner = selector.fuer(name_partner)
ausgabe_self = select_self.sum()
ausgabe_partner = select_partner.sum()
ausgabe_gesamt = selector.sum()
ergebnis = ''
if set_verhaeltnis != 50:
ergebnis += '{self_name} übernimmt einen Anteil von {verhaeltnis}% der Ausgaben.<br>'.format(
self_name=name_self, verhaeltnis=set_verhaeltnis)
if is_post_parameter_set(request, 'set_limit'):
ergebnis_satz = '''Durch das Limit bei {name} von {limit_value} EUR wurde das Verhältnis von {verhaeltnis_alt} auf {verhaeltnis_neu} aktualisiert<br>'''
verhaeltnis_alt = set_verhaeltnis
limited_person = request.values['set_limit_fuer']
limit_value = int(request.values['set_limit_value'])
if limited_person == name_partner:
partner_soll = abs(ausgabe_gesamt *
((100 - set_verhaeltnis) / 100))
if partner_soll > limit_value:
set_verhaeltnis = 100 - abs(
(limit_value / ausgabe_gesamt) * 100)
ergebnis += ergebnis_satz.format(
name=name_partner,
limit_value=limit_value,
verhaeltnis_alt=verhaeltnis_alt,
verhaeltnis_neu=set_verhaeltnis)
else:
self_soll = abs(ausgabe_gesamt * (set_verhaeltnis / 100))
if self_soll > limit_value:
set_verhaeltnis = abs((limit_value / ausgabe_gesamt) * 100)
ergebnis += ergebnis_satz.format(
name=name_self,
limit_value=limit_value,
verhaeltnis_alt=verhaeltnis_alt,
verhaeltnis_neu=set_verhaeltnis)
self_soll = (ausgabe_gesamt * (set_verhaeltnis / 100))
self_diff = self_soll - ausgabe_self
partner_soll = (ausgabe_gesamt * ((100 - set_verhaeltnis) / 100))
partner_diff = partner_soll - ausgabe_partner
ergebnis_satz = 'Die gemeinsamen Ausgaben sind ausgeglichen.'
if partner_diff > 0 or self_diff < 0:
ergebnis_satz = name_partner + ' bekommt von ' + name_self + ' noch ' + str(
'%.2f' % partner_diff) + '€.'
if self_diff > 0 or partner_diff < 0:
ergebnis_satz = name_self + ' bekommt von ' + name_partner + ' noch ' + str(
'%.2f' % self_diff) + '€.'
ergebnis += ergebnis_satz
context['str_ergebnis'] = ergebnis.replace('<br>', '\n')
context['ausgabe_partner'] = "%.2f" % abs(ausgabe_partner)
context['ausgabe_self'] = "%.2f" % abs(ausgabe_self)
context['self_diff'] = "%.2f" % self_diff
context['partner_diff'] = "%.2f" % partner_diff
context['self_soll'] = "%.2f" % abs(self_soll)
context['partner_soll'] = "%.2f" % abs(partner_soll)
context['ausgabe_gesamt'] = "%.2f" % abs(ausgabe_gesamt)
context['ergebnis'] = ergebnis
context['myname'] = name_self
context['partnername'] = name_partner
context['mindate'] = datum_to_german(mindate)
context['maxdate'] = datum_to_german(maxdate)
context['count'] = alle_gemeinsamen_buchungen.select().count()
context['set_mindate_rfc'] = datum_to_string(set_mindate)
context['set_maxdate_rfc'] = datum_to_string(set_maxdate)
context['set_mindate'] = datum_to_german(set_mindate)
context['set_maxdate'] = datum_to_german(set_maxdate)
context['set_count'] = selector.count()
context['set_verhaeltnis_real'] = int(set_verhaeltnis)
context['kategorien'] = db.einzelbuchungen.get_alle_kategorien(
hide_ausgeschlossene_kategorien=True)
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):
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 abrechnen(self,
mindate,
maxdate,
set_ergebnis=None,
verhaeltnis=50,
set_self_kategorie=None,
set_other_kategorie=None):
selector = self.gemeinsamebuchungen.select().select_range(
mindate, maxdate)
name_self = persisted_state.database_instance().name
name_partner = viewcore.name_of_partner()
gemeinsame_buchungen_content = selector.content
select_partner = selector.fuer(name_partner)
select_self = selector.fuer(name_self)
summe_partner = select_partner.sum()
summe_self = select_self.sum()
ausgaben_gesamt = selector.sum()
abrechnunsdatei = StringWriter()
zeitraum = datum_to_german(mindate) + '-' + datum_to_german(maxdate)
abrechnunsdatei.write_line('Abrechnung vom ' +
datum_to_german(time.today()) + ' (' +
zeitraum + ')')
self._write_trenner(abrechnunsdatei)
abrechnunsdatei.write_line('Ergebnis:')
abrechnunsdatei.write_line(set_ergebnis)
abrechnunsdatei.write_empty_line()
self._write_large_table_row(abrechnunsdatei,
'Ausgaben von ' + name_partner,
summe_partner)
self._write_large_table_row(abrechnunsdatei,
'Ausgaben von ' + name_self, summe_self)
abrechnunsdatei.write_line("".ljust(38, "-"))
self._write_large_table_row(abrechnunsdatei, "Gesamt", ausgaben_gesamt)
if verhaeltnis == 50:
self.write_into_file(abrechnunsdatei,
selector.faktor(0.5).to_list(),
'Gesamtausgaben pro Person ')
self.write_into_file(abrechnunsdatei, select_partner.to_list(),
'Ausgaben von ' + name_partner)
self.write_into_file(abrechnunsdatei, select_self.to_list(),
'Ausgaben von ' + name_self)
ausgaben_fuer_partner = DataFrame()
faktor_partner = self._faktor_other(verhaeltnis)
ausgaben_fuer_self = DataFrame()
faktor_self = self._faktor_self(verhaeltnis)
summe_halb = selector.faktor(0.5).sum()
if set_self_kategorie:
faktor_self = 0.5
if set_other_kategorie:
faktor_partner = 0.5
for _, row in gemeinsame_buchungen_content.iterrows():
buchung_partner = self._berechne_abbuchung(
row['Datum'], row['Kategorie'], row['Name'],
("%.2f" % (row['Wert'] * faktor_partner)))
buchung_partner.Dynamisch = False
ausgaben_fuer_partner = pd.concat(
[ausgaben_fuer_partner, buchung_partner])
buchung_self = self._berechne_abbuchung(
row['Datum'], row['Kategorie'], row['Name'],
("%.2f" % (row['Wert'] * faktor_self)))
buchung_self.Dynamisch = False
ausgaben_fuer_self = pd.concat([ausgaben_fuer_self, buchung_self])
if set_self_kategorie:
extra_wert = (ausgaben_gesamt *
self._faktor_self(verhaeltnis)) - summe_halb
extra_ausgleichs_buchung = self._berechne_abbuchung(
maxdate, set_self_kategorie, set_self_kategorie,
("%.2f" % extra_wert))
extra_ausgleichs_buchung.Dynamisch = False
ausgaben_fuer_self = pd.concat(
[ausgaben_fuer_self, extra_ausgleichs_buchung])
if set_other_kategorie:
extra_wert = (ausgaben_gesamt *
self._faktor_other(verhaeltnis)) - summe_halb
extra_ausgleichs_buchung = self._berechne_abbuchung(
maxdate, set_other_kategorie, set_other_kategorie,
("%.2f" % extra_wert))
extra_ausgleichs_buchung.Dynamisch = False
ausgaben_fuer_partner = pd.concat(
[ausgaben_fuer_partner, extra_ausgleichs_buchung])
report = TextReportWriter().generate_report(
ausgaben_fuer_partner, abrechnunsdatei.to_string())
self.einzelbuchungen.append_row(ausgaben_fuer_self)
self.einzelbuchungen.taint()
self.gemeinsamebuchungen.drop(
gemeinsame_buchungen_content.index.tolist())
self.taint()
write_abrechnung("Abrechnung_" + str(time.now()), report)
return report
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
