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));
}
