--- zogiLib/zogiLib.py	2004/06/25 16:59:45	1.30
+++ zogiLib/zogiLib.py	2004/08/25 16:31:28	1.43
@@ -1,4 +1,3 @@
-
 from Products.PageTemplates.PageTemplateFile import PageTemplateFile
 from Products.PageTemplates.PageTemplate import PageTemplate
 from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
@@ -7,7 +6,7 @@ from webdav.common import rfc1123_date
 
 import xml.dom.minidom
 from OFS.Folder import Folder
-from xml_helpers import getText
+from xml_helpers import getUniqueElementText,getText
 import os
 import re
 import string
@@ -15,7 +14,7 @@ import urllib
 import types
 from Globals import package_home
 
-ZOGIVERSION = "0.9.5 ROC:25.6.2004"
+ZOGIVERSION = "0.9.8 ROC:27.7.2004"
 
 def cropf(f):
     """returns a float with reduced precision"""
@@ -383,42 +382,160 @@ class zogiLib(Folder):
     """StandardElement"""
 
     meta_type="zogiLib"
+    #xxxx
 
     manage_options = Folder.manage_options+(
             {'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"""
 
         self.id=id
         self.title=title
-        self.digilibBaseUrl=digilibBaseUrl
-        self.localFileBase=localFileBase
+        self.dlServerURL = dlServerURL
         self.basePath=basePath
-        self.layout=version
+        self.layout=layout
         if dlTarget:
             self.dlTarget = dlTarget
         else:
             self.dlTarget = "digilib"
 
+        if dlToolbarBaseURL:
+            self.dlToolbarBaseURL = dlToolbarBaseURL
+        else:
+            self.dlToolbarBaseURL = dlServerURL + "/digimage.jsp?"
+
+
     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 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):
         """get DLInfo from digilib server"""
         paramH={}
-        baseUrl=re.sub("servlet/Scaler","dlInfo-xml.jsp",self.digilibBaseUrl)
+        baseUrl=self.dlServerURL+"/dlInfo-xml.jsp"
         try:
-            url=urllib.urlopen(baseUrl+self.REQUEST['QUERY_STRING'])
+            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 null
+            return {}
 
 
     def createHeadJS(self):
@@ -452,7 +569,7 @@ class zogiLib(Folder):
         # if not explicitly defined take normal request
         if not requestString:
             requestString = self.getAllDLParams()
-        url = self.digilibBaseUrl+requestString
+        url = self.dlServerURL+'/servlet/Scaler?'+requestString
         # construct bottom and side insets
         b_par = ""
         s_par = ""
@@ -512,20 +629,27 @@ class zogiLib(Folder):
 
     def dl_lib_js(self):
         """javascript"""
-        return sendFile(self, 'js/dl_lib.js', 'text/plain')
+        return sendFile(self, 'js/dllib.js', 'text/plain')
 
     def js_lib_js(self):
         """javascript"""
-        return sendFile(self, 'js/js_lib.js', 'text/plain')
+        return sendFile(self, 'js/baselib.js', 'text/plain')
 
     def optionwindow(self):
         """showoptions"""
 	self.checkQuery()
+        if self.REQUEST.has_key('frametarget'):
+            self.dlTarget = self.REQUEST['frametarget']
 	bt = self.REQUEST.SESSION['browserType']
         if bt['staticHTML']:
             pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/optionwindow_static.zpt')).__of__(self)
         else:
-            pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/optionwindow.zpt')).__of__(self)
+            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):
@@ -599,10 +723,12 @@ class zogiLib(Folder):
 	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"
                 
@@ -633,7 +759,7 @@ class zogiLib(Folder):
         else:
             modes=[]
 
-        self.REQUEST.SESSION['query'] = dlParams
+        self.REQUEST.SESSION['ZogiLibQuery'] = dlParams
         self.REQUEST.SESSION['dlModes'] = modes
         self.REQUEST.SESSION['dlInfo'] = self.getDLInfo()
         if not self.REQUEST.SESSION.has_key('browserType'):
@@ -643,7 +769,7 @@ class zogiLib(Folder):
 
     def checkQuery(self):
 	"""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!!"
 	    self.storeQuery()
         return
@@ -666,18 +792,18 @@ class zogiLib(Folder):
     def getDLParam(self, param):
         """returns parameter"""
         try:
-            return self.REQUEST.SESSION['query'][param]
+            return self.REQUEST.SESSION['ZogiLibQuery'][param]
         except:
             return
 
     def setDLParam(self, param, value):
         """sets parameter"""
-        self.REQUEST.SESSION['query'][param] = value
+        self.REQUEST.SESSION['ZogiLibQuery'][param] = value
         return
 
     def getAllDLParams(self):
         """parameter string for digilib"""
-        dlParams = self.REQUEST.SESSION['query']
+        dlParams = self.REQUEST.SESSION['ZogiLibQuery']
         # save modes
         modes = self.REQUEST.SESSION['dlModes']
         dlParams['mo'] = string.join(modes, ',')
@@ -717,7 +843,15 @@ class zogiLib(Folder):
         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()
@@ -955,18 +1089,20 @@ class zogiLib(Folder):
             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,digilibBaseUrl, localFileBase, version, basePath, dlTarget, RESPONSE=None):
+    def changeZogiLib(self,title,dlServerURL, version, basePath, dlTarget, dlToolbarBaseURL, RESPONSE=None):
         """change it"""
         self.title=title
-        self.digilibBaseUrl=digilibBaseUrl
-        self.localFileBase=localFileBase
+        self.dlServerURL=dlServerURL
         self.basePath = basePath
         self.layout=version
         if dlTarget:
@@ -974,18 +1110,58 @@ class zogiLib(Folder):
         else:
             self.dlTarget = "digilib"
 
+        if dlToolbarBaseURL:
+            self.dlToolbarBaseURL = dlToolbarBaseURL
+        else:
+            self.dlToolbarBaseURL = dlServerURL + "/digimage.jsp?"
+
         if RESPONSE is not None:
             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):
     """interface for adding zogilib"""
     pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiLibForm')).__of__(self)
     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"""
-    newObj=zogiLib(id,title,digilibBaseUrl, localFileBase, version, basePath, dlTarget)
+    newObj=zogiLib(id,title,dlServerURL, version, basePath, dlTarget, dlToolbarBaseURL)
     self.Destination()._setObject(id,newObj)
     if RESPONSE is not None:
         RESPONSE.redirect('manage_main')
@@ -1027,3 +1203,4 @@ def manage_addZogiLibPageTemplate(self,
     u = "%s/%s" % (u, urllib.quote(id))
     REQUEST.RESPONSE.redirect(u+'/manage_main')
     return ''
+