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