Change API Version from V3 to V1

2026-04-27 22:56:45 -04:00 · 2017-10-30 21:28:29 -04:00
parent db10057f2c
commit aae9f3cfc3
155 changed files with 248 additions and 248 deletions
@@ -0,0 +1,17 @@
+using NzbDrone.Core.Configuration;
+
+namespace Lidarr.Api.V1.Config
+{
+    public class DownloadClientConfigModule : SonarrConfigModule<DownloadClientConfigResource>
+    {
+        public DownloadClientConfigModule(IConfigService configService)
+            : base(configService)
+        {
+        }
+
+        protected override DownloadClientConfigResource ToResource(IConfigService model)
+        {
+            return DownloadClientConfigResourceMapper.ToResource(model);
+        }
+    }
+}
@@ -0,0 +1,33 @@
+using NzbDrone.Core.Configuration;
+using Lidarr.Http.REST;
+
+namespace Lidarr.Api.V1.Config
+{
+    public class DownloadClientConfigResource : RestResource
+    {
+        public string DownloadClientWorkingFolders { get; set; }
+
+        public bool EnableCompletedDownloadHandling { get; set; }
+        public bool RemoveCompletedDownloads { get; set; }
+
+        public bool AutoRedownloadFailed { get; set; }
+        public bool RemoveFailedDownloads { get; set; }
+    }
+
+    public static class DownloadClientConfigResourceMapper
+    {
+        public static DownloadClientConfigResource ToResource(IConfigService model)
+        {
+            return new DownloadClientConfigResource
+            {
+                DownloadClientWorkingFolders = model.DownloadClientWorkingFolders,
+
+                EnableCompletedDownloadHandling = model.EnableCompletedDownloadHandling,
+                RemoveCompletedDownloads = model.RemoveCompletedDownloads,
+
+                AutoRedownloadFailed = model.AutoRedownloadFailed,
+                RemoveFailedDownloads = model.RemoveFailedDownloads
+            };
+        }
+    }
+}
@@ -0,0 +1,85 @@
+using System.Linq;
+using System.Reflection;
+using FluentValidation;
+using NzbDrone.Common.EnvironmentInfo;
+using NzbDrone.Common.Extensions;
+using NzbDrone.Core.Authentication;
+using NzbDrone.Core.Configuration;
+using NzbDrone.Core.Update;
+using NzbDrone.Core.Validation;
+using NzbDrone.Core.Validation.Paths;
+using Lidarr.Http;
+
+namespace Lidarr.Api.V1.Config
+{
+    public class HostConfigModule : LidarrRestModule<HostConfigResource>
+    {
+        private readonly IConfigFileProvider _configFileProvider;
+        private readonly IConfigService _configService;
+        private readonly IUserService _userService;
+
+        public HostConfigModule(IConfigFileProvider configFileProvider, IConfigService configService, IUserService userService)
+            : base("/config/host")
+        {
+            _configFileProvider = configFileProvider;
+            _configService = configService;
+            _userService = userService;
+
+            GetResourceSingle = GetHostConfig;
+            GetResourceById = GetHostConfig;
+            UpdateResource = SaveHostConfig;
+
+            SharedValidator.RuleFor(c => c.BindAddress)
+                           .ValidIp4Address()
+                           .NotListenAllIp4Address()
+                           .When(c => c.BindAddress != "*");
+
+            SharedValidator.RuleFor(c => c.Port).ValidPort();
+
+            SharedValidator.RuleFor(c => c.UrlBase).ValidUrlBase();
+
+            SharedValidator.RuleFor(c => c.Username).NotEmpty().When(c => c.AuthenticationMethod != AuthenticationType.None);
+            SharedValidator.RuleFor(c => c.Password).NotEmpty().When(c => c.AuthenticationMethod != AuthenticationType.None);
+
+            SharedValidator.RuleFor(c => c.SslPort).ValidPort().When(c => c.EnableSsl);
+            SharedValidator.RuleFor(c => c.SslCertHash).NotEmpty().When(c => c.EnableSsl && OsInfo.IsWindows);
+
+            SharedValidator.RuleFor(c => c.Branch).NotEmpty().WithMessage("Branch name is required, 'master' is the default");
+            SharedValidator.RuleFor(c => c.UpdateScriptPath).IsValidPath().When(c => c.UpdateMechanism == UpdateMechanism.Script);
+        }
+
+        private HostConfigResource GetHostConfig()
+        {
+            var resource = _configFileProvider.ToResource(_configService);
+            resource.Id = 1;
+
+            var user = _userService.FindUser();
+            if (user != null)
+            {
+                resource.Username = user.Username;
+                resource.Password = user.Password;
+            }
+
+            return resource;
+        }
+
+        private HostConfigResource GetHostConfig(int id)
+        {
+            return GetHostConfig();
+        }
+
+        private void SaveHostConfig(HostConfigResource resource)
+        {
+            var dictionary = resource.GetType()
+                                     .GetProperties(BindingFlags.Instance | BindingFlags.Public)
+                                     .ToDictionary(prop => prop.Name, prop => prop.GetValue(resource, null));
+
+            _configFileProvider.SaveConfigDictionary(dictionary);
+
+            if (resource.Username.IsNotNullOrWhiteSpace() && resource.Password.IsNotNullOrWhiteSpace())
+            {
+                _userService.Upsert(resource.Username, resource.Password);
+            }
+        }
+    }
+}
@@ -0,0 +1,73 @@
+using NzbDrone.Common.Http.Proxy;
+using NzbDrone.Core.Authentication;
+using NzbDrone.Core.Configuration;
+using NzbDrone.Core.Update;
+using Lidarr.Http.REST;
+
+namespace Lidarr.Api.V1.Config
+{
+    public class HostConfigResource : RestResource
+    {
+        public string BindAddress { get; set; }
+        public int Port { get; set; }
+        public int SslPort { get; set; }
+        public bool EnableSsl { get; set; }
+        public bool LaunchBrowser { get; set; }
+        public AuthenticationType AuthenticationMethod { get; set; }
+        public bool AnalyticsEnabled { get; set; }
+        public string Username { get; set; }
+        public string Password { get; set; }
+        public string LogLevel { get; set; }
+        public string Branch { get; set; }
+        public string ApiKey { get; set; }
+        public string SslCertHash { get; set; }
+        public string UrlBase { get; set; }
+        public bool UpdateAutomatically { get; set; }
+        public UpdateMechanism UpdateMechanism { get; set; }
+        public string UpdateScriptPath { get; set; }
+        public bool ProxyEnabled { get; set; }
+        public ProxyType ProxyType { get; set; }
+        public string ProxyHostname { get; set; }
+        public int ProxyPort { get; set; }
+        public string ProxyUsername { get; set; }
+        public string ProxyPassword { get; set; }
+        public string ProxyBypassFilter { get; set; }
+        public bool ProxyBypassLocalAddresses { get; set; }
+    }
+
+    public static class HostConfigResourceMapper
+    {
+        public static HostConfigResource ToResource(this IConfigFileProvider model, IConfigService configService)
+        {
+            // TODO: Clean this mess up. don't mix data from multiple classes, use sub-resources instead?
+            return new HostConfigResource
+            {
+                BindAddress = model.BindAddress,
+                Port = model.Port,
+                SslPort = model.SslPort,
+                EnableSsl = model.EnableSsl,
+                LaunchBrowser = model.LaunchBrowser,
+                AuthenticationMethod = model.AuthenticationMethod,
+                AnalyticsEnabled = model.AnalyticsEnabled,
+                //Username
+                //Password
+                LogLevel = model.LogLevel,
+                Branch = model.Branch,
+                ApiKey = model.ApiKey,
+                SslCertHash = model.SslCertHash,
+                UrlBase = model.UrlBase,
+                UpdateAutomatically = model.UpdateAutomatically,
+                UpdateMechanism = model.UpdateMechanism,
+                UpdateScriptPath = model.UpdateScriptPath,
+                ProxyEnabled = configService.ProxyEnabled,
+                ProxyType = configService.ProxyType,
+                ProxyHostname = configService.ProxyHostname,
+                ProxyPort = configService.ProxyPort,
+                ProxyUsername = configService.ProxyUsername,
+                ProxyPassword = configService.ProxyPassword,
+                ProxyBypassFilter = configService.ProxyBypassFilter,
+                ProxyBypassLocalAddresses = configService.ProxyBypassLocalAddresses
+            };
+        }
+    }
+}
@@ -0,0 +1,28 @@
+using FluentValidation;
+using NzbDrone.Core.Configuration;
+using Lidarr.Http.Validation;
+
+namespace Lidarr.Api.V1.Config
+{
+    public class IndexerConfigModule : SonarrConfigModule<IndexerConfigResource>
+    {
+
+        public IndexerConfigModule(IConfigService configService)
+            : base(configService)
+        {
+            SharedValidator.RuleFor(c => c.MinimumAge)
+                           .GreaterThanOrEqualTo(0);
+
+            SharedValidator.RuleFor(c => c.Retention)
+                           .GreaterThanOrEqualTo(0);
+
+            SharedValidator.RuleFor(c => c.RssSyncInterval)
+                           .IsValidRssSyncInterval();
+        }
+
+        protected override IndexerConfigResource ToResource(IConfigService model)
+        {
+            return IndexerConfigResourceMapper.ToResource(model);
+        }
+    }
+}
@@ -0,0 +1,25 @@
+using NzbDrone.Core.Configuration;
+using Lidarr.Http.REST;
+
+namespace Lidarr.Api.V1.Config
+{
+    public class IndexerConfigResource : RestResource
+    {
+        public int MinimumAge { get; set; }
+        public int Retention { get; set; }
+        public int RssSyncInterval { get; set; }
+    }
+
+    public static class IndexerConfigResourceMapper
+    {
+        public static IndexerConfigResource ToResource(IConfigService model)
+        {
+            return new IndexerConfigResource
+            {
+                MinimumAge = model.MinimumAge,
+                Retention = model.Retention,
+                RssSyncInterval = model.RssSyncInterval,
+            };
+        }
+    }
+}
@@ -0,0 +1,22 @@
+using FluentValidation;
+using NzbDrone.Core.Configuration;
+using NzbDrone.Core.Validation.Paths;
+
+namespace Lidarr.Api.V1.Config
+{
+    public class MediaManagementConfigModule : SonarrConfigModule<MediaManagementConfigResource>
+    {
+        public MediaManagementConfigModule(IConfigService configService, PathExistsValidator pathExistsValidator)
+            : base(configService)
+        {
+            SharedValidator.RuleFor(c => c.FileChmod).NotEmpty();
+            SharedValidator.RuleFor(c => c.FolderChmod).NotEmpty();
+            SharedValidator.RuleFor(c => c.RecycleBin).IsValidPath().SetValidator(pathExistsValidator).When(c => !string.IsNullOrWhiteSpace(c.RecycleBin));
+        }
+
+        protected override MediaManagementConfigResource ToResource(IConfigService model)
+        {
+            return MediaManagementConfigResourceMapper.ToResource(model);
+        }
+    }
+}
@@ -0,0 +1,54 @@
+using NzbDrone.Core.Configuration;
+using NzbDrone.Core.MediaFiles;
+using Lidarr.Http.REST;
+
+namespace Lidarr.Api.V1.Config
+{
+    public class MediaManagementConfigResource : RestResource
+    {
+        public bool AutoUnmonitorPreviouslyDownloadedTracks { get; set; }
+        public string RecycleBin { get; set; }
+        public bool AutoDownloadPropers { get; set; }
+        public bool CreateEmptyArtistFolders { get; set; }
+        public FileDateType FileDate { get; set; }
+
+        public bool SetPermissionsLinux { get; set; }
+        public string FileChmod { get; set; }
+        public string FolderChmod { get; set; }
+        public string ChownUser { get; set; }
+        public string ChownGroup { get; set; }
+
+        public bool SkipFreeSpaceCheckWhenImporting { get; set; }
+        public bool CopyUsingHardlinks { get; set; }
+        public bool ImportExtraFiles { get; set; }
+        public string ExtraFileExtensions { get; set; }
+        public bool EnableMediaInfo { get; set; }
+    }
+
+    public static class MediaManagementConfigResourceMapper
+    {
+        public static MediaManagementConfigResource ToResource(IConfigService model)
+        {
+            return new MediaManagementConfigResource
+            {
+                AutoUnmonitorPreviouslyDownloadedTracks = model.AutoUnmonitorPreviouslyDownloadedTracks,
+                RecycleBin = model.RecycleBin,
+                AutoDownloadPropers = model.AutoDownloadPropers,
+                CreateEmptyArtistFolders = model.CreateEmptyArtistFolders,
+                FileDate = model.FileDate,
+
+                SetPermissionsLinux = model.SetPermissionsLinux,
+                FileChmod = model.FileChmod,
+                FolderChmod = model.FolderChmod,
+                ChownUser = model.ChownUser,
+                ChownGroup = model.ChownGroup,
+
+                SkipFreeSpaceCheckWhenImporting = model.SkipFreeSpaceCheckWhenImporting,
+                CopyUsingHardlinks = model.CopyUsingHardlinks,
+                ImportExtraFiles = model.ImportExtraFiles,
+                ExtraFileExtensions = model.ExtraFileExtensions,
+                EnableMediaInfo = model.EnableMediaInfo
+            };
+        }
+    }
+}
@@ -0,0 +1,22 @@
+using System.Linq;
+using System.Reflection;
+using NzbDrone.Core.Configuration;
+using Lidarr.Http;
+using NzbDrone.Core.Validation;
+
+namespace Lidarr.Api.V1.Config
+{
+    public class MetadataProviderConfigModule : SonarrConfigModule<MetadataProviderConfigResource>
+    {
+        public MetadataProviderConfigModule(IConfigService configService)
+            : base(configService)
+        {
+            SharedValidator.RuleFor(c => c.MetadataSource).IsValidUrl();
+        }
+
+        protected override MetadataProviderConfigResource ToResource(IConfigService model)
+        {
+            return MetadataProviderConfigResourceMapper.ToResource(model);
+        }
+    }
+}
@@ -0,0 +1,24 @@
+using NzbDrone.Core.Configuration;
+using Lidarr.Http.REST;
+
+namespace Lidarr.Api.V1.Config
+{
+    public class MetadataProviderConfigResource : RestResource
+    {
+        //Calendar
+        public string MetadataSource { get; set; }
+
+    }
+
+    public static class MetadataProviderConfigResourceMapper
+    {
+        public static MetadataProviderConfigResource ToResource(IConfigService model)
+        {
+            return new MetadataProviderConfigResource
+            {
+                MetadataSource = model.MetadataSource,
+
+            };
+        }
+    }
+}
@@ -0,0 +1,114 @@
+using System.Collections.Generic;
+using System.Linq;
+using FluentValidation;
+using FluentValidation.Results;
+using Nancy.ModelBinding;
+using Nancy.Responses;
+using NzbDrone.Common.Extensions;
+using NzbDrone.Core.Organizer;
+using Lidarr.Http;
+using Lidarr.Http.Extensions;
+using Lidarr.Http.Mapping;
+
+namespace Lidarr.Api.V1.Config
+{
+    public class NamingConfigModule : LidarrRestModule<NamingConfigResource>
+    {
+        private readonly INamingConfigService _namingConfigService;
+        private readonly IFilenameSampleService _filenameSampleService;
+        private readonly IFilenameValidationService _filenameValidationService;
+        private readonly IBuildFileNames _filenameBuilder;
+
+        public NamingConfigModule(INamingConfigService namingConfigService,
+                            IFilenameSampleService filenameSampleService,
+                            IFilenameValidationService filenameValidationService,
+                            IBuildFileNames filenameBuilder)
+            : base("config/naming")
+        {
+            _namingConfigService = namingConfigService;
+            _filenameSampleService = filenameSampleService;
+            _filenameValidationService = filenameValidationService;
+            _filenameBuilder = filenameBuilder;
+            GetResourceSingle = GetNamingConfig;
+            GetResourceById = GetNamingConfig;
+            UpdateResource = UpdateNamingConfig;
+
+            Get["/examples"] = x => GetExamples(this.Bind<NamingConfigResource>());
+
+
+            SharedValidator.RuleFor(c => c.StandardTrackFormat).ValidTrackFormat();
+            SharedValidator.RuleFor(c => c.ArtistFolderFormat).ValidArtistFolderFormat();
+            SharedValidator.RuleFor(c => c.AlbumFolderFormat).ValidAlbumFolderFormat();
+        }
+
+        private void UpdateNamingConfig(NamingConfigResource resource)
+        {
+            var nameSpec = resource.ToModel();
+            ValidateFormatResult(nameSpec);
+
+            _namingConfigService.Save(nameSpec);
+        }
+
+        private NamingConfigResource GetNamingConfig()
+        {
+            var nameSpec = _namingConfigService.GetConfig();
+            var resource = nameSpec.ToResource();
+
+            if (resource.StandardTrackFormat.IsNotNullOrWhiteSpace())
+            {
+                var basicConfig = _filenameBuilder.GetBasicNamingConfig(nameSpec);
+                basicConfig.AddToResource(resource);
+            }
+
+            return resource;
+        }
+
+        private NamingConfigResource GetNamingConfig(int id)
+        {
+            return GetNamingConfig();
+        }
+
+        private JsonResponse<NamingExampleResource> GetExamples(NamingConfigResource config)
+        {
+            if (config.Id == 0)
+            {
+                config = GetNamingConfig();
+            }
+
+            var nameSpec = config.ToModel();
+            var sampleResource = new NamingExampleResource();
+            
+            var singleTrackSampleResult = _filenameSampleService.GetStandardTrackSample(nameSpec);
+
+            sampleResource.SingleTrackExample = _filenameValidationService.ValidateTrackFilename(singleTrackSampleResult) != null
+                    ? null
+                    : singleTrackSampleResult.FileName;
+
+            sampleResource.ArtistFolderExample = nameSpec.ArtistFolderFormat.IsNullOrWhiteSpace()
+                ? null
+                : _filenameSampleService.GetArtistFolderSample(nameSpec);
+
+            sampleResource.AlbumFolderExample = nameSpec.AlbumFolderFormat.IsNullOrWhiteSpace()
+                ? null
+                : _filenameSampleService.GetAlbumFolderSample(nameSpec);
+
+            return sampleResource.AsResponse();
+        }
+
+        private void ValidateFormatResult(NamingConfig nameSpec)
+        {
+            var singleTrackSampleResult = _filenameSampleService.GetStandardTrackSample(nameSpec);
+
+            var singleTrackValidationResult = _filenameValidationService.ValidateTrackFilename(singleTrackSampleResult);
+
+            var validationFailures = new List<ValidationFailure>();
+
+            validationFailures.AddIfNotNull(singleTrackValidationResult);
+
+            if (validationFailures.Any())
+            {
+                throw new ValidationException(validationFailures.DistinctBy(v => v.PropertyName).ToArray());
+            }
+        }
+    }
+}
@@ -0,0 +1,19 @@
+using Lidarr.Http.REST;
+
+namespace Lidarr.Api.V1.Config
+{
+    public class NamingConfigResource : RestResource
+    {
+        public bool RenameTracks { get; set; }
+        public bool ReplaceIllegalCharacters { get; set; }
+        public string StandardTrackFormat { get; set; }
+        public string ArtistFolderFormat { get; set; }
+        public string AlbumFolderFormat { get; set; }
+        public bool IncludeArtistName { get; set; }
+        public bool IncludeAlbumTitle { get; set; }
+        public bool IncludeQuality { get; set; }
+        public bool ReplaceSpaces { get; set; }
+        public string Separator { get; set; }
+        public string NumberStyle { get; set; }
+    }
+}
@@ -0,0 +1,59 @@
+using NzbDrone.Core.Organizer;
+
+namespace Lidarr.Api.V1.Config
+{
+    public class NamingExampleResource
+    {
+        public string SingleTrackExample { get; set; }
+        public string ArtistFolderExample { get; set; }
+        public string AlbumFolderExample { get; set; }
+    }
+
+    public static class NamingConfigResourceMapper
+    {
+        public static NamingConfigResource ToResource(this NamingConfig model)
+        {
+            return new NamingConfigResource
+            {
+                Id = model.Id,
+
+                RenameTracks = model.RenameTracks,
+                ReplaceIllegalCharacters = model.ReplaceIllegalCharacters,
+                StandardTrackFormat = model.StandardTrackFormat,
+                ArtistFolderFormat = model.ArtistFolderFormat,
+                AlbumFolderFormat = model.AlbumFolderFormat
+                //IncludeSeriesTitle
+                //IncludeEpisodeTitle
+                //IncludeQuality
+                //ReplaceSpaces
+                //Separator
+                //NumberStyle
+            };
+        }
+
+        public static void AddToResource(this BasicNamingConfig basicNamingConfig, NamingConfigResource resource)
+        {
+            resource.IncludeArtistName = basicNamingConfig.IncludeArtistName;
+            resource.IncludeAlbumTitle = basicNamingConfig.IncludeAlbumTitle;
+            resource.IncludeQuality = basicNamingConfig.IncludeQuality;
+            resource.ReplaceSpaces = basicNamingConfig.ReplaceSpaces;
+            resource.Separator = basicNamingConfig.Separator;
+            resource.NumberStyle = basicNamingConfig.NumberStyle;
+        }
+
+        public static NamingConfig ToModel(this NamingConfigResource resource)
+        {
+            return new NamingConfig
+            {
+                Id = resource.Id,
+
+                RenameTracks = resource.RenameTracks,
+                ReplaceIllegalCharacters = resource.ReplaceIllegalCharacters,
+                StandardTrackFormat = resource.StandardTrackFormat,
+
+                ArtistFolderFormat = resource.ArtistFolderFormat,
+                AlbumFolderFormat = resource.AlbumFolderFormat
+            };
+        }
+    }
+}
@@ -0,0 +1,52 @@
+using System.Linq;
+using System.Reflection;
+using NzbDrone.Core.Configuration;
+using Lidarr.Http;
+using Lidarr.Http.REST;
+
+namespace Lidarr.Api.V1.Config
+{
+    public abstract class SonarrConfigModule<TResource> : LidarrRestModule<TResource> where TResource : RestResource, new()
+    {
+        private readonly IConfigService _configService;
+
+        protected SonarrConfigModule(IConfigService configService)
+            : this(new TResource().ResourceName.Replace("config", ""), configService)
+        {
+        }
+
+        protected SonarrConfigModule(string resource, IConfigService configService) :
+            base("config/" + resource.Trim('/'))
+        {
+            _configService = configService;
+
+            GetResourceSingle = GetConfig;
+            GetResourceById = GetConfig;
+            UpdateResource = SaveConfig;
+        }
+
+        private TResource GetConfig()
+        {
+            var resource = ToResource(_configService);
+            resource.Id = 1;
+
+            return resource;
+        }
+
+        protected abstract TResource ToResource(IConfigService model);
+
+        private TResource GetConfig(int id)
+        {
+            return GetConfig();
+        }
+
+        private void SaveConfig(TResource resource)
+        {
+            var dictionary = resource.GetType()
+                                     .GetProperties(BindingFlags.Instance | BindingFlags.Public)
+                                     .ToDictionary(prop => prop.Name, prop => prop.GetValue(resource, null));
+
+            _configService.SaveConfigDictionary(dictionary);
+        }
+    }
+}
@@ -0,0 +1,21 @@
+using System.Linq;
+using System.Reflection;
+using NzbDrone.Core.Configuration;
+using Lidarr.Http;
+
+namespace Lidarr.Api.V1.Config
+{
+    public class UiConfigModule : SonarrConfigModule<UiConfigResource>
+    {
+        public UiConfigModule(IConfigService configService)
+            : base(configService)
+        {
+
+        }
+
+        protected override UiConfigResource ToResource(IConfigService model)
+        {
+            return UiConfigResourceMapper.ToResource(model);
+        }
+    }
+}
@@ -0,0 +1,39 @@
+using NzbDrone.Core.Configuration;
+using Lidarr.Http.REST;
+
+namespace Lidarr.Api.V1.Config
+{
+    public class UiConfigResource : RestResource
+    {
+        //Calendar
+        public int FirstDayOfWeek { get; set; }
+        public string CalendarWeekColumnHeader { get; set; }
+
+        //Dates
+        public string ShortDateFormat { get; set; }
+        public string LongDateFormat { get; set; }
+        public string TimeFormat { get; set; }
+        public bool ShowRelativeDates { get; set; }
+
+        public bool EnableColorImpairedMode { get; set; }
+    }
+
+    public static class UiConfigResourceMapper
+    {
+        public static UiConfigResource ToResource(IConfigService model)
+        {
+            return new UiConfigResource
+            {
+                FirstDayOfWeek = model.FirstDayOfWeek,
+                CalendarWeekColumnHeader = model.CalendarWeekColumnHeader,
+
+                ShortDateFormat = model.ShortDateFormat,
+                LongDateFormat = model.LongDateFormat,
+                TimeFormat = model.TimeFormat,
+                ShowRelativeDates = model.ShowRelativeDates,
+
+                EnableColorImpairedMode = model.EnableColorImpairedMode,
+            };
+        }
+    }
+}