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

new logger implementet -- not ready 

logger dont create folder to log
model and controller (except userController) not ready
This commit is contained in:
Tim Gröger 2020-03-10 09:19:11 +01:00
parent 57f0f17a90
commit ba5f033981
18 changed files with 759 additions and 374 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
geruecht/__init__.py
View File

@ -4,12 +4,12 @@
Initialize also a singelton for the AccesTokenControler and start the Thread.
"""
from .logger import getDebugLogger, getInfoLogger
from .logger import getDebugLogger
from geruecht.controller import dbConfig, ldapConfig
from flask_mysqldb import MySQL
from flask_ldapconn import LDAPConn
DEBUG = getDebugLogger('INIT', True)
DEBUG = getDebugLogger()
DEBUG.info("Initialize App")
from flask import Flask

202
geruecht/baruser/routes.py
View File

@ -4,6 +4,10 @@ import geruecht.controller.userController as uc
from datetime import datetime
from geruecht.model import BAR, MONEY, USER, VORSTAND
from geruecht.decorator import login_required
from geruecht.logger import getDebugLogger, getCreditLogger
debug = getDebugLogger()
creditL = getCreditLogger()
baruser = Blueprint("baruser", __name__)
@ -22,28 +26,34 @@ def _bar(**kwargs):
JSON-File with Users, who has amounts in this month
or ERROR 401 Permission Denied
"""
dic = {}
users = userController.getAllUsersfromDB()
for user in users:
geruecht = None
geruecht = user.getGeruecht(datetime.now().year)
if geruecht is not None:
month = geruecht.getMonth(datetime.now().month)
amount = month[0] - month[1]
all = geruecht.getSchulden()
if all != 0:
if all >= 0:
type = 'credit'
else:
type = 'amount'
dic[user.uid] = {"username": user.uid,
"firstname": user.firstname,
"lastname": user.lastname,
"amount": all,
"locked": user.locked,
"type": type
}
return jsonify(dic)
debug.info("/bar")
try:
dic = {}
users = userController.getAllUsersfromDB()
for user in users:
geruecht = None
geruecht = user.getGeruecht(datetime.now().year)
if geruecht is not None:
month = geruecht.getMonth(datetime.now().month)
amount = month[0] - month[1]
all = geruecht.getSchulden()
if all != 0:
if all >= 0:
type = 'credit'
else:
type = 'amount'
dic[user.uid] = {"username": user.uid,
"firstname": user.firstname,
"lastname": user.lastname,
"amount": all,
"locked": user.locked,
"type": type
}
debug.debug("return {{}}".format(dic))
return jsonify(dic)
except Exception as err:
debug.debug("exception", exc_info=True)
return jsonify({"error": str(err)}), 500
@baruser.route("/baradd", methods=['POST'])
@ -57,26 +67,32 @@ def _baradd(**kwargs):
JSON-File with userID and the amount
or ERROR 401 Permission Denied
"""
data = request.get_json()
userID = data['userId']
amount = int(data['amount'])
debug.info("/baradd")
try:
data = request.get_json()
userID = data['userId']
amount = int(data['amount'])
date = datetime.now()
userController.addAmount(userID, amount, year=date.year, month=date.month)
user = userController.getUser(userID)
geruecht = user.getGeruecht(year=date.year)
month = geruecht.getMonth(month=date.month)
amount = abs(month[0] - month[1])
all = geruecht.getSchulden()
if all >= 0:
type = 'credit'
else:
type = 'amount'
dic = user.toJSON()
dic['amount'] = abs(all)
dic['type'] = type
return jsonify(dic)
date = datetime.now()
userController.addAmount(userID, amount, year=date.year, month=date.month)
user = userController.getUser(userID)
geruecht = user.getGeruecht(year=date.year)
month = geruecht.getMonth(month=date.month)
amount = abs(month[0] - month[1])
all = geruecht.getSchulden()
if all >= 0:
type = 'credit'
else:
type = 'amount'
dic = user.toJSON()
dic['amount'] = abs(all)
dic['type'] = type
debug.debug("return {{}}".format(dic))
creditL.info("{} Baruser {} {} fügt {} {} {} € Schulden hinzu.".format(date, kwargs['accToken'].user.firstname, kwargs['accToken'].user.lastname, user.firstname, user.lastname, amount/100))
return jsonify(dic)
except Exception as err:
debug.debug("exception", exc_info=True)
return jsonify({"error": str(err)}), 500
@baruser.route("/barGetUsers")
@ -90,9 +106,15 @@ def _getUsers(**kwargs):
JSON-File with Users
or ERROR 401 Permission Denied
"""
retVal = {}
retVal = ldap.getAllUser()
return jsonify(retVal)
debug.info("/barGetUsers")
try:
retVal = {}
retVal = ldap.getAllUser()
debug.debug("return {{}}".format(retVal))
return jsonify(retVal)
except Exception as err:
debug.debug("exception", exc_info=True)
return jsonify({"error": str(err)}), 500
@baruser.route("/bar/storno", methods=['POST'])
@login_required(groups=[BAR])
@ -105,50 +127,68 @@ def _storno(**kwargs):
JSON-File with userID and the amount
or ERROR 401 Permission Denied
"""
data = request.get_json()
userID = data['userId']
amount = int(data['amount'])
debug.info("/bar/storno")
try:
data = request.get_json()
userID = data['userId']
amount = int(data['amount'])
date = datetime.now()
userController.addCredit(userID, amount, year=date.year, month=date.month)
user = userController.getUser(userID)
geruecht = user.getGeruecht(year=date.year)
month = geruecht.getMonth(month=date.month)
amount = abs(month[0] - month[1])
all = geruecht.getSchulden()
if all >= 0:
type = 'credit'
else:
type = 'amount'
dic = user.toJSON()
dic['amount'] = abs(all)
dic['type'] = type
return jsonify(dic)
date = datetime.now()
userController.addCredit(userID, amount, year=date.year, month=date.month)
user = userController.getUser(userID)
geruecht = user.getGeruecht(year=date.year)
month = geruecht.getMonth(month=date.month)
amount = abs(month[0] - month[1])
all = geruecht.getSchulden()
if all >= 0:
type = 'credit'
else:
type = 'amount'
dic = user.toJSON()
dic['amount'] = abs(all)
dic['type'] = type
debug.debug("return {{}}".format(dic))
creditL.info("{} Baruser {} {} storniert {} € von {} {}".format(date, kwargs['accToken'].user.firstname, kwargs['accToken'].user.lastname, amount/100, user.firstname, user.lastname))
return jsonify(dic)
except Exception as err:
debug.debug("exception", exc_info=True)
return jsonify({"error": str(err)}), 500
@baruser.route("/barGetUser", methods=['POST'])
@login_required(groups=[BAR])
def _getUser(**kwargs):
data = request.get_json()
username = data['userId']
user = userController.getUser(username)
amount = user.getGeruecht(datetime.now().year).getSchulden()
if amount >= 0:
type = 'credit'
else:
type = 'amount'
debug.info("/barGetUser")
try:
data = request.get_json()
username = data['userId']
user = userController.getUser(username)
amount = user.getGeruecht(datetime.now().year).getSchulden()
if amount >= 0:
type = 'credit'
else:
type = 'amount'
retVal = user.toJSON()
retVal['amount'] = amount
retVal['type'] = type
return jsonify(retVal)
retVal = user.toJSON()
retVal['amount'] = amount
retVal['type'] = type
debug.debug("return {{}}".format(retVal))
return jsonify(retVal)
except Exception as err:
debug.debug("exception", exc_info=True)
return jsonify({"error": str(err)}), 500
@baruser.route("/search", methods=['GET'])
@login_required(groups=[BAR, MONEY, USER,VORSTAND])
def _search(**kwargs):
retVal = ldap.getAllUser()
for user in retVal:
if user['username'] == 'extern':
retVal.remove(user)
break
return jsonify(retVal)
debug.info("/search")
try:
retVal = ldap.getAllUser()
for user in retVal:
if user['username'] == 'extern':
retVal.remove(user)
break
debug.debug("return {{}}".format(retVal))
return jsonify(retVal)
except Exception as err:
debug.debug("exception", exc_info=True)
return jsonify({"error": str(err)}), 500

6
geruecht/configparser.py
View File

@ -1,7 +1,7 @@
import yaml
import sys
from .logger import getDebugLogger, getInfoLogger
DEBUG = getDebugLogger("CONFIG", True)
from .logger import getDebugLogger
DEBUG = getDebugLogger()
default = {
'AccessTokenLifeTime': 1800,
@ -86,7 +86,7 @@ class ConifgParser():
return self.mail
def __error__(self, msg):
DEBUG.error(msg)
DEBUG.error(msg, exc_info=True)
sys.exit(-1)
if __name__ == '__main__':

4
geruecht/controller/__init__.py
View File

@ -1,4 +1,4 @@
from geruecht.logger import getLogger
from geruecht.logger import getDebugLogger
from geruecht.configparser import ConifgParser
import os
@ -6,7 +6,7 @@ print(os.getcwd())
config = ConifgParser('geruecht/config.yml')
LOGGER = getLogger(__name__)
LOGGER = getDebugLogger()
class Singleton(type):
_instances = {}

4
geruecht/controller/emailController.py
View File

@ -3,9 +3,9 @@ from datetime import datetime
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.header import Header
from geruecht.logger import getLogger
from geruecht.logger import getDebugLogger
LOGGER = getLogger('E-MailController')
LOGGER = getDebugLogger()
class EmailController():

226
geruecht/controller/userController.py
View File

@ -1,4 +1,4 @@
from . import LOGGER, Singleton, ldapConfig, dbConfig, mailConfig
from . import Singleton, mailConfig
import geruecht.controller.databaseController as dc
import geruecht.controller.ldapController as lc
import geruecht.controller.emailController as ec
@ -6,219 +6,359 @@ 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, TansactJobIsAnswerdException
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 getAllStatus(self):
return db.getAllStatus()
debug.info("get all status for user")
retVal = db.getAllStatus()
debug.debug("status are {{}}".format(retVal))
return retVal
def getStatus(self, name):
return db.getStatus(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):
return db.setStatus(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):
return db.updateStatus(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):
return db.updateStatusOfUser(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):
return db.updateVotingOfUser(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):
return db.updateDrinkType(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):
return db.setDrinkType(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):
return db.getAllDrinkTypes()
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):
return db.getTransactJobFromUser(user, date.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):
return db.getAllTransactJobFromUser(user, date.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):
return db.getAllTransactJobToUser(user, date.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):
return db.getTransactJob(from_user, to_user, date.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):
return db.setLockedDay(date.date(), locked, hard)
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 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 = date.year
lockedMonth = date.month if date.month < now.month else now.month - 1 if oldMonth else now.month
daysInMonth = calendar.monthrange(lockedYear, lockedMonth)[1]
startDay = 1
debug.debug("calculate start day of month")
for i in range(1, 8):
if datetime(lockedYear, lockedMonth, i).weekday() == 2:
startDay = i
break
debug.debug("start day of month is {{}}".format(startDay))
debug.debug("check if date should be locked")
if lockedYear <= now.year and lockedMonth <= now.month:
for i in range(startDay, daysInMonth + 1):
debug.debug("lock day {{}}".format(datetime(lockedYear, lockedMonth, i)))
self.setLockedDay(datetime(lockedYear, lockedMonth, i), True)
for i in range(1, 8):
nextMonth = datetime(lockedYear, lockedMonth + 1, i)
if nextMonth.weekday() == 2:
break
debug.debug("lock day {{}}".format(datetime(lockedYear, lockedMonth, i)))
self.setLockedDay(nextMonth, True)
return db.getLockedDay(date.date())
retVal = db.getLockedDay(date.date())
debug.debug("locked day is {{}}".format(retVal))
return
def getWorker(self, date, username=None):
debug.info("get worker on {{}}".format(username, date))
if (username):
user = self.getUser(username)
return [db.getWorker(user, date)]
return db.getWorkers(date)
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)
return self.getWorker(date, username=username)
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)
return self.getUser(username)
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)
return self.getUser(username)
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:
if user.getGeruecht(year=datetime.now().year).getSchulden() <= (-1*user.limit):
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)
return user.getGeruecht(year)
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)
return user.getGeruecht(year)
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)
return db.getAllUser(extern=True)
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)
@ -226,59 +366,84 @@ class UserController(metaclass=Singleton):
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)
return emailController.sendMail(user)
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:
return self.getUser(attributes['username'])
retVal = self.getUser(attributes['username'])
debug.debug("user is {{}}".format(retVal))
return retVal
else:
return self.getUser(user.uid)
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:
@ -289,11 +454,14 @@ class UserController(metaclass=Singleton):
raise Exception(err)
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

10
geruecht/decorator.py
View File

@ -1,6 +1,6 @@
from functools import wraps
from .logger import getInfoLogger, getDebugLogger
DEBUG = getDebugLogger("login-decorator", True)
from .logger import getDebugLogger
DEBUG = getDebugLogger()
def login_required(**kwargs):
import geruecht.controller.accesTokenController as ac
from geruecht.model import BAR, USER, MONEY, GASTRO
@ -9,15 +9,17 @@ def login_required(**kwargs):
groups = [USER, BAR, GASTRO, MONEY]
if "groups" in kwargs:
groups = kwargs["groups"]
DEBUG.debug("groups are {{}}".format(groups))
def real_decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
token = request.headers.get('Token')
DEBUG.info("get token {{}}".format(token))
DEBUG.debug("token is {{}}".format(token))
accToken = accessController.validateAccessToken(token, groups)
DEBUG.debug("accToken is {{}}".format(accToken))
kwargs['accToken'] = accToken
if accToken:
DEBUG.info("token {{}} is valid".format(token))
DEBUG.debug("token {{}} is valid".format(token))
return func(*args, **kwargs)
else:
DEBUG.warning("token {{}} is not valid".format(token))

2
geruecht/finanzer/__init__.py
View File

@ -1,3 +1 @@
from geruecht.logger import getLogger
LOGGER = getLogger(__name__)

205
geruecht/finanzer/routes.py
View File

@ -1,10 +1,12 @@
from flask import Blueprint, request, jsonify
from geruecht.finanzer import LOGGER
from datetime import datetime
import geruecht.controller.userController as uc
from geruecht.model import MONEY
from geruecht.decorator import login_required
import time
from geruecht.logger import getDebugLogger, getCreditLogger
debug = getDebugLogger()
creditL = getCreditLogger()
finanzer = Blueprint("finanzer", __name__)
@ -22,16 +24,18 @@ def _getFinanzer(**kwargs):
A JSON-File with Users
or ERROR 401 Permission Denied.
"""
LOGGER.debug("Get all Useres")
users = userController.getAllUsersfromDB()
dic = {}
for user in users:
LOGGER.debug("Add User {} to ReturnValue".format(user))
dic[user.uid] = user.toJSON()
dic[user.uid]['creditList'] = {credit.year: credit.toJSON() for credit in user.geruechte}
LOGGER.debug("ReturnValue is {}".format(dic))
LOGGER.info("Send main for Finanzer")
return jsonify(dic)
debug.info("/getFinanzerMain")
try:
users = userController.getAllUsersfromDB()
dic = {}
for user in users:
dic[user.uid] = user.toJSON()
dic[user.uid]['creditList'] = {credit.year: credit.toJSON() for credit in user.geruechte}
debug.debug("return {{}}".format(dic))
return jsonify(dic)
except Exception as err:
debug.debug("exception", exc_info=True)
return jsonify({"error": str(err)}), 500
@finanzer.route("/finanzerAddAmount", methods=['POST'])
@login_required(groups=[MONEY])
@ -46,28 +50,29 @@ def _addAmount(**kwargs):
JSON-File with geruecht of year
or ERROR 401 Permission Denied
"""
data = request.get_json()
LOGGER.debug("Get data {}".format(data))
userID = data['userId']
amount = int(data['amount'])
LOGGER.debug("UserID is {} and amount is {}".format(userID, amount))
debug.info("/finanzerAddAmount")
try:
year = int(data['year'])
except KeyError as er:
LOGGER.error("KeyError in year. Year is set to default.")
year = datetime.now().year
try:
month = int(data['month'])
except KeyError as er:
LOGGER.error("KeyError in month. Month is set to default.")
month = datetime.now().month
LOGGER.debug("Year is {} and Month is {}".format(year, month))
userController.addAmount(userID, amount, year=year, month=month, finanzer=True)
user = userController.getUser(userID)
retVal = {str(geruecht.year): geruecht.toJSON() for geruecht in user.geruechte}
retVal['locked'] = user.locked
LOGGER.info("Send updated Geruecht")
return jsonify(retVal)
data = request.get_json()
userID = data['userId']
amount = int(data['amount'])
try:
year = int(data['year'])
except KeyError as er:
year = datetime.now().year
try:
month = int(data['month'])
except KeyError as er:
month = datetime.now().month
userController.addAmount(userID, amount, year=year, month=month, finanzer=True)
user = userController.getUser(userID)
retVal = {str(geruecht.year): geruecht.toJSON() for geruecht in user.geruechte}
retVal['locked'] = user.locked
debug.debug("return {{}}".format(retVal))
creditL.info("{} Finanzer {} {} fügt {} {} {} € Schulden hinzu.".format(datetime(year,month).date(), kwargs['accToken'].user.firstname, kwargs['accToken'].user.lastname, amount/100))
return jsonify(retVal)
except Exception as err:
debug.debug("exception", exc_info=True)
return jsonify({"error": str(err)}), 500
@finanzer.route("/finanzerAddCredit", methods=['POST'])
@login_required(groups=[MONEY])
@ -82,79 +87,109 @@ def _addCredit(**kwargs):
JSON-File with geruecht of year
or ERROR 401 Permission Denied
"""
data = request.get_json()
print(data)
LOGGER.debug("Get data {}".format(data))
userID = data['userId']
credit = int(data['credit'])
LOGGER.debug("UserID is {} and credit is {}".format(userID, credit))
debug.info("/finanzerAddCredit")
try:
year = int(data['year'])
except KeyError as er:
LOGGER.error("KeyError in year. Year is set to default.")
year = datetime.now().year
try:
month = int(data['month'])
except KeyError as er:
LOGGER.error("KeyError in month. Month is set to default.")
month = datetime.now().month
data = request.get_json()
userID = data['userId']
credit = int(data['credit'])
LOGGER.debug("Year is {} and Month is {}".format(year, month))
userController.addCredit(userID, credit, year=year, month=month).toJSON()
user = userController.getUser(userID)
retVal = {str(geruecht.year): geruecht.toJSON() for geruecht in user.geruechte}
retVal['locked'] = user.locked
LOGGER.info("Send updated Geruecht")
return jsonify(retVal)
try:
year = int(data['year'])
except KeyError as er:
year = datetime.now().year
try:
month = int(data['month'])
except KeyError as er:
month = datetime.now().month
userController.addCredit(userID, credit, year=year, month=month).toJSON()
user = userController.getUser(userID)
retVal = {str(geruecht.year): geruecht.toJSON() for geruecht in user.geruechte}
retVal['locked'] = user.locked
debug.debug("return {{}}".format(retVal))
creditL.info("{} Finanzer {} {} fügt {} {} {} € Guthaben hinzu.".format(datetime(year, month).date(),
kwargs['accToken'].user.firstname,
kwargs['accToken'].user.lastname,
credit / 100))
return jsonify(retVal)
except Exception as err:
debug.debug("exception", exc_info=True)
return jsonify({"error": str(err)}), 500
@finanzer.route("/finanzerLock", methods=['POST'])
@login_required(groups=[MONEY])
def _finanzerLock(**kwargs):
data = request.get_json()
username = data['userId']
locked = bool(data['locked'])
retVal = userController.lockUser(username, locked).toJSON()
return jsonify(retVal)
debug.info("/finanzerLock")
try:
data = request.get_json()
username = data['userId']
locked = bool(data['locked'])
retVal = userController.lockUser(username, locked).toJSON()
debug.debug("return {{}}".format(retVal))
return jsonify(retVal)
except Exception as err:
debug.debug("exception", exc_info=True)
return jsonify({"error": str(err)}), 500
@finanzer.route("/finanzerSetConfig", methods=['POST'])
@login_required(groups=[MONEY])
def _finanzerSetConfig(**kwargs):
data = request.get_json()
username = data['userId']
autoLock = bool(data['autoLock'])
limit = int(data['limit'])
retVal = userController.updateConfig(username, {'lockLimit': limit, 'autoLock': autoLock}).toJSON()
return jsonify(retVal)
debug.info("/finanzerSetConfig")
try:
data = request.get_json()
username = data['userId']
autoLock = bool(data['autoLock'])
limit = int(data['limit'])
retVal = userController.updateConfig(username, {'lockLimit': limit, 'autoLock': autoLock}).toJSON()
debug.debug("return {{}}".format(retVal))
return jsonify(retVal)
except Exception as err:
debug.debug("exception", exc_info=True)
return jsonify({"error": str(err)}), 500
@finanzer.route("/finanzerAddUser", methods=['POST'])
@login_required(groups=[MONEY])
def _finanzerAddUser(**kwargs):
data = request.get_json()
username = data['userId']
userController.getUser(username)
LOGGER.debug("Get all Useres")
users = userController.getAllUsersfromDB()
dic = {}
for user in users:
LOGGER.debug("Add User {} to ReturnValue".format(user))
dic[user.uid] = user.toJSON()
dic[user.uid]['creditList'] = {credit.year: credit.toJSON() for credit in user.geruechte}
LOGGER.debug("ReturnValue is {}".format(dic))
return jsonify(dic), 200
debug.info("/finanzerAddUser")
try:
data = request.get_json()
username = data['userId']
userController.getUser(username)
users = userController.getAllUsersfromDB()
dic = {}
for user in users:
dic[user.uid] = user.toJSON()
dic[user.uid]['creditList'] = {credit.year: credit.toJSON() for credit in user.geruechte}
debug.debug("return {{}}".format(dic))
return jsonify(dic), 200
except Exception as err:
debug.debug("exception", exc_info=True)
return jsonify({"error": str(err)}), 500
@finanzer.route("/finanzerSendOneMail", methods=['POST'])
@login_required(groups=[MONEY])
def _finanzerSendOneMail(**kwargs):
data = request.get_json()
username = data['userId']
retVal = userController.sendMail(username)
return jsonify(retVal)
debug.info("/finanzerSendOneMail")
try:
data = request.get_json()
username = data['userId']
retVal = userController.sendMail(username)
debug.debug("return {{}}".format(retVal))
return jsonify(retVal)
except Exception as err:
debug.debug("exception", exc_info=True)
return jsonify({"error": str(err)}), 500
@finanzer.route("/finanzerSendAllMail", methods=['GET'])
@login_required(groups=[MONEY])
def _finanzerSendAllMail(**kwargs):
retVal = userController.sendAllMail()
return jsonify(retVal)
debug.info("/finanzerSendAllMail")
try:
retVal = userController.sendAllMail()
debug.debug("return {{}}".format(retVal))
return jsonify(retVal)
except Exception as err:
debug.debug("exception", exc_info=True)
return jsonify({"error": str(err)}), 500

21
geruecht/gastro/routes.py
View File

@ -2,6 +2,9 @@ from flask import request, jsonify, Blueprint
from geruecht.decorator import login_required
import geruecht.controller.userController as uc
from geruecht.model import GASTRO
from geruecht.logger import getCreditLogger, getDebugLogger
debug = getDebugLogger()
gastrouser = Blueprint('gastrouser', __name__)
@ -10,62 +13,80 @@ userController = uc.UserController()
@gastrouser.route('/gastro/setDrink', methods=['POST'])
@login_required(groups=[GASTRO])
def setDrink(**kwargs):
debug.info("/gastro/setDrink")
try:
data = request.get_json()
retVal = userController.setDrinkPrice(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
@gastrouser.route('/gastro/updateDrink', methods=['POST'])
@login_required(groups=[GASTRO])
def updateDrink(**kwargs):
debug.info("/gastro/updateDrink")
try:
data = request.get_json()
retVal = userController.updateDrinkPrice(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
@gastrouser.route('/gastro/deleteDrink', methods=['POST'])
@login_required(groups=[GASTRO])
def deleteDrink(**kwargs):
debug.info("/gastro/dleteDrink")
try:
data = request.get_json()
id = data['id']
retVal = userController.deletDrinkPrice({"id": id})
debug.debug("return ok")
return jsonify({"ok": "ok"})
except Exception as err:
debug.debug("exception", exc_info=True)
return jsonify({"error": str(err)}), 500
@gastrouser.route('/gastro/setDrinkType', methods=['POST'])
@login_required(groups=[GASTRO])
def setType(**kwark):
debug.info("/gastro/setDrinkType")
try:
data = request.get_json()
name = data['name']
retVal = userController.setDrinkType(name)
debug.debug("return {{}}".format(retVal))
return jsonify(retVal)
except Exception as err:
debug.debug("exception", exc_info=True)
return jsonify({"error": str(err)}), 500
@gastrouser.route('/gastro/updateDrinkType', methods=['POST'])
@login_required(groups=[GASTRO])
def updateType(**kwargs):
debug.info("/gastro/updateDrinkType")
try:
data = request.get_json()
retVal = userController.updateDrinkType(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
@gastrouser.route('/gastro/deleteDrinkType', methods=['POST'])
@login_required(groups=[GASTRO])
def deleteType(**kwargs):
debug.info("/gastro/deleteDrinkType")
try:
data = request.get_json()
userController.deleteDrinkType(data)
debug.debug("return ok")
return jsonify({"ok": "ok"})
except Exception as err:
debug.debug("exception", exc_info=True)
return jsonify({"error": str(err)}), 500

43
geruecht/logger.py
View File

@ -1,35 +1,24 @@
import logging
from logging.handlers import WatchedFileHandler
import sys
import logging.config
import yaml
from os import path
FORMATTER = logging.Formatter("%(asctime)s — %(name)s — %(levelname)s — %(message)s")
if not path.exists("geruecht/log/debug"):
a = path.join(path.curdir ,"geruecht", "log", "debug")
logFileHandler = WatchedFileHandler("geruecht/log/debug.log")
logFileHandler.setFormatter(FORMATTER)
if not path.exists("geruecht/log/info"):
b = path.join(path.curdir, "geruecht", "log", "info")
logStreamHandler = logging.StreamHandler(stream=sys.stdout)
logStreamHandler.setFormatter(FORMATTER)
def getLogger(logger_name):
return getDebugLogger(logger_name)
with open("geruecht/logging.yml", 'rt') as file:
config = yaml.safe_load(file.read())
logging.config.dictConfig(config)
def getInfoLogger(logger_name):
logger = logging.getLogger(logger_name)
logger.setLevel(logging.INFO)
logger.addHandler(logStreamHandler)
logFileHandler = WatchedFileHandler("geruecht/log/info/{}.log".format(logger_name))
logFileHandler.setFormatter(FORMATTER)
logger.addHandler(logFileHandler)
return logger
def getDebugLogger():
return logging.getLogger("debug_logger")
def getDebugLogger(logger_name, path=False):
def getCreditLogger():
return logging.getLogger("credit_logger")
logger = logging.getLogger(logger_name)
if path:
logSecondFileHandler = WatchedFileHandler("geruecht/log/debug/{}.log".format(logger_name))
logSecondFileHandler.setFormatter(FORMATTER)
logger.addHandler(logSecondFileHandler)
logger.setLevel(logging.DEBUG)
logger.addHandler(logFileHandler)
logger.propagate = False
return logger
def getJobsLogger():
return logging.getLogger("jobs_logger")

57
geruecht/logging.yml Normal file
View File

@ -0,0 +1,57 @@
version: 1
disable_existing_loggers: True
formatters:
debug:
format: "%(asctime)s — %(filename)s - %(funcName)s - %(lineno)d - %(threadName)s - %(name)s — %(levelname)s — %(message)s"
simple:
format: "%(asctime)s - %(name)s - %(message)s"
handlers:
console:
class: logging.StreamHandler
level: DEBUG
formatter: debug
stream: ext://sys.stdout
debug:
class: logging.handlers.WatchedFileHandler
level: DEBUG
formatter: debug
filename: geruecht/log/debug/debug.log
encoding: utf8
credit:
class: logging.handlers.WatchedFileHandler
level: INFO
formatter: simple
filename: geruecht/log/info/geruecht.log
encoding: utf8
jobs:
class: logging.handlers.WatchedFileHandler
level: INFO
formatter: simple
filename: geruecht/log/info/jobs.log
encoding: utf8
loggers:
debug_logger:
level: DEBUG
handlers: [console, debug]
propagate: no
credit_logger:
level: INFO
handlers: [credit]
propagate: no
jobs_logger:
level: INFO
handlers: [jobs]
propagate: no
root:
level: INFO
handlers: [console, debug]

4
geruecht/model/accessToken.py
View File

@ -1,7 +1,7 @@
from datetime import datetime
from geruecht.logger import getLogger
from geruecht.logger import getDebugLogger
LOGGER = getLogger(__name__)
LOGGER = getDebugLogger()
class AccessToken():
""" Model for an AccessToken

4
geruecht/model/creditList.py
View File

@ -1,7 +1,7 @@
from datetime import datetime
from geruecht.logger import getLogger
from geruecht.logger import getDebugLogger
LOGGER = getLogger(__name__)
LOGGER = getDebugLogger()
def create_empty_data():
empty_data = {'id': 0,
'jan_guthaben': 0,

4
geruecht/model/user.py
View File

@ -1,8 +1,8 @@
from geruecht.logger import getLogger
from geruecht.logger import getDebugLogger
from geruecht.model.creditList import CreditList, create_empty_data
from datetime import datetime
LOGGER = getLogger(__name__)
LOGGER = getDebugLogger()
class User():

28
geruecht/routes.py
View File

@ -1,5 +1,5 @@
from geruecht import app
from geruecht.logger import getDebugLogger, getInfoLogger
from geruecht.logger import getDebugLogger
from geruecht.decorator import login_required
from geruecht.exceptions import PermissionDenied
import geruecht.controller.accesTokenController as ac
@ -10,29 +10,7 @@ from flask import request, jsonify
accesTokenController = ac.AccesTokenController()
userController = uc.UserController()
debug = getDebugLogger("MAIN-ROUTE", True)
info = getInfoLogger("MAIN-ROUTE")
def login(user, password):
return user.login(password)
@app.route("/valid")
def _valid():
token = request.headers.get("Token")
accToken = accesTokenController.validateAccessToken(token, [MONEY])
if accToken:
return jsonify(accToken.user.toJSON())
accToken = accesTokenController.validateAccessToken(token, [BAR])
if accToken:
return jsonify(accToken.user.toJSON())
accToken = accesTokenController.validateAccessToken(token, [GASTRO])
if accToken:
return jsonify(accToken.user.toJSON())
accToken = accesTokenController.validateAccessToken(token, [USER])
if accToken:
return jsonify(accToken.user.toJSON())
return jsonify({"error": "permission denied"}), 401
debug = getDebugLogger()
@app.route("/pricelist", methods=['GET'])
def _getPricelist():
@ -162,9 +140,9 @@ def _login():
"""
debug.info("Start log in.")
data = request.get_json()
debug.debug("JSON from request: {}".format(data))
username = data['username']
password = data['password']
debug.debug("username is {{}}".format(username))
try:
debug.info("search {{}} in database".format(username))
user, ldap_conn = userController.loginUser(username, password)

159
geruecht/user/routes.py
View File

@ -4,41 +4,57 @@ import geruecht.controller.userController as uc
from geruecht.model import USER
from datetime import datetime
from geruecht.exceptions import DayLocked
from geruecht.logger import getDebugLogger, getCreditLogger, getJobsLogger
user = Blueprint("user", __name__)
userController = uc.UserController()
debug = getDebugLogger()
creditL = getCreditLogger()
jobL = getJobsLogger()
@user.route("/user/main")
@login_required(groups=[USER])
def _main(**kwargs):
if 'accToken' in kwargs:
accToken = kwargs['accToken']
accToken.user = userController.getUser(accToken.user.uid)
retVal = accToken.user.toJSON()
retVal['creditList'] = {credit.year: credit.toJSON() for credit in accToken.user.geruechte}
return jsonify(retVal)
return jsonify("error", "something went wrong"), 500
debug.info("/user/main")
try:
if 'accToken' in kwargs:
accToken = kwargs['accToken']
accToken.user = userController.getUser(accToken.user.uid)
retVal = accToken.user.toJSON()
retVal['creditList'] = {credit.year: credit.toJSON() for credit in accToken.user.geruechte}
debug.debug("return {{}}".format(retVal))
return jsonify(retVal)
except Exception as err:
debug.debug("exception", exc_info=True)
return jsonify("error", "something went wrong"), 500
@user.route("/user/addAmount", methods=['POST'])
@login_required(groups=[USER])
def _addAmount(**kwargs):
if 'accToken' in kwargs:
accToken = kwargs['accToken']
data = request.get_json()
amount = int(data['amount'])
date = datetime.now()
userController.addAmount(accToken.user.uid, amount, year=date.year, month=date.month)
accToken.user = userController.getUser(accToken.user.uid)
retVal = accToken.user.toJSON()
retVal['creditList'] = {credit.year: credit.toJSON() for credit in accToken.user.geruechte}
return jsonify(retVal)
return jsonify({"error": "something went wrong"}), 500
debug.info("/user/addAmount")
try:
if 'accToken' in kwargs:
accToken = kwargs['accToken']
data = request.get_json()
amount = int(data['amount'])
date = datetime.now()
userController.addAmount(accToken.user.uid, amount, year=date.year, month=date.month)
accToken.user = userController.getUser(accToken.user.uid)
retVal = accToken.user.toJSON()
retVal['creditList'] = {credit.year: credit.toJSON() for credit in accToken.user.geruechte}
debug.debug("return {{}}".format(retVal))
creditL.info("{} {} {} fügt sich selbst {} € Schulden hinzu".format(date, accToken.user.firstname, accToken.user.lastname, amount/100))
return jsonify(retVal)
except Exception as err:
debug.debug("exception", exc_info=True)
return jsonify({"error": "something went wrong"}), 500
@user.route("/user/saveConfig", methods=['POST'])
@login_required(groups=[USER])
def _saveConfig(**kwargs):
debug.info("/user/saveConfig")
try:
if 'accToken' in kwargs:
accToken = kwargs['accToken']
@ -46,47 +62,55 @@ def _saveConfig(**kwargs):
accToken.user = userController.modifyUser(accToken.user, accToken.ldap_conn, data)
retVal = accToken.user.toJSON()
retVal['creditList'] = {credit.year: credit.toJSON() for credit in accToken.user.geruechte}
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/job", methods=['POST'])
@login_required(groups=[USER])
def _getUser(**kwargs):
data = request.get_json()
day = data['day']
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
debug.info("/user/job")
try:
data = request.get_json()
day = data['day']
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
}
else:
lockedDay = {
'date': {
'year': year,
'month': month,
'day': day
},
'locked': lockedDay['locked']
}
retVal = {
'worker': userController.getWorker(date),
'day': lockedDay
}
print(retVal)
return jsonify(retVal)
debug.debug("retrun {{}}".format(retVal))
return jsonify(retVal)
except Exception as err:
debug.debug("exception", exc_info=True)
return jsonify({"error": str(err)}), 500
@user.route("/user/addJob", methods=['POST'])
@login_required(groups=[USER])
def _addUser(**kwargs):
debug.info("/user/addJob")
try:
if 'accToken' in kwargs:
accToken = kwargs['accToken']
@ -97,16 +121,20 @@ def _addUser(**kwargs):
year = data['year']
date = datetime(year,month,day,12)
retVal = userController.addWorker(user.uid, date, userExc=True)
print(retVal)
debug.debug("return {{}}".format(retVal))
jobL.info("Mitglied {} {} schreib sich am {} zum Dienst ein.".format(user.firstname, user.lastname, date.date()))
return jsonify(retVal)
except DayLocked as err:
debug.debug("exception", exc_info=True)
return jsonify({'error': str(err)}), 403
except Exception as err:
debug.debug("exception", exc_info=True)
return jsonify({'error': str(err)}), 409
@user.route("/user/deleteJob", methods=['POST'])
@login_required(groups=[USER])
def _deletJob(**kwargs):
debug.info("/user/deleteJob")
try:
if 'accToken' in kwargs:
accToken = kwargs['accToken']
@ -117,15 +145,20 @@ def _deletJob(**kwargs):
year = data['year']
date = datetime(year,month,day,12)
userController.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()))
return jsonify({"ok": "ok"})
except DayLocked as err:
debug.debug("exception", exc_info=True)
return jsonify({"error": str(err)}), 403
except Exception as err:
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']
@ -138,17 +171,22 @@ def _transactJob(**kwargs):
date = datetime(year, month, day, 12)
to_user = userController.getUser(username)
retVal = userController.setTransactJob(user, to_user, date)
from_userl = retVal['from_user']
to_userl = retVal['to_user']
retVal['from_user'] = retVal['from_user'].toJSON()
retVal['to_user'] = retVal['to_user'].toJSON()
retVal['date'] = {'year': year, 'month': month, 'day': day}
print(retVal)
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']
@ -162,17 +200,22 @@ def _answer(**kwargs):
date = datetime(year, month, day, 12)
from_user = userController.getUser(username)
retVal = userController.answerdTransactJob(from_user, user, date, answer)
from_userl = retVal['from_user']
to_userl = retVal['to_user']
retVal['from_user'] = retVal['from_user'].toJSON()
retVal['to_user'] = retVal['to_user'].toJSON()
retVal['date'] = {'year': year, 'month': month, 'day': day}
print(retVal)
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']
@ -188,14 +231,16 @@ def _requests(**kwargs):
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)
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']
@ -211,14 +256,16 @@ def _getTransactJobs(**kwargs):
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)
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']
@ -231,8 +278,11 @@ def _deleteTransactJob(**kwargs):
date = datetime(year, month, day, 12)
to_user = userController.getUser(username)
userController.deleteTransactJob(from_user, to_user, date)
debug.debug("return ok")
jobL.info("Mitglied {} {} entfernt Dienstanfrage an {} {} am {}".format(from_user.firstname, from_user.lastname, to_user.firstname, to_user.lastname, date.date()))
return jsonify({"ok": "ok"})
except Exception as err:
debug.debug("exception", exc_info=True)
return jsonify({"error": str(err)}), 409
@user.route("/user/storno", methods=['POST'])
@ -246,6 +296,8 @@ def _storno(**kwargs):
JSON-File with userID and the amount
or ERROR 401 Permission Denied
"""
debug.info("/user/storno")
try:
if 'accToken' in kwargs:
accToken = kwargs['accToken']
@ -258,6 +310,9 @@ def _storno(**kwargs):
accToken.user = userController.getUser(accToken.user.uid)
retVal = accToken.user.toJSON()
retVal['creditList'] = {credit.year: credit.toJSON() for credit in accToken.user.geruechte}
debug.debug("return {{}}".format(retVal))
creditL.info("{} {} {} storniert {} €".format(date, user.firstname, user.lastname, amount/100))
return jsonify(retVal)
except Exception as err:
debug.debug("exception", exc_info=True)
return jsonify({"error": str(err)}), 409

150
geruecht/vorstand/routes.py
View File

@ -4,7 +4,10 @@ import geruecht.controller.userController as uc
import geruecht.controller.ldapController as lc
from geruecht.decorator import login_required
from geruecht.model import MONEY, GASTRO, VORSTAND
import time
from geruecht.logger import getDebugLogger, getJobsLogger
debug = getDebugLogger()
jobL = getJobsLogger()
vorstand = Blueprint("vorstand", __name__)
userController = uc.UserController()
@ -13,124 +16,156 @@ ldap= lc.LDAPController()
@vorstand.route('/um/setStatus', methods=['POST'])
@login_required(groups=[MONEY, GASTRO, VORSTAND])
def _setStatus(**kwargs):
debug.info("/um/setStatus")
try:
data = request.get_json()
name = data['name']
retVal = userController.setStatus(name)
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('/um/updateStatus', methods=['POST'])
@login_required(groups=[MONEY, GASTRO, VORSTAND])
def _updateStatus(**kwargs):
debug.info("/um/updateStatus")
try:
data = request.get_json()
retVal = userController.updateStatus(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('/um/deleteStatus', methods=['POST'])
@login_required(groups=[MONEY, GASTRO, VORSTAND])
def _deleteStatus(**kwargs):
debug.info("/um/deleteStatus")
try:
data = request.get_json()
userController.deleteStatus(data)
debug.debug("return ok")
return jsonify({"ok": "ok"})
except Exception as err:
debug.debug("exception", exc_info=True)
return jsonify({"error": str(err)}), 409
@vorstand.route('/um/updateStatusUser', methods=['POST'])
@login_required(groups=[MONEY, GASTRO, VORSTAND])
def _updateStatusUser(**kwargs):
debug.info("/um/updateStatusUser")
try:
data = request.get_json()
username = data['username']
status = data['status']
retVal = userController.updateStatusOfUser(username, status).toJSON()
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('/um/updateVoting', methods=['POST'])
@login_required(groups=[MONEY, GASTRO, VORSTAND])
def _updateVoting(**kwargs):
debug.info("/um/updateVoting")
try:
data = request.get_json()
username = data['username']
voting = data['voting']
retVal = userController.updateVotingOfUser(username, voting).toJSON()
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/addUser", methods=['POST', 'GET'])
@login_required(groups=[MONEY, GASTRO, VORSTAND])
def _addUser(**kwargs):
if request.method == 'GET':
return "<h1>HEllo World</h1>"
data = request.get_json()
user = data['user']
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)
debug.info("/sm/addUser")
try:
data = request.get_json()
user = data['user']
day = data['day']
month = data['month']
year = data['year']
date = datetime(year,month,day,12)
retVal = userController.addWorker(user['username'], date)
debug.debug("retrun {{}}".format(retVal))
userl = userController.getUser(user)
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)
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):
data = request.get_json()
day = data['day']
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
debug.info("/sm/getUser")
try:
data = request.get_json()
day = data['day']
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
}
else:
lockedDay = {
'date': {
'year': year,
'month': month,
'day': day
},
'locked': lockedDay['locked']
}
retVal = {
'worker': userController.getWorker(date),
'day': lockedDay
}
print(retVal)
return jsonify(retVal)
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/deleteUser", methods=['POST'])
@login_required(groups=[MONEY, GASTRO, VORSTAND])
def _deletUser(**kwargs):
data = request.get_json()
user = data['user']
day = data['day']
month = data['month']
year = data['year']
date = datetime(year, month, day, 12)
userController.deleteWorker(user['username'], date)
return jsonify({"ok": "ok"})
debug.info("/sm/deletUser")
try:
data = request.get_json()
user = data['user']
day = data['day']
month = data['month']
year = data['year']
date = datetime(year, month, day, 12)
userController.deleteWorker(user['username'], date)
debug.debug("return ok")
user = userController.getUser(user)
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"})
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):
debug.info("/sm/lockDay")
try:
data = request.get_json()
year = data['year']
@ -157,13 +192,20 @@ def _lockDay(**kwargs):
},
'locked': lockedDay['locked']
}
print(retVal)
debug.debug("return {{}}".format(retVal))
return jsonify(retVal)
except Exception as err:
debug.debug("exception", exc_info=True)
return jsonify({'error': err}), 409
@vorstand.route("/sm/searchWithExtern", methods=['GET'])
@login_required(groups=[VORSTAND])
def _search(**kwargs):
retVal = ldap.getAllUser()
return jsonify(retVal)
debug.info("/sm/searchWithExtern")
try:
retVal = ldap.getAllUser()
debug.debug("return {{}}".format(retVal))
return jsonify(retVal)
except Exception as err:
debug.debug("exception", exc_info=True)
return jsonify({"error": str(err)}), 500