from Products.PageTemplates.PageTemplateFile import PageTemplateFile
from Products.PageTemplates.PageTemplate import PageTemplate
from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
from OFS.Image import Image
from AccessControl import ClassSecurityInfo
import xml.dom.minidom
from OFS.Folder import Folder
from xml_helpers import getUniqueElementText,getText
import os
import re
import string
import urllib
import types
import random
from Globals import package_home
ZOGIVERSION = "0.9.15b DW:22.2.2005"
def cropf(f):
"""returns a float with reduced precision"""
return float(int(f * 10000)/10000.0)
def sendFile(self, filename, type):
"""sends an object or a local file (from the product) as response"""
paths = filename.split('/')
object = self
# look for an object called filename
for path in paths:
if hasattr(object, path):
object = getattr(object, path)
else:
object = None
break
if object:
# if the object exists then send it
return object.index_html(self.REQUEST.REQUEST, self.REQUEST.RESPONSE)
else:
# send a local file with the given content-type
fn = os.path.join(package_home(globals()), filename)
self.REQUEST.RESPONSE.setHeader("Content-Type", type)
self.REQUEST.RESPONSE.write(file(fn).read())
return
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
if string.find(ua, 'MSIE') > -1:
bt['isIE'] = True
else:
bt['isN4'] = (string.find(ua, 'Mozilla/4.') > -1)
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
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
class zogiImage(Image):
"""einzelnes Image"""
meta_type="zogiImage"
manage_options=ZopePageTemplate.manage_options+(
{'label':'Main config','action':'changeZogiImageForm'},
)
def __init__(self,id,title,baseUrl,queryString,content_type='',precondition=''):
"""init"""
self.id=id
self.title=title
if baseUrl:
self.baseUrl=baseUrl
else:
self.baseUrl="http://nausikaa.mpiwg-berlin.mpg.de/digitallibrary/servlet/Scaler?"
self.queryString=queryString
self.content_type=content_type
self.precondition=precondition
def getData(self):
"""getUrlData"""
return urllib.urlopen(self.baseUrl+self.queryString)
def changeZogiImageForm(self):
"""Main configuration"""
pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/changeZogiImageForm.zpt')).__of__(self)
return pt()
def changeZogiImage(self,title,baseUrl, queryString,RESPONSE=None):
"""change it"""
self.title=title
self.baseUrl=baseUrl
self.queryString=queryString
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
def index_html(self, REQUEST, RESPONSE):
"""service the request by redirecting to digilib server"""
RESPONSE.redirect(self.baseUrl+self.queryString)
return ''
def manage_addZogiImageForm(self):
"""Form for adding"""
pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiImage.zpt')).__of__(self)
return pt()
def manage_addZogiImage(self,id,title,baseUrl, queryString,RESPONSE=None):
"""add zogiimage"""
newObj=zogiImage(id,title,baseUrl, queryString)
self.Destination()._setObject(id,newObj)
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
class zogiLib(Folder):
"""digilib frontend with ZOPE"""
meta_type="zogiLib"
#xxxx
security=ClassSecurityInfo()
manage_options = Folder.manage_options+(
{'label':'Main Config','action':'changeZogiLibForm'},
)
def __init__(self, id, title, dlServerURL, layout="book", basePath="", dlTarget=None, dlToolbarBaseURL=None):
"""init"""
self.id=id
self.title=title
self.dlServerURL = dlServerURL
self.basePath=basePath
self.layout=layout
self.dlTarget = dlTarget
if dlToolbarBaseURL:
self.dlToolbarBaseURL = dlToolbarBaseURL
else:
self.dlToolbarBaseURL = dlServerURL + "/digimage.jsp?"
security.declareProtected('View','getLayout')
def getLayout(self):
"""get Layout"""
return self.layout
def version(self):
"""version information"""
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+="""%s"""%(viewUrl,label)
for set in sets:
ret+="
"
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+="""%s: | %s |
"""%(label,text)
ret+="
"
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):
"""get DLInfo from digilib server"""
paramH={}
baseUrl=self.dlServerURL+"/dlInfo-xml.jsp"
try:
url=urllib.urlopen(baseUrl+'?'+self.REQUEST['QUERY_STRING'])
dom=xml.dom.minidom.parse(url)
params=dom.getElementsByTagName('parameter')
for param in params:
paramH[param.getAttribute('name')]=param.getAttribute('value')
return paramH
except:
return {}
def createHeadJS(self):
"""generate all javascript tags for head"""
self.checkQuery()
bt = self.REQUEST.SESSION.get('browserType', {})
if bt['staticHTML']:
return
pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogilib_head_js')).__of__(self)
return pt()
def createParamJS(self):
"""generate javascript for parameters only"""
self.checkQuery()
bt = self.REQUEST.SESSION['browserType']
if bt['staticHTML']:
return
pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogilib_param_js')).__of__(self)
return pt()
def createScalerImg(self, requestString=None, bottom=0, side=0, width=500, height=500):
"""generate Scaler IMG Tag"""
self.checkQuery()
bt = self.REQUEST.SESSION['browserType']
# override with parameters from session
if self.REQUEST.SESSION.has_key('scalerDiv'):
(requestString, bottom, side, width, height) = self.REQUEST.SESSION['scalerDiv']
# if not explicitly defined take normal request
if not requestString:
requestString = self.getAllDLParams()
url = self.dlServerURL+'/servlet/Scaler?'+requestString
# construct bottom and side insets
b_par = ""
s_par = ""
if (bottom != 0) or (side != 0):
b_par = "-" + str(int(bottom))
s_par = "-" + str(int(side))
tag = ""
if bt['staticHTML']:
tag += ''%(url, int(width-side), int(height-bottom))
else:
if bt['isN4']:
# N4 needs layers
tag += ''
else:
tag += ''
tag += ''
if bt['isN4']:
tag += ''
else:
tag += '
'
return tag
def createScalerDiv(self, requestString = None, bottom = 0, side = 0, width=500, height=500):
"""generate scaler img and table with navigation arrows"""
self.checkQuery()
if requestString != None or bottom != 0 or side != 0:
self.REQUEST.SESSION['scalerDiv'] = (requestString, bottom, side, width, height)
else:
if self.REQUEST.SESSION.has_key('scalerDiv'):
# make shure to remove unused parameter
del self.REQUEST.SESSION['scalerDiv']
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt/zogilib_img_div')).__of__(self)
return pt()
def createAuxDiv(self):
"""generate other divs"""
self.checkQuery()
bt = self.REQUEST.SESSION['browserType']
if bt['staticHTML']:
return
if bt['isN4']:
f = 'zpt/zogilib_divsN4.zpt'
else:
f = 'zpt/zogilib_divs.zpt'
pt=PageTemplateFile(os.path.join(package_home(globals()),f)).__of__(self)
return pt()
def option_js(self):
"""javascript"""
return sendFile(self, 'js/option.js', 'text/plain')
def dl_lib_js(self):
"""javascript"""
return sendFile(self, 'js/dllib.js', 'text/plain')
def js_lib_js(self):
"""javascript"""
return sendFile(self, 'js/baselib.js', 'text/plain')
def optionwindow(self):
"""showoptions"""
self.checkQuery()
bt = self.REQUEST.SESSION['browserType']
if bt['staticHTML']:
pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/optionwindow_static.zpt')).__of__(self)
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)
return pt()
def mark1(self):
"""mark image"""
return sendFile(self, 'images/mark1.gif', 'image/gif')
def mark2(self):
"""mark image"""
return sendFile(self, 'images/mark2.gif', 'image/gif')
def mark3(self):
"""mark image"""
return sendFile(self, 'images/mark3.gif', 'image/gif')
def mark4(self):
"""mark image"""
return sendFile(self, 'images/mark4.gif', 'image/gif')
def mark5(self):
"""mark image"""
return sendFile(self, 'images/mark5.gif', 'image/gif')
def mark6(self):
"""mark image"""
return sendFile(self, 'images/mark6.gif', 'image/gif')
def mark7(self):
"""mark image"""
return sendFile(self, 'images/mark7.gif', 'image/gif')
def mark8(self):
"""mark image"""
return sendFile(self, 'images/mark8.gif', 'image/gif')
def corner1(self):
"""mark image"""
return sendFile(self, 'images/olinks.gif', 'image/gif')
def corner2(self):
"""mark image"""
return sendFile(self, 'images/orechts.gif', 'image/gif')
def corner3(self):
"""mark image"""
return sendFile(self, 'images/ulinks.gif', 'image/gif')
def corner4(self):
"""mark image"""
return sendFile(self, 'images/urechts.gif', 'image/gif')
def up_img(self):
"""mark image"""
return sendFile(self, 'images/up.gif', 'image/gif')
def down_img(self):
"""mark image"""
return sendFile(self, 'images/down.gif', 'image/gif')
def left_img(self):
"""mark image"""
return sendFile(self, 'images/left.gif', 'image/gif')
def right_img(self):
"""mark image"""
return sendFile(self, 'images/right.gif', 'image/gif')
def index_html(self):
"""main action"""
self.checkQuery()
bt = self.REQUEST.SESSION['browserType']
tp = "zogiLibMainTemplate"
if hasattr(self, tp):
pt = getattr(self, tp)
else:
tpt = self.layout
if bt['staticHTML']:
tpt = "static"
pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/zogiLibMain_%s'%tpt)).__of__(self)
return pt()
def storeQuery(self, more = None):
"""storeQuery in session"""
dlParams = {}
for fm in self.REQUEST.form.keys():
dlParams[fm] = self.REQUEST.form[fm]
# look for more
if more:
for fm in more.split('&'):
try:
pv = fm.split('=')
dlParams[pv[0]] = pv[1]
except:
pass
# parse digilib mode parameter
if 'mo' in dlParams:
if len(dlParams['mo']) > 0:
modes=dlParams['mo'].split(',')
else:
modes=[]
wid = self.getWID()
self.REQUEST.set('wid', wid)
self.setSubSession('dlQuery', dlParams)
self.setSubSession('dlModes', modes)
self.setSubSession('dlInfo', self.getDLInfo())
if not self.REQUEST.SESSION.has_key('browserType'):
self.REQUEST.SESSION['browserType'] = browserCheck(self)
return
def checkQuery(self):
"""check if the query has been stored"""
if not (self.REQUEST.SESSION and self.getSubSession('dlQuery')) :
print "ZOGILIB: have to store query!!"
self.storeQuery()
return
def zogilibPath(self, otherbase=None):
"""returns an URL to the zogiLib instance"""
url = self.REQUEST['URL1']
# should end with "/"
if len(url) > 0 and url[-1] != '/':
url += '/'
if type(otherbase) is str:
url += otherbase
else:
url += self.basePath
# should end with "/"
if len(url) > 0 and url[-1] != '/':
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, default=None):
"""returns parameter or default"""
try:
return self.getSubSession('dlQuery').get(param, default)
except:
return default
def setDLParam(self, param, value):
"""sets parameter"""
dlParams = self.getSubSession('dlQuery')
#try:
dlParams[param] = value
#except:
# self.setSubSession('dlQuery', {param: value})
return
def getAllDLParams(self):
"""parameter string for digilib"""
dlParams = self.getSubSession('dlQuery')
# save modes
modes = self.getSubSession('dlModes')
dlParams['mo'] = string.join(modes, ',')
# assemble query string
ret = ""
for param in dlParams.keys():
if dlParams[param] is None: continue
val = str(dlParams[param])
if val != "":
ret += param + "=" + val + "&"
# omit trailing "&"
return ret.rstrip('&')
def setDLParams(self,pn=None,ws=None,rot=None,brgt=None,cont=None):
"""setze Parameter"""
self.setDLParam('brgt', brgt)
self.setDLParam('cont', cont)
self.setDLParam('ws', ws)
self.setDLParam('rot', rot)
if pn:
# unmark
self.setDLParam('mk', None)
self.setDLParam('pn', pn)
return self.display()
def display(self):
"""(re)display page"""
if not self.getDLParam('wid'):
wid = self.getWID()
self.setDLParam('wid', wid)
params = self.getAllDLParams()
if self.basePath:
self.REQUEST.RESPONSE.redirect(self.REQUEST['URL2']+'?'+params)
else:
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):
"""returns dlTarget"""
self.checkQuery()
s = self.dlTarget
if s == None:
s = ""
# s = 'dl'
# if self.getDLParam('fn'):
# s += "_" + self.getDLParam('fn')
# if self.getDLParam('pn'):
# s += "_" + self.getDLParam('pn')
return s
def setStaticHTML(self, static=True):
"""sets the preference to static HTML"""
self.checkQuery()
self.REQUEST.SESSION['browserType']['staticHTML'] = static
return
def isStaticHTML(self):
"""returns if the page is using static HTML only"""
self.checkQuery()
return self.REQUEST.SESSION['browserType']['staticHTML']
def getPT(self):
"""pagenums"""
di = self.getSubSession('dlInfo')
if di:
return int(di['pt'])
else:
return 1
def getPN(self):
"""Pagenum"""
pn = self.getDLParam('pn')
try:
return int(pn)
except:
return 1
def getBiggerWS(self):
"""ws+1"""
ws = self.getDLParam('ws')
try:
return float(ws)+0.5
except:
return 1.5
def getSmallerWS(self):
"""ws-1"""
ws=self.getDLParam('ws')
try:
return max(float(ws)-0.5, 1)
except:
return 1
def hasMode(self, mode):
"""returns if mode is in the diglib mo parameter"""
wid = self.getWID()
return (mode in self.REQUEST.SESSION['dlModes_'+wid])
def hasNextPage(self):
"""returns if there is a next page"""
pn = self.getPN()
pt = self.getPT()
return (pn < pt)
def hasPrevPage(self):
"""returns if there is a previous page"""
pn = self.getPN()
return (pn > 1)
def canMoveLeft(self):
"""returns if its possible to move left"""
wx = float(self.getDLParam('wx') or 0)
return (wx > 0)
def canMoveRight(self):
"""returns if its possible to move right"""
wx = float(self.getDLParam('wx') or 0)
ww = float(self.getDLParam('ww') or 1)
return (wx + ww < 1)
def canMoveUp(self):
"""returns if its possible to move up"""
wy = float(self.getDLParam('wy') or 0)
return (wy > 0)
def canMoveDown(self):
"""returns if its possible to move down"""
wy = float(self.getDLParam('wy') or 0)
wh = float(self.getDLParam('wh') or 1)
return (wy + wh < 1)
def dl_StaticHTML(self):
"""set rendering to static HTML"""
self.checkQuery()
self.REQUEST.SESSION['browserType']['staticHTML'] = True
return self.display()
def dl_DynamicHTML(self):
"""set rendering to dynamic HTML"""
self.checkQuery()
self.REQUEST.SESSION['browserType']['staticHTML'] = False
return self.display()
def dl_HMirror(self):
"""mirror action"""
modes = self.getSubSession('dlModes')
if 'hmir' in modes:
modes.remove('hmir')
else:
modes.append('hmir')
return self.display()
def dl_VMirror(self):
"""mirror action"""
modes = self.getSubSession('dlModes')
if 'vmir' in modes:
modes.remove('vmir')
else:
modes.append('vmir')
return self.display()
def dl_Zoom(self, z):
"""general zoom action"""
ww1 = float(self.getDLParam('ww') or 1)
wh1 = float(self.getDLParam('wh') or 1)
wx = float(self.getDLParam('wx') or 0)
wy = float(self.getDLParam('wy') or 0)
ww2 = ww1 * z
wh2 = wh1 * z
wx += (ww1 - ww2) / 2
wy += (wh1 - wh2) / 2
ww2 = max(min(ww2, 1), 0)
wh2 = max(min(wh2, 1), 0)
wx = max(min(wx, 1), 0)
wy = max(min(wy, 1), 0)
self.setDLParam('ww', cropf(ww2))
self.setDLParam('wh', cropf(wh2))
self.setDLParam('wx', cropf(wx))
self.setDLParam('wy', cropf(wy))
return self.display()
def dl_ZoomIn(self):
"""zoom in action"""
z = 0.7071
return self.dl_Zoom(z)
def dl_ZoomOut(self):
"""zoom out action"""
z = 1.4142
return self.dl_Zoom(z)
def dl_Move(self, dx, dy):
"""general move action"""
ww = float(self.getDLParam('ww') or 1)
wh = float(self.getDLParam('wh') or 1)
wx = float(self.getDLParam('wx') or 0)
wy = float(self.getDLParam('wy') or 0)
wx += dx * 0.5 * ww
wy += dy * 0.5 * wh
wx = max(min(wx, 1), 0)
wy = max(min(wy, 1), 0)
self.setDLParam('wx', cropf(wx))
self.setDLParam('wy', cropf(wy))
return self.display()
def dl_MoveLeft(self):
"""move left action"""
return self.dl_Move(-1, 0)
def dl_MoveRight(self):
"""move left action"""
return self.dl_Move(1, 0)
def dl_MoveUp(self):
"""move left action"""
return self.dl_Move(0, -1)
def dl_MoveDown(self):
"""move left action"""
return self.dl_Move(0, 1)
def dl_WholePage(self):
"""zoom out action"""
self.setDLParam('ww', 1)
self.setDLParam('wh', 1)
self.setDLParam('wx', 0)
self.setDLParam('wy', 0)
return self.display()
def dl_PrevPage(self):
"""next page action"""
pn = self.getPN() - 1
if pn < 1:
pn = 1
self.setDLParam('pn', pn)
# unmark
self.setDLParam('mk', None)
return self.display()
def dl_NextPage(self):
"""next page action"""
pn = self.getPN() + 1
pt = self.getPT()
if pn > pt:
pn = pt
self.setDLParam('pn', pn)
# unmark
self.setDLParam('mk', None)
return self.display()
def dl_FirstPage(self):
"""first page action"""
self.setDLParam('pn', 1)
# unmark
self.setDLParam('mk', None)
return self.display()
def dl_LastPage(self):
"""last page action"""
self.setDLParam('pn', self.getPT())
# unmark
self.setDLParam('mk', None)
return self.display()
def dl_Unmark(self):
"""action to remove last mark"""
mk = self.getDLParam('mk')
if mk:
marks = mk.split(',')
marks.pop()
mk = string.join(marks, ',')
self.setDLParam('mk', mk)
return self.display()
def dl_db(self,db):
"""set db"""
self.setDLParam('db',db)
self.display()
def changeZogiLibForm(self):
"""Main configuration"""
pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/changeZogiLibForm.zpt')).__of__(self)
return pt()
def changeZogiLib(self,title,dlServerURL, version, basePath, dlTarget, dlToolbarBaseURL, RESPONSE=None):
"""change it"""
self.title=title
self.dlServerURL=dlServerURL
self.basePath = basePath
self.layout=version
self.dlTarget = dlTarget
if dlToolbarBaseURL:
self.dlToolbarBaseURL = dlToolbarBaseURL
else:
self.dlToolbarBaseURL = dlServerURL + "/digimage.jsp?"
if RESPONSE is not None:
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):
"""interface for adding zogilib"""
pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiLibForm')).__of__(self)
return pt()
def manage_addZogiLib(self,id,title,dlServerURL,version="book",basePath="",dlTarget=None,dlToolbarBaseURL=None,RESPONSE=None):
"""add dgilib"""
newObj=zogiLib(id,title,dlServerURL, version, basePath, dlTarget, dlToolbarBaseURL)
self.Destination()._setObject(id,newObj)
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
class zogiLibPageTemplate(ZopePageTemplate):
"""pageTemplate Objekt"""
meta_type="zogiLib_pageTemplate"
## def __init__(self, id, text=None, contentType=None):
## self.id = str(id)
## self.ZBindings_edit(self._default_bindings)
## if text is None:
## text = open(self._default_cont).read()
## self.pt_edit(text, contentType)
def manage_addZogiLibPageTemplateForm(self):
"""Form for adding"""
pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiLibPageTemplateForm')).__of__(self)
return pt()
def manage_addZogiLibPageTemplate(self, id='zogiLibMainTemplate', title=None, layout=None, text=None,
REQUEST=None, submit=None):
"Add a Page Template with optional file content."
id = str(id)
self._setObject(id, zogiLibPageTemplate(id))
ob = getattr(self, id)
if not layout: layout = "book"
ob.pt_edit(open(os.path.join(package_home(globals()),'zpt/zogiLibMain_%s.zpt'%layout)).read(),None)
if title:
ob.pt_setTitle(title)
try:
u = self.DestinationURL()
except AttributeError:
u = REQUEST['URL1']
u = "%s/%s" % (u, urllib.quote(id))
REQUEST.RESPONSE.redirect(u+'/manage_main')
return ''