Create an new account if trying to update a non existing one

darcs-hash:20071030210255-86b55-fbe6be24abeee3c2d21e21c6db2b2b5767be6ce1.gz

src/jcl/jabber/component.py

@@ -249,6 +249,7 @@ class AccountManager(object):
     def update_account(self,
                        account_name,
                        from_jid,
+                       account_type,
                        lang_class,
                        x_data):
         """Update account"""
@@ -263,9 +264,12 @@ class AccountManager(object):
                                          first_account=False,
                                          from_jid=from_jid)
         else:
-            self.__logger.error("Account " + account_name +
+            account_class = self.get_account_class(account_type)
-                                " was not found, cannot update it")
+            return self.create_account(account_name,
-            return []
+                                       from_jid,
+                                       account_class,
+                                       lang_class,
+                                       x_data)
 
     def create_account(self,
                        account_name,

src/jcl/jabber/register.py

@@ -66,11 +66,13 @@ class RootSetRegisterHandler(SetRegisterHandler):
         self.__logger = logging.getLogger("jcl.jabber.RootSetRegisterHandler")
 
     def filter(self, stanza, lang_class, x_data):
-        """"""
+        """
+        """
         return jabber.root_filter(self, stanza, lang_class)
 
     def handle(self, info_query, lang_class, data, x_data):
-        """"""
+        """
+        """
         self.__logger.debug("root_set_register")
         _account = None
         if not "name" in x_data or x_data["name"].value == "":
@@ -101,17 +103,25 @@ class AccountSetRegisterHandler(SetRegisterHandler):
         self.__logger = logging.getLogger("jcl.jabber.AccountSetRegisterHandler")
 
     def filter(self, stanza, lang_class, x_data):
-        """"""
+        """
+        """
         return jabber.account_filter(self, stanza, lang_class)
 
     def handle(self, info_query, lang_class, data, x_data):
-        """"""
+        """
+        """
         self.__logger.debug("account_set_register")
         _account = None
+        resource = info_query.get_to().resource
+        if resource is not None:
+            account_type = resource.split("/")[0]
+        else:
+            account_type = ""
         try:
             info_queries = self.account_manager.update_account(\
                 x_data["name"].value,
                 info_query.get_from(),
+                account_type,
                 lang_class,
                 x_data)
             info_queries.insert(0, info_query.make_result_response())
@@ -127,11 +137,13 @@ class AccountTypeSetRegisterHandler(SetRegisterHandler):
         self.__logger = logging.getLogger("jcl.jabber.AccountTypeSetRegisterHandler")
 
     def filter(self, stanza, lang_class, x_data):
-        """"""
+        """
+        """
         return jabber.account_type_filter(self, stanza, lang_class)
 
     def handle(self, info_query, lang_class, data, x_data):
-        """"""
+        """
+        """
         self.__logger.debug("account_type_set_register")
         account_type = data
         _account = None

src/jcl/jabber/tests/component.py

@@ -1500,6 +1500,59 @@ class JCLComponent_TestCase(JCLTestCase):
         self.assertEquals(stanza_error.get_text(),
                           Lang.en.mandatory_field % ("login"))
 
+    def test_handle_set_register_update_not_existing(self):
+        self.comp.stream = MockStream()
+        self.comp.stream_class = MockStream
+        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/res",
+                    to_jid="account1@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), 4)
+        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(), "account1@jcl.test.com")
+        self.assertEquals(iq_result.get_to(), "user1@test.com/res")
+
+        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/res")
+        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[3]
+        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")
+
     def test_handle_set_register_update_complex(self):
         model.db_connect()
         self.comp.stream = MockStream()
@@ -1544,7 +1597,7 @@ class JCLComponent_TestCase(JCLTestCase):
                          field_type="text-single")
         iq_set = Iq(stanza_type="set",
                     from_jid="user1@test.com/res",
-                    to_jid="account1@jcl.test.com")
+                    to_jid="account1@jcl.test.com/Example")
         query = iq_set.new_query("jabber:iq:register")
         x_data.as_xml(query)
         self.comp.handle_set_register(iq_set)
@@ -1568,7 +1621,7 @@ class JCLComponent_TestCase(JCLTestCase):
         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(), "account1@jcl.test.com")
+        self.assertEquals(iq_result.get_from(), "account1@jcl.test.com/Example")
         self.assertEquals(iq_result.get_to(), "user1@test.com/res")
 
         message = stanza_sent[1]