mirror of
https://github.com/pacnpal/Pac-cogs.git
synced 2025-12-20 10:51:05 -05:00
799 lines
29 KiB
Python
799 lines
29 KiB
Python
"""Module for settings-related commands"""
|
|
|
|
import logging
|
|
from enum import Enum, auto
|
|
from typing import Optional, Any, Dict, TypedDict
|
|
|
|
import discord # type: ignore
|
|
from discord import app_commands # type: ignore
|
|
from redbot.core import commands # type: ignore
|
|
from redbot.core.commands import Context, hybrid_group, guild_only, admin_or_permissions # type: ignore
|
|
|
|
from core.settings import VideoFormat, VideoQuality
|
|
from core.response_handler import handle_response, ResponseType
|
|
from utils.exceptions import CommandError, ErrorContext, ErrorSeverity
|
|
|
|
logger = logging.getLogger("VideoArchiver")
|
|
|
|
|
|
class SettingCategory(Enum):
|
|
"""Setting categories"""
|
|
|
|
CHANNELS = auto()
|
|
VIDEO = auto()
|
|
MESSAGES = auto()
|
|
PERFORMANCE = auto()
|
|
|
|
|
|
class SettingValidation(TypedDict):
|
|
"""Type definition for setting validation"""
|
|
|
|
valid: bool
|
|
error: Optional[str]
|
|
details: Dict[str, Any]
|
|
|
|
|
|
class SettingUpdate(TypedDict):
|
|
"""Type definition for setting update"""
|
|
|
|
setting: str
|
|
old_value: Any
|
|
new_value: Any
|
|
category: SettingCategory
|
|
|
|
|
|
async def validate_setting(
|
|
category: SettingCategory, setting: str, value: Any
|
|
) -> SettingValidation:
|
|
"""
|
|
Validate a setting value.
|
|
|
|
Args:
|
|
category: Setting category
|
|
setting: Setting name
|
|
value: Value to validate
|
|
|
|
Returns:
|
|
Validation result
|
|
"""
|
|
validation = SettingValidation(
|
|
valid=True,
|
|
error=None,
|
|
details={"category": category.name, "setting": setting, "value": value},
|
|
)
|
|
|
|
try:
|
|
if category == SettingCategory.VIDEO:
|
|
if setting == "format":
|
|
if value not in [f.value for f in VideoFormat]:
|
|
validation.update(
|
|
{
|
|
"valid": False,
|
|
"error": f"Invalid format. Must be one of: {', '.join(f.value for f in VideoFormat)}",
|
|
}
|
|
)
|
|
elif setting == "quality":
|
|
if not 144 <= value <= 4320:
|
|
validation.update(
|
|
{
|
|
"valid": False,
|
|
"error": "Quality must be between 144 and 4320",
|
|
}
|
|
)
|
|
elif setting == "max_file_size":
|
|
if not 1 <= value <= 100:
|
|
validation.update(
|
|
{"valid": False, "error": "Size must be between 1 and 100 MB"}
|
|
)
|
|
|
|
elif category == SettingCategory.MESSAGES:
|
|
if setting == "duration":
|
|
if not 0 <= value <= 168:
|
|
validation.update(
|
|
{
|
|
"valid": False,
|
|
"error": "Duration must be between 0 and 168 hours (1 week)",
|
|
}
|
|
)
|
|
elif setting == "template":
|
|
placeholders = ["{author}", "{channel}", "{original_message}"]
|
|
if not any(ph in value for ph in placeholders):
|
|
validation.update(
|
|
{
|
|
"valid": False,
|
|
"error": f"Template must include at least one placeholder: {', '.join(placeholders)}",
|
|
}
|
|
)
|
|
|
|
elif category == SettingCategory.PERFORMANCE:
|
|
if setting == "concurrent_downloads":
|
|
if not 1 <= value <= 5:
|
|
validation.update(
|
|
{
|
|
"valid": False,
|
|
"error": "Concurrent downloads must be between 1 and 5",
|
|
}
|
|
)
|
|
|
|
except Exception as e:
|
|
validation.update({"valid": False, "error": f"Validation error: {str(e)}"})
|
|
|
|
return validation
|
|
|
|
|
|
def setup_settings_commands(cog: Any) -> Any:
|
|
"""
|
|
Set up settings commands for the cog.
|
|
|
|
Args:
|
|
cog: VideoArchiver cog instance
|
|
|
|
Returns:
|
|
Main settings command group
|
|
"""
|
|
|
|
@hybrid_group(name="settings", fallback="show")
|
|
@guild_only()
|
|
async def settings(ctx: Context) -> None:
|
|
"""Show current archiver settings."""
|
|
try:
|
|
# Check if config manager is ready
|
|
if not cog.config_manager:
|
|
raise CommandError(
|
|
"Configuration system is not ready",
|
|
context=ErrorContext(
|
|
"SettingsCommands",
|
|
"show_settings",
|
|
{"guild_id": ctx.guild.id},
|
|
ErrorSeverity.HIGH,
|
|
),
|
|
)
|
|
|
|
# Defer the response immediately for slash commands
|
|
if hasattr(ctx, "interaction") and ctx.interaction:
|
|
await ctx.defer()
|
|
|
|
embed = await cog.config_manager.format_settings_embed(ctx.guild)
|
|
await handle_response(ctx, embed=embed, response_type=ResponseType.INFO)
|
|
|
|
except Exception as e:
|
|
error = f"Failed to show settings: {str(e)}"
|
|
logger.error(error, exc_info=True)
|
|
raise CommandError(
|
|
error,
|
|
context=ErrorContext(
|
|
"SettingsCommands",
|
|
"show_settings",
|
|
{"guild_id": ctx.guild.id},
|
|
ErrorSeverity.MEDIUM,
|
|
),
|
|
)
|
|
|
|
@settings.command(name="setchannel")
|
|
@guild_only()
|
|
@admin_or_permissions(administrator=True)
|
|
@app_commands.describe(channel="The channel where archived videos will be stored")
|
|
async def set_archive_channel(ctx: Context, channel: discord.TextChannel) -> None:
|
|
"""Set the channel where archived videos will be stored."""
|
|
try:
|
|
# Check if config manager is ready
|
|
if not cog.config_manager:
|
|
raise CommandError(
|
|
"Configuration system is not ready",
|
|
context=ErrorContext(
|
|
"SettingsCommands",
|
|
"set_archive_channel",
|
|
{"guild_id": ctx.guild.id},
|
|
ErrorSeverity.HIGH,
|
|
),
|
|
)
|
|
|
|
# Defer the response immediately for slash commands
|
|
if hasattr(ctx, "interaction") and ctx.interaction:
|
|
await ctx.defer()
|
|
|
|
# Check channel permissions
|
|
bot_member = ctx.guild.me
|
|
required_perms = discord.Permissions(
|
|
send_messages=True,
|
|
embed_links=True,
|
|
attach_files=True,
|
|
read_message_history=True,
|
|
)
|
|
channel_perms = channel.permissions_for(bot_member)
|
|
if not all(getattr(channel_perms, perm) for perm in required_perms):
|
|
raise CommandError(
|
|
"Missing required permissions in target channel",
|
|
context=ErrorContext(
|
|
"SettingsCommands",
|
|
"set_archive_channel",
|
|
{
|
|
"guild_id": ctx.guild.id,
|
|
"channel_id": channel.id,
|
|
"missing_perms": [
|
|
perm
|
|
for perm in required_perms
|
|
if not getattr(channel_perms, perm)
|
|
],
|
|
},
|
|
ErrorSeverity.MEDIUM,
|
|
),
|
|
)
|
|
|
|
await cog.config_manager.update_setting(
|
|
ctx.guild.id, "archive_channel", channel.id
|
|
)
|
|
await handle_response(
|
|
ctx,
|
|
f"Archive channel has been set to {channel.mention}.",
|
|
response_type=ResponseType.SUCCESS,
|
|
)
|
|
|
|
except Exception as e:
|
|
error = f"Failed to set archive channel: {str(e)}"
|
|
logger.error(error, exc_info=True)
|
|
raise CommandError(
|
|
error,
|
|
context=ErrorContext(
|
|
"SettingsCommands",
|
|
"set_archive_channel",
|
|
{"guild_id": ctx.guild.id, "channel_id": channel.id},
|
|
ErrorSeverity.HIGH,
|
|
),
|
|
)
|
|
|
|
@settings.command(name="setlog")
|
|
@guild_only()
|
|
@admin_or_permissions(administrator=True)
|
|
@app_commands.describe(channel="The channel where log messages will be sent")
|
|
async def set_log_channel(ctx: Context, channel: discord.TextChannel) -> None:
|
|
"""Set the channel where log messages will be sent."""
|
|
try:
|
|
# Check if config manager is ready
|
|
if not cog.config_manager:
|
|
raise CommandError(
|
|
"Configuration system is not ready",
|
|
context=ErrorContext(
|
|
"SettingsCommands",
|
|
"set_log_channel",
|
|
{"guild_id": ctx.guild.id},
|
|
ErrorSeverity.HIGH,
|
|
),
|
|
)
|
|
|
|
# Defer the response immediately for slash commands
|
|
if hasattr(ctx, "interaction") and ctx.interaction:
|
|
await ctx.defer()
|
|
|
|
# Check channel permissions
|
|
bot_member = ctx.guild.me
|
|
required_perms = discord.Permissions(
|
|
send_messages=True, embed_links=True, read_message_history=True
|
|
)
|
|
channel_perms = channel.permissions_for(bot_member)
|
|
if not all(getattr(channel_perms, perm) for perm in required_perms):
|
|
raise CommandError(
|
|
"Missing required permissions in target channel",
|
|
context=ErrorContext(
|
|
"SettingsCommands",
|
|
"set_log_channel",
|
|
{
|
|
"guild_id": ctx.guild.id,
|
|
"channel_id": channel.id,
|
|
"missing_perms": [
|
|
perm
|
|
for perm in required_perms
|
|
if not getattr(channel_perms, perm)
|
|
],
|
|
},
|
|
ErrorSeverity.MEDIUM,
|
|
),
|
|
)
|
|
|
|
await cog.config_manager.update_setting(
|
|
ctx.guild.id, "log_channel", channel.id
|
|
)
|
|
await handle_response(
|
|
ctx,
|
|
f"Log channel has been set to {channel.mention}.",
|
|
response_type=ResponseType.SUCCESS,
|
|
)
|
|
|
|
except Exception as e:
|
|
error = f"Failed to set log channel: {str(e)}"
|
|
logger.error(error, exc_info=True)
|
|
raise CommandError(
|
|
error,
|
|
context=ErrorContext(
|
|
"SettingsCommands",
|
|
"set_log_channel",
|
|
{"guild_id": ctx.guild.id, "channel_id": channel.id},
|
|
ErrorSeverity.HIGH,
|
|
),
|
|
)
|
|
|
|
@settings.command(name="addchannel")
|
|
@guild_only()
|
|
@admin_or_permissions(administrator=True)
|
|
@app_commands.describe(channel="The channel to monitor for videos")
|
|
async def add_enabled_channel(ctx: Context, channel: discord.TextChannel) -> None:
|
|
"""Add a channel to monitor for videos."""
|
|
try:
|
|
# Check if config manager is ready
|
|
if not cog.config_manager:
|
|
raise CommandError(
|
|
"Configuration system is not ready",
|
|
context=ErrorContext(
|
|
"SettingsCommands",
|
|
"add_enabled_channel",
|
|
{"guild_id": ctx.guild.id},
|
|
ErrorSeverity.HIGH,
|
|
),
|
|
)
|
|
|
|
# Defer the response immediately for slash commands
|
|
if hasattr(ctx, "interaction") and ctx.interaction:
|
|
await ctx.defer()
|
|
|
|
# Check channel permissions
|
|
bot_member = ctx.guild.me
|
|
required_perms = discord.Permissions(
|
|
read_messages=True, read_message_history=True
|
|
)
|
|
channel_perms = channel.permissions_for(bot_member)
|
|
if not all(getattr(channel_perms, perm) for perm in required_perms):
|
|
raise CommandError(
|
|
"Missing required permissions in target channel",
|
|
context=ErrorContext(
|
|
"SettingsCommands",
|
|
"add_enabled_channel",
|
|
{
|
|
"guild_id": ctx.guild.id,
|
|
"channel_id": channel.id,
|
|
"missing_perms": [
|
|
perm
|
|
for perm in required_perms
|
|
if not getattr(channel_perms, perm)
|
|
],
|
|
},
|
|
ErrorSeverity.MEDIUM,
|
|
),
|
|
)
|
|
|
|
enabled_channels = await cog.config_manager.get_setting(
|
|
ctx.guild.id, "enabled_channels"
|
|
)
|
|
if channel.id in enabled_channels:
|
|
await handle_response(
|
|
ctx,
|
|
f"{channel.mention} is already being monitored.",
|
|
response_type=ResponseType.WARNING,
|
|
)
|
|
return
|
|
|
|
enabled_channels.append(channel.id)
|
|
await cog.config_manager.update_setting(
|
|
ctx.guild.id, "enabled_channels", enabled_channels
|
|
)
|
|
await handle_response(
|
|
ctx,
|
|
f"Now monitoring {channel.mention} for videos.",
|
|
response_type=ResponseType.SUCCESS,
|
|
)
|
|
|
|
except Exception as e:
|
|
error = f"Failed to add enabled channel: {str(e)}"
|
|
logger.error(error, exc_info=True)
|
|
raise CommandError(
|
|
error,
|
|
context=ErrorContext(
|
|
"SettingsCommands",
|
|
"add_enabled_channel",
|
|
{"guild_id": ctx.guild.id, "channel_id": channel.id},
|
|
ErrorSeverity.HIGH,
|
|
),
|
|
)
|
|
|
|
@settings.command(name="removechannel")
|
|
@guild_only()
|
|
@admin_or_permissions(administrator=True)
|
|
@app_commands.describe(channel="The channel to stop monitoring")
|
|
async def remove_enabled_channel(
|
|
ctx: Context, channel: discord.TextChannel
|
|
) -> None:
|
|
"""Remove a channel from video monitoring."""
|
|
try:
|
|
# Check if config manager is ready
|
|
if not cog.config_manager:
|
|
raise CommandError(
|
|
"Configuration system is not ready",
|
|
context=ErrorContext(
|
|
"SettingsCommands",
|
|
"remove_enabled_channel",
|
|
{"guild_id": ctx.guild.id},
|
|
ErrorSeverity.HIGH,
|
|
),
|
|
)
|
|
|
|
# Defer the response immediately for slash commands
|
|
if hasattr(ctx, "interaction") and ctx.interaction:
|
|
await ctx.defer()
|
|
|
|
enabled_channels = await cog.config_manager.get_setting(
|
|
ctx.guild.id, "enabled_channels"
|
|
)
|
|
if channel.id not in enabled_channels:
|
|
await handle_response(
|
|
ctx,
|
|
f"{channel.mention} is not being monitored.",
|
|
response_type=ResponseType.WARNING,
|
|
)
|
|
return
|
|
|
|
enabled_channels.remove(channel.id)
|
|
await cog.config_manager.update_setting(
|
|
ctx.guild.id, "enabled_channels", enabled_channels
|
|
)
|
|
await handle_response(
|
|
ctx,
|
|
f"Stopped monitoring {channel.mention} for videos.",
|
|
response_type=ResponseType.SUCCESS,
|
|
)
|
|
|
|
except Exception as e:
|
|
error = f"Failed to remove enabled channel: {str(e)}"
|
|
logger.error(error, exc_info=True)
|
|
raise CommandError(
|
|
error,
|
|
context=ErrorContext(
|
|
"SettingsCommands",
|
|
"remove_enabled_channel",
|
|
{"guild_id": ctx.guild.id, "channel_id": channel.id},
|
|
ErrorSeverity.HIGH,
|
|
),
|
|
)
|
|
|
|
@settings.command(name="setformat")
|
|
@guild_only()
|
|
@admin_or_permissions(administrator=True)
|
|
@app_commands.describe(format="The video format to use (mp4, webm, or mkv)")
|
|
async def set_video_format(ctx: Context, format: str) -> None:
|
|
"""Set the video format for archived videos."""
|
|
try:
|
|
# Check if config manager is ready
|
|
if not cog.config_manager:
|
|
raise CommandError(
|
|
"Configuration system is not ready",
|
|
context=ErrorContext(
|
|
"SettingsCommands",
|
|
"set_video_format",
|
|
{"guild_id": ctx.guild.id},
|
|
ErrorSeverity.HIGH,
|
|
),
|
|
)
|
|
|
|
# Defer the response immediately for slash commands
|
|
if hasattr(ctx, "interaction") and ctx.interaction:
|
|
await ctx.defer()
|
|
|
|
# Validate format
|
|
format = format.lower()
|
|
validation = await validate_setting(SettingCategory.VIDEO, "format", format)
|
|
if not validation["valid"]:
|
|
await handle_response(
|
|
ctx, validation["error"], response_type=ResponseType.ERROR
|
|
)
|
|
return
|
|
|
|
await cog.config_manager.update_setting(
|
|
ctx.guild.id, "video_format", format
|
|
)
|
|
await handle_response(
|
|
ctx,
|
|
f"Video format has been set to {format}.",
|
|
response_type=ResponseType.SUCCESS,
|
|
)
|
|
|
|
except Exception as e:
|
|
error = f"Failed to set video format: {str(e)}"
|
|
logger.error(error, exc_info=True)
|
|
raise CommandError(
|
|
error,
|
|
context=ErrorContext(
|
|
"SettingsCommands",
|
|
"set_video_format",
|
|
{"guild_id": ctx.guild.id, "format": format},
|
|
ErrorSeverity.HIGH,
|
|
),
|
|
)
|
|
|
|
@settings.command(name="setquality")
|
|
@guild_only()
|
|
@admin_or_permissions(administrator=True)
|
|
@app_commands.describe(quality="The video quality (144-4320)")
|
|
async def set_video_quality(ctx: Context, quality: int) -> None:
|
|
"""Set the video quality for archived videos."""
|
|
try:
|
|
# Check if config manager is ready
|
|
if not cog.config_manager:
|
|
raise CommandError(
|
|
"Configuration system is not ready",
|
|
context=ErrorContext(
|
|
"SettingsCommands",
|
|
"set_video_quality",
|
|
{"guild_id": ctx.guild.id},
|
|
ErrorSeverity.HIGH,
|
|
),
|
|
)
|
|
|
|
# Defer the response immediately for slash commands
|
|
if hasattr(ctx, "interaction") and ctx.interaction:
|
|
await ctx.defer()
|
|
|
|
# Validate quality
|
|
validation = await validate_setting(
|
|
SettingCategory.VIDEO, "quality", quality
|
|
)
|
|
if not validation["valid"]:
|
|
await handle_response(
|
|
ctx, validation["error"], response_type=ResponseType.ERROR
|
|
)
|
|
return
|
|
|
|
await cog.config_manager.update_setting(
|
|
ctx.guild.id, "video_quality", quality
|
|
)
|
|
await handle_response(
|
|
ctx,
|
|
f"Video quality has been set to {quality}p.",
|
|
response_type=ResponseType.SUCCESS,
|
|
)
|
|
|
|
except Exception as e:
|
|
error = f"Failed to set video quality: {str(e)}"
|
|
logger.error(error, exc_info=True)
|
|
raise CommandError(
|
|
error,
|
|
context=ErrorContext(
|
|
"SettingsCommands",
|
|
"set_video_quality",
|
|
{"guild_id": ctx.guild.id, "quality": quality},
|
|
ErrorSeverity.HIGH,
|
|
),
|
|
)
|
|
|
|
@settings.command(name="setmaxsize")
|
|
@guild_only()
|
|
@admin_or_permissions(administrator=True)
|
|
@app_commands.describe(size="The maximum file size in MB (1-100)")
|
|
async def set_max_file_size(ctx: Context, size: int) -> None:
|
|
"""Set the maximum file size for archived videos."""
|
|
try:
|
|
# Check if config manager is ready
|
|
if not cog.config_manager:
|
|
raise CommandError(
|
|
"Configuration system is not ready",
|
|
context=ErrorContext(
|
|
"SettingsCommands",
|
|
"set_max_file_size",
|
|
{"guild_id": ctx.guild.id},
|
|
ErrorSeverity.HIGH,
|
|
),
|
|
)
|
|
|
|
# Defer the response immediately for slash commands
|
|
if hasattr(ctx, "interaction") and ctx.interaction:
|
|
await ctx.defer()
|
|
|
|
# Validate size
|
|
validation = await validate_setting(
|
|
SettingCategory.VIDEO, "max_file_size", size
|
|
)
|
|
if not validation["valid"]:
|
|
await handle_response(
|
|
ctx, validation["error"], response_type=ResponseType.ERROR
|
|
)
|
|
return
|
|
|
|
await cog.config_manager.update_setting(ctx.guild.id, "max_file_size", size)
|
|
await handle_response(
|
|
ctx,
|
|
f"Maximum file size has been set to {size}MB.",
|
|
response_type=ResponseType.SUCCESS,
|
|
)
|
|
|
|
except Exception as e:
|
|
error = f"Failed to set max file size: {str(e)}"
|
|
logger.error(error, exc_info=True)
|
|
raise CommandError(
|
|
error,
|
|
context=ErrorContext(
|
|
"SettingsCommands",
|
|
"set_max_file_size",
|
|
{"guild_id": ctx.guild.id, "size": size},
|
|
ErrorSeverity.HIGH,
|
|
),
|
|
)
|
|
|
|
@settings.command(name="setmessageduration")
|
|
@guild_only()
|
|
@admin_or_permissions(administrator=True)
|
|
@app_commands.describe(hours="How long to keep messages in hours (0-168)")
|
|
async def set_message_duration(ctx: Context, hours: int) -> None:
|
|
"""Set how long to keep archived messages."""
|
|
try:
|
|
# Check if config manager is ready
|
|
if not cog.config_manager:
|
|
raise CommandError(
|
|
"Configuration system is not ready",
|
|
context=ErrorContext(
|
|
"SettingsCommands",
|
|
"set_message_duration",
|
|
{"guild_id": ctx.guild.id},
|
|
ErrorSeverity.HIGH,
|
|
),
|
|
)
|
|
|
|
# Defer the response immediately for slash commands
|
|
if hasattr(ctx, "interaction") and ctx.interaction:
|
|
await ctx.defer()
|
|
|
|
# Validate duration
|
|
validation = await validate_setting(
|
|
SettingCategory.MESSAGES, "duration", hours
|
|
)
|
|
if not validation["valid"]:
|
|
await handle_response(
|
|
ctx, validation["error"], response_type=ResponseType.ERROR
|
|
)
|
|
return
|
|
|
|
await cog.config_manager.update_setting(
|
|
ctx.guild.id, "message_duration", hours
|
|
)
|
|
await handle_response(
|
|
ctx,
|
|
f"Message duration has been set to {hours} hours.",
|
|
response_type=ResponseType.SUCCESS,
|
|
)
|
|
|
|
except Exception as e:
|
|
error = f"Failed to set message duration: {str(e)}"
|
|
logger.error(error, exc_info=True)
|
|
raise CommandError(
|
|
error,
|
|
context=ErrorContext(
|
|
"SettingsCommands",
|
|
"set_message_duration",
|
|
{"guild_id": ctx.guild.id, "hours": hours},
|
|
ErrorSeverity.HIGH,
|
|
),
|
|
)
|
|
|
|
@settings.command(name="settemplate")
|
|
@guild_only()
|
|
@admin_or_permissions(administrator=True)
|
|
@app_commands.describe(
|
|
template="The message template to use. Available placeholders: {author}, {channel}, {original_message}"
|
|
)
|
|
async def set_message_template(ctx: Context, template: str) -> None:
|
|
"""Set the template for archived messages."""
|
|
try:
|
|
# Check if config manager is ready
|
|
if not cog.config_manager:
|
|
raise CommandError(
|
|
"Configuration system is not ready",
|
|
context=ErrorContext(
|
|
"SettingsCommands",
|
|
"set_message_template",
|
|
{"guild_id": ctx.guild.id},
|
|
ErrorSeverity.HIGH,
|
|
),
|
|
)
|
|
|
|
# Defer the response immediately for slash commands
|
|
if hasattr(ctx, "interaction") and ctx.interaction:
|
|
await ctx.defer()
|
|
|
|
# Validate template
|
|
validation = await validate_setting(
|
|
SettingCategory.MESSAGES, "template", template
|
|
)
|
|
if not validation["valid"]:
|
|
await handle_response(
|
|
ctx, validation["error"], response_type=ResponseType.ERROR
|
|
)
|
|
return
|
|
|
|
await cog.config_manager.update_setting(
|
|
ctx.guild.id, "message_template", template
|
|
)
|
|
await handle_response(
|
|
ctx,
|
|
f"Message template has been set to: {template}",
|
|
response_type=ResponseType.SUCCESS,
|
|
)
|
|
|
|
except Exception as e:
|
|
error = f"Failed to set message template: {str(e)}"
|
|
logger.error(error, exc_info=True)
|
|
raise CommandError(
|
|
error,
|
|
context=ErrorContext(
|
|
"SettingsCommands",
|
|
"set_message_template",
|
|
{"guild_id": ctx.guild.id},
|
|
ErrorSeverity.HIGH,
|
|
),
|
|
)
|
|
|
|
@settings.command(name="setconcurrent")
|
|
@guild_only()
|
|
@admin_or_permissions(administrator=True)
|
|
@app_commands.describe(count="Number of concurrent downloads (1-5)")
|
|
async def set_concurrent_downloads(ctx: Context, count: int) -> None:
|
|
"""Set the number of concurrent downloads allowed."""
|
|
try:
|
|
# Check if config manager is ready
|
|
if not cog.config_manager:
|
|
raise CommandError(
|
|
"Configuration system is not ready",
|
|
context=ErrorContext(
|
|
"SettingsCommands",
|
|
"set_concurrent_downloads",
|
|
{"guild_id": ctx.guild.id},
|
|
ErrorSeverity.HIGH,
|
|
),
|
|
)
|
|
|
|
# Defer the response immediately for slash commands
|
|
if hasattr(ctx, "interaction") and ctx.interaction:
|
|
await ctx.defer()
|
|
|
|
# Validate count
|
|
validation = await validate_setting(
|
|
SettingCategory.PERFORMANCE, "concurrent_downloads", count
|
|
)
|
|
if not validation["valid"]:
|
|
await handle_response(
|
|
ctx, validation["error"], response_type=ResponseType.ERROR
|
|
)
|
|
return
|
|
|
|
await cog.config_manager.update_setting(
|
|
ctx.guild.id, "concurrent_downloads", count
|
|
)
|
|
await handle_response(
|
|
ctx,
|
|
f"Concurrent downloads has been set to {count}.",
|
|
response_type=ResponseType.SUCCESS,
|
|
)
|
|
|
|
except Exception as e:
|
|
error = f"Failed to set concurrent downloads: {str(e)}"
|
|
logger.error(error, exc_info=True)
|
|
raise CommandError(
|
|
error,
|
|
context=ErrorContext(
|
|
"SettingsCommands",
|
|
"set_concurrent_downloads",
|
|
{"guild_id": ctx.guild.id, "count": count},
|
|
ErrorSeverity.HIGH,
|
|
),
|
|
)
|
|
|
|
# Store commands in cog for access
|
|
cog.settings = settings
|
|
cog.set_archive_channel = set_archive_channel
|
|
cog.set_log_channel = set_log_channel
|
|
cog.add_enabled_channel = add_enabled_channel
|
|
cog.remove_enabled_channel = remove_enabled_channel
|
|
cog.set_video_format = set_video_format
|
|
cog.set_video_quality = set_video_quality
|
|
cog.set_max_file_size = set_max_file_size
|
|
cog.set_message_duration = set_message_duration
|
|
cog.set_message_template = set_message_template
|
|
cog.set_concurrent_downloads = set_concurrent_downloads
|
|
|
|
return settings
|