public static async Task <Service> GetService(CommandContext ctx)
{
var guildServices = new List <Service>();
var servicesFresh = Service.GetServices();
foreach (Service service in servicesFresh)
{
if (service.Variables["__Nexus::DiscordGuild"] != null &&
service.Variables["__Nexus::DiscordGuild"].ToString() ==
ctx.Guild.Id.ToString() /*&& ShowServiceVar(service)*/)
{
guildServices.Add(service);
}
}
if (guildServices.Count == 0)
{
throw new CustomMessageException(EmbedTemplates.CreateErrorEmbed("Service Link",
"**No Services could be found. Add one by doing the `;Link` command!**"));
}
if (guildServices.Count == 1)
{
return(guildServices[0]);
}
if (guildServices.Count > 1)
{
return(await ChooseServiceFromList(ctx, guildServices));
}
return(null);
}
public async Task BanIp(CommandContext ctx, [RemainingText] string ipAddress)
{
await ctx.TriggerTypingAsync();
Network.RegisterInvalidLogin(ipAddress);
await ctx.RespondAsync(embed : EmbedTemplates.CreateSuccessEmbed("Added invalid login for IP " + ipAddress));
}
public async Task Play(CommandContext context, [RemainingText, Description("Ссылка на трек")] Uri trackUri)
{
var loadResult = await this.Music.Lavalink.LavalinkNode.GetTracksAsync(trackUri);
if (loadResult.LoadResultType == LavalinkLoadResultType.LoadFailed || loadResult.LoadResultType == LavalinkLoadResultType.NoMatches || !loadResult.Tracks.Any())
{
throw new DiscordUserInputException("Ошибка загрузки треков", nameof(trackUri));
}
var tracks = loadResult.Tracks.Select(x => new RemoteMusicItem(x, context.Member)).ToArray();
var remoteMusic = this.GuildMusic.MusicSources[(int)MusicSourceType.RemoteMusicData] as RemoteMusicData;
remoteMusic.Add(tracks);
await this.GuildMusic.CreatePlayerAsync(context.Member.VoiceState.Channel).ConfigureAwait(false);
if (this.GuildMusic.IsPlaying)
{
await context.RespondAsync(embed : EmbedTemplates.ExecutedByEmbed(context.Member, context.Guild.CurrentMember)
.WithTitle($"{tracks.Length} трек(ов) было добавлено в очередь")).ConfigureAwait(false);
}
else
{
if (this.GuildMusic.PlayingMessage == null)
{
this.GuildMusic.PlayingMessage = await context.RespondAsync(embed : await this.GuildMusic.NowPlayingEmbedAsync().ConfigureAwait(false)).ConfigureAwait(false);
}
await this.GuildMusic.Start();
}
}
public async System.Threading.Tasks.Task TaskViewer(CommandContext ctx, string serviceConnectionInfo)
{
await ctx.TriggerTypingAsync();
if (!(Service.GetGameServices(serviceConnectionInfo)[0] is Service service) || !service.Find())
{
await ctx.RespondAsync(embed : EmbedTemplates.CreateErrorEmbed("Task Manager",
"**Cannot find service with search criteria: ** *" + serviceConnectionInfo + "*"));
return;
}
var serviceTaskList =
TCAdmin.TaskScheduler.SDK.Objects.Task.GetTasksForSource(service.GetType().ToString(),
service.ServiceId.ToString());
var servicesTask = serviceTaskList.Cast <TCAdmin.TaskScheduler.SDK.Objects.Task>().ToList();
if (servicesTask.Count == 0)
{
await ctx.RespondAsync(embed : EmbedTemplates.CreateErrorEmbed("Task Manager", "No Tasks Found"));
return;
}
var taskManager =
new TcaTaskManager(
await ctx.RespondAsync(embed: EmbedTemplates.CreateInfoEmbed("Task Manager", "Initialize...")),
servicesTask.Last().TaskId);
await taskManager.Initialize();
}
public async Task ServerPowerShell(CommandContext ctx, string serverName, [RemainingText] string script)
{
await ctx.TriggerTypingAsync();
if (!script.StartsWith("```\n") && !script.EndsWith("```"))
{
await ctx.RespondAsync(embed : EmbedTemplates.CreateErrorEmbed("PowerShell",
"**No script found!** Example Script: ```\necho 'test'\n```"));
return;
}
if (!(Server.GetServers(true, serverName)[0] is Server server))
{
await ctx.RespondAsync(embed : EmbedTemplates.CreateErrorEmbed("Server Not Found",
$"{serverName} could not be found."));
return;
}
server.FileSystemService.CreateTextFile(@"C:\\DiscordScripts\\script.ps1",
Encoding.ASCII.GetBytes(script.Replace("```\n", string.Empty).Replace("```", string.Empty)));
var console = new RemoteConsole(server, @"C:\\Windows\\System32\\cmd.exe",
"/c powershell \"C:\\DiscordScripts\\script.ps1\"", "Powershell - Script", true);
await ctx.RespondAsync(embed : EmbedTemplates.CreateInfoEmbed("Live Output",
$"To start the command, click [here]({console.GetUrl()})"));
}
public async Task ForceDeleteTag(CommandContext context,
[RemainingText, Description("Название тега который нужно удалить")] string name)
{
if (string.IsNullOrWhiteSpace(name) || ForbiddenNames.Contains(name.ToLower()))
{
throw new DiscordUserInputException("Название тега не может быть пустым, полностью состоять из пробелов или называться также как и команды.", nameof(name));
}
name = name.ToLowerInvariant();
var gId = (long)context.Guild.Id;
Tag tag = await this.Database.Tags.SingleOrDefaultAsync(t => t.Name == name && t.GuildId == gId).ConfigureAwait(false);
if (tag == null)
{
throw new DiscordUserInputException("Тега с таким названием на этом сервере не существует, убедитесь в правильности написания названия названия тега.", nameof(name));
}
else
{
this.Database.Tags.Remove(tag);
int rowsAffected = await this.Database.SaveChangesAsync();
if (rowsAffected > 0)
{
await context.RespondAsync(embed : EmbedTemplates.ExecutedByEmbed(context.Member, context.Guild.CurrentMember)
.WithTitle($"Тег {name} успешно удален")).ConfigureAwait(false);
}
else
{
throw new DatabaseException($"Не удалось удалить тег {name}. Убедитесь в том что тег существует и правильности написания названия.", DatabaseActionType.Remove);
}
}
}
public async Task LinkServiceTask(CommandContext ctx)
{
var user = await AccountsService.GetUser(ctx);
var service = await DiscordService.LinkService(ctx, user);
await ctx.RespondAsync(embed : EmbedTemplates.CreateSuccessEmbed(service.Name, "Link Successful!"));
}
public async Task LoginUserAs(CommandContext ctx, DiscordMember member, string username)
{
var user = User.GetUserByUserName(username);
if (!user.Find())
{
await ctx.RespondAsync(embed : EmbedTemplates.CreateErrorEmbed("Login As", "Cannot find user"));
}
}
public Task LogoutUser(CommandContext ctx, DiscordMember discordMember)
{
var user = AccountsService.GetUser(discordMember.Id);
AccountsService.LogoutUser(user, discordMember.Id);
return(ctx.RespondAsync(
embed: EmbedTemplates.CreateSuccessEmbed(
description: $"**{user.FullName} has been unlinked and logged out.")));
}
public override async Task DoAction()
{
await base.DoAction();
var service = Authentication.Service;
service.Start("Started by Nexus.");
var embed = EmbedTemplates.CreateSuccessEmbed($"{service.NameNoHtml}", "**Started successfully**");
await CommandContext.RespondAsync(embed : embed);
}
public async Task Stop(CommandContext context)
{
this.GuildMusic.Stop();
foreach (var musicSource in this.GuildMusic.MusicSources)
{
musicSource.ClearQueue();
}
await context.RespondAsync(embed : EmbedTemplates.ExecutedByEmbed(context.Member, context.Guild.CurrentMember)
.WithTitle("Воспроизведение остановлено и списки очищены")).ConfigureAwait(false);
}
public override async Task <bool> ExecuteCheckAsync(CommandContext ctx, bool help)
{
if (await IsAdministrator(ctx))
{
return(true);
}
throw new CustomMessageException(EmbedTemplates.CreateErrorEmbed("Access Denied",
"**You require `Administrator` permissions to execute this command.**"));
}
public async System.Threading.Tasks.Task TaskViewer(CommandContext ctx, int taskId)
{
await ctx.TriggerTypingAsync();
var taskManager =
new TcaTaskManager(
await ctx.RespondAsync(embed: EmbedTemplates.CreateInfoEmbed("Task Manager", "Initialize...")),
taskId);
await taskManager.Initialize();
}
public Task LogoutUser(CommandContext ctx, string username)
{
var user = User.GetUserByUserName(username);
user.AppData.RemoveValue("OAUTH::Discord");
user.Save();
return(ctx.RespondAsync(
embed: EmbedTemplates.CreateSuccessEmbed(
description: $"**{user.FullName} has been unlinked and logged out.")));
}
public async Task UnlinkServices(CommandContext ctx)
{
var msg = await ctx.RespondAsync(embed : EmbedTemplates.CreateInfoEmbed("Unlink Services",
"Unlinking all services. Please wait..."));
DiscordService.ResetAllServices(ctx);
await msg.ModifyAsync(
embed : new Optional <DiscordEmbed>(
EmbedTemplates.CreateSuccessEmbed(description: "Unlinked all services.")));
}
public async Task GetVariable(CommandContext ctx, int userId, string variableName)
{
await ctx.TriggerTypingAsync();
var user = new User(userId);
var userCustomField = user.CustomFields[variableName];
await ctx.RespondAsync(embed : EmbedTemplates.CreateSuccessEmbed($"GetVariable for {user.UserName}",
$"VariableName `{variableName}` value is {userCustomField}"));
}
public async System.Threading.Tasks.Task RconTask()
{
var interactivity = CommandContext.Client.GetInteractivity();
await CommandContext.RespondAsync(embed : EmbedTemplates.CreateInfoEmbed("Remote Console",
"Please enter the RCON command to send to the server."));
var command = await interactivity.WaitForMessageAsync(
x => x.Author.Id == CommandContext.User.Id && x.Channel.Id == CommandContext.Channel.Id);
await RconTask(command.Result.Content);
}
public async System.Threading.Tasks.Task TaskList(CommandContext ctx, string serviceConnectionInfo, int amountOfTasks)
{
await ctx.TriggerTypingAsync();
var interactivity = ctx.Client.GetInteractivity();
if (!(Service.GetGameServices(serviceConnectionInfo)[0] is Service service) || !service.Find())
{
await ctx.RespondAsync(embed : EmbedTemplates.CreateErrorEmbed("Task Manager",
"**Cannot find service with search criteria: ** *" + serviceConnectionInfo + "*"));
return;
}
var serviceTaskList =
TCAdmin.TaskScheduler.SDK.Objects.Task.GetTasksForSource(service.GetType().ToString(),
service.ServiceId.ToString());
var servicesTask = new List <TCAdmin.TaskScheduler.SDK.Objects.Task>();
foreach (TCAdmin.TaskScheduler.SDK.Objects.Task task in serviceTaskList)
{
servicesTask.Add(task);
}
if (servicesTask.Count == 0)
{
await ctx.RespondAsync(embed : EmbedTemplates.CreateErrorEmbed("Task Manager", "No Tasks Found"));
return;
}
var tasksList = string.Empty;
var taskIdList = 1;
tasksList = servicesTask.Take(amountOfTasks).Aggregate(tasksList,
(current, task) => current + $"**{taskIdList++}**) {task.Name} [{task.ScheduledTime:f}]\n");
await ctx.RespondAsync(embed : EmbedTemplates.CreateInfoEmbed("Task Picker", tasksList));
var msg = await interactivity.WaitForMessageAsync(x => x.Channel == ctx.Channel && x.Author == ctx.User);
if (int.TryParse(msg.Result.Content, out var result))
{
var taskManager = new TcaTaskManager(
await ctx.RespondAsync(embed: EmbedTemplates.CreateInfoEmbed("Task Manager", "Initialize...")),
servicesTask[result - 1].TaskId);
await taskManager.Initialize();
}
else
{
await ctx.RespondAsync(embed : EmbedTemplates.CreateErrorEmbed("Task Manager", "Invalid Option"));
}
}
public override async Task <bool> ExecuteCheckAsync(CommandContext ctx, bool help)
{
if (await IsTcSubAdministrator(ctx))
{
return(true);
}
var companyInfo = new CompanyInfo(2);
throw new CustomMessageException(EmbedTemplates.CreateErrorEmbed("Access Denied",
$"**You do not have the correct Access Group in `{companyInfo.ControlPanelUrl}` to use this command.**"));
}
public override async System.Threading.Tasks.Task DoAction()
{
await base.DoAction();
var service = Authentication.Service;
service.Stop("Stopped by Nexus.");
// await CommandContext.RespondAsync($"**{service.NameNoHtml} has been stopped**");
var embed = EmbedTemplates.CreateSuccessEmbed($"{service.NameNoHtml}", "**Stopped successfully**");
await CommandContext.RespondAsync(embed : embed);
}
public async Task Playlists(CommandContext context)
{
var playlists = new List <string>();
lock (this.Bot.UpdateMusicLock)
{
playlists = this.Database.Playlist.Select(x => x.PlaylistName).Distinct().ToList();
}
await context.RespondAsync(embed : EmbedTemplates.ExecutedByEmbed(context.Member, context.Guild.CurrentMember)
.WithTitle("Список доступных плейлистов")
.WithDescription(string.Join(',', playlists.Select(x => Formatter.InlineCode(x))))).ConfigureAwait(false);
}
public async Task SetVariable(CommandContext ctx, int userId, string variableName, string variableValue)
{
await ctx.TriggerTypingAsync();
var user = new User(userId);
user.CustomFields[variableName] = variableValue;
user.Save();
await ctx.RespondAsync(embed : EmbedTemplates.CreateSuccessEmbed($"SetVariable for {user.UserName}",
$"VariableName `{variableName}` value set to {variableValue}"));
}
public async Task GetVariable(CommandContext ctx, DiscordMember member, string variableName)
{
var user = AccountsService.GetUser(member.Id);
if (user == null)
{
await ctx.RespondAsync(embed : EmbedTemplates.CreateErrorEmbed("SetVariable", "Could not find user."));
return;
}
await GetVariable(ctx, user.UserId, variableName);
}
public async Task CreateAsync(CommandContext context,
[Description("Название тега")] string name,
[RemainingText, Description("Содержимое тега")] string contents)
{
if (string.IsNullOrWhiteSpace(name) || ForbiddenNames.Contains(name.ToLower()))
{
throw new DiscordUserInputException("Название тега не может быть пустым, полностью состоять из пробелов или иметь такое же название как команды.", nameof(name));
}
if (string.IsNullOrWhiteSpace(contents))
{
throw new DiscordUserInputException("Содержимое тега не может быть пустым или содержать только пробелы.", nameof(contents));
}
if (contents.Length > 2000)
{
throw new DiscordUserInputException("Длина содержимого тега не может превышать 2000 символов.", nameof(contents));
}
name = name.ToLowerInvariant();
var tag = new Tag
{
Id = Convert.ToInt64(DateTimeOffset.Now.ToUnixTimeMilliseconds()),
Name = name,
TagContent = contents,
GuildId = (long)context.Guild.Id,
OwnerId = (long)context.User.Id,
CreationDate = DateTime.Now,
TimesUsed = 0
};
if (this.Database.Tags?.Any(t => t.Name == tag.Name && t.GuildId == tag.GuildId) == true)
{
throw new DiscordUserInputException("Тег с таким именем существует на данном сервере.", nameof(name));
}
await this.Database.Tags.AddAsync(tag).ConfigureAwait(false);
int rowsAffected = await this.Database.SaveChangesAsync();
if (rowsAffected > 0)
{
await context.RespondAsync(embed : EmbedTemplates.ExecutedByEmbed(context.Member, context.Guild.CurrentMember)
.WithTitle("Тег успешно создан")).ConfigureAwait(false);
}
else
{
throw new DatabaseException($"Не удалось создать тег {name}. Попробуйте снова.", DatabaseActionType.Add);
}
}
public async Task RestartMonitor(CommandContext ctx, string serverName)
{
if (!(Server.GetServers(true, serverName)[0] is Server server))
{
await ctx.RespondAsync(embed : EmbedTemplates.CreateErrorEmbed("Server Not Found",
$"{serverName} could not be found."));
return;
}
server.ServerUtilitiesService.RestartMonitor();
await ctx.RespondAsync(embed : EmbedTemplates.CreateSuccessEmbed("Monitor Restart",
$"{server.Name}'s monitor is restarting."));
}
public async Task ForceLinkService(CommandContext ctx, int serviceId)
{
await ctx.Message.DeleteAsync();
if (DiscordService.LinkService(ctx.Guild.Id, serviceId))
{
await ctx.RespondAsync(embed : EmbedTemplates.CreateSuccessEmbed(description: "**Linked Service**"));
}
else
{
await ctx.RespondAsync(
embed : EmbedTemplates.CreateErrorEmbed(description: "**Failed to link service**"));
}
}
public async Task SwitchPlaylist(CommandContext context, [RemainingText, Description("Название плейлиста")] string playlistName)
{
if (string.IsNullOrWhiteSpace(playlistName))
{
throw new DiscordUserInputException("Название плейлиста не должно быть пустым", nameof(playlistName));
}
var localMS = this.GuildMusic.MusicSources[(int)MusicSourceType.LocalMusicData] as LocalMusicData;
await localMS.ChangePlaylistAsync(playlistName);
await context.RespondAsync(embed : EmbedTemplates.ExecutedByEmbed(context.Member, context.Guild.CurrentMember)
.WithTitle($"Плейлист успешно изменен на {playlistName}")).ConfigureAwait(false);
}
public async Task EditTag(CommandContext context,
[Description("Название тега")] string name,
[RemainingText, Description("Новое содержимое тега")] string newContent)
{
if (string.IsNullOrWhiteSpace(name) || ForbiddenNames.Contains(name.ToLower()))
{
throw new DiscordUserInputException("Название тега не может быть пустым, полностью состоять из пробелов или называться также как и команды.", nameof(name));
}
if (string.IsNullOrWhiteSpace(newContent))
{
throw new DiscordUserInputException("Содержимое тега не может быть пустым или содержать одни пробелы.", nameof(newContent));
}
if (newContent.Length > 2000)
{
throw new DiscordUserInputException("Длина содержимого тега не должна превышать.", nameof(newContent));
}
name = name.ToLowerInvariant();
var gId = (long)context.Guild.Id;
var uId = (long)context.User.Id;
Tag tag = await this.Database.Tags.SingleOrDefaultAsync(t => t.Name == name && t.GuildId == gId && t.OwnerId == uId).ConfigureAwait(false);
if (tag == null)
{
throw new DiscordUserInputException("Тега с таким названием на этом сервере не существует, убедитесь в правильности написания названия и в том что вы являетесь владельцем данного тега.", nameof(name));
}
else
{
tag.TagContent = newContent;
this.Database.Tags.Update(tag);
int rowsAffected = await this.Database.SaveChangesAsync();
if (rowsAffected > 0)
{
await context.RespondAsync(embed : EmbedTemplates.ExecutedByEmbed(context.Member, context.Guild.CurrentMember)
.WithTitle($"Тег {name} успешно изменен")).ConfigureAwait(false);
}
else
{
throw new DatabaseException($"Не удалось изменить тег {name}", DatabaseActionType.Update);
}
}
}
public async Task SignOut(CommandContext ctx)
{
var user = AccountsService.GetUser(ctx.User.Id);
if (user == null)
{
await ctx.RespondAsync(embed : EmbedTemplates.CreateErrorEmbed("Logout",
"**You have to be signed in, in order to logout.**"));
return;
}
AccountsService.LogoutUser(user, ctx.User.Id);
await ctx.RespondAsync(embed : EmbedTemplates.CreateSuccessEmbed("Logout", "**You have been logged out**"));
}
public async Task LoginAs(CommandContext ctx, string username)
{
var user = User.GetUserByUserName(username);
if (!user.Find())
{
await ctx.RespondAsync(embed : EmbedTemplates.CreateErrorEmbed("Login As", "Cannot find user"));
return;
}
AccountsService.AddUserToEmulation(ctx.User.Id, user);
await ctx.RespondAsync(
embed : EmbedTemplates.CreateSuccessEmbed(description: "Logged in as " + user.UserName));
}
