File:  [Repository] / MPIWGWeb / MPIWGStaff.py
Revision 1.10.2.5: download - view: text, annotated - select for diffs - revision graph
Wed Oct 12 19:35:38 2005 UTC (18 years, 8 months ago) by dwinter
Branches: r2
new  database handling, major changes to minimize filemaer parts

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

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