Esempio n. 1
0
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")
Esempio n. 2
0
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")
Esempio n. 3
0
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') 
Esempio n. 4
0
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')
Esempio n. 5
0
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')
Esempio n. 6
0
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')
Esempio n. 7
0
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')
Esempio n. 8
0
def restOdjava():
    try:
        dnevnik = Dnevnik(session["user_data"]["idFakulteta"], "Fakultet", "Odjava sa sustava")
        baseSession.add(dnevnik)
        baseSession.commit()
    except (BaseException, KeyError):
        baseSession.rollback()
        pass
    session.pop('user_data', None)
    result = {
        "status" :  True,
        "message" : "Uspješno ste odjavljeni!"
    }
    
    return Response(json.dumps(result), mimetype='application/json; charset=UTF-8')
Esempio n. 9
0
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")
Esempio n. 10
0
def adminObavijesti():
    if request.method == "GET":
        return render_template("admin_objave.html")
    elif request.method == "POST":
        try:
            poruka = Poruka()
            poruka.naslov = request.form["naslov"]
            poruka.tekst = request.form["tekst"]
            poruka.vrijeme = datetime.now()
            baseSession.add(poruka)
            baseSession.commit()
            return render_template("admin_objave.html")
        except(BaseException):
            redirect("/adminObavijesti")
    else:
        redirect("/")
Esempio n. 11
0
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")
Esempio n. 12
0
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)
Esempio n. 13
0
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")
Esempio n. 14
0
def registracija():
    form = RegistrationForm(csrf_enabled = True)
    if request.method == 'POST':
        res = json.loads(Fakulteti.provjeriDostupnostEmaila(request.form['email'], False))
        if res['status'] == True:
            try:
                aKod = hashlib.sha224((request.form['email']+"o/6sfasSASD!#54!)w").encode()).hexdigest()
                noviFakultet = Fakultet(email=request.form['email'], lozinka = hashlib.sha512((request.form['password']).encode()).hexdigest(), \
                     aktiviran = False, blokiran = False, aktivacijskiKod=aKod)
                baseSession.add(noviFakultet)
                mail = Mail()
                msg = Message()
                msg.sender = ('Keglja inc. - StuFacJoint', '*****@*****.**')
                msg.subject = "Dobrodošli na StuFacJoint"
                msg.recipients = [request.form['email']]
                msg.body = 'Poveznica za aktivaciju: ' + url_for('index', _external=True) + 'rest/9f5a0e9de8ed801c983bf3019ca40c54f08b4a03/' + aKod
                msg.html = '''
                    <html>
                        <head>
                            <title> Potvrda elektroničke pošte </title>
                        </head>
                        <body>
                            <h1> Dobrodošli na StuFacJoint </h1>
                            <p> Kako bi koristili usluge molimo Vas da potvrdite adresu elektroničke pošte. </p>
                            <p> Aktivaciju možete izvršiti klikom na <a href='%s'>AKTIVIRAJ StuFacJoint</a> </p>
                        </body>
                    </html>
                ''' % (url_for('index', _external=True) + 'rest/9f5a0e9de8ed801c983bf3019ca40c54f08b4a03/' + aKod)
                mail.send(msg)

                baseSession.commit()
                return redirect('/login')
            except ValueError:
                baseSession.rollback()
                flash(("Greška kod registracije!").decode('utf-8'))
        else:
            flash((res['message']).decode('utf-8'))
    return render_template('registracija.html', form = form)
Esempio n. 15
0
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')
Esempio n. 16
0
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')
Esempio n. 17
0
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")
Esempio n. 18
0
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')
Esempio n. 19
0
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')
Esempio n. 20
0
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')
Esempio n. 21
0
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')