File:  [Repository] / ECHO_content / ECHO_collection.py
Revision 1.45: download - view: text, annotated - select for diffs - revision graph
Fri Apr 16 15:42:52 2004 UTC (20 years, 1 month ago) by dwinter
Branches: MAIN
CVS tags: HEAD
xml import for links implemented

    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,label,"","","",link,"","")
  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:             dynamical+="""Coords.push(new Coord('%s', Img, %s));\n"""%(ob[1],ob[0])
  601:         ret+=javaHandler%dynamical
  602:         return ret
  603:     
  604:     security.declarePublic('getCreditObject')
  605:     def getCreditObject(self,name):
  606:         """credit id to credititem"""
  607:         try:
  608:             return getattr(self.partners,name)
  609:         except:
  610:             return ""
  611: 
  612:     security.declarePublic('ECHO_generateNavBar')
  613:     def ECHO_generateNavBar(self):
  614:         """Erzeuge Navigationsbar"""
  615:         link=""
  616:         object="self"
  617:         ret=[]
  618:         path=self.getPhysicalPath()
  619:         for element in path:
  620:             
  621:            
  622:             if not element=="":
  623:                 object+="."+element
  624:                 
  625:                 label=eval(object).label
  626:                 link+="/"+element
  627:                 if not label=="":
  628:                     ret.append((label,link))
  629:         return ret
  630:     
  631:     security.declarePublic('ECHO_rerenderLinksMD')
  632:     def ECHO_rerenderLinksMD(self):
  633:         """Rerender all Links"""
  634:         
  635:         for entry in self.__dict__.keys():
  636:             object=getattr(self,entry)
  637:             
  638:             
  639:             try:
  640:                 
  641:                 if object.meta_type == 'ECHO_resource':
  642:                     
  643:                     object.ECHO_getResourceMD(template="no")
  644:                     
  645:             except:
  646:                 """nothing"""
  647:                 
  648:         return "Rerenderd all links to resources in: "+self.title
  649: 
  650:     security.declarePublic('ECHO_newViewerLink')
  651:     
  652: 
  653:     def getCoords(self):
  654:         try:
  655:             
  656:             x=  [string.join(x,",") for x in self.coords]  
  657:             return x
  658: 
  659:         except:
  660: 
  661:             return []
  662:         
  663:     def __init__(self,id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle,secondaryLink,imageTag="",bgcolour=""):
  664:         #print "CO",coords
  665: 
  666:         self.id = id
  667:         """Festlegen der ID"""
  668:         self.credits=toList(credits)
  669:         self.label = label
  670:         self.title=title
  671:         self.description=description
  672:         self.contentType=contentType
  673:         self.responsible=responsible
  674:         self.imageTag=imageTag
  675:         self.weight=weight
  676:         self.sortfield=sortfield
  677:         coordsnew=[ string.split(x,",") for x in coords]
  678:         self.coords=coordsnew
  679:         self.secondaryLinkTitle=secondaryLinkTitle
  680:         self.secondaryLink=secondaryLink
  681: 	self.bgcolour=bgcolour
  682:         
  683: 
  684:     manage_options = Folder.manage_options+(
  685:         {'label':'Main Config','action':'ECHO_collection_config'},
  686:         {'label':'Rerender Links','action':'ECHO_rerenderLinksMD'},
  687:         {'label':'Graphics','action':'ECHO_graphicEntry'},
  688: 	{'label':'create resources from XML','action':'createRessourcesFromXMLForm'},
  689: 
  690:         )
  691: 
  692:     def getOverview(self):
  693:         """overview graphics"""
  694:         
  695:         return self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])[0][1]
  696:     
  697:     
  698:     def ECHO_graphicEntry(self):
  699:         """DO nothing"""
  700:         overview = self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])
  701:         
  702:     
  703:         if overview:
  704:             pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_draw.zpt').__of__(self)
  705:             return pt()
  706:         else:
  707:             return "NO OVERVIEW GRAPHICS"
  708: 
  709:     def ECHO_enterCoords(self,coordstr,angle="",RESPONSE=None):
  710:         """Enter coords"""
  711:         coords=self.coords
  712:         temco=coordstr.split(",")
  713:         temco.append(angle)
  714:         coords.append(temco)
  715:         self.coords=coords[0:]
  716: 
  717:         if RESPONSE is not None:
  718:             RESPONSE.redirect('ECHO_graphicEntry')
  719: 
  720:     
  721:     security.declarePublic('ECHO_collection_config')
  722:     def ECHO_collection_config(self):
  723:         """Main configuration"""
  724: 
  725:         if not hasattr(self,'weight'):
  726:             self.weight=""
  727: 
  728:         if not hasattr(self,'sortfield'):
  729:             self.sortfield="weight"
  730:   
  731:         if not hasattr(self,'coords'):
  732:             self.coords=[]
  733: 
  734:         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_collection.zpt').__of__(self)
  735:         return pt()
  736: 
  737: 
  738:     security.declarePublic('changeECHO_collection')
  739: 
  740: 
  741:     def getBgcolour(self):
  742: 	    """colour"""
  743: 	    if hasattr(self,'bgcolour') and not (self.bgcolour==""):
  744: 		    return self.bgcolour
  745: 	    else:
  746: 		    return "#dddddd"
  747: 	    
  748:     def changeECHO_collection(self,title,label,description,contentType,responsible,weight,secondaryLink,secondaryLinkTitle,credits=None,sortfield="weight",coords=None,RESPONSE=None,imageTag="",bgcolour=""):
  749:         """Änderung der Properties"""
  750: 
  751:         self.secondaryLink=secondaryLink
  752:         self.secondaryLinkTitle=secondaryLinkTitle
  753:         self.imageTag=imageTag
  754: 	self.bgcolour=bgcolour
  755: 	
  756:         if coords:
  757:             coordsnew=[ string.split(x,",") for x in coords]
  758:             self.coords=coordsnew[0:]
  759:         else:
  760:             coordsnew=None
  761:             self.coords=None
  762:             
  763:         setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)
  764: 	try:
  765: 		self.coords=coordsnew[0:] # HACK fehler in setECHO_collection
  766:         except:
  767: 		"""none"""
  768: 		
  769:         self.sortfield=sortfield
  770: 
  771:         if RESPONSE is not None:
  772:             RESPONSE.redirect('manage_main')
  773:             
  774:     security.declarePublic('index_html')
  775: 
  776: 
  777:     def showOverview(self):
  778:         """overview"""
  779:         if 'ECHO_overview.html' in self.__dict__.keys():
  780:             return getattr(self,'ECHO_overview.html')()
  781:         pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_content_overview.zpt').__of__(self)
  782:         return pt()
  783: 
  784:     
  785:     def index_html(self):
  786:         """standard page"""
  787:         
  788:         if 'index.html' in self.__dict__.keys():
  789:             return getattr(self,'index.html')()
  790:         
  791:         elif 'overview' in self.__dict__.keys():
  792:             return self.showOverview()
  793:         elif hasattr(self,'collection_index_template'):
  794:             return self.collection_index_template()    
  795:         
  796:         pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_content_standard.zpt').__of__(self)
  797:         pt.content_type="text/html"
  798:         return pt()
  799: 
  800:     def content_html(self):
  801:         """template fuer content"""
  802:         return content_html(self,'collection')
  803:     
  804:     def getCredits(self):
  805:         """Ausgabe der credits"""
  806:         if self.credits:
  807:             return self.credits
  808:         else:
  809:             return []
  810: 
  811: 
  812:         
  813:     def getGraphicCoords(self):
  814:         """Give list of coordinates"""
  815:         subColTypes=['ECHO_collection','ECHO_externalLink','ECHO_resource']
  816:         ids=[]
  817:         for entry in self.__dict__.keys():
  818:             object=getattr(self,entry)
  819:             try:
  820:                 if object.meta_type in subColTypes:
  821:                     for coordtemp in object.coords:
  822:                         if len(coordtemp)>3:
  823:                             coord=coordtemp[0:4]
  824:                             if hasattr(object,'label') and not object.label=="":
  825:                                 ids.append([string.join(coord,", "),object.getId(),object.label,object])
  826:                             elif hasattr(object,'title'):
  827:                                 if not object.title=="":
  828:                                     ids.append([string.join(coord,", "),object.getId(),object.title,object])
  829:                                 else:
  830:                                     ids.append([string.join(coord,", "),object.getId(),object.getId(),object])
  831:                             else:
  832:                                 ids.append([string.join(coord,", "),object.getId(),object.getId(),object])
  833:                     
  834:             except:
  835:                 """nothing"""
  836: 
  837:         return ids
  838:     
  839: 
  840: 
  841: 
  842:     getSubCols = ECHO_helpers.getSubCols
  843:      
  844:                 
  845:     
  846:     
  847: def manage_addECHO_collectionForm(self):
  848:         """Add collection form"""
  849:         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_collectionForm.zpt').__of__(self)
  850:         return pt()
  851: 
  852: 
  853: def manage_addECHO_collection(self,id,title,label,description,contentType,responsible,weight,sortfield,coords="",secondaryLinkTitle="",secondaryLink="",credits=None,RESPONSE=None,imageTag="",bgcolour=""):
  854:     """add a echo collection"""
  855:     
  856: 
  857:     newObj=ECHO_collection(id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle=secondaryLinkTitle,secondaryLink=secondaryLink,imageTag=imageTag,bgcolour="")
  858: 
  859:     self._setObject(id,newObj)
  860: 
  861:     if RESPONSE is not None:
  862:         RESPONSE.redirect('manage_main')
  863: 
  864: class ECHO_group(ECHO_collection):
  865: 	"""ECHO Gruppe"""
  866: 	meta_type="ECHO_group"
  867: 
  868: 	manage_options = Folder.manage_options+(
  869: 		{'label':'Main Config','action':'ECHO_group_config'},
  870: 		{'label':'Rerender Links','action':'ECHO_rerenderLinksMD'},
  871: 		{'label':'Graphics','action':'ECHO_graphicEntry'},
  872: 		)
  873: 	def ECHO_group_config(self):
  874: 		"""Main configuration"""
  875: 		
  876: 		if not hasattr(self,'weight'):
  877: 			self.weight=""
  878: 			
  879: 		if not hasattr(self,'sortfield'):
  880: 			self.sortfield="weight"
  881: 				
  882: 		if not hasattr(self,'coords'):
  883: 			self.coords=[]
  884: 
  885: 		pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_group.zpt').__of__(self)
  886: 		return pt()
  887: 
  888: 	def changeECHO_group(self,title,label,description,contentType,responsible,weight,secondaryLink,secondaryLinkTitle,credits=None,sortfield="weight",coords=None,RESPONSE=None,imageTag="",bgcolour="",logo=""):
  889: 		"""Änderung der Properties"""
  890: 
  891: 		self.secondaryLink=secondaryLink
  892: 		self.secondaryLinkTitle=secondaryLinkTitle
  893: 		self.imageTag=imageTag
  894: 		self.bgcolour=bgcolour
  895:                 self.logo=logo
  896:                 
  897: 		if coords:
  898: 		    coordsnew=[ string.split(x,",") for x in coords]
  899: 		    self.coords=coordsnew[0:]
  900: 		else:
  901: 		    coordsnew=None
  902: 		    self.coords=None
  903: 
  904: 		setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)
  905: 
  906: 
  907: 
  908: 		self.sortfield=sortfield
  909: 
  910: 		if RESPONSE is not None:
  911: 		    RESPONSE.redirect('manage_main')
  912: 
  913: 	def getLogo(self):    
  914: 		"""logo ausgeben"""
  915:                 try:
  916:                     return self.logo
  917:                 except:
  918:                     return "ECHO_groups"
  919: 
  920: 	def content_html(self):
  921: 		"""template fuer content"""
  922: 		return content_html(self,'group')
  923:     
  924: 
  925: 
  926: def manage_addECHO_groupForm(self):
  927:         """Add group form"""
  928:         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_groupForm.zpt').__of__(self)
  929:         return pt()
  930: 
  931: 
  932: def manage_addECHO_group(self,id,title,label,description,contentType,responsible,weight,sortfield,coords="",secondaryLinkTitle="",secondaryLink="",credits=None,RESPONSE=None,imageTag="",bgcolour="",logo=""):
  933:     """add a echo group"""
  934:     
  935: 
  936:     newObj=ECHO_group(id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle=secondaryLinkTitle,secondaryLink=secondaryLink,imageTag=imageTag,bgcolour="")
  937: 
  938:     setattr(newObj,'logo',logo)
  939:     self._setObject(id,newObj)
  940:     
  941:     if RESPONSE is not None:
  942:         RESPONSE.redirect('manage_main')
  943: 
  944: 
  945: 	
  946: class ECHO_root(Folder,Persistent,Implicit):
  947:     """ECHO Root Folder"""
  948:     meta_type="ECHO_root"
  949: 
  950:     def getBgcolour(self):
  951: 	"""hack"""
  952: 	return "#dddddd"
  953: 
  954:     def contentTypeSelector_HTML(self,selected=None):
  955:         """give type selector"""
  956:         if not selected:
  957:             retStr="<option selected>\n"
  958:         else:
  959:             retStr="<option>\n"
  960:             
  961:         try:
  962:             for contentType in self.ZopeFind(self.contentTypes,obj_metatypes="ECHO_contentType"):
  963:                 if selected and (contentType[0]==selected):
  964:                     retStr+="""<option selected value="%s">%s\n"""%(contentType[0],contentType[0])
  965:                 else:                
  966:                     retStr+="""<option value="%s">%s\n"""%(contentType[0],contentType[0])
  967:         except:
  968:             """nothing"""
  969:         return retStr
  970:             
  971:     def patchContentType(self,obj=None):
  972:         """austauschen content_type with contentType (patch bei umstieg von alter Version)"""
  973:     
  974: 
  975:         if not obj:
  976:             obj = self
  977:             
  978:         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_externalLink','ECHO_pageTemplate'])
  979: 
  980:         for entry in entries:
  981:                 setattr(entry[1],'contentType',entry[1].content_type)
  982:                 #entry[1].contentType == entry[1].content_type
  983: 
  984:                 if entry[1].meta_type == 'ECHO_collection':
  985:                     entry[1].patchContentType(entry[1])    
  986: 
  987:                 
  988:         return "Rerenderd all links to resources in: "+self.title
  989:     
  990:     def ECHO_newViewerLink(self,obj=None):
  991:         """change links (:86 faellt weg)"""
  992: 
  993:         if not obj:
  994:             obj = self
  995:             
  996:         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection'])
  997: 
  998:         for entry in entries:
  999:                 
 1000:                 if entry[1].meta_type == 'ECHO_resource':
 1001:                     
 1002:                     entry[1].link=re.sub('\:86','',entry[1].link)
 1003: 
 1004:                 else:
 1005:                     
 1006:                     entry[1].ECHO_newViewerLink(entry[1])
 1007:                 
 1008:         return "Rerenderd all links to resources in: "+self.title
 1009: 
 1010:     def __init__(self,id,title):
 1011:         """init"""
 1012:         self.id = id
 1013:         self.title=title
 1014: 
 1015:     def deleteSpace(self,str):
 1016:         """delete space at the end of a line"""
 1017:         if str[len(str)-1]==" ":
 1018:             return str[0:len(str)-1]
 1019:         else:
 1020:             return str
 1021:         
 1022:     
 1023: 
 1024:     # zusaetliche methoden fuer das vlp muessen in ein eigenes produkt
 1025: 
 1026:     def formatAscii(self,str,url=None):
 1027:         """ersetze ascii umbrueche durch <br>"""
 1028:         #url=None
 1029:         if url:
 1030:             
 1031:             retStr=""
 1032:             words=str.split("\n")
 1033:             
 1034:             for word in words:
 1035:                 strUrl=url%word
 1036:                 print "str",strUrl
 1037:                 retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)
 1038:             str=retStr
 1039:         if str:
 1040:             return re.sub(r"[\n]","<br/>",str)
 1041:         else:
 1042:             return ""
 1043:         
 1044:     def link2html(self,str):
 1045:         """link2html fuer VLP muss hier noch raus"""
 1046:         if str:
 1047:             print str
 1048:             str=re.sub("\&","&amp;",str)
 1049:             dom=xml.dom.minidom.parseString("<?xml version='1.0' ?><txt>"+str+"</txt>")
 1050:             links=dom.getElementsByTagName("link")
 1051:             
 1052:             print "link",links
 1053:             for link in links:
 1054:                 link.tagName="a"
 1055:                 ref=link.getAttribute("ref")
 1056:                 if self.checkRef(ref):
 1057:                     link.setAttribute("href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref)
 1058: 
 1059:             return dom.toxml('utf-8')
 1060:         return ""
 1061: 
 1062: 
 1063:     def checkRef(self,ref):
 1064:         dbs={'vl_literature':'AND CD LIKE \'%lise%\'','vl_technology':'','vl_people':''}
 1065:         res=None
 1066:         for db in dbs.keys():
 1067:             #print ref,"select reference from %s where reference =\'%s\' %s"%(db,ref,dbs[db])
 1068: 
 1069:             res=res or self.search(var=str("select reference from %s where reference =\'%s\' %s"%(db,ref,dbs[db])))
 1070:         return res
 1071:                                     
 1072:     #Ende Methode fuer vlp
 1073: 
 1074:     def PgQuoteString(self,string):
 1075:         """Quote string"""
 1076:         #print "PG",string
 1077:         return libpq.PgQuoteString(string)
 1078:         
 1079:     def getPartners(self):
 1080:         """Get list of Partners. Presently only from a subfolder partners"""
 1081:                     
 1082:         return [ item[1] for item in self.partners.ZopeFind(self.partners,obj_metatypes=['ECHO_partner'])]
 1083:                 
 1084:                 
 1085:                    
 1086: 
 1087:     
 1088:     def getPartnersXML(self):
 1089:         """partner liste als xml""" 
 1090:         partners=self.getPartners()
 1091:         ret="<partners>"
 1092:         for partner in partners:
 1093:             ret+="""<partner id="%s" title="%s"/>\n"""%(partner.getId(),partner.title)
 1094: 
 1095:         return ret+"\n</partners>"
 1096:     
 1097:     def getCollectionTree(self):
 1098:         """get the collection tree (list of triples (parent,child, depth)"""
 1099: 
 1100:         def getCollection(object,depth=0):
 1101:             depth+=1
 1102:             collections=[]
 1103:             for entry in object.__dict__.keys():
 1104:                 element=getattr(object,entry)
 1105:                 try:
 1106:                     if element.meta_type=="ECHO_collection":
 1107:                         collections.append((object,element,depth))
 1108:                         collections+=getCollection(element,depth)
 1109:                 except:
 1110:                     """nothing"""
 1111:             return collections
 1112:         
 1113: 
 1114:         return getCollection(self)
 1115:     
 1116:     def getCollectionTreeIds(self):
 1117:         """Show the IDs of the Tree"""
 1118:         ret=[]
 1119:         for collection in self.getCollectionTree():
 1120:             ret.append((collection[0].getId(),collection[1].getId(),collection[2]))
 1121:         return ret
 1122: 
 1123:         
 1124:         
 1125: def manage_addECHO_root(self,id,title,RESPONSE=None):
 1126:     """Add an ECHO_root"""
 1127:     self._setObject(id,ECHO_root(id,title))
 1128:     
 1129:     if RESPONSE is not None:
 1130:         RESPONSE.redirect('manage_main')
 1131: 
 1132: def manage_addECHO_rootForm(self):
 1133:         """Nothing yet"""
 1134:         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_root.zpt').__of__(self)
 1135:         return pt()
 1136:  
 1137: class ECHO_partner(Image,Persistent):
 1138:     """ECHO Partner"""
 1139: 
 1140:     meta_type="ECHO_partner"
 1141: 
 1142:     def __init__(self, id, title,url, file, content_type='', precondition=''):
 1143:         self.__name__=id
 1144:         self.title=title
 1145:         self.url=url
 1146:         self.precondition=precondition
 1147: 
 1148:         data, size = self._read_data(file)
 1149:         content_type=self._get_content_type(file, data, id, content_type)
 1150:         self.update_data(data, content_type, size)
 1151: 
 1152:     manage_options = Image.manage_options+(
 1153:         {'label':'Partner Information','action':'ECHO_partner_config'},
 1154:         )
 1155: 
 1156:     def changeECHO_partner(self,url,RESPONSE=None):
 1157:         """Change main information"""
 1158:         self.url=url
 1159:         if RESPONSE is not None:
 1160:             RESPONSE.redirect('manage_main')
 1161:             
 1162:             
 1163: 
 1164:     def ECHO_partner_config(self):
 1165:         """Main configuration"""
 1166:         if not hasattr(self,'url'):
 1167:             self.url=""
 1168:         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_partner.zpt').__of__(self)
 1169:         return pt()
 1170: 
 1171:         
 1172: manage_addECHO_partnerForm=DTMLFile('dtml/ECHO_partnerAdd',globals(),
 1173:                              Kind='ECHO_partner',kind='ECHO_partner')
 1174: 
 1175: 
 1176: 
 1177: def manage_addECHO_partner(self, id, file,url, title='', precondition='', content_type='',
 1178:                     REQUEST=None):
 1179:     """
 1180:     Add a new ECHO_partner object.
 1181: 
 1182:     Creates a new ECHO_partner object 'id' with the contents of 'file'.
 1183:     Based on Image.manage_addImage
 1184:     """
 1185: 
 1186:     id=str(id)
 1187:     title=str(title)
 1188:     content_type=str(content_type)
 1189:     precondition=str(precondition)
 1190: 
 1191:     id, title = OFS.Image.cookId(id, title, file)
 1192: 
 1193:     self=self.this()
 1194: 
 1195:     # First, we create the image without data:
 1196:     self._setObject(id, ECHO_partner(id,title,url,'',content_type, precondition))
 1197: 
 1198:     # Now we "upload" the data.  By doing this in two steps, we
 1199:     # can use a database trick to make the upload more efficient.
 1200:     if file:
 1201:         self._getOb(id).manage_upload(file)
 1202:     if content_type:
 1203:         self._getOb(id).content_type=content_type
 1204: 
 1205:     if REQUEST is not None:
 1206:         try:    url=self.DestinationURL()
 1207:         except: url=REQUEST['URL1']
 1208:         REQUEST.RESPONSE.redirect('%s/manage_main' % url)
 1209:     return id
 1210: 
 1211: 

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