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 add_dtml
import YlTest
#from YlTest import asendaHTML
#import TestiYlesanne
#from TestiYlesanne import TestiYlesanne
from YlAlus import YlAlus


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):
         "Ülesande tüübi nimi"
         self.get_lang(('ivatests',), REQUEST)
         return REQUEST['L_it_check_exercise']
         
            
    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"
        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)
          
    def pakutudHTML(self, REQUEST):
       "Pakutud andmete esitus veebis"
       self.get_lang(('ivatests',),REQUEST)
       if self.vastusPakutud:
        if self.pakutudAndmed=="on":
          return "+"
        else:
          return "-"
       else:
        return REQUEST['L_it_no_saved_answer']

    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 self.vastus:
           olek=" CHECKED "
        return "<input type='checkbox' name='vastus' "+olek+"/>"
        
    def vastuseMuutmisLeht(self, vastus):
        "Vastuse salvestamine, üle kaetud"
        if vastus is not None:
          self.vastus=1
        else:
          self.vastus=0
          
    def koopia(self):
       "Koopia ülesandest"
       t=ValikYlesanne(self.kysimus, self.vastus)
       t.id=self.id
       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):
        "Ülesande tüübi nimi"
        self.get_lang(('ivatests',), REQUEST)
        return REQUEST['L_it_text_answer_exercise']                    
        
    def taitmineHTML(self, REQUEST, elemendinimi):
        "Vastuse sisestamise koht"
        return "<textarea name='%s' /></textarea>" % elemendinimi
        
    def vaatamineHTML(self, REQUEST):
        "Koostaja poolt lahenduskoha vaatamine"
        return "..."
          
    def pakutudHTML(self, REQUEST):
        "Pakutud andmete esitus veebis"
        self.get_lang(('ivatests',), REQUEST)
        if self.vastusPakutud:
          import YlTest
          return YlTest.asendaHTML(str(self.pakutudAndmed))
        else:
          return REQUEST['L_it_no_answer_text']
          
    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
       return t
       
Globals.InitializeClass(TekstivastusegaYlesanne)    


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

    def __init__(self, uuskysimus):
        "Loomine"
        self.kysimus=uuskysimus
        self.variandid=[]
        
    def ylesandeNimetus(self, REQUEST):
        "Nimetus"
        self.get_lang(('ivatests',),REQUEST)
#        return "OVYl"
        return REQUEST['L_it_one_answer']
        
    def loeTekstistYlesanne(self, reamassiiv):
        "Loeb andmed tekstist"
        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"
        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"
       import YlTest
       tulemus="<ul>"
       for x in self.variandid:
         tulemus=tulemus+"\n<li>"+YlTest.asendaHTML(x)+"</li>"
       tulemus=tulemus+"</ul>"
       return tulemus
       
    def vaatamineHTML(self, REQUEST):
       "Lahenduse vaatamine"
       return self.tegelikHTML(REQUEST)
 

    def pakutudHTML(self, REQUEST):
        "Pakutud andmete esitus veebis"
        if self.vastusPakutud:
          return YlTest.asendaHTML(self.pakutudAndmed)

    def vastuseMuutmisVorm(self, REQUEST):
        "Üle kaetud, lubab muuta variante ja vastust"
        import YlTest
        tulemus=REQUEST['L_it_correct_answers']+"<table>"
        for i in range(len(self.variandid)):
          tulemus=tulemus+"\n<tr>"+\
            "<td><input type='text' name='vastus' value='"+YlTest.asendaHTML(self.variandid[i])+"'></td></tr>"
        tulemus=tulemus+"<tr><td><input type='text' name='vastus' /></td></tr>"
        if len(self.variandid)==0:
          tulemus=tulemus+"<tr><td><input type='text' name='vastus' /></td></tr>"

        tulemus=tulemus+"</table>"
        return tulemus
        
    def vastuseMuutmisLeht(self, vastus):
        "Vastuse salvestamine, üle kaetud, kutsutakse muutmisLehelt"
        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])
#        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
       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):
        "Ülesande tüübi nimi"
        self.get_lang(('ivatests',), REQUEST)
        return REQUEST['L_it_multiple_choice_exercise']
                               
        
        
    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"
        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"
        import YlTest
        self.get_lang(('ivatests',), REQUEST)
        tulemus="<table>"
        if len(self.valikud)>0:
         for i in range(len(self.valikud)):
          tulemus=tulemus+"\n<tr>"+\
            "<td>"+YlTest.asendaHTML(self.valikud[i])+"</td>"+\
            "<td><input type='checkbox' name='"+elemendinimi+"' "+\
            "value='"+str(i)+"'></td></tr>"
         tulemus=tulemus+"</table>"
        else:
         tulemus=REQUEST['L_it_no_choices']
        return tulemus
        
    def tegelikHTML(self, REQUEST):
       "Opetaja pakutu"
       tulemus=""
       for i in range(len(self.valikud)):
         tulemus=tulemus+self.valikud[i]+" "
         if i in self.oigedValikud:
           tulemus=tulemus+"+"
         else:
           tulemus=tulemus+"-"
         tulemus=tulemus+"<br />"
       return tulemus
       
       if len(self.oigedValikud)==0:
         return "Lahendus puudub"
       else:
         tulemus=""
         for x in self.oigedValikud:
           tulemus=tulemus+self.valikud[x]+"<br />"
         return tulemus
        
    def vaatamineHTML(self, REQUEST):
        "Koostaja poolt lahenduskoha vaatamine"
        import YlTest
        self.get_lang(('ivatests',), REQUEST)
        tulemus=""
        if len(self.valikud)>0:
          tulemus=tulemus+"<ul>"
          for i in range(len(self.valikud)):
           try:           
            tulemus=tulemus+"\n<li>"+YlTest.asendaHTML(self.valikud[i])+" &nbsp; "+YlTest.asendaHTML(self.selgitused[i])+"</li>"
           except Exception, teade:
            tulemus=tulemus+str(teade)
          tulemus=tulemus+"</ul>"
        else:
          tulemus=REQUEST["L_it_no_choices_in_viewing"]
        return tulemus
        
        
    def pakutudHTML(self, REQUEST):
        "Pakutud andmete esitus veebis"
        self.get_lang(('ivatests',), REQUEST)
        if self.vastusPakutud:
          if self.pakutudAndmed is None:
            return "Vastus valimata"
          try:
            tulemus=""
            for x in self.pakutudAndmed:
              tulemus=tulemus+YlTest.asendaHTML(self.valikud[int(x)])+"<br />"            
            return tulemus
          except:
            return REQUEST['L_it_problem_with_data']          

    def kasPihtasArvutus(self):
        "Ylekate"
        return 0

    def vastuseMuutmisVorm(self, REQUEST):
        "Üle kaetud, lubab muuta variante ja vastust"
        import YlTest
        tulemus="<table>"
        for i in range(len(self.valikud)):
          margitud=""
          if i in self.oigedValikud:
            margitud="CHECKED"
          selgitustekst=""
          if i < len(self.selgitused):
            selgitustekst=YlTest.asendaHTML(self.selgitused[i])
          tulemus=tulemus+"\n<tr>"+\
            "<td><input type='text' name='vastus' value='"+YlTest.asendaHTML(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>"
        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

    def automaatPunkte(self):
      "Automaatne punktiarvutus"
#      return self.oigedValikud
      if not self.vastusPakutud: return 0
      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
       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.oigeValik=-1
        
    def ylesandeNimetus(self, REQUEST):
         "Ülesande tüübi nimi"
         self.get_lang(('ivatests',), REQUEST)
         return REQUEST['L_it_one_answer_exercise']

        
        
    def taitmineHTML(self, REQUEST, elemendinimi):
        "Vastuse sisestamise koht"
        import YlTest
        tulemus="<table>"
        if len(self.valikud)>0:
         for i in range(len(self.valikud)):
          tulemus=tulemus+"\n<tr>"+\
            "<td>"+YlTest.asendaHTML(self.valikud[i])+"</td>"+\
            "<td><input type='radio' name='"+elemendinimi+"' "+\
            "value='"+str(i)+"'></td></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 x in self.valikud:
            tulemus=tulemus+"\n<li>"+YlTest.asendaHTML(x)+"</li>"
          tulemus=tulemus+"</ul>"
        else:
          tulemus="Valikud puuduvad"
        return tulemus
        
        
    def pakutudHTML(self, REQUEST):
        "Pakutud andmete esitus veebis"
        if self.vastusPakutud:
          if self.pakutudAndmed is None:
            return "Vastus valimata"
          try:
            return YlTest.asendaHTML(self.valikud[int(self.pakutudAndmed)])
          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 vastuseMuutmisVorm(self, REQUEST):
        "Üle kaetud, lubab muuta variante ja vastust"
        import YlTest
        tulemus="<table><tr><td>Variandid</td><td>õige</td></tr>"
        for i in range(len(self.valikud)):
          margitud=""
          if i==self.oigeValik:
            margitud="CHECKED"
          tulemus=tulemus+"\n<tr>"+\
            "<td><input type='text' name='vastus' value='"+YlTest.asendaHTML(self.valikud[i])+"'></td>"+\
            "<td><input type='radio' name='valikunr' "+\
            "value='"+str(i)+"' "+margitud+"></td></tr>"
        tulemus=tulemus+"\n<tr><td><input type='text' name='vastus' /></td>"+\
                "<td><input type='radio' name='valikunr' value='"+str(len(self.valikud))+"'></td></tr>"
        if len(self.valikud)==0:
          tulemus=tulemus+"<tr><td><input type='text' name='vastus' /></td>"+\
                "<td><input type='radio' name='valikunr' value='1'></td></tr>"
        tulemus=tulemus+"</table>"
        return tulemus
        
    def muutmisLeht(self, REQUEST=None, kysimus="", vastus="", valikunr=-1):
        "Vastuse salvestamine, üle kaetud"
        self.kysimus=kysimus 
        if vastus is None:
          vastus=()
        if type(vastus) is types.StringType:
          vastus=(vastus,) 
        valikunr=int(valikunr)         
        self.valikud=[]
        for i in range(len(vastus)):
          if len(vastus[i])>0:
            self.valikud.append(vastus[i])
          else:
            if valikunr==i:
              valikunr=-1
            if valikunr>i:
              valikunr=valikunr-1
        self.oigeValik=valikunr
        REQUEST.RESPONSE.redirect('muutmisVorm')
          
    def koopia(self):
       "Koopia ülesandest"
       t=YksikvalikYlesanne(self.kysimus)
       for x in self.valikud:
         t.valikud.append(x)
       t.oigeValik=self.oigeValik
       t.id=self.id
       return t

Globals.InitializeClass(YksikvalikYlesanne)

class ArvuvahemikuliseVastusegaYlesanne(YlAlus):
  "Vajab arvulist vastust soovitud piirkonnas"
  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):
     "Tüübinimi kasutajale"
     return "Arvulise vastusega ülesanne"

  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)
 

  def pakutudHTML(self, REQUEST):
        "Pakutud andmete esitus veebis"
        if self.vastusPakutud:
          return YlTest.asendaHTML(self.pakutudAndmed)
 
  def vastuseMuutmisVorm(self, REQUEST):
      "muutmisvorm"
      tulemus="<table>"
      tulemus=tulemus+"<tr><td>Alampiir</td>"+\
        "<td><input type='text' name='vastus' value='"+str(self.alamPiir)+"'/></td></tr>"             
      tulemus=tulemus+"<tr><td>Kesk</td>"+\
        "<td><input type='text' name='vastus' value='"+str(self.oigeVastus)+"'/></td></tr>"
      tulemus=tulemus+"<tr><td>Ylempiir</td>"+\
        "<td><input type='text' name='vastus' value='"+str(self.ylemPiir)+"'/></td></tr>"
      tyybimargised=["", ""]
      tyybimargised[self.arvutusTyyp]=" selected "
      
      tulemus=tulemus+"<tr><td>Arvutustyyp</td>"+\
        """
          <select name="arvutusTyyp">
            <option value="0" %s >Vahemik</option>
            <option value="1" %s >Lineaar</option>
          </select>
         </td></tr>
        """ % (tyybimargised[0], tyybimargised[1])
      tulemus=tulemus+"</table>"
      return tulemus
     
  def vastuseMuutmisLeht(self, REQUEST, vastus):
     "Salvestus"
     if type(vastus) is None: return "Vigane vastus"
     if len(vastus)!=3: return "Pole piirid paigas"
     self.alamPiir=int(vastus[0])
     self.oigeVastus=int(vastus[1])
     self.ylemPiir=int(vastus[2])
     if hasattr(REQUEST, "arvutusTyyp"):
       self.arvutusTyyp=int(REQUEST["arvutusTyyp"])

  def koopia(self):
     "Koopia"
     t=ArvuvahemikuliseVastusegaYlesanne(self.kysimus)
     t.alamPiir=self.alamPiir
     t.ylemPiir=self.ylemPiir
     t.oigeVastus=self.oigeVastus
     t.arvutusTyyp=self.arvutusTyyp
     return t