Return to ECHO_language.py CVS log

Up to [Repository] / ECHO_content

bug fixed in echo_xslt

    1: """Methoden fuer Language Technologies"""
    2: 
    3: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
    4: from Products.ECHO_content.analyseAndTag.analyseAndTag import DonatusFile
    5: from OFS.SimpleItem import SimpleItem
    6: from OFS.Folder import Folder
    7: import xml.parsers
    8: import os.path
    9: import urlparse,urllib
   10: from Globals import package_home
   11: 
   12: class ECHO_language:
   13:         """language methods"""
   14:         
   15:         
   16:         def tagLex(self,nr="1",id=None):
   17:             """gerateword tags"""
   18:             
   19:            
   20:             df=DonatusFile(txt=self.getPage(_pn=nr,_id=id),baseUri=self.baseUri)
   21:            
   22:             return df.convertedXML()
   23:             #return DonatusFile(txt=self.getPage(_pn=nr)).convertedXML()
   24:         
   25: class Collection(SimpleItem):
   26:          def getCollectionXML(self,RESPONSE=None):
   27:              
   28:              """get collection as xml"""
   29:              return self.aq_parent.getCollectionXML(collection=self.getId(),RESPONSE=RESPONSE)
   30:          
   31:          def __init__(self,id):
   32:              """initialise"""
   33:              self.id=id
   34:              self.entries=[]
   35:              
   36:          
   37:          def getEntries(self):
   38:              """get the entries"""
   39:              entries=self.entries
   40:              for entry in entries: #backward compatibility, cannot be removed a.s.a.p.
   41:                  print entry
   42:                  if entry.has_key('master') and (len(entry['master'])<3):
   43:                      entry['master']=(entry['master'][0],entry['master'][1],'')
   44:                  if entry.has_key('slave') and (len(entry['slave'])<3):
   45:                      entry['slave']=(entry['slave'][0],entry['slave'][1],'')
   46:                  
   47:              return self.entries
   48:          
   49:          def deleteEntry(self,nr):
   50:              """delete an entry"""
   51:              del(self.entries[nr])
   52:            
   53:          def changeEntry(self,nr,slaveUrl,masterID):
   54:              """change an entry, only slaveUrl"""
   55:              tmp=self.entries[nr]
   56:              tm=tmp['master']
   57:              tmp['slave']=(slaveUrl,"","")
   58:              tmp['master']=(tm[0],tm[1],masterID)
   59:              entries=self.entries[0:]
   60:              entries[nr]=tmp 
   61:              self.entries=entries[0:]
   62:              
   63:          def appendEntry(self,fn,id,type,pagelink):
   64:              """append an entry"""
   65:              #check if last entry is complete
   66:              createNew=False
   67:             
   68:              if len(self.entries)==0: #noch gar kein Eintrag
   69:                  createNew=True
   70:              else:
   71:                  entry=self.entries[-1]
   72:                  if entry.get('master',None) and entry.get('slave',None):
   73:                      createNew=True
   74:              if createNew:
   75: 
   76:                  self.entries.append({})
   77:                  entry=self.entries[-1]
   78:              if type=="master":
   79:                  entry['master']=(fn,id,pagelink)
   80:              elif type=="slave":
   81:                  entry['slave']=(fn,id,pagelink)
   82:              
   83:              entries=self.entries[0:]
   84:              entries[-1]=entry 
   85:              self.entries=entries[0:]
   86:              
   87: class ECHO_linkCreator(Folder):
   88:      """creator for links"""
   89:      
   90:      meta_type="ECHO_linkCreator"
   91:      
   92: 
   93:                  
   94:                      
   95:      def getCollectionEntries(self,collection):
   96:          col=getattr(self,collection,None)
   97:          if not col:
   98:              return []
   99:        
  100:          return col.getEntries()
  101:      
  102:      def getAllRefIDs(self,collection):
  103:          """return all refids"""
  104:          ret=[]
  105:          entries=self.getCollectionEntries(collection)
  106:          
  107:          for entry in entries:
  108:              ret.append('_pagelink='+entry['master'][2])
  109:          return "&".join(ret)
  110:      
  111:              
  112:      def getCollectionXML(self,collection=None,RESPONSE=None):
  113:          """exports the collection as an XML file"""
  114:          if not collection:
  115:              return "<error>no collection: need parameter collection=COLLECTION_NAME</error>"
  116:        
  117:          i=0
  118:          ret=""
  119:          ret+="""<?xml version="1.0" encoding="UTF-8"?>"""
  120:          ret+="""<linklist xmlns="http://www.mpiwg-berlin.mpg.de/namespace">"""
  121:          ret+="""<linklistname>%s</linklistname>"""%collection
  122:          ret+="""<masterurl ref="%s"/>"""%self.getUrls(collection)[0]
  123:          ret+="""<slaveurl ref="%s"/>"""%self.getUrls(collection)[1]
  124:          
  125:          for entry in self.getCollectionEntries(collection):
  126:              ret+="""<link id="%s">"""%i
  127:              i+=1
  128:              
  129:              if entry.has_key('master'):
  130:                  ms=entry['master']
  131:   
  132:              
  133:                  try:
  134:                      if urlparse.urlparse(ms[0])[0]=="http": # url
  135:                          ret+="""<source filename="%s"/>"""%urllib.quote(ms[0])
  136:                      else:
  137:                          ret+="""<source filename="%s" refid="%s">"""%(ms[0],ms[1])
  138:                          splitted=ms[2].split("/")
  139:                          if (len(splitted)>3):
  140:                              ret+="""<pagelink refid="%s" selectionNodeIndex="%s"/>"""%(splitted[0],splitted[3])
  141:  
  142:                          ret+="""</source>"""
  143:                  except: #ohne pagelink&
  144:                      ret+="""<source filename="%s" refid="%s"/>"""%ms
  145:              if entry.has_key('slave'):
  146:                  ms=entry['slave']
  147:                  try:
  148:                     if urlparse.urlparse(ms[0])[0]=="http": # url
  149:                         ret+="""<target filename="%s"/>"""%urllib.quote(ms[0])
  150:                     else:
  151:                         ret+="""<target filename="%s" refid="%s">"""%(ms[0],ms[1])
  152:                         splitted=ms[2].split("/")
  153:                         if (len(splitted)>3):
  154:                             ret+="""<pagelink refid="%s" selectionNodeIndex="%s"/>"""%(splitted[0],splitted[3])
  155:                         ret+="""</target>"""
  156:                  except: #ohne pagelink
  157:                      ret+="""<target filename="%s" refid="%s"/>"""%ms
  158:                   
  159:              ret+="</link>"
  160:          ret+="""</linklist>"""
  161:          if RESPONSE:
  162:              RESPONSE.setHeader("Content-Type","text/xml")
  163:          return ret
  164:      def index_html(self,collection=None):
  165:          """show create links"""
  166:          if not collection:
  167:              return "no collection: need parameter collection=COLLECTION_NAME"
  168:          
  169:               
  170:          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ECHO_linkCreator_main')).__of__(self)
  171:          
  172:          col=getattr(self,collection,None)
  173:          if not col:
  174:              return []
  175:        
  176:          masterUrl=getattr(col,'masterUrl','')
  177:          slaveUrl=getattr(col,'slaveUrl','')
  178:          
  179:          return pt(collection=collection,masterUrl=masterUrl,slaveUrl=slaveUrl)
  180:      
  181:      def addEntry(self,collection,fn,id,type,pagelink,fromurl=None,RESPONSE=None,REQUEST=None):
  182:          """add an entry"""
  183:         
  184:          col=getattr(self, collection,None)
  185:          if not col:
  186:              self._setObject(collection,Collection(collection))
  187:              col=getattr(self, collection)
  188:          
  189:          col.appendEntry(fn,id,type,pagelink)
  190:          
  191:          if fromurl and RESPONSE:
  192:      
  193:              RESPONSE.setHeader("Expires",(DateTime()-1).rfc822())
  194:              RESPONSE.setHeader("Cache-Control", "no-cache")
  195:              RESPONSE.redirect(fromurl)
  196:    
  197: 
  198:      def changeEntry(self,collection,nr,slaveUrl,masterID,RESPONSE=None):
  199:          """change an entry 8only slaveUrl at the moment"""
  200:          col=getattr(self, collection,None)
  201:          col.changeEntry(nr,slaveUrl,masterID)
  202: 
  203:          if RESPONSE:
  204:              RESPONSE.redirect(self.absolute_url()+"?collection="+collection)
  205:          
  206:      def removeEntry(self,collection,nr,RESPONSE=None):
  207:          """remove an entry"""
  208:          col=getattr(self, collection,None)
  209:          col.deleteEntry(nr)
  210:          
  211:          if RESPONSE:
  212:              RESPONSE.redirect(self.absolute_url()+"?collection="+collection)
  213:          
  214:      def setUrls(self,collection,masterUrl,slaveUrl,RESPONSE=None):
  215:          """set the urls for the document viewer"""
  216:          col=getattr(self, collection,None)
  217:          setattr(col,'masterUrl',masterUrl)
  218:          setattr(col,'slaveUrl',slaveUrl)
  219:          
  220:          if RESPONSE:
  221:              RESPONSE.redirect(self.absolute_url()+"?collection="+collection)
  222:          
  223:      def getUrls(self,collection,RESPONSE=None):
  224:          """set the urls for the document viewer"""
  225:          col=getattr(self, collection,None)
  226:          x=getattr(col,'masterUrl')
  227:          y=getattr(col,'slaveUrl')
  228:          return x,y
  229:          
  230: def manage_addECHO_linkCreatorForm(self,RESPONSE=None):
  231:     """Form for adding"""
  232:     manage_addECHO_linkCreator(self,RESPONSE)
  233: 
  234: def manage_addECHO_linkCreator(self,RESPONSE=None):
  235:     """Add an ECHO_main"""
  236:     id='linkCreator'
  237:     self._setObject(id,ECHO_linkCreator(id))
  238:     
  239:   
  240:     if RESPONSE is not None:
  241:         RESPONSE.redirect('manage_main')      
  242:          
  243:          
  244:          
  245:          
  246:          
  247:          
  248:          
  249:          
  250:          
  251:          
  252:          
  253:          
  254:          
  255: