public void CanInsertPermaban()
{
var options = Utility.CreateNewContextOptions(nameof(CanInsertPermaban));
using (var context = new HubContext(options))
{
(var admin, var banTarget) = PrepareDatabase(context);
var service = new BanService(context);
var banAddModel = new BanAddModel(TimeSpan.FromDays(150),
context.Players.Single(x => x.Id == banTarget.Id), "Griefer", "byond://discordia.space:2011", true,
admin, banTarget.Ip, banTarget.Cid);
service.AddBan(banAddModel);
var ban = context.Bans.FirstOrDefault();
Assert.NotNull(ban);
Assert.Equal(ban.BannedById, admin.Id);
Assert.Equal(ban.TargetId, banTarget.Id);
Assert.Equal(ban.Duration, banAddModel.Duration.Minutes);
Assert.Equal(ban.Server, banAddModel.Server);
Assert.Equal(ban.Reason, banAddModel.BanReason);
Assert.Equal(ban.Type, BanType.Permaban);
Assert.Null(ban.Job);
}
}
public async Task CreateInstanceOfTypeBan()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(CreateInstanceOfTypeBan));
var mapperMock = new Mock <IDtoMapper <User, UserDto> >();
var testGuid = Guid.NewGuid();
var user = new User {
Id = testGuid, UserName = "******"
};
using (var actContext = new CWContext(options))
{
//Act
//Guid id, string description, int period
var sut = new BanService(actContext, mapperMock.Object);
await actContext.Users.AddAsync(user);
await actContext.SaveChangesAsync();
await sut.CreateAsync(testGuid, "testDescription", 3);
await actContext.SaveChangesAsync();
}
using (var assertContext = new CWContext(options))
{
//Assert
var ban = assertContext.Bans.FirstOrDefault(b => b.User == user);
Assert.IsInstanceOfType(ban, typeof(Ban));
}
}
public async Task SetCorrectInputValues()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(SetCorrectInputValues));
var mapperMock = new Mock <IDtoMapper <User, UserDto> >();
var testGuid = Guid.NewGuid();
var user = new User {
Id = testGuid, UserName = "******"
};
using (var actContext = new CWContext(options))
{
//Act
var sut = new BanService(actContext, mapperMock.Object);
await actContext.Users.AddAsync(user);
await actContext.SaveChangesAsync();
await sut.CreateAsync(testGuid, "description", 3);
await actContext.SaveChangesAsync();
}
using (var assertContext = new CWContext(options))
{
//Assert
var ban = assertContext.Bans.Include(b => b.User).FirstOrDefault(b => b.User.UserName == "Pesho");
Assert.AreEqual("Pesho", ban.User.UserName);
Assert.AreEqual("description", ban.Description);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="BanSetCommands"/> class.
/// </summary>
/// <param name="bans">The moderation service.</param>
/// <param name="feedback">The feedback service.</param>
public BanSetCommands
(
[NotNull] BanService bans,
[NotNull] UserFeedbackService feedback
)
{
_bans = bans;
_feedback = feedback;
}
/// <summary>
/// Initializes a new instance of the <see cref="BanSetCommands"/> class.
/// </summary>
/// <param name="bans">The moderation service.</param>
/// <param name="feedback">The feedback service.</param>
public BanSetCommands
(
BanService bans,
UserFeedbackService feedback
)
{
_bans = bans;
_feedback = feedback;
}
public void SetUp()
{
database = new Mock <IDatabase>();
httpContextReader = new Mock <IHttpContextReader>();
database.Setup(d => d.BanRepository.Insert(It.IsNotNull <Ban>(), It.IsAny <bool>()))
.ReturnsAsync(true);
banService = new BanService(database.Object, httpContextReader.Object);
}
public ActionResult Index()
{
var banService = new BanService();
ViewBag.Posts = banService.SearchBannedPosts(new SearchBannedPostsRequest()).Posts;
ViewBag.Comments = banService.SearchBannedComments(new SearchBannedCommentsRequest()).Comments;
ViewBag.Users = banService.SearchBannedUsers(new SearchBannedUsersRequest()).Users;
return(View());
}
public ActionResult EnableCommentary(int id)
{
var banService = new BanService();
var result = banService.EnableCommentary(new EnableCommentaryRequest {
CommentaryId = id
});
return(RedirectToAction("Index"));
}
public ActionResult EnablePost(int id)
{
var banService = new BanService();
var result = banService.EnablePost(new EnablePostRequest {
PostId = id
});
return(RedirectToAction("Index"));
}
/// <summary>
/// Initializes a new instance of the <see cref="ExpirationBehaviour"/> class.
/// </summary>
/// <param name="client">The Discord client.</param>
/// <param name="warnings">The warning service.</param>
/// <param name="bans">The ban service.</param>
public ExpirationBehaviour
(
[NotNull] DiscordSocketClient client,
[NotNull] WarningService warnings,
[NotNull] BanService bans
)
: base(client)
{
_warnings = warnings;
_bans = bans;
}
/// <summary>
/// Initializes a new instance of the <see cref="BanSetCommands"/> class.
/// </summary>
/// <param name="bans">The moderation service.</param>
/// <param name="context">The command context.</param>
/// <param name="feedback">The feedback service.</param>
public BanSetCommands
(
BanService bans,
ICommandContext context,
FeedbackService feedback
)
{
_bans = bans;
_context = context;
_feedback = feedback;
}
public ActionResult EnableUser(int id)
{
var banService = new BanService();
var result = banService.EnableUser(new EnableUserRequest {
UserId = id
});
SendAccountEnabledToUser(result.UserName, result.Email);
return(RedirectToAction("Index"));
}
/// <inheritdoc />
protected override void ConfigureServices(IServiceProvider serviceProvider)
{
var coreDatabase = serviceProvider.GetRequiredService <CoreDatabaseContext>();
coreDatabase.Database.Create();
var banDatabase = serviceProvider.GetRequiredService <ModerationDatabaseContext>();
banDatabase.Database.Create();
this.Database = banDatabase;
this.Bans = serviceProvider.GetRequiredService <BanService>();
}
public async Task ReturnCorrectObjects_WhenParamIsActive()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(ReturnCorrectObjects_WhenParamIsActive));
var mapperMock = new Mock <IDtoMapper <User, UserDto> >();
var testGuid = Guid.NewGuid();
var testGuid2 = Guid.NewGuid();
var users = new List <User>
{
new User {
Id = testGuid, UserName = "******", IsBanned = false
},
new User {
Id = testGuid2, UserName = "******", IsBanned = false
},
};
var userDtos = new List <UserDto>
{
new UserDto {
Id = testGuid, UserName = "******", IsBanned = false
},
new UserDto {
Id = testGuid2, UserName = "******", IsBanned = false
},
};
mapperMock.Setup(u => u.MapFrom(It.IsAny <ICollection <User> >())).Returns(userDtos);
using (var actContext = new CWContext(options))
{
//Act & Assert
var sut = new BanService(actContext, mapperMock.Object);
await actContext.Users.AddAsync(users[0]);
await actContext.Users.AddAsync(users[1]);
await actContext.SaveChangesAsync();
var result = await sut.GetAllAsync("active");
Assert.AreEqual(users[0].UserName, result.AsQueryable().First().UserName);
Assert.AreEqual(users[0].Id, result.AsQueryable().First().Id);
Assert.AreEqual(users[0].IsBanned, result.AsQueryable().First().IsBanned);
Assert.AreEqual(users[1].UserName, result.AsQueryable().Last().UserName);
Assert.AreEqual(users[1].Id, result.AsQueryable().Last().Id);
Assert.AreEqual(users[1].IsBanned, result.AsQueryable().Last().IsBanned);
}
}
private async Task <OperationResult> RescindBanIfExpiredAsync
(
ChannelLoggingService loggingService,
BanService bans,
SocketGuild guild,
UserBan ban,
CancellationToken ct
)
{
if (ct.IsCancellationRequested)
{
return(OperationResult.FromError("Operation was cancelled."));
}
if (!(ban.ExpiresOn <= DateTime.UtcNow))
{
// No rescinding is needed, so we'll just bail out
return(OperationResult.FromSuccess());
}
var rescinder = guild.GetUser(this.Client.CurrentUser.Id);
var notifyResult = await loggingService.NotifyUserUnbannedAsync(ban, rescinder);
if (!notifyResult.IsSuccess)
{
return(OperationResult.FromError(notifyResult));
}
var deleteResult = await bans.DeleteBanAsync(ban, ct);
if (!deleteResult.IsSuccess)
{
return(OperationResult.FromError(deleteResult));
}
try
{
await guild.RemoveBanAsync((ulong)ban.User.DiscordID);
}
catch (HttpException hex) when(hex.HttpCode == HttpStatusCode.NotFound)
{
// Already unbanned
return(OperationResult.FromSuccess());
}
catch (Exception ex)
{
return(OperationResult.FromError(ex));
}
return(OperationResult.FromSuccess());
}
/// <inheritdoc />
protected override void ConfigureServices(IServiceProvider serviceProvider)
{
var coreDatabase = serviceProvider.GetRequiredService <CoreDatabaseContext>();
var coreCreateScript = coreDatabase.Database.GenerateCreateScript();
var banDatabase = serviceProvider.GetRequiredService <ModerationDatabaseContext>();
var banCreateScript = banDatabase.Database.GenerateCreateScript();
banDatabase.Database.ExecuteSqlRaw(coreCreateScript);
banDatabase.Database.ExecuteSqlRaw(banCreateScript);
this.Database = banDatabase;
this.Bans = serviceProvider.GetRequiredService <BanService>();
}
/// <summary>
/// Initializes a new instance of the <see cref="BanCommands"/> class.
/// </summary>
/// <param name="moderation">The moderation service.</param>
/// <param name="bans">The ban service.</param>
/// <param name="feedback">The feedback service.</param>
/// <param name="interactivity">The interactivity service.</param>
/// <param name="logging">The logging service.</param>
public BanCommands
(
ModerationService moderation,
BanService bans,
UserFeedbackService feedback,
InteractivityService interactivity,
ChannelLoggingService logging
)
{
_moderation = moderation;
_bans = bans;
_feedback = feedback;
_interactivity = interactivity;
_logging = logging;
}
/// <summary>
/// Initializes a new instance of the <see cref="BanCommands"/> class.
/// </summary>
/// <param name="moderation">The moderation service.</param>
/// <param name="bans">The ban service.</param>
/// <param name="feedback">The feedback service.</param>
/// <param name="interactivity">The interactivity service.</param>
/// <param name="logging">The logging service.</param>
public BanCommands
(
[NotNull] ModerationService moderation,
[NotNull] BanService bans,
[NotNull] UserFeedbackService feedback,
[NotNull] InteractivityService interactivity,
[NotNull] ChannelLoggingService logging
)
{
_moderation = moderation;
_bans = bans;
_feedback = feedback;
_interactivity = interactivity;
_logging = logging;
}
public void Constructor_CreatesInstance()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(Constructor_CreatesInstance));
var mapperMock = new Mock <IDtoMapper <User, UserDto> >();
using (var assertContext = new CWContext(options))
{
//Act
var sut = new BanService(assertContext, mapperMock.Object);
//Assert
Assert.IsNotNull(sut);
}
}
public async Task ReturnCorrectTypeOfInstance_WhenParamIsBanned()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(ReturnCorrectTypeOfInstance_WhenParamIsBanned));
var mapperMock = new Mock <IDtoMapper <User, UserDto> >();
var testGuid = Guid.NewGuid();
var testGuid2 = Guid.NewGuid();
var users = new List <User>
{
new User {
Id = testGuid, UserName = "******", IsBanned = true
},
new User {
Id = testGuid2, UserName = "******", IsBanned = true
},
};
var userDtos = new List <UserDto>
{
new UserDto {
Id = testGuid, UserName = "******", IsBanned = true
},
new UserDto {
Id = testGuid2, UserName = "******", IsBanned = true
},
};
mapperMock.Setup(u => u.MapFrom(It.IsAny <ICollection <User> >())).Returns(userDtos);
using (var actContext = new CWContext(options))
{
//Act & Assert
var sut = new BanService(actContext, mapperMock.Object);
await actContext.Users.AddAsync(users[0]);
await actContext.Users.AddAsync(users[1]);
await actContext.SaveChangesAsync();
var result = await sut.GetAllAsync("banned");
Assert.IsInstanceOfType(result, typeof(ICollection <UserDto>));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="BanCommands"/> class.
/// </summary>
/// <param name="bans">The ban service.</param>
/// <param name="logging">The logging service.</param>
/// <param name="context">The command context.</param>
/// <param name="guildAPI">The guild API.</param>
/// <param name="feedback">The feedback service.</param>
/// <param name="userAPI">The user API.</param>
public BanCommands
(
BanService bans,
ChannelLoggingService logging,
ICommandContext context,
IDiscordRestGuildAPI guildAPI,
FeedbackService feedback,
IDiscordRestUserAPI userAPI
)
{
_bans = bans;
_logging = logging;
_context = context;
_guildAPI = guildAPI;
_feedback = feedback;
_userAPI = userAPI;
}
public async Task CorrectlyRemoveBan_WhenParamsAreValid()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(CorrectlyRemoveBan_WhenParamsAreValid));
var mapperMock = new Mock <IDtoMapper <User, UserDto> >();
var testGuid = Guid.NewGuid();
var userTest = new User {
Id = testGuid, UserName = "******", IsBanned = true, LockoutEnabled = true, LockoutEnd = DateTime.UtcNow.AddDays(1)
};
var banTest = new Ban {
HasExpired = false, User = userTest
};
using (var actContext = new CWContext(options))
{
//Act
await actContext.Users.AddAsync(userTest);
await actContext.Bans.AddAsync(banTest);
await actContext.SaveChangesAsync();
var sut = new BanService(actContext, mapperMock.Object);
await sut.RemoveAsync(testGuid);
await actContext.SaveChangesAsync();
}
using (var assertContext = new CWContext(options))
{
//Assert
var user = await assertContext.Users.FirstAsync();
var ban = assertContext.Bans
.Include(u => u.User)
.Where(b => b.User == user)
.FirstOrDefault();
Assert.AreEqual(user.IsBanned, false);
Assert.AreEqual(ban.HasExpired, true);
Assert.AreEqual(user.LockoutEnd < DateTime.Now, true);
}
}
public async Task ThrowWhen_NoBanIsFound()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(CorrectlyRemoveBan_WhenParamsAreValid));
var mapperMock = new Mock <IDtoMapper <User, UserDto> >();
var testGuid = Guid.NewGuid();
var userTest = new User {
Id = testGuid, UserName = "******", IsBanned = true, LockoutEnabled = true, LockoutEnd = DateTime.UtcNow.AddDays(1)
};
using (var assertContext = new CWContext(options))
{
//Act & Assert
await assertContext.Users.AddAsync(userTest);
await assertContext.SaveChangesAsync();
var sut = new BanService(assertContext, mapperMock.Object);
await Assert.ThrowsExceptionAsync <BusinessLogicException>(() => sut.RemoveAsync(testGuid));
}
}
public void CanInsertRegularJobban()
{
var options = Utility.CreateNewContextOptions(nameof(CanInsertRegularJobban));
using (var context = new HubContext(options))
{
(var admin, var banTarget) = PrepareDatabase(context);
var service = new BanService(context);
var jobbanAddModel = new JobbanAddModel(TimeSpan.FromDays(600), banTarget, "Griefer",
"byond://discordia.space:9999", false, "Medic", admin, banTarget.Ip, banTarget.Cid);
service.AddJobban(jobbanAddModel);
var jobban = context.Bans.FirstOrDefault();
Assert.NotNull(jobban);
Assert.Equal(jobban.Type, BanType.JobTempban);
Assert.Equal(jobban.Job, jobbanAddModel.Job);
Assert.Equal(jobban.Duration, jobbanAddModel.Duration.Minutes);
}
}
public CommandHandler(IServiceProvider provider, DiscordSocketClient client, CommandService commandService,
AfkService afkService, RatelimitingService ratelimitingService, StarboardService starboardService, SelfAssignableRolesService selfService, AnnouncementService announcementService,
ModService modService, GuildCountUpdaterService guildUpdate, ExpService expService, BanService banService, InteractionsService interactionsService)
{
_client = client;
_commands = commandService;
_afkService = afkService;
_services = provider;
_ratelimitingService = ratelimitingService;
_starboardService = starboardService;
_selfAssignableRolesService = selfService;
_announcementService = announcementService;
_modService = modService;
_guildCount = guildUpdate;
_banService = banService;
_interactionsService = interactionsService;
_guildCount.Initialize(client.ShardId, Utility.TOTAL_SHARDS, client.Guilds.Count);
_client.MessageReceived += HandleCommandsAsync;
//_client.MessageReceived += _afkService.Client_MessageReceived;
_commands.Log += CommandsOnLog;
_client.JoinedGuild += ClientOnJoinedGuild;
_client.LeftGuild += ClientOnLeftGuild;
_client.MessageReceived += expService.IncreaseEpOnMessageReceive;
_client.ReactionAdded += _starboardService.ClientOnReactionAdded;
_client.ReactionRemoved += _starboardService.ClientOnReactionRemoved;
_client.UserJoined += _selfAssignableRolesService.ClientOnUserJoined;
_client.UserJoined += _announcementService.ClientOnUserJoined;
_client.UserLeft += _announcementService.ClientOnUserLeft;
//mod Service
_client.UserBanned += _modService.ClientOnUserBanned;
_client.UserUnbanned += _modService.ClientOnUserUnbanned;
}
public SoraApiController(DiscordSocketClient client, BanService banService, DiscordRestClient restClient)
{
_client = client;
_restClient = restClient;
_banService = banService;
}
public UtilityModule(BanService banService)
{
_banService = banService;
}
public BanCommands(BanService ban)
{
_ban = ban;
}
//// Disabled by Catherine Renelle - Memory Leak Fix
////private string _connectionString;
#endregion
public async Task MainAsync(string[] args)
{
Console.WriteLine(args.Join(", "));
int shardId;
if (!int.TryParse(args[0], out shardId))
{
throw new Exception("INVALID SHARD ARGUMENT");
}
_restClient = new DiscordRestClient();
//Setup config
ConfigService.InitializeLoader();
ConfigService.LoadConfig();
if (!int.TryParse(ConfigService.GetConfigData("shardCount"), out Utility.TOTAL_SHARDS))
{
throw new Exception("INVALID SHARD COUNT");
}
//setup discord client
_client = new DiscordSocketClient(new DiscordSocketConfig()
{
LogLevel = LogSeverity.Info,
AlwaysDownloadUsers = false,
MessageCacheSize = 0,
TotalShards = Utility.TOTAL_SHARDS,
ShardId = shardId
});
Utility.SHARD_ID = shardId;
_client.Log += Log;
string token = "";
ConfigService.GetConfig().TryGetValue("token2", out token);
await _restClient.LoginAsync(TokenType.Bot, token);
//setup DB
Utility.SORA_VERSION = ConfigService.GetConfigData("version");
// setup banservice
_banService = new BanService();
//Setup Services
ProfileImageGeneration.Initialize();
_interactive = new InteractiveService(_client);
//Instantiate the dependency map and add our services and client to it
var serviceProvider = ConfigureServices();
// first setup weebservice
await serviceProvider.GetRequiredService <WeebService>().InitializeAsync();
//setup command handler
await serviceProvider.GetRequiredService <CommandHandler>().InitializeAsync(serviceProvider);
//SETUP other dependency injection services
serviceProvider.GetRequiredService <ReminderService>().Initialize();
serviceProvider.GetRequiredService <WaifuService>().Initialize();
serviceProvider.GetRequiredService <ProfileService>().Initialize();
serviceProvider.GetRequiredService <StarboardService>().Initialize();
serviceProvider.GetRequiredService <SelfAssignableRolesService>().Initialize();
serviceProvider.GetRequiredService <RatelimitingService>().SetTimer();
//Set up an event handler to execute some state-reliant startup tasks
_client.Ready += async() =>
{
SentryService.Install(_client);
};
//Connect to Discord
await _client.LoginAsync(TokenType.Bot, token);
await _client.StartAsync();
// initialize Autoreconnect Feature
_autoReconnectService = new AutoReconnectService(_client, LogPretty);
// setup ban users
_banService.FetchBannedUsers();
//INITIALIZE CACHE
CacheService.Initialize();
//build webserver and inject service
try
{
int port = int.Parse(ConfigService.GetConfigData("port"));
var host = new WebHostBuilder()
.UseKestrel() // MVC webserver is called Kestrel when self hosting
.UseUrls("http://*****:*****@"/web/") // Required to be set and exist. Create web folder in the folder the bot runs from. Folder can be empty.
.UseWebRoot(Directory.GetCurrentDirectory() + @"/web/") // Same as above.
.UseStartup <Startup>() // Use Startup class in Startup.cs
.ConfigureServices(services =>
{
services.AddSingleton(_client); // Injected Discord client
services.AddSingleton(_banService); // Injected Discord client
services.AddCors(options =>
{
options.AddPolicy("AllowLocal", builder => builder.WithOrigins("localhost")); // Enable CORS to only allow calls from localhost
});
services.AddMvc().AddJsonOptions(options => options.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore); // Fixes JSON Recursion issues in API response.
})
.Build(); // Actually creates the webhost
Console.WriteLine($"WEB API STARTED ON PORT: {port+shardId}");
await host.RunAsync(); // Run in tandem to client
}
catch (Exception e)
{
Console.WriteLine(e);
await SentryService.SendMessage(e.ToString());
}
//Hang indefinitely
await Task.Delay(-1);
}
public WebApiBanController(AccountService accountBaseFunction, BanService banService, UserManager <IdentityUser> user)
{
this.accountBaseFunction = accountBaseFunction;
this.banService = banService;
this.user = user;
}
