# $Id: Cruft.py,v 1.9 2003/08/23 12:34:56 berlingo Exp $
#
# Copyright 2001, 2002 by Fle3 Team and contributors
#
# This file is part of Fle3.
#
# Fle3 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.
#
# Fle3 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 Fle3; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

"""Contains class Cruft, which is used as a placeholder for miscellaneous utility functions that many objects need."""

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

from AccessControl import ClassSecurityInfo
from urllib import quote

import re
import common

class Cruft:
    """Class containing miscellaneous methods that are
    historical baggage, but possible be gotten rid of, or
    at least implemented differently or somewhere else."""
    security = ClassSecurityInfo()
    security.declarePublic('find_URL_of_fle_root')

    def x(self):
        """..."""
        for i in self.aq_chain:
            if hasattr(i,'id'):
                print i.id
            else:
                print i

    def find_URL_of_fle_root(self, REQUEST):
        """Return URL of our FLE installation."""
        import FLE
        from string import rfind
        url = REQUEST.URL1
        obj = self
        while not isinstance(obj, FLE.FLE):
            obj = obj.parent()
            url = url[:rfind(url,'/')]
        return url

    def find_URL_of_user_info(self, REQUEST):
        """Return URL of UserInfo."""
        import UserInfo
        from string import rfind
        url = REQUEST.URL1
        obj = self
        while not isinstance(obj, UserInfo.UserInfo):
            obj = obj.parent()
            url = url[:rfind(url,'/')]
        return url


    security.declarePublic('find_URL_of_webtop')
    def find_URL_of_webtop(self, REQUEST):
        """Return URL of Webtop."""
        import Webtop
        from string import rfind
        url = REQUEST.URL1
        obj = self
        while not isinstance(obj, Webtop.Webtop):
            obj = obj.parent()
            url = url[:rfind(url,'/')]
        return url

    security.declarePublic('find_URL_of_group_folder')
    def find_URL_of_group_folder(self, REQUEST):
        """Return URL of toplevel group folder or group folder proxy."""
        import GroupFolder
        import GroupFolderProxy
        from string import rfind
        url = REQUEST.URL1
        obj = self
        while 1:
            if isinstance(obj, GroupFolderProxy.GroupFolderProxy):
                return url
            if isinstance(obj, GroupFolder.GroupFolder):
                return url
            obj = obj.parent()
            url = url[:rfind(url,'/')]
        return url

    security.declarePublic('find_URL_of_thread_start_node')
    def find_URL_of_thread_start_node(self, REQUEST):
        """Return URL of starting note."""
        import CourseContext
        from string import rfind

        url = REQUEST.URL1
        obj = self
        while not isinstance(obj.parent(), CourseContext.CourseContext):
            obj = obj.parent()
            url = url[:rfind(url,'/')]
        return url

    security.declarePublic('find_URL_of_course')
    def find_URL_of_course(self, REQUEST):
        """Return URL of starting note."""
        obj = self
        while not obj.meta_type == 'Course':
            obj = obj.parent()
        return obj.absolute_url()

    security.declarePublic('find_URL_of_course_context')
    def find_URL_of_course_context(self, REQUEST):
        """Return URL of starting note."""
        import CourseContext
        from string import rfind

        url = REQUEST.URL1
        obj = self
        while not isinstance(obj, CourseContext.CourseContext):
            obj = obj.parent()
            url = url[:rfind(url,'/')]
        return url

    security.declarePublic('get_current_user')
    def get_current_user(self, REQUEST):
        """Extract current user's name from the REQUEST object."""
        if hasattr(REQUEST, 'kasutajanimi'):
          return REQUEST.kasutajanimi
        else:
          return str(REQUEST.AUTHENTICATED_USER)
        
    def salvestaKasutajanimi(self, REQUEST, nimi):
        """Kuna Python ei suuda alati AUTHENTICATED_USERit korralikult välja lugeda,
           siis jäetakse nimi DTMLi kaudu meelde."""
        REQUEST.kasutajanimi=nimi
        return self.get_current_user(REQUEST)

    security.declarePublic('urlquote')
    def urlquote(self, text):
        """urlquote given text."""
        return quote(text)

    def get_url_to_object(self,obj):
        # Make a list of parents without the Application object
        # (from obj to FLE)
        objs = obj.aq_inner.aq_chain[:-1]
        objs.reverse()
        path='/'.join([x.getId() for x in objs])+'/'
        return path

    def get_object_of_url(self,url,base):
        path=url.split('/')
        path.pop() # remove last entry
        path.reverse()
        if path[-1]=='http:':  # remove protocol
            path.pop()
            path.pop()
        path.pop() # remove first (root) entry
        obj = base.getPhysicalRoot()
        try:
            while path:
                oname=path.pop()
                obj=getattr(obj,oname).__of__(obj)
            return obj
        except:
            #raise 'Internal link error, object not found',str(obj)+' - '+oname
            return None

    def kasutajaURList(self, REQUEST):
       "Kasutajanimi"
       nimi=self.kasutajaNimi(REQUEST)
       if nimi=="":
         return nimi
       if nimi==str(REQUEST.AUTHENTICATED_USER):
         return ""
       return "&gt; " + "<a href='"+self.find_URL_of_fle_root(REQUEST)+"/fle_users/"+nimi+"/webtop/c"+self.jooksva_kursuse_nr(self, REQUEST)+"'>"+nimi+"</a>"

    def algusURList(self, REQUEST, osa):
      "URL soovitud loiguni"
      x=REQUEST.URL0
      if x.find(osa)==-1:
        return ""
      return x[:x.find(osa)+len(osa)]
      
    def kasLopeb(self, tekst, otsitav):
      "jah/ei"
#      return tekst+" ja " + otsitav
      return tekst.endswith(otsitav)



    def kasOmaVeebilaual(self, REQUEST):
      "jah/ei"
      return self.kasutajaNimi(REQUEST)==str(REQUEST.AUTHENTICATED_USER)


    def kasutajaNimi(self, REQUEST):
       "nimi"
       aadress=REQUEST.URL0
       nr=aadress.find('fle_users')
       if nr==-1:
         return ""
       ots=aadress.find('/', nr+10)       
       nimi=aadress[nr+10:ots]
       return nimi

    security.declarePublic('leiaKasutaja')
    def leiaKasutaja(self, REQUEST):
       "kasutaja objekt"
       nimi=self.kasutajaNimi(REQUEST)
       if hasattr(self.fle_root().fle_users, nimi):
          return getattr(self.fle_root().fle_users, nimi)
       return None


    def jooksevKasutaja(self, REQUEST):
       "Kasutajainfo objekt sisseloginud kasutaja kohta"
       return getattr(self.fle_root().fle_users, str(REQUEST.AUTHENTICATED_USER))
       
    def leheAvamisToimingud(self, REQUEST):
       "Tegevused iga lehe avamisel"
       try:
         self.seaKasutajaKeel(REQUEST)
         self.jooksevKasutaja(REQUEST).update_active(self.jooksva_kursuse_nr(self, REQUEST))       
         self.lisaSyndmus(REQUEST, "lehtiAvatud")
         self.kontrolli_kursuse_kaust(self, REQUEST)          
         return "tehtud"
       except:
        return "probleem"
       
       
    def seaKasutajaKeel(self, REQUEST):
       "Kasutja keele määramine"
       if hasattr(REQUEST, 'HTTP_ACCEPT_LANGUAGE'):
         keeletekst=REQUEST['HTTP_ACCEPT_LANGUAGE']
         keeled=keeletekst.split(",")
         kasutaja=self.jooksevKasutaja(REQUEST)
         if not kasutaja.kasKeelBrauserist():
           return "Vahetusesoov puudub"
         for x in keeled:
           if x=='et': x='et_ee'
           if x in ('et_ee', 'en'):
             kasutaja.set_language(x)
             return "Uus keel "+x
       return "Keel puudub"


    def voorasVasakul(self, REQUEST):
       "Viide voora veebilaua vasakul servas"
       if self.kasOmaVeebilaual(REQUEST):
          return ""
       tulemus=""
       kasutaja=self.leiaKasutaja(REQUEST)
       if kasutaja is None:
          return " "
       if kasutaja.has_photo():
          tulemus=tulemus+"<img src=\""+kasutaja.absolute_url()+"/get_photo\" height=\"80\" alt=\"\" />"
       else:
          tulemus=tulemus+"<img src=\"images/user\" height=\"80\" alt=\"\" />"
       tulemus=tulemus+"<br /><a href='"+kasutaja.absolute_url()+"/show_user_info'>"+self.kasutajaNimi(REQUEST)+"</a>"
       return tulemus
          
          
          
    

    def set_undefined_page(self, message, REQUEST):
        """Set REQUEST.RESPONSE.redirect, so that we go to undefined page
        and give an explanation."""
        message = common.quote_html_hack(message)
        REQUEST.RESPONSE.redirect(self.state_href(REQUEST,
            "undefined_page?explanation=%s" % message))

    security.declarePublic('to_str_list')
    # Using eval would be simpler and more general, but
    # we want to be paranoid.
    def to_str_list(self, s):
        """Reverse str representation of list of strings back to list."""
        return [x.strip() for x in s[1:-1].replace("'", "").split(',')]

    def kasutajaasukoht(self, REQUEST):
       "Kasutaja asukoht"
       x=REQUEST.URL0
       if x.find('fle_users')>0:          
          if x.find('/testivastused/')>0:
           if self.kas_opetaja(self, REQUEST):
            return 'Haldus'
           else:            
            return 'Tootuba'
#          return 'Kala'+x + str(x.find('/webtop')>0 or x.find('/sahtel')>0)
          if x.find('/webtop')>0 or x.find('/sahtel')>0 or x.find('/paevikuleht')>0 \
             or x.find('/kalendriAastaJooniseLeht')>0 or x.find('/kirjad')>0 \
             or x.find('/sobrad')>0:
            return 'Veebilaud'
          if x.find('/syndmused')>0: return 'Veebilaud'
          if x.find('kasutajateLisamiseVorm')>0: return 'Haldus'
	  if x.find('oigustePiiramine')>0: return 'Haldus'
          if self.kas_kasutaja_haldus(x): return 'Haldus'
          if not self.kasOmaVeebilaual(REQUEST):
            return 'Veebilaud'
          return 'Haldus'

       if x.find('/gf/')>0:
          return 'Raamaturiiul'
       if x.find('kasutajaSyndmusedLehena')>0 :return 'Veebilaud'
       if x.find('kursusteleRegistreerimiseVorm')>0 :return 'Veebilaud'
       if self.kas_haldus(REQUEST, x):
          return 'Haldus'
       else:
          return 'Tootuba'
 

    def sisegrupiNimi(self, REQUEST):
      "URList loetud grupi nimi"
      x=REQUEST.URL0
      if x.find('/sisegrupid/')>0:
        algus=x.find('/sisegrupid/')
        ots=x.find('/', algus+12)
        if ots==-1:
          tulemus=x[algus+12:]
        else:
          tulemus=x[algus+12:ots]
        return tulemus
      else:
        return ""




    security.declarePublic('kas_haldus')
    def kas_haldus(self, REQUEST, veebiurl):
       "kas sobib halduseks"
       if re.match(".*/courses/[0-9]+/syndmused", veebiurl):
         if self.kas_opetaja(self, REQUEST): return 1
         else: return 0
       laused=(
         ".*haldusleht",
         ".*testihaldus",
         ".*muuda_vorm",
         ".*kysimuse_vorm",
         ".*add_course_form",
         ".*sisegrupihaldus",
         ".*sisegrupi_lisamise_vorm",
         ".*sisegrupikustutusvorm",
         ".*sisegrupi_osaliste_vorm",
         ".*courses/index_html",
         ".*ylesandedMuutmisTabelina",
         ".*ylesanneteTyypideLoetelu",
         ".*muutmisVorm",
         ".*lubadeViited",
         ".*koigiLuba",
         ".*isikuLubadeLisamisVorm",
         ".*grupiLubadeLisamisVorm",
         ".*/kasutajateSyndmusteTabel",
         ".*/filtreerimisvorm2",
         ".*/kasutajateTulemused",
         ".*/typesets",
         #".*",         
       )
       leitud=0
       x=veebiurl
       for lause in laused:
         if re.match(lause, x):
           leitud=1
       return leitud

    security.declarePublic('kas_kasutaja_haldus')
    def kas_kasutaja_haldus(self, veebiurl):
       "kas sobib halduseks"
       laused=(
         ".*kasutajate_haldamise_vorm",         
         ".*kasutajateLisamisFailiVorm",         
         ".*kasutajaLehelt1",         
         ".*kasutajadFailist2",         
         ".*kasutajadFailist1",         
         ".*erialadeHalduseVorm",         
         ".*/kasutajaotsing",
         ".*/kasutajateKustutus.*",
         #".*",         
       )
       leitud=0
       x=veebiurl
       for lause in laused:
         if re.match(lause, x):
           leitud=1
       return leitud
       
       
    def kasKursuseVahetamiseTabel(self, REQUEST):
      "Kas vaja tabelit leivapuru ümber"
      if not self.kasutajaasukoht(REQUEST)=='Veebilaud': return 0
      if REQUEST.URL0.find('testivastused')>0 : return 0
      if REQUEST.URL0.find('syndmused')>0 : return 0 
  #      return int(REQUEST.URL0.find(str(REQUEST.AUTHENTICATED_USER)+'/webtop/c'))!=-1
      import string
      if int(string.find(REQUEST.URL0, str(REQUEST.AUTHENTICATED_USER)+'/webtop/c'))>0: return "Veebilaud"  
      if REQUEST.URL0.find(str(REQUEST.AUTHENTICATED_USER)+'/sahtel/c')>0: return "Sahtel"
      if REQUEST.URL0.find('paevikuleht')>0: return "Päevik"
      if int(string.find(REQUEST.URL0,'/webtop/c'))>0: return 1
      return 0


    def lisaSyndmus(self, REQUEST, syndmus, kasutajanimi=None,  lisaparameeter=None):
      "Kasutaja statistika lisamine"
      if(REQUEST == None):
        return "REQUEST puudub"
      if kasutajanimi is None:
        kasutajanimi=self.get_current_user(REQUEST)
      k=getattr(self.fle_root().fle_users, kasutajanimi).webtop
      kv=getattr(k, 'c'+str(self.fle_root().jooksva_kursuse_nr(self, REQUEST)))
      if not hasattr(kv.aq_inner, 'toimingud'):
        kv.aq_inner.toimingud={}
      if kv.aq_inner.toimingud.has_key(syndmus):
        kv.aq_inner.toimingud[syndmus]=kv.aq_inner.toimingud[syndmus]+1
      else:
        kv.aq_inner.toimingud[syndmus]=1
      kv.aq_inner.toimingud=kv.aq_inner.toimingud #kinnistus Zope tarvis
      return kv.aq_inner.toimingud        
      
    def kasutajaSyndmused(self, REQUEST, kasutajanimi):
      "Kasutaja syndmuste tabel"
      self.get_lang(('ivacommon', ), REQUEST)
      try:
        k=getattr(self.fle_root().fle_users, kasutajanimi)
        knr=self.fle_root().jooksva_kursuse_nr(self, REQUEST)
      except:
        return "</p>\n<p>" + REQUEST["L_ic_user_not_found"] + "</p>"
      try:
        kv=getattr(k.webtop, 'c'+str(self.fle_root().jooksva_kursuse_nr(self, REQUEST)))
      except:
        return "</p>\n<p>" + REQUEST["L_ic_no_user_data_in_this_course"] + "</p>"
      if not hasattr(kv, 'toimingud'):
          return "</p>\n<p>" + REQUEST["L_ic_no_events_for_user"] + "</p>"      
      tulemus="</p>\n<table border=\"0\" cellpadding=\"2\" cellspacing=\"1\" bgcolor=\"#EEEEEE\">\n"
#      for x in kv.syndmused.keys():
#        tulemus=tulemus+"\n<tr><td>"+x+"</td><td>"+str(kv.syndmused[x])+"</td></tr>\n"
      tulemus=tulemus+"<tr>\n<td class=\"t1\">"+REQUEST['L_ic_info_number_open_pages']+":</td>\n"+\
             "<td class=\"t1\">"+str(self.kysiKasutajaltSyndmus(REQUEST, k, knr, 'lehtiAvatud'))+"</td>\n</tr>"+\
        "\n<tr>\n<td class=\"t1\">"+REQUEST['L_ic_info_read_kb_notes']+":</td>\n"+\
             "<td class=\"t1\">"+str(self.kysiKasutajaltSyndmus(REQUEST, k, knr, 'sonumeidLoetud'))+"</td>\n</tr>"
             
      tulemus=tulemus+"\n<tr>\n<td class=\"t1\">"+REQUEST['L_ic_info_added_kb_notes']+":</td>\n"+\
             "<td class=\"t1\">"+str(self.kysiKasutajaltSyndmus(REQUEST, k, knr, 'sonumeidLisatud'))+"</td>\n</tr>"+\
        "\n<tr><td class=\"t1\">"+REQUEST['L_ic_info_added_jamming_artefacts']+":</td>\n"+\
             "<td class=\"t1\">"+str(self.kysiKasutajaltSyndmus(REQUEST, k, knr, 
'lisatudMeediaFaile'))+"</td>\n</tr>"+\
        "\n<tr>\n<td class=\"t1\">"+REQUEST['L_ic_info_test_results']+":</td>\n"+\
             "<td class=\"t1\">"+self.kasutajaTestiTulemused(REQUEST, k, knr)+"</td>\n</tr>\n"
      tulemus=tulemus+"<tr>\n<td class=\"t1\">"+REQUEST['L_ic_info_last_access']+":</td>\n"
      if k.last_active(knr):
          import time
          tulemus=tulemus+"<td class=\"t1\">"+time.strftime(REQUEST['L_timestamp_format'],time.localtime(k.last_active(knr)))+"</td>\n"
      else:
          tulemus=tulemus+"<td class=\"t1\">x</td>\n"
      tulemus=tulemus+"</tr>"
      kc=getattr(k.webtop, 'c'+str(knr))
      tulemus=tulemus+"\n<tr><td class=\"t1\">"+REQUEST['L_ic_info_total_mark']+":</td>\n<td class=\"t1\">"
      if hasattr(kc, 'koondhinne'):
          tulemus=tulemus+kc.koondhinne
      tulemus=tulemus+"</td>\n</tr>"

      tulemus=tulemus+"\n<tr><td class=\"t1\">"+REQUEST['L_ic_info_comment']+":</td>\n<td class=\"t1\">"
      if hasattr(kc, 'infoKommentaar'):
          tulemus=tulemus+kc.infoKommentaar
      tulemus=tulemus+"</td>\n</tr>\n"

      tulemus=tulemus+"</table>\n"
      return tulemus


      
    def kasutajaSyndmusedLehena(self, REQUEST, kasutajanimi):
      "Syndmused kujundatud lehel"      
      return self.hdr(self, REQUEST)+self.kasutajaSyndmused(REQUEST, kasutajanimi)+\
        self.fle_html_footer(self, REQUEST)
        
    def kysiKasutajaltSyndmus(self, REQUEST, kasutaja, knr, syndmus):
      "Sündmuse küsimine"
      if not hasattr(kasutaja.webtop, 'c'+str(knr)): return 0
      kv=getattr(kasutaja.webtop, 'c'+str(knr))
      if not hasattr(kv, 'toimingud'):
        return 0
      try:
       if not kv.toimingud.has_key(syndmus):
        return 0
      except:
       return 0
      return kv.toimingud[syndmus]
            
       
    def kasutajateSyndmusteTabel(self, REQUEST):
      "Kokkuvõte õpetajale"
      self.get_lang(('common','ivacommon'),REQUEST)
      import time
      tulemus=self.hdr(self, REQUEST)+"</p>\n<form action=\"kasutajateSyndmusteTabeliSalvestusLeht\">\n"
      tulemus=tulemus+"<table border=\"0\" cellpadding=\"2\" cellspacing=\"1\" bgcolor=\"#EEEEEE\">\n"
      tulemus=tulemus+"<tr>\n"+\
        "<th>"+REQUEST['L_ic_info_user_name']+"</th>\n"+\
        "<th>"+REQUEST['L_ic_info_number_open_pages']+"</th>\n"+\
        "<th>"+REQUEST['L_ic_info_added_kb_notes']+"</th>\n"+\
        "<th>"+REQUEST['L_ic_info_read_kb_notes']+"</th>\n"+\
        "<th>"+REQUEST['L_ic_info_added_jamming_artefacts']+"</th>\n"+\
        "<th>"+REQUEST['L_ic_info_test_results']+"</th>\n"+\
        "<th>"+REQUEST['L_ic_info_last_access']+"</th>\n"+\
        "<th>"+REQUEST['L_ic_info_total_mark']+"</th>\n"+\
        "<th>"+REQUEST['L_ic_info_comment']+"</th>\n"+\
        "</tr>\n"
      knr=self.fle_root().jooksva_kursuse_nr(self, REQUEST)
      kasutajad=getattr(self.fle_root().courses, knr).get_all_users()
      for x in kasutajad:
       try:
        kc=getattr(x.webtop, 'c'+str(knr))
        tulemus=tulemus+"<tr>\n"
        tulemus=tulemus+"<td class=\"t1\">"+x.get_id()+"</td>\n"
        tulemus=tulemus+"<td class=\"t1\" align=\"center\">"+str(self.kysiKasutajaltSyndmus(REQUEST, x, knr, 'lehtiAvatud'))+"</td>\n"
        tulemus=tulemus+"<td class=\"t1\" align=\"center\">"+str(self.kysiKasutajaltSyndmus(REQUEST, x, knr, 'sonumeidLisatud'))+"</td>\n"
        tulemus=tulemus+"<td class=\"t1\" align=\"center\">"+str(self.kysiKasutajaltSyndmus(REQUEST, x, knr, 'sonumeidLoetud'))+"</td>\n"
        tulemus=tulemus+"<td class=\"t1\" align=\"center\">"+str(self.kysiKasutajaltSyndmus(REQUEST, x, knr, 'lisatudMeediaFaile'))+"</td>\n"
        tulemus=tulemus+"<td class=\"t1\">"+self.kasutajaTestiTulemused(REQUEST, x, knr)+"</td>\n"
        if x.last_active(knr):
          tulemus=tulemus+"<td class=\"t1\">"+time.strftime(REQUEST['L_timestamp_format'],time.localtime(x.last_active(knr)))+"</td>\n"
        else:
          tulemus=tulemus+"<td class=\"t1\">x</td>\n"
        tulemus=tulemus+"<td class=\"t1\"><input type=\"text\" size=\"5\" name='"+x.get_id()+"Koondhinne' "
        if hasattr(kc, 'koondhinne'):
          tulemus=tulemus+"value='"+kc.koondhinne+"' "
        tulemus=tulemus+"/></td>\n"
        
        tulemus=tulemus+"<td class=\"t1\"><input type=\"text\" size=\"10\" name='"+x.get_id()+"InfoKommentaar' "
        if hasattr(kc, 'infoKommentaar'):
          tulemus=tulemus+"value='"+kc.infoKommentaar+"' "
        tulemus=tulemus+"/></td>\n"
        
        tulemus=tulemus+"</tr>\n"
       except:
         pass
              
      tulemus=tulemus+"</table>\n<input type=\"submit\" value=\""+REQUEST['L_ic_info_save']+"\" />\n</form>"+self.fle_html_footer(self, REQUEST)
      return tulemus

    def kasutajateSyndmusteTabeliSalvestusLeht(self, REQUEST):
      "Tulemuste salvestus"
      knr=self.fle_root().jooksva_kursuse_nr(self, REQUEST)
      kasutajad=getattr(self.fle_root().courses, knr).get_all_users()
      for x in kasutajad:
        koondhinne=getattr(REQUEST, x.get_id()+'Koondhinne')
        infoKommentaar=getattr(REQUEST, x.get_id()+'InfoKommentaar')
        kc=getattr(x.webtop, 'c'+str(knr))
        kc.koondhinne=koondhinne
        kc.infoKommentaar=infoKommentaar              
      REQUEST.RESPONSE.redirect('kasutajateSyndmusteTabel')

    def kasutajaTestiTulemused(self, REQUEST, kasutaja, knr):
      "Kasutaja kõikide testide lühikokkuvõte"
      kc=getattr(kasutaja.webtop, 'c'+str(knr))
      if not hasattr(kc, 'testivastused'):
        return ""
      kv=kc.testivastused
      tulemus=""
      for test in kv.objectValues():
#        tulemus=tulemus+test.get_id()+":"
       try:
        for variant in test.objectValues():
          tulemus=tulemus+" <a href='"+variant.absolute_url()+"'>"+variant.punktiArvutusLyhiHTML(REQUEST)+"</a>"
        tulemus=tulemus+";"
       except:
         pass
      return tulemus
      
    def kysiURLParameeter(self, REQUEST, parameeter):
      "Kui pole, siis tühi"
      if hasattr(REQUEST, parameeter):
        return REQUEST[parameeter]
      return ""      
      
    def filtreeriKasutajad(self, REQUEST, loetelu, enimi="", pnimi="", knimi="", org="-1"):
      "Kasutajate filtreerimine"
      tulemus=[]
      try:
        org=int(org)
      except:
        org=-1
      for kasutaja in loetelu:
        korras=1
        if not kasutaja.get_first_name().lower().startswith(enimi.lower()): korras=0
        if not kasutaja.get_last_name().lower().startswith(pnimi.lower()): korras=0
        if not kasutaja.get_uname().startswith(knimi.lower()): korras=0
        if org!=-1:
          if not kasutaja.get_organization().lower().startswith(self.fle_root().fle_users.kysiErialad(REQUEST)[int(org)].lower()): korras=0
        if korras:
          tulemus.append(kasutaja)
      return tulemus
      
    def filtreerimistest(self, REQUEST):
     "proov"
     return self.filtreeriKasutajad(REQUEST, self.fle_root().fle_users.get_users(), pnimi="J")
     
#    def iva_course_export(self, REQUEST):
#      "Iva kursuse eksport xml-ina ims-laadselt"
#      from ImportExportIMS import Kirjutus
#      k= Kirjutus(self.fle_root(), self.get_id())
#      import tempfile, os
#      #failinimi = tempfile.mktemp()
#      failinimi="c:\\temp\\test1.zip"
#      k.pakiTulemusFaili(failinimi)
#      file = open(failinimi,"rb")
#      export_data=file.read()
#      file.close()
#      print "nimi: "+failinimi
#      #os.remove(failinimi)
#      REQUEST.RESPONSE.setHeader('Content-disposition: attachment','filename=ivaexport.zip')
#      REQUEST.RESPONSE.setHeader('content-type','application/zip')
#      return export_data


# EOF

