protected override async Task OnRun()
        {
            var position = 0;

            using (var task = new SingletonReentrantTask(this, ComponentSlots.Database, SingletonReentrantTask.PRIORITY_LOW, async cancellationToken =>
            {
                var metaDataSource = this.MetaDataSourceFactory.Create();
                foreach (var libraryItem in this.LibraryItems)
                {
                    this.Description = Path.GetFileName(libraryItem.FileName);
                    this.Position = position;

                    if (!File.Exists(libraryItem.FileName))
                    {
                        Logger.Write(this, LogLevel.Debug, "File \"{0}\" no longer exists: Cannot refresh.", libraryItem.FileName);
                        continue;
                    }

                    var metaDatas = await metaDataSource.GetMetaData(libraryItem.FileName).ConfigureAwait(false);
                    MetaDataItem.Update(metaDatas, libraryItem.MetaDatas, null);

                    await this.WriteLibraryMetaData(libraryItem).ConfigureAwait(false);

                    libraryItem.Status = LibraryItemStatus.Import;
                    await LibraryTaskBase.UpdateLibraryItem(this.Database, libraryItem).ConfigureAwait(false);

                    position++;
                }
            }))
            {
                await task.Run().ConfigureAwait(false);
            }
        }
        private async Task WriteLibraryMetaData(LibraryItem libraryItem)
        {
            using (var transaction = this.Database.BeginTransaction(this.Database.PreferredIsolationLevel))
            {
                await this.Database.ExecuteAsync(this.Database.Queries.ClearLibraryMetaDataItems, (parameters, phase) =>
                {
                    switch (phase)
                    {
                    case DatabaseParameterPhase.Fetch:
                        parameters["itemId"] = libraryItem.Id;
                        parameters["type"]   = META_DATA_TYPE;
                        break;
                    }
                }, transaction).ConfigureAwait(false);

                using (var writer = new MetaDataWriter(this.Database, this.Database.Queries.AddLibraryMetaDataItem, transaction))
                {
                    await writer.Write(
                        libraryItem.Id,
                        libraryItem.MetaDatas,
                        metaDataItem => META_DATA_TYPE.HasFlag(metaDataItem.Type)
                        ).ConfigureAwait(false);
                }

                libraryItem.ImportDate = DateTimeHelper.ToString(DateTime.UtcNow.AddSeconds(30));
                await LibraryTaskBase.UpdateLibraryItem(this.Database, libraryItem, transaction).ConfigureAwait(false);

                if (transaction.HasTransaction)
                {
                    transaction.Commit();
                }
            }
        }
        protected override async Task OnRun()
        {
            var position = 0;

            using (var task = new SingletonReentrantTask(this, ComponentSlots.Database, SingletonReentrantTask.PRIORITY_LOW, async cancellationToken =>
            {
                var metaDataSource = this.MetaDataSourceFactory.Create();
                foreach (var libraryItem in this.LibraryItems)
                {
                    await this.SetDescription(new FileInfo(libraryItem.FileName).Name).ConfigureAwait(false);
                    await this.SetPosition(position).ConfigureAwait(false);

                    if (!File.Exists(libraryItem.FileName))
                    {
                        Logger.Write(this, LogLevel.Debug, "File \"{0}\" no longer exists: Cannot refresh.", libraryItem.FileName);
                        continue;
                    }

                    libraryItem.MetaDatas = new ObservableCollection <MetaDataItem>(
                        await metaDataSource.GetMetaData(libraryItem.FileName)
                        .ConfigureAwait(false));

                    await this.WriteLibraryMetaData(libraryItem).ConfigureAwait(false);
                    await LibraryTaskBase.SetLibraryItemStatus(this.Database, libraryItem.Id, LibraryItemStatus.Import).ConfigureAwait(false);

                    position++;
                }
            }))
            {
                await task.Run().ConfigureAwait(false);
            }
        }
        protected override async Task OnRun()
        {
            var position = 0;

            using (var task = new SingletonReentrantTask(this, ComponentSlots.Database, SingletonReentrantTask.PRIORITY_LOW, async cancellationToken =>
            {
                var metaDataSource = this.MetaDataSourceFactory.Create();
                foreach (var libraryItem in this.LibraryItems)
                {
                    if (this.IsCancellationRequested)
                    {
                        break;
                    }

                    await this.SetDescription(new FileInfo(libraryItem.FileName).Name).ConfigureAwait(false);
                    await this.SetPosition(position).ConfigureAwait(false);

                    if (!File.Exists(libraryItem.FileName))
                    {
                        Logger.Write(this, LogLevel.Debug, "File \"{0}\" no longer exists: Cannot update.", libraryItem.FileName);
                        this.Errors.Add(libraryItem, new FileNotFoundException(string.Format("File \"{0}\" no longer exists: Cannot update.", libraryItem.FileName)));
                        position++;
                        continue;
                    }

                    try
                    {
                        await metaDataSource.SetMetaData(
                            libraryItem.FileName,
                            libraryItem.MetaDatas,
                            metaDataItem => this.Names == null || !this.Names.Any() || this.Names.Contains(metaDataItem.Name, true)
                            ).ConfigureAwait(false);
                    }
                    catch (Exception e)
                    {
                        this.Errors.Add(libraryItem, e);
                        position++;
                        continue;
                    }

                    foreach (var metaDataItem in libraryItem.MetaDatas.ToArray())
                    {
                        if (!string.IsNullOrEmpty(metaDataItem.Value))
                        {
                            continue;
                        }
                        libraryItem.MetaDatas.Remove(metaDataItem);
                    }

                    await this.WriteLibraryMetaData(libraryItem).ConfigureAwait(false);
                    await LibraryTaskBase.SetLibraryItemStatus(this.Database, libraryItem.Id, LibraryItemStatus.Import).ConfigureAwait(false);

                    position++;
                }
            }))
            {
                await task.Run().ConfigureAwait(false);
            }
        }
        protected override async Task OnCompleted()
        {
            await base.OnCompleted().ConfigureAwait(false);

            //We don't need a lock for this so not performing in OnRun().
            var names = new HashSet <string>(StringComparer.OrdinalIgnoreCase);

            names.AddRange(LibraryTaskBase.UpdateLibraryCache(this.LibraryCache, this.LibraryItems, null));
            names.AddRange(LibraryTaskBase.UpdatePlaylistCache(this.PlaylistCache, this.LibraryItems, null));
            await this.SignalEmitter.Send(new Signal(this, CommonSignals.MetaDataUpdated, names)).ConfigureAwait(false);
        }
예제 #6
0
 protected virtual Task Schedule(PlaylistItem playlistItem)
 {
     playlistItem.Flags |= PlaylistItemFlags.Export;
     if (playlistItem.LibraryItem_Id.HasValue)
     {
         return(LibraryTaskBase.UpdateLibraryItem(
                    this.Database,
                    playlistItem.LibraryItem_Id.Value,
                    libraryItem => libraryItem.Flags |= LibraryItemFlags.Export
                    ));
     }
     return(PlaylistTaskBase.UpdatePlaylistItem(this.Database, playlistItem));
 }
        protected override async Task OnRun()
        {
            var position = 0;

            using (var task = new SingletonReentrantTask(this, ComponentSlots.Database, SingletonReentrantTask.PRIORITY_HIGH, async cancellationToken =>
            {
                foreach (var playlistItem in this.PlaylistItems)
                {
                    if (this.IsCancellationRequested)
                    {
                        break;
                    }

                    if (this.Visible)
                    {
                        this.Description = Path.GetFileName(playlistItem.FileName);
                        this.Position = position;
                    }

                    if (playlistItem.LibraryItem_Id.HasValue)
                    {
                        await this.WriteLibraryMetaData(playlistItem).ConfigureAwait(false);
                        await LibraryTaskBase.UpdateLibraryItem(
                            this.Database,
                            playlistItem.LibraryItem_Id.Value,
                            libraryItem => libraryItem.Status = LibraryItemStatus.Import
                            ).ConfigureAwait(false);
                    }
                    else
                    {
                        await this.WritePlaylistMetaData(playlistItem).ConfigureAwait(false);
                    }

                    if (this.WriteToFiles)
                    {
                        if (!await this.MetaDataManager.Synchronize(new[] { playlistItem }, this.Names.ToArray()).ConfigureAwait(false))
                        {
                            this.AddError(playlistItem, string.Format("Failed to write meta data to file \"{0}\". We will try again later.", playlistItem.FileName));
                        }
                    }

                    position++;
                }
            }))
            {
                await task.Run().ConfigureAwait(false);
            }
        }
        protected override async Task OnStarted()
        {
            if (this.Visible)
            {
                this.Name     = "Saving meta data";
                this.Position = 0;
                this.Count    = this.LibraryItems.Count();
            }
            await base.OnStarted().ConfigureAwait(false);

            //We don't need a lock for this so not waiting for OnRun().
            var names = new HashSet <string>(StringComparer.OrdinalIgnoreCase);

            names.AddRange(LibraryTaskBase.UpdateLibraryCache(this.LibraryCache, this.LibraryItems, this.Names));
            names.AddRange(LibraryTaskBase.UpdatePlaylistCache(this.PlaylistCache, this.LibraryItems, this.Names));
        }
예제 #9
0
 protected virtual async Task Deschedule(PlaylistItem playlistItem)
 {
     playlistItem.Flags &= ~PlaylistItemFlags.Export;
     if (playlistItem.LibraryItem_Id.HasValue)
     {
         await LibraryTaskBase.UpdateLibraryItem(
             this.Database,
             playlistItem.LibraryItem_Id.Value,
             libraryItem =>
         {
             libraryItem.ImportDate = DateTimeHelper.ToString(DateTime.UtcNow.AddSeconds(30));
             libraryItem.Flags     &= ~LibraryItemFlags.Export;
         }
             ).ConfigureAwait(false);
     }
     await PlaylistTaskBase.UpdatePlaylistItem(this.Database, playlistItem).ConfigureAwait(false);
 }
예제 #10
0
        public void InitializeDatabase(IDatabaseComponent database, DatabaseInitializeType type)
        {
            //IMPORTANT: When editing this function remember to change the checksum.
            if (!type.HasFlag(DatabaseInitializeType.Library))
            {
                return;
            }
            var scriptingRuntime = ComponentRegistry.Instance.GetComponent <IScriptingRuntime>();

            if (scriptingRuntime == null)
            {
                return;
            }
            using (var transaction = database.BeginTransaction(database.PreferredIsolationLevel))
            {
                var set = database.Set <LibraryHierarchy>(transaction);
                foreach (var libraryHierarchy in set)
                {
                    //TODO: Bad .Wait()
                    LibraryTaskBase.RemoveHierarchies(database, libraryHierarchy, null, transaction).Wait();
                }
                set.Clear();
                set.Add(new LibraryHierarchy()
                {
                    Name     = "Artist/Album/Title",
                    Type     = LibraryHierarchyType.Script,
                    Sequence = 0,
                    Enabled  = true,
                    Levels   = new ObservableCollection <LibraryHierarchyLevel>()
                    {
                        new LibraryHierarchyLevel()
                        {
                            Sequence = 0, Script = scriptingRuntime.CoreScripts.Artist
                        },
                        new LibraryHierarchyLevel()
                        {
                            Sequence = 1, Script = scriptingRuntime.CoreScripts.Year_Album
                        },
                        new LibraryHierarchyLevel()
                        {
                            Sequence = 2, Script = scriptingRuntime.CoreScripts.Disk_Track_Title
                        }
                    }
                });
                set.Add(new LibraryHierarchy()
                {
                    Name     = "Genre/Album/Title",
                    Type     = LibraryHierarchyType.Script,
                    Sequence = 1,
                    Enabled  = false,
                    Levels   = new ObservableCollection <LibraryHierarchyLevel>()
                    {
                        new LibraryHierarchyLevel()
                        {
                            Sequence = 0, Script = scriptingRuntime.CoreScripts.Genre
                        },
                        new LibraryHierarchyLevel()
                        {
                            Sequence = 1, Script = scriptingRuntime.CoreScripts.Year_Album
                        },
                        new LibraryHierarchyLevel()
                        {
                            Sequence = 2, Script = scriptingRuntime.CoreScripts.Disk_Track_Title
                        }
                    }
                });
                set.Add(new LibraryHierarchy()
                {
                    Name     = "Genre/Rating/Artist - Title [BPM]",
                    Type     = LibraryHierarchyType.Script,
                    Sequence = 2,
                    Enabled  = false,
                    Levels   = new ObservableCollection <LibraryHierarchyLevel>()
                    {
                        new LibraryHierarchyLevel()
                        {
                            Sequence = 0, Script = scriptingRuntime.CoreScripts.Genre
                        },
                        new LibraryHierarchyLevel()
                        {
                            Sequence = 1, Script = scriptingRuntime.CoreScripts.Rating
                        },
                        new LibraryHierarchyLevel()
                        {
                            Sequence = 2, Script = scriptingRuntime.CoreScripts.Artist_Title_BPM
                        }
                    }
                });
                set.Add(new LibraryHierarchy()
                {
                    Name     = "Folder Structure",
                    Type     = LibraryHierarchyType.FileSystem,
                    Sequence = 3,
                    Enabled  = false
                });
                transaction.Commit();
            }
        }
예제 #11
0
 protected virtual Task Deschedule(LibraryItem libraryItem)
 {
     libraryItem.ImportDate = DateTimeHelper.ToString(DateTime.UtcNow.AddSeconds(30));
     libraryItem.Flags     &= ~LibraryItemFlags.Export;
     return(LibraryTaskBase.UpdateLibraryItem(this.Database, libraryItem));
 }
예제 #12
0
 protected virtual Task Schedule(LibraryItem libraryItem)
 {
     libraryItem.Flags |= LibraryItemFlags.Export;
     return(LibraryTaskBase.UpdateLibraryItem(this.Database, libraryItem));
 }