1: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
2: from Products.PageTemplates.PageTemplate import PageTemplate
3: from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
4: from Products.ZSQLExtend.ZSQLExtend import ZSQLExtendFolder
5: from Products.ZCatalog.CatalogPathAwareness import CatalogAware
6: from OFS.Image import Image
7: from Globals import package_home
8: import urllib
9: import MPIWGStaff
10: import string
11: import re
12: import os
13: from types import *
14: import logging
15: import xmlhelper # Methoden zur Verwaltung der projekt xml
16: from OFS.SimpleItem import SimpleItem
17: from OFS.Folder import Folder
18: from Products.ZSQLMethods.SQL import SQLConnectionIDs
19: from AccessControl import ClassSecurityInfo
20: from bibliography import *
21: import time
22: import xml.dom.minidom
23: import sys
24: from Ft.Xml.XPath import Evaluate
25: from Ft.Xml.XPath.Context import Context
26: from Ft.Xml.Domlette import NonvalidatingReader,PrettyPrint, Print
27: from Ft.Xml import EMPTY_NAMESPACE
28: import copy
29: import updatePersonalWWW
30: import MPIWGStaff
31: from MPIWGHelper import *
32:
33: class MPIWGRoot(ZSQLExtendFolder):
34: """Stammordner fuer den Web-Server"""
35:
36: fieldLabels={'WEB_title':'WEB_Title','xdata_01':'Responsible Scientists','xdata_02':'Department',
37: 'xdata_03':'Historical Persons','xdata_04':'Time period',
38: 'xdata_05':'Sorting number','xdata_06':'Keywords','xdata_07':'Short title',
39: 'xdata_08':'Other involved scholars' ,'xdata_09':'Disciplines','xdata_10':'Themes',
40: 'xdata_11':'Object Digitallibrary','xdata_12':'Cooperation partners',
41: 'xdata_13':'Funding institutions','WEB_project_header':'WEB_project_header',
42: 'WEB_project_description':'WEB_project_description','WEB_related_pub':'WEB_related_pub'}
43:
44: folders=['MPIWGProject','Folder','ECHO_Navigation']
45: meta_type='MPIWGRoot'
46:
47: def transformProjectsToId(self):
48: """trnasformiere zu ID, Hilfsfunktion die die alten Templates analysiert und mit der neuen Liste
49: verantwortlicher Personen versieht"""
50: projects=self.getTree()
51: ret=""
52: for project in projects:
53: proj=project[3]
54: persons=proj.identifyNames(proj.getContent('xdata_01'))
55: if not hasattr(proj,'responsibleScientistsList'):
56: proj.responsibleScientistsList=[]
57:
58: for person in persons.items():
59:
60: if len(person[1]) >1: #nicht eindeutig
61: ret+="nicht eindeutig --- %s: %s\n"%(proj.getId(),person[0])
62:
63: elif len(person[1]) ==0: #kein eintrage
64: ret+="kein eintrag--- %s: %s\n"%(proj.getId(),person[0])
65: proj.responsibleScientistsList.append((person[0],""))
66: else:
67: proj.responsibleScientistsList.append((person[0],person[1][0].getObject().getKey()))
68:
69: return ret
70:
71:
72: def harvestProjects(self):
73: """harvest"""
74: folder="/tmp"
75: try:
76: os.mkdir("/tmp/harvest_MPIWG")
77: except:
78: pass
79: founds=self.ZopeFind(self.aq_parent.projects,obj_metatypes=['MPIWGProject'],search_sub=1)
80: for found in founds:
81: txt=found[1].harvest_page()
82:
83: if txt and (txt != ""):
84: name=found[0].replace("/","_")
85: fh=file("/tmp/harvest_MPIWG/"+name,"w")
86: fh.write(txt)
87: fh.close()
88:
89: def decode(self,str):
90: """decoder"""
91:
92: if not str:
93: return ""
94: if type(str) is StringType:
95: try:
96: return str.decode('utf-8')
97: except:
98: return str.decode('latin-1')
99: else:
100: return str
101:
102:
103: def getat(self,array,idx=0,default=None):
104: """return array element idx or default (but no exception)"""
105: if len(array) <= idx:
106: return default
107: else:
108: return array[idx]
109:
110:
111: def browserCheck(self):
112: """check the browsers request to find out the browser type"""
113: bt = {}
114: ua = self.REQUEST.get_header("HTTP_USER_AGENT")
115: bt['ua'] = ua
116: bt['isIE'] = False
117: bt['isN4'] = False
118: if string.find(ua, 'MSIE') > -1:
119: bt['isIE'] = True
120: else:
121: bt['isN4'] = (string.find(ua, 'Mozilla/4.') > -1)
122:
123: try:
124: nav = ua[string.find(ua, '('):]
125: ie = string.split(nav, "; ")[1]
126: if string.find(ie, "MSIE") > -1:
127: bt['versIE'] = string.split(ie, " ")[1]
128: except: pass
129:
130: bt['isMac'] = string.find(ua, 'Macintosh') > -1
131: bt['isWin'] = string.find(ua, 'Windows') > -1
132: bt['isIEWin'] = bt['isIE'] and bt['isWin']
133: bt['isIEMac'] = bt['isIE'] and bt['isMac']
134: bt['staticHTML'] = False
135:
136: return bt
137:
138:
139: def versionHeaderEN(self):
140: """version header text"""
141:
142: date= self.REQUEST.get('date',None)
143: if date:
144: txt="""<h2>This pages shows the project which existed at %s</h2>"""%str(date)
145: return txt
146: return ""
147:
148: def versionHeaderDE(self):
149: """version header text"""
150: date= self.REQUEST.get('date',None)
151: if date:
152: txt="""<h2>Auf dieser Seite finden Sie die Projekte mit Stand vom %s</h2>"""%str(date)
153: return ""
154:
155:
156: def createOrUpdateId_raw(self):
157: """create sequence to create ids for bibliography"""
158: debug=None
159: #suche groesste existierende id
160: founds=self.ZSQLQuery("select id from bibliography")
161:
162: if founds:
163: ids=[int(x.id[1:]) for x in founds]
164: maximum=max(ids)
165:
166: id_raw=self.ZSQLQuery("select nextval('id_raw')",debug=debug)
167:
168: if id_raw:
169: self.ZSQLQuery("drop sequence id_raw",debug=debug)
170:
171: self.ZSQLQuery("create sequence id_raw start %i"%(maximum+1),debug=debug)
172:
173:
174: def queryLink(self,link):
175: """append querystring to the link"""
176: return "%s?%s"%(link,self.REQUEST.get('QUERY_STRING',''))
177:
178: def getKategory(self,url):
179: """kategorie"""
180: splitted=url.split("/")
181: return splitted[4]
182:
183: def generateUrlProject(self,url,project=None):
184: """erzeuge aus absoluter url, relative des Projektes"""
185: if project:
186: splitted=url.split("/")
187: length=len(splitted)
188: short=splitted[length-2:length]
189:
190: base=self.REQUEST['URL3']+"/"+"/".join(short)
191:
192: else:
193: findPart=url.find("/projects/")
194: base=self.REQUEST['URL1']+"/"+url[findPart:]
195:
196:
197: return base
198:
199: def isNewCapital(self,text=None,reset=None):
200: if reset:
201: self.REQUEST['capital']="A"
202: return True
203: else:
204: if len(text)>0 and not (text[0]==self.REQUEST['capital']):
205: self.REQUEST['capital']=text[0]
206: return True
207: else:
208: return False
209:
210: def subNavStatic(self,obj):
211: """subnav" von self"""
212: def sortWeight(x,y):
213: x1=int(getattr(x[1],'weight','0'))
214: y1=int(getattr(y[1],'weight','0'))
215: return cmp(x1,y1)
216:
217: subs=self.ZopeFind(obj,obj_metatypes=['MPIWGTemplate','MPIWGLink'])
218: subret=[]
219:
220: for x in subs:
221: if not(x[1].title==""):
222: subret.append(x)
223: subret.sort(sortWeight)
224: return subret
225:
226: def subNav(self,obj):
227: """return subnav elemente"""
228: def sortWeight(x,y):
229: x1=int(getattr(x[1],'weight','0'))
230: y1=int(getattr(y[1],'weight','0'))
231: return cmp(x1,y1)
232: #if obj.meta_type in ['MPIWGTemplate','MPIWGLink']:
233: # id=obj.aq_parent.getId()
234: #else:
235:
236: #id=obj.getId()
237:
238:
239: #suche die zweite ebene
240:
241: if not obj.aq_parent.getId() in ['de','en']:
242: obj=obj.aq_parent
243:
244: while not self.ZopeFind(self,obj_ids=[obj.getId()]):
245: obj=obj.aq_parent
246:
247:
248: if hasattr(self,obj.getId()):
249:
250: subs=self.ZopeFind(getattr(self,obj.getId()),obj_metatypes=['MPIWGTemplate','MPIWGLink'])
251: subret=[]
252:
253: for x in subs:
254: if not(x[1].title==""):
255: subret.append(x)
256: subret.sort(sortWeight)
257: return subret
258: else:
259: return None
260:
261: def isActive(self,name):
262: """teste ob subnavigation aktiv"""
263: for part in self.REQUEST['URL'].split("/"):
264: if part==name:
265: return True
266: return False
267:
268: def getSection(self):
269: """returns the current section name"""
270: root = self.absolute_url()
271: url = self.REQUEST['URL']
272: if not url:
273: return None
274: path = string.replace(url, root, '')
275: paths = path.split('/')
276: if len(paths) > 0:
277: sec = paths[1]
278: if sec.find('.') < 0:
279: return sec
280: else:
281: return None
282: return None
283:
284: def getSectionStyle(self, name, style=""):
285: """returns a string with the given style + '-sel' if the current section == name"""
286: if self.getSection() == name:
287: return style + '-sel'
288: else:
289: return style
290:
291: def MPIWGrootURL(self):
292: """returns the URL to the root"""
293: return self.absolute_url()
294:
295: def upDateSQL(self,fileName):
296: """updates SQL databases using fm.jar"""
297: fmJarPath=os.path.join(package_home(globals()), 'updateSQL/fm.jar')
298: xmlPath=os.path.join(package_home(globals()), "updateSQL/%s"%fileName)
299: logger("MPIWG Web",logging.INFO,"java -classpath %s -Djava.awt.headless=true Convert %s"%(fmJarPath,xmlPath))
300: ret=os.popen("java -classpath %s -Djava.awt.headless=true Convert %s"%(fmJarPath,xmlPath),"r").read()
301: logger("MPIWG Web",logging.INFO,"result convert: %s"%ret)
302: return 1
303:
304: def patchProjects(self,RESPONSE):
305: """patch"""
306: projects=self.ZopeFind(self.projects,obj_metatypes=['MPIWGProject'])
307: for project in projects:
308: tmp=project[1].WEB_project_description[0].replace("/CD/projects/","")[0:]
309: setattr(project[1],'WEB_project_description',[tmp[0:]])
310: RESPONSE.write("<p>%s</p>\n"%project[0])
311:
312: def replaceNotEmpty(self,format,field):
313: """replace not empty"""
314: if field and (not field.lstrip()==''):
315: return self.decode(format%field)
316: else:
317: return ""
318:
319:
320: def isActiveMember(self,key):
321: """tested ob Mitarbeiter key ist aktiv"""
322: ret=self.getat(self.ZSQLInlineSearch(_table='personal_www',
323: _op_key='eq',key=key,
324: _op_publish_the_data='eq',
325: publish_the_data='yes'))
326:
327: logging.info("ACTIVE_MEMBER %s"%ret)
328: if ret:
329: return True
330: else:
331: return False
332:
333: def isActual(self,project):
334: """checke if project is actual"""
335: actualTime=time.localtime()
336:
337: if hasattr(project,'getObject'): #obj ist aus einer catalogTrefferList
338: obj=project.getObject()
339: else:
340: obj=project
341:
342: if getattr(obj,'archiveTime',actualTime)< actualTime:
343: return False
344: else:
345: return True
346:
347: def redirectIndex_html(self,request):
348: #return request['URL1']+'/index_html'
349:
350: return urllib.urlopen(request['URL1']+'/index_html').read()
351:
352:
353: def formatBibliography(self,here,found):
354: """format"""
355: return formatBibliography(here,found)
356:
357: def getValue(self,fieldStr):
358: """Inhalt des Feldes"""
359:
360: if type(fieldStr)==StringType:
361: field=fieldStr
362: else:
363: field=fieldStr[0]
364: try:
365: if field[len(field)-1]==";":
366: field=field[0:len(field)-1]
367: except:
368:
369: """nothing"""
370: field=re.sub(r';([^\s])','; \g<1>',field)
371: return field.encode('utf-8')
372:
373:
374:
375: def sortedNames(self,list):
376: """sort names"""
377:
378: def sortLastName(x_c,y_c):
379: try:
380: x=urllib.unquote(x_c).encode('utf-8','ignore')
381: except:
382: x=urllib.unquote(x_c)
383:
384: try:
385: y=urllib.unquote(y_c).encode('utf-8','ignore')
386: except:
387: x=urllib.unquote(y_c)
388:
389:
390:
391: try:
392: last_x=x.split()[len(x.split())-1]
393: last_y=y.split()[len(y.split())-1]
394:
395: except:
396:
397: last_x=""
398: last_y=""
399:
400:
401:
402: if last_x<last_y:
403: return 1
404: elif last_x>last_y:
405: return -1
406: else:
407: return 0
408:
409: list.sort(sortLastName)
410: list.reverse()
411:
412: return list
413:
414: def __init__(self, id, title):
415: """init"""
416: self.id=id
417: self.title=title
418:
419: def removeStopWords(self,xo):
420: """remove stop words from xo"""
421: if not hasattr(self,'_v_stopWords'):
422: self._v_stopWords=self.stopwords_en.data.split("\n")
423:
424: x=str(xo)
425:
426: strx=x.split(" ")
427:
428: for tmp in strx:
429:
430: if tmp.lower() in self._v_stopWords:
431: del strx[strx.index(tmp)]
432:
433: return " ".join(strx)
434:
435: def urlQuote(self,str):
436: """quote"""
437: return urllib.quote(str)
438:
439: def urlUnQuote(self,str):
440: """quote"""
441: return urllib.unquote(str)
442:
443:
444:
445: def getProjectsByFieldContent(self,fieldName,fieldContentsEntry, date=None):
446: """gib alle Projekte aus mit Value von field mit fieldName enthaelt ein Element der Liste fieldContents"""
447: def sort(x,y):
448: return cmp(x.WEB_title[0],y.WEB_title[0])
449:
450: if type(fieldContentsEntry) is StringType:
451: fieldContentsTmp=[fieldContentsEntry]
452: else:
453: fieldContentsTmp=fieldContentsEntry
454:
455: fieldContents=[]
456: for x in fieldContentsTmp:
457: fieldContents.append(" AND ".join(x.split()))
458: projects=self.ProjectCatalog({fieldName:string.join(fieldContents,' AND')})
459: #print projects
460: #ret=[x for x in projects]
461: ret=[]
462: for x in projects:
463: obj=x.getObject()
464: obj=obj.getActualVersion(date)
465: if obj and (not getattr(obj,'invisible',None)):
466: #if not (x in ret):
467: ret.append(x)
468:
469: ret.sort(sort)
470: return ret
471:
472: def changeMPIWGRootForm(self):
473: """edit"""
474: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeMPIWGRootForm')).__of__(self)
475: return pt()
476:
477: def changeMPIWGRoot(self,title,disciplineList,themesList,connection_id,RESPONSE=None):
478: """change"""
479: self.title=title
480: self.connection_id=connection_id
481: self.disciplineList=disciplineList
482: self.themesList=themesList
483:
484: if RESPONSE is not None:
485: RESPONSE.redirect('manage_main')
486:
487:
488:
489: def getContexts(self,childs=None,parents=None,depth=None,date=None,onlyActive=True):
490: """childs alle childs, alle parents"""
491: ret=[]
492:
493: if parents:
494: splitted=parents.split(".")
495: parentId=string.join(splitted[0:len(splitted)-1],".")
496:
497: for project in self.getProjectFields('xdata_05',sort='int',date=date):
498: if project[1]==parentId:
499: ret.append(project)
500:
501: if childs:
502: for project in self.getProjectFields('xdata_05',sort='int',date=date):
503: searchStr=childs+"(\..*)"
504:
505: if (onlyActive and project[0].isActiveProject()) or (not onlyActive):
506: if re.match(searchStr,project[1]):
507:
508: if depth:
509:
510: if int(depth)>=len(project[1].split("."))-len(childs.split(".")):
511:
512: ret.append(project)
513: else:
514: ret.append(project)
515: return ret
516:
517: def getProjectFields(self,fieldName,date=None,folder=None,sort=None):
518: """getListofFieldNames"""
519: ret=[]
520:
521: objects=self.ZopeFind(self.projects,obj_metatypes=['MPIWGProject'],search_sub=0)
522:
523:
524: for object in objects:
525: obj=object[1]
526: obj=obj.getActualVersion(date)
527: if obj and (not getattr(obj,'invisible',None)):
528: if fieldName=="WEB_title_or_short":
529:
530: if len(obj.getContent('xdata_07'))<3: # hack weil z.Z. manchmal noch ein Trennzeichen ; oder , im Feld statt leer
531: fieldNameTmp="WEB_title"
532: else:
533: fieldNameTmp="xdata_07"
534: else:
535: fieldNameTmp=fieldName
536:
537: ret.append((obj,obj.getContent(fieldNameTmp)))
538:
539:
540: if sort=="int":
541: ret.sort(sortI)
542: elif sort=="stopWords":
543:
544: ret.sort(sortStopWords(self))
545:
546: else:
547: ret.sort(sortF)
548:
549: return ret
550:
551: def showNewProjects(self):
552: projects=[]
553: for objs in self.getProjectFields('WEB_title_or_short'): # Get all Projets
554: if objs[0].xdata_05 and (objs[0].xdata_05[0] == ""):
555:
556: projects.append(objs)
557:
558: return projects
559:
560:
561: manage_options = Folder.manage_options+(
562: {'label':'Update personal homepages','action':'updatePersonalwww_html'},
563: {'label':'Reindex catalogs','action':'reindexCatalogs'},
564: {'label':'Main config','action':'changeMPIWGRootForm'},
565: {'label':'add e-mails','action':'showNewDBEntries'},
566: {'label':'update the institutsbibliography','action':'updateInstitutsbiliography'},
567: #{'label':'Edit Historical Persons','action':'editHistoricalPersonsForm'},
568: #{'label':'Store Historical Persons','action':'storeHistoricalPersons'},
569: )
570:
571:
572: def updatePublicationDB(self,personId=None):
573: """updates the publication db, i.e. copy year and type into the main table"""
574:
575: if personId:
576: founds = self.ZSQLInlineSearch(_table="publications",key_main=personId)
577: else:
578: founds = self.ZSQLInlineSearch(_table="publications")
579:
580: for found in founds:
581:
582: if found.id_institutsbibliographie and (not found.id_institutsbibliographie =="") and (not found.id_institutsbibliographie =="0"):
583:
584: entries = self.ZSQLInlineSearch(_table="institutsbiblio",id=found.id_institutsbibliographie)
585: for entry in entries:
586: self.ZSQLChange(_table='publications',_identify='oid=%s' % found.oid,year=entry.year,referencetype=entry.reference_type)
587:
588: if found.id_gen_bib and (not found.id_gen_bib ==""):
589: entries = self.ZSQLInlineSearch(_table="bibliography",id=found.id_gen_bib)
590: for entry in entries:
591: self.ZSQLChange(_table='publications',_identify='oid=%s' % found.oid,year=entry.year,referencetype=entry.reference_type)
592:
593: return True
594:
595: def showNewDBEntries(self):
596: """zeige neue Eintraege in der Datenbank ohne e-mail adressen bzw. fuer die noch kein Object angelegt wurde"""
597:
598: qstr="select * from personal_www where web_object_created='no' and not key=''"
599: res=self.ZSQLQuery(qstr)
600:
601: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','showNewDBEntries.zpt')).__of__(self)
602: return pt(newEntries=res)
603:
604: def createNewStaffObjects(self,RESPONSE):
605: """create new staff object"""
606:
607: memberFolder=getattr(self,'members')
608: args=self.REQUEST.form
609: arg_k=args.keys()
610: arg_k.remove("submit")
611: ret=""
612: for key in arg_k:
613: k=self.urlUnQuote(key)
614:
615: qstr="select * from personal_www where key=%s"%self.ZSQLQuote(k)
616: res=self.ZSQLQuery(qstr)[0]
617: if args[key]!="": #email-adresse wurde eingetragen
618: #create the object
619: e_mail=args[key]
620: try:
621: newObj=MPIWGStaff.MPIWGStaff(e_mail,res.last_name,res.first_name,k)
622: memberFolder._setObject(e_mail,newObj)
623: obj=getattr(memberFolder,e_mail)
624: obj.reindex_object()
625: ret+="Created %s \n"%e_mail
626: created=True
627: except:
628: msg="Cannot create new user %s (%s %s)"%(e_mail,sys.exc_info()[0],sys.exc_info()[1])
629: logging.error(msg)
630: ret+=msg+"\n"
631: created=False
632:
633: if created:
634: qstr="update personal_www set web_object_created='yes',e_mail='%s@mpiwg-berlin.mpg.de' where key=%s"%(e_mail,self.ZSQLQuote(k))
635: self.ZSQLQuery(qstr)
636:
637: return ret
638:
639:
640: def generateNewPersonEntry(self,data):
641: """generate a new person entry for data, neue personen werden zunaechst nur in der datenbank angelegt """
642:
643: #memberFolder=getattr(self,'members')
644: #create the object
645:
646: # try:
647: # newObj=MPIWGStaff.MPIWGStaff(urllib.quote(data['key']),data['last_name'].encode('utf-8'),data['first_name'].encode('utf-8'))
648: # memberFolder._setObject(urllib.quote(data['key']),newObj)
649: # except:
650: # return False, "Cannot create new user %s (%s %s)"%(data['key'],sys.exc_info()[0],sys.exc_info()[1])
651: #
652:
653: #create the new entry in the database
654:
655:
656: result,msg=MPIWGStaff.createNewDBEntry(self,data['publish_the_data'],data['key'],data['last_name'],
657: data['first_name'],data['title'],data['status'],"",
658: "",data['date_from'],data['date_to'],
659: data['department'],data['home_inst'],data['funded_by'],
660: data['e_mail2'],data['current_work'],"yes",data['date_stay_at_mpiwg'],data['group'],"no",data['current_work'])
661:
662: return result,msg
663:
664: def updatePersonEntry(self,data,ignoreEntries=[]):
665: """update an person entry from data. but ignore all fields in ignore Entries"""
666:
667: ignoreEntries.append('current_work') # TODO:updatecurrent work
668:
669: if data['date_to']=="": # wenn date_to leer
670: data['date_to']="date_none"
671:
672: if data['date_from']=="": # wenn date_fromleer
673: data['date_from']="date_none"
674: msg=""
675:
676:
677: #eintragen
678:
679: columns=data.keys()
680: for x in ignoreEntries:
681: logging.info("ign rem: %s"%x)
682: try: #falls in ignore entries felder sind, die nicht in columns sind, fange den fehler ab
683: columns.remove(x)
684: except:
685: pass
686:
687:
688: insert=[]
689: for key in columns:
690: if data[key]=="date_none": # date_none eintrag wird zu null uebersetzt
691: insert.append('%s=null'%key)
692: else:
693: insert.append(""" "%s"=%s"""%(key,self.ZSQLQuote(data[key])))
694:
695: insertStr=",".join(insert)
696: queryStr="update personal_www SET %s where key='%s'"%(insertStr,data['key'])
697: self.ZSQLQuery("SET DATESTYLE TO 'German'")
698: self.ZSQLQuery(queryStr)
699:
700: #currentwork
701: #if not (txt==""):
702: # queryStr="INSERT INTO current_work (id_main,current,publish) VALUES ('%s','%s','%s')"%(id,txt,txt_p)
703: #
704: # self.ZSQLQuery(queryStr)
705:
706: return True,msg
707:
708:
709: def updatePersonalwww_doIt(self):
710: """do the update"""
711: args=self.REQUEST.form
712: resultSet=self.REQUEST.SESSION['personal_www']['resultSet']
713: news=self.REQUEST.SESSION['personal_www']['news']
714: conflicts=self.REQUEST.SESSION['personal_www']['conflicts']
715: ret="<html><body>"
716: # generate the new entry
717:
718: if news and (len(news)>0):
719: ret+="<h2>Hinzugefügt</h2>"
720: ret+="<p>Neueinträge erscheinen erst auf der Homepage, wenn ihnen eine e-mail Adresse zugeordnet wurde.</p>"
721: ret+="<ul>"
722: for new in news:
723:
724: if args.has_key(self.urlQuote(new.encode('utf-8'))): # entry was selected
725: result,msg=self.generateNewPersonEntry(resultSet[new])
726: if not result:
727: logging.error("Error (generateNewPersonEntry) %s"%msg)
728: ret+="<li>ERROR: %s %s"%(new.encode('utf-8'),msg)
729: else:
730: ret+="<li>OK: %s"%(new.encode('utf-8'))
731: if news and (len(news)>0):
732: ret+="<p>Neueinträge erscheinen erst auf der Homepage, wenn ihnen eine e-mail Adresse zugeordnet wurde.</p>"
733: ret+="</ul>"
734:
735: # update
736:
737: if len(conflicts.keys())>0:
738: ret+="<h2>Änderung des Benutzers übernehmen</h2>"
739: ret+="<p>Wenn nötig in Filemaker-db ändern:</p>"
740:
741: # konflicte
742: for conflict in conflicts.keys():
743: ignoreEntries=[]
744: displayIgnored=[]
745: for cf in conflicts[conflict]:
746: if args[conflict.encode('utf-8')+'_'+cf[0]]=="stored": #use the stored one
747: ignoreEntries.append(cf[0]) #so ignore field cf[0]
748: displayIgnored.append(cf)
749: if len(displayIgnored)>0:
750: ret+="<h3>%s</h3>"%conflict.encode('utf-8')
751:
752: ret+="<table border='1'>"
753: for iE in displayIgnored:
754: ret+="<tr><td>%s</td><td>%s</td><td>%s</td>"%(iE[0].encode('utf-8'),iE[1].encode('utf-8'),iE[2].encode('utf-8'))
755: ret+="</tabel>"
756:
757: self.updatePersonEntry(resultSet[conflict],ignoreEntries=ignoreEntries)
758:
759: # rest
760: cl=list(conflicts.keys())
761:
762: for key in resultSet.keys():
763: if key not in cl:
764: self.updatePersonEntry(resultSet[key])
765: return ret+"</body></html>"
766:
767:
768: def updateInstitutsbiliography(self):
769: """update the Institutsbibliogrpahy"""
770: self.upDateSQL('personalwww.xml')
771: return "<html><body>DONE</body></html>"
772:
773:
774: def updatePersonalwww_html(self):
775: """update form for the homepages web form"""
776: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','updatePersonalwww.zpt')).__of__(self)
777: return pt()
778:
779:
780: def updatePersonalwww(self,uploadfile):
781: """update personalwww
782: @param uploadfile: file handle auf das file
783: """
784: dsn=self.getConnectionObj().connection_string
785: #dsn="dbname=personalwww"
786: resultSet=updatePersonalWWW.importFMPXML(uploadfile)
787: news,conflicts=updatePersonalWWW.checkImport(dsn, resultSet)
788:
789: self.REQUEST.SESSION['personal_www']={}
790: self.REQUEST.SESSION['personal_www']['resultSet']=resultSet
791: self.REQUEST.SESSION['personal_www']['news']=news
792: self.REQUEST.SESSION['personal_www']['conflicts']=conflicts
793:
794: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','updatePersonalwww_check.zpt')).__of__(self)
795: return pt()
796:
797:
798:
799: def reindexCatalogs(self,RESPONSE=None):
800: """reindex members and project catalog"""
801:
802:
803: try:
804:
805: self.ProjectCatalog.manage_catalogReindex(self.REQUEST,RESPONSE,self.REQUEST['URL1'])
806: except:
807: logger("MPIWG Root (updatehomepage)",logging.WARNING," %s %s"%sys.exc_info()[:2])
808:
809:
810:
811:
812:
813: if RESPONSE:
814: RESPONSE.redirect('manage_main')
815:
816:
817:
818:
819: def getAllMembers(self):
820: #ret=[]
821:
822: def sorter(x,y):
823: return cmp(x[0],y[0])
824:
825: results=self.MembersCatalog({'isPublished':True})
826:
827: ret=[(", ".join([proj.lastName, proj.firstName]).decode('utf-8'),proj.getKey) for proj in results]
828:
829: ret.sort(sorter)
830: return ret
831:
832:
833: def printAllMembers(self):
834: """print"""
835: members=self.getAllMembers()
836: ret=""
837: for x in members:
838: ret+="<p>%s</p>"%x
839: return ret
840:
841:
842: def makeList(self,entry):
843: """makes a list out of one entry or repeat a list"""
844: if type(entry) is StringType:
845: return [entry]
846: else:
847: return entry
848:
849: def getTreeRSS(self,dep=None,date=None,onlyActive=0,onlyArchived=0):
850: """generateTree"""
851: rss="""<?xml version="1.0" encoding="utf-8"?>
852: <rss version="2.0">
853: <channel>"""
854:
855: for obj in self.getTree(dep, date, onlyActive, onlyArchived):
856: rss+="""<item>"""
857: rss+="""<link>http://wwwneu.mpiwg-berlin.mpg.de/en/research/projects/%s</link>"""%obj[3].getId()
858: rss+="""</item>"""
859:
860: rss+="""</channel>
861: </rss>"""
862:
863:
864: return rss
865:
866: def getTree(self,dep=None,date=None,onlyActive=0,onlyArchived=0):
867: """generate Tree from project list
868: als Liste, jeder Eintrag ist ein Tupel ,(Tiefe, ProjektNummer,ProjektObject
869: onlyActive = 0 : alle Projekte
870: onlyActive = 1 : nur active Projekte
871: onlyActive = 2: nur inactive Projekte
872:
873: onlyArchived=0: alle Projekte
874: onlyArchived= 1 : nur aktuelle Projekte
875: onlyArchived = 2: nur archivierte Projekte
876: """
877:
878: returnListTmp=[]
879: returnList=[]
880:
881: for project in self.getProjectFields('xdata_05',sort="int",date=date): # get Projects sorted by xdata_05
882:
883: for idNr in project[1].split(";"): # more than one number
884: if not idNr=="":
885: splittedId=idNr.split(".")
886: depth=len(splittedId)
887: nr=idNr
888: #title=project[0].WEB_title
889: title=[project[0].getContent('WEB_title')]
890: #print title
891:
892: if idNr[0]=="x": # kompatibilitaet mit alter Konvention, x vor der Nummer macht project inactive
893: project[0].setActiveFlag(False)
894:
895: if (not dep) or (idNr[0]==dep): #falls dep gesetzt ist nur dieses hinzufuegen.
896:
897: if (onlyActive==0):
898: returnListTmp.append((depth,nr,title,project[0]))
899: elif (onlyActive==1) and project[0].isActiveProject(): #nur active projekte
900: returnListTmp.append((depth,nr,title,project[0]))
901: elif (onlyActive==2) and (not project[0].isActiveProject()): #nur active projekte
902: returnListTmp.append((depth,nr,title,project[0]))
903:
904:
905: #filter jetzt die Liste nach Archived oder nicht
906: for entry in returnListTmp:
907: if (onlyArchived==0):
908: returnList.append(entry)
909: elif (onlyArchived==1) and (not entry[3].isArchivedProject()): #nur active projekte
910: returnList.append(entry)
911: elif (onlyArchived==2) and (entry[3].isArchivedProject()): #nur active projekte
912: returnList.append(entry)
913:
914:
915: return returnList
916:
917:
918:
919: def changePosition(self,treeId,select,RESPONSE=None):
920: """Change Postion Entry"""
921: numbers=[]
922:
923: # Suche hoechste bisherige nummer
924: projects=self.getProjectFields('xdata_05') # get Projects sorted by xdata_05
925: #print "pj",projects
926: for project in projects: #suche alle subtrees der treeId
927: #print treeId
928:
929: founds=re.match(treeId+"\.(.*)",project[1].split(";")[0])
930: if founds:
931: #print "x",founds.group(0),len(founds.group(0).split("."))
932: if len(founds.group(0).split("."))==len(treeId.split("."))+1: # nur ein punkt mehr, d.h. untere ebene
933: try:
934: numbers.append(int(founds.group(0).split(".")[len(founds.group(0).split("."))-1]))
935: except:
936: numbers.append(int(0))
937:
938: try:
939: highest=max(numbers)
940: except:
941: highest=0
942: projects=self.showNewProjects()
943: for i in self.makeList(select):
944: highest+=10
945: projects[int(i)][0].xdata_05=treeId+"."+str(highest)
946:
947:
948: if RESPONSE is not None:
949: RESPONSE.redirect('showTree')
950:
951: def changeTree(self,RESPONSE=None):
952: """change the complete tree"""
953: form=self.REQUEST.form
954: hashList={}
955: onlyArchived=int(form.get("onlyArchived",0))
956: onlyActive=int(form.get("onlyActive",0))
957:
958:
959: fields=self.getTree(onlyArchived=onlyArchived,onlyActive=onlyActive)
960:
961: logging.info("GOT TREE!----------------------------------------------------")
962: for field in form.keys():
963:
964: splitted=field.split('_')
965: if (len(splitted)>1) and (splitted[1]=="runningNumber"): #feld hat die Form Nummer_name und runnignNumber
966:
967:
968: nr=int(splitted[0]) # nummer des Datensatzes
969: currentEntry = fields[nr]
970:
971: if form.has_key(str(nr)+'_active'): # active flag is set
972: fields[nr][3].setActiveFlag(True)
973: else:
974: fields[nr][3].setActiveFlag(False)
975:
976: #nummer hat sich geŠndert
977:
978: entryChanged = False;
979:
980:
981: if not (fields[nr][3].xdata_05==form[str(nr)+'_number']):
982: logging.info("Changed!Number+++++++++++++++++++++++++++++++++")
983: fields[nr][3].xdata_05=form[str(nr)+'_number']
984: entryChanged = True
985:
986: #completed har sich geaendert
987:
988: if not (fields[nr][3].getCompletedAt()==fields[nr][3].transformDate(form[str(nr)+'_completed'])):
989: fields[nr][3].setCompletedAt(form[str(nr)+'_completed'])
990: logging.info("Changed!Completed+++++++++++++++++++++++++++++++++")
991: entryChanged = True
992:
993: if not (fields[nr][3].getStartedAt()==fields[nr][3].transformDate(form[str(nr)+'_started'])):
994: fields[nr][3].setStartedAt(form[str(nr)+'_started'])
995: logging.info("Changed!Started+++++++++++++++++++++++++++++++++")
996: entryChanged = True
997:
998:
999: if entryChanged:
1000: logging.info("Changed!+++++++++++++++++++++++++++++++++")
1001: fields[nr][3].copyObjectToArchive()
1002:
1003:
1004: if RESPONSE is not None:
1005: RESPONSE.redirect('showTree')
1006:
1007: def getProjectWithId(self,id):
1008: fields=self.getProjectFields('xdata_05')
1009: for field in fields:
1010: if field[1]==id:
1011: return field[0]
1012:
1013: return None
1014:
1015:
1016:
1017:
1018: def getRelativeUrlFromPerson(self,list):
1019: """get urls to person list"""
1020: ret=[]
1021: persons=list.split(";")
1022: for person in persons:
1023:
1024: if len(person)>1: #nicht nur Trennzeichen
1025: splitted=person.split(",")
1026: if len(splitted)==1:
1027: splitted=person.split(" ")
1028: splittedNew=[re.sub(r'\s(.*)','$1',split) for split in splitted]
1029: if splittedNew[0]=='':
1030: del splittedNew[0]
1031: search=string.join(splittedNew,' AND ')
1032:
1033: if not search=='':
1034:
1035: try:
1036: proj=self.MembersCatalog({'title':search})
1037: except:
1038: proj=None
1039:
1040: if proj:
1041: #ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url,person.encode('utf-8')))
1042: ret.append("<a href=%s >%s</a>"%('members/'+proj[0].id+'/index.html',person))
1043: else:
1044: #ret.append("%s"%person.encode('utf-8'))
1045: ret.append("%s"%person)
1046: return string.join(ret,";")
1047:
1048: def getMemberIdFromKey(self,key):
1049: """gibt die ensprechende id im members Ordner zum key"""
1050:
1051: if key=="":
1052: return ""
1053: catalogged=self.MembersCatalog({'getKey':key})
1054: if len(catalogged)==0:
1055: return ""
1056: else:
1057: return catalogged[0].getObject().getId()
1058:
1059:
1060:
1061:
1062: def getProjectsOfMembers(self,date=None):
1063: """give tuple member /projects"""
1064: ret=[]
1065: members=self.getAllMembers()
1066:
1067: #return str(members)
1068: for x in members:
1069: projects=self.getProjectsOfMember(key=x[1],date=date)
1070: if len(projects)>0:
1071: ret.append((x[0],projects))
1072:
1073: return ret
1074:
1075: def getProjectsOfMember(self,key=None,date=None,onlyArchived=1,onlyActive=1):
1076: """get projects of a member
1077:
1078: @param key: (optional) Key zur Idenfikation des Benutzer
1079: @param date: (optional) Version die zum Zeitpunkt date gueltig war
1080: @param onlyArchived:
1081: onlyArchived=0: alle Projekte
1082: onlyArchived= 1 : nur aktuelle Projekte
1083: onlyArchived = 2: nur archivierte Projekte
1084: """
1085: # TODO: Die ganze Loesung
1086: def sortP(x,y):
1087: """sort by sorting number"""
1088: return cmp(x.WEB_title,y.WEB_title)
1089:
1090: ret=[]
1091: if key:
1092: proj=self.ProjectCatalog({'getPersonKeyList':key})
1093: else:
1094: return ret # key muss definiert sein
1095:
1096:
1097: if proj:
1098: proj2=[]
1099: for x in proj:
1100: if (not getattr(x.getObject(),'invisible',None)) and (getattr(x.getObject(),'archiveTime','')==''):
1101: proj2.append(x)
1102:
1103: else:
1104: proj2=[]
1105:
1106:
1107:
1108: proj2.sort(sortP)
1109:
1110: projectListe=[]
1111:
1112: for proj in proj2:
1113: obj=proj.getObject()
1114: add=False
1115: if onlyArchived==1: #nur aktuell projecte
1116: if not obj.isArchivedProject():
1117: add=True
1118: elif onlyArchived==2: #nur archivierte
1119: if obj.isArchivedProject():
1120: add=True
1121: else: #alle
1122: add=True
1123:
1124: if onlyActive==1: #nur active projecte
1125: if obj.isActiveProject():
1126: add=add & True
1127: else:
1128: add=add & False
1129:
1130: elif onlyArchived==2: #nur nicht aktvive
1131: if not obj.isActiveProject():
1132: add=add & True
1133: else: #alle
1134: add=add & True
1135:
1136: if add:
1137: projectListe.append(obj)
1138:
1139:
1140: return projectListe
1141:
1142: def givePersonList(self,name):
1143: """check if person is in personfolder and return list of person objects"""
1144:
1145: splitted=name.split(",")
1146: if len(splitted)==1:
1147: splitted=name.lstrip().rstrip().split(" ")
1148: splittedNew=[split.lstrip() for split in splitted]
1149:
1150: if splittedNew[0]=='':
1151: del splittedNew[0]
1152: search=string.join(splittedNew,' AND ')
1153:
1154: if not search=='':
1155: proj=self.MembersCatalog({'title':search})
1156:
1157: if proj:
1158: return [[x.lastName,x.firstName] for x in proj]
1159: else:
1160: return []
1161:
1162: ## splitted=name.split(",") # version nachname, vorname...
1163: ## if len(splitted)>1:
1164: ## lastName=splitted[0]
1165: ## firstName=splitted[1]
1166: ## else:
1167: ## splitted=name.split(" ") #version vorname irgenwas nachnamae
1168:
1169: ## lastName=splitted[len(splitted)-1]
1170: ## firstName=string.join(splitted[0:len(splitted)-1])
1171:
1172: ## objs=[]
1173:
1174: #print self.members
1175: ## for x in self.members.__dict__:
1176: ## obj=getattr(self.members,x)
1177: ## if hasattr(obj,'lastName') and hasattr(obj,'firstName'):
1178:
1179: ## if (re.match(".*"+obj.lastName+".*",lastName) or re.match(".*"+lastName+".*",obj.lastName)) and (re.match(".*"+obj.firstName+".*",firstName) or re.match(".*"+firstName+".*",obj.firstName)):
1180:
1181: ## objs.append((obj,lastName+", "+firstName))
1182:
1183:
1184: ## return objs
1185:
1186:
1187: def personCheck(self,names):
1188: """all persons for list"""
1189: #print "names",names
1190: splitted=names.split(";")
1191: ret={}
1192: for name in splitted:
1193:
1194: if not (name==""):
1195: try:
1196: ret[name]=self.givePersonList(name)
1197: except:
1198: """NOTHIHN"""
1199: #print "RET",ret
1200: return ret
1201:
1202: def giveCheckList(self,person,fieldname):
1203: """return checklist"""
1204: #print "GCL",fieldname
1205: if fieldname=='xdata_01':
1206: x=self.personCheck(person.getContent(fieldname))
1207: #print "GCLBACKX",x
1208: return x
1209:
1210:
1211: def isCheckField(self,fieldname):
1212: """return chechfield"""
1213:
1214: return (fieldname in checkFields)
1215:
1216:
1217: def generateNameIndex(self):
1218: """erzeuge einen index verwendeter personen"""
1219: import psycopg
1220: o = psycopg.connect('dbname=authorities user=dwinter password=3333',serialize=0)
1221: results={}
1222: print self.fulltext.historicalNames.items()
1223: for nameItem in self.fulltext.historicalNames.items(): #gehe durch alle namen des lexikons
1224:
1225: c = o.cursor()
1226: name=nameItem[0]
1227: print "check",name
1228: c.execute("select lastname,firstname from persons where lower(lastname) = '%s'"%quote(name))
1229: tmpres=c.fetchall()
1230: firstnames=[result[1] for result in tmpres] # find all firstnames
1231: if tmpres:
1232: lastname=tmpres[0][0]
1233:
1234: for found in self.fulltext({'names':name}):
1235: if found.getObject().isActual():
1236: for nh in found.getObject().getGetNeighbourhood(name, length=50,tagging=False): #hole umgebung
1237: #schaue nun ob der vorname hinter oder vor dem name ist
1238: position=nh.find(lastname)
1239: # vorher
1240: #print "NH",nh
1241: bevorS=nh[0:position].split()
1242: #print "BV",bevorS
1243: if len(bevorS)>1:
1244: try:
1245: bevor=[bevorS[-1],bevorS[-2]]
1246: except:
1247: bevor=[bevorS[0]]
1248: else:
1249: bevor=[]
1250: #nachher
1251: behindS= re.split("[,|;| ]",nh[position:])
1252: #print "BH",behindS
1253: if len(behindS)>2:
1254: try:
1255: behind=behindS[1:3]
1256: except:
1257: behind=[bevorS[1]]
1258: else:
1259: behind=[]
1260: for firstname in firstnames:
1261: if firstname in bevor+behind: #Namen wie mit Adelspraedikaten werden so erstmal nich gefunden
1262: id="%s,%s"%(lastname,firstname)
1263: if not results.has_key(id):
1264: results[id]=[]
1265: objId=found.getObject().getId()
1266: if not (objId in results[id]):
1267: print "d %s for %s"%(id,objId)
1268: results[id].append(objId)
1269: self.nameIndex=results
1270: return results
1271:
1272: def editNameIndexHTML(self):
1273: """edit the name index"""
1274: if not hasattr(self,'nameIndexEdited'): # falls editierter index noch nicht existiert, kopiere automatisch erstellten
1275: self.nameIndexEdited=copy.copy(self.nameIndex)
1276: print "huh"
1277: #self.nameIndexEdited=copy.copy(self.nameIndex)
1278: #print self.nameIndexEdited
1279: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editHistoricalNames.zpt')).__of__(self)
1280: return pt()
1281:
1282: def getNamesInProject(self,projectId):
1283: """get all names ofnameIndexEdited which are references in projec with projectId"""
1284:
1285: ret=[]
1286: for name in self.nameIndexEdited.keys():
1287: if projectId in self.nameIndexEdited[name]:
1288: ret.append(name)
1289:
1290: return ret
1291:
1292: def editNameIndex(self,RESPONSE=None,name=None,occurrances=None,submit=None):
1293: """edit the index"""
1294: nI=self.nameIndexEdited # mI introduced to make sure that changes to nameIndexEdited are know to ZODB
1295: if submit=="delete":
1296:
1297:
1298: dh=getattr(self,'deletedHistoricalNames',{})
1299:
1300: if type(dh) is ListType:
1301: dh={}
1302: if not dh.has_key(name):
1303: dh[name]=occurrances.split("\n")
1304: else:
1305: dh[name]+=occurrances.split("\n")
1306:
1307: self.deletedHistoricalNames=dh
1308:
1309: del self.nameIndexEdited[name]
1310:
1311:
1312: elif (submit=="change"):
1313:
1314: nI[name]=occurrances.split("\n")[0:]
1315:
1316: elif (submit=="add"):
1317: if not nI.has_key(name):
1318: nI[name]=occurrances.split("\n")
1319: else:
1320: nI[name]+=occurrances.split("\n")
1321:
1322: self.nameIndexEdited=nI
1323:
1324:
1325: if RESPONSE is not None:
1326: RESPONSE.redirect('editNameIndexHTML')
1327:
1328:
1329:
1330: def restoreIndex(self):
1331: """restore"""
1332: self.nameIndexEdited=self.nameIndex
1333: return "done"
1334:
1335:
1336:
1337: def manage_addMPIWGRootForm(self):
1338: """form for adding the root"""
1339: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMPIWGRootForm.zpt')).__of__(self)
1340: return pt()
1341:
1342: def manage_addMPIWGRoot(self,id,title,connection_id="",RESPONSE=None):
1343: """add a root folder"""
1344: newObj=MPIWGRoot(id,title)
1345: self._setObject(id,newObj)
1346: ob=getattr(self,id)
1347: setattr(ob,'connection_id',connection_id)
1348: if RESPONSE is not None:
1349: RESPONSE.redirect('manage_main')
1350:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvs/cvsweb/icons/back.gif){kind=icon}
Return to MPIWGRoot.py CVS log ![[TXT]](/cvs/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvs/cvsweb/icons/dir.gif){kind=icon}
Up to [Repository] / MPIWGWeb