Return to ZSQLMetaData.py CVS log

Up to [Repository] / ZSQLExtend

Annotation of ZSQLExtend/ZSQLMetaData.py, revision 1.3

1.1       dwinter     1: #objekte zur erzeugung und verwaltung von metadaten
                      2: 
                      3: from OFS.Folder import Folder
                      4: from Globals import Persistent
                      5: from Acquisition import Implicit
                      6: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
                      7: from Products.PageTemplates.PageTemplate import PageTemplate
                      8: from OFS.SimpleItem import SimpleItem
                      9: 
                     10: import string
                     11: 
                     12: 
                     13: class ZSQLMetadataMapping(SimpleItem):
                     14:     """Einfaches Mapping Object"""
                     15: 
                     16:     meta_type="ZSQLMetadataMapping"
                     17: 
                     18:     def readFieldsFromParent(self):
                     19:         """read all elements from root"""
                     20:         return self.ac_parent.fields
                     21:     
                     22:     def __init__(self,id,title,arglist):
                     23:         """init"""
                     24:         self.id=id
                     25:         self.title=title
                     26: 
                     27:         for fieldName in arglist.keys():
                     28:             setattr(self,"md_"+fieldName,arglist[fieldName])
                     29: 
                     30:     manage_options = SimpleItem.manage_options+(
                     31:         {'label':'Main Config','action':'change_ZSQLMappingForm'},
                     32:         )
                     33: 
                     34:     def getValue(self,fieldName):
                     35:         """get md value"""
1.2       dwinter    36:         try:
                     37:             return getattr(self,"md_"+fieldName)
                     38:         except:
                     39:             return ""
                     40:         
1.1       dwinter    41:     def generateMappingHash(self):
                     42:         """erzeugen des Hash"""
                     43:         hash={}
                     44:         for field in self.fieldList:
                     45:             hash[field]=getattr(self,"md_"+field)
                     46:         return hash
                     47: 
                     48:    
                     49:     
                     50:     def change_ZSQLMappingForm(self):
                     51:         """change"""
                     52:         pt=PageTemplateFile('Products/ZSQLExtend/ChangeZSQLMetadataMapping.zpt').__of__(self)
                     53:         return pt()
                     54:     
                     55:     def change_ZSQLMapping(self,titleOfObject,RESPONSE=None):
                     56:         """change"""
                     57: 
                     58:         self.title=titleOfObject
                     59:         arglist=self.REQUEST.form
                     60:         for fieldName in arglist.keys():
                     61:             setattr(self,"md_"+fieldName,arglist[fieldName])
                     62: 
                     63:         if RESPONSE is not None:
                     64:             RESPONSE.redirect('manage_main')
                     65: 
                     66:     
                     67: 
                     68: def manage_addZSQLMetadataMappingForm(self):
                     69:     """interface for adding the OSAS_root"""
                     70:     pt=PageTemplateFile('Products/ZSQLExtend/AddZSQLMetadataMapping.zpt').__of__(self)
                     71:     return pt()
                     72: 
                     73: def manage_addZSQLMetadataMapping(self,idOfObject,titleOfObject,RESPONSE=None):
                     74:     """add the OSAS_root"""
                     75:     
                     76:     argList={}
                     77:     for arg in self.REQUEST.form.keys():
                     78:         if not (arg in ['idOfObject','titleOfObject']):
                     79:             argList[arg]=self.REQUEST.form[arg]
                     80:         
                     81:     newObj=ZSQLMetadataMapping(idOfObject,titleOfObject,argList)
                     82:     self._setObject(idOfObject,newObj)
                     83:     if RESPONSE is not None:
                     84:         RESPONSE.redirect('manage_main')
                     85: 
                     86:    
                     87: class ZSQLMetadataMappingRoot(Persistent, Implicit, Folder):
1.3     ! casties    88:     """Root ordner fuer Metadaten set"""
1.1       dwinter    89: 
                     90:     meta_type='ZSQLMetadataMappingRoot'
                     91: 
                     92:     def __init__(self,id,title,fields):
                     93:         self.id=id
                     94:         self.title=title
                     95:         
                     96:         self.fieldList=fields.split(",")[0:]
                     97: 
                     98:     
                     99:     manage_options = Folder.manage_options+(
                    100:         {'label':'Main Config','action':'change_ZSQLMappingRootForm'},
                    101:         )
                    102: 
                    103: 
                    104:     def generateMappingList(self):
                    105:         """Erzeuge Mapping"""
                    106:         mapping={}
                    107:         for dict in self.__dict__:
                    108:             #print dict
                    109:             obj=getattr(self,dict)
                    110:             if hasattr(obj,'meta_type'):
                    111:                 if obj.meta_type=="ZSQLMetadataMapping":
                    112:                     mapping[obj.getId()]=obj.generateMappingHash()
                    113:         return mapping
                    114:     
                    115:     def generateMappingForType(self,type,clean="yes"):
                    116:         """erzeuge spezifisches Mapping"""
                    117:         hash=self.generateMappingList()
                    118:         if hash.has_key(type):
                    119:             if clean=="yes":
                    120:                 temp={}
                    121:                 for x in hash[type].keys():
                    122:                     if not hash[type][x]=="":
                    123:                         temp[x]=hash[type][x]
                    124:                 return temp
                    125:             else:
                    126:                 return hash[type]
                    127:         
                    128:         else:
                    129:             return {}
                    130: 
                    131:     def getFieldList(self):
                    132:         """erzeuge string aus fields"""
                    133:         return string.join(self.fieldList,",")
                    134: 
                    135:     def getFields(self):
                    136:         """ausgabe der Felder"""
                    137:         return self.fieldList
                    138: 
                    139:     def getTypeTitle(self,id):
                    140:         """Title von ID"""
                    141:         try:
                    142:             obj=getattr(self,id)
                    143:             return obj.title
                    144:         except:
                    145:             return id
                    146:         
                    147:     def getStoredTypes(self):
1.3     ! casties   148:         """Gebe gespeicherte typen zurueck"""
1.1       dwinter   149:         
                    150:         types=[]
                    151:         for dict in self.__dict__:
                    152:             
                    153:             obj=getattr(self,dict)
                    154:             if hasattr(obj,'meta_type'):
                    155:                 if obj.meta_type=="ZSQLMetadataMapping":
                    156:                     #print obj
                    157:                     if obj.title=="":
                    158:                         title=obj.id
                    159:                     else:
                    160:                         title=obj.title
                    161:                     types.append((obj.id,title))
                    162:         return types
                    163:     
                    164:     def change_ZSQLMappingRootForm(self):
                    165:         """change"""
                    166:         pt=PageTemplateFile('Products/ZSQLExtend/ChangeZSQLMetadataMappingRoot.zpt').__of__(self)
                    167:         return pt()
                    168: 
                    169: 
                    170:     def change_ZSQLMetadataMapping(self,title,fields,RESPONSE=None):
                    171:         """change entries"""
                    172:         self.title=title
                    173:         self.fieldList=fields.split(",")[0:]
                    174: 
                    175:         if RESPONSE is not None:
                    176:             RESPONSE.redirect('manage_main')
                    177: 
                    178:     
                    179: 
                    180: def manage_addZSQLMetadataMappingRootForm(self):
                    181:     """interface for adding the OSAS_root"""
                    182:     pt=PageTemplateFile('Products/ZSQLExtend/AddZSQLMetadataMappingRoot.zpt').__of__(self)
                    183:     return pt()
                    184: 
                    185: def manage_addZSQLMetadataMappingRoot(self,id,title,fields,RESPONSE=None):
                    186:     """add the OSAS_root"""
                    187:     newObj=ZSQLMetadataMappingRoot(id,title,fields)
                    188:     self._setObject(id,newObj)
                    189:     if RESPONSE is not None:
                    190:         RESPONSE.redirect('manage_main')
                    191: 
                    192: