private ConsentModel CreateConsentViewModel(ConsentInputModel inputModel, string returnUrl, Client client, Resources resources)
{
var model = new ConsentModel
{
RememberConsent = inputModel?.RememberConsent ?? true,
ScopesConsented = inputModel?.ScopesConsented ?? Enumerable.Empty <string>(),
ReturnUrl = returnUrl,
ClientName = client.ClientName ?? client.ClientId,
ClientUrl = client.ClientUri,
ClientLogoUrl = client.LogoUri,
AllowRememberConsent = client.AllowRememberConsent
};
model.IdentityScopes = resources.IdentityResources
.Select(x => this.CreateScopeViewModel(x, model.ScopesConsented.Contains(x.Name) || inputModel == null))
.ToArray();
model.ResourceScopes = resources.ApiResources.SelectMany(x => x.Scopes)
.Select(x => this.CreateScopeViewModel(x, model.ScopesConsented.Contains(x.Name) || inputModel == null))
.ToArray();
if (ConsentOptions.EnableOfflineAccess && resources.OfflineAccess)
{
model.ResourceScopes = model.ResourceScopes
.Union(
new[]
{
this.GetOfflineAccessScope(model.ScopesConsented.Contains(IdentityServerConstants.StandardScopes.OfflineAccess) || inputModel == null)
});
}
return(model);
}
/// <summary>
/// 生成授权模型
/// </summary>
/// <param name="returnUrl"></param>
/// <param name="request"></param>
/// <param name="client"></param>
/// <param name="resources"></param>
/// <returns></returns>
private ConsentModel CreateConsentModel(
string returnUrl,
AuthorizationRequest request,
Client client,
Resources resources)
{
var vm = new ConsentModel();
//vm.RememberConsent = model?.RememberConsent ?? true;
//vm.ScopesConsented = model?.ScopesConsented ?? Enumerable.Empty<string>();
//vm.ReturnUrl = returnUrl;
vm.ClientName = client.ClientName ?? client.ClientId;
vm.ClientUrl = client.ClientUri;
vm.ClientLogoUrl = client.LogoUri;
vm.AllowRememberConsent = client.AllowRememberConsent;
vm.IdentityScopes = resources.IdentityResources.Select(x => CreateScopeViewModel(x)).ToArray();
vm.ResourceScopes = resources.ApiResources.SelectMany(x => x.Scopes).Select(x => CreateScopeViewModel(x)).ToArray();
// 离线共享域
if (ConsentOptions.EnableOfflineAccess && resources.OfflineAccess)
{
vm.ResourceScopes = vm.ResourceScopes.Union(new ScopeResourceModel[] {
GetOfflineAccessScope()
});
}
return(vm);
}
public IActionResult SaveConsent(ConsentModel consentModel)
{
var consent = consentModel.Id > 0 ? _consentService.Get(consentModel.Id) : new Consent();
if (consent == null)
{
return(NotFound());
}
consent.Title = consentModel.Title;
consent.Description = consentModel.Description;
consent.DisplayOrder = consentModel.DisplayOrder;
consent.EnableLogging = consentModel.EnableLogging;
consent.Published = consentModel.Published;
consent.IsRequired = consentModel.IsRequired;
consent.OneTimeSelection = consentModel.OneTimeSelection;
consent.ConsentGroupId = consentModel.ConsentGroup?.Id ?? 0;
if (consent.ConsentGroupId < 0)
{
consent.ConsentGroupId = 0;
}
_consentService.InsertOrUpdate(consent);
return(R.Success.Result);
}
private ConsentModel CreateConsent(ResourceModel model, string returnUrl, AuthorizationRequest request, Client client, Resources resources)
{
ConsentModel consent = new ConsentModel
{
ScopesConsented = model?.ScopesConsented ?? Enumerable.Empty <string>(),
ReturnUrl = returnUrl,
ClientName = client.ClientName ?? client.ClientId,
ClientUrl = client.ClientUri,
ClientLogoUrl = client.LogoUri
};
consent.IdentityScopes = resources.IdentityResources.Select(x => CreateScope(x, consent.ScopesConsented.Contains(x.Name) || model == null)).ToArray();
consent.ResourceScopes = resources.ApiResources.SelectMany(x => x.Scopes).Select(x => CreateScope(x, consent.ScopesConsented.Contains(x.Name) || model == null)).ToArray();
if (resources.OfflineAccess)
{
consent.ResourceScopes = consent.ResourceScopes.Union(new ScopeModel[] {
new ScopeModel
{
Name = IdentityServer4.IdentityServerConstants.StandardScopes.OfflineAccess,
DisplayName = Config.OfflineAccessDisplayName,
Description = Config.OfflineAccessDescription,
Emphasize = true,
Checked = (consent.ScopesConsented.Contains(IdentityServer4.IdentityServerConstants.StandardScopes.OfflineAccess) || model == null)
}
});
}
return(consent);
}
/// <summary> Creates consent model. </summary>
/// <param name="model"> The model. </param>
/// <param name="returnUrl"> URL of the return. </param>
/// <param name="client"> The client. </param>
/// <param name="resources"> The resources. </param>
/// <returns> The new consent view model. </returns>
private ConsentModel CreateConsentModel(
ConsentInputModel model, string returnUrl,
Client client, IdentityServer4.Models.Resources resources)
{
var vm = new ConsentModel
{
RememberConsent = model?.RememberConsent ?? true,
ScopesConsented = model?.ScopesConsented ?? Enumerable.Empty <string>(),
ReturnUrl = returnUrl,
ClientName = client.ClientName,
ClientUrl = client.ClientUri,
ClientLogoUrl = client.LogoUri,
AllowRememberConsent = client.AllowRememberConsent
};
vm.IdentityScopes = resources.IdentityResources
.Select(x => CreateScopeModel(x, vm.ScopesConsented.Contains(x.Name) || model == null))
.ToArray();
vm.ResourceScopes = resources.ApiResources.SelectMany(x => x.Scopes)
.Select(x => CreateScopeModel(x, vm.ScopesConsented.Contains(x.Name) || model == null))
.ToArray();
if (ConsentOptions.EnableOfflineAccess && resources.OfflineAccess)
{
vm.ResourceScopes = vm.ResourceScopes.Union(new[]
{
GetOfflineAccessScope(vm.ScopesConsented.Contains(IdentityServerConstants.StandardScopes.OfflineAccess) ||
model == null)
});
}
return(vm);
}
public async Task <IActionResult> GetIndex(string returnUrl)
{
ConsentModel consents = await CreateConsentsAsync(returnUrl);
if (consents != null)
{
return(View("Index", consents));
}
return(View("Error"));
}
public ConsentModel Create(Consent entity)
{
var consentModel = new ConsentModel()
{
Title = entity.Title,
Description = entity.Description,
IsRequired = entity.IsRequired,
OneTimeSelection = entity.OneTimeSelection,
Id = entity.Id
};
return(consentModel);
}
public async Task AddConsentSignature_Failure()
{
var addModel = new ConsentModel()
{
SignatureBlob = _convertedImage, ContactId = -1, IsActive = true, ModifiedBy = 3, ForceRollback = true
};
var response =
await httpClient.PostAsync <ConsentModel>("/api/Consent/AddConsentSignature", addModel, new JsonMediaTypeFormatter());
var result = response.Content.ReadAsStringAsync().Result;
var model = Json.Decode <Response <ConsentModel> >(result);
Assert.IsTrue(model.ResultCode != 0, "Consent signature saved, but it should have failed.");
}
public async Task AddConsentSignature_Success()
{
var addModel = new ConsentModel()
{
SignatureBlob = Convert.FromBase64String(_sigImage), ContactId = _defaultContactId, IsActive = true, ModifiedBy = 3, ForceRollback = true
};
var response =
await _httpClient.PostAsync <ConsentModel>("/api/Consent/AddConsentSignature", addModel, new JsonMediaTypeFormatter());
var result = response.Content.ReadAsStringAsync().Result;
var responseModel = Json.Decode <Response <ConsentModel> >(result);
Assert.IsTrue(responseModel.RowAffected > 0, "Consent signature could not be saved.");
}
// GET
public async Task <IActionResult> Index(string returnUrl)
{
var request = await interactionService.GetAuthorizationContextAsync(returnUrl);
if (request != null)
{
var client = await clientStore.FindEnabledClientByIdAsync(request.ClientId);
if (client != null)
{
var resources = await resourceStore.FindResourcesByScopeAsync(request.ScopesRequested);
var model = new ConsentModel {
ClientId = request.ClientId,
ClientName = client.ClientName,
ClientLogoUrl = client.LogoUri,
AllowRememberConsent = client.AllowRememberConsent,
ReturnUrl = returnUrl,
ClientUrl = client.ClientUri
};
model.IdentityScopes = resources.IdentityResources.Select(r => new ScopeModel {
Name = r.Name,
DisplayName = r.DisplayName,
Checked = r.Required,
Description = r.Description,
Emphasize = r.Emphasize,
Required = r.Required
}).ToArray();
model.ResourceScopes = resources.ApiResources.SelectMany(r => r.Scopes).Select(r => new ScopeModel {
Name = r.Name,
DisplayName = r.DisplayName,
Checked = r.Required,
Description = r.Description,
Emphasize = r.Emphasize,
Required = r.Required
}).ToArray();
return(View(model));
}
return(View(null));
}
return(View(null));
}
public Response <ConsentModel> AddConsentSignature(ConsentModel consent)
{
var consentRepository = unitOfWork.GetRepository <ConsentModel>(SchemaName.ESignature);
SqlParameter contactIdParam = new SqlParameter("ContactID", consent.ContactId);
SqlParameter signatureBlobParam = new SqlParameter("SignatureBlob", consent.SignatureBlob);
signatureBlobParam.DbType = DbType.Binary;
SqlParameter isActiveParam = new SqlParameter("IsActive", consent.IsActive);
SqlParameter modifiedOnParam = new SqlParameter("ModifiedOn", consent.ModifiedOn ?? DateTime.Now);
List <SqlParameter> procParams = new List <SqlParameter>()
{
contactIdParam, signatureBlobParam, isActiveParam, modifiedOnParam
};
return(unitOfWork.EnsureInTransaction <Response <ConsentModel> >(consentRepository.ExecuteNQStoredProc, "usp_AddContactSignatures", procParams, forceRollback: consent.ForceRollback.GetValueOrDefault(false)));
}
private IHttpActionResult CreateConsentResult(
ValidatedAuthorizeRequest validatedRequest,
NameValueCollection requestParameters,
string errorMessage)
{
var consentModel = new ConsentModel(validatedRequest, requestParameters);
string name = User.GetName();
return(new EmbeddedHtmlResult(
Request,
new LayoutModel
{
Server = _settings.SiteName,
ErrorMessage = errorMessage,
Page = "consent",
Username = name,
SwitchUrl = Url.Route("switch", null) + "?" + requestParameters.ToQueryString(),
PageModel = consentModel
}));
}
public static ConsentViewModel ToViewModel(this ConsentModel entity)
{
if (entity == null)
{
return(null);
}
var model = new ConsentViewModel
{
SignatureId = entity.SignatureId,
SignatureBlob = entity.SignatureBlob == null ? string.Empty : Convert.ToBase64String(entity.SignatureBlob),
ContactId = entity.ContactId,
AuthorizedBy = entity.AuthorizedBy,
ContactName = entity.ContactName,
ContactDateofBirth = entity.ContactDateofBirth,
IsActive = entity.IsActive,
ModifiedOn = entity.ModifiedOn,
ModifiedBy = entity.ModifiedBy
};
return(model);
}
public static ConsentModel ToModel(this ConsentViewModel model)
{
if (model == null)
{
return(null);
}
var entity = new ConsentModel
{
SignatureId = model.SignatureId,
SignatureBlob = Convert.FromBase64String(model.SignatureBlob),
ContactId = model.ContactId,
AuthorizedBy = model.AuthorizedBy,
ContactName = model.ContactName,
ContactDateofBirth = model.ContactDateofBirth,
IsActive = model.IsActive,
ModifiedOn = model.ModifiedOn,
ModifiedBy = model.ModifiedBy,
ForceRollback = model.ForceRollback
};
return(entity);
}
public IHttpActionResult AddConsentSignature(ConsentModel consent)
{
return(new HttpResult <Response <ConsentModel> >(consentDataProvider.AddConsentSignature(consent), Request));
}
public IHttpActionResult AddConsentSignature(ConsentModel consent)
{
return(new HttpResult <Response <ConsentModel> >(consentRuleEngine.AddConsentSignature(consent), Request));
}
public void PassCodeConsented(ConsentModel input)
{
//do some Passcode consented magic
//throw new NotImplementedException();
}
public Response <ConsentModel> AddConsentSignature(ConsentModel consent)
{
return(consentService.AddConsentSignature(consent));
}
/// <summary>
/// Checks consent for a particular feature
/// </summary>
/// <param name="feature"></param>
/// <returns></returns>
public bool CheckConsent(string feature)
{
return(ConsentModel.CheckConsent(feature));
}
public Response <ConsentModel> AddConsentSignature(ConsentModel consent)
{
var apiUrl = baseRoute + "AddConsentSignature";
return(_communicationManager.Post <ConsentModel, Response <ConsentModel> >(consent, apiUrl));
}
/// <summary>
/// Updates a feature to give/deny consent
/// </summary>
/// <param name="feature"></param>
/// <param name="permission"></param>
public void UpdateConsent(string feature, bool permission)
{
ConsentModel.UpdateConsent(feature, permission);
}
public async Task <IActionResult> Index(ConsentModel model)
{
//获取授权上下文，验证返回 URL 是否有效
var request = await _interaction.GetAuthorizationContextAsync(model.ReturnUrl);
if (request == null)
{
model.Error = "请求授权上下文失效";
return(RedirectToAction("error"));
}
//同意-响应
ConsentResponse grantedConsent = null;
// 是否同意授权
if (!model.ConsentBtn)
{
//拒绝
grantedConsent = ConsentResponse.Denied;
// 触发拒绝事件
await _events.RaiseAsync(new ConsentDeniedEvent(User.GetSubjectId(), request.ClientId, request.ScopesRequested));
//return Redirect(model.ReturnUrl);
}
else
{
grantedConsent = new ConsentResponse
{
RememberConsent = model.RememberConsent
};
if (model.apis.Any())
{
grantedConsent.ScopesConsented = model.identitys.Concat(model.apis);
}
else
{
grantedConsent.ScopesConsented = model.identitys;
}
//grantedConsent.ScopesConsented = grantedConsent.ScopesConsented.Where(l => l != IdentityServer4.IdentityServerConstants.StandardScopes.OfflineAccess);
var subjectId = User.GetSubjectId();
// 触发授权事件
await _events.RaiseAsync(new ConsentGrantedEvent(subjectId, request.ClientId, request.ScopesRequested, grantedConsent.ScopesConsented, grantedConsent.RememberConsent));
}
// 将授权的结果传达回IdentityServer
await _interaction.GrantConsentAsync(request, grantedConsent);
if (!string.IsNullOrWhiteSpace(request.ClientId))
{
var client = await _clientStore.FindEnabledClientByIdAsync(request.ClientId);
//指定基于授权码的令牌请求是否需要证明密钥（默认为false）。
if (client?.RequirePkce == true)
{
model.Error = "请求授权上下文失效";
return(RedirectToAction("error"));
}
}
return(Redirect(model.ReturnUrl));
}
