public async virtual Task <ActionResult> IndexAsync(AuthorizationCodeResponseUrl authorizationCode,
CancellationToken taskCancellationToken)
{
if (string.IsNullOrEmpty(authorizationCode.Code))
{
var errorResponse = new TokenErrorResponse(authorizationCode);
Logger.Info("Received an error. The response is: {0}", errorResponse);
return(OnTokenError(errorResponse));
}
Logger.Debug("Received \"{0}\" code", authorizationCode.Code);
var returnUrl = Request.Url.ToString();
returnUrl = returnUrl.Substring(0, returnUrl.IndexOf("?"));
var token = await Flow.ExchangeCodeForTokenAsync(UserId, authorizationCode.Code, returnUrl,
taskCancellationToken).ConfigureAwait(false);
// Extract the right state.
var oauthState = await AuthWebUtility.ExtracRedirectFromState(Flow.DataStore, UserId,
authorizationCode.State).ConfigureAwait(false);
return(new RedirectResult(oauthState));
}
/// <summary>
/// Public constructor.
/// </summary>
/// <param name="message">Error message for this API exception.</param>
/// <param name="innerException">Inner exception, if any.</param>
/// <param name="error">The error details from server.</param>
/// <param name="statusCode">HTTP status code, if available.</param>
public AdsOAuthException(string message, Exception innerException, TokenErrorResponse error,
HttpStatusCode?statusCode)
: base(message, innerException)
{
this.Error = error;
this.StatusCode = statusCode;
}
public async Task <UserCredential> AuthorizeAsync(string userId, CancellationToken taskCancellationToken)
{
// Try to load a token from the data store.
var token = await Flow.LoadTokenAsync(userId, taskCancellationToken).ConfigureAwait(false);
// If the stored token is null or it doesn't have a refresh token and the access token is expired we need
// to retrieve a new authorization code.
if (token == null || (token.RefreshToken == null && token.IsExpired(flow.Clock)))
{
// Create an authorization code request.
var redirectUri = CodeReceiver.RedirectUri;
AuthorizationCodeRequestUrl codeRequest = Flow.CreateAuthorizationCodeRequest(redirectUri);
// Receive the code.
var response = await CodeReceiver.ReceiveCodeAsync(codeRequest, taskCancellationToken)
.ConfigureAwait(false);
if (string.IsNullOrEmpty(response.Code))
{
var errorResponse = new TokenErrorResponse(response);
Logger.Info("Received an error. The response is: {0}", errorResponse);
throw new TokenResponseException(errorResponse);
}
Logger.Debug("Received \"{0}\" code", response.Code);
// Get the token based on the code.
token = await Flow.ExchangeCodeForTokenAsync(userId, response.Code, CodeReceiver.RedirectUri,
taskCancellationToken).ConfigureAwait(false);
}
return(new UserCredential(flow, userId, token));
}
public override async Task <ActionResult> IndexAsync(AuthorizationCodeResponseUrl authorizationCode, CancellationToken taskCancellationToken)
{
if (string.IsNullOrEmpty(authorizationCode.Code))
{
var errorResponse = new TokenErrorResponse(authorizationCode);
return(OnTokenError(errorResponse));
}
var returnUrl = Request.Url.ToString();
returnUrl = returnUrl.Substring(0, returnUrl.IndexOf("?"));
await Flow.ExchangeCodeForTokenAsync(UserId, authorizationCode.Code, returnUrl,
taskCancellationToken);
var success = GoogleCalendarSyncer.SyncToGoogleCalendar(this);
if (!success)
{
return(Json("Token was revoked. Try again."));
}
return(Redirect(Url.Content("~/")));
}
public override async Task <ActionResult> IndexAsync(AuthorizationCodeResponseUrl authorizationCode,
CancellationToken taskCancellationToken)
{
if (string.IsNullOrEmpty(authorizationCode.Code))
{
var errorResponse = new TokenErrorResponse(authorizationCode);
Logger.Info("Received an error. The response is: {0}", errorResponse);
return(OnTokenError(errorResponse));
}
Logger.Debug("Received \"{0}\" code", authorizationCode.Code);
var returnUrl = Request.Url.ToString();
returnUrl = returnUrl.Substring(0, returnUrl.IndexOf("?"));
//AS- make sure _ISessionInfo is initialized
var l = _sessionInfo.CurrentAgencyId.GetValueOrDefault();
var u = _setupBusiness.GetClientEmail(l);
//AS
var token = await Flow.ExchangeCodeForTokenAsync(u, authorizationCode.Code, returnUrl,
taskCancellationToken).ConfigureAwait(true);//AS-include context
// Extract the right state.
var oauthState = await AuthWebUtility.ExtracRedirectFromState(Flow.DataStore, u,
authorizationCode.State).ConfigureAwait(true);//AS-include context
return(new RedirectResult(oauthState));
}
/// <inheritdoc/>
public async Task <UserCredential> AuthorizeAsync(string userId, CancellationToken taskCancellationToken)
{
// Try to load a token from the data store.
var token = await Flow.LoadTokenAsync(userId, taskCancellationToken).ConfigureAwait(false);
// Check if a new authorization code is needed.
if (ShouldRequestAuthorizationCode(token))
{
// Create an authorization code request.
var redirectUri = CodeReceiver.RedirectUri;
AuthorizationCodeRequestUrl codeRequest = Flow.CreateAuthorizationCodeRequest(redirectUri);
// Receive the code.
var response = await CodeReceiver.ReceiveCodeAsync(codeRequest, taskCancellationToken)
.ConfigureAwait(false);
if (string.IsNullOrEmpty(response.Code))
{
var errorResponse = new TokenErrorResponse(response);
Logger.Info("Received an error. The response is: {0}", errorResponse);
throw new TokenResponseException(errorResponse);
}
Logger.Debug("Received \"{0}\" code", response.Code);
// Get the token based on the code.
token = await Flow.ExchangeCodeForTokenAsync(userId, response.Code, redirectUri,
taskCancellationToken).ConfigureAwait(false);
}
return(new UserCredential(flow, userId, token));
}
public AuthorizationErrorResult(TokenErrorResponse tokenErrorResponse)
{
if (string.IsNullOrWhiteSpace(tokenErrorResponse.Error))
{
throw new ArgumentNullException(nameof(tokenErrorResponse.Error), "Error must be set.");
}
_tokenErrorResponse = tokenErrorResponse;
}
public TokenErrorResult(TokenErrorResponse error)
{
if (error.Error.IsMissing())
{
throw new ArgumentNullException(nameof(error.Error), "Error must be set");
}
Response = error;
}
private AuthorizationErrorResult Error(string error, string errorDescription = null, Dictionary <string, object> custom = null)
{
var response = new TokenErrorResponse {
Error = error,
ErrorDescription = errorDescription,
Custom = custom
};
Logger.LogError("[{EndpointName}] Trusted device registration initiation endpoint error: {Error}:{ErrorDescription}", nameof(InitRegistrationEndpoint), error, errorDescription ?? " -no message-");
return(new AuthorizationErrorResult(response));
}
private TokenErrorResult Error(string error, string errorDescription = null, Dictionary <string, object> custom = null)
{
var response = new TokenErrorResponse
{
Error = error,
ErrorDescription = errorDescription,
Custom = custom
};
return(new TokenErrorResult(response));
}
private TokenErrorResult Error(string error, string errorDescription = null, Dictionary <string, object> custom = null)
{
var response = new TokenErrorResponse
{
Error = error,
ErrorDescription = errorDescription,
Custom = custom
};
_logger.LogError("Device authorization error: {error}:{errorDescriptions}", error, error ?? "-no message-");
return(new TokenErrorResult(response));
}
private ActionResult TokenErrorJson(string error, string errorDescription)
{
if (error == "invalid_client")
{
Response.StatusCode = 401;
Response.Headers["WWW-Authenticate"] = "Basic realm=\"IdentityServices\"";
}
else
{
Response.StatusCode = 400;
}
var tokenErrorResponse = new TokenErrorResponse(error, errorDescription);
return(Content(tokenErrorResponse.GetResponseJson(), "application/json"));
}
protected override ActionResult OnTokenError(TokenErrorResponse errorResponse)
{
throw new TokenResponseException(errorResponse);
}
protected override ActionResult OnTokenError(TokenErrorResponse errorResponse)
{
return(Redirect("~/Home/AccessDenied"));
//throw new TokenResponseException(errorResponse);
}
protected override ActionResult OnTokenError(TokenErrorResponse errorResponse)
{
return(Redirect(Url.Content("~/")));
}
public override async Task <ActionResult> IndexAsync(AuthorizationCodeResponseUrl authorizationCode, CancellationToken taskCancellationToken)
{
try
{
log4net.ILog log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
log.Debug("-------------------------------IdenxAsync");
if (string.IsNullOrEmpty(authorizationCode.Code))
{
var errorResponse = new TokenErrorResponse(authorizationCode);
return(OnTokenError(errorResponse));
}
var returnUrl = Request.Url.ToString();
returnUrl = returnUrl.Substring(0, returnUrl.IndexOf("?"));
var token = await Flow.ExchangeCodeForTokenAsync(UserId, authorizationCode.Code, returnUrl,
taskCancellationToken);
UserCredential credentials = new UserCredential(this.FlowData.Flow, UserId, token);
var urlAuth = "https://www.googleapis.com/oauth2/v2/userinfo?access_token=" + token.AccessToken;
HttpClient client = new HttpClient();
HttpResponseMessage response = await client.GetAsync(urlAuth);
UsuarioGoogle googleUser = new UsuarioGoogle();
if (response.IsSuccessStatusCode)
{
googleUser = await response.Content.ReadAsAsync <UsuarioGoogle>();
}
/*var plusService = new PlusService(new BaseClientService.Initializer()
* {
* HttpClientInitializer = credentials,
* ApplicationName = "Box Festa",
* });*/
log.Debug("-------------------------------Plus service");
Sacola sacola = (Sacola)HttpContext.Session["sacola"];
Usuario usuario = new Usuario();
//BaseClientService.Initializer ini = new BaseClientService.Initializer { ApiKey = "AIzaSyBkXzq40hrcCImIxKSpNxQvr7zL37gN6qM" };
//PlusService plusService = new PlusService(ini);
//if (plusService != null)
//{
//PeopleResource.GetRequest prgr = plusService.People.Get("me");
//Person googleUser = prgr.Execute();
//Person me = plusService.People.Get(UserId).Execute();
//PeopleResource.GetRequest personRequest = plusService.People.Get(UserId);
//Person googleUser = personRequest.Execute();
//usuario.Email = googleUser.Emails.FirstOrDefault().Value;
//usuario.Nome = googleUser.Name.GivenName +" " + googleUser.Name.FamilyName;
//usuario.PrimeiroNome = googleUser.Name.GivenName;
usuario.Email = googleUser.email;
usuario.Nome = googleUser.given_name + " " + googleUser.family_name;
usuario.PrimeiroNome = googleUser.given_name;
Usuario usuarioBanco = UsuarioBO.ObterUsuarioEmail(usuario.Email);
if (usuarioBanco == null || usuarioBanco.Id == 0)
{
UsuarioBO.CadastrarUsuario(usuario);
}
usuario = UsuarioBO.ObterUsuarioEmail(usuario.Email);
HttpContext.Session["usuario"] = usuario;
//}
// Person me = plusService.People.Get(UserId).Execute();
/*var success = GoogleCalendarSyncer.SyncToGoogleCalendar(this);
* if (!success)
* {
* ViewData["Erro"] = "Token foi revogado. Tente novamente.";
* return new RedirectResult("~/Home/Login");
* }*/
if (!UsuarioBO.ExisteUsuario(usuario.Email))
{
UsuarioBO.CadastrarUsuario(usuario);
if (sacola != null && sacola.TipoPagamento.Equals("1"))
{
// if (sacola.Rua.Equals("Rua San Marino") && !String.IsNullOrEmpty(usuario.Email))
if (!String.IsNullOrEmpty(usuario.Email))
{
return(new RedirectResult("~/Home/PagSeguro"));
}
else
{
TempData["Erro"] = "Este Cep não pode efetuar compra.";
return(new RedirectResult("~/Home/Cart"));
}
}
else
{
ViewData["Mensagem"] = "Usuário criado com sucesso.";
return(new RedirectResult("~/Home/Index"));
}
}
else
{
if (sacola != null && sacola.TipoPagamento.Equals("1"))
{
if (!String.IsNullOrEmpty(usuario.Email))
{
return(new RedirectResult("~/Home/PagSeguro"));
}
else
{
TempData["Erro"] = "Este Cep não pode efetuar compra.";
return(new RedirectResult("~/Home/Cart"));
}
}
else
{
ViewData["Mensagem"] = "Usuário logado com sucesso.";
return(new RedirectResult("~/Home/Index"));
}
}
return(new RedirectResult("~/Home/Index"));
}
catch (Exception e)
{
ViewData["Erro"] = e.Message;
}
return(new RedirectResult("~/Home/Login"));
}
protected override ActionResult OnTokenError(TokenErrorResponse errorResponse)
{
return(View("Error"));
}
/// <summary>
/// A callback which gets the error when this controller didn't receive an authorization code. The default
/// implementation throws a <see cref="Google.Apis.Auth.OAuth2.Responses.TokenResponseException"/>.
/// </summary>
protected virtual ActionResult OnTokenError(TokenErrorResponse errorResponse)
{
throw new TokenResponseException(errorResponse);
}
// GET: /Account/HandleAuthenticationResponse?code=SplxlOBeZQQYbYS6WxSbIA&state=af0ifjsldkj
public async Task <ActionResult> HandleAuthenticationResponseAsync()
{
AuthenticationResponse authenticationResponse = AuthenticationResponse.LoadFromQueryString(Request.QueryString);
ActionResult actionResult;
if (authenticationResponse.State != (string)Session["OAuthAntiForgeryStateToken"])
{
actionResult = View(viewName: "Error", model: "Missing or invalid 'state' parameter.");
}
else if (string.IsNullOrEmpty(authenticationResponse.Code))
{
actionResult = View(viewName: "Error", model: $"Authentication failed. Error code: {authenticationResponse.Error}. Error description: {authenticationResponse.ErrorDescription}");
}
else
{
var tokenRequest = new TokenRequest(
clientId: Configuration.CLIENT_ID,
clientSecret: Configuration.CLIENT_SECRET,
grantType: "authorization_code",
code: authenticationResponse.Code,
redirectUri: Url.Action("HandleAuthenticationResponse", "Account", null, Request.Url.Scheme));
using (var tokenWebResponse = await tokenRequest.SendAsync(Configuration.TOKEN_ENDPOINT_URL))
{
if (tokenWebResponse == null)
{
actionResult = View(viewName: "Error", model: "Token request failed. Could not connect to the identity provider.");
}
else if (!tokenWebResponse.ContentType.StartsWith("application/json"))
{
actionResult = View(viewName: "Error", model: "Token request failed. Unexpected identity provider response.");
}
else
{
using (Stream tokenResponseStream = tokenWebResponse.GetResponseStream())
{
using (var tokenResponseReader = new StreamReader(tokenResponseStream))
{
string tokenResponseJson = await tokenResponseReader.ReadToEndAsync();
if (tokenWebResponse.StatusCode != HttpStatusCode.OK) // Token error response
{
TokenErrorResponse tokenErrorResponse = TokenErrorResponse.Deserialize(tokenResponseJson);
actionResult = View(viewName: "Error", model: $"Token request failed. Error code: {tokenErrorResponse.Error}. Error description: {tokenErrorResponse.ErrorDescription}");
}
else // Successful token response
{
SuccessfulTokenResponse successfulTokenResponse = SuccessfulTokenResponse.Deserialize(tokenResponseJson);
if (successfulTokenResponse.TokenType != "Bearer")
{
actionResult = View(viewName: "Error", model: $"Unexpected token type \"{successfulTokenResponse.TokenType}\". The only supported token type is \"Bearer\".");
}
else if (string.IsNullOrEmpty(successfulTokenResponse.IdToken))
{
actionResult = View(viewName: "Error", model: "The token response does not contain the required ID token.");
}
else
{
IdToken.ValidateAndLoadResult validateAndLoadIdTokenResult = IdToken.ValidateAndLoad(successfulTokenResponse.IdToken, Configuration.ISSUER_IDENTIFIER, Configuration.CLIENT_ID, Configuration.CLIENT_SECRET);
if (!validateAndLoadIdTokenResult.IsValid)
{
actionResult = View(viewName: "Error", model: "ID token validation failed. Error: " + validateAndLoadIdTokenResult.ErrorMessage);
}
else if (validateAndLoadIdTokenResult.IdToken.Exp < DateTime.UtcNow)
{
actionResult = View(viewName: "Error", model: "ID token is expired.");
}
else if (validateAndLoadIdTokenResult.IdToken.Nonce != (string)Session["OAuthAntiReplayNonceToken"])
{
actionResult = View(viewName: "Error", model: "Invalid \"nonce\" token. Possible replay attack.");
}
else
{
// All checks passed. Login the user and redirect to the Home page.
string userId = $"{validateAndLoadIdTokenResult.IdToken.Iss}|{validateAndLoadIdTokenResult.IdToken.Sub}";
var claimsIdentity = new ClaimsIdentity(new Claim[] { new Claim(ClaimTypes.Name, userId) }, DefaultAuthenticationTypes.ApplicationCookie);
HttpContext.GetOwinContext().Authentication.SignIn(new AuthenticationProperties {
IsPersistent = false
}, claimsIdentity);
actionResult = RedirectToAction("Index", "Home");
}
}
}
}
}
}
}
}
return(actionResult);
}
protected override ActionResult OnTokenError(TokenErrorResponse errorResponse)
{
ViewData["Erro"] = "Token foi revogado. Tente novamente.";
return(new RedirectResult("~/Home/Login"));
}
public override async Task <ActionResult> IndexAsync(AuthorizationCodeResponseUrl authorizationCode, CancellationToken taskCancellationToken)
{
if (string.IsNullOrEmpty(authorizationCode.Code))
{
var errorResponse = new TokenErrorResponse(authorizationCode);
Logger.Info("Received an error. The response is: {0}", errorResponse);
return(OnTokenError(errorResponse));
}
Logger.Debug("Received \"{0}\" code", authorizationCode.Code);
var returnUrl = Request.Url.ToString();
returnUrl = returnUrl.Substring(0, returnUrl.IndexOf("?"));
//Asynchronously exchanges code with a token.
var token = await Flow.ExchangeCodeForTokenAsync(UserId, authorizationCode.Code, returnUrl,
taskCancellationToken).ConfigureAwait(false);
//Constructs a new credential instance with access token
var credential = new UserCredential(Flow, UserId, token);
try
{
var peopleService = new PeopleServiceService(new BaseClientService.Initializer
{
HttpClientInitializer = credential,
ApplicationName = "< YOUR APP NAME >",
});
#region Contacts
PeopleResource.ConnectionsResource.ListRequest peopleRequest =
peopleService.People.Connections.List("people/me");
peopleRequest.PersonFields = "addresses,ageRanges,biographies,birthdays,calendarUrls," +
"clientData,coverPhotos,emailAddresses,events,externalIds,genders,imClients," +
"interests,locales,locations,memberships,metadata,miscKeywords,names,nicknames," +
"occupations,organizations,phoneNumbers,photos,relations,sipAddresses,skills,urls,userDefined";
peopleRequest.SortOrder = PeopleResource.ConnectionsResource.ListRequest.SortOrderEnum.LASTMODIFIEDDESCENDING;
peopleRequest.PageSize = 1000;
ListConnectionsResponse connectionsResponse = peopleRequest.Execute();
List <Person> connections = connectionsResponse.Connections as List <Person>;
// get all pages
while (!string.IsNullOrEmpty(connectionsResponse.NextPageToken))
{
peopleRequest.PageToken = connectionsResponse.NextPageToken;
connectionsResponse = peopleRequest.Execute();
connections.AddRange(connectionsResponse.Connections);
}
#endregion
var model = connections.Where(x => x.EmailAddresses != null && x.EmailAddresses.Any());
return(View(model));
}
catch (Exception exp)
{
Logger.Info("Received an error. The response is: {0}", exp.Message);
return(View("Error"));
}
}