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; }