Annotation of OSAS/OSA_system/OSAS_metadata.py, revision 1.5

1.1       dwinter     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
1.5     ! dwinter    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"""
1.1       dwinter    71: 
1.5     ! dwinter    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')
1.1       dwinter   104: 
1.5     ! dwinter   105:    
1.1       dwinter   106: 
                    107: 
                    108: class OSAS_add_Metadata(Folder):
                    109:     """Foldertype enthält methoden zur Halbautomatischen Erstellung von Metadatenfiles"""
                    110:     security=ClassSecurityInfo()
                    111:     
1.5     ! dwinter   112:     def __init__(self,id,linklabel,description,fields):
1.1       dwinter   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
1.5     ! dwinter   117:         self.fieldList=fields.split(",")[0:]
1.1       dwinter   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:     
1.5     ! dwinter   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
1.1       dwinter   188:     
                    189:     security.declarePublic('add_Metadata_config')
                    190:     def add_Metadata_config(self):
                    191:         """Main configuration"""
1.4       dwinter   192:         pt=PageTemplateFile('Products/OSA_system/zpt/ChangeOSAS_addMetadata.zpt').__of__(self)
1.1       dwinter   193:         return pt()
                    194:     
1.3       dwinter   195:     security.declarePublic('change_OSAS_addMetadata')
1.5     ! dwinter   196:     def change_OSAS_addMetadata(self,linklabel,description,fields,RESPONSE=None):
1.1       dwinter   197:         """Change Metadata"""
1.3       dwinter   198:         self.linklabel=linklabel
                    199:         self.description=description
1.5     ! dwinter   200:         self.fieldList=fields.split(",")[0:]
1.1       dwinter   201:         if RESPONSE is not None:
                    202:             RESPONSE.redirect('manage_main')
                    203: 
                    204:     security.declarePublic('index_html')
                    205:     def index_html(self):
1.5     ! dwinter   206:         """standard aufruf"""
1.1       dwinter   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"""
1.4       dwinter   225:     pt=PageTemplateFile('Products/OSA_system/zpt/AddOSAS_metadata.zpt').__of__(self)
1.1       dwinter   226:     return pt()
                    227: 
1.5     ! dwinter   228: def manage_AddOSAS_add_Metadata(self,id,linklabel,description,fields,RESPONSE=None):
1.1       dwinter   229:     """add the OSAS_root"""
1.5     ! dwinter   230:     newObj=OSAS_add_Metadata(id,linklabel,description,fields)
1.1       dwinter   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: 

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>