Cómo extender las propiedades disponibles de User.Identity

Solución:

Siempre que desee extender las propiedades de User.Identity con propiedades adicionales como la pregunta anterior, agregue estas propiedades a la clase ApplicationUser primero así:

public class ApplicationUser : IdentityUser
{
    public async Task<ClaimsIdentity> GenerateUserIdentityAsync(UserManager<ApplicationUser> manager)
    {
        // Note the authenticationType must match the one defined in CookieAuthenticationOptions.AuthenticationType
        var userIdentity = await manager.CreateIdentityAsync(this, DefaultAuthenticationTypes.ApplicationCookie);
        // Add custom user claims here
        return userIdentity;
    }

    // Your Extended Properties
    public long? OrganizationId { get; set; }
}

Entonces, lo que necesita es crear un método de extensión como este (yo creo el mío en una nueva carpeta de Extensiones):

namespace App.Extensions
{
    public static class IdentityExtensions
    {
        public static string GetOrganizationId(this IIdentity identity)
        {
            var claim = ((ClaimsIdentity)identity).FindFirst("OrganizationId");
            // Test for null to avoid issues during local testing
            return (claim != null) ? claim.Value : string.Empty;
        }
    }
}

Cuando crea la Identidad en la clase ApplicationUser, simplemente agregue el Claim -> OrganizationId así:

    public async Task<ClaimsIdentity> GenerateUserIdentityAsync(UserManager<ApplicationUser> manager)
    {
        // Note the authenticationType must match the one defined in CookieAuthenticationOptions.AuthenticationType
        var userIdentity = await manager.CreateIdentityAsync(this, DefaultAuthenticationTypes.ApplicationCookie);
        // Add custom user claims here => this.OrganizationId is a value stored in database against the user
        userIdentity.AddClaim(new Claim("OrganizationId", this.OrganizationId.ToString()));

        return userIdentity;
    }

Una vez que haya agregado el reclamo y tenga su método de extensión en su lugar, para que esté disponible como una propiedad en su User.Identity, agregue una declaración de uso en la página / archivo al que desea acceder:

en mi caso: using App.Extensions; dentro de un controlador y @using. App.Extensions dentro de un archivo .cshtml Ver.

EDITAR:

Lo que también puede hacer para evitar agregar una declaración de uso en cada Vista es ir a la carpeta Vistas y ubicar el archivo Web.config allí. Ahora busque el <namespaces> etiqueta y agregue su espacio de nombre de extensión allí así:

<add namespace="App.Extensions" />

Guarde su archivo y listo. Ahora todas las vistas conocerán tus extensiones.

Puede acceder al método de extensión:

var orgId = User.Identity.GetOrganizationId();

Estaba buscando la misma solución y Pawel me dio el 99% de la respuesta. Lo único que faltaba y que necesitaba para que se mostrara la extensión era agregar el siguiente código de Razor en la página cshtml (ver):

@using programname.Models.Extensions

Estaba buscando el Nombre, para mostrarlo en la parte superior derecha de mi NavBar después de que el usuario inicie sesión.

Pensé que publicaría esto en caso de que ayude a alguien más, así que aquí está mi código:

Creé una nueva carpeta llamada Extensiones (bajo mi carpeta de modelos) y creé la nueva clase como Pawel especificó anteriormente: IdentityExtensions.cs

using System.Security.Claims;
using System.Security.Principal;

namespace ProgramName.Models.Extensions
{
    public static class IdentityExtensions
    {
        public static string GetUserFirstname(this IIdentity identity)
        {
            var claim = ((ClaimsIdentity)identity).FindFirst("FirstName");
            // Test for null to avoid issues during local testing
            return (claim != null) ? claim.Value : string.Empty;
        }
    }
}

IdentityModels.cs :

public class ApplicationUser : IdentityUser
{

    //Extended Properties
    public string FirstName { get; internal set; }
    public string Surname { get; internal set; }
    public bool isAuthorized { get; set; }
    public bool isActive { get; set; }

    public async Task<ClaimsIdentity> GenerateUserIdentityAsync(UserManager<ApplicationUser> manager)
    {
        // Note the authenticationType must match the one defined in CookieAuthenticationOptions.AuthenticationType
        var userIdentity = await manager.CreateIdentityAsync(this, DefaultAuthenticationTypes.ApplicationCookie);
        // Add custom user claims here
        userIdentity.AddClaim(new Claim("FirstName", this.FirstName));

        return userIdentity;
    }
}

Entonces en mi _LoginPartial.cshtml(Debajo Views/Shared Carpetas) agregué @using.ProgramName.Models.Extensions

Luego agregué el cambio a la siguiente línea de código que iba a usar el nombre del usuario después de iniciar sesión:

@Html.ActionLink("Hello " + User.Identity.GetUserFirstname() + "!", "Index", "Manage", routeValues: null, htmlAttributes: new { title = "Manage" })

Quizás esto ayude a alguien más en el futuro.

Consulte esta excelente publicación de blog de John Atten: ASP.NET Identity 2.0: Customizing Users and Roles

Tiene excelente información paso a paso sobre todo el proceso. Ve a leerlo 🙂

Éstos son algunos de los conceptos básicos.

Extienda la clase ApplicationUser predeterminada agregando nuevas propiedades (es decir, dirección, ciudad, estado, etc.):

public class ApplicationUser : IdentityUser
{
    public async Task<ClaimsIdentity> 
    GenerateUserIdentityAsync(UserManager<ApplicationUser> manager)
    {
        var userIdentity = await manager.CreateIdentityAsync(this,  DefaultAuthenticationTypes.ApplicationCookie);
        return userIdentity;
    }
    public string Address { get; set; }
    public string City { get; set; }
    public string State { get; set; }

    // Use a sensible display name for views:
    [Display(Name = "Postal Code")]
    public string PostalCode { get; set; }

    // Concatenate the address info for display in tables and such:
    public string DisplayAddress
    {
        get
        {
            string dspAddress = string.IsNullOrWhiteSpace(this.Address) ? "" : this.Address;
            string dspCity = string.IsNullOrWhiteSpace(this.City) ? "" : this.City;
            string dspState = string.IsNullOrWhiteSpace(this.State) ? "" : this.State;
            string dspPostalCode = string.IsNullOrWhiteSpace(this.PostalCode) ? "" : this.PostalCode;

            return string.Format("{0} {1} {2} {3}", dspAddress, dspCity, dspState, dspPostalCode);
        }
    }

Luego agrega sus nuevas propiedades a su RegisterViewModel.

    // Add the new address properties:
    public string Address { get; set; }
    public string City { get; set; }
    public string State { get; set; }

Luego actualice la Vista de registro para incluir las nuevas propiedades.

    <div class="form-group">
        @Html.LabelFor(m => m.Address, new { @class = "col-md-2 control-label" })
        <div class="col-md-10">
            @Html.TextBoxFor(m => m.Address, new { @class = "form-control" })
        </div>
    </div>

Luego actualice el método Register () en AccountController con las nuevas propiedades.

    // Add the Address properties:
    user.Address = model.Address;
    user.City = model.City;
    user.State = model.State;
    user.PostalCode = model.PostalCode;

---

---

Utiliza Nuestro Buscador