'set-welcome' and 'delete-welcome' ad-hoc commands implementation

darcs-hash:20070904162832-86b55-692ca9da8ac5fe8f3ab450e1b46db570cbdb49f3.gz

src/jcl/jabber/command.py

@@ -829,16 +829,43 @@ class JCLCommandManager(CommandManager):
 
     def execute_delete_motd_1(self, info_query, session_context,
                               command_node, lang_class):
-        self.__logger.debug("Executing command 'del motd' step 1")
+        self.__logger.debug("Executing command 'delete motd' step 1")
         self.component.del_motd()
         command_node.setProp("status", STATUS_COMPLETED)
         return (None, [])
 
-    def execute_set_welcome(self, info_query):
+    def execute_set_welcome_1(self, info_query, session_context,
-        return []
+                              command_node, lang_class):
+        self.add_actions(command_node, [ACTION_NEXT])
+        result_form = Form(xmlnode_or_type="result",
+                           title="TODO",
+                           instructions="TODO")
+        result_form.add_field(field_type="hidden",
+                              name="FORM_TYPE",
+                              value="http://jabber.org/protocol/admin")
+        welcome_message = self.component.get_welcome_message()
+        result_form.add_field(name="welcome",
+                              field_type="text-multi",
+                              label="TODO",
+                              value=[welcome_message],
+                              required=True)
+        result_form.as_xml(command_node)
+        return (result_form, [])
 
-    def execute_delete_welcome(self, info_query):
+    def execute_set_welcome_2(self, info_query, session_context,
-        return []
+                              command_node, lang_class):
+        self.__logger.debug("Executing command 'set welcome' step 2")
+        welcome_message = session_context["welcome"][0]
+        self.component.set_welcome_message(welcome_message)
+        command_node.setProp("status", STATUS_COMPLETED)
+        return (None, [])
+
+    def execute_delete_welcome_1(self, info_query, session_context,
+                                 command_node, lang_class):
+        self.__logger.debug("Executing command 'delete welcome' step 1")
+        self.component.del_welcome_message()
+        command_node.setProp("status", STATUS_COMPLETED)
+        return (None, [])
 
     def execute_edit_admin(self, info_query):
         return []

src/jcl/jabber/component.py

@@ -557,30 +557,49 @@ class JCLComponent(Component, object):
                             % (exception, "".join(traceback.format_exception
                                                   (type, value, stack, 5))))
 
-    def get_motd(self):
+    def get_config_parameter(self, section, parameter):
         if self.config is not None \
-               and self.config.has_option("component", "motd"):
+               and self.config.has_option(section, parameter):
-            motd = self.config.get("component", "motd")
+            return self.config.get(section, parameter)
-            return motd
         else:
             return None
 
-    def set_motd(self, motd):
+    def set_config_parameter(self, section, parameter, value):
-        if not self.config.has_section("component"):
+        if not self.config.has_section(section):
-            self.config.add_section("component")
+            self.config.add_section(section)
-        self.config.set("component", "motd", motd)
+        self.config.set(section, parameter, value)
         configFile = open(self.config_file, "w")
         self.config.write(configFile)
         configFile.close()
 
-    def del_motd(self):
+    def del_config_parameter(self, section, parameter):
-        if self.config.has_section("component") \
+        if self.config.has_section(section) \
-           and self.config.has_option("component", "motd"):
+           and self.config.has_option(section, parameter):
-            self.config.remove_option("component", "motd")
+            self.config.remove_option(section, parameter)
             configFile = open(self.config_file, "w")
             self.config.write(configFile)
             configFile.close()
 
+    def get_motd(self):
+        return self.get_config_parameter("component", "motd")
+
+    def set_motd(self, motd):
+        self.set_config_parameter("component", "motd", motd)
+
+    def del_motd(self):
+        self.del_config_parameter("component", "motd")
+
+    def get_welcome_message(self):
+        return self.get_config_parameter("component", "welcome_message")
+
+    def set_welcome_message(self, welcome_message):
+        self.set_config_parameter("component", "welcome_message",
+                                  welcome_message)
+
+    def del_welcome_message(self):
+        self.del_config_parameter("component", "welcome_message")
+
+        
     ###########################################################################
     # Virtual methods
     ###########################################################################
@@ -742,6 +761,12 @@ class AccountManager(object):
             result.append(Presence(from_jid=self.component.jid,
                                    to_jid=from_jid,
                                    stanza_type="subscribe"))
+            welcome_message = self.component.get_welcome_message()
+            if welcome_message is not None:
+                result.append(Message(from_jid=self.component.jid,
+                                      to_jid=from_jid,
+                                      body=welcome_message,
+                                      subject=lang_class.welcome_message_subject))
         if new_account:
             # subscribe to user presence if this is a new account
             result.append(Message(\

src/jcl/jabber/tests/command.py

@@ -2500,23 +2500,143 @@ class JCLCommandManager_TestCase(JCLTestCase):
         self.assertFalse(self.comp.config.has_option("component", "motd"))
         os.unlink(config_file)
 
-#     def test_execute_set_welcome(self):
+    def test_execute_set_welcome(self):
-#         #TODO : implement command
+        self.comp.account_manager.account_classes = (ExampleAccount,
-#         info_query = Iq(stanza_type="set",
+                                                     Example2Account)
-#                         from_jid="user1@test.com",
+        config_file = tempfile.mktemp(".conf", "jcltest", jcl.tests.DB_DIR)
-#                         to_jid="jcl.test.com")
+        self.comp.config_file = config_file
-#         result = self.command_manager.execute_add_user(info_query)
+        self.comp.config = ConfigParser()
-#         self.assertNotEquals(result, None)
+        self.comp.set_welcome_message("Welcome Message")
-#         self.assertEquals(len(result), 1)
+        model.db_connect()
+        user1 = User(jid="test1@test.com")
+        account11 = ExampleAccount(user=user1,
+                                   name="account11",
+                                   jid="account11@jcl.test.com")
+        account11.status = account.ONLINE
+        account12 = Example2Account(user=user1,
+                                    name="account12",
+                                    jid="account12@jcl.test.com")
+        account12.status = "away"
+        user2 = User(jid="test2@test.com")
+        account21 = ExampleAccount(user=user2,
+                                   name="account21",
+                                   jid="account21@jcl.test.com")
+        account21.status = account.OFFLINE
+        account22 = ExampleAccount(user=user2,
+                                   name="account11",
+                                   jid="account11@jcl.test.com")
+        account22.status = account.OFFLINE
+        model.db_disconnect()
+        info_query = Iq(stanza_type="set",
+                        from_jid="user1@test.com",
+                        to_jid="jcl.test.com")
+        command_node = info_query.set_new_content(command.COMMAND_NS, "command")
+        command_node.setProp("node",
+                             "http://jabber.org/protocol/admin#set-welcome")
+        result = self.command_manager.apply_command_action(\
+            info_query,
+            "http://jabber.org/protocol/admin#set-welcome",
+            "execute")
+        self.assertNotEquals(result, None)
+        self.assertEquals(len(result), 1)
+        xml_command = result[0].xpath_eval("c:command",
+                                           {"c": "http://jabber.org/protocol/commands"})[0]
+        self.assertEquals(xml_command.prop("status"), "executing")
+        self.assertNotEquals(xml_command.prop("sessionid"), None)
+        self.__check_actions(result[0], ["next"])
+        fields = result[0].xpath_eval("c:command/data:x/data:field",
+                                      {"c": "http://jabber.org/protocol/commands",
+                                       "data": "jabber:x:data"})
+        self.assertEquals(len(fields), 2)
+        self.assertEquals(fields[1].prop("var"), "welcome")
+        self.assertEquals(fields[1].prop("type"), "text-multi")
+        self.assertEquals(fields[1].children.name, "value")
+        self.assertEquals(fields[1].children.content, "Welcome Message")
+        self.assertEquals(fields[1].children.next.name, "required")
 
-#     def test_execute_delete_welcome(self):
+        # Second step
-#         #TODO : implement command
+        info_query = Iq(stanza_type="set",
-#         info_query = Iq(stanza_type="set",
+                        from_jid="user1@test.com",
-#                         from_jid="user1@test.com",
+                        to_jid="jcl.test.com")
-#                         to_jid="jcl.test.com")
+        command_node = info_query.set_new_content(command.COMMAND_NS, "command")
-#         result = self.command_manager.execute_add_user(info_query)
+        command_node.setProp("node",
-#         self.assertNotEquals(result, None)
+                             "http://jabber.org/protocol/admin#set-welcome")
-#         self.assertEquals(len(result), 1)
+        session_id = xml_command.prop("sessionid")
+        command_node.setProp("sessionid", session_id)
+        command_node.setProp("action", "next")
+        submit_form = Form(xmlnode_or_type="submit")
+        submit_form.add_field(field_type="text-multi",
+                              name="welcome",
+                              value=["New Welcome Message"])
+        submit_form.as_xml(command_node)
+        result = self.command_manager.apply_command_action(\
+            info_query,
+            "http://jabber.org/protocol/admin#set-welcome",
+            "execute")
+        self.assertNotEquals(result, None)
+        self.assertEquals(len(result), 1)
+        xml_command = result[0].xpath_eval("c:command",
+                                           {"c": "http://jabber.org/protocol/commands"})[0]
+        self.assertEquals(xml_command.prop("status"), "completed")
+        self.assertEquals(xml_command.prop("sessionid"), session_id)
+        self.__check_actions(result[0])
+        context_session = self.command_manager.sessions[session_id][1]
+        self.assertEquals(context_session["welcome"],
+                          ["New Welcome Message"])
+        self.comp.config.read(self.comp.config_file)
+        self.assertTrue(self.comp.config.has_option("component", "welcome_message"))
+        self.assertEquals(self.comp.config.get("component", "welcome_message"),
+                          "New Welcome Message")
+        os.unlink(config_file)
+
+    def test_execute_delete_welcome(self):
+        self.comp.account_manager.account_classes = (ExampleAccount,
+                                                     Example2Account)
+        config_file = tempfile.mktemp(".conf", "jcltest", jcl.tests.DB_DIR)
+        self.comp.config_file = config_file
+        self.comp.config = ConfigParser()
+        self.comp.set_motd("test motd")
+        model.db_connect()
+        user1 = User(jid="test1@test.com")
+        account11 = ExampleAccount(user=user1,
+                                   name="account11",
+                                   jid="account11@jcl.test.com")
+        account11.status = account.ONLINE
+        account12 = Example2Account(user=user1,
+                                    name="account12",
+                                    jid="account12@jcl.test.com")
+        account12.status = "away"
+        user2 = User(jid="test2@test.com")
+        account21 = ExampleAccount(user=user2,
+                                   name="account21",
+                                   jid="account21@jcl.test.com")
+        account21.status = account.OFFLINE
+        account22 = ExampleAccount(user=user2,
+                                   name="account11",
+                                   jid="account11@jcl.test.com")
+        account22.status = account.OFFLINE
+        model.db_disconnect()
+        info_query = Iq(stanza_type="set",
+                        from_jid="user1@test.com",
+                        to_jid="jcl.test.com")
+        command_node = info_query.set_new_content(command.COMMAND_NS, "command")
+        command_node.setProp("node",
+                             "http://jabber.org/protocol/admin#delete-welcome")
+        result = self.command_manager.apply_command_action(\
+            info_query,
+            "http://jabber.org/protocol/admin#delete-welcome",
+            "execute")
+        self.assertNotEquals(result, None)
+        self.assertEquals(len(result), 1)
+        xml_command = result[0].xpath_eval("c:command",
+                                           {"c": "http://jabber.org/protocol/commands"})[0]
+        self.assertEquals(xml_command.prop("status"), "completed")
+        self.assertNotEquals(xml_command.prop("sessionid"), None)
+        self.__check_actions(result[0])
+        self.comp.config.read(self.comp.config_file)
+        self.assertFalse(self.comp.config.has_option("component",
+                                                     "welcome_message"))
+        os.unlink(config_file)
 
 #     def test_execute_edit_admin(self):
 #         #TODO : implement command

src/jcl/jabber/tests/component.py

@@ -1128,6 +1128,77 @@ class JCLComponent_TestCase(JCLTestCase):
         self.assertEquals(presence_account.get_node().prop("type"),
                           "subscribe")
 
+    def test_handle_set_register_new_with_welcome_message(self):
+        self.comp.stream = MockStream()
+        self.comp.stream_class = MockStream
+        config_file = tempfile.mktemp(".conf", "jcltest", jcl.tests.DB_DIR)
+        self.comp.config_file = config_file
+        self.comp.config = ConfigParser()
+        self.comp.config.read(self.comp.config_file)
+        self.comp.config.add_section("component")
+        self.comp.config.set("component", "welcome_message",
+                             "Welcome Message")
+        self.comp.config.write(open(self.comp.config_file, "w"))
+        x_data = Form("submit")
+        x_data.add_field(name="name",
+                         value="account1",
+                         field_type="text-single")
+        iq_set = Iq(stanza_type="set",
+                    from_jid="user1@test.com",
+                    to_jid="jcl.test.com")
+        query = iq_set.new_query("jabber:iq:register")
+        x_data.as_xml(query, None)
+        self.comp.handle_set_register(iq_set)
+
+        model.db_connect()
+        _account = account.get_account("user1@test.com", "account1")
+        self.assertNotEquals(_account, None)
+        self.assertEquals(_account.user.jid, "user1@test.com")
+        self.assertEquals(_account.name, "account1")
+        self.assertEquals(_account.jid, "account1@jcl.test.com")
+        model.db_disconnect()
+
+        stanza_sent = self.comp.stream.sent
+        self.assertEquals(len(stanza_sent), 5)
+        iq_result = stanza_sent[0]
+        self.assertTrue(isinstance(iq_result, Iq))
+        self.assertEquals(iq_result.get_node().prop("type"), "result")
+        self.assertEquals(iq_result.get_from(), "jcl.test.com")
+        self.assertEquals(iq_result.get_to(), "user1@test.com")
+
+        presence_component = stanza_sent[1]
+        self.assertTrue(isinstance(presence_component, Presence))
+        self.assertEquals(presence_component.get_from(), "jcl.test.com")
+        self.assertEquals(presence_component.get_to(), "user1@test.com")
+        self.assertEquals(presence_component.get_node().prop("type"),
+                          "subscribe")
+
+        message = stanza_sent[2]
+        self.assertTrue(isinstance(message, Message))
+        self.assertEquals(message.get_from(), "jcl.test.com")
+        self.assertEquals(message.get_to(), "user1@test.com")
+        self.assertEquals(message.get_subject(),
+                          Lang.en.welcome_message_subject)
+        self.assertEquals(message.get_body(),
+                          "Welcome Message")
+
+        message = stanza_sent[3]
+        self.assertTrue(isinstance(message, Message))
+        self.assertEquals(message.get_from(), "jcl.test.com")
+        self.assertEquals(message.get_to(), "user1@test.com")
+        self.assertEquals(message.get_subject(),
+                          _account.get_new_message_subject(Lang.en))
+        self.assertEquals(message.get_body(),
+                          _account.get_new_message_body(Lang.en))
+
+        presence_account = stanza_sent[4]
+        self.assertTrue(isinstance(presence_account, Presence))
+        self.assertEquals(presence_account.get_from(), "account1@jcl.test.com")
+        self.assertEquals(presence_account.get_to(), "user1@test.com")
+        self.assertEquals(presence_account.get_node().prop("type"),
+                          "subscribe")
+        os.unlink(config_file)
+
     def test_handle_set_register_new_multiple_types(self):
         self.comp.stream = MockStream()
         self.comp.stream_class = MockStream
@@ -2560,6 +2631,68 @@ class JCLComponent_TestCase(JCLTestCase):
         self.assertFalse(self.comp.config.has_option("component", "motd"))
         os.unlink(config_file)
 
+    def test_get_welcome_message(self):
+        config_file = tempfile.mktemp(".conf", "jcltest", jcl.tests.DB_DIR)
+        self.comp.config_file = config_file
+        self.comp.config = ConfigParser()
+        self.comp.config.read(self.comp.config_file)
+        self.comp.config.add_section("component")
+        self.comp.config.set("component", "welcome_message", "Welcome Message")
+        self.comp.config.write(open(self.comp.config_file, "w"))
+        motd = self.comp.get_welcome_message()
+        self.assertEquals(motd, "Welcome Message")
+        os.unlink(config_file)
+
+    def test_get_no_welcome_message(self):
+        config_file = tempfile.mktemp(".conf", "jcltest", jcl.tests.DB_DIR)
+        self.comp.config_file = config_file
+        self.comp.config = ConfigParser()
+        self.comp.config.read(self.comp.config_file)
+        self.comp.config.write(open(self.comp.config_file, "w"))
+        motd = self.comp.get_welcome_message()
+        self.assertEquals(motd, None)
+        os.unlink(config_file)
+
+    def test_set_new_welcome_message(self):
+        config_file = tempfile.mktemp(".conf", "jcltest", jcl.tests.DB_DIR)
+        self.comp.config_file = config_file
+        self.comp.config = ConfigParser()
+        self.comp.set_welcome_message("Welcome Message")
+        self.comp.config.read(self.comp.config_file)
+        self.assertTrue(self.comp.config.has_option("component",
+                                                    "welcome_message"))
+        self.assertEquals(self.comp.config.get("component", "welcome_message"),
+                          "Welcome Message")
+        os.unlink(config_file)
+
+    def test_set_welcome_message(self):
+        config_file = tempfile.mktemp(".conf", "jcltest", jcl.tests.DB_DIR)
+        self.comp.config_file = config_file
+        self.comp.config = ConfigParser()
+        self.comp.config.add_section("component")
+        self.comp.config.set("component", "welcome_message", "Welcome Message")
+        self.comp.config.write(open(self.comp.config_file, "w"))
+        self.comp.set_welcome_message("New Welcome Message")
+        self.comp.config.read(self.comp.config_file)
+        self.assertTrue(self.comp.config.has_option("component",
+                                                    "welcome_message"))
+        self.assertEquals(self.comp.config.get("component", "welcome_message"),
+                          "New Welcome Message")
+        os.unlink(config_file)
+
+    def test_del_welcome_message(self):
+        config_file = tempfile.mktemp(".conf", "jcltest", jcl.tests.DB_DIR)
+        self.comp.config_file = config_file
+        self.comp.config = ConfigParser()
+        self.comp.config.add_section("component")
+        self.comp.config.set("component", "welcome_message", "Welcome Message")
+        self.comp.config.write(open(self.comp.config_file, "w"))
+        self.comp.del_welcome_message()
+        self.comp.config.read(self.comp.config_file)
+        self.assertFalse(self.comp.config.has_option("component",
+                                                     "welcome_message"))
+        os.unlink(config_file)
+
     ###########################################################################
     # 'handle_command' tests
     ###########################################################################

src/jcl/lang.py

@@ -117,6 +117,8 @@ class Lang:
         command_add_user = u"Create new account"
         select_account_type = u"Select account type"
 
+        welcome_message_subject = u"Welcome"
+
     class fr:
         component_name = u"composant générique Jabber Component Library"
         register_title = u"Enregistrement d'une nouvelle connexion"
@@ -165,6 +167,8 @@ class Lang:
         command_add_user = u"Créer un compte"
         select_account_type = u"Selectionner le type de comptes"
 
+        welcome_message_subject = u"Bienvenue"
+
     class nl:
         # TODO: when finish, delete this line and uncomment in tests/lang.py the makeSuite(Language_nl_TestCase, 'test') line
         register_title = u"Registratie van verbindingen voor Jabber Mail"

src/jcl/tests/lang.py

@@ -121,6 +121,8 @@ class Language_TestCase(unittest.TestCase):
         self.assertNotEquals(self.lang_class.command_add_user, None)
         self.assertNotEquals(self.lang_class.select_account_type, None)
 
+        self.assertNotEquals(self.lang_class.welcome_message_subject, None)
+
 class Language_fr_TestCase(Language_TestCase):
     def setUp(self):
         self.lang_class = Lang.fr