david/jcl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

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

Browse Source 
darcs-hash:20070904162832-86b55-692ca9da8ac5fe8f3ab450e1b46db570cbdb49f3.gz
This commit is contained in:
David Rousselie
2007-09-04 18:28:32 +02:00
parent 61e7e256f0
commit 32ffc1ed89
6 changed files with 344 additions and 33 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
src/jcl/jabber/command.py
View File

@@ -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):
return []
def execute_set_welcome_1(self, info_query, session_context,
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):
return []
def execute_set_welcome_2(self, info_query, session_context,
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 []

49
src/jcl/jabber/component.py
View File

@@ -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"):
motd = self.config.get("component", "motd")
return motd
and self.config.has_option(section, parameter):
return self.config.get(section, parameter)
else:
return None
def set_motd(self, motd):
if not self.config.has_section("component"):
self.config.add_section("component")
self.config.set("component", "motd", motd)
def set_config_parameter(self, section, parameter, value):
if not self.config.has_section(section):
self.config.add_section(section)
self.config.set(section, parameter, value)
configFile = open(self.config_file, "w")
self.config.write(configFile)
configFile.close()
def del_motd(self):
if self.config.has_section("component") \
and self.config.has_option("component", "motd"):
self.config.remove_option("component", "motd")
def del_config_parameter(self, section, parameter):
if self.config.has_section(section) \
and self.config.has_option(section, parameter):
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(\

152
src/jcl/jabber/tests/command.py
View File

@@ -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):
# #TODO : implement command
# info_query = Iq(stanza_type="set",
# from_jid="user1@test.com",
# to_jid="jcl.test.com")
# result = self.command_manager.execute_add_user(info_query)
# self.assertNotEquals(result, None)
# self.assertEquals(len(result), 1)
def test_execute_set_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_welcome_message("Welcome Message")
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):
# #TODO : implement command
# info_query = Iq(stanza_type="set",
# from_jid="user1@test.com",
# to_jid="jcl.test.com")
# result = self.command_manager.execute_add_user(info_query)
# self.assertNotEquals(result, None)
# self.assertEquals(len(result), 1)
# Second step
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")
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

133
src/jcl/jabber/tests/component.py
View File

@@ -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
###########################################################################

4
src/jcl/lang.py
View File

@@ -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"

2
src/jcl/tests/lang.py
View File

@@ -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