path: root/kpov_judge/web/kpov_judge/kpov_judge.py

#!/usr/bin/env python

import flask
from flask import Flask, g, session, redirect, url_for, abort, render_template, flash, app, request
import pymongo
import json
import random
import settings
import datetime
import kpov_random_helpers
import traceback

app = Flask(__name__)
app.config.from_object(settings)

dummy_task = """
def task(neznano_ime_naloge):
    print "Ta naloga ne obstaja!"
    return {'odgovor': 'neznana naloga'}

def task_check(results, params):
    raise Exception("neznana naloga?")
    return "Manjka preverjalnik naloge (neznana naloga?)"

def gen_params(user_id, meta):
    return dict()

params_meta = {'neznano_ime_naloge': {'opis':'NEZNANA NALOGA', 'w': False}}
"""

@app.before_request
def before_request():
    g.db = pymongo.MongoClient(app.config['DB_HOST']).kpov
    try:
        user = app.config['USERNAME']
        password = app.config['PASSWORD']
        g.db.authenticate(user, password)
    except:
        #no auth or auth config?
        pass

@app.route('/')
def root():
    student_id = flask.app.request.environ.get('REMOTE_USER', 'Nobody')
    # env = flask.app.request.environ
    tasks = g.db.tasks.find(dict(), {'task_id':1})
    if tasks is not None:
        task_list = [i['task_id'] for i in tasks]
    else:
        task_list = []
    return render_template('index.html', student_id=student_id, tasks=task_list)

@app.route('/kpov_judge/')
def auth_greeting():
    student_id = flask.app.request.environ.get('REMOTE_USER', 'Nobody')
    return "To je past!" + str(flask.app.request.__dict__)

def results_post(task_id, results):
    student_id = flask.app.request.environ.get('REMOTE_USER', 'Nobody')
    db = g.db
    params = db.task_params.find_one({'task_id': task_id, 'student_id': student_id})
    if params is None:   
        params = dict()
    else:
        params = params['params']
    user_params = json.loads(flask.app.request.form['params'])
    meta = db.task_params_meta.find_one({'task_id': task_id})
    if meta is None:
        meta = dict()
    else:
        meta = meta['params']
    for param_name, param_meta in meta.iteritems():
        if param_meta.get('w', False) and param_name in user_params:
            params[param_name] = user_params[param_name] 
    task_check_source = db.task_checkers.find_one({'task_id':task_id})
    hints = []
    if task_check_source is None:
        task_check_source = dummy_checker
    else:
        task_check_source = task_check_source['source']
    try:
        task_check_code = compile(task_check_source, 'checker.py', 'exec')
        exec(task_check_code)
        res, hints = task_check(results, params)
    except Exception, e:
        hints += ["Checker crashed: " + str(e)]
        res = 0
        # flask.app.logger.error(str(e))
    if (type(res) is int and res > 0):
        res_status = 'OK'
    else:
        res_status = 'NOT OK'
    db.results.insert({'task_id': task_id, 'result': res, 'hints': hints, 'status': res_status,'student_id': student_id, 'response': results, 'time': datetime.datetime.now()})
    return {'result': res, 'hints': hints, 'status': res_status}

def results_dict(task_id):
    student_id = flask.app.request.environ.get('REMOTE_USER', 'Nobody')
    db = g.db
    try:
        entry = db.results.find_one(
            {'$query': {'task_id': task_id, 'student_id': student_id}, 
                '$orderby': {'status': -1}}, 
            {'result': 1, 'status': 1, 'hints': 1, '_id': 0})
        if entry is None:
            return {'result': 'Naloga ni bila nikdar ocenjena', 'status': 'NOT OK'}
        return entry
    except Exception, e:
        return {'Error': str(e)}
        # flask.app.logger.error(str(e))
    return {'result':"Mama! Zakaj si me zapustila? Sedaj se bom razstrelil."}

@app.route('/tasks/<task_id>/results.json', methods=['GET', 'POST'])
def results_json(task_id):
    if flask.app.request.method == 'POST':
        results_post(task_id, json.loads(flask.app.request.form['results']))
    return json.dumps(results_dict(task_id))

@app.route('/tasks/<task_id>/<lang>/results.html', methods=['GET'])
def results_html(task_id, lang):
    return render_template('results.html', results=results_dict(task_id))

def public_meta(db, task_id):
    shown = dict()
    try:
        meta = db.task_params_meta.find_one({'task_id': task_id})['params']
        for k, v in meta.iteritems():
            try:
                if v['public']:
                    shown[k] = v
            except:
                pass
    except:
        shown = dummy_meta
    return shown


@app.route('/tasks/<task_id>/task.py', methods=['GET'])
def task_source(task_id):
    db = g.db
    try:
        task_str = db.tasks.find_one({'task_id': task_id})['source']
    except:
        return dummy_task
    return task_str

@app.route('/tasks/<task_id>/task.html', methods=['GET', 'POST'])
def task_html(task_id):
    return render_template('task.html', task=task_source(task_id))

def get_params(task_id, student_id, db):
    try:
        meta = db.task_params_meta.find_one({'task_id': task_id})['params']
    except:
        return {'mama': 'ZAKVAJ?'}, {'mama':{'public': True}}
    params = db.task_params.find_one({'task_id': task_id, 'student_id': student_id})
    s = ""
    if params is None:
        try:
            gen_params_source = db.gen_params.find_one({'task_id':task_id})['source']
            gen_params_code = compile(gen_params_source, 'generator.py', 'exec')
            exec(gen_params_code)
            params = gen_params(student_id, meta)
            db.task_params.update({'task_id':task_id, 'student_id':student_id},
                {'$set': {'params': params}}, upsert=True)
            params = gen_params(student_id, meta)
            for computer in db.computers_meta.find({'task_id': task_id}):
                try:
                    name = computer.pop('name')
                    del computer['_id']
                    del computer['task_id']
                except:
                    pass
                db.student_computers.update({'task_id': task_id, 'student_id': student_id, 'name': name},
                    {'$set': computer}, upsert=True)
        except Exception, e:
            meta = {'crash':{'public': True}}
            params = {'crash': "Parameter creator crashed or missing:\n{}".format(
                traceback.format_exc())}
    else:
        params = params['params']
    return params, meta
 
@app.route('/tasks/<task_id>/', methods = ['GET'])
def task_lang_redirect(task_id):
    return redirect(url_for('task_greeting', task_id = task_id, 
        lang=app.config['DEFAULT_LANG']))

@app.route('/tasks/<task_id>/<lang>/howto/', methods = ['GET'])
def task_howto(task_id, lang):
    db = g.db
    return db.howtos.find({'task_id': task_id, 'lang':lang})[0].get('text', '')

@app.route('/tasks/<task_id>/<lang>/images/<fname>', methods = ['GET'])
def task_image(task_id, lang, fname):
    db = g.db
    return db.howto_images.find({'task_id': task_id, 'fname':fname})[0].get('data', '')

@app.route('/tasks/<task_id>/<lang>/', methods = ['GET'])
def task_greeting(task_id, lang):
    student_id = flask.app.request.environ.get('REMOTE_USER', 'Nobody')
    db = g.db
    # generate the parameters as soon as the student visits
    params, meta = get_params(task_id, student_id, db)
    try:
        instructions = db.task_instructions.find({'task_id': task_id})[0]
        instructions = instructions.get(lang,
            app.config['DEFAULT_LANG'])
    except:
        try:
            instructions = instructions.values()[0]
        except Exception, e:
            instructions = str(e)
    try:
        public_params = dict()
        for k, v in meta.iteritems():
            if v.get('public', False):
                public_params[k] = params.get(k, "???")
        instructions = instructions.format(**public_params)
    except Exception, e:
        instructions = str(e)
    computer_list = db.student_computers.find({'task_id':task_id, 'student_id': student_id})
    if request.args.get('narediStack', 'false') == 'true':
      #db.student_tasks.update({'task_id':task_id, 'student_id': student_id}, {'$set': {'create_openstack': True}}, upsert = True)
        openstackCreated = False # Spremeni na True, ko odkomentiras zgornjo vrstico.
    else:
        if db.student_tasks.find({'task_id':task_id, 'student_id': student_id, 'openstack_created': True}).count() > 0:
            openstackCreated = True
        elif db.student_tasks.find({'task_id':task_id, 'student_id': student_id, 'create_openstack': True}).count() > 0:
            openstackCreated = True
        else:
            openstackCreated = False
    return render_template('task_greeting.html', computers = computer_list, lang=lang, openstack = openstackCreated, instructions=instructions)

@app.route('/tasks/<task_id>/params.json', methods=['GET', 'POST'])
def params_json(task_id):
    student_id = flask.app.request.environ.get('REMOTE_USER', 'Nobody')
    db = g.db 
    params, meta = get_params(task_id, student_id, db)
    shown_params = dict()
    for name, param in params.iteritems():
        if meta.get(name, {'public': False})['public']:
            shown_params[name] = param
    if flask.app.request.method == 'POST':
        shown_params = dict()
        try:
            new_params = json.loads(flask.app.request.form['params'])
        except:
            new_params = dict()
        for name in params.iteritems():
            if meta.get(name, {'w': False})['w'] and k in new_params:
                params[name] = new_params[name]
            if meta.get(name, {'public': False})['public']:
                shown_params[name] = params[name]
        db.task_params.update({'task_id':task_id, 'student_id':student_id}, {'$set': {'params': params}}, upsert=True)
    return json.dumps(shown_params)

@app.route('/tasks/<task_id>/<lang>/params.html', methods=['GET', 'POST'])
def params_html(task_id, lang):
    student_id = flask.app.request.environ.get('REMOTE_USER', 'Nobody')
    db = g.db 
    params, meta = get_params(task_id, student_id, db)
    shown_params = dict()
    for name, meta_param in meta.iteritems():
        if meta_param.get('public', False):
            shown_params[name] = params.get(name, '')
    if flask.app.request.method == 'POST':
        form = flask.app.request.form
        new_params = dict()
        for k, v in meta.iteritems():
            if v.get('w', False):
                params[k] = flask.app.request.form[k]
            if v.get('public', False):
                shown_params[name] = params.get(name, '')
        db.task_params.update({'task_id':task_id, 'student_id':student_id}, {'$set': {'params': params}}, upsert=True)
    return render_template('params.html', params=shown_params, params_meta = meta)


@app.route('/tasks/<task_id>/params_meta.json', methods=['GET'])
def params_meta(task_id):
   db = g.db
   return json.dumps(public_meta(db, task_id))

@app.route('/static/<path:filename>')
def send_foo(filename):
    return send_from_directory(app.config.STATIC_FILES, filename)

if __name__ == '__main__':
    app.run(host='0.0.0.0')