File:  [Repository] / MPIWGWeb / MPIWGProjects.py
Revision 1.12: download - view: text, annotated - select for diffs - revision graph
Thu Jul 8 07:04:31 2004 UTC (19 years, 11 months ago) by dwinter
Branches: MAIN
CVS tags: HEAD
bugs fixed with encodings

    1: """This contains the class MPIWG Projects
    2: for organizing and maintaining the different projectspages
    3: 
    4: """
    5: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
    6: from Products.PageTemplates.PageTemplate import PageTemplate
    7: from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
    8: from Products.ZSQLExtend.ZSQLExtend import ZSQLExtendFolder
    9: 
   10: import urllib
   11: import MPIWGStaff
   12: import string
   13: import re
   14: from types import *
   15: 
   16: import xmlhelper # Methoden zur Verwaltung der projekt xmls
   17: from OFS.SimpleItem import SimpleItem
   18: from OFS.Folder import Folder
   19: 
   20: from bibliography import *
   21: 
   22: 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']
   23: 
   24: checkFields = ['xdata_01']
   25: 
   26: 
   27: 
   28: def sortF(x,y):
   29:     try:
   30:         return cmp(x[1],y[1])
   31:     except:
   32:         return 0
   33:     
   34: def sortI(x,y):
   35:     xsplit=x[1].split(".")
   36:     ysplit=y[1].split(".")
   37:     xret=""
   38:     yret=""
   39:     try:
   40:         for i in range(5):
   41:             try:
   42:                 yret=yret+"%04i"%int(xsplit[i])
   43:             except:
   44:                 yret=yret+"%04i"%0
   45: 
   46:             try:
   47:                 xret=xret+"%04i"%int(ysplit[i])
   48:             except:
   49:                 xret=xret+"%04i"%0
   50:                 
   51:         
   52:         return cmp(int(yret),int(xret))
   53:     except:
   54:         return cmp(x[1],y[1])
   55: 
   56:     
   57: class MPIWGRoot(ZSQLExtendFolder):
   58:     """Stammordner für den Web-Server"""
   59: 
   60:     fieldLabels={'WEB_title':'WEB_Title','xdata_01':'Responsible Scientists','xdata_02':'Department',
   61:              'xdata_03':'Historical Persons','xdata_04':'Time period',
   62:              'xdata_05':'Sorting number','xdata_06':'Keywords','xdata_07':'Short title',
   63:              'xdata_08':'Other involved scholars' ,'xdata_09':'Part of','xdata_10':'Covered by',
   64:              'xdata_11':'Object Digitallibrary','xdata_12':'Cooperation partners',
   65:              'xdata_13':'Funding institutions','WEB_project_header':'WEB_project_header',
   66:              'WEB_project_description':'WEB_project_description','WEB_related_pub':'WEB_related_pub'}
   67:     
   68:     folders=['MPIWGProject','Folder']
   69:     meta_type='MPIWGRoot'
   70: 
   71:     def replaceNotEmpty(self,format,field):
   72:         """replace not empty"""
   73:         if field and (not field==''):
   74:             return format%field
   75:         else:
   76:             return ""
   77:         
   78:         
   79:     def formatBibliography(self,here,found):
   80:         """format"""
   81:         return formatBibliography(here,found)
   82:     
   83:     def getValue(self,field):
   84:         """Inhalt des Feldes"""
   85: 
   86:         if type(field)==StringType:
   87:             try:
   88:                 if field[len(field)-1]==";":
   89:                     field=field[0:len(text)-1]
   90:             except:
   91:                     """nothing"""
   92:             
   93:             return field.encode('utf-8')
   94:         
   95:         else:
   96:             return field[0].encode('utf-8')
   97: 
   98:     
   99:     def sortedNames(self,list):
  100:         """sort names"""
  101: 
  102:         def sortLastName(x_c,y_c):
  103:             x=urllib.unquote(x_c)
  104:             y=urllib.unquote(y_c)
  105:             
  106:             try:
  107:                 last_x=x.split()[len(x.split())-1]
  108:                 last_y=y.split()[len(y.split())-1]
  109: 
  110:             except:
  111: 
  112:                 last_x=""
  113:                 last_y=""
  114:             
  115:             
  116:             
  117:             if last_x<last_y:
  118:                 return 1
  119:             elif last_x>last_y:
  120:                 return -1
  121:             else:
  122:                 return 0
  123:             
  124:         list.sort(sortLastName)
  125:         list.reverse()
  126:         
  127:         return list
  128:     
  129:     def __init__(self, id, title):
  130:         """init"""
  131:         self.id=id
  132:         self.title=title
  133: 
  134:     def urlQuote(self,str):
  135:         """quote"""
  136:         return urllib.quote(str)
  137: 
  138:     def urlUnQuote(self,str):
  139:         """quote"""
  140:         return urllib.unquote(str)
  141:     
  142:     def harvestHistoricalPersons(self):
  143:         """erstelle liste aller erwaehnten actors"""
  144: 
  145:         def normalize(str):
  146:             """loesche fuhrendes space"""
  147:             if (len(str)>1) and (str[0]==" "):
  148:                 ret=str[1:]
  149:             else:
  150:                 ret=str
  151:             return ret
  152:         
  153:         list={}
  154:         projects=self.ZopeFind(self.projects,obj_metatypes=['MPIWGProject'])
  155:         
  156:         for project in projects:
  157:             lg=len(project[1].xdata_03[0])-1
  158: 
  159:             if (lg>1) and (project[1].xdata_03[0][lg]==";"):
  160:                 project[1].xdata_03[0]=project[1].xdata_03[0][0:lg]
  161: 
  162:           
  163:      
  164:                 
  165:             try:
  166:                 if len(project[1].xdata_03[0].split(";"))>1: # guess if separator is ;
  167:                     for person in project[1].xdata_03[0].split(";"):
  168:                         personNormal=normalize(person)
  169:                         if personNormal in list.keys():
  170:                             list[urllib.quote(personNormal)][1].append(project[1])
  171:                         else:
  172:                             list[urllib.quote(personNormal)]=(personNormal,[project[1]])
  173:                 else: #guess , is sepeator
  174:                     for person in project[1].xdata_03[0].split(","):
  175:                         personNormal=normalize(person)
  176:                         if urllib.quote(personNormal) in list.keys():
  177:                             list[urllib.quote(personNormal)][1].append(project[1])
  178:                         else:
  179:                             list[urllib.quote(personNormal)]=(personNormal,[project[1]])
  180: 
  181:             except:
  182:                 print "ERROR",project
  183:                 
  184:         return list
  185: 
  186:     def storeHistoricalPersons(self,RESPONSE=None):
  187:         """store persons"""
  188:         self.personDict={}
  189:         personDict=self.harvestHistoricalPersons()
  190:         for person in personDict.keys():
  191:             for project in personDict[person][1]:
  192:                 if person in self.personDict.keys():
  193:                     self.personDict[person][1].append((project.absolute_url(),project.WEB_title[0],project.xdata_01[0]))
  194:                 else:
  195:                     self.personDict[person]=(personDict[person][0],[(project.absolute_url(),project.WEB_title[0],project.xdata_01[0])])
  196: 
  197:         if RESPONSE is not None:
  198:             RESPONSE.redirect("showHistoricalPersons")
  199:             
  200: 
  201:     def showHistoricalPersons(self):
  202:         """show persons"""
  203:         pt=PageTemplateFile('Products/MPIWGWeb/zpt/showHistoricalPersons').__of__(self)
  204:         return pt()
  205: 
  206:         
  207:     def editHistoricalPersonsForm(self):
  208:         """edit historical persons for consistency"""
  209:         pt=PageTemplateFile('Products/MPIWGWeb/zpt/editHistoricalPersonsForm').__of__(self)
  210:         return pt()
  211: 
  212:     def getProjectsByFieldContent(self,fieldName,fieldContentsEntry):
  213:         """gib alle Projekte aus mit Value von field mit fieldName enthält ein Element der Liste fieldContents"""
  214:         if type(fieldContentsEntry) is StringType:
  215:             fieldContents=[fieldContentsEntry]
  216:         else:
  217:             fieldContents=fieldContentsEntry
  218:             
  219:         projects=self.ProjectCatalog({fieldName:string.join(fieldContents,' OR')})
  220:         #print projects
  221:         return projects
  222: 
  223:     def changeMPIWGRootForm(self):
  224:         """edit"""
  225:         pt=PageTemplateFile('Products/MPIWGWeb/zpt/changeMPIWGRootForm').__of__(self)
  226:         return pt()
  227: 
  228:     def changeMPIWGRoot(self,title,disciplineList,themesList,RESPONSE=None):
  229:         """change"""
  230:         self.title=title
  231:         self.disciplineList=disciplineList
  232:         self.themesList=themesList
  233: 
  234:         if RESPONSE is not None:
  235:             RESPONSE.redirect('manage_main')
  236: 
  237:     def getDisciplineList(self):
  238:         """get disciplines as list"""
  239:         return self.disciplineList.split("\n")
  240:     
  241:     def getThemeList(self):
  242:         """get themes as list"""
  243:         return self.themesList.split("\n")
  244:     
  245:     def test(self):
  246:         """test"""
  247:         return self.getProjectsByFieldContent('xdata_09',['biology'])[0].absolute_url
  248: 
  249:     def getContexts(self,childs=None,parents=None,depth=None):
  250:         """childs alle childs, alle parents"""
  251:         ret=[]
  252:         if parents:
  253:             splitted=parents.split(".")
  254:             parentId=string.join(splitted[0:len(splitted)-1],".")
  255:         
  256:             for project in self.getProjectFields('xdata_05',sort='int'):
  257:                 if project[1]==parentId:
  258:                     ret.append(project)
  259: 
  260:         if childs:
  261:             for project in self.getProjectFields('xdata_05',sort='int'):
  262:                 searchStr=childs+"(\..*)"
  263:                 if re.match(searchStr,project[1]):
  264:                     
  265:                     if depth:
  266:                         print "ho"
  267:                         if int(depth)>=len(project[1].split("."))-len(childs.split(".")):
  268:                     
  269:                             ret.append(project)
  270:                     else:
  271:                         ret.append(project)
  272:         return ret
  273:     
  274:     def getProjectFields(self,fieldName,folder=None,sort=None):
  275:         """getListofFieldNames"""
  276:         ret=[]
  277:         #print "FN",fieldName
  278:         if not folder:
  279:             folder=self
  280:         for object in folder.__dict__:
  281: 
  282:             obj=getattr(folder,object)
  283:             if hasattr(obj,'meta_type'):
  284:                 #print obj.meta_type
  285:                 if obj.meta_type=='MPIWGProject':
  286:                     if fieldName=="WEB_title_or_short":
  287:                         #print "HI!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
  288:                         #print len(obj.getContent('xdata_07'))
  289:                         if len(obj.getContent('xdata_07'))<3: # hack weil z.Z. manchmal noch ein Trennzeichen ; oder , im Feld statt leer
  290:                             fieldNameTmp="WEB_title"
  291:                         else:
  292:                             fieldNameTmp="xdata_07"
  293:                     else:
  294:                         fieldNameTmp=fieldName
  295:                     
  296:                     ret.append((obj,obj.getContent(fieldNameTmp)))
  297: 
  298:                 if obj.meta_type in self.folders:
  299:                     
  300:                     ret += self.getProjectFields(fieldName,obj)
  301: 
  302:         if sort=="int":
  303:             ret.sort(sortI)
  304:         else:
  305:             ret.sort(sortF)
  306:         
  307:         return ret
  308: 
  309:     def showNewProjects(self):
  310:         projects=[]
  311:         for objs in self.getProjectFields('WEB_title_or_short'): # Get all Projets
  312:             if objs[0].xdata_05[0] == "":
  313:                 
  314:                 projects.append(objs)
  315:                 
  316:         return projects
  317:     
  318:         
  319:     manage_options = Folder.manage_options+(
  320:         {'label':'Import Persons','action':'importNamesForm'},
  321:         {'label':'Main config','action':'changeMPIWGRootForm'},
  322:         {'label':'Edit Historical Persons','action':'editHistoricalPersonsForm'},
  323:         {'label':'Store Historical Persons','action':'storeHistoricalPersons'},
  324:         )
  325:     
  326:     def importNamesForm(self):
  327:         """Form"""
  328:         pt=PageTemplateFile('Products/MPIWGWeb/zpt/MPIWGNamesForm.zpt').__of__(self)
  329:         return pt()
  330: 
  331:     def importNames(self,fileupload,folderName,RESPONSE=None):
  332:         """import komma-sep list email,lastName,firstName"""
  333:         project=getattr(self,folderName)
  334:         load=fileupload.read()
  335:         
  336:         for line in load.split('\r'):
  337:             
  338:             
  339:             splitted=line.split(",")
  340:             print splitted
  341:         
  342:             if not (splitted[0]==""):
  343:                 newObj=MPIWGStaff.MPIWGStaff(splitted[0],splitted[1],splitted[2])
  344:                 
  345:                 try:
  346:                     project._setObject(splitted[0],newObj)
  347:                     print "done:",splitted[0]
  348:                 except:
  349:                     print "not done:",splitted[0]
  350:                     
  351:         if RESPONSE is not None:
  352:             RESPONSE.redirect('manage_main')
  353: 
  354:     def getAllMembers(self):
  355:         """give list of all members"""
  356:         ret=[]
  357: 
  358:         #for x in self.members.objectValues('MPIWGStaff'):
  359:             #print x.title
  360:         #    ret.append(x.title.decode('utf-8'))
  361: 
  362:         for x in self.ZopeFind(self.members,obj_metatypes=['MPIWGStaff']):
  363:                                ret.append(x[1].title.decode('utf-8'))
  364:             
  365:         #ret.sort()
  366:         #print ret
  367:   
  368:         return ret
  369: 
  370:     def printAllMembers(self):
  371:         """prin"""
  372:         members=self.getAllMembers()
  373:         ret=""
  374:         for x in members:
  375:             ret+="<p>%s</p>"%x
  376:         return ret
  377:     
  378:         
  379:     def makeList(self,entry):
  380:         """makes a list out of one entry or repeat a list"""
  381:         if type(entry) is StringType:
  382:             return [entry]
  383:         else:
  384:             return entry
  385: 
  386: 
  387:     def getTree(self):
  388:         """generate Tree from project list"""
  389:         returnList=[]
  390:         for project in self.getProjectFields('xdata_05',sort="int"): # get Projects sorted by xdata_05
  391:             for idNr in project[1].split(";"): # more than one number
  392:                 if not idNr=="":
  393:                     splittedId=idNr.split(".")
  394:                     depth=len(splittedId)
  395:                     nr=idNr
  396:                     title=project[0].WEB_title
  397:                     
  398:                     returnList.append((depth,nr,title,project[0]))
  399:         
  400:         return returnList
  401: 
  402:     def changePosition(self,treeId,select,RESPONSE=None):
  403:         """Change Postion Entry"""
  404:         numbers=[]
  405: 
  406:         # Suche hoechste bisherige nummer
  407:         projects=self.getProjectFields('xdata_05') # get Projects sorted by xdata_05
  408:         #print "pj",projects
  409:         for project in projects: #suche alle subtrees der treeId
  410:             #print treeId
  411:             
  412:             founds=re.match(treeId+"\.(.*)",project[1].split(";")[0])
  413:             if founds:
  414:                 #print "x",founds.group(0),len(founds.group(0).split("."))
  415:                 if len(founds.group(0).split("."))==len(treeId.split("."))+1: # nur ein punkt mehr, d.h. untere ebene
  416:                     try:
  417:                         numbers.append(int(founds.group(0).split(".")[len(founds.group(0).split("."))-1]))
  418:                     except:
  419:                         numbers.append(int(0))
  420: 
  421:         try:
  422:             highest=max(numbers)
  423:         except:
  424:             highest=0
  425:         projects=self.showNewProjects()
  426:         for i in self.makeList(select):
  427:             highest+=10
  428:             projects[int(i)][0].xdata_05=treeId+"."+str(highest)
  429: 
  430: 
  431:         if RESPONSE is not None:
  432:             RESPONSE.redirect('showTree')
  433:         
  434:     def changeTree(self,RESPONSE=None):
  435:         """change the complete tree"""
  436:         form=self.REQUEST.form
  437:         hashList={}
  438:         fields=self.getTree()
  439: 
  440:         
  441:         for idNr in form.keys():
  442:             fields[int(idNr)][3].xdata_05=form[idNr]
  443: 
  444:         
  445: 
  446:         if RESPONSE is not None:
  447:             RESPONSE.redirect('showTree')
  448: 
  449:     def getProjectWithId(self,id):
  450:         fields=self.getProjectFields('xdata_05')
  451:         for field in fields:
  452:             if field[1]==id:
  453:                 return field[0]
  454: 
  455:         return None
  456:             
  457:         
  458:             
  459:         
  460:         
  461:             
  462:     def getUrlFromPerson(self,list):
  463:         """get urls to person list"""
  464:         ret=[]
  465:         persons=list.split(";")
  466:         for person in persons:
  467:             
  468:             if len(person)>1: #nicht nur Trennzeichen
  469:                 splitted=person.split(",")
  470:                 if len(splitted)==1:
  471:                     splitted=person.split(" ")
  472:                 splittedNew=[re.sub(r'\s(.*)','$1',split) for split in splitted]
  473:                 if splittedNew[0]=='':
  474:                     del splittedNew[0]
  475:                 search=string.join(splittedNew,' AND ')
  476:                 
  477:                 if not search=='':
  478: 
  479:                     try:
  480:                         proj=self.MembersCatalog({'title':search})
  481:                     except:
  482:                         proj=None
  483: 
  484:                 if proj:
  485:                     #ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url,person.encode('utf-8')))
  486:                     ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url,person))
  487:                 else:
  488:                     #ret.append("%s"%person.encode('utf-8'))
  489:                     ret.append("%s"%person)
  490:         return string.join(ret,";")
  491:                          
  492:     def getProjectsOfMembers(self):
  493:         """give tuple member /projects"""
  494:         ret=[]
  495:         members=self.getAllMembers()
  496:         #return str(members)
  497:         for x in members:
  498:             ret+=self.getProjectsOfMember(name=x)
  499: 
  500:         return ret
  501: 
  502:     def getProjectsOfMember(self,name=None,email=None):
  503:         """get project of a member"""
  504:         def sortP(x,y):
  505:             """sort by sorting number"""
  506:             
  507:             return cmp(x.xdata_05,y.xdata_05)
  508:         
  509:  
  510:         ret=[]
  511:         splitNeu=[]
  512:         if email:
  513:             members=self.ZopeFind(self.members,obj_metatypes=['MPIWGStaff'],obj_ids=[email])
  514:             name =  members[0][1].title.decode('utf-8')
  515: 
  516:         y=name
  517:         splitted=y.split(",")  
  518:         for s in splitted:
  519:             splitNeu.append("\""+s+"\"")
  520:         search=string.join(splitNeu,' AND ')
  521:             
  522:         proj=self.ProjectCatalog({'xdata_01':search})
  523:         if proj:
  524:             proj2=[x for x in proj]
  525:             proj2.sort(sortP)
  526:             ret.append((y,proj2))
  527: 
  528:         proj=self.ProjectCatalog({'xdata_08':search})
  529:         if proj:
  530:             proj2=[x for x in proj]
  531:             proj2.sort(sortP)
  532:             ret.append((y,proj2))
  533: 
  534:         
  535:         return ret
  536:      
  537:     def givePersonList(self,name):
  538:         """check if person is in personfolder and return list of person objects"""
  539:         
  540:         splitted=name.split(",")
  541:         if len(splitted)==1:
  542:             splitted=name.split(" ")
  543:         splittedNew=[re.sub(r'\s(.*)','$1',split) for split in splitted]
  544:         if splittedNew[0]=='':
  545:             del splittedNew[0]
  546:         search=string.join(splittedNew,' AND ')
  547:         if not search=='':
  548:             proj=self.MembersCatalog({'title':search})
  549: 
  550:         if proj:
  551:             return [[x.lastName,x.firstName] for x in proj]
  552:         else:
  553:             return []
  554:             
  555: ##         splitted=name.split(",") # version nachname, vorname...
  556: ##         if len(splitted)>1:
  557: ##             lastName=splitted[0] 
  558: ##             firstName=splitted[1]
  559: ##         else: 
  560: ##             splitted=name.split(" ") #version vorname irgenwas nachnamae
  561:         
  562: ##             lastName=splitted[len(splitted)-1]
  563: ##             firstName=string.join(splitted[0:len(splitted)-1])
  564: 
  565: ##         objs=[]
  566: 
  567:         #print  self.members 
  568:       ##   for x in self.members.__dict__:
  569: ##             obj=getattr(self.members,x)
  570: ##             if hasattr(obj,'lastName') and hasattr(obj,'firstName'):
  571:                 
  572: ##                 if (re.match(".*"+obj.lastName+".*",lastName) or re.match(".*"+lastName+".*",obj.lastName)) and (re.match(".*"+obj.firstName+".*",firstName) or re.match(".*"+firstName+".*",obj.firstName)):
  573:                     
  574: ##                     objs.append((obj,lastName+", "+firstName))
  575: 
  576:         
  577:         return objs
  578: 
  579: 
  580:     def personCheck(self,names):
  581:         """all persons for list"""
  582:         #print "names",names
  583:         splitted=names.split(";")
  584:         ret={}
  585:         for name in splitted:
  586: 
  587:             if not (name==""):
  588:                 try:
  589:                     ret[name]=self.givePersonList(name)
  590:                 except:
  591:                     """NOTHIHN"""
  592:         #print "RET",ret
  593:         return ret
  594: 
  595:     def giveCheckList(self,person,fieldname):
  596:         """return checklist"""
  597:         #print "GCL",fieldname
  598:         if fieldname=='xdata_01':
  599:             x=self.personCheck(person.getContent(fieldname))
  600:             #print "GCLBACKX",x
  601:             return x
  602:         
  603: 
  604:     def isCheckField(self,fieldname):
  605:         """return chechfield"""
  606:         
  607:         return (fieldname in checkFields)
  608: 
  609: 
  610:     
  611:     
  612:         
  613: def manage_addMPIWGRootForm(self):
  614:     """form for adding the root"""
  615:     pt=PageTemplateFile('Products/MPIWGWeb/zpt/addMPIWGRootForm.zpt').__of__(self)
  616:     return pt()
  617: 
  618: def manage_addMPIWGRoot(self,id,title,RESPONSE=None):
  619:     """add a root folder"""
  620:     newObj=MPIWGRoot(id,title)
  621:     self._setObject(id,newObj)
  622: 
  623:     if RESPONSE is not None:
  624:         RESPONSE.redirect('manage_main')
  625:         
  626: 
  627: class MPIWGProject(Folder):
  628:     """Class for Projects"""
  629: 
  630:     meta_type='MPIWGProject'
  631: 
  632:     def crossLinker(self):
  633:         """experimental crosslinker"""
  634:         splitted=self.WEB_project_description[0].split()
  635:         new=[]
  636:         for split in splitted:
  637:             try:
  638:                 found=self.DescriptionCatalog({'fulltext':split})
  639:           
  640:                 if len(found)>1:
  641:              
  642:                     new.append("<a href=%s>%s</a>"%(split,split))
  643:                 else:
  644:                     new.append(split)
  645:             except:
  646:                 new.append(split)
  647:         return string.join(new)
  648:             
  649:             
  650: 
  651: 
  652:     def generateTemplate(self,RESPONSE=None):
  653:         """Erzeuge Template für defined fields not_used"""
  654: 
  655:         id="index_html"
  656:         title=id
  657:         if self._getOb('index_html'):
  658:             self._delObject('index_html')
  659: 
  660:         
  661:         newObj=ZopePageTemplate(id,'TEXT')
  662:         self._setObject(id,newObj)
  663:         #self.manage_addPageTemplate(id,title)
  664:         if RESPONSE is not None:
  665:             RESPONSE.redirect('manage_main')
  666:             
  667:     def __init__(self, id, argv=None):
  668:         """initieriere classe"""
  669:         
  670:         self.id=id
  671:         self.title=id
  672:         if argv:
  673:             for arg in definedFields:
  674: 		try:
  675:                 	setattr(self,arg,argv[arg])
  676: 		except:
  677: 			setattr(self,arg,"")
  678:         else:
  679:             for arg in definedFields:
  680:                 setattr(self,arg,'')
  681:             
  682:     manage_options = Folder.manage_options+(
  683:         {'label':'Load New File','action':'loadNewFileForm'},
  684:         {'label':'Edit ProjectInfo','action':'editMPIWGProjectForm'},
  685:         {'label':'Edit BasisInfo','action':'editMPIWGBasisForm'},
  686:         {'label':'Edit Publications','action':'editMPIWGRelatedPublicationsForm'},
  687:         {'label':'Edit Themes & Disciplines','action':'editMPIWGDisciplinesThemesForm'},
  688:         )
  689: 
  690:     def getDataFields(self):
  691:         """giveListofDatafields"""
  692:         ret=[]
  693:         for x in range(1,14):
  694:             ret.append('xdata_%02i'%x)
  695:         return ret
  696:             
  697:     def getDefinedFields(self):
  698:         """show all defined fields"""
  699:         
  700:         return definedFields
  701: 
  702:     def getAttribute(self,field):
  703:         """get attrbiute"""
  704:         return getattr(self,field)
  705: 
  706:     def getContent(self,field):
  707:         """Inhalt des Feldes"""
  708:         
  709:         text=u''
  710:         #print "FIELD",field
  711:         for x in getattr(self,field):
  712:             #print "HIHIIII"
  713:             
  714:             try:
  715:                 text +=x.encode('utf-8')
  716:             except:
  717:                 try:
  718:                     text =x.encode('utf-8')
  719:                 except:
  720:                     text="ERROR"
  721:         
  722:         #delete separator (;) if  is there is one
  723:         try:
  724:             if text[len(text)-1]==";":
  725:                 text=text[0:len(text)-1].encode('utf-8')
  726:         except:
  727:             """nothing"""
  728:             
  729:         return text
  730: 
  731:     
  732:     def show_html(self):
  733:         """simple index"""
  734:         #return "HI"
  735:         pt=PageTemplateFile('Products/MPIWGWeb/zpt/MPIWGProject_index.zpt').__of__(self)
  736:         return pt()
  737: 
  738:     def editMPIWGProjectForm(self):
  739:         """editform"""
  740:         pt=PageTemplateFile('Products/MPIWGWeb/zpt/edit_MPIWGProject.zpt').__of__(self)
  741:         return pt()
  742: 
  743:     def editMPIWGProject(self,RESPONSE=None):
  744:         """edit the project"""
  745:         
  746:         #return self.REQUEST
  747:         for x in definedFields:
  748:             if self.REQUEST.has_key(x):
  749:                 
  750:                 setattr(self,x,[self.REQUEST[x].decode('utf-8')])
  751:             
  752:         if RESPONSE is not None:
  753:             RESPONSE.redirect('manage_main')
  754: 
  755:     def editMPIWGDisciplinesThemesForm(self):
  756:         """edit the disciplines and themes Form"""
  757:         pt=PageTemplateFile('Products/MPIWGWeb/zpt/edit_MPIWGDisciplinesThemes.zpt').__of__(self)
  758:         return pt()
  759: 
  760:     def editMPIWGDisciplinesThemes(self,disciplines=None,themes=None,RESPONSE=None):
  761:         """edit disciplin and form"""
  762:         if disciplines:
  763:             if type(disciplines) is StringType:
  764:                 self.xdata_09=disciplines
  765:             else:
  766:                 self.xdata_09=string.join(disciplines,";")
  767:         else:
  768:                 self.xdata_09=""
  769:         if themes:
  770:             if type(themes) is StringType:
  771:                 self.xdata_10=themes
  772:             else:
  773:                 self.xdata_10=string.join(themes,";")
  774:         else:
  775:             self.xdata_10=""
  776:             
  777:         if RESPONSE is not None:
  778:             RESPONSE.redirect('manage_main')
  779: 
  780: 
  781:     def isChecked(self,wert,list):
  782:         """check if wert is in ; seperated list"""
  783:         print "W:",wert
  784:         print "L:",list,type(list)
  785:         #felder sind manchmnal als liste mit einem element definiert
  786:         if type(list) is StringType or UnicodeType: 
  787:             splitted=list.split(";")
  788:         else:
  789:             splitted=list[0].split(";")
  790: 
  791:         print splitted
  792:         for x in splitted:
  793:             if (not x==u'') and x in wert:
  794:                 return 1
  795:         return 0
  796:     
  797:     def editMPIWGBasisForm(self):
  798:         """editform"""
  799:         pt=PageTemplateFile('Products/MPIWGWeb/zpt/edit_MPIWGBasis.zpt').__of__(self)
  800:         return pt()
  801:     def editMPIWGRelatedPublicationsForm(self):
  802:         """Edit related Publications"""
  803:         pt=PageTemplateFile('Products/MPIWGWeb/zpt/edit_MPIWGRelatedPublications.zpt').__of__(self)
  804:         return pt()
  805:         
  806:     
  807:     def loadNewFileForm(self):
  808:         """Neues XML-File einlesen"""
  809:         pt=PageTemplateFile('Products/MPIWGWeb/zpt/MPIWGProject_newfile.zpt').__of__(self)
  810:         return pt()
  811: 
  812:     def loadNewFile(self,RESPONSE=None):
  813:         """einlesen des neuen files"""
  814:         fileupload=self.REQUEST['fileupload']
  815:         if fileupload:
  816:             file_name=fileupload.filename
  817:             filedata=fileupload.read()
  818: 
  819:             argv=xmlhelper.proj2hash(filedata)
  820:             #print argv.keys()
  821:             for arg in definedFields:
  822:                 
  823:                 #print arg,argv[arg],getattr(self,arg)
  824:                 try:
  825:                     temp=argv[arg][0:]
  826:                     #old=getattr(self,arg)
  827:                     setattr(self,arg,temp)
  828:                     #print old,getattr(self,arg)
  829:                 except:
  830:                     """nothing"""
  831:                     
  832:         if RESPONSE is not None:
  833:             RESPONSE.redirect('manage_main')
  834: 
  835: def manage_addMPIWGProjectForm(self):
  836:     """form for adding the project"""
  837:     pt=PageTemplateFile('Products/MPIWGWeb/zpt/addMPIWGProjectForm.zpt').__of__(self)
  838:     return pt()
  839: 
  840: def manage_addMPIWGProject(self,id,RESPONSE=None):
  841:     """method to add a project"""
  842:     #print argv
  843:     if self.REQUEST.has_key('fileupload'):
  844:         fileupload=self.REQUEST['fileupload']
  845:         if fileupload:
  846:             file_name=fileupload.filename
  847:             filedata=fileupload.read()
  848: 
  849:             argv=xmlhelper.proj2hash(filedata)
  850: 
  851:             #print argv
  852:         newObj=MPIWGProject(id,argv)
  853:     else:
  854:         newObj=MPIWGProject(id)
  855: 
  856:     self._setObject(id,newObj)
  857: 
  858: 
  859:     if RESPONSE is not None:
  860:         RESPONSE.redirect('manage_main')

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