Beispiel #1
0
        public SimpleViewModel()
        {
            var dataSource = new FakeDataSource();

            Items = new InfiniteScrollCollection <DataItem>
            {
                OnLoadMore = async() =>
                {
                    // load the next page
                    var page  = Items.Count / PageSize;
                    var items = await dataSource.GetItemsAsync(page + 1, PageSize);

                    return(items);
                }
            };

            RefreshCommand = new Command(() =>
            {
                // clear and start again
                Items.Clear();
                Items.LoadMoreAsync();
            });

            // load the initial data
            Items.LoadMoreAsync();
        }
Beispiel #2
0
        InfiniteScrollCollection <EventListModel> GetItems(bool clearList, List <News> eventItemList)
        {
            InfiniteScrollCollection <EventListModel> items;

            if (clearList || Items == null)
            {
                items = new InfiniteScrollCollection <EventListModel>();
            }
            else
            {
                items = new InfiniteScrollCollection <EventListModel>(Items);
            }



            foreach (var eventItem in eventItemList)
            {
                items.Add(new EventListModel
                {
                    Title    = UppercaseFirst(eventItem.Title),
                    SubTitle = UppercaseFirst(eventItem.SubTitle),
                    Place    = UppercaseFirst(eventItem.Place),

                    Day = eventItem.StartDate.ToString("dddd"),

                    Date = eventItem.StartDate.ToString("dd MMMM"),

                    Year = eventItem.StartDate.ToString("yyyy"),

                    Color = "#" + GetRandamColor()
                });
            }

            return(items);
        }
        InfiniteScrollCollection <Products> GetItems(bool clearList, List <WSProduct> productItemList)
        {
            InfiniteScrollCollection <Products> items;

            if (clearList || Items == null)
            {
                items = new InfiniteScrollCollection <Products>();
            }
            else
            {
                items = new InfiniteScrollCollection <Products>(Items);
            }



            foreach (var productItem in productItemList)
            {
                items.Add(new Products
                {
                    Title       = UppercaseFirst(productItem.PName),
                    Description = UppercaseFirst(productItem.PDescription),

                    ImageUrl = productItem.PictureUrl,

                    Price = Convert.ToString(productItem.PPriceIncVAT) + " kr",
                });
            }

            return(items);
        }
Beispiel #4
0
        public MainViewModel()
        {
            Items = new InfiniteScrollCollection <ForumData>
            {
                OnLoadMore = async() =>
                {
                    IsBusy = true;
                    // load the next page
                    var page  = Items.Count / PageSize;
                    var items = await dataService.GetForumDataAsync(page + 1, PageSize);

                    IsBusy = false;
                    // return the items that need to be added
                    return(items);
                    //njkjk
                },
                OnCanLoadMore = () =>
                {
                    int testvar2 = dataService.GetCountAsync();
                    int testvar  = Items.Count;
                    return(Items.Count != 35);
                }
            };

            AddItems();
        }
        //protected override async void PullData()
        //{
        //    ApiResponse<MovieList> response;
        //    //using (UserDialogs.Instance.Loading())
        //    //{
        //        response = await _movieService.GetUpComingMovieRequest();
        //    //}
        //    response.Check((result) =>
        //    {
        //        MovieList = _movieService.GetMovieList(result);
        //    }, async (statusCode) =>
        //    {
        //        await HandleApiError(statusCode, async (errorCode) => await _dialogService.ShowDialogAsync(statusCode));
        //    });
        //}

        //protected override async void SearchData(string keyword)
        //{
        //    ApiResponse<MovieList> response;
        //    // using (UserDialogs.Instance.Loading())
        //    //{
        //    response = await _movieService.GetUpComingMovieRequest();
        //    //}
        //    response.Check((result) =>
        //    {
        //        MovieList = _movieService.GetMovieSearchData(result, keyword);
        //    }, async (statusCode) =>
        //    {
        //        await HandleApiError(statusCode, async (errorCode) => await _dialogService.ShowDialogAsync(statusCode));
        //    });
        //}
        protected override void PullData()
        {
            ApiResponse <MovieList> response;

            Task.Run(async() =>
            {
                MovieList = new InfiniteScrollCollection <Movie>
                {
                    OnLoadMore = async() =>
                    {
                        //await Task.Delay(2000);
                        List <Movie> movie = null;
                        var page           = MovieList.Count / pageSize + 1;
                        if (MovieList.Count != 0 && MovieList.Count < pageSize)
                        {
                            return(movie);
                        }
                        response = await _movieService.GetUpComingMovieRequest(page);
                        response.Check((result) =>
                        {
                            movie = _movieService.GetMovieList(result);
                        });

                        return(movie);
                    }
                };
                await MovieList.LoadMoreAsync();
            }).Wait();
        }
Beispiel #6
0
            InfiniteScrollCollection <DataItem> GetItems(bool clearList, int COUNT)
            {
                InfiniteScrollCollection <DataItem> items;

                if (clearList || Items == null)
                {
                    items = new InfiniteScrollCollection <DataItem>();
                }
                else
                {
                    items = new InfiniteScrollCollection <DataItem>(Items);
                }
                int SKIP = COUNT * 10;

                var obj = homeItems.Skip(SKIP).Take(10);

                foreach (DataItem item in obj)
                {
                    items.Add(new DataItem {
                        Title = item.Title.ToString(), ImageUrl = item.ImageUrl
                    });
                }


                return(items);
            }
Beispiel #7
0
        public override async Task InitializeAsync(object navigationData)
        {
            IsBusy = true;
            try
            {
                var list = await GetMoreUpComingAsync();

                Upcoming               = new InfiniteScrollCollection <Movie>(list);
                Upcoming.OnLoadMore   += GetMoreUpComingAsync;
                Upcoming.OnCanLoadMore = () => _hasMorePages;
                IsEmpty = list.Count() == 0;
            }
            catch (RestRequestException ex)
            {
                IsEmpty = true;
                MessagingCenter.Send(this, AppSettings.DialogMessage, ex.Message);
            }
            catch (Exception ex)
            {
                IsEmpty = true;
                MessagingCenter.Send(this, AppSettings.DialogMessage, "Ocorreu um erro inesperado ao obter lista de Filmes");
            }
            finally
            {
                IsBusy = false;
            }
        }
        public MainPage()
        {
            InitializeComponent();
            SetupDataTemplates();

            listView.ItemTemplate = new PostTemplateSelector
            {
                ImageTemplate       = imageTemplate,
                UnsupportedTemplate = unsupportedTemplate
            };

            Items = new InfiniteScrollCollection <Models.Post>
            {
                OnLoadMore = async() =>
                {
                    var result = await PostDataService.GetPosts(25, After);

                    var items = result.Item1;
                    After = result.Item2;
                    return(items);
                }
            };

            Populate();
        }
Beispiel #9
0
        public MovieViewModel()
        {
            movies = new InfiniteScrollCollection <Movie>
            {
                OnLoadMore = async() =>
                {
                    IsBusy = true;

                    // load the next page
                    var page = movies.Count / PageSize;

                    var items = await movieService.GetMoviesAsync(page, PageSize);

                    IsBusy = false;

                    // return the items that need to be added
                    return(items);
                },
                OnCanLoadMore = () =>
                {
                    return(movies.Count < 100);
                }
            };
            _ = DownloadDataAsync();
        }
Beispiel #10
0
        public MovieViewModel()
        {
            try
            {
                Items = new InfiniteScrollCollection <Result>
                {
                    OnLoadMore = async() =>
                    {
                        IsBusy = true;


                        var page = Items.Count / PageSize;

                        var items = await _dataService.GetItemsAsync(page, PageSize);

                        IsBusy = false;


                        return(items);
                    },
                    OnCanLoadMore = () =>
                    {
                        return(Items.Count > 0);
                    }
                };

                DownloadDataAsync();
            }
            catch (System.Exception ex)
            {
                App.Current.MainPage.DisplayAlert("Oops...", "Deu Ruim na conexão. Tente Novamente", "Ok");
            }
        }
Beispiel #11
0
        public PredictionPageViewModel(IPageService pageService) : this()
        {
            _pageService = pageService;

            try
            {
                Movie = new InfiniteScrollCollection <MovieShort>()
                {
                    OnLoadMore = async() =>
                    {
                        IsBusy = true;
                        await _pageService.PushAsync(new PopupLoading());

                        var movies = LoadMoreMovies();
                        await _pageService.PopAsync();

                        IsBusy = false;
                        return(movies);
                    },
                    OnCanLoadMore = () => !_isEnded
                };

                var movieList = LoadMoreMovies();
                Movie.AddRange(movieList);
            }
            catch (Exception) { }
        }
Beispiel #12
0
        public ScrollListViewModel(ObservableCollection <MovieShort> moviesList, LoadMore loadMethod, IPageService pageService) : this()
        {
            _loadMore    = loadMethod;
            _pageService = pageService;

            try
            {
                Movie = new InfiniteScrollCollection <MovieShort>(moviesList)
                {
                    OnLoadMore = async() =>
                    {
                        IsBusy = true;
                        await _pageService.PushAsync(new PopupLoading());

                        var movies = LoadMoreMovies();
                        await _pageService.PopAsync();

                        IsBusy = false;
                        return(movies);
                    },
                    OnCanLoadMore = () => !_isEnded
                };
            }
            catch (Exception) { }
        }
        // PartyDetailBindData
        /// <summary>
        /// This for integrating data in view model from API
        /// </summary>
        /// <returns></returns>

        InfiniteScrollCollection <PartyListModel> GetItems(bool clearList, List <Candidature> Party, string voteButtonStatus, string VotepopUpStatus)
        {
            InfiniteScrollCollection <PartyListModel> items;

            if (clearList || Items == null)
            {
                items = new InfiniteScrollCollection <PartyListModel>();
            }
            else
            {
                items = new InfiniteScrollCollection <PartyListModel>(Items);
            }

            foreach (var partyItem in Party)
            {
                items.Add(new PartyListModel
                {
                    partyID = Convert.ToString(partyItem.CandidatureCode),

                    partyImg = partyItem.Image,

                    partyName = partyItem.CandidatureName,

                    partySortName = partyItem.CandidatureSortName,

                    voteButtonVisiblity = voteButtonStatus == "1" ? false : true,

                    voteImag = voteButtonStatus == "1" ? "votepartiesNew1.png" : "vote_button_green1.png"
                });
            }

            return(items);
        }
        InfiniteScrollCollection <NewsItems> GetItems(bool clearList, List <wsNews> newsItemList)
        {
            InfiniteScrollCollection <NewsItems> items;

            if (clearList || Items == null)
            {
                items = new InfiniteScrollCollection <NewsItems>();
            }
            else
            {
                items = new InfiniteScrollCollection <NewsItems>(Items);
            }



            foreach (var newsItem in newsItemList)
            {
                items.Add(new NewsItems
                {
                    Title       = UppercaseFirst(newsItem.Title),
                    Description = UppercaseFirst(newsItem.SubTitle),

                    ImageUrl = newsItem.PictureUrl
                });
            }

            return(items);
        }
        public MoviesSearchViewModel()
        {
            SearchCommand = new Command(() =>
            {
                Items = new InfiniteScrollCollection <Result>
                {
                    OnLoadMore = async() =>
                    {
                        IsBusy = true;

                        var page = Items.Count / PageSize;

                        var items = await _dataService.GetSearchAsync(Term, page, PageSize);

                        IsBusy = false;


                        return(items);
                    },
                    OnCanLoadMore = () =>
                    {
                        return(Items.Count > 0);
                    }
                };

                DownloadDataAsync();
            });
        }
Beispiel #16
0
        public MainViewModel()
        {
            Movies = new InfiniteScrollCollection <MoviesNewClass.Resultado>
            {
                //todo scrool dispara esse evento
                OnLoadMore = async() =>
                {
                    IsBusy = true;

                    pageIndex++;
                    var movies = await _service.GeAllMovies(pageIndex);

                    IsBusy = false;
                    ClearOld();
                    return(movies);
                }
            };


            RefreshCommand = new Command(() =>
            {
                // clear and start again
                Movies.Clear();
                Movies.LoadMoreAsync();
            });

            Movies.LoadMoreAsync();
        }
Beispiel #17
0
 public StoreViewModel()
 {
     StoreCollection = new InfiniteScrollCollection <object>();
     StoreCollection.OnCanLoadMore = () => StoreCollection.Count < TotalCount;
     StoreCollection.OnLoadMore   += async() =>
     {
         return(await LoadData(SelectedItem.Type));
     };
 }
        public GroupedViewModel()
        {
            var dataSource = new FakeDataSource();

            Items = new InfiniteScrollCollection <GroupCollection <DataItem> >
            {
                OnLoadMore = async() =>
                {
                    // load the next page
                    var page  = Items.Sum(i => i.Count) / PageSize;
                    var items = await dataSource.GetItemsAsync(page + 1, PageSize);

                    // go through each group from the server
                    foreach (var group in items.GroupBy(i => i.Group))
                    {
                        // look to see if these items belong to any existing groups
                        var inList = Items.LastOrDefault(i => i.Group == group.Key);

                        if (inList != null)
                        {
                            // this is an existing group, so add the items to that
                            foreach (var item in group)
                            {
                                inList.Add(item);
                            }

                            // TODO: instead of adding each item individually, we could make use of
                            //       the RangedObservableCollection from the NuGet:
                            //       https://github.com/mattleibow/RangedObservableCollection
                            //       this would become:
                            //
                            //           inList.AddRange(group);
                        }
                        else
                        {
                            // this is a new group
                            Items.Add(new GroupCollection <DataItem>(group)
                            {
                                Group = group.Key
                            });
                        }
                    }

                    return(null);                    // we have added the items ourselves
                }
            };

            RefreshCommand = new Command(() =>
            {
                // clear and start again
                Items.Clear();
                Items.LoadMoreAsync();
            });

            // load the initial data
            Items.LoadMoreAsync();
        }
Beispiel #19
0
        /// <summary>
        /// Loads this instance.
        /// </summary>
        /// <returns></returns>
        private async Task <InfiniteScrollCollection <MessageViewModel> > Load()
        {
            var list = new InfiniteScrollCollection <MessageViewModel>();
            List <ImapMessageInfo> msgs = await loader.LoadMessages();

            foreach (var i in msgs)
            {
                list.Add(new MessageViewModel(i));
            }
            IsBusy = false;
            return(list);
        }
        public MainViewModel()
        {
            Items = new InfiniteScrollCollection <InstagramModel>
            {
                OnLoadMore = async() => {
                    IsBussy = true;
                    var items = await GetWaifus();

                    IsBussy = false;
                    return(items);
                }
            };
            GetData();
            Histories = new ObservableCollection <InstagramModel>(new List <InstagramModel> {
                new InstagramModel {
                    ProfilePicture = "https://randomuser.me/api/portraits/women/65.jpg", UserName = "******"
                },
                new InstagramModel {
                    ProfilePicture = "https://randomuser.me/api/portraits/women/0.jpg", UserName = "******"
                },
                new InstagramModel {
                    ProfilePicture = "https://randomuser.me/api/portraits/men/46.jpg", UserName = "******"
                },
                new InstagramModel {
                    ProfilePicture = "https://randomuser.me/api/portraits/women/54.jpg", UserName = "******"
                },
                new InstagramModel {
                    ProfilePicture = "https://randomuser.me/api/portraits/men/24.jpg", UserName = "******"
                },
                new InstagramModel {
                    ProfilePicture = "https://randomuser.me/api/portraits/women/64.jpg", UserName = "******"
                },
                new InstagramModel {
                    ProfilePicture = "https://randomuser.me/api/portraits/women/13.jpg", UserName = "******"
                },
                new InstagramModel {
                    ProfilePicture = "https://randomuser.me/api/portraits/women/18.jpg", UserName = "******"
                },
                new InstagramModel {
                    ProfilePicture = "https://randomuser.me/api/portraits/women/17.jpg", UserName = "******"
                },
                new InstagramModel {
                    ProfilePicture = "https://randomuser.me/api/portraits/women/70.jpg", UserName = "******"
                },
                new InstagramModel {
                    ProfilePicture = "https://randomuser.me/api/portraits/women/91.jpg", UserName = "******"
                },
                new InstagramModel {
                    UserName = "******", ProfilePicture = "https://randomuser.me/api/portraits/men/3.jpg"
                }
            });
        }
 public CarrouselMoviesViewModel()
 {
     Title = "Movies List";
     ;
     ItemsMovie = new InfiniteScrollCollection <MoviesModel>();
     ItemTresholdReachedCommand = new Command(async() => await ItemsTresholdReached());
     ShowMovieDetailCommand     = new Command(async() => await ExecuteMovieDetail());
     RefreshItemsCommand        = new Command(async() =>
     {
         await ExecuteLoadItemsCommand();
         IsRefreshing = false;
     });
 }
Beispiel #22
0
        public GroupViewList()
        {
            InitializeComponent();
            //BindingContext = new GroupListViewModel();
            Items = new InfiniteScrollCollection <ObservableGroupCollection <string, Items> >
            {
                OnLoadMore = async() =>
                {
                    // load the next page
                    IsWorking      = true;
                    ListItemsCount = 0;
                    foreach (var _itemslist in Items)
                    {
                        ListItemsCount += _itemslist.Count;
                    }
                    double _pagecount = (double)ListItemsCount / PageSize;
                    var    page       = Convert.ToInt32(Math.Ceiling(_pagecount));
                    var    items      = await DataItems.GetItemsAsync(page, PageSize);

                    var _items = items.GroupBy(e => e.Title).Select(e => new ObservableGroupCollection <string, Items>(e)).ToList();
                    if (_items.Count > 0)
                    {
                        foreach (var getGroupItems in _items.GroupBy(i => i.Header).ToList())
                        {
                            var _GetExistingGroupItems = Items.LastOrDefault(i => i.Header == getGroupItems.Key);
                            if (_GetExistingGroupItems != null && _GetExistingGroupItems.Count > 0)
                            {
                                // this is an existing group, so add the items to that
                                foreach (var _ExistingGroupedItems in getGroupItems.ToList())
                                {
                                    foreach (var _GroupListitems in _ExistingGroupedItems.ToList())
                                    {
                                        _GetExistingGroupItems.Add(_GroupListitems);  //Update items
                                    }
                                }
                            }
                            else
                            {
                                //Add new Group
                                Items.AddRange(getGroupItems);
                                GroupItems.ItemsSource = Items;
                            }
                        }
                    }

                    IsWorking = false;
                    return(null);
                }
            };
            loadDataAsync();
        }
        public MainPageViewModel(INavigationService navigationService, IPokeApi pokeApi, IPageDialogService pageDialogService)
            : base(navigationService)
        {
            Title = "Main Page";

            _pokeApi           = pokeApi;
            _pageDialogService = pageDialogService;

            NavegarCommand = new DelegateCommand <Pokemon>(async(pokemon) => await NavegarCommandExecute(pokemon));
            GaleriaCommand = new DelegateCommand <Pokemon>(async(pokemon) => await GaleriaCommandExecute(pokemon));
            RefreshCommand = new DelegateCommand(async() => await RefreshCommandExecute());

            Pokemons = new InfiniteScrollCollection <Pokemon>
            {
                OnLoadMore = async() =>
                {
                    IsBusy = true;
                    var items = new List <Pokemon>();
                    PokemonList = await _pokeApi.ObterListaPokemons(offset : OffSet);

                    if (PokemonList != null)
                    {
                        foreach (var poke in PokemonList.results)
                        {
                            var pokemon = await _pokeApi.ObterPokemon(poke.url);

                            if (pokemon != null)
                            {
                                items.Add(pokemon);
                            }
                        }
                        offset += 20;
                    }
                    IsBusy = false;

                    return(items);
                },
                OnCanLoadMore = () =>
                {
                    if (!string.IsNullOrEmpty(PokemonList.next))
                    {
                        return(true);
                    }

                    return(false);
                }
            };

            Pokemons.LoadMoreAsync();
        }
Beispiel #24
0
 public TaskPageModel()
 {
     canLoadMore   = true;
     PerformSearch = new Command(PerformSearchExcute);
     JobsList      = new InfiniteScrollCollection <JobEmployerDataModel>();
     GetJobList    = new ObservableCollection <JobEmployerDataModel>();
     TempjobList   = new ObservableCollection <JobEmployerDataModel>();
     showlist      = true;
     thereisnodata = false;
     Device.BeginInvokeOnMainThread(async() =>
     {
         await GetInfintyData(pagenumber);
     });
 }
Beispiel #25
0
 public MainPageViewModel(INavigationService navigationService, IPageDialogService pageDialogService,
                          IRestRepository restRepository) : base(navigationService)
 {
     PageDialogService = pageDialogService;
     RestRepository    = restRepository;
     SourceCoins       = new List <Coin>();
     Coins             = new InfiniteScrollCollection <Coin>
     {
         OnLoadMore    = OnLoadList(),
         OnCanLoadMore = () => Coins.Count < SourceCoins.Count
     };
     SearchCommand     = new DelegateCommand(Search);
     ItemTappedCommand = new DelegateCommand(async() => await ShowCoinDetails());
     RefreshCommand    = new DelegateCommand(async() => await GetCoins());
     RefreshCommand.Execute();
 }
 public MarketHistoryPageViewModel(INavigationService navigationService, IPageDialogService pageDialogService,
                                   IRestRepository restRepository) : base(navigationService)
 {
     PageDialogService = pageDialogService;
     RestRepository    = restRepository;
     SourceList        = new List <MarketHistory>();
     MarketHistories   = new InfiniteScrollCollection <MarketHistory>
     {
         OnLoadMore = async() =>
         {
             var page = MarketHistories.Count / PageSize;
             return(await Task.Run(() => LoadMarketHistory(page)));
         },
         OnCanLoadMore = () => MarketHistories.Count < SourceList.Count
     };
     RefreshCommand = new DelegateCommand(async() => await GetMarketHistory());
 }
Beispiel #27
0
        public SearchRequestViewModel()
        {
            apiService = new ApiServices();
            StatusList = GetStatus().OrderBy(t => t.name).ToList();

            Task.Run(async() =>
            {
                Requests = new InfiniteScrollCollection <Request>
                {
                    OnLoadMore = async() =>
                    {
                        //IsRefreshing = true;
                        // load the next page
                        var page = Requests.Count / PageSize;

                        var _searchModel = new SearchModel
                        {
                            maxResult = 200,
                            order     = "desc",
                            sortedBy  = "request_creation_date",
                            date      = CheckDateFrom,
                            date1     = CheckDateTo,
                            status    = SelectedStatus.name
                        };
                        var cookie   = Settings.Cookie;
                        var res      = cookie.Substring(11, 32);
                        var response = await apiService.PostRequest <Request>(
                            "https://portalesp.smart-path.it",
                            "/Portalesp",
                            "/request/searchRequest?mobile=mobile",
                            res,
                            _searchModel);
                        requestsList = (List <Request>)response.Result;
                        //IsRefreshing = false;
                        return(requestsList);
                    },
                    OnCanLoadMore = () =>
                    {
                        return(Requests.Count < 100 * PageSize);
                        // return Requests.Count < TotalCount;
                    }
                };
                // GetRequests();
                await Requests.LoadMoreAsync();
            });
        }
Beispiel #28
0
        /// <summary>
        /// Initializes a new instance of the <see cref="ListViewModel"/> class.
        /// </summary>
        /// <param name="page">The page.</param>
        public ListViewModel(Page page)
        {
            this.page = page;
            Messages  = new InfiniteScrollCollection <MessageViewModel>
            {
                OnLoadMore = async() =>
                {
                    IsBusy = true;
                    var list = await Load();

                    IsBusy = false;
                    return(list);
                },
                OnCanLoadMore = () => loader.MessagesLoaded < loader.MessagesCount
            };
            LoadMessages();
        }
 public SellOrdersPageViewModel(INavigationService navigationService, IPageDialogService pageDialogService,
                                IRestRepository restRepository) : base(navigationService)
 {
     PageDialogService = pageDialogService;
     RestRepository    = restRepository;
     SourceList        = new List <OrdersData>();
     SellOrders        = new InfiniteScrollCollection <OrdersData>
     {
         OnLoadMore = async() =>
         {
             var page = SellOrders.Count / PageSize;
             return(await Task.Run(() => LoadSellOrders(page)));
         },
         OnCanLoadMore = () => SellOrders.Count < SourceList.Count
     };
     RefreshCommand = new DelegateCommand(async() => await GetMarketDataOrders());
 }
        internal UpcomingMovieViewModel(UpcomingMovieService upcomingMovieService)
        {
            _upcomingMovieService = upcomingMovieService ?? throw new ArgumentException("upcomingMovieService");

            Title = "TMDb Upcoming Movies";
            ListView_ItemsSource = new InfiniteScrollCollection <MovieModel>
            {
                OnLoadMore = async() =>
                {
                    try
                    {
                        if (IsBusy)
                        {
                            return(null);
                        }

                        IsBusy = true;
                        var page = (uint)(ListView_ItemsSource.Count / PageSize) + 1;

                        if (totalPages > 0 &&
                            page >= totalPages)
                        {
                            IsBusy = false;
                            return(null);
                        }

                        var model = await GetMovieCollectionAsync(page);

                        totalPages = (uint)model.TotalPages;
                        IsBusy     = false;
                        return(model.MovieCollection);
                    }
                    catch (Exception ex)
                    {
                        IsBusy = false;
                        Debug.WriteLine(ex);
                        throw;
                    }
                }
            };

            ListView_RefreshCommand   = new Command(async() => await ExecuteListView_RefreshCommand_HandlerAsync());
            ToolbarItemSearch_Command = new Command(async() => await ToolbarItemSearch_Command_HandlerAsync());
            _ExecuteListView_RefreshCommand_HandlerAsync();
        }