public override void Clear() { Posts.Clear(); SortOrder.MarkUncomplited(); base.Clear(); }
private async Task FetchPostsAsync() { if (IsBusy == true) { return; } using (var httpClient = new HttpClient()) { httpClient.BaseAddress = new Uri("https://easypostsapp.azurewebsites.net/"); var httpResponse = await httpClient.GetAsync($"api/posts/"); var responseString = await httpResponse.Content.ReadAsStringAsync(); Console.WriteLine(responseString); var postModelsList = JsonConvert.DeserializeObject <List <PostModel> >(responseString); Posts.Clear(); foreach (var postModel in postModelsList) { if (string.IsNullOrEmpty(postModel.DateTimeString) == true) { postModel.DateTimeString = DateTime.UtcNow.ToString(); } Posts.Add(postModel); } IsBusy = false; } }
async Task ExecuteLoadPostCommand() { if (IsBusy) { return; } IsBusy = true; try { Posts.Clear(); var items = await AgoraService.GetPostsAsync(true); foreach (var item in items) { item.Author = await AgoraService.GetUserNameById(item.Author); } foreach (var item in items) { Posts.Insert(0, item); } } catch (Exception ex) { Debug.WriteLine(ex); } finally { IsBusy = false; } }
private void ExecuteLoadCommand() { if (IsBusy) { return; } IsBusy = true; if (CurrentAlbum == null) { IsBusy = false; return; } try { Posts.Clear(); CurrentAlbum.Posts.ForEach(p => Posts.Add(p)); OnPropertyChanged("HasPosts"); OnPropertyChanged("NoPosts"); } catch (Exception ex) { Debug.WriteLine(ex); } finally { IsBusy = false; } }
public async Task Load() { var posts = await http.GetAll(); Posts.Clear(); foreach (var p in posts) { Posts.Add(mapper.from(p)); } var popularPosts = await http.GetPopular(); PopularPosts.Clear(); foreach (var p in popularPosts) { PopularPosts.Add(mapper.from(p)); } var suggestedPosts = await http.GetSuggested(); SuggestedPosts.Clear(); foreach (var p in suggestedPosts) { SuggestedPosts.Add(mapper.from(p)); } }
private void LoadPostsByTeamFromDb(TeamListModel team) { Posts.Clear(); var posts = _postRepository.GetAllByTeamId(team.Id); Posts.AddRange(posts); }
async Task ExecuteLoadPostsCommand() { if (IsBusy) { return; } IsBusy = true; try { Posts.Clear(); PostRepository postRepository = new PostRepository(); var items = postRepository.GetAll(); foreach (var item in items) { Posts.Add(item); } } catch (Exception ex) { Debug.WriteLine(ex); } finally { IsBusy = false; } }
protected async Task SetOrderPostsBy(ChangeEventArgs e) { OrderPostsBy = e.Value.ToString(); Posts.Clear(); IsAllPosts = false; Page = 1; await LoadPosts(); }
private void SortPosts() { List <PostDetailModel> list = new List <PostDetailModel>(Posts); list.Sort(); Posts.Clear(); Posts.AddRange(list); }
public override void Clear() { Completed = false; Posts.Clear(); XactsSeen = 0; LastXact = null; base.Clear(); }
public async void GetPosts() { Posts.Clear(); var posts = await Firestore.Read(); foreach (var post in posts) { Posts.Add(post); } }
public PostListViewModel(Album album) { CurrentAlnum = album ?? throw new ApplicationException("No album set for post list"); Title = album.Name; LoadCommand = new Command(() => { if (IsBusy) { return; } IsBusy = true; if (album == null) { IsBusy = false; return; } try { Posts.Clear(); album.Posts.ForEach(p => Posts.Add(p)); OnPropertyChanged("IsListEmpty"); } catch (Exception ex) { Debug.WriteLine(ex); } finally { IsBusy = false; } }); MessagingCenter.Subscribe <Album>(this, "upsert", async a => { Title = a.Name; }); MessagingCenter.Subscribe <Post>(this, "upsert", async post => { post.AlbumId = album.Id; post = await dataService.UpsertAsync(post); if (album.Posts == null) { album.Posts = new List <Post>(); } album.Posts.Upsert(post); Posts.Upsert(post); OnPropertyChanged("IsListEmpty"); }); MessagingCenter.Subscribe <Post>(this, "delete", post => { Posts.Delete(post); album.Posts.Remove(post); OnPropertyChanged("IsListEmpty"); }); LoadCommand.Execute(null); }
/// <summary> /// Ported from void truncate_xacts::flush() /// </summary> public override void Flush() { if (!Posts.Any()) { return; } int l = Posts.Select(p => p.Xact).Distinct().Count(); Xact xact = Posts.First().Xact; int i = 0; foreach (Post post in Posts) { if (xact != post.Xact) { xact = post.Xact; i++; } bool print = false; if (HeadCount != 0) { if (HeadCount > 0 && i < HeadCount) { print = true; } else if (HeadCount < 0 && i >= -HeadCount) { print = true; } } if (!print && TailCount != 0) { if (TailCount > 0 && l - i <= TailCount) { print = true; } else if (TailCount < 0 && l - i > -TailCount) { print = true; } } if (print) { base.Handle(post); } } Posts.Clear(); base.Flush(); }
public void ClearIDs() { _ids.Clear(); _tmpIds.Clear(); _unreadCount = 0; OldestUnreadId = -1; if (Posts != null) { Posts.Clear(); } }
// public async Task LoadAsync() { var contents = await _monkeyHubApiService.GetPostsByUserIdAsync(_userModel.Id); Posts.Clear(); foreach (var item in contents) { item.Title = item.Title.ToUpper(); Posts.Add(item); } }
async Task LoadPosts() { Posts.Clear(); var feed = await _getFeedCommand.Execute(); foreach (var entry in feed.Entry) { var model = MapEntryToPostItem(entry); Posts.Add(model); } }
async Task LoadPosts() { var posts = await _getPostsCommand.Execute(); Posts.Clear(); foreach (var post in posts) { var model = _postMapper.Map(post); Posts.Add(model); } }
public async void GetPostsAsync(PostCategory postCategory) { switch (postCategory) { case PostCategory.Hot: StartWorkIndication(ViewModelConstants.LOADING_HOT_MESSAGE); break; case PostCategory.Trending: StartWorkIndication(ViewModelConstants.LOADING_TRENDING_MESSAGE); break; case PostCategory.Vote: StartWorkIndication(ViewModelConstants.LOADING_FRESH_MESSAGE); break; } ArePostsLoading = true; await Task.Run(async() => { var requestStatus = await _clientService.GetPostsAsync(postCategory, NUMBER_OF_POSTS); if (requestStatus != null && requestStatus.IsSuccessful) { _currentCategory = postCategory; Device.BeginInvokeOnMainThread(() => { Posts.Clear(); Posts = new ObservableCollection <PostView>(); _clientService.Posts.ToList().ForEach(post => Posts.Add(PostViewFactory.CreatePostViewFromPost(post))); CurrentPost = Posts.FirstOrDefault(); }); await Task.Delay(ViewModelConstants.GET_POSTS_DELAY); } else { StopWorkIndication(); string message = requestStatus == null ? ViewModelConstants.REQUEST_FAILED_MESSAGE : requestStatus.Message; await ShowMessage(message); } }); ArePostsLoading = false; StopWorkIndication(); }
public virtual void PostAccumulatedPosts() { // [DM] Enumerable.OrderBy is a stable sort that preserve original positions for equal items Posts = Posts.OrderBy(p => p, new ComparePosts(SortOrder, Report)).ToList(); foreach (Post post in Posts) { post.XData.SortCalc = false; base.Handle(post); } Posts.Clear(); }
public async Task UpdatePosts() { var postList = (await Post.GetPostByUser()).Posts.Distinct(); if (postList is null) { return; } Posts.Clear(); foreach (var post in postList) { Posts.Add(post); } }
public override void OnNavigatedTo(NavigationParameters parameters) { //TODO: Validate if loading posts each time we navigate to the page is a good idea? We will also trigger this going back and forth to detail _fakeService.GetPosts().Subscribe(items => { //Only clear and merge posts if we retrieve actual data if (items != null && items.Any()) { //TODO: Create a correct merge operation Posts.Clear(); Posts.Merge(items); } }); }
internal async Task LoadDataAsync() { RedditData = await RedditService.GetTopPost(); Posts.Clear(); RedditListItem value; foreach (var item in RedditData.data.children) { value = new RedditListItem { Value = item.data }; value.DismissItem += Dismiss; Posts.Add(value); } }
/// <summary> /// Asynchronously refreshes the posts. It calls the repository get posts method in order to refill the /// <see cref="Posts"/> collection. /// </summary> internal async Task RefreshPostsAsync() { var posts = await repository.GetPostsAsync(id); await UIUtils.InvokeFromUIThread(() => { Posts.Clear(); foreach (var p in posts) { Posts.Add(new PostViewModel { Title = p.Title, Content = p.Content }); } }); }
private void Search() { var postWithSearchedText = new HashSet <PostDetailModel>(); if (!string.IsNullOrEmpty(SearchText)) { SearchInAll(postWithSearchedText); Posts.Clear(); Posts.AddRange(postWithSearchedText); } else { LoadPostsByTeamFromDb(SelectedTeam); } SortPosts(); }
public void LoadPosts() { Posts.Clear(); var posts = apiClient.GetAllPostsByTeamId(IDHolder.IDActualTeam); foreach (var post in posts) { post.Comments = apiClient.GetCommentsByPostId(post.Id ?? default(int)); } if (posts != null) { posts = SortPosts(posts); } Posts.AddRange(posts); }
/// <summary>Loads the posts asynchronous.</summary> internal async Task LoadPostsAsync() { try { Posts.Clear(); Uri postUri = new Uri("http://localhost:4000/Posts/RelevantPosts/" + ReadSetting("CurrentCollective")); IList <Post> postList = await CrudHandler.GetGenericArrayAsync <Post>(postUri, ReadSetting("AuthInfo")).ConfigureAwait(true); foreach (var item in postList) { Posts.Add(item); } } catch (Exception ex) { Console.WriteLine(ex.Message); } }
public async Task <bool> UpdatePosts() { IsRefreshing = true; var posts = await Post.Read(); if (posts != null) { Posts.Clear(); foreach (var p in posts) { Posts.Add(p); } } IsRefreshing = false; return(true); }
public async Task <bool> UpdatePosts() { try { var posts = await Post.Read(); if (posts != null) { Posts.Clear(); foreach (var post in posts) { Posts.Add(post); } } return(true); } catch (Exception) { return(false); } }
private async void RefreshList() { try { Posts.Clear(); var table = App.TableClient.GetTableReference("Post"); await table.CreateIfNotExistsAsync(); var query = new TableQuery <PostEntity>(); var allPosts = await table.ExecuteQuerySegmentedAsync(query, null); foreach (var post in allPosts.OrderByDescending(p => p.PostDate)) { Posts.Add(post); } CurrentPost = Posts.First(); } catch (Exception ex) { } }
public async Task <bool> MyPosts() { try { var posts = await Post.GetPostByUserId(App.user.Id); if (posts != null) { Posts.Clear(); foreach (var post in posts) { Posts.Add(post); } } return(true); } catch (Exception ex) { var m = ex.Message; return(false); } }