def postociPoFakultetu():
result = {
"status" : False,
"podaci" : []
}
try:
idFak = session["user_data"]["idFakulteta"]
pripadaju = baseSession.query(Pripada).filter(Pripada.fakultet_idFakulteta == idFak).order_by(Pripada.postotak.desc())
pripadaju1 = baseSession.query(Pripada).filter(Pripada.fakultet_idFakulteta == idFak).group_by(Pripada.postotak).order_by(Pripada.postotak.desc())
lista = []
for pripada in pripadaju:
lista.append(pripada.postotak)
for pripada in pripadaju1:
a = {
"postotak" : pripada.postotak,
"broj" : lista.count(pripada.postotak)
}
result["podaci"].append(a)
result["status"] = True
try:
dnevnik = Dnevnik(session["user_data"]["idFakulteta"], "Fakultet", "Dohvaćanje statistike - Postoci po fakultetu")
baseSession.add(dnevnik)
baseSession.commit()
except (BaseException, KeyError):
baseSession.rollback()
pass
except (BaseException, KeyError):
pass
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
def fakseviPoPrioritetuJedan():
result = {
"status" : False,
"podaci" : []
}
try:
pripadaju = baseSession.query(Pripada).filter(Pripada.prioritet == 1).order_by(Pripada.fakultet_idFakulteta.asc())
pripadajuDist = baseSession.query(Pripada).filter(Pripada.prioritet == 1).group_by(Pripada.fakultet_idFakulteta)
lista = []
brojZapisa = 0
for pri in pripadaju:
lista.append(pri.fakultet.naziv)
for pri in pripadajuDist:
a = {
"naziv" : pri.fakultet.naziv,
"broj" : lista.count(pri.fakultet.naziv)
}
result["podaci"].append(a)
brojZapisa += 1
if brojZapisa >= 10:
break
result["status"] = True
try:
dnevnik = Dnevnik(session["user_data"]["idFakulteta"], "Fakultet", "Dohvaćanje statistike - Fakulteti po prioritetima")
baseSession.add(dnevnik)
baseSession.commit()
except (BaseException, KeyError):
baseSession.rollback()
pass
except (BaseException):
pass
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
def popisInteresaZaOdabrati():
"""
Metoda ne prima parametre. Vraća popis interesa koji fakultet može odabrati, tj. one koje nema odabrane.
Korisnik MORA biti prijavljen za poziv.
"""
result = {"status": False, "vrijeme": str(datetime.datetime.now()), "brojZapisa": 0, "podaci": []}
try:
listaInteresa = baseSession.query(Interes).all()
faks = baseSession.query(Fakultet).filter(Fakultet.idFakulteta == session["user_data"]["idFakulteta"]).first()
# Ovo je improvizirani način jer ovaj upit iz nekog razloga ne radi
# listaInteresa = baseSession.query(Interes).filter(Interes.fakulteti.any(Fakultet.idFakulteta != session["user_data"]["idFakulteta"])).order_by(Interes.idInteresa)
for i in listaInteresa:
if faks not in i.fakulteti:
a = {"idInteresa": i.idInteresa, "naziv": i.naziv}
result["podaci"].append(a)
result["brojZapisa"] = len(result["podaci"])
result["status"] = True
try:
dnevnik = Dnevnik(faks.idFakulteta, "Fakultet", "Dohvaćanje interesa za odabrati")
baseSession.add(dnevnik)
baseSession.commit()
except (BaseException):
baseSession.rollback()
pass
except (BaseException):
pass
return Response(json.dumps(result), mimetype="application/json; charset=UTF-8")
def kreirajInteres(nazivInteresa=None):
"""
Metoda za kreiranje interesa. Metoda prima podatke putem POST metode, predajom JSON-a oblika
{"naziv": "ime interesa"} ukoliko joj nije proslijeđen parametar. Ukoliko se proslijedi parametar
kreira se interes imena proslijeđenog u parametru.
@param nazivInteresa: string
Korisnik MORA biti prijavljen za poziv.
"""
result = {"status": False, "message": "Općenita greška"}
try:
if nazivInteresa == None:
data = request.get_json(force=True)
nazivInteresa = data["naziv"]
except KeyError:
result["message"] = "Neispravan JSON"
return Response(json.dumps(result), mimetype="application/json; charset=UTF-8")
try:
faks = baseSession.query(Fakultet).filter(Fakultet.idFakulteta == session["user_data"]["idFakulteta"]).first()
interes = baseSession.query(Interes).filter(Interes.naziv == nazivInteresa).first()
if interes == None:
baseSession.add(Interes(nazivInteresa))
baseSession.commit()
else:
result["message"] = "Interes već postoji: " + interes.naziv
return Response(json.dumps(result), mimetype="application/json; charset=UTF-8")
interes = baseSession.query(Interes).filter(Interes.naziv == nazivInteresa).first()
pi = PonudaInteresa()
pi.fakultet = faks
pi.interes = interes
baseSession.add(pi)
baseSession.commit()
result["status"] = True
result["message"] = "Podatak je uspješno dodan."
try:
dnevnik = Dnevnik(session["user_data"]["idFakulteta"], "Fakultet", "Kreiranje interesa")
baseSession.add(dnevnik)
baseSession.commit()
except (BaseException, KeyError):
baseSession.rollback()
pass
except (BaseException):
baseSession.rollback()
return Response(json.dumps(result), mimetype="application/json; charset=UTF-8")
def dodajInteres(listaId=None):
"""
Metoda dodaje listu interesa za pojedini fakultet. Ignoriraju se interesi koji već postoje.
Metoda prima listu ID-a preko parametra
@param listaId: [int, int, ..., int]
Ukoliko parametar nije proslijeđen, metoda preuzima podatke iz POST requesta, iz JSON objekta strukture
{"idLista":[int, int, ..., int]}
Korisnik MORA biti prijavljen za poziv.
"""
result = {"status": False, "message": "", "podaci": []}
try:
if listaId == None:
data = request.get_json(force=True)
listaId = data["idLista"]
except KeyError:
result["message"] = "Neispravan JSON"
return Response(json.dumps(result), mimetype="application/json; charset=UTF-8")
try:
idFaksa = session["user_data"]["idFakulteta"]
faks = baseSession.query(Fakultet).filter(Fakultet.idFakulteta == idFaksa).first()
listaInteresa = baseSession.query(Interes).filter(
Interes.idInteresa.in_(listaId)
) # svi interesi prema zadanim ID
for interes in listaInteresa:
if interes not in faks.interesi:
faks.interesi.append(interes)
result["podaci"].append(interes.naziv)
baseSession.add(faks)
baseSession.commit()
result["status"] = True
result["message"] = "Interesi su uspješno dodani."
try:
dnevnik = Dnevnik(session["user_data"]["idFakulteta"], "Fakultet", "Odabir interesa")
baseSession.add(dnevnik)
baseSession.commit()
except (BaseException, KeyError):
baseSession.rollback()
pass
except (BaseException, KeyError):
baseSession.rollback()
result["message"] = "Pogreška kod dodavanja interesa!"
return Response(json.dumps(result), mimetype="application/json; charset=UTF-8")
def popisOdabranihInteresa():
"""
Metoda ne prima parametre, a vraća popis odabranih interesa za prijavljeni fakultet.
Korisnik MORA biti prijavljen za poziv.
"""
result = {"status": False, "vrijeme": str(datetime.datetime.now()), "brojZapisa": 0, "podaci": []}
try:
faks = baseSession.query(Fakultet).filter(Fakultet.idFakulteta == session["user_data"]["idFakulteta"]).first()
for i in faks.interesi:
a = {"idInteresa": i.idInteresa, "naziv": i.naziv}
result["podaci"].append(a)
result["brojZapisa"] = len(result["podaci"])
result["status"] = True
try:
dnevnik = Dnevnik(session["user_data"]["idFakulteta"], "Fakultet", "Popis odabranih interesa")
baseSession.add(dnevnik)
baseSession.commit()
except (BaseException, KeyError):
baseSession.rollback()
pass
except (BaseException):
pass
return Response(json.dumps(result), mimetype="application/json; charset=UTF-8")
def promjeniEmail():
result={
"status" : False,
"message" : "Neuspješna promjena emaila!"
}
fakultet = baseSession.query(Fakultet).filter(Fakultet.idFakulteta == session["user_data"]["idFakulteta"]).first()
if fakultet != None:
res = json.loads(Fakulteti.provjeriDostupnostEmaila(request.form['noviEmail'], False))
if res["status"] == True:
if fakultet.lozinka == hashlib.sha512((request.form['trenutnaLozinka']).encode()).hexdigest():
fakultet.email = request.form['noviEmail']
baseSession.add(fakultet)
baseSession.commit()
result["status"] = True
result["message"] = "Email uspješno promjenjen!"
try:
dnevnik = Dnevnik(session["user_data"]["idFakulteta"], "Fakultet", "Promjena emaila")
baseSession.add(dnevnik)
baseSession.commit()
except (BaseException, KeyError):
baseSession.rollback()
pass
else:
result["message"] += " Pogrešna lozinka!"
else:
result["message"] += res["message"]
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
def pocetna():
try:
poruke = baseSession.query(Poruka).order_by(Poruka.vrijeme.desc())
except (BaseException):
pass
return render_template("objave.html", poruke = poruke)
def restRegistracijaUcenika():
result = {
'status' : False,
'message' : "Neuspješna registracija!"
}
#if request.method == 'POST':
data = request.get_json(force=True)
try:
email = data["email"]
lozinka = data["lozinka"]
ime = data["ime"]
prezime = data["prezime"]
except KeyError:
result["message"] = "Pogrešni podaci!"
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
try:
ucenik = baseSession.query(Ucenik).filter(Ucenik.email == email).first()
if ucenik == None:
noviUcenik = Ucenik()
noviUcenik.email = email
noviUcenik.lozinka = lozinka
noviUcenik.ime = ime
noviUcenik.prezime = prezime
baseSession.add(noviUcenik)
baseSession.commit()
result['status'] = True
result['message'] = "Uspješno ste se registrirali."
else:
result['message'] = "Upisana email adresa je zauzeta!"
except (BaseException, KeyError):
result["message"] = "Pogreška s bazom!"
baseSession.rollback()
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
def ukloniInteres(listaId=None):
"""Metoda ukladnja interes s popisa odabranih interesa za prijavljenog korisnika. Metoda također prima parametre
@param listaId: [int, int, ..., int]
kao i listu ID interesa u obliku JSON objekta preko POST metode
JSON izgleda ovako
Izgled J
{
"idInteresa" : [int, int, ..., int]
}
Korisnik MORA biti prijavljen za poziv.
"""
result = {"status": False, "message": "Općenita greška"}
try:
if listaId == None:
data = request.get_json(force=True)
listaId = data["idLista"]
except KeyError:
result["message"] = "Neispravan JSON"
return Response(json.dumps(result), mimetype="application/json; charset=UTF-8")
try:
idFaksa = session["user_data"]["idFakulteta"]
faks = baseSession.query(Fakultet).filter(Fakultet.idFakulteta == idFaksa).first()
listaInteresa = baseSession.query(Interes).filter(Interes.idInteresa.in_(listaId))
for interes in listaInteresa:
if interes in faks.interesi:
faks.interesi.remove(interes)
baseSession.add(faks)
baseSession.commit()
result["status"] = True
result["message"] = "Interesi su uspješno uklonjeni."
try:
dnevnik = Dnevnik(session["user_data"]["idFakulteta"], "Fakultet", "Uklanjanje interesa")
baseSession.add(dnevnik)
baseSession.commit()
except (BaseException, KeyError):
baseSession.rollback()
pass
except (BaseException, KeyError):
baseSession.rollback()
result["message"] = "Greška kod uklanjanja interesa."
return Response(json.dumps(result), mimetype="application/json; charset=UTF-8")
def dohvatiProfil():
listaUcilista = []
for instance in baseSession.query(VisokoUciliste).order_by(VisokoUciliste.idVisokogUcilista):
a = {"idVisokogUcilista" : instance.idVisokogUcilista, \
"naziv" : instance.naziv
}
listaUcilista.append(a)
return render_template('profil.html', popis=listaUcilista )
def obrisiInteres(idInteresa=None):
"""
Metoda prihvaća HTTP metodu post u kojoj putem JOSN objekta šalje ID interesa koji se želi izbrisati iz baze.
uobliku JSON objekta jednostavan i sadrži samo ID interesa
{
"idInteresa" : int
}
Moguće je proslijediti i parametar ID interesa
@param idInteresa: int
Korisnik MORA biti prijavljen za poziv.
"""
result = {"status": False, "message": "Općenita greška"}
try:
if idInteresa == None:
data = request.get_json(force=True)
idInteresa = data["idInteresa"]
except KeyError:
result["message"] = "Neispravan JSON"
return Response(json.dumps(result), mimetype="application/json; charset=UTF-8")
try:
baseSession.query(Interes).filter(Interes.idInteresa == idInteresa).first().delete()
baseSession.commit()
result["message"] = "Zapis je uspješno obrisan."
try:
dnevnik = Dnevnik(session["user_data"]["idFakulteta"], "Fakultet", "Brisanje interesa")
baseSession.add(dnevnik)
baseSession.commit()
except (BaseException, KeyError):
baseSession.rollback()
pass
except (BaseException):
baseSession.rollback()
result["message"] = "Greška kod brisanja zapisa."
return Response(json.dumps(result), mimetype="application/json; charset=UTF-8")
def restPrijava(mail=None, passw = None):
''' REST servis za prijavu fakulteta na sustav. Funkciju je moguće koristiti kao normalnu funkciju na
webu proslijeđivanjem parametara email, lozinka ili pozivanjem pomoću POST requesta'''
result = {
"status" : False,
"message" : "Neuspjela prijava!"
}
if request.method == 'POST' or (mail != None and passw != None):
if mail != None and passw != None:
userEmail = mail
userPass = passw
else:
data = request.get_json(force=True)
userEmail = data['email']
userPass = data['password']
try:
fakultet = baseSession.query(Fakultet).filter(and_(Fakultet.email==userEmail, Fakultet.blokiran==False, \
Fakultet.aktiviran==True, Fakultet.lozinka == hashlib.sha512(userPass.encode()).hexdigest())).first()
if fakultet != None:
a = {"idFakulteta" : fakultet.idFakulteta, \
"naziv" : fakultet.naziv, \
"ulica" : fakultet.ulica, \
"kucniBroj" : fakultet.kucniBroj, \
"postanskiBroj" : fakultet.postanskiBroj, \
"mjesto" : fakultet.mjesto, \
"kontaktEmail" : fakultet.kontaktEmail, \
"kontaktTelefon" : fakultet.kontaktTelefon, \
"logo" : fakultet.logo, \
"webStranica" : fakultet.webStranica, \
"visokoUciliste" : fakultet.visokoUciliste_idVisokogUcilista, \
"email" : fakultet.email
}
session['user_data'] = dict(a)
result['status'] = True
result['message'] = "Uspješno ste se prijavili!"
try:
dnevnik = Dnevnik(fakultet.idFakulteta, "Fakultet", "Prijava u sustav")
baseSession.add(dnevnik)
baseSession.commit()
except (BaseException):
baseSession.rollback()
pass
except (BaseException):
pass
if mail != None and passw != None: #Pozvano u web aplikaciji
return json.dumps(result)
else: #Pozvano preko rest servisa
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
def dohvatiDnevnik():
''' Funkcija dohvaća sve zapise u dnevniku'''
try:
dnevnik = baseSession.query(Dnevnik).order_by(Dnevnik.vrijeme.desc()).all()
broj = baseSession.query(Dnevnik).count()
except (BaseException):
pass
result = {
'draw' : 1,
'recordsTotal' : broj,
'data' : []
}
for zapis in dnevnik:
a = {
"idZapisa" : zapis.idZapisa,
"idLogiranogKorisnika" : zapis.idLogiranogKorisnika,
"tipLogiranogKorisnika" : zapis.tipLogiranogKorisnika,
"vrijeme" : zapis.vrijeme.isoformat(),
"akcija" : zapis.akcija
}
result["data"].append(a)
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
def deleteAction():
''' Funkcija dohvaća sve fakultete koji su registrirani. Čisto za potrebe CRUD.'''
result = {
'Result' : "ERROR",
'Message' : "Neuspješno brisanje zapisa!",
'Record' : []
}
try:
idFakulteta = request.form["idFakulteta"]
except (KeyError, TypeError):
result["Message"] = "Pogrešni podaci!"
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
try:
baseSession.query(Fakultet).filter(Fakultet.idFakulteta == idFakulteta).delete()
baseSession.commit()
result["Result"] = "OK"
result["Message"] = "Zapis uspješno obrisan."
except (BaseException) :
baseSession.rollback()
result["Message"] = "Pogreška s bazom!"
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
def brojUcenika(nijeServis = None):
result = {
"status" : False
}
try:
brojUce = baseSession.query(Ucenik).count()
if nijeServis != None:
return brojUce
else:
result["status"] = True
result["brojUcenika"] = brojUce
except (BaseException):
pass
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
def popisInteresa():
"""
Metoda ne prima parametre, a vraća sve interese iz baze podataka. Korisnik ne mora biti prijavljen za poziv.
"""
result = {"status": False, "vrijeme": str(datetime.datetime.now()), "brojZapisa": 0, "podaci": []}
try:
listaInteresa = baseSession.query(Interes).order_by(Interes.idInteresa)
for interes in listaInteresa:
a = {"idInteresa": interes.idInteresa, "naziv": interes.naziv}
result["podaci"].append(a)
result["brojZapisa"] = len(result["podaci"])
result["status"] = True
except (BaseException):
pass
return Response(json.dumps(result), mimetype="application/json; charset=UTF-8")
def provjeriDostupnostEmaila(email, odg = True):
''' Funkcija provjerava dostupnost email adrese, vraća True ako je slobodna, odnosno
False ako nije slobodna'''
result = {
'status' : True,
'message' : "Upisana email adresa je slobodna."
}
try:
fak = baseSession.query(Fakultet).filter(Fakultet.email == email).first()
if fak != None and fak.aktiviran == True:
result['status'] = False
result['message'] = "Upisana email adresa je zauzeta!"
except (BaseException):
pass
if odg: #Poziv sa rest servisa
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
else: #Poziv iz aplikacije
return json.dumps(result)
def dohvatiFakultete():
result = {
"status" : False,
"message" : "Neuspješno dohvaćanje!",
"podaci" : []
}
try:
for instance in baseSession.query(Fakultet).order_by(Fakultet.idFakulteta):
dodaj = {}
dodaj["naziv"] = instance.naziv
dodaj["url"] = instance.webStranica
result["podaci"].append(dodaj)
result["status"] = True
result["message"] = "Podaci uspješno dohvaćeni."
except (BaseException):
pass
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
def listAction():
''' Funkcija dohvaća sve fakultete koji su registrirani. Čisto za potrebe CRUD.'''
result = {
'Result' : "ERROR",
'Message' : "Neuspješno dohvaćanje zapisa!",
'Records' : []
}
try:
pocetak = int(request.args.get("jtStartIndex"))
velicinaStranice = int(request.args.get("jtPageSize"))
except KeyError as e:
result["Message"] = "Pogreška kod zahtjeva!"+str(e)
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
ukupniBroj = 0
try:
popisFakulteta = baseSession.query(Fakultet).order_by(Fakultet.idFakulteta)
for instance in popisFakulteta:
a = {"idFakulteta" : instance.idFakulteta,
"naziv" : instance.naziv,
"ulica" : instance.ulica,
"kucniBroj" : instance.kucniBroj,
"postanskiBroj" : instance.postanskiBroj,
"mjesto" : instance.mjesto,
"kontaktEmail" : instance.kontaktEmail,
"kontaktTelefon" : instance.kontaktTelefon,
"logo" : instance.logo,
"webStranica" : instance.webStranica,
"visokoUciliste" : instance.visokoUciliste_idVisokogUcilista,
"email" : instance.email,
"lozinka" : instance.lozinka
}
result['Records'].append(a)
ukupniBroj += 1
result['Result'] = "OK"
result['Message'] = "Successfull."
result["TotalRecordCount"] = ukupniBroj
except (BaseException) as e:
result['Message'] = str(e)
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
def aktivirajMail(kod, odg = True):
''' Funkcija aktivira korisnički profil pomoću adrese elektroničke pošte'''
result = {
'status' : False,
'message' : "Pogreška kod aktivacije!"
}
try:
fak = baseSession.query(Fakultet).filter(Fakultet.aktivacijskiKod == kod).first()
if fak != None:
fak.aktiviran = True
baseSession.add(fak)
baseSession.commit()
result['status'] = True
result['message'] = "Korisnički profil je uspješno aktiviran!"
except (BaseException):
baseSession.rollback()
if odg:
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
else:
return json.dumps(result)
def dohvatiSveucilistaFakultete():
result = {
"status" : False,
"message" : "Neuspješno dohvaćanje!",
"podaci" : []
}
try:
for instance in baseSession.query(VisokoUciliste).order_by(VisokoUciliste.idVisokogUcilista):
dodaj = {}
dodaj["uciliste"] = instance.naziv
dodaj["fakulteti"] = []
for k in instance.fakulteti:
fak = {
"naziv" : k.naziv
}
dodaj["fakulteti"].append(fak)
result["podaci"].append(dodaj)
result["status"] = True
result["message"] = "Podaci uspješno dohvaćeni."
except (BaseException):
baseSession.rollback()
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
def restPrijavaUcenika():
''' REST servis za prijavu ucenika na sustav.'''
result = {
"status" : False,
"message" : "Neuspjesna prijava!"
}
data = request.get_json(force=True)
try:
email = data["email"]
lozinka = data["lozinka"]
except KeyError:
result["message"] = "Pogrešni podaci!"
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
try:
ucenik = baseSession.query(Ucenik).filter(and_(Ucenik.email == email, Ucenik.lozinka == lozinka)).first()
if ucenik != None:
a = {"idUcenika" : ucenik.idUcenika, \
"ime" : ucenik.ime, \
"prezime" : ucenik.prezime, \
"email" : ucenik.email
}
result['status'] = True
result['message'] = "Uspjesno ste se prijavili."
result['podaci'] = a
try:
dnevnik = Dnevnik(ucenik.idUcenika, "Ucenik", "Prijava u sustav")
baseSession.add(dnevnik)
baseSession.commit()
except (BaseException):
baseSession.rollback()
pass
except (BaseException, KeyError):
result["message"] = "Pogreška s bazom!"
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
def prioritetiPoFakultetu():
result = {
"status" : False
}
try:
idFak = session["user_data"]["idFakulteta"]
pripadaju = baseSession.query(Pripada).filter(Pripada.fakultet_idFakulteta == idFak)
brojPrioriteta = [0,0,0,0,0]
for pripada in pripadaju:
if(pripada.prioritet == 1):
brojPrioriteta[0] += 1
elif (pripada.prioritet == 2):
brojPrioriteta[1] += 1
elif (pripada.prioritet == 3):
brojPrioriteta[2] += 1
elif (pripada.prioritet == 4):
brojPrioriteta[3] += 1
elif (pripada.prioritet == 5):
brojPrioriteta[4] += 1
else:
pass
result["podaci"] = brojPrioriteta
result["status"] = True
try:
dnevnik = Dnevnik(session["user_data"]["idFakulteta"], "Fakultet", "Dohvaćanje statistike - Prioriteti po fakultetu")
baseSession.add(dnevnik)
baseSession.commit()
except (BaseException, KeyError):
baseSession.rollback()
pass
except (BaseException, KeyError):
pass
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
def azurirajProfil():
result = {
"status":"GREŠKA",
"message" : "Pogreška kod ažuriranja podataka!"
}
azuriraj = False
if (request.method == 'POST'):
try:
fak = baseSession.query(Fakultet).filter(Fakultet.idFakulteta == session['user_data']['idFakulteta']).first()
if session['user_data']['naziv'] != request.form['id_naziv']:
fak.naziv = request.form['id_naziv']
azuriraj = True
if session['user_data']['ulica'] != request.form['id_ulica']:
fak.ulica = request.form['id_ulica']
azuriraj = True
if session['user_data']['kucniBroj'] != request.form['id_kucniBroj']:
fak.kucniBroj = request.form['id_kucniBroj']
azuriraj = True
if session['user_data']['mjesto'] != request.form['id_mjesto']:
fak.mjesto = request.form['id_mjesto']
azuriraj = True
if session['user_data']['postanskiBroj'] != request.form['id_postanskiBroj']:
fak.postanskiBroj = request.form['id_postanskiBroj']
azuriraj = True
if session['user_data']['kontaktEmail'] != request.form['id_kontaktEmail']:
fak.kontaktEmail = request.form['id_kontaktEmail']
azuriraj = True
if session['user_data']['kontaktTelefon'] != request.form['id_kontaktTelefon']:
fak.kontaktTelefon = request.form['id_kontaktTelefon']
azuriraj = True
if session['user_data']['webStranica'] != request.form['id_webStranica']:
fak.webStranica = request.form['id_webStranica']
azuriraj = True
if session['user_data']['visokoUciliste'] != request.form['id_visokoUciliste']:
fak.visokoUciliste_idVisokogUcilista = request.form['id_visokoUciliste']
azuriraj = True
if azuriraj:
#fa.zadnjaIzmjena = datetime.datetime.now()
baseSession.add(fak)
baseSession.commit()
#flash(("Podaci su uspješno ažurirani.").decode('utf-8'))
fak = baseSession.query(Fakultet).filter(Fakultet.idFakulteta == session['user_data']['idFakulteta']).first()
a = {"idFakulteta" : fak.idFakulteta, \
"naziv" : fak.naziv, \
"ulica" : fak.ulica, \
"kucniBroj" : fak.kucniBroj, \
"postanskiBroj" : fak.postanskiBroj, \
"mjesto" : fak.mjesto, \
"kontaktEmail" : fak.kontaktEmail, \
"kontaktTelefon" : fak.kontaktTelefon, \
"logo" : fak.logo, \
"webStranica" : fak.webStranica, \
"visokoUciliste" : fak.visokoUciliste_idVisokogUcilista, \
"email" : fak.email
}
session.pop('user_data', None)
session['user_data'] = dict(a)
result["status"] = "OK"
result["message"] = "Podaci su uspješno ažurirani."
try:
dnevnik = Dnevnik(session["user_data"]["idFakulteta"], "Fakultet", "Ažuriranje profila")
baseSession.add(dnevnik)
baseSession.commit()
except (BaseException, KeyError):
baseSession.rollback()
pass
else:
result["status"] = "INFO"
result["message"] = "Niste promjenili podatke."
except ValueError as e:
baseSession.rollback()
result["message"] = "Korak ex."
#flash(("Pogreška kod ažuriranja podataka!").decode('utf-8'))
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
def restAzuriranjeProfilaUcenika():
result = {
'status' : False,
'message' : "Neuspješno ažuriranje profila!"
}
try:
data = request.get_json(force=True)
idUcenika = data["idUcenika"]
ime = data["ime"]
prezime = data["prezime"]
email = data["email"]
lozinka = data["lozinka"]
ponovljenaLozinka = data["ponovljenaLozinka"]
if lozinka != ponovljenaLozinka:
result["message"] = "Lozinke se ne podudaraju!"
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
except KeyError:
result["message"] = "Pogrešan JSON!"
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
try:
ucenik = baseSession.query(Ucenik).filter(Ucenik.idUcenika == idUcenika).first()
if ucenik != None:
azuriraj = False
if ucenik.ime != ime:
ucenik.ime = ime
azuriraj = True
if ucenik.prezime != prezime:
ucenik.prezime = prezime
azuriraj = True
if ucenik.email != email:
tempUcenik = baseSession.query(Ucenik).filter(Ucenik.email == email).first()
if tempUcenik == None:
ucenik.email = email
azuriraj = True
else:
result["message"] = "Email adresa je zauzeta"
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
if ucenik.lozinka != lozinka:
ucenik.lozinka = lozinka
azuriraj = True
if azuriraj == True:
baseSession.add(ucenik)
baseSession.commit()
result["status"] = True
result["message"] = "Uspješno ste ažurirali profil."
try:
dnevnik = Dnevnik(idUcenika, "Ucenik", "Azuriranje profila")
baseSession.add(dnevnik)
baseSession.commit()
except (BaseException):
baseSession.rollback()
pass
else:
result["message"] = "Nepostojeći učenik!"
except (BaseException):
baseSession.rollback()
result["message"] = "Pogreška s bazom!"
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
def createAction():
''' Funkcija dohvaća sve fakultete koji su registrirani. Čisto za potrebe CRUD.'''
result = {
'Result' : "ERROR",
'Message' : "Neuspješno dodavanje zapisa!",
'Record' : []
}
try:
naziv = request.form["naziv"]
ulica = request.form["ulica"]
kucniBroj = request.form["kucniBroj"]
postanskiBroj = request.form["postanskiBroj"]
mjesto = request.form["mjesto"]
kontaktEmail = request.form["kontaktEmail"]
kontaktTelefon = request.form["kontaktTelefon"]
logo = request.form["logo"]
webStranica = request.form["webStranica"]
visokoUciliste = request.form["visokoUciliste"]
email = request.form["email"]
lozinka = request.form["lozinka"]
except (KeyError, TypeError):
result["Message"] = "Pogrešni podaci!"
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
try:
fakultet = baseSession.query(Fakultet).filter(Fakultet.email == email).first()
visokoUciliste = baseSession.query(VisokoUciliste).filter(VisokoUciliste.idVisokogUcilista == visokoUciliste).first()
if fakultet == None:
fakultet = Fakultet()
fakultet.naziv = naziv
fakultet.ulica = ulica
fakultet.kucniBroj = kucniBroj
fakultet.postanskiBroj = postanskiBroj
fakultet.mjesto = mjesto
fakultet.kontaktEmail = kontaktEmail
fakultet.kontaktTelefon = kontaktTelefon
fakultet.logo = logo
fakultet.webStranica = webStranica
fakultet.visokoUciliste = visokoUciliste
fakultet.email = email
fakultet.lozinka = hashlib.sha512(lozinka.encode()).hexdigest()
baseSession.add(fakultet)
baseSession.commit()
else:
result["Message"] = "Već postoji fakultet sa upisanom email adresom!"
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
dodaniFakultet = baseSession.query(Fakultet).filter(Fakultet.email == email).first()
if dodaniFakultet == None:
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
else:
a = {"idFakulteta" : dodaniFakultet.idFakulteta,
"naziv" : dodaniFakultet.naziv,
"ulica" : dodaniFakultet.ulica,
"kucniBroj" : dodaniFakultet.kucniBroj,
"postanskiBroj" : dodaniFakultet.postanskiBroj,
"mjesto" : dodaniFakultet.mjesto,
"kontaktEmail" : dodaniFakultet.kontaktEmail,
"kontaktTelefon" : dodaniFakultet.kontaktTelefon,
"logo" : dodaniFakultet.logo,
"webStranica" : dodaniFakultet.webStranica,
"visokoUciliste" : dodaniFakultet.visokoUciliste_idVisokogUcilista,
"email" : dodaniFakultet.email,
"lozinka" : dodaniFakultet.lozinka
}
result['Record'].append(a)
result['Result'] = "OK"
result['Message'] = "Successfull."
except (BaseException):
result["Message"] = "Pogreška s bazom!"
baseSession.rollback()
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
def dohvatiFakultetePoInteresima():
''' Funkcija dohvaća fakultete po prioritetima. Funkcija ne prima parametre već prihvaća POST HTTP request'''
result = {
'status' : False,
'vrijeme' : str(datetime.datetime.now()),
'poruka' : ""
}
data = request.get_json(force=True)
try:
listaInteresa = data["interesi"]
ucenikEmail = data["email"]
except (KeyError):
result["poruka"] = "Pogreška kod podataka!"
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
if len(listaInteresa) == 0:
result["poruka"] = "Niste poslali podatke!"
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
popis = []
try:
a = int(listaInteresa[0])
popis = listaInteresa
except ValueError:
temp = listaInteresa[1:-1].split(", ")
for i in temp:
popis.append(int(i))
try:
ucenik = baseSession.query(Ucenik).filter(Ucenik.email == ucenikEmail).first()
try:
dnevnik = Dnevnik(ucenik.idUcenika, "Ucenik", "Dohvat fakulteta po interesima")
baseSession.add(dnevnik)
baseSession.commit()
except (BaseException):
baseSession.rollback()
pass
except BaseException as e:
result["poruka"] = "Greška kod korisnika!"
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
try:
baseSession.query(JeZainteresiran).filter(JeZainteresiran.ucenik_idUcenika == ucenik.idUcenika).delete()
baseSession.commit()
for i in popis:
interes = baseSession.query(Interes).filter(Interes.idInteresa == i).first()
interesUcenika = JeZainteresiran()
interesUcenika.interes = interes
interesUcenika.ucenik = ucenik
baseSession.add(interesUcenika)
baseSession.commit()
except BaseException:
result["poruka"] = "Nepostojeći interesi!"
baseSession.rollback()
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
brojOdabranihInteresa = 0
try:
spremljeniInteresi = baseSession.query(JeZainteresiran).filter(JeZainteresiran.ucenik == ucenik)
baseSession.query(Pripada).filter(Pripada.ucenik_idUcenika == ucenik.idUcenika).delete()
baseSession.commit()
except (BaseException):
result["poruka"] = "Pogreška s bazom!"
baseSession.rollback()
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
try:
for inte in spremljeniInteresi:
brojOdabranihInteresa += 1
fakultetiPonuda = baseSession.query(PonudaInteresa).filter(PonudaInteresa.interes_idInteresa == inte.interes_idInteresa)
for fak in fakultetiPonuda:
prip = baseSession.query(Pripada).filter(and_(Pripada.fakultet_idFakulteta == fak.fakultet.idFakulteta, Pripada.ucenik_idUcenika == ucenik.idUcenika)).first()
if prip == None:
prip = Pripada()
prip.fakultet = fak.fakultet
prip.ucenik = ucenik
prip.brojHitova = 1
else:
prip.brojHitova += 1
baseSession.add(prip)
baseSession.commit()
except BaseException:
result["poruka"] = "Pogreška kod izračuna!"
baseSession.rollback()
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
try:
pripadaju = baseSession.query(Pripada).filter(Pripada.ucenik == ucenik)
for pripada in pripadaju:
pripada.postotak = pripada.brojHitova/brojOdabranihInteresa*100
baseSession.add(pripada)
baseSession.commit()
except BaseException:
result["poruka"] = "Poreška kod izračuna postotka!"
baseSession.rollback()
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
try:
pripadaju = baseSession.query(Pripada).filter(Pripada.ucenik == ucenik).order_by(Pripada.postotak.desc())
i = 1
for pripada in pripadaju:
pripada.prioritet = i
i += 1
baseSession.add(pripada)
baseSession.commit()
except BaseException:
result["poruka"] = "Pogreška kod izračuna prioriteta!"
baseSession.rollback()
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
try:
pripadaju = baseSession.query(Pripada).filter(Pripada.ucenik == ucenik).order_by(Pripada.prioritet.asc())
brZapisa = 0
result["podaci"] = []
for pripada in pripadaju:
brZapisa += 1
a = {
"nazivFakulteta" : pripada.fakultet.naziv,
"postotak" : pripada.postotak,
"url" : pripada.fakultet.webStranica
}
result["podaci"].append(a)
result["status"] = True
result["brojZapisa"] = brZapisa
except BaseException:
result["poruka"] = "Pogreška kod dohvata podataka!"
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')