libervia-backend: src/memory/memory.py comparison

comparison src/memory/memory.py @ 634:ca2cae6b2c6d

core: security attribute added to the parameters - getParams, getParamsUI and getParamsForCategory have a security_limit parameter to filter - parameters with security = 0 can be retrieved/modified from Libervia

author	souliane <souliane@mailoo.org>
date	Thu, 05 Sep 2013 20:28:44 +0200
parents	5646ecd3e35e
children	eff8772fd472

comparison

equal deleted inserted replaced

-:6a29a4d574bd
+:ca2cae6b2c6d
 raise exceptions.ProfileNotInCacheError
 if (category, name) not in cache:
 return None
 return cache[(category, name)]
-def __constructProfileXml(self, profile):
+def __constructProfileXml(self, security_limit, profile):
 """Construct xml for asked profile, filling values when needed
 /!\ as noticed in doc, don't forget to unlink the minidom.Document
+@security_limit: -1 to return all the params. Otherwise sole the
+params which have a security level defined *and* lower or equal to
+the specified value are returned.
 @param profile: profile name (not key !)
 @return: a deferred that fire a minidom.Document of the profile xml (cf warning above)
 """
 def constructProfile(ignore, profile_cache):
+def filterParam(node):
+"""Filter with security level.
+@return: True is this param must be filtered"""
+if security_limit < 0:
+return False
+if not node.hasAttribute('security'):
+debug("filtered param: %s (no security set)"
+% node.getAttribute("name"))
+return True
+if int(node.getAttribute('security')) > security_limit:
+debug("filtered param: %s (security level > %i)"
+% (node.getAttribute("name"), security_limit))
+return True
+return False
+# init the result document
 prof_xml = minidom.parseString('<params/>')
 cache = {}
 for type_node in self.dom.documentElement.childNodes:
-if type_node.nodeName == 'general' or type_node.nodeName == 'individual':  # we use all params, general and individual
+if type_node.nodeName != 'general' and type_node.nodeName != 'individual':
-for cat_node in type_node.childNodes:
+continue
-if cat_node.nodeName == 'category':
+# we use all params, general and individual
-category = cat_node.getAttribute('name')
+for cat_node in type_node.childNodes:
-if category not in cache:
+if cat_node.nodeName != 'category':
-cache[category] = dest_cat = cat_node.cloneNode(True)  # we make a copy for the new xml
+continue
-new_node = True
+category = cat_node.getAttribute('name')
-else:
+dest_params = {}  # result (merged) params for category
-dest_cat = cache[category]
+if category not in cache:
-new_node = False  # It's not a new node, we will merge information
+# we make a copy for the new xml
-params = cat_node.getElementsByTagName("param")
+cache[category] = dest_cat = cat_node.cloneNode(True)
-dest_params = {}
+for node in dest_cat.childNodes:
-for node in dest_cat.childNodes:
+if node.nodeName != "param":
-if node.nodeName != "param":
+continue
-continue
+if filterParam(node):
-dest_params[node.getAttribute('name')] = node
+dest_cat.removeChild(node)
+continue
-for param_node in params:
+dest_params[node.getAttribute('name')] = node
-name = param_node.getAttribute('name')
+new_node = True
+else:
-if name not in dest_params:
+# It's not a new node, we use the previously cloned one
-dest_params[name] = param_node.cloneNode(True)
+dest_cat = cache[category]
-dest_cat.appendChild(dest_params[name])
+new_node = False
+params = cat_node.getElementsByTagName("param")
-profile_value = self.__getParam(profile, category, name, type_node.nodeName, cache=profile_cache)
-if profile_value is not None:  # there is a value for this profile, we must change the default
+for param_node in params:
-dest_params[name].setAttribute('value', profile_value)
+# we have to merge new params (we are parsing individual parameters, we have to add them
-if new_node:
+# to the previously parsed general ones)
-prof_xml.documentElement.appendChild(dest_cat)
+name = param_node.getAttribute('name')
+if filterParam(param_node):
+continue
+if name not in dest_params:
+# this is reached when a previous category exists
+dest_params[name] = param_node.cloneNode(True)
+dest_cat.appendChild(dest_params[name])
+profile_value = self.__getParam(profile, category,
+name, type_node.nodeName,
+cache=profile_cache)
+if profile_value is not None:
+# there is a value for this profile, we must change the default
+dest_params[name].setAttribute('value', profile_value)
+if new_node:
+prof_xml.documentElement.appendChild(dest_cat)
+to_remove = []
+for cat_node in prof_xml.documentElement.childNodes:
+# we remove empty categories
+if cat_node.getElementsByTagName("param").length == 0:
+to_remove.append(cat_node)
+for node in to_remove:
+prof_xml.documentElement.removeChild(node)
 return prof_xml
 if profile in self.params:
 d = defer.succeed(None)
 profile_cache = self.params[profile]
 profile_cache = {}
 d = self.loadIndParams(profile, profile_cache)
 return d.addCallback(constructProfile, profile_cache)
-def getParamsUI(self, profile_key):
+def getParamsUI(self, security_limit, profile_key):
 """Return a SàT XMLUI for parameters, with given profile"""
 profile = self.getProfileName(profile_key)
 if not profile:
 error(_("Asking params for inexistant profile"))
 return ""
-d = self.getParams(profile)
+d = self.getParams(security_limit, profile)
 return d.addCallback(lambda param_xml: paramsXml2xmlUI(param_xml))
-def getParams(self, profile_key):
+def getParams(self, security_limit, profile_key):
 """Construct xml for asked profile
 Take params xml as skeleton"""
 profile = self.getProfileName(profile_key)
 if not profile:
 error(_("Asking params for inexistant profile"))
 return ""
 def returnXML(prof_xml):
 return_xml = prof_xml.toxml()
 prof_xml.unlink()
-return return_xml
+return '\n'.join([line for line in return_xml.split('\n')])
-return self.__constructProfileXml(profile).addCallback(returnXML)
+return self.__constructProfileXml(security_limit, profile).addCallback(returnXML)
-def getParamsForCategory(self, category, profile_key):
+def getParamsForCategory(self, category, security_limit, profile_key):
 """Return node's xml for selected category"""
 #TODO: manage category of general type (without existant profile)
 profile = self.getProfileName(profile_key)
 if not profile:
 error(_("Asking params for inexistant profile"))
 return result
 prof_xml.unlink()
 return "<category />"
-d = self.__constructProfileXml(profile)
+d = self.__constructProfileXml(security_limit, profile)
 return d.addCallback(returnCategoryXml)
 def __getParamNode(self, name, category, _type="@ALL@"):  # FIXME: is _type useful ?
 """Return a node from the param_xml
 @param name: name of the node
 return self.params.asyncGetParamA(name, category, attr, profile_key)
 def asyncGetStringParamA(self, name, category, attr="value", profile_key='@DEFAULT@'):
 return self.params.asyncGetStringParamA(name, category, attr, profile_key)
-def getParamsUI(self, profile_key):
+def getParamsUI(self, security_limit, profile_key):
-return self.params.getParamsUI(profile_key)
+return self.params.getParamsUI(security_limit, profile_key)
-def getParams(self, profile_key):
+def getParams(self, security_limit, profile_key):
-return self.params.getParams(profile_key)
+return self.params.getParams(security_limit, profile_key)
-def getParamsForCategory(self, category, profile_key):
+def getParamsForCategory(self, category, security_limit, profile_key):
-return self.params.getParamsForCategory(category, profile_key)
+return self.params.getParamsForCategory(category, security_limit, profile_key)
 def getParamsCategories(self):
 return self.params.getParamsCategories()
 def setParam(self, name, value, category, profile_key):

Mercurial > libervia-backend

comparison src/memory/memory.py @ 634:ca2cae6b2c6d