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

Diff for /ECHO_content/ECHO_collection.py between versions 1.66 and 1.80

version 1.66, 2004/05/07 15:07:22 version 1.80, 2004/05/11 14:57:35
Line 45  import ECHO_helpers Line 45  import ECHO_helpers
 #List of different types for the graphical linking viewer  #List of different types for the graphical linking viewer
 viewClassificationListMaster=['view point','area']  viewClassificationListMaster=['view point','area']
   
   def checkDiffs(self,metadict):
           """check differences"""
   
           def NoneToEmpty(obj):
               if obj:
                   return obj
               else:
                   return ""
           
           diffs={}
           tags=self.findTagsFromMapping(self.contentType)
           for field in tags[1]:
               try:
                   if (NoneToEmpty(self.getFieldValue(self.getFieldTag(tags,field)))==metadict[self.getFieldTag(tags,field)]):
                       diffs[self.getFieldTag(tags,field)]=1
                   else:
                       print "DIFF",field,self.getFieldValue(self.getFieldTag(tags,field)),metadict[self.getFieldTag(tags,field)]
                       diffs[self.getFieldTag(tags,field)]=0
               except:
                   diffs[self.getFieldTag(tags,field)]=0
                   print "EX",field
           return diffs
       
 def content_html(self,type):  def content_html(self,type):
         """template fuer content"""          """template fuer content"""
         #templates = self.ZopeFind(self.aq_parent,obj_ids=[type+"_template"])          #templates = self.ZopeFind(self.aq_parent,obj_ids=[type+"_template"])
Line 89  def sendFile(self, filename, type): Line 112  def sendFile(self, filename, type):
         break          break
     if object:      if object:
     # if the object exists then send it      # if the object exists then send it
     object()      return object.index_html(self.REQUEST.REQUEST, self.REQUEST.RESPONSE)
     else:      else:
     # send a local file with the given content-type      # send a local file with the given content-type
     fn = os.path.join(package_home(globals()), filename)      fn = os.path.join(package_home(globals()), filename)
Line 98  def sendFile(self, filename, type): Line 121  def sendFile(self, filename, type):
     return      return
   
   
   def writeMetadata(url,metadict):
       """Einlesen der Metadaten und und erstellen des geänderten XML file"""
   
       try:
           geturl=""
           for line in urllib.urlopen(url).readlines():
               geturl=geturl+line
           
           
       except:
           return (None,"Cannot open: "+url)
   
       try:
           dom=xml.dom.minidom.parseString(geturl)
       except:
           return (None,"Cannot parse: "+url+"<br>"+geturl)
   
       metanodes=dom.getElementsByTagName('bib')
   
       if not metanodes:
           metanodes=dom.getElementsByTagName('archimedes')
   
       metanode=metanodes[0]
   
       for metaData in metadict.keys():
           print metaData,metanode
           try:
               nodeOld=metanode.getElementsByTagName(metaData)
           except:
               nodeOld=None
               
           if nodeOld:
               metanode.removeChild(nodeOld[0]).unlink()
           else:
               # try also old writing rule - instead of _:
               try:
                   nodeOld=metanode.getElementsByTagName(re.sub('_','-',metaData))
               except:
                   nodeOld=None
                   
               if nodeOld:
                   metanode.removeChild(nodeOld[0]).unlink()
   
           metanodeneu=dom.createElement(metaData)
           metanodetext=dom.createTextNode(unicode(metadict[metaData],"utf8"))
           metanodeneu.appendChild(metanodetext)
           metanode.appendChild(metanodeneu)
   
       
       return dom.topxml().encode('utf-8')
   
 def readMetadata(url):  def readMetadata(url):
     """Methoden zum Auslesen der Metadateninformation zu einer Resource      """Methode zum Auslesen der Metadateninformation zu einer Resource
     Vorerst noch Typ bib"""      Vorerst noch Typ bib"""
           
     metadict={}      metadict={}
Line 134  def readMetadata(url): Line 208  def readMetadata(url):
                   
         for node in metacontent:          for node in metacontent:
             try:              try:
                 metadict[node.tagName.lower()]=getText(node.childNodes)                  metadict[re.sub('-','_',node.tagName.lower())]=getText(node.childNodes)
             except:              except:
                 """nothing"""                  """nothing"""
   
     #print metadict  
     return metadict,""      return metadict,""
           
   
Line 343  class ECHO_resource(Folder): Line 417  class ECHO_resource(Folder):
   
   
     def getCoords(self):      def getCoords(self):
         try:          """gibt coordinaten als String zurück und löscht zugleich einträge die keine Koordinaten sind, letzteres zur korrektur der Eingabe der alten version"""
             return [string.join(x,",") for x in self.coords]            retList=[]
         except:          if hasattr(self,'coords'):
             return []              for x in self.coords:
               if len(x)>1:
                   retList.append(string.join(x,","))
           return retList
   
       
   
     def getContentType(self):      def getContentType(self):
         try:          try:
Line 354  class ECHO_resource(Folder): Line 433  class ECHO_resource(Folder):
         except:          except:
             return ""              return ""
   
       def getCopyrightType(self):
           try:
               return self.copyrightType
           except:
               return ""
   
       def getRenderingType(self):
           try:
               return self.renderingType
           except:
               return ""
   
     def ECHO_resource_config(self):      def ECHO_resource_config(self):
         """Main configuration"""          """Main configuration"""
   
         if not hasattr(self,'weight'):          if not hasattr(self,'weight'):
             self.weight=""              self.weight=""
         if not hasattr(self,'coords'):  
             self.coords=[]  
   
         print "vorher",self.coords  
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource.zpt').__of__(self)          pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource.zpt').__of__(self)
         return pt()          return pt()
           
   
       def ECHO_resource_config_main(self):
           """Main configuration"""
   
           if not hasattr(self,'weight'):
               self.weight=""
   
           pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_main.zpt').__of__(self)
           return pt()
   
       def ECHO_resource_config_coords(self):
           """Coords configuration """
   
           pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_coords.zpt').__of__(self)
           return pt()
   
       def ECHO_resource_config_credits(self):
           """Main configuration"""
   
           pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_credits.zpt').__of__(self)
           return pt()
   
       def ECHO_resource_config_metadata(self):
           """Main configuration"""
   
       if (hasattr(self,'metadata')) and not (hasattr(self,'metaDataHash')):
           self.metaDataHash={}
           self.contentType=self.bib_type
           for data in self.metadata:
               data_neu=re.sub('-','_',data)
               self.metaDataHash[data_neu]=getattr(self,data)
               #print data_neu, getattr(self,data)
           #print self.metaDataHash,self.metadata
       
           pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_metadata.zpt').__of__(self)
           return pt()
   
   
       
   
       def changeECHO_resource_main(self,metalink,link,title,label,description,contentType,renderingType,weight,resourceID,RESPONSE=None):
           """Änderung der Properties"""
       self.resourceID=resourceID
       self.title=title
       self.label=label
       self.description=description
   
       self.contentType=contentType
       self.renderingType=renderingType
       self.weight=weight
       
           self.link=link
           self.metalink=metalink
           
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
   
       def changeECHO_resource_coords(self,coords,viewClassification,RESPONSE=None):
           """Änderung der Properties - coords"""
   
       if type(coords)==StringType:
               coords=[coords]
   
           try:        
               coordsnew=[ string.split(x,",") for x in coords]
           except:
           coordsnew=[]    
   
       self.coords=coordsnew[0:]
       self.viewClassification=viewClassification
           
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
       def changeECHO_resource_credits(self,credits,responsible,copyrightType,RESPONSE=None):
           """Änderung der Properties"""
       self.credits=credits
       self.responsible=responsible
       self.copyrightType=copyrightType
           
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
   
       def changeECHO_resource_metadata(self,RESPONSE=None):
           """change metadata"""
           tags=self.findTagsFromMapping(self.contentType)
           self.OSAS_meta={}
           for field in tags[1]:
               try:
                   self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)]
                   self.OSAS_meta[self.getFieldTag(tags,field)]=self.REQUEST.form['OSAS_%s'%self.getFieldTag(tags,field)]
               except:
                   """nothing"""
   
           return urllib.urlopen('http://xserve02.mpiwg-berlin.mpg.de:18880/echo_nav/storage/downloadExternalXML?index_meta_url=%s&xml_url=%s'%(self.metalink,self.absolute_url()+'/newMetaXML')).read()
           
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
   
       def newMetaXML(self):
           """new index.meta"""
           self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
           return writeMetadata(self.metalink,self.OSAS_meta)
   
       
     def changeECHO_resource(self,metalink,link,title,label,description,contentType,responsible,weight,viewClassification="",coords=None,credits=None,RESPONSE=None):      def changeECHO_resource(self,metalink,link,title,label,description,contentType,responsible,weight,viewClassification="",coords=None,credits=None,RESPONSE=None):
         """Änderung der Properties"""          """Änderung der Properties"""
                   
Line 386  class ECHO_resource(Folder): Line 581  class ECHO_resource(Folder):
                           
                           
     manage_options = Folder.manage_options+(      manage_options = Folder.manage_options+(
         {'label':'Main Config','action':'ECHO_resource_config'},          {'label':'Main Config','action':'ECHO_resource_config_main'},
         {'label':'Metadata','action':'ECHO_getResourceMD'},      {'label':'Change Credits & Copyright','action':'ECHO_resource_config_credits'},
         {'label':'Graphics','action':'ECHO_graphicEntry'},      {'label':'Change Metadata','action':'ECHO_resource_config_metadata'},
       {'label':'Change Coords','action':'ECHO_resource_config_coords'},
       {'label':'Add coords','action':'ECHO_graphicEntry'},
           {'label':'Sync Metadata','action':'ECHO_getResourceMD'},
         )          )
   
     def getOverview(self):      def getOverview(self):
Line 417  class ECHO_resource(Folder): Line 615  class ECHO_resource(Folder):
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('ECHO_graphicEntry')              RESPONSE.redirect('ECHO_graphicEntry')
   
   
       def isDefinedInThisSet(self,fields,field):
           """checks if field is defined in fields"""
           if (fields[0].has_key(field)) and not (fields[0][field]==""):
               return 1
           else:
             
               return 0
           
       def getFieldLabel(self,fields,field):
           """get labels"""
           try:
               ret =fields[0][field]
               if ret == "":
                   return field
               else:
                   return ret
           except:
               return field
   
   
   
       def getFieldTag(self,fields,field):
           """get labels"""
           try:
               ret =fields[0][field]
               if ret == "":
                   return field
               else:
                   return ret
           except:
               return field
   
       
           
       def getFieldValue(self,field):
           """get value"""
       #print field
           try:
       
               ret=self.metaDataHash[field]
               if ret == "":
                   return None
               else:
                   return ret
           except:
               return None
   
       def findLabelsFromMapping(self,referenceType):
           """gib hash mit label -> generic zurueck"""
           self.referencetypes=self.ZopeFind(self.standardMD)
       #print "RT",referenceType
       
           bibdata={}
           retdata={}
           fieldlist=self.standardMD.fieldList
           
       for referenceTypeF in self.referencetypes:
           #print referenceTypeF[1].title,referenceType    
           if referenceTypeF[1].title == referenceType:
               #print "OK"
               bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
               bibdata['data']=referenceTypeF[1]
               self.fields=bibdata[referenceType]
                           for field in fieldlist:
                               retdata[field]=referenceTypeF[1].getValue(field)[1]
       #print retdata,fieldlist
           return retdata,fieldlist
   
       def findTagsFromMapping(self,referenceType):
           """gib hash mit label -> generic zurueck"""
           self.referencetypes=self.ZopeFind(self.standardMD)
       
       
           bibdata={}
           retdata={}
           fieldlist=self.standardMD.fieldList
           
       for referenceTypeF in self.referencetypes:
       
           if referenceTypeF[1].title == referenceType: 
               bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
               bibdata['data']=referenceTypeF[1]
               self.fields=bibdata[referenceType]
                           for field in fieldlist:
                               retdata[field]=referenceTypeF[1].getValue(field)[0]
       
           return retdata,fieldlist
   
       
       
               
     def ECHO_getResourceMD(self,template="yes"):      def ECHO_getResourceMD(self,template="yes"):
         """Einlesen der Metadaten und Anlegen dieser Metadaten als Informationen zur Resource"""          """Einlesen der Metadaten und Anlegen dieser Metadaten als Informationen zur Resource"""
         (metadict, error)=readMetadata(self.metalink)          (metadict, error)=readMetadata(self.metalink)
Line 425  class ECHO_resource(Folder): Line 715  class ECHO_resource(Folder):
   
         if not error=="": #Fehler beim Auslesen des Metafiles          if not error=="": #Fehler beim Auslesen des Metafiles
             return "ERROR:",error              return "ERROR:",error
         for key in metadict.keys():#Hinzufügen der Felder  
   
             setattr(self,key,metadict[key].encode('ascii','replace'))  
                   
       if not (metadict['bib_type']==self.contentType):
           self.REQUEST.SESSION['contentStorage']=metadict['bib_type']
           self.REQUEST.SESSION['contentZope']=self.contentType
   
         self.metadata=metadict.keys()          return PageTemplateFile('Products/ECHO_content/zpt/ECHO_getResourceMDErrorContentType.zpt').__of__(self)()
           
           self.REQUEST.SESSION['metadict']=metadict
   
       self.REQUEST.SESSION['diffs']=checkDiffs(self,metadict)
   
         self.label=self.generate_label()  
                   
         if template=="yes":          if template=="yes":
             pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_resourceMD.zpt').__of__(self)              pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_resourceMD.zpt').__of__(self)
             return pt()              return pt()
           
   
       
       
     def ECHO_getMD(self,item):      def ECHO_getMD(self,item):
         """Ausgabe der MD"""          """Ausgabe der MD"""
         return getattr(self,item)          return getattr(self,item)
Line 574  class ECHO_link(ECHO_externalLink): Line 871  class ECHO_link(ECHO_externalLink):
           
   
     def content_html(self):      def content_html(self):
         """template fuer content"""          """template fuer link"""
           if hasattr(self,"link_template"):
         return content_html(self,'link')          return content_html(self,'link')
           else:
               return content_html(self,'collection')
           
 def manage_addECHO_linkForm(self):  def manage_addECHO_linkForm(self):
         """Form for external Links"""          """Form for external Links"""
Line 598  class ECHO_collection(Folder, Persistent Line 898  class ECHO_collection(Folder, Persistent
     """ECHO Collection"""      """ECHO Collection"""
     security=ClassSecurityInfo()      security=ClassSecurityInfo()
     meta_type='ECHO_collection'      meta_type='ECHO_collection'
       viewClassificationList=viewClassificationListMaster
     displayTypes=displayTypes      displayTypes=displayTypes
                           
       def getViewClassification(self):
           if hasattr(self,'viewClassification'):
               return self.viewClassification
           else:
               return ""
   
     def getTitle(self):      def getTitle(self):
     """title"""      """title"""
     return self.title.encode('utf-8')       return self.title.encode('utf-8') 
Line 677  class ECHO_collection(Folder, Persistent Line 983  class ECHO_collection(Folder, Persistent
           
     def createJavaScript(self):      def createJavaScript(self):
         """CreateJava"""          """CreateJava"""
         #ret=javaScriptMain          ret=javaScriptMain
         ret=""  
   
         dynamical="\n"          dynamical="\n"
         for ob in self.getGraphicCoords():          for ob in self.getGraphicCoords():
         if ob[4][4] == "":            if ob[4][4] == "":  
             #dynamical+="""Coords.push(new Coord('%s', Img, %s));\n"""%(ob[1],ob[0])              dynamical+="""Coords.push(new Coord('%s', Img, %s));\n"""%(ob[1],ob[0])
           else:
           dynamical+="""Coords.push(new Coord('%s', Img, %s));//%s\n"""%(ob[1],ob[0],ob[4][4])
           dynamical+="ShowArrow(new getObj('i.%s'),Img,%s);\n"%(ob[1],ob[0])
       ret+=javaHandler%dynamical
           return ret
   
       def createJSAreas(self):
           """new version of createJavaScript"""
           dynamical="\n"
           for ob in self.getGraphicCoords():
           if ob[5] == "area":
             dynamical+="""addArea('%s', 'overview', %s, 'area');\n"""%(ob[1],ob[0])              dynamical+="""addArea('%s', 'overview', %s, 'area');\n"""%(ob[1],ob[0])
         else:          else:
             dynamical+="""addArea('%s', 'overview', %s, 'arrow');\n"""%(ob[1],ob[0])              dynamical+="""addArea('%s', 'overview', %s, 'arrow');\n"""%(ob[1],ob[0])
         #dynamical+="""Coords.push(new Coord('%s', Img, %s));//%s\n"""%(ob[1],ob[0],ob[4][4])          return dynamical
         #dynamical+="ShowArrow(new getObj('i.%s'),Img,%s);\n"%(ob[1],ob[0])  
     #ret+=javaHandler%dynamical      def createMapHead(self):
         ret+=dynamical          """generate divs"""
         return ret          pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/ECHO_content_map_frag_js')).__of__(self)
           return pt()
           
       def createMapLink(self, ob, text=None):
       """generate map link"""
       id = ob[1]
       link = ob[1]
       if text == None:
           text = ob[2]
       tag = '<a id="a.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="_blank"'%(id,id,id,link)
       if ob[3].contentType == 'text-popup':
           tag += ' title="%s"'%ob[3].description
       tag += ">" + text + "</a>"
       return tag
   
       def createMapAux(self, ob, arrowsrc="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?dw=15&fn=icons/pfeil"):
       """generate map link image, text and other stuff"""
       id = ob[1]
       link = ob[1]
       vtype = ob[5]
       ctype = ob[3].contentType
       
       tag = '<a id="b.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="_blank">'%(id,id,id,link)
       if vtype == "view point":
           rot = ob[4][4]
           tag += '<img id="i.%s" src="%s&rot=%s" border="1" style="position:absolute; top:-100px; left:-100px; border-style:none" />'%(id,arrowsrc,rot)
       else:
           tag += '<span id="i.%s" style="position:absolute; top:-100px; left:-100px; border-style:none"'%(id)
           if ctype == "text-popup":
           desc = ob[3].description
           tag += ' title="%s"'%desc
           tag += ' />'
       tag += '</a>'
       return tag
   
           
     security.declarePublic('getCreditObject')      security.declarePublic('getCreditObject')
     def getCreditObject(self,name):      def getCreditObject(self,name):
Line 721  class ECHO_collection(Folder, Persistent Line 1071  class ECHO_collection(Folder, Persistent
         return ret          return ret
           
     security.declarePublic('ECHO_rerenderLinksMD')      security.declarePublic('ECHO_rerenderLinksMD')
   
     def ECHO_rerenderLinksMD(self,obj=None):      def ECHO_rerenderLinksMD(self,obj=None):
         """Rerender all Links"""          """Rerender all Links"""
         if not obj:          if not obj:
Line 731  class ECHO_collection(Folder, Persistent Line 1082  class ECHO_collection(Folder, Persistent
         for entry in entries:          for entry in entries:
         if entry[1].meta_type == 'ECHO_resource':          if entry[1].meta_type == 'ECHO_resource':
             entry[1].ECHO_getResourceMD(template="no")              entry[1].ECHO_getResourceMD(template="no")
             print "rerender",entry[1].getId()              #print "rerender",entry[1].getId()
         else:          else:
            self.ECHO_rerenderLinksMD(entry[1])             self.ECHO_rerenderLinksMD(entry[1])
   
Line 837  class ECHO_collection(Folder, Persistent Line 1188  class ECHO_collection(Folder, Persistent
         else:          else:
             return "#dddddd"              return "#dddddd"
                   
     def changeECHO_collection(self,title,label,description,contentType,responsible,weight,secondaryLink,secondaryLinkTitle,credits=None,sortfield="weight",coords=None,RESPONSE=None,imageTag="",bgcolour=""):      def changeECHO_collection(self,title,label,description,contentType,responsible,weight,secondaryLink,secondaryLinkTitle,credits=None,sortfield="weight",coords=None,RESPONSE=None,imageTag="",bgcolour="",viewClassification=None):
         """Änderung der Properties"""          """Aenderung der Properties"""
   
         self.secondaryLink=secondaryLink          self.secondaryLink=secondaryLink
         self.secondaryLinkTitle=secondaryLinkTitle          self.secondaryLinkTitle=secondaryLinkTitle
         self.imageTag=imageTag          self.imageTag=imageTag
     self.bgcolour=bgcolour      self.bgcolour=bgcolour
           self.viewClassification=viewClassification
           
         if coords:          if coords:
             coordsnew=[ string.split(x,",") for x in coords]              coordsnew=[ string.split(x,",") for x in coords]
Line 904  class ECHO_collection(Folder, Persistent Line 1256  class ECHO_collection(Folder, Persistent
   
     def area_img(self):      def area_img(self):
         """area image"""          """area image"""
         sendFile(self, 'images/red.gif', 'image/gif')          return sendFile(self, 'images/red.gif', 'image/gif')
         return   
   
     def hl_lib_js(self):      def hl_lib_js(self):
         """javascript"""          """javascript"""
         sendFile(self, 'js/hl_lib.js', 'text/plain')          return sendFile(self, 'js/hl_lib.js', 'text/plain')
         return   
   
     def js_lib_js(self):      def js_lib_js(self):
         """javascript"""          """javascript"""
         sendFile(self, 'js/js_lib.js', 'text/plain')          return sendFile(self, 'js/js_lib.js', 'text/plain')
         return   
   
                   
     def getGraphicCoords(self):      def getGraphicCoords(self):
         """Give list of coordinates"""          """Give list of coordinates"""
         subColTypes=['ECHO_collection','ECHO_externalLink','ECHO_resource']          subColTypes=['ECHO_collection','ECHO_resource']
         ids=[]          ids=[]
         for entrySearch in self.ZopeFind(self,obj_metatypes=subcolTypes):          for entrySearch in self.ZopeFind(self,obj_metatypes=subColTypes):
             object=entrySearch[1]              object=entrySearch[1]
             if hasattr(object,'coords'):              if hasattr(object,'coords'):
                 for coordtemp in object.coords:                  for coordtemp in object.coords:
                     if len(coordtemp)>3:                      if len(coordtemp)>3:
                         coord=coordtemp[0:4]                          coord=coordtemp[0:4]
                         label=""                          label=""
               vc=""
                         if hasattr(object,'label') and not object.label=="":                          if hasattr(object,'label') and not object.label=="":
                             label=object.label                              label=object.label
                         elif hasattr(object,'title') and not object.title=="":                          elif hasattr(object,'title') and not object.title=="":
                             label=object.title                              label=object.title
                         else:                          else:
                             label=object.getId()                              label=object.getId()
                         ids.append([string.join(coord,", "),object.getId(),label,object,coordtemp,object.getViewClassification()])              if object.viewClassification != "":
                   vc=object.viewClassification
               else:
                   if len(coordtemp) > 4 and coordtemp[4] != "":
                   vc="view point"
                   else:
                   vc="area"
                           ids.append([string.join(coord,", "),object.getId(),label,object,coordtemp,vc])
         return ids          return ids
           
   
Line 1091  class ECHO_root(Folder,Persistent,Implic Line 1447  class ECHO_root(Folder,Persistent,Implic
             retStr="<option>\n"              retStr="<option>\n"
                           
         try: # erste version contentTypes exists          try: # erste version contentTypes exists
             for contentType in self.ZopeFind(self.contentTypes,obj_metatypes=["ECHO_contentType"]):              for contentType in self.ZopeFind(self.contentTypes,obj_metatypes=["ECHO_contentType","OSAS_MetadataMapping"]):
                 if selected and (contentType[0]==selected):                  if selected and (contentType[0]==selected):
                     retStr+="""<option selected value="%s">%s\n"""%(contentType[0],contentType[0])                      retStr+="""<option selected value="%s">%s\n"""%(contentType[0],contentType[0])
                 else:                                  else:                
Line 1108  class ECHO_root(Folder,Persistent,Implic Line 1464  class ECHO_root(Folder,Persistent,Implic
                                   
         return retStr          return retStr
                           
       def renderingTypeSelector_HTML(self,selected=None):
            """give type selector"""
        if not selected:
            retStr="<option selected>\n"
        else:
            retStr="<option>\n"
            
        try: # erste version renderingTypes exists
            for renderingType in self.ZopeFind(self.renderingTypes,obj_metatypes=["ECHO_renderingType"]):
                if selected and (renderingType[0]==selected):
                    retStr+="""<option selected value="%s">%s\n"""%(renderingType[0],renderingType[0])
                else:                
                    retStr+="""<option value="%s">%s\n"""%(renderingType[0],renderingType[0])
        except:
            """nothing"""
        return retStr
   
       def renderingTypeSelector_HTML(self,selected=None):
            """give type selector"""
        if not selected:
            retStr="<option selected>\n"
        else:
            retStr="<option>\n"
            
        try: # erste version renderingTypes exists
            for renderingType in self.ZopeFind(self.renderingTypes,obj_metatypes=["ECHO_renderingType"]):
                if selected and (renderingType[0]==selected):
                    retStr+="""<option selected value="%s">%s\n"""%(renderingType[0],renderingType[0])
                else:                
                    retStr+="""<option value="%s">%s\n"""%(renderingType[0],renderingType[0])
        except:
            """nothing"""
        return retStr
   
   
       def copyrightTypeSelector_HTML(self,selected=None):
            """give type selector"""
        if not selected:
            retStr="<option selected>\n"
        else:
            retStr="<option>\n"
            
        try: # erste version copyrightTypes exists
            for copyrightType in self.ZopeFind(self.copyrightTypes,obj_metatypes=["ECHO_copyrightType"]):
                if selected and (copyrightType[0]==selected):
                    retStr+="""<option selected value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
                else:                
                    retStr+="""<option value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
        except:
            """nothing"""
        return retStr
   
               
     def patchContentType(self,obj=None):      def patchContentType(self,obj=None):
         """austauschen content_type with contentType (patch bei umstieg von alter Version)"""          """austauschen content_type with contentType (patch bei umstieg von alter Version)"""
           
Line 1134  class ECHO_root(Folder,Persistent,Implic Line 1543  class ECHO_root(Folder,Persistent,Implic
     def checkIfArrow(obj):      def checkIfArrow(obj):
         if hasattr(obj,'coords'):          if hasattr(obj,'coords'):
             for coordtemp in obj.coords:              for coordtemp in obj.coords:
                 print obj.title,len(coordtemp)                  #print obj.title,len(coordtemp)
                 if (len(coordtemp)>4) and not (coordtemp[4]==''):                  if (len(coordtemp)>4) and not (coordtemp[4]==''):
                     return 4                      return 4
             return None              return None
Line 1148  class ECHO_root(Folder,Persistent,Implic Line 1557  class ECHO_root(Folder,Persistent,Implic
         for entry in entries:          for entry in entries:
                   
         if checkIfArrow(entry[1]):          if checkIfArrow(entry[1]):
             print "VP"  
             setattr(entry[1],'viewClassification','view point')              setattr(entry[1],'viewClassification','view point')
         else:          else:
             print "area"  
             setattr(entry[1],'viewClassification','area')              setattr(entry[1],'viewClassification','area')
   
                 #entry[1].contentType == entry[1].content_type                  #entry[1].contentType == entry[1].content_type
Line 1208  class ECHO_root(Folder,Persistent,Implic Line 1615  class ECHO_root(Folder,Persistent,Implic
                           
             for word in words:              for word in words:
                 strUrl=url%word                  strUrl=url%word
                 print "str",strUrl                  #print "str",strUrl
                 retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)                  retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)
             str=retStr              str=retStr
         if str:          if str:
Line 1219  class ECHO_root(Folder,Persistent,Implic Line 1626  class ECHO_root(Folder,Persistent,Implic
     def link2html(self,str):      def link2html(self,str):
         """link2html fuer VLP muss hier noch raus"""          """link2html fuer VLP muss hier noch raus"""
         if str:          if str:
             print str              #print str
             str=re.sub("\&","&amp;",str)              str=re.sub("\&","&amp;",str)
             dom=xml.dom.minidom.parseString("<?xml version='1.0' ?><txt>"+str+"</txt>")              dom=xml.dom.minidom.parseString("<?xml version='1.0' ?><txt>"+str+"</txt>")
             links=dom.getElementsByTagName("link")              links=dom.getElementsByTagName("link")
                           
             print "link",links              #print "link",links
             for link in links:              for link in links:
                 link.tagName="a"                  link.tagName="a"
                 ref=link.getAttribute("ref")                  ref=link.getAttribute("ref")
Removed from v.1.66  
changed lines
  Added in v.1.80

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