async def sort_roles(server):
"""
Sort roles alphabetically
"""
# Get all roles
rlist = {}
for chan in chain(server.get_chans_in_cat(PUB_CAT),
server.get_chans_in_cat(PRV_CAT)):
rlist["%s-op" % chan.name] = \
dutils.get_role_by_name(server, "%s-op" % chan.name)
member_role = dutils.get_role_by_name(server, "%s-member" % chan.name)
if member_role:
rlist["%s-member" % chan.name] = member_role
# Sort them and position starting from the first alphanumeric role
print("Base position is %s" % str(sorted(rlist.keys())[0]))
crt_pos = rlist[sorted(rlist.keys())[0]].position
for rname in sorted(rlist.keys()):
print("Setting %s to %d" % (rname, crt_pos))
if crt_pos != rlist[rname].position:
await rlist[rname].set_position(crt_pos)
crt_pos -= 1
def serialize(self):
data = {}
data["server_id"] = self.server.id
data["channel_id"] = self.channel.id
data["first_role_id"] = dutils.get_role_by_name(self.server, self.first_role).id
data["last_role_id"] = dutils.get_role_by_name(self.server, self.last_role).id
data["max_selectable"] = self.max_selectable
data["title"] = self.title
data["msg_id"] = self.get_msg_id()
data["shown_page"] = self.shown_page
return data
def check_exp_time(rstorage, command_name, role, server):
if command_name not in rstorage:
return
tnow = datetime.datetime.now().timestamp()
to_del = []
for elem in rstorage[command_name]:
if elem['expire'] < tnow:
to_del.append(elem)
for elem in to_del:
role = dutils.get_role_by_name(server, role)
member = dutils.get_user_by_id(server, elem["user"])
new_roles = []
for role_id in elem['crt_roles']:
role = dutils.get_role_by_id(server, role_id)
if role:
new_roles.append(role)
if member:
member.replace_roles(new_roles)
rstorage[command_name].remove(elem)
rstorage.sync()
async def verified(server, author, event):
"""Get server access rights"""
verif = get_role_by_name(server, "Verified")
author.add_role(verif)
await event.msg.async_add_reaction(u"👍")
async def votat(author, event, server):
role = dutils.get_role_by_name(server, "A votat")
author.add_role(role)
try:
await event.msg.async_add_reaction(u"👍")
except:
import traceback
traceback.print_exc()
def make_nsfw(server, storage, reply, event, text, send_message):
"""
<topic> - make channel NSFW (only channel OPs can do it)
"""
target_chan, categ = find_irc_chan(server,
storage,
chan_id=event.channel.id)
if not target_chan:
return "You're not in a user managed channel"
if categ["type"] == PUB_CAT:
return "Only private channels can be made NSFW"
# Check if user is OP
has_right = user_has_role(event.author, "%s-op" % event.channel.name)
if not has_right:
return "Only channel OPs can do that"
# Set NSFW
target_chan.set_nsfw(True)
# Add NSFW to topic
if target_chan.topic and "NSFW" not in target_chan.topic:
target_chan.set_topic(text + " [NSFW]")
# Purge non-NSFW users
member_role = dutils.get_role_by_name(server,
"%s-member" % target_chan.name)
op_role = dutils.get_role_by_name(server, "%s-op" % target_chan.name)
for user in target_chan.members_accessing_chan():
for urole in user.roles:
if urole.name == NSFW_FORBID_ROLE:
user.remove_role(member_role)
user.remove_role(op_role)
send_message("Part <@%s> - because channel was made NSFW" %
user.id,
target=target_chan.id)
user.send_pm(
"You have been removed from %s, because the channel was made NSFW."
% target_chan.name)
async def ok(event, text, str_to_id, server):
try:
role = dutils.get_role_by_name(server, "Valoare")
user = dutils.get_user_by_id(server, str_to_id(text))
await event.msg.async_add_reaction(u"👍")
user.add_role(role)
except:
import traceback
traceback.print_exc()
def auto_ok(server, event, send_message, storage):
if server.id != RODDIT_ID:
return
creation_date = datetime.datetime.utcfromtimestamp(
int((int(event.member.id) >> 22) + 1420070400000) / 1000)
age = (datetime.datetime.now() - creation_date).total_seconds()
abulau = storage["join_params"]["abulau"]
avaloare = storage["join_params"]["aval"]
if age < abulau:
role = dutils.get_role_by_name(server, "Bulău")
event.member.add_role(role)
send_message(target="449899630176632842",
text="Auto-bulau given to <@%s>" % event.member.id)
elif age < avaloare:
send_message(target="449899630176632842",
text="Auto-valoare not given to <@%s>" % event.member.id)
else:
role = dutils.get_role_by_name(server, "Valoare")
event.member.add_role(role)
send_message(target="449899630176632842",
text="Auto-valoare given to <@%s>" % event.member.id)
async def create_channel(text, server, reply):
"""
<name type founder> - create a channel by specifying a 'name', type (either 'public' or 'private') and who is the channel founder
"""
# Check input
text = text.split(" ")
if len(text) != 3:
return create_channel.__doc__
# Parse data
chname = text[0].lower()
chtype = text[1].lower()
user = dutils.get_user_by_id(server, dutils.str_to_id(text[2]))
if not user:
reply("Could not find given user")
return
if chtype not in CHTYPES:
reply("Channel type must be one of: %s" % str(CHTYPES))
return
# Check dupes
for chan in chain(server.get_chans_in_cat(PUB_CAT),
server.get_chans_in_cat(PRV_CAT)):
if chan.name == chname:
reply("A channel by that name already exists")
return
await server.create_role("%s-op" % chname, mentionable=True)
if chtype == PUB_CAT:
await server.create_text_channel(chname, PUB_CAT)
elif chtype == PRV_CAT:
await server.create_text_channel(chname, PRV_CAT)
await server.create_role("%s-member" % chname, mentionable=True)
print("Created roles")
await sort_roles(server)
await sort_chans(server, PUB_CAT)
await sort_chans(server, PRV_CAT)
await resync_roles(server)
# Add the OP
user.add_role(dutils.get_role_by_name(server, "%s-op" % chname))
print("Should be done!")
def create_temp_role_cmd(text, hook, str_to_id, server, bot, storage):
"""
<command name, role> - create a command that assigns a temporary role by specifying `command_name role`
"""
text = text.split()
# Check if length is correct
if len(text) < 2:
return create_temp_role_cmd.__doc__
cmd = text[0]
# Check minumum length
if len(cmd) < 5:
return "Command length needs to be at least 5."
# Check that command exists
if hook.root.get_command(cmd) != None:
return "Command `%s` already exists. Try using another name." % cmd
# Get the given role
role = dutils.get_role_by_id(server, str_to_id(text[1]))
if not role:
role = dutils.get_role_by_name(server, text[1])
if not role:
return "No such role " + text[1]
if "cmds" not in storage:
storage["cmds"] = {}
# Create new object
new_cmd = {}
new_cmd["cmd_type"] = "temporary"
new_cmd["name"] = cmd
new_cmd["role_id"] = role.id
new_cmd["role_name"] = role.name
storage["cmds"][cmd] = new_cmd
storage.sync()
register_cmd(new_cmd, server)
return "Done"
def assign_temp_role(rstorage, server, bot, role, text, command_name,
str_to_id, event):
data = text.split(" ")
if len(data) < 2:
return "Needs at least user and time (and reason) (e.g. .{CMD} @plp, 5m - to give @plp {CMD} for 5 minutes OR .{CMD} @plp 5m bad user - to give @plp {CMD} for 5m and save the reason \"bad user\")".format(
CMD=command_name), None
reason = "Not given"
if len(data) >= 3:
reason = " ".join(data[2:])
user = str_to_id(data[0])
stime = data[1]
total_seconds = 0
last_start = 0
for pos, char in enumerate(stime):
if char in time_tokens:
value = int(stime[last_start:pos])
if char == 's':
total_seconds += value
elif char == 'm':
total_seconds += value * SEC_IN_MIN
elif char == 'h':
total_seconds += value * SEC_IN_HOUR
elif char == 'd':
total_seconds += value * SEC_IN_DAY
last_start = pos + 1
texp = datetime.datetime.now().timestamp() + total_seconds
brole = dutils.get_role_by_name(server, role)
member = dutils.get_user_by_id(server, user)
if brole == None or member == None:
print("Internal error " + str(brole) + str(member))
return "Internal error.", None
extra = False
crt_roles = []
if user in rstorage:
extra = True
for role in member.roles:
# if brole.id == role.id:
# extra = True
# break
crt_roles.append(role.id)
if command_name not in rstorage:
rstorage[command_name] = []
for entry in rstorage[command_name]:
if entry["user"] == user:
extra = True
break
if not extra:
reason_entry = add_reason(rstorage, event, member, reason, server,
texp, brole.name)
new_entry = {}
new_entry["user"] = user
new_entry["expire"] = texp
new_entry["crt_roles"] = crt_roles
new_entry["reason_id"] = reason_entry["Case ID"]
rstorage[command_name].append(new_entry)
member.replace_roles([brole])
rstorage.sync()
return "Gave <@%s> %s seconds %s time" % (user, str(total_seconds),
command_name), reason_entry
else:
reason_entry = adjust_time(rstorage, event, user, command_name, texp)
return "Adjusted time for user to %d" % total_seconds, reason_entry
return "wat"
async def do_stuff(self, event, label):
# Check for role assign spam
if await self.is_spam(event):
return
# Get the channel name
chname = label.split("**")[1]
# Lookup channel
target_chan, categ = find_irc_chan(self.server,
self.storage,
chan_name=chname)
if not target_chan:
return
if categ["type"] == PRV_CAT:
# Check if user is an OP
if dutils.user_has_role_name(event.author, "%s-op" % chname):
await event.async_send_message(
"<@%s>: OPs can't join/leave a channel that they operate."
% (event.author.id),
timeout=MSG_TIMEOUT,
check_old=False)
return
# Check for minimum requirements
can_access = False
for access_role in REQUIRED_ACCESS_ROLES:
if dutils.user_has_role_name(event.author, access_role):
can_access = True
if not can_access:
await event.async_send_message(
"<@%s>: You can't join/leave a channel" %
(event.author.id),
timeout=MSG_TIMEOUT,
check_old=False)
return
# Check for NSFW chans
if target_chan.is_nsfw:
if dutils.user_has_role_name(event.author, NSFW_FORBID_ROLE):
await event.async_send_message(
"<@%s>: You cant join a NSFW channel" %
(event.author.id),
timeout=MSG_TIMEOUT,
check_old=False)
return
# Check if user is a member
if dutils.user_has_role_name(event.author, "%s-member" % chname):
event.author.remove_role(
dutils.get_role_by_name(self.server, "%s-member" % chname))
await event.async_send_message("<@%s>: Removed you from `%s`" %
(event.author.id, chname),
timeout=MSG_TIMEOUT,
check_old=False)
return
# Add the role
event.author.add_role(
dutils.get_role_by_name(self.server,
"%s-member" % target_chan.name))
await event.async_send_message("<@%s>: Added you to `%s`" %
(event.author.id, chname),
timeout=MSG_TIMEOUT,
check_old=False)
elif categ["type"] == PUB_CAT:
# Check if the user wants to leave
in_channel = True
for user in target_chan.get_removed_users():
if user.id == event.author.id:
in_channel = False
if in_channel:
target_chan.remove_user_by_permission(event.author)
await event.async_send_message("<@%s>: Removed you from `%s`" %
(event.author.id, chname),
timeout=MSG_TIMEOUT,
check_old=False)
return
else:
target_chan.add_user_by_permission(event.author)
await event.async_send_message("<@%s>: Added you to `%s`" %
(event.author.id, chname),
timeout=MSG_TIMEOUT,
check_old=False)
