Return to OSAS_metadata.py CVS log

Up to [Repository] / OSAS / OSA_system

major changes: metadata now configurable with osas_metadatamapping, servlet for upload in osas root

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