public string TimeSpanBetweenClipsAsString(ChannelConfigContainer result)
{
var output = DetermineTimeBetweenClipsText();
string DetermineTimeBetweenClipsText()
{
if (!result.TimeSpanBetweenClipsAsTicks.HasValue)
{
return("at least a few minutes");
}
var timeSpan = TimeSpan.FromTicks(result.TimeSpanBetweenClipsAsTicks.Value);
if (timeSpan.TotalMinutes == 1)
{
return($"at least 1 minute");
}
if (timeSpan.TotalMinutes < 60)
{
return($"at least {(int)timeSpan.TotalMinutes} minutes");
}
if (timeSpan.TotalHours == 1)
{
return("at least 1 hour");
}
return($"at least {(int)timeSpan.TotalHours} hours");
}
var newLineDelimiter = _ConfigWrapper["NewLineDelimiter"];
var timeBetweenClipsFormat = _ConfigWrapper["TimeBetweenClipsFormat"].Replace(newLineDelimiter, "\n");
return(string.Format(timeBetweenClipsFormat, output));
}
public async Task PostBroadcasterConfigAsync()
{
const int channelId = 123;
const string broadcaster = "broadcaster";
_Log.Setup(s => s.LogInformation($"Checking that broadcaster '{broadcaster}' exists."));
const string endpoint = "https://twitch.tv/users";
const string clientId = "kdrgvhidhfskljecsemphgdhdfgfls";
const string accept = "application/json";
const string displayName = "BrOaDcAsTeR";
var getUserResponse = new GetUsersResponse {
Users = new List <User> {
new User {
DisplayName = displayName
}
}
};
_TwitchWrapper.Setup(s => s.GetUsers(endpoint, clientId, accept, broadcaster)).ReturnsAsync(getUserResponse);
_Log.Setup(s => s.LogInformation($"Found broadcaster '{broadcaster}' with display name '{displayName}'."));
_Log.Setup(s => s.LogInformation($"Posting broadcaster config for channel '{channelId}' broadcaster '{displayName}'."));
var inputContainer = new BroadcasterConfigContainer();
var outputContainer = new ChannelConfigContainer();
_Context.Setup(s => s.SetBroadcasterConfigAsync(channelId, displayName, inputContainer)).ReturnsAsync(outputContainer);
_Log.Setup(s => s.LogInformation($"Posted broadcaster config for channel '{channelId}' broadcaster '{displayName}'."));
var result = await _Helper.PostBroadcasterConfigAsync(endpoint, clientId, accept, channelId, broadcaster, inputContainer);
_Log.VerifyAll();
_TwitchWrapper.VerifyAll();
_Context.VerifyAll();
Assert.That(result.ErrorMessage, Is.Null.Or.Empty);
Assert.That(result.ChannelConfigContainer, Is.EqualTo(outputContainer));
}
public string BuildClipOrderString(ChannelConfigContainer result)
{
var clipOrderDescription = DetermineClipOrderDescription();
//TODO move this common formatting logic into a method
var newLineDelimiter = _ConfigWrapper["NewLineDelimiter"];
var clipOrderFormat = _ConfigWrapper["ClipOrderFormat"].Replace(newLineDelimiter, "\n");
return(string.Format(clipOrderFormat, clipOrderDescription));
string DetermineClipOrderDescription()
{
var clipOrderMappings = _ConfigWrapper.Get <List <ClipOrderMapping> >("ClipOrderMappings");
var description = clipOrderMappings.Where(s => MatchesAConfig(s.MapsToClipOrders)).Select(s => s.Description).SingleOrDefault();
if (description != null)
{
return(description);
}
return(clipOrderMappings.Where(s => s.IsDefault).Select(s => s.Description).Single());
bool MatchesAConfig(List <string> configClipOrders)
{
return(configClipOrders.Any(configClipOrder =>
{
if (configClipOrder == null) //if current config clip order is null
{
return result.ClipOrder == null; //return that input is null too
}
return configClipOrder.Equals(result.ClipOrder, StringComparison.CurrentCultureIgnoreCase); //else just check equality
}));
}
}
}
public string BuildTimeZoneString(ChannelConfigContainer result)
{
string output;
if (!result.UtcHourOffset.HasValue)
{
output = "none";
}
else
{
var utcHourOffsetString = result.UtcHourOffset.Value.ToString("#.#");
if (result.UtcHourOffset.Value >= 0)
{
output = $"UTC+{utcHourOffsetString}";
}
else
{
output = $"UTC{utcHourOffsetString}";
}
}
var newLineDelimiter = _ConfigWrapper["NewLineDelimiter"];
var timeZoneFormat = _ConfigWrapper["TimeZoneFormat"].Replace(newLineDelimiter, "\n");
return(string.Format(timeZoneFormat, output));
}
public void DetermineClipsAtATime(int?numberOfClipsAtATime, string expectedResult)
{
_ConfigWrapper.Setup(s => s["NewLineDelimiter"]).Returns("NEWLINE");
_ConfigWrapper.Setup(s => s["ClipsAtATimeFormat"]).Returns("```lessNEWLINE{0}```");
var container = new ChannelConfigContainer {
NumberOfClipsAtATime = numberOfClipsAtATime
};
var result = _TopClipsModuleHelper.DetermineClipsAtATime(container);
_ConfigWrapper.VerifyAll();
Assert.That(result, Is.EqualTo(expectedResult));
}
public void DeterminePostWhen(int?minPostingHour, int?maxPostingHour, string expectedResult)
{
_ConfigWrapper.Setup(s => s["NewLineDelimiter"]).Returns("NEWLINE");
_ConfigWrapper.Setup(s => s["PostWhenFormat"]).Returns("```fixNEWLINE{0}```");
var container = new ChannelConfigContainer {
MinPostingHour = minPostingHour, MaxPostingHour = maxPostingHour
};
var result = _TopClipsModuleHelper.DeterminePostWhen(container);
_ConfigWrapper.VerifyAll();
Assert.That(result, Is.EqualTo(expectedResult));
}
public void BuildStreamersText_NoStreamers()
{
var container = new ChannelConfigContainer {
Broadcasters = new List <BroadcasterConfigContainer>()
};
const string expectedResult = "no streamers have been set up";
_ConfigWrapper.Setup(s => s["NoStreamersText"]).Returns(expectedResult);
var result = _TopClipsModuleHelper.BuildStreamersText(container);
_ConfigWrapper.VerifyAll();
Assert.That(result, Is.EqualTo(expectedResult));
}
async Task ReplyAsync(ChannelConfigContainer result)
{
var streamersText = _TopClipsModuleHelper.BuildStreamersText(result);
var postWhen = _TopClipsModuleHelper.DeterminePostWhen(result);
var clipsAtATime = _TopClipsModuleHelper.DetermineClipsAtATime(result);
var timeSpanString = _TopClipsModuleHelper.TimeSpanBetweenClipsAsString(result);
var globalMinViewsString = _TopClipsModuleHelper.GlobalMinViewsAsString(result);
var timeZoneString = _TopClipsModuleHelper.BuildTimeZoneString(result);
var clipOrderString = _TopClipsModuleHelper.BuildClipOrderString(result);
var embed = _TopClipsModuleHelper.BuildChannelConfigEmbed(Context, postWhen, streamersText, clipsAtATime, timeSpanString, globalMinViewsString, timeZoneString, clipOrderString);
await ReplyAsync(message : string.Empty, embed : embed);
}
public async Task GetChannelConfigAsync()
{
const int channelId = 123;
_Log.Setup(s => s.LogInformation($"Getting channel config for channel '{channelId}'."));
var container = new ChannelConfigContainer();
_Context.Setup(s => s.GetChannelConfigAsync(channelId)).ReturnsAsync(container);
_Log.Setup(s => s.LogInformation($"Got channel config for channel '{channelId}'."));
var result = await _Helper.GetChannelConfigAsync(channelId);
_Log.VerifyAll();
_Context.VerifyAll();
Assert.That(result, Is.EqualTo(container));
}
public async Task PostChannelConfigAsync()
{
const int channelId = 123;
_Log.Setup(s => s.LogInformation($"Posting channel config for channel '{channelId}'."));
var inputContainer = new ChannelConfigContainer();
var outputContainer = new ChannelConfigContainer();
_Context.Setup(s => s.SetChannelConfigAsync(channelId, inputContainer)).ReturnsAsync(outputContainer);
_Log.Setup(s => s.LogInformation($"Posted channel config for channel '{channelId}'."));
var result = await _Helper.PostChannelConfigAsync(channelId, inputContainer);
_Log.VerifyAll();
_Context.VerifyAll();
Assert.That(result, Is.EqualTo(outputContainer));
}
public string DeterminePostWhen(ChannelConfigContainer container)
{
string output;
if (container.MinPostingHour.HasValue && container.MaxPostingHour.HasValue)
{
output = $"between {container.MinPostingHour.Value} and {container.MaxPostingHour.Value}";
}
else
{
output = "all the time";
}
var newLineDelimiter = _ConfigWrapper["NewLineDelimiter"];
var postWhenFormat = _ConfigWrapper["PostWhenFormat"].Replace(newLineDelimiter, "\n");
return(string.Format(postWhenFormat, output));
}
public string GlobalMinViewsAsString(ChannelConfigContainer result)
{
string output;
if (!result.GlobalMinViews.HasValue)
{
output = "any view count";
}
else
{
output = $"at least {result.GlobalMinViews.Value.ToString("N0")} views";
}
var newLineDelimiter = _ConfigWrapper["NewLineDelimiter"];
var globalMinViewsFormat = _ConfigWrapper["GlobalMinViewsFormat"].Replace(newLineDelimiter, "\n");
return(string.Format(globalMinViewsFormat, output));
}
public void BuildStreamersText_SomeStreamers()
{
_ConfigWrapper.Setup(s => s.GetValue <bool>("EnableNumberOfClipsPerDay")).Returns(true);
var broadcaster1 = new BroadcasterConfigContainer {
Broadcaster = "broadcaster123"
};
var broadcaster2 = new BroadcasterConfigContainer {
Broadcaster = "anotherstreamer", NumberOfClipsPerDay = 4
};
var broadcaster3 = new BroadcasterConfigContainer {
Broadcaster = "omegalulmydude"
};
var broadcaster4 = new BroadcasterConfigContainer {
Broadcaster = "zzzzzzzzzzz", NumberOfClipsPerDay = 1
};
var broadcasters = new List <BroadcasterConfigContainer> {
broadcaster1, broadcaster2, broadcaster3, broadcaster4
};
var container = new ChannelConfigContainer {
Broadcasters = broadcasters
};
const string streamersBegin = "here's your list of streamers";
_ConfigWrapper.Setup(s => s["StreamersFieldBeginText"]).Returns(streamersBegin);
const string newLineDelimiter = "NEWLINE";
_ConfigWrapper.Setup(s => s["NewLineDelimiter"]).Returns(newLineDelimiter);
var streamerFormats = new List <string> {
"```lessNEWLINE{0}```", "```diffNEWLINE{0}```", "```fixNEWLINE{0}```"
};
_ConfigWrapper.Setup(s => s.Get <List <string> >("StreamersFormats")).Returns(streamerFormats);
var result = _TopClipsModuleHelper.BuildStreamersText(container);
_ConfigWrapper.VerifyAll();
const string expectedResult =
"here's your list of streamers" +
"```less\nanotherstreamer, 4 clips per day, any view count```" +
"```diff\nbroadcaster123, no limit, any view count```" +
"```fix\nomegalulmydude, no limit, any view count```" +
"```less\nzzzzzzzzzzz, 1 clip per day, any view count```";
Assert.That(result, Is.EqualTo(expectedResult));
}
public string DetermineClipsAtATime(ChannelConfigContainer container)
{
var output = DetermineClipsAtATimeText();
string DetermineClipsAtATimeText()
{
if (!container.NumberOfClipsAtATime.HasValue)
{
return("no limit");
}
if (container.NumberOfClipsAtATime.Value == 1)
{
return($"{container.NumberOfClipsAtATime.Value} clip at a time");
}
return($"{container.NumberOfClipsAtATime.Value} clips at a time");
}
var newLineDelimiter = _ConfigWrapper["NewLineDelimiter"];
var clipsAtATimeFormat = _ConfigWrapper["ClipsAtATimeFormat"].Replace(newLineDelimiter, "\n");
return(string.Format(clipsAtATimeFormat, output));
}
public string BuildStreamersText(ChannelConfigContainer container)
{
if (!container.Broadcasters.Any())
{
return(_ConfigWrapper["NoStreamersText"]);
}
var enableNumberOfClipsPerDay = _ConfigWrapper.GetValue <bool>("EnableNumberOfClipsPerDay");
var streamersText = _ConfigWrapper["StreamersFieldBeginText"];
var newLineDelimiter = _ConfigWrapper["NewLineDelimiter"];
var streamersFormats = _ConfigWrapper.Get <List <string> >("StreamersFormats").Select(s => s.Replace(newLineDelimiter, "\n")).ToList();
var index = 0;
var orderedBroadcasters = container.Broadcasters.OrderBy(s => s.Broadcaster);
foreach (var broadcaster in orderedBroadcasters)
{
var broadcasterText = broadcaster.Broadcaster;
var numberOfClipsPerDayText = DetermineNumberOfClipsPerDayText();
var minViewsText = DetermineMinViewsText();
var thisStreamersText = DetermineThisStreamersText();
streamersText += string.Format(streamersFormats[index], thisStreamersText);
index = (index + 1) % streamersFormats.Count;
string DetermineNumberOfClipsPerDayText()
{
if (!broadcaster.NumberOfClipsPerDay.HasValue)
{
return("no limit");
}
if (broadcaster.NumberOfClipsPerDay.Value == 1)
{
return("1 clip per day");
}
return($"{broadcaster.NumberOfClipsPerDay.Value} clips per day");
}
string DetermineMinViewsText()
{
if (!broadcaster.MinViews.HasValue)
{
if (container.GlobalMinViews.HasValue)
{
return($"at least {container.GlobalMinViews.Value.ToString("N0")} views (global)");
}
return("any view count");
}
if (broadcaster.MinViews.Value == 1)
{
return("at least 1 view");
}
return($"at least {broadcaster.MinViews.Value.ToString("N0")} views");
}
string DetermineThisStreamersText()
{
if (enableNumberOfClipsPerDay)
{
return(string.Join(", ", broadcasterText, numberOfClipsPerDayText, minViewsText));
}
return(string.Join(", ", broadcasterText, minViewsText));
}
}
return(streamersText);
}
public async Task <ChannelConfigContainer> PostChannelConfigAsync(decimal channelId, ChannelConfigContainer container)
{
var requestUri = string.Format(_ChannelConfigEndpointFormat, channelId);
var response = await _HttpClient.PostObjectWithHeaderAsync(requestUri, container, _FunctionsKeyHeaderName, _PostChannelConfigFunctionKey);
if (!response.IsSuccessStatusCode)
{
throw new FunctionHelperException($"Error posting channel config for channel '{channelId}'. Status code '{response.StatusCode.ToString()}'. Reason phrase '{response.ReasonPhrase}'.");
}
var content = await response.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <ChannelConfigContainer>(content));
}
public async Task <ChannelConfigContainer> PostChannelConfigAsync(decimal channelId, ChannelConfigContainer container)
{
_Log.LogInformation($"Posting channel config for channel '{channelId}'.");
var result = await _Context.SetChannelConfigAsync(channelId, container);
_Log.LogInformation($"Posted channel config for channel '{channelId}'.");
return(result);
}
public PostBroadcasterConfigResponse(ChannelConfigContainer channelConfigContainer)
{
ChannelConfigContainer = channelConfigContainer;
}
