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

comparison src/memory/params.py @ 1477:ac522c4dab0e

core (params): jids_list type management

author	Goffi <goffi@goffi.org>
date	Thu, 20 Aug 2015 18:35:27 +0200
parents	c7fd121a6180
children	8d61160ee4b8

comparison

equal deleted inserted replaced

-:48706f4ff19c
+:ac522c4dab0e
 from xml.dom import minidom, NotFoundErr
 from sat.core.log import getLogger
 log = getLogger(__name__)
 from twisted.internet import defer
 from twisted.python.failure import Failure
+from twisted.words.protocols.jabber import jid
 from sat.tools.xml_tools import paramsXML2XMLUI
+# TODO: params should be rewritten using Twisted directly instead of minidom
+#       general params should be linked to sat.conf and kept synchronised
+#       this need an overall simplification to make maintenance easier
 class Params(object):
 """This class manage parameters with xml"""
 ### TODO: add desciption in params
 'force_server_param': C.FORCE_SERVER_PARAM,
 'force_port_param': C.FORCE_PORT_PARAM,
 'new_account_label': D_("Register new account"),
 'autoconnect_label': D_('Connect on frontend startup'),
 'autodisconnect_label': D_('Disconnect on frontend closure'),
-'category_misc': D_("Misc"),
 }
 def load_default_params(self):
 self.dom = minidom.parseString(Params.default_xml.encode('utf-8'))
 default_dom = minidom.parseString(Params.default_xml.encode('utf-8'))
 self._mergeParams(default_dom.documentElement, self.dom.documentElement)
 def loadGenParams(self):
 """Load general parameters data from storage
-@return: deferred triggered once params are loaded"""
+@return: deferred triggered once params are loaded
+"""
 return self.storage.loadGenParams(self.params_gen)
 def loadIndParams(self, profile, cache=None):
 """Load individual parameters
 set self.params cache or a temporary cache
 @param profile: profile to load (*must exist*)
 @param cache: if not None, will be used to store the value, as a short time cache
-@return: deferred triggered once params are loaded"""
+@return: deferred triggered once params are loaded
+"""
 if cache is None:
 self.params[profile] = {}
 return self.storage.loadIndParams(self.params[profile] if cache is None else cache, profile)
 def purgeProfile(self, profile):
 """Remove cache data of a profile
-@param profile: %(doc_profile)s"""
+@param profile: %(doc_profile)s
+"""
 try:
 del self.params[profile]
 except KeyError:
 log.error(_(u"Trying to purge cache of a profile not in memory: [%s]") % profile)
 self.params = {}
 self.params_gen = {}
 def asyncCreateProfile(self, profile):
 """Create a new profile
 @param profile: name of the profile
 @param callback: called when the profile actually exists in database and memory
 @return: a Deferred instance
 """
 if self.storage.hasProfile(profile):
 raise exceptions.ProfileUnknownError
 return profile_key
 def __get_unique_node(self, parent, tag, name):
 """return node with given tag
 @param parent: parent of nodes to check (e.g. documentElement)
 @param tag: tag to check (e.g. "category")
 @param name: name to check (e.g. "JID")
 @return: node if it exist or None
 """
 #the node is new
 return None
 def updateParams(self, xml, security_limit=C.NO_SECURITY_LIMIT, app=''):
 """import xml in parameters, update if the param already exists
 If security_limit is specified and greater than -1, the parameters
 that have a security level greater than security_limit are skipped.
 @param xml: parameters in xml form
 @param security_limit: -1 means no security, 0 is the maximum security then the higher the less secure
 @param app: name of the frontend registering the parameters or empty value
 """
+# TODO: should word with domish.Element
 src_parent = minidom.parseString(xml.encode('utf-8')).documentElement
 def pre_process_app_node(src_parent, security_limit, app):
 """Parameters that are registered from a frontend must be checked"""
 to_remove = []
 pre_process_app_node(src_parent, security_limit, app)
 import_node(self.dom.documentElement, src_parent)
 def paramsRegisterApp(self, xml, security_limit, app):
 """Register frontend's specific parameters
 If security_limit is specified and greater than -1, the parameters
 that have a security level greater than security_limit are skipped.
 @param xml: XML definition of the parameters to be added
 @param security_limit: -1 means no security, 0 is the maximum security then the higher the less secure
 @param app: name of the frontend registering the parameters
 def __default_ko(self, failure, name, category):
 log.error(_(u"Can't determine default value for [%(category)s/%(name)s]: %(reason)s") % {'category': category, 'name': name, 'reason': str(failure.value)})
 def setDefault(self, name, category, callback, errback=None):
 """Set default value of parameter
 'default_cb' attibute of parameter must be set to 'yes'
 @param name: name of the parameter
 @param category: category of the parameter
 @param callback: must return a string with the value (use deferred if needed)
 @param errback: must manage the error with args failure, name, category
 @return: str
 """
 if attr == 'value':
 value_to_use = value if value is not None else node.getAttribute(attr)  # we use value (user defined) if it exist, else we use node's default value
 if node.getAttribute('type') == 'bool':
-return value_to_use.lower() not in ('false', '0', 'no')
+return C.bool(value_to_use)
 if node.getAttribute('type') == 'int':
 return int(value_to_use)
 elif node.getAttribute('type') == 'list':
 options = [option for option in node.childNodes if option.nodeName == 'option']
 values = [option.getAttribute('value') for option in options]
 if len(selected) == 0:
 log.error(_(u'Parameter (%(cat)s, %(param)s) of type list has no default option!') % {'cat': cat, 'param': param})
 else:
 log.error(_(u'Parameter (%(cat)s, %(param)s) of type list has more than one default option!') % {'cat': cat, 'param': param})
 raise exceptions.DataError
+elif node.getAttribute('type') == 'jids_list':
+jids = value.split('\t')
+to_delete = []
+for idx, value in enumerate(jids):
+try:
+jids[idx] = jid.JID(value)
+except jid.InvalidFormat:
+log.warning(u"Incorrect jid value found in jids list: [{}]".format(value))
+to_delete.append(value)
+for value in to_delete:
+jids.remove(value)
+return jids
 return value_to_use
 return node.getAttribute(attr)
 def _getAttr(self, node, attr, value):
 """Get attribute value (synchronous).
 /!\ This method can not be used to retrieve password values.
 @param node: XML param node
 @param attr: name of the attribute to get (e.g.: 'value' or 'type')
 @param value: user defined value
-@return: str
+@return (unicode, bool, int, list): value to retrieve
 """
 if attr == 'value' and node.getAttribute('type') == 'password':
 raise exceptions.InternalError('To retrieve password values, use _asyncGetAttr instead of _getAttr')
 return self._getAttr_internal(node, attr, value)
 def _asyncGetAttr(self, node, attr, value, profile=None):
 """Get attribute value.
 Profile passwords are returned hashed (if not empty),
 other passwords are returned decrypted (if not empty).
 @param node: XML param node
 @param attr: name of the attribute to get (e.g.: 'value' or 'type')
 @param value: user defined value
 @param profile: %(doc_profile)s
-@return: a deferred str
+@return (unicode, bool, int, list): Deferred value to retrieve
 """
 value = self._getAttr_internal(node, attr, value)
 if attr != 'value' or node.getAttribute('type') != 'password':
 return defer.succeed(value)
 param_cat = node.parentNode.getAttribute('name')
 def getParamA(self, name, category, attr="value", profile_key=C.PROF_KEY_NONE):
 """Helper method to get a specific attribute.
 /!\ This method would return encrypted password values,
 to get the plain values you have to use _asyncGetParamA.
+@param name: name of the parameter
-@param name: name of the parameter
+@param category: category of the parameter
-@param category: category of the parameter
+@param attr: name of the attribute (default: "value")
-@param attr: name of the attribute (default: "value")
+@param profile: owner of the param (@ALL@ for everyone)
-@param profile: owner of the param (@ALL@ for everyone)
+@return: attribute
-@return: attribute
+"""
-"""
 #FIXME: looks really dirty and buggy, need to be reviewed/refactored
 node = self._getParamNode(name, category)
 if not node:
 log.error(_(u"Requested param [%(name)s] in category [%(category)s] doesn't exist !") % {'name': name, 'category': category})
 raise exceptions.NotFound
 d.addCallback(self.__type_to_string)
 return d
 def asyncGetParamA(self, name, category, attr="value", security_limit=C.NO_SECURITY_LIMIT, profile_key=C.PROF_KEY_NONE):
 """Helper method to get a specific attribute.
 @param name: name of the parameter
 @param category: category of the parameter
 @param attr: name of the attribute (default: "value")
 @param profile: owner of the param (@ALL@ for everyone)
 @return: Deferred
 d = self.storage.getIndParam(category, name, profile)
 return d.addCallback(lambda value: self._asyncGetAttr(node[1], attr, value, profile))
 def _getParam(self, category, name, type_=C.INDIVIDUAL, cache=None, profile=C.PROF_KEY_NONE):
 """Return the param, or None if it doesn't exist
 @param category: param category
 @param name: param name
 @param type_: GENERAL or INDIVIDUAL
 @param cache: temporary cache, to use when profile is not logged
 @param profile: the profile name (not profile key, i.e. name and not something like @DEFAULT@)
 """
 if type_ == C.GENERAL:
 if (category, name) in self.params_gen:
 return self.params_gen[(category, name)]
 return None  # This general param has the default value
-assert (type_ == C.INDIVIDUAL)
+assert type_ == C.INDIVIDUAL
 if profile == C.PROF_KEY_NONE:
 raise exceptions.ProfileNotSetError
 if profile in self.params:
 cache = self.params[profile]  # if profile is in main cache, we use it,
 # ignoring the temporary cache
 raise exceptions.ProfileNotInCacheError
 if (category, name) not in cache:
 return None
 return cache[(category, name)]
-def __constructProfileXml(self, security_limit, app, profile):
+def _constructProfileXml(self, security_limit, app, profile):
 """Construct xml for asked profile, filling values when needed
 /!\ as noticed in doc, don't forget to unlink the minidom.Document
 @param security_limit: NO_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 app: name of the frontend requesting the parameters, or '' to get all parameters
 else:
 try:
 option.removeAttribute('selected')
 except NotFoundErr:
 pass
+elif dest_params[name].getAttribute('type') == 'jids_list':
+jids = profile_value.split('\t') # FIXME: it's not good to use tabs as separator !
+for jid_ in jids:
+jid_elt = prof_xml.createElement('jid')
+jid_elt.appendChild(prof_xml.createTextNode(jid_))
+dest_params[name].appendChild(jid_elt)
 else:
 dest_params[name].setAttribute('value', profile_value)
 if new_node:
 prof_xml.documentElement.appendChild(dest_cat)
 d = self.getParams(security_limit, app, profile)
 return d.addCallback(lambda param_xml: paramsXML2XMLUI(param_xml))
 def getParams(self, security_limit, app, profile_key):
 """Construct xml for asked profile, take params xml as skeleton
 @param security_limit: NO_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 app: name of the frontend requesting the parameters, or '' to get all parameters
 @param profile_key: Profile key which can be either a magic (eg: @DEFAULT@) or the name of an existing profile.
 def returnXML(prof_xml):
 return_xml = prof_xml.toxml()
 prof_xml.unlink()
 return '\n'.join((line for line in return_xml.split('\n') if line))
-return self.__constructProfileXml(security_limit, app, profile).addCallback(returnXML)
+return self._constructProfileXml(security_limit, app, profile).addCallback(returnXML)
 def getParamsForCategory(self, category, security_limit, app, profile_key):
 """
 @param category: the desired category
 @param security_limit: NO_SECURITY_LIMIT (-1) to return all the params.
 return result
 prof_xml.unlink()
 return "<category />"
-d = self.__constructProfileXml(security_limit, app, profile)
+d = self._constructProfileXml(security_limit, app, 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
 if self.host.isConnected(profile):
 self.host.bridge.paramUpdate(name, value, category, profile)
 self.host.trigger.point("paramUpdateTrigger", name, value, category, node[0], profile)
 return defer.succeed(None)
-assert (node[0] == C.INDIVIDUAL)
+assert node[0] == C.INDIVIDUAL
-assert (profile_key != C.PROF_KEY_NONE)
+assert profile_key != C.PROF_KEY_NONE
 d_list = []
 if type_ == "button":
 log.debug(u"Clicked param button %s" % node.toxml())
 return defer.succeed(None)

Mercurial > libervia-backend

comparison src/memory/params.py @ 1477:ac522c4dab0e