File:  [Repository] / MPIWGWeb / MPIWGProjects.py
Revision 1.37: download - view: text, annotated - select for diffs - revision graph
Thu Oct 14 09:01:32 2004 UTC (19 years, 8 months ago) by dwinter
Branches: MAIN
CVS tags: HEAD
MPIWGTemplate added

    1: """This contains the class MPIWG Projects
    2: for organizing and maintaining the different projectspages
    3: 
    4: """
    5: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
    6: from Products.PageTemplates.PageTemplate import PageTemplate
    7: from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
    8: from Products.ZSQLExtend.ZSQLExtend import ZSQLExtendFolder
    9: from Globals import package_home
   10: import urllib
   11: import MPIWGStaff
   12: import string
   13: import re
   14: import os
   15: from types import *
   16: 
   17: import xmlhelper # Methoden zur Verwaltung der projekt xmls
   18: from OFS.SimpleItem import SimpleItem
   19: from OFS.Folder import Folder
   20: 
   21: from bibliography import *
   22: 
   23: definedFields=['WEB_title','xdata_01','xdata_02','xdata_03','xdata_04','xdata_05','xdata_06','xdata_07','xdata_08','xdata_09','xdata_10','xdata_11','xdata_12','xdata_13','WEB_project_header','WEB_project_description','WEB_related_pub']
   24: 
   25: checkFields = ['xdata_01']
   26: 
   27: 
   28: 
   29: def sortF(x,y):
   30:     try:
   31:         return cmp(x[1],y[1])
   32:     except:
   33:         try:
   34:             return cmp(str(x[1]),str(y[1]))
   35:         except:           
   36:             print "error",x[1],y[1]
   37:             return 0 
   38:     
   39: def sortI(x,y):
   40:     xsplit=x[1].split(".")
   41:     ysplit=y[1].split(".")
   42:     xret=""
   43:     yret=""
   44:     try:
   45:         for i in range(5):
   46:             try:
   47:                 yret=yret+"%04i"%int(xsplit[i])
   48:             except:
   49:                 yret=yret+"%04i"%0
   50: 
   51:             try:
   52:                 xret=xret+"%04i"%int(ysplit[i])
   53:             except:
   54:                 xret=xret+"%04i"%0
   55:                 
   56:         
   57:         return cmp(int(yret),int(xret))
   58:     except:
   59:         return cmp(x[1],y[1])
   60: 
   61: class MPIWGTemplate(ZopePageTemplate):
   62:     """Create a layout Template for different purposes"""
   63: 
   64:     meta_type="MPIWGTemplate"
   65: 
   66:     def __init__(self, id, text=None, content_type=None,MPIWGType=None):
   67:         self.id = str(id)
   68: 
   69: 
   70: 
   71:         self.ZBindings_edit(self._default_bindings)
   72:         if text is None:
   73:             self._default_content_fn = os.path.join(package_home(globals()),
   74:                                                'zpt/MPIWG_%s_template_standard.zpt'%MPIWGType)
   75:             text = open(self._default_content_fn).read()
   76:         self.pt_edit(text, content_type)
   77: 
   78:     
   79:         """change form"""
   80: 
   81: 
   82: def manage_addMPIWGTemplateForm(self):
   83:     """Form for adding"""
   84:     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt/AddMPIWGTemplate.zpt')).__of__(self)
   85:     return pt()
   86: 
   87: from urllib import quote
   88: 
   89: 
   90: def manage_addMPIWGTemplate(self, MPIWGType,id, title=None,REQUEST=None):
   91:     "Add a Page Template with optional file content."
   92:     if type(MPIWGType)==StringType:
   93:         MPIWGTypes=[MPIWGType]
   94:     else:
   95:         MPIWGTypes=MPIWGType
   96:         
   97:     for singleType in MPIWGTypes:
   98: 
   99: 
  100:         if REQUEST is None:
  101:             self._setObject(id, MPIWGTemplate(id, text,EchoType=singleType))
  102:             ob = getattr(self, id)
  103:             
  104:             if title:
  105:                 ob.pt_setTitle(title)
  106:             return ob
  107:         else:
  108:             file = REQUEST.form.get('file')
  109:             headers = getattr(file, 'headers', None)
  110:             if headers is None or not file.filename:
  111:                 zpt = MPIWGTemplate(id,MPIWGType=singleType)
  112:             else:
  113:                 zpt = MPIWGTemplate(id, file, headers.get('content_type'))
  114: 
  115:             self._setObject(id, zpt)
  116:             ob = getattr(self, id)
  117:             if title:
  118:                 ob.pt_setTitle(title)
  119: 
  120:             try:
  121:                 u = self.DestinationURL()
  122:             except AttributeError:
  123:                 u = REQUEST['URL1']
  124: 
  125:             
  126:     REQUEST.RESPONSE.redirect(u+'/manage_main')
  127:     return ''
  128: 
  129:     
  130: class MPIWGRoot(ZSQLExtendFolder):
  131:     """Stammordner für den Web-Server"""
  132: 
  133:     fieldLabels={'WEB_title':'WEB_Title','xdata_01':'Responsible Scientists','xdata_02':'Department',
  134:              'xdata_03':'Historical Persons','xdata_04':'Time period',
  135:              'xdata_05':'Sorting number','xdata_06':'Keywords','xdata_07':'Short title',
  136:              'xdata_08':'Other involved scholars' ,'xdata_09':'Part of','xdata_10':'Covered by',
  137:              'xdata_11':'Object Digitallibrary','xdata_12':'Cooperation partners',
  138:              'xdata_13':'Funding institutions','WEB_project_header':'WEB_project_header',
  139:              'WEB_project_description':'WEB_project_description','WEB_related_pub':'WEB_related_pub'}
  140:     
  141:     folders=['MPIWGProject','Folder']
  142:     meta_type='MPIWGRoot'
  143: 
  144:     def upDateSQL(self,fileName):
  145:         """updates SQL databases using fm.jar"""
  146:         fmJarPath=os.path.join(package_home(globals()), 'updateSQL/fm.jar')
  147:         xmlPath=os.path.join(package_home(globals()), "updateSQL/%s"%fileName)
  148: 
  149:         os.popen("java -classpath %s -Djava.awt.headless=true Convert %s"%(fmJarPath,xmlPath),"r").read()
  150: 
  151:         return 1
  152:     
  153:     def patchProjects(self,RESPONSE):
  154:         """patch"""
  155:         projects=self.ZopeFind(self.projects,obj_metatypes=['MPIWGProject'])
  156:         for project in projects:
  157: 		tmp=project[1].WEB_project_description[0].replace("/CD/projects/","")[0:]
  158:             	setattr(project[1],'WEB_project_description',[tmp[0:]])
  159:             	RESPONSE.write("<p>%s</p>\n"%project[0])
  160:             
  161:     def replaceNotEmpty(self,format,field):
  162:         """replace not empty"""
  163:         if field and (not field==''):
  164:             return format%field
  165:         else:
  166:             return ""
  167:         
  168: 
  169:     def redirectIndex_html(self,request):
  170:         #return request['URL1']+'/index_html'
  171:         
  172:         return urllib.urlopen(request['URL1']+'/index_html').read()
  173: 
  174:     
  175:     def formatBibliography(self,here,found):
  176:         """format"""
  177:         return formatBibliography(here,found)
  178:     
  179:     def getValue(self,fieldStr):
  180:         """Inhalt des Feldes"""
  181:         
  182:         if type(fieldStr)==StringType:
  183:             field=fieldStr
  184:         else:
  185:             field=fieldStr[0]
  186:         try:
  187:             if field[len(field)-1]==";":
  188:                 field=field[0:len(field)-1]
  189:         except:
  190: 
  191:             """nothing"""
  192:         field=re.sub(r';([^\s])','; \g<1>',field)
  193:         return field.encode('utf-8')
  194: 
  195: 
  196:     
  197:     def sortedNames(self,list):
  198:         """sort names"""
  199: 
  200:         def sortLastName(x_c,y_c):
  201:             try:
  202:                 x=urllib.unquote(x_c).encode('utf-8','ignore')
  203:             except:
  204:                 x=urllib.unquote(x_c)
  205: 
  206:             try:
  207:                 y=urllib.unquote(y_c).encode('utf-8','ignore')
  208:             except:
  209:                 x=urllib.unquote(y_c)
  210:                 
  211: 
  212:             
  213:             try:
  214:                 last_x=x.split()[len(x.split())-1]
  215:                 last_y=y.split()[len(y.split())-1]
  216: 
  217:             except:
  218: 
  219:                 last_x=""
  220:                 last_y=""
  221:             
  222:             
  223:             
  224:             if last_x<last_y:
  225:                 return 1
  226:             elif last_x>last_y:
  227:                 return -1
  228:             else:
  229:                 return 0
  230:             
  231:         list.sort(sortLastName)
  232:         list.reverse()
  233:         
  234:         return list
  235:     
  236:     def __init__(self, id, title):
  237:         """init"""
  238:         self.id=id
  239:         self.title=title
  240: 
  241:     def urlQuote(self,str):
  242:         """quote"""
  243:         return urllib.quote(str)
  244: 
  245:     def urlUnQuote(self,str):
  246:         """quote"""
  247:         return urllib.unquote(str)
  248:     
  249:     def harvestHistoricalPersons(self):
  250:         """erstelle liste aller erwaehnten actors"""
  251: 
  252:         def normalize(str):
  253:             """loesche fuhrendes space"""
  254:             if (len(str)>1) and (str[0]==" "):
  255:                 ret=str[1:]
  256:             else:
  257:                 ret=str
  258:             return ret
  259:         
  260:         list={}
  261:         projects=self.ZopeFind(self.projects,obj_metatypes=['MPIWGProject'])
  262:         
  263:         for project in projects:
  264:             lg=len(project[1].xdata_03[0])-1
  265: 
  266:             if (lg>1) and (project[1].xdata_03[0][lg]==";"):
  267:                 project[1].xdata_03[0]=project[1].xdata_03[0][0:lg]
  268: 
  269:           
  270:      
  271:                 
  272:             try:
  273:                 if len(project[1].xdata_03[0].split(";"))>1: # guess if separator is ;
  274:                     for person in project[1].xdata_03[0].split(";"):
  275:                         personNormal=normalize(person)
  276:                         if personNormal in list.keys():
  277:                             list[urllib.quote(personNormal)][1].append(project[1])
  278:                         else:
  279:                             list[urllib.quote(personNormal)]=(personNormal,[project[1]])
  280:                 else: #guess , is sepeator
  281:                     for person in project[1].xdata_03[0].split(","):
  282:                         personNormal=normalize(person)
  283:                         if urllib.quote(personNormal) in list.keys():
  284:                             list[urllib.quote(personNormal)][1].append(project[1])
  285:                         else:
  286:                             list[urllib.quote(personNormal)]=(personNormal,[project[1]])
  287: 
  288:             except:
  289:                 print "ERROR",project
  290:                 
  291:         return list
  292: 
  293:     def storeHistoricalPersons(self,RESPONSE=None):
  294:         """store persons"""
  295:         self.personDict={}
  296:         personDict=self.harvestHistoricalPersons()
  297:         for person in personDict.keys():
  298:             for project in personDict[person][1]:
  299:                 if person in self.personDict.keys():
  300:                     self.personDict[person][1].append((project.absolute_url(),project.WEB_title[0],project.xdata_01[0]))
  301:                 else:
  302:                     self.personDict[person]=(personDict[person][0],[(project.absolute_url(),project.WEB_title[0],project.xdata_01[0])])
  303: 
  304:         if RESPONSE is not None:
  305:             RESPONSE.redirect("showHistoricalPersons")
  306:             
  307: 
  308:     def getPersonDict(self,name):
  309:         """name von dict"""
  310: 
  311:         try:
  312:             return self.personDict[name][0].encode('utf-8')
  313:         except:
  314:             return self.personDict[name][0]
  315:             return self.personDict[name][0].decode('latin-1').encode('utf-8')
  316:         
  317: 
  318:     def showHistoricalPersons(self):
  319:         """show persons"""
  320:         pt=PageTemplateFile('Products/MPIWGWeb/zpt/showHistoricalPersons').__of__(self)
  321:         return pt()
  322: 
  323:         
  324:     def editHistoricalPersonsForm(self):
  325:         """edit historical persons for consistency"""
  326:         pt=PageTemplateFile('Products/MPIWGWeb/zpt/editHistoricalPersonsForm').__of__(self)
  327:         return pt()
  328: 
  329:     def getProjectsByFieldContent(self,fieldName,fieldContentsEntry):
  330:         """gib alle Projekte aus mit Value von field mit fieldName enthält ein Element der Liste fieldContents"""
  331:         if type(fieldContentsEntry) is StringType:
  332:             fieldContents=[fieldContentsEntry]
  333:         else:
  334:             fieldContents=fieldContentsEntry
  335:             
  336:         projects=self.ProjectCatalog({fieldName:string.join(fieldContents,' OR')})
  337:         #print projects
  338:         return projects
  339: 
  340:     def changeMPIWGRootForm(self):
  341:         """edit"""
  342:         pt=PageTemplateFile('Products/MPIWGWeb/zpt/changeMPIWGRootForm').__of__(self)
  343:         return pt()
  344: 
  345:     def changeMPIWGRoot(self,title,disciplineList,themesList,RESPONSE=None):
  346:         """change"""
  347:         self.title=title
  348:         self.disciplineList=disciplineList
  349:         self.themesList=themesList
  350: 
  351:         if RESPONSE is not None:
  352:             RESPONSE.redirect('manage_main')
  353: 
  354:     def getDisciplineList(self):
  355:         """get disciplines as list"""
  356:         return self.disciplineList.split("\n")
  357:     
  358:     def getThemeList(self):
  359:         """get themes as list"""
  360:         return self.themesList.split("\n")
  361:     
  362:     def test(self):
  363:         """test"""
  364:         return self.getProjectsByFieldContent('xdata_09',['biology'])[0].absolute_url
  365: 
  366:     def getContexts(self,childs=None,parents=None,depth=None):
  367:         """childs alle childs, alle parents"""
  368:         ret=[]
  369:         if parents:
  370:             splitted=parents.split(".")
  371:             parentId=string.join(splitted[0:len(splitted)-1],".")
  372:         
  373:             for project in self.getProjectFields('xdata_05',sort='int'):
  374:                 if project[1]==parentId:
  375:                     ret.append(project)
  376: 
  377:         if childs:
  378:             for project in self.getProjectFields('xdata_05',sort='int'):
  379:                 searchStr=childs+"(\..*)"
  380:                 if re.match(searchStr,project[1]):
  381:                     
  382:                     if depth:
  383: 
  384:                         if int(depth)>=len(project[1].split("."))-len(childs.split(".")):
  385:                     
  386:                             ret.append(project)
  387:                     else:
  388:                         ret.append(project)
  389:         return ret
  390:     
  391:     def getProjectFields(self,fieldName,folder=None,sort=None):
  392:         """getListofFieldNames"""
  393:         ret=[]
  394:         #print "FN",fieldName
  395:         if not folder:
  396:             folder=self
  397:         for object in folder.__dict__:
  398: 
  399:             obj=getattr(folder,object)
  400:             if hasattr(obj,'meta_type'):
  401:                 #print obj.meta_type
  402:                 if obj.meta_type=='MPIWGProject':
  403:                     if fieldName=="WEB_title_or_short":
  404:                         #print "HI!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
  405:                         #print len(obj.getContent('xdata_07'))
  406:                         if len(obj.getContent('xdata_07'))<3: # hack weil z.Z. manchmal noch ein Trennzeichen ; oder , im Feld statt leer
  407:                             fieldNameTmp="WEB_title"
  408:                         else:
  409:                             fieldNameTmp="xdata_07"
  410:                     else:
  411:                         fieldNameTmp=fieldName
  412:                     
  413:                     ret.append((obj,obj.getContent(fieldNameTmp)))
  414: 
  415:                 if obj.meta_type in self.folders:
  416:                     
  417:                     ret += self.getProjectFields(fieldName,obj)
  418: 
  419:         if sort=="int":
  420:             ret.sort(sortI)
  421:         else:
  422:             ret.sort(sortF)
  423:         
  424:         return ret
  425: 
  426:     def showNewProjects(self):
  427:         projects=[]
  428:         for objs in self.getProjectFields('WEB_title_or_short'): # Get all Projets
  429:             if objs[0].xdata_05[0] == "":
  430:                 
  431:                 projects.append(objs)
  432:                 
  433:         return projects
  434:     
  435:         
  436:     manage_options = Folder.manage_options+(
  437:         {'label':'Update Personal Homepages','action':'updateHomepages'},
  438:         {'label':'Main config','action':'changeMPIWGRootForm'},
  439:         {'label':'Edit Historical Persons','action':'editHistoricalPersonsForm'},
  440:         {'label':'Store Historical Persons','action':'storeHistoricalPersons'},
  441:         )
  442:     
  443:     def importNamesForm(self):
  444:         """Form"""
  445:         pt=PageTemplateFile('Products/MPIWGWeb/zpt/MPIWGNamesForm.zpt').__of__(self)
  446:         return pt()
  447: 
  448:     def importNames(self,fileupload,folderName,RESPONSE=None):
  449:         """import komma-sep list email,lastName,firstName"""
  450:         project=getattr(self,folderName)
  451:         load=fileupload.read()
  452:         
  453:         for line in load.split('\r'):
  454:             
  455:             
  456:             splitted=line.split(",")
  457:            # print splitted
  458:         
  459:             if not (splitted[0]==""):
  460:                 newObj=MPIWGStaff.MPIWGStaff(splitted[0],splitted[1],splitted[2])
  461:                 
  462:                 try:
  463:                     project._setObject(splitted[0],newObj)
  464:                     #print "done:",splitted[0]
  465:                 except:
  466:                     print "not done:",splitted[0]
  467:                     
  468:         if RESPONSE is not None:
  469:             RESPONSE.redirect('manage_main')
  470: 
  471:     def updateHomepages(self,RESPONSE):
  472:         """lege members an"""
  473:         self.upDateSQL('personalwww.xml')
  474:         founds=self.ZSQLInlineSearch(_table='personal_www')
  475:         project=getattr(self,'members')
  476:         for found in founds:
  477:             
  478:             if not (found.e_mail==""):
  479:                 newObj=MPIWGStaff.MPIWGStaff(found.username,found.name,found.vorname)
  480:                 
  481:                 try:
  482:                     project._setObject(found.username,newObj)
  483:                     RESPONSE.write("<p>new:%s</p>\n"%found.username)
  484:                 except:
  485:                     RESPONSE.write("<p>old:%s (%s,%s)</p>\n"%(found.username,found.name,found.vorname))
  486: 
  487: 
  488:                     
  489:         if RESPONSE is not None:
  490:             RESPONSE.redirect('manage_main')
  491: 
  492:         
  493:     def getAllMembers(self):
  494:         """give list of all members"""
  495:         ret=[]
  496: 
  497:         #for x in self.members.objectValues('MPIWGStaff'):
  498:             #print x.title
  499:         #    ret.append(x.title.decode('utf-8'))
  500: 
  501:         for x in self.ZopeFind(self.members,obj_metatypes=['MPIWGStaff']):
  502:                                ret.append(x[1].title.decode('utf-8'))
  503:             
  504:         ret.sort()
  505:         #print ret
  506:   
  507:         return ret
  508: 
  509:     def printAllMembers(self):
  510:         """prin"""
  511:         members=self.getAllMembers()
  512:         ret=""
  513:         for x in members:
  514:             ret+="<p>%s</p>"%x
  515:         return ret
  516:     
  517:         
  518:     def makeList(self,entry):
  519:         """makes a list out of one entry or repeat a list"""
  520:         if type(entry) is StringType:
  521:             return [entry]
  522:         else:
  523:             return entry
  524: 
  525: 
  526:     def getTree(self):
  527:         """generate Tree from project list"""
  528:         returnList=[]
  529:         for project in self.getProjectFields('xdata_05',sort="int"): # get Projects sorted by xdata_05
  530:             for idNr in project[1].split(";"): # more than one number
  531:                 if not idNr=="":
  532:                     splittedId=idNr.split(".")
  533:                     depth=len(splittedId)
  534:                     nr=idNr
  535:                     #title=project[0].WEB_title
  536:                     title=[project[0].getContent('WEB_title')]
  537:                     #print title
  538:                     returnList.append((depth,nr,title,project[0]))
  539:         
  540:         return returnList
  541: 
  542: 
  543:     def formatElementForOverview(self,element):
  544:         """format the element for output in overview"""
  545:         if element[0]==1: #department
  546:             #print element[3].getContent('xdata_05')
  547:             if element[3].getContent('xdata_05') == "4":
  548:                 return """<h2 class="hier"><a href="%s">Ind. Research Group I: %s</a></h2>"""%(element[3].absolute_url()+"/index.html",element[3].getContent('WEB_title'))
  549:             if element[3].getContent('xdata_05') == "5":
  550:                 return """<h2 class="hier"><a href="%s">Ind. Research Group II: %s</a></h2>"""%(element[3].absolute_url()+"/index.html",element[3].getContent('WEB_title'))
  551:             
  552:             return """<h2 class="hier"><a href="%s">Department %s: %s</a></h2>"""%(element[3].absolute_url()+"/index.html",element[3].getContent('xdata_05'),element[3].getContent('WEB_title'))
  553: 
  554:         elif element[0]==2: #mainprojects
  555:             return """<h3 class="hier"><a href="%s">%s</a></h3><p>"""%(element[3].absolute_url()+"/index.html",element[3].getContent('WEB_title'))
  556: 
  557:         elif element[0]==3:
  558:             return """<p class="hier"><a href="%s">%s</a></p>"""%(element[3].absolute_url()+"/index.html",element[3].getContent('WEB_title'))
  559: 
  560:         
  561:     def changePosition(self,treeId,select,RESPONSE=None):
  562:         """Change Postion Entry"""
  563:         numbers=[]
  564: 
  565:         # Suche hoechste bisherige nummer
  566:         projects=self.getProjectFields('xdata_05') # get Projects sorted by xdata_05
  567:         #print "pj",projects
  568:         for project in projects: #suche alle subtrees der treeId
  569:             #print treeId
  570:             
  571:             founds=re.match(treeId+"\.(.*)",project[1].split(";")[0])
  572:             if founds:
  573:                 #print "x",founds.group(0),len(founds.group(0).split("."))
  574:                 if len(founds.group(0).split("."))==len(treeId.split("."))+1: # nur ein punkt mehr, d.h. untere ebene
  575:                     try:
  576:                         numbers.append(int(founds.group(0).split(".")[len(founds.group(0).split("."))-1]))
  577:                     except:
  578:                         numbers.append(int(0))
  579: 
  580:         try:
  581:             highest=max(numbers)
  582:         except:
  583:             highest=0
  584:         projects=self.showNewProjects()
  585:         for i in self.makeList(select):
  586:             highest+=10
  587:             projects[int(i)][0].xdata_05=treeId+"."+str(highest)
  588: 
  589: 
  590:         if RESPONSE is not None:
  591:             RESPONSE.redirect('showTree')
  592:         
  593:     def changeTree(self,RESPONSE=None):
  594:         """change the complete tree"""
  595:         form=self.REQUEST.form
  596:         hashList={}
  597:         fields=self.getTree()
  598: 
  599:         
  600:         for idNr in form.keys():
  601:             fields[int(idNr)][3].xdata_05=form[idNr]
  602: 
  603:         
  604: 
  605:         if RESPONSE is not None:
  606:             RESPONSE.redirect('showTree')
  607: 
  608:     def getProjectWithId(self,id):
  609:         fields=self.getProjectFields('xdata_05')
  610:         for field in fields:
  611:             if field[1]==id:
  612:                 return field[0]
  613: 
  614:         return None
  615:             
  616:         
  617:             
  618:         
  619:     def getRelativeUrlFromPerson(self,list):
  620:         """get urls to person list"""
  621:         ret=[]
  622:         persons=list.split(";")
  623:         for person in persons:
  624:             
  625:             if len(person)>1: #nicht nur Trennzeichen
  626:                 splitted=person.split(",")
  627:                 if len(splitted)==1:
  628:                     splitted=person.split(" ")
  629:                 splittedNew=[re.sub(r'\s(.*)','$1',split) for split in splitted]
  630:                 if splittedNew[0]=='':
  631:                     del splittedNew[0]
  632:                 search=string.join(splittedNew,' AND ')
  633:                 
  634:                 if not search=='':
  635: 
  636:                     try:
  637:                         proj=self.MembersCatalog({'title':search})
  638:                     except:
  639:                         proj=None
  640: 
  641:                 if proj:
  642:                     #ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url,person.encode('utf-8')))
  643:                     ret.append("<a href=%s >%s</a>"%('members/'+proj[0].id+'/index.html',person))
  644:                 else:
  645:                     #ret.append("%s"%person.encode('utf-8'))
  646:                     ret.append("%s"%person)
  647:         return string.join(ret,";")
  648:         
  649:             
  650:     def getUrlFromPerson(self,list):
  651:         """get urls to person list"""
  652:         ret=[]
  653:         persons=list.split(";")
  654:         for person in persons:
  655:             
  656:             if len(person)>1: #nicht nur Trennzeichen
  657:                 splitted=person.split(",")
  658:                 if len(splitted)==1:
  659:                     splitted=person.lstrip().rstrip().split(" ")
  660:                 splittedNew=[re.sub(r'\s(.*)','$1',split) for split in splitted]
  661:                 if splittedNew[0]=='':
  662:                     del splittedNew[0]
  663:                 search=string.join(splittedNew,' AND ')
  664:                 
  665:                 if not search=='':
  666: 
  667:                     try:
  668:                         proj=self.MembersCatalog({'title':search})
  669:                     except:
  670:                         proj=None
  671: 
  672:                 if proj:
  673: 		    if person =="Otto Sibum" : person="H. Otto Sibum"
  674: 		    if person =="Norton Wise" : person="M. Norton Wise"
  675:                     #ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url,person.encode('utf-8')))
  676:                     ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url+"/index.html",person))
  677:                 else:
  678:                     #ret.append("%s"%person.encode('utf-8'))
  679:                     ret.append("%s"%person)
  680:         return string.join(ret,";")
  681:                          
  682:     def getProjectsOfMembers(self):
  683:         """give tuple member /projects"""
  684:         ret=[]
  685:         members=self.getAllMembers()
  686:         #return str(members)
  687:         for x in members:
  688:             ret+=self.getProjectsOfMember(name=x)
  689:             
  690:         return ret
  691: 
  692:     def getProjectsOfMember(self,name=None,email=None):
  693:         """get project of a member"""
  694:         def sortP(x,y):
  695:             """sort by sorting number"""
  696:             #print x.xdata_05,y.xdata_05
  697:             return cmp(x.WEB_title,y.WEB_title)
  698:         
  699:        
  700:         ret=[]
  701:         splitNeu=[]
  702:         if email:
  703:             members=self.ZopeFind(self.members,obj_metatypes=['MPIWGStaff'],obj_ids=[email])
  704:             name =  members[0][1].title.decode('utf-8')
  705: 
  706:         y=name
  707:         splitted=y.split(",")
  708:         #XXXX
  709:         splitNeu=["\'"+splitted[1]+" "+splitted[0]+"\'"]
  710:         
  711:         #for s in splitted:
  712:         #    splitNeu.append("\""+s+"\"")
  713:         search=string.join(splitNeu,' AND ')
  714:         
  715:         proj=self.ProjectCatalog({'xdata_01':search})
  716: 
  717:         if proj:
  718:             proj2=[]
  719:             for x in proj:
  720:              
  721:                 if not((splitted[1]==" Christoph") and (splitted[0]=="Hoffmann") and (str(x.WEB_title).find('Einstein')>0)):
  722:                        
  723:                        #print repr(splitted[1]),repr(splitted[0]),repr(x.WEB_title)
  724:                        proj2.append(x)
  725:         #    proj2.sort(sortP)
  726:         #    ret.append((y,proj2))
  727:         else:
  728:             proj2=[]
  729:             
  730:         proj=self.ProjectCatalog({'xdata_08':search})
  731:         if proj:
  732:             names=[x.WEB_title for x in proj]
  733:             for x in proj:
  734:                 if not x.WEB_title in names:
  735:                     proj2.append(x)
  736: 
  737: 
  738:         proj2.sort(sortP)
  739: 
  740:         if len(proj2)>0:
  741:             ret.append((y,proj2))
  742: 
  743:         return ret
  744:      
  745:     def givePersonList(self,name):
  746:         """check if person is in personfolder and return list of person objects"""
  747:         
  748:         splitted=name.split(",")
  749:         if len(splitted)==1:
  750:             splitted=name.lstrip().rstrip().split(" ")
  751:         splittedNew=[split.lstrip() for split in splitted]
  752:         
  753:         if splittedNew[0]=='':
  754:             del splittedNew[0]
  755:         search=string.join(splittedNew,' AND ')
  756:         if not search=='':
  757:             proj=self.MembersCatalog({'title':search})
  758: 
  759:         if proj:
  760:             return [[x.lastName,x.firstName] for x in proj]
  761:         else:
  762:             return []
  763:             
  764: ##         splitted=name.split(",") # version nachname, vorname...
  765: ##         if len(splitted)>1:
  766: ##             lastName=splitted[0] 
  767: ##             firstName=splitted[1]
  768: ##         else: 
  769: ##             splitted=name.split(" ") #version vorname irgenwas nachnamae
  770:         
  771: ##             lastName=splitted[len(splitted)-1]
  772: ##             firstName=string.join(splitted[0:len(splitted)-1])
  773: 
  774: ##         objs=[]
  775: 
  776:         #print  self.members 
  777:       ##   for x in self.members.__dict__:
  778: ##             obj=getattr(self.members,x)
  779: ##             if hasattr(obj,'lastName') and hasattr(obj,'firstName'):
  780:                 
  781: ##                 if (re.match(".*"+obj.lastName+".*",lastName) or re.match(".*"+lastName+".*",obj.lastName)) and (re.match(".*"+obj.firstName+".*",firstName) or re.match(".*"+firstName+".*",obj.firstName)):
  782:                     
  783: ##                     objs.append((obj,lastName+", "+firstName))
  784: 
  785:         
  786:         return objs
  787: 
  788: 
  789:     def personCheck(self,names):
  790:         """all persons for list"""
  791:         #print "names",names
  792:         splitted=names.split(";")
  793:         ret={}
  794:         for name in splitted:
  795: 
  796:             if not (name==""):
  797:                 try:
  798:                     ret[name]=self.givePersonList(name)
  799:                 except:
  800:                     """NOTHIHN"""
  801:         #print "RET",ret
  802:         return ret
  803: 
  804:     def giveCheckList(self,person,fieldname):
  805:         """return checklist"""
  806:         #print "GCL",fieldname
  807:         if fieldname=='xdata_01':
  808:             x=self.personCheck(person.getContent(fieldname))
  809:             #print "GCLBACKX",x
  810:             return x
  811:         
  812: 
  813:     def isCheckField(self,fieldname):
  814:         """return chechfield"""
  815:         
  816:         return (fieldname in checkFields)
  817: 
  818: 
  819:     
  820:     
  821:         
  822: def manage_addMPIWGRootForm(self):
  823:     """form for adding the root"""
  824:     pt=PageTemplateFile('Products/MPIWGWeb/zpt/addMPIWGRootForm.zpt').__of__(self)
  825:     return pt()
  826: 
  827: def manage_addMPIWGRoot(self,id,title,RESPONSE=None):
  828:     """add a root folder"""
  829:     newObj=MPIWGRoot(id,title)
  830:     self._setObject(id,newObj)
  831: 
  832:     if RESPONSE is not None:
  833:         RESPONSE.redirect('manage_main')
  834:         
  835: 
  836: class MPIWGProject(Folder):
  837:     """Class for Projects"""
  838: 
  839:     meta_type='MPIWGProject'
  840: 
  841:     def crossLinker(self):
  842:         """experimental crosslinker"""
  843:         splitted=self.WEB_project_description[0].split()
  844:         new=[]
  845:         for split in splitted:
  846:             try:
  847:                 found=self.DescriptionCatalog({'fulltext':split})
  848:           
  849:                 if len(found)>1:
  850:              
  851:                     new.append("<a href=%s>%s</a>"%(split,split))
  852:                 else:
  853:                     new.append(split)
  854:             except:
  855:                 new.append(split)
  856:         return string.join(new)
  857:             
  858:             
  859: 
  860: 
  861:     def generateTemplate(self,RESPONSE=None):
  862:         """Erzeuge Template für defined fields not_used"""
  863: 
  864:         id="index_html"
  865:         title=id
  866:         if self._getOb('index_html'):
  867:             self._delObject('index_html')
  868: 
  869:         
  870:         newObj=ZopePageTemplate(id,'TEXT')
  871:         self._setObject(id,newObj)
  872:         #self.manage_addPageTemplate(id,title)
  873:         if RESPONSE is not None:
  874:             RESPONSE.redirect('manage_main')
  875:             
  876:     def __init__(self, id, argv=None):
  877:         """initieriere classe"""
  878:         
  879:         self.id=id
  880:         self.title=id
  881:         if argv:
  882:             for arg in definedFields:
  883: 		try:
  884:                 	setattr(self,arg,argv[arg])
  885: 		except:
  886: 			setattr(self,arg,"")
  887:         else:
  888:             for arg in definedFields:
  889:                 setattr(self,arg,'')
  890:             
  891:     manage_options = Folder.manage_options+(
  892:         {'label':'Load New File','action':'loadNewFileForm'},
  893:         {'label':'Edit ProjectInfo','action':'editMPIWGProjectForm'},
  894:         {'label':'Edit BasisInfo','action':'editMPIWGBasisForm'},
  895:         {'label':'Edit Publications','action':'editMPIWGRelatedPublicationsForm'},
  896:         {'label':'Edit Themes & Disciplines','action':'editMPIWGDisciplinesThemesForm'},
  897:         )
  898: 
  899: 
  900:     def index_html(self):
  901:         """show homepage"""
  902: 	ext=self.ZopeFind(self.aq_parent,obj_ids=["project_main"])
  903: 
  904:         if ext:
  905:             return getattr(self,ext[0][1].getId())()
  906: 
  907:         pt=PageTemplateFile('Products/MPIWGWeb/zpt/project_main').__of__(self)
  908:         return pt()
  909: 
  910:     def getDataFields(self):
  911:         """giveListofDatafields"""
  912:         ret=[]
  913:         for x in range(1,14):
  914:             if not x in [6,10,9]: # not used fields
  915:                 ret.append('xdata_%02i'%x)
  916:         return ret
  917:             
  918:     def getDefinedFields(self):
  919:         """show all defined fields"""
  920:         
  921:         return definedFields
  922: 
  923:     def getAttribute(self,field):
  924:         """get attrbiute"""
  925:         return getattr(self,field)
  926: 
  927:     def getContent(self,field):
  928:         """Inhalt des Feldes"""
  929:         
  930:         text=u''
  931:         #print "FIELD",field
  932:         for x in getattr(self,field):
  933:             #print "HIHIIII"
  934:             
  935:             try:
  936:                 text +=x.encode('utf-8')
  937:             except:
  938:                 try:
  939:                     text =x.encode('utf-8')
  940:                 except:
  941:                     text=x.decode('latin-1').encode('utf-8')
  942:         
  943:         #delete separator (;) if  is there is one
  944:         ## try:
  945: ##             print text, text[len(text)-1]
  946: ##         except:
  947: ##             print "error:",text
  948:         try:
  949:             if text[len(text)-1]==";":
  950:                 text=text[0:len(text)-1]
  951:           
  952:                 
  953:         except:
  954:             """nothing"""
  955: 
  956:         text2=re.sub(r';([^\s])','; \g<1>',text)
  957:         #teste ob ergebnis leer und header dann nehme title
  958:         
  959:         if (text2=='') and (field=='WEB_project_header'):
  960:             return self.getContent('WEB_title')
  961: 
  962:         #teste ob WEB_project_description und keine führenden p tags
  963:         if (len(text2)>4) and (not text2[0:3]=='<p>') and (field=='WEB_project_description'):
  964:             return "<p>"+text2+"</p>"
  965:         #if text2=="Otto Sibum":
  966: 		#text2="H. Otto Sibum"
  967:         return text2
  968:     
  969:     def show_html(self):
  970:         """simple index"""
  971:         #return "HI"
  972:         pt=PageTemplateFile('Products/MPIWGWeb/zpt/MPIWGProject_index.zpt').__of__(self)
  973:         return pt()
  974: 
  975:     def editMPIWGProjectForm(self):
  976:         """editform"""
  977:         pt=PageTemplateFile('Products/MPIWGWeb/zpt/edit_MPIWGProject.zpt').__of__(self)
  978:         return pt()
  979: 
  980:     def editMPIWGProject(self,RESPONSE=None):
  981:         """edit the project"""
  982: 
  983:         #return self.REQUEST
  984:         for x in definedFields:
  985:             if self.REQUEST.has_key(x):
  986:                 
  987:                 setattr(self,x,[self.REQUEST[x].decode('utf-8')])
  988:             
  989:         if RESPONSE is not None:
  990:             RESPONSE.redirect('manage_main')
  991: 
  992:     def editMPIWGDisciplinesThemesForm(self):
  993:         """edit the disciplines and themes Form"""
  994:         pt=PageTemplateFile('Products/MPIWGWeb/zpt/edit_MPIWGDisciplinesThemes.zpt').__of__(self)
  995:         return pt()
  996: 
  997:     def editMPIWGDisciplinesThemes(self,disciplines=None,themes=None,RESPONSE=None):
  998:         """edit disciplin and form"""
  999:         if disciplines:
 1000:             if type(disciplines) is StringType:
 1001:                 self.xdata_09=disciplines
 1002:             else:
 1003:                 self.xdata_09=string.join(disciplines,";")
 1004:         else:
 1005:                 self.xdata_09=""
 1006:         if themes:
 1007:             if type(themes) is StringType:
 1008:                 self.xdata_10=themes
 1009:             else:
 1010:                 self.xdata_10=string.join(themes,";")
 1011:         else:
 1012:             self.xdata_10=""
 1013:             
 1014:         if RESPONSE is not None:
 1015:             RESPONSE.redirect('manage_main')
 1016: 
 1017: 
 1018:     def isChecked(self,wert,list):
 1019:         """check if wert is in ; seperated list"""
 1020:         print "W:",wert
 1021:         print "L:",list,type(list)
 1022:         #felder sind manchmnal als liste mit einem element definiert
 1023:         if type(list) is StringType or UnicodeType: 
 1024:             splitted=list.split(";")
 1025:         else:
 1026:             splitted=list[0].split(";")
 1027: 
 1028:         print splitted
 1029:         for x in splitted:
 1030:             if (not x==u'') and x in wert:
 1031:                 return 1
 1032:         return 0
 1033:     
 1034:     def editMPIWGBasisForm(self):
 1035:         """editform"""
 1036:         pt=PageTemplateFile('Products/MPIWGWeb/zpt/edit_MPIWGBasis.zpt').__of__(self)
 1037:         return pt()
 1038:     def editMPIWGRelatedPublicationsForm(self):
 1039:         """Edit related Publications"""
 1040:         pt=PageTemplateFile('Products/MPIWGWeb/zpt/edit_MPIWGRelatedPublications.zpt').__of__(self)
 1041:         return pt()
 1042:         
 1043:     
 1044:     def loadNewFileForm(self):
 1045:         """Neues XML-File einlesen"""
 1046:         pt=PageTemplateFile('Products/MPIWGWeb/zpt/MPIWGProject_newfile.zpt').__of__(self)
 1047:         return pt()
 1048: 
 1049:     def loadNewFile(self,RESPONSE=None):
 1050:         """einlesen des neuen files"""
 1051:         fileupload=self.REQUEST['fileupload']
 1052:         if fileupload:
 1053:             file_name=fileupload.filename
 1054:             filedata=fileupload.read()
 1055: 
 1056:             argv=xmlhelper.proj2hash(filedata)
 1057:             #print argv.keys()
 1058:             for arg in definedFields:
 1059:                 
 1060:                 #print arg,argv[arg],getattr(self,arg)
 1061:                 try:
 1062:                     temp=argv[arg][0:]
 1063:                     #old=getattr(self,arg)
 1064:                     setattr(self,arg,temp)
 1065:                     #print old,getattr(self,arg)
 1066:                 except:
 1067:                     """nothing"""
 1068:                     
 1069:         if RESPONSE is not None:
 1070:             RESPONSE.redirect('manage_main')
 1071: 
 1072: def manage_addMPIWGProjectForm(self):
 1073:     """form for adding the project"""
 1074:     pt=PageTemplateFile('Products/MPIWGWeb/zpt/addMPIWGProjectForm.zpt').__of__(self)
 1075:     return pt()
 1076: 
 1077: def manage_addMPIWGProject(self,id,RESPONSE=None):
 1078:     """method to add a project"""
 1079:     #print argv
 1080:     fileupload=self.REQUEST.get('fileupload',None)
 1081:     if fileupload:
 1082:         print fileupload
 1083:         file_name=fileupload.filename
 1084:         filedata=fileupload.read()
 1085:         
 1086:         argv=xmlhelper.proj2hash(filedata)
 1087:         
 1088:         #print argv
 1089:         newObj=MPIWGProject(id,argv)
 1090:     else:
 1091:         newObj=MPIWGProject(id)
 1092: 
 1093:     self._setObject(id,newObj)
 1094: 
 1095: 
 1096:     if RESPONSE is not None:
 1097:         RESPONSE.redirect('manage_main')

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>