# -*- coding: utf-8
# 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


import AccessControl
import OFS, Globals
import types
import YlTest
from OFS import SimpleItem
from TraversableWrapper import Traversable
from Globals import Persistent
from AccessControl import ClassSecurityInfo
from Cruft import Cruft
from common import add_dtml, translate
#from YlTest import asendaHTML
#from YlTyybid import ValikYlesanne

class YlAlus(
     Persistent,
     OFS.SimpleItem.Item,
     OFS.Folder.Folder,
     Traversable,
     AccessControl.Role.RoleManager
     ):
     "Testi ülesanne"
     meta_type="YlAlus"
     kysimus="Ülesande küsimus"
     viiteURL=""
     viiteTekst=""
     pilt=None
     kirjeldavTekst=""
     vastusPakutud=0
     tostuTundlik=1
     opetajaPunktid=None
     opetajaKommentaar=""
     normPunktid=10
     punktiArvutus=1

     def ylesandeNimetus(self, REQUEST):
       "Ülesande tüübi nimi"
#       return self.meta_type

     def punkte(self):
        "Arvestatavate punktide arv"
        if self.kasPunktiArvutus():
          if self.annaOpetajaPunktid() is not None:
            return self.annaOpetajaPunktid()
          else:
            return self.automaatPunkte()
          
        
     def automaatPunkte(self):
        "Kaetakse punktiarvutusel üle"
        return "X"
        
     def annaNormPunktid(self):
        "Võimalik normijärgsete maksimumpunktide arv vastavas ülesandes"
        return self.normPunktid
        
     def normPunktidHTML(self, REQUEST):
        "Väljund tabelisse"
        if self.kasPunktiArvutus():
          return str(self.annaNormPunktid())
        else:
          return "-/"+str(self.annaNormPunktid())
        
     def seaNormPunktid(self, REQUEST, punktid):
        "Normpunktide salvestus"
        self.get_lang(('ivatests',),REQUEST)
        import re
        try:
          punktid=re.sub(',', '.', punktid)
          self.normPunktid=float(punktid)
          return ""
        except:
          self.normPunktid=0
          return REQUEST['L_it_incorrect_point_count']
        
     def kasPunktiArvutus(self):
        "Kas vastav ülesanne on punktiarvutuse osa"
        try:
          return self.punktiArvutus
        except:
          return 0
        
     def seaPunktiArvutus(self, olek):
        "Punktiarvutus"
        if olek:
          self.punktiArvutus=1
        else:
          self.punktiArvutus=0
        
     def seaOpetajaKommentaar(self, kommentaar):
        "Õpetaja kommentaar lahendusele"
        self.opetajaKommentaar=kommentaar
        
     def annaOpetajaKommentaar(self):
        "Antakse kui on"
        if hasattr(self, "opetajaKommentaar"):
#         if type(self.opetajaKommentaar) is types.StringType:
          return str(self.opetajaKommentaar)
#         return "Vigane kommentaar"
        else:
          return ""
          
     def opetajaKommentaarHTML(self, REQUEST):
        "Kodeeritult"
        return YlTest.asendaHTML(self.annaOpetajaKommentaar())
          
     def seaOpetajaPunktid(self, punktid):
        "Õpetaja pakutud punktid lahendusele"
        if punktid is None:
          self.opetajaPunktid=None
          return
        try:
          self.opetajaPunktid=float(punktid)
          if float(punktid)==int(punktid):
            self.opetajaPunktid=int(punktid)
        except:
          pass
        
     def annaOpetajaPunktid(self):
        "Antakse kui on"
        if self.kasPunktiArvutus():
          if hasattr(self, "opetajaPunktid"):
            return self.opetajaPunktid
          else:
            return None
        return "-"
        
     def kysimusHTML(self, REQUEST):
        "Küsimus HTML-kodeeritult"
        import YlTest
        return YlTest.asendaHTML(self.kysimus)
        
     def viideHTML(self, REQUEST):
        "Vajutatav viide HTML-kodeeritult"
        try:
          if self.viiteURL=="" or self.viiteTekst=="":
             return ""
          return "<br /><a href='"+self.viiteURL+"'>"+YlTest.asendaHTML(self.viiteTekst)+"</a>"
        except:
          return ""
          
     def annaKirjeldavTekst(self, REQUEST):
       "Kirjeldav tekst"
       if hasattr(self, 'kirjeldavTekst'):
         return self.kirjeldavTekst
       else:
         return ""
         
     def kirjeldavTekstHTML(self, REQUEST):
       "Kirjeldav tekst kodeeritult"
       return YlTest.asendaHTML(self.annaKirjeldavTekst(REQUEST))
       
     def seaKirjeldavTekst(self, REQUEST, tekst):
       "Teksti seadmine"
       self.kirjeldavTekst=tekst
       
          
     def piltHTML(self, REQUEST):
        if self.kasPilt():
          return "<br /><img src='"+self.absolute_url()+"/naitaPilti'>"
        else:
          return ""
          
     def esitlusHTML(self, REQUEST):
        "Küsimus koos ilustustega"
        tulemus=""
        if self.annaKirjeldavTekst(REQUEST)!="":
          tulemus=tulemus+self.annaKirjeldavTekst(REQUEST)+"<br />"
        return tulemus+self.kysimusHTML(REQUEST)+self.viideHTML(REQUEST)+self.piltHTML(REQUEST)
        
     def taitmineHTML(self, REQUEST, elemendinimi):
        "Vastuse sisestamise koht"
        return "Täitmiseks mõeldud osa"
        
     def vaatamineHTML(self, REQUEST):
        "Koostaja poolt lahenduskoha vaatamine"
        return "Variantide vaatamiseks mõeldud osa"


     def kasPihtasArvutus(self):
       "Kas uuritakse tabamust"
       return 0

     def kasPihtasHTML(self, REQUEST):
        "Kas saadi vastusega pihta"
        if self.kasPihtasArvutus():
           if self.kasPihtas():
              return "+"
           else:
              return "-"
        else:
           return "Tabamust ei uurita"

     def kasPihtas(self):
        "Sisemine uuring alamklassis"
        return 0
        
     def tegelikHTML(self, REQUEST):
        "Opetaja pakutud oige vastus"
        return "Ainuoige lahendus puudub"
        
     def kirjeldavTekstVormis(self, REQUEST, elemendiNimi="kirjeldavTekst"):
        "Ülesannet kirjeldav tekst"
        self.get_lang(('ivatests',), REQUEST)
        tekst=REQUEST['L_it_describing_text']+":<br />\n<textarea name='"+elemendiNimi+"'>"+self.annaKirjeldavTekst(REQUEST)+"</textarea>"
        return tekst

     def kysimusVormis(self, REQUEST, elemendiNimi="kysimus"):
        return REQUEST['L_it_ex_question']+""":<br /><input type="text" name="%s" value="%s" />"""  % (elemendiNimi, self.kysimusHTML(REQUEST))
        
     def viideVormis(self, REQUEST):
        "Viite vorm"
        self.get_lang(('ivatests',), REQUEST)
        url=tekst=""
        try:
          url=self.viiteURL
          tekst=self.viiteTekst
        except:
          pass
        return """
         <table>
          <tr>
           <td>%s:</td>
           <td><input type="text" name="viiteURL" value="%s" /></td>
          </tr>
          <tr>
           <td>%s:</td>
           <td><input type="text" name="viiteTekst" value="%s" /></td>
          </tr>
         </table>
        
        """ % (translate(self, 'L_it_link_url', target=self.giveLanguage(REQUEST)), url, translate(self, 'L_it_link_text', target=self.giveLanguage(REQUEST)), tekst)
        

     def piltVormis(self, REQUEST):
        "Pildi vorm"
        self.get_lang(('ivatests',), REQUEST)
        return  translate(self, 'L_it_picture', target=self.giveLanguage(REQUEST))+""": <br />
          <input type="file" name="pilt" /><br />
          <input type="checkbox" name="kustutaPilt" /> """+translate(self, 'L_it_delete_picture', target=self.giveLanguage(REQUEST))+"""<br />
        """ + self.piltHTML(REQUEST)
        
     def normPunktidVormis(self, REQUEST):
        "Täispunktide sisestusvorm"
        self.get_lang(('ivatests',), REQUEST)
        arvutus=""
        if not self.kasPunktiArvutus():
          arvutus="<br />"+translate(self, 'L_it_no_automatic_point_calculating', target=self.giveLanguage(REQUEST))
        return "<br />"+translate(self, 'L_it_nominal_points', target=self.giveLanguage(REQUEST))+":<br />"+\
         "<input type='text' name='normPunktid' value='%s' /> %s" % (str(self.annaNormPunktid()), arvutus)
        
        


     def kasPilt(self):
       "Kas pilt olemas"
       if not hasattr(self, "pilt"):
         return 0
       if self.pilt is None:
         return 0
       return 1   
        
     def naitaPilti(self, REQUEST):
       "Pildiväljastus"
       if self.kasPilt():
         REQUEST.RESPONSE.setHeader('content-type', 'image/jpeg')
         return self.pilt
       else:
         return "Pilt puudub"
        
     def vastuseMuutmisVorm(self, REQUEST):
        "Muutmisvormi elemendid vastusepoole andmete näitamiseks, soovitav üle katta, elemendi nimeks vastus"
        return "Vastamiskoht"

     def leivaPuru(self, REQUEST, viimane=0):
        "Teekond üles"
        nimi=self.id
        if viimane:
          tekst=self.id
        else:
          tekst="<a href='"+self.absolute_url()+"'>"+str(self.id)+"</a>"
        return self.aq_parent.leivaPuru(REQUEST)+" &gt; "+tekst


     def muutmisVorm2(self, REQUEST, liikumisURL=None):
        "Testi muutmiseks mõeldud leht, üle katta vaid juhul, kui vaja muuta enam kui ühe elemendinimega vastuseosa"
        self.get_lang(('ivatests',), REQUEST)
        liiguvali=""
        if liikumisURL is not None:
          liiguvali="<input type='hidden' name='liikumisURL' value='"+liikumisURL+"' />"
        tulemus=YlTest.leheAlgus(self, REQUEST)+"<h2>"+self.ylesandeNimetus(REQUEST)+"</h2>"\
          "<form action='muutmisLeht' method='POST' enctype='multipart/form-data'>"+liiguvali+\
          self.kirjeldavTekstVormis(REQUEST)+\
          "<table><tr>"+\
          "<td valign='top'>"+self.kysimusVormis(REQUEST)+"</td>"+\
          "<td valign='top'>"+self.vastuseMuutmisVorm(REQUEST)+"</td></tr>"+\
          "</table><br />"+self.viideVormis(REQUEST)+"<br />"+\
          self.piltVormis(REQUEST)+self.normPunktidVormis(REQUEST)+\
          "<br /><input type='submit' value='"+REQUEST['L_it_ex_save']+"' /></form>"
        return tulemus+YlTest.leheLopp(self, REQUEST)
        
     def muutmisLeht(self, REQUEST, kysimus=None, vastus=None, 
         viiteURL=None, viiteTekst=None, pilt=None, 
         kustutaPilt=0, normPunktid=0, liikumisURL='muutmisVorm',
         kirjeldavTekst='', keyword=()):
        "Muutmisvormi andmete püüdja"
        probleem=""
        if kysimus:
          self.kysimus=kysimus
        try:
          self.vastuseMuutmisLeht(REQUEST, vastus)
        except:
          self.vastuseMuutmisLeht(vastus)
        self.kirjeldavTekst=kirjeldavTekst
        self.meta.keywords=[]
        for k in keyword:
          if k.strip():
            self.meta.keywords.append(k)
        self.meta.ex_changed=1
        self.meta.uname=str(REQUEST.AUTHENTICATED_USER)
        probleem=probleem+self.viiteSalvestusLeht(REQUEST, viiteURL, viiteTekst)
        probleem=probleem+self.pildiSalvestusLeht(pilt, kustutaPilt)
        probleem=probleem+self.seaNormPunktid(REQUEST, normPunktid)
        if probleem:
          return probleem
        REQUEST.RESPONSE.redirect(liikumisURL)
        
        
     def vastuseMuutmisLeht(self, vastus):
        "Leht vastuse muutmiseks, soovitav üle katta"   
        pass
        
     def viiteSalvestusLeht(self, REQUEST, viiteURL, viiteTekst):
        self.get_lang(('ivatests',), REQUEST)
        if (viiteURL is None or viiteURL==""):
           if(viiteTekst is None or viiteTekst==""):
             return ""
           else:
             return REQUEST['L_it_no_link_address']
        if not self.viiteSobivusKontroll(viiteURL):
           return REQUEST['L_it_incorrect_URL']
        if viiteTekst is None or viiteTekst=="":
           viiteTekst=viiteURL
        self.viiteURL=viiteURL
        self.viiteTekst=viiteTekst
        return ""
        
     def pildiSalvestusLeht(self, pilt, kustutaPilt):
        if kustutaPilt:
           self.pilt=None
        if pilt is None:
           return ""
        try:
         if len(pilt.filename)>0:
          self.pilt=pilt.read()
        except:
          pass
        return ""
           
        
     def viiteSobivusKontroll(self, viiteURL):
       return 1   
        
     def vahemikuTabavusSuhe(self, vastus, ala, kesk, yla):
       "Väljastatakse, kui suur osa saadi saadi tabavusmaksimumist"
       vastus=float(vastus)
       ala=float(ala)
       kesk=float(kesk)
       yla=float(yla)
       if ala>yla: return 0
       if kesk<ala: return 0
       if kesk>yla: return 0
       if vastus<ala: return 0
       if vastus>yla: return 0
       if vastus>=ala and vastus<=kesk:
         return (vastus-ala)/(kesk-ala)
       if vastus>=kesk and vastus <= yla:
         return  (yla-vastus)/(yla-kesk)
       return 0
       
     def lineaarProtsentSuhe(self, vastus, oige, protsent):
       """Pakutav vastus võib õige suhtes kuni määratud protsendi jagu
          kõikuda. Täpselt pihta saamisel on suhteks 1.0, muidu kahaneb
          lineaarselt kuni nullini kogu lubatud ulatusest välja nihkudes."""
       try:
         vastus=float(vastus)
         oige=float(oige)
         protsent=float(protsent)
         nihe=oige*protsent/100.0
       except:
         return 0
       return self.vahemikuTabavusSuhe(vastus, oige-nihe, oige, oige+nihe)
          


     def index_html(self, REQUEST):
        "Peegel veebis"
        import YlTest
        return YlTest.leheAlgus(self, REQUEST)+\
         self.kirjeldavTekstHTML(REQUEST)+\
         "<table><tr><td>"+self.esitlusHTML(REQUEST)+"</td>"+\
           "<td>"+self.vaatamineHTML(REQUEST)+"</td></tr></table>"+YlTest.leheLopp(self, REQUEST)
        
     def kustuta(self):
        "Ülesanne kustutatakse"
        self.aq_parent._delObject(self.id)
        
    
     def koopia(self):
        "samade andmetega ülesanne"
        import copy
        return copy.copy(self)
        
          
     def loeTekstistYlesanne(self, reamassiiv):
       "Loeb andmed saadetud tekstist, üle katta"
       
     def kirjutaYlesanneTekstiks(self, testinimi, nr):
       "Väljastab ülesande tekstina, üle katta"
       return ""
          
     def salvestaPakutu(self, andmed):
       "Loob koopia ülesandest koos pakutud vastusega"
       k=self.koopia()
       k.id=self.id
       k.vastusPakutud=1
       k.pakutudAndmed=andmed
       return k

     def lisaMeta(self, REQUEST):
       "Lisatakse ülesandele metaandmestik. Täidetakse võimaluse korral testist ja kursusest võetud andmetega."
       if hasattr(self, 'metaandmed'):
         return self.metaandmed
       import YlMeta
       from YlMeta import YlMeta
       meta=YlMeta()
       self._setObject('meta', meta)
       #Siin lisatakse olemasolevad andmed
       return self.meta

       
Globals.InitializeClass(YlAlus)
Globals.default__class_init__(YlAlus)