Return to ZSQLMetaData.py CVS log

Up to [Repository] / ZSQLExtend

fixing small errors for zope 2.12

    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"""
   36:         try:
   37:             return getattr(self,"md_"+fieldName)
   38:         except:
   39:             return ""
   40:         
   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):
   88:     """Root ordner fuer Metadaten set"""
   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):
  148:         """Gebe gespeicherte typen zurueck"""
  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: