--- documentViewer/documentViewer.py 2006/04/06 17:13:43 1.3 +++ documentViewer/documentViewer.py 2011/08/02 16:29:15 1.175.2.15 @@ -1,58 +1,109 @@ - -genericDigilib="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/" - from OFS.Folder import Folder from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate -from Products.PageTemplates.PageTemplateFile import PageTemplateFile +from Products.PageTemplates.PageTemplateFile import PageTemplateFile from AccessControl import ClassSecurityInfo +from AccessControl import getSecurityManager from Globals import package_home -from Ft.Xml.Domlette import NonvalidatingReader -from Ft.Xml.Domlette import PrettyPrint, Print -from Ft.Xml import EMPTY_NAMESPACE +#from Ft.Xml import EMPTY_NAMESPACE, Parse +#import Ft.Xml.Domlette -import Ft.Xml.XPath +import xml.etree.ElementTree as ET import os.path -import cgi +import sys import urllib -import zLOG - -def getTextFromNode(nodename): - nodelist=nodename.childNodes - rc = "" - for node in nodelist: - if node.nodeType == node.TEXT_NODE: - rc = rc + node.data - return rc - -import socket - -def urlopen(url): - """urlopen mit timeout""" - socket.setdefaulttimeout(2) - ret=urllib.urlopen(url) - socket.setdefaulttimeout(5) - return ret - -def getParamFromDigilib(path,param): - """gibt param von dlInfo aus""" - imageUrl=genericDigilib+"/dirInfo-xml.jsp?mo=dir&fn="+path - - zLOG.LOG("documentViewer (getparamfromdigilib)", zLOG.INFO, "dirInfo (%s) from %s"%(param,imageUrl)) - +import logging +import math +import urlparse +import re +import string + +from SrvTxtUtils import getInt, getText, getHttpData + +def logger(txt,method,txt2): + """logging""" + logging.info(txt+ txt2) + + +def serializeNode(node, encoding="utf-8"): + """returns a string containing node as XML""" + s = ET.tostring(node) + + # 4Suite: + # stream = cStringIO.StringIO() + # Ft.Xml.Domlette.Print(node, stream=stream, encoding=encoding) + # s = stream.getvalue() + # stream.close() + return s + +def browserCheck(self): + """check the browsers request to find out the browser type""" + bt = {} + ua = self.REQUEST.get_header("HTTP_USER_AGENT") + bt['ua'] = ua + bt['isIE'] = False + bt['isN4'] = False + bt['versFirefox']="" + bt['versIE']="" + bt['versSafariChrome']="" + bt['versOpera']="" + + if string.find(ua, 'MSIE') > -1: + bt['isIE'] = True + else: + bt['isN4'] = (string.find(ua, 'Mozilla/4.') > -1) + # Safari oder Chrome identification try: - dom = NonvalidatingReader.parseUri(imageUrl) - except: - return None - - params=dom.xpath("//dir/%s"%param) - zLOG.LOG("documentViewer (getparamfromdigilib)", zLOG.INFO, "dirInfo:%s"%params) - - if params: - return getTextFromNode(params[0]) - - + nav = ua[string.find(ua, '('):] + nav1=ua[string.find(ua,')'):] + nav2=nav1[string.find(nav1,'('):] + nav3=nav2[string.find(nav2,')'):] + ie = string.split(nav, "; ")[1] + ie1 =string.split(nav1, " ")[2] + ie2 =string.split(nav3, " ")[1] + ie3 =string.split(nav3, " ")[2] + if string.find(ie3, "Safari") >-1: + bt['versSafariChrome']=string.split(ie2, "/")[1] + except: pass + # IE identification + try: + nav = ua[string.find(ua, '('):] + ie = string.split(nav, "; ")[1] + if string.find(ie, "MSIE") > -1: + bt['versIE'] = string.split(ie, " ")[1] + except:pass + # Firefox identification + try: + nav = ua[string.find(ua, '('):] + nav1=ua[string.find(ua,')'):] + if string.find(ie1, "Firefox") >-1: + nav5= string.split(ie1, "/")[1] + logging.debug("FIREFOX: %s"%(nav5)) + bt['versFirefox']=nav5[0:3] + except:pass + #Opera identification + try: + if string.find(ua,"Opera") >-1: + nav = ua[string.find(ua, '('):] + nav1=nav[string.find(nav,')'):] + bt['versOpera']=string.split(nav1,"/")[2] + except:pass + + bt['isMac'] = string.find(ua, 'Macintosh') > -1 + bt['isWin'] = string.find(ua, 'Windows') > -1 + bt['isIEWin'] = bt['isIE'] and bt['isWin'] + bt['isIEMac'] = bt['isIE'] and bt['isMac'] + bt['staticHTML'] = False + + return bt + +def getParentPath(path, cnt=1): + """returns pathname shortened by cnt""" + # make sure path doesn't end with / + path = path.rstrip('/') + # split by /, shorten, and reassemble + return '/'.join(path.split('/')[0:-cnt]) ## @@ -60,362 +111,653 @@ def getParamFromDigilib(path,param): ## class documentViewer(Folder): """document viewer""" - meta_type="Document viewer" security=ClassSecurityInfo() manage_options=Folder.manage_options+( {'label':'main config','action':'changeDocumentViewerForm'}, ) + + metadataService = None + """MetaDataFolder instance""" # templates and forms viewer_main = PageTemplateFile('zpt/viewer_main', globals()) - thumbs_main = PageTemplateFile('zpt/thumbs_main', globals()) - image_main = PageTemplateFile('zpt/image_main', globals()) + toc_thumbs = PageTemplateFile('zpt/toc_thumbs', globals()) + toc_text = PageTemplateFile('zpt/toc_text', globals()) + toc_figures = PageTemplateFile('zpt/toc_figures', globals()) + page_main_images = PageTemplateFile('zpt/page_main_images', globals()) + page_main_double = PageTemplateFile('zpt/page_main_double', globals()) + page_main_text = PageTemplateFile('zpt/page_main_text', globals()) + page_main_text_dict = PageTemplateFile('zpt/page_main_text_dict', globals()) + page_main_gis =PageTemplateFile ('zpt/page_main_gis', globals()) + page_main_xml = PageTemplateFile('zpt/page_main_xml', globals()) + page_main_pureXml = PageTemplateFile('zpt/page_main_pureXml', globals()) head_main = PageTemplateFile('zpt/head_main', globals()) docuviewer_css = PageTemplateFile('css/docuviewer.css', globals()) - - security.declareProtected('View management screens','changeDocumentViewerForm') - changeDocumentViewerForm = PageTemplateFile('zpt/changeDocumentViewer', globals()) + info_xml = PageTemplateFile('zpt/info_xml', globals()) + + + thumbs_main_rss = PageTemplateFile('zpt/thumbs_main_rss', globals()) - def __init__(self,id,imageViewerUrl,title="",digilibBaseUrl=None): + def __init__(self,id,imageScalerUrl=None,textServerName=None,title="",digilibBaseUrl=None,thumbcols=2,thumbrows=5,authgroups="mpiwg"): """init document viewer""" self.id=id self.title=title - self.imageViewerUrl=imageViewerUrl - self.digilibBaseUrl = digilibBaseUrl - if not self.digilibBaseUrl: - self.digilibBaseUrl = self.findDigilibUrl() - # add template folder so we can always use template.something - self.manage_addFolder('template') + self.thumbcols = thumbcols + self.thumbrows = thumbrows + # authgroups is list of authorized groups (delimited by ,) + self.authgroups = [s.strip().lower() for s in authgroups.split(',')] + # create template folder so we can always use template.something + + templateFolder = Folder('template') + #self['template'] = templateFolder # Zope-2.12 style + self._setObject('template',templateFolder) # old style + try: + import MpdlXmlTextServer + textServer = MpdlXmlTextServer.MpdlXmlTextServer(id='fulltextclient',serverName=textServerName) + #templateFolder['fulltextclient'] = xmlRpcClient + templateFolder._setObject('fulltextclient',textServer) + except Exception, e: + logging.error("Unable to create MpdlXmlTextServer for fulltextclient: "+str(e)) + + try: + from Products.zogiLib.zogiLib import zogiLib + zogilib = zogiLib(id="zogilib", title="zogilib for docuviewer", dlServerURL=imageScalerUrl, layout="book") + #templateFolder['zogilib'] = zogilib + templateFolder._setObject('zogilib',zogilib) + except Exception, e: + logging.error("Unable to create zogiLib for zogilib: "+str(e)) + + try: + # assume MetaDataFolder instance is called metadata + self.metadataService = getattr(self, 'metadata') + except Exception, e: + logging.error("Unable to find MetaDataFolder 'metadata': "+str(e)) + + + # proxy text server methods to fulltextclient + def getTextPage(self, **args): + """get page""" + return self.template.fulltextclient.getTextPage(**args) + + def getOrigPages(self, **args): + """get page""" + return self.template.fulltextclient.getOrigPages(**args) + + def getOrigPagesNorm(self, **args): + """get page""" + return self.template.fulltextclient.getOrigPagesNorm(**args) + + def getQuery(self, **args): + """get query in search""" + return self.template.fulltextclient.getQuery(**args) + + def getSearch(self, **args): + """get search""" + return self.template.fulltextclient.getSearch(**args) + + def getGisPlaces(self, **args): + """get gis places""" + return self.template.fulltextclient.getGisPlaces(**args) + + def getAllGisPlaces(self, **args): + """get all gis places """ + return self.template.fulltextclient.getAllGisPlaces(**args) + + def getTranslate(self, **args): + """get translate""" + return self.template.fulltextclient.getTranslate(**args) + def getLemma(self, **args): + """get lemma""" + return self.template.fulltextclient.getLemma(**args) - security.declareProtected('View','index_html') - def index_html(self,mode,url,start=0,pn=1): + def getLemmaQuery(self, **args): + """get query""" + return self.template.fulltextclient.getLemmaQuery(**args) + + def getLex(self, **args): + """get lex""" + return self.template.fulltextclient.getLex(**args) + + def getToc(self, **args): + """get toc""" + return self.template.fulltextclient.getToc(**args) + + def getTocPage(self, **args): + """get tocpage""" + return self.template.fulltextclient.getTocPage(**args) + + + security.declareProtected('View','thumbs_rss') + def thumbs_rss(self,mode,url,viewMode="auto",start=None,pn=1): ''' view it - @param mode: defines which type of document is behind url + @param mode: defines how to access the document behind url @param url: url which contains display information - ''' + @param viewMode: if images display images, if text display text, default is images (text,images or auto) - zLOG.LOG("documentViewer (index)", zLOG.INFO, "mode: %s url:%s start:%s pn:%s"%(mode,url,start,pn)) - print "dlbaseurl:", self.digilibBaseUrl + ''' + logging.debug("HHHHHHHHHHHHHH:load the rss") + logging.debug("documentViewer (index) mode: %s url:%s start:%s pn:%s"%(mode,url,start,pn)) if not hasattr(self, 'template'): # create template folder if it doesn't exist - print "no template folder -- creating" self.manage_addFolder('template') if not self.digilibBaseUrl: self.digilibBaseUrl = self.findDigilibUrl() or "http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary" - print "dlbaseurl:", self.digilibBaseUrl + docinfo = self.getDocinfo(mode=mode,url=url) + #pageinfo = self.getPageinfo(start=start,current=pn,docinfo=docinfo) + pageinfo = self.getPageinfo(start=start,current=pn, docinfo=docinfo) + ''' ZDES ''' + pt = getattr(self.template, 'thumbs_main_rss') + + if viewMode=="auto": # automodus gewaehlt + if docinfo.has_key("textURL") or docinfo.get('textURLPath',None): #texturl gesetzt und textViewer konfiguriert + viewMode="text" + else: + viewMode="images" + + return pt(docinfo=docinfo,pageinfo=pageinfo,viewMode=viewMode) - docinfo = self.getDocinfo(mode=mode, url=url) - pageinfo = self.getPageinfo(start=start,current=pn) - pt = getattr(self.template, 'viewer_main') - return pt(docinfo=docinfo,pageinfo=pageinfo) - - def imageLink(self,nr): - """link hinter den images""" - paramsTmp=cgi.parse_qs(self.REQUEST['QUERY_STRING']) - params={} - for x in paramsTmp.iteritems(): - params[x[0]]=x[1][0] - - params['pn']=nr - newUrl=self.REQUEST['URL']+"?"+urllib.urlencode(params) - return newUrl + security.declareProtected('View','index_html') + def index_html(self,url,mode="texttool",viewMode="auto",tocMode="thumbs",start=None,pn=1,mk=None): + """ + view it + @param mode: defines how to access the document behind url + @param url: url which contains display information + @param viewMode: if images display images, if text display text, default is auto (text,images or auto) + @param tocMode: type of 'table of contents' for navigation (thumbs, text, figures, none) + """ - def getStyle(self, idx, selected, style=""): - """returns a string with the given style + 'sel' if path == selected.""" - #zLOG.LOG("documentViewer (getstyle)", zLOG.INFO, "idx: %s selected: %s style: %s"%(idx,selected,style)) - if idx == selected: - return style + 'sel' - else: - return style - + logging.debug("documentViewer (index) mode: %s url:%s start:%s pn:%s"%(mode,url,start,pn)) + + if not hasattr(self, 'template'): + # this won't work + logging.error("template folder missing!") + return "ERROR: template folder missing!" - def thumbruler(self,cols,rows,start,maximum): - """ruler for thumbs""" - ret="" - paramsTmp=cgi.parse_qs(self.REQUEST['QUERY_STRING']) - params={} - for x in paramsTmp.iteritems(): - - if not x[0]=="start": - params[x[0]]=x[1][0] - - newUrlSelect=self.REQUEST['URL']+"?"+urllib.urlencode(params) - if start>0: - newStart=max(start-cols*rows,0) - params['start']=newStart - newUrl=self.REQUEST['URL']+"?"+urllib.urlencode(params) - ret+="""prev"""%newUrl - - - ret+="""" + if not getattr(self, 'digilibBaseUrl', None): + self.digilibBaseUrl = self.findDigilibUrl() or "http://digilib.mpiwg-berlin.mpg.de/digitallibrary" + + docinfo = self.getDocinfo(mode=mode,url=url) - if startnext"""%newUrl + if tocMode != "thumbs": + # get table of contents + docinfo = self.getToc(mode=tocMode, docinfo=docinfo) + + # auto viewMode: text_dict if text else images + if viewMode=="auto": + if docinfo.get('textURL', None) or docinfo.get('textURLPath', None): + viewMode="text_dict" + else: + viewMode="images" + + pageinfo = self.getPageinfo(start=start, current=pn, docinfo=docinfo, viewMode=viewMode, tocMode=tocMode) + if viewMode != 'images' and docinfo.get('textURLPath', None): + # get full text page + page = self.getTextPage(mode=viewMode, pn=pn, docinfo=docinfo, pageinfo=pageinfo) + pageinfo['textPage'] = page + + # get template /template/viewer_main + pt = getattr(self.template, 'viewer_main') + # and execute with parameters + return pt(docinfo=docinfo, pageinfo=pageinfo, viewMode=viewMode, mk=self.generateMarks(mk)) + + def generateMarks(self,mk): + ret="" + if mk is None: + return "" + if not isinstance(mk, list): + mk=[mk] + for m in mk: + ret+="mk=%s"%m return ret + + def getBrowser(self): + """getBrowser the version of browser """ + bt = browserCheck(self) + logging.debug("BROWSER VERSION: %s"%(bt)) + return bt - - def getBibinfoFromIndexMeta(self,path,docinfo=None,dom=None): - """gets bibliographical info from the index.meta file at url or given by dom""" - zLOG.LOG("documentViewer (getbibinfofromindexmeta)", zLOG.INFO,"path: %s"%(path)) - - if docinfo is None: - docinfo = {} - - metaData=self.metadata.main.meta.bib - if dom is None: - server="http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary/servlet/Texter?fn=" - path="/".join(path.split("/")[0:-1]) - metaUrl=server+path+"/index.meta" - try: - dom = NonvalidatingReader.parseUri(metaUrl) - except: - return docinfo - - type=dom.xpath("//bib/@type") - if type and (len(type)>0): - type=type[0].value + def findDigilibUrl(self): + """try to get the digilib URL from zogilib""" + url = self.template.zogilib.getDLBaseUrl() + return url + + def getDocumentViewerURL(self): + """returns the URL of this instance""" + return self.absolute_url() + + def getStyle(self, idx, selected, style=""): + """returns a string with the given style and append 'sel' if path == selected.""" + #logger("documentViewer (getstyle)", logging.INFO, "idx: %s selected: %s style: %s"%(idx,selected,style)) + if idx == selected: + return style + 'sel' else: - type="generic" - type=type.replace("-"," ")# wrong typesiin index meta "-" instead of " " - hash=metaData.generateMappingForType(type) - - docinfo['author']=getTextFromNode(dom.xpath("//bib/%s"%hash['author'][0])[0]) - docinfo['title']=getTextFromNode(dom.xpath("//bib/%s"%hash['title'][0])[0]) - docinfo['year']=getTextFromNode(dom.xpath("//bib/%s"%hash['year'][0])[0]) - - return docinfo + return style + + def getLink(self, param=None, val=None, params=None, baseUrl=None, paramSep='&'): + """returns URL to documentviewer with parameter param set to val or from dict params""" + # copy existing request params + urlParams=self.REQUEST.form.copy() + # change single param + if param is not None: + if val is None: + if urlParams.has_key(param): + del urlParams[param] + else: + urlParams[param] = str(val) + + # change more params + if params is not None: + for k in params.keys(): + v = params[k] + if v is None: + # val=None removes param + if urlParams.has_key(k): + del urlParams[k] + + else: + urlParams[k] = v + + # FIXME: does this belong here? + if urlParams.get("mode", None) == "filepath": #wenn beim erst Aufruf filepath gesetzt wurde aendere das nun zu imagepath + urlParams["mode"] = "imagepath" + urlParams["url"] = getParentPath(urlParams["url"]) + + # quote values and assemble into query string (not escaping '/') + ps = paramSep.join(["%s=%s"%(k,urllib.quote_plus(v,'/')) for (k, v) in urlParams.items()]) + #ps = urllib.urlencode(urlParams) + if baseUrl is None: + baseUrl = self.REQUEST['URL1'] + + url = "%s?%s"%(baseUrl, ps) + return url + + def getLinkAmp(self, param=None, val=None, params=None, baseUrl=None): + """link to documentviewer with parameter param set to val""" + return self.getLink(param, val, params, baseUrl, '&') + + def getInfo_xml(self,url,mode): + """returns info about the document as XML""" + if not self.digilibBaseUrl: + self.digilibBaseUrl = self.findDigilibUrl() or "http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary" - def getDocinfoFromTextTool(self,url,docinfo=None): - """parse texttool tag in index meta""" - zLOG.LOG("documentViewer (getdocinfofromtexttool)", zLOG.INFO,"url: %s"%(url)) - if docinfo is None: - docinfo = {} - - try: - dom = NonvalidatingReader.parseUri(url) - except: - zLOG.LOG("documentViewer (parseUrlTexttool)", zLOG.INFO,"%s (%s)"%sys.exc_info()[0:2]) - return docinfo - - archivePaths=dom.xpath("//resource/archive-path") - - if archivePaths and (len(archivePaths)>0): - archivePath=getTextFromNode(archivePaths[0]) - else: - archivePath=None - - images=dom.xpath("//texttool/image") - - if images and (len(images)>0): - image=getTextFromNode(images[0]) - else: - image=None - - if image and archivePath: - image=os.path.join(archivePath,image) - image=image.replace("/mpiwg/online",'') - pt=getParamFromDigilib(image,'size') - docinfo['imagePath'] = image - docinfo['numberOfPages'] = pt - - viewerUrls=dom.xpath("//texttool/digiliburlprefix") - - if viewerUrls and (len(viewerUrls)>0): - viewerUrl=getTextFromNode(viewerUrls[0]) - docinfo['imageURL'] = viewerURL - - textUrls=dom.xpath("//texttool/text") - - if textUrls and (len(textUrls)>0): - textUrl=getTextFromNode(textUrls[0]) - docinfo['textURL'] = textURL - - docinfo = self.getBibinfoFromIndexMeta(url,docinfo=docinfo,dom=dom) - return docinfo - - - def getDocinfoFromImagePath(self,path,docinfo=None): - """path ist the path to the images it assumes that the index.meta file is one level higher.""" - zLOG.LOG("documentViewer (getdocinfofromimagepath)", zLOG.INFO,"path: %s"%(path)) - if docinfo is None: - docinfo = {} - docinfo['imagePath'] = path - path=path.replace("/mpiwg/online","") - pt=getParamFromDigilib(path,'size') - docinfo['numberOfPages'] = pt - imageUrl=genericDigilib+"/servlet/Scaler?fn=%s"%path - docinfo['imageURL'] = imageUrl + docinfo = self.getDocinfo(mode=mode,url=url) + pt = getattr(self.template, 'info_xml') + return pt(docinfo=docinfo) + + def isAccessible(self, docinfo): + """returns if access to the resource is granted""" + access = docinfo.get('accessType', None) + logging.debug("documentViewer (accessOK) access type %s"%access) + if access == 'free': + logging.debug("documentViewer (accessOK) access is free") + return True + + elif access is None or access in self.authgroups: + # only local access -- only logged in users + user = getSecurityManager().getUser() + logging.debug("documentViewer (accessOK) user=%s ip=%s"%(user,self.REQUEST.getClientAddr())) + if user is not None: + #print "user: ", user + return (user.getUserName() != "Anonymous User") + else: + return False - docinfo = self.getBibinfoFromIndexMeta(path,docinfo=docinfo) - return docinfo - + logging.error("documentViewer (accessOK) unknown access type %s"%access) + return False + + def getDocinfo(self, mode, url): """returns docinfo depending on mode""" - zLOG.LOG("documentViewer (getdocinfo)", zLOG.INFO,"mode: %s, url: %s"%(mode,url)) + logging.debug("getDocinfo: mode=%s, url=%s"%(mode,url)) # look for cached docinfo in session if self.REQUEST.SESSION.has_key('docinfo'): docinfo = self.REQUEST.SESSION['docinfo'] # check if its still current - if docinfo is not None and docinfo.get('mode') == mode and docinfo.get('url') == url: - zLOG.LOG("documentViewer (getdocinfo)", zLOG.INFO,"docinfo in session: %s"%docinfo) + if docinfo is not None and docinfo.get('mode', None) == mode and docinfo.get('url', None) == url: + logging.debug("getDocinfo: docinfo in session. keys=%s"%docinfo.keys()) return docinfo + # new docinfo docinfo = {'mode': mode, 'url': url} - if mode=="texttool": #index.meta with texttool information - docinfo = self.getDocinfoFromTextTool(url, docinfo=docinfo) + # add self url + docinfo['viewerUrl'] = self.getDocumentViewerURL() + # get index.meta DOM + docUrl = None + metaDom = None + if mode=="texttool": + # url points to document dir or index.meta + metaDom = self.metadataService.getDomFromPathOrUrl(url) + docUrl = url.replace('/index.meta', '') + if metaDom is None: + raise IOError("Unable to find index.meta for mode=texttool!") + elif mode=="imagepath": - docinfo = self.getDocinfoFromImagePath(url, docinfo=docinfo) + # url points to folder with images, index.meta optional + # asssume index.meta in parent dir + docUrl = getParentPath(url) + metaDom = self.metadataService.getDomFromPathOrUrl(docUrl) + + elif mode=="filepath": + # url points to image file, index.meta optional + # asssume index.meta is two path segments up + docUrl = getParentPath(url, 2) + metaDom = self.metadataService.getDomFromPathOrUrl(docUrl) + else: - zLOG.LOG("documentViewer (getdocinfo)", zLOG.ERROR,"unknown mode!") - zLOG.LOG("documentViewer (getdocinfo)", zLOG.INFO,"docinfo: %s"%docinfo) + logging.error("documentViewer (getdocinfo) unknown mode: %s!"%mode) + raise ValueError("Unknown mode %s! Has to be one of 'texttool','imagepath','filepath'."%(mode)) + + docinfo['documentUrl'] = docUrl + # process index.meta contents + if metaDom is not None: + # document directory name and path + logging.debug("RESOURCE: %s"%repr(self.metadataService.resource.meta.getData(dom=metaDom, all=True, recursive=2))) + resource = self.metadataService.getResourceData(dom=metaDom) + if resource: + docinfo = self.getDocinfoFromResource(docinfo, resource) + + # texttool info + texttool = self.metadataService.getTexttoolData(dom=metaDom) + if texttool: + docinfo = self.getDocinfoFromTexttool(docinfo, texttool) + + # bib info + bib = self.metadataService.getBibData(dom=metaDom) + if bib: + docinfo = self.getDocinfoFromBib(docinfo, bib) + else: + # no bib - try info.xml + docinfo = self.getDocinfoFromPresentationInfoXml(docinfo) + + # auth info + access = self.metadataService.getAccessData(dom=metaDom) + if access: + docinfo = self.getDocinfoFromAccess(docinfo, access) + + # attribution info + attribution = self.metadataService.getAttributionData(dom=metaDom) + if attribution: + logging.debug("getDocinfo: attribution=%s"%repr(attribution)) + docinfo['attribution'] = attribution + #docinfo = self.getDocinfoFromAccess(docinfo, access) + + # copyright info + copyright = self.metadataService.getCopyrightData(dom=metaDom) + if copyright: + logging.debug("getDocinfo: copyright=%s"%repr(copyright)) + docinfo['copyright'] = copyright + #docinfo = self.getDocinfoFromAccess(docinfo, access) + + # image path + if mode != 'texttool': + # override image path from texttool + docinfo['imagePath'] = url.replace('/mpiwg/online/', '', 1) + + # number of images from digilib + if docinfo.get('imagePath', None): + docinfo['imageURL'] = self.digilibBaseUrl + "/servlet/Scaler?fn=" + docinfo['imagePath'] + docinfo = self.getDocinfoFromDigilib(docinfo, docinfo['imagePath']) + + logging.debug("documentViewer (getdocinfo) docinfo: keys=%s"%docinfo.keys()) + #logging.debug("documentViewer (getdocinfo) docinfo: %s"%docinfo) + # store in session self.REQUEST.SESSION['docinfo'] = docinfo return docinfo - - - def getPageinfo(self, start, current): - """returns pageinfo with the given parameters""" - pageinfo = {} - pageinfo['start'] = start - pageinfo['current'] = current - return pageinfo + + def getDocinfoFromResource(self, docinfo, resource): + """reads contents of resource element into docinfo""" + docName = resource.get('name', None) + docinfo['documentName'] = docName + docPath = resource.get('archive-path', None) + if docPath: + # clean up document path + if docPath[0] != '/': + docPath = '/' + docPath - def text(self,mode,url,pn): - """give text""" - if mode=="texttool": #index.meta with texttool information - (viewerUrl,imagepath,textpath)=parseUrlTextTool(url) + if docName and (not docPath.endswith(docName)): + docPath += "/" + docName + + else: + # use docUrl as docPath + docUrl = docinfo['documentURL'] + if not docUrl.startswith('http:'): + docPath = docUrl + if docPath: + # fix URLs starting with /mpiwg/online + docPath = docPath.replace('/mpiwg/online', '', 1) + + docinfo['documentPath'] = docPath + return docinfo + + def getDocinfoFromTexttool(self, docinfo, texttool): + """reads contents of texttool element into docinfo""" + # image dir + imageDir = texttool.get('image', None) + docPath = docinfo.get('documentPath', None) + if imageDir and docPath: + #print "image: ", imageDir, " archivepath: ", archivePath + imageDir = os.path.join(docPath, imageDir) + imageDir = imageDir.replace('/mpiwg/online', '', 1) + docinfo['imagePath'] = imageDir + + # old style text URL + textUrl = texttool.get('text', None) + if textUrl and docPath: + if urlparse.urlparse(textUrl)[0] == "": #keine url + textUrl = os.path.join(docPath, textUrl) + + docinfo['textURL'] = textUrl + + # new style text-url-path + textUrl = texttool.get('text-url-path', None) + if textUrl: + docinfo['textURLPath'] = textUrl + + # page flow + docinfo['pageFlow'] = texttool.get('page-flow', 'ltr') + + # odd pages are left + docinfo['oddPage'] = texttool.get('odd-scan-orientation', 'left') + + # number of title page + docinfo['titlePage'] = texttool.get('title-scan-no', 0) + + # old presentation stuff + presentation = texttool.get('presentation', None) + if presentation and docPath: + if presentation.startswith('http:'): + docinfo['presentationUrl'] = presentation + else: + docinfo['presentationUrl'] = os.path.join(docPath, presentation) + - print textpath + return docinfo + + def getDocinfoFromBib(self, docinfo, bib): + """reads contents of bib element into docinfo""" + logging.debug("getDocinfoFromBib bib=%s"%repr(bib)) + # put all raw bib fields in dict "bib" + docinfo['bib'] = bib + bibtype = bib.get('@type', None) + docinfo['bibType'] = bibtype + # also store DC metadata for convenience + dc = self.metadataService.getDCMappedData(bib) + docinfo['creator'] = dc.get('creator',None) + docinfo['title'] = dc.get('title',None) + docinfo['date'] = dc.get('date',None) + return docinfo + + def getDocinfoFromAccess(self, docinfo, acc): + """reads contents of access element into docinfo""" + #TODO: also read resource type + logging.debug("getDocinfoFromAccess acc=%s"%repr(acc)) try: - dom = NonvalidatingReader.parseUri(textpath) - except: - return None - - list=[] - nodes=dom.xpath("//pb") + acctype = acc['@attr']['type'] + if acctype: + access=acctype + if access in ['group', 'institution']: + access = acc['name'].lower() + + docinfo['accessType'] = access - node=nodes[int(pn)-1] - - p=node - - while p.tagName!="p": - p=p.parentNode - - - endNode=nodes[int(pn)] - - - e=endNode - - while e.tagName!="p": - e=e.parentNode - - - next=node.parentNode - - #sammle s - while next and (next!=endNode.parentNode): - list.append(next) - next=next.nextSibling - list.append(endNode.parentNode) - - if p==e:# beide im selben paragraphen + except: pass -# else: -# next=p -# while next!=e: -# print next,e -# list.append(next) -# next=next.nextSibling -# -# for x in list: -# PrettyPrint(x) -# -# return list -# - - def image(self,mode,url,pn): - """give image out""" - if mode=="texttool": #index.meta with texttool information - (viewerUrl,imagepath,textpath)=parseUrlTextTool(url) - if not viewerUrl: - viewerUrl=self.imageViewerUrl - url=viewerUrl+"pn=%s&fn=%s"%(pn,imagepath[0]) - ret="""