public async Task <IResponse> IsReadAsync(int id)
{
var entity = await _dal.GetAsync(x => x.Id == id);
entity.IsRead = true;
return(await _dal.UpdateAsync(entity));
}
public async Task <IResponse> RoomJoin(int roomId)
{
var entity = await _dal.GetAsync(_userService.AccountId);
entity.RoomId = roomId;
return(await _dal.UpdateAsync(entity));
}
public async Task <IEnumerable <IResponse> > SaveRangeAsync(IEnumerable <RuleModel> models)
{
var result = new List <IResponse>();
foreach (var model in models)
{
var entity = await _dal.GetAsync(model.Id);
if (entity == null)
{
entity = new Rule
{
ApplicationModule = model.ApplicationModule,
RoleId = model.RoleId,
View = model.View,
Insert = model.Insert,
Update = model.Update,
Delete = model.Delete
};
result.Add(await _dal.InsertAsync(entity));
}
else
{
entity.View = model.View;
entity.Insert = model.Insert;
entity.Update = model.Update;
entity.Delete = model.Delete;
result.Add(await _dal.UpdateAsync(entity));
}
}
return(result);
}
public async Task <IResponse> UpdateAsync(AssigmentModel model)
{
model.CreatedUser = $"{_userService.FirstName} {_userService.LastName}";
if (model.PersonnelId != _userService.PersonnelId && !_userService.IsAdmin)
{
return(new ErrorResponse(AspectMessage.AccessDenied));
}
return(await _dal.UpdateAsync(_mapper.Map <Assigment>(model)));
}
private async Task <IDataResponse <LoginResultModel> > LoginAsync(User user, bool isRefreshLogin = false)
{
var roles = await _dalUserRole.TableNoTracking
.Include(x => x.Role)
.Include(x => x.User)
.Where(x => x.UserId == user.Id)
.Select(x => new UserRoleModel
{
Id = x.Id,
UserId = x.UserId,
RoleId = x.RoleId,
RoleName = x.Role.Name
})
.ToListAsync();
var accessToken = _tokenHelper.CreateToken(user.Id, roles);
var tokenOptions = _jwtOptions;
var userInfo = new UserInfo
{
UserId = user.Id,
FullName = $"{user.FirstName} {user.LastName}",
};
var u = await _dalUser.TableNoTracking.FirstOrDefaultAsync(x => x.Id == user.Id);
u.RefreshToken = accessToken.RefreshToken;
u.RefreshTokenExpiredDate = DateTime.Now.AddMinutes(tokenOptions.AccessTokenExpiration + 30);
await _dalUser.UpdateAsync(u);
_loggedInUsers.UserInfo = _loggedInUsers.UserInfo.Where(x => x.UserId == u.Id).ToList();
_loggedInUsers.UserInfo.Add(userInfo);
var result = new LoginResultModel
{
UserId = user.Id,
FullName = $"{user.FirstName} {user.LastName}",
Token = accessToken.Token,
RefreshToken = accessToken.RefreshToken,
TokenExpiration = DateTime.Now,
UserRoles = roles
};
return(new SuccessDataResponse <LoginResultModel>(result));
}
private async Task <IDataResponse <LoginResultModel> > LoginAsync(Account account, bool isRefreshLogin = false)
{
if (account.Email == "*****@*****.**")
{
account.AccountType = AccountType.SuperAdmin;
}
var user = new UserInfo
{
AccountId = account.Id,
AccountType = account.AccountType,
UserName = account.UserName,
};
var accessToken = _tokenHelper.CreateToken(account.Id);
var tokenOptions = _jwtOptions;
var acc = await _dal.TableNoTracking.FirstOrDefaultAsync(x => x.Id == account.Id);
acc.RefreshToken = accessToken.RefreshToken;
acc.RefreshTokenExpiredDate = DateTime.Now.AddMinutes(tokenOptions.AccessTokenExpiration + 30);
await _dal.UpdateAsync(acc);
_loggedInUsers.UserInfo = _loggedInUsers.UserInfo.Where(x => x.AccountId != account.Id).ToList();
_loggedInUsers.UserInfo.Add(user);
var result = new LoginResultModel
{
AccountId = account.Id,
UserName = account.UserName,
AccountType = account.AccountType,
Token = accessToken.Token,
RefreshToken = accessToken.RefreshToken,
TokenExpiration = DateTime.Now
};
return(new SuccessDataResponse <LoginResultModel>(result));
}
public async Task <IResponse> UpdateAsync(PersonnelModel model)
{
var entity = await _dal.GetAsync(x => x.Id == model.Id);
if (_userService.IsAdmin)
{
entity.FirstName = model.FirstName;
entity.LastName = model.LastName;
entity.Gsm = model.Gsm;
entity.Email = model.Email;
entity.PersonnelType = model.PersonnelType;
entity.RoleId = model.RoleId;
entity.TitleId = model.TitleId;
entity.DepartmentId = model.DepartmentId;
}
else
{
entity.FirstName = model.FirstName;
entity.LastName = model.LastName;
entity.Gsm = model.Gsm;
entity.Email = model.Email;
}
return(await _dal.UpdateAsync(entity));
}
public async Task <IResponse> UpdateAsync(NotificationModel model)
{
if (model.PersonnelId != null)
{
var entity = await _dal.TableNoTracking.FirstOrDefaultAsync(x => x.Id == model.Id);
if (model.PersonnelId != entity.PersonnelId)
{
var personNotify = await _dalPersonnelNotify.TableNoTracking.FirstOrDefaultAsync(x => x.NotificationId == model.Id);
personNotify.IsRead = false;
personNotify.PersonnelId = (int)model.PersonnelId;
await _dalPersonnelNotify.UpdateAsync(personNotify);
}
}
return(await _dal.UpdateAsync(_mapper.Map <Notification>(model)));
}
public async Task <IResponse> UpdateAsync(CategoryModel model)
{
var result = await _dal.UpdateAsync(_mapper.Map <Category>(model));
return(result);
}
public async Task <IResponse> UpdateAsync(RoleModel model)
{
return(await _dal.UpdateAsync(_mapper.Map <Role>(model)));
}
public async Task <IResponse> UpdateAsync(DepartmentModel model)
{
return(await _dal.UpdateAsync(_mapper.Map <Department>(model)));
}
public async Task <IResponse> UpdateAsync(ProductModel model)
{
return(await _dal.UpdateAsync(_mapper.Map <Product>(model)));
}
public async Task <IResponse> UpdateAsync(EmailTemplateModel model)
{
return(await _dal.UpdateAsync(_mapper.Map <EmailTemplate>(model)));
}
public async Task <IResponse> UpdateAsync(BlogModel model)
{
return(await _dal.UpdateAsync(_mapper.Map <Blog>(model)));
}
public async Task <IResponse> UpdateAsync(EmailParameterModel model)
{
return(await _dal.UpdateAsync(_mapper.Map <EmailParameter>(model)));
}
public async Task <IResponse> UpdateAsync(CategoryModel model)
{
return(await _dal.UpdateAsync(_mapper.Map <Category>(model)));
}
public async Task <IResponse> UpdateAsync(AuthorModel model)
{
return(await _dal.UpdateAsync(_mapper.Map <Author>(model)));
}
private async Task <IDataResponse <LoginResultModel> > LoginAsync(Personnel personnel, bool isRefreshLogin = false)
{
var roleId = personnel.RoleId;
if (personnel.Email == "*****@*****.**")
{
personnel.PersonnelType = PersonnelType.Admin;
}
var rules = await _dalRule.TableNoTracking.Where(x => x.RoleId == roleId).ToListAsync();
var rulesModel = rules.Select(x => new PersonnelRulesModel
{
ApplicationModule = x.ApplicationModule,
Delete = x.Delete,
Insert = x.Insert,
Update = x.Update,
View = x.View,
ApplicationModuleName = EnumHelper.GetDisplayValue(x.ApplicationModule),
}).ToList();
var user = new UserInfo
{
PersonnelId = personnel.Id,
FirstName = personnel.FirstName,
LastName = personnel.LastName,
PersonnelType = personnel.PersonnelType,
Email = personnel.Email,
Rules = rules.Select(x => new PersonnelRule
{
ApplicationModule = x.ApplicationModule,
View = x.View,
Insert = x.Insert,
Update = x.Update,
Delete = x.Delete
}).Where(x => x.Insert || x.View || x.Delete || x.Update).ToList()
};
var accessToken = _tokenHelper.CreateToken(personnel.Id, rulesModel);
var tokenOptions = _jwtOptions;
var per = await _dal.TableNoTracking.FirstOrDefaultAsync(x => x.Id == personnel.Id);
per.RefreshToken = accessToken.RefreshToken;
per.RefreshTokenExpiredDate = DateTime.Now.AddMinutes(tokenOptions.AccessTokenExpiration + 30);
await _dal.UpdateAsync(per);
_loggedInUsers.UserInfo = _loggedInUsers.UserInfo.Where(x => x.PersonnelId != personnel.Id).ToList();
_loggedInUsers.UserInfo.Add(user);
var result = new LoginResultModel
{
PersonnelId = personnel.Id,
FirstName = personnel.FirstName,
LastName = personnel.LastName,
Email = personnel.Email,
Token = accessToken.Token,
RefreshToken = accessToken.RefreshToken,
TokenExpiration = DateTime.Now,
Rules = rulesModel
};
return(new SuccessDataResponse <LoginResultModel>(result));
}
public async Task <IResponse> UpdateAsync(AssigmentTagModel model)
{
return(await _dal.UpdateAsync(_mapper.Map <AssigmentTag>(model)));
}
