Apply review suggestion

MediaBrowser.Providers/Manager/MetadataService.cs

@@ -655,119 +655,121 @@ namespace MediaBrowser.Providers.Manager
                 await RunCustomProvider(provider, item, logName, options, refreshResult, cancellationToken).ConfigureAwait(false);
             }
 
-            if (!item.IsLocked)
+            if (item.IsLocked)
             {
-                var temp = new MetadataResult<TItemType>
-                {
-                    Item = CreateNew()
-                };
-                temp.Item.Path = item.Path;
-                temp.Item.Id = item.Id;
+                return refreshResult;
+            }
 
-                var foundImageTypes = new List<ImageType>();
-                foreach (var provider in providers.OfType<ILocalMetadataProvider<TItemType>>())
-                {
-                    var providerName = provider.GetType().Name;
-                    Logger.LogDebug("Running {Provider} for {Item}", providerName, logName);
+            var temp = new MetadataResult<TItemType>
+            {
+                Item = CreateNew()
+            };
+            temp.Item.Path = item.Path;
+            temp.Item.Id = item.Id;
+
+            var foundImageTypes = new List<ImageType>();
+            foreach (var provider in providers.OfType<ILocalMetadataProvider<TItemType>>())
+            {
+                var providerName = provider.GetType().Name;
+                Logger.LogDebug("Running {Provider} for {Item}", providerName, logName);
 
-                    var itemInfo = new ItemInfo(item);
+                var itemInfo = new ItemInfo(item);
 
-                    try
-                    {
-                        var localItem = await provider.GetMetadata(itemInfo, options.DirectoryService, cancellationToken).ConfigureAwait(false);
+                try
+                {
+                    var localItem = await provider.GetMetadata(itemInfo, options.DirectoryService, cancellationToken).ConfigureAwait(false);
 
-                        if (localItem.HasMetadata)
+                    if (localItem.HasMetadata)
+                    {
+                        foreach (var remoteImage in localItem.RemoteImages)
                         {
-                            foreach (var remoteImage in localItem.RemoteImages)
+                            try
                             {
-                                try
-                                {
-                                    if (item.ImageInfos.Any(x => x.Type == remoteImage.Type)
-                                        && !options.IsReplacingImage(remoteImage.Type))
-                                    {
-                                        continue;
-                                    }
-
-                                    await ProviderManager.SaveImage(item, remoteImage.Url, remoteImage.Type, null, cancellationToken).ConfigureAwait(false);
-                                    refreshResult.UpdateType |= ItemUpdateType.ImageUpdate;
-
-                                    // remember imagetype that has just been downloaded
-                                    foundImageTypes.Add(remoteImage.Type);
-                                }
-                                catch (HttpRequestException ex)
+                                if (item.ImageInfos.Any(x => x.Type == remoteImage.Type)
+                                    && !options.IsReplacingImage(remoteImage.Type))
                                 {
-                                    Logger.LogError(ex, "Could not save {ImageType} image: {Url}", Enum.GetName(remoteImage.Type), remoteImage.Url);
+                                    continue;
                                 }
-                            }
 
-                            if (foundImageTypes.Count > 0)
-                            {
-                                imageService.UpdateReplaceImages(options, foundImageTypes);
-                            }
+                                await ProviderManager.SaveImage(item, remoteImage.Url, remoteImage.Type, null, cancellationToken).ConfigureAwait(false);
+                                refreshResult.UpdateType |= ItemUpdateType.ImageUpdate;
 
-                            if (imageService.MergeImages(item, localItem.Images, options))
+                                // remember imagetype that has just been downloaded
+                                foundImageTypes.Add(remoteImage.Type);
+                            }
+                            catch (HttpRequestException ex)
                             {
-                                refreshResult.UpdateType |= ItemUpdateType.ImageUpdate;
+                                Logger.LogError(ex, "Could not save {ImageType} image: {Url}", Enum.GetName(remoteImage.Type), remoteImage.Url);
                             }
+                        }
 
-                            MergeData(localItem, temp, Array.Empty<MetadataField>(), false, true);
-                            refreshResult.UpdateType |= ItemUpdateType.MetadataImport;
+                        if (foundImageTypes.Count > 0)
+                        {
+                            imageService.UpdateReplaceImages(options, foundImageTypes);
+                        }
 
-                            break;
+                        if (imageService.MergeImages(item, localItem.Images, options))
+                        {
+                            refreshResult.UpdateType |= ItemUpdateType.ImageUpdate;
                         }
 
-                        Logger.LogDebug("{Provider} returned no metadata for {Item}", providerName, logName);
-                    }
-                    catch (OperationCanceledException)
-                    {
-                        throw;
-                    }
-                    catch (Exception ex)
-                    {
-                        Logger.LogError(ex, "Error in {Provider}", provider.Name);
+                        MergeData(localItem, temp, Array.Empty<MetadataField>(), false, true);
+                        refreshResult.UpdateType |= ItemUpdateType.MetadataImport;
 
-                        // If a local provider fails, consider that a failure
-                        refreshResult.ErrorMessage = ex.Message;
+                        break;
                     }
-                }
 
-                var isLocalLocked = temp.Item.IsLocked;
-                if (!isLocalLocked && (options.ReplaceAllMetadata || options.MetadataRefreshMode > MetadataRefreshMode.ValidationOnly))
+                    Logger.LogDebug("{Provider} returned no metadata for {Item}", providerName, logName);
+                }
+                catch (OperationCanceledException)
+                {
+                    throw;
+                }
+                catch (Exception ex)
                 {
-                    var remoteResult = await ExecuteRemoteProviders(temp, logName, false, id, providers.OfType<IRemoteMetadataProvider<TItemType, TIdType>>(), cancellationToken)
-                        .ConfigureAwait(false);
+                    Logger.LogError(ex, "Error in {Provider}", provider.Name);
 
-                    refreshResult.UpdateType |= remoteResult.UpdateType;
-                    refreshResult.ErrorMessage = remoteResult.ErrorMessage;
-                    refreshResult.Failures += remoteResult.Failures;
+                    // If a local provider fails, consider that a failure
+                    refreshResult.ErrorMessage = ex.Message;
                 }
+            }
+
+            var isLocalLocked = temp.Item.IsLocked;
+            if (!isLocalLocked && (options.ReplaceAllMetadata || options.MetadataRefreshMode > MetadataRefreshMode.ValidationOnly))
+            {
+                var remoteResult = await ExecuteRemoteProviders(temp, logName, false, id, providers.OfType<IRemoteMetadataProvider<TItemType, TIdType>>(), cancellationToken)
+                    .ConfigureAwait(false);
 
-                if (providers.Any(i => i is not ICustomMetadataProvider))
+                refreshResult.UpdateType |= remoteResult.UpdateType;
+                refreshResult.ErrorMessage = remoteResult.ErrorMessage;
+                refreshResult.Failures += remoteResult.Failures;
+            }
+
+            if (providers.Any(i => i is not ICustomMetadataProvider))
+            {
+                if (refreshResult.UpdateType > ItemUpdateType.None)
                 {
-                    if (refreshResult.UpdateType > ItemUpdateType.None)
+                    if (!options.RemoveOldMetadata)
                     {
-                        if (!options.RemoveOldMetadata)
-                        {
-                            // Add existing metadata to provider result if it does not exist there
-                            MergeData(metadata, temp, Array.Empty<MetadataField>(), false, false);
-                        }
+                        // Add existing metadata to provider result if it does not exist there
+                        MergeData(metadata, temp, Array.Empty<MetadataField>(), false, false);
+                    }
 
-                        if (isLocalLocked)
-                        {
-                            MergeData(temp, metadata, item.LockedFields, true, true);
-                        }
-                        else
-                        {
-                            var shouldReplace = options.MetadataRefreshMode > MetadataRefreshMode.ValidationOnly || options.ReplaceAllMetadata;
-                            MergeData(temp, metadata, item.LockedFields, shouldReplace, false);
-                        }
+                    if (isLocalLocked)
+                    {
+                        MergeData(temp, metadata, item.LockedFields, true, true);
+                    }
+                    else
+                    {
+                        var shouldReplace = options.MetadataRefreshMode > MetadataRefreshMode.ValidationOnly || options.ReplaceAllMetadata;
+                        MergeData(temp, metadata, item.LockedFields, shouldReplace, false);
                     }
                 }
+            }
 
-                foreach (var provider in customProviders.Where(i => i is not IPreRefreshProvider))
-                {
-                    await RunCustomProvider(provider, item, logName, options, refreshResult, cancellationToken).ConfigureAwait(false);
-                }
+            foreach (var provider in customProviders.Where(i => i is not IPreRefreshProvider))
+            {
+                await RunCustomProvider(provider, item, logName, options, refreshResult, cancellationToken).ConfigureAwait(false);
             }
 
             return refreshResult;