# -*- coding: Latin-1 -*-
from OFS.Image import File
from Globals import HTMLFile
from webdav.common import rfc1123_date
from AccessControl import ClassSecurityInfo

def addZopilotFile(self,id,file='',title='',precondition='', content_type='',
                   REQUEST=None):
    """Add a new Zopilot - File object.

    Creates a new File Zopilot - object 'id' with the contents of 'file'"""

    id=str(id)
    title=str(title)
    content_type=str(content_type)
    precondition=str(precondition)

    id, title = cookId(id, title, file)

    self=self.this()

    # First, we create the file without data:
    self._setObject(id, ZopilotFile(id,title,'',content_type, precondition))

    # Now we "upload" the data.  By doing this in two steps, we
    # can use a database trick to make the upload more efficient.
    if file:
        self._getOb(id).manage_upload(file)
    if content_type:
        self._getOb(id).content_type=content_type

    if REQUEST is not None:
        REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')

def cookId(id, title, file):
    if not id and hasattr(file,'filename'):
        filename=file.filename
        title=title or filename
        id=filename[max(filename.rfind('/'),
                        filename.rfind('\\'),
                        filename.rfind(':'),
                        )+1:]
    return id, title

addZopilotFileForm = HTMLFile("addZopilotFileForm", globals())

class ZopilotFileRequest:
  """Klasse für den Request
  """
  def session_init(self):
   session=getattr(self.request,"SESSION",None)
   if 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
   else:
     # REQUEST.SESSION nicht vorhanden -> Kein richtiger Request (z.b.
     # Aufruf mittels dr())
     session = {}
     s = {}
     s["userGroups"] = []
     s["cookiesActive"] = 0
     s["userID"] = ""
     s["id"] = ""

   self.session = s
   session["webdocument"] = s

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

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

    if self.isAllowedToGetContent():
      RESPONSE.setHeader('Last-Modified', rfc1123_date(doc._p_mtime))
      RESPONSE.setHeader('Content-Type', doc.content_type)
      RESPONSE.setHeader('Content-Length', doc.size)
      # Don't cache the data itself, but provide an opportunity
      # for a cache manager to set response headers.
      doc.ZCacheable_set(None)
      data=doc.data
      if type(data) is str: return data
      while data is not None:
          if self.request_method == 'get':
              RESPONSE.write(data.data)
          data=data.next
      return ''
    else:
      if RESPONSE == None: RESPONSE=getattr(REQUEST,"RESPONSE",None)
      if RESPONSE != None: RESPONSE.setHeader('Content-type','text/html')
      return context.SeitenKopf(context,REQUEST,**kw) + self.contentNotAllowed() + 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):
    """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)
      else:
        #Er ist nicht angemeldet
        return c.NichtAngemeldet(c,req)
    #Zugreifbar aber kostenpflichtig
    if not self.documentPaid():
      c.ErzeugeKassenDaten()
      return c.NichtBezahlt(c,req)

  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 ZopilotFile(File):
    icon = "misc_/ZopilotFile/Icon"
    meta_type = "Zopilot - File"
    index_html = None
    def __call__(self, client=None, REQUEST={}, RESPONSE=None, **kw):
        r = ZopilotFileRequest()
        r.request_method = 'get'
        return r.execute(self, client, REQUEST, RESPONSE, kw)

    security = ClassSecurityInfo()

    security.declarePublic('HEAD')
    def HEAD(self, REQUEST, RESPONSE):
        """ """
        r = ZopilotFileRequest()
        r.request_method = 'head'
        l = len(r.execute(self, None, REQUEST, RESPONSE, {}))
        if l:
            RESPONSE.setHeader('Content-Length', l)
        return ''
