async def apiAdminRolesCreate(cls: "PhaazebotWeb",
WebRequest: ExtendedRequest) -> Response:
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
Create: StorageTransformer = StorageTransformer()
Create["name"] = Data.getStr("name", UNDEFINED, len_max=64)
Create["description"] = Data.getStr("description", UNDEFINED, len_max=512)
Create["can_be_removed"] = Data.getBool("name", UNDEFINED)
# checks
if Create["name"] == UNDEFINED:
return await cls.Tree.Api.errors.apiMissingData(
cls, WebRequest, msg="missing or invalid 'name'")
res: list = cls.BASE.PhaazeDB.selectQuery(
"SELECT COUNT(*) AS `i` FROM `web_role` WHERE LOWER(`web_role`.`name`) = %s",
(Create["name"], ))
if res[0]['i'] != 0:
return await cls.Tree.Api.errors.apiWrongData(
cls, WebRequest, msg=f"role '{Create['name']}' already exists")
cls.BASE.PhaazeDB.insertQuery(table="web_role",
content=Create.getAllTransform())
return cls.response(text=json.dumps(
dict(msg="role successful created", role=Create["name"], status=200)),
content_type="application/json",
status=200)
async def apiAdminUsersCreate(cls:"PhaazebotWeb", WebRequest:ExtendedRequest) -> Response:
"""
Default url: /api/admin/users/create
"""
Data:WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
Create:StorageTransformer = StorageTransformer()
Create["username"] = Data.getStr("username", UNDEFINED, len_max=64)
Create["email"] = Data.getStr("email", UNDEFINED, len_max=128)
Create["password"] = Data.getStr("password", UNDEFINED, len_max=256)
# checks
if not Create["username"] or not Create["email"] or not Create["password"]:
return await cls.Tree.Api.errors.apiMissingData(cls, WebRequest, msg="missing 'username', 'email' or 'password'")
Create["password"] = passwordFunction(Create["password"])
res_users:List[WebUser] = await getWebUsers(cls, overwrite_where=" AND LOWER(`user`.`username`) = LOWER(%s) OR LOWER(`user`.`email`) = LOWER(%s)", overwrite_where_values=(Create["username"], Create["email"]))
if res_users:
return await cls.Tree.Api.Account.errors.apiAccountTaken(cls, WebRequest)
new_id:int = cls.BASE.PhaazeDB.insertQuery(
table="user",
content=Create.getAllTransform()
)
cls.BASE.Logger.debug(f"(API/Admin) Created user '{Create['username']}' (ID:{new_id})", require="api:user")
return cls.response(
text=json.dumps(dict(msg="successful created user", user_id=new_id, status=200)),
content_type="application/json",
status=200
)
async def apiDiscordLogsGet(cls: "PhaazebotWeb",
WebRequest: ExtendedRequest) -> Response:
"""
Default url: /api/discord/logs/get
"""
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
Search: StorageTransformer = StorageTransformer()
Search["guild_id"] = Data.getStr("guild_id", UNDEFINED, must_be_digit=True)
Search["log_id"] = Data.getStr("log_id", UNDEFINED, must_be_digit=True)
Search["event_value"] = Data.getInt("event_value", UNDEFINED, min_x=1)
Search["content_contains"] = Data.getStr("content_contains",
"",
len_min=1,
len_max=512)
Search["date_from"] = Data.getStr("date_from", None, len_min=1, len_max=64)
Search["date_to"] = Data.getStr("date_to", None, len_min=1, len_max=64)
Search["created_at_between"] = (Search["date_from"], Search["date_to"])
Search["limit"] = Data.getInt("limit",
DEFAULT_LIMIT,
min_x=1,
max_x=MAX_LIMIT)
Search["offset"] = Data.getInt("offset", 0, min_x=0)
# checks
if not Search["guild_id"]:
return await apiMissingData(cls,
WebRequest,
msg="missing or invalid 'guild_id'")
PhaazeDiscord: "PhaazebotDiscord" = cls.BASE.Discord
Guild: discord.Guild = discord.utils.get(PhaazeDiscord.guilds,
id=int(Search["guild_id"]))
if not Guild:
return await apiDiscordGuildUnknown(cls, WebRequest)
log_res: List[DiscordLog] = await getDiscordServerLogs(
PhaazeDiscord, **Search.getAllTransform())
result: Dict[str,
Any] = dict(result=[Log.toJSON() for Log in log_res],
total=await
getDiscordServerLogs(PhaazeDiscord,
count_mode=True,
**Search.getAllTransform()),
limit=Search["limit"],
offset=Search["offset"],
status=200)
return cls.response(text=json.dumps(result),
content_type="application/json",
status=200)
async def apiDiscordConfigsNsfwEnabledChannelsGet(cls:"PhaazebotWeb", WebRequest:ExtendedRequest) -> Response:
"""
Default url: /api/discord/configs/nsfwenabledchannels/get
"""
Data:WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
Search:StorageTransformer = StorageTransformer()
Search["guild_id"] = Data.getStr("guild_id", UNDEFINED, must_be_digit=True)
Search["entry_id"] = Data.getStr("entry_id", UNDEFINED, must_be_digit=True)
Search["channel_id"] = Data.getStr("channel_id", UNDEFINED, must_be_digit=True)
Search["limit"] = Data.getInt("limit", DEFAULT_LIMIT, min_x=1, max_x=MAX_LIMIT)
Search["offset"] = Data.getInt("offset", 0, min_x=0)
# checks
if not Search["guild_id"]:
return await apiMissingData(cls, WebRequest, msg="missing or invalid 'guild_id'")
PhaazeDiscord:"PhaazebotDiscord" = cls.BASE.Discord
Guild:discord.Guild = discord.utils.get(PhaazeDiscord.guilds, id=int(Search["guild_id"]))
if not Guild:
return await apiDiscordGuildUnknown(cls, WebRequest)
# get user info
AuthDiscord:AuthDiscordWebUser = await authDiscordWebUser(cls, WebRequest)
if not AuthDiscord.found:
return await cls.Tree.Api.errors.apiMissingAuthorisation(cls, WebRequest)
# get member
CheckMember:discord.Member = Guild.get_member(int(AuthDiscord.User.user_id))
if not CheckMember:
return await cls.Tree.Api.Discord.errors.apiDiscordMemberNotFound(cls, WebRequest, guild_id=Search["guild_id"], user_id=AuthDiscord.User.user_id)
# check permissions
if not (CheckMember.guild_permissions.administrator or CheckMember.guild_permissions.manage_guild):
return await cls.Tree.Api.Discord.errors.apiDiscordMissingPermission(cls, WebRequest, guild_id=Search["guild_id"], user_id=AuthDiscord.User.user_id)
channel_res:List[DiscordNsfwEnabledChannel] = await getDiscordServerNsfwEnabledChannels(PhaazeDiscord, **Search.getAllTransform())
result:Dict[str, Any] = dict(
result=[Chan.toJSON() for Chan in channel_res],
limit=Search["limit"],
offset=Search["offset"],
total=await getDiscordServerNsfwEnabledChannels(PhaazeDiscord, count_mode=True, **Search.getAllTransform()),
status=200
)
return cls.response(
text=json.dumps(result),
content_type="application/json",
status=200
)
async def apiDiscordTwitchalertsGet(cls: "PhaazebotWeb",
WebRequest: ExtendedRequest) -> Response:
"""
Default url: /api/discord/twitchalerts/get
"""
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
Search: StorageTransformer = StorageTransformer()
Search["discord_guild_id"] = Data.getStr("guild_id",
UNDEFINED,
must_be_digit=True)
Search["alert_id"] = Data.getInt("alert_id", UNDEFINED, min_x=1)
Search["limit"] = Data.getInt("limit",
DEFAULT_LIMIT,
min_x=1,
max_x=MAX_LIMIT)
Search["offset"] = Data.getInt("offset", 0, min_x=0)
# checks
if not Search["discord_guild_id"]:
return await apiMissingData(cls,
WebRequest,
msg="missing or invalid 'guild_id'")
PhaazeDiscord: "PhaazebotDiscord" = cls.BASE.Discord
Guild: discord.Guild = discord.utils.get(PhaazeDiscord.guilds,
id=int(
Search["discord_guild_id"]))
if not Guild:
return await apiDiscordGuildUnknown(cls, WebRequest)
# get alerts
res_alerts: List[DiscordTwitchAlert] = await getDiscordServerTwitchAlerts(
PhaazeDiscord, **Search.getAllTransform())
# if only one is requested, also send custom content
with_message: bool = True if Search["alert_id"] else False
result: Dict[str, Any] = dict(
result=[Alert.toJSON(custom_msg=with_message) for Alert in res_alerts],
limit=Search["limit"],
offset=Search["offset"],
total=await getDiscordServerTwitchAlerts(PhaazeDiscord,
count_mode=True,
**Search.getAllTransform()),
status=200)
return cls.response(text=json.dumps(result),
content_type="application/json",
status=200)
async def apiDiscordAssignrolesGet(cls: "PhaazebotWeb",
WebRequest: ExtendedRequest) -> Response:
"""
Default url: /api/discord/assignroles/get
"""
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
Search: StorageTransformer = StorageTransformer()
Search["guild_id"] = Data.getStr("guild_id", UNDEFINED, must_be_digit=True)
Search["assignrole_id"] = Data.getStr("assignrole_id",
UNDEFINED,
must_be_digit=True)
Search["role_id"] = Data.getStr("role_id", UNDEFINED, must_be_digit=True)
Search["limit"] = Data.getInt("limit",
DEFAULT_LIMIT,
min_x=1,
max_x=MAX_LIMIT)
Search["offset"] = Data.getInt("offset", 0, min_x=0)
# checks
if not Search["guild_id"]:
return await apiMissingData(cls,
WebRequest,
msg="missing or invalid 'guild_id'")
PhaazeDiscord: "PhaazebotDiscord" = cls.BASE.Discord
Guild: discord.Guild = discord.utils.get(PhaazeDiscord.guilds,
id=int(Search["guild_id"]))
if not Guild:
return await apiDiscordGuildUnknown(cls, WebRequest)
assignroles: list = await getDiscordServerAssignRoles(
PhaazeDiscord, **Search.getAllTransform())
result: Dict[str, Any] = dict(
result=[ARole.toJSON() for ARole in assignroles],
limit=Search["limit"],
offset=Search["offset"],
total=await getDiscordServerAssignRoles(PhaazeDiscord,
count_mode=True,
**Search.getAllTransform()),
status=200)
return cls.response(text=json.dumps(result),
content_type="application/json",
status=200)
async def apiAdminRolesGet(cls: "PhaazebotWeb",
WebRequest: Request) -> Response:
"""
Default url: /api/admin/roles/get
"""
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
Search: StorageTransformer = StorageTransformer()
# get required stuff
Search["role_id"] = Data.getInt("role_id", UNDEFINED, min_x=1)
Search["name"] = Data.getStr("name", UNDEFINED)
Search["name_contains"] = Data.getStr("name_contains", UNDEFINED)
Search["can_be_removed"] = Data.getInt("can_be_removed", UNDEFINED)
Search["limit"] = Data.getInt("limit", DEFAULT_LIMIT, min_x=1)
Search["offset"] = Data.getInt("offset", 0, min_x=1)
# custom
Search["for_user_id"] = Data.getInt("for_user_id", UNDEFINED, min_x=1)
if Search["for_user_id"] != UNDEFINED:
res: List[dict] = cls.BASE.PhaazeDB.selectQuery(
"""
SELECT `web_user+web_role`.`role_id` AS `rid`
FROM `web_user+web_role`
WHERE `web_user+web_role`.`user_id` = %s""", (int(Search["for_user_id"]), ))
rid_list: str = ','.join(str(x["rid"]) for x in res)
if not rid_list: rid_list = "0"
Search["overwrite_where"] = f" AND `web_role`.`id` IN ({rid_list})"
res_roles: List[WebRole] = await getWebRoles(cls,
**Search.getAllTransform())
result: dict = dict(result=[Role.toJSON() for Role in res_roles],
limit=Search["limit"],
offset=Search["offset"],
total=await getWebRoles(cls,
count_mode=True,
**Search.getAllTransform()),
status=200)
return cls.response(text=json.dumps(result),
content_type="application/json",
status=200)
async def apiDiscordLevelsMedalsGet(cls:"PhaazebotWeb", WebRequest:ExtendedRequest) -> Response:
"""
Default url: /api/discord/levels/medals/get
"""
Data:WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
Search:StorageTransformer = StorageTransformer()
Search["guild_id"] = Data.getStr("guild_id", UNDEFINED, must_be_digit=True)
Search["medal_id"] = Data.getStr("medal_id", UNDEFINED, must_be_digit=True)
Search["member_id"] = Data.getStr("member_id", UNDEFINED, must_be_digit=True)
Search["name"] = Data.getStr("name", UNDEFINED, len_max=512)
Search["name_contains"] = Data.getStr("name_contains", UNDEFINED, len_max=512)
Search["limit"] = Data.getInt("limit", DEFAULT_LIMIT, min_x=1, max_x=MAX_LIMIT)
Search["offset"] = Data.getInt("offset", 0, min_x=0)
if not Search["guild_id"]:
return await apiMissingData(cls, WebRequest, msg="missing or invalid 'guild_id'")
PhaazeDiscord:"PhaazebotDiscord" = cls.BASE.Discord
Guild:discord.Guild = discord.utils.get(PhaazeDiscord.guilds, id=int(Search["guild_id"]))
if not Guild:
return await apiDiscordGuildUnknown(cls, WebRequest)
# get medals
res_medals:list = await getDiscordUsersMedals(PhaazeDiscord, **Search.getAllTransform())
result:Dict[str, Any] = dict(
result=[Medal.toJSON() for Medal in res_medals],
limit=Search["limit"],
offset=Search["offset"],
total=await getDiscordUsersMedals(PhaazeDiscord, count_mode=True, **Search.getAllTransform()),
status=200
)
return cls.response(
text=json.dumps(result),
content_type="application/json",
status=200
)
async def apiAdminUsersGet(cls: "PhaazebotWeb",
WebRequest: ExtendedRequest) -> Response:
"""
Default url: /api/admin/users/get
"""
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
Search: StorageTransformer = StorageTransformer()
# get required stuff
Search["user_id"] = Data.getInt("user_id", UNDEFINED, min_x=1)
Search["username"] = Data.getStr("username", UNDEFINED, len_max=64)
Search["username_contains"] = Data.getStr("username_contains",
UNDEFINED,
len_max=64)
Search["email"] = Data.getStr("email", UNDEFINED, len_max=128)
Search["email_contains"] = Data.getStr("email_contains",
UNDEFINED,
len_max=128)
Search["limit"] = Data.getInt("limit", DEFAULT_LIMIT, min_x=1)
Search["offset"] = Data.getInt("offset", 0, min_x=1)
# get user
res_users: List[WebUser] = await getWebUsers(cls,
**Search.getAllTransform())
result: Dict[str, Any] = dict(result=[Us.toJSON() for Us in res_users],
limit=Search["limit"],
offset=Search["offset"],
total=await
getWebUsers(cls,
count_mode=True,
**Search.getAllTransform()),
status=200)
return cls.response(text=json.dumps(result),
content_type="application/json",
status=200)
async def apiDiscordAssignrolesCreate(cls: "PhaazebotWeb",
WebRequest: ExtendedRequest) -> Response:
"""
Default url: /api/discord/assignroles/create
"""
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
Create: StorageTransformer = StorageTransformer()
Create["guild_id"] = Data.getStr("guild_id", UNDEFINED, must_be_digit=True)
Create["role_id"] = Data.getStr("role_id", UNDEFINED, must_be_digit=True)
Create["trigger"] = Data.getStr("trigger", "").lower().split(
" "
)[0] # only take the first argument trigger, since everything else can't be typed in a channel
# checks
if not Create["guild_id"]:
return await cls.Tree.Api.errors.apiMissingData(
cls, WebRequest, msg="missing or invalid 'guild_id'")
if not Create["role_id"]:
return await cls.Tree.Api.errors.apiMissingData(
cls, WebRequest, msg="missing or invalid 'role_id'")
if not Create["trigger"]:
return await cls.Tree.Api.errors.apiMissingData(
cls, WebRequest, msg="missing or invalid 'trigger'")
PhaazeDiscord: "PhaazebotDiscord" = cls.BASE.Discord
Guild: discord.Guild = discord.utils.get(PhaazeDiscord.guilds,
id=int(Create["guild_id"]))
if not Guild:
return await cls.Tree.Api.Discord.errors.apiDiscordGuildUnknown(
cls, WebRequest)
# get user info
AuthDiscord: AuthDiscordWebUser = await authDiscordWebUser(cls, WebRequest)
if not AuthDiscord.found:
return await cls.Tree.Api.errors.apiMissingAuthorisation(
cls, WebRequest)
# get member
CheckMember: discord.Member = Guild.get_member(
int(AuthDiscord.User.user_id))
if not CheckMember:
return await cls.Tree.Api.Discord.errors.apiDiscordMemberNotFound(
cls,
WebRequest,
guild_id=Create["guild_id"],
user_id=AuthDiscord.User.user_id)
# check permissions
if not (CheckMember.guild_permissions.administrator
or CheckMember.guild_permissions.manage_guild):
return await cls.Tree.Api.Discord.errors.apiDiscordMissingPermission(
cls,
WebRequest,
guild_id=Create["guild_id"],
user_id=AuthDiscord.User.user_id)
# get server role
AssignRole: discord.Role = getDiscordRoleFromString(
PhaazeDiscord, Guild, Create["role_id"])
if not AssignRole:
return await cls.Tree.Api.Discord.errors.apiDiscordRoleNotFound(
cls,
WebRequest,
guild_id=Guild.name,
guild_name=Guild.name,
role_id=Create["role_id"])
if AssignRole >= Guild.me.top_role or AssignRole == Guild.default_role:
return await cls.Tree.errors.piWrongData(
cls, WebRequest, msg=f"The Role `{AssignRole.name}` is to high")
# check if already exists and limits
res: list = cls.BASE.PhaazeDB.selectQuery(
"""
SELECT
COUNT(*) AS `all`,
SUM(
CASE WHEN `discord_assignrole`.`role_id` = %s
THEN 1 ELSE 0 END
) AS `match_role_id`,
SUM(
CASE WHEN LOWER(`discord_assignrole`.`trigger`) = LOWER(%s)
THEN 1 ELSE 0 END
) AS `match_trigger`
FROM `discord_assignrole`
WHERE `discord_assignrole`.`guild_id` = %s""",
(Create["role_id"], Create["trigger"], Create["guild_id"]))
if res[0]["match_role_id"]:
return await cls.Tree.Api.Discord.errors.apiDiscordAssignRoleExists(
cls,
WebRequest,
role_id=Create["role_id"],
role_name=AssignRole.name)
if res[0]["match_trigger"]:
return await cls.Tree.Api.Discord.errors.apiDiscordAssignRoleExists(
cls, WebRequest, trigger=Create["trigger"])
if res[0]["all"] >= cls.BASE.Limit.discord_assignrole_amount:
return await cls.Tree.Api.Discord.errors.apiDiscordAssignRoleLimit(
cls, WebRequest, limit=cls.BASE.Limit.discord_assignrole_amount)
cls.BASE.PhaazeDB.insertQuery(table="discord_assignrole",
content={
"guild_id": Create["guild_id"],
"trigger": Create["trigger"],
"role_id": str(AssignRole.id)
})
# logging
GuildSettings: DiscordServerSettings = await getDiscordSeverSettings(
PhaazeDiscord, Create["guild_id"], prevent_new=True)
log_coro: Coroutine = loggingOnAssignroleCreate(
PhaazeDiscord,
GuildSettings,
Creator=CheckMember,
assign_role_id=Create["role_id"],
trigger=Create["trigger"])
asyncio.ensure_future(log_coro, loop=cls.BASE.DiscordLoop)
cls.BASE.Logger.debug(
f"(API/Discord) Assignroles: {Create['guild_id']=} added: {Create['trigger']=}",
require="discord:configs")
return cls.response(text=json.dumps(
dict(msg="Assignroles: Added new entry",
entry=Create["trigger"],
status=200)),
content_type="application/json",
status=200)
async def apiDiscordTwitchalertsEdit(cls: "PhaazebotWeb",
WebRequest: ExtendedRequest) -> Response:
"""
Default url: /api/discord/twitchalerts/edit
"""
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
Edit: StorageTransformer = StorageTransformer()
Edit["guild_id"] = Data.getStr("guild_id", UNDEFINED, must_be_digit=True)
Edit["alert_id"] = Data.getStr("alert_id", UNDEFINED, must_be_digit=True)
# checks
if not Edit["alert_id"]:
return await cls.Tree.Api.errors.apiMissingData(
cls, WebRequest, msg="missing or invalid 'alert_id'")
if not Edit["guild_id"]:
return await cls.Tree.Api.errors.apiMissingData(
cls, WebRequest, msg="missing or invalid 'guild_id'")
# get/check discord
PhaazeDiscord: "PhaazebotDiscord" = cls.BASE.Discord
Guild: discord.Guild = discord.utils.get(PhaazeDiscord.guilds,
id=int(Edit["guild_id"]))
if not Guild:
return await cls.Tree.Api.Discord.errors.apiDiscordGuildUnknown(
cls, WebRequest)
# get alert
res_alerts: list = await getDiscordServerTwitchAlerts(
PhaazeDiscord,
discord_guild_id=Edit["guild_id"],
alert_id=Edit["alert_id"])
if not res_alerts:
return await cls.Tree.Api.Discord.Twitchalerts.errors.apiDiscordAlertNotExists(
cls, WebRequest, alert_id=Edit["guild_id"])
CurrentEditAlert: DiscordTwitchAlert = res_alerts.pop(0)
# check all update values
update: dict = dict()
Edit["custom_msg"] = Data.getStr("custom_msg",
UNDEFINED,
len_max=MAX_CONTENT_SIZE,
allow_none=True)
if Edit["custom_msg"] != UNDEFINED:
update["custom_msg"] = Edit["custom_msg"]
Edit["suppress_gamechange"] = Data.getBool("suppress_gamechange",
UNDEFINED)
if Edit["suppress_gamechange"] != UNDEFINED:
update["suppress_gamechange"] = Edit["suppress_gamechange"]
if not update:
return await cls.Tree.Api.errors.apiWrongData(
cls, WebRequest, msg=f"No changes, please add at least one")
# get user info
AuthDiscord: AuthDiscordWebUser = await authDiscordWebUser(cls, WebRequest)
if not AuthDiscord.found:
return await cls.Tree.Api.errors.apiMissingAuthorisation(
cls, WebRequest)
# get member
CheckMember: discord.Member = Guild.get_member(
int(AuthDiscord.User.user_id))
if not CheckMember:
return await cls.Tree.Api.Discord.errors.apiDiscordMemberNotFound(
cls,
WebRequest,
guild_id=Edit["guild_id"],
user_id=AuthDiscord.User.user_id)
# check permissions
if not (CheckMember.guild_permissions.administrator
or CheckMember.guild_permissions.manage_guild):
return await cls.Tree.Api.Discord.errors.apiDiscordMissingPermission(
cls,
WebRequest,
guild_id=Edit["guild_id"],
user_id=AuthDiscord.User.user_id)
cls.BASE.PhaazeDB.updateQuery(
table="discord_twitch_alert",
content=update,
where=
"`discord_twitch_alert`.`discord_guild_id` = %s AND `discord_twitch_alert`.`id` = %s",
where_values=(CurrentEditAlert.guild_id, CurrentEditAlert.alert_id))
# logging
GuildSettings: DiscordServerSettings = await getDiscordSeverSettings(
PhaazeDiscord, Edit["guild_id"], prevent_new=True)
log_coro: Coroutine = loggingOnTwitchalertEdit(
PhaazeDiscord,
GuildSettings,
ChangeMember=CheckMember,
twitch_channel=CurrentEditAlert.twitch_channel_name,
discord_channel_id=CurrentEditAlert.discord_channel_id,
changes=update)
asyncio.ensure_future(log_coro, loop=cls.BASE.DiscordLoop)
cls.BASE.Logger.debug(
f"(API/Discord) Twitchalert: {Edit['guild_id']=} edited {Edit['alert_id']=}",
require="discord:alerts")
return cls.response(text=json.dumps(
dict(msg="Twitchalert: Edited entry", changes=update, status=200)),
content_type="application/json",
status=200)
async def apiDiscordCommandsGet(cls:"PhaazebotWeb", WebRequest:ExtendedRequest) -> Response:
"""
Default url: /api/discord/commands/get
"""
Data:WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required vars
Search:StorageTransformer = StorageTransformer()
Search["guild_id"] = Data.getStr("guild_id", UNDEFINED, must_be_digit=True)
Search["command_id"] = Data.getStr("command_id", UNDEFINED, must_be_digit=True)
Search["trigger"] = Data.getStr("trigger", UNDEFINED, len_min=1, len_max=128)
Search["show_hidden"] = Data.getBool("show_hidden", False)
Search["active"] = None if Search["show_hidden"] else 1
Search["limit"] = Data.getInt("limit", DEFAULT_LIMIT, min_x=1, max_x=MAX_LIMIT)
Search["offset"] = Data.getInt("offset", 0, min_x=0)
# checks
if not Search["guild_id"]:
return await apiMissingData(cls, WebRequest, msg="missing or invalid 'guild_id'")
PhaazeDiscord:"PhaazebotDiscord" = cls.BASE.Discord
Guild:discord.Guild = discord.utils.get(PhaazeDiscord.guilds, id=int(Search["guild_id"]))
if not Guild:
return await apiDiscordGuildUnknown(cls, WebRequest)
if Search["show_hidden"]:
# user requested to get full information about commands, requires authorisation
AuthDiscord:AuthDiscordWebUser = await authDiscordWebUser(cls, WebRequest)
if not AuthDiscord.found:
return await apiMissingAuthorisation(cls, WebRequest)
# get member
CheckMember:discord.Member = Guild.get_member(int(AuthDiscord.User.user_id))
if not CheckMember:
return await cls.Tree.Api.Discord.errors.apiDiscordMemberNotFound(cls, WebRequest, guild_id=Search["guild_id"], user_id=AuthDiscord.User.user_id)
# check permissions
if not (CheckMember.guild_permissions.administrator or CheckMember.guild_permissions.manage_guild):
return await cls.Tree.Api.Discord.errors.apiDiscordMissingPermission(
cls,
WebRequest,
guild_id=Search["guild_id"],
user_id=AuthDiscord.User.user_id,
msg="'administrator' or 'manage_guild' permission required to show commands with hidden properties"
)
res_commands:List[DiscordCommand] = await getDiscordServerCommands(PhaazeDiscord, **Search.getAllTransform())
result:Dict[str, Any] = dict(
result=[Command.toJSON(show_hidden=Search["show_hidden"]) for Command in res_commands],
limit=Search["limit"],
offset=Search["offset"],
total=await getDiscordServerCommands(PhaazeDiscord, count_mode=True, **Search.getAllTransform()),
status=200
)
return cls.response(
text=json.dumps(result),
content_type="application/json",
status=200
)
async def apiDiscordAssignrolesEdit(cls: "PhaazebotWeb",
WebRequest: ExtendedRequest) -> Response:
"""
Default url: /api/discord/assignroles/edit
"""
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
Edit: StorageTransformer = StorageTransformer()
Edit["assignrole_id"] = Data.getInt("assignrole_id", "", min_x=1)
Edit["guild_id"] = Data.getStr("guild_id", "", must_be_digit=True)
# checks
if not Edit["assignrole_id"]:
return await cls.Tree.Api.errors.apiMissingData(
cls, WebRequest, msg="missing or invalid 'assignrole_id'")
if not Edit["guild_id"]:
return await cls.Tree.Api.errors.apiMissingData(
cls, WebRequest, msg="missing or invalid 'guild_id'")
# get/check discord
PhaazeDiscord: "PhaazebotDiscord" = cls.BASE.Discord
Guild: discord.Guild = discord.utils.get(PhaazeDiscord.guilds,
id=int(Edit["guild_id"]))
if not Guild:
return await cls.Tree.Api.Discord.errors.apiDiscordGuildUnknown(
cls, WebRequest)
# check if exists
res_assignroles: list = await getDiscordServerAssignRoles(
PhaazeDiscord,
guild_id=Edit["guild_id"],
assignrole_id=Edit["assignrole_id"])
if not res_assignroles:
return await cls.Tree.Api.Discord.errors.apiDiscordAssignRoleNotExists(
cls, WebRequest, assignrole_id=Edit["assignrole_id"])
AssignRoleToEdit: DiscordAssignRole = res_assignroles.pop(0)
# check all update values
update: dict = dict()
Edit["role_id"] = Data.getStr("role_id", UNDEFINED, must_be_digit=True)
if Edit["role_id"] != UNDEFINED:
AssignRole: discord.Role = getDiscordRoleFromString(
PhaazeDiscord, Guild, Edit["role_id"])
if not AssignRole:
return await cls.Tree.Api.Discord.errors.apiDiscordRoleNotFound(
cls,
WebRequest,
guild_name=Guild.name,
guild_id=Guild.id,
role_id=Edit["role_id"])
if AssignRole > Guild.me.top_role or AssignRole == Guild.default_role:
return await cls.Tree.Api.errors.apiWrongData(
cls,
WebRequest,
msg=f"The Role `{AssignRole.name}` is to high")
update["role_id"] = Edit["role_id"]
Edit["trigger"] = Data.getStr("trigger", "").lower().split(" ")[0]
if Edit["trigger"]:
# try to get command with this trigger
check_double_trigger: list = await getDiscordServerAssignRoles(
cls.BASE.Discord,
guild_id=Edit["guild_id"],
trigger=Edit["trigger"])
if check_double_trigger:
AssignRoleToCheck: DiscordAssignRole = check_double_trigger.pop(0)
# tried to set a trigger twice
if str(AssignRoleToEdit.assignrole_id) != str(
AssignRoleToCheck.assignrole_id):
return await cls.Tree.Api.Discord.Assignroles.errors.apiDiscordAssignRoleExists(
cls, WebRequest, trigger=Edit["trigger"])
update["trigger"] = Edit["trigger"]
# get user info
AuthDiscord: AuthDiscordWebUser = await authDiscordWebUser(cls, WebRequest)
if not AuthDiscord.found:
return await cls.Tree.Api.errors.apiMissingAuthorisation(
cls, WebRequest)
# get member
CheckMember: discord.Member = Guild.get_member(
int(AuthDiscord.User.user_id))
if not CheckMember:
return await cls.Tree.Api.Discord.errors.apiDiscordMemberNotFound(
cls,
WebRequest,
guild_id=Edit["guild_id"],
user_id=AuthDiscord.User.user_id)
# check permissions
if not (CheckMember.guild_permissions.administrator
or CheckMember.guild_permissions.manage_guild):
return await cls.Tree.Api.Discord.errors.apiDiscordMissingPermission(
cls,
WebRequest,
guild_id=Edit["guild_id"],
user_id=AuthDiscord.User.user_id)
if not update:
return await cls.Tree.Api.errors.apiWrongData(
cls, WebRequest, msg=f"No changes, please add at least one")
cls.BASE.PhaazeDB.updateQuery(
table="discord_assignrole",
content=update,
where=
"`discord_assignrole`.`guild_id` = %s AND `discord_assignrole`.`id` = %s",
where_values=(AssignRoleToEdit.guild_id,
AssignRoleToEdit.assignrole_id))
# logging
GuildSettings: DiscordServerSettings = await getDiscordSeverSettings(
PhaazeDiscord, Edit["guild_id"], prevent_new=True)
log_coro: Coroutine = loggingOnAssignroleEdit(
PhaazeDiscord,
GuildSettings,
Editor=CheckMember,
assign_role_trigger=AssignRoleToEdit.trigger,
changes=update)
asyncio.ensure_future(log_coro, loop=cls.BASE.DiscordLoop)
cls.BASE.Logger.debug(
f"(API/Discord) Assignrole: {Edit['guild_id']=} edited {Edit['assignrole_id']=}",
require="discord:role")
return cls.response(text=json.dumps(
dict(msg="Assignrole: Edited entry", changes=update, status=200)),
content_type="application/json",
status=200)
async def apiDiscordCommandsEdit(cls:"PhaazebotWeb", WebRequest:ExtendedRequest) -> Response:
"""
Default url: /api/discord/commands/edit
"""
Data:WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
Edit:StorageTransformer = StorageTransformer()
Edit["command_id"] = Data.getInt("command_id", "", min_x=1)
Edit["guild_id"] = Data.getStr("guild_id", "", must_be_digit=True)
# checks
if not Edit["command_id"]:
return await cls.Tree.Api.errors.apiMissingData(cls, WebRequest, msg="missing or invalid 'command_id'")
if not Edit["guild_id"]:
return await cls.Tree.Api.errors.apiMissingData(cls, WebRequest, msg="missing or invalid 'guild_id'")
# get/check discord
PhaazeDiscord:"PhaazebotDiscord" = cls.BASE.Discord
Guild:discord.Guild = discord.utils.get(PhaazeDiscord.guilds, id=int(Edit["guild_id"]))
if not Guild:
return await cls.Tree.Api.Discord.errors.apiDiscordGuildUnknown(cls, WebRequest)
# check if exists
res_commands:list = await getDiscordServerCommands(PhaazeDiscord, guild_id=Edit["guild_id"], command_id=Edit["command_id"], active=None)
if not res_commands:
return await cls.Tree.Api.Discord.Commands.errors.apiDiscordCommandNotExists(cls, WebRequest, command_id=Edit["command_id"])
CurrentEditCommand:DiscordCommand = res_commands.pop(0)
# after this point we have a existing command
# check all possible values if it should be edited
update:dict = dict()
# active
Edit["active"] = Data.getBool("active", UNDEFINED)
if Edit["active"] != UNDEFINED:
update["active"] = Edit["active"]
# trigger
Edit["trigger"] = Data.getStr("trigger", "", len_max=128).lower().split(" ")[0]
if Edit["trigger"]:
# try to get command with this trigger
check_double_trigger:list = await getDiscordServerCommands(PhaazeDiscord, guild_id=Edit["guild_id"], trigger=Edit["trigger"])
if check_double_trigger:
CommandToCheck:DiscordCommand = check_double_trigger.pop(0)
# tried to set a trigger twice
if str(CommandToCheck.command_id) != str(CurrentEditCommand.command_id):
return await cls.Tree.Api.Discord.Commands.errors.apiDiscordCommandExists(cls, WebRequest, trigger=Edit["trigger"])
update["trigger"] = Edit["trigger"]
# cooldown
Edit["cooldown"] = Data.getInt("cooldown", UNDEFINED, min_x=0)
if Edit["cooldown"] != UNDEFINED:
# wants a invalid cooldown
if not (cls.BASE.Limit.discord_commands_cooldown_min <= Edit["cooldown"] <= cls.BASE.Limit.discord_commands_cooldown_max):
return await cls.Tree.Api.errors.apiWrongData(cls, WebRequest, msg="'cooldown' is wrong")
update["cooldown"] = Edit["cooldown"]
# currency
Edit["required_currency"] = Data.getInt("required_currency", UNDEFINED, min_x=0)
if Edit["required_currency"] != UNDEFINED:
update["required_currency"] = Edit["required_currency"]
# require
Edit["require"] = Data.getInt("require", UNDEFINED, min_x=0)
if Edit["require"] != UNDEFINED:
update["require"] = Edit["require"]
# content
Edit["content"] = Data.getStr("content", UNDEFINED, len_max=1750)
if Edit["content"] != UNDEFINED:
update["content"] = Edit["content"]
# hidden
Edit["hidden"] = Data.getBool("hidden", UNDEFINED)
if Edit["hidden"] != UNDEFINED:
update["hidden"] = Edit["hidden"]
# function (and type)
Edit["complex"] = Data.getBool("complex", False)
Edit["function"] = Data.getStr("function", UNDEFINED, len_max=256)
if not Edit["complex"] and Edit["function"] != UNDEFINED:
# it its not complex, we need a function
if Edit["function"] not in [cmd["function"].__name__ for cmd in command_register]:
return await cls.Tree.Api.errors.apiWrongData(cls, WebRequest, msg=f"'{Edit['function']}' is not a valid value for field 'function'")
update["complex"] = Edit["complex"]
update["function"] = Edit["function"]
if Edit["complex"] and not Edit["function"]:
# it is complex, we need a content
if not update.get("content", ""):
return await cls.Tree.Api.errors.apiWrongData(cls, WebRequest, msg=f"'complex' is true, but missing 'content'")
update["complex"] = Edit["complex"]
update["function"] = ""
# get user info
AuthDiscord:AuthDiscordWebUser = await authDiscordWebUser(cls, WebRequest)
if not AuthDiscord.found:
return await cls.Tree.Api.errors.apiMissingAuthorisation(cls, WebRequest)
# get member
CheckMember:discord.Member = Guild.get_member(int(AuthDiscord.User.user_id))
if not CheckMember:
return await cls.Tree.Api.Discord.errors.apiDiscordMemberNotFound(cls, WebRequest, guild_id=Edit["guild_id"], user_id=AuthDiscord.User.user_id)
# check permissions
if not (CheckMember.guild_permissions.administrator or CheckMember.guild_permissions.manage_guild):
return await cls.Tree.Api.Discord.errors.apiDiscordMissingPermission(cls, WebRequest, guild_id=Edit["guild_id"], user_id=AuthDiscord.User.user_id)
if not update:
return await cls.Tree.Api.errors.apiWrongData(cls, WebRequest, msg=f"No changes, please add at least one")
cls.BASE.PhaazeDB.updateQuery(
table="discord_command",
content=update,
where="`discord_command`.`guild_id` = %s AND `discord_command`.`id` = %s",
where_values=(CurrentEditCommand.server_id, CurrentEditCommand.command_id)
)
# logging
GuildSettings:DiscordServerSettings = await getDiscordSeverSettings(PhaazeDiscord, Edit["guild_id"], prevent_new=True)
log_coro:Coroutine = loggingOnCommandEdit(PhaazeDiscord, GuildSettings, Editor=CheckMember, command_trigger=CurrentEditCommand.trigger, command_info=update)
asyncio.ensure_future(log_coro, loop=cls.BASE.DiscordLoop)
cls.BASE.Logger.debug(f"(API/Discord) Commands: {Edit['guild_id']=} edited {Edit['command_id']=}", require="discord:commands")
return cls.response(
text=json.dumps(dict(msg="Commands: Edited entry", changes=update, status=200)),
content_type="application/json",
status=200
)
async def apiDiscordRegularsCreate(cls: "PhaazebotWeb",
WebRequest: ExtendedRequest) -> Response:
"""
Default url: /api/discord/regulars/create
"""
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
Create: StorageTransformer = StorageTransformer()
Create["guild_id"] = Data.getStr("guild_id", UNDEFINED, must_be_digit=True)
Create["member_id"] = Data.getStr("member_id",
UNDEFINED,
must_be_digit=True)
# checks
if not Create["guild_id"]:
return await cls.Tree.Api.errors.apiMissingData(
cls, WebRequest, msg="missing or invalid 'guild_id'")
if not Create["member_id"]:
return await cls.Tree.Api.errors.apiMissingData(
cls, WebRequest, msg="missing or invalid 'member_id'")
# get/check discord
PhaazeDiscord: "PhaazebotDiscord" = cls.BASE.Discord
Guild: discord.Guild = discord.utils.get(PhaazeDiscord.guilds,
id=int(Create["guild_id"]))
if not Guild:
return await cls.Tree.Api.Discord.errors.apiDiscordGuildUnknown(
cls, WebRequest)
ActionMember: discord.Member = getDiscordMemberFromString(
PhaazeDiscord, Guild, Create["member_id"])
if not ActionMember:
return await cls.Tree.Api.Discord.errors.apiDiscordMemberNotFound(
cls, WebRequest, user_id=Create["member_id"])
# check if already exists and limits
res: list = cls.BASE.PhaazeDB.selectQuery(
"""
SELECT
COUNT(*) AS `all`,
SUM(
CASE WHEN `discord_regular`.`member_id` = %s
THEN 1 ELSE 0 END
) AS `match`
FROM `discord_regular`
WHERE `discord_regular`.`guild_id` = %s""",
(str(ActionMember.id), str(ActionMember.guild.id)))
if res[0]["match"]:
return await cls.Tree.Api.Discord.Regulars.errors.apiDiscordRegularExists(
cls, WebRequest)
if res[0]["all"] >= cls.BASE.Limit.discord_regular_amount:
return await cls.Tree.Api.Discord.Regulars.errors.apiDiscordRegularLimit(
cls, WebRequest)
# get user info
AuthDiscord: AuthDiscordWebUser = await authDiscordWebUser(cls, WebRequest)
if not AuthDiscord.found:
return await cls.Tree.Api.errors.apiMissingAuthorisation(
cls, WebRequest)
# get member
CheckMember: discord.Member = Guild.get_member(
int(AuthDiscord.User.user_id))
if not CheckMember:
return await cls.Tree.Api.Discord.errors.apiDiscordMemberNotFound(
cls,
WebRequest,
guild_id=Create["guild_id"],
user_id=AuthDiscord.User.user_id)
# check permissions
if not (CheckMember.guild_permissions.administrator
or CheckMember.guild_permissions.manage_guild):
return await cls.Tree.Api.Discord.errors.apiDiscordMissingPermission(
cls,
WebRequest,
guild_id=Create["guild_id"],
user_id=AuthDiscord.User.user_id)
cls.BASE.PhaazeDB.insertQuery(table="discord_regular",
content={
"guild_id": str(ActionMember.guild.id),
"member_id": str(ActionMember.id)
})
# logging
GuildSettings: DiscordServerSettings = await getDiscordSeverSettings(
PhaazeDiscord, Create["guild_id"], prevent_new=True)
log_coro: Coroutine = loggingOnRegularCreate(PhaazeDiscord,
GuildSettings,
Creator=CheckMember,
NewRegular=ActionMember)
asyncio.ensure_future(log_coro, loop=cls.BASE.DiscordLoop)
cls.BASE.Logger.debug(
f"(API/Discord) Regular: {Create['guild_id']=} added new entry {Create['member_id']=}",
require="discord:regulars")
return cls.response(text=json.dumps(
dict(msg="Regulars: Added new entry",
entry=ActionMember.name,
status=200)),
content_type="application/json",
status=200)
async def apiDiscordConfigsGameEnabledChannelsCreate(
cls: "PhaazebotWeb", WebRequest: ExtendedRequest) -> Response:
"""
Default url: /api/discord/configs/gameenabledchannels/create
"""
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
Create: StorageTransformer = StorageTransformer()
Create["guild_id"] = Data.getStr("guild_id", UNDEFINED, must_be_digit=True)
Create["channel_id"] = Data.getStr("channel_id",
UNDEFINED,
must_be_digit=True)
# checks
if not Create["guild_id"]:
return await cls.Tree.Api.errors.apiMissingData(
cls, WebRequest, msg="missing or invalid 'guild_id'")
if not Create["channel_id"]:
return await cls.Tree.Api.errors.apiMissingData(
cls, WebRequest, msg="missing or invalid 'channel_id'")
PhaazeDiscord: "PhaazebotDiscord" = cls.BASE.Discord
Guild: discord.Guild = discord.utils.get(PhaazeDiscord.guilds,
id=int(Create["guild_id"]))
if not Guild:
return await cls.Tree.Api.Discord.errors.apiDiscordGuildUnknown(
cls, WebRequest)
# get user info
AuthDiscord: AuthDiscordWebUser = await authDiscordWebUser(cls, WebRequest)
if not AuthDiscord.found:
return await cls.Tree.Api.errors.apiMissingAuthorisation(
cls, WebRequest)
# get member
CheckMember: discord.Member = Guild.get_member(
int(AuthDiscord.User.user_id))
if not CheckMember:
return await cls.Tree.Api.Discord.errors.apiDiscordMemberNotFound(
cls,
WebRequest,
guild_id=Create["guild_id"],
user_id=AuthDiscord.User.user_id)
# check permissions
if not (CheckMember.guild_permissions.administrator
or CheckMember.guild_permissions.manage_guild):
return await cls.Tree.Api.Discord.errors.apiDiscordMissingPermission(
cls,
WebRequest,
guild_id=Create["guild_id"],
user_id=AuthDiscord.User.user_id)
ActionChannel: discord.TextChannel = getDiscordChannelFromString(
PhaazeDiscord, Guild, Create["channel_id"], required_type="text")
if not ActionChannel:
return await cls.Tree.Api.Discord.errors.apiDiscordChannelNotFound(
cls, WebRequest, channel_id=Create["channel_id"])
# check if already exists
res: list = cls.BASE.PhaazeDB.selectQuery(
"""
SELECT COUNT(*) AS `match`
FROM `discord_enabled_gamechannel`
WHERE `discord_enabled_gamechannel`.`guild_id` = %s
AND `discord_enabled_gamechannel`.`channel_id` = %s""",
(Create["guild_id"], Create["channel_id"]))
if res[0]["match"]:
return await cls.Tree.Api.Discord.Configs.Gameenabledchannels.errors.apiDiscordConfigsGameEnabledChannelExists(
cls,
WebRequest,
channel_id=Create["channel_id"],
channel_name=ActionChannel.name)
cls.BASE.PhaazeDB.insertQuery(table="discord_enabled_gamechannel",
content={
"guild_id": Create["guild_id"],
"channel_id": Create["channel_id"]
})
cls.BASE.Logger.debug(
f"(API/Discord) Game enabled channel: {Create['guild_id']=} added: {Create['channel_id']=}",
require="discord:configs")
return cls.response(text=json.dumps(
dict(msg="Game enabled channel: Added new entry",
entry=Create["channel_id"],
status=200)),
content_type="application/json",
status=200)
async def apiDiscordConfigsEdit(cls: "PhaazebotWeb",
WebRequest: ExtendedRequest) -> Response:
"""
Default url: /api/discord/configs/edit
"""
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
Edit: StorageTransformer = StorageTransformer()
Edit["guild_id"] = Data.getStr("guild_id", "", must_be_digit=True)
# checks
if not Edit["guild_id"]:
return await cls.Tree.Api.errors.apiMissingData(
cls, WebRequest, msg="missing or invalid 'guild_id'")
PhaazeDiscord: "PhaazebotDiscord" = cls.BASE.Discord
Guild: discord.Guild = discord.utils.get(PhaazeDiscord.guilds,
id=int(Edit["guild_id"]))
if not Guild:
return await cls.Tree.Api.Discord.errors.apiDiscordGuildUnknown(
cls, WebRequest)
# get user info
AuthDiscord: AuthDiscordWebUser = await authDiscordWebUser(cls, WebRequest)
if not AuthDiscord.found:
return await cls.Tree.Api.errors.apiMissingAuthorisation(
cls, WebRequest)
# get member
CheckMember: discord.Member = Guild.get_member(
int(AuthDiscord.User.user_id))
if not CheckMember:
return await cls.Tree.Api.Discord.errors.apiDiscordMemberNotFound(
cls,
WebRequest,
guild_id=Edit["guild_id"],
user_id=AuthDiscord.User.user_id)
# check permissions
# to edit configs, at least moderator rights are needed, (there can be options that require server only duh)
if not (CheckMember.guild_permissions.administrator
or CheckMember.guild_permissions.manage_guild):
return await cls.Tree.Api.Discord.errors.apiDiscordMissingPermission(
cls,
WebRequest,
guild_id=Edit["guild_id"],
user_id=AuthDiscord.User.user_id)
Configs: DiscordServerSettings = await getDiscordSeverSettings(
PhaazeDiscord, origin=Edit["guild_id"], prevent_new=True)
if not Configs:
return await cls.Tree.Api.Discord.errors.apiDiscordGuildUnknown(
cls, WebRequest, msg="Could not find configs for this guild")
# check all update values
update: dict = dict()
Edit["autorole_id"] = Data.getStr("autorole_id",
UNDEFINED,
len_max=128,
allow_none=True)
if Edit["autorole_id"] != UNDEFINED:
error: bool = False
if not Edit["autorole_id"]:
update["autorole_id"] = None
else:
Role: discord.Role = getDiscordRoleFromString(
PhaazeDiscord, Guild, Edit["autorole_id"])
if not Role:
error = True
elif Role >= Guild.me.top_role:
return await cls.Tree.Api.errors.apiWrongData(
cls, WebRequest, msg=f"The Role `{Role.name}` is to high")
else:
update["autorole_id"] = str(Role.id)
if error:
return await cls.Tree.Api.errors.apiWrongData(
cls,
WebRequest,
msg=
f"{Edit['autorole_id']} could not be resolved as a valid discord role"
)
# blacklist_ban_links
Edit["blacklist_ban_links"] = Data.getBool("blacklist_ban_links",
UNDEFINED)
if Edit["blacklist_ban_links"] != UNDEFINED:
update["blacklist_ban_links"] = Edit["blacklist_ban_links"]
# blacklist_punishment
Edit["blacklist_punishment"] = Data.getStr("blacklist_punishment",
UNDEFINED,
len_max=32)
if Edit["blacklist_punishment"] != UNDEFINED:
Edit["blacklist_punishment"] = checkPunishmentString(
Edit["blacklist_punishment"])
update["blacklist_punishment"] = Edit["blacklist_punishment"]
# currency_name
Edit["currency_name"] = Data.getStr("currency_name",
UNDEFINED,
len_max=256,
allow_none=True)
if Edit["currency_name"] != UNDEFINED:
if not Edit['currency_name']:
update["currency_name"] = None
else:
update["currency_name"] = Edit["currency_name"]
# currency_name_multi
Edit["currency_name_multi"] = Data.getStr("currency_name_multi",
UNDEFINED,
len_max=256,
allow_none=True)
if Edit["currency_name_multi"] != UNDEFINED:
if not Edit["currency_name_multi"]:
update["currency_name_multi"] = None
else:
update["currency_name_multi"] = Edit["currency_name_multi"]
# leave_chan
Edit["leave_chan"] = Data.getStr("leave_chan",
UNDEFINED,
len_max=128,
allow_none=True)
if Edit["leave_chan"] != UNDEFINED:
error: bool = False
if not Edit["leave_chan"]:
update["leave_chan"] = None
else:
Chan: discord.TextChannel = getDiscordChannelFromString(
PhaazeDiscord, Guild, Edit["leave_chan"], required_type="text")
if not Chan:
error = True
else:
update["leave_chan"] = str(Chan.id)
if error:
return await cls.Tree.Api.errors.apiWrongData(
cls,
WebRequest,
msg=
f"'{Edit['leave_chan']}' could not be resolved as a valid discord text channel"
)
# leave_msg
Edit["leave_msg"] = Data.getStr("leave_msg",
UNDEFINED,
len_max=1750,
allow_none=True)
if Edit["leave_msg"] != UNDEFINED:
if not Edit["leave_msg"]:
update["leave_msg"] = None
else:
update["leave_msg"] = Edit["leave_msg"]
# level_custom_msg
Edit["level_custom_msg"] = Data.getStr("level_custom_msg",
UNDEFINED,
len_max=1750,
allow_none=True)
if Edit["level_custom_msg"] != UNDEFINED:
if not Edit["level_custom_msg"]:
update["level_custom_msg"] = None
else:
update["level_custom_msg"] = Edit["level_custom_msg"]
# level_announce_chan
Edit["level_announce_chan"] = Data.getStr("level_announce_chan",
UNDEFINED,
len_max=128,
allow_none=True)
if Edit["level_announce_chan"] != UNDEFINED:
error: bool = False
if not Edit["level_announce_chan"]:
update["level_announce_chan"] = None
else:
Chan: discord.TextChannel = getDiscordChannelFromString(
PhaazeDiscord,
Guild,
Edit["level_announce_chan"],
required_type="text")
if not Chan:
error = True
else:
update["level_announce_chan"] = str(Chan.id)
if error:
return await cls.Tree.Api.errors.apiWrongData(
cls,
WebRequest,
msg=
f"'{Edit['level_announce_chan']}' could not be resolved as a valid discord text channel"
)
update["level_announce_chan"] = Edit["level_announce_chan"]
# owner_disable_level
Edit["owner_disable_level"] = Data.getBool("owner_disable_level",
UNDEFINED)
if Edit["owner_disable_level"] != UNDEFINED:
if not Guild.owner == CheckMember:
return await cls.Tree.Api.Discord.errors.apiDiscordMissingPermission(
cls,
WebRequest,
guild_id=Edit["guild_id"],
user_id=AuthDiscord.User.user_id,
msg="changing 'owner_disable_level' require server owner")
update["owner_disable_level"] = Edit["owner_disable_level"]
# owner_disable_normal
Edit["owner_disable_normal"] = Data.getBool("owner_disable_normal",
UNDEFINED)
if Edit["owner_disable_normal"] != UNDEFINED:
if not Guild.owner == CheckMember:
return await cls.Tree.Api.Discord.errors.apiDiscordMissingPermission(
cls,
WebRequest,
guild_id=Edit["guild_id"],
user_id=AuthDiscord.User.user_id,
msg="changing 'owner_disable_level' require server owner")
update["owner_disable_normal"] = Edit["owner_disable_normal"]
# owner_disable_regular
Edit["owner_disable_regular"] = Data.getBool("owner_disable_regular",
UNDEFINED)
if Edit["owner_disable_regular"] != UNDEFINED:
if not Guild.owner == CheckMember:
return await cls.Tree.Api.Discord.errors.apiDiscordMissingPermission(
cls,
WebRequest,
guild_id=Edit["guild_id"],
user_id=AuthDiscord.User.user_id,
msg="changing 'owner_disable_level' require server owner")
update["owner_disable_regular"] = Edit["owner_disable_regular"]
# owner_disable_mod
Edit["owner_disable_mod"] = Data.getBool("owner_disable_mod", UNDEFINED)
if Edit["owner_disable_mod"] != UNDEFINED:
if not Guild.owner == CheckMember:
return await cls.Tree.Api.Discord.errors.apiDiscordMissingPermission(
cls,
WebRequest,
guild_id=Edit["guild_id"],
user_id=AuthDiscord.User.user_id,
msg="changing 'owner_disable_level' require server owner")
update["owner_disable_mod"] = Edit["owner_disable_mod"]
# track_channel
Edit["track_channel"] = Data.getStr("track_channel",
UNDEFINED,
len_max=128,
allow_none=True)
if Edit["track_channel"] != UNDEFINED:
error: bool = False
if not Edit["track_channel"]:
update["track_channel"] = Edit["track_channel"]
else:
Chan: discord.TextChannel = getDiscordChannelFromString(
PhaazeDiscord,
Guild,
Edit["track_channel"],
required_type="text")
if not Chan:
error = True
else:
update["track_channel"] = str(Chan.id)
if error:
return await cls.Tree.Api.errors.apiWrongData(
cls,
WebRequest,
msg=
f"'{Edit['track_channel']}' could not be resolved as a valid discord text channel"
)
# track_value
Edit["track_value"] = Data.getInt("track_value", UNDEFINED, min_x=0)
if Edit["track_value"] != UNDEFINED:
update["track_value"] = Edit["track_value"]
# welcome_chan
Edit["welcome_chan"] = Data.getStr("welcome_chan",
UNDEFINED,
len_max=128,
allow_none=True)
if Edit["welcome_chan"] != UNDEFINED:
error: bool = False
if not Edit["welcome_chan"]:
update["welcome_chan"] = None
else:
Chan: discord.TextChannel = getDiscordChannelFromString(
PhaazeDiscord,
Guild,
Edit["welcome_chan"],
required_type="text")
if not Chan:
error = True
else:
update["welcome_chan"] = str(Chan.id)
if error:
return await cls.Tree.Api.errors.apiWrongData(
cls,
WebRequest,
msg=
f"'{Edit['welcome_chan']}' could not be resolved as a valid discord text channel"
)
# welcome_msg
Edit["welcome_msg"] = Data.getStr("welcome_msg",
UNDEFINED,
len_max=1750,
allow_none=True)
if Edit["welcome_msg"] != UNDEFINED:
if not Edit["welcome_msg"]:
update["welcome_msg"] = None
else:
update["welcome_msg"] = Edit["welcome_msg"]
# welcome_msg_priv
Edit["welcome_msg_priv"] = Data.getStr("welcome_msg_priv",
UNDEFINED,
len_max=1750,
allow_none=True)
if Edit["welcome_msg_priv"] != UNDEFINED:
if not Edit["welcome_msg_priv"]:
update["welcome_msg_priv"] = None
else:
update["welcome_msg_priv"] = Edit["welcome_msg_priv"]
if not update:
return await cls.Tree.Api.errors.apiMissingData(
cls, WebRequest, msg="No changes, please add at least one")
cls.BASE.PhaazeDB.updateQuery(table="discord_setting",
content=update,
where="`discord_setting`.`guild_id` = %s",
where_values=(Edit["guild_id"], ))
# logging
log_coro: Coroutine = loggingOnConfigEdit(PhaazeDiscord,
Configs,
Editor=CheckMember,
changes=update)
asyncio.ensure_future(log_coro, loop=cls.BASE.DiscordLoop)
cls.BASE.Logger.debug(
f"(API/Discord) Configs: {Edit['guild_id']=} updated",
require="discord:configs")
return cls.response(text=json.dumps(
dict(msg="Configs: Updated", changes=update, status=200)),
content_type="application/json",
status=200)
async def apiDiscordQuotesCreate(cls: "PhaazebotWeb",
WebRequest: ExtendedRequest) -> Response:
"""
Default url: /api/discord/quotes/create
"""
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
Create: StorageTransformer = StorageTransformer()
Create["guild_id"] = Data.getStr("guild_id", UNDEFINED, must_be_digit=True)
Create["content"] = Data.getStr("content",
UNDEFINED,
len_max=MAX_QUOTE_SIZE)
# checks
if not Create["guild_id"]:
return await apiMissingData(cls,
WebRequest,
msg="missing or invalid 'guild_id'")
if not Create["content"]:
return await apiMissingData(cls,
WebRequest,
msg="missing or invalid 'content'")
# get/check discord
PhaazeDiscord: "PhaazebotDiscord" = cls.BASE.Discord
Guild: discord.Guild = discord.utils.get(PhaazeDiscord.guilds,
id=int(Create["guild_id"]))
if not Guild:
return await cls.Tree.Api.Discord.errors.apiDiscordGuildUnknown(
cls, WebRequest)
# check limit
res: list = cls.BASE.PhaazeDB.selectQuery(
"""
SELECT COUNT(*) AS `I`
FROM `discord_quote`
WHERE `discord_quote`.`guild_id` = %s""", (Create["guild_id"], ))
if res[0]['I'] >= cls.BASE.Limit.discord_quotes_amount:
return await cls.Tree.Api.Discord.Quotes.errors.apiDiscordQuoteLimit(
cls, WebRequest)
# get user info
DiscordUser: AuthDiscordWebUser = await authDiscordWebUser(cls, WebRequest)
if not DiscordUser.found:
return await apiMissingAuthorisation(cls, WebRequest)
# get member
CheckMember: discord.Member = Guild.get_member(
int(DiscordUser.User.user_id))
if not CheckMember:
return await cls.Tree.Api.Discord.errors.apiDiscordMemberNotFound(
cls,
WebRequest,
guild_id=Create["guild_id"],
user_id=DiscordUser.User.user_id)
# check permissions
if not (CheckMember.guild_permissions.administrator
or CheckMember.guild_permissions.manage_guild):
return await cls.Tree.Api.Discord.errors.apiDiscordMissingPermission(
cls,
WebRequest,
guild_id=Create["guild_id"],
user_id=DiscordUser.User.user_id)
new_quote_id: int = cls.BASE.PhaazeDB.insertQuery(table="discord_quote",
content={
"guild_id":
Create["guild_id"],
"content":
Create["content"]
})
# logging
GuildSettings: DiscordServerSettings = await getDiscordSeverSettings(
PhaazeDiscord, Create["guild_id"], prevent_new=True)
log_coro: Coroutine = loggingOnQuoteCreate(PhaazeDiscord,
GuildSettings,
Creator=CheckMember,
quote_content=Create["content"],
quote_id=new_quote_id)
asyncio.ensure_future(log_coro, loop=cls.BASE.DiscordLoop)
cls.BASE.Logger.debug(
f"(API/Discord) Quote: {Create['guild_id']=} added new entry",
require="discord:quotes")
return cls.response(text=json.dumps(
dict(msg="Quote: Added new entry", entry=Create["content"],
status=200)),
content_type="application/json",
status=200)
async def apiDiscordLevelsGet(cls:"PhaazebotWeb", WebRequest:ExtendedRequest) -> Response:
"""
Default url: /api/discord/levels/get
"""
Data:WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
Search:StorageTransformer = StorageTransformer()
Search["guild_id"] = Data.getStr("guild_id", UNDEFINED, must_be_digit=True)
Search["member_id"] = Data.getStr("member_id", UNDEFINED, must_be_digit=True)
Search["detailed"] = Data.getBool("detailed", False) # with names, avatar hash etc.
Search["nickname"] = Data.getBool("nickname", False) # usernames or nicknames?
Search["name_contains"] = Data.getStr("name_contains", UNDEFINED)
Search["edited"] = Data.getInt("edited", UNDEFINED) # 0 = only non-edited, 1 = only edited
Search["order"] = Data.getStr("order", UNDEFINED)
Search["limit"] = Data.getInt("limit", DEFAULT_LIMIT, min_x=1, max_x=MAX_LIMIT)
Search["offset"] = Data.getInt("offset", 0, min_x=0)
Search.addProtected("detailed")
Search.addProtected("nickname")
# checks
if not Search["guild_id"]:
return await apiMissingData(cls, WebRequest, msg="missing or invalid 'guild_id'")
# format
if Search["order"] == "id":
Search["order_str"] = "ORDER BY `id`"
elif Search["order"] == "member_id":
Search["order_str"] = "ORDER BY `member_id`"
elif Search["order"] == "currency":
Search["order_str"] = "ORDER BY `currency` DESC"
else:
Search["order_str"] = "ORDER BY `exp` DESC"
PhaazeDiscord:"PhaazebotDiscord" = cls.BASE.Discord
Guild:discord.Guild = discord.utils.get(PhaazeDiscord.guilds, id=int(Search["guild_id"]))
if not Guild:
return await apiDiscordGuildUnknown(cls, WebRequest)
# get levels
res_levels:list = await getDiscordServerUsers(PhaazeDiscord, **Search.getAllTransform())
return_list:list = list()
for LevelUser in res_levels:
level_user:dict = LevelUser.toJSON()
if Search["detailed"]:
Mem:discord.Member = Guild.get_member(int(LevelUser.member_id))
level_user["avatar"] = Mem.avatar if Mem else None
level_user["level"] = LevelCalc.getLevel(LevelUser.exp)
if not Mem:
level_user["username"] = "******"
else:
if Search["nickname"] and Mem.nick:
level_user["username"] = Mem.nick
else:
level_user["username"] = Mem.name
return_list.append(level_user)
result:Dict[str, Any] = dict(
result=return_list,
total=await getDiscordServerUsers(PhaazeDiscord, count_mode=True, **Search.getAllTransform()),
limit=Search["limit"],
offset=Search["offset"],
detailed=Search["detailed"],
status=200
)
return cls.response(
text=json.dumps(result),
content_type="application/json",
status=200
)
async def apiAccountEditPhaaze(cls: "PhaazebotWeb",
WebRequest: ExtendedRequest) -> Response:
"""
Default url: /api/account/phaaze/edit
"""
WebAuth: AuthWebUser = await authWebUser(cls, WebRequest)
if not WebAuth.found:
return await cls.Tree.Api.errors.apiMissingAuthorisation(
cls, WebRequest)
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
Edit: StorageTransformer = StorageTransformer()
Edit["current_password"] = Data.getStr("password", UNDEFINED, len_max=256)
Edit["new_username"] = Data.getStr("username", UNDEFINED, len_max=64)
Edit["new_email"] = Data.getStr("email", UNDEFINED, len_max=128)
Edit["new_password"] = Data.getStr("newpassword", UNDEFINED, len_max=256)
Edit["new_password2"] = Data.getStr("newpassword2", UNDEFINED, len_max=256)
# checks
if not Edit[
"current_password"] or WebAuth.User.password != passwordFunction(
Edit["current_password"]):
return await cls.Tree.Api.Account.errors.apiAccountPasswordsDontMatch(
cls, WebRequest, msg="Current password is not correct")
changed_email: bool = False # if yes, reset validate and send mail
update: dict = dict()
# if new_password is set, check all and set to update
if Edit["new_password"]:
if Edit["new_password"] != Edit["new_password2"]:
return await cls.Tree.Api.Account.errors.apiAccountPasswordsDontMatch(
cls, WebRequest)
if len(Edit["new_password"]) < 8:
return await cls.Tree.Api.Account.errors.apiAccountPasswordToShort(
cls, WebRequest, min_length=8)
update["password"] = passwordFunction(Edit["new_password"])
if Edit["new_username"]:
# want a new username
if Edit["new_username"].lower() != WebAuth.User.username.lower():
is_occupied: list = await getWebUsers(
cls,
overwrite_where=" AND LOWER(`user`.`username`) = LOWER(%s)",
overwrite_where_values=(Edit["new_username"], ))
if is_occupied:
# already taken
return await cls.Tree.Api.Account.errors.apiAccountTaken(
cls, WebRequest)
else:
# username is free, add to update and add one to username_changed,
# maybe i do something later with it
update["username_changed"] = WebAuth.User.username_changed + 1
update["username"] = Edit["new_username"]
# else, it's a different capitation or so
elif Edit["new_username"] != WebAuth.User.username:
update["username"] = Edit["new_username"]
if Edit["new_email"] and Edit["new_email"].lower() != WebAuth.User.email:
if re.match(IsEmail, Edit["new_email"]) is None:
# does not look like a email
return await cls.Tree.Api.Account.errors.apiAccountEmailWrong(
cls, WebRequest, email=Edit["new_email"])
is_occupied: list = await getWebUsers(cls,
email_contains=Edit["new_email"])
if is_occupied:
# already taken
return await cls.Tree.Api.Account.errors.apiAccountTaken(
cls, WebRequest)
else:
changed_email = True
update["email"] = Edit["new_email"]
if not update:
return await cls.Tree.Api.errors.apiWrongData(
cls, WebRequest, msg=f"No changes, please add at least one")
# verification mail
if changed_email:
cls.BASE.Logger.warning(
f"(API) New Email, send new verification mail: {Edit['new_email']}"
)
# TODO: SEND MAIL
update["edited_at"] = str(datetime.datetime.now())
cls.BASE.PhaazeDB.updateQuery(table="user",
content=update,
where="`user`.`id` = %s",
where_values=(WebAuth.User.user_id, ))
cls.BASE.Logger.debug(
f"(API) Account edit ({WebAuth.User.user_id}) : {str(update)}",
require="api:account")
return cls.response(status=200,
text=json.dumps(
dict(error="successful_edited",
msg="Your account has been successful edited",
update=update,
status=200)),
content_type="application/json")
async def apiDiscordTwitchalertsCreate(
cls: "PhaazebotWeb", WebRequest: ExtendedRequest) -> Response:
"""
Default url: /api/discord/twitchalerts/create
"""
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
Create: StorageTransformer = StorageTransformer()
Create["guild_id"] = Data.getStr("guild_id", UNDEFINED, must_be_digit=True)
Create["discord_channel_id"] = Data.getStr("discord_channel_id",
UNDEFINED,
must_be_digit=True)
Create["twitch_channel"] = Data.getStr("twitch_channel", UNDEFINED)
Create["custom_msg"] = Data.getStr("custom_msg",
None,
len_max=MAX_CONTENT_SIZE,
allow_none=True)
Create["suppress_gamechange"] = Data.getBool("suppress_gamechange", False)
# checks
if not Create["guild_id"]:
return await cls.Tree.Api.errors.apiMissingData(
cls, WebRequest, msg="missing or invalid 'guild_id'")
if not Create["discord_channel_id"]:
return await cls.Tree.Api.errors.apiMissingData(
cls, WebRequest, msg="missing or invalid 'discord_channel_id'")
if not Create["twitch_channel"]:
return await cls.Tree.Api.errors.apiMissingData(
cls, WebRequest, msg="missing or invalid 'twitch_channel'")
# get/check discord
PhaazeDiscord: "PhaazebotDiscord" = cls.BASE.Discord
Guild: discord.Guild = discord.utils.get(PhaazeDiscord.guilds,
id=int(Create["guild_id"]))
if not Guild:
return await cls.Tree.Api.Discord.errors.apiDiscordGuildUnknown(
cls, WebRequest)
TargetDiscordChannel: discord.TextChannel = getDiscordChannelFromString(
PhaazeDiscord,
Guild,
Create["discord_channel_id"],
required_type="text")
if not TargetDiscordChannel:
return await cls.Tree.Api.Discord.errors.apiDiscordChannelNotFound(
cls, WebRequest, msg=f"Could not find a valid text channel")
Match: re.Match = TwitchRe().ChannelLink.match(Create["twitch_channel"])
if Match:
Create["twitch_channel"] = Match.group("name")
user_res: list = await getTwitchUsers(cls.BASE,
item=Create["twitch_channel"],
item_type="login")
if not user_res:
return await cls.Tree.Api.Twitch.errors.apiTwitchUserNotFound(
cls, WebRequest, user_name=Create["twitch_channel"])
FoundUser: TwitchUser = user_res.pop(0)
# check if already exists and limits
res: list = cls.BASE.PhaazeDB.selectQuery(
"""
SELECT
COUNT(*) AS `all`,
SUM(
CASE WHEN `discord_twitch_alert`.`twitch_channel_id` = %(twitch_channel_id)s
THEN 1 ELSE 0 END
) AS `twitch_channel_match`,
SUM(
CASE WHEN `discord_twitch_alert`.`discord_channel_id` = %(discord_channel_id)s
THEN 1 ELSE 0 END
) AS `discord_channel_match`,
SUM(
CASE WHEN `discord_twitch_alert`.`discord_channel_id` = %(discord_channel_id)s
AND `discord_twitch_alert`.`twitch_channel_id` = %(twitch_channel_id)s
THEN 1 ELSE 0 END
) AS `both_match`
FROM `discord_twitch_alert`
WHERE `discord_twitch_alert`.`discord_guild_id` = %(discord_guild_id)s""",
dict(discord_guild_id=Create["guild_id"],
discord_channel_id=str(TargetDiscordChannel.id),
twitch_channel_id=FoundUser.user_id))
if res[0]["all"] == 0:
res[0]["twitch_channel_match"] = 0
res[0]["discord_channel_match"] = 0
res[0]["both_match"] = 0
if res[0]["twitch_channel_match"] >= MAX_SAME_TWITCH_ALERTS_PER_GUILD:
return await cls.Tree.Api.Discord.Twitchalerts.errors.apiDiscordAlertSameTwitchChannelLimit(
cls,
WebRequest,
limit=MAX_SAME_TWITCH_ALERTS_PER_GUILD,
twitch_name=FoundUser.display_name)
if res[0]["discord_channel_match"] >= 1:
# nothing... for now
pass
if res[0]["both_match"] >= 1:
return await cls.Tree.Api.Discord.Twitchalerts.errors.apiDiscordAlertExists(
cls,
WebRequest,
twitch_name=FoundUser.login,
discord_id=TargetDiscordChannel.id)
# get user info
AuthDiscord: AuthDiscordWebUser = await authDiscordWebUser(cls, WebRequest)
if not AuthDiscord.found:
return await cls.Tree.Api.errors.apiMissingAuthorisation(
cls, WebRequest)
# get member
CheckMember: discord.Member = Guild.get_member(
int(AuthDiscord.User.user_id))
if not CheckMember:
return await cls.Tree.Api.Discord.errors.apiDiscordMemberNotFound(
cls,
WebRequest,
guild_id=Create["guild_id"],
user_id=AuthDiscord.User.user_id)
# check permissions
if not (CheckMember.guild_permissions.administrator
or CheckMember.guild_permissions.manage_guild):
return await cls.Tree.Api.Discord.errors.apiDiscordMissingPermission(
cls,
WebRequest,
guild_id=Create["guild_id"],
user_id=AuthDiscord.User.user_id)
cls.BASE.PhaazeDB.insertQuery(table="discord_twitch_alert",
content={
"discord_guild_id":
Create["guild_id"],
"discord_channel_id":
str(TargetDiscordChannel.id),
"twitch_channel_id":
FoundUser.user_id,
"custom_msg":
Create["custom_msg"],
"suppress_gamechange":
Create["suppress_gamechange"]
})
# logging
GuildSettings: DiscordServerSettings = await getDiscordSeverSettings(
PhaazeDiscord, Create["guild_id"], prevent_new=True)
log_coro: Coroutine = loggingOnTwitchalertCreate(
PhaazeDiscord,
GuildSettings,
Creator=CheckMember,
discord_channel=TargetDiscordChannel.name,
twitch_channel=FoundUser.login)
asyncio.ensure_future(log_coro, loop=cls.BASE.DiscordLoop)
# some after work, with the new data
await placeGatheredData(cls, FoundUser)
cls.BASE.Logger.debug(
f"(API/Discord) Twitchalert: {Create['guild_id']=} added {FoundUser.user_id=}",
require="discord:alert")
return cls.response(text=json.dumps(
dict(msg="Twitchalert: Added new entry",
entry=FoundUser.user_type,
status=200)),
content_type="application/json",
status=200)
async def apiDiscordCommandsCreate(cls: "PhaazebotWeb",
WebRequest: ExtendedRequest) -> Response:
"""
Default url: /api/discord/commands/create
"""
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
Create: StorageTransformer = StorageTransformer()
Create["guild_id"] = Data.getStr("guild_id", "", must_be_digit=True)
Create["trigger"] = Data.getStr("trigger", "").lower().split(" ")[0]
Create["active"] = Data.getBool("active", True)
Create["complex"] = Data.getBool("complex", False)
Create["function"] = Data.getStr("function", "", len_max=256)
Create["content"] = Data.getStr("content", "", len_max=1750)
Create["hidden"] = Data.getBool("hidden", False)
Create["cooldown"] = Data.getInt(
"cooldown", cls.BASE.Limit.discord_commands_cooldown_min)
Create["require"] = Data.getInt("require", 0, min_x=0)
Create["required_currency"] = Data.getInt("required_currency", 0, min_x=0)
# checks
if not Create["guild_id"]:
return await cls.Tree.Api.errors.apiMissingData(
cls, WebRequest, msg="missing or invalid 'guild_id'")
if not Create["trigger"]:
return await cls.Tree.Api.errors.apiMissingData(
cls, WebRequest, msg="missing 'trigger'")
if not (cls.BASE.Limit.discord_commands_cooldown_min <= Create["cooldown"]
<= cls.BASE.Limit.discord_commands_cooldown_max):
return await cls.Tree.Api.errors.apiWrongData(
cls, WebRequest, msg="'cooldown' is wrong")
PhaazeDiscord: "PhaazebotDiscord" = cls.BASE.Discord
Guild: discord.Guild = discord.utils.get(PhaazeDiscord.guilds,
id=int(Create["guild_id"]))
if not Guild:
return await cls.Tree.Api.Discord.errors.apiDiscordGuildUnknown(
cls, WebRequest)
# if not complex
# check if the function actually exists
if not Create["complex"]:
if not Create["function"]:
return await cls.Tree.Api.errors.apiMissingData(
cls, WebRequest, msg="missing 'function'")
if Create["function"] not in [
cmd["function"].__name__ for cmd in command_register
]:
return await cls.Tree.Api.errors.apiWrongData(
cls,
WebRequest,
msg=
f"'{Create['function']}' is not a valid value for field 'function'"
)
# check if already exists and limits
res: list = cls.BASE.PhaazeDB.selectQuery(
"""
SELECT
COUNT(*) AS `all`,
SUM(
CASE WHEN LOWER(`discord_command`.`trigger`) = LOWER(%s)
THEN 1 ELSE 0 END
) AS `match`
FROM `discord_command`
WHERE `discord_command`.`guild_id` = %s""",
(Create["trigger"], Create["guild_id"]))
if res[0]["match"]:
return await cls.Tree.Api.Discord.Commands.errors.apiDiscordCommandExists(
cls, WebRequest, trigger=Create["trigger"])
if res[0]["all"] >= cls.BASE.Limit.discord_commands_amount:
return await cls.Tree.Api.Discord.Commands.errors.apiDiscordCommandLimit(
cls, WebRequest, limit=cls.BASE.Limit.discord_commands_amount)
# get user info
AuthDiscord: AuthDiscordWebUser = await authDiscordWebUser(cls, WebRequest)
if not AuthDiscord.found:
return await cls.Tree.Api.errors.apiMissingAuthorisation(
cls, WebRequest)
# get member
CheckMember: discord.Member = Guild.get_member(
int(AuthDiscord.User.user_id))
if not CheckMember:
return await cls.Tree.Api.Discord.errors.apiDiscordMemberNotFound(
cls,
WebRequest,
guild_id=Create["guild_id"],
user_id=AuthDiscord.User.user_id)
# check permissions
if not (CheckMember.guild_permissions.administrator
or CheckMember.guild_permissions.manage_guild):
return await cls.Tree.Api.Discord.errors.apiDiscordMissingPermission(
cls,
WebRequest,
guild_id=Create["guild_id"],
user_id=AuthDiscord.User.user_id)
cls.BASE.PhaazeDB.insertQuery(table="discord_command",
content=Create.getAllTransform())
# logging prep
log_dict: dict = Create.getAllTransform()
# logging
GuildSettings: DiscordServerSettings = await getDiscordSeverSettings(
PhaazeDiscord, Create["guild_id"], prevent_new=True)
log_coro: Coroutine = loggingOnCommandCreate(
PhaazeDiscord,
GuildSettings,
Creator=CheckMember,
command_trigger=Create["trigger"],
command_info=log_dict)
asyncio.ensure_future(log_coro, loop=cls.BASE.DiscordLoop)
cls.BASE.Logger.debug(
f"(API/Discord) Commands: {Create['guild_id']=} added: {Create['trigger']=}",
require="discord:commands")
return cls.response(text=json.dumps(
dict(msg="Commands: Added new entry",
entry=Create["trigger"],
status=200)),
content_type="application/json",
status=200)
async def apiDiscordQuotesEdit(cls: "PhaazebotWeb",
WebRequest: ExtendedRequest) -> Response:
"""
Default url: /api/discord/quotes/edit
"""
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
Edit: StorageTransformer = StorageTransformer()
Edit["quote_id"] = Data.getStr("quote_id", UNDEFINED, must_be_digit=True)
Edit["guild_id"] = Data.getStr("guild_id", UNDEFINED, must_be_digit=True)
# checks
if not Edit["quote_id"]:
return await cls.Tree.Api.errors.apiMissingData(
cls, WebRequest, msg="missing or invalid 'quote_id'")
if not Edit["guild_id"]:
return await cls.Tree.Api.errors.apiMissingData(
cls, WebRequest, msg="missing or invalid 'guild_id'")
PhaazeDiscord: "PhaazebotDiscord" = cls.BASE.Discord
Guild: discord.Guild = discord.utils.get(PhaazeDiscord.guilds,
id=int(Edit["guild_id"]))
if not Guild:
return await cls.Tree.Api.Discord.errors.apiDiscordGuildUnknown(
cls, WebRequest)
# check if exists
res_quotes: list = await getDiscordServerQuotes(cls.BASE.Discord,
guild_id=Edit["guild_id"],
quote_id=Edit["quote_id"])
if not res_quotes:
return await cls.Tree.Api.Discord.Quotes.errors.apiDiscordQuotesNotExists(
cls, WebRequest, quote_id=Edit["quote_id"])
QuoteToEdit: DiscordQuote = res_quotes.pop(0)
# check all update values
update: dict = dict()
Edit["content"] = Data.getStr("content", UNDEFINED, len_max=MAX_QUOTE_SIZE)
if Edit["content"] != UNDEFINED:
update["content"] = Edit["content"]
# get user info
AuthDiscord: AuthDiscordWebUser = await authDiscordWebUser(cls, WebRequest)
if not AuthDiscord.found:
return await cls.Tree.Api.errors.apiMissingAuthorisation(
cls, WebRequest)
# get member
CheckMember: discord.Member = Guild.get_member(
int(AuthDiscord.User.user_id))
if not CheckMember:
return await cls.Tree.Api.Discord.errors.apiDiscordMemberNotFound(
cls,
WebRequest,
guild_id=Edit["guild_id"],
user_id=AuthDiscord.User.user_id)
# check permissions
if not (CheckMember.guild_permissions.administrator
or CheckMember.guild_permissions.manage_guild):
return await cls.Tree.Api.Discord.errors.apiDiscordMissingPermission(
cls,
WebRequest,
guild_id=Edit["guild_id"],
user_id=AuthDiscord.User.user_id)
cls.BASE.PhaazeDB.updateQuery(
table="discord_quote",
content=update,
where="`discord_quote`.`guild_id` = %s AND `discord_quote`.`id` = %s",
where_values=(QuoteToEdit.guild_id, QuoteToEdit.quote_id))
# logging
GuildSettings: DiscordServerSettings = await getDiscordSeverSettings(
PhaazeDiscord, Edit["guild_id"], prevent_new=True)
log_coro: Coroutine = loggingOnQuoteEdit(PhaazeDiscord,
GuildSettings,
ChangeMember=CheckMember,
quote_id=QuoteToEdit.quote_id,
old_content=QuoteToEdit.content,
new_content=Edit["content"])
asyncio.ensure_future(log_coro, loop=cls.BASE.DiscordLoop)
cls.BASE.Logger.debug(
f"(API/Discord) Quote: {Edit['guild_id']=} edited {Edit['quote_id']=}",
require="discord:quotes")
return cls.response(text=json.dumps(
dict(msg="Quote: Edited entry", changes=update, status=200)),
content_type="application/json",
status=200)
async def apiDiscordConfigsWhitelistedLinkCreate(
cls: "PhaazebotWeb", WebRequest: ExtendedRequest) -> Response:
"""
Default url: /api/discord/configs/whitelistedlinks/create
"""
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
Create: StorageTransformer = StorageTransformer()
Create["guild_id"] = Data.getStr("guild_id", UNDEFINED, must_be_digit=True)
Create["link"] = Data.getStr("link", UNDEFINED, len_min=1, len_max=512)
# checks
if not Create["guild_id"]:
return await cls.Tree.Api.errors.apiMissingData(
cls, WebRequest, msg="missing or invalid 'guild_id'")
if not Create["link"]:
return await cls.Tree.Api.errors.apiMissingData(
cls, WebRequest, msg="missing or invalid 'link'")
PhaazeDiscord: "PhaazebotDiscord" = cls.BASE.Discord
Guild: discord.Guild = discord.utils.get(PhaazeDiscord.guilds,
id=int(Create["guild_id"]))
if not Guild:
return await cls.Tree.Api.Discord.errors.apiDiscordGuildUnknown(
cls, WebRequest)
# get user info
AuthDiscord: AuthDiscordWebUser = await authDiscordWebUser(cls, WebRequest)
if not AuthDiscord.found:
return await cls.Tree.Api.errors.apiMissingAuthorisation(
cls, WebRequest)
# get member
CheckMember: discord.Member = Guild.get_member(
int(AuthDiscord.User.user_id))
if not CheckMember:
return await cls.Tree.Api.Discord.errors.apiDiscordMemberNotFound(
cls,
WebRequest,
guild_id=Create["guild_id"],
user_id=AuthDiscord.User.user_id)
# check permissions
if not (CheckMember.guild_permissions.administrator
or CheckMember.guild_permissions.manage_guild):
return await cls.Tree.Api.Discord.errors.apiDiscordMissingPermission(
cls,
WebRequest,
guild_id=Create["guild_id"],
user_id=AuthDiscord.User.user_id)
# check if already exists
res: list = cls.BASE.PhaazeDB.selectQuery(
"""
SELECT COUNT(*) AS `match`
FROM `discord_blacklist_whitelistlink`
WHERE `discord_blacklist_whitelistlink`.`guild_id` = %s
AND `discord_blacklist_whitelistlink`.`link` = %s""",
(Create["guild_id"], Create["link"]))
if res[0]["match"]:
return await cls.Tree.Api.Discord.Configs.Whitelistedlinks.errors.apiDiscordWhitelistedLinkExists(
cls, WebRequest, link=Create["link"])
cls.BASE.PhaazeDB.insertQuery(table="discord_blacklist_whitelistlink",
content={
"guild_id": Create["guild_id"],
"link": Create["link"]
})
cls.BASE.Logger.debug(
f"(API/Discord) Linkwhitelist: {Create['guild_id']=} added: {Create['link']=}",
require="discord:configs")
return cls.response(text=json.dumps(
dict(msg="Linkwhitelist: Added new entry",
entry=Create["link"],
status=200)),
content_type="application/json",
status=200)
async def apiDiscordRegularsGet(cls: "PhaazebotWeb",
WebRequest: ExtendedRequest) -> Response:
"""
Default url: /api/discord/regulars/get
"""
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
Search: StorageTransformer = StorageTransformer()
Search["guild_id"] = Data.getStr("guild_id", UNDEFINED, must_be_digit=True)
Search["regular_id"] = Data.getStr("regular_id",
UNDEFINED,
must_be_digit=True)
Search["member_id"] = Data.getStr("member_id",
UNDEFINED,
must_be_digit=True)
Search["nickname"] = Data.getBool("nickname",
False) # usernames or nicknames?
Search["detailed"] = Data.getBool("detailed",
False) # with names, avatar hash etc.
Search["limit"] = Data.getInt("limit",
DEFAULT_LIMIT,
min_x=1,
max_x=MAX_LIMIT)
Search["offset"] = Data.getInt("offset", 0, min_x=0)
# checks
if not Search["guild_id"]:
return await apiMissingData(cls,
WebRequest,
msg="missing or invalid 'guild_id'")
PhaazeDiscord: "PhaazebotDiscord" = cls.BASE.Discord
Guild: discord.Guild = discord.utils.get(PhaazeDiscord.guilds,
id=int(Search["guild_id"]))
if not Guild:
return await apiDiscordGuildUnknown(cls, WebRequest)
# get regulars
res_regulars: List[DiscordRegular] = await getDiscordServerRegulars(
PhaazeDiscord, **Search.getAllTransform())
return_list: List[dict] = []
for Regular in res_regulars:
reg: dict = Regular.toJSON()
if Search["detailed"]:
Mem: discord.Member = Guild.get_member(int(Regular.member_id))
reg["avatar"] = Mem.avatar if Mem else None
if not Mem:
reg["username"] = "******"
else:
if Search["nickname"] and Mem.nick:
reg["username"] = Mem.nick
else:
reg["username"] = Mem.name
return_list.append(reg)
result: Dict[str, Any] = dict(result=return_list,
detailed=Search["detailed"],
total=await getDiscordServerRegulars(
PhaazeDiscord,
count_mode=True,
**Search.getAllTransform()),
limit=Search["limit"],
offset=Search["offset"],
status=200)
return cls.response(text=json.dumps(result),
content_type="application/json",
status=200)
async def apiDiscordLevelsMedalsCreate(
cls: "PhaazebotWeb", WebRequest: ExtendedRequest) -> Response:
"""
Default url: /api/discord/levels/medals/create
"""
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
Create: StorageTransformer = StorageTransformer()
Create["guild_id"] = Data.getStr("guild_id", UNDEFINED, must_be_digit=True)
Create["member_id"] = Data.getStr("member_id",
UNDEFINED,
must_be_digit=True)
Create["name"] = Data.getStr("name", "", len_max=512)
# checks
if not Create["guild_id"]:
return await cls.Tree.Api.errors.apiMissingData(
cls, WebRequest, msg="missing or invalid 'guild_id'")
if not Create["member_id"]:
return await cls.Tree.Api.errors.apiMissingData(
cls, WebRequest, msg="missing or invalid 'member_id'")
if not Create["name"]:
return await cls.Tree.Api.errors.apiMissingData(
cls, WebRequest, msg="missing or invalid 'name'")
# get/check discord
PhaazeDiscord: "PhaazebotDiscord" = cls.BASE.Discord
Guild: discord.Guild = discord.utils.get(PhaazeDiscord.guilds,
id=int(Create["guild_id"]))
if not Guild:
return await cls.Tree.Api.Discord.errors.apiDiscordGuildUnknown(
cls, WebRequest)
# check limit
res: list = cls.BASE.PhaazeDB.selectQuery(
"""
SELECT
COUNT(*) AS `all`,
SUM(
CASE WHEN LOWER(`discord_user_medal`.`name`) = LOWER(%s)
THEN 1 ELSE 0 END
) AS `match`
FROM `discord_user_medal`
WHERE `discord_user_medal`.`guild_id` = %s
AND `discord_user_medal`.`member_id` = %s""",
(Create["name"], Create["guild_id"], Create["member_id"]))
if res[0]['match']:
return await cls.Tree.Api.Discord.Levels.Medals.errors.apiDiscordUserMedalExists(
cls, WebRequest)
if res[0]['all'] >= cls.BASE.Limit.discord_level_medal_amount:
return await cls.Tree.Api.Discord.Levels.Medals.errors.apiDiscordUserMedalLimit(
cls, WebRequest)
# get user info
AuthDiscord: AuthDiscordWebUser = await authDiscordWebUser(cls, WebRequest)
if not AuthDiscord.found:
return await cls.Tree.Api.errors.apiMissingAuthorisation(
cls, WebRequest)
# get member
CheckMember: discord.Member = Guild.get_member(
int(AuthDiscord.User.user_id))
if not CheckMember:
return await cls.Tree.Api.Discord.errors.apiDiscordMemberNotFound(
cls,
WebRequest,
guild_id=Create["guild_id"],
user_id=AuthDiscord.User.user_id)
# check permissions
if not (CheckMember.guild_permissions.administrator
or CheckMember.guild_permissions.manage_guild):
return await cls.Tree.Api.Discord.errors.apiDiscordMissingPermission(
cls,
WebRequest,
guild_id=Create["guild_id"],
user_id=AuthDiscord.User.user_id)
cls.BASE.PhaazeDB.insertQuery(table="discord_user_medal",
content={
"guild_id": Create["guild_id"],
"member_id": Create["member_id"],
"name": Create["name"]
})
# logging
GuildSettings: DiscordServerSettings = await getDiscordSeverSettings(
PhaazeDiscord, Create["guild_id"], prevent_new=True)
log_coro: Coroutine = loggingOnLevelmedalCreate(
PhaazeDiscord,
GuildSettings,
Creator=CheckMember,
medal_member_id=Create["member_id"],
medal_name=Create["name"])
asyncio.ensure_future(log_coro, loop=cls.BASE.DiscordLoop)
cls.BASE.Logger.debug(
f"(API/Discord) User medal: {Create['guild_id']=} {Create['member_id']=} added new entry",
require="discord:medals")
return cls.response(text=json.dumps(
dict(msg="Medal: Added new entry", entry=Create["name"], status=200)),
content_type="application/json",
status=200)
async def apiDiscordLevelsEdit(cls: "PhaazebotWeb",
WebRequest: ExtendedRequest) -> Response:
"""
Default url: /api/discord/levels/edit
"""
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
Edit: StorageTransformer = StorageTransformer()
Edit["guild_id"] = Data.getStr("guild_id", "", must_be_digit=True)
Edit["member_id"] = Data.getStr("member_id", "", must_be_digit=True)
# checks
if not Edit["guild_id"]:
return await cls.Tree.Api.errors.apiMissingData(
cls, WebRequest, msg="missing or invalid 'guild_id'")
if not Edit["member_id"]:
return await cls.Tree.Api.errors.apiMissingData(
cls, WebRequest, msg="missing or invalid 'member_id'")
PhaazeDiscord: "PhaazebotDiscord" = cls.BASE.Discord
Guild: discord.Guild = discord.utils.get(PhaazeDiscord.guilds,
id=int(Edit["guild_id"]))
if not Guild:
return await cls.Tree.Api.Discord.errors.apiDiscordGuildUnknown(
cls, WebRequest)
# get user info
AuthDiscord: AuthDiscordWebUser = await authDiscordWebUser(cls, WebRequest)
if not AuthDiscord.found:
return await cls.Tree.Api.Discord.errors.apiMissingAuthorisation(
cls, WebRequest)
# get member
CheckMember: discord.Member = Guild.get_member(
int(AuthDiscord.User.user_id))
if not CheckMember:
return await cls.Tree.Api.Discord.errors.apiDiscordMemberNotFound(
cls,
WebRequest,
guild_id=Edit["guild_id"],
user_id=AuthDiscord.User.user_id)
# check permissions
# to edit configs, at least moderator rights are needed, (there can be options that require server only duh)
if not (CheckMember.guild_permissions.administrator
or CheckMember.guild_permissions.manage_guild):
return await cls.Tree.Api.Discord.errors.apiDiscordMissingPermission(
cls,
WebRequest,
guild_id=Edit["guild_id"],
user_id=AuthDiscord.User.user_id)
# get level user
res_level: list = await getDiscordServerUsers(PhaazeDiscord,
guild_id=Edit["guild_id"],
member_id=Edit["member_id"])
if not res_level:
return await cls.Tree.Api.Discord.errors.apiDiscordGuildUnknown(
cls, WebRequest, msg="Could not find a level for this user")
CurrentLevelUser: DiscordUserStats = res_level.pop(0)
# check all update values
update: dict = dict()
# currency
Edit["currency"] = Data.getInt("currency", UNDEFINED, min_x=0)
if Edit["currency"] != UNDEFINED:
update["currency"] = Edit["currency"]
# exp
Edit["exp"] = Data.getInt("exp", UNDEFINED, min_x=0)
if Edit["exp"] != UNDEFINED:
update["exp"] = Edit["exp"]
if Edit["exp"] != 0:
update["edited"] = 1
else:
update["edited"] = 0
# on_server
Edit["on_server"] = Data.getBool("on_server", UNDEFINED)
if Edit["on_server"] != UNDEFINED:
if not Guild.owner == CheckMember:
return await cls.Tree.Api.Discord.errors.apiDiscordMissingPermission(
cls,
WebRequest,
guild_id=Edit["guild_id"],
user_id=AuthDiscord.User.user_id,
msg="changing 'on_server' require server owner")
update["on_server"] = Edit["on_server"]
if not update:
return await cls.Tree.Api.errors.apiMissingData(
cls, WebRequest, msg="No changes, please add at least one")
cls.BASE.PhaazeDB.updateQuery(
table="discord_user",
content=update,
where=
"`discord_user`.`guild_id` = %s AND `discord_user`.`member_id` = %s",
where_values=(CurrentLevelUser.guild_id, CurrentLevelUser.member_id))
# logging
GuildSettings: DiscordServerSettings = await getDiscordSeverSettings(
PhaazeDiscord, Edit["guild_id"], prevent_new=True)
log_coro: Coroutine = loggingOnLevelEdit(
PhaazeDiscord,
GuildSettings,
Editor=CheckMember,
changed_member_id=CurrentLevelUser.member_id,
changes=update)
asyncio.ensure_future(log_coro, loop=cls.BASE.DiscordLoop)
cls.BASE.Logger.debug(
f"(API/Discord) Level: {Edit['guild_id']=} {Edit['member_id']=} updated",
require="discord:levels")
return cls.response(text=json.dumps(
dict(msg="Level: Updated", changes=update, status=200)),
content_type="application/json",
status=200)
