~azzar1/unity/add-show-desktop-key

# IVLE

# Copyright (C) 2007-2008 The University of Melbourne

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

# App: tutorial

# Author: Matt Giuca

# Date: 25/1/2008

# Tutorial application.

# Displays tutorial content with editable problems, allowing students to test

# and submit their solutions to problems and have them auto-tested.

# URL syntax

# All path segments are optional (omitted path segments will show menus).

# The first path segment is the subject code.

# The second path segment is the worksheet name.

import os

import cgi

import urllib

import re

from xml.dom import minidom

import cjson

from common import util

import conf

import plugins.console

THIS_APP = "tutorial"

# Regex for valid identifiers (subject/worksheet names)

re_ident = re.compile("[0-9A-Za-z_]+")

class Worksheet:

    def __init__(self, id, name):

        self.id = id

        self.name = name

    def __repr__(self):

        return ("Worksheet(id=" + repr(self.id) + ", name=" + repr(self.name)

                + ")")

def make_tutorial_path(subject=None, worksheet=None):

    """Creates an absolute (site-relative) path to a tutorial sheet.

    Subject or worksheet can be None.

    Ensures that top-level or subject-level URLs end in a '/', because they

    are represented as directories.

    """

    if subject is None:

        return util.make_path(THIS_APP + '/')

    else:

        if worksheet is None:

            return util.make_path(os.path.join(THIS_APP, subject + '/'))

        else:

            return util.make_path(os.path.join(THIS_APP, subject, worksheet))

def handle(req):

    """Handler for the Tutorial application."""

    # Set request attributes

    req.content_type = "text/html"

    req.scripts = [

        "media/common/util.js",

        "media/common/json2.js",

        "media/tutorial/tutorial.js",

    ]

    req.styles = [

        "media/tutorial/tutorial.css",

    ]

    # Let the console plugin insert its own styles and scripts

    plugins.console.insert_scripts_styles(req.scripts, req.styles)

    # Note: Don't print write_html_head_foot just yet

    # If we encounter errors later we do not want this

    path_segs = req.path.split(os.sep)

    subject = None

    worksheet = None

    if len(path_segs) > 2:

        req.throw_error(req.HTTP_NOT_FOUND)

    elif len(req.path) > 0:

        subject = path_segs[0]

        if len(path_segs) == 2:

            worksheet = path_segs[1]

    if subject == None:

        handle_toplevel_menu(req)

    elif worksheet == None:

        handle_subject_menu(req, subject)

    else:

        handle_worksheet(req, subject, worksheet)

        plugins.console.present(req, windowpane=True)

def handle_toplevel_menu(req):

    # This is represented as a directory. Redirect and add a slash if it is

    # missing.

    if req.uri[-1] != os.sep:

        req.throw_redirect(make_tutorial_path())

    req.write_html_head_foot = True

    req.write('<div id="ivle_padding">\n')

    req.write("<h1>IVLE Tutorials</h1>\n")

    req.write("""<p>Welcome to the IVLE tutorial system.

  Please select a subject from the list below to take a tutorial problem sheet

  for that subject.</p>\n""")

    # Get list of subjects

    # TODO: Fetch from DB. For now, just get directory listing

    subjects = os.listdir(conf.subjects_base)

    subjects.sort()

    req.write("<h2>Subjects</h2>\n<ul>\n")

    for subject in subjects:

        req.write('  <li><a href="%s">%s</a></li>\n'

            % (urllib.quote(subject) + '/', cgi.escape(subject)))

    req.write("</ul>\n")

    req.write("</div>\n")   # tutorialbody

def is_valid_subjname(subject):

    m = re_ident.match(subject)

    return m is not None and m.end() == len(subject)

def handle_subject_menu(req, subject):

    # This is represented as a directory. Redirect and add a slash if it is

    # missing.

    if req.uri[-1] != os.sep:

        req.throw_redirect(make_tutorial_path(subject))

    # Subject names must be valid identifiers

    if not is_valid_subjname(subject):

        req.throw_error(req.HTTP_NOT_FOUND)

    # Parse the subject description file

    # The subject directory must have a file "subject.xml" in it,

    # or it does not exist (404 error).

    try:

        subjectfile = open(os.path.join(conf.subjects_base, subject,

            "subject.xml"))

    except:

        req.throw_error(req.HTTP_NOT_FOUND)

    # Read in data about the subject

    subjectdom = minidom.parse(subjectfile)

    subjectfile.close()

    # TEMP: All of this is for a temporary XML format, which will later

    # change.

    worksheetsdom = subjectdom.documentElement

    worksheets = []     # List of string IDs

    for worksheetdom in worksheetsdom.childNodes:

        if worksheetdom.nodeType == worksheetdom.ELEMENT_NODE:

            worksheet = Worksheet(worksheetdom.getAttribute("id"),

                worksheetdom.getAttribute("name"))

            worksheets.append(worksheet)

    # Now all the errors are out the way, we can begin writing

    req.title = "Tutorial - %s" % subject

    req.write_html_head_foot = True

    req.write('<div id="ivle_padding">\n')

    req.write("<h1>IVLE Tutorials - %s</h1>\n" % cgi.escape(subject))

    req.write("<h2>Worksheets</h2>\n<ul>\n")

    for worksheet in worksheets:

        req.write('  <li><a href="%s">%s</a></li>\n'

            % (urllib.quote(worksheet.id), cgi.escape(worksheet.name)))

    req.write("</ul>\n")

    req.write("</div>\n")   # tutorialbody

def handle_worksheet(req, subject, worksheet):

    # Subject and worksheet names must be valid identifiers

    if not is_valid_subjname(subject) or not is_valid_subjname(worksheet):

        req.throw_error(req.HTTP_NOT_FOUND)

    # Read in worksheet data

    try:

        worksheetfile = open(os.path.join(conf.subjects_base, subject,

            worksheet + ".xml"))

    except:

        req.throw_error(req.HTTP_NOT_FOUND)

    worksheetdom = minidom.parse(worksheetfile)

    worksheetfile.close()

    # TEMP: All of this is for a temporary XML format, which will later

    # change.

    worksheetdom = worksheetdom.documentElement

    if worksheetdom.tagName != "worksheet":

        # TODO: Nicer error message, to help authors

        req.throw_error(req.HTTP_INTERNAL_SERVER_ERROR)

    worksheetname = worksheetdom.getAttribute("name")

    # Now all the errors are out the way, we can begin writing

    req.title = "Tutorial - %s" % worksheetname

    req.write_html_head_foot = True

    req.write('<div id="ivle_padding">\n')

    req.write("<h1>IVLE Tutorials - %s</h1>\n<h2>%s</h2>\n"

        % (cgi.escape(subject), cgi.escape(worksheetname)))

    # Write each element

    problemid = 0

    for node in worksheetdom.childNodes:

        problemid = present_worksheet_node(req, node, problemid)

    req.write("</div>\n")   # tutorialbody

def present_worksheet_node(req, node, problemid):

    """Given a node of a worksheet XML document, writes it out to the

    request. This recursively searches for "problem" elements and handles

    those specially (presenting their XML problem spec and input box), and

    just dumps the other elements as regular HTML.

    problemid is the ID to use for the first problem.

    Returns the new problemid after all the problems have been written

    (since we need unique IDs for each problem).

    """

    if node.nodeType == node.ELEMENT_NODE:

        if node.tagName == "problem":

            present_problem(req, node.getAttribute("src"), problemid)

            problemid += 1

        else:

            # Some other element. Write out its head and foot, and recurse.

            req.write("<" + node.tagName)

            # Attributes

            attrs = map(lambda (k,v): '%s="%s"'

                    % (cgi.escape(k), cgi.escape(v)), node.attributes.items())

            if len(attrs) > 0:

                req.write(" " + ' '.join(attrs))

            req.write(">")

            for childnode in node.childNodes:

                problemid = present_worksheet_node(req, childnode, problemid)

            req.write("</" + node.tagName + ">")

    else:

        # No need to recurse, so just print this node's contents

        req.write(node.toxml())

    return problemid

def innerXML(elem):

    """Given an element, returns its children as XML strings concatenated

    together."""

    s = ""

    for child in elem.childNodes:

        s += child.toxml()

    return s

def getTextData(element):

    """ Get the text and cdata inside an element

    Leading and trailing whitespace are stripped

    """

    data = ''

    for child in element.childNodes:

        if child.nodeType == child.CDATA_SECTION_NODE:

            data += child.data

        if child.nodeType == child.TEXT_NODE:

            data += child.data

    return data.strip()

def present_problem(req, problemsrc, problemid):

    """Open a problem file, and write out the problem to the request in HTML.

    problemsrc: "src" of the problem file. A path relative to the top-level

        problems base directory, as configured in conf.

    """

    req.write('<div class="tuteproblem" id="problem%d">\n'

        % problemid)

    # First normalise the path

    problemsrc = os.path.normpath(problemsrc)

    # Now if it begins with ".." or separator, then it's illegal

    if problemsrc.startswith("..") or problemsrc.startswith(os.sep):

        problemfile = None

    else:

        problemfile = os.path.join(conf.problems_base, problemsrc)

    try:

        problemfile = open(problemfile)

    except (TypeError, IOError):    # TypeError if problemfile == None

        req.write("<p><b>Server Error</b>: "

            + "Problem file could not be opened.</p>\n")

        req.write("</div>\n")

        return

    # Read problem file and present the problem

    # Note: We do not use the testing framework because it does a lot more

    # work than we need. We just need to get the problem name and a few other

    # fields from the XML.

    problemdom = minidom.parse(problemfile)

    problemfile.close()

    problemdom = problemdom.documentElement

    if problemdom.tagName != "problem":

        # TODO: Nicer error message, to help authors

        req.throw_error(req.HTTP_INTERNAL_SERVER_ERROR)

    problemname = problemdom.getAttribute("name")

    # Look for some other fields we need, which are elements:

    # - desc

    # - partial

    problemdesc = None

    problempartial= ""

    for elem in problemdom.childNodes:

        if elem.nodeType == elem.ELEMENT_NODE:

            if elem.tagName == "desc":

                problemdesc = innerXML(elem).strip()

            if elem.tagName == "partial":

                problempartial= getTextData(elem) + '\n'

    # Print this problem out to HTML 

    req.write("<p><b>Exercise:</b> %s</p>\n" % problemname)

    if problemdesc is not None:

        req.write("<div>%s</div>\n" % problemdesc)

    req.write('<textarea class="problembox" cols="80" rows="12">%s</textarea>'

            % problempartial)

    filename = cgi.escape(cjson.encode(problemsrc), quote=True)

    req.write("""\n<div class="problembuttons">

  <input type="button" value="Run"

    onclick="runproblem("problem%d", %s)" />

  <input type="button" value="Submit"

    onclick="submitproblem("problem%d", %s)" />

</div>

<div class="testoutput">

</div>

""" % (problemid, filename, problemid, filename))

    req.write("</div>\n")