Return to MPIWGProjects.py CVS log

Up to [Repository] / MPIWGWeb

new  database handling, major changes to minimize filemaer parts

    1: """This contains the class MPIWG Projects
    2: for organizing and maintaining the different project pages
    3: 
    4: """
    5: #TODO: mechanismus fur links to personen ueberarbeiten, da jetzt alle e_mails als members auftauchen unabhaengig vom status publish_the_data
    6: 
    7: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
    8: from Products.PageTemplates.PageTemplate import PageTemplate
    9: from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
   10: from Products.ZSQLExtend.ZSQLExtend import ZSQLExtendFolder
   11: from Products.ZCatalog.CatalogPathAwareness import CatalogAware
   12: from OFS.Image import Image
   13: from Globals import package_home
   14: import urllib
   15: import MPIWGStaff
   16: import string
   17: import re
   18: import os
   19: from types import *
   20: import zLOG
   21: import xmlhelper # Methoden zur Verwaltung der projekt xml
   22: from OFS.SimpleItem import SimpleItem
   23: from OFS.Folder import Folder
   24: from Products.ZSQLMethods.SQL import SQLConnectionIDs
   25: from AccessControl import ClassSecurityInfo
   26: from bibliography import *
   27: import time
   28: import xml.dom.minidom
   29: import sys
   30: 
   31: 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']
   32: 
   33: checkFields = ['xdata_01']
   34: 
   35: 
   36: def getTextFromNode(nodename):
   37:     nodelist=nodename.childNodes
   38:     rc = ""
   39:     for node in nodelist:
   40:         if node.nodeType == node.TEXT_NODE:
   41:            rc = rc + node.data
   42:     return rc
   43: 
   44: def sortF(x,y):
   45:     try:
   46:         return cmp(x[1],y[1])
   47:     except:
   48:         try:
   49:             return cmp(str(x[1]),str(y[1]))
   50:         except:           
   51:             
   52:             return 0 
   53:     
   54: def sortI(x,y):
   55:     xsplit=x[1].split(".")
   56:     ysplit=y[1].split(".")
   57:     xret=""
   58:     yret=""
   59:     try:
   60:         for i in range(5):
   61:             try:
   62:                 yret=yret+"%04i"%int(xsplit[i])
   63:             except:
   64:                 yret=yret+"%04i"%0
   65: 
   66:             try:
   67:                 xret=xret+"%04i"%int(ysplit[i])
   68:             except:
   69:                 xret=xret+"%04i"%0
   70:                 
   71:         
   72:         return cmp(int(yret),int(xret))
   73:     except:
   74:         return cmp(x[1],y[1])
   75: 
   76: class MPIWGLink(SimpleItem):
   77:     """create a symbolic link to another page"""
   78: 
   79:     meta_type="MPIWGLink"
   80:     
   81:     def isActiveItem(self):
   82:         """teste ob ausgewaehlt"""
   83:         #url1 beim link anstelle von url1, da link jeweils index_html als url hat.
   84:         if self.absolute_url()==self.REQUEST['URL1']:
   85:             return "aktiv"
   86:         else:
   87:             return ""
   88: 
   89:     def __init__(self,id,link,title='',weight=''):
   90:         """init mpiwglink"""
   91:         self.id=id
   92:         self.link=link
   93:         self.title=title
   94:         self.weight=weight
   95: 
   96:     def getObj(self):
   97:         """bekomme original"""
   98:        ##  objpath=self.link.replace("/",".")
   99: ##         if objpath[0]!=".":
  100: ##             objpath="."+objpath
  101: 
  102: ##         print objpath
  103: ##         return eval("self"+objpath)
  104: 
  105: 
  106:         splitted=self.link.lstrip().split("/")
  107:         obj=self
  108:         for x in splitted:
  109:             if not x=="":
  110:               obj=getattr(obj,x)
  111:             
  112:         return obj
  113: 
  114:     def getWeight(self):
  115:         if self.linkWeight and linkWeight!="":
  116:             return self.linkWeight
  117:         else:
  118:             return self.getObj().weight
  119: 
  120:     manage_options=SimpleItem.manage_options+(
  121:         {'label':'main config','action':'changeLinkForm'},
  122:         )
  123: 
  124: 
  125:     def changeLinkForm(self):
  126:         """change MPIWG link"""
  127:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGLinkChange.zpt')).__of__(self)
  128:         return pt()
  129: 
  130:     def changeLink(self,link,title,weight,RESPONSE=None):
  131:         """change links"""
  132:         self.link=link
  133:         self.title=title
  134:         self.weight=weight
  135: 
  136:         if RESPONSE is not None:
  137:             RESPONSE.redirect('manage')
  138: 
  139:     def index_html(self):
  140:         """index"""
  141:         
  142:         return self.getObj().pt_render(extra_context={'here':self})
  143:                                        
  144: 
  145: def manage_addMPIWGLinkForm(self):
  146:     """Form for adding link"""
  147:     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt/AddMPIWGLink.zpt')).__of__(self)
  148:     return pt()
  149: 
  150: def manage_addMPIWGLink(self,id,link,title,weight,RESPONSE=None):
  151:     """add link"""
  152:     newObj=MPIWGLink(id,link,title,weight)
  153: 
  154:     self._setObject(id,newObj)
  155:     
  156:     if RESPONSE is not None:
  157:         RESPONSE.redirect('manage_main')
  158: 
  159: 
  160: class MPIWGTemplate(ZopePageTemplate):
  161:     """Create a layout Template for different purposes"""
  162: 
  163:     meta_type="MPIWGTemplate"
  164: 
  165:     manage_options=ZopePageTemplate.manage_options+(
  166:         {'label':'Change Weight','action':'changeWeightForm'},
  167:         )
  168: 
  169:     def changeWeightForm(self):
  170:         """change weight form"""
  171:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGTemplateChangeWeight.zpt')).__of__(self)
  172:         return pt()
  173: 
  174:     def changeWeight(self,weight,RESPONSE=None):
  175:         """change weight"""
  176:         self.weight=weight
  177:         if RESPONSE is not None:
  178:             RESPONSE.redirect('manage')
  179: 
  180:         
  181:     def __init__(self, id, text=None, content_type=None,MPIWGType=None):
  182:         self.id = str(id)
  183: 
  184: 
  185: 
  186:         self.ZBindings_edit(self._default_bindings)
  187:         if text is None:
  188:             self._default_content_fn = os.path.join(package_home(globals()),
  189:                                                'zpt/MPIWG_%s_template_standard.zpt'%MPIWGType)
  190:             text = open(self._default_content_fn).read()
  191:         self.pt_edit(text, content_type)
  192: 
  193:     
  194:         """change form"""
  195: 
  196:     def isActiveItem(self):
  197:         """teste ob ausgewaehlt"""
  198:         if self.absolute_url()==self.REQUEST['URL']:
  199:             return "aktiv"
  200:         else:
  201:             return ""
  202:         
  203: def manage_addMPIWGTemplateForm(self):
  204:     """Form for adding"""
  205:     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt/AddMPIWGTemplate.zpt')).__of__(self)
  206:     return pt()
  207: 
  208: from urllib import quote
  209: 
  210: 
  211: def manage_addMPIWGTemplate(self, MPIWGType,id, title=None,weight=0,REQUEST=None):
  212:     "Add a Page Template with optional file content."
  213:     if type(MPIWGType)==StringType:
  214:         MPIWGTypes=[MPIWGType]
  215:     else:
  216:         MPIWGTypes=MPIWGType
  217:         
  218:     for singleType in MPIWGTypes:
  219: 
  220: 
  221:         if REQUEST is None:
  222:             self._setObject(id, MPIWGTemplate(id, text,EchoType=singleType))
  223:             ob = getattr(self, id)
  224:             
  225:             if title:
  226:                 ob.pt_setTitle(title)
  227:             return ob
  228:         else:
  229:             file = REQUEST.form.get('file')
  230:             headers = getattr(file, 'headers', None)
  231:             if headers is None or not file.filename:
  232:                 zpt = MPIWGTemplate(id,MPIWGType=singleType)
  233:             else:
  234:                 zpt = MPIWGTemplate(id, file, headers.get('content_type'))
  235: 
  236:             self._setObject(id, zpt)
  237:             ob = getattr(self, id)
  238:             if title:
  239:                 ob.pt_setTitle(title)
  240: 
  241:             try:
  242:                 u = self.DestinationURL()
  243:             except AttributeError:
  244:                 u = REQUEST['URL1']
  245: 
  246:     ob = getattr(self, id)
  247:     ob.weight=weight
  248:     
  249:     REQUEST.RESPONSE.redirect(u+'/manage_main')
  250:     return ''
  251: 
  252:     
  253: class MPIWGRoot(ZSQLExtendFolder):
  254:     """Stammordner für den Web-Server"""
  255: 
  256:     fieldLabels={'WEB_title':'WEB_Title','xdata_01':'Responsible Scientists','xdata_02':'Department',
  257:              'xdata_03':'Historical Persons','xdata_04':'Time period',
  258:              'xdata_05':'Sorting number','xdata_06':'Keywords','xdata_07':'Short title',
  259:              'xdata_08':'Other involved scholars' ,'xdata_09':'Disciplines','xdata_10':'Themes',
  260:              'xdata_11':'Object Digitallibrary','xdata_12':'Cooperation partners',
  261:              'xdata_13':'Funding institutions','WEB_project_header':'WEB_project_header',
  262:              'WEB_project_description':'WEB_project_description','WEB_related_pub':'WEB_related_pub'}
  263:     
  264:     folders=['MPIWGProject','Folder','ECHO_Navigation']
  265:     meta_type='MPIWGRoot'
  266: 
  267:     def versionHeaderEN(self):
  268:         """version header text"""
  269:         
  270:         date= self.REQUEST.get('date',None)
  271:         if date:
  272:             txt="""<h2>This pages shows the project which existed at %s</h2>"""%str(date)
  273:             return txt
  274:         return ""
  275: 
  276:     def versionHeaderDE(self):
  277:         """version header text"""
  278:         date= self.REQUEST.get('date',None)
  279:         if date:
  280:             txt="""<h2>Auf dieser Seite finden Sie die Projekte mit Stand vom %s</h2>"""%str(date)
  281:         return ""
  282:     
  283:         
  284:     def createOrUpdateId_raw(self):
  285:         """create sequence to create ids for bibliography"""
  286:         debug=None
  287:         #suche groesste existierende id
  288:         founds=self.ZSQLQuery("select id from bibliography")
  289:         
  290:         if founds:
  291:             ids=[int(x.id[1:]) for x in founds]
  292:             maximum=max(ids)
  293:             
  294:             id_raw=self.ZSQLQuery("select nextval('id_raw_test')",debug=debug)
  295:             
  296:             if id_raw:
  297:                 self.ZSQLQuery("drop sequence id_raw_test",debug=debug)
  298:             
  299:             self.ZSQLQuery("create sequence id_raw_test start %i"%(maximum+1),debug=debug)
  300:         
  301:     
  302:     def queryLink(self,link):
  303:         """append querystring to the link"""
  304:         return "%s?%s"%(link,self.REQUEST.get('QUERY_STRING',''))
  305: 
  306:     def getKategory(self,url):
  307:         """kategorie"""
  308:         splitted=url.split("/")
  309:         return splitted[4]
  310: 
  311:     def generateUrlProject(self,url,project=None):
  312:         """erzeuge aus absoluter url, relative des Projektes"""
  313:         if project:
  314:             splitted=url.split("/")
  315:             length=len(splitted)
  316:             short=splitted[length-2:length]
  317:             
  318:             base=self.REQUEST['URL3']+"/"+"/".join(short)
  319: 
  320:         else:
  321:             findPart=url.find("/projects/")
  322:             base=self.REQUEST['URL1']+"/"+url[findPart:]
  323: 
  324:                 
  325:         return base
  326:     
  327:     def isNewCapital(self,text=None,reset=None):
  328:         if reset:
  329:             self.REQUEST['capital']="A"
  330:             return True
  331:         else:
  332:             if len(text)>0 and not (text[0]==self.REQUEST['capital']):
  333:                 self.REQUEST['capital']=text[0]
  334:                 return True
  335:             else:
  336:                 return False
  337:         
  338:     def subNav(self,obj):
  339:         """return subnav elemente"""
  340:         def sortWeight(x,y):
  341:             x1=int(getattr(x[1],'weight','0'))
  342:             y1=int(getattr(y[1],'weight','0'))
  343:             return cmp(x1,y1)
  344:         #if obj.meta_type in ['MPIWGTemplate','MPIWGLink']:
  345:         #    id=obj.aq_parent.getId()
  346:         #else:
  347: 
  348:         #id=obj.getId()
  349: 
  350:         
  351:         #suche die zweite ebene
  352:         if not obj.aq_parent.getId() in ['de','en']:
  353:             obj=obj.aq_parent
  354:             
  355:         while not self.ZopeFind(self,obj_ids=[obj.getId()]):
  356:             obj=obj.aq_parent
  357:         
  358:         if hasattr(self,obj.getId()):
  359:             
  360:             subs=self.ZopeFind(getattr(self,obj.getId()),obj_metatypes=['MPIWGTemplate','MPIWGLink'])
  361:             subret=[]
  362: 
  363:             for x in subs:
  364:                 if not(x[1].title==""):
  365:                     subret.append(x)
  366:             subret.sort(sortWeight)
  367:             return subret
  368:         else:
  369:             return None
  370: 
  371:     def isActive(self,name):
  372:         """teste ob subnavigation aktiv"""
  373:         for part in self.REQUEST['URL'].split("/"):
  374:             if part==name:
  375:                 return True
  376:         return False
  377:         
  378:         
  379:     def upDateSQL(self,fileName):
  380:         """updates SQL databases using fm.jar"""
  381:         fmJarPath=os.path.join(package_home(globals()), 'updateSQL/fm.jar')
  382:         xmlPath=os.path.join(package_home(globals()), "updateSQL/%s"%fileName)
  383:         zLOG.LOG("MPIWG Web",zLOG.INFO,"java -classpath %s -Djava.awt.headless=true Convert %s"%(fmJarPath,xmlPath))
  384:         ret=os.popen("java -classpath %s -Djava.awt.headless=true Convert %s"%(fmJarPath,xmlPath),"r").read()
  385:         zLOG.LOG("MPIWG Web",zLOG.INFO,"result convert: %s"%ret)
  386:         return 1
  387:     
  388:     def patchProjects(self,RESPONSE):
  389:         """patch"""
  390:         projects=self.ZopeFind(self.projects,obj_metatypes=['MPIWGProject'])
  391:         for project in projects:
  392:                 tmp=project[1].WEB_project_description[0].replace("/CD/projects/","")[0:]
  393:                 setattr(project[1],'WEB_project_description',[tmp[0:]])
  394:                 RESPONSE.write("<p>%s</p>\n"%project[0])
  395:             
  396:     def replaceNotEmpty(self,format,field):
  397:         """replace not empty"""
  398:         if field and (not field.lstrip()==''):
  399:             return format%field
  400:         else:
  401:             return ""
  402:         
  403: 
  404:     def isActual(self,project):
  405:         """checke if project is actual"""
  406:         actualTime=time.localtime()
  407:         obj= project.getObject()
  408:         
  409:         if getattr(obj,'archiveTime',actualTime)< actualTime:
  410:             return False
  411:         else:
  412:             return True
  413:         
  414:     def redirectIndex_html(self,request):
  415:         #return request['URL1']+'/index_html'
  416:         
  417:         return urllib.urlopen(request['URL1']+'/index_html').read()
  418: 
  419:     
  420:     def formatBibliography(self,here,found):
  421:         """format"""
  422:         return formatBibliography(here,found)
  423:     
  424:     def getValue(self,fieldStr):
  425:         """Inhalt des Feldes"""
  426:         
  427:         if type(fieldStr)==StringType:
  428:             field=fieldStr
  429:         else:
  430:             field=fieldStr[0]
  431:         try:
  432:             if field[len(field)-1]==";":
  433:                 field=field[0:len(field)-1]
  434:         except:
  435: 
  436:             """nothing"""
  437:         field=re.sub(r';([^\s])','; \g<1>',field)
  438:         return field.encode('utf-8')
  439: 
  440: 
  441:     
  442:     def sortedNames(self,list):
  443:         """sort names"""
  444: 
  445:         def sortLastName(x_c,y_c):
  446:             try:
  447:                 x=urllib.unquote(x_c).encode('utf-8','ignore')
  448:             except:
  449:                 x=urllib.unquote(x_c)
  450: 
  451:             try:
  452:                 y=urllib.unquote(y_c).encode('utf-8','ignore')
  453:             except:
  454:                 x=urllib.unquote(y_c)
  455:                 
  456: 
  457:             
  458:             try:
  459:                 last_x=x.split()[len(x.split())-1]
  460:                 last_y=y.split()[len(y.split())-1]
  461: 
  462:             except:
  463: 
  464:                 last_x=""
  465:                 last_y=""
  466:             
  467:             
  468:             
  469:             if last_x<last_y:
  470:                 return 1
  471:             elif last_x>last_y:
  472:                 return -1
  473:             else:
  474:                 return 0
  475:             
  476:         list.sort(sortLastName)
  477:         list.reverse()
  478:         
  479:         return list
  480:     
  481:     def __init__(self, id, title):
  482:         """init"""
  483:         self.id=id
  484:         self.title=title
  485: 
  486:     def urlQuote(self,str):
  487:         """quote"""
  488:         return urllib.quote(str)
  489: 
  490:     def urlUnQuote(self,str):
  491:         """quote"""
  492:         return urllib.unquote(str)
  493:     
  494:     def harvestHistoricalPersons(self):
  495:         """erstelle liste aller erwaehnten actors"""
  496: 
  497:         def normalize(str):
  498:             """loesche fuhrendes space"""
  499:             if (len(str)>1) and (str[0]==" "):
  500:                 ret=str[1:]
  501:             else:
  502:                 ret=str
  503:             return ret
  504:         
  505:         list={}
  506:         projects=self.ZopeFind(self.projects,obj_metatypes=['MPIWGProject'])
  507:         
  508:         for project in projects:
  509:             lg=len(project[1].xdata_03[0])-1
  510: 
  511:             if (lg>1) and (project[1].xdata_03[0][lg]==";"):
  512:                 project[1].xdata_03[0]=project[1].xdata_03[0][0:lg]
  513: 
  514:           
  515:      
  516:                 
  517:             try:
  518:                 if len(project[1].xdata_03[0].split(";"))>1: # guess if separator is ;
  519:                     for person in project[1].xdata_03[0].split(";"):
  520:                         personNormal=normalize(person)
  521:                         if personNormal in list.keys():
  522:                             list[urllib.quote(personNormal)][1].append(project[1])
  523:                         else:
  524:                             list[urllib.quote(personNormal)]=(personNormal,[project[1]])
  525:                 else: #guess , is sepeator
  526:                     for person in project[1].xdata_03[0].split(","):
  527:                         personNormal=normalize(person)
  528:                         if urllib.quote(personNormal) in list.keys():
  529:                             list[urllib.quote(personNormal)][1].append(project[1])
  530:                         else:
  531:                             list[urllib.quote(personNormal)]=(personNormal,[project[1]])
  532: 
  533:             except:
  534:                 zLOG.LOG("MPIWG Web (harvestHistoricalPerson)",zLOG.ERROR,"cannot annalyize: %s"%repr(project))
  535: 
  536:                 
  537:         return list
  538: 
  539:     def storeHistoricalPersons(self,RESPONSE=None):
  540:         """store persons"""
  541:         self.personDict={}
  542:         personDict=self.harvestHistoricalPersons()
  543:         for person in personDict.keys():
  544:             for project in personDict[person][1]:
  545:                 if person in self.personDict.keys():
  546:                     self.personDict[person][1].append((project.absolute_url(),project.WEB_title[0],project.xdata_01[0]))
  547:                 else:
  548:                     self.personDict[person]=(personDict[person][0],[(project.absolute_url(),project.WEB_title[0],project.xdata_01[0])])
  549: 
  550:         if RESPONSE is not None:
  551:             RESPONSE.redirect("showHistoricalPersons")
  552:             
  553: 
  554:     def getPersonDict(self,name):
  555:         """name von dict"""
  556: 
  557:         try:
  558:             return self.personDict[name][0].encode('utf-8')
  559:         except:
  560:             return self.personDict[name][0]
  561:             return self.personDict[name][0].decode('latin-1').encode('utf-8')
  562:         
  563: 
  564:     def showHistoricalPersons(self):
  565:         """show persons"""
  566:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','showHistoricalPersons')).__of__(self)
  567:         return pt()
  568: 
  569:         
  570:     def editHistoricalPersonsForm(self):
  571:         """edit historical persons for consistency"""
  572:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editHistoricalPersonsForm')).__of__(self)
  573:         return pt()
  574: 
  575:     def getProjectsByFieldContent(self,fieldName,fieldContentsEntry, date=None):
  576:         """gib alle Projekte aus mit Value von field mit fieldName enthält ein Element der Liste fieldContents"""
  577:         def sort(x,y):
  578:                 return cmp(x.WEB_title[0],y.WEB_title[0])
  579: 
  580:         if type(fieldContentsEntry) is StringType:
  581:             fieldContentsTmp=[fieldContentsEntry]
  582:         else:
  583:             fieldContentsTmp=fieldContentsEntry
  584: 
  585:         fieldContents=[]
  586:         for x in fieldContentsTmp:
  587:             fieldContents.append(" AND ".join(x.split()))
  588:         projects=self.ProjectCatalog({fieldName:string.join(fieldContents,' AND')})
  589:         #print projects
  590:         #ret=[x for x in projects]
  591:         ret=[]
  592:         for x in projects:
  593:             obj=x.getObject()
  594:             obj=obj.getActualVersion(date)
  595:             if obj and (not getattr(obj,'invisible',None)):
  596:                 #if not (x in ret):
  597:                     ret.append(x)
  598: 
  599:         ret.sort(sort)
  600:         return ret
  601: 
  602:     def changeMPIWGRootForm(self):
  603:         """edit"""
  604:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeMPIWGRootForm')).__of__(self)
  605:         return pt()
  606: 
  607:     def changeMPIWGRoot(self,title,disciplineList,themesList,connection_id,RESPONSE=None):
  608:         """change"""
  609:         self.title=title
  610:         self.connection_id=connection_id
  611:         self.disciplineList=disciplineList
  612:         self.themesList=themesList
  613: 
  614:         if RESPONSE is not None:
  615:             RESPONSE.redirect('manage_main')
  616: 
  617:     def getDisciplineList(self):
  618:         """get disciplines as list"""
  619:         list= self.disciplineList.split("\n")
  620:         return [x.rstrip().lstrip() for x in list]
  621:     
  622:     def getThemeList(self):
  623:         """get themes as list"""
  624:         list= self.themesList.split("\n")
  625:         return [x.rstrip().lstrip() for x in list]
  626:     
  627:     def test(self):
  628:         """test"""
  629:         return self.getProjectsByFieldContent('xdata_09',['biology'])[0].absolute_url
  630: 
  631:     def getContexts(self,childs=None,parents=None,depth=None,date=None):
  632:         """childs alle childs, alle parents"""
  633:         ret=[]
  634:         
  635:         if parents:
  636:             splitted=parents.split(".")
  637:             parentId=string.join(splitted[0:len(splitted)-1],".")
  638:         
  639:             for project in self.getProjectFields('xdata_05',sort='int',date=date):
  640:                 if project[1]==parentId:
  641:                     ret.append(project)
  642: 
  643:         if childs:
  644:             for project in self.getProjectFields('xdata_05',sort='int',date=date):
  645:                 searchStr=childs+"(\..*)"
  646:                 if re.match(searchStr,project[1]):
  647:                     
  648:                     if depth:
  649: 
  650:                         if int(depth)>=len(project[1].split("."))-len(childs.split(".")):
  651:                     
  652:                             ret.append(project)
  653:                     else:
  654:                         ret.append(project)
  655:         return ret
  656:     
  657:     def getProjectFields(self,fieldName,date=None,folder=None,sort=None):
  658:         """getListofFieldNames"""
  659:         ret=[]
  660:     
  661:         objects=self.ZopeFind(self.projects,obj_metatypes=['MPIWGProject'],search_sub=0)
  662: 
  663:                 
  664:         for object in objects:
  665:             obj=object[1]
  666:             obj=obj.getActualVersion(date)
  667:             if obj and (not getattr(obj,'invisible',None)):
  668:                 if fieldName=="WEB_title_or_short":
  669: 
  670:                     if len(obj.getContent('xdata_07'))<3: # hack weil z.Z. manchmal noch ein Trennzeichen ; oder , im Feld statt leer
  671:                         fieldNameTmp="WEB_title"
  672:                     else:
  673:                         fieldNameTmp="xdata_07"
  674:                 else:
  675:                     fieldNameTmp=fieldName
  676: 
  677:                 ret.append((obj,obj.getContent(fieldNameTmp)))
  678: 
  679:         
  680:         if sort=="int":
  681:             ret.sort(sortI)
  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:     manage_options = Folder.manage_options+(
  698:         {'label':'Update Personal Homepages','action':'updateHomepages'},
  699:         {'label':'Main config','action':'changeMPIWGRootForm'},
  700:         {'label':'Edit Historical Persons','action':'editHistoricalPersonsForm'},
  701:         {'label':'Store Historical Persons','action':'storeHistoricalPersons'},
  702:         )
  703:     
  704:     def importNamesForm(self):
  705:         """Form"""
  706:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGNamesForm.zpt')).__of__(self)
  707:         return pt()
  708: 
  709:     def importNames(self,fileupload,folderName,RESPONSE=None):
  710:         """import komma-sep list email,lastName,firstName"""
  711:         project=getattr(self,folderName)
  712:         load=fileupload.read()
  713:         
  714:         for line in load.split('\r'):
  715:             
  716:             
  717:             splitted=line.split(",")
  718:            # print splitted
  719:         
  720:             if not (splitted[0]==""):
  721:                 newObj=MPIWGStaff.MPIWGStaff(splitted[0],splitted[1],splitted[2])
  722:                 
  723:                 try:
  724:                     project._setObject(splitted[0],newObj)
  725:                     #print "done:",splitted[0]
  726:                 except:
  727:                     zLOG.LOG("MPIWG Web (importNames)",zLOG.INFO,"cannot import: %s"%splitted[0])
  728: 
  729:                     
  730:         if RESPONSE is not None:
  731:             RESPONSE.redirect('manage_main')
  732: 
  733:     def updatePublicationDB(self,personId=None):
  734:         """updates the publication db, i.e. copy year into the main table"""
  735:         
  736:         if personId:
  737:             founds = self.ZSQLInlineSearch(_table="publications",id_main=personId)
  738:         else:
  739:             founds = self.ZSQLInlineSearch(_table="publications")
  740:             
  741:         for found in founds:
  742: 
  743:             if found.id_institutsbibliographie and (not found.id_institutsbibliographie ==""):
  744:                 entries = self.ZSQLInlineSearch(_table="institutsbiblio",id=found.id_institutsbibliographie)
  745:                 for entry in entries:
  746:                     self.ZSQLChange(_table='publications',_identify='oid=%s' % found.oid,year=entry.year,referencetype=entry.reference_type)
  747:                     
  748:             if found.id_gen_bib and (not found.id_gen_bib ==""):
  749:                 entries = self.ZSQLInlineSearch(_table="bibliography",id=found.id_gen_bib)
  750:                 for entry in entries:
  751:                     self.ZSQLChange(_table='publications',_identify='oid=%s' % found.oid,year=entry.year,referencetype=entry.reference_type)
  752:                     
  753:         return True        
  754:         
  755:     def updateHomepage_neu(self,RESPONSE=None):
  756:         """ update"""
  757:         RESPONSE.write("<html><body>\n")
  758:         url="http://itgroup.mpiwg-berlin.mpg.de:8050/FMPro?-db=personal-www&-format=-dso_xml&-lay=sql_export&-max=10000&-findall"
  759:         fh=urllib.urlopen(url)
  760:         dom=xml.dom.minidom.parse(fh)
  761:         
  762:         
  763:         memberFolder=getattr(self,'members')
  764:         members=memberFolder.ZopeFind(memberFolder,obj_metatypes=["MPIWGStaff"])
  765:         
  766:         memberList=[x[0] for x in members]
  767:         
  768:         for row in dom.getElementsByTagName('ROW'):
  769:             username=getTextFromNode(row.getElementsByTagName('username')[0])
  770:             id=getTextFromNode(row.getElementsByTagName('ID')[0])
  771:             name=getTextFromNode(row.getElementsByTagName('Name')[0])
  772:             vorname=getTextFromNode(row.getElementsByTagName('Vorname')[0])
  773:             title=getTextFromNode(row.getElementsByTagName('Title')[0])
  774:             e_mail=getTextFromNode(row.getElementsByTagName('e_mail')[0])
  775:             e_mail_p=getTextFromNode(row.getElementsByTagName('e_mail_p')[0])
  776:             date_from=getTextFromNode(row.getElementsByTagName('Date_from')[0])
  777:             date_to=getTextFromNode(row.getElementsByTagName('Date_to')[0])
  778:             abteilung=getTextFromNode(row.getElementsByTagName('Abteilung')[0])
  779:             heimat_inst=getTextFromNode(row.getElementsByTagName('heimat_inst')[0])
  780:             funded_by=getTextFromNode(row.getElementsByTagName('funded_by')[0])
  781:             e_mail2=getTextFromNode(row.getElementsByTagName('e_mail2')[0])
  782:             publish_the_data=getTextFromNode(row.getElementsByTagName('publish_the_data')[0])
  783:            
  784:             cwNode=row.getElementsByTagName('current_work.current')[0]
  785:             cw=cwNode.getElementsByTagName('DATA')
  786:             if cw:
  787:                 txt=getTextFromNode(cw[0])
  788:             else:
  789:                 txt=""
  790:            
  791:             cwNode=row.getElementsByTagName('current_work.publish')[0]
  792:             cw=cwNode.getElementsByTagName('DATA')
  793:             if cw:
  794:                 txt_p=getTextFromNode(cw[0])
  795:             else:
  796:                 txt_p=""
  797:              
  798:             project=getattr(self,'members')
  799:             
  800:             if not (username in memberList):#neuer eintrag
  801:                 try:
  802:                     newObj=MPIWGStaff.MPIWGStaff(str(username),name,vorname)
  803:                     memberFolder._setObject(str(username),newObj)
  804:                     RESPONSE.write("<p>new:%s</p>\n"%username.encode('utf-8'))
  805:                     obj=getattr(memberFolder,username)
  806:                     obj.createNewDBEntry(publish_the_data,id,name,
  807:                                           vorname,title,e_mail,
  808:                                           e_mail_p,date_from,date_to,
  809:                                           abteilung,heimat_inst,funded_by,
  810:                                           e_mail2,txt,txt_p)
  811:                 except:
  812:                     RESPONSE.write("<p>ERROR:%s %s %s</p>\n"%(username.encode('utf-8'),name.encode('utf-8'),vorname.encode('utf-8')))
  813:                     RESPONSE.write("<p>      : %s %s"%sys.exc_info()[:2])
  814:             else:
  815:                 RESPONSE.write("<p>update:%s</p>\n"%username.encode('utf-8'))
  816:                 self.ZSQLChange(_table="personal_www",_identify="id=%s"%id,publish_the_data=publish_the_data,
  817:                                    date_from=date_from,
  818:                                    date_to=date_to)
  819:                   
  820:           
  821:            
  822:         return True
  823:         
  824:     def updateHomepages(self,RESPONSE):
  825:         """lege members an"""
  826:         self.upDateSQL('personalwww.xml')
  827:         founds=self.ZSQLInlineSearch(_table='personal_www',publish_the_data='yes')
  828:         project=getattr(self,'members')
  829:         for found in founds:
  830:             
  831:             if not (found.e_mail==""):
  832:                 newObj=MPIWGStaff.MPIWGStaff(found.username,found.name,found.vorname)
  833:                 
  834:                 try:
  835:                     project._setObject(found.username,newObj)
  836:                     RESPONSE.write("<p>new:%s</p>\n"%found.username)
  837:                 except:
  838:                     RESPONSE.write("<p>old:%s (%s,%s)</p>\n"%(found.username,found.name,found.vorname))
  839: 
  840:                 
  841: 
  842:         #delete non existing
  843: 
  844: 
  845:         foundUserNames=[x.username for x in founds]
  846:         for member in self.ZopeFind(self,obj_metatypes=["MPIWGStaff"],search_sub=1):            
  847:             
  848:             if member[1].getId() not in foundUserNames:
  849:                 member[1].aq_parent.manage_delObjects(ids=[member[1].getId()])
  850:                 RESPONSE.write("<p>deleted:%s</p>\n"%member[1].getId())
  851:         try:
  852:             self.MembersCatalog.manage_catalogReindex(self.REQUEST,RESPONSE,self.REQUEST['URL1'])
  853:         except:
  854:             pass
  855:         self.ProjectCatalog.manage_catalogReindex(self.REQUEST,RESPONSE,self.REQUEST['URL1'])
  856:     
  857:         self.updatePublicationDB() 
  858:            
  859:         if RESPONSE is not None:
  860:             RESPONSE.redirect('manage_main')
  861: 
  862:         
  863:     def getAllMembers(self):
  864:         """give list of all members"""
  865:         ret=[]
  866: 
  867:         #for x in self.members.objectValues('MPIWGStaff'):
  868:             #print x.title
  869:         #    ret.append(x.title.decode('utf-8'))
  870: 
  871:         for x in self.ZopeFind(self.members,obj_metatypes=['MPIWGStaff']):
  872:                                ret.append(x[1].title.decode('utf-8'))
  873:             
  874:         ret.sort()
  875:         #print ret
  876:   
  877:         return ret
  878: 
  879:     def printAllMembers(self):
  880:         """prin"""
  881:         members=self.getAllMembers()
  882:         ret=""
  883:         for x in members:
  884:             ret+="<p>%s</p>"%x
  885:         return ret
  886:     
  887:         
  888:     def makeList(self,entry):
  889:         """makes a list out of one entry or repeat a list"""
  890:         if type(entry) is StringType:
  891:             return [entry]
  892:         else:
  893:             return entry
  894: 
  895: 
  896:     def getTree(self,date=None):
  897:         """generate Tree from project list"""
  898: 
  899:         returnList=[]
  900:         for project in self.getProjectFields('xdata_05',sort="int",date=date): # get Projects sorted by xdata_05
  901: 
  902:             for idNr in project[1].split(";"): # more than one number
  903:                 if not idNr=="":
  904:                     splittedId=idNr.split(".")
  905:                     depth=len(splittedId)
  906:                     nr=idNr
  907:                     #title=project[0].WEB_title
  908:                     title=[project[0].getContent('WEB_title')]
  909:                     #print title
  910:                     if idNr[0]!="x":
  911:                        returnList.append((depth,nr,title,project[0]))
  912:         
  913:         return returnList
  914: 
  915:     def formatElementsAsList(self,elements):
  916:         """formatiere tree als liste"""
  917:         
  918:         actualDepth=0
  919:         ret=""
  920:         for element in elements:
  921:             if (element[0]>actualDepth):
  922:                 #fuege soviele ul ein wie unterschied in tiefe
  923:                 if element[0]==1:
  924:                     ret+="""<div class="dept">\n<ul class="liste">\n"""
  925:                 else:
  926:                     for i in range(element[0]-actualDepth):
  927:                         if i>0:
  928:                             ret+="<li>"
  929:                         ret+="""<ul class="liste">\n"""
  930: 
  931:                 actualDepth=element[0]
  932:                 
  933:             elif (element[0]<actualDepth):
  934:                 #fuege soviele /ul ein wie unterschied in tiefe
  935:                 for i in range(-element[0]+actualDepth):
  936: 
  937:                     ret+="<br><br></li></ul>\n"
  938: 
  939:                     #ret+="<br><br>\n</li>\n</ul>\n</li>\n"
  940: 
  941: 
  942:                 if element[0]==1:
  943:                     department=int(element[3].getContent('xdata_05'))-1
  944:                     
  945:                     ret+="""</ul></div>\n"""
  946:                     if department==4: #hack
  947:                         department=3
  948: 
  949:                     ret+="""<div class="bildspalte"><img src="../grafik/dept%i.jpg" width="160" height="120" vspace="40"></div>
  950:                     <div class="dept">\n<ul class="liste">\n
  951:                     """%department
  952:             
  953:                 actualDepth=element[0]
  954:             else:
  955:                 ret+="""\n</li>\n"""
  956:             ret+="""<li>\n"""
  957:             
  958:             if actualDepth==1:
  959:                 departmentName={'1':'Department I','2':'Department II','3':'Department III', '4':'Ind. Research Group','5':'Ind. Research Group'} 
  960:                 department=element[3].getContent('xdata_05')
  961:                 ret+="""<a href="#top"><img src="../grafik/totop.gif" vspace="10" border="0"></a><br><a name="dept%s"></a>%s: """%(department,departmentName[department])
  962: 
  963:             if self.REQUEST.has_key('date'):
  964:                 ret+="""<a href="%s?date=%s">%s</a>"""%(self.generateUrlProject(element[3].absolute_url())+"/index.html",self.REQUEST['date'],element[3].getContent('WEB_title'))
  965:             else:
  966:                 ret+="""<a href="%s">%s</a>"""%(self.generateUrlProject(element[3].absolute_url())+"/index.html",element[3].getContent('WEB_title'))
  967:         return ret
  968:     
  969:     def formatElementForOverview(self,element):
  970:         """format the element for output in overview"""
  971:         if element[0]==1: #department
  972:             #print element[3].getContent('xdata_05')
  973:             if element[3].getContent('xdata_05') == "4":
  974:                 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'))
  975:             if element[3].getContent('xdata_05') == "5":
  976:                 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'))
  977:             
  978:             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'))
  979: 
  980:         elif element[0]==2: #mainprojects
  981:             return """<h3 class="hier"><a href="%s">%s</a></h3><p>"""%(element[3].absolute_url()+"/index.html",element[3].getContent('WEB_title'))
  982: 
  983:         elif element[0]==3:
  984:             return """<p class="hier"><a href="%s">%s</a></p>"""%(element[3].absolute_url()+"/index.html",element[3].getContent('WEB_title'))
  985: 
  986:         
  987:     def changePosition(self,treeId,select,RESPONSE=None):
  988:         """Change Postion Entry"""
  989:         numbers=[]
  990: 
  991:         # Suche hoechste bisherige nummer
  992:         projects=self.getProjectFields('xdata_05') # get Projects sorted by xdata_05
  993:         #print "pj",projects
  994:         for project in projects: #suche alle subtrees der treeId
  995:             #print treeId
  996:             
  997:             founds=re.match(treeId+"\.(.*)",project[1].split(";")[0])
  998:             if founds:
  999:                 #print "x",founds.group(0),len(founds.group(0).split("."))
 1000:                 if len(founds.group(0).split("."))==len(treeId.split("."))+1: # nur ein punkt mehr, d.h. untere ebene
 1001:                     try:
 1002:                         numbers.append(int(founds.group(0).split(".")[len(founds.group(0).split("."))-1]))
 1003:                     except:
 1004:                         numbers.append(int(0))
 1005: 
 1006:         try:
 1007:             highest=max(numbers)
 1008:         except:
 1009:             highest=0
 1010:         projects=self.showNewProjects()
 1011:         for i in self.makeList(select):
 1012:             highest+=10
 1013:             projects[int(i)][0].xdata_05=treeId+"."+str(highest)
 1014: 
 1015: 
 1016:         if RESPONSE is not None:
 1017:             RESPONSE.redirect('showTree')
 1018:         
 1019:     def changeTree(self,RESPONSE=None):
 1020:         """change the complete tree"""
 1021:         form=self.REQUEST.form
 1022:         hashList={}
 1023:         fields=self.getTree()
 1024: 
 1025:         
 1026:         for idNr in form.keys():
 1027:             if not (fields[int(idNr)][3].xdata_05==form[idNr]):
 1028:                 fields[int(idNr)][3].xdata_05=form[idNr]
 1029:                 fields[int(idNr)][3].copyObjectToArchive()
 1030:         
 1031: 
 1032:         if RESPONSE is not None:
 1033:             RESPONSE.redirect('showTree')
 1034: 
 1035:     def getProjectWithId(self,id):
 1036:         fields=self.getProjectFields('xdata_05')
 1037:         for field in fields:
 1038:             if field[1]==id:
 1039:                 return field[0]
 1040: 
 1041:         return None
 1042:             
 1043:         
 1044:             
 1045:         
 1046:     def getRelativeUrlFromPerson(self,list):
 1047:         """get urls to person list"""
 1048:         ret=[]
 1049:         persons=list.split(";")
 1050:         for person in persons:
 1051:             
 1052:             if len(person)>1: #nicht nur Trennzeichen
 1053:                 splitted=person.split(",")
 1054:                 if len(splitted)==1:
 1055:                     splitted=person.split(" ")
 1056:                 splittedNew=[re.sub(r'\s(.*)','$1',split) for split in splitted]
 1057:                 if splittedNew[0]=='':
 1058:                     del splittedNew[0]
 1059:                 search=string.join(splittedNew,' AND ')
 1060:                 
 1061:                 if not search=='':
 1062: 
 1063:                     try:
 1064:                         proj=self.MembersCatalog({'title':search})
 1065:                     except:
 1066:                         proj=None
 1067: 
 1068:                 if proj:
 1069:                     #ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url,person.encode('utf-8')))
 1070:                     ret.append("<a href=%s >%s</a>"%('members/'+proj[0].id+'/index.html',person))
 1071:                 else:
 1072:                     #ret.append("%s"%person.encode('utf-8'))
 1073:                     ret.append("%s"%person)
 1074:         return string.join(ret,";")
 1075:         
 1076:             
 1077:     def getUrlFromPerson(self,list):
 1078:         """get urls to person list"""
 1079:         ret=[]
 1080:         persons=list.split(";")
 1081:         for person in persons:
 1082:             
 1083:             if len(person)>1: #nicht nur Trennzeichen
 1084:                 splitted=person.split(",")
 1085:                 if len(splitted)==1:
 1086:                     splitted=person.lstrip().rstrip().split(" ")
 1087:                 splittedNew=[re.sub(r'\s(.*)','$1',split) for split in splitted]
 1088:                 if splittedNew[0]=='':
 1089:                     del splittedNew[0]
 1090:                 search=string.join(splittedNew,' AND ')
 1091:                 
 1092:                 if not search=='':
 1093: 
 1094:                     try:
 1095:                         proj=self.MembersCatalog({'title':search})
 1096:                     except:
 1097:                         proj=None
 1098: 
 1099:                 if proj:
 1100:                     if person =="Otto Sibum" : person="H. Otto Sibum"
 1101:                     if person =="Norton Wise" : person="M. Norton Wise"
 1102:                     #ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url,person.encode('utf-8')))
 1103:                     ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url+"/index.html",person))
 1104:                 else:
 1105:                     #ret.append("%s"%person.encode('utf-8'))
 1106:                     ret.append("%s"%person)
 1107:         return string.join(ret,";")
 1108:                          
 1109:     def getProjectsOfMembers(self,date=None):
 1110:         """give tuple member /projects"""
 1111:         ret=[]
 1112:         members=self.getAllMembers()
 1113:         #return str(members)
 1114:         for x in members:
 1115:             ret+=self.getProjectsOfMember(name=x,date=date)
 1116:             
 1117:         return ret
 1118: 
 1119:     def getProjectsOfMember(self,name=None,email=None,date=None):
 1120:         """get project of a member"""
 1121:         def sortP(x,y):
 1122:             """sort by sorting number"""
 1123:             #print x.xdata_05,y.xdata_05
 1124:             return cmp(x.WEB_title,y.WEB_title)
 1125:         
 1126:        
 1127:         ret=[]
 1128:         splitNeu=[]
 1129:         if email:
 1130:             
 1131:             members=self.ZopeFind(self.members,obj_metatypes=['MPIWGStaff'],obj_ids=[email],search_sub=1)
 1132:             name =  members[0][1].title.decode('utf-8')
 1133: 
 1134:         y=name
 1135:         splitted=y.split(",")
 1136:         #XXXX
 1137:         splitNeu=["\'"+splitted[1]+" "+splitted[0]+"\'"]
 1138:         
 1139:         #for s in splitted:
 1140:         #    splitNeu.append("\""+s+"\"")
 1141:         search=string.join(splitNeu,' AND ')
 1142:         
 1143:         proj=self.ProjectCatalog({'xdata_01':search})
 1144: 
 1145:         if proj:
 1146:             proj2=[]
 1147:             for x in proj:
 1148:                 if (not getattr(x.getObject(),'invisible',None)) and (getattr(x.getObject(),'archiveTime','')==''):
 1149:                     if not((splitted[1]==" Christoph") and (splitted[0]=="Hoffmann") and (str(x.WEB_title).find('Einstein')>0)):
 1150:                        proj2.append(x)
 1151: 
 1152:         else:
 1153:             proj2=[]
 1154:             
 1155:         proj=self.ProjectCatalog({'xdata_08':search})
 1156:         if proj:
 1157:             names=[x.WEB_title for x in proj]
 1158:             for x in proj:
 1159:                 
 1160:                 if (not x.WEB_title in names) and (getattr(x.getObject(),'archiveTime','')==''):
 1161:                     proj2.append(x)
 1162: 
 1163: 
 1164:         proj2.sort(sortP)
 1165: 
 1166:         if len(proj2)>0:
 1167:             ret.append((y,proj2))
 1168: 
 1169:         return ret
 1170:      
 1171:     def givePersonList(self,name):
 1172:         """check if person is in personfolder and return list of person objects"""
 1173:         
 1174:         splitted=name.split(",")
 1175:         if len(splitted)==1:
 1176:             splitted=name.lstrip().rstrip().split(" ")
 1177:         splittedNew=[split.lstrip() for split in splitted]
 1178:         
 1179:         if splittedNew[0]=='':
 1180:             del splittedNew[0]
 1181:         search=string.join(splittedNew,' AND ')
 1182:         if not search=='':
 1183:             proj=self.MembersCatalog({'title':search})
 1184: 
 1185:         if proj:
 1186:             return [[x.lastName,x.firstName] for x in proj]
 1187:         else:
 1188:             return []
 1189:             
 1190: ##         splitted=name.split(",") # version nachname, vorname...
 1191: ##         if len(splitted)>1:
 1192: ##             lastName=splitted[0] 
 1193: ##             firstName=splitted[1]
 1194: ##         else: 
 1195: ##             splitted=name.split(" ") #version vorname irgenwas nachnamae
 1196:         
 1197: ##             lastName=splitted[len(splitted)-1]
 1198: ##             firstName=string.join(splitted[0:len(splitted)-1])
 1199: 
 1200: ##         objs=[]
 1201: 
 1202:         #print  self.members 
 1203:       ##   for x in self.members.__dict__:
 1204: ##             obj=getattr(self.members,x)
 1205: ##             if hasattr(obj,'lastName') and hasattr(obj,'firstName'):
 1206:                 
 1207: ##                 if (re.match(".*"+obj.lastName+".*",lastName) or re.match(".*"+lastName+".*",obj.lastName)) and (re.match(".*"+obj.firstName+".*",firstName) or re.match(".*"+firstName+".*",obj.firstName)):
 1208:                     
 1209: ##                     objs.append((obj,lastName+", "+firstName))
 1210: 
 1211:         
 1212:         return objs
 1213: 
 1214: 
 1215:     def personCheck(self,names):
 1216:         """all persons for list"""
 1217:         #print "names",names
 1218:         splitted=names.split(";")
 1219:         ret={}
 1220:         for name in splitted:
 1221: 
 1222:             if not (name==""):
 1223:                 try:
 1224:                     ret[name]=self.givePersonList(name)
 1225:                 except:
 1226:                     """NOTHIHN"""
 1227:         #print "RET",ret
 1228:         return ret
 1229: 
 1230:     def giveCheckList(self,person,fieldname):
 1231:         """return checklist"""
 1232:         #print "GCL",fieldname
 1233:         if fieldname=='xdata_01':
 1234:             x=self.personCheck(person.getContent(fieldname))
 1235:             #print "GCLBACKX",x
 1236:             return x
 1237:         
 1238: 
 1239:     def isCheckField(self,fieldname):
 1240:         """return chechfield"""
 1241:         
 1242:         return (fieldname in checkFields)
 1243: 
 1244:         
 1245: def manage_addMPIWGRootForm(self):
 1246:     """form for adding the root"""
 1247:     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMPIWGRootForm.zpt')).__of__(self)
 1248:     return pt()
 1249: 
 1250: def manage_addMPIWGRoot(self,id,title,connection_id="",RESPONSE=None):
 1251:     """add a root folder"""
 1252:     newObj=MPIWGRoot(id,title)
 1253:     self._setObject(id,newObj)
 1254:     ob=getattr(self,id)
 1255:     setattr(ob,'connection_id',connection_id)
 1256:     if RESPONSE is not None:
 1257:         RESPONSE.redirect('manage_main')
 1258:         
 1259: 
 1260: class MPIWGProject_publication(SimpleItem):
 1261:     """publications object fuer project"""
 1262: 
 1263:     meta_type="MPIWGProject_publication"
 1264: 
 1265:     def editPublication(self,text=None,RESPONSE=None):
 1266:         """edit a publication"""
 1267: 
 1268:         if (not text):
 1269:             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_publicationForm.zpt')).__of__(self)
 1270:             return pt()
 1271: 
 1272:        
 1273:         self.text=text[0:]
 1274: 
 1275:         if RESPONSE:
 1276:             RESPONSE.redirect("../managePublications")
 1277:             
 1278: class MPIWGProject_image(Image):
 1279:     """Images for Projects"""
 1280: 
 1281:     meta_type="MPIWGProject_image"
 1282: 
 1283:     def showImage(self,imageUrl=None):
 1284:         """show Images at an extra page"""
 1285:         self.getContent('WEB_project_description',filter='yes') #get the content and store image infos into session
 1286:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','projectImageView.zpt')).__of__(self)
 1287:         return pt()
 1288:     
 1289:     def editImage(self,file=None,caption=None,RESPONSE=None):
 1290:         """edit the Image"""
 1291:         if (not file) and (not caption):
 1292:             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_imageForm.zpt')).__of__(self)
 1293:             return pt()
 1294: 
 1295:         if file and (not file.filename.lstrip().rstrip()==""):
 1296:             self.manage_upload(file)
 1297: 
 1298:         if caption:
 1299:             self.caption=caption[0:]
 1300: 
 1301:         if RESPONSE:
 1302:             RESPONSE.redirect("../manageImages")
 1303: 
 1304: class MPIWGProject(CatalogAware,Folder):
 1305:     """Class for Projects"""
 1306: 
 1307: 
 1308:     security=ClassSecurityInfo()
 1309:     meta_type='MPIWGProject'
 1310:     default_catalog='ProjectCatalog'
 1311: 
 1312:     def sortedByPlace(self,metatype):
 1313:         """find metatype and sort by place"""
 1314:         def sort(x,y):
 1315:             return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))
 1316: 
 1317:         founds=self.ZopeFind(self,obj_metatypes=[metatype]);
 1318:         
 1319:         founds.sort(sort)
 1320:         
 1321:         return founds
 1322:     
 1323: 
 1324:     def copyPublicationsToList(self,RESPONSE=None):
 1325:         """copy publications in to list"""
 1326: 
 1327:         publicationTxt=self.getContent('WEB_related_pub')
 1328: 
 1329:         pubSplits=publicationTxt.split("<p>")
 1330: 
 1331:         for pubSplit in pubSplits:
 1332:             pubSplit=pubSplit.replace("</p>","")
 1333:             self.addPublication(pubSplit)
 1334: 
 1335:         if RESPONSE:
 1336:             RESPONSE.redirect('managePublications')
 1337:         
 1338:     
 1339:     def copyImageToMargin(self,RESPONSE=None):
 1340:         """copy inline images to marginal images"""
 1341:         self.getContent('WEB_project_description',filter='yes')
 1342: 
 1343:         filename=self.imageURL.split("/")[-1]
 1344:         #lege neues images object an, mit leerem bild
 1345: 
 1346:         if self.ZopeFind(self,obj_ids=[filename]):
 1347:             #existiert das bild schon, dann neueun filenamen
 1348:             filename="project_image_"+filename
 1349:             
 1350:         self.addImage(None,self.imagecap,filename=filename)
 1351:         #hole die bilddaten aus der url
 1352:         data=urllib.urlopen(self.absolute_url()+"/"+self.imageURL).read()
 1353: 
 1354:         obj=getattr(self,filename)
 1355:         obj.update_data(data)
 1356:         
 1357:         if RESPONSE:
 1358:             RESPONSE.redirect('manageImages')
 1359:             
 1360:     def manageImages(self,imageName=None,op=None):
 1361:         """managage images"""
 1362: 
 1363: 
 1364:         if imageName and op:
 1365:             if op=='up':
 1366:                 images=self.getImages()
 1367:                 for image in images:
 1368:                     if image[0]==imageName:
 1369:                         nr=images.index(image)
 1370:                         if not nr==0:
 1371:                             images[nr-1][1].place+=1
 1372:                             images[nr][1].place-=1
 1373:                         pass
 1374:             elif op=='down':
 1375:                 images=self.getImages()
 1376:                 for image in images:
 1377:                     if image[0]==imageName:
 1378:                         nr=images.index(image)
 1379:                         if not (nr==len(images)-1):
 1380:                             images[nr+1][1].place-=1
 1381:                             images[nr][1].place+=1
 1382:                         pass
 1383: 
 1384: 
 1385:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_manageImagesForm.zpt')).__of__(self)
 1386:         return pt()
 1387: 
 1388:     def managePublications(self,pubName=None,op=None):
 1389:         """managage images"""
 1390: 
 1391: 
 1392:         if pubName and op:
 1393:             if op=='up':
 1394:                 publications=self.getPublications()
 1395:                 for publication in publications:
 1396:                     if publication[0]==pubName:
 1397:                         nr=publications.index(publication)
 1398:                         if not nr==0:
 1399:                             publications[nr-1][1].place+=1
 1400:                             publications[nr][1].place-=1
 1401:                         pass
 1402:             elif op=='down':
 1403:                 publications=self.getPublications()
 1404:                 for publication in publications:
 1405:                     if publication[0]==pubName:
 1406:                         nr=publications.index(publication)
 1407:                         if not (nr==len(publications)-1):
 1408:                             publications[nr+1][1].place-=1
 1409:                             publications[nr][1].place+=1
 1410:                         pass
 1411: 
 1412: 
 1413:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_managePublicationsForm.zpt')).__of__(self)
 1414:         return pt()
 1415: 
 1416:     def getPublications(self):
 1417:         """get all Publications"""
 1418:         def sort_images(x,y):
 1419:             return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))
 1420: 
 1421:         publications=self.ZopeFind(self,obj_metatypes=['MPIWGProject_publication'])
 1422:         
 1423:         publications.sort(sort_images)
 1424:         return publications
 1425: 
 1426:     def addPublication(self,text,RESPONSE=None):
 1427:         """add an MPIWG_Publication"""
 1428: 
 1429:         name="publication_"+str(self.getLastPublicationNumber()+1)
 1430:         
 1431:         newPublication=MPIWGProject_publication(name)
 1432: 
 1433:         self._setObject(name,newPublication)
 1434:         obj=getattr(self,name)
 1435:         obj.text=text[0:]
 1436:         obj.enabled=True;
 1437:         obj.place=self.getLastPublicationNumber()+1
 1438:         obj.id=name
 1439:         
 1440:         if RESPONSE is not None:
 1441:             RESPONSE.redirect('managePublications')
 1442: 
 1443:  
 1444:     def getLastPublicationNumber(self):
 1445:         publications=self.getPublications()
 1446:         
 1447:         if not publications:
 1448:             return 0
 1449:         else:
 1450:             return getattr(publications[-1][1],'place',0)
 1451:         
 1452:     def deletePublication(self,id,RESPONSE=None):
 1453:         """delete Publication id"""
 1454:         self.manage_delObjects([id])
 1455:         if RESPONSE:
 1456:             RESPONSE.redirect('managePublications')
 1457: 
 1458:     def getImages(self):
 1459:         """get all Images"""
 1460:         def sort_images(x,y):
 1461:             return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))
 1462: 
 1463:         images=self.ZopeFind(self,obj_metatypes=['MPIWGProject_image'])
 1464:         
 1465:         images.sort(sort_images)
 1466:         return images
 1467: 
 1468:     def getLastImageNumber(self):
 1469:         images=self.getImages()
 1470:         
 1471:         if not images:
 1472:             return 0
 1473:         else:
 1474:             return getattr(images[-1][1],'place',0)
 1475:         
 1476:     def deleteImage(self,id,RESPONSE=None):
 1477:         """delete Image id"""
 1478:         self.manage_delObjects([id])
 1479:         if RESPONSE:
 1480:             RESPONSE.redirect('manageImages')
 1481: 
 1482:     def addImage(self,fileHd,caption,RESPONSE=None,filename=None):
 1483:         """add an MPIWG_Project_image"""
 1484: 
 1485:         if not filename:
 1486:             filename=fileHd.filename
 1487: 
 1488:         if not fileHd:
 1489:             fileHd=file(os.path.join(package_home(globals()),'blank.gif'))
 1490:             
 1491:         newImage=MPIWGProject_image(filename,filename,fileHd)
 1492: 
 1493:         self._setObject(filename,newImage)
 1494:         obj=getattr(self,filename)
 1495:         obj.caption=caption[0:]
 1496:         obj.enabled=True;
 1497:         obj.place=self.getLastImageNumber()+1
 1498:         
 1499:         if RESPONSE is not None:
 1500:             RESPONSE.redirect('manageImages')
 1501: 
 1502:     def PrincipiaSearchSource(self):
 1503:         """Return cataloguable key for ourselves."""
 1504:         return str(self)
 1505: 
 1506:     def versionHeader(self):
 1507:         """version Header, gibt header text entsprechend der aktuellen version aus"""
 1508:         
 1509:         actualTime=time.localtime()
 1510:         retTXT="""<h2>This is an outdated version, for the actual version please refer to <a href="%s">%s</a></h2>"""
 1511:         s=self.aq_parent.absolute_url()
 1512:         #print getattr(self,'archiveTime',actualTime)
 1513:         if getattr(self,'archiveTime',actualTime)< actualTime:
 1514:             return retTXT%(s,s)
 1515:         else:
 1516:             return ""
 1517: 
 1518:     def getActualVersion(self,date=None):
 1519:         """actuelle version"""
 1520:         def sortProjectsByTime(x,y):
 1521:             return cmp(x[1].archiveTime,y[1].archiveTime)
 1522: 
 1523:         if not date:
 1524:             if self.isActual():
 1525:                 return self
 1526:             else:
 1527:                 return None
 1528: 
 1529:         #suche ob aeltere versionen vorhanden sind
 1530: 
 1531:         finds=self.ZopeFind(self,obj_metatypes=['MPIWGProject'])
 1532:         if not finds: #wenn nicht dann teste ob die aktuelle version schon existiert hat.
 1533:             ad=getattr(self,'creationTime','20050101000000')
 1534:             if int(date)>int(ad):
 1535:                 return self
 1536:             else:
 1537:                 return None
 1538: 
 1539: 
 1540:         else:
 1541:             finds.sort(sortProjectsByTime)
 1542: 
 1543:         for find in finds:
 1544:             #gehe durch die alten Projekte und finde das entprechende
 1545:             if (int(find[1].archiveTime) > int(date)) and (int(date)>int(getattr(find[1],'creationTime','20050101000000'))):
 1546:                 return find[1]
 1547: 
 1548:         #kein passendes gefunden, dann teste ob das aktuelle in frage kommt
 1549:         ad=getattr(self,'creationTime','20050101000000')
 1550:         
 1551:         if int(date)>int(ad):
 1552:         
 1553:             return self
 1554:         else:
 1555:             return None
 1556:           
 1557:         
 1558:     def isActual(self):
 1559:         """gibt 1 zurueck wenn aktuell, 0 sonst"""
 1560:         actualTime=time.localtime()
 1561:         
 1562:         
 1563:         #print getattr(self,'archiveTime',actualTime)
 1564:         if getattr(self,'archiveTime',actualTime)< actualTime:
 1565:             return 0
 1566:         else:
 1567:             return 1
 1568:         
 1569:     def copyObjectToArchive(self):
 1570:         """kopiere aktuelles objekt ins archiv"""
 1571:         cb=self.aq_parent.manage_copyObjects(self.getId())
 1572:         self.manage_pasteObjects(cb)
 1573:         actualTime=time.localtime()
 1574:         
 1575:         self.manage_renameObject(self.getId(),self.getId()+"_"+time.strftime("%Y%m%d%H%M%S",actualTime))
 1576:         obj=getattr(self,self.getId()+"_"+time.strftime("%Y%m%d%H%M%S",actualTime))
 1577:         obj.setArchiveTime(time.strftime("%Y%m%d%H%M%S",actualTime))
 1578:         ids=[x[0] for x in self.ZopeFind(obj,obj_metatypes=['MPIWGProject'])]
 1579:         obj.manage_delObjects(ids)
 1580:         
 1581:     def setArchiveTime(self,time):
 1582:         """set Archive Time"""
 1583:         self.archiveTime=time[0:]
 1584:         
 1585:     def versionManageForm(self):
 1586:         """version Manage form:currently only set to invisible"""
 1587:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_versionManageForm.zpt')).__of__(self)
 1588:         return pt()
 1589: 
 1590:     def versionManage(self,invisible=None,RESPONSE=None):
 1591:         """version Manage form:currently only set to invisible"""
 1592:         self.invisible=invisible
 1593: 
 1594:         if RESPONSE is not None:
 1595:             RESPONSE.redirect('manage_main')
 1596: 
 1597:    
 1598:     def crossLinker(self):
 1599:         """experimental crosslinker"""
 1600:         splitted=self.WEB_project_description[0].split()
 1601:         new=[]
 1602:         for split in splitted:
 1603:             try:
 1604:                 found=self.DescriptionCatalog({'fulltext':split})
 1605:           
 1606:                 if len(found)>1:
 1607:              
 1608:                     new.append("<a href=%s>%s</a>"%(split,split))
 1609:                 else:
 1610:                     new.append(split)
 1611:             except:
 1612:                 new.append(split)
 1613:         return string.join(new)
 1614:             
 1615:             
 1616: 
 1617: 
 1618:     def generateTemplate(self,RESPONSE=None):
 1619:         """Erzeuge Template für defined fields not_used"""
 1620: 
 1621:         id="index_html"
 1622:         title=id
 1623:         if self._getOb('index_html'):
 1624:             self._delObject('index_html')
 1625: 
 1626:         
 1627:         newObj=ZopePageTemplate(id,'TEXT')
 1628:         self._setObject(id,newObj)
 1629:         #self.manage_addPageTemplate(id,title)
 1630:         if RESPONSE is not None:
 1631:             RESPONSE.redirect('manage_main')
 1632:             
 1633:     def __init__(self, id, argv=None):
 1634:         """initiere classe"""
 1635: 
 1636:         self.creationTime=time.strftime("%Y%m%d%H%M%S",time.localtime())[0:]
 1637:         self.id=id
 1638:         self.title=id
 1639:         if argv:
 1640:             for arg in definedFields:
 1641:                 try:
 1642:                         setattr(self,arg,argv[arg])
 1643:                 except:
 1644:                         setattr(self,arg,"")
 1645:         else:
 1646:             for arg in definedFields:
 1647:                 setattr(self,arg,'')
 1648:             
 1649:     manage_options = Folder.manage_options+(
 1650:         {'label':'Load New File','action':'loadNewFileForm'},
 1651:         {'label':'Edit ProjectInfo','action':'editMPIWGProjectForm'},
 1652:         {'label':'Edit BasisInfo','action':'editMPIWGBasisForm'},
 1653:         {'label':'Edit Publications','action':'editMPIWGRelatedPublicationsForm'},
 1654:         {'label':'Edit Themes & Disciplines','action':'editMPIWGDisciplinesThemesForm'},
 1655:         {'label':'Versionmanager','action':'versionManageForm'},
 1656:         )
 1657: 
 1658: 
 1659:     def checkDate(self,date):
 1660:         """teste ob zum Zeitpunkt date eine andere version existierte"""
 1661:         
 1662: 
 1663:         def sortProjectsByTime(x,y):
 1664:             return cmp(x[1].archiveTime,y[1].archiveTime)
 1665: 
 1666:         #suche ob aeltere versionen vorhanden sind
 1667: 
 1668:         finds=self.ZopeFind(self,obj_metatypes=['MPIWGProject'])
 1669:         if not finds: #wenn nicht dann teste ob die aktuelle version schon existiert hat.
 1670:             ad=getattr(self,'creationTime','20050101000000')
 1671:             if int(date)>int(ad):
 1672:                 return self.REQUEST['URL1']+"/"+self.getId()
 1673:             else:
 1674:                 return self.REQUEST['URL1']+"/no_project"
 1675: 
 1676: 
 1677:         else:
 1678:             finds.sort(sortProjectsByTime)
 1679: 
 1680:         for find in finds:
 1681:             #gehe durch die alten Projekte und finde das entprechende
 1682:             if (int(find[1].archiveTime) > int(date)) and (int(date)>int(getattr(find[1],'creationTime','20050101000000'))):
 1683:                 return self.REQUEST['URL1']+"/"+find[1].getId()
 1684: 
 1685:         #kein passendes gefunden, dann teste ob das aktuelle in frage kommt
 1686:         ad=getattr(self,'creationTime','20050101000000')
 1687:         
 1688:         if int(date)>int(ad):
 1689:         
 1690:             return self.REQUEST['URL1']+"/"+self.getId()
 1691:         else:
 1692:             return self.REQUEST['URL1']+"/no_project"
 1693:         
 1694:             
 1695:     def no_project(self):
 1696:         """warnung: project noch nicht existent"""
 1697:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','no_project')).__of__(self)
 1698:         return pt()
 1699:     
 1700:     def index_html(self,request=True,context=None):
 1701:         """show homepage"""
 1702:         if not context:
 1703:             context=self
 1704:         if request:
 1705:             if self.REQUEST.has_key('date') and self.REQUEST.SESSION.get('MPI_redirected',None)==None:
 1706:                 self.REQUEST.SESSION['MPI_redirected']=1
 1707:                 self.REQUEST.RESPONSE.redirect(self.checkDate(self.REQUEST['date'])+"?date="+self.REQUEST['date'])
 1708:             else:
 1709:                 self.REQUEST.SESSION['MPI_redirected']=None
 1710:         
 1711:         #ext=self.ZopeFind(self.aq_parent,obj_ids=["project_main"])
 1712:         ext=getattr(self,"project_main",None)
 1713:         if ext:
 1714:             return getattr(self,ext.getId())()
 1715: 
 1716:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','project_main')).__of__(context)    
 1717: 
 1718:         return pt()
 1719: 
 1720:     
 1721:     def getDataFields(self):
 1722:         """giveListofDatafields"""
 1723:         ret=[]
 1724:         for x in range(1,14):
 1725:             if not x in [6,10,9]: # not used fields
 1726:                 ret.append('xdata_%02i'%x)
 1727:         return ret
 1728:             
 1729:     def getDefinedFields(self):
 1730:         """show all defined fields"""
 1731:         
 1732:         return definedFields
 1733: 
 1734:     def getAttribute(self,field):
 1735:         """get attrbiute"""
 1736:         return getattr(self,field)
 1737: 
 1738:     def getContent(self,field,filter=None):
 1739:         """Inhalt des Feldes"""
 1740:         
 1741:         text=u''
 1742: 
 1743:         for x in getattr(self,field):
 1744:             
 1745:             try:
 1746:                 text +=x
 1747:             except:
 1748:                 text = x
 1749:             
 1750:         
 1751: 
 1752:         try:
 1753:             if text[len(text)-1]==";":
 1754:                 text=text[0:len(text)-1]
 1755:           
 1756:                 
 1757:         except:
 1758:             pass
 1759:         
 1760:         if text=='':
 1761:             text2=text
 1762:         else:
 1763:             text2=re.sub(r';([^\s])','; \g<1>',text)
 1764: 
 1765:         #teste ob ergebnis leer und header dann nehme title
 1766:         
 1767:         if (text2=='') and (field=='WEB_project_header'):
 1768:             return self.getContent('WEB_title')
 1769: 
 1770:         if filter:
 1771:             splitted=text2.split("""<p class="picture">""")
 1772:             if len(splitted)>1:
 1773:                 tmp=splitted[1].split("</p>")
 1774:                 #return repr(splitted[1])
 1775:                 try:
 1776:                         self.imageURL=tmp[0].split("\"")[1].encode('utf-8')
 1777:                 except:
 1778:                         self.imageURL=tmp[0].split("src=")[1].split(" ")[0].encode('utf-8')
 1779:                 
 1780:                 split2="</p>".join(tmp[1:])
 1781: 
 1782:                 text3=splitted[0]+split2
 1783: 
 1784:                 splitted=text3.split("""<p class="picturetitle">""")
 1785:                 if len(splitted)>1:
 1786:                     tmp=splitted[1].split("</p>")
 1787:                     self.imagecap=tmp[0].encode('utf-8')
 1788:                 
 1789:                     split4="".join(tmp[1:])
 1790: 
 1791:                     text5=splitted[0]+split4
 1792:                 else:
 1793:                     #keine caption
 1794:                     text5=text3
 1795:             else:
 1796:                 #kein bild
 1797:                 text5=text2
 1798:         else:
 1799:             text5=text2
 1800: 
 1801:         #teste ob WEB_project_description und keine führenden p tags
 1802:         if (len(text5)>4) and (not text5[0:3]=='<p>') and (field=='WEB_project_description'):
 1803:             text5= "<p>"+text5+"</p>"
 1804: 
 1805: 
 1806:         #filter image
 1807:         
 1808: 
 1809:         return text5.encode('utf-8')
 1810: 
 1811:     def showImagesOfPage(self,imageUrl=None):
 1812:         """show Images of project"""
 1813:         self.getContent('WEB_project_description',filter='yes') #get the content and store image infos into session
 1814:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','projectImageView.zpt')).__of__(self)
 1815:         return pt()
 1816:         
 1817:     
 1818:     def show_html(self):
 1819:         """simple index"""
 1820:         #return "HI"
 1821:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_index.zpt')).__of__(self)
 1822:         return pt()
 1823: 
 1824:     def saveFromPreview(self):
 1825:         """save content aus preview"""
 1826:         self.WEB_project_description=self.previewTemplate.WEB_project_description[0:]
 1827:         self.REQUEST.RESPONSE.redirect("./index.html")
 1828:         
 1829:     def saveEditedContent(self,kupu=None,preview=None):
 1830:         """save Edited content"""
 1831: 
 1832:         if preview:
 1833:             kupu=preview
 1834:         #find content of body tags
 1835:         start=kupu.find("<body>")
 1836:         end=kupu.find("</body>")
 1837:         newcontent= kupu[start+6:end]
 1838: 
 1839:         if preview:
 1840:             
 1841:             return self.preview(newcontent)
 1842: 
 1843:         self.copyObjectToArchive()
 1844:         self.WEB_project_description=newcontent[0:]
 1845: 
 1846:         self.REQUEST.RESPONSE.redirect("./index.html")
 1847:         
 1848:         return True
 1849: 
 1850:     security.declareProtected('View managment screens','edit')
 1851:     def edit(self,western=None):
 1852:         """Edit pages"""
 1853:         if western:
 1854:             self.REQUEST.RESPONSE.setCookie("MP_debug_code","western",path="/")
 1855: 
 1856:             
 1857:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGProjectNeu.zpt')).__of__(self)
 1858:         return pt()
 1859: 
 1860:     def preview(self,description):
 1861:         """preview"""
 1862:         tmpPro=getattr(self,"previewTemplate",None)
 1863:         if not tmpPro:
 1864:             tmpPro=MPIWGProject("previewTemplate")
 1865:             self._setObject("previewTemplate",tmpPro)
 1866:         for field in definedFields:
 1867:             setattr(tmpPro,field,getattr(self,field))
 1868:         tmpPro.WEB_project_description=description[0:]
 1869:         
 1870:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','previewFrame.zpt')).__of__(self)
 1871:         return pt()
 1872: 
 1873:         #return self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+"/previewTemplate")
 1874:         
 1875: 
 1876:     def getWebProject_description(self):
 1877:         """get description"""
 1878:         debug= self.REQUEST.cookies.get("MP_debug_code",None)
 1879:         
 1880:         if debug and debug=="western":
 1881:             return """
 1882:             <html>
 1883:             <head>
 1884:             <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
 1885:             </head>
 1886:             <body>%s
 1887:             </html></body>
 1888:             """%self.WEB_project_description[0]
 1889:         
 1890:         return """
 1891:             <html>
 1892:             <head>
 1893:             <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
 1894:             </head>
 1895:             <body>%s
 1896:             </html></body>
 1897:             """%self.getContent('WEB_project_description')
 1898:         
 1899:         
 1900:         
 1901:     def editMPIWGProjectForm(self):
 1902:         """editform"""
 1903:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGProject.zpt')).__of__(self)
 1904:         return pt()
 1905: 
 1906:     
 1907:     def editMPIWGProject(self,RESPONSE=None,fromEdit=None):
 1908:         """edit the project and archive the old version"""
 1909:         
 1910:         self.copyObjectToArchive() # archive the object
 1911: 
 1912: 
 1913:         for x in definedFields:
 1914:             if self.REQUEST.has_key(x):
 1915:                 
 1916:                 setattr(self,x,[self.REQUEST[x].decode('utf-8')])
 1917: 
 1918:         if fromEdit and (RESPONSE is not None):
 1919:             RESPONSE.redirect('./editMPIWGBasisEditor')
 1920: 
 1921:         else:
 1922:             if RESPONSE is not None:
 1923:                 RESPONSE.redirect('manage_main')
 1924: 
 1925: 
 1926: 
 1927:     security.declareProtected('View managment screens','editMPIWGDisciplinesThemesEditor')
 1928:     def editMPIWGDisciplinesThemesEditor(self):
 1929:         """edit from edit"""
 1930:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGDisciplinesThemesNeu.zpt')).__of__(self)
 1931:         return pt()
 1932:         
 1933:     
 1934:     def editMPIWGDisciplinesThemesForm(self):
 1935:         """edit the disciplines and themes Form"""
 1936:      
 1937:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGDisciplinesThemes.zpt')).__of__(self)
 1938:         return pt()
 1939: 
 1940:     def editMPIWGDisciplinesThemes(self,disciplines=None,themes=None,RESPONSE=None,fromEdit=None):
 1941:         """edit disciplin and form"""
 1942:         if disciplines:
 1943:             if type(disciplines) is StringType:
 1944:                 self.xdata_09=disciplines
 1945:             else:
 1946:                 self.xdata_09=string.join(disciplines,";")
 1947:         else:
 1948:                 self.xdata_09=""
 1949:         if themes:
 1950:             if type(themes) is StringType:
 1951:                 self.xdata_10=themes
 1952:             else:
 1953:                 self.xdata_10=string.join(themes,";")
 1954:         else:
 1955:             self.xdata_10=""
 1956: 
 1957:         if fromEdit and (RESPONSE is not None):
 1958:             RESPONSE.redirect('./editMPIWGDisciplinesThemesEditor')
 1959: 
 1960:         else:
 1961:             if RESPONSE is not None:
 1962:                 RESPONSE.redirect('manage_main')
 1963: 
 1964: 
 1965:     def isChecked(self,wert,list):
 1966:         """check if wert is in ; seperated list"""
 1967: 
 1968:         #felder sind manchmnal als liste mit einem element definiert
 1969:         if type(list) is StringType or UnicodeType: 
 1970:             splitted=list.split(";")
 1971:         else:
 1972:             splitted=list[0].split(";")
 1973: 
 1974:         splitted=[y.rstrip().lstrip() for y in splitted]
 1975:         
 1976:         for x in splitted:
 1977:             if (not x==u'') and x in wert:
 1978:                 return 1
 1979:         return 0
 1980: 
 1981:     security.declareProtected('View management screens','editMPIWGBasisEditor')
 1982:     def editMPIWGBasisEditor(self):
 1983:         """editform"""
 1984:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGBasisNeu.zpt')).__of__(self)
 1985:         return pt()
 1986: 
 1987:     
 1988:     def editMPIWGBasisForm(self):
 1989:         """editform"""
 1990:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGBasis.zpt')).__of__(self)
 1991:         return pt()
 1992: 
 1993:     
 1994:     def editMPIWGRelatedPublicationsForm(self):
 1995:         """Edit related Publications"""
 1996:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGRelatedPublications.zpt')).__of__(self)
 1997:         return pt()
 1998:         
 1999:     
 2000:     def loadNewFileForm(self):
 2001:         """Neues XML-File einlesen"""
 2002:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_newfile.zpt')).__of__(self)
 2003:         return pt()
 2004: 
 2005:     def loadNewFile(self,RESPONSE=None):
 2006:         """einlesen des neuen files"""
 2007:         fileupload=self.REQUEST['fileupload']
 2008:         if fileupload:
 2009:             file_name=fileupload.filename
 2010:             filedata=fileupload.read()
 2011: 
 2012:             argv=xmlhelper.proj2hash(filedata)
 2013:             #print argv.keys()
 2014:             for arg in definedFields:
 2015:                 
 2016:                 #print arg,argv[arg],getattr(self,arg)
 2017:                 try:
 2018:                     temp=argv[arg][0:]
 2019:                     #old=getattr(self,arg)
 2020:                     setattr(self,arg,temp)
 2021:                     #print old,getattr(self,arg)
 2022:                 except:
 2023:                     """nothing"""
 2024:                     
 2025:         if RESPONSE is not None:
 2026:             RESPONSE.redirect('manage_main')
 2027: 
 2028: def manage_addMPIWGProjectForm(self):
 2029:     """form for adding the project"""
 2030:     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMPIWGProjectForm.zpt')).__of__(self)
 2031:     return pt()
 2032: 
 2033: def manage_addMPIWGProject(self,id,RESPONSE=None):
 2034:     """method to add a project"""
 2035:     #print argv
 2036:     fileupload=self.REQUEST.get('fileupload',None)
 2037:     if fileupload:
 2038: 
 2039:         file_name=fileupload.filename
 2040:         filedata=fileupload.read()
 2041:         
 2042:         argv=xmlhelper.proj2hash(filedata)
 2043:         
 2044:         #print argv
 2045:         newObj=MPIWGProject(id,argv)
 2046:     else:
 2047:         newObj=MPIWGProject(id)
 2048: 
 2049:     self._setObject(id,newObj)
 2050: 
 2051:     
 2052:     if RESPONSE is not None:
 2053:         RESPONSE.redirect('manage_main')