Merge branch 'feature/serviceMangement' into develop

geruecht/baruser/routes.py

@@ -3,7 +3,7 @@ import geruecht.controller as gc
 import geruecht.controller.ldapController as lc
 import geruecht.controller.userController as uc
 from datetime import datetime
-from geruecht.model import BAR, MONEY
+from geruecht.model import BAR, MONEY, USER
 from geruecht.decorator import login_required
 
 baruser = Blueprint("baruser", __name__)
@@ -146,7 +146,7 @@ def _getUser(**kwargs):
 
 
 @baruser.route("/search", methods=['POST'])
-@login_required(groups=[BAR, MONEY])
+@login_required(groups=[BAR, MONEY, USER])
 def _search(**kwargs):
     data = request.get_json()
     searchString = data['searchString']

geruecht/controller/databaseController.py

@@ -6,6 +6,7 @@ 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):
     '''
@@ -18,6 +19,7 @@ class DatabaseController(metaclass=Singleton):
         self.db = db
 
     def getAllUser(self):
+        try:
             cursor = self.db.connection.cursor()
             cursor.execute("select * from user")
             data = cursor.fetchall()
@@ -30,8 +32,13 @@ class DatabaseController(metaclass=Singleton):
                     user.initGeruechte(creditLists)
                     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):
+        try:
             retVal = None
             cursor = self.db.connection.cursor()
             cursor.execute("select * from user where uid='{}'".format(username))
@@ -40,10 +47,14 @@ class DatabaseController(metaclass=Singleton):
                 retVal = User(data)
                 creditLists = self.getCreditListFromUser(retVal)
                 retVal.initGeruechte(creditLists)
-
             return retVal
+        except Exception as err:
+            traceback.print_exc()
+            self.db.connection.rollback()
+            raise DatabaseExecption("Something went worng with Datatabase: {}".format(err))
 
     def getUserById(self, id):
+        try:
             retVal = None
             cursor = self.db.connection.cursor()
             cursor.execute("select * from user where id={}".format(id))
@@ -53,6 +64,10 @@ class DatabaseController(metaclass=Singleton):
                 creditLists = self.getCreditListFromUser(retVal)
                 retVal.initGeruechte(creditLists)
             return retVal
+        except Exception as err:
+            traceback.print_exc()
+            self.db.connection.rollback()
+            raise DatabaseExecption("Something went worng with Datatabase: {}".format(err))
 
     def _convertGroupToString(self, groups):
         retVal = ''
@@ -66,14 +81,20 @@ class DatabaseController(metaclass=Singleton):
 
 
     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)
@@ -82,9 +103,14 @@ class DatabaseController(metaclass=Singleton):
             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'])
@@ -96,15 +122,25 @@ class DatabaseController(metaclass=Singleton):
                 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()
@@ -127,25 +163,42 @@ class DatabaseController(metaclass=Singleton):
             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']} if data else None
+            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']} for work in data]
+            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):
@@ -155,6 +208,8 @@ class DatabaseController(metaclass=Singleton):
             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:
@@ -165,11 +220,155 @@ class DatabaseController(metaclass=Singleton):
                 raise UsernameExistDB("Username already exists")
             else:
                 cursor.execute("update user set uid='{}' where id={}".format(newUsername, user.id))
-                self.db.connection()
+                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))
+
+
 if __name__ == '__main__':
     db = DatabaseController()
     user = db.getUser('jhille')

geruecht/controller/userController.py

@@ -2,10 +2,11 @@ from . import LOGGER, Singleton, ldapConfig, dbConfig, 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, UsernameExistDB, DatabaseExecption, LDAPExcetpion
+from geruecht.exceptions import UsernameExistLDAP, UsernameExistDB, DatabaseExecption, LDAPExcetpion, DayLocked, TansactJobIsAnswerdException
 
 db = dc.DatabaseController()
 ldap = lc.LDAPController(ldapConfig['dn'])
@@ -16,20 +17,85 @@ class UserController(metaclass=Singleton):
     def __init__(self):
         pass
 
+    def setTransactJob(self, from_user, to_user, date):
+        return db.setTransactJob(from_user, to_user, date.date())
+
+    def getTransactJobFromUser(self, user, date):
+        return db.getTransactJobFromUser(user, date.date())
+
+    def getAllTransactJobFromUser(self, user, date):
+        return db.getAllTransactJobFromUser(user, date.date())
+
+    def getAllTransactJobToUser(self, user, date):
+        return db.getAllTransactJobToUser(user, date.date())
+
+    def getTransactJob(self, from_user, to_user, date):
+        return db.getTransactJob(from_user, to_user, date.date())
+
+    def deleteTransactJob(self, from_user, to_user, date):
+        transactJob = self.getTransactJob(from_user, to_user, date)
+        if transactJob['answerd']:
+            raise TansactJobIsAnswerdException("TransactJob is already answerd")
+        db.deleteTransactJob(from_user, to_user, date.date())
+
+    def answerdTransactJob(self, from_user, to_user, date, answer):
+        transactJob = db.updateTransactJob(from_user, to_user, date.date(), answer)
+        if answer:
+            self.addWorker(to_user.uid, date)
+        return transactJob
+
+    def setLockedDay(self, date, locked, hard=False):
+        return db.setLockedDay(date.date(), locked, hard)
+
+    def getLockedDay(self, date):
+        now = datetime.now()
+        daysInMonth = calendar.monthrange(date.year, date.month)[1]
+        startMonth = 1
+        for i in range(1, 8):
+            if datetime(date.year, date.month, i).weekday() == 2:
+                startMonth = i
+                break
+        if date.year <= now.year and date.month <= now.month:
+            for i in range(startMonth, daysInMonth + 1):
+                self.setLockedDay(datetime(date.year, date.month, i), True)
+            for i in range(1, 8):
+                nextMonth = datetime(date.year, date.month + 1, i)
+                if nextMonth.weekday() == 2:
+                    break
+                self.setLockedDay(nextMonth, True)
+        return db.getLockedDay(date.date())
+
     def getWorker(self, date, username=None):
         if (username):
             user = self.getUser(username)
             return [db.getWorker(user, date)]
         return db.getWorkers(date)
 
-    def addWorker(self, username, date):
+    def addWorker(self, username, date, userExc=False):
+        if (userExc):
+            lockedDay = self.getLockedDay(date)
+            if lockedDay:
+                if lockedDay['locked']:
+                    raise DayLocked("Day is locked. You can't get the Job")
         user = self.getUser(username)
         if (not db.getWorker(user, date)):
             db.setWorker(user, date)
         return self.getWorker(date, username=username)
 
-    def deleteWorker(self, username, date):
+    def deleteWorker(self, username, date, userExc=False):
         user = self.getUser(username)
+        if userExc:
+            lockedDay = self.getLockedDay(date)
+            if lockedDay:
+                if lockedDay['locked']:
+                    transactJobs = self.getTransactJobFromUser(user, date)
+                    found = False
+                    for job in transactJobs:
+                        if job['accepted'] and job['answerd']:
+                            found = True
+                            break
+                    if not found:
+                        raise DayLocked("Day is locked. You can't delete the Job")
         db.deleteWorker(user, date)
 
     def lockUser(self, username, locked):
@@ -81,8 +147,8 @@ class UserController(metaclass=Singleton):
     def checkBarUser(self, user):
         date = datetime.now()
         zero = date.replace(hour=0, minute=0, second=0, microsecond=0)
-        end = zero + timedelta(hours=11)
+        end = zero + timedelta(hours=12)
-        startdatetime = date.replace(hour=11, minute=0, second=0, microsecond=0)
+        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)

geruecht/exceptions/__init__.py

@@ -8,3 +8,7 @@ class DatabaseExecption(Exception):
     pass
 class LDAPExcetpion(Exception):
     pass
+class DayLocked(Exception):
+    pass
+class TansactJobIsAnswerdException(Exception):
+    pass

geruecht/user/routes.py

@@ -3,8 +3,7 @@ from geruecht.decorator import login_required
 import geruecht.controller.userController as uc
 from geruecht.model import USER
 from datetime import datetime
-import time
+from geruecht.exceptions import DayLocked
-import traceback
 
 user = Blueprint("user", __name__)
 
@@ -49,13 +48,189 @@ def _saveConfig(**kwargs):
             retVal['creditList'] = {credit.year: credit.toJSON() for credit in accToken.user.geruechte}
             return jsonify(retVal)
     except Exception as err:
-        return jsonify({"error": err}), 409
+        return jsonify({"error": str(err)}), 409
 
 @user.route("/user/job", methods=['POST'])
 @login_required(groups=[USER])
 def _getUser(**kwargs):
     data = request.get_json()
-    date = datetime.utcfromtimestamp(int(data['date']))
+    day = data['day']
-    retVal = userController.getWorker(date)
+    month = data['month']
+    year = data['year']
+    date = datetime(year, month, day, 12)
+    lockedDay = userController.getLockedDay(date)
+    if not lockedDay:
+        lockedDay = {
+            'date': {
+                'year': year,
+                'month': month,
+                'day': day
+            },
+            'locked': False
+        }
+    else:
+        lockedDay = {
+            'date': {
+                'year': year,
+                'month': month,
+                'day': day
+            },
+            'locked': lockedDay['locked']
+        }
+    retVal = {
+        'worker': userController.getWorker(date),
+        'day': lockedDay
+    }
     print(retVal)
     return jsonify(retVal)
+
+@user.route("/user/addJob", methods=['POST'])
+@login_required(groups=[USER])
+def _addUser(**kwargs):
+    try:
+        if 'accToken' in kwargs:
+            accToken = kwargs['accToken']
+            user = accToken.user
+            data = request.get_json()
+            day = data['day']
+            month = data['month']
+            year = data['year']
+            date = datetime(year,month,day,12)
+            retVal = userController.addWorker(user.uid, date, userExc=True)
+            print(retVal)
+            return jsonify(retVal)
+    except DayLocked as err:
+        return jsonify({'error': str(err)}), 403
+    except Exception as err:
+        return jsonify({'error': str(err)}), 409
+
+@user.route("/user/deleteJob", methods=['POST'])
+@login_required(groups=[USER])
+def _deletJob(**kwargs):
+    try:
+        if 'accToken' in kwargs:
+            accToken = kwargs['accToken']
+            user = accToken.user
+            data = request.get_json()
+            day = data['day']
+            month = data['month']
+            year = data['year']
+            date = datetime(year,month,day,12)
+            userController.deleteWorker(user.uid, date, True)
+            return jsonify({"ok": "ok"})
+    except DayLocked as err:
+        return jsonify({"error": str(err)}), 403
+    except Exception as err:
+        return jsonify({"error": str(err)}), 409
+
+@user.route("/user/transactJob", methods=['POST'])
+@login_required(groups=[USER])
+def _transactJob(**kwargs):
+    try:
+        if 'accToken' in kwargs:
+            accToken = kwargs['accToken']
+            user = accToken.user
+            data = request.get_json()
+            year = data['year']
+            month = data['month']
+            day = data['day']
+            username = data['user']
+            date = datetime(year, month, day, 12)
+            to_user = userController.getUser(username)
+            retVal = userController.setTransactJob(user, to_user, date)
+            retVal['from_user'] = retVal['from_user'].toJSON()
+            retVal['to_user'] = retVal['to_user'].toJSON()
+            retVal['date'] = {'year': year, 'month': month, 'day': day}
+            print(retVal)
+            return jsonify(retVal)
+    except Exception as err:
+        return jsonify({"error": str(err)}), 409
+
+@user.route("/user/answerTransactJob", methods=['POST'])
+@login_required(groups=[USER])
+def _answer(**kwargs):
+    try:
+        if 'accToken' in kwargs:
+            accToken = kwargs['accToken']
+            user = accToken.user
+            data = request.get_json()
+            year = data['year']
+            month = data['month']
+            day = data['day']
+            answer = data['answer']
+            username = data['username']
+            date = datetime(year, month, day, 12)
+            from_user = userController.getUser(username)
+            retVal = userController.answerdTransactJob(from_user, user, date, answer)
+            retVal['from_user'] = retVal['from_user'].toJSON()
+            retVal['to_user'] = retVal['to_user'].toJSON()
+            retVal['date'] = {'year': year, 'month': month, 'day': day}
+            print(retVal)
+            return jsonify(retVal)
+    except Exception as err:
+        return jsonify({"error": str(err)}), 409
+
+@user.route("/user/jobRequests", methods=['POST'])
+@login_required(groups=[USER])
+def _requests(**kwargs):
+    try:
+        if 'accToken' in kwargs:
+            accToken = kwargs['accToken']
+            user = accToken.user
+            data = request.get_json()
+            year = data['year']
+            month = data['month']
+            day = data['day']
+            date = datetime(year, month, day, 12)
+            retVal = userController.getAllTransactJobToUser(user, date)
+            for data in retVal:
+                data['from_user'] = data['from_user'].toJSON()
+                data['to_user'] = data['to_user'].toJSON()
+                data_date = data['date']
+                data['date'] = {'year': data_date.year, 'month': data_date.month, 'day': data_date.day}
+            print(retVal)
+            return jsonify(retVal)
+    except Exception as err:
+        return jsonify({"error": str(err)}), 409
+
+@user.route("/user/getTransactJobs", methods=['POST'])
+@login_required(groups=[USER])
+def _getTransactJobs(**kwargs):
+    try:
+        if 'accToken' in kwargs:
+            accToken = kwargs['accToken']
+            user = accToken.user
+            data = request.get_json()
+            year = data['year']
+            month = data['month']
+            day = data['day']
+            date = datetime(year, month, day, 12)
+            retVal = userController.getAllTransactJobFromUser(user, date)
+            for data in retVal:
+                data['from_user'] = data['from_user'].toJSON()
+                data['to_user'] = data['to_user'].toJSON()
+                data_date = data['date']
+                data['date'] = {'year': data_date.year, 'month': data_date.month, 'day': data_date.day}
+            print(retVal)
+            return jsonify(retVal)
+    except Exception as err:
+        return jsonify({"error": str(err)}), 409
+
+@user.route("/user/deleteTransactJob", methods=['POST'])
+@login_required(groups=[USER])
+def _deleteTransactJob(**kwargs):
+    try:
+        if 'accToken' in kwargs:
+            accToken = kwargs['accToken']
+            from_user = accToken.user
+            data = request.get_json()
+            year = data['year']
+            month = data['month']
+            day = data['day']
+            username = data['username']
+            date = datetime(year, month, day, 12)
+            to_user = userController.getUser(username)
+            userController.deleteTransactJob(from_user, to_user, date)
+            return jsonify({"ok": "ok"})
+    except Exception as err:
+        return jsonify({"error": str(err)}), 409

geruecht/vorstand/routes.py

@@ -18,7 +18,10 @@ def _addUser(**kwargs):
 
     data = request.get_json()
     user = data['user']
-    date = datetime.utcfromtimestamp(int(data['date']))
+    day = data['day']
+    month = data['month']
+    year = data['year']
+    date = datetime(year,month,day,12)
     retVal = userController.addWorker(user['username'], date)
     print(retVal)
     return jsonify(retVal)
@@ -27,8 +30,33 @@ def _addUser(**kwargs):
 @login_required(groups=[MONEY, GASTRO])
 def _getUser(**kwargs):
     data = request.get_json()
-    date = datetime.utcfromtimestamp(int(data['date']))
+    day = data['day']
-    retVal = userController.getWorker(date)
+    month = data['month']
+    year = data['year']
+    date = datetime(year, month, day, 12)
+    lockedDay = userController.getLockedDay(date)
+    if not lockedDay:
+        lockedDay = {
+            'date': {
+                'year': year,
+                'month': month,
+                'day': day
+            },
+            'locked': False
+        }
+    else:
+        lockedDay = {
+            'date': {
+                'year': year,
+                'month': month,
+                'day': day
+            },
+            'locked': lockedDay['locked']
+        }
+    retVal = {
+        'worker': userController.getWorker(date),
+        'day': lockedDay
+    }
     print(retVal)
     return  jsonify(retVal)
 
@@ -37,6 +65,43 @@ def _getUser(**kwargs):
 def _deletUser(**kwargs):
     data = request.get_json()
     user = data['user']
-    date = datetime.utcfromtimestamp(int(data['date']))
+    day = data['day']
+    month = data['month']
+    year = data['year']
+    date = datetime(year, month, day, 12)
     userController.deleteWorker(user['username'], date)
     return jsonify({"ok": "ok"})
+
+@vorstand.route("/sm/lockDay", methods=['POST'])
+@login_required(groups=[MONEY, GASTRO])
+def _lockDay(**kwargs):
+    try:
+        data = request.get_json()
+        year = data['year']
+        month = data['month']
+        day = data['day']
+        locked = data['locked']
+        date = datetime(year, month, day, 12)
+        lockedDay = userController.setLockedDay(date, locked, True)
+        if not lockedDay:
+            retVal = {
+                'date': {
+                    'year': year,
+                    'month': month,
+                    'day': day
+                },
+                'locked': False
+            }
+        else:
+            retVal = {
+                'date': {
+                    'year': year,
+                    'month': month,
+                    'day': day
+                },
+                'locked': lockedDay['locked']
+            }
+        print(retVal)
+        return jsonify(retVal)
+    except Exception as err:
+        return jsonify({'error': err}), 409