private async Task <TResponse <bool> > CanInsert(InsertUserModel request)
{
try
{
var user = await ReadOnlyRepository.QueryFirstOrDefaultAsync <UserModel>(SqlQuery.USER_FIND_BY_USERNAME,
new
{
request.Username
});
if (user.IsSuccess)
{
if (user.Data != null)
{
return(await Fail <bool>(ErrorEnum.USERNAME_HAS_EXIST.GetStringValue()));
}
return(await Ok(true));
}
return(await Fail <bool>(user.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
private async Task <TResponse <bool> > CanInsert(InsertUserModel user)
{
try
{
var users = await ReadOnlyRepository.QueryAsync <UserModel>(SqlQuery.USER_FIND_BY_NAME,
new
{
user.Username
});
if (users != null)
{
if (users.IsSuccess)
{
if (users.Data.Any())
{
return(await Fail <bool>(ErrorEnum.UserNameHasExist.GetStringValue()));
}
return(await Ok(true));
}
return(await Fail <bool>(users.Message));
}
return(await Ok(true));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
public async Task <ActionResult <bool> > Add([FromForm] InsertUserModel request)
{
var webRoot = _env.WebRootPath;
var PathWithFolderName = System.IO.Path.Combine(webRoot, "Avatars");
return(Ok(await UserService.Add(await GetUserId(),
request,
GetPermissionId(), PathWithFolderName)));
}
public async Task <TResponse <bool> > Insert(InsertUserModel request)
{
try
{
var response = await HttpService.Send <bool>(BaseUrl + ApiUrl.USER_INSERT, request, HttpMethod.Post);
if (response.IsSuccess)
{
return(await Ok(response.Data));
}
return(await Fail <bool>(response.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
public async Task <IActionResult> Add(InsertUserModel model)
{
if (ModelState.IsValid)
{
var result = await _userService.Insert(model);
if (result.IsSuccess)
{
StatusMessage = SuccessNotifcation("Insert user success!");
return(RedirectToAction("Index"));
}
ModelState.AddModelError("", result.Message);
}
await LoadSites();
return(View(model));
}
public async Task <IActionResult> Add(InsertUserModel model)
{
if (ModelState.IsValid)
{
var result = await _userService.Insert(_mapper.Map <InsertUserModel, InsertUserRequest>(model));
if (result.IsSuccess)
{
TempData["Update"] = result.ToJson();
return(RedirectToAction("Index",
"User"));
}
ModelState.AddModelError("",
result.Message);
}
await SetViewBag();
return(View(model));
}
public async Task <TResponse <bool> > Add(int userId,
InsertUserModel request,
int permissionId,
string path)
{
try
{
var checkValid = await CheckPermission(userId,
permissionId);
if (checkValid.IsSuccess)
{
var canInsert = await CanInsert(request);
if (canInsert.IsSuccess)
{
string avatar = string.Empty;
var image = request.Avatar;
if (image != null &&
image.Length > 0)
{
avatar = $"{request.Username}.png";
}
var result = await WriteRepository.ExecuteScalarAsync <int>(SqlQuery.USER_INSERT,
new
{
request.Username,
Password = Sha512(request.Password),
request.DisplayName,
request.FullName,
request.PhoneNumber,
request.Email,
request.BranchId,
request.RoleId,
Avatar = avatar,
UserCreated = userId,
DateCreated = DateTime.Now,
UserUpdated = userId,
DateUpdated = DateTime.Now
});
if (result.IsSuccess)
{
if (result.Data > 0)
{
if (image != null &&
image.Length > 0)
{
try
{
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
using (FileStream fileStream = File.Create(Path.Combine(path,
request.Username) + ".png"))
{
image.CopyTo(fileStream);
fileStream.Flush();
}
}
catch (Exception exception)
{
Log(exception);
}
}
#region Update redis cache
await _userCacheService.AddOrUpdate(new UserCacheModel
{
Id = result.Data,
Username = request.Username,
DisplayName = request.DisplayName,
Email = request.Email,
PhoneNumber = request.PhoneNumber,
FullName = request.FullName
});
#endregion
return(await Ok(true));
}
return(await Fail <bool>(ErrorEnum.BAD_REQUEST.GetStringValue()));
}
return(await Fail <bool>(result.Message));
}
return(await Fail <bool>(canInsert.Message));
}
return(await Fail <bool>(checkValid.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
public async Task <ActionResult <bool> > Add(InsertUserModel req)
{
return(Ok(await _userService.Add(UserId,
req)));
}
/// <summary>
/// Add User
/// </summary>
/// <param name="userId"></param>
/// <param name="user"></param>
/// <returns></returns>
public async Task <TResponse <bool> > Add(int userId,
InsertUserModel user)
{
try
{
var canInsert = await CanInsert(user);
if (canInsert.IsSuccess)
{
var result = await WriteRepository.ExecuteScalarAsync <int>(SqlQuery.USER_INSERT, new
{
user.Username,
user.Email,
user.Name,
user.Phone,
Password = Sha512(user.Password),
UserCreated = userId,
UserUpdated = userId
});
if (result != null)
{
if (result.IsSuccess)
{
if (result.Data == 0)
{
return(await Fail <bool>($"Insert USER {user.Username} is failure"));
}
var insertedUserId = result.Data;
#region Insert site
if (user.Sites != null &&
user.Sites.Any())
{
foreach (var siteId in user.Sites)
{
var site = await ReadOnlyRepository.QueryFirstOrDefaultAsync <SiteModel>(SqlQuery.SITE_GET_BY_ID, new
{
Id = siteId
});
if (site.IsSuccess &&
site.Data != null)
{
await WriteRepository.ExecuteAsync(SqlQuery.USER_SITE_INSERT, new
{
UserId = insertedUserId,
SiteId = siteId,
UserCreated = userId,
UserUpdated = userId
});
}
}
}
#endregion
#region Insert role
if (user.Roles != null &&
user.Roles.Any())
{
foreach (var roleId in user.Roles)
{
var role = await ReadOnlyRepository.QueryFirstOrDefaultAsync <RoleModel>(SqlQuery.ROLE_GET_BY_ID, new
{
Id = roleId
});
if (role.IsSuccess &&
role.Data != null)
{
await WriteRepository.ExecuteAsync(SqlQuery.ROLE_GROUP_INSERT_USER, new
{
UserId = insertedUserId,
RoleId = roleId,
UserCreated = userId,
UserUpdated = userId
});
}
}
}
#endregion
return(await Ok(true));
}
return(await Fail <bool>(result.Message));
}
return(await Fail <bool>($"Insert USER {user.Username} is failure"));
}
return(await Fail <bool>(canInsert.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
