public static BearerToken GetBearerToken()
{
BearerToken token = null;
var jsonToken = $"grant_type=password&database={CONFIG.DATABASE}&username={CONFIG.USERNAME}&password={CONFIG.PASSWORD}&keys={CONFIG.KEYS}";
var requestBearer = (HttpWebRequest)WebRequest.Create($"{CONFIG.ADDRESS}/API/Bearer");
requestBearer.ContentType = "application/x-www-form-urlencoded";
requestBearer.ContentLength = jsonToken.Length;
requestBearer.Timeout = 10000;
requestBearer.Method = "POST";
using (var writer = new StreamWriter(requestBearer.GetRequestStream()))
{
writer.Write(jsonToken);
writer.Flush();
writer.Close();
}
using (var response = (HttpWebResponse)requestBearer.GetResponse())
{
using (var reader = new StreamReader(response.GetResponseStream()))
{
var data = reader.ReadToEnd();
response.Close();
reader.Close();
token = JsonConvert.DeserializeObject <BearerToken>(data);
}
}
return(token);
}
public async Task <IActionResult> Register([FromBody] RegisterUserData registerUserData)
{
var newUser = Mapper.Map <User>(registerUserData);
newUser.Password = EncyptionProvider.HashPassword(newUser.Password);
var repositoryResponse = await Repository.RegisterUser(newUser);
if (!repositoryResponse.Successful)
{
if (repositoryResponse.RepositoryResponseMessage == RepositoryResponse <User> .RepositoryResponseMessageEnum.EmailIndexException)
{
return(new BadRequestObjectResult(AuthControllerErrorCodes.EmailUsedError));
}
if (repositoryResponse.RepositoryResponseMessage == RepositoryResponse <User> .RepositoryResponseMessageEnum.UserIndexException)
{
return(new BadRequestObjectResult(AuthControllerErrorCodes.LoginUsedError));
}
if (repositoryResponse.RepositoryResponseMessage == RepositoryResponse <User> .RepositoryResponseMessageEnum.UserIndexAndEmailIndexException)
{
return(new BadRequestObjectResult(AuthControllerErrorCodes.LoginAndEmailUsedError));
}
return(new BadRequestResult());
}
BearerToken bearerToken = EncyptionProvider.CreateBearerToken(Mapper.Map <BearerToken>(repositoryResponse.Value));
return(new JsonResult(bearerToken));
}
private BearerToken GetToken()
{
const string url = "GetUserToken";
var client = new HttpClient();
var currentToken = new BearerToken();
try
{
var usr = new AuthRequest
{
User = UserName,
Pwd = PassWord
};
client.BaseAddress = new Uri(WebApiUrl);
var content = new JsonContent(usr);
var response = client.PostAsync(url, content).Result;
if (response.IsSuccessStatusCode)
{
currentToken = response.Data <BearerToken>();
}
}
catch (Exception ex)
{
LogErrorMessage(client.BaseAddress + url, ex);
}
return(currentToken);
}
public void ClearToken()
{
lock (locker)
{
token = null;
}
}
public Form1()
{
InitializeComponent();
this.BringToFront();
this.Focus();
this.KeyPreview = true;
Index = 0; Pages = new List <Tuple <string, Status> >();
button1.Enabled = button2.Enabled = false;
if (BearerToken.Equals("none"))
{
try
{
BearerToken = OAuth2.GetToken(ConsumerKey, ConsumerSecret).BearerToken;
Properties.Settings.Default.Save();
}
catch (Exception e)
{
MessageBox.Show(e.ToString());
Environment.Exit(1);
}
}
Token = OAuth2Token.Create(ConsumerKey, ConsumerSecret, BearerToken);
toolStripTextBox1.Focus();
}
/// <summary>
/// This method validates if the parameter <paramref name="token" /> is valid and can be used.
/// </summary>
/// <returns>
/// True if valid and false otherwise
/// </returns>
/// <param name="token"> A token class of type BearerToken to be validated</param>
/// <seealso cref="BearerToken"/>
public static bool IsValidToken(BearerToken token)
{
// Adding 2 seconds guard to ensure the request is done before the expiry time has reached
return(token != null &&
!string.IsNullOrEmpty(token.AccessToken) &&
token.ExpirationDate > DateTime.UtcNow.AddSeconds(2));
}
public async Task <string> GetAuthToken(string username, string password)
{
AuthRequest requestBody = new AuthRequest
{
Username = username,
Password = password
};
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri(APIConstants.AUTHURL),
Content = new StringContent(JsonConvertService.SerializeToJson(requestBody), Encoding.UTF8, "application/json")
};
httpClient.ApiClient.DefaultRequestHeaders.Clear();
using (HttpResponseMessage response = await httpClient.ApiClient.SendAsync(request))
{
if (response.IsSuccessStatusCode)
{
BearerToken token = Newtonsoft.Json.JsonConvert.DeserializeObject <BearerToken>(response.Content.ReadAsStringAsync().Result);
return(token.Token);
}
else
{
throw new HttpRequestException();
}
}
}
protected override void Execute(CodeActivityContext context)
{
var projectID = ProjectID.Get(context);
var modelID = ModelID.Get(context);
var locationID = LocationID.Get(context);
var bearerToken = BearerToken.Get(context);
var content = Content.Get(context);
var jsonData = String.Format("{ \"payload\": { \"textSnippet\": { \"content\": \"{0}\", \"mime_type\": \"text/plain\" } } }", content);
var jsonDataBytes = Encoding.ASCII.GetBytes(jsonData);
request = HttpWebRequest.CreateHttp(String.Format("https://automl.googleapis.com/v1/projects/{0}/locations/{1}/models/{2}:predict",
projectID, locationID, modelID));
request.Method = "POST";
request.ContentType = "application/json";
request.Headers.Add(HttpRequestHeader.Authorization, $"Bearer {bearerToken}");
using (var req_stream = request.GetRequestStream())
{
req_stream.Write(jsonDataBytes, 0, jsonDataBytes.Length);
req_stream.Close();
}
var response = request.GetResponse();
}
public async Task <IResponseResult <User> > WhoAmIAsync(BearerToken bearerToken)
{
var url = $"{this.AuthApiBaseUrl}/whoami";
var headers = HeaderCollection.Add("Authorization", bearerToken.ToString());
return(await this.ExecuteRequestAsync <User>(HttpMethod.Get, url, null, headers));
}
public CallOptions ApplyCustomOptions(CallOptions custom)
{
if (custom is null)
{
return(this);
}
if (custom.Version != null)
{
Version = custom.Version;
}
Ttl = custom.Ttl;
Epoch = custom.Epoch;
if (custom.XHeaders != null)
{
XHeaders = custom.XHeaders;
}
if (custom.Session != null)
{
Session = custom.Session;
}
if (custom.Bearer != null)
{
Bearer = custom.Bearer;
}
return(this);
}
public async Task <AuthorizationResult> Authorize(string login, string password)
{
var user = await _dataProvider.Get <UserDb>()
.Where(x =>
x.NormalLogin == login.ToLower() &&
x.Password == PostgresEfExtensions.Crypt(password, x.Password)
)
.Select(x => new
{
x.Id,
Name = x.Login,
ImageUrl = x.Profile.AvatarUrl,
})
.SingleOrDefaultAsync(Context.CancellationToken);
if (user == null)
{
_logger.LogWarning("Не верный логин и/или пароль");
throw new RemoteException("Не верный логин и/или пароль");
}
// Авторизовываем текущее подключение.
BearerToken bearerToken = Context.Authorize(userId: user.Id);
_logger.LogInformation($"Авторизован пользователь: \"{login}\"");
return(new AuthorizationResult
{
BearerToken = bearerToken,
UserId = user.Id,
UserName = user.Name,
ImageUrl = new Uri(user.ImageUrl)
});
}
//TODO check token
/// <summary>
/// Get token using blizzard login credentials => authorization code
/// </summary>
/// <param name="code"></param>
/// <returns></returns>
public async Task <BearerToken> GetTokenWithAuthenticationCode(string code)
{
string path = "oauth/token";
var authToken = Encoding.ASCII.GetBytes($"{ConfigurationManager.AppSettings["client_id"]}:{ConfigurationManager.AppSettings["client_secret"]}");
AuthenticationHeaderValue authHeader = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(authToken));
List <KeyValuePair <string, string> > content = new List <KeyValuePair <string, string> >();
content.Add(new KeyValuePair <string, string>("grant_type", "authorization_code"));
content.Add(new KeyValuePair <string, string>("scope", "wow.profile openid"));
content.Add(new KeyValuePair <string, string>("redirect_uri", "https://localhost:44380/Account/Authorize"));
content.Add(new KeyValuePair <string, string>("code", code));
content.Add(new KeyValuePair <string, string>("region", "eu"));
try
{
string response = await SendPost(true, path, content, authHeader);
BearerToken token = JsonConvert.DeserializeObject <BearerToken>(response);
token.SetExpirationDate();
instance.token = token;
return(token);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
return(null);
}
public IHttpActionResult Index(LoginModel model)
{
try
{
MusicianBusiness musicianBusiness = new MusicianBusiness();
Musician user = musicianBusiness.Login(model.email, model.password);
if (user == null)
{
return(Unauthorized());
}
BearerToken bearerLogin = new BearerToken(new BearerDatabaseManager(model.email));
bearerLogin.GenerateHeaderToken(user.id.ToString(), user.email);
return(Ok(user));
}
catch (Exception ex)
{
return(BadRequest(ex.StackTrace));
return(InternalServerError(ex));
}
}
private void PopulateDefaultProperties(RateContribution rateContribution)
{
BearerToken bearerToken = new BearerToken();
var activeToken = bearerToken.GetActiveToken();
rateContribution.musician_id = int.Parse(activeToken.client);
}
public void AgregarDireccion(BearerToken token)
{
Direccion nuevaDireccion = new Direccion()
{
IdTienda = 24,
NomDirCte = "La oficina prueba",
IdTipoDomCte = 1,
NomRecibeCte = "Jesús",
IdEstadoCte = 19,
NomCiudadCte = "Monterrey",
NomColoniaCte = "Cumbres",
NomCalleCte = "Sector 8",
NumExtCalleCte = 1913,
NumIntCalleCteOpc = 1913,
CpCte = 64610,
TelefonoCte = "8711182334"
};
direccion = nuevaDireccion;
string controlador = "/api/direccion/New";
string endpoint = urlbase + controlador;
var client = new RestClient(endpoint);
client.Timeout = -1;
var request = new RestRequest(Method.POST);
request.AddHeader("bearertoken", token.AccessToken);
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", nuevaDireccion.ToJson(), ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
}
public async Task <IResponseResult <BearerToken> > RefreshTokenAsync(BearerToken bearerToken)
{
var url = $"{this.AuthApiBaseUrl}/refresh-token";
var headers = HeaderCollection.Add("Authorization", bearerToken.RefreshToken);
return(await this.ExecuteRequestAsync <BearerToken>(HttpMethod.Get, url, null, headers));
}
public IResponseResult RevokeToken(BearerToken token)
{
var url = $"{this.AuthApiBaseUrl}/revoke-token";
var headers = HeaderCollection.Add("Authorization", token.ToString());
return(this.ExecuteRequest <BearerToken>(HttpMethod.Get, url, null, headers));
}
public static async Task <string> GetRefreshToken(string RefreshToken)
{
using (var httpClient = new HttpClient())
{
Uri Endpoint = new Uri($"{AppSetting.ApiEndpoint}Token");
var tokenRequest =
new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>("grant_type", "refresh_token"),
new KeyValuePair <string, string>("refresh_token", RefreshToken)
};
HttpContent encodedRequest = new FormUrlEncodedContent(tokenRequest);
HttpResponseMessage response = await httpClient.PostAsync(Endpoint, encodedRequest);
if (response != null && response.StatusCode == System.Net.HttpStatusCode.OK)
{
string jsonResponse = response.Content.ReadAsStringAsync().Result;
SetToken(jsonResponse);
BearerToken token = JsonConvert.DeserializeObject <BearerToken>(jsonResponse);
return(token.AccessToken);
}
else
{
//Se arrivo qui allora email e password sono sbagliati.
throw new ApplicationException("Password o Email errati.");
}
}
}
public async Task <string> GetAccessToken()
{
if (token == null || token.IsExpired())
{
lock (locker)
{
if (token != null && !token.IsExpired())
{
return(token.access_token);
}
Dictionary <String, string> dic = new Dictionary <string, string>()
{
{ "grant_type", "client_credentials" },
{ "client_id", clientId },
{ "client_secret", clientSecret }
};
BearerToken bt = restClient.SubmitForm <BearerToken>(_url, dic).Result;
if (bt != null && !String.IsNullOrEmpty(bt.access_token))
{
bt.LastGetTime = DateTime.UtcNow;
//Logger.Info("获取Access Token:{0}\r\n{1}", clientId, bt.access_token);
}
token = bt;
}
}
return(token?.access_token);
}
private async Task <string> GetAzureRateCard(BearerToken bears, string subscriptionId, string offerCode, string currency, string locale, string region)
{
string rateCardApiVersion = "2015-06-01-preview";
string rateCardUrl = $@"https://management.azure.com//subscriptions//{subscriptionId}//providers//Microsoft.Commerce//RateCard?api-version={rateCardApiVersion}&$filter=OfferDurableId eq '{offerCode}' and Currency eq '{currency}' and Locale eq '{locale}' and RegionInfo eq '{region}'";
HttpResponseMessage response = null;
string responseMsg = string.Empty;
using (HttpClient client = new HttpClient())
{
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
client.DefaultRequestHeaders.Add("Authorization", bears.BearerTokenHeader);
try
{
response = await client.GetAsync(rateCardUrl);
if (response.StatusCode.Equals(HttpStatusCode.OK))
{
responseMsg = await response.Content.ReadAsStringAsync();
}
}
catch (HttpRequestException ex)
{
response.StatusCode = HttpStatusCode.BadRequest;
}
catch (Exception ex2)
{
//TODO: Show a meessage
}
}
return(responseMsg);
}
public void AccessTokenRefreshTest()
{
var request = new Mock <HttpWebRequest>();
request.Setup(obj => obj.RequestUri).Returns(new Uri("https://demo.eduvpn.nl/portal/oauth.php/token"));
request.SetupSet(obj => obj.Method = "POST");
request.SetupProperty(obj => obj.Credentials);
request.SetupProperty(obj => obj.PreAuthenticate, false);
request.SetupSet(obj => obj.ContentType = "application/x-www-form-urlencoded");
request.SetupProperty(obj => obj.ContentLength);
var request_buffer = new byte[1048576];
request.Setup(obj => obj.GetRequestStream()).Returns(new MemoryStream(request_buffer, true));
var response = new Mock <HttpWebResponse>();
response.Setup(obj => obj.GetResponseStream()).Returns(new MemoryStream(Encoding.UTF8.GetBytes(Global.AccessTokenJSON)));
response.SetupGet(obj => obj.StatusCode).Returns(HttpStatusCode.OK);
request.Setup(obj => obj.GetResponse()).Returns(response.Object);
AccessToken
token1 = new BearerToken(Global.AccessTokenObj, DateTimeOffset.Now),
token2 = token1.RefreshToken(request.Object, new NetworkCredential("username", "password"));
var request_param = HttpUtility.ParseQueryString(Encoding.ASCII.GetString(request_buffer, 0, (int)request.Object.ContentLength));
Assert.AreEqual("refresh_token", request_param["grant_type"]);
Assert.IsNotNull(request_param["refresh_token"]);
Assert.IsTrue((token1.Scope == null) == (request_param["scope"] == null));
Assert.IsTrue(token1.Scope == null || token1.Scope.SetEquals(new HashSet <string>(request_param["scope"].Split(null))));
Assert.AreEqual(token1, token2);
Assert.IsTrue(token1.Authorized == token2.Authorized);
Assert.IsTrue((token1.Expires - token2.Expires).TotalSeconds < 60);
Assert.IsTrue((token1.Scope == null) == (token2.Scope == null));
Assert.IsTrue(token1.Scope == null || token1.Scope.SetEquals(token2.Scope));
}
public IResponseResult <User> WhoAmI(BearerToken bearerToken)
{
var url = $"{this.BaseUrl}/whoami";
var headers = HeaderCollection.Add("Authorization", bearerToken.ToString());
return(this.ExecuteRequest <User>(HttpMethod.Get, url, null, headers));
}
public async Task Token_Ok()
{
//Arrage
var token = new BearerToken()
{
Access_token = "1234token",
User_email = "*****@*****.**"
};
var claims = new[] {
new Claim(ClaimsIdentity.DefaultNameClaimType, "*****@*****.**")
};
var identity = new ClaimsIdentity(claims, "Token", ClaimsIdentity.DefaultNameClaimType, null);
authService.Setup(x => x.GetIdentityAsync(It.IsAny <string>(), It.IsAny <string>()))
.Returns(Task.FromResult(identity));
authService.Setup(x => x.GetBearerToken(identity))
.Returns(token);
//Act
var action = await controller.Token(new UserLoginPostModel { Password = "******", Email = "*****@*****.**" });
//Assert
var result = Assert.IsType <OkObjectResult>(action);
Assert.Equal(token.Access_token, "1234token");
}
public async Task <IResponseResult <BearerToken> > VerifyTokenAsync(BearerToken token)
{
var url = $"{this.AuthApiBaseUrl}/verify-token";
var headers = HeaderCollection.Add("Authorization", token.ToString());
return(await this.ExecuteRequestAsync <BearerToken>(HttpMethod.Get, url, null, headers));
}
public async Task <IResponseResult> RevokeTokenAsync(BearerToken token, bool logoutFromAllDevices = false)
{
var url = $"{this.BaseUrl}/revoke-token";
var headers = HeaderCollection.Add("Authorization", token.ToString());
var queryString = logoutFromAllDevices ? QueryString.Add("logout-all", true) : QueryString.Empty;
return(await this.ExecuteRequestAsync(HttpMethod.Get, url, queryString, headers));
}
public IResponseResult <BearerToken> RefreshToken(BearerToken bearerToken)
{
var url = $"{this.BaseUrl}/refresh-token";
var headers = HeaderCollection.Add("Authorization", bearerToken.RefreshToken);
var response = this.ExecuteRequest(HttpMethod.Get, url, null, headers);
return(ConvertToBearerTokenResponse(response));
}
public static void TestBearerTokenV3(Scope scope, string expectedToken)
{
TestScope(scope, ScopeTypes.BearerToken);
Assert.True(scope is BearerToken);
BearerToken token = scope as BearerToken;
Assert.Equal(expectedToken, token.Token);
}
public TokenBundle
(
BearerToken bearerToken,
RefreshToken refreshToken
)
{
BearerToken = bearerToken;
RefreshToken = refreshToken;
}
public static int GetLoggedUserId()
{
BearerToken bearerToken = new BearerToken(new BearerDatabaseManager());
var activeToken = bearerToken.GetActiveToken();
var retorno = int.Parse(activeToken.client);
return(retorno);
}
public void BearerTokenSerialization()
{
BearerToken constScope = JsonConvert.DeserializeObject <Scope>(BEARERTOKEN) as BearerToken;
BearerToken scope = new BearerToken("access-token-from-Amazon");
//Context check
Assert.Equal(constScope.Type, scope.Type);
Assert.Equal(constScope.Token, scope.Token);
}
