File:  [Repository] / ECHO_content / ECHO_collection.py
Revision 1.73: download - view: text, annotated - select for diffs - revision graph
Mon May 10 08:44:19 2004 UTC (20 years, 1 month ago) by dwinter
Branches: MAIN
CVS tags: HEAD
new ressource metadata editing added

    1: """New version of the product started February, 8th. Without scientific classification, use content-type for further classification."""
    2: """Echo collection provides the classes for the ECHO content web-site.
    3: 
    4: class ECHO_collection is the basis class for an ECHO collection.
    5: 
    6: class ECHO_resource contains information on ECHO resources (e.g. an Display environment for Metadata
    7: 
    8: class ECHO_externalLink contains information on externalLinks
    9: 
   10: 
   11: """
   12: import string
   13: import re
   14: import os
   15: import OFS.Image
   16: from types import *
   17: from OFS.Image import Image
   18: from Globals import DTMLFile
   19: from OFS.Folder import Folder
   20: from OFS.SimpleItem import SimpleItem
   21: from AccessControl import ClassSecurityInfo
   22: from Globals import InitializeClass
   23: from Globals import DTMLFile
   24: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
   25: from Products.PageTemplates.PageTemplate import PageTemplate
   26: from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
   27: from Globals import Persistent, package_home
   28: from Acquisition import Implicit
   29: from ECHO_helpers import displayTypes
   30: try:
   31: 	from psycopg import libpq
   32: except:
   33: 	try:
   34: 		from pyPgSQL import libpq
   35: 	except:
   36: 		print "ECHO_collection: Warning - No libpq imported!"
   37: 		
   38: import xml.dom.minidom
   39: 
   40: import urllib
   41: import xml.dom.minidom
   42: from ECHO_graphicalOverview import javaHandler,javaScriptMain
   43: import ECHO_helpers
   44: 
   45: #List of different types for the graphical linking viewer
   46: viewClassificationListMaster=['view point','area']
   47: 
   48: def checkDiffs(self,metadict):
   49: 	    """check differences"""
   50: 
   51: 	    def NoneToEmpty(obj):
   52: 		    if obj:
   53: 			    return obj
   54: 		    else:
   55: 			    return ""
   56: 	    
   57: 	    diffs={}
   58: 	    tags=self.findTagsFromMapping(self.contentType)
   59: 	    for field in tags[1]:
   60: 		    try:
   61: 			    if (NoneToEmpty(self.getFieldValue(self.getFieldTag(tags,field)))==metadict[self.getFieldTag(tags,field)]):
   62: 				    diffs[self.getFieldTag(tags,field)]=1
   63: 			    else:
   64: 				    print "DIFF",field,self.getFieldValue(self.getFieldTag(tags,field)),metadict[self.getFieldTag(tags,field)]
   65: 				    diffs[self.getFieldTag(tags,field)]=0
   66: 		    except:
   67: 			    diffs[self.getFieldTag(tags,field)]=0
   68: 			    print "EX",field
   69: 	    return diffs
   70:     
   71: def content_html(self,type):
   72:         """template fuer content"""
   73:         #templates = self.ZopeFind(self.aq_parent,obj_ids=[type+"_template"])
   74:         #
   75:         #if templates:
   76:         #    return templates[0][1]()
   77: 
   78:         try:
   79:             obj=getattr(self,type+"_template")
   80:             return obj()
   81:         except:
   82:             pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_%s_template_standard.zpt'%type).__of__(self)
   83:             pt.content_type="text/html"
   84:             return pt()
   85:     
   86: def toList(field):
   87:     """Einzelfeld in Liste umwandeln"""
   88:     if type(field)==StringType:
   89:         return [field]
   90:     else:
   91:         return field
   92:     
   93: def getText(nodelist):
   94: 
   95:     rc = ""
   96:     for node in nodelist:
   97:     	if node.nodeType == node.TEXT_NODE:
   98:            rc = rc + node.data
   99:     return rc
  100: 
  101: 
  102: def sendFile(self, filename, type):
  103:     """sends an object or a local file (in the product) as response"""
  104:     paths = filename.split('/')
  105:     object = self
  106:     # look for an object called filename
  107:     for path in paths:
  108:         if hasattr(object, path):
  109: 	    object = getattr(object, path)
  110: 	else:
  111: 	    object = None
  112: 	    break
  113:     if object:
  114: 	# if the object exists then send it
  115: 	object()
  116:     else:
  117: 	# send a local file with the given content-type
  118: 	fn = os.path.join(package_home(globals()), filename)
  119: 	self.REQUEST.RESPONSE.setHeader("Content-Type", type)
  120: 	self.REQUEST.RESPONSE.write(file(fn).read())
  121:     return
  122: 
  123: 
  124: def writeMetadata(url,metadict):
  125: 	"""Einlesen der Metadaten und und erstellen des geänderten XML file"""
  126: 
  127: 	try:
  128: 		geturl=""
  129: 		for line in urllib.urlopen(url).readlines():
  130: 			geturl=geturl+line
  131:         
  132:         
  133: 	except:
  134: 		return (None,"Cannot open: "+url)
  135: 
  136: 	try:
  137: 		dom=xml.dom.minidom.parseString(geturl)
  138: 	except:
  139: 		return (None,"Cannot parse: "+url+"<br>"+geturl)
  140: 
  141: 	metanodes=dom.getElementsByTagName('bib')
  142: 
  143: 	if not metanodes:
  144: 		metanodes=dom.getElementsByTagName('archimedes')
  145: 
  146: 	metanode=metanodes[0]
  147: 
  148: 	for metaData in metadict.keys():
  149: 		print metaData,metanode
  150: 		try:
  151: 			nodeOld=metanode.getElementsByTagName(metaData)
  152: 		except:
  153: 			nodeOld=None
  154: 			
  155: 		if nodeOld:
  156: 			metanode.removeChild(nodeOld[0]).unlink()
  157: 		else:
  158: 			# try also old writing rule - instead of _:
  159: 			try:
  160: 				nodeOld=metanode.getElementsByTagName(re.sub('_','-',metaData))
  161: 			except:
  162: 				nodeOld=None
  163: 				
  164: 			if nodeOld:
  165: 				metanode.removeChild(nodeOld[0]).unlink()
  166: 
  167: 		metanodeneu=dom.createElement(metaData)
  168: 		metanodetext=dom.createTextNode(unicode(metadict[metaData],"utf8"))
  169: 		metanodeneu.appendChild(metanodetext)
  170: 		metanode.appendChild(metanodeneu)
  171: 
  172: 	
  173: 	return dom.toxml().encode('utf-8')
  174: 
  175: def readMetadata(url):
  176:     """Methode zum Auslesen der Metadateninformation zu einer Resource
  177:     Vorerst noch Typ bib"""
  178:     
  179:     metadict={}
  180:     try:
  181:         geturl=""
  182:         for line in urllib.urlopen(url).readlines():
  183:             geturl=geturl+line
  184:         
  185:         
  186:     except:
  187:         return (None,"Cannot open: "+url)
  188: 
  189:     try:
  190:         dom=xml.dom.minidom.parseString(geturl)
  191:     except:
  192:         return (None,"Cannot parse: "+url+"<br>"+geturl)
  193: 
  194:     metanode=dom.getElementsByTagName('bib')
  195:     metadict['bib_type']='Book'
  196:     if len(metanode)==0:
  197:         metanode=dom.getElementsByTagName('archimedes')
  198:         metadict['bib_type']='Archimedes'
  199:         #print "HELLO"
  200:         
  201:     if not len(metanode)==0:    
  202:         metacontent=metanode[0].childNodes
  203:     
  204:         try:
  205:             metadict['bib_type']=getText(dom.getElementsByTagName('bib')[0].attributes['type'].childNodes)
  206:         except:
  207:             """nothing"""
  208:         
  209:         for node in metacontent:
  210:             try:
  211:                 metadict[re.sub('-','_',node.tagName.lower())]=getText(node.childNodes)
  212:             except:
  213:                 """nothing"""
  214: 
  215: 
  216:     return metadict,""
  217:     
  218: 
  219: def setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordstrs,viewClassification=""):
  220: 
  221:         """Allegemeine Informationen zu einer ECHO Collection"""
  222: 
  223:         self.viewClassification=viewClassification
  224: 
  225:         self.label = label
  226:         self.title=title
  227:         self.description=description
  228:         self.contentType=contentType
  229:         self.responsible=responsible
  230:         self.credits=toList(credits)
  231:         self.weight=weight
  232: 
  233:         coords=[]
  234:         #coordinates of for rectangles
  235: 
  236:         #print "cs", coordstrs
  237:         if coordstrs:
  238:             for coordstr in coordstrs:
  239:                 #print "cs", coordstr
  240:                 try:
  241:                     temco=coordstr.split(",")
  242:                 except:
  243:                     temco=[]
  244:                 #temco.append(angle)
  245:                 coords.append(temco)
  246: 
  247: 
  248:         self.coords=coords[0:]
  249:             
  250: 
  251: class scientificClassification(SimpleItem,Persistent,Implicit):
  252:     """outdated will be deleeted in the next versions: subclass"""
  253:     security=ClassSecurityInfo()
  254:     
  255:     def __init__(self,context,science,practice):
  256:         self.context=context
  257:         self.science=science
  258:         self.practice=practice
  259:         self.id="scientific_Classification"
  260:         
  261:     security.declarePublic('get_context')
  262:     def get_context(self):
  263:         return self.context
  264:     
  265:     security.declarePublic('get_science')
  266:     def get_science(self):
  267:         return self.science
  268:         
  269:     security.declarePublic('get_practice')
  270:     def get_practice(self):
  271:         return self.practice
  272:     
  273:                 
  274: class scientificInformation(Folder,Persistent,Implicit):
  275:     """outdated will be deleted in the next versions: subclass scientificInformation"""
  276:     security=ClassSecurityInfo()
  277:     
  278:     
  279:     
  280:     def __init__(self,source_type,period):
  281: 
  282:         self.id="scientific_Information"
  283:         self.source_type=source_type
  284:         self.period=period
  285:         
  286: 
  287: 
  288:     security.declarePublic('get_source_type')
  289:     def get_source_type(self):
  290:         return self.source_type
  291:     
  292:     security.declarePublic('get_period')
  293:     def get_period(self):
  294:         return self.period
  295: 
  296: class ECHO_layoutTemplate(ZopePageTemplate):
  297:     """Create a layout Template for different purposes"""
  298: 
  299:     meta_type="ECHO_layoutTemplate"
  300: 
  301:     def __init__(self, id, text=None, content_type=None,EchoType=None):
  302:         self.id = str(id)
  303: 
  304: 
  305: 
  306:         self.ZBindings_edit(self._default_bindings)
  307:         if text is None:
  308:             self._default_content_fn = os.path.join(package_home(globals()),
  309:                                                'zpt/ECHO_%s_template_standard.zpt'%EchoType)
  310:             text = open(self._default_content_fn).read()
  311:         self.pt_edit(text, content_type)
  312: 
  313:     
  314:         """change form"""
  315: 
  316: 
  317: def manage_addECHO_layoutTemplateForm(self):
  318:     """Form for adding"""
  319:     pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_layoutTemplate.zpt').__of__(self)
  320:     return pt()
  321: 
  322: from urllib import quote
  323: 
  324: 
  325: def manage_addECHO_layoutTemplate(self, EchoType,title=None,REQUEST=None):
  326:     "Add a Page Template with optional file content."
  327:     if type(EchoType)==StringType:
  328:         EchoTypes=[EchoType]
  329:     else:
  330:         EchoTypes=EchoType
  331:         
  332:     for singleType in EchoTypes:
  333: 
  334:         id = str(singleType)+"_template"
  335:         if REQUEST is None:
  336:             self._setObject(id, ECHO_layoutTemplate(id, text,EchoType=singleType))
  337:             ob = getattr(self, id)
  338:             
  339:             if title:
  340:                 ob.pt_setTitle(title)
  341:             return ob
  342:         else:
  343:             file = REQUEST.form.get('file')
  344:             headers = getattr(file, 'headers', None)
  345:             if headers is None or not file.filename:
  346:                 zpt = ECHO_layoutTemplate(id,EchoType=singleType)
  347:             else:
  348:                 zpt = ECHO_layoutTemplate(id, file, headers.get('content_type'))
  349: 
  350:             self._setObject(id, zpt)
  351:             ob = getattr(self, id)
  352:             if title:
  353:                 ob.pt_setTitle(title)
  354: 
  355:             try:
  356:                 u = self.DestinationURL()
  357:             except AttributeError:
  358:                 u = REQUEST['URL1']
  359: 
  360:             
  361:     REQUEST.RESPONSE.redirect(u+'/manage_main')
  362:     return ''
  363: 
  364: class ECHO_resource(Folder):
  365:     """ECHO Ressource"""
  366:     meta_type='ECHO_resource'
  367: 
  368:     viewClassificationList=viewClassificationListMaster
  369: 
  370:     getSubCols = ECHO_helpers.getSubCols
  371:     def getTitle(self):
  372: 	"""title"""
  373: 	return self.title.encode('utf-8') 
  374: 
  375:     def getLabel(self):
  376: 	"""title"""
  377: 	return self.label.encode('utf-8') 
  378: 
  379:     def content_html(self):
  380:         """template fuer content"""
  381:         return content_html(self,'resource')
  382:     
  383:     def getViewClassification(self):
  384:         if hasattr(self,'viewClassification'):
  385:             return self.viewClassification
  386:         else:
  387:             return ""
  388:         
  389:     def getCredits(self):
  390:         """Ausgabe der credits"""
  391:         if self.credits:
  392:             return self.credits
  393:         else:
  394:             return []
  395:     
  396:     def __init__(self,id,link,metalink,title,label,description,contentType,responsible,credits,weight,coords):
  397: 
  398:         self.id = id
  399:         """Festlegen der ID"""
  400:         
  401:         self.label = label
  402:         self.link= link
  403:         self.metalink=metalink
  404:         self.title=title
  405:         self.weight=weight
  406:         self.credits=toList(credits)
  407:         self.description=description
  408:         self.contentType=contentType
  409:         self.responsible=responsible
  410:         
  411:         if coords:
  412:             coordsnew=[ string.split(x,",") for x in coords]
  413:         else:
  414:             coordsnew=[]
  415:         
  416:         self.coords=coordsnew
  417: 
  418: 
  419:     def getCoords(self):
  420: 	    """gibt coordinaten als String zurück und löscht zugleich einträge die keine Koordinaten sind, letzteres zur korrektur der Eingabe der alten version"""
  421: 	    retList=[]
  422: 	    if hasattr(self,'coords'):
  423: 		    for x in self.coords:
  424: 			if len(x)>1:
  425: 				retList.append(string.join(x,","))
  426: 	    return retList
  427: 
  428:     
  429: 
  430:     def getContentType(self):
  431: 	    try:
  432: 		    return self.contentType
  433: 	    except:
  434: 		    return ""
  435: 
  436:     def getCopyrightType(self):
  437: 	    try:
  438: 		    return self.copyrightType
  439: 	    except:
  440: 		    return ""
  441: 
  442:     def getRenderingType(self):
  443: 	    try:
  444: 		    return self.renderingType
  445: 	    except:
  446: 		    return ""
  447: 
  448:     def ECHO_resource_config(self):
  449:         """Main configuration"""
  450: 
  451:         if not hasattr(self,'weight'):
  452:             self.weight=""
  453: 
  454:         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource.zpt').__of__(self)
  455:         return pt()
  456:     
  457: 
  458:     def ECHO_resource_config_main(self):
  459:         """Main configuration"""
  460: 
  461:         if not hasattr(self,'weight'):
  462:             self.weight=""
  463: 
  464:         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_main.zpt').__of__(self)
  465:         return pt()
  466: 
  467:     def ECHO_resource_config_coords(self):
  468:         """Coords configuration """
  469: 
  470:         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_coords.zpt').__of__(self)
  471:         return pt()
  472: 
  473:     def ECHO_resource_config_credits(self):
  474:         """Main configuration"""
  475: 
  476:         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_credits.zpt').__of__(self)
  477:         return pt()
  478: 
  479:     def ECHO_resource_config_metadata(self):
  480:         """Main configuration"""
  481: 
  482: 	if (hasattr(self,'metadata')) and not (hasattr(self,'metaDataHash')):
  483: 		self.metaDataHash={}
  484: 		self.contentType=self.bib_type
  485: 		for data in self.metadata:
  486: 			data_neu=re.sub('-','_',data)
  487: 			self.metaDataHash[data_neu]=getattr(self,data)
  488: 			#print data_neu, getattr(self,data)
  489: 		#print self.metaDataHash,self.metadata
  490: 	
  491:         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_metadata.zpt').__of__(self)
  492:         return pt()
  493: 
  494: 
  495:     
  496: 
  497:     def changeECHO_resource_main(self,metalink,link,title,label,description,contentType,renderingType,weight,resourceID,RESPONSE=None):
  498:         """Änderung der Properties"""
  499: 	self.resourceID=resourceID
  500: 	self.title=title
  501: 	self.label=label
  502: 	self.description=description
  503: 
  504: 	self.contentType=contentType
  505: 	self.renderingType=renderingType
  506: 	self.weight=weight
  507: 	
  508:         self.link=link
  509:         self.metalink=metalink
  510:         
  511:         if RESPONSE is not None:
  512:             RESPONSE.redirect('manage_main')
  513: 
  514: 
  515:     def changeECHO_resource_coords(self,coords,viewClassification,RESPONSE=None):
  516:         """Änderung der Properties - coords"""
  517: 
  518: 	try:        
  519:         	coordsnew=[ string.split(x,",") for x in coords]
  520:         except:
  521: 		coordsnew=[]	
  522: 
  523: 	self.coords=coordsnew[0:]
  524: 	self.viewClassification=viewClassification
  525:         
  526:         if RESPONSE is not None:
  527:             RESPONSE.redirect('manage_main')
  528: 
  529:     def changeECHO_resource_credits(self,credits,responsible,copyrightType,RESPONSE=None):
  530:         """Änderung der Properties"""
  531: 	self.credits=credits
  532: 	self.responsible=responsible
  533: 	self.copyrightType=copyrightType
  534:         
  535:         if RESPONSE is not None:
  536:             RESPONSE.redirect('manage_main')
  537: 
  538: 
  539:     def changeECHO_resource_metadata(self,RESPONSE=None):
  540: 	    """change metadata"""
  541: 	    tags=self.findTagsFromMapping(self.contentType)
  542: 	    OSAS_meta={}
  543: 	    for field in tags[1]:
  544: 		    try:
  545: 			    self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)]
  546: 			    self.OSAS_meta[self.getFieldTag(tags,field)]=self.REQUEST.form['OSAS_%s'%self.getFieldTag(tags,field)]
  547: 		    except:
  548: 			    """nothing"""
  549: 
  550: 	    return urllib.urlopen('http://localhost:8080/echo_nav/storage/downloadExternalXML?index_meta_url=%s&xml_url=%s'%(self.absolute_url()+'/newMetaXML',self.metalink)).read()
  551: 	    
  552: 	    if RESPONSE is not None:
  553: 		    RESPONSE.redirect('manage_main')
  554: 
  555: 
  556:     def newMetaXML(self):
  557: 	    self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
  558: 	    return writeMetadata(self.metalink,self.OSAS_meta)
  559: 
  560:     
  561:     def changeECHO_resource(self,metalink,link,title,label,description,contentType,responsible,weight,viewClassification="",coords=None,credits=None,RESPONSE=None):
  562:         """Änderung der Properties"""
  563:         
  564: 	try:        
  565:         	coordsnew=[ string.split(x,",") for x in coords]
  566:         except:
  567: 		coordsnew=[]	
  568:         
  569:         setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)
  570: 	self.viewClassification=viewClassification
  571:         self.coords=coordsnew[0:]
  572:         self.link=link
  573:         self.metalink=metalink
  574:         
  575:         if RESPONSE is not None:
  576:             RESPONSE.redirect('manage_main')
  577:             
  578:             
  579:     manage_options = Folder.manage_options+(
  580:         {'label':'Main Config','action':'ECHO_resource_config_main'},
  581: 	{'label':'Change Credits & Copyright','action':'ECHO_resource_config_credits'},
  582: 	{'label':'Change Metadata','action':'ECHO_resource_config_metadata'},
  583: 	{'label':'Change Coords','action':'ECHO_resource_config_coords'},
  584: 	{'label':'Add coords','action':'ECHO_graphicEntry'},
  585:         {'label':'Sync Metadata','action':'ECHO_getResourceMD'},
  586: 	)
  587: 
  588:     def getOverview(self):
  589:         """overview graphics"""
  590:         
  591:         return self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])[0][1]
  592: 
  593:     def ECHO_graphicEntry(self):
  594:         """DO nothing"""
  595:         overview = self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])
  596:         if overview: 
  597:             pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_draw.zpt').__of__(self)
  598:             return pt()
  599:         else:
  600:             return "NO OVERVIEW GRAPHICS"
  601: 
  602:     def ECHO_enterCoords(self,coordstr,angle="",RESPONSE=None):
  603:         """Enter coords"""
  604:         coords=self.coords
  605:         temco=coordstr.split(",")
  606:         temco.append(angle)
  607:         coords.append(temco)
  608:         
  609:         self.coords=coords[0:]
  610: 
  611:         if RESPONSE is not None:
  612:             RESPONSE.redirect('ECHO_graphicEntry')
  613: 
  614: 
  615:     def isDefinedInThisSet(self,fields,field):
  616: 	    """checks if field is defined in fields"""
  617: 	    if (fields[0].has_key(field)) and not (fields[0][field]==""):
  618: 		    return 1
  619: 	    else:
  620: 		  
  621: 		    return 0
  622: 	    
  623:     def getFieldLabel(self,fields,field):
  624:         """get labels"""
  625:         try:
  626:             ret =fields[0][field]
  627:             if ret == "":
  628:                 return field
  629:             else:
  630:                 return ret
  631:         except:
  632:             return field
  633: 
  634: 
  635: 
  636:     def getFieldTag(self,fields,field):
  637:         """get labels"""
  638:         try:
  639:             ret =fields[0][field]
  640:             if ret == "":
  641:                 return field
  642:             else:
  643:                 return ret
  644:         except:
  645:             return field
  646: 
  647:     
  648:         
  649:     def getFieldValue(self,field):
  650:         """get value"""
  651: 	#print field
  652:         try:
  653: 	
  654:             ret=self.metaDataHash[field]
  655:             if ret == "":
  656:                 return None
  657:             else:
  658:                 return ret
  659:         except:
  660:             return None
  661: 
  662:     def findLabelsFromMapping(self,referenceType):
  663:         """gib hash mit label -> generic zurueck"""
  664:         self.referencetypes=self.ZopeFind(self.standardMD)
  665: 	#print "RT",referenceType
  666: 	
  667:         bibdata={}
  668:         retdata={}
  669:         fieldlist=self.standardMD.fieldList
  670:         
  671: 	for referenceTypeF in self.referencetypes:
  672: 		#print referenceTypeF[1].title,referenceType	
  673: 		if referenceTypeF[1].title == referenceType:
  674: 			#print "OK"
  675: 			bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
  676: 			bibdata['data']=referenceTypeF[1]
  677: 			self.fields=bibdata[referenceType]
  678:                         for field in fieldlist:
  679:                             retdata[field]=referenceTypeF[1].getValue(field)[1]
  680: 	#print retdata,fieldlist
  681:         return retdata,fieldlist
  682: 
  683:     def findTagsFromMapping(self,referenceType):
  684:         """gib hash mit label -> generic zurueck"""
  685:         self.referencetypes=self.ZopeFind(self.standardMD)
  686: 	
  687: 	
  688:         bibdata={}
  689:         retdata={}
  690:         fieldlist=self.standardMD.fieldList
  691:         
  692: 	for referenceTypeF in self.referencetypes:
  693: 	
  694: 		if referenceTypeF[1].title == referenceType: 
  695: 			bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
  696: 			bibdata['data']=referenceTypeF[1]
  697: 			self.fields=bibdata[referenceType]
  698:                         for field in fieldlist:
  699:                             retdata[field]=referenceTypeF[1].getValue(field)[0]
  700: 	
  701:         return retdata,fieldlist
  702: 
  703:     
  704:     
  705: 		    
  706:     def ECHO_getResourceMD(self,template="yes"):
  707:         """Einlesen der Metadaten und Anlegen dieser Metadaten als Informationen zur Resource"""
  708:         (metadict, error)=readMetadata(self.metalink)
  709: 
  710: 
  711: 
  712:         if not error=="": #Fehler beim Auslesen des Metafiles
  713: 		return "ERROR:",error
  714: 	
  715: 
  716: 	if not (metadict['bib_type']==self.contentType):
  717: 		self.REQUEST.SESSION['contentStorage']=metadict['bib_type']
  718: 		self.REQUEST.SESSION['contentZope']=self.contentType
  719: 
  720: 		return PageTemplateFile('Products/ECHO_content/zpt/ECHO_getResourceMDErrorContentType.zpt').__of__(self)()
  721: 		
  722:         self.REQUEST.SESSION['metadict']=metadict
  723: 
  724: 	self.REQUEST.SESSION['diffs']=checkDiffs(self,metadict)
  725: 
  726: 		
  727:         if template=="yes":
  728:             pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_resourceMD.zpt').__of__(self)
  729:             return pt()
  730: 
  731: 
  732:     
  733:     
  734:     def ECHO_getMD(self,item):
  735:         """Ausgabe der MD"""
  736:         return getattr(self,item)
  737:         
  738:     def index_html(self):
  739:         """standard page"""
  740:         
  741:         return self.REQUEST.RESPONSE.redirect(self.link)
  742: 
  743:     def generate_label(self):
  744:         """Erzeugt_standard_Label aus Template"""
  745:         pt=getattr(self,"label_template_"+self.bib_type)
  746: 
  747:         return pt()
  748: 
  749: def manage_addECHO_resourceForm(self):
  750:         """Form for adding a ressource"""
  751:         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_resourceForm.zpt').__of__(self)
  752:         return pt()
  753: 
  754: 
  755: 
  756: def manage_addECHO_resource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None):
  757:     """addaresource"""
  758: 
  759:     newObj=ECHO_resource(id,link,metalink,title,label,description,contentType,responsible,credits,weight,coords)
  760: 
  761:     self._setObject(id,newObj)
  762: 
  763:     if RESPONSE is not None:
  764:         RESPONSE.redirect('manage_main')
  765:  
  766: 
  767: class ECHO_externalLink(Folder):
  768:     """Link zu einer externen Ressource"""
  769:     security=ClassSecurityInfo()
  770:     meta_type='ECHO_externalLink'
  771: 
  772:     def getTitle(self):
  773: 	"""title"""
  774: 	return self.title.encode('utf-8') 
  775: 
  776:     def getLabel(self):
  777: 	"""title"""
  778: 	return self.label.encode('utf-8') 
  779: 
  780:     def content_html(self):
  781:         """template fuer content"""
  782:         return content_html(self,'externalLink')
  783:     
  784:     def __init__(self,id,link,title,label,description,contentType,responsible,credits,weight,coords):
  785: 
  786:         self.id = id
  787:         """Festlegen der ID"""
  788: 
  789:         self.credits=toList(credits)
  790:         self.label = label
  791:         self.link= link
  792:         self.title=title
  793:         self.weight=weight
  794:         self.description=description
  795:         self.contentType=contentType
  796:         self.responsible=responsible
  797:         coordsnew=[ string.split(x,",") for x in coords]
  798:         self.coords=coordsnew
  799: 
  800:     def ECHO_externalLink_config(self):
  801:         """Main configuration"""
  802: 
  803:         if not hasattr(self,'weight'):
  804:             self.weight=""
  805:         if not hasattr(self,'coords'):
  806:             
  807:             self.coords=['']
  808:             #print "G",self.coords
  809: 
  810:         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_externalLink.zpt').__of__(self)
  811:         return pt()
  812:     
  813: 
  814:     def changeECHO_externalLink(self,link,title,label,description,contentType,responsible,weight,coords=None,credits=None,RESPONSE=None):
  815: 
  816:         """Änderung der Properties"""
  817: 	try:
  818: 		coordsnew=[ string.split(x,",") for x in coords]
  819: 	except:
  820: 		coordsnew=[]
  821: 
  822:         setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coords)
  823: 
  824:         self.coords=coordsnew[0:]
  825:         self.link=link
  826:         if RESPONSE is not None:
  827:             RESPONSE.redirect('manage_main')
  828:             
  829:             
  830:     manage_options = Folder.manage_options+(
  831:         {'label':'Main Config','action':'ECHO_externalLink_config'},
  832:         )
  833: 
  834:     def getCredits(self):
  835:         """Ausgabe der credits"""
  836:         if self.credits:
  837:             return self.credits
  838:         else:
  839:             return []
  840:         
  841:     def index_html(self):
  842:         """standard page"""
  843:         
  844:         return self.REQUEST.RESPONSE.redirect(self.link)
  845: 
  846: def manage_addECHO_externalLinkForm(self):
  847:         """Form for external Links"""
  848:         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_externalLinkForm.zpt').__of__(self)
  849:         return pt()
  850: 
  851: 
  852: def manage_addECHO_externalLink(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None):
  853:     """Add an external Link"""
  854: 
  855:     newObj=ECHO_externalLink(id,link,title,label,description,contentType,responsible,credits,weight,coords)
  856: 
  857:     self._setObject(id,newObj)
  858: 
  859:     if RESPONSE is not None:
  860:         RESPONSE.redirect('manage_main')
  861:  
  862: 
  863: class ECHO_link(ECHO_externalLink):
  864: 	"""external_link"""
  865: 
  866: 	meta_type="ECHO_link"
  867: 	
  868: 
  869: 	def content_html(self):
  870: 		"""template fuer content"""
  871: 		return content_html(self,'link')
  872: 	
  873: def manage_addECHO_linkForm(self):
  874:         """Form for external Links"""
  875:         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_linkForm.zpt').__of__(self)
  876:         return pt()
  877: 
  878: 
  879: def manage_addECHO_link(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None):
  880:     """Add an external Link"""
  881: 
  882:     newObj=ECHO_link(id,link,title,label,description,contentType,responsible,credits,weight,coords)
  883: 
  884:     self._setObject(id,newObj)
  885: 
  886:     if RESPONSE is not None:
  887:         RESPONSE.redirect('manage_main')
  888: 	
  889: 
  890: class ECHO_collection(Folder, Persistent, Implicit):
  891:     """ECHO Collection"""
  892:     security=ClassSecurityInfo()
  893:     meta_type='ECHO_collection'
  894:     viewClassificationList=viewClassificationListMaster
  895:     displayTypes=displayTypes
  896: 
  897:     def getViewClassification(self):
  898:         if hasattr(self,'viewClassification'):
  899:             return self.viewClassification
  900:         else:
  901:             return ""
  902: 
  903:     def getTitle(self):
  904: 	"""title"""
  905: 	return self.title.encode('utf-8') 
  906: 
  907:     def getLabel(self):
  908: 	"""title"""
  909: 	return self.label.encode('utf-8') 
  910: 
  911:     def createRessourcesFromXMLForm(self):
  912: 	    """form"""
  913: 	    pt=PageTemplateFile('Products/ECHO_content/zpt/createRessourcesFromXMLForm.zpt').__of__(self)
  914: 	    return pt()
  915:     def createRessourcesFromXML(self,fileupload):
  916: 	    """read an XML file for generating resources"""
  917: 	    dom=xml.dom.minidom.parse(fileupload)
  918: 	    ret="<h2>Added</h2>"
  919: 	    for resource in dom.getElementsByTagName('resource'):
  920: 		    link=getText(resource.getElementsByTagName('link')[0].childNodes)
  921: 		    label=getText(resource.getElementsByTagName('label')[0].childNodes)
  922: 		    #splitted=link.split("?")[0].split("/")
  923: 		    #id=splitted[len(splitted)-1].encode('ascii')
  924: 		    id=re.sub(" ","_",label).encode('ascii')
  925: 		    
  926: 		    ret+="<p>"+label+"</p>"
  927: 		    manage_addECHO_resource(self,id,label.encode('ascii'),label.encode('ascii'),"","","",link.encode('ascii'),"","")
  928: 	    return ret
  929:     def getImageTag(self):
  930:         """GetTag"""
  931:         try:
  932:             return self.imageTag
  933:         except:
  934:             return ""
  935: 
  936:     def addResource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None):
  937:         """SSS"""
  938:         try:
  939:             manage_addECHO_resource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None)
  940:             return "done"
  941:         except:
  942:             return None
  943: 
  944:     def getSecondaryLink(self):
  945:         """secondary link"""
  946:         try:
  947:             return self.secondaryLink
  948:         except:
  949:             return ""
  950: 
  951:     def getSecondaryLinkTitle(self):
  952:         """secondary link"""
  953:         try:
  954:             return self.secondaryLinkTitle
  955:         except:
  956:             return ""
  957:         
  958:     def getCollectionTreeXML(self):
  959:         """Tree as XML"""
  960: 
  961:         def getCollection(object,depth=0):
  962:             depth+=1
  963:             collections=""
  964:             for entry in object.__dict__.keys():
  965:                 element=getattr(object,entry)
  966:                 try:
  967:                     if element.meta_type in ["ECHO_collection","ECHO_group"]:
  968:                         collections+="<element name=\""+quote(element.title)+"\" url=\""+element.absolute_url()+"\">"
  969:                         collections+=getCollection(element,depth)+"</element>\n"
  970:                 except:
  971:                     """nothing"""
  972:             return collections
  973:         
  974: 	ret="""<?xml version="1.0" encoding="utf-8" ?>"""
  975:         return ret+"<collection>"+getCollection(self)+"</collection>"
  976:     
  977:     def createJavaScript(self):
  978:         """CreateJava"""
  979:         ret=javaScriptMain
  980: 
  981:         dynamical="\n"
  982:         for ob in self.getGraphicCoords():
  983: 	    if ob[4][4] == "":	
  984: 	        dynamical+="""Coords.push(new Coord('%s', Img, %s));\n"""%(ob[1],ob[0])
  985: 	    else:
  986: 		dynamical+="""Coords.push(new Coord('%s', Img, %s));//%s\n"""%(ob[1],ob[0],ob[4][4])
  987: 		dynamical+="ShowArrow(new getObj('i.%s'),Img,%s);\n"%(ob[1],ob[0])
  988: 	ret+=javaHandler%dynamical
  989:         return ret
  990: 
  991:     def createJSAreas(self):
  992:         """CreateJava"""
  993:         dynamical="\n"
  994:         for ob in self.getGraphicCoords():
  995: 	    if ob[5] == "area":	
  996: 	        dynamical+="""addArea('%s', 'overview', %s, 'area');\n"""%(ob[1],ob[0])
  997: 	    else:
  998: 	        dynamical+="""addArea('%s', 'overview', %s, 'arrow');\n"""%(ob[1],ob[0])
  999:         return dynamical
 1000:     
 1001:     security.declarePublic('getCreditObject')
 1002:     def getCreditObject(self,name):
 1003:         """credit id to credititem"""
 1004:         try:
 1005:             return getattr(self.partners,name)
 1006:         except:
 1007:             return ""
 1008: 
 1009:     security.declarePublic('ECHO_generateNavBar')
 1010:     def ECHO_generateNavBar(self):
 1011:         """Erzeuge Navigationsbar"""
 1012:         link=""
 1013:         object="self"
 1014:         ret=[]
 1015:         path=self.getPhysicalPath()
 1016:         for element in path:
 1017:             
 1018:            
 1019:             if not element=="":
 1020:                 object+="."+element
 1021:                 
 1022:                 label=eval(object).label
 1023:                 link+="/"+element
 1024:                 if not label=="":
 1025:                     ret.append((label,link))
 1026:         return ret
 1027:     
 1028:     security.declarePublic('ECHO_rerenderLinksMD')
 1029: 
 1030:     def ECHO_rerenderLinksMD(self,obj=None):
 1031:         """Rerender all Links"""
 1032:         if not obj:
 1033:             obj = self
 1034:             
 1035:         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection'])
 1036: 
 1037:         for entry in entries:
 1038: 		if entry[1].meta_type == 'ECHO_resource':
 1039: 			entry[1].ECHO_getResourceMD(template="no")
 1040: 			#print "rerender",entry[1].getId()
 1041: 		else:
 1042: 		   self.ECHO_rerenderLinksMD(entry[1])
 1043: 
 1044:                 
 1045:                 
 1046:         return "Rerenderd all links to resources in: "+self.title
 1047: 
 1048:     security.declarePublic('ECHO_newViewerLink')
 1049:     
 1050: 
 1051:     def getCoords(self):
 1052:         try:
 1053:             
 1054:             x=  [string.join(x,",") for x in self.coords]  
 1055:             return x
 1056: 
 1057:         except:
 1058: 
 1059:             return []
 1060:         
 1061:     def __init__(self,id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle,secondaryLink,imageTag="",bgcolour=""):
 1062:         #print "CO",coords
 1063: 
 1064:         self.id = id
 1065:         """Festlegen der ID"""
 1066:         self.credits=toList(credits)
 1067:         self.label = label
 1068:         self.title=title
 1069:         self.description=description
 1070:         self.contentType=contentType
 1071:         self.responsible=responsible
 1072:         self.imageTag=imageTag
 1073:         self.weight=weight
 1074:         self.sortfield=sortfield
 1075:         coordsnew=[ string.split(x,",") for x in coords]
 1076:         self.coords=coordsnew
 1077:         self.secondaryLinkTitle=secondaryLinkTitle
 1078:         self.secondaryLink=secondaryLink
 1079: 	self.bgcolour=bgcolour
 1080:         
 1081: 
 1082:     manage_options = Folder.manage_options+(
 1083:         {'label':'Main Config','action':'ECHO_collection_config'},
 1084:         {'label':'Rerender Links','action':'ECHO_rerenderLinksMD'},
 1085:         {'label':'Graphics','action':'ECHO_graphicEntry'},
 1086: 	{'label':'create resources from XML','action':'createRessourcesFromXMLForm'},
 1087: 
 1088:         )
 1089: 
 1090:     def getOverview(self):
 1091:         """overview graphics"""
 1092:         
 1093:         return self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])[0][1]
 1094:     
 1095:     
 1096:     def ECHO_graphicEntry(self):
 1097:         """DO nothing"""
 1098:         overview = self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])
 1099:         
 1100:     
 1101:         if overview:
 1102:             pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_draw.zpt').__of__(self)
 1103:             return pt()
 1104:         else:
 1105:             return "NO OVERVIEW GRAPHICS"
 1106: 
 1107:     def ECHO_enterCoords(self,coordstr,angle="",RESPONSE=None):
 1108:         """Enter coords"""
 1109:         coords=self.coords
 1110:         temco=coordstr.split(",")
 1111:         temco.append(angle)
 1112:         coords.append(temco)
 1113:         self.coords=coords[0:]
 1114: 
 1115:         if RESPONSE is not None:
 1116:             RESPONSE.redirect('ECHO_graphicEntry')
 1117: 
 1118:     
 1119:     security.declarePublic('ECHO_collection_config')
 1120:     def ECHO_collection_config(self):
 1121:         """Main configuration"""
 1122: 
 1123:         if not hasattr(self,'weight'):
 1124:             self.weight=""
 1125: 
 1126:         if not hasattr(self,'sortfield'):
 1127:             self.sortfield="weight"
 1128:   
 1129:         if not hasattr(self,'coords'):
 1130:             self.coords=[]
 1131: 
 1132:         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_collection.zpt').__of__(self)
 1133:         return pt()
 1134: 
 1135: 
 1136:     security.declarePublic('changeECHO_collection')
 1137: 
 1138: 
 1139:     def getBgcolour(self):
 1140: 	    """colour"""
 1141: 	    if hasattr(self,'bgcolour') and not (self.bgcolour==""):
 1142: 		    return self.bgcolour
 1143: 	    else:
 1144: 		    return "#dddddd"
 1145: 	    
 1146:     def changeECHO_collection(self,title,label,description,contentType,responsible,weight,secondaryLink,secondaryLinkTitle,credits=None,sortfield="weight",coords=None,RESPONSE=None,imageTag="",bgcolour="",viewClassification=None):
 1147:         """Aenderung der Properties"""
 1148: 
 1149:         self.secondaryLink=secondaryLink
 1150:         self.secondaryLinkTitle=secondaryLinkTitle
 1151:         self.imageTag=imageTag
 1152: 	self.bgcolour=bgcolour
 1153:         self.viewClassification=viewClassification
 1154: 	
 1155:         if coords:
 1156:             coordsnew=[ string.split(x,",") for x in coords]
 1157:             self.coords=coordsnew[0:]
 1158:         else:
 1159:             coordsnew=None
 1160:             self.coords=None
 1161:             
 1162:         setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)
 1163: 	try:
 1164: 		self.coords=coordsnew[0:] # HACK fehler in setECHO_collection
 1165:         except:
 1166: 		"""none"""
 1167: 		
 1168:         self.sortfield=sortfield
 1169: 
 1170:         if RESPONSE is not None:
 1171:             RESPONSE.redirect('manage_main')
 1172:             
 1173:     security.declarePublic('index_html')
 1174: 
 1175: 
 1176:     def showOverview(self):
 1177:         """overview"""
 1178:         if 'ECHO_overview.html' in self.__dict__.keys():
 1179:             return getattr(self,'ECHO_overview.html')()
 1180:         pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_content_overview.zpt').__of__(self)
 1181:         return pt()
 1182: 
 1183:     
 1184:     def index_html(self):
 1185:         """standard page"""
 1186:         
 1187:         if 'index.html' in self.__dict__.keys():
 1188:             return getattr(self,'index.html')()
 1189:         
 1190:         elif 'overview' in self.__dict__.keys():
 1191:             return self.showOverview()
 1192:         elif hasattr(self,'collection_index_template'):
 1193:             return self.collection_index_template()    
 1194:         elif hasattr(self,'main_index_template'):
 1195:             return self.main_index_template()    
 1196:         
 1197:         pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_main_index_template_standard.zpt').__of__(self)
 1198:         pt.content_type="text/html"
 1199:         return pt()
 1200: 
 1201:     def content_html(self):
 1202:         """template fuer content"""
 1203:         return content_html(self,'collection')
 1204:     
 1205:     def getCredits(self):
 1206:         """Ausgabe der credits"""
 1207:         if self.credits:
 1208:             return self.credits
 1209:         else:
 1210:             return []
 1211: 
 1212:     def area_img(self):
 1213:         """area image"""
 1214:         sendFile(self, 'images/red.gif', 'image/gif')
 1215:         return 
 1216: 
 1217:     def hl_lib_js(self):
 1218:         """javascript"""
 1219:         sendFile(self, 'js/hl_lib.js', 'text/plain')
 1220:         return 
 1221: 
 1222:     def js_lib_js(self):
 1223:         """javascript"""
 1224:         sendFile(self, 'js/js_lib.js', 'text/plain')
 1225:         return 
 1226: 
 1227:         
 1228:     def getGraphicCoords(self):
 1229:         """Give list of coordinates"""
 1230:         subColTypes=['ECHO_collection','ECHO_resource']
 1231:         ids=[]
 1232:         for entrySearch in self.ZopeFind(self,obj_metatypes=subColTypes):
 1233:             object=entrySearch[1]
 1234:             if hasattr(object,'coords'):
 1235:                 for coordtemp in object.coords:
 1236:                     if len(coordtemp)>3:
 1237:                         coord=coordtemp[0:4]
 1238:                         label=""
 1239: 			vc=""
 1240:                         if hasattr(object,'label') and not object.label=="":
 1241:                             label=object.label
 1242:                         elif hasattr(object,'title') and not object.title=="":
 1243:                             label=object.title
 1244:                         else:
 1245:                             label=object.getId()
 1246: 			if object.viewClassification != "":
 1247: 			    vc=object.viewClassification
 1248: 			else:
 1249: 			    if len(coordtemp) > 4 and coordtemp[4] != "":
 1250: 				vc="view point"
 1251: 			    else:
 1252: 				vc="area"
 1253:                         ids.append([string.join(coord,", "),object.getId(),label,object,coordtemp,vc])
 1254:         return ids
 1255:     
 1256: 
 1257: 
 1258: 
 1259:     getSubCols = ECHO_helpers.getSubCols
 1260:      
 1261:                 
 1262:     
 1263:     
 1264: def manage_addECHO_collectionForm(self):
 1265:         """Add collection form"""
 1266:         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_collectionForm.zpt').__of__(self)
 1267:         return pt()
 1268: 
 1269: 
 1270: def manage_addECHO_collection(self,id,title,label,description,contentType,responsible,weight,sortfield,coords="",secondaryLinkTitle="",secondaryLink="",credits=None,RESPONSE=None,imageTag="",bgcolour=""):
 1271:     """add a echo collection"""
 1272:     
 1273: 
 1274:     newObj=ECHO_collection(id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle=secondaryLinkTitle,secondaryLink=secondaryLink,imageTag=imageTag,bgcolour="")
 1275: 
 1276:     self._setObject(id,newObj)
 1277: 
 1278:     if RESPONSE is not None:
 1279:         RESPONSE.redirect('manage_main')
 1280: 
 1281: class ECHO_group(ECHO_collection):
 1282: 	"""ECHO Gruppe"""
 1283: 	meta_type="ECHO_group"
 1284: 
 1285: 	manage_options = Folder.manage_options+(
 1286: 		{'label':'Main Config','action':'ECHO_group_config'},
 1287: 		{'label':'Rerender Links','action':'ECHO_rerenderLinksMD'},
 1288: 		{'label':'Graphics','action':'ECHO_graphicEntry'},
 1289: 		)
 1290: 
 1291: 	def index_html(self):
 1292: 		"""standard page"""
 1293: 		displayedObjects=self.ZopeFind(self,obj_metatypes=displayTypes)
 1294: 		#if (len(displayedObjects)==1) and (displayedObjects[0][1].meta_type=="ECHO_collection"): # nur ein Object dann redirect auf dieses Object
 1295: 		#	return self.REQUEST.RESPONSE.redirect(displayedObjects[0][1].absolute_url())
 1296: 		
 1297: 		if 'index.html' in self.__dict__.keys():
 1298: 			return getattr(self,'index.html')()
 1299: 		
 1300: 		elif 'overview' in self.__dict__.keys():
 1301: 			return self.showOverview()
 1302: 		elif hasattr(self,'group_index_template'):
 1303: 			return self.group_index_template()
 1304: 		elif hasattr(self,'collection_index_template'):
 1305: 			return self.collection_index_template()    
 1306: 		elif hasattr(self,'main_index_template'):
 1307: 		    return self.main_index_template()    
 1308: 
 1309: 		pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_main_index_template_standard.zpt').__of__(self)
 1310: 		pt.content_type="text/html"
 1311: 		return pt()
 1312: 
 1313: 	def ECHO_group_config(self):
 1314: 		"""Main configuration"""
 1315: 		
 1316: 		if not hasattr(self,'weight'):
 1317: 			self.weight=""
 1318: 			
 1319: 		if not hasattr(self,'sortfield'):
 1320: 			self.sortfield="weight"
 1321: 				
 1322: 		if not hasattr(self,'coords'):
 1323: 			self.coords=[]
 1324: 
 1325: 		pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_group.zpt').__of__(self)
 1326: 		return pt()
 1327: 
 1328: 	def changeECHO_group(self,title,label,description,contentType,responsible,weight,secondaryLink,secondaryLinkTitle,credits=None,sortfield="weight",coords=None,RESPONSE=None,imageTag="",bgcolour="",logo=""):
 1329: 		"""Änderung der Properties"""
 1330: 
 1331: 		self.secondaryLink=secondaryLink
 1332: 		self.secondaryLinkTitle=secondaryLinkTitle
 1333: 		self.imageTag=imageTag
 1334: 		self.bgcolour=bgcolour
 1335:                 self.logo=logo
 1336:                 
 1337: 		if coords:
 1338: 		    coordsnew=[ string.split(x,",") for x in coords]
 1339: 		    self.coords=coordsnew[0:]
 1340: 		else:
 1341: 		    coordsnew=None
 1342: 		    self.coords=None
 1343: 
 1344: 		setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)
 1345: 
 1346: 
 1347: 
 1348: 		self.sortfield=sortfield
 1349: 
 1350: 		if RESPONSE is not None:
 1351: 		    RESPONSE.redirect('manage_main')
 1352: 
 1353: 	def getLogo(self):    
 1354: 		"""logo ausgeben"""
 1355:                 try:
 1356:                     return self.logo
 1357:                 except:
 1358:                     return "ECHO_groups"
 1359: 
 1360: 	def content_html(self):
 1361: 		"""template fuer content"""
 1362: 		return content_html(self,'group')
 1363:     
 1364: 
 1365: 
 1366: def manage_addECHO_groupForm(self):
 1367:         """Add group form"""
 1368:         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_groupForm.zpt').__of__(self)
 1369:         return pt()
 1370: 
 1371: 
 1372: def manage_addECHO_group(self,id,title,label,description,contentType,responsible,weight,sortfield,coords="",secondaryLinkTitle="",secondaryLink="",credits=None,RESPONSE=None,imageTag="",bgcolour="",logo=""):
 1373:     """add a echo group"""
 1374:     
 1375: 
 1376:     newObj=ECHO_group(id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle=secondaryLinkTitle,secondaryLink=secondaryLink,imageTag=imageTag,bgcolour="")
 1377: 
 1378:     setattr(newObj,'logo',logo)
 1379:     self._setObject(id,newObj)
 1380:     
 1381:     if RESPONSE is not None:
 1382:         RESPONSE.redirect('manage_main')
 1383: 
 1384: 
 1385: 	
 1386: class ECHO_root(Folder,Persistent,Implicit):
 1387:     """ECHO Root Folder"""
 1388:     meta_type="ECHO_root"
 1389: 
 1390:     
 1391:     def getImageTag(self):
 1392: 	    """needed by main_template"""
 1393: 	    return ""
 1394:     secondaryLink="" #needed by main_template
 1395:     secondaryLinkTitle="" #needed by main_template
 1396:     
 1397:     def getBgcolour(self):
 1398: 	"""hack"""
 1399: 	return "#dddddd"
 1400: 
 1401:     def contentTypeSelector_HTML(self,selected=None):
 1402:         """give type selector"""
 1403:         if not selected:
 1404:             retStr="<option selected>\n"
 1405:         else:
 1406:             retStr="<option>\n"
 1407:             
 1408:         try: # erste version contentTypes exists
 1409:             for contentType in self.ZopeFind(self.contentTypes,obj_metatypes=["ECHO_contentType","OSAS_MetadataMapping"]):
 1410:                 if selected and (contentType[0]==selected):
 1411:                     retStr+="""<option selected value="%s">%s\n"""%(contentType[0],contentType[0])
 1412:                 else:                
 1413:                     retStr+="""<option value="%s">%s\n"""%(contentType[0],contentType[0])
 1414:         except:
 1415: 		try:
 1416: 			for contentType in self.ZopeFind(self.standardMD,obj_metatypes=["OSAS_MetadataMapping"]):
 1417: 				if selected and (contentType[0]==selected):
 1418: 					retStr+="""<option selected value="%s">%s\n"""%(contentType[0],contentType[0])
 1419: 				else:                
 1420: 					retStr+="""<option value="%s">%s\n"""%(contentType[0],contentType[0])
 1421: 		except:
 1422: 			"""nothing"""
 1423: 			    
 1424: 	return retStr
 1425: 
 1426:     def renderingTypeSelector_HTML(self,selected=None):
 1427:          """give type selector"""
 1428: 	 if not selected:
 1429: 		 retStr="<option selected>\n"
 1430: 	 else:
 1431: 		 retStr="<option>\n"
 1432: 		 
 1433: 	 try: # erste version renderingTypes exists
 1434: 		 for renderingType in self.ZopeFind(self.renderingTypes,obj_metatypes=["ECHO_renderingType"]):
 1435: 			 if selected and (renderingType[0]==selected):
 1436: 				 retStr+="""<option selected value="%s">%s\n"""%(renderingType[0],renderingType[0])
 1437: 			 else:                
 1438: 				 retStr+="""<option value="%s">%s\n"""%(renderingType[0],renderingType[0])
 1439: 	 except:
 1440: 		 """nothing"""
 1441: 	 return retStr
 1442: 
 1443:     def renderingTypeSelector_HTML(self,selected=None):
 1444:          """give type selector"""
 1445: 	 if not selected:
 1446: 		 retStr="<option selected>\n"
 1447: 	 else:
 1448: 		 retStr="<option>\n"
 1449: 		 
 1450: 	 try: # erste version renderingTypes exists
 1451: 		 for renderingType in self.ZopeFind(self.renderingTypes,obj_metatypes=["ECHO_renderingType"]):
 1452: 			 if selected and (renderingType[0]==selected):
 1453: 				 retStr+="""<option selected value="%s">%s\n"""%(renderingType[0],renderingType[0])
 1454: 			 else:                
 1455: 				 retStr+="""<option value="%s">%s\n"""%(renderingType[0],renderingType[0])
 1456: 	 except:
 1457: 		 """nothing"""
 1458: 	 return retStr
 1459: 
 1460: 
 1461:     def copyrightTypeSelector_HTML(self,selected=None):
 1462:          """give type selector"""
 1463: 	 if not selected:
 1464: 		 retStr="<option selected>\n"
 1465: 	 else:
 1466: 		 retStr="<option>\n"
 1467: 		 
 1468: 	 try: # erste version copyrightTypes exists
 1469: 		 for copyrightType in self.ZopeFind(self.copyrightTypes,obj_metatypes=["ECHO_copyrightType"]):
 1470: 			 if selected and (copyrightType[0]==selected):
 1471: 				 retStr+="""<option selected value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
 1472: 			 else:                
 1473: 				 retStr+="""<option value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
 1474: 	 except:
 1475: 		 """nothing"""
 1476: 	 return retStr
 1477: 
 1478:             
 1479:     def patchContentType(self,obj=None):
 1480:         """austauschen content_type with contentType (patch bei umstieg von alter Version)"""
 1481:     
 1482: 
 1483:         if not obj:
 1484:             obj = self
 1485:             
 1486:         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_externalLink','ECHO_pageTemplate'])
 1487: 
 1488:         for entry in entries:
 1489:                 setattr(entry[1],'contentType',entry[1].content_type)
 1490:                 #entry[1].contentType == entry[1].content_type
 1491: 
 1492:                 if entry[1].meta_type == 'ECHO_collection':
 1493:                     entry[1].patchContentType(entry[1])    
 1494: 
 1495:                 
 1496:         return "changed all contenttypes in: "+self.title
 1497: 
 1498: 
 1499:     def patchViewClassification(self,obj=None):
 1500:         """setze viewClassification heuristisch"""
 1501: 
 1502: 	def checkIfArrow(obj):
 1503: 		if hasattr(obj,'coords'):
 1504: 			for coordtemp in obj.coords:
 1505: 				#print obj.title,len(coordtemp)
 1506: 				if (len(coordtemp)>4) and not (coordtemp[4]==''):
 1507: 					return 4
 1508: 			return None
 1509: 		return None
 1510: 	
 1511:         if not obj:
 1512:             obj = self
 1513:             
 1514:         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_group'])
 1515: 
 1516:         for entry in entries:
 1517: 		
 1518: 		if checkIfArrow(entry[1]):
 1519: 			setattr(entry[1],'viewClassification','view point')
 1520: 		else:
 1521: 			setattr(entry[1],'viewClassification','area')
 1522: 
 1523:                 #entry[1].contentType == entry[1].content_type
 1524: 
 1525:                 if entry[1].meta_type in ['ECHO_collection','ECHO_group']:
 1526:                     entry[1].patchViewClassification(entry[1])    
 1527: 
 1528:                 
 1529:         return "changed all contenttypes in: "+self.title
 1530: 
 1531:     def ECHO_newViewerLink(self,obj=None):
 1532:         """change links (:86 faellt weg)"""
 1533: 
 1534:         if not obj:
 1535:             obj = self
 1536:             
 1537:         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection'])
 1538: 
 1539:         for entry in entries:
 1540:                 
 1541:                 if entry[1].meta_type == 'ECHO_resource':
 1542:                     
 1543:                     entry[1].link=re.sub('\:86','',entry[1].link)
 1544: 
 1545:                 else:
 1546:                     
 1547:                     entry[1].ECHO_newViewerLink(entry[1])
 1548:                 
 1549:         return "Rerenderd all links to resources in: "+self.title
 1550: 
 1551:     def __init__(self,id,title):
 1552:         """init"""
 1553:         self.id = id
 1554:         self.title=title
 1555: 
 1556:     def deleteSpace(self,str):
 1557:         """delete space at the end of a line"""
 1558:         if str[len(str)-1]==" ":
 1559:             return str[0:len(str)-1]
 1560:         else:
 1561:             return str
 1562:         
 1563:     
 1564: 
 1565:     # zusaetliche methoden fuer das vlp muessen in ein eigenes produkt
 1566: 
 1567:     def formatAscii(self,str,url=None):
 1568:         """ersetze ascii umbrueche durch <br>"""
 1569:         #url=None
 1570:         if url:
 1571:             
 1572:             retStr=""
 1573:             words=str.split("\n")
 1574:             
 1575:             for word in words:
 1576:                 strUrl=url%word
 1577:                 #print "str",strUrl
 1578:                 retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)
 1579:             str=retStr
 1580:         if str:
 1581:             return re.sub(r"[\n]","<br/>",str)
 1582:         else:
 1583:             return ""
 1584:         
 1585:     def link2html(self,str):
 1586:         """link2html fuer VLP muss hier noch raus"""
 1587:         if str:
 1588:             #print str
 1589:             str=re.sub("\&","&amp;",str)
 1590:             dom=xml.dom.minidom.parseString("<?xml version='1.0' ?><txt>"+str+"</txt>")
 1591:             links=dom.getElementsByTagName("link")
 1592:             
 1593:             #print "link",links
 1594:             for link in links:
 1595:                 link.tagName="a"
 1596:                 ref=link.getAttribute("ref")
 1597:                 if self.checkRef(ref):
 1598:                     link.setAttribute("href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref)
 1599: 
 1600:             return dom.toxml('utf-8')
 1601:         return ""
 1602: 
 1603: 
 1604:     def checkRef(self,ref):
 1605:         dbs={'vl_literature':'AND CD LIKE \'%lise%\'','vl_technology':'','vl_people':''}
 1606:         res=None
 1607:         for db in dbs.keys():
 1608:             #print ref,"select reference from %s where reference =\'%s\' %s"%(db,ref,dbs[db])
 1609: 
 1610:             res=res or self.search(var=str("select reference from %s where reference =\'%s\' %s"%(db,ref,dbs[db])))
 1611:         return res
 1612:                                     
 1613:     #Ende Methode fuer vlp
 1614: 
 1615:     def PgQuoteString(self,string):
 1616:         """Quote string"""
 1617:         #print "PG",string
 1618:         return libpq.PgQuoteString(string)
 1619:         
 1620:     def getPartners(self):
 1621:         """Get list of Partners. Presently only from a subfolder partners"""
 1622:                     
 1623:         return [ item[1] for item in self.partners.ZopeFind(self.partners,obj_metatypes=['ECHO_partner'])]
 1624:                 
 1625:                 
 1626:                    
 1627: 
 1628:     
 1629:     def getPartnersXML(self):
 1630:         """partner liste als xml""" 
 1631:         partners=self.getPartners()
 1632:         ret="""<?xml version="1.0" encoding="utf-8" ?>
 1633: 	<partners>"""
 1634:         
 1635: 	for partner in partners:
 1636:             ret+="""<partner id="%s" title="%s"/>\n"""%(partner.getId(),unicode(partner.title,'utf-8','replace'))
 1637: 
 1638:         return ret+"\n</partners>"
 1639:     
 1640:     def getCollectionTree(self):
 1641:         """get the collection tree (list of triples (parent,child, depth)"""
 1642: 
 1643:         def getCollection(object,depth=0):
 1644:             depth+=1
 1645:             collections=[]
 1646:             for entry in object.__dict__.keys():
 1647:                 element=getattr(object,entry)
 1648:                 try:
 1649:                     if element.meta_type=="ECHO_collection":
 1650:                         collections.append((object,element,depth))
 1651:                         collections+=getCollection(element,depth)
 1652:                 except:
 1653:                     """nothing"""
 1654:             return collections
 1655:         
 1656: 
 1657:         return getCollection(self)
 1658:     
 1659:     def getCollectionTreeIds(self):
 1660:         """Show the IDs of the Tree"""
 1661:         ret=[]
 1662:         for collection in self.getCollectionTree():
 1663:             ret.append((collection[0].getId(),collection[1].getId(),collection[2]))
 1664:         return ret
 1665: 
 1666:         
 1667:         
 1668: def manage_addECHO_root(self,id,title,RESPONSE=None):
 1669:     """Add an ECHO_root"""
 1670:     self._setObject(id,ECHO_root(id,title))
 1671:     
 1672:     if RESPONSE is not None:
 1673:         RESPONSE.redirect('manage_main')
 1674: 
 1675: def manage_addECHO_rootForm(self):
 1676:         """Nothing yet"""
 1677:         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_root.zpt').__of__(self)
 1678:         return pt()
 1679:  
 1680: class ECHO_partner(Image,Persistent):
 1681:     """ECHO Partner"""
 1682: 
 1683:     meta_type="ECHO_partner"
 1684: 
 1685:     def __init__(self, id, title,url, file, content_type='', precondition=''):
 1686:         self.__name__=id
 1687:         self.title=title
 1688:         self.url=url
 1689:         self.precondition=precondition
 1690: 
 1691:         data, size = self._read_data(file)
 1692:         content_type=self._get_content_type(file, data, id, content_type)
 1693:         self.update_data(data, content_type, size)
 1694: 
 1695:     manage_options = Image.manage_options+(
 1696:         {'label':'Partner Information','action':'ECHO_partner_config'},
 1697:         )
 1698: 
 1699:     def changeECHO_partner(self,url,RESPONSE=None):
 1700:         """Change main information"""
 1701:         self.url=url
 1702:         if RESPONSE is not None:
 1703:             RESPONSE.redirect('manage_main')
 1704:             
 1705:             
 1706: 
 1707:     def ECHO_partner_config(self):
 1708:         """Main configuration"""
 1709:         if not hasattr(self,'url'):
 1710:             self.url=""
 1711:         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_partner.zpt').__of__(self)
 1712:         return pt()
 1713: 
 1714:         
 1715: manage_addECHO_partnerForm=DTMLFile('dtml/ECHO_partnerAdd',globals(),
 1716:                              Kind='ECHO_partner',kind='ECHO_partner')
 1717: 
 1718: 
 1719: 
 1720: def manage_addECHO_partner(self, id, file,url, title='', precondition='', content_type='',
 1721:                     REQUEST=None):
 1722:     """
 1723:     Add a new ECHO_partner object.
 1724: 
 1725:     Creates a new ECHO_partner object 'id' with the contents of 'file'.
 1726:     Based on Image.manage_addImage
 1727:     """
 1728: 
 1729:     id=str(id)
 1730:     title=str(title)
 1731:     content_type=str(content_type)
 1732:     precondition=str(precondition)
 1733: 
 1734:     id, title = OFS.Image.cookId(id, title, file)
 1735: 
 1736:     self=self.this()
 1737: 
 1738:     # First, we create the image without data:
 1739:     self._setObject(id, ECHO_partner(id,title,url,'',content_type, precondition))
 1740: 
 1741:     # Now we "upload" the data.  By doing this in two steps, we
 1742:     # can use a database trick to make the upload more efficient.
 1743:     if file:
 1744:         self._getOb(id).manage_upload(file)
 1745:     if content_type:
 1746:         self._getOb(id).content_type=content_type
 1747: 
 1748:     if REQUEST is not None:
 1749:         try:    url=self.DestinationURL()
 1750:         except: url=REQUEST['URL1']
 1751:         REQUEST.RESPONSE.redirect('%s/manage_main' % url)
 1752:     return id
 1753: 
 1754: 

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