Annotation of ECHO_content/ECHO_resource.py, revision 1.6

1.1       dwinter     1: import urlparse
                      2: import string
                      3: import tempfile
                      4: import zipfile
                      5: import re
                      6: import os,shutil
                      7: import OFS.Image
                      8: from types import *
                      9: from OFS.Cache import Cacheable
                     10: from OFS.Image import Image
                     11: from Globals import DTMLFile
                     12: from OFS.Folder import Folder
                     13: from OFS.SimpleItem import SimpleItem
                     14: from AccessControl import ClassSecurityInfo
                     15: from AccessControl.User import UserFolder
                     16: from Globals import InitializeClass
                     17: from Globals import DTMLFile
                     18: import Globals
                     19: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
                     20: from Products.PageTemplates.PageTemplate import PageTemplate
                     21: from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate,manage_addPageTemplate
                     22: from Globals import Persistent, package_home
                     23: from Acquisition import Implicit
                     24: from Products.ZCatalog.CatalogPathAwareness import CatalogAware
                     25: from Products.ZCTextIndex.ZCTextIndex import manage_addLexicon
1.2       dwinter    26: try:
                     27:    from Products.MetaDataProvider.MetaDataClient import MetaDataClient
                     28: except:
                     29:    print "no metadata services"
1.1       dwinter    30: import urllib
                     31: import urllib2
                     32: import cgi
                     33: import smtplib
                     34: import time
                     35: from Ft.Xml.Domlette import NonvalidatingReader
                     36: from Ft.Xml.Domlette import PrettyPrint, Print
                     37: from Ft.Xml import EMPTY_NAMESPACE
                     38: 
                     39: import Ft.Xml.XPath
                     40: import cStringIO
                     41: 
                     42: import sys
                     43: 
                     44: try:
                     45:         from psycopg import libpq
                     46: except:
                     47:         try:
                     48:                 from pyPgSQL import libpq
                     49:         except:
                     50:                 print "ECHO_collection: Warning - No libpq imported!"
                     51:                 
                     52: import xml.dom.minidom
                     53: 
                     54: import urllib
                     55: import xml.dom.minidom
                     56: import ECHO_helpers
                     57: from ECHO_helpers import *
                     58: 
                     59: 
                     60: from ECHO_movie import *
                     61: import vlp_xmlhelpers #TODO: vlp elemente aus echo herausnehmen
                     62: import xmlrpclib
                     63: 
                     64: import logging
                     65: 
                     66: class ECHO_resource(CatalogAware,Folder,Persistent,ECHO_basis):
                     67:     """ECHO Ressource"""
                     68:     security=ClassSecurityInfo()
                     69:     meta_type='ECHO_resource'
                     70:     default_catalog='resourceCatalog'
                     71:     
                     72: #    viewClassificationList=viewClassificationListMaster
                     73: 
                     74:     def PrincipiaSearchSource(self):
                     75:            """Return cataloguable key for ourselves."""
                     76:            return str(self)
                     77: 
                     78:     getSubCols = ECHO_helpers.getSubCols
                     79: 
                     80:     def index_meta(self,RESPONSE=None):
                     81:         """ gibt das im metalink gespeicher xml-file zurueck"""
                     82:         url = self.metalink
                     83:         txt=""
                     84:         logging.debug("ml:%s"%url)
                     85:         try:
                     86:             page = urllib.urlopen(url);
                     87:             if RESPONSE:
                     88:                 RESPONSE.setHeader("Content-Type","text/xml")
                     89:             
                     90:             txt = page.read();
                     91:         except:
                     92:             logging.error("Cannot read metadata of: %s"%self.getId())
                     93:         
                     94:         return txt
                     95:         
                     96:     def reindex(self):
                     97:         """generate fields for indexing and reindex"""
                     98:         
                     99:         #TODO: korrigieren des metalink pfades konfigurierbar machen
                    100:         splitted= [x for x in urlparse.urlparse(self.metalink)]
                    101:         splitted[1]="foxridge.mpiwg-berlin.mpg.de"[0:]
                    102:         
                    103:         if splitted[0]=="http":
                    104:             self.metalink=urlparse.urlunparse(splitted)
                    105:         
                    106: 
                    107:         self.fullTextUrl=self.getFullTextXML(noredirect="yes")
                    108:         
                    109:         #TODO: korrigieren relative url to absoluter url volltexten, konfigurierbar?
                    110:         splitted= [x for x in urlparse.urlparse(self.fullTextUrl)]
                    111:         if splitted[0]=="":
                    112:             splitted[0]="http"
                    113:             splitted[1]="foxridge.mpiwg-berlin.mpg.de"[0:]
                    114:             
                    115:             self.fullTextUrl=urlparse.urlunparse(splitted)
                    116:             
                    117:         self.imagePath=self.getImagePath()
                    118:         
                    119:         self.reindex_object()
                    120:   
                    121:   
                    122:     security.declareProtected('View','createPDF')
                    123:     def createPDF(self,RESPONSE=None,local=None,dpi=150):
                    124:             """erzeuge pdf file"""
                    125:             pages=1
                    126:             dpi=float(dpi)
                    127:             imagePath=self.getImagePath().replace("/mpiwg/online","")
                    128:             
                    129:             
                    130:             image="http://nausikaa2.mpiwg-berlin.mpg.de/digitallibrary/servlet/Scaler?fn="+imagePath+"&dw=%i&dh=%i&pn=%i"
                    131:             xmlInfo="http://nausikaa2.mpiwg-berlin.mpg.de/digitallibrary/dlInfo-xml.jsp?fn="+imagePath
                    132: 
                    133:             dom=xml.dom.minidom.parse(urllib.urlopen(xmlInfo))
                    134:             for parameter in dom.getElementsByTagName('parameter'):
                    135:                     if parameter.getAttribute('name')=="pt":
                    136:                             pages=int(parameter.getAttribute('value'))
                    137:                             break
                    138:             
                    139: 
                    140:             tempdir="/tmp/archivesImageServer"
                    141:             if not os.path.exists(tempdir):
                    142:                     os.mkdir(tempdir) 
                    143:   
                    144:             tmpPath=tempfile.mkdtemp(dir=tempdir)
                    145:             
                    146: 
                    147:             tmpZip=tempfile.mktemp(dir=tempdir)
                    148: 
                    149:             tmpFn=os.path.split(tmpZip)[1]
                    150: 
                    151: 
                    152:     
                    153: 
                    154:             if RESPONSE:
                    155:                     RESPONSE.setHeader("Content-Type","text/html")
                    156:                     RESPONSE.write("<h1>I am creating  the pdf</h1>")
                    157:                     txt="<h3>1. step: getting the images( %i pages)</h3>"%pages
                    158:                     RESPONSE.write(txt)
                    159: 
                    160:             c=canvas.Canvas(tmpZip)
                    161:             for i in range(1,pages+1):
                    162:                     if RESPONSE:
                    163:                             RESPONSE.write(str("<p>Get Page: %i<br>\n"%i))
                    164:                     faktor=dpi/72.0
                    165:                     
                    166:                     fn=tmpPath+"/%i"%i
                    167: 
                    168:                     width,height=A4
                    169:                     #print image%(width*faktor,height*faktor,i)
                    170:                     url=urllib.urlopen(image%(width*faktor,height*faktor,i)).read()
                    171:                     fh=file(fn,"w")
                    172:                     fh.write(url)
                    173:                     fh.close()
                    174: 
                    175:     
                    176: 
                    177:                     c.drawImage(fn,0,0,width=width,height=height)
                    178:                     c.showPage()
                    179:             c.save()
                    180:             if RESPONSE:
                    181:                     RESPONSE.write("<p>finished<br>\n")
                    182: 
                    183:             if RESPONSE:
                    184:                     len=os.stat(tmpZip)[6]
                    185:                     downloadUrl=self.absolute_url()+"/downloadPDF"
                    186:                     RESPONSE.write("""<h1><a href="downloadPDF?fn=%s">Click here for download ( %i Byte)</a></h1>\n"""%(tmpFn,len))
                    187:                     RESPONSE.write("""<p>The file will be stored for a while, you can download it later, the URL is:</p>
                    188:                     <p><a href="downloadPDF?fn=%s">%s?fn=%s</a></h1>\n"""%(tmpFn,downloadUrl,tmpFn))
                    189:                     RESPONSE.close()
                    190: 
                    191: 
                    192:     def downloadPDF(self,fn):
                    193:             """download prepared set"""
                    194:             filename="/tmp/archivesImageServer/"+fn
                    195:             namePDF=self.getId()+".pdf"
                    196:             self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s" """%namePDF)
                    197:             self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
                    198:             len=os.stat(filename)[6]
                    199:             self.REQUEST.RESPONSE.setHeader("Content-Length",len)
                    200:             images=file(filename).read()
                    201:             self.REQUEST.RESPONSE.write(images)
                    202:             self.REQUEST.RESPONSE.close()
                    203: 
                    204: 
                    205:     def getRDF(self,urn=None):
                    206:             """rdf"""
1.3       dwinter   207:             ap = self.getArchivePathFromMetadata()
                    208:          
                    209:        
                    210:             ret=getRDFDescription(self,self.link,urn=urn,ap=ap)
1.4       dwinter   211:            
1.1       dwinter   212:             return ret+self.createSubElementRDF(urn=urn) 
                    213: 
                    214:   
                    215:     def changeAccessRightForm(self,preselect=None):
                    216:         """change the access rights"""
                    217:         
                    218:         pt=zptFile(self, 'zpt/ChangeECHO_resourceAccessRight.zpt')
                    219:         return pt(preselect=preselect)
                    220:     
                    221:     def changeAccessRight(self):
                    222:         """changeRights"""
                    223:         argv=self.REQUEST.form
                    224:         self.setAccessRightXML(argv["%s_xml"%self.getId()])
                    225:         self.accessRight=argv["%s_echo"%self.getId()]
                    226:          
                    227:         self.REQUEST.RESPONSE.redirect('manage_main')
                    228:         
                    229:     
                    230:     def getAccessRightSelectorHTML(self,outlook="select",xmldominant=None,preselect=None):
                    231:             """htmlselector, xmldominant= in der regel wird der wert des xmlfiles ausgegeben ausser er existiert nicht"""
                    232:             values=['','free','MPIWG']
                    233:             
                    234:             if preselect:#set all to the preselected
                    235:                 ar=(preselect,preselect)
                    236:             else:#else set to actual value
                    237:                 ar=self.getAccessRightMD()
                    238:                 
                    239:             if outlook=="select":
                    240:                     ret="""<select name="%s_xml">"""%self.getId()
                    241:                     ret1="""<select name="%s_echo">"""%self.getId()
                    242:                     for value in values:
                    243:                             if value==ar[0]:
                    244:                                     ret+="<option selected>%s</option>"%value
                    245:                             else:
                    246:                                     ret+="<option>%s</option>"%value
                    247:                             
                    248:                             if value==ar[1]:
                    249:                                     ret1+="<option selected>%s</option>"%value
                    250:                             else:
                    251:                                     ret1+="<option>%s</option>"%value
                    252:                     
                    253:                     
                    254:                     if not xmldominant:
                    255:                         return ret+"</select>",ret1+"</select>"
                    256:                     else:
                    257:                         if ar[0] is not None:
                    258:                             return ret+"</select>"
                    259:                         else:
                    260:                             return "<p>No xml file (only local selection):"+ret1
                    261: 
                    262:             else:
                    263:                     ret=""
                    264:                     ret1=""
                    265:                     for value in values:
                    266:                             
                    267:                             if value==ar[0]:
                    268:                                     ret+="""<input type="radio" name="%s_xml" value="%s" checked>%s"""%(self.getId(),value,value)
                    269:                             else:
                    270:                                     ret+="""<input type="radio" name="%s_xml" value="%s">%s"""%(self.getId(),value,value)
                    271:                                     
                    272:                             if value==ar[1]:
                    273:                                     ret1+="""<input type="radio" name="%s_echo" value="%s" checked>%s"""%(self.getId(),value,value)
                    274:                             else:
                    275:                                     ret1+="""<input type="radio" name="%s_echo" value="%s">%s"""%(self.getId(),value,value)
                    276: 
                    277:                     if not xmldominant:                        
                    278:                         return ret,ret1
                    279:                     else:                         
                    280:                         if ar[0]:
                    281:                             return ret
                    282:                         else:
                    283:                             return "<p>No xml file (only local selection)</p>"+ret1
                    284: 
                    285: 
                    286: 
                    287:     def copyAccessRightsFromMD(self):
                    288:             """kopiere rechte aus den metadaten"""
                    289:             self.accessRight=self.getAccessRightMD()[0]
                    290:             
                    291:             
                    292:             
                    293:             
                    294:     
                    295:     def getAccessRightMD(self):
                    296:                 """set accessright"""
                    297:                 url=self.metalink
                    298: 
                    299:                 try:
                    300:                     urllib.urlopen(url)
                    301:                 except:
                    302:                     logger("ECHO_Resource (getAccessRightMD)", logging.INFO,"%s (%s)"%sys.exc_info()[0:2])
                    303: 
                    304:                     return None,getattr(self,'accessRight','')
                    305:                 
                    306:             
                    307:                 try:
                    308:                         dom = NonvalidatingReader.parseUri(url)
                    309:                 except:
                    310:                         logger("ECHO_Resource (getAccessRightMD)", logging.INFO,"%s (%s)"%sys.exc_info()[0:2])
                    311:                         return (None,"Cannot parse: "+url+"<br>"+"%s (%s)"%sys.exc_info()[0:2])
                    312: 
                    313: 
                    314:                 accessright=dom.xpath("//meta/access-conditions/access/@type")
                    315:                 if accessright:
                    316:                     accessright=accessright[0].value
                    317:                 if str(accessright)=='institution':
                    318:                     tmp=dom.xpath("//meta/access-conditions/access/name")
                    319:                     if tmp:
                    320:                         accessright=getTextFromNode(tmp[0])
                    321:                     
                    322:                 if not accessright:
                    323:                     accessright=""
                    324:                 
                    325:                 return accessright,getattr(self,'accessRight','')             
                    326: 
                    327:     def changeAccessRightMD(self,accessright,RESPONSE=None):
                    328:             """change the rights - not user anymore"""
                    329:             #TODO: check if method still needed
                    330:             params="accessright=%s"%accessright
                    331: 
                    332: 
                    333:             #print ECHO_helpers.urlopen(self.absolute_url()+'/setAccessRightXML'+'?'+params).read()
                    334: 
                    335:             tries=0
                    336:             for i in range(10):
                    337:                     x=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()+'/setAccessRightXML'+urllib.quote('?'+params))).read()
                    338:                     if x=="ok":
                    339:                            
                    340:                             break;
                    341:                  
                    342:             
                    343:           
                    344:             if RESPONSE is not None:
                    345:                         RESPONSE.redirect('manage_main')
                    346: 
                    347:                 
                    348:     def setAccessRightXML(self,accessright):
                    349:                 """set accessright"""
                    350:                 url=self.metalink
                    351:                 accessrights=['MPIWG','free']#allowes rights
                    352:                 
                    353:                 if accessright =='':
                    354:                     """do nothing"""
                    355:                     return ""
                    356:                     
                    357:                     
                    358:                 try:
                    359:                         geturl=""
                    360:                         for line in ECHO_helpers.urlopen(url).readlines():
                    361:                                 geturl=geturl+line 
                    362: 
                    363: 
                    364:                 except:
                    365:                         return (None,"Cannot open: "+url)
                    366: 
                    367:                 try:
                    368:                         dom=xml.dom.minidom.parseString(geturl)
                    369:                         root=dom.getElementsByTagName('resource')[0]
                    370:                 except:
                    371:                         return (None,"Cannot parse: "+url+"<br>"+geturl)
                    372: 
                    373:                 metamains=dom.getElementsByTagName('meta')
                    374:                 
                    375:                 if not metamains:
                    376:                         nodenew=dom.createElement('meta')
                    377:                         root.appendChild(nodenew)
                    378:                         metamain=nodenew
                    379:                 else:
                    380:                         metamain=metamains[0]
                    381:                 
                    382:                 
                    383:                 metanodes=metamain.getElementsByTagName('access-conditions')
                    384: 
                    385:                 if not metanodes:
                    386:                         nodenew=dom.createElement('access-conditions')
                    387:                         metamain.appendChild(nodenew)
                    388:                         metanode=nodenew
                    389:                 else:
                    390:                         metanode=metanodes[0]
                    391: 
                    392:                 accesses=metanode.getElementsByTagName('access')
                    393: 
                    394:                 #delete old
                    395:                 if accesses:
                    396:                      metanode.removeChild(accesses[0]).unlink()
                    397: 
                    398:                 #create new
                    399:                     
                    400:                 nodenew2=dom.createElement('access')
                    401:                 metanode.appendChild(nodenew2)
                    402:                 metanode2=nodenew2
                    403:                 
                    404:                 attribute=metanode2.getAttribute('type')
                    405:                 
                    406:                 if accessright=="free":
                    407:                     
                    408:                      metanode2.setAttribute('type','free')
                    409:                 
                    410:                 elif accessright.upper()=='MPIWG':
                    411:                         metanode2.setAttribute('type','institution')
                    412:                         nodenew4=dom.createElement('name')
                    413:                         metanodetext=dom.createTextNode('MPIWG')
                    414:                         nodenew4.appendChild(metanodetext)
                    415:                         nodenew2.appendChild(nodenew4)
                    416:                 #print dom.toxml().encode('utf-8')
                    417:                 string= encodeRPC(dom.toxml().encode('utf-8'))
                    418:                 
                    419:                 #TODO: make server configurable
                    420:                 server=xmlrpclib.Server("http://foxridge.mpiwg-berlin.mpg.de/server")
                    421: 
                    422:                 path=urlparse.urlparse(self.metalink)[2]
                    423:          
                    424:                 server.writeMetaDataFile(path,string,"yes")
                    425:         
                    426:     def setStartPageForm(self):
                    427:             """Form for changing the startpage"""
                    428: 
                    429:             
                    430:             pt=zptFile(self, 'zpt/ChangeECHO_resourceStartPage.zpt')
                    431:             pt.content_type="text/html"
                    432:             return pt()
                    433:     
                    434: 
                    435:     def createImageUrl(self,pn=1):
                    436:             """create ImageUrl"""
                    437: 
                    438:             
1.5       dwinter   439:             resourcepath=readFieldFromXML_xpath(self.metalink,'//resource/archive-path')
1.1       dwinter   440:             
                    441:             digiliburlprefix=readFieldFromXML(self.metalink,'texttool','digiliburlprefix')
                    442:             images=readFieldFromXML(self.metalink,'texttool','image')
                    443: 
                    444: 
                    445:             if (not resourcepath) or (not digiliburlprefix) or (not images):
                    446:                     logger("ECHO (createImageUrl)",logging.ERROR,"Cannot create ImageUrl for %s"%self.absolute_url())
                    447:                     return None
                    448:             resourcepath=resourcepath.replace('/mpiwg/online','')
                    449:             if not digiliburlprefix: digiliburlprefix="http://echo.mpiwg-berlin.mpg.de/zogilib?"
                    450: 
                    451:             if (not images) or (not resourcepath): return None
                    452: 
                    453:             return "%sfn=%s&pn=%i"%(digiliburlprefix,resourcepath+"/"+images,pn)
                    454:     
                    455:     def copyTitleToInfoXML(self,RESPONSE=None):
                    456:             """copy title from the resource"""
                    457:             presentationXML=readFieldFromXML(self.metalink,'texttool','presentation')
1.5       dwinter   458:             resourcepath=readFieldFromXML_xpath(self.metalink,'//resource/archive-path')
1.1       dwinter   459:             if (not presentationXML) or (not resourcepath): 
                    460:                 if RESPONSE:
                    461:                         RESPONSE.write("Error: %s\n"%self.getId())
                    462:                 else:
                    463:                         return None,self.absolute_url()
                    464: 
                    465:             try:
                    466:                     fh=file(os.path.join(resourcepath,presentationXML),'w')
                    467:                     fh.write("""<info>
                    468:                     <author></author>
                    469:                     <title>%s</title>
                    470:                     <date></date>
                    471:                     <display>yes</display>
                    472:                     </info>"""%self.title)
                    473:                     fh.close()
                    474:                     return 1,self.getId()
                    475:             except:
                    476:                     if RESPONSE:
                    477:                             RESPONSE.write("Error: %s\n"%self.getId())
                    478:                     else:
                    479:                             return None,self.absolute_url()
                    480: 
                    481:             
                    482:     def setStartPage(self,startpage=None,RESPONSE=None):
                    483:             """set start page, if no startpage defined use the generic one of the resource"""
                    484: 
                    485:             if (not (type(startpage)==StringType)):
                    486:                     if ("__generic" in startpage): # checke ob generic in der liste
                    487:                             startpage=self.absolute_url()+"/startpage_html"
                    488:                     elif ("__firstPage" in startpage): # checke ob generic in der liste
                    489:                             startpage=self.createImageUrl()
                    490:                             
                    491:             if (not startpage):
                    492:                     startpage=self.absolute_url()+"/startpage_html"
                    493:             elif (startpage=="__generic"):
                    494:                     startpage=self.absolute_url()+"/startpage_html"
                    495:             elif (startpage=="__firstPage"):
                    496:                         startpage=self.createImageUrl()
                    497:     
                    498:             params="startpage=%s"%startpage
                    499:             #print '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))
                    500:                
                    501:             tries=0
                    502:             for i in range(10):
                    503:                     x=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()
                    504:                     if x=="ok":
                    505:                            
                    506:                             break;
                    507:                  
                    508:             
                    509:             path=self.metalink
                    510:             
                    511:             path=re.sub(self.REQUEST['SERVER_URL'],'',path)
                    512:             path=re.sub('http://'+self.REQUEST['HTTP_HOST'],'',path)
                    513:             
                    514:             path=re.sub('http://foxridge.mpiwg-berlin.mpg.de:8080','',path) # falls foxridge als server
                    515:             path=re.sub('http://foxridge.mpiwg-berlin.mpg.de','',path) # falls foxridge als server
                    516:             path=re.sub('http://foxridge.rz-berlin.mpg.de:8080','',path) # falls foxridge als server
                    517:             path=re.sub('http://content.mpiwg-berlin.mpg.de','',path) # falls content als server
                    518:             path=re.sub('http://foxridge.rz-berlin.mpg.de','',path) # falls foxridge als server
                    519:             path=re.sub('http://vision.mpiwg-berlin.mpg.de','',path) # falls vision als server
                    520:             path=re.sub('http://xserve02.mpiwg-berlin.mpg.de:18880','',path) # falls vision als server
                    521:             path=re.sub('http://echo.mpiwg-berlin.mpg.de','',path) # falls echo
                    522:             path=re.sub('/index.meta','',path) 
                    523: 
                    524: 
                    525:             ECHO_helpers.urlopen("http://nausikaa2.rz-berlin.mpg.de:86/cgi-bin/toc/admin/reg.cgi?path=%s"%path).readlines()
                    526: 
                    527:             if RESPONSE is not None:
                    528:                         RESPONSE.redirect('manage_main')
                    529: 
                    530:     def changeViewerTemplateSetForm(self):
                    531:             """change the viewer template set"""
                    532:             pt=zptFile(self, 'zpt/changeResourceViewerTemplateSet')
                    533:             return pt()
                    534: 
                    535: 
                    536:     def setLink(self, link=None):
                    537:         """change link field"""
                    538:         if link is not None:
                    539:             self.link = link
                    540:             
                    541:    
                    542:     def getTextToolsField(self,name,default=''):
                    543:         """Lese Textoolsfelder aus index.meta im path aus"""
                    544:         
                    545:         try:
                    546:             dom=xml.dom.minidom.parse(self.metalink)
                    547:             node=dom.getElementsByTagName('texttool')[0] #getNode
                    548:             subnode=node.getElementsByTagName(name)[0]
                    549: 
                    550:             # bei text wird nur der Folder gebraucht
                    551:             if name=="text":
                    552:                 splitted=getText(subnode.childNodes).split("/")
                    553:                 return splitted[len(splitted)-2]
                    554:             else:
                    555:                 return getText(subnode.childNodes)
                    556:         except:
                    557:             return default
                    558:    
                    559: 
                    560:     def changeViewerTemplateSet(self,project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix,RESPONSE=None):
                    561:             """changeit"""
                    562: 
                    563:             paramList=['project','startpage','xslt','thumbtemplate','topbar','digiLibTemplate','digiliburlprefix']
                    564: 
                    565:             
                    566:             #writeMetadata(self.metalink,self.metaDataHash,project,None,xslt,thumbtemplate,topbar,digiLibTemplate)
                    567: 
                    568:             params="project=%s&xslt=%s&thumbtemplate=%s&topbar=%s&digiLibTemplate=%s&digiliburlprefix=%s"%(project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix)
                    569: 
                    570:             try:
                    571:                 tries=0
                    572:                 for i in range(10):
                    573:                         x=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()
                    574:                         if x=="ok":
                    575:                            
                    576:                             break;
                    577:                  
                    578:             except:
                    579:                 logger("ECHO_ressource (changeViewerTemplateSet)", logging.ERROR,"%s (%s)"%sys.exc_info()[0:2])          
                    580:                 logger("ECHO_ressource (changeViewerTemplateSet)", logging.ERROR,'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)))
                    581:             #print self.absolute_url()+'/newMetaXML'+urllib.quote'?'+params)
                    582:             # hack Pfad auf die Dokumente
                    583:             path=self.metalink
                    584:             
                    585:             
                    586: 
                    587:             path=re.sub('/index.meta','',path) 
                    588: 
                    589:             #TODO: direct access to the file system necessary, fix that also xmlrpc to the server where the index file is stored is possible    
                    590:             parsedUrl=urlparse.urlparse(path)
                    591:             path=parsedUrl[2]
                    592: 
                    593:             try:        
                    594:                 return ECHO_helpers.urlopen("http://nausikaa2.rz-berlin.mpg.de:86/cgi-bin/toc/admin/reg.cgi?path=%s"%path).readlines()
                    595:             except:
                    596:                 logger("ECHO_Resource (changeViewerTemplateSet)", logging.INFO,"%s (%s)"%sys.exc_info()[0:2])
                    597:                 logger("ECHO_Resource (changeViewerTemplateSet)", logging.INFO,"http://nausikaa2.rz-berlin.mpg.de:86/cgi-bin/toc/admin/reg.cgi?path=%s"%path)
                    598: 
                    599:             if RESPONSE is not None:
                    600:                         RESPONSE.redirect('manage_main')
                    601: 
                    602:     
                    603: 
                    604:     security.declarePublic('content_html')      
                    605:     def content_html(self):
                    606:         """template fuer content"""
                    607:         return ECHO_basis.content_html(self,'resource')
                    608:     
                    609: #    def getViewClassification(self):
                    610: #        if hasattr(self,'viewClassification'):
                    611: #            return self.viewClassification
                    612: #        else:
                    613: #            return ""
                    614: 
                    615:     def getFullTextXML(self,noredirect=None):
                    616:             """getFullTextXML; gives the FullText as an XML Document, and <error></error> if somthing goes wrong."""
                    617: 
                    618:             try:
                    619:                     #logger("ECHO Fulltext",logging.INFO,"open %s"%self.metalink)
                    620:                     fh=ECHO_helpers.urlopen(self.metalink)
                    621:                     #logger("ECHO Fulltext",logging.INFO,"opened %s"%self.metalink)
                    622:                     dom=xml.dom.minidom.parse(fh)
                    623:                     texttools=dom.getElementsByTagName('texttool')
                    624:                     text=texttools[0].getElementsByTagName('text')
                    625:                     texturl=getText(text[0].childNodes)
                    626: 
                    627:                     #logger("ECHO Fulltext",logging.INFO,"found %s"%texturl)
                    628:                     fh.close()
                    629:                     #logger("ECHO Fulltext",logging.INFO,"closed fh")
                    630:                     #keine url
                    631:                     if not (texturl.split(":")[0] in ['http','ftp','file']): 
                    632:                         if not noredirect:
                    633:                             return file(texturl).read()
                    634:                         else:
                    635:                             return texturl
                    636: 
                    637:                     if not noredirect:
                    638:                             self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')  
                    639:                             logger("ECHO Fulltext",logging.INFO,"redirect to:%s"%texturl)
                    640:                             self.REQUEST.RESPONSE.redirect(texturl)
                    641:                     else:
                    642:                             return texturl
                    643:             except:
                    644: 
                    645:                     if not noredirect:
                    646:                             self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
                    647:                             self.REQUEST.RESPONSE.write("<error>no fulltext available</error>")
                    648:                     else:
                    649:                             return "<error>no fulltext available</error>"
                    650: 
                    651:     def getImagePath(self):
                    652:             """gibt pfad zum image aus"""
                    653:             return self.getImageView(noredirect="yes",onlyPath="yes")
                    654:     
1.3       dwinter   655:     def getArchivePathFromMetadata(self):
                    656:        try:
1.5       dwinter   657:            archivePath=readFieldFromXML_xpath(self.metalink,"//resource/archive-path")
                    658:            return archivePath
1.3       dwinter   659:        except:
                    660:            return ""
                    661:    
1.1       dwinter   662:     def getImageView(self,noredirect=None,onlyPath=None):
                    663:             """getImages; give Imageviewr  and <error></error> if somthing goes wrong."""
                    664:             try:
1.5       dwinter   665:                    archivePath=readFieldFromXML_xpath(self.metalink,"//resource/archive-path")
                    666:                   
1.1       dwinter   667:                     archivepath=re.sub('/mpiwg/online/','',archivepath) 
                    668:                     imageurl="http://echo.mpiwg-berlin.mpg.de/zogilib?fn="+archivepath+"/"+imagetemp
                    669:                     fh.close()
                    670: 
                    671:                     if not noredirect:
                    672:                             self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')  
                    673:                             self.REQUEST.RESPONSE.redirect(imageurl)
                    674:                     else:
                    675:                             if not onlyPath:
                    676:                                     return imageurl
                    677:                             else:
                    678:                                     return archivepath+"/"+imagetemp
                    679:             except:
                    680: 
                    681:                     if not noredirect:
                    682:                             self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
                    683:                             self.REQUEST.RESPONSE.write("<error>no fulltext available</error>")
                    684:                     else:
                    685:                             return "<error>no images available</error>"
                    686: 
                    687:     
                    688:     def getCopyrightsHTML(self):
                    689:             """gib (link auf copyright link, mediatyp, institution, copyrightType, label von copyrightType) aus"""
                    690:             
                    691:             if hasattr(self,'copyrightModel'):
                    692:                     obj=self.copyrightModel
                    693:                     
                    694:             else:
                    695:                     return "ERROR"
                    696:             ret=[]
                    697:             
                    698:             for copyright in obj.getCopyrights(): #copyright - media / partner / copyrightID
                    699:                     
                    700:                     
                    701:                     try:
                    702:                         if hasattr(self.copyrightTypes,copyright[2]):
                    703:                              copyrightTypeObj=getattr(self.copyrightTypes,copyright[2])
                    704:                              link="copyrightTypes/"+copyright[2]+'/copyright.html'
                    705:                         else:
                    706:                              copyrightTypeObj=getattr(obj,copyright[2])
                    707:                              link="copyrightModel/"+copyright[2]+'/copyright.html'
                    708:                              
                    709:                         label=copyrightTypeObj.label
                    710:                         url=getattr(copyrightTypeObj, 'url', '')
                    711:                             
                    712:                         if url!='':
                    713:                                  ret.append((url,copyright[0],copyright[1],copyright[2],label))
                    714:                         else:
                    715:                                 if hasattr(copyrightTypeObj, 'copyright.html'):
                    716:                                      ret.append(("""%s?partner=%s"""%(link,copyright[1]),copyright[0],copyright[1],copyright[2],label))
                    717:                                 else:
                    718:                                      ret.append(('empty',copyright[0],copyright[1],copyright[2],label))
                    719:                     except:
                    720:                             """nothing"""
                    721:                     
                    722:             return ret
                    723:             
                    724:     def getInstitutionsHTML(self):
                    725:                 """gibt Liste der foerdernden Institutionen aus"""
                    726:                 
                    727:                 if hasattr(self,'support'):
                    728:                         obj=self.support
                    729:                         ret=obj.getSupporter()
                    730:                         return ret
                    731:                 else:
                    732:                         return ''
                    733:                         
                    734:     def getOwnerOriginalsHTML(self):
                    735:                """gibt Liste der foerdernden Institutionen aus"""
                    736:                
                    737:                if hasattr(self,'ownerOriginal'):
                    738:                        obj=self.ownerOriginal
                    739:                        ret=obj.getOwner()
                    740:                        return ret
                    741:                else:
                    742:                        return ''
                    743:     
                    744:     def getDigiCopyByHTML(self):
                    745:                """gibt Liste der foerdernden Institutionen aus"""
                    746:                
                    747:                if hasattr(self,'digiCopyBy'):
                    748:                        obj=self.digiCopyBy
                    749:                        ret=obj.getDigiCopyBy()
                    750:                        return ret
                    751:                else:
                    752:                        return ''                    
                    753:     
                    754:     def getCredits(self):
                    755:         """Ausgabe der credits"""
                    756:         if self.credits:
                    757:             return self.credits
                    758:         else:
                    759:             return []
                    760: 
                    761: 
                    762:     def getStorageManagerResourceURL(self):
                    763:         """get the link to storage"""
                    764:         urlbase=self.getStorageManagerURL();
                    765:         
                    766:         #now get the path from the metadatalink
                    767:         
                    768:         path = self.correctPath(self.getMetaDataLink())
                    769:         if path is None:
                    770:             return ""
                    771:         else:
                    772:             path=path.replace("index.meta","")
                    773:             return urlbase+path
                    774:         
                    775:         
                    776:     def correctPath(self,path):
                    777:         #take only the path of the url which starts with /permanent or /experimental
                    778:         
                    779:         rs= re.search("/permanent/(.*)", path);
                    780:         if rs is not None:
                    781:             txt="permanent/"+rs.group(1)
                    782:         else:
                    783:             rs= re.search("/experimental/(.*)", path);
                    784:             if rs is not None:
                    785:                 txt="experimental"+rs.group(1)
                    786:             else:
                    787:                 return None
                    788:         
                    789:         return txt
                    790:         
                    791:     def __init__(self,id,link,metalink,resourceID,title,label,description,contentType,renderingType,copyrightType,responsible,credits,weight,coords):
                    792: 
                    793:         self.id = id
                    794:         """Festlegen der ID"""
                    795:         
                    796:         self.label = label
                    797:         self.link= link
                    798:         self.metalink=metalink
                    799:         self.title=title
                    800:         self.weight=weight
                    801:         self.credits=toList(credits)
                    802:         self.description=description
                    803:         self.contentType=contentType
                    804:         self.copyrightType=copyrightType
                    805:         self.renderingType=renderingType
                    806:         self.responsible=responsible
                    807:         self.resourceID=resourceID
                    808:         
                    809:         if coords:
                    810:             coordsnew=[ string.split(x,",") for x in coords]
                    811:         else:
                    812:             coordsnew=[]
                    813:         
                    814:         self.coords=coordsnew
                    815: #       self.viewClassification=""
                    816: 
                    817: 
                    818: 
                    819:     def getContentType(self):
                    820:             try:
                    821:                     return normalizeCt(self.contentType)
                    822:             except:
                    823:                     return ""
                    824: 
                    825:     def getCopyrightType(self):
                    826:             try:
                    827:                     return self.copyrightType
                    828:             except:
                    829:                     return ""
                    830: 
                    831:     def getRenderingType(self):
                    832:             try:
                    833:                     return self.renderingType
                    834:             except:
                    835:                     return ""
                    836: 
                    837:     def ECHO_resource_config(self):
                    838:         """Main configuration"""
                    839: 
                    840:         if not hasattr(self,'weight'):
                    841:             self.weight=""
                    842: 
                    843:         pt=zptFile(self, 'zpt/ChangeECHO_resource.zpt')
                    844:         return pt()
                    845:     
                    846: 
                    847:     def ECHO_resource_config_main(self):
                    848:         """Main configuration"""
                    849:         if not hasattr(self,'weight'):
                    850:             self.weight=""
                    851:         pt=zptFile(self, 'zpt/ChangeECHO_resource_main.zpt')
                    852:         return pt()
                    853: 
                    854:     def ECHO_resource_config_coords(self):
                    855:         """Coords configuration """
                    856:         pt=zptFile(self, 'zpt/ChangeECHO_resource_coords.zpt')
                    857:         return pt()
                    858: 
                    859:     def ECHO_resource_config_credits(self):
                    860:         """Main configuration"""
                    861:         pt=zptFile(self, 'zpt/ChangeECHO_resource_credits.zpt')
                    862:         return pt()
                    863: 
                    864:     def ECHO_resource_config_metadata(self):
                    865:         """Main configuration"""
                    866:         if (hasattr(self,'metadata')) and not (hasattr(self,'metaDataHash')):
                    867:                 self.metaDataHash={}
                    868:                 self.contentType=self.bib_type
                    869:                 for data in self.metadata:
                    870:                         data_neu=re.sub('-','_',data)
                    871:                         self.metaDataHash[data_neu]=getattr(self,data)[0:]
                    872: 
                    873:         
                    874:         pt=zptFile(self, 'zpt/ChangeECHO_resource_metadata.zpt')
                    875:         return pt()
                    876: 
                    877: 
                    878:     
                    879:     def changeViewer(self,newViewer):
                    880:         """set newViewer to the url of the new viewer
                    881:         only if metalink is set, otherwise it gives false
                    882:         """
                    883:         
                    884:         texterUrl="http://nausikaa2.mpiwg-berlin.mpg.de/digitallibrary/servlet/Texter?fn=/"
                    885:         
                    886:         vl,msg=self.checkValidityOfMetaLink()
                    887:         
                    888:         if not vl: #ungueltiger link, versuche neuen
                    889:             newStr=re.match(".*/mpiwg/online/(.*)",self.metalink) # suche pfad hinter /mpiwg/online 
                    890:             oldLink=self.metalink
                    891:             
                    892:             if newStr:
                    893:                 self.metalink=texterUrl+newStr.group(1)
                    894:                 vl,msg=self.checkValidityOfMetaLink()
                    895:             else:
                    896:                 logging.error("change Viewer XX(mew Metadatafile) %s"%self.metalink)
                    897:                 vl=False
                    898:                 
                    899:             if not vl: # geht immer noch nicht, dann setzte wieder zurueck
                    900:                 self.metalink=oldLink
                    901:             
                    902:             logging.info("change Viewer (mew Metadatafile) %s"%self.metalink)
                    903:            
                    904:         if vl:
                    905:             self.newViewer=newViewer
                    906:             return vl,msg
                    907:         else:
                    908:             return vl,msg
                    909:     
                    910:     def checkValidityOfMetaLink(self):
                    911:         """checks if the metalink is valid xml"""
                    912:         
                    913:         ml=self.metalink
                    914:         
                    915:         try:
                    916:             txt=urllib.urlopen(ml)
                    917: 
                    918:         except:
                    919:             return False,"Cannot open: %s)"%ml
                    920:         
                    921:         txt.close()        
                    922:         try:
                    923:             dom = NonvalidatingReader.parseUri(ml)
                    924:         except:
                    925:             return False, "Connot parse: %s)"%ml
                    926:         
                    927:         if len(dom.xpath("//texttool"))==0:
                    928:             return False, "No texttools: %s)"%ml
                    929:             
                    930:         return True,""
                    931:         
                    932:     def changeECHO_resource_main(self,metalink,link,title,label,description,contentType,renderingType,weight,resourceID,newViewer='',RESPONSE=None):
                    933:         """Aenderung der Properties"""
                    934:         self.resourceID=resourceID
                    935:         self.title=title
                    936:         self.label=label
                    937:         self.description=description
                    938: 
                    939:         self.contentType=contentType
                    940:         self.renderingType=renderingType
                    941:         self.weight=weight
                    942:         
                    943:         self.link=link
                    944:         self.metalink=metalink
                    945:         
                    946:         self.newViewer=newViewer
                    947:         
                    948:         
                    949:         if RESPONSE is not None:
                    950:             RESPONSE.redirect('manage_main')
                    951: 
                    952: 
                    953:     def changeECHO_resource_coords(self,RESPONSE=None):
                    954:         """Aenderung der Properties - coords"""
                    955:         #return self.REQUEST
                    956:         for area in self.getMapAreas():
                    957:             id = area.getId()
                    958:             if self.REQUEST.has_key('del.'+id):
                    959:                 # delete this area
                    960:                 self._delObject(id)
                    961:                 # return to same menu
                    962:                 if RESPONSE is not None:
                    963:                     RESPONSE.redirect('ECHO_resource_config_coords')
                    964:                 return
                    965:             # modify this area
                    966:             coordstring = self.REQUEST.get('coords.'+id, '')
                    967:             coords = string.split(coordstring, ',')
                    968:             angle = self.REQUEST.get('angle.'+id, '0')
                    969:             type = self.REQUEST.get('type.'+id, 'area')
                    970:             if len(coords) == 4:
                    971:                 area.setCoordString(coordstring)
                    972:                 area.setAngle(angle)
                    973:                 area.setType(type)
                    974:         # return to main menu    
                    975:         if RESPONSE is not None:
                    976:             RESPONSE.redirect('manage_main')
                    977: 
                    978: 
                    979:     def changeECHO_resource_credits(self,credits,responsible,copyrightType,RESPONSE=None):
                    980:         """Aenderung der Properties"""
                    981:         self.credits=credits
                    982:         self.responsible=responsible
                    983:         self.copyrightType=copyrightType
                    984:         
                    985:         if RESPONSE is not None:
                    986:             RESPONSE.redirect('manage_main')
                    987: 
                    988: 
                    989:     def changeECHO_resource_metadata_local(self,RESPONSE=None):
                    990:             """change metadata"""
                    991:             tags=self.findTagsFromMapping(normalizeCt(self.contentType))
                    992:             for field in tags[1]:
                    993:                     self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)][0:]
                    994:                         
                    995: 
                    996:                     
                    997:             if RESPONSE is not None:
                    998:                     RESPONSE.redirect('manage_main')
                    999: 
                   1000:     def changeECHO_resource_metadata(self,RESPONSE=None):
                   1001:             """change metadata"""
                   1002:             tags=self.findTagsFromMapping(normalizeCt(self.contentType))
                   1003:             self.OSAS_meta={}
                   1004:             for field in tags[1]:
                   1005:                     try:
                   1006:                             self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)]
                   1007:                             self.OSAS_meta[self.getFieldTag(tags,field)]=self.REQUEST.form['OSAS_%s'%self.getFieldTag(tags,field)]
                   1008:                     except:
                   1009:                             logger("ECHO_collection (changeECHO_resource_metadata)",logging.ERROR,"%s (%s)"%sys.exc_info()[0:2])
                   1010: 
                   1011:             logging.debug("changeECHO_resource_metadata:"+repr(self.newMetaXML()))
                   1012:             
                   1013:             
                   1014:             mc = MetaDataClient("http://content.mpiwg-berlin.mpg.de/metaDataServer") 
                   1015:             x=mc.writeMetaDataFile(self.getMetaDataLink(),self.newMetaXML(),compressed=None)
                   1016:                            
                   1017:             logging.debug("changeECHO_resource_metadata (xlrpc return):"+repr(x))
                   1018:             
                   1019: 
                   1020:             if RESPONSE is not None:
                   1021:                     RESPONSE.redirect('manage_main')
                   1022: 
                   1023:     
                   1024: 
                   1025:     def getMDValueSimpleSearchField(self):
                   1026:             """returns value for simple search"""
                   1027:             
                   1028:             try:
                   1029:                 return " ".join([self.getMDValue('title',generic="yes"),
                   1030:                              self.getMDValue('author',generic="yes"),
                   1031:                              self.getMDValue('year',generic="yes"),self.getTitle()])
                   1032:             except:
                   1033:                 
                   1034:                 #logger(" ECHO_collection(getMDSimpleSearchField)",logging.INFO," ".join([self.getMDValue('title',generic="yes"),
                   1035:                  #            self.getMDValue('author',generic="yes"),
                   1036:                   #           self.getMDValue('year',generic="yes"),'']))
                   1037:                 return ""
                   1038:                              
                   1039:     def getMDValue(self,fieldNameTest,empty=None,generic=None):
                   1040:             """get md values"""
                   1041:             #TODO: cache mappinghash
                   1042:             
                   1043:             fieldName=None
                   1044:             if generic:
                   1045:                 if self.contentType:
                   1046:                     ct=self.contentType.replace(" ","_").lower()
                   1047:                     ct=self.contentType.replace("-","_").lower()
                   1048:                 else:
                   1049:                     logger("ECHO_collection (getMDValue)", logging.INFO, "no_content type for %s"%self.getId())
                   1050:                     ct=""
                   1051:                     
                   1052:                 #caching
                   1053:                 if not hasattr(self,'_v_mapHash'): #noch keine cachevariable
                   1054:                     self._v_mapHash={}
                   1055:                 
                   1056:                 
                   1057: 
                   1058:                 tmp=self._v_mapHash.get(ct,None) 
                   1059:                 if tmp: #teste ob type schon existiert
                   1060:                     fieldName=tmp.get(fieldNameTest,None)
                   1061:                 else:
                   1062:                     self._v_mapHash[ct]={}
                   1063:                     
                   1064: 
                   1065:                 #noch nicht gecached    
                   1066:                 if not fieldName and hasattr(self.standardMD,ct):    
                   1067:                     fieldName=getattr(self.standardMD,ct).generateMappingHash()[fieldNameTest][0]
                   1068:                     self._v_mapHash[ct][fieldNameTest]=fieldName
                   1069:             if not fieldName:
                   1070:                 fieldName=fieldNameTest  
                   1071:             if not empty:
                   1072:                            #FIXME: warum gibt es manchmal kein metadatahas
                   1073:                 try:
                   1074:                     
                   1075:                     ret =self.metaDataHash.get(fieldName,'!!NOT USED HERE in Type: %s'%normalizeCt(self.contentType))
                   1076:                 except:
                   1077:                     logger("ECHO (line 1069)",logging.ERROR,"no md hash for %s"%self.getId()) 
                   1078:                     return ""
                   1079:                   
                   1080:             else:
                   1081: 
                   1082:                    
                   1083:                    ret= self.metaDataHash.get(fieldNameTest,empty)
1.6     ! dwinter  1084:            
1.1       dwinter  1085:             return unicodify(ret)
                   1086: 
                   1087:     getFieldValue=getMDValue #depricated
                   1088: 
                   1089:     def newMetaXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None,digiliburlprefix=None):
                   1090:             """new index.meta"""
                   1091:             self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
                   1092: 
                   1093:             if not hasattr(self,'metaDataHash'):
                   1094:                 
                   1095:                     self.copyIndex_meta2echo_resource()
                   1096:             try:
                   1097: 
                   1098: 
                   1099:                     return writeMetadata(self.metalink,self.OSAS_meta,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix=digiliburlprefix)
                   1100:             except:
                   1101:                     #print self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix
                   1102: 
                   1103:                     return writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix=digiliburlprefix)
                   1104: 
                   1105:     def showMetaDataXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None):
                   1106:             """return bibliographical metadata as stored in the object"""
                   1107:             
                   1108:             try:
                   1109:                     
                   1110:                     return writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,xmlfrag="yes")
                   1111:             except:
                   1112:                     return "<error> no metadata stored</error>"
                   1113:     
                   1114:     def getXQueryMetaData(self,xquery):
                   1115:                 '''
                   1116:                 execute an xquery on the metadata and returns a list of tuples, 
                   1117:                 each tuple represent the content of the node as text and the whole node as xml-fragment
                   1118:                 @param xquery: xquery auf den metadaten
                   1119:                 '''
                   1120:                 
                   1121:                 try:
                   1122:                         md=writeMetadata(self.metalink,self.metaDataHash,xmlfrag="yes")
                   1123:                 except:
                   1124:                         return None
                   1125: 
                   1126:                 dom = NonvalidatingReader.parseString(md,"http://www.mpiwg-berlin.mpg.de/")
                   1127:                 
                   1128:                 results=Ft.Xml.XPath.Evaluate(xquery, contextNode=dom)
                   1129:             
                   1130:                 ret=[]
                   1131:                 for result in results:
                   1132:                     
                   1133:                     buf = cStringIO.StringIO()
                   1134:                     PrettyPrint(result, stream=buf)
                   1135:                     str = buf.getvalue()[0:]
                   1136:                     buf.close()
                   1137:                     ret.append((getTextFromNode(result),str)) 
                   1138:                         
                   1139:                 return ret
                   1140:         
                   1141:     def getMetaDataXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None):
                   1142:             """prints out metadata as stored in the echo environment, format is the index.meta format"""
                   1143:             self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
                   1144:             return writeMetadata(self.metalink,self.metaDataHash)
                   1145: 
                   1146:     def getMetaDataLink(self):
                   1147:         """get link to the meta data"""
                   1148:         return self.metalink
                   1149:     
                   1150:     def changeECHO_resource(self,metalink,link,title,label,description,contentType,responsible,weight,coords=None,credits=None,RESPONSE=None):
                   1151:         """Aenderung der Properties"""
                   1152:         
                   1153:         setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight)
                   1154:         self.link=link
                   1155:         self.metalink=metalink
                   1156:         
                   1157:         if RESPONSE is not None:
                   1158:             RESPONSE.redirect('manage_main')
                   1159:             
                   1160:             
                   1161:     manage_options = (
                   1162:         {'label':'Main Config','action':'ECHO_resource_config_main'},
                   1163:         {'label':'Change Local Metadata','action':'ECHO_resource_config_metadata'},
                   1164:         {'label':'Sync Metadata with Repository','action':'ECHO_getResourceMD'},
                   1165:         {'label':'Graphic Coords','action':'ECHO_graphicEntry'},
                   1166:         {'label':'Change TemplateSets and Image Viewer','action':'changeViewerTemplateSetForm'},
                   1167:         {'label':'set/change startpage','action':'setStartPageForm'},
                   1168:         {'label':'Copy MD for indexing and search','action':'copySearchFields'},
                   1169:         {'label':'Change AccessRights','action':'changeAccessRightForm'}, 
                   1170:         ) + Folder.manage_options
                   1171: 
                   1172: 
                   1173:     def isDefinedInThisSet(self,fields,field):
                   1174:             """checks if field is defined in fields"""
                   1175:             if (fields[0].has_key(field)) and not (fields[0][field]==""):
                   1176:                     return 1
                   1177:             else:
                   1178:                   
                   1179:                     return 0
                   1180:             
                   1181:     def getFieldLabel(self,fields,field):
                   1182:         """get labels"""
                   1183:         try:
                   1184:             ret =fields[0][field]
                   1185:             if ret == "":
                   1186:                 return field
                   1187:             else:
                   1188:                 return ret
                   1189:         except:
                   1190:             return field
                   1191: 
                   1192: 
                   1193: 
                   1194:     def getFieldTag(self,fields,field):
                   1195:         """get labels"""
                   1196:         try:
                   1197:             ret =fields[0][field]
                   1198:             if ret == "":
                   1199:                 return field
                   1200:             else:
                   1201:                 return ret
                   1202:         except:
                   1203:             return field
                   1204: 
                   1205:     
                   1206: 
                   1207:     def getMetaDataHash(self):
                   1208:             """md hash"""
1.6     ! dwinter  1209:            
        !          1210:             return getattr(self,'metaDataHash',{})
1.1       dwinter  1211:     
                   1212:     def setFieldValue(self,field,value):
                   1213:         """get value"""
                   1214:         #TODO: remove setFieldValue
                   1215:         
                   1216:         if not hasattr(self,'metaDataHash'):
                   1217:                 setattr(self,'metaDataHash',{})
                   1218:         self.metaDataHash[field]=value[0:]
                   1219: 
                   1220:     def copySearchFields(self):
                   1221:             """copys metadatafields to the object"""
1.6     ! dwinter  1222:             
        !          1223:             # Zunaechst die gnerischen felder
1.1       dwinter  1224:             fields=['author','title','year']
                   1225:             for field in fields:
1.6     ! dwinter  1226:                setattr(self,'MD_'+field,self.getMDValue(field,generic="yes"))
        !          1227:                     
        !          1228:            # jetzt die spezifischen
        !          1229:            for field in self.getMetaDataHash().keys():
        !          1230:                    if not (field in fields):
        !          1231:                        logging.debug("ECHO_resource (copySearchFields) mapping: "+field)
        !          1232:                        setattr(self,'MD_'+field,self.getMDValue(field))
        !          1233:    
        !          1234:            
        !          1235:              
1.1       dwinter  1236: 
                   1237:     def findLabelsFromMapping(self,referenceType):
                   1238:         """gib hash mit label -> generic zurueck"""
                   1239:         #return {},[]
                   1240: 
                   1241:         temp=self.ZopeFind(self.standardMD)
                   1242: 
                   1243:         if referenceType=="":
                   1244:                 referenceType="book"
                   1245:         
                   1246:         
                   1247:         bibdata={}
                   1248:         retdata={}
                   1249:         fields=[]
                   1250:         fieldlist=self.standardMD.fieldList
                   1251: 
                   1252:         tags=self.findTagsFromMapping(normalizeCt(self.contentType))
1.6     ! dwinter  1253:         logging.debug("ECHO_resource(findLabelsFromMapping)"+repr(tags))
1.1       dwinter  1254:         self.referencetypes=tags[2]
                   1255:         for referenceTypeF in self.referencetypes:
                   1256:                 
1.6     ! dwinter  1257:                 logging.debug("--- compare"+normalizeCt(referenceTypeF[1].title)+normalizeCt(referenceType.lower()))
1.1       dwinter  1258:                 if normalizeCt(referenceTypeF[1].title) == normalizeCt(referenceType.lower()):
1.6     ! dwinter  1259:                        
1.1       dwinter  1260:                         try:
                   1261:                                 bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
                   1262:                                 referenceType=referenceTypeF[1].title
1.6     ! dwinter  1263:                                 logging.debug("------fields:"+repr(fields))
1.1       dwinter  1264:                         except:
                   1265:                                 bibdata[referenceType]=referenceTypeF[1].fields
                   1266:                 
                   1267: 
                   1268:                         bibdata['data']=referenceTypeF[1]
                   1269:                         fields=bibdata[referenceType]
                   1270:                         for field in fieldlist:
                   1271:                             retdata[field]=referenceTypeF[1].getValue(field)[1]
1.6     ! dwinter  1272:         
1.1       dwinter  1273:         return retdata,fieldlist,temp,fields
                   1274: 
                   1275:     def findTagsFromMapping(self,referenceType):
                   1276:         """gib hash mit label -> generic zurueck"""
                   1277:         
                   1278: 
                   1279:         if referenceType=="":
                   1280:                 referenceType="book"
                   1281:         
                   1282:         temp =  self.ZopeFind(self.standardMD)[0:]
                   1283: 
                   1284:         
                   1285:         #self.referencetypes=temp[0:]
                   1286:         
                   1287:         
                   1288:     
                   1289: 
                   1290:         bibdata={}
                   1291:         retdata={}
                   1292:         fieldlist=self.standardMD.fieldList
                   1293:         fields=[]
                   1294:         for referenceTypeF in temp:
                   1295:                 #print referenceType
                   1296:         
                   1297:                 if normalizeCt(referenceTypeF[1].title) == normalizeCt(referenceType.lower()):
                   1298:                         try:
                   1299:                                 bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
                   1300:                                 referenceType=referenceTypeF[1].title
                   1301:                         except:
1.6     ! dwinter  1302:                                logging.debug("Error in ECHOresource(findTagsFromMapping): %s %s"%(sys.exc_info[0],sys.exc_info[1]))
        !          1303:                                bibdata[referenceType]=referenceTypeF[1].fields
1.1       dwinter  1304:                         bibdata['data']=referenceTypeF[1]
                   1305:                         fields=bibdata[referenceType]
                   1306:                         for field in fieldlist:
                   1307:                             retdata[field]=referenceTypeF[1].getValue(field)[0]
                   1308:         
                   1309:         return retdata,fieldlist,temp,fields
                   1310: 
                   1311:     
                   1312:     security.declarePublic('copyIndex_meta2echo_resource') # has to be change, presentlyset because of OSAS koordination
                   1313:     def copyIndex_meta2echo_resource(self,RESPONSE=None):
                   1314:             """copy MD von Index_meta to the echo_resource"""
                   1315:             
                   1316:             (metadict, error)=readMetadata(self.metalink)
                   1317: 
                   1318: 
                   1319:             
                   1320:             self.metaDataHash={}
                   1321:             if not error=="": #Fehler beim Auslesen des Metafiles
                   1322:                     
                   1323:                     return "ERROR:",error,self.absolute_url()
                   1324:             
                   1325:             self.contentType=normalizeCt(metadict['bib_type'])[0:]
                   1326:             fields=self.findTagsFromMapping(normalizeCt(self.contentType))
                   1327:             
                   1328:             #fields=self.findLabelsFromMapping(normalizeCt(self.contentType))
                   1329:             for field in fields[1]:
                   1330:                     
                   1331:                     if self.isDefinedInThisSet(fields,field):
                   1332:                             #print urllib.unquote(metadict.get(self.getFieldTag(fields,field),''))
                   1333:                             self.setFieldValue(self.getFieldTag(fields,field),metadict.get(self.getFieldTag(fields,field),''))
                   1334: 
                   1335:             
                   1336:             
                   1337:             if RESPONSE:
                   1338:                     return RESPONSE.redirect('manage_main')
                   1339:             
                   1340:             return "OK:",self.absolute_url(),normalizeCt(self.contentType)
                   1341:         
                   1342:     def ECHO_getResourceMD(self,template="yes",back=None,overwrite="no"):
                   1343:         """Einlesen der Metadaten und Anlegen dieser Metadaten als Informationen zur Resource"""
                   1344:         (metadict, error)=readMetadata(self.metalink)
1.6     ! dwinter  1345:       
1.1       dwinter  1346:         if back:
                   1347:             self.REQUEST.SESSION['back']=back
                   1348: 
                   1349:         if not error=="": #Fehler beim Auslesen des Metafiles
                   1350:                 return "ERROR:",error
                   1351:         
                   1352:         if (not self.contentType) or (overwrite=="yes"):
                   1353:                 self.contentType=normalizeCt(normalizeCt(metadict['bib_type']).lower())
                   1354:                 
                   1355:         if not (normalizeCt(metadict['bib_type']).lower()==normalizeCt(self.contentType).lower()):
                   1356:                 self.REQUEST.SESSION['contentStorage']=normalizeCt(metadict['bib_type'])
                   1357:                 self.REQUEST.SESSION['contentZope']=normalizeCt(self.contentType)
                   1358: 
                   1359:                 return zptFile(self, 'zpt/ECHO_getResourceMDErrorContentType.zpt')()
                   1360: 
                   1361:         #self.REQUEST.SESSION['metadict']=metadict
                   1362:         
                   1363:         
                   1364:         
                   1365: 
                   1366:         self.REQUEST.SESSION['diffs']=checkDiffs(self,metadict)
                   1367: 
                   1368: 
                   1369:         if template=="yes":
                   1370:                 #pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/ECHO_resourceMD.zpt'),metadict=metadict).__of__(self)
                   1371:                 pt=zptFile(self, 'zpt/ECHO_resourceMD.zpt')
                   1372:                 
                   1373:                 return pt(metadict=metadict)
                   1374: 
                   1375:         
                   1376: 
                   1377:     
                   1378:     
                   1379:     def ECHO_getMD(self,item):
                   1380:         """Ausgabe der MD"""
                   1381:         return getattr(self,item)
                   1382: 
                   1383:     def checkRDF(self,path):
                   1384:             """check if pdf in the path"""
                   1385:             try:
                   1386:                     for fileName in os.listdir(path):
                   1387:                             if os.path.splitext(fileName)[1]==".pdf":
                   1388:                                     return os.path.join(path,fileName)
                   1389:                     return None
                   1390:             except:
                   1391:                     return None
                   1392:             
                   1393:             
                   1394:     security.declareProtected('View','index_html')
                   1395:     def index_html(self):
                   1396:         """standard page"""
                   1397:         pdf=self.checkRDF(self.link)
                   1398:         if pdf:
                   1399:                 fh=file(pdf,'r').read()
                   1400:                 self.REQUEST.RESPONSE.setHeader('Content-Type','application/pdf')
                   1401:                 self.REQUEST.RESPONSE.write(fh)
                   1402:                 self.REQUEST.RESPONSE.close()
                   1403:                 return 
                   1404:             
                   1405:         if getattr(self,'newViewer',''): #benutze den neuen viewer
                   1406:             url=self.newViewer+'url='+self.metalink+"&mode=texttool"
                   1407:             return self.REQUEST.RESPONSE.redirect(url)
                   1408:             
                   1409:         return self.REQUEST.RESPONSE.redirect(self.link)
                   1410: 
                   1411:     def startpage_html(self):
                   1412:             """prints out a startpage for a resource for use e.g. in the BVE"""
                   1413: 
                   1414:             # suche ob startpage.html in dem Ordner vorhanden ist, dann wir diese angezeigt
                   1415: 
                   1416:             sp=self.ZopeFind(self,obj_ids=['startpage.html'])
                   1417: 
                   1418:             if sp:
                   1419:                     return sp[1]()
                   1420: 
                   1421:             #pruefen ob irgendwo ein template
                   1422:             if hasattr(self,'startpage_index_template'): 
                   1423:                     return self.startpage_index_template()
                   1424: 
                   1425:             #generisches template ausgeben
                   1426:             
                   1427:             pt=zptFile(self, 'zpt/ECHO_startpage_index_template_standard.zpt')
                   1428:             pt.content_type="text/html"
                   1429:             return pt()
                   1430: 
                   1431:     def toc_html(self):
                   1432:             
                   1433:             sp=self.ZopeFind(self,obj_ids=['toc.html'])
                   1434:                     
                   1435:             if sp:
                   1436:                     return sp[0][1]()
                   1437: 
                   1438: 
                   1439:     security.declarePublic('generate_label') # has to be change, presentlyset because of OSAS koordination
                   1440: 
                   1441:     def generate_label(self):
                   1442:         """Erzeugt_standard_Label aus Template"""
                   1443:         pt=getattr(self,"label_template_"+normalizeCt(self.contentType).lower())
                   1444: 
                   1445:         self.label=pt()[0:]
                   1446:         return pt()
                   1447: 
                   1448:     security.declarePublic('generate_title') # has to be change, presentlyset because of OSAS koordination
                   1449: 
                   1450:     def generate_title(self,RESPONSE=None):
                   1451:         """Erzeugt_standard_Label aus Template"""
                   1452:         pt=getattr(self,"label_template_"+normalizeCt(self.contentType).lower())
                   1453: 
                   1454:         self.title=pt()[0:]
                   1455:         
                   1456:         return pt()
                   1457: 
                   1458: Globals.InitializeClass(ECHO_resource)
                   1459: 
                   1460: def manage_addECHO_resourceForm(self):
                   1461:         """Form for adding a ressource"""
                   1462:         pt=zptFile(self, 'zpt/AddECHO_resourceForm.zpt')
                   1463:         return pt()
                   1464: 
                   1465: 
                   1466: 
                   1467: 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):
                   1468:     """addresource"""
                   1469: 
                   1470:     newObj=ECHO_resource(id,link,metalink,resourceID,title,label,description,contentType,renderingType,copyrightType,responsible,credits,weight,coords)
                   1471: 
                   1472:     self._setObject(id,newObj)
                   1473: 
                   1474:     if RESPONSE is not None:
                   1475:         RESPONSE.redirect('manage_main')
                   1476:  

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