public async Task SynchronizeReleases()
        {
            await SynchronizeReleasesFromSource(
                async() => {
                var releases  = await m_AnilibriaApiService.GetPage(1, 2000);
                var schedules = await m_AnilibriaApiService.GetSchedule();

                SaveSchedule(schedules);

                return(releases);
            }
                );
        }
        public async Task SynchronizeReleases()
        {
            try {
                //uncomment experimental feature
                //var touchedReleases = await m_AnilibriaApiService.GetTouchedReleases ();
                var releases = await m_AnilibriaApiService.GetPage(1, 2000);

                var schedules = await m_AnilibriaApiService.GetSchedule();

                SaveSchedule(schedules);

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

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

                var cacheReleases = collection.Find(a => true);

                var addReleases     = new List <ReleaseEntity> ();
                var updatedReleases = new List <ReleaseEntity> ();

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

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

                    if (cacheRelease == null)
                    {
                        addReleases.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);
                        updatedReleases.Add(cacheRelease);
                    }
                }
                if (addReleases.Any())
                {
                    collection.AddRange(addReleases);
                }
                if (updatedReleases.Any())
                {
                    collection.Update(updatedReleases);
                }
                changesCollection.Update(changes);

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