import AccessControl
import OFS, Globals
from OFS import SimpleItem
import types
import time
from TraversableWrapper import Traversable
from Globals import Persistent
from AccessControl import ClassSecurityInfo
from Cruft import Cruft
from common import add_dtml
#import TestiYlesanne
import YlVahendus
from YlVahendus import YlVahendus
#from TestiYlesanne import TestiYlesanne
     
        
                   
class YlTest(
     OFS.Folder.Folder,
     OFS.SimpleItem.Item,
     Persistent,
     AccessControl.Role.RoleManager,
     Traversable,
     Cruft
     ):
    "Ülesannetest koosnev test"
    meta_type='YlTest'
    pealkiri=""
    nr=0
    avatudTaitmiseks=0
    juhuslikJarjekord=0
    
    security=ClassSecurityInfo()
    security.declareObjectPublic()
    
    
    def __init__(self):
       "Alustus"
       self.koigiLuba=LahendusLuba()
       self.koigiLuba.id='koigiLuba'
       self.grupiLoad=LahendusLoad()
       self.grupiLoad.id='grupiLoad'
       self.isikuLoad=LahendusLoad()
       self.isikuLoad.id='isikuLoad'
       self.vahendus=YlVahendus()
       self.vahendus.id='vahendus'
      
    def lisaYlesanne(self, yl):
       "uus ülesanne testis"
       if yl is None: return
       self.nr=self.nr+1
       yl.id="yl"+str(self.nr)
       tulem = self._setObject(yl.id, yl)
       return tulem 
       
    def lisaYlesanded(self, ylmassiiv):
       "Lisatakse ülesannete massiiv"
       for x in ylmassiiv:
         self.lisaYlesanne(x)
         
    def ylesandedTekstina(self):
       "Väljastab ülesanded HotPotatos ekspordina"
       tulemus=""
       yl=self.ylesanded()
       for i in range(len(yl)):
         tulemus=tulemus+yl[i].kirjutaYlesanneTekstiks(self.pealkiri, i+1)
       return tulemus
       
    def kysimused(self):
       "Küsimuste loetelu"
       k=[]
       for x in self.ylesanded():
         k.append(x.kysimus)
       return k
       
    def ylesanded(self):
       "Ülesannete loetelu"
       return self.objectValues()
     
    def annaPealkiri(self):
       "Testi nimi"
       try:
         if len(self.pealkiri)>0:
           return self.pealkiri    
         return self.getId()
       except:
         return self.getId()
         
    def pealkiriHTML(self, REQUEST):
       "Pealkiri HTMLina"
       return asendaHTML(self.annaPealkiri())

    def pealkirjaEsitlus(self, REQUEST):
       "Nimi menüüs"
       if self.pealkiriHTML(REQUEST)!="":
         return self.pealkiriHTML(REQUEST)
       else:
         return self.getId()
         
    def seaPealkiri(self, pealkiri):
       "Pealkirja salvestus"
       self.pealkiri=pealkiri
       
    def pealkirjaMuutmisVormHTML(self, REQUEST, liikumisURL):
       "Leht pealkirja muutuse sisestuseks"
       tulemus=leheAlgus(self, REQUEST)
       tulemus=tulemus+self.pealkirjaMuutmisVorm(REQUEST, liikumisURL)
       tulemus=tulemus+leheLopp(self, REQUEST)
       return tulemus
       
    def pealkirjaMuutmisVorm(self, REQUEST, liikumisURL=""):
       "Vorm pealkirja muutmiseks"
       self.get_lang(('ivatests',), REQUEST)
       return "<form action='pealkirjaMuutmisLeht'>"\
         "<input type='text' name='pealkiri' value='"+self.annaPealkiri()+"' />"+\
         "<input type='submit' value='"+REQUEST['L_it_save_title']+"' />"+\
         "<input type='hidden' name='liikumisURL' value="+liikumisURL+">"+\
         "</form>"
         
    def pealkirjaMuutmisLeht(self, REQUEST, pealkiri, liikumisURL=""):
       "Pealkirja salvestus"
       self.seaPealkiri(pealkiri)
       if liikumisURL=='':
         liikumisURL='ylesandedMuutmisTabelina';
#       REQUEST.RESPONSE.redirect('ylesandedMuutmisTabelina')
       REQUEST.RESPONSE.redirect(liikumisURL)
     
       
       
    def ylesanneteArv(self):
       "Ülesannete arv"
       return len(self.ylesanded())
       
    def tutvustus(self):
       "Testi tutvutus"
       return "Lahendamiseks mõeldud test"
       
    def kasKysimusteJuhuslikJarjekord(self):
       "Kas lahendamisel järjestatakse küsimused juhuslikult"
       if hasattr(self, 'juhuslikJarjekord'):
         return self.juhuslikJarjekord
       return 0
       
    def seaKysimusteJuhuslikJarjekord(self, jarjekord):
       "Muutuja seadmine"
       if jarjekord:
         self.juhuslikJarjekord=1
       else:
         self.juhuslikJarjekord=0
       return str(self.juhuslikJarjekord)
       
    def muudaKysimusteJuhuslikJarjekord(self):
      "Järjekorra muutmine"
      if self.kasKysimusteJuhuslikJarjekord():
        self.seaKysimusteJuhuslikJarjekord(0)
      else:
        self.seaKysimusteJuhuslikJarjekord(1)
      return str(self.kasKysimusteJuhuslikJarjekord())
        

    def kasLubatudLahendada(self, REQUEST):
      "Arvutus lubade kaudu"
      try:
       if self.kasAvatudTaitmiseks()==1: return 1
       n=self.lahendusKordadeArv(REQUEST)
       if self.koigiLuba.kasLubatudLahendada(REQUEST, n):return 1
       if hasattr(self.isikuLoad, str(REQUEST.AUTHENTICATED_USER)):
         if getattr(self.isikuLoad, str(REQUEST.AUTHENTICATED_USER)).kasLubatudLahendada(REQUEST, n):
           return 1
       for x in self.find_course().sisegrupid.objectValues():
         m=x.get_local_roles()
         leitud=0
         for t in m:
          if t[0]==str(REQUEST.AUTHENTICATED_USER):
            leitud=1
         if leitud:
           try:
            if hasattr(self.grupiLoad, x.id):
             if getattr(self.grupiLoad, x.id).kasLubatudLahendada(REQUEST, n):
                return 1
           except:
             pass
       return 0
      except:
       return 1
        
    def kasLubatudLahendadaTekst(self, REQUEST):
      "Abifunktsioon"
      return str(self.kasLubatudLahendada(REQUEST))
       
    def lubadeViited(self, REQUEST):
       "Viited lubadele"
       self.get_lang(('ivatests',), REQUEST)
       tulemus=leheAlgus(self, REQUEST)+"<h3>"+REQUEST['L_it_description_of_permissions']+"</h3><form action='lubadeKustutusLeht'><ul>"
       tulemus=tulemus+"<li>"
       if self.avatudTaitmiseks==1:
         tulemus=tulemus+"<input type='checkbox' name='chkavatudtaitmiseks' /> "
       else:
         tulemus=tulemus+"<a href='lubaKoigileTaita'>"+REQUEST["L_it_open_test"]+"</a>"
       tulemus=tulemus+REQUEST["L_it_opened_for_all"]+": "
       if self.avatudTaitmiseks==1:
         tulemus=tulemus+" + "
       else:
         tulemus=tulemus+" - "
       tulemus=tulemus+"</li>"
       tulemus=tulemus+"<li>"
       if self.koigiLuba.algusAeg!=-1:
         tulemus=tulemus+"<input type='checkbox' name='chkkoigiluba' />"
       tulemus=tulemus+"<a href='koigiLuba'>"+REQUEST['L_it_all_permission']+"</a>"+\
         self.koigiLuba.loaAndmedTekstina(REQUEST)+"</li>"+\
         "<li>"+REQUEST['L_it_inner_groups_permission']
       if self.kasLeidubLoataGruppe():
         tulemus=tulemus+", <a href='grupiLubadeLisamisVorm'>"+REQUEST["L_it_add_group_permission"]+"</a>"
       tulemus=tulemus+"</li><ul>"
       for x in self.grupiLoad.objectValues():
         tulemus=tulemus+"\n<li><input type='checkbox' name='grupp"+x.id+"' /><a href='"+x.absolute_url()+"'>"+x.id+"</a>"+x.loaAndmedTekstina(REQUEST)+"</li>"
       tulemus=tulemus+"</ul><li>"+REQUEST['L_it_user_permission']
       if self.kasLeidubLoataIsikuid():
         tulemus=tulemus+", <a href='isikuLubadeLisamisVorm'>"+REQUEST["L_it_add_personal_permission"]+"</a>"	
       tulemus=tulemus+"</li><ul>"
       for x in self.isikuLoad.objectValues():
         tulemus=tulemus+"\n<li><input type='checkbox' name='isik"+x.id+"' /><a href='"+x.absolute_url()+"'>"+x.id+"</a>"+x.loaAndmedTekstina(REQUEST)+"</li>"
       tulemus=tulemus+"</ul><input type='submit' value='"+REQUEST["L_it_delete_permission"]+"' /></form>"+leheLopp(self, REQUEST)
       return tulemus
       
    def lubadeKustutusLeht(self, REQUEST):
      "Lubade eemaldamine"
      if hasattr(REQUEST, 'chkavatudtaitmiseks'):
         self.avatudTaitmiseks=0
      if hasattr(REQUEST, 'chkkoigiluba'):
         self.koigiLuba.algusAeg=-1
      for x in self.isikuLoad.nimedeLoetelu():
        if hasattr(REQUEST, 'isik'+x):
          self.isikuLoad._delObject(x)
      for x in self.grupiLoad.nimedeLoetelu():
        if hasattr(REQUEST, 'grupp'+x):
          self.grupiLoad._delObject(x)
      REQUEST.RESPONSE.redirect('lubadeViited')
      
    def lubaKoigileTaita(self, REQUEST):
       "Õigus pidevalt täita"
       self.seaAvatudTaitmiseks(1, REQUEST)
       REQUEST.RESPONSE.redirect('lubadeViited')
        
       
    def kasLeidubLoataIsikuid(self):
       "jah/ei"
       return len(self.find_course().get_all_users_id())>len(self.isikuLoad.nimedeLoetelu())
              
    def isikuLubadeLisamisVorm(self, REQUEST):
       "Valida, kellel lubada"
       self.get_lang(('ivatests',),REQUEST)
       tulemus=leheAlgus(self, REQUEST)+"<form action='isikuLubadeLisamisLeht'>"
       isikud=self.find_course().get_all_users_id()
       loagaIsikud=self.isikuLoad.nimedeLoetelu()
       kogus=0
       for x in isikud:
          if x not in loagaIsikud:
            kogus=kogus+1
            tulemus=tulemus+"<br />\n<input type='checkbox' name='nimed' value='"+x+"'/>"+x               
       if kogus>0:
         tulemus=tulemus+"<br /><input type='submit' value='"+REQUEST['L_it_add_user_permission']+"' />"
       else:
         tulemus=tulemus+REQUEST["L_it_no_users_without_permission"]
       return tulemus+"</form>"+leheLopp(self, REQUEST)
       
    def isikuLubadeLisamisLeht(self, REQUEST, nimed=None):
       "Nimede salvestus"
       if nimed is not None:
         if type(nimed) is types.StringType:
           nimed=(nimed,)
         for x in nimed:
           luba=LahendusLuba()
           luba.id=x
           self.isikuLoad._setObject(luba.id, luba)       
       REQUEST.RESPONSE.redirect('lubadeViited')
       
    def kasLeidubLoataGruppe(self):
       "jah/ei"
       return len(self.find_course().sisegrupid.objectValues())>len(self.grupiLoad.nimedeLoetelu())
       
    def grupiLubadeLisamisVorm(self, REQUEST):
       "Valida, kellel lubada"
       self.get_lang(('ivatests',), REQUEST)
       tulemus=leheAlgus(self, REQUEST)
       if self.kasLeidubLoataGruppe():
        tulemus=tulemus+"<form action='grupiLubadeLisamisLeht'>"
        grupid=self.find_course().sisegrupid.objectValues()
        loagaGrupid=self.grupiLoad.nimedeLoetelu()
        for x in grupid:
          if x.id not in loagaGrupid:
            tulemus=tulemus+"<br />\n<input type='checkbox' name='nimed' value='"+str(x.id)+"'/>"+str(x.id)               
        tulemus=tulemus+"<br /><input type='submit' value='"+REQUEST['L_it_add_group_permission']+"' />"
        tulemus= tulemus+"</form>"
       else:
        tulemus=tulemus+REQUEST["L_it_no_groups_without_permission"]
       tulemus=tulemus+leheLopp(self, REQUEST)
       return tulemus
       
    def grupiLubadeLisamisLeht(self, REQUEST, nimed=None):
       "Lahendusloa lisamine grupile"
       if nimed is not None:
         if type(nimed) is types.StringType:
           nimed=(nimed,)
         for x in nimed:
           luba=LahendusLuba()
           luba.id=x
           self.grupiLoad._setObject(luba.id, luba)       
       REQUEST.RESPONSE.redirect('lubadeViited')
       
       
    def kustutaLahendusload(self):
       "Kustutatakse lahendusload"
       self.grupiLoad.kustutaKoikLoad()
       self.isikuLoad.kustutaKoikLoad()
       self.koigiLuba.algusAeg=-1
       self.koigiLuba.loppAeg=-1
       self.koigiLuba.kordadeArv=-1
       
    def kasLeidubLubasid(self):
      "Lubade olemasolu otsing"
      if len(self.grupiLoad.objectValues())>0: return 1
      if len(self.isikuLoad.objectValues())>0: return 1
      if self.koigiLuba.algusAeg!=-1: return 1
      return 0
      
      
    def taitmisAvatusSymbol(self):
      "Sümbol vastavalt ligipääsuseisundile"
      #self.get_lang(('ivatests',), sonad)
      if self.kasAvatudTaitmiseks()==1:
        #return sonad['L_it_qt_public']
	return "Avalik"
      if self.kasAvatudTaitmiseks()==2:
        #return sonad['L_it_qt_between']
	return "Limiidiga"
      return "Kinni"
      #return sonad['L_it_qt_closed']

    def kasAvatudTaitmiseks(self):
       "Teatab, kas opilastele on test nahtav"
       try:   
         if self.avatudTaitmiseks:
           return 1
         if self.kasLeidubLubasid(): return 2
         return 0
       except:
         return 0

    def seaAvatudTaitmiseks(self, seisund, REQUEST):
       "Saab oelda, kas avatud"
       if int(seisund)==1:
         self.avatudTaitmiseks=1
       else: 
         self.avatudTaitmiseks=0
         self.kustutaLahendusload()
       #return str(self.avatudTaitmiseks)
       REQUEST.RESPONSE.redirect('index_html')
       
    def muudaAvatudTaitmiseks(self, REQUEST):
       "Vahetab seisundi"
       if self.avatudTaitmiseks==1:
         self.seaAvatudTaitmiseks(0, REQUEST)
       else:
         self.seaAvatudTaitmiseks(1, REQUEST)
       
    def ylesanneteTyypideLoetelu(self, REQUEST):
        "Väljakutse"
        return leheAlgus(self, REQUEST)+self.vahendus.ylesanneteTyypideLoetelu(REQUEST)+leheLopp(self, REQUEST)
        
    def lisaUusYlesanne(self, REQUEST, tyyp):
        "Ülesande lisamine" 
        yl=self.vahendus.lisaUusYlesanne(REQUEST, tyyp)
        self.lisaYlesanne(yl)
        REQUEST.RESPONSE.redirect(self.absolute_url()+"/"+yl.id+"/muutmisVorm?liikumisURL="+self.absolute_url())

    def ylesandedTabelina(self, REQUEST):
        "Ülesanded tabelina"
        m=self.ylesanded()
        tulemus=leheAlgus(self, REQUEST)+self.pealkirjaEsitlus(REQUEST)+"<table>"
        for x in m:
          tulemus=tulemus+"\n<tr><td>"+x.esitlusHTML(REQUEST)+"<td>"+\
            "<td>"+x.vaatamineHTML(REQUEST)+"</td>"+\
            "<td>"+x.marksonadHTML(REQUEST)+"</td>"+\
            "<td>"+x.ylesanne.ylesandeNimetus(REQUEST)+"</td></tr>"
        tulemus=tulemus+"</table>"
        return tulemus+leheLopp(self, REQUEST)


    def ylesandedMuutmisTabelina(self, REQUEST):
        "Ülesanded koos viidetega kustutamiseks ja muutmiseks"
        self.get_lang(('ivatests',), REQUEST)
        tulemus=leheAlgus(self, REQUEST)+self.vahendus.ylesanneteTyybidValikuna(REQUEST) 
        if len(self.ylesanded())>0:        
         tulemus=tulemus+"<form action='kustuta_leht'><table>"+\
          "<tr><td>"+REQUEST['L_it_deletion']+"</td><td>"+REQUEST['L_it_question']+"</td><td>"+REQUEST['L_it_answer']+"</td><td>"+REQUEST['L_it_type']+"</td><td>"+REQUEST['L_it_points']+"</td><td>"+REQUEST['L_it_change']+"</td></tr>"
         for x in self.ylesanded():
          try:
           tulemus=tulemus+"\n<tr>"+\
            "<td><input type='checkbox' name='kustuta' value='"+x.id+"' />"+"</td>"+\
            "<td>"+x.esitlusHTML(REQUEST)+"</td>"+\
            "<td>"+x.vaatamineHTML(REQUEST)+"</td>"+\
            "<td>"+x.ylesandeNimetus(REQUEST)+"</td>"+\
            "<td>"+x.normPunktidHTML(REQUEST)+"</td>"+\
            "<td><a href='"+x.id+"/muutmisVorm?liikumisURL="+self.absolute_url()+"'>"+REQUEST['L_it_change']+"</a></td>"+\
            "</tr>"
          except:
           print "Vigane ülesanne"
         tulemus=tulemus+"</table><input type='submit' value='"+REQUEST['L_it_deletion']+"' /></form>"+\
           "\n<br />"
        return tulemus+leheLopp(self, REQUEST)
        


    def kustuta_leht(self, REQUEST, kustuta=None):
        "ülesannete kustutamise leht"
        if kustuta is None:
           kustuta=()
        if type(kustuta) is types.StringType:
           kustuta=(kustuta,)
        for x in kustuta:
           self._delObject(x)
        REQUEST.RESPONSE.redirect('ylesandedMuutmisTabelina')
        
    def ylTyyp(self, REQUEST, ylid):
       "Küsitud ID-ga ülesande tüüp"
       if hasattr(self, ylid):
         return self.ylid.ylesandeNimetus(REQUEST)
       return None

       
    def taidaVorm(self, REQUEST):
      "Täitmisvorm"
      self.get_lang(('ivatests',), REQUEST)
      tulemus=leheAlgus(self, REQUEST)+"<h3>"
      tulemus=tulemus+REQUEST['L_it_solving_test'] % self.pealkirjaEsitlus(REQUEST)
      tulemus=tulemus+"""</h3>
         <form action="loeAndmedLehelt" method="post">
           <table>
       """ 
      kirjutusyl=[]
      for x in self.ylesanded():
        kirjutusyl.append(x)
      if self.kasKysimusteJuhuslikJarjekord():
        import random
        random.shuffle(kirjutusyl)
      for x in kirjutusyl:  
            tulemus=tulemus+"\n<tr><td>"+x.esitlusHTML(REQUEST)+"</td>"+\
            "<td>"+x.taitmineHTML(REQUEST, x.id) + "</td></tr>"
      tulemus=tulemus+"""
               </table>
               <input type="submit" name='salvestusnupp' value="""+REQUEST['L_it_save_solved_test']+""" />
               </form>
               """
      return tulemus+leheLopp(self, REQUEST)
       
    def index_html(self, REQUEST):
       "Peegel veebi"
       if self.kas_opetaja(self, REQUEST):
         #return self.ylesandedMuutmisTabelina(REQUEST)
         REQUEST.RESPONSE.redirect(self.absolute_url()+"/ylesandedMuutmisTabelina")
       else:
         return self.taidaVorm(REQUEST)


    def loeAndmedLehelt(self, REQUEST):
        "Veebilt tulevad andmed talde"
        self.get_lang(('ivatests',), REQUEST)
        tulemus=""
        if not hasattr(REQUEST, 'salvestusnupp'):
          return leheAlgus(self, REQUEST)+\
            "Salvestamiseks vajuta nuppu. Mine tagasi ja taida edasi"+\
            leheLopp(self, REQUEST)
        t=TestiVastused()
        t.testinimi=self.id
        for x in self.ylesanded():
          vastus=None
          if hasattr(REQUEST, x.id):
            vastus=getattr(REQUEST, x.id)
          tulemus=tulemus+"!"+x.id+" "+str(vastus)
          t._setObject(x.id, x.salvestaPakutu(vastus))
        self.paigutaTestiVastus(REQUEST, t)
        return leheAlgus(self, REQUEST)+"<br /><b>"+REQUEST['L_it_answers_saved']+"</b>"+leheLopp(self, REQUEST)
        
  #  def salvestusAsukoht(self, REQUEST, testinimi='nimetu'):
  #     "Koht testi tulemuste salvestamiseks"
  #     kasutaja=getattr(getattr(self.fle_root().fle_users, str(REQUEST.AUTHENTICATED_USER)).webtop, 'wt5')
  #     if not hasattr(kasutaja, 'testid'):
  #        kasutaja.manage_addProduct['OFSP'].manage_addFolder('testid')
  #        #kasutaja._setObject('testid', TestiVastused())
  #     if not hasattr(kasutaja.testid, testinimi):
  #        kasutaja.testid.manage_addProduct['OFSP'].manage_addFolder(testinimi)
  #        testikataloog=getattr(kasutaja.testid, testinimi)
  #        testikataloog.variandinr=0
  #     testikataloog=getattr(kasutaja.testid, testinimi)
  #     #return self.get_url_to_object(testikataloog)
  #     return testikataloog
  

    def salvestusAsukoht(self, REQUEST, testinimi='nimetu'):
       "Koht testi tulemuste salvestamiseks"
       kasutajajuur=getattr(self.fle_root().fle_users,\
                   str(REQUEST.AUTHENTICATED_USER))
       try:
        kasutaja=getattr(kasutajajuur.webtop,\
          'c'+kasutajajuur.get_jooksev_kursus())
       except:
        kasutaja=kasutajajuur.webtop
       if not hasattr(kasutaja, 'testivastused'):
          kasutaja.manage_addProduct['OFSP'].manage_addFolder('testivastused')
          kasutaja.testivastused.id='testivastused'
       if not hasattr(kasutaja.testivastused.aq_self, testinimi):
          kasutaja.testivastused.manage_addProduct['OFSP'].manage_addFolder(testinimi)
          testikataloog=getattr(kasutaja.testivastused, testinimi)
          testikataloog.id=testinimi
          testikataloog.variandinr=0
       testikataloog=getattr(kasutaja.testivastused, testinimi)
       #return self.get_url_to_object(testikataloog)
       return testikataloog

    def paigutaTestiVastus(self, REQUEST, vastus):
       "Paigutab variandi uue id alla"
       self.get_lang(('ivatests',), REQUEST)
       k=self.salvestusAsukoht(REQUEST, vastus.testinimi)
       k.variandinr=k.variandinr+1
       vastus.id="variant"+str(k.variandinr)
       k._setObject(vastus.id, vastus)
       self.lisaSyndmus(REQUEST, 'testeLahendatud')
       return str(k.variandinr)
       
    def lahendusKordadeArv(self, REQUEST):
       "Mitu varianti on kasutaja vastavat testi lahendanud"
       k=self.salvestusAsukoht(REQUEST, self.id)
       return len(k.objectValues())

    def kasutajateTulemused(self, REQUEST, kommentaarid=0):
       "Testi tulemused"
       self.get_lang(('ivatests',), REQUEST)
       tulemus=leheAlgus(self, REQUEST)+"</p>\n<h2>"+(REQUEST['L_it_test_answers'] % self.id)+"</h2>\n"
       kommentaarid=int(kommentaarid)
       if kommentaarid==0:
         tulemus=tulemus+"<p><a href='"+REQUEST.URL0+"?kommentaarid=1'>"+REQUEST['L_it_show_comments']+"</a></p>\n"
       else:
         tulemus=tulemus+"<p><a href='"+REQUEST.URL0+"?kommentaarid=0'>"+REQUEST['L_it_hide_comments']+"</a></p>\n"       
       try:
         kasutajad=self.get_all_users()
       except:
         return tulemus+REQUEST['L_it_problem_in_finding_user']
       tulemus=tulemus+"\n<table border=\"0\" cellpadding=\"2\" cellspacing=\"1\" bgcolor=\"#EEEEEE\">\n"
       for x in kasutajad:
        tulemus=tulemus+"<tr>\n<td class=\"t1\" valign=\"top\">"+str(x.id)+"</td>\n<td class=\"t1\">\n"
        try:
         k=getattr(x.webtop, 'c'+str(self.find_course().get_id()))
           #tulemus=tulemus+"j"+k.absolute_url()
         if hasattr(k, 'testivastused'):
             #tulemus=tulemus+"k"
             if hasattr(k.testivastused, self.id):      
               t=getattr(k.testivastused, self.id)
               for y in t.objectValues():
#                 print type(y)
                 tulemus=tulemus+"<a href='"+y.absolute_url()+"'>"+str(y.id)+"</a> "
                 if kommentaarid:
                   tulemus=tulemus+str(y.lyhiKokkuvoteOpetajale(REQUEST))
                 else:
                   tulemus=tulemus+str(y.punktiArvutusHTML(REQUEST))
                 tulemus=tulemus+"<br />\n"
               tulemus=tulemus+"\n</td>\n"
        except Exception, probleem:
          tulemus=tulemus+" "+str(probleem)
       return tulemus+"</tr>\n</table>\n"+leheLopp(self, REQUEST)



    def lahendusteArvud(self, REQUEST):
      "Lahendamise statistika: kohal 0: lahendajate arv, kohal 2 lahenduste arv"
      try:
       kasutajad=self.get_all_users()
       taitjaid=0
       lahendusi=0
       for x in kasutajad:
         if hasattr(x.webtop, 'c'+str(self.find_course().get_id())):
          k=getattr(x.webtop, 'c'+str(self.find_course().get_id()))
          if hasattr(k, 'testivastused'):
            if hasattr(k.testivastused, self.id):
               t=getattr(k.testivastused, self.id)
               if len(t.objectValues())>0:
                 taitjaid=taitjaid+1
                 lahendusi=lahendusi+len(t.objectValues())
       return (taitjaid, " ",  lahendusi)                           
      except:
       return ('x', ' ', 'x')       
       
    def leivaPuru(self, REQUEST, viimane=0):
       "Teekond üles"
       self.get_lang(('ivatests',),REQUEST)
       nimi=self.id
       if viimane:
         tekst=nimi
       else:
         tekst="<a href='"+self.absolute_url()+"'>"+nimi+"</a>"
       if self.kas_opetaja(self, REQUEST):
#          pass
         return " &gt; <a href='"+self.fle_root().testihaldus.absolute_url()+"'>"+REQUEST["L_it_hdr_tests"]+"</a> &gt; " + tekst
       return " &gt; "+tekst
       
#    def paigutaTestiVastus(self, REQUEST, vastus):
#       "Paigutab variandi uue id alla"
#       k=self.salvestusAsukoht(REQUEST, vastus.id)
#       k.variandinr=k.variandinr+1
#       #vastus=ValikTest()
#       k._setObject("variant"+str(k.variandinr), vastus)
#       return str(k.variandinr)

#Globals.default__class_init__(YlTest)
Globals.InitializeClass(YlTest)

class LahendusLoad(Persistent, OFS.Folder.Folder, Traversable):
   "Lahenduslubade kogum"
   def leivaPuru(self, REQUEST, viimane=0):
     "Teekond üles"
     nimi=self.id+" "
     if viimane:
         tekst=nimi
     else:
         tekst="<a href='"+self.absolute_url()+"'>"+nimi+"</a>"
     return self.aq_parent.leivaPuru(REQUEST)+" &gt; <a href='"+self.aq_parent.absolute_url()+"/lubadeViited'>lubade haldus</a> &gt; "+tekst
       
   def kustutusLeht(self, REQUEST, kustuta=None):
     "õiguslubade kustutamine"
     if kustuta is not None:
       if type(kustuta)==types.StringType:
         kustuta=(kustuta,)
       for x in kustuta:
         self._delObject(x)
     REQUEST.RESPONSE.redirect('index_html')
     
   def kustutaKoikLoad(self):
     "Plats puhtaks"
     for x in self.nimedeLoetelu():
       self._delObject(x)
     
   def nimedeLoetelu(self):
     "Elementide nimed tekstina"
     nimed=[]
     for x in self.objectValues():
       nimed.append(x.id)
     return nimed
       
   def index_html(self, REQUEST):
     "Lubade loetelu"
     self.get_lang(('ivatests',), REQUEST)
     tulemus=leheAlgus(self, REQUEST)
     if len(self.objectValues())>0:
      tulemus=tulemus+"<form action='kustutusLeht'><ul>"
      for x in self.objectValues():
       tulemus=tulemus+"\n<li><input type='checkbox' name='kustuta' value='"+x.id+"'><a href='"+x.absolute_url()+"'>"+x.id+"</a></li>"
      tulemus=tulemus+"</ul><input type='submit' value='"+REQUEST['L_it_delete_permission']+"' /></form>"
     else:
      tulemus=tulemus+"Lubasid pole jagatud"
     tulemus=tulemus+leheLopp(self, REQUEST)
     return tulemus

class LahendusLuba(Persistent, OFS.SimpleItem.Item, Traversable):
   "õigused testi lahendamiseks"
   kordadeArv=-1  #arvu ei piirata
   algusAeg=-1    #Pole avatud lahendamiseks
   loppAeg=-1     #Kestust ei piirata
   import time
   def kasLahendusAeg(self):
     "jah/ei praeguse hetke kohta"
     if self.algusAeg==-1: return 0
     if self.algusAeg>time.time():return 0
     if self.loppAeg==-1:return 1
     if self.loppAeg>time.time():return 1
     else: return 0
     
   def kasLubatudLahendada(self, REQUEST, tehtudKordadeArv):
     "Jah/ei"
     if self.kasLahendusAeg()==0:return 0
     if self.kordadeArv==-1: return 1
     return int(tehtudKordadeArv)<self.kordadeArv
     
   def looValik(self, elemendinimi, algus, ots, valitu=-1, minkohtadearv=2, samm=1):
      "Valikmenüü HTML"
      tulemus="<select name='"+elemendinimi+"'>"
      x=algus
      while x<=ots:
        tulemus=tulemus+"\n <option value='"+str(x)+"'"
        if valitu==x:
          tulemus=tulemus+" selected "
        tekst=str(x)
        while len(tekst)<minkohtadearv:
          tekst="0"+tekst
        tulemus=tulemus+">"+tekst+"</option>"
        x=x+samm
      tulemus=tulemus+"\n</select>"
      return tulemus

   def aegTekstina(self, REQUEST, aeg):
      "tekstiesitus"
      self.get_lang(('common',), REQUEST)
      if aeg==-1: return "*"
      return time.strftime(REQUEST['L_timestamp_format'], time.localtime(aeg))
   
   def loaAndmedTekstina(self, REQUEST):
      "Loa kirjeldus ekraanil. Ajavahemik, kordade arv."
      self.get_lang(('ivatests',), REQUEST)
      tulemus=""
      if self.algusAeg==-1:
        tulemus=tulemus+"  "+REQUEST['L_it_timelimit']
        return tulemus
      tulemus=tulemus+self.aegTekstina(REQUEST, self.algusAeg)+"-"
      if self.loppAeg==-1:
        tulemus="igavesti"
      else:
        tulemus=tulemus+self.aegTekstina(REQUEST, self.loppAeg)
      if self.kordadeArv==-1:
        tulemus=tulemus+" piiramata arv"
      else:
        tulemus=tulemus+" "+str(self.kordadeArv)
      tulemus=tulemus+" x" 
      return tulemus
      

   def ajaMuutmisElemendid(self, elemendinimi, aeg=-1):
     "Valikute kogum"
     if aeg==-1:aeg=time.time()
     m=time.localtime(aeg)
     tulemus=self.looValik(elemendinimi+"Aasta", m[0]-1, m[0]+10, m[0])
     tulemus=tulemus+"-"+\
             self.looValik(elemendinimi+"Kuu", 1, 12, m[1])
     tulemus=tulemus+"-"+\
             self.looValik(elemendinimi+"Paev", 1, 31, m[2])
     tulemus=tulemus+" &nbsp; "+\
             self.looValik(elemendinimi+"Tund", 0, 23, m[3])
     tulemus=tulemus+":"+\
             self.looValik(elemendinimi+"Minut", 0, 59, m[4], samm=5)
     return tulemus
     
   def ajaPyydmisLeht(self, REQUEST, elemendinimi):
     "Saabuvad parameetrid ajaks"
     m=(int(getattr(REQUEST, elemendinimi+"Aasta")),
        int(getattr(REQUEST, elemendinimi+"Kuu")),
        int(getattr(REQUEST, elemendinimi+"Paev")),
        int(getattr(REQUEST, elemendinimi+"Tund")),
        int(getattr(REQUEST, elemendinimi+"Minut")),0,0,0,-1)
     return time.mktime(m)
          
     
   def muutmisVorm(self, REQUEST, liikumisURL=''):
     "Väljund veebilehele"
     self.get_lang(('ivatests',), REQUEST)
     tulemus=leheAlgus(self, REQUEST)+\
       "<form action='muutmisLeht'><input type='hidden' name='liikumisURL' value='"+liikumisURL+"' />"
     korratekst=REQUEST['L_it_unlimited']
     if self.kordadeArv!=-1:
       korratekst=str(self.kordadeArv)
     tulemus=tulemus+"<h3>"+REQUEST['L_it_start_time']+"</h3>"+\
       self.ajaMuutmisElemendid("algusAeg", self.algusAeg)+\
       "<h3>"+REQUEST['L_it_end_time']+"</h3>"+\
       self.ajaMuutmisElemendid("loppAeg", self.loppAeg)+\
       "<h3>"+REQUEST['L_it_repeat']+"</h3>"+\
       "<input type='text' name='kordadearv' value='"+korratekst+"'/>"+\
       "<br /><input type='submit' value='"+REQUEST['L_it_save']+"' />"
     tulemus=tulemus+"</form>"+leheLopp(self, REQUEST)
     return tulemus
     
   def muutmisLeht(self, REQUEST, liikumisURL=''):
     "Tulemuste talletus"
     self.algusAeg=self.ajaPyydmisLeht(REQUEST, "algusAeg")
     self.loppAeg=self.ajaPyydmisLeht(REQUEST, "loppAeg")
     try:
       self.kordadeArv=int(REQUEST['kordadearv'])
     except:
       self.kordadeArv=-1
     if liikumisURL!='':
       REQUEST.RESPONSE.redirect(liikumisURL)
     else:
       REQUEST.RESPONSE.redirect('muutmisVorm')
     
   def index_html(self, REQUEST):
     "Avaleht"
     return self.muutmisVorm(REQUEST)

   def leivaPuru(self, REQUEST, viimane=0):
     "Teekond üles"
     nimi=self.id+" lahendusaeg"
     if viimane:
         tekst=nimi
     else:
         tekst="<a href='"+self.absolute_url()+"'>"+nimi+"</a>"
     return self.aq_parent.leivaPuru(REQUEST)+" &gt; "+tekst
       
     
     
     
   
class TestiVastused(
     OFS.Folder.Folder,
     Persistent,
     AccessControl.Role.RoleManager,
     Traversable,
     Cruft
     ):           
     "Testi vastusvariant"
     testinimi=""
     koguKommentaar=""
     
     def ylesanded(self):
       "Ülesannete kogum"
       return self.objectValues()
     
     
     def vastusteTabel(self, REQUEST):
       "Ülesannete vastused tabelina"
       self.get_lang(('ivatests',), REQUEST)
       tulemus=leheAlgus(self, REQUEST)
       tulemus=tulemus+"<br /><table cellspacing='10'>"+\
         "<tr><td>"+REQUEST['L_it_an_question']+"</td><td>"+REQUEST['L_it_an_user_answer']+"</td><td>"+REQUEST['L_it_an_teacher_answer']+"</td><td>"+REQUEST['L_it_an_points']+"</td><td>"+REQUEST['L_it_an_comment']+"</td></tr>"
       for x in self.ylesanded():
        try:
          p="x"
          if x.kasPunktiArvutus():
            p=str(x.punkte())+"/"+str(x.normPunktid)
          tulemus=tulemus+"\n<tr><td>"+x.esitlusHTML(REQUEST)+"</td><td>"+\
          x.pakutudHTML(REQUEST)+"</td><td>"+x.tegelikHTML(REQUEST)+"</td><td>"+p+"</td><td>"+x.opetajaKommentaarHTML(REQUEST)+"</td></tr>"
        except:
          tulemus=tulemus+"<tr><td colspan='4'>Vigane vastus</td></tr>"  
       tulemus=tulemus+"</table><br />"+self.punktiArvutusHTML(REQUEST)+"<br />"+self.koguKommentaarHTML(REQUEST)+"<br />"
       if self.kas_opetaja(self, REQUEST):
         tulemus=tulemus+"<a href='vastusteKommenteeritavTabel'>"+REQUEST['L_it_an_answer_commenting_table']+"</a>"
       return tulemus+leheLopp(self, REQUEST)

     def vastusteKommenteeritavTabel(self, REQUEST):
       "Ülesannete vastused tabelina"
       self.get_lang(('ivatests',), REQUEST)
       tulemus=leheAlgus(self, REQUEST)+\
       "<form action='kommentaarideSalvestusLeht'><table>"+\
         "<tr><td>"+REQUEST['L_it_anc_question']+"</td><td>"+REQUEST['L_it_anc_user_answer']+"</td><td>"+REQUEST['L_it_anc_teacher_answer']+"</td>"+\
              "<td>"+REQUEST['L_it_anc_automatic_points']+"</td><td>"+REQUEST['L_it_anc_nominal_points']+"</td><td>"+REQUEST['L_it_anc_teacher_points']+"</td><td>"+REQUEST['L_it_anc_teachers_comment']+"</td><td>"+REQUEST['L_it_anc_point_reading']+"</td></tr>"
       for x in self.ylesanded():
          opunktid=""
          if x.annaOpetajaPunktid() is not None:
            opunktid=x.annaOpetajaPunktid()
          else:
            if x.kasPunktiArvutus():
              opunktid=x.automaatPunkte()
          tulemus=tulemus+"\n<tr><td>"+x.esitlusHTML(REQUEST)+"</td><td>"+\
          x.pakutudHTML(REQUEST)+"</td><td>"+x.tegelikHTML(REQUEST)+"</td>"
          tulemus=tulemus+"<td>"+str(x.automaatPunkte())+"</td>"+\
          "<td>"+str(x.normPunktid)+"</td>"+\
          "<td><input type='text' name='opetajapunktid"+x.id+"' "+\
          " value='"+str(opunktid)+"' size='5' /></td>"
          tulemus=tulemus+\
          "<td><input type='text' name='opetajakommentaar"+x.id+"' "+\
          " value='"+str(x.annaOpetajaKommentaar())+"' /></td>"+\
          "<td>"+str(x.kasPunktiArvutus())+"</td>"+\
          "</tr>"
       tulemus=tulemus+"</table><br />"+\
        self.punktiArvutusHTML(REQUEST)+"<br />"+REQUEST['L_it_anc_comment_to_whole_answer']+":<br />"+\
        "<textarea name='koguKommentaar'>"+self.annaKoguKommentaar()+"</textarea>"+\
        "<input type='submit' value='"+REQUEST['L_it_anc_save']+"' /></form>"
       return tulemus+leheLopp(self, REQUEST)


     def kommentaarideSalvestusLeht(self, REQUEST):
       "Õpetaja kommentaaride salvestus"
       import re
       for x in self.ylesanded():
         if hasattr(REQUEST, 'opetajapunktid'+x.id) and len(getattr(REQUEST,'opetajapunktid'+x.id))>0:
           try:
             x.seaOpetajaPunktid(float(re.sub(",", ".", getattr(REQUEST,'opetajapunktid'+x.id))))
             x.seaPunktiArvutus(1)
           except:
             x.seaPunktiArvutus(0)
         else:
           x.seaOpetajaPunktid(None)
           x.seaPunktiArvutus(0)
         if hasattr(REQUEST, 'opetajakommentaar'+x.id):
           x.seaOpetajaKommentaar(getattr(REQUEST, 'opetajakommentaar'+x.id))           
           
       self.seaKoguKommentaar(REQUEST.koguKommentaar)
       REQUEST.RESPONSE.redirect('vastusteKommenteeritavTabel')
       
     def seaKoguKommentaar(self, koguKommentaar):
       "Salvestatakse õpetaja kommentaar kogu lahendusvariandile"
       self.koguKommentaar=koguKommentaar
       
     def annaKoguKommentaar(self):
       "Kommentaari väljastus"
       return self.koguKommentaar
       
     def koguKommentaarHTML(self, REQUEST):
       "Kogu kommentaar HTML-ina"
       return asendaHTML(self.annaKoguKommentaar())
       
     def lyhiKokkuvoteOpetajale(self, REQUEST):
       "Kokkuvote"
       tulemus=self.punktiArvutusHTML(REQUEST)
       for x in self.ylesanded():
         if len(x.annaOpetajaKommentaar())>0:
           tulemus=tulemus+"<br />\n"+x.opetajaKommentaarHTML(REQUEST)
       if len(self.koguKommentaarHTML(REQUEST))>0:
         tulemus=tulemus+"<br /><br />"+self.koguKommentaarHTML(REQUEST)
       return tulemus

     def pihtasSumma(self):
       "Tabamusega ylesannete summa"
       summa=0
       for x in self.ylesanded():
         if x.kasPihtas():
           summa=summa+1
       return summa
       
     def punktiSumma(self):
        "Ülesannete punktisumma"
        summa=0
        for x in self.ylesanded():
         try:
          if x.kasPunktiArvutus():
             summa=summa+x.punkte()
         except Exception, probleem:
          print str(probleem) + " punkte " + x.absolute_url()
        return summa
        
     def normPunktiSumma(self):
        "100%"
        summa=0
        for x in self.ylesanded():
          if x.kasPunktiArvutus():
            summa=summa+x.annaNormPunktid()
        return summa
        
     def punktiProtsent(self, REQUEST):
        "%"
        self.get_lang(('ivatests',), REQUEST)
        if self.normPunktiSumma()==0:
          return "Protsendiarvutus puudub"
        return str(round(self.punktiSumma()*100/self.normPunktiSumma(), 2))+" %"

     def punktiArvutusHTML(self, REQUEST):
        "Tulemuste väljastus"
        self.get_lang(('ivatests',), REQUEST)        
        return str(round(self.punktiSumma(),2))+" / "+str(round(self.normPunktiSumma(), 2))+\
           ", "+self.punktiProtsent(REQUEST)
       
     def punktiArvutusLyhiHTML(self, REQUEST):
        "Tulemuste väljastus"
        self.get_lang(('ivatests',), REQUEST)        
        return str(round(self.punktiSumma(), 2))+" / "+str(self.normPunktiSumma())
       
     def leivaPuru(self, REQUEST, viimane=0):
       "Teekond üles"
       self.get_lang(('ivatests',),REQUEST)
       nimi=self.testinimi
       if viimane:
         tekst=nimi
       else:
         tekst="<a href='"+self.absolute_url()+"'>"+nimi+"</a>"
         
       if self.fle_root().kas_opetaja(self, REQUEST):
         testipuru="<a href='"+self.get_url_to_object(self.fle_root())+"testihaldus'>"+REQUEST['L_it_tests']+"</a>"
       else:
         testipuru=REQUEST['L_it_tests']
       return " &gt; "+testipuru+" &gt; "+tekst+" &gt; "+REQUEST['L_it_answers']+" "
       
     def index_html(self, REQUEST):
       "Peegel veebi"
       return self.vastusteTabel(REQUEST)
       
Globals.InitializeClass(TestiVastused)
Globals.default__class_init__(TestiVastused)   

def asendaHTML(sona):
   try:
    sona=sona.replace("&", "&amp;")
    sona=sona.replace(">", "&gt;")          
    sona=sona.replace("<", "&lt;")             
    return sona;
   except:
    return "kala: "+sona
           
def leheAlgus(obj, REQUEST):
   return obj.fle_root().hdr(obj, REQUEST)+obj.leivaPuru(REQUEST)+"<br />"
   
def leheLopp(obj, REQUEST):
   return obj.fle_html_footer(obj, REQUEST)

