# -*- coding: Latin-1 -*-
from Globals import HTMLFile, DTMLFile
from OFS.DTMLDocument import DTMLDocument
from urllib import quote
from AccessControl.Permissions import change_dtml_documents
from AccessControl import ClassSecurityInfo

def addZopilotDTMLDocument(self, id, title='', REQUEST=None):
    """Lege ein neues Zopilot - DTML Document an"""
    id=str(id)
    title=str(title)
    doc = ZopilotDTMLDocument('',__name__=id)
    doc.title = title
    id=self._setObject(id, doc)
    if REQUEST is not None:
        try: u=self.DestinationURL()
        except: u=REQUEST['URL1']
        u="%s/%s" % (u,quote(id))
        REQUEST.RESPONSE.redirect(u+'/manage_main')
    return ''

addZopilotDTMLDocumentForm = HTMLFile("addZopilotDTMLDocumentForm", globals())

class ZopilotDTMLDocumentRequest:
  """Klasse für den Request
  """
  def session_init(self):
   session = self.request.SESSION
   if session.has_key("webdocument"):
     #Sitzungsobjekt vorhanden
     s = session["webdocument"]
     s["cookiesActive"] = 1
   else:
     s = {}
     s["userGroups"] = []
     s["cookiesActive"] = 0
     s["userID"] = ""
     s["id"] = session.id
   self.session = s
   session["webdocument"] = s

  def execute(self, doc, client, REQUEST, RESPONSE, kw):
    """Request ausführen
    """
    self.request = REQUEST
    context = doc
    self.context = context

    lDG = context.HoleBenutzerGruppen().split(",")
    dDG = {}
    for g in lDG:
      dDG[g] = 1
    self.documentGroups = dDG

    if RESPONSE == None: RESPONSE=getattr(REQUEST,"RESPONSE",None)
    if RESPONSE != None:
      if not getattr(context,"ZopilotDTMLDocumentNoContentType",None):
        RESPONSE.setHeader('Content-type','text/html')

    if self.isAllowedToGetContent():
      if getattr(context, 'set_last_modified_header', False) and RESPONSE!=None:
        RESPONSE.setHeader('Last-Modified',' '.join(context.bobobase_modification_time().toZone('GMT').rfc822().split()[:-1])+' GMT')
      return context.SeitenKopf(context,REQUEST,**kw) + DTMLDocument.__call__(doc, client, REQUEST, RESPONSE, **kw) + context.SeitenFuss(context,REQUEST,**kw)
    else:
      return context.SeitenKopf(context,REQUEST,**kw) + self.contentNotAllowed(kw) + context.SeitenFuss(context,REQUEST,**kw)

  def BenutzerAngemeldet(self):
    """Ermittelt, ob sich der Benutzer schon angemeldet hat
    """
    #Angemeldet ist er, wenn er zu mindestens einer Benutzergruppe gehört
    return self.session["userGroups"] != []

  def contentNotAllowed(self,kw):
    """Wird aufgerufen, falls der Content für den User nicht erlaubt ist
       (weil es anmeldepflichtig ist und er nicht angemeldet ist oder zu falschen Benutzergruppe gehört,
        oder das Dokument kostenpflichtig ist und er nicht bezahlt hat)
    """
    #Warum nicht?
    c = self.context
    req = self.request
    if not self.documentAccessable():
      #Dokument nicht zugreifbar
      if self.BenutzerAngemeldet():
        #Benutzer aber angemeldet, d.h. er gehört zu zu keiner berechtigten Benutzergruppe
        return c.NichtInGruppe(c,req,**kw)
      else:
        #Er ist nicht angemeldet
        return c.NichtAngemeldet(c,req,**kw)
    #Zugreifbar aber kostenpflichtig
    if not self.documentPaid():
      c.ErzeugeKassenDaten()
      return c.NichtBezahlt(c,req,**kw)

  def documentAccessable(self):
    """Prüft, ob das Dokument für den User zugreifbar ist
    """
    #Ist das Dokument von allen Gruppen zugreifbar?
    dg = self.documentGroups
    if dg.has_key("all"):
      return 1

    #Ist bei diesem Request keine Anmeldung erforderlich ?
    OhneAnmeldung=getattr(self.context,"OhneAnmeldung",None)
    if OhneAnmeldung:
     if OhneAnmeldung(): return 1

    # erst an dieser stelle session initialisieren
    self.session_init()

    if self.BenutzerAngemeldet():
      #Gehoert der User zu einer Gruppe, die zugreifen darf?
      for g in self.session["userGroups"]:
        if dg.has_key(g): return 1
    return 0

  def documentPaid(self):
    """Prüft, ob das Dokument bezahlt ist, falls kostenpflichtig
       Nebeneffekt: dekrementiert Abrufe, falls kostenpflichtig und bezahlt
    """
    c = self.context

    if c.HolePreis() == 0:
      return 1

    # erst an dieser stelle session initialisieren
    self.session_init()
    s = self.session

    if c.Bezahlt(s["id"],s["userID"],c.HoleGruppe()):
      c.AktualisiereBezahlt(s["id"],s["userID"],c.HoleGruppe())
      return 1
    return 0

  def isAllowedToGetContent(self):
    """Prüft ob Content zugreifbar und bezahlt ist
    """
    return self.documentAccessable() and self.documentPaid()

class ZopilotDTMLDocument(DTMLDocument):
    icon = "misc_/ZopilotDTMLDocument/Icon"
    meta_type = "Zopilot - DTML Document"
    index_html = None

    manage_options = ((DTMLDocument.manage_options[0],
                       {'label':'WYSIWYG', 'action':'manage_editFormRich',
                       'help':('OFSP','DTML-DocumentOrMethod_Edit.stx')})
                      + DTMLDocument.manage_options[1:])

    security = ClassSecurityInfo()

    manage_editFormRich = DTMLFile('documentRichEdit', globals())
    manage_editFormRich._setName('manage_editFormRich')
    security.declareProtected(change_dtml_documents, 'manage_editFormRich')

    security.declareProtected(change_dtml_documents, 'manage_edit_rich')
    def manage_edit_rich(self,data,title,SUBMIT='Change',dtpref_cols='100%',
                         dtpref_rows='20',REQUEST=None):
        """
        Replaces a Documents contents with Data, Title with Title.

        The SUBMIT parameter is also used to change the size of the editing
        area on the default Document edit screen.  If the value is "Smaller",
        the rows and columns decrease by 5.  If the value is "Bigger", the
        rows and columns increase by 5.  If any other or no value is supplied,
        the data gets checked for DTML errors and is saved.
        """
        self._validateProxy(REQUEST)
        if self._size_changes.has_key(SUBMIT):
            return self._er(data,title,SUBMIT,dtpref_cols,dtpref_rows,REQUEST)
        if self.wl_isLocked():
            raise ResourceLockedError, (
                'This document has been locked via WebDAV.')

        self.title=str(title)
        if type(data) is not type(''): data=data.read()
        self.munge(data)
        self.ZCacheable_invalidate()
        if REQUEST:
            message="Content changed."
            return self.manage_editFormRich(self,REQUEST,manage_tabs_message=message)

    def __call__(self, client=None, REQUEST={}, RESPONSE=None, **kw):
        r = ZopilotDTMLDocumentRequest()
        return r.execute(self, client, REQUEST, RESPONSE, kw)
