/// <summary>
/// 当用户添加后触发得方法。
/// </summary>
/// <param name="context">数据库事务操作实例。</param>
/// <param name="user">用户实例。</param>
/// <param name="cancellationToken">取消标志。</param>
/// <returns>返回操作结果，返回<c>true</c>表示操作成功，将自动提交事务，如果<c>false</c>或发生错误，则回滚事务。</returns>
public virtual async Task <bool> OnCreatedAsync(IDbTransactionContext <TUser> context, TUser user, CancellationToken cancellationToken = default)
{
//添加用户角色
var roles = await context.As <TRole>().FetchAsync(x => x.IsDefault, cancellationToken);
var urdb = context.As <TUserRole>();
foreach (var role in roles)
{
var userRole = new TUserRole {
RoleId = role.Id, UserId = user.Id
};
await urdb.CreateAsync(userRole, cancellationToken);
}
//更新用户最大角色，用于显示等使用
var maxRole = roles.OrderByDescending(x => x.RoleLevel).First();
if (maxRole != null)
{
user.RoleId = maxRole.Id;
await context.UpdateAsync(user.Id, new { user.RoleId }, cancellationToken);
}
//子账号
if (user.ParentId > 0)
{
var sdb = context.As <UserIndex>();
await sdb.CreateIndexAsync(user.Id, user.ParentId, cancellationToken);
}
return(true);
}
/// <summary>
/// 当用户添加后触发得方法。
/// </summary>
/// <param name="context">数据库事务操作实例。</param>
/// <param name="user">用户实例。</param>
/// <returns>返回操作结果，返回<c>true</c>表示操作成功，将自动提交事务，如果<c>false</c>或发生错误，则回滚事务。</returns>
public virtual bool OnCreated(IDbTransactionContext <TUser> context, TUser user)
{
//添加用户角色
var roles = context.As <TRole>().Fetch(x => x.IsDefault).ToList();
var urdb = context.As <TUserRole>();
foreach (var role in roles)
{
var userRole = new TUserRole {
RoleId = role.Id, UserId = user.Id
};
urdb.Create(userRole);
}
//更新用户最大角色，用于显示等使用
var maxRole = roles.OrderByDescending(x => x.RoleLevel).First();
if (maxRole != null)
{
user.RoleId = maxRole.Id;
context.Update(user.Id, new { user.RoleId });
}
//子账号
if (user.ParentId > 0)
{
var sdb = context.As <UserIndex>();
sdb.CreateIndex(user.Id, user.ParentId);
}
return(true);
}
/// <summary>
/// 当用户添加后触发得方法。
/// </summary>
/// <param name="context">数据库事务操作实例。</param>
/// <returns>返回操作结果，返回<c>true</c>表示操作成功，将自动提交事务，如果<c>false</c>或发生错误，则回滚事务。</returns>
public bool OnCreated(IDbTransactionContext <User> context)
{
//添加用户角色
var role = context.As <Role>()
.Find(x => x.NormalizedName == DefaultRole.Member.NormalizedName);
var userRole = new UserRole {
RoleId = role.RoleId, UserId = UserId
};
return(context.As <UserRole>().Create(userRole));
}
/// <summary>
/// 当用户添加后触发得方法。
/// </summary>
/// <param name="context">数据库事务操作实例。</param>
/// <param name="cancellationToken">取消标志。</param>
/// <returns>返回操作结果，返回<c>true</c>表示操作成功，将自动提交事务，如果<c>false</c>或发生错误，则回滚事务。</returns>
public async Task <bool> OnCreatedAsync(IDbTransactionContext <User> context, CancellationToken cancellationToken = default(CancellationToken))
{
//添加用户角色
var role = await context.As <Role>()
.FindAsync(x => x.NormalizedName == DefaultRole.Member.NormalizedName, cancellationToken);
var userRole = new UserRole {
RoleId = role.RoleId, UserId = UserId
};
return(await context.As <UserRole>().CreateAsync(userRole, cancellationToken));
}
/// <summary>
/// 当用户添加后触发得方法。
/// </summary>
/// <param name="context">数据库事务操作实例。</param>
/// <param name="user">用户实例。</param>
/// <param name="cancellationToken">取消标志。</param>
/// <returns>返回操作结果，返回<c>true</c>表示操作成功，将自动提交事务，如果<c>false</c>或发生错误，则回滚事务。</returns>
public virtual Task <bool> OnCreatedAsync(IDbTransactionContext <TUser> context, TUser user, CancellationToken cancellationToken = default)
{
//积分
var usdb = context.As <UserScore>();
return(usdb.CreateAsync(new UserScore {
UserId = user.Id
}, cancellationToken));
}
/// <summary>
/// 当用户添加后触发得方法。
/// </summary>
/// <param name="context">数据库事务操作实例。</param>
/// <param name="user">用户实例。</param>
/// <returns>返回操作结果，返回<c>true</c>表示操作成功，将自动提交事务，如果<c>false</c>或发生错误，则回滚事务。</returns>
public virtual bool OnCreated(IDbTransactionContext <TUser> context, TUser user)
{
//积分
var usdb = context.As <UserScore>();
return(usdb.Create(new UserScore {
UserId = user.Id
}));
}
/// <summary>
/// 设置用户最高级的角色。
/// </summary>
/// <param name="db">事务实例。</param>
/// <param name="userId">用户Id。</param>
/// <param name="cancellationToken">取消标识。</param>
/// <returns>返回设置结果。</returns>
protected virtual async Task <bool> SetMaxRoleAsync(IDbTransactionContext <TRole> db, int userId, CancellationToken cancellationToken = default)
{
var role = await db.AsQueryable()
.Select()
.OrderByDescending(x => x.RoleLevel)
.InnerJoin <TUserRole>((r, ur) => r.RoleId == ur.RoleId)
.Where <TUserRole>(x => x.UserId == userId)
.FirstOrDefaultAsync(cancellationToken);
return(await db.As <TUser>().UpdateAsync(x => x.UserId == userId, new { role.RoleId, RoleName = role.Name }, cancellationToken));
}
/// <summary>
/// 设置用户最高级的角色。
/// </summary>
/// <param name="db">事务实例。</param>
/// <param name="userId">用户Id。</param>
/// <returns>返回设置结果。</returns>
protected virtual bool SetMaxRole(IDbTransactionContext <TRole> db, int userId)
{
var role = db.AsQueryable()
.Select()
.OrderByDescending(x => x.RoleLevel)
.InnerJoin <TUserRole>((r, ur) => r.RoleId == ur.RoleId)
.Where <TUserRole>(x => x.UserId == userId)
.FirstOrDefault();
return(db.As <TUser>().Update(x => x.UserId == userId, new { role.RoleId, RoleName = role.Name }));
}
/// <summary>
/// 当角色更新前触发得方法。
/// </summary>
/// <param name="context">数据库事务操作实例。</param>
/// <param name="cancellationToken">取消标志。</param>
/// <returns>返回操作结果，返回<c>true</c>表示操作成功，将自动提交事务，如果<c>false</c>或发生错误，则回滚事务。</returns>
public async Task <bool> OnUpdateAsync(IDbTransactionContext <Role> context, CancellationToken cancellationToken = default(CancellationToken))
{
//更改用户显示的角色名称
var dbRole = await context.FindAsync(RoleId, cancellationToken);
if (dbRole.Name != Name)
{
await context.As <User>().UpdateAsync(x => x.RoleId == RoleId, new { RoleName = Name }, cancellationToken);
}
return(true);
}
/// <summary>
/// 当角色更新前触发得方法。
/// </summary>
/// <param name="context">数据库事务操作实例。</param>
/// <returns>返回操作结果，返回<c>true</c>表示操作成功，将自动提交事务，如果<c>false</c>或发生错误，则回滚事务。</returns>
public bool OnUpdate(IDbTransactionContext <Role> context)
{
//更改用户显示的角色名称
var dbRole = context.Find(RoleId);
if (dbRole.Name != Name)
{
context.As <User>().Update(x => x.RoleId == RoleId, new { RoleName = Name });
}
return(true);
}
/// <summary>
/// 当角色删除前触发得方法。
/// </summary>
/// <param name="context">数据库事务操作实例。</param>
/// <returns>返回操作结果，返回<c>true</c>表示操作成功，将自动提交事务，如果<c>false</c>或发生错误，则回滚事务。</returns>
public bool OnDelete(IDbTransactionContext <Role> context)
{
//更改用户显示的角色名称
var basic = context.Find(x => x.NormalizedName == DefaultRole.Member.NormalizedName);
var dbRole = context.Find(RoleId);
if (dbRole.Name != Name)
{
context.As <User>().Update(x => x.RoleId == basic.RoleId, new { basic.RoleId, RoleName = basic.Name });
}
return(true);
}
/// <summary>
/// 当角色删除前触发得方法。
/// </summary>
/// <param name="context">数据库事务操作实例。</param>
/// <param name="cancellationToken">取消标志。</param>
/// <returns>返回操作结果，返回<c>true</c>表示操作成功，将自动提交事务，如果<c>false</c>或发生错误，则回滚事务。</returns>
public async Task <bool> OnDeleteAsync(IDbTransactionContext <Role> context, CancellationToken cancellationToken = default(CancellationToken))
{
//更改用户显示的角色名称
var basic = await context.FindAsync(x => x.NormalizedName == DefaultRole.Member.NormalizedName, cancellationToken);
var dbRole = await context.FindAsync(RoleId, cancellationToken);
if (dbRole.Name != Name)
{
await context.As <User>().UpdateAsync(x => x.RoleId == basic.RoleId, new { basic.RoleId, RoleName = basic.Name }, cancellationToken);
}
return(true);
}
/// <summary>
/// 添加用户。
/// </summary>
/// <param name="db">当前事务实例。</param>
/// <param name="userName">用户名称。</param>
/// <param name="password">密码。</param>
/// <param name="roles">角色列表，不包含默认角色。</param>
/// <param name="parentId">父级Id。</param>
/// <returns>返回当前用户Id。</returns>
protected async Task <int> CreateAsync(IDbTransactionContext <TUser> db, string userName, string password, List <TRole> roles, int parentId)
{
var user = new TUser();
user.UserName = userName;
user.PasswordHash = password;
user.NickName = user.UserName;
user.NormalizedUserName = UserManager.NormalizeName(user.UserName);
user.PasswordHash = UserManager.HashPassword(user);
user.ParentId = parentId;
if (!await db.CreateAsync(user))
{
Logger.LogCritical("添加用户实例失败：{0}", userName);
return(0);
}
foreach (var handler in _handlers)
{
if (!await handler.OnCreatedAsync(db, user))
{
Logger.LogCritical("触发用户事件失败：{0}，类型：{1}", userName, handler.GetType().FullName);
return(0);
}
}
var urdb = db.As <TUserRole>();
foreach (var role in roles)
{
if (!await urdb.CreateAsync(new TUserRole {
RoleId = role.Id, UserId = user.Id
}))
{
Logger.LogCritical("添加用户角色失败：{0}（{2}），角色：{1}（{3}）", userName, role.Name, user.Id, role.Id);
return(0);
}
}
var maxRole = roles.OrderByDescending(x => x.RoleLevel).First();
user.RoleId = maxRole.Id;
if (await db.UpdateAsync(user.Id, new { user.RoleId }))
{
return(user.Id);
}
Logger.LogCritical("添加用户最高角色失败：{0}，角色：{1}", userName, maxRole.Name);
return(0);
}
/// <summary>
/// 网站添加后调用的方法。
/// </summary>
/// <param name="context">当前事务管理器。</param>
/// <param name="site">网站实例。</param>
/// <returns>返回触发方法后的结果，如果返回<code>false</code>将回滚事件。</returns>
public virtual async Task <bool> OnCreatedAsync(IDbTransactionContext <SiteAdapter> context, TSite site)
{
var sd = context.As <SiteDomain>();
foreach (var domain in DefaultDomains)
{
if (!await sd.CreateAsync(new SiteDomain {
Domain = domain, SiteId = site.Id
}))
{
return(false);
}
}
return(true);
}
/// <summary>
/// 更新用户积分。
/// </summary>
/// <param name="db">数据库事务接口实例。</param>
/// <param name="userId">用户Id。</param>
/// <param name="score">用户积分。</param>
/// <param name="remark">描述。</param>
/// <param name="scoreType">积分使用类型。</param>
/// <param name="cancellationToken">取消标志。</param>
/// <returns>返回添加结果。</returns>
public static async Task <UpdateScoreResult> UpdateScoreAsync(this IDbTransactionContext <UserScore> db, int userId, int score, string remark = null, ScoreType?scoreType = null, CancellationToken cancellationToken = default)
{
var userScore = await db.AsQueryable().WithNolock().Where(x => x.UserId == userId).FirstOrDefaultAsync(cancellationToken);
if (userScore == null || userScore.Score < score)
{
return(UpdateScoreStatus.NotEnough);
}
var log = new ScoreLog();
log.BeforeScore = userScore.Score;
log.Score = -score;
userScore.Score -= score;
userScore.ScoredDate = DateTimeOffset.Now;
if (scoreType == null)
{
scoreType = score > 0 ? ScoreType.Consume : ScoreType.Recharge;
}
log.ScoreType = scoreType.Value;
if (!await db.UpdateAsync(x => x.UserId == userId && x.RowVersion == userScore.RowVersion, new { userScore.Score, userScore.ScoredDate }, cancellationToken))
{
return(UpdateScoreStatus.ScoreError);
}
log.AfterScore = userScore.Score;
log.Remark = remark;
log.UserId = userId;
var sdb = db.As <ScoreLog>();
if (await sdb.CreateAsync(log, cancellationToken))
{
return(log.Id);
}
return(UpdateScoreStatus.LogError);
}
/// <summary>
/// 当用户删除前触发得方法。
/// </summary>
/// <param name="context">数据库事务操作实例。</param>
/// <param name="user">用户实例。</param>
/// <param name="cancellationToken">取消标志。</param>
/// <returns>返回操作结果，返回<c>true</c>表示操作成功，将自动提交事务，如果<c>false</c>或发生错误，则回滚事务。</returns>
public virtual Task <bool> OnDeleteAsync(IDbTransactionContext <TUser> context, TUser user, CancellationToken cancellationToken = default)
{
var sdb = context.As <UserScore>();
return(sdb.DeleteAsync(x => x.UserId == user.Id, cancellationToken));
}
/// <summary>
/// 当用户删除前触发得方法。
/// </summary>
/// <param name="context">数据库事务操作实例。</param>
/// <param name="user">用户实例。</param>
/// <returns>返回操作结果，返回<c>true</c>表示操作成功，将自动提交事务，如果<c>false</c>或发生错误，则回滚事务。</returns>
public virtual bool OnDelete(IDbTransactionContext <TUser> context, TUser user)
{
var sdb = context.As <UserScore>();
return(sdb.Delete(x => x.UserId == user.Id));
}
