private RestoreOptionFactory()

in src/Microsoft.SqlTools.ServiceLayer/DisasterRecovery/RestoreOperation/RestoreOptionFactory.cs [199:552]
340 lines of code
3 McCabe index (conditional complexity)

        private RestoreOptionFactory()
        {
            Register(RestoreOptionsHelper.RelocateDbFiles,
                new OptionBuilder
                {
                    DefaultValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject) =>
                    {
                        return false;
                    },
                    CurrentValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject) =>
                    {
                        return restoreDataObject.RelocateAllFiles;
                    },
                    ValidateFunction = (IRestoreDatabaseTaskDataObject restoreDataObject, object currentValue, object defaultValue) =>
                    {
                        return new OptionValidationResult
                        {
                            IsReadOnly = restoreDataObject.DbFiles.Count == 0
                        };
                    },
                    SetValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject, object value) =>
                    {

                        restoreDataObject.RelocateAllFiles = restoreDataObject.RestoreParams.GetOptionValue<bool>(RestoreOptionsHelper.RelocateDbFiles);
                        return true;
                    }
                });
            Register(RestoreOptionsHelper.DataFileFolder,
                new OptionBuilder
                {
                    DefaultValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject) =>
                    {
                        return restoreDataObject.DefaultDataFileFolder;
                    },
                    CurrentValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject) =>
                    {
                        return restoreDataObject.DataFilesFolder;
                    },
                    ValidateFunction = (IRestoreDatabaseTaskDataObject restoreDataObject, object currentValue, object defaultValue) =>
                    {
                        return new OptionValidationResult
                        {
                            IsReadOnly = !restoreDataObject.RelocateAllFiles
                        };
                    },
                    SetValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject, object value) =>
                    {

                        restoreDataObject.DataFilesFolder = GetValueAs<string>(value);
                        return true;
                    }
                });
            Register(RestoreOptionsHelper.LogFileFolder,
                new OptionBuilder
                {
                    DefaultValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject) =>
                    {
                        return restoreDataObject.DefaultLogFileFolder;
                    },
                    CurrentValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject) =>
                    {
                        return restoreDataObject.LogFilesFolder;
                    },
                    ValidateFunction = (IRestoreDatabaseTaskDataObject restoreDataObject, object currentValue, object defaultValue) =>
                    {
                        return new OptionValidationResult
                        {
                            IsReadOnly = !restoreDataObject.RelocateAllFiles
                        };
                    },
                    SetValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject, object value) =>
                    {

                        restoreDataObject.LogFilesFolder = GetValueAs<string>(value);
                        return true;
                    }
                });
            Register(RestoreOptionsHelper.ReplaceDatabase,
                new OptionBuilder
                {
                    DefaultValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject) =>
                    {
                        return false;
                    },
                    CurrentValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject) =>
                    {
                        return restoreDataObject.RestoreOptions.ReplaceDatabase;
                    },
                    ValidateFunction = (IRestoreDatabaseTaskDataObject restoreDataObject, object currentValue, object defaultValue) =>
                    {
                        return new OptionValidationResult();
                    },
                    SetValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject, object value) =>
                    {

                        restoreDataObject.RestoreOptions.ReplaceDatabase = GetValueAs<bool>(value);
                        return true;
                    }
                });
            Register(RestoreOptionsHelper.KeepReplication,
                new OptionBuilder
                {
                    DefaultValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject) =>
                    {
                        return false;
                    },
                    CurrentValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject) =>
                    {
                        return restoreDataObject.RestoreOptions.KeepReplication;
                    },
                    ValidateFunction = (IRestoreDatabaseTaskDataObject restoreDataObject, object currentValue, object defaultValue) =>
                    {
                        return new OptionValidationResult()
                        {
                            IsReadOnly = restoreDataObject.RestoreOptions.RecoveryState == DatabaseRecoveryState.WithNoRecovery
                        };
                    },
                    SetValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject, object value) =>
                    {

                        restoreDataObject.RestoreOptions.KeepReplication = GetValueAs<bool>(value);
                        return true;
                    }
                });
            Register(RestoreOptionsHelper.SetRestrictedUser,
                new OptionBuilder
                {
                    DefaultValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject) =>
                    {
                        return false;
                    },
                    CurrentValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject) =>
                    {
                        return restoreDataObject.RestoreOptions.SetRestrictedUser;
                    },
                    ValidateFunction = (IRestoreDatabaseTaskDataObject restoreDataObject, object currentValue, object defaultValue) =>
                    {
                        return new OptionValidationResult()
                        {
                        };
                    },
                    SetValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject, object value) =>
                    {

                        restoreDataObject.RestoreOptions.SetRestrictedUser = GetValueAs<bool>(value);
                        return true;
                    }
                });
            Register(RestoreOptionsHelper.RecoveryState,
                new OptionBuilder
                {
                    DefaultValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject) =>
                    {
                        return DatabaseRecoveryState.WithRecovery.ToString();
                    },
                    CurrentValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject) =>
                    {
                        return restoreDataObject.RestoreOptions.RecoveryState.ToString();
                    },
                    ValidateFunction = (IRestoreDatabaseTaskDataObject restoreDataObject, object currentValue, object defaultValue) =>
                    {
                        return new OptionValidationResult()
                        {
                        };
                    },
                    SetValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject, object value) =>
                    {

                        restoreDataObject.RestoreOptions.RecoveryState = GetValueAs<DatabaseRecoveryState>(value);
                        return true;
                    }
                });
            Register(RestoreOptionsHelper.StandbyFile,
                new OptionBuilder
                {
                    DefaultValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject) =>
                    {
                        return restoreDataObject.DefaultStandbyFile;
                    },
                    CurrentValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject) =>
                    {
                        return restoreDataObject.RestoreOptions.StandByFile;
                    },
                    ValidateFunction = (IRestoreDatabaseTaskDataObject restoreDataObject, object currentValue, object defaultValue) =>
                    {
                        return new OptionValidationResult()
                        {
                            IsReadOnly = restoreDataObject.RestoreOptions.RecoveryState != DatabaseRecoveryState.WithStandBy
                        };
                    },
                    SetValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject, object value) =>
                    {

                        restoreDataObject.RestoreOptions.StandByFile = GetValueAs<string>(value);
                        return true;
                    }
                });
            Register(RestoreOptionsHelper.BackupTailLog,
                new OptionBuilder
                {
                    DefaultValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject) =>
                    {
                        return restoreDataObject.IsTailLogBackupPossible;
                    },
                    CurrentValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject) =>
                    {
                        return restoreDataObject.BackupTailLog;
                    },
                    ValidateFunction = (IRestoreDatabaseTaskDataObject restoreDataObject, object currentValue, object defaultValue) =>
                    {
                        return new OptionValidationResult()
                        {
                            IsReadOnly = !restoreDataObject.IsTailLogBackupPossible
                        };
                    },
                    SetValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject, object value) =>
                    {

                        restoreDataObject.BackupTailLog = GetValueAs<bool>(value);
                        return true;
                    }
                });
            Register(RestoreOptionsHelper.TailLogBackupFile,
                new OptionBuilder
                {
                    DefaultValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject) =>
                    {
                        return restoreDataObject.DefaultTailLogbackupFile;
                    },
                    CurrentValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject) =>
                    {
                        return restoreDataObject.TailLogBackupFile;
                    },
                    ValidateFunction = (IRestoreDatabaseTaskDataObject restoreDataObject, object currentValue, object defaultValue) =>
                    {
                        return new OptionValidationResult()
                        {
                            IsReadOnly = !restoreDataObject.BackupTailLog | !restoreDataObject.IsTailLogBackupPossible
                        };
                    },
                    SetValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject, object value) =>
                    {

                        restoreDataObject.TailLogBackupFile = GetValueAs<string>(value);
                        return true;
                    }
                });
            Register(RestoreOptionsHelper.TailLogWithNoRecovery,
                new OptionBuilder
                {
                    DefaultValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject) =>
                    {
                        return restoreDataObject.IsTailLogBackupWithNoRecoveryPossible;
                    },
                    CurrentValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject) =>
                    {
                        return restoreDataObject.TailLogWithNoRecovery;
                    },
                    ValidateFunction = (IRestoreDatabaseTaskDataObject restoreDataObject, object currentValue, object defaultValue) =>
                    {
                        return new OptionValidationResult()
                        {
                            IsReadOnly = !restoreDataObject.BackupTailLog | !restoreDataObject.IsTailLogBackupWithNoRecoveryPossible
                        };
                    },
                    SetValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject, object value) =>
                    {

                        restoreDataObject.TailLogWithNoRecovery = GetValueAs<bool>(value);
                        return true;
                    }
                });
            Register(RestoreOptionsHelper.CloseExistingConnections,
                new OptionBuilder
                {
                    DefaultValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject) =>
                    {
                        return false;
                    },
                    CurrentValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject) =>
                    {
                        return restoreDataObject.CloseExistingConnections;
                    },
                    ValidateFunction = (IRestoreDatabaseTaskDataObject restoreDataObject, object currentValue, object defaultValue) =>
                    {
                        return new OptionValidationResult()
                        {
                            IsReadOnly = !restoreDataObject.CanDropExistingConnections
                        };
                    },
                    SetValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject, object value) =>
                    {

                        restoreDataObject.CloseExistingConnections = GetValueAs<bool>(value);
                        return true;
                    }
                });
            Register(RestoreOptionsHelper.SourceDatabaseName,
               new OptionBuilder
               {
                   DefaultValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject) =>
                   {
                       return restoreDataObject.DefaultSourceDbName;
                   },
                   CurrentValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject) =>
                   {
                       return restoreDataObject.SourceDatabaseName;
                   },
                   ValidateFunction = (IRestoreDatabaseTaskDataObject restoreDataObject, object currentValue, object defaultValue) =>
                   {
                       string errorMessage = string.Empty;
                       var sourceDbNames = restoreDataObject.SourceDbNames;
                       if (currentValue == null)
                       {
                           errorMessage = "Source database name is not valid";
                       }
                       return new OptionValidationResult()
                       {
                          ErrorMessage = errorMessage
                       };
                   },
                   SetValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject, object value) =>
                   {

                       restoreDataObject.SourceDatabaseName = GetValueAs<string>(value);
                       return true;
                   }
               });
            Register(RestoreOptionsHelper.TargetDatabaseName,
               new OptionBuilder
               {
                   DefaultValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject) =>
                   {
                       return restoreDataObject.OverwriteTargetDatabase ? restoreDataObject.DefaultSourceDbName : restoreDataObject.DefaultTargetDbName;
                   },
                   CurrentValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject) =>
                   {
                       return restoreDataObject.TargetDatabaseName;
                   },
                   ValidateFunction = (IRestoreDatabaseTaskDataObject restoreDataObject, object currentValue, object defaultValue) =>
                   {
                       return new OptionValidationResult()
                       {
                           IsReadOnly = false
                       };
                   },
                   SetValueFunction = (IRestoreDatabaseTaskDataObject restoreDataObject, object value) =>
                   {

                       restoreDataObject.TargetDatabaseName = GetValueAs<string>(value);
                       return true;
                   }
               });
        }