Return to OSAS_metadata.py CVS log

Up to [Repository] / OSAS / OSA_system

metadaten sind nun extern konfigurierbar medatamapping und metadataobjekt

    1: # Classen zur Produktion von Metataden
    2: 
    3: # Classes for displaying, browsing and organizing the archive
    4: 
    5: import addFolder
    6: import OSAS_add # methods for adding metadata and/or files
    7: 
    8: from Globals import InitializeClass
    9: from Globals import Persistent
   10: from OFS.Folder import Folder
   11: from OFS.SimpleItem import SimpleItem
   12: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
   13: from Products.PageTemplates.PageTemplate import PageTemplate
   14: from OFS.Traversable import Traversable
   15: from OFS.Cache import Cacheable
   16: from OFS.History import Historical, html_diff
   17: from Shared.DC.Scripts.Script import Script, BindingsUI
   18: from OFS.PropertyManager import PropertyManager
   19: from ExtensionClass import Base
   20: from Acquisition import Implicit
   21: import string
   22: from AccessControl import ClassSecurityInfo
   23: 
   24: 
   25: class OSAS_MetadataMapping(SimpleItem):
   26:     """Einfaches Mapping Object"""
   27: 
   28:     meta_type="OSAS_MetadataMapping"
   29: 
   30:     def readFieldsFromParent(self):
   31:         """read all elements from root"""
   32:         #print self.getId()
   33:         return self.aq_parent.fieldList
   34:     
   35:     def __init__(self,id,title,arglist,fieldList):
   36:         """init"""
   37:         self.id=id
   38:         self.title=title
   39:         self.fields=[]
   40:         
   41:         for fieldName in fieldList:
   42:             setattr(self,"md_"+fieldName,arglist[fieldName])
   43:             self.fields.append(arglist[fieldName])
   44:             
   45:     manage_options = SimpleItem.manage_options+(
   46:         {'label':'Main Config','action':'change_OSAS_MappingForm'},
   47:         )
   48: 
   49:     def getValue(self,fieldName):
   50:         """get md value"""
   51:         print self.__dict__
   52:         print self,fieldName,getattr(self,"md_"+fieldName)
   53:         try:
   54:             return getattr(self,"md_"+fieldName)
   55:         except:
   56:             return ""
   57:         
   58:     def generateMappingHash(self):
   59:         """erzeugen des Hash"""
   60:         hash={}
   61:         for field in self.fieldList:
   62:             hash[field]=getattr(self,"md_"+field)
   63:         return hash
   64: 
   65:        
   66:     
   67:     def change_OSAS_MappingForm(self):
   68:         """change"""
   69:         pt=PageTemplateFile('Products/OSA_system/zpt/ChangeOSAS_MetadataMapping.zpt').__of__(self)
   70:         return pt()
   71:     
   72:     def change_OSAS_Mapping(self,titleOfObject,RESPONSE=None):
   73:         """change"""
   74: 
   75:         self.title=titleOfObject
   76:         arglist=self.REQUEST.form
   77:         self.fields=[]
   78:         
   79:         
   80:         for fieldName in self.readFieldsFromParent():
   81: 
   82:             setattr(self,"md_"+fieldName,(arglist[fieldName],arglist['label_'+fieldName],arglist['explanation_'+fieldName]))
   83:             self.fields.append(arglist[fieldName])
   84:             
   85:         if RESPONSE is not None:
   86:             RESPONSE.redirect('manage_main')
   87: 
   88:     
   89: 
   90: def manage_addOSAS_MetadataMappingForm(self):
   91:     """interface for adding the OSAS_root"""
   92:     pt=PageTemplateFile('Products/OSA_system/zpt/AddOSAS_MetadataMapping.zpt').__of__(self)
   93:     return pt()
   94: 
   95: def manage_addOSAS_MetadataMapping(self,idOfObject,titleOfObject,RESPONSE=None):
   96:     """add the OSAS_root"""
   97:     
   98:     argList={}
   99:     for arg in self.fieldList:
  100:         if not (arg in ['idOfObject','titleOfObject']):
  101:             argList[arg]=(self.REQUEST.form[arg],self.REQUEST.form['label_'+arg],self.REQUEST.form['explanation_'+arg])
  102:             
  103:     newObj=OSAS_MetadataMapping(idOfObject,titleOfObject,argList,self.fieldList)
  104:     self._setObject(idOfObject,newObj)
  105:     if RESPONSE is not None:
  106:         RESPONSE.redirect('manage_main')
  107: 
  108:    
  109: 
  110: 
  111: class OSAS_add_Metadata(Folder):
  112:     """Foldertype enthält methoden zur Halbautomatischen Erstellung von Metadatenfiles"""
  113:     security=ClassSecurityInfo()
  114:     
  115:     def __init__(self,id,linklabel,description,fields):
  116:         """initialize a new instance"""
  117:         self.id = id
  118:         self.linklabel =linklabel #label fuer link auf add page
  119:         self.description=description #description of the method for link page
  120:         self.fieldList=fields.split(",")[0:]
  121:         
  122:     meta_type='OSAS_add_Metadata'
  123: 
  124:     manage_options = Folder.manage_options+(
  125:         {'label':'Main Config','action':'add_Metadata_config'},
  126:         )
  127: 
  128:     
  129:     def generateMappingList(self):
  130:         """Erzeuge Mapping"""
  131:         mapping={}
  132:         for dict in self.__dict__:
  133:             #print dict
  134:             obj=getattr(self,dict)
  135:             if hasattr(obj,'meta_type'):
  136:                 if obj.meta_type=="OSAS_MetadataMapping":
  137:                     mapping[obj.getId()]=obj.generateMappingHash()
  138:         return mapping
  139:     
  140:     def generateMappingForType(self,type,clean="yes"):
  141:         """erzeuge spezifisches Mapping"""
  142:         hash=self.generateMappingList()
  143:         if hash.has_key(type):
  144:             if clean=="yes":
  145:                 temp={}
  146:                 for x in hash[type].keys():
  147:                     if not hash[type][x]=="":
  148:                         temp[x]=hash[type][x]
  149:                 return temp
  150:             else:
  151:                 return hash[type]
  152:         
  153:         else:
  154:             return {}
  155: 
  156:     def getFieldList(self):
  157:         """erzeuge string aus fields"""
  158:         try:
  159:             return string.join(self.fieldList,",")
  160:         except:
  161:             return ""
  162:         
  163:     def getFields(self):
  164:         """ausgabe der Felder"""
  165:         return self.fieldList
  166: 
  167:     def getTypeTitle(self,id):
  168:         """Title von ID"""
  169:         try:
  170:             obj=getattr(self,id)
  171:             return obj.title
  172:         except:
  173:             return id
  174:         
  175:     def getStoredTypes(self):
  176:         """Gebe gespeicherte typen zurück"""
  177:         
  178:         types=[]
  179:         for dict in self.__dict__:
  180:             
  181:             obj=getattr(self,dict)
  182:             if hasattr(obj,'meta_type'):
  183:                 if obj.meta_type=="OSAS_MetadataMapping":
  184:                     #print obj
  185:                     if obj.title=="":
  186:                         title=obj.id
  187:                     else:
  188:                         title=obj.title
  189:                     types.append((obj.id,title))
  190:         return types
  191:     
  192:     security.declarePublic('add_Metadata_config')
  193:     def add_Metadata_config(self):
  194:         """Main configuration"""
  195:         pt=PageTemplateFile('Products/OSA_system/zpt/ChangeOSAS_addMetadata.zpt').__of__(self)
  196:         return pt()
  197:     
  198:     security.declarePublic('change_OSAS_addMetadata')
  199:     def change_OSAS_addMetadata(self,linklabel,description,fields,RESPONSE=None):
  200:         """Change Metadata"""
  201:         self.linklabel=linklabel
  202:         self.description=description
  203:         self.fieldList=fields.split(",")[0:]
  204:         if RESPONSE is not None:
  205:             RESPONSE.redirect('manage_main')
  206: 
  207:     security.declarePublic('index_html')
  208:     def index_html(self):
  209:         """standard aufruf"""
  210:         return OSAS_add.add(self,no_upload=0)
  211: 
  212: 
  213:     security.declarePublic('add2')
  214:     def add2(self):
  215:         """ anlegen naechster schritt"""
  216:         return OSAS_add.add2(self)
  217: 
  218:     def add3(self):
  219:         """Foldername"""
  220:         return OSAS_add.add3(self)
  221: 
  222:     def add6(self):
  223:         """write new index.meta file"""
  224:         return OSAS_add.add6(self)
  225: 
  226:         
  227:   
  228:     
  229: def manage_AddOSAS_add_MetadataForm(self):
  230:     """interface for adding the OSAS_add_Metadata"""
  231:     pt=PageTemplateFile('Products/OSA_system/zpt/AddOSAS_metadata.zpt').__of__(self)
  232:     return pt()
  233: 
  234: def manage_AddOSAS_add_Metadata(self,id,linklabel,description,fields,RESPONSE=None):
  235:     """add the OSAS_root"""
  236:     newObj=OSAS_add_Metadata(id,linklabel,description,fields)
  237:     self.Destination()._setObject(id,newObj)
  238:     if RESPONSE is not None:
  239:         RESPONSE.redirect('manage_main')
  240: 
  241:             
  242: InitializeClass(OSAS_add_Metadata)
  243: