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

Diff for /zogiLib/zogiLib.py between versions 1.59 and 1.68

version 1.59, 2005/11/08 10:13:30 version 1.68, 2007/05/04 14:20:42
Line 18  import string Line 18  import string
 import urllib  import urllib
 import xml.dom.minidom  import xml.dom.minidom
   
 ZOGIVERSION = "0.10.1a ROC 3.11.2005"  ZOGIVERSION = "0.10.4b ROC 13.11.2006"
   
 def cropf(f):  def cropf(f):
     """returns a float with reduced precision"""      """returns a float with reduced precision"""
     return float(int(f * 10000)/10000.0)      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):  def browserCheck(self):
     """check the browsers request to find out the browser type"""      """check the browsers request to find out the browser type"""
     bt = {}      bt = {}
Line 78  class zogiImage(SimpleItem): Line 57  class zogiImage(SimpleItem):
     """einzelnes Image"""      """einzelnes Image"""
     meta_type="zogiImage"      meta_type="zogiImage"
   
     manage_options=SimpleItem.manage_options+(      manage_options=(
         {'label':'Main config','action':'changeZogiImageForm'},          {'label':'Main config','action':'changeZogiImageForm'},
        )         )+SimpleItem.manage_options
           
           
     def __init__(self,id,title,baseUrl,queryString,content_type='',precondition=''):      def __init__(self,id,title,baseUrl,queryString,content_type='',precondition=''):
Line 100  class zogiImage(SimpleItem): Line 79  class zogiImage(SimpleItem):
     #    """getUrlData"""      #    """getUrlData"""
     #    return urllib.urlopen(self.baseUrl+self.queryString)      #    return urllib.urlopen(self.baseUrl+self.queryString)
   
     def changeZogiImageForm(self):      changeZogiImageForm = PageTemplateFile('zpt/changeZogiImageForm.zpt', globals())
         """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):      def index_html(self, REQUEST, RESPONSE):
         """service the request by redirecting to digilib server"""          """service the request by redirecting to digilib server"""
         RESPONSE.redirect(self.baseUrl+self.queryString)          # use status 307 = moved temporarily
           RESPONSE.redirect(self.baseUrl+self.queryString, status=307)
         return ''          return ''
                   
   
     def rescale(self,width=None,height=None):      def rescale(self,width=None,height=None):
         """andere parameter im querystring"""          """andere parameter im querystring"""
         qs=cgi.parse_qs(self.queryString)          qs=cgi.parse_qs(self.queryString)
Line 131  class zogiImage(SimpleItem): Line 100  class zogiImage(SimpleItem):
         if height:          if height:
             qs['dh']=height              qs['dh']=height
   
           
         qsneu=urllib.urlencode(qs)          qsneu=urllib.urlencode(qs)
         self.queryString=qsneu          self.queryString=qsneu
         return "done"          return "done"
           
       
       def setWithDigilibURL(self,digilibUrl):
           """take all parameters from digilib URL string"""
           base = re.match('(.*?/Scaler\?)(.*)', digilibUrl)
           if base is not None:
               params = base.group(2).split('&')
               newparams = []
               # filter out the parameters we want
               for p in params:
                   (key, val) = p.split('=')
                   if key in ['fn','pn','dw','dh','ww','wh','wx','wy','mo']:
                       newparams.append(p)
               # set the new parameters
               if len(newparams) > 1:
                   self.baseUrl = base.group(1)
                   self.queryString = '&'.join(newparams)
                   return True
           
           return False
       
       
       def changeZogiImage(self,title,baseUrl, queryString, digilibUrl=None, RESPONSE=None):
           """change it"""
           self.title=title
           self.baseUrl=baseUrl
           self.queryString=queryString
           if digilibUrl is not None and len(digilibUrl) > 0:
               self.setWithDigilibURL(digilibUrl)
               
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
       
 def manage_addZogiImageForm(self):  def manage_addZogiImageForm(self):
     """Form for adding"""      """Form for adding"""
     pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiImage.zpt')).__of__(self)      pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiImage.zpt')).__of__(self)
     return pt()      return pt()
   
   
 def manage_addZogiImage(self,id,title,baseUrl, queryString,RESPONSE=None):  def manage_addZogiImage(self,id,title,baseUrl,queryString,digilibUrl=None,RESPONSE=None):
     """add zogiimage"""      """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 digilibUrl is not None and len(digilibUrl) > 0:
           newObj.setWithDigilibURL(digilibUrl)
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
   
Line 184  class zogiLib(Folder): Line 187  class zogiLib(Folder):
     main_book      = PageTemplateFile('zpt/main_book', globals())      main_book      = PageTemplateFile('zpt/main_book', globals())
     main_image     = PageTemplateFile('zpt/main_image', globals())      main_image     = PageTemplateFile('zpt/main_image', globals())
     main_metaData  = PageTemplateFile('zpt/main_metadata', globals())      main_metaData  = PageTemplateFile('zpt/main_metadata', globals())
     main_static    = PageTemplateFile('zpt/main_static', globals())      #main_static    = PageTemplateFile('zpt/main_static', globals())
     options        = PageTemplateFile('zpt/options', globals())      options        = PageTemplateFile('zpt/options', globals())
     changeForm     = PageTemplateFile('zpt/changeForm', globals())      #changeForm     = PageTemplateFile('zpt/changeForm', globals())
   
 # display templates  # display templates
     aux_divs           = PageTemplateFile('zpt/aux_divs', globals())      aux_divs           = PageTemplateFile('zpt/aux_divs', globals())
     aux_divsN4         = PageTemplateFile('zpt/aux_divsN4', globals())      #aux_divsN4     = PageTemplateFile('zpt/aux_divsN4', globals())
     img_div        = PageTemplateFile('zpt/img_div', globals())      img_div        = PageTemplateFile('zpt/img_div', globals())
           
 # javascripts  # javascripts
Line 343  class zogiLib(Folder): Line 346  class zogiLib(Folder):
         """get DLInfo from digilib server"""          """get DLInfo from digilib server"""
         paramH={}          paramH={}
         baseUrl=self.getDLBaseUrl()+"/dlInfo-xml.jsp"          baseUrl=self.getDLBaseUrl()+"/dlInfo-xml.jsp"
         print "getdlinfo: ", baseUrl          #print "getdlinfo: ", baseUrl
         try:          try:
             url=urllib.urlopen(baseUrl+'?'+self.getAllDLParams())              url=urllib.urlopen(baseUrl+'?'+self.getAllDLParams())
             dom=xml.dom.minidom.parse(url)              dom=xml.dom.minidom.parse(url)
Line 365  class zogiLib(Folder): Line 368  class zogiLib(Folder):
             url += otherbase              url += otherbase
         else:          else:
             url += self.basePath              url += self.basePath
         # should end with "/"          # should still end with "/"
         if len(url) > 0 and url[-1] != '/':          if len(url) > 0 and url[-1] != '/':
             url += '/'              url += '/'
         return url          return url
Line 410  class zogiLib(Folder): Line 413  class zogiLib(Folder):
         return True          return True
           
                   
     def createScalerImg(self, requestString=None, bottom=0, side=0, width=500, height=500):      def createScalerImg(self, requestString=None, bottom=0, side=0, width=500, height=500, options=None):
         """generate Scaler IMG Tag"""          """generate Scaler IMG Tag"""
         self.checkQuery()          self.checkQuery()
         bt = self.REQUEST.SESSION['browserType']          bt = self.getBrowserType()
         # override with parameters from session          # override with parameters from session
         if  self.REQUEST.SESSION.has_key('scalerDiv'):          if  self.REQUEST.SESSION.has_key('scalerDiv'):
             (requestString, bottom, side, width, height) = self.REQUEST.SESSION['scalerDiv']              (requestString, bottom, side, width, height) = self.REQUEST.SESSION['scalerDiv']
Line 421  class zogiLib(Folder): Line 424  class zogiLib(Folder):
         if not requestString:          if not requestString:
             requestString = self.getAllDLParams()              requestString = self.getAllDLParams()
         url = self.getScalerUrl(requestString=requestString)          url = self.getScalerUrl(requestString=requestString)
           # take insets from options if present
           if options is not None:
               side = options.get('side', side)
               bottom = options.get('bottom', bottom)
         # construct bottom and side insets          # construct bottom and side insets
         b_par = ""          b_par = ""
         s_par = ""          s_par = ""
Line 466  class zogiLib(Folder): Line 473  class zogiLib(Folder):
         tp = "main_template"          tp = "main_template"
         tpt = self.layout          tpt = self.layout
                   
         if hasattr(self, 'template'):          if not hasattr(self, 'template'):
             pt = getattr(self.template, 'main_'+tpt)              # create template folder if it doesn't exist
         else:              print "no template folder -- creating"
             pt = getattr(self, 'main_'+tpt)              self.manage_addFolder('template')
                           
           pt = getattr(self.template, 'main_'+tpt)
         return pt()          return pt()
   
     def checkQuery(self):      def checkQuery(self):
         """make shure that the query has been saved"""          """make shure that the query has been saved"""
         if not self.REQUEST.has_key('dlParams'):          if not self.REQUEST.has_key('dlParams'):
             self.storeQuery()              self.storeQuery()
         if not self.REQUEST.SESSION.has_key('browserType'):  
             bt = browserCheck(self)  
             self.REQUEST.SESSION.set('browserType', bt)              
   
     def storeQuery(self, more=None, withpt=False):      def storeQuery(self, more=None, withpt=False):
         """parse query parameters into a hash in REQUEST"""          """parse query parameters into a hash in REQUEST"""
Line 562  class zogiLib(Folder): Line 567  class zogiLib(Folder):
                           
         return self.display()          return self.display()
   
       def getBrowserType(self):
           """get browser type object"""
           if self.REQUEST.SESSION.has_key('browserType'):
               return self.REQUEST.SESSION['browserType']
           else:
               bt = browserCheck(self)
               self.REQUEST.SESSION.set('browserType', bt)                        
               return bt
   
   
     def display(self):      def display(self):
         """(re)display page"""          """(re)display page"""
Line 585  class zogiLib(Folder): Line 599  class zogiLib(Folder):
         """returns dlTarget"""          """returns dlTarget"""
         self.checkQuery()          self.checkQuery()
         s = self.dlTarget          s = self.dlTarget
         if s == None:          if (s is None) or (s == ""):
             s = ""  #            s = ""
 #         s = 'dl'              s = 'dl'
 #         if self.getDLParam('fn'):              if self.getDLParam('fn'):
 #             s += "_" + self.getDLParam('fn')                  s += "_" + self.getDLParam('fn')
 #         if self.getDLParam('pn'):              if self.getDLParam('pn'):
 #             s += "_" + self.getDLParam('pn')                  s += "_" + self.getDLParam('pn')
   
         return s          return s
   
     def getPN(self):      def getPN(self):
         """pagenums"""          """pagenumber"""
         pn = int(self.getDLParam('pn', 1))          pn = int(self.getDLParam('pn', 1))
         return pn          return pn
           
     def getPT(self):      def getPT(self):
         """pagenums"""          """number of total pages"""
         pt = self.getDLParam('pt', None)          pt = self.getDLParam('pt', None)
         if pt is None:          if pt is None:
             # get pt from dlInfo              # get pt from dlInfo
Line 654  class zogiLib(Folder): Line 669  class zogiLib(Folder):
     def dl_StaticHTML(self):      def dl_StaticHTML(self):
         """set rendering to static HTML"""          """set rendering to static HTML"""
         self.checkQuery()          self.checkQuery()
         self.REQUEST.SESSION['browserType']['staticHTML'] = True          self.getBrowserType()['staticHTML'] = True
         return self.display()          return self.display()
   
     def dl_DynamicHTML(self):      def dl_DynamicHTML(self):
         """set rendering to dynamic HTML"""          """set rendering to dynamic HTML"""
         self.checkQuery()          self.checkQuery()
         self.REQUEST.SESSION['browserType']['staticHTML'] = False          self.getBrowserType()['staticHTML'] = False
         return self.display()          return self.display()
                   
     def dl_HMirror(self):      def dl_HMirror(self):
Line 786  class zogiLib(Folder): Line 801  class zogiLib(Folder):
         self.setDLParam('mk', None)          self.setDLParam('mk', None)
         return self.display()          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):      def dl_db(self,db):
         """set db"""          """set db"""
         self.setDLParam('db',db)          self.setDLParam('db',db)
Line 888  def manage_addZogiLibPageTemplateForm(se Line 893  def manage_addZogiLibPageTemplateForm(se
     pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiLibPageTemplateForm')).__of__(self)      pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/addZogiLibPageTemplateForm')).__of__(self)
     return pt()      return pt()
   
 def manage_addZogiLibPageTemplate(self, id='zogiLibMainTemplate', title=None, layout=None, text=None,  def manage_addZogiLibPageTemplate(self, title=None, layout=None, text=None,
                            REQUEST=None, submit=None):                             REQUEST=None, submit=None):
     "Add a Page Template with optional file content."      "Add a Page Template with optional file content."
   
     id = str(id)      if not layout: layout = "book"
       id = 'main_%s'%layout
     self._setObject(id, zogiLibPageTemplate(id))      self._setObject(id, zogiLibPageTemplate(id))
     ob = getattr(self, id)      ob = getattr(self, id)
     if not layout: layout = "book"      ob.pt_edit(open(os.path.join(package_home(globals()),'zpt/main_%s.zpt'%layout)).read(),'text/html')
     ob.pt_edit(open(os.path.join(package_home(globals()),'zpt/zogiLibMain_%s.zpt'%layout)).read(),None)  
     if title:      if title:
         ob.pt_setTitle(title)          ob.pt_setTitle(title)
     try:      try:
         u = self.DestinationURL()          url = self.DestinationURL()
     except AttributeError:      except AttributeError:
         u = REQUEST['URL1']          url = REQUEST['URL1']
                   
     u = "%s/%s" % (u, urllib.quote(id))      url = "%s/%s" % (url, urllib.quote(id))
     REQUEST.RESPONSE.redirect(u+'/manage_main')      REQUEST.RESPONSE.redirect(url+'/manage_main')
     return ''      return ''
   
Removed from v.1.59  
changed lines
  Added in v.1.68

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