コード例 #1
0
ファイル: views.py プロジェクト: isharacomix/8bitmooc
def view_playground(request):
    me = Student.from_request(request)

    # Compile the code and save it in the database.
    good = False
    pattern = None
    name = ""
    if request.method == "POST":
        try:
            old = CodeSubmission.objects.filter(student=me, challenge=None).order_by("-timestamp")[0]
        except:
            old = None

        # Get code from the POST request.
        name = slugify(request.POST.get("name") if request.POST.get("name") else "untitled")[:32]
        code = request.POST.get("code") if request.POST.get("code") else ""
        try:
            pattern = Pattern.objects.get(name=str(request.POST.get("pattern")))
        except:
            pattern = None

        # Save this in the database whether it compiles or not.
        CR = CodeSubmission()
        CR.name = name
        CR.student = me
        CR.code = code
        CR.pattern = pattern
        CR.save()

        good = assembler.assemble_and_store(request, name, code, pattern)
        publish = False
        if "publish" in request.POST and me and not me.banned and good:
            publish = True

        # Convert the last code submission into a diff image, but only save it
        # if the diff is actually smaller than the full code.
        if old and old.published == 0:
            old.parent = CR
            old_code = old.code
            old.code = ""
            for d in difflib.unified_diff(CR.code.splitlines(True), old_code.splitlines(True)):
                old.code += d
            if len(old.code) < len(old_code):
                old.save()

        # Redirect based on which button was clicked.
        if publish:
            CR.published = len(CodeSubmission.objects.filter(published__gt=0)) + 1
            CR.save()
            return redirect("playground")
        elif "download" in request.POST and good:
            return redirect("rom")
        else:
            return redirect("playground")

    # Render the page.
    code = ""
    if "rom_code" in request.session:
        code = request.session["rom_code"]
        pattern = request.session.get("rom_pattern")
        name = str(request.session.get("rom_name"))
    elif me:
        subs = CodeSubmission.objects.filter(student=me, challenge=None).order_by("-timestamp")
        if len(subs) > 0:
            code = subs[0].code
            name = subs[0].name

    # Get recently published games.
    recent = CodeSubmission.objects.filter(published__gt=0).order_by("-timestamp")
    return render(
        request,
        "playground.html",
        {
            "name": name,
            "pattern": pattern,
            "patterns": Pattern.objects.all(),
            "code": code,
            "recently_published": recent[:25],
            "alerts": request.session.pop("alerts", []),
        },
    )
コード例 #2
0
ファイル: views.py プロジェクト: isharacomix/8bitmooc
def view_challenge(request, name):
    me = Student.from_request(request)
    
    # First, try to get the challenge.
    try: challenge = Challenge.objects.get(slug=name)
    except exceptions.ObjectDoesNotExist: raise Http404()
        
    # Find the records for this submission. We need them whether we are viewing
    # or processing.
    my_size, my_speed = 0x10000, 0x10000
    best_size, best_speed = 0x1000000, 0x1000000
    completed = False
    records = CodeSubmission.objects.filter(challenge=challenge, is_correct=True).order_by('rom_size')
    if len(records) > 0:
        best_size = records[0].rom_size
        records = records.order_by('runtime')
        best_speed = records[0].runtime
    records = records.filter(student=me).order_by('rom_size')
    if len(records) > 0:
        my_size = records[0].rom_size
        records = records.order_by('runtime')
        my_speed = records[0].runtime
        completed = True
        
    # If it was a POST request, then we'll take care of that now. This takes
    # care of the side-effects and creates the challenge responses that will be
    # handled below.
    code = ""
    if request.method == "POST":
        try: old = CodeSubmission.objects.filter(student=me, challenge=challenge).order_by('-timestamp')[0]
        except: old = None
        
        code = request.POST.get("code") if "code" in request.POST else ""
        CR = CodeSubmission()
        CR.student = me
        CR.challenge = challenge
        CR.code = code
        CR.is_correct = False if challenge.autograde else None
        CR.save()
        
        # Convert the last code submission into a diff image, but only save it
        # if the diff is actually smaller than the full code.
        if old and len(SOS.objects.filter(submission=old)) == 0:
            old.parent = CR
            old_code = old.code
            old.code = ""
            for d in difflib.unified_diff( CR.code.splitlines(True), old_code.splitlines(True)):
                old.code += d
            if len(old.code) < len(old_code):
                old.save()
        
        # Only try to autograde if the program compiles.
        compiles = assembler.assemble_and_store(request, "challenge%s"%challenge.slug,
                   code, challenge.pattern, challenge.preamble, challenge.postamble)
        if compiles and challenge.autograde:
            completed = me in challenge.completed_by.all()
            results = autograde.grade( challenge, me, code, completed )
            
            # Save its correctness in the database.
            CR.is_correct = True if results else False
            if results: CR.rom_size, CR.runtime = results
            CR.save()
            
            # Award victory if the program is correct.
            if results and not completed:
                challenge.completed_by.add(me)
                challenge.save()
                request.session['alerts'].append(('alert-success',
                                                  '''Congratulations! You completed
                                                  this challenge! Can you make it
                                                  more efficient?'''))
                LogEntry.log(request, "Completed %s"%challenge.slug)
            elif results:
                request.session['alerts'].append(('alert-success',
                                                  '''This solution was %d bytes in
                                                  size and executed %d instructions.'''%results))
                LogEntry.log(request, "%s: %d, %d"%(challenge.slug,results[0],results[1]))
        
        # Is there an SOS involved?
        if "sos" in request.POST and "help" in request.POST:
            for s in SOS.objects.filter(challenge=challenge, student=me):
                s.active = False
                s.save()
        
            s = SOS()
            s.challenge = challenge
            s.submission = CR
            s.content = request.POST["help"]
            s.student = me
            s.save()
        
        # Handle the redirect.
        if "download" in request.POST and compiles:
            return redirect("rom")
        return redirect("challenge", challenge.slug)
    
    # Load the latest submission code to display it on the screen.
    subs = CodeSubmission.objects.filter(student=me, challenge=challenge).order_by('-timestamp')
    if len(subs) > 0: code = subs[0].code
    
    # Try to load up the best submissions by everyone.
    return render(request, "challenge.html", {'challenge': challenge,
                                              'alerts': request.session.pop('alerts', []),
                                              'code': code,
                                              'my_size': my_size,
                                              'my_speed': my_speed,
                                              'best_size': best_size,
                                              'best_speed': best_speed,
                                              'completed': completed,
                                              'feedback': SOS.objects.filter(challenge=challenge, student=me) } )