def test__convert_query_fail_not_allowed_fields(app, faker):
fields = []
for i in range(3):
fields.append(faker.word())
query = {
faker.word(): faker.word(),
faker.word(): faker.word(),
faker.word(): faker.word()
}
with pytest.raises(app_exceptions.ValidateDataError):
Paginator._convert_query(table=pagination, raw_query=query)
async def test__get_count_pages_success(app, database, pagination_data):
async with app['db'].acquire() as conn: # type: SAConnection
limit = 10
query = {'limit': limit}
#
paginator = Paginator(conn=conn, table=pagination, query=query)
await paginator._calculate()
assert paginator.pages_count == ceil(COUNT_DATA / limit)
#
limit = 123456
query = {'limit': limit}
paginator = Paginator(conn=conn, table=pagination, query=query)
await paginator._calculate()
assert paginator.pages_count == ceil(COUNT_DATA / limit)
async def test_get_page_success(app, database, pagination_data):
limit = 14
query = {'limit': limit}
async with app['db'].acquire() as conn: # type: SAConnection
paginator = Paginator(conn=conn, table=pagination, query=query)
await paginator._calculate()
#
data = await paginator.get_page(page=0)
assert paginator == data.paginator
assert len(data) == limit
elem = data[7]
assert elem['id'] == 8
assert elem['sequence'] == f'sequence_7'
assert data.has_next() is True
assert data.has_prev() is False
assert data.get_next_page() == 2
assert data.get_prev_page() == 1
assert data[0]['id'] == 1
# 500 / 14 = 36
count = COUNT_DATA - (paginator._pages_count - 1) * limit
data = await paginator.get_page(page=paginator._pages_count + 10)
assert data.page == paginator._pages_count
assert len(data) == count
assert data.has_next() is False
assert data.has_prev() is True
assert data.get_next_page() == paginator._pages_count
assert data.get_prev_page() == paginator._pages_count - 1
assert data[0]['id'] == 491
def user_fans(request, user_id, template=TEMPLATE):
# _start_at = datetime.datetime.now()
_query_user = User(user_id)
_query_user_context = _query_user.read()
if request.user.is_authenticated():
_request_user_id = request.user.id
_request_user_context = User(_request_user_id).read()
_relation = User.get_relation(_request_user_context['user_id'], _query_user_context['user_id'])
else:
_request_user_id = None
_request_user_context = None
_relation = None
_page_num = request.GET.get('p', 1)
_fans_id_list = _query_user.read_fan_user_id_list()
_paginator = Paginator(_page_num, 8, len(_fans_id_list))
_fans_list = []
for _u_id in _fans_id_list[_paginator.offset : _paginator.offset + _paginator.count_in_one_page]:
try:
_f_user = User(_u_id)
_f_user_context = _f_user.read()
if _request_user_context != None:
_f_user_context['relation'] = User.get_relation(_request_user_context['user_id'], _u_id)
_f_user_context['latest_like_entity_id_list'] = _f_user.read_latest_like_entity_list()
_fans_list.append(_f_user_context)
except Exception, e:
pass
async def viewblacklist(self, ctx):
blacklist = (await self.bot.get_data(ctx.guild.id))[9]
if not blacklist:
await ctx.send(
embed=discord.Embed(description="No one is blacklisted.",
colour=self.bot.primary_colour))
return
all_pages = []
for chunk in [
blacklist[i:i + 25] for i in range(0, len(blacklist), 25)
]:
page = discord.Embed(
title="Blacklist",
description="\n".join(
[f"<@{user}> ({user})" for user in chunk]),
colour=self.bot.primary_colour,
)
page.set_footer(text="Use the reactions to flip pages.")
all_pages.append(page)
if len(all_pages) == 1:
embed = all_pages[0]
embed.set_footer(text=discord.Embed.Empty)
await ctx.send(embed=embed)
return
paginator = Paginator(length=1,
entries=all_pages,
use_defaults=True,
embed=True,
timeout=120)
await paginator.start(ctx)
def report_list(request):
_page_num = int(request.GET.get("p", "1"))
_paginator = Paginator(_page_num, 30, Report.objects.count())
_report_context_list = []
for _report in Report.objects.all().order_by(
'-created_time')[_paginator.offset:_paginator.offset +
_paginator.count_in_one_page]:
if isinstance(_report, EntityReport):
_report_context_list.append({
'type': 'entity_report',
'comment': _report.comment,
'entity_id': _report.entity_id,
'reporter_id': _report.reporter_id
})
elif isinstance(_report, EntityNoteReport):
_report_context_list.append({
'type': 'entity_note_report',
'comment': _report.comment,
'note_id': _report.note_id,
'reporter_id': _report.reporter_id
})
return render_to_response('report/list.html', {
'active_division': 'report',
'report_context_list': _report_context_list,
'paginator': _paginator
},
context_instance=RequestContext(request))
def user_tag_entity(request, user_id, tag_hash, template="tag/tag_detail.html"):
# _start_at = datetime.datetime.now()
# _request_user_id = request.user.id if request.user.is_authenticated() else None
if request.user.is_authenticated():
_request_user_id = request.user.id
_request_user_like_entity_set = Entity.like_set_of_user(_request_user_id)
else:
_request_user_id = None
_request_user_like_entity_set = list()
_user_context = User(user_id).read()
_tag_text = Tag.get_tag_text_from_hash(tag_hash)
_page_num = request.GET.get('p', 1)
_entity_id_list = Tag.find_user_tag_entity(user_id, _tag_text)
_paginator = Paginator(_page_num, 24, len(_entity_id_list))
_entities = list()
for _entity_id in _entity_id_list[_paginator.offset : _paginator.offset + _paginator.count_in_one_page]:
try:
_entity_context = Entity(_entity_id).read()
_entity_context['is_user_already_like'] = True if _entity_id in _request_user_like_entity_set else False
_entities.append(_entity_context)
# _entities.append(Entity(_entity_id).read())
except Exception, e:
log.error(e.message)
async def sharedservers(self, ctx, *, user_id: int):
user = await self.bot.cogs["Communication"].handler("get_user", 1, {"user_id": user_id})
if not user:
await ctx.send(embed=discord.Embed(description="No such user was found.", colour=self.bot.error_colour))
return
data = await self.bot.cogs["Communication"].handler(
"get_user_guilds", self.bot.cluster_count, {"user_id": user_id}
)
guilds = []
for chunk in data:
guilds.extend(chunk)
guilds = [f"{guild['name']} `{guild['id']}`" for guild in guilds]
all_pages = []
for chunk in [guilds[i : i + 20] for i in range(0, len(guilds), 20)]:
page = discord.Embed(title="Guilds", colour=self.bot.primary_colour)
for guild in chunk:
if page.description == discord.Embed.Empty:
page.description = guild
else:
page.description += f"\n{guild}"
page.set_footer(text="Use the reactions to flip pages.")
all_pages.append(page)
if len(all_pages) == 1:
embed = all_pages[0]
embed.set_footer(text=discord.Embed.Empty)
await ctx.send(embed=embed)
return
paginator = Paginator(length=1, entries=all_pages, use_defaults=True, embed=True, timeout=120)
await paginator.start(ctx)
async def cmd_ud(self, message):
"""
Usage:
{command_prefix}ud <word>
Get the meanings of a word/phrase from urban dictionary.
If no word is given, gets a single meaning of a random word.
"""
word = message.content.replace(f"{self.prefix}ud", '').strip()
urban = Urban()
responses = urban.fetch(word)
if len(responses) == 0:
await message.channel.send(
f"Sorry {message.author.mention}, couldn't find any results for {word}."
)
return
embedder = Embedder(message.author.avatar_url)
embeds = [
embedder.generate(
responses[i]["word"], {
"Meaning": responses[i]["meaning"],
"Example": responses[i]["example"]
}, i + 1, len(responses)) for i in range(len(responses))
]
if len(embeds) == 1:
await message.channel.send(content=message.author.mention,
embed=embeds[0])
else:
base = await message.channel.send(
f"{message.author.mention} Fetching results. Please wait. :hourglass_flowing_sand:"
)
pager = Paginator(message, base, embeds, self)
await pager.run()
async def get(self, request, **kwargs):
"""查看视频"""
user_id = kwargs.get('user_id')
prefix = "{}/media/".format(request.app.config.UPLOAD_DOMAIN)
q = request.raw_args.get('q')
page = int(request.raw_args.get('page', 1))
per_page = int(request.raw_args.get('per_page', 10))
_start = (page - 1) * per_page
if q:
count_res = await request.app.db.get(
"select count(id) as count from video where concat(ifnull(`title`, ''), ',', ifnull(`description`, '')) like %s and video.`user_id` = %s and video.`delete_flag` = 0;",
('%%%s%%' % q, user_id))
count = count_res['count']
res = await request.app.db.query(
"select video.`id`, video.`title`, video.`description`, concat(%s, video.`pic`) as pic, concat(%s, video.`path`) as video, video.`create_time`, video.`update_time` from video where concat(ifnull(`title`, ''), ',', ifnull(`description`, '')) like %s and video.`user_id` = %s and video.`delete_flag` = 0 order by id desc limit %s, %s;",
(prefix, prefix, '%%%s%%' % q, user_id, _start, per_page))
else:
count_res = await request.app.db.get(
"select count(id) as count from video where video.`user_id` = %s and video.`delete_flag` = 0;",
(user_id, ))
count = count_res['count']
res = await request.app.db.query(
"select video.`id`, video.`title`, video.`description`, concat(%s, video.`pic`) as pic, concat(%s, video.`path`) as video, video.`create_time`, video.`update_time` from video where video.`user_id` = %s and video.`delete_flag` = 0 order by id desc limit %s, %s;",
(prefix, prefix, user_id, _start, per_page))
paginate = Paginator(count, per_page)
pages = paginate()
return response.json(
{
'code': 'Success',
'total': count,
'pages': pages,
'data': res
},
dumps=json_dumps)
async def findserver(self, ctx, *, name: str):
data = await self.bot.cogs["Communication"].handler(
"find_guild", self.bot.cluster_count, {"name": name})
guilds = []
for chunk in data:
guilds.extend(chunk)
if len(guilds) == 0:
await ctx.send(
embed=discord.Embed(description="No such guild was found.",
colour=self.bot.error_colour))
return
all_pages = []
for chunk in [guilds[i:i + 20] for i in range(0, len(guilds), 20)]:
page = discord.Embed(title="Guilds",
colour=self.bot.primary_colour)
for guild in chunk:
if page.description == discord.Embed.Empty:
page.description = guild
else:
page.description += f"\n{guild}"
page.set_footer(text="Use the reactions to flip pages.")
all_pages.append(page)
if len(all_pages) == 1:
embed = all_pages[0]
embed.set_footer(text=discord.Embed.Empty)
await ctx.send(embed=embed)
return
paginator = Paginator(length=1,
entries=all_pages,
use_defaults=True,
embed=True,
timeout=120)
await paginator.start(ctx)
async def jisho_(self, ctx: BContext, *, keywords: str) -> None:
"""Get results from Jisho.org, Japanese dictionary"""
async with ctx.typing():
data = await self.jisho.lookup(keywords)
if not data:
await ctx.send("No words found.")
return
results = []
size = len(data)
for i, res in enumerate(data, 1):
res = {k: "\n".join(v) or "None" for k, v in res.items()}
res["english"] = ", ".join(res["english"].split("\n"))
embed = discord.Embed()
embed.url = self.jisho_url.format("%20".join(keywords.split()))
embed.title = keywords
embed.add_field(name="Words", value=res["words"])
embed.add_field(name="Readings", value=res["readings"])
embed.add_field(name="Parts of Speech",
value=res["parts_of_speech"])
embed.add_field(name="Meanings", value=res["english"])
embed.set_footer(text="Page {}/{}".format(i, size))
embed.color = discord.Color(0x56D926)
results.append(embed)
paginator = Paginator(results)
await paginator.start(ctx)
async def get(self, request, **kwargs):
"""查看图片"""
prefix = "{}/media/".format(request.app.config.UPLOAD_DOMAIN)
q = request.raw_args.get('q')
page = int(request.raw_args.get('page', 1))
per_page = int(request.raw_args.get('per_page', 10))
_start = (page - 1) * per_page
if q:
count_res = await request.app.db.get(
"select count(pic.`id`) as count from pic left join user on pic.user_id = user.id where concat(ifnull(`title`, ''), ',', ifnull(`description`, ''), ',', ifnull(user.`nickname`, '')) like %s and pic.`delete_flag` = 0;",
('%%%s%%' % q, ))
count = count_res['count']
res = await request.app.db.query(
"select pic.`id`, pic.`title`, pic.`description`, concat(%s, pic.`path`) as pic, ifnull(user.`nickname`, '未知') as user, pic.`create_time`, pic.`update_time` from pic left join user on pic.user_id = user.id where concat(ifnull(`title`, ''), ',', ifnull(`description`, ''), ',', ifnull(user.`nickname`, '')) like %s and pic.`delete_flag` = 0 order by id desc limit %s, %s;",
(prefix, '%%%s%%' % q, _start, per_page))
else:
count_res = await request.app.db.get(
"select count(id) as count from pic where pic.`delete_flag` = 0;"
)
count = count_res['count']
res = await request.app.db.query(
"select pic.`id`, pic.`title`, pic.`description`, concat(%s, pic.`path`) as pic, ifnull(user.nickname, '未知') as user, pic.`create_time`, pic.`update_time` from pic left join user on pic.user_id = user.id where pic.`delete_flag` = 0 order by id desc limit %s, %s;",
(prefix, _start, per_page))
paginate = Paginator(count, per_page)
pages = paginate()
return response.json(
{
'code': 'Success',
'total': count,
'pages': pages,
'data': res
},
dumps=json_dumps)
async def get(self, request, **kwargs):
q = request.raw_args.get('q')
page = int(request.raw_args.get('page', 1))
per_page = int(request.raw_args.get('per_page', 10))
_start = (page - 1) * per_page
if q:
count_res = await request.app.db.get(
"select count(id) as count from user where concat(`username`, ',', `nickname`, ',', `phone`, ',', `email`) like %s and delete_flag = 0;",
('%%%s%%' % q))
count = count_res['count']
res = await request.app.db.query(
"select `id`, `username`, `nickname`, `gender`, `email`, `phone`, `create_time`, `update_time` from user where concat(`username`, ',', `nickname`, ',', `phone`, ',', `email`) like %s and delete_flag = 0 order by id desc limit %s, %s;",
('%%%s%%' % q, _start, per_page))
else:
count_res = await request.app.db.get(
"select count(id) as count from user where delete_flag = 0;")
count = count_res['count']
res = await request.app.db.query(
"select `id`, `username`, `nickname`, `gender`, `email`, `phone`, `create_time`, `update_time` from user where delete_flag = 0 order by id desc limit %s, %s;",
(_start, per_page))
paginate = Paginator(count, per_page)
pages = paginate()
return response.json(
{
'code': 'Success',
'total': count,
'pages': pages,
'data': res
},
dumps=json_dumps)
async def _star_who(self, ctx, message: MessageID):
"""Shows who starred a message.
The ID can either be the starred message ID or the message ID in the starboard channel.
"""
query = """
SELECT starrers.author_id
FROM starrers
INNER JOIN starboard_entries entry
ON entry.id = starrers.entry_id
WHERE entry.message_id = $1
OR entry.bot_message_id = $1;
"""
records = await ctx.db.fetch(query, message)
if not records:
return await ctx.send('No one starred this message or you provided an invalid message ID.')
members = [
str(ctx.guild.get_member(r[0]))
for r in records
if ctx.guild.get_member(r[0])
]
try:
base = pluralize(**{'star': len(records)})
if len(records) > len(members):
title = f'{base} ({len(records) - len(members)} left server)'
else:
title = base
pages = Paginator(ctx, entries=members, per_page=20, title=title)
await pages.interact()
except Exception as e:
await ctx.send(e)
async def sharedservers(self, ctx, *, user: converters.GlobalUser):
data = await self.bot.comm.handler("get_user_guilds",
self.bot.cluster_count,
{"user_id": user.id})
guilds = []
for chunk in data:
guilds.extend(chunk)
guilds = [
f"{guild.name} `{guild.id}` ({guild.member_count} members)"
for guild in guilds
]
all_pages = []
for chunk in [guilds[i:i + 20] for i in range(0, len(guilds), 20)]:
page = discord.Embed(title="Servers",
colour=self.bot.primary_colour)
for guild in chunk:
if page.description == discord.Embed.Empty:
page.description = guild
else:
page.description += f"\n{guild}"
page.set_footer(text="Use the reactions to flip pages.")
all_pages.append(page)
if len(all_pages) == 1:
embed = all_pages[0]
embed.set_footer(text=discord.Embed.Empty)
await ctx.send(embed=embed)
return
paginator = Paginator(length=1,
entries=all_pages,
use_defaults=True,
embed=True,
timeout=120)
await paginator.start(ctx)
def test__convert_query_success_default(app, faker):
_query = {}
query = Paginator._convert_query(table=pagination, raw_query=_query)
assert query['limit'] == Paginator._DEFAULT_LIMIT
assert query['order_by'] == Paginator._DEFAULT_ORDER_BY
assert query['sort_by'] == 'id'
assert query['page'] == 1
assert query['filters'] == {}
async def test_order_by_success(app, database, pagination_data):
query = {'order_by': 'desc', 'limit': COUNT_DATA}
async with app['db'].acquire() as conn: # type: SAConnection
paginator = Paginator(conn=conn, table=pagination, query=query)
page_data = await paginator.get_page()
assert paginator._records_count == COUNT_DATA
assert len(page_data) == COUNT_DATA
assert page_data[0]['id'] == COUNT_DATA
async def send_bot_help(self, cogs):
fields = {}
for i in cogs:
new = self.get_cog(i, cogs[i])
if new:
fields.update(new)
pag = Paginator(
self.context, 'Help', fields, colour=colours['green'], maxf=3
)
await pag.setup()
def book_list(request):
# 获取所有的书籍对象
books = models.Book.objects.all() # 这是queryset对象
current_page = request.GET.get('page')
paginator = Paginator(request, current_page, books.count(), 10, 7)
books = books[paginator.start:paginator.end]
return render(request, 'book_list.html', {
'book_list': books,
'paginator': paginator,
'current_page': current_page
})
async def viewsnippet(self, ctx, *, name: str = None):
if name:
name = name.lower()
async with self.bot.pool.acquire() as conn:
res = await conn.fetchrow(
"SELECT name, content FROM snippet WHERE name=$1 AND guild=$2",
name,
ctx.guild.id,
)
if not res:
await ctx.send(embed=discord.Embed(
description="A snippet with that name was not found.",
colour=self.bot.error_colour,
))
return
embed = discord.Embed(title="Snippet",
colour=self.bot.primary_colour)
embed.add_field(name="Name", value=res[0], inline=False)
embed.add_field(name="Content", value=res[1], inline=False)
await ctx.send(embed=embed)
return
async with self.bot.pool.acquire() as conn:
res = await conn.fetch(
"SELECT name, content FROM snippet WHERE guild=$1",
ctx.guild.id)
if not res:
await ctx.send(embed=discord.Embed(
description="No snippet has been added yet.",
colour=self.bot.primary_colour))
return
all_pages = []
for chunk in [res[i:i + 10] for i in range(0, len(res), 10)]:
page = discord.Embed(title="Snippets",
colour=self.bot.primary_colour)
for snippet in chunk:
page.add_field(
name=snippet[0],
value=snippet[1][:100] +
"..." if len(snippet[1]) > 100 else snippet[1],
inline=False,
)
page.set_footer(text="Use the reactions to flip pages.")
all_pages.append(page)
if len(all_pages) == 1:
embed = all_pages[0]
embed.set_footer(text=discord.Embed.Empty)
await ctx.send(embed=embed)
return
paginator = Paginator(length=1,
entries=all_pages,
use_defaults=True,
embed=True,
timeout=120)
await paginator.start(ctx)
async def _show_aliases(self, ctx):
"""Shows all aliases that exist on this server."""
query = """
SELECT alias, command FROM command_aliases
WHERE guild_id = $1
ORDER BY alias;
"""
entries = starmap('`{0}` => `{1}`'.format, await ctx.db.fetch(query, ctx.guild.id))
pages = Paginator(ctx, entries)
await pages.interact()
async def test_filter_success(app, database, pagination_data):
query = {'sequence': 'sequence_1', 'limit': COUNT_DATA}
async with app['db'].acquire() as conn: # type: SAConnection
paginator = Paginator(conn=conn, table=pagination, query=query)
page_data = await paginator.get_page()
assert paginator._records_count == 111
assert len(page_data) == 111
assert 'id' in page_data[0]
assert 'sequence' in page_data[0]
assert 'some_data' in page_data[0]
async def urban_dictionary(self, ctx, *, term: str = ""):
"""Searches for a term on urbandictionary.com"""
if not term:
url = "http://api.urbandictionary.com/v0/random"
else:
term = uriquote(term)
url = f"http://api.urbandictionary.com/v0/define?term={term}"
async with self.bot.session.get(url) as resp:
data = await resp.json()
pages = Paginator(ctx, data['list'], self.ud_callback)
await pages.paginate()
def banner_list(request):
_page_num = int(request.GET.get("p", "1"))
_paginator = Paginator(_page_num, 30, BannerModel.objects.count())
_banner_context_list = Banner.find(offset=_paginator.offset,
count=_paginator.count_in_one_page)
return render_to_response('banner/list.html', {
'active_division': 'banner',
'banner_context_list': _banner_context_list,
'paginator': _paginator
},
context_instance=RequestContext(request))
def tencent_selection(request, template='tencent/selection.html'):
_start_at = datetime.now()
if request.user.is_authenticated():
_request_user_id = request.user.id
else:
_request_user_id = None
_agent = 'iphone'
if 'Android' in request.META['HTTP_USER_AGENT']:
_agent = 'android'
_page_num = int(request.GET.get('p', 1))
_hdl = NoteSelection.objects.filter(post_time__lt=datetime.now())
_paginator = Paginator(_page_num, 30, _hdl.count())
_hdl = _hdl.order_by('-post_time')
_selection_list = []
_entity_id_list = []
for _note_selection in _hdl[_paginator.offset:_paginator.offset +
_paginator.count_in_one_page]:
_selection_note_id = _note_selection['note_id']
_entity_id = _note_selection['entity_id']
_entity_context = Entity(_entity_id).read()
_note_context = Note(_selection_note_id).read()
_creator_context = User(_note_context['creator_id']).read()
_selection_list.append({
'entity_context': _entity_context,
'note_context': _note_context,
'creator_context': _creator_context,
})
_entity_id_list.append(_entity_id)
_duration = datetime.now() - _start_at
WebLogTask.delay(
entry='tencent',
duration=_duration.seconds * 1000000 + _duration.microseconds,
page='SELECTION',
request=request.REQUEST,
ip=get_client_ip(request),
log_time=datetime.now(),
request_user_id=_request_user_id,
appendix={
'result_entities': _entity_id_list,
},
)
return render_to_response(template, {
'agent': _agent,
'selection_list': _selection_list,
'next_page_num': _page_num + 1,
},
context_instance=RequestContext(request))
async def rt(self, ctx, *, movie_name: str):
"""Searches Flixster for a movie's Rotten Tomatoes score and critics consensus if available"""
url = self.rt_search_url.format(uriquote(movie_name))
# RT api is slow...
async with ctx.channel.typing():
data = await self.json_from_flxurl(url)
movielist = []
for movie in data:
movielist.append(movie['id'])
if not movielist:
await ctx.send(f"Couldn't find a movie named `{movie_name}` on Flixster")
return
pages = Paginator(ctx, movielist, self.rt_output_callback)
await pages.paginate()
async def _help(self, ctx, command: str = None):
"""Shows all commands"""
prefix = (await self.bot.get_prefix(ctx.message))[-1]
if command:
cmd = self.bot.get_command(
command.lower()) or self.bot.get_cog(command)
if not cmd:
return await ctx.send(
f"Command or category '{command}' not found.")
if isinstance(cmd, commands.Command):
em = discord.Embed(color=0xff0000)
em.title = cmd.name
em.description = cmd.help or "No Description"
em.description += "\nUsage: `{}{}`".format(
ctx.prefix, _command_signature(cmd))
if cmd.aliases:
em.description += "\nAliases: `{}`".format(", ".join(
cmd.aliases))
return await ctx.send(embed=em)
cmds = self.bot.get_cog_commands(command)
em = discord.Embed(color=self.bot.color)
em.description = cmd.__doc__ + "\n\n`" if cmd.__doc__ else "No Description\n\n`"
em.set_footer(
text=f"{prefix}help <cmd> for more info on a command.")
for x in cmds:
msg = f"{prefix}{x.signature} {x.short_doc}\n"
em.description += msg
em.description += "`"
return await ctx.send(embed=em)
else:
cogs = self.bot.cogs.keys()
pages = []
for x in cogs:
if x == "Owner" and ctx.author.id not in ctx.bot.devs:
continue
cmds = self.bot.get_cog_commands(x)
cog = self.bot.get_cog(x)
msg = cog.__class__.__name__ + "\n" + cog.__doc__ + "\n\n`" if cog.__doc__ else cog.__class__.__name__ + "\nNo Description\n\n`"
for cmd in cmds:
if cmd.hidden:
continue
cmd_msg = f"{prefix}{_command_signature(cmd)} {cmd.short_doc}\n"
msg += cmd_msg
msg += "`"
pages.append(msg)
em = discord.Embed(color=0xff0000)
em.set_footer(
text=f"{prefix}help <cmd> for more information on a command.")
paginator = Paginator(ctx, pages=pages, page_count=True, embed=em)
await paginator.run()
def note_comment_list(request):
_page_num = int(request.GET.get("p", "1"))
_comment_count = Note.comment_count()
_paginator = Paginator(_page_num, 30, _comment_count)
_context_list = []
for _comment in Note.find_comment(offset=_paginator.offset,
count=_paginator.count_in_one_page):
try:
_comment_context = Note(_comment[0]).read_comment(_comment[1])
_comment_context['creator'] = User(
_comment_context['creator_id']).read()
_context_list.append(_comment_context)
except Exception, e:
pass
async def _ignores(self, ctx):
"""Tells you what channels or members are currently ignored on this server."""
query = 'SELECT entity_id FROM plonks WHERE guild_id = $1;'
entries = [(ctx.guild.get_channel(entity_id)
or ctx.guild.get_member(entity_id)
or _DummyEntry(entity_id)).mention
for entity_id, in await ctx.db.fetch(query, ctx.guild.id)]
if not entries:
return await ctx.send('Nothing\'s being ignored in here.')
pages = Paginator(ctx,
entries,
title=f'Currently ignoring...',
per_page=20)
await pages.interact()
