def board_post_startpost(self, lhs=None, rhs=None):
if self.group:
bb_type = '+gb'
else:
bb_type = '+bb'
if self.character.db.curpost:
message = "You have a post in progress. Use %sproof to view it, %spost to post it, or %stoss to erase it."
self.error(message % (bb_type, bb_type, bb_type))
return
findname, subject = lhs.split('/', 2)
if not findname:
self.error("No board entered.")
return
if not subject:
self.error("No subject entered.")
return
try:
board_group = self.board_group
board = board_group.find_board(find_name=findname.strip(), checker=self.character)
except ValueError as err:
self.error(unicode(err))
return
if not board.perm_check(self.character, 'write'):
self.error("Permission denied.")
return
curpost = {'subject': sanitize_string(subject), 'board': board, 'group': self.group}
self.character.db.curpost = curpost
self.sys_msg("You have begun writing a post. Use %s to add text." % bb_type)
def func(self):
rhs = self.rhs
lhs = self.lhs
switches = self.final_switches
if self.cmdstring.startswith('.'):
rest_string = self.raw_string[1:]
rest_string = sanitize_string(rest_string)
if ' ' in rest_string:
lhs, rhs = rest_string.split(' ', 1)
else:
lhs = rest_string
rhs = None
if '/' in lhs:
lhs, self.switches = lhs.split('/', 1)
self.parse_switches()
switches = self.final_switches
if switches:
switch = switches[0]
getattr(self, 'switch_%s' % switch)(lhs, rhs)
return
if self.args:
self.switch_broadcast(lhs, rhs)
return
else:
self.switch_list(lhs, rhs)
def valid_slot(input):
if not input:
raise ValueError("No slot name entered!")
input = sanitize_string(input)
if not re.match(r"\w+", input):
raise ValueError("The only characters allowed in slot names are alphanumerics and underscores.")
return input
def valid_groupname(newname=None):
if not newname:
raise ValueError("Group Name is empty.")
newname = sanitize_string(newname, strip_ansi=True)
if len(newname) > 35:
raise ValueError("Group names may not exceed 35 characters in length.")
return newname
def valid_rankname(newname=None):
if not newname:
raise ValueError("Rank Name is empty.")
newname = sanitize_string(newname)
if len(newname) > 35:
raise ValueError("Rank Names may not exceed 35 characters in length.")
return newname
def valid_name(namecheck=None):
if not namecheck:
raise ValueError("Name field empty.")
namecheck = sanitize_string(namecheck, strip_ansi=True)
if not re.match('^[\w-]+$', namecheck):
raise ValueError("File '%s' could not be set: Info names must be alphanumeric." % namecheck)
if len(namecheck) > 18:
raise ValueError("Info File names may not exceed 18 characters.")
return namecheck
def switch_create(self):
if not self.args:
self.error("No name entered!")
return
new_name = sanitize_string(self.lhs, strip_ansi=True)
if District.objects.filter(key__iexact=new_name).count():
self.error("That name is taken.")
return
district = District.objects.create(key=new_name)
self.sys_msg("District '%s' created!" % district)
def add(self, creator, name=None):
if not name:
raise ValueError("No name entered!")
name = dramatic_capitalize(sanitize_string(name))
if self.model.stats.filter(key__iexact=name).count():
raise ValueError("Name already in use.")
new_mod = self.model.stats.create(key=name, creator=creator)
new_stat = self.use(self, new_mod)
self.stats.append(new_stat)
self.stats_dict[new_mod.id] = new_stat
return new_stat
def rename(self, new_name):
if not new_name:
raise ValueError("No new name entered!")
clean_name = sanitize_string(new_name, strip_ansi=True)
if self.__class__.objects.filter(key__iexact=clean_name).exclude(id=self.id).count():
raise ValueError("Names must be unique, case insensitive.")
else:
if self.key == clean_name:
return
self.key = clean_name
self.save(update_fields=['key'])
def make_board(self, key=None):
if not key:
raise ValueError("Board requires a name.")
new_name = sanitize_string(key, strip_ansi=True)
try:
new_num = max([board.order for board in self.boards.all()]) + 1
except ValueError:
new_num = 1
board = self.boards.create(key=new_name, order=new_num)
board.init_locks()
return board
def add(self, name=None):
if not name:
raise ValueError("No specialty name entered!")
name = dramatic_capitalize(sanitize_string(name))
if self.game.specialties.filter(stat_id=self.id, key__iexact=name).count():
raise ValueError("Specialty name already in use.")
new_mod = self.game.specialties.create(stat_id=self.id, key=name)
new_spec = self.specialty(self, new_mod)
self.specialties.append(new_spec)
self.specialties_dict[new_mod.id] = new_spec
return new_spec
def character(key, player):
from athanor.core.config import GLOBAL_SETTINGS
key = sanitize_string(key, strip_ansi=True)
typeclass = settings.BASE_CHARACTER_TYPECLASS
home = GLOBAL_SETTINGS['character_home']
if key.upper() in SPEECH_FACTORY.upper():
raise ValueError("That character name is already in use!")
char = create_object(typeclass=typeclass, key=key, location=home, home=home)
player.account.bind_character(char)
SPEECH_FACTORY.update(char)
return char
def extend(self, name=None):
if not self.can_extend:
raise ValueError("Cannot extend %s with new sub-categories." %
self.name)
if not name:
raise ValueError("No name entered!")
name = dramatic_capitalize(sanitize_string(name))
new_mod = self.model.children.create(game=self.game, key=name)
new_sub = self.sub(self, root=self.root, model=new_mod)
self.subs.append(new_sub)
self.subs_dict[new_sub.sub_id] = new_sub
self.subs_name[name] = new_sub
return new_sub
def create(self, creator, name=None):
if not self.can_create:
raise ValueError("Cannot add entries to %s!" % self.name)
if not name:
raise ValueError("No name entered!")
name = dramatic_capitalize(sanitize_string(name))
if self.model.entries.filter(key__iexact=name).count():
raise ValueError("Name is already in use!")
new_mod = self.model.entries.create(creator=creator, key=name)
new_stat = self.stat(self, new_mod)
self.stats.append(new_stat)
self.stats_dict[new_stat.id] = new_stat
self.stats_name[name] = new_stat
return new_stat
def switch_title(self, lhs, rhs):
try:
slot_name = valid_slot(lhs)
except ValueError as err:
self.error(unicode(err))
return
slot = self.character.radio.filter(key__istartswith=slot_name).first()
if not slot:
self.error("Radio slot not found.")
return
if rhs:
slot.title = sanitize_string(rhs)
slot.save(update_fields=['title'])
self.sys_msg("Title changed to: %s" % rhs)
else:
slot.title = None
slot.save(update_fields=['title'])
self.sys_msg("Title cleared.")
def switch_groups(self):
penn_groups = cobj('gop').children.all()
for old_group in penn_groups:
if not old_group.group:
old_group.group, created = Group.objects.get_or_create(key=old_group.name)
old_group.save(update_fields=['group'])
new_group = old_group.group
new_group.description = old_group.mushget('DESCRIBE')
old_ranks = old_group.lattrp('RANK`\d+')
old_rank_nums = [old_rank.split('`', 1)[1] for old_rank in old_ranks]
rank_dict = dict()
for num in old_rank_nums:
new_rank, created = new_group.ranks.get_or_create(num=int(num))
rank_name = old_group.mushget('RANK`%s`NAME' % num)
if rank_name:
new_rank.name = sanitize_string(rank_name)
new_rank.save(update_fields=['name'])
rank_dict[int(num)] = new_rank
old_members = [objmatch(member) for member in old_group.mushget('MEMBERS').split(' ') if objmatch(member)]
for old_member in old_members:
if not old_member.obj:
continue
old_num = int(old_member.mushget('D`GROUP`%s`RANK' % old_group.dbref)) or 4
title = old_member.mushget('D`GROUP`%s`NAME' % old_group.dbref)
if not title:
title = None
new_member, created = new_group.participants.get_or_create(character=old_member.obj, title=title,
rank=rank_dict[old_num])
for channel in [new_group.ic_channel, new_group.ooc_channel]:
if channel:
if channel.locks.check(new_member.character, 'listen'):
channel.connect(new_member.character)
new_group.save()
board_group, created = BoardGroup.objects.get_or_create(main=0, group=new_group)
for old_board in old_group.contents.all():
if not old_board.board:
old_board.board = board_group.make_board(key=old_board.name)
old_board.save(update_fields=['board'])
new_board = old_board.board
old_order = int(old_board.mushget('ORDER'))
new_board.order = old_order
new_board.save()
self.convert_board(new_board)
def switch_codename(self, lhs, rhs):
try:
slot_name = valid_slot(lhs)
except ValueError as err:
self.error(unicode(err))
return
slot = self.character.radio.filter(key__istartswith=slot_name).first()
if not slot:
self.error("Radio slot not found.")
return
if rhs:
if Character.objects.filter_family(db_key__iexact=rhs).count():
self.error("Cannot set your codename to an existing character's name.")
return
slot.codename = sanitize_string(rhs)
slot.save(update_fields=['codename'])
self.sys_msg("Codename changed to: %s" % rhs)
else:
slot.codename = None
slot.save(update_fields=['codename'])
self.sys_msg("Codename cleared.")
def switch_color(self, lhs, rhs):
try:
slot_name = valid_slot(lhs)
except ValueError as err:
self.error(unicode(err))
return
slot = self.character.radio.filter(key__istartswith=slot_name).first()
if not slot:
self.error("Radio slot not found.")
return
if rhs:
if len(ANSIString('|%s' % rhs)) != 0:
self.error("That is not a valid color code.")
return
slot.color = sanitize_string(rhs)
slot.save(update_fields=['color'])
self.sys_msg("Color changed to: %s" % rhs)
else:
slot.color = None
slot.save(update_fields=['color'])
self.sys_msg("Color cleared.")
def board_post_quickpost(self, lhs=None, rhs=None):
if not lhs:
self.error("No board entered.")
return
findname, subject = lhs.split('/', 2)
if not findname:
self.error("No board entered.")
return
if not subject:
self.error("No subject entered.")
return
if not rhs:
self.error("No post text entered.")
return
try:
board_group = self.board_group
board = board_group.find_board(find_name=findname.strip(), checker=self.character)
except ValueError as err:
self.error(unicode(err))
return
board.make_post(stub=self.character.stub, subject=sanitize_string(subject),
text=penn_substitutions(rhs.strip()))
def clean_string(value):
return dramatic_capitalize(sanitize_string(value, strip_ansi=True, strip_mxp=True,
strip_newlines=True, strip_indents=True))
