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 override Task <ModuleResult> Execute(Data data)
{
if (!CheckValidHost())
{
return(Task.FromResult(ModuleResult.Create(this, ResultType.Error, "This is not a valid host.")));
}
var successful = GetCertificate();
if (_certificate == null)
{
return(Task.FromResult(ModuleResult.Create(this, ResultType.Error, "The host does not have a valid SSL Certificate.")));
}
if (!successful)
{
return(Task.FromResult(ModuleResult.Create(this, ResultType.Error, "The host does not have a valid SSL Certificate.")));
}
_certificateResults.Add("Valid from: " + _certificate.GetEffectiveDateString());
_certificateResults.Add("Valid till: " + _certificate.GetExpirationDateString());
_certificateResults.Add("Signature algorithm: " + _certificate.SignatureAlgorithm.FriendlyName);
var result = _certificateResults.Aggregate(_host + " has a valid SSL Certificate.", (current, cResult) => current + Environment.NewLine + cResult);
return(Task.FromResult(ModuleResult.Create(this, ResultType.Success, result)));
}
/// <summary>
///
/// </summary>
/// <param name="snapshot"></param>
/// <returns></returns>
public static List <TechnologyResultDTO> GetSizingMeasureTechnologies(Snapshot snapshot, string hrefModule, Int32 measureId)
{
List <TechnologyResultDTO> result = new List <TechnologyResultDTO>();
if (snapshot != null && snapshot.SizingMeasuresResults != null)
{
ApplicationResult applicationResult = snapshot.SizingMeasuresResults.FirstOrDefault(_ => _.Reference.Key == measureId && _.ModulesResult != null);
ModuleResult modulesResult = null;
if (applicationResult != null)
{
modulesResult = applicationResult.ModulesResult.FirstOrDefault(_ => _.Module.Href == hrefModule);
}
if (modulesResult != null)
{
result = modulesResult.TechnologyResults.Select(_ => new TechnologyResultDTO {
Name = _.Technology, Value = _.DetailResult.Value
}).ToList();
}
}
return(result);
}
/// <summary>
/// Try and enable the module in the specified hardpoint.
/// </summary>
public ModuleResult EnableModuleIn(Hardpoint hardpoint)
{
if (hardpoint.IsEmpty)
{
return(ModuleResult.NoModule);
}
else
{
ActorModule.DisabledReason disabledReason = hardpoint.Module.DisabledBy;
ModuleResult res = hardpoint.Module.EnableModule();
if (res == ModuleResult.Success)
{
++_totalActive;
if (disabledReason != ActorModule.DisabledReason.User)
{
--_autoDisabled;
}
if (onChange != null)
{
onChange(ActorModule.Change.Enabled, hardpoint.Module);
}
}
return(res);
}
}
/// <summary>
/// Try and disable the module in the specified hardpoint.
/// </summary>
public ModuleResult DisableModuleIn(Hardpoint hardpoint, ActorModule.DisabledReason reason = ActorModule.DisabledReason.User)
{
if (hardpoint == null)
{
return(ModuleResult.InvalidHardpoint);
}
if (hardpoint.IsEmpty)
{
return(ModuleResult.NoModule);
}
else if (!hardpoint.Module.IsEnabled)
{
return(ModuleResult.AlreadyDisabled);
}
else
{
ModuleResult result = hardpoint.Module.DisableModule(reason);
if (result == ModuleResult.Success)
{
--_totalActive;
if (reason == ActorModule.DisabledReason.ResourceLoss)
{
++_autoDisabled;
}
if (onChange != null)
{
onChange(ActorModule.Change.Disabled, hardpoint.Module);
}
}
return(result);
}
}
public static void ResultScreen()
{
infoPanel.Controls.Add(ModuleResult.Instance);
ModuleResult.Instance.Dock = DockStyle.Fill;
ModuleResult.Instance.BringToFront();
ModuleResult.Refresh();
}
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 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 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);
}
/// <summary>
/// Try and enable the module installed in the provided Hardpoint.
/// Can return a Partial result if the module exists, but there is not
/// enough energy or computer resources to enable the module.
/// </summary>
public OperationResult EnableModule(Hardpoint hardpoint)
{
ModuleResult res = hardpoints.EnableModuleIn(hardpoint);
switch (res)
{
case ModuleResult.Success:
return(OperationResult.OK());
case ModuleResult.NoModule:
return(OperationResult.Fail("No Module to disable"));
case ModuleResult.AlreadyEnabled:
return(OperationResult.OK("Module already enabled"));
case ModuleResult.InsufficientPower:
return(OperationResult.Partial("Not enough energy to activate Module"));
case ModuleResult.InsufficientCpu:
return(OperationResult.Partial("Not enough CPU"));
default:
return(OperationResult.Fail("Failed because: " + res.ToString()));
}
}
private ModuleResult CalculateModuleResult(Module module)
{
var moduleResult = new ModuleResult();
moduleResult.ResultStatus = GPRTCommon.Result.Status.PASS;
moduleResult.Credits = Convert.ToInt32(module.CreditValue);
var assesmentResults = new List <AssesmentResult>();
foreach (var assesment in module.Assesments)
{
var assesmentResult = CalculateAssementResult(assesment);
assesmentResults.Add(assesmentResult);
}
moduleResult.Mark = assesmentResults.Sum(ar => Convert.ToDecimal(ar.Assesment.ActualMark))
/ assesmentResults.Count;
if (assesmentResults.Any(ar => ar.ResultStatus == GPRTCommon.Result.Status.FAIL) ||
moduleResult.Mark < 30)
{
moduleResult.ResultStatus = GPRTCommon.Result.Status.FAIL;
moduleResult.Credits = 0;
}
moduleResult.Module = module;
moduleResult.AssesmentResults = assesmentResults;
return(moduleResult);
}
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);
}
public static void Log(ModuleResult moduleResult)
{
Console.Write("[");
SetConsoleColor(ConsoleColor.Cyan);
Console.Write($"{moduleResult.ModuleName}");
SetConsoleColor(ConsoleColor.White);
Console.Write("] [");
if (moduleResult.ResultType == ResultType.Success)
{
SetConsoleColor(ConsoleColor.Green);
}
else if (moduleResult.ResultType == ResultType.Warning)
{
SetConsoleColor(ConsoleColor.DarkYellow);
}
else if (moduleResult.ResultType == ResultType.Error)
{
SetConsoleColor(ConsoleColor.Red);
}
Console.Write($"{moduleResult.ResultType}");
SetConsoleColor(ConsoleColor.White);
Console.WriteLine($"] {moduleResult.Message}");
}
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 override async Task <ModuleResult> Run(IDictionary <string, string> variables, ColoredTextWriter output)
{
await Task.Delay(1); // add something awaitable to make this an async task like all other tasks
var result = new ModuleResult(ModuleResultStates.Error, new List <string>(), "no command run");
return(result);
}
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);
}
private async void MessageAllUsers(ModuleResult result)
{
var mentions = new StringBuilder();
foreach (var user in result.Users)
{
mentions.Append($"{user.Mention} ");
}
await ReplyAsync(mentions.ToString(), false, result.RequesterUserBuilder.Build());
}
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);
}
/// <summary>
/// Remove any installed module from the provided Hardpoint, with the provided
/// removal reason (Uninstalled or Destroyed).
///
/// If there was a module installed,
/// we try to return the prefab that the module was instantiated from.
/// </summary>
public GameObject RemoveModuleFrom(Hardpoint hardpoint,
ActorModule.Change reason = ActorModule.Change.Uninstalled)
{
GameObject prefab;
ModuleResult result = hardpoints.RemoveModuleFrom(hardpoint, reason, out prefab);
if (result == ModuleResult.InvalidHardpoint)
{
Debug.LogError("Trying to remove module from invalid hardpoint!");
}
return(prefab);
}
public void BuildModuleCompletionData(ModuleResult tr, ItemVisibility visMod,
List <string> alreadyAddedModuleNames)
{
if (!tr.IsOnlyModuleNamePartTyped())
{
foreach (var i in tr.ResolvedModule)
{
var di = i as DNode;
if (di == null)
{
if (i != null)
{
CompletionDataGenerator.Add(i);
}
continue;
}
if (di.IsPublic && CanItemBeShownGenerally(i))
{
CompletionDataGenerator.Add(i);
}
}
}
else
{
var modNameParts = tr.ResolvedModule.ModuleName.Split('.');
string packageDir = modNameParts[0];
for (int i = 1; i <= tr.AlreadyTypedModuleNameParts; i++)
{
packageDir += "." + modNameParts[i];
}
if (tr.AlreadyTypedModuleNameParts < modNameParts.Length - 1)
{
// Don't add a package name that already has been added before.. so e.g. show only the first module of package "std.c."
if (alreadyAddedModuleNames.Contains(packageDir))
{
return;
}
alreadyAddedModuleNames.Add(packageDir);
CompletionDataGenerator.Add(modNameParts[tr.AlreadyTypedModuleNameParts], PathOverride: packageDir);
}
else
{
CompletionDataGenerator.Add(modNameParts[modNameParts.Length - 1], tr.ResolvedModule);
}
}
}
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);
}
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);
}
/// <summary>
/// Disable the module that is currently installed in the provided hardpoint.
/// Can return a Partial result if module was already disabled.
/// </summary>
public OperationResult DisableModule(Hardpoint hardpoint)
{
ModuleResult res = hardpoints.DisableModuleIn(hardpoint);
switch (res)
{
case ModuleResult.NoModule:
return(OperationResult.Fail("No Module to disable"));
case ModuleResult.AlreadyDisabled:
return(OperationResult.Partial("Module is already disabled"));
default:
return(OperationResult.OK());
}
}
public override async Task <ModuleResult> Execute(Data data)
{
var stopWatch = new Stopwatch();
stopWatch.Start();
var pathList = await GetPathTraversalList("https://raw.githubusercontent.com/Bo0oM/fuzz.txt/master/fuzz.txt");
ExecutePathTraversal(_host, pathList);
var result = string.Join(Environment.NewLine, _foundHost);
stopWatch.Stop();
result += $"{ Environment.NewLine } Pathtraversal completed in: { stopWatch.Elapsed.TotalSeconds } seconds";
return(ModuleResult.Create(this, ResultType.Success, result));
}
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);
}
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 (requestUser == null || requestUser == null)
{
result.RequesterUserBuilder = EmbedBuilderHelper.GreenBuilder();
result.RequesterUserBuilder
.WithTitle($"Raid: {raidName}")
.WithDescription($"Added {guests} guest{(guests == 1 ? "" : "s")}");
}
else
{
var userToAddGuestsUsername = (userToAddGuests as IGuildUser).Nickname ?? userToAddGuests.Username;
var requestUserUsername = (requestUser as IGuildUser).Nickname ?? requestUser.Username;
result.RequesterUserBuilder = EmbedBuilderHelper.GreenBuilder();
result.RequesterUserBuilder
.WithTitle($"Raid: {raidName}")
.WithDescription($"Added {guests} guest{(guests == 1 ? "" : "s")} for {userToAddGuestsUsername}");
result.ReferenceUserBuilder = EmbedBuilderHelper.GreenBuilder();
result.ReferenceUserBuilder
.WithTitle($"Raid: {raidName}")
.WithDescription($"{requestUserUsername} has added {guests} guest{(guests == 1 ? "" : "s")} to the raid for you");
}
}
else if (raids.Count() == 0)
{
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder("Cannot find raid");
}
else
{
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder("Unknown Error");
}
return(result);
}
/// <summary>
/// Triggers the deactivation of the component.
/// </summary>
public ModuleResult Deactivate(ActorModule module)
{
// Make sure we're in the right state to Deactivate.
if (!_isActive)
{
return(ModuleResult.AlreadyInactive);
}
ModuleResult result = OnDeactivation(module);
MechaCoreComponent core = module.MechaCore;
core.computer.DeallocateCpu(cpuResources);
core.power.Free(energyUse);
_isActive = false;
return(result);
}
private ModuleResult RemoveUserFromRaid(Raid raid, IUser requesterUser, IUser referenceUser)
{
var result = new ModuleResult();
IUser userToCheck = referenceUser ?? requesterUser;
if (raid.Users.Any(a => a.Equals(User.FromIUser(userToCheck))))
{
raid.Users.RemoveAt(raid.Users.FindIndex(a => a.Equals(User.FromIUser(userToCheck))));
UpdateRaidWithDifferentUsers(raid);
result.Success = true;
if (referenceUser != null)
{
result.ReferenceUserBuilder = EmbedBuilderHelper.GreenBuilder();
result.ReferenceUserBuilder.AddField(x => {
x.Name = $"Raid: {raid.Name}";
x.Value = $"You have been removed from the raid by {requesterUser.Username}";
x.IsInline = false;
});
result.RequesterUserBuilder = EmbedBuilderHelper.GreenBuilder();
result.RequesterUserBuilder.AddField(x => {
x.Name = $"Raid: {raid.Name}";
x.Value = $"You have removed {referenceUser.Username} from the raid";
x.IsInline = false;
});
}
else
{
result.RequesterUserBuilder = EmbedBuilderHelper.GreenBuilder();
result.RequesterUserBuilder.AddField(x => {
x.Name = $"Raid: {raid.Name}";
x.Value = "You have been removed from the raid";
x.IsInline = false;
});
}
}
else
{
result.RequesterUserBuilder = EmbedBuilderHelper.ErrorBuilder($"Could not find user in that raid");
}
return(result);
}
/// <summary>
/// Initializes a new instance of the <see cref="AsyncModuleResult" /> class.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="result">The result.</param>
public AsyncModuleResult(IHttpContext context, ModuleResult result)
{
Context = context;
Result = result;
}
