version 1.34, 2004/07/21 17:44:51
|
version 1.51, 2004/10/27 11:35:44
|
Line 12 import re
|
Line 12 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.7 ROC:21.7.2004" |
ZOGIVERSION = "0.9.12b ROC:27.10.2004" |
|
|
def cropf(f): |
def cropf(f): |
"""returns a float with reduced precision""" |
"""returns a float with reduced precision""" |
Line 22 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 47 def browserCheck(self):
|
Line 48 def browserCheck(self):
|
bt = {} |
bt = {} |
ua = self.REQUEST.get_header("HTTP_USER_AGENT") |
ua = self.REQUEST.get_header("HTTP_USER_AGENT") |
bt['ua'] = ua |
bt['ua'] = ua |
bt['isIE'] = string.find(ua, 'MSIE') > -1 |
bt['isIE'] = False |
bt['isN4'] = (string.find(ua, 'Mozilla/4.') > -1) and not bt['isIE'] |
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, '('):] |
nav = ua[string.find(ua, '('):] |
ie = string.split(nav, "; ")[1] |
ie = string.split(nav, "; ")[1] |
if string.find(ie, "MSIE") > -1: |
if string.find(ie, "MSIE") > -1: |
bt['versIE'] = string.split(ie, " ")[1] |
bt['versIE'] = string.split(ie, " ")[1] |
|
except: pass |
|
|
bt['isMac'] = string.find(ua, 'Macintosh') > -1 |
bt['isMac'] = string.find(ua, 'Macintosh') > -1 |
bt['isWin'] = string.find(ua, 'Windows') > -1 |
bt['isWin'] = string.find(ua, 'Windows') > -1 |
bt['isIEWin'] = bt['isIE'] and bt['isWin'] |
bt['isIEWin'] = bt['isIE'] and bt['isWin'] |
Line 75 class zogiImage(Image):
|
Line 84 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 98 class zogiImage(Image):
|
Line 111 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""" |
Modified version of OFS/Image.py |
RESPONSE.redirect(self.baseUrl+self.queryString) |
|
|
The default view of the contents of a File or Image. |
|
|
|
Returns the contents of the file or image. Also, sets the |
|
Content-Type HTTP header to the objects content type. |
|
""" |
|
|
|
# HTTP If-Modified-Since header handling. |
|
header=REQUEST.get_header('If-Modified-Since', None) |
|
if header is not None: |
|
header=header.split( ';')[0] |
|
# Some proxies seem to send invalid date strings for this |
|
# header. If the date string is not valid, we ignore it |
|
# rather than raise an error to be generally consistent |
|
# with common servers such as Apache (which can usually |
|
# understand the screwy date string as a lucky side effect |
|
# of the way they parse it). |
|
# This happens to be what RFC2616 tells us to do in the face of an |
|
# invalid date. |
|
try: mod_since=long(DateTime(header).timeTime()) |
|
except: mod_since=None |
|
if mod_since is not None: |
|
if self._p_mtime: |
|
last_mod = long(self._p_mtime) |
|
else: |
|
last_mod = long(0) |
|
if last_mod > 0 and last_mod <= mod_since: |
|
# Set header values since apache caching will return Content-Length |
|
# of 0 in response if size is not set here |
|
RESPONSE.setHeader('Last-Modified', rfc1123_date(self._p_mtime)) |
|
RESPONSE.setHeader('Content-Type', self.content_type) |
|
RESPONSE.setHeader('Content-Length', self.size) |
|
RESPONSE.setHeader('Accept-Ranges', 'bytes') |
|
self.ZCacheable_set(None) |
|
RESPONSE.setStatus(304) |
|
return '' |
return '' |
|
|
if self.precondition and hasattr(self,self.precondition): |
|
# Grab whatever precondition was defined and then |
|
# execute it. The precondition will raise an exception |
|
# if something violates its terms. |
|
c=getattr(self,self.precondition) |
|
if hasattr(c,'isDocTemp') and c.isDocTemp: |
|
c(REQUEST['PARENTS'][1],REQUEST) |
|
else: |
|
c() |
|
|
|
# HTTP Range header handling |
|
range = REQUEST.get_header('Range', None) |
|
request_range = REQUEST.get_header('Request-Range', None) |
|
if request_range is not None: |
|
# Netscape 2 through 4 and MSIE 3 implement a draft version |
|
# Later on, we need to serve a different mime-type as well. |
|
range = request_range |
|
if_range = REQUEST.get_header('If-Range', None) |
|
if range is not None: |
|
ranges = HTTPRangeSupport.parseRange(range) |
|
|
|
if if_range is not None: |
|
# Only send ranges if the data isn't modified, otherwise send |
|
# the whole object. Support both ETags and Last-Modified dates! |
|
if len(if_range) > 1 and if_range[:2] == 'ts': |
|
# ETag: |
|
if if_range != self.http__etag(): |
|
# Modified, so send a normal response. We delete |
|
# the ranges, which causes us to skip to the 200 |
|
# response. |
|
ranges = None |
|
else: |
|
# Date |
|
date = if_range.split( ';')[0] |
|
try: mod_since=long(DateTime(date).timeTime()) |
|
except: mod_since=None |
|
if mod_since is not None: |
|
if self._p_mtime: |
|
last_mod = long(self._p_mtime) |
|
else: |
|
last_mod = long(0) |
|
if last_mod > mod_since: |
|
# Modified, so send a normal response. We delete |
|
# the ranges, which causes us to skip to the 200 |
|
# response. |
|
ranges = None |
|
|
|
if ranges: |
|
# Search for satisfiable ranges. |
|
satisfiable = 0 |
|
for start, end in ranges: |
|
if start < self.size: |
|
satisfiable = 1 |
|
break |
|
|
|
if not satisfiable: |
|
RESPONSE.setHeader('Content-Range', |
|
'bytes */%d' % self.size) |
|
RESPONSE.setHeader('Accept-Ranges', 'bytes') |
|
RESPONSE.setHeader('Last-Modified', |
|
rfc1123_date(self._p_mtime)) |
|
RESPONSE.setHeader('Content-Type', self.content_type) |
|
RESPONSE.setHeader('Content-Length', self.size) |
|
RESPONSE.setStatus(416) |
|
return '' |
|
|
|
ranges = HTTPRangeSupport.expandRanges(ranges, self.size) |
|
|
|
if len(ranges) == 1: |
|
# Easy case, set extra header and return partial set. |
|
start, end = ranges[0] |
|
size = end - start |
|
|
|
RESPONSE.setHeader('Last-Modified', |
|
rfc1123_date(self._p_mtime)) |
|
RESPONSE.setHeader('Content-Type', self.content_type) |
|
RESPONSE.setHeader('Content-Length', size) |
|
RESPONSE.setHeader('Accept-Ranges', 'bytes') |
|
RESPONSE.setHeader('Content-Range', |
|
'bytes %d-%d/%d' % (start, end - 1, self.size)) |
|
RESPONSE.setStatus(206) # Partial content |
|
|
|
data = urllib.urlopen(self.baseUrl+self.queryString).read() |
|
if type(data) is StringType: |
|
return data[start:end] |
|
|
|
# Linked Pdata objects. Urgh. |
|
pos = 0 |
|
while data is not None: |
|
l = len(data.data) |
|
pos = pos + l |
|
if pos > start: |
|
# We are within the range |
|
lstart = l - (pos - start) |
|
|
|
if lstart < 0: lstart = 0 |
|
|
|
# find the endpoint |
|
if end <= pos: |
|
lend = l - (pos - end) |
|
|
|
# Send and end transmission |
|
RESPONSE.write(data[lstart:lend]) |
|
break |
|
|
|
# Not yet at the end, transmit what we have. |
|
RESPONSE.write(data[lstart:]) |
|
|
|
data = data.next |
|
|
|
return '' |
|
|
|
else: |
|
boundary = choose_boundary() |
|
|
|
# Calculate the content length |
|
size = (8 + len(boundary) + # End marker length |
|
len(ranges) * ( # Constant lenght per set |
|
49 + len(boundary) + len(self.content_type) + |
|
len('%d' % self.size))) |
|
for start, end in ranges: |
|
# Variable length per set |
|
size = (size + len('%d%d' % (start, end - 1)) + |
|
end - start) |
|
|
|
|
|
# Some clients implement an earlier draft of the spec, they |
|
# will only accept x-byteranges. |
|
draftprefix = (request_range is not None) and 'x-' or '' |
|
|
|
RESPONSE.setHeader('Content-Length', size) |
|
RESPONSE.setHeader('Accept-Ranges', 'bytes') |
|
RESPONSE.setHeader('Last-Modified', |
|
rfc1123_date(self._p_mtime)) |
|
RESPONSE.setHeader('Content-Type', |
|
'multipart/%sbyteranges; boundary=%s' % ( |
|
draftprefix, boundary)) |
|
RESPONSE.setStatus(206) # Partial content |
|
|
|
data = urllib.urlopen(self.baseUrl+self.queryString).read() |
|
# The Pdata map allows us to jump into the Pdata chain |
|
# arbitrarily during out-of-order range searching. |
|
pdata_map = {} |
|
pdata_map[0] = data |
|
|
|
for start, end in ranges: |
|
RESPONSE.write('\r\n--%s\r\n' % boundary) |
|
RESPONSE.write('Content-Type: %s\r\n' % |
|
self.content_type) |
|
RESPONSE.write( |
|
'Content-Range: bytes %d-%d/%d\r\n\r\n' % ( |
|
start, end - 1, self.size)) |
|
|
|
if type(data) is StringType: |
|
RESPONSE.write(data[start:end]) |
|
|
|
else: |
|
# Yippee. Linked Pdata objects. The following |
|
# calculations allow us to fast-forward through the |
|
# Pdata chain without a lot of dereferencing if we |
|
# did the work already. |
|
first_size = len(pdata_map[0].data) |
|
if start < first_size: |
|
closest_pos = 0 |
|
else: |
|
closest_pos = ( |
|
((start - first_size) >> 16 << 16) + |
|
first_size) |
|
pos = min(closest_pos, max(pdata_map.keys())) |
|
data = pdata_map[pos] |
|
|
|
while data is not None: |
|
l = len(data.data) |
|
pos = pos + l |
|
if pos > start: |
|
# We are within the range |
|
lstart = l - (pos - start) |
|
|
|
if lstart < 0: lstart = 0 |
|
|
|
# find the endpoint |
|
if end <= pos: |
|
lend = l - (pos - end) |
|
|
|
# Send and loop to next range |
|
RESPONSE.write(data[lstart:lend]) |
|
break |
|
|
|
# Not yet at the end, transmit what we have. |
|
RESPONSE.write(data[lstart:]) |
|
|
|
data = data.next |
|
# Store a reference to a Pdata chain link so we |
|
# don't have to deref during this request again. |
|
pdata_map[pos] = data |
|
|
|
# Do not keep the link references around. |
|
del pdata_map |
|
|
|
RESPONSE.write('\r\n--%s--\r\n' % boundary) |
|
return '' |
|
|
|
RESPONSE.setHeader('Last-Modified', rfc1123_date(self._p_mtime)) |
|
RESPONSE.setHeader('Content-Type', self.content_type) |
|
RESPONSE.setHeader('Content-Length', self.size) |
|
RESPONSE.setHeader('Accept-Ranges', 'bytes') |
|
|
|
# Don't cache the data itself, but provide an opportunity |
|
# for a cache manager to set response headers. |
|
self.ZCacheable_set(None) |
|
|
|
data=urllib.urlopen(self.baseUrl+self.queryString).read() |
|
|
|
if type(data) is type(''): |
|
RESPONSE.setBase(None) |
|
return data |
|
|
|
while data is not None: |
|
RESPONSE.write(data.data) |
|
data=data.next |
|
|
|
return '' |
|
|
|
|
|
def manage_addZogiImageForm(self): |
def manage_addZogiImageForm(self): |
Line 370 def manage_addZogiImageForm(self):
|
Line 125 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 379 def manage_addZogiImage(self,id,title,ba
|
Line 134 def manage_addZogiImage(self,id,title,ba
|
|
|
|
|
class zogiLib(Folder): |
class zogiLib(Folder): |
"""StandardElement""" |
"""digilib frontend with ZOPE""" |
|
|
meta_type="zogiLib" |
meta_type="zogiLib" |
#xxxx |
#xxxx |
Line 388 class zogiLib(Folder):
|
Line 143 class zogiLib(Folder):
|
{'label':'Main Config','action':'changeZogiLibForm'}, |
{'label':'Main Config','action':'changeZogiLibForm'}, |
) |
) |
|
|
def __init__(self, id, title, digilibBaseURL,localFileBase, version="book", basePath="", dlTarget=None, dlServerURL=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.dlServerURL = dlServerURL |
if digilibBaseURL and not dlServerURL: |
|
self.dlServerURL = re.sub("/servlet/Scaler\?","",self.digilibBaseURL) |
|
|
|
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""" |
Line 451 class zogiLib(Folder):
|
Line 204 class zogiLib(Folder):
|
|
|
return ret |
return ret |
except: |
except: |
return ret |
|
|
|
def formatHTML(self,url,label=None,viewUrl=None): |
return [] |
|
|
|
|
|
def formatHTML(self,url,label=None,viewUrl=None): |
|
|
sets=xml.dom.minidom.parse(urllib.urlopen(url)).getElementsByTagName('dataset') |
sets=xml.dom.minidom.parse(urllib.urlopen(url)).getElementsByTagName('dataset') |
ret="" |
ret="" |
print label |
print label |
Line 474 class zogiLib(Folder):
|
Line 228 class zogiLib(Folder):
|
ret+="</table>" |
ret+="</table>" |
return ret |
return ret |
|
|
|
|
def getMetaData(self): |
def getMetaData(self): |
"""getMetaData""" |
"""getMetaData""" |
try: |
try: |
Line 520 class zogiLib(Folder):
|
Line 275 class zogiLib(Folder):
|
return self.formatHTML(link+'fn=%s&pn=%s&object=%s'%(fn,pn,ob),label,url) |
return self.formatHTML(link+'fn=%s&pn=%s&object=%s'%(fn,pn,ob),label,url) |
return ret |
return ret |
|
|
|
|
def getDLInfo(self): |
def getDLInfo(self): |
"""get DLInfo from digilib server""" |
"""get DLInfo from digilib server""" |
paramH={} |
paramH={} |
baseUrl=self.dlServerURL+"/dlInfo-xml.jsp" |
baseUrl=self.dlServerURL+"/dlInfo-xml.jsp" |
try: |
try: |
url=urllib.urlopen(baseUrl+self.REQUEST['QUERY_STRING']) |
url=urllib.urlopen(baseUrl+'?'+self.REQUEST['QUERY_STRING']) |
dom=xml.dom.minidom.parse(url) |
dom=xml.dom.minidom.parse(url) |
params=dom.getElementsByTagName('parameter') |
params=dom.getElementsByTagName('parameter') |
for param in params: |
for param in params: |
Line 538 class zogiLib(Folder):
|
Line 294 class zogiLib(Folder):
|
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 566 class zogiLib(Folder):
|
Line 322 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 639 class zogiLib(Folder):
|
Line 395 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: |
finds=self.ZopeFind(self,obj_ids=['viewingTools.zpt']) |
tp = "viewingTools.zpt" |
if finds: |
if hasattr(self, tp): |
|
pt = getattr(self, tp) |
return finds[0][1]() |
|
else: |
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 732 class zogiLib(Folder):
|
Line 488 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 754 class zogiLib(Folder):
|
Line 509 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 764 class zogiLib(Folder):
|
Line 521 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 784 class zogiLib(Folder):
|
Line 541 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 832 class zogiLib(Folder):
|
Line 622 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: |
Line 844 class zogiLib(Folder):
|
Line 639 class zogiLib(Folder):
|
|
|
def getToolbarPageURL(self): |
def getToolbarPageURL(self): |
"""returns a toolbar-enabled page URL""" |
"""returns a toolbar-enabled page URL""" |
url=self.dlServerURL+'/digimage.jsp?'+self.getAllDLParams() |
url=self.dlToolbarBaseURL+self.getAllDLParams() |
return url |
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 871 class zogiLib(Folder):
|
Line 668 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 903 class zogiLib(Folder):
|
Line 700 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 953 class zogiLib(Folder):
|
Line 751 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 963 class zogiLib(Folder):
|
Line 761 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 1094 class zogiLib(Folder):
|
Line 892 class zogiLib(Folder):
|
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 1159 def manage_addZogiLibPageTemplate(self,
|
Line 993 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 '' |
|
|