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