Return to OSAS_root.py CVS log

Up to [Repository] / OSA_system2

viewer zu handler

    1: """ OSAS_contains the basic classes for configuring the OSAS and
    2: basic objects for displaying data.
    3: All site specific adaptation should be made in OSAS_Root
    4: """
    5: 
    6: from OSAS_helpers import *
    7: import OSAS_helpers
    8: from OFS.SimpleItem import SimpleItem
    9: from time import localtime,strftime
   10: from Acquisition import Implicit
   11: from OFS.Folder import Folder
   12: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
   13: from Products.PageTemplates.PageTemplate import PageTemplate
   14: import urllib
   15: from urlparse import *
   16: import re
   17: import xml.dom.minidom
   18: from types import *
   19: import zLOG
   20: import os.path
   21: import Globals
   22: from Globals import package_home
   23: from AccessControl import ClassSecurityInfo
   24: 
   25: 
   26: class OSAS_handlerObject(Folder):
   27:     """
   28:     Grundlegende Klasse fuer Handler zur Zeit noch in Entwicklung
   29: 
   30:     """
   31:     meta_type="OSAS_HandlerObject__neu"
   32: 
   33:     
   34:     def __init__(self,id,title,prefix,objectTypes,ignorePath=""):
   35:         """inititialisiere die Klasse
   36: 
   37:         :Parameters:
   38:          - `id` : Zope ID des Objektes
   39:          - `title`: Titel des Objektes
   40:          - `prefix` : URL bzw. URL Rumpf der Zusammen mit dem Pfad des Objectes die Anzeige URL ergibt
   41:          - `objectType` : liste von Objekttypen die mittels dieses Handlers angezeigt werden können.
   42:          - `ignorePath` : Pfad der bei dem übergebenen Pfad element ingnoriert werden soll. Optional.
   43:         """
   44:         self.id=id
   45:         self.title=title
   46:         self.prefix=prefix
   47:         self.objectTypes=toList(objectTypes)
   48:         self.ignorePath=ignorePath
   49: 
   50:     manage_options = Folder.manage_options+(
   51:         {'label':'Main Config','action':'changeHandlerObjectForm'},
   52:         )
   53: 
   54:     def changeHandlerObjectForm(self):
   55:         """Main configuration"""
   56:         pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt','changeHandlerObjectForm.zpt')).__of__(self)
   57:         return pt()
   58: 
   59:     def changeHandlerObject(self,title,prefix,objectTypes,ignorePath=None,RESPONSE=None):
   60:         """Change RootFolderName"""
   61:         self.title=title
   62:         self.prefix=prefix
   63:         self.ignorePath=ignorePath
   64:         self.objectTypes=toList(objectTypes)
   65:         
   66:         if RESPONSE is not None:
   67:             RESPONSE.redirect('manage_main')
   68: 
   69: 
   70: def manage_addHandlerObjectForm(self):
   71:     """form for adding a handler Object"""
   72:     pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt','addHandlerObjectForm.zpt')).__of__(self)
   73:     return pt()
   74: 
   75: def manage_addHandlerObject(self,id,title,prefix,objectTypes,ignorePath,RESPONSE=None):
   76:     """add the OSAS_root"""
   77:     newObj=OSAS_handlerObject(id,title,prefix,objectTypes,ignorePath)
   78:     self._setObject(id,newObj)
   79:     
   80:     if RESPONSE is not None:
   81:         RESPONSE.redirect('manage_main')
   82: 
   83:     
   84: class OSAS_root(Folder,Implicit):
   85:     """Implicit Folder of the  Storage Systems"""
   86: 
   87:     security=ClassSecurityInfo()
   88: 
   89:     def __init__(self,id,rootFolderName,uploadServletUrl=None):
   90:         """initialize a new instance
   91: 
   92: 
   93:         @param id: Zope ID des Objektes
   94:         @param rootFolderName : path zum root folder des Storagesystems
   95:         @param uploadServerletUrl : url des UploadServlets (required fuer batch upload)
   96: 
   97:         """
   98:         
   99:         self.id = id
  100:         self.rootFolderName = rootFolderName
  101:         self.uploadServletUrl=uploadServletUrl
  102:         
  103:     meta_type="OSAS_Root__neu"
  104: 
  105:     manage_options = Folder.manage_options+(
  106:         {'label':'Main Config','action':'changeRootForm'},
  107:         )
  108: 
  109: 
  110:     OSASObjectTypes=OSAS_helpers.OSASObjectTypes
  111:     
  112:     def changeRootForm(self):
  113:         """Main configuration"""
  114:         pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt','changeRootForm.zpt')).__of__(self)
  115:         
  116:         return pt()
  117: 
  118:     def changeRoot(self,rootFolderName,uploadServletUrl,RESPONSE=None):
  119:         """Change RootFolderName"""
  120:         self.rootFolderName=rootFolderName
  121: 
  122:         self.uploadServletUrl=uploadServletUrl
  123:         
  124:         if RESPONSE is not None:
  125:             RESPONSE.redirect('manage_main')
  126: 
  127:     localDate=localDate
  128:     
  129:     def getUploadServletUrl(self):
  130:         """gibt  url des servlets zurueck"""
  131:         return self.uploadServletUrl
  132:         
  133: 
  134:     def validateIndexMeta(self,data):
  135:         """TO BE DONE testet ob data ein gueltiges index.meta file ist, zur Zeit wird dom erzeugt ohne validierung.
  136:         @param data: zu testendes XML file als string
  137:         @return: zeiger auf dom  falls ok, None  andernfalls (z.Z: immmer dom falls parse possible)
  138:         """
  139:         try:
  140:             return xml.dom.minidom.parseString(xmlneu)
  141:         except:
  142:             return None
  143:         
  144:     security.declareProtected('View management screens','uploadExternalXMLString','uploadExternalXMLUrl','uploadExternalXML')
  145:     
  146:     def uploadExternalXMLString(self,index_meta_url,xml_string):
  147:         """lese ein xml file aus xml_url und schreibe es in den lokalen Filebaum
  148:         
  149:         @param index_meta_url: url eines index.meta files auf dem lokalen Server, es gilt rootFolderName + pfad teil der url = pfad auf dem Server. 
  150:         @param xml_string: string mit index_meta ersetzt obiges index.meta
  151:         @return: 'error' als String bei Fehler 'ok' bei ok.
  152:         """
  153: 
  154:         return self.uploadExternalXML(index_meta_url,xml_string)
  155: 
  156: 
  157:     def uploadExternalXMLUrl(self,index_meta_url,xml_url):
  158:         """lese ein xml file aus xml_url und schreibe es in den lokalen Filebaum
  159:         
  160:         @param index_meta_url: url eines index.meta files auf dem lokalen Server, es gilt rootFolderName + pfad teil der url = pfad auf dem Server. 
  161:         @param xml_url: externe url auf ein index_meta ersetzt obiges index.meta
  162:         @return: 'error' als String bei Fehler 'ok' bei ok.
  163:         """
  164: 
  165:         return self.uploadExternalXML(index_meta_url,xml_url)
  166: 
  167:     
  168:     def uploadExternalXML(self,index_meta_url,xml_url=None,xml_string=None):
  169:         """lese ein xml file aus xml_url und schreibe es in den lokalen Filebaum
  170:         
  171:         @param index_meta_url: url eines index.meta files auf dem lokalen Server, es gilt rootFolderName + pfad teil der url = pfad auf dem Server. 
  172:         @param xml_url: (optional, default=None) externe url auf ein index_meta ersetzt obiges index.meta
  173:         @param xml_string: (optional, default=None) string mit index_meta ersetzt obiges index.meta
  174:         @return: 'error' als String bei Fehler 'ok' bei ok.
  175:         """
  176: 
  177:         if xml_url:
  178:             xmlneu=urllib.urlopen(xml_url).read()
  179:         else:
  180:             xmlneu=xml_string
  181:         
  182:         dom=self.validateIndexMeta(xmlneu)
  183:         if not dom:
  184:             zLOG.LOG('OSAS_Root (downloadExternalXML)',zLOG.ERROR,'cannot parse: %s', xml_url)
  185:             return "error"
  186: 
  187: 
  188:         path=self.rootFolderName+urlparse(index_meta_url)[2]
  189: 
  190:         fh=open(path,'w')
  191: 
  192:         fh.write(xmlneu)
  193:         fh.close()
  194:         return "ok"
  195: 
  196:     security.declareProtected('View','getIndexMetaFile')
  197: 
  198:    
  199:     def getIndexMetaFile(self,index_meta):
  200:         """gibt index metafile aus
  201:         @param index_meta: index_meta ist eine URI entweder url des index_meta oder file mit file://
  202:         """
  203:         filearray=[]
  204:         urlparsed=urlparse(index_meta)[1:]
  205: 
  206:         for x in urlparsed:
  207:             
  208:             if not (x==''):
  209:                 filearray.append(x)
  210: 
  211:         path=os.sep.join(filearray)
  212: 
  213:         realPath=os.path.normpath(os.path.join(self.rootFolderName,path))
  214:         
  215:         if realPath.find(self.rootFolderName) <0: #versuch auf Pfad unterhalb des Rootfolder zuzugreifen
  216:             return {}
  217:             
  218: 
  219:         if not os.path.isfile(realPath):
  220:             return None,"(ERROR) path %s does not exist."%path
  221: 
  222:     
  223:         fh=file(realPath,'r')
  224:         str=fh.read()
  225:         fh.close()
  226:         return str
  227: 
  228: 
  229: Globals.InitializeClass(OSAS_root)
  230: 
  231: def manage_addOSAS_rootForm(self):
  232:     """interface for adding the OSAS_root"""
  233:     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addOSAS_rootForm.zpt')).__of__(self)
  234:     return pt()
  235: 
  236: def manage_addOSAS_root(self,id,RootFolderName,uploadServletUrl,RESPONSE=None):
  237:     """add the OSAS_root"""
  238:     newObj=OSAS_root(id,RootFolderName,uploadServletUrl)
  239:     self._setObject(id,newObj)
  240:     if RESPONSE is not None:
  241:         RESPONSE.redirect('manage_main')
  242: 
  243: