1: """This contains the class MPIWG Projects
2: for organizing and maintaining the different project pages
3:
4: $author dwinter - last change 26.06.2008
5:
6: """
7: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
8: from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
9: from Products.ZCatalog.CatalogPathAwareness import CatalogAware
10: from Products.MPIWGBibliography.BibliographyManager import BibliographyManager
11: from OFS.Image import Image
12: from Globals import package_home
13: import urllib
14: import re
15: import os
16: from types import *
17: import logging
18: import xmlhelper # Methoden zur Verwaltung der projekt xml
19: from OFS.SimpleItem import SimpleItem
20: from OFS.Folder import Folder
21:
22: from AccessControl import ClassSecurityInfo
23: from bibliography import *
24: import time
25: #import xml.dom.minidom
26: import sys
27: #from Ft.Xml.XPath import Evaluate
28: #from Ft.Xml.XPath.Context import Context
29: #from Ft.Xml.Domlette import NonvalidatingReader,PrettyPrint, Print
30: #from Ft.Xml import EMPTY_NAMESPACE
31: #import copy
32: #import updatePersonalWWW
33:
34: #import MPIWGStaff
35:
36: from MPIWGHelper import *
37:
38: import MPIWGRoot
39: import MPIWGLink
40: import MPIWGTemplate
41:
42: # die folgenden Klassen sind jetzt in einzelne Files ausgelagert aus KompatibilitŠtsgrŸnden, bleiben die Klassen hier noch drin.
43: # Sonst funktionieren die alten Webseiten nicht mehr.
44:
45: class MPIWGRoot(MPIWGRoot.MPIWGRoot):
46: """depricated"""
47:
48: class MPIWGLink(MPIWGLink.MPIWGLink):
49: """depricated"""
50:
51: class MPIWGTemplate(MPIWGTemplate.MPIWGTemplate):
52: """depricated"""
53:
54: class MPIWGProject_publication(SimpleItem):
55: """publications object fuer project"""
56:
57: meta_type="MPIWGProject_publication"
58:
59: def editPublication(self,text=None,RESPONSE=None):
60: """edit a publication"""
61:
62: if (not text):
63: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_publicationForm.zpt')).__of__(self)
64: return pt()
65:
66:
67: self.text=text[0:]
68:
69: if RESPONSE:
70: RESPONSE.redirect("../managePublications")
71:
72: class MPIWGProject_image(Image):
73: """Images for Projects"""
74:
75: meta_type="MPIWGProject_image"
76:
77: def showImage(self,imageUrl=None):
78: """show Images at an extra page"""
79: self.getContent('WEB_project_description',filter='yes') #get the content and store image infos into session
80: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','projectImageView.zpt')).__of__(self)
81: return pt()
82:
83: def editImage(self,file=None,caption=None,RESPONSE=None):
84: """edit the Image"""
85: if (not file) and (not caption):
86: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_imageForm.zpt')).__of__(self)
87: return pt()
88:
89: if file and (not file.filename.lstrip().rstrip()==""):
90: self.manage_upload(file)
91:
92: if caption:
93: self.caption=caption[0:]
94:
95: if RESPONSE:
96: RESPONSE.redirect("../manageImages")
97:
98: class MPIWGProject(CatalogAware,Folder):
99: """Class for Projects"""
100:
101:
102: security=ClassSecurityInfo()
103: meta_type='MPIWGProject'
104: default_catalog='ProjectCatalog'
105:
106: def decode(self,str):
107: """return unicode object"""
108: return unicodify(str)
109:
110: def sortedByPlace(self,metatype):
111: """find metatype and sort by place"""
112: def sort(x,y):
113: return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))
114:
115: founds=self.ZopeFind(self,obj_metatypes=[metatype]);
116:
117: founds.sort(sort)
118:
119: return founds
120:
121:
122: def copyPublicationsToList(self,RESPONSE=None):
123: """copy publications in to list"""
124:
125: publicationTxt=self.getContent('WEB_related_pub')
126:
127: pubSplits=publicationTxt.split("<p>")
128:
129: for pubSplit in pubSplits:
130: pubSplit=pubSplit.replace("</p>","")
131: self.addPublication(pubSplit)
132:
133: if RESPONSE:
134: RESPONSE.redirect('managePublications')
135:
136:
137: def copyImageToMargin(self,RESPONSE=None):
138: """copy inline images to marginal images"""
139:
140:
141: #getImages from WEB_project_description
142: description=self.getContent('WEB_project_description')
143:
144: text2=description
145: splitted=text2.split("""<p class="picture">""")
146:
147: imageURLs=[]
148: imageCaptions=[]
149: for split in splitted[1:]:
150: tmp=split.split("</p>")
151: #return repr(splitted[1])
152:
153: try:
154: imageURLs.append(tmp[0].split("\"")[1].encode('utf-8'))
155: except:
156:
157: try:
158: imageURLs.append(tmp[0].split("src=")[1].split(" ")[0].encode('utf-8'))
159: except:
160: imageURLs.append("")
161:
162: split2="</p>".join(tmp[1:])
163:
164:
165: splitted=split2.split("""<p class="picturetitle">""")
166: if len(splitted)>1:
167: tmp=splitted[1].split("</p>")
168: imageCaptions.append(tmp[0].encode('utf-8'))
169:
170:
171: else:
172: #keine caption
173:
174: imageCaptions.append("")
175:
176:
177: #eintragen:
178: for imageURL in imageURLs:
179: filename=imageURL.split("/")[-1]
180: #lege neues images object an, mit leerem bild
181:
182: if self.ZopeFind(self,obj_ids=[filename]):
183: #existiert das bild schon, dann neuen filenamen
184: filename="project_image_"+filename
185:
186: self.addImage(None,imageCaptions[imageURLs.index(imageURL)],filename=filename)
187: #hole die bilddaten aus der url
188: url=self.absolute_url()+"/"+imageURL
189: #url=self.absolute_url()+"/"+filename
190:
191: try:#relative url
192: data=urllib.urlopen(url).read()
193: except:
194: try:#absolute
195: data=urllib.urlopen(self.imageURL).read()
196: except:
197: logger("MPIWG Project",logging.ERROR,"can't open: %s"%url)
198:
199: obj=getattr(self,filename)
200: obj.update_data(data)
201:
202: if RESPONSE:
203: RESPONSE.redirect('manageImages')
204:
205: def manageImages(self,imageName=None,op=None):
206: """managage images"""
207:
208:
209: if imageName and op:
210: if op=='up':
211: images=self.getImages()
212: for image in images:
213: if image[0]==imageName:
214: nr=images.index(image)
215: if not nr==0:
216: images[nr-1][1].place+=1
217: images[nr][1].place-=1
218: pass
219: elif op=='down':
220: images=self.getImages()
221: for image in images:
222: if image[0]==imageName:
223: nr=images.index(image)
224: if not (nr==len(images)-1):
225: images[nr+1][1].place-=1
226: images[nr][1].place+=1
227: pass
228:
229:
230: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_manageImagesForm.zpt')).__of__(self)
231: return pt()
232:
233: def managePublications(self,pubName=None,op=None):
234: """managage images"""
235:
236:
237: if pubName and op:
238: if op=='up':
239: publications=self.getPublications()
240: for publication in publications:
241: if publication[0]==pubName:
242: nr=publications.index(publication)
243: if not nr==0:
244: publications[nr-1][1].place+=1
245: publications[nr][1].place-=1
246: pass
247: elif op=='down':
248: publications=self.getPublications()
249: for publication in publications:
250: if publication[0]==pubName:
251: nr=publications.index(publication)
252: if not (nr==len(publications)-1):
253: publications[nr+1][1].place-=1
254: publications[nr][1].place+=1
255: pass
256:
257:
258: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_managePublicationsForm.zpt')).__of__(self)
259: return pt()
260: def hasExtendedPublicationList(self):
261: """test if extended publication list exists"""
262: if not hasattr(self,"publicationList"):
263: return False
264: else:
265: return True
266:
267: def createExtendedPublicationList(self,RESPONSE=None):
268: """erzeuge erweiterte publications liste"""
269: pl = BibliographyManager("publicationList","","institutsbiblio",self.connection_id)
270: self._setObject("publicationList", pl)
271:
272:
273: zt=ZopePageTemplate('index.html')
274: pl._setObject('index.html',zt)
275: default_content_fn = os.path.join(package_home(globals()),
276: 'zpt/showExtendedProjectBibliography.zpt')
277: text = open(default_content_fn).read()
278: zt.pt_edit(text, 'text/html')
279:
280:
281: if RESPONSE:
282: RESPONSE.redirect("managePublications")
283:
284: def getPublications(self):
285: """get all Publications"""
286: def sort_images(x,y):
287: return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))
288:
289: publications=self.ZopeFind(self,obj_metatypes=['MPIWGProject_publication'])
290:
291: publications.sort(sort_images)
292: return publications
293:
294: def addPublication(self,text,RESPONSE=None):
295: """add an MPIWG_Publication"""
296:
297: name="publication_"+str(self.getLastPublicationNumber()+1)
298:
299: newPublication=MPIWGProject_publication(name)
300:
301: self._setObject(name,newPublication)
302: obj=getattr(self,name)
303: obj.text=text[0:]
304: obj.enabled=True;
305: obj.place=self.getLastPublicationNumber()+1
306: obj.id=name
307:
308: if RESPONSE is not None:
309: RESPONSE.redirect('managePublications')
310:
311:
312: def getLastPublicationNumber(self):
313: publications=self.getPublications()
314:
315: if not publications:
316: return 0
317: else:
318: return getattr(publications[-1][1],'place',0)
319:
320: def deletePublication(self,id,RESPONSE=None):
321: """delete Publication id"""
322: self.manage_delObjects([id])
323: if RESPONSE:
324: RESPONSE.redirect('managePublications')
325:
326: def getImages(self):
327: """get all Images"""
328:
329: def sort_images(x,y):
330: return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))
331:
332:
333: if (getattr(self,'imageURL','')!='') or (getattr(self,'imagecap','')!='') :
334: try:
335: self.addImage(None,getattr(self,'imagecap',''),RESPONSE=None,filename=getattr(self,'imageURL',''))
336: except:
337: pass
338: self.imageURL=''
339: self.imagecap=''
340:
341: images=self.ZopeFind(self,obj_metatypes=['MPIWGProject_image'])
342:
343: images.sort(sort_images)
344: return images
345:
346: def getLastImageNumber(self):
347: images=self.getImages()
348:
349: if not images:
350: return 0
351: else:
352: return getattr(images[-1][1],'place',0)
353:
354: def deleteImage(self,id,RESPONSE=None):
355: """delete Image id"""
356: self.manage_delObjects([id])
357: if RESPONSE:
358: RESPONSE.redirect('manageImages')
359:
360:
361: def hasChildren(self,date=None,onlyActive=1,onlyArchived=1):
362: """check if project has children"""
363: ct=self.getContexts(childs=self.getContent('xdata_05'),
364: depth=1,date=date,onlyActive=onlyActive)
365:
366: if ct and len(ct)>0:
367: return True
368: else:
369: return False
370:
371:
372: def addImage(self,fileHd,caption,RESPONSE=None,filename=None):
373: """add an MPIWG_Project_image"""
374:
375: if not filename:
376: filename=fileHd.filename
377:
378: if not fileHd:
379: fileHd=file(os.path.join(package_home(globals()),'blank.gif'))
380:
381: newImage=MPIWGProject_image(filename,filename,fileHd)
382:
383: self._setObject(filename,newImage)
384: obj=getattr(self,filename)
385: obj.caption=caption[0:]
386: obj.enabled=True;
387: obj.place=self.getLastImageNumber()+1
388: obj.id=filename
389:
390: if RESPONSE is not None:
391: RESPONSE.redirect('manageImages')
392:
393: def PrincipiaSearchSource(self):
394: """Return cataloguable key for ourselves."""
395: return str(self)
396:
397: def versionHeader(self):
398: """version Header, gibt header text entsprechend der aktuellen version aus"""
399:
400: actualTime=time.localtime()
401: retTXT="""<h2>This is an outdated version, for the actual version please refer to <a href="%s">%s</a></h2>"""
402: s=self.aq_parent.absolute_url()
403: #print getattr(self,'archiveTime',actualTime)
404: if getattr(self,'archiveTime',actualTime)< actualTime:
405: return retTXT%(s,s)
406: else:
407: return ""
408:
409: def getActualVersion(self,date=None):
410: """actuelle version"""
411: def sortProjectsByTime(x,y):
412: return cmp(x[1].archiveTime,y[1].archiveTime)
413:
414: if not date:
415: if self.isActual():
416: return self
417: else:
418: return None
419:
420: #suche ob aeltere versionen vorhanden sind
421:
422: finds=self.ZopeFind(self,obj_metatypes=['MPIWGProject'])
423: if not finds: #wenn nicht dann teste ob die aktuelle version schon existiert hat.
424: ad=getattr(self,'creationTime','20050101000000')
425: if int(date)>int(ad):
426: return self
427: else:
428: return None
429:
430:
431: else:
432: finds.sort(sortProjectsByTime)
433:
434: for find in finds:
435: #gehe durch die alten Projekte und finde das entprechende
436: if (int(find[1].archiveTime) > int(date)) and (int(date)>int(getattr(find[1],'creationTime','20050101000000'))):
437: return find[1]
438:
439: #kein passendes gefunden, dann teste ob das aktuelle in frage kommt
440: ad=getattr(self,'creationTime','20050101000000')
441:
442: if int(date)>int(ad):
443:
444: return self
445: else:
446: return None
447:
448:
449: def isActual(self):
450: """gibt 1 zurueck wenn aktuell, 0 sonst"""
451: actualTime=time.localtime()
452:
453:
454: #print getattr(self,'archiveTime',actualTime)
455: if getattr(self,'archiveTime',actualTime)< actualTime:
456: return 0
457: else:
458: return 1
459:
460: def copyObjectToArchive(self):
461: """kopiere aktuelles objekt ins archiv"""
462: cb=self.aq_parent.manage_copyObjects(self.getId())
463: self.manage_pasteObjects(cb)
464: actualTime=time.localtime()
465:
466: self.manage_renameObject(self.getId(),self.getId()+"_"+time.strftime("%Y%m%d%H%M%S",actualTime))
467: obj=getattr(self,self.getId()+"_"+time.strftime("%Y%m%d%H%M%S",actualTime))
468: obj.setArchiveTime(time.strftime("%Y%m%d%H%M%S",actualTime))
469: ids=[x[0] for x in self.ZopeFind(obj,obj_metatypes=['MPIWGProject'])]
470: obj.manage_delObjects(ids)
471:
472: def setArchiveTime(self,time):
473: """set Archive Time"""
474: self.archiveTime=time[0:]
475:
476: def versionManageForm(self):
477: """version Manage form:currently only set to invisible"""
478: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_versionManageForm.zpt')).__of__(self)
479: return pt()
480:
481: def versionManage(self,invisible=None,RESPONSE=None):
482: """version Manage form:currently only set to invisible"""
483: self.invisible=invisible
484:
485: if RESPONSE is not None:
486: RESPONSE.redirect('manage_main')
487:
488:
489: def crossLinker(self):
490: """experimental crosslinker"""
491: splitted=self.WEB_project_description[0].split()
492: new=[]
493: for split in splitted:
494: try:
495: found=self.DescriptionCatalog({'fulltext':split})
496:
497: if len(found)>1:
498:
499: new.append("<a href=%s>%s</a>"%(split,split))
500: else:
501: new.append(split)
502: except:
503: new.append(split)
504: return " ".join(new)
505:
506:
507:
508:
509: def generateTemplate(self,RESPONSE=None):
510: """Erzeuge Template fuer defined fields not_used"""
511:
512: id="index_html"
513: title=id
514: if self._getOb('index_html'):
515: self._delObject('index_html')
516:
517:
518: newObj=ZopePageTemplate(id,'TEXT')
519: self._setObject(id,newObj)
520: #self.manage_addPageTemplate(id,title)
521: if RESPONSE is not None:
522: RESPONSE.redirect('manage_main')
523:
524: def __init__(self, id, argv=None):
525: """initiere classe"""
526:
527: self.creationTime=time.strftime("%Y%m%d%H%M%S",time.localtime())[0:]
528: self.id=id
529: self.title=id
530: self.isActiveFlag=True #Flag is true is the project is still active, False if accomplished
531: self.responsibleScientistsList=[] # enthaelt die Lister der verantwortlichen Wissenschaftler in der Form (NAME, KEY), key ist "" flass Wissenschaftler nicht an unserem Haus
532:
533: if argv:
534: for arg in definedFields:
535: try:
536: setattr(self,arg,argv[arg])
537: except:
538: setattr(self,arg,"")
539: else:
540: for arg in definedFields:
541: setattr(self,arg,'')
542:
543: manage_options = Folder.manage_options+(
544: {'label':'Load New File','action':'loadNewFileForm'},
545: {'label':'Edit ProjectInfo','action':'editMPIWGProjectForm'},
546: {'label':'Edit BasisInfo','action':'editMPIWGBasisForm'},
547: {'label':'Edit Publications','action':'editMPIWGRelatedPublicationsForm'},
548: {'label':'Edit Themes & Disciplines','action':'editMPIWGDisciplinesThemesForm'},
549: {'label':'Versionmanager','action':'versionManageForm'},
550: )
551:
552:
553: def isActiveProject(self):
554: """check if the project is still active, default is true, set to false is the project is accomplished"""
555: return getattr(self,'isActiveFlag',True)
556:
557: def isArchivedProject(self):
558: """check if the project is archived"""
559:
560: completed=getattr(self,'completedAt',0)
561:
562: #completed leer
563: if completed=="" :
564: return False;
565: if completed == 0:
566: return False;
567:
568:
569: return True
570:
571:
572: def setActiveFlag(self,status=True):
573: """set the active flag"""
574: self.isActiveFlag=status
575:
576: def setCompletedAt(self,date):
577: """set the date of completion, date should be in the form DD.MM.YYYY or MM.YYYY or YYYY"""
578: logging.info("DATE:"+repr(date))
579: transformedDate=self.transformDate(date);
580: logging.info("transformed"+repr(transformedDate))
581: if transformedDate is not None:
582: setattr(self,"completedAt",transformedDate)
583: return True;
584: else:
585: return False;
586:
587: def setStartedAt(self,date):
588: """set the date of start, date should be in the form DD.MM.YYYY or MM.YYYY or YYYY"""
589: logging.info("DATE:"+repr(date))
590: transformedDate=self.transformDate(date);
591: logging.info("transformed"+repr(transformedDate))
592: if transformedDate is not None:
593: setattr(self,"startedAt",transformedDate)
594: return True;
595: else:
596: return False;
597: def getCompletedAt(self):
598: """gibt das transformierte Datum zurueck, an dem das Projekt beendet wurde."""
599: date=getattr(self,'completedAt','')
600: if date:
601: return self.reTransformDate(date);
602: else:
603: return '';
604:
605: def getStartedAt(self):
606: """gibt das transformierte Datum zurŸck, an dem Projekt begonnen wurde."""
607: date=getattr(self,'startedAt','')
608: if date:
609: return self.reTransformDate(date);
610: else:
611: return '';
612:
613: def reTransformDate(self,date):
614: """transformiert , transformdate zurueck"""
615: year=int(date/10000)
616: month=int((date-year*10000)/100)
617: day=int((date-year*10000-month*100))
618: if (day==0) and (month==0):
619: return """%s"""%year;
620: if day==0 :
621: return """%s.%s"""%(month,year);
622:
623: return """%s.%s.%s"""%(day,month,year);
624:
625:
626: def transformDate(self,date):
627: """transformiert ein Datum von DD.MM.YYYY, MM.YYYY,YYYY nach YYYYMMDD, alle nicht angebebenn Werte
628: werden auf 0 gesetzt, es wird null zurŸckgegeben falls das Datum ungueltig ist"""
629:
630: if (date==None):
631: return None;
632:
633:
634: if (date.lstrip().rstrip()=="" ) :
635: return "";
636:
637: splitted=date.split(".")
638: length=len(splitted)
639: year=0
640: month=0
641: day=0
642: if length > 3:
643: return "";
644: if length==3:
645: day = int(splitted[0])
646: if length>1:
647: month=int(splitted[length-2])
648:
649: if length > 0:
650: try:
651: year = int(splitted[length-1])
652: except:
653: pass
654:
655: ## logging.info("month:"+(month))
656: if not (0<=month<13):
657: return None;
658:
659: if not(0<=day<32):
660: return None;
661:
662: if (year>0) and (year<1900): #jahr nicht vierstellig eingegeben
663: year=2000+year;
664: return year*10000+month*100+day
665:
666:
667:
668: def checkDate(self,date):
669: """teste ob zum Zeitpunkt date eine andere version existierte"""
670:
671:
672: def sortProjectsByTime(x,y):
673: return cmp(x[1].archiveTime,y[1].archiveTime)
674:
675: #suche ob aeltere versionen vorhanden sind
676:
677: finds=self.ZopeFind(self,obj_metatypes=['MPIWGProject'])
678: if not finds: #wenn nicht dann teste ob die aktuelle version schon existiert hat.
679: ad=getattr(self,'creationTime','20050101000000')
680: if int(date)>int(ad):
681: return self.REQUEST['URL1']+"/"+self.getId()
682: else:
683: return self.REQUEST['URL1']+"/no_project"
684:
685:
686: else:
687: finds.sort(sortProjectsByTime)
688:
689: for find in finds:
690: #gehe durch die alten Projekte und finde das entprechende
691: if (int(find[1].archiveTime) > int(date)) and (int(date)>int(getattr(find[1],'creationTime','20050101000000'))):
692: return self.REQUEST['URL1']+"/"+find[1].getId()
693:
694: #kein passendes gefunden, dann teste ob das aktuelle in frage kommt
695: ad=getattr(self,'creationTime','20050101000000')
696:
697: if int(date)>int(ad):
698:
699: return self.REQUEST['URL1']+"/"+self.getId()
700: else:
701: return self.REQUEST['URL1']+"/no_project"
702:
703:
704: def no_project(self):
705: """warnung: project noch nicht existent"""
706: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','no_project')).__of__(self)
707: return pt()
708:
709: def getGetNeighbourhood(self,wordStr, length=100,tagging=True):
710: """finde umgebung um die worte in wordStr, zurueckgegeben wird eine Array mit den Umgebungen von Fundstellen der Worte
711: alle Tags werden entfernt, die Fundstellen werden mit <span class="found">XX</span> getaggt, die Umgebungen werden
712: case insensitive gesucht
713: @param wordStr: string mit Worten getrennt durch Leerzeichen, Phrasen sind mit " gekennzeichnet
714: "eine phrase", "*" bezeichnet wildcards und wird ignoriert"
715: @param length: optional, default wert 100, 2*length ist die groesse der Umgebung
716: @param tagging: optional default wert true, kein span tag wird erzweugt falls tag=false
717: """
718:
719: ret=[] # nimmt das Array auf, dass spaeter zurueckgegeben wird
720: ranges=[] #Array mit tupeln x,y wobei x die Position des Anfang und y des Endes der i-ten Umgebung angiebt
721:
722: def isInRanges(nr,length):
723: """test ob eine gegeben Position nr schon irgendwo in einer Umgebung ist, gibt den Index des ersten Wertes aus ranges zurueck,
724: -1, wenn kein Treffer
725:
726: @param nr: Position die geprueft werden soll
727: @param length: Laenge des Wortes das geprueft werden soll
728: """
729: for x in ranges:
730: if (x[0]<=nr) and (nr < (x[1]-length)):
731: return ranges.index(x)
732: return -1
733:
734: # deal with phrases, in Phrasen werden die Leerzeichen durch "_" ersetzt.
735: def rep_empty(str):
736: x= re.sub(" ","_",str.group(0))
737: return re.sub("\"","",x)
738:
739: wordStr=re.sub("\".*?\"", rep_empty,wordStr)#ersetze leerzeichen in " " durch "_" und loesche "
740:
741: #deal with wildcards, for our purposes it is enough to delete the wildcard
742: wordStr=wordStr.replace("*","")
743:
744: words=wordStr.split(" ")
745: #if not words is ListType:
746: # words=[words]
747:
748: txt=self.harvest_page()
749: if not txt:
750: return ret
751: txt=re.sub("<.*?>", "", txt) # loesche alle Tags
752: for word in words:
753: word=re.sub("_"," ",word) # ersetze zurueck "_" durch " "
754: pos=0
755:
756: n=txt.lower().count(word.lower()) # wie oft tritt das Wort auf
757:
758: for i in range(n):
759: pos=txt.lower().find(word.lower(),pos)
760:
761: if pos > 0:
762: x=max(0,pos-length)
763: y=min(len(txt),pos+length)
764:
765:
766: #is word already in one of the results
767: nr=isInRanges(pos,len(word))
768: if nr >=0:# word ist in einer schon gefunden Umgebung, dann vergroessere diese
769: x=min(ranges[nr][0],x)
770: y=max(ranges[nr][1],y)
771:
772: str=txt[x:y]
773:
774: if nr >=0: # word ist in einer schon gefunden Umgebung
775: ranges[nr]=(x,y) # neue Position der Umgebung
776:
777: ret[nr]=str # neue Umgebung
778: else: # andernfalls neue Umgebung hinzufuegen
779: ranges.append((x,y))
780:
781: ret.append(str)
782:
783: pos=pos+len(word)
784: else:
785: break;
786:
787: # now highlight everything
788: if tagging:
789: for x in range(len(ret)):
790: for word in words:
791: repl=re.compile(word,re.IGNORECASE)
792: ret[x]=repl.sub(""" <span class="found">%s</span>"""%word.upper(),ret[x])
793:
794: return ret
795:
796: def harvest_page(self,context=None):
797: """seite fuer harvesting fuer die Projektsuche"""
798: if not context:
799: context=self
800:
801: if self.isActiveProject() and self.isActual():
802: ext=getattr(self,"harvest_main",None)
803: if ext:
804: return getattr(self,ext.getId())()
805:
806: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','harvest_main')).__of__(context)
807:
808:
809: return pt()
810:
811: def index_html(self,request=True,context=None):
812: """show homepage"""
813: if not context:
814: context=self
815: if request:
816: if self.REQUEST.has_key('date') and self.REQUEST.SESSION.get('MPI_redirected',None)==None:
817: self.REQUEST.SESSION['MPI_redirected']=1
818: self.REQUEST.RESPONSE.redirect(self.checkDate(self.REQUEST['date'])+"?date="+self.REQUEST['date'])
819: else:
820: self.REQUEST.SESSION['MPI_redirected']=None
821:
822: #ext=self.ZopeFind(self.aq_parent,obj_ids=["project_main"])
823: ext=getattr(self,"project_main",None)
824: if ext:
825: return getattr(self,ext.getId())()
826:
827: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','project_main')).__of__(context)
828:
829: return pt()
830:
831:
832: def getDataFields(self):
833: """giveListofDatafields"""
834: ret=[]
835: for x in range(1,14):
836: if not x in [6,10,9]: # not used fields
837: ret.append('xdata_%02i'%x)
838: return ret
839:
840: def getDefinedFields(self):
841: """show all defined fields"""
842:
843: return definedFields
844:
845: def getAttribute(self,field):
846: """get attrbiute"""
847: return getattr(self,field)
848:
849: def getContent(self,field,filter=None):
850: """Inhalt des Feldes"""
851:
852: text=u''
853:
854: for x in getattr(self,field):
855:
856: try:
857: text +=x
858: except:
859: text = x
860:
861:
862:
863: try:
864: if text[len(text)-1]==";":
865: text=text[0:len(text)-1]
866:
867:
868: except:
869: pass
870:
871: if text=='':
872: text2=text
873: else:
874: text2=re.sub(r';([^\s])','; \g<1>',text)
875:
876: #teste ob ergebnis leer und header dann nehme title
877:
878: if (text2=='') and (field=='WEB_project_header'):
879: return self.getContent('WEB_title')
880:
881: if filter:
882: splitted=text2.split("""<p class="picture">""")
883: if len(splitted)>1:
884: tmp=splitted[1].split("</p>")
885: #return repr(splitted[1])
886: try:
887: self.imageURL=tmp[0].split("\"")[1].encode('utf-8')
888: except:
889: try:
890: self.imageURL=tmp[0].split("src=")[1].split(" ")[0].encode('utf-8')
891: except:
892: self.imageURL=""
893:
894: split2="</p>".join(tmp[1:])
895:
896: text3=splitted[0]+split2
897:
898: splitted=text3.split("""<p class="picturetitle">""")
899: if len(splitted)>1:
900: tmp=splitted[1].split("</p>")
901: self.imagecap=tmp[0].encode('utf-8')
902:
903: split4="".join(tmp[1:])
904:
905: text5=splitted[0]+split4
906: else:
907: #keine caption
908: text5=text3
909: else:
910: #kein bild
911: text5=text2
912: else:
913: text5=text2
914:
915: #teste ob WEB_project_description und keine fuehrenden p tags
916: if (len(text5)>4) and (not text5[0:3]=='<p>') and (field=='WEB_project_description'):
917: text5= "<p>"+text5+"</p>"
918:
919:
920: #filter image
921:
922: text5=text5.lstrip().rstrip() #loescher leerzeichen und einzelndes br
923: if (text5=="<br>") or (text5=="<br/>"):
924: text5=""
925:
926: logging.debug("getcontent: field=%s filter=%s -> %s"%(field,filter,repr(text5)))
927: #return unicodify(text5)
928: return utf8ify(text5) # return as utf-8 byte string
929:
930:
931: def showImagesOfPage(self,imageUrl=None):
932: """show Images of project"""
933: self.getContent('WEB_project_description',filter='yes') #get the content and store image infos into session
934: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','projectImageView.zpt')).__of__(self)
935: return pt()
936:
937:
938: def show_html(self):
939: """simple index"""
940: #return "HI"
941: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_index.zpt')).__of__(self)
942: return pt()
943:
944: def saveFromPreview(self):
945: """save content aus preview"""
946: self.WEB_project_description=self.previewTemplate.WEB_project_description[0:]
947: self.REQUEST.RESPONSE.redirect("./index.html")
948:
949: def saveEditedContent(self,kupu=None,preview=None):
950: """save Edited content"""
951:
952: if preview:
953: kupu=preview
954: #find content of body tags
955: start=kupu.find("<body>")
956: end=kupu.find("</body>")
957: newcontent= kupu[start+6:end]
958:
959: if preview:
960:
961: return self.preview(newcontent)
962:
963: self.copyObjectToArchive()
964: self.WEB_project_description=newcontent[0:]
965:
966: self.REQUEST.RESPONSE.redirect("./index.html")
967:
968: return True
969:
970: security.declareProtected('View management screens','edit')
971: def edit(self,western=None):
972: """Edit pages"""
973: if western:
974: self.REQUEST.RESPONSE.setCookie("MP_debug_code","western",path="/")
975:
976:
977: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGProjectNeu.zpt')).__of__(self)
978: return pt()
979:
980: edit_MPIWGProject_main = PageTemplateFile('zpt/edit_MPIWGProject_main', globals())
981:
982: def getPathStyle(self, path, selected, style=""):
983: """returns a string with the given style + 'sel' if path == selected."""
984:
985: if path == selected:
986: return style + 'sel'
987: else:
988: return style
989:
990: def preview(self,description):
991: """preview"""
992: tmpPro=getattr(self,"previewTemplate",None)
993: if not tmpPro:
994: tmpPro=MPIWGProject("previewTemplate")
995: self._setObject("previewTemplate",tmpPro)
996: for field in definedFields:
997: setattr(tmpPro,field,getattr(self,field))
998: tmpPro.WEB_project_description=description[0:]
999: tmpPro.invisible=True
1000: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','previewFrame.zpt')).__of__(self)
1001: return pt()
1002:
1003: #return self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+"/previewTemplate")
1004:
1005:
1006: def getWebProject_description(self):
1007: """get description"""
1008: debug= self.REQUEST.cookies.get("MP_debug_code",None)
1009:
1010: if debug and debug=="western":
1011: return """
1012: <html>
1013: <head>
1014: <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
1015: </head>
1016: <body>%s
1017: </html></body>
1018: """%self.WEB_project_description[0]
1019:
1020: return """
1021: <html>
1022: <head>
1023: <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
1024: </head>
1025: <body>%s
1026: </html></body>
1027: """%self.getContent('WEB_project_description')
1028:
1029:
1030:
1031: def editMPIWGProjectForm(self):
1032: """editform"""
1033: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGProject.zpt')).__of__(self)
1034: return pt()
1035:
1036: def isResponsibleScientist(self,key):
1037: """teste ob eine Person in der Liste der respl. scientists auftaucht"""
1038: #logging.info("XXXXXXXXXXXXX"+repr(self.responsibleScientistsList))
1039:
1040:
1041: keys = [x[1] for x in getattr(self,"responsibleScientistsList",[])]
1042:
1043: if key in keys:
1044: return True
1045: else:
1046: return False
1047:
1048: def getPersonKeyList(self):
1049: """gibt die key Lister der beteiligten Personen zurŸck"""
1050: return [x[1] for x in getattr(self,'responsibleScientistsList',[])]
1051:
1052:
1053:
1054:
1055: def identifyNames(self,nameList):
1056: """Bekommt eine Komma oder Semikolon getrennte Liste mit Name der Form Vorname MittelName(n) Nachname
1057: und ordnet diese dann Mitarbeiter IDs zu falls es schone eine Liste gibt wird im Projekte gibt wird diese Upgedated.
1058: @param nameList
1059: """
1060: nameList=nameList.replace(";",",") # falls ; als Trenner ersetze
1061: names=nameList.split(",")
1062:
1063: returnNamesDict={}
1064:
1065:
1066: for name in names:
1067: name=name.lstrip().rstrip()
1068: nameSplitted = name.split(" ")
1069: if len(nameSplitted)>1: #vor und nachname angegeben)
1070:
1071: lastname=nameSplitted[-1]
1072: firstname=nameSplitted[0]
1073: else:
1074: firstname =""
1075: lastname=nameSplitted[0]
1076:
1077: #finde Mitarbeiter mit den entsprechenden Name
1078: logging.info("Search: %s %s %s"%(name,firstname,lastname))
1079: firstname=firstname.capitalize()
1080: lastname=lastname.capitalize()
1081: cataloggedNames=self.MembersCatalog(firstName=firstname,lastName=lastname)
1082:
1083: #Teste ob die ensprechenden Namen schon der Liste zu geordnet sind
1084: #if not hasattr(self,'responsibleScientistsList'):
1085: # self.responsibleScientistsList={}
1086: #
1087: # if name in self.responsibleScientistsList.values()
1088:
1089: if len(cataloggedNames)>0:
1090: returnNamesDict[name]=cataloggedNames
1091: else:
1092: returnNamesDict[name]=[]
1093:
1094: return returnNamesDict
1095:
1096: def editMPIWGProject(self,RESPONSE=None,fromEdit=None):
1097: """edit the project and archive the old version"""
1098:
1099: self.copyObjectToArchive() # archive the object
1100:
1101:
1102: for x in definedFields:
1103: if self.REQUEST.has_key(x):
1104:
1105: setattr(self,x,[self.REQUEST[x].decode('utf-8')])
1106:
1107:
1108:
1109:
1110: completedAt = self.REQUEST.get('completedAt')
1111: if not self.setCompletedAt(completedAt):
1112: RESPONSE.redirect('./editMPIWGBasisEditor?error="dateWrong')
1113:
1114: startedAt = self.REQUEST.get('startedAt')
1115: if not self.setStartedAt(startedAt):
1116: RESPONSE.redirect('./editMPIWGBasisEditor?error="dateWrong')
1117:
1118: if self.REQUEST.has_key('historicalNames'):
1119: self.en.changeHistoricalNames(self.getId(),self.REQUEST['historicalNames'].split("\n"))
1120:
1121: if self.REQUEST.has_key('active'):
1122: self.setActiveFlag(True)
1123: else:
1124: self.setActiveFlag(False)
1125:
1126: self.responsibleScientistsList=[] # setze die Liste der verantwortlichen Wissenschaftler zurueck
1127:
1128: names={}
1129: keys={}
1130: tmpList=[]
1131: for key in self.REQUEST.keys(): #gehe durch das Formular
1132: splitted=key.split("_")
1133: if splitted[0]=="responsibleScientist": #wenn es ein Feld der Form reponsibleScientist_nr_KEY gibt
1134: nr=splitted[2]
1135: if splitted[1]=="name":
1136: names[nr]=self.REQUEST[key]
1137: elif splitted[1]=="key":
1138: keys[nr]=self.REQUEST[key]
1139:
1140:
1141: for nr in names.keys():
1142: tmpList.append((names[nr],keys.get(nr,"")))
1143:
1144: self.responsibleScientistsList=tmpList
1145: if fromEdit and (RESPONSE is not None):
1146: #RESPONSE.redirect('./editMPIWGBasisEditor')
1147: return self.editMPIWGBasisEditor(identifiedNames=self.identifyNames(self.REQUEST.get('xdata_01','')))
1148:
1149: else:
1150: if RESPONSE is not None:
1151: RESPONSE.redirect('manage_main')
1152:
1153:
1154:
1155: security.declareProtected('View managment screens','editMPIWGDisciplinesThemesEditor')
1156: def editMPIWGDisciplinesThemesEditor(self):
1157: """edit from edit"""
1158: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGDisciplinesThemesNeu.zpt')).__of__(self)
1159: return pt()
1160:
1161:
1162: def editMPIWGDisciplinesThemesForm(self):
1163: """edit the disciplines and themes Form"""
1164:
1165: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGDisciplinesThemes.zpt')).__of__(self)
1166: return pt()
1167:
1168: def editMPIWGDisciplinesThemes(self,disciplines=None,themes=None,RESPONSE=None,fromEdit=None):
1169: """edit disciplin and form"""
1170: if disciplines:
1171: if type(disciplines) is StringType:
1172: self.xdata_09=disciplines
1173: else:
1174: self.xdata_09=";".join(disciplines)
1175: else:
1176: self.xdata_09=""
1177: if themes:
1178: if type(themes) is StringType:
1179: self.xdata_10=themes
1180: else:
1181: self.xdata_10=";".join(themes)
1182: else:
1183: self.xdata_10=""
1184:
1185: if fromEdit and (RESPONSE is not None):
1186: RESPONSE.redirect('./editMPIWGDisciplinesThemesEditor')
1187:
1188: else:
1189: if RESPONSE is not None:
1190: RESPONSE.redirect('manage_main')
1191:
1192:
1193: def isChecked(self,wert,list):
1194: """check if wert is in ; seperated list"""
1195:
1196: #felder sind manchmnal als liste mit einem element definiert
1197: if type(list) is StringType or UnicodeType:
1198: splitted=list.split(";")
1199: else:
1200: splitted=list[0].split(";")
1201:
1202: splitted=[y.rstrip().lstrip() for y in splitted]
1203:
1204: for x in splitted:
1205: x=re.sub(r"[^A-z ]","",x)
1206: if (not x==u'') and x in wert:
1207: return 1
1208: return 0
1209:
1210: security.declareProtected('View management screens','editMPIWGBasisEditor')
1211: def editMPIWGBasisEditor(self, identifiedNames=None):
1212:
1213: """editform"""
1214: if not identifiedNames:
1215: identifiedNames=self.identifyNames(self.getContent('xdata_01'))
1216: # identifiedNames=self.getFullNameEntries()
1217:
1218: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGBasisNeu.zpt')).__of__(self)
1219: return pt(identifiedNames=identifiedNames)
1220:
1221: security.declareProtected('View management screens','editMPIWGBasisForm')
1222: def editMPIWGBasisForm(self):
1223: """editform"""
1224: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGBasis.zpt')).__of__(self)
1225: return pt()
1226:
1227: security.declareProtected('View management screens','editMPIWGRelatedPublicationsForm')
1228: def editMPIWGRelatedPublicationsForm(self):
1229: """Edit related Publications"""
1230: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGRelatedPublications.zpt')).__of__(self)
1231: return pt()
1232:
1233:
1234: def loadNewFileForm(self):
1235: """Neues XML-File einlesen"""
1236: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_newfile.zpt')).__of__(self)
1237: return pt()
1238:
1239: def loadNewFile(self,RESPONSE=None):
1240: """einlesen des neuen files"""
1241: fileupload=self.REQUEST['fileupload']
1242: if fileupload:
1243: file_name=fileupload.filename
1244: filedata=fileupload.read()
1245:
1246: argv=xmlhelper.proj2hash(filedata)
1247: #print argv.keys()
1248: for arg in definedFields:
1249:
1250: #print arg,argv[arg],getattr(self,arg)
1251: try:
1252: temp=argv[arg][0:]
1253: #old=getattr(self,arg)
1254: setattr(self,arg,temp)
1255: #print old,getattr(self,arg)
1256: except:
1257: """nothing"""
1258:
1259: if RESPONSE is not None:
1260: RESPONSE.redirect('manage_main')
1261:
1262: def manage_addMPIWGProjectForm(self):
1263: """form for adding the project"""
1264: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMPIWGProjectForm.zpt')).__of__(self)
1265: return pt()
1266:
1267: def manage_addMPIWGProject(self,id,RESPONSE=None):
1268: """method to add a project"""
1269: #print argv
1270: fileupload=self.REQUEST.get('fileupload',None)
1271: if fileupload:
1272:
1273: file_name=fileupload.filename
1274: filedata=fileupload.read()
1275:
1276: argv=xmlhelper.proj2hash(filedata)
1277:
1278: #print argv
1279: newObj=MPIWGProject(id,argv)
1280: else:
1281: newObj=MPIWGProject(id)
1282:
1283: self._setObject(id,newObj)
1284:
1285:
1286: if RESPONSE is not None:
1287: RESPONSE.redirect('manage_main')
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvs/cvsweb/icons/back.gif){kind=icon}
Return to MPIWGProjects.py CVS log ![[TXT]](/cvs/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvs/cvsweb/icons/dir.gif){kind=icon}
Up to [Repository] / MPIWGWeb