public async Task DeleteAsync(Comment comment)
{
int affrows = 0;
//如果是根评论，删除所有的子评论
if (!comment.RootCommentId.HasValue)
{
affrows += await _commentRepository.DeleteAsync(r => r.RootCommentId == comment.Id);
}
else
{
await _commentRepository.UpdateDiy.Set(r => r.ChildsCount - 1).Where(r => r.Id == comment.RootCommentId)
.ExecuteAffrowsAsync();
}
affrows += await _commentRepository.DeleteAsync(new Comment { Id = comment.Id });
switch (comment.SubjectType)
{
case 1:
await _articleRepository.UpdateDiy.Set(r => r.CommentQuantity - affrows)
.Where(r => r.Id == comment.SubjectId).ExecuteAffrowsAsync();
break;
}
}
/// <summary>
/// 权限标签上的Permission改变时，删除数据库中存在的无效权限，并生成新的权限。
/// </summary>
/// <returns></returns>
public async Task SeedPermissionAsync(List <PermissionDefinition> linCmsAttributes)
{
List <LinPermission> insertPermissions = new List <LinPermission>();
List <LinPermission> allPermissions = await _permissionRepository.Select.ToListAsync();
Expression <Func <LinGroupPermission, bool> > expression = u => false;
Expression <Func <LinPermission, bool> > permissionExpression = u => false;
allPermissions.ForEach(permissioin =>
{
if (!linCmsAttributes.Any(r => r.Permission == permissioin.Name))
{
expression = expression.Or(r => r.PermissionId == permissioin.Id);
permissionExpression = permissionExpression.Or(r => r.Id == permissioin.Id);
}
});
int effectRows = await _permissionRepository.DeleteAsync(permissionExpression);
effectRows += await _groupPermissionRepository.DeleteAsync(expression);
_logger.LogInformation($"删除了{effectRows}条数据");
linCmsAttributes.ForEach(r =>
{
bool exist = allPermissions.Any(u => u.Module == r.Module && u.Name == r.Permission);
if (!exist)
{
insertPermissions.Add(new LinPermission(r.Permission, r.Module));
}
});
await _permissionRepository.InsertAsync(insertPermissions);
_logger.LogInformation($"新增了{insertPermissions.Count}条数据");
}
public async Task DeleteAsync(long subscribeUserId)
{
bool any = await _userSubscribeRepository.Select.AnyAsync(r =>
r.CreateUserId == _currentUser.Id && r.SubscribeUserId == subscribeUserId);
if (!any)
{
throw new LinCmsException("已取消关注");
}
using IUnitOfWork unitOfWork = _unitOfWorkManager.Begin();
using ICapTransaction capTransaction = unitOfWork.BeginTransaction(_capBus, false);
await _userSubscribeRepository.DeleteAsync(r =>
r.SubscribeUserId == subscribeUserId && r.CreateUserId == _currentUser.Id);
await _capBus.PublishAsync("NotificationController.Post", new CreateNotificationDto()
{
NotificationType = NotificationType.UserLikeUser,
NotificationRespUserId = subscribeUserId,
UserInfoId = _currentUser.Id ?? 0,
CreateTime = DateTime.Now,
IsCancel = true
});
await capTransaction.CommitAsync();
}
public async Task DeleteAsync(long id)
{
LinGroup linGroup = await _groupRepository.Where(r => r.Id == id).FirstAsync();
if (linGroup.IsNull())
{
throw new LinCmsException("分组不存在，删除失败", ErrorCode.NotFound, StatusCodes.Status404NotFound);
}
if (linGroup.IsStatic)
{
throw new LinCmsException("无法删除静态权限组!");
}
bool exist = await _userGroupRepository.Select.AnyAsync(r => r.GroupId == id);
if (exist)
{
throw new LinCmsException("分组下存在用户，不可删除", ErrorCode.Inoperable);
}
await _groupRepository.DeleteAsync(id);
await _groupPermissionRepository.DeleteAsync(r => r.GroupId == id);
//_freeSql.Transaction(() =>
//{
// _freeSql.Delete<LinGroupPermission>(new LinGroupPermission { GroupId = id }).ExecuteAffrows();
// _freeSql.Delete<LinGroup>(id).ExecuteAffrows();
//});
}
public async Task UpdateAsync(Guid id, CreateUpdateChannelDto updateChannel)
{
Channel channel = await _channelRepository.Select.Where(r => r.Id == id).ToOneAsync();
if (channel == null)
{
throw new LinCmsException("该数据不存在");
}
bool exist = await _channelRepository.Select.AnyAsync(r => r.ChannelName == updateChannel.ChannelName && r.Id != id && r.ChannelCode == updateChannel.ChannelCode);
if (exist)
{
throw new LinCmsException($"技术频道[{updateChannel.ChannelName}]已存在");
}
Mapper.Map(updateChannel, channel);
await _channelRepository.UpdateAsync(channel);
await _channelTagRepository.DeleteAsync(r => r.ChannelId == id);
var channelTagLists = new List <ChannelTag>();
updateChannel.TagIds?.ForEach(r => { channelTagLists.Add(new ChannelTag(id, r)); });
await _channelTagRepository.InsertAsync(channelTagLists);
}
public async Task DeleteUserTagAsync(Guid tagId)
{
bool any = await _userTagRepository.Select.AnyAsync(r => r.CreateUserId == CurrentUser.Id && r.TagId == tagId);
if (!any)
{
throw new LinCmsException("已取消关注");
}
await _userTagRepository.DeleteAsync(r => r.TagId == tagId && r.CreateUserId == CurrentUser.Id);
await _tagService.UpdateSubscribersCountAsync(tagId, -1);
}
public async Task <UnifyResponseDto> DeleteClassify(Guid id)
{
Classify classify = await _classifyRepository.Select.Where(a => a.Id == id).ToOneAsync();
if (classify.CreateUserId != _currentUser.Id)
{
throw new LinCmsException("您无权删除他人的分类专栏");
}
await _classifyRepository.DeleteAsync(new Classify { Id = id });
return(UnifyResponseDto.Success());
}
/// <summary>
/// 权限标签上的Permission改变时，删除数据库中存在的无效权限，并生成新的权限。
/// </summary>
/// <returns></returns>
public async Task SeedPermissionAsync(List <PermissionDefinition> linCmsAttributes, CancellationToken cancellationToken)
{
List <LinPermission> insertPermissions = new List <LinPermission>();
List <LinPermission> updatePermissions = new List <LinPermission>();
List <LinPermission> allPermissions = await _permissionRepository.Select.ToListAsync();
Expression <Func <LinGroupPermission, bool> > expression = u => false;
Expression <Func <LinPermission, bool> > permissionExpression = u => false;
allPermissions.ForEach(permissioin =>
{
if (linCmsAttributes.All(r => r.Permission != permissioin.Name))
{
expression = expression.Or(r => r.PermissionId == permissioin.Id);
permissionExpression = permissionExpression.Or(r => r.Id == permissioin.Id);
}
});
int effectRows = await _permissionRepository.DeleteAsync(permissionExpression, cancellationToken);
effectRows += await _groupPermissionRepository.DeleteAsync(expression, cancellationToken);
_logger.LogInformation($"删除了{effectRows}条数据");
linCmsAttributes.ForEach(r =>
{
LinPermission permissionEntity = allPermissions.FirstOrDefault(u => u.Module == r.Module && u.Name == r.Permission);
if (permissionEntity == null)
{
insertPermissions.Add(new LinPermission(r.Permission, r.Module, r.Router));
}
else
{
bool routerExist = allPermissions.Any(u => u.Module == r.Module && u.Name == r.Permission && u.Router == r.Router);
if (!routerExist)
{
permissionEntity.Router = r.Router;
updatePermissions.Add(permissionEntity);
}
}
});
await _permissionRepository.InsertAsync(insertPermissions, cancellationToken);
_logger.LogInformation($"新增了{insertPermissions.Count}条数据");
await _permissionRepository.UpdateAsync(updatePermissions, cancellationToken);
_logger.LogInformation($"更新了{updatePermissions.Count}条数据");
}
public async Task UnBind(Guid id)
{
LinUserIdentity userIdentity = await _userIdentityRepository.GetAsync(id);
if (userIdentity == null || userIdentity.CreateUserId != CurrentUser.Id)
{
throw new LinCmsException("你无权解绑此账号");
}
List <LinUserIdentity> userIdentities = await _userIdentityRepository.Select.Where(r => r.CreateUserId == CurrentUser.Id).ToListAsync();
bool hasPwd = userIdentities.Where(r => r.IdentityType == LinUserIdentity.Password).Any();
if (!hasPwd && userIdentities.Count == 1)
{
throw new LinCmsException("你未设置密码，无法解绑最后一个第三方登录账号");
}
await _userIdentityRepository.DeleteAsync(userIdentity);
}
public async Task CreateOrCancelAsync(CreateNotificationDto notificationDto)
{
if (notificationDto.IsCancel == false)
{
Notification linNotification = _mapper.Map <Notification>(notificationDto);
await _notificationRepository.InsertAsync(linNotification);
}
else
{
Expression <Func <Notification, bool> > exprssion = r =>
r.NotificationType == notificationDto.NotificationType &&
r.UserInfoId == notificationDto.UserInfoId;
switch (notificationDto.NotificationType)
{
case NotificationType.UserLikeArticle: //点赞随笔
exprssion = exprssion.And(r => r.ArticleId == notificationDto.ArticleId);
break;
case NotificationType.UserCommentOnArticle: //评论随笔
case NotificationType.UserLikeArticleComment: //点赞随笔下的评论
exprssion = exprssion.And(r =>
r.ArticleId == notificationDto.ArticleId && r.CommentId == notificationDto.CommentId);
break;
case NotificationType.UserCommentOnComment: //回复评论
exprssion = exprssion.And(r =>
r.ArticleId == notificationDto.ArticleId && r.CommentId == notificationDto.CommentId &&
r.NotificationRespUserId == notificationDto.NotificationRespUserId);
break;
case NotificationType.UserLikeUser: //关注用户
exprssion = exprssion.And(r =>
r.NotificationRespUserId == notificationDto.NotificationRespUserId);
break;
default:
exprssion = r => false;
break;
}
await _notificationRepository.DeleteAsync(exprssion);
}
}
public async Task DeleteAsync(Guid id)
{
Article article = _articleRepository.Select.Where(r => r.Id == id).IncludeMany(r => r.Tags).ToOne();
if (article.IsNotNull())
{
await _classifyService.UpdateArticleCountAsync(article.ClassifyId, 1);
article.Tags?
.ForEach(async(u) => { await _tagService.UpdateArticleCountAsync(u.Id, -1); });
}
await _articleRepository.DeleteAsync(new Article { Id = id });
await _tagArticleRepository.DeleteAsync(r => r.ArticleId == id);
await _commentRepository.DeleteAsync(r => r.SubjectId == id);
await _userLikeRepository.DeleteAsync(r => r.SubjectId == id);
}
public async Task <string> CreateOrCancelAsync(CreateUpdateUserLikeDto createUpdateUserLike)
{
Expression <Func <UserLike, bool> > predicate = r =>
r.SubjectId == createUpdateUserLike.SubjectId && r.CreateUserId == _currentUser.Id;
bool exist = await _userLikeRepository.Select.AnyAsync(predicate);
int increaseLikeQuantity = 1;
if (exist)
{
increaseLikeQuantity = -1;
await _userLikeRepository.DeleteAsync(predicate);
}
switch (createUpdateUserLike.SubjectType)
{
case UserLikeSubjectType.UserLikeArticle:
await _articleService.UpdateLikeQuantity(createUpdateUserLike.SubjectId, increaseLikeQuantity);
break;
case UserLikeSubjectType.UserLikeComment:
await _commentService.UpdateLikeQuantity(createUpdateUserLike.SubjectId, increaseLikeQuantity);
break;
}
if (exist)
{
return("取消点赞成功");
}
UserLike userLike = _mapper.Map <UserLike>(createUpdateUserLike);
_userLikeRepository.Insert(userLike);
return("点赞成功");
}
public async Task DeleteUserGroupAsync(long userId)
{
await _userGroupRepository.DeleteAsync(r => r.UserId == userId);
}
public async Task <UnifyResponseDto> DeleteAsync(Guid id)
{
await _tagRepository.DeleteAsync(new Tag { Id = id });
return(UnifyResponseDto.Success());
}
public async Task DeleteAsync(long id)
{
await _cultureRepository.DeleteAsync(new LocalCulture { Id = id });
}
public async Task DeleteAsync(int id)
{
await _baseItemRepository.DeleteAsync(new BaseItem { Id = id });
}
public async Task DeleteAsync(long id)
{
await _resourceRepository.DeleteAsync(new LocalResource { Id = id });
}
public async Task DeleteAsync(long id)
{
await Repository.DeleteAsync(new Doc { Id = id });
}
public async Task DeleteAsync(long id)
{
await _bookRepository.DeleteAsync(new Book { Id = id });
}
public async Task DeleteAsync(Guid id)
{
await _channelRepository.DeleteAsync(new Channel { Id = id });
}
public async Task DeletePermissionsAsync(RemovePermissionDto permissionDto)
{
await _groupPermissionRepository.DeleteAsync(r =>
permissionDto.PermissionIds.Contains(r.PermissionId) && r.GroupId == permissionDto.GroupId);
}
public Task DeleteAsync(long id)
{
return(_bookRepository.DeleteAsync(new Book {
Id = id
}));
}
