Merge 72a1720 into b6a7eaa

cfg/conf.yml.orig

@@ -79,4 +79,3 @@ plugins:
         notif_on_attack: False
         max_metter: 100
         attack_duration: 3000
-

smserver/chat_commands/ban.py

@@ -8,58 +8,57 @@
 
 
 class ChatBan(ChatPlugin):
+    """ Command to ban a user """
+
     command = "ban"
     helper = "Ban a user. /ban user"
     permission = ability.Permissions.ban_user
 
-    def __call__(self, serv, message):
-        user = serv.session.query(models.User).filter_by(name=message).first()
+    def __call__(self, resource, message):
+        user = resource.session.query(models.User).filter_by(name=message).first()
+        connection = resource.connection
+
         if not user:
-            serv.send_message("Unknown user %s" % with_color(message), to="me")
-            return
+            return ["Unknown user %s" % with_color(message)]
 
-        if user.level(serv.conn.room) > serv.level(serv.conn.room):
-            serv.send_message("Not authorize to ban %s" % user.fullname_colored(serv.conn.room), to="me")
-            return
+        if user.level(connection.room_id) >= connection.level(connection.room_id):
+            return ["Not authorize to ban %s" % user.fullname_colored(connection.room_id)]
 
-        models.Ban.ban(serv.session, user_id=user.id, room_id=serv.conn.room)
-        ChatKick.kick_user(serv.server, user, serv.room)
+        models.Ban.ban(resource.session, user_id=user.id, room_id=connection.room_id)
+        ChatKick.kick_user(self.server, user, connection.room)
 
-        serv.server.send_message(
+        resource.send(
             "%s ban user %s" % (
-                serv.colored_user_repr(serv.room),
-                user.fullname_colored(serv.room)
-            ),
-            room=serv.room
+                models.User.colored_users_repr(connection.active_users),
+                user.fullname_colored(connection.room_id),
+            )
         )
 
 
 class ChatKick(ChatPlugin):
+    """ Command to kick a user """
+
     command = "kick"
     helper = "kick a user. /kick user"
     permission = ability.Permissions.kick_user
 
-    def __call__(self, serv, message):
-        user = serv.session.query(models.User).filter_by(name=message).first()
+    def __call__(self, resource, message):
+        user = resource.session.query(models.User).filter_by(name=message).first()
+        connection = resource.connection
+
         if not user:
-            serv.send_message("Unknown user %s" % with_color(message), to="me")
-            return
+            return ["Unknown user %s" % with_color(message)]
 
-        if user.level(serv.conn.room) > serv.level(serv.conn.room):
-            serv.send_message("Not authorize to kick %s" % user.fullname_colored(serv.conn.room), to="me")
-            return
+        if user.level(connection.room_id) >= connection.level(connection.room_id):
+            return ["Not authorize to kick %s" % user.fullname_colored(connection.room_id)]
 
-        ret = self.kick_user(serv.server, user, serv.room)
-        if not ret:
-            serv.send_message("Cannot kick user %s" % user.fullname_colored(serv.conn.room))
-            return
+        ChatKick.kick_user(self.server, user, connection.room)
 
-        serv.server.send_message(
+        resource.send(
             "%s kick user %s" % (
-                serv.colored_user_repr(serv.room),
-                user.fullname_colored(serv.room)
-            ),
-            room=serv.room
+                models.User.colored_users_repr(connection.active_users),
+                user.fullname_colored(connection.room_id),
+            )
         )
 
     @staticmethod
@@ -79,18 +78,25 @@ def kick_user(server, user, room=None):
         if user.room != room:
             return
 
-        room_resource.RoomResource(server, user.connection).leave()
+        room_resource.RoomResource(server, connection=user.connection).leave()
 
 class ChatUnBan(ChatPlugin):
+    """ Chat command to unban a user """
+
     command = "unban"
     helper = "UnBan a user. /unban user"
     permission = ability.Permissions.unban_user
 
-    def __call__(self, serv, message):
-        user = serv.session.query(models.User).filter_by(name=message).first()
+    def __call__(self, resource, message):
+        user = resource.session.query(models.User).filter_by(name=message).first()
         if not user:
-            serv.send_message("Unknown user %s" % with_color(message), to="me")
-            return
+            return ["Unknown user %s" % with_color(message)]
+
+        connection = resource.connection
 
-        models.Ban.unban(serv.session, user_id=user.id, room_id=serv.conn.room)
-        serv.send_message("User %s has been unban from this room" % user.fullname_colored(serv.conn.room))
+        models.Ban.unban(resource.session, user_id=user.id, room_id=connection.room_id)
+        resource.send(
+            "User {user} has been unban from this room".format(
+                user=user.fullname_colored(resource.connection.room_id)
+            )
+        )

smserver/chat_commands/general.py

@@ -5,43 +5,67 @@
 
 
 class ChatHelp(ChatPlugin):
+    """ Display the list of all the commands """
+
     command = "help"
     helper = "Show help"
 
-    def __call__(self, serv, message):
-        for command, action in sorted(serv.server.chat_commands.items()):
-            if not action.can(serv):
+    def __call__(self, resource, message):
+        response = []
+
+        commands = self.server.chat_commands
+
+        if message:
+            if message not in commands or not commands[message].can(resource.connection):
+                return ["Unknown command %s" % message]
+
+            return ["/%s: %s" % (message, commands[message].helper)]
+
+        for command, action in sorted(commands.items()):
+            if not action.can(resource.connection):
                 continue
 
-            serv.send_message("/%s: %s" % (command, action.helper), to="me")
+            response.append("/%s: %s" % (command, action.helper))
+
+        return response
 
 class ChatUserListing(ChatPlugin):
+    """ List the users connected """
+
     command = "users"
     helper = "List users"
 
-    def __call__(self, serv, message):
-        users = serv.session.query(models.User).filter_by(online=True)
-        max_users = serv.server.config.server.get("max_users")
-        if serv.room:
-            users = users.filter_by(room_id=serv.room.id)
-            max_users = serv.room.max_users
+    def __call__(self, resource, message, *, limit=20):
+        response = []
 
-        users = users.all()
-        serv.send_message("%s/%s players online" % (len(users), max_users), to="me")
+        connection = resource.connection
 
-        for user in users:
-            serv.send_message(
-                "%s (in %s)" % (
-                    user.fullname_colored(serv.conn.room),
-                    user.enum_status.name),
-                to="me")
+        users = resource.session.query(models.User).filter_by(online=True)
+        max_users = self.server.config.server.get("max_users")
+        if connection.room:
+            users = users.filter_by(room_id=connection.room_id)
+            max_users = connection.room.max_users
 
+        response.append("%s/%s players online" % (users.count(), max_users))
+
+        for user in users.order_by("name").limit(limit):
+            response.append(
+                "%s (in %s)" % (
+                    user.fullname_colored(connection.room_id),
+                    user.enum_status.name
+                )
+            )
+        return response
 
 class ChatTimestamp(ChatPlugin):
+    """ Add the timestamp in the chat messages """
+
     command = "timestamp"
     helper = "Show timestamp"
 
     def __call__(self, serv, message):
+        #FIXME need to be store elsewhere (don't work for the moment)
+
         if serv.conn.chat_timestamp:
             serv.conn.chat_timestamp = False
             serv.send_message("Chat timestamp disabled", to="me")

smserver/chat_commands/role.py

@@ -1,75 +1,80 @@
-
+""" Role chat command """
 
 from smserver import models, ability
 from smserver.chathelper import with_color
 from smserver.chatplugin import ChatPlugin
 
 
 class ChatOP(ChatPlugin):
+    """ Command to OP a user """
+
     command = "op"
     helper = "Change user level to operator. /op user"
     room = True
     permission = ability.Permissions.set_op
 
-    def __call__(self, serv, message):
-        user = serv.session.query(models.User).filter_by(name=message).first()
+    def __call__(self, resource, message):
+        user = resource.session.query(models.User).filter_by(name=message).first()
         if not user:
-            serv.send_message("Unknown user %s" % with_color(message), to="me")
-            return
+            return ["Unknown user %s" % with_color(message)]
 
-        if user.level(serv.conn.room) > serv.level(serv.conn.room):
-            serv.send_message("Not authorize to op %s" % user.fullname_colored(serv.conn.room), to="me")
-            return
+        connection = resource.connection
 
-        user.set_level(serv.room.id, 5)
-        serv.send_message("%s give operator right to %s" % (
-            serv.colored_user_repr(serv.room.id),
-            user.fullname_colored(serv.room.id)
+        if user.level(connection.room_id) > connection.level(connection.room_id):
+            return ["Not authorize to op %s" % user.fullname_colored(connection.room_id)]
+
+        user.set_level(connection.room_id, 5)
+        resource.send("%s give operator right to %s" % (
+            models.User.colored_users_repr(connection.active_users),
+            user.fullname_colored(connection.room_id)
         ))
 
 
 class ChatOwner(ChatPlugin):
+    """ Command to owner a user """
+
     command = "owner"
     helper = "Change user level to owner. /owner user"
     room = True
     permission = ability.Permissions.set_owner
 
-    def __call__(self, serv, message):
-        user = serv.session.query(models.User).filter_by(name=message).first()
+    def __call__(self, resource, message):
+        user = resource.session.query(models.User).filter_by(name=message).first()
         if not user:
-            serv.send_message("Unknown user %s" % with_color(message), to="me")
-            return
+            return ["Unknown user %s" % with_color(message)]
 
-        if user.level(serv.conn.room) > serv.level(serv.conn.room):
-            serv.send_message("Not authorize to owner %s" % user.fullname_colored(serv.conn.room), to="me")
-            return
+        connection = resource.connection
 
-        user.set_level(serv.room.id, 10)
-        serv.send_message("%s give operator right to %s" % (
-            serv.colored_user_repr(serv.room.id),
-            user.fullname_colored(serv.room.id)
+        if user.level(connection.room_id) > connection.level(connection.room_id):
+            return ["Not authorize to owner %s" % user.fullname_colored(connection.room_id)]
+
+        user.set_level(connection.room_id, 10)
+        resource.send("%s give owner right to %s" % (
+            models.User.colored_users_repr(connection.active_users),
+            user.fullname_colored(connection.room_id)
         ))
 
 
 class ChatVoice(ChatPlugin):
+    """ Command to voice a user """
+
     command = "voice"
     helper = "Change user level to voice. /voice user"
     room = True
     permission = ability.Permissions.set_voice
 
-    def __call__(self, serv, message):
-        user = serv.session.query(models.User).filter_by(name=message).first()
+    def __call__(self, resource, message):
+        user = resource.session.query(models.User).filter_by(name=message).first()
         if not user:
-            serv.send_message("Unknown user %s" % with_color(message), to="me")
-            return
+            return ["Unknown user %s" % with_color(message)]
 
-        if user.level(serv.conn.room) > serv.level(serv.conn.room):
-            serv.send_message("Not authorize to voice %s" % user.fullname_colored(serv.conn.room), to="me")
-            return
+        connection = resource.connection
 
-        user.set_level(serv.room.id, 1)
-        serv.send_message("%s give voice right to %s" % (
-            serv.colored_user_repr(serv.room.id),
-            user.fullname_colored(serv.room.id)
-        ))
+        if user.level(connection.room_id) > connection.level(connection.room_id):
+            return ["Not authorize to voice %s" % user.fullname_colored(connection.room_id)]
 
+        user.set_level(connection.room_id, 1)
+        resource.send("%s give voice right to %s" % (
+            models.User.colored_users_repr(connection.active_users),
+            user.fullname_colored(connection.room_id)
+        ))

smserver/chatplugin.py

@@ -1,4 +1,3 @@
-
 """
     This module add the class needed for creating custom chat command
 
@@ -48,32 +47,35 @@ class ChatPlugin(object):
         :rtype: str
     """
 
-    def can(self, serv):
+    def __init__(self, server):
+        self.server = server
+
+    def can(self, connection):
         """
             Method call each time somenone try to run this command
 
-            :param serv: The StepmaniaController instance
-            :type serv: StepmaniaController
+            :param connection: The connection which perform this command
+            :type connection: smserver.models.connection.Connection
             :return: True if authorize False if not
             :rtype: bool
         """
 
-        if self.room and not serv.room:
+        if self.room and not connection.room:
             return False
 
-        if self.permission and serv.cannot(self.permission, serv.conn.room):
+        if self.permission and not connection.can(self.permission, connection.room_id):
             return False
 
         return True
 
-    def __call__(self, serv, message):
+    def __call__(self, resource, message):
         """
             Action to perform when using the command
 
-            :param serv: The StepmaniaController instance
+            :param resource: The chat resource that send this command
             :param message: The text after the command. (Eg. /command text)
-            :type serv: StepmaniaController
+            :type resource: smserve.resources.chat_resources.ChatResource
             :type message: str
-            :return: Nothing
+            :return: Response fo the command
+            :rtype: list
         """
-