public async Task TrendRandom([Remainder] string randomSearchString)
{
var match = await _FunctionWrapper.GetJobConfigAsync(Context.Channel.Id);
var maxLength = _Config.GetValue <int>("RandomSearchStringMaxLength");
var isValidSearchString = !string.IsNullOrEmpty(randomSearchString) && randomSearchString.Length <= maxLength;
if (!isValidSearchString)
{
await TryReplyAsync($"Please provide a random gif filter that is at most {maxLength} characters long.");
}
else
{
string newRandomSearchString;
var shouldTurnCommandOff = _TrendHelper.ShouldTurnCommandOff(randomSearchString);
if (shouldTurnCommandOff)
{
newRandomSearchString = null;
}
else
{
newRandomSearchString = randomSearchString;
}
var container = new JobConfigContainer(match, randomSearchString);
var result = await _FunctionWrapper.PostJobConfigAsync(Context.Channel.Id, container);
await ReplyWithJobConfig(result);
}
}
public async Task <JobConfigContainer> PostJobConfigAsync(decimal channelId, JobConfigContainer jobConfigContainer)
{
var requestUri = $"{_JobConfigEndpoint}/{channelId}";
var response = await _HttpClient.PostObjectWithHeaderAsync(requestUri, jobConfigContainer, _FunctionsKeyHeaderName, _PostJobConfigFunctionKey);
return(await ProcessJobConfigResponse(channelId, response));
}
public void BuildEmbed()
{
var context = new Mock <ICommandContext>();
const string channelName = "Apex Legends Pog";
context.Setup(s => s.Channel.Name).Returns(channelName);
const string guildIconUrl = "https://asdf.com/icon";
context.Setup(s => s.Guild.IconUrl).Returns(guildIconUrl);
const string helpText = "Here is some help text to help you out.";
_Config.Setup(s => s["GetConfigHelpFieldText"]).Returns(helpText);
var config = new JobConfigContainer();
var result = _TrendHelper.BuildEmbed(config, context.Object);
context.VerifyAll();
_Config.VerifyAll();
var expectedAuthorName = $"Setup for Channel # {channelName}";
Assert.That(result.Author.Value.Name, Is.EqualTo(expectedAuthorName));
Assert.That(result.Author.Value.IconUrl, Is.EqualTo(guildIconUrl));
Assert.That(result.Fields[0].Inline, Is.True);
Assert.That(result.Fields[0].Name, Is.EqualTo("How Often?"));
Assert.That(result.Fields[0].Value, Is.EqualTo("```less\nnever```"));
Assert.That(result.Fields[1].Inline, Is.True);
Assert.That(result.Fields[1].Name, Is.EqualTo("Random Gifs?"));
Assert.That(result.Fields[1].Value, Is.EqualTo("```yaml\nno```"));
Assert.That(result.Fields[2].Inline, Is.True);
Assert.That(result.Fields[2].Name, Is.EqualTo("Trend When?"));
Assert.That(result.Fields[2].Value, Is.EqualTo("```fix\nall the time```"));
Assert.That(result.Fields[3].Inline, Is.False);
Assert.That(result.Fields[3].Name, Is.EqualTo("Need Help?"));
Assert.That(result.Fields[3].Value, Is.EqualTo(helpText));
}
static string DetermineQuietHoursFieldValue(JobConfigContainer jobConfig)
{
if (jobConfig.MinQuietHour.HasValue && jobConfig.MaxQuietHour.HasValue)
{
return($"between {jobConfig.MaxQuietHour.Value} and {jobConfig.MinQuietHour.Value} o'clock");
}
return("all the time");
}
static string DetermineRandomFieldValue(JobConfigContainer config)
{
if (!string.IsNullOrEmpty(config.RandomSearchString))
{
return($"yes, of \"{config.RandomSearchString}\"");
}
return("no");
}
public async Task <IActionResult> RunAsync(JobConfigContainer container, decimal channelId)
{
_Log.LogInformation($"Channel {channelId} posting job config.");
var result = await _Context.SetJobConfig(channelId, container);
_Log.LogInformation($"Channel {channelId} posted job config.");
return(new OkObjectResult(result));
}
public JobConfigContainer(JobConfigContainer basedOn, short?minQuietHour, short?maxQuietHour)
{
ChannelId = basedOn.ChannelId;
Interval = basedOn.Interval;
Time = basedOn.Time;
RandomSearchString = basedOn.RandomSearchString;
MinQuietHour = minQuietHour;
MaxQuietHour = maxQuietHour;
}
public JobConfigContainer(JobConfigContainer basedOn, short?interval, string time)
{
ChannelId = basedOn.ChannelId;
Interval = interval;
Time = time;
RandomSearchString = basedOn.RandomSearchString;
MinQuietHour = basedOn.MinQuietHour;
MaxQuietHour = basedOn.MaxQuietHour;
}
public JobConfigContainer(JobConfigContainer basedOn, string randomSearchString)
{
ChannelId = basedOn.ChannelId;
Interval = basedOn.Interval;
Time = basedOn.Time;
RandomSearchString = randomSearchString;
MinQuietHour = basedOn.MinQuietHour;
MaxQuietHour = basedOn.MaxQuietHour;
}
public static EmbedBuilder WithHowOften(this EmbedBuilder embedBuilder, JobConfigContainer config)
{
if (config.Interval.HasValue && !string.IsNullOrEmpty(config.Time))
{
var every = $"```less\n{config.Interval} {config.Time.ToLower()}```";
return(embedBuilder.AddInlineField("How Often?", every));
}
return(embedBuilder.AddInlineField("How Often?", "```less\nnever```"));
}
public async Task RunAsync()
{
const decimal channelId = 123;
_Log.Setup(s => s.LogInformation($"Channel {channelId} deleting job config."));
var container = new JobConfigContainer();
_Context.Setup(s => s.DeleteJobConfig(channelId)).Returns(Task.CompletedTask);
_Log.Setup(s => s.LogInformation($"Channel {channelId} deleted job config."));
var result = await _DeleteJobConfigHelper.RunAsync(channelId);
_Log.VerifyAll();
_Context.VerifyAll();
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.InstanceOf <NoContentResult>());
}
public async Task Every(short interval, Time time)
{
var errorMessage = _TrendHelper.DetermineErrorMessage(interval, time);
if (string.IsNullOrEmpty(errorMessage))
{
var match = await _FunctionWrapper.GetJobConfigAsync(Context.Channel.Id);
var container = new JobConfigContainer(match, interval, time.ToString());
var result = await _FunctionWrapper.PostJobConfigAsync(Context.Channel.Id, container);
await ReplyWithJobConfig(result);
}
else
{
await TryReplyAsync(errorMessage);
}
}
public async Task RunAsync()
{
const decimal channelId = 123;
_Log.Setup(s => s.LogInformation($"Channel {channelId} getting job config."));
var container = new JobConfigContainer();
_Context.Setup(s => s.GetJobConfig(channelId)).ReturnsAsync(container);
_Log.Setup(s => s.LogInformation($"Channel {channelId} got job config."));
var result = await _GetJobConfigHelper.RunAsync(channelId);
_Log.VerifyAll();
_Context.VerifyAll();
var okObjectResult = result as OkObjectResult;
Assert.That(okObjectResult, Is.Not.Null);
Assert.That(okObjectResult.Value, Is.EqualTo(container));
}
public Embed BuildEmbed(JobConfigContainer config, ICommandContext context)
{
var author = new EmbedAuthorBuilder()
.WithName($"Setup for Channel # {context.Channel.Name}")
.WithIconUrl(context.Guild.IconUrl);
var helpFieldText = _Config["GetConfigHelpFieldText"];
var helpField = new EmbedFieldBuilder()
.WithName("Need Help?")
.WithValue(helpFieldText);
var embedBuilder = new EmbedBuilder()
.WithAuthor(author)
.WithHowOften(config)
.WithRandomConfigFields(config)
.WithQuietHourFields(config)
.AddField(helpField);
return(embedBuilder.Build());
}
public async Task Between([Remainder] string trendBetweenString)
{
var match = await _FunctionWrapper.GetJobConfigAsync(Context.Channel.Id);
var split = trendBetweenString.Split(_ArgsSplit, StringSplitOptions.RemoveEmptyEntries);
if (split.Length != 3)
{
await TryReplyAsync(_Config["InvalidQuietHoursInputFormat"]);
}
else
{
var minInRange = _TrendHelper.IsInRange(split[2], out var minQuietHour);
var maxInRange = _TrendHelper.IsInRange(split[0], out var maxQuietHour);
if (!(minInRange && maxInRange) || minQuietHour == maxQuietHour)
{
await TryReplyAsync(_Config["InvalidQuietHoursRangeMessage"]);
}
else
{
short?newMinQuietHour;
short?newMaxQuietHour;
var shouldTurnCommandOff = _TrendHelper.ShouldTurnCommandOff(trendBetweenString);
if (shouldTurnCommandOff)
{
newMinQuietHour = null;
newMaxQuietHour = null;
}
else
{
newMinQuietHour = minQuietHour;
newMaxQuietHour = maxQuietHour;
}
var container = new JobConfigContainer(match, minQuietHour, maxQuietHour);
var result = await _FunctionWrapper.PostJobConfigAsync(Context.Channel.Id, container);
await ReplyWithJobConfig(result);
}
}
}
public static EmbedBuilder WithQuietHourFields(this EmbedBuilder embedBuilder, JobConfigContainer jobConfig)
{
var fieldValue = DetermineQuietHoursFieldValue(jobConfig);
return(embedBuilder.AddInlineField("Trend When?", $"```fix\n{fieldValue}```"));
}
async Task ReplyWithJobConfig(JobConfigContainer config)
{
var embed = _TrendHelper.BuildEmbed(config, Context);
await TryReplyAsync(embed);
}
public static EmbedBuilder WithRandomConfigFields(this EmbedBuilder embedBuilder, JobConfigContainer config)
{
var fieldValue = DetermineRandomFieldValue(config);
return(embedBuilder.AddInlineField("Random Gifs?", $"```yaml\n{fieldValue}```"));
}
