示例#1
0
        public async Task <IActionResult> Index(InputConsentViewModel viewmodel)
        {
            // viewmodel.ReturlUrl
            ConsentResponse consentResponse = null;

            if (viewmodel.Button == "no")
            {
                consentResponse = ConsentResponse.Denied;
            }
            else
            {
                if (viewmodel.ScopesConsented != null && viewmodel.ScopesConsented.Any())
                {
                    consentResponse = new ConsentResponse
                    {
                        RememberConsent = viewmodel.RemeberConsent,
                        ScopesConsented = viewmodel.ScopesConsented
                    };
                }
            }
            if (consentResponse != null)
            {
                var request = await _identityServerInteractionService.GetAuthorizationContextAsync(viewmodel.ReturnUrl);

                await _identityServerInteractionService.GrantConsentAsync(request, consentResponse);

                return(Redirect(viewmodel.ReturnUrl));
            }
            return(View(await BuildConsentViewModel(viewmodel.ReturnUrl)));
        }
示例#2
0
        public async Task <ProcessConsentResult> PorcessConsentAsync(InputConsentViewModel viewModel)
        {
            ConsentResponse consentResponse = null;
            var             result          = new ProcessConsentResult();

            if (viewModel.Button == "no")
            {
                consentResponse = ConsentResponse.Denied;
            }
            else if (viewModel.Button == "yes")
            {
                if (viewModel.ScopecConsented != null && viewModel.ScopecConsented.Any())
                {
                    consentResponse = new ConsentResponse
                    {
                        RememberConsent = viewModel.RemeberConsent,
                        ScopesConsented = viewModel.ScopecConsented
                    };
                }
                result.ValidationError = "请至少选中一个权限";
            }
            if (consentResponse != null)
            {
                var request = await _identityServerInteractionService.GetAuthorizationContextAsync(viewModel.ReturnUrl);

                await _identityServerInteractionService.GrantConsentAsync(request, consentResponse);

                result.RedirectUrl = viewModel.ReturnUrl;
            }
            var consentViewModel = await BuildConsentViewModelAsync(viewModel.ReturnUrl, viewModel);

            result.viewModel = consentViewModel;
            return(result);
        }
示例#3
0
        public async Task <IActionResult> Index([FromForm] InputConsentViewModel inputModel)
        {
            ConsentResponse consentResponse = null;

            if (inputModel.Button == "no")
            {
                consentResponse = ConsentResponse.Denied;
            }
            else if (inputModel.Button == "yes")
            {
                if (inputModel.ScopesConsented?.Any() ?? false)
                {
                    consentResponse = new ConsentResponse
                    {
                        ScopesConsented = inputModel.ScopesConsented,
                        RememberConsent = inputModel.RememberConsent
                    };
                }
            }

            if (consentResponse != null)
            {
                var request = await _identityServerInteractionService.GetAuthorizationContextAsync(inputModel.ReturnUrl);

                await _identityServerInteractionService.GrantConsentAsync(request, consentResponse);

                return(Redirect(inputModel.ReturnUrl));
            }
            throw new Exception("error");
        }
示例#4
0
        public async Task <IActionResult> Index(InputConsentViewModel viewModel)
        {
            ConsentResponse consentResponse = null;

            if (viewModel.Button == "no")
            {
                consentResponse = ConsentResponse.Denied;
            }
            else if (viewModel.Button == "yes")
            {
                if (viewModel.ScopesConsented != null && viewModel.ScopesConsented.Any())
                {
                    consentResponse = new ConsentResponse
                    {
                        ScopesConsented = viewModel.ScopesConsented,
                        RememberConsent = viewModel.RememberConsent
                    };
                }
            }
            if (consentResponse != null)
            {
                await consentService.SaveConsentViewModel(consentResponse, viewModel.ReturnUrl);

                return(Redirect(viewModel.ReturnUrl));
            }
            if (consentResponse == null)
            {
                ModelState.AddModelError("", "请至少选中一个权限");
            }
            return(View());
        }
        public async Task <IActionResult> Index(InputConsentViewModel viewModel)
        {
            viewModel.Button = "yes";
            ConsentResponse response = null;

            if (viewModel.Button == "no")
            {
                response = ConsentResponse.Denied;
            }
            else if (viewModel.Button == "yes")
            {
                if (viewModel.ScopedConsent != null && viewModel.ScopedConsent.Any())
                {
                    response = new ConsentResponse()
                    {
                        RememberConsent = viewModel.RememberConsent,
                        ScopesConsented = viewModel.ScopedConsent
                    };
                }
            }
            if (response != null)
            {
                var res = await _identityServerInteractionService.GetAuthorizationContextAsync(viewModel.ReturnUrl);

                await _identityServerInteractionService.GrantConsentAsync(res, response);

                Redirect(viewModel.ReturnUrl);
            }
            return(View());
        }
        public async Task <IActionResult> Index(string returnUrl, InputConsentViewModel viewModel = null)
        {
            var model = await _consentService.BuildConsentViewModel(returnUrl, viewModel);

            if (model == null)
            {
            }

            return(View(model));
        }
        public async Task <IActionResult> Index(InputConsentViewModel viewModel)
        {
            var result = await _consentService.ProcessConsent(viewModel);

            if (result.IsCallBack)
            {
                return(Redirect(result.ReditectUrl));
            }

            return(View(viewModel));
        }
示例#8
0
        /// <summary>
        /// BuildConsentViewModel
        /// </summary>
        /// <param name="ReturnUrl"></param>
        /// <param name="model">二次选中的时候发生作用</param>
        /// <returns></returns>
        public async Task <ConsentViewModel> BuildConsentViewModel(string ReturnUrl, InputConsentViewModel model = null)
        {
            var request = await _identityServerInteractionService.GetAuthorizationContextAsync(ReturnUrl);

            if (request == null)
            {
                return(null);
            }
            var vm = CreateConsentViewModel(request, model);

            vm.ReturnUrl = ReturnUrl;
            return(vm);
        }
示例#9
0
        public async Task <IActionResult> Index(InputConsentViewModel viewModel)
        {
            var result = await _consentService.ProcessConsent(viewModel);

            if (result.IsRedirect)
            {
                return(Redirect(result.RedirectUrl));
            }
            if (!string.IsNullOrEmpty(result.ValidationError))
            {
                ModelState.AddModelError("", result.ValidationError);
            }
            return(View(result.ViewModel));
        }
示例#10
0
        public async Task <IActionResult> Index(InputConsentViewModel inputConsent)
        {
            var result = await _consentService.ProcessConsentAsync(inputConsent);

            if (result.IsRedirect)
            {
                return(Redirect(result.RedirectUrl));
            }

            // 如果不跳转,则继续返回Index视图
            if (!string.IsNullOrEmpty(result.ValidationError))
            {
                ModelState.AddModelError("", result.ValidationError); // key没有传值
            }
            return(View(result.consentViewModel));                    // 填充Index视图,需要ConsentViewModel的对象
        }
        public async Task <IActionResult> Index(InputConsentViewModel inputConsentViewModel)
        {
            var processConsentResult = await _consentService.ProceedConsent(inputConsentViewModel);

            if (processConsentResult.IsReturnUrl)
            {
                return(Redirect(processConsentResult.ReturnUrl));
            }

            if (!string.IsNullOrEmpty(processConsentResult.ValidateErrorMessage))
            {
                ModelState.AddModelError("", processConsentResult.ValidateErrorMessage);
            }


            return(View(processConsentResult.consentViewModel));
        }
示例#12
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="returnUrl"></param>
        /// <param name="model">二次选中的时候发生作用</param>
        /// <returns></returns>
        public async Task <ConsentViewModel> BuildConsentViewModel(string returnUrl, InputConsentViewModel model = null)
        {
            var request = await _identityServerInteractionService.GetAuthorizationContextAsync(returnUrl);

            if (request == null)
            {
                return(null);
            }
            var client = await _clientStore.FindEnabledClientByIdAsync(request.ClientId);

            var resources = await _resourceStore.FindEnabledResourcesByScopeAsync(request.ScopesRequested);

            var vm = CreateConsentViewModel(request, client, resources, model);

            vm.ReturnUrl = returnUrl;
            return(vm);
        }
示例#13
0
        public async Task <ProcessConsentResult> ProcessConsent(InputConsentViewModel viewModel)
        {
            ConsentResponse consentResponse = null;
            var             result          = new ProcessConsentResult();

            switch (viewModel.Button)
            {
            case "no":
                consentResponse = ConsentResponse.Denied;
                break;

            case "yes":
                if (viewModel.ScopesConsented != null && viewModel.ScopesConsented.Any())
                {
                    consentResponse = new ConsentResponse()
                    {
                        ScopesConsented = viewModel.ScopesConsented,
                        RememberConsent = viewModel.RememberConsent
                    };
                }
                else
                {
                    result.ValidationError = "请至少选择一个信息!";
                }
                break;
            }

            if (consentResponse != null)
            {
                var request = await _identityServer.GetAuthorizationContextAsync(viewModel.ReturnUrl);

                await _identityServer.GrantConsentAsync(request, consentResponse);

                result.RedirectUrl = viewModel.ReturnUrl;
            }
            else
            {
                var consentViewModel = await BuildConsentViewModelAsync(viewModel.ReturnUrl, viewModel);

                result.ViewModel = consentViewModel;
            }


            return(result);
        }
示例#14
0
        private ConsentViewModel CreateConsentViewModel(AuthorizationRequest request, Client client,
                                                        Resources resources, InputConsentViewModel model)
        {
            var rememberConsent = model?.RememberConsent ?? true;
            var selectedScopes  = model?.ScopesConsented ?? Enumerable.Empty <string>();

            var vm = new ConsentViewModel();

            vm.ClientName      = client.ClientName;
            vm.ClientLogoUrl   = client.LogoUri;
            vm.ClientUrl       = client.ClientUri;
            vm.RememberConsent = rememberConsent;

            vm.IdentityScopes = resources.IdentityResources.Select(i => CreateScopeViewModel(i, selectedScopes.Contains(i.Name) || model == null));
            vm.ResourceScopes = resources.ApiResources.SelectMany(i => i.Scopes).Select(i => CreateScopeViewModel(i, selectedScopes.Contains(i.Name) || model == null));

            return(vm);
        }
示例#15
0
        public async Task <ProcessConsentResult> ProcessConsentAsync(InputConsentViewModel inputConsent)
        {
            ProcessConsentResult result = new ProcessConsentResult();

            ConsentResponse consentResponse = null;

            if (inputConsent.Button == "no")
            {
                consentResponse = ConsentResponse.Denied;
            }
            else if (inputConsent.Button == "yes")
            {
                if (inputConsent.ScopesConsented != null && inputConsent.ScopesConsented.Any())
                {
                    consentResponse = new ConsentResponse
                    {
                        RememberConsent = inputConsent.RememberConsent,
                        ScopesConsented = inputConsent.ScopesConsented
                    };
                }
                else
                { // 一个权限都没有选,给校验错误提示
                    result.ValidationError = "Please select at least one permission!";
                }
            }

            if (consentResponse != null)
            { //构造 Redirect return url
                var requestContext = await _identityServerInteractionService.GetAuthorizationContextAsync(inputConsent.ReturnUrl);

                await _identityServerInteractionService.GrantConsentAsync(requestContext, consentResponse); //告诉identityServer 用户做了哪些授权(同意 / 取消)

                //return Redirect(inputConsent.ReturnUrl);
                result.RedirectUrl = inputConsent.ReturnUrl;
            }
            else
            { // 如果consentResponse=null,即什么权限都没有选中,那么继续返回Index视图,这时实例化ConsentViewModel的对象
                var consentViewModel = await BuildConsentViewModelAsync(inputConsent.ReturnUrl, inputConsent);

                result.consentViewModel = consentViewModel;
            }

            return(result);
        }
示例#16
0
        public async Task <ConsentViewModel> BuildConsentViewModel(string returnUrl, InputConsentViewModel inputConsentViewModel = null)
        {
            //这个 returnUrl是在consent页中获取的必须带上这个请求页才能得到信息
            var request = await _identityServerInteractionService.GetAuthorizationContextAsync(returnUrl);

            if (request == null)
            {
                return(null);
            }

            var client = await _clientStore.FindClientByIdAsync(request.ClientId);

            var resources = await _resourceStore.FindEnabledResourcesByScopeAsync(request.ScopesRequested);// 所以这个scope就是代表这个客户端可以请求的api 或者获得的资源的名称?

            var model = CreateConsentViewModel(request, client, resources, inputConsentViewModel);

            model.ReutrnUrl = returnUrl;
            return(model);
        }
示例#17
0
        public async Task <ProcessConsentResult> ProceedConsent(InputConsentViewModel inputConsentViewModel)
        {
            ProcessConsentResult processConsentResult = new ProcessConsentResult();

            ConsentResponse consentResponse = null;

            if (inputConsentViewModel.Button == "yes")
            {
                if (inputConsentViewModel.scopeItems != null && inputConsentViewModel.scopeItems.Any())
                {
                    consentResponse = new ConsentResponse();
                    consentResponse.RememberConsent = inputConsentViewModel.RemenberConsent;
                    consentResponse.ScopesConsented = inputConsentViewModel.scopeItems;
                }
                else
                {
                    processConsentResult.ValidateErrorMessage = "请选择授权";
                }
            }
            else
            {
                consentResponse = ConsentResponse.Denied;//拒绝授权
            }

            if (consentResponse != null)
            {
                var request = await _identityServerInteractionService.GetAuthorizationContextAsync(inputConsentViewModel.ReutrnUrl);

                await _identityServerInteractionService.GrantConsentAsync(request, consentResponse);//不太明白这一步,是确定授权然后自动记录到数据?

                //这里是跳转回当前授权服务器的页面的
                //return Redirect(inputConsentViewModel.ReutrnUrl);
                processConsentResult.ReturnUrl = inputConsentViewModel.ReutrnUrl;
            }
            else
            {
                ConsentViewModel consentViewModel = await BuildConsentViewModel(inputConsentViewModel.ReutrnUrl);

                processConsentResult.consentViewModel = consentViewModel;
            }
            return(processConsentResult);
        }
示例#18
0
        public async Task <ProcessConsetnResult> ProcessConsent(InputConsentViewModel model)
        {
            var result = new ProcessConsetnResult()
            {
            };
            ConsentResponse consentResponse = null;

            if (model.Button == "no")
            {
                consentResponse = ConsentResponse.Denied;
            }
            else if (model.Button == "yes")
            {
                if (model.ScopesConsented != null && model.ScopesConsented.Any())
                {
                    consentResponse = new ConsentResponse
                    {
                        RememberConsent = model.RememberConsent,
                        ScopesConsented = model.ScopesConsented
                    };
                }
                else
                {
                    result.ValidationError = "请至少选择一个";
                }
            }
            if (consentResponse != null)
            {
                var request = await _identityServerInteractionServer.GetAuthorizationContextAsync(model.ReturnUrl);

                await _identityServerInteractionServer.GrantConsentAsync(request, consentResponse);

                result.RedirectUrl = model.ReturnUrl;
            }

            var consentViewModel = await BuildConsentViewModelAsync(model.ReturnUrl, model);

            result.ViewModel = consentViewModel;
            return(result);
        }
示例#19
0
        public async Task <ConsentGrantProceResult> ConsentGrantProce(InputConsentViewModel model)
        {
            ConsentResponse consentResponse = null;
            var             result          = new ConsentGrantProceResult();

            if (model.Button == "no")
            {
                consentResponse = new ConsentResponse {
                    Error = AuthorizationError.AccessDenied
                };
            }
            else if (model.Button == "yes")
            {
                if (model.ScopesConsented != null && model.ScopesConsented.Any())
                {
                    consentResponse = new ConsentResponse
                    {
                        RememberConsent       = model.AllowRememberConsent,
                        ScopesValuesConsented = model.ScopesConsented
                    };
                }
                else
                {
                    result.ValidateError = "请至少选中一个权限";
                }
            }
            if (consentResponse != null)
            {
                var request = await _identityServerInteractionService.GetAuthorizationContextAsync(model.ReturnUrl);

                await _identityServerInteractionService.GrantConsentAsync(request, consentResponse);

                result.RedirectUri = model.ReturnUrl;
            }
            else
            {
                result.ConsentViewModel = await BindConsentViewModelAsync(model.ReturnUrl, model);
            }
            return(result);
        }
示例#20
0
        public async Task <ProcessConsentResult> ProcessConsent(InputConsentViewModel model)
        {
            ConsentResponse response = null;
            var             result   = new ProcessConsentResult();

            if (model.Button == "no")
            {
                response = new ConsentResponse {
                    Error = AuthorizationError.AccessDenied
                };
            }
            else if (model.Button == "yes")
            {
                if (model.ScopesConsented != null && model.ScopesConsented.Any())
                {
                    response = new ConsentResponse()
                    {
                        ScopesValuesConsented = model.ScopesConsented.ToArray(),
                        RememberConsent       = model.RememberConsent
                    };
                }
                result.ValidationError = "请至少选中一个权限";
            }
            if (response != null)
            {
                var request = await _identityServerInteractionService.GetAuthorizationContextAsync(model.ReturnUrl);

                await _identityServerInteractionService.GrantConsentAsync(request, response);

                result.RedirectUrl = model.ReturnUrl;
            }
            else
            {
                var consentViewModel = await BuildConsentViewModel(model.ReturnUrl, model);

                result.consentViewModel = consentViewModel;
            }
            return(result);
        }
示例#21
0
        public async Task <ProcessConsentResult> PorcessConsent(InputConsentViewModel model)
        {
            ConsentResponse consent = null;
            var             result  = new ProcessConsentResult();

            if (model != null)
            {
                if (model.Button == "no")
                {
                    consent = ConsentResponse.Denied;// 拒绝授权
                }
                else if (model.Button == "yes")
                {
                    if (model.ScopesConsented != null && model.ScopesConsented.Any())
                    {
                        consent = new ConsentResponse
                        {
                            RememberConsent = model.RemeberConsent,
                            ScopesConsented = model.ScopesConsented
                        };
                    }
                    result.ValidationError = "请至少选中一个权限";
                }
            }
            if (consent != null)
            {
                var response = await _identityServerInteractionService.GetAuthorizationContextAsync(model.ReturnUrl);

                await _identityServerInteractionService.GrantConsentAsync(response, consent);// 通知用户同意

                result.RedirectUrl = model.ReturnUrl;
            }
            else
            {
                result.ConsentViewModel = await BuildConsentViewModel(model.ReturnUrl, model);
            }
            return(result);
        }
示例#22
0
        public async Task <ProcessConsentResult> ProcessConsent(InputConsentViewModel viewModel)
        {
            ConsentResponse consentResponse = null;

            if (viewModel.Button == "no")
            {
                consentResponse = ConsentResponse.Denied;
            }
            else if (viewModel.Button == "yes")
            {
                if (viewModel.ScopesConsented != null && viewModel.ScopesConsented.Any())
                {
                    consentResponse = new ConsentResponse
                    {
                        RememberConsent = viewModel.RemeberConsent,
                        ScopesConsented = viewModel.ScopesConsented,
                    };
                }
            }
            ProcessConsentResult result = new ProcessConsentResult();

            if (consentResponse != null)
            {
                var response = await _identityServerInteractionService.GetAuthorizationContextAsync(viewModel.ReturnUrl);

                await _identityServerInteractionService.GrantConsentAsync(response, consentResponse);

                result.ReditectUrl = viewModel.ReturnUrl;
            }


            var consentViewModel = await BuildConsentViewModel(viewModel.ReturnUrl);

            result.ViewModel = consentViewModel;


            return(result);
        }
        public async Task <ProcessConsentResult> ProcessConsent(InputConsentViewModel vm)
        {
            ConsentResponse consentResp = null;
            var             result      = new ProcessConsentResult();

            if (vm.Button == "no")
            {
                consentResp = ConsentResponse.Denied;
            }
            else if (vm.Button == "yes")
            {
                if (vm.ScopesConsented != null &&
                    vm.ScopesConsented.Any())
                {
                    consentResp = new ConsentResponse
                    {
                        RememberConsent = vm.RememberConsent,
                        ScopesConsented = vm.ScopesConsented
                    };
                }
                result.ValidationError = "请至少选中一个权限";
            }
            if (consentResp != null)
            {
                var req = await _identityServerInteractionService.GetAuthorizationContextAsync(vm.ReturnUrl);

                await _identityServerInteractionService.GrantConsentAsync(req, consentResp);

                result.RedirectUrl = vm.ReturnUrl;
            }
            {
                var consentvm = await BuildConsentViewModel(vm.ReturnUrl, vm);

                result.ConsentViewModel = consentvm;
            }
            return(result);
        }
示例#24
0
        private ConsentViewModel CreateConsentViewModel(AuthorizationRequest request, InputConsentViewModel model)
        {
            var rememberConsent = model?.RememberConsent ?? true;
            var selectedScops   = model?.ScopesConsented ?? Enumerable.Empty <string>();

            var vm = new ConsentViewModel()
            {
                ClientName      = request.Client.ClientName ?? request.Client.ClientId,
                ClientLogoUrl   = request.Client.LogoUri,
                ClientUrl       = request.Client.ClientUri,
                RememberConsent = rememberConsent,
                IdentityScopes  = request.ValidatedResources.Resources.IdentityResources.Select(i => CreateScopeViewModel(i, selectedScops.Contains(i.Name) || model == null)),
            };
            var apiScopes = new List <ScopeViewModel>();

            foreach (var parsedScope in request.ValidatedResources.ParsedScopes)
            {
                var apiScope = request.ValidatedResources.Resources.FindApiScope(parsedScope.ParsedName);
                if (apiScope != null)
                {
                    var scopeVm = CreateScopeViewModel(parsedScope, apiScope, vm.ScopesConsented.Contains(parsedScope.RawValue) || model == null);
                    apiScopes.Add(scopeVm);
                }
            }
            vm.ResourceScopes = apiScopes;

            return(vm);
        }
示例#25
0
 public async Task <IActionResult> Index(InputConsentViewModel viewModel)
 {
     //var model = await BuildConsentViewModel(returnUrl);
     return(View());
 }
示例#26
0
        public async Task <ConsentViewModel> BuildConsentViewModelAsync(string returnUrl, InputConsentViewModel inputConsent = null)
        {
            // 通过 identityServerInteractionService 获取 authorization context 信息
            var requestContext = await _identityServerInteractionService.GetAuthorizationContextAsync(returnUrl);

            if (requestContext == null)
            {
                return(null);
            }

            // 通过 clientStore 获取 client 信息
            var client = await _clientStore.FindEnabledClientByIdAsync(requestContext.ClientId);

            if (client == null)
            {
                return(null);
            }

            // 通过 resourceStore 获取 apiResource 和 identityResource 信息
            var resource = await _resourceStore.FindEnabledResourcesByScopeAsync(requestContext.ScopesRequested);

            if (resource == null)
            {
                return(null);
            }

            var consentViewModel = CreateConsentViewModel(requestContext, client, resource, inputConsent);

            //将 returnUrl 绑定到 consentViewModel对象上
            consentViewModel.ReturnUrl = returnUrl;
            return(consentViewModel);
        }
示例#27
0
        public async Task <IActionResult> Index(string returnUrl, InputConsentViewModel vm)
        {
            var model = await _consentSvc.BuildConsentViewModel(returnUrl, vm);

            return(View(model));
        }
示例#28
0
        private ConsentViewModel CreateConsentViewModel(Client client, Resources resources, InputConsentViewModel model)
        {
            var selectedScopes = model?.ScopesConsented ?? Enumerable.Empty <string>();

            return(new ConsentViewModel
            {
                ClientName = client.ClientName,
                ClientLogoUrl = client.LogoUri,
                ClientUrl = client.ClientUri,
                RememberConsent = model?.RememberConsent ?? client.AllowRememberConsent,
                IdentityScopes =
                    resources.IdentityResources.Select(i => CreateScopeViewModel(i, selectedScopes.Contains(i.Name))),
                ResourceScopes = resources.ApiResources.SelectMany(i => i.Scopes)
                                 .Select(i => CreateScopeViewModel(i, selectedScopes.Contains(i.Name)))
            });
        }
示例#29
0
        private ConsentViewModel CreateConsentViewModel(AuthorizationRequest request,
                                                        Client client, Resources resources, InputConsentViewModel model)
        {
            var selectedScopes = model?.ScopesConsented ?? Enumerable.Empty <string>();


            var vm = new ConsentViewModel();

            vm.ClientName     = client.ClientName;
            vm.ClientLogoUrl  = client.LogoUri;
            vm.ClientUrl      = client.ClientUri;
            vm.RemeberConsent = model?.RemeberConsent ?? true;

            vm.IdentityScopes = resources.IdentityResources.Select(_identityResource => {
                return(new ScopeViewModel
                {
                    Name = _identityResource.Name,
                    DisplayName = _identityResource.DisplayName,
                    Description = _identityResource.Description,
                    Required = _identityResource.Required,
                    Checked = selectedScopes.Contains(_identityResource.Name) || _identityResource.Required || model == null,
                    Emphasize = _identityResource.Emphasize
                });
            });

            vm.ResourceScopes = resources.ApiResources.SelectMany(i => i.Scopes).Select(_scope => {
                return(new ScopeViewModel
                {
                    Name = _scope.Name,
                    DisplayName = _scope.DisplayName,
                    Description = _scope.Description,
                    Required = _scope.Required,
                    Checked = selectedScopes.Contains(_scope.Name) || _scope.Required || model == null,
                    Emphasize = _scope.Emphasize
                });
            });

            return(vm);
        }
        private ConsentViewModel CreateConsentViewModel(AuthorizationRequest request, Client client, Resources resources, InputConsentViewModel model)
        {
            var selectedScopes = model?.ScopesConsented ?? Enumerable.Empty <string>();

            var consentViewModel = new ConsentViewModel();

            consentViewModel.ClientName    = client.ClientName;
            consentViewModel.ClientLogoUrl = client.LogoUri;
            consentViewModel.ClientUrl     = client.ClientUri;
            //consentViewModel.AllowRememberConsent = client.AllowRememberConsent;
            consentViewModel.RememberConsent = (model == null || model.RememberConsent);            // client.AllowRememberConsent;

            consentViewModel.IdentityScopes = resources.IdentityResources.Select(i => CreateScopeViewModel(i, model == null || selectedScopes.Contains(i.Name)));
            consentViewModel.ResourceScopes = resources.ApiResources.SelectMany(a => a.Scopes).Select(s => CreateScopeViewModel(s, model == null || selectedScopes.Contains(s.Name)));

            return(consentViewModel);
        }