def write(database):
einzelbuchungen = database.einzelbuchungen.content.copy()[database.einzelbuchungen.content.Dynamisch == False]
einzelbuchungen_raw_data = einzelbuchungen[['Datum', 'Kategorie', 'Name', 'Wert', 'Tags']]
content = einzelbuchungen_raw_data.to_csv(index=False)
content += "\n Dauerauftraege \n"
content += database.dauerauftraege.content.to_csv(index=False)
content += "\n Gemeinsame Buchungen \n"
content += database.gemeinsamebuchungen.content.to_csv(index=False)
FileSystem.instance().write('../Database_' + database.name + '.csv', content)
print("WRITER: All Saved")
def test_import_shouldWriteIntoAbrechnungen(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}))
written_abrechnung = None
for key in FileSystem.instance()._fs_stub.keys():
if key.startswith('../Import'):
written_abrechnung = FileSystem.instance()._fs_stub[key]
assert written_abrechnung == self._IMPORT_DATA
def teste_write_with_old_database_should_migrate(self):
self.mock_filesystem()
self.write_db_file_stub('testuser', self.full_db_old)
database = DBManager.read('testuser', set())
DBManager.write(database)
assert FileSystem.instance().read('../Database_testuser.csv') == self.full_db.split('\n')
def read(nutzername, ausgeschlossene_kategorien):
if not FileSystem.instance().read('../Database_' + nutzername + '.csv'):
neue_datenbank = DatabaseModule.Database(nutzername)
write(neue_datenbank)
file_content = FileSystem.instance().read('../Database_' + nutzername + '.csv')
tables = {}
tables["einzelbuchungen"] = ""
tables["dauerauftraege"] = ""
tables["gemeinsamebuchungen"] = ""
mode = "einzelbuchungen"
for line in file_content:
line = line.strip()
if line == "":
continue
if line == 'Dauerauftraege':
mode = 'dauerauftraege'
continue
if line == 'Gemeinsame Buchungen':
mode = 'gemeinsamebuchungen'
continue
if not ',' in line:
break
tables[mode] = tables[mode] + "\n" + line
database = DatabaseModule.Database(nutzername, ausgeschlossene_kategorien=ausgeschlossene_kategorien)
raw_data = pd.read_csv(StringIO(tables["einzelbuchungen"]))
database.einzelbuchungen.parse(raw_data)
print("READER: Einzelbuchungen gelesen")
database.dauerauftraege.parse(pd.read_csv(StringIO(tables["dauerauftraege"])))
print("READER: Daueraufträge gelesen")
database.gemeinsamebuchungen.parse(pd.read_csv(StringIO(tables["gemeinsamebuchungen"])))
print('READER: Refreshe Database')
database.refresh()
print('READER: Refresh done')
return database
def _load_config():
lines = FileSystem.instance().read('../config')
if not lines:
return dict(configuration_provider.DEFAULT_CONFIG)
loaded_config = {}
for line in lines:
if ':' in line:
line = line.strip()
loaded_config[line.split(':', 1)[0]] = line.split(':', 1)[1]
for key in dict(configuration_provider.DEFAULT_CONFIG):
if key not in loaded_config:
loaded_config[key] = configuration_provider.DEFAULT_CONFIG[key]
print("#####", loaded_config)
return loaded_config
def handle_request(request, import_prefix='', gemeinsam=False):
print(request)
imported_values = pandas.DataFrame([],
columns=('Datum', 'Kategorie', 'Name',
'Wert', ''))
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'])
r = requests.post(serverurl + '/getabrechnung.php',
data={
'email': request.values['email'],
'password': request.values['password']
})
print(r.content)
response = handle_request(PostRequest(
{'import': r.content.decode("utf-8")}),
import_prefix='Internet')
r = requests.post(serverurl + '/deleteitems.php',
data={
'email': request.values['email'],
'password': request.values['password']
})
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)
online_username = requester.instance().post(
serverurl + '/getusername.php',
data={
'email': request.values['email'],
'password': request.values['password']
})
print('online username: '******'/getgemeinsam.php',
data={
'email': request.values['email'],
'password': request.values['password']
})
print(online_content)
table = _parse_table(online_content)
print('table before person mapping', table)
table.Person = table.Person.map(
lambda x: viewcore.database_instance().name
if x == online_username else configuration_provider.
get_configuration('PARTNERNAME'))
online_content = "#######MaschinenimportStart\n"
online_content = online_content + table.to_csv(index=False)
online_content = online_content + "#######MaschinenimportEnd\n"
response = handle_request(PostRequest({'import': online_content}),
import_prefix='Internet_Gemeinsam',
gemeinsam=True)
requester.instance().post(serverurl + '/deletegemeinsam.php',
data={
'email': request.values['email'],
'password':
request.values['password']
})
return response
elif post_action_is(request, 'set_kategorien'):
kategorien = ','.join(
sorted(viewcore.database_instance().einzelbuchungen.
get_kategorien_ausgaben(
hide_ausgeschlossene_kategorien=True)))
serverurl = request.values['server']
serverurl = _add_protokoll_if_needed(serverurl)
_save_server_creds(serverurl, request.values['email'])
serverurl = serverurl + '/setkategorien.php'
requester.instance().post(serverurl,
data={
'email': request.values['email'],
'password':
request.values['password'],
'kategorien': kategorien
})
else:
print(request.values)
content = request.values['import'].replace('\r', '')
FileSystem.instance().write(
'../Import/' + import_prefix + 'Import_' + str(datetime.now()),
content)
imported_values = _parse_table(content)
datenbank_kategorien = set(viewcore.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)
context = viewcore.generate_base_context('import')
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
return 'import.html', context
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)
context = viewcore.generate_base_context('import')
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
return 'import.html', context
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 = viewcore.generate_base_context('import')
context['element_titel'] = 'Kategorien zuweisen'
context['unpassende_kategorien'] = nicht_passende_kategorien
context['optionen'] = options
context['import'] = request.values['import']
context['transaction_id'] = 'requested'
return 'import_mapping.html', context
context = viewcore.generate_base_context('import')
context[
'ONLINE_DEFAULT_SERVER'] = configuration_provider.get_configuration(
'ONLINE_DEFAULT_SERVER')
context['ONLINE_DEFAULT_USER'] = configuration_provider.get_configuration(
'ONLINE_DEFAULT_USER')
return 'import.html', context
def write_db_file_stub(self,name, stub):
FileSystem.instance().write('../Database_' + name + '.csv', stub)
def abrechnen(self):
'''
rechnet gemeinsame ausgaben aus der Datenbank ab
'''
name_self = viewcore.database_instance().name
name_partner = viewcore.name_of_partner()
ausgaben_maureen = self.gemeinsamebuchungen.content[
self.gemeinsamebuchungen.content.Person == name_partner]
ausgaben_sebastian = self.gemeinsamebuchungen.content[
self.gemeinsamebuchungen.content.Person == name_self]
summe_maureen = self._sum(ausgaben_maureen['Wert'])
summe_sebastian = self._sum(ausgaben_sebastian['Wert'])
ausgaben_gesamt = summe_maureen + summe_sebastian
dif_maureen = (ausgaben_gesamt / 2) - summe_maureen
abrechnunsdatei = StringWriter()
abrechnunsdatei.write("Abrechnung vom " +
datum_to_german(viewcore.today()) + "\n")
self._write_trenner(abrechnunsdatei)
abrechnunsdatei.write("Ergebnis:\n")
if dif_maureen > 0:
abrechnunsdatei.write(name_self + ' muss an ' + name_partner +
' noch ' + str('%.2f' % dif_maureen) +
"€ überweisen.\n")
else:
abrechnunsdatei.write(name_partner + ' muss an ' + name_self +
' noch ' + str("%.2f" % (dif_maureen * -1)) +
"€ überweisen.\n")
abrechnunsdatei.write("\n")
abrechnunsdatei.write(('Ausgaben von ' + name_partner).ljust(30, " ") +
str("%.2f" % summe_maureen).rjust(7, " ") + "\n")
abrechnunsdatei.write(('Ausgaben von ' + name_self).ljust(30, " ") +
str("%.2f" % summe_sebastian).rjust(7, " ") +
"\n")
abrechnunsdatei.write("".ljust(38, "-") + "\n")
abrechnunsdatei.write("Gesamt".ljust(30, " ") +
str("%.2f" % ausgaben_gesamt).rjust(7, " ") +
"\n \n \n")
self._write_trenner(abrechnunsdatei)
abrechnunsdatei.write("Gesamtausgaben pro Person \n")
self._write_trenner(abrechnunsdatei)
abrechnunsdatei.write("Datum".ljust(10, " ") + " Kategorie " +
"Name".ljust(20, " ") + " " +
"Wert".rjust(7, " ") + "\n")
for _, row in self.gemeinsamebuchungen.content.iterrows():
abrechnunsdatei.write(
datum_to_german(row['Datum']) + " " +
row['Kategorie'].ljust(len("Kategorie "), " ") + " " +
row['Name'].ljust(20, " ") + " " +
str("%.2f" % (row['Wert'] / 2)).rjust(7, " ") + "\n")
abrechnunsdatei.write("\n")
abrechnunsdatei.write("\n")
self._write_trenner(abrechnunsdatei)
abrechnunsdatei.write('Ausgaben von ' + name_partner + '\n')
self._write_trenner(abrechnunsdatei)
abrechnunsdatei.write("Datum".ljust(10, " ") + " Kategorie " +
"Name".ljust(20, " ") + " " +
"Wert".rjust(7, " ") + "\n")
for _, row in ausgaben_maureen.iterrows():
abrechnunsdatei.write(
datum_to_german(row['Datum']) + " " +
row['Kategorie'].ljust(len("Kategorie "), " ") + " " +
row['Name'].ljust(20, " ") + " " +
str("%.2f" % (row['Wert'])).rjust(7, " ") + "\n")
abrechnunsdatei.write("\n")
abrechnunsdatei.write("\n")
self._write_trenner(abrechnunsdatei)
abrechnunsdatei.write('Ausgaben von ' + name_self + '\n')
self._write_trenner(abrechnunsdatei)
abrechnunsdatei.write("Datum".ljust(10, " ") + " Kategorie " +
"Name".ljust(20, " ") + " " +
"Wert".rjust(7, " ") + "\n")
for _, row in ausgaben_sebastian.iterrows():
abrechnunsdatei.write(
datum_to_german(row['Datum']) + " " +
row['Kategorie'].ljust(len("Kategorie "), " ") + " " +
row['Name'].ljust(20, " ") + " " +
str("%.2f" % (row['Wert'])).rjust(7, " ") + "\n")
ausgaben = DataFrame()
for _, row in self.gemeinsamebuchungen.content.iterrows():
buchung = self._berechne_abbuchung(row['Datum'], row['Kategorie'],
row['Name'],
("%.2f" % (row['Wert'] / 2)))
buchung.Dynamisch = False
ausgaben = ausgaben.append(buchung)
abrechnunsdatei.write("\n\n")
abrechnunsdatei.write("#######MaschinenimportStart\n")
abrechnunsdatei.write(ausgaben.to_csv(index=False))
abrechnunsdatei.write("#######MaschinenimportEnd\n")
self.einzelbuchungen.append_row(ausgaben)
self.gemeinsamebuchungen.empty()
self.taint()
FileSystem.instance().write(
"../Abrechnungen/Abrechnung_" + str(datetime.now()),
abrechnunsdatei.to_string())
return abrechnunsdatei.to_string()
def _save_config(config):
content = []
for key in config:
content.append('{key}:{value}'.format(key=key, value=config[key]))
content = reduce(lambda x, y: str(x) + '\n' + str(y), content)
FileSystem.instance().write('../config', content)