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