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