//public int GetSiteIdByFolderNonAsync(string folderName)
//{
// return siteRepo.GetSiteIdByFolderNonAsync(folderName);
//}
public async Task <ISiteSettings> Fetch(Guid siteGuid)
{
ISiteSettings site = await siteRepo.Fetch(siteGuid, CancellationToken);
dataProtector.UnProtect(site);
return(site);
}
private async Task <ISiteSettings> GetSite()
{
if (multiTenantOptions.UseRelatedSitesMode)
{
if (multiTenantOptions.Mode == MultiTenantMode.FolderName)
{
CancellationToken cancellationToken
= contextAccessor.HttpContext?.RequestAborted ?? CancellationToken.None;
site = await siteRepo.Fetch(multiTenantOptions.RelatedSiteId, cancellationToken);
return(site);
}
}
TenantContext <SiteSettings> tenantContext
= await siteResolver.ResolveAsync(contextAccessor.HttpContext);
if (tenantContext != null && tenantContext.Tenant != null)
{
site = tenantContext.Tenant;
}
return(site);
}
private async Task <TenantContext <SiteSettings> > ResolveByHostAsync(HttpContext context)
{
TenantContext <SiteSettings> tenantContext = null;
CancellationToken cancellationToken = context?.RequestAborted ?? CancellationToken.None;
ISiteSettings site
= await siteRepo.Fetch(context.Request.Host.Value, cancellationToken);
if (site != null)
{
dataProtector.UnProtect(site);
tenantContext = new TenantContext <SiteSettings>((SiteSettings)site);
}
return(tenantContext);
}
public override async Task <ClaimsPrincipal> CreateAsync(TUser user)
{
// this one was using IdentityOptions.ApplicationCookieAuthenticationScheme
//ClaimsPrincipal principal = await base.CreateAsync(user);
if (user == null)
{
throw new ArgumentNullException("user");
}
var userId = await UserManager.GetUserIdAsync(user);
var userName = await UserManager.GetUserNameAsync(user);
var id = new ClaimsIdentity(
tenantResolver.ResolveAuthScheme(AuthenticationScheme.Application),
Options.ClaimsIdentity.UserNameClaimType,
Options.ClaimsIdentity.RoleClaimType
);
id.AddClaim(new Claim(Options.ClaimsIdentity.UserIdClaimType, userId));
id.AddClaim(new Claim(Options.ClaimsIdentity.UserNameClaimType, userName));
if (UserManager.SupportsUserSecurityStamp)
{
id.AddClaim(new Claim(Options.ClaimsIdentity.SecurityStampClaimType,
await UserManager.GetSecurityStampAsync(user)));
}
if (UserManager.SupportsUserRole)
{
var roles = await UserManager.GetRolesAsync(user);
foreach (var roleName in roles)
{
id.AddClaim(new Claim(Options.ClaimsIdentity.RoleClaimType, roleName));
if (RoleManager.SupportsRoleClaims)
{
var role = await RoleManager.FindByNameAsync(roleName);
if (role != null)
{
id.AddClaims(await RoleManager.GetClaimsAsync(role));
}
}
}
}
if (UserManager.SupportsUserClaim)
{
id.AddClaims(await UserManager.GetClaimsAsync(user));
}
ClaimsPrincipal principal = new ClaimsPrincipal(id);
if (principal.Identity is ClaimsIdentity)
{
ClaimsIdentity identity = (ClaimsIdentity)principal.Identity;
Claim displayNameClaim = new Claim("DisplayName", user.DisplayName);
if (!identity.HasClaim(displayNameClaim.Type, displayNameClaim.Value))
{
identity.AddClaim(displayNameClaim);
}
// this seems pointless to pass in CancellationToken.None
//ISiteSettings site = await siteRepo.Fetch(user.SiteId, CancellationToken.None);
ISiteSettings site = await siteRepo.Fetch(user.SiteId, CancellationToken.None);
if (site != null)
{
Claim siteGuidClaim = new Claim("SiteGuid", site.SiteGuid.ToString());
if (!identity.HasClaim(siteGuidClaim.Type, siteGuidClaim.Value))
{
identity.AddClaim(siteGuidClaim);
}
}
if (principal.IsInRole("Admins"))
{
if (site != null && site.IsServerAdminSite)
{
// if the user is an admin of a server admin site
// add ServerAdmins role
Claim serverAdminRoleClaim = new Claim(ClaimTypes.Role, "ServerAdmins");
identity.AddClaim(serverAdminRoleClaim);
}
}
}
return(principal);
}
public async Task <ISiteSettings> Fetch(Guid siteGuid)
{
return(await siteRepo.Fetch(siteGuid, CancellationToken));
}
public async Task <ISiteSettings> Fetch(Guid siteGuid)
{
return(await siteRepo.Fetch(siteGuid));
}
