version 1.3, 2005/02/11 20:06:57
|
version 1.18, 2010/09/01 13:26:16
|
Line 6 from OFS.Folder import Folder
|
Line 6 from OFS.Folder import Folder
|
from AccessControl import ClassSecurityInfo |
from AccessControl import ClassSecurityInfo |
from Products.PageTemplates.PageTemplateFile import PageTemplateFile |
from Products.PageTemplates.PageTemplateFile import PageTemplateFile |
import os.path |
import os.path |
|
import sys |
import xml.dom.minidom |
import xml.dom.minidom |
|
import xml.dom.pulldom |
import OSAS_helpers |
import OSAS_helpers |
import zLOG |
import logging |
|
|
|
#ersetzt logging |
|
def logger(txt,method,txt2): |
|
"""logging""" |
|
logging.info(txt+ txt2) |
|
|
|
|
|
import string |
|
try: |
|
from xml.xpath import Evaluate |
|
except: |
|
from Ft.Xml.XPath import Evaluate |
|
import xmlrpclib |
|
|
|
from types import * |
|
|
class OSAS_MetadataMapping(SimpleItem): |
class OSAS_MetadataMapping(SimpleItem): |
"""Einfaches Mapping Object""" |
"""Einfaches Mapping Object""" |
Line 59 class OSAS_MetadataMapping(SimpleItem):
|
Line 76 class OSAS_MetadataMapping(SimpleItem):
|
@param fieldName: Bezeichnung des gesuchten Metadatums |
@param fieldName: Bezeichnung des gesuchten Metadatums |
@retunr: Value des Metadatums""" |
@retunr: Value des Metadatums""" |
|
|
return getattr(self,"md_"+fieldName,(None,None,None)) |
ret= getattr(self,"md_"+fieldName,(None,None,None,None,None)) |
|
if len(ret)!= 4: # alte MD haben keine info ueber optional/required und listen werte |
|
ret=ret+("","") |
|
return ret |
|
|
|
|
def isEmptyValue(self,fieldName): |
def isEmptyValue(self,fieldName): |
Line 91 class OSAS_MetadataMapping(SimpleItem):
|
Line 111 class OSAS_MetadataMapping(SimpleItem):
|
arglist=self.REQUEST.form |
arglist=self.REQUEST.form |
|
|
for fieldName in self.readFieldsFromParent(): |
for fieldName in self.readFieldsFromParent(): |
setattr(self,"md_"+fieldName,(arglist[fieldName],arglist['label_'+fieldName],arglist['explanation_'+fieldName])) |
setattr(self,"md_"+fieldName,(arglist[fieldName],arglist['label_'+fieldName],arglist['explanation_'+fieldName],arglist['status_'+fieldName],arglist['values_'+fieldName])) |
|
|
|
|
if RESPONSE is not None: |
if RESPONSE is not None: |
RESPONSE.redirect('manage_main') |
RESPONSE.redirect('manage_main') |
|
|
|
manage_workspace=changeMetadataMappingForm |
|
|
def manage_addMetadataMappingForm(self): |
def manage_addMetadataMappingForm(self): |
"""interface for adding the OSAS_root""" |
"""interface for adding the OSAS_root""" |
Line 111 def manage_addMetadataMapping(self,idOfO
|
Line 131 def manage_addMetadataMapping(self,idOfO
|
argList={} |
argList={} |
for arg in self.fieldList: |
for arg in self.fieldList: |
if not (arg in ['idOfObject','titleOfObject']): |
if not (arg in ['idOfObject','titleOfObject']): |
argList[arg]=(self.REQUEST.form[arg],self.REQUEST.form['label_'+arg],self.REQUEST.form['explanation_'+arg]) |
argList[arg]=(self.REQUEST.form[arg],self.REQUEST.form['label_'+arg],self.REQUEST.form['explanation_'+arg],self.REQUEST.form['status_'+arg],self.REQUEST.form['values_'+arg]) |
|
|
newObj=OSAS_MetadataMapping(idOfObject,titleOfObject,argList) |
newObj=OSAS_MetadataMapping(idOfObject,titleOfObject,argList) |
self._setObject(idOfObject,newObj) |
self._setObject(idOfObject,newObj) |
Line 121 def manage_addMetadataMapping(self,idOfO
|
Line 141 def manage_addMetadataMapping(self,idOfO
|
|
|
|
|
class OSAS_Metadata(Folder): |
class OSAS_Metadata(Folder): |
"""Foldertype enthält methoden zur Halbautomatischen Erstellung von Metadatenfiles""" |
"""Foldertype enthaelt methoden zur Halbautomatischen Erstellung von Metadatenfiles""" |
security=ClassSecurityInfo() |
security=ClassSecurityInfo() |
|
|
def __init__(self,id,linklabel,description,fields): |
def __init__(self,id,shortDescription,description,fields): |
"""initialize a new instance""" |
"""initialize a new instance""" |
self.id = id |
self.id = id |
self.linklabel =linklabel #label fuer link auf add page |
self.shortDescription =shortDescription #label fuer link auf add page |
self.description=description #description of the method for link page |
self.description=description #description of the method for link page |
self.fieldList=fields.split(",")[0:] |
self.fieldList=fields.split(",")[0:] |
|
|
Line 153 class OSAS_Metadata(Folder):
|
Line 173 class OSAS_Metadata(Folder):
|
self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml') |
self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml') |
return ret |
return ret |
|
|
def showOverviewXML(self,RESPONSE): |
|
|
def showOverviewXML(self,RESPONSE=None,wrapped=False): |
"""gives an overview over the Metadata stored in this folder""" |
"""gives an overview over the Metadata stored in this folder""" |
ret="""<metadata name="%s">"""%self.getId() |
ret="" |
|
if wrapped: |
|
ret+="""<metadataExport>""" |
|
ret+="""<metadata name="%s">"""%self.getId() |
ret+=self.showGenericXML() |
ret+=self.showGenericXML() |
for entry in self.ZopeFind(self,obj_metatypes=['OSAS_MetadataMapping']): |
for entry in self.ZopeFind(self,obj_metatypes=['OSAS_MetadataMapping__neu']): |
ret+=entry[1].showSetXML() |
ret+=entry[1].showSetXML() |
|
|
|
for entry in self.ZopeFind(self,obj_metatypes=['OSAS_Metadata__neu']): |
|
ret+=entry[1].showOverviewXML() |
|
|
ret+="</metadata>" |
ret+="</metadata>" |
|
|
|
if wrapped: |
|
ret+="""</metadataExport>""" |
if not RESPONSE: |
if not RESPONSE: |
return ret |
return ret |
else: |
else: |
self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml') |
RESPONSE.setHeader('Content-Type','text/xml') |
return ret |
return ret |
|
|
def generateMappingList(self): |
def generateMappingList(self): |
"""Erzeuge Mapping""" |
"""Erzeuge Mapping""" |
mapping={} |
mapping={} |
|
|
for dict in self.__dict__: |
for dict in self.__dict__: |
#print dict |
#print dict |
obj=getattr(self,dict) |
obj=getattr(self,dict) |
if hasattr(obj,'meta_type'): |
if hasattr(obj,'meta_type'): |
if obj.meta_type=="OSAS_MetadataMapping": |
logging.debug("generateMappungList read type:"+repr(obj.meta_type)) |
|
if ((obj.meta_type=="OSAS_MetadataMapping__neu") or (obj.meta_type=="MetadataMapping")): #metadatamapping is the newer type |
|
logging.debug("generateMappungListadded:"+repr(obj.getId())) |
mapping[obj.getId()]=obj.generateMappingHash() |
mapping[obj.getId()]=obj.generateMappingHash() |
|
|
return mapping |
return mapping |
|
|
def generateMappingForType(self,type,clean="yes"): |
def generateMappingForType(self,type,clean="yes"): |
"""erzeuge spezifisches Mapping""" |
"""erzeuge spezifisches Mapping""" |
|
|
hash=self.generateMappingList() |
hash=self.generateMappingList() |
if hash.has_key(type): |
logging.debug("generateMappingForType:"+type) |
|
for key in hash.keys(): |
|
logging.debug("generateMappingForType comparing:"+key.lower()+type.lower()) |
|
if (key.lower() == type.lower()): |
if clean=="yes": |
if clean=="yes": |
temp={} |
temp={} |
for x in hash[type].keys(): |
for x in hash[key].keys(): |
if not hash[type][x]=="": |
if not hash[key][x]=="": |
temp[x]=hash[type][x] |
temp[x]=hash[key][x] |
return temp |
return temp |
else: |
else: |
return hash[type] |
|
|
|
else: |
return hash[key] |
|
|
return {} |
return {} |
|
|
def getFieldList(self): |
def getFieldList(self): |
Line 202 class OSAS_Metadata(Folder):
|
Line 239 class OSAS_Metadata(Folder):
|
except: |
except: |
return "" |
return "" |
|
|
|
security.declarePublic('getFields') |
def getFields(self): |
def getFields(self): |
"""ausgabe der Felder""" |
"""ausgabe der Felder""" |
return self.fieldList |
return self.fieldList |
Line 214 class OSAS_Metadata(Folder):
|
Line 252 class OSAS_Metadata(Folder):
|
except: |
except: |
return id |
return id |
|
|
|
def getType(self,type): |
|
"""gib metadataobject type zurueck""" |
|
|
|
for obj in self.ZopeFind(self,obj_metatypes=['OSAS_MetadataMapping__neu']): |
|
if obj[0]==type: |
|
return obj |
|
return (self.id,self) |
|
|
|
|
|
|
def getStoredTypes(self): |
def getStoredTypes(self): |
"""Gebe gespeicherte typen zurück""" |
"""Gebe gespeicherte typen zurueck""" |
|
|
types=[] |
types=[] |
|
|
for obj in self.ZopeFind(self,obj_metatypes=['OSAS_MetadataMapping_neu']): |
for obj in self.ZopeFind(self,obj_metatypes=['OSAS_MetadataMapping__neu']): |
if obj.title=="": |
if obj[1].title=="": |
title=obj.id |
title=obj[1].id |
else: |
else: |
title=obj.title |
title=obj[1].title |
types.append((obj.id,title)) |
types.append((obj[1].id, title, obj[1])) |
|
|
return types |
return types |
|
|
Line 242 class OSAS_Metadata(Folder):
|
Line 290 class OSAS_Metadata(Folder):
|
RESPONSE.redirect('manage_main') |
RESPONSE.redirect('manage_main') |
|
|
def getDisplayFieldsAsStr(self,indexMeta): |
def getDisplayFieldsAsStr(self,indexMeta): |
"""Gebe display fields als string zurück |
ret=[] |
|
try: |
|
if indexMeta and not (indexMeta==""): |
|
dom=xml.dom.pulldom.parseString(indexMeta) |
|
|
|
for (event,node) in dom: |
|
|
|
if event == xml.dom.pulldom.START_ELEMENT and node.tagName=="bib": |
|
dom.expandNode(node) |
|
|
|
try: |
|
type=node.getAttribute('type') |
|
mapping=getattr(self,type).generateMappingHash() |
|
except: |
|
type='generic' |
|
mapping=getattr(self,type).generateMappingHash() |
|
|
|
for field in self.displayFields: |
|
try: |
|
ret.append(OSAS_helpers.getText(node.getElementsByTagName(mapping[field][0])[0].childNodes)) |
|
except: |
|
"""nothing""" |
|
|
|
return "; ".join(ret) |
|
else: |
|
return "" |
|
except: |
|
return "" |
|
def getDisplayFieldsAsStrOLD(self,indexMeta): |
|
"""Gebe display fields als string zurueck |
@param path: Pfad zum Object |
@param path: Pfad zum Object |
""" |
""" |
ret=[] |
ret=[] |
try: |
try: |
dom=xml.dom.minidom.parseString(indexMeta) |
dom=xml.dom.minidom.parseString(indexMeta) |
except: |
except: |
zLOG.LOG("OSAS_metadata (getDisplayFieldsAsStr)",zLOG.INFO,"Cannot parse: %s"%indexMeta) |
logger("OSAS_metadata (getDisplayFieldsAsStr)",logging.INFO,"Cannot parse: %s"%indexMeta) |
try: |
try: |
bib = dom.getElementsByTagName("meta")[0].getElementsByTagName("bib")[0] |
bib = dom.getElementsByTagName("meta")[0].getElementsByTagName("bib")[0] |
except: |
except: |
Line 276 class OSAS_Metadata(Folder):
|
Line 353 class OSAS_Metadata(Folder):
|
return pt() |
return pt() |
|
|
security.declarePublic('changeMetadata') |
security.declarePublic('changeMetadata') |
def changeMetadata(self,linklabel,description,fields,RESPONSE=None): |
def changeMetadata(self,shortDescription,description,fields,RESPONSE=None): |
"""Change Metadata""" |
"""Change Metadata""" |
self.linklabel=linklabel |
self.shortDescription=shortDescription |
self.description=description |
self.description=description |
self.fieldList=fields.split(",")[0:] |
self.fieldList=fields.split(",")[0:] |
if RESPONSE is not None: |
if RESPONSE is not None: |
Line 291 class OSAS_Metadata(Folder):
|
Line 368 class OSAS_Metadata(Folder):
|
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','importXMLSchemaForm.zpt')).__of__(self) |
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','importXMLSchemaForm.zpt')).__of__(self) |
return pt() |
return pt() |
|
|
|
|
def importXMLSchema(self,file,RESPONSE=None): |
def importXMLSchema(self,file,RESPONSE=None): |
"""import xmlschema, Metadatenschema wird eingelesen und entsprechende Metadatenmappings angelegt.""" |
"""import xmlschema, Metadatenschema wird eingelesen und entsprechende Metadatenmappings angelegt.""" |
|
|
Line 320 class OSAS_Metadata(Folder):
|
Line 398 class OSAS_Metadata(Folder):
|
RESPONSE.write("Wrote: %s"%id) |
RESPONSE.write("Wrote: %s"%id) |
|
|
|
|
|
def createMetadataFragment(self,type,path,prefix="",presets={}): |
|
"""fragment""" |
|
self.REQUEST.SESSION['MDF_type']=type |
|
self.REQUEST.SESSION['MDF_path']=path |
|
self.REQUEST.SESSION['MDF_prefix']=prefix |
|
self.REQUEST.SESSION['MDF_presets']=presets |
|
|
|
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMetadataForm_fragment.zpt')).__of__(self) |
|
return pt() |
|
|
|
def createMetadataForm(self,type="",path=""): |
|
"""createMetadataForm""" |
|
self.REQUEST.SESSION['MDF_type']=type |
|
self.REQUEST.SESSION['MDF_path']=path |
|
|
|
|
|
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMetadataForm_template.zpt')).__of__(self) |
|
return pt() |
|
|
|
def readMetadata(self,MDF_path,MDF_type,MDF_prefix="",MDF_xpathStart="", MDF_addPath=None,MDF_identifyFields=None,newdoc=None,actualNode=None): |
|
|
|
if type(MDF_path)==ListType: |
|
MDF_path=MDF_path[0] |
|
|
|
indexFile=os.path.join(MDF_path,'index.meta') |
|
|
|
server=xmlrpclib.Server(self.serverUrl) |
|
|
|
documentStr=server.getFile(indexFile) |
|
|
|
if documentStr: |
|
newdoc=xml.dom.minidom.parseString(documentStr) |
|
dom=newdoc.documentElement |
|
actualNode=dom |
|
else: |
|
return {} |
|
|
|
if self.containerTag=="": |
|
containerTag="doc" |
|
else: |
|
containerTag=self.containerTag |
|
|
|
if MDF_xpathStart=="": |
|
dom=newdoc.documentElement |
|
actualNode=dom |
|
else: |
|
#try to find xpath |
|
if MDF_identifyFields: |
|
query=[] |
|
for field in MDF_identifyFields.keys(): |
|
|
|
query.append("""(%s="%s")"""%(field,MDF_identifyFields[field])) |
|
querystr=" and ".join(query) |
|
xpathStr=MDF_xpathStart+"[%s]"%querystr |
|
|
|
else: |
|
xpathStr=MDF_xpathStart |
|
|
|
|
|
xpathNodes=Evaluate(xpathStr,actualNode) |
|
|
|
|
|
if len(xpathNodes)>0: |
|
actualNode=xpathNodes[0] |
|
else: |
|
return {} |
|
|
|
ret={} |
|
for node in actualNode.childNodes: |
|
name=node.tagName |
|
text=OSAS_helpers.getText(node.childNodes) |
|
ret[name]=text |
|
|
|
return ret |
|
|
|
def writeMetadata(self,MDF_path,MDF_type,form,MDF_prefix="",MDF_xpathStart="", MDF_addPath=None,MDF_identifyFields=None,newdoc=None,actualNode=None): |
|
"""writeMetadata""" |
|
#MDF_path="/tmp/index.meta" |
|
if type(MDF_path)==ListType: |
|
MDF_path=MDF_path[0] |
|
|
|
|
|
indexFile=os.path.join(MDF_path,'index.meta') |
|
|
|
server=xmlrpclib.Server(self.serverUrl) |
|
if newdoc: |
|
if not actualNode: actualNode=newdoc |
|
dom=newdoc |
|
else: |
|
documentStr=server.getFile(indexFile) |
|
|
|
if documentStr: |
|
|
|
newdoc=xml.dom.minidom.parseString(documentStr) |
|
dom=newdoc.documentElement |
|
actualNode=dom |
|
|
|
|
|
else: |
|
|
|
impl=xml.dom.minidom.getDOMImplementation() |
|
newdoc=None |
|
|
|
|
|
if self.containerTag=="": |
|
containerTag="doc" |
|
else: |
|
containerTag=self.containerTag |
|
|
|
create=None |
|
if MDF_xpathStart=="": |
|
if not newdoc: |
|
newdoc=impl.createDocument(None,containerTag,None) |
|
dom=newdoc.documentElement |
|
actualNode=dom |
|
else: |
|
|
|
#try to find xpath |
|
if MDF_identifyFields: |
|
query=[] |
|
for field in MDF_identifyFields: |
|
|
|
query.append("""(%s="%s")"""%(field,form[MDF_prefix+"MD_"+field])) |
|
querystr=" and ".join(query) |
|
xpathStr=MDF_xpathStart+"[%s]"%querystr |
|
|
|
else: |
|
xpathStr=MDF_xpathStart |
|
|
|
|
|
xpathNodes=Evaluate(xpathStr,actualNode) |
|
|
|
|
|
|
|
|
|
if len(xpathNodes)>0: |
|
actualNode=xpathNodes[0] |
|
|
|
else: |
|
#existiert nicht dann neue erzeugen |
|
|
|
if len(Evaluate(MDF_xpathStart,dom))>0: |
|
|
|
create=True |
|
|
|
splitted=MDF_xpathStart.split("/") |
|
base="" |
|
for element in splitted: |
|
|
|
if not (element=="") and not (element==containerTag): |
|
base="/".join([base,element]) |
|
|
|
if not newdoc: |
|
newdoc=impl.createDocument(None,element,None) |
|
actualNode=newdoc.documentElement |
|
dom=actualNode |
|
else: |
|
changed=None |
|
|
|
if not (MDF_addPath==base): |
|
|
|
|
|
for childNode in actualNode.childNodes: |
|
if getattr(childNode,'tagName','')==element: |
|
actualNode=childNode |
|
changed=1 |
|
|
|
if (os.path.normpath("/".join(["",containerTag,base]))==MDF_xpathStart) and create: |
|
actualNode=actualNode.parentNode |
|
changed=None |
|
|
|
if not changed: |
|
namenode=newdoc.createElement(element) |
|
|
|
actualNode.appendChild(namenode) |
|
actualNode=namenode |
|
|
|
|
|
|
|
|
|
for name in self.REQUEST.form.keys(): |
|
length=len(MDF_prefix) |
|
if MDF_type and not (MDF_type == ""): |
|
actualNode.setAttribute("type",MDF_type) |
|
if name[0:3+length]==MDF_prefix+"MD_": |
|
tagName=name[3+length:] |
|
|
|
#CHECK if element exists |
|
for childNode in actualNode.childNodes: |
|
if getattr(childNode,'tagName','')==tagName: |
|
actualNode.removeChild(childNode).unlink() |
|
|
|
namenode=newdoc.createElement(tagName) |
|
namenodetext=newdoc.createTextNode(self.REQUEST.form[name]) |
|
namenode.appendChild(namenodetext) |
|
actualNode.appendChild(namenode) |
|
|
|
ret=newdoc.toxml(encoding='utf-8') |
|
zLOG.LOG("OSAS_metadata (writeMetadata)",zLOG.INFO,"write: %s"%ret) |
|
|
|
|
|
server.writeMetaDataFile(indexFile,ret) |
|
|
|
|
|
return newdoc,actualNode |
|
|
|
def writeMetadataFile(self,MDF_path,MDF_type,MDF_xpathStart="",newdoc=None,actualNode=None): |
|
"""writeMetaFile""" |
|
|
|
return self.writeMetadata(MDF_path,MDF_type,self.REQUEST.form,MDF_xpathStart=MDF_xpathStart,newdoc=newdoc,actualNode=actualNode) |
|
|
|
|
|
def isEmptyValue(self,fieldName): |
|
"""im generischen fall stets falsch""" |
|
return 1 |
|
|
|
def getValue(self,fieldName): |
|
"""im generischen fall gleich fieldname""" |
|
return fieldName,fieldName,"","","" |
|
|
|
def getList(self,list): |
|
"""return list""" |
|
|
|
if list=="": |
|
return None |
|
listsplit=[i.rstrip() for i in list.split("\n")] |
|
return listsplit |
|
|
|
def showHelp(self,refType,genericTag): |
|
"""helptext""" |
|
for reference in self.ZopeFind(self): |
|
if reference[1].title==refType: |
|
text=getattr(reference[1],'md_'+genericTag)[2] |
|
return text |
|
return "NO EXPLANATION" |
|
|
|
def showHelpTag(self,url,reftype,item): |
|
"""gen javascript for showhelp""" |
|
url2=url+'/showHelp?refType=%s&genericTag=%s'%(reftype,item) |
|
ret="""javascript:wd=window.open(\'%s\',\'Help\',\'width=300,height=250\');void(\'\');wd.focus();"""%url2 |
|
return ret |
|
|
|
|
def manage_addMetadataForm(self): |
def manage_addMetadataForm(self): |
"""interface for adding the OSAS_add_Metadata""" |
"""interface for adding the OSAS_add_Metadata""" |
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMetadataForm.zpt')).__of__(self) |
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMetadataForm.zpt')).__of__(self) |
return pt() |
return pt() |
|
|
def manage_addMetadata(self,id,linklabel,description,fields,RESPONSE=None): |
def manage_addMetadata(self,id,shortDescription,description,fields,RESPONSE=None): |
"""add the OSAS_root""" |
"""add the OSAS_root""" |
newObj=OSAS_Metadata(id,linklabel,description,fields) |
newObj=OSAS_Metadata(id,shortDescription,description,fields) |
self.Destination()._setObject(id,newObj) |
self.Destination()._setObject(id,newObj) |
if RESPONSE is not None: |
if RESPONSE is not None: |
RESPONSE.redirect('manage_main') |
RESPONSE.redirect('manage_main') |
|
|
|
|
InitializeClass(OSAS_Metadata) |
|