Annotation of OSA_system2/OSAS_root.py, revision 1.12

1.2       dwinter     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: """
1.1       dwinter     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
1.2       dwinter    21: import Globals
1.1       dwinter    22: from Globals import package_home
1.2       dwinter    23: from AccessControl import ClassSecurityInfo
1.6       dwinter    24: import xmlrpclib
                     25: from xml.sax import make_parser
                     26: from xml.sax.handler import ContentHandler
                     27: import sys
1.1       dwinter    28: 
1.6       dwinter    29: class OSAS_add_contextData(Folder):
                     30:     """Einfuegen eines Documentes in eine Collection"""
                     31:     
                     32:     security=ClassSecurityInfo()
                     33: 
                     34:             
                     35:     meta_type='OSAS_addObjectToCollection'    
                     36: 
                     37:     def XmlToTree(self,URL,pwstr=None):
                     38:         """Collection XML to Tree"""
                     39:         def spaces(depth):
                     40:             
                     41:             tmp=""
                     42:             k=0
                     43:             while k<2*depth:
                     44:                 k+=1
                     45:                 tmp=tmp+"&nbsp;"+"&nbsp;"
                     46:             return tmp
                     47: 
                     48:         class requestHandler(ContentHandler):
                     49:             def __init__(self):
                     50:                 self.depth=0
                     51:                 self.retStr=""
                     52:                 
                     53:             def startElement(self,name,attrs):
                     54:                 if name=="element":
                     55:                     self.depth+=1
                     56:                     begin=""
                     57:                     end=""
                     58:                     if self.depth==1:
                     59:                         begin="<b>"
                     60:                         end="</b>"
                     61:                         
                     62:                     self.retStr+=spaces(self.depth)+"<input type='radio' name='collection' value='%s'>%s</input>"%(attrs.get('url'),begin+urllib.unquote(attrs.get('name')))+end+"<br>\n"
                     63: 
                     64: 
                     65:                     
                     66:             def endElement(self,name):
                     67:                 if name=="element":
                     68:                     self.depth-=1
                     69: 
                     70:         if pwstr=="":
                     71:             pwstr=None
                     72:             
                     73:        
                     74: 
                     75:         try:
                     76:             if pwstr:
                     77:                 URL+="/getCollectionTreeXML?pwstr=%s"%pwstr    
                     78:             else:
                     79:                 URL+="/getCollectionTreeXML"
                     80:             parser=make_parser()
                     81:             curHandler=requestHandler()
                     82:             parser.setContentHandler(curHandler)
                     83: 
                     84:             parser.parse(urllib.urlopen(URL))
                     85:             return curHandler.retStr.encode('utf-8')
                     86: 
                     87:         except:
                     88:             zLOG.LOG('OSAS_Root (addFileToDollection)',zLOG.ERROR,'%s %s'%sys.exc_info()[:2])
1.12    ! dwinter    89:             return URL
1.6       dwinter    90:             return urllib.urlopen(URL).read()
1.12    ! dwinter    91:             
1.6       dwinter    92:       
                     93:     def __init__(self,id,collection):
                     94:         self.id=id
                     95:         self.collection=collection
                     96: 
                     97:   
                     98:    
                     99: 
                    100:     def getPartners(self,URL):
                    101:         """Zeige Partnerliste"""
                    102:         class requestHandler(ContentHandler):
                    103:             def __init__(self):
                    104:                 self.ret=[]
                    105:                 
                    106:             def startElement(self,name,attrs):
                    107:                 if name=="partner":
                    108:                     self.ret.append((attrs.get('id'),attrs.get('title').encode('utf-8')))
                    109: 
                    110: 
                    111:         URL+="/getPartnersXML"
1.12    ! dwinter   112:         parser=make_parser()    
        !           113:         curHandler=requestHandler()
1.6       dwinter   114:         parser.setContentHandler(curHandler)
1.12    ! dwinter   115:         parser.parse(urllib.urlopen(URL))               
        !           116:         try:    
1.6       dwinter   117:                   
1.12    ! dwinter   118:                 return curHandler.ret
1.6       dwinter   119:         except:
1.12    ! dwinter   120:                 return [("",URL)]
1.6       dwinter   121: 
                    122:     
                    123:     
                    124:     def addContextData(self,path):
                    125:         """Hinzufuegen zu einer Sammlung"""
                    126: 
                    127:         server=xmlrpclib.Server(self.serverUrl)
                    128:         
                    129: 
                    130:         self.REQUEST.SESSION['images']=server.getImages(path)
                    131: 
                    132: 
                    133:         self.REQUEST.SESSION['movies']=server.getMovies(path)
                    134: 
                    135: 
                    136:         
                    137:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','contextDataMain.zpt')).__of__(self)
                    138:         return pt()
                    139:     
                    140:     index_html=addContextData
                    141:     
1.10      dwinter   142:     def addContextData2(self,path,collection,label,description,content_type,responsible,weight,thumb="",streamingfile="",rawfile="",lowresfile="",credits=None):
1.6       dwinter   143:         """Hinzufuegen der Resource"""
                    144:         splitted=path.split("/")
                    145:         #print "BLU"
                    146:         id=splitted[len(splitted)-1]
                    147:         title=splitted[len(splitted)-1]
                    148:         metalink=self.REQUEST['SERVER_URL']+path+"/index.meta"
                    149:         
                    150:         #link=TOBEDONE"
                    151:         """Hinzufuegen der Ressource"""
1.12    ! dwinter   152: 
        !           153:         gifPath=path.replace("/mpiwg/online/","")
        !           154:         rawPath=path.replace("/mpiwg/online/permanent/einstein_exhibition/movies/","")
        !           155:         lowresPath=path.replace("/mpiwg/online/permanent/einstein_exhibition/movies/","")
        !           156: 
1.7       dwinter   157:         thumbUrl="http://einst3.mpiwg-berlin.mpg.de/"+gifPath+"/"+thumb
                    158:         link="rtsp://einst1.mpiwg-berlin.mpg.de/"+gifPath+"/"+streamingfile
                    159:         rawFile="file:///Volumes/einstein_movies/"+rawPath+"/"+rawfile
1.11      dwinter   160:         lowresFile="rtsp://einst1.mpiwg-berlin.mpg.de/"+gifPath+"/"+lowresfile
1.6       dwinter   161: 
                    162:         
                    163:         params=urllib.urlencode({'id':id,'title':title,'link':link,'thumbUrl':thumbUrl,'rawFile':rawFile,'label':label,'description':description,'contentType':content_type,'responsible':responsible,'weight':weight,'credits':credits,'metalink':metalink})
                    164: 
1.8       dwinter   165:                 
1.6       dwinter   166:         try:
                    167:             server=xmlrpclib.Server(collection,allow_none=True)
1.10      dwinter   168:             retStr=server.addMovie(id,title,label,description,content_type,responsible,link,thumbUrl,rawFile,lowresFile,metalink,weight,credits)
1.6       dwinter   169:         except:
                    170:             zLOG.LOG('OSAS_Root (addFileToDollection2)',zLOG.ERROR,'%s %s'%sys.exc_info()[:2])
                    171:             return "An Error occured adding the resource\n", collection,params
                    172:         
1.12    ! dwinter   173:         #print "added"
        !           174:         if not retStr:
1.6       dwinter   175:             return "An Error occured adding the resource\n", collection,params
1.12    ! dwinter   176:         
1.6       dwinter   177:         #print collection+"/"+id+"/copyIndex_meta2echo_resource"
                    178: 
                    179:         urllib.urlopen(collection+"/"+id+"/copyIndex_meta2echo_resource").read()
1.12    ! dwinter   180:         #print "copy2res"
1.6       dwinter   181:         urllib.urlopen(collection+"/"+id+"/generate_label").read()
1.12    ! dwinter   182:         #print "label"
1.6       dwinter   183:         urllib.urlopen(collection+"/"+id+"/generate_title").read()
1.12    ! dwinter   184:         #print "title"
1.8       dwinter   185:         return self.REQUEST.RESPONSE.redirect(self.REQUEST['URL2']+'/browse?path='+path)
1.6       dwinter   186:         
                    187:     manage_options = Folder.manage_options+(
                    188:             {'label':'Main Config','action':'add_contextData_config'},
                    189:             )
                    190:         
                    191:      
                    192:     def add_contextData_config(self):
                    193:         """Main configuration"""
                    194:         pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt','changeAddContextData.zpt')).__of__(self)
                    195:         return pt()
                    196:     
                    197:     
                    198:     def change_OSAS_add_contextData(self,collection,pwstr=None,RESPONSE=None):
                    199:         """Change"""
                    200:         self.pwstr=pwstr
                    201:         self.collection=collection
                    202:         if RESPONSE is not None:
                    203:             RESPONSE.redirect('manage_main')
                    204:             
                    205: def manage_AddOSAS_add_contextDataForm(self):
                    206:     """interface for adding the OSAS_add_Metadata"""
                    207:     pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt','addContextData.zpt')).__of__(self)
                    208:     return pt()
                    209: 
                    210: def manage_AddOSAS_add_contextData(self,id,collection,RESPONSE=None):
                    211:     """add the OSAS_root"""
                    212:     newObj=OSAS_add_contextData(id,collection)
                    213:     self.Destination()._setObject(id,newObj)
                    214:     if RESPONSE is not None:
                    215:         RESPONSE.redirect('manage_main')
                    216: 
                    217:             
                    218: 
                    219: 
                    220:     
1.1       dwinter   221: 
1.3       dwinter   222: class OSAS_handlerObject(Folder):
1.1       dwinter   223:     """
1.3       dwinter   224:     Grundlegende Klasse fuer Handler zur Zeit noch in Entwicklung
1.1       dwinter   225: 
                    226:     """
1.3       dwinter   227:     meta_type="OSAS_HandlerObject__neu"
1.2       dwinter   228: 
1.1       dwinter   229:     
                    230:     def __init__(self,id,title,prefix,objectTypes,ignorePath=""):
                    231:         """inititialisiere die Klasse
                    232: 
                    233:         :Parameters:
                    234:          - `id` : Zope ID des Objektes
                    235:          - `title`: Titel des Objektes
                    236:          - `prefix` : URL bzw. URL Rumpf der Zusammen mit dem Pfad des Objectes die Anzeige URL ergibt
1.3       dwinter   237:          - `objectType` : liste von Objekttypen die mittels dieses Handlers angezeigt werden können.
1.1       dwinter   238:          - `ignorePath` : Pfad der bei dem übergebenen Pfad element ingnoriert werden soll. Optional.
                    239:         """
                    240:         self.id=id
                    241:         self.title=title
                    242:         self.prefix=prefix
                    243:         self.objectTypes=toList(objectTypes)
                    244:         self.ignorePath=ignorePath
                    245: 
                    246:     manage_options = Folder.manage_options+(
1.3       dwinter   247:         {'label':'Main Config','action':'changeHandlerObjectForm'},
1.1       dwinter   248:         )
                    249: 
1.3       dwinter   250:     def changeHandlerObjectForm(self):
1.1       dwinter   251:         """Main configuration"""
1.3       dwinter   252:         pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt','changeHandlerObjectForm.zpt')).__of__(self)
1.1       dwinter   253:         return pt()
                    254: 
1.6       dwinter   255:     def changeHandlerObject(self,title,prefix,objectTypes="",ignorePath=None,newTarget="yes",RESPONSE=None):
1.1       dwinter   256:         """Change RootFolderName"""
                    257:         self.title=title
                    258:         self.prefix=prefix
                    259:         self.ignorePath=ignorePath
                    260:         self.objectTypes=toList(objectTypes)
1.6       dwinter   261:         self.newTarget=newTarget
1.1       dwinter   262:         
                    263:         if RESPONSE is not None:
                    264:             RESPONSE.redirect('manage_main')
                    265: 
                    266: 
1.3       dwinter   267: def manage_addHandlerObjectForm(self):
                    268:     """form for adding a handler Object"""
                    269:     pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt','addHandlerObjectForm.zpt')).__of__(self)
1.1       dwinter   270:     return pt()
                    271: 
1.3       dwinter   272: def manage_addHandlerObject(self,id,title,prefix,objectTypes,ignorePath,RESPONSE=None):
1.1       dwinter   273:     """add the OSAS_root"""
1.3       dwinter   274:     newObj=OSAS_handlerObject(id,title,prefix,objectTypes,ignorePath)
1.1       dwinter   275:     self._setObject(id,newObj)
                    276:     
                    277:     if RESPONSE is not None:
                    278:         RESPONSE.redirect('manage_main')
                    279: 
                    280:     
                    281: class OSAS_root(Folder,Implicit):
                    282:     """Implicit Folder of the  Storage Systems"""
1.2       dwinter   283: 
                    284:     security=ClassSecurityInfo()
                    285: 
1.4       dwinter   286:     def __init__(self,id,rootFolderName,serverUrl,uploadServletUrl=None):
1.1       dwinter   287:         """initialize a new instance
                    288: 
                    289: 
                    290:         @param id: Zope ID des Objektes
                    291:         @param rootFolderName : path zum root folder des Storagesystems
                    292:         @param uploadServerletUrl : url des UploadServlets (required fuer batch upload)
                    293: 
                    294:         """
                    295:         
                    296:         self.id = id
                    297:         self.rootFolderName = rootFolderName
                    298:         self.uploadServletUrl=uploadServletUrl
1.4       dwinter   299:         self.serverUrl=serverUrl
1.5       dwinter   300:     meta_type="OSAS_Root"
1.1       dwinter   301: 
                    302:     manage_options = Folder.manage_options+(
                    303:         {'label':'Main Config','action':'changeRootForm'},
                    304:         )
                    305: 
                    306: 
                    307:     OSASObjectTypes=OSAS_helpers.OSASObjectTypes
1.5       dwinter   308: 
1.9       dwinter   309:     def extendDict(self,dict1,dict2):
                    310:         """add two dicts"""
                    311:         ret=dict1
                    312:         for name in dict2.keys():
                    313:             ret[name]=dict2[name]
                    314:         return ret
                    315:     
                    316:         
1.6       dwinter   317:     def generateMovieThumb(self,name):
                    318:         """generate movie"""
                    319:         server=xmlrpclib.Server(self.serverUrl)
1.7       dwinter   320:         name="/mpiwg/online/permanent/einstein_exhibition/movies/"+name
                    321: 
1.8       dwinter   322:         
1.6       dwinter   323:         ret=server.generateMovieThumb(name,os.path.splitext(name)[0]+".gif")
                    324:         return ret
                    325:     
1.5       dwinter   326:     security.declareProtected("View management screens","getOSASObjectTypes")
                    327:     def getOSASObjectTypes(self):
                    328:         """return list of objecttypes"""
                    329:         return OSASObjectTypes
                    330: 
                    331:     def setProxy(self,name,value):
                    332:         """set proxy"""
                    333:         self.REQUEST.SESSION[name]=value
                    334:         return True
                    335: 
                    336:     def listToSingle(self,path):
                    337:         """list to single"""
                    338:         if type(path)==ListType:
                    339:             return path[0]
                    340:         else:
                    341:             return path
                    342: 
                    343:     def splitPath(self,path):
                    344:         """split path"""
                    345:         if type(path)==ListType:
                    346:             path=path[0]
                    347:         return os.path.split(path)
1.1       dwinter   348:     
                    349:     def changeRootForm(self):
                    350:         """Main configuration"""
                    351:         pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt','changeRootForm.zpt')).__of__(self)
                    352:         
                    353:         return pt()
                    354: 
1.4       dwinter   355:     def changeRoot(self,rootFolderName,uploadServletUrl,serverUrl,RESPONSE=None):
1.1       dwinter   356:         """Change RootFolderName"""
                    357:         self.rootFolderName=rootFolderName
1.4       dwinter   358:         self.serverUrl=serverUrl
1.1       dwinter   359:         self.uploadServletUrl=uploadServletUrl
                    360:         
                    361:         if RESPONSE is not None:
                    362:             RESPONSE.redirect('manage_main')
                    363: 
                    364:     localDate=localDate
                    365:     
                    366:     def getUploadServletUrl(self):
                    367:         """gibt  url des servlets zurueck"""
                    368:         return self.uploadServletUrl
                    369:         
                    370: 
1.2       dwinter   371:     def validateIndexMeta(self,data):
                    372:         """TO BE DONE testet ob data ein gueltiges index.meta file ist, zur Zeit wird dom erzeugt ohne validierung.
                    373:         @param data: zu testendes XML file als string
                    374:         @return: zeiger auf dom  falls ok, None  andernfalls (z.Z: immmer dom falls parse possible)
                    375:         """
                    376:         try:
                    377:             return xml.dom.minidom.parseString(xmlneu)
                    378:         except:
                    379:             return None
                    380:         
                    381:     security.declareProtected('View management screens','uploadExternalXMLString','uploadExternalXMLUrl','uploadExternalXML')
                    382:     
                    383:     def uploadExternalXMLString(self,index_meta_url,xml_string):
                    384:         """lese ein xml file aus xml_url und schreibe es in den lokalen Filebaum
1.1       dwinter   385:         
                    386:         @param index_meta_url: url eines index.meta files auf dem lokalen Server, es gilt rootFolderName + pfad teil der url = pfad auf dem Server. 
1.2       dwinter   387:         @param xml_string: string mit index_meta ersetzt obiges index.meta
1.1       dwinter   388:         @return: 'error' als String bei Fehler 'ok' bei ok.
                    389:         """
1.2       dwinter   390: 
                    391:         return self.uploadExternalXML(index_meta_url,xml_string)
                    392: 
                    393: 
                    394:     def uploadExternalXMLUrl(self,index_meta_url,xml_url):
                    395:         """lese ein xml file aus xml_url und schreibe es in den lokalen Filebaum
1.1       dwinter   396:         
1.2       dwinter   397:         @param index_meta_url: url eines index.meta files auf dem lokalen Server, es gilt rootFolderName + pfad teil der url = pfad auf dem Server. 
                    398:         @param xml_url: externe url auf ein index_meta ersetzt obiges index.meta
                    399:         @return: 'error' als String bei Fehler 'ok' bei ok.
                    400:         """
                    401: 
                    402:         return self.uploadExternalXML(index_meta_url,xml_url)
1.1       dwinter   403: 
1.2       dwinter   404:     
                    405:     def uploadExternalXML(self,index_meta_url,xml_url=None,xml_string=None):
                    406:         """lese ein xml file aus xml_url und schreibe es in den lokalen Filebaum
1.1       dwinter   407:         
1.2       dwinter   408:         @param index_meta_url: url eines index.meta files auf dem lokalen Server, es gilt rootFolderName + pfad teil der url = pfad auf dem Server. 
                    409:         @param xml_url: (optional, default=None) externe url auf ein index_meta ersetzt obiges index.meta
                    410:         @param xml_string: (optional, default=None) string mit index_meta ersetzt obiges index.meta
                    411:         @return: 'error' als String bei Fehler 'ok' bei ok.
                    412:         """
1.1       dwinter   413: 
1.2       dwinter   414:         if xml_url:
                    415:             xmlneu=urllib.urlopen(xml_url).read()
                    416:         else:
                    417:             xmlneu=xml_string
                    418:         
                    419:         dom=self.validateIndexMeta(xmlneu)
                    420:         if not dom:
1.1       dwinter   421:             zLOG.LOG('OSAS_Root (downloadExternalXML)',zLOG.ERROR,'cannot parse: %s', xml_url)
                    422:             return "error"
                    423: 
                    424: 
                    425:         path=self.rootFolderName+urlparse(index_meta_url)[2]
                    426: 
                    427:         fh=open(path,'w')
                    428: 
                    429:         fh.write(xmlneu)
                    430:         fh.close()
                    431:         return "ok"
                    432: 
1.2       dwinter   433:     security.declareProtected('View','getIndexMetaFile')
                    434: 
                    435:    
                    436:     def getIndexMetaFile(self,index_meta):
                    437:         """gibt index metafile aus
                    438:         @param index_meta: index_meta ist eine URI entweder url des index_meta oder file mit file://
                    439:         """
                    440:         filearray=[]
                    441:         urlparsed=urlparse(index_meta)[1:]
                    442: 
                    443:         for x in urlparsed:
                    444:             
                    445:             if not (x==''):
                    446:                 filearray.append(x)
                    447: 
                    448:         path=os.sep.join(filearray)
                    449: 
                    450:         realPath=os.path.normpath(os.path.join(self.rootFolderName,path))
1.1       dwinter   451:         
1.2       dwinter   452:         if realPath.find(self.rootFolderName) <0: #versuch auf Pfad unterhalb des Rootfolder zuzugreifen
                    453:             return {}
                    454:             
                    455: 
                    456:         if not os.path.isfile(realPath):
                    457:             return None,"(ERROR) path %s does not exist."%path
                    458: 
                    459:     
                    460:         fh=file(realPath,'r')
                    461:         str=fh.read()
                    462:         fh.close()
                    463:         return str
                    464: 
                    465: 
                    466: Globals.InitializeClass(OSAS_root)
                    467: 
1.1       dwinter   468: def manage_addOSAS_rootForm(self):
                    469:     """interface for adding the OSAS_root"""
                    470:     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addOSAS_rootForm.zpt')).__of__(self)
                    471:     return pt()
                    472: 
1.4       dwinter   473: def manage_addOSAS_root(self,id,RootFolderName,uploadServletUrl,serverUrl,RESPONSE=None):
1.1       dwinter   474:     """add the OSAS_root"""
1.4       dwinter   475:     newObj=OSAS_root(id,RootFolderName,serverUrl,uploadServletUrl)
1.1       dwinter   476:     self._setObject(id,newObj)
                    477:     if RESPONSE is not None:
                    478:         RESPONSE.redirect('manage_main')
                    479: 
                    480:     

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>