# -*- coding: utf-8
# $Id: WebtopFolder.py,v 1.8 2003/08/18 07:44:24 berlingo Exp $
#
# 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

"""Contains class WebtopFolder, which represents a folder in a user's webtop."""

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

from copy import copy
from urllib import quote_plus, quote
import Globals
import time
from common import reload_dtml, add_dtml
from input_checks import is_valid_title, is_valid_url, strip_all
from WebtopItem import WebtopItem
from WebtopLink import WebtopLink
from WebtopMemo import WebtopMemo
from WebtopFile import WebtopFile
from Cruft import Cruft
import Webtop
import OFS
from OFS.ObjectManager import checkValidId
import FLE
from TempObjectManager import TempObjectManager
from AccessControl import ClassSecurityInfo
from common import add_dtml
from common import perm_view, perm_edit, perm_manage, perm_add_lo
from Products.ZWiki.ZWikiPage import ZWikiPage
from Products.PageTemplates.GlobalTranslationService import getGlobalTranslationService, DummyTranslationService

# This class acts as a container to other WebtopItems and as the factory
# object used to manipulate them.
class WebtopFolder(
    WebtopItem,
    OFS.Folder.Folder,
    TempObjectManager,
    Cruft):
    """A folder in a Webtop."""
    meta_type = "WebtopFolder"

    list_of_types=('WebtopFolder', 'WebtopLink', 'WebtopMemo', 'WebtopFile',
                   'GroupFolder', 'GroupFolderProxy')
    security = ClassSecurityInfo()
    service = getGlobalTranslationService()
    global service


    def index_html(self, REQUEST=None):
       "Avaleht"
#       print self.kasEsitluskaust(REQUEST)
       self.lisaSyndmus(REQUEST, 'kaustuVaadatud')
       return self.fle_root().wt_index_html(self, REQUEST)


    def __init__(self, parent, name):
        """Construct the webtop folder object."""
        WebtopItem.__init__(self,parent,name)
        #TempObjectManager.__init__(self)
        #new_reload_dtml(self, self.dtml_files)
        self.set_icon('images/folder_gif')

    security.declarePrivate('manage_afterAdd')
    def manage_afterAdd(self,item,container):
        """Clean up creation - create the TempObjectManager
        and set permissions."""
        #TempObjectManager.manage_afterAdd(self, item, container)
	#Vahur
        try:
          WebtopItem.manage_afterAdd(self, item, container)
        except:
          pass
        #self.manage_permission('Edit', ['FLEAdmin', 'Owner'], 1)

    # for ZCatalog
    security.declarePrivate('get_content')
    def get_content(self):
        """Return content (names of this folder's Webtop items in
        one string)"""
        return ' '.join(
            [o.get_name() for  o in self.objectValues(
            ('WebtopFolder', 'WebtopLink', 'WebtopMemo', 'WebtopFile'))])

    security.declareProtected(perm_view, 'has_content')
    def has_content(self):
        """Any WebtopItems in this folder?"""
        return len(self.objectIds(self.list_of_types)) > 0

    security.declareProtected(perm_view, 'list_contents_request')
    def list_contents_request(self, REQUEST):
        "jarjestab vastavalt Request parameeetrile suund"
        if hasattr(REQUEST, 'suund'):
           return self.list_contents(criteria=REQUEST['suund'])
        else:
           return self.list_contents(criteria='weight')


    security.declareProtected(perm_view, 'list_contents')
    def list_contents(self, criteria='',only_folder=''):
        """Returns a list of all different WebtopItems in this folder."""
        if criteria == '': criteria = 'date'

	if only_folder:
		objs = self.objectValues(only_folder)
	else:
	        objs = self.objectValues(self.list_of_types)

        if criteria == 'name':
            d = {}
            names = []
            for o in objs:
                name = o.get_name()
                names.append(name)
                d[name] = o

            names.sort()
            s_objs = []
            for n in names:
                s_objs.append(d[n])

            return s_objs

        elif criteria == 'size':
            d = {}
            sizes = []
            for o in objs:
                # We append name in order to get unique keys
                # 10 digits should be enough for everybody. :-)
                size = '%010d' % o.get_size() + o.get_name()
                sizes.append(size)
                d[size] = o

            sizes.sort()
            s_objs = []

            for n in sizes:
                s_objs.append(d[n])

            return s_objs


        elif criteria == 'date':
            d = {}
            timestamps = []
            for o in objs:
                # We append name in order to get unique keys
                timestamp = '%012.4f' % o.get_timestamp() + o.get_name()
                timestamps.append(timestamp)
                d[timestamp] = o

            timestamps.sort()
            timestamps.reverse()
            s_objs = []
            for n in timestamps:
                s_objs.append(d[n])

            return s_objs
	elif criteria == 'weight':
	    d = {}
	    sizes = []
	    for o in objs:
		if not hasattr(o,'weight'):
			o.weight = 1000
		size = '%010d' % o.weight + o.get_id()
		sizes.append(size)
		d[size] = o

	    sizes.sort()
	    sizes.reverse()
	    s_objs = []
	    for n in sizes:
		s_objs.append(d[n])

	    return s_objs

        else:
            raise 'FLE Error', 'Unknown sort criteria'

    def juhtLeht(self):
      "Kataloogi avaleht kokkupakitavasse arhiivi"
      t="<html><head><title>Kataloog</title></head><body>"
      t=t+self.get_name()+"<ul>"
      m=self.list_contents()
      for x in m:
        t=t+"<li>"
        if x.meta_type=="WebtopLink":
          t=t+"<a href='"+x.get_content()+"'>"+x.get_name()+"</a>"
        if x.meta_type=="WebtopMemo":
          t=t+"<a href='"+x.get_id()+".txt'>"+x.get_name()+"</a>"
        if x.meta_type=="WebtopFolder" or x.meta_type=="WebtopFile":
          t=t+"<a href='"+x.get_id()+"'>"+x.get_name()+"</a>"
        t=t+"</li>\n"
      t=t+"</ul></body></html>"
      return t
      

    def looArhiiv(self, REQUEST,  arhiiv=None, tee=""):
      "Kataloogide ning alamkataloogide arhiveerimiseks."
      algus=0
      import zipfile
      if arhiiv==None:
        import tempfile
        failinimi=tempfile.mktemp()
        arhiiv=zipfile.ZipFile(failinimi,"w",zipfile.ZIP_DEFLATED)
        algus=1
      tee=tee+self.get_id()+"/"
      m=self.list_contents()
      kasIndeks=0
      for x in m:
        if x.get_id()=="index.html":
          kasIndeks=1
      if not kasIndeks:
        arhiiv.writestr(zipfile.ZipInfo(tee+"index.html"), self.juhtLeht())
      for x in m:
        if x.meta_type=="WebtopFolder":
          print x.kasWikiKaust()
	  print x.absolute_url()
          x.looArhiiv(REQUEST, arhiiv, tee)
        if x.meta_type=="WebtopMemo":
          arhiiv.writestr(zipfile.ZipInfo(tee+x.get_id()+".txt"), x.get_body())
        if x.meta_type=="WebtopFile":
          arhiiv.writestr(zipfile.ZipInfo(tee+x.get_id()), str(x.get_content()))
      if algus:
        arhiiv.close()
        file = open(failinimi,"rb")
        export_data=file.read()
        file.close()
        import os
        os.remove(failinimi)
        REQUEST.RESPONSE.setHeader('content-type','application/zip')
        REQUEST.RESPONSE.setHeader('Content-disposition','attachment; filename=arhiiv.zip')
        return export_data
                                                                                            
    
    def laeArhiiv(self, REQUEST, arhiiviandmed):
      "Arhiivi laadimine kataloogi"
      import tempfile
      failinimi=tempfile.mktemp()
      fail=open(failinimi, "w+b")
      fail.write(arhiiviandmed.read())
      fail.close()
      import zipfile
      arhiiv=zipfile.ZipFile(failinimi, "r", zipfile.ZIP_DEFLATED)
      m=arhiiv.namelist()
      viga = ""
      for x in m:
        viga += self.lisaFail(REQUEST, x, arhiiv)
      return viga 
      
      
    def lisaFail(self, REQUEST, failinimi, arhiiv=None):
      "Loob kataloogitee alates jooksvast kataloogist ning lppu paigutab faili"
      self.get_lang(('ivacommon',),REQUEST)
      kaust=self
      m=failinimi.split("/")
      vastus = ""
      for x in m[0:-1]:
        if not hasattr(kaust.aq_self, x):
          kaust.lisa_kaust(x)
        kaust=getattr(kaust, x)
      try:
	      checkValidId(kaust,m[-1],allow_dup=1)
      except:
	      vastus += m[-1]+" - "+REQUEST['L_ic_invalid_filename']+"<br />"
      try:
	      if not vastus:
		      checkValidId(kaust,m[-1])
	              kaust.add_file(m[-1], arhiiv.read(failinimi), 1)      
      except:
#	      vastus += m[-1]+REQUEST['L_ic_filename_exists']+"<br />"
	      vastus += m[-1]+str(service.translate('iva','Error: Filename is already in use.',None,self))+"<br />"
      return vastus
        
        
    security.declareProtected(perm_edit, 'add_wiki_handler')
    def add_wiki_handler(
        self, REQUEST, my_name,
        submit = '', # form buttons
        cancel = '', #
        ):
        """Handles the input from folder add form."""

        self.get_lang(('common','webtop'),REQUEST)
        my_name = strip_all(my_name)
	import string
	my_name = string.replace(my_name,my_name[0],my_name[0].upper(),1)
        #if submit:
        if not cancel:
            if not is_valid_title(my_name):
                return self.message_dialog_error(
                    self, REQUEST,
                    title=REQUEST['L_invalid_name'],
                    message=REQUEST['L_give_valid_name'],
                    action='wt_add_wiki?my_name=%s' % quote_plus(my_name))
            if my_name in [o.get_name() for o in self.list_contents()]:
                return self.message_dialog_error(
                    self, REQUEST,
                    title=REQUEST['L_invalid_name'],
                    message=REQUEST['L_name_taken'] % my_name,
                    action='wt_add_wiki?name=%s' % quote_plus(my_name),
		    my_name=my_name)

            fold_obj = self.add_wiki(my_name)
            fold_obj.set_author(str(REQUEST.AUTHENTICATED_USER))
        elif cancel:
            pass
        else:
            # This code should never be reached.
            raise 'FLE Error', 'Unknown button'

        return REQUEST.RESPONSE.redirect(self.state_href(REQUEST, 'index_html'))
    security.declareProtected(perm_edit, 'add_folder_handler')
    def add_folder_handler(
        self, REQUEST, my_name,
        submit = '', # form buttons
        cancel = '', #
        ):
        """Handles the input from folder add form."""

        self.get_lang(('common','webtop'),REQUEST)
        my_name = strip_all(my_name)
        #if submit:
        if not cancel:
            if not is_valid_title(my_name):
                return self.message_dialog_error(
                    self, REQUEST,
                    title=REQUEST['L_invalid_name'],
                    message=REQUEST['L_give_valid_name'],
                    action='wt_add_folder?my_name=%s' % quote_plus(my_name))
            if my_name in [o.get_name() for o in self.list_contents()]:
                return self.message_dialog_error(
                    self, REQUEST,
                    title=REQUEST['L_invalid_name'],
                    message=REQUEST['L_name_taken'] % my_name,
                    action='wt_add_folder?name=%s' % quote_plus(my_name),
		    my_name=my_name)

            fold_obj = self.add_folder(my_name)
            fold_obj.set_author(str(REQUEST.AUTHENTICATED_USER))
        elif cancel:
            pass
        else:
            # This code should never be reached.
            raise 'FLE Error', 'Unknown button'

        return REQUEST.RESPONSE.redirect(self.state_href(REQUEST, 'index_html'))


    security.declarePublic('lisa_kursuse_kaust')
    def lisa_kursuse_kaust(
        self, REQUEST, my_name
        ):
        """Handles the input from folder add form."""

        self.get_lang(('common','webtop'),REQUEST)
        my_name = strip_all(my_name)
        fold_obj = self.lisa_kaust(my_name)
        fold_obj.set_author(str(REQUEST.AUTHENTICATED_USER))
             #self.manage_addProduct['OFSP'].manage_addFolder('omawiki');
#        wikiobj=ZWikiPage(source_string='', __name__='WikiStart')
#        wikiobj.title='pealkiri'
#        wikiobj._deleteOwnershipAfterAdd()
#        fold_obj._setObject('WikiStart', wikiobj)
#        print self.get_id()+" "+self.absolute_url()
#        if self.get_id()=='sahtel':
#        fold_obj.add_link('info', self.fle_root().absolute_url()+'/kasutajaSyndmusedLehena?kasutajanimi='+str(REQUEST.AUTHENTICATED_USER))
#        return REQUEST.RESPONSE.redirect(self.state_href(REQUEST, 'index_html'))


    security.declarePublic('lisa_kursuse_kaust_ilma_requestita')
    def lisa_kursuse_kaust_ilma_requestita(
        self, nimi, my_name
        ):
        """Handles the input from folder add form."""

        my_name = strip_all(my_name)
        fold_obj = self.lisa_kaust(my_name)
        fold_obj.set_author(nimi)
             #self.manage_addProduct['OFSP'].manage_addFolder('omawiki');
#        wikiobj=ZWikiPage(source_string='', __name__='WikiStart')
#        wikiobj.title='pealkiri'
#        wikiobj._deleteOwnershipAfterAdd()
#        fold_obj._setObject('WikiStart', wikiobj)
	return fold_obj


    security.declareProtected(perm_edit, 'lisa_kaust')
    def lisa_kaust(self,name):
        """Implementation of add_folder_handler without http code."""
        f = WebtopFolder(self,name)
        f.id=name
        self._setObject(name,f)
        return f.__of__(self)
        
    def lisa_info_viide(self, REQUEST):
      "test"
      self.add_link('info', self.fle_root().absolute_url()+'/kasutajaSyndmusedLehena?kasutajanimi='+str(REQUEST.AUTHENTICATED_USER))
      return "Valmis"

    def kasLubatudMuuta(self, REQUEST):
      "Kas kausta sisu tohib muuta. Kasutatakse lesannete esitamisel"
      if not self.kasEsitluskaust(REQUEST):
        return 1
      too=self.kysiToo(REQUEST)
      if not self.kasEsitluskaust(REQUEST):
	return 1
      if too.loppaeg:
        return time.time()<too.loppaeg
      return 1
      
    def viimaseMuutmisajaTeade(self, REQUEST):
      "Teade kaustas, kui kaua seda muuta tohib"
      self.get_lang(('ivatasks',),REQUEST)
      if not self.kasEsitluskaust(REQUEST): return ""
      too=self.kysiToo(REQUEST)
      if not hasattr(too, 'loppaeg'):
	      return ""
      if too.loppaeg:
        return REQUEST['L_ia_edit_deadline']+" "+time.strftime(REQUEST['L_timestamp_format'], time.localtime(too.loppaeg))
      return ""
        
        

#    def seaViimaneMuutmisAeg(self, REQUEST, aeg):
#      "Millise ajani tohib kausta sisu muuta"
#      if not self.kas_opetaja(self, REQUEST):
#        return "Pole muutmisluba"
#      self.viimaneMuutmisAeg=aeg

    def kasJuhend(self,REQUEST):
	""" kas kodutl on juhend """
	tulem = ""
	too = self.kysiToo(REQUEST)
	if not hasattr(too, 'juhend'):
		return
	if too.juhend == "":
		return
	elem = too.juhend.split("/")
	koht = self.fle_root()
	try:
		for obj in elem:
			if len(obj)>0:
				koht = getattr(koht, obj)
		obj_nimi = koht.get_name()
		tulem += "<a href=\""+self.fle_root().absolute_url()+too.juhend+"\">"+obj_nimi+"</a>"
	except:
		too.juhend = ""
		tulem = ""
	return tulem

    def kasEsitluskaust(self, REQUEST):
      "Kas kaust on meldud kodut esitamiseks"
      if hasattr(self, 'esitluskaust'):
	if self.esitluskaust != 0:
           return self.esitluskaust
      return 0
      
    def seaEsitluskaust(self, seisund):
      "Mratakse kas tegemist esitluskaustaga"
      if seisund:
        self.esitluskaust=1
      else:
        self.esitluskaust=0
      return "Seisund "+str(self.esitluskaust)
      
    def kysiToo(self, REQUEST):
      "Ligips kaustaga seotud t andmetele"
      nr=self.jooksva_kursuse_nr(REQUEST)
      m=self.absolute_url().split('/')
      vastus=-1
      veel=1
      i=0
      while veel and i<len(m):
        if m[i].startswith('too'):
#          if i+1<len(m):
            vastus=i
        i+=1
      if vastus==-1: return None
      toonimi=m[vastus]
      try:
	      return getattr(getattr(self.fle_root().courses, nr).kodutood, toonimi)
      except:
	      # mingil phjusel ei ole kodutd enam olemas...
	      self.seaEsitluskaust(0)
#	      return getattr(getattr(self.fle_root().courses, nr).kodutood, toonimi)
#      return getattr(getattr(self.fle_root().courses, nr).kodutood, self.id)
      
    
    def kysiPunktid(self, REQUEST=None):
      "Ksitakse esitlust punktid kui on"
      if hasattr(self, 'punktid'):
        return self.punktid
      return ""
      
    def kysiKommentaar(self, REQUEST=None):
      "Ksitakse esitlust kommentaar kui on"
      if hasattr(self, 'kommentaar'):
        return self.kommentaar
      return ""
      
    def esitluskaustaAndmed(self, REQUEST):
      "Vljastatakse kas hindamise vi vaatamise leht sltuvalt, kas tegemist petaja vi ppuriga"
      if self.kas_opetaja(self, REQUEST):
        return self.esitluskaustaHindamiseVorm(REQUEST)
      return self.esitluskaustaHinded(REQUEST)

    def esitluskaustaHindamiseVorm(self, REQUEST):
      "Esitluskaustas oleva hindamine"
      t=self.hdr(self, REQUEST)
      t+="<form action='esitluskaustaHindamiseLeht' method='post'>"
      too=self.kysiToo(REQUEST)      
      t+="<table>"
      t+="<tr><td>Normpunkte</td><td>"+str(too.normPunkte)+"</td></tr>"
      t+="<tr><td>Punktid</td><td><input type='text' name='punktid' value='"+str(self.kysiPunktid(REQUEST))+"'></td></tr>"
      t+="<tr><td>Kommentaar</td><td><textarea name='kommentaar' rows='4'>"+self.kysiKommentaar(REQUEST)+"</textarea></td></tr>"     
      t+="</table><input type='submit' value='Salvesta' />"
      t+="</form>"  
      t+=self.fle_html_footer(self, REQUEST)
      return t

    def esitluskaustaHindamiseLeht(self, REQUEST, punktid, kommentaar):
      "Andmete salvestus"
      import re
      punktid=re.sub(',', '.', punktid)
      try:
        self.punktid=float(punktid)
      except:
        pass
      self.kommentaar=kommentaar
      REQUEST.RESPONSE.redirect(self.fle_root().courses.absolute_url()+"/"+self.jooksva_kursuse_nr(self, REQUEST)+"/kasutajateHinneteTabel")
      
    def esitluskaustaHinded(self, REQUEST):
      "Esitluskaustas oleva hindamine"
      if not self.kasOmaVeebilaual(REQUEST):
	      return
      t=self.hdr(self, REQUEST)
      too=self.kysiToo(REQUEST)
      t+="<table><tr><td>Punktid</td><td>"+str(self.kysiPunktid(REQUEST))+"</td></tr>"
      t+="<tr><td>Kommentaar</td><td>"+self.kysiKommentaar(REQUEST)+"</td></tr>"     
      t+="</table>"
      t+=self.fle_html_footer(self, REQUEST)
      return t

    def kasWikiKaust(self,REQUEST=None):
	""" kas tegemist on wiki kaustaga """
	if hasattr(self,'wiki_kaust'):
		if self.wiki_kaust == 1:
			return 1
	return 0

    def wikiKaustEsimeneLeht(self,REQUEST=None):
	""" find ZWikiPage that has no parents """
	lehenimi = ""
	count = 0
	if hasattr(self,'cached_first_name'):
		if hasattr(self, self.cached_first_name):
			return self.cached_first_name
	if len(self.objectValues('ZWiki Page'))>0:
		pass
	else:
		return "../" 
	for obj in self.objectValues('ZWiki Page'):
#		print "'"+str(len(obj.parents))+"'"+str(obj.parents)+"'"
		if obj.parents == [] or obj.parents[0] == '':
			lehenimi = obj.__name__
			self.cached_first_name = lehenimi
			count = count +1
	if not lehenimi:
		if hasattr(self.aq_inner.aq_self, self.get_name()):
			lehenimi = self.get_name()
	return lehenimi

    def firstAndLast(self,uname=''):
	""" Give object author's first and last name """
	if not uname:
		abc = self.getOwnerTuple()[1]
	else:
		abc = uname
	ui = self.fle_users.get_user_info(str(abc))
	if ui.get_first_name()=='' and ui.get_last_name()=='':
		nimi = abc
	else:
		nimi = ui.get_first_name()+" "+ui.get_last_name()
	return nimi
      
    security.declareProtected(perm_edit, 'add_wiki')
    def add_wiki(self,name):
	from Products.ZWiki.ZWikiPage import ZWikiPage
        """Implementation of add_folder_handler without http code."""
        f = WebtopFolder(self,name)
	f.wiki_kaust = 1
        self._setObject(f.id,f)
	wikiobj = ZWikiPage(source_string='', __name__=name)
        wikiobj._deleteOwnershipAfterAdd()
        #wikiobj.title='pealkiri'
	f._setObject(name,wikiobj)
        return f.__of__(self)

    security.declareProtected(perm_edit, 'add_folder')
    def add_folder(self,name):
        """Implementation of add_folder_handler without http code."""
        f = WebtopFolder(self,name)
        self._setObject(f.id,f)
        return f.__of__(self)

    security.declareProtected(perm_edit, 'add_link_handler')
    def add_link_handler(
        self, REQUEST, my_name, url,
        type = '',
        submit = '', # form buttons
        cancel = '', #
        back_link = '', # 'add link to webtop' feature outside webtop
        ):
        """Handles the input from link add form."""

        if REQUEST:
            self.get_lang(('common','webtop'),REQUEST)
        my_name = strip_all(my_name)
        if submit:
            if not is_valid_title(my_name):
                return self.message_dialog_error(
                    self, REQUEST,
                    title=REQUEST['L_invalid_name'],
                    message=REQUEST['L_give_valid_name'],
                    action='wt_add_link?my_name=%s&my_url=%s' % \
                    (quote_plus(my_name), quote_plus(url)))
            elif my_name in [o.get_name() for o in self.list_contents()]:
                return self.message_dialog_error(
                    self, REQUEST,
                    title=REQUEST['L_invalid_name'],
                    message=REQUEST['L_name_taken'] % my_name,
                    action='wt_add_link?my_name=%s&url=%s' % \
                    (quote_plus(my_name), quote_plus(url)))
            if not is_valid_url(url):
                return self.message_dialog_error(
                    self, REQUEST,
                    title=REQUEST['L_invalid_url'],
                    message=REQUEST['L_give_valid_url'],
                    action='wt_add_link?my_name=%s&url=%s' % \
                    (quote_plus(my_name), quote_plus(url)))
            link_obj = self.add_link(my_name, url)
            self.lisaSyndmus(REQUEST, 'linkeLisatud')
            link_obj.set_author(str(REQUEST.AUTHENTICATED_USER))
        elif back_link:
            if not is_valid_title(my_name):
##                return self.message_dialog(
##                    self, REQUEST,
##                    title=REQUEST['L_invalid_name'],
##                    message=REQUEST['L_give_valid_name'],
##                    action=back_link)
                # I think raise is more appropriate here because
                # if we have invalid name here, we have a _bug_
                # and not an user error. --jmp 2002-02-20
                raise 'FLE Error', 'Invalid name for link.'

            # If name already exists generate a new name...
            my_name = self.__build_name(my_name)

            link_obj = self.add_link(my_name,url,1)
            link_obj.set_author(str(REQUEST.AUTHENTICATED_USER))
            if REQUEST:
                return self.message_dialog(
                    self, REQUEST,
                    title=REQUEST['L_webtop_link_added'],
                    message=REQUEST['L_added_webtop_link'] % (type, my_name),
                    action=back_link)
            else:
                return
        elif cancel:
            pass
        else:
            # This code should never be reached.
            raise 'FLE Error', 'Unknown button'

        if REQUEST:
            REQUEST.RESPONSE.redirect(self.state_href(REQUEST, 'index_html'))

    security.declarePrivate('add_link')
    def add_link(self,name,url_or_obj,internal=0):
        """Implementation of add_link_handler without http code."""
        l = WebtopLink(self,name,url_or_obj,internal)
        self._setObject(l.id,l)
        return l.__of__(self)

    security.declarePrivate('add_group_folder_proxy')
    def add_group_folder_proxy(self, name, course_id):
        """Create GroupGolderProxy into WebtopFolder."""
        from GroupFolderProxy import GroupFolderProxy
        uname = str(self.getOwner())

        name = self.__build_name(name)

        l = GroupFolderProxy(self, name, course_id)
        self._setObject(l.id, l)

        l.changeOwnership(self.acl_users.getUser(uname).__of__(self.acl_users))

        # Copy local roles that user (owner of the WebtopFolder) has
        # on the course to the GroupFolderProxy. (+ everybody should
        # own her own GroupFolderProxy!)
        for user, roles in self.courses.get_child(course_id).get_local_roles():
            if uname == user:
                self.get_child(l.id).manage_setLocalRoles(uname,
                                                          roles + ('Owner',))
                return

        raise 'FLE Error', 'User does not have any role in the course!'

    security.declarePrivate('recursive_delete_group_folder_proxy')
    def recursive_delete_group_folder_proxy(self, course_id):
        """Delete all GroupFolderProxy objects (pointing to given
        course) in this folder and recursively in all subfolders."""

        for proxy in self.objectValues('GroupFolderProxy'):
            if proxy.get_course_this_belongs_to().get_id() == course_id:
                self._delObject(proxy.get_id())

        for folder in self.objectValues('WebtopFolder'):
            folder.recursive_delete_group_folder_proxy(course_id)

    security.declareProtected(perm_edit, 'add_file_handler')
    def add_file_handler(
        self, REQUEST, my_name, file=None,
        key = '',
        submit = '', # form buttons
        cancel = '', #
        ):
        """Handles the input from upload form."""

        self.get_lang(('common','webtop', 'coursemgmnt'),REQUEST)
        nimetu=0
        my_name = strip_all(my_name)
          
        if submit:
            message = ''

            if self.absolute_url().find('fle_users')>=0:
             if self.get_quota() >= 0: # Quota in use?
                # Would we exceed the quota?
                if file and len(file.filename):
                    file.seek(0, 2)
                    size = self.find_class_obj(Webtop.Webtop).get_size() + \
                           file.tell()
                    file.seek(0, 0)

                    if size > self.get_quota():
                        return self.message_dialog_error(
                            self, REQUEST,
                            title=REQUEST['L_quota_reached_title'],
                            message=REQUEST['L_quota_reached'],
                        action='index_html')

            if len(my_name)==0:
              nimetu=1
              nimemassiiv=file.filename.split("\\")
              my_name=nimemassiiv[-1]
            # Check name
            if not is_valid_title(my_name):
                message = REQUEST['L_give_valid_name']+'. '
            elif my_name in [o.get_name() for o in self.list_contents()]:
                message = REQUEST['L_name_taken'] % my_name

            # Check file
            if not key:
                if (not file) or len(file.filename) is 0:
                    message += ' '+REQUEST['L_no_file_supplied']

            if message:
                if (not key) and file and len(file.filename) > 0:
                    key = self.add_tmp_object(WebtopFile(self, 'spam', file))
                if key: action = 'wt_upload?key=%s&my_name=%s' % \
                                 (quote_plus(key),
                                  quote_plus(my_name))
                else: action = 'wt_upload?my_name=%s' % quote_plus(my_name)
                return self.message_dialog_error(
                    self, REQUEST,
                    title=REQUEST['L_error'],
                    message=message,
                    action=action)
            else:
                if key:
                    f = self.remove_tmp_object(key)
                    f.set_name(my_name)
                    self._setObject(f.id,f)
                    f.set_author(str(REQUEST.AUTHENTICATED_USER))
                else:
                    if nimetu:
                      file_obj = self.add_file(my_name,file, 1)
                    else:
                      file_obj = self.add_file(my_name,file, 0)
                    file_obj.set_author(str(REQUEST.AUTHENTICATED_USER))
                    self.lisaSyndmus(REQUEST, 'faileLisatud')

        elif cancel:
            if key: self.remove_tmp_object(key)
        else:
            # This code should never be reached.
            raise 'FLE Error', 'Unknown button'
        REQUEST.RESPONSE.redirect(self.state_href(REQUEST, 'index_html'))

    security.declarePrivate('add_file')
    def add_file(self,name,file, nimiIDks=0):
        """Implementation of add_file_handler without http code."""
        if nimiIDks:
          f = WebtopFile(self, name, file, name)
        else:
	  suffix = str(file.filename.split(".")[-1])
          f = WebtopFile(self, name, file)
	  f.id = f.id + "."+suffix
        self._setObject(f.id,f)
        return f.__of__(self)

    security.declareProtected(perm_edit, 'add_memo_handler')
    def add_memo_handler(
        self,
        REQUEST,
        my_name,
        contents,
        submit='',
        cancel=''):
        """Handles the input from memo add form."""

        self.get_lang(('common','webtop'),REQUEST)
        my_name = strip_all(my_name)
        if submit:
            if not is_valid_title(my_name):
                return self.message_dialog_error(
                    self, REQUEST,
                    title=REQUEST['L_invalid_name'],
                    message=REQUEST['L_give_valid_name'],
                    action='wt_add_memo?my_name=%s&contents=%s' % \
                    (quote_plus(my_name), quote_plus(contents)))
            elif my_name in [o.get_name() for o in self.list_contents()]:
                return self.message_dialog_error(
                    self, REQUEST,
                    title=REQUEST['L_invalid_name'],
                    message=REQUEST['L_name_taken'] % my_name,
                    action='wt_add_memo?my_name=%s&contents=%s' % \
                    (quote_plus(my_name), quote_plus(contents)),
		    my_name=my_name,
		    contents=contents)
            else:
                memo_obj = self.add_memo(my_name,contents)
                memo_obj.set_author(str(REQUEST.AUTHENTICATED_USER))
                self.lisaSyndmus(REQUEST, 'memosidLisatud')

        elif cancel:
            pass
        else:
            # This code should never be reached.
            raise 'FLE Error', 'Unknown button'

        REQUEST.RESPONSE.redirect(self.state_href(REQUEST, 'index_html'))

    security.declarePrivate('add_memo')
    def add_memo(self,name,contents):
        """Implementation of add_memo_handler without http code."""
        m = WebtopMemo(self,name,contents)
        self._setObject(m.id,m)
        return m.__of__(self)

    security.declareProtected(perm_edit, 'form_handler')
    def form_handler(
        self,
        item_ids=None,
        copy='', cut='', dublikaat='', paste='', remove='', rename='', # submit buttons
        kalendrisse='', paki='', arhiivifail=None, lae='', REQUEST=None, cancel='',paki2=''):
        """Handles the input from folder default form:
        item copy/cut/paste, remove and rename operations."""
        self.get_lang(('common','webtop','coursemgmnt','ivacommon'),REQUEST)

        # Quota reached? (GroupFolders don't use quota.)
        import common
	if cancel:
		REQUEST.RESPONSE.redirect(self.state_href(REQUEST, 'index_html'))
		return
        if not common.intersect_bool(
            ('GroupFolder', 'GroupFolderProxy'),
            [t[0].meta_type for t in self.list_parents_to_top()]) \
            and self.is_quota_limit_reached() and (copy or cut or paste):
            if REQUEST:
                return self.message_dialog_error(
                    self, REQUEST,
                    title=REQUEST['L_quota_reached_title'],
                    message=REQUEST['L_quota_reached'],
                    action='index_html')
            else:
                raise 'FLE Error', \
                      "Can't copy/cut/paste when quota is reached."



        if item_ids is None and paste or paki or lae:
            if paste:
              self.paste(REQUEST)
            elif paki:
		if paki2:
#			REQUEST.RESPONSE.redirect('..')
			return self.looArhiiv(REQUEST)
		else:
			REQUEST.RESPONSE.redirect('wiki_manage')
			return
#              return self.looArhiiv(REQUEST)
            elif lae:
              tulem = self.laeArhiiv(REQUEST, arhiivifail)
	      if tulem:

#		      return self.message_dialog_error()
#		      html = self.hdr(self, REQUEST)+"<br /><br />"
		      #tulem = REQUEST['L_ic_filename_exists']+"<br />"+tulem
		      tulem = service.translate('iva','Error: Filename is already in use.',None,self)
		      return tulem+"a"
		      return html+tulem+self.fle_html_footer(self, REQUEST)
        elif item_ids:
            from types import StringType
            if type(item_ids) is StringType:
                item_ids=(item_ids,)
            objs = self.map_ids_to_objects(item_ids)

            if remove:
                self.remove(objs)
            elif copy:
                self.copy(objs)
            elif cut:
                self.cut(objs)
            elif dublikaat:
                self.dublikaat(objs, REQUEST)
            elif kalendrisse:
                self.kalendrisse(REQUEST, objs)
            elif rename:
#                print str(quote(repr(item_ids)))
                REQUEST.RESPONSE.redirect(
                    self.state_href(REQUEST, 'wt_rename?item_ids=%s' % \
                                    quote(repr(item_ids))))
                return
            else:
                raise 'No action specified!'
        else:
            if REQUEST:
                return self.message_dialog_error(
                    self, REQUEST,
                    title=REQUEST['L_no_item_selected'],
                    message=REQUEST['L_select_item_first'],
                    action='index_html')

        if not kalendrisse:
          REQUEST.RESPONSE.redirect(self.state_href(REQUEST, 'index_html'))

    # FIXME: input_checks
    security.declareProtected(perm_edit, 'rename_helper')
    # This is called from wt_rename to convert a list stored in url
    # back to list. There are two cases:
    #
    # 1. User select some object on index_html page and clicks 'rename':
    #
    #    index_html(dtml) -> form_handler -> redirect to wt_rename(dtml)
    #
    #    In this case only Ids of objects are passed to form_handler
    #
    #
    # 2. As long user gives invalid input we are in the following loop:
    #
    #    wt_rename -> rename_handler -> message_dialog(dtml) -> wt_rename
    #
    #    Here we have pass user's invalid names back to wt_rename so
    #    that user doesn't have to start everytime from scratch.
    def rename_helper(self, expr1, expr2=None):
        """Helper function for DTML method wt_rename.dtml"""
        if not expr2:
            return eval(expr1)
        else:
            id_list = eval(expr1)
            name_list = eval(expr2)
            retval = []
            for i in range(len(id_list)):
                retval.append((id_list[i], name_list[i]))
            return retval

    security.declarePrivate('get_clipboard')
    def get_clipboard(self):
        """Locates and returns a reference to the webtop's clipboard."""
        return self.parent().get_clipboard()

    security.declareProtected(perm_view, 'is_clipboard_empty')
    def is_clipboard_empty(self):
        """Is clipboard empty?"""
        return not self.get_clipboard().objectIds()

    def __clear_clipboard(self):
        """Empties the webtop's clipboard."""
        clip = self.get_clipboard()
        for item_id in clip.objectIds():
            clip._delObject(item_id)
        return clip

    security.declarePrivate('copy')
    def copy(self,items):
        """Copies items into the webtop's clipboard."""
        clip = self.__clear_clipboard()
        for item in items:
            newitem = item._getCopy(self)
            #print "[copied item: %s from %s]" % (repr(newitem), repr(item))
            newitem.id = self.generate_id()
            clip._setObject(newitem.id,newitem)
        #print "CLIPBOARD: %s" % repr(clip.objectItems())

    security.declarePrivate('cut')
    def cut(self,items):
        """Cuts items into the webtop's clipboard."""
        clip = self.__clear_clipboard()
        for item in items:
            self._delObject(self.find_id_used_in_parent(item))
            clip._setObject(item.id,item)
        #print "CLIPBOARD: %s" % repr(clip.objectItems())

    def dublikaat(self, items, REQUEST):
       "Dublikaat sahtlist webtoppi"
       for item in items:
         newitem=item._getCopy(self)
         if self.kysiSisegrupiNimi():
           sihtkoht=self.kysiSisegrupiAvalikKaust()
         else:
           sihtkoht=getattr(self.parent().webtop, 'c'+self. get_jooksev_kursus())
         newitem.id=sihtkoht.generate_id()
         newitem.set_name(sihtkoht.__build_name(newitem.get_name(), REQUEST))
         sihtkoht._setObject(newitem.id, newitem)
         
    def kysiSisegrupiNimi(self):
       "otsib, kas tegemist sisegrupiga ja teatab nime"
       import string
       if self.absolute_url().find('sisegrupid')>=0:
         k=self
         while k.aq_parent.id!='sisegrupid':
           k=k.aq_parent
         return k.id
       return 0
       
    def kysiSisegrupiAvalikKaust(self):
      "Kaust kuhu lisada"
      k=self
      while k.aq_parent.id!='courses':
        k=k.aq_parent
      r=k.ryhmalauad
      m=r.objectValues('WebtopFolder')
      kaust=None
      nimi=self.kysiSisegrupiNimi()
      for x in m:
        if x.get_name()==nimi:
          kaust=x
      return kaust
      
    def kalendrisse(self, REQUEST, items):
       "Viide sndmusena kalendrisse"
       import Kalender
       from Kalender import KalendriSyndmus
       k=self.kysiSyndmusteKataloog()
       esimene=None
       for e in items:
         s=e.absolute_url()[len(self.fle_root().absolute_url()):]       
         nr=str(k.kysiUusNr())
         s=KalendriSyndmus(e.get_name(), siseviide=s)
         s.id=nr
         k._setObject(nr, s)
         if esimene==None: esimene=s
       if esimene:
         REQUEST.RESPONSE.redirect(k.absolute_url()+"/"+nr+"/changeEvent")
       


    # FIXME: i18n word 'copy'
    def __build_name(self,name, REQUEST):
        """Constructs a name for an item pasted from the clipboard.
        If the item's own name is already used, a suitable
        postfix is added."""
        self.get_lang(('ivacommon',),REQUEST)                 
        if not self.name_exists(name):
            return name

        iter = 1
        newname=name+' ('+REQUEST['L_ic_copy1']+')'
        while self.name_exists(newname):
            iter += 1
            newname=name+' ('+REQUEST['L_ic_copy2']+' ' + str(iter) + ')'
        return newname

    security.declarePrivate('paste')
    def paste(self, REQUEST):
        """Pastes items from the webtop's clipboard."""
        clip = self.get_clipboard()
        for item in clip.objectValues():
            newitem = item._getCopy(self)
            #print "[pasted item: %s]" % repr(newitem)
            newitem.id = self.generate_id()
            newitem.set_name(self.__build_name(newitem.get_name(), REQUEST))
            self._setObject(newitem.id,newitem)

    security.declarePrivate('remove')
    # items: list of removable object references in current
    def remove(self,items):
        """Removes items from this folder, placing them in trash.
        Or actually: in the tmp_objects folder inside this WebtopFolder."""
        for item in items:
#            self.move_to_tmp(item)
           self._delObject(item.get_id())

    security.declareProtected(perm_edit, 'rename_handler')
    def rename_handler(
        self, REQUEST,
        item_id_list,
        new_name_list,
        submit = '', # form buttons
        cancel = '', #
        ):
        """Handles rename_form submission."""

        if submit:

            bad_names = []
            for name in new_name_list:
                if not is_valid_title(name):
                    bad_names.append(name)

            if bad_names:
                self.get_lang(('common', 'webtop',),REQUEST)
                return self.message_dialog_error(
                    self, REQUEST,
                    title=REQUEST['L_invalid_name'],
                    message=REQUEST['L_invalid_names'] +' %s' % \
                    " ".join([repr(n) for n in bad_names]),
                    action='wt_rename?item_ids=%s&names=%s' % \
                    (quote(repr(item_id_list)),
                     quote(repr(new_name_list))))

            # Same name given for several object?
            new_names = list(copy(new_name_list))
            new_names.sort()
            for i in range(len(new_names)-1):
                if new_names[i] == new_names[i+1]:
                    self.get_lang(('webtop',),REQUEST)
                    return self.message_dialog_error(
                        self, REQUEST,
                        title=REQUEST['L_invalid_name'],
                        message=REQUEST['L_same_names'],
                        action='wt_rename?item_ids=%s&names=%s' % \
                        (quote(repr(item_id_list)),
                         quote(repr(new_name_list))))


            # Some other object has already some given name?

            # FIXME: slow: 'not in' inside loop...
            names_in_use = [o.get_name() for o in \
                            filter(lambda x, y=item_id_list: \
                                   x.get_id() not in y,
                                   self.list_contents())]

            bad_names = []
            for name in new_name_list:
                if name in names_in_use:
                    bad_names.append(name)

            if bad_names:
                self.get_lang(('webtop',),REQUEST)
                return self.message_dialog_error(
                    self, REQUEST,
                    title=REQUEST['L_invalid_name'],
                    message=REQUEST['L_names_in_use'] + ' %s' % \
                    " ".join([repr(n) for n in bad_names]),
                    action='wt_rename?item_ids=%s&names=%s' % \
                    (quote(repr(item_id_list)),
                     quote(repr(new_name_list))))

            for i in range(len(item_id_list)):
                (id, name) = (item_id_list[i], new_name_list[i])
                self.rename(self.get_child(id), name)

        elif cancel:
            pass
        else:
            # This code should never be reached.
            raise 'FLE Error', 'Unknown button'


        REQUEST.RESPONSE.redirect(self.state_href(REQUEST, 'index_html'))

    security.declarePrivate('name_exists')
    def name_exists(self,name):
        """Checks whether a given name exists already in the folder."""
        for item in self.objectValues():
            if hasattr(item,'get_name'):
                if item.get_name()==name:
                    return 1
        return 0

    security.declarePrivate('rename')
    # Input checks are done in rename_handler.
    def rename(self,objref,new_item_name):
        """Implementation of item rename."""
        objref.set_name(new_item_name)

    security.declareProtected(perm_view, 'get_size')
    def get_size(self):
        """Return size of the object."""
        size = 0

        for o in self.objectValues(
            ('WebtopFolder', 'WebtopLink', 'WebtopMemo', 'WebtopFile')):
            size += o.get_size()

        return size


    def viimaneMuutus(self):
       "Viimane muutus andmepuus"
       muutusaeg=self.get_timestamp()
       for o in self.objectValues(
            ('WebtopFolder', 'WebtopLink', 'WebtopMemo', 'WebtopFile')):
            if o.get_timestamp()>muutusaeg:
               muutusaeg=o.viimaneMuutus()
       return muutusaeg
      
    def kylastus(self, REQUEST):
       "Klastusaja seadmine"
       import time
       if not hasattr(self.aq_self, 'kylastused'):
          self.aq_self.kylastused={}
       self.aq_self.kylastused[str(REQUEST.AUTHENTICATED_USER)]=time.time()
       self.aq_self.kylastused=self.aq_self.kylastused

    def kylastajateLoetelu(self, REQUEST):
      "Millal ja kes viimati vaadanud"
      self.get_lang(('ivacommon',),REQUEST)
      import YlTest
      tulemus=self.hdr(self, REQUEST)+ " &gt; " + REQUEST['L_ic_viewers']+"</p>\n"
      if not hasattr(self.aq_self, 'kylastused'):
         self.aq_self.kylastused={}
      if len(self.aq_self.kylastused)==0:
        tulemus=tulemus+ "<p>"+REQUEST['L_ic_nobody_read']+"</p>\n"             
      else:
        tulemus=tulemus+"<h2>"+REQUEST['L_ic_viewed_by']+"</h2>" 
        tulemus=tulemus+ "<table border=\"0\" cellpadding=\"2\" cellspacing=\"1\" bgcolor=\"#EEEEEE\">\n"
        tulemus=tulemus+ "<tr>\n<th width=\"200\">"+REQUEST['L_ic_name']+"</th>\n<th width=\"100\">"+\
                                                   REQUEST['L_ic_date']+"</th>\n</tr>\n"
        for x in self.aq_self.kylastused.keys():
          tulemus=tulemus+"<tr>\n<td class=\"t1\" width=\"200\">"+x+"</td>\n<td class=\"t1\" width=\"100\">\n"
          tulemus=tulemus+self.get_printable_day(self.aq_self.kylastused[x], REQUEST)+"</td>\n</tr>\n"
        tulemus=tulemus+"</table>\n"
      tulemus=tulemus+self.fle_html_footer(self, REQUEST)
      return tulemus        

       
    def viimaneKylastus(self, REQUEST):
       "Vastava kasutaja viimatine klastusaeg, puudumisel 0" 
       if not hasattr(self.aq_self, 'kylastused'):
          return 0
       if not self.aq_self.kylastused.has_key(str(REQUEST.AUTHENTICATED_USER)):
          return 0
       return self.aq_self.kylastused[str(REQUEST.AUTHENTICATED_USER)]
       
    def kasMuudetudParastKylastust(self, REQUEST):
       "jah/ei"
       return self.viimaneMuutus()>self.viimaneKylastus(REQUEST)

    def proov(self):
	""" proov """
	import re
	print self.wikiKaustEsimeneLeht()
	page = getattr(self,self.wikiKaustEsimeneLeht())
	t = page.preRendered()
	t = page.renderMarkedLinksIn(t)
	if page.hasFitTests(): t = page.runFitTestsIn(t)
	if page.isIssue(): t = page.addIssueFormTo(t)
	t = page.renderMidsectionIn(t)
	a = t
	eelmine = ""
	yle = ""
	link = 0
	linktext = ""
	uustext = ""
	for x in a:
		if x == "a" and eelmine == "<":
			link = 1
			linktext = "<"
			uustext = uustext[:-1]
		if x == ">" and eelmine == "a" and yle == "/":
			link = 0
			linktext += ">"
			if not re.search(">\?</",linktext):
				print linktext
#
#a = re.search('\"(.*)\"',link)
#re.sub(link[a.start()+1:a.end()-1],'KALA',link)
#a = re.search('>(.*)<',link)
#re.sub(link[a.start()+1:a.end()-1],'KALA',link)
#
			linktext = ""
			continue
		if link:
			linktext += x
		else:
			uustext += x
		yle = eelmine
		eelmine = x
	uustext += eelmine
	return uustext


#    def lisaYlesanneteHoidla(self):
#       "Hoidla lisamine"
#       #XXX
#       #from YlTest import *
#       from YlHoidla import TestiYlesanneteHoidla
#       self._setObject('hoidla', TestiYlesanneteHoidla())
#       self.hoidla.id='hoidla'
#       return "hoidla lisatud"


Globals.InitializeClass(WebtopFolder)
# EOF
