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