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

Diff for /OSAS/OSA_system/OSAS_addfiles.py between versions 1.10 and 1.29

version 1.10, 2003/10/11 10:54:13 version 1.29, 2004/04/15 21:30:42
Line 1 Line 1
 # Methoden und Classen zum Hinzufuegen von Dokumenten  # Methoden und Classen zum Hinzufuegen von Dokumenten
   
   
   from OSAS_helpers import readArchimedesXML, getText
   import os
 import xml.dom.minidom  import xml.dom.minidom
 from Products.ECHO_content import ECHO_collection  import re
 import urllib  import urllib
 import OSAS_add  import OSAS_add
 import OSAS_show  import OSAS_show
Line 11  from AccessControl import ClassSecurityI Line 14  from AccessControl import ClassSecurityI
 from Globals import InitializeClass  from Globals import InitializeClass
 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 archive # check if this is necessary
   
   
   from xml.sax import make_parser
   from xml.sax.handler import ContentHandler
   
   def spaces(depth):
       """needed in XMLtoTree"""
       tmp=""
       k=0
       while k<2*depth:
           k+=1
           tmp=tmp+"&nbsp;"+"&nbsp;"
       return tmp
   
   
 class OSAS_add_Document(Folder):  class OSAS_add_Document(Folder):
     """Hinzufuegen eines Dokumentes zum Storage"""      """Hinzufuegen eines Dokumentes zum Storage"""
Line 31  class OSAS_add_Document(Folder): Line 49  class OSAS_add_Document(Folder):
     security.declarePublic('add_Document_config')      security.declarePublic('add_Document_config')
     def add_Document_config(self):      def add_Document_config(self):
         """Main configuration"""          """Main configuration"""
         pt=PageTemplateFile('Products/OSA_system/ChangeOSAS_addDocument.zpt').__of__(self)          pt=PageTemplateFile('Products/OSA_system/zpt/ChangeOSAS_addDocument.zpt').__of__(self)
         return pt()          return pt()
           
     security.declarePublic('change_OSAS_add_Document')      security.declarePublic('change_OSAS_add_Document')
Line 44  class OSAS_add_Document(Folder): Line 62  class OSAS_add_Document(Folder):
     security.declarePublic('index_html')      security.declarePublic('index_html')
     def index_html(self):      def index_html(self):
         """stantard aufruf"""          """stantard aufruf"""
         return OSAS_add.add(self,no_upload=1)          return OSAS_add.add(self.standardMD,no_upload=1)
   
   
     security.declarePublic('add2')      security.declarePublic('add2')
     def add2(self):      def add2(self):
         """ anlegen naechster schritt"""          """ anlegen naechster schritt"""
         return OSAS_add.add2(self)          return OSAS_add.add2(self.standardMD)
   
     def add3(self):      def add3(self):
         """Foldername"""          """Foldername"""
Line 68  class OSAS_add_Document(Folder): Line 86  class OSAS_add_Document(Folder):
         """write new index.meta file"""          """write new index.meta file"""
         return OSAS_add.add6(self)          return OSAS_add.add6(self)
   
       def addText2(self):
           """add only a text"""
           metadata=OSAS_add.parse_query_string(self.REQUEST['QUERY_STRING'])
           metadata['archive-creation-date']=OSAS_add.date(self)
           metadata['creator']=self.REQUEST['creator']
           metadata['description']=self.REQUEST['content_description']
       metadata['archive-path']=os.path.split(self.REQUEST.SESSION['path'])[0]
       #metadata['folder_name']=self.REQUEST.SESSION['folder_name']
       metadata['folder_name']=os.path.split(self.REQUEST.SESSION['path'])[1]
       metadata['content-type']="fulltext document"
       self.reftype=self.REQUEST.SESSION['reftype']
       self.REQUEST.SESSION['add_metadata']=metadata   
       self.add_metadata=metadata
       self.metadata=self.REQUEST.SESSION['metadata']
       self.metadataprint=""
       for tag in self.metadata.keys():
           self.metadataprint=self.metadataprint+"<"+tag+">"+self.metadata[tag]+"</"+tag+">\n"
   
       newtemplate=PageTemplateFile('Products/OSA_system/zpt/index_meta').__of__(self)
       newtemplate.content_type="text/plain"
       renderxml = newtemplate()
           metapath=self.REQUEST.SESSION['path']+"/index.meta"
       
       
       f=open(metapath,'w')
       f.writelines(renderxml)
       f.close()
       os.chmod(metapath,0664)
       os.popen('chmod -R 0775 %s'%self.add_metadata['archive-path']+"/"+self.add_metadata['folder_name']) 
       
           return OSAS_add.addText2(self)
   
     def addImages(self,path):      def addImages(self,path):
         """Hinzufügen eines neuen Imagesfolders"""          """Hinzufügen eines neuen Imagesfolders"""
Line 80  class OSAS_add_Document(Folder): Line 129  class OSAS_add_Document(Folder):
           
 def manage_AddOSAS_add_DocumentForm(self):  def manage_AddOSAS_add_DocumentForm(self):
     """interface for adding the OSAS_add_Metadata"""      """interface for adding the OSAS_add_Metadata"""
     pt=PageTemplateFile('Products/OSA_system/AddOSAS_document.zpt').__of__(self)      pt=PageTemplateFile('Products/OSA_system/zpt/AddOSAS_document.zpt').__of__(self)
     return pt()      return pt()
   
 def manage_AddOSAS_add_Document(self,id,RESPONSE=None):  def manage_AddOSAS_add_Document(self,id,RESPONSE=None):
Line 113  class OSAS_add_Text(Folder): Line 162  class OSAS_add_Text(Folder):
     security.declarePublic('add_Text_config')      security.declarePublic('add_Text_config')
     def add_Text_config(self):      def add_Text_config(self):
         """Main configuration"""          """Main configuration"""
         pt=PageTemplateFile('Products/OSA_system/ChangeOSAS_addText.zpt').__of__(self)          pt=PageTemplateFile('Products/OSA_system/zpt/ChangeOSAS_addText.zpt').__of__(self)
         return pt()          return pt()
           
     security.declarePublic('change_OSAS_add_Text')      security.declarePublic('change_OSAS_add_Text')
Line 132  class OSAS_add_Text(Folder): Line 181  class OSAS_add_Text(Folder):
         return OSAS_add.addText2(self)          return OSAS_add.addText2(self)
 def manage_AddOSAS_add_TextForm(self):  def manage_AddOSAS_add_TextForm(self):
     """interface for adding the OSAS_add_Metadata"""      """interface for adding the OSAS_add_Metadata"""
     pt=PageTemplateFile('Products/OSA_system/AddOSAS_text.zpt').__of__(self)      pt=PageTemplateFile('Products/OSA_system/zpt/AddOSAS_text.zpt').__of__(self)
     return pt()      return pt()
   
 def manage_AddOSAS_add_Text(self,id,RESPONSE=None):  def manage_AddOSAS_add_Text(self,id,RESPONSE=None):
Line 145  def manage_AddOSAS_add_Text(self,id,RESP Line 194  def manage_AddOSAS_add_Text(self,id,RESP
                           
 InitializeClass(OSAS_add_Text)  InitializeClass(OSAS_add_Text)
   
   
 class OSAS_add_contextData(Folder):  class OSAS_add_contextData(Folder):
     """Einfuegen eines Documentes in eine Collection"""      """Einfuegen eines Documentes in eine Collection"""
           
Line 153  class OSAS_add_contextData(Folder): Line 203  class OSAS_add_contextData(Folder):
                           
     meta_type='OSAS_add_contextData'          meta_type='OSAS_add_contextData'    
   
       def XmlToTree(self,URL):
           """Collection XML to Tree"""
           
           
           class requestHandler(ContentHandler):
               def __init__(self):
                   self.depth=0
                   self.retStr=""
                   
               def startElement(self,name,attrs):
                   if name=="element":
                       self.depth+=1
                       begin=""
                       end=""
                       if self.depth==1:
                           begin="<b>"
                           end="</b>"
                           
                       self.retStr+=spaces(self.depth)+"<input type='radio' name='collection' value='%s'>%s</input>"%(attrs.get('url'),begin+attrs.get('name')+end)+"<br>\n"
   
   
                       
               def endElement(self,name):
                   if name=="element":
                       self.depth-=1
   
   
           try:
               URL+="/getCollectionTreeXML"
               parser=make_parser()
               curHandler=requestHandler()
               parser.setContentHandler(curHandler)
   
               parser.parse(urllib.urlopen(URL))
               return curHandler.retStr
           except:
               return urllib.urlopen(URL).read()
           
     def __init__(self,id,collection):      def __init__(self,id,collection):
         self.id=id          self.id=id
         self.collection=collection          self.collection=collection
   
     def getChilds(self,id,depth,items):  
         list=[]  
         for object in items:  
             if (depth==object[2])&(id==object[0]):  
                 list.append(object)  
         return list  
   
     def printChilds(self,startItem,depth,items,enddepth):  
   
         def spaces(depth):  
             tmp=""  
             k=0  
             while k<2*depth:  
                 k+=1  
                 tmp=tmp+"&nbsp;"+"&nbsp;"  
             return tmp  
   
         def retLink(object):      def getPartners(self,URL):
             return "<input type='checkbox' name='collection' value='%s'>%s</input>"% (string.join(object.getPhysicalPath(),"."),object.title)          """Zeige Partnerliste"""
           class requestHandler(ContentHandler):
               def __init__(self):
                   self.ret=[]
                             
         depth+=1              def startElement(self,name,attrs):
         childs=self.getChilds(startItem,depth,items)                  if name=="partner":
         tmp=""                      self.ret.append((attrs.get('id'),attrs.get('title')))
         for child in childs:  
             if depth < enddepth:  
                 tmp=tmp+spaces(depth)  
                                   
                 tmp= tmp+retLink(child[1])+"<br>"+self.printChilds(child[1],depth,items,enddepth)+"<br>"  
             else:  
                 tmp=tmp+spaces(2*depth)  
                 tmp = tmp+retLink(child[1])+"<br>"  
   
         return tmp          URL+="/getPartnersXML"
                                           
     def generateTree(self,depth=10):          try:
         """Erzeugt HTML-Tree der Collection"""  
           
         exec("items=self.getPhysicalRoot()."+self.collection+".getCollectionTree()")              parser=make_parser()
         #print items[0][0]              curHandler=requestHandler()
               parser.setContentHandler(curHandler)
   
         childs=self.printChilds(items[0][0],0,items,depth)              parser.parse(urllib.urlopen(URL))
               return curHandler.ret
           except:
               return [("",urllib.urlopen(URL).read())]
                   
         return childs  
   
     def getPartners(self):  
         """Zeige Partnerliste"""  
         exec("items=self.getPhysicalRoot()."+self.collection+".partners.getPartners()")  
         return items  
     def addContextData(self,path):      def addContextData(self,path):
         """Hinzufügen zu einer Sammlung"""          """Hinzufügen zu einer Sammlung"""
         try:          try:
             urllib.urlopen(self.REQUEST['SERVER_URL']+path+"/index.meta")              urllib.urlopen(self.REQUEST['SERVER_URL']+path+"/index.meta")
                           
         except:          except:
             return "index.meta file has to exist!"              return self.REQUEST['SERVER_URL']+path+"/index.meta file has to exist!"
   
         links=[(path,'standard storage')]          links=[(path,'standard storage')]
                   
         links+=OSAS_show.readContexts(path) # auslesen von contexten für den link          links+=OSAS_show.readContexts(path) # auslesen von contexten für den link
         #print "LINK",links          #print "LINK",links
           #return links
         self.REQUEST.SESSION['links']=links          self.REQUEST.SESSION['links']=links
         pt=PageTemplateFile('Products/OSA_system/contextDataMain.zpt').__of__(self)          pt=PageTemplateFile('Products/OSA_system/zpt/contextDataMain.zpt').__of__(self)
         return pt()          return pt()
           
           
     def addContextData2(self,path,collection,context,science,practice,source_type,period,link,label,description,content_type,responsible,credits):      def addContextData2(self,path,collection,link,label,description,content_type,responsible,weight,credits=None):
         """Hinzufuegen der Resource"""          """Hinzufuegen der Resource"""
         splitted=path.split("/")          splitted=path.split("/")
                   #print "BLU"
         id=splitted[len(splitted)-1]          id=splitted[len(splitted)-1]
         title=splitted[len(splitted)-1]          title=splitted[len(splitted)-1]
         metalink=self.REQUEST['SERVER_URL']+path+"/index.meta"          metalink=self.REQUEST['SERVER_URL']+path+"/index.meta"
           
         #link=TOBEDONE"          #link=TOBEDONE"
         """Hinzufügen der Ressource"""          """Hinzufügen der Ressource"""
   
           params=urllib.urlencode({'id':id,'title':title,'link':link,'label':label,'description':description,'contentType':content_type,'responsible':responsible,'weight':weight,'credits':credits,'metalink':metalink})
   
           retStr=urllib.urlopen(collection+"/addResource",params).read()
                   
         exec("collection_object=self"+collection)      if not retStr:
               return "An Error occured adding the resource\n"
                   
         ECHO_collection.manage_AddECHO_resource(collection_object,context,science,practice,source_type,period,id,title,label,description,content_type,responsible,link,metalink,credits,RESPONSE=None)  
   
         getattr(collection_object,id).ECHO_getResourceMD()          urllib.urlopen(collection+"/"+id+"/ECHO_getResourceMD").read()
   
         return self.REQUEST.RESPONSE.redirect(self.REQUEST['URL2']+'?path='+path)          return self.REQUEST.RESPONSE.redirect(self.REQUEST['URL2']+'?path='+path)
                   
Line 248  class OSAS_add_contextData(Folder): Line 321  class OSAS_add_contextData(Folder):
             
     def add_contextData_config(self):      def add_contextData_config(self):
         """Main configuration"""          """Main configuration"""
         pt=PageTemplateFile('Products/OSA_system/ChangeOSAS_add_contextData.zpt').__of__(self)          pt=PageTemplateFile('Products/OSA_system/zpt/ChangeOSAS_add_contextData.zpt').__of__(self)
         return pt()          return pt()
           
           
Line 260  class OSAS_add_contextData(Folder): Line 333  class OSAS_add_contextData(Folder):
                           
 def manage_AddOSAS_add_contextDataForm(self):  def manage_AddOSAS_add_contextDataForm(self):
     """interface for adding the OSAS_add_Metadata"""      """interface for adding the OSAS_add_Metadata"""
     pt=PageTemplateFile('Products/OSA_system/AddOSAS_contextData.zpt').__of__(self)      pt=PageTemplateFile('Products/OSA_system/zpt/AddOSAS_contextData.zpt').__of__(self)
     return pt()      return pt()
   
 def manage_AddOSAS_add_contextData(self,id,collection,RESPONSE=None):  def manage_AddOSAS_add_contextData(self,id,collection,RESPONSE=None):
Line 292  class OSAS_add_Presentation(Folder): Line 365  class OSAS_add_Presentation(Folder):
     security.declarePublic('add_Presentation_config')      security.declarePublic('add_Presentation_config')
     def add_Presentation_config(self):      def add_Presentation_config(self):
         """Main configuration"""          """Main configuration"""
         pt=PageTemplateFile('Products/OSA_system/ChangeOSAS_addPresentation.zpt').__of__(self)          pt=PageTemplateFile('Products/OSA_system/zpt/ChangeOSAS_addPresentation.zpt').__of__(self)
         return pt()          return pt()
           
     security.declarePublic('change_OSAS_add_Presentation')      security.declarePublic('change_OSAS_add_Presentation')
Line 312  class OSAS_add_Presentation(Folder): Line 385  class OSAS_add_Presentation(Folder):
           
 def manage_AddOSAS_add_PresentationForm(self):  def manage_AddOSAS_add_PresentationForm(self):
     """interface for adding the OSAS_add_Metadata"""      """interface for adding the OSAS_add_Metadata"""
     pt=PageTemplateFile('Products/OSA_system/AddOSAS_presentation.zpt').__of__(self)      pt=PageTemplateFile('Products/OSA_system/zpt/AddOSAS_presentation.zpt').__of__(self)
     return pt()      return pt()
   
 def manage_AddOSAS_add_Presentation(self,id,RESPONSE=None):  def manage_AddOSAS_add_Presentation(self,id,RESPONSE=None):
Line 326  def manage_AddOSAS_add_Presentation(self Line 399  def manage_AddOSAS_add_Presentation(self
 InitializeClass(OSAS_add_Presentation)  InitializeClass(OSAS_add_Presentation)
   
 class OSAS_combineTextImage(Folder):  class OSAS_combineTextImage(Folder):
     """Hinzufügen der Combine Text und Image"""      """Hinzufüge der Combine Text und Image"""
     security=ClassSecurityInfo()      security=ClassSecurityInfo()
   
     def __init__(self,id):      def __init__(self,id):
Line 344  class OSAS_combineTextImage(Folder): Line 417  class OSAS_combineTextImage(Folder):
     security.declarePublic('combineTextImage_config')      security.declarePublic('combineTextImage_config')
     def combineTextImage_config(self):      def combineTextImage_config(self):
         """Main configuration"""          """Main configuration"""
         pt=PageTemplateFile('Products/OSA_system/ChangeOSAS_combineTextImage.zpt').__of__(self)          pt=PageTemplateFile('Products/OSA_system/zpt/ChangeOSAS_combineTextImage.zpt').__of__(self)
         return pt()          return pt()
           
     security.declarePublic('change_OSAS_combineTextImage')      security.declarePublic('change_OSAS_combineTextImage')
Line 357  class OSAS_combineTextImage(Folder): Line 430  class OSAS_combineTextImage(Folder):
     security.declarePublic('combineTextImage')      security.declarePublic('combineTextImage')
     def combineTextImage(self,path):      def combineTextImage(self,path):
         """Hinzufügen der Presenationsinformation"""          """Hinzufügen der Presenationsinformation"""
         return OSAS_add.combineTextImage(self,path)          """gibt input formular zur erstellung des texttools meta tag aus"""
       files = os.listdir(path)
       
       texts=[]
       imagefolders=[]
       presentationfolders=[]
   
       splitted=path.split("/")
       externxml=readArchimedesXML(splitted[len(splitted)-1])
       
       for filename in files:
           #print "FN",filename
           if archive.isdigilib2(path+"/"+filename):
               imagefolders.append(filename)
               
           if archive.isFullText(path,filename):
               #print "HI"
               texts.append(filename)
           if archive.isPresentation(path,filename):
               presentationfolders.append(filename)
       
       dom=xml.dom.minidom.parse(path+"/index.meta")
       try:
           filelanguage=archive.getText(dom.getElementsByTagName('lang')[0].childNodes)
       except:
           filelanguage=""
                   
       self.REQUEST.SESSION['isolist']=OSAS_add.getISO()
           
       tmp=self.REQUEST.SESSION['isolist'].keys()
       tmp.sort()
       self.REQUEST.SESSION['isolistsort']=tmp
       self.REQUEST.SESSION['path']=path
       self.REQUEST.SESSION['texts']=texts
       self.REQUEST.SESSION['imagefolders']=imagefolders
       self.REQUEST.SESSION['presentationfolders']=presentationfolders
       self.REQUEST.SESSION['filelanguage']=filelanguage
       self.REQUEST.SESSION['externxml']=externxml
   
       newtemplate=PageTemplateFile('Products/OSA_system/zpt/ImageandText').__of__(self)
       return newtemplate()
       
       def getProjects(self,obj_ids=None):
           """Get the Project title for configuration"""
           ret=[]
           
           try:
               projects=self.ZopeFind(self.projects,obj_metatypes=['OSAS_project'],obj_ids=obj_ids)#assumes projects folder somewhere in the hierarchie.
               
               for project in projects:
                   ret.append((project[1].title,project[0],project[1]))
               
               return ret
           
           except:
               return [('no Projectfolders','')]
   
       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]
               
               return getText(subnode.childNodes)
           except:
               return default
               
   
     def combineTextImage2(self,path):      def combineTextImage2(self,path):
         """Eingabe von Metadateninformationen"""          """Eingabe von Metadateninformationen"""
         OSAS_add.combineTextImage2(self,path) # Add images          OSAS_add.combineTextImage2(self,path) # Add images
         splitted=path.split("/")          splitted=path.split("/")
         linkPath=splitted[len(splitted)-1]          linkPath=splitted[len(splitted)-1]
         linkViewerEnvironment="http://nausikaa2.mpiwg-berlin.mpg.de:86/cgi-bin/toc/toc.x.cgi?dir=%s&step=thumb" % linkPath          linkViewerEnvironmentImages="http://nausikaa2.mpiwg-berlin.mpg.de/cgi-bin/toc/toc.x.cgi?dir=%s&step=thumb" % linkPath
           linkViewerEnvironmentOnlyText="http://nausikaa2.mpiwg-berlin.mpg.de/cgi-bin/toc/toc.x.cgi?dir=%s&step=textonly" % linkPath
   
           if self.REQUEST.has_key('image'): # bilder vorhanden
               linkViewerEnvironment=linkViewerEnvironmentImages
           else:
               linkViewerEnvironment=linkViewerEnvironmentOnlyText
               
         self.REQUEST.SESSION['linkViewerEnvironment']=linkViewerEnvironment          self.REQUEST.SESSION['linkViewerEnvironment']=linkViewerEnvironment
   
         writeToContext(path,linkViewerEnvironment,"ECHO standard environment")          writeToContext(path,linkViewerEnvironment,"ECHO standard environment",unique="yes")
                   
         pt=PageTemplateFile('Products/OSA_system/AddOSAS_combineTextImageFinal.zpt').__of__(self)          pt=PageTemplateFile('Products/OSA_system/zpt/AddOSAS_combineTextImageFinal.zpt').__of__(self)
   
         return pt()          return pt()
   
       def isSelectedProject(self,obj,id):
           """is ausgewählt"""
           
           if self.REQUEST['project']==id:
               return 1
           else:
               return None
   
 def writeToContext(path,link,description):  def writeToContext(path,link,description,unique="no"):
     """Created an additional entry to the index.meta file of path"""      """Created an additional entry to the index.meta file of path"""
     dom=xml.dom.minidom.parse(path+"/index.meta")      dom=xml.dom.minidom.parse(path+"/index.meta")
     node=dom.getElementsByTagName('resource')[0]      node=dom.getElementsByTagName('resource')[0]
   
       if unique=="yes":
           
           contexts=node.getElementsByTagName('context')
           for context in contexts:
               nameTag=getText(context.getElementsByTagName('name')[0].childNodes)
               linkTag=getText(context.getElementsByTagName('link')[0].childNodes)
               
               
               linkTag=re.sub("\:86","",linkTag) # alter port 86 gleich ohne port nummer (hack)
               if (nameTag==description) and (linkTag==link):
                   node.removeChild(context).unlink()
                       
     subnode=dom.createElement('context')      subnode=dom.createElement('context')
   
     linknode=dom.createElement('link')      linknode=dom.createElement('link')
Line 400  def writeToContext(path,link,description Line 567  def writeToContext(path,link,description
   
 def manage_AddOSAS_combineTextImageForm(self):  def manage_AddOSAS_combineTextImageForm(self):
     """interface for adding the OSAS_add_Metadata"""      """interface for adding the OSAS_add_Metadata"""
     pt=PageTemplateFile('Products/OSA_system/AddOSAS_combineTextImage.zpt').__of__(self)      pt=PageTemplateFile('Products/OSA_system/zpt/AddOSAS_combineTextImage.zpt').__of__(self)
     return pt()      return pt()
   
 def manage_AddOSAS_combineTextImage(self,id,RESPONSE=None):  def manage_AddOSAS_combineTextImage(self,id,RESPONSE=None):
Removed from v.1.10  
changed lines
  Added in v.1.29

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