"""New version of the product started February, 8th. Without scientific classification, use content-type for further classification."""
"""Echo collection provides the classes for the ECHO content web-site.
class ECHO_collection is the basis class for an ECHO collection.
class ECHO_resource contains information on ECHO resources (e.g. an Display environment for Metadata
class ECHO_externalLink contains information on externalLinks
"""
import string
import re
import os
import OFS.Image
from types import *
from OFS.Cache import Cacheable
from OFS.Image import Image
from Globals import DTMLFile
from OFS.Folder import Folder
from OFS.SimpleItem import SimpleItem
from AccessControl import ClassSecurityInfo
from AccessControl.User import UserFolder
from Globals import InitializeClass
from Globals import DTMLFile
import Globals
from Products.PageTemplates.PageTemplateFile import PageTemplateFile
from Products.PageTemplates.PageTemplate import PageTemplate
from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
from Globals import Persistent, package_home
from Acquisition import Implicit
from ECHO_helpers import displayTypes
import urllib
import time
from Ft.Xml.Domlette import NonvalidatingReader
from Ft.Xml.Domlette import PrettyPrint
from Ft.Xml import EMPTY_NAMESPACE
import Ft.Xml.XPath
import cStringIO
try:
from psycopg import libpq
except:
try:
from pyPgSQL import libpq
except:
print "ECHO_collection: Warning - No libpq imported!"
import xml.dom.minidom
import urllib
import xml.dom.minidom
from ECHO_graphicalOverview import javaHandler,javaScriptMain
import ECHO_helpers
def donatus(txt2):
import xmlrpclib
server = xmlrpclib.ServerProxy("http://archimedes.fas.harvard.edu/cgi-bin/donatus-rpc")
txt=txt2.encode('utf-8')
bin=xmlrpclib.Binary(txt)
ret=server.donatus.analyze(bin)
return ret['morphData'].data
def donatusVariant2Lemma(morphData):
"""creates hash variant -> morphdata"""
ret={}
dom=xml.dom.minidom.parseString(morphData)
lemmas=dom.getElementsByTagName('lemma')
for lemma in lemmas:
variants=lemma.getElementsByTagName('variant')
for variant in variants:
atr=variant.getAttribute('form')
if ret.has_key(atr):
ret[atr].append=lemma.getAttribute('form')
else:
ret[atr]=[lemma.getAttribute('form')]
return ret
#regexp for extracting elements from xml
patternTXT=r"<\s*txt.*?>(.*?)"
regexpTXT = re.compile(patternTXT, re.IGNORECASE + re.DOTALL)
patternPage=r"<\s*page.*?>(.*?)"
regexpPage = re.compile(patternPage, re.IGNORECASE + re.DOTALL)
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')+" "
except:
ret+="Error:"+entry[0]+" "
return "
"+ret+"Rerenderd all links to resources in: "+self.title+""
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())+" "
ret+=x
#print x
if RESPONSE is not None:
#RESPONSE.redirect('./manage_main')
return ""+ret+""
return ret
def getRDFDescription(self,linkURL,urn=None,nameDef=None,typeName=None):
"""rdf"""
ret=""
about=""""""
name="""%s"""
link="""%s"""
clickable="""%s"""
#link=""""""
type="""%s"""
#xlink=""""""
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"
ret=about2+"\n"+name2+"\n"+type2+"\n"+clickable2+"\n"
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 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()
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 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):
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="""
"""
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+" "+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+" "+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,""
def setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordstrs,viewClassification=""):
"""Allegemeine Informationen zu einer ECHO Collection"""
self.viewClassification=viewClassification
self.label = label
self.title=title
self.description=description
self.contentType=contentType
self.responsible=responsible
self.credits=toList(credits)
self.weight=weight
coords=[]
#coordinates of for rectangles
if coordstrs:
for coordstr in coordstrs:
try:
temco=coordstr.split(",")
except:
temco=[]
coords.append(temco)
self.coords=coords[0:]
class ECHO_copyright(Folder):
"""Copyright informationen"""
meta_type="ECHO_copyright"
def __init__(self,id,title,copyrights):
"""init"""
self.title=title
self.id=id
self.copyrights=copyrights[0:]
def getCopyrights(self):
"""return coyprights"""
return self.copyrights
manage_options = Folder.manage_options+(
{'label':'Main Config','action':'ECHO_copyright_configForm'},
)
def ECHO_copyright_configForm(self):
"""change form"""
pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_copyright').__of__(self)
pt.content_type="text/html"
return pt()
def ECHO_copyright_config(self,title,RESPONSE=None):
"""change"""
self.title=title
self.copyrights=[]
self.copyrights=getCopyrightsFromForm(self,self.REQUEST.form)[0:]
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
def manage_addECHO_copyrightForm(self):
"""Form for adding"""
pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_copyright.zpt').__of__(self)
return pt()
def manage_addECHO_copyright(self, id,title,RESPONSE=None):
"""add the copyright"""
meta_type="ECHO_copyright"
#first generate copyrights as list of tripels (mediaType,partner,copyrightType)
self._setObject(id, ECHO_copyright(id, title,getCopyrightsFromForm(self,self.REQUEST.form)))
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
class ECHO_layoutTemplate(ZopePageTemplate):
"""Create a layout Template for different purposes"""
meta_type="ECHO_layoutTemplate"
def __init__(self, id, text=None, content_type=None,EchoType=None):
self.id = str(id)
self.ZBindings_edit(self._default_bindings)
if text is None:
self._default_content_fn = os.path.join(package_home(globals()),
'zpt/ECHO_%s_template_standard.zpt'%EchoType)
text = open(self._default_content_fn).read()
self.pt_edit(text, content_type)
"""change form"""
def manage_addECHO_layoutTemplateForm(self):
"""Form for adding"""
pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_layoutTemplate.zpt').__of__(self)
return pt()
from urllib import quote
def manage_addECHO_layoutTemplate(self, EchoType,title=None,REQUEST=None):
"Add a Page Template with optional file content."
if type(EchoType)==StringType:
EchoTypes=[EchoType]
else:
EchoTypes=EchoType
for singleType in EchoTypes:
id = str(singleType)+"_template"
if REQUEST is None:
self._setObject(id, ECHO_layoutTemplate(id, text,EchoType=singleType))
ob = getattr(self, id)
if title:
ob.pt_setTitle(title)
return ob
else:
file = REQUEST.form.get('file')
headers = getattr(file, 'headers', None)
if headers is None or not file.filename:
zpt = ECHO_layoutTemplate(id,EchoType=singleType)
else:
zpt = ECHO_layoutTemplate(id, file, headers.get('content_type'))
self._setObject(id, zpt)
ob = getattr(self, id)
if title:
ob.pt_setTitle(title)
try:
u = self.DestinationURL()
except AttributeError:
u = REQUEST['URL1']
REQUEST.RESPONSE.redirect(u+'/manage_main')
return ''
class ECHO_fullText(ZopePageTemplate):
"""echo fulltext in xml"""
meta_type="ECHO_fullText"
def donatusVariant2Lemma(self,nr='1'):
"""analyze by donatus"""
return donatusVariant2Lemma(donatus(self.lemmatize(nr)))
def tagLex(self,nr="1"):
"""generate Links"""
global retLex
global toggle
toggle=0
retLex=""
lemmatized=self.lemmatize(nr)[0:]
#print "ho",repr(lemmatized)
variants=donatusVariant2Lemma(donatus(lemmatized))
def createTag(name,attrs):
global toggle
if name=="w":
toggle=1
return ""
else:
tag="<"
tag+=name
for attr in attrs.keys():
tag+=""" %s="%s" """%(attr,attrs[attr])
tag+=">"
return tag
def createData(data):
global toggle
astring="""%s """
if toggle: # tag war ein w
toggle=0
if variants.has_key(data):
return astring%(variants[data][0],data)
else:
return astring%(data,data)
# 3 handler functions
def start_element(name, attrs):
global retLex
retLex+=createTag(name,attrs)
def end_element(name):
global retLex
if not name=="w":
retLex+="%s>"%(name.encode('utf-8'))
def char_data(data):
global retLex
if data:
try:
retLex+=createData(data)
except:
"""no"""
p = xml.parsers.expat.ParserCreate()
p.StartElementHandler = start_element
p.EndElementHandler = end_element
p.CharacterDataHandler = char_data
p.Parse(lemmatized.encode('utf-8'),1)
#print repr(lemmatized.encode('utf-8'))
return retLex
def lemmatize(self,nr='1',lang="de"):
"""lemmatize"""
global ret
ret=""
def createTag(name,attrs):
tag="<"
tag+=name
for attr in attrs.keys():
tag+=""" %s="%s" """%(attr,attrs[attr])
tag+=">"
return tag
def insertW(str):
splitted=str.split()
wordlist=["%s"%split for split in splitted]
return string.join(wordlist,'\n')
# 3 handler functions
def start_element(name, attrs):
global ret
ret+=createTag(name,attrs)
def end_element(name):
global ret
ret+="%s>"%(name.encode('utf-8'))
def char_data(data):
global ret
ret+=insertW(data)
p = xml.parsers.expat.ParserCreate()
p.StartElementHandler = start_element
p.EndElementHandler = end_element
p.CharacterDataHandler = char_data
p.Parse(self.getPage(nr), 1)
txt="""%s"""
ret=txt%(lang,ret)
return ret
def getPage(self,nr='1'):
"""get page n"""
dom=xml.dom.minidom.parseString(self())
pages=dom.getElementsByTagName('page')
return pages[int(nr)-1].toxml('utf-8')
# Product registration and Add support
manage_addECHO_fullTextForm = PageTemplateFile(
'zpt/AddECHO_fullText.zpt', globals())
from urllib import quote
def manage_addECHO_fullText(self, id, title=None, text=None,
REQUEST=None, submit=None):
"Add a Page Template with optional file content."
id = str(id)
if REQUEST is None:
self._setObject(id, ECHO_fullText(id, text))
ob = getattr(self, id)
if title:
ob.pt_setTitle(title)
return ob
else:
file = REQUEST.form.get('file')
headers = getattr(file, 'headers', None)
if headers is None or not file.filename:
zpt = ECHO_fullText(id)
else:
zpt = ECHO_fullText(id, file, headers.get('content_type'))
self._setObject(id, zpt)
try:
u = self.DestinationURL()
except AttributeError:
u = REQUEST['URL1']
if submit == " Add and Edit ":
u = "%s/%s" % (u, quote(id))
REQUEST.RESPONSE.redirect(u+'/manage_main')
return ''
class ECHO_resource(Folder,Persistent):
"""ECHO Ressource"""
security=ClassSecurityInfo()
meta_type='ECHO_resource'
viewClassificationList=viewClassificationListMaster
getSubCols = ECHO_helpers.getSubCols
security.declareProtected('View','index_html')
def showRDF(self):
"""showrdf"""
self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
ret="""\n\n"""
ret+=self.getRDF(urn="echo:colllectionroot")+"\n"
ret+=""""""
return ret
def getRDF(self,urn=None):
"""rdf"""
ret=getRDFDescription(self,self.link,urn=urn)
return ret+self.createSubElementRDF(urn=urn)
def createSubElementRDF(self,urn=None):
"""rdf list"""
if not urn:
urn=self.absolute_url()
ret=""
rettemp="""\n"""%urn
flag=0
li="""\n"""
if not ('' in self.getFullTextXML(noredirect='Yes')):
nurn=self.absolute_url()+'/getFullTextXML'
rettemp+=li%nurn
flag=1
if not ('' in self.getImageView(noredirect='Yes')):
nurn=self.absolute_url()+'/getImageView'
rettemp+=li%nurn
flag=1
if not ('' in self.showMetaDataXML()):
nurn=self.absolute_url()+'/showMetaDataXML'
rettemp+=li%nurn
flag=1
rettemp+=""
if flag==1:
ret+=rettemp
if not ('' 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 ('' 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 ('' 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 getAccessRightSelectorHTML(self,outlook="select"):
"""htmlselector"""
values=['free','mpiwg']
if outlook=="select":
ret=""""
else:
ret=""
for value in values:
if value==self.getAccessRightMD():
ret+="""%s"""%(self.getId(),value,value)
else:
ret+="""%s"""%(self.getId(),value,value)
return ret
def getAccessRightMD(self):
"""set accessright"""
url=self.metalink
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)
root=dom.getElementsByTagName('resource')[0]
except:
return (None,"Cannot parse: "+url+" "+geturl)
internal=dom.getElementsByTagName('internal')
if internal:
institution=dom.getElementsByTagName('institution')
return getText(institution[0].childNodes)
free=dom.getElementsByTagName('free')
if free:
return "free"
return "free" #default free
def changeAccessRightMD(self,accessright,RESPONSE=None):
"""change the rights"""
params="accessright=%s"%accessright
#print ECHO_helpers.urlopen(self.absolute_url()+'/setAccessRightXML'+'?'+params).read()
ECHO_helpers.urlopen('http://xserve02.mpiwg-berlin.mpg.de:18880/echo_nav/storage/downloadExternalXML?index_meta_url=%s&xml_url=%s'%(self.metalink,self.absolute_url()+'/setAccessRightXML'+urllib.quote('?'+params))).read()
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
def setAccessRightXML(self,accessright):
"""set accessright"""
url=self.metalink
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)
root=dom.getElementsByTagName('resource')[0]
except:
return (None,"Cannot parse: "+url+" "+geturl)
metanodes=dom.getElementsByTagName('access-conditions')
if not metanodes:
nodenew=dom.createElement('access-conditions')
root.appendChild(nodenew)
metanode=nodenew
else:
metanode=metanodes[0]
accesses=metanode.getElementsByTagName('access')
if not accesses:
nodenew2=dom.createElement('access')
metanode.appendChild(nodenew2)
metanode2=nodenew2
else:
metanode2=accesses[0]
internal=metanode.getElementsByTagName('internal')
if internal:
metanode2.removeChild(internal[0]).unlink()
free=metanode.getElementsByTagName('free')
if free:
metanode2.removeChild(internal[0]).unlink()
if accessright=='free':
nodenew3=dom.createElement('free')
metanode2.appendChild(nodenew3)
elif accessright=='mpiwg':
nodenew3=dom.createElement('internal')
nodenew4=dom.createElement('institution')
metanodetext=dom.createTextNode('mpiwg')
nodenew4.appendChild(metanodetext)
nodenew3.appendChild(nodenew4)
metanode2.appendChild(nodenew3)
return dom.toxml().encode('utf-8')
def setStartPageForm(self):
"""Form for changing the startpage"""
pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resourceStartPage.zpt').__of__(self)
pt.content_type="text/html"
return pt()
def setStartPage(self,startpage=None,RESPONSE=None):
"""set start page, if no startpage defined use the generic one of the resource"""
if (not (type(startpage)==StringType)) and ("__generic" in startpage): # checke ob generic in der liste
startpage=self.absolute_url()+"/startpage_html"
if (not startpage) or (startpage=="__generic"):
startpage=self.absolute_url()+"/startpage_html"
params="startpage=%s"%startpage
ECHO_helpers.urlopen('http://xserve02.mpiwg-berlin.mpg.de:18880/echo_nav/storage/downloadExternalXML?index_meta_url=%s&xml_url=%s'%(self.metalink,self.absolute_url()+'/newMetaXML'+urllib.quote('?'+params))).read()
path=self.metalink
path=re.sub(self.REQUEST['SERVER_URL'],'',path)
path=re.sub('http://'+self.REQUEST['HTTP_HOST'],'',path)
path=re.sub('http://foxridge.mpiwg-berlin.mpg.de:8080','',path) # falls foxridge als server
path=re.sub('http://foxridge.mpiwg-berlin.mpg.de','',path) # falls foxridge als server
path=re.sub('http://foxridge.rz-berlin.mpg.de:8080','',path) # falls foxridge als server
path=re.sub('http://content.mpiwg-berlin.mpg.de','',path) # falls content als server
path=re.sub('http://foxridge.rz-berlin.mpg.de','',path) # falls foxridge als server
path=re.sub('http://vision.rz-berlin.mpg.de','',path) # falls vision als server
path=re.sub('http://echo.mpiwg-berlin.mpg.de','',path) # falls echo
path=re.sub('/index.meta','',path)
ECHO_helpers.urlopen("http://nausikaa2.rz-berlin.mpg.de:86/cgi-bin/toc/admin/reg.cgi?path=%s"%path).readlines()
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
def changeViewerTemplateSetForm(self):
"""change the viewer template set"""
pt=PageTemplateFile('Products/ECHO_content/zpt/changeResourceViewerTemplateSet').__of__(self)
return pt()
def getTextToolsField(self,name,default=''):
"""Lese Textoolsfelder aus index.meta im path aus"""
try:
dom=xml.dom.minidom.parse(self.metalink)
node=dom.getElementsByTagName('texttool')[0] #getNode
subnode=node.getElementsByTagName(name)[0]
# bei text wird nur der Folder gebraucht
if name=="text":
splitted=getText(subnode.childNodes).split("/")
return splitted[len(splitted)-2]
else:
return getText(subnode.childNodes)
except:
return default
def changeViewerTemplateSet(self,project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix,RESPONSE=None):
"""changeit"""
paramList=['project','startpage','xslt','thumbtemplate','topbar','digiLibTemplate','digiliburlprefix']
#writeMetadata(self.metalink,self.metaDataHash,project,None,xslt,thumbtemplate,topbar,digiLibTemplate)
params="project=%s&xslt=%s&thumbtemplate=%s&topbar=%s&digiLibTemplate=%s&digiliburlprefix=%s"%(project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix)
ECHO_helpers.urlopen('http://echo.mpiwg-berlin.mpg.de/echo_nav/storage/downloadExternalXML?index_meta_url=%s&xml_url=%s'%(self.metalink,self.absolute_url()+'/newMetaXML'+urllib.quote('?'+params))).read()
#print self.absolute_url()+'/newMetaXML'+urllib.quote'?'+params)
# hack Pfad auf die Dokumente
path=self.metalink
path=re.sub('/index.meta','',path)
path=re.sub(self.REQUEST['SERVER_URL'],'',path)
path=re.sub('http://'+self.REQUEST['HTTP_HOST'],'',path)
path=re.sub('http://foxridge.mpiwg-berlin.mpg.de:8080','',path) # falls foxridge als server
path=re.sub('http://foxridge.mpiwg-berlin.mpg.de:8080','',path) # falls foxridge als server
path=re.sub('http://foxridge.mpiwg-berlin.mpg.de','',path) # falls foxridge als server
path=re.sub('http://foxridge.rz-berlin.mpg.de:8080','',path) # falls foxridge als server
path=re.sub('http://foxridge.rz-berlin.mpg.de','',path) # falls foxridge als server
path=re.sub('http://content.mpiwg-berlin.mpg.de','',path) # falls content als server
path=re.sub('http://echo.mpiwg-berlin.mpg.de','',path) # falls echo
path=re.sub('http://vision.rz-berlin.mpg.de','',path) # falls vision als server
return ECHO_helpers.urlopen("http://nausikaa2.rz-berlin.mpg.de:86/cgi-bin/toc/admin/reg.cgi?path=%s"%path).readlines()
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
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 content_html(self):
"""template fuer content"""
return content_html(self,'resource')
def getViewClassification(self):
if hasattr(self,'viewClassification'):
return self.viewClassification
else:
return ""
def getFullTextXML(self,noredirect=None):
"""getFullTextXML; gives the FullText as an XML Document, and if somthing goes wrong."""
try:
fh=ECHO_helpers.urlopen(self.metalink)
dom=xml.dom.minidom.parse(fh)
texttools=dom.getElementsByTagName('texttool')
text=texttools[0].getElementsByTagName('text')
texturl=getText(text[0].childNodes)
if not (texturl.split(":")[0] in ['http','ftp','file']):
texturl=re.sub("//","/",texturl)
#return texturl+"::"+texturl.split(":")[0]
if not noredirect:
self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
self.REQUEST.RESPONSE.redirect(texturl)
else:
return texturl
except:
if not noredirect:
self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
self.REQUEST.RESPONSE.write("no fulltext available")
else:
return "no fulltext available"
def getImageView(self,noredirect=None):
"""getImages; give Imageviewr and if somthing goes wrong."""
try:
fh=ECHO_helpers.urlopen(self.metalink)
dom=xml.dom.minidom.parse(fh)
texttools=dom.getElementsByTagName('texttool')
text=texttools[0].getElementsByTagName('image')
imagetemp=getText(text[0].childNodes)
text=dom.getElementsByTagName('archive-path')
archivepath=getText(text[0].childNodes)
archivepath=re.sub('/mpiwg/online/','',archivepath)
imageurl="http://echo.mpiwg-berlin.mpg.de/zogilib?fn="+archivepath+"/"+imagetemp
if not noredirect:
self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
self.REQUEST.RESPONSE.redirect(imageurl)
else:
return imageurl
except:
if not noredirect:
self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
self.REQUEST.RESPONSE.write("no fulltext available")
else:
return "no images available"
def getCopyrightsHTML(self):
"""gib (link auf copyright link, mediatyp, institution, copyrightType, label von copyrightType) aus"""
if hasattr(self,'copyrightModel'):
obj=self.copyrightModel
else:
return "ERROR"
ret=[]
for copyright in obj.getCopyrights(): #copyright - media / partner / copyrightID
try:
if hasattr(self.copyrightTypes,copyright[2]):
copyrightTypeObj=getattr(self.copyrightTypes,copyright[2])
link="copyrightTypes/"+copyright[2]+'/copyright.html'
else:
copyrightTypeObj=getattr(obj,copyright[2])
link="copyrightModel/"+copyright[2]+'/copyright.html'
label=copyrightTypeObj.label
url=getattr(copyrightTypeObj, 'url', '')
if url!='':
ret.append((url,copyright[0],copyright[1],copyright[2],label))
else:
if hasattr(copyrightTypeObj, 'copyright.html'):
ret.append(("""%s?partner=%s"""%(link,copyright[1]),copyright[0],copyright[1],copyright[2],label))
else:
ret.append(('empty',copyright[0],copyright[1],copyright[2],label))
except:
"""nothing"""
return ret
def getInstitutionsHTML(self):
"""gibt Liste der frdernden Institutionen aus"""
if hasattr(self,'support'):
obj=self.support
ret=obj.getSupporter()
return ret
else:
return ''
def getCredits(self):
"""Ausgabe der credits"""
if self.credits:
return self.credits
else:
return []
def __init__(self,id,link,metalink,resourceID,title,label,description,contentType,renderingType,copyrightType,responsible,credits,weight,coords):
self.id = id
"""Festlegen der ID"""
self.label = label
self.link= link
self.metalink=metalink
self.title=title
self.weight=weight
self.credits=toList(credits)
self.description=description
self.contentType=contentType
self.copyrightType=copyrightType
self.renderingType=renderingType
self.responsible=responsible
self.resourceID=resourceID
if coords:
coordsnew=[ string.split(x,",") for x in coords]
else:
coordsnew=[]
self.coords=coordsnew
def getCoords(self):
"""gibt coordinaten als String zurück und löscht zugleich einträge die keine Koordinaten sind, letzteres zur korrektur der Eingabe der alten version"""
retList=[]
if hasattr(self,'coords'):
for x in self.coords:
if len(x)>1:
retList.append(string.join(x,","))
return retList
def getContentType(self):
try:
return self.contentType
except:
return ""
def getCopyrightType(self):
try:
return self.copyrightType
except:
return ""
def getRenderingType(self):
try:
return self.renderingType
except:
return ""
def ECHO_resource_config(self):
"""Main configuration"""
if not hasattr(self,'weight'):
self.weight=""
pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource.zpt').__of__(self)
return pt()
def ECHO_resource_config_main(self):
"""Main configuration"""
if not hasattr(self,'weight'):
self.weight=""
pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_main.zpt').__of__(self)
return pt()
def ECHO_resource_config_coords(self):
"""Coords configuration """
pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_coords.zpt').__of__(self)
return pt()
def ECHO_resource_config_credits(self):
"""Main configuration"""
pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_credits.zpt').__of__(self)
return pt()
def ECHO_resource_config_metadata(self):
"""Main configuration"""
if (hasattr(self,'metadata')) and not (hasattr(self,'metaDataHash')):
self.metaDataHash={}
self.contentType=self.bib_type
for data in self.metadata:
data_neu=re.sub('-','_',data)
self.meta
DataHash[data_neu]=getattr(self,data)[0:]
pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_metadata.zpt').__of__(self)
return pt()
def changeECHO_resource_main(self,metalink,link,title,label,description,contentType,renderingType,weight,resourceID,RESPONSE=None):
"""Änderung der Properties"""
self.resourceID=resourceID
self.title=title
self.label=label
self.description=description
self.contentType=contentType
self.renderingType=renderingType
self.weight=weight
self.link=link
self.metalink=metalink
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
def changeECHO_resource_coords(self,coords,viewClassification,RESPONSE=None):
"""Änderung der Properties - coords"""
if type(coords)==StringType:
coords=[coords]
try:
coordsnew=[ string.split(x,",") for x in coords]
except:
coordsnew=[]
self.coords=coordsnew[0:]
self.viewClassification=viewClassification
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
def changeECHO_resource_credits(self,credits,responsible,copyrightType,RESPONSE=None):
"""Änderung der Properties"""
self.credits=credits
self.responsible=responsible
self.copyrightType=copyrightType
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
def changeECHO_resource_metadata_local(self,RESPONSE=None):
"""change metadata"""
tags=self.findTagsFromMapping(self.contentType)
for field in tags[1]:
self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)][0:]
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
def changeECHO_resource_metadata(self,RESPONSE=None):
"""change metadata"""
tags=self.findTagsFromMapping(self.contentType)
self.OSAS_meta={}
for field in tags[1]:
try:
self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)]
self.OSAS_meta[self.getFieldTag(tags,field)]=self.REQUEST.form['OSAS_%s'%self.getFieldTag(tags,field)]
except:
"""nothing"""
ECHO_helpers.urlopen('http://xserve02.mpiwg-berlin.mpg.de:18880/echo_nav/storage/downloadExternalXML?index_meta_url=%s&xml_url=%s'%(self.metalink,self.absolute_url()+'/newMetaXML')).read()
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
def getMDValue(self,fieldName):
return self.metaDataHash.get(fieldName,'!!NOT USED HERE in Type: %s'%self.contentType)
def newMetaXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None,digiliburlprefix=None):
"""new index.meta"""
self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
if not hasattr(self,'metaDataHash'):
self.copyIndex_meta2echo_resource()
try:
return writeMetadata(self.metalink,self.OSAS_meta,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix=digiliburlprefix)
except:
return writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix=digiliburlprefix)
def showMetaDataXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None):
"""schreibe md"""
try:
return writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,xmlfrag="yes")
except:
return " no metadata stored"
def getMetaDataXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None):
"""prints out metadata as stored in the echo environment, format is the index.meta format"""
self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
return writeMetadata(self.metalink,self.metaDataHash)
def changeECHO_resource(self,metalink,link,title,label,description,contentType,responsible,weight,viewClassification="",coords=None,credits=None,RESPONSE=None):
"""Änderung der Properties"""
try:
coordsnew=[ string.split(x,",") for x in coords]
except:
coordsnew=[]
setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)
self.viewClassification=viewClassification
self.coords=coordsnew[0:]
self.link=link
self.metalink=metalink
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
manage_options = Folder.manage_options+(
{'label':'Main Config','action':'ECHO_resource_config_main'},
{'label':'Change Metadata','action':'ECHO_resource_config_metadata'},
{'label':'Change Coords','action':'ECHO_resource_config_coords'},
{'label':'Add coords','action':'ECHO_graphicEntry'},
{'label':'Sync Metadata','action':'ECHO_getResourceMD'},
{'label':'Change TemplateSets and Image Viewer','action':'changeViewerTemplateSetForm'},
{'label':'set/change startpage','action':'setStartPageForm'},
{'label':'Copy MD for indexing and search','action':'copySearchFields'},
)
def getOverview(self):
"""overview graphics"""
return self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])[0][1]
def ECHO_graphicEntry(self):
"""DO nothing"""
overview = self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])
if overview:
pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_draw.zpt').__of__(self)
return pt()
else:
return "NO OVERVIEW GRAPHICS"
def ECHO_enterCoords(self,coordstr,angle="",RESPONSE=None):
"""Enter coords"""
coords=self.coords
temco=coordstr.split(",")
temco.append(angle)
coords.append(temco)
self.coords=coords[0:]
if RESPONSE is not None:
RESPONSE.redirect('ECHO_graphicEntry')
def isDefinedInThisSet(self,fields,field):
"""checks if field is defined in fields"""
if (fields[0].has_key(field)) and not (fields[0][field]==""):
return 1
else:
return 0
def getFieldLabel(self,fields,field):
"""get labels"""
try:
ret =fields[0][field]
if ret == "":
return field
else:
return ret
except:
return field
def getFieldTag(self,fields,field):
"""get labels"""
try:
ret =fields[0][field]
if ret == "":
return field
else:
return ret
except:
return field
def getFieldValue(self,field):
"""get value"""
try:
ret=self.metaDataHash[field]
if ret == "":
return None
else:
return ret
except:
return None
def getMetaDataHash(self):
"""md hash"""
return self.metaDataHash
def setFieldValue(self,field,value):
"""get value"""
if not hasattr(self,'metaDataHash'):
setattr(self,'metaDataHash',{})
self.metaDataHash[field]=value[0:]
def copySearchFields(self):
"""copys metadatafields to the object"""
fields=['author','title','year']
for field in fields:
setattr(self,'MD_'+field,self.getFieldValue(field))
def findLabelsFromMapping(self,referenceType):
"""gib hash mit label -> generic zurueck"""
#return {},[]
temp=self.ZopeFind(self.standardMD)
if referenceType=="":
referenceType="book"
bibdata={}
retdata={}
fields=[]
fieldlist=self.standardMD.fieldList
for referenceTypeF in self.referencetypes:
if referenceTypeF[1].title.lower() == referenceType.lower():
try:
bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
referenceType=referenceTypeF[1].title
except:
bibdata[referenceType]=referenceTypeF[1].fields
bibdata['data']=referenceTypeF[1]
fields=bibdata[referenceType]
for field in fieldlist:
retdata[field]=referenceTypeF[1].getValue(field)[1]
return retdata,fieldlist,temp,fields
def findTagsFromMapping(self,referenceType):
"""gib hash mit label -> generic zurueck"""
if referenceType=="":
referenceType="book"
temp = self.ZopeFind(self.standardMD)[0:]
#self.referencetypes=temp[0:]
bibdata={}
retdata={}
fieldlist=self.standardMD.fieldList
fields=[]
for referenceTypeF in temp:
#print referenceType
if referenceTypeF[1].title.lower() == referenceType.lower():
try:
bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
referenceType=referenceTypeF[1].title
except:
bibdata[referenceType]=referenceTypeF[1].fields
bibdata['data']=referenceTypeF[1]
fields=bibdata[referenceType]
for field in fieldlist:
retdata[field]=referenceTypeF[1].getValue(field)[0]
return retdata,fieldlist,temp,fields
security.declarePublic('copyIndex_meta2echo_resource') # has to be change, presentlyset because of OSAS koordination
def copyIndex_meta2echo_resource(self,RESPONSE=None):
"""copy MD von Index_meta to the echo_resource"""
(metadict, error)=readMetadata(self.metalink)
self.metaDataHash={}
if not error=="": #Fehler beim Auslesen des Metafiles
return "ERROR:",error,self.absolute_url()
self.contentType=metadict['bib_type'][0:]
fields=self.findTagsFromMapping(self.contentType)
#fields=self.findLabelsFromMapping(self.contentType)
for field in fields[1]:
if self.isDefinedInThisSet(fields,field):
#print urllib.unquote(metadict.get(self.getFieldTag(fields,field),''))
self.setFieldValue(self.getFieldTag(fields,field),metadict.get(self.getFieldTag(fields,field),''))
if RESPONSE:
return RESPONSE.redirect('manage_main')
def ECHO_getResourceMD(self,template="yes",back=None):
"""Einlesen der Metadaten und Anlegen dieser Metadaten als Informationen zur Resource"""
(metadict, error)=readMetadata(self.metalink)
if back:
self.REQUEST.SESSION['back']=back
if not error=="": #Fehler beim Auslesen des Metafiles
return "ERROR:",error
if not (metadict['bib_type'].lower()==self.contentType.lower()):
self.REQUEST.SESSION['contentStorage']=metadict['bib_type']
self.REQUEST.SESSION['contentZope']=self.contentType
return PageTemplateFile('Products/ECHO_content/zpt/ECHO_getResourceMDErrorContentType.zpt').__of__(self)()
self.REQUEST.SESSION['metadict']=metadict
self.REQUEST.SESSION['diffs']=checkDiffs(self,self.REQUEST.SESSION['metadict'])
if template=="yes":
pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_resourceMD.zpt').__of__(self)
return pt()
def ECHO_getMD(self,item):
"""Ausgabe der MD"""
return getattr(self,item)
def index_html(self):
"""standard page"""
return self.REQUEST.RESPONSE.redirect(self.link)
def startpage_html(self):
"""prints out a startpage for a resource for use e.g. in the BVE"""
# suche ob startpage.html in dem Ordner vorhanden ist, dann wir diese angezeigt
sp=self.ZopeFind(self,obj_ids=['startpage.html'])
if sp:
return sp[1]()
#prüfen ob irgendwo ein template
if hasattr(self,'startpage_index_template'):
return self.startpage_index_template()
#generisches template ausgeben
pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_startpage_index_template_standard.zpt').__of__(self)
pt.content_type="text/html"
return pt()
def toc_html(self):
sp=self.ZopeFind(self,obj_ids=['toc.html'])
if sp:
return sp[0][1]()
security.declarePublic('generate_label') # has to be change, presentlyset because of OSAS koordination
def generate_label(self):
"""Erzeugt_standard_Label aus Template"""
pt=getattr(self,"label_template_"+self.contentType.lower())
self.label=pt()[0:]
return pt()
security.declarePublic('generate_title') # has to be change, presentlyset because of OSAS koordination
def generate_title(self,RESPONSE=None):
"""Erzeugt_standard_Label aus Template"""
pt=getattr(self,"label_template_"+self.contentType.lower())
self.title=pt()[0:]
return pt()
Globals.InitializeClass(ECHO_resource)
def manage_addECHO_resourceForm(self):
"""Form for adding a ressource"""
pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_resourceForm.zpt').__of__(self)
return pt()
def manage_addECHO_resource(self,id,title,label,description,responsible,link,metalink,weight,copyrightType=None,resourceID=None,contentType=None,renderingType=None,credits=None,coords=None,RESPONSE=None):
"""addaresource"""
newObj=ECHO_resource(id,link,metalink,resourceID,title,label,description,contentType,renderingType,copyrightType,responsible,credits,weight,coords)
self._setObject(id,newObj)
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
class ECHO_externalLink(Folder):
"""Link zu einer externen Ressource"""
security=ClassSecurityInfo()
meta_type='ECHO_externalLink'
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 content_html(self):
"""template fuer content"""
return content_html(self,'externalLink')
def __init__(self,id,link,title,label,description,contentType,responsible,credits,weight,coords):
self.id = id
"""Festlegen der ID"""
self.credits=toList(credits)
self.label = label
self.link= link
self.title=title
self.weight=weight
self.description=description
self.contentType=contentType
self.responsible=responsible
coordsnew=[ string.split(x,",") for x in coords]
self.coords=coordsnew
def ECHO_externalLink_config(self):
"""Main configuration"""
if not hasattr(self,'weight'):
self.weight=""
if not hasattr(self,'coords'):
self.coords=['']
pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_externalLink.zpt').__of__(self)
return pt()
def changeECHO_externalLink(self,link,title,label,description,contentType,responsible,weight,coords=None,credits=None,RESPONSE=None):
"""Änderung der Properties"""
try:
coordsnew=[ string.split(x,",") for x in coords]
except:
coordsnew=[]
setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coords)
self.coords=coordsnew[0:]
self.link=link
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
manage_options = Folder.manage_options+(
{'label':'Main Config','action':'ECHO_externalLink_config'},
)
def index_html(self):
"""standard page"""
return self.REQUEST.RESPONSE.redirect(self.link)
def manage_addECHO_externalLinkForm(self):
"""Form for external Links"""
pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_externalLinkForm.zpt').__of__(self)
return pt()
def manage_addECHO_externalLink(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None):
"""Add an external Link"""
newObj=ECHO_externalLink(id,link,title,label,description,contentType,responsible,credits,weight,coords)
self._setObject(id,newObj)
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
class ECHO_link(ECHO_externalLink):
"""external_link"""
meta_type="ECHO_link"
def content_html(self):
"""template fuer link"""
if hasattr(self,"link_template"):
return content_html(self,'link')
else:
return content_html(self,'collection')
def manage_addECHO_linkForm(self):
"""Form for external Links"""
pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_linkForm.zpt').__of__(self)
return pt()
def manage_addECHO_link(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None):
"""Add an external Link"""
newObj=ECHO_link(id,link,title,label,description,contentType,responsible,credits,weight,coords)
self._setObject(id,newObj)
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
class ECHO_collection(Folder, Persistent, Implicit, Cacheable):
"""ECHO Collection"""
security=ClassSecurityInfo()
meta_type='ECHO_collection'
viewClassificationList=viewClassificationListMaster
displayTypes=displayTypes
path="/mpiwg/online/permanent/shipbuilding"
def getRDF(self,urn=None):
"""rdf of the collection"""
contents=self.ZopeFind(self,obj_metatypes=['ECHO_group','ECHO_resource','ECHO_collection'])
ret=getRDFDescription(self,self.absolute_url(),urn=urn)
if not urn:
urn=self.absolute_url()
li="""\n"""
for content in contents:
ret+=content[1].getRDF()+"\n"
ret+="""\n"""%urn
for content in contents:
nurn=content[1].absolute_url()
ret+=li%nurn
return ret+""
def showRDF(self):
"""showrdf"""
self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
ret="""\n\n"""
ret+=self.getRDF(urn="echo:collectionroot")+"\n"
ret+=""""""
return ret
def changeLabels(self):
"""change form"""
pt=PageTemplateFile('Products/ECHO_content/zpt/changeLabelsForm').__of__(self)
pt.content_type="text/html"
return pt()
def changeTitles(self):
"""change form"""
pt=PageTemplateFile('Products/ECHO_content/zpt/changeTitleForm').__of__(self)
pt.content_type="text/html"
return pt()
def changeWeights(self):
"""change form"""
pt=PageTemplateFile('Products/ECHO_content/zpt/changeWeightForm').__of__(self)
pt.content_type="text/html"
return pt()
def changeMetaDataLinks(self):
"""change form"""
pt=PageTemplateFile('Products/ECHO_content/zpt/changeMetaDataLinkForm').__of__(self)
pt.content_type="text/html"
return pt()
def changeAccessRightsCollection(self):
"""change"""
ret=""
argv=self.REQUEST.form
resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])
for resource in resources:
try:
ret+=resource[1].getId()+" "+argv[resource[1].getId()]+""
resource[1].changeAccessRightMD(argv[resource[1].getId()])
except:
"""not"""
return ret
def changeMetaDataLinkInCollection(self):
"""change all lables of a collection"""
ret=""
argv=self.REQUEST.form
resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])
for resource in resources:
try:
ret+=resource[1].getId()+" "+argv[resource[1].getId()]+""
resource[1].metalink=argv[resource[1].getId()][0:]
except:
"""not"""
return ret
def changeMetaDataLinkInCollection(self):
"""change all lables of a collection"""
ret=""
argv=self.REQUEST.form
resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])
for resource in resources:
try:
ret+=resource[1].getId()+" "+argv[resource[1].getId()]+""
resource[1].metalink=argv[resource[1].getId()][0:]
except:
"""not"""
return ret
def changeWeightsInCollection(self):
"""change all lables of a collection"""
ret=""
argv=self.REQUEST.form
resources=self.ZopeFind(self,obj_metatypes=['ECHO_pageTemplate','ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])
for resource in resources:
try:
ret+=resource[1].getId()+" "+argv[resource[1].getId()]+""
resource[1].weight=argv[resource[1].getId()][0:]
except:
"""not"""
return ret
def changeTitlesInCollection(self):
"""change all lables of a collection"""
ret=""
argv=self.REQUEST.form
resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])
for resource in resources:
try:
ret+=resource[1].getId()+" "+argv[resource[1].getId()]+""
resource[1].title=argv[resource[1].getId()][0:]
except:
"""not"""
return ret
def updateCollection(self,RESPONSE=None):
"""liest verzeichnisse aus dem pfad und legt sie dann als objekte in den ordner"""
files=os.listdir(self.path)
ret=""
for fileName in files:
if fileName:
tempPath=re.sub("/mpiwg/online","",self.path)
link="http://echo.mpiwg-berlin.mpg.de/zogilib_book?fn="+tempPath+"/"+fileName+"/pageimg"
metalink=self.path+"/"+fileName+"/index.meta"
try:
#link="http://nausikaa2.mpiwg-berlin.mpg.de/cgi-bin/toc/toc.x.cgi?dir="+fileName+"&step=thumb"
newObj=ECHO_resource(fileName,link,metalink,fileName,fileName,fileName,'generated','book','','','','','','')
self._setObject(fileName,newObj)
genObj=getattr(self,fileName)
#genObj.createIndexFile()
ret+="OK:"+fileName+" "
except:
print "ERROR"
ret+="ERROR:"+fileName+" "
return ret
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
def updateCollectionMD(self,RESPONSE=None):
"""updateMD"""
files=os.listdir(self.path)
for fileName in files:
if fileName:
genObj=getattr(self,fileName)
genObj.copyIndex_meta2echo_resource()
genObj.generate_title()
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
def changeViewerTemplateSetsForm(self):
"""change the viewer template set"""
pt=PageTemplateFile('Products/ECHO_content/zpt/changeViewerTemplateSet').__of__(self)
return pt()
def getViewerTemplateSets(self,obj_ids=None,RESPONSE=None):
"""Get the ViewerTemplateSet title for configuration"""
ret=[]
try:
viewerTemplateSets=self.ZopeFind(self.viewerTemplateSets,obj_metatypes=['OSAS_viewerTemplateSet'],obj_ids=obj_ids)#assumes viewerTemplateSets folder somewhere in the hierarchie.
for viewerTemplateSet in viewerTemplateSets:
ret.append((viewerTemplateSet[1].title,viewerTemplateSet[0],viewerTemplateSet[1]))
return ret
except:
return [('no ViewerTemplateSetfolders','')]
def getTextToolsField(self,name,default=''):
"""Lese viewerTemplateSet der Collection not implemented yet!"""
return default
def isSelectedViewerTemplateSet(self,obj,id):
"""is ausgewählt"""
if self.REQUEST['viewerTemplateSet']==id:
return 1
else:
return None
def changeViewerTemplateSets(self,project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix,RESPONSE=None):
"""change the templates"""
resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
for resource in resources:
resource[1].changeViewerTemplateSet(project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix)
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
def setStartpageFolderForm(self):
"""Form for changing the startpage"""
pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resourceStartPageFolder.zpt').__of__(self)
pt.content_type="text/html"
return pt()
def setStartpageFolder(self,startpage=None,RESPONSE=None):
"""change the templates"""
resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
for resource in resources:
resource[1].setStartPage(startpage)
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
def copySearchFields(self,RESPONSE=None):
"""copys import metadatafields to the object"""
resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])
for resource in resources:
resource[1].copySearchFields()
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
def reloadMetaDataFromStorageWarning(self,RESPONSE=None):
"""warning"""
pt=PageTemplateFile('Products/ECHO_content/zpt/reloadMetaDataFromStorageWarning.zpt').__of__(self)
pt.content_type="text/html"
return pt()
def reloadMetaDataFromStorage(self,RESPONSE=None):
"""copy metadata from the storage to ECHO"""
return reloadMetaDataFromStorage(self,RESPONSE=None)
def getPartnerCopyright(self,name,sonst="generic"):
"""gibt generisches copyright eines partners aus, sonst behalte jetzige einsteillung"""
#print "hi",name,sonst
#print getattr(self.partners,name).copyrightType
try:
partner=getattr(self.partners,name)
return partner.copyrightType
except:
print "error"
return sonst
def partnerSelector_HTML(self,selected=None):
"""give type selector"""
if not selected:
retStr="