# Python imports
import doctest
import logging
import os
import traceback
import random
import StringIO
import sys
import json
from django.contrib.auth.models import User
from testappproj.testapp.models import *
from django.http import HttpResponse
from django import http
from django import shortcuts
from django.template import Context ,RequestContext
from django.template.loader import get_template
# Local imports
from forms import *
import models
from helpers import bulkuploader as pykataupload
from datetime import date
from django.contrib.auth.decorators import permission_required
from models import Problem
from django.contrib.auth.decorators import login_required
from models import Score
import time
import sandbox
import re
from django.utils.datastructures import MultiValueDictKeyError
def respond(request, user,template, params=None):
"""Helper to render a response, passing standard stuff to the response.
Args:
request: The request object.
user: The User object representing the current user; or None if nobody
is logged in.
template: The template name; '.html' is appended automatically.
params: A dict giving the template parameters; modified in-place.
Returns:
Whatever render_to_response(template, params) returns.
Raises:
Whatever render_to_response(template, params) raises.
"""
if params is None:
params = {}
if user:
params['user'] = user
params['sign_out'] = 1
# params['is_admin'] = (users.is_current_user_admin())
else:
params['sign_in'] = 1
# if not template.endswith('.html'):
template += '.html'
return shortcuts.render_to_response(template, params)
def import_check(user_code):
no_imports=len(re.findall('import',user_code))
if (no_imports >= 1):
return True
return False
def plot_change_code(user_code):
return user_code
def check_examination_done(f):
def wrap(request, *args, **kwargs):
#this check the session if userid key exist, if not it will redirect to login page
if unicode(request.user)==unicode('amit'):
print "hello what the hell"
return f(request, *args, **kwargs)
user= Test_User.objects.get(user=request.user)
if user.exam_done==True:
return HttpResponse("You have given the exam before")
return f(request, *args, **kwargs)
return wrap
def execute_plotting_test_cases(user_code , solution_image,problem_id , username):
print user_code
print "solution"+solution_image
image_name = username+'_'+str(problem_id)+'_'+time.time()
code="""from pylab import *
%s
show()"""%user_code
solved=False
# create file-like string to capture output
codeOut = StringIO.StringIO()
codeErr = StringIO.StringIO()
# capture output and errors
sys.stdout = codeOut
sys.stderr = codeErr
sandbox.execute(code)
# restore stdout and stderr
sys.stdout = sys.__stdout__
sys.stderr = sys.__stderr__
s = codeOut.getvalue()
s=unicode(s)
print s.strip()
print solution.strip()
if solution.strip() == s.strip():
solved =True
errors=codeErr.getvalue()
codeOut.close()
codeErr.close()
return solved,errors
def execute_test_cases(code , solution):
solved=False
if import_check(code):
print "entered"
return solved,None,True
# create file-like string to capture output
codeOut = StringIO.StringIO()
codeErr = StringIO.StringIO()
# capture output and errors
sys.stdout = codeOut
sys.stderr = codeErr
sandbox.execute(code)
# restore stdout and stderr
sys.stdout = sys.__stdout__
sys.stderr = sys.__stderr__
s = codeOut.getvalue()
s=unicode(s)
print s.strip()
print solution.strip()
if solution.strip() == s.strip():
solved =True
errors=codeErr.getvalue()
codeOut.close()
codeErr.close()
return solved,errors,False
def complete(request):
print request.user
user= Test_User.objects.get(user=request.user)
user.exam_done=True
user.save()
return respond(request, request.user ,'submit')
def index(request):
""" need to change user in the django.contrib way"""
user = request.user
return respond(request , user, 'index')
@login_required(function=None, redirect_field_name='next')
@check_examination_done
def problems(request, category=None):
user = request.user
entries=[]
all_sessions=set([element.session for element in Problem.objects.all()])
#get problems to solve from each session.
for session in all_sessions:
get_problem=random.Random().choice(Problem.objects.filter(session=session))
e = dict(problem=get_problem.description,
username=user.username,
problem_id=get_problem.id,
session =get_problem.session
)
entries.append(e)
return respond(request, user, 'problems',{'entries' : entries } )
@login_required(function=None, redirect_field_name='next')
def code(request, problem_id):
# print problem_id
problem = Problem.objects.get(id=int(problem_id))
if problem is None:
return http.HttpResponseNotFound('No such problem.')
print problem.id
return respond(request, request.user ,'code' ,{'problem' : problem } )
def run(request):
user = request.user
print user
problem_id = request.POST.get('problem_id')
if problem_id:
problem = Problem.objects.get(id=int(problem_id))
if problem is None:
return http.HttpResponse('There is no problem like this are you sure you solved it')
user_code = request.POST.get('user_code')
if user_code == '':
return http.HttpResponse('No solution')
user_code = user_code.replace('\r\n', '\n')
user_code += '\n\n'
errors = ''
solved,errors,import_test= execute_test_cases(user_code,problem.solution)
if import_test==True:
return http.HttpResponse("DO NOT try to import or your exam and account will invalidated")
if solved==True:
#user is answering his first question
try:
print user.id
score_for_user= Score.objects.get(user=user)
score_for_user.total_credits+=problem.credit
score_for_user.save()
# user has answered questions previously
except Score.DoesNotExist:
score_new_user=user.id
score_total_credits=problem.credit
score=Score(user_id=user.id,total_credits=score_total_credits)
score.save()
else:
http.HttpResponse('Wrong Answer')
return http.HttpResponse("Right Answer")
@permission_required('testapp.add_problem' , login_url="/code/1234")
def new_edit(request, problem_id=None, internal=False):
# internal indicates that it is being called internally by uploader
user = request.user
if user.is_anonymous() :
return http.HttpResponseForbidden('You must be an signed in to create edit a problem.')
if problem_id is None:
creating_new = True
else:
creating_new = False
if request.method == 'POST':
form = ProblemForm(request.POST, request.FILES)
else:
form = ProblemForm()
if not request.POST:
return respond(request, user, 'new_edit_problem', {'form':form, 'problem':None, 'creating':creating_new })
if form.is_valid():
try:
description = form.cleaned_data['Description']
problem_type=form.cleaned_data['Problem_type']
solution=form.cleaned_data['Solution']
session=form.cleaned_data['Session']
credit=form.cleaned_data['Credit']
# solution_image=form.cleaned_data['Solution_Image']
solution_image=request.FILES['Solution_Image']
author = user.username
created = date.today()
modified=date.today()
# print request.FILES
# print "this is solution"+solution
# print "this is solution_image"+solution_image
problem=Problem(description=description,problem_type=problem_type,solution_image=solution_image,session=session,author=author,created=created,modified=modified,credit=credit)
except MultiValueDictKeyError:
description = form.cleaned_data['Description']
problem_type=form.cleaned_data['Problem_type']
solution=form.cleaned_data['Solution']
session=form.cleaned_data['Session']
credit=form.cleaned_data['Credit']
# solution_image=form.cleaned_data['Solution_Image']
author = user.username
created = date.today()
modified=date.today()
problem=Problem(description=description,problem_type=problem_type,solution=solution,session=session,author=author,created=created,modified=modified,credit=credit)
problem.save()
print "saved"
else:
print "form is valid"
print form.errors
# print form.errors
# except ValueError, err:
# errors['__all__'] = unicode(err)
if form.errors:
print "new world"
return respond(request, user, 'new_edit_problem',
{'form': form, 'problem':problem, 'creating':creating_new,'error':errors})
# if creating_new:
# # if internal:
# # if len(request.POST['user_id'])>0:
# # logging.info(request.POST)
# # problem.author = users.User(request.POST['user_id'])
# # else:
# # problem.author = user
# # else:
# l = []
# for x in problem.categories:
# l.extend(x.split())
# problem.categories = l
# problem.put()
if internal:
return ('success','success')
return http.HttpResponseRedirect('/problems')