304 lines
8.8 KiB
Python
304 lines
8.8 KiB
Python
"""
|
|
deze python script werkt, en werkt in de terminal
|
|
voor een gui versie, zie moderator_gui.py
|
|
deze script en moderator_gui.py werken onafhankelijk van elkaar
|
|
"""
|
|
import hashlib
|
|
import getpass
|
|
import database_connector
|
|
from api_keys import *
|
|
import datetime
|
|
from TwitterAPI import TwitterAPI
|
|
|
|
conn = database_connector.conn
|
|
cur = database_connector.cur
|
|
|
|
def newaccount():
|
|
"""
|
|
Spreekt voorzich, dit was een test functie om sql een beetje onder de knie te krijgen
|
|
:returns True on success, False on error
|
|
"""
|
|
try:
|
|
username = input('Gebruikersnaam: ').lower()
|
|
if len(username) > 64 or len(username) < 3:
|
|
print('Gebruikersnaam lengte is ongeldig, gebruik minimaal 3 en maximaal 64 tekens!')
|
|
return False
|
|
elif ' ' in username:
|
|
print('Gebruikersnaam bevat spatie, dat mag niet')
|
|
return False
|
|
print('Uw gebruikersnaam is: ' + username)
|
|
except:
|
|
print('Ongeldige invoer')
|
|
return False
|
|
|
|
try:
|
|
password1 = getpass.getpass('Voer wachtwoord in: ')
|
|
password2 = getpass.getpass('Herhaal wachtwoord: ')
|
|
if len(password1) < 4:
|
|
print('Wachtwoord lengte is te weinig, gebruik minimaal 4 tekens!')
|
|
return False
|
|
elif password1 != password2:
|
|
print('Wachtwoorden zijn niet hetzelfde!')
|
|
except:
|
|
print('Ongeldige invoer')
|
|
return False
|
|
|
|
cur.execute("SELECT naam FROM moderators WHERE naam = (%s);", (username, ))
|
|
sqlreturn = cur.fetchone()
|
|
|
|
if sqlreturn == None:
|
|
"""
|
|
password1 appenden met 'saltedlol' an beide encoden als utf8(ja ik weet het, zo werkt salting niet)
|
|
daarna hashen met sha256(ja ik weet het er zijn betere manieren)
|
|
|
|
na al dat gedoe, in de database inserten met gebruikersnaam en hash
|
|
"""
|
|
hashedpass = hashlib.sha256(password1.encode('UTF-8') + 'saltandpepper'.encode('UTF-8')).hexdigest()
|
|
try:
|
|
cur.execute("INSERT INTO moderators(naam, hash, maylogin) VALUES (%s, %s, %s)", (username, hashedpass, 'true'))
|
|
conn.commit()
|
|
print('Account aangemaakt!')
|
|
return True
|
|
except:
|
|
print('Fout bij het aanmaken van account!')
|
|
return False
|
|
else:
|
|
print('Probleem met de database, bestaat de gebruiker al?')
|
|
return False
|
|
|
|
|
|
def publishtwit(berichtid):
|
|
"""
|
|
ontvangt lokaal bericht id en published dat bericht naar twitter
|
|
na het publishen, de functie pakt dan de twitter uniek id en zet het in de twitter berichten table met alle
|
|
waarden die twitter mee heeft gegeven zoals: id, tijd, datum
|
|
na het successfol publishen gaat de bericht status naar published(5)
|
|
"""
|
|
twitter_API = TwitterAPI(TWITTER_APIKEY, TWITTER_APISECRET, TWITTER_ACCESSTOKEN, TWITTER_ACCESSSECRET)
|
|
|
|
cur.execute("SELECT * FROM berichten WHERE berichtid = (%s)", [berichtid])
|
|
bericht = cur.fetchone()
|
|
|
|
cur.execute("SELECT naam FROM locaties WHERE locatieid = (%s)", [bericht[9]])
|
|
locatie = cur.fetchone()
|
|
|
|
# het bericht dat gepubliceerd wordt
|
|
formatted = str(bericht[1] + ' | Door ' + bericht[4] + ' op ' + locatie[0])
|
|
|
|
if len(formatted) < 180:
|
|
response = twitter_API.request('statuses/update', {'status': formatted})
|
|
jsonresponse = response.json()
|
|
if response.status_code == 200:
|
|
# vul tabel twitterberichten eerst in
|
|
QUERY = 'INSERT INTO twitterberichten(twitterid, datumpublished) VALUES (%s, %s)'
|
|
DATA = (jsonresponse['id'], jsonresponse['created_at'])
|
|
cur.execute(QUERY, DATA)
|
|
|
|
# link twitterberichten met bericht in berichten tabel
|
|
QUERY = 'UPDATE berichten SET twitterid = (%s) WHERE berichtid = (%s)'
|
|
DATA = (jsonresponse['id'], berichtid)
|
|
cur.execute(QUERY, DATA)
|
|
conn.commit()
|
|
return True
|
|
else:
|
|
print('Probleem met het publishen naar twitter')
|
|
return False
|
|
else:
|
|
print('bericht is te lang')
|
|
return False
|
|
|
|
|
|
|
|
def getmessage(moderatorid):
|
|
"""
|
|
vraagt de outste bericht op en zet het bericht gelijk op moderator lock(2)
|
|
returnt een tuple met de oudste bericht met de status 1(pending moderation)
|
|
de tuple ziet er alsvolgt uit: (berichtid int, berichtinhoud str, datum date, naam str)
|
|
"""
|
|
cur.execute("SELECT berichtid, bericht, datumontvangen, naamposter FROM berichten WHERE statusid = 1 ORDER BY datumontvangen LIMIT 1")
|
|
|
|
gottuple = cur.fetchone()
|
|
|
|
if gottuple == None:
|
|
return False
|
|
|
|
cur.execute("UPDATE berichten SET statusid = 2, moderatorid = (%s) WHERE berichtid = (%s)", (moderatorid, gottuple[0]))
|
|
conn.commit()
|
|
return gottuple
|
|
|
|
def unlockmessage(berichtid):
|
|
cur.execute("UPDATE berichten SET statusid = 1, moderatorid = NULL WHERE berichtid = (%s)", [berichtid])
|
|
conn.commit()
|
|
return True
|
|
|
|
def acceptmessage(berichtid, moderatorid):
|
|
|
|
date = datetime.datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")
|
|
|
|
QUERY = "UPDATE berichten SET statusid = 4, datumgekeurd = (%s), moderatorid = (%s) WHERE berichtid = (%s)"
|
|
DATA = (date, moderatorid, berichtid)
|
|
cur.execute(QUERY, DATA)
|
|
conn.commit()
|
|
return True
|
|
|
|
def rejectmessage(berichtid, moderatorid):
|
|
|
|
date = datetime.datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")
|
|
|
|
QUERY = "UPDATE berichten SET statusid = 3, datumgekeurd = (%s), moderatorid = (%s) WHERE berichtid = (%s)"
|
|
DATA = (date, moderatorid, berichtid)
|
|
cur.execute(QUERY, DATA)
|
|
conn.commit()
|
|
return True
|
|
|
|
|
|
def moderateloop(moderatorid):
|
|
"""
|
|
deze functie stop alleen als de gebruiker het aangeeft met: q
|
|
|
|
deze functie vraagt ten eerste de outste bericht door getmessage()
|
|
daarna weergeven de bericht, naam, tijd en datum.
|
|
als de moderator het bericht goedkeurt de status van bericht veranderen naar moderator accepted(4)
|
|
als de bericht wordt afgewezen verander de status naar moderator rejected(3) en loop weer verder
|
|
nadat de bericht is goedgekeurt direct de functie publishtwit(berichtid) en loopt weer verder
|
|
"""
|
|
|
|
while True:
|
|
exitvar = False
|
|
|
|
bericht = getmessage(moderatorid)
|
|
|
|
if bericht == False:
|
|
print('Er zijn geen berichten meer om te weergeven, probeer het later opnieuw')
|
|
return True
|
|
|
|
print("Op " + str(bericht[2]) + " heeft " + str(bericht[3]) + " een bericht achtergelaten")
|
|
print(str(bericht[0]) + " " + str(bericht[1]))
|
|
|
|
while exitvar != True:
|
|
try:
|
|
modinput = input('r = reject, a = accept, q = quit: ').lower()
|
|
if modinput == 'r':
|
|
if rejectmessage(bericht[0], moderatorid):
|
|
print('Moderatie opgeslagen')
|
|
else:
|
|
print('Probleem met het opslaan van de moderatie')
|
|
exitvar = True
|
|
elif modinput == 'a':
|
|
if acceptmessage(bericht[0], moderatorid):
|
|
print('Bericht successvol opgeslagen in database')
|
|
else:
|
|
print('Probleem met het opslaan van de moderatie.')
|
|
|
|
if publishtwit(bericht[0]):
|
|
print('Bericht is successvol gepubliceerd op twitter')
|
|
else:
|
|
print('Probleem met het publiceren op twitter')
|
|
|
|
exitvar = True
|
|
elif modinput == 'q':
|
|
unlockmessage(bericht[0])
|
|
return True
|
|
except:
|
|
print('Ongeldige invoer')
|
|
|
|
|
|
def listmessages(moderatorid):
|
|
while True:
|
|
inputcorrect = False
|
|
print('_________________________________')
|
|
print('Lijst opvragen')
|
|
print('1. Berichten weergeven')
|
|
print('2. Moderators weergeven')
|
|
print('3. Gepubliseerde berichten weergeven')
|
|
print('4. Locaties weergeven')
|
|
print('0. Vorige Menu')
|
|
print('_________________________________')
|
|
|
|
while inputcorrect == False:
|
|
try:
|
|
optie = int(input('Kies optie: '))
|
|
inputcorrect = True
|
|
except:
|
|
print('Ongeldige invoer')
|
|
|
|
if optie == 0:
|
|
return True
|
|
elif optie == 1:
|
|
return
|
|
elif optie == 2:
|
|
return
|
|
elif optie == 3:
|
|
return
|
|
elif optie == 4:
|
|
return
|
|
else:
|
|
print('Ongeldige invoer')
|
|
|
|
def menu(moderatorid, moderatornaam):
|
|
while True:
|
|
inputcorrect = False
|
|
|
|
print('_________________________________')
|
|
print('Hoofdmenu, ingelogd als: ' + moderatornaam)
|
|
print('1. Berichten moderatie wachtrij')
|
|
print('2. Lijst opvragen')
|
|
print('3. Account aanmaken')
|
|
print('0. Uitloggen')
|
|
print('_________________________________')
|
|
|
|
while inputcorrect == False:
|
|
try:
|
|
optie = int(input('Kies optie: '))
|
|
inputcorrect = True
|
|
except:
|
|
print('Ongeldige invoer')
|
|
|
|
|
|
if optie == 0:
|
|
return True
|
|
elif optie == 1:
|
|
moderateloop(moderatorid)
|
|
elif optie == 2:
|
|
#listmessages(moderatorid)
|
|
print('Optie moet nog aangemaakt worden')
|
|
elif optie == 3:
|
|
newaccount()
|
|
else:
|
|
print('Ongeldige invoer')
|
|
|
|
|
|
|
|
def login():
|
|
"""
|
|
deze functie is de eerste die opgeroepen wordt, en vraagt de moderator om in te loggen
|
|
na een successfol inlog start de functie menu() met parameter moderatorid
|
|
als er niet wordt ingelogd stop de functie
|
|
"""
|
|
|
|
try:
|
|
username = input('Gebruikersnaam: ')
|
|
password = getpass.getpass('Wachtwoord: ')
|
|
except:
|
|
print('Ongeldige invoer')
|
|
|
|
hashedpass = hashlib.sha256(password.encode('UTF-8') + 'saltandpepper'.encode('UTF-8')).hexdigest()
|
|
|
|
cur.execute("SELECT * FROM moderators WHERE naam = (%s);", [username])
|
|
sqlreturn = cur.fetchone()
|
|
|
|
if sqlreturn == None:
|
|
print('Gebruiker niet gevonven')
|
|
return False
|
|
elif hashedpass != sqlreturn[2]:
|
|
print('Wachtwoord onjuist')
|
|
return False
|
|
elif sqlreturn[3] != True:
|
|
print('account mag niet inloggen')
|
|
return False
|
|
|
|
menu(sqlreturn[0], sqlreturn[1])
|
|
|
|
|
|
while True:
|
|
login() |