Return to OSAS_metadata.py CVS log

Up to [Repository] / OSAS / OSA_system

metadata overview implemented

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