File:  [Repository] / MPIWGWeb / MPIWGStaff.py
Revision 1.10.2.7: download - view: text, annotated - select for diffs - revision graph
Fri Oct 14 15:21:22 2005 UTC (18 years, 8 months ago) by dwinter
Branches: r2
bugs fixed

    1: """This file contains the classes for the organization of the staff"""
    2: # TODO: pruefe ob die id der einzelnen tabellen, wie id in publications noch benutzt werden
    3: # TODO: pruefe ob die bibliographischen felder in publications noch benutzt werden
    4: # TODO: wird username gebraucht?
    5: 
    6: from OFS.Folder import Folder
    7: from Products.ZSQLExtend.ZSQLExtend import ZSQLExtendFolder
    8: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
    9: from Products.PageTemplates.PageTemplate import PageTemplate
   10: from Products.ZCatalog.CatalogPathAwareness import CatalogAware
   11: import os
   12: import bibliography
   13: from Globals import package_home
   14: from Products.PythonScripts.standard import sql_quote
   15: from types import *
   16: 
   17: departmentList="Renn\nRheinberger\nDaston\nKlein\nSibum\nIT\nInstitut\nBibliothek"
   18: 
   19: 
   20: def getTemplate(self, tpName):
   21:     """get a template file either form the instance or from the product"""
   22:     ext=self.ZopeFind(self.aq_parent,obj_ids=[tpName])
   23:     if ext:
   24:         pt = getattr(self,ext[0][1].getId())
   25:     else:
   26:         pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/'+tpName)).__of__(self)
   27:     assert(pt)
   28:     return pt
   29: 
   30: class MPIWGStaff(CatalogAware,ZSQLExtendFolder):
   31:     """Staff"""
   32: 
   33:     meta_type="MPIWGStaff"
   34:     default_catalog='MembersCatalog'
   35:     departmentList=departmentList
   36:     
   37:     def getConnectionObj(self):#ueberschreibe connection id methode    
   38:          
   39:             return getattr(self.de,self.de.connection_id)
   40:         
   41:     def isPublished(self):
   42:         """gib publications status aus der datenbank aus"""
   43:         username=self.getId()
   44:         query="select count(publish_the_data) from personal_www where username='%s' and publish_the_data='yes'"%username
   45:         
   46:         res = self.ZSQLQuery(query)
   47:         
   48:         if res and res[0].count>0:
   49:             return True
   50:         else:
   51:             return False
   52:         
   53:     def createNewDBEntry(self,publish_the_data,id,name,vorname,username,title,e_mail,e_mail_p,date_from,date_to,abteilung,heimat_inst,funded_by="",e_mail2="",txt="",txt_p="no"):
   54:         """lege person in der datenbank an"""
   55:         msg=""
   56:         #test ob id schon existiert
   57:         if self.ZSQLQuery("select id from personal_www where id='%s'"%id):
   58:             return False,"ERROR:id %s already exists"%id
   59:         
   60:         if self.ZSQLQuery("select username from personal_www where username='%s' and publish_the_data='yes'"%username):
   61:             
   62:             return False,"ERROR:username %s already exists and has data published, id=%s not added (running update again might solve this problem)"%(username,id)
   63:         
   64:         if self.ZSQLQuery("select username from personal_www where username='%s' and not publish_the_data='yes'"%username):
   65:             msg="WARNING:username %s not unique but id=%s added"%(username,id)
   66:         #eintragen
   67:         columnlist="publish_the_data,id,name,vorname,username,title,e_mail,e_mail_p,date_from,date_to,abteilung,heimat_inst,funded_by,e_mail2"
   68:         insertTuple=(publish_the_data,id,name,vorname,username,title,e_mail,e_mail_p,date_from,date_to,abteilung,heimat_inst,funded_by,e_mail2)
   69:         
   70:         insert=[]
   71:         for element in insertTuple:
   72:             insert.append("'%s'"%element)
   73:         
   74:         insertStr=",".join(insert)
   75:         queryStr="INSERT INTO personal_www (%s) VALUES (%s)"%(columnlist,insertTuple)
   76:         
   77:         self.ZSQLQuery(queryStr)
   78:         
   79:         #currentwork
   80:         if not (txt==""):
   81:             queryStr="INSERT INTO current_work (id_main,current,publish) VALUES ('%s','%s','%s')"%(id,txt,txt_p)
   82:             self.ZSQLQuery(queryStr)
   83:         
   84:         return True,msg
   85:     
   86:     def updateDBEntry(self,publish_the_data,date_from,date_to,DBid=None): 
   87:         """zpddatedb"""
   88:         if not DBid:
   89:             DBid=self.getDBId()
   90:          
   91:         self.ZSQLQuery("SET DATESTYLE TO 'German'")
   92:         self.ZSQLChange(_table="personal_www",_identify="id=%s"%DBid,publish_the_data=publish_the_data,
   93:                                    date_from=date_from,
   94:                                    date_to=date_to)
   95:                   
   96:           
   97:     def getPublicationSelectionMode(self):
   98:         """get publication selection mode, default 'priority'"""
   99:         return getattr(self,'publicationSelectionMode','priority')
  100:         
  101:     def changePublicationSelectionMode(self,publicationSelectionMode,RESPONSE=None):
  102:         """change PublicationSelectionMode"""
  103:         
  104:         self.publicationSelectionMode=publicationSelectionMode
  105:         
  106:         if RESPONSE:
  107:             RESPONSE.redirect("editPublications")
  108:             
  109:             
  110:     def getPublishImage(self):
  111:         """publish the image??, default no"""
  112:         return getattr(self,'publishImage','no')
  113:     
  114:     def updateImage(self,file,publishImage,rename=None,RESPONSE=None):
  115:         """update image"""
  116:         
  117:         if self.getImageObj():
  118:             self.getImageObj().updateImage(file,rename=None,RESPONSE=None)
  119:         else:
  120:             self.getImageFolder().addImage2(file,fileName=self.getId())
  121:             
  122:         self.publishImage=publishImage
  123:         
  124:         if RESPONSE:
  125:             RESPONSE.redirect("edit")
  126:             
  127:     def getImageFolder(self):
  128:         """getImageFolder"""
  129:         return self.getPhysicalRoot().www_neu.images.staff_images
  130:     
  131:     def getImageObj(self):
  132:         """getImage"""
  133:         imageFolder=self.getImageFolder()
  134:         
  135:         image=getattr(imageFolder,self.getId(),None)
  136: 
  137:         if not image:
  138:             for suffix in ['jpg','tif']:
  139:                 
  140:                 image=getattr(imageFolder,self.getId()+"."+suffix,None)
  141:                 if image:
  142:                     break
  143:         return image
  144:             
  145:     def getImageUrl(self):
  146:         """getImageUrl"""
  147:         image=self.getImageObj()
  148:         if not image:
  149:             return None
  150:         else:
  151:             return self.getImageObj().absolute_url()+"/image"
  152:     
  153:     def PrincipiaSearchSource(self):
  154:         """Return cataloguable key for ourselves."""
  155:         return str(self)
  156: 
  157:     manage_options = Folder.manage_options+(
  158:         {'label':'Edit','action':'changeMPIWGStaffForm'},
  159:         {'label':'Change Publications Special','action':'changePublications_specialForm'},
  160:         )
  161:     
  162:     def __init__(self,id, lastName,firstName):
  163:         """init"""
  164:         self.id=id
  165:         self.title="%s, %s"%(lastName,firstName)
  166:         self.lastName=lastName
  167:         self.firstName=firstName
  168: 
  169: 
  170:     def index_html(self):
  171:         """show homepage"""
  172:         pt = getTemplate(self, "members_main")
  173:         return pt()
  174: 
  175:     def changePublications_specialForm(self):
  176:         """Priority publications manual field"""
  177:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changePublications_special.zpt')).__of__(self)
  178:         return pt()
  179:         
  180:     def changePublications_special(self,usePublicationsSpecial=None,specialPublicationsField=None,RESPONSE=None):
  181:         """change publications special params"""
  182:         if usePublicationsSpecial:
  183:           self.usePublicationsSpecial=True
  184:          
  185:         else:
  186:           self.usePublicationsSpecial=False
  187: 
  188:         self.specialPublicationsField=specialPublicationsField[0:]
  189: 
  190:         if RESPONSE is not None:
  191:             RESPONSE.redirect('manage_main')
  192: 
  193:         
  194:     def publications_full(self):
  195:         """show publication"""
  196:         pt=getTemplate(self, "publications_full_main")
  197:         return pt()
  198: 
  199:     def talks_full(self):
  200:         """show talks"""
  201:         pt=getTemplate(self, 'talks_full_main')
  202:         return pt()
  203: 
  204:     def teaching_full(self):
  205:         """show talks"""
  206:         pt=getTemplate(self, 'teaching_full_main')
  207:         return pt()
  208:     
  209:     def changeMPIWGStaffForm(self):
  210:         """change form"""
  211:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGStaff.zpt')).__of__(self)
  212:         return pt()
  213: 
  214:     def changeMPIWGStaff(self,lastName,firstName,RESPONSE=None):
  215:         """change it"""
  216:         self.title="%s, %s"%(lastName,firstName)
  217:         self.lastName=lastName
  218:         self.firstName=firstName
  219: 
  220:         if RESPONSE is not None:
  221:             RESPONSE.redirect('manage_main')
  222: 
  223:     def edit(self):
  224:         """Edit the pages"""
  225: 
  226:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editMPIWGStaff.zpt')).__of__(self)
  227:         return pt()
  228: 
  229:     mainEditFile=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editMPIWGStaff_main.zpt'))
  230: 
  231:     def changeResearch(self,noredirect=None):
  232:         """change the research entries"""
  233:         newEntries={}
  234:         id_main=self.REQUEST.form['id_main']
  235: 
  236:         mainfieldL=self.REQUEST.form['main_fields'].split(",")
  237:         mainfield={}
  238:         for x in mainfieldL:
  239:             tmp=x.split('__')
  240:             mainfield[tmp[0]]=tmp[1]
  241:         for field in self.REQUEST.form.keys():
  242:             splittedField=field.split("__")
  243:             if len(splittedField)<3:
  244:                 pass #kein datenbank eintrag
  245: 
  246:             elif splittedField[2]=='new': # store new entries
  247:                 if not newEntries.has_key(splittedField[0]):
  248:                     newEntries[splittedField[0]]={}
  249:                     
  250:                 newEntries[splittedField[0]][splittedField[1]]=self.REQUEST.form[field]
  251: 
  252:             else:
  253:                 query="UPDATE %s "%splittedField[0]
  254:                 query+="SET %s = '%s' "%(splittedField[1],sql_quote(self.REQUEST.form[field]))
  255:                 query+="WHERE oid = '%s' "%sql_quote(splittedField[2])
  256:                 
  257:                 self.ZSQLQuery(query)
  258: 
  259: 
  260:         #new entries
  261:         for newEntry in newEntries.keys():
  262:             query="INSERT INTO %s "%newEntry
  263:             keys=['id_main']
  264:             values=["'"+id_main+"'"]
  265:             for key in newEntries[newEntry].keys():
  266:                 keys.append(key)
  267:                 values.append("'"+newEntries[newEntry][key]+"'")
  268: 
  269: 
  270:             keystring=",".join(keys)
  271:                 
  272:             valuestring=",".join(values)
  273:                 
  274:             query+=" (%s) "%keystring
  275:             query+="VALUES (%s)"%valuestring
  276:             if not (newEntries[newEntry][mainfield[newEntry]].lstrip().rstrip()==""):
  277:                 self.ZSQLQuery(query)
  278: 
  279:         if not noredirect:
  280:             self.REQUEST.RESPONSE.redirect(self.REQUEST['HTTP_REFERER'])
  281:         
  282:     def editCV(self,cv=None,oid=None,RESPONSE=None):
  283:          """edit Cv"""
  284: 
  285:          if (not cv):
  286:              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editCV.zpt')).__of__(self)
  287:              return pt()
  288:         
  289:          query="UPDATE personal_www SET cv ='%s' WHERE oid='%s'"
  290: 
  291:          self.ZSQLQuery(query%(cv,oid))
  292:         
  293:          if RESPONSE:
  294:             RESPONSE.redirect("editCV")
  295: 
  296:     def editAwards(self,awards=None,oid=None,RESPONSE=None):
  297:          """edit a awards"""
  298: 
  299:          if (not awards):
  300:              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editAwards.zpt')).__of__(self)
  301:              return pt()
  302:         
  303:          query="UPDATE personal_www SET awards ='%s' WHERE oid='%s'"
  304: 
  305:          self.ZSQLQuery(query%(awards,oid))
  306:         
  307:          if RESPONSE:
  308:             RESPONSE.redirect("editAwards")
  309: 
  310:     def editTalks(self):
  311:         """edit talks"""
  312: 
  313:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editTalks.zpt')).__of__(self)
  314:         return pt()
  315:         
  316:          
  317:     def editTeaching(self):
  318:         """edit Teaching"""
  319: 
  320:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editTeaching.zpt')).__of__(self)
  321:         return pt()
  322:         
  323:     def getDocTypes(self):
  324:         finds = self.ZopeFind(self.metadata.main.meta.bib,obj_metatypes=["OSAS_MetadataMapping__neu"])
  325: 
  326:         list= [x[0] for x in finds]
  327:         return "\n".join(list)
  328: 
  329:     def editMainData(self,REQUEST=None,RESPONSE=None,name=None,**argv):
  330:         """edit main data"""
  331:         
  332:     
  333:         if not name:
  334:             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editMainData.zpt')).__of__(self)
  335:             return pt() 
  336:         else:
  337:             
  338:             self.ZSQLChange(argv,_table="personal_www",_identify="<%s"%self.getDBId(),USE_FORM="yes")
  339:             if RESPONSE:
  340:                 RESPONSE.redirect("editMainData")
  341:                 
  342:               
  343:     def newBibliography(self,_docType=None, _addEntry=None,RESPONSE=None,**argv):
  344:         
  345:         """add an entry to the bibliography"""
  346:         if not _docType: #kein docType
  347:             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','newBibliographyEntryDocType.zpt')).__of__(self)
  348:             return pt() 
  349:         elif _docType and not _addEntry: #doctype aber keine daten
  350:             self.REQUEST['_docType']=_docType
  351:             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','newBibliographyEntry.zpt')).__of__(self)
  352:             return pt() 
  353:         else: #doctype und daten
  354:             try:
  355:                 newId=self.ZSQLSimpleSearch("select nextval('id_raw')")[0].nextval
  356:             except:#id_raw existiert nich, dann neu erzeugen
  357:                 
  358:                 self.createOrUpdateId_raw()
  359:                 newId=self.ZSQLSimpleSearch("select nextval('id_raw')")[0].nextval
  360:                                 
  361:             bookId="b%06i" % newId
  362:             
  363:             self.ZSQLAdd(argv,_table="bibliography",reference_type=_docType,id=bookId)
  364:             self.ZSQLAdd(_table="publications",id_gen_bib=bookId,id_main=self.getDBId(),publish='yes')
  365:             self.updatePublicationDB(personId=self.getDBId())
  366:             
  367:         
  368:         if RESPONSE:
  369:             RESPONSE.redirect("editPublications")
  370:             
  371:         return True
  372:     
  373:     def editImage(self):
  374:         """edit images"""
  375:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editImageStaff.zpt')).__of__(self)
  376:         return pt()
  377:     
  378:     def editBibliography(self):
  379:         """edit the bibliography"""
  380:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editBibliographyEntry.zpt')).__of__(self)
  381:         return pt()
  382:     
  383:       
  384:         
  385:     def editPublications(self):
  386:         """edit the bibliographie"""
  387: 
  388:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editPublications.zpt')).__of__(self)
  389:         return pt()
  390:     
  391:     def changeSortingMode(self,sortingMode,RESPONSE=None,REQUEST=None):
  392:         """change sorting mode"""
  393:         self.sortingMode=sortingMode
  394:         
  395:         if RESPONSE and REQUEST:
  396:             REQUEST.RESPONSE.redirect(REQUEST['HTTP_REFERER'])
  397: 
  398:         return True
  399: 
  400:     def getSortingMode(self):
  401:         """get sorting mode"""
  402:         return getattr(self,'sortingMode','priority')
  403:     
  404:     def integer(self,value):
  405:         try:
  406:             return int(value)
  407:         except:
  408:             return 0
  409:         
  410:         
  411:     def changePublications(self):
  412:         """change the publication list"""
  413:         self.changeResearch(noredirect=True)
  414:         
  415:         #self.updatePublicationDB(personId=self.getDBId())
  416:         self.REQUEST.RESPONSE.redirect(self.REQUEST['HTTP_REFERER'])
  417:         
  418: 
  419: 
  420:     def addPublications(self,submit=None,REQUEST=None,noredirect=None):
  421:         """add publications"""
  422: 
  423:         #setzte flag ob aufruf aus suchformular
  424:         
  425:         if REQUEST.get("QUERY_STRING",None) and (not submit):
  426:             self.REQUEST.set('fromSearch','1')
  427:         else:
  428:             self.REQUEST.set('fromSearch','0')
  429:              
  430:         if not submit or (not (submit == "add")):
  431:             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addPublications.zpt')).__of__(self)
  432:             return pt()
  433:         
  434:         #new entries
  435:         entries = REQUEST.form.get('addEntries',None)
  436:         if not (type(entries) is ListType):
  437:             entries=[entries]
  438:             
  439:         for bibId in entries: 
  440:             query="INSERT INTO %s " % "publications"
  441:             query+="(id_main,id_institutsbibliographie,publish) "
  442:             query+="VALUES ('%s','%s','yes')" %(sql_quote(self.getDBId()),sql_quote(bibId))
  443:             print "ADD",query
  444:             #self.ZSQLAdd(_table="publications",id_institutsbibliographie=bibId,id_main=self.getDBId(),publish='yes')
  445:             self.ZSQLQuery(query)
  446:      
  447:         self.updatePublicationDB(personId=self.getDBId())
  448:         
  449:         if not noredirect:
  450:             
  451:             self.REQUEST.RESPONSE.redirect("./editPublications")
  452:             
  453:             return True
  454:         
  455:     
  456:     def getDBId(self):
  457:         """get id from the personal database"""
  458:         search=self.ZSQLInlineSearch(_table='personal_www',username=self.getId(),publish_the_data='yes')
  459:         if search:#name existiert und published, dann nimm diesen falls es mehrereeventuell nich publizierte datensaetze gibt.
  460:             return search[0].id
  461:         else:#nicht publiziert dann nimm einen davon
  462:             search2=self.ZSQLInlineSearch(_table='personal_www',username=self.getId())
  463:             if search2:
  464:                 return search2[0].id
  465:             else:
  466:                 return None
  467:         
  468:     
  469:     
  470:     formatBiblHelp=bibliography.formatBiblHelp
  471:     
  472:     def sortBibliography(self,list,sortingMode=None):
  473:         if not sortingMode:
  474:             sortingMode=self.getSortingMode()
  475:     
  476:         if sortingMode == "year":
  477:             return self.sortYear(list)
  478:         else:
  479:             return self.sortPriority(list)
  480:         
  481:     def sortPriority(self,list):
  482:         def sort(x,y):
  483:             try:
  484:                 xInt=int(x.priority)
  485:             except:
  486:                 xInt=0
  487:             try:
  488:                 yInt=int(y.priority)
  489:             except:
  490:                 yInt=0
  491: 
  492:             return cmp(xInt,yInt)
  493: 
  494:         tmp=[x for x in list]
  495:         tmp.sort(sort)           
  496:         return tmp
  497: 
  498:     def sortYear(self,list):
  499:         #TODO: sort TO APPEAR and TO BE PUBLISHED etc...
  500:         
  501:         def sort(x,y):
  502:             try:
  503:                 xInt=int(x.year)
  504:             except:
  505:                 xInt=0
  506:             try:
  507:                 yInt=int(y.year)
  508:             except:
  509:                 yInt=0
  510: 
  511:             return cmp(yInt,xInt)
  512:             
  513:             
  514:         tmp=[x for x in list]
  515:         
  516:         tmp.sort(sort)           
  517:         return tmp
  518:     
  519:     def deleteField(self,table,oid):
  520:         """delete entry"""
  521:         query="DELETE FROM %s WHERE oid = '%s'"%(table,oid)
  522: 
  523:         self.ZSQLQuery(query)
  524:         self.REQUEST.RESPONSE.redirect(self.REQUEST['HTTP_REFERER'])
  525:         
  526:     
  527: def manage_addMPIWGStaffForm(self):
  528:     """form for adding the project"""
  529:     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMPIWGStaffForm.zpt')).__of__(self)
  530:     return pt()
  531: 
  532: def manage_addMPIWGStaff(self,id,lastName,firstName,RESPONSE=None):
  533:     """add it"""
  534:     newObj=MPIWGStaff(id,lastName,firstName)
  535: 
  536:     self._setObject(id,newObj)
  537: 
  538: 
  539:     if RESPONSE is not None:
  540:         RESPONSE.redirect('manage_main')
  541: 
  542:     

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