380 lines
17 KiB
Python
380 lines
17 KiB
Python
import discord
|
|
from discord.ext import commands
|
|
|
|
from geeksbot.imports.utils import Paginator, Book
|
|
|
|
|
|
class Tickets(commands.Cog):
|
|
def __init__(self, bot):
|
|
self.bot = bot
|
|
|
|
@commands.command()
|
|
async def request(self, ctx, *, message=None):
|
|
if not ctx.guild:
|
|
await ctx.send("This command must be run from inside a guild.")
|
|
return
|
|
|
|
if not message:
|
|
await ctx.send("Please include a message containing your request")
|
|
return
|
|
|
|
if len(message) > 1000:
|
|
await ctx.send(
|
|
"Request is too long, please keep your request to less than 1000 characters."
|
|
)
|
|
return
|
|
|
|
data = {
|
|
"author": ctx.author.id,
|
|
"message": ctx.message.id,
|
|
"channel": ctx.channel.id,
|
|
"content": message,
|
|
}
|
|
msg_resp = await self.bot.aio_session.get(
|
|
f"{self.bot.api_base}/messages/{ctx.message.id}/wait/",
|
|
headers=self.bot.auth_header,
|
|
)
|
|
if msg_resp.status == 404:
|
|
error = await msg_resp.json()
|
|
await ctx.send(error["details"])
|
|
return
|
|
|
|
resp = await self.bot.aio_session.post(
|
|
f"{self.bot.api_base}/messages/{ctx.guild.id}/requests/",
|
|
headers=self.bot.auth_header,
|
|
json=data,
|
|
)
|
|
|
|
if resp.status == 201:
|
|
admin_channel_resp = await self.bot.aio_session.get(
|
|
f"{self.bot.api_base}/channels/{ctx.guild.id}/admin/",
|
|
headers=self.bot.auth_header,
|
|
)
|
|
request = await resp.json()
|
|
|
|
if admin_channel_resp.status == 200:
|
|
admin_chan_data = await admin_channel_resp.json()
|
|
msg = f""
|
|
admin_roles_resp = await self.bot.aio_session.get(
|
|
f"{self.bot.api_base}/guilds/{ctx.guild.id}/roles/admin/",
|
|
headers=self.bot.auth_header,
|
|
)
|
|
if admin_roles_resp.status == 200:
|
|
admin_roles_data = await admin_roles_resp.json()
|
|
for role in admin_roles_data:
|
|
msg += f'{ctx.guild.get_role(int(role["id"])).mention} '
|
|
msg += (
|
|
f"New Request ID: {request['id']} "
|
|
f"{ctx.author.mention} has requested assistance: \n"
|
|
f"```{request['content']}``` \n"
|
|
f"Requested at: {request['requested_at'].split('.')[0].replace('T', ' ')} GMT\n"
|
|
f"In {ctx.guild.get_channel(int(request['channel'])).name}"
|
|
)
|
|
admin_chan = ctx.guild.get_channel(int(admin_chan_data["id"]))
|
|
await admin_chan.send(msg)
|
|
await ctx.send(
|
|
f"{ctx.author.mention} The admin have received your request.\n"
|
|
f'If you would like to update or close your request please reference Request ID `{request["id"]}`'
|
|
)
|
|
|
|
@commands.command(aliases=["comment"])
|
|
async def update(self, ctx, request_id=None, *, comment: str = None):
|
|
try:
|
|
request_id = int(request_id)
|
|
except ValueError:
|
|
await ctx.send(
|
|
"Please include the ID of the request you would like to update as the first thing after the command."
|
|
)
|
|
return
|
|
|
|
if not comment:
|
|
await ctx.send(
|
|
"There is nothing to update since you didn't include a message."
|
|
)
|
|
return
|
|
|
|
data = {"author": ctx.author.id, "content": comment}
|
|
|
|
comment_resp = await self.bot.aio_session.post(
|
|
f"{self.bot.api_base}/messages/{ctx.guild.id}/requests/{request_id}/comments/",
|
|
headers=self.bot.auth_header,
|
|
json=data,
|
|
)
|
|
|
|
if comment_resp.status == 201:
|
|
comment = await comment_resp.json()
|
|
admin_channel_resp = await self.bot.aio_session.get(
|
|
f"{self.bot.api_base}/channels/{ctx.guild.id}/admin/",
|
|
headers=self.bot.auth_header,
|
|
)
|
|
|
|
if admin_channel_resp.status == 200:
|
|
admin_channel_data = await admin_channel_resp.json()
|
|
admin_channel = ctx.guild.get_channel(int(admin_channel_data["id"]))
|
|
if admin_channel:
|
|
request_resp = await self.bot.aio_session.get(
|
|
f"{self.bot.api_base}/messages/{ctx.guild.id}/requests/{request_id}/",
|
|
headers=self.bot.auth_header,
|
|
)
|
|
pag = Paginator(self.bot, prefix="```md", suffix="```")
|
|
header = (
|
|
f"{ctx.author.mention} has commented on request {request_id}\n"
|
|
)
|
|
if request_resp.status == 200:
|
|
request = await request_resp.json()
|
|
requestor = await ctx.guild.fetch_member(int(request["author"]))
|
|
header += (
|
|
f'Original Request by {requestor.mention if requestor else "`User cannot be found`"}:\n'
|
|
f'```{request["content"]}```'
|
|
)
|
|
pag.set_header(header)
|
|
|
|
if request.get("comments"):
|
|
comments = request["comments"]
|
|
for comment in comments:
|
|
author = await ctx.guild.fetch_member(
|
|
int(comment["author"])
|
|
)
|
|
pag.add(
|
|
f'{author.display_name}: {comment["content"]}',
|
|
keep_intact=True,
|
|
)
|
|
if ctx.author != requestor and requestor:
|
|
for page in pag.pages(page_headers=False):
|
|
await requestor.send(page)
|
|
book = Book(pag, (None, admin_channel, self.bot, ctx.message))
|
|
await book.create_book()
|
|
await ctx.send(
|
|
f"{ctx.author.mention} Your comment has been added to the request."
|
|
)
|
|
|
|
@commands.command(name="requests_list", aliases=["rl"])
|
|
async def _requests_list(self, ctx, closed: str = ""):
|
|
pag = Paginator(self.bot)
|
|
admin_roles_resp = await self.bot.aio_session.get(
|
|
f"{self.bot.api_base}/guilds/{ctx.guild.id}/roles/admin/",
|
|
headers=self.bot.auth_header,
|
|
)
|
|
if admin_roles_resp.status == 200:
|
|
admin_roles_data = await admin_roles_resp.json()
|
|
admin_roles = [
|
|
ctx.guild.get_role(int(role["id"])) for role in admin_roles_data
|
|
]
|
|
if any([role in ctx.author.roles for role in admin_roles]):
|
|
requests_resp = await self.bot.aio_session.get(
|
|
f"{self.bot.api_base}/messages/{ctx.guild.id}/requests/",
|
|
headers=self.bot.auth_header,
|
|
)
|
|
if requests_resp.status == 200:
|
|
requests_data = await requests_resp.json()
|
|
requests_list = (
|
|
requests_data["requests"]
|
|
if isinstance(requests_data, dict)
|
|
else requests_data
|
|
)
|
|
while isinstance(requests_data, dict) and requests_data.get("next"):
|
|
requests_resp = await self.bot.aio_session.get(
|
|
requests_data["next"], headers=self.bot.auth_header
|
|
)
|
|
if requests_resp.status == 200:
|
|
requests_data = await requests_resp.json()
|
|
requests_list.extend(
|
|
requests_data["requests"]
|
|
if isinstance(requests_data, dict)
|
|
else requests_data
|
|
)
|
|
for request in requests_list:
|
|
member = await ctx.guild.fetch_member(int(request["author"])
|
|
title = (
|
|
f"<{'Request ID':^20} {'Requested By':^20}>\n"
|
|
f"<{request['id']:^20} {member.display_name if member else 'None':^20}>"
|
|
)
|
|
orig_channel = ctx.guild.get_channel(
|
|
int(request.get("channel"))
|
|
)
|
|
comments_count_resp = await self.bot.aio_session.get(
|
|
f'{self.bot.api_base}/messages/{ctx.guild.id}/requests/{request["id"]}/comments/count/',
|
|
headers=self.bot.auth_header,
|
|
)
|
|
pag.add(
|
|
f"\n\n{title}\n"
|
|
f"{request['content']}\n\n"
|
|
f"Comments: {await comments_count_resp.text() if comments_count_resp.status == 200 else 0}\n"
|
|
f"Requested at: "
|
|
f"{request['requested_at'].split('.')[0].replace('T', ' ')} GMT\n"
|
|
f"In {orig_channel.name if orig_channel else 'N/A'}",
|
|
keep_intact=True,
|
|
)
|
|
pag.add(
|
|
f"\n\uFFF8\nThere are currently {len(requests_list)} requests open."
|
|
)
|
|
else:
|
|
pag.add(
|
|
"There are no open requests for this guild.", keep_intact=True
|
|
)
|
|
else:
|
|
requests_resp = await self.bot.aio_session.get(
|
|
f"{self.bot.api_base}/messages/{ctx.guild.id}/requests/user/{ctx.author.id}/",
|
|
headers=self.bot.auth_header,
|
|
)
|
|
if requests_resp.status == 200:
|
|
requests_data = await requests_resp.json()
|
|
requests_list = (
|
|
requests_data["requests"]
|
|
if isinstance(requests_data, dict)
|
|
else requests_data
|
|
)
|
|
while isinstance(requests_data, dict) and requests_data.get("next"):
|
|
requests_resp = await self.bot.aio_session.get(
|
|
requests_data["next"], headers=self.bot.auth_header
|
|
)
|
|
if requests_resp.status == 200:
|
|
requests_data = await requests_resp.json()
|
|
requests_list.extend(
|
|
requests_data["requests"]
|
|
if isinstance(requests_data, dict)
|
|
else requests_data
|
|
)
|
|
for request in requests_list:
|
|
title = f"<{'Request ID':^20}>\n" f"<{request['id']:^20}>"
|
|
orig_channel = ctx.guild.get_channel(
|
|
int(request.get("channel"))
|
|
)
|
|
comments_count_resp = await self.bot.aio_session.get(
|
|
f'{self.bot.api_base}/messages/{ctx.guild.id}/requests/{request["id"]}/comments/count/',
|
|
headers=self.bot.auth_header,
|
|
)
|
|
pag.add(
|
|
f"\n\n{title}\n"
|
|
f"{request['content']}\n\n"
|
|
f"Comments: {await comments_count_resp.text() if comments_count_resp.status == 200 else 0}\n"
|
|
f"Requested at: "
|
|
f"{request['requested_at'].split('.')[0].replace('T', ' ')} GMT\n"
|
|
f"In {orig_channel.name if orig_channel else 'N/A'}",
|
|
keep_intact=True,
|
|
)
|
|
pag.add(
|
|
f"\n\uFFF8\nYou currently have {len(requests_list)} requests open."
|
|
)
|
|
else:
|
|
pag.add(
|
|
"You have no open requests for this guild.", keep_intact=True
|
|
)
|
|
for page in pag.pages():
|
|
await ctx.send(page)
|
|
|
|
@commands.command()
|
|
async def close(self, ctx, *, ids=None):
|
|
if not ids:
|
|
await ctx.send("Please include at least one Request ID to close.")
|
|
return
|
|
|
|
admin = False
|
|
admin_roles_resp = await self.bot.aio_session.get(
|
|
f"{self.bot.api_base}/guilds/{ctx.guild.id}/roles/admin/",
|
|
headers=self.bot.auth_header,
|
|
)
|
|
if admin_roles_resp.status == 200:
|
|
admin_roles_data = await admin_roles_resp.json()
|
|
admin_roles = [
|
|
ctx.guild.get_role(int(role["id"])) for role in admin_roles_data
|
|
]
|
|
if any([role in ctx.author.roles for role in admin_roles]):
|
|
admin = True
|
|
|
|
ids = [id.strip() for id in ids.replace(" ", "").split(",")]
|
|
|
|
for id in ids:
|
|
request_resp = await self.bot.aio_session.get(
|
|
f"{self.bot.api_base}/messages/{ctx.guild.id}/requests/{id}/",
|
|
headers=self.bot.auth_header,
|
|
)
|
|
if request_resp.status == 200:
|
|
request = await request_resp.json()
|
|
requestor = await ctx.guild.fetch_member(int(request["author"]))
|
|
if requestor == ctx.author or admin:
|
|
data = {"completed_by": ctx.author.id}
|
|
delete_resp = await self.bot.aio_session.delete(
|
|
f"{self.bot.api_base}/messages/{ctx.guild.id}/requests/{id}/",
|
|
headers=self.bot.auth_header,
|
|
json=data,
|
|
)
|
|
if delete_resp.status == 202:
|
|
delete_data = await delete_resp.json()
|
|
if delete_data["completed"]:
|
|
await ctx.send(f"Request {id} closed.")
|
|
await requestor.send(
|
|
f"{ctx.author.display_name} has closed request {id} which was "
|
|
f"opened by you in the "
|
|
f'{ctx.guild.get_channel(int(request["channel"])).name} '
|
|
f"channel."
|
|
f'```{request["content"]}```'
|
|
f"If there are any issues please open a new request."
|
|
)
|
|
else:
|
|
await ctx.send("That is not your request to close.")
|
|
|
|
@commands.command()
|
|
async def view(self, ctx, id=None):
|
|
if not id:
|
|
await ctx.send(
|
|
"Please include the id of the request you would like to view."
|
|
)
|
|
return
|
|
|
|
admin = False
|
|
admin_roles_resp = await self.bot.aio_session.get(
|
|
f"{self.bot.api_base}/guilds/{ctx.guild.id}/roles/admin/",
|
|
headers=self.bot.auth_header,
|
|
)
|
|
if admin_roles_resp.status == 200:
|
|
admin_roles_data = await admin_roles_resp.json()
|
|
admin_roles = [
|
|
ctx.guild.get_role(int(role["id"])) for role in admin_roles_data
|
|
]
|
|
if any([role in ctx.author.roles for role in admin_roles]):
|
|
admin = True
|
|
|
|
request_resp = await self.bot.aio_session.get(
|
|
f"{self.bot.api_base}/messages/{ctx.guild.id}/requests/{id}/",
|
|
headers=self.bot.auth_header,
|
|
)
|
|
if request_resp.status == 200:
|
|
request = await request_resp.json()
|
|
requestor = await ctx.guild.fetch_member(int(request["author"]))
|
|
if requestor == ctx.author or admin:
|
|
pag = Paginator(self.bot, prefix="```md", suffix="```")
|
|
header = (
|
|
f'Request {id} by {requestor.mention if requestor else "`User cannot be found`"}:\n'
|
|
f'```{request["content"]}```'
|
|
)
|
|
pag.set_header(header)
|
|
|
|
if request.get("comments"):
|
|
pag.add("Comments: \n")
|
|
comments = request["comments"]
|
|
for comment in comments:
|
|
author = await ctx.guild.fetch_member(int(comment["author"]))
|
|
pag.add(
|
|
f'{author.display_name}: {comment["content"]}',
|
|
keep_intact=True,
|
|
)
|
|
else:
|
|
pag.add("No Comments")
|
|
|
|
if request.get("completed"):
|
|
closer = await ctx.guild.fetch_member(
|
|
int(request.get("completed_by"))
|
|
)
|
|
pag.add(
|
|
f'Closed By: {closer.name}#{closer.discriminator}\n{request.get("completed_message")}'
|
|
)
|
|
book = Book(pag, (None, ctx.channel, self.bot, ctx.message))
|
|
await book.create_book()
|
|
else:
|
|
await ctx.send("That is not your request to close.")
|
|
|
|
|
|
def setup(bot):
|
|
bot.add_cog(Tickets(bot))
|