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));
}
public void TestConstructor_Query()
{
string query = "code=123&error=ERR&error_uri=URI&error_description=DESC&state=STATE&other_ine=2222222222";
var response = new AuthorizationCodeResponseUrl(query);
SubtestConstructor(response);
}
/// <summary>Parses the HTTP request query parameters into the Authorization code response.</summary>
internal static void ParseRequest(this AuthorizationCodeResponseUrl authorizationCode, HttpRequest request)
{
var queryDic = QueryHelpers.ParseQuery(request.QueryString.ToString());
if (queryDic.ContainsKey("code"))
{
authorizationCode.Code = queryDic["code"];
}
if (queryDic.ContainsKey("state"))
{
authorizationCode.State = queryDic["state"];
}
// if there is no error these are not present in the query string, check first
if (queryDic.ContainsKey("error"))
{
authorizationCode.Error = queryDic["error"];
}
if (queryDic.ContainsKey("error_description"))
{
authorizationCode.ErrorDescription = queryDic["error_description"];
}
if (queryDic.ContainsKey("error_uri"))
{
authorizationCode.ErrorUri = queryDic["error_uri"];
}
}
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));
}
async Task <AuthorizationCodeResponseUrl> ICodeReceiver.ReceiveCodeAsync(AuthorizationCodeRequestUrl url, CancellationToken taskCancellationToken)
{
var authorizationUrl = url.Build().ToString();
using (var listener = new HttpListener()) {
listener.Prefixes.Add(RedirectUri);
try {
listener.Start();
Process.Start(authorizationUrl);
// Wait to get the authorization code response.
var context = await listener.GetContextAsync().ConfigureAwait(false);
NameValueCollection coll = context.Request.QueryString;
// Write a "close" response.
Thread.Sleep(200);
// Create a new response URL with a dictionary that contains all the response query parameters.
var codeResponse = new AuthorizationCodeResponseUrl(coll.AllKeys.ToDictionary(k => k, k => coll[k]));
using (var writer = new System.IO.StreamWriter(context.Response.OutputStream)) {
writer.WriteLine(string.IsNullOrWhiteSpace(codeResponse.Error) ? successResponse : failureResponse);
writer.Flush();
}
context.Response.OutputStream.Close();
return(codeResponse);
} finally {
listener.Close();
}
}
}
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 void TestConstructor_Query()
{
string query = "code=123&error=ERR&error_uri=URI&error_description=DESC&state=STATE&another_parameter=ANOTHER_PARAMETER";
var response = new AuthorizationCodeResponseUrl(query);
SubtestConstructor(response);
}
public async Task <AuthorizationCodeResponseUrl> ReceiveCodeAsync(AuthorizationCodeRequestUrl url, CancellationToken taskCancellationToken)
{
var fileName = url.Build().ToString();
AuthorizationCodeResponseUrl authorizationCodeResponseUrl;
using (var httpListener = new HttpListener())
{
httpListener.Prefixes.Add(RedirectUri);
try
{
httpListener.Start();
Logger.Debug("Open a browser with \"{0}\" URL", (object)fileName);
Process.Start(fileName);
var httpListenerContext = await httpListener.GetContextAsync().ConfigureAwait(false);
var coll = httpListenerContext.Request.QueryString;
using (var streamWriter = new StreamWriter(httpListenerContext.Response.OutputStream))
{
streamWriter.WriteLine(ClosePageResponse);
streamWriter.Flush();
}
httpListenerContext.Response.OutputStream.Close();
var allKeys = coll.AllKeys;
Expression <Func <string, string> > elementSelector = k => coll[k];
authorizationCodeResponseUrl = new AuthorizationCodeResponseUrl(allKeys.ToDictionary(k => k, elementSelector.Compile()));
}
finally
{
httpListener.Close();
}
}
return(authorizationCodeResponseUrl);
}
private void SubtestConstructor(AuthorizationCodeResponseUrl response)
{
Assert.Equal("123", response.Code);
Assert.Equal("ERR", response.Error);
Assert.Equal("URI", response.ErrorUri);
Assert.Equal("DESC", response.ErrorDescription);
Assert.Equal("STATE", response.State);
}
public void TestConstructor_Default()
{
var response = new AuthorizationCodeResponseUrl();
Assert.Null(response.Code);
Assert.Null(response.Error);
Assert.Null(response.ErrorUri);
Assert.Null(response.ErrorDescription);
Assert.Null(response.State);
}
/// <summary>Parses the HTTP request query parameters into the Authorization code response.</summary>
internal static void ParseRequest(this AuthorizationCodeResponseUrl authorizationCode, HttpRequestBase request)
{
var queryDic = HttpUtility.ParseQueryString(request.Url.Query);
authorizationCode.Code = queryDic["code"];
authorizationCode.Error = queryDic["error"];
authorizationCode.ErrorDescription = queryDic["error_description"];
authorizationCode.ErrorUri = queryDic["error_uri"];
authorizationCode.State = queryDic["state"];
}
public override Task <ActionResult> IndexAsync(AuthorizationCodeResponseUrl authorizationCode, CancellationToken taskCancellationToken)
{
var stateWithoutRandomToken = authorizationCode.State.Substring(0, authorizationCode.State.Length - AuthorizationCodeWebApp.StateRandomLength);
var uri = new Uri(stateWithoutRandomToken);
var profileId = uri.ParseQueryString().Get("profileId");
var config = AnalyticsAccount.GetByUniqueId(profileId);
_flowData = new uSplitFlowMetadata(config);
return(base.IndexAsync(authorizationCode, taskCancellationToken));
}
private void SubtestConstructor(AuthorizationCodeResponseUrl response)
{
Assert.Equal("123", response.Code);
Assert.Equal("ERR", response.Error);
Assert.Equal("URI", response.ErrorUri);
Assert.Equal("DESC", response.ErrorDescription);
Assert.Equal("STATE", response.State);
var pair = Assert.Single(response.AdditionalParameters);
Assert.Equal("another_parameter", pair.Key);
Assert.Equal("ANOTHER_PARAMETER", pair.Value);
}
public async Task <AuthorizationCodeResponseUrl> ReceiveCodeAsync(AuthorizationCodeRequestUrl url, CancellationToken taskCancellationToken)
{
YoutubeAuthClient client = new YoutubeAuthClient();
var response = new AuthorizationCodeResponseUrl
{
Code = await client.RefreshToken(Code)
};
return(response);
}
public void TestConstructor_Dictionary()
{
var dic = new Dictionary <string, string>();
dic["code"] = "123";
dic["error"] = "ERR";
dic["error_uri"] = "URI";
dic["error_description"] = "DESC";
dic["state"] = "STATE";
dic["another_parameter"] = "ANOTHER_PARAMETER";
var response = new AuthorizationCodeResponseUrl(dic);
SubtestConstructor(response);
}
public void TestConstructor_Dictionary()
{
var dic = new Dictionary <string, string>();
dic["code"] = "123";
dic["error"] = "ERR";
dic["error_uri"] = "URI";
dic["error_description"] = "DESC";
dic["state"] = "STATE";
// Some other parameter, which is not part of the response.
dic["another_one"] = "BLAH BLAH BLAH";
var response = new AuthorizationCodeResponseUrl(dic);
SubtestConstructor(response);
}
private void authWebBrowser_TitleChanged(object sender, EventArgs e)
{
// The result always comes back
var browser = (WebBrowser)sender;
if (browser.Url.AbsolutePath == new Uri(GoogleAuthConsts.ApprovalUrl).AbsolutePath)
{
// Per API documentation, the reponse is after the first space in the title.
var query = browser.DocumentTitle.Substring(browser.DocumentTitle.IndexOf(" ") + 1);
ResponseUrl = new AuthorizationCodeResponseUrl(query);
// Dialog is no longer neeed.
this.Close();
}
else
{
System.Diagnostics.Trace.TraceInformation(browser.Url.AbsolutePath);
}
}
/// <summary>
/// Setups the listener.
/// </summary>
private async void SetupListener()
{
mlistener = new HttpListener();
mlistener.Prefixes.Add(mRedirectUrl);
mlistener.Start();
var context = await mlistener.GetContextAsync().ConfigureAwait(false);
NameValueCollection coll = context.Request.QueryString;
// Write a "close" response.
using (var writer = new StreamWriter(context.Response.OutputStream))
{
writer.WriteLine(ClosePageResponse);
writer.Flush();
}
context.Response.OutputStream.Close();
mItem = new AuthorizationCodeResponseUrl(coll.AllKeys.ToDictionary(k => k, k => coll[k]));
}
public async Task <ActionResult> ConnectCallBack(AuthorizationCodeResponseUrl authorizationCode,
CancellationToken taskCancellationToken)
{
try
{
var userId = CurrentUser.StringId;
var returnUrl = Request.Url.ToString();
returnUrl = returnUrl.Substring(0, returnUrl.IndexOf("?"));
var token =
await
AppFlow.Flow.ExchangeCodeForTokenAsync(userId, authorizationCode.Code, returnUrl,
taskCancellationToken);
var api = new Oauth2Service(new BaseClientService.Initializer()
{
HttpClientInitializer = new UserCredential(AppFlow.Flow, userId, token)
});
var userInfo = api.Userinfo.Get().Execute();
CurrentUser.GoogleDriveAccount = new GoogleDriveAccount
{
ConnectingDate = DateTime.UtcNow,
Enabled = true,
AccessToken = token.AccessToken,
RefreshToken = token.RefreshToken,
Issued = token.Issued,
Scope = token.Scope,
TokenType = token.TokenType,
ExpiresInSeconds = token.ExpiresInSeconds,
AccountName = userInfo.Name
};
UnitOfWork.Commit();
}
catch
{
ModelState.AddModelError("", "Can't connect to Google Drive.");
}
return(RedirectToAction <UserController>(c => c.Index()));
}
/// <summary>Constructs a new token error response from the given authorization code response.</summary>
public TokenErrorResponse(AuthorizationCodeResponseUrl authorizationCode)
{
Error = authorizationCode.Error;
ErrorDescription = authorizationCode.ErrorDescription;
ErrorUri = authorizationCode.ErrorUri;
}
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"));
}
}
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"));
}
/// <summary>Constructs a new token error response from the given authorization code response.</summary>
public TokenErrorResponse(AuthorizationCodeResponseUrl authorizationCode)
{
Error = authorizationCode.Error;
ErrorDescription = authorizationCode.ErrorDescription;
ErrorUri = authorizationCode.ErrorUri;
}
