private bool IsOnCooldown(SocketMessage discordMessage, ParabotUser parabotUser)
{
long fiveMinutesInMilliseconds = 1800000;
var diffInMilliseconds = discordMessage.Timestamp.ToUnixTimeMilliseconds() - parabotUser.CooldownDTM;
return(diffInMilliseconds <= fiveMinutesInMilliseconds ? true : false);
}
public LevelRepository(ParabotUser parabotUser)
{
this._parabotUserId = parabotUser.ParabotUserId;
this._username = parabotUser.UserName;
this._serverName = parabotUser.ServerName;
this._discordId = parabotUser.DiscordId;
this._serverId = parabotUser.ServerId;
}
public async Task InsertNewUser(ParabotUser parabotUser)
{
try
{
await _userCollection.InsertOneAsync(parabotUser);
Log.Information($"User {parabotUser.UserName} with ParabotId {parabotUser.ParabotUserId} has been inserted into the database");
}
catch
{
Log.Error($"User {parabotUser.UserName} with ParabotId {parabotUser.ParabotUserId} has failed inserting into the database");
}
}
private async Task <bool> CheckLevelUpEligibility(ParabotUser parabotUser)
{
LevelRepository levelRepo = new LevelRepository();
var levelList = await levelRepo.GetExpRequirements();
var levelUpRequirements = levelList.FirstOrDefault(l => l.Level == parabotUser.Level + 1);
if (levelUpRequirements == null)
{
levelUpRequirements = new ParabotLevel(parabotUser.Level + 1, 50);
}
Log.Debug($"Level {parabotUser.Level} user {parabotUser.UserName} with {parabotUser.Exp} experience requires {levelUpRequirements.ExpRequirement} experience to level up to {levelUpRequirements.Level}");
return(parabotUser.Exp >= levelUpRequirements.ExpRequirement ? true : false);
}
public async Task UpdateParabotUser(ParabotUser parabotUser)
{
var filterUser = Builders <ParabotUser> .Filter.Eq("_id", _parabotUserId);
try
{
await _userCollection.FindOneAndReplaceAsync <ParabotUser>(filterUser, parabotUser);
Log.Information($"Successfully updated Parabot User {parabotUser.UserName} from server {parabotUser.ServerName}");
}
catch
{
Log.Error($"Error updating Parabot User {parabotUser.UserName} from server {parabotUser.ServerName}");
}
}
public async Task <ParabotLevel> GetLevelRequirement(ParabotUser parabotUser)
{
LevelRepository levelRepo = new LevelRepository(parabotUser);
var resultList = await levelRepo.GetExpRequirements();
switch (resultList.Count)
{
case 0:
Log.Error("Error finding Exp Requirements collection");
return(null);
default:
Log.Information("Found Exp Requirements collection");
return(resultList.FirstOrDefault(level => level.Level == parabotUser.Level + 1));
}
}
private void CheckRoleEligibility(ParabotUser parabotUser, SocketMessage messageEvent)
{
var guild = (messageEvent.Channel as SocketTextChannel).Guild;
var guildUser = messageEvent.Author as SocketGuildUser;
var firstRole = guild.Roles.FirstOrDefault(r => r.Name == "THE OUTTERMOST BOX");
var secondRole = guild.Roles.FirstOrDefault(r => r.Name == "THE OUTER BOX");
var thirdRole = guild.Roles.FirstOrDefault(r => r.Name == "THE BOX");
var finalRole = guild.Roles.FirstOrDefault(r => r.Name == "THE INNER BOX");
var firstRoleExists = guildUser.Roles.FirstOrDefault(r => r.Name == firstRole.Name);
var secondRoleExists = guildUser.Roles.FirstOrDefault(r => r.Name == secondRole.Name);
var thirdRoleExists = guildUser.Roles.FirstOrDefault(r => r.Name == thirdRole.Name);
var finalRoleExists = guildUser.Roles.FirstOrDefault(r => r.Name == finalRole.Name);
switch (parabotUser.Level)
{
case 1:
if (firstRoleExists == null)
{
guildUser.AddRoleAsync(firstRole);
}
break;
case 5:
if (secondRoleExists == null)
{
guildUser.AddRoleAsync(secondRole);
}
break;
case 10:
if (thirdRoleExists == null)
{
guildUser.AddRoleAsync(thirdRole);
}
break;
case 15:
if (finalRoleExists == null)
{
guildUser.AddRoleAsync(finalRole);
}
break;
}
}
private async Task <ParabotUser> ProcessExp(SocketMessage discordMessage, ParabotUser parabotUser)
{
Log.Information($"Entered increment exp method for user: {parabotUser}");
if (IsOnCooldown(discordMessage, parabotUser))
{
return(parabotUser);
}
try
{
Log.Information($"User {parabotUser.UserName} is not on cooldown");
parabotUser.GiveExp(1);
parabotUser.ResetCooldown(discordMessage.Timestamp.ToUnixTimeMilliseconds());
if (await CheckLevelUpEligibility(parabotUser))
{
parabotUser = await ProcessLevelUp(discordMessage, parabotUser);
}
return(parabotUser);
}
catch (Exception e)
{
Log.Error(e.ToString());
return(null);
}
}
private static async Task <ParabotUser> ProcessLevelUp(SocketMessage discordMessage, ParabotUser parabotUser)
{
parabotUser.LevelUp();
try
{
await discordMessage.Channel.SendMessageAsync($"Congratulations {parabotUser.UserName}, you have reached level {parabotUser.Level}");
}
catch (Exception e)
{
var dmChannel = await discordMessage.Author.GetOrCreateDMChannelAsync();
await dmChannel.SendMessageAsync($"Congratulations {parabotUser.UserName}, you have reached level {parabotUser.Level} in {parabotUser.ServerName}");
Log.Error(e.ToString());
}
return(parabotUser);
}
