ECHO_content/ECHO_collection.py - diff

Return to ECHO_collection.py CVS log

Up to [Repository] / ECHO_content

Diff for /ECHO_content/ECHO_collection.py between versions 1.78 and 1.90

version 1.78, 2004/05/10 16:22:17	version 1.90, 2004/05/26 07:39:36
Line 19 from Globals import DTMLFile	Line 19 from Globals import DTMLFile
from OFS.Folder import Folder	from OFS.Folder import Folder
from OFS.SimpleItem import SimpleItem	from OFS.SimpleItem import SimpleItem
from AccessControl import ClassSecurityInfo	from AccessControl import ClassSecurityInfo
	from AccessControl.User import UserFolder
from Globals import InitializeClass	from Globals import InitializeClass
from Globals import DTMLFile	from Globals import DTMLFile
	import Globals
from Products.PageTemplates.PageTemplateFile import PageTemplateFile	from Products.PageTemplates.PageTemplateFile import PageTemplateFile
from Products.PageTemplates.PageTemplate import PageTemplate	from Products.PageTemplates.PageTemplate import PageTemplate
from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate	from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
from Globals import Persistent, package_home	from Globals import Persistent, package_home
from Acquisition import Implicit	from Acquisition import Implicit
from ECHO_helpers import displayTypes	from ECHO_helpers import displayTypes


try:	try:
from psycopg import libpq	from psycopg import libpq
except:	except:
Line 48 viewClassificationListMaster=['view poin	Line 52 viewClassificationListMaster=['view poin
def checkDiffs(self,metadict):	def checkDiffs(self,metadict):
"""check differences"""	"""check differences"""




def NoneToEmpty(obj):	def NoneToEmpty(obj):
if obj:	if obj:
return obj	return obj
else:	else:
return ""	return ""



diffs={}	diffs={}

tags=self.findTagsFromMapping(self.contentType)	tags=self.findTagsFromMapping(self.contentType)
	self.referencetypes=tags[2]
	self.fields=tags[3]


for field in tags[1]:	for field in tags[1]:
try:	try:
if (NoneToEmpty(self.getFieldValue(self.getFieldTag(tags,field)))==metadict[self.getFieldTag(tags,field)]):	if (NoneToEmpty(self.getFieldValue(self.getFieldTag(tags,field)))==metadict[self.getFieldTag(tags,field)]):
diffs[self.getFieldTag(tags,field)]=1	diffs[self.getFieldTag(tags,field)]=1
else:	else:
print "DIFF",field,self.getFieldValue(self.getFieldTag(tags,field)),metadict[self.getFieldTag(tags,field)]	#print "DIFF",field,self.getFieldValue(self.getFieldTag(tags,field)),metadict[self.getFieldTag(tags,field)]
diffs[self.getFieldTag(tags,field)]=0	diffs[self.getFieldTag(tags,field)]=0
except:	except:
diffs[self.getFieldTag(tags,field)]=0	diffs[self.getFieldTag(tags,field)]=0
print "EX",field	#print "EX",field
return diffs	return diffs

def content_html(self,type):	def content_html(self,type):
Line 120 def sendFile(self, filename, type):	Line 134 def sendFile(self, filename, type):
self.REQUEST.RESPONSE.write(file(fn).read())	self.REQUEST.RESPONSE.write(file(fn).read())
return	return

	class BrowserCheck:
	"""check the browsers request to find out the browser type"""

	def __init__(self, zope):
	self.ua = zope.REQUEST.get_header("HTTP_USER_AGENT")
	self.isN4 = (string.find(self.ua, 'Mozilla/4.') > -1) and (string.find(self.ua, 'MSIE') < 0)
	self.isIE = string.find(self.ua, 'MSIE') > -1
	self.nav = self.ua[string.find(self.ua, '('):]
	ie = string.split(self.nav, "; ")[1]
	if string.find(ie, "MSIE") > -1:
	self.versIE = string.split(ie, " ")[1]
	self.isMac = string.find(self.ua, 'Macintosh') > -1
	self.isWin = string.find(self.ua, 'Windows') > -1
	self.isIEWin = self.isIE and self.isWin
	self.isIEMac = self.isIE and self.isMac


def writeMetadata(url,metadict):	def writeMetadata(url,metadict):
"""Einlesen der Metadaten und und erstellen des geänderten XML file"""	"""Einlesen der Metadaten und und erstellen des geaenderten XML file"""

try:	try:
geturl=""	geturl=""
Line 146 def writeMetadata(url,metadict):	Line 176 def writeMetadata(url,metadict):
metanode=metanodes[0]	metanode=metanodes[0]

for metaData in metadict.keys():	for metaData in metadict.keys():
print metaData,metanode
try:	try:
nodeOld=metanode.getElementsByTagName(metaData)	nodeOld=metanode.getElementsByTagName(metaData)
except:	except:
Line 165 def writeMetadata(url,metadict):	Line 195 def writeMetadata(url,metadict):
metanode.removeChild(nodeOld[0]).unlink()	metanode.removeChild(nodeOld[0]).unlink()

metanodeneu=dom.createElement(metaData)	metanodeneu=dom.createElement(metaData)
metanodetext=dom.createTextNode(unicode(metadict[metaData],"utf8"))	try:
	metanodetext=dom.createTextNode(unicode(metadict[metaData],"utf-8"))
	except:
	metanodetext=dom.createTextNode(metadict[metaData].encode('utf-8'))
metanodeneu.appendChild(metanodetext)	metanodeneu.appendChild(metanodetext)
metanode.appendChild(metanodeneu)	metanode.appendChild(metanodeneu)


return dom.topxml().encode('utf-8')	return dom.toxml().encode('utf-8')



def readMetadata(url):	def readMetadata(url):
"""Methode zum Auslesen der Metadateninformation zu einer Resource	"""Methode zum Auslesen der Metadateninformation zu einer Resource
Line 208 def readMetadata(url):	Line 243 def readMetadata(url):

for node in metacontent:	for node in metacontent:
try:	try:
metadict[re.sub('-','_',node.tagName.lower())]=getText(node.childNodes)	metadict[re.sub('-','_',node.tagName.lower())]=urllib.unquote(getText(node.childNodes))
except:	except:
"""nothing"""	"""nothing"""

Line 361 def manage_addECHO_layoutTemplate(self,	Line 396 def manage_addECHO_layoutTemplate(self,
REQUEST.RESPONSE.redirect(u+'/manage_main')	REQUEST.RESPONSE.redirect(u+'/manage_main')
return ''	return ''

class ECHO_resource(Folder):	class ECHO_resource(Folder,Persistent):
"""ECHO Ressource"""	"""ECHO Ressource"""
meta_type='ECHO_resource'	meta_type='ECHO_resource'

Line 386 class ECHO_resource(Folder):	Line 421 class ECHO_resource(Folder):
else:	else:
return ""	return ""

	def getFullTextXML(self,noredirect=None):
	"""getFullTextXML; gives the FullText as an XML Document, and <error></error> if somthing goes wrong."""
	try:
	fh=urllib.urlopen(self.metalink)
	dom=xml.dom.minidom.parse(fh)
	texttools=dom.getElementsByTagName('texttool')
	text=texttools[0].getElementsByTagName('text')
	texturl=getText(text[0].childNodes)
	self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
	if not noredirect:
	self.REQUEST.RESPONSE.redirect(texturl)
	else:
	return texturl
	except:

	if not noredirect:
	self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
	self.REQUEST.RESPONSE.write("<error>no fulltext available</error>")
	else:
	return "<error>no fulltext available</error>"

def getCredits(self):	def getCredits(self):
"""Ausgabe der credits"""	"""Ausgabe der credits"""
if self.credits:	if self.credits:
Line 393 class ECHO_resource(Folder):	Line 449 class ECHO_resource(Folder):
else:	else:
return []	return []

def __init__(self,id,link,metalink,title,label,description,contentType,responsible,credits,weight,coords):	def __init__(self,id,link,metalink,resourceID,title,label,description,contentType,renderingType,responsible,credits,weight,coords):

self.id = id	self.id = id
"""Festlegen der ID"""	"""Festlegen der ID"""
Line 406 class ECHO_resource(Folder):	Line 462 class ECHO_resource(Folder):
self.credits=toList(credits)	self.credits=toList(credits)
self.description=description	self.description=description
self.contentType=contentType	self.contentType=contentType
	self.renderingType=renderingType
self.responsible=responsible	self.responsible=responsible
	self.resourceID=resourceID

if coords:	if coords:
coordsnew=[ string.split(x,",") for x in coords]	coordsnew=[ string.split(x,",") for x in coords]
Line 518 class ECHO_resource(Folder):	Line 576 class ECHO_resource(Folder):
if type(coords)==StringType:	if type(coords)==StringType:
coords=[coords]	coords=[coords]


try:	try:
coordsnew=[ string.split(x,",") for x in coords]	coordsnew=[ string.split(x,",") for x in coords]
except:	except:
Line 540 class ECHO_resource(Folder):	Line 597 class ECHO_resource(Folder):
RESPONSE.redirect('manage_main')	RESPONSE.redirect('manage_main')


	def changeECHO_resource_metadata_local(self,RESPONSE=None):
	"""change metadata"""
	tags=self.findTagsFromMapping(self.contentType)
	for field in tags[1]:
	self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)]



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

def changeECHO_resource_metadata(self,RESPONSE=None):	def changeECHO_resource_metadata(self,RESPONSE=None):
"""change metadata"""	"""change metadata"""
tags=self.findTagsFromMapping(self.contentType)	tags=self.findTagsFromMapping(self.contentType)
Line 557 class ECHO_resource(Folder):	Line 625 class ECHO_resource(Folder):
RESPONSE.redirect('manage_main')	RESPONSE.redirect('manage_main')


	def getMDValue(self,fieldName):
	return self.metaDataHash.get(fieldName,'!!NOT USED HERE in Type: %s'%self.contentType)

def newMetaXML(self):	def newMetaXML(self):
"""new index.meta"""	"""new index.meta"""
self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')	self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
return writeMetadata(self.metalink,self.OSAS_meta)	return writeMetadata(self.metalink,self.OSAS_meta)


	def getMetaDataXML(self):
	"""prints out metadata as stored in the echo environment, format is the index.meta format"""
	self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
	return writeMetadata(self.metalink,self.metaDataHash)

def changeECHO_resource(self,metalink,link,title,label,description,contentType,responsible,weight,viewClassification="",coords=None,credits=None,RESPONSE=None):	def changeECHO_resource(self,metalink,link,title,label,description,contentType,responsible,weight,viewClassification="",coords=None,credits=None,RESPONSE=None):
"""Änderung der Properties"""	"""Änderung der Properties"""

Line 664 class ECHO_resource(Folder):	Line 740 class ECHO_resource(Folder):
except:	except:
return None	return None

	def getMetaDataHash(self):
	"""md hash"""
	return self.metaDataHash

	def setFieldValue(self,field,value):
	"""get value"""
	#print field
	if not hasattr(self,'metaDataHash'):
	setattr(self,'metaDataHash',{})
	self.metaDataHash[field]=value[0:]



def findLabelsFromMapping(self,referenceType):	def findLabelsFromMapping(self,referenceType):
"""gib hash mit label -> generic zurueck"""	"""gib hash mit label -> generic zurueck"""
self.referencetypes=self.ZopeFind(self.standardMD)	#return {},[]
#print "RT",referenceType
	temp=self.ZopeFind(self.standardMD)

	if referenceType=="":
	referenceType="book"


bibdata={}	bibdata={}
retdata={}	retdata={}
	fields=[]
fieldlist=self.standardMD.fieldList	fieldlist=self.standardMD.fieldList

for referenceTypeF in self.referencetypes:	for referenceTypeF in self.referencetypes:
#print referenceTypeF[1].title,referenceType	#print referenceTypeF[1].title,referenceType
if referenceTypeF[1].title == referenceType:	if referenceTypeF[1].title.lower() == referenceType.lower():
#print "OK"	#print "OK"
	try:
bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields	bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
	referenceType=referenceTypeF[1].title
	except:
	bibdata[referenceType]=referenceTypeF[1].fields


bibdata['data']=referenceTypeF[1]	bibdata['data']=referenceTypeF[1]
self.fields=bibdata[referenceType]	fields=bibdata[referenceType]
for field in fieldlist:	for field in fieldlist:
retdata[field]=referenceTypeF[1].getValue(field)[1]	retdata[field]=referenceTypeF[1].getValue(field)[1]
#print retdata,fieldlist	#print retdata,fieldlist
return retdata,fieldlist	return retdata,fieldlist,temp,fields

def findTagsFromMapping(self,referenceType):	def findTagsFromMapping(self,referenceType):
"""gib hash mit label -> generic zurueck"""	"""gib hash mit label -> generic zurueck"""
self.referencetypes=self.ZopeFind(self.standardMD)

	if referenceType=="":
	referenceType="book"

	temp = self.ZopeFind(self.standardMD)[0:]


	#self.referencetypes=temp[0:]






bibdata={}	bibdata={}
retdata={}	retdata={}
fieldlist=self.standardMD.fieldList	fieldlist=self.standardMD.fieldList

for referenceTypeF in self.referencetypes:	for referenceTypeF in temp:

if referenceTypeF[1].title == referenceType:	if referenceTypeF[1].title.lower() == referenceType.lower():
	try:
bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields	bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
	referenceType=referenceTypeF[1].title
	except:
	bibdata[referenceType]=referenceTypeF[1].fields
bibdata['data']=referenceTypeF[1]	bibdata['data']=referenceTypeF[1]
self.fields=bibdata[referenceType]	fields=bibdata[referenceType]
for field in fieldlist:	for field in fieldlist:
retdata[field]=referenceTypeF[1].getValue(field)[0]	retdata[field]=referenceTypeF[1].getValue(field)[0]

return retdata,fieldlist	return retdata,fieldlist,temp,fields



	def copyIndex_meta2echo_resource(self,RESPONSE=None):
	"""copy MD von Index_meta to the echo_resource"""

	(metadict, error)=readMetadata(self.metalink)

	self.metaDataHash={}
	if not error=="": #Fehler beim Auslesen des Metafiles
	return "ERROR:",error
	fields=self.findTagsFromMapping(self.contentType)
	#fields=self.findLabelsFromMapping(self.contentType)
	for field in fields[1]:
	if self.isDefinedInThisSet(fields,field):
	self.setFieldValue(self.getFieldTag(fields,field),metadict.get(self.getFieldTag(fields,field),''))



	if RESPONSE:
	return RESPONSE.redirect('manage_main')

def ECHO_getResourceMD(self,template="yes"):	def ECHO_getResourceMD(self,template="yes"):
"""Einlesen der Metadaten und Anlegen dieser Metadaten als Informationen zur Resource"""	"""Einlesen der Metadaten und Anlegen dieser Metadaten als Informationen zur Resource"""
Line 718 class ECHO_resource(Folder):	Line 853 class ECHO_resource(Folder):
return "ERROR:",error	return "ERROR:",error


if not (metadict['bib_type']==self.contentType):	if not (metadict['bib_type'].lower()==self.contentType.lower()):
self.REQUEST.SESSION['contentStorage']=metadict['bib_type']	self.REQUEST.SESSION['contentStorage']=metadict['bib_type']
self.REQUEST.SESSION['contentZope']=self.contentType	self.REQUEST.SESSION['contentZope']=self.contentType

Line 726 class ECHO_resource(Folder):	Line 861 class ECHO_resource(Folder):

self.REQUEST.SESSION['metadict']=metadict	self.REQUEST.SESSION['metadict']=metadict

self.REQUEST.SESSION['diffs']=checkDiffs(self,metadict)

	self.REQUEST.SESSION['diffs']=checkDiffs(self,self.REQUEST.SESSION['metadict'])



if template=="yes":	if template=="yes":
Line 736 class ECHO_resource(Folder):	Line 874 class ECHO_resource(Folder):




def ECHO_getMD(self,item):	def ECHO_getMD(self,item):
"""Ausgabe der MD"""	"""Ausgabe der MD"""
return getattr(self,item)	return getattr(self,item)
Line 745 class ECHO_resource(Folder):	Line 884 class ECHO_resource(Folder):

return self.REQUEST.RESPONSE.redirect(self.link)	return self.REQUEST.RESPONSE.redirect(self.link)

	def startpage_html(self):
	"""prints out a startpage for a resource for use e.g. in the BVE"""

	# suche ob startpage.html in dem Ordner vorhanden ist, dann wir diese angezeigt

	sp=self.ZopeFind(self,obj_ids=['startpage.html'])

	if sp:
	return sp[1]()

	#prüfen ob irgendwo ein template
	if hasattr(self,'startpage_index_template'):
	return self.startpage_index_template()

	#generisches template ausgeben

	pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_startpage_index_template_standard.zpt').__of__(self)
	pt.content_type="text/html"
	return pt()

	def toc_html(self):

	sp=self.ZopeFind(self,obj_ids=['toc.html'])

	if sp:
	return sp[0][1]()



def generate_label(self):	def generate_label(self):
"""Erzeugt_standard_Label aus Template"""	"""Erzeugt_standard_Label aus Template"""
pt=getattr(self,"label_template_"+self.bib_type)	pt=getattr(self,"label_template_"+self.bib_type)

return pt()	return pt()

	def generate_title(self,RESPONSE=None):
	"""Erzeugt_standard_Label aus Template"""
	pt=getattr(self,"label_template_"+self.contentType)

	self.title=pt()

	return pt()

def manage_addECHO_resourceForm(self):	def manage_addECHO_resourceForm(self):
"""Form for adding a ressource"""	"""Form for adding a ressource"""
pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_resourceForm.zpt').__of__(self)	pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_resourceForm.zpt').__of__(self)
Line 758 def manage_addECHO_resourceForm(self):	Line 934 def manage_addECHO_resourceForm(self):



def manage_addECHO_resource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None):	def manage_addECHO_resource(self,id,title,label,description,responsible,link,metalink,weight,resourceID=None,contentType=None,renderingType=None,credits=None,coords=None,RESPONSE=None):
"""addaresource"""	"""addaresource"""

newObj=ECHO_resource(id,link,metalink,title,label,description,contentType,responsible,credits,weight,coords)	newObj=ECHO_resource(id,link,metalink,resourceID,title,label,description,contentType,renderingType,responsible,credits,weight,coords)

self._setObject(id,newObj)	self._setObject(id,newObj)

Line 872 class ECHO_link(ECHO_externalLink):	Line 1048 class ECHO_link(ECHO_externalLink):


def content_html(self):	def content_html(self):
"""template fuer content"""	"""template fuer link"""
	if hasattr(self,"link_template"):
return content_html(self,'link')	return content_html(self,'link')
	else:
	return content_html(self,'collection')

def manage_addECHO_linkForm(self):	def manage_addECHO_linkForm(self):
"""Form for external Links"""	"""Form for external Links"""
Line 894 def manage_addECHO_link(self,id,title,la	Line 1073 def manage_addECHO_link(self,id,title,la

class ECHO_collection(Folder, Persistent, Implicit):	class ECHO_collection(Folder, Persistent, Implicit):
"""ECHO Collection"""	"""ECHO Collection"""

security=ClassSecurityInfo()	security=ClassSecurityInfo()
meta_type='ECHO_collection'	meta_type='ECHO_collection'
viewClassificationList=viewClassificationListMaster	viewClassificationList=viewClassificationListMaster
Line 913 class ECHO_collection(Folder, Persistent	Line 1093 class ECHO_collection(Folder, Persistent
"""title"""	"""title"""
return self.label.encode('utf-8')	return self.label.encode('utf-8')



def createRessourcesFromXMLForm(self):	def createRessourcesFromXMLForm(self):
"""form"""	"""form"""
pt=PageTemplateFile('Products/ECHO_content/zpt/createRessourcesFromXMLForm.zpt').__of__(self)	pt=PageTemplateFile('Products/ECHO_content/zpt/createRessourcesFromXMLForm.zpt').__of__(self)
return pt()	return pt()

def createRessourcesFromXML(self,fileupload):	def createRessourcesFromXML(self,fileupload):
"""read an XML file for generating resources"""	"""read an XML file for generating resources"""
dom=xml.dom.minidom.parse(fileupload)	dom=xml.dom.minidom.parse(fileupload)
Line 980 class ECHO_collection(Folder, Persistent	Line 1163 class ECHO_collection(Folder, Persistent
return ret+"<collection>"+getCollection(self)+"</collection>"	return ret+"<collection>"+getCollection(self)+"</collection>"

def createJavaScript(self):	def createJavaScript(self):
"""CreateJava"""	"""OLD CreateJava"""
ret=javaScriptMain	ret=javaScriptMain

dynamical="\n"	dynamical="\n"
Line 994 class ECHO_collection(Folder, Persistent	Line 1177 class ECHO_collection(Folder, Persistent
return ret	return ret

def createJSAreas(self):	def createJSAreas(self):
"""new version of createJavaScript"""	"""create area calls for JavaScript"""
dynamical="\n"	dynamical="\n"
for ob in self.getGraphicCoords():	for ob in self.getGraphicCoords():
if ob[5] == "area":	if ob[5] == "area":
Line 1004 class ECHO_collection(Folder, Persistent	Line 1187 class ECHO_collection(Folder, Persistent
return dynamical	return dynamical

def createMapHead(self):	def createMapHead(self):
"""generate divs"""	"""create javascript include and script tags for head"""
pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/ECHO_content_map_frag_js')).__of__(self)	pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/ECHO_content_map_frag_js')).__of__(self)
return pt()	return pt()

	def createMapImg(self):
	"""generate img-tag for map"""
	bt = BrowserCheck(self)
	tag = ""
	src = self.REQUEST['URL1'] + "/overview"
	if bt.isN4:
	tag += '<ilayer id="overview" visibility="show"><img src="%s"></ilayer>'%src
	else:
	tag += '<img id="overview" src="%s" />'%src
	return tag

def createMapLink(self, ob, text=None):	def createMapLink(self, ob, text=None):
"""generate map link"""	"""generate map link"""
	bt = BrowserCheck(self)
id = ob[1]	id = ob[1]
link = ob[1]	link = ob[1]
if text == None:	if text == None:
text = ob[2]	text = ob[2]
	tag = ""
	if bt.isN4:
	tag += '<ilayer id="a.%s"><a onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="_blank"'%(id,id,id,link)
	tag += ">" + text + "</a></ilayer>"
	else:
tag = '<a id="a.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="_blank"'%(id,id,id,link)	tag = '<a id="a.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="_blank"'%(id,id,id,link)
if ob[3].contentType == 'text-popup':	if ob[3].contentType == 'text-popup':
tag += ' title="%s"'%ob[3].description	tag += ' title="%s"'%ob[3].description
Line 1026 class ECHO_collection(Folder, Persistent	Line 1226 class ECHO_collection(Folder, Persistent
link = ob[1]	link = ob[1]
vtype = ob[5]	vtype = ob[5]
ctype = ob[3].contentType	ctype = ob[3].contentType
	bt = BrowserCheck(self)
	tag = ""

	if bt.isN4:
	tag += '<layer id="i.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)">'%(id,id,id)
	if vtype == "view point":
	rot = ob[4][4]
	tag += '<a href="%s"><img border="0" src="%s&rot=%s" /></a>'%(link,arrowsrc,rot)
	else:
	tag += '<a href="%s"><img border="0" width="1000" height="1000" src="trans_img"'%(link)
	if ctype == "text-popup":
	desc = ob[3].description
	tag += ' alt="%s"'%desc
	tag += ' /></a>'
	tag += '</layer>'
	else:
tag = '<a id="b.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="_blank">'%(id,id,id,link)	tag = '<a id="b.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="_blank">'%(id,id,id,link)
if vtype == "view point":	if vtype == "view point":
rot = ob[4][4]	rot = ob[4][4]
tag += '<img id="i.%s" src="%s&rot=%s" border="1" style="position:absolute; top:-100px; left:-100px; border-style:none" />'%(id,arrowsrc,rot)	if bt.isIEWin and bt.versIE > 5:
	tag += '<span id="i.%s" style="position:absolute; top:-100px; left:-100px; border-style:none; border-width=1px; filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(src=\'%s&rot=%s\');"><img style="visibility:hidden" src="%s&rot=%s" /></span>'%(id,arrowsrc,rot,arrowsrc,rot)
else:	else:
tag += '<span id="i.%s" style="position:absolute; top:-100px; left:-100px; border-style:none"'%(id)	tag += '<img id="i.%s" src="%s&rot=%s" border="1" style="position:absolute; top:-100px; left:-100px; border-style:none;" />'%(id,arrowsrc,rot)
	else:
	if bt.isIEWin:
	tag += '<div id="i.%s" style="position:absolute; top:-100px; left:-100px;background:url(area_img)"'%(id)
	else:
	tag += '<div id="i.%s" style="position:absolute; top:-100px; left:-100px;"'%(id)
if ctype == "text-popup":	if ctype == "text-popup":
desc = ob[3].description	desc = ob[3].description
tag += ' title="%s"'%desc	tag += ' title="%s"'%desc
tag += ' />'	tag += '> </div>'
tag += '</a>'	tag += '</a>'
return tag	return tag

Line 1213 class ECHO_collection(Folder, Persistent	Line 1434 class ECHO_collection(Folder, Persistent
if RESPONSE is not None:	if RESPONSE is not None:
RESPONSE.redirect('manage_main')	RESPONSE.redirect('manage_main')

security.declarePublic('index_html')


def showOverview(self):	def showOverview(self):
"""overview"""	"""overview"""
Line 1223 class ECHO_collection(Folder, Persistent	Line 1442 class ECHO_collection(Folder, Persistent
pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_content_overview.zpt').__of__(self)	pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_content_overview.zpt').__of__(self)
return pt()	return pt()

	security.declareProtected('View','index_html')

def index_html(self):	def index_html(self):
"""standard page"""	"""standard page"""
Line 1254 class ECHO_collection(Folder, Persistent	Line 1474 class ECHO_collection(Folder, Persistent

def area_img(self):	def area_img(self):
"""area image"""	"""area image"""
	bt = BrowserCheck(self)
	if bt.isIE or bt.isN4:
return sendFile(self, 'images/red.gif', 'image/gif')	return sendFile(self, 'images/red.gif', 'image/gif')
	else:
	return sendFile(self, 'images/reda.png', 'image/png')

	def trans_img(self):
	"""empty image"""
	return sendFile(self, 'images/trans.gif', 'image/gif')

def hl_lib_js(self):	def hl_lib_js(self):
"""javascript"""	"""javascript"""
sendFile(self, 'js/hl_lib.js', 'text/plain')	return sendFile(self, 'js/hl_lib.js', 'text/plain')
return

def js_lib_js(self):	def js_lib_js(self):
"""javascript"""	"""javascript"""
sendFile(self, 'js/js_lib.js', 'text/plain')	return sendFile(self, 'js/js_lib.js', 'text/plain')
return

def getGraphicCoords(self):	def getGraphicCoords(self):
"""Give list of coordinates"""	"""Give list of coordinates"""
Line 1299 class ECHO_collection(Folder, Persistent	Line 1525 class ECHO_collection(Folder, Persistent

getSubCols = ECHO_helpers.getSubCols	getSubCols = ECHO_helpers.getSubCols

	Globals.InitializeClass(ECHO_collection)


def manage_addECHO_collectionForm(self):	def manage_addECHO_collectionForm(self):
"""Add collection form"""	"""Add collection form"""
Line 1321 def manage_addECHO_collection(self,id,ti	Line 1546 def manage_addECHO_collection(self,id,ti

class ECHO_group(ECHO_collection):	class ECHO_group(ECHO_collection):
"""ECHO Gruppe"""	"""ECHO Gruppe"""
	security=ClassSecurityInfo()
meta_type="ECHO_group"	meta_type="ECHO_group"

manage_options = Folder.manage_options+(	manage_options = Folder.manage_options+(
Line 1329 class ECHO_group(ECHO_collection):	Line 1555 class ECHO_group(ECHO_collection):
{'label':'Graphics','action':'ECHO_graphicEntry'},	{'label':'Graphics','action':'ECHO_graphicEntry'},
)	)

	security.declareProtected('View','index_html')
def index_html(self):	def index_html(self):
"""standard page"""	"""standard page"""
displayedObjects=self.ZopeFind(self,obj_metatypes=displayTypes)	displayedObjects=self.ZopeFind(self,obj_metatypes=displayTypes)
Line 1422 def manage_addECHO_group(self,id,title,l	Line 1649 def manage_addECHO_group(self,id,title,l
if RESPONSE is not None:	if RESPONSE is not None:
RESPONSE.redirect('manage_main')	RESPONSE.redirect('manage_main')

	Globals.InitializeClass(ECHO_group)


	class ECHO_userFolder(UserFolder):
	"""User folder for Intranet"""
	_domain_auth_mode=1 # Identification via domain
	meta_type="ECHO_userFolder"

	def authenticate(self, name, password, request):
	emergency = self._emergency_user
	if name is None:
	return None
	if emergency and name==emergency.getUserName():
	user = emergency
	else:
	user = self.getUser(name)
	if user is not None and user.authenticate(password, request):
	return user
	else:
	return None

	def domainSpecMatch(self,spec, request):
	host=''
	addr=''

	# Fast exit for the match-all case
	if len(spec) == 1 and spec[0] == '*':
	return 1

	if request.has_key('REMOTE_HOST'):
	host=request['REMOTE_HOST']

	if request.has_key('REMOTE_ADDR'):
	addr=request['REMOTE_ADDR']

	if request.has_key('HTTP_X_FORWARDED_FOR'):
	addr=request['HTTP_X_FORWARDED_FOR']


	if not host and not addr:
	return 0

	if not host:
	try: host=socket.gethostbyaddr(addr)[0]
	except: pass
	if not addr:
	try: addr=socket.gethostbyname(host)
	except: pass


	_host=host.split('.')
	_addr=addr.split('.')
	_hlen=len(_host)
	_alen=len(_addr)

	for ob in spec:
	sz=len(ob)
	_ob=ob.split('.')
	_sz=len(_ob)

	mo = addr_match(ob)
	if mo is not None:
	if mo.end(0)==sz:
	fail=0
	for i in range(_sz):
	a=_addr[i]
	o=_ob[i]
	if (o != a) and (o != '*'):
	fail=1
	break
	if fail:
	continue
	return 1

	mo = host_match(ob)
	if mo is not None:
	if mo.end(0)==sz:
	if _hlen < _sz:
	continue
	elif _hlen > _sz:
	_item=_host[-_sz:]
	else:
	_item=_host
	fail=0
	for i in range(_sz):
	h=_item[i]
	o=_ob[i]
	if (o != h) and (o != '*'):
	fail=1
	break
	if fail:
	continue
	return 1
	return 0

	Globals.default__class_init__(ECHO_userFolder)



	def manage_addECHO_userFolder(self,dtself=None,REQUEST=None,**ignored):
	"""add a user folder """
	f=ECHO_userFolder()
	self=self.this()
	try: self._setObject('acl_users', f)
	except: return MessageDialog(
	title ='Item Exists',
	message='This object already contains a User Folder',
	action ='%s/manage_main' % REQUEST['URL1'])
	self.__allow_groups__=f
	if REQUEST is not None:
	REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')

	def manage_addECHO_userFolderForm(self):
	"""add a user folder form"""
	return manage_addECHO_userFolder(self)

class ECHO_root(Folder,Persistent,Implicit):	class ECHO_root(Folder,Persistent,Implicit):
"""ECHO Root Folder"""	"""ECHO Root Folder"""

	security=ClassSecurityInfo()

meta_type="ECHO_root"	meta_type="ECHO_root"


	def getBibTag(self,tag,content):
	"""get field tag für index-meta-generation"""
	if not content or content=="":
	return ""
	ret="<%s>"%tag
	ret+=urllib.quote(content)
	ret+="</%s>"%tag
	return ret

	def getValueFromClass(self,field,found):
	"""retattribute falss existing"""
	try:
	return getattr(found,field)
	except:
	return ""

def getImageTag(self):	def getImageTag(self):
"""needed by main_template"""	"""needed by main_template"""
return ""	return ""
Line 1704 class ECHO_root(Folder,Persistent,Implic	Line 2064 class ECHO_root(Folder,Persistent,Implic
ret.append((collection[0].getId(),collection[1].getId(),collection[2]))	ret.append((collection[0].getId(),collection[1].getId(),collection[2]))
return ret	return ret

	def getResourcesHTML(self,viewerType=None,filter=None):
	"""gebe all ressourcen aus"""

	def sortHTML(x,y):
	return cmp(x[1].title,y[1].title)

	ret="""<html><body><h2>Resources in ECHO</h3>"""

	resources = self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
	ret+="""<h3>Found %i resources</h3>"""%len(resources)
	resources.sort(sortHTML)
	for resource in resources:
	echo_url=resource[1].absolute_url()

	if hasattr(resource[1],'title'):
	title=resource[1].title
	else:
	title="None"
	if filter:
	if re.search(filter,title):
	ret+="""\n<p><a href="%s">%s</a></p>"""%(echo_url,title)
	else:
	ret+="""\n<p><a href="%s">%s</a></p>"""%(echo_url,title)

	ret +="""\n</body></html>"""

	#self.REQUEST.RESPONSE.setHeader("Content-Type", "text/html")
	#self.REQUEST.RESPONSE.write(ret)
	return ret

	def getResourcesXML(self,viewerType=None,filter=None):
	"""gebe all ressourcen aus"""
	ret="""<?xml version="1.0" ?>
	<index>"""
	for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):

	echo_url=resource[1].absolute_url()
	if hasattr(resource[1],'link'):
	viewer_url=resource[1].link
	else:
	viewer_url="NO URL"
	if filter:
	if re.search(filter,viewer_url):
	ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
	else:
	ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
	ret +="""\n</index>"""

	self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")
	self.REQUEST.RESPONSE.write(ret)

	def getFullTextsXML(self,viewerType=None,filter=None):
	"""gebe all ressourcen aus"""
	ret="""<?xml version="1.0" ?>
	<index>"""
	for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):

	echo_url=resource[1].absolute_url()
	if resource[1].getFullTextXML(noredirect="yes"):
	if hasattr(resource[1],'link'):
	viewer_url=echo_url+"/getFullTextXML"
	else:
	viewer_url="NO URL"
	if filter:
	if re.search(filter,viewer_url):
	ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
	else:
	ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))
	ret +="""\n</index>"""


	self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")
	self.REQUEST.RESPONSE.write(ret)

def manage_addECHO_root(self,id,title,RESPONSE=None):	def manage_addECHO_root(self,id,title,RESPONSE=None):
"""Add an ECHO_root"""	"""Add an ECHO_root"""

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

Removed from v.1.78
changed lines
	Added in v.1.90