diff --git a/geruecht/baruser/routes.py b/geruecht/baruser/routes.py index 98c7df5..76903d1 100644 --- a/geruecht/baruser/routes.py +++ b/geruecht/baruser/routes.py @@ -1,6 +1,6 @@ from flask import Blueprint, request, jsonify import geruecht.controller.ldapController as lc -import geruecht.controller.userController as uc +import geruecht.controller.mainController as mc from datetime import datetime from geruecht.model import BAR, MONEY, USER, VORSTAND from geruecht.decorator import login_required @@ -12,7 +12,7 @@ creditL = getCreditLogger() baruser = Blueprint("baruser", __name__) ldap = lc.LDAPController() -userController = uc.UserController() +mainController = mc.MainController() @baruser.route("/bar") @@ -29,7 +29,7 @@ def _bar(**kwargs): debug.info("/bar") try: dic = {} - users = userController.getAllUsersfromDB() + users = mainController.getAllUsersfromDB() for user in users: geruecht = None geruecht = user.getGeruecht(datetime.now().year) @@ -72,9 +72,9 @@ def _baradd(**kwargs): amount = int(data['amount']) amountl = amount date = datetime.now() - userController.addAmount( + mainController.addAmount( userID, amount, year=date.year, month=date.month) - user = userController.getUser(userID) + user = mainController.getUser(userID) geruecht = user.getGeruecht(year=date.year) month = geruecht.getMonth(month=date.month) amount = abs(month[0] - month[1]) @@ -135,9 +135,9 @@ def _storno(**kwargs): amount = int(data['amount']) amountl = amount date = datetime.now() - userController.addCredit( + mainController.addCredit( userID, amount, year=date.year, month=date.month) - user = userController.getUser(userID) + user = mainController.getUser(userID) geruecht = user.getGeruecht(year=date.year) month = geruecht.getMonth(month=date.month) amount = abs(month[0] - month[1]) @@ -165,7 +165,7 @@ def _getUser(**kwargs): try: data = request.get_json() username = data['userId'] - user = userController.getUser(username) + user = mainController.getUser(username) amount = user.getGeruecht(datetime.now().year).getSchulden() if amount >= 0: type = 'credit' diff --git a/geruecht/controller/accesTokenController.py b/geruecht/controller/accesTokenController.py index bd1970f..6c683c4 100644 --- a/geruecht/controller/accesTokenController.py +++ b/geruecht/controller/accesTokenController.py @@ -1,6 +1,6 @@ from geruecht.model.accessToken import AccessToken import geruecht.controller as gc -import geruecht.controller.userController as uc +import geruecht.controller.mainController as mc from geruecht.model import BAR from datetime import datetime, timedelta import hashlib @@ -9,7 +9,7 @@ from geruecht.logger import getDebugLogger debug = getDebugLogger() -userController = uc.UserController() +mainController = mc.MainController() class AccesTokenController(metaclass=Singleton): """ Control all createt AccesToken @@ -34,7 +34,7 @@ class AccesTokenController(metaclass=Singleton): def checkBar(self, user): debug.info("check if user {{ {} }} is baruser".format(user)) - if (userController.checkBarUser(user)): + if (mainController.checkBarUser(user)): if BAR not in user.group: debug.debug("append bar to user {{ {} }}".format(user)) user.group.append(BAR) diff --git a/geruecht/controller/databaseController.py b/geruecht/controller/databaseController.py deleted file mode 100644 index 82d32b9..0000000 --- a/geruecht/controller/databaseController.py +++ /dev/null @@ -1,706 +0,0 @@ -import pymysql -from . import Singleton -from geruecht import db -from geruecht.model.user import User -from geruecht.model.creditList import CreditList -from datetime import datetime, timedelta -from geruecht.exceptions import UsernameExistDB, DatabaseExecption -import traceback -from MySQLdb._exceptions import IntegrityError - -class DatabaseController(metaclass=Singleton): - ''' - DatabaesController - - Connect to the Database and execute sql-executions - ''' - - def __init__(self): - self.db = db - - def getAllUser(self, extern=False, workgroups=True): - try: - cursor = self.db.connection.cursor() - cursor.execute("select * from user") - data = cursor.fetchall() - - if data: - retVal = [] - for value in data: - if extern and value['uid'] == 'extern': - continue - user = User(value) - creditLists = self.getCreditListFromUser(user) - user.initGeruechte(creditLists) - if workgroups: - user.workgroups = self.getWorkgroupsOfUser(user.id) - retVal.append(user) - 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, workgroups=True): - try: - retVal = None - cursor = self.db.connection.cursor() - cursor.execute("select * from user where uid='{}'".format(username)) - data = cursor.fetchone() - if data: - retVal = User(data) - creditLists = self.getCreditListFromUser(retVal) - retVal.initGeruechte(creditLists) - if workgroups: - retVal.workgroups = self.getWorkgroupsOfUser(retVal.id) - 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, workgroups=True): - try: - retVal = None - cursor = self.db.connection.cursor() - cursor.execute("select * from user where id={}".format(id)) - data = cursor.fetchone() - if data: - retVal = User(data) - creditLists = self.getCreditListFromUser(retVal) - retVal.initGeruechte(creditLists) - if workgroups: - retVal.workgroups = self.getWorkgroupsOfUser(retVal.id) - 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): - retVal = '' - print('groups: {}'.format(groups)) - if groups: - for group in groups: - if len(retVal) != 0: - retVal += ',' - retVal += group - return retVal - - - def insertUser(self, user): - try: - cursor = self.db.connection.cursor() - groups = self._convertGroupToString(user.group) - cursor.execute("insert into user (uid, dn, firstname, lastname, gruppe, lockLimit, locked, autoLock, mail) VALUES ('{}','{}','{}','{}','{}',{},{},{},'{}')".format( - 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): - try: - cursor = self.db.connection.cursor() - print('uid: {}; group: {}'.format(user.uid, user.group)) - groups = self._convertGroupToString(user.group) - sql = "update user set dn='{}', firstname='{}', lastname='{}', gruppe='{}', lockLimit={}, locked={}, autoLock={}, mail='{}' where uid='{}'".format( - user.dn, user.firstname, user.lastname, groups, user.limit, user.locked, user.autoLock, user.mail, user.uid) - print(sql) - 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): - try: - cursor = self.db.connection.cursor() - if 'year' in kwargs: - sql = "select * from creditList where user_id={} and year_date={}".format(user.id, kwargs['year']) - else: - sql = "select * from creditList where user_id={}".format(user.id) - cursor.execute(sql) - data = cursor.fetchall() - if len(data) == 1: - return [CreditList(data[0])] - 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): - try: - cursor = self.db.connection.cursor() - 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): - try: - cursor = self.db.connection.cursor() - cursor.execute("select * from creditList where user_id={} and year_date={}".format(creditlist.user_id, creditlist.year)) - data = cursor.fetchall() - if len(data) == 0: - self.createCreditList(creditlist.user_id, creditlist.year) - 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.feb_guthaben, creditlist.feb_schulden, - creditlist.maer_guthaben, creditlist.maer_schulden, - creditlist.apr_guthaben, creditlist.apr_schulden, - creditlist.mai_guthaben, creditlist.mai_schulden, - creditlist.jun_guthaben, creditlist.jun_schulden, - creditlist.jul_guthaben, creditlist.jul_schulden, - creditlist.aug_guthaben, creditlist.aug_schulden, - creditlist.sep_guthaben, creditlist.sep_schulden, - creditlist.okt_guthaben, creditlist.okt_schulden, - creditlist.nov_guthaben, creditlist.nov_schulden, - creditlist.dez_guthaben, creditlist.dez_schulden, - creditlist.last_schulden, creditlist.year, creditlist.user_id) - print(sql) - cursor = self.db.connection.cursor() - 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): - try: - cursor = self.db.connection.cursor() - cursor.execute("select * from bardienste where user_id={} and startdatetime='{}'".format(user.id, date)) - 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): - try: - cursor = self.db.connection.cursor() - cursor.execute("select * from bardienste where startdatetime='{}'".format(date)) - 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): - try: - cursor = self.db.connection.cursor() - 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): - try: - cursor = self.db.connection.cursor() - cursor.execute("delete from bardienste where user_id={} and startdatetime='{}'".format(user.id, date)) - 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 changeUsername(self, user, newUsername): - try: - cursor= self.db.connection.cursor() - cursor.execute("select * from user where uid='{}'".format(newUsername)) - data = cursor.fetchall() - if data: - raise UsernameExistDB("Username already exists") - else: - cursor.execute("update user set uid='{}' where id={}".format(newUsername, 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 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 DatabaseExecption("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)) - - def setTransactJob(self, from_user, to_user, date): - try: - exists = self.getTransactJob(from_user, to_user, date) - if exists: - raise IntegrityError("job_transact already exists") - cursor = self.db.connection.cursor() - cursor.execute("insert into job_transact (jobdate, from_user_id, to_user_id) VALUES ('{}', {}, {})".format(date, from_user.id, to_user.id)) - self.db.connection.commit() - return self.getTransactJob(from_user, to_user, date) - except Exception as err: - traceback.print_exc() - self.db.connection.rollback() - raise DatabaseExecption("Somethin went wrong with Database: {}".format(err)) - - def getTransactJob(self, from_user, to_user, date): - try: - cursor = self.db.connection.cursor() - cursor.execute("select * from job_transact where from_user_id={} and to_user_id={} and jobdate='{}'".format(from_user.id, to_user.id, date)) - data = cursor.fetchone() - if data: - return {"from_user": from_user, "to_user": to_user, "date": data['jobdate'], "answerd": data['answerd'], "accepted": data['accepted']} - return None - except Exception as err: - traceback.print_exc() - self.db.connection.rollback() - raise DatabaseExecption("Something went worng with Database: {}".format(err)) - - def getAllTransactJobFromUser(self, from_user, date): - try: - cursor = self.db.connection.cursor() - cursor.execute("select * from job_transact where from_user_id={}".format(from_user.id)) - data = cursor.fetchall() - retVal = [] - for transact in data: - if date <= transact['jobdate']: - retVal.append({"from_user": from_user, "to_user": self.getUserById(transact['to_user_id']), "date": transact['jobdate'], "accepted": transact['accepted'], "answerd": transact['answerd']}) - return retVal - except Exception as err: - traceback.print_exc() - self.db.connection.rollback() - raise DatabaseExecption("Somethin went wrong with Database: {}".format(err)) - - def getAllTransactJobToUser(self, to_user, date): - try: - cursor = self.db.connection.cursor() - cursor.execute("select * from job_transact where to_user_id={}".format(to_user.id)) - data = cursor.fetchall() - retVal = [] - for transact in data: - if date <= transact['jobdate']: - retVal.append({"to_user": to_user, "from_user": self.getUserById(transact['from_user_id']), "date": transact['jobdate'], "accepted": transact['accepted'], "answerd": transact['answerd']}) - return retVal - except Exception as err: - traceback.print_exc() - self.db.connection.rollback() - raise DatabaseExecption("Somethin went wrong with Database: {}".format(err)) - - def getTransactJobToUser(self, to_user, date): - try: - cursor = self.db.connection.cursor() - cursor.execute("select * from job_transact where to_user_id={} and jobdate='{}'".format(to_user.id, date)) - data = cursor.fetchone() - if data: - return {"from_user": self.getUserById(data['from_user_id']), "to_user": to_user, "date": data['jobdate'], "accepted": data['accepted'], "answerd": data['answerd']} - else: - return None - except Exception as err: - traceback.print_exc() - self.db.connection.rollback() - raise DatabaseExecption("Somethin went wrong with Database: {}".format(err)) - - def updateTransactJob(self, from_user, to_user, date, accepted): - try: - cursor = self.db.connection.cursor() - cursor.execute("update job_transact set accepted={}, answerd=true where to_user_id={} and jobdate='{}'".format(accepted, to_user.id, date)) - self.db.connection.commit() - return self.getTransactJob(from_user, to_user, date) - except Exception as err: - traceback.print_exc() - self.db.connection.rollback() - raise DatabaseExecption("Somethin went wrong with Database: {}".format(err)) - - def getTransactJobFromUser(self, user, date): - try: - cursor = self.db.connection.cursor() - cursor.execute("select * from job_transact where from_user_id={} and jobdate='{}'".format(user.id, date)) - data = cursor.fetchall() - return [{"from_user": user, "to_user": self.getUserById(transact['to_user_id']), "date": transact['jobdate'], "accepted": transact['accepted'], "answerd": transact['answerd']} for transact in data] - except Exception as err: - traceback.print_exc() - self.db.connection.rollback() - raise DatabaseExecption("Somethin went wrong with Database: {}".format(err)) - - def deleteTransactJob(self, from_user, to_user, date): - try: - cursor = self.db.connection.cursor() - cursor.execute("delete from job_transact where from_user_id={} and to_user_id={} and jobdate='{}'".format(from_user.id, to_user.id, date)) - self.db.connection.commit() - except Exception as err: - traceback.print_exc() - self.db.connection.rollback() - raise DatabaseExecption("Something went wrong with Database: {}".format(err)) - - def getPriceList(self): - try: - cursor = self.db.connection.cursor() - cursor.execute("select * from pricelist") - return cursor.fetchall() - except Exception as err: - traceback.print_exc() - self.db.connection.rollback() - raise DatabaseExecption("Something went wrong with Database: {}".format(err)) - - def getDrinkPrice(self, name): - try: - cursor = self.db.connection.cursor() - if type(name) == str: - sql = "select * from pricelist where name='{}'".format(name) - elif type(name) == int: - sql = 'select * from pricelist where id={}'.format(name) - else: - raise DatabaseExecption("name as no type int or str. name={}, type={}".format(name, type(name))) - cursor.execute(sql) - return cursor.fetchone() - except Exception as err: - traceback.print_exc() - self.db.connection.rollback() - raise DatabaseExecption("Something went wrong with Database: {}".format(err)) - - def setDrinkPrice(self, drink): - try: - cursor = self.db.connection.cursor() - cursor.execute( - "insert into pricelist (name, price, price_big, price_club, price_club_big, premium, premium_club, price_extern_club, type) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s)", - ( - drink['name'], drink['price'], drink['price_big'], drink['price_club'], drink['price_club_big'], - drink['premium'], drink['premium_club'], drink['price_extern_club'], drink['type'])) - self.db.connection.commit() - return self.getDrinkPrice(str(drink['name'])) - except Exception as err: - traceback.print_exc() - self.db.connection.rollback() - raise DatabaseExecption("Something went wrong with Database: {}".format(err)) - - def updateDrinkPrice(self, drink): - try: - cursor = self.db.connection.cursor() - cursor.execute("update pricelist set name=%s, price=%s, price_big=%s, price_club=%s, price_club_big=%s, premium=%s, premium_club=%s, price_extern_club=%s, type=%s where id=%s", - ( - drink['name'], drink['price'], drink['price_big'], drink['price_club'], drink['price_club_big'], drink['premium'], drink['premium_club'], drink['price_extern_club'], drink['type'], drink['id'] - )) - self.db.connection.commit() - return self.getDrinkPrice(drink['id']) - except Exception as err: - traceback.print_exc() - self.db.connection.rollback() - raise DatabaseExecption("Something went wrong with Database: {}".format(err)) - - def deleteDrink(self, drink): - try: - cursor = self.db.connection.cursor() - cursor.execute("delete from pricelist where id={}".format(drink['id'])) - self.db.connection.commit() - except Exception as err: - traceback.print_exc() - self.db.connection.rollback() - raise DatabaseExecption("Something went worng with Database: {}".format(err)) - - def getDrinkType(self, name): - try: - cursor = self.db.connection.cursor() - if type(name) == str: - sql = "select * from drink_type where name='{}'".format(name) - elif type(name) == int: - sql = 'select * from drink_type where id={}'.format(name) - else: - raise DatabaseExecption("name as no type int or str. name={}, type={}".format(name, type(name))) - cursor.execute(sql) - return cursor.fetchone() - except Exception as err: - traceback.print_exc() - self.db.connection.rollback() - raise DatabaseExecption("Something went wrong with Database: {}".format(err)) - - def setDrinkType(self, name): - try: - cursor = self.db.connection.cursor() - cursor.execute("insert into drink_type (name) values ('{}')".format(name)) - self.db.connection.commit() - return self.getDrinkType(name) - except Exception as err: - traceback.print_exc() - self.db.connection.rollback() - raise DatabaseExecption("Something went worng with Database: {}".format(err)) - - def updateDrinkType(self, type): - try: - cursor = self.db.connection.cursor() - cursor.execute("update drink_type set name='{}' where id={}".format(type['name'], type['id'])) - self.db.connection.commit() - return self.getDrinkType(type['id']) - except Exception as err: - traceback.print_exc() - self.db.connection.rollback() - raise DatabaseExecption("Something went worng with Database: {}".format(err)) - - def deleteDrinkType(self, type): - try: - cursor = self.db.connection.cursor() - cursor.execute("delete from drink_type where id={}".format(type['id'])) - self.db.connection.commit() - except Exception as err: - traceback.print_exc() - self.db.connection.rollback() - raise DatabaseExecption("Something went wrong with Database: {}".format(err)) - - def getAllDrinkTypes(self): - try: - cursor = self.db.connection.cursor() - cursor.execute('select * from drink_type') - return cursor.fetchall() - except Exception as err: - traceback.print_exc() - self.db.connection.rollback() - raise DatabaseExecption("Something went worng with Database: {}".format(err)) - - def getAllStatus(self): - try: - cursor = self.db.connection.cursor() - cursor.execute('select * from statusgroup') - return cursor.fetchall() - except Exception as err: - traceback.print_exc() - self.db.connection.rollback() - raise DatabaseExecption("Something went worng with Databes: {}".format(err)) - - def getStatus(self, name): - try: - cursor = self.db.connection.cursor() - if type(name) == str: - sql = "select * from statusgroup where name='{}'".format(name) - elif type(name) == int: - sql = 'select * from statusgroup where id={}'.format(name) - else: - raise DatabaseExecption("name as no type int or str. name={}, type={}".format(name, type(name))) - cursor.execute(sql) - return cursor.fetchone() - except Exception as err: - traceback.print_exc() - self.db.connection.rollback() - raise DatabaseExecption("Something went worng with Databes: {}".format(err)) - - def setStatus(self, name): - try: - cursor = self.db.connection.cursor() - cursor.execute("insert into statusgroup (name) values ('{}')".format(name)) - self.db.connection.commit() - return self.getStatus(name) - except Exception as err: - traceback.print_exc() - self.db.connection.rollback() - raise DatabaseExecption("Something went worng with Databes: {}".format(err)) - - def updateStatus(self, status): - try: - cursor = self.db.connection.cursor() - cursor.execute("update statusgroup set name='{}' where id={}".format(status['name'], status['id'])) - self.db.connection.commit() - return self.getStatus(status['id']) - except Exception as err: - traceback.print_exc() - self.db.connection.rollback() - raise DatabaseExecption("Something went worng with Databes: {}".format(err)) - - def deleteStatus(self, status): - try: - cursor = self.db.connection.cursor() - cursor.execute("delete from statusgroup where id={}".format(status['id'])) - self.db.connection.commit() - except Exception as err: - traceback.print_exc() - self.db.connection.rollback() - raise DatabaseExecption("Something went worng with Databes: {}".format(err)) - - def updateStatusOfUser(self, username, status): - try: - cursor = self.db.connection.cursor() - cursor.execute("update user set statusgroup={} where uid='{}'".format(status['id'], username)) - self.db.connection.commit() - return self.getUser(username) - except Exception as err: - traceback.print_exc() - self.db.connection.rollback() - raise DatabaseExecption("Something went worng with Databes: {}".format(err)) - - def updateVotingOfUser(self, username, voting): - try: - cursor = self.db.connection.cursor() - cursor.execute("update user set voting={} where uid='{}'".format(voting, username)) - self.db.connection.commit() - return self.getUser(username) - except Exception as err: - traceback.print_exc() - self.db.connection.rollback() - raise DatabaseExecption("Something went worng with Databes: {}".format(err)) - - def getAllWorkgroups(self): - try: - cursor = self.db.connection.cursor() - cursor.execute('select * from workgroup') - list = cursor.fetchall() - for item in list: - if item['boss'] != None: - item['boss']=self.getUserById(item['boss'], workgroups=False).toJSON() - return list - except Exception as err: - traceback.print_exc() - self.db.connection.rollback() - raise DatabaseExecption("Something went worng with Databes: {}".format(err)) - - def getWorkgroup(self, name): - try: - cursor = self.db.connection.cursor() - if type(name) == str: - sql = "select * from workgroup where name='{}'".format(name) - elif type(name) == int: - sql = 'select * from workgroup where id={}'.format(name) - else: - raise DatabaseExecption("name as no type int or str. name={}, type={}".format(name, type(name))) - cursor.execute(sql) - retVal = cursor.fetchone() - retVal['boss'] = self.getUserById(retVal['boss'], workgroups=False).toJSON() if retVal['boss'] != None else None - return retVal - except Exception as err: - traceback.print_exc() - self.db.connection.rollback() - raise DatabaseExecption("Something went worng with Databes: {}".format(err)) - - def setWorkgroup(self, name, boss): - try: - cursor = self.db.connection.cursor() - cursor.execute("insert into workgroup (name, boss) values ('{}', {})".format(name, boss['id'])) - self.db.connection.commit() - return self.getWorkgroup(name) - except Exception as err: - traceback.print_exc() - self.db.connection.rollback() - raise DatabaseExecption("Something went worng with Databes: {}".format(err)) - - def updateWorkgroup(self, workgroup): - try: - cursor = self.db.connection.cursor() - cursor.execute("update workgroup set name='{}', boss={} where id={}".format(workgroup['name'], workgroup['boss']['id'], workgroup['id'])) - self.db.connection.commit() - return self.getWorkgroup(workgroup['id']) - except Exception as err: - traceback.print_exc() - self.db.connection.rollback() - raise DatabaseExecption("Something went worng with Databes: {}".format(err)) - - def deleteWorkgroup(self, workgroup): - try: - cursor = self.db.connection.cursor() - cursor.execute("delete from workgroup where id={}".format(workgroup['id'])) - self.db.connection.commit() - except Exception as err: - traceback.print_exc() - self.db.connection.rollback() - raise DatabaseExecption("Something went worng with Databes: {}".format(err)) - - def getWorkgroupsOfUser(self, userid): - try: - cursor = self.db.connection.cursor() - cursor.execute("select * from user_workgroup where user_id={} ".format(userid)) - knots = cursor.fetchall() - retVal = [self.getWorkgroup(knot['workgroup_id']) for knot in knots] - return retVal - except Exception as err: - traceback.print_exc() - self.db.connection.rollback() - raise DatabaseExecption("Something went wrong with Database: {}".format(err)) - - def getUsersOfWorkgroups(self, workgroupid): - try: - cursor = self.db.connection.cursor() - cursor.execute("select * from user_workgroup where workgroup_id={}".format(workgroupid)) - knots = cursor.fetchall() - retVal = [self.getUserById(knot['user_id'], workgroups=False).toJSON() for knot in knots] - return retVal - except Exception as err: - traceback.print_exc() - self.db.connection.rollback() - raise DatabaseExecption("Something went wrong with Database: {}".format(err)) - - def getUserWorkgroup(self, user, workgroup): - try: - cursor = self.db.connection.cursor() - cursor.execute("select * from user_workgroup where workgroup_id={} and user_id={}".format(workgroup['id'], user['id'])) - knot = cursor.fetchone() - retVal = {"workgroup": self.getWorkgroup(workgroup['id']), "user": self.getUserById(user['id'], workgroups=False).toJSON()} - return retVal - except Exception as err: - traceback.print_exc() - self.db.connection.rollback() - raise DatabaseExecption("Something went wrong with Database: {}".format(err)) - - def setUserWorkgroup(self, user, workgroup): - try: - cursor = self.db.connection.cursor() - cursor.execute("insert into user_workgroup (user_id, workgroup_id) VALUES ({}, {})".format(user['id'], workgroup['id'])) - self.db.connection.commit() - return self.getUserWorkgroup(user, workgroup) - except Exception as err: - traceback.print_exc() - self.db.connection.rollback() - raise DatabaseExecption("Something went wrong with Database: {}".format(err)) - - def deleteWorkgroupsOfUser(self, user): - try: - cursor = self.db.connection.cursor() - cursor.execute("delete from user_workgroup where user_id={}".format(user['id'])) - self.db.connection.commit() - except Exception as err: - traceback.print_exc() - self.db.connection.rollback() - raise DatabaseExecption("Something went wrong with Database: {}".format(err)) - -if __name__ == '__main__': - db = DatabaseController() - user = db.getUser('jhille') - db.getCreditListFromUser(user, year=2018) diff --git a/geruecht/controller/databaseController/__init__.py b/geruecht/controller/databaseController/__init__.py new file mode 100644 index 0000000..9ab55bb --- /dev/null +++ b/geruecht/controller/databaseController/__init__.py @@ -0,0 +1,69 @@ +from ..mainController import Singleton +from geruecht import db +from ..databaseController import dbUserController, dbCreditListController, dbJobKindController, dbPricelistController, dbWorkerController, dbWorkgroupController, dbJobInviteController, dbJobRequesController +from geruecht.exceptions import DatabaseExecption +import traceback +from MySQLdb._exceptions import IntegrityError + +class DatabaseController(dbUserController.Base, + dbCreditListController.Base, + dbWorkerController.Base, + dbWorkgroupController.Base, + dbPricelistController.Base, + dbJobKindController.Base, + dbJobInviteController.Base, + dbJobRequesController.Base, + metaclass=Singleton): + ''' + DatabaesController + + Connect to the Database and execute sql-executions + ''' + + def __init__(self): + self.db = db + + 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 DatabaseExecption("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)) + + +if __name__ == '__main__': + db = DatabaseController() + user = db.getUser('jhille') + db.getCreditListFromUser(user, year=2018) diff --git a/geruecht/controller/databaseController/dbCreditListController.py b/geruecht/controller/databaseController/dbCreditListController.py new file mode 100644 index 0000000..f8098b5 --- /dev/null +++ b/geruecht/controller/databaseController/dbCreditListController.py @@ -0,0 +1,66 @@ +import traceback +from datetime import datetime + +from geruecht.exceptions import DatabaseExecption +from geruecht.model.creditList import CreditList + + +class Base: + def getCreditListFromUser(self, user, **kwargs): + try: + cursor = self.db.connection.cursor() + if 'year' in kwargs: + sql = "select * from creditList where user_id={} and year_date={}".format(user.id, kwargs['year']) + else: + sql = "select * from creditList where user_id={}".format(user.id) + cursor.execute(sql) + data = cursor.fetchall() + if len(data) == 1: + return [CreditList(data[0])] + 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): + try: + cursor = self.db.connection.cursor() + 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): + try: + cursor = self.db.connection.cursor() + cursor.execute("select * from creditList where user_id={} and year_date={}".format(creditlist.user_id, creditlist.year)) + data = cursor.fetchall() + if len(data) == 0: + self.createCreditList(creditlist.user_id, creditlist.year) + 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.feb_guthaben, creditlist.feb_schulden, + creditlist.maer_guthaben, creditlist.maer_schulden, + creditlist.apr_guthaben, creditlist.apr_schulden, + creditlist.mai_guthaben, creditlist.mai_schulden, + creditlist.jun_guthaben, creditlist.jun_schulden, + creditlist.jul_guthaben, creditlist.jul_schulden, + creditlist.aug_guthaben, creditlist.aug_schulden, + creditlist.sep_guthaben, creditlist.sep_schulden, + creditlist.okt_guthaben, creditlist.okt_schulden, + creditlist.nov_guthaben, creditlist.nov_schulden, + creditlist.dez_guthaben, creditlist.dez_schulden, + creditlist.last_schulden, creditlist.year, creditlist.user_id) + print(sql) + cursor = self.db.connection.cursor() + 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)) \ No newline at end of file diff --git a/geruecht/controller/databaseController/dbJobInviteController.py b/geruecht/controller/databaseController/dbJobInviteController.py new file mode 100644 index 0000000..91d54ad --- /dev/null +++ b/geruecht/controller/databaseController/dbJobInviteController.py @@ -0,0 +1,84 @@ +import traceback + +from geruecht.exceptions import DatabaseExecption + + +class Base: + def getJobInvite(self, from_user, to_user, date, id=None): + try: + cursor = self.db.connection.cursor() + if id: + cursor.execute("select * from job_invites where id={}".format(id)) + else: + cursor.execute("select * from job_invites where from_user={} and to_user={} and on_date='{}'".format(from_user['id'], to_user['id'], date)) + retVal = cursor.fetchone() + retVal['to_user'] = self.getUserById(retVal['to_user']).toJSON() + retVal['from_user'] = self.getUserById(retVal['from_user']).toJSON() + retVal['on_date'] = {'year': retVal['on_date'].year, 'month': retVal['on_date'].month, 'day': retVal['on_date'].day} + return retVal + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went worng with Datatabase: {}".format(err)) + + def getJobInvitesFromUser(self, from_user, date): + try: + cursor = self.db.connection.cursor() + cursor.execute("select * from job_invites where from_user={} and on_date>='{}'".format(from_user['id'], date)) + retVal = cursor.fetchall() + for item in retVal: + item['from_user'] = from_user + item['to_user'] = self.getUserById(item['to_user']).toJSON() + item['on_date'] = {'year': item['on_date'].year, 'month': item['on_date'].month, 'day': item['on_date'].day} + return retVal + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went worng with Datatabase: {}".format(err)) + + def getJobInvitesToUser(self, to_user, date): + try: + cursor = self.db.connection.cursor() + cursor.execute("select * from job_invites where to_user={} and on_date>='{}'".format(to_user['id'], date)) + retVal = cursor.fetchall() + for item in retVal: + item['from_user'] = self.getUserById(item['from_user']).toJSON() + item['to_user'] = to_user + item['on_date'] = {'year': item['on_date'].year, 'month': item['on_date'].month, 'day': item['on_date'].day} + return retVal + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went worng with Datatabase: {}".format(err)) + + def setJobInvite(self, from_user, to_user, date): + try: + cursor = self.db.connection.cursor() + cursor.execute("insert into job_invites (from_user, to_user, on_date) values ({}, {}, '{}')".format(from_user['id'], to_user['id'], date)) + self.db.connection.commit() + return self.getJobInvite(from_user, to_user, date) + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went worng with Datatabase: {}".format(err)) + + def updateJobInvite(self, jobinvite): + try: + cursor = self.db.connection.cursor() + cursor.execute("update job_invites set watched={} where id={}".format(jobinvite['watched'], jobinvite['id'])) + self.db.connection.commit() + return self.getJobInvite(None, None, None, jobinvite['id']) + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went worng with Datatabase: {}".format(err)) + + def deleteJobInvite(self, jobinvite): + try: + cursor = self.db.connection.cursor() + cursor.execute("delete from job_invites where id={}".format(jobinvite['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)) \ No newline at end of file diff --git a/geruecht/controller/databaseController/dbJobKindController.py b/geruecht/controller/databaseController/dbJobKindController.py new file mode 100644 index 0000000..c243f0d --- /dev/null +++ b/geruecht/controller/databaseController/dbJobKindController.py @@ -0,0 +1,112 @@ +import traceback + +from geruecht.exceptions import DatabaseExecption + + +class Base: + def getAllJobKinds(self): + try: + cursor = self.db.connection.cursor() + cursor.execute('select * from job_kind') + list = cursor.fetchall() + for item in list: + item['workgroup'] = self.getWorkgroup(item['workgroup']) if item['workgroup'] != None else None + return list + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went worng with Databes: {}".format(err)) + + def getJobKind(self, name): + try: + cursor = self.db.connection.cursor() + if type(name) == str: + sql = "select * from job_kind where name='{}'".format(name) + elif type(name) == int: + sql = 'select * from job_kind where id={}'.format(name) + else: + raise DatabaseExecption("name as no type int or str. name={}, type={}".format(name, type(name))) + cursor.execute(sql) + retVal = cursor.fetchone() + retVal['workgroup'] = self.getWorkgroup(retVal['workgroup']) if retVal['workgroup'] != None else None + return retVal + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went worng with Databes: {}".format(err)) + + def setJobKind(self, name, workgroup_id): + try: + cursor = self.db.connection.cursor() + cursor.execute("insert into job_kind (name, workgroup) values ('{}', {})".format(name, workgroup_id if workgroup_id != None else 'NULL')) + self.db.connection.commit() + return self.getJobKind(name) + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went worng with Databes: {}".format(err)) + + def updateJobKind(self, jobkind): + try: + cursor = self.db.connection.cursor() + cursor.execute("update job_kind set name='{}', workgroup={} where id={}".format(jobkind['name'], jobkind['workgroup']['id'] if jobkind['workgroup'] != None else 'NULL', jobkind['id'])) + self.db.connection.commit() + return self.getJobKind(jobkind['id']) + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went worng with Databes: {}".format(err)) + + def deleteJobKind(self, jobkind): + try: + cursor = self.db.connection.cursor() + cursor.execute("delete from job_kind where id={}".format(jobkind['id'])) + self.db.connection.commit() + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went worng with Databes: {}".format(err)) + + def setJobKindDates(self, date, jobkind, maxpersons): + try: + cursor = self.db.connection.cursor() + cursor.execute("insert into job_kind_dates (daydate, job_kind, maxpersons) values ('{}', {}, {})".format(date, jobkind['id'] if jobkind != None else 'NULL', maxpersons)) + self.db.connection.commit() + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went worng with Databes: {}".format(err)) + + def updateJobKindDates(self, jobkindDate): + try: + cursor = self.db.connection.cursor() + cursor.execute("update job_kind_dates set job_kind={}, maxpersons='{}' where id={}".format(jobkindDate['job_kind']['id'] if jobkindDate['job_kind'] != None else 'NULL', jobkindDate['maxpersons'], jobkindDate['id'])) + self.db.connection.commit() + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went wrong with Database: {}".format(err)) + + def getJobKindDates(self, date): + try: + cursor = self.db.connection.cursor() + cursor.execute("select * from job_kind_dates where daydate='{}'".format(date)) + list = cursor.fetchall() + for item in list: + item['job_kind'] = self.getJobKind(item['job_kind']) if item['job_kind'] != None else None + item['daydate'] = {'year': item['daydate'].year, 'month': item['daydate'].month, 'day': item['daydate'].day} + return list + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went worng with Databes: {}".format(err)) + + def deleteJobKindDates(self, jobkinddates): + try: + cursor = self.db.connection.cursor() + cursor.execute("delete from job_kind_dates where id={}".format(jobkinddates['id'])) + self.db.connection.commit() + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went worng with Databes: {}".format(err)) \ No newline at end of file diff --git a/geruecht/controller/databaseController/dbJobRequesController.py b/geruecht/controller/databaseController/dbJobRequesController.py new file mode 100644 index 0000000..8f77752 --- /dev/null +++ b/geruecht/controller/databaseController/dbJobRequesController.py @@ -0,0 +1,97 @@ +import traceback + +from geruecht.exceptions import DatabaseExecption + + +class Base: + def getJobRequest(self, from_user, to_user, date, id=None): + try: + cursor = self.db.connection.cursor() + if id: + cursor.execute("select * from job_request where id={}".format(id)) + else: + cursor.execute("select * from job_request where from_user={} and to_user={} and on_date='{}'".format(from_user['id'], to_user['id'], date)) + retVal = cursor.fetchone() + retVal['to_user'] = self.getUserById(retVal['to_user']).toJSON() + retVal['from_user'] = self.getUserById(retVal['from_user']).toJSON() + retVal['on_date'] = {'year': retVal['on_date'].year, 'month': retVal['on_date'].month, 'day': retVal['on_date'].day} + retVal['job_kind'] = self.getJobKind(retVal['job_kind']) + return retVal + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went worng with Datatabase: {}".format(err)) + + def getJobRequestsFromUser(self, from_user, date): + try: + cursor = self.db.connection.cursor() + cursor.execute("select * from job_request where from_user={} and on_date>='{}'".format(from_user['id'], date)) + retVal = cursor.fetchall() + for item in retVal: + item['from_user'] = from_user + item['to_user'] = self.getUserById(item['to_user']).toJSON() + item['on_date'] = {'year': item['on_date'].year, 'month': item['on_date'].month, 'day': item['on_date'].day} + item['job_kind'] = self.getJobKind(item['job_kind']) + return retVal + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went worng with Datatabase: {}".format(err)) + + def getJobRequestsToUser(self, to_user, date): + try: + cursor = self.db.connection.cursor() + cursor.execute("select * from job_request where to_user={} and on_date>='{}'".format(to_user['id'], date)) + retVal = cursor.fetchall() + for item in retVal: + item['from_user'] = self.getUserById(item['from_user']).toJSON() + item['to_user'] = to_user + item['on_date'] = {'year': item['on_date'].year, 'month': item['on_date'].month, 'day': item['on_date'].day} + item['job_kind'] = self.getJobKind(item['job_kind']) + return retVal + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went worng with Datatabase: {}".format(err)) + + def setJobRequest(self, from_user, to_user, date, job_kind): + try: + cursor = self.db.connection.cursor() + cursor.execute("insert into job_request (from_user, to_user, on_date, job_kind) values ({}, {}, '{}', {})".format(from_user['id'], to_user['id'], date, job_kind['id'])) + self.db.connection.commit() + return self.getJobRequest(from_user, to_user, date) + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went worng with Datatabase: {}".format(err)) + + def updateJobRequest(self, jobrequest): + try: + cursor = self.db.connection.cursor() + cursor.execute("update job_request set watched={}, answered={}, accepted={} where id={}".format(jobrequest['watched'], jobrequest['answered'], jobrequest['accepted'], jobrequest['id'])) + self.db.connection.commit() + return self.getJobRequest(None, None, None, jobrequest['id']) + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went worng with Datatabase: {}".format(err)) + + def updateAllJobRequest(self, jobrequest): + try: + cursor = self.db.connection.cursor() + cursor.execute("update job_request set answered={} where from_user={} and on_date='{}'".format(jobrequest['answered'], jobrequest['from_user']['id'], jobrequest['on_date'])) + 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 deleteJobRequest(self, jobrequest): + try: + cursor = self.db.connection.cursor() + cursor.execute("delete from job_request where id={}".format(jobrequest['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)) \ No newline at end of file diff --git a/geruecht/controller/databaseController/dbPricelistController.py b/geruecht/controller/databaseController/dbPricelistController.py new file mode 100644 index 0000000..2b0c749 --- /dev/null +++ b/geruecht/controller/databaseController/dbPricelistController.py @@ -0,0 +1,128 @@ +import traceback + +from geruecht.exceptions import DatabaseExecption + + +class Base: + def getPriceList(self): + try: + cursor = self.db.connection.cursor() + cursor.execute("select * from pricelist") + return cursor.fetchall() + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went wrong with Database: {}".format(err)) + + def getDrinkPrice(self, name): + try: + cursor = self.db.connection.cursor() + if type(name) == str: + sql = "select * from pricelist where name='{}'".format(name) + elif type(name) == int: + sql = 'select * from pricelist where id={}'.format(name) + else: + raise DatabaseExecption("name as no type int or str. name={}, type={}".format(name, type(name))) + cursor.execute(sql) + return cursor.fetchone() + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went wrong with Database: {}".format(err)) + + def setDrinkPrice(self, drink): + try: + cursor = self.db.connection.cursor() + cursor.execute( + "insert into pricelist (name, price, price_big, price_club, price_club_big, premium, premium_club, price_extern_club, type) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s)", + ( + drink['name'], drink['price'], drink['price_big'], drink['price_club'], drink['price_club_big'], + drink['premium'], drink['premium_club'], drink['price_extern_club'], drink['type'])) + self.db.connection.commit() + return self.getDrinkPrice(str(drink['name'])) + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went wrong with Database: {}".format(err)) + + def updateDrinkPrice(self, drink): + try: + cursor = self.db.connection.cursor() + cursor.execute("update pricelist set name=%s, price=%s, price_big=%s, price_club=%s, price_club_big=%s, premium=%s, premium_club=%s, price_extern_club=%s, type=%s where id=%s", + ( + drink['name'], drink['price'], drink['price_big'], drink['price_club'], drink['price_club_big'], drink['premium'], drink['premium_club'], drink['price_extern_club'], drink['type'], drink['id'] + )) + self.db.connection.commit() + return self.getDrinkPrice(drink['id']) + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went wrong with Database: {}".format(err)) + + def deleteDrink(self, drink): + try: + cursor = self.db.connection.cursor() + cursor.execute("delete from pricelist where id={}".format(drink['id'])) + self.db.connection.commit() + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went worng with Database: {}".format(err)) + + def getDrinkType(self, name): + try: + cursor = self.db.connection.cursor() + if type(name) == str: + sql = "select * from drink_type where name='{}'".format(name) + elif type(name) == int: + sql = 'select * from drink_type where id={}'.format(name) + else: + raise DatabaseExecption("name as no type int or str. name={}, type={}".format(name, type(name))) + cursor.execute(sql) + return cursor.fetchone() + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went wrong with Database: {}".format(err)) + + def setDrinkType(self, name): + try: + cursor = self.db.connection.cursor() + cursor.execute("insert into drink_type (name) values ('{}')".format(name)) + self.db.connection.commit() + return self.getDrinkType(name) + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went worng with Database: {}".format(err)) + + def updateDrinkType(self, type): + try: + cursor = self.db.connection.cursor() + cursor.execute("update drink_type set name='{}' where id={}".format(type['name'], type['id'])) + self.db.connection.commit() + return self.getDrinkType(type['id']) + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went worng with Database: {}".format(err)) + + def deleteDrinkType(self, type): + try: + cursor = self.db.connection.cursor() + cursor.execute("delete from drink_type where id={}".format(type['id'])) + self.db.connection.commit() + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went wrong with Database: {}".format(err)) + + def getAllDrinkTypes(self): + try: + cursor = self.db.connection.cursor() + cursor.execute('select * from drink_type') + return cursor.fetchall() + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went worng with Database: {}".format(err)) \ No newline at end of file diff --git a/geruecht/controller/databaseController/dbUserController.py b/geruecht/controller/databaseController/dbUserController.py new file mode 100644 index 0000000..08f2d9d --- /dev/null +++ b/geruecht/controller/databaseController/dbUserController.py @@ -0,0 +1,197 @@ +from geruecht.exceptions import DatabaseExecption, UsernameExistDB +from geruecht.model.user import User +import traceback + +class Base: + def getAllUser(self, extern=False, workgroups=True): + try: + cursor = self.db.connection.cursor() + cursor.execute("select * from user") + data = cursor.fetchall() + + if data: + retVal = [] + for value in data: + if extern and value['uid'] == 'extern': + continue + user = User(value) + creditLists = self.getCreditListFromUser(user) + user.initGeruechte(creditLists) + if workgroups: + user.workgroups = self.getWorkgroupsOfUser(user.id) + retVal.append(user) + 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, workgroups=True): + try: + retVal = None + cursor = self.db.connection.cursor() + cursor.execute("select * from user where uid='{}'".format(username)) + data = cursor.fetchone() + if data: + retVal = User(data) + creditLists = self.getCreditListFromUser(retVal) + retVal.initGeruechte(creditLists) + if workgroups: + retVal.workgroups = self.getWorkgroupsOfUser(retVal.id) + 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, workgroups=True): + try: + retVal = None + cursor = self.db.connection.cursor() + cursor.execute("select * from user where id={}".format(id)) + data = cursor.fetchone() + if data: + retVal = User(data) + creditLists = self.getCreditListFromUser(retVal) + retVal.initGeruechte(creditLists) + if workgroups: + retVal.workgroups = self.getWorkgroupsOfUser(retVal.id) + 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): + retVal = '' + print('groups: {}'.format(groups)) + if groups: + for group in groups: + if len(retVal) != 0: + retVal += ',' + retVal += group + return retVal + + + def insertUser(self, user): + try: + cursor = self.db.connection.cursor() + groups = self._convertGroupToString(user.group) + cursor.execute("insert into user (uid, dn, firstname, lastname, gruppe, lockLimit, locked, autoLock, mail) VALUES ('{}','{}','{}','{}','{}',{},{},{},'{}')".format( + 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): + try: + cursor = self.db.connection.cursor() + print('uid: {}; group: {}'.format(user.uid, user.group)) + groups = self._convertGroupToString(user.group) + sql = "update user set dn='{}', firstname='{}', lastname='{}', gruppe='{}', lockLimit={}, locked={}, autoLock={}, mail='{}' where uid='{}'".format( + user.dn, user.firstname, user.lastname, groups, user.limit, user.locked, user.autoLock, user.mail, user.uid) + print(sql) + 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 changeUsername(self, user, newUsername): + try: + cursor= self.db.connection.cursor() + cursor.execute("select * from user where uid='{}'".format(newUsername)) + data = cursor.fetchall() + if data: + raise UsernameExistDB("Username already exists") + else: + cursor.execute("update user set uid='{}' where id={}".format(newUsername, 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 getAllStatus(self): + try: + cursor = self.db.connection.cursor() + cursor.execute('select * from statusgroup') + return cursor.fetchall() + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went worng with Databes: {}".format(err)) + + def getStatus(self, name): + try: + cursor = self.db.connection.cursor() + if type(name) == str: + sql = "select * from statusgroup where name='{}'".format(name) + elif type(name) == int: + sql = 'select * from statusgroup where id={}'.format(name) + else: + raise DatabaseExecption("name as no type int or str. name={}, type={}".format(name, type(name))) + cursor.execute(sql) + return cursor.fetchone() + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went worng with Databes: {}".format(err)) + + def setStatus(self, name): + try: + cursor = self.db.connection.cursor() + cursor.execute("insert into statusgroup (name) values ('{}')".format(name)) + self.db.connection.commit() + return self.getStatus(name) + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went worng with Databes: {}".format(err)) + + def updateStatus(self, status): + try: + cursor = self.db.connection.cursor() + cursor.execute("update statusgroup set name='{}' where id={}".format(status['name'], status['id'])) + self.db.connection.commit() + return self.getStatus(status['id']) + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went worng with Databes: {}".format(err)) + + def deleteStatus(self, status): + try: + cursor = self.db.connection.cursor() + cursor.execute("delete from statusgroup where id={}".format(status['id'])) + self.db.connection.commit() + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went worng with Databes: {}".format(err)) + + def updateStatusOfUser(self, username, status): + try: + cursor = self.db.connection.cursor() + cursor.execute("update user set statusgroup={} where uid='{}'".format(status['id'], username)) + self.db.connection.commit() + return self.getUser(username) + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went worng with Databes: {}".format(err)) + + def updateVotingOfUser(self, username, voting): + try: + cursor = self.db.connection.cursor() + cursor.execute("update user set voting={} where uid='{}'".format(voting, username)) + self.db.connection.commit() + return self.getUser(username) + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went worng with Databes: {}".format(err)) \ No newline at end of file diff --git a/geruecht/controller/databaseController/dbWorkerController.py b/geruecht/controller/databaseController/dbWorkerController.py new file mode 100644 index 0000000..7a2e917 --- /dev/null +++ b/geruecht/controller/databaseController/dbWorkerController.py @@ -0,0 +1,77 @@ +import traceback +from datetime import timedelta + +from geruecht.exceptions import DatabaseExecption + + +class Base: + def getWorker(self, user, date): + try: + cursor = self.db.connection.cursor() + cursor.execute("select * from bardienste where user_id={} and startdatetime='{}'".format(user.id, date)) + 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}, "job_kind": self.getJobKind(data['job_kind']) if data['job_kind'] != None else None} 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): + try: + cursor = self.db.connection.cursor() + cursor.execute("select * from bardienste where startdatetime='{}'".format(date)) + data = cursor.fetchall() + retVal = [] + # for work in data: + # 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} + # job_kind = self.getJobKind(work['job_kind']) if work['job_kind'] != None else None + # retVal.append({'user': user, 'startdatetime': startdatetime, 'enddatetime': enddatetime, 'start': start, 'job_kind': job_kind}) + # return retVal + 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}, "job_kind": self.getJobKind(work['job_kind']) if work['job_kind'] != None else None} 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, job_kind=None): + try: + cursor = self.db.connection.cursor() + cursor.execute("insert into bardienste (user_id, startdatetime, enddatetime, job_kind) values ({},'{}','{}', {})".format(user.id, date, date + timedelta(days=1), job_kind['id'] if job_kind != None else 'NULL')) + 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 changeWorker(self, from_user, to_user, date): + try: + cursor = self.db.connection.cursor() + cursor.execute("update bardienste set user_id={} where user_id={} and startdatetime='{}'".format(to_user['id'], from_user['id'], date)) + 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 deleteAllWorkerWithJobKind(self, date, job_kind): + try: + cursor = self.db.connection.cursor() + cursor.execute("delete from bardienste where startdatetime='{}' and job_kind={}".format(date, job_kind['id'])) + self.db.connection.commit() + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went wrong with Database: {}".format(err)) + + def deleteWorker(self, user, date): + try: + cursor = self.db.connection.cursor() + cursor.execute("delete from bardienste where user_id={} and startdatetime='{}'".format(user.id, date)) + self.db.connection.commit() + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went worng with Datatabase: {}".format(err)) \ No newline at end of file diff --git a/geruecht/controller/databaseController/dbWorkgroupController.py b/geruecht/controller/databaseController/dbWorkgroupController.py new file mode 100644 index 0000000..c67f5d2 --- /dev/null +++ b/geruecht/controller/databaseController/dbWorkgroupController.py @@ -0,0 +1,126 @@ +import traceback + +from geruecht.exceptions import DatabaseExecption + + +class Base: + def getAllWorkgroups(self): + try: + cursor = self.db.connection.cursor() + cursor.execute('select * from workgroup') + list = cursor.fetchall() + for item in list: + if item['boss'] != None: + item['boss']=self.getUserById(item['boss'], workgroups=False).toJSON() + return list + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went worng with Databes: {}".format(err)) + + def getWorkgroup(self, name): + try: + cursor = self.db.connection.cursor() + if type(name) == str: + sql = "select * from workgroup where name='{}'".format(name) + elif type(name) == int: + sql = 'select * from workgroup where id={}'.format(name) + else: + raise DatabaseExecption("name as no type int or str. name={}, type={}".format(name, type(name))) + cursor.execute(sql) + retVal = cursor.fetchone() + retVal['boss'] = self.getUserById(retVal['boss'], workgroups=False).toJSON() if retVal['boss'] != None else None + return retVal + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went worng with Databes: {}".format(err)) + + def setWorkgroup(self, name, boss): + try: + cursor = self.db.connection.cursor() + cursor.execute("insert into workgroup (name, boss) values ('{}', {})".format(name, boss['id'])) + self.db.connection.commit() + return self.getWorkgroup(name) + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went worng with Databes: {}".format(err)) + + def updateWorkgroup(self, workgroup): + try: + cursor = self.db.connection.cursor() + cursor.execute("update workgroup set name='{}', boss={} where id={}".format(workgroup['name'], workgroup['boss']['id'], workgroup['id'])) + self.db.connection.commit() + return self.getWorkgroup(workgroup['id']) + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went worng with Databes: {}".format(err)) + + def deleteWorkgroup(self, workgroup): + try: + cursor = self.db.connection.cursor() + cursor.execute("delete from workgroup where id={}".format(workgroup['id'])) + self.db.connection.commit() + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went worng with Databes: {}".format(err)) + + def getWorkgroupsOfUser(self, userid): + try: + cursor = self.db.connection.cursor() + cursor.execute("select * from user_workgroup where user_id={} ".format(userid)) + knots = cursor.fetchall() + retVal = [self.getWorkgroup(knot['workgroup_id']) for knot in knots] + return retVal + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went wrong with Database: {}".format(err)) + + def getUsersOfWorkgroups(self, workgroupid): + try: + cursor = self.db.connection.cursor() + cursor.execute("select * from user_workgroup where workgroup_id={}".format(workgroupid)) + knots = cursor.fetchall() + retVal = [self.getUserById(knot['user_id'], workgroups=False).toJSON() for knot in knots] + return retVal + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went wrong with Database: {}".format(err)) + + def getUserWorkgroup(self, user, workgroup): + try: + cursor = self.db.connection.cursor() + cursor.execute("select * from user_workgroup where workgroup_id={} and user_id={}".format(workgroup['id'], user['id'])) + knot = cursor.fetchone() + retVal = {"workgroup": self.getWorkgroup(workgroup['id']), "user": self.getUserById(user['id'], workgroups=False).toJSON()} + return retVal + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went wrong with Database: {}".format(err)) + + def setUserWorkgroup(self, user, workgroup): + try: + cursor = self.db.connection.cursor() + cursor.execute("insert into user_workgroup (user_id, workgroup_id) VALUES ({}, {})".format(user['id'], workgroup['id'])) + self.db.connection.commit() + return self.getUserWorkgroup(user, workgroup) + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went wrong with Database: {}".format(err)) + + def deleteWorkgroupsOfUser(self, user): + try: + cursor = self.db.connection.cursor() + cursor.execute("delete from user_workgroup where user_id={}".format(user['id'])) + self.db.connection.commit() + except Exception as err: + traceback.print_exc() + self.db.connection.rollback() + raise DatabaseExecption("Something went wrong with Database: {}".format(err)) \ No newline at end of file diff --git a/geruecht/controller/emailController.py b/geruecht/controller/emailController.py index e7f269a..190ac07 100644 --- a/geruecht/controller/emailController.py +++ b/geruecht/controller/emailController.py @@ -4,23 +4,22 @@ from email.mime.multipart import MIMEMultipart from email.mime.text import MIMEText from email.header import Header from geruecht.logger import getDebugLogger +from . import mailConfig debug = getDebugLogger() class EmailController(): - def __init__(self, smtpServer, user, passwd, crypt, port=587, email=""): + def __init__(self): debug.info("init email controller") - self.smtpServer = smtpServer - self.port = port - self.user = user - self.passwd = passwd - self.crypt = crypt - if email: - self.email = email - else: - self.email = user - debug.debug("smtpServer is {{ {} }}, port is {{ {} }}, user is {{ {} }}, crypt is {{ {} }}, email is {{ {} }}".format(smtpServer, port, user, crypt, self.email)) + self.smtpServer = mailConfig['URL'] + self.port = mailConfig['port'] + self.user = mailConfig['user'] + self.passwd = mailConfig['passwd'] + self.crypt = mailConfig['crypt'] + self.email = mailConfig['email'] + + debug.debug("smtpServer is {{ {} }}, port is {{ {} }}, user is {{ {} }}, crypt is {{ {} }}, email is {{ {} }}".format(self.smtpServer, self.port, self.user, self.crypt, self.email)) def __connect__(self): debug.info('connect to email server') diff --git a/geruecht/controller/ldapController.py b/geruecht/controller/ldapController.py index 0692f1c..ca204b2 100644 --- a/geruecht/controller/ldapController.py +++ b/geruecht/controller/ldapController.py @@ -71,6 +71,8 @@ class LDAPController(metaclass=Singleton): main_group_number = self.ldap.connection.response[0]['attributes']['gidNumber'] debug.debug("main group number is {{ {} }}".format(main_group_number)) if main_group_number: + if type(main_group_number) is list: + main_group_number = main_group_number[0] self.ldap.connection.search('ou=group,{}'.format(self.dn), '(gidNumber={})'.format(main_group_number), attributes=['cn']) group_name = self.ldap.connection.response[0]['attributes']['cn'][0] debug.debug("group name is {{ {} }}".format(group_name)) diff --git a/geruecht/controller/mainController/__init__.py b/geruecht/controller/mainController/__init__.py new file mode 100644 index 0000000..41f2a7f --- /dev/null +++ b/geruecht/controller/mainController/__init__.py @@ -0,0 +1,150 @@ +from .. import Singleton, mailConfig +import geruecht.controller.databaseController as dc +import geruecht.controller.ldapController as lc +import geruecht.controller.emailController as ec +from geruecht.model.user import User +from datetime import datetime, timedelta +from geruecht.logger import getDebugLogger +from ..mainController import mainJobKindController, mainCreditListController, mainPricelistController, mainUserController, mainWorkerController, mainWorkgroupController, mainJobInviteController, mainJobRequestController + +db = dc.DatabaseController() +ldap = lc.LDAPController() +emailController = ec.EmailController() + +debug = getDebugLogger() + + +class MainController(mainJobKindController.Base, + mainCreditListController.Base, + mainPricelistController.Base, + mainUserController.Base, + mainWorkerController.Base, + mainWorkgroupController.Base, + mainJobInviteController.Base, + mainJobRequestController.Base, + metaclass=Singleton): + + def __init__(self): + debug.debug("init UserController") + pass + + def setLockedDay(self, date, locked, hard=False): + debug.info( + "set day locked on {{ {} }} with state {{ {} }}".format(date, locked)) + retVal = db.setLockedDay(date.date(), locked, hard) + debug.debug("seted day locked is {{ {} }}".format(retVal)) + return retVal + + def getLockedDays(self, from_date, to_date): + debug.info("get locked days from {{ {} }} to {{ {} }}".format( + from_date.date(), to_date.date())) + oneDay = timedelta(1) + delta = to_date.date() - from_date.date() + retVal = [] + startdate = from_date - oneDay + for _ in range(delta.days + 1): + startdate += oneDay + lockday = self.getLockedDay(startdate) + retVal.append(lockday) + debug.debug("lock days are {{ {} }}".format(retVal)) + return retVal + + def getLockedDaysFromList(self, date_list): + debug.info("get locked days from list {{ {} }}".format(date_list)) + retVal = [] + for on_date in date_list: + day = datetime(on_date['on_date']['year'], on_date['on_date']['month'], on_date['on_date']['day'], 12) + retVal.append(self.getLockedDay(day)) + return retVal + + def getLockedDay(self, date): + debug.info("get locked day on {{ {} }}".format(date)) + now = datetime.now() + debug.debug("now is {{ {} }}".format(now)) + oldMonth = False + debug.debug("check if date old month or current month") + for i in range(1, 8): + if datetime(now.year, now.month, i).weekday() == 2: + if now.day < i: + oldMonth = True + break + debug.debug("oldMonth is {{ {} }}".format(oldMonth)) + lockedYear = now.year + lockedMonth = now.month if now.month < now.month else now.month - \ + 1 if oldMonth else now.month + endDay = 1 + debug.debug("calculate end day of month") + lockedYear = lockedYear if lockedMonth != 12 else (lockedYear + 1) + lockedMonth = (lockedMonth + 1) if lockedMonth != 12 else 1 + for i in range(1, 8): + nextMonth = datetime(lockedYear, lockedMonth, i) + if nextMonth.weekday() == 2: + endDay = i + break + + monthLockedEndDate = datetime( + lockedYear, lockedMonth, endDay) - timedelta(1) + debug.debug("get lock day from database") + retVal = db.getLockedDay(date.date()) + if not retVal: + debug.debug( + "lock day not exists, retVal is {{ {} }}".format(retVal)) + if date.date() <= monthLockedEndDate.date(): + debug.debug("lock day {{ {} }}".format(date.date())) + self.setLockedDay(date, True) + retVal = db.getLockedDay(date.date()) + else: + retVal = {"daydate": date.date(), "locked": False} + debug.debug("locked day is {{ {} }}".format(retVal)) + return retVal + + def __updateDataFromLDAP(self, user): + debug.info("update data from ldap for user {{ {} }}".format(user)) + groups = ldap.getGroup(user.uid) + debug.debug("ldap gorups are {{ {} }}".format(groups)) + user_data = ldap.getUserData(user.uid) + debug.debug("ldap data is {{ {} }}".format(user_data)) + user_data['gruppe'] = groups + user_data['group'] = groups + user.updateData(user_data) + db.updateUser(user) + + def checkBarUser(self, user): + debug.info("check if user {{ {} }} is baruser") + date = datetime.now() + zero = date.replace(hour=0, minute=0, second=0, microsecond=0) + end = zero + timedelta(hours=12) + startdatetime = date.replace( + hour=12, minute=0, second=0, microsecond=0) + if date > zero and end > date: + startdatetime = startdatetime - timedelta(days=1) + enddatetime = startdatetime + timedelta(days=1) + debug.debug("startdatetime is {{ {} }} and enddatetime is {{ {} }}".format( + startdatetime, end)) + result = False + if date >= startdatetime and date < enddatetime: + result = db.getWorker(user, startdatetime) + debug.debug("worker is {{ {} }}".format(result)) + return True if result else False + + def sendMail(self, username): + debug.info("send mail to user {{ {} }}".format(username)) + if type(username) == User: + user = username + if type(username) == str: + user = db.getUser(username) + retVal = emailController.sendMail(user) + debug.debug("send mail is {{ {} }}".format(retVal)) + return retVal + + def sendAllMail(self): + debug.info("send mail to all user") + retVal = [] + users = db.getAllUser() + debug.debug("users are {{ {} }}".format(users)) + for user in users: + retVal.append(self.sendMail(user)) + debug.debug("send mails are {{ {} }}".format(retVal)) + return retVal + + diff --git a/geruecht/controller/mainController/mainCreditListController.py b/geruecht/controller/mainController/mainCreditListController.py new file mode 100644 index 0000000..f6e24c2 --- /dev/null +++ b/geruecht/controller/mainController/mainCreditListController.py @@ -0,0 +1,83 @@ +from datetime import datetime + +import geruecht.controller.databaseController as dc +import geruecht.controller.emailController as ec +from geruecht.logger import getDebugLogger + +db = dc.DatabaseController() +emailController = ec.EmailController() +debug = getDebugLogger() + +class Base: + def autoLock(self, user): + debug.info("start autolock of user {{ {} }}".format(user)) + if user.autoLock: + debug.debug("autolock is active") + credit = user.getGeruecht(year=datetime.now().year).getSchulden() + limit = -1*user.limit + if credit <= limit: + debug.debug( + "credit {{ {} }} is more than user limit {{ {} }}".format(credit, limit)) + debug.debug("lock user") + user.updateData({'locked': True}) + debug.debug("send mail to user") + emailController.sendMail(user) + else: + debug.debug( + "cretid {{ {} }} is less than user limit {{ {} }}".format(credit, limit)) + debug.debug("unlock user") + user.updateData({'locked': False}) + db.updateUser(user) + + def addAmount(self, username, amount, year, month, finanzer=False): + debug.info("add amount {{ {} }} to user {{ {} }} no month {{ {} }}, year {{ {} }}".format( + amount, username, month, year)) + user = self.getUser(username) + debug.debug("user is {{ {} }}".format(user)) + if user.uid == 'extern': + debug.debug("user is extern user, so exit add amount") + return + if not user.locked or finanzer: + debug.debug("user is not locked {{ {} }} or is finanzer execution {{ {} }}".format( + user.locked, finanzer)) + user.addAmount(amount, year=year, month=month) + creditLists = user.updateGeruecht() + debug.debug("creditList is {{ {} }}".format(creditLists)) + for creditList in creditLists: + debug.debug("update creditlist {{ {} }}".format(creditList)) + db.updateCreditList(creditList) + debug.debug("do autolock") + self.autoLock(user) + retVal = user.getGeruecht(year) + debug.debug("updated creditlists is {{ {} }}".format(retVal)) + return retVal + + def addCredit(self, username, credit, year, month): + debug.info("add credit {{ {} }} to user {{ {} }} on month {{ {} }}, year {{ {} }}".format( + credit, username, month, year)) + user = self.getUser(username) + debug.debug("user is {{ {} }}".format(user)) + if user.uid == 'extern': + debug.debug("user is extern user, so exit add credit") + return + user.addCredit(credit, year=year, month=month) + creditLists = user.updateGeruecht() + debug.debug("creditlists are {{ {} }}".format(creditLists)) + for creditList in creditLists: + debug.debug("update creditlist {{ {} }}".format(creditList)) + db.updateCreditList(creditList) + debug.debug("do autolock") + self.autoLock(user) + retVal = user.getGeruecht(year) + debug.debug("updated creditlists are {{ {} }}".format(retVal)) + return retVal + + def __updateGeruechte(self, user): + debug.debug("update creditlists") + user.getGeruecht(datetime.now().year) + creditLists = user.updateGeruecht() + debug.debug("creditlists are {{ {} }}".format(creditLists)) + if user.getGeruecht(datetime.now().year).getSchulden() != 0: + for creditList in creditLists: + debug.debug("update creditlist {{ {} }}".format(creditList)) + db.updateCreditList(creditList) \ No newline at end of file diff --git a/geruecht/controller/mainController/mainJobInviteController.py b/geruecht/controller/mainController/mainJobInviteController.py new file mode 100644 index 0000000..47a1ea0 --- /dev/null +++ b/geruecht/controller/mainController/mainJobInviteController.py @@ -0,0 +1,38 @@ +from datetime import date + +import geruecht.controller.databaseController as dc +from geruecht import getDebugLogger + +db = dc.DatabaseController() +debug = getDebugLogger() + +class Base: + def getJobInvites(self, from_user, to_user, date): + debug.info("get JobInvites from_user {{ {} }} to_user {{ {} }} on date {{ {} }}".format(from_user, to_user, date)) + if from_user is None: + retVal = db.getJobInvitesToUser(to_user, date) + elif to_user is None: + retVal = db.getJobInvitesFromUser(from_user, date) + else: + raise Exception("from_user {{ {} }} and to_user {{ {} }} are None".format(from_user, to_user)) + return retVal + + def setJobInvites(self, data): + debug.info("set new JobInvites data {{ {} }}".format(data)) + retVal = [] + for jobInvite in data: + from_user = jobInvite['from_user'] + to_user = jobInvite['to_user'] + on_date = date(jobInvite['date']['year'], jobInvite['date']['month'], jobInvite['date']['day']) + debug.info("set new JobInvite from_user {{ {} }}, to_user {{ {} }}, on_date {{ {} }}") + retVal.append(db.setJobInvite(from_user, to_user, on_date)) + debug.debug("seted JobInvites are {{ {} }}".format(retVal)) + return retVal + + def updateJobInvites(self, data): + debug.info("update JobInvites data {{ {} }}".format(data)) + return db.updateJobInvite(data) + + def deleteJobInvite(self, jobInvite): + debug.info("delete JobInvite {{ {} }}".format(jobInvite)) + db.deleteJobInvite(jobInvite) \ No newline at end of file diff --git a/geruecht/controller/mainController/mainJobKindController.py b/geruecht/controller/mainController/mainJobKindController.py new file mode 100644 index 0000000..3eb67f0 --- /dev/null +++ b/geruecht/controller/mainController/mainJobKindController.py @@ -0,0 +1,90 @@ +from datetime import date, timedelta, datetime, time +import geruecht.controller.databaseController as dc +from geruecht.logger import getDebugLogger + +db = dc.DatabaseController() +debug = getDebugLogger() + +class Base: + def getAllJobKinds(self): + debug.info("get all jobkinds") + retVal = db.getAllJobKinds() + debug.debug("jobkinds are {{ {} }}".format(retVal)) + return retVal + + def getJobKind(self, name): + debug.info("get jobkinds {{ {} }}".format(name)) + retVal = db.getJobKind(name) + debug.debug("jobkind is {{ {} }} is {{ {} }}".format(name, retVal)) + return retVal + + def setJobKind(self, name, workgroup=None): + debug.info("set jobkind {{ {} }} ".format(name)) + retVal = db.setJobKind(name, workgroup) + debug.debug( + "seted jobkind {{ {} }} is {{ {} }}".format(name, retVal)) + return retVal + + def deleteJobKind(self, jobkind): + debug.info("delete jobkind {{ {} }}".format(jobkind)) + db.deleteJobKind(jobkind) + + def updateJobKind(self, jobkind): + debug.info("update workgroup {{ {} }}".format(jobkind)) + retVal = db.updateJobKind(jobkind) + debug.debug("updated jobkind is {{ {} }}".format(retVal)) + return retVal + + def getJobKindDates(self, date): + debug.info("get jobkinddates on {{ {} }}".format(date)) + retVal = db.getJobKindDates(date) + debug.debug("jobkinddates are {{ {} }}".format(retVal)) + return retVal + + def updateJobKindDates(self, jobkindDate): + debug.info("update jobkinddate {{ {} }}".format(jobkindDate)) + retVal = db.updateJobKindDates(jobkindDate) + debug.debug("updated jobkind is {{ {} }}".format(retVal)) + return retVal + + def deleteJobKindDates(self, jobkinddates): + debug.info("delete jobkinddates {{ {} }}".format(jobkinddates)) + db.deleteJobKindDates(jobkinddates) + + def setJobKindDates(self, datum, jobkind, maxpersons): + debug.info("set jobkinddates with {{ {}, {}, {}, }}".format(datum, jobkind, maxpersons)) + retVal = db.setJobKindDates(datum, jobkind, maxpersons) + debug.debug("seted jobkinddates is {{ {} }}".format(retVal)) + return retVal + + def controllJobKindDates(self, jobkinddates): + debug.info("controll jobkinddates {{ {} }}".format(jobkinddates)) + datum = None + for jobkinddate in jobkinddates: + datum = date(jobkinddate['daydate']['year'], jobkinddate['daydate']['month'], jobkinddate['daydate']['day']) + if jobkinddate['id'] == -1: + if jobkinddate['job_kind']: + self.setJobKindDates(datum, jobkinddate['job_kind'], jobkinddate['maxpersons']) + if jobkinddate['id'] == 0: + jobkinddate['id'] = jobkinddate['backupid'] + db.deleteAllWorkerWithJobKind(datetime.combine(datum, time(12)), jobkinddate['job_kind']) + self.deleteJobKindDates(jobkinddate) + if jobkinddate['id'] >= 1: + self.updateJobKindDates(jobkinddate) + retVal = self.getJobKindDates(datum) if datum != None else [] + debug.debug("controlled jobkinddates {{ {} }}".format(retVal)) + return retVal + + def getJobKindDatesFromTo(self, from_date, to_date): + debug.info("get locked days from {{ {} }} to {{ {} }}".format( + from_date.date(), to_date.date())) + oneDay = timedelta(1) + delta = to_date.date() - from_date.date() + retVal = [] + startdate = from_date - oneDay + for _ in range(delta.days + 1): + startdate += oneDay + jobkinddate = self.getJobKindDates(startdate) + retVal.append(jobkinddate) + debug.debug("lock days are {{ {} }}".format(retVal)) + return retVal \ No newline at end of file diff --git a/geruecht/controller/mainController/mainJobRequestController.py b/geruecht/controller/mainController/mainJobRequestController.py new file mode 100644 index 0000000..05529a6 --- /dev/null +++ b/geruecht/controller/mainController/mainJobRequestController.py @@ -0,0 +1,42 @@ +from datetime import date, time, datetime + +import geruecht.controller.databaseController as dc +from geruecht import getDebugLogger + +db = dc.DatabaseController() +debug = getDebugLogger() + +class Base: + def getJobRequests(self, from_user, to_user, date): + debug.info("get JobRequests from_user {{ {} }} to_user {{ {} }} on date {{ {} }}".format(from_user, to_user, date)) + if from_user is None: + retVal = db.getJobRequestsToUser(to_user, date) + elif to_user is None: + retVal = db.getJobRequestsFromUser(from_user, date) + else: + raise Exception("from_user {{ {} }} and to_user {{ {} }} are None".format(from_user, to_user)) + return retVal + + def setJobRequests(self, data): + debug.info("set new JobRequests data {{ {} }}".format(data)) + retVal = [] + for jobRequest in data: + from_user = jobRequest['from_user'] + to_user = jobRequest['to_user'] + on_date = date(jobRequest['date']['year'], jobRequest['date']['month'], jobRequest['date']['day']) + job_kind = jobRequest['job_kind'] + debug.info("set new JobRequest from_user {{ {} }}, to_user {{ {} }}, on_date {{ {} }}") + retVal.append(db.setJobRequest(from_user, to_user, on_date, job_kind)) + debug.debug("seted JobRequests are {{ {} }}".format(retVal)) + return retVal + + def updateJobRequests(self, data): + debug.info("update JobRequest data {{ {} }}".format(data)) + if data['accepted']: + self.changeWorker(data['from_user'], data['to_user'], datetime.combine(data['on_date'], time(12))) + db.updateAllJobRequest(data) + return db.updateJobRequest(data) + + def deleteJobRequest(self, jobRequest): + debug.info("delete JobRequest {{ {} }}".format(jobRequest)) + db.deleteJobRequest(jobRequest) \ No newline at end of file diff --git a/geruecht/controller/mainController/mainPricelistController.py b/geruecht/controller/mainController/mainPricelistController.py new file mode 100644 index 0000000..06cec00 --- /dev/null +++ b/geruecht/controller/mainController/mainPricelistController.py @@ -0,0 +1,50 @@ +import geruecht.controller.databaseController as dc +from geruecht.logger import getDebugLogger + +db = dc.DatabaseController() +debug = getDebugLogger() + +class Base: + def deleteDrinkType(self, type): + debug.info("delete drink type {{ {} }}".format(type)) + db.deleteDrinkType(type) + + def updateDrinkType(self, type): + debug.info("update drink type {{ {} }}".format(type)) + retVal = db.updateDrinkType(type) + debug.debug("updated drink type is {{ {} }}".format(retVal)) + return retVal + + def setDrinkType(self, type): + debug.info("set drink type {{ {} }}".format(type)) + retVal = db.setDrinkType(type) + debug.debug("seted drink type is {{ {} }}".format(retVal)) + return retVal + + def deletDrinkPrice(self, drink): + debug.info("delete drink {{ {} }}".format(drink)) + db.deleteDrink(drink) + + def setDrinkPrice(self, drink): + debug.info("set drink {{ {} }}".format(drink)) + retVal = db.setDrinkPrice(drink) + debug.debug("seted drink is {{ {} }}".format(retVal)) + return retVal + + def updateDrinkPrice(self, drink): + debug.info("update drink {{ {} }}".format(drink)) + retVal = db.updateDrinkPrice(drink) + debug.debug("updated drink is {{ {} }}".format(retVal)) + return retVal + + def getAllDrinkTypes(self): + debug.info("get all drink types") + retVal = db.getAllDrinkTypes() + debug.debug("all drink types are {{ {} }}".format(retVal)) + return retVal + + def getPricelist(self): + debug.info("get all drinks") + list = db.getPriceList() + debug.debug("all drinks are {{ {} }}".format(list)) + return list \ No newline at end of file diff --git a/geruecht/controller/mainController/mainUserController.py b/geruecht/controller/mainController/mainUserController.py new file mode 100644 index 0000000..c0c70aa --- /dev/null +++ b/geruecht/controller/mainController/mainUserController.py @@ -0,0 +1,160 @@ +from geruecht.exceptions import UsernameExistLDAP, LDAPExcetpion, PermissionDenied +import geruecht.controller.databaseController as dc +import geruecht.controller.ldapController as lc +from geruecht.logger import getDebugLogger + +db = dc.DatabaseController() +ldap = lc.LDAPController() +debug = getDebugLogger() + +class Base: + def getAllStatus(self): + debug.info("get all status for user") + retVal = db.getAllStatus() + debug.debug("status are {{ {} }}".format(retVal)) + return retVal + + def getStatus(self, name): + debug.info("get status of user {{ {} }}".format(name)) + retVal = db.getStatus(name) + debug.debug("status of user {{ {} }} is {{ {} }}".format(name, retVal)) + return retVal + + def setStatus(self, name): + debug.info("set status of user {{ {} }}".format(name)) + retVal = db.setStatus(name) + debug.debug( + "settet status of user {{ {} }} is {{ {} }}".format(name, retVal)) + return retVal + + def deleteStatus(self, status): + debug.info("delete status {{ {} }}".format(status)) + db.deleteStatus(status) + + def updateStatus(self, status): + debug.info("update status {{ {} }}".format(status)) + retVal = db.updateStatus(status) + debug.debug("updated status is {{ {} }}".format(retVal)) + return retVal + + def updateStatusOfUser(self, username, status): + debug.info("update status {{ {} }} of user {{ {} }}".format( + status, username)) + retVal = db.updateStatusOfUser(username, status) + debug.debug( + "updatet status of user {{ {} }} is {{ {} }}".format(username, retVal)) + return retVal + + def updateVotingOfUser(self, username, voting): + debug.info("update voting {{ {} }} of user {{ {} }}".format( + voting, username)) + retVal = db.updateVotingOfUser(username, voting) + debug.debug( + "updatet voting of user {{ {} }} is {{ {} }}".format(username, retVal)) + return retVal + + def lockUser(self, username, locked): + debug.info("lock user {{ {} }} for credit with status {{ {} }}".format( + username, locked)) + user = self.getUser(username) + debug.debug("user is {{ {} }}".format(user)) + user.updateData({'locked': locked}) + db.updateUser(user) + retVal = self.getUser(username) + debug.debug("locked user is {{ {} }}".format(retVal)) + return retVal + + def updateConfig(self, username, data): + debug.info( + "update config of user {{ {} }} with config {{ {} }}".format(username, data)) + user = self.getUser(username) + debug.debug("user is {{ {} }}".format(user)) + user.updateData(data) + db.updateUser(user) + retVal = self.getUser(username) + debug.debug("updated config of user is {{ {} }}".format(retVal)) + return retVal + + def getAllUsersfromDB(self, extern=True): + debug.info("get all users from database") + users = db.getAllUser() + debug.debug("users are {{ {} }}".format(users)) + for user in users: + try: + debug.debug("update data from ldap") + self.__updateDataFromLDAP(user) + except: + pass + debug.debug("update creditlists") + self.__updateGeruechte(user) + retVal = db.getAllUser(extern=extern) + debug.debug("all users are {{ {} }}".format(retVal)) + return retVal + + def getUser(self, username): + debug.info("get user {{ {} }}".format(username)) + user = db.getUser(username) + debug.debug("user is {{ {} }}".format(user)) + groups = ldap.getGroup(username) + debug.debug("groups are {{ {} }}".format(groups)) + user_data = ldap.getUserData(username) + debug.debug("user data from ldap is {{ {} }}".format(user_data)) + user_data['gruppe'] = groups + user_data['group'] = groups + if user is None: + debug.debug("user not exists in database -> insert into database") + user = User(user_data) + db.insertUser(user) + else: + debug.debug("update database with user") + user.updateData(user_data) + db.updateUser(user) + user = db.getUser(username) + self.__updateGeruechte(user) + debug.debug("user is {{ {} }}".format(user)) + return user + + def modifyUser(self, user, ldap_conn, attributes): + debug.info("modify user {{ {} }} with attributes {{ {} }} with ldap_conn {{ {} }}".format( + user, attributes, ldap_conn)) + try: + if 'username' in attributes: + debug.debug("change username, so change first in database") + db.changeUsername(user, attributes['username']) + ldap.modifyUser(user, ldap_conn, attributes) + if 'username' in attributes: + retVal = self.getUser(attributes['username']) + debug.debug("user is {{ {} }}".format(retVal)) + return retVal + else: + retVal = self.getUser(user.uid) + debug.debug("user is {{ {} }}".format(retVal)) + return retVal + except UsernameExistLDAP as err: + debug.debug( + "username exists on ldap, rechange username on database", exc_info=True) + db.changeUsername(user, user.uid) + raise Exception(err) + except LDAPExcetpion as err: + if 'username' in attributes: + db.changeUsername(user, user.uid) + raise Exception(err) + except Exception as err: + raise Exception(err) + + def validateUser(self, username, password): + debug.info("validate user {{ {} }}".format(username)) + ldap.login(username, password) + + def loginUser(self, username, password): + debug.info("login user {{ {} }}".format(username)) + try: + user = self.getUser(username) + debug.debug("user is {{ {} }}".format(user)) + user.password = password + ldap.login(username, password) + ldap_conn = ldap.bind(user, password) + return user, ldap_conn + except PermissionDenied as err: + debug.debug("permission is denied", exc_info=True) + raise err \ No newline at end of file diff --git a/geruecht/controller/mainController/mainWorkerController.py b/geruecht/controller/mainController/mainWorkerController.py new file mode 100644 index 0000000..4ae0d16 --- /dev/null +++ b/geruecht/controller/mainController/mainWorkerController.py @@ -0,0 +1,58 @@ +from datetime import time, datetime + +import geruecht.controller.databaseController as dc +from geruecht.exceptions import DayLocked +from geruecht.logger import getDebugLogger + +db = dc.DatabaseController() +debug = getDebugLogger() + +class Base: + def getWorker(self, date, username=None): + debug.info("get worker {{ {} }} on {{ {} }}".format(username, date)) + if (username): + user = self.getUser(username) + debug.debug("user is {{ {} }}".format(user)) + retVal = [db.getWorker(user, date)] + debug.debug("worker is {{ {} }}".format(retVal)) + return retVal + retVal = db.getWorkers(date) + debug.debug("workers are {{ {} }}".format(retVal)) + return retVal + + def addWorker(self, username, date, job_kind=None, userExc=False): + debug.info("add job user {{ {} }} on {{ {} }} with job_kind {{ {} }}".format(username, date, job_kind)) + if (userExc): + debug.debug("this is a user execution, check if day is locked") + lockedDay = self.getLockedDay(date) + if lockedDay: + if lockedDay['locked']: + debug.debug("day is lockey. user cant get job") + raise DayLocked("Day is locked. You can't get the Job") + user = self.getUser(username) + debug.debug("user is {{ {} }}".format(user)) + debug.debug("check if user has job on date") + if (not db.getWorker(user, date)): + debug.debug("set job to user") + db.setWorker(user, date, job_kind=job_kind) + retVal = self.getWorker(date, username=username) + debug.debug("worker on date is {{ {} }}".format(retVal)) + return retVal + + def changeWorker(self, from_user, to_user, date): + debug.info("change worker from {{ {} }} to {{ {} }} on {{ {} }}".format(from_user, to_user, date)) + db.changeWorker(from_user, to_user, date) + + def deleteWorker(self, username, date, userExc=False): + debug.info( + "delete worker {{ {} }} on date {{ {} }}".format(username, date)) + user = self.getUser(username) + debug.debug("user is {{ {} }}".format(user)) + if userExc: + debug.debug("is user execution, check if day locked") + lockedDay = self.getLockedDay(date) + if lockedDay: + if lockedDay['locked']: + raise DayLocked( + "Day is locked. You can't delete the Job") + db.deleteWorker(user, date) \ No newline at end of file diff --git a/geruecht/controller/mainController/mainWorkgroupController.py b/geruecht/controller/mainController/mainWorkgroupController.py new file mode 100644 index 0000000..c32132e --- /dev/null +++ b/geruecht/controller/mainController/mainWorkgroupController.py @@ -0,0 +1,42 @@ +import geruecht.controller.databaseController as dc +from geruecht.logger import getDebugLogger + +db = dc.DatabaseController() +debug = getDebugLogger() + +class Base: + def updateWorkgroupsOfUser(self, user, workgroups): + debug.info("update workgroups {{ {} }} of user {{ {} }}".format(workgroups, user)) + db.deleteWorkgroupsOfUser(user) + for workgroup in workgroups: + db.setUserWorkgroup(user, workgroup) + return db.getWorkgroupsOfUser(user['id']) + + def getAllWorkgroups(self): + debug.info("get all workgroups") + retVal = db.getAllWorkgroups() + debug.debug("workgroups are {{ {} }}".format(retVal)) + return retVal + + def getWorkgroups(self, name): + debug.info("get Workgroup {{ {} }}".format(name)) + retVal = db.getWorkgroup(name) + debug.debug("workgroup is {{ {} }} is {{ {} }}".format(name, retVal)) + return retVal + + def setWorkgroup(self, name, boss): + debug.info("set workgroup {{ {} }} with boss {{ {} }}".format(name, boss)) + retVal = db.setWorkgroup(name, boss) + debug.debug( + "seted workgroup {{ {} }} is {{ {} }}".format(name, retVal)) + return retVal + + def deleteWorkgroup(self, workgroup): + debug.info("delete workgroup {{ {} }}".format(workgroup)) + db.deleteWorkgroup(workgroup) + + def updateWorkgroup(self, workgroup): + debug.info("update workgroup {{ {} }}".format(workgroup)) + retVal = db.updateWorkgroup(workgroup) + debug.debug("updated workgroup is {{ {} }}".format(retVal)) + return retVal \ No newline at end of file diff --git a/geruecht/controller/userController.py b/geruecht/controller/userController.py deleted file mode 100644 index ebdffde..0000000 --- a/geruecht/controller/userController.py +++ /dev/null @@ -1,559 +0,0 @@ -from . import Singleton, mailConfig -import geruecht.controller.databaseController as dc -import geruecht.controller.ldapController as lc -import geruecht.controller.emailController as ec -import calendar -from geruecht.model.user import User -from geruecht.exceptions import PermissionDenied -from datetime import datetime, timedelta -from geruecht.exceptions import UsernameExistLDAP, LDAPExcetpion, DayLocked, TansactJobIsAnswerdException -from geruecht.logger import getDebugLogger - -db = dc.DatabaseController() -ldap = lc.LDAPController() -emailController = ec.EmailController( - mailConfig['URL'], mailConfig['user'], mailConfig['passwd'], mailConfig['crypt'], mailConfig['port'], mailConfig['email']) - -debug = getDebugLogger() - - -class UserController(metaclass=Singleton): - - def __init__(self): - debug.debug("init UserController") - pass - - def updateWorkgroupsOfUser(self, user, workgroups): - debug.info("update workgroups {{ {} }} of user {{ {} }}".format(workgroups, user)) - db.deleteWorkgroupsOfUser(user) - for workgroup in workgroups: - db.setUserWorkgroup(user, workgroup) - return db.getWorkgroupsOfUser(user['id']) - - def getAllWorkgroups(self): - debug.info("get all workgroups") - retVal = db.getAllWorkgroups() - debug.debug("workgroups are {{ {} }}".format(retVal)) - return retVal - - def getWorkgroups(self, name): - debug.info("get Workgroup {{ {} }}".format(name)) - retVal = db.getWorkgroup(name) - debug.debug("workgroup is {{ {} }} is {{ {} }}".format(name, retVal)) - return retVal - - def setWorkgroup(self, name, boss): - debug.info("set workgroup {{ {} }} with boss {{ {} }}".format(name, boss)) - retVal = db.setWorkgroup(name, boss) - debug.debug( - "seted workgroup {{ {} }} is {{ {} }}".format(name, retVal)) - return retVal - - def deleteWorkgroup(self, workgroup): - debug.info("delete workgroup {{ {} }}".format(workgroup)) - db.deleteWorkgroup(workgroup) - - def updateWorkgroup(self, workgroup): - debug.info("update workgroup {{ {} }}".format(workgroup)) - retVal = db.updateWorkgroup(workgroup) - debug.debug("updated workgroup is {{ {} }}".format(retVal)) - return retVal - - def getAllStatus(self): - debug.info("get all status for user") - retVal = db.getAllStatus() - debug.debug("status are {{ {} }}".format(retVal)) - return retVal - - def getStatus(self, name): - debug.info("get status of user {{ {} }}".format(name)) - retVal = db.getStatus(name) - debug.debug("status of user {{ {} }} is {{ {} }}".format(name, retVal)) - return retVal - - def setStatus(self, name): - debug.info("set status of user {{ {} }}".format(name)) - retVal = db.setStatus(name) - debug.debug( - "settet status of user {{ {} }} is {{ {} }}".format(name, retVal)) - return retVal - - def deleteStatus(self, status): - debug.info("delete status {{ {} }}".format(status)) - db.deleteStatus(status) - - def updateStatus(self, status): - debug.info("update status {{ {} }}".format(status)) - retVal = db.updateStatus(status) - debug.debug("updated status is {{ {} }}".format(retVal)) - return retVal - - def updateStatusOfUser(self, username, status): - debug.info("update status {{ {} }} of user {{ {} }}".format( - status, username)) - retVal = db.updateStatusOfUser(username, status) - debug.debug( - "updatet status of user {{ {} }} is {{ {} }}".format(username, retVal)) - return retVal - - def updateVotingOfUser(self, username, voting): - debug.info("update voting {{ {} }} of user {{ {} }}".format( - voting, username)) - retVal = db.updateVotingOfUser(username, voting) - debug.debug( - "updatet voting of user {{ {} }} is {{ {} }}".format(username, retVal)) - return retVal - - def deleteDrinkType(self, type): - debug.info("delete drink type {{ {} }}".format(type)) - db.deleteDrinkType(type) - - def updateDrinkType(self, type): - debug.info("update drink type {{ {} }}".format(type)) - retVal = db.updateDrinkType(type) - debug.debug("updated drink type is {{ {} }}".format(retVal)) - return retVal - - def setDrinkType(self, type): - debug.info("set drink type {{ {} }}".format(type)) - retVal = db.setDrinkType(type) - debug.debug("seted drink type is {{ {} }}".format(retVal)) - return retVal - - def deletDrinkPrice(self, drink): - debug.info("delete drink {{ {} }}".format(drink)) - db.deleteDrink(drink) - - def setDrinkPrice(self, drink): - debug.info("set drink {{ {} }}".format(drink)) - retVal = db.setDrinkPrice(drink) - debug.debug("seted drink is {{ {} }}".format(retVal)) - return retVal - - def updateDrinkPrice(self, drink): - debug.info("update drink {{ {} }}".format(drink)) - retVal = db.updateDrinkPrice(drink) - debug.debug("updated drink is {{ {} }}".format(retVal)) - return retVal - - def getAllDrinkTypes(self): - debug.info("get all drink types") - retVal = db.getAllDrinkTypes() - debug.debug("all drink types are {{ {} }}".format(retVal)) - return retVal - - def getPricelist(self): - debug.info("get all drinks") - list = db.getPriceList() - debug.debug("all drinks are {{ {} }}".format(list)) - return list - - def setTransactJob(self, from_user, to_user, date): - debug.info("set transact job from {{ {} }} to {{ {} }} on {{ {} }}".format( - from_user, to_user, date)) - jobtransact = db.setTransactJob(from_user, to_user, date.date()) - debug.debug("transact job is {{ {} }}".format(jobtransact)) - debug.info("send mail with transact job to user") - emailController.sendMail( - jobtransact['to_user'], 'jobtransact', jobtransact) - return jobtransact - - def getTransactJobFromUser(self, user, date): - debug.info( - "get transact job from user {{ {} }} on {{ {} }}".format(user, date)) - retVal = db.getTransactJobFromUser(user, date.date()) - debug.debug( - "transact job from user {{ {} }} is {{ {} }}".format(user, retVal)) - return retVal - - def getAllTransactJobFromUser(self, user, date): - debug.info( - "get all transact job from user {{ {} }} start on {{ {} }}".format(user, date)) - retVal = db.getAllTransactJobFromUser(user, date.date()) - debug.debug("all transact job are {{ {} }}".format(retVal)) - return retVal - - def getAllTransactJobToUser(self, user, date): - debug.info( - "get all transact job from to_user {{ {} }} start on {{ {} }}".format(user, date)) - retVal = db.getAllTransactJobToUser(user, date.date()) - debug.debug("all transact job are {{ {} }}".format(retVal)) - return retVal - - def getTransactJob(self, from_user, to_user, date): - debug.info("get transact job from user {{ {} }} to user {{ {} }} on {{ {} }}".format( - from_user, to_user, date)) - retVal = db.getTransactJob(from_user, to_user, date.date()) - debug.debug("transact job is {{ {} }}".format(retVal)) - return retVal - - def deleteTransactJob(self, from_user, to_user, date): - debug.info("delete transact job from user {{ {} }} to user {{ {} }} on {{ {} }}".format( - from_user, to_user, date)) - transactJob = self.getTransactJob(from_user, to_user, date) - debug.debug("transact job is {{ {} }}".format(transactJob)) - if transactJob['answerd']: - debug.warning( - "transactjob {{ {} }} can not delete because is answerd") - raise TansactJobIsAnswerdException( - "TransactJob is already answerd") - db.deleteTransactJob(from_user, to_user, date.date()) - - def answerdTransactJob(self, from_user, to_user, date, answer): - debug.info("answer transact job from user {{ {} }} to user {{ {} }} on {{ {} }} with answer {{ {} }}".format( - from_user, to_user, date, answer)) - transactJob = db.updateTransactJob( - from_user, to_user, date.date(), answer) - debug.debug("transactjob is {{ {} }}".format(transactJob)) - if answer: - debug.info("add worker on date {{ {} }}".format(date)) - self.addWorker(to_user.uid, date) - return transactJob - - def setLockedDay(self, date, locked, hard=False): - debug.info( - "set day locked on {{ {} }} with state {{ {} }}".format(date, locked)) - retVal = db.setLockedDay(date.date(), locked, hard) - debug.debug("seted day locked is {{ {} }}".format(retVal)) - return retVal - - def getLockedDays(self, from_date, to_date): - debug.info("get locked days from {{ {} }} to {{ {} }}".format( - from_date.date(), to_date.date())) - oneDay = timedelta(1) - delta = to_date.date() - from_date.date() - retVal = [] - startdate = from_date - oneDay - for _ in range(delta.days + 1): - startdate += oneDay - lockday = self.getLockedDay(startdate) - retVal.append(lockday) - debug.debug("lock days are {{ {} }}".format(retVal)) - return retVal - - def getLockedDay(self, date): - debug.info("get locked day on {{ {} }}".format(date)) - now = datetime.now() - debug.debug("now is {{ {} }}".format(now)) - oldMonth = False - debug.debug("check if date old month or current month") - for i in range(1, 8): - if datetime(now.year, now.month, i).weekday() == 2: - if now.day < i: - oldMonth = True - break - debug.debug("oldMonth is {{ {} }}".format(oldMonth)) - lockedYear = now.year - lockedMonth = now.month if now.month < now.month else now.month - \ - 1 if oldMonth else now.month - endDay = 1 - debug.debug("calculate end day of month") - lockedYear = lockedYear if lockedMonth != 12 else (lockedYear + 1) - lockedMonth = (lockedMonth + 1) if lockedMonth != 12 else 1 - for i in range(1, 8): - nextMonth = datetime(lockedYear, lockedMonth, i) - if nextMonth.weekday() == 2: - endDay = i - break - - monthLockedEndDate = datetime( - lockedYear, lockedMonth, endDay) - timedelta(1) - debug.debug("get lock day from database") - retVal = db.getLockedDay(date.date()) - if not retVal: - debug.debug( - "lock day not exists, retVal is {{ {} }}".format(retVal)) - if date.date() <= monthLockedEndDate.date(): - debug.debug("lock day {{ {} }}".format(date.date())) - self.setLockedDay(date, True) - retVal = db.getLockedDay(date.date()) - else: - retVal = {"daydate": date.date(), "locked": False} - debug.debug("locked day is {{ {} }}".format(retVal)) - return retVal - - def getWorker(self, date, username=None): - debug.info("get worker {{ {} }} on {{ {} }}".format(username, date)) - if (username): - user = self.getUser(username) - debug.debug("user is {{ {} }}".format(user)) - retVal = [db.getWorker(user, date)] - debug.debug("worker is {{ {} }}".format(retVal)) - return retVal - retVal = db.getWorkers(date) - debug.debug("workers are {{ {} }}".format(retVal)) - return retVal - - def addWorker(self, username, date, userExc=False): - debug.info("add job user {{ {} }} on {{ {} }}".format(username, date)) - if (userExc): - debug.debug("this is a user execution, check if day is locked") - lockedDay = self.getLockedDay(date) - if lockedDay: - if lockedDay['locked']: - debug.debug("day is lockey. user cant get job") - raise DayLocked("Day is locked. You can't get the Job") - user = self.getUser(username) - debug.debug("user is {{ {} }}".format(user)) - debug.debug("check if user has job on date") - if (not db.getWorker(user, date)): - debug.debug("set job to user") - db.setWorker(user, date) - retVal = self.getWorker(date, username=username) - debug.debug("worker on date is {{ {} }}".format(retVal)) - return retVal - - def deleteWorker(self, username, date, userExc=False): - debug.info( - "delete worker {{ {} }} on date {{ {} }}".format(username, date)) - user = self.getUser(username) - debug.debug("user is {{ {} }}".format(user)) - if userExc: - debug.debug("is user execution, check if day locked") - lockedDay = self.getLockedDay(date) - if lockedDay: - if lockedDay['locked']: - debug.debug( - "day is locked, check if accepted transact job exists") - transactJobs = self.getTransactJobFromUser(user, date) - debug.debug( - "transact job is {{ {} }}".format(transactJobs)) - found = False - for job in transactJobs: - if job['accepted'] and job['answerd']: - debug.debug("accepted transact job exists") - found = True - break - if not found: - debug.debug("no accepted transact job found") - raise DayLocked( - "Day is locked. You can't delete the Job") - db.deleteWorker(user, date) - - def lockUser(self, username, locked): - debug.info("lock user {{ {} }} for credit with status {{ {} }}".format( - username, locked)) - user = self.getUser(username) - debug.debug("user is {{ {} }}".format(user)) - user.updateData({'locked': locked}) - db.updateUser(user) - retVal = self.getUser(username) - debug.debug("locked user is {{ {} }}".format(retVal)) - return retVal - - def updateConfig(self, username, data): - debug.info( - "update config of user {{ {} }} with config {{ {} }}".format(username, data)) - user = self.getUser(username) - debug.debug("user is {{ {} }}".format(user)) - user.updateData(data) - db.updateUser(user) - retVal = self.getUser(username) - debug.debug("updated config of user is {{ {} }}".format(retVal)) - return retVal - - def __updateDataFromLDAP(self, user): - debug.info("update data from ldap for user {{ {} }}".format(user)) - groups = ldap.getGroup(user.uid) - debug.debug("ldap gorups are {{ {} }}".format(groups)) - user_data = ldap.getUserData(user.uid) - debug.debug("ldap data is {{ {} }}".format(user_data)) - user_data['gruppe'] = groups - user_data['group'] = groups - user.updateData(user_data) - db.updateUser(user) - - def autoLock(self, user): - debug.info("start autolock of user {{ {} }}".format(user)) - if user.autoLock: - debug.debug("autolock is active") - credit = user.getGeruecht(year=datetime.now().year).getSchulden() - limit = -1*user.limit - if credit <= limit: - debug.debug( - "credit {{ {} }} is more than user limit {{ {} }}".format(credit, limit)) - debug.debug("lock user") - user.updateData({'locked': True}) - debug.debug("send mail to user") - emailController.sendMail(user) - else: - debug.debug( - "cretid {{ {} }} is less than user limit {{ {} }}".format(credit, limit)) - debug.debug("unlock user") - user.updateData({'locked': False}) - db.updateUser(user) - - def addAmount(self, username, amount, year, month, finanzer=False): - debug.info("add amount {{ {} }} to user {{ {} }} no month {{ {} }}, year {{ {} }}".format( - amount, username, month, year)) - user = self.getUser(username) - debug.debug("user is {{ {} }}".format(user)) - if user.uid == 'extern': - debug.debug("user is extern user, so exit add amount") - return - if not user.locked or finanzer: - debug.debug("user is not locked {{ {} }} or is finanzer execution {{ {} }}".format( - user.locked, finanzer)) - user.addAmount(amount, year=year, month=month) - creditLists = user.updateGeruecht() - debug.debug("creditList is {{ {} }}".format(creditLists)) - for creditList in creditLists: - debug.debug("update creditlist {{ {} }}".format(creditList)) - db.updateCreditList(creditList) - debug.debug("do autolock") - self.autoLock(user) - retVal = user.getGeruecht(year) - debug.debug("updated creditlists is {{ {} }}".format(retVal)) - return retVal - - def addCredit(self, username, credit, year, month): - debug.info("add credit {{ {} }} to user {{ {} }} on month {{ {} }}, year {{ {} }}".format( - credit, username, month, year)) - user = self.getUser(username) - debug.debug("user is {{ {} }}".format(user)) - if user.uid == 'extern': - debug.debug("user is extern user, so exit add credit") - return - user.addCredit(credit, year=year, month=month) - creditLists = user.updateGeruecht() - debug.debug("creditlists are {{ {} }}".format(creditLists)) - for creditList in creditLists: - debug.debug("update creditlist {{ {} }}".format(creditList)) - db.updateCreditList(creditList) - debug.debug("do autolock") - self.autoLock(user) - retVal = user.getGeruecht(year) - debug.debug("updated creditlists are {{ {} }}".format(retVal)) - return retVal - - def getAllUsersfromDB(self): - debug.info("get all users from database") - users = db.getAllUser() - debug.debug("users are {{ {} }}".format(users)) - for user in users: - try: - debug.debug("update data from ldap") - self.__updateDataFromLDAP(user) - except: - pass - debug.debug("update creditlists") - self.__updateGeruechte(user) - retVal = db.getAllUser(extern=True) - debug.debug("all users are {{ {} }}".format(retVal)) - return retVal - - def checkBarUser(self, user): - debug.info("check if user {{ {} }} is baruser") - date = datetime.now() - zero = date.replace(hour=0, minute=0, second=0, microsecond=0) - end = zero + timedelta(hours=12) - startdatetime = date.replace( - hour=12, minute=0, second=0, microsecond=0) - if date > zero and end > date: - startdatetime = startdatetime - timedelta(days=1) - enddatetime = startdatetime + timedelta(days=1) - debug.debug("startdatetime is {{ {} }} and enddatetime is {{ {} }}".format( - startdatetime, end)) - result = False - if date >= startdatetime and date < enddatetime: - result = db.getWorker(user, startdatetime) - debug.debug("worker is {{ {} }}".format(result)) - return True if result else False - - def getUser(self, username): - debug.info("get user {{ {} }}".format(username)) - user = db.getUser(username) - debug.debug("user is {{ {} }}".format(user)) - groups = ldap.getGroup(username) - debug.debug("groups are {{ {} }}".format(groups)) - user_data = ldap.getUserData(username) - debug.debug("user data from ldap is {{ {} }}".format(user_data)) - user_data['gruppe'] = groups - user_data['group'] = groups - if user is None: - debug.debug("user not exists in database -> insert into database") - user = User(user_data) - db.insertUser(user) - else: - debug.debug("update database with user") - user.updateData(user_data) - db.updateUser(user) - user = db.getUser(username) - self.__updateGeruechte(user) - debug.debug("user is {{ {} }}".format(user)) - return user - - def __updateGeruechte(self, user): - debug.debug("update creditlists") - user.getGeruecht(datetime.now().year) - creditLists = user.updateGeruecht() - debug.debug("creditlists are {{ {} }}".format(creditLists)) - if user.getGeruecht(datetime.now().year).getSchulden() != 0: - for creditList in creditLists: - debug.debug("update creditlist {{ {} }}".format(creditList)) - db.updateCreditList(creditList) - - def sendMail(self, username): - debug.info("send mail to user {{ {} }}".format(username)) - if type(username) == User: - user = username - if type(username) == str: - user = db.getUser(username) - retVal = emailController.sendMail(user) - debug.debug("send mail is {{ {} }}".format(retVal)) - return retVal - - def sendAllMail(self): - debug.info("send mail to all user") - retVal = [] - users = db.getAllUser() - debug.debug("users are {{ {} }}".format(users)) - for user in users: - retVal.append(self.sendMail(user)) - debug.debug("send mails are {{ {} }}".format(retVal)) - return retVal - - def modifyUser(self, user, ldap_conn, attributes): - debug.info("modify user {{ {} }} with attributes {{ {} }} with ldap_conn {{ {} }}".format( - user, attributes, ldap_conn)) - try: - if 'username' in attributes: - debug.debug("change username, so change first in database") - db.changeUsername(user, attributes['username']) - ldap.modifyUser(user, ldap_conn, attributes) - if 'username' in attributes: - retVal = self.getUser(attributes['username']) - debug.debug("user is {{ {} }}".format(retVal)) - return retVal - else: - retVal = self.getUser(user.uid) - debug.debug("user is {{ {} }}".format(retVal)) - return retVal - except UsernameExistLDAP as err: - debug.debug( - "username exists on ldap, rechange username on database", exc_info=True) - db.changeUsername(user, user.uid) - raise Exception(err) - except LDAPExcetpion as err: - if 'username' in attributes: - db.changeUsername(user, user.uid) - raise Exception(err) - except Exception as err: - raise Exception(err) - - def validateUser(self, username, password): - debug.info("validate user {{ {} }}".format(username)) - ldap.login(username, password) - - def loginUser(self, username, password): - debug.info("login user {{ {} }}".format(username)) - try: - user = self.getUser(username) - debug.debug("user is {{ {} }}".format(user)) - user.password = password - ldap.login(username, password) - ldap_conn = ldap.bind(user, password) - return user, ldap_conn - except PermissionDenied as err: - debug.debug("permission is denied", exc_info=True) - raise err diff --git a/geruecht/finanzer/routes.py b/geruecht/finanzer/routes.py index 96b72d1..8b2e2fa 100644 --- a/geruecht/finanzer/routes.py +++ b/geruecht/finanzer/routes.py @@ -1,6 +1,6 @@ from flask import Blueprint, request, jsonify from datetime import datetime -import geruecht.controller.userController as uc +import geruecht.controller.mainController as mc from geruecht.model import MONEY from geruecht.decorator import login_required from geruecht.logger import getDebugLogger, getCreditLogger @@ -10,7 +10,7 @@ creditL = getCreditLogger() finanzer = Blueprint("finanzer", __name__) -userController = uc.UserController() +mainController = mc.MainController() @finanzer.route("/getFinanzerMain") @@ -26,7 +26,7 @@ def _getFinanzer(**kwargs): """ debug.info("/getFinanzerMain") try: - users = userController.getAllUsersfromDB() + users = mainController.getAllUsersfromDB() dic = {} for user in users: dic[user.uid] = user.toJSON() @@ -65,9 +65,9 @@ def _addAmount(**kwargs): month = int(data['month']) except KeyError: month = datetime.now().month - userController.addAmount( + mainController.addAmount( userID, amount, year=year, month=month, finanzer=True) - user = userController.getUser(userID) + user = mainController.getUser(userID) retVal = {str(geruecht.year): geruecht.toJSON() for geruecht in user.geruechte} retVal['locked'] = user.locked @@ -108,9 +108,9 @@ def _addCredit(**kwargs): except KeyError: month = datetime.now().month - userController.addCredit( + mainController.addCredit( userID, credit, year=year, month=month).toJSON() - user = userController.getUser(userID) + user = mainController.getUser(userID) retVal = {str(geruecht.year): geruecht.toJSON() for geruecht in user.geruechte} retVal['locked'] = user.locked @@ -131,7 +131,7 @@ def _finanzerLock(**kwargs): data = request.get_json() username = data['userId'] locked = bool(data['locked']) - retVal = userController.lockUser(username, locked).toJSON() + retVal = mainController.lockUser(username, locked).toJSON() debug.debug("return {{ {} }}".format(retVal)) return jsonify(retVal) except Exception as err: @@ -148,7 +148,7 @@ def _finanzerSetConfig(**kwargs): username = data['userId'] autoLock = bool(data['autoLock']) limit = int(data['limit']) - retVal = userController.updateConfig( + retVal = mainController.updateConfig( username, {'lockLimit': limit, 'autoLock': autoLock}).toJSON() debug.debug("return {{ {} }}".format(retVal)) return jsonify(retVal) @@ -164,8 +164,8 @@ def _finanzerAddUser(**kwargs): try: data = request.get_json() username = data['userId'] - userController.getUser(username) - users = userController.getAllUsersfromDB() + mainController.getUser(username) + users = mainController.getAllUsersfromDB() dic = {} for user in users: dic[user.uid] = user.toJSON() @@ -185,7 +185,7 @@ def _finanzerSendOneMail(**kwargs): try: data = request.get_json() username = data['userId'] - retVal = userController.sendMail(username) + retVal = mainController.sendMail(username) debug.debug("return {{ {} }}".format(retVal)) return jsonify(retVal) except Exception as err: @@ -198,7 +198,7 @@ def _finanzerSendOneMail(**kwargs): def _finanzerSendAllMail(**kwargs): debug.info("/finanzerSendAllMail") try: - retVal = userController.sendAllMail() + retVal = mainController.sendAllMail() debug.debug("return {{ {} }}".format(retVal)) return jsonify(retVal) except Exception as err: diff --git a/geruecht/gastro/routes.py b/geruecht/gastro/routes.py index 5ddb3c1..baca57a 100644 --- a/geruecht/gastro/routes.py +++ b/geruecht/gastro/routes.py @@ -1,6 +1,6 @@ from flask import request, jsonify, Blueprint from geruecht.decorator import login_required -import geruecht.controller.userController as uc +import geruecht.controller.mainController as mc from geruecht.model import GASTRO from geruecht.logger import getCreditLogger, getDebugLogger @@ -8,7 +8,7 @@ debug = getDebugLogger() gastrouser = Blueprint('gastrouser', __name__) -userController = uc.UserController() +mainController = mc.MainController() @gastrouser.route('/gastro/setDrink', methods=['POST']) @@ -17,7 +17,7 @@ def setDrink(**kwargs): debug.info("/gastro/setDrink") try: data = request.get_json() - retVal = userController.setDrinkPrice(data) + retVal = mainController.setDrinkPrice(data) debug.debug("return {{ {} }}".format(retVal)) return jsonify(retVal) except Exception as err: @@ -31,7 +31,7 @@ def updateDrink(**kwargs): debug.info("/gastro/updateDrink") try: data = request.get_json() - retVal = userController.updateDrinkPrice(data) + retVal = mainController.updateDrinkPrice(data) debug.debug("return {{ {} }}".format(retVal)) return jsonify(retVal) except Exception as err: @@ -46,7 +46,7 @@ def deleteDrink(**kwargs): try: data = request.get_json() id = data['id'] - userController.deletDrinkPrice({"id": id}) + mainController.deletDrinkPrice({"id": id}) debug.debug("return ok") return jsonify({"ok": "ok"}) except Exception as err: @@ -61,7 +61,7 @@ def setType(**kwark): try: data = request.get_json() name = data['name'] - retVal = userController.setDrinkType(name) + retVal = mainController.setDrinkType(name) debug.debug("return {{ {} }}".format(retVal)) return jsonify(retVal) except Exception as err: @@ -75,7 +75,7 @@ def updateType(**kwargs): debug.info("/gastro/updateDrinkType") try: data = request.get_json() - retVal = userController.updateDrinkType(data) + retVal = mainController.updateDrinkType(data) debug.debug("return {{ {} }}".format(retVal)) return jsonify(retVal) except Exception as err: @@ -89,7 +89,7 @@ def deleteType(**kwargs): debug.info("/gastro/deleteDrinkType") try: data = request.get_json() - userController.deleteDrinkType(data) + mainController.deleteDrinkType(data) debug.debug("return ok") return jsonify({"ok": "ok"}) except Exception as err: diff --git a/geruecht/routes.py b/geruecht/routes.py index fec35b2..96dc57e 100644 --- a/geruecht/routes.py +++ b/geruecht/routes.py @@ -3,12 +3,12 @@ from geruecht.logger import getDebugLogger from geruecht.decorator import login_required from geruecht.exceptions import PermissionDenied import geruecht.controller.accesTokenController as ac -import geruecht.controller.userController as uc +import geruecht.controller.mainController as mc from geruecht.model import MONEY, BAR, USER, GASTRO, VORSTAND, EXTERN from flask import request, jsonify accesTokenController = ac.AccesTokenController() -userController = uc.UserController() +mainController = mc.MainController() debug = getDebugLogger() @@ -19,7 +19,7 @@ def _valid(**kwargs): try: accToken = kwargs['accToken'] data = request.get_json() - userController.validateUser(accToken.user.uid, data['password']) + mainController.validateUser(accToken.user.uid, data['password']) debug.debug('return {{ "ok": "ok" }}') return jsonify({"ok": "ok"}) except Exception as err: @@ -30,7 +30,7 @@ def _valid(**kwargs): def _getPricelist(): try: debug.info("get pricelist") - retVal = userController.getPricelist() + retVal = mainController.getPricelist() debug.info("return pricelist {{ {} }}".format(retVal)) return jsonify(retVal) except Exception as err: @@ -42,7 +42,7 @@ def _getPricelist(): def getTypes(): try: debug.info("get drinktypes") - retVal = userController.getAllDrinkTypes() + retVal = mainController.getAllDrinkTypes() debug.info("return drinktypes {{ {} }}".format(retVal)) return jsonify(retVal) except Exception as err: @@ -55,7 +55,7 @@ def getTypes(): def _getAllStatus(**kwargs): try: debug.info("get all status for users") - retVal = userController.getAllStatus() + retVal = mainController.getAllStatus() debug.info("return all status for users {{ {} }}".format(retVal)) return jsonify(retVal) except Exception as err: @@ -71,7 +71,7 @@ def _getStatus(**kwargs): data = request.get_json() name = data['name'] debug.info("get status from user {{ {} }}".format(name)) - retVal = userController.getStatus(name) + retVal = mainController.getStatus(name) debug.info( "return status from user {{ {} }} : {{ {} }}".format(name, retVal)) return jsonify(retVal) @@ -81,11 +81,14 @@ def _getStatus(**kwargs): @app.route('/getUsers', methods=['GET']) -@login_required(groups=[MONEY, GASTRO, VORSTAND], bar=True) +@login_required(groups=[USER], bar=True) def _getUsers(**kwargs): try: + extern = True + if 'extern' in request.args: + extern = not bool(int(request.args['extern'])) debug.info("get all users from database") - users = userController.getAllUsersfromDB() + users = mainController.getAllUsersfromDB(extern=extern) debug.debug("users are {{ {} }}".format(users)) retVal = [user.toJSON() for user in users] debug.info("return all users from database {{ {} }}".format(retVal)) @@ -173,7 +176,7 @@ def _login(): debug.debug("username is {{ {} }}".format(username)) try: debug.info("search {{ {} }} in database".format(username)) - user, ldap_conn = userController.loginUser(username, password) + user, ldap_conn = mainController.loginUser(username, password) debug.debug("user is {{ {} }}".format(user)) user.password = password token = accesTokenController.createAccesToken(user, ldap_conn) diff --git a/geruecht/user/routes.py b/geruecht/user/routes.py index 79631f3..e433798 100644 --- a/geruecht/user/routes.py +++ b/geruecht/user/routes.py @@ -1,14 +1,14 @@ from flask import Blueprint, request, jsonify from geruecht.decorator import login_required -import geruecht.controller.userController as uc +import geruecht.controller.mainController as mc from geruecht.model import USER -from datetime import datetime, time +from datetime import datetime, time, date from geruecht.exceptions import DayLocked from geruecht.logger import getDebugLogger, getCreditLogger, getJobsLogger user = Blueprint("user", __name__) -userController = uc.UserController() +mainController = mc.MainController() debug = getDebugLogger() creditL = getCreditLogger() @@ -22,7 +22,7 @@ def _main(**kwargs): try: if 'accToken' in kwargs: accToken = kwargs['accToken'] - accToken.user = userController.getUser(accToken.user.uid) + accToken.user = mainController.getUser(accToken.user.uid) retVal = accToken.user.toJSON() retVal['creditList'] = {credit.year: credit.toJSON() for credit in accToken.user.geruechte} @@ -43,9 +43,9 @@ def _addAmount(**kwargs): data = request.get_json() amount = int(data['amount']) date = datetime.now() - userController.addAmount( + mainController.addAmount( accToken.user.uid, amount, year=date.year, month=date.month) - accToken.user = userController.getUser(accToken.user.uid) + accToken.user = mainController.getUser(accToken.user.uid) retVal = accToken.user.toJSON() retVal['creditList'] = {credit.year: credit.toJSON() for credit in accToken.user.geruechte} @@ -66,7 +66,7 @@ def _saveConfig(**kwargs): if 'accToken' in kwargs: accToken = kwargs['accToken'] data = request.get_json() - accToken.user = userController.modifyUser( + accToken.user = mainController.modifyUser( accToken.user, accToken.ldap_conn, data) retVal = accToken.user.toJSON() retVal['creditList'] = {credit.year: credit.toJSON() @@ -89,12 +89,12 @@ def _getUsers(**kwrags): from_date = datetime( from_date['year'], from_date['month'], from_date['day']) to_date = datetime(to_date['year'], to_date['month'], to_date['day']) - lockedDays = userController.getLockedDays(from_date, to_date) + lockedDays = mainController.getLockedDays(from_date, to_date) retVal = [] for lockedDay in lockedDays: day = datetime.combine(lockedDay['daydate'], time(12)) retDay = { - "worker": userController.getWorker(day), + "worker": mainController.getWorker(day), "day": { "date": { "year": day.year, @@ -102,7 +102,8 @@ def _getUsers(**kwrags): "day": day.day }, "locked": lockedDay['locked'] - } + }, + "jobkinddate": mainController.getJobKindDates(day.date()) } retVal.append(retDay) @@ -112,6 +113,35 @@ def _getUsers(**kwrags): debug.debug("exception", exc_info=True) return jsonify({"error": str(err)}), 500 +@user.route("/user/jobsOnDates", methods=['POST']) +@login_required(groups=[USER]) +def _getJobsOnDates(**kwargs): + debug.info("/user/jobsOnDates") + try: + data = request.get_json() + lockedDays = mainController.getLockedDaysFromList(data) + retVal = [] + for lockedDay in lockedDays: + day = datetime.combine(lockedDay['daydate'], time(12)) + retDay = { + "worker": mainController.getWorker(day), + "day": { + "date": { + "year": day.year, + "month": day.month, + "day": day.day + }, + "locked": lockedDay['locked'] + }, + "jobkinddate": mainController.getJobKindDates(day.date()) + } + retVal.append(retDay) + + debug.debug("return {{ {} }}".format(retVal)) + return jsonify(retVal) + except Exception as err: + debug.debug("exception", exc_info=True) + return jsonify({"error": str(err)}), 500 @user.route("/user/job", methods=['POST']) @login_required(groups=[USER]) @@ -123,7 +153,7 @@ def _getUser(**kwargs): month = data['month'] year = data['year'] date = datetime(year, month, day, 12) - lockedDay = userController.getLockedDay(date) + lockedDay = mainController.getLockedDay(date) if not lockedDay: lockedDay = { 'date': { @@ -143,7 +173,7 @@ def _getUser(**kwargs): 'locked': lockedDay['locked'] } retVal = { - 'worker': userController.getWorker(date), + 'worker': mainController.getWorker(date), 'day': lockedDay } debug.debug("retrun {{ {} }}".format(retVal)) @@ -166,7 +196,11 @@ def _addUser(**kwargs): month = data['month'] year = data['year'] date = datetime(year, month, day, 12) - retVal = userController.addWorker(user.uid, date, userExc=True) + job_kind = None + if 'job_kind' in data: + job_kind = data['job_kind'] + mainController.addWorker(user.uid, date, job_kind=job_kind, userExc=True) + retVal = mainController.getWorker(date) debug.debug("return {{ {} }}".format(retVal)) jobL.info("Mitglied {} {} schreib sich am {} zum Dienst ein.".format( user.firstname, user.lastname, date.date())) @@ -192,11 +226,12 @@ def _deletJob(**kwargs): month = data['month'] year = data['year'] date = datetime(year, month, day, 12) - userController.deleteWorker(user.uid, date, True) + mainController.deleteWorker(user.uid, date, True) + retVal = mainController.getWorker(date) debug.debug("return ok") jobL.info("Mitglied {} {} entfernt sich am {} aus dem Dienst".format( user.firstname, user.lastname, date.date())) - return jsonify({"ok": "ok"}) + return jsonify(retVal) except DayLocked as err: debug.debug("exception", exc_info=True) return jsonify({"error": str(err)}), 403 @@ -204,148 +239,6 @@ def _deletJob(**kwargs): debug.debug("exception", exc_info=True) return jsonify({"error": str(err)}), 409 - -@user.route("/user/transactJob", methods=['POST']) -@login_required(groups=[USER]) -def _transactJob(**kwargs): - debug.info("/user/transactJob") - try: - if 'accToken' in kwargs: - accToken = kwargs['accToken'] - user = accToken.user - data = request.get_json() - year = data['year'] - month = data['month'] - day = data['day'] - username = data['user'] - date = datetime(year, month, day, 12) - to_user = userController.getUser(username) - retVal = userController.setTransactJob(user, to_user, date) - from_userl = retVal['from_user'] - to_userl = retVal['to_user'] - retVal['from_user'] = retVal['from_user'].toJSON() - retVal['to_user'] = retVal['to_user'].toJSON() - retVal['date'] = {'year': year, 'month': month, 'day': day} - debug.debug("return {{ {} }}".format(retVal)) - jobL.info("Mitglied {} {} sendet Dienstanfrage an Mitglied {} {} am {}".format( - from_userl.firstname, from_userl.lastname, to_userl.firstname, to_userl.lastname, date.date())) - return jsonify(retVal) - except Exception as err: - debug.debug("exception", exc_info=True) - return jsonify({"error": str(err)}), 409 - - -@user.route("/user/answerTransactJob", methods=['POST']) -@login_required(groups=[USER]) -def _answer(**kwargs): - debug.info("/user/answerTransactJob") - try: - if 'accToken' in kwargs: - accToken = kwargs['accToken'] - user = accToken.user - data = request.get_json() - year = data['year'] - month = data['month'] - day = data['day'] - answer = data['answer'] - username = data['username'] - date = datetime(year, month, day, 12) - from_user = userController.getUser(username) - retVal = userController.answerdTransactJob( - from_user, user, date, answer) - from_userl = retVal['from_user'] - to_userl = retVal['to_user'] - retVal['from_user'] = retVal['from_user'].toJSON() - retVal['to_user'] = retVal['to_user'].toJSON() - retVal['date'] = {'year': year, 'month': month, 'day': day} - debug.debug("return {{ {} }}".format(retVal)) - jobL.info("Mitglied {} {} beantwortet Dienstanfrage von {} {} am {} mit {}".format(to_userl.firstname, - to_userl.lastname, from_userl.firstname, from_userl.lastname, date.date(), 'JA' if answer else 'NEIN')) - return jsonify(retVal) - except Exception as err: - debug.debug("exception", exc_info=True) - return jsonify({"error": str(err)}), 409 - - -@user.route("/user/jobRequests", methods=['POST']) -@login_required(groups=[USER]) -def _requests(**kwargs): - debug.info("/user/jobRequests") - try: - if 'accToken' in kwargs: - accToken = kwargs['accToken'] - user = accToken.user - data = request.get_json() - year = data['year'] - month = data['month'] - day = data['day'] - date = datetime(year, month, day, 12) - retVal = userController.getAllTransactJobToUser(user, date) - for data in retVal: - data['from_user'] = data['from_user'].toJSON() - data['to_user'] = data['to_user'].toJSON() - data_date = data['date'] - data['date'] = {'year': data_date.year, - 'month': data_date.month, 'day': data_date.day} - debug.debug("return {{ {} }}".format(retVal)) - return jsonify(retVal) - except Exception as err: - debug.debug("exception", exc_info=True) - return jsonify({"error": str(err)}), 409 - - -@user.route("/user/getTransactJobs", methods=['POST']) -@login_required(groups=[USER]) -def _getTransactJobs(**kwargs): - debug.info("/user/getTransactJobs") - try: - if 'accToken' in kwargs: - accToken = kwargs['accToken'] - user = accToken.user - data = request.get_json() - year = data['year'] - month = data['month'] - day = data['day'] - date = datetime(year, month, day, 12) - retVal = userController.getAllTransactJobFromUser(user, date) - for data in retVal: - data['from_user'] = data['from_user'].toJSON() - data['to_user'] = data['to_user'].toJSON() - data_date = data['date'] - data['date'] = {'year': data_date.year, - 'month': data_date.month, 'day': data_date.day} - debug.debug("return {{ {} }}".format(retVal)) - return jsonify(retVal) - except Exception as err: - debug.debug("exception", exc_info=True) - return jsonify({"error": str(err)}), 409 - - -@user.route("/user/deleteTransactJob", methods=['POST']) -@login_required(groups=[USER]) -def _deleteTransactJob(**kwargs): - debug.info("/user/deleteTransactJob") - try: - if 'accToken' in kwargs: - accToken = kwargs['accToken'] - from_user = accToken.user - data = request.get_json() - year = data['year'] - month = data['month'] - day = data['day'] - username = data['username'] - date = datetime(year, month, day, 12) - to_user = userController.getUser(username) - userController.deleteTransactJob(from_user, to_user, date) - debug.debug("return ok") - jobL.info("Mitglied {} {} entfernt Dienstanfrage an {} {} am {}".format( - from_user.firstname, from_user.lastname, to_user.firstname, to_user.lastname, date.date())) - return jsonify({"ok": "ok"}) - except Exception as err: - debug.debug("exception", exc_info=True) - return jsonify({"error": str(err)}), 409 - - @user.route("/user/storno", methods=['POST']) @login_required(groups=[USER]) def _storno(**kwargs): @@ -367,9 +260,9 @@ def _storno(**kwargs): amount = int(data['amount']) date = datetime.now() - userController.addCredit( + mainController.addCredit( user.uid, amount, year=date.year, month=date.month) - accToken.user = userController.getUser(accToken.user.uid) + accToken.user = mainController.getUser(accToken.user.uid) retVal = accToken.user.toJSON() retVal['creditList'] = {credit.year: credit.toJSON() for credit in accToken.user.geruechte} @@ -379,4 +272,117 @@ def _storno(**kwargs): return jsonify(retVal) except Exception as err: debug.debug("exception", exc_info=True) - return jsonify({"error": str(err)}), 409 + return jsonify({"error": str(err)}), 500 + + +@user.route("/user/getJobInvites", methods=['POST']) +@login_required(groups=[USER]) +def _getJobInvites(**kwargs): + try: + debug.info("/user/getJobInvites") + from_user = None + to_user = None + on_date = None + + data = request.get_json() + + if 'from_user' in data: + from_user = data['from_user'] + if 'to_user' in data: + to_user = data['to_user'] + on_date = date(data['date']['year'], data['date']['month'], data['date']['day']) + retVal = mainController.getJobInvites(from_user, to_user, on_date) + debug.debug("return {{ {} }}".format(retVal)) + return jsonify(retVal) + except Exception as err: + debug.debug("exception", exc_info=True) + return jsonify({"error": str(err)}), 500 + +@user.route("/user/JobInvites", methods=['PUT', 'POST']) +@login_required(groups=[USER]) +def _JobInvites(**kwargs): + try: + debug.info("/user/JobInvites") + data = request.get_json() + if request.method == 'PUT': + mainController.setJobInvites(data) + retVal = mainController.getJobInvites(kwargs['accToken'].user.toJSON(), None, datetime.now().date()) + debug.debug("return {{ {} }}".format(retVal)) + if request.method == 'POST': + retVal = mainController.updateJobInvites(data) + + return jsonify(retVal) + except Exception as err: + debug.debug("exception", exc_info=True) + return jsonify({"error": str(err)}), 500 + +@user.route("/user/deleteJobInvite", methods=['POST']) +@login_required(groups=[USER]) +def _deleteJobInvite(**kwargs): + try: + debug.info("/user/deleteJobInvite") + data = request.get_json() + mainController.deleteJobInvite(data) + retVal = mainController.getJobInvites(data['from_user'], None, datetime.now().date()) + debug.debug("return {{ {} }}".format(retVal)) + return jsonify(retVal) + except Exception as err: + debug.debug("exception", exc_info=True) + return jsonify({"error": str(err)}), 500 + + +@user.route("/user/getJobRequests", methods=['POST']) +@login_required(groups=[USER]) +def _getJobRequests(**kwargs): + try: + debug.info("/user/getJobRequests") + from_user = None + to_user = None + on_date = None + + data = request.get_json() + + if 'from_user' in data: + from_user = data['from_user'] + if 'to_user' in data: + to_user = data['to_user'] + on_date = date(data['date']['year'], data['date']['month'], data['date']['day']) + retVal = mainController.getJobRequests(from_user, to_user, on_date) + debug.debug("return {{ {} }}".format(retVal)) + return jsonify(retVal) + except Exception as err: + debug.debug("exception", exc_info=True) + return jsonify({"error": str(err)}), 500 + +@user.route("/user/JobRequests", methods=['PUT', 'POST']) +@login_required(groups=[USER]) +def _JobRequests(**kwargs): + try: + debug.info("/user/JobRequests") + data = request.get_json() + if request.method == 'PUT': + mainController.setJobRequests(data) + retVal = mainController.getJobRequests(kwargs['accToken'].user.toJSON(), None, datetime.now().date()) + debug.debug("return {{ {} }}".format(retVal)) + if request.method == 'POST': + data['on_date'] = date(data['on_date']['year'], data['on_date']['month'], data['on_date']['day']) + retVal = mainController.updateJobRequests(data) + + return jsonify(retVal) + except Exception as err: + debug.debug("exception", exc_info=True) + return jsonify({"error": str(err)}), 500 + +@user.route("/user/deleteJobRequest", methods=['POST']) +@login_required(groups=[USER]) +def _deleteJobRequest(**kwargs): + try: + debug.info("/user/deleteJobRequest") + data = request.get_json() + mainController.deleteJobRequest(data) + retVal = mainController.getJobRequests(data['from_user'], None, datetime.now().date()) + debug.debug("return {{ {} }}".format(retVal)) + return jsonify(retVal) + except Exception as err: + debug.debug("exception", exc_info=True) + return jsonify({"error": str(err)}), 500 \ No newline at end of file diff --git a/geruecht/vorstand/routes.py b/geruecht/vorstand/routes.py index 56b8ff6..143a6c6 100644 --- a/geruecht/vorstand/routes.py +++ b/geruecht/vorstand/routes.py @@ -1,6 +1,6 @@ from flask import Blueprint, request, jsonify -from datetime import datetime, time -import geruecht.controller.userController as uc +from datetime import datetime, time, date +import geruecht.controller.mainController as mc import geruecht.controller.ldapController as lc from geruecht.decorator import login_required from geruecht.model import MONEY, GASTRO, VORSTAND @@ -10,7 +10,7 @@ debug = getDebugLogger() jobL = getJobsLogger() vorstand = Blueprint("vorstand", __name__) -userController = uc.UserController() +mainController = mc.MainController() ldap = lc.LDAPController() @@ -21,7 +21,7 @@ def _setStatus(**kwargs): try: data = request.get_json() name = data['name'] - retVal = userController.setStatus(name) + retVal = mainController.setStatus(name) debug.debug("return {{ {} }}".format(retVal)) return jsonify(retVal) except Exception as err: @@ -35,7 +35,7 @@ def _updateStatus(**kwargs): debug.info("/um/updateStatus") try: data = request.get_json() - retVal = userController.updateStatus(data) + retVal = mainController.updateStatus(data) debug.debug("return {{ {} }}".format(retVal)) return jsonify(retVal) except Exception as err: @@ -49,7 +49,7 @@ def _deleteStatus(**kwargs): debug.info("/um/deleteStatus") try: data = request.get_json() - userController.deleteStatus(data) + mainController.deleteStatus(data) debug.debug("return ok") return jsonify({"ok": "ok"}) except Exception as err: @@ -65,7 +65,7 @@ def _updateStatusUser(**kwargs): data = request.get_json() username = data['username'] status = data['status'] - retVal = userController.updateStatusOfUser(username, status).toJSON() + retVal = mainController.updateStatusOfUser(username, status).toJSON() debug.debug("return {{ {} }}".format(retVal)) return jsonify(retVal) except Exception as err: @@ -81,7 +81,7 @@ def _updateVoting(**kwargs): data = request.get_json() username = data['username'] voting = data['voting'] - retVal = userController.updateVotingOfUser(username, voting).toJSON() + retVal = mainController.updateVotingOfUser(username, voting).toJSON() debug.debug("return {{ {} }}".format(retVal)) return jsonify(retVal) except Exception as err: @@ -94,7 +94,7 @@ def _updateWorkgroups(**kwargs): debug.info("/um/updateWorkgroups") try: data = request.get_json() - retVal = userController.updateWorkgroupsOfUser({"id": data['id']}, data['workgroups']) + retVal = mainController.updateWorkgroupsOfUser({"id": data['id']}, data['workgroups']) debug.debug("return {{ {} }}".format(retVal)) return jsonify(retVal), 200 except Exception as err: @@ -112,9 +112,12 @@ def _addUser(**kwargs): month = data['month'] year = data['year'] date = datetime(year, month, day, 12) - retVal = userController.addWorker(user['username'], date) + job_kind = None + if 'job_kind' in data: + job_kind = data['job_kind'] + retVal = mainController.addWorker(user['username'], date, job_kind=job_kind) debug.debug("retrun {{ {} }}".format(retVal)) - userl = userController.getUser(user['username']) + userl = mainController.getUser(user['username']) jobL.info("Vorstand {} {} schreibt Mitglied {} {} am {} zum Dienst ein".format( kwargs['accToken'].user.firstname, kwargs['accToken'].user.lastname, userl.firstname, userl.lastname, date.date())) return jsonify(retVal) @@ -123,41 +126,6 @@ def _addUser(**kwargs): return jsonify({"error": str(err)}), 500 -@vorstand.route("/sm/getUsers", methods=['POST']) -@login_required(groups=[MONEY, GASTRO, VORSTAND]) -def _getUsers(**kwrags): - debug.info("/sm/getUsers") - try: - data = request.get_json() - from_date = data['from_date'] - to_date = data['to_date'] - from_date = datetime( - from_date['year'], from_date['month'], from_date['day']) - to_date = datetime(to_date['year'], to_date['month'], to_date['day']) - lockedDays = userController.getLockedDays(from_date, to_date) - retVal = [] - for lockedDay in lockedDays: - day = datetime.combine(lockedDay['daydate'], time(12)) - retDay = { - "worker": userController.getWorker(day), - "day": { - "date": { - "year": day.year, - "month": day.month, - "day": day.day - }, - "locked": lockedDay['locked'] - } - } - retVal.append(retDay) - - debug.debug("return {{ {} }}".format(retVal)) - return jsonify(retVal) - except Exception as err: - debug.debug("exception", exc_info=True) - return jsonify({"error": str(err)}), 500 - - @vorstand.route("/sm/getUser", methods=['POST']) @login_required(groups=[MONEY, GASTRO, VORSTAND]) def _getUser(**kwargs): @@ -168,7 +136,7 @@ def _getUser(**kwargs): month = data['month'] year = data['year'] date = datetime(year, month, day, 12) - lockedDay = userController.getLockedDay(date) + lockedDay = mainController.getLockedDay(date) lockedDay = { 'date': { 'year': year, @@ -178,7 +146,7 @@ def _getUser(**kwargs): 'locked': lockedDay['locked'] } retVal = { - 'worker': userController.getWorker(date), + 'worker': mainController.getWorker(date), 'day': lockedDay } debug.debug("return {{ {} }}".format(retVal)) @@ -199,9 +167,9 @@ def _deletUser(**kwargs): month = data['month'] year = data['year'] date = datetime(year, month, day, 12) - userController.deleteWorker(user['username'], date) + mainController.deleteWorker(user['username'], date) debug.debug("return ok") - user = userController.getUser(user['username']) + user = mainController.getUser(user['username']) jobL.info("Vorstand {} {} entfernt Mitglied {} {} am {} vom Dienst".format( kwargs['accToken'].user.firstname, kwargs['accToken'].user.lastname, user.firstname, user.lastname, date.date())) return jsonify({"ok": "ok"}) @@ -214,7 +182,7 @@ def _deletUser(**kwargs): def _getAllWorkgroups(**kwargs): try: debug.info("get all workgroups") - retVal = userController.getAllWorkgroups() + retVal = mainController.getAllWorkgroups() debug.info("return all workgroups {{ {} }}".format(retVal)) return jsonify(retVal) except Exception as err: @@ -229,7 +197,7 @@ def _getWorkgroup(**kwargs): data = request.get_json() name = data['name'] debug.info("get workgroup {{ {} }}".format(name)) - retVal = userController.getWorkgroups(name) + retVal = mainController.getWorkgroups(name) debug.info( "return workgroup {{ {} }} : {{ {} }}".format(name, retVal)) return jsonify(retVal) @@ -248,10 +216,10 @@ def _workgroup(**kwargs): boss = None if 'boss' in data: boss = data['boss'] - retVal = userController.setWorkgroup(name, boss) + retVal = mainController.setWorkgroup(name, boss) debug.debug("return {{ {} }}".format(retVal)) if request.method == 'POST': - retVal = userController.updateWorkgroup(data) + retVal = mainController.updateWorkgroup(data) debug.debug("return {{ {} }}".format(retVal)) return jsonify(retVal) except Exception as err: @@ -264,7 +232,7 @@ def _deleteWorkgroup(**kwargs): try: data = request.get_json() debug.info("/wgm/deleteWorkgroup") - userController.deleteWorkgroup(data) + mainController.deleteWorkgroup(data) retVal = {"ok": "ok"} debug.debug("return ok") return jsonify(retVal) @@ -272,6 +240,95 @@ def _deleteWorkgroup(**kwargs): debug.debug("exception", exc_info=True) return jsonify({"error": str(err)}), 500 +@vorstand.route("/sm/getAllJobKinds", methods=['GET']) +@login_required(bar=True) +def _getAllJobKinds(**kwargs): + try: + debug.info("get all jobkinds") + retVal = mainController.getAllJobKinds() + debug.info("return all jobkinds {{ {} }}".format(retVal)) + return jsonify(retVal) + except Exception as err: + debug.warning("exception in get all workgroups.", exc_info=True) + return jsonify({"error": str(err)}), 500 + +@vorstand.route("/sm/getJobKind", methods=['POST']) +@login_required(bar=True) +def _getJobKinds(**kwargs): + try: + debug.info("get jobkind") + data = request.get_json() + name = data['name'] + debug.info("get jobkind {{ {} }}".format(name)) + retVal = mainController.getJobKind(name) + debug.info( + "return workgroup {{ {} }} : {{ {} }}".format(name, retVal)) + return jsonify(retVal) + except Exception as err: + debug.warning("exception in get workgroup.", exc_info=True) + return jsonify({"error": str(err)}), 500 + +@vorstand.route("/sm/JobKind", methods=['POST', 'PUT', 'DELETE']) +@login_required(groups=[MONEY, GASTRO, VORSTAND]) +def _JobKinds(**kwargs): + debug.info("/sm/JobKind") + try: + data = request.get_json() + if request.method == 'PUT': + name = data['name'] + workgroup = None + if 'workgroup' in data: + workgroup = data['workgroup'] + retVal = mainController.setJobKind(name, workgroup) + debug.debug("return {{ {} }}".format(retVal)) + if request.method == 'POST': + retVal = mainController.updateJobKind(data) + debug.debug("return {{ {} }}".format(retVal)) + return jsonify(retVal) + except Exception as err: + debug.debug("exception", exc_info=True) + return jsonify({"error": str(err)}), 500 + +@vorstand.route("/sm/deleteJobKind", methods=['POST']) +@login_required(groups=[VORSTAND]) +def _deleteJobKind(**kwargs): + try: + data = request.get_json() + debug.info("/sm/deleteJobKind") + mainController.deleteJobKind(data) + retVal = {"ok": "ok"} + debug.debug("return ok") + return jsonify(retVal) + except Exception as err: + debug.debug("exception", exc_info=True) + return jsonify({"error": str(err)}), 500 + +@vorstand.route("/jk/getJobKindDates", methods=['POST']) +@login_required() +def _getJobKindDates(**kwargs): + try: + debug.info("/jk/getJobKindDates") + data = request.get_json() + datum = date(data['year'], data['month'], data['day']) + retVal = mainController.getJobKindDates(datum) + debug.debug("return {{ {} }}".format(retVal)) + return jsonify(retVal) + except Exception as err: + debug.debug("exception", exc_info=True) + return jsonify({"error": str(err)}), 500 + +@vorstand.route("/jk/JobKindDate", methods=['POST']) +@login_required(groups=[VORSTAND]) +def _jobKindDates(**kwargs): + try: + debug.info("/jk/JobKindDate") + data = request.get_json() + retVal = mainController.controllJobKindDates(data) + debug.debug("return {{ {} }}".format(retVal)) + return jsonify(retVal) + except Exception as err: + debug.debug("exception", exc_info=True) + return jsonify({"error": str(err)}), 500 @vorstand.route("/sm/lockDay", methods=['POST']) @login_required(groups=[MONEY, GASTRO, VORSTAND]) @@ -284,7 +341,7 @@ def _lockDay(**kwargs): day = data['day'] locked = data['locked'] date = datetime(year, month, day, 12) - lockedDay = userController.setLockedDay(date, locked, True) + lockedDay = mainController.setLockedDay(date, locked, True) if not lockedDay: retVal = { 'date': {