public SkillResponse Handle(SkillRequest skillRequest, TokenUser tokenUser)
{
if (!base.skillRequestValidator.IsValid(skillRequest))
{
throw new ArgumentNullException("skillRequest");
}
if (tokenUser == null)
{
throw new ArgumentNullException("tokenUser");
}
logger.LogTrace("BEGIN ResetAllPoints. RequestId: {0}.", skillRequest.Request.RequestId);
SkillResponse response;
tokenUser.Players = tokenUser.Players.Select(x => new Player()
{
Name = x.Name, Points = 0
}).ToList();
response = string.Format("Okay, I reset all of the tokens' points to zero.").Tell(true);
logger.LogTrace("END ResetAllPoints. RequestId: {0}.", skillRequest.Request.RequestId);
return(response);
}
public void Tweet_PublishWithBigURL()
{
IToken token = TokenSingleton.Instance;
TokenUser currentUser = new TokenUser(token);
string messageWithoutUrl = "Hello Tweetinvi! I believe that your API is great at this date of ("
+ DateTime.Now + ") - ";
string messageUrl = "https://maps.google.com/?ie=UTF8&ll=51.502759,-0.13278&spn=" +
"0.03211,0.084543&t=h&z=14&vpsrc=6&iwloc=A" +
"&q=Saint+James+Park&cid=18398735506960162143";
string bigString = messageWithoutUrl + messageUrl;
Assert.AreEqual(messageWithoutUrl.Length < 140 - 22, true);
Assert.AreEqual(messageUrl.Length > 22, true);
Assert.AreEqual(bigString.Length > 140, true);
// Create Tweet locally
ITweet tweet = new Tweet(bigString, token);
// Send the Tweet
tweet.Publish();
Assert.AreNotEqual(tweet.Id, null);
Assert.AreEqual(currentUser.Equals(tweet.Creator), true);
Assert.AreEqual(tweet.IsTweetPublished, true);
tweet.Destroy();
}
public bool VerifyToken(string userName, string token, out TokenUser user)
{
try
{
if (string.IsNullOrWhiteSpace(userName) || string.IsNullOrWhiteSpace(token))
{
user = null;
return(false);
}
if (!_dictToken.ContainsKey(userName))
{
MemberUser memberUser;
if (_userWorker.ValidateToken(userName, token, out memberUser) == true)
{
_dictToken.Add(userName, new TokenUser(memberUser));
}
}
if (_dictToken.ContainsKey(userName))
{
if (_dictToken[userName].Token == token)
{
user = _dictToken[userName];
return(true);
}
}
}
catch
{
}
user = null;
return(false);
}
public void RemoveTokenUser(TokenUser user)
{
if (user != null)
{
RemoveTokenUser(user.UserName);
}
}
public async Task <TokenUser> Token(string url, string consumerKey, string token, string verifier)
{
var accessTokenDto = new comum_dto.oauth.OAuth10Parametros(consumerKey, token, verifier);
httpClient.DefaultRequestHeaders.Clear();
var content = new FormUrlEncodedContent(accessTokenDto.ObterParametros());
var requestUri = $"{url}/oauth/access_token";
var response = await httpClient.PostAsync(requestUri, content);
response.EnsureSuccessStatusCode();
string result = response.Content.ReadAsStringAsync().Result;
var querystring = HttpUtility.ParseQueryString(result);
var tokenUser = new TokenUser()
{
oauth_token = querystring["oauth_token"],
oauth_token_secret = querystring["oauth_token_secret"],
user_id = querystring["user_id"]
};
return(tokenUser);
}
private void SendConexionEmail(Usuario user, TokenUser userToken)
{
//Para recepción -ellos reciben
//tokenID = (Token generado en el aplicativo)
//subscriptionName = (Nombre de registro normalizado)
//tokenAPI = (token full)
var datos = new string[7];
//Datos para envío
datos[0] = userToken.SignToken;
datos[1] = userToken.Token;
datos[2] = user.NombreSuscripcion;
//Datos para Respuesta
datos[3] = "H-jsdfbKLiRvc_vXshLQpC1QnUQlpwleDfFNU5wjnyMhu4";
datos[4] = "respuesta_proveedores";
datos[5] = "{'topicName':'',subscriptionName':'',messageBody':'',tokenID':''}";
datos[6] = user.Nombre;
var body = TemplateHtml.GetTemplateForNewSupply(datos);
MessageServiceMail serviceMail =
new MessageServiceMail(_configuration);
serviceMail.SendEmailAsync(user.Nombre, user.Email, "Parámetros de Configuración", body, null).GetAwaiter().GetResult();
}
public void Constructor_ReturnsInstanceOfClass()
{
string expectedId = "TestId";
DateTime expectedCreateDate = DateTime.Now;
DateTime expectedUpdateDate = DateTime.Now;
string expectedPasswordHash = "TestPasswordHash";
bool expectedHasPointsPersistence = false;
long expectedTTL = 123456789;
List <Player> expectedPlayers = new List <Player>()
{
new Player()
{
Name = "TestPlayerName", Points = 3
}
};
TokenUser tokenUser = new TokenUser();
tokenUser.Id = expectedId;
tokenUser.CreateDate = expectedCreateDate;
tokenUser.UpdateDate = expectedUpdateDate;
tokenUser.PasswordHash = expectedPasswordHash;
tokenUser.HasPointsPersistence = expectedHasPointsPersistence;
tokenUser.TTL = expectedTTL;
tokenUser.Players = expectedPlayers;
Assert.IsType <TokenUser>(tokenUser);
Assert.Equal(tokenUser.Id, expectedId);
Assert.Equal(tokenUser.CreateDate, expectedCreateDate);
Assert.Equal(tokenUser.UpdateDate, expectedUpdateDate);
Assert.Equal(tokenUser.PasswordHash, expectedPasswordHash);
Assert.Equal(tokenUser.HasPointsPersistence, expectedHasPointsPersistence);
Assert.Equal(tokenUser.TTL, expectedTTL);
Assert.True(tokenUser.Players.SequenceEqual(expectedPlayers));
}
public async Task GetSkillResponse_ShouldThrowNotSupportedException_WhenIntentNameIsUnknown()
{
SkillResponse expectedSkillResponse = string.Format("Okay").Tell(true);
Mock <ISkillRequestValidator> mockSkillRequestValidator = new Mock <ISkillRequestValidator>();
mockSkillRequestValidator.Setup(x => x.IsValid(It.IsAny <SkillRequest>())).Returns(true);
Mock <ILogger <IntentRequestRouter> > mockLogger = new Mock <ILogger <IntentRequestRouter> >();
Mock <IIntentRequestHandler> mockIntentRequestHandler = new Mock <IIntentRequestHandler>();
mockIntentRequestHandler.Setup(x => x.HandlerName).Returns(IntentRequestName.AddPoints);
mockIntentRequestHandler.Setup(x => x.Handle(It.IsAny <SkillRequest>(), It.IsAny <TokenUser>())).Returns(expectedSkillResponse);
List <Mock <IIntentRequestHandler> > mockRequestHandlers = new List <Mock <IIntentRequestHandler> >();
mockRequestHandlers.Add(mockIntentRequestHandler);
IntentRequestRouter sut = new IntentRequestRouter(mockSkillRequestValidator.Object, mockLogger.Object, mockRequestHandlers.Select(x => x.Object));
SkillRequest skillRequest = GenerateValidSkillRequest(new IntentRequest()
{
RequestId = "TestRequestId", Locale = "en-US", Type = "IntentRequest", Intent = new Intent()
{
ConfirmationStatus = "CONFIRMED", Name = "UnknownIntentName"
}
});
TokenUser tokenUser = new TokenUser();
await Assert.ThrowsAsync <NotSupportedException>(() => sut.GetSkillResponse(skillRequest, tokenUser));
}
public TokenUser IsTokenUserValido(string userName, string token, DateTime timeRequest)
{
TokenUser tokenUserResult = null;
IsTokenValid(userName, token, timeRequest, ref tokenUserResult);
return(tokenUserResult);
}
public async Task <Result <LoginItem> > Handle(Contract request, CancellationToken cancellationToken)
{
var user = await _userManager.FindByNameAsync(request.UserName);
if (user == null || user.IsBlocked)
{
return(Result.Fail <LoginItem>("Usuário ou Senha inválido"));
}
var result = await _userManager.CheckPasswordAsync(user, request.Password);
if (!result)
{
return(Result.Fail <LoginItem>("Usuário ou Senha inválido"));
}
var tokenResource = await _tokenGenerator.GenerateUserToken(user);
var tokenUser = new TokenUser()
{
Name = user.Name, Phone = user.Phone, Cpf = user.Cpf, Email = user.Email
};
tokenUser.ColorBaseValues = CheckUserColorPalette(tokenResource.UserId, tokenResource.Role);
tokenUser.LogoUrl = CheckUserLogo(tokenResource.UserId, tokenResource.Role);
await SaveRefreshToken(user.Id, tokenResource.RefreshToken, cancellationToken);
return(Result.Ok(new LoginItem()
{
TokenInfo = tokenResource, User = tokenUser
}));
}
public IActionResult CreateToken([FromBody] LoginModel login)
{
IActionResult response = Unauthorized();
UserModel user = Authenticate(login);
if (user != null)
{
TokenUser tokenUser = _personalContext.TokenUser.FirstOrDefaultAsync(d => d.UserId.ToString() == user.UserId).Result;
if (_personalContext.TokenUser.Contains(tokenUser))
{
_personalContext.TokenUser.Remove(tokenUser);
}
string tokenString = BuildToken(user);
string refreshToken = GenerateRefreshToken();
TokenUser newtoken = new TokenUser();
newtoken.ExpriedTime = DateTime.Now.AddDays(1);
newtoken.UserId = new Guid(user.UserId);
newtoken.RefreshToken = refreshToken;
_personalContext.TokenUser.Add(newtoken);
_personalContext.SaveChanges();
response = Ok(new { access_token = tokenString, refresh_token = refreshToken });
}
return(response);
}
public SkillResponse Handle(SkillRequest skillRequest, TokenUser tokenUser)
{
if (!base.skillRequestValidator.IsValid(skillRequest))
{
throw new ArgumentNullException("skillRequest");
}
if (tokenUser == null)
{
throw new ArgumentNullException("tokenUser");
}
logger.LogTrace("BEGIN GetAllPlayersCount. RequestId: {0}.", skillRequest.Request.RequestId);
SkillResponse response;
if (tokenUser.Players == null)
{
response = string.Format("There are no tokens in your list.").Tell(true);
}
else
{
response = string.Format("There are {0} tokens in your list.", tokenUser.Players.Count).Tell(true);
}
logger.LogTrace("END GetAllPlayersCount. RequestId: {0}.", skillRequest.Request.RequestId);
return(response);
}
private static DinazorIdentity AuthenticateMe(TokenUser tokenUser)
{
_dinazorIdentity = new DinazorIdentity();
_dinazorIdentity.TokenUser = new TokenUser();
try
{
if (tokenUser != null)
{
_dinazorIdentity.TokenUser = tokenUser;
_dinazorIdentity.IsAuthenticated = true;
}
else
{
_dinazorIdentity.TokenUser.Token = string.Empty;
_dinazorIdentity.TokenUser.Username = string.Empty;
_dinazorIdentity.TokenUser.IsAuthenticated = false;
}
return(_dinazorIdentity);
}
catch (Exception exce)
{
throw new Exception("Error while retrieving the authorization details. Please contact administrator.", exce);
}
}
public override void OnAuthorization(HttpActionContext actionContext)
{
bool isAuthorized = false;
if (actionContext.Request.Headers.Contains(Token_UserName_Key) && actionContext.Request.Headers.Contains(Token_Header_Key))
{
string cpkbUserName = actionContext.Request.Headers.GetValues(Token_UserName_Key).FirstOrDefault();
string cpkbToken = actionContext.Request.Headers.GetValues(Token_Header_Key).FirstOrDefault();
TokenUser tokenUser = null;
if (SecurityManager.VerifyToken(cpkbUserName, cpkbToken, out tokenUser))
{
if (tokenUser != null)
{
if (_authorizedRoles != null && _authorizedRoles.Length > 0)
{
isAuthorized = _authorizedRoles.Contains(tokenUser.RoleName);
}
else
{
isAuthorized = true;
}
}
}
}
if (!isAuthorized)
{
actionContext.Response = actionContext.Request.CreateResponse(HttpStatusCode.Unauthorized);
}
}
public static IToken GenerateToken(IToken consumerToken, RetrieveCaptchaDelegate getCaptchaDelegate)
{
Console.WriteLine("Starting Token Generation...");
ITokenCreator creator = new TokenCreator(consumerToken.ConsumerKey,
consumerToken.ConsumerSecret);
Console.WriteLine("Please enter the verifier key...");
IToken newToken = creator.CreateToken(getCaptchaDelegate);
if (newToken != null)
{
Console.WriteLine("Token generated!");
Console.WriteLine("Token Information : ");
Console.WriteLine("Consumer Key : {0}", newToken.ConsumerKey);
Console.WriteLine("Consumer Secret : {0}", newToken.ConsumerSecret);
Console.WriteLine("Access Token : {0}", newToken.AccessToken);
Console.WriteLine("Access Token Secret : {0}", newToken.AccessTokenSecret);
ITokenUser loggedUser = new TokenUser(newToken);
Console.WriteLine("Your name is {0}!", loggedUser.ScreenName);
return(newToken);
}
Console.WriteLine("Token could not be generated. Please login and specify your verifier key!");
return(null);
}
public static void Broadcast(TokenUser tokenUser)
{
foreach (var item in SubscriberList)
{
item.Notify(tokenUser);
}
}
public SkillResponse Handle(SkillRequest skillRequest, TokenUser tokenUser)
{
if (!base.skillRequestValidator.IsValid(skillRequest))
{
throw new ArgumentNullException("skillRequest");
}
if (tokenUser == null)
{
throw new ArgumentNullException("tokenUser");
}
logger.LogTrace("BEGIN RefundSubscription. RequestId: {0}.", skillRequest.Request.RequestId);
CancelDirective directive = new CancelDirective(Configuration.File.GetSection("InSkillProducts").GetSection("PointsPersistence")["Id"], "correlationToken");
SkillResponse response = ResponseBuilder.Empty();
response.Response.ShouldEndSession = true;
response.Response.Directives.Add(directive);
logger.LogTrace("END RefundSubscription. RequestId: {0}.", skillRequest.Request.RequestId);
return(response);
}
public bool AutorizarAccesoLDAP()
{
try
{
//TokenUser usuarioToken = UsersLog.UsersOnline.Where(q => q.UserName.Equals(this._usuarioName, StringComparison.InvariantCultureIgnoreCase)).Select(q => q).FirstOrDefault();
TokenUser usuarioToken = null;
UsuarioContext bs = new UsuarioContext();
if (usuarioToken == null)
{
if (ValidarAccesoLDAP(this._usuarioName, this._passwd))
{
return(true);
}
else
{
return(false);
}
}
else
{
this._User = usuarioToken;
return(IsTokenValid(this._User.UserName, this._User.Token, DateTime.Now, ref this._User));
}
}
catch (Exception ex)
{
throw ex;
}
}
private async Task <TokenUser> GenerateToken(User model)
{
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_appSettings.Secret);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.NameIdentifier, model.Username),
new Claim(ClaimTypes.Name, string.Format("{0}, {1}", model.FirstName, model.LastName))
}),
Expires = DateTime.UtcNow.AddHours(3), // Se configura para que expire dentro de 3 horas, sacar luego
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
var jwtSecurityToken = tokenHandler.WriteToken(token);
TokenUser tokenUser;
//Registro en base el token para el usuario con su expiracion
tokenUser = new TokenUser()
{
IdUser = model.IdUser,
Token = jwtSecurityToken,
InitDate = DateTime.Now,
EndDate = tokenDescriptor.Expires
};
await _genericRepositoryToken.AddAsync(tokenUser);
return(tokenUser);
}
public bool ValidateAndExtract(HttpContext context, string token)
{
try
{
_logger.LogDebug("TokenValidator, ValidateAndExtract, Parameters token:{token}", token);
var claims = GetClaims(token);
if (!claims.Any())
{
return(false);
}
var user = new TokenUser
{
Token = token,
Id = int.Parse(claims.First(x => x.Type == "id").Value),
Type = Enum.Parse <UserType>(claims.First(x => x.Type == "type").Value)
};
_logger.LogDebug("TokenValidator, ValidateAndExtract, User Id: {id}", user.Id);
context.Items["User"] = user;
return(true);
}
catch (Exception exception)
{
_logger.LogError(exception, exception.Message);
return(false);
}
}
public async Task <TokenUser> Get(string id)
{
if (String.IsNullOrWhiteSpace(id))
{
throw new ArgumentNullException("id");
}
TokenUser tokenUser = await _tokenUserRepository.Load(id);
// If TTL has passed then force delete the TokenUser and return null
if (tokenUser != null && tokenUser.TTL != null)
{
double secondsRemaining = tokenUser.TTLSecondsRemaining();
bool isExpired = secondsRemaining <= 0;
if (isExpired)
{
_logger.LogInformation("Deleting expired User. User Id: {0}, TTL Seconds Remaining: {1}.", tokenUser.Id, secondsRemaining);
await _tokenUserRepository.Delete(id);
tokenUser = null;
}
}
return(tokenUser);
}
public async Task GetSkillResponse_ShouldReturnSkillResponse_WhenInputsAreInvalid()
{
SkillResponse expectedSkillResponse = new SkillResponse();
Mock <ISkillRequestValidator> mockSkillRequestValidator = new Mock <ISkillRequestValidator>();
mockSkillRequestValidator.Setup(x => x.IsValid(It.IsAny <SkillRequest>())).Returns(true);
Mock <ILogger <IntentRequestRouter> > mockLogger = new Mock <ILogger <IntentRequestRouter> >();
Mock <IIntentRequestHandler> mockIntentRequestHandler = new Mock <IIntentRequestHandler>();
mockIntentRequestHandler.Setup(x => x.HandlerName).Returns(IntentRequestName.AddPoints);
mockIntentRequestHandler.Setup(x => x.Handle(It.IsAny <SkillRequest>(), It.IsAny <TokenUser>())).Returns(expectedSkillResponse);
List <Mock <IIntentRequestHandler> > mockRequestHandlers = new List <Mock <IIntentRequestHandler> >();
mockRequestHandlers.Add(mockIntentRequestHandler);
IntentRequestRouter sut = new IntentRequestRouter(mockSkillRequestValidator.Object, mockLogger.Object, mockRequestHandlers.Select(x => x.Object));
SkillRequest skillRequest = GenerateValidSkillRequest(new IntentRequest()
{
RequestId = "TestRequestId", Locale = "en-US", Type = "IntentRequest", Intent = new Intent()
{
ConfirmationStatus = "CONFIRMED", Name = "AddPoints"
}
});
TokenUser tokenUser = new TokenUser();
SkillResponse skillResponse = await sut.GetSkillResponse(skillRequest, tokenUser);
Assert.IsType <SkillResponse>(skillResponse);
}
public static string TTLPhrase(this TokenUser tokenUser)
{
double secondsLeft = tokenUser.TTLSecondsRemaining();
double minutesLeft = Math.Ceiling(secondsLeft / 60);
if (secondsLeft > 60)
{
return(string.Format("for {0} more minutes", minutesLeft));
}
else if (secondsLeft == 60)
{
return(string.Format("for {0} more minute", minutesLeft));
}
else if (secondsLeft < 60 && secondsLeft > 0)
{
if (secondsLeft == 1)
{
return(string.Format("for {0} more second", secondsLeft));
}
return(string.Format("for {0} more seconds", secondsLeft));
}
return("momentarily");
}
public void TokenUserConstructor()
{
TokenUser me = new TokenUser(TokenTestSingleton.Instance);
IUser userMe = new User(TokenTestSingleton.ScreenName, TokenTestSingleton.Instance);
Assert.AreEqual(TokenTestSingleton.ScreenName, me.ScreenName);
Assert.AreEqual(userMe.Equals(me), true);
}
public void UserSuggestedUsers()
{
ITokenUser u = new TokenUser(TokenTestSingleton.Instance);
List <ISuggestedUserList> userList = u.GetSuggestedUserList();
Assert.AreNotEqual(userList, null);
Assert.AreNotEqual(userList.Count, 0);
}
public void UserGetBlockedUsers()
{
ITokenUser u = new TokenUser(TokenTestSingleton.Instance);
List <IUser> users = u.GetBlockedUsers();
Assert.AreNotEqual(users, null);
Assert.AreNotEqual(users.Count, 0);
}
public void UserGetMentions()
{
ITokenUser u = new TokenUser(TokenTestSingleton.Instance);
List <IMention> mentions = u.GetLatestMentionsTimeline();
Assert.AreNotEqual(mentions, null);
Assert.AreNotEqual(mentions.Count, 0);
}
public void AddUpsellDirective(TokenUser tokenUser, SkillResponse response)
{
string message = string.Format("Your tokens will only be availble {0} without a subscription to {1}. Do you want to know more about the subscription?", tokenUser.TTLPhrase(), Configuration.File.GetSection("InSkillProducts").GetSection("PointsPersistence")["Name"]);
UpsellDirective directive = new UpsellDirective(Configuration.File.GetSection("InSkillProducts").GetSection("PointsPersistence")["Id"], "correlationToken", message);
response.Response.Directives.Add(directive);
tokenUser.UpsellTicks = 0;
}
public void UserGetHomeTimeline()
{
ITokenUser u = new TokenUser(TokenTestSingleton.Instance);
List <ITweet> tweets = u.GetHomeTimeline(20, true, true);
Assert.AreNotEqual(tweets, null);
Assert.AreNotEqual(tweets.Count, 0);
}
public async Task Save(TokenUser user)
{
if (user == null)
{
throw new ArgumentNullException("user");
}
await _context.SaveAsync <TokenUser>(user);
}
public void SendError(ScoreInfo invalidScore, UnrecognisedTokenException exception)
{
try
{
var sendNotifications = bool.Parse(ConfigurationManager.AppSettings["SendNotifications"]);
if (!sendNotifications) return;
var user = new TokenUser(TokenSingleton.Token);
var tweet = string.Format("@{0} Unrecognised token: \"{1}\". Language spec: http://t.co/mESKiN9qSS",
invalidScore.Username,
exception.Message.Length > tokenLength ? exception.Message.Substring(0, tokenLength) : exception.Message);
user.PublishTweet(tweet);
}
catch (Exception)
{
// ToDo: implement UI notifications
}
}
private void Follow(string userId)
{
_logger.InfoFormat("Attempting to follow {0}", userId);
var me = new TokenUser(_twitterToken);
_logger.Info("Got tokenuser");
var toFollow = new User(userId, _twitterToken);
_logger.Info("Got toFollow");
me.Follow(toFollow, true);
_logger.InfoFormat("Followed user {0}", userId);
}
