public override async Task OnConnectedAsync() { try { var feature = Context.Features.Get <IConnectionHeartbeatFeature>(); if (feature == null) { await _usersService.AddUserAsync(Context.ConnectionId, Context.User.SubId(), Context.User.UserName()); await base.OnConnectedAsync(); return; } var context = Context.GetHttpContext(); if (context == null) { throw new InvalidOperationException("The HTTP context cannot be resolved."); } var result = await context.AuthenticateAsync(IdentityServerAuthenticationDefaults.AuthenticationScheme); if (result.Ticket == null) { Context.Abort(); return; } var expiresClaim = result.Ticket.Principal.FindFirst(JwtClaimTypes.Expiration); if (!long.TryParse(expiresClaim.Value, out var expiresValue)) { Context.Abort(); return; } var expires = DateTimeOffset.FromUnixTimeSeconds(expiresValue); feature.OnHeartbeat(state => { var(innerExpires, connection) = ((DateTimeOffset, HubCallerContext))state; if (innerExpires < DateTimeOffset.UtcNow) { connection.Abort(); } }, (expires, Context)); await _usersService.AddUserAsync(Context.ConnectionId, Context.User.SubId(), Context.User.UserName()); await base.OnConnectedAsync(); } catch (Exception e) { Console.WriteLine($"Add user failed. Error: {e.Message}"); } }
private async void OnSave() { var editingCustomer = Mapper.Map <EditableUser, User>(User); try { if (EditMode) { await _usersService.UpdateUserAsync(editingCustomer); } else { await _usersService.AddUserAsync(editingCustomer); } Done?.Invoke(); } catch (Exception ex) { Failed(ex); } finally { User = null; } }
public async Task <ActionResult <AuthenticatedUser> > Register([FromBody] RegisterCredentials credentials) { var isAdded = await _users.AddUserAsync(credentials); if (isAdded) { var user = await _authenticateService.Authenticate(new LoginCredentials() { Email = credentials.Email, Password = credentials.Password }); if (user != null) { var transaction = await _transactions.CreateTransactionAsync(null, user.Id, REGISTRATION_BONUS, DateTime.Now); if (transaction != null) { var result = await _transactions.CommitTransactionAsync(transaction); if (result != null) { return(Ok(user)); } } } return(BadRequest(new { message = "Registration failed" })); } else { return(BadRequest(new { message = "User already registered" })); } }
public async Task <IActionResult> AddUser([FromForm] UserDTO userDTO) { if (userDTO == null) { return(BadRequest("User Object is null")); } if (!ModelState.IsValid) { return(BadRequest("Invalid model object")); } var user = new User { DisplayName = userDTO.DisplayName, UserName = userDTO.DisplayName, Email = userDTO.Email, PasswordHash = userDTO.Password }; //var userEntity = _mapper string errors = await _usersService.AddUserAsync(user); if (errors == string.Empty) { return(Ok(userDTO)); } else { throw new HttpResponseException(500, errors); } }
public async Task <IActionResult> CreateUser( [HttpTrigger(AuthorizationLevel.Function, "post", Route = "users")] CreateUserRequest request) { var user = request.User.MapToUser(); await _usersService.AddUserAsync(user); return(new CreatedResult($"/{user.DogeId}", user)); }
public async Task <IActionResult> Post([FromBody] User user) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } await _usersService.AddUserAsync(user); return(Created("", user)); }
public async Task <ActionResult> CreateAsync([Bind("Id,FirstName,LastName,Email,Gender,Mobile,Pin,Password,Address,Image,CustomField1,CustomField2,CustomField3")] Users user) { if (ModelState.IsValid) { user.Id = Guid.NewGuid().ToString(); await _usersService.AddUserAsync(user); return(RedirectToAction("Index")); } return(View(user)); }
public async Task <IActionResult> Add(string username, string fullname) { try { await _usersService.AddUserAsync(username, fullname); return(Ok()); } catch (Exception ex) { return(new BadRequestObjectResult($"Unable to add a user: {ex.Message}")); } }
public async Task HandleAsync(SynchronizeUserCommand command) { var dataStructure = _mapper.Map <UserDataStructure>(command); if (await _usersService.UserExists(dataStructure.Id)) { await _usersService.UpdateUserAsync(dataStructure); } else { await _usersService.AddUserAsync(dataStructure); } }
public async Task <IActionResult> AddUserAsync([FromBody] User userModel) { try { var user = await service.AddUserAsync(userModel); return(Ok(user)); } catch (Exception ex) { var exceptionResponse = GetExceptionResponse(ex, Request); return(exceptionResponse); } }
public async Task <ActionResult> AddNewUser(UsersViewModel _userViewModel, string redirectUrl) { if (!ModelState.IsValid) { return(View(_userViewModel)); } var user = new Users.User { userName = _userViewModel.userName, role = _userViewModel.role, login = _userViewModel.login }; await userService.AddUserAsync(user); return(RedirectToLocal(redirectUrl)); }
public IActionResult Register(RegisterViewModel model) { if (!ModelState.IsValid) { ViewData[ErrorKey] = InvalidModelSateError; return(View(model)); } var userRegistrationTask = usersService .AddUserAsync(model.Username, model.Password, model.Email, model.FullName); if (!userRegistrationTask.Result.Succeeded) { ViewData[ErrorKey] = string.Join(Environment.NewLine, userRegistrationTask.Result.Errors.Select(e => e.Description)); return(View()); } return(RedirectToAction("Login", "Users")); }
public async Task <IActionResult> AddUser([FromBody] AddUserFormModel userForm) { var user = await _usersService.AddUserAsync(HttpContext.GetUser(), userForm); return(Ok(GetRequestResult(user))); }
public void AddUser(UserAddModel model) { _userService.AddUserAsync(model); return; }
public async Task <IActionResult> RegisterUser(RegisterUserViewModel model) { if (!ModelState.IsValid) { // ModelState invalid, return the view with the passed-in model // so changes can be made return(View(model)); } // create user + claims var userToCreate = model.IsProvisioningFromExternal ? new User { Username = model.Username, IsActive = true } : new User { Password = model.Password.GetSha256Hash(), Username = model.Username, IsActive = true }; userToCreate.UserClaims.Add(new UserClaim("country", model.Country)); userToCreate.UserClaims.Add(new UserClaim("address", model.Address)); userToCreate.UserClaims.Add(new UserClaim("given_name", model.Firstname)); userToCreate.UserClaims.Add(new UserClaim("family_name", model.Lastname)); userToCreate.UserClaims.Add(new UserClaim("email", model.Email)); userToCreate.UserClaims.Add(new UserClaim("subscriptionlevel", "FreeUser")); if (model.IsProvisioningFromExternal) { userToCreate.UserLogins.Add(new UserLogin { LoginProvider = model.Provider, ProviderKey = model.ProviderUserId }); } // add it through the repository await _usersService.AddUserAsync(userToCreate); if (!model.IsProvisioningFromExternal) { // log the user in // issue authentication cookie with subject ID and username var props = new AuthenticationProperties { IsPersistent = false, ExpiresUtc = DateTimeOffset.UtcNow.Add(AccountOptions.RememberMeLoginDuration) }; await HttpContext.SignInAsync(userToCreate.SubjectId, userToCreate.Username, props); } // continue with the flow if (_interaction.IsValidReturnUrl(model.ReturnUrl) || Url.IsLocalUrl(model.ReturnUrl)) { return(Redirect(model.ReturnUrl)); } return(Redirect("~/")); }
public async Task HandleAsync(CreateUserCommand command) { var dataStructure = _mapper.Map <UserDataStructure>(command); await _usersService.AddUserAsync(dataStructure); }