private IHttpActionResult CreateConsentResult( ValidatedAuthorizeRequest validatedRequest, UserConsent consent, NameValueCollection requestParameters, string errorMessage) { var env = Request.GetOwinEnvironment(); var consentModel = new ConsentViewModel { RequestId = env.GetRequestId(), SiteName = _options.SiteName, SiteUrl = env.GetIdentityServerBaseUrl(), ErrorMessage = errorMessage, CurrentUser = User.GetName(), ClientName = validatedRequest.Client.ClientName, ClientUrl = validatedRequest.Client.ClientUri, ClientLogoUrl = validatedRequest.Client.LogoUri ?? null, IdentityScopes = validatedRequest.GetIdentityScopes(this._localizationService), ResourceScopes = validatedRequest.GetResourceScopes(this._localizationService), AllowRememberConsent = validatedRequest.Client.AllowRememberConsent, RememberConsent = consent != null ? consent.RememberConsent : true, LoginWithDifferentAccountUrl = Url.Route(Constants.RouteNames.Oidc.SwitchUser, null).AddQueryString(requestParameters.ToQueryString()), LogoutUrl = Url.Route(Constants.RouteNames.Oidc.EndSession, null), ConsentUrl = Url.Route(Constants.RouteNames.Oidc.Consent, null).AddQueryString(requestParameters.ToQueryString()), AntiForgery = _antiForgeryToken.GetAntiForgeryToken() }; return new ConsentActionResult(_viewService, consentModel); }
protected async Task<IHttpActionResult> ProcessRequestAsync(NameValueCollection parameters, UserConsent consent = null) { if (!_settings.AuthorizeEndpoint.IsEnabled) { Logger.Warn("Endpoint is disabled. Aborting"); return NotFound(); } /////////////////////////////////////////////////////////////// // validate protocol parameters ////////////////////////////////////////////////////////////// var result = _validator.ValidateProtocol(parameters); var request = _validator.ValidatedRequest; if (result.IsError) { return this.AuthorizeError( result.ErrorType, result.Error, request.ResponseMode, request.RedirectUri, request.State); } var interaction = _interactionGenerator.ProcessLogin(request, User as ClaimsPrincipal); if (interaction.IsError) { return this.AuthorizeError(interaction.Error); } if (interaction.IsLogin) { return this.RedirectToLogin(interaction.SignInMessage, request.Raw, _settings); } // user must be authenticated at this point if (!User.Identity.IsAuthenticated) { throw new InvalidOperationException("User is not authenticated"); } request.Subject = User as ClaimsPrincipal; /////////////////////////////////////////////////////////////// // validate client ////////////////////////////////////////////////////////////// result = await _validator.ValidateClientAsync(); if (result.IsError) { return this.AuthorizeError( result.ErrorType, result.Error, request.ResponseMode, request.RedirectUri, request.State); } interaction = await _interactionGenerator.ProcessConsentAsync(request, consent); if (interaction.IsError) { return this.AuthorizeError(interaction.Error); } if (interaction.IsConsent) { Logger.Info("Showing consent screen"); return CreateConsentResult(request, request.Raw, interaction.ConsentError); } return await CreateAuthorizeResponseAsync(request); }
public void ProcessConsentAsync_NoPromptMode_ConsentServiceRequiresConsent_ConsentGranted_NoScopesSelected_ReturnsConsentResult() { RequiresConsent(true); var request = new ValidatedAuthorizeRequest() { ResponseMode = Constants.ResponseModes.Fragment, State = "12345", RedirectUri = "https://client.com/callback", ValidatedScopes = new ScopeValidator(null), Client = new Client { } }; var consent = new UserConsent { Button = "yes", RememberConsent = false, Scopes = new string[] { } }; var result = subject.ProcessConsentAsync(request, consent).Result; request.WasConsentShown.Should().BeTrue(); result.IsConsent.Should().BeTrue(); result.ConsentError.Should().Be(Messages.MustSelectAtLeastOnePermission); AssertUpdateConsentNotCalled(); }
public async Task ProcessConsentAsync_AllowConsentSelected_SavesConsent() { RequiresConsent(true); var client = new Client { AllowRememberConsent = true }; var user = new ClaimsPrincipal(); var request = new ValidatedAuthorizeRequest() { ResponseMode = Constants.ResponseModes.Fragment, State = "12345", RedirectUri = "https://client.com/callback", ValidatedScopes = new ScopeValidator(new InMemoryScopeStore(GetScopes())), Client = client, Subject = user }; await request.ValidatedScopes.AreScopesValidAsync(new string[] { "read", "write" }); var consent = new UserConsent { Button = "yes", RememberConsent = true, Scopes = new string[] { "read" } }; var result = subject.ProcessConsentAsync(request, consent).Result; AssertUpdateConsentCalled(client, user, "read"); }
public Task <IHttpActionResult> PostConsent(UserConsent model) { return(ProcessRequestAsync(Request.RequestUri.ParseQueryString(), model ?? new UserConsent())); }
public async Task <ConsentInteractionResponse> ProcessConsentAsync(ValidatedAuthorizeRequest request, UserConsent consent = null) { if (request == null) { throw new ArgumentNullException("request"); } if (request.PromptMode != null && request.PromptMode != Constants.PromptModes.None && request.PromptMode != Constants.PromptModes.Consent) { throw new ArgumentException("Invalid PromptMode"); } var consentRequired = await _consent.RequiresConsentAsync(request.Client, request.Subject, request.RequestedScopes); if (consentRequired && request.PromptMode == Constants.PromptModes.None) { Logger.Info("Prompt=none requested, but consent is required."); return(new ConsentInteractionResponse { Error = new AuthorizeError { ErrorType = ErrorTypes.Client, Error = Constants.AuthorizeErrors.InteractionRequired, ResponseMode = request.ResponseMode, ErrorUri = request.RedirectUri, State = request.State } }); } if (request.PromptMode == Constants.PromptModes.Consent || consentRequired) { var response = new ConsentInteractionResponse(); // did user provide consent if (consent == null) { // user was not yet shown conset screen response.IsConsent = true; } else { request.WasConsentShown = true; // user was shown consent -- did they say yes or no if (consent.WasConsentGranted == false) { // no need to show consent screen again // build access denied error to return to client response.Error = new AuthorizeError { ErrorType = ErrorTypes.Client, Error = Constants.AuthorizeErrors.AccessDenied, ResponseMode = request.ResponseMode, ErrorUri = request.RedirectUri, State = request.State }; } else { // they said yes, set scopes they chose request.ValidatedScopes.SetConsentedScopes(consent.ScopedConsented); if (!request.ValidatedScopes.GrantedScopes.Any()) { // they said yes, but didn't pick any scopes // show consent again and provide error message response.IsConsent = true; response.ConsentError = _localizationService.GetMessage(MessageIds.MustSelectAtLeastOnePermission); } else if (request.Client.AllowRememberConsent) { // remember consent var scopes = Enumerable.Empty <string>(); if (consent.RememberConsent) { // remember what user actually selected scopes = request.ValidatedScopes.GrantedScopes.Select(x => x.Name); } await _consent.UpdateConsentAsync(request.Client, request.Subject, scopes); } } } return(response); } return(new ConsentInteractionResponse()); }
/// <summary> /// Initializing IronSource /// </summary> /// <param name="consent">user consent -> if true show personalized ads</param> /// <param name="platformSettings">contains all required settings for this publisher</param> public void InitializeAds(UserConsent consent, UserConsent ccpaConsent, List <PlatformSettings> platformSettings) { debug = Advertisements.Instance.debug; if (initialized == false) { initialized = true; #if UNITY_ANDROID PlatformSettings settings = platformSettings.First(cond => cond.platform == SupportedPlatforms.Android); #endif #if UNITY_IOS PlatformSettings settings = platformSettings.First(cond => cond.platform == SupportedPlatforms.iOS); #endif //apply settings appKey = settings.appId.id; bannerAdUnit = settings.idBanner.id; interstitialAdUnit = settings.idInterstitial.id; rewardedVideoAdUnit = settings.idRewarded.id; //verify settings if (debug) { Debug.Log(this + " Initialize"); ScreenWriter.Write(this + " Initialize"); Debug.Log(this + " App Key: " + appKey); ScreenWriter.Write(this + " App Key: " + appKey); Debug.Log(this + " Banner ID: " + bannerAdUnit); ScreenWriter.Write(this + " Banner ID: " + bannerAdUnit); Debug.Log(this + " Interstitial ID: " + interstitialAdUnit); ScreenWriter.Write(this + " Interstitial ID: " + interstitialAdUnit); Debug.Log(this + " Rewarded ID: " + rewardedVideoAdUnit); ScreenWriter.Write(this + " Rewarded ID: " + rewardedVideoAdUnit); } UpdateConsent(consent, ccpaConsent); if (!string.IsNullOrEmpty(bannerAdUnit)) { IronSourceEvents.onBannerAdLoadedEvent += BannerAdLoadedEvent; IronSourceEvents.onBannerAdLoadFailedEvent += BannerAdLoadFailedEvent; IronSourceEvents.onBannerAdClickedEvent += BannerAdClickedEvent; IronSourceEvents.onBannerAdScreenPresentedEvent += BannerAdScreenPresentedEvent; IronSourceEvents.onBannerAdScreenDismissedEvent += BannerAdScreenDismissedEvent; IronSourceEvents.onBannerAdLeftApplicationEvent += BannerAdLeftApplicationEvent; IronSource.Agent.init(appKey, IronSourceAdUnits.BANNER); } if (!string.IsNullOrEmpty(interstitialAdUnit)) { IronSourceEvents.onInterstitialAdReadyEvent += InterstitialAdReadyEvent; IronSourceEvents.onInterstitialAdLoadFailedEvent += InterstitialAdLoadFailedEvent; IronSourceEvents.onInterstitialAdShowSucceededEvent += InterstitialAdShowSucceededEvent; IronSourceEvents.onInterstitialAdShowFailedEvent += InterstitialAdShowFailedEvent; IronSourceEvents.onInterstitialAdClickedEvent += InterstitialAdClickedEvent; IronSourceEvents.onInterstitialAdOpenedEvent += InterstitialAdOpenedEvent; IronSourceEvents.onInterstitialAdClosedEvent += InterstitialAdClosedEvent; IronSource.Agent.init(appKey, IronSourceAdUnits.INTERSTITIAL); LoadInterstitial(); } if (!string.IsNullOrEmpty(rewardedVideoAdUnit)) { IronSourceEvents.onRewardedVideoAdOpenedEvent += RewardedVideoAdOpenedEvent; IronSourceEvents.onRewardedVideoAdClosedEvent += RewardedVideoAdClosedEvent; IronSourceEvents.onRewardedVideoAvailabilityChangedEvent += RewardedVideoAvailabilityChangedEvent; IronSourceEvents.onRewardedVideoAdStartedEvent += RewardedVideoAdStartedEvent; IronSourceEvents.onRewardedVideoAdEndedEvent += RewardedVideoAdEndedEvent; IronSourceEvents.onRewardedVideoAdRewardedEvent += RewardedVideoAdRewardedEvent; IronSourceEvents.onRewardedVideoAdShowFailedEvent += RewardedVideoAdShowFailedEvent; IronSource.Agent.init(appKey, IronSourceAdUnits.REWARDED_VIDEO); } //IronSource.Agent.validateIntegration(); } }
public void InitializeAds(UserConsent consent, UserConsent ccpaConsent, System.Collections.Generic.List <PlatformSettings> platformSettings) { }
private async Task <IHttpActionResult> ProcessRequestAsync(NameValueCollection parameters, UserConsent consent = null) { // validate request var result = await _validator.ValidateAsync(parameters, User as ClaimsPrincipal); if (result.IsError) { return(await this.AuthorizeErrorAsync( result.ErrorType, result.Error, result.ErrorDescription, result.ValidatedRequest)); } var request = result.ValidatedRequest; var loginInteraction = await _interactionGenerator.ProcessLoginAsync(request, User as ClaimsPrincipal); if (loginInteraction.IsError) { return(await this.AuthorizeErrorAsync( loginInteraction.Error.ErrorType, loginInteraction.Error.Error, null, request)); } if (loginInteraction.IsLogin) { return(this.RedirectToLogin(loginInteraction.SignInMessage, request.Raw)); } // we're either authenticated at this point, or it's an anonymous token request if (User.Identity.IsAuthenticated) { request.Subject = User as ClaimsPrincipal; } else { request.Subject = Principal.Create( "anon", new DefaultAnonymousClaimsProvider { CurrentAnonymousId = Request.GetOwinContext().Get <string>(Constants.OwinEnvironment.AnonymousId) }.GetAnonymousClaims( request.Client, request.ValidatedScopes.RequestedScopes).ToArray()); } // now that client configuration is loaded, we can do further validation loginInteraction = await _interactionGenerator.ProcessClientLoginAsync(request); if (loginInteraction.IsLogin) { return(this.RedirectToLogin(loginInteraction.SignInMessage, request.Raw)); } if (request.CanCreateAnonymousToken()) { return(await CreateAuthorizeResponseAsync(request)); } var consentInteraction = await _interactionGenerator.ProcessConsentAsync(request, consent); if (consentInteraction.IsError) { return(await this.AuthorizeErrorAsync( consentInteraction.Error.ErrorType, consentInteraction.Error.Error, null, request)); } if (consentInteraction.IsConsent) { Logger.Info("Showing consent screen"); return(CreateConsentResult(request, consent, request.Raw, consentInteraction.ConsentError)); } return(await CreateAuthorizeResponseAsync(request)); }
public async Task <InteractionResponse> ProcessConsentAsync(ValidatedAuthorizeRequest request, UserConsent consent) { if (request.PromptMode == Constants.PromptModes.Consent || await _consent.RequiresConsentAsync(request.Client, request.Subject, request.RequestedScopes)) { var response = new InteractionResponse(); // did user provide consent if (consent == null) { // user was not yet shown conset screen response.IsConsent = true; } else { request.WasConsentShown = true; // user was shown consent -- did they say yes or no if (consent.WasConsentGranted == false) { // no need to show consent screen again // build access denied error to return to client response.IsError = true; response.Error = new AuthorizeError { ErrorType = ErrorTypes.Client, Error = Constants.AuthorizeErrors.AccessDenied, ResponseMode = request.ResponseMode, ErrorUri = request.RedirectUri, State = request.State }; } else { // they said yes, set scopes they chose request.ValidatedScopes.SetConsentedScopes(consent.ScopedConsented); if (!request.ValidatedScopes.GrantedScopes.Any()) { // they said yes, but didn't pick any scopes // show consent again and provide error message response.IsConsent = true; response.ConsentError = "Must select at least one permission."; } if (request.Client.AllowRememberConsent) { // remember consent var scopes = Enumerable.Empty <string>(); if (consent.RememberConsent) { // remember what user actually selected scopes = request.ValidatedScopes.GrantedScopes.Select(x => x.Name); } await _consent.UpdateConsentAsync(request.Client, request.Subject, scopes); } } } return(response); } return(new InteractionResponse()); }
private IHttpActionResult CreateConsentResult( ValidatedAuthorizeRequest validatedRequest, UserConsent consent, NameValueCollection requestParameters, string errorMessage) { var env = Request.GetOwinEnvironment(); var consentModel = new ConsentViewModel() { SiteName = _options.SiteName, SiteUrl = env.GetIdentityServerBaseUrl(), ErrorMessage = errorMessage, CurrentUser = User.GetName(), ClientName = validatedRequest.Client.ClientName, ClientUrl = validatedRequest.Client.ClientUri, ClientLogoUrl = validatedRequest.Client.LogoUri != null ? validatedRequest.Client.LogoUri.AbsoluteUri : null, IdentityScopes = validatedRequest.GetIdentityScopes(), ApplicationScopes = validatedRequest.GetApplicationScopes(), AllowRememberConsent = validatedRequest.Client.AllowRememberConsent, RememberConsent = consent != null ? consent.RememberConsent : true, LoginWithDifferentAccountUrl = Url.Route(Constants.RouteNames.Oidc.SwitchUser, null) + "?" + requestParameters.ToQueryString(), LogoutUrl = Url.Route(Constants.RouteNames.Oidc.EndSession, null), ConsentUrl = Url.Route(Constants.RouteNames.Oidc.Consent, null) + "?" + requestParameters.ToQueryString() }; return new ConsentActionResult(_viewService, env, consentModel); }
public async Task<InteractionResponse> ProcessConsentAsync(ValidatedAuthorizeRequest request, UserConsent consent) { if (request.PromptMode == Constants.PromptModes.Consent || await _consent.RequiresConsentAsync(request.Client, request.Subject, request.RequestedScopes)) { var response = new InteractionResponse(); // did user provide consent if (consent == null) { // user was not yet shown conset screen response.IsConsent = true; } else { request.WasConsentShown = true; // user was shown consent -- did they say yes or no if (consent.WasConsentGranted == false) { // no need to show consent screen again // build access denied error to return to client response.IsError = true; response.Error = new AuthorizeError { ErrorType = ErrorTypes.Client, Error = Constants.AuthorizeErrors.AccessDenied, ResponseMode = request.ResponseMode, ErrorUri = request.RedirectUri, State = request.State }; } else { // they said yes, set scopes they chose request.ValidatedScopes.SetConsentedScopes(consent.ScopedConsented); if (!request.ValidatedScopes.GrantedScopes.Any()) { // they said yes, but didn't pick any scopes // show consent again and provide error message response.IsConsent = true; response.ConsentError = "Must select at least one permission."; } if (request.Client.AllowRememberConsent) { // remember consent var scopes = Enumerable.Empty<string>(); if (consent.RememberConsent) { // remember what user actually selected scopes = request.ValidatedScopes.GrantedScopes.Select(x => x.Name); } await _consent.UpdateConsentAsync(request.Client, request.Subject, scopes); } } } return response; } return new InteractionResponse(); }
/// <summary> /// Initializing AdColony /// </summary> /// <param name="consent">user consent -> if true show personalized ads</param> /// <param name="platformSettings">contains all required settings for this publisher</param> public void InitializeAds(UserConsent consent, UserConsent ccpaConsent, List <PlatformSettings> platformSettings) { debug = Advertisements.Instance.debug; //get settings #if UNITY_ANDROID PlatformSettings settings = platformSettings.First(cond => cond.platform == SupportedPlatforms.Android); #endif #if UNITY_IOS PlatformSettings settings = platformSettings.First(cond => cond.platform == SupportedPlatforms.iOS); #endif //apply settings appId = settings.appId.id; bannerZoneId = settings.idBanner.id; interstitialZoneId = settings.idInterstitial.id; rewardedZoneId = settings.idRewarded.id; //add listeners Ads.OnConfigurationCompleted += OnConfigurationCompleted; Ads.OnRequestInterstitial += OnRequestInterstitial; Ads.OnRequestInterstitialFailedWithZone += OnRequestInterstitialFailed; Ads.OnClosed += OnClosed; Ads.OnRewardGranted += OnRewardGranted; Ads.OnAdViewLoaded += BannerLoaded; Ads.OnAdViewFailedToLoad += BannerLoadFailed; //preparing AdColony SDK for initialization AppOptions appOptions = new AppOptions(); appOptions.AdOrientation = AdOrientationType.AdColonyOrientationAll; appOptions.GdprRequired = true; if (consent == UserConsent.Unset || consent == UserConsent.Accept) { appOptions.GdprConsentString = "1"; } else { appOptions.GdprConsentString = "0"; } List <string> zoneIDs = new List <string>(); if (!string.IsNullOrEmpty(bannerZoneId)) { zoneIDs.Add(bannerZoneId); } if (!string.IsNullOrEmpty(interstitialZoneId)) { zoneIDs.Add(interstitialZoneId); } if (!string.IsNullOrEmpty(rewardedZoneId)) { zoneIDs.Add(rewardedZoneId); } if (zoneIDs.Count == 0) { Debug.LogError("Please add your IDs in SettingsWindow"); return; } //Apply configuration Ads.Configure(appId, appOptions, zoneIDs.ToArray()); //verify settings if (debug) { Debug.Log(this + " Initialize"); ScreenWriter.Write(this + " Initialize"); Debug.Log(this + " App ID: " + appId); ScreenWriter.Write(this + " App ID: " + appId); Debug.Log(this + " Banner Zone ID: " + bannerZoneId); ScreenWriter.Write(this + " Banner Zone ID: " + bannerZoneId); Debug.Log(this + " Interstitial Zone ID: " + interstitialZoneId); ScreenWriter.Write(this + " Interstitial Zone ID: " + interstitialZoneId); Debug.Log(this + " Rewarded Zone ID: " + rewardedZoneId); ScreenWriter.Write(this + " Rewarded Zone ID: " + rewardedZoneId); } }
/// <summary> /// Initializing Admob /// </summary> /// <param name="consent">user consent -> if true show personalized ads</param> /// <param name="platformSettings">contains all required settings for this publisher</param> public void InitializeAds(UserConsent consent, UserConsent ccpaConsent, List <PlatformSettings> platformSettings) { debug = Advertisements.Instance.debug; if (initialized == false) { if (debug) { Debug.Log("Admob Start Initialization"); ScreenWriter.Write("Admob Start Initialization"); } //get settings #if UNITY_ANDROID PlatformSettings settings = platformSettings.First(cond => cond.platform == SupportedPlatforms.Android); #endif #if UNITY_IOS PlatformSettings settings = platformSettings.First(cond => cond.platform == SupportedPlatforms.iOS); #endif //apply settings interstitialId = settings.idInterstitial.id; bannerId = settings.idBanner.id; rewardedVideoId = settings.idRewarded.id; TagForChildDirectedTreatment tagFororChildren; if (settings.directedForChildren == true) { designedForFamilies = "true"; tagFororChildren = TagForChildDirectedTreatment.True; } else { designedForFamilies = "false"; tagFororChildren = TagForChildDirectedTreatment.Unspecified; } directedForChildren = settings.directedForChildren; RequestConfiguration requestConfiguration = new RequestConfiguration.Builder().SetTagForChildDirectedTreatment(tagFororChildren).build(); MobileAds.SetRequestConfiguration(requestConfiguration); MobileAds.SetiOSAppPauseOnBackground(true); //verify settings if (debug) { Debug.Log("Admob Banner ID: " + bannerId); ScreenWriter.Write("Admob Banner ID: " + bannerId); Debug.Log("Admob Interstitial ID: " + interstitialId); ScreenWriter.Write("Admob Interstitial ID: " + interstitialId); Debug.Log("Admob Rewarded Video ID: " + rewardedVideoId); ScreenWriter.Write("Admob Rewarded Video ID: " + rewardedVideoId); Debug.Log("Admob Directed for children: " + directedForChildren); ScreenWriter.Write("Admob Directed for children: " + directedForChildren); } //preparing Admob SDK for initialization if (consent == UserConsent.Unset || consent == UserConsent.Accept) { this.consent = "0"; } else { this.consent = "1"; } if (ccpaConsent == UserConsent.Unset || ccpaConsent == UserConsent.Accept) { this.ccpaConsent = "0"; } else { this.ccpaConsent = "1"; } MobileAds.Initialize(InitComplete); initialized = true; } }
public Task<IHttpActionResult> PostConsent(UserConsent model) { return ProcessRequestAsync(Request.RequestUri.ParseQueryString(), model ?? new UserConsent()); }
/// <summary> /// Initializing Unity Ads /// </summary> /// <param name="consent">user consent -> if true show personalized ads</param> /// <param name="platformSettings">contains all required settings for this publisher</param> public void InitializeAds(UserConsent consent, UserConsent ccpaConsent, List <PlatformSettings> platformSettings) { debug = Advertisements.Instance.debug; //get settings #if UNITY_ANDROID PlatformSettings settings = platformSettings.First(cond => cond.platform == SupportedPlatforms.Android); #endif #if UNITY_IOS PlatformSettings settings = platformSettings.First(cond => cond.platform == SupportedPlatforms.iOS); #endif //apply settings unityAdsId = settings.appId.id; bannerPlacement = settings.idBanner.id; videoAdPlacement = settings.idInterstitial.id; rewardedVideoAdPlacement = settings.idRewarded.id; //verify settings if (debug) { Debug.Log(this + " Initialization Started"); ScreenWriter.Write(this + " Initialization Started"); Debug.Log(this + " App ID: " + unityAdsId); ScreenWriter.Write(this + " App ID: " + unityAdsId); Debug.Log(this + " Banner placement ID: " + bannerPlacement); ScreenWriter.Write(this + " Banner Placement ID: " + bannerPlacement); Debug.Log(this + " Interstitial Placement ID: " + videoAdPlacement); ScreenWriter.Write(this + " Interstitial Placement ID: " + videoAdPlacement); Debug.Log(this + " Rewarded Video Placement ID: " + rewardedVideoAdPlacement); ScreenWriter.Write(this + " Rewarded Video Placement ID: " + rewardedVideoAdPlacement); } //preparing Unity Ads SDK for initialization if (consent != UserConsent.Unset) { MetaData gdprMetaData = new MetaData("gdpr"); if (consent == UserConsent.Accept) { gdprMetaData.Set("consent", "true"); } else { gdprMetaData.Set("consent", "false"); } Advertisement.SetMetaData(gdprMetaData); } if (ccpaConsent != UserConsent.Unset) { MetaData privacyMetaData = new MetaData("privacy"); if (consent == UserConsent.Accept) { privacyMetaData.Set("consent", "true"); } else { privacyMetaData.Set("consent", "false"); } Advertisement.SetMetaData(privacyMetaData); } Advertisement.AddListener(this); Advertisement.Initialize(unityAdsId, false); }
private async Task <IHttpActionResult> ProcessRequestAsync(NameValueCollection parameters, UserConsent consent = null) { /////////////////////////////////////////////////////////////// // validate protocol parameters ////////////////////////////////////////////////////////////// var result = _validator.ValidateProtocol(parameters); var request = _validator.ValidatedRequest; if (result.IsError) { return(this.AuthorizeError( result.ErrorType, result.Error, request)); } var loginInteraction = await _interactionGenerator.ProcessLoginAsync(request, User as ClaimsPrincipal); if (loginInteraction.IsError) { return(this.AuthorizeError( loginInteraction.Error.ErrorType, loginInteraction.Error.Error, request)); } if (loginInteraction.IsLogin) { return(this.RedirectToLogin(loginInteraction.SignInMessage, request.Raw)); } // user must be authenticated at this point if (!User.Identity.IsAuthenticated) { throw new InvalidOperationException("User is not authenticated"); } request.Subject = User as ClaimsPrincipal; /////////////////////////////////////////////////////////////// // validate client ////////////////////////////////////////////////////////////// result = await _validator.ValidateClientAsync(); if (result.IsError) { return(this.AuthorizeError( result.ErrorType, result.Error, request)); } // now that client configuration is loaded, we can do further validation loginInteraction = await _interactionGenerator.ProcessClientLoginAsync(request); if (loginInteraction.IsLogin) { return(this.RedirectToLogin(loginInteraction.SignInMessage, request.Raw)); } var consentInteraction = await _interactionGenerator.ProcessConsentAsync(request, consent); if (consentInteraction.IsError) { return(this.AuthorizeError( consentInteraction.Error.ErrorType, consentInteraction.Error.Error, request)); } if (consentInteraction.IsConsent) { Logger.Info("Showing consent screen"); return(CreateConsentResult(request, consent, request.Raw, consentInteraction.ConsentError)); } return(await CreateAuthorizeResponseAsync(request)); }
public void UpdateConsent(UserConsent consent, UserConsent ccpaConsent) { }
public void ProcessConsentAsync_PromptModeIsConsent_ConsentNotGranted_ReturnsErrorResult() { var request = new ValidatedAuthorizeRequest() { ResponseMode = Constants.ResponseModes.Fragment, State = "12345", RedirectUri = new Uri("https://client.com/callback"), PromptMode = Constants.PromptModes.Consent }; var consent = new UserConsent { Button = "no", RememberConsent = false, Scopes = new string[] { "read", "write" } }; var result = subject.ProcessConsentAsync(request, consent).Result; Assert.IsTrue(request.WasConsentShown); Assert.IsTrue(result.IsError); Assert.AreEqual(ErrorTypes.Client, result.Error.ErrorType); Assert.AreEqual(Constants.AuthorizeErrors.AccessDenied, result.Error.Error); AssertErrorReturnsRequestValues(result.Error, request); AssertUpdateConsentNotCalled(); }
protected async Task <IHttpActionResult> ProcessRequestAsync(NameValueCollection parameters, UserConsent consent = null) { _logger.Start("OIDC authorize endpoint."); /////////////////////////////////////////////////////////////// // validate protocol parameters ////////////////////////////////////////////////////////////// var result = _validator.ValidateProtocol(parameters); var request = _validator.ValidatedRequest; if (result.IsError) { return(this.AuthorizeError( result.ErrorType, result.Error, request.ResponseMode, request.RedirectUri, request.State)); } var interaction = _interactionGenerator.ProcessLogin(request, User as ClaimsPrincipal); if (interaction.IsError) { return(this.AuthorizeError(interaction.Error)); } if (interaction.IsLogin) { return(this.RedirectToLogin(interaction.SignInMessage, request.Raw, _settings)); } // user must be authenticated at this point if (!User.Identity.IsAuthenticated) { throw new InvalidOperationException("User is not authenticated"); } request.Subject = User as ClaimsPrincipal; /////////////////////////////////////////////////////////////// // validate client ////////////////////////////////////////////////////////////// result = await _validator.ValidateClientAsync(); if (result.IsError) { return(this.AuthorizeError( result.ErrorType, result.Error, request.ResponseMode, request.RedirectUri, request.State)); } interaction = await _interactionGenerator.ProcessConsentAsync(request, consent); if (interaction.IsError) { return(this.AuthorizeError(interaction.Error)); } if (interaction.IsConsent) { return(CreateConsentResult(request, request.Raw, interaction.ConsentError)); } return(await CreateAuthorizeResponseAsync(request)); }
public void ProcessConsentAsync_PromptModeIsConsent_ConsentGranted_NoScopesSelected_ReturnsConsentResult() { var request = new ValidatedAuthorizeRequest() { ResponseMode = Constants.ResponseModes.Fragment, State = "12345", RedirectUri = new Uri("https://client.com/callback"), PromptMode = Constants.PromptModes.Consent, ValidatedScopes = new ScopeValidator(), Client = new Client { } }; var consent = new UserConsent { Button = "yes", RememberConsent = false, Scopes = new string[] { } }; var result = subject.ProcessConsentAsync(request, consent).Result; Assert.IsTrue(request.WasConsentShown); Assert.IsTrue(result.IsConsent); Assert.AreEqual(Messages.MustSelectAtLeastOnePermission, result.ConsentError); AssertUpdateConsentNotCalled(); }
public void ProcessConsentAsync_NoPromptMode_ConsentServiceRequiresConsent_ConsentNotGranted_ReturnsErrorResult() { RequiresConsent(true); var request = new ValidatedAuthorizeRequest() { ResponseMode = Constants.ResponseModes.Fragment, State = "12345", RedirectUri = "https://client.com/callback", }; var consent = new UserConsent { Button = "no", RememberConsent = false, Scopes = new string[] { "read", "write" } }; var result = subject.ProcessConsentAsync(request, consent).Result; request.WasConsentShown.Should().BeTrue(); result.IsError.Should().BeTrue(); result.Error.ErrorType.Should().Be(ErrorTypes.Client); result.Error.Error.Should().Be(Constants.AuthorizeErrors.AccessDenied); AssertErrorReturnsRequestValues(result.Error, request); AssertUpdateConsentNotCalled(); }
public void ProcessConsentAsync_PromptModeConsent_ConsentGranted_ScopesSelected_ReturnsConsentResult() { RequiresConsent(true); var request = new ValidatedAuthorizeRequest() { ResponseMode = Constants.ResponseModes.Fragment, State = "12345", RedirectUri = new Uri("https://client.com/callback"), ValidatedScopes = new ScopeValidator(), Client = new Client { } }; request.ValidatedScopes.AreScopesValid(new string[] { "read", "write" }, TestScopes.Get()); var consent = new UserConsent { Button = "yes", RememberConsent = false, Scopes = new string[] { "read" } }; var result = subject.ProcessConsentAsync(request, consent).Result; Assert.AreEqual(1, request.ValidatedScopes.GrantedScopes.Count); Assert.AreEqual(request.ValidatedScopes.GrantedScopes.First().Name, "read"); Assert.IsTrue(request.WasConsentShown); Assert.IsFalse(result.IsConsent); AssertUpdateConsentNotCalled(); }
public async Task ProcessConsentAsync_PromptModeConsent_ConsentGranted_ScopesSelected_ReturnsConsentResult() { RequiresConsent(true); var request = new ValidatedAuthorizeRequest() { ResponseMode = Constants.ResponseModes.Fragment, State = "12345", RedirectUri = "https://client.com/callback", ValidatedScopes = new ScopeValidator(new InMemoryScopeStore(GetScopes())), Client = new Client { AllowRememberConsent = false } }; await request.ValidatedScopes.AreScopesValidAsync(new string[] { "read", "write" }); var consent = new UserConsent { Button = "yes", RememberConsent = false, Scopes = new string[] { "read" } }; var result = subject.ProcessConsentAsync(request, consent).Result; request.ValidatedScopes.GrantedScopes.Count.Should().Be(1); "read".Should().Be(request.ValidatedScopes.GrantedScopes.First().Name); request.WasConsentShown.Should().BeTrue(); result.IsConsent.Should().BeFalse(); AssertUpdateConsentNotCalled(); }
public Task <IHttpActionResult> PostConsent(UserConsent model) { Logger.Info("Resuming from consent, restarting validation"); return(ProcessRequestAsync(Request.RequestUri.ParseQueryString(), model ?? new UserConsent())); }
private async Task<IHttpActionResult> ProcessRequestAsync(NameValueCollection parameters, UserConsent consent = null) { /////////////////////////////////////////////////////////////// // validate protocol parameters ////////////////////////////////////////////////////////////// var result = _validator.ValidateProtocol(parameters); var request = _validator.ValidatedRequest; if (result.IsError) { return this.AuthorizeError( result.ErrorType, result.Error, request); } var loginInteraction = await _interactionGenerator.ProcessLoginAsync(request, User as ClaimsPrincipal); if (loginInteraction.IsError) { return this.AuthorizeError( loginInteraction.Error.ErrorType, loginInteraction.Error.Error, request); } if (loginInteraction.IsLogin) { return this.RedirectToLogin(loginInteraction.SignInMessage, request.Raw); } // user must be authenticated at this point if (!User.Identity.IsAuthenticated) { throw new InvalidOperationException("User is not authenticated"); } request.Subject = User as ClaimsPrincipal; /////////////////////////////////////////////////////////////// // validate client ////////////////////////////////////////////////////////////// result = await _validator.ValidateClientAsync(); if (result.IsError) { return this.AuthorizeError( result.ErrorType, result.Error, request); } // now that client configuration is loaded, we can do further validation loginInteraction = await _interactionGenerator.ProcessClientLoginAsync(request); if (loginInteraction.IsLogin) { return this.RedirectToLogin(loginInteraction.SignInMessage, request.Raw); } var consentInteraction = await _interactionGenerator.ProcessConsentAsync(request, consent); if (consentInteraction.IsError) { return this.AuthorizeError( consentInteraction.Error.ErrorType, consentInteraction.Error.Error, request); } if (consentInteraction.IsConsent) { Logger.Info("Showing consent screen"); return CreateConsentResult(request, consent, request.Raw, consentInteraction.ConsentError); } return await CreateAuthorizeResponseAsync(request); }
protected async Task <IHttpActionResult> ProcessRequestAsync(NameValueCollection parameters, UserConsent consent = null) { if (!_options.AuthorizeEndpoint.IsEnabled) { Logger.Warn("Endpoint is disabled. Aborting"); return(NotFound()); } /////////////////////////////////////////////////////////////// // validate protocol parameters ////////////////////////////////////////////////////////////// var result = _validator.ValidateProtocol(parameters); var request = _validator.ValidatedRequest; if (result.IsError) { return(this.AuthorizeError( result.ErrorType, result.Error, request.ResponseMode, request.RedirectUri, request.State)); } var loginInteraction = _interactionGenerator.ProcessLogin(request, User as ClaimsPrincipal); if (loginInteraction.IsError) { return(this.AuthorizeError(loginInteraction.Error)); } if (loginInteraction.IsLogin) { return(this.RedirectToLogin(loginInteraction.SignInMessage, request.Raw, _options)); } // user must be authenticated at this point if (!User.Identity.IsAuthenticated) { throw new InvalidOperationException("User is not authenticated"); } request.Subject = User as ClaimsPrincipal; /////////////////////////////////////////////////////////////// // validate client ////////////////////////////////////////////////////////////// result = await _validator.ValidateClientAsync(); if (result.IsError) { return(this.AuthorizeError( result.ErrorType, result.Error, request.ResponseMode, request.RedirectUri, request.State)); } var consentInteraction = await _interactionGenerator.ProcessConsentAsync(request, consent); if (consentInteraction.IsError) { return(this.AuthorizeError(consentInteraction.Error)); } if (consentInteraction.IsConsent) { Logger.Info("Showing consent screen"); return(CreateConsentResult(request, consent, request.Raw, consentInteraction.ConsentError)); } return(await CreateAuthorizeResponseAsync(request)); }
public Task<IHttpActionResult> PostConsent(UserConsent model) { Logger.Info("Resuming from consent, restarting validation"); return ProcessRequestAsync(Request.RequestUri.ParseQueryString(), model ?? new UserConsent()); }
public void InitializeAds(UserConsent consent, UserConsent ccpaConsent, List <PlatformSettings> platformSettings) { }
public async Task<ConsentInteractionResponse> ProcessConsentAsync(ValidatedAuthorizeRequest request, UserConsent consent = null) { if (request == null) throw new ArgumentNullException("request"); if (request.PromptMode != null && request.PromptMode != Constants.PromptModes.None && request.PromptMode != Constants.PromptModes.Consent) { throw new ArgumentException("Invalid PromptMode"); } var consentRequired = await _consent.RequiresConsentAsync(request.Client, request.Subject, request.RequestedScopes); if (consentRequired && request.PromptMode == Constants.PromptModes.None) { Logger.Info("Prompt=none requested, but consent is required."); return new ConsentInteractionResponse { Error = new AuthorizeError { ErrorType = ErrorTypes.Client, Error = Constants.AuthorizeErrors.InteractionRequired, ResponseMode = request.ResponseMode, ErrorUri = request.RedirectUri, State = request.State } }; } if (request.PromptMode == Constants.PromptModes.Consent || consentRequired) { var response = new ConsentInteractionResponse(); // did user provide consent if (consent == null) { // user was not yet shown conset screen response.IsConsent = true; } else { request.WasConsentShown = true; // user was shown consent -- did they say yes or no if (consent.WasConsentGranted == false) { // no need to show consent screen again // build access denied error to return to client response.Error = new AuthorizeError { ErrorType = ErrorTypes.Client, Error = Constants.AuthorizeErrors.AccessDenied, ResponseMode = request.ResponseMode, ErrorUri = request.RedirectUri, State = request.State }; } else { // they said yes, set scopes they chose request.ValidatedScopes.SetConsentedScopes(consent.ScopedConsented); if (!request.ValidatedScopes.GrantedScopes.Any()) { // they said yes, but didn't pick any scopes // show consent again and provide error message response.IsConsent = true; response.ConsentError = _localizationService.GetMessage(MessageIds.MustSelectAtLeastOnePermission); } else if (request.Client.AllowRememberConsent) { // remember consent var scopes = Enumerable.Empty<string>(); if (consent.RememberConsent) { // remember what user actually selected scopes = request.ValidatedScopes.GrantedScopes.Select(x => x.Name); } await _consent.UpdateConsentAsync(request.Client, request.Subject, scopes); } } } return response; } return new ConsentInteractionResponse(); }
public static IdentityServer4.Models.Consent ToModel(this UserConsent entity) { return(entity == null ? null : Mapper.Map <IdentityServer4.Models.Consent>(entity)); }