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