public void Authenticate(string name, string password, bool ssl = true) { user = reddit.LogIn(name, password, ssl); if (user == null) throw new BotException($"Login failed. User: {name}"); Console.WriteLine($"Logged in as {user.Name}"); }
public static AuthenticatedUser FromString(string data) { string[] arr = data.Split('\n'); AuthenticatedUser user = new AuthenticatedUser(); user.ID = Convert.ToInt32(arr[0]); user.Name = arr[1]; user.Role = GetSecurityRoleById(user.ID); return user; }
public async Task Delete__User_Can_Delete_His_Private_Training() { AuthenticatedUser user = await LogInAs("*****@*****.**"); Training training = await CreatePrivateTraining(user.Id); string deleteEndpoint = ApiRoutes.Training.Delete.Replace("{trainingId}", training.Id.ToString()); var response = await Client.DeleteAsync(deleteEndpoint); response.StatusCode.Should().Be(HttpStatusCode.NoContent); int trainingCount = await Context.Training.AsNoTracking().CountAsync(); trainingCount.Should().Be(0); int userTrainingCount = await Context.UserTraining.AsNoTracking().CountAsync(); userTrainingCount.Should().Be(0); }
public void SignIn_With_Invalid_Credentials_Returns_InvalidCredentials_View() { _dataAccessor.Setup(d => d.VerifyCredentials("Test User", "TestPass!")).Returns(false); var authenticatedUser = new AuthenticatedUser { Username = "******", Password = "******" }; var result = _controller.SignIn(authenticatedUser); Assert.NotNull(result); var viewResult = result as ViewResult; Assert.NotNull(viewResult); Assert.AreEqual("InvalidCredentials", viewResult.ViewName); _dataAccessor.Verify(d => d.VerifyCredentials("Test User", "TestPass!"), Times.Once); }
private void TestIsLoginDiscontinued(string credentialType, bool isOnWhiteList, bool isOnDomainList, bool isOnExceptionList, bool isOnTransformList, bool isWrongCase, bool expectedResult) { // Arrange var credential = new Credential(credentialType, "value"); var user = new User("test") { EmailAddress = _email, Credentials = new[] { credential } }; var authUser = new AuthenticatedUser(user, credential); var config = CreateConfiguration(isOnWhiteList, isOnDomainList, isOnExceptionList, isOnTransformList, isOnTenantPairList: false, isWrongCase: isWrongCase); // Act var result = config.IsLoginDiscontinued(authUser); // Assert Assert.Equal(expectedResult, result); }
public UserComments Exec(SqlConnection db, AuthenticatedUser au, int skip, int take) { var retComments = new UserComments(); foreach (var item in repository.UserComments(db, au.Id, skip, take, ref retComments.total)) { retComments.list.Add(new UserCommentInformation { Comment = item.Comment, Date = item.DateAdded, ProductName = "x", ProductCategory = "y", ProductId = 1 }); } return(retComments); }
private async Task <AuthenticatedUser> AssociateCredential(AuthenticatedUser user) { var result = await _authService.ReadExternalLoginCredential(OwinContext); if (result.ExternalIdentity == null) { // User got here without an external login cookie (or an expired one) // Send them to the logon action return(null); } await _authService.AddCredential(user.User, result.Credential); // Notify the user of the change _messageService.SendCredentialAddedNotice(user.User, result.Credential); return(new AuthenticatedUser(user.User, result.Credential)); }
public async Task Get_Friends_As_New_User() { // Arrange var expected = 0; var user = new AuthenticatedUser() { Name = "abc", PreferredUsername = "******", UserIdentifier = "u", ProviderIdentifier = "p" }; // Act var actual = await _friendsHandler.GetFriendsAsync(user); // Assert Assert.Equal(expected, actual.Count); }
public async Task Login() { try { ErrorMessage = string.Empty; AuthenticatedUser result = await _apiHelper.Authenticate(Username, Password); // Retrieve the additional information about the user await _apiHelper.GetLoggedInUserInfo(result.AccessToken); // Push the event for the login _events.PublishOnUIThread(new LogOnEvent()); } catch (Exception e) { ErrorMessage = e.Message; } }
private AuthenticatedUser getUserID(string token) { AuthenticatedUser user = new AuthenticatedUser(); SqlConnection con = new SqlConnection(System.Configuration.ConfigurationManager.ConnectionStrings["MS_TableConnectionString"].ConnectionString); con.Open(); try { SqlCommand cmd = new SqlCommand("SELECT Token.UserID, Expires, UserTypeID FROM Token " + "INNER JOIN Users " + "On Token.UserID = Users.UserID " + "WHERE Token = @token", con); cmd.Parameters.AddWithValue("@token", token); SqlDataReader reader = cmd.ExecuteReader(); if (reader.HasRows) { while (reader.Read()) { user.UserID = reader.GetInt32(0); DateTime time = reader.GetDateTime(1); if (time < DateTime.Now) { deleteToken(user.UserID); user.UserID = 0; return(user); } user.UserTypeID = reader.GetInt32(2); con.Close(); return(user); } return(user); } else { return(user); } } catch (Exception) { con.Close(); return(user); } }
public async Task ItShouldRunTheDownloader() { var parameters = DownloadMonitorCommand.Parameters.Random(); this.ensureAuthenticated.ExecuteAsync().Returns(Task.FromResult(AuthenticatedUser.Random())); var createdInputFolder = SingletonRandom.Instance.NextString(); this.getCreatedOutputFolder.Execute(parameters.InputFolder).Returns(createdInputFolder); var createdOutputFolder = SingletonRandom.Instance.NextString(); this.getCreatedOutputFolder.Execute(parameters.OutputFolder).Returns(createdOutputFolder); this.monitorDownloads.ExecuteAsync( Arg.Any <ChannelWriter <QueuedDownloadToken> >(), Arg.Any <string>(), Arg.Any <CancellationToken>()).Returns(Task.CompletedTask); this.processDownloads.ExecuteAsync( Arg.Any <ChannelReader <QueuedDownloadToken> >(), Arg.Any <string>(), Arg.Any <bool>(), Arg.Any <bool>(), Arg.Any <string>(), Arg.Any <string>(), Arg.Any <CancellationToken>()).Returns(Task.CompletedTask); await this.target.ExecuteAsync(parameters); await this.monitorDownloads.Received(1).ExecuteAsync( Arg.Any <ChannelWriter <QueuedDownloadToken> >(), createdInputFolder, Arg.Any <CancellationToken>()); await this.processDownloads.Received(1).ExecuteAsync( Arg.Any <ChannelReader <QueuedDownloadToken> >(), createdOutputFolder, parameters.GenerateCsv, parameters.KeepBinary, parameters.PostProcessor, parameters.PostProcessorArguments, Arg.Any <CancellationToken>()); }
public async Task WillNotSendConfirmationEmailWhenConfirmEmailAddressesIsOff() { // Arrange var authUser = new AuthenticatedUser( new User("theUsername") { UnconfirmedEmailAddress = "*****@*****.**", EmailConfirmationToken = "t0k3n" }, new Credential()); var configurationService = GetConfigurationService(); configurationService.Current.ConfirmEmailAddresses = false; GetMock <AuthenticationService>() .Setup(x => x.Register("theUsername", "*****@*****.**", It.IsAny <Credential>())) .CompletesWith(authUser); var controller = GetController <AuthenticationController>(); GetMock <AuthenticationService>() .Setup(x => x.CreateSessionAsync(controller.OwinContext, authUser)) .Returns(Task.FromResult(0)) .Verifiable(); // Act var result = await controller.Register( new LogOnViewModel() { Register = new RegisterViewModel { Username = "******", Password = "******", EmailAddress = "*****@*****.**", } }, "/theReturnUrl", linkingAccount : false); // Assert GetMock <IMessageService>() .Verify(x => x.SendNewAccountEmail( It.IsAny <MailAddress>(), It.IsAny <string>()), Times.Never()); }
public async Task <IActionResult> Login([FromForm] LoginModel loginModel, string returnUrl = "/") { if (!ModelState.IsValid) { return(View(loginModel)); } AuthenticatedUser authenticatedUser = null; try { authenticatedUser = _apiFacade.LoginUser(loginModel.EmailAddress, PasswordFunctions.GetSHA256(loginModel.Password)); } catch (Exception ex) { if (!ex.Message.Contains("Unauthorized")) { ModelState.AddModelError("Authenitcation Error", "There was an error logging you in: " + ex.Message); return(View()); } } if (authenticatedUser != null && !string.IsNullOrWhiteSpace(authenticatedUser.JsonToken)) { var identity = new ClaimsIdentity(CookieAuthenticationDefaults.AuthenticationScheme); identity.AddClaim(new Claim(ClaimTypes.Name, loginModel.EmailAddress)); identity.AddClaim(new Claim(ClaimTypes.Sid, authenticatedUser.JsonToken)); identity.AddClaim(new Claim(ClaimTypes.NameIdentifier, authenticatedUser.Id.ToString())); SetRoles(authenticatedUser, identity); await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, new ClaimsPrincipal(identity), new AuthenticationProperties { IsPersistent = loginModel.RememberMe, ExpiresUtc = DateTime.UtcNow.AddHours(_appSettings.Value.TokenTimeOutInHours) }); return(RedirectToLocal(returnUrl)); } else { ViewBag.Message = "Password or Email address is invalid."; return(View()); } }
public async Task WillCreateAndLogInTheUserWhenNotLinking() { // Arrange var authUser = new AuthenticatedUser( new User("theUsername") { UnconfirmedEmailAddress = "*****@*****.**", EmailConfirmationToken = "t0k3n" }, new Credential()); GetMock <AuthenticationService>() .Setup(x => x.Register("theUsername", "*****@*****.**", It.IsAny <Credential>())) .CompletesWith(authUser); var controller = GetController <AuthenticationController>(); GetMock <AuthenticationService>() .Setup(x => x.CreateSession(controller.OwinContext, authUser.User)) .Verifiable(); // Act var result = await controller.Register( new LogOnViewModel() { Register = new RegisterViewModel { Username = "******", Password = "******", EmailAddress = "*****@*****.**", } }, "/theReturnUrl", linkingAccount : false); // Assert GetMock <AuthenticationService>().VerifyAll(); var expectedAddress = new MailAddress(authUser.User.UnconfirmedEmailAddress, authUser.User.Username); GetMock <IMessageService>() .Verify(x => x.SendNewAccountEmail( expectedAddress, "https://nuget.local/account/confirm/theUsername/t0k3n")); ResultAssert.IsSafeRedirectTo(result, "/theReturnUrl"); }
public async Task GivenNoLinkButEmailMatchingLocalUser_ItDisplaysLogOnViewPresetForSignIn() { // Arrange var fakes = Get <Fakes>(); var existingUser = new User("existingUser") { EmailAddress = "*****@*****.**" }; var cred = new CredentialBuilder().CreateExternalCredential("MicrosoftAccount", "blorg", "Bloog"); var msAuther = new MicrosoftAccountAuthenticator(); var msaUI = msAuther.GetUI(); var authUser = new AuthenticatedUser( fakes.CreateUser("test", cred), cred); GetMock <AuthenticationService>(); // Force a mock to be created GetMock <IUserService>() .Setup(u => u.FindByEmailAddress(existingUser.EmailAddress)) .Returns(existingUser); var controller = GetController <AuthenticationController>(); GetMock <AuthenticationService>() .Setup(x => x.AuthenticateExternalLogin(controller.OwinContext)) .CompletesWith(new AuthenticateExternalLoginResult() { ExternalIdentity = new ClaimsIdentity(new[] { new Claim(ClaimTypes.Email, existingUser.EmailAddress) }), Authenticator = msAuther }); // Act var result = await controller.LinkExternalAccount("theReturnUrl"); // Assert var model = ResultAssert.IsView <LogOnViewModel>(result, viewName: LinkExternalViewName); Assert.Equal(msaUI.AccountNoun, model.External.ProviderAccountNoun); Assert.Null(model.External.AccountName); Assert.True(model.External.FoundExistingUser); Assert.Equal(existingUser.EmailAddress, model.SignIn.UserNameOrEmail); Assert.Equal(existingUser.EmailAddress, model.Register.EmailAddress); }
public async Task Patch__User_Can_Assign_Public_Training_To_His_Trainings() { AuthenticatedUser user = await LogInAs("*****@*****.**"); Training training = await CreatePublicTraining(); AddPublicTrainingToUserRequest request = new AddPublicTrainingToUserRequest { TrainingId = training.Id }; HttpContent content = new StringContent(JsonSerializer.Serialize(request), Encoding.UTF8, "application/json"); var response = await Client.PatchAsync(ApiRoutes.Training.AssignPublicTrainingToUser, content); response.StatusCode.Should().Be(HttpStatusCode.OK); int userTrainingCount = await Context.UserTraining.AsNoTracking().CountAsync(); userTrainingCount.Should().Be(1); }
public async Task Patch__User_Cant_Add_Exercises_To_His_Public_Training() { AuthenticatedUser user = await LogInAs("*****@*****.**"); Training training = await CreatePublicTraining(user.Id); Exercise exercise1 = await CreateExercise(); string patchEndpoint = ApiRoutes.Training.AddExercisesToTraining.Replace("{trainingId}", training.Id.ToString()); UpdateTrainingExercisesRequest request = new UpdateTrainingExercisesRequest { Exercises = new[] { exercise1.Id } }; HttpContent content = new StringContent(JsonSerializer.Serialize(request), Encoding.UTF8, "application/json"); var response = await Client.PatchAsync(patchEndpoint, content); response.StatusCode.Should().Be(HttpStatusCode.Forbidden); }
private bool ProcessLogin(string username, string password) { _reddit = new Reddit(WebAgent.RateLimitMode.Pace); if (string.IsNullOrEmpty(username) || string.IsNullOrEmpty(password)) return false; try { OutputTextBlock.Text += $"\r\n{DateTime.Now} | Logging in as {username}."; _redditUser = _reddit.LogIn(username, password); } catch (Exception ex) { OutputTextBlock.Text += $"\r\n{DateTime.Now} | Login failed. Exception encountered: {ex.Message}. Is Reddit down?"; } if (_redditUser != null) return true; return false; }
public async Task <IActionResult> OnGetAsync( [FromServices] AuthenticatedUser user) { var reg = await _registrations.GetRegistration(user); if (reg.HasCompletedVerification) { return(RedirectToPage("/apprenticeships/index")); } if (!reg.HasViewedVerification) { await _registrations.FirstSeenOn(user.ApprenticeId, DateTime.UtcNow); } EmailAddress = reg?.Email; return(Page()); }
public async Task <(MyChessGame?Game, HandlerError?Error)> CreateGameAsync(AuthenticatedUser authenticatedUser, MyChessGame game) { var opponentID = game.Players.Black.ID; var opponent = await GetUserByUserIDAsync(opponentID); if (opponent == null) { return(null, new HandlerError() { Instance = LoggingEvents.CreateLinkToProblemDescription(LoggingEvents.GameHandlerOpponentNotFound), Status = (int)HttpStatusCode.NotFound, Title = "User not found", Detail = "For some reason your opponent could not be found" }); } var user = await GetOrCreateUserAsync(authenticatedUser); game.ID = Guid.NewGuid().ToString("D"); game.Players.White.ID = user.UserID; var data = _compactor.Compact(game); // TODO: Validate game data var comment = game.Moves[0].Comment; await _context.UpsertAsync(TableNames.GamesWaitingForYou, new GameEntity { PartitionKey = opponentID, RowKey = game.ID, Data = data }); await _context.UpsertAsync(TableNames.GamesWaitingForOpponent, new GameEntity { PartitionKey = user.UserID, RowKey = game.ID, Data = data }); await _notificationHandler.SendNotificationAsync(opponentID, game.ID, comment); return(game, null); }
public SendMessageResponse SendMessage(SendMessageRequest messageRequest) { using (new OperationContextScope((IClientChannel)proxy)) { AuthenticatedUser currentLoggedUser = AuthenticatedUser.Instance; WebOperationContext.Current.OutgoingRequest.Headers.Add("Authentication", currentLoggedUser.Authentication.ToString()); try { SendMessageResponse response = proxy.SendMessage(messageRequest); return(response); } catch (Exception ex) { return(new SendMessageResponse { IsSuccess = false, Message = ex.Message }); } } }
//public Repository(IEnsuranceContext context) //{ // this.context = context; //} #region Authentication public AuthenticatedUser AuthenticateUser(Authentication login) { AuthenticatedUser user = null; using (var context = new EnsuranceDBEntities()) { user = context.Users.AsNoTracking() .Where(u => u.UserName == login.UserName && u.Password == login.Password) .Select(u => new AuthenticatedUser { Id = u.Id, Name = u.Name, LastName = u.LastName, Username = u.UserName, Token = "" }).FirstOrDefault <AuthenticatedUser>(); } return(user); }
public async Task <Project> UpdateAsync(Project project, AuthenticatedUser currentUser) { await EnsureUserHasAccessAsync(currentUser, project.Id, AccessType.Admin, nameof(UpdateAsync)); var dbProject = await projectRepository.FindByIdAsync(project.Id); if (dbProject == null) { throw new EntityNotFoundException(nameof(Project), project.Id.ToString()); } dbProject.Name = project.Name; dbProject.GitToken = project.GitToken; dbProject.ProjectUri = project.ProjectUri; await projectRepository.UpdateAsync(dbProject); return(ModelsMapper.ConvertProjectDbModelToServiceModel(dbProject)); }
public ITestApiContext ParseQueryStringToContext( IEnumerable <KeyValuePair <string, string> > queryKeyValuePairs, AuthenticatedUser authenticatedUser, EntityId organizationUnitId, EntityId repositoryId) { var metaData = new MetaDataEnvelope(); var warnings = new List <string>(); var querystringAsDictionary = this.QueryStringToDictionary(queryKeyValuePairs); var filters = querystringAsDictionary.ContainsKey("filters") ? querystringAsDictionary["filters"] : string.Empty; var context = new TestApiContext( querystringAsDictionary, querystringAsDictionary.ContainsKey("count") ? ParseInt("Count", querystringAsDictionary["count"], warnings) : DefaultCount, querystringAsDictionary.ContainsKey("offset") ? ParseInt("Offset", querystringAsDictionary["offset"], warnings) : DefaultOffset, this.ParseFilters(filters, metaData), authenticatedUser, organizationUnitId, repositoryId, metaData, Enumerable.Empty <string>(), Enumerable.Empty <string>()); PopulateMetaData(metaData, context, filters); querystringAsDictionary.Remove("count"); querystringAsDictionary.Remove("offset"); querystringAsDictionary.Remove("filters"); AddFiltersToDebugIfRequired(context); warnings.ForEach(context.AddWarning); return(context); }
public async Task <ActionResult> CompleteAuth(string code) { string clientId = "YOUR_CLIENT_ID"; string clientSecret = "YOUR_CLIENT_SECRET"; string redirectUri = "YOUR_REDIRECT_URL"; var result = await InstagramOAuth.AuthenticateUser(clientId, clientSecret, "authorization_code", redirectUri, code); if (result.IsSuccessStatusCode) { string responseContent = result.Content.ReadAsStringAsync().Result; AuthenticatedUser authenticatedUser = JsonConvert.DeserializeObject <AuthenticatedUser>(responseContent); } else { throw new Exception(); } return(View()); }
public async Task <ActionResult <RegisteredUser> > AddNewAuthenticatedUser(AuthenticatedUser authenticatedUser) { if (Context != null) { try { authenticatedUser.CreationDate = DateTimeOffset.UtcNow.ToUnixTimeSeconds(); authenticatedUser.Updated = DateTimeOffset.UtcNow.ToUnixTimeSeconds(); //var refinedObject = authenticatedUser; //refinedObject.CreationDate = DateTimeOffset.UtcNow.ToUnixTimeSeconds(); //refinedObject.Updated = DateTimeOffset.UtcNow.ToUnixTimeSeconds(); Context.AuthenticatedUsers.Add(authenticatedUser); await Context.SaveChangesAsync(); var newUser = Context.AuthenticatedUsers.Where(user => user.UserName.Equals(authenticatedUser.UserName)).First(); if (newUser != null) { var newUserRole = await UserRoleHandler.Get.StoreRoleAsync(newUser.ID, roleType : RoleType.USER); if (newUserRole != null) { return(new RegisteredUser { ID = newUser.ID, FirstName = newUser.FirstName, LastName = newUser.LastName, Email = newUser.Email, UserName = newUser.UserName, Role = RoleType.USER.ToString(), CreationDate = newUser.CreationDate, Updated = newUser.Updated }); } } } catch (DbUpdateException) { } catch (Exception) { } } return(null); }
public IAuthenticatedUser Authenticate(AuthenticateParameters authParams) { var user = _userBusiness.AuthenticateUser(authParams.Login, authParams.Password); if (user != null) { var issuedAt = _clock.UtcNow; var jwtToken = _jwtOptions.Enabled ? new JwtSecurityToken( issuer: _jwtOptions.Issuer, claims: user.GetJwtClaims(issuedAt), expires: issuedAt.LocalDateTime.Add(_jwtOptions.Duration), signingCredentials: new SigningCredentials(new SymmetricSecurityKey(_jwtOptions.Key.ToBytes()), SecurityAlgorithms.HmacSha256)) : null; return(AuthenticatedUser.Create(user, jwtToken == null ? null : new JwtSecurityTokenHandler().WriteToken(jwtToken))); } return(null); }
public void OnComplete(Android.Gms.Tasks.Task task) { if (task.IsSuccessful) { // process document var result = task.Result; if (result is DocumentSnapshot doc) { var user = new AuthenticatedUser(); user.Id = doc.Id; user.FirstName = doc.GetString("FirstName"); user.LastName = doc.GetString("LastName"); _tcs.TrySetResult(user); return; } } // somthing went wrong _tcs.TrySetResult(default(AuthenticatedUser)); }
/// <summary> /// Initializes a new instance of the MainViewModel class. /// </summary> public PluralsightMainViewModel(ILoginService loginService, ICourseService courseService, IConfigProvider configProvider) { _configProvider = configProvider; CurrentUserAgent = _configProvider.UserAgent; _courseService = courseService; NumberOfSelectedCourses = 0; AuthenticatedUser authenticatedUser = Newtonsoft.Json.JsonConvert.DeserializeObject <AuthenticatedUser>(loginService.LoginResultJson); Title = $"{authenticatedUser.CurrentUser.FirstName} {authenticatedUser.CurrentUser.LastName} ({authenticatedUser.CurrentUser.Email})"; CourseTagSelectedCommand = new RelayCommand <string>(OnCourseTagSelected); CancelDownloadsCommand = new RelayCommand(OnCancelDownloads, CanCancelDownload); OpenDownloadsFolderCommand = new RelayCommand(OnOpenDownloadsFolder); OpenSettingsWindowCommand = new RelayCommand(OnOpenSettingsWindow); ProductCheckBoxToggledCommand = new RelayCommand <bool>(OnProductCheckBoxToggledCommand); DownloadCourseCommand = new RelayCommand(OnDownloadCourseAsync, CanExecuteDownload); NumberOfCoursesForTag = _courseService.CoursesByToolName.ToDictionary(kvp => kvp.Key, v => v.Value.Count); AllCourses = _courseService.CoursesByToolName.Values.SelectMany(x => x).Distinct().ToList(); }
public ITestApiContext ParseBodyToContext( RequestBody body, IEnumerable <KeyValuePair <string, string> > queryKeyValuePairs, AuthenticatedUser authenticatedUser, EntityId organizationUnitId, EntityId repositoryId) { var queryString = this.QueryStringToDictionary(queryKeyValuePairs); if (body.Pagination != null) { queryString["Count"] = body.Pagination.Count.ToString(CultureInfo.InvariantCulture); queryString["Offset"] = body.Pagination.Offset.ToString(CultureInfo.InvariantCulture); } queryString["Filters"] = body.Filters; return(this.ParseQueryStringToContext(queryString, authenticatedUser, organizationUnitId, repositoryId)); }
public ProductDto Exec(SqlConnection db, AuthenticatedUser au, long Id) { var ret = repository.ProductById(db, Id); if (ret == null) { Error = new ServiceError { Message = "Invalid Product ID" }; return(null); } var retCateg = repository.CategoryById(db, ret.ProductCategoryID); var retSubCateg = repository.SubCategoryById(db, ret.ProductSubCategoryID); if (au != null) { repository.ProductAddView(db, au.Id, Id); } var retComments = new System.Collections.Generic.List <NewProductComment>(); foreach (var item in repository.ProductComments(db, Id)) { retComments.Add(new NewProductComment { Comment = item.Comment, Date = item.DateAdded?.ToString("dd/MM/yyyy HH:mm"), UserName = repository.UserById(db, (long)item.UserID)?.Name }); } return(new ProductDto { Id = ret.Id, Name = ret.Name, Views = repository.ProductViews(db, Id), Category = retCateg.Name, SubCategory = retSubCateg.Name, Comments = retComments }); }
public async Task Get_Settings_As_Existing_User_With_Notification() { // Arrange var expectedNotifications = 1; var expectedPlayAlwaysUp = true; var user = new AuthenticatedUser() { Name = "abc", PreferredUsername = "******", UserIdentifier = "u", ProviderIdentifier = "p" }; await _context.UpsertAsync(TableNames.Users, new UserEntity() { PartitionKey = "u", RowKey = "p", UserID = "user123" }); await _context.UpsertAsync(TableNames.UserSettings, new UserSettingEntity() { PartitionKey = "user123", RowKey = "user123", PlayAlwaysUp = true }); await _context.UpsertAsync(TableNames.UserNotifications, new UserNotificationEntity() { PartitionKey = "user123", RowKey = "user123", Name = "Browser" }); // Act var actual = await _settingsHandler.GetSettingsAsync(user); // Assert Assert.NotNull(actual); Assert.Equal(expectedNotifications, actual.Notifications.Count); Assert.Equal(expectedPlayAlwaysUp, actual.PlayAlwaysUp); }
protected async Task <UserEntity> GetOrCreateUserAsync(AuthenticatedUser authenticatedUser) { var user = await _context.GetAsync <UserEntity>(TableNames.Users, authenticatedUser.UserIdentifier, authenticatedUser.ProviderIdentifier); if (user == null) { _log.BaseHandlerCreateNewUser(); var userID = Guid.NewGuid().ToString("D"); var userEntity = new UserEntity { PartitionKey = authenticatedUser.UserIdentifier, RowKey = authenticatedUser.ProviderIdentifier, Name = authenticatedUser.Name, UserID = userID, Created = DateTime.UtcNow, Enabled = true }; await _context.UpsertAsync(TableNames.Users, userEntity); var userID2UserEntity = new UserID2UserEntity { PartitionKey = userID, RowKey = userID, UserPrimaryKey = userEntity.PartitionKey, UserRowKey = userEntity.RowKey }; await _context.UpsertAsync(TableNames.UserID2User, userID2UserEntity); _log.BaseHandlerNewUserCreated(userID); return(userEntity); } else { _log.BaseHandlerExistingUserFound(user.UserID); return(user); } }
public bool Authenticate(string user, string pass) { HelperClasses.Serializer srl = new HelperClasses.Serializer(); myService.ResponseItem ex_resp = new myService.ResponseItem(); //string fileExtension = VirtualPathUtility.GetFileName(filePath); AuthenticatedUser auth_user = new AuthenticatedUser(); try { auth_user = TRUserAuthentication(user, pass); } catch (HttpRequestValidationException ex_http) { string ex_res = ex_http.ToString(); } return auth_user.IsAuthenticated; }
private static IEnumerable<Post> GetOrCreateDailyPosts(Reddit reddit, Subreddit subreddit, AuthenticatedUser user, int year, int month) { var firstDateOfMonth = new DateTime(year, month, 1); var monthName = firstDateOfMonth.ToString("MMMM"); var createdPost = false; var dailyPostDate = firstDateOfMonth; var userPosts = user.Posts.ToList(); while (dailyPostDate.Month == month) { var dailyPostTitle = string.Format(DailyPostTitleFormat, year, monthName, dailyPostDate.Day); var dailyPosts = userPosts.Where(p => p.Title == dailyPostTitle).OrderByDescending(p => p.Created); if (dailyPosts.Any()) { if (dailyPosts.Count() > 1) reddit.ComposePrivateMessage("Multiple daily posts found", "Multiple posts found for " + dailyPostDate.ToShortDateString() + " post." + Environment.NewLine + string.Join(Environment.NewLine, dailyPosts.Select(p => p.Shortlink)), SubredditName); yield return dailyPosts.First(); } else { // Create the post for the day. var post = subreddit.SubmitTextPost(dailyPostTitle, string.Format(DailyPostDescription, dailyPostDate.ToLongDateString())); CreateDailyEvents(post, dailyPostDate.Year, dailyPostDate.Month, dailyPostDate.Day); yield return post; createdPost = true; Thread.Sleep(10000); // Wait 10 seconds before creating another post } dailyPostDate = dailyPostDate.AddDays(1); } if (createdPost) reddit.ComposePrivateMessage("New month worth of posts created", "Daily posts were created for " + monthName + ".", SubredditName); }
//public static PlayVerseAPI GetInstance(PlayverseEnvironment env) { // Instance = new PlayVerseAPI(env); // return Instance; //} //Stub public AuthenticatedUser Login(string email, string password) { AuthenticatedUser info = new AuthenticatedUser() { UserInfo = new Authenticated() { isAuthenticated = false }, }; try { info.UserSessionInfo = PVConnection.Get<UserAuth>().LoginWithPlayverse(email, password); info.UserInfo.isAuthenticated = true; } catch (Exception ex) { Logger.Instance.Exception(ex.Message, ex.StackTrace); PVConnection.Get<Logging>().AddLog(ErrorType.Exception, "MoniVerse PlayVerseAPI", "Login", Uuid.Empty, ex.Message, ex.StackTrace, ErrorLevel.Low); } return info; }
public static void SetCredentials(AuthenticatedUser user, bool rememberMe) { DateTime expiration = rememberMe ? DateTime.Now.AddMonths(1) : DateTime.Now.AddHours(3); FormsAuthenticationTicket ticket = new FormsAuthenticationTicket( 1, user.Name, DateTime.Now, expiration, rememberMe, user.ToString(), FormsAuthentication.FormsCookiePath ); string encTicket = FormsAuthentication.Encrypt(ticket); HttpCookie cookie = new HttpCookie(FormsAuthentication.FormsCookieName, encTicket); if (rememberMe) { cookie.Expires = expiration; } HttpContext.Current.Response.Cookies.Add(cookie); HttpContext.Current.Session.Add("app_user", user); }
public virtual async Task<ActionResult> Create(NewUserViewModel model) { if (!ModelState.IsValid) { return View(model); } var user = new AuthenticatedUser(model.UserName, model.Email); var result = await _userManager.CreateAsync(user, model.Password); if (result.Succeeded) { return RedirectToAction("success"); } else { foreach (var errorMessage in result.Errors) { ModelState.AddModelError(string.Empty, errorMessage); } return View(model); } }
private User ToUser(XElement author) { var isAuth = author.Attribute("isAuthenticated"); if (isAuth != null && isAuth.Value == "true") { AuthenticatedUser retval; var id = (long)author; if (!authUserCache.TryGetValue(id, out retval)) authUserCache[id] = retval = new AuthenticatedUser(id); return retval; } return new AnonymousUser ( (string)author, (string)author.Parent.Element(XName.Get("email", XmlnsExport)) ); }
private void mainWindowMenuDestroyDropDownRedditButton_Click(object sender, RoutedEventArgs e) { // Destroy Reddit user variable redditUser = null; redditConnection = null; redditUsername = null; redditPassword = null; mainWindowMenuSetupDropDownRedditConnectButton.IsEnabled = true; mainWindowMenuDestroyDropDownRedditButton.IsEnabled = false; }
private void mainWindowMenuSetupDropDownRedditConnectButton_Click(object sender, RoutedEventArgs e) { RedditConnectionDialog redditConnectResult = new RedditConnectionDialog(); redditConnectResult.ShowDialog(); // Handle connection info dialog if (redditConnectResult != null) { redditConnectResult.Close(); } // Check for full information entry if (redditUsername == "" || redditPassword == "" || redditUsername == null || redditPassword == null) { // User did not enter all required information, do not attempt to connect appendErrorText(botOutputBox, "Please enter all required fields (Username, password)\r"); return; } try { redditUser = redditConnection.LogIn(redditUsername, redditPassword); } catch (AuthenticationException) { appendErrorText(botOutputBox, "Reddit login information provided did not authenticate.\rCheck that the provided username and password are correct."); return; } isRedditConnected = true; mainWindowMenuSetupDropDownRedditConnectButton.IsEnabled = false; mainWindowMenuDestroyDropDownRedditButton.IsEnabled = true; return; }
public static object GetInfo(AuthenticatedUser.Info prop) { AuthenticatedUser user = GetAuthenticatedUser(); if (user != null) { switch (prop) { case AuthenticatedUser.Info.ID: return user.ID; case AuthenticatedUser.Info.Name: return user.Name; case AuthenticatedUser.Info.Role: return user.Role; } } return null; }
public void login(string username, string password) { user = reddit.LogIn(username, password); subreddit = reddit.GetSubreddit("/r/Dota2"); }
// TR User Authentication // Windows Authentication, Without Windows Authentication, Hack Authentication private AuthenticatedUser TRUserAuthentication(string user, string password) { AuthenticatedUser auth_user; myService.Authentication UserAuth; //---> Authentication Needed if (blAuthenticationNeeded == false) { auth_user = new AuthenticatedUser(user, true, AuthenticationMethod.NoAuthentication); return auth_user; } //---> //---> Hack Authentication bool sUser = false; sUser = HashGen.VerifyCode(user, password); if (sUser) { auth_user = new AuthenticatedUser(user, true, AuthenticationMethod.Hack); return auth_user; } //---> //---> TR Authentication PSIntranet.Service.ServiceBase.PSIntranetServiceBase pb = new ServiceBase.PSIntranetServiceBase(); UserAuth = pb.AuthenticateUser(user, password); if (UserAuth.Success) { auth_user = new AuthenticatedUser(user, true, AuthenticationMethod.Normal); return auth_user; } else if (UserAuth.TRAuth) { auth_user = new AuthenticatedUser(user, false, AuthenticationMethod.Normal); return auth_user; } else { //---> Windows Authentication auth_user = LDAPAuthentication("LDAP://10.0.0.9",user,password); return auth_user; //---> } //---> //auth_user = new AuthenticatedUser(user, false, AuthenticationMethod.Missing); //return auth_user; }
public PasswordAuthenticationResult(AuthenticationResult result, AuthenticatedUser authenticatedUser = null, int lockTimeRemainingMinutes = 0) { Result = result; LockTimeRemainingMinutes = lockTimeRemainingMinutes; AuthenticatedUser = authenticatedUser; }
AuthenticatedUser LDAPAuthentication(string path, string user, string pass) { AuthenticatedUser authuser; try { PrincipalContext ctx = new PrincipalContext(ContextType.Domain, "10.0.0.9:389", "CN=Time Report Web Service account,CN=Users,DC=process-solutions,DC=hu", "trwebservice", "th824EpuWret5nUs"); //PrincipalContext ctx = new PrincipalContext(ContextType.Domain, "10.0.0.9:389", "CN=Users,DC=process-solutions,DC=hu", "process/trwebservice", "th824EpuWret5nUs"); if (ctx.ValidateCredentials(user, pass)) { authuser = new AuthenticatedUser(user, true, AuthenticationMethod.LDAP); } else { authuser = new AuthenticatedUser(user, false, AuthenticationMethod.LDAP); //HelperClasses.WriteLog.WriteToLog(PSIntranet.Common.Constants.AppPath + PSIntranet.Common.Constants.DEFAULT_LOG_FILE, "Authentication failed : " + user); } } catch (Exception ex) { //System.Windows.Forms.MessageBox.Show(ex.ToString()); authuser = new AuthenticatedUser(user, false, AuthenticationMethod.LDAP); //HelperClasses.WriteLog.WriteToLog(PSIntranet.Common.Constants.AppPath + PSIntranet.Common.Constants.DEFAULT_LOG_FILE, "Exception: " + ex.ToString()); } return authuser; }