version 1.8, 2004/04/02 07:56:26
|
version 1.84.2.3, 2012/08/29 07:53:31
|
Line 1
|
Line 1
|
# Objekte zur Erzeugung von Navigationselementen |
# Objekte zur Erzeugung von Navigationselement |
|
# 29-8-2012 Referenzen zum Storagemanager entfernt |
|
|
|
from AccessControl import ClassSecurityInfo |
|
from Globals import DTMLFile |
|
from OFS.Image import Image,cookId |
from OFS.Folder import Folder |
from OFS.Folder import Folder |
from OFS.SimpleItem import SimpleItem |
from OFS.SimpleItem import SimpleItem |
from Products.PageTemplates.PageTemplateFile import PageTemplateFile |
from Products.PageTemplates.PageTemplateFile import PageTemplateFile |
Line 11 from Products.PageTemplates.ZopePageTemp
|
Line 14 from Products.PageTemplates.ZopePageTemp
|
import os.path |
import os.path |
from Globals import package_home |
from Globals import package_home |
import urllib |
import urllib |
|
from ECHO_helpers import * |
|
from ECHO_collection import content_html |
|
from types import * |
|
|
|
|
|
from Globals import DTMLFile |
|
from OFS.Image import Image,cookId |
|
from OFS.Folder import Folder |
|
from OFS.SimpleItem import SimpleItem |
|
from Products.PageTemplates.PageTemplateFile import PageTemplateFile |
|
from Products.PageTemplates.PageTemplate import PageTemplate |
|
import re |
|
import string |
|
from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate |
|
import os.path |
|
|
|
import urllib |
|
import ECHO_helpers |
|
from ECHO_helpers import displayTypes,checkOnlyOneInGroup,unicodify |
|
from ECHO_collection import content_html |
|
import logging |
|
|
|
#def ersetzt logging |
|
def logger(txt,method,txt2): |
|
"""logging""" |
|
logging.info(txt+ txt2) |
|
|
|
|
|
try: |
|
from Products.ZSQLExtend.ZSQLExtend import ZSQLExtendFolder |
|
except: |
|
logger('ECHO_Nav',logging.INFO,'ZSQLSimpleSearch not supported') |
|
|
|
|
|
|
|
class ECHO_ZCatalogElement(SimpleItem): |
|
"""Erzeuge navigation aus ZCatalog-abfrage""" |
|
meta_type="ECHO_ZCatalogElement" |
|
baseUrl="" |
|
|
|
def __init__(self,id,title,field,catalogId,baseUrl,weight,contentType): |
|
"""init""" |
|
self.id=id |
|
self.title=title |
|
self.catalogId=catalogId |
|
self.field=field |
|
|
|
self.baseUrl=baseUrl |
|
self.weight=weight |
|
self.content=contentType |
|
|
|
|
|
manage_options= SimpleItem.manage_options+( |
|
{'label':'Main Config','action':'changeECHO_ZCatalogElementForm'}, |
|
) |
|
|
|
|
|
def getWeight(self): |
|
"""get weight""" |
|
if hasattr(self,'weight'): |
|
return self.weight |
|
else: |
|
return 0 |
|
|
|
def getcontentType(self): |
|
"""get weight""" |
|
|
|
if hasattr(self,'contentType'): |
|
return self.contentType |
|
else: |
|
return 0 |
|
|
|
|
|
def changeECHO_ZCatalogElementForm(self): |
|
"""change""" |
|
|
|
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeECHO_ZCatalogElement.zpt')).__of__(self) |
|
return pt() |
|
|
|
def changeECHO_ZCatalogElement(self,title,field,catalogId,baseUrl,weight,contentType,RESPONSE=None): |
|
"""change""" |
|
self.title=title |
|
self.catalogId=catalogId |
|
self.field=field |
|
self.baseUrl=baseUrl |
|
self.weight=weight |
|
self.contentType=contentType |
|
|
|
if RESPONSE is not None: |
|
RESPONSE.redirect('manage_main') |
|
def getKeywordList(self): |
|
try: |
|
return getattr(self,self.catalogId).uniqueValuesFor(self.field) |
|
except: |
|
#return getattr(self,self.catalogId).query(self.field) |
|
|
|
list= [x for x in getattr(getattr(self,self.catalogId),self.field).words()] |
|
list.sort() |
|
return list |
|
|
|
def getNavList(self): |
|
"""ausgabe der treffer list fuer navigation""" |
|
|
|
records=self.getKeywordList() |
|
|
|
records=[x.encode('utf-8') for x in records] |
|
records.sort() |
|
if not records: |
|
return [] |
|
else: |
|
ret=[] |
|
for record in records: |
|
|
|
#print "RC",record |
|
#if record: |
|
# ret.append((record,self.baseUrl+urllib.quote(record))) |
|
try: |
|
ret.append((record,self.baseUrl+urllib.quote(record))) |
|
except: |
|
"""nothing""" |
|
|
|
return ret |
|
|
|
|
|
def manage_addECHO_ZCatalogElementForm(self): |
|
"""Form for adding""" |
|
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddECHO_ZCatalogElement.zpt')).__of__(self) |
|
return pt() |
|
|
|
def manage_addECHO_ZCatalogElement(self,id,title,field,catalogId,baseUrl,weight,contentType,RESPONSE=None): |
|
"""Add an ECHO_ZCatalogelement""" |
|
|
|
self._setObject(id,ECHO_ZCatalogElement(id,title,field,catalogId,baseUrl,weight,contentType)) |
|
|
|
if RESPONSE is not None: |
|
RESPONSE.redirect('manage_main') |
|
|
|
|
|
|
|
class ECHO_contentType(Image): |
|
"""ContentType Object""" |
|
|
|
meta_type="ECHO_contentType" |
|
|
|
|
|
manage_options=Image.manage_options+( |
|
{'label':'Change Description','action':'changeECHO_contentTypeForm'}, |
|
) |
|
|
|
def changeECHO_contentTypeForm(self): |
|
"""Change the description text""" |
|
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeECHO_contentType.zpt')).__of__(self) |
|
return pt() |
|
|
|
def changeECHO_contentType(self,description,RESPONSE=None): |
|
"""Change the Content""" |
|
self.description=description |
|
if RESPONSE is not None: |
|
RESPONSE.redirect('manage_main') |
|
|
|
manage_addECHO_contentTypeForm=DTMLFile('dtml/ECHO_contentTypeAdd',globals(), |
|
Kind='ECHO_contentType',kind='ECHO_contentType') |
|
|
|
def manage_addECHO_contentType(self, id, file=None, title='', precondition='', content_type='', description='', |
|
REQUEST=None): |
|
""" |
|
Add a new Image object. |
|
|
|
Creates a new Image object 'id' with the contents of 'file'. |
|
""" |
|
|
|
id=str(id) |
|
title=str(title) |
|
content_type=str(content_type) |
|
precondition=str(precondition) |
|
|
|
id, title = cookId(id, title, file) |
|
|
|
self=self.this() |
|
|
|
# First, we create the image without data: |
|
self._setObject(id, ECHO_contentType(id,title,'',content_type, precondition)) |
|
|
|
self._getOb(id).description=description |
|
|
|
# Now we "upload" the data. By doing this in two steps, we |
|
# can use a database trick to make the upload more efficient. |
|
if file: |
|
self._getOb(id).manage_upload(file) |
|
if content_type: |
|
self._getOb(id).content_type=content_type |
|
|
|
if REQUEST is not None: |
|
try: url=self.DestinationURL() |
|
except: url=REQUEST['URL1'] |
|
REQUEST.RESPONSE.redirect('%s/manage_main' % url) |
|
return id |
|
|
|
|
class ECHO_sqlElement(SimpleItem): |
class ECHO_sqlElement(SimpleItem): |
"""Erzeuge navigation aus sql-abfrage""" |
"""Erzeuge navigation aus sql-abfrage""" |
meta_type="ECHO_sqlElement" |
meta_type="ECHO_sqlElement" |
baseUrl="" |
baseUrl="" |
|
|
def __init__(self,id,title,query,field,searchField,baseUrl,weight,content_type): |
|
|
|
|
def __init__(self,id,title,query,field,searchField,baseUrl,weight,contentType): |
"""init""" |
"""init""" |
self.id=id |
self.id=id |
self.title=title |
self.title=title |
Line 28 class ECHO_sqlElement(SimpleItem):
|
Line 231 class ECHO_sqlElement(SimpleItem):
|
else: |
else: |
self.searchField=searchField |
self.searchField=searchField |
self.baseUrl=baseUrl |
self.baseUrl=baseUrl |
self.weight=weight |
|
self.content=content_type |
self.content=contentType |
|
|
manage_options= SimpleItem.manage_options+( |
manage_options= SimpleItem.manage_options+( |
{'label':'Main Config','action':'changeECHO_sqlElementForm'}, |
{'label':'Main Config','action':'changeECHO_sqlElementForm'}, |
Line 48 class ECHO_sqlElement(SimpleItem):
|
Line 251 class ECHO_sqlElement(SimpleItem):
|
else: |
else: |
return 0 |
return 0 |
|
|
def getContent_type(self): |
def getcontentType(self): |
"""get weight""" |
"""get weight""" |
|
|
if hasattr(self,'content_type'): |
if hasattr(self,'contentType'): |
return self.content_type |
return self.contentType |
else: |
else: |
return 0 |
return 0 |
|
|
Line 60 class ECHO_sqlElement(SimpleItem):
|
Line 263 class ECHO_sqlElement(SimpleItem):
|
def changeECHO_sqlElementForm(self): |
def changeECHO_sqlElementForm(self): |
"""change""" |
"""change""" |
|
|
pt=PageTemplateFile('Products/ECHO_content/zpt/changeECHO_sqlElement.zpt').__of__(self) |
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeECHO_sqlElement.zpt')).__of__(self) |
return pt() |
return pt() |
|
|
def changeECHO_sqlElement(self,title,query,field,searchField,baseUrl,weight,content_type,RESPONSE=None): |
def changeECHO_sqlElement(self,title,query,field,searchField,baseUrl,weight,contentType,RESPONSE=None): |
"""change""" |
"""change""" |
self.title=title |
self.title=title |
self.query=query |
self.query=query |
Line 71 class ECHO_sqlElement(SimpleItem):
|
Line 274 class ECHO_sqlElement(SimpleItem):
|
self.searchField=searchField |
self.searchField=searchField |
self.baseUrl=baseUrl |
self.baseUrl=baseUrl |
self.weight=weight |
self.weight=weight |
self.content_type=content_type |
self.contentType=contentType |
|
|
if RESPONSE is not None: |
if RESPONSE is not None: |
RESPONSE.redirect('manage_main') |
RESPONSE.redirect('manage_main') |
|
|
def searchQuery(self): |
try: |
return self.search(var=self.query) |
searchQuery=ZSQLExtendFolder.ZSQLSimpleSearch |
|
except: |
|
logger('ECHO_Nav',logging.INFO,'ZSQLSimpleSearch not supported') |
|
|
def getNavList(self): |
def getNavList(self): |
"""ausgabe der treffer list für navigation""" |
"""ausgabe der treffer list fuer navigation""" |
records=self.searchQuery() |
|
|
#naechste schritte sind trial and error, warum geht mal das eine mal das andere 2.3 / 2.4 ?? |
|
|
|
try: |
|
try: |
|
records=self.ZSQLSimpleSearch(query=self.query) |
|
except: |
|
records=self.searchQuery(self.aq_parent,query=self.query) #python 2.4 version (??) |
|
except: |
|
records=self.searchQuery(query=self.query)#python 2.3 version(??) |
|
|
|
|
if not records: |
if not records: |
return [] |
return [] |
else: |
else: |
Line 90 class ECHO_sqlElement(SimpleItem):
|
Line 306 class ECHO_sqlElement(SimpleItem):
|
try: |
try: |
ret.append((getattr(record,self.field),self.baseUrl+urllib.quote(str(getattr(record,self.getSearchField()))))) |
ret.append((getattr(record,self.field),self.baseUrl+urllib.quote(str(getattr(record,self.getSearchField()))))) |
except: |
except: |
|
logger('ECHO_Nav',logging.INFO,"error, search") |
"""notrhing""" |
"""notrhing""" |
|
|
return ret |
return ret |
Line 97 class ECHO_sqlElement(SimpleItem):
|
Line 314 class ECHO_sqlElement(SimpleItem):
|
|
|
def manage_addECHO_sqlElementForm(self): |
def manage_addECHO_sqlElementForm(self): |
"""Form for adding""" |
"""Form for adding""" |
pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_sqlElement.zpt').__of__(self) |
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddECHO_sqlElement.zpt')).__of__(self) |
return pt() |
return pt() |
|
|
def manage_addECHO_sqlElement(self,id,title,query,field,searchField,baseUrl,weight,content_type,RESPONSE=None): |
def manage_addECHO_sqlElement(self,id,title,query,field,searchField,baseUrl,weight,contentType,RESPONSE=None): |
"""Add an ECHO_sqlelement""" |
"""Add an ECHO_sqlelement""" |
self._setObject(id,ECHO_sqlElement(id,title,query,field,searchField,baseUrl,weight,content_type)) |
self._setObject(id,ECHO_sqlElement(id,title,query,field,searchField,baseUrl,weight,contentType)) |
|
|
if RESPONSE is not None: |
if RESPONSE is not None: |
RESPONSE.redirect('manage_main') |
RESPONSE.redirect('manage_main') |
|
|
|
|
class ECHO_pageTemplate(ZopePageTemplate): |
class ECHO_pageTemplate(ZopePageTemplate,ECHO_basis): |
"""pageTemplate Objekt""" |
"""pageTemplate Objekt""" |
meta_type="ECHO_pageTemplate" |
meta_type="ECHO_pageTemplate" |
|
security=ClassSecurityInfo() |
|
|
|
|
_default_content_fn = os.path.join(package_home(globals()), |
_default_content_fn = os.path.join(package_home(globals()), |
'html/ECHO_pageTemplateDefault.html') |
'html/ECHO_pageTemplateDefault.html') |
|
|
manage_options=ZopePageTemplate.manage_options+( |
manage_options=ZopePageTemplate.manage_options+ECHO_basis.manage_options+( |
{'label':'Weight and Type','action':'changeECHO_pageTemplateWeightForm'}, |
{'label':'Main Config','action':'changeECHO_pageTemplateMainForm'}, |
|
{'label':'Graphic Coords','action':'ECHO_graphicEntry'}, |
) |
) |
|
|
def changeECHO_pageTemplateWeightForm(self): |
security.declarePublic('content_html') |
|
|
|
def addChanges(self): |
|
"""do nothing leere methode, notwendig, da bei veerbung |
|
von dieser klasse nur ueberschrieben werden kann, |
|
falls methode per url aufgerufen werden soll""" |
|
|
|
return True |
|
|
|
def content_html(self): |
|
"""content_html""" |
|
return content_html(self,'pageTemplate') |
|
|
|
def changeECHO_pageTemplateMainForm(self): |
"""change""" |
"""change""" |
pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_pageTemplateWeight.zpt').__of__(self) |
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ChangeECHO_pageTemplateMain.zpt')).__of__(self) |
return pt() |
return pt() |
|
|
def changeECHO_pageTemplateWeight(self,weight,content_type,RESPONSE=None): |
def changeECHO_pageTemplateMain(self,weight,contentType,label,description,RESPONSE=None,isAlwaysClickable=None,suffix=None,prefix=None): |
"""change""" |
"""change""" |
self.weight=weight |
self.weight=weight |
self.content_type=content_type |
self.contentType=contentType |
|
self.label=label |
|
self.description=description |
|
self.isAlwaysClickable=isAlwaysClickable |
|
self.suffix=suffix |
|
self.prefix=prefix |
|
|
if RESPONSE is not None: |
if RESPONSE is not None: |
RESPONSE.redirect('manage_main') |
RESPONSE.redirect('manage_main') |
Line 139 class ECHO_pageTemplate(ZopePageTemplate
|
Line 377 class ECHO_pageTemplate(ZopePageTemplate
|
else: |
else: |
return 0 |
return 0 |
|
|
def getContent_Type(self): |
def getcontentType(self): |
"""get weight""" |
"""get contentType""" |
if hasattr(self,'weight'): |
if hasattr(self,'contentType'): |
return self.weight |
return self.contentType |
else: |
else: |
return 0 |
return 0 |
|
|
|
def getCrumb(self): |
|
"""returns breadcrumb for this object""" |
|
return ECHO_helpers.getCrumb(self) |
|
|
|
def getHierCrumbs(self): |
|
"""returns a list of hierarchical breadcrumbs from self to the ECHO_root""" |
|
return ECHO_helpers.getHierCrumbs(self); |
|
|
|
|
|
|
## def __init__(self, id, text=None, content_type=None): |
## def __init__(self, id, text=None, contentType=None): |
## self.id = str(id) |
## self.id = str(id) |
## self.ZBindings_edit(self._default_bindings) |
## self.ZBindings_edit(self._default_bindings) |
## if text is None: |
## if text is None: |
## text = open(self._default_cont).read() |
## text = open(self._default_cont).read() |
## self.pt_edit(text, content_type) |
## self.pt_edit(text, contentType) |
|
|
def manage_addECHO_pageTemplateForm(self): |
def manage_addECHO_pageTemplateForm(self): |
"""Form for adding""" |
"""Form for adding""" |
pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_pageTemplate.zpt').__of__(self) |
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddECHO_pageTemplate.zpt')).__of__(self) |
return pt() |
return pt() |
|
|
from urllib import quote |
from urllib import quote |
|
|
|
|
def manage_addECHO_pageTemplate(self, id, weight= 0,content_type=0,title=None, text=None, |
def manage_addECHO_pageTemplate(self, id, label, weight= 0,contentType=0,title=None, text=None, |
REQUEST=None, submit=None): |
REQUEST=None, submit=None): |
"Add a Page Template with optional file content." |
"Add a Page Template with optional file content." |
|
|
Line 174 def manage_addECHO_pageTemplate(self, id
|
Line 419 def manage_addECHO_pageTemplate(self, id
|
self._setObject(id, ECHO_pageTemplate(id, text)) |
self._setObject(id, ECHO_pageTemplate(id, text)) |
ob = getattr(self, id) |
ob = getattr(self, id) |
setattr(ob,'weight',weight) |
setattr(ob,'weight',weight) |
setattr(ob,'content_type',content_type) |
setattr(ob,'label',label) |
|
setattr(ob,'contentType',contentType) |
if title: |
if title: |
ob.pt_setTitle(title) |
ob.pt_setTitle(title) |
return ob |
return ob |
Line 184 def manage_addECHO_pageTemplate(self, id
|
Line 430 def manage_addECHO_pageTemplate(self, id
|
if headers is None or not file.filename: |
if headers is None or not file.filename: |
zpt = ECHO_pageTemplate(id) |
zpt = ECHO_pageTemplate(id) |
else: |
else: |
zpt = ECHO_pageTemplate(id, file, headers.get('content_type')) |
zpt = ECHO_pageTemplate(id, file, headers.get('contentType')) |
|
|
self._setObject(id, zpt) |
self._setObject(id, zpt) |
ob = getattr(self, id) |
ob = getattr(self, id) |
setattr(ob,'weight',weight) |
setattr(ob,'weight',weight) |
|
setattr(ob,'label',label) |
if title: |
if title: |
ob.pt_setTitle(title) |
ob.pt_setTitle(title) |
|
|
Line 206 def manage_addECHO_pageTemplate(self, id
|
Line 453 def manage_addECHO_pageTemplate(self, id
|
class ECHO_navigation(Folder): |
class ECHO_navigation(Folder): |
"""Navigations Element""" |
"""Navigations Element""" |
meta_type="ECHO_Navigation" |
meta_type="ECHO_Navigation" |
|
management_page_charset="utf-8" |
|
|
|
def getUsername(self): |
|
"""get name of user""" |
|
username=str(self.REQUEST['AUTHENTICATED_USER']) |
|
if username=='Anonymous User': |
|
return None |
|
else: |
|
return username |
|
|
displayedMetaTypes=['ImageCollectionIFrame','ECHO_collection','ECHO_pageTemplate','ZSQLExtendFolder','ECHO_sqlElement','ECHO_resource','ECHO_externalLink'] |
def searchExternalCollection(self,url,simpleSearch): |
|
"""search external collection via xmlrpc""" |
|
server=xmlrpclib.Server(url) |
|
|
|
results=server.getSubcolsXMLRpc(simpleSearch) |
|
|
|
return results |
|
|
|
def getXMLRpcConnection(self,url): |
|
"""getxmlrpc""" |
|
if not hasattr(self,"_v_server"): |
|
self._v_server=[] |
|
|
|
server=xmlrpclib.Server(url) |
|
self._v_server.append(server) |
|
|
|
return len(self._v_server)-1 |
|
|
|
def getXMLRpcMethod(self,nr,method,compressed=None): |
|
"""getmethod""" |
|
|
|
ret= eval('self._v_server[%i].%s'%(nr,method)) |
|
if compressed: |
|
ret=decodeRPC(ret) |
|
return ret |
|
|
|
def getNavInfo(self): |
|
"""root informationen""" |
|
if hasattr(self,'logo_image'): |
|
if hasattr(self.logo_image,'tag'): |
|
imageTag=self.logo_image.tag() |
|
else: |
|
imageTag='' |
|
return (self.title,imageTag) |
|
|
|
def linkBar(self,parent): |
|
"""linkbarer balken""" |
|
str="" |
|
|
|
|
|
while not(parent.meta_type == "ECHO_root"): |
|
fragment="""<a href="%s">%s</a>"""%(parent.absolute_url(),parent.label) |
|
str=fragment+"/"+str |
|
parent=parent.aq_parent |
|
|
|
return str |
|
|
|
def decode(self,str): |
|
"""decoder""" |
|
return unicodify(str) |
|
|
|
def ECHOFormatListStr(self,list,search="\n",replace="<br>"): |
|
"""formatiert liste im str""" |
|
if list: |
|
return re.sub(search,replace,list) |
|
else: |
|
return |
|
|
|
def ECHO_cacheManageForm(self): |
|
"""change form""" |
|
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ECHO_cacheManageForm')).__of__(self) |
|
pt.content_type="text/html" |
|
return pt() |
|
|
|
def ECHO_cacheManage(self,cacheManagerName=None,deleteCache=None, activateCache=None,RESPONSE=None): |
|
"""cachemanager""" |
|
if cacheManagerName=="": chacheManagerName=None |
|
|
|
self.cacheManagerName=cacheManagerName |
|
self.setCache(managerName=cacheManagerName) |
|
|
|
if deleteCache: |
|
try: |
|
self.deleteCache() |
|
except: |
|
for roots in self.ZopeFind(self,obj_metatypes=['ECHO_root'],search_sub=1): |
|
roots[1].deleteCache() |
|
|
|
|
|
self.activateCache=activateCache |
|
|
|
if RESPONSE is not None: |
|
RESPONSE.redirect('manage_main') |
|
|
|
def setCache(self,obj=None,RESPONSE=None,managerName='CacheManager'): |
|
"""setze alle collections auf cache = CacheManager""" |
|
|
|
|
|
if not obj: |
|
obj = self |
|
|
|
entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_collection','VLP_resource'],search_sub=1) |
|
|
|
for entry in entries: |
|
entry[1].ZCacheable_setManagerId(managerName) |
|
|
|
|
|
return "changed all CM in: "+self.title |
|
|
|
|
|
|
|
displayableMetaTypes=displayTypes |
|
|
|
|
|
def getR(self): |
|
"""re""" |
|
return self.REQUEST |
|
|
def __init__(self,id,title,pathToHierarchy): |
def __init__(self,id,title,pathToHierarchy): |
"""init""" |
"""init""" |
self.id=id |
self.id=id |
self.title=title |
self.title=title |
self.pathToHierarchy=pathToHierarchy |
self.pathToHierarchy=pathToHierarchy |
|
self.displayedMetaTypes=displayTypes |
|
|
manage_options = Folder.manage_options+( |
manage_options = Folder.manage_options+( |
{'label':'Main Config','action':'ECHO_navigationConfigForm'}, |
{'label':'Main Config','action':'ECHO_navigationConfigForm'}, |
|
{'label':'Cache','action':'ECHO_cacheManageForm'}, |
|
|
) |
) |
|
displayedMetaTypes=displayTypes |
|
|
|
|
|
|
def ECHO_navigationConfigForm(self): |
def ECHO_navigationConfigForm(self): |
"""configForm""" |
"""configForm""" |
pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_navigation.zpt').__of__(self) |
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ChangeECHO_navigation.zpt')).__of__(self) |
return pt() |
return pt() |
|
|
def ECHO_navigationConfig(self,title,pathToHierarchy,RESPONSE=None): |
def ECHO_navigationConfig(self,title,pathToHierarchy,displayedMetaTypes=displayTypes,RESPONSE=None): |
"""config""" |
"""config""" |
self.title=title |
self.title=title |
self.pathToHierarchy=pathToHierarchy |
self.pathToHierarchy=pathToHierarchy |
|
self.displayedMetaTypes=toList(displayedMetaTypes)[0:] |
|
|
|
|
if RESPONSE is not None: |
if RESPONSE is not None: |
RESPONSE.redirect('manage_main') |
RESPONSE.redirect('manage_main') |
|
|
|
|
def getColls(self,obj,depth): |
def getColls(self,obj,depth,checkOnly="no"): |
nav={} |
nav={} |
#print "HERE",obj. |
#print "HERE",obj. |
for keys in obj.__dict__.keys(): |
for x_objs in obj.ZopeFind(obj,obj_metatypes=self.displayedMetaTypes): |
x=getattr(obj,keys) |
x=x_objs[1] |
if hasattr(x,"meta_type"): |
if checkOnly=="yes": |
if x.meta_type in self.displayedMetaTypes: |
x = checkOnlyOneInGroup(x) |
if depth>1: |
if depth>1: |
nav[x.getId()]=(self.getColls(x,depth-1),x) |
nav[x.getId()]=(self.getColls(x,depth-1),x) |
else: |
else: |
nav[x.getId()]=(None,x) |
nav[x.getId()]=(None,x) |
return nav |
return nav |
|
|
def createNavHash(self,depth): |
def createNavHash(self,depth,checkOnly="no"): |
"""Auslesen des Hierarchiebuames""" |
"""Auslesen des Hierarchiebuames""" |
temp=self.pathToHierarchy[0:] |
temp=self.pathToHierarchy[0:] |
temp=re.sub("/",".",temp) |
temp=re.sub("/",".",temp) |
temp="self.aq_parent"+temp |
temp="self.aq_parent"+temp |
|
|
|
|
objtemp=eval(temp) |
objtemp=eval(temp) |
nav={} |
nav={} |
obj=objtemp |
|
|
|
#exec(obj) |
#check if cash is enabled and if already exists and if not empty |
|
if getattr(self,'_v_hash',None) and getattr(self,'activateCache',None) and self._v_hash.get(str(depth),None): |
|
|
|
return self._v_hash[str(depth)] |
|
|
|
# if not generate new hash |
|
obj=objtemp |
|
|
#objtemp = compile(temp,'<string>','single') |
for keys in obj.ZopeFind(obj,obj_metatypes=self.displayedMetaTypes): |
#obj=eval(objtemp) |
|
#print obj |
|
|
|
#print obj.__dict__.keys() |
|
|
|
for keys in obj.__dict__.keys(): |
|
x=getattr(obj,keys) |
|
if hasattr(x,"meta_type"): |
|
#print x.meta_type |
|
if x.meta_type in self.displayedMetaTypes: |
|
|
|
|
x=keys[1] |
if depth>1: |
if depth>1: |
nav[x.getId()]=(self.getColls(x,int(depth)-1),x) |
nav[x.getId()]=(self.getColls(x,int(depth)-1,checkOnly),x) |
else: |
else: |
nav[x.getId()]=(None,x) |
nav[x.getId()]=(None,x) |
|
|
|
#store in cache if activated |
|
if getattr(self,'activateCache',None): |
|
|
|
try: |
|
self._v_hash[str(depth)]={} |
|
except: |
|
self._v_hash={} |
|
self._v_hash[str(depth)]={} |
|
|
|
for x in nav.keys(): |
|
self._v_hash[str(depth)][x]=nav[x] |
|
|
#print nav |
|
return nav |
return nav |
|
|
def barFromHash(self,hash,start=None,sortField=None): |
def barFromHash(self,hash,start=None,sortField=None,location=None): |
"""Erzeuge Navigations Element""" |
"""Erzeuge Navigations Element""" |
#print "hash",hash |
|
listNav=[] |
listNav=[] |
if not start: |
if not start: |
temp=hash |
temp=hash |
sortField="weight" |
sortField="weight" |
else: # list mit pfad zum hash |
else: # liste mit pfad zum hash |
temp=hash |
temp=hash |
#print "HI",sortField |
#print "HI",sortField |
if not sortField: |
if not sortField: |
tempObj=self.pathToHierarchy[0:] |
tempObj=self.pathToHierarchy[0:] |
tempObj=re.sub("/",".",tempObj) |
tempObj=re.sub("/",".",tempObj) |
tempObj="self.aq_parent"+tempObj |
tempObj="self.aq_parent"+tempObj |
|
#print tempObj |
objtemp=eval(tempObj) |
objtemp=eval(tempObj) |
|
|
obj=objtemp |
obj=objtemp |
Line 316 class ECHO_navigation(Folder):
|
Line 693 class ECHO_navigation(Folder):
|
"""nothing""" |
"""nothing""" |
return [] |
return [] |
#print "TEMP",temp,self.tempSorted(temp, field=sortField) |
#print "TEMP",temp,self.tempSorted(temp, field=sortField) |
print "HELL",sortField |
|
for x in self.tempSorted(temp, field=sortField): |
for x in self.tempSorted(temp, field=sortField): |
|
|
if not temp[x][1].title == "": |
if not temp[x][1].title == "": |
if temp[x][1].meta_type=="ECHO_sqlElement": |
|
|
if (temp[x][1].meta_type=="ECHO_sqlElement") or (temp[x][1].meta_type=="ECHO_ZCatalogElement"): |
|
|
for z in temp[x][1].getNavList(): |
for z in temp[x][1].getNavList(): |
listNav.append((z[0],z[1])) |
listNav.append((z[0],z[1],None,'','')) |
|
|
else: |
else: |
# add label fals existiert und nicht leer |
# add label falls existiert und nicht leer |
if hasattr(temp[x][1],'label'): |
if hasattr(temp[x][1],'label'): |
if not temp[x][1].label=='': |
|
label=temp[x][1].label |
if not temp[x][1].getLabel()=='': |
print "HAS LABEL",label |
label=temp[x][1].getLabel() |
else: |
else: |
label=temp[x][1].title |
try: |
|
label=temp[x][1].getTitle() |
|
except: |
|
logger("ECHO_Nav",logging.ERROR,"%s has neither getLabel nor getTile implemented"%temp[x][1].getId()) |
|
label="" |
else: |
else: |
label=temp[x][1].title |
label=temp[x][1].getTitle() |
|
|
|
|
listNav.append((label,createPath(self.absolute_url(),temp[x][1].absolute_url()))) |
if location: |
|
|
#print self.getId(),start |
loc=getattr(temp[x][1],'location','top') |
#print listNav |
if (loc==location): |
|
|
#html="" |
|
#for k in listNav: |
|
# print k |
|
# html=html+"<a href='%s'>%s</a> "% (self.absolute_url()+createPath(k[1][1].absolute_url()),k[0]) |
|
|
|
|
listNav.append((label,createPath(self,self.absolute_url(),temp[x][1].absolute_url(relative=1))+getattr(temp[x][1],'queryString',''),temp[x][1],getattr(temp[x][1],'prefix',''),getattr(temp[x][1],'suffix',''))) |
|
else: |
|
|
|
listNav.append((label,createPath(self,self.absolute_url(),temp[x][1].absolute_url(relative=1))+getattr(temp[x][1],'queryString',''),temp[x][1],getattr(temp[x][1],'prefix',''),getattr(temp[x][1],'suffix',''))) |
|
#print self.REQUEST |
return listNav |
return listNav |
|
|
def tempSorted(self,hash,field="weight"): |
def tempSorted(self,hash,field="weight"): |
ls=[] |
ls=[] |
print "SORT",field |
|
for x in hash.keys(): |
for x in hash.keys(): |
#print hash[x][1] |
#print hash[x][1] |
if hasattr(hash[x][1],field): |
if hasattr(hash[x][1],field): |
|
try: |
|
weight=int(getattr(hash[x][1],field)) |
|
except: |
weight=getattr(hash[x][1],field) |
weight=getattr(hash[x][1],field) |
#print weight |
#print weight |
else: |
else: |
Line 367 class ECHO_navigation(Folder):
|
Line 757 class ECHO_navigation(Folder):
|
|
|
def isSelectedPath(self,item): |
def isSelectedPath(self,item): |
"""test is path is already selected""" |
"""test is path is already selected""" |
|
|
|
testStr=re.sub("/index_html",'',self.REQUEST.get('URL','')) |
|
|
|
if len(item)<2: |
|
return 0 |
|
#falls exakte Uebereinstimmung dann immer 1 |
|
if (testStr==item[1]) and (self.REQUEST.get('QUERY_STRING','')==''): |
|
|
|
return 1 |
|
|
found=re.search("\?(.*)",item[1]) |
found=re.search("\?(.*)",item[1]) |
|
|
if found: |
if found: |
temp=re.sub(" ","%20",found.group(0)) |
temp=re.sub(" ","%20",found.group(0)) |
|
|
#print temp+"::"+self.REQUEST['QUERY_STRING'] |
#print temp+"::"+self.REQUEST['QUERY_STRING'] |
if ("?"+self.REQUEST['QUERY_STRING'])==temp: |
if ("?"+self.REQUEST['QUERY_STRING'])==temp: |
|
if getattr(item[2],'isAlwaysClickable',None): #immer auswaehlbar? |
|
|
|
return 2 |
|
else: |
|
return 1 |
|
|
|
if (getattr(item[2],'meta_type','')=="ECHO_pageTemplate") and (re.search(item[1],self.REQUEST['URL'])): |
|
if getattr(item[2],'isAlwaysClickable',None): #immer auswaehlbar? |
|
|
|
return 2 |
|
else: |
return 1 |
return 1 |
|
|
if re.search(item[1],self.REQUEST['URL']): |
if re.search(item[1]+"/",self.REQUEST['URL']): |
|
if getattr(item[2],'isAlwaysClickable',None): #immer auswaehlbar? |
|
|
|
return 2 |
|
else: |
return 1 |
return 1 |
else: |
else: |
return 0 |
return 0 |
|
|
|
|
|
def getPathStyle(self, item, style=""): |
|
"""returns a string with the given style + 'sel' if the path is already selected.""" |
|
|
|
if self.isSelectedPath(item): |
|
return style + 'sel' |
|
else: |
|
return style |
|
|
|
|
|
def getCrumb(self): |
|
"""returns breadcrumb for this object""" |
|
# ignore this object if title is empty |
|
if not self.title: |
|
return None |
|
|
|
# we use title for the label TODO: add label to ECHO_root |
|
crumb = {'obj': self, |
|
'url': self.absolute_url(), |
|
'label': self.title} |
|
return crumb |
|
|
|
def getHierCrumbs(self): |
|
"""returns a list of hierarchical breadcrumbs from self to the ECHO_root""" |
|
return ECHO_helpers.getHierCrumbs(self) |
|
|
|
|
def buttonsFromHash(self,hash,start=None,orientation="horizontal"): |
def buttonsFromHash(self,hash,start=None,orientation="horizontal"): |
|
|
"""Generate Buttons""" |
"""Generate Buttons""" |
Line 407 class ECHO_navigation(Folder):
|
Line 850 class ECHO_navigation(Folder):
|
|
|
description=temp[x][1].title |
description=temp[x][1].title |
|
|
url=createPath(self.absolute_url(),temp[key][1].absolute_url()) |
|
|
url=createPath(self,self.absolute_url(),temp[key][1].absolute_url(relative=1)) |
|
|
if (self.REQUEST['URL']==url) | (self.REQUEST['URL']==url+"/index_html"): |
if (self.REQUEST['URL']==url) | (self.REQUEST['URL']==url+"/index_html"): |
html=html+startTag+"[%s]" % description+endTag |
html=html+startTag+"[%s]" % description+endTag |
Line 422 class ECHO_navigation(Folder):
|
Line 866 class ECHO_navigation(Folder):
|
def mainNavBar(self): |
def mainNavBar(self): |
"""print main navigation bar""" |
"""print main navigation bar""" |
keys="" |
keys="" |
print "NAVBAR",self.getId() |
|
try: |
try: |
keys=self.buttonsFromHash(self.createNavHash(0)) |
keys=self.buttonsFromHash(self.createNavHash(0)) |
except: |
except: |
Line 430 class ECHO_navigation(Folder):
|
Line 874 class ECHO_navigation(Folder):
|
|
|
return keys |
return keys |
|
|
def mainNavElements(self): |
def mainNavElements(self,location=None): |
"""print main navigation bar""" |
"""print main navigation bar""" |
keys="" |
keys="" |
print "NAVELEMENT",self.getId() |
#print "NAVELEMENT",self.getId() |
#try: |
#try: |
|
|
keys=self.barFromHash(self.createNavHash(0)) |
keys=self.barFromHash(self.createNavHash(0),location=location) |
|
|
#except: |
#except: |
# keys="" |
# keys="" |
|
|
return keys |
return keys |
|
|
|
def numberOfMainNavElements(self): |
|
"""number of main elements""" |
|
|
|
return len(self.barFromHash(self.createNavHash(0))) |
|
|
|
def startOfHierarchy(self,list): |
|
splitted=self.pathToHierarchy.split("/") |
|
last=splitted[len(splitted)-1] |
|
#print last,list |
|
try: |
|
nr=list.index(last) |
|
except: |
|
nr=0 |
|
return nr+1 |
|
|
|
def subNavStatic(self,obj): |
|
"""subnav" von self""" |
|
def sortWeight(x,y): |
|
x1=int(getattr(x[1],'weight','0')) |
|
y1=int(getattr(y[1],'weight','0')) |
|
return cmp(x1,y1) |
|
print "obj",obj |
|
subs=self.ZopeFind(obj,obj_metatypes=self.displayedMetaTypes) |
|
subret=[] |
|
|
|
for x in subs: |
|
if not(x[1].title==""): |
|
subret.append(x) |
|
subret.sort(sortWeight) |
|
return subret |
|
|
def secondNavElements(self): |
def secondNavElements(self): |
"""Zweite Ordnung""" |
"""Zweite Ordnung Navigationselemente""" |
|
|
|
hash=self.createNavHash(2,checkOnly="no") |
|
|
hash=self.createNavHash(2) |
|
actual_url=self.REQUEST['URL'] |
actual_url=self.REQUEST['URL'] |
|
|
ult_temp=re.sub(self.absolute_url(),"",actual_url) |
ult_temp=re.sub(self.absolute_url(),"",actual_url) |
Line 454 class ECHO_navigation(Folder):
|
Line 930 class ECHO_navigation(Folder):
|
|
|
splitted=ult_temp.split("/") |
splitted=ult_temp.split("/") |
|
|
|
#print "AU",self.absolute_url(),splitted |
|
#start=[splitted[2]] #orig |
|
startNr= self.startOfHierarchy(splitted) |
|
|
## if splitted[len(splitted)-1]=="index_html": |
start=[splitted[startNr]] |
## start=[splitted[len(splitted)-2]] |
|
## else: |
|
## start=[splitted[len(splitted)-1]] |
|
|
|
start=[splitted[2]] |
|
#print start |
#print start |
|
|
keys=self.barFromHash(hash,start=start) |
keys=self.barFromHash(hash,start=start) |
Line 485 class ECHO_navigation(Folder):
|
Line 960 class ECHO_navigation(Folder):
|
## else: |
## else: |
## start=[splitted[len(splitted)-1]] |
## start=[splitted[len(splitted)-1]] |
|
|
start=splitted[2:order+1] |
#start=splitted[2:order+1] #orig |
|
startNr= self.startOfHierarchy(splitted) |
|
#print startNr |
|
start=splitted[startNr:order+startNr-1] |
#print start |
#print start |
|
|
keys=self.barFromHash(hash,start=start) |
keys=self.barFromHash(hash,start=start) |
Line 521 class ECHO_navigation(Folder):
|
Line 999 class ECHO_navigation(Folder):
|
|
|
def manage_addECHO_navigationForm(self): |
def manage_addECHO_navigationForm(self): |
"""Form for adding""" |
"""Form for adding""" |
pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_navigation.zpt').__of__(self) |
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddECHO_navigation.zpt')).__of__(self) |
return pt() |
return pt() |
|
|
def manage_addECHO_navigation(self,id,title,pathToHierarchy,RESPONSE=None): |
def manage_addECHO_navigation(self,id,title,pathToHierarchy,RESPONSE=None): |
Line 536 def manage_addECHO_navigation(self,id,ti
|
Line 1014 def manage_addECHO_navigation(self,id,ti
|
|
|
|
|
|
|
def createPath(url1,url2): |
def createPath(self,url1,url2): |
|
#bugfix in absolute_url, ploetzlich erschein in absolute_url der physikalische pfad. |
|
|
|
if self.REQUEST.has_key('VirtualRootPhysicalPath'): |
|
vp="/".join(self.REQUEST['VirtualRootPhysicalPath']) |
|
if (len(vp)>0): |
|
if vp[0]=="/": |
|
vp=vp[1:] |
|
|
|
url2=url2.replace(vp+"/",'') |
|
else: |
temp1=url1.split("/") |
temp1=url1.split("/") |
temp2=url2.split("/") |
temp2=url2.split("/") |
for test in temp1: |
for test in temp1: |
if temp2[0]==test: |
if temp2[0]==test: |
del temp2[0] |
del temp2[0] |
|
|
return url1+"/"+string.join(temp2,"/") |
url2= string.join(temp2,"/") |
|
|
|
return url1+"/"+url2 |
|
|
def sortWeight(x,y): |
def sortWeight(x,y): |
#print x[1],y[1] |
#print x[1],y[1] |