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