# -*- coding: utf-8
# $Id$
#
# Copyright 2001, 2002 by IVA Team and contributors
#
# This file is part of IVA.
#
# IVA 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.
#
# IVA 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 IVA; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

__version__ = "$Revision$"[11:-2]

import AccessControl
import OFS, Globals
from OFS import SimpleItem
import types
from TraversableWrapper import Traversable
from Globals import Persistent
from AccessControl import ClassSecurityInfo
from Cruft import Cruft
from common import translate, perm_manage
#import TestiYlesanne
#from TestiYlesanne import TestiYlesanne
from YlAlus import YlAlus
from input_checks import strip_tags
import re

class ValikYlesanne(YlAlus):
    "Valikvastustega ülesanne"
    meta_type='ValikYlesanne'
    security=ClassSecurityInfo()
    security.declareObjectPublic()
    vastus=1
    
    def __init__(self, uuskysimus, uusvastus=1):
        """ """
        self.kysimus=uuskysimus
        if self.sobivuskontroll(uusvastus):
            self.vastus=uusvastus # kas 0 või 1
        else:
            raise Exception("sobimatu vastus")          
        
    def ylesandeNimetus(self, REQUEST=None):
        "ülesande tüübi nimi"
        return 'Yes/No'         
            
    def sobivuskontroll(self, valik):
        if valik==0 or valik==1:
            return 1
        else:
            return 0
        
    def annaKysimus(self):
        return self.kysimus
        
        
    def taitmineHTML(self, REQUEST, elemendinimi):
        "Vastuse sisestamise koht"
        if not self.kasLubatudLahendada(REQUEST):
            return ":­("
        return "<input type='checkbox' name='%s' />" % elemendinimi
        
    def vaatamineHTML(self, REQUEST):
        "Koostaja poolt lahenduskoha vaatamine"
        if self.vastus:
            return "+"
        else:
            return "-"

    def tegelikHTML(self, REQUEST):
        "Opetaja lahendus"
        return self.vaatamineHTML(REQUEST)

    security.declareProtected(perm_manage, 'pakutud')
    def pakutud(self):
        """ pakutud vastus """
        return self.pakutudAndmed

    def pakutudHTML(self, REQUEST=None, vastus=0):
        "Pakutud andmete esitus veebis"
        if vastus==0:
            vastus=self.pakutudAndmed
        if vastus=="on":
            return "+"
        else:
            return "-"

    def kasPihtasArvutus(self):
        "Ylekate"
        return 1

    def kasPihtas(self):
        "uuring"
        arv=0
        if self.pakutudAndmed=="on":
            arv=1
        if arv==self.vastus:
            return 1
        else:
            return 0

    def automaatPunkte(self):
        "Automaatne punktide arv"
        if self.kasPihtas():
            return self.normPunktid
        else:
            return 0
         
          
    def vastuseMuutmisVorm(self, REQUEST):
        """üle kaetud, näitab vastusevaliku märkeruudu """
        olek=""
        if not self.kas_opetaja(REQUEST): return ":-("
        if self.vastus:
           olek=" CHECKED "
        v=translate(self, "Is answer correct?", target=self.giveLanguage(REQUEST)) 
        return v+" <input type='checkbox' name='vastus' "+olek+"/>"
        
    def vastuseMuutmisLeht(self, REQUEST=None,vastus=''):
        "Vastuse salvestamine, üle kaetud"
        if not self.kas_opetaja(REQUEST): return ":-("
        if vastus is not None:
          self.vastus=1
        else:
          self.vastus=0
        return ""
          
    def koopia(self):
       "Koopia ülesandest"
       t=ValikYlesanne(self.kysimus, self.vastus)
       t.id=self.id
       t.normPunktid=self.normPunktid
       t.kirjeldavTekst=self.kirjeldavTekst
       return t
Globals.InitializeClass(ValikYlesanne)       
       
class TekstivastusegaYlesanne(YlAlus):
    "Tekstivastustega ülesanne"
    meta_type='TekstivastusegaYlesanne'
    security=ClassSecurityInfo()
    security.declareObjectPublic()
 
    def __init__(self, uuskysimus):
        """
        """
        self.kysimus=uuskysimus
        self.seaPunktiArvutus(0)
        
        
    def ylesandeNimetus(self, REQUEST=None):
        "ülesande tüübi nimi"
        return 'Paragraph'
        
    def taitmineHTML(self, REQUEST, elemendinimi):
        "Vastuse sisestamise koht"
        return "<textarea rows=\"10\" cols=\"50\" name='%s' /></textarea>" % elemendinimi
        
    def vaatamineHTML(self, REQUEST):
        "Koostaja poolt lahenduskoha vaatamine"
        return "..."
          
    security.declareProtected(perm_manage, 'pakutud')
    def pakutud(self):
        """ pakutud vastus """
        return self.pakutudAndmed
    
    def pakutudHTML(self, REQUEST=None, vastus=0):
        "Pakutud andmete esitus veebis"
        if vastus==0:
          vastus=self.pakutudAndmed
        return strip_tags(str(vastus))
          
    def tegelikHTML(self, REQUEST):
        "Opetaja vastus"
        return "Igal oma vastus"
          
    def vastuseMuutmisVorm(self, REQUEST):
        "Üle kaetud, vastust ei saa ette määrata"
        return "..."       
        
          
    def koopia(self):
       "Koopia ülesandest"
       t=TekstivastusegaYlesanne(self.kysimus)
       t.id=self.id
       t.normPunktid=self.normPunktid
       t.kirjeldavTekst=self.kirjeldavTekst
       t.viiteURL=self.viiteURL
       t.viiteTekst=self.viiteTekst       
       return t
       
Globals.InitializeClass(TekstivastusegaYlesanne)    


class OigeTekstivastusegaYlesanne(YlAlus):
    "Küsimus, millele leidub õige vastus"
    meta_type="OigeTekstivastusegaYlesanne"
    security=ClassSecurityInfo()
    security.declareObjectPublic()

    def __init__(self, uuskysimus):
        "Loomine"
        self.kysimus=uuskysimus
        self.variandid=[]
        
    def ylesandeNimetus(self, REQUEST=None):
        "Nimetus"
        return 'Short answer'
        
    def loeTekstistYlesanne(self, reamassiiv):
        "Loeb andmed tekstist"
        if not self.kas_opetaja(REQUEST): return ":-("
        self.variandid=[]
        for i in range(len(reamassiiv)):
          if len(reamassiiv[i].split(":"))>1:
            if reamassiiv[i].split(":")[1]=="QUESTION":
              self.kysimus=reamassiiv[i+1].strip()
            if reamassiiv[i][0:7]==":ANSWER" and reamassiiv[i][7:8]!="S":
              self.variandid.append(reamassiiv[i].split(":")[2])
            if reamassiiv[i][0:5]==":CASE":
              if reamassiiv[i][6:7]=="0":
                self.tostuTundlik=0
              else:
                self.tostuTundlik=1
              
    def kirjutaYlesanneTekstiks(self, testinimi="test", nr=1):
        "Väljastatakse andmed tekstina"
        if not self.kas_opetaja(REQUEST):
           return ":­("
        tulemus=":TYPE:S\n"
        tulemus=tulemus+":TITLE:%s (%s)\n" % (testinimi, nr)
        tulemus=tulemus+":CAT:%s\n" % testinimi
        tulemus=tulemus+":QUESTION:H\n%s\n" % self.kysimus
        tulemus=tulemus+":ANSWERS:1\n"
        tulemus=tulemus+":CASE:%s\n" % self.tostuTundlik
        for i in range(len(self.variandid)):
          tulemus=tulemus+":ANSWER%s:%s:100:0:0\n" % (i+1, self.variandid[i])
        return tulemus
        

    def taitmineHTML(self, REQUEST, elemendinimi):
        "Vastuse sisestamise koht"
        return "<input type='text' name='%s' />" % elemendinimi
    

    def tegelikHTML(self, REQUEST):
       "Opetaja pakutu"
       try:
         if not self.kasLubatudLahendada(REQUEST):
           return ""
       except:
               pass
       tulemus="<ul>"
       for x in self.variandid:
         tulemus=tulemus+"\n<li>"+strip_tags(x)+"</li>"
       tulemus=tulemus+"</ul>"
       return tulemus
       
    def vaatamineHTML(self, REQUEST):
       "Lahenduse vaatamine"
       return self.tegelikHTML(REQUEST)
 

    security.declareProtected(perm_manage, 'pakutud')
    def pakutud(self):
        """ pakutud vastus """
        return self.pakutudAndmed
    
    def pakutudHTML(self, REQUEST=None, vastus=0):
        "Pakutud andmete esitus veebis"
        if vastus==0:
          vastus=self.pakutudAndmed
        return strip_tags(vastus)
        
    def vastuseMuutmisVorm(self, REQUEST):
        "ZPT kaudu"
        return self.qtChangeFormShortAnswerExercise(REQUEST)

    def vastuseMuutmisLeht(self, REQUEST, vastus):
        "Vastuse salvestamine, üle kaetud, kutsutakse muutmisLehelt"
        if not self.kas_opetaja(REQUEST): return ":-("
        if vastus is None:
          vastus=()
        if type(vastus) is types.StringType:
          vastus=(vastus,) 
        self.variandid=[]
        for i in range(len(vastus)):
          if len(vastus[i])>0:
            self.variandid.append(vastus[i])
        if self.variandid:
          return ""
        return translate(self, "No correct answers given", target=self.giveLanguage(REQUEST))
#        REQUEST.RESPONSE.redirect('muutmisVorm')

    def kasPihtas(self):
       "Kas tabati"
       tabamus=0
       if not self.vastusPakutud:
         return 0
       for x in self.variandid:
         if self.tostuTundlik:
           if x == self.pakutudAndmed:
             tabamus=1
         else:
           if x.lower()==self.pakutudAndmed.lower():
             tabamus=1
       return tabamus
       
    
    def automaatPunkte(self):
       "Automaatselt arvestatavad punktid"
       if self.kasPihtas():
         return self.normPunktid
       else:
         return 0    

    def koopia(self):
       "Koopia"
       t=OigeTekstivastusegaYlesanne(self.kysimus)
       for x in self.variandid:
         t.variandid.append(x)
       t.id=self.id
       t.normPunktid=self.normPunktid       
       t.kirjeldavTekst=self.kirjeldavTekst
       return t
       
       

class MitmikvalikYlesanne(YlAlus):
    "Mitme võimaliku õige variandiga ülesanne"
    meta_type='MitmikvalikYlesanne'
    security=ClassSecurityInfo()
    security.declareObjectPublic()
 
    def __init__(self, uuskysimus):
        "Loomine"
        self.kysimus=uuskysimus
        self.valikud=[]
        self.selgitused=[]
        self.oigedValikud=[]
        
    def ylesandeNimetus(self, REQUEST=None):
        "Ülesande tüübi nimi"
        return 'Mark all correct'
        
    def loeTekstistYlesanne(self, reamassiiv):
        "Loeb andmed tekstist"
        self.valikud=[]
        self.selgitused=[]
        self.oigedValikud=[]
        self.kysimus="Kysimus puudub"
        leitud=0
        for i in range(len(reamassiiv)):
          if len(reamassiiv[i].split(":"))>1:
            if reamassiiv[i].split(":")[1]=="QUESTION":
              self.kysimus=reamassiiv[i+1].strip()
            if reamassiiv[i][0:7]==":ANSWER" and reamassiiv[i][7:8]!="S":
              self.valikud.append(reamassiiv[i+1].strip())              
              leitud=leitud+1
              if reamassiiv[i].split(":")[2]!="0":
                self.oigedValikud.append(leitud)
            if reamassiiv[i][0:7]==":REASON" and reamassiiv[i][7:8]!="S":
              self.selgitused.append(reamassiiv[i+1].strip())              
              
    def kirjutaYlesanneTekstiks(self, testinimi="test", nr=1):
        "Väljastatakse andmed tekstina"
        if not self.kasLubatudLahendada(REQUEST):
           return ":­("
        tulemus=":TYPE:MC:1:0:C\n"
        tulemus=tulemus+":TITLE:%s (%s)\n" % (testinimi, nr)
        tulemus=tulemus+":CAT:%s\n" % testinimi
        tulemus=tulemus+":QUESTION:H\n%s\n" % self.kysimus
        if len(self.oigedValikud)==0:
          protsent="0"
        else:
          protsent=str(100/len(self.oigedValikud))
        for i in range(len(self.valikud)):
          arv="0"
          if i in self.oigedValikud:
            arv=protsent
          tulemus=tulemus+":ANSWER%s:%s:H\n%s\n:REASON%s:H\n%s\n" % (i+1, arv, self.valikud[i], i+1, self.selgitused[i])
        return tulemus
        
    def taitmineHTML(self, REQUEST, elemendinimi):
        "Vastuse sisestamise koht"
        tulemus="<table>"
        if len(self.valikud)>0:
         for i in range(len(self.valikud)):
          tulemus=tulemus+"\n<tr>"+\
            "<td>"+strip_tags(self.valikud[i])+"</td>"+\
            "<td><input type='checkbox' name='"+elemendinimi+"' "+\
            "value='"+str(i)+"'></td></tr>"
         tulemus=tulemus+"</table>"
        else:
         tulemus=translate(self, "Missing choices", target=self.giveLanguage(REQUEST))
        return tulemus
        
    def tegelikHTML(self, REQUEST):
       "Opetaja pakutu"
       tulemus="<ul>"
       for i in range(len(self.valikud)):
         tulemus += "<li>"
         tulemus=tulemus+self.valikud[i]+" "
         if i in self.oigedValikud:
           tulemus=tulemus+"+"
         else:
           tulemus=tulemus+"-"
         try:
           tulemus=tulemus+"<br /><i>"+self.selgitused[i]+"</i>"
         except:
           pass
         tulemus += "</li>"
#         tulemus=tulemus+"<br />"
       tulemus += "</ul>"
       return tulemus
       
       if len(self.oigedValikud)==0:
               return "Lahendus puudub" #XXX:translation!
       else:
         tulemus=""
         for x in self.oigedValikud:
           tulemus=tulemus+self.valikud[x]+"<br />"
         return tulemus
        
    def vaatamineHTML(self, REQUEST):
        "Koostaja poolt lahenduskoha vaatamine"
        tulemus=""
        if len(self.valikud)>0:
          tulemus=tulemus+"<ul>"
          for i in range(len(self.valikud)):
           try:           
            tulemus=tulemus+"\n<li>"+strip_tags(self.valikud[i])+" &nbsp; "+strip_tags(self.selgitused[i])+"</li>"
           except Exception, teade:
            tulemus=tulemus+str(teade)
          tulemus=tulemus+"</ul>"
        else:
          tulemus=translate(self, "Missing choices", target=self.giveLanguage(REQUEST))
        return tulemus
        
        
    security.declareProtected(perm_manage, 'pakutud')
    def pakutud(self):
        """ pakutud vastus """
        return self.pakutudAndmed
    
    def pakutudHTML(self, REQUEST, vastus=0):
          "Pakutud andmete esitus veebis"
          if vastus==0:
            vastus=self.pakutudAndmed          
          if vastus is None:
            return translate(self,"Answers missing",target=self.giveLanguage(REQUEST))
          try:
            tulemus="<ul>"
            for x in vastus:
              tulemus=tulemus+"<li>"+strip_tags(self.valikud[int(x)])+"</li>"            
            tulemus+="</ul>"
            return tulemus
          except:
            return translate(self,'Problem with data',target=self.giveLanguage(REQUEST))

    def kasPihtasArvutus(self):
        "Ylekate"
        return 0

    def vastuseMuutmisVorm(self, REQUEST):
        "üle kaetud, lubab muuta variante ja vastust"
        tulemus="<table><tr><td>"+translate(self, 'Responses', target=self.giveLanguage(REQUEST))+"</td><td>"+translate(self, 'Feedback', target=self.giveLanguage(REQUEST))+"</td><td>"+translate(self, 'Correct', target=self.giveLanguage(REQUEST))+"</td></tr>"
        for i in range(len(self.valikud)):
          margitud=""
          if i in self.oigedValikud:
            margitud="CHECKED"
          selgitustekst=""
          if i < len(self.selgitused):
            selgitustekst=strip_tags(self.selgitused[i])
          tulemus=tulemus+"\n<tr>"+\
            "<td><input type='text' name='vastus' value='"+strip_tags(self.valikud[i])+"'></td>"+\
            "<td><input type='text' name='selgitus' value='"+selgitustekst+"'></td>"+\
            "<td><input type='checkbox' name='valikunr' "+\
            "value='"+str(i)+"' "+margitud+"></td></tr>"
        tulemus=tulemus+"\n<tr><td><input type='text' name='vastus' /></td><td><input type='text' name='selgitus' /></td>"+\
                "<td><input type='checkbox' name='valikunr' value='"+str(len(self.valikud))+"'></td></tr>"
        tulemus=tulemus+"\n<tr><td><input type='text' name='vastus' /></td><td><input type='text' name='selgitus' /></td>"+\
                "<td><input type='checkbox' name='valikunr' value='"+str(len(self.valikud)+1)+"'></td></tr>"
        tulemus=tulemus+"\n<tr><td><input type='text' name='vastus' /></td><td><input type='text' name='selgitus' /></td>"+\
                "<td><input type='checkbox' name='valikunr' value='"+str(len(self.valikud)+2)+"'></td></tr>"
        tulemus=tulemus+"\n<tr><td><input type='text' name='vastus' /></td><td><input type='text' name='selgitus' /></td>"+\
                "<td><input type='checkbox' name='valikunr' value='"+str(len(self.valikud)+3)+"'></td></tr>"
        #if len(self.valikud)==0:
        #  tulemus=tulemus+"\n<tr><td><input type='text' name='vastus' /></td><td><input type='text' name='selgitus' /></td>"+\
        #        "<td><input type='checkbox' name='valikunr' value='1'></td></tr>"
        tulemus=tulemus+"</table>"
        return tulemus
        
    def vastuseMuutmisLeht(self, REQUEST, vastus=None):
        "Vastuse salvestamine, üle kaetud"
        if REQUEST is None: return
        if hasattr(REQUEST, "selgitus"):
          selgitus=getattr(REQUEST, "selgitus")
        else:
          selgitus=()
        if hasattr(REQUEST, "valikunr"):
          valikunr=getattr(REQUEST, "valikunr")
        else:
          valikunr=()
        if vastus is None:
          vastus=()
        if type(vastus) is types.StringType:
          vastus=(vastus,) 
          selgitus=(selgitus,)
        self.oigedValikud=[]
        if valikunr is None:
          valikunr=()
        if type(valikunr) is types.StringType:
          valikunr=(valikunr,)
        for x in valikunr:
          self.oigedValikud.append(int(x))
        self.valikud=[]
        self.selgitused=[]
        for i in range(len(vastus)):
          if len(vastus[i])>0:
            self.valikud.append(vastus[i])
            if i < len(selgitus):
             self.selgitused.append(selgitus[i])
          else:
            if i in self.oigedValikud:
              self.oigedValikud.remove(i)
            for j in range(len(self.oigedValikud)):
              if self.oigedValikud[j]>i:
                self.oigedValikud[j]=self.oigedValikud[j]-1
        if len(vastus)==0:
          return translate(self, "Answers missing", target=self.giveLanguage(REQUEST))
        return ""

    def automaatPunkte(self):
      "Automaatne punktiarvutus"
#      return self.oigedValikud
      if self.pakutudAndmed is None: return 0
      if type(self.pakutudAndmed) is types.StringType:
        vastused=(int(self.pakutudAndmed),)
      else:
        vastused=map(int, self.pakutudAndmed)
#      return vastused + self.oigedValikud
#      pihtas=[]
      korras=0
      for i in range(len(self.valikud)):
         if ((i in self.oigedValikud) and (i in vastused)) or \
            ((i not in self.oigedValikud) and (i not in vastused)):
          #Kui pakutu ja oige on ühesugune
          korras=korras+1
#          pihtas.append(i)
#      return pihtas
      korras=korras*1.0
      return self.normPunktid*korras/len(self.valikud)
        
          
    def koopia(self):
       "Koopia ülesandest"
       t=MitmikvalikYlesanne(self.kysimus)
       for x in self.valikud:
         t.valikud.append(x)
       for x in self.selgitused:
         t.selgitused.append(x)
       for x in self.oigedValikud:
         t.oigedValikud.append(x)
       t.id=self.id       
       t.normPunktid=self.normPunktid
       t.kirjeldavTekst=self.kirjeldavTekst
       return t

Globals.InitializeClass(MitmikvalikYlesanne)

class YksikvalikYlesanne(YlAlus):
    "Üksiku valikuga ülesanne"
    meta_type='YksikvalikYlesanne'
    security=ClassSecurityInfo()
    security.declareObjectPublic()
 
    def __init__(self, uuskysimus):
        "Loomine"
        self.kysimus=uuskysimus
        self.valikud=[]
        self.selgitused=[]
        self.oigeValik=-1
        
    def ylesandeNimetus(self, REQUEST=None):
         "Ülesande tüübi nimi"
         return 'Multiple choice'
        
    def taitmineHTML(self, REQUEST, elemendinimi):
        "Vastuse sisestamise koht"
        tulemus="<table>"
        if len(self.valikud)>0:
         for i in range(len(self.valikud)):
          tulemus=tulemus+"\n<tr>"+\
            "<td><input type='radio' name='"+elemendinimi+"' "+\
            "value='"+str(i)+"'></td>"+\
            "<td>"+strip_tags(self.valikud[i])+"</td>"
          tulemus=tulemus+"</tr>"
         tulemus=tulemus+"</table>"
        else:
         tulemus="Valikud puuduvad"
        return tulemus
        
    def tegelikHTML(self, REQUEST):
       "Opetaja pakutu"
       if self.oigeValik==-1:
         return "Lahendus puudub"
       return self.valikud[self.oigeValik]

        
    def vaatamineHTML(self, REQUEST):
        "Koostaja poolt lahenduskoha vaatamine"
        tulemus=""
        if len(self.valikud)>0:
          tulemus=tulemus+"<ul>"
          for i in range(len(self.valikud)):
            tulemus=tulemus+"\n<li>"+strip_tags(self.valikud[i])
            try:
              tulemus=tulemus+"|"+strip_tags(self.selgitused[i])
            except:
              pass
            tulemus=tulemus+"</li>"
          tulemus=tulemus+"</ul>"
        else:
          tulemus="Valikud puuduvad"
        return tulemus
        
        
    security.declareProtected(perm_manage, 'pakutud')
    def pakutud(self):
        """ pakutud vastus """
        return self.pakutudAndmed
    
    def pakutudHTML(self, REQUEST=None, vastus=0):
          "Pakutud andmete esitus veebis"
          if vastus==0:
            vastus=self.pakutudAndmed
          if vastus is None:
            return "Vastus valimata"
          try:
            return strip_tags(self.valikud[int(vastus)]) +"|" + self.annaSelgitus(int(vastus))          
          except:
            return "Probleem andmetega"          

    def kasPihtasArvutus(self):
        "Ylekate"
        return 1

    def kasPihtas(self):
        "Arvutus ise"
        try:
          return int(self.pakutudAndmed)==self.oigeValik
        except:
          return 0
          
    def automaatPunkte(self):
       "Automaatne punktide arv"
       if self.kasPihtas():
         return self.normPunktid
       else:
         return 0
         
    def annaSelgitus(self, nr):
       "selgituse väljastus, kuna selgituse lahter tuli hiljem juurde"
       try:
         return self.selgitused[nr]
       except:
         return ""
         
    def annaMuutmisVormiRida(self, REQUEST, nr):
          "Ühe rea loomine"
          margitud=""
          if nr==self.oigeValik:
            margitud="CHECKED"
          valik=""
          try:
            valik=self.valikud[nr] 
          except:
            pass
          return "<tr><td><input type='text' name='vastus' value='"+strip_tags(valik)+"'></td>"+\
            "<td><input type='radio' name='valikunr' "+\
            "value='"+str(nr)+"' "+margitud+"></td><td><input type='text' name='selgitus' value='"+strip_tags(self.annaSelgitus(nr))+"' /></tr>"
        

         
    def vastuseMuutmisVorm(self, REQUEST):
        "Üle kaetud, lubab muuta variante ja vastust"
        tulemus="<table><tr><td>"+translate(self, 'Responses', target=self.giveLanguage(REQUEST))+"</td><td>"+translate(self, 'Correct', target=self.giveLanguage(REQUEST))+"</td><td>"+translate(self, 'Feedback', target=self.giveLanguage(REQUEST)) +"</td></tr>"
        for i in range(len(self.valikud)+4):
           tulemus=tulemus+self.annaMuutmisVormiRida(REQUEST, i)
        tulemus=tulemus+"</table>"
        return tulemus
        
    def muutmisLehtBak(self, REQUEST=None, kysimus="", vastus="", selgitus="", valikunr=-1):
        "Vastuse salvestamine, üle kaetud"
        self.kysimus=kysimus 
        if vastus is None:
          vastus=()
        if type(vastus) is types.StringType:
          vastus=(vastus,) 
        if selgitus is None:
          selgitus=()
        if type(selgitus) is types.StringType:
          selgitus=(selgitus,)
        valikunr=int(valikunr)         
        self.valikud=[]
        self.selgitused=[]
        for i in range(len(vastus)):
          if len(vastus[i])>0:
            self.valikud.append(vastus[i])
            self.selgitused.append(selgitus[i])
              
          else:
            if valikunr==i:
              valikunr=-1
            if valikunr>i:
              valikunr=valikunr-1
        self.oigeValik=valikunr
        REQUEST.RESPONSE.redirect('muutmisVorm')
        
    def vastuseMuutmisLeht(self, REQUEST, vastus):
        "Vastuse muutmine"
        if vastus is None:
          vastus=()
        if type(vastus) is types.StringType:
          vastus=(vastus,)
        if hasattr(REQUEST, 'selgitus'):
          selgitus=REQUEST.selgitus
        else:
          selgitus=()
        if type(selgitus) is types.StringType:
          selgitus=(selgitus,)
        if hasattr(REQUEST, 'valikunr'):
          valikunr=REQUEST.valikunr
        else:
          valikunr=-1
        valikunr=int(valikunr)         
        self.valikud=[]
        self.selgitused=[]
        for i in range(len(vastus)):
          if len(vastus[i])>0:
            self.valikud.append(vastus[i])
            self.selgitused.append(selgitus[i])
              
          else:
            if valikunr==i:
              valikunr=-1
            if valikunr>i:
              valikunr=valikunr-1
        self.oigeValik=valikunr
        if valikunr==-1:
          return translate(self, "No correct answers given", target=self.giveLanguage(REQUEST))
        return ""
                            

          
    def koopia(self):
       "Koopia ülesandest"
       t=YksikvalikYlesanne(self.kysimus)
       for x in self.valikud:
         t.valikud.append(x)
       try:
        for x in self.selgitused:
          t.selgitused.append(x)
       except:
         pass
       t.oigeValik=self.oigeValik
       t.id=self.id
       t.normPunktid=self.normPunktid
       t.kirjeldavTekst=self.kirjeldavTekst
       return t

Globals.InitializeClass(YksikvalikYlesanne)

class ArvuvahemikuliseVastusegaYlesanne(YlAlus):
  "Vajab arvulist vastust soovitud piirkonnas"
  meta_type="ArvuvahemikuliseVastusegaYlesanne"
  security=ClassSecurityInfo()
  security.declareObjectPublic()
  
  def __init__(self, uuskysimus):
     "Loomine"
     self.kysimus=uuskysimus
     self.alamPiir=-1
     self.ylemPiir=-1
     self.oigeVastus=-1
     self.arvutusTyyp=0  # vahemik
     

  def taitmineHTML(self, REQUEST, elemendinimi):
     "Vastuse sisestamise koht"
     return "<input type='text' name='%s' />" % elemendinimi

  def ylesandeNimetus(self, REQUEST=None):
     "Tüübinimi kasutajale"
     return 'Numerical'

  def tegelikHTML(self, REQUEST):
     "petaja lahendus"     
     return str(self.alamPiir)+" &lt;= x="+str(self.oigeVastus)+" &lt;= "+str(self.ylemPiir)

  def vaatamineHTML(self, REQUEST):
     "Lahenduse vaatamine"
     return self.tegelikHTML(REQUEST)

  security.declareProtected(perm_manage, 'pakutud')
  def pakutud(self):
      """ pakutud vastus """
      return self.pakutudAndmed
    
  def pakutudHTML(self, REQUEST=None, vastus=0):
        "Pakutud andmete esitus veebis"
        if vastus==0:
          vastus=self.pakutudAndmed
        return strip_tags(vastus)
        
  def vastuseMuutmisVorm(self, REQUEST):
     "Väljakutse zpt kaudu"
     return self.qtChangeFormNumberSpaceExercise(REQUEST)

  def salvestaPakutu(self, andmed):
      "Loob koopia ülesandest koos pakutud vastusega"
      k=self.koopia()
      k.id=self.id
      k.vastusPakutud=1
      andmed_x=re.sub(',', '.', andmed);
      k.pakutudAndmed=andmed_x
      return k
 
  def vastuseMuutmisLeht(self, REQUEST, vastus):
     "Salvestus"
     import re
     if type(vastus) is None: return "Vigane vastus"
     if len(vastus)!=3: return "Pole piirid paigas"
     for i in range(3):
       vastus[i]=re.sub(',', '.', vastus[i]);
     self.alamPiir=float(vastus[0])
     self.oigeVastus=float(vastus[1])
     self.ylemPiir=float(vastus[2])
     if hasattr(REQUEST, "arvutusTyyp"):
       self.arvutusTyyp=int(REQUEST["arvutusTyyp"])
     if self.alamPiir>self.oigeVastus:
             return translate(self, 'Error: minimum is bigger than correct answer', target=self.giveLanguage(REQUEST))+"<br />"
     if self.ylemPiir<self.oigeVastus:
             return translate(self, 'Error: maximum is smaller than correct answer', target=self.giveLanguage(REQUEST))+"<br />"
     return ""
       
  def automaatPunkte(self):
    "Automaatne punktiarvutus"
    if self.vastusPakutud:
      try:
         x=float(self.pakutudAndmed)
      except:
         return 0
      if self.arvutusTyyp==0: #vahemik
        if x>=self.alamPiir and x<=self.ylemPiir:
          return self.normPunktid
        else:
          return 0
      if self.arvutusTyyp==1: #Lineaar maksimumiga
        if x<self.alamPiir:
           return 0
        if x>self.ylemPiir:
           return 0
        if x>self.alamPiir and x<=self.oigeVastus:        
          return ((x-self.alamPiir)*1.0/(self.oigeVastus-self.alamPiir))*self.normPunktid
        if x==self.alamPiir:
          if x==self.oigeVastus: return self.normPunktid
          else: return 0
        if x>=self.oigeVastus and x<self.ylemPiir:
          return  (1-((x-self.oigeVastus)*1.0/(self.ylemPiir-self.oigeVastus)))*self.normPunktid
        if x==self.ylemPiir:
          if x==self.oigeVastus: return self.normPunktid
          else: return 0
    else:
      return 0

  def koopia(self):
     "Koopia"
     t=ArvuvahemikuliseVastusegaYlesanne(self.kysimus)
     t.alamPiir=self.alamPiir
     t.ylemPiir=self.ylemPiir
     t.oigeVastus=self.oigeVastus
     t.arvutusTyyp=self.arvutusTyyp
     t.normPunktid=self.normPunktid
     t.kirjeldavTekst=self.kirjeldavTekst
     return t
     
       
class ProtsentYlesanne(YlAlus):
  "Protsendiarvutus mitmel moel"
  meta_type="ProtsentYlesanne"
  security=ClassSecurityInfo()
  security.declareObjectPublic()
  
  def __init__(self, uuskysimus):
    "Loomine"
    self.kysimus=uuskysimus
    self.kysitav=0 
      #0-protsent (aine/lahus), 1 lahusti, 2 aine, 3 aine/lahusti
    self.aineAlamPiir=10
    self.aineYlemPiir=100
    self.lahustiAlamPiir=110
    self.lahustiYlemPiir=1000
    self.lahustiTekst="vesi; destilleeritud vesi"
    self.lahustiYhik="g"
    self.aineTekst="sool; suhkur"
    self.aineYhik="g"
    self.vastuseTapsusProtsent=10
    self.aineKogus=-1
    self.lahustiKogus=-1
    self.tekitaAndmed()
    self.arvutusTyyp=0
    
  def tekitaAndmed(self):
    "Juhuslike algandmete loomine"
    import random
    self.aineKogus=self.aineAlamPiir+int(random.random()*(self.aineYlemPiir-self.aineAlamPiir))
    self.lahustiKogus=self.lahustiAlamPiir+int(random.random()*(self.lahustiYlemPiir-self.lahustiAlamPiir))
    
  def leiaProtsent(self):
    "Lahuse protsent"
    return 100*(float(self.aineKogus)/float(float(self.aineKogus)+float(self.lahustiKogus)))
    
  def juhusona(self, tekst, eraldaja=";"):
    "Juhuslik jupp eraldajatega lahutatud tekstist"
    import random
    m=tekst.split(eraldaja)
    return m[int(random.random()*len(m))]
        

  def taitmineHTML(self, REQUEST, elemendinimi):
    "Lahendajale"
    self.tekitaAndmed()
    tulemus="<input type='hidden' name='"+elemendinimi+"' value='"+str(self.aineKogus)+"' />"+\
       "<input type='hidden' name='"+elemendinimi+"' value='"+str(self.lahustiKogus)+"' />"+\
       "<input type='hidden' name='"+elemendinimi+"' value='"+str(self.kysitav)+"' />\n<table>"
    if self.kysitav==0:
      tulemus=tulemus+\
        "<tr><td>"+self.juhusona(self.lahustiTekst)+"</td><td>"+str(self.lahustiKogus)+"</td><td>"+self.lahustiYhik+"</td></tr>"+\
        "<tr><td>"+self.juhusona(self.aineTekst)+"</td><td>"+str(self.aineKogus)+"</td><td>"+self.aineYhik+"</td></tr>"+\
        "<tr><td>protsent: </td><td><input type='text' name='"+elemendinimi+"' /></td><td>%</td></tr>"      
    
    if self.kysitav==1:
      tulemus=tulemus+\
        "<tr><td>"+self.juhusona(self.lahustiTekst)+"</td><td><input type='text' name='"+elemendinimi+"' /></td><td>"+self.lahustiYhik+"</td></tr>"+\
        "<tr><td>"+self.juhusona(self.aineTekst)+"</td><td>"+str(self.aineKogus)+"</td><td>"+self.aineYhik+"</td></tr>"+\
        "<tr><td>protsent: </td><td>"+str(round(self.leiaProtsent(), 2))+"</td><td>%</td></tr>"      
    
    if self.kysitav==2:
      tulemus=tulemus+\
        "<tr><td>"+self.juhusona(self.lahustiTekst)+"</td><td>"+str(self.lahustiKogus)+"</td><td>"+self.lahustiYhik+"</td></tr>"+\
        "<tr><td>"+self.juhusona(self.aineTekst)+"</td><td><input type='text' name='"+elemendinimi+"' /></td><td>"+self.aineYhik+"</td></tr>"+\
        "<tr><td>protsent: </td><td>"+str(round(self.leiaProtsent(),2))+"</td><td>%</td></tr>"      
    
    if self.kysitav==3:
      tulemus=tulemus+\
        "<tr><td>"+self.juhusona(self.lahustiTekst)+"</td><td>"+str(self.lahustiKogus)+"</td><td>"+self.lahustiYhik+"</td></tr>"+\
        "<tr><td>"+self.juhusona(self.aineTekst)+"</td><td>"+str(self.aineKogus)+"</td><td>"+self.aineYhik+"</td></tr>"+\
        "<tr><td>Mitu protsenti moodutab <br /> teine esimesest: </td><td><input type='text' name='"+elemendinimi+"' /></td><td>%</td></tr>"      
      
    tulemus=tulemus+"</table>"
    return tulemus
    
  def ylesandeNimetus(self, REQUEST=None):
    "Nimetus"
    return "Percent"
    
    
  def kysitavTekstina(self, REQUEST, nr=-1):
    "Küsitav suurus tekstina"
    if nr==-1: nr=self.kysitav
    nr=int(nr)
    suurused=[translate(self, "Strenght of solution", target=self.giveLanguage(REQUEST)), 
              translate(self, "Amount of solvent", target=self.giveLanguage(REQUEST)), 
              translate(self, "Amount of soluble", target=self.giveLanguage(REQUEST)),
              translate(self, "Soluble/Solvent", target=self.giveLanguage(REQUEST)) 
             ]
    try:
     return suurused[nr]
    except:
            return translate(self, "Error",target=self.giveLanguage(REQUEST))+': '+nr
    
  def kasPaiknebVahemikus(self, pakutud, oige, nihkeprotsent):
    "abifunktsioon"
    import re
    import types
    try:
      if type(pakutud)==types.StringType:
        pakutud=re.sub(',', '.', pakutud)
      pakutud=float(pakutud)
    except:
      return 0
    if pakutud>=oige-oige*float(nihkeprotsent)/100 and \
       pakutud<=oige+oige*float(nihkeprotsent)/100:
         return 1
    return 0
    
  def paigutaPakutudAndmed(self):
    "Pakututest tagasi "
    import re
    self.aineKogus=float(re.sub(',', '.', self.pakutudAndmed[0]))
    self.lahustiKogus=float(re.sub(',', '.', self.pakutudAndmed[1]))
    self.kysitav=int(self.pakutudAndmed[2])
    return self.pakutudAndmed[3]
    self.pakutudAndmed[3]=float(re.sub(',', '.', self.pakutudAndmed[3]))

  def tegelikHTML(self, REQUEST):
    "Õpetaja lahendus"
    tulemus=""
    if self.vastusPakutud:
     self.paigutaPakutudAndmed()
     tulemus=tulemus+"<table>"+\
        "<tr><td>"+self.juhusona(self.lahustiTekst)+"</td><td>"+str(self.lahustiKogus)+"</td><td>"+self.lahustiYhik+"</td></tr>"

     tulemus=tulemus+   "<tr><td>"+self.juhusona(self.aineTekst)+"</td><td>"+str(self.aineKogus)+"</td><td>"+self.aineYhik+"</td></tr>"
     tulemus=tulemus+   "<tr><td>"+translate(self, "Strenght of solution", target=self.giveLanguage(REQUEST))+": </td><td>"+str(round(self.leiaProtsent(), 2))+"%</td><td></td></tr>"
     tulemus=tulemus+   "<tr><td>"+translate(self, "Soluble/Solvent", target=self.giveLanguage(REQUEST))+": </td><td>"+str(round(float(self.aineKogus)/float(self.lahustiKogus)*100, 2))+"% </td><td></td><td></td></tr>"
     tulemus=tulemus+   "</table>"      
    tulemus=tulemus+ translate(self, "Variable to be found", target=self.giveLanguage(REQUEST))+": "+str(self.kysitavTekstina(REQUEST))
    return tulemus    
    
  def vaatamineHTML(self, REQUEST):
     "Lahenduse vaatamine"     
     return self.tegelikHTML(REQUEST)
     
  security.declareProtected(perm_manage, 'pakutud')
  def pakutud(self):
        """ pakutud vastus """
        return self.pakutudAndmed
    
  def pakutudHTML(self, REQUEST=None, vastus=0):
        "Pakutud andmete esitus veebis"
        if vastus==0:
          vastus=self.pakutudAndmed
        return strip_tags(vastus[3])
          
  def automaatPunkte(self):
    "Automaatselt arvutatav punktide arv"
    self.paigutaPakutudAndmed()
    if (not hasattr(self, 'arvutusTyyp')) or self.arvutusTyyp==0:
     if self.kasPihtas():
      return self.normPunktid
     else:
      return 0
    if self.arvutusTyyp==1: #lineaar
      return self.kuidasPihtas()*self.normPunktid
     
    
  def kasPihtas(self):
    "Pihtasarvutus"
    self.kysitav=int(self.kysitav)
    if self.kysitav==0:
      return self.kasPaiknebVahemikus(self.pakutudAndmed[3], self.leiaProtsent(), float(self.vastuseTapsusProtsent))
    if self.kysitav==1:
      return self.kasPaiknebVahemikus(self.pakutudAndmed[3], float(self.lahustiKogus), float(self.vastuseTapsusProtsent))
    if self.kysitav==2:
      return self.kasPaiknebVahemikus(self.pakutudAndmed[3], float(self.aineKogus), float(self.vastuseTapsusProtsent))
    if self.kysitav==3:
      return (self.kasPaiknebVahemikus(self.pakutudAndmed[3], 100*float(self.aineKogus)/float(self.lahustiKogus), self.vastuseTapsusProtsent))
    return "probleem"      
         
    
  def kuidasPihtas(self):
    "Keskelt maksimumpunktidega lineaarne vahemik"
    self.kysitav=int(self.kysitav)
    if self.kysitav==0:
      return self.lineaarProtsentSuhe(self.pakutudAndmed[3], self.leiaProtsent(), float(self.vastuseTapsusProtsent))
    if self.kysitav==1:
      return self.lineaarProtsentSuhe(self.pakutudAndmed[3], float(self.lahustiKogus), float(self.vastuseTapsusProtsent))
    if self.kysitav==2:
      return self.lineaarProtsentSuhe(self.pakutudAndmed[3], float(self.aineKogus), float(self.vastuseTapsusProtsent))
    if self.kysitav==3:
      return (self.lineaarProtsentSuhe(self.pakutudAndmed[3], 100*float(self.aineKogus)/float(self.lahustiKogus), self.vastuseTapsusProtsent))
    return "probleem"      
         
      

  def vastuseMuutmisVorm(self, REQUEST):
    "zpt vorm"
    return self.qtChangeFormPercentExercise(REQUEST)


  def vastuseMuutmisLeht(self, REQUEST, vastus):
     "Andmete talletus"
     import re
     try:
       self.aineAlamPiir=float(re.sub(',', '.', vastus[0]))
       self.aineYlemPiir=float(re.sub(',', '.',vastus[1]))    
       self.lahustiAlamPiir=float(re.sub(',', '.',vastus[2]))
       self.lahustiYlemPiir=float(re.sub(',', '.',vastus[3]))
       self.aineTekst=vastus[4]
       self.aineYhik=vastus[5]
       self.lahustiTekst=vastus[6]
       self.lahustiYhik=vastus[7]
       self.vastuseTapsusProtsent=float(re.sub(',', '.',vastus[8]))
       self.kysitav=int(vastus[9])
       if hasattr(REQUEST, "arvutusTyyp"):
         self.arvutusTyyp=int(REQUEST["arvutusTyyp"])
     except:
       return translate(self, "Problem with data", target=self.giveLanguage(REQUEST))
     return ""


     
  def koopia(self):
    "Koopia ülesandest"
    t=ProtsentYlesanne(self.kysimus)
    t.aineAlamPiir=self.aineAlamPiir
    t.aineYlemPiir=self.aineYlemPiir
    t.lahustiAlamPiir=self.lahustiAlamPiir
    t.lahustiYlemPiir=self.lahustiYlemPiir
    t.aineTekst=self.aineTekst
    t.aineYhik=self.aineYhik
    t.lahustiTekst=self.lahustiTekst
    t.lahustiYhik=self.lahustiYhik
    t.vastuseTapsusProtsent=self.vastuseTapsusProtsent
    t.kysitav=self.kysitav
    t.arvutusTyyp=self.arvutusTyyp
    t.normPunktid=self.normPunktid
    t.kirjeldavTekst=self.kirjeldavTekst
    return t



class VastavusYlesanne(YlAlus):
    "Variantide kokkusobitamine"
    meta_type="VastavusYlesanne"
    security=ClassSecurityInfo()
    security.declareObjectPublic()

    def __init__(self, uuskysimus):
        "Loomine"
        self.kysimus=uuskysimus
        self.kysimused=[]
        self.vastused=[]
        self.jarjestus=[]
        
    def ylesandeNimetus(self, REQUEST=None):
        "ylesande tyybi nimi"
        return "Matching"
        
    def taitmineHTML(self, REQUEST, elemendinimi):
        "Lahendaja sisestus"
        if not self.kasLubatudLahendada(REQUEST):
                return ":-("
        tulemus="<table>"
        for i in range(len(self.kysimused)):
          tulemus=tulemus+"<tr><td>"+self.kysimused[i]+"</td><td>"
          tulemus=tulemus+"<select name='"+elemendinimi+"'>"
          tulemus += "<option value=\"\"></option>"
          for j in range(len(self.vastused)):
            tulemus=tulemus+"<option value='"+str(j)+"'>"+self.vastused[j]+"</option>\n"
          tulemus=tulemus+"</select></td></tr>"
        tulemus=tulemus+"</table>"
        return tulemus

    def tegelikHTML(self, REQUEST):
        "õpetaja lahendus"
        tulemus="<table>"
        for i in range(len(self.kysimused)):
          tulemus=tulemus+"<tr><td>"+self.kysimused[i]+\
            "</td><td>"+self.vastused[i]+"</td></tr>"
        tulemus=tulemus+"</table>"
        return tulemus
        
    def vaatamineHTML(self, REQUEST):
        "Koostaja poolt lahenduse vaatamine"
        return self.tegelikHTML(REQUEST)
    
    security.declareProtected(perm_manage, 'pakutud')
    def pakutud(self):
        """ pakutud vastus """
        return self.pakutudAndmed
    
    def pakutudHTML(self, REQUEST=None, vastus=0):
       "Pakutud andmete esitus veebis"
       if vastus==0:
         vastus=self.pakutudAndmed
       tulemus=""
       tulemus=tulemus+"<table>"
       for i in range(len(self.kysimused)):
           tulemus += "<tr><td>"+self.kysimused[i]+"</td><td>"
           try:
               tulemus += self.vastused[int(vastus[i])]
           except ValueError:
               pass
           tulemus += "</td></tr>\n"
       tulemus=tulemus+"</table>"
       return tulemus
       
    def vastuseMuutmisVorm(self, REQUEST=None):
       "zpt-vorm"
       return self.qtChangeFormMatchingExercise(REQUEST)   
       
    def vastuseMuutmisLeht(self, REQUEST, vastus=None):
        "Vastuse salvestamine, üle kaetud"
        if REQUEST is None: return
        if hasattr(REQUEST, 'kys'):
          kys=getattr(REQUEST, 'kys')
        else:
          kys=()
        if vastus is None:
          vastus=()
        if type(vastus) is types.StringType:
          vastus=(vastus,) 
        if type(kys) is types.StringType:
          vastus=(kys,) 
        self.kysimused=[]
        self.vastused=[]
        self.jarjestus=[]
#        for x in kys:
#          self.kysimused.append(x)
#        for x in vastus:
#          self.vastused.append(x)
        for i in range(len(kys)):
          if len(kys[i])>0:
            self.kysimused.append(kys[i])
            self.vastused.append(vastus[i])
        for i in range(len(self.kysimused)):
          self.jarjestus.append(i)
        import random
        random.shuffle(self.jarjestus)
        if not self.kysimused:
          translate(self, 'No pairs given', target=self.giveLanguage(REQUEST))
        return ""
    
    def automaatPunkte(self):
        """ Automaatne punktide arv """
        kokku=0
        for i in range(len(self.kysimused)):
            chosen = 0
            try:
                chosen = int(self.pakutudAndmed[i])
            except ValueError:
                continue
            if self.kysimused[i]==self.kysimused[int(chosen)]:
                kokku=kokku+1
        if len(self.kysimused)==0:
            return self.normPunktid
        return float(kokku)/float(len(self.kysimused))*self.normPunktid
       
    def kirjutaYlesanneTekstiks(self, testinimi="test", nr=1):
        "Väljastatakse andmed tekstina"
        if not self.kasLubatudLahendada(REQUEST):
           return ":­("
        tulemus=":TYPE:M:long:long:E:1\n"
        tulemus=tulemus+":TITLE:%s (%s)\n" % (testinimi, nr)
        tulemus=tulemus+":CAT:%s\n" % testinimi
        tulemus=tulemus+":QUESTION:H\n%s\n" % self.kysimus
        for i in range(len(self.kysimused)):
          tulemus=tulemus+":L"+str(i+1)+"\n"+self.kysimused[i]+"\n:R"+\
           str(i+1)+"\n"+self.vastused[i]+"\n"
        return tulemus
    
    def loeTekstistYlesanne(self, reamassiiv):
        "Loeb andmed tekstist"
        self.kysimused=[]
        self.vastused=[]
        self.jarjestus=[]
        nr=0
        for i in range(len(reamassiiv)):
          if reamassiiv[i].split(":")[1]=="QUESTION":
            self.kysimus=reamassiiv[i+1]
          if reamassiiv[i].split(":")[1][0]=="L":
            self.kysimused.append(reamassiiv[i+1])
            self.vastused.append(reamassiiv[i+3])
        for i in range(len(self.kysimused)):
          self.jarjestus.append(i)
        import random
        random.shuffle(self.jarjestus)
        
    
    def koopia(self):
       "Koopia ylesandest"
       t=VastavusYlesanne(self.kysimus)
       for x in self.kysimused:
         t.kysimused.append(x)
       for x in self.vastused:
         t.vastused.append(x)
       for x in self.jarjestus:
         t.jarjestus.append(x)
       t.normPunktid=self.normPunktid
       t.kirjeldavTekst=self.kirjeldavTekst
       return t