IdentityManagerMetadata GetMetadata()
{
if (metadata == null)
{
var createprops = new List<PropertyMetadata>()
{
PropertyMetadata.FromProperty<InMemoryUser>(x => x.Username, type:Constants.ClaimTypes.Username, required:true),
};
var updateprops = new List<PropertyMetadata>();
updateprops.AddRange(new PropertyMetadata[]{
PropertyMetadata.FromProperty<InMemoryUser>(x => x.Username, type:Constants.ClaimTypes.Username, required:true),
PropertyMetadata.FromPropertyName<InMemoryUser>("Password", type:Constants.ClaimTypes.Password, required:true),
PropertyMetadata.FromFunctions<InMemoryUser, string>(Constants.ClaimTypes.Name, this.GetName, this.SetName, name:"Name", required:true),
});
updateprops.AddRange(PropertyMetadata.FromType<InMemoryUser>());
updateprops.AddRange(new PropertyMetadata[]{
PropertyMetadata.FromPropertyName<InMemoryUser>("Mobile"),
PropertyMetadata.FromPropertyName<InMemoryUser>("Email", dataType:PropertyDataType.Email),
new PropertyMetadata {
Name = "Is Administrator",
Type = "role.admin",
DataType = PropertyDataType.Boolean,
Required = true,
},
new PropertyMetadata {
Name = "Gravatar Url",
Type = "gravatar",
DataType = PropertyDataType.Url,
}
});
var roleCreateProps = new List<PropertyMetadata>();
roleCreateProps.Add(PropertyMetadata.FromProperty<InMemoryRole>(x => x.Name));
var roleUpdateProps = new List<PropertyMetadata>();
roleUpdateProps.Add(PropertyMetadata.FromProperty<InMemoryRole>(x=>x.Description, type:"description"));
metadata = new IdentityManagerMetadata()
{
UserMetadata = new UserMetadata
{
SupportsCreate = true,
SupportsDelete = true,
SupportsClaims = true,
CreateProperties = createprops,
UpdateProperties = updateprops
},
RoleMetadata = new RoleMetadata
{
RoleClaimType = Constants.ClaimTypes.Role,
SupportsCreate = true,
SupportsDelete = true,
CreateProperties = roleCreateProps,
UpdateProperties = roleUpdateProps
}
};
}
return metadata;
}
async Task<IdentityManagerMetadata> GetMetadataAsync()
{
if (_metadata == null)
{
_metadata = await this.userManager.GetMetadataAsync();
if (_metadata == null) throw new InvalidOperationException("GetMetadataAsync returned null");
_metadata.Validate();
}
return _metadata;
}
public IdentityManagerMetadata GetMetadata()
{
if (metadata == null)
{
var createprops = new List <PropertyMetadata>()
{
PropertyMetadata.FromProperty <InMemoryUser>(x => x.Username, name: IdentityManagerConstants.ClaimTypes.Username, required: true),
};
var updateprops = new List <PropertyMetadata>();
updateprops.AddRange(new PropertyMetadata[] {
PropertyMetadata.FromProperty <InMemoryUser>(x => x.Username, name: IdentityManagerConstants.ClaimTypes.Username, required: true),
PropertyMetadata.FromPropertyName <InMemoryUser>("Password", name: IdentityManagerConstants.ClaimTypes.Password, required: true),
PropertyMetadata.FromFunctions <InMemoryUser, string>(IdentityManagerConstants.ClaimTypes.Name, u => GetName(u), SetName, displayName: "DisplayName", required: true),
});
updateprops.AddRange(PropertyMetadata.FromType <InMemoryUser>());
updateprops.AddRange(new PropertyMetadata[] {
PropertyMetadata.FromPropertyName <InMemoryUser>("Mobile"),
PropertyMetadata.FromPropertyName <InMemoryUser>("Email", dataType: PropertyDataType.Email),
new PropertyMetadata {
Name = "Is Administrator",
Type = "role.admin",
DataType = PropertyDataType.Boolean,
Required = true,
},
new PropertyMetadata {
Name = "Gravatar Url",
Type = "gravatar",
DataType = PropertyDataType.Url,
}
});
var roleCreateProps = new List <PropertyMetadata>
{
PropertyMetadata.FromProperty <InMemoryRole>(x => x.Name)
};
var roleUpdateProps = new List <PropertyMetadata>
{
PropertyMetadata.FromProperty <InMemoryRole>(x => x.Description, name: "description")
};
metadata = new IdentityManagerMetadata()
{
UserMetadata = new UserMetadata
{
SupportsCreate = true,
SupportsDelete = true,
SupportsClaims = true,
CreateProperties = createprops,
UpdateProperties = updateprops
},
RoleMetadata = new RoleMetadata
{
RoleClaimType = IdentityManagerConstants.ClaimTypes.Role,
SupportsCreate = true,
SupportsDelete = true,
CreateProperties = roleCreateProps,
UpdateProperties = roleUpdateProps
}
};
}
return(metadata);
}
public virtual Task <IdentityManagerMetadata> GetStandardMetadata(bool includeAccountProperties = true)
{
var update = new List <PropertyMetadata>();
if (UserManager.SupportsUserPassword)
{
update.Add(PropertyMetadata.FromFunctions <TUser, string>(Constants.ClaimTypes.Password, u => Task.FromResult <string>(null), SetPassword, "Password", PropertyDataType.Password, true));
}
if (UserManager.SupportsUserEmail)
{
update.Add(PropertyMetadata.FromFunctions <TUser, string>(Constants.ClaimTypes.Email, u => GetEmail(u), SetEmail, "Email", PropertyDataType.Email));
}
if (UserManager.SupportsUserPhoneNumber)
{
update.Add(PropertyMetadata.FromFunctions <TUser, string>(Constants.ClaimTypes.Phone, u => GetPhone(u), SetPhone, "Phone", PropertyDataType.String));
}
if (UserManager.SupportsUserTwoFactor)
{
update.Add(PropertyMetadata.FromFunctions <TUser, bool>("two_factor", u => GetTwoFactorEnabled(u), SetTwoFactorEnabled, "Two Factor Enabled", PropertyDataType.Boolean));
}
if (UserManager.SupportsUserLockout)
{
update.Add(PropertyMetadata.FromFunctions <TUser, bool>("locked_enabled", GetLockoutEnabled, (user1, enabled) => SetLockoutEnabled(user1, enabled), "Lockout Enabled", PropertyDataType.Boolean));
update.Add(PropertyMetadata.FromFunctions <TUser, bool>("locked", GetLockedOut, (user1, locked) => SetLockedOut(user1, locked), "Locked Out", PropertyDataType.Boolean));
}
if (includeAccountProperties)
{
update.AddRange(PropertyMetadata.FromType <TUser>());
}
var create = new List <PropertyMetadata>();
create.Add(PropertyMetadata.FromProperty <TUser>(x => x.UserName, name: Constants.ClaimTypes.Username, required: true));
create.Add(PropertyMetadata.FromFunctions <TUser, string>(Constants.ClaimTypes.Password, u => Task.FromResult <string>(null), SetPassword, "Password", PropertyDataType.Password, true));
var user = new UserMetadata
{
SupportsCreate = true,
SupportsDelete = true,
SupportsClaims = UserManager.SupportsUserClaim,
CreateProperties = create,
UpdateProperties = update
};
var role = new RoleMetadata
{
RoleClaimType = RoleClaimType,
SupportsCreate = true,
SupportsDelete = true,
CreateProperties = new[] {
PropertyMetadata.FromProperty <TRole>(x => x.Name, name: Constants.ClaimTypes.Name, required: true),
}
};
var meta = new IdentityManagerMetadata
{
UserMetadata = user,
RoleMetadata = role
};
return(Task.FromResult(meta));
}
internal void SetupGetMetadataAsync(IdentityManagerMetadata data)
{
Setup(x => x.GetMetadataAsync())
.Returns(Task.FromResult(data));
}
public virtual IdentityManagerMetadata GetStandardMetadata(bool includeAccountProperties = true)
{
var update = new List <PropertyMetadata>();
if (this.userManager.SupportsUserPassword)
{
update.Add(PropertyMetadata.FromFunctions <TUser, string>(Constants.ClaimTypes.Password, x => null, SetPassword, name: "Password", dataType: PropertyDataType.Password, required: true));
}
if (this.userManager.SupportsUserEmail)
{
update.Add(PropertyMetadata.FromFunctions <TUser, string>(Constants.ClaimTypes.Email, GetEmail, SetEmail, name: "Email", dataType: PropertyDataType.Email));
}
if (this.userManager.SupportsUserPhoneNumber)
{
update.Add(PropertyMetadata.FromFunctions <TUser, string>(Constants.ClaimTypes.Phone, GetPhone, SetPhone, name: "Phone", dataType: PropertyDataType.String));
}
if (this.userManager.SupportsUserTwoFactor)
{
update.Add(PropertyMetadata.FromFunctions <TUser, bool>("two_factor", GetTwoFactorEnabled, SetTwoFactorEnabled, name: "Two Factor Enabled", dataType: PropertyDataType.Boolean));
}
if (this.userManager.SupportsUserLockout)
{
update.Add(PropertyMetadata.FromFunctions <TUser, bool>("locked_enabled", GetLockoutEnabled, SetLockoutEnabled, name: "Lockout Enabled", dataType: PropertyDataType.Boolean));
update.Add(PropertyMetadata.FromFunctions <TUser, bool>("locked", GetLockedOut, SetLockedOut, name: "Locked Out", dataType: PropertyDataType.Boolean));
}
if (includeAccountProperties)
{
update.AddRange(PropertyMetadata.FromType(typeof(TUser)));
}
var create = new List <PropertyMetadata>();
create.Add(PropertyMetadata.FromProperty <TUser>(x => x.UserName, type: Constants.ClaimTypes.Username, required: true));
create.Add(PropertyMetadata.FromFunctions <TUser, string>(Constants.ClaimTypes.Password, x => null, SetPassword, name: "Password", dataType: PropertyDataType.Password, required: true));
var user = new UserMetadata
{
SupportsCreate = true,
SupportsDelete = true,
SupportsClaims = this.userManager.SupportsUserClaim,
CreateProperties = create,
UpdateProperties = update
};
var role = new RoleMetadata
{
RoleClaimType = this.RoleClaimType,
SupportsCreate = true,
SupportsDelete = true,
CreateProperties = new PropertyMetadata[] {
PropertyMetadata.FromProperty <TRole>(x => x.Name, type: Constants.ClaimTypes.Name, required: true),
}
};
var meta = new IdentityManagerMetadata
{
UserMetadata = user,
RoleMetadata = role
};
return(meta);
}
public UserDetailDataResource(UserDetail user, UrlHelper url, IdentityManagerMetadata meta, RoleSummary[] roles)
{
if (user == null)
{
throw new ArgumentNullException("user");
}
if (url == null)
{
throw new ArgumentNullException("url");
}
if (meta == null)
{
throw new ArgumentNullException("meta");
}
this["Username"] = user.Username;
this["Name"] = user.Name;
this["Subject"] = user.Subject;
if (user.Properties != null)
{
var props =
from p in user.Properties
let m = (from m in meta.UserMetadata.UpdateProperties where m.Type == p.Type select m).SingleOrDefault()
where m != null
select new
{
Data = m.Convert(p.Value),
Meta = m,
Links = new
{
update = url.Link(Constants.RouteNames.UpdateUserProperty,
new
{
subject = user.Subject,
type = p.Type.ToBase64UrlEncoded()
}
),
}
};
if (props.Any())
{
this["Properties"] = props.ToArray();
}
}
if (roles != null && user.Claims != null)
{
var roleClaims = user.Claims.Where(x => x.Type == meta.RoleMetadata.RoleClaimType);
var query =
from r in roles
orderby r.Name
select new
{
data = roleClaims.Any(x => x.Value == r.Name),
meta = new
{
type = r.Name,
description = r.Description,
},
links = new
{
add = url.Link(Constants.RouteNames.AddRole, new { subject = user.Subject, role = r.Name.ToBase64UrlEncoded() }),
remove = url.Link(Constants.RouteNames.RemoveRole, new { subject = user.Subject, role = r.Name.ToBase64UrlEncoded() })
}
};
this["Roles"] = query.ToArray();
}
if (meta.UserMetadata.SupportsClaims && user.Claims != null)
{
var claims =
from c in user.Claims.ToArray()
select new
{
Data = c,
Links = new
{
delete = url.Link(Constants.RouteNames.RemoveClaim, new
{
subject = user.Subject,
type = c.Type.ToBase64UrlEncoded(),
value = c.Value.ToBase64UrlEncoded()
})
}
};
this["Claims"] = new
{
Data = claims.ToArray(),
Links = new
{
create = url.Link(Constants.RouteNames.AddClaim, new { subject = user.Subject })
}
};
}
}
public AspNetCoreIdentityManagerService(UserManager <TUser> userManager, RoleManager <TRole> roleManager, IdentityManagerMetadata metadata)
: this(userManager, roleManager, () => Task.FromResult(metadata))
{
}
public virtual IdentityManagerMetadata GetStandardMetadata(bool includeAccountProperties = true)
{
var update = new List <PropertyMetadata>();
if (userAccountService.Configuration.EmailIsUsername)
{
update.AddRange(new PropertyMetadata[] {
PropertyMetadata.FromFunctions <TAccount, string>(Constants.ClaimTypes.Username, GetUsername, SetUsername, name: "Email", dataType: PropertyDataType.Email, required: true),
PropertyMetadata.FromFunctions <TAccount, string>(Constants.ClaimTypes.Password, x => null, SetPassword, name: "Password", dataType: PropertyDataType.Password, required: true),
});
}
else
{
update.AddRange(new PropertyMetadata[] {
PropertyMetadata.FromFunctions <TAccount, string>(Constants.ClaimTypes.Username, GetUsername, SetUsername, name: "Username", dataType: PropertyDataType.String, required: true),
PropertyMetadata.FromFunctions <TAccount, string>(Constants.ClaimTypes.Password, x => null, SetPassword, name: "Password", dataType: PropertyDataType.Password, required: true),
PropertyMetadata.FromFunctions <TAccount, string>(Constants.ClaimTypes.Email, GetEmail, SetConfirmedEmail, name: "Email", dataType: PropertyDataType.Email, required: userAccountService.Configuration.RequireAccountVerification),
});
}
var create = new List <PropertyMetadata>();
if (!userAccountService.Configuration.EmailIsUsername && !userAccountService.Configuration.RequireAccountVerification)
{
create.AddRange(update.Where(x => x.Required).ToArray());
create.AddRange(new PropertyMetadata[] {
PropertyMetadata.FromFunctions <TAccount, string>(Constants.ClaimTypes.Email, GetEmail, SetConfirmedEmail, name: "Email", dataType: PropertyDataType.Email, required: false),
});
}
update.AddRange(new PropertyMetadata[] {
PropertyMetadata.FromFunctions <TAccount, string>(Constants.ClaimTypes.Phone, GetPhone, SetConfirmedPhone, name: "Phone", dataType: PropertyDataType.String, required: false),
PropertyMetadata.FromFunctions <TAccount, bool>("IsLoginAllowed", GetIsLoginAllowed, SetIsLoginAllowed, name: "Is Login Allowed", dataType: PropertyDataType.Boolean, required: false),
});
if (includeAccountProperties)
{
update.AddRange(PropertyMetadata.FromType <TAccount>());
}
var user = new UserMetadata
{
SupportsCreate = true,
SupportsDelete = true,
SupportsClaims = true,
CreateProperties = create,
UpdateProperties = update
};
var meta = new IdentityManagerMetadata {
UserMetadata = user
};
if (this.groupService != null && this.groupQuery != null)
{
meta.RoleMetadata.SupportsCreate = true;
meta.RoleMetadata.SupportsDelete = true;
meta.RoleMetadata.RoleClaimType = Constants.ClaimTypes.Role;
meta.RoleMetadata.CreateProperties = new PropertyMetadata[] {
new PropertyMetadata {
Name = "Name",
Type = Constants.ClaimTypes.Name,
DataType = PropertyDataType.String,
Required = true
}
};
}
return(meta);
}
public virtual IdentityManagerMetadata GetStandardMetadata(bool includeAccountProperties = true)
{
var update = new List <PropertyMetadata>();
if (this.userManager.SupportsUserPassword)
{
update.Add(PropertyMetadata.FromFunctions <TUser, string>(Constants.ClaimTypes.Password, x => null, this.SetPassword, "Password", PropertyDataType.Password, true));
}
if (this.userManager.SupportsUserEmail)
{
update.Add(PropertyMetadata.FromFunctions <TUser, string>(Constants.ClaimTypes.Email, this.GetEmail, this.SetEmail, "Email", PropertyDataType.Email));
}
if (this.userManager.SupportsUserPhoneNumber)
{
update.Add(PropertyMetadata.FromFunctions <TUser, string>(Constants.ClaimTypes.Phone, this.GetPhone, this.SetPhone, "Phone", PropertyDataType.String));
}
if (this.userManager.SupportsUserTwoFactor)
{
update.Add(PropertyMetadata.FromFunctions <TUser, bool>("two_factor", this.GetTwoFactorEnabled, this.SetTwoFactorEnabled, "Two Factor Enabled", PropertyDataType.Boolean));
}
if (this.userManager.SupportsUserLockout)
{
update.Add(PropertyMetadata.FromFunctions <TUser, bool>("locked_enabled", this.GetLockoutEnabled, this.SetLockoutEnabled, "Lockout Enabled", PropertyDataType.Boolean));
update.Add(PropertyMetadata.FromFunctions <TUser, bool>("locked", this.GetLockedOut, this.SetLockedOut, "Locked Out", PropertyDataType.Boolean));
}
update.Add(PropertyMetadata.FromFunctions <TUser, bool>(Constants.ClaimTypes.EmailConfirmed, this.GetIsEmailConfirmed, this.SetEmailConfirmed, "Email Confirmed", PropertyDataType.Boolean));
if (includeAccountProperties)
{
update.AddRange(PropertyMetadata.FromType <TUser>());
}
var create = new List <PropertyMetadata>
{
new PropertyMetadata()
{
Name = "Name", Type = Constants.ClaimTypes.Name, DataType = PropertyDataType.String, Required = true
},
PropertyMetadata.FromProperty <TUser>(x => x.Email, Constants.ClaimTypes.Email, required: true),
PropertyMetadata.FromFunctions <TUser, string>(Constants.ClaimTypes.Password, x => null, this.SetPassword, "Password", PropertyDataType.Password, true),
PropertyMetadata.FromFunctions <TUser, bool>(Constants.ClaimTypes.EmailConfirmed, x => false, this.SetEmailConfirmed, "Email Confirmed", PropertyDataType.Boolean)
};
var user = new UserMetadata
{
SupportsCreate = true,
SupportsDelete = true,
SupportsClaims = this.userManager.SupportsUserClaim,
CreateProperties = create,
UpdateProperties = update
};
var role = new RoleMetadata
{
RoleClaimType = this.RoleClaimType,
SupportsCreate = true,
SupportsDelete = true,
CreateProperties = new[]
{
PropertyMetadata.FromProperty <TRole>(x => x.Name, Constants.ClaimTypes.Name, required: true)
}
};
var meta = new IdentityManagerMetadata
{
UserMetadata = user,
RoleMetadata = role
};
return(meta);
}
