--- ECHO_content/ECHO_helpers.py	2004/10/28 13:38:40	1.24
+++ ECHO_content/ECHO_helpers.py	2004/11/24 15:16:33	1.25
@@ -2,6 +2,73 @@ import socket
 import urllib
 import xml.dom.minidom
 from types import *
+from Products.PageTemplates.PageTemplateFile import PageTemplateFile
+from Globals import package_home
+import os.path
+
+displayTypes = ['ZSQLExtendFolder','ZSQLBibliography','ECHO_group','ECHO_collection','ECHO_resource','ECHO_link','ECHO_sqlElement','ECHO_pageTemplate','ECHO_externalLink','ImageCollectionIFrame','VLP_resource','VLP_essay','ECHO_ZCatalogElement','ImageCollection','versionedFileFolder']
+
+def content_html(self,type):
+        """template fuer content"""
+        #templates = self.ZopeFind(self.aq_parent,obj_ids=[type+"_template"])
+        #
+        #if templates:
+        #    return templates[0][1]()
+
+        if hasattr(self,type+"_template"):
+            obj=getattr(self,type+"_template")
+            return obj()
+        else:
+            pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_%s_template_standard.zpt'%type).__of__(self)
+            pt.content_type="text/html"
+            return pt()
+    
+    
+
+class ECHO_basis:
+    """basis eigenschaften fuer echo objekte"""
+    
+    def content_html(self,type="collection"):
+	    """template fuer content bei einbau und ECHO_Umgebung"""
+	    
+	    return content_html(self,type)
+        
+    def getTitle(self):
+	"""title"""
+	try:
+		return self.title.encode('utf-8','ignore') 
+	except:
+		self.title=self.title.decode('iso-8859-1','ignore')[0:] #correnct conding error
+		return self.title.encode('utf-8','ignore') 
+	
+    def getLabel(self):
+	"""title"""
+	try:
+		return self.label.encode('utf-8','ignore') 
+	except:
+		self.label=self.label.decode('iso-8859-1','ignore')[0:] #correnct conding error
+		return self.label.encode('utf-8','ignore') 
+	
+    
+    def changeECHOEntriesForm(self):
+        """change Entries for the ECHO Navigation environment"""
+        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeECHOEntriesForm')).__of__(self)
+        return pt()
+    
+    def changeECHOEntries(self,label,weight,description,RESPONSE=None):
+        """change Entries for the ECHO Navigation environment
+        @param label: label fuer die Navigation"""
+        self.label=label
+        self.weight=weight
+        self.description=description
+        
+        if RESPONSE:
+            RESPONSE.redirect("manage_main")
+
+    manage_options=({'label':'change ECHO Navigation Entries','action':'changeECHOEntriesForm'},)
+
+    #ende der echo erweiterungen
+
 
 def toList(field):
     """Einzelfeld in Liste umwandeln"""
@@ -18,6 +85,14 @@ def getText(nodelist):
            rc = rc + node.data
     return rc
 
+def getTextFromNode(nodename):
+    nodelist=nodename.childNodes
+    rc = ""
+    for node in nodelist:
+    	if node.nodeType == node.TEXT_NODE:
+           rc = rc + node.data
+    return rc
+
 
 def readFieldFromXML(meta_url,parent,field):
 	"""lesespezifisches metadatum"""
@@ -59,7 +134,7 @@ def urlopen(url):
 #		return None
 
 
-displayTypes = ['ZSQLExtendFolder','ZSQLBibliography','ECHO_group','ECHO_collection','ECHO_resource','ECHO_link','ECHO_sqlElement','ECHO_pageTemplate','ImageCollectionIFrame','VLP_resource','VLP_essay','ECHO_ZCatalogElement']
+
 
 
 def checkOnlyOneInGroup(object): 
@@ -79,13 +154,10 @@ def getSubCols(self,sortfield="weight",s
 	
 	
 	for entry in displayedObjects:
+            
             object=entry[1]
-            try:
-                if object.meta_type in subColTypes:
-			ids.append(object)
-                    
-            except:
-                """nothing"""
+            ids.append(object)
+
         try:
             sortfield=self.sortfield
         except:
@@ -104,4 +176,356 @@ def getSubCols(self,sortfield="weight",s
                 tmp=10000000
             tmplist.append((tmp,x))
         tmplist.sort()
+
         return [x for (key,x) in tmplist]
+
+def ECHO_rerenderLinksMD(self,obj=None,types=['title','label']):
+        """Rerender all Links"""
+	ret=""
+	
+        if not obj:
+            obj = self
+            
+        entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource'],search_sub=1)
+
+        for entry in entries:
+		if entry[1].meta_type == 'ECHO_resource':
+			try:
+				entry[1].ECHO_getResourceMD(template="no")
+                                if "title" in types:
+                                    entry[1].generate_title()
+                                if "label" in types:
+                                    entry[1].generate_label()
+				ret+="OK:"+entry[0]+"-- "+entry[1].getTitle().decode('utf-8')+"-- "+entry[1].getTitle().decode('utf-8')+"<br>"
+			except:
+				ret+="Error:"+entry[0]+"<br>"
+
+		
+                
+                
+        return "<html><body>"+ret+"Rerenderd all links to resources in: "+self.title+"</html></body>"
+
+def reloadMetaDataFromStorage(self,RESPONSE=None):
+	    """copy metadata from the storage to ECHO"""
+	    ret=""
+	    resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
+
+	    for resource in resources:
+		    x=str(resource[1].copyIndex_meta2echo_resource())+"<br>"
+		    ret+=x
+		    #print x
+		    
+
+	    if RESPONSE is not None:
+		    #RESPONSE.redirect('./manage_main')
+		    return "<html><body>"+ret+"</html></body>"
+
+	    return ret
+    
+def getRDFDescription(self,linkURL,urn=None,nameDef=None,typeName=None):
+	    """rdf"""
+	    
+	    ret=""
+	    about="""<RDF:Description RDF:about="%s">"""
+	    name="""<ECHONAVIGATION:name>%s</ECHONAVIGATION:name>"""
+	    link="""<ECHONAVIGATION:link xlink:href="%s">%s</ECHONAVIGATION:link>"""
+	    clickable="""<ECHONAVIGATION:linkClickable>%s</ECHONAVIGATION:linkClickable>"""
+	    #link="""<ECHONAVIGATION:link RDF:about="%s"/>"""
+	    type="""<ECHONAVIGATION:type>%s</ECHONAVIGATION:type>"""
+            #xlink="""<ECHONAVIGATION:xlink xlink:href="%s"/>"""	
+	    if not urn:
+		    #urn="urn:"+re.sub('/',':',self.absolute_url())
+		    urn=self.absolute_url()
+	    about2=about%urn
+	    if not nameDef:
+		    if hasattr(self,'label') and not (self.label==""):
+			    name2=name%self.label
+		    elif not self.title=="":
+			    name2=name%self.title
+		    else:
+			    name2=name%self.getId()
+
+		    name2=re.sub('&','&amp;',name2)
+	    else:
+		    name2=name%nameDef
+
+	    linkURL=re.sub('http:','',linkURL)
+	    linkURL2=re.sub('&','&amp;',linkURL)
+	    link2=link%(("http:"+linkURL2),("http:"+urllib.quote(linkURL)))
+	    clickable2=clickable%"true"
+
+	    if not typeName:
+		    type2=type%self.meta_type
+	    else:
+		    type2=type%typeName
+	    
+	    #ret=about2+"\n"+name2+"\n"+link2+"\n"+type2+"\n"+clickable2+"\n</RDF:Description>"
+	    ret=about2+"\n"+name2+"\n"+type2+"\n"+clickable2+"\n</RDF:Description>"
+	    return ret
+    
+def getCopyrightsFromForm(self,argv): 
+	medias={}
+	partners={}
+	copyrights={}
+	
+	copyrightsFinal=[]
+	for arg in argv.keys():
+		
+		if arg[0:5]=='media':
+			nm=int(arg[5:])
+			medias[nm]=argv[arg]
+		elif arg[0:5]=='partn':
+			nm=int(arg[5:])
+			partners[nm]=argv[arg]
+		elif arg[0:5]=='copyr':
+			nm=int(arg[5:])
+			copyrights[nm]=argv[arg]
+
+
+
+	copyrightsList=[(medias[nm],partners[nm],copyrights[nm]) for nm in medias.keys()]
+	for copyright in copyrightsList:
+		
+		if copyright[2]=='institution0000':
+			copyrightsFinal.append((copyright[0],copyright[1],self.getPartnerCopyright(copyright[1],'')))
+		else:
+			if not copyright[0]=='':
+				copyrightsFinal.append(copyright)
+		
+			
+	return copyrightsFinal
+
+#List of different types for the graphical linking viewer
+viewClassificationListMaster=['view point','area']
+
+
+def checkDiffs(self,metadict):
+	    """check differences"""
+
+	    
+
+    
+	    def NoneToEmpty(obj):
+		    if obj:
+			    return obj
+		    else:
+			    return ""
+
+	    
+	    
+	    diffs={}
+	    
+	    tags=self.findTagsFromMapping(self.contentType)
+	    self.referencetypes=tags[2]
+	    self.fields=tags[3]
+	    
+    
+	    for field in tags[1]:
+		    try:
+			    if (NoneToEmpty(self.getFieldValue(self.getFieldTag(tags,field)))==metadict[self.getFieldTag(tags,field)]):
+				    diffs[self.getFieldTag(tags,field)]=1
+			    else:
+				    
+				    diffs[self.getFieldTag(tags,field)]=0
+		    except:
+			    diffs[self.getFieldTag(tags,field)]=0
+			    
+	    return diffs
+    
+
+
+
+def sendFile(self, filename, type):
+    """sends an object or a local file (in the product) as response"""
+    paths = filename.split('/')
+    object = self
+    # look for an object called filename
+    for path in paths:
+        if hasattr(object, path):
+	    object = getattr(object, path)
+	else:
+	    object = None
+	    break
+    if object:
+	# if the object exists then send it
+	return object.index_html(self.REQUEST.REQUEST, self.REQUEST.RESPONSE)
+    else:
+	# send a local file with the given content-type
+	fn = os.path.join(package_home(globals()), filename)
+	self.REQUEST.RESPONSE.setHeader("Content-Type", type)
+	self.REQUEST.RESPONSE.write(file(fn).read())
+    return
+
+class BrowserCheck:
+    """check the browsers request to find out the browser type"""
+    
+    def __init__(self, zope):
+        """initialisiere"""
+	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,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None,xmlfrag=None,digiliburlprefix=None):
+	"""Einlesen der Metadaten und und erstellen des geaenderten XML file"""
+
+	def updateTextToolNode(tag,value):
+		#print dom,tag,value
+		metanode=dom.getElementsByTagName('texttool')[0]
+		try:
+			nodeOld=metanode.getElementsByTagName(tag)
+		except:
+			nodeOld=None
+			
+		if nodeOld:
+			metanode.removeChild(nodeOld[0]).unlink()
+
+		node=dom.createElement(tag)
+		nodetext=dom.createTextNode(value)
+		node.appendChild(nodetext)
+		metanode.appendChild(node)
+
+	if xmlfrag:
+		geturl="""<?xml version="1.0" ?>
+                           <resource type="MPIWG">
+			   <meta>
+			    <bib type="Book">
+	                    </bib>
+			    </meta>
+			    </resource>"""
+		dom=xml.dom.minidom.parseString(geturl)
+	else:
+		try:
+			geturl=""
+			for line in ECHO_helpers.urlopen(url).readlines():
+				geturl=geturl+line
+
+
+		except:
+			return (None,"Cannot open: "+url)
+
+		try:
+			dom=xml.dom.minidom.parseString(geturl)
+		except:
+			return (None,"Cannot parse: "+url+"<br>"+geturl)
+
+	
+
+	metanodes=dom.getElementsByTagName('bib')
+
+	if not metanodes:
+		metanodes=dom.getElementsByTagName('archimedes')
+
+	metanode=metanodes[0]
+
+	for metaData in metadict.keys():
+		
+		try:
+			nodeOld=metanode.getElementsByTagName(metaData)
+		except:
+			nodeOld=None
+			
+		if nodeOld:
+			metanode.removeChild(nodeOld[0]).unlink()
+		else:
+			# try also old writing rule - instead of _:
+			try:
+				nodeOld=metanode.getElementsByTagName(re.sub('_','-',metaData))
+			except:
+				nodeOld=None
+				
+			if nodeOld:
+				metanode.removeChild(nodeOld[0]).unlink()
+
+		metanodeneu=dom.createElement(metaData)
+                metanodetext=dom.createTextNode(metadict[metaData])
+		#try:
+			#metanodetext=dom.createTextNode(unicode(metadict[metaData],"utf-8"))
+		#except:
+			#metanodetext=dom.createTextNode(metadict[metaData].encode('utf-8'))
+		metanodeneu.appendChild(metanodetext)
+		metanode.appendChild(metanodeneu)
+
+
+	
+	
+	
+	if project:
+		updateTextToolNode('project',project)
+
+	if startpage:
+		updateTextToolNode('startpage',startpage)
+
+	if topbar:
+		updateTextToolNode('toptemplate',topbar)
+
+	if thumbtemplate:
+		updateTextToolNode('thumbtemplate',thumbtemplate)
+
+	if xslt:
+		updateTextToolNode('xslt',xslt)
+
+	
+	if digiliburlprefix:
+		updateTextToolNode('digiliburlprefix',digiliburlprefix)
+	
+        try:	
+	 return dom.toxml().encode('utf-8')
+	except:
+	 return dom.toxml('utf-8')
+
+	
+	
+def readMetadata(url):
+    """Methode zum Auslesen der Metadateninformation zu einer Resource
+    Vorerst noch Typ bib"""
+    
+    metadict={}
+    try:
+        geturl=""
+        for line in ECHO_helpers.urlopen(url).readlines():
+            geturl=geturl+line
+        
+        
+    except:
+        return (None,"Cannot open: "+url)
+
+    try:
+        dom=xml.dom.minidom.parseString(geturl)
+    except:
+        return (None,"Cannot parse: "+url+"<br>"+geturl)
+
+    metanode=dom.getElementsByTagName('bib')
+    metadict['bib_type']='Book'
+    if len(metanode)==0:
+        metanode=dom.getElementsByTagName('archimedes')
+        metadict['bib_type']='Archimedes'
+        
+        
+    if not len(metanode)==0:    
+        metacontent=metanode[0].childNodes
+    
+        try:
+            metadict['bib_type']=getText(dom.getElementsByTagName('bib')[0].attributes['type'].childNodes)
+        except:
+            """nothing"""
+        
+        for node in metacontent:
+            try:
+		    #print urllib.unquote(getText(node.childNodes)),getText(node.childNodes)
+		    metadict[re.sub('-','_',node.tagName.lower())]=urllib.unquote(getText(node.childNodes))
+            except:
+                """nothing"""
+
+
+    return metadict,""
+