Return to OSAS_root.py CVS log

Up to [Repository] / OSA_system2

viewer zu handler

""" OSAS_contains the basic classes for configuring the OSAS and
basic objects for displaying data.
All site specific adaptation should be made in OSAS_Root
"""

from OSAS_helpers import *
import OSAS_helpers
from OFS.SimpleItem import SimpleItem
from time import localtime,strftime
from Acquisition import Implicit
from OFS.Folder import Folder
from Products.PageTemplates.PageTemplateFile import PageTemplateFile
from Products.PageTemplates.PageTemplate import PageTemplate
import urllib
from urlparse import *
import re
import xml.dom.minidom
from types import *
import zLOG
import os.path
import Globals
from Globals import package_home
from AccessControl import ClassSecurityInfo


class OSAS_handlerObject(Folder):
    """
    Grundlegende Klasse fuer Handler zur Zeit noch in Entwicklung

    """
    meta_type="OSAS_HandlerObject__neu"

    
    def __init__(self,id,title,prefix,objectTypes,ignorePath=""):
        """inititialisiere die Klasse

        :Parameters:
         - `id` : Zope ID des Objektes
         - `title`: Titel des Objektes
         - `prefix` : URL bzw. URL Rumpf der Zusammen mit dem Pfad des Objectes die Anzeige URL ergibt
         - `objectType` : liste von Objekttypen die mittels dieses Handlers angezeigt werden können.
         - `ignorePath` : Pfad der bei dem übergebenen Pfad element ingnoriert werden soll. Optional.
        """
        self.id=id
        self.title=title
        self.prefix=prefix
        self.objectTypes=toList(objectTypes)
        self.ignorePath=ignorePath

    manage_options = Folder.manage_options+(
        {'label':'Main Config','action':'changeHandlerObjectForm'},
        )

    def changeHandlerObjectForm(self):
        """Main configuration"""
        pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt','changeHandlerObjectForm.zpt')).__of__(self)
        return pt()

    def changeHandlerObject(self,title,prefix,objectTypes,ignorePath=None,RESPONSE=None):
        """Change RootFolderName"""
        self.title=title
        self.prefix=prefix
        self.ignorePath=ignorePath
        self.objectTypes=toList(objectTypes)
        
        if RESPONSE is not None:
            RESPONSE.redirect('manage_main')


def manage_addHandlerObjectForm(self):
    """form for adding a handler Object"""
    pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt','addHandlerObjectForm.zpt')).__of__(self)
    return pt()

def manage_addHandlerObject(self,id,title,prefix,objectTypes,ignorePath,RESPONSE=None):
    """add the OSAS_root"""
    newObj=OSAS_handlerObject(id,title,prefix,objectTypes,ignorePath)
    self._setObject(id,newObj)
    
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')

    
class OSAS_root(Folder,Implicit):
    """Implicit Folder of the  Storage Systems"""

    security=ClassSecurityInfo()

    def __init__(self,id,rootFolderName,uploadServletUrl=None):
        """initialize a new instance


        @param id: Zope ID des Objektes
        @param rootFolderName : path zum root folder des Storagesystems
        @param uploadServerletUrl : url des UploadServlets (required fuer batch upload)

        """
        
        self.id = id
        self.rootFolderName = rootFolderName
        self.uploadServletUrl=uploadServletUrl
        
    meta_type="OSAS_Root__neu"

    manage_options = Folder.manage_options+(
        {'label':'Main Config','action':'changeRootForm'},
        )


    OSASObjectTypes=OSAS_helpers.OSASObjectTypes
    
    def changeRootForm(self):
        """Main configuration"""
        pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt','changeRootForm.zpt')).__of__(self)
        
        return pt()

    def changeRoot(self,rootFolderName,uploadServletUrl,RESPONSE=None):
        """Change RootFolderName"""
        self.rootFolderName=rootFolderName

        self.uploadServletUrl=uploadServletUrl
        
        if RESPONSE is not None:
            RESPONSE.redirect('manage_main')

    localDate=localDate
    
    def getUploadServletUrl(self):
        """gibt  url des servlets zurueck"""
        return self.uploadServletUrl
        

    def validateIndexMeta(self,data):
        """TO BE DONE testet ob data ein gueltiges index.meta file ist, zur Zeit wird dom erzeugt ohne validierung.
        @param data: zu testendes XML file als string
        @return: zeiger auf dom  falls ok, None  andernfalls (z.Z: immmer dom falls parse possible)
        """
        try:
            return xml.dom.minidom.parseString(xmlneu)
        except:
            return None
        
    security.declareProtected('View management screens','uploadExternalXMLString','uploadExternalXMLUrl','uploadExternalXML')
    
    def uploadExternalXMLString(self,index_meta_url,xml_string):
        """lese ein xml file aus xml_url und schreibe es in den lokalen Filebaum
        
        @param index_meta_url: url eines index.meta files auf dem lokalen Server, es gilt rootFolderName + pfad teil der url = pfad auf dem Server. 
        @param xml_string: string mit index_meta ersetzt obiges index.meta
        @return: 'error' als String bei Fehler 'ok' bei ok.
        """

        return self.uploadExternalXML(index_meta_url,xml_string)


    def uploadExternalXMLUrl(self,index_meta_url,xml_url):
        """lese ein xml file aus xml_url und schreibe es in den lokalen Filebaum
        
        @param index_meta_url: url eines index.meta files auf dem lokalen Server, es gilt rootFolderName + pfad teil der url = pfad auf dem Server. 
        @param xml_url: externe url auf ein index_meta ersetzt obiges index.meta
        @return: 'error' als String bei Fehler 'ok' bei ok.
        """

        return self.uploadExternalXML(index_meta_url,xml_url)

    
    def uploadExternalXML(self,index_meta_url,xml_url=None,xml_string=None):
        """lese ein xml file aus xml_url und schreibe es in den lokalen Filebaum
        
        @param index_meta_url: url eines index.meta files auf dem lokalen Server, es gilt rootFolderName + pfad teil der url = pfad auf dem Server. 
        @param xml_url: (optional, default=None) externe url auf ein index_meta ersetzt obiges index.meta
        @param xml_string: (optional, default=None) string mit index_meta ersetzt obiges index.meta
        @return: 'error' als String bei Fehler 'ok' bei ok.
        """

        if xml_url:
            xmlneu=urllib.urlopen(xml_url).read()
        else:
            xmlneu=xml_string
        
        dom=self.validateIndexMeta(xmlneu)
        if not dom:
            zLOG.LOG('OSAS_Root (downloadExternalXML)',zLOG.ERROR,'cannot parse: %s', xml_url)
            return "error"


        path=self.rootFolderName+urlparse(index_meta_url)[2]

        fh=open(path,'w')

        fh.write(xmlneu)
        fh.close()
        return "ok"

    security.declareProtected('View','getIndexMetaFile')

   
    def getIndexMetaFile(self,index_meta):
        """gibt index metafile aus
        @param index_meta: index_meta ist eine URI entweder url des index_meta oder file mit file://
        """
        filearray=[]
        urlparsed=urlparse(index_meta)[1:]

        for x in urlparsed:
            
            if not (x==''):
                filearray.append(x)

        path=os.sep.join(filearray)

        realPath=os.path.normpath(os.path.join(self.rootFolderName,path))
        
        if realPath.find(self.rootFolderName) <0: #versuch auf Pfad unterhalb des Rootfolder zuzugreifen
            return {}
            

        if not os.path.isfile(realPath):
            return None,"(ERROR) path %s does not exist."%path

    
        fh=file(realPath,'r')
        str=fh.read()
        fh.close()
        return str


Globals.InitializeClass(OSAS_root)

def manage_addOSAS_rootForm(self):
    """interface for adding the OSAS_root"""
    pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addOSAS_rootForm.zpt')).__of__(self)
    return pt()

def manage_addOSAS_root(self,id,RootFolderName,uploadServletUrl,RESPONSE=None):
    """add the OSAS_root"""
    newObj=OSAS_root(id,RootFolderName,uploadServletUrl)
    self._setObject(id,newObj)
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')