libervia-backend: sat/plugins/plugin_misc

comparison sat/plugins/plugin_misc_account.py @ 4037:524856bd7b19

massive refactoring to switch from camelCase to snake_case: historically, Libervia (SàT before) was using camelCase as allowed by PEP8 when using a pre-PEP8 code, to use the same coding style as in Twisted. However, snake_case is more readable and it's better to follow PEP8 best practices, so it has been decided to move on full snake_case. Because Libervia has a huge codebase, this ended with a ugly mix of camelCase and snake_case. To fix that, this patch does a big refactoring by renaming every function and method (including bridge) that are not coming from Twisted or Wokkel, to use fully snake_case. This is a massive change, and may result in some bugs.

author	Goffi <goffi@goffi.org>
date	Sat, 08 Apr 2023 13:54:42 +0200
parents	943de4f9ce50
children

comparison

equal deleted inserted replaced

-:c4464d7ae97b
+:524856bd7b19
 # TODO: cleaning, separate email handling, more configuration/tests, fixes
 def __init__(self, host):
 log.info(_("Plugin Account initialization"))
 self.host = host
-host.bridge.addMethod(
+host.bridge.add_method(
-"registerSatAccount",
+"libervia_account_register",
 ".plugin",
 in_sign="sss",
 out_sign="",
-method=self._registerAccount,
+method=self._register_account,
 async_=True,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"getNewAccountDomain",
+"account_domain_new_get",
 ".plugin",
 in_sign="",
 out_sign="s",
-method=self.getNewAccountDomain,
+method=self.account_domain_new_get,
 async_=False,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"getAccountDialogUI",
+"account_dialog_ui_get",
 ".plugin",
 in_sign="s",
 out_sign="s",
-method=self._getAccountDialogUI,
+method=self._get_account_dialog_ui,
 async_=False,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"asyncConnectWithXMPPCredentials",
+"credentials_xmpp_connect",
 ".plugin",
 in_sign="ss",
 out_sign="b",
-method=self.asyncConnectWithXMPPCredentials,
+method=self.credentials_xmpp_connect,
 async_=True,
 )
-self.fixEmailAdmins()
+self.fix_email_admins()
 self._sessions = Sessions()
-self.__account_cb_id = host.registerCallback(
+self.__account_cb_id = host.register_callback(
-self._accountDialogCb, with_data=True
+self._account_dialog_cb, with_data=True
 )
-self.__change_password_id = host.registerCallback(
+self.__change_password_id = host.register_callback(
-self.__changePasswordCb, with_data=True
+self.__change_password_cb, with_data=True
 )
-def deleteBlogCallback(posts, comments):
+def delete_blog_callback(posts, comments):
-return lambda data, profile: self.__deleteBlogPostsCb(
+return lambda data, profile: self.__delete_blog_posts_cb(
 posts, comments, data, profile
 )
-self.__delete_posts_id = host.registerCallback(
+self.__delete_posts_id = host.register_callback(
-deleteBlogCallback(True, False), with_data=True
+delete_blog_callback(True, False), with_data=True
 )
-self.__delete_comments_id = host.registerCallback(
+self.__delete_comments_id = host.register_callback(
-deleteBlogCallback(False, True), with_data=True
+delete_blog_callback(False, True), with_data=True
 )
-self.__delete_posts_comments_id = host.registerCallback(
+self.__delete_posts_comments_id = host.register_callback(
-deleteBlogCallback(True, True), with_data=True
+delete_blog_callback(True, True), with_data=True
 )
-self.__delete_account_id = host.registerCallback(
+self.__delete_account_id = host.register_callback(
-self.__deleteAccountCb, with_data=True
+self.__delete_account_cb, with_data=True
 )
 # FIXME: remove this after some time, when the deprecated parameter is really abandoned
-def fixEmailAdmins(self):
+def fix_email_admins(self):
 """Handle deprecated config option "admin_email" to fix the admin emails list"""
-admin_email = self.getConfig("admin_email")
+admin_email = self.config_get("admin_email")
 if not admin_email:
 return
 log.warning(
 "admin_email parameter is deprecated, please use email_admins_list instead"
 )
 param_name = "email_admins_list"
 try:
 section = ""
-value = self.host.memory.getConfig(section, param_name, Exception)
+value = self.host.memory.config_get(section, param_name, Exception)
 except (configparser.NoOptionError, configparser.NoSectionError):
 section = CONFIG_SECTION
-value = self.host.memory.getConfig(
+value = self.host.memory.config_get(
 section, param_name, default_conf[param_name]
 )
 value = set(value)
 value.add(admin_email)
 self.host.memory.config.set(section, param_name, ",".join(value))
-def getConfig(self, name, section=CONFIG_SECTION):
+def config_get(self, name, section=CONFIG_SECTION):
 if name.startswith("email_"):
 # XXX: email_ parameters were first in [plugin account] section
 #      but as it make more sense to have them in common with other plugins,
 #      they can now be in [DEFAULT] section
 try:
-value = self.host.memory.getConfig(None, name, Exception)
+value = self.host.memory.config_get(None, name, Exception)
 except (configparser.NoOptionError, configparser.NoSectionError):
 pass
 else:
 return value
 if section == CONFIG_SECTION:
 default = default_conf[name]
 else:
 default = None
-return self.host.memory.getConfig(section, name, default)
+return self.host.memory.config_get(section, name, default)
-def _registerAccount(self, email, password, profile):
+def _register_account(self, email, password, profile):
 return self.registerAccount(email, password, None, profile)
 def registerAccount(self, email, password, jid_s, profile):
 """Register a new profile, its associated XMPP account, send the confirmation emails.
 - non empty value: bind this JID to the new sat profile
 - None or "": register a new JID on the local XMPP server
 @param profile
 @return Deferred
 """
-d = self.createProfile(password, jid_s, profile)
+d = self.create_profile(password, jid_s, profile)
-d.addCallback(lambda __: self.sendEmails(email, profile))
+d.addCallback(lambda __: self.send_emails(email, profile))
 return d
-def createProfile(self, password, jid_s, profile):
+def create_profile(self, password, jid_s, profile):
 """Register a new profile and its associated XMPP account.
 @param password (unicode): password chosen by the user
 while be used for profile *and* XMPP account
 @param jid_s (unicode): JID to re-use or to register:
 @return Deferred
 """
 if not password or not profile:
 raise exceptions.DataError
-if profile.lower() in self.getConfig("reserved_list"):
+if profile.lower() in self.config_get("reserved_list"):
 return defer.fail(Failure(exceptions.ConflictError))
-d = self.host.memory.createProfile(profile, password)
+d = self.host.memory.create_profile(profile, password)
-d.addCallback(lambda __: self.profileCreated(password, jid_s, profile))
+d.addCallback(lambda __: self.profile_created(password, jid_s, profile))
 return d
-def profileCreated(self, password, jid_s, profile):
+def profile_created(self, password, jid_s, profile):
 """Create the XMPP account and set the profile connection parameters.
 @param password (unicode): password chosen by the user
 @param jid_s (unicode): JID to re-use or to register:
 - non empty value: bind this JID to the new sat profile
 """
 if jid_s:
 d = defer.succeed(None)
 jid_ = jid.JID(jid_s)
 else:
-jid_s = profile + "@" + self.getNewAccountDomain()
+jid_s = profile + "@" + self.account_domain_new_get()
 jid_ = jid.JID(jid_s)
-d = self.host.plugins["XEP-0077"].registerNewAccount(jid_, password)
+d = self.host.plugins["XEP-0077"].register_new_account(jid_, password)
 def setParams(__):
-self.host.memory.setParam(
+self.host.memory.param_set(
 "JabberID", jid_s, "Connection", profile_key=profile
 )
-d = self.host.memory.setParam(
+d = self.host.memory.param_set(
 "Password", password, "Connection", profile_key=profile
 )
 return d
-def removeProfile(failure):
+def remove_profile(failure):
-self.host.memory.asyncDeleteProfile(profile)
+self.host.memory.profile_delete_async(profile)
 return failure
-d.addCallback(lambda __: self.host.memory.startSession(password, profile))
+d.addCallback(lambda __: self.host.memory.start_session(password, profile))
 d.addCallback(setParams)
-d.addCallback(lambda __: self.host.memory.stopSession(profile))
+d.addCallback(lambda __: self.host.memory.stop_session(profile))
-d.addErrback(removeProfile)
+d.addErrback(remove_profile)
 return d
-def _sendEmailEb(self, failure_, email):
+def _send_email_eb(self, failure_, email):
 # TODO: return error code to user
 log.error(
 _("Failed to send account creation confirmation to {email}: {msg}").format(
 email=email, msg=failure_
 )
 )
-def sendEmails(self, email, profile):
+def send_emails(self, email, profile):
 # time to send the email
-domain = self.getNewAccountDomain()
+domain = self.account_domain_new_get()
 # email to the administrators
-admins_emails = self.getConfig("email_admins_list")
+admins_emails = self.config_get("email_admins_list")
 if not admins_emails:
 log.warning(
 "No known admin email, we can't send email to administrator(s).\n"
 "Please fill email_admins_list parameter"
 )
 d_admin = defer.fail(exceptions.DataError("no admin email"))
 else:
 subject = _("New Libervia account created")
 # there is no email when an existing XMPP account is used
 body = f"New account created on {domain}: {profile} [{email or '<no email>'}]"
-d_admin = sat_email.sendEmail(
+d_admin = sat_email.send_email(
 self.host.memory.config, admins_emails, subject, body)
 admins_emails_txt = ", ".join(["<" + addr + ">" for addr in admins_emails])
 d_admin.addCallbacks(
 lambda __: log.debug(
 )
 if not email:
 # TODO: if use register with an existing account, an XMPP message should be sent
 return d_admin
-jid_s = self.host.memory.getParamA(
+jid_s = self.host.memory.param_get_a(
 "JabberID", "Connection", profile_key=profile
 )
 subject = _("Your Libervia account has been created")
 body = _(WELCOME_MSG).format(profile=profile, jid=jid_s, domain=domain)
 # XXX: this will not fail when the email address doesn't exist
 # FIXME: check email reception to validate email given by the user
 # FIXME: delete the profile if the email could not been sent?
-d_user = sat_email.sendEmail(self.host.memory.config, [email], subject, body)
+d_user = sat_email.send_email(self.host.memory.config, [email], subject, body)
 d_user.addCallbacks(
 lambda __: log.debug(
 "Account creation confirmation sent to <{}>".format(email)
 ),
-self._sendEmailEb,
+self._send_email_eb,
 errbackArgs=[email]
 )
 return defer.DeferredList([d_user, d_admin])
-def getNewAccountDomain(self):
+def account_domain_new_get(self):
 """get the domain that will be set to new account"""
-domain = self.getConfig("new_account_domain") or self.getConfig(
+domain = self.config_get("new_account_domain") or self.config_get(
 "xmpp_domain", None
 )
 if not domain:
 log.warning(
 _(
 ).format(default=DEFAULT_DOMAIN)
 )
 return DEFAULT_DOMAIN
 return domain
-def _getAccountDialogUI(self, profile):
+def _get_account_dialog_ui(self, profile):
 """Get the main dialog to manage your account
 @param menu_data
 @param profile: %(doc_profile)s
 @return: XML of the dialog
 """
 title=D_("Manage your account"),
 submit_id=self.__account_cb_id,
 )
 tab_container = form_ui.current_container
-tab_container.addTab(
+tab_container.add_tab(
 "update", D_("Change your password"), container=xml_tools.PairsContainer
 )
 form_ui.addLabel(D_("Current profile password"))
 form_ui.addPassword("current_passwd", value="")
 form_ui.addLabel(D_("New password"))
 form_ui.addPassword("new_passwd2", value="")
 # FIXME: uncomment and fix these features
 """
 if 'GROUPBLOG' in self.host.plugins:
-tab_container.addTab("delete_posts", D_("Delete your posts"), container=xml_tools.PairsContainer)
+tab_container.add_tab("delete_posts", D_("Delete your posts"), container=xml_tools.PairsContainer)
 form_ui.addLabel(D_("Current profile password"))
 form_ui.addPassword("delete_posts_passwd", value="")
 form_ui.addLabel(D_("Delete all your posts and their comments"))
 form_ui.addBool("delete_posts_checkbox", "false")
 form_ui.addLabel(D_("Delete all your comments on other's posts"))
 form_ui.addBool("delete_comments_checkbox", "false")
-tab_container.addTab("delete", D_("Delete your account"), container=xml_tools.PairsContainer)
+tab_container.add_tab("delete", D_("Delete your account"), container=xml_tools.PairsContainer)
 form_ui.addLabel(D_("Current profile password"))
 form_ui.addPassword("delete_passwd", value="")
 form_ui.addLabel(D_("Delete your account"))
 form_ui.addBool("delete_checkbox", "false")
 """
 return form_ui.toXml()
 @defer.inlineCallbacks
-def _accountDialogCb(self, data, profile):
+def _account_dialog_cb(self, data, profile):
 """Called when the user submits the main account dialog
 @param data
 @param profile
 """
-sat_cipher = yield self.host.memory.asyncGetParamA(
+sat_cipher = yield self.host.memory.param_get_a_async(
 C.PROFILE_PASS_PATH[1], C.PROFILE_PASS_PATH[0], profile_key=profile
 )
 @defer.inlineCallbacks
 def verify(attempt):
 delete_checkbox = data[xml_tools.SAT_FORM_PREFIX + 'delete_checkbox']
 if delete_checkbox == 'true':
 verified = yield verify(delete_passwd)
 assert isinstance(verified, bool)
 if verified:
-defer.returnValue(self.__deleteAccount(profile))
+defer.returnValue(self.__delete_account(profile))
 defer.returnValue(error_ui())
 # check for blog posts deletion
 if 'GROUPBLOG' in self.host.plugins:
 delete_posts_passwd = data[xml_tools.SAT_FORM_PREFIX + 'delete_posts_passwd']
 comments = delete_comments_checkbox == 'true'
 if posts or comments:
 verified = yield verify(delete_posts_passwd)
 assert isinstance(verified, bool)
 if verified:
-defer.returnValue(self.__deleteBlogPosts(posts, comments, profile))
+defer.returnValue(self.__delete_blog_posts(posts, comments, profile))
 defer.returnValue(error_ui())
 """
 # check for password modification
 current_passwd = data[xml_tools.SAT_FORM_PREFIX + "current_passwd"]
 if new_passwd1 or new_passwd2:
 verified = yield verify(current_passwd)
 assert isinstance(verified, bool)
 if verified:
 if new_passwd1 == new_passwd2:
-data = yield self.__changePassword(new_passwd1, profile=profile)
+data = yield self.__change_password(new_passwd1, profile=profile)
 defer.returnValue(data)
 else:
 defer.returnValue(
 error_ui(
 D_("The values entered for the new password are not equal.")
 )
 defer.returnValue(error_ui())
 defer.returnValue({})
-def __changePassword(self, password, profile):
+def __change_password(self, password, profile):
 """Ask for a confirmation before changing the XMPP account and SàT profile passwords.
 @param password (str): the new password
 @param profile (str): %(doc_profile)s
 """
-session_id, __ = self._sessions.newSession(
+session_id, __ = self._sessions.new_session(
 {"new_password": password}, profile=profile
 )
 form_ui = xml_tools.XMLUI(
 "form",
 title=D_("Change your password?"),
 )
 )
 form_ui.addText(D_("Continue with changing the password?"))
 return {"xmlui": form_ui.toXml()}
-def __changePasswordCb(self, data, profile):
+def __change_password_cb(self, data, profile):
 """Actually change the user XMPP account and SàT profile password
 @param data (dict)
 @profile (str): %(doc_profile)s
 """
-client = self.host.getClient(profile)
+client = self.host.get_client(profile)
-password = self._sessions.profileGet(data["session_id"], profile)["new_password"]
+password = self._sessions.profile_get(data["session_id"], profile)["new_password"]
 del self._sessions[data["session_id"]]
-def passwordChanged(__):
+def password_changed(__):
-d = self.host.memory.setParam(
+d = self.host.memory.param_set(
 C.PROFILE_PASS_PATH[1],
 password,
 C.PROFILE_PASS_PATH[0],
 profile_key=profile,
 )
 d.addCallback(
-lambda __: self.host.memory.setParam(
+lambda __: self.host.memory.param_set(
 "Password", password, "Connection", profile_key=profile
 )
 )
 confirm_ui = xml_tools.XMLUI("popup", title=D_("Confirmation"))
 confirm_ui.addText(D_("Your password has been changed."))
 error_ui.addText(
 D_("Your password could not be changed: %s") % failure.getErrorMessage()
 )
 return defer.succeed({"xmlui": error_ui.toXml()})
-d = self.host.plugins["XEP-0077"].changePassword(client, password)
+d = self.host.plugins["XEP-0077"].change_password(client, password)
-d.addCallbacks(passwordChanged, errback)
+d.addCallbacks(password_changed, errback)
 return d
-def __deleteAccount(self, profile):
+def __delete_account(self, profile):
 """Ask for a confirmation before deleting the XMPP account and SàT profile
 @param profile
 """
 form_ui = xml_tools.XMLUI(
 "form", title=D_("Delete your account?"), submit_id=self.__delete_account_id
 )
 form_ui.addText(
 D_(
 "All your data stored on %(server)s, including your %(target)s will be erased."
 )
-% {"server": self.getNewAccountDomain(), "target": target}
+% {"server": self.account_domain_new_get(), "target": target}
 )
 form_ui.addText(
 D_(
 "There is no other confirmation dialog, this is the very last one! Are you sure?"
 )
 )
 return {"xmlui": form_ui.toXml()}
-def __deleteAccountCb(self, data, profile):
+def __delete_account_cb(self, data, profile):
 """Actually delete the XMPP account and SàT profile
 @param data
 @param profile
 """
-client = self.host.getClient(profile)
+client = self.host.get_client(profile)
-def userDeleted(__):
+def user_deleted(__):
 # FIXME: client should be disconnected at this point, so 2 next loop should be removed (to be confirmed)
 for jid_ in client.roster._jids:  # empty roster
 client.presence.unsubscribe(jid_)
-for jid_ in self.host.memory.getWaitingSub(
+for jid_ in self.host.memory.sub_waiting_get(
 profile
 ):  # delete waiting subscriptions
-self.host.memory.delWaitingSub(jid_)
+self.host.memory.del_waiting_sub(jid_)
-delete_profile = lambda: self.host.memory.asyncDeleteProfile(
+delete_profile = lambda: self.host.memory.profile_delete_async(
 profile, force=True
 )
 if "GROUPBLOG" in self.host.plugins:
 d = self.host.plugins["GROUPBLOG"].deleteAllGroupBlogsAndComments(
 profile_key=profile
 % failure.getErrorMessage()
 )
 return defer.succeed({"xmlui": error_ui.toXml()})
 d = self.host.plugins["XEP-0077"].unregister(client, jid.JID(client.jid.host))
-d.addCallbacks(userDeleted, errback)
+d.addCallbacks(user_deleted, errback)
 return d
-def __deleteBlogPosts(self, posts, comments, profile):
+def __delete_blog_posts(self, posts, comments, profile):
 """Ask for a confirmation before deleting the blog posts
 @param posts: delete all posts of the user (and their comments)
 @param comments: delete all the comments of the user on other's posts
 @param data
 @param profile
 )
 )
 return {"xmlui": form_ui.toXml()}
-def __deleteBlogPostsCb(self, posts, comments, data, profile):
+def __delete_blog_posts_cb(self, posts, comments, data, profile):
 """Actually delete the XMPP account and SàT profile
 @param posts: delete all posts of the user (and their comments)
 @param comments: delete all the comments of the user on other's posts
 @param profile
 """
 return defer.succeed({"xmlui": error_ui.toXml()})
 d.addCallbacks(deleted, errback)
 return d
-def asyncConnectWithXMPPCredentials(self, jid_s, password):
+def credentials_xmpp_connect(self, jid_s, password):
 """Create and connect a new SàT profile using the given XMPP credentials.
 Re-use given JID and XMPP password for the profile name and profile password.
 @param jid_s (unicode): JID
 @param password (unicode): XMPP password
 @return Deferred(bool)
 @raise exceptions.PasswordError, exceptions.ConflictError
 """
 try:  # be sure that the profile doesn't exist yet
-self.host.memory.getProfileName(jid_s)
+self.host.memory.get_profile_name(jid_s)
 except exceptions.ProfileUnknownError:
 pass
 else:
 raise exceptions.ConflictError
-d = self.createProfile(password, jid_s, jid_s)
+d = self.create_profile(password, jid_s, jid_s)
 d.addCallback(
-lambda __: self.host.memory.getProfileName(jid_s)
+lambda __: self.host.memory.get_profile_name(jid_s)
 )  # checks if the profile has been successfuly created
 d.addCallback(lambda profile: defer.ensureDeferred(
 self.host.connect(profile, password, {}, 0)))
 def connected(result):
-self.sendEmails(None, profile=jid_s)
+self.send_emails(None, profile=jid_s)
 return result
-def removeProfile(
+def remove_profile(
 failure
 ):  # profile has been successfully created but the XMPP credentials are wrong!
 log.debug(
 "Removing previously auto-created profile: %s" % failure.getErrorMessage()
 )
-self.host.memory.asyncDeleteProfile(jid_s)
+self.host.memory.profile_delete_async(jid_s)
 raise failure
 # FIXME: we don't catch the case where the JID host is not an XMPP server, and the user
 # has to wait until the DBUS timeout ; as a consequence, emails are sent to the admins
-# and the profile is not deleted. When the host exists, removeProfile is well called.
+# and the profile is not deleted. When the host exists, remove_profile is well called.
-d.addCallbacks(connected, removeProfile)
+d.addCallbacks(connected, remove_profile)
 return d

Mercurial > libervia-backend

comparison sat/plugins/plugin_misc_account.py @ 4037:524856bd7b19