File:  [Repository] / ECHO_content / ECHO_collection.py
Revision 1.47: download - view: text, annotated - select for diffs - revision graph
Sun Apr 18 17:36:02 2004 UTC (20 years, 1 month ago) by casties
Branches: MAIN
CVS tags: HEAD
new Arrows for view point regions -- first try

    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: 
   30: #from psycopg import libpq
   31: #from pyPgSQL import libpq
   32: import xml.dom.minidom
   33: 
   34: import urllib
   35: import xml.dom.minidom
   36: from ECHO_graphicalOverview import javaHandler,javaScriptMain
   37: import ECHO_helpers
   38: 
   39: #List of different types for the graphical linking viewer
   40: viewClassificationListMaster=['view point','area']
   41: 
   42: def content_html(self,type):
   43:         """template fuer content"""
   44:         #templates = self.ZopeFind(self.aq_parent,obj_ids=[type+"_template"])
   45:         #
   46:         #if templates:
   47:         #    return templates[0][1]()
   48: 
   49:         try:
   50:             obj=getattr(self,type+"_template")
   51:             return obj()
   52:         except:
   53:             pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_%s_template_standard.zpt'%type).__of__(self)
   54:             pt.content_type="text/html"
   55:             return pt()
   56:     
   57: def toList(field):
   58:     """Einzelfeld in Liste umwandeln"""
   59:     if type(field)==StringType:
   60:         return [field]
   61:     else:
   62:         return field
   63:     
   64: def getText(nodelist):
   65: 
   66:     rc = ""
   67:     for node in nodelist:
   68:     	if node.nodeType == node.TEXT_NODE:
   69:            rc = rc + node.data
   70:     return rc
   71: 
   72: 
   73: def readMetadata(url):
   74:     """Methoden zum Auslesen der Metadateninformation zu einer Resource
   75:     Vorerst noch Typ bib"""
   76:     
   77:     metadict={}
   78:     try:
   79:         geturl=""
   80:         for line in urllib.urlopen(url).readlines():
   81:             geturl=geturl+line
   82:         
   83:         
   84:     except:
   85:         return (None,"Cannot open: "+url)
   86: 
   87:     try:
   88:         dom=xml.dom.minidom.parseString(geturl)
   89:     except:
   90:         return (None,"Cannot parse: "+url+"<br>"+geturl)
   91: 
   92:     metanode=dom.getElementsByTagName('bib')
   93:     metadict['bib_type']='Book'
   94:     if len(metanode)==0:
   95:         metanode=dom.getElementsByTagName('archimedes')
   96:         metadict['bib_type']='Archimedes'
   97:         #print "HELLO"
   98:         
   99:     if not len(metanode)==0:    
  100:         metacontent=metanode[0].childNodes
  101:     
  102:         try:
  103:             metadict['bib_type']=getText(dom.getElementsByTagName('bib')[0].attributes['type'].childNodes)
  104:         except:
  105:             """nothing"""
  106:         
  107:         for node in metacontent:
  108:             try:
  109:                 metadict[node.tagName.lower()]=getText(node.childNodes)
  110:             except:
  111:                 """nothing"""
  112: 
  113:     #print metadict
  114:     return metadict,""
  115:     
  116: 
  117: def setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordstrs,viewClassification=""):
  118: 
  119:         """Allegemeine Informationen zu einer ECHO Collection"""
  120: 
  121:         self.viewClassification=viewClassification
  122: 
  123:         self.label = label
  124:         self.title=title
  125:         self.description=description
  126:         self.contentType=contentType
  127:         self.responsible=responsible
  128:         self.credits=toList(credits)
  129:         self.weight=weight
  130: 
  131:         coords=[]
  132:         #coordinates of for rectangles
  133: 
  134:         #print "cs", coordstrs
  135:         if coordstrs:
  136:             for coordstr in coordstrs:
  137:                 #print "cs", coordstr
  138:                 try:
  139:                     temco=coordstr.split(",")
  140:                 except:
  141:                     temco=[]
  142:                 #temco.append(angle)
  143:                 coords.append(temco)
  144: 
  145: 
  146:         self.coords=coords[0:]
  147:             
  148: 
  149: class scientificClassification(SimpleItem,Persistent,Implicit):
  150:     """outdated will be deleeted in the next versions: subclass"""
  151:     security=ClassSecurityInfo()
  152:     
  153:     def __init__(self,context,science,practice):
  154:         self.context=context
  155:         self.science=science
  156:         self.practice=practice
  157:         self.id="scientific_Classification"
  158:         
  159:     security.declarePublic('get_context')
  160:     def get_context(self):
  161:         return self.context
  162:     
  163:     security.declarePublic('get_science')
  164:     def get_science(self):
  165:         return self.science
  166:         
  167:     security.declarePublic('get_practice')
  168:     def get_practice(self):
  169:         return self.practice
  170:     
  171:                 
  172: class scientificInformation(Folder,Persistent,Implicit):
  173:     """outdated will be deleted in the next versions: subclass scientificInformation"""
  174:     security=ClassSecurityInfo()
  175:     
  176:     
  177:     
  178:     def __init__(self,source_type,period):
  179: 
  180:         self.id="scientific_Information"
  181:         self.source_type=source_type
  182:         self.period=period
  183:         
  184: 
  185: 
  186:     security.declarePublic('get_source_type')
  187:     def get_source_type(self):
  188:         return self.source_type
  189:     
  190:     security.declarePublic('get_period')
  191:     def get_period(self):
  192:         return self.period
  193: 
  194: class ECHO_layoutTemplate(ZopePageTemplate):
  195:     """Create a layout Template for different purposes"""
  196: 
  197:     meta_type="ECHO_layoutTemplate"
  198: 
  199:     def __init__(self, id, text=None, content_type=None,EchoType=None):
  200:         self.id = str(id)
  201: 
  202: 
  203: 
  204:         self.ZBindings_edit(self._default_bindings)
  205:         if text is None:
  206:             self._default_content_fn = os.path.join(package_home(globals()),
  207:                                                'zpt/ECHO_%s_template_standard.zpt'%EchoType)
  208:             text = open(self._default_content_fn).read()
  209:         self.pt_edit(text, content_type)
  210: 
  211:     
  212:         """change form"""
  213: 
  214: 
  215: def manage_addECHO_layoutTemplateForm(self):
  216:     """Form for adding"""
  217:     pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_layoutTemplate.zpt').__of__(self)
  218:     return pt()
  219: 
  220: from urllib import quote
  221: 
  222: 
  223: def manage_addECHO_layoutTemplate(self, EchoType,title=None,REQUEST=None):
  224:     "Add a Page Template with optional file content."
  225:     if type(EchoType)==StringType:
  226:         EchoTypes=[EchoType]
  227:     else:
  228:         EchoTypes=EchoType
  229:         
  230:     for singleType in EchoTypes:
  231: 
  232:         id = str(singleType)+"_template"
  233:         if REQUEST is None:
  234:             self._setObject(id, ECHO_layoutTemplate(id, text,EchoType=singleType))
  235:             ob = getattr(self, id)
  236:             
  237:             if title:
  238:                 ob.pt_setTitle(title)
  239:             return ob
  240:         else:
  241:             file = REQUEST.form.get('file')
  242:             headers = getattr(file, 'headers', None)
  243:             if headers is None or not file.filename:
  244:                 zpt = ECHO_layoutTemplate(id,EchoType=singleType)
  245:             else:
  246:                 zpt = ECHO_layoutTemplate(id, file, headers.get('content_type'))
  247: 
  248:             self._setObject(id, zpt)
  249:             ob = getattr(self, id)
  250:             if title:
  251:                 ob.pt_setTitle(title)
  252: 
  253:             try:
  254:                 u = self.DestinationURL()
  255:             except AttributeError:
  256:                 u = REQUEST['URL1']
  257: 
  258:             
  259:     REQUEST.RESPONSE.redirect(u+'/manage_main')
  260:     return ''
  261: 
  262: class ECHO_resource(Folder):
  263:     """ECHO Ressource"""
  264:     meta_type='ECHO_resource'
  265: 
  266:     viewClassificationList=viewClassificationListMaster
  267: 
  268:     getSubCols = ECHO_helpers.getSubCols
  269: 
  270:     def content_html(self):
  271:         """template fuer content"""
  272:         return content_html(self,'resource')
  273:     
  274:     def getViewClassification(self):
  275:         if hasattr(self,'viewClassification'):
  276:             return self.viewClassification
  277:         else:
  278:             return ""
  279:         
  280:     def getCredits(self):
  281:         """Ausgabe der credits"""
  282:         if self.credits:
  283:             return self.credits
  284:         else:
  285:             return []
  286:     
  287:     def __init__(self,id,link,metalink,title,label,description,contentType,responsible,credits,weight,coords):
  288: 
  289:         self.id = id
  290:         """Festlegen der ID"""
  291:         
  292:         self.label = label
  293:         self.link= link
  294:         self.metalink=metalink
  295:         self.title=title
  296:         self.weight=weight
  297:         self.credits=toList(credits)
  298:         self.description=description
  299:         self.contentType=contentType
  300:         self.responsible=responsible
  301:         
  302:         if coords:
  303:             coordsnew=[ string.split(x,",") for x in coords]
  304:         else:
  305:             coordsnew=[]
  306:         
  307:         self.coords=coordsnew
  308: 
  309: 
  310:     def getCoords(self):
  311:         try:
  312:             return [string.join(x,",") for x in self.coords]  
  313:         except:
  314:             return []
  315: 
  316: 
  317:     def ECHO_resource_config(self):
  318:         """Main configuration"""
  319: 
  320:         if not hasattr(self,'weight'):
  321:             self.weight=""
  322:         if not hasattr(self,'coords'):
  323:             self.coords=[]
  324: 
  325:         print "vorher",self.coords
  326:         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource.zpt').__of__(self)
  327:         return pt()
  328:     
  329: 
  330:     def changeECHO_resource(self,metalink,link,title,label,description,contentType,responsible,weight,viewClassification="",coords=None,credits=None,RESPONSE=None):
  331:         """Änderung der Properties"""
  332:         
  333: 	try:        
  334:         	coordsnew=[ string.split(x,",") for x in coords]
  335:         except:
  336: 		coordsnew=[]	
  337:         
  338:         setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)
  339: 
  340:         self.coords=coordsnew[0:]
  341:         self.link=link
  342:         self.metalink=metalink
  343:         
  344:         if RESPONSE is not None:
  345:             RESPONSE.redirect('manage_main')
  346:             
  347:             
  348:     manage_options = Folder.manage_options+(
  349:         {'label':'Main Config','action':'ECHO_resource_config'},
  350:         {'label':'Metadata','action':'ECHO_getResourceMD'},
  351:         {'label':'Graphics','action':'ECHO_graphicEntry'},
  352:         )
  353: 
  354:     def getOverview(self):
  355:         """overview graphics"""
  356:         
  357:         return self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])[0][1]
  358: 
  359:     def ECHO_graphicEntry(self):
  360:         """DO nothing"""
  361:         overview = self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])
  362:         if overview: 
  363:             pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_draw.zpt').__of__(self)
  364:             return pt()
  365:         else:
  366:             return "NO OVERVIEW GRAPHICS"
  367: 
  368:     def ECHO_enterCoords(self,coordstr,angle="",RESPONSE=None):
  369:         """Enter coords"""
  370:         coords=self.coords
  371:         temco=coordstr.split(",")
  372:         temco.append(angle)
  373:         coords.append(temco)
  374:         
  375:         self.coords=coords[0:]
  376: 
  377:         if RESPONSE is not None:
  378:             RESPONSE.redirect('ECHO_graphicEntry')
  379: 
  380:     def ECHO_getResourceMD(self,template="yes"):
  381:         """Einlesen der Metadaten und Anlegen dieser Metadaten als Informationen zur Resource"""
  382:         (metadict, error)=readMetadata(self.metalink)
  383: 
  384: 
  385: 
  386:         if not error=="": #Fehler beim Auslesen des Metafiles
  387:             return "ERROR:",error
  388:         for key in metadict.keys():#Hinzufügen der Felder
  389: 
  390:             setattr(self,key,metadict[key].encode('ascii','replace'))
  391:         
  392: 
  393:         self.metadata=metadict.keys()
  394: 
  395:         self.label=self.generate_label()
  396:         
  397:         if template=="yes":
  398:             pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_resourceMD.zpt').__of__(self)
  399:             return pt()
  400:     
  401:     def ECHO_getMD(self,item):
  402:         """Ausgabe der MD"""
  403:         return getattr(self,item)
  404:         
  405:     def index_html(self):
  406:         """standard page"""
  407:         
  408:         return self.REQUEST.RESPONSE.redirect(self.link)
  409: 
  410:     def generate_label(self):
  411:         """Erzeugt_standard_Label aus Template"""
  412:         pt=getattr(self,"label_template_"+self.bib_type)
  413: 
  414:         return pt()
  415: 
  416: def manage_addECHO_resourceForm(self):
  417:         """Form for adding a ressource"""
  418:         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_resourceForm.zpt').__of__(self)
  419:         return pt()
  420: 
  421: 
  422: 
  423: def manage_addECHO_resource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None):
  424:     """addaresource"""
  425: 
  426:     newObj=ECHO_resource(id,link,metalink,title,label,description,contentType,responsible,credits,weight,coords)
  427: 
  428:     self._setObject(id,newObj)
  429: 
  430:     if RESPONSE is not None:
  431:         RESPONSE.redirect('manage_main')
  432:  
  433: 
  434: class ECHO_externalLink(Folder):
  435:     """Link zu einer externen Ressource"""
  436:     security=ClassSecurityInfo()
  437:     meta_type='ECHO_externalLink'
  438: 
  439:     def content_html(self):
  440:         """template fuer content"""
  441:         return content_html(self,'externalLink')
  442:     
  443:     def __init__(self,id,link,title,label,description,contentType,responsible,credits,weight,coords):
  444: 
  445:         self.id = id
  446:         """Festlegen der ID"""
  447: 
  448:         self.credits=toList(credits)
  449:         self.label = label
  450:         self.link= link
  451:         self.title=title
  452:         self.weight=weight
  453:         self.description=description
  454:         self.contentType=contentType
  455:         self.responsible=responsible
  456:         coordsnew=[ string.split(x,",") for x in coords]
  457:         self.coords=coordsnew
  458: 
  459:     def ECHO_externalLink_config(self):
  460:         """Main configuration"""
  461: 
  462:         if not hasattr(self,'weight'):
  463:             self.weight=""
  464:         if not hasattr(self,'coords'):
  465:             
  466:             self.coords=['']
  467:             #print "G",self.coords
  468: 
  469:         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_externalLink.zpt').__of__(self)
  470:         return pt()
  471:     
  472: 
  473:     def changeECHO_externalLink(self,link,title,label,description,contentType,responsible,weight,coords=None,credits=None,RESPONSE=None):
  474: 
  475:         """Änderung der Properties"""
  476: 	try:
  477: 		coordsnew=[ string.split(x,",") for x in coords]
  478: 	except:
  479: 		coordsnew=[]
  480: 
  481:         setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coords)
  482: 
  483:         self.coords=coordsnew[0:]
  484:         self.link=link
  485:         if RESPONSE is not None:
  486:             RESPONSE.redirect('manage_main')
  487:             
  488:             
  489:     manage_options = Folder.manage_options+(
  490:         {'label':'Main Config','action':'ECHO_externalLink_config'},
  491:         )
  492: 
  493:     def getCredits(self):
  494:         """Ausgabe der credits"""
  495:         if self.credits:
  496:             return self.credits
  497:         else:
  498:             return []
  499:         
  500:     def index_html(self):
  501:         """standard page"""
  502:         
  503:         return self.REQUEST.RESPONSE.redirect(self.link)
  504: 
  505: def manage_addECHO_externalLinkForm(self):
  506:         """Form for external Links"""
  507:         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_externalLinkForm.zpt').__of__(self)
  508:         return pt()
  509: 
  510: 
  511: def manage_addECHO_externalLink(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None):
  512:     """Add an external Link"""
  513: 
  514:     newObj=ECHO_externalLink(id,link,title,label,description,contentType,responsible,credits,weight,coords)
  515: 
  516:     self._setObject(id,newObj)
  517: 
  518:     if RESPONSE is not None:
  519:         RESPONSE.redirect('manage_main')
  520:  
  521: 
  522: 
  523: class ECHO_collection(Folder, Persistent, Implicit):
  524:     """ECHO Collection"""
  525:     security=ClassSecurityInfo()
  526:     meta_type='ECHO_collection'
  527: 
  528:     def createRessourcesFromXMLForm(self):
  529: 	    """form"""
  530: 	    pt=PageTemplateFile('Products/ECHO_content/zpt/createRessourcesFromXMLForm.zpt').__of__(self)
  531: 	    return pt()
  532:     def createRessourcesFromXML(self,fileupload):
  533: 	    """read an XML file for generating resources"""
  534: 	    dom=xml.dom.minidom.parse(fileupload)
  535: 	    ret="<h2>Added</h2>"
  536: 	    for resource in dom.getElementsByTagName('resource'):
  537: 		    link=getText(resource.getElementsByTagName('link')[0].childNodes)
  538: 		    label=getText(resource.getElementsByTagName('label')[0].childNodes)
  539: 		    #splitted=link.split("?")[0].split("/")
  540: 		    #id=splitted[len(splitted)-1].encode('ascii')
  541: 		    id=re.sub(" ","_",label).encode('ascii')
  542: 		    
  543: 		    ret+="<p>"+label+"</p>"
  544: 		    manage_addECHO_resource(self,id,label.encode('ascii'),label.encode('ascii'),"","","",link.encode('ascii'),"","")
  545: 	    return ret
  546:     def getImageTag(self):
  547:         """GetTag"""
  548:         try:
  549:             return self.imageTag
  550:         except:
  551:             return ""
  552: 
  553:     def addResource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None):
  554:         """SSS"""
  555:         try:
  556:             manage_addECHO_resource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None)
  557:             return "done"
  558:         except:
  559:             return None
  560: 
  561:     def getSecondaryLink(self):
  562:         """secondary link"""
  563:         try:
  564:             return self.secondaryLink
  565:         except:
  566:             return ""
  567: 
  568:     def getSecondaryLinkTitle(self):
  569:         """secondary link"""
  570:         try:
  571:             return self.secondaryLinkTitle
  572:         except:
  573:             return ""
  574:         
  575:     def getCollectionTreeXML(self):
  576:         """Tree as XML"""
  577: 
  578:         def getCollection(object,depth=0):
  579:             depth+=1
  580:             collections=""
  581:             for entry in object.__dict__.keys():
  582:                 element=getattr(object,entry)
  583:                 try:
  584:                     if element.meta_type in ["ECHO_collection","ECHO_group"]:
  585:                         collections+="<element name=\""+element.title+"\" url=\""+element.absolute_url()+"\">"
  586:                         collections+=getCollection(element,depth)+"</element>\n"
  587:                 except:
  588:                     """nothing"""
  589:             return collections
  590:         
  591: 
  592:         return "<collection>"+getCollection(self)+"</collection>"
  593:     
  594:     def createJavaScript(self):
  595:         """CreateJava"""
  596:         ret=javaScriptMain
  597: 
  598:         dynamical=""
  599:         for ob in self.getGraphicCoords():
  600: 	    if ob[4][4] == "":	
  601: 	        dynamical+="""Coords.push(new Coord('%s', Img, %s));\n"""%(ob[1],ob[0])
  602: 	    else:
  603: 	        dynamical+="""Coords.push(new Coord('%s', Img, %s));//%s\n"""%(ob[1],ob[0],ob[4][4])
  604: 		dynamical+="ShowArrow(new getObj('i.%s'),Img,%s);\n"%(ob[1],ob[0])
  605:         ret+=javaHandler%dynamical
  606:         return ret
  607:     
  608:     security.declarePublic('getCreditObject')
  609:     def getCreditObject(self,name):
  610:         """credit id to credititem"""
  611:         try:
  612:             return getattr(self.partners,name)
  613:         except:
  614:             return ""
  615: 
  616:     security.declarePublic('ECHO_generateNavBar')
  617:     def ECHO_generateNavBar(self):
  618:         """Erzeuge Navigationsbar"""
  619:         link=""
  620:         object="self"
  621:         ret=[]
  622:         path=self.getPhysicalPath()
  623:         for element in path:
  624:             
  625:            
  626:             if not element=="":
  627:                 object+="."+element
  628:                 
  629:                 label=eval(object).label
  630:                 link+="/"+element
  631:                 if not label=="":
  632:                     ret.append((label,link))
  633:         return ret
  634:     
  635:     security.declarePublic('ECHO_rerenderLinksMD')
  636:     def ECHO_rerenderLinksMD(self):
  637:         """Rerender all Links"""
  638:         
  639:         for entry in self.__dict__.keys():
  640:             object=getattr(self,entry)
  641:             
  642:             
  643:             try:
  644:                 
  645:                 if object.meta_type == 'ECHO_resource':
  646:                     
  647:                     object.ECHO_getResourceMD(template="no")
  648:                     
  649:             except:
  650:                 """nothing"""
  651:                 
  652:         return "Rerenderd all links to resources in: "+self.title
  653: 
  654:     security.declarePublic('ECHO_newViewerLink')
  655:     
  656: 
  657:     def getCoords(self):
  658:         try:
  659:             
  660:             x=  [string.join(x,",") for x in self.coords]  
  661:             return x
  662: 
  663:         except:
  664: 
  665:             return []
  666:         
  667:     def __init__(self,id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle,secondaryLink,imageTag="",bgcolour=""):
  668:         #print "CO",coords
  669: 
  670:         self.id = id
  671:         """Festlegen der ID"""
  672:         self.credits=toList(credits)
  673:         self.label = label
  674:         self.title=title
  675:         self.description=description
  676:         self.contentType=contentType
  677:         self.responsible=responsible
  678:         self.imageTag=imageTag
  679:         self.weight=weight
  680:         self.sortfield=sortfield
  681:         coordsnew=[ string.split(x,",") for x in coords]
  682:         self.coords=coordsnew
  683:         self.secondaryLinkTitle=secondaryLinkTitle
  684:         self.secondaryLink=secondaryLink
  685: 	self.bgcolour=bgcolour
  686:         
  687: 
  688:     manage_options = Folder.manage_options+(
  689:         {'label':'Main Config','action':'ECHO_collection_config'},
  690:         {'label':'Rerender Links','action':'ECHO_rerenderLinksMD'},
  691:         {'label':'Graphics','action':'ECHO_graphicEntry'},
  692: 	{'label':'create resources from XML','action':'createRessourcesFromXMLForm'},
  693: 
  694:         )
  695: 
  696:     def getOverview(self):
  697:         """overview graphics"""
  698:         
  699:         return self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])[0][1]
  700:     
  701:     
  702:     def ECHO_graphicEntry(self):
  703:         """DO nothing"""
  704:         overview = self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])
  705:         
  706:     
  707:         if overview:
  708:             pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_draw.zpt').__of__(self)
  709:             return pt()
  710:         else:
  711:             return "NO OVERVIEW GRAPHICS"
  712: 
  713:     def ECHO_enterCoords(self,coordstr,angle="",RESPONSE=None):
  714:         """Enter coords"""
  715:         coords=self.coords
  716:         temco=coordstr.split(",")
  717:         temco.append(angle)
  718:         coords.append(temco)
  719:         self.coords=coords[0:]
  720: 
  721:         if RESPONSE is not None:
  722:             RESPONSE.redirect('ECHO_graphicEntry')
  723: 
  724:     
  725:     security.declarePublic('ECHO_collection_config')
  726:     def ECHO_collection_config(self):
  727:         """Main configuration"""
  728: 
  729:         if not hasattr(self,'weight'):
  730:             self.weight=""
  731: 
  732:         if not hasattr(self,'sortfield'):
  733:             self.sortfield="weight"
  734:   
  735:         if not hasattr(self,'coords'):
  736:             self.coords=[]
  737: 
  738:         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_collection.zpt').__of__(self)
  739:         return pt()
  740: 
  741: 
  742:     security.declarePublic('changeECHO_collection')
  743: 
  744: 
  745:     def getBgcolour(self):
  746: 	    """colour"""
  747: 	    if hasattr(self,'bgcolour') and not (self.bgcolour==""):
  748: 		    return self.bgcolour
  749: 	    else:
  750: 		    return "#dddddd"
  751: 	    
  752:     def changeECHO_collection(self,title,label,description,contentType,responsible,weight,secondaryLink,secondaryLinkTitle,credits=None,sortfield="weight",coords=None,RESPONSE=None,imageTag="",bgcolour=""):
  753:         """Änderung der Properties"""
  754: 
  755:         self.secondaryLink=secondaryLink
  756:         self.secondaryLinkTitle=secondaryLinkTitle
  757:         self.imageTag=imageTag
  758: 	self.bgcolour=bgcolour
  759: 	
  760:         if coords:
  761:             coordsnew=[ string.split(x,",") for x in coords]
  762:             self.coords=coordsnew[0:]
  763:         else:
  764:             coordsnew=None
  765:             self.coords=None
  766:             
  767:         setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)
  768: 	try:
  769: 		self.coords=coordsnew[0:] # HACK fehler in setECHO_collection
  770:         except:
  771: 		"""none"""
  772: 		
  773:         self.sortfield=sortfield
  774: 
  775:         if RESPONSE is not None:
  776:             RESPONSE.redirect('manage_main')
  777:             
  778:     security.declarePublic('index_html')
  779: 
  780: 
  781:     def showOverview(self):
  782:         """overview"""
  783:         if 'ECHO_overview.html' in self.__dict__.keys():
  784:             return getattr(self,'ECHO_overview.html')()
  785:         pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_content_overview.zpt').__of__(self)
  786:         return pt()
  787: 
  788:     
  789:     def index_html(self):
  790:         """standard page"""
  791:         
  792:         if 'index.html' in self.__dict__.keys():
  793:             return getattr(self,'index.html')()
  794:         
  795:         elif 'overview' in self.__dict__.keys():
  796:             return self.showOverview()
  797:         elif hasattr(self,'collection_index_template'):
  798:             return self.collection_index_template()    
  799:         
  800:         pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_content_standard.zpt').__of__(self)
  801:         pt.content_type="text/html"
  802:         return pt()
  803: 
  804:     def content_html(self):
  805:         """template fuer content"""
  806:         return content_html(self,'collection')
  807:     
  808:     def getCredits(self):
  809:         """Ausgabe der credits"""
  810:         if self.credits:
  811:             return self.credits
  812:         else:
  813:             return []
  814: 
  815: 
  816:         
  817:     def getGraphicCoords(self):
  818:         """Give list of coordinates"""
  819:         subColTypes=['ECHO_collection','ECHO_externalLink','ECHO_resource']
  820:         ids=[]
  821:         for entry in self.__dict__.keys():
  822:             object=getattr(self,entry)
  823:             try:
  824:                 if object.meta_type in subColTypes:
  825:                     for coordtemp in object.coords:
  826:                         if len(coordtemp)>3:
  827:                             coord=coordtemp[0:4]
  828:                             if hasattr(object,'label') and not object.label=="":
  829:                                 ids.append([string.join(coord,", "),object.getId(),object.label,object,coordtemp])
  830:                             elif hasattr(object,'title'):
  831:                                 if not object.title=="":
  832:                                     ids.append([string.join(coord,", "),object.getId(),object.title,object,coordtemp])
  833:                                 else:
  834:                                     ids.append([string.join(coord,", "),object.getId(),object.getId(),object,coordtemp])
  835:                             else:
  836:                                 ids.append([string.join(coord,", "),object.getId(),object.getId(),object,coordtemp])
  837:                     
  838:             except:
  839:                 """nothing"""
  840: 
  841:         return ids
  842:     
  843: 
  844: 
  845: 
  846:     getSubCols = ECHO_helpers.getSubCols
  847:      
  848:                 
  849:     
  850:     
  851: def manage_addECHO_collectionForm(self):
  852:         """Add collection form"""
  853:         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_collectionForm.zpt').__of__(self)
  854:         return pt()
  855: 
  856: 
  857: def manage_addECHO_collection(self,id,title,label,description,contentType,responsible,weight,sortfield,coords="",secondaryLinkTitle="",secondaryLink="",credits=None,RESPONSE=None,imageTag="",bgcolour=""):
  858:     """add a echo collection"""
  859:     
  860: 
  861:     newObj=ECHO_collection(id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle=secondaryLinkTitle,secondaryLink=secondaryLink,imageTag=imageTag,bgcolour="")
  862: 
  863:     self._setObject(id,newObj)
  864: 
  865:     if RESPONSE is not None:
  866:         RESPONSE.redirect('manage_main')
  867: 
  868: class ECHO_group(ECHO_collection):
  869: 	"""ECHO Gruppe"""
  870: 	meta_type="ECHO_group"
  871: 
  872: 	manage_options = Folder.manage_options+(
  873: 		{'label':'Main Config','action':'ECHO_group_config'},
  874: 		{'label':'Rerender Links','action':'ECHO_rerenderLinksMD'},
  875: 		{'label':'Graphics','action':'ECHO_graphicEntry'},
  876: 		)
  877: 	def ECHO_group_config(self):
  878: 		"""Main configuration"""
  879: 		
  880: 		if not hasattr(self,'weight'):
  881: 			self.weight=""
  882: 			
  883: 		if not hasattr(self,'sortfield'):
  884: 			self.sortfield="weight"
  885: 				
  886: 		if not hasattr(self,'coords'):
  887: 			self.coords=[]
  888: 
  889: 		pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_group.zpt').__of__(self)
  890: 		return pt()
  891: 
  892: 	def changeECHO_group(self,title,label,description,contentType,responsible,weight,secondaryLink,secondaryLinkTitle,credits=None,sortfield="weight",coords=None,RESPONSE=None,imageTag="",bgcolour="",logo=""):
  893: 		"""Änderung der Properties"""
  894: 
  895: 		self.secondaryLink=secondaryLink
  896: 		self.secondaryLinkTitle=secondaryLinkTitle
  897: 		self.imageTag=imageTag
  898: 		self.bgcolour=bgcolour
  899:                 self.logo=logo
  900:                 
  901: 		if coords:
  902: 		    coordsnew=[ string.split(x,",") for x in coords]
  903: 		    self.coords=coordsnew[0:]
  904: 		else:
  905: 		    coordsnew=None
  906: 		    self.coords=None
  907: 
  908: 		setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)
  909: 
  910: 
  911: 
  912: 		self.sortfield=sortfield
  913: 
  914: 		if RESPONSE is not None:
  915: 		    RESPONSE.redirect('manage_main')
  916: 
  917: 	def getLogo(self):    
  918: 		"""logo ausgeben"""
  919:                 try:
  920:                     return self.logo
  921:                 except:
  922:                     return "ECHO_groups"
  923: 
  924: 	def content_html(self):
  925: 		"""template fuer content"""
  926: 		return content_html(self,'group')
  927:     
  928: 
  929: 
  930: def manage_addECHO_groupForm(self):
  931:         """Add group form"""
  932:         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_groupForm.zpt').__of__(self)
  933:         return pt()
  934: 
  935: 
  936: def manage_addECHO_group(self,id,title,label,description,contentType,responsible,weight,sortfield,coords="",secondaryLinkTitle="",secondaryLink="",credits=None,RESPONSE=None,imageTag="",bgcolour="",logo=""):
  937:     """add a echo group"""
  938:     
  939: 
  940:     newObj=ECHO_group(id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle=secondaryLinkTitle,secondaryLink=secondaryLink,imageTag=imageTag,bgcolour="")
  941: 
  942:     setattr(newObj,'logo',logo)
  943:     self._setObject(id,newObj)
  944:     
  945:     if RESPONSE is not None:
  946:         RESPONSE.redirect('manage_main')
  947: 
  948: 
  949: 	
  950: class ECHO_root(Folder,Persistent,Implicit):
  951:     """ECHO Root Folder"""
  952:     meta_type="ECHO_root"
  953: 
  954:     def getBgcolour(self):
  955: 	"""hack"""
  956: 	return "#dddddd"
  957: 
  958:     def contentTypeSelector_HTML(self,selected=None):
  959:         """give type selector"""
  960:         if not selected:
  961:             retStr="<option selected>\n"
  962:         else:
  963:             retStr="<option>\n"
  964:             
  965:         try:
  966:             for contentType in self.ZopeFind(self.contentTypes,obj_metatypes="ECHO_contentType"):
  967:                 if selected and (contentType[0]==selected):
  968:                     retStr+="""<option selected value="%s">%s\n"""%(contentType[0],contentType[0])
  969:                 else:                
  970:                     retStr+="""<option value="%s">%s\n"""%(contentType[0],contentType[0])
  971:         except:
  972:             """nothing"""
  973:         return retStr
  974:             
  975:     def patchContentType(self,obj=None):
  976:         """austauschen content_type with contentType (patch bei umstieg von alter Version)"""
  977:     
  978: 
  979:         if not obj:
  980:             obj = self
  981:             
  982:         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_externalLink','ECHO_pageTemplate'])
  983: 
  984:         for entry in entries:
  985:                 setattr(entry[1],'contentType',entry[1].content_type)
  986:                 #entry[1].contentType == entry[1].content_type
  987: 
  988:                 if entry[1].meta_type == 'ECHO_collection':
  989:                     entry[1].patchContentType(entry[1])    
  990: 
  991:                 
  992:         return "Rerenderd all links to resources in: "+self.title
  993:     
  994:     def ECHO_newViewerLink(self,obj=None):
  995:         """change links (:86 faellt weg)"""
  996: 
  997:         if not obj:
  998:             obj = self
  999:             
 1000:         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection'])
 1001: 
 1002:         for entry in entries:
 1003:                 
 1004:                 if entry[1].meta_type == 'ECHO_resource':
 1005:                     
 1006:                     entry[1].link=re.sub('\:86','',entry[1].link)
 1007: 
 1008:                 else:
 1009:                     
 1010:                     entry[1].ECHO_newViewerLink(entry[1])
 1011:                 
 1012:         return "Rerenderd all links to resources in: "+self.title
 1013: 
 1014:     def __init__(self,id,title):
 1015:         """init"""
 1016:         self.id = id
 1017:         self.title=title
 1018: 
 1019:     def deleteSpace(self,str):
 1020:         """delete space at the end of a line"""
 1021:         if str[len(str)-1]==" ":
 1022:             return str[0:len(str)-1]
 1023:         else:
 1024:             return str
 1025:         
 1026:     
 1027: 
 1028:     # zusaetliche methoden fuer das vlp muessen in ein eigenes produkt
 1029: 
 1030:     def formatAscii(self,str,url=None):
 1031:         """ersetze ascii umbrueche durch <br>"""
 1032:         #url=None
 1033:         if url:
 1034:             
 1035:             retStr=""
 1036:             words=str.split("\n")
 1037:             
 1038:             for word in words:
 1039:                 strUrl=url%word
 1040:                 print "str",strUrl
 1041:                 retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)
 1042:             str=retStr
 1043:         if str:
 1044:             return re.sub(r"[\n]","<br/>",str)
 1045:         else:
 1046:             return ""
 1047:         
 1048:     def link2html(self,str):
 1049:         """link2html fuer VLP muss hier noch raus"""
 1050:         if str:
 1051:             print str
 1052:             str=re.sub("\&","&amp;",str)
 1053:             dom=xml.dom.minidom.parseString("<?xml version='1.0' ?><txt>"+str+"</txt>")
 1054:             links=dom.getElementsByTagName("link")
 1055:             
 1056:             print "link",links
 1057:             for link in links:
 1058:                 link.tagName="a"
 1059:                 ref=link.getAttribute("ref")
 1060:                 if self.checkRef(ref):
 1061:                     link.setAttribute("href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref)
 1062: 
 1063:             return dom.toxml('utf-8')
 1064:         return ""
 1065: 
 1066: 
 1067:     def checkRef(self,ref):
 1068:         dbs={'vl_literature':'AND CD LIKE \'%lise%\'','vl_technology':'','vl_people':''}
 1069:         res=None
 1070:         for db in dbs.keys():
 1071:             #print ref,"select reference from %s where reference =\'%s\' %s"%(db,ref,dbs[db])
 1072: 
 1073:             res=res or self.search(var=str("select reference from %s where reference =\'%s\' %s"%(db,ref,dbs[db])))
 1074:         return res
 1075:                                     
 1076:     #Ende Methode fuer vlp
 1077: 
 1078:     def PgQuoteString(self,string):
 1079:         """Quote string"""
 1080:         #print "PG",string
 1081:         return libpq.PgQuoteString(string)
 1082:         
 1083:     def getPartners(self):
 1084:         """Get list of Partners. Presently only from a subfolder partners"""
 1085:                     
 1086:         return [ item[1] for item in self.partners.ZopeFind(self.partners,obj_metatypes=['ECHO_partner'])]
 1087:                 
 1088:                 
 1089:                    
 1090: 
 1091:     
 1092:     def getPartnersXML(self):
 1093:         """partner liste als xml""" 
 1094:         partners=self.getPartners()
 1095:         ret="<partners>"
 1096:         for partner in partners:
 1097:             ret+="""<partner id="%s" title="%s"/>\n"""%(partner.getId(),partner.title)
 1098: 
 1099:         return ret+"\n</partners>"
 1100:     
 1101:     def getCollectionTree(self):
 1102:         """get the collection tree (list of triples (parent,child, depth)"""
 1103: 
 1104:         def getCollection(object,depth=0):
 1105:             depth+=1
 1106:             collections=[]
 1107:             for entry in object.__dict__.keys():
 1108:                 element=getattr(object,entry)
 1109:                 try:
 1110:                     if element.meta_type=="ECHO_collection":
 1111:                         collections.append((object,element,depth))
 1112:                         collections+=getCollection(element,depth)
 1113:                 except:
 1114:                     """nothing"""
 1115:             return collections
 1116:         
 1117: 
 1118:         return getCollection(self)
 1119:     
 1120:     def getCollectionTreeIds(self):
 1121:         """Show the IDs of the Tree"""
 1122:         ret=[]
 1123:         for collection in self.getCollectionTree():
 1124:             ret.append((collection[0].getId(),collection[1].getId(),collection[2]))
 1125:         return ret
 1126: 
 1127:         
 1128:         
 1129: def manage_addECHO_root(self,id,title,RESPONSE=None):
 1130:     """Add an ECHO_root"""
 1131:     self._setObject(id,ECHO_root(id,title))
 1132:     
 1133:     if RESPONSE is not None:
 1134:         RESPONSE.redirect('manage_main')
 1135: 
 1136: def manage_addECHO_rootForm(self):
 1137:         """Nothing yet"""
 1138:         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_root.zpt').__of__(self)
 1139:         return pt()
 1140:  
 1141: class ECHO_partner(Image,Persistent):
 1142:     """ECHO Partner"""
 1143: 
 1144:     meta_type="ECHO_partner"
 1145: 
 1146:     def __init__(self, id, title,url, file, content_type='', precondition=''):
 1147:         self.__name__=id
 1148:         self.title=title
 1149:         self.url=url
 1150:         self.precondition=precondition
 1151: 
 1152:         data, size = self._read_data(file)
 1153:         content_type=self._get_content_type(file, data, id, content_type)
 1154:         self.update_data(data, content_type, size)
 1155: 
 1156:     manage_options = Image.manage_options+(
 1157:         {'label':'Partner Information','action':'ECHO_partner_config'},
 1158:         )
 1159: 
 1160:     def changeECHO_partner(self,url,RESPONSE=None):
 1161:         """Change main information"""
 1162:         self.url=url
 1163:         if RESPONSE is not None:
 1164:             RESPONSE.redirect('manage_main')
 1165:             
 1166:             
 1167: 
 1168:     def ECHO_partner_config(self):
 1169:         """Main configuration"""
 1170:         if not hasattr(self,'url'):
 1171:             self.url=""
 1172:         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_partner.zpt').__of__(self)
 1173:         return pt()
 1174: 
 1175:         
 1176: manage_addECHO_partnerForm=DTMLFile('dtml/ECHO_partnerAdd',globals(),
 1177:                              Kind='ECHO_partner',kind='ECHO_partner')
 1178: 
 1179: 
 1180: 
 1181: def manage_addECHO_partner(self, id, file,url, title='', precondition='', content_type='',
 1182:                     REQUEST=None):
 1183:     """
 1184:     Add a new ECHO_partner object.
 1185: 
 1186:     Creates a new ECHO_partner object 'id' with the contents of 'file'.
 1187:     Based on Image.manage_addImage
 1188:     """
 1189: 
 1190:     id=str(id)
 1191:     title=str(title)
 1192:     content_type=str(content_type)
 1193:     precondition=str(precondition)
 1194: 
 1195:     id, title = OFS.Image.cookId(id, title, file)
 1196: 
 1197:     self=self.this()
 1198: 
 1199:     # First, we create the image without data:
 1200:     self._setObject(id, ECHO_partner(id,title,url,'',content_type, precondition))
 1201: 
 1202:     # Now we "upload" the data.  By doing this in two steps, we
 1203:     # can use a database trick to make the upload more efficient.
 1204:     if file:
 1205:         self._getOb(id).manage_upload(file)
 1206:     if content_type:
 1207:         self._getOb(id).content_type=content_type
 1208: 
 1209:     if REQUEST is not None:
 1210:         try:    url=self.DestinationURL()
 1211:         except: url=REQUEST['URL1']
 1212:         REQUEST.RESPONSE.redirect('%s/manage_main' % url)
 1213:     return id
 1214: 
 1215: 

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