580 lines
27 KiB
Python
580 lines
27 KiB
Python
import pymysql
|
|
from . import Singleton
|
|
from geruecht import db
|
|
from geruecht.model.user import User
|
|
from geruecht.model.creditList import CreditList
|
|
from datetime import datetime, timedelta
|
|
from geruecht.exceptions import UsernameExistDB, DatabaseExecption
|
|
import traceback
|
|
from MySQLdb._exceptions import IntegrityError
|
|
|
|
class DatabaseController(metaclass=Singleton):
|
|
'''
|
|
DatabaesController
|
|
|
|
Connect to the Database and execute sql-executions
|
|
'''
|
|
|
|
def __init__(self):
|
|
self.db = db
|
|
|
|
def getAllUser(self, extern=False):
|
|
try:
|
|
cursor = self.db.connection.cursor()
|
|
cursor.execute("select * from user")
|
|
data = cursor.fetchall()
|
|
|
|
if data:
|
|
retVal = []
|
|
for value in data:
|
|
if extern and value['uid'] == 'extern':
|
|
continue
|
|
user = User(value)
|
|
creditLists = self.getCreditListFromUser(user)
|
|
user.initGeruechte(creditLists)
|
|
retVal.append(user)
|
|
return retVal
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Something went worng with Datatabase: {}".format(err))
|
|
|
|
def getUser(self, username):
|
|
try:
|
|
retVal = None
|
|
cursor = self.db.connection.cursor()
|
|
cursor.execute("select * from user where uid='{}'".format(username))
|
|
data = cursor.fetchone()
|
|
if data:
|
|
retVal = User(data)
|
|
creditLists = self.getCreditListFromUser(retVal)
|
|
retVal.initGeruechte(creditLists)
|
|
return retVal
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Something went worng with Datatabase: {}".format(err))
|
|
|
|
def getUserById(self, id):
|
|
try:
|
|
retVal = None
|
|
cursor = self.db.connection.cursor()
|
|
cursor.execute("select * from user where id={}".format(id))
|
|
data = cursor.fetchone()
|
|
if data:
|
|
retVal = User(data)
|
|
creditLists = self.getCreditListFromUser(retVal)
|
|
retVal.initGeruechte(creditLists)
|
|
return retVal
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Something went worng with Datatabase: {}".format(err))
|
|
|
|
def _convertGroupToString(self, groups):
|
|
retVal = ''
|
|
print('groups: {}'.format(groups))
|
|
if groups:
|
|
for group in groups:
|
|
if len(retVal) != 0:
|
|
retVal += ','
|
|
retVal += group
|
|
return retVal
|
|
|
|
|
|
def insertUser(self, user):
|
|
try:
|
|
cursor = self.db.connection.cursor()
|
|
groups = self._convertGroupToString(user.group)
|
|
cursor.execute("insert into user (uid, dn, firstname, lastname, gruppe, lockLimit, locked, autoLock, mail) VALUES ('{}','{}','{}','{}','{}',{},{},{},'{}')".format(
|
|
user.uid, user.dn, user.firstname, user.lastname, groups, user.limit, user.locked, user.autoLock, user.mail))
|
|
self.db.connection.commit()
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Something went worng with Datatabase: {}".format(err))
|
|
|
|
|
|
def updateUser(self, user):
|
|
try:
|
|
cursor = self.db.connection.cursor()
|
|
print('uid: {}; group: {}'.format(user.uid, user.group))
|
|
groups = self._convertGroupToString(user.group)
|
|
sql = "update user set dn='{}', firstname='{}', lastname='{}', gruppe='{}', lockLimit={}, locked={}, autoLock={}, mail='{}' where uid='{}'".format(
|
|
user.dn, user.firstname, user.lastname, groups, user.limit, user.locked, user.autoLock, user.mail, user.uid)
|
|
print(sql)
|
|
cursor.execute(sql)
|
|
self.db.connection.commit()
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Something went worng with Datatabase: {}".format(err))
|
|
|
|
|
|
def getCreditListFromUser(self, user, **kwargs):
|
|
try:
|
|
cursor = self.db.connection.cursor()
|
|
if 'year' in kwargs:
|
|
sql = "select * from creditList where user_id={} and year_date={}".format(user.id, kwargs['year'])
|
|
else:
|
|
sql = "select * from creditList where user_id={}".format(user.id)
|
|
cursor.execute(sql)
|
|
data = cursor.fetchall()
|
|
if len(data) == 1:
|
|
return [CreditList(data[0])]
|
|
else:
|
|
return [CreditList(value) for value in data]
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Something went worng with Datatabase: {}".format(err))
|
|
|
|
|
|
def createCreditList(self, user_id, year=datetime.now().year):
|
|
try:
|
|
cursor = self.db.connection.cursor()
|
|
cursor.execute("insert into creditList (year_date, user_id) values ({},{})".format(year, user_id))
|
|
self.db.connection.commit()
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Something went worng with Datatabase: {}".format(err))
|
|
|
|
|
|
def updateCreditList(self, creditlist):
|
|
try:
|
|
cursor = self.db.connection.cursor()
|
|
cursor.execute("select * from creditList where user_id={} and year_date={}".format(creditlist.user_id, creditlist.year))
|
|
data = cursor.fetchall()
|
|
if len(data) == 0:
|
|
self.createCreditList(creditlist.user_id, creditlist.year)
|
|
sql = "update creditList set jan_guthaben={}, jan_schulden={},feb_guthaben={}, feb_schulden={}, maer_guthaben={}, maer_schulden={}, apr_guthaben={}, apr_schulden={}, mai_guthaben={}, mai_schulden={}, jun_guthaben={}, jun_schulden={}, jul_guthaben={}, jul_schulden={}, aug_guthaben={}, aug_schulden={},sep_guthaben={}, sep_schulden={},okt_guthaben={}, okt_schulden={}, nov_guthaben={}, nov_schulden={}, dez_guthaben={}, dez_schulden={}, last_schulden={} where year_date={} and user_id={}".format(creditlist.jan_guthaben, creditlist.jan_schulden,
|
|
creditlist.feb_guthaben, creditlist.feb_schulden,
|
|
creditlist.maer_guthaben, creditlist.maer_schulden,
|
|
creditlist.apr_guthaben, creditlist.apr_schulden,
|
|
creditlist.mai_guthaben, creditlist.mai_schulden,
|
|
creditlist.jun_guthaben, creditlist.jun_schulden,
|
|
creditlist.jul_guthaben, creditlist.jul_schulden,
|
|
creditlist.aug_guthaben, creditlist.aug_schulden,
|
|
creditlist.sep_guthaben, creditlist.sep_schulden,
|
|
creditlist.okt_guthaben, creditlist.okt_schulden,
|
|
creditlist.nov_guthaben, creditlist.nov_schulden,
|
|
creditlist.dez_guthaben, creditlist.dez_schulden,
|
|
creditlist.last_schulden, creditlist.year, creditlist.user_id)
|
|
print(sql)
|
|
cursor = self.db.connection.cursor()
|
|
cursor.execute(sql)
|
|
self.db.connection.commit()
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Something went worng with Datatabase: {}".format(err))
|
|
|
|
def getWorker(self, user, date):
|
|
try:
|
|
cursor = self.db.connection.cursor()
|
|
cursor.execute("select * from bardienste where user_id={} and startdatetime='{}'".format(user.id, date))
|
|
data = cursor.fetchone()
|
|
return {"user": user.toJSON(), "startdatetime": data['startdatetime'], "enddatetime": data['enddatetime'], "start": { "year": data['startdatetime'].year, "month": data['startdatetime'].month, "day": data['startdatetime'].day}} if data else None
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Something went worng with Datatabase: {}".format(err))
|
|
|
|
def getWorkers(self, date):
|
|
try:
|
|
cursor = self.db.connection.cursor()
|
|
cursor.execute("select * from bardienste where startdatetime='{}'".format(date))
|
|
data = cursor.fetchall()
|
|
return [{"user": self.getUserById(work['user_id']).toJSON(), "startdatetime": work['startdatetime'], "enddatetime": work['enddatetime'], "start": { "year": work['startdatetime'].year, "month": work['startdatetime'].month, "day": work['startdatetime'].day}} for work in data]
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Something went worng with Datatabase: {}".format(err))
|
|
|
|
def setWorker(self, user, date):
|
|
try:
|
|
cursor = self.db.connection.cursor()
|
|
cursor.execute("insert into bardienste (user_id, startdatetime, enddatetime) values ({},'{}','{}')".format(user.id, date, date + timedelta(days=1)))
|
|
self.db.connection.commit()
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Something went worng with Datatabase: {}".format(err))
|
|
|
|
|
|
def deleteWorker(self, user, date):
|
|
try:
|
|
cursor = self.db.connection.cursor()
|
|
cursor.execute("delete from bardienste where user_id={} and startdatetime='{}'".format(user.id, date))
|
|
self.db.connection.commit()
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Something went worng with Datatabase: {}".format(err))
|
|
|
|
def changeUsername(self, user, newUsername):
|
|
try:
|
|
cursor= self.db.connection.cursor()
|
|
cursor.execute("select * from user where uid='{}'".format(newUsername))
|
|
data = cursor.fetchall()
|
|
if data:
|
|
raise UsernameExistDB("Username already exists")
|
|
else:
|
|
cursor.execute("update user set uid='{}' where id={}".format(newUsername, user.id))
|
|
self.db.connection.commit()
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Something went worng with Datatabase: {}".format(err))
|
|
|
|
def getLockedDay(self, date):
|
|
try:
|
|
cursor = self.db.connection.cursor()
|
|
cursor.execute("select * from locked_days where daydate='{}'".format(date))
|
|
data = cursor.fetchone()
|
|
return data
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Something went worng with Datatabase: {}".format(err))
|
|
|
|
def setLockedDay(self, date, locked, hard=False):
|
|
try:
|
|
cursor = self.db.connection.cursor()
|
|
sql = "insert into locked_days (daydate, locked) VALUES ('{}', {})".format(date, locked)
|
|
cursor.execute(sql)
|
|
self.db.connection.commit()
|
|
return self.getLockedDay(date)
|
|
except IntegrityError as err:
|
|
self.db.connection.rollback()
|
|
try:
|
|
exists = self.getLockedDay(date)
|
|
if hard:
|
|
sql = "update locked_days set locked={} where id={}".format(locked, exists['id'])
|
|
else:
|
|
sql = False
|
|
if sql:
|
|
cursor.execute(sql)
|
|
self.db.connection.commit()
|
|
return self.getLockedDay(date)
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Something went wrong with Database: {}".format(err))
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Something went worng with Datatabase: {}".format(err))
|
|
|
|
def setTransactJob(self, from_user, to_user, date):
|
|
try:
|
|
exists = self.getTransactJob(from_user, to_user, date)
|
|
if exists:
|
|
raise IntegrityError("job_transact already exists")
|
|
cursor = self.db.connection.cursor()
|
|
cursor.execute("insert into job_transact (jobdate, from_user_id, to_user_id) VALUES ('{}', {}, {})".format(date, from_user.id, to_user.id))
|
|
self.db.connection.commit()
|
|
return self.getTransactJob(from_user, to_user, date)
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Somethin went wrong with Database: {}".format(err))
|
|
|
|
def getTransactJob(self, from_user, to_user, date):
|
|
try:
|
|
cursor = self.db.connection.cursor()
|
|
cursor.execute("select * from job_transact where from_user_id={} and to_user_id={} and jobdate='{}'".format(from_user.id, to_user.id, date))
|
|
data = cursor.fetchone()
|
|
if data:
|
|
return {"from_user": from_user, "to_user": to_user, "date": data['jobdate'], "answerd": data['answerd'], "accepted": data['accepted']}
|
|
return None
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Something went worng with Database: {}".format(err))
|
|
|
|
def getAllTransactJobFromUser(self, from_user, date):
|
|
try:
|
|
cursor = self.db.connection.cursor()
|
|
cursor.execute("select * from job_transact where from_user_id={}".format(from_user.id))
|
|
data = cursor.fetchall()
|
|
retVal = []
|
|
for transact in data:
|
|
if date <= transact['jobdate']:
|
|
retVal.append({"from_user": from_user, "to_user": self.getUserById(transact['to_user_id']), "date": transact['jobdate'], "accepted": transact['accepted'], "answerd": transact['answerd']})
|
|
return retVal
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Somethin went wrong with Database: {}".format(err))
|
|
|
|
def getAllTransactJobToUser(self, to_user, date):
|
|
try:
|
|
cursor = self.db.connection.cursor()
|
|
cursor.execute("select * from job_transact where to_user_id={}".format(to_user.id))
|
|
data = cursor.fetchall()
|
|
retVal = []
|
|
for transact in data:
|
|
if date <= transact['jobdate']:
|
|
retVal.append({"to_user": to_user, "from_user": self.getUserById(transact['from_user_id']), "date": transact['jobdate'], "accepted": transact['accepted'], "answerd": transact['answerd']})
|
|
return retVal
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Somethin went wrong with Database: {}".format(err))
|
|
|
|
def getTransactJobToUser(self, to_user, date):
|
|
try:
|
|
cursor = self.db.connection.cursor()
|
|
cursor.execute("select * from job_transact where to_user_id={} and jobdate='{}'".format(to_user.id, date))
|
|
data = cursor.fetchone()
|
|
if data:
|
|
return {"from_user": self.getUserById(data['from_user_id']), "to_user": to_user, "date": data['jobdate'], "accepted": data['accepted'], "answerd": data['answerd']}
|
|
else:
|
|
return None
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Somethin went wrong with Database: {}".format(err))
|
|
|
|
def updateTransactJob(self, from_user, to_user, date, accepted):
|
|
try:
|
|
cursor = self.db.connection.cursor()
|
|
cursor.execute("update job_transact set accepted={}, answerd=true where to_user_id={} and jobdate='{}'".format(accepted, to_user.id, date))
|
|
self.db.connection.commit()
|
|
return self.getTransactJob(from_user, to_user, date)
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Somethin went wrong with Database: {}".format(err))
|
|
|
|
def getTransactJobFromUser(self, user, date):
|
|
try:
|
|
cursor = self.db.connection.cursor()
|
|
cursor.execute("select * from job_transact where from_user_id={} and jobdate='{}'".format(user.id, date))
|
|
data = cursor.fetchall()
|
|
return [{"from_user": user, "to_user": self.getUserById(transact['to_user_id']), "date": transact['jobdate'], "accepted": transact['accepted'], "answerd": transact['answerd']} for transact in data]
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Somethin went wrong with Database: {}".format(err))
|
|
|
|
def deleteTransactJob(self, from_user, to_user, date):
|
|
try:
|
|
cursor = self.db.connection.cursor()
|
|
cursor.execute("delete from job_transact where from_user_id={} and to_user_id={} and jobdate='{}'".format(from_user.id, to_user.id, date))
|
|
self.db.connection.commit()
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Something went wrong with Database: {}".format(err))
|
|
|
|
def getPriceList(self):
|
|
try:
|
|
cursor = self.db.connection.cursor()
|
|
cursor.execute("select * from pricelist")
|
|
return cursor.fetchall()
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Something went wrong with Database: {}".format(err))
|
|
|
|
def getDrinkPrice(self, name):
|
|
try:
|
|
cursor = self.db.connection.cursor()
|
|
if type(name) == str:
|
|
sql = "select * from pricelist where name='{}'".format(name)
|
|
elif type(name) == int:
|
|
sql = 'select * from pricelist where id={}'.format(name)
|
|
else:
|
|
raise DatabaseExecption("name as no type int or str. name={}, type={}".format(name, type(name)))
|
|
cursor.execute(sql)
|
|
return cursor.fetchone()
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Something went wrong with Database: {}".format(err))
|
|
|
|
def setDrinkPrice(self, drink):
|
|
try:
|
|
cursor = self.db.connection.cursor()
|
|
cursor.execute(
|
|
"insert into pricelist (name, price, price_big, price_club, price_club_big, premium, premium_club, price_extern_club, type) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s)",
|
|
(
|
|
drink['name'], drink['price'], drink['price_big'], drink['price_club'], drink['price_club_big'],
|
|
drink['premium'], drink['premium_club'], drink['price_extern_club'], drink['type']))
|
|
self.db.connection.commit()
|
|
return self.getDrinkPrice(str(drink['name']))
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Something went wrong with Database: {}".format(err))
|
|
|
|
def updateDrinkPrice(self, drink):
|
|
try:
|
|
cursor = self.db.connection.cursor()
|
|
cursor.execute("update pricelist set name=%s, price=%s, price_big=%s, price_club=%s, price_club_big=%s, premium=%s, premium_club=%s, price_extern_club=%s, type=%s where id=%s",
|
|
(
|
|
drink['name'], drink['price'], drink['price_big'], drink['price_club'], drink['price_club_big'], drink['premium'], drink['premium_club'], drink['price_extern_club'], drink['type'], drink['id']
|
|
))
|
|
self.db.connection.commit()
|
|
return self.getDrinkPrice(drink['id'])
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Something went wrong with Database: {}".format(err))
|
|
|
|
def deleteDrink(self, drink):
|
|
try:
|
|
cursor = self.db.connection.cursor()
|
|
cursor.execute("delete from pricelist where id={}".format(drink['id']))
|
|
self.db.connection.commit()
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Something went worng with Database: {}".format(err))
|
|
|
|
def getDrinkType(self, name):
|
|
try:
|
|
cursor = self.db.connection.cursor()
|
|
if type(name) == str:
|
|
sql = "select * from drink_type where name='{}'".format(name)
|
|
elif type(name) == int:
|
|
sql = 'select * from drink_type where id={}'.format(name)
|
|
else:
|
|
raise DatabaseExecption("name as no type int or str. name={}, type={}".format(name, type(name)))
|
|
cursor.execute(sql)
|
|
return cursor.fetchone()
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Something went wrong with Database: {}".format(err))
|
|
|
|
def setDrinkType(self, name):
|
|
try:
|
|
cursor = self.db.connection.cursor()
|
|
cursor.execute("insert into drink_type (name) values ('{}')".format(name))
|
|
self.db.connection.commit()
|
|
return self.getDrinkType(name)
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Something went worng with Database: {}".format(err))
|
|
|
|
def updateDrinkType(self, type):
|
|
try:
|
|
cursor = self.db.connection.cursor()
|
|
cursor.execute("update drink_type set name='{}' where id={}".format(type['name'], type['id']))
|
|
self.db.connection.commit()
|
|
return self.getDrinkType(type['id'])
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Something went worng with Database: {}".format(err))
|
|
|
|
def deleteDrinkType(self, type):
|
|
try:
|
|
cursor = self.db.connection.cursor()
|
|
cursor.execute("delete from drink_type where id={}".format(type['id']))
|
|
self.db.connection.commit()
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Something went wrong with Database: {}".format(err))
|
|
|
|
def getAllDrinkTypes(self):
|
|
try:
|
|
cursor = self.db.connection.cursor()
|
|
cursor.execute('select * from drink_type')
|
|
return cursor.fetchall()
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Something went worng with Database: {}".format(err))
|
|
|
|
def getAllStatus(self):
|
|
try:
|
|
cursor = self.db.connection.cursor()
|
|
cursor.execute('select * from statusgroup')
|
|
return cursor.fetchall()
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Something went worng with Databes: {}".format(err))
|
|
|
|
def getStatus(self, name):
|
|
try:
|
|
cursor = self.db.connection.cursor()
|
|
if type(name) == str:
|
|
sql = "select * from statusgroup where name='{}'".format(name)
|
|
elif type(name) == int:
|
|
sql = 'select * from statusgroup where id={}'.format(name)
|
|
else:
|
|
raise DatabaseExecption("name as no type int or str. name={}, type={}".format(name, type(name)))
|
|
cursor.execute(sql)
|
|
return cursor.fetchone()
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Something went worng with Databes: {}".format(err))
|
|
|
|
def setStatus(self, name):
|
|
try:
|
|
cursor = self.db.connection.cursor()
|
|
cursor.execute("insert into statusgroup (name) values ('{}')".format(name))
|
|
self.db.connection.commit()
|
|
return self.getStatus(name)
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Something went worng with Databes: {}".format(err))
|
|
|
|
def updateStatus(self, status):
|
|
try:
|
|
cursor = self.db.connection.cursor()
|
|
cursor.execute("update statusgroup set name='{}' where id={}".format(status['name'], status['id']))
|
|
self.db.connection.commit()
|
|
return self.getStatus(status['id'])
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Something went worng with Databes: {}".format(err))
|
|
|
|
def deleteStatus(self, status):
|
|
try:
|
|
cursor = self.db.connection.cursor()
|
|
cursor.execute("delete from statusgroup where id={}".format(status['id']))
|
|
self.db.connection.commit()
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Something went worng with Databes: {}".format(err))
|
|
|
|
def updateStatusOfUser(self, username, status):
|
|
try:
|
|
cursor = self.db.connection.cursor()
|
|
cursor.execute("update user set statusgroup={} where uid='{}'".format(status['id'], username))
|
|
self.db.connection.commit()
|
|
return self.getUser(username)
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Something went worng with Databes: {}".format(err))
|
|
|
|
def updateVotingOfUser(self, username, voting):
|
|
try:
|
|
cursor = self.db.connection.cursor()
|
|
cursor.execute("update user set voting={} where uid='{}'".format(voting, username))
|
|
self.db.connection.commit()
|
|
return self.getUser(username)
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.db.connection.rollback()
|
|
raise DatabaseExecption("Something went worng with Databes: {}".format(err))
|
|
|
|
if __name__ == '__main__':
|
|
db = DatabaseController()
|
|
user = db.getUser('jhille')
|
|
db.getCreditListFromUser(user, year=2018)
|