Exemple #1
0
        /// <summary>
        /// Navigate to.
        /// </summary>
        /// <param name="parameter">Parameter.</param>
        public void NavigateTo(object parameter)
        {
            var collection = m_DataContext.GetCollection <CinemaHallReleaseEntity> ();

            m_ReleasesEntity = collection.FirstOrDefault();

            if (m_ReleasesEntity == null)
            {
                m_ReleasesEntity = new CinemaHallReleaseEntity {
                    Releases = new List <long> ()
                };
                collection.Add(m_ReleasesEntity);
            }

            IsEmptyList = !m_ReleasesEntity.Releases.Any();

            var releases = m_ReleasesService.GetReleases();

            var releasesDictionary = releases.ToDictionary(a => a.Id);

            var cinemaHallReleases = new List <CinemaHallReleaseModel> ();
            var iterator           = -1;

            foreach (var releaseId in m_ReleasesEntity.Releases)
            {
                var releaseModel = releasesDictionary[releaseId];
                cinemaHallReleases.Add(
                    new CinemaHallReleaseModel {
                    Title       = releaseModel.Title,
                    Description = releaseModel.Description,
                    Order       = iterator,
                    Poster      = m_AnilibriaApiService.GetUrl(releaseModel.Poster),
                    ReleaseId   = releaseModel.Id
                }
                    );
            }

            RefreshReleases(cinemaHallReleases);

            RaiseCommands();

            m_AnalyticsService.TrackEvent("CinemaHallpage", "NavigatedTo", "Simple");
        }
 private void RefreshAfterSynchronize(object parameter) => m_Releases = m_ReleasesService.GetReleases();
        private async Task SynchronizeReleasesFromSource(Func <Task <IEnumerable <Release> > > loadContentHandler)
        {
            try {
                var firstRun = !m_ReleasesService.GetReleases().Any();

                var releases = await loadContentHandler();

                var cacheReleases = m_ReleasesService.GetReleases().ToList();

                var changesCollection = m_DataContext.GetCollection <ChangesEntity> ();
                var changes           = GetChanges(changesCollection);

                if (changes != null)
                {
                    SaveHistoryChanges(changes, cacheReleases);
                }

                var cacheReleasesDictionary = cacheReleases.ToDictionary(a => a.Id);

                foreach (var release in releases)
                {
                    cacheReleasesDictionary.TryGetValue(release.Id, out var cacheRelease);

                    if (cacheRelease == null)
                    {
                        cacheReleases.Add(MapToRelease(release));
                        if (cacheReleases.Count() > 0)
                        {
                            if (changes.NewReleases == null)
                            {
                                changes.NewReleases = new List <long> {
                                    release.Id
                                };
                            }
                            else
                            {
                                var newReleases = changes.NewReleases.ToList();
                                newReleases.Add(release.Id);
                                changes.NewReleases = newReleases;
                            }
                        }
                    }
                    else
                    {
                        UpdateCachedRelease(release, cacheRelease, changes);
                    }
                }

                m_ReleasesService.SetReleases(cacheReleases);
                await m_ReleasesService.SaveReleases();

                if (!firstRun)
                {
                    changesCollection.Update(changes);
                }

                ObserverEvents.FireEvent("synchronizedReleases", null);
                ObserverEvents.FireEvent(
                    "showMessage",
                    new MessageModel {
                    Header  = "Синхронизация релизов",
                    Message = "Синхронизация релизов успешно выполнена"
                }
                    );
            } catch {
                ObserverEvents.FireEvent(
                    "showMessage",
                    new MessageModel {
                    Header  = "Синхронизация релизов",
                    Message = "Не удалось выполнить синхронизацию релизов"
                }
                    );
            }
        }