public async Task CanCreateGuild_SuccessTest()
{
var config = new GuildConfiguration()
{
MinMembers = 2
};
var character1 = CreateCharacter(testMap);
var character2 = CreateCharacter(testMap);
var party = new Party();
character1.SetParty(party);
character2.SetParty(party);
var database = new Mock <IDatabase>();
database.Setup(x => x.Characters.FindAsync(character1.Id)).ReturnsAsync(new DbCharacter());
database.Setup(x => x.Characters.FindAsync(character2.Id)).ReturnsAsync(new DbCharacter());
var guildManager = new GuildManager(guildLoggerMock.Object, config, new GuildHouseConfiguration(), database.Object, gameWorldMock.Object, timeMock.Object);
var result = await guildManager.CanCreateGuild(character1, "guild_name");
Assert.Equal(GuildCreateFailedReason.Success, result);
}
public static GuildConfiguration Set(ulong guildId, string prefix, bool enablePrimaryPrefix = true,
bool enableXpSystem = false)
{
var guildconfig = new GuildConfiguration
{
GuildId = guildId,
EnablePrimaryPrefix = enablePrimaryPrefix,
Prefix = prefix,
EnableXpSystem = enableXpSystem
};
bool contains = GuildConfigs.GuildConfigs.Any(gc => gc.GuildId == guildId);
if (contains)
{
GuildConfigs.GuildConfigs.ForEach(gc =>
{
if (gc.GuildId == guildconfig.GuildId)
{
gc.Prefix = guildconfig.Prefix;
gc.EnablePrimaryPrefix = guildconfig.EnablePrimaryPrefix;
gc.EnableXpSystem = guildconfig.EnableXpSystem;
}
});
}
else
{
GuildConfigs.GuildConfigs.Add(guildconfig);
}
WriteOut();
return(guildconfig);
}
public static void WriteOut()
{
var dirs = Directory.GetDirectories(Information.Directory);
foreach (string dir in dirs)
{
string dirName = Path.GetFileName(dir);
if (ulong.TryParse(dirName, out ulong guildId))
{
string config = Path.Combine(dir, "guildconfig.json");
if (!File.Exists(config))
{
File.Create(config).Dispose();
}
var guildconfig =
GuildConfigs.GuildConfigs.FirstOrDefault(gc => gc.GuildId == guildId);
if (guildconfig == default(GuildConfiguration))
{
guildconfig = new GuildConfiguration
{
EnablePrimaryPrefix = true,
GuildId = guildId,
Prefix = Information.SecondaryPrefix
}
}
;
File.WriteAllText(config, JsonConvert.SerializeObject(guildconfig));
}
}
}
}
public void SendGuildRequest_PartyChangeTest()
{
var config = new GuildConfiguration()
{
MinMembers = 2
};
var character1 = CreateCharacter(testMap);
var character2 = CreateCharacter(testMap);
var party = new Party();
character1.SetParty(party);
character2.SetParty(party);
var guildManager = new GuildManager(guildLoggerMock.Object, config, new GuildHouseConfiguration(), databaseMock.Object, gameWorldMock.Object, timeMock.Object);
guildManager.SendGuildRequest(character1, "guild_name", "guild_message");
Assert.NotEmpty(GuildManager.CreationRequests);
Assert.True(GuildManager.CreationRequests.ContainsKey(party));
character2.SetParty(null);
Assert.Empty(GuildManager.CreationRequests);
Assert.False(GuildManager.CreationRequests.ContainsKey(party));
}
public async Task DeleteGuildConfiguration(GuildConfiguration guildConfiguration)
{
using (var connection = new MySqlConnection(_configuration["ConnectionStrings:CouchBot"]))
{
await connection.OpenAsync();
await connection.DeleteAsync(guildConfiguration);
}
}
public static void Init()
{
if (GuildConfigs == null)
{
GuildConfigs = new GuildConfigurations();
}
var dirs = Directory.GetDirectories(Information.Directory);
ConsoleHelper.Log($"Loading {dirs.Length} Guild configuration files..", LogSeverity.Info);
int loaded = 0;
foreach (string dir in dirs)
{
string dirName = Path.GetFileName(dir);
if (ulong.TryParse(dirName, out ulong guildId))
{
// is it a valid Guild _data Directory?
string config = Path.Combine(dir, "guildconfig.json");
if (!File.Exists(config))
{
//create
File.Create(config).Dispose();
var guildconfig = new GuildConfiguration
{
GuildId = guildId
};
if (!GuildConfigs.GuildConfigs.Contains(guildconfig))
{
GuildConfigs.GuildConfigs.Add(guildconfig);
}
else
{
GuildConfigs.GuildConfigs.ForEach(gc =>
{
if (gc.GuildId == guildconfig.GuildId)
{
gc.Prefix = guildconfig.Prefix;
gc.EnablePrimaryPrefix = guildconfig.EnablePrimaryPrefix;
}
});
}
File.WriteAllText(config, JsonConvert.SerializeObject(guildconfig));
}
else
{
//load
string serialized = File.ReadAllText(config);
GuildConfigs.GuildConfigs.Add(JsonConvert.DeserializeObject <GuildConfiguration>(serialized));
loaded++;
}
}
}
ConsoleHelper.Log($"{loaded}/{dirs.Length} guild configuration files loaded!", LogSeverity.Info);
}
/// <summary>
/// Main method where actual guild processing occurs.
/// </summary>
private async Task<PGDiagnostic> ProcessGuildAsync(SocketGuild guild)
{
var diag = new PGDiagnostic();
// Load guild information - stop if there is none (bot never previously used in guild)
var gc = await GuildConfiguration.LoadAsync(guild.Id, true).ConfigureAwait(false);
if (gc == null) return diag;
// Check if role settings are correct before continuing with further processing
SocketRole role = null;
if (gc.RoleId.HasValue) role = guild.GetRole(gc.RoleId.Value);
diag.RoleCheck = CheckCorrectRoleSettings(guild, role);
if (diag.RoleCheck != null) return diag;
// Determine who's currently having a birthday
var users = await GuildUserConfiguration.LoadAllAsync(guild.Id).ConfigureAwait(false);
var tz = gc.TimeZone;
var birthdays = GetGuildCurrentBirthdays(users, tz);
// Note: Don't quit here if zero people are having birthdays. Roles may still need to be removed by BirthdayApply.
diag.CurrentBirthdays = birthdays.Count.ToString();
IEnumerable<SocketGuildUser> announcementList;
// Update roles as appropriate
try
{
var updateResult = await UpdateGuildBirthdayRoles(guild, role, birthdays).ConfigureAwait(false);
announcementList = updateResult.Item1;
diag.RoleApplyResult = updateResult.Item2; // statistics
}
catch (Discord.Net.HttpException ex)
{
diag.RoleApply = ex.Message;
return diag;
}
diag.RoleApply = null;
// Birthday announcement
var announce = gc.AnnounceMessages;
var announceping = gc.AnnouncePing;
SocketTextChannel channel = null;
if (gc.AnnounceChannelId.HasValue) channel = guild.GetTextChannel(gc.AnnounceChannelId.Value);
if (announcementList.Count() != 0)
{
var announceResult =
await AnnounceBirthdaysAsync(announce, announceping, channel, announcementList).ConfigureAwait(false);
diag.Announcement = announceResult;
}
else
{
diag.Announcement = "No new role additions. Announcement not needed.";
}
return diag;
}
public static GuildConfiguration GetGuildConfiguration(this DatabaseContext db, ulong guildId)
{
GuildConfiguration config = db.GuildConfigurations.FirstOrDefault(x => x.GuildId == guildId);
if (config is null)
{
config = new GuildConfiguration(guildId);
db.GuildConfigurations.Add(config);
db.SaveChanges();
}
return(config);
}
public async Task CanCreateGuild_MinMembersTest()
{
var config = new GuildConfiguration()
{
MinMembers = 2
};
var guildManager = new GuildManager(guildLoggerMock.Object, config, new GuildHouseConfiguration(), databaseMock.Object, gameWorldMock.Object, timeMock.Object, inventoryMock.Object, partyMock.Object, countryMock.Object, etinMock.Object);
var result = await guildManager.CanCreateGuild("guild_name");
Assert.Equal(GuildCreateFailedReason.NotEnoughMembers, result);
}
public string GetCommandPrefix(GuildConfiguration guildConfiguration)
{
var prefix = _appConfiguration.DefaultCommandPrefix;
if (guildConfiguration != null)
{
if (!string.IsNullOrWhiteSpace(guildConfiguration.CommandPrefix))
{
prefix = guildConfiguration.CommandPrefix;
}
}
return(prefix);
}
public async Task CanCreateGuild_MinGoldTest()
{
var config = new GuildConfiguration()
{
MinGold = 10
};
var character = CreateCharacter();
var guildManager = new GuildManager(guildLoggerMock.Object, config, new GuildHouseConfiguration(), databaseMock.Object, gameWorldMock.Object, timeMock.Object);
var result = await guildManager.CanCreateGuild(character, "guild_name");
Assert.Equal((uint)0, character.Gold);
Assert.Equal(GuildCreateFailedReason.NotEnoughGold, result);
}
/// <inheritdoc />
public void ConfigureServices(IServiceCollection services)
{
// Add options.
services.AddOptions <WorldConfiguration>()
.Configure <IConfiguration>((settings, configuration) => configuration.GetSection("WorldServer").Bind(settings));
services.AddOptions <DatabaseConfiguration>()
.Configure <IConfiguration>((settings, configuration) => configuration.GetSection("Database").Bind(settings));
services.AddOptions <InterServerConfig>()
.Configure <IConfiguration>((settings, configuration) => configuration.GetSection("InterServer").Bind(settings));
services.AddOptions <GuildConfiguration>()
.Configure <IConfiguration>((settings, configuration) => configuration.GetSection("Game:Guild").Bind(settings));
services.RegisterDatabaseServices();
services.AddSingleton <IInterServerClient, ISClient>();
services.AddSingleton <IWorldServer, WorldServer>();
services.AddSingleton <IGameWorld, GameWorld>();
services.AddSingleton <ISelectionScreenFactory, SelectionScreenFactory>();
services.AddSingleton <IMapsLoader, MapsLoader>();
services.AddSingleton <IMapFactory, MapFactory>();
services.AddSingleton <IMobFactory, MobFactory>();
services.AddSingleton <INpcFactory, NpcFactory>();
services.AddSingleton <IObeliskFactory, ObeliskFactory>();
services.AddSingleton <ICharacterFactory, CharacterFactory>();
services.AddSingleton <ICharacterConfiguration, CharacterConfiguration>((x) => CharacterConfiguration.LoadFromConfigFile());
services.AddSingleton <IGuildConfiguration, GuildConfiguration>((x) => GuildConfiguration.LoadFromConfigFile());
services.AddSingleton <IGuildHouseConfiguration, GuildHouseConfiguration>((x => GuildHouseConfiguration.LoadFromConfigFile()));
services.AddSingleton <IDatabasePreloader, DatabasePreloader>((x) =>
{
using (var scope = x.CreateScope())
{
var logger = scope.ServiceProvider.GetRequiredService <ILogger <DatabasePreloader> >();
var db = scope.ServiceProvider.GetRequiredService <IDatabase>();
return(new DatabasePreloader(logger, db));
}
});
services.AddSingleton <IChatManager, ChatManager>();
services.AddSingleton <INoticeManager, NoticeManager>();
services.AddSingleton <IGuildRankingManager, GuildRankingManager>();
services.AddTransient <ILogsDatabase, LogsDbContext>();
services.AddTransient <ILinkingManager, LinkingManager>();
services.AddTransient <IDyeingManager, DyeingManager>();
services.AddTransient <IGuildManager, GuildManager>();
services.AddTransient <ITimeService, TimeService>();
services.AddSingleton <IBackgroundTaskQueue, BackgroundTaskQueue>();
services.AddHostedService <DatabaseWorker>();
}
public DateTimeZone GetChannelDateTimeZone(GuildConfiguration guildConfiguration, string channelName)
{
var defaultZone = _appConfiguration.Timezone;
var channelConfigurations = GetChannelConfigurations(guildConfiguration, channelName);
var channelZone = channelConfigurations.FirstOrDefault(e => !string.IsNullOrWhiteSpace(e.Timezone));
if (channelZone != null)
{
return(DateTimeZoneProviders.Tzdb[channelZone.Timezone]);
}
if (defaultZone != null)
{
return(DateTimeZoneProviders.Tzdb[defaultZone]);
}
return(DateTimeZone.Utc);
}
public async Task CanCreateGuild_MinGoldTest()
{
var config = new GuildConfiguration()
{
MinGold = 10
};
var inventory = inventoryMock;
inventory.Setup(x => x.Gold).Returns(0);
var guildManager = new GuildManager(guildLoggerMock.Object, config, new GuildHouseConfiguration(), databaseMock.Object, gameWorldMock.Object, timeMock.Object, inventory.Object, partyMock.Object, countryMock.Object, etinMock.Object);
var result = await guildManager.CanCreateGuild("guild_name");
Assert.Equal((uint)0, inventory.Object.Gold);
Assert.Equal(GuildCreateFailedReason.NotEnoughGold, result);
}
public void SetAgreeRequest_Test()
{
var config = new GuildConfiguration()
{
MinMembers = 2
};
var character1 = CreateCharacter(testMap);
var character2 = CreateCharacter(testMap);
var party = new Party();
character1.SetParty(party);
character2.SetParty(party);
var database = new Mock <IDatabase>();
database.Setup(x => x.Guilds.Add(It.IsAny <DbGuild>()));
database.Setup(x => x.SaveChangesAsync(default)).ReturnsAsync(1);
public async Task CanCreateGuild_AnotherGuildTest()
{
var config = new GuildConfiguration()
{
MinMembers = 2
};
var character1 = CreateCharacter(testMap);
var character2 = CreateCharacter(testMap);
character2.GuildId = 1;
var party = new Party();
character1.SetParty(party);
character2.SetParty(party);
var guildManager = new GuildManager(guildLoggerMock.Object, config, new GuildHouseConfiguration(), databaseMock.Object, gameWorldMock.Object, timeMock.Object);
var result = await guildManager.CanCreateGuild(character1, "guild_name");
Assert.Equal(GuildCreateFailedReason.PartyMemberInAnotherGuild, result);
}
public static GuildConfiguration Set(GuildConfiguration guildconfig)
{
bool contains = GuildConfigs.GuildConfigs.Any(gc => gc.GuildId == guildconfig.GuildId);
if (contains)
{
GuildConfigs.GuildConfigs.ForEach(gc =>
{
if (gc.GuildId == guildconfig.GuildId)
{
gc.Prefix = guildconfig.Prefix;
gc.EnablePrimaryPrefix = guildconfig.EnablePrimaryPrefix;
gc.EnableXpSystem = guildconfig.EnableXpSystem;
}
});
}
else
{
GuildConfigs.GuildConfigs.Add(guildconfig);
}
WriteOut();
return(guildconfig);
}
public async Task CanCreateGuild_PenaltyTest()
{
var config = new GuildConfiguration()
{
MinMembers = 2,
MinPenalty = 2 // 2 hours
};
var character1 = CreateCharacter(testMap);
var character2 = CreateCharacter(testMap);
var party = new Party();
character1.SetParty(party);
character2.SetParty(party);
var time = new Mock <ITimeService>();
time.Setup(x => x.UtcNow)
.Returns(new DateTime(2021, 1, 1, 2, 0, 0)); // 1 Jan 2021 02:00
var database = new Mock <IDatabase>();
database.Setup(x => x.Characters.FindAsync(character1.Id))
.ReturnsAsync(new DbCharacter()
{
Id = character1.Id,
GuildLeaveTime = new DateTime(2021, 1, 1, 1, 0, 0) // 1 Jan 2021 01:00
});
database.Setup(x => x.Characters.FindAsync(character2.Id))
.ReturnsAsync(new DbCharacter());
var guildManager = new GuildManager(guildLoggerMock.Object, config, new GuildHouseConfiguration(), database.Object, gameWorldMock.Object, time.Object);
var result = await guildManager.CanCreateGuild(character1, "guild_name");
Assert.Equal(GuildCreateFailedReason.PartyMemberGuildPenalty, result);
}
public async Task <bool> VerifyUser(Verification verification, GuildConfiguration guild)
{
var botAuthResult = await _app.AcquireTokenForClient(new[] { "https://graph.microsoft.com/.default" }).ExecuteAsync();
var graph = new GraphServiceClient("https://graph.microsoft.com/beta", new GraphAuthenticationProvider(botAuthResult));
try
{
var user = await graph.Users[verification.CorpUserId.ToString()].Request().GetAsync();
if (!user.AccountEnabled ?? false)
{
return(false);
}
if (user.MailNickname.Contains("#EXT#"))
{
return(false);
}
if (guild.RequiresOrganization)
{
var org = GetOrg(verification.CorpUserId.ToString(), guild.Organization, graph);
if (org == null)
{
return(false);
}
}
return(true);
}
catch (ServiceException ex) when(ex.Error.Code == "Request_ResourceNotFound")
{
return(false);
}
}
public IEnumerable <ChannelConfiguration> GetChannelConfigurations(GuildConfiguration guildConfiguration, string channelName)
{
if (guildConfiguration == null)
{
yield break;
}
channelName = channelName.ToLowerInvariant();
var configurations = GetChannelConfigurations(guildConfiguration);
foreach (var configuration in configurations)
{
if (configuration.IsWildcardChannelWithFenceInName)
{
if (channelName.StartsWith(configuration.Name.ToLowerInvariant()))
{
// Add part of the channel name to the fences list
//var fences = configuration.Fences != null ? configuration.Fences.ToList() : new List<string>();
//fences.Add(channelName.Substring(configuration.Name.Length));
//configuration.Fences = fences.Distinct().ToArray();
configuration.Fences = new[] { channelName.Substring(configuration.Name.Length) };
yield return(configuration);
}
}
else
{
if (channelName == configuration.Name.ToLowerInvariant())
{
yield return(configuration);
}
}
}
//var channelSetting = GetChannelConfigurations(guildSetting).FirstOrDefault(e => e.HasRegionConstraint
// ? channelName.StartsWith(e.Name.ToLowerInvariant())
// : channelName == e.Name.ToLowerInvariant());
//return channelSetting;
}
public async Task CanCreateGuild_MinLevelTest()
{
var config = new GuildConfiguration()
{
MinMembers = 2,
MinLevel = 2
};
var character1 = CreateCharacter(testMap);
var character2 = CreateCharacter(testMap);
var party = new Party(packetFactoryMock.Object);
character1.PartyManager.Party = party;
character2.PartyManager.Party = party;
var guildManager = new GuildManager(guildLoggerMock.Object, config, new GuildHouseConfiguration(), databaseMock.Object, gameWorldMock.Object, timeMock.Object, inventoryMock.Object, character1.PartyManager, countryMock.Object, etinMock.Object);
var result = await guildManager.CanCreateGuild("guild_name");
Assert.Equal(1, character1.LevelProvider.Level);
Assert.Equal(1, character2.LevelProvider.Level);
Assert.Equal(GuildCreateFailedReason.LevelLimit, result);
}
/// <inheritdoc />
public void ConfigureServices(IServiceCollection services)
{
// Add options.
services.AddOptions <ImgeneusServerOptions>()
.Configure <IConfiguration>((settings, configuration) => configuration.GetSection("TcpServer").Bind(settings));
services.AddOptions <WorldConfiguration>()
.Configure <IConfiguration>((settings, configuration) => configuration.GetSection("WorldServer").Bind(settings));
services.AddOptions <DatabaseConfiguration>()
.Configure <IConfiguration>((settings, configuration) => configuration.GetSection("Database").Bind(settings));
services.AddOptions <InterServerConfig>()
.Configure <IConfiguration>((settings, configuration) => configuration.GetSection("InterServer").Bind(settings));
services.AddOptions <GuildConfiguration>()
.Configure <IConfiguration>((settings, configuration) => configuration.GetSection("Game:Guild").Bind(settings));
services.RegisterDatabaseServices();
services.AddHandlers();
services.AddSingleton <IInterServerClient, ISClient>();
services.AddSingleton <IWorldServer, WorldServer>();
services.AddSingleton <IGamePacketFactory, GamePacketFactory>();
services.AddSingleton <IGameWorld, GameWorld>();
services.AddSingleton <IGameDefinitionsPreloder, GameDefinitionsPreloder>();
services.AddSingleton <IMapsLoader, MapsLoader>();
services.AddSingleton <IMapFactory, MapFactory>();
services.AddSingleton <IMobFactory, MobFactory>();
services.AddSingleton <INpcFactory, NpcFactory>();
services.AddSingleton <IObeliskFactory, ObeliskFactory>();
services.AddSingleton <ICharacterConfiguration, CharacterConfiguration>((x) => CharacterConfiguration.LoadFromConfigFile());
services.AddSingleton <IGuildConfiguration, GuildConfiguration>((x) => GuildConfiguration.LoadFromConfigFile());
services.AddSingleton <IGuildHouseConfiguration, GuildHouseConfiguration>((x => GuildHouseConfiguration.LoadFromConfigFile()));
services.AddSingleton <IItemEnchantConfiguration, ItemEnchantConfiguration>((x => ItemEnchantConfiguration.LoadFromConfigFile()));
services.AddSingleton <IMoveTownsConfiguration, MoveTownsConfiguration>((x => MoveTownsConfiguration.LoadFromConfigFile()));
services.AddSingleton <IItemCreateConfiguration, ItemCreateConfiguration>((x => ItemCreateConfiguration.LoadFromConfigFile()));
services.AddSingleton <IChatManager, ChatManager>();
services.AddSingleton <INoticeManager, NoticeManager>();
services.AddSingleton <IGuildRankingManager, GuildRankingManager>();
services.AddSingleton <IEtinManager, EtinManager>();
services.AddSingleton <IDatabasePreloader, DatabasePreloader>((x) =>
{
using (var scope = x.CreateScope())
{
var logger = scope.ServiceProvider.GetRequiredService <ILogger <DatabasePreloader> >();
var db = scope.ServiceProvider.GetRequiredService <IDatabase>();
return(new DatabasePreloader(logger, db));
}
});
services.AddScoped <ICharacterFactory, CharacterFactory>();
services.AddScoped <ISelectionScreenManager, SelectionScreenManager>();
services.AddScoped <IGameSession, GameSession>();
services.AddScoped <IStatsManager, StatsManager>();
services.AddScoped <ICountryProvider, CountryProvider>();
services.AddScoped <ILevelProvider, LevelProvider>();
services.AddScoped <ILevelingManager, LevelingManager>();
services.AddScoped <IHealthManager, HealthManager>();
services.AddScoped <ISpeedManager, SpeedManager>();
services.AddScoped <IAttackManager, AttackManager>();
services.AddScoped <ISkillsManager, SkillsManager>();
services.AddScoped <IBuffsManager, BuffsManager>();
services.AddScoped <IElementProvider, ElementProvider>();
services.AddScoped <IInventoryManager, InventoryManager>();
services.AddScoped <IStealthManager, StealthManager>();
services.AddScoped <IKillsManager, KillsManager>();
services.AddScoped <IVehicleManager, VehicleManager>();
services.AddScoped <IShapeManager, ShapeManager>();
services.AddScoped <IMovementManager, MovementManager>();
services.AddScoped <ILinkingManager, LinkingManager>();
services.AddScoped <IAdditionalInfoManager, AdditionalInfoManager>();
services.AddScoped <IMapProvider, MapProvider>();
services.AddScoped <ITeleportationManager, TeleportationManager>();
services.AddScoped <IDyeingManager, DyeingManager>();
services.AddScoped <IPartyManager, PartyManager>();
services.AddScoped <ITradeManager, TradeManager>();
services.AddScoped <IFriendsManager, FriendsManager>();
services.AddScoped <IDuelManager, DuelManager>();
services.AddScoped <IGuildManager, GuildManager>();
services.AddScoped <IBankManager, BankManager>();
services.AddScoped <IQuestsManager, QuestsManager>();
services.AddScoped <IUntouchableManager, UntouchableManager>();
services.AddScoped <IWarehouseManager, WarehouseManager>();
services.AddScoped <IAIManager, AIManager>();
services.AddScoped <IShopManager, ShopManager>();
services.AddScoped <ISkillCastingManager, SkillCastingManager>();
services.AddScoped <ICastProtectionManager, CastProtectionManager>();
services.AddTransient <ICryptoManager, CryptoManager>();
services.AddTransient <ILogsDatabase, LogsDbContext>();
services.AddTransient <ITimeService, TimeService>();
// Add admin website
services.AddRazorPages();
services.AddServerSideBlazor();
services.AddDefaultIdentity <DbUser>(options =>
{
options.Password.RequireNonAlphanumeric = false;
options.Password.RequireUppercase = false;
options.Password.RequireLowercase = false;
options.Password.RequiredLength = 1;
})
.AddRoles <DbRole>()
.AddEntityFrameworkStores <DatabaseContext>();
}
public async Task DeleteGuildConfiguration(GuildConfiguration guildConfiguration)
{
await _guildDal.DeleteGuildConfiguration(guildConfiguration);
}
public async Task UpdateGuildConfiguration(GuildConfiguration guildConfiguration)
{
await _guildDal.UpdateGuildConfiguration(guildConfiguration);
}
public GuildConfigSocketCommandContext(DiscordSocketClient client, SocketUserMessage msg, GuildConfiguration config) : base(client, msg)
{
Configuration = config;
}
/// <summary>
/// Determines if the incoming message is an incoming command, and dispatches to the appropriate handler if necessary.
/// </summary>
private async Task Client_MessageReceived(SocketMessage msg)
{
if (!(msg.Channel is SocketTextChannel channel))
{
return;
}
if (msg.Author.IsBot || msg.Author.IsWebhook)
{
return;
}
if (((IMessage)msg).Type != MessageType.Default)
{
return;
}
var author = (SocketGuildUser)msg.Author;
// Limit 3:
// For all cases: base command, 2 parameters.
// Except this case: "bb.config", subcommand name, subcommand parameters in a single string
var csplit = msg.Content.Split(" ", 3, StringSplitOptions.RemoveEmptyEntries);
if (csplit.Length > 0 && csplit[0].StartsWith(CommandPrefix, StringComparison.OrdinalIgnoreCase))
{
// Determine if it's something we're listening for.
if (!_dispatchCommands.TryGetValue(csplit[0].Substring(CommandPrefix.Length), out CommandHandler command))
{
return;
}
// Load guild information here
var gconf = await GuildConfiguration.LoadAsync(channel.Guild.Id, false);
// Ban check
if (!gconf.IsBotModerator(author)) // skip check if user is a moderator
{
if (await gconf.IsUserBlockedAsync(author.Id))
{
return; // silently ignore
}
}
// Execute the command
try
{
Log("Command", $"{channel.Guild.Name}/{author.Username}#{author.Discriminator}: {msg.Content}");
await command(this, gconf, csplit, channel, author);
}
catch (Exception ex)
{
if (ex is HttpException)
{
return;
}
Log("Command", ex.ToString());
try
{
channel.SendMessageAsync(":x: An unknown error occurred. It has been reported to the bot owner.").Wait();
// TODO webhook report
}
catch (HttpException) { } // Fail silently
}
}
}
} //Get only, this will only be set by me in config
protected bool Equals(GuildConfiguration other) => GuildId == other.GuildId;
private IEnumerable <ChannelConfiguration> GetChannelConfigurations(GuildConfiguration discord)
{
return(discord.Raids.Cast <ChannelConfiguration>().Union(discord.Pokemon));
}
public async Task Setup()
{
using DatabaseContext db = _db.CreateDbContext();
GuildConfiguration config = db.GetGuildConfiguration(Context.GuildId);
await Context.Channel.SendInfoAsync("Starting setup");
await Response("Which channel should Availabot be used in? (#mention channel)");
config.ChannelId = 0;
while (config.ChannelId == 0)
{
MessageReceivedEventArgs response = await Context.WaitForMessageAsync(x => x.Member.Id == Context.Author.Id, TimeSpan.FromMinutes(1));
if (response is null)
{
await Response("Setup cancelled.");
return;
}
if (Mention.TryParseChannel(response.Message.Content, out Snowflake channelId) &&
Context.Guild.Channels.TryGetValue(channelId, out IGuildChannel guildChannel) &&
guildChannel is ITextChannel)
{
config.ChannelId = channelId;
}
else
{
await Response("Invalid input, please try again.");
}
}
await Response("Which role should be used to label available users? (@mention role)");
config.RoleId = 0;
while (config.RoleId == 0)
{
MessageReceivedEventArgs response = await Context.WaitForMessageAsync(x => x.Member.Id == Context.Author.Id, TimeSpan.FromMinutes(1));
if (response is null)
{
await Response("Setup cancelled.");
return;
}
if (Mention.TryParseRole(response.Message.Content, out Snowflake roleId) &&
Context.Guild.Roles.TryGetValue(roleId, out _))
{
config.RoleId = roleId;
}
else
{
await Response("Invalid input, please try again.");
}
}
ITextChannel channel = Context.Guild.Channels.First(x => x.Key == config.ChannelId).Value as ITextChannel;
IUserMessage message = await channel.SendMessageAsync(new LocalMessageBuilder()
.WithContent("This message will be modified shortly...")
.WithMentions(LocalMentionsBuilder.None)
.Build());
await message.PinAsync();
foreach (IEmoji emoji in Constants.NumberEmojis.Take(5))
{
await message.AddReactionAsync(emoji);
}
await message.AddReactionAsync(Constants.XEmoji);
config.MessageId = message.Id;
db.GuildConfigurations.Update(config);
await db.SaveChangesAsync();
await _availability.UpdateGuildMessageAsync(Context.GuildId);
await Context.Channel.SendSuccessAsync("Setup completed");
}
