""" 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
import xmlrpclib
from xml.sax import make_parser
from xml.sax.handler import ContentHandler
import sys
class OSAS_add_contextData(Folder):
"""Einfuegen eines Documentes in eine Collection"""
security=ClassSecurityInfo()
meta_type='OSAS_addObjectToCollection'
def XmlToTree(self,URL,pwstr=None):
"""Collection XML to Tree"""
def spaces(depth):
tmp=""
k=0
while k<2*depth:
k+=1
tmp=tmp+" "+" "
return tmp
class requestHandler(ContentHandler):
def __init__(self):
self.depth=0
self.retStr=""
def startElement(self,name,attrs):
if name=="element":
self.depth+=1
begin=""
end=""
if self.depth==1:
begin="<b>"
end="</b>"
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"
def endElement(self,name):
if name=="element":
self.depth-=1
if pwstr=="":
pwstr=None
try:
if pwstr:
URL+="/getCollectionTreeXML?pwstr=%s"%pwstr
else:
URL+="/getCollectionTreeXML"
parser=make_parser()
curHandler=requestHandler()
parser.setContentHandler(curHandler)
parser.parse(urllib.urlopen(URL))
return curHandler.retStr.encode('utf-8')
except:
zLOG.LOG('OSAS_Root (addFileToDollection)',zLOG.ERROR,'%s %s'%sys.exc_info()[:2])
return URL
return urllib.urlopen(URL).read()
def __init__(self,id,collection):
self.id=id
self.collection=collection
def getPartners(self,URL):
"""Zeige Partnerliste"""
class requestHandler(ContentHandler):
def __init__(self):
self.ret=[]
def startElement(self,name,attrs):
if name=="partner":
self.ret.append((attrs.get('id'),attrs.get('title').encode('utf-8')))
URL+="/getPartnersXML"
parser=make_parser()
curHandler=requestHandler()
parser.setContentHandler(curHandler)
parser.parse(urllib.urlopen(URL))
try:
return curHandler.ret
except:
return [("",URL)]
def addContextData(self,path):
"""Hinzufuegen zu einer Sammlung"""
server=xmlrpclib.Server(self.serverUrl)
self.REQUEST.SESSION['images']=server.getImages(path)
self.REQUEST.SESSION['movies']=server.getMovies(path)
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','contextDataMain.zpt')).__of__(self)
return pt()
index_html=addContextData
def addContextData2(self,path,collection,label,description,content_type,responsible,weight,thumb="",streamingfile="",rawfile="",lowresfile="",credits=None):
"""Hinzufuegen der Resource"""
splitted=path.split("/")
#print "BLU"
id=splitted[len(splitted)-1]
title=splitted[len(splitted)-1]
metalink=self.REQUEST['SERVER_URL']+path+"/index.meta"
#link=TOBEDONE"
"""Hinzufuegen der Ressource"""
gifPath=path.replace("/mpiwg/online/","")
rawPath=path.replace("/mpiwg/online/permanent/einstein_exhibition/movies/","")
lowresPath=path.replace("/mpiwg/online/permanent/einstein_exhibition/movies/","")
thumbUrl="http://einst3.mpiwg-berlin.mpg.de/"+gifPath+"/"+thumb
link="rtsp://einst1.mpiwg-berlin.mpg.de/"+gifPath+"/"+streamingfile
rawFile="file:///Volumes/einstein_movies/"+rawPath+"/"+rawfile
lowresFile="file:///Volumes/einstein_movies/"+lowresPath+"/"+lowresfile
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})
try:
server=xmlrpclib.Server(collection,allow_none=True)
retStr=server.addMovie(id,title,label,description,content_type,responsible,link,thumbUrl,rawFile,lowresFile,metalink,weight,credits)
except:
zLOG.LOG('OSAS_Root (addFileToDollection2)',zLOG.ERROR,'%s %s'%sys.exc_info()[:2])
return "An Error occured adding the resource\n", collection,params
#print "added"
if not retStr:
return "An Error occured adding the resource\n", collection,params
#print collection+"/"+id+"/copyIndex_meta2echo_resource"
urllib.urlopen(collection+"/"+id+"/copyIndex_meta2echo_resource").read()
#print "copy2res"
urllib.urlopen(collection+"/"+id+"/generate_label").read()
#print "label"
urllib.urlopen(collection+"/"+id+"/generate_title").read()
#print "title"
return self.REQUEST.RESPONSE.redirect(self.REQUEST['URL2']+'/browse?path='+path)
manage_options = Folder.manage_options+(
{'label':'Main Config','action':'add_contextData_config'},
)
def add_contextData_config(self):
"""Main configuration"""
pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt','changeAddContextData.zpt')).__of__(self)
return pt()
def change_OSAS_add_contextData(self,collection,pwstr=None,RESPONSE=None):
"""Change"""
self.pwstr=pwstr
self.collection=collection
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
def manage_AddOSAS_add_contextDataForm(self):
"""interface for adding the OSAS_add_Metadata"""
pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt','addContextData.zpt')).__of__(self)
return pt()
def manage_AddOSAS_add_contextData(self,id,collection,RESPONSE=None):
"""add the OSAS_root"""
newObj=OSAS_add_contextData(id,collection)
self.Destination()._setObject(id,newObj)
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
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,newTarget="yes",RESPONSE=None):
"""Change RootFolderName"""
self.title=title
self.prefix=prefix
self.ignorePath=ignorePath
self.objectTypes=toList(objectTypes)
self.newTarget=newTarget
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,serverUrl,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
self.serverUrl=serverUrl
meta_type="OSAS_Root"
manage_options = Folder.manage_options+(
{'label':'Main Config','action':'changeRootForm'},
)
OSASObjectTypes=OSAS_helpers.OSASObjectTypes
def extendDict(self,dict1,dict2):
"""add two dicts"""
ret=dict1
for name in dict2.keys():
ret[name]=dict2[name]
return ret
def generateMovieThumb(self,name):
"""generate movie"""
server=xmlrpclib.Server(self.serverUrl)
name="/mpiwg/online/permanent/einstein_exhibition/movies/"+name
ret=server.generateMovieThumb(name,os.path.splitext(name)[0]+".gif")
return ret
security.declareProtected("View management screens","getOSASObjectTypes")
def getOSASObjectTypes(self):
"""return list of objecttypes"""
return OSASObjectTypes
def setProxy(self,name,value):
"""set proxy"""
self.REQUEST.SESSION[name]=value
return True
def listToSingle(self,path):
"""list to single"""
if type(path)==ListType:
return path[0]
else:
return path
def splitPath(self,path):
"""split path"""
if type(path)==ListType:
path=path[0]
return os.path.split(path)
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,serverUrl,RESPONSE=None):
"""Change RootFolderName"""
self.rootFolderName=rootFolderName
self.serverUrl=serverUrl
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,serverUrl,RESPONSE=None):
"""add the OSAS_root"""
newObj=OSAS_root(id,RootFolderName,serverUrl,uploadServletUrl)
self._setObject(id,newObj)
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>