title: OpenIdConnectEvents OnAuthorizationCodeReceived not firing
body: <p>I am signing in with Azure AD in my Dotnet core web application, it is supposed to hit OnAuthorizationCodeReceived event, but it's not fired. </p>
  
  <p>Could you please give some light on this?</p>
  
  <pre><code> public void Configure(string name, OpenIdConnectOptions options)
              {
                  JsonFileConfigurationService config = new JsonFileConfigurationService();
                  options.ClientId = config.AzureAdClientId;
                  options.Authority = $"{config.AzureAdInstance}{config.AzureAdTenantId}";
                  options.UseTokenLifetime = true;
                  options.CallbackPath = config.AzureAdCallbackPath;
                  options.RequireHttpsMetadata = false;
                  var allScopes = $"{_azureOptions.Scopes} {_azureOptions.GraphScopes}".Split(new[] { ' ' });
                  foreach (var scope in allScopes) { options.Scope.Add(scope); }
  
                  options.TokenValidationParameters = new TokenValidationParameters
                  {
                      // Instead of using the default validation (validating against a single issuer value, as we do in line of business apps),
                      // we inject our own multitenant validation logic
                      ValidateIssuer = false,
  
                      // If the app is meant to be accessed by entire organizations, add your issuer validation logic here.
                      //IssuerValidator = (issuer, securityToken, validationParameters) =&gt; {
                      //    if (myIssuerValidationLogic(issuer)) return issuer;
                      //}
                  };
  
                  options.Events = new OpenIdConnectEvents
                  {
                      OnTicketReceived = context =&gt;
                      {
                          // If your authentication logic is based on users then add your logic here
                          return Task.CompletedTask;
                      },
                      OnAuthenticationFailed = context =&gt;
                      {
                          context.Response.Redirect("/Home/Error");
                          context.HandleResponse(); // Suppress the exception
                          return Task.CompletedTask;
                      },
                      OnAuthorizationCodeReceived = async (context) =&gt;
                      {
                          var code = context.ProtocolMessage.Code;
                          var identifier = context.Principal.FindFirst(config.AzureAdObjectIdentifierType).Value;
                          var memoryCache = context.HttpContext.RequestServices.GetRequiredService&lt;IMemoryCache&gt;();
                          var graphScopes = _azureOptions.GraphScopes.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
  
                          var cca = new ConfidentialClientApplication(
                              _azureOptions.ClientId,
                              _azureOptions.BaseUrl + _azureOptions.CallbackPath,
                              new ClientCredential(_azureOptions.ClientSecret),
                              new SessionTokenCache(identifier, memoryCache).GetCacheInstance(),
                              null);
                          var result = await cca.AcquireTokenByAuthorizationCodeAsync(code, graphScopes);
  
                          // Check whether the login is from the MSA tenant. 
                          // The sample uses this attribute to disable UI buttons for unsupported operations when the user is logged in with an MSA account.
                          var currentTenantId = context.Principal.FindFirst(config.AzureAdTenantId).Value;
                          if (currentTenantId == "9188040d-6c67-4c5b-b112-36a304b66dad")
                          {
                              // MSA (Microsoft Account) is used to log in
                          }
  
                          context.HandleCodeRedemption(result.AccessToken, result.IdToken);
                      },
                      // If your application needs to do authenticate single users, add your user validation below.
                      //OnTokenValidated = context =&gt;
                      //{
                      //    return myUserValidationLogic(context.Ticket.Principal);
                      //}
                  };
              }
  </code></pre>