zogiLib/zogiLib.py - diff

Return to zogiLib.py CVS log

Up to [Repository] / zogiLib

Diff for /zogiLib/zogiLib.py between versions 1.30 and 1.48

version 1.30, 2004/06/25 16:59:45	version 1.48, 2004/10/12 16:58:14
Line 1	Line 1

from Products.PageTemplates.PageTemplateFile import PageTemplateFile	from Products.PageTemplates.PageTemplateFile import PageTemplateFile
from Products.PageTemplates.PageTemplate import PageTemplate	from Products.PageTemplates.PageTemplate import PageTemplate
from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate	from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
Line 7 from webdav.common import rfc1123_date	Line 6 from webdav.common import rfc1123_date

import xml.dom.minidom	import xml.dom.minidom
from OFS.Folder import Folder	from OFS.Folder import Folder
from xml_helpers import getText	from xml_helpers import getUniqueElementText,getText
import os	import os
import re	import re
import string	import string
import urllib	import urllib
import types	import types
	import random
from Globals import package_home	from Globals import package_home

ZOGIVERSION = "0.9.5 ROC:25.6.2004"	ZOGIVERSION = "0.9.10b ROC:12.10.2004"

def cropf(f):	def cropf(f):
"""returns a float with reduced precision"""	"""returns a float with reduced precision"""
Line 23 def cropf(f):	Line 23 def cropf(f):


def sendFile(self, filename, type):	def sendFile(self, filename, type):
"""sends an object or a local file (in the product) as response"""	"""sends an object or a local file (from the product) as response"""
paths = filename.split('/')	paths = filename.split('/')
object = self	object = self
# look for an object called filename	# look for an object called filename
Line 76 class zogiImage(Image):	Line 76 class zogiImage(Image):
"""init"""	"""init"""
self.id=id	self.id=id
self.title=title	self.title=title
	if baseUrl:
self.baseUrl=baseUrl	self.baseUrl=baseUrl
	else:
	self.baseUrl="http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary/servlet/Scaler?"

self.queryString=queryString	self.queryString=queryString
self.content_type=content_type	self.content_type=content_type
self.precondition=precondition	self.precondition=precondition
Line 99 class zogiImage(Image):	Line 103 class zogiImage(Image):
if RESPONSE is not None:	if RESPONSE is not None:
RESPONSE.redirect('manage_main')	RESPONSE.redirect('manage_main')


def index_html(self, REQUEST, RESPONSE):	def index_html(self, REQUEST, RESPONSE):
	"""service the request by redirecting to digilib server"""
	print "REDIRECT: ", self.baseUrl+self.queryString
	RESPONSE.redirect(self.baseUrl+self.queryString)
	return ''

	def index_html2(self, REQUEST, RESPONSE):
"""	"""
Modified version of OFS/Image.py	Modified version of OFS/Image.py

Line 351 class zogiImage(Image):	Line 360 class zogiImage(Image):
# for a cache manager to set response headers.	# for a cache manager to set response headers.
self.ZCacheable_set(None)	self.ZCacheable_set(None)

	#return "zogiimage: "+self.baseUrl+self.queryString
data=urllib.urlopen(self.baseUrl+self.queryString).read()	data=urllib.urlopen(self.baseUrl+self.queryString).read()

if type(data) is type(''):	if type(data) is type(''):
Line 371 def manage_addZogiImageForm(self):	Line 381 def manage_addZogiImageForm(self):


def manage_addZogiImage(self,id,title,baseUrl, queryString,RESPONSE=None):	def manage_addZogiImage(self,id,title,baseUrl, queryString,RESPONSE=None):
"""add dgilib"""	"""add zogiimage"""
newObj=zogiImage(id,title,baseUrl, queryString)	newObj=zogiImage(id,title,baseUrl, queryString)
self.Destination()._setObject(id,newObj)	self.Destination()._setObject(id,newObj)
if RESPONSE is not None:	if RESPONSE is not None:
Line 383 class zogiLib(Folder):	Line 393 class zogiLib(Folder):
"""StandardElement"""	"""StandardElement"""

meta_type="zogiLib"	meta_type="zogiLib"
	#xxxx

manage_options = Folder.manage_options+(	manage_options = Folder.manage_options+(
{'label':'Main Config','action':'changeZogiLibForm'},	{'label':'Main Config','action':'changeZogiLibForm'},
)	)

def __init__(self, id, title, digilibBaseUrl, localFileBase, version="book", basePath="", dlTarget=None):	def __init__(self, id, title, dlServerURL, layout="book", basePath="", dlTarget=None, dlToolbarBaseURL=None):
"""init"""	"""init"""

self.id=id	self.id=id
self.title=title	self.title=title
self.digilibBaseUrl=digilibBaseUrl	self.dlServerURL = dlServerURL
self.localFileBase=localFileBase
self.basePath=basePath	self.basePath=basePath
self.layout=version	self.layout=layout
if dlTarget:
self.dlTarget = dlTarget	self.dlTarget = dlTarget

	if dlToolbarBaseURL:
	self.dlToolbarBaseURL = dlToolbarBaseURL
else:	else:
self.dlTarget = "digilib"	self.dlToolbarBaseURL = dlServerURL + "/digimage.jsp?"


def version(self):	def version(self):
"""version information"""	"""version information"""
return ZOGIVERSION	return ZOGIVERSION

	def getContextStatic(self):
	"""get all the contexts which go to static pages"""

	try:
	dom=xml.dom.minidom.parse(urllib.urlopen(self.getMetaFileName()))
	contexts=dom.getElementsByTagName("context")

	ret=[]
	for context in contexts:
	name=getUniqueElementText(context.getElementsByTagName("name"))

	link=getUniqueElementText(context.getElementsByTagName("link"))
	if name or link:
	ret.append((name,link))
	return ret
	except:
	return []

	def getContextDatabases(self):
	"""get all dynamic contexts"""
	try:
	dom=xml.dom.minidom.parse(urllib.urlopen(self.getMetaFileName()))
	contexts=dom.getElementsByTagName("context")
	ret=[]
	for context in contexts:
	metaDataLinks=context.getElementsByTagName("meta-datalink")
	for metaDataLink in metaDataLinks:
	db=metaDataLink.getAttribute("db")
	link=self.REQUEST['URL1']+"/dl_db?db=%s"%db
	if db:
	ret.append((db,link))
	metaDataLinks=context.getElementsByTagName("meta-baselink")

	for metaDataLink in metaDataLinks:
	db=metaDataLink.getAttribute("db")
	link=self.REQUEST['URL1']+"/dl_db?db=%s"%db
	if db:
	ret.append((db,link))

	return ret
	except:

	return []


	def formatHTML(self,url,label=None,viewUrl=None):

	sets=xml.dom.minidom.parse(urllib.urlopen(url)).getElementsByTagName('dataset')
	ret=""
	print label
	if label:
	ret+="""<a href="%s">%s</a>"""%(viewUrl,label)
	for set in sets:
	ret+="<table>"
	for node in set.childNodes:
	if hasattr(node,'tagName'):
	tag=node.tagName
	label=node.getAttribute("label")
	if not label:
	label=tag
	text=getText(node.childNodes)
	ret+="""<tr><td><b>%s:</b></td><td>%s</td></tr>"""%(label,text)
	ret+="</table>"
	return ret


	def getMetaData(self):
	"""getMetaData"""
	try:
	dom=xml.dom.minidom.parse(urllib.urlopen(self.getMetaFileName()))
	except:
	return "error metadata"

	contexts=dom.getElementsByTagName("context")
	ret=[]
	db=self.getDLParam("db")
	ob=self.getDLParam("object")

	fn=self.getDLParam("fn")
	pn=self.getDLParam("pn")
	if not fn:
	fn=""
	if not pn:
	pn=""
	if not ob:
	ob=""

	for context in contexts:
	metaDataLinks=context.getElementsByTagName("meta-datalink")
	for metaDataLink in metaDataLinks:

	if (db==metaDataLink.getAttribute("db")) or (len(metaDataLinks)==1):

	link=getUniqueElementText(metaDataLink.getElementsByTagName("metadata-url"))
	label=getUniqueElementText(metaDataLink.getElementsByTagName("label"))
	url=getUniqueElementText(metaDataLink.getElementsByTagName("url"))

	return self.formatHTML(link,label,url)

	metaDataLinks=context.getElementsByTagName("meta-baselink")

	for metaDataLink in metaDataLinks:

	if db==metaDataLink.getAttribute("db") or (len(metaDataLinks)==1):

	link=getUniqueElementText(metaDataLink.getElementsByTagName("metadata-url"))
	label=getUniqueElementText(metaDataLink.getElementsByTagName("label"))
	url=getUniqueElementText(metaDataLink.getElementsByTagName("url"))

	return self.formatHTML(link+'fn=%s&pn=%s&object=%s'%(fn,pn,ob),label,url)
	return ret


def getDLInfo(self):	def getDLInfo(self):
"""get DLInfo from digilib server"""	"""get DLInfo from digilib server"""
paramH={}	paramH={}
baseUrl=re.sub("servlet/Scaler","dlInfo-xml.jsp",self.digilibBaseUrl)	baseUrl=self.dlServerURL+"/dlInfo-xml.jsp"
try:	try:
url=urllib.urlopen(baseUrl+self.REQUEST['QUERY_STRING'])	print "querying: ", baseUrl+'?'+self.REQUEST['QUERY_STRING']
	url=urllib.urlopen(baseUrl+'?'+self.REQUEST['QUERY_STRING'])
	print " ok, parsing..."
dom=xml.dom.minidom.parse(url)	dom=xml.dom.minidom.parse(url)
	print " ok"
params=dom.getElementsByTagName('parameter')	params=dom.getElementsByTagName('parameter')
for param in params:	for param in params:
	print " param: ", param.getAttribute('name'), " = ", param.getAttribute('value')
paramH[param.getAttribute('name')]=param.getAttribute('value')	paramH[param.getAttribute('name')]=param.getAttribute('value')
return paramH	return paramH
except:	except:
return null	return {}


def createHeadJS(self):	def createHeadJS(self):
"""generate all javascript tags for head"""	"""generate all javascript tags for head"""
self.checkQuery()	self.checkQuery()
bt = self.REQUEST.SESSION['browserType']	bt = self.REQUEST.SESSION.get('browserType', {})
if bt['staticHTML']:	if bt['staticHTML']:
return	return

Line 452 class zogiLib(Folder):	Line 582 class zogiLib(Folder):
# if not explicitly defined take normal request	# if not explicitly defined take normal request
if not requestString:	if not requestString:
requestString = self.getAllDLParams()	requestString = self.getAllDLParams()
url = self.digilibBaseUrl+requestString	url = self.dlServerURL+'/servlet/Scaler?'+requestString
# construct bottom and side insets	# construct bottom and side insets
b_par = ""	b_par = ""
s_par = ""	s_par = ""
Line 512 class zogiLib(Folder):	Line 642 class zogiLib(Folder):

def dl_lib_js(self):	def dl_lib_js(self):
"""javascript"""	"""javascript"""
return sendFile(self, 'js/dl_lib.js', 'text/plain')	return sendFile(self, 'js/dllib.js', 'text/plain')

def js_lib_js(self):	def js_lib_js(self):
"""javascript"""	"""javascript"""
return sendFile(self, 'js/js_lib.js', 'text/plain')	return sendFile(self, 'js/baselib.js', 'text/plain')

def optionwindow(self):	def optionwindow(self):
"""showoptions"""	"""showoptions"""
Line 525 class zogiLib(Folder):	Line 655 class zogiLib(Folder):
if bt['staticHTML']:	if bt['staticHTML']:
pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/optionwindow_static.zpt')).__of__(self)	pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/optionwindow_static.zpt')).__of__(self)
else:	else:
	tp = "viewingTools.zpt"
	if hasattr(self, tp):
	pt = getattr(self, tp)
	else:
pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/optionwindow.zpt')).__of__(self)	pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/optionwindow.zpt')).__of__(self)

return pt()	return pt()

def mark1(self):	def mark1(self):
Line 599 class zogiLib(Folder):	Line 734 class zogiLib(Folder):
self.checkQuery()	self.checkQuery()
bt = self.REQUEST.SESSION['browserType']	bt = self.REQUEST.SESSION['browserType']
tp = "zogiLibMainTemplate"	tp = "zogiLibMainTemplate"

if hasattr(self, tp):	if hasattr(self, tp):
pt = getattr(self, tp)	pt = getattr(self, tp)
else:	else:
tpt = self.layout	tpt = self.layout

if bt['staticHTML']:	if bt['staticHTML']:
tpt = "static"	tpt = "static"

Line 611 class zogiLib(Folder):	Line 748 class zogiLib(Folder):
return pt()	return pt()



def storeQuery(self, more = None):	def storeQuery(self, more = None):
"""storeQuery in session"""	"""storeQuery in session"""
dlParams = {}	dlParams = {}
Line 633 class zogiLib(Folder):	Line 769 class zogiLib(Folder):
else:	else:
modes=[]	modes=[]

self.REQUEST.SESSION['query'] = dlParams	wid = self.getWID()
self.REQUEST.SESSION['dlModes'] = modes	self.REQUEST.set('wid', wid)
self.REQUEST.SESSION['dlInfo'] = self.getDLInfo()	self.setSubSession('dlQuery', dlParams)
	self.setSubSession('dlModes', modes)
	self.setSubSession('dlInfo', self.getDLInfo())
if not self.REQUEST.SESSION.has_key('browserType'):	if not self.REQUEST.SESSION.has_key('browserType'):
self.REQUEST.SESSION['browserType'] = browserCheck(self)	self.REQUEST.SESSION['browserType'] = browserCheck(self)

Line 643 class zogiLib(Folder):	Line 781 class zogiLib(Folder):

def checkQuery(self):	def checkQuery(self):
"""check if the query has been stored"""	"""check if the query has been stored"""
if not (self.REQUEST.SESSION and self.REQUEST.SESSION.has_key('query')) :	if not (self.REQUEST.SESSION and self.getSubSession('dlQuery')) :
print "ZOGILIB: have to store query!!"	print "ZOGILIB: have to store query!!"
self.storeQuery()	self.storeQuery()
return	return
Line 663 class zogiLib(Folder):	Line 801 class zogiLib(Folder):
url += '/'	url += '/'
return url	return url

	def zogilibAction(self, action, otherbase=None, wid=None):
	"""returns a URL with zogilib path, action and wid"""
	url = self.zogilibPath(otherbase)
	url += action
	if wid:
	url += '?wid=' + wid
	else:
	url += '?wid=' + self.getWID()
	return url

	def getSubSession(self, key, default=None):
	"""returns an element from a session with a wid"""
	wid = self.getWID()
	return self.REQUEST.SESSION.get(key+'_'+wid, default)

	def setSubSession(self, key, value):
	"""puts an element in a session with a wid"""
	wid = self.getWID()
	self.REQUEST.SESSION.set(key+'_'+wid, value)
	return

	def getWID(self):
	"""returns a (new) window id"""
	wid = self.REQUEST.get('wid')
	if not wid:
	wid = 'digi_'+str(int(random.random()*10000))
	print "new WID:", wid
	return wid

def getDLParam(self, param):	def getDLParam(self, param):
"""returns parameter"""	"""returns parameter"""
try:	try:
return self.REQUEST.SESSION['query'][param]	return self.getSubSession('dlQuery').get(param)
except:	except:
return	return

def setDLParam(self, param, value):	def setDLParam(self, param, value):
"""sets parameter"""	"""sets parameter"""
self.REQUEST.SESSION['query'][param] = value	dlParams = self.getSubSession('dlQuery')
	#try:
	dlParams[param] = value
	#except:
	# self.setSubSession('dlQuery', {param: value})
return	return

def getAllDLParams(self):	def getAllDLParams(self):
"""parameter string for digilib"""	"""parameter string for digilib"""
dlParams = self.REQUEST.SESSION['query']	dlParams = self.getSubSession('dlQuery')
# save modes	# save modes
modes = self.REQUEST.SESSION['dlModes']	modes = self.getSubSession('dlModes')
dlParams['mo'] = string.join(modes, ',')	dlParams['mo'] = string.join(modes, ',')
# assemble query string	# assemble query string
ret = ""	ret = ""
Line 711 class zogiLib(Folder):	Line 882 class zogiLib(Folder):

def display(self):	def display(self):
"""(re)display page"""	"""(re)display page"""
	if not self.getDLParam('wid'):
	wid = self.getWID()
	self.setDLParam('wid', wid)

params = self.getAllDLParams()	params = self.getAllDLParams()

if self.basePath:	if self.basePath:
self.REQUEST.RESPONSE.redirect(self.REQUEST['URL2']+'?'+params)	self.REQUEST.RESPONSE.redirect(self.REQUEST['URL2']+'?'+params)
else:	else:
self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+params)	self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'?'+params)

	def getMetaFileName(self):
	url=self.dlServerURL+'/dlContext-xml.jsp?'+self.getAllDLParams()
	return urlbase

	def getToolbarPageURL(self):
	"""returns a toolbar-enabled page URL"""
	url=self.dlToolbarBaseURL+self.getAllDLParams()
	return url

def getDLTarget(self):	def getDLTarget(self):
"""returns dlTarget"""	"""returns dlTarget"""
self.checkQuery()	self.checkQuery()
s = self.dlTarget	s = self.dlTarget
	if s == None:
	s = ""
# s = 'dl'	# s = 'dl'
# if self.getDLParam('fn'):	# if self.getDLParam('fn'):
# s += "_" + self.getDLParam('fn')	# s += "_" + self.getDLParam('fn')
Line 742 class zogiLib(Folder):	Line 928 class zogiLib(Folder):

def getPT(self):	def getPT(self):
"""pagenums"""	"""pagenums"""
di = self.REQUEST.SESSION['dlInfo']	di = self.getSubSession('dlInfo')
if di:	if di:
return int(di['pt'])	return int(di['pt'])
else:	else:
Line 774 class zogiLib(Folder):	Line 960 class zogiLib(Folder):

def hasMode(self, mode):	def hasMode(self, mode):
"""returns if mode is in the diglib mo parameter"""	"""returns if mode is in the diglib mo parameter"""
return (mode in self.REQUEST.SESSION['dlModes'])	wid = self.getWID()
	return (mode in self.REQUEST.SESSION['dlModes_'+wid])

def hasNextPage(self):	def hasNextPage(self):
"""returns if there is a next page"""	"""returns if there is a next page"""
Line 824 class zogiLib(Folder):	Line 1011 class zogiLib(Folder):

def dl_HMirror(self):	def dl_HMirror(self):
"""mirror action"""	"""mirror action"""
modes = self.REQUEST.SESSION['dlModes']	modes = self.getSubSession('dlModes')
if 'hmir' in modes:	if 'hmir' in modes:
modes.remove('hmir')	modes.remove('hmir')
else:	else:
Line 834 class zogiLib(Folder):	Line 1021 class zogiLib(Folder):

def dl_VMirror(self):	def dl_VMirror(self):
"""mirror action"""	"""mirror action"""
modes = self.REQUEST.SESSION['dlModes']	modes = self.getSubSession('dlModes')
if 'vmir' in modes:	if 'vmir' in modes:
modes.remove('vmir')	modes.remove('vmir')
else:	else:
Line 955 class zogiLib(Folder):	Line 1142 class zogiLib(Folder):
self.setDLParam('mk', mk)	self.setDLParam('mk', mk)
return self.display()	return self.display()

	def dl_db(self,db):
	"""set db"""
	self.setDLParam('db',db)
	self.display()

def changeZogiLibForm(self):	def changeZogiLibForm(self):
"""Main configuration"""	"""Main configuration"""
pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/changeZogiLibForm.zpt')).__of__(self)	pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/changeZogiLibForm.zpt')).__of__(self)
return pt()	return pt()

def changeZogiLib(self,title,digilibBaseUrl, localFileBase, version, basePath, dlTarget, RESPONSE=None):	def changeZogiLib(self,title,dlServerURL, version, basePath, dlTarget, dlToolbarBaseURL, RESPONSE=None):
"""change it"""	"""change it"""
self.title=title	self.title=title
self.digilibBaseUrl=digilibBaseUrl	self.dlServerURL=dlServerURL
self.localFileBase=localFileBase
self.basePath = basePath	self.basePath = basePath
self.layout=version	self.layout=version
if dlTarget:
self.dlTarget = dlTarget	self.dlTarget = dlTarget

	if dlToolbarBaseURL:
	self.dlToolbarBaseURL = dlToolbarBaseURL
else:	else:
self.dlTarget = "digilib"	self.dlToolbarBaseURL = dlServerURL + "/digimage.jsp?"

if RESPONSE is not None:	if RESPONSE is not None:
RESPONSE.redirect('manage_main')	RESPONSE.redirect('manage_main')



	##
	## odds and ends
	##

	def repairZogilib(self, obj=None):
	"""change stuff that broke on upgrading"""

	msg = ""

	if not obj:
	obj = self.getPhysicalRoot()

	print "starting in ", obj

	entries=obj.ZopeFind(obj,obj_metatypes=['zogiLib'],search_sub=1)

	for entry in entries:
	print " found ", entry
	#
	# replace digilibBaseUrl by dlServerURL
	if hasattr(entry[1], 'digilibBaseUrl'):
	msg += " fixing digilibBaseUrl in "+entry[0]+"\n"
	entry[1].dlServerURL = re.sub('/servlet/Scaler\?','',entry[1].digilibBaseUrl)
	del entry[1].digilibBaseUrl

	#
	# add dlToolbarBaseURL
	if not hasattr(entry[1], 'dlToolbarBaseURL'):
	msg += " fixing dlToolbarBaseURL in "+entry[0]+"\n"
	entry[1].dlToolbarBaseURL = entry[1].dlServerURL + "/digimage.jsp?"

	return msg+"\n\nfixed all zogilib instances in: "+obj.title


def manage_addZogiLibForm(self):	def manage_addZogiLibForm(self):
"""interface for adding zogilib"""	"""interface for adding zogilib"""
pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiLibForm')).__of__(self)	pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiLibForm')).__of__(self)
return pt()	return pt()

def manage_addZogiLib(self,id,title,digilibBaseUrl, localFileBase,version="book",basePath="",dlTarget="digilib",RESPONSE=None):	def manage_addZogiLib(self,id,title,dlServerURL,version="book",basePath="",dlTarget=None,dlToolbarBaseURL=None,RESPONSE=None):
"""add dgilib"""	"""add dgilib"""
newObj=zogiLib(id,title,digilibBaseUrl, localFileBase, version, basePath, dlTarget)	newObj=zogiLib(id,title,dlServerURL, version, basePath, dlTarget, dlToolbarBaseURL)
self.Destination()._setObject(id,newObj)	self.Destination()._setObject(id,newObj)
if RESPONSE is not None:	if RESPONSE is not None:
RESPONSE.redirect('manage_main')	RESPONSE.redirect('manage_main')
Line 1027 def manage_addZogiLibPageTemplate(self,	Line 1253 def manage_addZogiLibPageTemplate(self,
u = "%s/%s" % (u, urllib.quote(id))	u = "%s/%s" % (u, urllib.quote(id))
REQUEST.RESPONSE.redirect(u+'/manage_main')	REQUEST.RESPONSE.redirect(u+'/manage_main')
return ''	return ''

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

Removed from v.1.30
changed lines
	Added in v.1.48