468 lines
20 KiB
Python
468 lines
20 KiB
Python
from . import Singleton, mailConfig
|
|
import geruecht.controller.databaseController as dc
|
|
import geruecht.controller.ldapController as lc
|
|
import geruecht.controller.emailController as ec
|
|
import calendar
|
|
from geruecht.model.user import User
|
|
from geruecht.exceptions import PermissionDenied
|
|
from datetime import datetime, timedelta
|
|
from geruecht.exceptions import UsernameExistLDAP, LDAPExcetpion, DayLocked, TansactJobIsAnswerdException
|
|
from geruecht.logger import getDebugLogger
|
|
|
|
db = dc.DatabaseController()
|
|
ldap = lc.LDAPController()
|
|
emailController = ec.EmailController(mailConfig['URL'], mailConfig['user'], mailConfig['passwd'], mailConfig['crypt'], mailConfig['port'], mailConfig['email'])
|
|
|
|
debug = getDebugLogger()
|
|
|
|
class UserController(metaclass=Singleton):
|
|
|
|
def __init__(self):
|
|
debug.debug("init UserController")
|
|
pass
|
|
|
|
def getAllStatus(self):
|
|
debug.info("get all status for user")
|
|
retVal = db.getAllStatus()
|
|
debug.debug("status are {{}}".format(retVal))
|
|
return retVal
|
|
|
|
def getStatus(self, name):
|
|
debug.info("get status of user {{}}".format(name))
|
|
retVal = db.getStatus(name)
|
|
debug.debug("status of user {{}} is {{}}".format(name, retVal))
|
|
return retVal
|
|
|
|
def setStatus(self, name):
|
|
debug.info("set status of user {{}}".format(name))
|
|
retVal = db.setStatus(name)
|
|
debug.debug("settet status of user {{}} is {{}}".format(name, retVal))
|
|
return retVal
|
|
|
|
def deleteStatus(self, status):
|
|
debug.info("delete status {{}}".format(status))
|
|
db.deleteStatus(status)
|
|
|
|
def updateStatus(self, status):
|
|
debug.info("update status {{}}".format(status))
|
|
retVal = db.updateStatus(status)
|
|
debug.debug("updated status is {{}}".format(retVal))
|
|
return retVal
|
|
|
|
def updateStatusOfUser(self, username, status):
|
|
debug.info("update status {{}} of user {{}}".format(status, username))
|
|
retVal = db.updateStatusOfUser(username, status)
|
|
debug.debug("updatet status of user {{}} is {{}}".format(username, retVal))
|
|
return retVal
|
|
|
|
def updateVotingOfUser(self, username, voting):
|
|
debug.info("update voting {{}} of user {{}}".format(voting, username))
|
|
retVal = db.updateVotingOfUser(username, voting)
|
|
debug.debug("updatet voting of user {{}} is {{}}".format(username, retVal))
|
|
return retVal
|
|
|
|
def deleteDrinkType(self, type):
|
|
debug.info("delete drink type {{}}".format(type))
|
|
db.deleteDrinkType(type)
|
|
|
|
def updateDrinkType(self, type):
|
|
debug.info("update drink type {{}}".format(type))
|
|
retVal = db.updateDrinkType(type)
|
|
debug.debug("updated drink type is {{}}".format(retVal))
|
|
return retVal
|
|
|
|
def setDrinkType(self, type):
|
|
debug.info("set drink type {{}}".format(type))
|
|
retVal = db.setDrinkType(type)
|
|
debug.debug("seted drink type is {{}}".format(retVal))
|
|
return retVal
|
|
|
|
def deletDrinkPrice(self, drink):
|
|
debug.info("delete drink {{}}".format(drink))
|
|
db.deleteDrink(drink)
|
|
|
|
def setDrinkPrice(self, drink):
|
|
debug.info("set drink {{}}".format(drink))
|
|
retVal = db.setDrinkPrice(drink)
|
|
debug.debug("seted drink is {{}}".format(retVal))
|
|
return retVal
|
|
|
|
def updateDrinkPrice(self, drink):
|
|
debug.info("update drink {{}}".format(drink))
|
|
retVal = db.updateDrinkPrice(drink)
|
|
debug.debug("updated drink is {{}}".format(retVal))
|
|
return retVal
|
|
|
|
def getAllDrinkTypes(self):
|
|
debug.info("get all drink types")
|
|
retVal = db.getAllDrinkTypes()
|
|
debug.debug("all drink types are {{}}".format(retVal))
|
|
return retVal
|
|
|
|
def getPricelist(self):
|
|
debug.info("get all drinks")
|
|
list = db.getPriceList()
|
|
debug.debug("all drinks are {{}}".format(list))
|
|
return list
|
|
|
|
def setTransactJob(self, from_user, to_user, date):
|
|
debug.info("set transact job from {{}} to {{}} on {{}}".format(from_user, to_user, date))
|
|
jobtransact = db.setTransactJob(from_user, to_user, date.date())
|
|
debug.debug("transact job is {{}}".format(jobtransact))
|
|
debug.info("send mail with transact job to user")
|
|
emailController.sendMail(jobtransact['to_user'], 'jobtransact', jobtransact)
|
|
return jobtransact
|
|
|
|
def getTransactJobFromUser(self, user, date):
|
|
debug.info("get transact job from user {{}} on {{}}".format(user, date))
|
|
retVal = db.getTransactJobFromUser(user, date.date())
|
|
debug.debug("transact job from user {{}} is {{}}".format(user, retVal))
|
|
return retVal
|
|
|
|
def getAllTransactJobFromUser(self, user, date):
|
|
debug.info("get all transact job from user {{}} start on {{}}".format(user, date))
|
|
retVal = db.getAllTransactJobFromUser(user, date,date())
|
|
debug.debug("all transact job are {{}}".format(retVal))
|
|
return retVal
|
|
|
|
def getAllTransactJobToUser(self, user, date):
|
|
debug.info("get all transact job from to_user {{}} start on {{}}".format(user, date))
|
|
retVal = db.getAllTransactJobToUser(user, date.date())
|
|
debug.debug("all transact job are {{}}".format(retVal))
|
|
return retVal
|
|
|
|
def getTransactJob(self, from_user, to_user, date):
|
|
debug.info("get transact job from user {{}} to user {{}} on {{}}".format(from_user, to_user, date))
|
|
retVal = db.getTransactJob(from_user, to_user, date.date())
|
|
debug.debug("transact job is {{}}".format(retVal))
|
|
return retVal
|
|
|
|
def deleteTransactJob(self, from_user, to_user, date):
|
|
debug.info("delete transact job from user {{}} to user {{}} on {{}}".format(from_user, to_user, date))
|
|
transactJob = self.getTransactJob(from_user, to_user, date)
|
|
debug.debug("transact job is {{}}".format(transactJob))
|
|
if transactJob['answerd']:
|
|
debug.warning("transactjob {{}} can not delete because is answerd")
|
|
raise TansactJobIsAnswerdException("TransactJob is already answerd")
|
|
db.deleteTransactJob(from_user, to_user, date.date())
|
|
|
|
def answerdTransactJob(self, from_user, to_user, date, answer):
|
|
debug.info("answer transact job from user {{}} to user {{}} on {{}} with answer {{}}".format(from_user, to_user, date, answer))
|
|
transactJob = db.updateTransactJob(from_user, to_user, date.date(), answer)
|
|
debug.debug("transactjob is {{}}".format(transactJob))
|
|
if answer:
|
|
debug.info("add worker on date {{}}".format(date))
|
|
self.addWorker(to_user.uid, date)
|
|
return transactJob
|
|
|
|
def setLockedDay(self, date, locked, hard=False):
|
|
debug.info("set day locked on {{}} with state {{}}".format(date, locked))
|
|
retVal = db.setLockedDay(date.date(), locked, hard)
|
|
debug.debug("seted day locked is {{}}".format(retVal))
|
|
return retVal
|
|
|
|
def 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)
|
|
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)
|
|
debug.debug("user is {{}}".format(user))
|
|
retVal = [db.getWorker(user, date)]
|
|
debug.debug("worker is {{}}".format(retVal))
|
|
return retVal
|
|
retVal = db.getWorkers(date)
|
|
debug.debug("workers are {{}}".format(retVal))
|
|
return retVal
|
|
|
|
def addWorker(self, username, date, userExc=False):
|
|
debug.info("add job user {{}} on {{}}".format(username, date))
|
|
if (userExc):
|
|
debug.debug("this is a user execution, check if day is locked")
|
|
lockedDay = self.getLockedDay(date)
|
|
if lockedDay:
|
|
if lockedDay['locked']:
|
|
debug.debug("day is lockey. user cant get job")
|
|
raise DayLocked("Day is locked. You can't get the Job")
|
|
user = self.getUser(username)
|
|
debug.debug("user is {{}}".format(user))
|
|
debug.debug("check if user has job on date")
|
|
if (not db.getWorker(user, date)):
|
|
debug.debug("set job to user")
|
|
db.setWorker(user, date)
|
|
retVal = self.getWorker(date, username=username)
|
|
debug.debug("worker on date is {{}}".format(retVal))
|
|
return retVal
|
|
|
|
def deleteWorker(self, username, date, userExc=False):
|
|
debug.info("delete worker {{}} on date {{}}".format(username, date))
|
|
user = self.getUser(username)
|
|
debug.debug("user is {{}}".format(user))
|
|
if userExc:
|
|
debug.debug("is user execution, check if day locked")
|
|
lockedDay = self.getLockedDay(date)
|
|
if lockedDay:
|
|
if lockedDay['locked']:
|
|
debug.debug("day is locked, check if accepted transact job exists")
|
|
transactJobs = self.getTransactJobFromUser(user, date)
|
|
debug.debug("transact job is {{}}".format(transactJobs))
|
|
found = False
|
|
for job in transactJobs:
|
|
if job['accepted'] and job['answerd']:
|
|
debug.debug("accepted transact job exists")
|
|
found = True
|
|
break
|
|
if not found:
|
|
debug.debug("no accepted transact job found")
|
|
raise DayLocked("Day is locked. You can't delete the Job")
|
|
db.deleteWorker(user, date)
|
|
|
|
def lockUser(self, username, locked):
|
|
debug.info("lock user {{}} for credit with status {{}}".format(username, locked))
|
|
user = self.getUser(username)
|
|
debug.debug("user is {{}}".format(user))
|
|
user.updateData({'locked': locked})
|
|
db.updateUser(user)
|
|
retVal = self.getUser(username)
|
|
debug.debug("locked user is {{}}".format(retVal))
|
|
return retVal
|
|
|
|
def updateConfig(self, username, data):
|
|
debug.info("update config of user {{}} with config {{}}".format(username, data))
|
|
user = self.getUser(username)
|
|
debug.debug("user is {{}}".format(user))
|
|
user.updateData(data)
|
|
db.updateUser(user)
|
|
retVal = self.getUser(username)
|
|
debug.debug("updated config of user is {{}}".format(retVal))
|
|
return retVal
|
|
|
|
def __updateDataFromLDAP(self, user):
|
|
debug.info("update data from ldap for user {{}}".format(user))
|
|
groups = ldap.getGroup(user.uid)
|
|
debug.debug("ldap gorups are {{}}".format(groups))
|
|
user_data = ldap.getUserData(user.uid)
|
|
debug.debug("ldap data is {{}}".format(user_data))
|
|
user_data['gruppe'] = groups
|
|
user_data['group'] = groups
|
|
user.updateData(user_data)
|
|
db.updateUser(user)
|
|
|
|
def autoLock(self, user):
|
|
debug.info("start autolock of user {{}}".format(user))
|
|
if user.autoLock:
|
|
debug.debug("autolock is active")
|
|
credit = user.getGeruecht(year=datetime.now().year).getSchulden()
|
|
limit = -1*user.limit
|
|
if credit <= limit:
|
|
debug.debug("credit {{}} is more than user limit {{}}".format(credit, limit))
|
|
debug.debug("lock user")
|
|
user.updateData({'locked': True})
|
|
debug.debug("send mail to user")
|
|
emailController.sendMail(user)
|
|
else:
|
|
debug.debug("cretid {{}} is less than user limit {{}}".format(credit, limit))
|
|
debug.debug("unlock user")
|
|
user.updateData({'locked': False})
|
|
db.updateUser(user)
|
|
|
|
def addAmount(self, username, amount, year, month, finanzer=False):
|
|
debug.info("add amount {{}} to user {{}} no month {{}}, year {{}}".format(amount, username, month, year))
|
|
user = self.getUser(username)
|
|
debug.debug("user is {{}}".format(user))
|
|
if user.uid == 'extern':
|
|
debug.debug("user is extern user, so exit add amount")
|
|
return
|
|
if not user.locked or finanzer:
|
|
debug.debug("user is not locked {{}} or is finanzer execution {{}}".format(user.locked, finanzer))
|
|
user.addAmount(amount, year=year, month=month)
|
|
creditLists = user.updateGeruecht()
|
|
debug.debug("creditList is {{}}".format(creditLists))
|
|
for creditList in creditLists:
|
|
debug.debug("update creditlist {{}}".format(creditList))
|
|
db.updateCreditList(creditList)
|
|
debug.debug("do autolock")
|
|
self.autoLock(user)
|
|
retVal = user.getGeruecht(year)
|
|
debug.debug("updated creditlists is {{}}".format(retVal))
|
|
return retVal
|
|
|
|
def addCredit(self, username, credit, year, month):
|
|
debug.info("add credit {{}} to user {{}} on month {{}}, year {{}}".format(credit, username, month, year))
|
|
user = self.getUser(username)
|
|
debug.debug("user is {{}}".format(user))
|
|
if user.uid == 'extern':
|
|
debug.debug("user is extern user, so exit add credit")
|
|
return
|
|
user.addCredit(credit, year=year, month=month)
|
|
creditLists = user.updateGeruecht()
|
|
debug.debug("creditlists are {{}}".format(creditLists))
|
|
for creditList in creditLists:
|
|
debug.debug("update creditlist {{}}".format(creditList))
|
|
db.updateCreditList(creditList)
|
|
debug.debug("do autolock")
|
|
self.autoLock(user)
|
|
retVal = user.getGeruecht(year)
|
|
debug.debug("updated creditlists are {{}}".format(retVal))
|
|
return retVal
|
|
|
|
def getAllUsersfromDB(self):
|
|
debug.info("get all users from database")
|
|
users = db.getAllUser()
|
|
debug.debug("users are {{}}".format(users))
|
|
for user in users:
|
|
try:
|
|
debug.debug("update data from ldap")
|
|
self.__updateDataFromLDAP(user)
|
|
except:
|
|
pass
|
|
debug.debug("update creditlists")
|
|
self.__updateGeruechte(user)
|
|
retVal = db.getAllUser(extern=True)
|
|
debug.debug("all users are {{}}".format(retVal))
|
|
return retVal
|
|
|
|
def checkBarUser(self, user):
|
|
debug.info("check if user {{}} is baruser")
|
|
date = datetime.now()
|
|
zero = date.replace(hour=0, minute=0, second=0, microsecond=0)
|
|
end = zero + timedelta(hours=12)
|
|
startdatetime = date.replace(hour=12, minute=0, second=0, microsecond=0)
|
|
if date > zero and end > date:
|
|
startdatetime = startdatetime - timedelta(days=1)
|
|
enddatetime = startdatetime + timedelta(days=1)
|
|
debug.debug("startdatetime is {{}} and enddatetime is {{}}".format(startdatetime, end))
|
|
result = False
|
|
if date >= startdatetime and date < enddatetime:
|
|
result = db.getWorker(user, startdatetime)
|
|
debug.debug("worker is {{}}".format(result))
|
|
return True if result else False
|
|
|
|
|
|
def getUser(self, username):
|
|
debug.info("get user {{}}".format(username))
|
|
user = db.getUser(username)
|
|
debug.debug("user is {{}}".format(user))
|
|
groups = ldap.getGroup(username)
|
|
debug.debug("groups are {{}}".format(groups))
|
|
user_data = ldap.getUserData(username)
|
|
debug.debug("user data from ldap is {{}}".format(user_data))
|
|
user_data['gruppe'] = groups
|
|
user_data['group'] = groups
|
|
if user is None:
|
|
debug.debug("user not exists in database -> insert into database")
|
|
user = User(user_data)
|
|
db.insertUser(user)
|
|
else:
|
|
debug.debug("update database with user")
|
|
user.updateData(user_data)
|
|
db.updateUser(user)
|
|
user = db.getUser(username)
|
|
self.__updateGeruechte(user)
|
|
debug.debug("user is {{}}".format(user))
|
|
return user
|
|
|
|
def __updateGeruechte(self, user):
|
|
debug.debug("update creditlists")
|
|
user.getGeruecht(datetime.now().year)
|
|
creditLists = user.updateGeruecht()
|
|
debug.debug("creditlists are {{}}".format(creditLists))
|
|
if user.getGeruecht(datetime.now().year).getSchulden() != 0:
|
|
for creditList in creditLists:
|
|
debug.debug("update creditlist {{}}".format(creditList))
|
|
db.updateCreditList(creditList)
|
|
|
|
def sendMail(self, username):
|
|
debug.info("send mail to user {{}}".format(username))
|
|
if type(username) == User:
|
|
user = username
|
|
if type(username) == str:
|
|
user = db.getUser(username)
|
|
retVal = emailController.sendMail(user)
|
|
debug.debug("send mail is {{}}".format(retVal))
|
|
return retVal
|
|
|
|
def sendAllMail(self):
|
|
debug.info("send mail to all user")
|
|
retVal = []
|
|
users = db.getAllUser()
|
|
debug.debug("users are {{}}".format(users))
|
|
for user in users:
|
|
retVal.append(self.sendMail(user))
|
|
debug.debug("send mails are {{}}".format(retVal))
|
|
return retVal
|
|
|
|
def modifyUser(self, user, ldap_conn, attributes):
|
|
debug.info("modify user {{}} with attributes {{}} with ldap_conn {{}}".format(user, attributes, ldap_conn))
|
|
try:
|
|
if 'username' in attributes:
|
|
debug.debug("change username, so change first in database")
|
|
db.changeUsername(user, attributes['username'])
|
|
ldap.modifyUser(user, ldap_conn, attributes)
|
|
if 'username' in attributes:
|
|
retVal = self.getUser(attributes['username'])
|
|
debug.debug("user is {{}}".format(retVal))
|
|
return retVal
|
|
else:
|
|
retVal = self.getUser(user.uid)
|
|
debug.debug("user is {{}}".format(retVal))
|
|
return retVal
|
|
except UsernameExistLDAP as err:
|
|
debug.debug("username exists on ldap, rechange username on database", exc_info=True)
|
|
db.changeUsername(user, user.uid)
|
|
raise Exception(err)
|
|
except LDAPExcetpion as err:
|
|
if 'username' in attributes:
|
|
db.changeUsername(user, user.uid)
|
|
raise Exception(err)
|
|
except Exception as err:
|
|
raise Exception(err)
|
|
|
|
def 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
|