def _clear_reminder(conn, rem_name):
"""Is for appending to old reminders in the db"""
db.set_cell(conn, 'reminders', 'msg', '', 'name', rem_name)
db.set_cell(conn, 'reminders', 'last_updated', str(int(time.time())),
'name', rem_name)
db.ccache()
async def _add_words(client, data, conn, words, message, ban=False):
"""Is used for adding words to the ban or kick list."""
if ban:
column = 'banwords'
else:
column = 'kickwords'
for msg in message:
if ban:
if ':' in msg:
timeless = ' '.join(msg.split(':')[0:-1])
else:
timeless = msg
msg = f'{msg}:60'
else:
timeless = msg
if not words:
asyncio.create_task(
client.notice(data.nickname, f'Adding {msg} to {column}'))
db.set_cell(conn, 'channels', column, msg.strip(), 'channel',
data.target)
elif timeless in words:
asyncio.create_task(
client.notice(data.nickname, f'{msg} is already in {column}.'))
else:
asyncio.create_task(
client.notice(data.nickname, f'Adding {msg} to {column}'))
words = f'{words[0][0]} {msg}'.strip()
db.set_cell(conn, 'channels', column, words, 'channel',
data.target)
async def _get_prefix(self, target: str) -> str:
"""
Is used to get or set the channel command prefix.
Returns default for private messages.
If channel has prefix set to non valid prefix, set it to default.
"""
default_prefix: str
try:
default_prefix = self.bot.config['servers'][self.server_tag].get(
'command_prefix', '.')
except AttributeError:
default_prefix = '.'
conn: Connection = self.bot.dbs[self.server_tag]
prefix: Optional[str]
if target[0] == '#':
db_prefix: DBResult = db.get_cell(conn, 'channels',
'commandprefix', 'channel',
target)
if not db_prefix:
prefix = default_prefix
db.add_channel(conn, target, prefix)
else:
prefix = db_prefix[0][0]
valid_prefixes: Union[str, List[str]] = self.bot.config.get(
'valid_command_prefixes', '.')
if not prefix or prefix not in valid_prefixes:
prefix = default_prefix
db.set_cell(conn, 'channels', 'commandprefix', prefix,
'channel', target)
else:
prefix = default_prefix
return prefix
async def _del_words(client, data, conn, words, message, ban=False):
"""Is used for removing words to the ban or kick list."""
if ban:
column = 'banwords'
else:
column = 'kickwords'
for msg in message:
if ban:
if ':' in msg:
timeless = ' '.join(msg.split(':')[0:-1])
else:
timeless = msg
msg = f'{msg}:60'
else:
timeless = msg
if timeless in words:
asyncio.create_task(
client.notice(data.nickname, f'Removimg {msg} from {column}.'))
if ban:
regex = re.compile(r'{0}*\:[0-9]'.format(timeless))
words = [i for i in words.split() if not regex.search(i)]
words = ' '.join(words)
else:
words = words.replace(msg, '').strip()
db.set_cell(conn, 'channels', column, words, 'channel',
data.target)
else:
asyncio.create_task(
client.notice(data.nickname, f'{msg} is not in {column}.'))
async def _update_user(self, user: str, mask: str) -> None:
"""
Is used to update the users db information when they speak.
Runs before sieves so ignored users are in the db.
If user not in db, adds them, otherwise update nick,
or mask if needed.
"""
if user == self.nickname:
return
conn: Connection = self.bot.dbs[self.server_tag]
db_mask: DBResult = db.get_cell(conn, 'users', 'mask', 'nick', user)
db_nick: DBResult = db.get_cell(conn, 'users', 'nick', 'mask', mask)
if not db_mask or not db_nick:
db.add_user(conn, user, mask)
return
else:
same_mask = (db_mask[0][0] == mask)
same_nick = (db_nick[0][0] == user)
# if mask changed
if not same_mask and same_nick:
db.set_cell(conn, 'users', 'mask', mask, 'nick', user)
# if nick changed
if same_mask and not same_nick:
db.set_cell(conn, 'users', 'nick', user, 'mask', mask)
async def c_un_ignore(client, data):
"""
.unignore/.ignore <list/user/mask> -- Unignores or ignores a list of users,
or lists ignored users.
"""
conn = client.bot.dbs[data.server]
message = data.message.replace(',', ' ')
masks = await _parse_masks(client, data, conn, message)
if not len(masks) and message.split(' ')[0] != 'list':
doc = ' '.join(c_un_ignore.__doc__.split())
asyncio.create_task(client.notice(data.nickname, f'{doc}'))
asyncio.create_task(
client.notice(data.nickname, f'No valid users or masks.'))
return
ignored = db.get_cell(conn, 'channels', 'ignored', 'channel',
data.target)[0][0]
if not ignored:
ignored = ''
if message.split(' ')[0] == 'list':
if len(ignored) > 0:
asyncio.create_task(
client.notice(data.nickname, f'Ignored users: {ignored}'))
else:
asyncio.create_task(
client.notice(data.nickname, f'No users ignored.'))
return
for mask in masks:
if data.command == 'unignore':
if mask in ignored:
asyncio.create_task(
client.notice(data.nickname,
f'{mask} is unignored in {data.target}.'))
ignored = ignored.replace(mask, '').strip()
else:
asyncio.create_task(
client.notice(data.nickname,
f'{mask} is not ignored in {data.target}.'))
return
elif data.command == 'ignore':
if mask in ignored:
asyncio.create_task(
client.notice(
data.nickname,
f'{mask} is already ignored in {data.target}.'))
return
else:
asyncio.create_task(
client.notice(data.nickname,
f'ignoring {mask} in {data.target}.'))
ignored += mask + ' '
db.set_cell(conn, 'channels', 'ignored', ignored, 'channel', data.target)
async def g_set(client, data):
"""
.set <table> <matchcol> <value> <setcol> <value> -- Changes values in the
database, and lists valid tables and columns when arguments ommited.
"""
bot = client.bot
conn = bot.dbs[data.server]
if not data.message:
doc = ' '.join(g_set.__doc__.split())
asyncio.create_task(client.notice(data.nickname, f'{doc}'))
asyncio.create_task(_list_tables(client, data, conn))
return
message = data.split_message
table = message[0]
columns = await _list_columns(None, data, conn, table)
table_exists = db.get_table(conn, table)
if isinstance(table_exists, OperationalError):
asyncio.create_task(_list_tables(client, data, conn))
return
if len(message) == 1:
asyncio.create_task(_list_columns(client, data, conn, table))
return
match_col = message[1]
if match_col not in columns:
asyncio.create_task(_list_columns(client, data, conn, table))
return
match_value = await _get_match_value(client, data, message)
if not match_value:
return
row_exists = db.get_cell(conn, table, match_col, match_col, match_value)
if not row_exists:
asyncio.create_task(
client.notice(data.nickname,
f'{match_value} is not in that table.'))
return
set_column = await _get_set_column(client, data, conn, message, table,
columns)
if not set_column:
return
value = ' '.join(message[4:])
if not value:
asyncio.create_task(
client.notice(data.nickname, 'Need a value to add.'))
else:
conn = client.bot.dbs[data.server]
asyncio.create_task(
client.notice(data.nickname, f'Setting {set_column} to {value}.'))
db.set_cell(conn, table, set_column, value, match_col, match_value)
def _update_user_intro(conn, intro_name, intro_value, username):
"""Deleting intro"""
for intro_clearer in intro_clear:
if intro_value.startswith(intro_clearer):
db.set_cell(conn, 'users', intro_name, None, 'nick', username)
db.ccache()
return
db.set_cell(conn, 'users', intro_name, intro_value, 'nick', username)
db.ccache()
return
def _append_reminder(conn, rem_name, rem_text):
"""Is for appending to old reminders in the db"""
old_rem_text = _get_reminder_text(conn, rem_name)
new_rem_text = f'{old_rem_text} and {rem_text}'
rem_text_trunc = new_rem_text[:max_reminder_len]
db.set_cell(conn, 'reminders', 'msg', rem_text_trunc, 'name', rem_name)
db.set_cell(conn, 'reminders', 'last_updated', str(int(time.time())),
'name', rem_name)
db.ccache()
async def add_to_channels(client: Any, data: data.ParsedRaw, conn: Connection,
column: str, adding: str, existing: List[str],
added_msg: str, already_msg: str):
if adding in existing:
asyncio.create_task(client.notice(data.nickname, already_msg))
else:
existing.append(adding)
if len(existing) > 1:
db.set_cell(conn, 'channels', column, ' '.join(existing),
'channel', data.target)
else:
print(existing)
db.set_cell(conn, 'channels', column, existing[0], 'channel',
data.target)
asyncio.create_task(client.notice(data.nickname, added_msg))
async def _enable_disable(client, target, conn, value, cell):
if len(value) > 1:
db.set_cell(conn, 'channels', cell, ' '.join(value), 'channel', target)
else:
if not value:
db.set_cell(conn, 'channels', cell, '', 'channel', target)
else:
db.set_cell(conn, 'channels', cell, value[0], 'channel', target)
async def del_from_channels(
client: Any, data: data.ParsedRaw, conn: Connection, column: str,
removing: str, existing: List[str], removed_msg: str, notin_msg: str):
if removing in existing:
existing.remove(removing)
if len(existing) > 1:
db.set_cell(conn, 'channels', column, ' '.join(existing),
'channel', data.target)
else:
if not existing:
db.set_cell(conn, 'channels', column, '', 'channel',
data.target)
else:
db.set_cell(conn, 'channels', column, existing, 'channel',
data.target)
asyncio.create_task(client.notice(data.nickname, removed_msg))
else:
asyncio.create_task(client.notice(data.nickname, notin_msg))
def _clear_user_attribute(conn, attr_name, username):
db.set_cell(conn, 'users', attr_name, '', 'nick', username)
db.ccache()
return
async def c_flood(client, data):
"""
.flood [list/cmd/msg] [messages/disable] [second] [kick/ban/warn] --
List, disable, or change the max messages per second or commands per
second. The bot can kick, ban(which also kicks), or warn flooding users.
"""
conn = client.bot.dbs[data.server]
msgflood = db.get_cell(conn, 'channels', 'msgflood', 'channel',
data.target)[0][0]
cmdflood = db.get_cell(conn, 'channels', 'cmdflood', 'channel',
data.target)[0][0]
if ' ' in data.message:
message = data.message.split(' ')
else:
message = [data.message]
if message[0] == 'list':
if msgflood not in (None, ''):
asyncio.create_task(
client.notice(data.nickname, f'Message flood: {msgflood}.'))
else:
asyncio.create_task(
client.notice(data.nickname, f'No message flood set.'))
if cmdflood not in (None, ''):
asyncio.create_task(
client.notice(data.nickname, f'Command flood: {cmdflood}.'))
else:
asyncio.create_task(
client.notice(data.nickname, f'No command flood set.'))
return
secs = await _secs_or_help(client, data, message)
if not secs:
return
if message[0] == 'msg':
if message[1] == 'disable':
asyncio.create_task(
client.notice(data.nickname, 'Disabling message flood.'))
db.set_cell(conn, 'channels', 'msgflood', '', 'channel',
data.target)
else:
asyncio.create_task(
client.notice(
data.nickname,
f'Changing message flood to {message[1]} {secs}'
f'{message[3]}.'))
db.set_cell(conn, 'channels', 'msgflood',
f'{message[1]} {secs} {message[3]}', 'channel',
data.target)
if message[0] == 'cmd':
if message[1] == 'disable':
asyncio.create_task(
client.notice(data.nickname, 'Disabling command flood.'))
db.set_cell(conn, 'channels', 'cmdflood', '', 'channel',
data.target)
else:
asyncio.create_task(
client.notice(
data.nickname,
f'Changing command flood to {message[1]} {secs}'
f'{message[3]}.'))
db.set_cell(conn, 'channels', 'cmdflood',
f'{message[1]} {secs} {message[3]}', 'channel',
data.target)
def _update_user_attribute(conn, attr_name, attr_value, username):
db.set_cell(conn, 'users', attr_name, attr_value, 'nick', username)
db.ccache()
return
def _add_lastfm_nick(conn, irc_nick, lastfm_nick):
nick_check = _get_lastfm_nick(conn, irc_nick)
db.set_cell(conn, 'users', 'lastfm', lastfm_nick, 'nick', irc_nick)
return lastfm_nick
def _update_user_location(conn, location_column, location_value, username):
db.set_cell(conn, 'users', location_column, location_value, 'nick',
username)
db.ccache()
return
