/// <summary> /// Creates a new user. /// </summary> /// <param name="userViewModel"></param> /// <param name="ct"></param> /// <returns></returns> public async Task <UserViewModel> AddUserAsync(UserRequestViewModel userViewModel, CancellationToken ct = default(CancellationToken)) { if (string.IsNullOrWhiteSpace(userViewModel.Password)) { throw new AppException("Password is required"); } var user = await _repository.GetUserAsync(userViewModel.Username); if (user != null) { throw new AppException("Username \"" + user.Username + "\" is already taken"); } byte[] passwordHash, passwordSalt; CreatePasswordHash(userViewModel.Password, out passwordHash, out passwordSalt); user = new User { Username = userViewModel.Username, PasswordHash = passwordHash, PasswordSalt = passwordSalt, CreatedAt = DateTime.Now }; user = await _repository.AddAsync(user, ct); return(new UserViewModel() { UserId = user.UserId }); }
public async Task <IActionResult> Register([FromBody] UserRequestViewModel user) { var dbUser = user.ToUser(); await userRepository.AddUser(dbUser); return(Ok(dbUser.ToUserResponseViewModel())); }
public async Task <IActionResult> Signup(UserRequestViewModel request) { _logger.LogDebug("Signing up"); var result = await _service.Signup(request); if (result.Success) { return(Ok(result)); } return(BadRequest(result)); }
public IActionResult GetUserList(UserRequestViewModel query, TokenModel tokenModel) { var searchModel = Mapper.Map <UserSearchDto>(query); var list = _userService.GetList(searchModel); return(Ok(new PageResponseViewModel() { Data = list.Items, Page = new PageViewModel { PageSize = query.PageSize, Total = list.TotalNum, PageIndex = query.PageIndex } })); }
public async Task <IActionResult> CheckIfUserExists([FromBody] UserRequestViewModel user) { var userExists = await userRepository.CheckIfUserExists(user.Email, user.Username); if (userExists) { return(Conflict(new ErrorResponseViewModel { Id = (int)ErrorResponseIds.UserAlreadyExists, Message = "Invalid user credentials" })); } return(Ok()); }
public async Task <IActionResult> Login([FromBody] UserRequestViewModel user) { var userToReturn = await userRepository.GetUserByUsernamePassword(user.Username, user.Password); if (userToReturn == null) { return(NotFound(new ErrorResponseViewModel { Id = (int)ErrorResponseIds.UserInvalid, Message = "Invalid user credentials" })); } return(Ok(userToReturn)); }
public async Task <IHttpActionResult> Register([FromBody] UserRequestViewModel userModel) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } IdentityResult result = await _repo.RegisterUser(userModel); IHttpActionResult errorResult = GetErrorResult(result); return(errorResult == null?Ok() : errorResult); }
public IActionResult Index() { if (this.User.Identity.IsAuthenticated) { UserRequestViewModel model = new UserRequestViewModel { Email = this.User.Identity.Name, }; return(this.View(model)); } return(this.View()); }
public async Task <ActionResult> Login(UserRequestViewModel user) { if (!ModelState.IsValid) { return(View()); } try { UserResponseViewModel loggedInUser = await _userService.GetUserForLogin(user); if (loggedInUser != null) { var identity = new ClaimsIdentity(CookieAuthenticationDefaults.AuthenticationScheme); identity.AddClaim(new Claim(ClaimTypes.Name, loggedInUser.FirstName + " " + loggedInUser.LastName)); identity.AddClaim(new Claim(ClaimTypes.NameIdentifier, loggedInUser.CNP)); identity.AddClaim(new Claim(ClaimTypes.PrimarySid, loggedInUser.Id)); identity.AddClaim(new Claim(ClaimTypes.Role, "User")); if (loggedInUser.IsAdmin) { identity.AddClaim(new Claim(ClaimTypes.Role, "Admin")); } identity.AddClaim(new Claim("UserId", loggedInUser.Id)); var authProperties = new AuthenticationProperties { AllowRefresh = true, ExpiresUtc = DateTimeOffset.Now.AddDays(1), IsPersistent = true, }; var claimsPrincipal = new ClaimsPrincipal(identity); await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, claimsPrincipal, authProperties); return(RedirectToAction("Index", "Home")); } } catch (UserNotFoundException) { ModelState.Clear(); ModelState.AddModelError("", "Invalid login attempt."); return(View("Login", user)); } return(null); }
public ActionResult MyRequests(string id) { UserRequestViewModel model = new UserRequestViewModel { Client = _clientServece.GetByIdUser(id), Requests = _requestService.GetAllByIdUser(id) }; if (TempData["request"] != null) { ViewBag.status = TempData["request"].ToString(); ViewBag.icon = TempData["icon"].ToString(); } return(View(model)); }
public PartialViewResult GetRentRequestList(int?PageNumber) { unitOfWork = new EFUnitOfWork(db); UserRequestViewModel urvm = new UserRequestViewModel(); List <UserRequestModel> userRequests = new List <UserRequestModel>(); userRequests = unitOfWork.GetRepository <UserRequest>().GetAll().ProjectTo <UserRequestModel>().ToList(); urvm.UsersRequestCount = userRequests.Count(); urvm.PagedListUsers = userRequests.ToPagedList(PageNumber ?? 1, 10); unitOfWork.Dispose(); return(PartialView("_UserRequestListView", urvm)); }
public async Task <bool> UserExists(UserRequestViewModel user) { var url = $"{_configuration["UserServiceAPIUrl"]}/api/User/UserExist"; try { var responseString = await HTTPRequestSender.PostAsync(url, user); return(false); } catch (Exception e) { var errorResponse = JsonConvert.DeserializeObject <ErrorResponseViewModel>(e.Message); return(errorResponse.Id == (int)ErrorResponseIds.UserAlreadyExists || true); } }
public async Task <IActionResult> Contact(UserRequestViewModel model) { if (!this.ModelState.IsValid) { return(this.View(model)); } this.TempData["info"] = "Your request was accepted!"; UserRequest request = AutoMapperConfig.MapperInstance.Map <UserRequest>(model); request.RequestDate = DateTime.UtcNow; await this.userRequestsService.AddUserRequestAsync(request); return(this.Redirect($"/Contacts/Index")); }
public async Task <ActionResult> Register(UserRequestViewModel newUser) { if (await _userService.UserExists(newUser)) { ModelState.AddModelError("", "Username or email already exists."); return(View("Login", newUser)); } if (!ModelState.IsValid) { return(View("Login", newUser)); } await _userService.RegisterUser(newUser); return(RedirectToAction("Index", "Home")); }
public static User ToUser(this UserRequestViewModel userRequestViewModer) { return(new User() { Address = userRequestViewModer.Address, IsAdmin = false, Balance = 0, CNP = userRequestViewModer.CNP, DateOfBirth = userRequestViewModer.DateOfBirth, Email = userRequestViewModer.Email, FirstName = userRequestViewModer.FirstName, FullName = $"{userRequestViewModer.FirstName} {userRequestViewModer.LastName}", LastName = userRequestViewModer.LastName, Password = userRequestViewModer.Password, Username = userRequestViewModer.Username, }); }
public IActionResult Index(int id) { var userRequestsViewModel = this.userRequestService.All().OrderByDescending(x => x.RequestDate).Select(x => new UserRequestViewModel() { Content = x.Content, Title = x.Title, Email = x.Email, Id = x.Id, RequestDate = x.RequestDate, Seen = x.Seen }).ToList(); var currentUserRequest = this.userRequestService.GetRequestById(id); var temp = new UserRequestViewModel(); if (currentUserRequest == null) { temp = userRequestsViewModel.FirstOrDefault(); } else { temp = new UserRequestViewModel() { Content = currentUserRequest.Content, Email = currentUserRequest.Email, Id = currentUserRequest.Id, RequestDate = currentUserRequest.RequestDate, Seen = currentUserRequest.Seen, Title = currentUserRequest.Title }; } this.userRequestService.Seen(id); var viewModel = new IndexUserRequestViewModel { UserRequestsViewModel = userRequestsViewModel, UserRequestViewModel = temp }; return(View(viewModel)); }
public async Task <AppResponseViewModel> Signup(UserRequestViewModel request) { try { var user = new ApplicationUser() { Id = Guid.NewGuid().ToString(), DisplayName = request.DisplayName, UserName = request.UserName, Email = request.Email, CreationDate = DateTime.UtcNow }; var result = await _userManager.CreateAsync(user, request.Password); if (result.Succeeded) { return(new AppResponseViewModel() { Success = true, Message = "User successfully created", }); } else { return(new AppResponseViewModel() { Success = false, Message = "Validation errors", Errors = result.Errors.Select(e => e.Description) }); } } catch (Exception e) { _logger.LogError($"Something went wrong when signup: {e.Message}"); } return(new AppResponseViewModel() { Success = false, Message = "Something went wrong" }); }
public async Task <IdentityResult> RegisterUser(UserRequestViewModel userModel) { byte[] image; try { image = Convert.FromBase64String(userModel.PassportImage); } catch (FormatException ex) { return(IdentityResult.Failed(ex.Message)); } var user = MapUser(userModel, image); IdentityResult result; try { result = await _userManager.CreateAsync(user, userModel.Password); } catch (DbUpdateException ex) { _logger.Error("UserRepository.RegisterUser", ex.InnerException.InnerException); return(IdentityResult.Failed(ex.InnerException.InnerException.Message)); } if (!result.Succeeded) { return(result); } result = await _userManager.AddToRoleAsync(user.Id, RoleTypes.User); if (!result.Succeeded) { var exception = new InvalidOperationException($"Can not add role '{RoleTypes.User}' for user '{user.UserName}'"); _logger.Fatal("UserRepository.RegisterUser", exception); throw exception; } return(result); }
public async Task <IActionResult> Authenticate([FromBody] UserRequestViewModel user) { try { var result = await _manager.Authenticate(user.Username, user.Password); if (result == null) { return(BadRequest(new { message = "Username or password is incorrect" })); } return(Ok(result)); } catch (Exception ex) { return(StatusCode(500, new { Code = "ServerError", ex.Message })); } }
private ApplicationUser MapUser(UserRequestViewModel user, byte[] image) { return(new ApplicationUser { UserName = user.UserName, Email = user.Email, PhoneNumber = user.PhoneNumber, IsApproved = false, FCMPushNotificationToken = user.FCMPushNotificationToken, UserInfo = new UserInfo { FirstName = user.FirstName, LastName = user.LastName, Patronymic = user.Patronymic, CardNumber = user.CardNumber, CardOwnerFullName = user.CardOwnerFullName, CardDateOfExpire = DateTime.ParseExact(user.CardDateOfExpire, "MM/yy", CultureInfo.InvariantCulture).Date, CardCVV2Key = user.CardCVV2Key, PassportImage = image, ImageMimeType = user.ImageMimeType } }); }
public async Task <InpowerResult> getChatAll(UserRequestViewModel model) { InpowerResult resp = null; try { resp = await _helper.Get <InpowerResult>(GlobalConstant.ChatUrls.getAllChatServiceUrl.ToString()); return(resp); } catch (Exception ex) { CrashReportService crashReport = new CrashReportService(); CrashReportModel CR = new CrashReportModel(); CR.Filename = "Registration"; CR.Eventname = "AccountService"; // CR.UserID = GlobalClass.UserID == null ? "0" : GlobalClass.UserID; CR.ErrorMsg = ex.Message + ex.StackTrace; await crashReport.SendCrashReport(CR, GlobalConstant.CrashUrl); return(resp); } }
public async Task <UserResponseViewModel> RegisterUser(UserRequestViewModel user) { var url = $"{_configuration["UserServiceAPIUrl"]}/api/User/Register"; try { var responseString = await HTTPRequestSender.PostAsync(url, user); var responseUser = JsonConvert.DeserializeObject <UserResponseViewModel>(responseString); return(responseUser); } catch (Exception e) { var errorResponse = JsonConvert.DeserializeObject <ErrorResponseViewModel>(e.Message); if (errorResponse.Id == (int)ErrorResponseIds.UserAlreadyExists) { throw new UserAlreadyExistsException(); } throw; } }
public async Task <IActionResult> Register([FromBody] UserRequestViewModel input, CancellationToken ct = default(CancellationToken)) { try { if (input == null) { return(BadRequest()); } return(StatusCode(201, await _manager.AddUserAsync(input, ct))); } catch (AppException ex) { return(BadRequest(new { message = ex.Message })); } catch (Exception ex) { return(StatusCode(500, new { Code = "ServerError", ex.Message })); } }
public async Task AddUserRequest([FromBody] UserRequestViewModel userRequestVm) { await _userRequestService.AddUserRequest(userRequestVm); }
public UserRequest() { InitializeComponent(); BindingContext = viewModel = new UserRequestViewModel(this); }
public async Task AddUserRequest(UserRequestViewModel userRequestVm) { var userRequest = _mapper.Map <UserRequestViewModel, UserRequest>(userRequestVm); await _userRequestRepository.AddUserRequest(userRequest); }