from OFS.Folder import Folder
from Globals import Persistent
from Acquisition import Implicit
from Globals import DTMLFile
import urllib
import re
import string
from pyPgSQL import libpq
from AccessControl import getSecurityManager
import os.path
from Products.PageTemplates.PageTemplateFile import PageTemplateFile



class ZSQLExtendFolder(Persistent, Implicit, Folder):
    """Folder"""
    meta_type="ZSQLExtendFolder"

    def content_html(self):
        """template fuer content"""
        
        try:
            obj=getattr(self,"ZSQLBibliography_template")
            return obj()
        except:
            pt=PageTemplateFile('Products/ZSQLExtend/zpt/ZSQLBibliography_template_standard.zpt',content_type='text/htm').__of__(self)
            pt.content_type="text/html"
            
            return pt()

        
    def getWeight(self):
        """getLabe"""
        try:
            return self.weight
        except:
            return ""

    def getLabel(self):
        """getLabe"""
        try:
            return self.label
        except:
            return ""

    def getDescription(self):
        """getLabe"""
        try:
            return self.description
        except:
            return ""

    manage_options=Folder.manage_options+(
        {'label':'Main Config','action':'changeZSQLExtendForm'},
       )

    def changeZSQLExtendForm(self):
        """change folder config"""
        pt=PageTemplateFile('Products/ZSQLExtend/zpt/changeZSQLExtendForm.zpt').__of__(self)
        return pt()


    def changeZSQLExtend(self,label,description,weight=0,REQUEST=None):
        """change it"""

        self.weight=weight
        self.label=label
        self.description=description
        
        if REQUEST is not None:
            return self.manage_main(self, REQUEST)

    def formatAscii(self,str,url=None):
        """ersetze ascii umbrueche durch <br>"""
        #url=None
        if url and str:
            
            retStr=""
            words=str.split("\n")
            
            for word in words:
                strUrl=url%word
                #print "str",strUrl
                retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)
            str=retStr
        if str:
            return re.sub(r"[\n]","<br/>",str)
        else:
            return ""
        
    def getSAttribute(self,obj,atribute,pref=''):
        """get Attribute or emptystring"""
        
        #print "obj",obj
        try:
            return pref+getattr(obj,atribute)
        except:
            return ""
        
    def getS(self,str):
        """make none to empty string"""
        if str:
            return str
        else:
            return ""

    def actualPath(self,url=None):
	"""path"""

        if self.REQUEST['HTTP_X_FORWARDED_SERVER']=='':
            host=self.REQUEST['HTTP_HOST']
        else:
            host=self.REQUEST['HTTP_X_FORWARDED_SERVER']
	if not url:
		return "http://"+host+self.REQUEST['PATH_TRANSLATED']
    	else:
		temp=self.REQUEST[url].split("/")
		temp[2]=host
		return string.join(temp,"/")

    def getRequest(self):
	"""request"""
	return self.REQUEST

    def lowerEnd(self,path):
        """oinly for demo"""
        return os.path.splitext(path)[0]+".jpg"
        
    def ZSQLisEmpty(self,field):
        """Teste ob Treffer leer"""
        #print "field",field
        if not field:
            return 1
        if field=="":
            return 1
        return 0

    def ZSQLsearchOptions(self,fieldname=""):
        """return HTML Fragment with search options"""
	
        ret="""<select name="-op_%s">
	<option value="bw">begins with</option>          	<!-- begins with / beginnt mit, "Wort*" -->
	<option value="ew">ends with</option>
   	<option value="ct" selected>contains</option>          		<!-- contains / enthaellt, "Wort" -->
    <option value="eq">equals</option>          		<!-- equals / ist, =Wort -->
</select>"""%fieldname
        return ret

    def ZSQLSelectionFromCRList(self,fieldname,listField,boxType="checkbox",checked=None):
        """generate select oprions form a cr seperated list"""
        fields=listField.split("\n")
        ret=""
        for field in fields:
            if checked and (field in checked.split("\n")):
                ret+="""<input name="%s" type="%s" value="%s" checked>%s"""%(fieldname,boxType,field.encode('utf-8'),field.encode('utf-8'))
            else:
                ret+="""<input name="%s" type="%s" value="%s">%s"""%(fieldname,boxType,field.encode('utf-8'),field.encode('utf-8'))
        return ret


    def ZSQLOptionsFromCRList(self,fieldname,listField):
        """generate select oprions form a cr seperated list"""
        fields=listField.split("\n")
        ret="""<select name="%s">
            """%fieldname
        for field in fields:
            ret+="""<option value="%s">%s</option>"""%(field.encode('utf-8'),field.encode('utf-8'))
        ret+="""</select>"""
        return ret

    def ZSQLOptionsFromSearchList(self,fieldname,results,fieldName,valueName=None,start=None):
        """generate select oprions form a cr seperated list"""
        if not valueName:
            valueName=fieldName
            
        ret="""<select name="%s">
            """%fieldname
        if start:
	    if start==' ':
		start=''
            ret+="""<option value="%s">%s</option>"""%(start,start)
        for result in results:
            field=getattr(result,fieldName)
            fieldValue=getattr(result,valueName)
            ret+="""<option value="%s">%s</option>"""%(field,fieldValue)
        ret+="""</select>"""
        return ret

            
    
    def ZSQLInlineSearch(self,storename=None,**argv):
        """inlinesearch"""
        qs=[]
        if storename:
            """store"""
        else:
            storename="foundCount"
            
    

        #print "INLINE:",argv
        for a in argv.keys():
            qs.append(a+"="+urllib.quote(str(argv[a])))
        #return []  
        return self.parseQueryString(string.join(qs,","),"_",storename=storename)

    def ZSQLInlineSearch2(self,query):
        """inlinesearch"""
        qs=[]
        
    

        #print "INLINE:",query
        
        return self.search(var=query)
    
    def ZSQLAdd(self):
        """Neuer Eintrag"""
        qs=self.REQUEST['QUERY_STRING']
        addList={}
        for q in qs.split("&"):
            name=re.sub("r'+'"," ",q.split("=")[0].lower())
            value=q.split("=")[1]
	    value=re.sub(r'\+'," ",value)
	    value=urllib.unquote(value)	
            if name=="-table":
                table=urllib.unquote(value)
            elif name=="-format":
                format=urllib.unquote(value)
            elif (not name[0]=="-") and (not len(value)==0):
                addList[urllib.unquote(name)]=urllib.unquote(value)

        keyList=[]
        valueList=[]
        for x in addList.keys():
            keyList.append("\""+x+"\"")
            valueList.append(libpq.PgQuoteString(addList[x]))

        keyString=string.join(keyList,",")
        valueString=string.join(valueList,",")
        
        queryString="INSERT INTO %s (%s) VALUES (%s)"%(table,keyString,valueString)
        self.search(var=queryString)
        return self.REQUEST.RESPONSE.redirect(format)
        
    def ZSQLChange(self,**argv):
        """Ändern von Einträgen"""
        #qs=self.REQUEST['QUERY_STRING']
        # very bad hack
        qs_temp=[]
    
        for a in self.REQUEST.form.keys():
            qs_temp.append(a+"="+urllib.quote(str(self.REQUEST.form[a])))

        qs=string.join(qs_temp,"&")

    
        #print "CHANGE QS",self.REQUEST
        #return self.REQUEST
        changeList=[]
        for q in qs.split("&"):
            name=urllib.unquote(re.sub("r'+'"," ",q.split("=")[0].lower()))
            value=q.split("=")[1]
            value=re.sub(r'\+'," ",value)
	    value=urllib.unquote(value)
	    if name=="-table":
                table=urllib.unquote(value)
            elif name=="-identify":
                identify=urllib.unquote(value)
                identify=identify.split("=")[0]+"="+libpq.PgQuoteString(identify.split("=")[1])
            elif name=="-format":
                format=urllib.unquote(value)
            elif (not name[0]=="-") and (not len(value)==0):
                changeList.append("\""+name+"\"="+libpq.PgQuoteString(urllib.unquote(value)))
        changeString=string.join(changeList,",")
        queryString="UPDATE %s SET %s WHERE %s"%(table,changeString,identify)
        self.search(var=queryString)
        return self.REQUEST.RESPONSE.redirect(format)

    def ZSQLChange_old(self):
        """Ändern von Einträgen"""
        qs=self.REQUEST['QUERY_STRING']
        #print "CHANGE QS",self.REQUEST
        #return self.REQUEST
        changeList=[]
        for q in qs.split("&"):
            name=urllib.unquote(re.sub("r'+'"," ",q.split("=")[0].lower()))
            value=q.split("=")[1]
            value=re.sub(r'\+'," ",value)
	    value=urllib.unquote(value)
	    if name=="-table":
                table=urllib.unquote(value)
            elif name=="-identify":
                identify=urllib.unquote(value)
                identify=identify.split("=")[0]+"="+libpq.PgQuoteString(identify.split("=")[1])
            elif name=="-format":
                format=urllib.unquote(value)
            elif (not name[0]=="-") and (not len(value)==0):
                changeList.append("\""+name+"\"="+libpq.PgQuoteString(urllib.unquote(value)))
        changeString=string.join(changeList,",")
        queryString="UPDATE %s SET %s WHERE %s"%(table,changeString,identify)
        self.search(var=queryString)
        return self.REQUEST.RESPONSE.redirect(format)
    
    def ZSQLFind(self,qs="",select="oid,*",storename=None,**argv):
        """Find"""

        def delEmpty(list):
            ret=[]
            for x in list:
                splitted=x.split("=")
                if (len(splitted)>1) and not (splitted[1]==' '):
                    ret.append(x)
            return ret
            
        if qs=="":
           if self.REQUEST['QUERY_STRING']:
               qs=self.REQUEST['QUERY_STRING']
               
               
               qs=string.join(qs.split("&"),",")
               
               for field in argv.keys():
                   
                   qs+=",-%s=%s"%(field,argv[field])
               #print qs
           else:
               
               qs=self.REQUEST.SESSION['query']
               for field in argv.keys():
                   #print field
                   qs+=",-%s=%s"%(field,argv[field])
               
        else:
            self.REQUEST['QUERY_STRING']=qs

            qs=string.join(qs.split("&"),",")
            
        
        
        qs=re.sub("\\+"," ",qs)# Austauschen da Leerzeichen bei http-get durch + ersetzt wird, generell sollte alles auf post umgeschrieben werden. vom search formular.

        qs=string.join(delEmpty(qs.split(",")),",")

        if storename:
            """store"""
        else:
            storename="foundCount"


        
        ret=self.parseQueryString(qs,"-",select=select,storemax="yes",storename=storename)
        #print self.REQUEST.SESSION["foundCount"]
        
        
        return ret

    def ZSQLFoundCountLen(self,var):
        return len(var)
            
    def ZSQLFoundCount(self,qs="",select="*",storename=None):
        
       ##  if qs=="":
            
##             if self.REQUEST['QUERY_STRING']:
            
##                 qs=self.REQUEST['QUERY_STRING']
##                 qs=string.join(qs.split("&"),",")
##             else:
            
##                 qs=self.REQUEST.SESSION['query']
##         else:
##             qs=string.join(qs.split("&"),",")


##         temp= self.parseQueryString(qs,"-",select=select,storemax="yes",nostore="yes")
        if storename:
            """store"""
        else:
            storename="foundCount"
        
        return self.REQUEST.SESSION[storename]['count']

    def ZSQLRangeStart(self,storename=None):
        
        if storename:
            """store"""
        else:
            storename="foundCount"
        
        return int(self.REQUEST.SESSION[storename]['rangeStart'])+1
    
    def ZSQLRangeSize(self,storename=None):
        
        if storename:
            """store"""
        else:
            storename="foundCount"
            
        return self.REQUEST.SESSION[storename]['rangeSize']

    def ZSQLRangeEnd(self,storename=None):
        
        if storename:
            """store"""
        else:
            storename="foundCount"
        
        return str(min(int(self.REQUEST.SESSION[storename]['rangeEnd']),int(self.REQUEST.SESSION[storename]['count'])))
    
    def parseQueryString(self,qs,iCT,storemax="no",select=None,nostore=None,storename=None):
        """analysieren den QueryString"""
        #print "NO",nostore
        lop="AND" # standardsuche mit and
        max="ALL" #standard alle auswählen
        maxstr=""
        whereList=[]
        sort=""
        op="bw"
        opfields={}
        skip=""
        rangeStart=0
        limit=0
        searchFields={}
        
        if not select:
            select="oid,*"
        #print "Q",nostore,qs
        #check for op in the case of inline search
        
	splitted=qs.split(",")
	
            
        for q in splitted:
                
                name=re.sub("r'+'"," ",q.split("=")[0].lower())
                try:
                    value=urllib.unquote(q.split("=",1)[1])
                except:
                    value=""
                #print "Hi",name[0:3],q
                if name[0:3]==iCT+"op":
                    op=value

                    field=name[4:]
                    opfields[field]=op
                    #print "HI",op,field
	#print opfieldsa
        #now analyse the querystring
        for q in qs.split(","):
            
            
            #try:

            name=re.sub("r'+'"," ",q.split("=")[0].lower())
            try:
                value=urllib.unquote(q.split("=",1)[1])
            except:
                value=""
                
            #value=libpq.PgQuoteString(value)
            
            
            if name==iCT+"lop":
                lop=value
            elif name==iCT+"table":
                table=value
            elif name==iCT+"select":
                select=value
            elif name==iCT+"max":
                maxstr="LIMIT "+str(value)
                limit=str(value)
            elif name==iCT+"skip":
                skip="OFFSET "+str(value)
                rangeStart=str(value)
            elif name==iCT+"join":
                whereList.append(value)
            elif name==iCT+"sort":
                sort="ORDER BY "+value
            elif name==iCT+"token":
                if not nostore=="yes":
                    self.REQUEST.SESSION['token']=value

            elif name==iCT+"op":
                op=value



            elif (not name[0]==iCT) and (not len(value)==0):
                
		#print "OP",op,name
                value=value.lower()

                searchFields[name]=value
                
                if opfields.has_key(name):
                    op=opfields[name]
		else:
		    op="ct"
		name="LOWER("+name+")"    
                if op=="ct":
                    whereList.append(name+" LIKE "+libpq.PgQuoteString("%"+value+"%"))
                elif op=="gt":
                    whereList.append(name+">"+libpq.PgQuoteString(value))
                elif op=="lt":
                    whereList.append(name+"<"+libpq.PgQuoteString(value))
                elif op=="eq":
                    whereList.append(name+"="+libpq.PgQuoteString(value))
                elif op=="bw":
                    whereList.append(name+" LIKE "+libpq.PgQuoteString(value+"%"))
                elif op=="ew":
                    whereList.append(name+" LIKE "+libpq.PgQuoteString("%"+value))
                op="ct"
            
            #except:
            #    print "END",value,name,Exception       
        if len(whereList)>0:
            where="WHERE "+string.join(whereList," "+lop+" ")
        else:
            where=""
        #print "QE",table
        
        query="SELECT %s FROM %s %s %s %s %s"%(select,table,where,sort,maxstr,skip)
        
        if not nostore=="yes":
            
            self.REQUEST.SESSION['qs']=opfields
        #print "IAMHERE again:", query

        if storename:
            query2="SELECT count(*) FROM %s %s"%(table,where)
            #print "storing",query2
            #print "QUERYSTRING:",self.REQUEST.SESSION[storename]['queryString2']
            if not self.REQUEST.SESSION.has_key(storename):
                self.REQUEST.SESSION[storename]={}
            if self.REQUEST.SESSION[storename].has_key('queryString2'):
                #print "HI",storename
                if not self.REQUEST.SESSION[storename]['queryString2']==query2:
                    #print "HOOOOO",storename
                    self.REQUEST.SESSION[storename]['queryString2']=query2
                    self.REQUEST.SESSION[storename]['count']=self.search(var=query2)[0].count
                    #print "QUERY",query2,"::::",self.REQUEST.SESSION[storename]['queryString2']
                
            else:
                self.REQUEST.SESSION[storename]['queryString2']=query2
                self.REQUEST.SESSION[storename]['count']=self.search(var=query2)[0].count
                #print "QUERYNEW",self.REQUEST.SESSION[storename]['queryString2']
            
            
            self.REQUEST.SESSION[storename]['rangeStart']=rangeStart
            if limit=="all":
                self.REQUEST.SESSION[storename]['rangeEnd']=self.REQUEST.SESSION[storename]['count']
            else:
                self.REQUEST.SESSION[storename]['rangeEnd']=int(rangeStart)+int(limit)
            self.REQUEST.SESSION[storename]['rangeSize']=limit
            self.REQUEST.SESSION[storename]['searchFields']=searchFields
            
        #print "Q",query            
        return self.ZSQLQuery(query)

    def ZSQLQuery(self,query):
        """query"""
        return self.search(var=query)
    
    def ZSQLSearch(self):
        """To be done"""
        rq=self.REQUEST['QUERY_STRING']
        querys=rq.split("&")
        

        for querytemp in querys:
            query=querytemp.split("=")
            try:
                if query[0].lower()=="-format":
                    formatfile=query[1]
            except:
                """nothing"""
        #print formatfile        
        self.REQUEST.SESSION['query']=string.join(self.REQUEST['QUERY_STRING'].split("&"),",")
        return self.REQUEST.RESPONSE.redirect(urllib.unquote(formatfile))

    
    def ZSQLint(self,string):
        try:

            return(int(string))
        except:
            return 0

    def getZSQLSearchFieldsList(self,storename="foundCount"):
        """get searchfieldList"""
        #print self.REQUEST.SESSION[storename]['searchFields'].keys()
        return  self.REQUEST.SESSION[storename]['searchFields'].keys()

    def getZSQLSearchFields(self,storename="foundCount"):
        """get searchfield"""
        #print "SF",self.REQUEST.SESSION[storename]['searchFields']
        return  self.REQUEST.SESSION[storename]['searchFields']

                                                
    def nextLink(self,html,storename="foundCount"):
        """nextLink"""
        try:
            limit=self.REQUEST.SESSION[storename]['rangeSize']
            if int(limit)==0 :
                limit="1"
            newRangeStart=int(self.REQUEST.SESSION[storename]['rangeStart'])+int(limit)
        except:
            limit=0
            newRangeStart=0
            
        if newRangeStart>self.REQUEST.SESSION[storename]['count']:
            #newRangeStart=self.REQUEST.SESSION[storename]['count']-1
            return ""
        
        #create new query string
        
        if self.REQUEST['QUERY_STRING']=="":
            qs=self.REQUEST.SESSION['query']
            
            queries=string.split(qs,",")
            
            
        else:
            qs=self.REQUEST['QUERY_STRING']
            queries=string.split(qs,"&")
            
            
            
        newquery=[]

        skipFound=0
        
        for query in queries:
            
            #print query.split("=")[0]
            if query[0]=="_" : query[0]="-"

            if query.split("=")[0].lower()=="-skip":
                print "d", newRangeStart
                skipFound=1
                query="-skip=%i"%newRangeStart
            newquery.append(query)

        if skipFound==0 :
            query="-skip=%i"%newRangeStart
            newquery.append(query)
                
        newquerystring=string.join(newquery,"&")
	
        return "<a href='%s'>%s</a>"%(self.actualPath()+"?"+newquerystring,html)
            
        
    def prevLink(self,html,storename="foundCount"):
        """prev link"""
        try:
            limit=self.REQUEST.SESSION[storename]['rangeSize']
            if int(limit)==0 :
                limit="1"
            newRangeStart=int(self.REQUEST.SESSION[storename]['rangeStart'])-int(limit)
        except:
            limit=1
            newRangeStart=0
        if newRangeStart <0:
            return ""

        #print "limit",limit,newRangeStart,int(self.REQUEST.SESSION[storename]['rangeStart'])
        
        if newRangeStart<0:
                newRangeStart=0

        #create new query string
        
        if self.REQUEST['QUERY_STRING']=="":
            qs=self.REQUEST.SESSION['query']
            #qs=re.sub(r'_','-',qs) #aendern für query
            queries=string.split(qs,",")
            
            
        else:
            qs=self.REQUEST['QUERY_STRING']
            queries=string.split(qs,"&")
            
            
            
        newquery=[]
        
        skipFound=0

        for query in queries:
            #print query.split("=")[0]

            if query[0]=="_" : query[0]="-"
            
            if query.split("=")[0].lower()=="-skip":
                #print"HI"
                query="-skip=%i"%newRangeStart
                skipFound=1
            newquery.append(query)

        if skipFound==0 :
            query="-skip=%i"%newRangeStart
            newquery.append(query)
            
        newquerystring=string.join(newquery,"&")

        return "<a href='%s'>%s</a>"%(self.actualPath()+"?"+newquerystring,html)


    
    def prevLink_old(self,html):
        """prev link"""
        if self.REQUEST['QUERY_STRING']=="":
            qs=self.REQUEST.SESSION['query']
        else:
            qs=self.REQUEST['QUERY_STRING']
        max=re.search(r'max\=(.*)\,',qs.lower())
        offset=re.search(r'offset\=(.*)\,',qs.lower())
        if not offset:
            offsetnew=0
        else:
            offsetnew=int(offset)-max
            if offsetnew<0:
                offsetnew=0
        queries=string.split(qs,",")
        newquery=[]
        if offset:
            for query in queries:
                if query.split("=")[0].lower()=="offset":
                    query="-offset=%i"%offsetnew
                newquery.append(query)
                newquerystring=string.join(newquery,"&")
        else:
            queries.append("-offset=%i"%offsetnew)
            newquerystring=string.join(queries,"&")
        return "<a href='%s'>%s</a>"%(self.actualPath()+"?"+newquerystring,html)
        
    def nextLink_old(self,html):
        """prev link"""
        if self.REQUEST['QUERY_STRING']=="":
            qs=self.REQUEST.SESSION['query']
        else:
            qs=self.REQUEST['QUERY_STRING']
        max=re.search(r'max\=(.*)\,',qs.lower())
    
        offset=re.search(r'offset\=(.*)\,',qs.lower())
        if not offset:
            offsetnew=1
        else:
            offsetnew=int(offset)+int(max)
            if offsetnew<0:
                offsetnew=0
        queries=string.split(qs,",")
        newquery=[]
        if offset:
            for query in queries:

                if query.split("=")[0].lower()=="-offset":
                    query="-offset=%i"%offsetnew
                newquery.append(query)
                newquerystring=string.join(newquery,"&")
        else:
            queries.append("-offset=%i"%offsetnew)
            newquerystring=string.join(queries,"&")
        
        return "<a href='%s'>%s</a>"%(self.actualPath()+"?"+newquerystring,html)
        
    
manage_addZSQLExtendFolderForm=DTMLFile('ZSQLExtendFolderAdd', globals())

def manage_addZSQLExtendFolder(self, id, title='', label='', description='',
                     createPublic=0,
                     createUserF=0,
                     REQUEST=None):
    """Add a new Folder object with id *id*.

    If the 'createPublic' and 'createUserF' parameters are set to any true
    value, an 'index_html' and a 'UserFolder' objects are created respectively
    in the new folder.
    """
    
    
    ob=ZSQLExtendFolder()
    ob.id=str(id)
    ob.title=title
    self._setObject(id, ob)
    ob=self._getOb(id)
    setattr(ob,'label',label)
    setattr(ob,'description',description)
    
    checkPermission=getSecurityManager().checkPermission

    if createUserF:
        if not checkPermission('Add User Folders', ob):
            raise Unauthorized, (
                  'You are not authorized to add User Folders.'
                  )
        ob.manage_addUserFolder()

    if createPublic:
        if not checkPermission('Add Page Templates', ob):
            raise Unauthorized, (
                  'You are not authorized to add Page Templates.'
                  )
        ob.manage_addProduct['PageTemplates'].manage_addPageTemplate(
            id='index_html', title='')

    if REQUEST is not None:
        return self.manage_main(self, REQUEST, update_menu=1)



class ZSQLBibliography(Folder,ZSQLExtendFolder):
    """Bibliography"""
    meta_type="ZSQLBibliography"
    def getLabel(self):
        try:
            return self.label
        except:
            return ""

    def getDescription(self):
        try:
            return self.description
        except:
            return ""
            
    def changeZSQLBibliographyForm(self):
        """change folder config"""
        pt=PageTemplateFile('Products/ZSQLExtend/zpt/changeZSQLBibliographyForm.zpt').__of__(self)
        return pt()


    def content_html(self):
        """template fuer content"""
        
        try:
            obj=getattr(self,"ZSQLBibliography_template")
            return obj()
        except:
            pt=PageTemplateFile('Products/ZSQLExtend/zpt/ZSQLBibliography_template_standard.zpt').__of__(self)
            pt.content_type="text/html"
            return pt()

    def changeZSQLBibliography(self,tableName,label,description,REQUEST=None):
        """change it"""
        self.tableName=tableName
        self.label=label
        self.description=description
        
        if REQUEST is not None:
            return self.manage_main(self, REQUEST)

    manage_options=Folder.manage_options+(
        {'label':'Main Config','action':'changeZSQLBibliographyForm'},
       )


    def getFieldLabel(self,fields,field):
        """get labels"""
        try:
            ret =fields[0][field]
            if ret == "":
                return field
            else:
                return ret
        except:
            return field
        
    def getFieldValue(self,found,field):
        """get value"""
        try:
            ret=getattr(found,field)
            if ret == "":
                return None
            else:
                return ret
        except:
            return None

    def findTagsFromMapping(self,referenceType):
        """gib hash mit label -> generic zurueck"""
        self.referencetypes=self.ZopeFind(self.standardMD)
        bibdata={}
        retdata={}
        fieldlist=self.standardMD.fieldList
        
	for referenceTypeF in self.referencetypes:
		#print referenceType,referenceTypeF[1].title
		if referenceTypeF[1].title == referenceType: 
			bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
			bibdata['data']=referenceTypeF[1]
			self.fields=bibdata[referenceType]
                        for field in fieldlist:
                            retdata[field]=referenceTypeF[1].getValue(field)[0]

        return retdata,fieldlist
        
    def findLabelsFromMapping(self,referenceType):
        """gib hash mit label -> generic zurueck"""
        self.referencetypes=self.ZopeFind(self.standardMD)
        bibdata={}
        retdata={}
        fieldlist=self.standardMD.fieldList
        
	for referenceTypeF in self.referencetypes:
		#print referenceType,referenceTypeF[1].title
		if referenceTypeF[1].title == referenceType: 
			bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
			bibdata['data']=referenceTypeF[1]
			self.fields=bibdata[referenceType]
                        for field in fieldlist:
                            retdata[field]=referenceTypeF[1].getValue(field)[1]

        return retdata,fieldlist

    def createIndexTag(self,tag,content):
        """creste tag"""
        if content:
            ret="""<%s>%s</%s>"""%(tag,content,tag)
            return ret
        else:
            return ""
    
    def getMetaDataXML(self):
        """crate index meta"""
        pt=PageTemplateFile('Products/ZSQLExtend/zpt/record.xml').__of__(self)
        pt.content_type="text/xml"
        return pt()

    def getMetaDatasXML(self):
        """index"""
        ret="""<?xml version="1.0" ?>
	             <index>"""
        for found in self.search(var="select oid from %s"%self.tableName):
            link=self.absolute_url()+"/"+"record.html?oid=%i"%found.oid
            metalink=self.absolute_url()+"/"+"getMetaDataXML?oid=%i"%found.oid
            
            ret+="""<resource resourceLink="%s" metaLink="%s"/>\n"""%(link,metalink)
            
        return ret+"\n</index>"
    
manage_addZSQLBibliographyForm=DTMLFile('ZSQLBibliographyAdd', globals())

def manage_addZSQLBibliography(self, id, tableName,label,description,title='',
                     createPublic=0,
                     createUserF=0,
                     REQUEST=None):
    """Add a new Folder object with id *id*.

    If the 'createPublic' and 'createUserF' parameters are set to any true
    value, an 'index_html' and a 'UserFolder' objects are created respectively
    in the new folder.
    """
    
    
    ob=ZSQLBibliography()
    ob.id=str(id)
    ob.title=title
    self._setObject(id, ob)
    ob=self._getOb(id)
    setattr(ob,'tableName',tableName)
    setattr(ob,'label',label)
    setattr(ob,'description',description)
    
    checkPermission=getSecurityManager().checkPermission

    if createUserF:
        if not checkPermission('Add User Folders', ob):
            raise Unauthorized, (
                  'You are not authorized to add User Folders.'
                  )
        ob.manage_addUserFolder()

    if createPublic:
        if not checkPermission('Add Page Templates', ob):
            raise Unauthorized, (
                  'You are not authorized to add Page Templates.'
                  )
        ob.manage_addProduct['PageTemplates'].manage_addPageTemplate(
            id='index_html', title='')

    if REQUEST is not None:
        return self.manage_main(self, REQUEST, update_menu=1)