public async Task<IActionResult> IssueToken([FromBody] BearerTokenRequest model)
{
if (!ValidModelState(out var error))
return error;
TUser user;
switch (model.IdentityType)
{
case IdentityType.Username:
user = await _userManager.FindByNameAsync(model.Identity);
break;
case IdentityType.Email:
user = await _userManager.FindByEmailAsync(model.Identity);
if (!user.EmailConfirmed)
return NotFound();
break;
case IdentityType.PhoneNumber:
user = await _userManager.FindByPhoneNumberAsync(model.Identity);
if (!user.PhoneNumberConfirmed)
return NotFound();
break;
default:
throw new ArgumentOutOfRangeException();
}
if (user == null)
return NotFound();
if (user.LockoutEnd.HasValue && user.LockoutEnd > _timestamps.GetCurrentTime())
return Forbid();
if (await _userManager.CheckPasswordAsync(user, model.Password))
{
Debug.Assert(nameof(IUserIdProvider.Id) == nameof(IdentityUser.Id));
var claims = await _userManager.GetClaimsAsync(user);
if (HttpContext.GetTenantContext<TTenant>() is TenantContext<TTenant> tenantContext)
{
if (tenantContext.Tenant != null)
{
claims.Add(new Claim(_securityOptions.Value.Claims.TenantIdClaim, tenantContext.Tenant.Id));
claims.Add(new Claim(_securityOptions.Value.Claims.TenantNameClaim, tenantContext.Tenant.Name));
}
}
var provider = user.ActLike<IUserIdProvider>();
var token = JwtSecurity.CreateToken(provider, claims, _securityOptions.Value, _apiOptions.Value);
return Ok(new
{
AccessToken = token
});
}
return Unauthorized();
}
/// <summary>
/// GetBearerToken will swap the provided accessCode and clientSecretKey for a bearer token.
/// The bearer token is essentially the session id for the caller on behalf of the user who
/// produced this access code.
/// </summary>
/// <param name="client">DigivanceClient</param>
/// <param name="accessCode">The access_code returned from Digivance auth process</param>
/// <param name="clientSecretKey">Your product's clientSecretKey</param>
/// <returns>The bearer token that can be used to call functions on behalf of this user</returns>
public async static Task <string> GetBearerToken(this DigivanceClient client, string accessCode, string clientSecretKey)
{
BearerTokenRequest bearerTokenRequest = new BearerTokenRequest {
AccessCode = accessCode,
ClientSecretKey = clientSecretKey
};
HttpResponseMessage response = await client.PostAsJsonAsync($"{client.BaseAddress}/auth/bearertoken", bearerTokenRequest);
if (response.StatusCode != HttpStatusCode.OK)
{
string payload = await response.Content.ReadAsStringAsync();
ErrorResponse res = JsonConvert.DeserializeObject <ErrorResponse>(payload);
throw new Exception(res.Message);
}
client.BearerToken = client.GetCookie("BearerToken");
return(client.BearerToken);
}
public static void Main(string[] args)
{
Uri tokenUri = new Uri("https://api.twitter.com/oauth2/token");
Uri userTimelineUri = new Uri("https://api.twitter.com/1.1/statuses/user_timeline.json");
var twitter = new Twitter();
var credential = new BearerTokenCredential(ConsumerKey, ConsumerSecret);
var tokenRequest = new BearerTokenRequest(credential, tokenUri);
IBearerToken token= twitter.RequestBearerToken(tokenRequest);
Console.WriteLine(token);
string screenName = "JohnRentoul";
var tweetsRequest = new TweetRequest(token, userTimelineUri, screenName);
var tweets = twitter.GetTweets(tweetsRequest);
Console.WriteLine();
Console.WriteLine("--------");
Console.WriteLine();
List<SyndicationItem> items = new List<SyndicationItem>();
int counter = 0;
foreach (var tweet in tweets)
{
if (tweet.ContainsLinks)
{
counter++;
foreach (var link in tweet.Links)
{
Console.WriteLine(link.AbsoluteUri);
}
StringBuilder content = new StringBuilder();
content.AppendLine(tweet.text);
foreach(var link in tweet.Links)
{
string linkTag = string.Format(@"<a href='{0}'>{0}</>", link.AbsoluteUri);
content.AppendLine(linkTag);
}
SyndicationItem item = new SyndicationItem(screenName + counter, content.ToString(), new Uri("http://localhost"));
items.Add(item);
}
}
var syndicationFeed = new SyndicationFeed("LinkTwrapper", "Tweets containing links", new Uri("http://localhost"))
{ Items = items };
string timestamp = DateTime.Now.ToString("yyyy-MM-dd_hhmmssfff");
string filePath = string.Format(@"C:\WS\LinkTwrapper\RSSFiles\Tweets{0}.rss", timestamp);
using (var fileStream = File.Create(filePath))
{
using (var xmlWriter = XmlWriter.Create(fileStream))
{
syndicationFeed.SaveAsRss20(xmlWriter);
xmlWriter.Flush();
}
}
Console.ReadLine();
}
public async Task <IActionResult> IssueToken([FromBody] BearerTokenRequest model)
{
if (!Debugger.IsAttached)
{
return(NotImplemented());
}
#if DEBUG
var superUser = _securityOptions.Value.SuperUser;
if (!superUser.Enabled)
{
return(NotFound());
}
if (!ValidModelState(out var error))
{
return(error);
}
bool isSuperUser;
switch (model.IdentityType)
{
case IdentityType.Username:
isSuperUser = superUser.Username == model.Identity;
if (!isSuperUser)
{
return(NotFound());
}
break;
case IdentityType.Email:
isSuperUser = superUser.Email == model.Identity;
if (!isSuperUser)
{
return(NotFound());
}
break;
case IdentityType.PhoneNumber:
isSuperUser = superUser.PhoneNumber == model.Identity;
if (!isSuperUser)
{
return(NotFound());
}
break;
default:
throw new ArgumentOutOfRangeException();
}
var encoding = Encoding.UTF8;
if (Crypto.ConstantTimeEquals(encoding.GetBytes(model.Password), encoding.GetBytes(_securityOptions.Value.SuperUser.Password)))
{
Debug.Assert(nameof(IUserIdProvider.Id) == nameof(IObject.Id));
var claims = new List <Claim>
{
new Claim(ClaimTypes.Role, nameof(SecurityOptions.SuperUser))
};
var provider = new { Id = "87BA0A16-7253-4A6F-A8D4-82DFA1F723C1" }.ActLike <IUserIdProvider>();
var token = JwtSecurity.CreateToken(provider, claims, _securityOptions.Value, _apiOptions.Value);
return(Ok(new { AccessToken = token }));
}
return(Unauthorized());
#endif
return(NotImplemented());
}
