File:  [Repository] / MPIWGWeb / MPIWGProjects.py
Revision 1.47.2.47: download - view: text, annotated - select for diffs - revision graph
Mon Jan 16 15:21:47 2006 UTC (18 years, 5 months ago) by dwinter
Branches: r2
mehr als ein bild importieren

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

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