[BACK]Return to OSAS_show.py CVS log [TXT] [DIR] Up to [Repository] / OSAS / OSA_system

Diff for /OSAS/OSA_system/OSAS_show.py between versions 1.1 and 1.36

version 1.1, 2003/09/25 15:25:08 version 1.36, 2010/02/15 19:09:00
Line 1 Line 1
 # Classes for displaying, browsing and organizing the archive  """ Classes for displaying, browsing and organizing the archive
   20040303 Needs configuration for rescaling thumbs
   
   """
   
   import addFolder
   import OSAS_helpers
 from OFS.Folder import Folder  from OFS.Folder import Folder
 from OFS.SimpleItem import SimpleItem  from OFS.SimpleItem import SimpleItem
 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 AccessControl import ClassSecurityInfo
   from Globals import InitializeClass,package_home
   import zLOG
   
 class OSAS_ShowOnline(SimpleItem):  class OSAS_ShowOnline(SimpleItem):
       security=ClassSecurityInfo()
       
     """OnlineBrowser"""      """OnlineBrowser"""
     def __init__(self,id):      def __init__(self,id):
         """initialize a new instance"""          """initialize a new instance"""
Line 13  class OSAS_ShowOnline(SimpleItem): Line 23  class OSAS_ShowOnline(SimpleItem):
   
     meta_type="OSAS_ShowOnline"      meta_type="OSAS_ShowOnline"
   
       security.declareProtected('View','index_html')
     def index_html(self):      def index_html(self):
         """main view"""          """main view"""
         pt=PageTemplateFile('products/OSA_system/OSAS_ViewFiles.zpt').__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','OSAS_ViewFiles.zpt')).__of__(self)
         return pt()          return pt()
           
     def getfilesystem2(self,start,reload=0):      def getfilesystem2(self,start,reload=0):
Line 44  class OSAS_ShowOnline(SimpleItem): Line 55  class OSAS_ShowOnline(SimpleItem):
         return hasMetafile(path)          return hasMetafile(path)
   
     def getMetafile(self,path):      def getMetafile(self,path):
         return getMetafile(path)          
           return getMetafile(path).decode('utf-8')
   
     def toggle_view(self,path,file):      def toggle_view(self,path,file):
         """Oeffnen bzw. schließen der Subfolders"""          """Oeffnen bzw. schliessen der Subfolders"""
         self.tree(path).toggle(path,file)          self.tree(path).toggle(path,file)
         return self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+"?path="+path)          return self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+"?path="+path)
           
       
   InitializeClass(OSAS_ShowOnline)
   
 def manage_AddOSAS_ShowOnlineForm(self):  def manage_AddOSAS_ShowOnlineForm(self):
     """interface for adding the OSAS_root"""      """interface for adding the OSAS_root"""
     pt=PageTemplateFile('products/OSA_system/AddOSAS_ShowOnline.zpt').__of__(self)      pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddOSAS_ShowOnline.zpt')).__of__(self)
     return pt()      return pt()
   
 def manage_AddOSAS_ShowOnline(self,id,RESPONSE=None):  def manage_AddOSAS_ShowOnline(self,id,RESPONSE=None):
Line 64  def manage_AddOSAS_ShowOnline(self,id,RE Line 79  def manage_AddOSAS_ShowOnline(self,id,RE
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
   
   
   class OSAS_StoreOnline(SimpleItem):
       """Webfrontend fuer das Storagesystem"""
       security=ClassSecurityInfo()
       
       def __init__(self,id):
           """initialize a new instance"""
           self.id = id
   
       meta_type="OSAS_StoreOnline"
   
       security.declareProtected('View','index_html')
       def index_html(self):
           """main view"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','OSAS_StoreFiles.zpt')).__of__(self)
           return pt()
   
       def readContexts(self,path):
           """Zeige Contexte"""
           if os.path.exists(path+"/index.meta"):
               
               return readContexts(path)
               
           else:
               
               return []
   
       def rescaleThumbs(self,path):
           """rescale thumbs of images in path"""
   
           dlpath = re.sub('/mpiwg/online/','',self.REQUEST['path'])
           ret=os.popen("ssh archive@nausikaa2.rz-berlin.mpg.de /usr/local/mpiwg/scripts/scaleomat -src=/mpiwg/online -dest=/mpiwg/temp/online/scaled/thumb -dir=%s -scaleto=100 -sync >> /tmp/sc.out &"%dlpath )
           #os.popen("ssh archive@nausikaa2.rz-berlin.mpg.de /usr/local/mpiwg/scripts/scaleomat.pl %s /mpiwg/temp/online/scaled/thumb 90 --replace >> /tmp/sc.out &"% re.sub('/mpiwg/online/','',self.REQUEST['path']))
       zLOG.LOG("OSAS_StoreOnline (rescleThumbs)",zLOG.INFO,ret.read())
       zLOG.LOG("OSAS_StoreOnline (rescleThumbs)",zLOG.INFO,"ssh archive@nausikaa2.rz-berlin.mpg.de /usr/local/mpiwg/scripts/scaleomat -src=/mpiwg/online -dest=/mpiwg/temp/online/scaled/thumb -dir=%s -scaleto=100 -sync >> /tmp/sc.out &"%dlpath)
           self.REQUEST.SESSION['path']=self.REQUEST['path']
           #return self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1'])
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','OSAS_scaled.zpt')).__of__(self)
           return pt()
   
       
       def getfilesystem2(self,start,reload=0):
           """load filesystem"""
   
           k=filesystem2(start,1)
           return k
   
       def tree(self,start):
           """get the filetree"""
           k=browse(start)
           return k
   
       def path_to_link_store(self,path):
           """generates navigation bar for viewfiles"""
           return path_to_link_store(self.REQUEST['URL'],path)
       
       def isdigilib2(self,path):
           """check if digilib"""
           return isdigilib2(path)
   
       def changeName(self,name):
           return changeName(name)
   
       def hasMetafile(self,path):
           return hasMetafile(path)
   
       def getMetafile(self,path):
           
           return getMetafile(path).decode('utf-8')
   
       def toggle_view(self,path,file):
           """Oeffnen bzw. schliessen der Subfolders"""
           self.tree(path).toggle(path,file)
           return self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+"?path="+path)
   
       def isFolder(self,path):
           """Test ob Eintrag ein Folder ist"""
           return isFolder(self,path)
       
       def isScannedDocument(self,path):
           """Test ob Eintrag ein Scanned Document ist"""
           return isScannedDocument(self,path)
   
       def isFullText(self,path,folder_name):
           """Test ob Eintrag ein Folder ist"""
           return isFullText(path,folder_name)
   
       def isPdf(self,path,folder_name):
           """Test ob Eintrag ein Folder mit pdf2 ist"""
           return isPdf(path,folder_name)
   
   
       def isPresentation(self,path,folder_name):
           """Test ob Eintrag ein Folder ist"""
           return isPresentation(path,folder_name)
   
       def date(self):
           return strftime("%d.%m.%Y",localtime()) 
   
       def addFolderForm(self,path):
           """add a new path"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','OSAS_addFolder.zpt')).__of__(self)
           return pt()
   
       def showHelp(self,refType,genericTag):
           """helptext"""
           for reference in self.ZopeFind(self.standardMD):
               if reference[1].title==refType:
                   text=getattr(reference[1],'md_'+genericTag)[2]
                   return text
           return "NO EXPLANATION"
   
       def showHelpTag(self,url,reftype,item):
           """gen javascript for showhelp"""
           url2=url+'/showHelp?refType=%s&genericTag=%s'%(reftype,item)
           ret="""javascript:wd=window.open(\'%s\',\'Help\',\'width=300,height=250\');void(\'\');wd.focus();"""%url2
           return ret
   
       def addFolder(self,path,folder_name,description,archive_creation_date,creator):
           """add the folder to the filesystem and write the metadata files"""
           return addFolder.addFolder(self,path,folder_name,description,archive_creation_date,creator)
   
       def EditIndex(self,path):
           """Editiere das Index Metafile"""
           try:
               dom=xml.dom.minidom.parse(path+"/index.meta")
               indexmeta=dom.toxml(encoding='UTF-8')
           except:
               indexmeta=""
               
           self.REQUEST.SESSION['indexmeta']=indexmeta
           self.REQUEST.SESSION['path']=path
           newtemplate=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editindex')).__of__(self)
           return newtemplate()
   
       def EditIndex2(self):
           """Sichern der Aenderungen in Index.meta"""
           if not self.REQUEST.has_key('fileupload'):
               #newtext=urllib.unquote(self.REQUEST['indexmeta'])
               newtext=self.REQUEST['indexmeta']
              
           else:
               self.file_name=self.REQUEST['fileupload'].filename
               #newtext=self.REQUEST.form['fileupload'].read()
               # HACK DW
               newtext=self.REQUEST['indexmeta']
               
           indexmeta=file(self.REQUEST.SESSION['path']+"/index.meta","w")
           indexmeta.writelines(newtext)
           return self.REQUEST.response.redirect(self.REQUEST['URL1']+"?path="+self.REQUEST.SESSION['path'])
         
       def add_metafile(self):
           """nothing"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','OSAS_addmetadata.zpt')).__of__(self)
           return pt()
   
       def getTextToolsField(self,path,name,default=''):
           """Lese Textoolsfelder aus index.meta im path aus"""
           
           try:
               dom=xml.dom.minidom.parse(path+"/index.meta")
               node=dom.getElementsByTagName('texttool')[0] #getNode
               subnode=node.getElementsByTagName(name)[0]
   
               # bei text wird nur der Folder gebraucht
               if name=="text":
                   splitted=getText(subnode.childNodes).split("/")
                   return splitted[len(splitted)-2]
               else:
                   return getText(subnode.childNodes)
           except:
               return default
               
       def getViewerTemplateSets(self,obj_ids=None):
           """Get the ViewerTemplateSet title for configuration"""
           ret=[]
           
           try:
               viewerTemplateSets=self.ZopeFind(self.viewerTemplateSets,obj_metatypes=['OSAS_viewerTemplateSet'],obj_ids=obj_ids)#assumes viewerTemplateSets folder somewhere in the hierarchie.
               
               for viewerTemplateSet in viewerTemplateSets:
                   ret.append((viewerTemplateSet[1].title,viewerTemplateSet[0],viewerTemplateSet[1]))
               
               return ret
           
           except:
               return [('no ViewerTemplateSetfolders','')]
   
       def changeTemplatesForm(self,path):
           """changeform"""
           path=self.REQUEST.SESSION['path']=path
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeTemplatesForm.zpt')).__of__(self)
           return pt()
   
           
   
       def changeTemplates(self,path,RESPONSE=None):
           """Andere alle Eintraege in index.meta"""
           os.path.walk(path,OSAS_helpers.changeIndexMeta,self.REQUEST.form)
           if RESPONSE is not None:
                   RESPONSE.redirect(self.REQUEST['URL1']+"?path="+self.REQUEST.SESSION['path'])
   
           
   InitializeClass(OSAS_StoreOnline)
           
   def manage_AddOSAS_StoreOnlineForm(self):
       """interface for adding the OSAS_root"""
       pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddOSAS_StoreOnline.zpt')).__of__(self)
       return pt()
   
   def manage_AddOSAS_StoreOnline(self,id,RESPONSE=None):
       """add the OSAS_root"""
       newObj=OSAS_StoreOnline(id)
       self._setObject(id,newObj)
       if RESPONSE is not None:
           RESPONSE.redirect('manage_main')
   
   
   
   
   def readContexts(path):
       """ReadContext from index.meta"""
       dom=xml.dom.minidom.parse(path+"/index.meta")
       nodes=dom.getElementsByTagName('context')
       ret=[]
       
       
       for node in nodes:
           try:
               link=getText(node.getElementsByTagName('link')[0].childNodes)
               name=getText(node.getElementsByTagName('name')[0].childNodes)
               ret.append((link,name))
           except:
               """nothing"""
       return ret
   
   
 ### Ab hier Baustelle  ### Ab hier Baustelle
   
Line 79  from AccessControl import ClassSecurityI Line 327  from AccessControl import ClassSecurityI
 from AccessControl.Role import RoleManager  from AccessControl.Role import RoleManager
 from Acquisition import Implicit  from Acquisition import Implicit
 from Globals import Persistent  from Globals import Persistent
   try:
 from time import strptime  from time import strptime
   except:
       print "ignoring time.strptime import"
       
 from time import strftime  from time import strftime
 import time  import time
 import os.path  import os.path
Line 88  import xml.dom.minidom Line 340  import xml.dom.minidom
 from Products.PageTemplates.PageTemplateFile import PageTemplateFile  from Products.PageTemplates.PageTemplateFile import PageTemplateFile
 from Products.PageTemplates.PageTemplate import PageTemplate  from Products.PageTemplates.PageTemplate import PageTemplate
 import tempfile  import tempfile
 tempfile.tempdir="/var/tmp/archiver"  tempfile.tempdir="/var/tmp"
   
 exclusion=[".HSResource","lost+found","Network Trash Folder","TheFindByContentFolder","TheVolumeSettingsFolder"]  exclusion=[".HSResource","lost+found","Network Trash Folder","TheFindByContentFolder","TheVolumeSettingsFolder"]
   
 class fsentry(Implicit, Persistent, RoleManager):  class fsentry(Implicit, Persistent, RoleManager):
       """File entry class"""        """File entry class"""
       path = ""        path = ""
Line 210  class filesystem(Implicit, Persistent, R Line 463  class filesystem(Implicit, Persistent, R
   
       def archive_the_path(self,path):        def archive_the_path(self,path):
            """parse indexmeta and return digilib path"""             """parse indexmeta and return digilib path"""
              
            try:             try:
                  #f = os.popen("cat "+path+"/index.meta","r")                   #f = os.popen("cat "+path+"/index.meta","r")
                  f =file(path+"/index.meta","r")                   f =file(path+"/index.meta","r")
Line 218  class filesystem(Implicit, Persistent, R Line 472  class filesystem(Implicit, Persistent, R
                         
                  try:                   try:
                        dom = xml.dom.minidom.parseString(lines)                         dom = xml.dom.minidom.parseString(lines)
                          if dom.getElementsByTagName("content-type"):
                        if getText(dom.getElementsByTagName("content-type")[0].childNodes)=="folder":                         if getText(dom.getElementsByTagName("content-type")[0].childNodes)=="folder":
                              """folder nicht archivieren"""                               """folder nicht archivieren"""
                              return 0                               return 0
                        else:                             
                              archive_storage_date=getText(dom.getElementsByTagName("archive-storage-date")[0].childNodes)                               archive_storage_date=getText(dom.getElementsByTagName("archive-storage-date")[0].childNodes)
                         
                              if archive_storage_date=="":                               if archive_storage_date=="":
Line 310  class filesystem2(Implicit, Persistent, Line 565  class filesystem2(Implicit, Persistent,
             
       def getfs(self,start):        def getfs(self,start):
         """load filessystem"""          """load filessystem"""
           
         f = os.popen("find "+ start+" -name '*' ","r")          f = os.popen("find "+ start+" -name '*' ","r")
     lines = f.readlines()      lines = f.readlines()
           
Line 318  class filesystem2(Implicit, Persistent, Line 574  class filesystem2(Implicit, Persistent,
       def loadfs(self,start):        def loadfs(self,start):
         """analyse filesystem"""          """analyse filesystem"""
         for line in self.getfs(start):          for line in self.getfs(start):
                       logging.debug("loadfs: reading %s"%repr(line))
         g=re.search(r"(.*/)(.*)\n",line)          g=re.search(r"(.*/)(.*)\n",line)
         if not g==None:          if not g==None:
                   try:                    try:
Line 326  class filesystem2(Implicit, Persistent, Line 582  class filesystem2(Implicit, Persistent,
                         file=g.group(2)                          file=g.group(2)
                   except:                    except:
                         """nothing"""                          """nothing"""
                     logging.debug("loadfs: file=%s"%repr(file))
                     #if file[0] in ('.',':'):
                         # skip dot-files
                     #    continue
                   if self.node.has_key(path):                    if self.node.has_key(path):
                  elements=self.node[path]                   elements=self.node[path]
                  elements.append(file)                   elements.append(file)
Line 396  class browse(Implicit, Persistent, RoleM Line 656  class browse(Implicit, Persistent, RoleM
       def filterExcluded(self,dir):        def filterExcluded(self,dir):
       ret=[]        ret=[]
       for item in dir:        for item in dir:
         if not item in exclusion:                  if not ((item in exclusion) or (item[0] in ('.',':'))):
             ret.append(item)               ret.append(item) 
       return ret        return ret
           
Line 445  class browse(Implicit, Persistent, RoleM Line 705  class browse(Implicit, Persistent, RoleM
               
 def getfs(start):  def getfs(start):
     """return filesystem"""      """return filesystem"""
           
   
         f = os.popen("find "+ start+" -name '*'","r")          f = os.popen("find "+ start+" -name '*'","r")
     lines = f.readlines()      lines = f.readlines()
         return lines          return lines
Line 535  def path_to_link_view(URL,path): Line 797  def path_to_link_view(URL,path):
       i=i-1        i=i-1
     return string      return string
   
 def path_to_link_store(path):  def path_to_link_store(URL,path):
     """generates navigation bar for viewfiles"""      """generates navigation bar for viewfiles"""
     string=""      string=""
           
Line 552  def path_to_link_store(path): Line 814  def path_to_link_store(path):
           tmppath=os.path.dirname(tmppath)            tmppath=os.path.dirname(tmppath)
   
     while i>=0:      while i>=0:
           string=string+"<a href=storefiles?path="+pathes[i][0]+">"+pathes[i][1]+"</a>/"            string=string+"<a href="+URL+"?path="+pathes[i][0]+">"+pathes[i][1]+"</a>/"
               
       i=i-1        i=i-1
     return string      return string
Line 705  def getText(nodelist): Line 967  def getText(nodelist):
   
 def getBib(nodelist):  def getBib(nodelist):
     rc= "<table border='0'>"      rc= "<table border='0'>"
     print "HI"      
     for node in nodelist:      for node in nodelist:
                   
         if node.nodeType == node.ELEMENT_NODE:          if node.nodeType == node.ELEMENT_NODE:
        """nothing"""         """nothing"""
              
        rc = rc+"<tr><td valign='right'>"+str(node.nodeName)+":</td><td> "+getText(node.childNodes)+"</td></tr>"         rc = rc+"<tr><td valign='right'>"+str(node.nodeName)+":</td><td> "+getText(node.childNodes)+"</td></tr>"
              
     #print rc      #print rc
     return rc+"</table>"      return rc+"</table>"
   
 def getMetafile(path):  def getMetafile(path):
     """get index.meta"""      """get index.meta and translate it to an HTML"""
     html=[]      html=[]
     if not os.path.exists(path+"/index.meta"):      if not os.path.exists(path+"/index.meta"):
                       
Line 724  def getMetafile(path): Line 988  def getMetafile(path):
        f = os.popen("cat "+path+"/index.meta","r")         f = os.popen("cat "+path+"/index.meta","r")
        lines = f.read()         lines = f.read()
        dom = xml.dom.minidom.parseString(lines)         dom = xml.dom.minidom.parseString(lines)
          try:
        name=getText(dom.getElementsByTagName("name")[0].childNodes)          name=getText(dom.getElementsByTagName("name")[0].childNodes) 
          except:
              name="NOT_DEFINED!!!"
          try:
        creator=getText(dom.getElementsByTagName("creator")[0].childNodes)            creator=getText(dom.getElementsByTagName("creator")[0].childNodes)   
          except:
              creator="NOT_DEFINED!!!"
   
          try:
        creation_date=getText(dom.getElementsByTagName("archive-creation-date")[0].childNodes)          creation_date=getText(dom.getElementsByTagName("archive-creation-date")[0].childNodes) 
          except:
              creation_date="NOT_DEFINED!!!"
   
          try:
        description=getText(dom.getElementsByTagName("description")[0].childNodes)          description=getText(dom.getElementsByTagName("description")[0].childNodes) 
          except:
              description="NOT_DEFINED!!!"
              
        try:         try:
         type=getText(dom.getElementsByTagName("content-type")[0].childNodes)           type=getText(dom.getElementsByTagName("content-type")[0].childNodes) 
        except:         except:
Line 748  def getMetafile(path): Line 1027  def getMetafile(path):
     else:      else:
       html=html+"<h4>Info</h4>"        html=html+"<h4>Info</h4>"
         html=html+getBib(bib.childNodes)          html=html+getBib(bib.childNodes)
         print html          
        except:         except:
         """none"""          """none"""
                 
 #        html=html.encode('utf-8','replace')+getBib(bib.childNodes).encode('utf-8','replace')  #        html=html.encode('utf-8','replace')+getBib(bib.childNodes).encode('utf-8','replace')
                 
        return html         return html.encode('utf-8')
   
 def hasMetafile(path):  def hasMetafile(path):
     """get index.meta"""      """get index.meta"""
     return os.path.exists(path+"/index.meta")      return os.path.exists(path+"/index.meta")
     #return path      #return path
   
   
   
 def isdigilib2(path):  def isdigilib2(path):
       """check if folder is candidate for digilib without metadata"""         """check if folder is candidate for digilib without metadata""" 
           try:            try:
Line 810  def isFullText(path,folder_name): Line 1091  def isFullText(path,folder_name):
                           
             return 0              return 0
   
   def isPdf(path,folder_name):
         """check if foldername in path is full text"""
         try:
               dom=xml.dom.minidom.parse(path+"/index.meta")
               for node in dom.getElementsByTagName("dir"):
                     
                     if getText(node.getElementsByTagName("content-type")[0].childNodes).lower()=="pdf":
                           
                           if getText(node.getElementsByTagName("name")[0].childNodes)==folder_name:
                                 return 1
               return 0
         except:
               
               return 0
   
 def isPresentation(path,folder_name):  def isPresentation(path,folder_name):
       """check if foldername in path is full text"""        """check if foldername in path is full text"""
Line 840  def changeName(path): Line 1135  def changeName(path):
             return "digifiles/"+re.search(r"(.*)/mpiwg/production/docuserver/(.*)",path).group(2)              return "digifiles/"+re.search(r"(.*)/mpiwg/production/docuserver/(.*)",path).group(2)
      else:         else:  
             return temp2.group(2)              return temp2.group(2)
       except: # hack - im archivbereich keine online darstellung gibt jetzt ein no zurück.        except: # hack - im archivbereich keine online darstellung gibt jetzt ein no zurueck.
             return "NO"              return "NO"
   
           
Line 958  def getFile(self): Line 1253  def getFile(self):
       return self.REQUEST.SESSION['something']        return self.REQUEST.SESSION['something']
   
 def isFolder(self,path):  def isFolder(self,path):
       """returns TRUE, wenn path ein Folder ist in den weitere Objekte Folder oder Dokumente gelegt werden dürfen"""        """returns TRUE, wenn path ein Folder ist in den weitere Objekte Folder oder Dokumente gelegt werden duerfen"""
       return not isScannedDocument(self,path) # vorläufig sind alle Documente die keine scanned documente sind folder.        return not isScannedDocument(self,path) # vorlaeufig sind alle Documente die keine scanned documente sind folder.
   
 def isScannedDocument(self,path):  def isScannedDocument(self,path):
       """returns TRUE, wenn path der Stammordner eines gescannten Documents ist"""        """returns TRUE, wenn path der Stammordner eines gescannten Documents ist"""
       try:        try:
             f = file(path+"/index.meta","r")              f = file(path+"/index.meta","r")
               logging.debug("isscanneddocument: file=%s"%f)
             lines = f.read()              lines = f.read()
         
             try:              try:
                   dom = xml.dom.minidom.parseString(lines)                    dom = xml.dom.minidom.parseString(lines)
                   content_type=getText(dom.getElementsByTagName("content-type")[0].childNodes)                     content_type=getText(dom.getElementsByTagName("content-type")[0].childNodes) 
                   if (content_type=="scanned-document") or (content_type=="scanned document"):                    logging.debug("isscanneddocument: content_type=%s"%content_type)
                     if (content_type=="scanned-document") or (content_type=="scanned document") or (content_type=="fulltext document"):
                         return 1                          return 1
                   else:                    else:
                         return 0                          return 0
Line 986  def date(self): Line 1282  def date(self):
   
               
               
 def EditIndex(self,path):  
       try:  
             dom=xml.dom.minidom.parse(path+"/index.meta")  
             indexmeta=dom.toxml()  
       except:  
             indexmeta=""  
       self.REQUEST.SESSION['indexmeta']=indexmeta  
       self.REQUEST.SESSION['path']=path  
       newtemplate=PageTemplateFile('/usr/local/mpiwg/Zope/Extensions/editindex').__of__(self)  
       return newtemplate()  
   
 def EditIndex2(self):  
       if not self.REQUEST.has_key('fileupload'):  
             #newtext=urllib.unquote(self.REQUEST['indexmeta'])  
             newtext=self.REQUEST['indexmeta']  
             print newtext  
       else:  
             self.file_name=self.REQUEST['fileupload'].filename  
             #newtext=self.REQUEST.form['fileupload'].read()  
             # HACK DW  
             newtext=self.REQUEST['indexmeta']  
         
       indexmeta=file(self.REQUEST.SESSION['path']+"/index.meta","w")  
       indexmeta.writelines(newtext)  
       return self.REQUEST.response.redirect("storage/storefiles?path="+self.REQUEST.SESSION['path'])  
   
       
Removed from v.1.1  
changed lines
  Added in v.1.36

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