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