From 04d6254262a2a10327877bb255f2e58a468a76ef Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tim=20Gr=C3=B6ger?= Date: Sun, 17 May 2020 20:21:22 +0200 Subject: [PATCH 1/8] vorstand can create, edit or delete job_kinds --- geruecht/controller/databaseController.py | 60 +++++++++++++++++++++++ geruecht/controller/userController.py | 29 +++++++++++ geruecht/vorstand/routes.py | 59 ++++++++++++++++++++++ 3 files changed, 148 insertions(+) diff --git a/geruecht/controller/databaseController.py b/geruecht/controller/databaseController.py index 82d32b9..8e760c2 100644 --- a/geruecht/controller/databaseController.py +++ b/geruecht/controller/databaseController.py @@ -700,6 +700,66 @@ class DatabaseController(metaclass=Singleton): self.db.connection.rollback() raise DatabaseExecption("Something went wrong with Database: {}".format(err)) + def getAllJobKinds(self): + try: + cursor = self.db.connection.cursor() + cursor.execute('select * from job_kind') + list = cursor.fetchall() + 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() + 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): + try: + cursor = self.db.connection.cursor() + cursor.execute("insert into job_kind (name) values ('{}')".format(name)) + 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='{}'where id={}".format(jobkind['name'], 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)) + if __name__ == '__main__': db = DatabaseController() user = db.getUser('jhille') diff --git a/geruecht/controller/userController.py b/geruecht/controller/userController.py index ebdffde..b129317 100644 --- a/geruecht/controller/userController.py +++ b/geruecht/controller/userController.py @@ -23,6 +23,35 @@ class UserController(metaclass=Singleton): debug.debug("init UserController") pass + 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): + debug.info("set jobkind {{ {} }} ".format(name)) + retVal = db.setJobKind(name) + 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 updateWorkgroupsOfUser(self, user, workgroups): debug.info("update workgroups {{ {} }} of user {{ {} }}".format(workgroups, user)) db.deleteWorkgroupsOfUser(user) diff --git a/geruecht/vorstand/routes.py b/geruecht/vorstand/routes.py index 56b8ff6..4e99868 100644 --- a/geruecht/vorstand/routes.py +++ b/geruecht/vorstand/routes.py @@ -272,6 +272,65 @@ 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 = userController.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 = userController.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'] + retVal = userController.setJobKind(name) + debug.debug("return {{ {} }}".format(retVal)) + if request.method == 'POST': + retVal = userController.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") + userController.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("/sm/lockDay", methods=['POST']) @login_required(groups=[MONEY, GASTRO, VORSTAND]) From 7ce8fef278e1f1038c3b1389ee9ebe0bf7a84304 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tim=20Gr=C3=B6ger?= Date: Sun, 17 May 2020 21:18:56 +0200 Subject: [PATCH 2/8] vorstand can change the group for jobkind --- geruecht/controller/databaseController.py | 9 ++++++--- geruecht/controller/userController.py | 4 ++-- geruecht/vorstand/routes.py | 5 ++++- 3 files changed, 12 insertions(+), 6 deletions(-) diff --git a/geruecht/controller/databaseController.py b/geruecht/controller/databaseController.py index 8e760c2..59c5b1b 100644 --- a/geruecht/controller/databaseController.py +++ b/geruecht/controller/databaseController.py @@ -705,6 +705,8 @@ class DatabaseController(metaclass=Singleton): 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() @@ -722,16 +724,17 @@ class DatabaseController(metaclass=Singleton): 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): + def setJobKind(self, name, workgroup_id): try: cursor = self.db.connection.cursor() - cursor.execute("insert into job_kind (name) values ('{}')".format(name)) + 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: @@ -742,7 +745,7 @@ class DatabaseController(metaclass=Singleton): def updateJobKind(self, jobkind): try: cursor = self.db.connection.cursor() - cursor.execute("update job_kind set name='{}'where id={}".format(jobkind['name'], jobkind['id'])) + 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: diff --git a/geruecht/controller/userController.py b/geruecht/controller/userController.py index b129317..3e6f605 100644 --- a/geruecht/controller/userController.py +++ b/geruecht/controller/userController.py @@ -35,9 +35,9 @@ class UserController(metaclass=Singleton): debug.debug("jobkind is {{ {} }} is {{ {} }}".format(name, retVal)) return retVal - def setJobKind(self, name): + def setJobKind(self, name, workgroup=None): debug.info("set jobkind {{ {} }} ".format(name)) - retVal = db.setJobKind(name) + retVal = db.setJobKind(name, workgroup) debug.debug( "seted jobkind {{ {} }} is {{ {} }}".format(name, retVal)) return retVal diff --git a/geruecht/vorstand/routes.py b/geruecht/vorstand/routes.py index 4e99868..b098fff 100644 --- a/geruecht/vorstand/routes.py +++ b/geruecht/vorstand/routes.py @@ -308,7 +308,10 @@ def _JobKinds(**kwargs): data = request.get_json() if request.method == 'PUT': name = data['name'] - retVal = userController.setJobKind(name) + workgroup = None + if 'workgroup' in data: + workgroup = data['workgroup'] + retVal = userController.setJobKind(name, workgroup) debug.debug("return {{ {} }}".format(retVal)) if request.method == 'POST': retVal = userController.updateJobKind(data) From 2ef50fbefd50f4e481081219dfcf0fcb87328ad1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tim=20Gr=C3=B6ger?= Date: Fri, 22 May 2020 21:55:14 +0200 Subject: [PATCH 3/8] vorstand can set job_kinds for day with max persons extern user can be set if job_kind is delete, all jobs are deleted for this date and job_kind --- geruecht/baruser/routes.py | 16 +- geruecht/controller/accesTokenController.py | 6 +- geruecht/controller/databaseController.py | 769 ------------------ .../controller/databaseController/__init__.py | 61 ++ .../dbCreditListController.py | 66 ++ .../databaseController/dbJobKindController.py | 112 +++ .../dbJobTransactController.py | 110 +++ .../dbPricelistController.py | 128 +++ .../databaseController/dbUserController.py | 197 +++++ .../databaseController/dbWorkerController.py | 67 ++ .../dbWorkgroupController.py | 126 +++ geruecht/controller/emailController.py | 21 +- geruecht/controller/ldapController.py | 2 + .../controller/mainController/__init__.py | 141 ++++ .../mainCreditListController.py | 83 ++ .../mainController/mainJobKindController.py | 89 ++ .../mainJobTransactController.py | 71 ++ .../mainController/mainPricelistController.py | 50 ++ .../mainController/mainUserController.py | 160 ++++ .../mainController/mainWorkerController.py | 65 ++ .../mainController/mainWorkgroupController.py | 42 + geruecht/controller/userController.py | 588 ------------- geruecht/finanzer/routes.py | 26 +- geruecht/gastro/routes.py | 16 +- geruecht/routes.py | 21 +- geruecht/user/routes.py | 47 +- geruecht/vorstand/routes.py | 117 ++- 27 files changed, 1704 insertions(+), 1493 deletions(-) delete mode 100644 geruecht/controller/databaseController.py create mode 100644 geruecht/controller/databaseController/__init__.py create mode 100644 geruecht/controller/databaseController/dbCreditListController.py create mode 100644 geruecht/controller/databaseController/dbJobKindController.py create mode 100644 geruecht/controller/databaseController/dbJobTransactController.py create mode 100644 geruecht/controller/databaseController/dbPricelistController.py create mode 100644 geruecht/controller/databaseController/dbUserController.py create mode 100644 geruecht/controller/databaseController/dbWorkerController.py create mode 100644 geruecht/controller/databaseController/dbWorkgroupController.py create mode 100644 geruecht/controller/mainController/__init__.py create mode 100644 geruecht/controller/mainController/mainCreditListController.py create mode 100644 geruecht/controller/mainController/mainJobKindController.py create mode 100644 geruecht/controller/mainController/mainJobTransactController.py create mode 100644 geruecht/controller/mainController/mainPricelistController.py create mode 100644 geruecht/controller/mainController/mainUserController.py create mode 100644 geruecht/controller/mainController/mainWorkerController.py create mode 100644 geruecht/controller/mainController/mainWorkgroupController.py delete mode 100644 geruecht/controller/userController.py 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 59c5b1b..0000000 --- a/geruecht/controller/databaseController.py +++ /dev/null @@ -1,769 +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)) - - 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)) - -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..91f8f8e --- /dev/null +++ b/geruecht/controller/databaseController/__init__.py @@ -0,0 +1,61 @@ +from ..mainController import Singleton +from geruecht import db +from ..databaseController import dbUserController, dbCreditListController, dbJobKindController, dbJobTransactController, dbPricelistController, dbWorkerController, dbWorkgroupController +from geruecht.exceptions import DatabaseExecption +import traceback +from MySQLdb._exceptions import IntegrityError + +class DatabaseController(dbUserController.Base, dbCreditListController.Base, dbWorkerController.Base, dbWorkgroupController.Base, dbPricelistController.Base, dbJobTransactController.Base, dbJobKindController.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/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/dbJobTransactController.py b/geruecht/controller/databaseController/dbJobTransactController.py new file mode 100644 index 0000000..cafe463 --- /dev/null +++ b/geruecht/controller/databaseController/dbJobTransactController.py @@ -0,0 +1,110 @@ +import traceback + +from MySQLdb._exceptions import IntegrityError + +from geruecht.exceptions import DatabaseExecption + + +class Base: + 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 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)) \ 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..134625d --- /dev/null +++ b/geruecht/controller/databaseController/dbWorkerController.py @@ -0,0 +1,67 @@ +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 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..a2c9013 --- /dev/null +++ b/geruecht/controller/mainController/__init__.py @@ -0,0 +1,141 @@ +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, mainJobTransactController, mainPricelistController, mainUserController, mainWorkerController, mainWorkgroupController + +db = dc.DatabaseController() +ldap = lc.LDAPController() +emailController = ec.EmailController() + +debug = getDebugLogger() + + +class MainController(mainJobKindController.Base, + mainCreditListController.Base, + mainJobTransactController.Base, + mainPricelistController.Base, + mainUserController.Base, + mainWorkerController.Base, + mainWorkgroupController.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 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/mainJobKindController.py b/geruecht/controller/mainController/mainJobKindController.py new file mode 100644 index 0000000..cc23f6c --- /dev/null +++ b/geruecht/controller/mainController/mainJobKindController.py @@ -0,0 +1,89 @@ +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: + 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/mainJobTransactController.py b/geruecht/controller/mainController/mainJobTransactController.py new file mode 100644 index 0000000..87e085f --- /dev/null +++ b/geruecht/controller/mainController/mainJobTransactController.py @@ -0,0 +1,71 @@ +import geruecht.controller.databaseController as dc +import geruecht.controller.emailController as ec +from geruecht.exceptions import TansactJobIsAnswerdException +from geruecht.logger import getDebugLogger + +db = dc.DatabaseController() +emailController = ec.EmailController() +debug = getDebugLogger() + +class Base: + 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 \ 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..cbce839 --- /dev/null +++ b/geruecht/controller/mainController/mainWorkerController.py @@ -0,0 +1,65 @@ +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 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) \ 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 3e6f605..0000000 --- a/geruecht/controller/userController.py +++ /dev/null @@ -1,588 +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 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 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..ff05912 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) @@ -84,8 +84,11 @@ def _getStatus(**kwargs): @login_required(groups=[MONEY, GASTRO, VORSTAND], 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..0396106 100644 --- a/geruecht/user/routes.py +++ b/geruecht/user/routes.py @@ -1,6 +1,6 @@ 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 geruecht.exceptions import DayLocked @@ -8,7 +8,7 @@ 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) @@ -123,7 +124,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 +144,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 +167,7 @@ def _addUser(**kwargs): month = data['month'] year = data['year'] date = datetime(year, month, day, 12) - retVal = userController.addWorker(user.uid, date, userExc=True) + retVal = mainController.addWorker(user.uid, date, userExc=True) debug.debug("return {{ {} }}".format(retVal)) jobL.info("Mitglied {} {} schreib sich am {} zum Dienst ein.".format( user.firstname, user.lastname, date.date())) @@ -192,7 +193,7 @@ 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) debug.debug("return ok") jobL.info("Mitglied {} {} entfernt sich am {} aus dem Dienst".format( user.firstname, user.lastname, date.date())) @@ -219,8 +220,8 @@ def _transactJob(**kwargs): day = data['day'] username = data['user'] date = datetime(year, month, day, 12) - to_user = userController.getUser(username) - retVal = userController.setTransactJob(user, to_user, date) + to_user = mainController.getUser(username) + retVal = mainController.setTransactJob(user, to_user, date) from_userl = retVal['from_user'] to_userl = retVal['to_user'] retVal['from_user'] = retVal['from_user'].toJSON() @@ -250,8 +251,8 @@ def _answer(**kwargs): answer = data['answer'] username = data['username'] date = datetime(year, month, day, 12) - from_user = userController.getUser(username) - retVal = userController.answerdTransactJob( + from_user = mainController.getUser(username) + retVal = mainController.answerdTransactJob( from_user, user, date, answer) from_userl = retVal['from_user'] to_userl = retVal['to_user'] @@ -280,7 +281,7 @@ def _requests(**kwargs): month = data['month'] day = data['day'] date = datetime(year, month, day, 12) - retVal = userController.getAllTransactJobToUser(user, date) + retVal = mainController.getAllTransactJobToUser(user, date) for data in retVal: data['from_user'] = data['from_user'].toJSON() data['to_user'] = data['to_user'].toJSON() @@ -307,7 +308,7 @@ def _getTransactJobs(**kwargs): month = data['month'] day = data['day'] date = datetime(year, month, day, 12) - retVal = userController.getAllTransactJobFromUser(user, date) + retVal = mainController.getAllTransactJobFromUser(user, date) for data in retVal: data['from_user'] = data['from_user'].toJSON() data['to_user'] = data['to_user'].toJSON() @@ -335,8 +336,8 @@ def _deleteTransactJob(**kwargs): day = data['day'] username = data['username'] date = datetime(year, month, day, 12) - to_user = userController.getUser(username) - userController.deleteTransactJob(from_user, to_user, date) + to_user = mainController.getUser(username) + mainController.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())) @@ -367,9 +368,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} diff --git a/geruecht/vorstand/routes.py b/geruecht/vorstand/routes.py index b098fff..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) @@ -277,7 +245,7 @@ def _deleteWorkgroup(**kwargs): def _getAllJobKinds(**kwargs): try: debug.info("get all jobkinds") - retVal = userController.getAllJobKinds() + retVal = mainController.getAllJobKinds() debug.info("return all jobkinds {{ {} }}".format(retVal)) return jsonify(retVal) except Exception as err: @@ -292,7 +260,7 @@ def _getJobKinds(**kwargs): data = request.get_json() name = data['name'] debug.info("get jobkind {{ {} }}".format(name)) - retVal = userController.getJobKind(name) + retVal = mainController.getJobKind(name) debug.info( "return workgroup {{ {} }} : {{ {} }}".format(name, retVal)) return jsonify(retVal) @@ -311,10 +279,10 @@ def _JobKinds(**kwargs): workgroup = None if 'workgroup' in data: workgroup = data['workgroup'] - retVal = userController.setJobKind(name, workgroup) + retVal = mainController.setJobKind(name, workgroup) debug.debug("return {{ {} }}".format(retVal)) if request.method == 'POST': - retVal = userController.updateJobKind(data) + retVal = mainController.updateJobKind(data) debug.debug("return {{ {} }}".format(retVal)) return jsonify(retVal) except Exception as err: @@ -327,7 +295,7 @@ def _deleteJobKind(**kwargs): try: data = request.get_json() debug.info("/sm/deleteJobKind") - userController.deleteJobKind(data) + mainController.deleteJobKind(data) retVal = {"ok": "ok"} debug.debug("return ok") return jsonify(retVal) @@ -335,6 +303,33 @@ def _deleteJobKind(**kwargs): 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]) def _lockDay(**kwargs): @@ -346,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': { From 7bd7acc6bf5f12f8015eeb3e48b88a9743e8b4e3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tim=20Gr=C3=B6ger?= Date: Sun, 24 May 2020 22:12:46 +0200 Subject: [PATCH 4/8] =?UTF-8?q?routes=20f=C3=BCr=20user=20erweitert,=20sod?= =?UTF-8?q?ass=20sich=20der=20user=20in=20einen=20bestimmten=20dienst=20ei?= =?UTF-8?q?nschreiben=20kann.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- geruecht/user/routes.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/geruecht/user/routes.py b/geruecht/user/routes.py index 0396106..6ebd0b6 100644 --- a/geruecht/user/routes.py +++ b/geruecht/user/routes.py @@ -167,7 +167,11 @@ def _addUser(**kwargs): month = data['month'] year = data['year'] date = datetime(year, month, day, 12) - retVal = mainController.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())) From efa0257cd05271227952fb289419a1445e4951de Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tim=20Gr=C3=B6ger?= Date: Wed, 27 May 2020 12:10:51 +0200 Subject: [PATCH 5/8] =?UTF-8?q?user=20k=C3=B6nnen=20sich=20einladen,=20und?= =?UTF-8?q?=20austragen,=20jobinvites=20k=C3=B6nnen=20geupdated=20werden?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../controller/databaseController/__init__.py | 11 +- .../dbJobInviteController.py | 84 +++++++ .../dbJobTransactController.py | 110 -------- .../controller/mainController/__init__.py | 12 +- .../mainController/mainJobInviteController.py | 38 +++ .../mainJobTransactController.py | 71 ------ .../mainController/mainWorkerController.py | 15 +- geruecht/routes.py | 2 +- geruecht/user/routes.py | 234 +++++++----------- 9 files changed, 233 insertions(+), 344 deletions(-) create mode 100644 geruecht/controller/databaseController/dbJobInviteController.py delete mode 100644 geruecht/controller/databaseController/dbJobTransactController.py create mode 100644 geruecht/controller/mainController/mainJobInviteController.py delete mode 100644 geruecht/controller/mainController/mainJobTransactController.py diff --git a/geruecht/controller/databaseController/__init__.py b/geruecht/controller/databaseController/__init__.py index 91f8f8e..76a47c6 100644 --- a/geruecht/controller/databaseController/__init__.py +++ b/geruecht/controller/databaseController/__init__.py @@ -1,11 +1,18 @@ from ..mainController import Singleton from geruecht import db -from ..databaseController import dbUserController, dbCreditListController, dbJobKindController, dbJobTransactController, dbPricelistController, dbWorkerController, dbWorkgroupController +from ..databaseController import dbUserController, dbCreditListController, dbJobKindController, dbPricelistController, dbWorkerController, dbWorkgroupController, dbJobInviteController from geruecht.exceptions import DatabaseExecption import traceback from MySQLdb._exceptions import IntegrityError -class DatabaseController(dbUserController.Base, dbCreditListController.Base, dbWorkerController.Base, dbWorkgroupController.Base, dbPricelistController.Base, dbJobTransactController.Base, dbJobKindController.Base, metaclass=Singleton): +class DatabaseController(dbUserController.Base, + dbCreditListController.Base, + dbWorkerController.Base, + dbWorkgroupController.Base, + dbPricelistController.Base, + dbJobKindController.Base, + dbJobInviteController.Base, + metaclass=Singleton): ''' DatabaesController 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/dbJobTransactController.py b/geruecht/controller/databaseController/dbJobTransactController.py deleted file mode 100644 index cafe463..0000000 --- a/geruecht/controller/databaseController/dbJobTransactController.py +++ /dev/null @@ -1,110 +0,0 @@ -import traceback - -from MySQLdb._exceptions import IntegrityError - -from geruecht.exceptions import DatabaseExecption - - -class Base: - 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 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)) \ No newline at end of file diff --git a/geruecht/controller/mainController/__init__.py b/geruecht/controller/mainController/__init__.py index a2c9013..3d4c969 100644 --- a/geruecht/controller/mainController/__init__.py +++ b/geruecht/controller/mainController/__init__.py @@ -5,7 +5,7 @@ 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, mainJobTransactController, mainPricelistController, mainUserController, mainWorkerController, mainWorkgroupController +from ..mainController import mainJobKindController, mainCreditListController, mainPricelistController, mainUserController, mainWorkerController, mainWorkgroupController, mainJobInviteController db = dc.DatabaseController() ldap = lc.LDAPController() @@ -16,11 +16,11 @@ debug = getDebugLogger() class MainController(mainJobKindController.Base, mainCreditListController.Base, - mainJobTransactController.Base, mainPricelistController.Base, mainUserController.Base, mainWorkerController.Base, mainWorkgroupController.Base, + mainJobInviteController.Base, metaclass=Singleton): def __init__(self): @@ -48,6 +48,14 @@ class MainController(mainJobKindController.Base, 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() 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/mainJobTransactController.py b/geruecht/controller/mainController/mainJobTransactController.py deleted file mode 100644 index 87e085f..0000000 --- a/geruecht/controller/mainController/mainJobTransactController.py +++ /dev/null @@ -1,71 +0,0 @@ -import geruecht.controller.databaseController as dc -import geruecht.controller.emailController as ec -from geruecht.exceptions import TansactJobIsAnswerdException -from geruecht.logger import getDebugLogger - -db = dc.DatabaseController() -emailController = ec.EmailController() -debug = getDebugLogger() - -class Base: - 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 \ No newline at end of file diff --git a/geruecht/controller/mainController/mainWorkerController.py b/geruecht/controller/mainController/mainWorkerController.py index cbce839..95bd2a0 100644 --- a/geruecht/controller/mainController/mainWorkerController.py +++ b/geruecht/controller/mainController/mainWorkerController.py @@ -1,3 +1,5 @@ +from datetime import time, datetime + import geruecht.controller.databaseController as dc from geruecht.exceptions import DayLocked from geruecht.logger import getDebugLogger @@ -47,19 +49,6 @@ class Base: 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) \ No newline at end of file diff --git a/geruecht/routes.py b/geruecht/routes.py index ff05912..96dc57e 100644 --- a/geruecht/routes.py +++ b/geruecht/routes.py @@ -81,7 +81,7 @@ 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 diff --git a/geruecht/user/routes.py b/geruecht/user/routes.py index 6ebd0b6..e9b49b0 100644 --- a/geruecht/user/routes.py +++ b/geruecht/user/routes.py @@ -2,7 +2,7 @@ from flask import Blueprint, request, jsonify from geruecht.decorator import login_required 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 @@ -113,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]) @@ -198,10 +227,11 @@ def _deletJob(**kwargs): year = data['year'] date = datetime(year, month, day, 12) 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 @@ -209,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 = mainController.getUser(username) - retVal = mainController.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 = mainController.getUser(username) - retVal = mainController.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 = mainController.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 = mainController.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 = mainController.getUser(username) - mainController.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): @@ -384,4 +272,60 @@ 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 \ No newline at end of file From dcc9c5ee1426296ee9588bb241154cd1cc0a17ca Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tim=20Gr=C3=B6ger?= Date: Wed, 27 May 2020 15:05:19 +0200 Subject: [PATCH 6/8] fix, dass keine job_kinddates gespeichert werden, wo kein job_kind existiert. --- geruecht/controller/mainController/mainJobKindController.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/geruecht/controller/mainController/mainJobKindController.py b/geruecht/controller/mainController/mainJobKindController.py index cc23f6c..3eb67f0 100644 --- a/geruecht/controller/mainController/mainJobKindController.py +++ b/geruecht/controller/mainController/mainJobKindController.py @@ -63,7 +63,8 @@ class Base: for jobkinddate in jobkinddates: datum = date(jobkinddate['daydate']['year'], jobkinddate['daydate']['month'], jobkinddate['daydate']['day']) if jobkinddate['id'] == -1: - self.setJobKindDates(datum, jobkinddate['job_kind'], jobkinddate['maxpersons']) + 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']) From b0f09969a5322381b3743965f1761ef348f866a1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tim=20Gr=C3=B6ger?= Date: Tue, 2 Jun 2020 23:24:17 +0200 Subject: [PATCH 7/8] =?UTF-8?q?user=20kann=20jobrequest=20updaten,=20erste?= =?UTF-8?q?llen=20oder=20l=C3=B6schen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../controller/databaseController/__init__.py | 3 +- .../dbJobRequesController.py | 97 +++++++++++++++++++ .../databaseController/dbWorkerController.py | 10 ++ .../controller/mainController/__init__.py | 3 +- .../mainJobRequestController.py | 41 ++++++++ .../mainController/mainWorkerController.py | 4 + geruecht/user/routes.py | 57 +++++++++++ 7 files changed, 213 insertions(+), 2 deletions(-) create mode 100644 geruecht/controller/databaseController/dbJobRequesController.py create mode 100644 geruecht/controller/mainController/mainJobRequestController.py diff --git a/geruecht/controller/databaseController/__init__.py b/geruecht/controller/databaseController/__init__.py index 76a47c6..9ab55bb 100644 --- a/geruecht/controller/databaseController/__init__.py +++ b/geruecht/controller/databaseController/__init__.py @@ -1,6 +1,6 @@ from ..mainController import Singleton from geruecht import db -from ..databaseController import dbUserController, dbCreditListController, dbJobKindController, dbPricelistController, dbWorkerController, dbWorkgroupController, dbJobInviteController +from ..databaseController import dbUserController, dbCreditListController, dbJobKindController, dbPricelistController, dbWorkerController, dbWorkgroupController, dbJobInviteController, dbJobRequesController from geruecht.exceptions import DatabaseExecption import traceback from MySQLdb._exceptions import IntegrityError @@ -12,6 +12,7 @@ class DatabaseController(dbUserController.Base, dbPricelistController.Base, dbJobKindController.Base, dbJobInviteController.Base, + dbJobRequesController.Base, metaclass=Singleton): ''' DatabaesController diff --git a/geruecht/controller/databaseController/dbJobRequesController.py b/geruecht/controller/databaseController/dbJobRequesController.py new file mode 100644 index 0000000..b65e323 --- /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={} where id={}".format(jobrequest['watched'], jobrequest['answered'], 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={}, accepted={} where from_user={} and on_date='{}'".format(jobrequest['answered'], jobrequest['accepted'], 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/dbWorkerController.py b/geruecht/controller/databaseController/dbWorkerController.py index 134625d..7a2e917 100644 --- a/geruecht/controller/databaseController/dbWorkerController.py +++ b/geruecht/controller/databaseController/dbWorkerController.py @@ -46,6 +46,16 @@ class Base: 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() diff --git a/geruecht/controller/mainController/__init__.py b/geruecht/controller/mainController/__init__.py index 3d4c969..41f2a7f 100644 --- a/geruecht/controller/mainController/__init__.py +++ b/geruecht/controller/mainController/__init__.py @@ -5,7 +5,7 @@ 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 +from ..mainController import mainJobKindController, mainCreditListController, mainPricelistController, mainUserController, mainWorkerController, mainWorkgroupController, mainJobInviteController, mainJobRequestController db = dc.DatabaseController() ldap = lc.LDAPController() @@ -21,6 +21,7 @@ class MainController(mainJobKindController.Base, mainWorkerController.Base, mainWorkgroupController.Base, mainJobInviteController.Base, + mainJobRequestController.Base, metaclass=Singleton): def __init__(self): diff --git a/geruecht/controller/mainController/mainJobRequestController.py b/geruecht/controller/mainController/mainJobRequestController.py new file mode 100644 index 0000000..8c7bc1f --- /dev/null +++ b/geruecht/controller/mainController/mainJobRequestController.py @@ -0,0 +1,41 @@ +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']) + debug.info("set new JobRequest from_user {{ {} }}, to_user {{ {} }}, on_date {{ {} }}") + retVal.append(db.setJobRequest(from_user, to_user, on_date)) + 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/mainWorkerController.py b/geruecht/controller/mainController/mainWorkerController.py index 95bd2a0..4ae0d16 100644 --- a/geruecht/controller/mainController/mainWorkerController.py +++ b/geruecht/controller/mainController/mainWorkerController.py @@ -39,6 +39,10 @@ class Base: 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)) diff --git a/geruecht/user/routes.py b/geruecht/user/routes.py index e9b49b0..b48e5b3 100644 --- a/geruecht/user/routes.py +++ b/geruecht/user/routes.py @@ -326,6 +326,63 @@ def _deleteJobInvite(**kwargs): 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() + data['on_date'] = date(data['on_date']['year'], data['on_date']['month'], data['on_date']['day']) + 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': + 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 From fd2c9a2a7e4924a41d88430eb118c5de36b247e5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tim=20Gr=C3=B6ger?= Date: Thu, 4 Jun 2020 13:19:00 +0200 Subject: [PATCH 8/8] =?UTF-8?q?diensteinladung=20und=20=C3=BCbertragung=20?= =?UTF-8?q?fertig.=20User=20k=C3=B6nnen=20leute=20einladen,=20sich=20austr?= =?UTF-8?q?agen,=20jobs=20abgeben=20usw.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit user können sehen, wenn es neue nachrichten gibt und sehen ob die einladung bzw. anfrage gesehen wurde. --- .../controller/databaseController/dbJobRequesController.py | 4 ++-- .../controller/mainController/mainJobRequestController.py | 3 ++- geruecht/user/routes.py | 2 +- 3 files changed, 5 insertions(+), 4 deletions(-) diff --git a/geruecht/controller/databaseController/dbJobRequesController.py b/geruecht/controller/databaseController/dbJobRequesController.py index b65e323..8f77752 100644 --- a/geruecht/controller/databaseController/dbJobRequesController.py +++ b/geruecht/controller/databaseController/dbJobRequesController.py @@ -68,7 +68,7 @@ class Base: def updateJobRequest(self, jobrequest): try: cursor = self.db.connection.cursor() - cursor.execute("update job_request set watched={}, answered={} where id={}".format(jobrequest['watched'], jobrequest['answered'], jobrequest['id'])) + 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: @@ -79,7 +79,7 @@ class Base: def updateAllJobRequest(self, jobrequest): try: cursor = self.db.connection.cursor() - cursor.execute("update job_request set answered={}, accepted={} where from_user={} and on_date='{}'".format(jobrequest['answered'], jobrequest['accepted'], jobrequest['from_user']['id'], jobrequest['on_date'])) + 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() diff --git a/geruecht/controller/mainController/mainJobRequestController.py b/geruecht/controller/mainController/mainJobRequestController.py index 8c7bc1f..05529a6 100644 --- a/geruecht/controller/mainController/mainJobRequestController.py +++ b/geruecht/controller/mainController/mainJobRequestController.py @@ -24,8 +24,9 @@ class Base: 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)) + retVal.append(db.setJobRequest(from_user, to_user, on_date, job_kind)) debug.debug("seted JobRequests are {{ {} }}".format(retVal)) return retVal diff --git a/geruecht/user/routes.py b/geruecht/user/routes.py index b48e5b3..e433798 100644 --- a/geruecht/user/routes.py +++ b/geruecht/user/routes.py @@ -360,12 +360,12 @@ def _JobRequests(**kwargs): try: debug.info("/user/JobRequests") data = request.get_json() - data['on_date'] = date(data['on_date']['year'], data['on_date']['month'], data['on_date']['day']) 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)