Return to MPIWGProjects.py CVS log

Up to [Repository] / MPIWGWeb

minor

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