async def apiDiscordCommandsList(cls: "WebIndex",
WebRequest: Request) -> Response:
"""
Default url: /api/discord/commands/list
"""
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
function: str = Data.getStr("function", "")
command_list: list = []
for cmd in sorted(command_register, key=lambda c: c["name"]):
# user only wantes a specific command/function to be returned (could result in none)
if function:
if cmd["function"].__name__ != function: continue
c: dict = dict(name=cmd["name"],
description=cmd["description"],
function=cmd["function"].__name__,
details=cmd["details"],
need_content=cmd["need_content"])
command_list.append(c)
return cls.response(text=json.dumps(dict(result=command_list, status=200)),
content_type="application/json",
status=200)
async def apiAdminModule(cls: "WebIndex", WebRequest: Request) -> Response:
"""
Default url: /api/admin/module
"""
WebUser: WebUserInfo = await cls.getWebUserInfo(WebRequest)
if not WebUser.checkRoles(["admin", "superadmin"]):
return await apiNotAllowed(cls,
WebRequest,
msg="Admin rights required")
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
module: str = Data.getStr("module", "x")
state: bool = Data.getBool("state", False)
if not hasattr(cls.Web.BASE.Active, module):
return await apiMissingValidMethod(
cls, WebRequest, msg=f"module '{module}' not avariable")
setattr(cls.Web.BASE.Active, module, state)
cls.Web.BASE.Logger.warning(
f"Module change state: '{module}' now '{state}'")
# handle state 'False', which means shutdown the module
if not state:
shutdownModule(cls.Web.BASE, module)
return cls.response(body=json.dumps(
dict(msg=f"state for module: '{module}' is now: {str(state)}",
status=200)),
status=200,
content_type='application/json')
async def apiAdminRolesDelete(cls:"PhaazebotWeb", WebRequest:ExtendedRequest) -> Response:
Data:WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
role_id:int = Data.getInt("role_id", UNDEFINED, min_x=1)
# checks
if role_id == UNDEFINED:
return await cls.Tree.Api.errors.apiMissingData(cls, WebRequest, msg="missing or invalid 'role_id'")
res:List[WebRole] = await getWebRoles(cls, role_id=role_id)
if not res:
return await cls.Tree.Api.errors.apiWrongData(cls, WebRequest, msg=f"could not find role")
RoleToDelete:WebRole = res.pop(0)
if not RoleToDelete.can_be_removed:
return await cls.Tree.Api.errors.apiWrongData(cls, WebRequest, msg=f"'{RoleToDelete.name}' cannot be removed")
cls.BASE.PhaazeDB.deleteQuery(
"DELETE FROM `web_role` WHERE `web_role`.`id` = %s",
(RoleToDelete.role_id,)
)
return cls.response(
text=json.dumps(dict(msg="role successful deleted", role=RoleToDelete.name, status=200)),
content_type="application/json",
status=200
)
async def apiDiscordSearch(cls: "PhaazebotWeb",
WebRequest: ExtendedRequest) -> Response:
"""
Default url: /api/twitch/search
"""
PhaazeTwitch: "PhaazebotTwitch" = cls.BASE.Twitch
if not PhaazeTwitch:
return await cls.Tree.errors.notAllowed(
cls, WebRequest, msg="Twitch module is not active")
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
search: str = Data.getStr("search", "", len_max=128)
term: str = Data.getStr("term", "", len_max=512)
if search not in SEARCH_OPTIONS:
return await apiMissingData(
cls,
WebRequest,
msg="missing or invalid 'search', allowed: " +
", ".join(SEARCH_OPTIONS))
if not term:
return await apiMissingData(cls,
WebRequest,
msg="invalid or missing 'term'")
if search == "channel":
return await searchChannel(cls, WebRequest, Data)
if search == "user":
return await searchUser(cls, WebRequest, Data)
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 apiAdminEvaluate(cls:"WebIndex", WebRequest:Request) -> Response:
"""
Default url: /api/admin/evaluate
"""
WebUser:WebUserInfo = await cls.getWebUserInfo(WebRequest)
if not WebUser.checkRoles(["superadmin"]): return await apiNotAllowed(cls, WebRequest, msg="Superadmin rights required")
Data:WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
command:str = Data.getStr("command", "")
corotine:bool = Data.getBool("corotine", False)
# this is for easyer access
locals()["BASE"] = cls.Web.BASE
locals()["SUPERBASE"] = GlobalStorage
try:
res:Any = eval(command)
if corotine: res = await res
except Exception as Fail:
res:Any = Fail
result = str(res)
return cls.response(
body=json.dumps(dict(result=result, status="200")),
status=200,
content_type='application/json'
)
async def apiDiscordAssignrolesGet(cls:"WebIndex", WebRequest:Request) -> Response:
"""
Default url: /api/discord/assignroles/get
"""
Data:WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
guild_id:str = Data.getStr("guild_id", "", must_be_digit=True)
role_id:int = Data.getInt("role_id", UNDEFINED, min_x=1)
assignrole_id:int = Data.getInt("assignrole_id", UNDEFINED, min_x=1)
limit:int = Data.getInt("limit", DEFAULT_LIMIT, min_x=1, max_x=MAX_LIMIT)
offset:int = Data.getInt("offset", 0, min_x=0)
# checks
if not guild_id:
return await apiMissingData(cls, WebRequest, msg="missing or invalid 'guild_id'")
PhaazeDiscord:"PhaazebotDiscord" = cls.Web.BASE.Discord
Guild:discord.Guild = discord.utils.get(PhaazeDiscord.guilds, id=int(guild_id))
if not Guild:
return await apiDiscordGuildUnknown(cls, WebRequest)
assignroles:list = await getDiscordServerAssignRoles(PhaazeDiscord, guild_id=guild_id, role_id=role_id, assignrole_id=assignrole_id, limit=limit, offset=offset)
return cls.response(
text=json.dumps( dict(
result=[ ARole.toJSON() for ARole in assignroles ],
status=200)
),
content_type="application/json",
status=200
)
async def apiAdminRolesGet(cls: "WebIndex", WebRequest: Request) -> Response:
"""
Default url: /api/admin/roles/get
"""
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
role_id: int = Data.getInt("role_id", UNDEFINED, min_x=1)
sql: str = "SELECT * FROM `role`"
values: tuple = ()
# only show one?
if role_id:
sql += " WHERE `role`.`id` = %s"
values += (role_id, )
res: list = cls.Web.BASE.PhaazeDB.selectQuery(sql, values)
res = [WebRole(r) for r in res]
return_list: list = list()
for Role in res:
return_list.append(Role.toJSON())
return cls.response(text=json.dumps(dict(result=return_list, status=200)),
content_type="application/json",
status=200)
async def apiAdminRolesDelete(cls: "WebIndex",
WebRequest: Request) -> Response:
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
role_id: int = Data.getInt("role_id", UNDEFINED, min_x=1)
# checks
if not role_id:
return await apiMissingData(cls,
WebRequest,
msg="missing or invalid 'role_id'")
res: list = cls.Web.BASE.PhaazeDB.selectQuery(
"SELECT `name`, `can_be_removed` FROM `role` WHERE `role`.`id` = %s",
(role_id, ))
if not res:
return await apiWrongData(cls, WebRequest, msg=f"could not find role")
role: dict = res.pop(0)
if not role["can_be_removed"]:
return await apiWrongData(cls,
WebRequest,
msg=f"'{role['name']}' cannot be removed")
cls.Web.BASE.PhaazeDB.deleteQuery(
"DELETE FROM `role` WHERE `role`.`id` = %s", (role_id, ))
return cls.response(text=json.dumps(
dict(msg="role successfull deleted", role=role['name'], status=200)),
content_type="application/json",
status=200)
async def apiAdminRolesCreate(cls: "WebIndex",
WebRequest: Request) -> Response:
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
name: str = Data.getStr("name", "")
description: str = Data.getStr("description", "")
can_be_removed: bool = Data.getBool("can_be_removed", True)
# checks
if not name:
return await apiMissingData(cls,
WebRequest,
msg="missing or invalid 'name'")
res: list = cls.Web.BASE.PhaazeDB.selectQuery(
"SELECT COUNT(*) AS `i` FROM `role` WHERE LOWER(`role`.`name`) = %s",
(name, ))
if res[0]['i'] != 0:
return await apiWrongData(cls,
WebRequest,
msg=f"role '{name}' already exists")
cls.Web.BASE.PhaazeDB.insertQuery(
table="role",
content=dict(name=name,
description=description,
can_be_removed=validateDBInput(bool, can_be_removed)))
return cls.response(text=json.dumps(
dict(msg="role successfull created", role=name, status=200)),
content_type="application/json",
status=200)
async def apiDiscordConfigsGet(cls: "PhaazebotWeb",
WebRequest: ExtendedRequest) -> Response:
"""
Default url: /api/discord/configs/get
"""
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
guild_id: str = Data.getStr("guild_id", "", must_be_digit=True)
# checks
if not 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(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=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=guild_id,
user_id=AuthDiscord.User.user_id)
# get configs
Configs: DiscordServerSettings = await getDiscordSeverSettings(
PhaazeDiscord, origin=guild_id, prevent_new=True)
if not Configs:
return await cls.Tree.Api.errors.apiMissingData(
cls, WebRequest, msg="Could not find configs for this guild")
return cls.response(text=json.dumps(
dict(result=Configs.toJSON(), 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 apiDiscordGuild(cls: "WebIndex", WebRequest: Request) -> Response:
"""
Default url: /api/discord/guild
"""
PhaazeDiscord: "PhaazebotDiscord" = cls.Web.BASE.Discord
if not PhaazeDiscord:
return await apiNotAllowed(cls,
WebRequest,
msg="Discord module is not active")
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
guild_id: str = Data.getStr("guild_id", "", must_be_digit=True)
if not guild_id:
return await apiMissingData(cls,
WebRequest,
msg="invalid or missing 'guild_id'")
Guild: discord.Guild = discord.utils.get(PhaazeDiscord.guilds,
id=int(guild_id))
if not Guild:
return await apiDiscordGuildUnknown(cls, WebRequest)
res: list = cls.Web.BASE.PhaazeDB.query(
"""
SELECT
(SELECT COUNT(*) FROM `discord_user` WHERE `discord_user`.`guild_id` = %s) AS `level_count`,
(SELECT COUNT(*) FROM `discord_command` WHERE `discord_command`.`guild_id` = %s) AS `command_count`,
(SELECT COUNT(*) FROM `discord_quote` WHERE `discord_quote`.`guild_id` = %s) AS `quote_count`,
(SELECT COUNT(*) FROM `discord_twitch_alert` WHERE `discord_twitch_alert`.`discord_guild_id` = %s) AS `twitch_alert_count`""",
(guild_id, guild_id, guild_id, guild_id))
stats_info: dict = res[0]
result: dict = dict(
id=str(Guild.id),
name=Guild.name,
owner_id=str(Guild.owner_id),
icon=Guild.icon,
banner=Guild.banner,
description=Guild.description,
features=Guild.features,
splash=Guild.splash,
premium_tier=Guild.premium_tier,
premium_subscription_count=Guild.premium_subscription_count,
member_count=Guild.member_count,
channel_count=len(Guild.channels),
channels=getAPIChannelList(Guild.channels),
role_count=len(Guild.roles),
roles=getAPIRoleList(Guild.roles),
command_count=stats_info.get("command_count", 0),
quote_count=stats_info.get("quote_count", 0),
twitch_alert_count=stats_info.get("twitch_alert_count", 0),
level_count=stats_info.get("level_count", 0))
return cls.response(body=json.dumps(dict(result=result, status=200)),
status=200,
content_type='application/json')
async def apiAccountCreatePhaaze(cls: "WebIndex",
WebRequest: Request) -> Response:
"""
Default url: /api/account/phaaze/create
"""
WebUser: WebUserInfo = await cls.getWebUserInfo(WebRequest)
if WebUser.found:
return await apiAccountAlreadyLoggedIn(cls,
WebRequest,
user_id=WebUser.user_id)
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
username: str = Data.getStr("username", "")
email: str = Data.getStr("email", "")
password: str = Data.getStr("password", "")
password2: str = Data.getStr("password2", "")
# checks
if password != password2:
return await apiAccountPasswordsDontMatch(cls, WebRequest)
if len(password) < 8:
return await apiAccountPasswordToShort(cls, WebRequest, min_length=8)
if not re.match(IsEmail, email):
return await apiAccountEmailWrong(cls, WebRequest, email=email)
res_users: list = await getWebUsers(
cls,
"LOWER(`user`.`username`) = LOWER(%s) OR LOWER(`user`.`email`) = LOWER(%s)",
(username, email))
if res_users:
return await apiAccountTaken(cls,
WebRequest,
email=email,
username=username)
# everything ok -> create
new_user: dict = dict(username=username,
password=password_function(password),
email=email)
user_id: int = cls.Web.BASE.PhaazeDB.insertQuery(table="user",
content=new_user)
cls.Web.BASE.Logger.debug(f"(API) Account created: ID: {user_id}",
require="api:create")
return cls.response(body=json.dumps(
dict(status=200,
message="successfull created user",
user_id=user_id,
username=username)),
content_type="application/json",
status=200)
async def apiDiscordCommandsGet(cls:"WebIndex", WebRequest:Request) -> Response:
"""
Default url: /api/discord/commands/get
"""
Data:WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required vars
guild_id:str = Data.getStr("guild_id", "", must_be_digit=True)
command_id:str = Data.getStr("command_id", "", must_be_digit=True)
show_hidden:bool = Data.getBool("show_hidden", False)
limit:int = Data.getInt("limit", DEFAULT_LIMIT, min_x=1, max_x=MAX_LIMIT)
offset:int = Data.getInt("offset", 0, min_x=0)
# checks
if not guild_id:
return await apiMissingData(cls, WebRequest, msg="missing or invalid 'guild_id'")
PhaazeDiscord:"PhaazebotDiscord" = cls.Web.BASE.Discord
Guild:discord.Guild = discord.utils.get(PhaazeDiscord.guilds, id=int(guild_id))
if not Guild:
return await apiDiscordGuildUnknown(cls, WebRequest)
if show_hidden:
# user requested to get full information about commands, requires authorisation
DiscordUser:DiscordWebUserInfo = await cls.getDiscordUserInfo(WebRequest)
if not DiscordUser.found:
return await apiMissingAuthorisation(cls, WebRequest)
# get member
CheckMember:discord.Member = Guild.get_member(int(DiscordUser.user_id))
if not CheckMember:
return await apiDiscordMemberNotFound(cls, WebRequest, guild_id=guild_id, user_id=DiscordUser.user_id)
# check permissions
if not (CheckMember.guild_permissions.administrator or CheckMember.guild_permissions.manage_guild):
return await apiDiscordMissingPermission(
cls,
WebRequest,
guild_id=guild_id,
user_id=DiscordUser.user_id,
msg = "'administrator' or 'manage_guild' permission required to show commands with hidden properties"
)
res_commands:list = await getDiscordServerCommands(cls.Web.BASE.Discord, guild_id, command_id=command_id, show_nonactive=show_hidden, limit=limit, offset=offset)
# this point is only reached when command can be hidden or user requested hidden props has authorist
api_return:list = list()
for Command in res_commands:
api_return.append(Command.toJSON(show_hidden=show_hidden))
return cls.response(
text=json.dumps( dict(result=api_return, 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 apiDiscordCommandsListCommands(
cls: "PhaazebotWeb", WebRequest: ExtendedRequest) -> Response:
"""
Default url: /api/discord/commands/list
"""
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
function: str = Data.getStr("function", "", len_max=128)
detailed: bool = Data.getBool("detailed", True)
recommended: bool = Data.getBool("recommended", False)
command_list: list = []
cmd: dict
for cmd in sorted(command_register, key=lambda c: c["name"]):
# user only wants a specific command/function to be returned (could result in none)
if function:
if cmd["function"].__name__ != function: continue
command: dict = dict()
# base information
command["name"] = cmd.get("name", "N/A")
command["function"] = cmd.get("function", lambda: "N/A").__name__
if detailed:
# extra information to know what a function wants
command["description"] = cmd.get("description", None)
command["required_arguments"] = cmd.get("required_arguments", [])
command["optional_arguments"] = cmd.get("optional_arguments", [])
command["endless_arguments"] = cmd.get("endless_arguments", False)
command["need_content"] = cmd.get("need_content", False)
command["allows_content"] = cmd.get("allows_content", False)
command["example_calls"] = cmd.get("example_calls", [])
if recommended:
# recommended values for a command
command["recommended_require"] = cmd.get("recommended_require",
None)
command["recommended_cooldown"] = cmd.get("recommended_cooldown",
None)
command_list.append(command)
return cls.response(text=json.dumps(dict(result=command_list, status=200)),
content_type="application/json",
status=200)
async def apiAdminUsersDelete(cls: "WebIndex",
WebRequest: Request) -> Response:
"""
Default url: /api/admin/users/delete
"""
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
user_id: str = Data.getStr("user_id", "", must_be_digit=True)
# checks
if not user_id:
return await apiMissingData(cls,
WebRequest,
msg="missing or invalid 'user_id'")
# format
where: str = f"`user`.`id` = {user_id}"
# get user
res_users: list = await getWebUsers(cls, where=where)
if not res_users:
return await apiUserNotFound(cls,
WebRequest,
msg=f"no user found with id: {user_id}")
UserToDelete: WebUserInfo = res_users.pop(0)
# check for higher users
if UserToDelete.checkRoles(["superadmin", "admin"]):
if not (await cls.getWebUserInfo(WebRequest)).checkRoles(
["superadmin"]):
return await apiNotAllowed(
cls,
WebRequest,
msg=f"Only Superadmin's can delete (Super)admin user")
cls.Web.BASE.PhaazeDB.deleteQuery(
"""
DELETE FROM `user`
WHERE `user`.`id` = %s LIMIT 1""", (UserToDelete.user_id, ))
cls.Web.BASE.Logger.debug(f"(API) Deleted user U:{user_id}",
require="api:user")
return cls.response(text=json.dumps(
dict(msg="user successfull deleted", status=200)),
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 apiAdminUsersCreate(cls: "WebIndex",
WebRequest: Request) -> Response:
"""
Default url: /api/admin/users/create
"""
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
username: str = Data.getStr("username", UNDEFINED)
email: str = Data.getStr("email", UNDEFINED)
password: str = Data.getStr("password", UNDEFINED)
# format
if password:
password = password_function(password)
# checks
if not username or not email or not password:
return await apiMissingData(
cls, WebRequest, msg="missing 'username', 'email' or 'password'")
try:
new_id: int = cls.Web.BASE.PhaazeDB.insertQuery(table="user",
content=dict(
username=username,
email=email,
password=password))
cls.Web.BASE.Logger.debug(
f"(API) Create user '{username}' (ID:{new_id})",
require="api:user")
return cls.response(text=json.dumps(
dict(msg="user successfull created", status=200)),
content_type="application/json",
status=200)
except:
cls.Web.BASE.Logger.debug(
f"(API) Create user failed, account already taken: {str(username)} - {str(email)}",
require="api:create")
return cls.response(body=json.dumps(
dict(error="account_taken",
status=400,
msg="username or email is already taken")),
content_type="application/json",
status=400)
async def apiAdminUsersGet(cls: "WebIndex", WebRequest: Request) -> Response:
"""
Default url: /api/admin/users/get
"""
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
user_id: str = Data.getStr("user_id", "", must_be_digit=True)
username: str = Data.getStr("username", "")
email: str = Data.getStr("email", "")
offset: int = Data.getInt("offset", 0, min_x=0)
limit: int = Data.getInt("limit", DEFAULT_LIMIT, min_x=1)
# format
where: str = "1=1"
values: tuple = ()
if user_id:
where = "`user`.`id` = %s"
values = (user_id, )
elif email or username:
where = "`user`.`username` LIKE %s OR `user`.`email` LIKE %s"
values = (username, email)
# get user
res_users: list = await getWebUsers(cls,
where=where,
values=values,
limit=limit,
offset=offset)
if not res_users:
return await apiUserNotFound(cls, WebRequest, msg=f"no user found")
result: dict = dict(result=[WebUser.toJSON() for WebUser in res_users],
limit=limit,
offset=offset,
total=await getWebUserAmount(cls,
where=where,
values=values),
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 apiAdminEvaluate(cls: "PhaazebotWeb",
WebRequest: ExtendedRequest) -> Response:
"""
Default url: /api/admin/evaluate
"""
WebAuth: AuthWebUser = await authWebUser(cls, WebRequest)
if not WebAuth.found:
return await cls.Tree.Api.errors.apiMissingAuthorisation(WebRequest)
if not WebAuth.User.checkRoles(["superadmin"]):
return await cls.Tree.Api.errors.apiNotAllowed(
WebRequest, msg="Superadmin rights required")
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
command: str = Data.getStr("command", "")
coroutine: bool = Data.getBool("coroutine", False)
# this is for easier access
locals()["BASE"] = cls.BASE
locals()["SUPERBASE"] = GlobalStorage
# return values
success: bool = False
result: Optional[str] = None
trace: Optional[str] = None
try:
res: Any = eval(command)
if coroutine: res = await res
result = str(res)
trace = None
success = True
except Exception as Fail:
result = str(Fail)
trace = traceback.format_exc()
success = False
return cls.response(body=json.dumps(
dict(result=result, traceback=trace, success=success, status="200")),
status=200,
content_type='application/json')
async def apiDiscordTwitchalertsGet(cls: "WebIndex",
WebRequest: Request) -> Response:
"""
Default url: /api/discord/twitchalerts/get
"""
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
guild_id: str = Data.getStr("guild_id", "", must_be_digit=True)
alert_id: int = Data.getInt("alert_id", UNDEFINED, min_x=1)
limit: int = Data.getInt("limit", DEFAULT_LIMIT, min_x=1, max_x=MAX_LIMIT)
offset: int = Data.getInt("offset", 0, min_x=0)
# checks
if not guild_id:
return await apiMissingData(cls,
WebRequest,
msg="missing or invalid 'guild_id'")
PhaazeDiscord: "PhaazebotDiscord" = cls.Web.BASE.Discord
Guild: discord.Guild = discord.utils.get(PhaazeDiscord.guilds,
id=int(guild_id))
if not Guild:
return await apiDiscordGuildUnknown(cls, WebRequest)
# get alerts
res_alerts: list = await getDiscordTwitchAlerts(PhaazeDiscord,
guild_id=guild_id,
alert_id=alert_id,
limit=limit,
offset=offset)
# if only one is requestet, also send custom content
with_message: bool = True if alert_id else False
return cls.response(text=json.dumps(
dict(result=[
Alert.toJSON(custom_msg=with_message) for Alert in res_alerts
],
total=(await getDiscordTwitchAlertsAmount(PhaazeDiscord,
guild_id)),
status=200)),
content_type="application/json",
status=200)
async def apiAdminUsersDelete(cls: "PhaazebotWeb",
WebRequest: ExtendedRequest) -> Response:
"""
Default url: /api/admin/users/delete
"""
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
user_id: int = Data.getInt("user_id", 0, min_x=1)
# checks
if not user_id:
return await cls.Tree.Api.errors.apiMissingData(
cls, WebRequest, msg="missing or invalid 'user_id'")
# get user
res_users: List[WebUser] = await getWebUsers(cls, user_id=user_id)
if not res_users:
return await cls.Tree.Api.errors.apiUserNotFound(cls,
WebRequest,
user_id=user_id)
UserToDelete: WebUser = res_users.pop(0)
# check for higher users
if UserToDelete.checkRoles(["superadmin", "admin"]):
if not (await authWebUser(cls, WebRequest)).User.checkRoles(
["superadmin"]):
return await cls.Tree.Api.errors.apiNotAllowed(
cls,
WebRequest,
msg=f"Only Superadmin's can delete (Super)admin user")
cls.BASE.PhaazeDB.deleteQuery(
"""
DELETE FROM `user`
WHERE `user`.`id` = %s LIMIT 1""", (UserToDelete.user_id, ))
cls.BASE.Logger.debug(f"(API) Deleted user {user_id=}", require="api:user")
return cls.response(text=json.dumps(
dict(msg="user successful deleted", status=200)),
content_type="application/json",
status=200)
async def apiAdminModule(cls: "PhaazebotWeb",
WebRequest: ExtendedRequest) -> Response:
"""
Default url: /api/admin/module
"""
WebAuth: AuthWebUser = await authWebUser(cls, WebRequest)
if not WebAuth.found:
return await cls.Tree.Api.errors.apiMissingAuthorisation(WebRequest)
if not WebAuth.User.checkRoles(["admin", "superadmin"]):
return await cls.Tree.Api.errors.apiNotAllowed(
WebRequest, msg="Admin rights required")
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
# get required stuff
module: str = Data.getStr("module", "x")
state: bool = Data.getBool("state", UNDEFINED)
if state == UNDEFINED:
return await cls.Tree.Api.errors.apiWrongData(
cls, WebRequest, msg="missing boolish field 'state'")
if not hasattr(cls.BASE.Active, module):
return await cls.Tree.Api.errors.apiMissingValidMethod(
cls, WebRequest, msg=f"module '{module}' not available")
setattr(cls.BASE.Active, module, state)
cls.BASE.Logger.warning(f"Module change state: '{module}' now '{state}'")
# handle state 'False', which means shutdown the module
if not state:
shutdownModule(cls.BASE, module)
response: Dict[str, Any] = dict(
msg=f"state for module: '{module}' is now: {str(state)}",
changed_module=module,
new_state=state,
status=200)
return cls.response(body=json.dumps(response),
status=200,
content_type='application/json')
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 apiDiscordSearch(cls: "PhaazebotWeb",
WebRequest: ExtendedRequest) -> Response:
"""
Default url: /api/discord/search
"""
PhaazeDiscord: "PhaazebotDiscord" = cls.BASE.Discord
if not PhaazeDiscord:
return await apiNotAllowed(cls,
WebRequest,
msg="Discord module is not active")
Data: WebRequestContent = WebRequestContent(WebRequest)
await Data.load()
search: str = Data.getStr("search", "", len_max=128)
term: str = Data.getStr("term", "", len_max=512)
if search not in SEARCH_OPTIONS:
return await apiMissingData(
cls,
WebRequest,
msg="missing or invalid 'search', allowed: " +
", ".join(SEARCH_OPTIONS))
if not term:
return await apiMissingData(cls,
WebRequest,
msg="invalid or missing 'term'")
if search == "guild":
return await searchGuild(cls, WebRequest, Data)
if search == "member":
return await searchMember(cls, WebRequest, Data)
if search == "role":
return await searchRole(cls, WebRequest, Data)
if search == "channel":
return await searchChannel(cls, WebRequest, Data)