public void UserDetails_ShouldReturn_ViewAndDetailInfo()
{
// Arrange
string userId = "asd1";
var userDto = new AppUserDto {
Id = userId
};
mockAdminService.Setup(u => u.GetUserById(userId)).Returns(userDto);
AdminController controller = new AdminController(new DeliveryMessage(), mockAdminService.Object,
mockInvoicesService.Object);
AppUserViewModel userViewModel = null;
try
{
// Act
result = controller.UserDetails(userId) as ViewResult;
userViewModel = (AppUserViewModel)result.Model;
}
catch (Exception ex)
{
errorMessage = ex.Message + " | " + ex.StackTrace;
}
// Assert
Assert.IsTrue(result.ViewName == "UserDetails", errorMessage);
Assert.IsNotNull(userViewModel, errorMessage);
}
private void LoginBtn_Click(object sender, RoutedEventArgs e)
{
string user = LoginBox.Text;
string pswd = PasswordBox.Password;
if (MyAes.EncryptStringToString(pswd).Length <= 255)
{
userDto = AppUserOperations.SelectAppUser(user, pswd);
}
if (userDto != null)
{
AuthBox.Visibility = Visibility.Visible;
AuthBtn.Visibility = Visibility.Visible;
AuthBox.IsEnabled = true;
AuthBtn.IsEnabled = true;
LoginBtn.IsEnabled = false;
RegisterBtn.IsEnabled = false;
timer.Start();
stopwatch.Start();
try
{
Task.Run(() => { SendAuthCode(user); });
}
catch (SmtpException exc)
{
Debug.WriteLine(exc);
}
}
else
{
MessageBox.Show("Nieprawidłowe dane logowania.");
}
}
public async Task <IActionResult> SignIn(AppUserLoginDto loginDto)
{
if (ModelState.IsValid)
{
AppUser appUser = await appUserService.FindByUserName(loginDto.UserName);
if (appUserService.CheckPassword(loginDto, appUser) && appUser != null)
{
ICollection <AppRole> roles = await appUserService.GetRolesByUserName(loginDto.UserName);
AppUserDto appUserDto = accountHelper.GenerateAppUserDto(appUser, roles);
appUserSessionService.Set(appUserDto);
logger.LogInformation($"{appUser.UserName} kullanıcısı giriş yaptı");
return(RedirectToAction("Index", "Home"));
}
else
{
logger.LogInformation($"{loginDto.UserName} Kullanici adi veya parola hatali ");
ModelState.AddModelError("", "Kullanici adi veya parola hatali");
return(View(loginDto));
}
}
else
{
logger.LogInformation("AppUserLoginDto Not Valid");
ModelState.AddModelError("", "Lütfen gereken tüm alanları doldurunuz");
return(View(loginDto));
}
}
public async Task <IActionResult> UpdateUser(int id, [FromBody] AppUserDto userDto)
{
if (id != userDto.Id)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = await _userService.GetByIdAsync(userDto.Id);
if (user == null)
{
return(NotFound("User does not exist"));
}
_mapper.Map(userDto, user);
try
{
_userService.Update(user);
await _unitOfWork.SaveAsync();
}
catch (Exception)
{
throw new Exception("An unexpected error occured. Could not update.");
}
return(Ok(_mapper.Map <AppUserDto>(user)));
}
public async Task <IActionResult> RegisterEmployee([FromBody] AppUserDto model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email,
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
PhoneNumber = model.PhoneNumber,
EmployeeNumber = model.EmployeeNumber,
Address = model.Address
};
var result = await _userManager.CreateAsync(user, $"{model.LastName}123!");
if (result.Succeeded)
{
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=532713
// Send an email with this link
//var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
//var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: HttpContext.Request.Scheme);
//await _emailSender.SendEmailAsync(model.Email, "Confirm your account",
// "Please confirm your account by clicking this link: <a href=\"" + callbackUrl + "\">link</a>");
// await _signInManager.SignInAsync(user, isPersistent: false);
_logger.LogInformation(3, "User created a new account with password.");
var userViewModel = await GetUser(user.UserName);
return(Ok(userViewModel));
}
AddErrors(result);
}
// If we got this far, something failed
return(BadRequest(this.ModelState));
}
public async Task <ActionResult> Login(LoginViewModel model)
{
try
{
if (ModelState.IsValid)
{
AppUserDto userDto = new AppUserDto {
Email = model.Email, Password = model.Password
};
ClaimsIdentity claim = await adminService.Authenticate(userDto);
if (claim == null)
{
ModelState.AddModelError("", "Невірний логін або пароль.");
}
else
{
AuthenticationManager.SignOut();
AuthenticationManager.SignIn(new AuthenticationProperties
{
IsPersistent = true
}, claim);
return(RedirectToAction("Index", "Main"));
}
}
return(View(model));
}
catch (Exception ex)
{
deliveryMessage.Title = "Адміністрування";
deliveryMessage.Body = ex.Message;
return(View("DeliveryMessage", deliveryMessage));
}
}
public async Task <IActionResult> Index()
{
AppUserDto loginUser = appUserSessionService.Get();
ICollection <Website> userWebsites = await userWebsiteService.GetWebsitesByUserId(loginUser.Id);
return(View(userWebsites));
}
// [Permission(Action = ActionName.CanUpdate)]
public IHttpActionResult Edit(string id, [FromBody] AppUserDto user)
{
return(CreateResponse(() =>
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
var model = UserManager.FindById(id);
Mapper.Map(user, model);
UserManager.Update(model);
if (user.Roles.Any())
{
var userRoles = UserManager.GetRoles(model.Id);
UserManager.RemoveFromRoles(model.Id, userRoles.ToArray());
UserManager.AddToRoles(model.Id, user.Roles.ToArray());
}
return Ok();
}));
}
public async void NewUserLogin()
{
string url = $"{TestDomain}/api/apps/login";
IList <string> mockUsers = CreateMockUsers(1000); // 模拟用户
bool testResult = true;
foreach (var mockUser in mockUsers)
{
HttpClient httpClient = new HttpClient();
AppUserDto userDto = new AppUserDto
{
AppId = TestAppId,
UserId = mockUser,
Channel = ""
};
var httpContent = new StringContent(JsonConvert.SerializeObject(userDto), Encoding.UTF8, "application/json");
var response = await httpClient.PostAsync(url, httpContent);
testResult &= response.IsSuccessStatusCode;
}
Assert.True(testResult);
}
public IActionResult Register([FromBody] AppUserDto userDto)
{
var userManager = _serviceProvider.GetRequiredService <UserManager <IdentityUser> >();
var user = userManager.FindByEmailAsync(userDto.UserName).Result;
var requiredRole = (SiriusEnums.Roles)userDto.Role;
if (user != null)
{
return(BadRequest($"User {userDto.UserName} already exists!"));
}
try
{
user = new IdentityUser
{
Id = Guid.NewGuid().ToString(),
UserName = userDto.UserName,
Email = userDto.UserName,
SecurityStamp = Guid.NewGuid().ToString(),
};
userManager.CreateAsync(user, userDto.Password + SiriusConfiguration.Salt).Wait();
userManager.AddToRoleAsync(user, requiredRole.ToString()).Wait();
return(Ok());
}
catch (AppException ex)
{
// return error message if there was an exception
return(BadRequest(new { message = ex.Message }));
}
}
public async Task <ServiceResult> CreateAsync(AppUserDto appUserDto, string password)
{
try
{
// Checking if user already exist
var appUserExist = await _uow.AppUsers.AsQueryable()
.AnyAsync(u => u.Email == appUserDto.Email &&
u.UserName == appUserDto.Name);
if (appUserExist)
{
return(new ServiceResult($"User with name: {appUserDto.Name} or email: {appUserDto.Email} - already exist."));
}
// User creating
var appUser = _mapper.Map <AppUser>(appUserDto);
var result = await _uow.AppUsers.CreateAsync(appUser, password);
return(new ServiceResult {
Succeeded = result.Succeeded
});
}
catch (Exception ex)
{
_logger.LogError($"{this.ToString()} - error message:{ex.Message}");
return(new ServiceResult(ex.Message));
}
}
public async Task <IActionResult> GetOrAddAppUser([FromBody] AppUserDto appUserDto)
{
if (appUserDto.Id > 0)
{
return(Ok(
_mapper.Map <AppUserDto>(
_context.AppUser.Find(appUserDto.Id))
));
}
if (appUserDto.Name != null)
{
var appUser = await _context.AppUser
.SingleOrDefaultAsync(m => m.Name == appUserDto.Name);
if (appUser == null)
{
appUser = new AppUser {
Name = appUserDto.Name
};
_context.AppUser.Add(appUser);
_context.SaveChanges();
}
return(Ok(
_mapper.Map <AppUserDto>(
appUser
)
));
}
return(BadRequest("user not found"));
}
public IActionResult Authenticate([FromBody] AppUserDto userDto)
{
var user = _userService.Authenticate(userDto.UserName, userDto.Password);
if (user == null)
{
return(BadRequest(new { message = "Username or password is incorrect" }));
}
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(SiriusConfiguration.AppSecret);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new[]
{
new Claim(ClaimTypes.Name, user.Id)
}),
Expires = DateTime.UtcNow.AddDays(7),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
var tokenString = tokenHandler.WriteToken(token);
// return basic user info (without password) and token to store client side
return(Ok(new
{
Id = user.Id,
Username = user.UserName,
Token = tokenString
}));
}
public async Task <AppUserDto> Register(AppUserDto userDto)
{
var accountRepository = DataContextManager.CreateRepository <IAccountRepository>();
var user = await accountRepository.GetByEmail(userDto.Email);
if (user != null)
{
throw new ArgumentException(ErrorMessage.SAMENAME.ToString());
}
user = new AppUser
{
FirstName = userDto.FirstName,
LastName = userDto.LastName,
Email = userDto.Email,
Mobile = userDto.Mobile,
Password = GetMD5Hash(userDto.Password),
CreateDate = DateTime.Now,
IsActive = true
};
await accountRepository.Add(user);
return(MapperFactory.CreateMapper <IAppUserMapper>().MapToModel(user));
}
public TokenUserResponse GenerateToken(AppUserDto appUserDto)
{
var claims = new List <Claim>
{
new Claim(ClaimTypes.Name, appUserDto.UserName),
new Claim(ClaimTypes.NameIdentifier, appUserDto.AppUserId.ToString()),
};
string accessToken = GenerateAccessToken(claims);
string refreshToken = GenerateRefreshToken();
var token = new TokenUserResponse
{
UserId = appUserDto.AppUserId,
UserName = appUserDto.UserName,
CoverPhotoUrl = appUserDto.CoverPhotoUrl,
ProfilePhotoUrl = appUserDto.ProfilePhotoUrl,
RegisteredDate = appUserDto.RegisteredDate,
UserPosts = appUserDto.UserPosts,
AccessToken = accessToken,
RefreshToken = refreshToken,
Expires = JwtTokenDefinitions.TokenExpirationTime.Ticks
};
return(token);
}
public async Task <IViewComponentResult> InvokeAsync()
{
var user = await _userManager.GetUserAsync(HttpContext.User);
AppUserDto appUserDto = _mapper.Map <AppUser, AppUserDto>(user);
return(View(appUserDto));
}
public async Task <AppUserDto> CreateUserAsync(AppUserDto dto)
{
var userRecord = await _firebaseAuth.CreateUserAsync(new UserRecordArgs
{
Email = dto.Email,
Password = dto.Password,
});
dto.Uid = userRecord.Uid;
return(dto);
}
public async Task <ActionResult> Register([FromBody] UserRegisterModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var userDto = new AppUserDto
{
FirstName = model.FirstName,
LastName = model.LastName,
Email = model.Email,
Password = model.Password,
Mobile = model.Mobile,
};
try
{
var newUser = await _accountService.Register(userDto);
var identity = await GetIdentity(model.Email, model.Password);
var now = DateTime.UtcNow;
var newToken = GenerateToken(identity.Claims);
var refreshToken = GenerateRefreshToken();
await _accountService.SaveRefreshToken(model.Email, refreshToken);
var response = new
{
access_token = newToken,
refresh_token = refreshToken,
expires_date = now.Add(TimeSpan.FromMinutes(AuthOptions.LIFETIME))
};
return(Ok(response));
}
catch (ArgumentException aex)
{
_log.Error(aex);
return(Unauthorized(aex.Message));
}
catch (ObjectNotFoundException onfex)
{
_log.Error(onfex);
}
catch (UnauthorizedAccessException uaex)
{
_log.Error(uaex);
}
return(Unauthorized(ErrorMessage.INVALIDEMAILORPASSWORD.ToString()));
}
public IActionResult Add([FromForm] AppUserDto rentalWithCreditCardDto)
{
var rental = _mapper.Map <Rental>(rentalWithCreditCardDto);
var creditCard = _mapper.Map <CreditCard>(rentalWithCreditCardDto);
var result = _rentalManager.AddRentalWithPayment(rental, creditCard, rentalWithCreditCardDto.willBeRecorded);
if (!result.IsSuccess)
{
return(BadRequest(result));
}
return(Ok(result));
}
private OrderViewModel CreateOrders(List <OrderItemViewModel> orderItems, AppUserDto owner)
{
var newOrder = new OrderViewModel()
{
OrderId = Guid.NewGuid().ToString(),
CreatedDate = DateTime.UtcNow,
Status = "InProcess",
AppUserId = owner.AppUserId
};
//Keeping history
//var orderItemsToHistory = await _itemsHistoryComparer.GetOrderHistoryToRecordAsync(owner, orderItems);
//var newOrderHistory = _mapper.Map<OrderHistoryDto>(newOrder);
if (orderItems.Count() > 0)
{
foreach (var item in orderItems)
{
var orderItem = _mapper.Map <OrderItemViewModel>(item);
orderItem.OrderId = newOrder.OrderId;
orderItem.CreatedDate = DateTime.UtcNow;
orderItem.Order = newOrder;
//Keeping history
//var newOrderItemHistory = new OrderItemHistoryDto();
//if (ItemsHistoryComparer.CompareTwoItems(item,))
//{
//}
// _mapper.Map<OrderItemHistoryDto>(orderItem);
var orderProduct = new OrderProductViewModel()
{
OrderId = newOrder.OrderId,
ProductId = item.ProductId,
};
newOrder.TotalPrice += orderItem.TotalQuantityPrice;
newOrder.OrderItems.Add(orderItem);
newOrder.OrderProducts.Add(orderProduct);
//newOrderHistory.OrderItems.Add(newOrderItemHistory);
//newOrderHistory.ProductIdDetail = item.ProductId;
//newOrder.OrderHistory = newOrderHistory;
//newOrder.AppUser.OrderHistoryCount += 1;
}
}
return(newOrder);
}
public async Task <IActionResult> ActiveUser()
{
var userName = User.Identity.Name;
var user = await _appUserService.FindByUserNameAsync(userName);
var model = new AppUserDto
{
Id = user.Id,
Name = user.Name,
Surname = user.Surname
};
return(Ok(model));
}
/// <summary>
/// User authentication
/// </summary>
/// <param name="userDto">Data transfer object from the login page</param>
/// <returns>Об'єкт ClaimsIdentity</returns>
public async Task <ClaimsIdentity> Authenticate(AppUserDto userDto)
{
ClaimsIdentity claim = null;
// Знаходимо користувача
IdentityUser user = await userManager.FindAsync(userDto.Email, userDto.Password);
// авторизуємо його і повертаємо ClaimsIdentity
if (user != null)
{
claim = await userManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie);
}
return(claim);
}
public async Task <IActionResult> ActiveUser()
{
var user = await this.appUserService.FindByUserNameAsync(User.Identity.Name);
var roles = await this.appUserService.GetRolesByUserName(User.Identity.Name);
AppUserDto appUserDto = new AppUserDto
{
Name = user.Name,
Roles = roles.Select(x => x.Name).ToList(),
UserName = user.UserName
};
return(Ok(appUserDto));
}
public async Task <IActionResult> EditProfile() // Get current User data
{
var user = await _userManager.GetUserAsync(HttpContext.User);
if (user == null)
{
return(NotFound());
}
AppUserDto appUserDto = _mapper.Map <AppUser, AppUserDto>(user);
var json = JsonConvert.SerializeObject(appUserDto);
return(Json(json));
}
public async Task <IActionResult> ActiveUser()
{
var user = await _appUserService.FindByUserName(User.Identity.Name);
var roles = await _appUserService.GetRolesByUserName(User.Identity.Name);
AppUserDto appUserDto = new AppUserDto
{
FullName = user.FullName,
UserName = user.UserName,
Roles = roles.Select(I => I.Name).ToList()
};
return(Ok(appUserDto));
}
public async Task <ActionResult <AppUserDto> > PostAppUser(AppUserDto appUser)
{
try
{
await _appUserRepository.AddAsync(_mapper.Map <AppUser>(appUser));
await _unitOfWorkAppUser.CommitAsync(_cancellationToken);
return(CreatedAtAction("GetAppUser", new { id = appUser.AppUserId }, appUser));
}
catch (Exception ex)
{
var eerorMsg = ex.Message;
throw;
}
}
public void Insert(AppUserDto dto)
{
using (var ctx = DbContextManager <EfDbContext> .GetManager())
{
var db = ctx.DbContext;
var data = new AppUser();
SetData(data, dto);
db.AppUsers.Add(data);
db.SaveChanges();
dto.ConcurrencyStamp = data.ConcurrencyStamp;
}
}
public async Task <IActionResult> PutAppUser(AppUserDto appUser)
{
//if (id != appUser.AppUserId)
//{
// return BadRequest();
//}
try
{
if (ModelState.IsValid)
{
await _unitOfWorkAppUser.UpdateAsync(_cancellationToken,
_mapper.Map <AppUser>(appUser));
return(Ok());
//return CreatedAtAction("GetAppUser", new { id = appUser.AppUserId }, appUser);
}
else
{
return(NotFound());
}
}
catch (Exception ex)
{
var errMsg = ex.Message;
throw;
}
//_context.Entry(appUser).State = EntityState.Modified;
//try
//{
// await _context.SaveChangesAsync();
//}
//catch (DbUpdateConcurrencyException)
//{
// //if (!AppUserExists(id))
// //{
// // return NotFound();
// //}
// //else
// //{
// // throw;
// //}
//}
return(NoContent());
}
public void OnAuthorization(AuthorizationFilterContext context)
{
AppUserDto user = context.HttpContext.RequestServices.GetService <IAppUserSessionService>().Get();
if (user.IsNull())
{
context.Result = new RedirectToActionResult("SignIn", "Auth", null);
}
else if (Roles.Any())
{
string foundRole = Roles.FirstOrDefault(role => user.Roles.Contains(role));
if (foundRole.EmptyCheck())
{
context.Result = new RedirectToActionResult("AccessDenied", "Auth", null);
}
}
}
private void SetData(AppUser data, AppUserDto dto)
{
data.Id = dto.Id;
data.UserName = dto.UserName;
data.NormalizedUserName = dto.NormalizedUserName;
data.Email = dto.Email;
data.NormalizedEmail = dto.NormalizedEmail;
data.EmailConfirmed = dto.EmailConfirmed;
data.PasswordHash = dto.PasswordHash;
data.SecurityStamp = dto.SecurityStamp;
data.PhoneNumber = dto.PhoneNumber;
data.PhoneNumberConfirmed = dto.PhoneNumberConfirmed;
data.TwoFactorEnabled = dto.TwoFactorEnabled;
data.LockoutEnd = dto.LockoutEnd;
data.LockoutEnabled = dto.LockoutEnabled;
data.AccessFailedCount = dto.AccessFailedCount;
}
