mirror of
https://github.com/evennia/evennia.git
synced 2026-03-30 20:47:17 +02:00
811 lines
27 KiB
Python
811 lines
27 KiB
Python
"""
|
|
Comsys command module.
|
|
"""
|
|
|
|
from src.comms.models import Channel, Msg, ChannelConnection
|
|
from src.comms.channelhandler import CHANNELHANDLER
|
|
from src.utils import create, utils
|
|
from src.permissions.permissions import has_perm
|
|
from src.commands.default.muxcommand import MuxCommand
|
|
|
|
def find_channel(caller, channelname, silent=False):
|
|
"""
|
|
Helper function for searching for a single channel with
|
|
some error handling.
|
|
"""
|
|
channels = Channel.objects.channel_search(channelname)
|
|
if not channels:
|
|
if not silent:
|
|
caller.msg("Channel '%s' not found." % channelname)
|
|
return None
|
|
elif len(channels) > 1:
|
|
matches = ", ".join(["%s(%s)" % (chan.key, chan.id) for chan in channels])
|
|
if not silent:
|
|
caller.msg("Multiple channels match (be more specific): \n%s" % matches)
|
|
return None
|
|
return channels[0]
|
|
|
|
class CmdAddCom(MuxCommand):
|
|
"""
|
|
addcom - subscribe to a channel with optional alias
|
|
|
|
Usage:
|
|
addcom [alias=] <channel>
|
|
|
|
Joins a given channel. If alias is given, this will allow you to
|
|
refer to the channel by this alias rather than the full channel
|
|
name. Subsequent calls of this command can be used to add multiple
|
|
aliases to an already joined channel.
|
|
"""
|
|
|
|
key = "addcom"
|
|
aliases = ["aliaschan","chanalias"]
|
|
help_category = "Comms"
|
|
|
|
def func(self):
|
|
"Implement the command"
|
|
|
|
caller = self.caller
|
|
args = self.args
|
|
player = caller.player
|
|
|
|
if not args:
|
|
caller.msg("Usage: addcom [alias =] channelname.")
|
|
return
|
|
|
|
if self.rhs:
|
|
# rhs holds the channelname
|
|
channelname = self.rhs
|
|
alias = self.lhs
|
|
else:
|
|
channelname = self.args
|
|
alias = None
|
|
|
|
channel = find_channel(caller, channelname)
|
|
if not channel:
|
|
# we use the custom search method to handle errors.
|
|
return
|
|
|
|
# check permissions
|
|
if not has_perm(player, channel, 'chan_listen'):
|
|
caller.msg("You are not allowed to listen to this channel.")
|
|
return
|
|
|
|
string = ""
|
|
if not channel.has_connection(player):
|
|
# we want to connect as well.
|
|
if not channel.connect_to(player):
|
|
# if this would have returned True, the player is connected
|
|
caller.msg("You are not allowed to join this channel.")
|
|
return
|
|
else:
|
|
string += "You now listen to the channel %s. " % channel.key
|
|
|
|
if alias:
|
|
# create a nick and add it to the caller.
|
|
caller.nickhandler(alias, channel.key, nick_type="channel")
|
|
string += "You can now refer to the channel %s with the alias '%s'."
|
|
caller.msg(string % (channel.key, alias))
|
|
else:
|
|
string += "No alias added."
|
|
caller.msg(string)
|
|
|
|
|
|
class CmdDelCom(MuxCommand):
|
|
"""
|
|
delcom - unsubscribe from channel or remove channel alias
|
|
|
|
Usage:
|
|
delcom <alias or channel>
|
|
|
|
If the full channel name is given, unsubscribe from the
|
|
channel. If an alias is given, remove the alias but don't
|
|
unsubscribe.
|
|
"""
|
|
|
|
key = "delcom"
|
|
aliases = ["delaliaschan, delchanalias"]
|
|
help_category = "Comms"
|
|
|
|
def func(self):
|
|
"Implementing the command. "
|
|
|
|
caller = self.caller
|
|
player = caller.player
|
|
|
|
if not self.args:
|
|
caller.msg("Usage: delcom <alias or channel>")
|
|
return
|
|
ostring = self.args.lower()
|
|
|
|
channel = find_channel(caller, ostring, silent=True)
|
|
if channel:
|
|
# we have given a channel name - unsubscribe
|
|
if not channel.has_connection(player):
|
|
caller.msg("You are listening to that channel.")
|
|
return
|
|
chkey = channel.key.lower()
|
|
# find all nicks linked to this channel and delete them
|
|
for nick in [nick for nick in caller.nicks
|
|
if nick.db_type == "channel" and nick.db_real.lower() == chkey]:
|
|
nick.delete()
|
|
channel.disconnect_from(player)
|
|
caller.msg("You stop listening to channel '%s'. Eventual aliases were removed." % channel.key)
|
|
return
|
|
else:
|
|
# we are removing a channel nick
|
|
channame = caller.nickhandler(ostring, nick_type="channel")
|
|
channel = find_channel(caller, channame, silent=True)
|
|
if not channel:
|
|
caller.msg("No channel with alias '%s' was found." % ostring)
|
|
else:
|
|
caller.nickhandler(ostring, nick_type="channel", delete=True)
|
|
caller.msg("Your alias '%s' for channel %s was cleared." % (ostring, channel.key))
|
|
|
|
# def cmd_allcom(command):
|
|
# """
|
|
# allcom - operate on all channels
|
|
|
|
# Usage:
|
|
# allcom [on | off | who | clear]
|
|
|
|
# Allows the user to universally turn off or on all channels they are on,
|
|
# as well as perform a 'who' for all channels they are on. Clear deletes
|
|
# all channels.
|
|
|
|
# Without argument, works like comlist.
|
|
# """
|
|
|
|
# caller = self.caller
|
|
# arg = self.args
|
|
# if not arg:
|
|
# cmd_comlist(command)
|
|
# caller.msg("(allcom arguments: 'on', 'off', 'who' and 'clear'.)")
|
|
# return
|
|
# arg = arg.strip()
|
|
# if arg == 'clear':
|
|
# cmd_clearcom(command)
|
|
# return
|
|
|
|
# #get names and alias of all subscribed channels
|
|
# chandict = comsys.plr_get_cdict(self.session)
|
|
# aliaslist = chandict.keys()
|
|
# aliaslist.sort()
|
|
# if arg == "on":
|
|
# for alias in aliaslist:
|
|
# comsys.plr_chan_on(self.session, alias)
|
|
# elif arg == "off":
|
|
# for alias in aliaslist:
|
|
# comsys.plr_chan_off(self.session, alias)
|
|
# elif arg == "who":
|
|
# s = ""
|
|
# if not aliaslist:
|
|
# s += " (No channels) "
|
|
# for alias in aliaslist:
|
|
# s += "-- %s (alias: %s)\n" % (chandict[alias][0],alias)
|
|
# sess_list = comsys.get_cwho_list(chandict[alias][0])
|
|
# objlist = [sess.get_pobject() for sess in sess_list]
|
|
# plist = [p.get_name(show_dbref=caller.sees_dbrefs())
|
|
# for p in filter(lambda o: o.is_player(), objlist)]
|
|
# olist = [o.get_name(show_dbref=caller.sees_dbrefs())
|
|
# for o in filter(lambda o: not o.is_player(), objlist)]
|
|
# plist.sort()
|
|
# olist.sort()
|
|
# if plist:
|
|
# s += " Players:\n "
|
|
# for pname in plist:
|
|
# s += "%s, " % pname
|
|
# s = s[:-2] + "\n"
|
|
# if olist:
|
|
# s += " Objects:\n "
|
|
# for oname in olist:
|
|
# s += "%s, " % oname
|
|
# s = s[:-2] + "\n"
|
|
# s = s[:-1]
|
|
# caller.msg(s)
|
|
# GLOBAL_CMD_TABLE.add_self("allcom", cmd_allcom, help_category="Comms")
|
|
|
|
## def cmd_clearcom(self):
|
|
## """
|
|
## clearcom - removes all channels
|
|
|
|
## Usage:
|
|
## clearcom
|
|
|
|
## Effectively runs delcom on all channels the user is on. It will remove
|
|
## their aliases, remove them from the channel, and clear any titles they
|
|
## have set.
|
|
## """
|
|
## caller = self.caller
|
|
## #get aall subscribed channel memberships
|
|
## memberships = caller.channel_membership_set.all()
|
|
|
|
## if not memberships:
|
|
## s = "No channels to delete. "
|
|
## else:
|
|
## s = "Deleting all channels in your subscriptions ...\n"
|
|
## for membership in memberships:
|
|
## chan_name = membership.channel.get_name()
|
|
## s += "You have left %s.\n" % chan_name
|
|
## comsys.plr_del_channel(caller, membership.user_alias)
|
|
## comsys.send_cmessage(chan_name, "%s has left the channel." % caller.get_name(show_dbref=False))
|
|
## s = s[:-1]
|
|
## caller.msg(s)
|
|
## GLOBAL_CMD_TABLE.add_self("clearcom", cmd_clearcom)
|
|
|
|
|
|
class CmdChannels(MuxCommand):
|
|
"""
|
|
@clist
|
|
|
|
Usage:
|
|
@channels
|
|
@clist
|
|
comlist
|
|
|
|
Lists all available channels available to you, wether you listen to them or not.
|
|
Use 'comlist" to only view your current channel subscriptions.
|
|
"""
|
|
key = "@channels"
|
|
aliases = ["@clist", "channels", "comlist", "chanlist", "channellist", "all channels"]
|
|
help_category = "Comms"
|
|
|
|
def func(self):
|
|
"Implement function"
|
|
|
|
caller = self.caller
|
|
|
|
# all channels we have available to listen to
|
|
channels = [chan for chan in Channel.objects.get_all_channels() if has_perm(caller, chan, 'can_listen')]
|
|
if not channels:
|
|
caller.msg("No channels available")
|
|
return
|
|
# all channel we are already subscribed to
|
|
subs = [conn.channel for conn in ChannelConnection.objects.get_all_player_connections(caller.player)]
|
|
|
|
if self.cmdstring != "comlist":
|
|
|
|
string = "\nAll available channels:"
|
|
cols = [[" "], ["Channel"], ["Aliases"], ["Perms"], ["Description"]]
|
|
for chan in channels:
|
|
if chan in subs:
|
|
cols[0].append(">")
|
|
else:
|
|
cols[0].append(" ")
|
|
cols[1].append(chan.key)
|
|
cols[2].append(",".join(chan.aliases))
|
|
cols[3].append(",".join(chan.permissions))
|
|
cols[4].append(chan.desc)
|
|
# put into table
|
|
for ir, row in enumerate(utils.format_table(cols)):
|
|
if ir == 0:
|
|
string += "\n{w" + "".join(row) + "{n"
|
|
else:
|
|
string += "\n" + "".join(row)
|
|
self.caller.msg(string)
|
|
|
|
string = "\nYour channel subscriptions:"
|
|
if not subs:
|
|
string += "(None)"
|
|
else:
|
|
nicks = [nick for nick in caller.nicks if nick.db_type == 'channel']
|
|
print nicks
|
|
cols = [["Channel"], ["Aliases"], ["Description"]]
|
|
for chan in subs:
|
|
cols[0].append(chan.key)
|
|
cols[1].append(",".join([nick.db_nick for nick in nicks
|
|
if nick.db_real.lower() == chan.key.lower()] + chan.aliases))
|
|
cols[2].append(chan.desc)
|
|
# put into table
|
|
for ir, row in enumerate(utils.format_table(cols)):
|
|
if ir == 0:
|
|
string += "\n{w" + "".join(row) + "{n"
|
|
else:
|
|
string += "\n" + "".join(row)
|
|
caller.msg(string)
|
|
|
|
class CmdCdestroy(MuxCommand):
|
|
"""
|
|
@cdestroy
|
|
|
|
Usage:
|
|
@cdestroy <channel>
|
|
|
|
Destroys a channel that you control.
|
|
"""
|
|
|
|
key = "@cdestroy"
|
|
help_category = "Comms"
|
|
|
|
def func(self):
|
|
"Destroy objects cleanly."
|
|
caller = self.caller
|
|
|
|
if not self.args:
|
|
caller.msg("Usage: @cdestroy <channelname>")
|
|
return
|
|
channel = find_channel(caller, self.args)
|
|
if not channel:
|
|
caller.msg("Could not find channel %s." % self.args)
|
|
return
|
|
if not has_perm(caller, channel, 'chan_admin', default_deny=True):
|
|
caller.msg("You are not allowed to do that.")
|
|
return
|
|
|
|
message = "%s is being destroyed. Make sure to change your aliases." % channel
|
|
msgobj = create.create_message(caller, message, channel)
|
|
channel.msg(msgobj)
|
|
channel.delete()
|
|
CHANNELHANDLER.update()
|
|
caller.msg("%s was destroyed." % channel)
|
|
|
|
|
|
## def cmd_cset(self):
|
|
## """
|
|
## @cset
|
|
|
|
## Sets various flags on a channel.
|
|
## """
|
|
## # TODO: Implement cmd_cset
|
|
## pass
|
|
|
|
## def cmd_ccharge(self):
|
|
## """
|
|
## @ccharge
|
|
|
|
## Sets the cost to transmit over a channel. Default is free.
|
|
## """
|
|
## # TODO: Implement cmd_ccharge
|
|
## pass
|
|
|
|
## def cmd_cboot(self):
|
|
## """
|
|
## @cboot
|
|
|
|
## Usage:
|
|
## @cboot[/quiet] <channel> = <player or object>
|
|
|
|
## Kicks a player or object from a channel you control.
|
|
## """
|
|
## caller = self.caller
|
|
## args = self.args
|
|
## switches = self.self_switches
|
|
|
|
## if not args or not "=" in args:
|
|
## caller.msg("Usage: @cboot[/quiet] <channel> = <object>")
|
|
## return
|
|
## cname, objname = args.split("=",1)
|
|
## cname, objname = cname.strip(), objname.strip()
|
|
## if not cname or not objname:
|
|
## caller.msg("You must supply both channel and object.")
|
|
## return
|
|
## try:
|
|
## channel = CommChannel.objects.get(name__iexact=cname)
|
|
## except CommChannel.DoesNotExist:
|
|
## caller.msg("Could not find channel %s." % cname)
|
|
## return
|
|
|
|
## #do we have power over this channel?
|
|
## if not channel.controlled_by(caller) or caller.has_perm("channels.channel_admin"):
|
|
## caller.msg("You don't have that power in channel '%s'." % cname)
|
|
## return
|
|
|
|
## #mux specification requires an * before player objects.
|
|
## player_boot = False
|
|
## if objname[0] == '*':
|
|
## player_boot = True
|
|
## objname = objname[1:]
|
|
## bootobj = Object.objects.player_name_search(objname)
|
|
## if not bootobj:
|
|
## caller.msg("Object '%s' not found." % objname)
|
|
## return
|
|
## if bootobj.is_player() and not player_boot:
|
|
## caller.msg("To boot players you need to start their name with an '*'. ")
|
|
## return
|
|
|
|
## #check so that this object really is on the channel in the first place
|
|
## membership = bootobj.channel_membership_set.filter(channel__name__iexact=cname)
|
|
## if not membership:
|
|
## caller.msg("'%s' is not on channel '%s'." % (objname,cname))
|
|
## return
|
|
|
|
## #announce to channel
|
|
## if not 'quiet' in switches:
|
|
## comsys.send_cmessage(cname, "%s boots %s from channel." % \
|
|
## (caller.get_name(show_dbref=False), objname))
|
|
|
|
## #all is set, boot the object by removing all its aliases from the channel.
|
|
## for mship in membership:
|
|
## comsys.plr_del_channel(bootobj, mship.user_alias)
|
|
|
|
## GLOBAL_CMD_TABLE.add_self("@cboot", cmd_cboot, help_category="Comms")
|
|
|
|
|
|
## def cmd_cemit(self):
|
|
## """
|
|
## @cemit - send a message to channel
|
|
|
|
## Usage:
|
|
## @cemit <channel>=<message>
|
|
## @cemit/noheader <channel>=<message>
|
|
## @cemit/sendername <channel>=<message>
|
|
|
|
## Allows the user to send a message over a channel as long as
|
|
## they own or control it. It does not show the user's name unless they
|
|
## provide the /sendername switch.
|
|
|
|
## [[channel_selfs]]
|
|
|
|
## Useful channel selfs
|
|
## (see their help pages for detailed help and options)
|
|
|
|
## - Listing channels
|
|
## clist - show all channels available to you
|
|
## comlist - show channels you listen to
|
|
|
|
## - Joining/parting channels
|
|
## addcom - add your alias for a channel
|
|
## delcom - remove alias for channel
|
|
## (leave channel if no more aliases)
|
|
## allcom - view, on/off or remove all your channels
|
|
## clearcom - removes all channels
|
|
|
|
## - Other
|
|
## who - list who's online
|
|
## <chanalias> off - silence channel temporarily
|
|
## <chanalias> on - turn silenced channel back on
|
|
## """
|
|
## caller = self.caller
|
|
|
|
## if not self.args:
|
|
## caller.msg("@cemit[/switches] <channel> = <message>")
|
|
## return
|
|
|
|
## eq_args = self.args.split('=', 1)
|
|
|
|
## if len(eq_args) != 2:
|
|
## caller.msg("You must provide a channel name and a message to emit.")
|
|
## return
|
|
|
|
## cname = eq_args[0].strip()
|
|
## cmessage = eq_args[1].strip()
|
|
## final_cmessage = cmessage
|
|
## if len(cname) == 0:
|
|
## caller.msg("You must provide a channel name to emit to.")
|
|
## return
|
|
## if len(cmessage) == 0:
|
|
## caller.msg("You must provide a message to emit.")
|
|
## return
|
|
|
|
## name_matches = comsys.cname_search(cname, exact=True)
|
|
## if name_matches:
|
|
## cname_parsed = name_matches[0].get_name()
|
|
## else:
|
|
## caller.msg("Could not find channel %s." % (cname,))
|
|
## return
|
|
|
|
## # If this is False, don't show the channel header before
|
|
## # the message. For example: [Public] Woohoo!
|
|
## show_channel_header = True
|
|
## if "noheader" in self.self_switches:
|
|
## if not caller.has_perm("objects.emit_commchannel"):
|
|
## caller.msg(defines_global.NOPERMS_MSG)
|
|
## return
|
|
## final_cmessage = cmessage
|
|
## show_channel_header = False
|
|
## else:
|
|
## if "sendername" in self.self_switches:
|
|
## if not comsys.plr_has_channel(self.session, cname_parsed,
|
|
## return_muted=False):
|
|
## caller.msg("You must be on %s to do that." % (cname_parsed,))
|
|
## return
|
|
## final_cmessage = "%s: %s" % (caller.get_name(show_dbref=False),
|
|
## cmessage)
|
|
## else:
|
|
## if not caller.has_perm("objects.emit_commchannel"):
|
|
## caller.msg(defines_global.NOPERMS_MSG)
|
|
## return
|
|
## final_cmessage = cmessage
|
|
|
|
## if not "quiet" in self.self_switches:
|
|
## caller.msg("Sent - %s" % (name_matches[0],))
|
|
## comsys.send_cmessage(cname_parsed, final_cmessage,
|
|
## show_header=show_channel_header)
|
|
|
|
## #pipe to external channels (IRC, IMC) eventually mapped to this channel
|
|
## comsys.send_cexternal(cname_parsed, cmessage, caller=caller)
|
|
|
|
## GLOBAL_CMD_TABLE.add_self("@cemit", cmd_cemit,priv_tuple=("channels.emit_commchannel",),
|
|
## help_category="Comms")
|
|
|
|
## def cmd_cwho(self):
|
|
## """
|
|
## @cwho
|
|
|
|
## Usage:
|
|
## @cwho channel[/all]
|
|
|
|
## Displays the name, status and object type for a given channel.
|
|
## Adding /all after the channel name will list disconnected players
|
|
## as well.
|
|
## """
|
|
## session = self.session
|
|
## caller = self.caller
|
|
|
|
## if not self.args:
|
|
## cmd_clist(self)
|
|
## caller.msg("Usage: @cwho <channel>[/all]")
|
|
## return
|
|
|
|
## channel_name = self.args
|
|
|
|
## if channel_name.strip() == '':
|
|
## caller.msg("You must specify a channel name.")
|
|
## return
|
|
|
|
## name_matches = comsys.cname_search(channel_name, exact=True)
|
|
|
|
## if name_matches:
|
|
## # Check to make sure the user has permission to use @cwho.
|
|
## is_channel_admin = caller.has_perm("objects.channel_admin")
|
|
## is_controlled_by_plr = name_matches[0].controlled_by(caller)
|
|
|
|
## if is_controlled_by_plr or is_channel_admin:
|
|
## comsys.msg_cwho(caller, channel_name)
|
|
## else:
|
|
## caller.msg("Permission denied.")
|
|
## return
|
|
## else:
|
|
## caller.msg("No channel with that name was found.")
|
|
## return
|
|
## GLOBAL_CMD_TABLE.add_self("@cwho", cmd_cwho, help_category="Comms")
|
|
|
|
class CmdChannelCreate(MuxCommand):
|
|
"""
|
|
@ccreate
|
|
channelcreate
|
|
Usage:
|
|
@ccreate <new channel>[;alias;alias...] = description
|
|
|
|
Creates a new channel owned by you.
|
|
"""
|
|
|
|
key = "@ccreate"
|
|
aliases = "channelcreate"
|
|
permissions = "cmd:ccreate"
|
|
help_category = "Comms"
|
|
|
|
def func(self):
|
|
"Implement the command"
|
|
|
|
caller = self.caller
|
|
|
|
if not self.args:
|
|
caller.msg("Usage @ccreate <channelname>[;alias;alias..] = description")
|
|
return
|
|
|
|
description = ""
|
|
|
|
if self.rhs:
|
|
description = self.rhs
|
|
lhs = self.lhs
|
|
channame = lhs
|
|
aliases = None
|
|
if ';' in lhs:
|
|
channame, aliases = [part.strip().lower()
|
|
for part in lhs.split(';', 1) if part.strip()]
|
|
aliases = [alias.strip().lower()
|
|
for alias in aliases.split(';') if alias.strip()]
|
|
channel = Channel.objects.channel_search(channame)
|
|
if channel:
|
|
caller.msg("A channel with that name already exists.")
|
|
return
|
|
# Create and set the channel up
|
|
permissions = "chan_send:%s,chan_listen:%s,chan_admin:has_id(%s)" % \
|
|
("Players","Players",caller.id)
|
|
new_chan = create.create_channel(channame, aliases, description, permissions)
|
|
new_chan.connect_to(caller)
|
|
caller.msg("Created channel %s and connected to it." % new_chan.key)
|
|
|
|
|
|
## def cmd_cchown(self):
|
|
## """
|
|
## @cchown
|
|
|
|
## Usage:
|
|
## @cchown <channel> = <player>
|
|
|
|
## Changes the owner of a channel.
|
|
## """
|
|
## caller = self.caller
|
|
## args = self.args
|
|
## if not args or "=" not in args:
|
|
## caller.msg("Usage: @cchown <channel> = <player>")
|
|
## return
|
|
## cname, pname = args.split("=",1)
|
|
## cname, pname = cname.strip(), pname.strip()
|
|
## #locate channel
|
|
## try:
|
|
## channel = CommChannel.objects.get(name__iexact=cname)
|
|
## except CommChannel.DoesNotExist:
|
|
## caller.msg("Channel '%s' not found." % cname)
|
|
## return
|
|
## #check so we have ownership to give away.
|
|
## if not channel.controlled_by(caller) and not caller.has_perm("channels.channel_admin"):
|
|
## caller.msg("You don't control this channel.")
|
|
## return
|
|
## #find the new owner
|
|
## new_owner = Object.objects.player_name_search(pname)
|
|
## if not new_owner:
|
|
## caller.msg("New owner '%s' not found." % pname)
|
|
## return
|
|
## old_owner = channel.get_owner()
|
|
## old_pname = old_owner.get_name(show_dbref=False)
|
|
## if old_owner == new_owner:
|
|
## caller.msg("Owner unchanged.")
|
|
## return
|
|
## #all is set, change owner
|
|
## channel.set_owner(new_owner)
|
|
## caller.msg("Owner of %s changed from %s to %s." % (cname, old_pname, pname))
|
|
## new_owner.msg("%s transfered ownership of channel '%s' to you." % (old_pname, cname))
|
|
## GLOBAL_CMD_TABLE.add_self("@cchown", cmd_cchown, help_category="Comms")
|
|
|
|
|
|
class CmdCdesc(MuxCommand):
|
|
"""
|
|
@cdesc - set channel description
|
|
|
|
Usage:
|
|
@cdesc <channel> = <description>
|
|
|
|
Changes the description of the channel as shown in
|
|
channel lists.
|
|
"""
|
|
|
|
key = "@cdesc"
|
|
permissions = "cmd:cdesc"
|
|
help_category = "Comms"
|
|
|
|
def func(self):
|
|
"Implement command"
|
|
|
|
caller = self.caller
|
|
|
|
if not self.rhs:
|
|
caller.msg("Usage: @cdesc <channel> = <description>")
|
|
return
|
|
channel = find_channel(caller, self.lhs)
|
|
if not channel:
|
|
caller.msg("Channel '%s' not found." % self.lhs)
|
|
return
|
|
#check permissions
|
|
if not has_perm(caller, channel, 'channel_admin'):
|
|
caller.msg("You cant admin this channel.")
|
|
return
|
|
# set the description
|
|
channel.desc = self.rhs
|
|
channel.save()
|
|
caller.msg("Description of channel '%s' set to '%s'." % (channel.key, self.rhs))
|
|
|
|
class CmdPage(MuxCommand):
|
|
"""
|
|
page - send private message
|
|
|
|
Usage:
|
|
page[/switches] [<player>,<player>,... = <message>]
|
|
tell ''
|
|
page/list <number>
|
|
|
|
Switch:
|
|
list - show your last <number> of tells/pages.
|
|
|
|
Send a message to target user (if online). If no
|
|
argument is given, you will instead see who was the last
|
|
person you paged to.
|
|
"""
|
|
|
|
key = "page"
|
|
aliases = ['tell']
|
|
permissions = "cmd:tell"
|
|
help_category = "Comms"
|
|
|
|
def func(self):
|
|
|
|
"Implement function using the Msg methods"
|
|
|
|
caller = self.caller
|
|
player = caller.player
|
|
|
|
# get the messages we've sent
|
|
messages_we_sent = list(Msg.objects.get_messages_by_sender(player))
|
|
pages_we_sent = [msg for msg in messages_we_sent
|
|
if msg.receivers]
|
|
# get last messages we've got
|
|
pages_we_got = list(Msg.objects.get_messages_by_receiver(player))
|
|
|
|
if 'list' in self.switches:
|
|
pages = pages_we_sent + pages_we_got
|
|
pages.sort(lambda x, y: cmp(x.date_sent, y.date_sent))
|
|
|
|
number = 10
|
|
if self.args:
|
|
try:
|
|
number = int(self.args)
|
|
except ValueError:
|
|
pass
|
|
|
|
if len(pages) > number:
|
|
lastpages = pages[-number:]
|
|
else:
|
|
lastpages = pages
|
|
|
|
lastpages = "\n ".join(["{w%s{n {c%s{n to {c%s{n: %s" % (utils.datetime_format(page.date_sent),
|
|
page.sender.name,
|
|
"{n,{c ".join([obj.name for obj in page.receivers]),
|
|
page.message)
|
|
for page in lastpages])
|
|
caller.msg("Your latest pages:\n %s" % lastpages )
|
|
return
|
|
|
|
if not self.args or not self.rhs:
|
|
if pages_we_sent:
|
|
string = "You last paged {c%s{n." % (", ".join([obj.name
|
|
for obj in pages_we_sent[-1].receivers]))
|
|
caller.msg(string)
|
|
return
|
|
else:
|
|
string = "You haven't paged anyone yet."
|
|
caller.msg(string)
|
|
return
|
|
|
|
# We are sending. Build a list of targets
|
|
|
|
if not self.lhs:
|
|
# If there are no targets, then set the targets
|
|
# to the last person they paged.
|
|
if pages_we_sent:
|
|
receivers = pages_we_sent[-1].receivers
|
|
else:
|
|
caller.msg("Who do you want to page?")
|
|
return
|
|
else:
|
|
receivers = self.lhslist
|
|
|
|
recobjs = []
|
|
for receiver in set(receivers):
|
|
if isinstance(receiver, basestring):
|
|
pobj = caller.search("*%s" % (receiver.lstrip('*')), global_search=True)
|
|
if not pobj:
|
|
return
|
|
elif hasattr(receiver, 'character'):
|
|
pobj = receiver.character
|
|
else:
|
|
caller.msg("Who do you want to page?")
|
|
return
|
|
recobjs.append(pobj)
|
|
if not recobjs:
|
|
caller.msg("No players matching your target were found.")
|
|
return
|
|
|
|
header = "{wPlayer{n {c%s{n {wpages:{n" % caller.key
|
|
message = self.rhs
|
|
|
|
# if message begins with a :, we assume it is a 'page-pose'
|
|
if message.startswith(":"):
|
|
message = "%s %s" % (caller.key, message.strip(':').strip())
|
|
|
|
# create the persistent message object
|
|
msg = create.create_message(player, message,
|
|
receivers=recobjs)
|
|
|
|
# tell the players they got a message.
|
|
received = []
|
|
for pobj in recobjs:
|
|
pobj.msg("%s %s" % (header, message))
|
|
if hasattr(pobj, 'has_player') and not pobj.has_player:
|
|
received.append("{C%s{n" % pobj.name)
|
|
caller.msg("%s is offline. They will see your message if they list their pages later." % received[-1])
|
|
else:
|
|
received.append("{c%s{n" % pobj.name)
|
|
received = ", ".join(received)
|
|
caller.msg("You paged %s with: '%s'." % (received, message))
|