Flaschengeist/flaschengeist
Flaschengeist
/
flaschengeist
7
0
Fork 0
Code Issues 20 Pull Requests Packages Projects Releases 2 Wiki Activity

finished ##189 

it test if the date is lower or equal then date now
if true the month will be locked in soft mode
if one day exists in database the status of locked will not change
This commit is contained in:
Tim Gröger 2020-02-23 21:27:03 +01:00
parent 576002a95c
commit 65d09225b1
4 changed files with 205 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

281
geruecht/controller/databaseController.py
View File

@ -6,6 +6,7 @@ from geruecht.model.creditList import CreditList
from datetime import datetime, timedelta from datetime import datetime, timedelta
from geruecht.exceptions import UsernameExistDB, DatabaseExecption from geruecht.exceptions import UsernameExistDB, DatabaseExecption
import traceback import traceback
from MySQLdb._exceptions import IntegrityError
class DatabaseController(metaclass=Singleton): class DatabaseController(metaclass=Singleton):
''' '''
@ -18,41 +19,55 @@ class DatabaseController(metaclass=Singleton):
self.db = db self.db = db
def getAllUser(self): def getAllUser(self):
cursor = self.db.connection.cursor() try:
cursor.execute("select * from user") cursor = self.db.connection.cursor()
data = cursor.fetchall() cursor.execute("select * from user")
data = cursor.fetchall()
if data: if data:
retVal = [] retVal = []
for value in data: for value in data:
user = User(value) user = User(value)
creditLists = self.getCreditListFromUser(user) creditLists = self.getCreditListFromUser(user)
user.initGeruechte(creditLists) user.initGeruechte(creditLists)
retVal.append(user) retVal.append(user)
return retVal return retVal
except Exception as err:
traceback.print_exc()
self.db.connection.rollback()
raise DatabaseExecption("Something went worng with Datatabase: {}".format(err))
def getUser(self, username): def getUser(self, username):
retVal = None try:
cursor = self.db.connection.cursor() retVal = None
cursor.execute("select * from user where uid='{}'".format(username)) cursor = self.db.connection.cursor()
data = cursor.fetchone() cursor.execute("select * from user where uid='{}'".format(username))
if data: data = cursor.fetchone()
retVal = User(data) if data:
creditLists = self.getCreditListFromUser(retVal) retVal = User(data)
retVal.initGeruechte(creditLists) creditLists = self.getCreditListFromUser(retVal)
retVal.initGeruechte(creditLists)
return retVal return retVal
except Exception as err:
traceback.print_exc()
self.db.connection.rollback()
raise DatabaseExecption("Something went worng with Datatabase: {}".format(err))
def getUserById(self, id): def getUserById(self, id):
retVal = None try:
cursor = self.db.connection.cursor() retVal = None
cursor.execute("select * from user where id={}".format(id)) cursor = self.db.connection.cursor()
data = cursor.fetchone() cursor.execute("select * from user where id={}".format(id))
if data: data = cursor.fetchone()
retVal = User(data) if data:
creditLists = self.getCreditListFromUser(retVal) retVal = User(data)
retVal.initGeruechte(creditLists) creditLists = self.getCreditListFromUser(retVal)
return retVal retVal.initGeruechte(creditLists)
return retVal
except Exception as err:
traceback.print_exc()
self.db.connection.rollback()
raise DatabaseExecption("Something went worng with Datatabase: {}".format(err))
def _convertGroupToString(self, groups): def _convertGroupToString(self, groups):
retVal = '' retVal = ''
@ -66,86 +81,124 @@ class DatabaseController(metaclass=Singleton):
def insertUser(self, user): def insertUser(self, user):
cursor = self.db.connection.cursor() try:
groups = self._convertGroupToString(user.group) cursor = self.db.connection.cursor()
cursor.execute("insert into user (uid, dn, firstname, lastname, gruppe, lockLimit, locked, autoLock, mail) VALUES ('{}','{}','{}','{}','{}',{},{},{},'{}')".format( groups = self._convertGroupToString(user.group)
user.uid, user.dn, user.firstname, user.lastname, groups, user.limit, user.locked, user.autoLock, user.mail)) cursor.execute("insert into user (uid, dn, firstname, lastname, gruppe, lockLimit, locked, autoLock, mail) VALUES ('{}','{}','{}','{}','{}',{},{},{},'{}')".format(
self.db.connection.commit() user.uid, user.dn, user.firstname, user.lastname, groups, user.limit, user.locked, user.autoLock, user.mail))
self.db.connection.commit()
except Exception as err:
traceback.print_exc()
self.db.connection.rollback()
raise DatabaseExecption("Something went worng with Datatabase: {}".format(err))
def updateUser(self, user): def updateUser(self, user):
cursor = self.db.connection.cursor() try:
print('uid: {}; group: {}'.format(user.uid, user.group)) cursor = self.db.connection.cursor()
groups = self._convertGroupToString(user.group) print('uid: {}; group: {}'.format(user.uid, user.group))
sql = "update user set dn='{}', firstname='{}', lastname='{}', gruppe='{}', lockLimit={}, locked={}, autoLock={}, mail='{}' where uid='{}'".format( groups = self._convertGroupToString(user.group)
user.dn, user.firstname, user.lastname, groups, user.limit, user.locked, user.autoLock, user.mail, user.uid) sql = "update user set dn='{}', firstname='{}', lastname='{}', gruppe='{}', lockLimit={}, locked={}, autoLock={}, mail='{}' where uid='{}'".format(
print(sql) user.dn, user.firstname, user.lastname, groups, user.limit, user.locked, user.autoLock, user.mail, user.uid)
cursor.execute(sql) print(sql)
self.db.connection.commit() cursor.execute(sql)
self.db.connection.commit()
except Exception as err:
traceback.print_exc()
self.db.connection.rollback()
raise DatabaseExecption("Something went worng with Datatabase: {}".format(err))
def getCreditListFromUser(self, user, **kwargs): def getCreditListFromUser(self, user, **kwargs):
cursor = self.db.connection.cursor() try:
if 'year' in kwargs: cursor = self.db.connection.cursor()
sql = "select * from creditList where user_id={} and year_date={}".format(user.id, kwargs['year']) if 'year' in kwargs:
else: sql = "select * from creditList where user_id={} and year_date={}".format(user.id, kwargs['year'])
sql = "select * from creditList where user_id={}".format(user.id) else:
cursor.execute(sql) sql = "select * from creditList where user_id={}".format(user.id)
data = cursor.fetchall() cursor.execute(sql)
if len(data) == 1: data = cursor.fetchall()
return [CreditList(data[0])] if len(data) == 1:
else: return [CreditList(data[0])]
return [CreditList(value) for value in data] else:
return [CreditList(value) for value in data]
except Exception as err:
traceback.print_exc()
self.db.connection.rollback()
raise DatabaseExecption("Something went worng with Datatabase: {}".format(err))
def createCreditList(self, user_id, year=datetime.now().year): def createCreditList(self, user_id, year=datetime.now().year):
cursor = self.db.connection.cursor() try:
cursor.execute("insert into creditList (year_date, user_id) values ({},{})".format(year, user_id)) cursor = self.db.connection.cursor()
self.db.connection.commit() cursor.execute("insert into creditList (year_date, user_id) values ({},{})".format(year, user_id))
self.db.connection.commit()
except Exception as err:
traceback.print_exc()
self.db.connection.rollback()
raise DatabaseExecption("Something went worng with Datatabase: {}".format(err))
def updateCreditList(self, creditlist): def updateCreditList(self, creditlist):
cursor = self.db.connection.cursor() try:
cursor.execute("select * from creditList where user_id={} and year_date={}".format(creditlist.user_id, creditlist.year)) cursor = self.db.connection.cursor()
data = cursor.fetchall() cursor.execute("select * from creditList where user_id={} and year_date={}".format(creditlist.user_id, creditlist.year))
if len(data) == 0: data = cursor.fetchall()
self.createCreditList(creditlist.user_id, creditlist.year) if len(data) == 0:
sql = "update creditList set jan_guthaben={}, jan_schulden={},feb_guthaben={}, feb_schulden={}, maer_guthaben={}, maer_schulden={}, apr_guthaben={}, apr_schulden={}, mai_guthaben={}, mai_schulden={}, jun_guthaben={}, jun_schulden={}, jul_guthaben={}, jul_schulden={}, aug_guthaben={}, aug_schulden={},sep_guthaben={}, sep_schulden={},okt_guthaben={}, okt_schulden={}, nov_guthaben={}, nov_schulden={}, dez_guthaben={}, dez_schulden={}, last_schulden={} where year_date={} and user_id={}".format(creditlist.jan_guthaben, creditlist.jan_schulden, self.createCreditList(creditlist.user_id, creditlist.year)
creditlist.feb_guthaben, creditlist.feb_schulden, sql = "update creditList set jan_guthaben={}, jan_schulden={},feb_guthaben={}, feb_schulden={}, maer_guthaben={}, maer_schulden={}, apr_guthaben={}, apr_schulden={}, mai_guthaben={}, mai_schulden={}, jun_guthaben={}, jun_schulden={}, jul_guthaben={}, jul_schulden={}, aug_guthaben={}, aug_schulden={},sep_guthaben={}, sep_schulden={},okt_guthaben={}, okt_schulden={}, nov_guthaben={}, nov_schulden={}, dez_guthaben={}, dez_schulden={}, last_schulden={} where year_date={} and user_id={}".format(creditlist.jan_guthaben, creditlist.jan_schulden,
creditlist.maer_guthaben, creditlist.maer_schulden, creditlist.feb_guthaben, creditlist.feb_schulden,
creditlist.apr_guthaben, creditlist.apr_schulden, creditlist.maer_guthaben, creditlist.maer_schulden,
creditlist.mai_guthaben, creditlist.mai_schulden, creditlist.apr_guthaben, creditlist.apr_schulden,
creditlist.jun_guthaben, creditlist.jun_schulden, creditlist.mai_guthaben, creditlist.mai_schulden,
creditlist.jul_guthaben, creditlist.jul_schulden, creditlist.jun_guthaben, creditlist.jun_schulden,
creditlist.aug_guthaben, creditlist.aug_schulden, creditlist.jul_guthaben, creditlist.jul_schulden,
creditlist.sep_guthaben, creditlist.sep_schulden, creditlist.aug_guthaben, creditlist.aug_schulden,
creditlist.okt_guthaben, creditlist.okt_schulden, creditlist.sep_guthaben, creditlist.sep_schulden,
creditlist.nov_guthaben, creditlist.nov_schulden, creditlist.okt_guthaben, creditlist.okt_schulden,
creditlist.dez_guthaben, creditlist.dez_schulden, creditlist.nov_guthaben, creditlist.nov_schulden,
creditlist.last_schulden, creditlist.year, creditlist.user_id) creditlist.dez_guthaben, creditlist.dez_schulden,
print(sql) creditlist.last_schulden, creditlist.year, creditlist.user_id)
cursor = self.db.connection.cursor() print(sql)
cursor.execute(sql) cursor = self.db.connection.cursor()
self.db.connection.commit() cursor.execute(sql)
self.db.connection.commit()
except Exception as err:
traceback.print_exc()
self.db.connection.rollback()
raise DatabaseExecption("Something went worng with Datatabase: {}".format(err))
def getWorker(self, user, date): def getWorker(self, user, date):
cursor = self.db.connection.cursor() try:
cursor.execute("select * from bardienste where user_id={} and startdatetime='{}'".format(user.id, date)) cursor = self.db.connection.cursor()
data = cursor.fetchone() cursor.execute("select * from bardienste where user_id={} and startdatetime='{}'".format(user.id, date))
return {"user": user.toJSON(), "startdatetime": data['startdatetime'], "enddatetime": data['enddatetime'], "start": { "year": data['startdatetime'].year, "month": data['startdatetime'].month, "day": data['startdatetime'].day}} if data else None data = cursor.fetchone()
return {"user": user.toJSON(), "startdatetime": data['startdatetime'], "enddatetime": data['enddatetime'], "start": { "year": data['startdatetime'].year, "month": data['startdatetime'].month, "day": data['startdatetime'].day}} if data else None
except Exception as err:
traceback.print_exc()
self.db.connection.rollback()
raise DatabaseExecption("Something went worng with Datatabase: {}".format(err))
def getWorkers(self, date): def getWorkers(self, date):
cursor = self.db.connection.cursor() try:
cursor.execute("select * from bardienste where startdatetime='{}'".format(date)) cursor = self.db.connection.cursor()
data = cursor.fetchall() cursor.execute("select * from bardienste where startdatetime='{}'".format(date))
return [{"user": self.getUserById(work['user_id']).toJSON(), "startdatetime": work['startdatetime'], "enddatetime": work['enddatetime'], "start": { "year": work['startdatetime'].year, "month": work['startdatetime'].month, "day": work['startdatetime'].day}} for work in data] data = cursor.fetchall()
return [{"user": self.getUserById(work['user_id']).toJSON(), "startdatetime": work['startdatetime'], "enddatetime": work['enddatetime'], "start": { "year": work['startdatetime'].year, "month": work['startdatetime'].month, "day": work['startdatetime'].day}} for work in data]
except Exception as err:
traceback.print_exc()
self.db.connection.rollback()
raise DatabaseExecption("Something went worng with Datatabase: {}".format(err))
def setWorker(self, user, date): def setWorker(self, user, date):
cursor = self.db.connection.cursor() try:
cursor.execute("insert into bardienste (user_id, startdatetime, enddatetime) values ({},'{}','{}')".format(user.id, date, date + timedelta(days=1))) cursor = self.db.connection.cursor()
self.db.connection.commit() cursor.execute("insert into bardienste (user_id, startdatetime, enddatetime) values ({},'{}','{}')".format(user.id, date, date + timedelta(days=1)))
self.db.connection.commit()
except Exception as err:
traceback.print_exc()
self.db.connection.rollback()
raise DatabaseExecption("Something went worng with Datatabase: {}".format(err))
def deleteWorker(self, user, date): def deleteWorker(self, user, date):
@ -155,6 +208,8 @@ class DatabaseController(metaclass=Singleton):
self.db.connection.commit() self.db.connection.commit()
except Exception as err: except Exception as err:
traceback.print_exc() traceback.print_exc()
self.db.connection.rollback()
raise DatabaseExecption("Something went worng with Datatabase: {}".format(err))
def changeUsername(self, user, newUsername): def changeUsername(self, user, newUsername):
try: try:
@ -165,9 +220,49 @@ class DatabaseController(metaclass=Singleton):
raise UsernameExistDB("Username already exists") raise UsernameExistDB("Username already exists")
else: else:
cursor.execute("update user set uid='{}' where id={}".format(newUsername, user.id)) cursor.execute("update user set uid='{}' where id={}".format(newUsername, user.id))
self.db.connection() self.db.connection.commit()
except Exception as err: except Exception as err:
traceback.print_exc() traceback.print_exc()
self.db.connection.rollback()
raise DatabaseExecption("Something went worng with Datatabase: {}".format(err))
def getLockedDay(self, date):
try:
cursor = self.db.connection.cursor()
cursor.execute("select * from locked_days where daydate='{}'".format(date))
data = cursor.fetchone()
return data
except Exception as err:
traceback.print_exc()
self.db.connection.rollback()
raise DatabaseExecption("Something went worng with Datatabase: {}".format(err))
def setLockedDay(self, date, locked, hard=False):
try:
cursor = self.db.connection.cursor()
sql = "insert into locked_days (daydate, locked) VALUES ('{}', {})".format(date, locked)
cursor.execute(sql)
self.db.connection.commit()
return self.getLockedDay(date)
except IntegrityError as err:
self.db.connection.rollback()
try:
exists = self.getLockedDay(date)
if hard:
sql = "update locked_days set locked={} where id={}".format(locked, exists['id'])
else:
sql = False
if sql:
cursor.execute(sql)
self.db.connection.commit()
return self.getLockedDay(date)
except Exception as err:
traceback.print_exc()
self.db.connection.rollback()
raise DatabaseController("Something went wrong with Database: {}".format(err))
except Exception as err:
traceback.print_exc()
self.db.connection.rollback()
raise DatabaseExecption("Something went worng with Datatabase: {}".format(err)) raise DatabaseExecption("Something went worng with Datatabase: {}".format(err))
if __name__ == '__main__': if __name__ == '__main__':

9
geruecht/controller/userController.py
View File

@ -2,6 +2,7 @@ from . import LOGGER, Singleton, ldapConfig, dbConfig, mailConfig
import geruecht.controller.databaseController as dc import geruecht.controller.databaseController as dc
import geruecht.controller.ldapController as lc import geruecht.controller.ldapController as lc
import geruecht.controller.emailController as ec import geruecht.controller.emailController as ec
import calendar
from geruecht.model.user import User from geruecht.model.user import User
from geruecht.exceptions import PermissionDenied from geruecht.exceptions import PermissionDenied
from datetime import datetime, timedelta from datetime import datetime, timedelta
@ -16,6 +17,14 @@ class UserController(metaclass=Singleton):
def __init__(self): def __init__(self):
pass pass
def getLockedDay(self, date):
now = datetime.now()
daysInMonth = calendar.monthrange(date.year, date.month)[1]
if date.year <= now.year and date.month <= now.month:
for i in range(1, daysInMonth + 1):
db.setLockedDay(datetime(date.year, date.month, i).date(), True)
return db.getLockedDay(date.date())
def getWorker(self, date, username=None): def getWorker(self, date, username=None):
if (username): if (username):
user = self.getUser(username) user = self.getUser(username)

5
geruecht/user/routes.py
View File

@ -59,6 +59,9 @@ def _getUser(**kwargs):
month = data['month'] month = data['month']
year = data['year'] year = data['year']
date = datetime(year, month, day, 12) date = datetime(year, month, day, 12)
retVal = userController.getWorker(date) retVal = {
'worker': userController.getWorker(date),
'day': userController.getLockedDay(date)
}
print(retVal) print(retVal)
return jsonify(retVal) return jsonify(retVal)

5
geruecht/vorstand/routes.py
View File

@ -34,7 +34,10 @@ def _getUser(**kwargs):
month = data['month'] month = data['month']
year = data['year'] year = data['year']
date = datetime(year, month, day, 12) date = datetime(year, month, day, 12)
retVal = userController.getWorker(date) retVal = {
'worker': userController.getWorker(date),
'day': userController.getLockedDay(date)
}
print(retVal) print(retVal)
return jsonify(retVal) return jsonify(retVal)