async def from_json(cls, data: dict, bot: Red):
"""Return a `BattleLog` object from dictionary representation of the log."""
self = cls()
# Get player's `User` instance.
self.player = bot.get_user(data["player_id"])
if self.player is None:
self.player = await bot.fetch_user(data["player_id"])
self.player_brawler_name = data["player_brawler_name"]
self.player_brawler_level = data["player_brawler_level"]
# Get opponent's `User` instance.
self.opponent = bot.get_user(data["opponent_id"])
if self.opponent is None:
self.opponent = await bot.fetch_user(data["opponent_id"])
self.opponent_brawler_name = data["opponent_brawler_name"]
self.opponent_brawler_level = data["opponent_brawler_level"]
self.game_mode = data["game_mode"]
self.result = data["result"]
return self
async def get_cases_for_member(
guild: discord.Guild, bot: Red, *, member: discord.Member = None, member_id: int = None
) -> List[Case]:
"""
Gets all cases for the specified member or member id in a guild.
Parameters
----------
guild: `discord.Guild`
The guild to get the cases from
bot: Red
The bot's instance
member: `discord.Member`
The member to get cases about
member_id: int
The id of the member to get cases about
Returns
-------
list
A list of all matching cases.
Raises
------
ValueError
If at least one of member or member_id is not provided
`discord.Forbidden`
The bot does not have permission to fetch the modlog message which was sent.
`discord.HTTPException`
Fetching the user failed.
"""
cases = await _config.custom(_CASES, str(guild.id)).all()
if not (member_id or member):
raise ValueError("Expected a member or a member id to be provided.") from None
if not member_id:
member_id = member.id
if not member:
member = bot.get_user(member_id) or member_id
try:
modlog_channel = await get_modlog_channel(guild)
except RuntimeError:
modlog_channel = None
cases = [
await Case.from_json(modlog_channel, bot, case_number, case_data, user=member, guild=guild)
for case_number, case_data in cases.items()
if case_data["user"] == member_id
]
return cases
async def get_user(user_id: int, bot: Red) -> Optional[discord.User]:
"""Returns `discord.User` object from the given ID.
Returns `None` if user can't be found.
"""
user = bot.get_user(user_id)
if user is None:
try:
user = await bot.fetch_user(user_id)
except Exception:
pass
return user
def __init__(self,
bot: Red,
dt_str: str,
text: str,
timezone: str,
created_by_id: int,
id_: str = None):
self._bot = bot
self.id_ = (id_ if id_ is not None else self.generate_unique_id(
text=text, dt_str=dt_str, created_by_id=created_by_id))
self.dt_str = dt_str
self.dt = datetime.strptime(dt_str, self.ISO8601_FORMAT)
self.text = text
self.timezone = timezone
self.tz_info: DstTzInfo = pytz.timezone(timezone)
self.created_by_id = created_by_id
self.created_by: discord.User = bot.get_user(created_by_id)
async def from_json(
cls, mod_channel: discord.TextChannel, bot: Red, case_number: int, data: dict, **kwargs
):
"""Get a Case object from the provided information
Parameters
----------
mod_channel: discord.TextChannel
The mod log channel for the guild
bot: Red
The bot's instance. Needed to get the target user
case_number: int
The case's number.
data: dict
The JSON representation of the case to be gotten
**kwargs
Extra attributes for the Case instance which override values
in the data dict. These should be complete objects and not
IDs, where possible.
Returns
-------
Case
The case object for the requested case
Raises
------
`discord.NotFound`
The user the case is for no longer exists
`discord.Forbidden`
Cannot read message history to fetch the original message.
`discord.HTTPException`
A generic API issue
"""
guild = kwargs.get("guild") or mod_channel.guild
message = kwargs.get("message")
if message is None:
message_id = data.get("message")
if message_id is not None:
message = discord.utils.get(bot.cached_messages, id=message_id)
if message is None:
try:
message = await mod_channel.fetch_message(message_id)
except discord.HTTPException:
message = None
else:
message = None
user_objects = {"user": None, "moderator": None, "amended_by": None}
for user_key in tuple(user_objects):
user_object = kwargs.get(user_key)
if user_object is None:
user_id = data.get(user_key)
if user_id is None:
user_object = None
else:
user_object = bot.get_user(user_id) or user_id
user_objects[user_key] = user_object
channel = kwargs.get("channel") or guild.get_channel(data["channel"]) or data["channel"]
case_guild = kwargs.get("guild") or bot.get_guild(data["guild"])
return cls(
bot=bot,
guild=case_guild,
created_at=data["created_at"],
action_type=data["action_type"],
case_number=case_number,
reason=data["reason"],
until=data["until"],
channel=channel,
modified_at=data["modified_at"],
message=message,
last_known_username=data.get("last_known_username"),
**user_objects,
)
