216 lines
7.0 KiB
Python
216 lines
7.0 KiB
Python
from geruecht.logger import getLogger
|
|
from geruecht.model.creditList import CreditList, create_empty_data
|
|
from datetime import datetime
|
|
|
|
LOGGER = getLogger(__name__)
|
|
|
|
|
|
class User():
|
|
""" Database Object for User
|
|
|
|
Table for all safed User
|
|
|
|
Attributes:
|
|
id: Id in Database as Primary Key.
|
|
userID: ID for the User maybe to Link?
|
|
username: Username of the User to Login
|
|
firstname: Firstname of the User
|
|
Lastname: Lastname of the User
|
|
group: Which group is the User? moneymaster, gastro, user or bar?
|
|
password: salted hashed password for the User.
|
|
"""
|
|
def __init__(self, data):
|
|
if 'id' in data:
|
|
self.id = int(data['id'])
|
|
self.uid = data['uid']
|
|
self.dn = data['dn']
|
|
self.firstname = data['firstname']
|
|
self.lastname = data['lastname']
|
|
self.group = data['gruppe']
|
|
if 'mail' in data:
|
|
self.mail = data['mail']
|
|
else:
|
|
self.mail = ''
|
|
if 'lockLimit' in data:
|
|
self.limit = int(data['lockLimit'])
|
|
else:
|
|
self.limit = 4200
|
|
if 'locked' in data:
|
|
self.locked = bool(data['locked'])
|
|
else:
|
|
self.locked = False
|
|
if 'autoLock' in data:
|
|
self.autoLock = bool(data['autoLock'])
|
|
else:
|
|
self.autoLock = True
|
|
if type(data['gruppe']) == list:
|
|
self.group = data['gruppe']
|
|
elif type(data['gruppe']) == str:
|
|
self.group = data['gruppe'].split(',')
|
|
if 'creditLists' in data:
|
|
self.geruechte = data['creditLists']
|
|
self.password = ''
|
|
|
|
def updateData(self, data):
|
|
if 'dn' in data:
|
|
self.dn = data['dn']
|
|
if 'firstname' in data:
|
|
self.firstname = data['firstname']
|
|
if 'lastname' in data:
|
|
self.lastname = data['lastname']
|
|
if 'gruppe' in data:
|
|
self.group = data['gruppe']
|
|
if 'lockLimit' in data:
|
|
self.limit = int(data['lockLimit'])
|
|
if 'locked' in data:
|
|
self.locked = bool(data['locked'])
|
|
if 'autoLock' in data:
|
|
self.autoLock = bool(data['autoLock'])
|
|
if 'mail' in data:
|
|
self.mail = data['mail']
|
|
|
|
def initGeruechte(self, creditLists):
|
|
if type(creditLists) == list:
|
|
self.geruechte = creditLists
|
|
|
|
def createGeruecht(self, amount=0, year=datetime.now().year):
|
|
""" Create Geruecht
|
|
|
|
This function create a geruecht for the user for an year.
|
|
By default is amount zero and year the actual year.
|
|
|
|
Args:
|
|
amount: is the last_schulden of the geruecht
|
|
year: is the year of the geruecht
|
|
|
|
Returns:
|
|
the created geruecht
|
|
"""
|
|
LOGGER.debug("Create Geruecht for user {} in year {}".format(self, year))
|
|
data = create_empty_data()
|
|
data['user_id'] = self.id
|
|
data['last_schulden'] = amount
|
|
data['year_date'] = year
|
|
credit = CreditList(data)
|
|
self.geruechte.append(credit)
|
|
LOGGER.debug("Created Geruecht {}".format(credit))
|
|
return credit
|
|
|
|
def getGeruecht(self, year=datetime.now().year):
|
|
""" Get Geruecht
|
|
|
|
This function returns the geruecht of an year.
|
|
By default is the year the actual year.
|
|
|
|
Args:
|
|
year: the year of the geruecht
|
|
|
|
Returns:
|
|
the geruecht of the year
|
|
"""
|
|
LOGGER.debug("Iterate through Geruechte of User {}".format(self))
|
|
for geruecht in self.geruechte:
|
|
LOGGER.debug("Check if Geruecht {} has year {}".format(geruecht, year))
|
|
if geruecht.year == year:
|
|
LOGGER.debug("Find Geruecht {} for User {}".format(geruecht, self))
|
|
return geruecht
|
|
LOGGER.debug("No Geruecht found for User {}. Will create one".format(self))
|
|
geruecht = self.createGeruecht(year=year)
|
|
|
|
return self.getGeruecht(year=year)
|
|
|
|
def addAmount(self, amount, year=datetime.now().year, month=datetime.now().month):
|
|
""" Add Amount
|
|
|
|
This function add an amount to a geruecht with an spezified year and month to the user.
|
|
By default the year is the actual year.
|
|
By default the month is the actual month.
|
|
|
|
Args:
|
|
year: year of the geruecht
|
|
month: month for the amount
|
|
|
|
Returns:
|
|
double (credit, amount)
|
|
"""
|
|
LOGGER.debug("Add amount to User {} in year {} and month {}".format(self, year, month))
|
|
geruecht = self.getGeruecht(year=year)
|
|
retVal = geruecht.addAmount(amount, month=month)
|
|
|
|
return retVal
|
|
|
|
def addCredit(self, credit, year=datetime.now().year, month=datetime.now().month):
|
|
""" Add Credit
|
|
|
|
This function add an credit to a geruecht with an spezified year and month to the user.
|
|
By default the year is the actual year.
|
|
By default the month is the actual month.
|
|
|
|
Args:
|
|
year: year of the geruecht
|
|
month: month for the amount
|
|
|
|
Returns:
|
|
double (credit, amount)
|
|
"""
|
|
LOGGER.debug("Add credit to User {} in year {} and month {}".format(self, year, month))
|
|
geruecht = self.getGeruecht(year=year)
|
|
retVal = geruecht.addCredit(credit, month=month)
|
|
|
|
return retVal
|
|
|
|
def updateGeruecht(self):
|
|
""" Update list of geruechte
|
|
|
|
This function iterate through the geruechte, which sorted by year and update the last_schulden of the geruecht.
|
|
"""
|
|
LOGGER.debug("Update all Geruechte ")
|
|
self.geruechte.sort(key=self.sortYear)
|
|
|
|
for index, geruecht in enumerate(self.geruechte):
|
|
if index == 0 or index == len(self.geruechte) - 1:
|
|
geruecht.last_schulden = 0
|
|
if index != 0:
|
|
geruecht.last_schulden = (self.geruechte[index - 1].getSchulden() * -1)
|
|
|
|
return self.geruechte
|
|
|
|
def sortYear(self, geruecht):
|
|
""" Sort Year
|
|
|
|
This function is only an helperfunction to sort the list of geruechte by years.
|
|
It only returns the year of the geruecht.
|
|
|
|
Args:
|
|
geruecht: geruecht which year you want
|
|
|
|
Returns:
|
|
int year of the geruecht
|
|
"""
|
|
return geruecht.year
|
|
|
|
def toJSON(self):
|
|
""" Create Dic to dump in JSON
|
|
|
|
Returns:
|
|
A Dic with static Attributes.
|
|
"""
|
|
dic = {
|
|
"userId": self.uid,
|
|
"uid": self.uid,
|
|
"dn": self.dn,
|
|
"firstname": self.firstname,
|
|
"lastname": self.lastname,
|
|
"group": self.group,
|
|
"username": self.uid,
|
|
"locked": self.locked,
|
|
"autoLock": self.autoLock,
|
|
"limit": self.limit,
|
|
"mail": self.mail
|
|
}
|
|
return dic
|
|
|
|
def __repr__(self):
|
|
return "User({}, {}, {})".format(self.uid, self.dn, self.group)
|
|
|