[BACK]Return to zogiLib.py CVS log [TXT] [DIR] Up to [Repository] / zogiLib

Diff for /zogiLib/zogiLib.py between versions 1.31 and 1.43

version 1.31, 2004/07/16 13:47:50 version 1.43, 2004/08/25 16:31:28
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
Line 15  import urllib Line 14  import urllib
 import types  import types
 from Globals import package_home  from Globals import package_home
   
 ZOGIVERSION = "0.9.5 ROC:25.6.2004"  ZOGIVERSION = "0.9.8 ROC:27.7.2004"
   
 def cropf(f):  def cropf(f):
     """returns a float with reduced precision"""      """returns a float with reduced precision"""
Line 383  class zogiLib(Folder): Line 382  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:          if dlTarget:
             self.dlTarget = dlTarget              self.dlTarget = dlTarget
         else:          else:
             self.dlTarget = "digilib"              self.dlTarget = "digilib"
   
           if dlToolbarBaseURL:
               self.dlToolbarBaseURL = dlToolbarBaseURL
           else:
               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 ret
   
   
       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'])              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:
                 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):
Line 452  class zogiLib(Folder): Line 569  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 629  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"""
     self.checkQuery()      self.checkQuery()
           if self.REQUEST.has_key('frametarget'):
               self.dlTarget = self.REQUEST['frametarget']
     bt = self.REQUEST.SESSION['browserType']      bt = self.REQUEST.SESSION['browserType']
         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 604  class zogiLib(Folder): Line 723  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 638  class zogiLib(Folder): Line 759  class zogiLib(Folder):
         else:          else:
             modes=[]              modes=[]
   
         self.REQUEST.SESSION['query'] = dlParams          self.REQUEST.SESSION['ZogiLibQuery'] = dlParams
         self.REQUEST.SESSION['dlModes'] = modes          self.REQUEST.SESSION['dlModes'] = modes
         self.REQUEST.SESSION['dlInfo'] = self.getDLInfo()          self.REQUEST.SESSION['dlInfo'] = self.getDLInfo()
         if not self.REQUEST.SESSION.has_key('browserType'):          if not self.REQUEST.SESSION.has_key('browserType'):
Line 648  class zogiLib(Folder): Line 769  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.REQUEST.SESSION.has_key('ZogiLibQuery')) :
         print "ZOGILIB: have to store query!!"          print "ZOGILIB: have to store query!!"
         self.storeQuery()          self.storeQuery()
         return          return
Line 671  class zogiLib(Folder): Line 792  class zogiLib(Folder):
     def getDLParam(self, param):      def getDLParam(self, param):
         """returns parameter"""          """returns parameter"""
         try:          try:
             return self.REQUEST.SESSION['query'][param]              return self.REQUEST.SESSION['ZogiLibQuery'][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          self.REQUEST.SESSION['ZogiLibQuery'][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.REQUEST.SESSION['ZogiLibQuery']
         # save modes          # save modes
         modes = self.REQUEST.SESSION['dlModes']          modes = self.REQUEST.SESSION['dlModes']
         dlParams['mo'] = string.join(modes, ',')          dlParams['mo'] = string.join(modes, ',')
Line 722  class zogiLib(Folder): Line 843  class zogiLib(Folder):
         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"""
Line 960  class zogiLib(Folder): Line 1089  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:          if dlTarget:
Line 979  class zogiLib(Folder): Line 1110  class zogiLib(Folder):
         else:          else:
             self.dlTarget = "digilib"              self.dlTarget = "digilib"
   
           if dlToolbarBaseURL:
               self.dlToolbarBaseURL = dlToolbarBaseURL
           else:
               self.dlToolbarBaseURL = dlServerURL + "/digimage.jsp?"
   
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
                       
   
       ##
       ## odd stuff
       ##
   
       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="digilib",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 1032  def manage_addZogiLibPageTemplate(self, Line 1203  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 ''
   
Removed from v.1.31  
changed lines
  Added in v.1.43

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