public override async Task <ScrollResponse> Scroll(ScrollRequest request, ServerCallContext context)
{
Logger.LogInformation("Received scroll request for {id}", request.ScrollId);
var result = await Client.Scroll(request.ScrollId);
var response = new ScrollResponse()
{
ScrollId = result.ScrollId
};
foreach (var message in result.Messages)
{
response.Results.Add(
new Result()
{
Id = message.Id,
DisplayName = message.DisplayName,
Message = message.Text,
Channel = message.Channel,
Timestamp = message.TimeStamp
});
}
return(response);
}
public override async Task <ScrollResponse> InitScroll(InitScrollRequest request, ServerCallContext context)
{
Logger.LogInformation("Initializing scroll for {Timestamp}", request.Timestamp);
var result = await Client.InitScroll(request.Size, request.Timestamp, request.Direction);
var response = new ScrollResponse()
{
ScrollId = result.ScrollId
};
foreach (var message in result.Messages)
{
response.Results.Add(
new Result()
{
Id = message.Id,
DisplayName = message.DisplayName,
Message = message.Text,
Channel = message.Channel,
Timestamp = message.TimeStamp
});
}
return(response);
}
//TODO: Can probably be optimized
/// <summary>
/// Returns recent feed items from the endpoint
/// </summary>
/// <param name="endpoint">Path from the base URL</param>
/// <param name="initialScroll">False when continueing from a scroll, otherwise true</param>
/// <returns>Feed items</returns>
private async Task <ScrollResponse> GetScrollableFeed(string endpoint, bool initialScroll)
{
//First, obtain the pulse-groups from games with the given ids
ScrollResponse feedResponse = initialScroll ? _apiClient.Scroll <ApiPulseGroup>(endpoint) : new ScrollResponse {
Scrollables = _apiClient.GetMultiple <ApiPulseGroup>(endpoint)
};
//Then, get the feed items (pulses) themselves
IEnumerable <ApiFeedItem> pulses = feedResponse.Scrollables.Select(pg => new ApiFeedItem {
Id = ((ApiPulseGroup)pg).FeedItems.First(),
Game = ((ApiPulseGroup)pg).Game
});
string fields = "id,published_at,updated_at,url,title,summary,pulse_image";
IEnumerable <ApiFeedItem> apiFeedItems =
_apiClient.GetMultiple <ApiFeedItem>($"pulses/{pulses.Select(p => p.Id).CommaSeparate()}/?fields={fields}");
//Convert the ApiFeedItems to FeedItems
IList <FeedItem> feedItems = new List <FeedItem>();
foreach (ApiFeedItem apiFeedItem in apiFeedItems)
{
int gameId = pulses.FirstOrDefault(p => p.Id == apiFeedItem.Id).Game;
FeedItem feedItem = ApiFeedItemMapper.MapFeedItem(apiFeedItem);
feedItem.Game = await _gameRepository.GetGame(gameId);
feedItems.Add(feedItem);
}
feedResponse.Scrollables = feedItems;
return(feedResponse);
}
private void Core_WebMessageReceived(object sender, CoreWebView2WebMessageReceivedEventArgs e)
{
ScrollResponse response = JsonConvert.DeserializeObject <ScrollResponse>(e.WebMessageAsJson);
//MessageBox.Show("Scrolling to " + response.ScrollPos);
if (currentReviewDocument != null)
{
currentReviewDocument.ScrollTo(response.ScrollPos);
}
}
public async Task <HomeViewModel> Home(string userId = null)
{
HomeViewModel model;
if (userId != null)
{
ScrollResponse feedResponse = await GetPersonalisedHomeFeed(userId);
model = new HomeViewModel {
Feed = feedResponse.Scrollables as IEnumerable <FeedItem>,
FeedPageCount = feedResponse.PageCount,
FeedScrollUrl = feedResponse.ScrollUrl
};
}
else
{
model = new HomeViewModel {
Feed = new List <FeedItem>()
};
}
return(model);
}
/// <summary>
/// Returns feed items from continueing the scroll
/// </summary>
/// <param name="scrollUrl">The scroll URL to continue scrolling</param>
/// <returns>Feed items</returns>
public async Task <IEnumerable <FeedItem> > GetScrollableFeed(string scrollUrl)
{
ScrollResponse response = await GetScrollableFeed(scrollUrl, false);
return(response.Scrollables as IEnumerable <FeedItem>);
}
