version 1.233, 2005/08/19 07:53:16
|
version 1.255, 2005/11/25 18:46:40
|
Line 1
|
Line 1
|
|
|
|
|
"""New version of the product started February, 8th. Without scientific classification, use content-type for further classification.""" |
"""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. |
"""Echo collection provides the classes for the ECHO content web-site. |
|
|
Line 39 from Products.PageTemplates.PageTemplate
|
Line 37 from Products.PageTemplates.PageTemplate
|
from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate |
from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate |
from Globals import Persistent, package_home |
from Globals import Persistent, package_home |
from Acquisition import Implicit |
from Acquisition import Implicit |
|
from Products.ZCatalog.CatalogPathAwareness import CatalogAware |
|
|
import urllib |
import urllib |
import cgi |
import cgi |
import smtplib |
import smtplib |
import time |
import time |
from Ft.Xml.Domlette import NonvalidatingReader |
from Ft.Xml.Domlette import NonvalidatingReader |
from Ft.Xml.Domlette import PrettyPrint |
from Ft.Xml.Domlette import PrettyPrint, Print |
from Ft.Xml import EMPTY_NAMESPACE |
from Ft.Xml import EMPTY_NAMESPACE |
|
|
import Ft.Xml.XPath |
import Ft.Xml.XPath |
Line 68 import ECHO_helpers
|
Line 67 import ECHO_helpers
|
from ECHO_helpers import * |
from ECHO_helpers import * |
from ECHO_language import * |
from ECHO_language import * |
from ECHO_movie import * |
from ECHO_movie import * |
|
import vlp_xmlhelpers #TODO: vlp elemente aus echo herausnehmen |
#regexp for extracting elements from xml |
|
patternTXT=r"<\s*txt.*?>(.*?)</txt>" |
|
regexpTXT = re.compile(patternTXT, re.IGNORECASE + re.DOTALL) |
|
patternPage=r"<\s*page.*?>(.*?)</page>" |
|
regexpPage = re.compile(patternPage, re.IGNORECASE + re.DOTALL) |
|
|
|
|
|
|
|
Line 304 def manage_addECHO_fullText(self, id, ti
|
Line 298 def manage_addECHO_fullText(self, id, ti
|
return '' |
return '' |
|
|
|
|
class ECHO_resource(Folder,Persistent,ECHO_basis): |
class ECHO_resource(CatalogAware,Folder,Persistent,ECHO_basis): |
"""ECHO Ressource""" |
"""ECHO Ressource""" |
security=ClassSecurityInfo() |
security=ClassSecurityInfo() |
meta_type='ECHO_resource' |
meta_type='ECHO_resource' |
|
default_catalog='resourceCatalog' |
|
|
# viewClassificationList=viewClassificationListMaster |
# viewClassificationList=viewClassificationListMaster |
|
|
|
def PrincipiaSearchSource(self): |
|
"""Return cataloguable key for ourselves.""" |
|
return str(self) |
|
|
getSubCols = ECHO_helpers.getSubCols |
getSubCols = ECHO_helpers.getSubCols |
|
|
|
def reindex(self): |
|
"""generate fields for indexing and reindex""" |
|
import urlparse |
|
#TODO: korrigieren des metalink pfades konfigurierbar machen |
|
splitted= [x for x in urlparse.urlparse(self.metalink)] |
|
splitted[1]="foxridge.mpiwg-berlin.mpg.de"[0:] |
|
|
|
if splitted[0]=="http": |
|
self.metalink=urlparse.urlunparse(splitted) |
|
|
|
|
|
self.fullTextUrl=self.getFullTextXML(noredirect="yes") |
|
|
|
#TODO: korrigieren relative url to absoluter url volltexten, konfigurierbar? |
|
splitted= [x for x in urlparse.urlparse(self.fullTextUrl)] |
|
if splitted[0]=="": |
|
splitted[0]="http" |
|
splitted[1]="foxridge.mpiwg-berlin.mpg.de"[0:] |
|
|
|
self.fullTextUrl=urlparse.urlunparse(splitted) |
|
|
|
self.imagePath=self.getImagePath() |
|
|
|
self.reindex_object() |
|
|
|
|
security.declareProtected('View','createPDF') |
security.declareProtected('View','createPDF') |
def createPDF(self,RESPONSE=None,local=None,dpi=150): |
def createPDF(self,RESPONSE=None,local=None,dpi=150): |
Line 922 class ECHO_resource(Folder,Persistent,EC
|
Line 946 class ECHO_resource(Folder,Persistent,EC
|
self.contentType=self.bib_type |
self.contentType=self.bib_type |
for data in self.metadata: |
for data in self.metadata: |
data_neu=re.sub('-','_',data) |
data_neu=re.sub('-','_',data) |
self.meta |
self.metaDataHash[data_neu]=getattr(self,data)[0:] |
DataHash[data_neu]=getattr(self,data)[0:] |
|
|
|
|
|
pt=zptFile(self, 'zpt/ChangeECHO_resource_metadata.zpt') |
pt=zptFile(self, 'zpt/ChangeECHO_resource_metadata.zpt') |
Line 1015 class ECHO_resource(Folder,Persistent,EC
|
Line 1038 class ECHO_resource(Folder,Persistent,EC
|
RESPONSE.redirect('manage_main') |
RESPONSE.redirect('manage_main') |
|
|
|
|
def getMDValue(self,fieldName,empty=None): |
|
|
def getMDValueSimpleSearchField(self): |
|
"""returns value for simple search""" |
|
return " ".join([self.getMDValue('title',generic="yes"), |
|
self.getMDValue('author',generic="yes"), |
|
self.getMDValue('year',generic="yes")]) |
|
|
|
def getMDValue(self,fieldNameTest,empty=None,generic=None): |
|
"""get md values""" |
|
#TODO: cache mappinghash |
|
|
|
fieldName=None |
|
if generic: |
|
if self.contentType: |
|
ct=self.contentType.replace(" ","_").lower() |
|
else: |
|
zLOG.LOG("ECHO_collection (getMDValue)", zLOG.INFO, "no_content type for %s"%self.getId()) |
|
ct="" |
|
|
|
#caching |
|
if not hasattr(self,'_v_mapHash'): #noch keine cachevariable |
|
self._v_mapHash={} |
|
|
|
tmp=self._v_mapHash.get(ct,None) |
|
if tmp: #teste ob type schon existiert |
|
fieldName=tmp.get(fieldNameTest,None) |
|
else: |
|
self._v_mapHash[ct]={} |
|
|
|
#noch nicht gecached |
|
if not fieldName and hasattr(self.standardMD,ct): |
|
fieldName=getattr(self.standardMD,ct).generateMappingHash()[fieldNameTest][0] |
|
self._v_mapHash[ct][fieldNameTest]=fieldName |
|
if not fieldName: |
|
fieldName=fieldNameTest |
if not empty: |
if not empty: |
|
#FIXME: warum gibt es manchmal kein metadatahas |
|
try: |
return self.metaDataHash.get(fieldName,'!!NOT USED HERE in Type: %s'%self.contentType) |
return self.metaDataHash.get(fieldName,'!!NOT USED HERE in Type: %s'%self.contentType) |
|
except: |
|
zLOG.LOG("ECHO (line 1069)",zLOG.ERROR,"no md hash for %s"%self.getId()) |
|
return "" |
|
|
else: |
else: |
return self.metaDataHash.get(fieldName,empty) |
|
|
return self.metaDataHash.get(fieldNameTest,empty) |
|
|
|
getFieldValue=getMDValue #depricated |
|
|
def newMetaXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None,digiliburlprefix=None): |
def newMetaXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None,digiliburlprefix=None): |
"""new index.meta""" |
"""new index.meta""" |
Line 1035 class ECHO_resource(Folder,Persistent,EC
|
Line 1100 class ECHO_resource(Folder,Persistent,EC
|
return writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix=digiliburlprefix) |
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): |
def showMetaDataXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None): |
"""schreibe md""" |
"""return bibliographical metadata as stored in the object""" |
|
|
try: |
try: |
|
|
Line 1043 class ECHO_resource(Folder,Persistent,EC
|
Line 1108 class ECHO_resource(Folder,Persistent,EC
|
except: |
except: |
return "<error> no metadata stored</error>" |
return "<error> no metadata stored</error>" |
|
|
|
def getXQueryMetaData(self,xquery): |
|
''' |
|
execute an xquery on the metadata and returns a list of tuples, |
|
each tuple represent the content of the node as text and the whole node as xml-fragment |
|
@param xquery: xquery auf den metadaten |
|
''' |
|
|
|
try: |
|
md=writeMetadata(self.metalink,self.metaDataHash,xmlfrag="yes") |
|
except: |
|
return None |
|
|
|
dom = NonvalidatingReader.parseString(md,"http://www.mpiwg-berlin.mpg.de/") |
|
|
|
results=Ft.Xml.XPath.Evaluate(xquery, contextNode=dom) |
|
|
|
ret=[] |
|
for result in results: |
|
|
|
buf = cStringIO.StringIO() |
|
PrettyPrint(result, stream=buf) |
|
str = buf.getvalue()[0:] |
|
buf.close() |
|
ret.append((getTextFromNode(result),str)) |
|
|
|
return ret |
|
|
def getMetaDataXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None): |
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""" |
"""prints out metadata as stored in the echo environment, format is the index.meta format""" |
self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml') |
self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml') |
Line 1104 class ECHO_resource(Folder,Persistent,EC
|
Line 1196 class ECHO_resource(Folder,Persistent,EC
|
|
|
|
|
|
|
def getFieldValue(self,field): |
|
"""get value""" |
|
|
|
try: |
|
|
|
ret=self.metaDataHash[field] |
|
if ret == "": |
|
return None |
|
else: |
|
|
|
return ret |
|
except: |
|
return None |
|
|
|
def getMetaDataHash(self): |
def getMetaDataHash(self): |
"""md hash""" |
"""md hash""" |
return self.metaDataHash |
return self.metaDataHash |
|
|
def setFieldValue(self,field,value): |
def setFieldValue(self,field,value): |
"""get value""" |
"""get value""" |
|
#TODO: remove setFieldValue |
|
|
if not hasattr(self,'metaDataHash'): |
if not hasattr(self,'metaDataHash'): |
setattr(self,'metaDataHash',{}) |
setattr(self,'metaDataHash',{}) |
Line 1133 class ECHO_resource(Folder,Persistent,EC
|
Line 1212 class ECHO_resource(Folder,Persistent,EC
|
def copySearchFields(self): |
def copySearchFields(self): |
"""copys metadatafields to the object""" |
"""copys metadatafields to the object""" |
fields=['author','title','year'] |
fields=['author','title','year'] |
|
|
for field in fields: |
for field in fields: |
setattr(self,'MD_'+field,self.getFieldValue(field)) |
setattr(self,'MD_'+field,self.getMDValue(field,generic="yes")) |
|
|
|
|
def findLabelsFromMapping(self,referenceType): |
def findLabelsFromMapping(self,referenceType): |
Line 1187 class ECHO_resource(Folder,Persistent,EC
|
Line 1267 class ECHO_resource(Folder,Persistent,EC
|
|
|
|
|
|
|
|
|
|
|
bibdata={} |
bibdata={} |
retdata={} |
retdata={} |
fieldlist=self.standardMD.fieldList |
fieldlist=self.standardMD.fieldList |
Line 1238 class ECHO_resource(Folder,Persistent,EC
|
Line 1316 class ECHO_resource(Folder,Persistent,EC
|
if RESPONSE: |
if RESPONSE: |
return RESPONSE.redirect('manage_main') |
return RESPONSE.redirect('manage_main') |
|
|
def ECHO_getResourceMD(self,template="yes",back=None): |
return "OK:",self.absolute_url(),self.contentType |
|
|
|
def ECHO_getResourceMD(self,template="yes",back=None,overwrite="no"): |
"""Einlesen der Metadaten und Anlegen dieser Metadaten als Informationen zur Resource""" |
"""Einlesen der Metadaten und Anlegen dieser Metadaten als Informationen zur Resource""" |
(metadict, error)=readMetadata(self.metalink) |
(metadict, error)=readMetadata(self.metalink) |
|
|
Line 1248 class ECHO_resource(Folder,Persistent,EC
|
Line 1328 class ECHO_resource(Folder,Persistent,EC
|
if not error=="": #Fehler beim Auslesen des Metafiles |
if not error=="": #Fehler beim Auslesen des Metafiles |
return "ERROR:",error |
return "ERROR:",error |
|
|
if not self.contentType: |
if (not self.contentType) or (overwrite=="yes"): |
self.contentType=metadict['bib_type'].lower() |
self.contentType=metadict['bib_type'].lower() |
|
|
if not (metadict['bib_type'].lower()==self.contentType.lower()): |
if not (metadict['bib_type'].lower()==self.contentType.lower()): |
Line 1375 class ECHO_externalLink(Folder,ECHO_basi
|
Line 1455 class ECHO_externalLink(Folder,ECHO_basi
|
security.declarePublic('content_html') |
security.declarePublic('content_html') |
def content_html(self): |
def content_html(self): |
"""template fuer content""" |
"""template fuer content""" |
return ECHO_basis.content_html(self,'externalLink') |
ret= ECHO_basis.content_html(self,'externalLink') |
|
|
|
|
|
try: |
|
return ret.encode('utf-8') |
|
|
|
except: |
|
try: |
|
return ret.decode('latin-1') |
|
except: |
|
|
|
return ret |
|
|
def __init__(self,id,link,title,label,description,contentType,responsible,credits,weight,coords): |
def __init__(self,id,link,title,label,description,contentType,responsible,credits,weight,coords): |
|
|
Line 1449 class ECHO_link(ECHO_externalLink):
|
Line 1540 class ECHO_link(ECHO_externalLink):
|
|
|
meta_type="ECHO_link" |
meta_type="ECHO_link" |
|
|
|
manage_options = ECHO_externalLink.manage_options+( |
|
{'label':'add links config','action':'ECHO_link_addLinksForm'}, |
|
) |
|
|
|
def ECHO_link_addLinksForm(self): |
|
"""Main configuration""" |
|
|
|
pt=zptFile(self, 'zpt/ChangeECHO_link_addLinks.zpt') |
|
return pt() |
|
|
|
def ECHO_link_addLinks(self,addLinks,RESPONSE): |
|
"""add links""" |
|
self.addLinks=addLinks |
|
if RESPONSE is not None: |
|
RESPONSE.redirect('manage_main') |
|
|
def content_html(self): |
def content_html(self): |
"""template fuer link""" |
"""template fuer link""" |
|
|
|
|
if hasattr(self,"link_template"): |
if hasattr(self,"link_template"): |
return ECHO_basis.content_html(self,'link') |
ret=ECHO_basis.content_html(self,'link') |
|
|
else: |
else: |
return ECHO_basis.content_html(self,'collection') |
ret=ECHO_basis.content_html(self,'collection') |
|
|
|
|
|
#return ret |
|
return ret |
|
# |
|
# |
|
# try: |
|
# return ret.decode('utf-8') |
|
# except: |
|
# try: |
|
# return ret.decode('latin-1') |
|
# except: |
|
# |
|
# return ret |
|
# |
|
|
|
|
def index_html(self): |
def index_html(self): |
"""standard link""" |
"""standard link""" |
Line 1472 class ECHO_link(ECHO_externalLink):
|
Line 1597 class ECHO_link(ECHO_externalLink):
|
else: |
else: |
params={} |
params={} |
|
|
|
if getattr(self,'addLinks','yes')=="yes": |
params['backLink']=self.aq_parent.absolute_url() |
params['backLink']=self.aq_parent.absolute_url() |
params['startLink']=splitted[0]+"?"+urllib.urlencode(params) |
params['startLink']=splitted[0]+"?"+urllib.urlencode(params) |
|
|
Line 1493 def manage_addECHO_link(self,id,title,la
|
Line 1619 def manage_addECHO_link(self,id,title,la
|
|
|
self._setObject(id,newObj) |
self._setObject(id,newObj) |
|
|
|
getattr(self,id).addLinks='no' |
|
|
if RESPONSE is not None: |
if RESPONSE is not None: |
RESPONSE.redirect('manage_main') |
RESPONSE.redirect('manage_main') |
|
|
Line 1507 class ECHO_collection(Folder, Persistent
|
Line 1635 class ECHO_collection(Folder, Persistent
|
|
|
path="/mpiwg/online/permanent/shipbuilding" |
path="/mpiwg/online/permanent/shipbuilding" |
|
|
|
def getTitleAndLabel(self): |
|
"""gibt title und label zurueck""" |
|
return (getattr(self,'title',''),getattr(self,'label','')) |
|
|
def localizeObjects(self): |
def localizeObjects(self): |
"""localize all objects""" |
"""localize all objects""" |
contents=self.ZopeFind(self,obj_metatypes=['ECHO_externalLink','ECHO_link','ECHO_mapText']) |
contents=self.ZopeFind(self,obj_metatypes=['ECHO_externalLink','ECHO_link','ECHO_mapText']) |
Line 1515 class ECHO_collection(Folder, Persistent
|
Line 1647 class ECHO_collection(Folder, Persistent
|
if not find: |
if not find: |
self.manage_addECHO_locale("en",'','') |
self.manage_addECHO_locale("en",'','') |
for content in contents: |
for content in contents: |
|
|
if content[1].meta_type in['ECHO_link','ECHO_externalLink']: |
if content[1].meta_type in['ECHO_link','ECHO_externalLink']: |
|
|
find=content[1].ZopeFind(content[1],obj_metatypes=('ECHO_mapText')) |
find=content[1].ZopeFind(content[1],obj_metatypes=('ECHO_mapText')) |
if find: |
if find: |
root=find[0][1] |
root=find[0][1] |
Line 1699 class ECHO_collection(Folder, Persistent
|
Line 1833 class ECHO_collection(Folder, Persistent
|
pass |
pass |
return ret |
return ret |
|
|
def updateCollection(self,RESPONSE=None): |
def importCollection(self,path=None,RESPONSE=None): |
"""liest verzeichnisse aus dem pfad und legt sie dann als objekte in den ordner""" |
"""liest verzeichnisse aus dem pfad und legt sie dann als objekte in den ordner""" |
files=os.listdir(self.path) |
|
|
if path is None: |
|
pt=zptFile(self, 'zpt/importCollection.zpt') |
|
return pt() |
|
|
|
files=os.listdir(path) |
ret="" |
ret="" |
for fileName in files: |
for fileName in files: |
|
|
if fileName: |
if fileName: |
|
|
tempPath=re.sub("/mpiwg/online","",self.path) |
tempPath=re.sub("/mpiwg/online","",path) |
link="http://echo.mpiwg-berlin.mpg.de/zogilib_book?fn="+tempPath+"/"+fileName+"/pageimg" |
link="http://echo.mpiwg-berlin.mpg.de/zogilib_book?fn="+tempPath+"/"+fileName+"/pageimg" |
|
|
metalink=self.path+"/"+fileName+"/index.meta" |
metalink=self.path+"/"+fileName+"/index.meta" |
Line 1730 class ECHO_collection(Folder, Persistent
|
Line 1869 class ECHO_collection(Folder, Persistent
|
if RESPONSE is not None: |
if RESPONSE is not None: |
RESPONSE.redirect('manage_main') |
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): |
def changeViewerTemplateSetsForm(self): |
"""change the viewer template set""" |
"""change the viewer template set""" |
pt=zptFile(self, 'zpt/changeViewerTemplateSet') |
pt=zptFile(self, 'zpt/changeViewerTemplateSet') |
Line 1834 class ECHO_collection(Folder, Persistent
|
Line 1959 class ECHO_collection(Folder, Persistent
|
RESPONSE.redirect('manage_main') |
RESPONSE.redirect('manage_main') |
|
|
def copySearchFields(self,RESPONSE=None): |
def copySearchFields(self,RESPONSE=None): |
"""copys import metadatafields to the object""" |
"""copys < metadatafields to the object""" |
resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource']) |
resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1) |
|
|
for resource in resources: |
for resource in resources: |
|
|
Line 1853 class ECHO_collection(Folder, Persistent
|
Line 1978 class ECHO_collection(Folder, Persistent
|
def reloadMetaDataFromStorage(self,RESPONSE=None): |
def reloadMetaDataFromStorage(self,RESPONSE=None): |
"""copy metadata from the storage to ECHO""" |
"""copy metadata from the storage to ECHO""" |
|
|
return reloadMetaDataFromStorage(self,RESPONSE=None) |
return reloadMetaDataFromStorage(self,RESPONSE) |
|
|
|
|
def getPartnerCopyright(self,name,sonst="generic"): |
def getPartnerCopyright(self,name,sonst="generic"): |
Line 2064 class ECHO_collection(Folder, Persistent
|
Line 2189 class ECHO_collection(Folder, Persistent
|
{'label':'Set Startpage','action':'setStartpageFolderForm'}, |
{'label':'Set Startpage','action':'setStartpageFolderForm'}, |
{'label':'Change Viewer Templates and Image Viewer','action':'changeViewerTemplateSetsForm'}, |
{'label':'Change Viewer Templates and Image Viewer','action':'changeViewerTemplateSetsForm'}, |
{'label':'Reload Metadata','action':'reloadMetaDataFromStorageWarning'}, |
{'label':'Reload Metadata','action':'reloadMetaDataFromStorageWarning'}, |
{'label':'ImportCollection','action':'updateCollection'}, |
{'label':'ImportCollection','action':'importCollection'}, |
{'label':'Copy MD for indexing and search','action':'copySearchFields'}, |
{'label':'Copy MD for indexing and search','action':'copySearchFields'}, |
) |
) |
|
|
Line 2160 class ECHO_collection(Folder, Persistent
|
Line 2285 class ECHO_collection(Folder, Persistent
|
def content_html(self,**argv): |
def content_html(self,**argv): |
"""template fuer content""" |
"""template fuer content""" |
#print "NN",argv |
#print "NN",argv |
return ECHO_basis.content_html(self,'collection') |
ret = ECHO_basis.content_html(self,'collection') |
|
|
|
try: |
|
return ret.encode('utf-8') |
|
except: |
|
|
|
try: |
|
return ret.decode('latin-1') |
|
except: |
|
|
|
return ret |
|
|
def getCredits(self): |
def getCredits(self): |
"""Ausgabe der credits""" |
"""Ausgabe der credits""" |
Line 2518 class ECHO_root(Folder,Persistent,Implic
|
Line 2653 class ECHO_root(Folder,Persistent,Implic
|
|
|
meta_type="ECHO_root" |
meta_type="ECHO_root" |
|
|
|
|
|
def mod_re_sub(self,pattern,replace,string): |
|
"""re.sub aus mod re zur Verfuegung stellen""" |
|
return re.sub(pattern,replace,string) |
|
|
|
def findObjectFromFulltext(self,existUri): |
|
''' |
|
|
|
@param url: |
|
@param existUri: |
|
''' |
|
|
|
if existUri: |
|
#TODO: at the moment assume that the filename is unique, the whole has to changed to a system of ids. |
|
filename=existUri.split("/")[-1] |
|
|
|
founds=self.resourceCatalog.search({'fullTextUrl':os.path.splitext(filename)[0]}) |
|
|
|
ret=[(found.title,found.getObject().absolute_url(),found.getObject().aq_parent.absolute_url()) for found in founds] |
|
|
|
return ret |
|
|
|
def reindex(self,RESPONSE=None): |
|
"""indiziere alle Objecte neu""" |
|
|
|
if RESPONSE: |
|
RESPONSE.write("<html><body>") |
|
|
|
resources=self.ZopeFind(self,obj_metatypes=["ECHO_resource"], search_sub=1) |
|
|
|
for resource in resources: |
|
resource[1].reindex() |
|
print "<p> done %s </p>\n" |
|
if RESPONSE: |
|
RESPONSE.write("<p> done %s </p>\n"%resource[0]) |
|
|
|
if RESPONSE: |
|
RESPONSE.write("<p> ok </p></html></body>\n") |
|
|
def printer(self,txt): |
def printer(self,txt): |
print txt |
print txt |
print txt[2] |
print txt[2] |
Line 2534 class ECHO_root(Folder,Persistent,Implic
|
Line 2708 class ECHO_root(Folder,Persistent,Implic
|
|
|
def setLanguage(self,lang): |
def setLanguage(self,lang): |
"""Set language cookie""" |
"""Set language cookie""" |
self.REQUEST.RESPONSE.setCookie('lang_exhibition',lang,path="") |
self.REQUEST.RESPONSE.setCookie('lang_exhibition',lang,path="/") |
|
|
def switchLanguage(self): |
def switchLanguage(self): |
"""Set language cookie""" |
"""Set language cookie""" |
Line 2543 class ECHO_root(Folder,Persistent,Implic
|
Line 2717 class ECHO_root(Folder,Persistent,Implic
|
else: |
else: |
lang="en" |
lang="en" |
|
|
self.REQUEST.RESPONSE.setCookie('lang_exhibition',lang,path="") |
self.REQUEST.RESPONSE.setCookie('lang_exhibition',lang,path="/") |
self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']) |
self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']) |
def getLanguage(self): |
def getLanguage(self): |
"""get language cookie""" |
"""get language cookie""" |
Line 3057 class ECHO_root(Folder,Persistent,Implic
|
Line 3231 class ECHO_root(Folder,Persistent,Implic
|
else: |
else: |
return "" |
return "" |
|
|
def link2html(self,str): |
link2html=vlp_xmlhelpers.link2html |
"""link2html fuer VLP muss hier noch raus""" |
|
if str: |
|
|
|
str=re.sub("\&","&",str) |
|
dom=xml.dom.minidom.parseString("<?xml version='1.0' encoding='utf-8'?><txt>"+str+"</txt>") |
|
links=dom.getElementsByTagName("link") |
|
|
|
|
|
for link in links: |
|
link.tagName="a" |
|
ref=link.getAttribute("ref") |
|
pn=link.getAttribute("page") |
|
|
|
if self.checkRef(ref): |
|
if pn: |
|
link.setAttribute("href",self.aq_parent.absolute_url()+"/references?id="+ref+"&page="+pn) |
|
else: |
|
link.setAttribute("href",self.aq_parent.absolute_url()+"/references?id="+ref) |
|
|
|
|
|
newxml=dom.toxml('utf-8') |
|
|
|
retStr=regexpTXT.search(newxml) |
|
|
|
return retStr.group(1) |
|
|
|
|
|
return "" |
|
|
|
def xml2html(self,str,quote="yes"): |
|
"""link2html fuer VLP muss hier noch raus""" |
|
|
|
if str: |
|
if quote=="yes2": |
|
str=re.sub("\&","&",str) |
|
#dom=xml.dom.minidom.parseString(str) |
|
dom = NonvalidatingReader.parseString(str,"http://www.mpiwg-berlin.mpg.de/") |
|
#links=dom.getElementsByTagName("link") |
|
links=Ft.Xml.XPath.Evaluate(".//link", contextNode=dom) |
|
for link in links: |
|
#link.tagName="a" |
|
|
|
ref=link.getAttributeNS(EMPTY_NAMESPACE,"ref") |
|
pn=link.getAttributeNS(EMPTY_NAMESPACE,"page") |
|
|
|
cns=link.childNodes[0:] |
|
|
|
newLink=dom.createElementNS(EMPTY_NAMESPACE,"a") |
|
for x in cns: |
|
newLink.appendChild(x) |
|
|
|
|
|
|
|
link.parentNode.replaceChild(newLink,link) |
|
if self.checkRef(ref): |
|
if pn: |
|
newLink.setAttributeNS(EMPTY_NAMESPACE,"href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref+"&p="+pn) |
|
else: |
|
newLink.setAttributeNS(EMPTY_NAMESPACE,"href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref) |
|
|
|
#str= dom.toxml('utf-8') |
|
buf = cStringIO.StringIO() |
|
PrettyPrint(dom, stream=buf) |
|
str = buf.getvalue() |
|
buf.close() |
|
#str=PrettyPrint(dom.documentElement,encoding='UTF-8') |
|
#print link.toxml('utf-8') |
|
#print type(str) |
|
retStr=regexpPage.search(str) |
|
|
|
try: # hack warum fehtl manchmal page?? |
xml2html=vlp_xmlhelpers.xml2html |
return retStr.group(1) |
|
except: |
|
return str |
|
return "" |
|
|
|
def checkRef(self,ref): |
|
if ref[0:3]=='lit': |
|
if len(self.library_data({ 'id':ref}))>0: |
|
return 1 |
|
try: |
|
if ref[0:7]=="tec_cat": |
|
return 1 |
|
except: |
|
"""nothing""" |
|
|
|
dbs={'vl_technology':'','vl_people':" AND complete='yes'",'vl_sites':''} |
checkRef=vlp_xmlhelpers.checkRef |
res=None |
|
for db in dbs.keys(): |
|
res=res or self.search(var=str("select reference from %s where reference =\'%s\' %s"%(db,ref,dbs[db]))) |
|
return res |
|
|
|
#Ende Methode fuer vlp |
# def checkRef(self,ref): |
|
# if ref[0:3]=='lit': |
|
# if len(self.library_data({ 'id':ref}))>0: |
|
# return 1 |
|
# try: |
|
# if ref[0:7]=="tec_cat": |
|
# return 1 |
|
# except: |
|
# """nothing""" |
|
# |
|
# dbs={'vl_technology':'','vl_people':" AND complete='yes'",'vl_sites':''} |
|
# res=None |
|
# for db in dbs.keys(): |
|
# res=res or self.search(var=str("select reference from %s where reference =\'%s\' %s"%(db,ref,dbs[db]))) |
|
# return res |
|
# |
|
# #Ende Methode fuer vlp |
|
|
def PgQuoteString(self,string): |
def PgQuoteString(self,string): |
"""Quote string""" |
"""Quote string""" |