version 1.19, 2004/09/09 16:56:37
|
version 1.27, 2004/11/28 21:56:07
|
Line 1
|
Line 1
|
import socket |
import socket |
import urllib |
import urllib |
|
import xml.dom.minidom |
|
from types import * |
|
from Products.PageTemplates.PageTemplateFile import PageTemplateFile |
|
from Globals import package_home |
|
import os.path |
|
|
|
displayTypes = ['ZSQLExtendFolder','ZSQLBibliography','ECHO_group','ECHO_collection','ECHO_resource','ECHO_link','ECHO_sqlElement','ECHO_pageTemplate','ECHO_externalLink','ImageCollectionIFrame','VLP_resource','VLP_essay','ECHO_ZCatalogElement','ImageCollection','versionedFileFolder'] |
|
|
|
def content_html(self,type): |
|
"""template fuer content""" |
|
#templates = self.ZopeFind(self.aq_parent,obj_ids=[type+"_template"]) |
|
# |
|
#if templates: |
|
# return templates[0][1]() |
|
|
|
if hasattr(self,type+"_template"): |
|
obj=getattr(self,type+"_template") |
|
return obj() |
|
else: |
|
pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_%s_template_standard.zpt'%type).__of__(self) |
|
pt.content_type="text/html" |
|
return pt() |
|
|
|
|
|
|
|
class ECHO_basis: |
|
"""basis eigenschaften fuer echo objekte""" |
|
def showRDF(self): |
|
"""showrdf""" |
|
self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml') |
|
ret="""<?xml version="1.0" encoding="utf-8"?>\n<RDF:RDF xmlns:RDF="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:ECHONAVIGATION="http://www.echo.eu/rdf#">\n""" |
|
ret+=self.getRDF(urn="echo:colllectionroot")+"\n" |
|
|
|
ret+="""</RDF:RDF>""" |
|
return ret |
|
|
|
|
|
|
|
def createSubElementRDF(self,urn=None): |
|
"""rdf list""" |
|
if not urn: |
|
urn=self.absolute_url() |
|
ret="" |
|
|
|
rettemp="""<RDF:Seq RDF:about="%s">\n"""%urn |
|
flag=0 |
|
|
|
li="""<RDF:li RDF:resource="%s" />\n""" |
|
if not ('<error>' in self.getFullTextXML(noredirect='Yes')): |
|
nurn=self.absolute_url()+'/getFullTextXML' |
|
rettemp+=li%nurn |
|
flag=1 |
|
if not ('<error>' in self.getImageView(noredirect='Yes')): |
|
nurn=self.absolute_url()+'/getImageView' |
|
rettemp+=li%nurn |
|
flag=1 |
|
|
|
|
|
if not ('<error>' in self.showMetaDataXML()): |
|
nurn=self.absolute_url()+'/showMetaDataXML' |
|
rettemp+=li%nurn |
|
flag=1 |
|
|
|
rettemp+="</RDF:Seq>" |
|
|
|
if flag==1: |
|
ret+=rettemp |
|
|
|
if not ('<error>' in self.getFullTextXML(noredirect='Yes')): |
|
nurn=self.absolute_url()+'/getFullTextXML' |
|
ret+=getRDFDescription(self,self.absolute_url()+'/getFullTextXML',urn=nurn,nameDef="Fulltext",typeName="ECHO_fulltext") |
|
|
|
if not ('<error>' in self.getImageView(noredirect='Yes')): |
|
nurn=self.absolute_url()+'/getImageView' |
|
ret+=getRDFDescription(self,self.absolute_url()+'/getImageView',urn=nurn,nameDef="Image View",typeName="ECHO_imageview") |
|
|
|
if not ('<error>' in self.showMetaDataXML()): |
|
nurn=self.absolute_url()+'/showMetaDataXML' |
|
ret+=getRDFDescription(self,self.absolute_url()+'/showMetaDataXML',urn=nurn,nameDef="Metadata",typeName="ECHO_metaData") |
|
|
|
return ret |
|
|
|
def content_html(self,type="collection"): |
|
"""template fuer content bei einbau und ECHO_Umgebung""" |
|
|
|
return content_html(self,type) |
|
|
|
def getTitle(self): |
|
"""title""" |
|
try: |
|
return self.title.encode('utf-8','ignore') |
|
except: |
|
self.title=self.title.decode('iso-8859-1','ignore')[0:] #correnct conding error |
|
return self.title.encode('utf-8','ignore') |
|
|
|
def getLabel(self): |
|
"""title""" |
|
try: |
|
return self.label.encode('utf-8','ignore') |
|
except: |
|
self.label=self.label.decode('iso-8859-1','ignore')[0:] #correnct conding error |
|
return self.label.encode('utf-8','ignore') |
|
|
|
|
|
def changeECHOEntriesForm(self): |
|
"""change Entries for the ECHO Navigation environment""" |
|
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeECHOEntriesForm')).__of__(self) |
|
return pt() |
|
|
|
def changeECHOEntries(self,label,weight,description,queryString,RESPONSE=None): |
|
"""change Entries for the ECHO Navigation environment |
|
@param label: label fuer die Navigation""" |
|
self.label=label |
|
self.weight=weight |
|
self.description=description |
|
self.queryString=queryString |
|
|
|
if RESPONSE: |
|
RESPONSE.redirect("manage_main") |
|
|
|
manage_options=({'label':'change ECHO Navigation Entries','action':'changeECHOEntriesForm'},) |
|
|
|
#ende der echo erweiterungen |
|
|
|
|
|
def toList(field): |
|
"""Einzelfeld in Liste umwandeln""" |
|
if type(field)==StringType: |
|
return [field] |
|
else: |
|
return field |
|
|
|
def getText(nodelist): |
|
|
|
rc = "" |
|
for node in nodelist: |
|
if node.nodeType == node.TEXT_NODE: |
|
rc = rc + node.data |
|
return rc |
|
|
|
def getTextFromNode(nodename): |
|
nodelist=nodename.childNodes |
|
rc = "" |
|
for node in nodelist: |
|
if node.nodeType == node.TEXT_NODE: |
|
rc = rc + node.data |
|
return rc |
|
|
|
|
|
def readFieldFromXML(meta_url,parent,field): |
|
"""lesespezifisches metadatum""" |
|
|
|
try: |
|
dom=xml.dom.minidom.parse(meta_url) |
|
|
|
except: |
|
try: |
|
fh=urllib.urlopen(meta_url) |
|
dom=xml.dom.minidom.parse(fh) |
|
except: |
|
return None |
|
if not dom: return None |
|
|
|
parent=dom.getElementsByTagName(parent) |
|
if not parent: return None |
|
|
|
field=parent[0].getElementsByTagName(field) |
|
|
|
if not field: return None |
|
|
|
return getText(field[0].childNodes) |
|
|
|
|
|
|
def urlopen(url): |
def urlopen(url): |
"""urlopen mit timeout""" |
"""urlopen mit timeout""" |
|
socket.setdefaulttimeout(2) |
|
ret=urllib.urlopen(url) |
socket.setdefaulttimeout(5) |
socket.setdefaulttimeout(5) |
return urllib.urlopen(url) |
return ret |
# urlopener = urllib.URLopener() |
# urlopener = urllib.URLopener() |
# |
# |
# try: |
# try: |
Line 14 def urlopen(url):
|
Line 189 def urlopen(url):
|
# return None |
# return None |
|
|
|
|
displayTypes = ['ZSQLExtendFolder','ZSQLBibliography','ECHO_group','ECHO_collection','ECHO_resource','ECHO_link','ECHO_sqlElement','ECHO_pageTemplate','ImageCollectionIFrame','VLP_resource','VLP_essay','ECHO_ZCatalogElement'] |
|
|
|
|
|
def checkOnlyOneInGroup(object): |
def checkOnlyOneInGroup(object): |
Line 23 def checkOnlyOneInGroup(object):
|
Line 198 def checkOnlyOneInGroup(object):
|
if len(displayedObjects)==1: # nur ein Object dann redirect auf dieses Object |
if len(displayedObjects)==1: # nur ein Object dann redirect auf dieses Object |
|
|
return displayedObjects[0][1] |
return displayedObjects[0][1] |
else: |
else: return object |
return object |
|
|
|
def getSubCols(self,sortfield="weight",subColTypes= displayTypes): |
def getSubCols(self,sortfield="weight",subColTypes= displayTypes,sortFieldMD=None): |
|
|
|
def sortfnc(sortfield,x,y): |
|
xa=x[1].getMDValue(sortfield) |
|
ya=y[1].getMDValue(sortfield) |
|
print xa,ya |
|
return cmp(xa,ya) |
|
|
|
sortWithMD = lambda sortfield : (lambda x,y : sortfnc(sortfield,x,y)) |
ids=[] |
ids=[] |
displayedObjects=self.ZopeFind(self,obj_metatypes=subColTypes) |
displayedObjects=self.ZopeFind(self,obj_metatypes=subColTypes) |
|
|
|
|
for entry in displayedObjects: |
for entry in displayedObjects: |
|
|
object=entry[1] |
object=entry[1] |
try: |
|
if object.meta_type in subColTypes: |
|
ids.append(object) |
ids.append(object) |
|
|
except: |
|
"""nothing""" |
|
try: |
try: |
sortfield=self.sortfield |
sortfield=self.sortfield |
except: |
except: |
Line 58 def getSubCols(self,sortfield="weight",s
|
Line 235 def getSubCols(self,sortfield="weight",s
|
else: |
else: |
tmp=10000000 |
tmp=10000000 |
tmplist.append((tmp,x)) |
tmplist.append((tmp,x)) |
|
|
|
if not sortFieldMD: |
tmplist.sort() |
tmplist.sort() |
|
else: |
|
tmplist.sort(sortWithMD(sortFieldMD)) |
|
|
return [x for (key,x) in tmplist] |
return [x for (key,x) in tmplist] |
|
|
|
def ECHO_rerenderLinksMD(self,obj=None,types=['title','label']): |
|
"""Rerender all Links""" |
|
ret="" |
|
|
|
if not obj: |
|
obj = self |
|
|
|
entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource'],search_sub=1) |
|
|
|
for entry in entries: |
|
if entry[1].meta_type == 'ECHO_resource': |
|
try: |
|
entry[1].ECHO_getResourceMD(template="no") |
|
if "title" in types: |
|
entry[1].generate_title() |
|
if "label" in types: |
|
entry[1].generate_label() |
|
ret+="OK:"+entry[0]+"-- "+entry[1].getTitle().decode('utf-8')+"-- "+entry[1].getTitle().decode('utf-8')+"<br>" |
|
except: |
|
ret+="Error:"+entry[0]+"<br>" |
|
|
|
|
|
|
|
|
|
return "<html><body>"+ret+"Rerenderd all links to resources in: "+self.title+"</html></body>" |
|
|
|
def reloadMetaDataFromStorage(self,RESPONSE=None): |
|
"""copy metadata from the storage to ECHO""" |
|
ret="" |
|
resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1) |
|
|
|
for resource in resources: |
|
x=str(resource[1].copyIndex_meta2echo_resource())+"<br>" |
|
ret+=x |
|
#print x |
|
|
|
|
|
if RESPONSE is not None: |
|
#RESPONSE.redirect('./manage_main') |
|
return "<html><body>"+ret+"</html></body>" |
|
|
|
return ret |
|
|
|
def getRDFDescription(self,linkURL,urn=None,nameDef=None,typeName=None): |
|
"""rdf""" |
|
|
|
ret="" |
|
about="""<RDF:Description RDF:about="%s">""" |
|
name="""<ECHONAVIGATION:name>%s</ECHONAVIGATION:name>""" |
|
link="""<ECHONAVIGATION:link xlink:href="%s">%s</ECHONAVIGATION:link>""" |
|
clickable="""<ECHONAVIGATION:linkClickable>%s</ECHONAVIGATION:linkClickable>""" |
|
#link="""<ECHONAVIGATION:link RDF:about="%s"/>""" |
|
type="""<ECHONAVIGATION:type>%s</ECHONAVIGATION:type>""" |
|
#xlink="""<ECHONAVIGATION:xlink xlink:href="%s"/>""" |
|
if not urn: |
|
#urn="urn:"+re.sub('/',':',self.absolute_url()) |
|
urn=self.absolute_url() |
|
about2=about%urn |
|
if not nameDef: |
|
if hasattr(self,'label') and not (self.label==""): |
|
name2=name%self.label |
|
elif not self.title=="": |
|
name2=name%self.title |
|
else: |
|
name2=name%self.getId() |
|
|
|
name2=re.sub('&','&',name2) |
|
else: |
|
name2=name%nameDef |
|
|
|
linkURL=re.sub('http:','',linkURL) |
|
linkURL2=re.sub('&','&',linkURL) |
|
link2=link%(("http:"+linkURL2),("http:"+urllib.quote(linkURL))) |
|
clickable2=clickable%"true" |
|
|
|
if not typeName: |
|
type2=type%self.meta_type |
|
else: |
|
type2=type%typeName |
|
|
|
#ret=about2+"\n"+name2+"\n"+link2+"\n"+type2+"\n"+clickable2+"\n</RDF:Description>" |
|
ret=about2+"\n"+name2+"\n"+type2+"\n"+clickable2+"\n</RDF:Description>" |
|
return ret |
|
|
|
def getCopyrightsFromForm(self,argv): |
|
medias={} |
|
partners={} |
|
copyrights={} |
|
|
|
copyrightsFinal=[] |
|
for arg in argv.keys(): |
|
|
|
if arg[0:5]=='media': |
|
nm=int(arg[5:]) |
|
medias[nm]=argv[arg] |
|
elif arg[0:5]=='partn': |
|
nm=int(arg[5:]) |
|
partners[nm]=argv[arg] |
|
elif arg[0:5]=='copyr': |
|
nm=int(arg[5:]) |
|
copyrights[nm]=argv[arg] |
|
|
|
|
|
|
|
copyrightsList=[(medias[nm],partners[nm],copyrights[nm]) for nm in medias.keys()] |
|
for copyright in copyrightsList: |
|
|
|
if copyright[2]=='institution0000': |
|
copyrightsFinal.append((copyright[0],copyright[1],self.getPartnerCopyright(copyright[1],''))) |
|
else: |
|
if not copyright[0]=='': |
|
copyrightsFinal.append(copyright) |
|
|
|
|
|
return copyrightsFinal |
|
|
|
#List of different types for the graphical linking viewer |
|
viewClassificationListMaster=['view point','area'] |
|
|
|
|
|
def checkDiffs(self,metadict): |
|
"""check differences""" |
|
|
|
|
|
|
|
|
|
def NoneToEmpty(obj): |
|
if obj: |
|
return obj |
|
else: |
|
return "" |
|
|
|
|
|
|
|
diffs={} |
|
|
|
tags=self.findTagsFromMapping(self.contentType) |
|
self.referencetypes=tags[2] |
|
self.fields=tags[3] |
|
|
|
|
|
for field in tags[1]: |
|
try: |
|
if (NoneToEmpty(self.getFieldValue(self.getFieldTag(tags,field)))==metadict[self.getFieldTag(tags,field)]): |
|
diffs[self.getFieldTag(tags,field)]=1 |
|
else: |
|
|
|
diffs[self.getFieldTag(tags,field)]=0 |
|
except: |
|
diffs[self.getFieldTag(tags,field)]=0 |
|
|
|
return diffs |
|
|
|
|
|
|
|
|
|
def sendFile(self, filename, type): |
|
"""sends an object or a local file (in the product) as response""" |
|
paths = filename.split('/') |
|
object = self |
|
# look for an object called filename |
|
for path in paths: |
|
if hasattr(object, path): |
|
object = getattr(object, path) |
|
else: |
|
object = None |
|
break |
|
if object: |
|
# if the object exists then send it |
|
return object.index_html(self.REQUEST.REQUEST, self.REQUEST.RESPONSE) |
|
else: |
|
# send a local file with the given content-type |
|
fn = os.path.join(package_home(globals()), filename) |
|
self.REQUEST.RESPONSE.setHeader("Content-Type", type) |
|
self.REQUEST.RESPONSE.write(file(fn).read()) |
|
return |
|
|
|
class BrowserCheck: |
|
"""check the browsers request to find out the browser type""" |
|
|
|
def __init__(self, zope): |
|
"""initialisiere""" |
|
self.ua = zope.REQUEST.get_header("HTTP_USER_AGENT") |
|
self.isN4 = (string.find(self.ua, 'Mozilla/4.') > -1) and (string.find(self.ua, 'MSIE') < 0) |
|
self.isIE = string.find(self.ua, 'MSIE') > -1 |
|
self.nav = self.ua[string.find(self.ua, '('):] |
|
ie = string.split(self.nav, "; ")[1] |
|
if string.find(ie, "MSIE") > -1: |
|
self.versIE = string.split(ie, " ")[1] |
|
self.isMac = string.find(self.ua, 'Macintosh') > -1 |
|
self.isWin = string.find(self.ua, 'Windows') > -1 |
|
self.isIEWin = self.isIE and self.isWin |
|
self.isIEMac = self.isIE and self.isMac |
|
|
|
|
|
|
|
def writeMetadata(url,metadict,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None,xmlfrag=None,digiliburlprefix=None): |
|
"""Einlesen der Metadaten und und erstellen des geaenderten XML file""" |
|
|
|
def updateTextToolNode(tag,value): |
|
#print dom,tag,value |
|
metanode=dom.getElementsByTagName('texttool')[0] |
|
try: |
|
nodeOld=metanode.getElementsByTagName(tag) |
|
except: |
|
nodeOld=None |
|
|
|
if nodeOld: |
|
metanode.removeChild(nodeOld[0]).unlink() |
|
|
|
node=dom.createElement(tag) |
|
nodetext=dom.createTextNode(value) |
|
node.appendChild(nodetext) |
|
metanode.appendChild(node) |
|
|
|
if xmlfrag: |
|
geturl="""<?xml version="1.0" ?> |
|
<resource type="MPIWG"> |
|
<meta> |
|
<bib type="Book"> |
|
</bib> |
|
</meta> |
|
</resource>""" |
|
dom=xml.dom.minidom.parseString(geturl) |
|
else: |
|
try: |
|
geturl="" |
|
for line in ECHO_helpers.urlopen(url).readlines(): |
|
geturl=geturl+line |
|
|
|
|
|
except: |
|
return (None,"Cannot open: "+url) |
|
|
|
try: |
|
dom=xml.dom.minidom.parseString(geturl) |
|
except: |
|
return (None,"Cannot parse: "+url+"<br>"+geturl) |
|
|
|
|
|
|
|
metanodes=dom.getElementsByTagName('bib') |
|
|
|
if not metanodes: |
|
metanodes=dom.getElementsByTagName('archimedes') |
|
|
|
metanode=metanodes[0] |
|
|
|
for metaData in metadict.keys(): |
|
|
|
try: |
|
nodeOld=metanode.getElementsByTagName(metaData) |
|
except: |
|
nodeOld=None |
|
|
|
if nodeOld: |
|
metanode.removeChild(nodeOld[0]).unlink() |
|
else: |
|
# try also old writing rule - instead of _: |
|
try: |
|
nodeOld=metanode.getElementsByTagName(re.sub('_','-',metaData)) |
|
except: |
|
nodeOld=None |
|
|
|
if nodeOld: |
|
metanode.removeChild(nodeOld[0]).unlink() |
|
|
|
metanodeneu=dom.createElement(metaData) |
|
metanodetext=dom.createTextNode(metadict[metaData]) |
|
#try: |
|
#metanodetext=dom.createTextNode(unicode(metadict[metaData],"utf-8")) |
|
#except: |
|
#metanodetext=dom.createTextNode(metadict[metaData].encode('utf-8')) |
|
metanodeneu.appendChild(metanodetext) |
|
metanode.appendChild(metanodeneu) |
|
|
|
|
|
|
|
|
|
|
|
if project: |
|
updateTextToolNode('project',project) |
|
|
|
if startpage: |
|
updateTextToolNode('startpage',startpage) |
|
|
|
if topbar: |
|
updateTextToolNode('toptemplate',topbar) |
|
|
|
if thumbtemplate: |
|
updateTextToolNode('thumbtemplate',thumbtemplate) |
|
|
|
if xslt: |
|
updateTextToolNode('xslt',xslt) |
|
|
|
|
|
if digiliburlprefix: |
|
updateTextToolNode('digiliburlprefix',digiliburlprefix) |
|
|
|
try: |
|
return dom.toxml().encode('utf-8') |
|
except: |
|
return dom.toxml('utf-8') |
|
|
|
|
|
|
|
def readMetadata(url): |
|
"""Methode zum Auslesen der Metadateninformation zu einer Resource |
|
Vorerst noch Typ bib""" |
|
|
|
metadict={} |
|
try: |
|
geturl="" |
|
for line in ECHO_helpers.urlopen(url).readlines(): |
|
geturl=geturl+line |
|
|
|
|
|
except: |
|
return (None,"Cannot open: "+url) |
|
|
|
try: |
|
dom=xml.dom.minidom.parseString(geturl) |
|
except: |
|
return (None,"Cannot parse: "+url+"<br>"+geturl) |
|
|
|
metanode=dom.getElementsByTagName('bib') |
|
metadict['bib_type']='Book' |
|
if len(metanode)==0: |
|
metanode=dom.getElementsByTagName('archimedes') |
|
metadict['bib_type']='Archimedes' |
|
|
|
|
|
if not len(metanode)==0: |
|
metacontent=metanode[0].childNodes |
|
|
|
try: |
|
metadict['bib_type']=getText(dom.getElementsByTagName('bib')[0].attributes['type'].childNodes) |
|
except: |
|
"""nothing""" |
|
|
|
for node in metacontent: |
|
try: |
|
#print urllib.unquote(getText(node.childNodes)),getText(node.childNodes) |
|
metadict[re.sub('-','_',node.tagName.lower())]=urllib.unquote(getText(node.childNodes)) |
|
except: |
|
"""nothing""" |
|
|
|
|
|
return metadict,"" |
|
|