public void Switch(JryVideoDataSourceProviderManagerMode mode)
        {
            switch (mode)
            {
                case JryVideoDataSourceProviderManagerMode.Public:
                    this.CurrentDataCenter = this.NormalDataCenter;
                    break;

                case JryVideoDataSourceProviderManagerMode.Private:
                    this.CurrentDataCenter = this.SecureDataCenter;
                    break;

                default:
                    throw new ArgumentOutOfRangeException(nameof(mode), mode, null);
            }
        }
Exemple #2
0
            public override async Task FixAsync(DataCenter dataCenter)
            {
                switch (this.Type)
                {
                case ErrorType.FlagCount:
                    var flag = await dataCenter.FlagManager.FindAsync(JryFlag.BuildFlagId(this.type, this.value));

                    if (flag != null)
                    {
                        flag.Count = this.count;
                        await dataCenter.FlagManager.UpdateAsync(flag);
                    }
                    else
                    {
                        Debug.Assert(false);
                    }
                    break;

                default:
                    throw new ArgumentOutOfRangeException();
                }
            }
Exemple #3
0
        public void Switch(JryVideoDataSourceProviderManagerMode mode)
        {
            if (this.threadId != Thread.CurrentThread.ManagedThreadId)
            {
                throw new InvalidOperationException();
            }

            var old = this.CurrentDataCenter;

            switch (mode)
            {
                case JryVideoDataSourceProviderManagerMode.Public:
                    this.CurrentDataCenter = this.NormalDataCenter;
                    break;

                case JryVideoDataSourceProviderManagerMode.Private:
                    this.CurrentDataCenter = this.SecureDataCenter;
                    break;

                default:
                    throw new ArgumentOutOfRangeException(nameof(mode), mode, null);
            }

            var @new = this.CurrentDataCenter;

            if (old != @new)
            {
                if (old != null)
                {
                    old.FlagManager.FlagChanged -= this.FlagManager_FlagChanged;
                }

                Debug.Assert(@new != null);
                @new.FlagManager.FlagChanged += this.FlagManager_FlagChanged;
            }
        }
            public override async Task FixAsync(DataCenter dataCenter)
            {
                var oldId = this.cover.Id;

                switch (this.Type)
                {
                    case ErrorType.CoverMissingParent:
                        switch (this.cover.CoverType)
                        {
                            case CoverType.Artist:
                                break;

                            case CoverType.Video:
                                break;

                            case CoverType.Background:
                                break;

                            case CoverType.Role:
                                if (this.cover.ActorId != null)
                                {
                                    if (this.cover.VideoId != null)
                                    {
                                        if (this.cover.SeriesId != null)
                                        {

                                        }
                                        else
                                        {
                                            var roleCol = await dataCenter.VideoRoleManager.FindAsync(this.cover.VideoId);
                                            var matchs = roleCol.Roles().Where(z => z.ActorId == this.cover.ActorId).ToArray();
                                            if (matchs.Length != 1) return;
                                            var cover = await dataCenter.CoverManager.FindAsync((matchs[0] as ICoverParent).CoverId);
                                            if (cover != null) return;
                                            cover = await dataCenter.CoverManager.FindAsync(this.cover.Id);
                                            cover.Id = (matchs[0] as ICoverParent).CoverId;
                                            await dataCenter.CoverManager.InsertOrUpdateAsync(cover);
                                            await dataCenter.CoverManager.RemoveAsync(oldId);
                                        }
                                    }
                                    else
                                    {

                                    }
                                }

                                break;

                            default:
                                throw new ArgumentOutOfRangeException();
                        }
                        break;

                    default:
                        throw new ArgumentOutOfRangeException();
                }
            }
 public virtual Task FixAsync(DataCenter dataCenter) => Task.FromResult(0);
 public DatabaseHealthTester(DataCenter dataCenter)
 {
     this.dataCenter = dataCenter;
 }
Exemple #7
0
 public void Initialize(DataCenter dataCenter)
 {
     dataCenter.SeriesManager.ItemRemoved      += this.SeriesManager_ItemRemoved;
     dataCenter.SeriesManager.VideoInfoRemoved += this.SeriesManager_VideoInfoRemoved;
 }
Exemple #8
0
 public DatabaseHealthTester(DataCenter dataCenter)
 {
     this.dataCenter = dataCenter;
 }
 private async Task<bool> TryAutoAddCoverAsync(DataCenter dataCenter, TheTVDBClient client, RemoteId removeId, VideoRole role)
 {
     var theTVDBId = await client.TryGetTheTVDBSeriesIdByRemoteIdAsync(removeId);
     if (theTVDBId == null) return false;
     var actor = await dataCenter.ArtistManager.FindAsync(role.ActorId);
     if (actor == null) return false;
     var actors = (await client.GetActorsBySeriesIdAsync(theTVDBId)).ToArray();
     actors = actors.Where(z => z.Id == actor.TheTVDBId).ToArray();
     if (actors.Length != 1) return false;
     if (!actors[0].HasBanner) return false;
     var url = actors[0].BuildUrl(client);
     var builder = CoverBuilder.CreateRole(role);
     builder.Uri.Add(url);
     return await dataCenter.CoverManager.BuildCoverAsync(builder);
 }
            public bool Equals(DataCenter dataCenter, bool isOnlyTracking, string searchText, int pageIndex, int pageSize)
            {
                if (dataCenter != this.DataCenter) return false;

                if (isOnlyTracking) return this.IsOnlyTracking;

                if (pageIndex != this.PageIndex || pageSize != this.PageSize) return false;
                return this.IsSearchTextEquals(searchText);
            }
 public static async Task<SearchResult> SearchAsync(DataCenter dataCenter, string searchText, int pageIndex, int pageSize)
 {
     var result = new SearchResult(dataCenter)
     {
         SearchText = searchText?.Trim() ?? string.Empty,
         PageIndex = pageIndex,
         PageSize = pageSize
     };
     await result.LoadAsync(dataCenter.SeriesManager);
     return result;
 }
 public static async Task<SearchResult> OnlyTrackingAsync(DataCenter dataCenter)
 {
     var result = new SearchResult(dataCenter)
     {
         IsOnlyTracking = true
     };
     await result.LoadAsync(dataCenter.SeriesManager);
     return result;
 }
 private SearchResult(DataCenter dataCenter)
 {
     this.DataCenter = dataCenter;
 }
Exemple #14
0
            public override async Task FixAsync(DataCenter dataCenter)
            {
                var oldId = this.cover.Id;

                switch (this.Type)
                {
                case ErrorType.CoverMissingParent:
                    switch (this.cover.CoverType)
                    {
                    case CoverType.Artist:
                        break;

                    case CoverType.Video:
                        break;

                    case CoverType.Background:
                        break;

                    case CoverType.Role:
                        if (this.cover.ActorId != null)
                        {
                            if (this.cover.VideoId != null)
                            {
                                if (this.cover.SeriesId != null)
                                {
                                }
                                else
                                {
                                    var roleCol = await dataCenter.VideoRoleManager.FindAsync(this.cover.VideoId);

                                    var matchs = roleCol.Roles().Where(z => z.ActorId == this.cover.ActorId).ToArray();
                                    if (matchs.Length != 1)
                                    {
                                        return;
                                    }
                                    var cover = await dataCenter.CoverManager.FindAsync((matchs[0] as ICoverParent).CoverId);

                                    if (cover != null)
                                    {
                                        return;
                                    }
                                    cover = await dataCenter.CoverManager.FindAsync(this.cover.Id);

                                    cover.Id = (matchs[0] as ICoverParent).CoverId;
                                    await dataCenter.CoverManager.InsertOrUpdateAsync(cover);

                                    await dataCenter.CoverManager.RemoveAsync(oldId);
                                }
                            }
                            else
                            {
                            }
                        }

                        break;

                    default:
                        throw new ArgumentOutOfRangeException();
                    }
                    break;

                default:
                    throw new ArgumentOutOfRangeException();
                }
            }
Exemple #15
0
 public virtual Task FixAsync(DataCenter dataCenter) => Task.FromResult(0);
            public override async Task FixAsync(DataCenter dataCenter)
            {
                switch (this.Type)
                {
                    case ErrorType.FlagCount:
                        var flag = await dataCenter.FlagManager.FindAsync(JryFlag.BuildFlagId(this.type, this.value));
                        if (flag != null)
                        {
                            flag.Count = this.count;
                            await dataCenter.FlagManager.UpdateAsync(flag);
                        }
                        else
                        {
                            Debug.Assert(false);
                        }
                        break;

                    default:
                        throw new ArgumentOutOfRangeException();
                }
            }
            /// <summary>
            /// return true if success.
            /// </summary>
            /// <param name="dataCenter"></param>
            /// <param name="source"></param>
            /// <returns></returns>
            public async Task<bool> GenerateAsync(DataCenter dataCenter, ICoverParent source)
            {
                var client = JryVideoCore.Current.GetTheTVDBClient();
                if (client == null) return false;

                this.coverManager = dataCenter.CoverManager;
                return await this.AutoGenerateCoverAsync(client, this.source.InfoView.Source) ||
                       await this.AutoGenerateCoverOverTheTVDBIdAsync(client,
                           this.source.InfoView.SeriesView.Source.TheTVDBId,
                           this.source.InfoView.Source.Index.ToString()) ||
                       await this.AutoGenerateCoverAsync(client, this.source.InfoView.SeriesView.Source);
            }
Exemple #18
0
 public void Initialize(DataCenter dataCenter)
 {
     dataCenter.SeriesManager.CoverParentRemoving    += this.Manager_CoverParentRemoving;
     dataCenter.VideoRoleManager.CoverParentRemoving += this.Manager_CoverParentRemoving;
     dataCenter.ArtistManager.CoverParentRemoving    += this.Manager_CoverParentRemoving;
 }
            /// <summary>
            /// return true if success.
            /// </summary>
            /// <returns></returns>
            public async Task<bool> GenerateAsync(DataCenter dataCenter, ICoverParent source)
            {
                var client = JryVideoCore.Current.GetTheTVDBClient();
                if (client == null) return false;

                var role = (VideoRole)source;

                var tvdb = this.TheTVDBItem;
                if (tvdb != null && !tvdb.TheTVDBId.IsNullOrWhiteSpace())
                {
                    if (await this.TryAutoAddCoverAsync(dataCenter, client, new RemoteId(RemoteIdType.TheTVDB, tvdb.TheTVDBId), role))
                    {
                        return true;
                    }
                }

                var imdb = this.ImdbItem.GetValidImdbId();
                if (imdb != null)
                {
                    if (await this.TryAutoAddCoverAsync(dataCenter, client, new RemoteId(RemoteIdType.Imdb, imdb), role))
                    {
                        return true;
                    }
                }

                return false;
            }
Exemple #20
0
 public void Initialize(DataCenter dataCenter)
 {
     dataCenter.SeriesManager.VideoInfoRemoved += this.SeriesManager_VideoInfoRemoved;
     dataCenter.FlagManager.FlagChanged        += this.FlagManager_FlagChanged;
 }
 public SeriesManager(DataCenter dataCenter, ISeriesSet source)
     : base(source)
 {
     this.DataCenter = dataCenter;
 }
Exemple #22
0
 public void Initialize(DataCenter dataCenter)
 {
     dataCenter.FlagManager.FlagChanged += this.FlagManager_FlagChanged;
 }