public PagingWrapper <List <FeedBackDTO> > GetAllFeedback(int page, int size, string searchParam)
{
PagingWrapper <List <FeedBackDTO> > pagingModel = new PagingWrapper <List <FeedBackDTO> >();
List <FeedBackDTO> modelList = new List <FeedBackDTO>();
var allPost = _postRepo.GetAll().ToList();
allPost.ForEach(p =>
{
p.comments = this._commentRepo.GetAll().Where(c => c.PostId == p.Id).ToList();
FeedBackDTO parentModel = new FeedBackDTO();
parentModel.Id = p.Id;
parentModel.Content = p.Title;
parentModel.Author = p.Author;
parentModel.CreationDate = p.CreationTime;
parentModel.TotalComments = p.comments.Count;
parentModel.isParent = true;
modelList.Add(parentModel);
p.comments.ToList().ForEach(cm =>
{
FeedBackDTO childModel = new FeedBackDTO();
childModel.Id = cm.Id;
childModel.Content = cm.Content;
childModel.Author = this._userRepo.Get(cm.UserId).UserName.ToString();
childModel.CreationDate = cm.CreationTime;
childModel.TotalDislikes = this._voteRepo.GetAll().Where(v => v.CommentId == cm.Id && v.IsLiked == false).Count();
childModel.TotalLikes = this._voteRepo.GetAll().Where(v => v.CommentId == cm.Id && v.IsLiked == true).Count();
childModel.isParent = false;
modelList.Add(childModel);
});
});
// for searching
if (searchParam != null && searchParam != "")
{
modelList = modelList.Where(ap => ap.Content.ToLower().Contains(searchParam.ToLower()) == true).ToList();
}
var query = modelList;
var entries = query.Skip((page - 1) * size).Take(size).ToList();
var count = query.Count();
var totalPages = (int)Math.Ceiling(count / (float)size);
var firstPage = 1; // obviously
var lastPage = totalPages;
var prevPage = page > firstPage ? page - 1 : firstPage;
var nextPage = page < lastPage ? page + 1 : lastPage;
pagingModel.totalPages = totalPages;
pagingModel.firstPage = firstPage;
pagingModel.lastPage = lastPage;
pagingModel.prevPage = prevPage;
pagingModel.nextPage = nextPage;
pagingModel.currentPage = page;
pagingModel.totalRows = modelList.Count();
pagingModel.Data = entries;
return(pagingModel);
}
public ViewModelViewPlayablePagingWrapper(PagingWrapper <T> page)
{
_loadedPages = new List <PagingWrapper <T> > {
page
};
CurrentPage = page;
}
private async void LoadNewCurrentPage(string href)
{
SearchResult nextResult = await DataLoader.GetInstance().GetItemFromHref <SearchResult>(href);
PagingWrapper <T> newPage = (PagingWrapper <T>)nextResult.GetPagingWrapper <T>();
_loadedPages.Add(newPage);
CurrentPage = newPage;
}
public async Task <ActionResult> GetContracts(
[FromQuery] KeyValuePair <string, string> orderBy,
[FromBody] ContractInfoFilter filters,
[FromQuery] Paging paging)
{
var data = _contractService.GetContracts(orderBy, filters, paging, out int totalCount);
var result = new PagingWrapper <ContractInfo>
{
DataCollection = data,
TotalCount = totalCount
};
return(new JsonResult(result));
}
public async Task <List <Track> > GetAblumAllTracks(string albumid)
{
string baseUrl = string.Format(GET_ALBUM_TRACKS_URL_FORMAT, albumid);
NameValueCollection qparams = new NameValueCollection()
{
{ "limit", "50" }
};
string url = WebHelper.GetQueryUrl(baseUrl, qparams);
PagingWrapper <Track> firstPage = await ExecuteWebrequest <PagingWrapper <Track> >(url);
return(await GetAllItemsFromPagingWrapper(firstPage));
}
public async Task <List <Album> > GetArtitstAllAlbums(string artistid, string market)
{
string baseUrl = string.Format(GET_ARTIST_ALBUMS_URL_FORMAT, artistid);
NameValueCollection qparams = new NameValueCollection()
{
{ "market", market },
{ "limit", 50.ToString() }
};
string url = WebHelper.GetQueryUrl(baseUrl, qparams);
PagingWrapper <Album> firstPage = await ExecuteWebrequest <PagingWrapper <Album> >(url);
return(await GetAllItemsFromPagingWrapper(firstPage));
}
private async Task GetAndProcessSearchPage(int offset)
{
SearchConfiguration config = new SearchConfiguration()
{
Offset = offset,
Amount = 50,
Scope = new List <string>()
{
"playlist"
},
SearchText = _searchText
};
PagingWrapper <Playlist> page = (await DataLoader.GetInstance().Search(config, true)).Playlists;
//Parallel.ForEach(page.Items, async(playlist) =>
//{
// _runningGetTrackTasks++;
// await GetAndProcessTracksFromPlaylist(playlist);
//});
foreach (Playlist p in page.Items)
{
while (CurrentParallelTasks >= _maxParallelTask)
{
Thread.Sleep(5);
}
_runningGetTrackTasks++;
await GetAndProcessTracksFromPlaylist(p);
}
_runningGetSearchPageTasks--;
if (_searchLoadStartCompleted && CurrentParallelTasks - _runningSortingTasks == 0)
{
while (_runningSortingTasks > 0)
{
Thread.Sleep(5);
}
_callback();
}
}
public async Task <List <T> > GetAllItemsFromPagingWrapper <T>(PagingWrapper <T> page, bool retryOnLimit = false, int retryAfterLimitms = 5000)
where T : new()
{
List <T> result = new List <T>();
PagingWrapper <T> current = page;
List <PagingWrapper <T> > previous = new List <PagingWrapper <T> >();
while (!string.IsNullOrEmpty(current.Previous))
{
current = await GetItemFromHref <PagingWrapper <T> >(current.Previous, retryOnLimit, retryAfterLimitms);
previous.Add(current);
}
if (previous.Count > 0)
{
result.AddRange(((previous as IEnumerable <PagingWrapper <T> >).Reverse() // returns ordered enumerable paging wrappers
.Select(x => x.Items as IEnumerable <T>) // returns IEnumerable<IEnumerable<T>>
.Aggregate((x, y) => (x).Union(y))));
}
if (page.Items == null)
{
page = await GetItemFromHref <PagingWrapper <T> >(page.Href, retryOnLimit, retryAfterLimitms);
}
result.AddRange(page.Items);
current = page;
while (!string.IsNullOrEmpty(current.Next))
{
current = await GetItemFromHref <PagingWrapper <T> >(current.Next, retryOnLimit, retryAfterLimitms);
result.AddRange(current.Items);
}
return(result);
}
