diff --git a/geruecht/baruser/routes.py b/geruecht/baruser/routes.py
index a8c47a4..58dbc52 100644
--- a/geruecht/baruser/routes.py
+++ b/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']
diff --git a/geruecht/controller/databaseController.py b/geruecht/controller/databaseController.py
index c88c977..b9c2ba3 100644
--- a/geruecht/controller/databaseController.py
+++ b/geruecht/controller/databaseController.py
@@ -259,12 +259,116 @@ class DatabaseController(metaclass=Singleton):
             except Exception as err:
                 traceback.print_exc()
                 self.db.connection.rollback()
-                raise DatabaseController("Something went wrong with Database: {}".format(err))
+                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')
diff --git a/geruecht/controller/userController.py b/geruecht/controller/userController.py
index 293820e..b7210ae 100644
--- a/geruecht/controller/userController.py
+++ b/geruecht/controller/userController.py
@@ -6,7 +6,7 @@ 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, DayLocked
+from geruecht.exceptions import UsernameExistLDAP, UsernameExistDB, DatabaseExecption, LDAPExcetpion, DayLocked, TansactJobIsAnswerdException
 
 db = dc.DatabaseController()
 ldap = lc.LDAPController(ldapConfig['dn'])
@@ -17,7 +17,34 @@ class UserController(metaclass=Singleton):
     def __init__(self):
         pass
 
-    def setLockedDay(self, date, locked,hard=False):
+    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):
@@ -56,12 +83,19 @@ class UserController(metaclass=Singleton):
         return self.getWorker(date, username=username)
 
     def deleteWorker(self, username, date, userExc=False):
+        user = self.getUser(username)
         if userExc:
             lockedDay = self.getLockedDay(date)
             if lockedDay:
                 if lockedDay['locked']:
-                    raise DayLocked("Day is locked. You can't delete the Job")
-        user = self.getUser(username)
+                    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):
diff --git a/geruecht/exceptions/__init__.py b/geruecht/exceptions/__init__.py
index 4ef2dbf..307c48e 100644
--- a/geruecht/exceptions/__init__.py
+++ b/geruecht/exceptions/__init__.py
@@ -9,4 +9,6 @@ class DatabaseExecption(Exception):
 class LDAPExcetpion(Exception):
     pass
 class DayLocked(Exception):
+    pass
+class TansactJobIsAnswerdException(Exception):
     pass
\ No newline at end of file
diff --git a/geruecht/user/routes.py b/geruecht/user/routes.py
index 4f4ed33..beaade9 100644
--- a/geruecht/user/routes.py
+++ b/geruecht/user/routes.py
@@ -48,7 +48,7 @@ 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])
@@ -100,9 +100,9 @@ def _addUser(**kwargs):
             print(retVal)
             return jsonify(retVal)
     except DayLocked as err:
-        return jsonify({'error': err}), 403
+        return jsonify({'error': str(err)}), 403
     except Exception as err:
-        return jsonify({'error': err}), 409
+        return jsonify({'error': str(err)}), 409
 
 @user.route("/user/deleteJob", methods=['POST'])
 @login_required(groups=[USER])
@@ -119,6 +119,118 @@ def _deletJob(**kwargs):
             userController.deleteWorker(user.uid, date, True)
             return jsonify({"ok": "ok"})
     except DayLocked as err:
-        return jsonify({"error": err}), 403
+        return jsonify({"error": str(err)}), 403
     except Exception as err:
-        return jsonify({"error": err}), 409
\ No newline at end of file
+        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
\ No newline at end of file