public ModuleResult GetSpecificRaid(string raidName)
{
var result = new ModuleResult();
var raids = _raidFileService.GetRaidsFromFile().Where(a => a.Name.Equals(raidName, StringComparison.CurrentCultureIgnoreCase));
if (raids.Count() == 1)
{
var raid = raids.Single();
result.Success = true;
result.RequesterUserBuilder = EmbedBuilderHelper.BlueBuilder();
result.RequesterUserBuilder
.WithTitle($"Raid: {raid.ToString()}")
.WithDescription(raid.ToStringUsers())
.WithThumbnailUrl(raid.RaidBossSpriteUrl);
}
else if (raids.Count() == 0)
{
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder("Could not find that raid");
}
else
{
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder("Unknown Error");
}
return(result);
}
public async Task <ModuleResult> AddPokemon(string raidName, string raidBoss, IGuildUser user)
{
var result = new ModuleResult();
int raidBossId;
string raidBossName;
string raidBossSpriteUrl;
try {
(raidBossId, raidBossName, raidBossSpriteUrl) = await Mons.GetMonInfo(raidBoss);
}
catch (Exception e) {
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder("Cannot recognise raid boss. Check your spelling!");
return(result);
}
var raids = _raidFileService.GetRaidsFromFile().Where(a => a.Name.Equals(raidName, StringComparison.CurrentCultureIgnoreCase));
if (raids.Count() == 1)
{
var raid = raids.Single();
if (raid.RaidBossId == raidBossId)
{
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder($"That raid already has a raidboss of: {raidBossName}");
return(result);
}
if (user.GuildPermissions.Has(GuildPermission.ManageMessages) || raid.Users.FirstOrDefault().Equals(User.FromIUser(user)))
{
result.Users = raid.Users;
var allRaids = _raidFileService.GetRaidsFromFile();
var oldRaidBossId = allRaids.Single(a => a.Equals(raid)).RaidBossId;
allRaids.Single(a => a.Equals(raid)).RaidBossId = raidBossId;
allRaids.Single(a => a.Equals(raid)).RaidBossName = raidBossName;
allRaids.Single(a => a.Equals(raid)).RaidBossSpriteUrl = raidBossSpriteUrl;
_raidFileService.PushRaidsToFile(allRaids);
string raidBossMessage = oldRaidBossId == 0 ? $"Raidboss has been changed to {raidBossName}" : $"Raidboss has been changed from {raid.RaidBossName} to {raidBossName}";
result.Success = true;
result.RequesterUserBuilder = EmbedBuilderHelper.GreenBuilder();
result.RequesterUserBuilder
.WithTitle($"Raid: {raidName}")
.WithDescription(raidBossMessage)
.WithThumbnailUrl(raidBossSpriteUrl);
}
else
{
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder("Only the leader can change the raidboss");
}
}
else if (raids.Count() == 0)
{
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder("Cannot find raid");
}
else
{
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder("Unknown Error");
}
return(result);
}
public async Task AdminPermission([Summary("The permission level for raid creation")] string permissionLevel)
{
var dmChannel = await Context.User.GetOrCreateDMChannelAsync();
GuildPermission?permission;
if (permissionLevel.Equals("off", StringComparison.CurrentCultureIgnoreCase))
{
permission = null;
}
else
{
permission = (GuildPermission)Enum.Parse(typeof(GuildPermission), permissionLevel, true);
}
//Check if it failed and return the list of settings you can use
_permissionService.SetAdminRights(permission);
var builder = EmbedBuilderHelper.GreenBuilder();
builder.AddField(x => {
x.Name = "Setting: Create Raid Permission";
x.Value = $"Setting has been changed to: {permissionLevel}";
x.IsInline = false;
});
await dmChannel.SendMessageAsync("", false, builder.Build());
}
public ModuleResult LeaveRaid(string raidName, IUser requesterUser, IUser userToUpdate)
{
var result = new ModuleResult();
var raids = _raidFileService.GetRaidsFromFile().Where(a => a.Name.Equals(raidName, StringComparison.CurrentCultureIgnoreCase));
var userFilteredRaids = raids.Where(a => a.Users.Any(b => b.Equals(User.FromIUser(requesterUser))));
if (userFilteredRaids.Count() == 1)
{
return(RemoveUserFromRaid(userFilteredRaids.First(), requesterUser, userToUpdate));
}
else if (raids.Count() == 0)
{
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder("Could not find that raid");
}
else if (userFilteredRaids.Count() == 0)
{
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder("Could not find the user in that raid");
}
else
{
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder("Somthing went wrong");
}
return(result);
}
public ModuleResult MessageUsers(string raidName, string message)
{
var result = new ModuleResult();
var raids = _raidFileService.GetRaidsFromFile().Where(a => a.Name.Equals(raidName, StringComparison.CurrentCultureIgnoreCase));
if (raids.Count() == 1)
{
result.Users = raids.Single().Users;
result.Success = true;
result.RequesterUserBuilder = EmbedBuilderHelper.GreenBuilder();
result.RequesterUserBuilder.AddField(x => {
x.Name = $"Raid: {raidName}";
x.Value = message;
x.IsInline = false;
});
}
else if (raids.Count() == 0)
{
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder("Cannot find raid");
}
else
{
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder("Unknown Error");
}
return(result);
}
public ModuleResult GetSpecificRaid(string raidName)
{
var result = new ModuleResult();
var raids = _raidFileService.GetRaidsFromFile().Where(a => a.Name.Equals(raidName, StringComparison.CurrentCultureIgnoreCase));
if (raids.Count() == 1)
{
var raid = raids.Single();
result.Success = true;
result.RequesterUserBuilder = EmbedBuilderHelper.BlueBuilder();
result.RequesterUserBuilder.WithThumbnailUrl(string.Format(PokemonUrlHelpers.getPokemonUrl(raid.RaidBossId), raid.RaidBossId));
result.RequesterUserBuilder.AddField(x => {
x.Name = $"Raid: {raid.ToString()}";
x.Value = raid.ToStringUsers();
x.IsInline = false;
});
}
else if (raids.Count() == 0)
{
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder("Could not find that raid");
}
else
{
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder("Unknown Error");
}
return(result);
}
/// <summary>
/// Méthode de prise en charge de la commande uptime
/// </summary>
/// <param name="channel"></param>
/// <param name="user"></param>
public void UptimeAsync(IMessageChannel channel, IUser user)
{
var processStartTime = Process.GetCurrentProcess().StartTime;
TimeSpan uptime = DateTime.Now - processStartTime;
string description = "";
if (uptime.Days != 0)
{
description += $"{uptime.Days} jour" + (uptime.Days == 1 ? "" : "s") + ", ";
}
if (uptime.Hours != 0)
{
description += $"{uptime.Hours} heure" + (uptime.Hours == 1 ? "" : "s") + ", ";
}
if (uptime.Minutes != 0)
{
description += $"{uptime.Minutes} minute" + (uptime.Minutes == 1 ? "" : "s") + ", ";
}
description += $"{uptime.Seconds} seconde" + (uptime.Seconds > 1 ? "s" : "");
var builder = EmbedBuilderHelper.EmbedBuilderUptime(description);
Reply("", builder);
}
public ModuleResult CreateRaid(string raidName, IUser user)
{
ModuleResult result = new ModuleResult();
var now = DateTime.Now;
Raid raid = new Raid()
{
Name = raidName,
Users = new List <User>(),
CreateDateTime = now,
ExpireStart = now,
Expire = TimeSpan.FromMinutes(_permissions.AutoExpireMins)
};
if (_permissions.JoinRaidOnCreate)
{
raid.Users.Add(User.FromIUser(user));
}
bool success = AddRaids(raid);
if (success)
{
result.Success = true;
result.RequesterUserBuilder = EmbedBuilderHelper.GreenBuilder();
result.RequesterUserBuilder
.WithTitle("Raid succesfully created:")
.WithDescription(raid.ToString());
}
else
{
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder("Raid already exists. Please join or create a different raid.");
}
return(result);
}
public async Task <ModuleResult> CreateRaid(string raidName, string raidTime, string raidBoss, IUser user, int guests)
{
ModuleResult result = new ModuleResult();
int raidBossId;
string raidBossName;
string raidBossSpriteUrl;
try {
(raidBossId, raidBossName, raidBossSpriteUrl) = await Mons.GetMonInfo(raidBoss);
}
catch (Exception e) {
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder("Cannot recognise raid boss. Check your spelling!");
return(result);
}
var now = DateTime.Now;
raidTime = raidTime.Replace(".", ":").Replace(",", ":").Replace(";", ":");
DateTime time;
if (DateTime.TryParseExact(raidTime, "H:mm", CultureInfo.InvariantCulture, DateTimeStyles.None, out time))
{
Raid raid = new Raid()
{
Name = raidName,
Time = time,
Users = new List <User>(),
CreateDateTime = now,
ExpireStart = now,
Expire = TimeSpan.FromMinutes(_permissions.AutoExpireMins),
RaidBossId = raidBossId,
RaidBossName = raidBossName,
RaidBossSpriteUrl = raidBossSpriteUrl
};
if (_permissions.JoinRaidOnCreate)
{
raid.Users.Add(User.FromIUser(user, guests));
}
bool success = AddRaids(raid);
if (success)
{
result.Success = true;
result.RequesterUserBuilder = EmbedBuilderHelper.GreenBuilder();
result.RequesterUserBuilder
.WithTitle("Raid succesfully created:")
.WithDescription(raid.ToString())
.WithThumbnailUrl(raidBossSpriteUrl);
}
else
{
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder("Raid already exists. Please join or create a different raid.");
}
}
else
{
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder("I do not understand that time. Try using a format of Hours:Mins e.g. `11:30`");
}
return(result);
}
public async Task Uptime()
{
var uptime = ServerTimerService.GetServerUptime();
var sb = new StringBuilder();
sb.AppendLine(String.Format("Uptime : {0}", uptime));
var embed = EmbedBuilderHelper.BuildEmbed("Server Uptime", sb.ToString(), DateTime.Now.ToLongTimeString(), "blue");
await Context.Channel.SendMessageAsync(null, false, embed);
}
/// <summary>
/// Méthode de prise en charge de la commande rps
/// </summary>
/// <param name="channel"></param>
/// <param name="user"></param>
/// <param name="userChoice"></param>
public void RpsAsync(IMessageChannel channel, IUser user, string userChoice)
{
var builder = EmbedBuilderHelper.EmbedBuilderInformation(user)
.WithTitle("Rps command")
.WithDescription("Pierre Feuille Ciseaux")
.AddField("Usage", "!rps [choice]")
.AddField("Parameters", "Pierre :punch:\nFeuille :hand_splayed:\nCiseaux :v:");
// Vérification des paramètres
if (userChoice == null)
{
Reply("", builder);
return;
}
bool exists = false;
foreach (var choice in RpsHelper.PossibleValues)
{
if (choice.ToLower().Equals(userChoice.ToLower()))
{
exists = true;
}
}
if (!exists)
{
Reply("", builder);
return;
}
// Comportement
Random rnd = new Random();
string botChoice = RpsHelper.PossibleValues[rnd.Next(0, 3)];
if (botChoice.ToLower().Equals(userChoice.ToLower()))
{
Reply($"{user.Mention} a choisi ***{botChoice}***, je choisi ***{botChoice}***\nEgalité !");
return;
}
string sChoice = "";
if (userChoice.ToLower().Equals(RpsHelper.Rock))
{
sChoice += RpsHelper.ChoiceChecker[RpsHelper.Rock](user, botChoice);
}
else if (userChoice.ToLower().Equals(RpsHelper.Paper))
{
sChoice += RpsHelper.ChoiceChecker[RpsHelper.Paper](user, botChoice);
}
else
{
sChoice += RpsHelper.ChoiceChecker[RpsHelper.Scissors](user, botChoice);
}
Reply(sChoice);
}
public ModuleResult ChangeTime(string raidName, string raidTime, IGuildUser user)
{
var result = new ModuleResult();
raidTime = raidTime.Replace(".", ":").Replace(",", ":").Replace(";", ":");
DateTime time;
if (DateTime.TryParseExact(raidTime, "H:mm", CultureInfo.InvariantCulture, DateTimeStyles.None, out time))
{
if (time > DateTime.Now.AddHours(_permissions.TimeZone))
{
var raids = _raidFileService.GetRaidsFromFile().Where(a => a.Name.Equals(raidName, StringComparison.CurrentCultureIgnoreCase));
if (raids.Count() == 1)
{
var raid = raids.Single();
if (user.GuildPermissions.Has(GuildPermission.ManageMessages) || raid.Users.FirstOrDefault().Equals(User.FromIUser(user)))
{
result.Users = raid.Users;
var allRaids = _raidFileService.GetRaidsFromFile();
allRaids.Single(a => a.Equals(raid)).Time = time;
_raidFileService.PushRaidsToFile(allRaids);
result.Success = true;
result.RequesterUserBuilder = EmbedBuilderHelper.GreenBuilder();
result.RequesterUserBuilder.AddField(x => {
x.Name = $"Raid: {raidName}";
x.Value = $"Time has been changed to {time.ToString("H:mm")}";
x.IsInline = false;
});
}
else
{
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder("Only the leader can delete a raid");
}
}
else if (raids.Count() == 0)
{
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder("Cannot find raid");
}
else
{
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder("Unknown Error");
}
}
else
{
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder("That time has already passed. Please choose a different time.");
}
}
else
{
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder("I do not understand that time. Try using a format of Hours:Mins e.g. `11:30`");
}
return(result);
}
public ModuleResult JoinRaid(string raidName, IUser forUser, int guests, IUser requestUser = null)
{
ModuleResult result = new ModuleResult();
var raids = _raidFileService.GetRaidsFromFile().Where(a => a.Name.Equals(raidName, StringComparison.CurrentCultureIgnoreCase));
if (raids.Count() == 1)
{
bool success = AddUserToRaidIfNotExists(raids.Single(), forUser, guests);
if (success)
{
result.Success = true;
if (requestUser != null)
{
result.RequesterUserBuilder = EmbedBuilderHelper.GreenBuilder();
string withGuests = guests == 0 ? string.Empty : $"with {guests} guests";
result.RequesterUserBuilder.AddField(x => {
x.Name = $"Raid: {raidName}";
x.Value = $"You have added {forUser.Username} to the raid {withGuests}";
x.IsInline = false;
});
result.ReferenceUserBuilder = EmbedBuilderHelper.GreenBuilder();
result.ReferenceUserBuilder.AddField(x => {
x.Name = $"Raid: {raidName}";
x.Value = $"You have been added to the raid by {requestUser.Username} {withGuests}";
x.IsInline = false;
});
}
else
{
result.RequesterUserBuilder = EmbedBuilderHelper.GreenBuilder();
result.RequesterUserBuilder.AddField(x => {
x.Name = $"Raid: {raidName}";
x.Value = $"You have been added to the raid";
x.IsInline = false;
});
}
}
else
{
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder("User is already in the raid");
}
}
else if (raids.Count() == 0)
{
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder("Cannot find raid");
}
else
{
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder("Unknown Error");
}
return(result);
}
public EmbedBuilder GetRaids()
{
var raids = _raidFileService.GetRaidsFromFile();
if (raids.Count() == 0)
{
return(EmbedBuilderHelper.ErrorBuilder("No raids have been created yet"));
}
return(EmbedBuilderHelper.RaidEmbedBuilder("All current raids:", raids));
}
/// <summary>
/// Méthode de prise en charge de la commande help
/// </summary>
/// <param name="commands"></param>
/// <param name="provider"></param>
/// <param name="guild"></param>
/// <param name="user"></param>
public void HelpAsync(CommandService commands, IServiceProvider provider, IGuild guild, IUser user)
{
var builder = EmbedBuilderHelper.EmbedBuilderUptime(null, "Help");
foreach (var module in commands.Modules)
{
}
Reply($"", builder);
}
/// <summary>
/// Méthode de prise en charge de la commande membercount
/// </summary>
/// <param name="channel"></param>
/// <param name="user"></param>
public async void MembercountAsync(IGuild guild, IUser user)
{
var builder = EmbedBuilderHelper.EmbedBuilderInformation(user)
.WithTitle("Membercount command")
.AddField("Membres", await InformationHelper.GetNbUsers(guild), true)
.AddField("En ligne", await InformationHelper.GetNbOnline(guild), true)
.AddField("Humains", await InformationHelper.GetNbHumans(guild), true)
.AddField("Bots", await InformationHelper.GetNbBots(guild), true);
Reply("", builder);
}
public ModuleResult JoinRaid(string raidName, IUser forUser, int guests, bool isRemote, IUser requestUser = null)
{
ModuleResult result = new ModuleResult();
var raids = _raidFileService.GetRaidsFromFile().Where(a => a.Name.Equals(raidName, StringComparison.CurrentCultureIgnoreCase));
if (raids.Count() == 1)
{
bool success = AddUserToRaidIfNotExists(raids.Single(), forUser, guests, isRemote);
if (success)
{
result.Success = true;
result.RequesterUserBuilder = EmbedBuilderHelper.GreenBuilder();
string withGuests = guests == 0 ? string.Empty : $"with {guests} guest{(guests == 1 ? "" : "s")}";
string asRemoteAttendee = isRemote ? " as a remote attendee" : string.Empty;
if (requestUser != null)
{
var forUserUsername = (forUser as IGuildUser).Nickname ?? forUser.Username;
var requestUserUsername = (requestUser as IGuildUser).Nickname ?? requestUser.Username;
result.RequesterUserBuilder
.WithTitle($"Raid: {raidName}")
.WithDescription($"You have added {forUserUsername} to the raid{asRemoteAttendee} {withGuests}");
result.ReferenceUserBuilder = EmbedBuilderHelper.GreenBuilder();
result.ReferenceUserBuilder
.WithTitle($"Raid: {raidName}")
.WithDescription($"You have been added to the raid{asRemoteAttendee} by {requestUserUsername} {withGuests}");
}
else
{
result.RequesterUserBuilder
.WithTitle($"Raid: {raidName}")
.WithDescription($"You have been added to the raid{asRemoteAttendee}");
}
}
else
{
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder("User is already in the raid");
}
}
else if (raids.Count() == 0)
{
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder("Cannot find raid");
}
else
{
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder("Unknown Error");
}
return(result);
}
public async Task AutoDeleteRaid([Summary("Minutes")] int mins)
{
var dmChannel = await Context.User.GetOrCreateDMChannelAsync();
_permissionService.SetAutoDeleteRaid(mins);
var builder = EmbedBuilderHelper.GreenBuilder();
builder.WithTitle("Setting: AutoDeleteRaid").WithDescription($"Setting has been changed to: {mins} mins");
await dmChannel.SendMessageAsync("", false, builder.Build());
}
public async Task JoinRaidOnCreate([Summary("True or false")] bool shouldJoin)
{
var dmChannel = await Context.User.GetOrCreateDMChannelAsync();
_permissionService.SetJoinRaidOnCreatePermission(shouldJoin);
var builder = EmbedBuilderHelper.GreenBuilder();
builder.WithTitle("Setting: Should Join Raid On Raid Creation").WithDescription($"Setting has been changed to: {shouldJoin}");
await dmChannel.SendMessageAsync("", false, builder.Build());
}
public async Task GetSettings()
{
var dmChannel = await Context.User.GetOrCreateDMChannelAsync();
ServerSettings settings = _permissionService.GetSettings();
var builder = EmbedBuilderHelper.GreenBuilder();
builder.WithTitle("Current Settings:").WithDescription(settings.ToString());
await dmChannel.SendMessageAsync("", false, builder.Build());
}
public async Task Roll()
{
string[] reply = UserMessageHandler.EightBall().Split(",");
var user = Context.Message.Author.Username;
var dieOne = reply[0];
var dieTwo = reply[1];
var sb = new StringBuilder();
sb.Append(String.Format("{0} rolled [{1}:game_die: {2}:game_die:]", user, dieOne, dieTwo));
var embed = EmbedBuilderHelper.BuildEmbed("Dice", sb.ToString(), DateTime.Now.ToLongTimeString(), "darkorange");
await Context.Channel.SendMessageAsync(null, false, embed);
}
public ModuleResult ChangeAttendanceMode(string raidName, IUser requesterUser, IUser userToUpdate)
{
var result = new ModuleResult();
var raids = _raidFileService.GetRaidsFromFile().Where(a => a.Name.Equals(raidName, StringComparison.CurrentCultureIgnoreCase));
if (raids.Count() == 1)
{
var raid = raids.Single();
if (userToUpdate == null)
{
var user = raid.Users.Single(a => a.Equals(User.FromIUser(requesterUser)));
user.IsRemoteAttendee = !user.IsRemoteAttendee;
UpdateRaidWithDifferentUsers(raid);
result.Success = true;
result.RequesterUserBuilder = EmbedBuilderHelper.GreenBuilder();
result.RequesterUserBuilder
.WithTitle($"Raid: {raidName}")
.WithDescription($"Updated attendance mode to {(user.IsRemoteAttendee == true ? "remote" : "in person")}");
}
else
{
var user = raid.Users.Single(a => a.Equals(User.FromIUser(userToUpdate)));
user.IsRemoteAttendee = !user.IsRemoteAttendee;
UpdateRaidWithDifferentUsers(raid);
result.Success = true;
var userToUpdateUsername = (userToUpdate as IGuildUser).Nickname ?? userToUpdate.Username;
var requesterUserUsername = (requesterUser as IGuildUser).Nickname ?? requesterUser.Username;
result.RequesterUserBuilder = EmbedBuilderHelper.GreenBuilder();
result.RequesterUserBuilder
.WithTitle($"Raid: {raidName}")
.WithDescription($"Updated attendance mode to {(user.IsRemoteAttendee == true ? "remote" : "in person")} for {userToUpdateUsername}");
result.ReferenceUserBuilder = EmbedBuilderHelper.GreenBuilder();
result.ReferenceUserBuilder
.WithTitle($"Raid: {raidName}")
.WithDescription($"{requesterUserUsername} has updated your attendance mode to {(user.IsRemoteAttendee == true ? "remote" : "in person")}");
}
}
else if (raids.Count() == 0)
{
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder("Cannot find raid");
}
else
{
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder("Unknown Error");
}
return(result);
}
private async Task <bool> CheckPermission(IGuildUser requesterUser, ServerSettings serverPermissions)
{
var application = await Context.Client.GetApplicationInfoAsync();
if (serverPermissions.AdminRights != null && !requesterUser.GuildPermissions.Has(serverPermissions.AdminRights.Value) && requesterUser.Id != application.Owner.Id)
{
var dmChannelUser = await requesterUser.GetOrCreateDMChannelAsync();
EmbedBuilder builder = EmbedBuilderHelper.ErrorBuilder("You do not have permission to do that!");
await dmChannelUser.SendMessageAsync("", false, builder.Build());
return(false);
}
return(true);
}
public ModuleResult ChangeDate(string raidName, string raidDate, IGuildUser user)
{
var result = new ModuleResult();
DateTime date;
if (DateTime.TryParseExact(raidDate, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out date))
{
var raids = _raidFileService.GetRaidsFromFile().Where(a => a.Name.Equals(raidName, StringComparison.CurrentCultureIgnoreCase));
if (raids.Count() == 1)
{
var raid = raids.Single();
if (user.GuildPermissions.Has(GuildPermission.ManageMessages) || raid.Users.FirstOrDefault().Equals(User.FromIUser(user)))
{
result.Users = raid.Users;
var allRaids = _raidFileService.GetRaidsFromFile();
allRaids.Single(a => a.Equals(raid)).Day = date;
_raidFileService.PushRaidsToFile(allRaids);
result.Success = true;
result.RequesterUserBuilder = EmbedBuilderHelper.GreenBuilder();
result.RequesterUserBuilder.AddField(x => {
x.Name = $"Raid: {raidName}";
x.Value = $"Date has been changed to {date.ToString("yyyy'-'MM'-'dd")}\nPlease note you will need to change the expire seperately";
x.IsInline = false;
});
}
else
{
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder("Only the leader can change the date");
}
}
else if (raids.Count() == 0)
{
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder("Cannot find raid");
}
else
{
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder("Unknown Error");
}
}
else
{
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder("I do not understand that date. Try using a format of year-month-day e.g.`2018-04-28`");
}
return(result);
}
public async Task AutoDeleteRaid([Summary("Minutes")] int mins)
{
var dmChannel = await Context.User.GetOrCreateDMChannelAsync();
_permissionService.SetAutoDeleteRaid(mins);
var builder = EmbedBuilderHelper.GreenBuilder();
builder.AddField(x => {
x.Name = "Setting: AutoDeleteRaid";
x.Value = $"Setting has been changed to: {mins} mins";
x.IsInline = false;
});
await dmChannel.SendMessageAsync("", false, builder.Build());
}
public async Task SetTimeZone([Summary("TimeZone you are located using + or - e.g. -4")] int timeZone)
{
var dmChannel = await Context.User.GetOrCreateDMChannelAsync();
_permissionService.SetTimeZone(timeZone);
var builder = EmbedBuilderHelper.GreenBuilder();
builder.AddField(x => {
x.Name = "Setting: TimeZone";
x.Value = $"Setting has been changed to: {timeZone}";
x.IsInline = false;
});
await dmChannel.SendMessageAsync("", false, builder.Build());
}
public async Task JoinRaidOnCreate([Summary("True or false")] bool shouldJoin)
{
var dmChannel = await Context.User.GetOrCreateDMChannelAsync();
_permissionService.SetJoinRaidOnCreatePermission(shouldJoin);
var builder = EmbedBuilderHelper.GreenBuilder();
builder.AddField(x => {
x.Name = "Setting: Should Join Raid On Raid Creation";
x.Value = $"Setting has been changed to: {shouldJoin}";
x.IsInline = false;
});
await dmChannel.SendMessageAsync("", false, builder.Build());
}
public ModuleResult AddGuests(string raidName, IUser userToAddGuests, int guests, IUser requestUser = null)
{
var result = new ModuleResult();
var raids = _raidFileService.GetRaidsFromFile().Where(a => a.Name.Equals(raidName, StringComparison.CurrentCultureIgnoreCase));
if (raids.Count() == 1)
{
var raid = raids.Single();
raid.Users.Single(a => a.Equals(User.FromIUser(userToAddGuests))).GuestsCount = guests;
UpdateRaidWithDifferentUsers(raid);
result.Success = true;
if (userToAddGuests == null)
{
result.RequesterUserBuilder = EmbedBuilderHelper.GreenBuilder();
result.RequesterUserBuilder.AddField(x => {
x.Name = $"Raid: {raidName}";
x.Value = $"Added {guests} guests";
x.IsInline = false;
});
}
else
{
result.ReferenceUserBuilder = EmbedBuilderHelper.GreenBuilder();
result.ReferenceUserBuilder.AddField(x => {
x.Name = $"Raid: {raidName}";
x.Value = $"Added {guests} guests for {userToAddGuests.Username}";
x.IsInline = false;
});
result.RequesterUserBuilder = EmbedBuilderHelper.GreenBuilder();
result.RequesterUserBuilder.AddField(x => {
x.Name = $"Raid: {raidName}";
x.Value = $"{requestUser} has added {guests} guests to the raid for you.";
x.IsInline = false;
});
}
}
else if (raids.Count() == 0)
{
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder("Cannot find raid");
}
else
{
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder("Unknown Error");
}
return(result);
}
/// <summary>
/// Méthode de prise en charge de la commande almanax
/// </summary>
/// <param name="channel"></param>
/// <param name="user"></param>
/// <param name="date"></param>
public void AlmanaxAsync(IMessageChannel channel, IUser user, string date = null)
{
if (date == null)
{
date = DateTime.Today.Day.ToString("D2") + "/" + DateTime.Today.Month.ToString("D2");
}
Almanax almanax = JsonHelper.GetAlmanax(date);
var builder = EmbedBuilderHelper.EmbedBuilderInformation(user)
.WithThumbnailUrl("https://almanax.ordre2vlad.fr/images/items/" + almanax.ItemImage + ".png")
.WithTitle("Almanax command")
.AddField(almanax.Quest.Split(" : ")[0], almanax.Quest.Split(" : ")[1])
.AddField(almanax.Type, almanax.Effect)
.AddField("Offrande", almanax.Offering);
Reply("", builder);
}
public async Task GetSettings()
{
var dmChannel = await Context.User.GetOrCreateDMChannelAsync();
ServerSettings settings = _permissionService.GetSettings();
var builder = EmbedBuilderHelper.GreenBuilder();
builder.AddField(x => {
x.Name = "Current Settings:";
x.Value = settings.ToString();
x.IsInline = false;
});
await dmChannel.SendMessageAsync("", false, builder.Build());
}
