# -*- 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
from OFS import SimpleItem
import types
import time
from TraversableWrapper import Traversable
from Globals import Persistent
from AccessControl import ClassSecurityInfo, getSecurityManager, Unauthorized
from Cruft import Cruft
from common import translate, perm_edit, perm_view, mkTime
from Products.ZCatalog.CatalogPathAwareness import CatalogAware
from input_checks import strip_tags
from DateTime import DateTime
import calendar
calendar.setfirstweekday(0)

from zope.interface import implements
from interfaces import ICalendar, IEvent

class KalendriSyndmus(
     OFS.SimpleItem.Item,
     Persistent,
     AccessControl.Role.RoleManager,
     Traversable,
     Cruft,
     CatalogAware
     ):
     """ Teade kalendris """
     meta_type = 'Event'
     implements(IEvent)
     security = ClassSecurityInfo()
     security.declareObjectPublic()
     
     def __init__(self, nimi, pikk='', algus=-1, lopp=-1, viide="", siseviide="", olek=0,blokerid=[]):
       "Alustus"
       if algus == -1:
        algus = time.time()
       if lopp == -1:
        lopp = time.time()
       self.nimi=nimi
       self.pikk=pikk
       self.algus=algus
       self.lopp=lopp
       self.viide=viide
       self.siseviide=siseviide
       self.blokerid = []
       self.olek=olek #0-ajatu sündmus 1-lõpetamata töö 2-lõpetatud töö
       self.icon_tag=None
       self.default_catalog = 'catalog_events'

     security.declareProtected(perm_view,'getName')
     def getName(self):
         """ Event name """
         return self.nimi

     security.declareProtected(perm_view,'getIconTag')
     def getIconTag(self):
         if not hasattr(self,'icon_tag'):
                 self.icon_tag = None
         if self.icon_tag is not None:
             if self.icon_tag.endswith('odune'):
                 self.icon_tag += '.gif'
         if self.icon_tag is not None:
                 result = "<img src=\"++resource++"+self.icon_tag+"\" alt=\"This is homework event\" title=\"This is homework event\" />"
         else:
                 result = ""
         return result

     security.declareProtected(perm_view,'setIconTag')
     def setIconTag(self,path):
         self.icon_tag = path
         self.icon_tag = self.icon_tag
         return self.icon_tag
       
     def getContent(self):
         """ Event content """
         return self.pikk
       
     security.declarePublic('kysiAlgus')
     def kysiAlgus(self):
       "Syndmuse algusaeg"
       return self.algus

     def kysiLopp(self):
       "Syndmuse lõppaeg"
       return self.lopp

     def get_start_time(self):
         """ Event start time in DateTime format """
         return DateTime(self.kysiAlgus()).ISO()

     def get_end_time(self):
         """ Event end time in DateTime format """
         return DateTime(self.kysiLopp()).ISO()
       
     def aegTekstina(self, REQUEST, aeg, timestamp=''):
       "tekstiesitus"
       if aeg==-1: return "*"
       if not timestamp:
               timestamp = translate(self,'timestamp_format',default="%H:%M %Y-%m-%d")
       else:
               timestamp = REQUEST[timestamp]
       return time.strftime(timestamp, time.localtime(aeg))

     def tekstAjana(self, REQUEST, ajatekst):
       "Tagasi ajaformaati"
       return mktime(time.strptime(translate(self,'timestamp_format',default="%H:%M %Y-%m-%d")), ajatekst)

     def kysiViide(self):
       "Välisviide"
       return self.viide
       
     def kysiSiseviide(self):
       "Siseviide"
       return self.siseviide
       
     def kysiSiseviiteURL(self):
       "Siseviide"
       return self.fle_root().absolute_url()+self.siseviide
       
     def siseviiteNimi(self):
       "Nagu funktsiooni nime ütleb"
       import re
       if self.siseviide=="": return ""
       m=self.siseviide.split("/")
       o=self.fle_root()
       try:
         for x in m:
           if len(x)>0:
            o=getattr(o, re.sub('%20',' ',x))
       except:
         return ""
       return o.get_name()
       
     def kysiSiseviiteLink(self):
         "Koos"
         return "<a href='"+self.kysiSiseviiteURL()+"'>"+self.siseviiteNimi()+"</a>"
       
     def kysiOlek(self):
       "Sündmuse olek"
       if hasattr(self, 'olek'): return self.olek
       return 0

     def getPersonalStatus(self,REQUEST):
         """ """
         if hasattr(self, 'status_'+str(REQUEST.AUTHENTICATED_USER)):
                 return getattr(self,'status_'+str(REQUEST.AUTHENTICATED_USER))
         else:
                 return 0
         return 0
       
     def olekuVarv(self, REQUEST):
       "Olekut illustreeriv lahter"
       if self.getPersonalStatus(REQUEST):
               stat = self.getPersonalStatus(REQUEST)
       else:
               stat = self.kysiOlek()
       if stat==0:
         return "\"black\""
       if stat==1: #pooleli
         if time.time()>self.lopp: #Hilinenud
           return "\"red\""
         else: return   "\"blue\""
       return  "\"green\""       
       
     def asukohaNimi(self):
       "Kursuse nimi, kus sündmus asub, muu sündmuse puhul None"
       aadress=self.absolute_url()
       algus=aadress.find('courses')
       if algus>=0:
         nr=aadress[algus:].split("/")[1]
         t=getattr(self.fle_root().courses, nr).get_name()
         m=aadress[algus:].split("/")
         for i in range(len(m)):
           if m[i]=="subgroups" and i+1<len(m):
             t=t#+" / " + m[i+1]
         return t
       return None
       
     def asukohtTekstina(self, REQUEST):
       "Sõnastatuna tabelisse kandmiseks"
       t=self.asukohaNimi()
       if t is None:
         if REQUEST.AUTHENTICATED_USER==self.kysiOmanik(): 
           return translate(self,'Own')
         else:
           return self.kysiOmanik().getUserName()
       return t

     security.declarePublic('kysiOmanik')
     def kysiOmanik(self):
       "Sündmuse looja"
       return self.getOwner()

     def kasOmanik(self, REQUEST):
       "jah/ei"
       return str(REQUEST.AUTHENTICATED_USER)==str(self.kysiOmanik())
       
     def userStatus(self,REQUEST,submitt='',olek='',userLocation=''):
        """ User changes event status for himself """
        if not submitt:
                return
        if not olek:
                return
        keyword = 'status_'+str(REQUEST.AUTHENTICATED_USER)
        try:
                setattr(self, keyword,int(olek))
        except:
                return "something happened"
        return REQUEST.RESPONSE.redirect(self.absolute_url()+'?userLocation='+userLocation)

     security.declareProtected(perm_edit,'muutmisLeht')
     def muutmisLeht(self, REQUEST,userLocation=''):
       """ __Change__ event """
       self.algus=mkTime(REQUEST, "algus")
       self.lopp=mkTime(REQUEST, "lopp")
       if self.lopp<self.algus: self.lopp=self.algus
       self.nimi=strip_tags(REQUEST['nimi'])
       self.pikk=REQUEST['pikk']
       self.viide=REQUEST['viide']
       self.siseviide=REQUEST['siseviide']
       self.olek=int(REQUEST['olek'])
       self.reindex_object()
       REQUEST.RESPONSE.redirect(self.absolute_url()+'?userLocation='+userLocation)
       
     def vcal(self, REQUEST):
        """ Export!? """
        from ExportIMS import Kirjutus
        Kir = Kirjutus(self.fle_root(), None)
        kat = 'kursus'
        syndmus = self
        vCal = "BEGIN:VCALENDAR\r\n"
        vCal += "METHOD:PUBLISH\r\n"
        vCal += "PRODID:-//IVA//0.6//EN\r\n"
        vCal += "VERSION:2.0\r\n"
        vCal += "BEGIN:VEVENT\r\n"
        vCal += "DTSTART:"+Kir.vCalTime(syndmus.algus)+"\r\n"
        vCal += "DTEND:"+Kir.vCalTime(syndmus.lopp)+"\r\n"
        #vCal += "N:"+omanik+"\r\n"
        vCal += "DESCRIPTION:"+Kir.format(syndmus.getContent())+"\r\n"
        #vCal += "SUMMARY:"+Kir.format(syndmus.lyhi)+"\r\n"
        vCal += "STATUS:"+str(syndmus.olek)+"\r\n"
        vCal += "CUTYPE:"+kat+"\r\n"
        vCal += "URL:"+syndmus.viide+"\r\n"
        vCal += "X-PROPERTY;VALUE=NAME:"+Kir.format(syndmus.nimi)+"\r\n"
        vCal += "RESOURCES:"+Kir.format(syndmus.siseviide)+"\r\n"
        vCal += "END:VEVENT\r\n"
        vCal += "END:VCALENDAR\r\n"
        REQUEST.RESPONSE.setHeader('Content-disposition','attachment; filename=event.ics')
        REQUEST.RESPONSE.setHeader('content-type','text/calendar')
        return vCal

     security.declareProtected(perm_view, 'export')
     def export(self, doc=None):
        """ export """
        from xml.dom.minidom import Document
        if not doc: doc = Document()
        mess = doc.createElement('message')
        mess.appendChild(doc.createTextNode('koll-koll'))
        return mess
       
class KalendriSyndmusteKataloog(
    OFS.Folder.Folder,
    OFS.SimpleItem.Item,
    Persistent,
    AccessControl.Role.RoleManager,
    Traversable,
    Cruft
    ):
    """ some functions here do some misc stuff. find closest event folder and call'em out """
    
    implements(ICalendar)
    security = ClassSecurityInfo()
    security.declareObjectPublic()
    syndmuseNr=0

    def __init__(self):
        """ init, set id """
        self.id = 'syndmused'
     
    security.declarePrivate('kysiUusNr')
    def kysiUusNr(self):
        self.syndmuseNr=self.syndmuseNr+1
        while hasattr(self.aq_self, 'event'+str(self.syndmuseNr)):
                self.syndmuseNr=self.syndmuseNr+1
        return self.syndmuseNr

    security.declareProtected(perm_view, 'may_edit')
    def may_edit(self):
        """ returns true if user can edit/add event in current container, otherwise false """
        return getSecurityManager().checkPermission('Add FLE LO', self)
     
    security.declareProtected(perm_edit, 'events_form_handler')
    def events_form_handler(self, REQUEST, kustutus=(), backlink='', confirmation='', userLocation='Organizer'):
        """ confirm deleting events """
        if kustutus:
                if confirmation:
                        #do stuff and redirect away
                        self.delete_events(kustutus)
                        return REQUEST.RESPONSE.redirect('%s?userLocation=%s' % ( self.absolute_url(), userLocation) )
                return self.restrictedTraverse('message_dialog2.html')(
                        title="Confirmation",
                        message="Are you sure you want to delete events?",
                        option1_name="cancel",
                        option1_value="Cancel",
                        option2_value="Delete", 
                        option2_name="confirmation",
                        extra_value_name='backlink',
                        extra_values = (backlink,),
                        item_name='kustutus',
                        item_value=kustutus,
                        userLocation=userLocation,
                        handler="events_form_handler")
        
    security.declareProtected(perm_edit,'delete_events')
    def delete_events(self, obj_ids):
        """ Sündmuste kustutamine """
        if type(obj_ids) == types.StringType:
                s = obj_ids[1:-1].split(',')
                obj_ids = []
                for x in s:
                        obj_ids.append(x[1:-1])
        for x in obj_ids:
                self._delObject(x.split('/')[-1])
        return 0
       
    security.declareProtected(perm_edit,'muutmisLeht')
    def muutmisLeht(self, REQUEST=None,userLocation='', data= {}, timestamps=0):
       """ Change event. If we're here then we add new event """
       if not self.may_edit(): raise Unauthorized
       req = REQUEST
       if not REQUEST:
           req = data
       from input_checks import is_valid_title
       
       name = req.get('nimi', '')
       pikk = req.get('pikk', '')
       if not timestamps:
           algus=mkTime(req, "algus")
           lopp=mkTime(req, "lopp")
       else:
           algus = req.get('algus')
           lopp = req.get('lopp')
       
       if not is_valid_title(name) and REQUEST:
               return self.restrictedTraverse('message_dialog.html')(
                        message='Invalid title',
                        action='changeEvent.html?userLocation=%s&nimi=%s&pikk=%s&algus=%s&lopp=%s' % (userLocation, name, pikk, algus, lopp)
                        )
       if not pikk and REQUEST:
               return self.restrictedTraverse('message_dialog.html')(
                        message='No content',
                        action='changeEvent.html?userLocation=%s&nimi=%s&pikk=%s&algus=%s&lopp=%s' % (userLocation, name, pikk, algus, lopp)
                        )
       nr='event'+str(self.kysiUusNr())
       k=KalendriSyndmus(nr)
       
       k.algus=algus
       k.lopp=lopp
       if k.lopp<k.algus: 
               k.lopp=k.algus
       k.nimi=strip_tags(name)
       if not k.nimi: k.nimi = nr
       k.pikk=pikk
       k.viide=req['viide']
       if hasattr(req, 'siseviide'):
               k.siseviide=req['siseviide']
       else: k.siseviide=""
       k.olek=int(req['olek'])
       k.id=nr
       self._setObject(nr, k)
       if REQUEST:
           return REQUEST.RESPONSE.redirect(self.absolute_url()+'?userLocation='+userLocation)
       else:
           return nr
       
    security.declareProtected(perm_edit,'addEvent')
    def addEvent(self, REQUEST,userLocation='Organizer'):
       """ new event """
       ctime = REQUEST.get('ctime', None)
       if ctime:
               ctime = DateTime(ctime)
               return REQUEST.RESPONSE.redirect('changeEvent.html?userLocation='+userLocation+'&eventtime='+str(DateTime(ctime).timeTime()))
       else:
               return REQUEST.RESPONSE.redirect('changeEvent.html?userLocation='+userLocation)

    security.declarePrivate('lisaSyndmusKohe')
    def lisaSyndmusKohe(self, nimi, pikk, start, end, url, res, status):
        """ add event immediately """
        nr = str(self.kysiUusNr())
        k = KalendriSyndmus(nimi, pikk, start, end, url, res, status)
        k.id = nr
        self._setObject(nr, k)
        return k

    def olekuTekst(self, nr):
       "Olek tekstina"
       if nr==0: return ""
       if nr==1: return "incomplete"
       if nr==2: return "complete"
       
    def getPrevMonth(self, month, year):
        """ calendar - get previous month """
        if month==0 or month==1:
                month, year = 12, year -1
        else:
                month-=1
        return DateTime(year, month, 1)

    def getNextMonth(self, month, year):
        """ calendar - get next month """
        if month==12:
                month, year = 1, year + 1
        else:
                month+=1
        return DateTime(year, month, 1)

    def getNextYear(self, year):
        """ return next year number """
        return int(year)+1
        
    def getPrevYear(self, year):
        """ return previous year number """
        return int(year)-1

    def getDate(self, cdate=''):
        """ get date """
        if cdate:
                return DateTime(cdate)
        else:
                return DateTime()

    def getWeeks(self, year, month):
        """ return array of weeks """
        return calendar.monthcalendar(year, month)

    def getEventsObj(self):
        """ return events with objectValues() """
        return self.objectValues('Event')

    security.declareProtected(perm_edit, 'getEvents')
    def getEvents(self, REQUEST, 
        sort='get_start_time',  # sort on 
        blocked=0,              # 0 - show all, 1 - show only hidden(blocked), 2 - show only not hidden
        srange=None,            # range start
        erange=None,            # range end
        own=0,                  # only own events
        only_current=0,         # events only from current container
        curUser=None            # current user
        ):
        """ return all events. should be called from events folder context """
        
        # TODO: XXX: fix subgroup handling
        o = self.catalog_events
        
        if not curUser:
            curUser = getattr(self.fle_root().fle_users, str(REQUEST.AUTHENTICATED_USER) )
        user = curUser
                
        events = []

        pp = self.fle_root().getPhysicalPath()
        base = '/'.join(pp)+'/'
        
        paths = []

        self_phys_path = self.getPhysicalPath()
        self_path = '/'.join(self_phys_path)
        paths.append(self_path)
        
        if erange: erange = erange.ISO()
        if srange: srange = srange.ISO()
        if not int(only_current):
            #events = o(path=self.absolute_url(1), getStartTime=iday, sort_on=sort)
            for c in user.user_courses(quick=1):
                #paths.append(c.absolute_url(1)+'/syndmused')
                course_base = base + 'courses/'+c.get_id
                paths.append(course_base+'/syndmused')
                #cource = self.fle_root().courses.get_child(c.get_id)
                #sgm = getattr(cource, 'subgroups', None)
                slist = c.getSubgroupList
                for sub in slist.keys():
                    if user.get_id() in slist[sub]:
                        paths.append(course_base+'/subgroups/'+sub+'/syndmused')
                        #user_sg = sgm.user_subgroups_by_id(user.get_uname())
                        #for sub in user_sg:
        query = {'path':paths,
                 'get_start_time':{'query':erange, 'range':'max'},
                 'get_end_time':{'query':srange, 'range':'min'},
                 'sort_on':sort,
                 'sort_order':'descending',
                }
        events = o(query)
        return events

    security.declareProtected(perm_view, 'export')
    def export(self, doc=None):
        """ export """
        from xml.dom.minidom import Document
        from xml.dom.ext import PrettyPrint
        if not doc: doc = Document()
        mbox = doc.createElement('MailMessages')
        for x in self.getEventsObj():
                mess = x.export(doc)
                mbox.appendChild(mess)
        PrettyPrint(mbox)
        return mbox
# EOF