protected override void init()
 {
     if (UserId.HasValue)
     {
         User = UserManagementStatics.GetUser(UserId.Value, true);
     }
 }
Пример #2
0
 protected override void init()
 {
     User = UserManagementStatics.GetUser(EmailAddress);
     if (User == null)
     {
         throw new ApplicationException("emailAddress");
     }
 }
Пример #3
0
        private PostBackAction getSendNewPasswordAction()
        {
            var userLocal = UserManagementStatics.GetUser(emailAddress.Value);

            if (userLocal == null)
            {
                throw new DataModificationException(getUnregisteredEmailMessage());
            }
            return(new PostBackAction(ConfirmPasswordReset.GetInfo(userLocal.Email, info.ReturnUrl)));
        }
Пример #4
0
            protected override void init()
            {
                if (!UserManagementStatics.UserManagementEnabled)
                {
                    throw new ApplicationException("User management not enabled");
                }

                if (User.Any() && User != "anonymous" && (UserObject = UserManagementStatics.GetUser(User)) == null)
                {
                    throw new ApplicationException("user");
                }
            }
Пример #5
0
        protected override void loadData()
        {
            BasicPage.Instance.Body.Attributes["class"] = CssElementCreator.SelectUserPageBodyCssClass;

            ph.AddControlsReturnThis(new PageName());

            if (AppTools.IsLiveInstallation)
            {
                ph.AddControlsReturnThis(
                    new Paragraph(
                        new Strong("Warning:"),
                        " Do not impersonate a user without permission. Your actions will be attributed to the user you are impersonating, not to you.".GetLiteralControl()));
            }

            var pb = PostBack.CreateFull(
                actionGetter: () => new PostBackAction(new ExternalResourceInfo(info.ReturnUrl.Any() ? info.ReturnUrl : NetTools.HomeUrl)));

            DataValue <User> user = new DataValue <User>();

            ph.AddControlsReturnThis(
                FormItem.Create(
                    "User's email address (leave blank for anonymous)",
                    new EwfTextBox(""),
                    validationGetter: control => new EwfValidation(
                        (pbv, validator) => {
                var errorHandler = new ValidationErrorHandler("user");
                var emailAddress = validator.GetEmailAddress(errorHandler, control.GetPostBackValue(pbv), true);
                if (errorHandler.LastResult != ErrorCondition.NoError)
                {
                    return;
                }
                if (!emailAddress.Any())
                {
                    user.Value = null;
                    return;
                }
                user.Value = UserManagementStatics.GetUser(emailAddress);
                if (user.Value == null)
                {
                    validator.NoteErrorAndAddMessage("The email address you entered does not match a user.");
                }
            },
                        pb)).ToControl(),
                new Paragraph(
                    new PostBackButton(
                        pb,
                        new ButtonActionControlStyle(
                            AppRequestState.Instance.ImpersonatorExists ? "Change User" : "Begin Impersonation",
                            buttonSize: ButtonActionControlStyle.ButtonSize.Large))));

            pb.AddModificationMethod(() => UserImpersonationStatics.BeginImpersonation(user.Value));
        }
        /// <summary>
        /// Call this during LoadData.
        /// </summary>
        /// <param name="userId"></param>
        /// <param name="vl"></param>
        /// <param name="availableRoles">Pass a restricted list of <see cref="Role"/>s the user may select. Otherwise, Roles available
        /// in the System Provider are used.</param>
        /// <param name="validationPredicate">If the function returns true, validation continues.</param>
        public void LoadData(int?userId, ValidationList vl, List <Role> availableRoles = null, Func <bool> validationPredicate = null)
        {
            availableRoles = (availableRoles != null ? availableRoles.OrderBy(r => r.Name) : UserManagementStatics.SystemProvider.GetRoles()).ToList();

            user = userId.HasValue ? UserManagementStatics.GetUser(userId.Value, true) : null;
            if (includePasswordControls() && user != null)
            {
                facUser = FormsAuthStatics.GetUser(user.UserId, true);
            }

            Func <bool> validationShouldRun = () => validationPredicate == null || validationPredicate();

            var b = FormItemBlock.CreateFormItemTable(heading: "Security Information");

            b.AddFormItems(
                FormItem.Create(
                    "Email address",
                    new EwfTextBox(user != null ? user.Email : ""),
                    validationGetter: control => new Validation(
                        (pbv, validator) => {
                if (validationShouldRun())
                {
                    Email = validator.GetEmailAddress(new ValidationErrorHandler("email address"), control.GetPostBackValue(pbv), false);
                }
            },
                        vl)));

            if (includePasswordControls())
            {
                var group = new RadioButtonGroup(false);

                var keepPassword = FormItem.Create(
                    "",
                    group.CreateInlineRadioButton(true, label: userId.HasValue ? "Keep the current password" : "Do not create a password"),
                    validationGetter: control => new Validation(
                        (pbv, validator) => {
                    if (!validationShouldRun() || !control.IsCheckedInPostBack(pbv))
                    {
                        return;
                    }
                    if (user != null)
                    {
                        Salt               = facUser.Salt;
                        SaltedPassword     = facUser.SaltedPassword;
                        MustChangePassword = facUser.MustChangePassword;
                    }
                    else
                    {
                        genPassword(false);
                    }
                },
                        vl));

                var generatePassword = FormItem.Create(
                    "",
                    group.CreateInlineRadioButton(false, label: "Generate a " + (userId.HasValue ? "new, " : "") + "random password and email it to the user"),
                    validationGetter: control => new Validation(
                        (pbv, validator) => {
                    if (validationShouldRun() && control.IsCheckedInPostBack(pbv))
                    {
                        genPassword(true);
                    }
                },
                        vl));

                var newPassword      = new DataValue <string>();
                var confirmPassword  = new DataValue <string>();
                var newPasswordTable = EwfTable.Create(style: EwfTableStyle.StandardExceptLayout);
                newPasswordTable.AddItem(
                    new EwfTableItem(
                        "Password",
                        FormItem.Create(
                            "",
                            new EwfTextBox("", masksCharacters: true, disableBrowserAutoComplete: true)
                {
                    Width = Unit.Pixel(200)
                },
                            validationGetter: control => new Validation((pbv, v) => newPassword.Value = control.GetPostBackValue(pbv), vl)).ToControl()));
                newPasswordTable.AddItem(
                    new EwfTableItem(
                        "Password again",
                        FormItem.Create(
                            "",
                            new EwfTextBox("", masksCharacters: true, disableBrowserAutoComplete: true)
                {
                    Width = Unit.Pixel(200)
                },
                            validationGetter: control => new Validation((pbv, v) => confirmPassword.Value = control.GetPostBackValue(pbv), vl)).ToControl()));

                var providePasswordRadio = group.CreateBlockRadioButton(false, label: "Provide a " + (userId.HasValue ? "new " : "") + "password");
                providePasswordRadio.NestedControls.Add(newPasswordTable);
                var providePassword = FormItem.Create(
                    "",
                    providePasswordRadio,
                    validationGetter: control => new Validation(
                        (pbv, validator) => {
                    if (!validationShouldRun() || !control.IsCheckedInPostBack(pbv))
                    {
                        return;
                    }
                    FormsAuthStatics.ValidatePassword(validator, newPassword, confirmPassword);
                    var p              = new Password(newPassword.Value);
                    Salt               = p.Salt;
                    SaltedPassword     = p.ComputeSaltedHash();
                    MustChangePassword = false;
                },
                        vl));

                b.AddFormItems(
                    FormItem.Create("Password", ControlStack.CreateWithControls(true, keepPassword.ToControl(), generatePassword.ToControl(), providePassword.ToControl())));
            }

            b.AddFormItems(
                FormItem.Create(
                    "Role",
                    SelectList.CreateDropDown(
                        from i in availableRoles select SelectListItem.Create(i.RoleId as int?, i.Name),
                        user != null ? user.Role.RoleId as int? : null),
                    validationGetter: control => new Validation(
                        (pbv, validator) => {
                if (validationShouldRun())
                {
                    RoleId = control.ValidateAndGetSelectedItemIdInPostBack(pbv, validator) ?? default(int);
                }
            },
                        vl)));

            Controls.Add(b);
        }
Пример #7
0
        protected override void loadData()
        {
            if (info.User.Any())
            {
                if (!pageViewDataModificationsExecuted)
                {
                    throw new ApplicationException("Page-view data modifications did not execute.");
                }

                ph.AddControlsReturnThis(new Paragraph("Please wait.".ToComponents()).ToCollection().GetControls());
                StandardLibrarySessionState.Instance.SetInstantClientSideNavigation(new ExternalResourceInfo(info.ReturnUrl).GetUrl());
                return;
            }

            BasicPage.Instance.Body.Attributes["class"] = CssElementCreator.SelectUserPageBodyCssClass;

            ph.AddControlsReturnThis(new PageName().ToCollection().GetControls());

            if (ConfigurationStatics.IsLiveInstallation)
            {
                ph.AddControlsReturnThis(
                    new Paragraph(
                        new ImportantContent("Warning:".ToComponents()).ToCollection()
                        .Concat(
                            " Do not impersonate a user without permission. Your actions will be attributed to the user you are impersonating, not to you."
                            .ToComponents())
                        .Materialize()).ToCollection()
                    .GetControls());
            }

            var user = new DataValue <User>();
            var pb   = PostBack.CreateFull(
                firstModificationMethod: () => UserImpersonationStatics.BeginImpersonation(user.Value),
                actionGetter: () => new PostBackAction(new ExternalResourceInfo(info.ReturnUrl.Any() ? info.ReturnUrl : NetTools.HomeUrl)));

            FormState.ExecuteWithDataModificationsAndDefaultAction(
                pb.ToCollection(),
                () => {
                ph.AddControlsReturnThis(
                    new EmailAddressControl(
                        "",
                        true,
                        validationMethod: (postBackValue, validator) => {
                    if (!postBackValue.Any())
                    {
                        user.Value = null;
                        return;
                    }
                    user.Value = UserManagementStatics.GetUser(postBackValue);
                    if (user.Value == null)
                    {
                        validator.NoteErrorAndAddMessage("The email address you entered does not match a user.");
                    }
                }).ToFormItem(label: "User's email address (leave blank for anonymous)".ToComponents())
                    .ToComponentCollection()
                    .Append(
                        new Paragraph(
                            new EwfButton(
                                new StandardButtonStyle(
                                    AppRequestState.Instance.ImpersonatorExists ? "Change User" : "Begin Impersonation",
                                    buttonSize: ButtonSize.Large))
                            .ToCollection()))
                    .GetControls());
            });
        }
        /// <summary>
        /// Call this during LoadData.
        /// </summary>
        /// <param name="userId"></param>
        /// <param name="availableRoles">Pass a restricted list of <see cref="Role"/>s the user may select. Otherwise, Roles available
        /// in the System Provider are used.</param>
        public void LoadData(int?userId, List <Role> availableRoles = null)
        {
            availableRoles = (availableRoles?.OrderBy(r => r.Name) ?? UserManagementStatics.SystemProvider.GetRoles()).ToList();

            var user    = userId.HasValue ? UserManagementStatics.GetUser(userId.Value, true) : null;
            var facUser = includePasswordControls() && user != null?FormsAuthStatics.GetUser(user.UserId, true) : null;

            var b = FormItemList.CreateStack();

            b.AddFormItems(Email.ToEmailAddressControl(false, value: user != null ? user.Email : "").ToFormItem(label: "Email address".ToComponents()));

            if (includePasswordControls())
            {
                var group = new RadioButtonGroup(false);

                var keepPassword = group.CreateRadioButton(
                    true,
                    label: userId.HasValue ? "Keep the current password".ToComponents() : "Do not create a password".ToComponents(),
                    validationMethod: (postBackValue, validator) => {
                    if (!postBackValue.Value)
                    {
                        return;
                    }
                    if (user != null)
                    {
                        Salt.Value               = facUser.Salt;
                        SaltedPassword.Value     = facUser.SaltedPassword;
                        MustChangePassword.Value = facUser.MustChangePassword;
                    }
                    else
                    {
                        genPassword(false);
                    }
                })
                                   .ToFormItem();

                var generatePassword = group.CreateRadioButton(
                    false,
                    label: "Generate a {0} password and email it to the user".FormatWith(userId.HasValue ? "new, random" : "random").ToComponents(),
                    validationMethod: (postBackValue, validator) => {
                    if (postBackValue.Value)
                    {
                        genPassword(true);
                    }
                })
                                       .ToFormItem();

                var providePasswordSelected = new DataValue <bool>();
                var providePassword         = group.CreateFlowRadioButton(
                    false,
                    label: "Provide a {0}".FormatWith(userId.HasValue ? "new password" : "password").ToComponents(),
                    setup: FlowRadioButtonSetup.Create(
                        nestedContentGetter: () => {
                    return(FormState.ExecuteWithValidationPredicate(
                               () => providePasswordSelected.Value,
                               () => {
                        var password = new DataValue <string>();
                        var list = FormItemList.CreateStack(
                            generalSetup: new FormItemListSetup(classes: new ElementClass("newPassword")),
                            items: password.GetPasswordModificationFormItems());

                        new EwfValidation(
                            validator => {
                            var p = new Password(password.Value);
                            Salt.Value = p.Salt;
                            SaltedPassword.Value = p.ComputeSaltedHash();
                            MustChangePassword.Value = false;
                        });

                        return list.ToCollection();
                    }));
                }),
                    validationMethod: (postBackValue, validator) => providePasswordSelected.Value = postBackValue.Value)
                                              .ToFormItem();

                b.AddFormItems(
                    new StackList(keepPassword.ToListItem().ToCollection().Append(generatePassword.ToListItem()).Append(providePassword.ToListItem())).ToFormItem(
                        label: "Password".ToComponents()));
            }

            b.AddFormItems(
                RoleId.ToDropDown(
                    DropDownSetup.Create(from i in availableRoles select SelectListItem.Create(i.RoleId as int?, i.Name)),
                    value: new SpecifiedValue <int?>(user?.Role.RoleId))
                .ToFormItem(label: "Role".ToComponents()));

            this.AddControlsReturnThis(new Section("Security Information", b.ToCollection()).ToCollection().GetControls());
        }
Пример #9
0
        /// <summary>
        /// Call this during LoadData.
        /// </summary>
        /// <param name="userId"></param>
        /// <param name="availableRoles">Pass a restricted list of <see cref="Role"/>s the user may select. Otherwise, Roles available
        /// in the System Provider are used.</param>
        /// <param name="validationPredicate">If the function returns true, validation continues.</param>
        public void LoadData(int?userId, List <Role> availableRoles = null, Func <bool> validationPredicate = null)
        {
            availableRoles = (availableRoles != null ? availableRoles.OrderBy(r => r.Name) : UserManagementStatics.SystemProvider.GetRoles()).ToList();

            user = userId.HasValue ? UserManagementStatics.GetUser(userId.Value, true) : null;
            if (includePasswordControls() && user != null)
            {
                facUser = FormsAuthStatics.GetUser(user.UserId, true);
            }

            Func <bool> validationShouldRun = () => validationPredicate == null || validationPredicate();

            var b = FormItemBlock.CreateFormItemTable(heading: "Security Information");

            b.AddFormItems(
                FormItem.Create(
                    "Email address",
                    new EwfTextBox(user != null ? user.Email : ""),
                    validationGetter: control => new EwfValidation(
                        (pbv, validator) => {
                if (validationShouldRun())
                {
                    Email = validator.GetEmailAddress(new ValidationErrorHandler("email address"), control.GetPostBackValue(pbv), false);
                }
            })));

            if (includePasswordControls())
            {
                var group = new RadioButtonGroup(false);

                var keepPassword = FormItem.Create(
                    "",
                    group.CreateInlineRadioButton(true, label: userId.HasValue ? "Keep the current password" : "Do not create a password"),
                    validationGetter: control => new EwfValidation(
                        (pbv, validator) => {
                    if (!validationShouldRun() || !control.IsCheckedInPostBack(pbv))
                    {
                        return;
                    }
                    if (user != null)
                    {
                        Salt               = facUser.Salt;
                        SaltedPassword     = facUser.SaltedPassword;
                        MustChangePassword = facUser.MustChangePassword;
                    }
                    else
                    {
                        genPassword(false);
                    }
                }));

                var generatePassword = FormItem.Create(
                    "",
                    group.CreateInlineRadioButton(false, label: "Generate a " + (userId.HasValue ? "new, " : "") + "random password and email it to the user"),
                    validationGetter: control => new EwfValidation(
                        (pbv, validator) => {
                    if (validationShouldRun() && control.IsCheckedInPostBack(pbv))
                    {
                        genPassword(true);
                    }
                }));

                var providePassword = FormState.ExecuteWithValidationPredicate(
                    validationShouldRun,
                    () => {
                    var providePasswordSelected = new DataValue <bool>();
                    return(FormItem.Create(
                               "",
                               group.CreateBlockRadioButton(
                                   false,
                                   (postBackValue, validator) => providePasswordSelected.Value = postBackValue.Value,
                                   label: "Provide a {0}".FormatWith(userId.HasValue ? "new password" : "password"),
                                   nestedControlListGetter: () => {
                        return FormState.ExecuteWithValidationPredicate(
                            () => providePasswordSelected.Value,
                            () => {
                            var password = new DataValue <string>();
                            var newPasswordTable = EwfTable.Create(style: EwfTableStyle.StandardExceptLayout);
                            foreach (var i in password.GetPasswordModificationFormItems(textBoxWidth: Unit.Pixel(200)))
                            {
                                newPasswordTable.AddItem(new EwfTableItem(i.Label, i.ToControl(omitLabel: true)));
                            }

                            new EwfValidation(
                                validator => {
                                var p = new Password(password.Value);
                                Salt = p.Salt;
                                SaltedPassword = p.ComputeSaltedHash();
                                MustChangePassword = false;
                            });

                            return newPasswordTable.ToCollection();
                        });
                    }),
                               validationGetter: control => control.Validation));
                });

                b.AddFormItems(
                    FormItem.Create("Password", ControlStack.CreateWithControls(true, keepPassword.ToControl(), generatePassword.ToControl(), providePassword.ToControl())));
            }

            b.AddFormItems(
                FormItem.Create(
                    "Role",
                    SelectList.CreateDropDown(
                        from i in availableRoles select SelectListItem.Create(i.RoleId as int?, i.Name),
                        user != null ? user.Role.RoleId as int? : null),
                    validationGetter: control => new EwfValidation(
                        (pbv, validator) => {
                if (validationShouldRun())
                {
                    RoleId = control.ValidateAndGetSelectedItemIdInPostBack(pbv, validator) ?? default(int);
                }
            })));

            Controls.Add(b);
        }