public InteractiveRequest(
IServiceBundle serviceBundle,
AuthenticationRequestParameters authenticationRequestParameters,
ApiEvent.ApiIds apiId,
IEnumerable <string> extraScopesToConsent,
string loginHint,
UIBehavior uiBehavior,
IWebUI webUi)
: base(serviceBundle, authenticationRequestParameters, apiId)
{
RedirectUriHelper.Validate(authenticationRequestParameters.RedirectUri);
webUi?.ValidateRedirectUri(authenticationRequestParameters.RedirectUri);
_extraScopesToConsent = new SortedSet <string>();
if (!extraScopesToConsent.IsNullOrEmpty())
{
_extraScopesToConsent = ScopeHelper.CreateSortedSetFromEnumerable(extraScopesToConsent);
}
ValidateScopeInput(_extraScopesToConsent);
authenticationRequestParameters.LoginHint = loginHint;
if (!string.IsNullOrWhiteSpace(authenticationRequestParameters.ExtraQueryParameters) &&
authenticationRequestParameters.ExtraQueryParameters[0] == '&')
{
authenticationRequestParameters.ExtraQueryParameters =
authenticationRequestParameters.ExtraQueryParameters.Substring(1);
}
_webUi = webUi;
_uiBehavior = uiBehavior;
AuthenticationRequestParameters.RequestContext.Logger.Info(
"Additional scopes - " + _extraScopesToConsent.AsSingleString() + ";" +
"UIBehavior - " + _uiBehavior.PromptValue);
}
public void SilentRefreshFailedNoCacheItemFoundTest()
{
using (var harness = new MockHttpTestHarness(TestConstants.AuthorityHomeTenant))
{
var parameters = harness.CreateRequestParams(
harness.Cache,
ScopeHelper.CreateSortedSetFromEnumerable(
new[]
{
"some-scope1",
"some-scope2"
}),
authorityOverride: AuthorityInfo.FromAuthorityUri(TestConstants.AuthorityHomeTenant, false));
var silentParameters = new AcquireTokenSilentParameters()
{
Account = new Account(TestConstants.HomeAccountId, TestConstants.DisplayableId, TestConstants.ProductionPrefCacheEnvironment),
};
try
{
var request = new SilentRequest(harness.ServiceBundle, parameters, silentParameters);
Task <AuthenticationResult> task = request.RunAsync(CancellationToken.None);
var authenticationResult = task.Result;
Assert.Fail("MsalUiRequiredException should be thrown here");
}
catch (AggregateException ae)
{
var exc = ae.InnerException as MsalUiRequiredException;
Assert.IsNotNull(exc, "Actual exception type is " + ae.InnerException.GetType());
Assert.AreEqual(MsalError.NoTokensFoundError, exc.ErrorCode);
}
}
}
public AuthenticationRequestParameters(
IServiceBundle serviceBundle,
ITokenCacheInternal tokenCache,
AcquireTokenCommonParameters commonParameters,
RequestContext requestContext)
{
_commonParameters = commonParameters;
Authority = Authority.CreateAuthorityForRequest(serviceBundle.Config.AuthorityInfo, commonParameters.AuthorityOverride);
ClientId = serviceBundle.Config.ClientId;
CacheSessionManager = new CacheSessionManager(tokenCache, this, serviceBundle.TelemetryManager);
Scope = ScopeHelper.CreateSortedSetFromEnumerable(commonParameters.Scopes);
RedirectUri = new Uri(serviceBundle.Config.RedirectUri);
RequestContext = requestContext;
IsBrokerEnabled = serviceBundle.Config.IsBrokerEnabled;
// Set application wide query parameters.
ExtraQueryParameters = serviceBundle.Config.ExtraQueryParameters ?? new Dictionary <string, string>();
// Copy in call-specific query parameters.
if (commonParameters.ExtraQueryParameters != null)
{
foreach (KeyValuePair <string, string> kvp in commonParameters.ExtraQueryParameters)
{
ExtraQueryParameters[kvp.Key] = kvp.Value;
}
}
}
public async Task ForceRefreshParameterFalseTestAsync()
{
using (var httpManager = new MockHttpManager())
{
httpManager.AddInstanceDiscoveryMockHandler();
var app = ConfidentialClientApplicationBuilder
.Create(MsalTestConstants.ClientId)
.WithAuthority(new Uri(MsalTestConstants.AuthorityTestTenant), true)
.WithRedirectUri(MsalTestConstants.RedirectUri)
.WithClientSecret(MsalTestConstants.ClientSecret)
.WithHttpManager(httpManager)
.BuildConcrete();
_tokenCacheHelper.PopulateCacheForClientCredential(app.AppTokenCacheInternal.Accessor);
var accessTokens = await app.AppTokenCacheInternal.GetAllAccessTokensAsync(true).ConfigureAwait(false);
var accessTokenInCache = accessTokens
.Where(item => ScopeHelper.ScopeContains(item.ScopeSet, MsalTestConstants.Scope))
.ToList().FirstOrDefault();
// Don't add mock to fail in case of network call
// If there's a network call by mistake, then there won't be a proper number
// of mock web request/response objects in the queue and we'll fail.
var result = await app
.AcquireTokenForClient(MsalTestConstants.Scope)
.WithForceRefresh(false)
.ExecuteAsync(CancellationToken.None)
.ConfigureAwait(false);
Assert.AreEqual(accessTokenInCache.Secret, result.AccessToken);
}
}
public async Task <WebTokenRequest> CreateWebTokenRequestAsync(
WebAccountProvider provider,
AuthenticationRequestParameters authenticationRequestParameters,
bool isForceLoginPrompt,
bool isInteractive,
bool isAccountInWam)
{
bool setLoginHint = false;
bool addNewAccount = false;
string loginHint = authenticationRequestParameters.LoginHint ?? authenticationRequestParameters.Account?.Username;
if (isInteractive && !isAccountInWam)
{
if (!string.IsNullOrEmpty(loginHint))
{
setLoginHint = true;
}
else
{
addNewAccount = !(await _webAccountProviderFactory.IsDefaultAccountMsaAsync().ConfigureAwait(false));
}
}
var promptType = (setLoginHint || addNewAccount || (isForceLoginPrompt && isInteractive)) ?
WebTokenRequestPromptType.ForceAuthentication :
WebTokenRequestPromptType.Default;
string scopes = ScopeHelper.GetMsalScopes(authenticationRequestParameters.Scope).AsSingleString();
WebTokenRequest request = new WebTokenRequest(
provider,
scopes,
authenticationRequestParameters.ClientId,
promptType);
if (addNewAccount || setLoginHint)
{
request.Properties.Add("Client_uiflow", "new_account"); // launch add account flow
if (setLoginHint)
{
request.Properties.Add("LoginHint", loginHint); // prefill username
}
}
request.Properties.Add("api-version", "2.0"); // request V2 tokens over V1
request.Properties.Add("oauth2_batch", "1"); // request tokens as OAuth style name/value pairs
request.Properties.Add("x-client-info", "1"); // request client_info
if (ApiInformation.IsPropertyPresent("Windows.Security.Authentication.Web.Core.WebTokenRequest", "CorrelationId"))
{
request.CorrelationId = authenticationRequestParameters.CorrelationId.ToString();
}
else
{
_logger.Warning("[WAM MSA Plugin] Could not add the correlation ID to the request.");
}
return(request);
}
public void Is_False_When_ModifiedDate_Is_Late_And_OutOfScope(SectorTypes sector, ScopeStatuses scopeStatus)
{
var totalYearOffsets = 4;
for (var yearOffset = 0; yearOffset < totalYearOffsets; yearOffset++)
{
// Arrange
int testYear = VirtualDateTime.Now.Year - yearOffset;
DateTime snapshotDate = sector.GetAccountingStartDate(testYear);
DateTime nextSnapshotDate = snapshotDate.AddYears(1);
DateTime modifiedDate = nextSnapshotDate.AddDays(2);
Organisation testOrganisation = sector == SectorTypes.Private
? OrganisationHelper.GetPrivateOrganisation()
: OrganisationHelper.GetPublicOrganisation();
OrganisationScope testScope = ScopeHelper.CreateScope(scopeStatus, snapshotDate);
Return testReturn = ReturnHelper.CreateLateReturn(testOrganisation, snapshotDate, modifiedDate, testScope);
// Act
bool actual = testReturn.IsLateSubmission;
// Assert
Assert.AreEqual(false, actual);
}
}
public BoolString AfterDelete(Context db)
{
Helper.Audit(db, "BaseTable", AuditMode.Delete, id, this);
List <string> messages = new List <string>();
return(ScopeHelper.RegulateMessages(messages));
}
public BoolString BeforeCreate(Context db)
{
active = true;
List <string> messages = new List <string>();
return(ScopeHelper.RegulateMessages(messages));
}
protected SortedSet <string> GetDecoratedScope(SortedSet <string> inputScope)
{
SortedSet <string> set = new SortedSet <string>(inputScope.ToArray());
set.UnionWith(ScopeHelper.CreateSortedSetFromEnumerable(OAuth2Value.ReservedScopes));
return(set);
}
public BoolString AfterCreate(Context db)
{
Helper.Audit(db, "RDProgramming", AuditMode.Create, id, this);
List <string> messages = new List <string>();
return(ScopeHelper.RegulateMessages(messages));
}
/// <summary>
/// Moves the node to the center of top border
/// </summary>
private void MoveNodeToCenterOfTopBorder()
{
Point topBorderCenter = ScopeHelper.GetTopBorderCenter(m_scopeNode, 15, m_labelHeight);
m_enterScopeNode.Data.X = topBorderCenter.X;
m_enterScopeNode.Data.Y = topBorderCenter.Y;
}
public void ScopeHelperPerf()
{
ISet <string> scopeSet = null;
using (new PerformanceValidator(100, "Convert scope string to set"))
{
// about 500ms for 5000 iterations -> down to 160ms after replacing SortedSet with HashSet
for (int i = 0; i < 1000; i++)
{
scopeSet = ScopeHelper.ConvertStringToScopeSet(LotsOfScopes);
}
}
bool contains = true;
using (new PerformanceValidator(100, "Scope contains"))
{
// about 150ms for 10000 iterations -> down to 5ms after replacing SortedSet with HashSet
for (int i = 0; i < 10000; i++)
{
contains = ScopeHelper.ScopeContains(
scopeSet,
new[] { "Tasks.ReadWrite", "Agreement.ReadWrite.All", "bogus" });
}
}
Assert.IsFalse(contains);
}
public BoolString AfterEdit(Context db)
{
Helper.Audit(db, "RDChannel", AuditMode.Edit, id, this);
List <string> messages = new List <string>();
return(ScopeHelper.RegulateMessages(messages));
}
public BoolString AfterActive(Context db)
{
Helper.Audit(db, "BaseColumn", AuditMode.Active, id, this);
List <string> messages = new List <string>();
return(ScopeHelper.RegulateMessages(messages));
}
private MsalAccessTokenCacheItem(
string scopes,
DateTimeOffset cachedAt,
DateTimeOffset expiresOn,
DateTimeOffset extendedExpiresOn,
DateTimeOffset?refreshOn,
string tenantId,
string keyId,
string tokenType)
{
CredentialType = StorageJsonValues.CredentialTypeAccessToken;
ScopeString = scopes;
ScopeSet = ScopeHelper.ConvertStringToScopeSet(ScopeString);
ExpiresOn = expiresOn;
ExtendedExpiresOn = extendedExpiresOn;
RefreshOn = refreshOn;
TenantId = tenantId ?? "";
KeyId = keyId;
TokenType = tokenType;
CachedAt = cachedAt;
}
/// <summary>
/// Moves the node to center of bottom border.
/// </summary>
private void MoveNodeToCenterOfBottomBorder()
{
Point bottomBorderCenter = ScopeHelper.GetBottomBorderCenter(m_scopeNode, 15, m_labelHeight);
m_exitScopeNode.Data.X = bottomBorderCenter.X;
m_exitScopeNode.Data.Y = bottomBorderCenter.Y;
}
public BoolString AfterInactive(Context db)
{
Helper.Audit(db, "RDType", AuditMode.Inactive, id, this);
List <string> messages = new List <string>();
return(ScopeHelper.RegulateMessages(messages));
}
public static void Synchronize(string sqlConnectionString)
{
bool isScopeExists = ScopeHelper.CheckScope(sqlConnectionString, true);
if (!isScopeExists)
{
ScopeHelper.CreateScope(sqlConnectionString, true);
}
using (var localDbConnection = new SqlCeConnection(Constants.LocalConnectionString))
using (var remoteDbConnection = new SqlConnection(sqlConnectionString))
{
var syncOrchestrator = new SyncOrchestrator
{
Direction = SyncDirectionOrder.DownloadAndUpload,
RemoteProvider =
new SqlSyncProvider("SyncScope", remoteDbConnection),
LocalProvider = new SqlCeSyncProvider("SyncScope", localDbConnection)
};
syncOrchestrator.Synchronize();
}
ContactsManager.Current.RefreshCache();
CompaniesManager.Current.RefreshCache();
}
/// <summary>
/// Retrieve access token for the configured "client_id" and specified scopes. Request to the server is only performed if matching valid token is not in the cache
/// </summary>
/// <param name="scopes">OAuth2 scopes to request</param>
/// <param name="token">Cancellation token</param>
/// <returns>Access token</returns>
/// <exception cref="TokenEndpointException">Exception during token endpoint communication</exception>
public Task <string> GetTokenAsync(string[] scopes, CancellationToken token = default(CancellationToken))
{
var cacheKey = string.Join(":", _partialCacheKey, ScopeHelper.ToScopeString(scopes));
return(_cache.GetOrCreateAsync(cacheKey,
ct => _customGrantTokenClient.GetTokenInternalAsync(new List <KeyValuePair <string, string> >(), scopes, ct),
token));
}
void DisplayNameLocation(string[] scopes)
{
Console.WriteLine();
Console.WriteLine("Device name/location:");
Console.WriteLine("name - " + ScopeHelper.GetName(scopes));
Console.WriteLine("location - " + ScopeHelper.GetLocation(scopes));
Console.WriteLine();
}
private Dictionary <string, string> CreateAuthorizationRequestParameters(Uri redirectUriOverride = null)
{
var extraScopesToConsent = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
if (!_interactiveParameters.ExtraScopesToConsent.IsNullOrEmpty())
{
extraScopesToConsent = ScopeHelper.CreateScopeSet(_interactiveParameters.ExtraScopesToConsent);
}
if (extraScopesToConsent.Contains(_requestParams.AppConfig.ClientId))
{
throw new ArgumentException("API does not accept client id as a user-provided scope");
}
var unionScope = ScopeHelper.GetMsalScopes(
new HashSet <string>(_requestParams.Scope.Concat(extraScopesToConsent)));
var authorizationRequestParameters = new Dictionary <string, string>
{
[OAuth2Parameter.Scope] = unionScope.AsSingleString(),
[OAuth2Parameter.ResponseType] = OAuth2ResponseType.Code,
[OAuth2Parameter.ClientId] = _requestParams.AppConfig.ClientId,
[OAuth2Parameter.RedirectUri] = redirectUriOverride?.OriginalString ?? _requestParams.RedirectUri.OriginalString
};
if (!string.IsNullOrWhiteSpace(_requestParams.ClaimsAndClientCapabilities))
{
authorizationRequestParameters[OAuth2Parameter.Claims] = _requestParams.ClaimsAndClientCapabilities;
}
if (!string.IsNullOrWhiteSpace(_interactiveParameters.LoginHint))
{
authorizationRequestParameters[OAuth2Parameter.LoginHint] = _interactiveParameters.LoginHint;
}
if (_requestParams.RequestContext.CorrelationId != Guid.Empty)
{
authorizationRequestParameters[OAuth2Parameter.CorrelationId] =
_requestParams.RequestContext.CorrelationId.ToString();
}
foreach (KeyValuePair <string, string> kvp in MsalIdHelper.GetMsalIdParameters(_requestParams.RequestContext.Logger))
{
authorizationRequestParameters[kvp.Key] = kvp.Value;
}
if (_interactiveParameters.Prompt == Prompt.NotSpecified)
{
authorizationRequestParameters[OAuth2Parameter.Prompt] = Prompt.SelectAccount.PromptValue;
}
else if (_interactiveParameters.Prompt.PromptValue != Prompt.NoPrompt.PromptValue)
{
authorizationRequestParameters[OAuth2Parameter.Prompt] = _interactiveParameters.Prompt.PromptValue;
}
return(authorizationRequestParameters);
}
/// <summary>
/// Moves the node along scope border.
/// </summary>
private void MoveNodeAlongScopeBorder()
{
Point?intersection = ScopeHelper.GetIntersection(m_scopeNode, m_scopeNode.ExitDecisionNode, 15, 15, 15, 15, m_labelHeight);
if (intersection != null)
{
m_exitScopeNode.Data.X = intersection.Value.X;
m_exitScopeNode.Data.Y = intersection.Value.Y;
}
}
public async Task ForceRefreshParameterTrueTestAsync()
{
await RunWithMockHttpAsync(
async (httpManager, serviceBundle, receiver) =>
{
httpManager.AddInstanceDiscoveryMockHandler();
var cache = new TokenCache();
_tokenCacheHelper.PopulateCache(cache.TokenCacheAccessor);
string authority = Authority.CreateAuthority(serviceBundle, MsalTestConstants.AuthorityTestTenant, false)
.CanonicalAuthority;
var app = new ConfidentialClientApplication(
serviceBundle,
MsalTestConstants.ClientId,
authority,
MsalTestConstants.RedirectUri,
new ClientCredential(MsalTestConstants.ClientSecret),
null,
cache)
{
ValidateAuthority = false
};
httpManager.AddMockHandlerForTenantEndpointDiscovery(app.Authority);
//add mock response for successful token retrival
const string TokenRetrievedFromNetCall = "token retrieved from network call";
httpManager.AddMockHandler(
new MockHttpMessageHandler
{
Method = HttpMethod.Post,
ResponseMessage =
MockHelpers.CreateSuccessfulClientCredentialTokenResponseMessage(TokenRetrievedFromNetCall)
});
var result = await app.AcquireTokenForClientAsync(MsalTestConstants.Scope, true).ConfigureAwait(false);
Assert.AreEqual(TokenRetrievedFromNetCall, result.AccessToken);
// make sure token in Cache was updated
ICollection <MsalAccessTokenCacheItem> accessTokens =
cache.GetAllAccessTokensForClient(new RequestContext(null, new MsalLogger(Guid.NewGuid(), null)));
var accessTokenInCache = accessTokens
.Where(item => ScopeHelper.ScopeContains(item.ScopeSet, MsalTestConstants.Scope))
.ToList().FirstOrDefault();
Assert.AreEqual(TokenRetrievedFromNetCall, accessTokenInCache.Secret);
Assert.IsNotNull(
receiver.EventsReceived.Find(
anEvent => // Expect finding such an event
anEvent[EventBase.EventNameKey].EndsWith("api_event") &&
anEvent[ApiEvent.WasSuccessfulKey] == "true" && anEvent[ApiEvent.ApiIdKey] == "727"));
}).ConfigureAwait(false);
}
public async Task ForceRefreshParameterTrueTestAsync()
{
var receiver = new MyReceiver();
using (var httpManager = new MockHttpManager())
{
httpManager.AddInstanceDiscoveryMockHandler();
var app = ConfidentialClientApplicationBuilder
.Create(MsalTestConstants.ClientId)
.WithAuthority(new Uri(MsalTestConstants.AuthorityTestTenant), true)
.WithRedirectUri(MsalTestConstants.RedirectUri)
.WithClientSecret(MsalTestConstants.ClientSecret)
.WithHttpManager(httpManager)
.WithTelemetry(receiver.HandleTelemetryEvents)
.BuildConcrete();
_tokenCacheHelper.PopulateCache(app.AppTokenCacheInternal.Accessor);
httpManager.AddMockHandlerForTenantEndpointDiscovery(app.Authority);
// add mock response for successful token retrieval
const string TokenRetrievedFromNetCall = "token retrieved from network call";
httpManager.AddMockHandler(
new MockHttpMessageHandler
{
ExpectedMethod = HttpMethod.Post,
ResponseMessage =
MockHelpers.CreateSuccessfulClientCredentialTokenResponseMessage(TokenRetrievedFromNetCall)
});
var result = await app
.AcquireTokenForClient(MsalTestConstants.Scope)
.WithForceRefresh(true)
.ExecuteAsync(CancellationToken.None)
.ConfigureAwait(false);
Assert.AreEqual(TokenRetrievedFromNetCall, result.AccessToken);
// make sure token in Cache was updated
var accessTokens = await app.AppTokenCacheInternal.GetAllAccessTokensAsync(true).ConfigureAwait(false);
var accessTokenInCache = accessTokens
.Where(item => ScopeHelper.ScopeContains(item.ScopeSet, MsalTestConstants.Scope))
.ToList().FirstOrDefault();
Assert.AreEqual(TokenRetrievedFromNetCall, accessTokenInCache.Secret);
Assert.IsNotNull(
receiver.EventsReceived.Find(
anEvent => // Expect finding such an event
anEvent[EventBase.EventNameKey].EndsWith("api_event") &&
anEvent[ApiEvent.WasSuccessfulKey] == "true" && anEvent[MsalTelemetryBlobEventNames.ApiIdConstStrKey] == "1004"));
}
}
private Dictionary <string, string> CreateAuthorizationRequestParameters(Uri redirectUriOverride = null)
{
var extraScopesToConsent = new SortedSet <string>();
if (!_interactiveParameters.ExtraScopesToConsent.IsNullOrEmpty())
{
extraScopesToConsent = ScopeHelper.CreateSortedSetFromEnumerable(_interactiveParameters.ExtraScopesToConsent);
}
if (extraScopesToConsent.Contains(_requestParams.ClientId))
{
throw new ArgumentException("API does not accept client id as a user-provided scope");
}
SortedSet <string> unionScope = GetDecoratedScope(
new SortedSet <string>(_requestParams.Scope.Union(extraScopesToConsent)));
var authorizationRequestParameters = new Dictionary <string, string>
{
[OAuth2Parameter.Scope] = unionScope.AsSingleString(),
[OAuth2Parameter.ResponseType] = OAuth2ResponseType.Code,
[OAuth2Parameter.ClientId] = _requestParams.ClientId,
[OAuth2Parameter.RedirectUri] = redirectUriOverride?.OriginalString ?? _requestParams.RedirectUri.OriginalString
};
if (!string.IsNullOrWhiteSpace(_requestParams.ClaimsAndClientCapabilities))
{
authorizationRequestParameters[OAuth2Parameter.Claims] = _requestParams.ClaimsAndClientCapabilities;
}
if (!string.IsNullOrWhiteSpace(_interactiveParameters.LoginHint))
{
authorizationRequestParameters[OAuth2Parameter.LoginHint] = _interactiveParameters.LoginHint;
}
if (_requestParams.RequestContext?.Logger?.CorrelationId != Guid.Empty)
{
authorizationRequestParameters[OAuth2Parameter.CorrelationId] =
_requestParams.RequestContext.Logger.CorrelationId.ToString();
}
foreach (KeyValuePair <string, string> kvp in MsalIdHelper.GetMsalIdParameters(_requestParams.RequestContext.Logger))
{
authorizationRequestParameters[kvp.Key] = kvp.Value;
}
if (_interactiveParameters.Prompt.PromptValue != Prompt.NoPrompt.PromptValue)
{
authorizationRequestParameters[OAuth2Parameter.Prompt] = _interactiveParameters.Prompt.PromptValue;
}
return(authorizationRequestParameters);
}
private void CheckScopes(HandlerContext context)
{
var requestedScopes = context.Request.RequestData.GetScopesFromAuthorizationRequest();
if (!requestedScopes.Any())
{
throw new OAuthException(ErrorCodes.INVALID_REQUEST, string.Format(OAuth.ErrorMessages.MISSING_PARAMETER, OAuth.DTOs.AuthorizationRequestParameters.Scope));
}
ScopeHelper.Validate(requestedScopes, context.Client.AllowedScopes.Select(s => s.Name));
}
public static void AreScopesEqual(string scopesExpected, string scopesActual)
{
var expectedScopes = ScopeHelper.ConvertStringToLowercaseSortedSet(scopesExpected);
var actualScopes = ScopeHelper.ConvertStringToLowercaseSortedSet(scopesActual);
// can't use Assert.AreEqual on HashSet, so we'll compare by hand.
Assert.AreEqual(expectedScopes.Count, actualScopes.Count);
foreach (string expectedScope in expectedScopes)
{
Assert.IsTrue(actualScopes.Contains(expectedScope));
}
}
private static IEnumerable <MsalAccessTokenCacheItem> FilterByScopes(
AuthenticationRequestParameters requestParams,
IEnumerable <MsalAccessTokenCacheItem> tokenCacheItems)
{
var requestScopes = requestParams.Scope.Except(OAuth2Value.ReservedScopes, StringComparer.OrdinalIgnoreCase);
tokenCacheItems = tokenCacheItems.FilterWithLogging(
item => ScopeHelper.ScopeContains(item.ScopeSet, requestScopes),
requestParams.RequestContext.Logger,
"Filtering by scopes");
return(tokenCacheItems);
}
public void BindInputs(params Pin[] pins)
{
// We validate against specifications.
inputDesc.ValidateThrow(pins);
// Obtains the scope.
ScopeHelper.GetScope(ref scope, pins);
inputs = pins;
// We create the output pin.
outputs = new Pin[] { new Pin(PinFormat.Floatx4, Pin.NotArray, this) };
}
private static IEnumerable <MsalAccessTokenCacheItem> FilterByScopes(
AuthenticationRequestParameters requestParams,
IEnumerable <MsalAccessTokenCacheItem> tokenCacheItems)
{
var requestScopes = requestParams.Scope.Where(s =>
!OAuth2Value.ReservedScopes.Contains(s));
tokenCacheItems = tokenCacheItems.FilterWithLogging(
item => ScopeHelper.ScopeContains(item.ScopeSet, requestScopes),
requestParams.RequestContext.Logger,
"Filtering by scopes");
return(tokenCacheItems);
}
void prepareRenameMemberDefinitions(MethodNameScopes scopes)
{
Log.v("Renaming member definitions #1");
prepareRenameEntryPoints();
var virtualMethods = new ScopeHelper(memberInfos, modules.AllTypes);
var ifaceMethods = new ScopeHelper(memberInfos, modules.AllTypes);
var propMethods = new ScopeHelper(memberInfos, modules.AllTypes);
var eventMethods = new ScopeHelper(memberInfos, modules.AllTypes);
foreach (var scope in getSorted(scopes)) {
if (scope.hasNonRenamableMethod())
continue;
else if (scope.hasGetterOrSetterPropertyMethod() && getPropertyMethodType(scope.Methods[0]) != PropertyMethodType.Other)
propMethods.add(scope);
else if (scope.hasAddRemoveOrRaiseEventMethod())
eventMethods.add(scope);
else if (scope.hasInterfaceMethod())
ifaceMethods.add(scope);
else
virtualMethods.add(scope);
}
var prepareHelper = new PrepareHelper(memberInfos, modules.AllTypes);
prepareHelper.prepare((info) => info.prepareRenameMembers());
prepareHelper.prepare((info) => info.prepareRenamePropsAndEvents());
propMethods.visitAll((scope) => prepareRenameProperty(scope, false));
eventMethods.visitAll((scope) => prepareRenameEvent(scope, false));
propMethods.visitAll((scope) => prepareRenameProperty(scope, true));
eventMethods.visitAll((scope) => prepareRenameEvent(scope, true));
foreach (var typeDef in modules.AllTypes)
memberInfos.type(typeDef).initializeEventHandlerNames();
prepareHelper.prepare((info) => info.prepareRenameMethods());
ifaceMethods.visitAll((scope) => prepareRenameVirtualMethods(scope, "imethod_", false));
virtualMethods.visitAll((scope) => prepareRenameVirtualMethods(scope, "vmethod_", false));
ifaceMethods.visitAll((scope) => prepareRenameVirtualMethods(scope, "imethod_", true));
virtualMethods.visitAll((scope) => prepareRenameVirtualMethods(scope, "vmethod_", true));
restoreMethodArgs(scopes);
foreach (var typeDef in modules.AllTypes)
memberInfos.type(typeDef).prepareRenameMethods2();
}