Return to OSAS_metadata.py CVS log

Up to [Repository] / OSAS / OSA_system

fehler korrigiert falls metadata leer wird index.meta jetzt korrect erzeugt

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