Return to OSAS_metadata.py CVS log

Up to [Repository] / OSAS / OSA_system

fixing small errors for zope 2.12

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