[BACK]Return to OSAS_metadata.py CVS log [TXT] [DIR] Up to [Repository] / OSAS / OSA_system

Diff for /OSAS/OSA_system/OSAS_metadata.py between versions 1.2 and 1.9

version 1.2, 2003/10/09 08:10:52 version 1.9, 2004/05/26 08:08:57
Line 18  from Shared.DC.Scripts.Script import Scr Line 18  from Shared.DC.Scripts.Script import Scr
 from OFS.PropertyManager import PropertyManager  from OFS.PropertyManager import PropertyManager
 from ExtensionClass import Base  from ExtensionClass import Base
 from Acquisition import Implicit  from Acquisition import Implicit
   import string
 from AccessControl import ClassSecurityInfo  from AccessControl import ClassSecurityInfo
   
   
   class OSAS_MetadataMapping(SimpleItem):
       """Einfaches Mapping Object"""
   
       meta_type="OSAS_MetadataMapping"
   
       def readFieldsFromParent(self):
           """read all elements from root"""
           #print self.getId()
           return self.aq_parent.fieldList
       
       def __init__(self,id,title,arglist,fieldList):
           """init"""
           self.id=id
           self.title=title
           self.fields=[]
           
           for fieldName in fieldList:
               setattr(self,"md_"+fieldName,arglist[fieldName])
               self.fields.append(arglist[fieldName])
               
       manage_options = SimpleItem.manage_options+(
           {'label':'Main Config','action':'change_OSAS_MappingForm'},
           )
   
   
       def showSetXML(self,RESPONSE=None):
           """prints out the mapping as XML"""
           ret="""<set name="%s">"""%self.title
           for fieldName in self.readFieldsFromParent():
               entry=getattr(self,"md_"+fieldName)
               if entry[2]=="": # no explanation of this field
                   ret+="""<entry genericName="%s" tag="%s" label="%s"/>"""%(fieldName,entry[0],entry[1])
               else:
                   ret+="""<entry genericName="%s" tag="%s" label="%s">%s</entry>"""%(fieldName,entry[0],entry[1],entry[2])
           ret+="</set>"
   
           if not RESPONSE:
               return ret
           else:
               self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
               return ret
   
       def getValue(self,fieldName):
           """get md value"""
   
           try:
               return getattr(self,"md_"+fieldName)
           except:
               return (None,None,None)
   
       def isEmptyValue(self,fieldName):
           """empty"""
           try:
               field=getattr(self,"md_"+fieldName)
               if field[1]=='':
                   return 0
               else:
                   return 1
           except:
               return 0
           
       def generateMappingHash(self):
           """erzeugen des Hash"""
           hash={}
           for field in self.fieldList:
               hash[field]=getattr(self,"md_"+field)
           return hash
   
          
       
       def change_OSAS_MappingForm(self):
           """change"""
           pt=PageTemplateFile('Products/OSA_system/zpt/ChangeOSAS_MetadataMapping.zpt').__of__(self)
           return pt()
       
       def change_OSAS_Mapping(self,titleOfObject,RESPONSE=None):
           """change"""
   
           self.title=titleOfObject
           arglist=self.REQUEST.form
           self.fields=[]
           
           
           for fieldName in self.readFieldsFromParent():
   
               setattr(self,"md_"+fieldName,(arglist[fieldName],arglist['label_'+fieldName],arglist['explanation_'+fieldName]))
               self.fields.append(arglist[fieldName])
               
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
       
   
   def manage_addOSAS_MetadataMappingForm(self):
       """interface for adding the OSAS_root"""
       pt=PageTemplateFile('Products/OSA_system/zpt/AddOSAS_MetadataMapping.zpt').__of__(self)
       return pt()
   
   def manage_addOSAS_MetadataMapping(self,idOfObject,titleOfObject,RESPONSE=None):
       """add the OSAS_root"""
       
       argList={}
       for arg in self.fieldList:
           if not (arg in ['idOfObject','titleOfObject']):
               argList[arg]=(self.REQUEST.form[arg],self.REQUEST.form['label_'+arg],self.REQUEST.form['explanation_'+arg])
               
       newObj=OSAS_MetadataMapping(idOfObject,titleOfObject,argList,self.fieldList)
       self._setObject(idOfObject,newObj)
       if RESPONSE is not None:
           RESPONSE.redirect('manage_main')
   
      
   
   
 class OSAS_add_Metadata(Folder):  class OSAS_add_Metadata(Folder):
     """Foldertype enthält methoden zur Halbautomatischen Erstellung von Metadatenfiles"""      """Foldertype enthält methoden zur Halbautomatischen Erstellung von Metadatenfiles"""
     security=ClassSecurityInfo()      security=ClassSecurityInfo()
           
     def __init__(self,id,linklabel,description):      def __init__(self,id,linklabel,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.linklabel =linklabel #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:]
                   
     meta_type='OSAS_add_Metadata'      meta_type='OSAS_add_Metadata'
   
Line 39  class OSAS_add_Metadata(Folder): Line 153  class OSAS_add_Metadata(Folder):
         {'label':'Main Config','action':'add_Metadata_config'},          {'label':'Main Config','action':'add_Metadata_config'},
         )          )
   
           def showGenericXML(self,RESPONSE=None):
           """show generic fields as XML"""
           ret="""<set name="%s">"""%"generic"
           for field in self.fieldList:
               ret+="""<entry genericName="%s"/>"""%field
   
           ret+="</set>"
           
           if not RESPONSE:
               return ret
           else:
               self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
               return ret
       def showOverviewXML(self,RESPONSE):
           """gives an overview over the Metadata stored in this folder"""
           ret="""<metadata name="%s">"""%self.getId()
           ret+=self.showGenericXML()
           for entry in self.ZopeFind(self,obj_metatypes=['OSAS_MetadataMapping']):
               ret+=entry[1].showSetXML()
   
           ret+="</metadata>"
   
           if not RESPONSE:
               return ret
           else:
               self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
               return ret
           
       def generateMappingList(self):
           """Erzeuge Mapping"""
           mapping={}
           for dict in self.__dict__:
               #print dict
               obj=getattr(self,dict)
               if hasattr(obj,'meta_type'):
                   if obj.meta_type=="OSAS_MetadataMapping":
                       mapping[obj.getId()]=obj.generateMappingHash()
           return mapping
       
       def generateMappingForType(self,type,clean="yes"):
           """erzeuge spezifisches Mapping"""
           hash=self.generateMappingList()
           if hash.has_key(type):
               if clean=="yes":
                   temp={}
                   for x in hash[type].keys():
                       if not hash[type][x]=="":
                           temp[x]=hash[type][x]
                   return temp
               else:
                   return hash[type]
           
           else:
               return {}
   
       def getFieldList(self):
           """erzeuge string aus fields"""
           try:
               return string.join(self.fieldList,",")
           except:
               return ""
           
       def getFields(self):
           """ausgabe der Felder"""
           return self.fieldList
   
       def getTypeTitle(self,id):
           """Title von ID"""
           try:
               obj=getattr(self,id)
               return obj.title
           except:
               return id
           
       def getStoredTypes(self):
           """Gebe gespeicherte typen zurück"""
           
           types=[]
           for dict in self.__dict__:
               
               obj=getattr(self,dict)
               if hasattr(obj,'meta_type'):
                   if obj.meta_type=="OSAS_MetadataMapping":
                       #print obj
                       if obj.title=="":
                           title=obj.id
                       else:
                           title=obj.title
                       types.append((obj.id,title))
           return types
           
     security.declarePublic('add_Metadata_config')      security.declarePublic('add_Metadata_config')
     def add_Metadata_config(self):      def add_Metadata_config(self):
         """Main configuration"""          """Main configuration"""
         pt=PageTemplateFile('Products/OSA_system/ChangeOSAS_addMetadata.zpt').__of__(self)          pt=PageTemplateFile('Products/OSA_system/zpt/ChangeOSAS_addMetadata.zpt').__of__(self)
         return pt()          return pt()
           
     security.declarePublic('change_OSAS_add_Metadata')      security.declarePublic('change_OSAS_addMetadata')
     def change_OSAS_add_Metadata(self,linklabel,description,RESPONSE=None):      def change_OSAS_addMetadata(self,linklabel,description,fields,RESPONSE=None):
         """Change Metadata"""          """Change Metadata"""
         self.RootFolderName=RootFolderName          self.linklabel=linklabel
           self.description=description
           self.fieldList=fields.split(",")[0:]
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
     security.declarePublic('index_html')      security.declarePublic('index_html')
     def index_html(self):      def index_html(self):
         """stantard aufruf"""          """standard aufruf"""
         return OSAS_add.add(self,no_upload=0)          return OSAS_add.add(self,no_upload=0)
   
   
Line 73  class OSAS_add_Metadata(Folder): Line 278  class OSAS_add_Metadata(Folder):
         """write new index.meta file"""          """write new index.meta file"""
         return OSAS_add.add6(self)          return OSAS_add.add6(self)
           
           
     
       
 def manage_AddOSAS_add_MetadataForm(self):  def manage_AddOSAS_add_MetadataForm(self):
     """interface for adding the OSAS_add_Metadata"""      """interface for adding the OSAS_add_Metadata"""
     pt=PageTemplateFile('Products/OSA_system/AddOSAS_metadata.zpt').__of__(self)      pt=PageTemplateFile('Products/OSA_system/zpt/AddOSAS_metadata.zpt').__of__(self)
     return pt()      return pt()
   
 def manage_AddOSAS_add_Metadata(self,id,linklabel,description,RESPONSE=None):  def manage_AddOSAS_add_Metadata(self,id,linklabel,description,fields,RESPONSE=None):
     """add the OSAS_root"""      """add the OSAS_root"""
     newObj=OSAS_add_Metadata(id,linklabel,description)      newObj=OSAS_add_Metadata(id,linklabel,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')
Removed from v.1.2  
changed lines
  Added in v.1.9

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