File:  [Repository] / ECHO_content / ECHO_helpers.py
Revision 1.63: download - view: text, annotated - select for diffs - revision graph
Fri Oct 28 17:49:45 2005 UTC (18 years, 7 months ago) by dwinter
Branches: MAIN
CVS tags: HEAD
new metadata handling, getMDValue changed, getFieldValue depricated

    1: import re
    2: import string
    3: import socket
    4: import urllib
    5: import string
    6: import xml.dom.minidom
    7: import types
    8: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
    9: from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
   10: from OFS.SimpleItem import SimpleItem
   11: from Globals import package_home
   12: import Globals
   13: from AccessControl import ClassSecurityInfo
   14: import os.path
   15: from OFS.Folder import Folder
   16: import ECHO_collection
   17: 
   18: displayTypes = ['ZSQLExtendFolder','ZSQLBibliography','ECHO_group','ECHO_collection','ECHO_resource','ECHO_link','ECHO_sqlElement','ECHO_pageTemplate','ECHO_externalLink','ImageCollectionIFrame','VLP_resource','VLP_essay','ECHO_ZCatalogElement','ImageCollection','versionedFileFolder','ECHO_movie']
   19: 
   20: def content_html(self,type):
   21:         """template fuer content"""
   22:         #templates = self.ZopeFind(self.aq_parent,obj_ids=[type+"_template"])
   23:         #
   24:         #if templates:
   25:         #    return templates[0][1]()
   26: 
   27:         if hasattr(self,type+"_template"):
   28:             obj=getattr(self,type+"_template")
   29:             return obj()
   30:         else:
   31:             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ECHO_%s_template_standard.zpt'%type)).__of__(self)
   32:             pt.content_type="text/html"
   33:             return pt()
   34:     
   35:     
   36: 
   37: class ECHO_basis:
   38:     """basis eigenschaften fuer echo objekte"""
   39:     security=ClassSecurityInfo()
   40:     security.declarePublic('getImageTag')
   41: 
   42:     def manage_addECHO_locale(self,lang,title,label,text=None,content_type=None,RESPONSE=None):
   43:             return ECHO_collection.manage_addECHO_locale(self,lang,title,label)
   44:             
   45:     def getImageTag(self):
   46:             """sollte uerberschrieben werden, falls von der Klasse eine imagetag zurueckkommt"""
   47:             
   48:             return ""
   49:     
   50:     def showRDF(self):
   51:             """showrdf"""
   52:             self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
   53:             ret="""<?xml version="1.0" encoding="utf-8"?>\n<RDF:RDF xmlns:RDF="http://www.w3.org/1999/02/22-rdf-syntax-ns#"  xmlns:ECHONAVIGATION="http://www.echo.eu/rdf#">\n"""
   54: 
   55:             ret+=self.getRDF(urn="echo:collectionroot")+"\n"
   56: 
   57: 
   58:             ret+="""</RDF:RDF>"""
   59:             return ret 
   60: 
   61:   
   62:     def RDF(self):
   63:             """showrdf"""
   64:             self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
   65:             ret="""<?xml version="1.0" encoding="utf-8"?>\n<RDF:RDF xmlns:RDF="http://www.w3.org/1999/02/22-rdf-syntax-ns#"  xmlns:ECHONAVIGATION="http://www.echo.eu/rdf#">\n"""
   66: 
   67:             ret+=self.getRDF(urn=self.absolute_url())+"\n"
   68: 
   69: 
   70:             ret+="""</RDF:RDF>"""
   71:             return ret 
   72: 
   73:   
   74:     def createSubElementRDF(self,urn=None):
   75:             """rdf list"""
   76:             if not urn:
   77:                     urn=self.absolute_url()
   78:             ret=""
   79: 
   80:             rettemp="""<RDF:Seq RDF:about="%s">\n"""%urn
   81:             flag=0
   82:             
   83:             li="""<RDF:li RDF:resource="%s" />\n"""
   84:             if not ('<error>' in self.getFullTextXML(noredirect='Yes')):
   85:                     nurn=self.absolute_url()+'/getFullTextXML'
   86:                     rettemp+=li%nurn
   87:                     flag=1
   88:             if not ('<error>' in self.getImageView(noredirect='Yes')):
   89:                     nurn=self.absolute_url()+'/getImageView'
   90:                     rettemp+=li%nurn
   91:                     flag=1
   92: 
   93: 
   94:             if not ('<error>' in self.showMetaDataXML()):
   95:                     nurn=self.absolute_url()+'/showMetaDataXML'
   96:                     rettemp+=li%nurn
   97:                     flag=1
   98:                     
   99:             rettemp+="</RDF:Seq>"
  100: 
  101:             if flag==1:
  102:                     ret+=rettemp
  103:                     
  104:             if not ('<error>' in self.getFullTextXML(noredirect='Yes')):
  105:                     nurn=self.absolute_url()+'/getFullTextXML'  
  106:                     ret+=getRDFDescription(self,self.absolute_url()+'/getFullTextXML',urn=nurn,nameDef="Fulltext",typeName="ECHO_fulltext")
  107: 
  108:             if not ('<error>' in self.getImageView(noredirect='Yes')):
  109:                     nurn=self.absolute_url()+'/getImageView'
  110:                     ret+=getRDFDescription(self,self.absolute_url()+'/getImageView',urn=nurn,nameDef="Image View",typeName="ECHO_imageview")
  111:                     
  112:             if not ('<error>' in self.showMetaDataXML()):
  113:                     nurn=self.absolute_url()+'/showMetaDataXML'
  114:                     ret+=getRDFDescription(self,self.absolute_url()+'/showMetaDataXML',urn=nurn,nameDef="Metadata",typeName="ECHO_metaData")
  115: 
  116:             return ret
  117:             
  118:     def content_html(self,type="collection"):
  119:             """template fuer content bei einbau und ECHO_Umgebung"""
  120:             
  121:             return content_html(self,type)
  122:         
  123:     def getTitle(self):
  124:         """title"""
  125:         lang=self.getLanguage()
  126:         locale=None
  127:         if lang and not (lang =="de"):
  128:                 locale=self.ZopeFind(self,obj_ids=["locale_"+lang])
  129: 
  130:         if locale:
  131:                 return self.decode(locale[0][1].title)
  132:         else:
  133:                 return self.decode(self.title)
  134: 
  135: 
  136:         try:
  137:                 return self.title.encode('utf-8','ignore') 
  138:         except:
  139:                 self.title=self.title.decode('iso-8859-1','ignore')[0:] #correnct conding error
  140:                 return self.title.encode('utf-8','ignore') 
  141:         
  142:     def getLabel(self):
  143:         """title"""
  144:         lang=self.getLanguage()
  145:         locale=None
  146:         if lang and not (lang=="de"):
  147:                 locale=self.ZopeFind(self,obj_ids=["locale_"+lang])
  148: 
  149:         if locale:
  150:                 return self.decode(locale[0][1].label)
  151:         
  152: 
  153:         if not hasattr(self,'label'):
  154:                 self.label=""
  155:                 
  156:         if self.label=="":
  157:                 ret=self.getTitle()
  158:                 if ret=="":
  159:                         ret=self.getId()
  160:                 return ret
  161:         
  162:         return self.decode(self.label)
  163:         try:
  164:                 return self.label.encode('utf-8','ignore') 
  165:         except:
  166:                 self.label=self.label.decode('iso-8859-1','ignore')[0:] #correnct conding error
  167:                 return self.label.encode('utf-8','ignore') 
  168:         
  169:     
  170:     def changeECHOEntriesForm(self):
  171:         """change Entries for the ECHO Navigation environment"""
  172:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeECHOEntriesForm')).__of__(self)
  173:         return pt()
  174:     
  175:     def changeECHOEntries(self,label,weight,description,queryString,RESPONSE=None):
  176:         """change Entries for the ECHO Navigation environment
  177:         @param label: label fuer die Navigation"""
  178:         self.label=label
  179:         self.weight=weight
  180:         self.description=description
  181:         self.queryString=queryString
  182:         
  183:         if RESPONSE:
  184:             RESPONSE.redirect("manage_main")
  185: 
  186:     manage_options=({'label':'change ECHO Navigation Entries','action':'changeECHOEntriesForm'},)
  187: 
  188: 
  189:     def hasOverview(self):
  190:         """returns if there is an overview graphics"""
  191:         return hasattr(self, 'overview')
  192: 
  193:     def hasParentOverview(self):
  194:         """returns if the parent has an overview graphics"""
  195:         return hasattr(self.aq_parent, 'overview')
  196: 
  197:     def getOverview(self):
  198:         """map overview graphics"""
  199:         #return self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])[0][1]
  200:         if self.hasOverview():
  201:             return getattr(self, 'overview')
  202:         return None
  203: 
  204:     def getMapAreas(self):
  205:         """returns the list of MapAreas"""
  206:         forcetypes = self.REQUEST.get('map_force_types', None)
  207:         if forcetypes:
  208:             typelist = forcetypes.split(',')
  209:         else:
  210:             typelist = None
  211:         areas = []
  212:         # get all contained MapAreas
  213:         for res in self.ZopeFind(self, obj_metatypes=('MapArea')):
  214:             area = res[1]
  215:             # check the allowed types
  216:             if typelist is not None and area.getType() not in typelist:
  217:                 continue
  218:             areas.append(area)
  219:         return areas
  220: 
  221:     def addMapArea(self, newarea):
  222:         """add a map area to this object"""
  223:         if (newarea.id is None):
  224:             # create new id
  225:             ids = [a.id for a in self.getMapAreas()]
  226:             i = len(ids)
  227:             while ("a%02d"%i in ids):
  228:                 # if it exists, try the next one
  229:                 i += 1
  230:             newarea.id = "a%02d"%i
  231:         self._setObject(newarea.id, newarea)
  232: 
  233:     def getMapText(self):
  234:         """returns the MapText"""
  235:         # get (the first) contained MapText
  236:         #lang="en"
  237:         lang=self.getLanguage()
  238:         res=None
  239:         if lang and not (lang=="de"):
  240:                 resTmp = self.ZopeFind(self, obj_metatypes=('ECHO_mapText'))
  241:                 res = self.ZopeFind(resTmp[0][1])
  242: 
  243:         if not res:
  244:                 res = self.ZopeFind(self, obj_metatypes=('ECHO_mapText'))
  245:         if len(res) > 0:
  246:             text = res[0][1]
  247:             return text
  248:         return None
  249: 
  250:     def ECHO_graphicEntry(self):
  251:         """change map coordinates"""
  252:         if self.hasParentOverview():
  253:             pt=zptFile(self, 'zpt/ECHO_draw.zpt')
  254:             return pt()
  255:         else:
  256:             return "NO OVERVIEW GRAPHICS"
  257: 
  258:     def ECHO_addCoords(self,RESPONSE=None):
  259:         """change or add MapArea"""
  260:         #return self.REQUEST
  261:         # change existing areas
  262:         for area in self.getMapAreas():
  263:             id = area.getId()
  264:             if self.REQUEST.has_key('del.'+id):
  265:                 # delete this area
  266:                 self._delObject(id)
  267:                 # return to same menu
  268:                 if RESPONSE is not None:
  269:                     RESPONSE.redirect('ECHO_graphicEntry')
  270:                 return
  271:             # modify this area
  272:             coordstring = self.REQUEST.get('coords.'+id, '')
  273:             coords = string.split(coordstring, ',')
  274:             angle = self.REQUEST.get('angle.'+id, '0')
  275:             type = self.REQUEST.get('type.'+id, 'area')
  276:             permanent = self.REQUEST.get('permanent.'+id, '')
  277:             if len(coords) == 4:
  278:                 area.setCoordString(coordstring)
  279:                 area.setAngle(angle)
  280:                 area.setType(type)
  281:                 area.setPermanent(permanent)
  282:         # add the "new" area
  283:         if self.REQUEST.has_key('add'):
  284:             coordstring = self.REQUEST.get('coords.new', '')
  285:             coords = string.split(coordstring, ',')
  286:             angle = self.REQUEST.get('angle.new', '0')
  287:             type = self.REQUEST.get('type.new', 'area')
  288:             permanent = self.REQUEST.get('permanent.new', '')
  289:             if len(coords) == 4:
  290:                 coords.append(angle)
  291:                 area = MapArea(None, coords, type=type, permanent=permanent)
  292:                 self.addMapArea(area)
  293:         # return to edit area menu
  294:         if RESPONSE is not None:
  295:             RESPONSE.redirect('ECHO_graphicEntry')
  296: 
  297:     def createJSAreas(self, areas):
  298:         """create area calls for JavaScript"""
  299:         forceperm = self.REQUEST.get('map_force_permanent', None)
  300:         js="\n"
  301:         for ob in areas:
  302:             # check for force-permanent
  303:             if forceperm is not None:
  304:                 perm = forceperm
  305:             else:
  306:                 perm = ob.isPermanent()
  307:             js+="""addArea('%s', 'overview', %s, '%s', '%s');\n"""%(ob.getFullId(),ob.getCoordString(),ob.getType(),perm)
  308:         return js
  309: 
  310:     def createMapHead(self):
  311:         """create javascript include and script tags for head"""
  312:         pt=zptFile(self, 'zpt/ECHO_content_map_frag_js')
  313:         return pt()
  314: 
  315:     def createMapImg(self):
  316:         """generate img-tag for map"""
  317:         bt = BrowserCheck(self)
  318:         tag = ""
  319:         src = self.getOverview().absolute_url()
  320:         if bt.isN4:
  321:             # N4 needs ilayer to create an id
  322:             tag += '<ilayer id="overview" visibility="show"><img src="%s"></ilayer>'%src
  323:         else:
  324:             # img with id
  325:             tag += '<img id="overview" src="%s" />'%src
  326:         return tag
  327:         
  328:     def createParentMapImg(self):
  329:         """generate img-tag for map of parent"""
  330:         return self.aq_parent.createMapImg()
  331: 
  332:     def createMapLink(self, ob, text=None, target="_blank"):
  333:         """generate map link"""
  334:         bt = BrowserCheck(self)
  335:         id = ob.getFullId()
  336:         link = ob.getLinkId()
  337:         if text is None:
  338:             text = ob.getLabel()
  339:         if text is None:
  340:             text = "link"
  341:         tiptext = ob.getTip()
  342:         tag = ""
  343:         if bt.isN4:
  344:             # N4 needs layer for highlighting
  345:             tag += '<ilayer id="a.%s"><a class="maplink" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="%s"'%(id,id,id,link,target)
  346:             tag += ">" + text + "</a></ilayer>"
  347:         else:
  348:             # a-element
  349:             tag = '<a id="a.%s" class="maplink" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="%s"'%(id,id,id,link,target)
  350:             if tiptext:
  351:                 tag += ' title="%s"'%tiptext
  352:             tag += ">" + text + "</a>"
  353:         return tag
  354: 
  355:     def createMapAux(self, ob, arrowsrc="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?dw=15&fn=icons/pfeil", circlesrc="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?dw=15&fn=icons/kreis", target="_blank",backLink=None,alternativArrowsrc="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?dw=15&fn=icons/pfeil_blau"):
  356:         """generate map link image, text and other stuff"""
  357:         bt = BrowserCheck(self)
  358:         id = ob.getFullId()
  359:         link = ob.getLinkId()
  360:         tiptext = ob.getTip()
  361:         tag = ""
  362: 
  363:         if bt.isN4:
  364:             #
  365:             # N4 needs layer and img elements
  366:             #
  367:             tag += '<layer id="i.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)">'%(id,id,id)
  368:             if ob.isTypeArrow():
  369:                 # N4 - Arrow
  370:                 rot = ob.angle
  371:                 
  372:                 if hasattr(getattr(self,link),'link'):
  373:                         cLink=getattr(self,link).link
  374:                         # if existing delete virtuell path 
  375:                         cLink=cLink.replace('/'.join(self.REQUEST['VirtualRootPhysicalPath']),'')
  376: 
  377:                 if backLink and hasattr(getattr(self,link),'link') and backLink==self.REQUEST['SERVER_URL']+cLink.lstrip():
  378:                         marksrc=alternativArrowsrc
  379:                 else:
  380:                         marksrc = arrowsrc
  381: 
  382:                 
  383:                 if float(rot) < 0:
  384:                     marksrc = circlesrc
  385:                 tag += '<a href="%s"><img border="0" src="%s&rot=%s" /></a>'%(link,marksrc,rot)
  386:             elif ob.isTypeText():
  387:                 # N4 - Text
  388:                 tag += '<div id="t.%s" class="maptext"'%(id)
  389:                 tag += 'style="visibility:hidden">'
  390:                 tag += ob.getText()
  391:                 tag += '</div>'
  392:             else:
  393:                 # N4 - Area
  394:                 tag += '<a href="%s"><img border="0" width="1000" height="1000" src="trans_img"'%(link)
  395:                 if tiptext:
  396:                     tag += ' alt="%s"'%tiptext
  397:                 tag += ' /></a>'
  398:             tag += '</layer>'
  399:         else:
  400:             #
  401:             # (more or less) DOM capable browser
  402:             #
  403:             tag = '<a id="b.%s" class="mapmarklink" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="%s">'%(id,id,id,link,target)
  404:             if ob.isTypeArrow():
  405:                 # DOM - Arrow
  406:                 rot = ob.angle
  407:                                 
  408:                 if hasattr(getattr(self,link),'link'):
  409:                         cLink=getattr(self,link).link
  410:                         # if existing delete virtuell path 
  411:                         if hasattr(self.REQUEST,'VirtualRootPhysicalPath'):
  412:                             cLink=cLink.replace('/'.join(self.REQUEST['VirtualRootPhysicalPath']),'')
  413: 
  414:                 if backLink and hasattr(getattr(self,link),'link') and backLink==self.REQUEST['SERVER_URL']+cLink.lstrip():
  415:                         marksrc=alternativArrowsrc
  416:                 else:
  417:                         marksrc = arrowsrc
  418: 
  419:                 try:
  420:                    rot=float(rot)
  421:                 except:
  422:                    rot=0
  423: 
  424:                 if float(rot) < 0:
  425:                     marksrc = circlesrc
  426:                 if bt.isIEWin and bt.versIE > 5:
  427:                     # IE/Win 5.5 has "feature" for PNG transparency
  428:                     tag += '<span id="i.%s" style="position:absolute; top:-100px; left:-100px; border-style:none; border-width=1px; filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(src=\'%s&rot=%s\');"><img style="visibility:hidden" src="%s&rot=%s" /></span>'%(id,marksrc,rot,marksrc,rot)
  429:                 else:
  430:                     # arrow image
  431:                     tag += '<img id="i.%s" src="%s&rot=%s" border="1" style="position:absolute; top:-100px; left:-100px; border-style:none;" />'%(id,marksrc,rot)
  432:             elif ob.isTypeText():
  433:                 # DOM - Text
  434:                 tag += '<div id="i.%s" style="position:absolute; top:-100px; left:-100px;"'%(id)
  435:                 tag += '><div id="t.%s" class="maptext"'%(id)
  436:                 tag += 'style="visibility:hidden">'
  437:                 tag += ob.getText()
  438:                 tag += '</div></div>'
  439:             else:
  440:                 # DOM - Area
  441:                 if bt.isIE:
  442:                     # IE needs transparent img for area
  443:                     tag += '<img id="i.%s" border="0" style="position:absolute; top:-100px; left:-100px;" src="trans_img"'%(id)
  444:                     if tiptext:
  445:                         tag += ' title="%s"'%tiptext
  446:                     tag += " />"
  447:                 else:
  448:                     # empty div for area
  449:                     tag += '<div id="i.%s" style="position:absolute; top:-100px; left:-100px;"'%(id)
  450:                     if tiptext:
  451:                         tag += ' title="%s"'%tiptext
  452:                     tag += '> </div>'
  453:             tag += '</a>'
  454:         return tag
  455: 
  456: 
  457:     #ende der echo erweiterungen
  458: 
  459: 
  460: def toList(field):
  461:     """Einzelfeld in Liste umwandeln"""
  462:     if type(field)==types.StringType:
  463:         return [field]
  464:     else:
  465:         return field
  466: 
  467: def getText(nodelist):
  468:     rc = ""
  469:     for node in nodelist:
  470:         if node.nodeType == node.TEXT_NODE:
  471:            rc = rc + node.data
  472:     return rc
  473: 
  474: def getTextFromNode(nodename):
  475:     nodelist=nodename.childNodes
  476:     rc = ""
  477:     for node in nodelist:
  478:         if node.nodeType == node.TEXT_NODE:
  479:            rc = rc + node.data
  480:     return rc
  481: 
  482: 
  483: def readFieldFromXML(meta_url,parent,field):
  484:         """lesespezifisches metadatum"""
  485:         
  486:         try:
  487:                 dom=xml.dom.minidom.parse(meta_url)
  488: 
  489:         except:
  490:                 try:
  491:                         fh=urllib.urlopen(meta_url)
  492:                         dom=xml.dom.minidom.parse(fh)
  493:                 except:
  494:                         return None
  495:         if not dom: return None
  496: 
  497:         parent=dom.getElementsByTagName(parent)
  498:         if not parent: return None
  499: 
  500:         field=parent[0].getElementsByTagName(field)
  501: 
  502:         if not field: return None
  503: 
  504:         return getText(field[0].childNodes)
  505:         
  506:         
  507:               
  508: def urlopen(url):
  509:         """urlopen mit timeout"""
  510:         socket.setdefaulttimeout(2)
  511:         ret=urllib.urlopen(url)
  512:         socket.setdefaulttimeout(5)
  513:         return ret
  514: #       urlopener = urllib.URLopener()
  515: #
  516: #       try:            
  517: #               con = urlopener.open(url)
  518: #               return con
  519: #       except timeoutsocket.Timeout:
  520: #               return None
  521: 
  522: 
  523: 
  524: 
  525: 
  526: def checkOnlyOneInGroup(object): 
  527:         """check if object is a group and if it containt only one element it return this element"""
  528:         displayedObjects=object.ZopeFind(object,obj_metatypes=displayTypes)
  529:         if len(displayedObjects)==1: # nur ein Object dann redirect auf dieses Object
  530: 
  531:                 return displayedObjects[0][1]
  532:         else:           return object
  533: 
  534: def getSubCols(self, sortfield=None, subColTypes=displayTypes, sortFieldMD=None,searchMD=None,generic="yes"):
  535:         
  536:         def sort(x,y):
  537:                 return cmp(x[0],y[0])
  538:         
  539:         def sortfnc(sortfield,x,y):
  540:                 try:
  541:                         xa=x[1].getMDValue(sortfield,generic=generic)
  542:                 except:
  543:                         xa=""
  544:                 try:
  545:                         ya=y[1].getMDValue(sortfield,generic=generic)
  546:                 except:
  547:                         ya=""
  548:                 return cmp(xa,ya)
  549:         
  550:         sortWithMD = lambda sortfield : (lambda x,y : sortfnc(sortfield,x,y))
  551:         ids=[]
  552:         displayedObjects=self.ZopeFind(self,obj_metatypes=subColTypes)
  553: 
  554:         
  555:         
  556:         for entry in displayedObjects:
  557: 
  558:                         
  559:                 object=entry[1]
  560:                 if searchMD and hasattr(object,'getMDValue'):
  561:                         flag=0
  562:                         for field in searchMD.keys():
  563:                                 if object.getMDValue(field,generic=generic)==searchMD[field]:
  564:                                         flag=1
  565:                                 else:
  566:                                         flag=0
  567:                                         break
  568:                         if flag==1:
  569:                                 ids.append(object)
  570:                 else:
  571:                         ids.append(object)
  572: 
  573:         if not sortfield:
  574:             sortfield=getattr(self,'sortfield','weight')
  575: 
  576:             
  577:         tmplist=[]
  578: 
  579:         for x in ids:
  580:                 
  581:                 if hasattr(x,sortfield):
  582:                         try:
  583:                                 tmp=int(getattr(x,sortfield))
  584:                         except:
  585:                                 tmp=getattr(x,sortfield)
  586:                                 
  587:                 else:
  588:                         tmp=10000000
  589:                         
  590:                 tmplist.append((tmp,x))
  591: 
  592:         if not sortFieldMD:
  593:                 tmplist.sort(sort)
  594:         else:
  595:                 tmplist.sort(sortWithMD(sortFieldMD))
  596:         
  597:         return [x for (key,x) in tmplist]
  598: 
  599: def ECHO_rerenderLinksMD(self,obj=None,types=['title','label']):
  600:         """Rerender all Links"""
  601:         ret=""
  602:         
  603:         if not obj:
  604:             obj = self
  605:             
  606:         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource'],search_sub=1)
  607: 
  608:         for entry in entries:
  609:                 if entry[1].meta_type == 'ECHO_resource':
  610:                         try:
  611:                                 entry[1].ECHO_getResourceMD(template="no")
  612:                                 if "title" in types:
  613:                                     entry[1].generate_title()
  614:                                 if "label" in types:
  615:                                     entry[1].generate_label()
  616:                                 ret+="OK:"+entry[0]+"-- "+entry[1].getTitle().decode('utf-8')+"-- "+entry[1].getTitle().decode('utf-8')+"<br>"
  617:                         except:
  618:                                 ret+="Error:"+entry[0]+"<br>"
  619: 
  620:                 
  621:                 
  622:                 
  623:         return "<html><body>"+ret+"Rerenderd all links to resources in: "+self.title+"</html></body>"
  624: 
  625: def reloadMetaDataFromStorage(self,RESPONSE=None):
  626:             """copy metadata from the storage to ECHO"""
  627:             ret=""
  628:             resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
  629:             if RESPONSE is not None:
  630:                 RESPONSE.setHeader("Content-Type", type)
  631:                 RESPONSE.write("<html><body>\n")
  632:                 
  633:             for resource in resources:
  634:                     x=str(resource[1].copyIndex_meta2echo_resource())+"<br>"
  635:                     if RESPONSE is not None:
  636:                         RESPONSE.write(x+"\n")
  637:                     
  638:                     ret+=x
  639: 
  640:             if RESPONSE is not None:
  641:                     #RESPONSE.redirect('./manage_main')
  642:                     RESPONSE.write( "</html></body>")
  643: 
  644:             return ret
  645:     
  646: def getRDFDescription(self,linkURL,urn=None,nameDef=None,typeName=None):
  647:             """rdf"""
  648:             
  649:             ret=""
  650:             about="""<RDF:Description RDF:about="%s">"""
  651:             name="""<ECHONAVIGATION:name>%s</ECHONAVIGATION:name>"""
  652:             link="""<ECHONAVIGATION:link xlink:href="%s">%s</ECHONAVIGATION:link>"""
  653:             clickable="""<ECHONAVIGATION:linkClickable>%s</ECHONAVIGATION:linkClickable>"""
  654:             #link="""<ECHONAVIGATION:link RDF:about="%s"/>"""
  655:             type="""<ECHONAVIGATION:type>%s</ECHONAVIGATION:type>"""
  656:             #xlink="""<ECHONAVIGATION:xlink xlink:href="%s"/>"""        
  657:             if not urn:
  658:                     #urn="urn:"+re.sub('/',':',self.absolute_url())
  659:                     urn=self.absolute_url()
  660:             about2=about%urn
  661:             if not nameDef:
  662:                     if hasattr(self,'label') and not (self.label==""):
  663:                             name2=name%self.label
  664:                     elif not self.title=="":
  665:                             name2=name%self.title
  666:                     else:
  667:                             name2=name%self.getId()
  668: 
  669:                     name2=re.sub('&','&amp;',name2)
  670:             else:
  671:                     name2=name%nameDef
  672: 
  673:             linkURL=re.sub('http:','',linkURL)
  674:             linkURL2=re.sub('&','&amp;',linkURL)
  675:             link2=link%(("http:"+linkURL2),("http:"+urllib.quote(linkURL)))
  676:             clickable2=clickable%"true"
  677: 
  678:             if not typeName:
  679:                     type2=type%self.meta_type
  680:             else:
  681:                     type2=type%typeName
  682:             
  683:             #ret=about2+"\n"+name2+"\n"+link2+"\n"+type2+"\n"+clickable2+"\n</RDF:Description>"
  684:             ret=about2+"\n"+name2+"\n"+type2+"\n"+clickable2+"\n</RDF:Description>"
  685:             return ret
  686:     
  687: def getCopyrightsFromForm(self,argv): 
  688:         medias={}
  689:         partners={}
  690:         copyrights={}
  691:         
  692:         copyrightsFinal=[]
  693:         for arg in argv.keys():
  694:                 
  695:                 if arg[0:5]=='media':
  696:                         nm=int(arg[5:])
  697:                         medias[nm]=argv[arg]
  698:                 elif arg[0:5]=='partn':
  699:                         nm=int(arg[5:])
  700:                         partners[nm]=argv[arg]
  701:                 elif arg[0:5]=='copyr':
  702:                         nm=int(arg[5:])
  703:                         copyrights[nm]=argv[arg]
  704: 
  705: 
  706: 
  707:         copyrightsList=[(medias[nm],partners[nm],copyrights[nm]) for nm in medias.keys()]
  708:         for copyright in copyrightsList:
  709:                 
  710:                 if copyright[2]=='institution0000':
  711:                         copyrightsFinal.append((copyright[0],copyright[1],self.getPartnerCopyright(copyright[1],'')))
  712:                 else:
  713:                         if not copyright[0]=='':
  714:                                 copyrightsFinal.append(copyright)
  715:                 
  716:                         
  717:         return copyrightsFinal
  718: 
  719: #List of different types for the graphical linking viewer
  720: viewClassificationListMaster=['view point','area']
  721: 
  722: 
  723: def checkDiffs(self,metadict):
  724:             """check differences"""
  725: 
  726:             
  727: 
  728:     
  729:             def NoneToEmpty(obj):
  730:                     if obj:
  731:                             return obj
  732:                     else:
  733:                             return ""
  734: 
  735:             
  736:             
  737:             diffs={}
  738:             
  739:             tags=self.findTagsFromMapping(self.contentType)
  740:             self.referencetypes=tags[2]
  741:             self.fields=tags[3]
  742:             
  743:     
  744:             for field in tags[1]:
  745:                     try:
  746:                             if (NoneToEmpty(self.getMDValue(self.getFieldTag(tags,field)))==metadict[self.getFieldTag(tags,field)]):
  747:                                     diffs[self.getFieldTag(tags,field)]=1
  748:                             else:
  749:                                     
  750:                                     diffs[self.getFieldTag(tags,field)]=0
  751:                     except:
  752:                             diffs[self.getFieldTag(tags,field)]=0
  753:                             
  754:             return diffs
  755:     
  756: 
  757: def zptFile(self, path, orphaned=False):
  758:     """returns a page template file from the product"""
  759:     if orphaned:
  760:         # unusual case
  761:         pt=PageTemplateFile(os.path.join(package_home(globals()), path))
  762:     else:
  763:         pt=PageTemplateFile(os.path.join(package_home(globals()), path)).__of__(self)
  764:     return pt
  765: 
  766: 
  767: def findObjectPath(startobject, filename):
  768:     """returns the object with the name filename starting at startobject"""
  769:     if startobject is None:
  770:         return None
  771:     paths = filename.split('/')
  772:     object = startobject
  773:     for path in paths:
  774:             
  775:         if hasattr(object, path):
  776:             object = getattr(object, path)
  777:         else:
  778:             object = None
  779:             break
  780:     return object
  781: 
  782: 
  783: def zptObjectOrFile(self, filename, localdir='zpt', orphaned=False):
  784:     """returns a page template instance or a file from the product"""
  785:     # look for an object called path
  786:     pt = findObjectPath(self, filename)
  787:     # the object should also not be a python function
  788:     if (pt is None) or isinstance(pt, types.FunctionType):
  789:         # get a ZPT file
  790:         pt = zptFile(self, localdir+'/'+filename, orphaned=orphaned)
  791:     return pt
  792: 
  793: 
  794: def sendFile(self, filename, type):
  795:     """sends an object or a local file (in the product) as response"""
  796:     # look for an object called filename
  797:     object = findObjectPath(self, filename)
  798:     if object:
  799:         # if the object exists then send it
  800:         return object.index_html(self.REQUEST.REQUEST, self.REQUEST.RESPONSE)
  801:     else:
  802:         # send a local file with the given content-type
  803:         fn = os.path.join(package_home(globals()), filename)
  804:         self.REQUEST.RESPONSE.setHeader("Content-Type", type)
  805:         self.REQUEST.RESPONSE.write(file(fn).read())
  806:     return
  807: 
  808: 
  809: class BrowserCheck:
  810:     """check the browsers request to find out the browser type"""
  811:     
  812:     def __init__(self, zope):
  813:         """initialisiere"""
  814:         self.ua = zope.REQUEST.get_header("HTTP_USER_AGENT")
  815:         self.isN4 = False
  816:         self.isIE = False
  817:         if string.find(self.ua, 'MSIE') > -1:
  818:             self.isIE = True
  819:         else:
  820:             self.isN4 = string.find(self.ua, 'Mozilla/4.') > -1
  821:         try:
  822:             self.nav = self.ua[string.find(self.ua, '('):]
  823:             ie = string.split(self.nav, "; ")[1]
  824:             if string.find(ie, "MSIE") > -1:
  825:                 self.versIE = string.split(ie, " ")[1]
  826:         except: pass
  827:         self.isMac = string.find(self.ua, 'Macintosh') > -1
  828:         self.isWin = string.find(self.ua, 'Windows') > -1
  829:         self.isIEWin = self.isIE and self.isWin
  830:         self.isIEMac = self.isIE and self.isMac
  831: 
  832:                 
  833: def writeMetadata(url,metadict,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None,xmlfrag=None,digiliburlprefix=None):
  834:         """Einlesen der Metadaten und und erstellen des geaenderten XML file"""
  835: 
  836:         def updateTextToolNode(tag,value):
  837: 
  838:                 metanode=dom.getElementsByTagName('texttool')[0]
  839:                 try:
  840:                         nodeOld=metanode.getElementsByTagName(tag)
  841:                 except:
  842:                         nodeOld=None
  843:                         
  844:                 if nodeOld:
  845:                         metanode.removeChild(nodeOld[0]).unlink()
  846: 
  847:                 node=dom.createElement(tag)
  848:                 nodetext=dom.createTextNode(value)
  849:                 node.appendChild(nodetext)
  850:                 metanode.appendChild(node)
  851: 
  852:         if xmlfrag:
  853:                 geturl="""<?xml version="1.0" ?>
  854:                            <resource type="MPIWG">
  855:                            <meta>
  856:                             <bib type="Book">
  857:                             </bib>
  858:                             </meta>
  859:                             </resource>"""
  860:                 dom=xml.dom.minidom.parseString(geturl)
  861:         else:
  862:                 try:
  863:                         geturl=""
  864:                         for line in urlopen(url).readlines():
  865:                                 geturl=geturl+line
  866: 
  867: 
  868:                 except:
  869:                         return (None,"XCannot open: "+url)
  870: 
  871:                 try:
  872:                         dom=xml.dom.minidom.parseString(geturl)
  873:                 except:
  874:                         return (None,"Cannot parse: "+url+"<br>"+geturl)
  875: 
  876:         
  877: 
  878:         metanodes=dom.getElementsByTagName('bib')
  879: 
  880:         if not metanodes:
  881:                 metanodes=dom.getElementsByTagName('archimedes')
  882: 
  883:         metanode=metanodes[0]
  884: 
  885:         for metaData in metadict.keys():
  886:                 
  887:                 try:
  888:                         nodeOld=metanode.getElementsByTagName(metaData)
  889:                 except:
  890:                         nodeOld=None
  891:                         
  892:                 if nodeOld:
  893:                         metanode.removeChild(nodeOld[0]).unlink()
  894:                 else:
  895:                         # try also old writing rule - instead of _:
  896:                         try:
  897:                                 nodeOld=metanode.getElementsByTagName(re.sub('_','-',metaData))
  898:                         except:
  899:                                 nodeOld=None
  900:                                 
  901:                         if nodeOld:
  902:                                 metanode.removeChild(nodeOld[0]).unlink()
  903: 
  904:                 metanodeneu=dom.createElement(metaData)
  905:                 metanodetext=dom.createTextNode(metadict[metaData])
  906:                 #try:
  907:                         #metanodetext=dom.createTextNode(unicode(metadict[metaData],"utf-8"))
  908:                 #except:
  909:                         #metanodetext=dom.createTextNode(metadict[metaData].encode('utf-8'))
  910:                 metanodeneu.appendChild(metanodetext)
  911:                 metanode.appendChild(metanodeneu)
  912: 
  913: 
  914:         
  915:         
  916:         
  917:         if project:
  918:                 updateTextToolNode('project',project)
  919: 
  920:         if startpage:
  921:                 updateTextToolNode('startpage',startpage)
  922: 
  923:         if topbar:
  924:                 updateTextToolNode('toptemplate',topbar)
  925: 
  926:         if thumbtemplate:
  927:                 updateTextToolNode('thumbtemplate',thumbtemplate)
  928: 
  929:         if xslt:
  930:                 updateTextToolNode('xslt',xslt)
  931: 
  932:         
  933:         if digiliburlprefix:
  934:                 updateTextToolNode('digiliburlprefix',digiliburlprefix)
  935:         
  936:         try:    
  937:          return dom.toxml().encode('utf-8')
  938:         except:
  939:          return dom.toxml('utf-8')
  940: 
  941:         
  942:         
  943: def readMetadata(url):
  944:     """Methode zum Auslesen der Metadateninformation zu einer Resource
  945:     Vorerst noch Typ bib"""
  946:     
  947:     metadict={}
  948:     
  949:     try:
  950:         geturl=""
  951:         for line in urlopen(url).readlines():
  952:             geturl=geturl+line
  953:         
  954:         
  955:     except:
  956:         return (None,"Cannot open: "+url)
  957: 
  958:     try:
  959:         dom=xml.dom.minidom.parseString(geturl)
  960:     except:
  961:             return (None,"Cannot parse: "+url+"<br>"+geturl)
  962: 
  963:     metanode=dom.getElementsByTagName('bib')
  964:     metadict['bib_type']='Book'
  965:     if len(metanode)==0:
  966:         metanode=dom.getElementsByTagName('archimedes')
  967:         metadict['bib_type']='Archimedes'
  968:         
  969:         
  970:     if not len(metanode)==0:    
  971:         metacontent=metanode[0].childNodes
  972:     
  973:         try:
  974:             metadict['bib_type']=getText(dom.getElementsByTagName('bib')[0].attributes['type'].childNodes)
  975:         except:
  976:             """nothing"""
  977:         
  978:         for node in metacontent:
  979:                 try:
  980:                         #print urllib.unquote(getText(node.childNodes)),getText(node.childNodes)
  981:                         #metadict[re.sub('-','_',node.tagName.lower())]=urllib.unquote(getText(node.childNodes))
  982:                         metadict[re.sub('-','_',node.tagName.lower())]=getText(node.childNodes)
  983:                 
  984:                 except:
  985:                         """nothing"""
  986: 
  987: 
  988:     return metadict,""
  989:     
  990: 
  991: class MapArea(SimpleItem):
  992:     """simple class to hold coordinates"""
  993: 
  994:     meta_type = 'MapArea'
  995:     # Create a SecurityInfo for this class.
  996:     security = ClassSecurityInfo()
  997:     security.setDefaultAccess("allow")
  998:     # type constants
  999:     TYPE_AREA = 'area'
 1000:     TYPE_ARROW = 'arrow'
 1001:     TYPE_TEXT = 'text'
 1002:         
 1003:     def __init__(self, id, coords, label=None, type=None, tip=None, permanent=False):
 1004:         """init"""
 1005:         self.coords = coords[0:4]
 1006:         if len(coords) > 4:
 1007:             self.angle = coords[4]
 1008:         else:
 1009:             self.angle = 0
 1010:         self.id = id
 1011:         self.label = label
 1012:         self.setType(type)
 1013:         self.tip = tip
 1014:         self.permanent = permanent
 1015: 
 1016:     def setCoords(self, coords):
 1017:         """sets the coords"""
 1018:         self.coords = coords
 1019: 
 1020:     def getCoordString(self):
 1021:         """returns coordinates as a string"""
 1022:         return string.join(self.coords, ',')
 1023: 
 1024:     def setCoordString(self, coordstring):
 1025:         """sets coordinates from a string"""
 1026:         coords = string.split(coordstring, ',')
 1027:         self.coords = [c.strip() for c in coords]
 1028: 
 1029:     def getFullId(self, prefix=None):
 1030:         """returns the id with prefixed parent id"""
 1031:         if prefix is None:
 1032:             if hasattr(self, 'aq_parent'):
 1033:                 prefix = self.aq_parent.id
 1034:             else:
 1035:                 prefix = "id"
 1036:         fid = prefix + "." + self.id
 1037:         return fid
 1038: 
 1039:     def getType(self):
 1040:         """returns the type"""
 1041:         return self.type
 1042: 
 1043:     def setType(self, type):
 1044:         """sets the type"""
 1045:         if type == MapArea.TYPE_ARROW:
 1046:             self.type = MapArea.TYPE_ARROW
 1047:         elif type == MapArea.TYPE_AREA:
 1048:             self.type = MapArea.TYPE_AREA
 1049:         elif type == MapArea.TYPE_TEXT:
 1050:             self.type = MapArea.TYPE_TEXT
 1051:         else:
 1052:             self.type = MapArea.TYPE_AREA
 1053:             
 1054:     def isTypeArea(self):
 1055:         """returns if the type is area"""
 1056:         return self.type == MapArea.TYPE_AREA
 1057: 
 1058:     def isTypeArrow(self):
 1059:         """returns if the type is arrow"""
 1060:         return self.type == MapArea.TYPE_ARROW
 1061: 
 1062:     def isTypeText(self):
 1063:         """returns if the type is text"""
 1064:         return self.type == MapArea.TYPE_TEXT
 1065: 
 1066:     def getAngle(self):
 1067:         """returns the angle"""
 1068:         return self.angle
 1069: 
 1070:     def setAngle(self, angle):
 1071:         """sets the angle"""
 1072:         self.angle = angle
 1073: 
 1074:     def getTip(self):
 1075:         """returns the popup text"""
 1076:         # patch old version
 1077:         if not hasattr(self, 'tip'):
 1078:             self.tip = self.text
 1079: 
 1080:         if self.tip is None:
 1081:             if hasattr(self, 'aq_parent'):
 1082:                 parent = self.aq_parent
 1083:                 if parent.contentType == 'text-popup':
 1084:                     return parent.description
 1085:         return self.tip
 1086: 
 1087:     def setTip(self, text):
 1088:         """sets the text"""
 1089:         self.tiptext = text
 1090: 
 1091:     def getText(self):
 1092:         """returns the text fpr the area"""
 1093:         if hasattr(self, 'aq_parent'):
 1094:             parent = self.aq_parent
 1095:             text = parent.getMapText()
 1096:             if text is not None:
 1097:                 return text.document_src()
 1098:         return ""
 1099: 
 1100:     def getLabel(self):
 1101:         """returns the link label"""
 1102:         if self.label is None:
 1103:             if hasattr(self, 'aq_parent'):
 1104:                 return self.aq_parent.label or self.aq_parent.id
 1105:         return self.label
 1106: 
 1107:     def setLabel(self, label):
 1108:         """sets the label"""
 1109:         self.label = label
 1110: 
 1111:     def isPermanent(self):
 1112:         """returns the permanent state"""
 1113:         # patch old objects
 1114:         if not hasattr(self, 'permanent'):
 1115:             self.permanent = False
 1116:         return self.permanent
 1117: 
 1118:     def setPermanent(self, state):
 1119:         """sets the permanent state"""
 1120:         if state:
 1121:             self.permanent = True
 1122:         else:
 1123:             self.permanent = False
 1124: 
 1125:     def getLinkId(self):
 1126:         if hasattr(self, 'aq_parent'):
 1127:             return self.aq_parent.id
 1128:         return self.id
 1129: 
 1130: # call this to initialize framework classes, which
 1131: # does the right thing with the security assertions.
 1132: Globals.InitializeClass(MapArea)
 1133: 
 1134: 
 1135: class MapText(Folder,ZopePageTemplate):
 1136:     """class to hold text for map areas"""
 1137: 
 1138:     meta_type = 'ECHO_mapText'
 1139:     # Create a SecurityInfo for this class.
 1140:     security = ClassSecurityInfo()
 1141:     security.setDefaultAccess("allow")
 1142: 
 1143:     
 1144:     _default_content_fn = os.path.join(package_home(globals()),
 1145:                                        'html', 'ECHO_mapText_default.html')
 1146: 
 1147:     def __init__(self, id, text=None, content_type=None):
 1148:         self.id = str(id)
 1149:         self.ZBindings_edit(self._default_bindings)
 1150:         if text is None:
 1151:             text = open(self._default_content_fn).read()
 1152:         self.pt_edit(text, content_type)
 1153: 
 1154:     def createLocale(self):
 1155:             """create locale"""
 1156:             return ECHO_collection.manage_addECHO_localeForm(self)
 1157: 
 1158:     manage_main=ZopePageTemplate.pt_editForm
 1159: 
 1160:     def manage_addECHO_locale(self,lang,title,label,text=None,content_type=None,RESPONSE=None):
 1161:             """manage add echo locale in map"""
 1162:             ECHO_collection.manage_addECHO_locale(self,lang,title,label,text,content_type)
 1163:             if RESPONSE is not None:
 1164:                         RESPONSE.redirect('manage_main')
 1165: 
 1166: 
 1167:     def changeLocale(self):
 1168:            """change locale"""
 1169:            return self.locale_en.change_ECHO_localeForm()
 1170: 
 1171:     def change_ECHO_locale(self,lang,title,label,text=None,content_type=None,RESPONSE=None):
 1172:                 """change echo locale"""
 1173: 
 1174:                 obj= self.locale_en.change_ECHO_locale(lang,title,label,text,content_type,RESPONSE)
 1175:         
 1176: 
 1177: 
 1178:                 if RESPONSE is not None:
 1179:                         RESPONSE.redirect('manage_main')
 1180: 
 1181:                 
 1182: # Product registration and Add support
 1183: manage_addMapTextForm = PageTemplateFile(
 1184:     'zpt/AddECHO_mapText', globals(), __name__='manage_addMapTextForm')
 1185: 
 1186: def manage_addMapText(self, id, title=None, text=None,
 1187:                            REQUEST=None, submit=None):
 1188:     "Add a Map Text with optional file content."
 1189: 
 1190:     id = str(id)
 1191:     if REQUEST is None:
 1192:         self._setObject(id, MapText(id, text))
 1193:         ob = getattr(self, id)
 1194:         if title:
 1195:             ob.pt_setTitle(title)
 1196:         return ob
 1197:     else:
 1198:         file = REQUEST.form.get('file')
 1199:         headers = getattr(file, 'headers', None)
 1200:         if headers is None or not file.filename:
 1201:             zpt = MapText(id, text)
 1202:         else:
 1203:             zpt = MapText(id, file, headers.get('content_type'))
 1204: 
 1205:         self._setObject(id, zpt)
 1206:         if title:
 1207:             ob = getattr(self, id)
 1208:             ob.pt_setTitle(title)
 1209: 
 1210:         try:
 1211:             u = self.DestinationURL()
 1212:         except AttributeError:
 1213:             u = REQUEST['URL1']
 1214: 
 1215:         if submit == " Add and Edit ":
 1216:             u = "%s/%s" % (u, urllib.quote(id))
 1217:         REQUEST.RESPONSE.redirect(u+'/manage_main')
 1218:     return ''
 1219: 
 1220: # call this to initialize framework classes, which
 1221: # does the right thing with the security assertions.
 1222: Globals.InitializeClass(MapText)

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