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