def test_change_partnername_should_change_partnername(self):
self.set_up()
assert viewcore.name_of_partner() == 'kein_Partnername_gesetzt'
configuration.index(
PostRequest({
'action': 'set_partnername',
'partnername': 'testpartner'
}))
assert viewcore.name_of_partner() == 'testpartner'
def test_result_withLimitSelfAndValueOverLimit_shouldModifyVerhaeltnis(
self):
self.set_up()
name_partner = viewcore.name_of_partner()
self_name = persisted_state.database_instance().name
gemeinsame_buchungen = persisted_state.database_instance(
).gemeinsamebuchungen
gemeinsame_buchungen.add(self.some_datum(), self.some_name(),
self.some_kategorie(), -50, self_name)
gemeinsame_buchungen.add(self.some_datum(), self.some_name(),
self.some_kategorie(), -50, name_partner)
result = gemeinsam_abrechnen.index(
PostRequest({
'set_verhaeltnis': 50,
'set_limit': 'on',
'set_limit_fuer': self_name,
'set_limit_value': 40
}))
assert result[
'ergebnis'] == 'Durch das Limit bei Test_User von 40 EUR wurde das Verhältnis von 50 auf 40.0 aktualisiert<br>Test_User bekommt von Partner noch 10.00€.'
assert result['self_soll'] == '40.00'
assert result['partner_soll'] == '60.00'
assert result['self_diff'] == '10.00'
assert result['partner_diff'] == '-10.00'
def test_personenOption_shouldContainNames(self):
self.set_up()
result = addgemeinsam.index(GetRequest())
assert persisted_state.database_instance().name in result['personen']
assert viewcore.name_of_partner() in result['personen']
assert len(result['personen']) == 2
def test_result_withLimitSelfAndValueUnderLimit_shouldReturnDefaultVerhaeltnis(
self):
self.set_up()
name_partner = viewcore.name_of_partner()
self_name = persisted_state.database_instance().name
gemeinsame_buchungen = persisted_state.database_instance(
).gemeinsamebuchungen
gemeinsame_buchungen.add(self.some_datum(), self.some_name(),
self.some_kategorie(), -50, self_name)
gemeinsame_buchungen.add(self.some_datum(), self.some_name(),
self.some_kategorie(), -50, name_partner)
result = gemeinsam_abrechnen.index(
PostRequest({
'set_verhaeltnis': 50,
'set_limit': 'on',
'set_limit_fuer': self_name,
'set_limit_value': 100
}))
assert result[
'ergebnis'] == 'Die gemeinsamen Ausgaben sind ausgeglichen.'
assert result['self_soll'] == '50.00'
assert result['partner_soll'] == '50.00'
assert result['self_diff'] == '0.00'
assert result['partner_diff'] == '0.00'
def test_shortResult_withPartnerMoreSpendings_shouldReturnEqualSentence(
self):
self.set_up()
gemeinsame_buchungen = persisted_state.database_instance(
).gemeinsamebuchungen
name_partner = viewcore.name_of_partner()
gemeinsame_buchungen.add(datum('01.01.2010'), self.some_name(),
self.some_kategorie(), -11, name_partner)
result = gemeinsam_abrechnen.index(GetRequest())
assert result[
'ergebnis'] == 'Partner bekommt von Test_User noch 5.50€.'
def test_abrechnen_with_date_range_should_only_import_matching_elements(self):
self.set_up()
db = persisted_state.database_instance()
db.gemeinsamebuchungen.add(datum('17.03.2010'), 'to early', 'to early', 99, viewcore.name_of_partner())
db.gemeinsamebuchungen.add(datum('17.03.2017'), 'some kategorie', 'some name', 10, viewcore.name_of_partner())
db.gemeinsamebuchungen.add(datum('17.03.2020'), 'to late', 'to late', 99, viewcore.name_of_partner())
db.abrechnen(mindate=datum('01.01.2017'), maxdate=datum('01.12.2017'))
assert len(db.einzelbuchungen.content) == 1
uebertragene_buchung = db.einzelbuchungen.get(0)
assert uebertragene_buchung['Name'] == 'some name'
assert uebertragene_buchung['Datum'] == datum('17.03.2017')
assert uebertragene_buchung['Kategorie'] == 'some kategorie'
assert uebertragene_buchung['Wert'] == '5.00'
assert len(db.gemeinsamebuchungen.select().to_list()) == 2
uebertragene_buchung = db.gemeinsamebuchungen.select().to_list()[0]
assert uebertragene_buchung['Name'] == 'to early'
uebertragene_buchung = db.gemeinsamebuchungen.select().to_list()[1]
assert uebertragene_buchung['Name'] == 'to late'
def test_shortResult_withEqualValue_shouldReturnEqualSentence(self):
self.set_up()
name_partner = viewcore.name_of_partner()
self_name = persisted_state.database_instance().name
gemeinsame_buchungen = persisted_state.database_instance(
).gemeinsamebuchungen
gemeinsame_buchungen.add(datum('01.01.2010'), self.some_name(),
self.some_kategorie(), -11, self_name)
gemeinsame_buchungen.add(datum('01.01.2010'), self.some_name(),
self.some_kategorie(), -11, name_partner)
result = gemeinsam_abrechnen.index(GetRequest())
assert result[
'ergebnis'] == 'Die gemeinsamen Ausgaben sind ausgeglichen.'
def test_change_partnername_should_mirgrate_old_partnernames(self):
self.set_up()
name_of_partner = viewcore.name_of_partner()
gemeinsame_buchungen = 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 = database_instance().gemeinsamebuchungen
database_partners = gemeinsame_buchungen.content.Person
assert set(database_partners) == set(['testpartner_renamed'])
def test_result_withSelektiertemVerhaeltnis(self):
self.set_up()
name_partner = viewcore.name_of_partner()
self_name = persisted_state.database_instance().name
gemeinsame_buchungen = persisted_state.database_instance(
).gemeinsamebuchungen
gemeinsame_buchungen.add(self.some_datum(), self.some_name(),
self.some_kategorie(), -50, self_name)
gemeinsame_buchungen.add(self.some_datum(), self.some_name(),
self.some_kategorie(), -50, name_partner)
result = gemeinsam_abrechnen.index(PostRequest({'set_verhaeltnis':
60}))
assert result[
'ergebnis'] == 'Test_User übernimmt einen Anteil von 60% der Ausgaben.<br>Partner bekommt von Test_User noch 10.00€.'
assert result['self_soll'] == '60.00'
assert result['partner_soll'] == '40.00'
assert result['self_diff'] == '-10.00'
assert result['partner_diff'] == '10.00'
def test_shortResult_withSelectedDate_shouldFilterEntries(self):
self.set_up()
name_partner = viewcore.name_of_partner()
self_name = persisted_state.database_instance().name
gemeinsame_buchungen = persisted_state.database_instance(
).gemeinsamebuchungen
gemeinsame_buchungen.add(self.some_datum(), self.some_name(),
self.some_kategorie(), -1000, self_name)
gemeinsame_buchungen.add(datum('15.01.2011'), self.some_name(),
self.some_kategorie(), -20, name_partner)
gemeinsame_buchungen.add(datum('15.01.2012'), self.some_name(),
self.some_kategorie(), -1000, name_partner)
result = gemeinsam_abrechnen.index(
PostRequest({
'set_mindate': '2011-01-01',
'set_maxdate': '2011-02-01'
}))
assert result[
'ergebnis'] == 'Partner bekommt von Test_User noch 10.00€.'
assert result['count'] == 3
assert result['set_count'] == 1
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 test_abrechnen_should_add_einzelbuchungen(self):
self.set_up()
db = persisted_state.database_instance()
db.gemeinsamebuchungen.add(datum('17.03.2017'), 'some kategorie', 'some name', 10, viewcore.name_of_partner())
db.abrechnen(mindate=datum('17.03.2017'), maxdate=datum('17.03.2017'))
assert len(db.einzelbuchungen.content) == 1
uebertragene_buchung = db.einzelbuchungen.get(0)
assert uebertragene_buchung['Name'] == 'some name'
assert uebertragene_buchung['Datum'] == datum('17.03.2017')
assert uebertragene_buchung['Kategorie'] == 'some kategorie'
assert uebertragene_buchung['Wert'] == '5.00'
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 test_abrechnen_should_print_file_content(self):
self.set_up()
db = persisted_state.database_instance()
db.gemeinsamebuchungen.add(datum('17.03.2017'), 'some kategorie', 'some name', -10, viewcore.name_of_partner())
time.stub_today_with(datum('01.01.2010'))
abrechnungs_text = db.abrechnen(
mindate=datum('17.03.2017'),
maxdate=datum('17.03.2017'),
set_ergebnis="%Ergebnis%")
time.reset_viewcore_stubs()
assert abrechnungs_text == self.abrechnung
def test_abrechnen_with_other_kategorie_set_should_add_other_kategorie(self):
self.set_up()
db = persisted_state.database_instance()
time.stub_today_with(datum('01.01.2010'))
db.gemeinsamebuchungen.add(datum('17.03.2017'), 'some kategorie', 'some name', -100, viewcore.name_of_partner())
abrechnungs_text = db.abrechnen(
mindate=datum('17.03.2017'),
maxdate=datum('17.03.2017'),
set_ergebnis='%Ergebnis%',
verhaeltnis=70,
set_other_kategorie='Ausgleich')
assert len(db.einzelbuchungen.content) == 1
uebertragene_buchung = db.einzelbuchungen.get(0)
assert uebertragene_buchung['Name'] == 'some name'
assert uebertragene_buchung['Datum'] == datum('17.03.2017')
assert uebertragene_buchung['Kategorie'] == 'some kategorie'
assert uebertragene_buchung['Wert'] == '-70.00'
assert abrechnungs_text == self.abrechnung_verhaeltnis_other
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):
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