/// <summary>
/// Delete Site
/// </summary>
/// <param name="userId"></param>
/// <param name="siteId"></param>
/// <returns></returns>
public async Task <TResponse <bool> > Delete(int userId,
int siteId)
{
try
{
var canDelete = await CanDelete(siteId);
if (canDelete.IsSuccess)
{
var result = await WriteRepository.ExecuteAsync(SqlQuery.SITE_DELETE, new
{
Id = siteId,
UserUpdated = userId
});
if (result.IsSuccess)
{
if (result.Data == 0)
{
return(await Fail <bool>(string.Format(ErrorEnum.SqlQueryCanNotExecute.GetStringValue(), "SITE_DELETE")));
}
return(await Ok(true));
}
return(await Fail <bool>(result.Message));
}
return(await Fail <bool>(canDelete.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
public async Task <TResponse <bool> > RemoveByKey(int userId,
string key)
{
try
{
var result = await WriteRepository.ExecuteAsync(SqlQuery.PERSISTED_GRANT_REMOVE_BY_KEY, new
{
UserUpdated = userId,
Key = key
});
if (result.IsSuccess)
{
if (result.Data > 0)
{
return(await Ok(true));
}
return(await Fail <bool>(string.Format(ErrorEnum.SqlQueryCanNotExecute.GetStringValue(), "PERSISTED_GRANT_REMOVE_BY_KEY")));
}
return(await Fail <bool>(result.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
public async Task <TResponse <bool> > RemoveBySubjectIdClientIdType(int userId,
string subjectId,
string clientId,
string type)
{
try
{
var result = await WriteRepository.ExecuteAsync(SqlQuery.PERSISTED_GRANT_REMOVE_BY_SUBJECT_CLIENT_TYPE, new
{
UserUpdated = userId,
SubjectId = subjectId,
ClientId = clientId,
Type = type
});
if (result.IsSuccess)
{
if (result.Data > 0)
{
return(await Ok(true));
}
return(await Fail <bool>(string.Format(ErrorEnum.SqlQueryCanNotExecute.GetStringValue(), "PERSISTED_GRANT_REMOVE_BY_SUBJECT_CLIENT_TYPE")));
}
return(await Fail <bool>(result.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
private async Task <TResponse <bool> > Update(int userId,
PersistedGrantDto persistedGrant)
{
try
{
var result = await WriteRepository.ExecuteAsync(SqlQuery.PERSISTED_GRANT_UPDATE, new
{
persistedGrant.ClientId,
persistedGrant.SubjectId,
persistedGrant.Key,
persistedGrant.Data,
persistedGrant.Type,
persistedGrant.CreationTime,
persistedGrant.Expiration,
UserUpdated = userId
});
if (result.IsSuccess)
{
if (result.Data > 0)
{
return(await Ok(true));
}
return(await Fail <bool>(string.Format(ErrorEnum.SqlQueryCanNotExecute.GetStringValue(), "PERSISTED_GRANT_UPDATE")));
}
return(await Fail <bool>(result.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
public async Task <TResponse <bool> > Insert(Models.LogAccount logAccount)
{
try
{
string sqlQuery = @"INSERT dbo.LogAccount (UserId, UserAgentId, IpAddress, Datetime) VALUES (@UserId, @UserAgentId, @IpAddress, @Datetime)";
var result = await WriteRepository.ExecuteAsync(sqlQuery,
new
{
logAccount.UserId,
logAccount.UserAgentId,
logAccount.IpAddress,
logAccount.DateTime
});
if (result.IsSuccess)
{
if (result.Data > 0)
{
return(await Ok(true));
}
return(await Fail <bool>("Can not insert log account"));
}
return(await Fail <bool>(result.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
public async Task <TResponse <bool> > Update(int userId,
UpdateCrmPriorityModel request,
int permissionId)
{
try
{
var checkValid = await _userService.CheckPermission(userId,
permissionId);
if (checkValid.IsSuccess)
{
var canUpdate = await CanUpdate(request);
if (canUpdate.IsSuccess)
{
var result = await WriteRepository.ExecuteAsync(SqlQuery.CRM_PRIORITY_UPDATE,
new
{
request.Id,
request.Name,
request.Color,
UserUpdated = userId,
DateUpdated = DateTime.Now
});
if (result.IsSuccess)
{
if (result.Data > 0)
{
#region Update redis cache
await _crmPriorityCacheService.AddOrUpdate(new CrmPriorityCacheModel
{
Id = request.Id,
Name = request.Name,
Color = request.Color
});
#endregion
return(await Ok(true));
}
return(await Fail <bool>(ErrorEnum.BAD_REQUEST.GetStringValue()));
}
return(await Fail <bool>(result.Message));
}
return(await Fail <bool>(canUpdate.Message));
}
return(await Fail <bool>(checkValid.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
public async Task <TResponse <bool> > Add(int userId,
InsertProductModel request,
int permissionId)
{
try
{
var checkValid = await _userService.CheckPermission(userId,
permissionId);
if (checkValid.IsSuccess)
{
var canInsert = await CanInsert(request);
if (canInsert.IsSuccess)
{
var result = await WriteRepository.ExecuteAsync(SqlQuery.PRODUCT_INSERT,
new
{
request.Name,
request.ImportPrice,
request.SellPrice,
request.MinCount,
request.MaxCount,
request.WarrantyMonth,
request.ProductUnitId,
request.ProductGroupId,
request.ProductStatusId,
request.ManufacturerId,
request.CountryId,
request.Description,
UserCreated = userId,
DateCreated = DateTime.Now,
UserUpdated = userId,
DateUpdated = DateTime.Now
});
if (result.IsSuccess)
{
if (result.Data > 0)
{
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 <TResponse <bool> > Delete(int userId,
int id,
int permissionId)
{
try
{
var checkValid = await CheckPermission(userId,
permissionId);
if (checkValid.IsSuccess)
{
var canDelete = await CanDelete(id);
if (canDelete.IsSuccess)
{
var result = await WriteRepository.ExecuteAsync(SqlQuery.USER_DELETE,
new
{
Id = id,
UserUpdated = userId,
DateUpdated = DateTime.Now
});
if (result.IsSuccess)
{
if (result.Data > 0)
{
//TODO: xoa file avatar
#region Update redis cache
await _userCacheService.Remove(id);
#endregion
return(await Ok(true));
}
return(await Fail <bool>(ErrorEnum.BAD_REQUEST.GetStringValue()));
}
return(await Fail <bool>(result.Message));
}
return(await Fail <bool>(canDelete.Message));
}
return(await Fail <bool>(checkValid.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
public async Task <TResponse <bool> > Add(int userId,
InsertRoleModel request,
int permissionId)
{
try
{
var checkValid = await _userService.CheckPermission(userId,
permissionId);
if (checkValid.IsSuccess)
{
var canInsert = await CanInsert(request);
if (canInsert.IsSuccess)
{
var result = await WriteRepository.ExecuteAsync(SqlQuery.ROLE_INSERT,
new
{
request.Name,
UserCreated = userId,
DateCreated = DateTime.Now,
UserUpdated = userId,
DateUpdated = DateTime.Now
});
if (result.IsSuccess)
{
if (result.Data > 0)
{
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));
}
}
/// <summary>
/// Delete User
/// </summary>
/// <param name="userId"></param>
/// <param name="userIsDeletedId"></param>
/// <returns></returns>
public async Task <TResponse <bool> > Delete(int userId,
int userIsDeletedId)
{
try
{
var canDelete = await CanDelete(userIsDeletedId);
if (canDelete.IsSuccess)
{
var result = await WriteRepository.ExecuteAsync(SqlQuery.USER_DELETE, new
{
Id = userIsDeletedId,
UserUpdated = userId
});
if (result != null)
{
if (result.IsSuccess)
{
if (result.Data == 0)
{
return(await Fail <bool>($"Delete USER {userIsDeletedId} is failure"));
}
return(await Ok(true));
}
return(await Fail <bool>(result.Message));
}
return(await Fail <bool>($"DELETE USER {userIsDeletedId} is failure"));
}
return(await Fail <bool>(canDelete.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
public async Task <TResponse <bool> > ChangePassword(int userId,
string password,
string newPassword)
{
try
{
var canChangePassword = await CanChangePassword(userId,
password);
if (canChangePassword.IsSuccess)
{
newPassword = Sha512(newPassword);
var result = await WriteRepository.ExecuteAsync(SqlQuery.USER_CHANGE_PASSWORD,
new
{
Id = userId,
Password = newPassword
});
if (result.IsSuccess)
{
if (result.Data > 0)
{
return(await Ok(true));
}
return(await Fail <bool>(ErrorEnum.BAD_REQUEST.GetStringValue()));
}
return(await Fail <bool>(result.Message));
}
return(await Fail <bool>(canChangePassword.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
public async Task <TResponse <bool> > ChangePassword(string username,
string currentPassword,
string password)
{
try
{
var checkPassword = await CheckInvalidPassword(username, currentPassword);
if (checkPassword.IsSuccess)
{
var result = await WriteRepository.ExecuteAsync(SqlQuery.USER_UPDATED_PASSWORD, new
{
Id = checkPassword.Data,
Password = Sha512(password),
UserUpdated = checkPassword.Data
});
if (result.IsSuccess)
{
if (result.Data > 0)
{
return(await Ok(true));
}
return(await Fail <bool>(string.Format(ErrorEnum.SqlQueryCanNotExecute.GetStringValue(), "USER_UPDATED_PASSWORD")));
}
return(await Fail <bool>(result.Message));
}
return(await Fail <bool>(checkPassword.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
public async Task <TResponse <bool> > UpdateInformation(UserDto user)
{
try
{
var canUpdate = await GetById(user.Id);
if (canUpdate.IsSuccess)
{
var result = await WriteRepository.ExecuteAsync(SqlQuery.USER_UPDATE_INFORMATION, new
{
user.Id,
user.Email,
user.Name,
user.Phone,
UserUpdated = user.Id
});
if (result.IsSuccess)
{
if (result.Data > 0)
{
return(await Ok(true));
}
return(await Fail <bool>(string.Format(ErrorEnum.SqlQueryCanNotExecute.GetStringValue(), "USER_UPDATE_INFORMATION")));
}
return(await Fail <bool>(result.Message));
}
return(await Fail <bool>(canUpdate.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
/// <summary>
/// Change User Password
/// </summary>
/// <param name="userId"></param>
/// <param name="id"></param>
/// <param name="password"></param>
/// <returns></returns>
public async Task <TResponse <bool> > ChangePassword(int userId,
int id,
string password)
{
try
{
var canChangePassword = await CanChangePassword(id);
if (canChangePassword.IsSuccess)
{
var result = await WriteRepository.ExecuteAsync(SqlQuery.USER_CHANGE_PASSWORD, new
{
Id = id,
Password = Sha512(password),
UserUpdated = userId
});
if (result.IsSuccess)
{
if (result.Data > 0)
{
return(await Ok(true));
}
return(await Fail <bool>(string.Format(ErrorEnum.SqlQueryCanNotExecute.GetStringValue(), "USER_CHANGE_PASSWORD")));
}
return(await Fail <bool>(result.Message));
}
return(await Fail <bool>(canChangePassword.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
/// <summary>
/// Update Site
/// </summary>
/// <param name="userId"></param>
/// <param name="request"></param>
/// <returns></returns>
public async Task <TResponse <bool> > Update(int userId,
UpdateSiteModel request)
{
try
{
var canUpdate = await CanUpdate(request);
if (canUpdate.IsSuccess)
{
var result = await WriteRepository.ExecuteAsync(SqlQuery.SITE_UPDATE, new
{
request.Id,
request.SiteCode,
request.SiteName,
UserUpdated = userId
});
if (result.IsSuccess)
{
if (result.Data == 0)
{
return(await Fail <bool>(string.Format(ErrorEnum.SqlQueryCanNotExecute.GetStringValue(), "SITE_UPDATE")));
}
return(await Ok(true));
}
return(await Fail <bool>(result.Message));
}
return(await Fail <bool>(canUpdate.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
public async Task<TResponse<bool>> Add(InsertNotificationModel request)
{
try
{
var result = await WriteRepository.ExecuteAsync(SqlQuery.NOTIFICATION_INSERT,
new
{
request.UserId,
request.UserReceiveId,
request.Title,
request.Message,
request.Action,
request.Type,
request.Status,
DateCreated = DateTime.Now,
DateUpdated = request.Status == 0
? null
: (DateTime?) DateTime.Now
});
if(result.IsSuccess)
{
if(result.Data > 0)
{
return await Ok(true);
}
return await Fail<bool>(ErrorEnum.BAD_REQUEST.GetStringValue());
}
return await Fail<bool>(result.Message);
}
catch (Exception exception)
{
return await Fail<bool>(exception);
}
}
public async Task <TResponse <bool> > UpdateInformationUser(int userId,
UpdateInformationModel request,
string folder)
{
try
{
var user = await GetById(userId);
if (user.IsSuccess)
{
var image = request.Image;
string avatar = string.Empty;
if (image != null &&
image.Length > 0)
{
avatar = $"{user.Data.Username}.png";
}
var result = await WriteRepository.ExecuteAsync(SqlQuery.USER_UPDATE_INFORMATION,
new
{
request.FullName,
request.DisplayName,
request.PhoneNumber,
request.Email,
request.BranchId,
request.Avatar,
UserUpdated = userId,
DateUpdated = DateTime.Now,
Id = userId
});
if (result.IsSuccess)
{
if (result.Data > 0)
{
if (image != null &&
image.Length > 0)
{
try
{
if (!Directory.Exists(folder))
{
Directory.CreateDirectory(folder);
}
using (FileStream filestream = File.Create(Path.Combine(folder,
user.Data.Username) + ".png"))
{
image.CopyTo(filestream);
filestream.Flush();
}
}
catch (Exception ex)
{
}
}
return(await Ok(true));
}
return(await Fail <bool>(ErrorEnum.CAN_NOT_CHANGE_USER_INFORMATION.GetStringValue()));
}
}
return(await Fail <bool>(user.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
public async Task <TResponse <bool> > Log(AuditTableKafkaMessage <AuditCrm> crm)
{
try
{
string title = string.Empty;
switch (crm.LogType)
{
case LogTypeEnum.INSERT:
title = "đã thêm mới Cơ hội bán hàng";
break;
case LogTypeEnum.UPDATE:
title = "đã cập nhật cơ hội bán hàng";
break;
case LogTypeEnum.CHANGE_STATUS:
title = "đã thay đổi trạng thái";
break;
case LogTypeEnum.COMMENT:
title = "đã bình luận";
break;
}
string message = await BuildMessage(crm);
var result = await WriteRepository.ExecuteScalarAsync <int>(SqlQuery.INSERT_LOG, new
{
TableName = "Crm",
ObjectId = crm.Id,
Title = title,
Message = message,
crm.UserId,
LogDate = DateTime.Now,
OldStatusId = crm.OldValue.CrmStatusId,
StatusId = crm.Value.CrmStatusId
});
if (result.IsSuccess)
{
if (result.Data > 0)
{
if (crm.Attachments.Any())
{
foreach (var crmAttachment in crm.Attachments)
{
await WriteRepository.ExecuteAsync(SqlQuery.INSERT_LOG_ATTACHMENTS, new
{
TableLogId = result.Data,
Attachment = crmAttachment.Key,
AttachmentName = crmAttachment.Value
});
}
}
Logger.Info($"Insert log CRM: {title} - {message}");
return(await Ok(true));
}
return(await Fail <bool>($"Can not insert log: {crm.ToJson()}"));
}
return(await Fail <bool>(result.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
/// <summary>
/// Update User
/// </summary>
/// <param name="userId"></param>
/// <param name="user"></param>
/// <returns></returns>
public async Task <TResponse <bool> > Update(int userId,
UpdateUserModel user)
{
try
{
var canUpdate = await CanUpdate(user);
if (canUpdate.IsSuccess)
{
var result = await WriteRepository.ExecuteAsync(SqlQuery.USER_UPDATE, new
{
user.Id,
user.Email,
user.Name,
user.Phone,
UserUpdated = userId
});
if (result != null)
{
if (result.IsSuccess)
{
if (result.Data == 0)
{
return(await Fail <bool>($"Update USER {user.Id} is failure"));
}
#region Set Sites
var sites = user.Sites ?? new List <int>();
var oldSites = await ReadOnlyRepository.QueryAsync <SiteModel>(SqlQuery.SITE_GET_BY_USER_ID, new
{
UserId = user.Id
});
//kiem tra site nao chua ton tai thi them moi
foreach (var site in sites)
{
var exist = await ReadOnlyRepository.QueryFirstOrDefaultAsync <int>(SqlQuery.USER_CHECK_SITE_VALID, new
{
UserId = user.Id,
SiteId = site
});
if (exist.IsSuccess)
{
if (exist.Data == 0)
{
//chua co, them moi vao
var siteId = await ReadOnlyRepository.QueryFirstOrDefaultAsync <SiteModel>(SqlQuery.SITE_GET_BY_ID, new
{
Id = site
});
if (siteId.IsSuccess &&
siteId.Data != null)
{
await WriteRepository.ExecuteAsync(SqlQuery.USER_SITE_INSERT, new
{
UserId = user.Id,
SiteId = siteId.Data.Id,
UserCreated = userId,
UserUpdated = userId
});
}
}
}
}
//kiem tra site nao bi xoa bo
if (oldSites.IsSuccess)
{
if (oldSites.Data != null &&
oldSites.Data.Any())
{
foreach (var oldSite in oldSites.Data)
{
if (!sites.Contains(oldSite.Id))
{
await WriteRepository.ExecuteAsync(SqlQuery.REMOVE_USER_FROM_SITE, new
{
UserId = user.Id,
SiteId = oldSite.Id,
UserUpdated = userId
});
}
}
}
}
#endregion
#region Set Roles
var roles = user.Roles ?? new List <int>();
var oldRoles = await ReadOnlyRepository.QueryAsync <RoleModel>(SqlQuery.ROLE_GET_BY_USER_ID, new
{
UserId = user.Id
});
//kiem tra role nao chua ton tai thi them moi
foreach (var role in roles)
{
var exist = await ReadOnlyRepository.QueryFirstOrDefaultAsync <int>(SqlQuery.USER_CHECK_ROLE_VALID, new
{
UserId = user.Id,
RoleId = role
});
if (exist.IsSuccess)
{
if (exist.Data == 0)
{
//chua co, them moi vao
var roleId = await ReadOnlyRepository.QueryFirstOrDefaultAsync <RoleModel>(SqlQuery.ROLE_GET_BY_ID, new
{
Id = role
});
if (roleId.IsSuccess &&
roleId.Data != null)
{
await WriteRepository.ExecuteAsync(SqlQuery.USER_ROLE_INSERT, new
{
UserId = user.Id,
RoleId = roleId.Data.Id,
UserCreated = userId,
UserUpdated = userId
});
}
}
}
}
//kiem tra role nao bi xoa bo
if (oldRoles.IsSuccess)
{
if (oldRoles.Data != null &&
oldRoles.Data.Any())
{
foreach (var oldRole in oldRoles.Data)
{
if (!roles.Contains(oldRole.Id))
{
await WriteRepository.ExecuteAsync(SqlQuery.REMOVE_USER_FROM_ROLE, new
{
UserId = user.Id,
RoleId = oldRole.Id,
UserUpdated = userId
});
}
}
}
}
#endregion
return(await Ok(true));
}
return(await Fail <bool>(result.Message));
}
return(await Fail <bool>($"Update USER {user.Id} is failure"));
}
return(await Fail <bool>(canUpdate.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
public async Task Update(int crmId,
List <int> userIds,
int type,
int userUpdated)
{
var crmUsers = await LoadFromRedis();
var existUserIds = crmUsers.Where(c => c.CrmId == crmId && c.Type == type)
.Select(c => c.UserId);
foreach (var userId in userIds)
{
if (!existUserIds.Contains(userId))
{
//them moi
var result = await WriteRepository.ExecuteScalarAsync <int>(SqlQuery.INSERT_CRM_USER,
new
{
CrmId = crmId,
UserId = userId,
Type = type,
UserCreated = userUpdated,
DateCreated = DateTime.Now,
UserUpdated = userUpdated,
DateUpdated = DateTime.Now
});
if (result.IsSuccess)
{
if (result.Data > 0)
{
crmUsers.Add(new CrmUserCacheModel
{
Id = result.Data,
CrmId = crmId,
UserId = userId,
Type = type
});
}
}
}
}
foreach (var existUserId in existUserIds)
{
if (!userIds.Contains(existUserId))
{
//xoa bo
var result = await WriteRepository.ExecuteAsync(SqlQuery.REMOVE_CRM_USER,
new
{
CrmId = crmId,
UserId = existUserId,
Type = type,
UserUpdated = userUpdated,
DateUpdated = DateTime.Now
});
if (result.IsSuccess)
{
if (result.Data > 0)
{
var crmUser = crmUsers.FirstOrDefault(c => c.CrmId == crmId && c.UserId == existUserId && c.Type == type);
if (crmUser != null)
{
crmUsers.Remove(crmUser);
}
}
}
}
}
await DistributedCache.Set(_cacheKey,
crmUsers);
}
public async Task <TResponse <bool> > Update(int userId,
UpdateBranchModel request,
int permissionId)
{
try
{
var checkValid = await _userService.CheckPermission(userId,
permissionId);
if (checkValid.IsSuccess)
{
var canUpdate = await CanUpdate(request);
if (canUpdate.IsSuccess)
{
var result = await WriteRepository.ExecuteAsync(SqlQuery.BRANCH_UPDATE,
new
{
request.Id,
request.Name,
request.Hotline,
request.Address,
request.ProvinceId,
request.DistrictId,
request.WardId,
UserUpdated = userId,
DateUpdated = DateTime.Now
});
if (result.IsSuccess)
{
if (result.Data > 0)
{
#region Update redis cache
await _branchCacheService.AddOrUpdate(new BranchCacheModel
{
Id = request.Id,
Name = request.Name,
Hotline = request.Hotline,
ProvinceId = request.ProvinceId,
DistrictId = request.DistrictId,
WardId = request.WardId,
Address = request.Address
});
#endregion
return(await Ok(true));
}
return(await Fail <bool>(ErrorEnum.BAD_REQUEST.GetStringValue()));
}
return(await Fail <bool>(result.Message));
}
return(await Fail <bool>(canUpdate.Message));
}
return(await Fail <bool>(checkValid.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
public async Task <TResponse <bool> > Update(int userId,
UpdateWarrantyStatusModel request,
int permissionId)
{
try
{
var checkValid = await _userService.CheckPermission(userId,
permissionId);
if (checkValid.IsSuccess)
{
var canUpdate = await CanUpdate(request);
if (canUpdate.IsSuccess)
{
var result = await WriteRepository.ExecuteAsync(SqlQuery.WARRANTY_STATUS_UPDATE,
new
{
request.Id,
request.Name,
request.Color,
request.SortOrder,
request.IsSendSms,
request.SmsContent,
UserUpdated = userId,
DateUpdated = DateTime.Now
});
if (result.IsSuccess)
{
if (result.Data > 0)
{
#region Update redis cache
await _warrantyStatusCacheService.AddOrUpdate(new WarrantyStatusCacheModel
{
Id = request.Id,
Name = request.Name,
Color = request.Color,
SortOrder = request.SortOrder,
SmsContent = request.SmsContent,
IsSendSms = request.IsSendSms
});
#endregion
return(await Ok(true));
}
return(await Fail <bool>(ErrorEnum.BAD_REQUEST.GetStringValue()));
}
return(await Fail <bool>(result.Message));
}
return(await Fail <bool>(canUpdate.Message));
}
return(await Fail <bool>(checkValid.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
public async Task <TResponse <bool> > Update(int userId,
UpdateUserModel request,
int permissionId,
string path)
{
try
{
var checkValid = await CheckPermission(userId,
permissionId);
if (checkValid.IsSuccess)
{
var canUpdate = await CanUpdate(request);
if (canUpdate.IsSuccess)
{
string avatar = string.Empty;
var image = request.Avatar;
if (image != null &&
image.Length > 0)
{
avatar = $"{request.Username}.png";
}
var result = await WriteRepository.ExecuteAsync(SqlQuery.USER_UPDATE,
new
{
request.Id,
request.DisplayName,
request.FullName,
request.Email,
request.PhoneNumber,
request.BranchId,
request.RoleId,
Avatar = avatar,
UserUpdated = userId,
DateUpdated = DateTime.Now
});
if (result.IsSuccess)
{
if (result.Data > 0)
{
string message = string.Empty;
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 ex)
{
message = ex.ToString();
}
}
#region Update redis cache
await _userCacheService.AddOrUpdate(new UserCacheModel
{
Id = request.Id,
Username = request.Username,
DisplayName = request.DisplayName,
Email = request.Email,
PhoneNumber = request.PhoneNumber,
FullName = request.FullName
});
#endregion
return(await Ok(true,
message));
}
return(await Fail <bool>(ErrorEnum.BAD_REQUEST.GetStringValue()));
}
return(await Fail <bool>(result.Message));
}
return(await Fail <bool>(canUpdate.Message));
}
return(await Fail <bool>(checkValid.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
/// <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));
}
}