Return to OSAS_metadata.py CVS log

Up to [Repository] / OSAS / OSA_system

feherhafte print in getvalue deleted

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