1: """This contains the class MPIWG Projects
2: for organizing and maintaining the different project pages
3:
4: """
5: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
6: from Products.PageTemplates.PageTemplate import PageTemplate
7: from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
8: from Products.ZSQLExtend.ZSQLExtend import ZSQLExtendFolder
9: from Products.ZCatalog.CatalogPathAwareness import CatalogAware
10: from Globals import package_home
11: import urllib
12: import MPIWGStaff
13: import string
14: import re
15: import os
16: from types import *
17: import zLOG
18: import xmlhelper # Methoden zur Verwaltung der projekt xmls
19: from OFS.SimpleItem import SimpleItem
20: from OFS.Folder import Folder
21: from Products.ZSQLMethods.SQL import SQLConnectionIDs
22:
23: from bibliography import *
24: import time
25:
26: definedFields=['WEB_title','xdata_01','xdata_02','xdata_03','xdata_04','xdata_05','xdata_06','xdata_07','xdata_08','xdata_09','xdata_10','xdata_11','xdata_12','xdata_13','WEB_project_header','WEB_project_description','WEB_related_pub']
27:
28: checkFields = ['xdata_01']
29:
30:
31:
32: def sortF(x,y):
33: try:
34: return cmp(x[1],y[1])
35: except:
36: try:
37: return cmp(str(x[1]),str(y[1]))
38: except:
39:
40: return 0
41:
42: def sortI(x,y):
43: xsplit=x[1].split(".")
44: ysplit=y[1].split(".")
45: xret=""
46: yret=""
47: try:
48: for i in range(5):
49: try:
50: yret=yret+"%04i"%int(xsplit[i])
51: except:
52: yret=yret+"%04i"%0
53:
54: try:
55: xret=xret+"%04i"%int(ysplit[i])
56: except:
57: xret=xret+"%04i"%0
58:
59:
60: return cmp(int(yret),int(xret))
61: except:
62: return cmp(x[1],y[1])
63:
64: class MPIWGTemplate(ZopePageTemplate):
65: """Create a layout Template for different purposes"""
66:
67: meta_type="MPIWGTemplate"
68:
69: manage_options=ZopePageTemplate.manage_options+(
70: {'label':'Change Weight','action':'changeWeightForm'},
71: )
72:
73: def changeWeightForm(self):
74: """change weight form"""
75: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGTemplateChangeWeight.zpt')).__of__(self)
76: return pt()
77:
78: def changeWeight(self,weight,RESPONSE=None):
79: """change weight"""
80: self.weight=weight
81: if RESPONSE is not None:
82: RESPONSE.redirect('manage')
83:
84:
85: def __init__(self, id, text=None, content_type=None,MPIWGType=None):
86: self.id = str(id)
87:
88:
89:
90: self.ZBindings_edit(self._default_bindings)
91: if text is None:
92: self._default_content_fn = os.path.join(package_home(globals()),
93: 'zpt/MPIWG_%s_template_standard.zpt'%MPIWGType)
94: text = open(self._default_content_fn).read()
95: self.pt_edit(text, content_type)
96:
97:
98: """change form"""
99:
100: def isActive(self):
101: """teste ob ausgewaehlt"""
102: if self.absolute_url()==self.REQUEST['URL']:
103: return "aktiv"
104: else:
105: return ""
106:
107: def manage_addMPIWGTemplateForm(self):
108: """Form for adding"""
109: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt/AddMPIWGTemplate.zpt')).__of__(self)
110: return pt()
111:
112: from urllib import quote
113:
114:
115: def manage_addMPIWGTemplate(self, MPIWGType,id, title=None,weight=0,REQUEST=None):
116: "Add a Page Template with optional file content."
117: if type(MPIWGType)==StringType:
118: MPIWGTypes=[MPIWGType]
119: else:
120: MPIWGTypes=MPIWGType
121:
122: for singleType in MPIWGTypes:
123:
124:
125: if REQUEST is None:
126: self._setObject(id, MPIWGTemplate(id, text,EchoType=singleType))
127: ob = getattr(self, id)
128:
129: if title:
130: ob.pt_setTitle(title)
131: return ob
132: else:
133: file = REQUEST.form.get('file')
134: headers = getattr(file, 'headers', None)
135: if headers is None or not file.filename:
136: zpt = MPIWGTemplate(id,MPIWGType=singleType)
137: else:
138: zpt = MPIWGTemplate(id, file, headers.get('content_type'))
139:
140: self._setObject(id, zpt)
141: ob = getattr(self, id)
142: if title:
143: ob.pt_setTitle(title)
144:
145: try:
146: u = self.DestinationURL()
147: except AttributeError:
148: u = REQUEST['URL1']
149:
150: ob = getattr(self, id)
151: ob.weight=weight
152:
153: REQUEST.RESPONSE.redirect(u+'/manage_main')
154: return ''
155:
156:
157: class MPIWGRoot(ZSQLExtendFolder):
158: """Stammordner für den Web-Server"""
159:
160: fieldLabels={'WEB_title':'WEB_Title','xdata_01':'Responsible Scientists','xdata_02':'Department',
161: 'xdata_03':'Historical Persons','xdata_04':'Time period',
162: 'xdata_05':'Sorting number','xdata_06':'Keywords','xdata_07':'Short title',
163: 'xdata_08':'Other involved scholars' ,'xdata_09':'Part of','xdata_10':'Covered by',
164: 'xdata_11':'Object Digitallibrary','xdata_12':'Cooperation partners',
165: 'xdata_13':'Funding institutions','WEB_project_header':'WEB_project_header',
166: 'WEB_project_description':'WEB_project_description','WEB_related_pub':'WEB_related_pub'}
167:
168: folders=['MPIWGProject','Folder','ECHO_Navigation']
169: meta_type='MPIWGRoot'
170:
171: def isNewCapital(self,text=None,reset=None):
172: if reset:
173: self.REQUEST['capital']="A"
174: return True
175: else:
176: if len(text)>0 and not (text[0]==self.REQUEST['capital']):
177: self.REQUEST['capital']=text[0]
178: return True
179: else:
180: return False
181:
182: def subNav(self,id):
183: """return subnav elemente"""
184: def sortWeight(x,y):
185: x1=int(getattr(x[1],'weight','0'))
186: y1=int(getattr(y[1],'weight','0'))
187: return cmp(x1,y1)
188: if hasattr(self,id):
189: subs=self.ZopeFind(getattr(self,id),obj_metatypes=['MPIWGTemplate'])
190: subs.sort(sortWeight)
191: return subs
192: else:
193: return None
194: def isActive(self,name):
195: """teste ob subnavigation aktiv"""
196: for part in self.REQUEST['URL'].split("/"):
197: if part==name:
198: return True
199: return False
200:
201:
202: def upDateSQL(self,fileName):
203: """updates SQL databases using fm.jar"""
204: fmJarPath=os.path.join(package_home(globals()), 'updateSQL/fm.jar')
205: xmlPath=os.path.join(package_home(globals()), "updateSQL/%s"%fileName)
206: zLOG.LOG("MPIWG Web",zLOG.INFO,"java -classpath %s -Djava.awt.headless=true Convert %s"%(fmJarPath,xmlPath))
207: ret=os.popen("java -classpath %s -Djava.awt.headless=true Convert %s"%(fmJarPath,xmlPath),"r").read()
208: zLOG.LOG("MPIWG Web",zLOG.INFO,"result convert: %s"%ret)
209: return 1
210:
211: def patchProjects(self,RESPONSE):
212: """patch"""
213: projects=self.ZopeFind(self.projects,obj_metatypes=['MPIWGProject'])
214: for project in projects:
215: tmp=project[1].WEB_project_description[0].replace("/CD/projects/","")[0:]
216: setattr(project[1],'WEB_project_description',[tmp[0:]])
217: RESPONSE.write("<p>%s</p>\n"%project[0])
218:
219: def replaceNotEmpty(self,format,field):
220: """replace not empty"""
221: if field and (not field.lstrip()==''):
222: return format%field
223: else:
224: return ""
225:
226:
227: def isActual(self,project):
228: """checke if project is actual"""
229: actualTime=time.localtime()
230: obj= project.getObject()
231:
232: if getattr(obj,'archiveTime',actualTime)< actualTime:
233: return False
234: else:
235: return True
236:
237: def redirectIndex_html(self,request):
238: #return request['URL1']+'/index_html'
239:
240: return urllib.urlopen(request['URL1']+'/index_html').read()
241:
242:
243: def formatBibliography(self,here,found):
244: """format"""
245: return formatBibliography(here,found)
246:
247: def getValue(self,fieldStr):
248: """Inhalt des Feldes"""
249:
250: if type(fieldStr)==StringType:
251: field=fieldStr
252: else:
253: field=fieldStr[0]
254: try:
255: if field[len(field)-1]==";":
256: field=field[0:len(field)-1]
257: except:
258:
259: """nothing"""
260: field=re.sub(r';([^\s])','; \g<1>',field)
261: return field.encode('utf-8')
262:
263:
264:
265: def sortedNames(self,list):
266: """sort names"""
267:
268: def sortLastName(x_c,y_c):
269: try:
270: x=urllib.unquote(x_c).encode('utf-8','ignore')
271: except:
272: x=urllib.unquote(x_c)
273:
274: try:
275: y=urllib.unquote(y_c).encode('utf-8','ignore')
276: except:
277: x=urllib.unquote(y_c)
278:
279:
280:
281: try:
282: last_x=x.split()[len(x.split())-1]
283: last_y=y.split()[len(y.split())-1]
284:
285: except:
286:
287: last_x=""
288: last_y=""
289:
290:
291:
292: if last_x<last_y:
293: return 1
294: elif last_x>last_y:
295: return -1
296: else:
297: return 0
298:
299: list.sort(sortLastName)
300: list.reverse()
301:
302: return list
303:
304: def __init__(self, id, title):
305: """init"""
306: self.id=id
307: self.title=title
308:
309: def urlQuote(self,str):
310: """quote"""
311: return urllib.quote(str)
312:
313: def urlUnQuote(self,str):
314: """quote"""
315: return urllib.unquote(str)
316:
317: def harvestHistoricalPersons(self):
318: """erstelle liste aller erwaehnten actors"""
319:
320: def normalize(str):
321: """loesche fuhrendes space"""
322: if (len(str)>1) and (str[0]==" "):
323: ret=str[1:]
324: else:
325: ret=str
326: return ret
327:
328: list={}
329: projects=self.ZopeFind(self.projects,obj_metatypes=['MPIWGProject'])
330:
331: for project in projects:
332: lg=len(project[1].xdata_03[0])-1
333:
334: if (lg>1) and (project[1].xdata_03[0][lg]==";"):
335: project[1].xdata_03[0]=project[1].xdata_03[0][0:lg]
336:
337:
338:
339:
340: try:
341: if len(project[1].xdata_03[0].split(";"))>1: # guess if separator is ;
342: for person in project[1].xdata_03[0].split(";"):
343: personNormal=normalize(person)
344: if personNormal in list.keys():
345: list[urllib.quote(personNormal)][1].append(project[1])
346: else:
347: list[urllib.quote(personNormal)]=(personNormal,[project[1]])
348: else: #guess , is sepeator
349: for person in project[1].xdata_03[0].split(","):
350: personNormal=normalize(person)
351: if urllib.quote(personNormal) in list.keys():
352: list[urllib.quote(personNormal)][1].append(project[1])
353: else:
354: list[urllib.quote(personNormal)]=(personNormal,[project[1]])
355:
356: except:
357: zLOG.LOG("MPIWG Web (harvestHistoricalPerson)",zLOG.ERROR,"cannot annalyize: %s"%repr(project))
358:
359:
360: return list
361:
362: def storeHistoricalPersons(self,RESPONSE=None):
363: """store persons"""
364: self.personDict={}
365: personDict=self.harvestHistoricalPersons()
366: for person in personDict.keys():
367: for project in personDict[person][1]:
368: if person in self.personDict.keys():
369: self.personDict[person][1].append((project.absolute_url(),project.WEB_title[0],project.xdata_01[0]))
370: else:
371: self.personDict[person]=(personDict[person][0],[(project.absolute_url(),project.WEB_title[0],project.xdata_01[0])])
372:
373: if RESPONSE is not None:
374: RESPONSE.redirect("showHistoricalPersons")
375:
376:
377: def getPersonDict(self,name):
378: """name von dict"""
379:
380: try:
381: return self.personDict[name][0].encode('utf-8')
382: except:
383: return self.personDict[name][0]
384: return self.personDict[name][0].decode('latin-1').encode('utf-8')
385:
386:
387: def showHistoricalPersons(self):
388: """show persons"""
389: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','showHistoricalPersons')).__of__(self)
390: return pt()
391:
392:
393: def editHistoricalPersonsForm(self):
394: """edit historical persons for consistency"""
395: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editHistoricalPersonsForm')).__of__(self)
396: return pt()
397:
398: def getProjectsByFieldContent(self,fieldName,fieldContentsEntry):
399: """gib alle Projekte aus mit Value von field mit fieldName enthält ein Element der Liste fieldContents"""
400: if type(fieldContentsEntry) is StringType:
401: fieldContents=[fieldContentsEntry]
402: else:
403: fieldContents=fieldContentsEntry
404:
405: projects=self.ProjectCatalog({fieldName:string.join(fieldContents,' OR')})
406: #print projects
407: return projects
408:
409: def changeMPIWGRootForm(self):
410: """edit"""
411: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeMPIWGRootForm')).__of__(self)
412: return pt()
413:
414: def changeMPIWGRoot(self,title,disciplineList,themesList,connection_id,RESPONSE=None):
415: """change"""
416: self.title=title
417: self.connection_id=connection_id
418: self.disciplineList=disciplineList
419: self.themesList=themesList
420:
421: if RESPONSE is not None:
422: RESPONSE.redirect('manage_main')
423:
424: def getDisciplineList(self):
425: """get disciplines as list"""
426: return self.disciplineList.split("\n")
427:
428: def getThemeList(self):
429: """get themes as list"""
430: return self.themesList.split("\n")
431:
432: def test(self):
433: """test"""
434: return self.getProjectsByFieldContent('xdata_09',['biology'])[0].absolute_url
435:
436: def getContexts(self,childs=None,parents=None,depth=None):
437: """childs alle childs, alle parents"""
438: ret=[]
439: if parents:
440: splitted=parents.split(".")
441: parentId=string.join(splitted[0:len(splitted)-1],".")
442:
443: for project in self.getProjectFields('xdata_05',sort='int'):
444: if project[1]==parentId:
445: ret.append(project)
446:
447: if childs:
448: for project in self.getProjectFields('xdata_05',sort='int'):
449: searchStr=childs+"(\..*)"
450: if re.match(searchStr,project[1]):
451:
452: if depth:
453:
454: if int(depth)>=len(project[1].split("."))-len(childs.split(".")):
455:
456: ret.append(project)
457: else:
458: ret.append(project)
459: return ret
460:
461: def getProjectFields(self,fieldName,actual="yes",folder=None,sort=None):
462: """getListofFieldNames"""
463: ret=[]
464:
465: objects=self.ZopeFind(self.projects,obj_metatypes=['MPIWGProject'],search_sub=0)
466:
467:
468: for object in objects:
469: obj=object[1]
470:
471: if (not getattr(obj,'invisible',None)) and (obj.isActual()):
472: if fieldName=="WEB_title_or_short":
473:
474: if len(obj.getContent('xdata_07'))<3: # hack weil z.Z. manchmal noch ein Trennzeichen ; oder , im Feld statt leer
475: fieldNameTmp="WEB_title"
476: else:
477: fieldNameTmp="xdata_07"
478: else:
479: fieldNameTmp=fieldName
480:
481: ret.append((obj,obj.getContent(fieldNameTmp)))
482:
483:
484: if sort=="int":
485: ret.sort(sortI)
486: else:
487: ret.sort(sortF)
488:
489: return ret
490:
491: def showNewProjects(self):
492: projects=[]
493: for objs in self.getProjectFields('WEB_title_or_short'): # Get all Projets
494: if objs[0].xdata_05[0] == "":
495:
496: projects.append(objs)
497:
498: return projects
499:
500:
501: manage_options = Folder.manage_options+(
502: {'label':'Update Personal Homepages','action':'updateHomepages'},
503: {'label':'Main config','action':'changeMPIWGRootForm'},
504: {'label':'Edit Historical Persons','action':'editHistoricalPersonsForm'},
505: {'label':'Store Historical Persons','action':'storeHistoricalPersons'},
506: )
507:
508: def importNamesForm(self):
509: """Form"""
510: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGNamesForm.zpt')).__of__(self)
511: return pt()
512:
513: def importNames(self,fileupload,folderName,RESPONSE=None):
514: """import komma-sep list email,lastName,firstName"""
515: project=getattr(self,folderName)
516: load=fileupload.read()
517:
518: for line in load.split('\r'):
519:
520:
521: splitted=line.split(",")
522: # print splitted
523:
524: if not (splitted[0]==""):
525: newObj=MPIWGStaff.MPIWGStaff(splitted[0],splitted[1],splitted[2])
526:
527: try:
528: project._setObject(splitted[0],newObj)
529: #print "done:",splitted[0]
530: except:
531: zLOG.LOG("MPIWG Web (importNames)",zLOG.INFO,"cannot import: %s"%splitted[0])
532:
533:
534: if RESPONSE is not None:
535: RESPONSE.redirect('manage_main')
536:
537: def updateHomepages(self,RESPONSE):
538: """lege members an"""
539:
540: self.upDateSQL('personalwww.xml')
541: founds=self.ZSQLInlineSearch(_table='personal_www',publish_the_data='yes')
542: project=getattr(self,'members')
543: for found in founds:
544:
545: if not (found.e_mail==""):
546: newObj=MPIWGStaff.MPIWGStaff(found.username,found.name,found.vorname)
547:
548: try:
549: project._setObject(found.username,newObj)
550: RESPONSE.write("<p>new:%s</p>\n"%found.username)
551: except:
552: RESPONSE.write("<p>old:%s (%s,%s)</p>\n"%(found.username,found.name,found.vorname))
553:
554:
555: #delete non existing
556:
557:
558: foundUserNames=[x.username for x in founds]
559: for member in self.ZopeFind(self,obj_metatypes=["MPIWGStaff"],search_sub=1):
560:
561: if member[1].getId() not in foundUserNames:
562: member[1].aq_parent.manage_delObjects(ids=[member[1].getId()])
563: RESPONSE.write("<p>deleted:%s</p>\n"%member[1].getId())
564: try:
565: self.MembersCatalog.manage_catalogReindex(self.REQUEST,RESPONSE,self.REQUEST['URL1'])
566: except:
567: pass
568: self.ProjectCatalog.manage_catalogReindex(self.REQUEST,RESPONSE,self.REQUEST['URL1'])
569:
570:
571: if RESPONSE is not None:
572: RESPONSE.redirect('manage_main')
573:
574:
575: def getAllMembers(self):
576: """give list of all members"""
577: ret=[]
578:
579: #for x in self.members.objectValues('MPIWGStaff'):
580: #print x.title
581: # ret.append(x.title.decode('utf-8'))
582:
583: for x in self.ZopeFind(self.members,obj_metatypes=['MPIWGStaff']):
584: ret.append(x[1].title.decode('utf-8'))
585:
586: ret.sort()
587: #print ret
588:
589: return ret
590:
591: def printAllMembers(self):
592: """prin"""
593: members=self.getAllMembers()
594: ret=""
595: for x in members:
596: ret+="<p>%s</p>"%x
597: return ret
598:
599:
600: def makeList(self,entry):
601: """makes a list out of one entry or repeat a list"""
602: if type(entry) is StringType:
603: return [entry]
604: else:
605: return entry
606:
607:
608: def getTree(self):
609: """generate Tree from project list"""
610: returnList=[]
611: for project in self.getProjectFields('xdata_05',sort="int"): # get Projects sorted by xdata_05
612:
613: for idNr in project[1].split(";"): # more than one number
614: if not idNr=="":
615: splittedId=idNr.split(".")
616: depth=len(splittedId)
617: nr=idNr
618: #title=project[0].WEB_title
619: title=[project[0].getContent('WEB_title')]
620: #print title
621: returnList.append((depth,nr,title,project[0]))
622:
623: return returnList
624:
625: def formatElementsAsList(self,elements):
626: """formatiere tree als liste"""
627:
628: actualDepth=0
629: ret=""
630: for element in elements:
631: if (element[0]>actualDepth):
632: #fuege soviele ul ein wie unterschied in tiefe
633: if element[0]==1:
634: ret+="""<div class="dept">\n"""
635: else:
636: for i in range(element[0]-actualDepth):
637: ret+="</li>\n<li><ul>\n"
638:
639: actualDepth=element[0]
640:
641: elif (element[0]<actualDepth):
642: #fuege soviele /ul ein wie unterschied in tiefe
643: for i in range(-element[0]+actualDepth):
644: ret+="<br><br></li></ul></li>\n"
645:
646: if element[0]==1:
647: department=int(element[3].getContent('xdata_05'))-1
648:
649: ret+="""</div>\n"""
650: ret+="""<div class="bildspalte"><img src="../grafik/dept%i.jpg" width="160" height="120" vspace="40"></div>
651: <div class="dept">\n<ul>\n
652: """%department
653:
654: actualDepth=element[0]
655: else:
656: ret+="""</li>\n"""
657: ret+="""<li>\n"""
658:
659: if actualDepth==1:
660: departmentName={'1':'Department I','2':'Department II','3':'Department III', '4':'NWG','5':'NWG'}
661: department=element[3].getContent('xdata_05')
662: ret+="""<img src="../grafik/totop.gif" vspace="10" border="0"></a><br><a name="dept%s"></a>%s: """%(department,departmentName[department])
663:
664: ret+="""<a href="%s">%s</a>"""%(element[3].absolute_url()+"/index.html",element[3].getContent('WEB_title'))
665: return ret
666:
667: def formatElementForOverview(self,element):
668: """format the element for output in overview"""
669: if element[0]==1: #department
670: #print element[3].getContent('xdata_05')
671: if element[3].getContent('xdata_05') == "4":
672: return """<h2 class="hier"><a href="%s">Ind. Research Group I: %s</a></h2>"""%(element[3].absolute_url()+"/index.html",element[3].getContent('WEB_title'))
673: if element[3].getContent('xdata_05') == "5":
674: return """<h2 class="hier"><a href="%s">Ind. Research Group II: %s</a></h2>"""%(element[3].absolute_url()+"/index.html",element[3].getContent('WEB_title'))
675:
676: return """<h2 class="hier"><a href="%s">Department %s: %s</a></h2>"""%(element[3].absolute_url()+"/index.html",element[3].getContent('xdata_05'),element[3].getContent('WEB_title'))
677:
678: elif element[0]==2: #mainprojects
679: return """<h3 class="hier"><a href="%s">%s</a></h3><p>"""%(element[3].absolute_url()+"/index.html",element[3].getContent('WEB_title'))
680:
681: elif element[0]==3:
682: return """<p class="hier"><a href="%s">%s</a></p>"""%(element[3].absolute_url()+"/index.html",element[3].getContent('WEB_title'))
683:
684:
685: def changePosition(self,treeId,select,RESPONSE=None):
686: """Change Postion Entry"""
687: numbers=[]
688:
689: # Suche hoechste bisherige nummer
690: projects=self.getProjectFields('xdata_05') # get Projects sorted by xdata_05
691: #print "pj",projects
692: for project in projects: #suche alle subtrees der treeId
693: #print treeId
694:
695: founds=re.match(treeId+"\.(.*)",project[1].split(";")[0])
696: if founds:
697: #print "x",founds.group(0),len(founds.group(0).split("."))
698: if len(founds.group(0).split("."))==len(treeId.split("."))+1: # nur ein punkt mehr, d.h. untere ebene
699: try:
700: numbers.append(int(founds.group(0).split(".")[len(founds.group(0).split("."))-1]))
701: except:
702: numbers.append(int(0))
703:
704: try:
705: highest=max(numbers)
706: except:
707: highest=0
708: projects=self.showNewProjects()
709: for i in self.makeList(select):
710: highest+=10
711: projects[int(i)][0].xdata_05=treeId+"."+str(highest)
712:
713:
714: if RESPONSE is not None:
715: RESPONSE.redirect('showTree')
716:
717: def changeTree(self,RESPONSE=None):
718: """change the complete tree"""
719: form=self.REQUEST.form
720: hashList={}
721: fields=self.getTree()
722:
723:
724: for idNr in form.keys():
725: fields[int(idNr)][3].xdata_05=form[idNr]
726:
727:
728:
729: if RESPONSE is not None:
730: RESPONSE.redirect('showTree')
731:
732: def getProjectWithId(self,id):
733: fields=self.getProjectFields('xdata_05')
734: for field in fields:
735: if field[1]==id:
736: return field[0]
737:
738: return None
739:
740:
741:
742:
743: def getRelativeUrlFromPerson(self,list):
744: """get urls to person list"""
745: ret=[]
746: persons=list.split(";")
747: for person in persons:
748:
749: if len(person)>1: #nicht nur Trennzeichen
750: splitted=person.split(",")
751: if len(splitted)==1:
752: splitted=person.split(" ")
753: splittedNew=[re.sub(r'\s(.*)','$1',split) for split in splitted]
754: if splittedNew[0]=='':
755: del splittedNew[0]
756: search=string.join(splittedNew,' AND ')
757:
758: if not search=='':
759:
760: try:
761: proj=self.MembersCatalog({'title':search})
762: except:
763: proj=None
764:
765: if proj:
766: #ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url,person.encode('utf-8')))
767: ret.append("<a href=%s >%s</a>"%('members/'+proj[0].id+'/index.html',person))
768: else:
769: #ret.append("%s"%person.encode('utf-8'))
770: ret.append("%s"%person)
771: return string.join(ret,";")
772:
773:
774: def getUrlFromPerson(self,list):
775: """get urls to person list"""
776: ret=[]
777: persons=list.split(";")
778: for person in persons:
779:
780: if len(person)>1: #nicht nur Trennzeichen
781: splitted=person.split(",")
782: if len(splitted)==1:
783: splitted=person.lstrip().rstrip().split(" ")
784: splittedNew=[re.sub(r'\s(.*)','$1',split) for split in splitted]
785: if splittedNew[0]=='':
786: del splittedNew[0]
787: search=string.join(splittedNew,' AND ')
788:
789: if not search=='':
790:
791: try:
792: proj=self.MembersCatalog({'title':search})
793: except:
794: proj=None
795:
796: if proj:
797: if person =="Otto Sibum" : person="H. Otto Sibum"
798: if person =="Norton Wise" : person="M. Norton Wise"
799: #ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url,person.encode('utf-8')))
800: ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url+"/index.html",person))
801: else:
802: #ret.append("%s"%person.encode('utf-8'))
803: ret.append("%s"%person)
804: return string.join(ret,";")
805:
806: def getProjectsOfMembers(self):
807: """give tuple member /projects"""
808: ret=[]
809: members=self.getAllMembers()
810: #return str(members)
811: for x in members:
812: ret+=self.getProjectsOfMember(name=x)
813:
814: return ret
815:
816: def getProjectsOfMember(self,name=None,email=None):
817: """get project of a member"""
818: def sortP(x,y):
819: """sort by sorting number"""
820: #print x.xdata_05,y.xdata_05
821: return cmp(x.WEB_title,y.WEB_title)
822:
823:
824: ret=[]
825: splitNeu=[]
826: if email:
827: print "IIII:",self.getId()
828: members=self.ZopeFind(self.members,obj_metatypes=['MPIWGStaff'],obj_ids=[email],search_sub=1)
829: name = members[0][1].title.decode('utf-8')
830:
831: y=name
832: splitted=y.split(",")
833: #XXXX
834: splitNeu=["\'"+splitted[1]+" "+splitted[0]+"\'"]
835:
836: #for s in splitted:
837: # splitNeu.append("\""+s+"\"")
838: search=string.join(splitNeu,' AND ')
839:
840: proj=self.ProjectCatalog({'xdata_01':search})
841:
842: if proj:
843: proj2=[]
844: for x in proj:
845:
846: if not getattr(x.getObject(),'invisible',None):
847: if not((splitted[1]==" Christoph") and (splitted[0]=="Hoffmann") and (str(x.WEB_title).find('Einstein')>0)):
848: proj2.append(x)
849:
850: else:
851: proj2=[]
852:
853: proj=self.ProjectCatalog({'xdata_08':search})
854: if proj:
855: names=[x.WEB_title for x in proj]
856: for x in proj:
857:
858: if not x.WEB_title in names:
859: proj2.append(x)
860:
861:
862: proj2.sort(sortP)
863:
864: if len(proj2)>0:
865: ret.append((y,proj2))
866:
867: return ret
868:
869: def givePersonList(self,name):
870: """check if person is in personfolder and return list of person objects"""
871:
872: splitted=name.split(",")
873: if len(splitted)==1:
874: splitted=name.lstrip().rstrip().split(" ")
875: splittedNew=[split.lstrip() for split in splitted]
876:
877: if splittedNew[0]=='':
878: del splittedNew[0]
879: search=string.join(splittedNew,' AND ')
880: if not search=='':
881: proj=self.MembersCatalog({'title':search})
882:
883: if proj:
884: return [[x.lastName,x.firstName] for x in proj]
885: else:
886: return []
887:
888: ## splitted=name.split(",") # version nachname, vorname...
889: ## if len(splitted)>1:
890: ## lastName=splitted[0]
891: ## firstName=splitted[1]
892: ## else:
893: ## splitted=name.split(" ") #version vorname irgenwas nachnamae
894:
895: ## lastName=splitted[len(splitted)-1]
896: ## firstName=string.join(splitted[0:len(splitted)-1])
897:
898: ## objs=[]
899:
900: #print self.members
901: ## for x in self.members.__dict__:
902: ## obj=getattr(self.members,x)
903: ## if hasattr(obj,'lastName') and hasattr(obj,'firstName'):
904:
905: ## if (re.match(".*"+obj.lastName+".*",lastName) or re.match(".*"+lastName+".*",obj.lastName)) and (re.match(".*"+obj.firstName+".*",firstName) or re.match(".*"+firstName+".*",obj.firstName)):
906:
907: ## objs.append((obj,lastName+", "+firstName))
908:
909:
910: return objs
911:
912:
913: def personCheck(self,names):
914: """all persons for list"""
915: #print "names",names
916: splitted=names.split(";")
917: ret={}
918: for name in splitted:
919:
920: if not (name==""):
921: try:
922: ret[name]=self.givePersonList(name)
923: except:
924: """NOTHIHN"""
925: #print "RET",ret
926: return ret
927:
928: def giveCheckList(self,person,fieldname):
929: """return checklist"""
930: #print "GCL",fieldname
931: if fieldname=='xdata_01':
932: x=self.personCheck(person.getContent(fieldname))
933: #print "GCLBACKX",x
934: return x
935:
936:
937: def isCheckField(self,fieldname):
938: """return chechfield"""
939:
940: return (fieldname in checkFields)
941:
942:
943:
944:
945:
946: def manage_addMPIWGRootForm(self):
947: """form for adding the root"""
948: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMPIWGRootForm.zpt')).__of__(self)
949: return pt()
950:
951: def manage_addMPIWGRoot(self,id,title,connection_id="",RESPONSE=None):
952: """add a root folder"""
953: newObj=MPIWGRoot(id,title)
954: self._setObject(id,newObj)
955: ob=getattr(self,id)
956: setattr(ob,'connection_id',connection_id)
957: if RESPONSE is not None:
958: RESPONSE.redirect('manage_main')
959:
960:
961: class MPIWGProject(CatalogAware,Folder):
962: """Class for Projects"""
963:
964: meta_type='MPIWGProject'
965: default_catalog='ProjectCatalog'
966:
967: def PrincipiaSearchSource(self):
968: """Return cataloguable key for ourselves."""
969: return str(self)
970:
971: def versionHeader(self):
972: """version Header, gibt header text entsprechend der aktuellen version aus"""
973:
974: actualTime=time.localtime()
975: retTXT="""<h2>This is an outdated version, for the actual version please refer to <a href="%s">%s</a></h2>"""
976: s=self.aq_parent.absolute_url()
977: #print getattr(self,'archiveTime',actualTime)
978: if getattr(self,'archiveTime',actualTime)< actualTime:
979: return retTXT%(s,s)
980: else:
981: return ""
982: def isActual(self):
983: """gibt 1 zurueck wenn aktuell, 0 sonst"""
984: actualTime=time.localtime()
985:
986:
987: #print getattr(self,'archiveTime',actualTime)
988: if getattr(self,'archiveTime',actualTime)< actualTime:
989: return 0
990: else:
991: return 1
992:
993: def copyObjectToArchive(self):
994: """kopiere aktuelles objekt ins archiv"""
995: cb=self.aq_parent.manage_copyObjects(self.getId())
996: self.manage_pasteObjects(cb)
997: actualTime=time.localtime()
998:
999: self.manage_renameObject(self.getId(),self.getId()+"_"+time.strftime("%Y%m%d%H%M%S",actualTime))
1000: obj=getattr(self,self.getId()+"_"+time.strftime("%Y%m%d%H%M%S",actualTime))
1001: obj.setArchiveTime(time.strftime("%Y%m%d%H%M%S",actualTime))
1002: ids=[x[0] for x in self.ZopeFind(obj,obj_metatypes=['MPIWGProject'])]
1003: obj.manage_delObjects(ids)
1004:
1005: def setArchiveTime(self,time):
1006: """set Archive Time"""
1007: self.archiveTime=time[0:]
1008:
1009: def versionManageForm(self):
1010: """version Manage form:currently only set to invisible"""
1011: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_versionManageForm.zpt')).__of__(self)
1012: return pt()
1013:
1014: def versionManage(self,invisible=None,RESPONSE=None):
1015: """version Manage form:currently only set to invisible"""
1016: self.invisible=invisible
1017:
1018: if RESPONSE is not None:
1019: RESPONSE.redirect('manage_main')
1020:
1021:
1022: def crossLinker(self):
1023: """experimental crosslinker"""
1024: splitted=self.WEB_project_description[0].split()
1025: new=[]
1026: for split in splitted:
1027: try:
1028: found=self.DescriptionCatalog({'fulltext':split})
1029:
1030: if len(found)>1:
1031:
1032: new.append("<a href=%s>%s</a>"%(split,split))
1033: else:
1034: new.append(split)
1035: except:
1036: new.append(split)
1037: return string.join(new)
1038:
1039:
1040:
1041:
1042: def generateTemplate(self,RESPONSE=None):
1043: """Erzeuge Template für defined fields not_used"""
1044:
1045: id="index_html"
1046: title=id
1047: if self._getOb('index_html'):
1048: self._delObject('index_html')
1049:
1050:
1051: newObj=ZopePageTemplate(id,'TEXT')
1052: self._setObject(id,newObj)
1053: #self.manage_addPageTemplate(id,title)
1054: if RESPONSE is not None:
1055: RESPONSE.redirect('manage_main')
1056:
1057: def __init__(self, id, argv=None):
1058: """initieriere classe"""
1059:
1060: self.id=id
1061: self.title=id
1062: if argv:
1063: for arg in definedFields:
1064: try:
1065: setattr(self,arg,argv[arg])
1066: except:
1067: setattr(self,arg,"")
1068: else:
1069: for arg in definedFields:
1070: setattr(self,arg,'')
1071:
1072: manage_options = Folder.manage_options+(
1073: {'label':'Load New File','action':'loadNewFileForm'},
1074: {'label':'Edit ProjectInfo','action':'editMPIWGProjectForm'},
1075: {'label':'Edit BasisInfo','action':'editMPIWGBasisForm'},
1076: {'label':'Edit Publications','action':'editMPIWGRelatedPublicationsForm'},
1077: {'label':'Edit Themes & Disciplines','action':'editMPIWGDisciplinesThemesForm'},
1078: {'label':'Versionmanager','action':'versionManageForm'},
1079: )
1080:
1081:
1082: def checkDate(self,date):
1083: """teste ob zum Zeitpunkt date eine andere version existierte"""
1084:
1085:
1086: def sortProjectsByTime(x,y):
1087: return cmp(x[1].archiveTime,y[1].archiveTime)
1088:
1089: finds=self.ZopeFind(self,obj_metatypes=['MPIWGProject'])
1090: if not finds:
1091: return self.absolute_url()
1092: else:
1093: finds.sort(sortProjectsByTime)
1094:
1095: for find in finds:
1096: if int(find[1].archiveTime) > int(date):
1097: return find[1].absolute_url()
1098:
1099: return self.absolute_url()
1100:
1101:
1102:
1103: def index_html(self):
1104: """show homepage"""
1105:
1106: if self.REQUEST.has_key('date') and self.REQUEST.SESSION.get('MPI_redirected',None)==None:
1107: self.REQUEST.SESSION['MPI_redirected']=1
1108: self.REQUEST.RESPONSE.redirect(self.checkDate(self.REQUEST['date']))
1109: else:
1110: self.REQUEST.SESSION['MPI_redirected']=None
1111:
1112: ext=self.ZopeFind(self.aq_parent,obj_ids=["project_main"])
1113:
1114: if ext:
1115: return getattr(self,ext[0][1].getId())()
1116:
1117: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','project_main')).__of__(self)
1118: return pt()
1119:
1120:
1121: def getDataFields(self):
1122: """giveListofDatafields"""
1123: ret=[]
1124: for x in range(1,14):
1125: if not x in [6,10,9]: # not used fields
1126: ret.append('xdata_%02i'%x)
1127: return ret
1128:
1129: def getDefinedFields(self):
1130: """show all defined fields"""
1131:
1132: return definedFields
1133:
1134: def getAttribute(self,field):
1135: """get attrbiute"""
1136: return getattr(self,field)
1137:
1138: def getContent(self,field):
1139: """Inhalt des Feldes"""
1140:
1141: text=u''
1142:
1143: for x in getattr(self,field):
1144:
1145: try:
1146: text +=x
1147: except:
1148: text = x
1149:
1150:
1151:
1152: try:
1153: if text[len(text)-1]==";":
1154: text=text[0:len(text)-1]
1155:
1156:
1157: except:
1158: pass
1159:
1160: if text=='':
1161: text2=text
1162: else:
1163: text2=re.sub(r';([^\s])','; \g<1>',text)
1164:
1165: #teste ob ergebnis leer und header dann nehme title
1166:
1167: if (text2=='') and (field=='WEB_project_header'):
1168: return self.getContent('WEB_title')
1169:
1170: #teste ob WEB_project_description und keine führenden p tags
1171: if (len(text2)>4) and (not text2[0:3]=='<p>') and (field=='WEB_project_description'):
1172: return "<p>"+text2+"</p>"
1173:
1174:
1175: return text2.encode('utf-8')
1176:
1177: def show_html(self):
1178: """simple index"""
1179: #return "HI"
1180: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_index.zpt')).__of__(self)
1181: return pt()
1182:
1183: def editMPIWGProjectForm(self):
1184: """editform"""
1185: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGProject.zpt')).__of__(self)
1186: return pt()
1187:
1188: def editMPIWGProject(self,RESPONSE=None):
1189: """edit the project and archive the old version"""
1190:
1191: self.copyObjectToArchive() # archive the object
1192:
1193:
1194: for x in definedFields:
1195: if self.REQUEST.has_key(x):
1196:
1197: setattr(self,x,[self.REQUEST[x].decode('utf-8')])
1198:
1199:
1200:
1201: if RESPONSE is not None:
1202: RESPONSE.redirect('manage_main')
1203:
1204: def editMPIWGDisciplinesThemesForm(self):
1205: """edit the disciplines and themes Form"""
1206: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGDisciplinesThemes.zpt')).__of__(self)
1207: return pt()
1208:
1209: def editMPIWGDisciplinesThemes(self,disciplines=None,themes=None,RESPONSE=None):
1210: """edit disciplin and form"""
1211: if disciplines:
1212: if type(disciplines) is StringType:
1213: self.xdata_09=disciplines
1214: else:
1215: self.xdata_09=string.join(disciplines,";")
1216: else:
1217: self.xdata_09=""
1218: if themes:
1219: if type(themes) is StringType:
1220: self.xdata_10=themes
1221: else:
1222: self.xdata_10=string.join(themes,";")
1223: else:
1224: self.xdata_10=""
1225:
1226: if RESPONSE is not None:
1227: RESPONSE.redirect('manage_main')
1228:
1229:
1230: def isChecked(self,wert,list):
1231: """check if wert is in ; seperated list"""
1232:
1233: #felder sind manchmnal als liste mit einem element definiert
1234: if type(list) is StringType or UnicodeType:
1235: splitted=list.split(";")
1236: else:
1237: splitted=list[0].split(";")
1238:
1239:
1240: for x in splitted:
1241: if (not x==u'') and x in wert:
1242: return 1
1243: return 0
1244:
1245: def editMPIWGBasisForm(self):
1246: """editform"""
1247: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGBasis.zpt')).__of__(self)
1248: return pt()
1249: def editMPIWGRelatedPublicationsForm(self):
1250: """Edit related Publications"""
1251: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGRelatedPublications.zpt')).__of__(self)
1252: return pt()
1253:
1254:
1255: def loadNewFileForm(self):
1256: """Neues XML-File einlesen"""
1257: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_newfile.zpt')).__of__(self)
1258: return pt()
1259:
1260: def loadNewFile(self,RESPONSE=None):
1261: """einlesen des neuen files"""
1262: fileupload=self.REQUEST['fileupload']
1263: if fileupload:
1264: file_name=fileupload.filename
1265: filedata=fileupload.read()
1266:
1267: argv=xmlhelper.proj2hash(filedata)
1268: #print argv.keys()
1269: for arg in definedFields:
1270:
1271: #print arg,argv[arg],getattr(self,arg)
1272: try:
1273: temp=argv[arg][0:]
1274: #old=getattr(self,arg)
1275: setattr(self,arg,temp)
1276: #print old,getattr(self,arg)
1277: except:
1278: """nothing"""
1279:
1280: if RESPONSE is not None:
1281: RESPONSE.redirect('manage_main')
1282:
1283: def manage_addMPIWGProjectForm(self):
1284: """form for adding the project"""
1285: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMPIWGProjectForm.zpt')).__of__(self)
1286: return pt()
1287:
1288: def manage_addMPIWGProject(self,id,RESPONSE=None):
1289: """method to add a project"""
1290: #print argv
1291: fileupload=self.REQUEST.get('fileupload',None)
1292: if fileupload:
1293:
1294: file_name=fileupload.filename
1295: filedata=fileupload.read()
1296:
1297: argv=xmlhelper.proj2hash(filedata)
1298:
1299: #print argv
1300: newObj=MPIWGProject(id,argv)
1301: else:
1302: newObj=MPIWGProject(id)
1303:
1304: self._setObject(id,newObj)
1305:
1306:
1307: if RESPONSE is not None:
1308: 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