public static void UpdateUser(this AppUser appUser, AppUserVm appUserVm, string action = "add")
{
//public string Id { set; get; }
appUser.Id = appUserVm.Id;
//public string UserName { set; get; }
appUser.UserName = appUserVm.UserName;
//public string PhoneNumber { set; get; }
appUser.PhoneNumber = appUserVm.PhoneNumber;
//public string Email { set; get; }
appUser.Email = appUserVm.Email;
//public string FullName { set; get; }
appUser.FullName = appUserVm.FullName;
//public string Address { set; get; }
appUser.Address = appUserVm.Address;
//public DateTimeOffset BirthDay { set; get; }
appUser.BirthDay = appUserVm.BirthDay;
//public bool Gender { set; get; }
appUser.Gender = appUserVm.Gender;
//public bool IsActive { set; get; }
appUser.IsActive = appUserVm.IsActive;
//public bool IsSystemAccount { set; get; }
appUser.IsSystemAccount = appUserVm.IsSystemAccount;
//public DateTimeOffset CreatedDate { set; get; }
appUser.CreatedDate = appUserVm.CreatedDate;
//public DateTimeOffset UpdatedDate { set; get; }
appUser.UpdatedDate = appUserVm.UpdatedDate;
//public string CreatedBy { set; get; }
appUser.CreatedBy = appUserVm.CreatedBy;
}
public async Task <ApiResponse> DeleteUser([FromBody] AppUserVm appUserVm)
{
if (repository.CurrentUser?.Id == appUserVm.Id)
{
return(new ApiResponse
{
ErrorMessage = "Невозможно удалить пользователя"
});
}
var dbResponse = await repository.AppUsers.DeleteAsync(appUserVm.Id);
if (dbResponse.Success)
{
return(new ApiResponse
{
Message = dbResponse.Message
});
}
return(new ApiResponse
{
ErrorMessage = dbResponse.ErrorMessage
});
}
public async Task <ApiResponse <AppUserVm> > UpdateUser([FromBody] AppUserVm userCredentials)
{
var dbResponse = await repository.AppUsers.UpdateAsync(userCredentials);
if (dbResponse.Success)
{
var userVm = new AppUserVm(dbResponse.Response);
var userRolesIds = repository.CustomRoles.Items.Select(x => x.Id);
var allRoles = repository.CustomRoles.Items.ToList();
var userCustomRoles = dbResponse.Response.AppUserCustomRoles.Select(x => x.CustomRole.Id);
userVm.CustomRoles.AddRange(allRoles.Select(r => new CustomRoleVm
{
Id = r.Id,
Name = r.Name,
Description = r.Description,
IsSelected = userCustomRoles.Contains(r.Id)
}).OrderBy(x => x.Name));
return(new ApiResponse <AppUserVm>
{
Response = userVm,
Message = dbResponse.Message
});
}
return(new ApiResponse <AppUserVm>
{
ErrorMessage = "Произошла ошибка при обработке вашего запроса"
});
}
/// <summary>
/// Create new instance of the manager base.
/// </summary>
/// <param name="repositories">Repository instance.</param>
/// <param name="appSettings">Application settings</param>
/// <param name="currentUser">Current user instance.</param>
protected StggManagerBase(IRepositories repositories, IAppSettings appSettings, AppUserVm currentUser)
{
Repositories = repositories;
CurrentUser = currentUser;
AppSettings = appSettings;
Factories = new Factories();
}
public async Task <HttpResponseMessage> Create(HttpRequestMessage request, AppUserVm appUserVm)
{
if (ModelState.IsValid)
{
var newAppUser = new AppUser();
newAppUser.UpdateUser(appUserVm);
newAppUser.CreatedDate = GetDateTimeNowUTC();
newAppUser.CreatedBy = User.Identity.GetUserId();
newAppUser.IsSystemAccount = true;
try
{
newAppUser.Id = Guid.NewGuid().ToString();
var result = await _userManager.CreateAsync(newAppUser, appUserVm.Password);
if (result.Succeeded)
{
var listAppUserGroup = new List <AppUserGroup>();
foreach (var group in appUserVm.Groups)
{
listAppUserGroup.Add(new AppUserGroup()
{
GroupId = group.Id,
UserId = newAppUser.Id
});
//add role to user
var listRole = _appRoleService.GetListRoleByGroupId(group.Id);
foreach (var role in listRole)
{
await _userManager.RemoveFromRoleAsync(newAppUser.Id, role.Name);
await _userManager.AddToRoleAsync(newAppUser.Id, role.Name);
}
}
_appGroupService.AddUserToGroups(listAppUserGroup, newAppUser.Id);
return(request.CreateResponse(HttpStatusCode.OK, appUserVm));
}
else
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, string.Join(",", result.Errors)));
}
}
catch (NameDuplicatedException dex)
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, dex.Message));
}
catch (Exception ex)
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, ex.Message));
}
}
else
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
}
public ActionResult Login(AppUserVm appUserVM)
{
var user = db.AppUsers.Where(x => x.UserName == appUserVM.UserName && x.Password == appUserVM.Password).FirstOrDefault();
if (user != null)
{
Session["login"] = user;
return(RedirectToAction("Index", "Dashboard"));
}
else
{
return(View());
}
}
public async Task <HttpResponseMessage> Update(HttpRequestMessage request, AppUserVm applicationUserViewModel)
{
if (ModelState.IsValid)
{
var appUser = await _userManager.FindByIdAsync(applicationUserViewModel.Id);
RemoveAllRoleOfUser(appUser);
try
{
appUser.UpdateUser(applicationUserViewModel);
appUser.UpdatedDate = GetDateTimeNowUTC();
appUser.UpdatedBy = User.Identity.GetUserId();
var result = await _userManager.UpdateAsync(appUser);
if (result.Succeeded)
{
var listAppUserGroup = new List <AppUserGroup>();
foreach (var group in applicationUserViewModel.Groups)
{
listAppUserGroup.Add(new AppUserGroup()
{
GroupId = group.Id,
UserId = applicationUserViewModel.Id
});
//add role to user
var listRole = _appRoleService.GetListRoleByGroupId(group.Id);
foreach (var role in listRole)
{
await _userManager.AddToRoleAsync(appUser.Id, role.Name);
}
}
_appGroupService.AddUserToGroups(listAppUserGroup, applicationUserViewModel.Id);
return(request.CreateResponse(HttpStatusCode.OK, applicationUserViewModel));
}
else
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, string.Join(",", result.Errors)));
}
}
catch (NameDuplicatedException dex)
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, dex.Message));
}
}
else
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
}
/// <summary>
/// Find a user by UserName.
/// </summary>
/// <param name="userName">UserName of the account.</param>
public async Task <StggResult <AppUserVm> > FindByUserNameAsync(string userName)
{
// Find the user account
var stggResult = new StggResult <AppUserVm>();
var user = await AppUserManager.FindByNameAsync(userName);
if (user == null)
{
stggResult.AddError("User not found.");
return(stggResult);
}
// Convert the user account into an application user view model
var userRoleIds = user.Roles.Select(e => e.RoleId);
var roleNames = FindRolesByIds(userRoleIds);
var appUserVm = new AppUserVm(user, roleNames);
return(new StggResult <AppUserVm>(appUserVm));
}
/// <summary>
/// Set current user account.
/// </summary>
/// <param name="appUserVm">Application user account object.</param>
/// <param name="rememberMe">True to remember this person.</param>
public static void SetCurrentUser(AppUserVm appUserVm, bool rememberMe = false)
{
SessionManager.Set(SessionKey.CurrentUser, appUserVm);
// The user is not authenticated, we need not to add ASP.NET cookie.
if (!appUserVm.Identity.IsAuthenticated)
{
return;
}
Thread.CurrentPrincipal = HttpContext.Current.User = appUserVm;
var roles = string.Join(",", appUserVm.Roles);
var expireDateTime = DateTime.UtcNow.AddDays(7);
// Create an authenticated cookie.
var ticket = new FormsAuthenticationTicket(
1, /* version number of the ticket */
appUserVm.Identity.Name,
DateTime.UtcNow,
expireDateTime,
rememberMe,
roles,
FormsAuthentication.FormsCookiePath);
var encryptedTicket = FormsAuthentication.Encrypt(ticket);
var cookie = new HttpCookie(FormsAuthentication.FormsCookieName, encryptedTicket)
{
HttpOnly = true,
Expires = rememberMe
? expireDateTime
: DateTime.MinValue
};
HttpContext.Current.Response.Cookies.Add(cookie);
}
public ContentManager(IRepositories repositories, IAppSettings appSettings, AppUserVm currentUser)
: base(repositories, appSettings, currentUser)
{
}
public SportsTypeManager(IRepositories repositories, IAppSettings appSettings, AppUserVm currentUser)
: base(repositories, appSettings, currentUser)
{
}
public async Task <HttpResponseMessage> ResetPassword(HttpRequestMessage request, AppUserVm userVm)
{
//var appUser = await _userManager.FindByIdAsync(User.Identity.GetUserId());
var remove = await _userManager.RemovePasswordAsync(userVm.Id);
var passWord = DateTime.Now.ToString("ddMMyyyyss");
var result = await _userManager.AddPasswordAsync(userVm.Id, passWord);
if (result.Succeeded)
{
return(request.CreateResponse(HttpStatusCode.OK, passWord));
}
else
{
return(request.CreateErrorResponse(HttpStatusCode.OK, "Không cập nhật được password"));
}
}
/// <summary>
/// Authenticate a user.
/// </summary>
/// <param name="appUserLoginVm">Login view model.</param>
public async Task <StggResult <SignInStatus, AppUserVm> > LoginAsync(AppUserLoginVm appUserLoginVm)
{
var stggResult = new StggResult <SignInStatus, AppUserVm>();
var appUserVm = new AppUserVm();
var user = await AppUserManager.FindByNameAsync(appUserLoginVm.UserName);
if (user != null)
{
var isLockedOut = await AppUserManager.IsLockedOutAsync(user.Id);
if (AppUserManager.SupportsUserLockout && isLockedOut)
{
// User is locked.
appUserVm.SignInStatus = SignInStatus.LockedOut;
}
else
{
// Authenticate user.
if (AppUserManager.CheckPassword(user, appUserLoginVm.Password))
{
// Now we need to check and reset the Access Failed Counter for this user.
var getAccessFailedExceeded = AppUserManager.GetAccessFailedCount(user.Id) > 0;
if (AppUserManager.SupportsUserLockout && getAccessFailedExceeded)
{
// Reset the failed count.
var resetAccessFailResult = await AppUserManager.ResetAccessFailedCountAsync(user.Id);
if (resetAccessFailResult.Succeeded == false)
{
appUserVm.SignInStatus = SignInStatus.Failed;
stggResult.AddError("Failed to login.");
}
}
var emailIsConfirmed = AppUserManager.IsEmailConfirmed(user.Id);
if (!emailIsConfirmed)
{
appUserVm.SignInStatus = SignInStatus.RequiresVerification;
stggResult.AddError("Email requires verification.");
}
var userRoleIds = user.Roles.Select(e => e.RoleId);
var roleNames = FindRolesByIds(userRoleIds);
appUserVm = new AppUserVm(user, roleNames, true);
}
else
{
var lockedoutEnabledForUser = await AppUserManager.GetLockoutEnabledAsync(user.Id);
// Password was not valid.
if (AppUserManager.SupportsUserLockout && lockedoutEnabledForUser)
{
// Increment access failed count.
var accessFailedResult = await AppUserManager.AccessFailedAsync(user.Id);
if (accessFailedResult.Succeeded == false)
{
appUserVm.SignInStatus = SignInStatus.LockedOut;
stggResult.AddError("User is locked out.");
}
else
{
appUserVm.SignInStatus = SignInStatus.Failed;
}
}
else
{
appUserVm.SignInStatus = SignInStatus.Failed;
}
}
}
}
else
{
// We could not find this user from the database.
appUserVm.SignInStatus = SignInStatus.Failed;
}
stggResult.SetValue(appUserVm);
stggResult.SetStatus(appUserVm.SignInStatus);
return(stggResult);
}
/// <summary>
/// Create a new instance of the stat track application manager.
/// </summary>
public Managers(IAppSettings appSettings, AppUserVm currentUser = null)
{
_repositories = new StggRepositories(new StatTrackEntitiesFactory().Create());
_appSettings = appSettings;
_currentUser = currentUser;
}
public async Task <ApiResponse <AppUserVm> > AddUser([FromBody] AppUserVm userCredentials)
{
var defaultErrorResponse = new ApiResponse <AppUserVm>
{
ErrorMessage = "Пожалуйста, предоставьте все необходимые данные для создания учетной записи пользователя"
};
if (userCredentials == null)
{
return(defaultErrorResponse);
}
if (string.IsNullOrWhiteSpace(userCredentials.UserName))
{
return(defaultErrorResponse);
}
if (repository.AppUsers.Items.Any(userEmail => userEmail.Email == userCredentials.Email) ||
repository.AppUsers.Items.Any(userLogin => userLogin.UserName == userCredentials.UserName))
{
return(new ApiResponse <AppUserVm>
{
ErrorMessage = "Пользователь с данной эл. почтой или логином уже существует"
});
}
if (!userCredentials.Email.IsEmail())
{
return(new ApiResponse <AppUserVm>
{
ErrorMessage = "Не корректная эл. почта"
});
}
var user = new AppUser
{
UserName = userCredentials.UserName.Trim(),
Email = userCredentials.Email.Trim()
};
user.AppUserCustomRoles = userCredentials.CustomRoles.Where(x => x.IsSelected).Select(cr => new AppUserCustomRole
{
CustomRoleId = cr.Id,
AppUserId = user.Id
}).ToList();
var randomPassword = RandomPasswordGenerator.GenerateRandomPassword();
var result = await userManager.CreateAsync(user, randomPassword);
if (result.Succeeded)
{
TestProjectEmailSender.SendAccountPasswordEmailAsync(user.Email, randomPassword);
var customRolesIds = userCredentials.CustomRoles.Where(x => x.IsSelected).Select(r => r.Id).ToList();
var appRolesToAdd = repository.CustomRoles.Items.Where(cr => customRolesIds.Contains(cr.Id))
.SelectMany(cRole => cRole.AppRoleCustomRoles).Select(x => x.AppRole.Name).ToList();
var rolesResult = await userManager.AddToRolesAsync(user, appRolesToAdd);
if (rolesResult.Succeeded)
{
var allRoles = repository.CustomRoles.Items.ToList();
var userVm = new AppUserVm(user);
userVm.CustomRoles.AddRange(allRoles.Select(r => new CustomRoleVm
{
Id = r.Id,
Name = r.Name,
Description = r.Description,
IsSelected = customRolesIds.Contains(r.Id)
}).OrderBy(x => x.Name));
return(new ApiResponse <AppUserVm>
{
Response = userVm,
Message = $"Пользователь успешно создан, пароль от учётной записи будет выслан на почту {userVm.Email} \n ... pass: {randomPassword}"
});
}
return(new ApiResponse <AppUserVm>
{
ErrorMessage = "Произошла ошибка при обработке вашего запроса"
});
}
return(new ApiResponse <AppUserVm>
{
ErrorMessage = result.Errors.AggregateErrors()
});
}
