コード例 #1
0
def _handle_request(_):
    name_self = viewcore.database_instance().name
    name_partner = viewcore.name_of_partner()

    ausgabe_sebastian = viewcore.database_instance().gemeinsamebuchungen.fuer(
        name_self)
    ausgabe_maureen = viewcore.database_instance().gemeinsamebuchungen.fuer(
        name_partner)
    ausgabe_sebastian = _sum(ausgabe_sebastian.Wert)
    ausgabe_maureen = _sum(ausgabe_maureen.Wert)
    ausgabe_gesamt = ausgabe_maureen + ausgabe_sebastian

    dif_sebastian = (ausgabe_gesamt / 2) - ausgabe_sebastian
    dif_maureen = (ausgabe_gesamt / 2) - ausgabe_maureen

    ergebnis = 'Die gemeinsamen Ausgaben sind ausgeglichen.'

    if dif_maureen > 0:
        ergebnis = name_partner + ' bekommt von ' + name_self + ' noch ' + str(
            '%.2f' % dif_maureen) + '€.'

    if dif_sebastian > 0:
        ergebnis = name_self + ' bekommt von ' + name_partner + ' noch ' + str(
            '%.2f' % dif_sebastian) + '€.'
    print("ergebnis:", ergebnis)

    context = viewcore.generate_base_context('gemeinsamabrechnen')

    context['ausgabe_maureen'] = "%.2f" % abs(ausgabe_maureen)
    context['ausgabe_sebastian'] = "%.2f" % abs(ausgabe_sebastian)
    context['ausgabe_gesamt'] = "%.2f" % abs(ausgabe_gesamt)
    context['ergebnis'] = ergebnis
    context['myname'] = name_self
    context['partnername'] = name_partner
    return context
コード例 #2
0
def _computePieChartProzentual(context, jahr):
    result = viewcore.database_instance(
    ).einzelbuchungen.get_jahresausgaben_nach_kategorie_prozentual(jahr)
    ausgaben_data = []
    ausgaben_labels = []
    ausgaben_colors = []
    for kategorie, wert in result.items():
        ausgaben_data.append('%.2f' % abs(wert))
        ausgaben_labels.append(kategorie)
        ausgaben_colors.append('#' + viewcore.database_instance().
                               einzelbuchungen.get_farbe_fuer(kategorie))

    context['pie_ausgaben_data_prozentual'] = ausgaben_data
    context['pie_ausgaben_labels'] = ausgaben_labels
    context['pie_ausgaben_colors'] = ausgaben_colors

    result = viewcore.database_instance(
    ).einzelbuchungen.get_jahreseinnahmen_nach_kategorie_prozentual(jahr)
    einnahmen_data = []
    einnahmen_labels = []
    einnahmen_colors = []
    for kategorie, wert in result.items():
        einnahmen_data.append('%.2f' % abs(wert))
        einnahmen_labels.append(kategorie)
        einnahmen_colors.append('#' + viewcore.database_instance().
                                einzelbuchungen.get_farbe_fuer(kategorie))

    context['pie_einnahmen_data_prozentual'] = einnahmen_data
    context['pie_einnahmen_labels'] = einnahmen_labels
    context['pie_einnahmen_colors'] = einnahmen_colors

    return context
コード例 #3
0
    def test_gemeinsamImport_withUnpassendenUsername_shouldImportValueAndRepalceName(
            self):
        self.set_up()
        einzelbuchungen = viewcore.database_instance().einzelbuchungen
        einzelbuchungen.add(datum('01.01.2017'), 'Essen', 'some name', -1.54)

        requester.INSTANCE = RequesterStub({
            'https://test.test/getgemeinsam.php':
            self._IMPORT_DATA_GEMEINSAM_WRONG_SELF,
            'https://test.test/deletegemeinsam.php':
            '',
            'https://test.test/getusername.php':
            'Sebastian_Online'
        })

        context = import_data.index(
            PostRequest({
                'action': 'load_online_gemeinsame_transactions',
                'email': '',
                'server': 'test.test',
                'password': ''
            }))

        assert context['element_titel'] == 'Export / Import'
        assert len(
            viewcore.database_instance().gemeinsamebuchungen.content) == 2
        assert viewcore.database_instance(
        ).gemeinsamebuchungen.content.Person[0] == 'Sebastian'
        assert viewcore.database_instance(
        ).gemeinsamebuchungen.content.Person[1] == 'Maureen'

        assert requester.instance().call_count_of(
            'https://test.test/deletegemeinsam.php') == 1
        assert requester.instance().complete_call_count() == 3
コード例 #4
0
 def test_shortResult_withSelfMoreSpendings_shouldReturnEqualSentence(self):
     self.set_up()
     gemeinsame_buchungen = viewcore.database_instance().gemeinsamebuchungen
     name_self = viewcore.database_instance().name
     gemeinsame_buchungen.add(datum('01.01.2010'), 'Some Cat.', 'Some Name',
                              -11, name_self)
     result = gemeinsam_abrechnen.index(GetRequest())
     assert result[
         'ergebnis'] == 'Test_User bekommt von Maureen noch 5.50€.'
コード例 #5
0
def _handle_abrechnen_request(_):
    print("Abrechnen")
    context = viewcore.generate_base_context('gemeinsamabrechnen')
    abrechnungs_text = viewcore.database_instance().abrechnen()
    context['abrechnungstext'] = abrechnungs_text.replace('\n', '<br>')
    viewcore.database_instance().einzelbuchungen.taint()
    viewcore.database_instance().gemeinsamebuchungen.taint()

    return context
コード例 #6
0
 def test_editCallFromUeberischt_shouldNameButtonEdit(self):
     self.set_up()
     database_instance().einzelbuchungen.add(datum('10.10.2010'),
                                             'kategorie', 'name', 10.00)
     context = addausgabe.handle_request(
         PostRequest({
             'action': 'edit',
             'edit_index': '0'
         }))
     assert context['approve_title'] == 'Ausgabe aktualisieren'
コード例 #7
0
    def test_gemeinsam_addePassendeKategorie_shouldImportValue(self):
        self.set_up()
        einzelbuchungen = viewcore.database_instance().einzelbuchungen
        einzelbuchungen.add(datum('01.01.2017'), 'Essen', 'some name', -1.54)

        html, context = import_data.handle_request(PostRequest(
            {'import': self._IMPORT_DATA_GEMEINSAM}),
                                                   gemeinsam=True)
        assert context['element_titel'] == 'Export / Import'
        assert len(
            viewcore.database_instance().gemeinsamebuchungen.content) == 2
コード例 #8
0
def _handle_request(request):
    if post_action_is(request, 'delete'):
        print("Delete: ", request.values['delete_index'])
        viewcore.database_instance().gemeinsamebuchungen.delete(int(request.values['delete_index']))

    ausgaben_liste = []
    data = viewcore.database_instance().gemeinsamebuchungen.content.sort_values(by='Datum')
    for row_index, row in data.iterrows():
        ausgaben_liste.append((row_index, row.Datum, row.Name, row.Kategorie, '%.2f' % row.Wert, row.Person))

    context = viewcore.generate_base_context('gemeinsameuebersicht')
    context['ausgaben'] = ausgaben_liste
    context['transaction_key'] = 'requested'
    return context
コード例 #9
0
    def test_change_db_should_trigger_db_reload(self):
        self.set_up()
        configuration.index(
            PostRequest({
                'action': 'edit_databases',
                'dbs': 'test'
            }))
        assert viewcore.database_instance().name == 'test'

        configuration.index(
            PostRequest({
                'action': 'edit_databases',
                'dbs': 'test2'
            }))
        assert viewcore.database_instance().name == 'test2'
コード例 #10
0
 def test_add_should_only_fire_once(self):
     self.set_up()
     next_id = request_handler.current_key()
     addgemeinsam.index(
         PostRequest({
             'action': 'add',
             'ID': next_id,
             'date': rfc('1.1.2017'),
             'kategorie': 'Essen',
             'name': 'testname',
             'person': 'testperson',
             'wert': '2,00'
         }))
     addgemeinsam.index(
         PostRequest({
             'action': 'add',
             'ID': next_id,
             'date': rfc('1.1.2017'),
             'kategorie': 'overwritten',
             'name': 'overwritten',
             'person': 'overwritten',
             'wert': '0,00'
         }))
     testdb = viewcore.database_instance()
     assert testdb.gemeinsamebuchungen.content.Wert[0] == -1 * float('2.00')
     assert testdb.gemeinsamebuchungen.content.Name[0] == 'testname'
     assert testdb.gemeinsamebuchungen.content.Kategorie[0] == 'Essen'
     assert testdb.gemeinsamebuchungen.content.Datum[0] == datum('1.1.2017')
     assert testdb.gemeinsamebuchungen.content.Person[0] == 'testperson'
コード例 #11
0
    def teste_contextValues_withMutlibleEinnahmeAndAusgabe(self):
        self.set_up()
        db = viewcore.database_instance()
        db.einzelbuchungen.add(datum('10.10.2010'), 'some kategorie',
                               'some name', -100)
        db.einzelbuchungen.add(datum('10.10.2010'), 'eine einnahme kategorie',
                               'some name', 10)
        db.einzelbuchungen.add(datum('10.10.2010'), 'some kategorie',
                               'some name', -100)
        db.einzelbuchungen.add(datum('10.10.2010'), 'eine einnahme kategorie',
                               'some name', 10)
        db.einzelbuchungen.add(datum('10.10.2010'), 'some kategorie2',
                               'some name', -100)
        db.einzelbuchungen.add(datum('10.10.2010'), 'eine einnahme kategorie2',
                               'some name', 10)

        result_context = uebersicht_jahr.index(
            PostRequest({
                'date': '2010',
                'mode': ''
            }))

        assert result_context['zusammenfassung_ausgaben'] == [[
            'some kategorie', '-200.00', '00a65a'
        ], ['some kategorie2', '-100.00', '00c0ef']]
        assert result_context['zusammenfassung_einnahmen'] == [[
            'eine einnahme kategorie', '20.00', '3c8dbc'
        ], ['eine einnahme kategorie2', '10.00', 'f56954']]
        assert result_context['buchungen'][0]['wert'] == ['30.00']
        assert result_context['buchungen'][1]['wert'] == ['300.00']
コード例 #12
0
    def teste_mitMehrAusgabenAlsEinnahmen(self):
        self.set_up()
        db = viewcore.database_instance()
        db.einzelbuchungen.add(datum('10.10.2010'), 'some kategorie',
                               'some name', -100)
        db.einzelbuchungen.add(datum('10.10.2010'), 'eine einnahme kategorie',
                               'some name', 10)

        result_context = uebersicht_monat.index(
            PostRequest({'date': '2010_10'}))

        assert result_context['gesamt'] == '-100.00'
        assert result_context['gesamt_einnahmen'] == '10.00'

        assert result_context['einnahmen'] == [('eine einnahme kategorie',
                                                '10.00', '3c8dbc')]
        assert result_context['einnahmen_labels'] == [
            'eine einnahme kategorie'
        ]
        assert result_context['einnahmen_data'] == ['10.00']

        assert result_context['ausgaben'] == [('some kategorie', '-100.00',
                                               'f56954')]
        assert result_context['ausgaben_labels'] == ['some kategorie']
        assert result_context['ausgaben_data'] == ['100.00']
コード例 #13
0
    def test_isTainted_shouldReturnFalseWhenTainted(self):
        self.set_up()
        db = viewcore.database_instance()

        assert not db.is_tainted()
        db.taint()
        assert db.is_tainted()
コード例 #14
0
    def test_tainNumber_shouldIncludeDauerauftraege(self):
        self.set_up()
        db = viewcore.database_instance()

        assert db.taint_number() == 0
        db.dauerauftraege.taint()
        assert db.taint_number() == 1
コード例 #15
0
    def test_add_ausgabe_should_only_fire_once(self):
        self.set_up()
        request_key = request_handler.current_key()

        addausgabe.index(
            PostRequest({
                'action': 'add',
                'ID': request_key,
                'date': rfc('1.1.2017'),
                'kategorie': 'Essen',
                'name': 'testname',
                'wert': '2,00'
            }))

        addausgabe.index(
            PostRequest({
                'action': 'add',
                'ID': request_key,
                'date': rfc('1.1.2017'),
                'kategorie': 'overwritten',
                'name': 'overwritten',
                'wert': '0,00'
            }))

        testdb = database_instance()
        assert len(testdb.einzelbuchungen.content) == 1
        assert testdb.einzelbuchungen.content.Wert[0] == -1 * float('2.00')
        assert testdb.einzelbuchungen.content.Name[0] == 'testname'
        assert testdb.einzelbuchungen.content.Kategorie[0] == 'Essen'
        assert testdb.einzelbuchungen.content.Datum[0] == datum('1.1.2017')
コード例 #16
0
    def test_edit_ausgabe(self):
        self.set_up()

        addausgabe.handle_request(
            VersionedPostRequest({
                'action': 'add',
                'date': rfc('1.1.2017'),
                'kategorie': 'Essen',
                'name': 'testname',
                'wert': '2,00'
            }))

        addausgabe.handle_request(
            VersionedPostRequest({
                'action': 'add',
                'edit_index': '0',
                'date': rfc('5.1.2017'),
                'kategorie': 'Essen',
                'name': 'testname',
                'wert': '2,50'
            }))
        testdb = database_instance()
        assert len(testdb.einzelbuchungen.content) == 1
        assert testdb.einzelbuchungen.content.Wert[0] == -1 * float('2.50')
        assert testdb.einzelbuchungen.content.Name[0] == 'testname'
        assert testdb.einzelbuchungen.content.Kategorie[0] == 'Essen'
        assert testdb.einzelbuchungen.content.Datum[0] == datum('5.1.2017')
コード例 #17
0
    def test_change_partnername_should_mirgrate_old_partnernames(self):
        self.set_up()
        name_of_partner = viewcore.name_of_partner()
        gemeinsame_buchungen = viewcore.database_instance().gemeinsamebuchungen
        gemeinsame_buchungen.add(datum('01.01.2017'), 'kat', 'name', 1,
                                 name_of_partner)

        configuration.index(
            PostRequest({
                'action': 'set_partnername',
                'partnername': 'testpartner_renamed'
            }))
        gemeinsame_buchungen = viewcore.database_instance().gemeinsamebuchungen
        database_partners = gemeinsame_buchungen.content.Person

        assert set(database_partners) == set(['testpartner_renamed'])
コード例 #18
0
def _handle_request(_):
    einzelbuchungen = viewcore.database_instance().einzelbuchungen
    selector = einzelbuchungen.select()
    ausgaben_liste = []
    for row_index, row in selector.select_aktueller_monat().raw_table(
    ).iterrows():
        ausgaben_liste.append({
            'index': row_index,
            'datum': datum_to_german(row.Datum),
            'name': row.Name,
            'kategorie': row.Kategorie,
            'wert': '%.2f' % row.Wert
        })

    context = {
        'zusammenfassung_monatsliste':
        _monatsliste(),
        'zusammenfassung_einnahmenliste':
        _list_to_json(
            selector.select_einnahmen().inject_zeros_for_last_6_months(
            ).select_letzte_6_montate().sum_monthly()),
        'zusammenfassung_ausgabenliste':
        _list_to_json(
            selector.select_ausgaben().inject_zeros_for_last_6_months(
            ).select_letzte_6_montate().sum_monthly()),
        'ausgaben_des_aktuellen_monats':
        ausgaben_liste,
    }
    context = {**context, **viewcore.generate_base_context('dashboard')}
    return context
コード例 #19
0
    def test_edit_ausgabe(self):
        self.set_up()

        addgemeinsam.index(
            VersionedPostRequest({
                'action': 'add',
                'date': rfc('1.1.2017'),
                'kategorie': 'Essen',
                'name': 'testname',
                'person': 'testperson',
                'wert': '2,00'
            }))

        addgemeinsam.index(
            PostRequest({
                'action': 'add',
                'ID': request_handler.current_key(),
                'edit_index': '0',
                'date': rfc('5.1.2017'),
                'kategorie': 'Essen',
                'name': 'testname',
                'person': 'testperson2',
                'wert': '2,50'
            }))

        testdb = viewcore.database_instance()
        assert testdb.gemeinsamebuchungen.content.Wert[0] == -1 * float('2.50')
        assert testdb.gemeinsamebuchungen.content.Name[0] == 'testname'
        assert testdb.gemeinsamebuchungen.content.Kategorie[0] == 'Essen'
        assert testdb.gemeinsamebuchungen.content.Datum[0] == datum('5.1.2017')
        assert testdb.gemeinsamebuchungen.content.Person[0] == 'testperson2'
コード例 #20
0
    def test_tainNumber_shouldIncludeEinzelbuchungen(self):
        self.set_up()
        db = viewcore.database_instance()

        assert db.taint_number() == 0
        db.einzelbuchungen.taint()
        assert db.taint_number() == 1
コード例 #21
0
    def test_personenOption_shouldContainNames(self):
        self.set_up()
        result = addgemeinsam.index(GetRequest())

        assert viewcore.database_instance().name in result['personen']
        assert viewcore.name_of_partner() in result['personen']
        assert len(result['personen']) == 2
コード例 #22
0
    def test_taint_shouldIncreaseTaintNumber(self):
        self.set_up()
        db = viewcore.database_instance()

        assert db.taint_number() == 0
        db.taint()
        assert db.taint_number() == 1
コード例 #23
0
def _import(import_data, gemeinsam):
    print('importing data:')
    print(import_data)
    if gemeinsam:
        viewcore.database_instance().gemeinsamebuchungen.parse(import_data)
        viewcore.database_instance().gemeinsamebuchungen.taint()
    else:
        viewcore.database_instance().einzelbuchungen.parse(import_data)
        viewcore.database_instance().einzelbuchungen.taint()
コード例 #24
0
    def test_addePassendeKategorie_shouldImportValue(self):
        self.set_up()
        einzelbuchungen = viewcore.database_instance().einzelbuchungen
        einzelbuchungen.add(datum('01.01.2017'), 'Essen', 'some name', -1.54)

        context = import_data.index(PostRequest({'import': self._IMPORT_DATA}))
        assert context['element_titel'] == 'Export / Import'
        assert einzelbuchungen.select().select_year(2017).sum() == -11.54
コード例 #25
0
    def test_deTaint_shouldDeTaintEinzelbuchungen(self):
        self.set_up()
        db = viewcore.database_instance()

        db.einzelbuchungen.taint()
        assert db.is_tainted()
        db.de_taint()
        assert not db.is_tainted()
コード例 #26
0
 def set_up(self):
     FileSystem.INSTANCE = FileSystemStub()
     configuration_provider.LOADED_CONFIG = None
     viewcore.DATABASE_INSTANCE = None
     viewcore.DATABASES = []
     print(viewcore.database_instance().name)
     configuration_provider.set_configuration('PARTNERNAME', 'Maureen')
     request_handler.stub_me()
コード例 #27
0
    def test_deTaint_shouldDeTaintDauerauftraege(self):
        self.set_up()
        db = viewcore.database_instance()

        db.dauerauftraege.taint()
        assert db.is_tainted()
        db.de_taint()
        assert not db.is_tainted()
コード例 #28
0
    def test_addeUnpassendenKategorie_shouldShowImportMappingPage(self):
        self.set_up()
        einzelbuchungen = viewcore.database_instance().einzelbuchungen
        einzelbuchungen.add(datum('01.01.2017'), 'unbekannt', 'some name',
                            -1.54)

        context = import_data.index(PostRequest({'import': self._IMPORT_DATA}))
        assert context['element_titel'] == 'Kategorien zuweisen'
コード例 #29
0
    def teste_datumsdarstellung_einzelbuchungsliste(self):
        self.set_up()
        db = viewcore.database_instance()
        db.einzelbuchungen.add(datum('10.10.2011'), 'eine einnahme kategorie',
                               'some name', 10)

        result_context = uebersicht_monat.index(GetRequest())

        assert result_context['zusammenfassung'][0][0] == '10.10.2011'
コード例 #30
0
    def test_abrechnen(self):
        self.set_up()
        testdb = viewcore.database_instance()
        testdb.gemeinsamebuchungen.add(datum('01.01.2010'), 'Eine Katgorie',
                                       'Ein Name', 2.60, 'Eine Person')
        gemeinsam_abrechnen.abrechnen(PostRequest({}))

        assert testdb.einzelbuchungen.anzahl() == 1
        assert testdb.einzelbuchungen.get_all().Wert[0] == '1.30'