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); }