# -*- 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
import types
from OFS import SimpleItem
from TraversableWrapper import Traversable
from Globals import Persistent
from AccessControl import ClassSecurityInfo
from Cruft import Cruft
from common import translate, perm_edit
from input_checks import strip_tags
#from YlTyybid import ValikYlesanne

class YlAlus(
     Persistent,
     OFS.SimpleItem.Item,
     OFS.Folder.Folder,
     Traversable,
     AccessControl.Role.RoleManager
     ):
     """ Testi ülesanne """
     
     security = ClassSecurityInfo()
     security.declareObjectPublic()
     
     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"
        import re
        try:
          punktid=re.sub(',', '.', punktid)
          self.normPunktid=float(punktid)
          return ""
        except:
          self.normPunktid=0
          return translate(self,'Invalid score',target=self.giveLanguage(REQUEST))
        
     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 strip_tags(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"
	#XXX: throws error on viewing answers
	try:
          if not self.kasLubatudLahendada(REQUEST):
           return ":-("
        except AttributeError:
		pass
        return strip_tags(self.kysimus)
        
     def viideHTML(self, REQUEST):
        "Vajutatav viide HTML-kodeeritult"
	#XXX: throws error on viewing answers
	try:
          if not self.kasLubatudLahendada(REQUEST):
           return ":-("
        except AttributeError:
		pass
        try:
          if self.viiteURL=="" or self.viiteTekst=="":
             return ""
          return "<br /><a href='"+self.viiteURL+"'>"+strip_tags(self.viiteTekst)+"</a>"
        except:
          return ""
  
     security.declareProtected(perm_edit, 'getDescription')
     def getDescription(self,REQUEST):
	 """ doc """
	 REQUEST.RESPONSE.setHeader('Content-Type', 'text/html')
	 tekst = self.kirjeldavTekst+" "+self.kysimus
	 return tekst
          
     def annaKirjeldavTekst(self, REQUEST):
       "Kirjeldav tekst"
       #XXX: throws error on viewing answers
       try:
         if not self.kasLubatudLahendada(REQUEST):
           return ":-("
       except AttributeError:
	       pass
       REQUEST.RESPONSE.setHeader('Content-type', 'text/html')
       #XXX: onfly upgrading :)
       if self.kysimus:
	       self.kirjeldavTekst += self.kysimus
	       self.kysimus = ""
       return self.kirjeldavTekst+"  "+self.kysimus
         
     def kirjeldavTekstHTML(self, REQUEST):
       "Kirjeldav tekst kodeeritult"
       if not self.kasLubatudLahendada(REQUEST):
         return ":-("
       return strip_tags(self.annaKirjeldavTekst(REQUEST))
       
     def seaKirjeldavTekst(self, REQUEST, tekst):
       "Teksti seadmine"
       self.kirjeldavTekst=tekst
          
     def esitlusHTML(self, REQUEST):
        """Küsimus koos ilustustega"""
	#XXX: throws error on viewing answers
	try:
            if not self.kasLubatudLahendada(REQUEST):
                return ""
        except AttributeError:
		pass
        tulemus=""
        if self.annaKirjeldavTekst(REQUEST)!="":
            tulemus=tulemus+self.annaKirjeldavTekst(REQUEST)+"<br />"
        return tulemus+self.kysimusHTML(REQUEST)+self.viideHTML(REQUEST)

     def _getQuestionHTML(self):
         """ get question and describing text """
         # ---- annaKirjeldavTekst ----
         #XXX: onfly upgrading :)
         if self.kysimus:
             self.kirjeldavTekst += self.kysimus
             self.kysimus = ""
         res = self.kirjeldavTekst+"  "+self.kysimus
         # ---- kysimusHTML ----
         res += strip_tags(self.kysimus)

         # ---- viideHTML ----
         if self.viiteURL or self.viiteTekst:
             res += "<br /><a href='"+self.viiteURL+"'>"+strip_tags(self.viiteTekst)+"</a>"
         return res

     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"
        if not self.kasLubatudLahendada(REQUEST):
         return ":-("
        tekst='L_it_describing_text'+":<br />\n<textarea name='"+elemendiNimi+"'>"+self.annaKirjeldavTekst(REQUEST)+"</textarea>"
        return tekst

     def kysimusVormis(self, REQUEST, elemendiNimi="kysimus"):
        if not self.kasLubatudLahendada(REQUEST):
         return ":-("
        return 'L_it_ex_question'+""":<br /><input type="text" name="%s" value="%s" />"""  % (elemendiNimi, self.kysimusHTML(REQUEST))
        
     def viideVormis(self, REQUEST):
        "Viite vorm"
        if not self.kasLubatudLahendada(REQUEST):
         return ":-("
        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 normPunktidVormis(self, REQUEST):
        "Täispunktide sisestusvorm"
        arvutus=""
        if not self.kasPunktiArvutus():
          arvutus="<br />"+translate(self, 'n/a', target=self.giveLanguage(REQUEST))
        return "<br />"+translate(self, 'Maximum number of points for this question', 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 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 muutmisLeht(self, REQUEST, kysimus="", vastus=None, 
        viiteURL=None, viiteTekst=None, pilt=None, 
        kustutaPilt=0, normPunktid=0, liikumisURL='muutmisVorm',
        kirjeldavTekst='', keyword=(), title="", kupu=''):
        """ Muutmisvormi andmete püüdja """
        probleem=""
        self.kysimus=kysimus
        #return "pikkus: "+str(len(kirjeldavTekst.strip()))
        #if len(kirjeldavTekst.strip())<5:
        if len(kupu)<5:
            probleem+=translate(self, 'You have not entered question!', target=self.giveLanguage(REQUEST))+"<br />"
        import re
        tmp = re.search('<body[^>]*>(.*?)</body>', kupu).group()
        tmp = re.sub('<body>', '', tmp)
        tmp = re.sub('</body>', '', tmp)
        kirjeldavTekst = tmp
        probleem+=self.vastuseMuutmisLeht(REQUEST, vastus)
        self.kirjeldavTekst=kirjeldavTekst
        self.meta.keywords=[]
        for k in keyword:
            if k.strip():
                if not k in self.meta.keywords:
                    self.meta.keywords.append(k)
        self.meta.title=title
        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 self.message_dialog(self, REQUEST, 
                    title='Error',
                    message=probleem,
                    action=self.absolute_url()+"/kupuform"
                    )
        return REQUEST.RESPONSE.redirect('../ylesandedMuutmisTabelina')
        
        
     def vastuseMuutmisLeht(self, REQUEST=None, vastus=''):
        "Leht vastuse muutmiseks, soovitav üle katta"   
        return ""
        
     def viiteSalvestusLeht(self, REQUEST, viiteURL, viiteTekst):
        if (viiteURL is None or viiteURL==""):
           if(viiteTekst is None or viiteTekst==""):
             return ""
           else:
             return 'Address missing'
        if not self.viiteSobivusKontroll(viiteURL):
           return 'Invalid 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"
	if not self.kasLubatudLahendada(REQUEST):
		return ""
        return self.defaultRender(page=self.kirjeldavTekstHTML(REQUEST)+\
         "<table><tr><td>"+self.esitlusHTML(REQUEST)+"</td>"+\
           "<td>"+self.vaatamineHTML(REQUEST)+"</td></tr></table>")
        
     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
       
     def lisaPilt(self, REQUEST, pilt, pos, raam):
       "Ãlesande külg salvestatakse pilt"
       if not hasattr(self, 'pildid'):
         self.pildid=[]
       if len(pilt.filename)>0:
         self.pildid.append(pilt.read())
         self.pildid=self.pildid
       return """
         <html><body>
           <script>
             aken=opener.document.getElementById('irm').contentWindow;
             see="%s";
             aken.focus();
             aken.document.execCommand('insertimage',false,see);
             plt=(document.selection)?aken.document.selection.createRange()(0):aken.getSelection().getRangeAt(0).commonAncestorContainer.childNodes.item(0);
             plt.setAttribute('align',"%s");
             plt.setAttribute('border',"%s");
           </script>
         </body></html>
        """ %  (self.id+"/kysiPilt?pildinr="+str(len(self.pildid)-1), pos, raam)
       
       
     def kysiPilt(self, REQUEST, pildinr):
       "VÃljastatakse soovitud jarjekrranumbriga pilt"
       if not hasattr(self, 'pildid'):
         self.pildid=[]
       if int(pildinr)>=len(self.pildid):
         return "pole sellist pilti"
       REQUEST.RESPONSE.setHeader('Content-type', 'image/jpeg')
       return self.pildid[int(pildinr)]
       
Globals.InitializeClass(YlAlus)
Globals.default__class_init__(YlAlus)