mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
3796 lines
148 KiB
C#
3796 lines
148 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="CreateUserWizard.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
namespace System.Web.UI.WebControls {
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Collections.Specialized;
|
|
using System.ComponentModel;
|
|
using System.Drawing;
|
|
using System.Drawing.Design;
|
|
using System.Globalization;
|
|
using System.Linq;
|
|
using System.Security.Permissions;
|
|
using System.Web.Security;
|
|
using System.Web.Configuration;
|
|
using System.Web.UI;
|
|
using System.Web.Util;
|
|
using System.Net.Mail;
|
|
using System.Text;
|
|
using System.Web.Management;
|
|
|
|
|
|
/// <devdoc>
|
|
/// Displays UI that allows creating a user.
|
|
/// </devdoc>
|
|
[
|
|
Bindable(false),
|
|
DefaultEvent("CreatedUser"),
|
|
Designer("System.Web.UI.Design.WebControls.CreateUserWizardDesigner, " + AssemblyRef.SystemDesign),
|
|
ToolboxData("<{0}:CreateUserWizard runat=\"server\"> <WizardSteps> <asp:CreateUserWizardStep runat=\"server\"/> <asp:CompleteWizardStep runat=\"server\"/> </WizardSteps> </{0}:CreateUserWizard>")
|
|
]
|
|
public class CreateUserWizard : Wizard {
|
|
public static readonly string ContinueButtonCommandName = "Continue";
|
|
|
|
private string _password;
|
|
private string _confirmPassword;
|
|
private string _answer;
|
|
private string _unknownErrorMessage;
|
|
private string _validationGroup;
|
|
private CreateUserWizardStep _createUserStep;
|
|
private CompleteWizardStep _completeStep;
|
|
private CreateUserStepContainer _createUserStepContainer;
|
|
private CompleteStepContainer _completeStepContainer;
|
|
|
|
private const string _userNameReplacementKey = "<%\\s*UserName\\s*%>";
|
|
private const string _passwordReplacementKey = "<%\\s*Password\\s*%>";
|
|
|
|
private bool _failure;
|
|
private bool _convertingToTemplate;
|
|
|
|
private DefaultCreateUserNavigationTemplate _defaultCreateUserNavigationTemplate;
|
|
|
|
private const int _viewStateArrayLength = 13;
|
|
private Style _createUserButtonStyle;
|
|
private TableItemStyle _labelStyle;
|
|
private Style _textBoxStyle;
|
|
private TableItemStyle _hyperLinkStyle;
|
|
private TableItemStyle _instructionTextStyle;
|
|
private TableItemStyle _titleTextStyle;
|
|
private TableItemStyle _errorMessageStyle;
|
|
private TableItemStyle _passwordHintStyle;
|
|
private Style _continueButtonStyle;
|
|
private TableItemStyle _completeSuccessTextStyle;
|
|
private Style _validatorTextStyle;
|
|
private MailDefinition _mailDefinition;
|
|
|
|
private static readonly object EventCreatingUser = new object();
|
|
private static readonly object EventCreateUserError = new object();
|
|
private static readonly object EventCreatedUser = new object();
|
|
private static readonly object EventButtonContinueClick = new object();
|
|
private static readonly object EventSendingMail = new object();
|
|
private static readonly object EventSendMailError = new object();
|
|
|
|
private const string _createUserNavigationTemplateName = "CreateUserNavigationTemplate";
|
|
|
|
// Needed for user template feature
|
|
private const string _userNameID = "UserName";
|
|
private const string _passwordID = "Password";
|
|
private const string _confirmPasswordID = "ConfirmPassword";
|
|
private const string _errorMessageID = "ErrorMessage";
|
|
private const string _emailID = "Email";
|
|
private const string _questionID = "Question";
|
|
private const string _answerID = "Answer";
|
|
|
|
// Needed only for "convert to template" feature, otherwise unnecessary
|
|
private const string _userNameRequiredID = "UserNameRequired";
|
|
private const string _passwordRequiredID = "PasswordRequired";
|
|
private const string _confirmPasswordRequiredID = "ConfirmPasswordRequired";
|
|
private const string _passwordRegExpID = "PasswordRegExp";
|
|
private const string _emailRegExpID = "EmailRegExp";
|
|
private const string _emailRequiredID = "EmailRequired";
|
|
private const string _questionRequiredID = "QuestionRequired";
|
|
private const string _answerRequiredID = "AnswerRequired";
|
|
private const string _passwordCompareID = "PasswordCompare";
|
|
private const string _continueButtonID = "ContinueButton";
|
|
private const string _helpLinkID = "HelpLink";
|
|
private const string _editProfileLinkID = "EditProfileLink";
|
|
private const string _createUserStepContainerID = "CreateUserStepContainer";
|
|
private const string _completeStepContainerID = "CompleteStepContainer";
|
|
private const string _sideBarLabelID = "SideBarLabel";
|
|
private const ValidatorDisplay _requiredFieldValidatorDisplay = ValidatorDisplay.Static;
|
|
private const ValidatorDisplay _compareFieldValidatorDisplay = ValidatorDisplay.Dynamic;
|
|
private const ValidatorDisplay _regexpFieldValidatorDisplay = ValidatorDisplay.Dynamic;
|
|
|
|
private TableRow _passwordHintTableRow;
|
|
private TableRow _questionRow;
|
|
private TableRow _answerRow;
|
|
private TableRow _emailRow;
|
|
private TableRow _passwordCompareRow;
|
|
private TableRow _passwordRegExpRow;
|
|
private TableRow _emailRegExpRow;
|
|
private TableRow _passwordTableRow;
|
|
private TableRow _confirmPasswordTableRow;
|
|
|
|
private const bool _displaySideBarDefaultValue = false;
|
|
|
|
|
|
/// <devdoc>
|
|
/// Creates a new instance of a CreateUserWizard.
|
|
/// </devdoc>
|
|
public CreateUserWizard()
|
|
: base(_displaySideBarDefaultValue) {
|
|
}
|
|
|
|
#region Public Properties
|
|
|
|
[
|
|
DefaultValue(0),
|
|
]
|
|
public override int ActiveStepIndex {
|
|
get {
|
|
return base.ActiveStepIndex;
|
|
}
|
|
set {
|
|
base.ActiveStepIndex = value;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the initial value in the answer textbox.
|
|
/// </devdoc>
|
|
[
|
|
Localizable(true),
|
|
WebCategory("Appearance"),
|
|
DefaultValue(""),
|
|
Themeable(false),
|
|
WebSysDescription(SR.CreateUserWizard_Answer)
|
|
]
|
|
public virtual string Answer {
|
|
get {
|
|
return (_answer == null) ? String.Empty : _answer;
|
|
}
|
|
set {
|
|
_answer = value;
|
|
}
|
|
}
|
|
|
|
private string AnswerInternal {
|
|
get {
|
|
string answer = Answer;
|
|
if (String.IsNullOrEmpty(Answer) && _createUserStepContainer != null) {
|
|
ITextControl answerTextBox = (ITextControl)_createUserStepContainer.AnswerTextBox;
|
|
if (answerTextBox != null) {
|
|
answer = answerTextBox.Text;
|
|
}
|
|
}
|
|
// Pass Null instead of Empty into Membership
|
|
if (String.IsNullOrEmpty(answer)) {
|
|
answer = null;
|
|
}
|
|
|
|
return answer;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the text that identifies the question textbox.
|
|
/// </devdoc>
|
|
[
|
|
Localizable(true),
|
|
WebCategory("Appearance"),
|
|
WebSysDefaultValue(SR.CreateUserWizard_DefaultAnswerLabelText),
|
|
WebSysDescription(SR.CreateUserWizard_AnswerLabelText)
|
|
]
|
|
public virtual string AnswerLabelText {
|
|
get {
|
|
object obj = ViewState["AnswerLabelText"];
|
|
return (obj == null) ? SR.GetString(SR.CreateUserWizard_DefaultAnswerLabelText) : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["AnswerLabelText"] = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the text to be shown in the validation summary when the answer is empty.
|
|
/// </devdoc>
|
|
[
|
|
Localizable(true),
|
|
WebCategory("Validation"),
|
|
WebSysDefaultValue(SR.CreateUserWizard_DefaultAnswerRequiredErrorMessage),
|
|
WebSysDescription(SR.LoginControls_AnswerRequiredErrorMessage)
|
|
]
|
|
public virtual string AnswerRequiredErrorMessage {
|
|
get {
|
|
object obj = ViewState["AnswerRequiredErrorMessage"];
|
|
return (obj == null) ? SR.GetString(SR.CreateUserWizard_DefaultAnswerRequiredErrorMessage) : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["AnswerRequiredErrorMessage"] = value;
|
|
}
|
|
}
|
|
|
|
[
|
|
WebCategory("Behavior"),
|
|
DefaultValue(false),
|
|
Themeable(false),
|
|
WebSysDescription(SR.CreateUserWizard_AutoGeneratePassword)
|
|
]
|
|
public virtual bool AutoGeneratePassword {
|
|
get {
|
|
object obj = ViewState["AutoGeneratePassword"];
|
|
return (obj == null) ? false : (bool)obj;
|
|
}
|
|
set {
|
|
if (AutoGeneratePassword != value) {
|
|
ViewState["AutoGeneratePassword"] = value;
|
|
RequiresControlsRecreation();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets the complete step
|
|
/// </devdoc>
|
|
[
|
|
Browsable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
|
|
WebCategory("Appearance"),
|
|
WebSysDescription(SR.CreateUserWizard_CompleteStep)
|
|
]
|
|
public CompleteWizardStep CompleteStep {
|
|
get {
|
|
EnsureChildControls();
|
|
return _completeStep;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// The text to be shown after the password has been changed.
|
|
/// </devdoc>
|
|
[
|
|
Localizable(true),
|
|
WebCategory("Appearance"),
|
|
WebSysDefaultValue(SR.CreateUserWizard_DefaultCompleteSuccessText),
|
|
WebSysDescription(SR.CreateUserWizard_CompleteSuccessText)
|
|
]
|
|
public virtual string CompleteSuccessText {
|
|
get {
|
|
object obj = ViewState["CompleteSuccessText"];
|
|
return (obj == null) ? SR.GetString(SR.CreateUserWizard_DefaultCompleteSuccessText) : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["CompleteSuccessText"] = value;
|
|
}
|
|
}
|
|
|
|
[
|
|
WebCategory("Styles"),
|
|
DefaultValue(null),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
|
|
NotifyParentProperty(true),
|
|
PersistenceMode(PersistenceMode.InnerProperty),
|
|
WebSysDescription(SR.CreateUserWizard_CompleteSuccessTextStyle)
|
|
]
|
|
public TableItemStyle CompleteSuccessTextStyle {
|
|
get {
|
|
if (_completeSuccessTextStyle == null) {
|
|
_completeSuccessTextStyle = new TableItemStyle();
|
|
if (IsTrackingViewState) {
|
|
((IStateManager)_completeSuccessTextStyle).TrackViewState();
|
|
}
|
|
}
|
|
return _completeSuccessTextStyle;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets the confirm new password entered by the user.
|
|
/// </devdoc>
|
|
[
|
|
Browsable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
|
|
]
|
|
public virtual string ConfirmPassword {
|
|
get {
|
|
return (_confirmPassword == null) ? String.Empty : _confirmPassword;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the message that is displayed for confirm password errors
|
|
/// </devdoc>
|
|
[
|
|
Localizable(true),
|
|
WebCategory("Validation"),
|
|
WebSysDefaultValue(SR.CreateUserWizard_DefaultConfirmPasswordCompareErrorMessage),
|
|
WebSysDescription(SR.ChangePassword_ConfirmPasswordCompareErrorMessage)
|
|
]
|
|
public virtual string ConfirmPasswordCompareErrorMessage {
|
|
get {
|
|
object obj = ViewState["ConfirmPasswordCompareErrorMessage"];
|
|
return (obj == null) ? SR.GetString(SR.CreateUserWizard_DefaultConfirmPasswordCompareErrorMessage) : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["ConfirmPasswordCompareErrorMessage"] = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the text that identifies the new password textbox.
|
|
/// </devdoc>
|
|
[
|
|
Localizable(true),
|
|
WebCategory("Appearance"),
|
|
WebSysDefaultValue(SR.CreateUserWizard_DefaultConfirmPasswordLabelText),
|
|
WebSysDescription(SR.CreateUserWizard_ConfirmPasswordLabelText)
|
|
]
|
|
public virtual string ConfirmPasswordLabelText {
|
|
get {
|
|
object obj = ViewState["ConfirmPasswordLabelText"];
|
|
return (obj == null) ? SR.GetString(SR.CreateUserWizard_DefaultConfirmPasswordLabelText) : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["ConfirmPasswordLabelText"] = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the text to be shown in the validation summary when the confirm password is empty.
|
|
/// </devdoc>
|
|
[
|
|
Localizable(true),
|
|
WebCategory("Validation"),
|
|
WebSysDefaultValue(SR.CreateUserWizard_DefaultConfirmPasswordRequiredErrorMessage),
|
|
WebSysDescription(SR.LoginControls_ConfirmPasswordRequiredErrorMessage)
|
|
]
|
|
public virtual string ConfirmPasswordRequiredErrorMessage {
|
|
get {
|
|
object obj = ViewState["ConfirmPasswordRequiredErrorMessage"];
|
|
return (obj == null) ? SR.GetString(SR.CreateUserWizard_DefaultConfirmPasswordRequiredErrorMessage) : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["ConfirmPasswordRequiredErrorMessage"] = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the URL of an image to be displayed for the continue button.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Appearance"),
|
|
DefaultValue(""),
|
|
WebSysDescription(SR.ChangePassword_ContinueButtonImageUrl),
|
|
Editor("System.Web.UI.Design.ImageUrlEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
|
|
UrlProperty()
|
|
]
|
|
public virtual string ContinueButtonImageUrl {
|
|
get {
|
|
object obj = ViewState["ContinueButtonImageUrl"];
|
|
return (obj == null) ? String.Empty : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["ContinueButtonImageUrl"] = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets the style of the continue button.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Styles"),
|
|
DefaultValue(null),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
|
|
NotifyParentProperty(true),
|
|
PersistenceMode(PersistenceMode.InnerProperty),
|
|
WebSysDescription(SR.CreateUserWizard_ContinueButtonStyle)
|
|
]
|
|
public Style ContinueButtonStyle {
|
|
get {
|
|
if (_continueButtonStyle == null) {
|
|
_continueButtonStyle = new Style();
|
|
if (IsTrackingViewState) {
|
|
((IStateManager)_continueButtonStyle).TrackViewState();
|
|
}
|
|
}
|
|
return _continueButtonStyle;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the text to be shown for the continue button.
|
|
/// </devdoc>
|
|
[
|
|
Localizable(true),
|
|
WebCategory("Appearance"),
|
|
WebSysDefaultValue(SR.CreateUserWizard_DefaultContinueButtonText),
|
|
WebSysDescription(SR.CreateUserWizard_ContinueButtonText)
|
|
]
|
|
public virtual string ContinueButtonText {
|
|
get {
|
|
object obj = ViewState["ContinueButtonText"];
|
|
return (obj == null) ? SR.GetString(SR.CreateUserWizard_DefaultContinueButtonText) : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["ContinueButtonText"] = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the type of the continue button.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Appearance"),
|
|
DefaultValue(ButtonType.Button),
|
|
WebSysDescription(SR.CreateUserWizard_ContinueButtonType)
|
|
]
|
|
public virtual ButtonType ContinueButtonType {
|
|
get {
|
|
object obj = ViewState["ContinueButtonType"];
|
|
return (obj == null) ? ButtonType.Button : (ButtonType)obj;
|
|
}
|
|
set {
|
|
if (value < ButtonType.Button || value > ButtonType.Link) {
|
|
throw new ArgumentOutOfRangeException("value");
|
|
}
|
|
if (value != ContinueButtonType) {
|
|
ViewState["ContinueButtonType"] = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the URL of an image to be displayed for the continue button.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Behavior"),
|
|
DefaultValue(""),
|
|
WebSysDescription(SR.LoginControls_ContinueDestinationPageUrl),
|
|
Editor("System.Web.UI.Design.UrlEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
|
|
Themeable(false),
|
|
UrlProperty()
|
|
]
|
|
public virtual string ContinueDestinationPageUrl {
|
|
get {
|
|
object obj = ViewState["ContinueDestinationPageUrl"];
|
|
return (obj == null) ? String.Empty : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["ContinueDestinationPageUrl"] = value;
|
|
}
|
|
}
|
|
|
|
private bool ConvertingToTemplate {
|
|
get {
|
|
return (DesignMode && _convertingToTemplate);
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets the create user step
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Appearance"),
|
|
Browsable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
|
|
WebSysDescription(SR.CreateUserWizard_CreateUserStep)
|
|
]
|
|
public CreateUserWizardStep CreateUserStep {
|
|
get {
|
|
EnsureChildControls();
|
|
return _createUserStep;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the URL of an image to be displayed for the create user button.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Appearance"),
|
|
DefaultValue(""),
|
|
WebSysDescription(SR.CreateUserWizard_CreateUserButtonImageUrl),
|
|
Editor("System.Web.UI.Design.ImageUrlEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
|
|
UrlProperty()
|
|
]
|
|
public virtual string CreateUserButtonImageUrl {
|
|
get {
|
|
object obj = ViewState["CreateUserButtonImageUrl"];
|
|
return (obj == null) ? String.Empty : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["CreateUserButtonImageUrl"] = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets the style of the createUser button.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Styles"),
|
|
DefaultValue(null),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
|
|
NotifyParentProperty(true),
|
|
PersistenceMode(PersistenceMode.InnerProperty),
|
|
WebSysDescription(SR.CreateUserWizard_CreateUserButtonStyle)
|
|
]
|
|
public Style CreateUserButtonStyle {
|
|
get {
|
|
if (_createUserButtonStyle == null) {
|
|
_createUserButtonStyle = new Style();
|
|
if (IsTrackingViewState) {
|
|
((IStateManager)_createUserButtonStyle).TrackViewState();
|
|
}
|
|
}
|
|
return _createUserButtonStyle;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the text to be shown for the continue button.
|
|
/// </devdoc>
|
|
[
|
|
Localizable(true),
|
|
WebCategory("Appearance"),
|
|
WebSysDefaultValue(SR.CreateUserWizard_DefaultCreateUserButtonText),
|
|
WebSysDescription(SR.CreateUserWizard_CreateUserButtonText)
|
|
]
|
|
public virtual string CreateUserButtonText {
|
|
get {
|
|
object obj = ViewState["CreateUserButtonText"];
|
|
return (obj == null) ? SR.GetString(SR.CreateUserWizard_DefaultCreateUserButtonText) : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["CreateUserButtonText"] = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the type of the continue button.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Appearance"),
|
|
DefaultValue(ButtonType.Button),
|
|
WebSysDescription(SR.CreateUserWizard_CreateUserButtonType)
|
|
]
|
|
public virtual ButtonType CreateUserButtonType {
|
|
get {
|
|
object obj = ViewState["CreateUserButtonType"];
|
|
return (obj == null) ? ButtonType.Button : (ButtonType)obj;
|
|
}
|
|
set {
|
|
if (value < ButtonType.Button || value > ButtonType.Link) {
|
|
throw new ArgumentOutOfRangeException("value");
|
|
}
|
|
if (value != CreateUserButtonType) {
|
|
ViewState["CreateUserButtonType"] = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool DefaultCreateUserStep {
|
|
get {
|
|
CreateUserWizardStep step = CreateUserStep;
|
|
return (step == null) ? false : step.ContentTemplate == null;
|
|
}
|
|
}
|
|
|
|
private bool DefaultCompleteStep {
|
|
get {
|
|
CompleteWizardStep step = CompleteStep;
|
|
return (step == null) ? false : step.ContentTemplate == null;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets whether the created user will be disabled
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Behavior"),
|
|
DefaultValue(false),
|
|
Themeable(false),
|
|
WebSysDescription(SR.CreateUserWizard_DisableCreatedUser)
|
|
]
|
|
public virtual bool DisableCreatedUser {
|
|
get {
|
|
object obj = ViewState["DisableCreatedUser"];
|
|
return (obj == null) ? false : (bool)obj;
|
|
}
|
|
set {
|
|
ViewState["DisableCreatedUser"] = value;
|
|
}
|
|
}
|
|
|
|
|
|
[
|
|
DefaultValue(false)
|
|
]
|
|
public override bool DisplaySideBar {
|
|
get {
|
|
return base.DisplaySideBar;
|
|
}
|
|
set {
|
|
base.DisplaySideBar = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the message that is displayed for duplicate emails
|
|
/// </devdoc>
|
|
[
|
|
Localizable(true),
|
|
WebCategory("Appearance"),
|
|
WebSysDefaultValue(SR.CreateUserWizard_DefaultDuplicateEmailErrorMessage),
|
|
WebSysDescription(SR.CreateUserWizard_DuplicateEmailErrorMessage)
|
|
]
|
|
public virtual string DuplicateEmailErrorMessage {
|
|
get {
|
|
object obj = ViewState["DuplicateEmailErrorMessage"];
|
|
return (obj == null) ? SR.GetString(SR.CreateUserWizard_DefaultDuplicateEmailErrorMessage) : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["DuplicateEmailErrorMessage"] = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the message that is displayed for email errors
|
|
/// </devdoc>
|
|
[
|
|
Localizable(true),
|
|
WebCategory("Appearance"),
|
|
WebSysDefaultValue(SR.CreateUserWizard_DefaultDuplicateUserNameErrorMessage),
|
|
WebSysDescription(SR.CreateUserWizard_DuplicateUserNameErrorMessage)
|
|
]
|
|
public virtual string DuplicateUserNameErrorMessage {
|
|
get {
|
|
object obj = ViewState["DuplicateUserNameErrorMessage"];
|
|
return (obj == null) ? SR.GetString(SR.CreateUserWizard_DefaultDuplicateUserNameErrorMessage) : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["DuplicateUserNameErrorMessage"] = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the URL for the image shown next to the profile page.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Links"),
|
|
DefaultValue(""),
|
|
WebSysDescription(SR.LoginControls_EditProfileIconUrl),
|
|
Editor("System.Web.UI.Design.ImageUrlEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
|
|
UrlProperty()
|
|
]
|
|
public virtual string EditProfileIconUrl {
|
|
get {
|
|
object obj = ViewState["EditProfileIconUrl"];
|
|
return (obj == null) ? String.Empty : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["EditProfileIconUrl"] = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the text to be shown for the edit profile page
|
|
/// </devdoc>
|
|
[
|
|
Localizable(true),
|
|
WebCategory("Links"),
|
|
DefaultValue(""),
|
|
WebSysDescription(SR.CreateUserWizard_EditProfileText)
|
|
]
|
|
public virtual string EditProfileText {
|
|
get {
|
|
object obj = ViewState["EditProfileText"];
|
|
return (obj == null) ? String.Empty : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["EditProfileText"] = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the URL of the edit profile page.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Links"),
|
|
DefaultValue(""),
|
|
WebSysDescription(SR.CreateUserWizard_EditProfileUrl),
|
|
Editor("System.Web.UI.Design.UrlEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
|
|
UrlProperty()
|
|
]
|
|
public virtual string EditProfileUrl {
|
|
get {
|
|
object obj = ViewState["EditProfileUrl"];
|
|
return (obj == null) ? String.Empty : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["EditProfileUrl"] = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the initial value in the Email textbox.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Appearance"),
|
|
DefaultValue(""),
|
|
WebSysDescription(SR.CreateUserWizard_Email)
|
|
]
|
|
public virtual string Email {
|
|
get {
|
|
object obj = ViewState["Email"];
|
|
return (obj == null) ? String.Empty : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["Email"] = value;
|
|
}
|
|
}
|
|
|
|
private string EmailInternal {
|
|
get {
|
|
string email = Email;
|
|
if (String.IsNullOrEmpty(email) && _createUserStepContainer != null) {
|
|
ITextControl emailTextBox = (ITextControl)_createUserStepContainer.EmailTextBox;
|
|
if (emailTextBox != null) {
|
|
return emailTextBox.Text;
|
|
}
|
|
}
|
|
return email;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the text that identifies the email textbox.
|
|
/// </devdoc>
|
|
[
|
|
Localizable(true),
|
|
WebCategory("Appearance"),
|
|
WebSysDefaultValue(SR.CreateUserWizard_DefaultEmailLabelText),
|
|
WebSysDescription(SR.CreateUserWizard_EmailLabelText)
|
|
]
|
|
public virtual string EmailLabelText {
|
|
get {
|
|
object obj = ViewState["EmailLabelText"];
|
|
return (obj == null) ? SR.GetString(SR.CreateUserWizard_DefaultEmailLabelText) : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["EmailLabelText"] = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Regular expression used to validate the email address
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Validation"),
|
|
WebSysDefaultValue(""),
|
|
WebSysDescription(SR.CreateUserWizard_EmailRegularExpression)
|
|
]
|
|
public virtual string EmailRegularExpression {
|
|
get {
|
|
object obj = ViewState["EmailRegularExpression"];
|
|
return (obj == null) ? String.Empty : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["EmailRegularExpression"] = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the text to be shown in the validation summary when the email fails the reg exp.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Validation"),
|
|
WebSysDefaultValue(SR.CreateUserWizard_DefaultEmailRegularExpressionErrorMessage),
|
|
WebSysDescription(SR.CreateUserWizard_EmailRegularExpressionErrorMessage)
|
|
]
|
|
public virtual string EmailRegularExpressionErrorMessage {
|
|
get {
|
|
object obj = ViewState["EmailRegularExpressionErrorMessage"];
|
|
return (obj == null) ? SR.GetString(SR.CreateUserWizard_DefaultEmailRegularExpressionErrorMessage) : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["EmailRegularExpressionErrorMessage"] = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the text to be shown in the validation summary when the email is empty.
|
|
/// </devdoc>
|
|
[
|
|
Localizable(true),
|
|
WebCategory("Validation"),
|
|
WebSysDefaultValue(SR.CreateUserWizard_DefaultEmailRequiredErrorMessage),
|
|
WebSysDescription(SR.CreateUserWizard_EmailRequiredErrorMessage)
|
|
]
|
|
public virtual string EmailRequiredErrorMessage {
|
|
get {
|
|
object obj = ViewState["EmailRequiredErrorMessage"];
|
|
return (obj == null) ? SR.GetString(SR.CreateUserWizard_DefaultEmailRequiredErrorMessage) : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["EmailRequiredErrorMessage"] = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the text that is displayed for unknown errors
|
|
/// </devdoc>
|
|
[
|
|
Localizable(true),
|
|
WebCategory("Appearance"),
|
|
WebSysDefaultValue(SR.CreateUserWizard_DefaultUnknownErrorMessage),
|
|
WebSysDescription(SR.CreateUserWizard_UnknownErrorMessage)
|
|
]
|
|
public virtual string UnknownErrorMessage {
|
|
get {
|
|
object obj = ViewState["UnknownErrorMessage"];
|
|
return (obj == null) ? SR.GetString(SR.CreateUserWizard_DefaultUnknownErrorMessage) : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["UnknownErrorMessage"] = value;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Gets the style of the error message.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Styles"),
|
|
DefaultValue(null),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
|
|
NotifyParentProperty(true),
|
|
PersistenceMode(PersistenceMode.InnerProperty),
|
|
WebSysDescription(SR.CreateUserWizard_ErrorMessageStyle)
|
|
]
|
|
public TableItemStyle ErrorMessageStyle {
|
|
get {
|
|
if (_errorMessageStyle == null) {
|
|
_errorMessageStyle = new ErrorTableItemStyle();
|
|
if (IsTrackingViewState) {
|
|
((IStateManager)_errorMessageStyle).TrackViewState();
|
|
}
|
|
}
|
|
return _errorMessageStyle;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the URL of an image to be displayed for the help link.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Links"),
|
|
DefaultValue(""),
|
|
WebSysDescription(SR.LoginControls_HelpPageIconUrl),
|
|
Editor("System.Web.UI.Design.ImageUrlEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
|
|
UrlProperty()
|
|
]
|
|
public virtual string HelpPageIconUrl {
|
|
get {
|
|
object obj = ViewState["HelpPageIconUrl"];
|
|
return (obj == null) ? String.Empty : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["HelpPageIconUrl"] = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the text to be shown for the help link.
|
|
/// </devdoc>
|
|
[
|
|
Localizable(true),
|
|
WebCategory("Links"),
|
|
DefaultValue(""),
|
|
WebSysDescription(SR.ChangePassword_HelpPageText)
|
|
]
|
|
public virtual string HelpPageText {
|
|
get {
|
|
object obj = ViewState["HelpPageText"];
|
|
return (obj == null) ? String.Empty : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["HelpPageText"] = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the URL of the help page.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Links"),
|
|
DefaultValue(""),
|
|
WebSysDescription(SR.LoginControls_HelpPageUrl),
|
|
Editor("System.Web.UI.Design.UrlEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
|
|
UrlProperty()
|
|
]
|
|
public virtual string HelpPageUrl {
|
|
get {
|
|
object obj = ViewState["HelpPageUrl"];
|
|
return (obj == null) ? String.Empty : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["HelpPageUrl"] = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets the style of the hyperlinks.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Styles"),
|
|
DefaultValue(null),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
|
|
NotifyParentProperty(true),
|
|
PersistenceMode(PersistenceMode.InnerProperty),
|
|
WebSysDescription(SR.WebControl_HyperLinkStyle)
|
|
]
|
|
public TableItemStyle HyperLinkStyle {
|
|
get {
|
|
if (_hyperLinkStyle == null) {
|
|
_hyperLinkStyle = new TableItemStyle();
|
|
if (IsTrackingViewState) {
|
|
((IStateManager)_hyperLinkStyle).TrackViewState();
|
|
}
|
|
}
|
|
return _hyperLinkStyle;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the text that is displayed to give instructions.
|
|
/// </devdoc>
|
|
[
|
|
Localizable(true),
|
|
WebCategory("Appearance"),
|
|
DefaultValue(""),
|
|
WebSysDescription(SR.WebControl_InstructionText)
|
|
]
|
|
public virtual string InstructionText {
|
|
get {
|
|
object obj = ViewState["InstructionText"];
|
|
return (obj == null) ? String.Empty : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["InstructionText"] = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets the style of the instructions.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Styles"),
|
|
DefaultValue(null),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
|
|
NotifyParentProperty(true),
|
|
PersistenceMode(PersistenceMode.InnerProperty),
|
|
WebSysDescription(SR.WebControl_InstructionTextStyle)
|
|
]
|
|
public TableItemStyle InstructionTextStyle {
|
|
get {
|
|
if (_instructionTextStyle == null) {
|
|
_instructionTextStyle = new TableItemStyle();
|
|
if (IsTrackingViewState) {
|
|
((IStateManager)_instructionTextStyle).TrackViewState();
|
|
}
|
|
}
|
|
return _instructionTextStyle;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the message that is displayed for answer errors
|
|
/// </devdoc>
|
|
[
|
|
Localizable(true),
|
|
WebCategory("Appearance"),
|
|
WebSysDefaultValue(SR.CreateUserWizard_DefaultInvalidAnswerErrorMessage),
|
|
WebSysDescription(SR.CreateUserWizard_InvalidAnswerErrorMessage)
|
|
]
|
|
public virtual string InvalidAnswerErrorMessage {
|
|
get {
|
|
object obj = ViewState["InvalidAnswerErrorMessage"];
|
|
return (obj == null) ? SR.GetString(SR.CreateUserWizard_DefaultInvalidAnswerErrorMessage) : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["InvalidAnswerErrorMessage"] = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the message that is displayed for email errors
|
|
/// </devdoc>
|
|
[
|
|
Localizable(true),
|
|
WebCategory("Appearance"),
|
|
WebSysDefaultValue(SR.CreateUserWizard_DefaultInvalidEmailErrorMessage),
|
|
WebSysDescription(SR.CreateUserWizard_InvalidEmailErrorMessage)
|
|
]
|
|
public virtual string InvalidEmailErrorMessage {
|
|
get {
|
|
object obj = ViewState["InvalidEmailErrorMessage"];
|
|
return (obj == null) ? SR.GetString(SR.CreateUserWizard_DefaultInvalidEmailErrorMessage) : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["InvalidEmailErrorMessage"] = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the text to be shown there is a problem with the password.
|
|
/// </devdoc>
|
|
[
|
|
Localizable(true),
|
|
WebCategory("Appearance"),
|
|
WebSysDefaultValue(SR.CreateUserWizard_DefaultInvalidPasswordErrorMessage),
|
|
WebSysDescription(SR.CreateUserWizard_InvalidPasswordErrorMessage)
|
|
]
|
|
public virtual string InvalidPasswordErrorMessage {
|
|
get {
|
|
object obj = ViewState["InvalidPasswordErrorMessage"];
|
|
return (obj == null) ? SR.GetString(SR.CreateUserWizard_DefaultInvalidPasswordErrorMessage) : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["InvalidPasswordErrorMessage"] = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the message that is displayed for question errors
|
|
/// </devdoc>
|
|
[
|
|
Localizable(true),
|
|
WebCategory("Appearance"),
|
|
WebSysDefaultValue(SR.CreateUserWizard_DefaultInvalidQuestionErrorMessage),
|
|
WebSysDescription(SR.CreateUserWizard_InvalidQuestionErrorMessage)
|
|
]
|
|
public virtual string InvalidQuestionErrorMessage {
|
|
get {
|
|
object obj = ViewState["InvalidQuestionErrorMessage"];
|
|
return (obj == null) ? SR.GetString(SR.CreateUserWizard_DefaultInvalidQuestionErrorMessage) : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["InvalidQuestionErrorMessage"] = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets the style of the textbox labels.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Styles"),
|
|
DefaultValue(null),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
|
|
NotifyParentProperty(true),
|
|
PersistenceMode(PersistenceMode.InnerProperty),
|
|
WebSysDescription(SR.LoginControls_LabelStyle)
|
|
]
|
|
public TableItemStyle LabelStyle {
|
|
get {
|
|
if (_labelStyle == null) {
|
|
_labelStyle = new TableItemStyle();
|
|
if (IsTrackingViewState) {
|
|
((IStateManager)_labelStyle).TrackViewState();
|
|
}
|
|
}
|
|
return _labelStyle;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets whether the created user will be logged into the site
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Behavior"),
|
|
DefaultValue(true),
|
|
Themeable(false),
|
|
WebSysDescription(SR.CreateUserWizard_LoginCreatedUser)
|
|
]
|
|
public virtual bool LoginCreatedUser {
|
|
get {
|
|
object obj = ViewState["LoginCreatedUser"];
|
|
return (obj == null) ? true : (bool)obj;
|
|
}
|
|
set {
|
|
ViewState["LoginCreatedUser"] = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// The content and format of the e-mail message that contains the new password.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Behavior"),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
|
|
NotifyParentProperty(true),
|
|
PersistenceMode(PersistenceMode.InnerProperty),
|
|
Themeable(false),
|
|
WebSysDescription(SR.CreateUserWizard_MailDefinition)
|
|
]
|
|
public MailDefinition MailDefinition {
|
|
get {
|
|
if (_mailDefinition == null) {
|
|
_mailDefinition = new MailDefinition();
|
|
if (IsTrackingViewState) {
|
|
((IStateManager)_mailDefinition).TrackViewState();
|
|
}
|
|
}
|
|
return _mailDefinition;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the name of the membership provider. If null or empty, the default provider is used.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Data"),
|
|
DefaultValue(""),
|
|
Themeable(false),
|
|
WebSysDescription(SR.MembershipProvider_Name)
|
|
]
|
|
public virtual string MembershipProvider {
|
|
get {
|
|
object obj = ViewState["MembershipProvider"];
|
|
return (obj == null) ? String.Empty : (string)obj;
|
|
}
|
|
set {
|
|
if (MembershipProvider != value) {
|
|
ViewState["MembershipProvider"] = value;
|
|
RequiresControlsRecreation();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets the new password entered by the user.
|
|
/// </devdoc>
|
|
[
|
|
Browsable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
|
|
]
|
|
public virtual string Password {
|
|
get {
|
|
return (_password == null) ? String.Empty : _password;
|
|
}
|
|
}
|
|
|
|
private string PasswordInternal {
|
|
get {
|
|
string password = Password;
|
|
if (String.IsNullOrEmpty(password) && !AutoGeneratePassword && _createUserStepContainer != null) {
|
|
ITextControl passwordTextBox = (ITextControl)_createUserStepContainer.PasswordTextBox;
|
|
if (passwordTextBox != null) {
|
|
return passwordTextBox.Text;
|
|
}
|
|
}
|
|
return password;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// The style of the password hint text.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Styles"),
|
|
DefaultValue(null),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
|
|
NotifyParentProperty(true),
|
|
PersistenceMode(PersistenceMode.InnerProperty),
|
|
WebSysDescription(SR.CreateUserWizard_PasswordHintStyle)
|
|
]
|
|
public TableItemStyle PasswordHintStyle {
|
|
get {
|
|
if (_passwordHintStyle == null) {
|
|
_passwordHintStyle = new TableItemStyle();
|
|
if (IsTrackingViewState) {
|
|
((IStateManager)_passwordHintStyle).TrackViewState();
|
|
}
|
|
}
|
|
return _passwordHintStyle;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the text for the password hint.
|
|
/// </devdoc>
|
|
[
|
|
Localizable(true),
|
|
WebCategory("Appearance"),
|
|
WebSysDefaultValue(""),
|
|
WebSysDescription(SR.ChangePassword_PasswordHintText)
|
|
]
|
|
public virtual string PasswordHintText {
|
|
get {
|
|
object obj = ViewState["PasswordHintText"];
|
|
return (obj == null) ? String.Empty : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["PasswordHintText"] = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the text that identifies the new password textbox.
|
|
/// </devdoc>
|
|
[
|
|
Localizable(true),
|
|
WebCategory("Appearance"),
|
|
WebSysDefaultValue(SR.LoginControls_DefaultPasswordLabelText),
|
|
WebSysDescription(SR.LoginControls_PasswordLabelText)
|
|
]
|
|
public virtual string PasswordLabelText {
|
|
get {
|
|
object obj = ViewState["PasswordLabelText"];
|
|
return (obj == null) ? SR.GetString(SR.LoginControls_DefaultPasswordLabelText) : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["PasswordLabelText"] = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Regular expression used to validate the new password
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Validation"),
|
|
WebSysDefaultValue(""),
|
|
WebSysDescription(SR.CreateUserWizard_PasswordRegularExpression)
|
|
]
|
|
public virtual string PasswordRegularExpression {
|
|
get {
|
|
object obj = ViewState["PasswordRegularExpression"];
|
|
return (obj == null) ? String.Empty : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["PasswordRegularExpression"] = value;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the text to be shown in the validation summary when the password fails the reg exp.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Validation"),
|
|
WebSysDefaultValue(SR.Password_InvalidPasswordErrorMessage),
|
|
WebSysDescription(SR.CreateUserWizard_PasswordRegularExpressionErrorMessage)
|
|
]
|
|
public virtual string PasswordRegularExpressionErrorMessage {
|
|
get {
|
|
object obj = ViewState["PasswordRegularExpressionErrorMessage"];
|
|
return (obj == null) ? SR.GetString(SR.Password_InvalidPasswordErrorMessage) : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["PasswordRegularExpressionErrorMessage"] = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the text to be shown in the validation summary when the new password is empty.
|
|
/// </devdoc>
|
|
[
|
|
Localizable(true),
|
|
WebCategory("Validation"),
|
|
WebSysDefaultValue(SR.CreateUserWizard_DefaultPasswordRequiredErrorMessage),
|
|
WebSysDescription(SR.CreateUserWizard_PasswordRequiredErrorMessage)
|
|
]
|
|
public virtual string PasswordRequiredErrorMessage {
|
|
get {
|
|
object obj = ViewState["PasswordRequiredErrorMessage"];
|
|
return (obj == null) ? SR.GetString(SR.CreateUserWizard_DefaultPasswordRequiredErrorMessage) : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["PasswordRequiredErrorMessage"] = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the initial value in the question textbox.
|
|
/// </devdoc>
|
|
[
|
|
Localizable(true),
|
|
WebCategory("Appearance"),
|
|
DefaultValue(""),
|
|
Themeable(false),
|
|
WebSysDescription(SR.CreateUserWizard_Question)
|
|
]
|
|
public virtual string Question {
|
|
get {
|
|
object obj = ViewState["Question"];
|
|
return (obj == null) ? String.Empty : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["Question"] = value;
|
|
}
|
|
}
|
|
|
|
private string QuestionInternal {
|
|
get {
|
|
string question = Question;
|
|
if (String.IsNullOrEmpty(question) && _createUserStepContainer != null) {
|
|
ITextControl questionTextBox = (ITextControl)_createUserStepContainer.QuestionTextBox;
|
|
if (questionTextBox != null) {
|
|
question = questionTextBox.Text;
|
|
}
|
|
}
|
|
// Pass Null instead of Empty into Membership
|
|
if (String.IsNullOrEmpty(question)) question = null;
|
|
return question;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets whether an security question and answer is required to create the user
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Validation"),
|
|
DefaultValue(true),
|
|
WebSysDescription(SR.CreateUserWizard_QuestionAndAnswerRequired)
|
|
]
|
|
protected internal bool QuestionAndAnswerRequired {
|
|
get {
|
|
if (DesignMode) {
|
|
// Don't require question and answer if the CreateUser step is templated in the designer
|
|
if (CreateUserStep != null && CreateUserStep.ContentTemplate != null) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
return LoginUtil.GetProvider(MembershipProvider).RequiresQuestionAndAnswer;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the text that identifies the question textbox.
|
|
/// </devdoc>
|
|
[
|
|
Localizable(true),
|
|
WebCategory("Appearance"),
|
|
WebSysDefaultValue(SR.CreateUserWizard_DefaultQuestionLabelText),
|
|
WebSysDescription(SR.CreateUserWizard_QuestionLabelText)
|
|
]
|
|
public virtual string QuestionLabelText {
|
|
get {
|
|
object obj = ViewState["QuestionLabelText"];
|
|
return (obj == null) ? SR.GetString(SR.CreateUserWizard_DefaultQuestionLabelText) : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["QuestionLabelText"] = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the text to be shown in the validation summary when the question is empty.
|
|
/// </devdoc>
|
|
[
|
|
Localizable(true),
|
|
WebCategory("Validation"),
|
|
WebSysDefaultValue(SR.CreateUserWizard_DefaultQuestionRequiredErrorMessage),
|
|
WebSysDescription(SR.CreateUserWizard_QuestionRequiredErrorMessage)
|
|
]
|
|
public virtual string QuestionRequiredErrorMessage {
|
|
get {
|
|
object obj = ViewState["QuestionRequiredErrorMessage"];
|
|
return (obj == null) ? SR.GetString(SR.CreateUserWizard_DefaultQuestionRequiredErrorMessage) : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["QuestionRequiredErrorMessage"] = value;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets whether an email address is required to create the user
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Behavior"),
|
|
DefaultValue(true),
|
|
Themeable(false),
|
|
WebSysDescription(SR.CreateUserWizard_RequireEmail)
|
|
]
|
|
public virtual bool RequireEmail {
|
|
get {
|
|
object obj = ViewState["RequireEmail"];
|
|
return (obj == null) ? true : (bool)obj;
|
|
}
|
|
set {
|
|
if (RequireEmail != value) {
|
|
ViewState["RequireEmail"] = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal override bool ShowCustomNavigationTemplate {
|
|
get {
|
|
if (base.ShowCustomNavigationTemplate) return true;
|
|
return (ActiveStep == CreateUserStep);
|
|
}
|
|
}
|
|
|
|
[
|
|
DefaultValue(""),
|
|
]
|
|
public override string SkipLinkText {
|
|
get {
|
|
string s = SkipLinkTextInternal;
|
|
return s == null ? String.Empty : s;
|
|
}
|
|
set {
|
|
base.SkipLinkText = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the style of the textboxes.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Styles"),
|
|
DefaultValue(null),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
|
|
NotifyParentProperty(true),
|
|
PersistenceMode(PersistenceMode.InnerProperty),
|
|
WebSysDescription(SR.LoginControls_TextBoxStyle)
|
|
]
|
|
public Style TextBoxStyle {
|
|
get {
|
|
if (_textBoxStyle == null) {
|
|
_textBoxStyle = new Style();
|
|
if (IsTrackingViewState) {
|
|
((IStateManager)_textBoxStyle).TrackViewState();
|
|
}
|
|
}
|
|
return _textBoxStyle;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets the style of the title.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Styles"),
|
|
DefaultValue(null),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
|
|
NotifyParentProperty(true),
|
|
PersistenceMode(PersistenceMode.InnerProperty),
|
|
WebSysDescription(SR.LoginControls_TitleTextStyle)
|
|
]
|
|
public TableItemStyle TitleTextStyle {
|
|
get {
|
|
if (_titleTextStyle == null) {
|
|
_titleTextStyle = new TableItemStyle();
|
|
if (IsTrackingViewState) {
|
|
((IStateManager)_titleTextStyle).TrackViewState();
|
|
}
|
|
}
|
|
return _titleTextStyle;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the initial value in the user name textbox.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Appearance"),
|
|
DefaultValue(""),
|
|
WebSysDescription(SR.UserName_InitialValue)
|
|
]
|
|
public virtual string UserName {
|
|
get {
|
|
object obj = ViewState["UserName"];
|
|
return (obj == null) ? String.Empty : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["UserName"] = value;
|
|
}
|
|
}
|
|
|
|
private string UserNameInternal {
|
|
get {
|
|
string userName = UserName;
|
|
if (String.IsNullOrEmpty(userName) && _createUserStepContainer != null) {
|
|
ITextControl userNameTextBox = (ITextControl)_createUserStepContainer.UserNameTextBox;
|
|
if (userNameTextBox != null) {
|
|
return userNameTextBox.Text;
|
|
}
|
|
}
|
|
return userName;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the text that identifies the user name textbox.
|
|
/// </devdoc>
|
|
[
|
|
Localizable(true),
|
|
WebCategory("Appearance"),
|
|
WebSysDefaultValue(SR.CreateUserWizard_DefaultUserNameLabelText),
|
|
WebSysDescription(SR.LoginControls_UserNameLabelText)
|
|
]
|
|
public virtual string UserNameLabelText {
|
|
get {
|
|
object obj = ViewState["UserNameLabelText"];
|
|
return (obj == null) ? SR.GetString(SR.CreateUserWizard_DefaultUserNameLabelText) : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["UserNameLabelText"] = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets or sets the text to be shown in the validation summary when the user name is empty.
|
|
/// </devdoc>
|
|
[
|
|
Localizable(true),
|
|
WebCategory("Validation"),
|
|
WebSysDefaultValue(SR.CreateUserWizard_DefaultUserNameRequiredErrorMessage),
|
|
WebSysDescription(SR.ChangePassword_UserNameRequiredErrorMessage)
|
|
]
|
|
public virtual string UserNameRequiredErrorMessage {
|
|
get {
|
|
object obj = ViewState["UserNameRequiredErrorMessage"];
|
|
return (obj == null) ? SR.GetString(SR.CreateUserWizard_DefaultUserNameRequiredErrorMessage) : (string)obj;
|
|
}
|
|
set {
|
|
ViewState["UserNameRequiredErrorMessage"] = value;
|
|
}
|
|
}
|
|
|
|
[
|
|
WebCategory("Styles"),
|
|
DefaultValue(null),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
|
|
NotifyParentProperty(true),
|
|
PersistenceMode(PersistenceMode.InnerProperty),
|
|
WebSysDescription(SR.CreateUserWizard_ValidatorTextStyle)
|
|
]
|
|
public Style ValidatorTextStyle {
|
|
get {
|
|
if (_validatorTextStyle == null) {
|
|
_validatorTextStyle = new ErrorStyle();
|
|
if (IsTrackingViewState) {
|
|
((IStateManager)_validatorTextStyle).TrackViewState();
|
|
}
|
|
}
|
|
return _validatorTextStyle;
|
|
}
|
|
}
|
|
|
|
private string ValidationGroup {
|
|
get {
|
|
if (_validationGroup == null) {
|
|
EnsureID();
|
|
_validationGroup = ID;
|
|
}
|
|
|
|
return _validationGroup;
|
|
}
|
|
}
|
|
|
|
|
|
[
|
|
Editor("System.Web.UI.Design.WebControls.CreateUserWizardStepCollectionEditor," + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
|
|
]
|
|
public override WizardStepCollection WizardSteps {
|
|
get {
|
|
return base.WizardSteps;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Public Events
|
|
|
|
/// <devdoc>
|
|
/// Raised on the click of the continue button.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Action"),
|
|
WebSysDescription(SR.CreateUserWizard_ContinueButtonClick)
|
|
]
|
|
public event EventHandler ContinueButtonClick {
|
|
add {
|
|
Events.AddHandler(EventButtonContinueClick, value);
|
|
}
|
|
remove {
|
|
Events.RemoveHandler(EventButtonContinueClick, value);
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Raised before a user is created.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Action"),
|
|
WebSysDescription(SR.CreateUserWizard_CreatingUser)
|
|
]
|
|
public event LoginCancelEventHandler CreatingUser {
|
|
add {
|
|
Events.AddHandler(EventCreatingUser, value);
|
|
}
|
|
remove {
|
|
Events.RemoveHandler(EventCreatingUser, value);
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Raised after a user is created.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Action"),
|
|
WebSysDescription(SR.CreateUserWizard_CreatedUser)
|
|
]
|
|
public event EventHandler CreatedUser {
|
|
add {
|
|
Events.AddHandler(EventCreatedUser, value);
|
|
}
|
|
remove {
|
|
Events.RemoveHandler(EventCreatedUser, value);
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Raised on a create user error
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Action"),
|
|
WebSysDescription(SR.CreateUserWizard_CreateUserError)
|
|
]
|
|
public event CreateUserErrorEventHandler CreateUserError {
|
|
add {
|
|
Events.AddHandler(EventCreateUserError, value);
|
|
}
|
|
remove {
|
|
Events.RemoveHandler(EventCreateUserError, value);
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Raised before the e-mail is sent.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Action"),
|
|
WebSysDescription(SR.ChangePassword_SendingMail)
|
|
]
|
|
public event MailMessageEventHandler SendingMail {
|
|
add {
|
|
Events.AddHandler(EventSendingMail, value);
|
|
}
|
|
remove {
|
|
Events.RemoveHandler(EventSendingMail, value);
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Raised when there is an error sending mail.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Action"),
|
|
WebSysDescription(SR.CreateUserWizard_SendMailError)
|
|
]
|
|
public event SendMailErrorEventHandler SendMailError {
|
|
add {
|
|
Events.AddHandler(EventSendMailError, value);
|
|
}
|
|
remove {
|
|
Events.RemoveHandler(EventSendMailError, value);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
private void AnswerTextChanged(object source, EventArgs e) {
|
|
Answer = ((ITextControl)source).Text;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Sets the properties of child controls that are editable by the client.
|
|
/// </devdoc>
|
|
private void ApplyCommonCreateUserValues() {
|
|
// We need to use Internal for the DropDownList case where it won't fire a TextChanged for the first item
|
|
if (!String.IsNullOrEmpty(UserNameInternal)) {
|
|
ITextControl userNameTextBox = (ITextControl)_createUserStepContainer.UserNameTextBox;
|
|
if (userNameTextBox != null) {
|
|
userNameTextBox.Text = UserNameInternal;
|
|
}
|
|
}
|
|
|
|
if (!String.IsNullOrEmpty(EmailInternal)) {
|
|
ITextControl emailTextBox = (ITextControl)_createUserStepContainer.EmailTextBox;
|
|
if (emailTextBox != null) {
|
|
emailTextBox.Text = EmailInternal;
|
|
}
|
|
}
|
|
|
|
if (!String.IsNullOrEmpty(QuestionInternal)) {
|
|
ITextControl questionTextBox = (ITextControl)_createUserStepContainer.QuestionTextBox;
|
|
if (questionTextBox != null) {
|
|
questionTextBox.Text = QuestionInternal;
|
|
}
|
|
}
|
|
|
|
if (!String.IsNullOrEmpty(AnswerInternal)) {
|
|
ITextControl answerTextBox = (ITextControl)_createUserStepContainer.AnswerTextBox;
|
|
if (answerTextBox != null) {
|
|
answerTextBox.Text = AnswerInternal;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ApplyDefaultCreateUserValues() {
|
|
_createUserStepContainer.UserNameLabel.Text = UserNameLabelText;
|
|
WebControl userTextBox = (WebControl)_createUserStepContainer.UserNameTextBox;
|
|
userTextBox.TabIndex = TabIndex;
|
|
userTextBox.AccessKey = AccessKey;
|
|
|
|
_createUserStepContainer.PasswordLabel.Text = PasswordLabelText;
|
|
WebControl passwordTextBox = (WebControl)_createUserStepContainer.PasswordTextBox;
|
|
passwordTextBox.TabIndex = TabIndex;
|
|
|
|
_createUserStepContainer.ConfirmPasswordLabel.Text = ConfirmPasswordLabelText;
|
|
WebControl confirmTextBox = (WebControl)_createUserStepContainer.ConfirmPasswordTextBox;
|
|
confirmTextBox.TabIndex = TabIndex;
|
|
|
|
if (_textBoxStyle != null) {
|
|
userTextBox.ApplyStyle(_textBoxStyle);
|
|
passwordTextBox.ApplyStyle(_textBoxStyle);
|
|
confirmTextBox.ApplyStyle(_textBoxStyle);
|
|
}
|
|
|
|
LoginUtil.ApplyStyleToLiteral(_createUserStepContainer.Title, CreateUserStep.Title, TitleTextStyle, true);
|
|
LoginUtil.ApplyStyleToLiteral(_createUserStepContainer.InstructionLabel, InstructionText, InstructionTextStyle, true);
|
|
LoginUtil.ApplyStyleToLiteral(_createUserStepContainer.UserNameLabel, UserNameLabelText, LabelStyle, false);
|
|
LoginUtil.ApplyStyleToLiteral(_createUserStepContainer.PasswordLabel, PasswordLabelText, LabelStyle, false);
|
|
LoginUtil.ApplyStyleToLiteral(_createUserStepContainer.ConfirmPasswordLabel, ConfirmPasswordLabelText, LabelStyle, false);
|
|
|
|
// VSWhidbey 447805 Do not render PasswordHintText if AutoGeneratePassword is false.
|
|
if (!String.IsNullOrEmpty(PasswordHintText) && !AutoGeneratePassword) {
|
|
LoginUtil.ApplyStyleToLiteral(_createUserStepContainer.PasswordHintLabel, PasswordHintText, PasswordHintStyle, false);
|
|
} else {
|
|
_passwordHintTableRow.Visible = false;
|
|
}
|
|
|
|
bool enableValidation = true;
|
|
|
|
WebControl emailTextBox = null;
|
|
if (RequireEmail) {
|
|
LoginUtil.ApplyStyleToLiteral(_createUserStepContainer.EmailLabel, EmailLabelText, LabelStyle, false);
|
|
emailTextBox = (WebControl)_createUserStepContainer.EmailTextBox;
|
|
((ITextControl)emailTextBox).Text = Email;
|
|
RequiredFieldValidator emailRequired = _createUserStepContainer.EmailRequired;
|
|
emailRequired.ToolTip = EmailRequiredErrorMessage;
|
|
emailRequired.ErrorMessage = EmailRequiredErrorMessage;
|
|
emailRequired.Enabled = enableValidation;
|
|
emailRequired.Visible = enableValidation;
|
|
if (_validatorTextStyle != null) {
|
|
emailRequired.ApplyStyle(_validatorTextStyle);
|
|
}
|
|
|
|
emailTextBox.TabIndex = TabIndex;
|
|
if (_textBoxStyle != null) {
|
|
emailTextBox.ApplyStyle(_textBoxStyle);
|
|
}
|
|
} else {
|
|
_emailRow.Visible = false;
|
|
}
|
|
|
|
WebControl questionTextBox = null;
|
|
WebControl answerTextBox = null;
|
|
RequiredFieldValidator questionRequired = _createUserStepContainer.QuestionRequired;
|
|
RequiredFieldValidator answerRequired = _createUserStepContainer.AnswerRequired;
|
|
bool qaValidatorsEnabled = enableValidation && QuestionAndAnswerRequired;
|
|
questionRequired.Enabled = qaValidatorsEnabled;
|
|
questionRequired.Visible = qaValidatorsEnabled;
|
|
answerRequired.Enabled = qaValidatorsEnabled;
|
|
answerRequired.Visible = qaValidatorsEnabled;
|
|
if (QuestionAndAnswerRequired) {
|
|
LoginUtil.ApplyStyleToLiteral(_createUserStepContainer.QuestionLabel, QuestionLabelText, LabelStyle, false);
|
|
questionTextBox = (WebControl)_createUserStepContainer.QuestionTextBox;
|
|
((ITextControl)questionTextBox).Text = Question;
|
|
questionTextBox.TabIndex = TabIndex;
|
|
LoginUtil.ApplyStyleToLiteral(_createUserStepContainer.AnswerLabel, AnswerLabelText, LabelStyle, false);
|
|
|
|
answerTextBox = (WebControl)_createUserStepContainer.AnswerTextBox;
|
|
((ITextControl)answerTextBox).Text = Answer;
|
|
answerTextBox.TabIndex = TabIndex;
|
|
|
|
if (_textBoxStyle != null) {
|
|
questionTextBox.ApplyStyle(_textBoxStyle);
|
|
answerTextBox.ApplyStyle(_textBoxStyle);
|
|
}
|
|
|
|
questionRequired.ToolTip = QuestionRequiredErrorMessage;
|
|
questionRequired.ErrorMessage = QuestionRequiredErrorMessage;
|
|
|
|
answerRequired.ToolTip = AnswerRequiredErrorMessage;
|
|
answerRequired.ErrorMessage = AnswerRequiredErrorMessage;
|
|
|
|
if (_validatorTextStyle != null) {
|
|
questionRequired.ApplyStyle(_validatorTextStyle);
|
|
answerRequired.ApplyStyle(_validatorTextStyle);
|
|
}
|
|
} else {
|
|
_questionRow.Visible = false;
|
|
_answerRow.Visible = false;
|
|
}
|
|
|
|
if (_defaultCreateUserNavigationTemplate != null) {
|
|
((BaseNavigationTemplateContainer)(CreateUserStep.CustomNavigationTemplateContainer)).NextButton = _defaultCreateUserNavigationTemplate.CreateUserButton;
|
|
((BaseNavigationTemplateContainer)(CreateUserStep.CustomNavigationTemplateContainer)).CancelButton = _defaultCreateUserNavigationTemplate.CancelButton;
|
|
}
|
|
|
|
RequiredFieldValidator passwordRequired = _createUserStepContainer.PasswordRequired;
|
|
RequiredFieldValidator confirmPasswordRequired = _createUserStepContainer.ConfirmPasswordRequired;
|
|
CompareValidator passwordCompareValidator = _createUserStepContainer.PasswordCompareValidator;
|
|
RegularExpressionValidator regExpValidator = _createUserStepContainer.PasswordRegExpValidator;
|
|
bool passwordValidatorsEnabled = enableValidation && !AutoGeneratePassword;
|
|
passwordRequired.Enabled = passwordValidatorsEnabled;
|
|
passwordRequired.Visible = passwordValidatorsEnabled;
|
|
confirmPasswordRequired.Enabled = passwordValidatorsEnabled;
|
|
confirmPasswordRequired.Visible = passwordValidatorsEnabled;
|
|
passwordCompareValidator.Enabled = passwordValidatorsEnabled;
|
|
passwordCompareValidator.Visible = passwordValidatorsEnabled;
|
|
|
|
bool passRegExpEnabled = passwordValidatorsEnabled && PasswordRegularExpression.Length > 0;
|
|
regExpValidator.Enabled = passRegExpEnabled;
|
|
regExpValidator.Visible = passRegExpEnabled;
|
|
|
|
if (!enableValidation) {
|
|
_passwordRegExpRow.Visible = false;
|
|
_passwordCompareRow.Visible = false;
|
|
_emailRegExpRow.Visible = false;
|
|
}
|
|
|
|
if (AutoGeneratePassword) {
|
|
_passwordTableRow.Visible = false;
|
|
_confirmPasswordTableRow.Visible = false;
|
|
_passwordRegExpRow.Visible = false;
|
|
_passwordCompareRow.Visible = false;
|
|
} else {
|
|
passwordRequired.ErrorMessage = PasswordRequiredErrorMessage;
|
|
passwordRequired.ToolTip = PasswordRequiredErrorMessage;
|
|
|
|
confirmPasswordRequired.ErrorMessage = ConfirmPasswordRequiredErrorMessage;
|
|
confirmPasswordRequired.ToolTip = ConfirmPasswordRequiredErrorMessage;
|
|
|
|
passwordCompareValidator.ErrorMessage = ConfirmPasswordCompareErrorMessage;
|
|
|
|
if (_validatorTextStyle != null) {
|
|
passwordRequired.ApplyStyle(_validatorTextStyle);
|
|
confirmPasswordRequired.ApplyStyle(_validatorTextStyle);
|
|
passwordCompareValidator.ApplyStyle(_validatorTextStyle);
|
|
}
|
|
|
|
if (passRegExpEnabled) {
|
|
regExpValidator.ValidationExpression = PasswordRegularExpression;
|
|
regExpValidator.ErrorMessage = PasswordRegularExpressionErrorMessage;
|
|
if (_validatorTextStyle != null) {
|
|
regExpValidator.ApplyStyle(_validatorTextStyle);
|
|
}
|
|
} else {
|
|
_passwordRegExpRow.Visible = false;
|
|
|
|
}
|
|
}
|
|
|
|
RequiredFieldValidator userNameRequired = _createUserStepContainer.UserNameRequired;
|
|
userNameRequired.ErrorMessage = UserNameRequiredErrorMessage;
|
|
userNameRequired.ToolTip = UserNameRequiredErrorMessage;
|
|
userNameRequired.Enabled = enableValidation;
|
|
userNameRequired.Visible = enableValidation;
|
|
if (_validatorTextStyle != null) {
|
|
userNameRequired.ApplyStyle(_validatorTextStyle);
|
|
}
|
|
|
|
bool emailRegExpEnabled = enableValidation && EmailRegularExpression.Length > 0 && RequireEmail;
|
|
RegularExpressionValidator emailRegExpValidator = _createUserStepContainer.EmailRegExpValidator;
|
|
emailRegExpValidator.Enabled = emailRegExpEnabled;
|
|
emailRegExpValidator.Visible = emailRegExpEnabled;
|
|
if (EmailRegularExpression.Length > 0 && RequireEmail) {
|
|
emailRegExpValidator.ValidationExpression = EmailRegularExpression;
|
|
emailRegExpValidator.ErrorMessage = EmailRegularExpressionErrorMessage;
|
|
if (_validatorTextStyle != null) {
|
|
emailRegExpValidator.ApplyStyle(_validatorTextStyle);
|
|
}
|
|
} else {
|
|
_emailRegExpRow.Visible = false;
|
|
}
|
|
|
|
// Link Setup
|
|
string helpPageText = HelpPageText;
|
|
bool helpPageTextVisible = (helpPageText.Length > 0);
|
|
|
|
HyperLink helpPageLink = _createUserStepContainer.HelpPageLink;
|
|
Image helpPageIcon = _createUserStepContainer.HelpPageIcon;
|
|
helpPageLink.Visible = helpPageTextVisible;
|
|
if (helpPageTextVisible) {
|
|
helpPageLink.Text = helpPageText;
|
|
helpPageLink.NavigateUrl = HelpPageUrl;
|
|
helpPageLink.TabIndex = TabIndex;
|
|
}
|
|
string helpPageIconUrl = HelpPageIconUrl;
|
|
bool helpPageIconVisible = (helpPageIconUrl.Length > 0);
|
|
helpPageIcon.Visible = helpPageIconVisible;
|
|
if (helpPageIconVisible) {
|
|
helpPageIcon.ImageUrl = helpPageIconUrl;
|
|
helpPageIcon.AlternateText = helpPageText;
|
|
}
|
|
LoginUtil.SetTableCellVisible(helpPageLink, helpPageTextVisible || helpPageIconVisible);
|
|
if (_hyperLinkStyle != null && (helpPageTextVisible || helpPageIconVisible)) {
|
|
// Apply style except font to table cell, then apply font and forecolor to HyperLinks
|
|
// VSWhidbey 81289
|
|
TableItemStyle hyperLinkStyleExceptFont = new TableItemStyle();
|
|
hyperLinkStyleExceptFont.CopyFrom(_hyperLinkStyle);
|
|
hyperLinkStyleExceptFont.Font.Reset();
|
|
LoginUtil.SetTableCellStyle(helpPageLink, hyperLinkStyleExceptFont);
|
|
helpPageLink.Font.CopyFrom(_hyperLinkStyle.Font);
|
|
helpPageLink.ForeColor = _hyperLinkStyle.ForeColor;
|
|
}
|
|
|
|
Control errorMessageLabel = _createUserStepContainer.ErrorMessageLabel;
|
|
if (errorMessageLabel != null) {
|
|
if (_failure && !String.IsNullOrEmpty(_unknownErrorMessage)) {
|
|
((ITextControl)errorMessageLabel).Text = _unknownErrorMessage;
|
|
LoginUtil.SetTableCellStyle(errorMessageLabel, ErrorMessageStyle);
|
|
LoginUtil.SetTableCellVisible(errorMessageLabel, true);
|
|
} else {
|
|
LoginUtil.SetTableCellVisible(errorMessageLabel, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ApplyCompleteValues() {
|
|
LoginUtil.ApplyStyleToLiteral(_completeStepContainer.SuccessTextLabel, CompleteSuccessText, _completeSuccessTextStyle, true);
|
|
|
|
switch (ContinueButtonType) {
|
|
case ButtonType.Link:
|
|
_completeStepContainer.ContinuePushButton.Visible = false;
|
|
_completeStepContainer.ContinueImageButton.Visible = false;
|
|
_completeStepContainer.ContinueLinkButton.Text = ContinueButtonText;
|
|
_completeStepContainer.ContinueLinkButton.ValidationGroup = ValidationGroup;
|
|
_completeStepContainer.ContinueLinkButton.TabIndex = TabIndex;
|
|
_completeStepContainer.ContinueLinkButton.AccessKey = AccessKey;
|
|
break;
|
|
case ButtonType.Button:
|
|
_completeStepContainer.ContinueLinkButton.Visible = false;
|
|
_completeStepContainer.ContinueImageButton.Visible = false;
|
|
_completeStepContainer.ContinuePushButton.Text = ContinueButtonText;
|
|
_completeStepContainer.ContinuePushButton.ValidationGroup = ValidationGroup;
|
|
_completeStepContainer.ContinuePushButton.TabIndex = TabIndex;
|
|
_completeStepContainer.ContinuePushButton.AccessKey = AccessKey;
|
|
break;
|
|
case ButtonType.Image:
|
|
_completeStepContainer.ContinueLinkButton.Visible = false;
|
|
_completeStepContainer.ContinuePushButton.Visible = false;
|
|
_completeStepContainer.ContinueImageButton.ImageUrl = ContinueButtonImageUrl;
|
|
_completeStepContainer.ContinueImageButton.AlternateText = ContinueButtonText;
|
|
_completeStepContainer.ContinueImageButton.ValidationGroup = ValidationGroup;
|
|
_completeStepContainer.ContinueImageButton.TabIndex = TabIndex;
|
|
_completeStepContainer.ContinueImageButton.AccessKey = AccessKey;
|
|
break;
|
|
}
|
|
|
|
if (!NavigationButtonStyle.IsEmpty) {
|
|
_completeStepContainer.ContinuePushButton.ApplyStyle(NavigationButtonStyle);
|
|
_completeStepContainer.ContinueImageButton.ApplyStyle(NavigationButtonStyle);
|
|
_completeStepContainer.ContinueLinkButton.ApplyStyle(NavigationButtonStyle);
|
|
}
|
|
|
|
if (_continueButtonStyle != null) {
|
|
_completeStepContainer.ContinuePushButton.ApplyStyle(_continueButtonStyle);
|
|
_completeStepContainer.ContinueImageButton.ApplyStyle(_continueButtonStyle);
|
|
_completeStepContainer.ContinueLinkButton.ApplyStyle(_continueButtonStyle);
|
|
}
|
|
|
|
LoginUtil.ApplyStyleToLiteral(_completeStepContainer.Title, CompleteStep.Title, _titleTextStyle, true);
|
|
|
|
string editProfileText = EditProfileText;
|
|
bool editProfileVisible = (editProfileText.Length > 0);
|
|
HyperLink editProfileLink = _completeStepContainer.EditProfileLink;
|
|
editProfileLink.Visible = editProfileVisible;
|
|
if (editProfileVisible) {
|
|
editProfileLink.Text = editProfileText;
|
|
editProfileLink.NavigateUrl = EditProfileUrl;
|
|
editProfileLink.TabIndex = TabIndex;
|
|
if (_hyperLinkStyle != null) {
|
|
// Apply style except font to table cell, then apply font and forecolor to HyperLinks
|
|
// VSWhidbey 81289
|
|
Style hyperLinkStyleExceptFont = new TableItemStyle();
|
|
hyperLinkStyleExceptFont.CopyFrom(_hyperLinkStyle);
|
|
hyperLinkStyleExceptFont.Font.Reset();
|
|
LoginUtil.SetTableCellStyle(editProfileLink, hyperLinkStyleExceptFont);
|
|
editProfileLink.Font.CopyFrom(_hyperLinkStyle.Font);
|
|
editProfileLink.ForeColor = _hyperLinkStyle.ForeColor;
|
|
}
|
|
}
|
|
string editProfileIconUrl = EditProfileIconUrl;
|
|
bool editProfileIconVisible = (editProfileIconUrl.Length > 0);
|
|
Image editProfileIcon = _completeStepContainer.EditProfileIcon;
|
|
editProfileIcon.Visible = editProfileIconVisible;
|
|
if (editProfileIconVisible) {
|
|
editProfileIcon.ImageUrl = editProfileIconUrl;
|
|
editProfileIcon.AlternateText = EditProfileText;
|
|
}
|
|
LoginUtil.SetTableCellVisible(editProfileLink, editProfileVisible || editProfileIconVisible);
|
|
|
|
// Copy the styles from the StepStyle property if defined.
|
|
Table table = ((CompleteStepContainer)(CompleteStep.ContentTemplateContainer)).LayoutTable;
|
|
table.Height = Height;
|
|
table.Width = Width;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Attempts to create a user, returns false if unsuccessful
|
|
/// </devdoc>
|
|
private bool AttemptCreateUser() {
|
|
if (Page != null && !Page.IsValid) {
|
|
return false;
|
|
}
|
|
|
|
LoginCancelEventArgs args = new LoginCancelEventArgs();
|
|
OnCreatingUser(args);
|
|
if (args.Cancel) return false;
|
|
|
|
MembershipProvider provider = LoginUtil.GetProvider(MembershipProvider);
|
|
MembershipCreateStatus status;
|
|
|
|
if (AutoGeneratePassword) {
|
|
int length = Math.Max(10, Membership.MinRequiredPasswordLength);
|
|
_password = Membership.GeneratePassword(length, Membership.MinRequiredNonAlphanumericCharacters);
|
|
}
|
|
|
|
// CreateUser() should not throw an exception. Status is returned through the out parameter.
|
|
provider.CreateUser(UserNameInternal, PasswordInternal, EmailInternal, QuestionInternal, AnswerInternal, !DisableCreatedUser /*isApproved*/, null, out status);
|
|
if (status == MembershipCreateStatus.Success) {
|
|
OnCreatedUser(EventArgs.Empty);
|
|
|
|
// Send mail if specified
|
|
if (_mailDefinition != null && !String.IsNullOrEmpty(EmailInternal)) {
|
|
LoginUtil.SendPasswordMail(EmailInternal, UserNameInternal, PasswordInternal, MailDefinition,
|
|
/*defaultSubject*/ null, /*defaultBody*/ null, OnSendingMail, OnSendMailError,
|
|
this);
|
|
}
|
|
|
|
// Set AllowReturn to false now that we've created the user
|
|
CreateUserStep.AllowReturnInternal = false;
|
|
|
|
// Set the logged in cookie if required
|
|
if (LoginCreatedUser) {
|
|
AttemptLogin();
|
|
}
|
|
|
|
return true;
|
|
} else {
|
|
// Failed to create user handling below.
|
|
// Raise the error first so users get a chance to change the failure text.
|
|
OnCreateUserError(new CreateUserErrorEventArgs(status));
|
|
|
|
switch (status) {
|
|
case MembershipCreateStatus.DuplicateEmail:
|
|
_unknownErrorMessage = DuplicateEmailErrorMessage;
|
|
break;
|
|
case MembershipCreateStatus.DuplicateUserName:
|
|
_unknownErrorMessage = DuplicateUserNameErrorMessage;
|
|
break;
|
|
case MembershipCreateStatus.InvalidAnswer:
|
|
_unknownErrorMessage = InvalidAnswerErrorMessage;
|
|
break;
|
|
case MembershipCreateStatus.InvalidEmail:
|
|
_unknownErrorMessage = InvalidEmailErrorMessage;
|
|
break;
|
|
case MembershipCreateStatus.InvalidQuestion:
|
|
_unknownErrorMessage = InvalidQuestionErrorMessage;
|
|
break;
|
|
case MembershipCreateStatus.InvalidPassword:
|
|
string invalidPasswordErrorMessage = InvalidPasswordErrorMessage;
|
|
if (!String.IsNullOrEmpty(invalidPasswordErrorMessage)) {
|
|
invalidPasswordErrorMessage = String.Format(CultureInfo.InvariantCulture, invalidPasswordErrorMessage,
|
|
provider.MinRequiredPasswordLength, provider.MinRequiredNonAlphanumericCharacters);
|
|
}
|
|
_unknownErrorMessage = invalidPasswordErrorMessage;
|
|
break;
|
|
default:
|
|
_unknownErrorMessage = UnknownErrorMessage;
|
|
break;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private void AttemptLogin() {
|
|
// Try to authenticate the user
|
|
MembershipProvider provider = LoginUtil.GetProvider(MembershipProvider);
|
|
|
|
// ValidateUser() should not throw an exception.
|
|
if (provider.ValidateUser(UserName, Password)) {
|
|
System.Web.Security.FormsAuthentication.SetAuthCookie(UserNameInternal, false);
|
|
}
|
|
}
|
|
|
|
private void ConfirmPasswordTextChanged(object source, EventArgs e) {
|
|
if (!AutoGeneratePassword) {
|
|
_confirmPassword = ((ITextControl)source).Text;
|
|
}
|
|
}
|
|
|
|
|
|
/// <internalonly />
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
protected internal override void CreateChildControls() {
|
|
_createUserStep = null;
|
|
_completeStep = null;
|
|
|
|
base.CreateChildControls();
|
|
UpdateValidators();
|
|
}
|
|
|
|
|
|
private void RegisterEvents() {
|
|
RegisterTextChangedEvent(_createUserStepContainer.UserNameTextBox, UserNameTextChanged);
|
|
RegisterTextChangedEvent(_createUserStepContainer.EmailTextBox, EmailTextChanged);
|
|
RegisterTextChangedEvent(_createUserStepContainer.QuestionTextBox, QuestionTextChanged);
|
|
RegisterTextChangedEvent(_createUserStepContainer.AnswerTextBox, AnswerTextChanged);
|
|
RegisterTextChangedEvent(_createUserStepContainer.PasswordTextBox, PasswordTextChanged);
|
|
RegisterTextChangedEvent(_createUserStepContainer.ConfirmPasswordTextBox, ConfirmPasswordTextChanged);
|
|
}
|
|
|
|
private static void RegisterTextChangedEvent(Control control, Action<object, EventArgs> textChangedHandler) {
|
|
var textBoxControl = control as IEditableTextControl;
|
|
if (textBoxControl != null) {
|
|
textBoxControl.TextChanged += new EventHandler(textChangedHandler);
|
|
}
|
|
}
|
|
|
|
internal override Wizard.TableWizardRendering CreateTableRendering() {
|
|
return new TableWizardRendering(this);
|
|
}
|
|
|
|
internal override Wizard.LayoutTemplateWizardRendering CreateLayoutTemplateRendering() {
|
|
return new LayoutTemplateWizardRendering(this);
|
|
}
|
|
|
|
internal override ITemplate CreateDefaultSideBarTemplate() {
|
|
return new DefaultSideBarTemplate();
|
|
}
|
|
|
|
internal override ITemplate CreateDefaultDataListItemTemplate() {
|
|
return new DataListItemTemplate();
|
|
}
|
|
|
|
#region Control creation helpers
|
|
|
|
private static TableRow CreateTwoColumnRow(Control leftCellControl, params Control[] rightCellControls) {
|
|
var row = CreateTableRow();
|
|
|
|
var leftCell = CreateTableCell();
|
|
leftCell.HorizontalAlign = HorizontalAlign.Right;
|
|
leftCell.Controls.Add(leftCellControl);
|
|
row.Cells.Add(leftCell);
|
|
|
|
var rightCell = CreateTableCell();
|
|
foreach (var control in rightCellControls) {
|
|
rightCell.Controls.Add(control);
|
|
}
|
|
row.Cells.Add(rightCell);
|
|
|
|
return row;
|
|
}
|
|
|
|
private static TableRow CreateDoubleSpannedColumnRow(params Control[] cellControls) {
|
|
return CreateDoubleSpannedColumnRow(null /* cellHorizontalAlignment */, cellControls);
|
|
}
|
|
|
|
private static TableRow CreateDoubleSpannedColumnRow(HorizontalAlign? cellHorizontalAlignment, params Control[] cellControls) {
|
|
var row = CreateTableRow();
|
|
|
|
var cell = CreateTableCell();
|
|
cell.ColumnSpan = 2;
|
|
if (cellHorizontalAlignment.HasValue) {
|
|
cell.HorizontalAlign = cellHorizontalAlignment.Value;
|
|
}
|
|
foreach (var control in cellControls) {
|
|
cell.Controls.Add(control);
|
|
}
|
|
row.Cells.Add(cell);
|
|
|
|
return row;
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Helper function to create a literal with auto id disabled
|
|
/// </devdoc>
|
|
private static LabelLiteral CreateLabelLiteral(Control control) {
|
|
LabelLiteral lit = new LabelLiteral(control);
|
|
lit.PreventAutoID();
|
|
return lit;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Helper function to create a literal with auto id disabled
|
|
/// </devdoc>
|
|
private static Literal CreateLiteral() {
|
|
Literal lit = new Literal();
|
|
lit.PreventAutoID();
|
|
return lit;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Helper function to create and set properties for a required field validator
|
|
/// </devdoc>
|
|
private static RequiredFieldValidator CreateRequiredFieldValidator(string id, string validationGroup, Control targetTextBox, bool enableValidation) {
|
|
RequiredFieldValidator validator = new RequiredFieldValidator() {
|
|
ID = id,
|
|
ControlToValidate = targetTextBox.ID,
|
|
ValidationGroup = validationGroup,
|
|
Display = _requiredFieldValidatorDisplay,
|
|
Text = SR.GetString(SR.LoginControls_DefaultRequiredFieldValidatorText),
|
|
Enabled = enableValidation,
|
|
Visible = enableValidation
|
|
};
|
|
return validator;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Helper function to create a table with auto id disabled
|
|
/// </devdoc>
|
|
private static Table CreateTable() {
|
|
Table table = new Table();
|
|
table.Width = Unit.Percentage(100);
|
|
table.Height = Unit.Percentage(100);
|
|
table.PreventAutoID();
|
|
return table;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Helper function to create a table cell with auto id disabled
|
|
/// </devdoc>
|
|
private static TableCell CreateTableCell() {
|
|
TableCell cell = new TableCell();
|
|
cell.PreventAutoID();
|
|
return cell;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Helper function to create a table row with auto id disabled
|
|
/// </devdoc>
|
|
private static TableRow CreateTableRow() {
|
|
TableRow row = new LoginUtil.DisappearingTableRow();
|
|
row.PreventAutoID();
|
|
return row;
|
|
}
|
|
|
|
#endregion
|
|
|
|
// Helper method to create custom navigation templates.
|
|
internal override void CreateCustomNavigationTemplates() {
|
|
//
|
|
for (int i = 0; i < WizardSteps.Count; ++i) {
|
|
TemplatedWizardStep step = WizardSteps[i] as TemplatedWizardStep;
|
|
if (step != null) {
|
|
string id = GetCustomContainerID(i);
|
|
BaseNavigationTemplateContainer container = CreateBaseNavigationTemplateContainer(id);
|
|
if (step.CustomNavigationTemplate != null) {
|
|
step.CustomNavigationTemplate.InstantiateIn(container);
|
|
step.CustomNavigationTemplateContainer = container;
|
|
container.SetEnableTheming();
|
|
} else if (step == CreateUserStep) {
|
|
ITemplate customNavigationTemplate = new DefaultCreateUserNavigationTemplate(this);
|
|
customNavigationTemplate.InstantiateIn(container);
|
|
step.CustomNavigationTemplateContainer = container;
|
|
container.RegisterButtonCommandEvents();
|
|
}
|
|
CustomNavigationContainers[step] = container;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal override void DataListItemDataBound(object sender, WizardSideBarListControlItemEventArgs e) {
|
|
var dataListItem = e.Item;
|
|
|
|
// Ignore the item that is not created from DataSource
|
|
if (dataListItem.ItemType != ListItemType.Item &&
|
|
dataListItem.ItemType != ListItemType.AlternatingItem &&
|
|
dataListItem.ItemType != ListItemType.SelectedItem &&
|
|
dataListItem.ItemType != ListItemType.EditItem) {
|
|
return;
|
|
}
|
|
|
|
// For VSWhidbey 193022, we have to support wiring up sidebar buttons in sidebar templates
|
|
// so use the base implementation for this.
|
|
IButtonControl button = dataListItem.FindControl(SideBarButtonID) as IButtonControl;
|
|
if (button != null) {
|
|
base.DataListItemDataBound(sender, e);
|
|
return;
|
|
}
|
|
|
|
Label label = dataListItem.FindControl(_sideBarLabelID) as Label;
|
|
if (label == null) {
|
|
if (!DesignMode) {
|
|
throw new InvalidOperationException(
|
|
SR.GetString(SR.CreateUserWizard_SideBar_Label_Not_Found, DataListID, _sideBarLabelID));
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// Apply the button style to the side bar label.
|
|
label.MergeStyle(SideBarButtonStyle);
|
|
|
|
// Render wizardstep title on the button control.
|
|
WizardStepBase step = dataListItem.DataItem as WizardStepBase;
|
|
if (step != null) {
|
|
// Need to render the sidebar tablecell.
|
|
RegisterSideBarDataListForRender();
|
|
|
|
// Use the step title if defined, otherwise use ID
|
|
if (step.Title.Length > 0) {
|
|
label.Text = step.Title;
|
|
} else {
|
|
label.Text = step.ID;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void EmailTextChanged(object source, EventArgs e) {
|
|
Email = ((ITextControl)source).Text;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Creates the default steps if they were not specified declaritively
|
|
/// </devdoc>
|
|
private void EnsureCreateUserSteps() {
|
|
bool foundCreate = false;
|
|
bool foundComplete = false;
|
|
foreach (WizardStepBase step in WizardSteps) {
|
|
var createUserStep = step as CreateUserWizardStep;
|
|
if (createUserStep != null) {
|
|
if (foundCreate) {
|
|
throw new HttpException(SR.GetString(SR.CreateUserWizard_DuplicateCreateUserWizardStep));
|
|
}
|
|
|
|
foundCreate = true;
|
|
_createUserStep = createUserStep;
|
|
} else {
|
|
var completeStep = step as CompleteWizardStep;
|
|
if (completeStep != null) {
|
|
if (foundComplete) {
|
|
throw new HttpException(SR.GetString(SR.CreateUserWizard_DuplicateCompleteWizardStep));
|
|
}
|
|
|
|
foundComplete = true;
|
|
_completeStep = completeStep;
|
|
}
|
|
}
|
|
}
|
|
if (!foundCreate) {
|
|
// This default step cannot disable ViewState, otherwise AllowReturn will not work properly.
|
|
// VSWhidbey 459041
|
|
_createUserStep = new CreateUserWizardStep();
|
|
// Internally created control needs to be themed as well. VSWhidbey 377952
|
|
_createUserStep.ApplyStyleSheetSkin(Page);
|
|
WizardSteps.AddAt(0, _createUserStep);
|
|
_createUserStep.Active = true;
|
|
}
|
|
if (!foundComplete) {
|
|
// This default step cannot disable ViewState, otherwise AllowReturn will not work properly.
|
|
// VSWhidbey 459041
|
|
_completeStep = new CompleteWizardStep();
|
|
// Internally created control needs to be themed as well. VSWhidbey 377952
|
|
_completeStep.ApplyStyleSheetSkin(Page);
|
|
WizardSteps.Add(_completeStep);
|
|
}
|
|
if (ActiveStepIndex == -1) ActiveStepIndex = 0;
|
|
}
|
|
|
|
|
|
/// <internalonly/>
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
[SecurityPermission(SecurityAction.Demand, Unrestricted = true)]
|
|
protected override IDictionary GetDesignModeState() {
|
|
IDictionary dictionary = base.GetDesignModeState();
|
|
|
|
WizardStepBase active = ActiveStep;
|
|
if (active != null && active == CreateUserStep) {
|
|
dictionary[_customNavigationControls] = CustomNavigationContainers[ActiveStep].Controls;
|
|
}
|
|
|
|
// Needed so the failure text label is visible in the designer
|
|
Control errorMessageLabel = _createUserStepContainer.ErrorMessageLabel;
|
|
if (errorMessageLabel != null) {
|
|
LoginUtil.SetTableCellVisible(errorMessageLabel, true);
|
|
}
|
|
|
|
return dictionary;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Instantiates all the content templates for each TemplatedWizardStep
|
|
/// </devdoc>
|
|
internal override void InstantiateStepContentTemplates() {
|
|
bool useInnerTable = (LayoutTemplate == null);
|
|
foreach (WizardStepBase step in WizardSteps) {
|
|
if (step == CreateUserStep) {
|
|
step.Controls.Clear();
|
|
_createUserStepContainer = new CreateUserStepContainer(this, useInnerTable);
|
|
_createUserStepContainer.ID = _createUserStepContainerID;
|
|
ITemplate createUserStepTemplate = CreateUserStep.ContentTemplate;
|
|
if (createUserStepTemplate == null) {
|
|
createUserStepTemplate = new DefaultCreateUserContentTemplate(this);
|
|
} else {
|
|
_createUserStepContainer.SetEnableTheming();
|
|
}
|
|
createUserStepTemplate.InstantiateIn(_createUserStepContainer.Container);
|
|
|
|
CreateUserStep.ContentTemplateContainer = _createUserStepContainer;
|
|
step.Controls.Add(_createUserStepContainer);
|
|
} else if (step == CompleteStep) {
|
|
step.Controls.Clear();
|
|
_completeStepContainer = new CompleteStepContainer(this, useInnerTable);
|
|
_completeStepContainer.ID = _completeStepContainerID;
|
|
ITemplate completeStepTemplate = CompleteStep.ContentTemplate;
|
|
if (completeStepTemplate == null) {
|
|
completeStepTemplate = new DefaultCompleteStepContentTemplate(_completeStepContainer);
|
|
}
|
|
else {
|
|
_completeStepContainer.SetEnableTheming();
|
|
}
|
|
completeStepTemplate.InstantiateIn(_completeStepContainer.Container);
|
|
|
|
CompleteStep.ContentTemplateContainer = _completeStepContainer;
|
|
step.Controls.Add(_completeStepContainer);
|
|
} else {
|
|
var templatedStep = step as TemplatedWizardStep;
|
|
if (templatedStep != null) {
|
|
InstantiateStepContentTemplate(templatedStep);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <internalonly/>
|
|
/// <devdoc>
|
|
/// Loads a saved state of the <see cref='System.Web.UI.WebControls.CreateUserWizard'/>.
|
|
/// </devdoc>
|
|
protected override void LoadViewState(object savedState) {
|
|
if (savedState == null) {
|
|
base.LoadViewState(null);
|
|
} else {
|
|
object[] myState = (object[])savedState;
|
|
if (myState.Length != _viewStateArrayLength) {
|
|
throw new ArgumentException(SR.GetString(SR.ViewState_InvalidViewState));
|
|
}
|
|
|
|
base.LoadViewState(myState[0]);
|
|
if (myState[1] != null) {
|
|
((IStateManager)CreateUserButtonStyle).LoadViewState(myState[1]);
|
|
}
|
|
if (myState[2] != null) {
|
|
((IStateManager)LabelStyle).LoadViewState(myState[2]);
|
|
}
|
|
if (myState[3] != null) {
|
|
((IStateManager)TextBoxStyle).LoadViewState(myState[3]);
|
|
}
|
|
if (myState[4] != null) {
|
|
((IStateManager)HyperLinkStyle).LoadViewState(myState[4]);
|
|
}
|
|
if (myState[5] != null) {
|
|
((IStateManager)InstructionTextStyle).LoadViewState(myState[5]);
|
|
}
|
|
if (myState[6] != null) {
|
|
((IStateManager)TitleTextStyle).LoadViewState(myState[6]);
|
|
}
|
|
if (myState[7] != null) {
|
|
((IStateManager)ErrorMessageStyle).LoadViewState(myState[7]);
|
|
}
|
|
if (myState[8] != null) {
|
|
((IStateManager)PasswordHintStyle).LoadViewState(myState[8]);
|
|
}
|
|
if (myState[9] != null) {
|
|
((IStateManager)MailDefinition).LoadViewState(myState[9]);
|
|
}
|
|
if (myState[10] != null) {
|
|
((IStateManager)ContinueButtonStyle).LoadViewState(myState[10]);
|
|
}
|
|
if (myState[11] != null) {
|
|
((IStateManager)CompleteSuccessTextStyle).LoadViewState(myState[11]);
|
|
}
|
|
if (myState[12] != null) {
|
|
((IStateManager)ValidatorTextStyle).LoadViewState(myState[12]);
|
|
}
|
|
}
|
|
|
|
UpdateValidators();
|
|
}
|
|
|
|
// Call this whenever ChildControlsAreCreated to ensure we clean up the old validators
|
|
private void UpdateValidators() {
|
|
if (DesignMode) {
|
|
return;
|
|
}
|
|
|
|
// Because we create our child controls during on init, we need to remove validators
|
|
// from the page potentially that were created mistakenly before viewstate was loaded
|
|
if (DefaultCreateUserStep && _createUserStepContainer != null) {
|
|
// Remove the validators that aren't required when autogenerating a password
|
|
if (AutoGeneratePassword) {
|
|
BaseValidator confirmPassword = _createUserStepContainer.ConfirmPasswordRequired;
|
|
if (confirmPassword != null) {
|
|
Page.Validators.Remove(confirmPassword);
|
|
confirmPassword.Enabled = false;
|
|
}
|
|
BaseValidator passwordRequired = _createUserStepContainer.PasswordRequired;
|
|
if (passwordRequired != null) {
|
|
Page.Validators.Remove(passwordRequired);
|
|
passwordRequired.Enabled = false;
|
|
}
|
|
BaseValidator passRegExp = _createUserStepContainer.PasswordRegExpValidator;
|
|
if (passRegExp != null) {
|
|
Page.Validators.Remove(passRegExp);
|
|
passRegExp.Enabled = false;
|
|
}
|
|
} else if (PasswordRegularExpression.Length <= 0) {
|
|
BaseValidator passRegExp = _createUserStepContainer.PasswordRegExpValidator;
|
|
if (passRegExp != null) {
|
|
if (Page != null) {
|
|
Page.Validators.Remove(passRegExp);
|
|
}
|
|
passRegExp.Enabled = false;
|
|
}
|
|
}
|
|
|
|
// remove the validators from the page if we don't require email
|
|
if (!RequireEmail) {
|
|
BaseValidator emailRequired = _createUserStepContainer.EmailRequired;
|
|
if (emailRequired != null) {
|
|
if (Page != null) {
|
|
Page.Validators.Remove(emailRequired);
|
|
}
|
|
emailRequired.Enabled = false;
|
|
}
|
|
BaseValidator emailRegExp = _createUserStepContainer.EmailRegExpValidator;
|
|
if (emailRegExp != null) {
|
|
if (Page != null) {
|
|
Page.Validators.Remove(emailRegExp);
|
|
}
|
|
emailRegExp.Enabled = false;
|
|
}
|
|
} else if (EmailRegularExpression.Length <= 0) {
|
|
BaseValidator emailRegExp = _createUserStepContainer.EmailRegExpValidator;
|
|
if (emailRegExp != null) {
|
|
if (Page != null) {
|
|
Page.Validators.Remove(emailRegExp);
|
|
}
|
|
emailRegExp.Enabled = false;
|
|
}
|
|
}
|
|
|
|
// remove the validators from the page if we don't require question and answer
|
|
if (!QuestionAndAnswerRequired) {
|
|
BaseValidator questionRequired = _createUserStepContainer.QuestionRequired;
|
|
if (questionRequired != null) {
|
|
if (Page != null) {
|
|
Page.Validators.Remove(questionRequired);
|
|
}
|
|
questionRequired.Enabled = false;
|
|
}
|
|
|
|
BaseValidator answerRequired = _createUserStepContainer.AnswerRequired;
|
|
if (answerRequired != null) {
|
|
if (Page != null) {
|
|
Page.Validators.Remove(answerRequired);
|
|
}
|
|
answerRequired.Enabled = false;
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
protected override bool OnBubbleEvent(object source, EventArgs e) {
|
|
// Intercept continue button clicks here
|
|
CommandEventArgs ce = e as CommandEventArgs;
|
|
if (ce != null) {
|
|
if (ce.CommandName.Equals(ContinueButtonCommandName, StringComparison.CurrentCultureIgnoreCase)) {
|
|
OnContinueButtonClick(EventArgs.Empty);
|
|
return true;
|
|
}
|
|
}
|
|
return base.OnBubbleEvent(source, e);
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Raises the ContinueClick event.
|
|
/// </devdoc>
|
|
protected virtual void OnContinueButtonClick(EventArgs e) {
|
|
EventHandler handler = (EventHandler)Events[EventButtonContinueClick];
|
|
if (handler != null) {
|
|
handler(this, e);
|
|
}
|
|
|
|
string continuePageUrl = ContinueDestinationPageUrl;
|
|
if (!String.IsNullOrEmpty(continuePageUrl)) {
|
|
// we should not terminate execution of current page, to give
|
|
// page a chance to cleanup its resources. This may be less performant though.
|
|
Page.Response.Redirect(ResolveClientUrl(continuePageUrl), false);
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Raises the CreatedUser event.
|
|
/// </devdoc>
|
|
protected virtual void OnCreatedUser(EventArgs e) {
|
|
EventHandler handler = (EventHandler)Events[EventCreatedUser];
|
|
if (handler != null) {
|
|
handler(this, e);
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Raises the CreateUserError event.
|
|
/// </devdoc>
|
|
protected virtual void OnCreateUserError(CreateUserErrorEventArgs e) {
|
|
CreateUserErrorEventHandler handler = (CreateUserErrorEventHandler)Events[EventCreateUserError];
|
|
if (handler != null) {
|
|
handler(this, e);
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Raises the CreatingUser event.
|
|
/// </devdoc>
|
|
protected virtual void OnCreatingUser(LoginCancelEventArgs e) {
|
|
LoginCancelEventHandler handler = (LoginCancelEventHandler)Events[EventCreatingUser];
|
|
if (handler != null) {
|
|
handler(this, e);
|
|
}
|
|
}
|
|
|
|
protected override void OnNextButtonClick(WizardNavigationEventArgs e) {
|
|
// If they just clicked next on CreateUser, lets try creating
|
|
if (WizardSteps[e.CurrentStepIndex] == _createUserStep) {
|
|
e.Cancel = (Page != null && !Page.IsValid);
|
|
|
|
if (!e.Cancel) {
|
|
// Cancel the event if there's a failure
|
|
_failure = !AttemptCreateUser();
|
|
if (_failure) {
|
|
e.Cancel = true;
|
|
ITextControl errorMessageLabel = (ITextControl)_createUserStepContainer.ErrorMessageLabel;
|
|
if (errorMessageLabel != null && !String.IsNullOrEmpty(_unknownErrorMessage)) {
|
|
errorMessageLabel.Text = _unknownErrorMessage;
|
|
|
|
var errorMessageLabelCtrl = errorMessageLabel as Control;
|
|
if (errorMessageLabelCtrl != null) {
|
|
errorMessageLabelCtrl.Visible = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
base.OnNextButtonClick(e);
|
|
}
|
|
|
|
|
|
protected internal override void OnPreRender(EventArgs e) {
|
|
// Done for some error checking (no duplicate createuserwizard/complete steps)
|
|
EnsureCreateUserSteps();
|
|
base.OnPreRender(e);
|
|
|
|
// VSWhidbey 438108 Make sure the MembershipProvider exists.
|
|
string providerString = MembershipProvider;
|
|
if (!String.IsNullOrEmpty(providerString)) {
|
|
MembershipProvider provider = Membership.Providers[providerString];
|
|
if (provider == null) {
|
|
throw new HttpException(SR.GetString(SR.WebControl_CantFindProvider));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Raises the SendingMail event.
|
|
/// </devdoc>
|
|
protected virtual void OnSendingMail(MailMessageEventArgs e) {
|
|
MailMessageEventHandler handler = (MailMessageEventHandler)Events[EventSendingMail];
|
|
if (handler != null) {
|
|
handler(this, e);
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Raises the SendMailError event.
|
|
/// </devdoc>
|
|
protected virtual void OnSendMailError(SendMailErrorEventArgs e) {
|
|
SendMailErrorEventHandler handler = (SendMailErrorEventHandler)Events[EventSendMailError];
|
|
if (handler != null) {
|
|
handler(this, e);
|
|
}
|
|
}
|
|
|
|
private void PasswordTextChanged(object source, EventArgs e) {
|
|
if (!AutoGeneratePassword) {
|
|
_password = ((ITextControl)source).Text;
|
|
}
|
|
}
|
|
|
|
private void QuestionTextChanged(object source, EventArgs e) {
|
|
Question = ((ITextControl)source).Text;
|
|
}
|
|
|
|
/// <internalonly/>
|
|
/// <devdoc>
|
|
/// Saves the state of the <see cref='System.Web.UI.WebControls.CreateUserWizard'/>.
|
|
/// </devdoc>
|
|
protected override object SaveViewState() {
|
|
object[] myState = new object[_viewStateArrayLength];
|
|
|
|
myState[0] = base.SaveViewState();
|
|
myState[1] = (_createUserButtonStyle != null) ? ((IStateManager)_createUserButtonStyle).SaveViewState() : null;
|
|
myState[2] = (_labelStyle != null) ? ((IStateManager)_labelStyle).SaveViewState() : null;
|
|
myState[3] = (_textBoxStyle != null) ? ((IStateManager)_textBoxStyle).SaveViewState() : null;
|
|
myState[4] = (_hyperLinkStyle != null) ? ((IStateManager)_hyperLinkStyle).SaveViewState() : null;
|
|
myState[5] =
|
|
(_instructionTextStyle != null) ? ((IStateManager)_instructionTextStyle).SaveViewState() : null;
|
|
myState[6] = (_titleTextStyle != null) ? ((IStateManager)_titleTextStyle).SaveViewState() : null;
|
|
myState[7] =
|
|
(_errorMessageStyle != null) ? ((IStateManager)_errorMessageStyle).SaveViewState() : null;
|
|
myState[8] = (_passwordHintStyle != null) ? ((IStateManager)_passwordHintStyle).SaveViewState() : null;
|
|
myState[9] = (_mailDefinition != null) ? ((IStateManager)_mailDefinition).SaveViewState() : null;
|
|
myState[10] = (_continueButtonStyle != null) ? ((IStateManager)_continueButtonStyle).SaveViewState() : null;
|
|
myState[11] = (_completeSuccessTextStyle != null) ? ((IStateManager)_completeSuccessTextStyle).SaveViewState() : null;
|
|
myState[12] = (_validatorTextStyle != null) ? ((IStateManager)_validatorTextStyle).SaveViewState() : null;
|
|
|
|
for (int i = 0; i < _viewStateArrayLength; i++) {
|
|
if (myState[i] != null) {
|
|
return myState;
|
|
}
|
|
}
|
|
|
|
// More performant to return null than an array of null values
|
|
return null;
|
|
}
|
|
|
|
[SecurityPermission(SecurityAction.Demand, Unrestricted = true)]
|
|
protected override void SetDesignModeState(IDictionary data) {
|
|
if (data != null) {
|
|
object o = data["ConvertToTemplate"];
|
|
if (o != null) {
|
|
_convertingToTemplate = (bool)o;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void SetChildProperties() {
|
|
ApplyCommonCreateUserValues();
|
|
if (DefaultCreateUserStep) {
|
|
ApplyDefaultCreateUserValues();
|
|
}
|
|
|
|
if (DefaultCompleteStep) {
|
|
ApplyCompleteValues();
|
|
}
|
|
|
|
// Always try to apply the failure text, even if templated
|
|
Control errorMessageLabel = _createUserStepContainer.ErrorMessageLabel;
|
|
if (errorMessageLabel != null) {
|
|
if (_failure && !String.IsNullOrEmpty(_unknownErrorMessage)) {
|
|
((ITextControl)errorMessageLabel).Text = _unknownErrorMessage;
|
|
errorMessageLabel.Visible = true;
|
|
} else {
|
|
errorMessageLabel.Visible = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void SetDefaultCreateUserNavigationTemplateProperties() {
|
|
Debug.Assert(_defaultCreateUserNavigationTemplate != null);
|
|
|
|
WebControl createUserButton = (WebControl)_defaultCreateUserNavigationTemplate.CreateUserButton;
|
|
WebControl previousButton = (WebControl)_defaultCreateUserNavigationTemplate.PreviousButton;
|
|
WebControl cancelButton = (WebControl)_defaultCreateUserNavigationTemplate.CancelButton;
|
|
|
|
_defaultCreateUserNavigationTemplate.ApplyLayoutStyleToInnerCells(NavigationStyle);
|
|
|
|
//int createUserStepIndex = WizardSteps.IndexOf(CreateUserStep);
|
|
var createUserButtonControl = (IButtonControl)createUserButton;
|
|
createUserButtonControl.CausesValidation = true;
|
|
createUserButtonControl.Text = CreateUserButtonText;
|
|
createUserButtonControl.ValidationGroup = ValidationGroup;
|
|
var previousButtonControl = (IButtonControl)previousButton;
|
|
previousButtonControl.CausesValidation = false;
|
|
previousButtonControl.Text = StepPreviousButtonText;
|
|
((IButtonControl)cancelButton).Text = CancelButtonText;
|
|
|
|
// Apply styles and tab index to the visible buttons
|
|
if (_createUserButtonStyle != null) createUserButton.ApplyStyle(_createUserButtonStyle);
|
|
createUserButton.ControlStyle.MergeWith(NavigationButtonStyle);
|
|
createUserButton.TabIndex = TabIndex;
|
|
createUserButton.Visible = true;
|
|
|
|
var createUserImageButton = createUserButton as ImageButton;
|
|
if (createUserImageButton != null) {
|
|
createUserImageButton.ImageUrl = CreateUserButtonImageUrl;
|
|
createUserImageButton.AlternateText = CreateUserButtonText;
|
|
}
|
|
|
|
previousButton.ApplyStyle(StepPreviousButtonStyle);
|
|
previousButton.ControlStyle.MergeWith(NavigationButtonStyle);
|
|
previousButton.TabIndex = TabIndex;
|
|
|
|
int previousStepIndex = GetPreviousStepIndex(false);
|
|
if (previousStepIndex != -1 && WizardSteps[previousStepIndex].AllowReturn) {
|
|
previousButton.Visible = true;
|
|
} else {
|
|
previousButton.Parent.Visible = false;
|
|
}
|
|
|
|
var previousImageButton = previousButton as ImageButton;
|
|
if (previousImageButton != null) {
|
|
previousImageButton.AlternateText = StepPreviousButtonText;
|
|
previousImageButton.ImageUrl = StepPreviousButtonImageUrl;
|
|
}
|
|
|
|
if (DisplayCancelButton) {
|
|
cancelButton.ApplyStyle(CancelButtonStyle);
|
|
cancelButton.ControlStyle.MergeWith(NavigationButtonStyle);
|
|
cancelButton.TabIndex = TabIndex;
|
|
cancelButton.Visible = true;
|
|
|
|
var cancelImageButton = cancelButton as ImageButton;
|
|
if (cancelImageButton != null) {
|
|
cancelImageButton.ImageUrl = CancelButtonImageUrl;
|
|
cancelImageButton.AlternateText = CancelButtonText;
|
|
}
|
|
} else {
|
|
cancelButton.Parent.Visible = false;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Marks the starting point to begin tracking and saving changes to the
|
|
/// control as part of the control viewstate.
|
|
/// </devdoc>
|
|
protected override void TrackViewState() {
|
|
base.TrackViewState();
|
|
|
|
if (_createUserButtonStyle != null) {
|
|
((IStateManager)_createUserButtonStyle).TrackViewState();
|
|
}
|
|
if (_labelStyle != null) {
|
|
((IStateManager)_labelStyle).TrackViewState();
|
|
}
|
|
if (_textBoxStyle != null) {
|
|
((IStateManager)_textBoxStyle).TrackViewState();
|
|
}
|
|
if (_hyperLinkStyle != null) {
|
|
((IStateManager)_hyperLinkStyle).TrackViewState();
|
|
}
|
|
if (_instructionTextStyle != null) {
|
|
((IStateManager)_instructionTextStyle).TrackViewState();
|
|
}
|
|
if (_titleTextStyle != null) {
|
|
((IStateManager)_titleTextStyle).TrackViewState();
|
|
}
|
|
if (_errorMessageStyle != null) {
|
|
((IStateManager)_errorMessageStyle).TrackViewState();
|
|
}
|
|
if (_passwordHintStyle != null) {
|
|
((IStateManager)_passwordHintStyle).TrackViewState();
|
|
}
|
|
if (_mailDefinition != null) {
|
|
((IStateManager)_mailDefinition).TrackViewState();
|
|
}
|
|
if (_continueButtonStyle != null) {
|
|
((IStateManager)_continueButtonStyle).TrackViewState();
|
|
}
|
|
if (_completeSuccessTextStyle != null) {
|
|
((IStateManager)_completeSuccessTextStyle).TrackViewState();
|
|
}
|
|
if (_validatorTextStyle != null) {
|
|
((IStateManager)_validatorTextStyle).TrackViewState();
|
|
}
|
|
}
|
|
|
|
private void UserNameTextChanged(object source, EventArgs e) {
|
|
UserName = ((ITextControl)source).Text;
|
|
}
|
|
|
|
|
|
private new class LayoutTemplateWizardRendering : Wizard.LayoutTemplateWizardRendering {
|
|
private new CreateUserWizard Owner { get; set; }
|
|
|
|
public LayoutTemplateWizardRendering(CreateUserWizard owner)
|
|
: base(owner) {
|
|
Owner = owner;
|
|
}
|
|
|
|
public override void CreateControlHierarchy() {
|
|
Owner.EnsureCreateUserSteps();
|
|
|
|
base.CreateControlHierarchy();
|
|
|
|
Owner.InstantiateStepContentTemplates();
|
|
|
|
Owner.RegisterEvents();
|
|
|
|
// Set the editable child control properties here for two reasons:
|
|
// - So change events will be raised if viewstate is disabled on the child controls
|
|
// - Viewstate is always disabled for default template, and might be for user template
|
|
// - So the controls render correctly in the designer
|
|
Owner.ApplyCommonCreateUserValues();
|
|
}
|
|
|
|
|
|
public override void ApplyControlProperties() {
|
|
Owner.SetChildProperties();
|
|
|
|
if (Owner.CreateUserStep.CustomNavigationTemplate == null) {
|
|
Owner.SetDefaultCreateUserNavigationTemplateProperties();
|
|
}
|
|
|
|
base.ApplyControlProperties();
|
|
}
|
|
}
|
|
|
|
|
|
private new class TableWizardRendering : Wizard.TableWizardRendering {
|
|
private new CreateUserWizard Owner {
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public TableWizardRendering(CreateUserWizard wizard)
|
|
: base(wizard) {
|
|
Owner = wizard;
|
|
}
|
|
|
|
public override void ApplyControlProperties() {
|
|
Owner.SetChildProperties();
|
|
|
|
if (Owner.CreateUserStep.CustomNavigationTemplate == null) {
|
|
Owner.SetDefaultCreateUserNavigationTemplateProperties();
|
|
}
|
|
|
|
base.ApplyControlProperties();
|
|
}
|
|
|
|
public override void CreateControlHierarchy() {
|
|
Owner.EnsureCreateUserSteps();
|
|
|
|
base.CreateControlHierarchy();
|
|
|
|
Owner.RegisterEvents();
|
|
|
|
// Set the editable child control properties here for two reasons:
|
|
// - So change events will be raised if viewstate is disabled on the child controls
|
|
// - Viewstate is always disabled for default template, and might be for user template
|
|
// - So the controls render correctly in the designer
|
|
Owner.ApplyCommonCreateUserValues();
|
|
}
|
|
}
|
|
|
|
private sealed class DefaultCompleteStepContentTemplate : ITemplate {
|
|
private CompleteStepContainer _completeContainer;
|
|
|
|
public DefaultCompleteStepContentTemplate(CompleteStepContainer container) {
|
|
_completeContainer = container;
|
|
}
|
|
|
|
private static void ConstructControls(CompleteStepContainer container) {
|
|
container.Title = CreateLiteral();
|
|
|
|
container.SuccessTextLabel = CreateLiteral();
|
|
|
|
container.EditProfileLink = new HyperLink() {
|
|
ID = _editProfileLinkID
|
|
};
|
|
|
|
container.EditProfileIcon = new Image();
|
|
container.EditProfileIcon.PreventAutoID();
|
|
|
|
container.ContinueLinkButton = new LinkButton() {
|
|
ID = _continueButtonID + "LinkButton",
|
|
CommandName = ContinueButtonCommandName,
|
|
CausesValidation = false,
|
|
};
|
|
|
|
container.ContinuePushButton = new Button() {
|
|
ID = _continueButtonID + "Button",
|
|
CommandName = ContinueButtonCommandName,
|
|
CausesValidation = false
|
|
};
|
|
|
|
container.ContinueImageButton = new ImageButton() {
|
|
ID = _continueButtonID + "ImageButton",
|
|
CommandName = ContinueButtonCommandName,
|
|
CausesValidation = false
|
|
}; ;
|
|
}
|
|
|
|
private static void LayoutControls(CompleteStepContainer container) {
|
|
Table table = CreateTable();
|
|
table.EnableViewState = false;
|
|
|
|
AddTitleRow(table, container);
|
|
AddSuccessTextRow(table, container);
|
|
AddContinueRow(table, container);
|
|
AddEditRow(table, container);
|
|
|
|
container.LayoutTable = table;
|
|
container.AddChildControl(table);
|
|
}
|
|
|
|
private static void AddTitleRow(Table table, CompleteStepContainer container) {
|
|
var r = CreateDoubleSpannedColumnRow(HorizontalAlign.Center, container.Title);
|
|
table.Rows.Add(r);
|
|
}
|
|
|
|
private static void AddSuccessTextRow(Table table, CompleteStepContainer container) {
|
|
var r = CreateTableRow();
|
|
var c = CreateTableCell();
|
|
c.Controls.Add(container.SuccessTextLabel);
|
|
r.Cells.Add(c);
|
|
table.Rows.Add(r);
|
|
}
|
|
|
|
private static void AddContinueRow(Table table, CompleteStepContainer container) {
|
|
var r = CreateDoubleSpannedColumnRow(HorizontalAlign.Right,
|
|
container.ContinuePushButton,
|
|
container.ContinueLinkButton,
|
|
container.ContinueImageButton);
|
|
table.Rows.Add(r);
|
|
}
|
|
|
|
private static void AddEditRow(Table table, CompleteStepContainer container) {
|
|
var r = CreateDoubleSpannedColumnRow(container.EditProfileIcon, container.EditProfileLink);
|
|
table.Rows.Add(r);
|
|
}
|
|
|
|
void ITemplate.InstantiateIn(Control container) {
|
|
ConstructControls(_completeContainer);
|
|
LayoutControls(_completeContainer);
|
|
}
|
|
}
|
|
|
|
|
|
private sealed class DefaultCreateUserContentTemplate : ITemplate {
|
|
private CreateUserWizard _wizard;
|
|
|
|
internal DefaultCreateUserContentTemplate(CreateUserWizard wizard) {
|
|
_wizard = wizard;
|
|
}
|
|
|
|
private void ConstructControls(CreateUserStepContainer container) {
|
|
string validationGroup = _wizard.ValidationGroup;
|
|
|
|
container.Title = CreateLiteral();
|
|
container.InstructionLabel = CreateLiteral();
|
|
container.PasswordHintLabel = CreateLiteral();
|
|
|
|
container.UserNameTextBox = new TextBox() {
|
|
ID = _userNameID
|
|
};
|
|
|
|
// Must explicitly set the ID of controls that raise postback events
|
|
container.PasswordTextBox = new TextBox() {
|
|
ID = _passwordID,
|
|
TextMode = TextBoxMode.Password
|
|
}; ;
|
|
|
|
container.ConfirmPasswordTextBox = new TextBox() {
|
|
ID = _confirmPasswordID,
|
|
TextMode = TextBoxMode.Password
|
|
};
|
|
|
|
bool enableValidation = true;
|
|
container.UserNameRequired = CreateRequiredFieldValidator(_userNameRequiredID, validationGroup, container.UserNameTextBox, enableValidation);
|
|
|
|
container.UserNameLabel = CreateLabelLiteral(container.UserNameTextBox);
|
|
container.PasswordLabel = CreateLabelLiteral(container.PasswordTextBox);
|
|
container.ConfirmPasswordLabel = CreateLabelLiteral(container.ConfirmPasswordTextBox);
|
|
|
|
Image helpPageIcon = new Image();
|
|
helpPageIcon.PreventAutoID();
|
|
container.HelpPageIcon = helpPageIcon;
|
|
|
|
container.HelpPageLink = new HyperLink() {
|
|
ID = _helpLinkID
|
|
};
|
|
|
|
container.ErrorMessageLabel = new Literal() {
|
|
ID = _errorMessageID
|
|
};
|
|
|
|
container.EmailTextBox = new TextBox() {
|
|
ID = _emailID
|
|
};
|
|
|
|
container.EmailRequired = CreateRequiredFieldValidator(_emailRequiredID, validationGroup, container.EmailTextBox, enableValidation);
|
|
container.EmailLabel = CreateLabelLiteral(container.EmailTextBox);
|
|
|
|
container.EmailRegExpValidator = new RegularExpressionValidator() {
|
|
ID = _emailRegExpID,
|
|
ControlToValidate = _emailID,
|
|
ErrorMessage = _wizard.EmailRegularExpressionErrorMessage,
|
|
ValidationExpression = _wizard.EmailRegularExpression,
|
|
ValidationGroup = validationGroup,
|
|
Display = _regexpFieldValidatorDisplay,
|
|
Enabled = enableValidation,
|
|
Visible = enableValidation
|
|
};
|
|
|
|
container.PasswordRequired = CreateRequiredFieldValidator(_passwordRequiredID, validationGroup, container.PasswordTextBox, enableValidation);
|
|
container.ConfirmPasswordRequired = CreateRequiredFieldValidator(_confirmPasswordRequiredID, validationGroup, container.ConfirmPasswordTextBox, enableValidation);
|
|
|
|
container.PasswordRegExpValidator = new RegularExpressionValidator() {
|
|
ID = _passwordRegExpID,
|
|
ControlToValidate = _passwordID,
|
|
ErrorMessage = _wizard.PasswordRegularExpressionErrorMessage,
|
|
ValidationExpression = _wizard.PasswordRegularExpression,
|
|
ValidationGroup = validationGroup,
|
|
Display = _regexpFieldValidatorDisplay,
|
|
Enabled = enableValidation,
|
|
Visible = enableValidation,
|
|
};
|
|
|
|
container.PasswordCompareValidator = new CompareValidator() {
|
|
ID = _passwordCompareID,
|
|
ControlToValidate = _confirmPasswordID,
|
|
ControlToCompare = _passwordID,
|
|
Operator = ValidationCompareOperator.Equal,
|
|
ErrorMessage = _wizard.ConfirmPasswordCompareErrorMessage,
|
|
ValidationGroup = validationGroup,
|
|
Display = _compareFieldValidatorDisplay,
|
|
Enabled = enableValidation,
|
|
Visible = enableValidation,
|
|
};
|
|
|
|
container.QuestionTextBox = new TextBox() {
|
|
ID = _questionID
|
|
}; ;
|
|
|
|
container.AnswerTextBox = new TextBox() {
|
|
ID = _answerID
|
|
}; ;
|
|
|
|
container.QuestionRequired = CreateRequiredFieldValidator(_questionRequiredID, validationGroup, container.QuestionTextBox, enableValidation);
|
|
container.AnswerRequired = CreateRequiredFieldValidator(_answerRequiredID, validationGroup, container.AnswerTextBox, enableValidation);
|
|
|
|
container.QuestionLabel = CreateLabelLiteral(container.QuestionTextBox);
|
|
container.AnswerLabel = CreateLabelLiteral(container.AnswerTextBox);
|
|
}
|
|
|
|
private void LayoutControls(CreateUserStepContainer container) {
|
|
Table table = CreateTable();
|
|
table.EnableViewState = false;
|
|
|
|
AddTitleRow(table, container);
|
|
AddInstructionRow(table, container);
|
|
AddUserNameRow(table, container);
|
|
AddPasswordRow(table, container);
|
|
AddPasswordHintRow(table, container);
|
|
AddConfirmPasswordRow(table, container);
|
|
AddEmailRow(table, container);
|
|
AddQuestionRow(table, container);
|
|
AddAnswerRow(table, container);
|
|
AddPasswordCompareValidatorRow(table, container);
|
|
AddPasswordRegexValidatorRow(table, container);
|
|
AddEmailRegexValidatorRow(table, container);
|
|
AddErrorMessageRow(table, container);
|
|
AddHelpPageLinkRow(table, container);
|
|
|
|
container.AddChildControl(table);
|
|
}
|
|
|
|
private static void AddTitleRow(Table table, CreateUserStepContainer container) {
|
|
var row = CreateDoubleSpannedColumnRow(HorizontalAlign.Center, container.Title);
|
|
table.Rows.Add(row);
|
|
}
|
|
|
|
private static void AddInstructionRow(Table table, CreateUserStepContainer container) {
|
|
var row = CreateDoubleSpannedColumnRow(HorizontalAlign.Center, container.InstructionLabel);
|
|
row.PreventAutoID();
|
|
table.Rows.Add(row);
|
|
}
|
|
|
|
private void AddUserNameRow(Table table, CreateUserStepContainer container) {
|
|
if (_wizard.ConvertingToTemplate) {
|
|
container.UserNameLabel.RenderAsLabel = true;
|
|
}
|
|
var row = CreateTwoColumnRow(container.UserNameLabel, container.UserNameTextBox, container.UserNameRequired);
|
|
table.Rows.Add(row);
|
|
}
|
|
|
|
private void AddPasswordRow(Table table, CreateUserStepContainer container) {
|
|
if (_wizard.ConvertingToTemplate) {
|
|
container.PasswordLabel.RenderAsLabel = true;
|
|
}
|
|
var rightCellColumns = new List<Control>() { container.PasswordTextBox };
|
|
if (!_wizard.AutoGeneratePassword) {
|
|
rightCellColumns.Add(container.PasswordRequired);
|
|
}
|
|
var row = CreateTwoColumnRow(container.PasswordLabel, rightCellColumns.ToArray());
|
|
_wizard._passwordTableRow = row;
|
|
table.Rows.Add(row);
|
|
}
|
|
|
|
private void AddPasswordHintRow(Table table, CreateUserStepContainer container) {
|
|
var row = CreateTableRow();
|
|
|
|
var leftCell = CreateTableCell();
|
|
row.Cells.Add(leftCell);
|
|
|
|
var rightCell = CreateTableCell();
|
|
rightCell.Controls.Add(container.PasswordHintLabel);
|
|
row.Cells.Add(rightCell);
|
|
|
|
_wizard._passwordHintTableRow = row;
|
|
table.Rows.Add(row);
|
|
}
|
|
|
|
private void AddConfirmPasswordRow(Table table, CreateUserStepContainer container) {
|
|
if (_wizard.ConvertingToTemplate) {
|
|
container.ConfirmPasswordLabel.RenderAsLabel = true;
|
|
}
|
|
var rightCellColumns = new List<Control>() { container.ConfirmPasswordTextBox };
|
|
if (!_wizard.AutoGeneratePassword) {
|
|
rightCellColumns.Add(container.ConfirmPasswordRequired);
|
|
}
|
|
var row = CreateTwoColumnRow(container.ConfirmPasswordLabel, rightCellColumns.ToArray());
|
|
_wizard._confirmPasswordTableRow = row;
|
|
table.Rows.Add(row);
|
|
}
|
|
|
|
private void AddEmailRow(Table table, CreateUserStepContainer container) {
|
|
if (_wizard.ConvertingToTemplate) {
|
|
container.EmailLabel.RenderAsLabel = true;
|
|
}
|
|
var row = CreateTwoColumnRow(container.EmailLabel, container.EmailTextBox, container.EmailRequired);
|
|
_wizard._emailRow = row;
|
|
table.Rows.Add(row);
|
|
}
|
|
|
|
private void AddQuestionRow(Table table, CreateUserStepContainer container) {
|
|
if (_wizard.ConvertingToTemplate) {
|
|
container.QuestionLabel.RenderAsLabel = true;
|
|
}
|
|
var row = CreateTwoColumnRow(container.QuestionLabel, container.QuestionTextBox, container.QuestionRequired);
|
|
_wizard._questionRow = row;
|
|
table.Rows.Add(row);
|
|
}
|
|
|
|
private void AddAnswerRow(Table table, CreateUserStepContainer container) {
|
|
if (_wizard.ConvertingToTemplate) {
|
|
container.AnswerLabel.RenderAsLabel = true;
|
|
}
|
|
var row = CreateTwoColumnRow(container.AnswerLabel, container.AnswerTextBox, container.AnswerRequired);
|
|
_wizard._answerRow = row;
|
|
table.Rows.Add(row);
|
|
}
|
|
|
|
private void AddPasswordCompareValidatorRow(Table table, CreateUserStepContainer container) {
|
|
var row = CreateDoubleSpannedColumnRow(HorizontalAlign.Center, container.PasswordCompareValidator);
|
|
_wizard._passwordCompareRow = row;
|
|
table.Rows.Add(row);
|
|
}
|
|
|
|
private void AddPasswordRegexValidatorRow(Table table, CreateUserStepContainer container) {
|
|
var row = CreateDoubleSpannedColumnRow(HorizontalAlign.Center, container.PasswordRegExpValidator);
|
|
_wizard._passwordRegExpRow = row;
|
|
table.Rows.Add(row);
|
|
}
|
|
|
|
private void AddEmailRegexValidatorRow(Table table, CreateUserStepContainer container) {
|
|
var row = CreateDoubleSpannedColumnRow(HorizontalAlign.Center, container.EmailRegExpValidator);
|
|
_wizard._emailRegExpRow = row;
|
|
table.Rows.Add(row);
|
|
}
|
|
|
|
private static void AddErrorMessageRow(Table table, CreateUserStepContainer container) {
|
|
var row = CreateDoubleSpannedColumnRow(HorizontalAlign.Center, container.ErrorMessageLabel);
|
|
table.Rows.Add(row);
|
|
}
|
|
|
|
private static void AddHelpPageLinkRow(Table table, CreateUserStepContainer container) {
|
|
var row = CreateDoubleSpannedColumnRow(container.HelpPageIcon, container.HelpPageLink);
|
|
table.Rows.Add(row);
|
|
}
|
|
|
|
void ITemplate.InstantiateIn(Control container) {
|
|
var createUserContainer = _wizard._createUserStepContainer;
|
|
ConstructControls(createUserContainer);
|
|
LayoutControls(createUserContainer);
|
|
}
|
|
}
|
|
|
|
private sealed class DefaultCreateUserNavigationTemplate : ITemplate {
|
|
private CreateUserWizard _wizard;
|
|
private TableRow _row;
|
|
private IButtonControl[][] _buttons;
|
|
private TableCell[] _innerCells;
|
|
|
|
internal DefaultCreateUserNavigationTemplate(CreateUserWizard wizard) {
|
|
_wizard = wizard;
|
|
}
|
|
|
|
internal void ApplyLayoutStyleToInnerCells(TableItemStyle tableItemStyle) {
|
|
// VSWhidbey 401891, apply the table layout styles to the innercells.
|
|
for (int i = 0; i < _innerCells.Length; i++) {
|
|
if (tableItemStyle.IsSet(TableItemStyle.PROP_HORZALIGN)) {
|
|
_innerCells[i].HorizontalAlign = tableItemStyle.HorizontalAlign;
|
|
}
|
|
|
|
if (tableItemStyle.IsSet(TableItemStyle.PROP_VERTALIGN)) {
|
|
_innerCells[i].VerticalAlign = tableItemStyle.VerticalAlign;
|
|
}
|
|
}
|
|
}
|
|
|
|
void ITemplate.InstantiateIn(Control container) {
|
|
_wizard._defaultCreateUserNavigationTemplate = this;
|
|
container.EnableViewState = false;
|
|
|
|
Table table = CreateTable();
|
|
table.CellSpacing = 5;
|
|
table.CellPadding = 5;
|
|
container.Controls.Add(table);
|
|
|
|
TableRow tableRow = new TableRow();
|
|
_row = tableRow;
|
|
tableRow.PreventAutoID();
|
|
tableRow.HorizontalAlign = HorizontalAlign.Right;
|
|
table.Rows.Add(tableRow);
|
|
|
|
_buttons = new IButtonControl[3][];
|
|
_buttons[0] = new IButtonControl[3];
|
|
_buttons[1] = new IButtonControl[3];
|
|
_buttons[2] = new IButtonControl[3];
|
|
|
|
_innerCells = new TableCell[3];
|
|
|
|
_innerCells[0] = CreateButtonControl(_buttons[0], _wizard.ValidationGroup, Wizard.StepPreviousButtonID, false, Wizard.MovePreviousCommandName);
|
|
_innerCells[1] = CreateButtonControl(_buttons[1], _wizard.ValidationGroup, Wizard.StepNextButtonID, true, Wizard.MoveNextCommandName);
|
|
_innerCells[2] = CreateButtonControl(_buttons[2], _wizard.ValidationGroup, Wizard.CancelButtonID, false, Wizard.CancelCommandName);
|
|
}
|
|
|
|
private void OnPreRender(object source, EventArgs e) {
|
|
((ImageButton)source).Visible = false;
|
|
}
|
|
|
|
private TableCell CreateButtonControl(IButtonControl[] buttons, String validationGroup, String id,
|
|
bool causesValidation, string commandName) {
|
|
|
|
LinkButton linkButton = new LinkButton() {
|
|
CausesValidation = causesValidation,
|
|
ID = id + "LinkButton",
|
|
Visible = false,
|
|
CommandName = commandName,
|
|
ValidationGroup = validationGroup
|
|
};
|
|
buttons[0] = linkButton;
|
|
|
|
ImageButton imageButton = new ImageButton() {
|
|
CausesValidation = causesValidation,
|
|
ID = id + "ImageButton",
|
|
// We need the image button to be visible because it OnPreRender is only called on visible controls
|
|
// for postbacks to work, we don't need this behavior in the designer
|
|
Visible = !_wizard.DesignMode,
|
|
CommandName = commandName,
|
|
ValidationGroup = validationGroup
|
|
};
|
|
imageButton.PreRender += new EventHandler(OnPreRender);
|
|
|
|
buttons[1] = imageButton;
|
|
|
|
Button button = new Button() {
|
|
CausesValidation = causesValidation,
|
|
ID = id + "Button",
|
|
Visible = false,
|
|
CommandName = commandName,
|
|
ValidationGroup = validationGroup,
|
|
};
|
|
buttons[2] = button;
|
|
|
|
TableCell tableCell = new TableCell();
|
|
tableCell.HorizontalAlign = HorizontalAlign.Right;
|
|
_row.Cells.Add(tableCell);
|
|
|
|
tableCell.Controls.Add(linkButton);
|
|
tableCell.Controls.Add(imageButton);
|
|
tableCell.Controls.Add(button);
|
|
|
|
return tableCell;
|
|
}
|
|
|
|
internal IButtonControl PreviousButton {
|
|
get {
|
|
return GetButtonBasedOnType(0, _wizard.StepPreviousButtonType);
|
|
}
|
|
}
|
|
|
|
internal IButtonControl CreateUserButton {
|
|
get {
|
|
return GetButtonBasedOnType(1, _wizard.CreateUserButtonType);
|
|
}
|
|
}
|
|
|
|
internal IButtonControl CancelButton {
|
|
get {
|
|
return GetButtonBasedOnType(2, _wizard.CancelButtonType);
|
|
}
|
|
}
|
|
|
|
private IButtonControl GetButtonBasedOnType(int pos, ButtonType type) {
|
|
switch (type) {
|
|
case ButtonType.Button:
|
|
return _buttons[pos][2];
|
|
|
|
case ButtonType.Image:
|
|
return _buttons[pos][1];
|
|
|
|
case ButtonType.Link:
|
|
return _buttons[pos][0];
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private sealed class DataListItemTemplate : ITemplate {
|
|
public void InstantiateIn(Control container) {
|
|
Label item = new Label();
|
|
item.PreventAutoID();
|
|
item.ID = _sideBarLabelID;
|
|
container.Controls.Add(item);
|
|
}
|
|
}
|
|
|
|
private sealed class DefaultSideBarTemplate : ITemplate {
|
|
public void InstantiateIn(Control container) {
|
|
DataList dataList = new DataList();
|
|
dataList.ID = Wizard.DataListID;
|
|
container.Controls.Add(dataList);
|
|
|
|
dataList.SelectedItemStyle.Font.Bold = true;
|
|
dataList.ItemTemplate = new DataListItemTemplate();
|
|
}
|
|
}
|
|
|
|
private sealed class CreateUserStepContainer : BaseContentTemplateContainer {
|
|
private CreateUserWizard _createUserWizard;
|
|
|
|
private Control _userNameTextBox;
|
|
private Control _passwordTextBox;
|
|
private Control _confirmPasswordTextBox;
|
|
private Control _emailTextBox;
|
|
private Control _questionTextBox;
|
|
private Control _answerTextBox;
|
|
|
|
private Control _unknownErrorMessageLabel;
|
|
|
|
internal CreateUserStepContainer(CreateUserWizard wizard, bool useInnerTable)
|
|
: base(wizard, useInnerTable) {
|
|
_createUserWizard = wizard;
|
|
}
|
|
|
|
internal LabelLiteral AnswerLabel { get; set; }
|
|
|
|
internal RequiredFieldValidator AnswerRequired { get; set; }
|
|
|
|
/// <devdoc>
|
|
/// Required control, must have type IEditableTextControl
|
|
/// </devdoc>
|
|
internal Control AnswerTextBox {
|
|
get {
|
|
if (_answerTextBox != null) {
|
|
return _answerTextBox;
|
|
} else {
|
|
Control answerTextBox = FindControl(_answerID);
|
|
if (answerTextBox is IEditableTextControl) {
|
|
//
|
|
return answerTextBox;
|
|
} else {
|
|
if (!_createUserWizard.DesignMode && _createUserWizard.QuestionAndAnswerRequired) {
|
|
throw new HttpException(SR.GetString(SR.CreateUserWizard_NoAnswerTextBox,
|
|
_createUserWizard.ID, _answerID));
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
set {
|
|
_answerTextBox = value;
|
|
}
|
|
}
|
|
|
|
internal LabelLiteral ConfirmPasswordLabel { get; set; }
|
|
|
|
internal RequiredFieldValidator ConfirmPasswordRequired { get; set; }
|
|
|
|
internal Control ConfirmPasswordTextBox {
|
|
get {
|
|
if (_confirmPasswordTextBox != null) {
|
|
return _confirmPasswordTextBox;
|
|
} else {
|
|
Control confirmPasswordTextBox = FindControl(_confirmPasswordID);
|
|
if (confirmPasswordTextBox is IEditableTextControl) {
|
|
//
|
|
return confirmPasswordTextBox;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
set {
|
|
_confirmPasswordTextBox = value;
|
|
}
|
|
}
|
|
|
|
internal LabelLiteral EmailLabel { get; set; }
|
|
|
|
internal RegularExpressionValidator EmailRegExpValidator { get; set; }
|
|
|
|
internal RequiredFieldValidator EmailRequired { get; set; }
|
|
|
|
/// <devdoc>
|
|
/// Required control, must have type IEditableTextControl
|
|
/// </devdoc>
|
|
internal Control EmailTextBox {
|
|
get {
|
|
if (_emailTextBox != null) {
|
|
return _emailTextBox;
|
|
} else {
|
|
Control emailTextBox = FindControl(_emailID);
|
|
if (emailTextBox is IEditableTextControl) {
|
|
//
|
|
return emailTextBox;
|
|
} else {
|
|
if (!_createUserWizard.DesignMode && _createUserWizard.RequireEmail) {
|
|
throw new HttpException(SR.GetString(SR.CreateUserWizard_NoEmailTextBox,
|
|
_createUserWizard.ID, _emailID));
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
set {
|
|
_emailTextBox = value;
|
|
}
|
|
}
|
|
|
|
internal LabelLiteral PasswordLabel { get; set; }
|
|
|
|
/// <devdoc>
|
|
/// Optional control, must have type ITextControl
|
|
/// </devdoc>
|
|
internal Control ErrorMessageLabel {
|
|
get {
|
|
if (_unknownErrorMessageLabel != null) {
|
|
return _unknownErrorMessageLabel;
|
|
} else {
|
|
Control control = FindControl(_errorMessageID);
|
|
ITextControl errorMessageLabel = control as ITextControl;
|
|
if (errorMessageLabel == null) {
|
|
return null;
|
|
}
|
|
return control;
|
|
}
|
|
}
|
|
set {
|
|
_unknownErrorMessageLabel = value;
|
|
}
|
|
}
|
|
|
|
internal Image HelpPageIcon { get; set; }
|
|
|
|
internal HyperLink HelpPageLink { get; set; }
|
|
|
|
internal Literal InstructionLabel { get; set; }
|
|
|
|
internal CompareValidator PasswordCompareValidator { get; set; }
|
|
|
|
internal Literal PasswordHintLabel { get; set; }
|
|
|
|
internal RegularExpressionValidator PasswordRegExpValidator { get; set; }
|
|
|
|
internal RequiredFieldValidator PasswordRequired { get; set; }
|
|
|
|
/// <devdoc>
|
|
/// Required control, must have type IEditableTextControl
|
|
/// </devdoc>
|
|
internal Control PasswordTextBox {
|
|
get {
|
|
if (_passwordTextBox != null) {
|
|
return _passwordTextBox;
|
|
} else {
|
|
Control passwordTextBox = FindControl(_passwordID);
|
|
if (passwordTextBox is IEditableTextControl) {
|
|
//
|
|
return passwordTextBox;
|
|
} else {
|
|
if (!_createUserWizard.DesignMode && !_createUserWizard.AutoGeneratePassword) {
|
|
throw new HttpException(SR.GetString(SR.CreateUserWizard_NoPasswordTextBox,
|
|
_createUserWizard.ID, _passwordID));
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
set {
|
|
_passwordTextBox = value;
|
|
}
|
|
}
|
|
|
|
internal Literal Title { get; set; }
|
|
|
|
internal LabelLiteral UserNameLabel { get; set; }
|
|
|
|
internal RequiredFieldValidator UserNameRequired { get; set; }
|
|
|
|
internal LabelLiteral QuestionLabel { get; set; }
|
|
|
|
internal RequiredFieldValidator QuestionRequired { get; set; }
|
|
|
|
/// <devdoc>
|
|
/// Required control, must have type IEditableTextControl
|
|
/// </devdoc>
|
|
internal Control QuestionTextBox {
|
|
get {
|
|
if (_questionTextBox != null) {
|
|
return _questionTextBox;
|
|
} else {
|
|
Control questionTextBox = FindControl(_questionID);
|
|
if (questionTextBox is IEditableTextControl) {
|
|
//
|
|
return questionTextBox;
|
|
} else {
|
|
if (!_createUserWizard.DesignMode && _createUserWizard.QuestionAndAnswerRequired) {
|
|
throw new HttpException(SR.GetString(SR.CreateUserWizard_NoQuestionTextBox,
|
|
_createUserWizard.ID, _questionID));
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
set {
|
|
_questionTextBox = value;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Required control, must have type IEditableTextControl
|
|
/// </devdoc>
|
|
internal Control UserNameTextBox {
|
|
get {
|
|
if (_userNameTextBox != null) {
|
|
return _userNameTextBox;
|
|
} else {
|
|
Control userNameTextBox = FindControl(_userNameID);
|
|
if (userNameTextBox is IEditableTextControl) {
|
|
//
|
|
return userNameTextBox;
|
|
} else if (!_createUserWizard.DesignMode) {
|
|
throw new HttpException(SR.GetString(SR.CreateUserWizard_NoUserNameTextBox,
|
|
_createUserWizard.ID, _userNameID));
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
set {
|
|
_userNameTextBox = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
private sealed class CompleteStepContainer : BaseContentTemplateContainer {
|
|
|
|
internal CompleteStepContainer(CreateUserWizard wizard, bool useInnerTable)
|
|
: base(wizard, useInnerTable) {
|
|
}
|
|
|
|
internal LinkButton ContinueLinkButton { get; set; }
|
|
|
|
internal Button ContinuePushButton { get; set; }
|
|
|
|
internal ImageButton ContinueImageButton { get; set; }
|
|
|
|
internal Image EditProfileIcon { get; set; }
|
|
|
|
internal HyperLink EditProfileLink { get; set; }
|
|
|
|
internal Table LayoutTable { get; set; }
|
|
|
|
internal Literal SuccessTextLabel { get; set; }
|
|
|
|
internal Literal Title { get; set; }
|
|
}
|
|
}
|
|
}
|