"""This file contains the classes for the organization of the staff"""
# TODO: pruefe ob die id der einzelnen tabellen, wie id in publications noch benutzt werden
# TODO: pruefe ob die bibliographischen felder in publications noch benutzt werden
# TODO: wird username gebraucht?

from zExceptions import Redirect

from OFS.Folder import Folder
from Products.PageTemplates.PageTemplateFile import PageTemplateFile
from Products.PageTemplates.PageTemplate import PageTemplate
from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
from Products.ZCatalog.CatalogPathAwareness import CatalogAware
from Products.versionedFile.extVersionedFile import extVersionedFileFolder
from AccessControl import getSecurityManager

from Products.ZSQLExtend.ZSQLExtend import ZSQLExtendFolder

from Products.ZDBInterface.ZDBInterfaceFolder import ZDBInterfaceFolder
from AccessControl import ClassSecurityInfo
from App.class_init import InitializeClass
from Products.ExtFile.ExtFile import * 
import os
import logging
import email
from Globals import package_home
from Products.PythonScripts.standard import sql_quote
from types import *
import time
import logging
import re
from OFS.Cache import Cacheable
import urllib2
import transaction

from SrvTxtUtils import getHttpData, getAt, getInt, unicodify, utf8ify
import bibliography

from MPIWGHelper import *
#ersetzt logging
def logger(txt,method,txt2):
    """logging""" 
    logging.info(txt+ txt2)

departmentList="Renn\nRheinberger\nDaston\nKlein\nSibum\nIT\nInstitut\nBibliothek"
coneService="http://127.0.0.1:8280/MetaDataManagerRestlet/cone/" # kann in MPIWGRoot konfiguriert werden.



def createNewDBEntry(self,publish_the_data,key,name,vorname,titles_new,position,e_mail,e_mail_p,date_from,date_to,abteilung,heimat_inst,funded_by="",e_mail2="",txt="",txt_p="no",stay_at_mpiwg="",group="",web_object_created="no",current_work=""):
        """lege person in der datenbank an"""

        if date_to=="": # wenn date_to leer
             date_to="date_none"
        
        if date_from=="": # wenn date_fromleer
             date_from="date_none"
        msg=""
        #test ob id schon existiert
        if self.ZSQLQuery("select key from personal_www where key='%s'"%id):
            return False,"ERROR:key%s already exists"%key
        
        #eintragen
        columnlist="""publish_the_data,key,last_name,first_name,titles_new,status,e_mail,e_mail_p,date_from,date_to,department,home_inst,funded_by,e_mail2,date_stay_at_mpiwg,web_object_created,"group",current_work,current_work_p """
        insertTuple=(publish_the_data,key,name,vorname,titles_new,position,e_mail,e_mail_p,date_from,date_to,abteilung,heimat_inst,funded_by,e_mail2,stay_at_mpiwg,web_object_created,group,current_work,"yes")
        
        insert=[]
        for element in insertTuple:
            if element=="date_none": # date_none eintrag wird zu null uebersetzt
                insert.append('null')
            else:
                insert.append("%s"%self.ZSQLQuote(element))
            
        insertStr=",".join(insert)
        queryStr="INSERT INTO personal_www (%s) VALUES (%s)"%(columnlist,insertStr)
        self.ZSQLQuery("SET DATESTYLE TO 'German'")
        self.ZSQLQuery(queryStr)
        logging.info("QQQQ %s:"%queryStr)
        #currentwork
        #if not (current_work==""):
        #    queryStr="INSERT INTO current_work (key_main,current,publish) VALUES ('%s',%s,'%s')"%(key,self.ZSQLQuote(current_work),"yes")

        #  self.ZSQLQuery(queryStr)
        
        return True,msg
    
    
class MPIWGStaff(CatalogAware,ZSQLExtendFolder,Cacheable):
    """Staff"""

    meta_type="MPIWGStaff"
    default_catalog='MembersCatalog'
    departmentList=departmentList
    #_v_cone=None;
    security=ClassSecurityInfo()
    
    manage_options = Folder.manage_options+(
        {'label':'Edit','action':'changeMPIWGStaffForm'},
        {'label':'Change Publications Special','action':'changePublications_specialForm'},
        ) + Cacheable.manage_options
    
    __manager_id = "ramCache"
    def __init__(self,id, lastName,firstName,key):
        """init"""
        self.id=id
        self.title=key
        self.lastName=lastName
        self.firstName=firstName
        self.key=key
    
    # compat TODO: remove this
    def getat(self, array, idx, default=None):
        """returns always an int (0 in case of problems)"""
        return getAt(array, idx, default)
    
    # compat TODO: remove this
    def decode(self, s):
        """TODO: remove this"""
        return unicodify(s)
    
    def redirect(self,RESPONSE,url):
        """mache ein redirect mit einem angehaengten time stamp um ein reload zu erzwingen"""
        
        timeStamp=time.time()
        
        if url.find("?")>-1: #giebt es schon parameter
            addStr="&time=%s"
        else:
            addStr="?time=%s"
            
        RESPONSE.setHeader('Last-Modified',email.Utils.formatdate().split("-")[0]+'GMT')
        logging.error(email.Utils.formatdate()+' GMT')
        RESPONSE.redirect(url+addStr%timeStamp)
        
    def getKeyUTF8(self):
        """get db_key utf8"""
        logging.debug("KEY - MPIWGStaff 1:"+self.getKey())
        logging.debug("KEY - MPIWGStaff 2 :"+utf8ify(self.getKey()))
        
        return utf8ify(self.getKey())
    
    def setKey(self,key):
	"""set key"""
	self.key=key

    def rmKey(self):
        """rm"""
        self.key=None
        return ""

    def getKey(self):
        """get database key"""
        

        if getattr(self,'key',None):
            logging.debug("KEY - MPIWGStaff 4:"+self.key)
            #logging.error("SAVED KEY:%s"%self.key)
            return unicodify(self.key.lower())
            #return self.key.lower()
        
        #fuer alt faelle ohne key
        #logging.error("NEW KEY:%s"%(self.firstName+'_'+self.lastName).lower().replace(' ',''))
        return (self.firstName+'_'+self.lastName).lower().replace(' ','')
        
    def getConnectionObj(self):
         """returns connection id (from root)"""
         try:
             root = self.getMPIWGRoot()
             return root.getConnectionObj()
         except:
             return self.en.getConnectionObj()

    def isPublished(self):
        """gib publications status aus der datenbank aus"""
        key=self.getKey()
        query="select count(publish_the_data) from personal_www where lower(key)='%s' and publish_the_data='yes'"%key
        
        res = self.ZSQLQuery(query)
        
        if res and res[0].count>0:
            return True
        else:
            return False
        
 
  
    def updateDBEntry(self,publish_the_data,date_from,date_to,DBid=None,stay_at_mpiwg="",position="",abteilung=""): 
        """zpddatedb"""
        if not DBid:
                    DBid=self.getDBId()
        
 
        self.ZSQLQuery("SET DATESTYLE TO 'German'")

        test=self.ZSQLQuery("select id from personal_www where id='%s' "%DBid)

        
        if test and (len(test)>0): #dataset exists
            logger("MPIWG Web",logging.INFO,'UPDATE: _table="personal_www",_identify="id=%s"'%DBid+',publish_the_data=%s'%publish_the_data+',date_from=%s'%date_from+',date_to=%s'%date_to+',stay_at_mpiwg=%s'%stay_at_mpiwg+',position=%s'%position)
            self.ZSQLChange(_table="personal_www",_identify="id=%s"%DBid,publish_the_data=publish_the_data,
                                   date_from=date_from,
                                   date_to=date_to,stay_at_mpiwg=stay_at_mpiwg,position=position,abteilung=abteilung)
            return True
        else:
            return False
          
    def getPublicationSelectionMode(self):
        """get publication selection mode, default 'priority'"""
        return getattr(self,'publicationSelectionMode','priority')
        
    def changePublicationSelectionMode(self,publicationSelectionMode,RESPONSE=None):
        """change PublicationSelectionMode"""
        
        self.publicationSelectionMode=publicationSelectionMode
        self.ZCacheable_invalidate()
        if RESPONSE:
            self.redirect(RESPONSE,"editPublications")
            
    
    def downloadCV(self,RESPONSE):
        """download cv file"""
        ob=self._getOb("downloadableFiles")._getOb("cv.pdf")
        
        RESPONSE.redirect(ob.absolute_url()+"/download")
    
    def getLastUpdateCV(self):
        """getDate of Last Update"""
        try:
                ob=self._getOb("downloadableFiles")._getOb("cv.pdf")
                return ob.getLastChangeDate()
        except:
                return "No file yet!"
    def getLastUpdatePublications(self):
        """getDate of Last Update"""
        try:
                ob=self._getOb("downloadableFiles")._getOb("publications.pdf")
                return ob.getLastChangeDate()
        except:
                return "No file yet!"
    def downloadPublications(self,RESPONSE):
        """download publications"""
        ob=self._getOb("downloadableFiles")._getOb("publications.pdf")
        
        RESPONSE.redirect(ob.absolute_url()+"/download")
   
    def changeDownloads(self,cv_pdf=None,cv_publish=None,publications_pdf=None,publications_publish=None,RESPONSE=None):
        """"change the downloadable files"""
        self.ZCacheable_invalidate()
        if not hasattr(self,'downloadableFiles'):
           
            extFolder =  extVersionedFileFolder()
            extFolder.id = "downloadableFiles"
            self._setObject(extFolder.id,extFolder)
            
        ob = self._getOb("downloadableFiles")
        
        if cv_publish:
            self.cv_publish=cv_publish
            
        if publications_publish:
            self.publications_publish=publications_publish
            
        if cv_pdf:
            if not hasattr(ob,"cv.pdf"):
                ob.addFile("",cv_pdf,newName="cv.pdf")
            
            else:
                cvFile = getattr(ob,"cv.pdf")
                cvFile.addContentObject("","",file=cv_pdf)
        
        if publications_pdf:
            if not hasattr(ob,"publications.pdf"):
                ob.addFile("",cv_pdf,newName="publications.pdf")
            
            else:
                cvFile = getattr(ob,"publications.pdf")
                cvFile.addContentObject("","",file=publications_pdf)
        
        if RESPONSE:
            self.redirect(RESPONSE,self.REQUEST['HTTP_REFERER'])
    

    def getPublishImage(self):
        """publish the image??, default no"""
        return getattr(self,'publishImage','no')
    
    def updateImage(self,publishImage,file=None,rename=None,RESPONSE=None):
        """update image"""

        if file and not(file.filename==""):
            if self.getImageObj():
                              self.getImageObj().updateImage(file,_rename=None,RESPONSE=None)
            else:
                # create new image object
                xp = file.filename.rfind('.')
                if xp > 0:
                    ext = file.filename[xp:]
                    #fn = self.getId()+ext
                    fn = self.getId()
                    logger("MPWIG STAFF", logging.INFO, "new filename: %s"%fn)
                    self.getImageFolder().addImage2(file,fileName=fn)
                else:
                    logger("MPWIG STAFF", logging.ERROR, "uploaded filename %s has no extension!"%file.filename)
            
        self.publishImage=publishImage
        
        if RESPONSE:
            self.redirect(RESPONSE,"edit")
            
    def getImageFolder(self):
        """getImageFolder"""
        #TODO: make place of staff image folder configurable
        
        try:
            return self.getPhysicalRoot().www_neu.images.staff_images
        except: 
            logger("MPWIG STAFF", logging.ERROR, "image folder not found: has to be add /www_neu/staff_images") 
            return None
        
    def getImageObj(self):
        """getImage"""
        imageFolder=self.getImageFolder()
        
        if not imageFolder: return None
        
        image=getattr(imageFolder,self.getId(),None)

        if not image:
            for suffix in ['jpg','tif']:
                
                image=getattr(imageFolder,self.getId()+"."+suffix,None)
                if image:
                    break
        return image
            
    def getImageUrl(self):
        """getImageUrl"""
        image=self.getImageObj()
        if not image:
            return None
        else:
            return self.getImageObj().absolute_url()+"/image"
    
    def PrincipiaSearchSource(self):
        """Return cataloguable key for ourselves."""
        return str(self)

    def getPersonID(self):
        """gibt den ID fuer die Person zurueck"
        im Moment ist personID = id, i.e. e-mail
        """
        return self.id

    def getConeUrl(self):
        """gibt coneURL zurueck"""
        
        self.coneService=getattr(self, "coneServiceURL",coneService)
        logging.debug("coneservice:"+self.coneService)
        
        if getattr(self,'_v_cone',None)==None:
            try:  
                
                self._v_cone=getHttpData(self.coneService+self.getPersonID())
                #cone = urllib2.urlopen(self.coneService+self.getPersonID())              
                #self._v_cone=cone.read()
                if self._v_cone==None:
                    self._v_cone=""
            except:
                self._v_cone=""
                return ""
            
        return self._v_cone
           
           
        
        
    def harvest_page_old(self,context=None):
        """geharvestete seite = verschlankte version von members_main"""
        #pt = getTemplate(self, "harvest_members_main")
        
        if not self.isPublished():
            return ""
        if not context:
            context=self
            
        
        ext=getattr(self,"harvest_members_main",None)
        if ext:
            return getattr(self,ext.getId())()
        
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','harvest_members_main')).__of__(context)    


        return pt()

    def harvest_page(self,mode="normal"):
        """harvest"""
        logging.debug("AAAAXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
        if not self.isPublished():
            return 
        st = getattr(self.en.staff.members,self.getId()).index_html(mode)
        
        templates = self.en.getHarvestCache()
        #templates = getattr(self,'getHarvestCache',self.en.getHarvestCache)()
        rendered = st
        templates[self.absolute_url()]=rendered
        transaction.commit()
        return rendered
	
        
    
    def index_html(self,mode="normal"):
        """show homepage"""
    
        bound_names={}
        request = self.REQUEST
        if request is not None:
            response = request.response
            if not response.headers.has_key('content-type'):
                response.setHeader('content-type', 'text/html')

        security = getSecurityManager()
        bound_names['user'] = security.getUser()

        # Retrieve the value from the cache.
        keyset = None
        if self.ZCacheable_isCachingEnabled():
            
            # Prepare a cache key.
            keyset = {'here': self}
                      
            result = self.ZCacheable_get(keywords=keyset)
           
            if result is not None:
                # Got a cached value.
                return result
        
        # look for individual page
        if self.hasObject("index.html"):
            pt = getattr(self, "index.html")
        # else use template
        else:
            if mode=="slim":
                pt = getTemplate(self, "members_main_slim")
            else:
                pt = getTemplate(self, "members_main")
        # Execute the template in a new security context.
        security.addContext(self)

        try:
            result = pt.pt_render(extra_context=bound_names)
            if keyset is not None:
                # Store the result in the cache.
                self.ZCacheable_set(result, keywords=keyset)
               
            return result
        finally:
            security.removeContext(self)
       

   
    def changePublications_specialForm(self):
        """Priority publications manual field"""
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changePublications_special.zpt')).__of__(self)
        return pt()
        
    def changePublications_special(self,usePublicationsSpecial=None,specialPublicationsField=None,RESPONSE=None):
        """change publications special params"""
        self.ZCacheable_invalidate()
        if usePublicationsSpecial:
          self.usePublicationsSpecial=True
         
        else:
          self.usePublicationsSpecial=False

        self.specialPublicationsField=specialPublicationsField[0:]

        if RESPONSE is not None:
            self.redirect(RESPONSE,'manage_main')

        
    def publications_full(self):
        """show publication"""
        pt=getTemplate(self, "publications_full_main")
        return pt()

    def talks_full(self):
        """show talks"""
        pt=getTemplate(self, 'talks_full_main')
        return pt()

    def teaching_full(self):
        """show talks"""
        pt=getTemplate(self, 'teaching_full_main')
        return pt()
    
    def changeMPIWGStaffForm(self):
        """change form"""
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGStaff.zpt')).__of__(self)
        return pt()
    
    security.declareProtected('View management screens','changeMPIWGStaff')
    def changeMPIWGStaff(self,lastName,firstName,key=None,RESPONSE=None):
        """change it"""
        self.ZCacheable_invalidate()
        self.title="%s, %s"%(lastName,firstName)
        self.lastName=lastName
        self.firstName=firstName
        if key:
            self.key = key
            
        
        if RESPONSE is not None:
            self.redirect(RESPONSE,'manage_main')
            
    security.declareProtected('View management screens','edit')
    def edit(self):
        """Edit the pages"""
        #TODO: zusammenspiel mit apache, redirect auf 18080 rausnehmen bzw. zumindest verallgemeinern
        #if self.REQUEST['SERVER_URL']=="http://www.mpiwg-berlin.mpg.de":
        #        redURL="http://xserve04.mpiwg-berlin.mpg.de:18080/www_neu/de/mitarbeiter/members/%s/edit"%self.getId()
        #
        #        self.REQUEST.RESPONSE.redirect(redURL)

        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editMPIWGStaff.zpt')).__of__(self)
        
        
        logging.debug("XX:"+email.Utils.formatdate().split("-")[0]+'GMT')
        return pt()

    mainEditFile=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editMPIWGStaff_main.zpt'))
    addPublicationsBib=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addPublicationsBib.zpt'))

    def getPathStyle(self, path, selected, style=""):
        """returns a string with the given style + 'sel' if path == selected."""

        if path == selected:
            return style + 'sel'
        else:
            return style    


    def getLabel(self):
        """returns a label for this object"""
        return self.title

    def getBreadcrumbs(self):
        """return list of breadcrumbs from here to the root"""
        crumbs = []
        # skip direct parent Folder /members/
        parent = self.aq_parent.aq_parent
        # get parents breadcrumbs
        logging.debug("getbreadcrumbs-: title=%s self=%s parent=%s"%(self.title, repr(self), repr(parent)))
        if hasattr(parent, 'getBreadcrumbs'):
            logging.debug("getbreadcrumbs: recurse to %s"%parent)
            crumbs = parent.getBreadcrumbs()
        
        # try to get acquisition URL from parent
        if hasattr(parent, 'absolute_url'):
            baseUrl = "%s/%s/"%(parent.absolute_url(), 'members')
        else:
            baseUrl = "/en/staff/members/"
            
        # add this
        crumbs.append((self.getLabel(), baseUrl+self.getId(), self))
            
        return crumbs


    def changeCurrentWork(self,current_work,key,publish="yes",RESPONSE=None):
        """change current work"""
        
        query="UPDATE personal_www SET current_work =%s WHERE key='%s'"
         
        self.ZSQLQuery(query%(self.ZSQLQuote(current_work),key))
       
        query="UPDATE personal_www SET current_work_p =%s WHERE key='%s'"
         
        self.ZSQLQuery(query%(self.ZSQLQuote(publish),key))
        self.ZCacheable_invalidate()
        if RESPONSE:
            self.redirect(RESPONSE,"edit")
        
    security.declareProtected('View management screens','changeResearch')
    def changeResearch(self,noredirect=None,RESPONSE=None):
        """change the research entries"""
        self.ZCacheable_invalidate()
        newEntries={}
        key_main=self.REQUEST.form['key_main']

        mainfieldL=self.REQUEST.form['main_fields'].split(",")
        mainfield={}
        for x in mainfieldL:
            tmp=x.split('__')
            mainfield[tmp[0]]=tmp[1]
        for field in self.REQUEST.form.keys():
            splittedField=field.split("__")
            if len(splittedField)<3:
                pass #kein datenbank eintrag

            elif splittedField[2]=='new': # store new entries
                if not newEntries.has_key(splittedField[0]):
                    newEntries[splittedField[0]]={}
                    
                newEntries[splittedField[0]][splittedField[1]]=self.REQUEST.form[field]

            else:
                query="UPDATE %s "%splittedField[0]
                query+="SET %s = '%s' "%(splittedField[1],sql_quote(self.REQUEST.form[field]))
                query+="WHERE oid = '%s' "%sql_quote(splittedField[2])
                
                self.ZSQLQuery(query)


        #new entries
        for newEntry in newEntries.keys():
            query="INSERT INTO %s "%newEntry
            keys=['key_main']
            values=["'"+sql_quote(key_main)+"'"]
            for key in newEntries[newEntry].keys():
                keys.append(key)
                values.append("'"+sql_quote(newEntries[newEntry][key])+"'")


            keystring=",".join(keys)
                
            valuestring=",".join(values)
                
            query+=" (%s) "%keystring
            query+="VALUES (%s)"%valuestring
            if not (newEntries[newEntry][mainfield[newEntry]].lstrip().rstrip()==""):
                self.ZSQLQuery(query)

        if not noredirect:
            self.redirect(RESPONSE,self.REQUEST['HTTP_REFERER'])
            
    security.declareProtected('View management screens','editCV')    
    def editCV(self,cv=None,oid=None,RESPONSE=None):
         """edit Cv"""

         if (not oid):
             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editCV.zpt')).__of__(self)
             return pt()
        
         query="UPDATE personal_www SET cv =%s WHERE oid='%s'"
         self.ZCacheable_invalidate()
         self.ZSQLQuery(query%(self.ZSQLQuote(cv),oid))
        
         if RESPONSE:
            self.redirect(RESPONSE,"editCV")
            
    
    def getProfile(self):
        """get the profile"""
        self.REQUEST.RESPONSE.setHeader('Last-Modified',email.Utils.formatdate().split("-")[0]+'GMT')
      
        founds=self.ZSQLInlineSearchU(_table='personal_www',key=self.getKeyUTF8())
        html="""<html><body>%s</body></html>"""
        if founds.profile and founds.profile != "":
           
            return html%founds.profile
        else:
                        
            return html%self.generateProfileForPerson(founds)
            
    def editProfile(self,oid=None,RESPONSE=None, kupu=None, preview=None):
         """edit Profile, new entry replaces CD, current work and research interests"""
        
         if (not oid):
             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editProfile.zpt')).__of__(self)
             return pt()
        
         self.ZCacheable_invalidate() 
         
         
         if preview:
             pass
             #TODO: not supported yet
             #kupu=preview
             # find content of body tags
        
         start=kupu.find("<body>")
         end=kupu.find("</body>")
         
         newcontent= kupu[start+6:end]
            
            
         
        
         if preview: 
            #TODO: not supported yet
            if RESPONSE:
                self.redirect(RESPONSE,"editProfile")
            
            #return self.preview(newcontent)

         query="UPDATE personal_www SET profile=%s WHERE oid='%s'"       
         self.ZSQLQuery(query%(self.ZSQLQuote(newcontent),oid))
         logging.error("PROFILE:"+query%(self.ZSQLQuote(newcontent),oid))
         if RESPONSE:
            self.redirect(RESPONSE,"editProfile")



    def generateProfileForPerson(self,person):
        """erzeugt ein automatisches Profil aus den alten Eintraegen  CV, Current work, und research interests"""
        
        ret=""
        #founds=self.ZSQLInlineSearch(_table='research_interest',key_main=person.getKeyUTF8())
        founds=self.ZSQLInlineSearch(_table='research_interest',key_main=person.key)
        if founds:
            ret="<p class=\"bio_section_header\">Research interests: </p><br/>"
        for found in self.sortPriority(founds):
            ret+=found.interest+"<br/>"
        
        
        if (person.current_work) and (not person.current_work==""):
            ret+="<p class=\"bio_section_header\">Current work: </p><br/>"
      
            ret+=person.current_work+"<br/>"
    	if (person.cv) and (not person.cv==""):
            ret+="<p class=\"bio_section_header\">Curriculum Vitae: </p><br/>"
	    ret+=self.formatAscii(person.cv)
        
        return ret
    security.declareProtected('View management screens','editDownloads')
    def editDownloads(self):    
        """editiere die Downloads von der Webseite"""
        
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editDownloads.zpt')).__of__(self)
        return pt()
    
    security.declareProtected('View management screens','editAdditionalLinks.zpt')
    def editAdditionalLinks(self):    
        """editiere die Downloads von der Webseite"""
        
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editAdditionalLinks.zpt')).__of__(self)
        return pt()
    
    
    security.declareProtected('View management screens','editAwards')    
    def editAwards(self,awards=None,oid=None,RESPONSE=None):
         """edit a awards"""
     
         if (not oid):
             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editAwards.zpt')).__of__(self)
             return pt()
         self.ZCacheable_invalidate()
         query="UPDATE personal_www SET awards =%s WHERE oid='%s'"
      
         self.ZSQLQuery(query%(self.ZSQLQuote(awards),oid))
        
        
         if RESPONSE:
            self.redirect(RESPONSE,"editAwards")

    security.declareProtected('View management screens','editTalks')    
    def editTalks(self):
        """edit talks"""

        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editTalks.zpt')).__of__(self)
        return pt()
        
    security.declareProtected('View management screens','editTeaching')    
    def editTeaching(self):
        """edit Teaching"""

        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editTeaching.zpt')).__of__(self)
        return pt()
        
    def getDocTypes(self):
        finds = self.ZopeFind(self.metadata.main.meta.bib,obj_metatypes=["OSAS_MetadataMapping__neu"])

        list= [x[0] for x in finds]
        return "\n".join(list)

    security.declareProtected('View management screens','editMainData')    
    def editMainData(self,REQUEST=None,RESPONSE=None):
        """edit main data"""
        self.ZCacheable_invalidate()
        argv=REQUEST.form
        
        if not argv.has_key('last_name'):
            pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editMainData.zpt')).__of__(self)
            return pt() 
        else:
            self.ZSQLChange(argv,_table="personal_www",_identify="lower(key)=%s"%utf8ify(self.getKey().lower()),USE_FORM="yes")
            # aendere auch dien enstsprechen infos in der instance
            self.changeMPIWGStaff(argv['last_name'],argv['first_name']);
            
            
            
            self.reindex_object()
            
            
            
            if RESPONSE:
                self.redirect(RESPONSE,"editMainData")
                
    security.declareProtected('View management screens','newBibliogrpaphy')    
    def newBibliography(self,_docType=None, _addEntry=None,RESPONSE=None,**argv):
        
        """add an entry to the bibliography"""
        if not _docType: #kein docType
            pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','newBibliographyEntryDocType.zpt')).__of__(self)
            return pt() 
        elif _docType and not _addEntry: #doctype aber keine daten
            self.REQUEST['_docType']=_docType
            pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','newBibliographyEntry.zpt')).__of__(self)
            return pt() 
        else: #doctype und daten
            try:
                newId=self.ZSQLSimpleSearch("select nextval('id_raw')")[0].nextval
            except:#id_raw existiert nich, dann neu erzeugen
                
                self.createOrUpdateId_raw()
                newId=self.ZSQLSimpleSearch("select nextval('id_raw')")[0].nextval
                                
            bookId="b%06i" % newId
            
            self.ZSQLAdd(argv,_table="bibliography",reference_type=_docType,id=bookId)

            self.ZSQLAdd(_useRequest=False,_table="publications",id_gen_bib=bookId,key_main=self.getDBId(),publish='yes')
            self.updatePublicationDB(personId=self.getDBId())
            
        
        if RESPONSE:
            self.redirect(RESPONSE,"editPublications")
            
        return True
    
    security.declareProtected('View management screens','editImage')    
    def editImage(self):
        """edit images"""
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editImageStaff.zpt')).__of__(self)
        return pt()
    
    security.declareProtected('View management screens','editBibliography')    
    def editBibliography(self):
        """edit the bibliography"""
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editBibliographyEntry.zpt')).__of__(self)
        return pt()
    
      
    security.declareProtected('View management screens','editPublications')    
    def editPublications(self):
        """edit the bibliographie"""

        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editPublications.zpt')).__of__(self)
        return pt()
    
    def changeSortingMode(self,sortingMode,RESPONSE=None,REQUEST=None):
        """change sorting mode"""
        self.ZCacheable_invalidate()
        self.sortingMode=sortingMode
        
        if RESPONSE and REQUEST:
            self.redirect(RESPONSE,REQUEST['HTTP_REFERER'])

        return True

    def getSortingMode(self):
        """get sorting mode"""
        mode=getattr(self,'sortingMode','priority')
        if mode=="year":
            return "year DESC"
        else:
            return mode
        
    def integer(self,value):
        try:
            return int(value)
        except:
            return 0
        
    security.declareProtected('View management screens','changePublications')    
    def changePublications(self,RESPONSE=None):
        """change the publication list"""
        self.changeResearch(noredirect=True)
        self.ZCacheable_invalidate()
        #self.updatePublicationDB(personId=self.getDBId())
        self.redirect(RESPONSE,self.REQUEST['HTTP_REFERER'])
        

  
    security.declareProtected('View management screens','addPublications')    
    def addPublications(self,submit=None,REQUEST=None,noredirect=None,RESPONSE=None):
        """add publications"""

        #setzte flag ob aufruf aus suchformular
        
        if REQUEST.get("QUERY_STRING",None) and (not submit):
            self.REQUEST.set('fromSearch','1')
        else:
            self.REQUEST.set('fromSearch','0')
             
        if not submit or (not (submit == "add")):
            pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addPublications.zpt')).__of__(self)
            return pt()
        
        #new entries
        entries = REQUEST.form.get('addEntries',None)
        if not (type(entries) is ListType):
            entries=[entries]
        
        
        for bibId in entries: 
            query="INSERT INTO %s " % "publications"
            query+="(key_main,id_institutsbibliographie,publish) "
            query+="VALUES ('%s','%s','yes')" %(sql_quote(self.getKey()),sql_quote(bibId))
            
            #self.ZSQLAdd(_table="publications",id_institutsbibliographie=bibId,id_main=self.getDBId(),publish='yes')
            self.ZSQLQuery(query)
     
        self.updatePublicationDB(personId=self.getKey())
        
        if not noredirect:
            
            self.redirect(RESPONSE,"./editPublications")
            
            return True
        
    
    def getDBId(self):
        """get id from the personal database"""
        
        #in der neuen version ist definitions gemaess der key der Datenbank gleich dem key im Object.
        # TODO: remove all occurences of getDBId and replaces it by getKey
        return self.getKey()
        
    formatBiblHelp=bibliography.formatBiblHelp
    
    def sortBibliography(self,list,sortingMode=None,max=None):
        if not sortingMode:
            sortingMode=self.getSortingMode()
    
        if sortingMode == "year":
            l= self.sortYear(list)
        else:
            l=self.sortPriority(list)
        
        if max:
            return l[0:min(len(l),max)]
        else:
            return l
        
    def sortPriority(self,list):
        def sort(x,y):
            try:
                xInt=int(x.priority)
            except:
                xInt=0
            try:
                yInt=int(y.priority)
            except:
                yInt=0

            return cmp(xInt,yInt)

        if not list:
            return []
        tmp=[x for x in list]
        tmp.sort(sort)           
        
        return tmp

    def sortYear(self,list):
        #TODO: sort TO APPEAR and TO BE PUBLISHED etc...
        
        def sort(x,y):
            try:
                xInt=int(x.year)
            except:
                xInt=0
            try:
                yInt=int(y.year)
            except:
                yInt=0

            return cmp(yInt,xInt)
            
            
        tmp=[x for x in list]
        
        tmp.sort(sort)           
        return tmp
    
    def deleteField(self,table,oid,RESPONSE=None):
        """delete entry"""
        query="DELETE FROM %s WHERE oid = '%s'"%(table,oid)

        self.ZSQLQuery(query)
        self.redirect(RESPONSE,self.REQUEST['HTTP_REFERER'])
        
    
def manage_addMPIWGStaffForm(self):
    """form for adding the project"""
    pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMPIWGStaffForm.zpt')).__of__(self)
    return pt()

def manage_addMPIWGStaff(self,id,lastName,firstName,RESPONSE=None):
    """add it"""
    newObj=MPIWGStaff(id,lastName,firstName)

    self._setObject(id,newObj)

    if RESPONSE is not None:
        self.redirect(RESPONSE,'manage_main')


    
class MPIWGStaffFolder(ZDBInterfaceFolder):
    """Folder of staff objects"""

    meta_type="MPIWGStaffFolder"
    security=ClassSecurityInfo()

    #
    # templates
    #
    member_index_html = PageTemplateFile('zpt/staff/member_index_html', globals())


    #
    # hook into traversal to create folder of virtual staff objects
    # like /members/$username/index_html
    # 
    def __before_publishing_traverse__(self, object, request):
        stack = request.TraversalRequestNameStack
        logging.debug("MPIWGStaffFolder: traverse stack=%s self=%s"%(repr(stack),repr(self)))
        
        # TODO: should we do more checks?
        if stack and len(stack) > 0:
            try:
                # id is the first path component
                id = stack[-1]
                logging.debug(id)
               
                member = self.getMember(id)
                if member is not None:
                    member = member.__of__(self)
                    request.set('MPIWGStaffMember', member)
                    stack.pop(-1)

                    #weitere parameter
                    if len(stack)> 0:
                        mode = stack[-1]
                        request.set('MPIWGStaffMode', mode)
                        stack.pop(-1)
                   
                   
            except (IndexError, ValueError):
                # missing context or not an integer id; perhaps some URL hacking going on?
                logging.error("error traversing user id!")
                raise Redirect(self.absolute_url())  # redirects to `/members`, adjust as needed
            
        
                
    def index_html(self,REQUEST,RESPONSE):
        """show homepage"""
        logging.debug("MPIWGStaffFolder: index_html!")
        member = REQUEST.get('MPIWGStaffMember', None)
        mode = REQUEST.get('MPIWGStaffMode', None)
        if member is not None:
            
            if mode is not None:
                return member.execute(mode,REQUEST);
            
            
            logging.debug("member: key=%s"%(member.getKey()))
            pt = None
            try:
                # get template /template/member_index_html
                pt = getattr(self.template, 'member_index_html', None)
            except:
                logging.error("No template /template/member_index_html")
                # TODO: error page?
                return "No template /template/member_index_html"

            if pt is not None:
                return pt(member=member)

        return REQUEST
    
    
    def getMember(self, username=None, key=None):
        """returns a MPIWGStaffMember object if the username exists"""
        member = None
        if username is not None:
            # TODO: we should have a username column
            email = '%s@mpiwg-berlin.mpg.de'%username
            content = self.executeZSQL("select * from personal_www where e_mail = %s", [email])
            if len(content) > 0:
                member = MPIWGStaffMember(self, dbresult=content)
        
        elif key is not None:
            content = folder.executeZSQL("select * from personal_www where key = %s", [key])
            if len(content) > 0:
                member = MPIWGStaffMember(self, dbresult=content)             
         
        return member
    

    def sortPriority(self,list):
        def sort(x,y):
            try:
                xInt=int(x.priority)
            except:
                xInt=0
            try:
                yInt=int(y.priority)
            except:
                yInt=0

            return cmp(xInt,yInt)

        if not list:
            return []
        tmp=[x for x in list]
        tmp.sort(sort)           
        
        return tmp
    
    def getPublications(self,memberID="renn"):
        
        try:
            pubs=self.mpiwgPubman.getPublications(memberID)
            return pubs
        except:
            return []
def manage_addMPIWGStaffFolderForm(self):
    """form for adding the project"""
    pt=PageTemplateFile('zpt/addMPIWGStaffFolderForm', globals()).__of__(self)
    return pt()

def manage_addMPIWGStaffFolder(self,id,title,RESPONSE=None):
    """add it"""
    newObj=MPIWGStaffFolder(id,title)

    self._setObject(id,newObj)

    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')


class MPIWGStaffMember(Folder):
    """MPIWG staff member object from database"""
    
    security = ClassSecurityInfo()

    def __init__(self, folder, dbresult):
        """constructor: takes parent MPIWGStaffFolder and content"""
        self.folder = folder
        self.content = dbresult[0]
            
    def isValid(self):
        """returns if this member exists"""
        return len(self.content) > 0

    def getKey(self):
        """returns the db key"""
        return self.content.key

    def getUsername(self):
        """returns the username"""
        id = re.sub('@mpiwg-berlin\.mpg\.de', '', self.content.e_mail)
        return id
    
    def getPublishedImageUrl(self):
        """returns the URL to the image if it is published"""
        if self.content.image_p == 'yes':
            url = 'http://digilib.mpiwg-berlin.mpg.de/digitallibrary/Scaler?fn=permanent/mpiwg/staff/%s'%self.getUsername()
            return url
        
        return None
    
    def getContent(self):
        """returns the db content of this object"""
        return self.content
    
    
    # TODO: ugly!
    security.declarePublic('sortBibliography')    
    def sortBibliography(self,bib,sortingMode=None,max=None):
        """sort bibliography"""
        if not sortingMode:
            sortingMode= "priority"
    
        l = [x for x in bib]
        
        if sortingMode == "year":
            l.sort(key=lambda x: getInt(x.year))
        else:
            l.sort(key=lambda x: getInt(x.priority))
        
        if max:
            return l[0:min(len(l),max)]
        else:
            return l

    
    
    def execute(self,mode,REQUEST=None):
        method = getattr(self,mode,None)
        if method is not None:
            return method(REQUEST);
        else:
            return "NOT FOUND"
        
    
    def getProfile(self,REQUEST):
        """get the profile"""
        self.REQUEST.RESPONSE.setHeader('Last-Modified',email.Utils.formatdate().split("-")[0]+'GMT')
      
        
        html="""<html><body>%s</body></html>"""
        if self.content.profile and self.content.profile != "":
           
            return html%self.content.profile
        else:
                        
            return html%""
            
    
    def getTalks(self):
        
        return self.folder.executeZSQL("SELECT oid,* FROM talks  WHERE  key_main = %s",[self.content.key]) 
        #return self.folder.ZSQLInlineSearch(_table='talks',key_main=self.content.key)
    
    
    def getTeaching(self):
        
        return self.folder.executeZSQL("SELECT oid,* FROM teaching  WHERE  key_main = %s",[self.content.key]) 
    
    
    
    def getLastUpdateCV(self):
        """getDate of Last Update"""
        try:
                fname="%s_cv.pdf"%self.getUsername().encode('utf-8')
                logging.debug(fname)
                ob=self.folder._getOb("downloadableFiles")._getOb(fname)
                return ob.bobobase_modification_time()
        except:
                return "No file yet!"
            
    def getLastUpdatePublications(self):
        """getDate of Last Update"""
        try:
                ob=self.folder._getOb("downloadableFiles")._getOb("%s_publications.pdf"%self.getUsername().encode('utf-8'))
                return ob.bobobase_modification_time()
        except:
                return "No file yet!"
    
    
    def downloadCV(self,REQUEST):
      
        fname="%s_cv.pdf"%self.getUsername().encode('utf-8')
        logging.debug(fname)
        ob=self.folder._getOb("downloadableFiles")._getOb(fname)
        REQUEST.RESPONSE.redirect(ob.absolute_url())

    def downloadPublications(self,REQUEST):
        ob=self.folder._getOb("downloadableFiles")._getOb("%s_publications.pdf"%self.getUsername().encode('utf-8'))
        REQUEST.RESPONSE.redirect(ob.absolute_url())

    def getAdditionalLinks(self):
        
        return self.folder.executeZSQL("SELECT oid,* FROM additionalLink  WHERE  key_main = %s",[self.content.key]) 
        #return self.folder.ZSQLInlineSearch(_table='talks',key_main=self.content.key)
  
        #return self.folder.ZSQLInlineSearch(_table='talks',key_main=self.content.key)
    
    def getPathStyle(self, path, selected, style=""):
        """returns a string with the given style + 'sel' if path == selected."""

        if path == selected:
            return style + 'sel'
        else:
            return style    


    
    mainEditFile=PageTemplateFile(os.path.join(package_home(globals()),'zpt/staff','edit_main.zpt'))
    
    
    security.declareProtected('View management screens','edit')    
    def edit(self,REQUEST=None):
        """Edit the  basic information"""
      

        
        if REQUEST:
            argv=REQUEST.form
            
            if argv.has_key('last_name'): #got data to change
                self.invalidate_chache()
                self.changeData(argv);
                       
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt/staff','edit_basic.zpt')).__of__(self)
        return pt()
        
   
    security.declareProtected('View management screens','edit')    
    def editShortEntry(self,REQUEST=None):
        """Edit the  basic information"""
      

        
        if REQUEST:
            argv=REQUEST.form
            
            if argv.has_key('current_work'): #got data to change
                self.invalidate_chache()
                self.changeData(argv);
                       
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt/staff','edit_shortEntry.zpt')).__of__(self)
        return pt()
  
   
    security.declareProtected('View management screens','editProfile')        
    def editProfile(self, REQUEST=None):
         """edit Profile, new entry replaces CD, current work and research interests"""
        
         
         if REQUEST:
             kupu=REQUEST.form.get('kupu',None);
             preview=REQUEST.form.get('preview',None);
       
         
         if kupu:
             start=kupu.find("<body>")
             end=kupu.find("</body>")
         
             newcontent= kupu[start+6:end]
             query="UPDATE personal_www SET profile=%s WHERE key='%s'"       
             self.executeZSQL(query%(self.ZSQLQuote(newcontent),self.content.key))
             logging.error("PROFILE:"+query%(self.ZSQLQuote(newcontent),self.content.key))
        
         if preview: 
             pass
                #TODO: not supported yet
                #if RESPONSE:
                #    self.redirect(RESPONSE,"editProfile")
                
                #return self.preview(newcontent)
          
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt/staff','edit_profile.zpt')).__of__(self)
         return pt()
        
    

    security.declareProtected('View management screens','editTalks')    
    def editTalks(self,REQUEST):
        """edit talks"""


        if REQUEST:
            argv=REQUEST.form
            
            if argv.has_key('main_fields'): #got data to change
                self.invalidate_chache()
                self.changeAdditionalData(argv);
                       
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt/staff','edit_talks.zpt')).__of__(self)
        return pt()
     
   
    security.declareProtected('View management screens','editTeaching')    
    def editTeaching(self,REQUEST):
        """edit teaching"""


        if REQUEST:
            argv=REQUEST.form
            
            if argv.has_key('main_fields'): #got data to change
                self.invalidate_chache()
                self.changeAdditionalData(argv);
                       
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt/staff','edit_teaching.zpt')).__of__(self)
        return pt()
     
   
    security.declareProtected('View management screens','editAdditionalLinks.zpt')
    def editAdditionalLinks(self,REQUEST):    
        """editiere die additiona link von der Webseite"""
        
        if REQUEST:
            argv=REQUEST.form
            
            if argv.has_key('main_fields'): #got data to change
                self.invalidate_chache()
                self.changeAdditionalData(argv);
                       
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt/staff','edit_additionalLinks.zpt')).__of__(self)
        return pt()
    
    
        security.declareProtected('View management screens','editDownloads')
    def editDownloads(self,REQUEST):    
        """editiere die Downloads von der Webseite"""
        
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt/staff','edit_downloads.zpt')).__of__(self)
        return pt()
   
    def changeDownloads(self,REQUEST):
        """"change the downloadable files"""
        self.invalidate_chache();
        
        data=REQUEST.form
       
        ob = self.folder._getOb("downloadableFiles")
        
        if data.get('cv_publish',None):
           
            self.changeData({'cv_p':data['cv_publish']})
       
        if data.get('publications_publish',None):
            self.changeData({'publications_p':data['publications_publish']})
        
            
        if data.get('cv_pdf',None):
            cvName ="%s_cv.pdf"%self.getUsername()
            cvName=cvName.encode('utf-8')
            logging.debug("CCC")
            if not hasattr(ob,cvName):
                
                cvFile = ExtFile(cvName,cvName)
                ob._setObject(cvName,cvFile)
            
          
            cvFile = getattr(ob,cvName)
                
            cvFile.manage_upload(file=data['cv_pdf'])
            
           
            
        
        if data.get('publications_pdf',None):
            
            
            pdfName="%s_publications.pdf"%self.getUsername()
            pdfName=pdfName.encode('utf-8')
            
            if not hasattr(ob,pdfName):
                
                cvFile = ExtFile(pdfName,pdfName)
                ob._setObject(pdfName,cvFile)
            
         
            cvFile = getattr(ob,pdfName)
                
            cvFile.manage_upload(file=data['publications_pdf'])
            
      
        #REQUEST.response.redirect(self.REQUEST['HTTP_REFERER'])
 
   
    

    def changeData(self,changeSet):
        """changes the data in the database, changeset expects field --> value."""
        for field in changeSet.keys():
            if hasattr(self.content,field):
                logging.debug("Changing: %s"%field)
                
                
                results = self.folder.executeZSQL("update personal_www set "+field+" = %s where key = %s ", [changeSet.get(field),self.getKey().encode('utf-8')]);
        
                logging.debug(results)
   
   
    security.declareProtected('View management screens','changeAdditionalData')
    def changeAdditionalData(self,data):
        """change the research entries"""
        
        self.invalidate_chache();
        
        newEntries={}
        

        mainfieldL=data['main_fields'].split(",") #fields to be changed
        # format DATABASE__FIELDNAME
        
        mainfield={}
        for x in mainfieldL:
            tmp=x.split('__')
            mainfield[tmp[0]]=tmp[1]
        for field in data:
            splittedField=field.split("__")
            if len(splittedField)<3:
                pass #kein datenbank eintrag

            elif splittedField[2]=='new': # store new entries
                if not newEntries.has_key(splittedField[0]):
                    newEntries[splittedField[0]]={}
                    
                newEntries[splittedField[0]][splittedField[1]]=data[field]

            else:
                query="UPDATE %s "%splittedField[0]
                query+="SET %s = '%s' "%(splittedField[1],sql_quote(data[field]))
                query+="WHERE oid = '%s' "%sql_quote(splittedField[2])
                
                self.executeZSQL(query)


        #new entries
        for newEntry in newEntries.keys():
            query="INSERT INTO %s "%newEntry
            keys=['key_main']
            values=["'"+sql_quote(self.getKey())+"'"]
            for key in newEntries[newEntry].keys():
                keys.append(key)
                values.append("'"+sql_quote(newEntries[newEntry][key])+"'")


            keystring=",".join(keys)
                
            valuestring=",".join(values)
                
            query+=" (%s) "%keystring
            query+="VALUES (%s)"%valuestring
            if not (newEntries[newEntry][mainfield[newEntry]].lstrip().rstrip()==""):
                self.executeZSQL(query)

            

    
   
    def deleteField(self,REQUEST):
        """delete entry"""
        
        
        table = REQUEST.form.get('table',None);
        oid = REQUEST.form.get('oid',None);
        
        if table is None or oid is None:
            return
        
        query="DELETE FROM %s WHERE oid = '%s'"%(table,oid)

        self.executeZSQL(query)
        REQUEST.response.redirect(self.REQUEST['HTTP_REFERER'])
 
   
    def invalidate_chache(self):
        #TODO: How to invalidate the varnish cache from the member object
        pass;
        
        
    def getStaffURL(self):
        ident = self.content.e_mail;
        splitted = ident.split("@");
        return splitted[0]
        
    def getPublications(self):
        
        pubs= self.folder.getPublications("")
       
        return pubs
        
        
InitializeClass(MPIWGStaffMember)