root/trunk/ExerciseMaterial.py

# Copyright 2006 by the LeMill Team (see AUTHORS)
#
# This file is part of LeMill.
#
# LeMill 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.
#
# LeMill 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 LeMill; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1

from AccessControl import ClassSecurityInfo, getSecurityManager
from Products.Archetypes.public import *
from Products.CMFCore.utils import getToolByName
from config import PROJECTNAME, MODIFY_CONTENT, VIEW, to_unicode
from FieldsWidgets import ChapterField, ExerciseWidget
from Schemata import no_description, material_schema, community_editing_schema, draft_schema
from Material import Material
from permissions import MODIFY_CONTENT
from random import shuffle
from Products.LeMill import LeMillMessageFactory as _
from Products.MailHost.MailHost import MailHostError
import re

exercise_schema = Schema((
   ChapterField('bodyText',
        accessor="getBodyText",
        edit_accessor = 'getRawBodyText',
        mutator = "setBodyText",
        index='ZCTextIndex',
        index_method = 'getOnlyText',
        copied_in_translation=True,
        searchable = True,
        deleteEmptyChapters = False,
        allowable_content_types = ['text/html',],
        allow_file_upload = False,
        default_output_type = 'text/x-html-captioned',
        default_content_type = 'text/html',
        default=[{'type':'text_block', 'text':''}],
        widget=ExerciseWidget(label = "Body text",
            label_msgid = "label_bodytext",
            i18n_domain = "lemill",
            ),
    ),
)) 

schema = material_schema + community_editing_schema + no_description + draft_schema + exercise_schema
schema = schema.copy()
schema.moveField('rights', pos='bottom')
schema.moveField('language', after='bodyText')
schema['title'].required = True
schema.moveField('hideDrafts', before='rights')

blanks= re.compile("(\{.*?\})")

class ExerciseMaterial(Material):
    """Exercise page"""
    schema = schema
    meta_type = "ExerciseMaterial"
    archetype_name = "ExerciseMaterial"
    default_location = 'content/exercises'
    security = ClassSecurityInfo()
    security.declareObjectPublic()
    aliases = {
        '(Default)' : 'fullscreen_view',
        'view'      : 'base_view',
        'edit'      : 'base_edit',
        'feedback'  : 'exercise_feedback',
    }

    def separateBlanksFromText(self, text):
        pieces=[]
        answers=[]
        previous_was_blank=False
        for piece in re.split(blanks, text):
            if piece.startswith('{'):
                answer=to_unicode(piece.strip('{} '))
                if previous_was_blank:
                    answers[-1].append(answer)
                else:
                    answers.append([answer])
                previous_was_blank=True
            elif piece=='':
                pass
            else:            
                pieces.append(to_unicode(piece))
                previous_was_blank=False
        return pieces, answers
            
    def replaceBlanksWithInputTag(self, text, index, readonly=False, give_answers=False):
        pieces, answers=self.separateBlanksFromText(text)
        inputs=[]
        results=[]
        if readonly:
            readonly=' readonly="1"'
        else:
            readonly=''
        for i, answer in enumerate(answers):
            if give_answers:
                answer=''.join('{%s}' % a for a in answer)
            else:
                answer=""
            a=u"""<input type="text" value="%s"%s name="exercise_%s_answer_%s" id="exercise_%s_answer_%s" />""" % (to_unicode(answer), readonly, index, i, index, i)
            inputs.append(a)
        for piece in pieces:
            results.append(piece)
            if inputs:
                results.append(inputs.pop(0))
        if inputs: # leftovers
            results+=inputs
        return u''.join(results)

    def checkFillInTheBlankAnswersFromForm(self, form, text, index):
        """ Checks fill-in-the-blanks exercise from web form,
            returns completed exercise text and lists of correct and wrong answers """
        pieces, answers=self.separateBlanksFromText(text)
        corrects=wrongs=0
        corrected_answers=[]
        for i, choices in enumerate(answers):
            a=to_unicode(form.get('exercise_%s_answer_%s' % (index, i), ''))
            if a in choices:
                corrects+=1
                corrected_answers.append('<span class="correct_fitb">%s</span>' % a)
            else:
                wrongs+=1
                corrected_answers.append('<span class="incorrect_fitb">%s</span>' % a)
                corrected_answers.append('<span class="corrected_fitb">%s</span>' % '/'.join(choices))
        results=[]
        for piece in pieces:
            results.append(piece)
            if answers and corrected_answers:                                
                results.append(corrected_answers.pop(0))
        results.append('\n')
        return u''.join(results), corrects, wrongs

    def checkMultipleChoiceFromForm(self, form, question, choices, index):
        """ Checks form for multiple choice test, returns exercise with correct answers marked and number of right and wrong answers """
        corrects=wrongs=0
        # Check if this is a choice or multiple choice form
        cor=0
        multiple=False
        for q,c in choices:
            if c:
                cor+=1
        if cor!=1:
            multiple=True
        results=['<p><strong>%s</strong></p>\n' % to_unicode(question)]
        
        if multiple:
            for i, choice in enumerate(choices):
                checked=form.get('exercise_%s_checkbox_%s' % (index, i), '')
                correct=(checked and choice[1]) or not (checked or choice[1])
                checked_str=''
                if checked: checked_str=' checked="checked"'
                if correct: 
                    style='correct_mc'
                    corrects+=1
                else:
                    style='incorrect_mc'
                    wrongs+=1
                results.append('<div><span class="%s"><input type="checkbox" disabled="disabled" %s />%s</span></div>\n' % (style, checked_str, to_unicode(choice[0])))
        else:
            checked=int(form.get('exercise_%s_radio' % index, '-1'))         
            for i, choice in enumerate(choices):
                style=''
                if checked==i:
                    checked_str=' checked="checked"'
                    if choice[1]:
                        style='correct_mc'
                        corrects+=1
                    else:
                        style='incorrect_mc'
                else:
                    checked_str=''
                    if choice[1]:
                        style='incorrect_mc'
                        wrongs+=1
                results.append('<div><span class="%s"><input type="radio" name="exercise_%s_radio" disabled="disabled" %s />%s</span></div>\n' % (style, index, checked_str, to_unicode(choice[0])))
        return u''.join(results), corrects, wrongs                

        
    def checkOpenEndedFromForm(self, form, question, index):
        """ Reports back the given answer """
        results=[question,'\n\n']
        a=form.get('exercise_%s_answer' % index, '')
        results.append(a)
        results.append('\n\n')
        return u''.join(results)                           


    def checkExercise(self):
        """ Builds a dictionary of required info for web feedback form """
        lt=getToolByName(self, 'lemill_tool')
        form=self.REQUEST.form
        REQUEST=self.REQUEST
        students_name = to_unicode(REQUEST.get('your_name',''))
        students_email= REQUEST.get('students_email','')
        teachers_email = REQUEST.get('teachers_email','')
        captcha=self.lemill_tool.validateCaptcha(REQUEST.get('recaptcha_challenge_field',''), REQUEST.get('recaptcha_response_field',''))
        exercise_title=self.Title()
        exercise_url=self.absolute_url()
        chapters=[]
        total=0
        max_total=0
        for index, chapter in enumerate(self.getBodyText()):
            text=chapter['text']
            ctype=chapter['type']
            if ctype=='fill_in_the_blanks':
                s, cs, ws=self.checkFillInTheBlankAnswersFromForm(form, text,index)
                max_score=chapter.get('max_points',3.0)
                score=(cs/(cs+ws or 1))*max_score
                total+=score
                max_total+=max_score
                chapters.append({'type':ctype, 'score':score, 'max_score':max_score,'text':s})
            elif chapter['type']=='open_ended':
                s=self.checkOpenEndedFromForm(form, text, index)
                chapters.append({'type':ctype, 'text':s, 'max_score':0})
            elif chapter['type']=='multiple_choices':
                s, cs, ws=self.checkMultipleChoiceFromForm(form, text, chapter['choices'], index)
                max_score=chapter.get('max_points',3.0)
                score=(cs/(cs+ws or 1))*max_score
                total+=score
                max_total+=max_score
                chapters.append({'type':ctype, 'score':score,'max_score':max_score,'text':s})
        dict={'chapters':chapters, 'title':exercise_title,'url':exercise_url,'max_total':max_total, 'total':total, 'percent':(total/(max_total or 1))*100.0,  'teachers_email':teachers_email,'students_email':students_email,'students_name':students_name}        
        return dict
        

    def sendAnswers(self, REQUEST):
        """ Send e-mail to a teacher """
        captcha_c=REQUEST.get('recaptcha_challenge_field','')
        captcha_r=REQUEST.get('recaptcha_response_field','')
        captcha=self.lemill_tool.validateCaptcha(captcha_c, captcha_r)
        students_email= REQUEST.get('students_email','')

        if students_email and not captcha:
            #msg = self.translate("Invalid answer for humanity test.",domain='lemill')
            #lt=getToolByName(self, 'lemill_tool')
            #lt.addPortalMessage(msg, 'warn')
            return REQUEST.RESPONSE
        body=self.exercise_feedback()
        if students_email and captcha:
            msg,msg_type=self._sendAnswers(REQUEST, body)
            lt=getToolByName(self, 'lemill_tool')
            lt.addPortalMessage(msg,msg_type)
        return body

    def _sendAnswers(self, REQUEST, body):
        ### Note for future unicode problems: self.translate returns unicode objects, 
        # but forms return utf-8 encoded strings. joining them together or embedding them with %s is harmful.
        # when building longer strings, they should be manipulated as unicode (convert utf-8 strings with to_unicode()), but when
        # sending email, the text should be utf-8 encoded str.    
        mhost=self.MailHost
        students_name = to_unicode(REQUEST.get('your_name',''))
        #students_email = to_unicode(REQUEST.get('students_email',''))
        students_email= REQUEST.get('students_email','')
        teachers_email = REQUEST.get('teachers_email','')
        d={'name':students_name,
            'exercise_title':to_unicode(self.Title()),
            'exercise_url':to_unicode(self.absolute_url())}      
        if not students_email or (teachers_email and not students_name):
            msg = self.translate("text_mail_feedback_no_information", "You have not provided enough information to send an e-mail.",domain='lemill')
            return (msg, 'warn')
        # Build message body
        # Other email fields
        if students_name:
            msubject=self.translate(u"LeMill exercise '%(exercise_title)s' by %(name)s", domain='lemill') % d
        else:
            msubject=self.translate(u"LeMill exercise '%(exercise_title)s' feedback", domain='lemill') % d
        if teachers_email:
            mto=teachers_email
            mcc=students_email
        else:
            mto=students_email
            mcc=''
        # Send
        try:
            # if the body is page it should already be utf-8?
            #body=body.encode('utf-8')
            mhost.secureSend(body, mto, "LeMill <no-reply@lemill.net>", subject=msubject, mcc=mcc, subtype="html", charset='utf-8')
            msg = self.translate("text_mail_feedback_message_sent", "The e-mail has been sent.",domain='lemill')

            return (msg, 'mess')
        except (MailHostError, AttributeError):
            msg = self.translate("The e-mail could not be sent.",domain='lemill')
            return (msg, 'warn')

    def prepareForPDF(self):
        """ Replaces form fields with dotted lines """        
        text=Material.prepareForPDF(self)
        # Getting rid of submit for exercises
        submit_pattern = re.compile('<fieldset class="visualNoPrint">.*?</fieldset>', re.MULTILINE | re.DOTALL | re.IGNORECASE)
        text = re.sub(submit_pattern, '', text)
        # Replace text inputs with some dots
        input_text_pattern = re.compile('<input type="text" value="" name="exercise_.*?/>',re.DOTALL | re.IGNORECASE | re.MULTILINE)
        text = re.sub(input_text_pattern, '.......... ', text)
        # Replace textarea with some lines of dots
        textarea_pattern = re.compile('<textarea.*?</textarea>', re.DOTALL | re.IGNORECASE | re.MULTILINE)
        text = re.sub(textarea_pattern, '<br />'.join(('.'*80, '.'*80)), text)
        return text

    def fixBrokenChoice(self):
        """ If choice -type is mapped wrong, fix it """
        old_values=self.getRawBodyText()
        new_values=[]
        fixed=False
        for vald in old_values:
            if vald['type']=='choice' and isinstance(vald['text'], list):
                 # [text, [correct_answers], [wrong_answers]]
                 broken_text=vald['text']
                 vald['text']=broken_text[0]
                 choices=[(broken_text[1][0], 1)]
                 for item in broken_text[2]:
                    choices.append((item, 0))
                 vald['choices']=choices
                 vald['type']='multiple_choices'
                 fixed=True
            new_values.append(vald)
        if fixed:
            self.setBodyText(new_values)


registerType(ExerciseMaterial, PROJECTNAME)