tede/gx_api/GxPress/Service/GxPress.Service.Implement/Notice/NoticeService.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Transactions;
using AutoMapper;
using Datory;
using GxPress.Common.Exceptions;
using GxPress.Common.Page;
using GxPress.Common.Tools;
using GxPress.Entity;
using GxPress.EnumConst;
using GxPress.Repository.Interface;
using GxPress.Request.Analyze;
using GxPress.Request.Notice;
using GxPress.Result;
using GxPress.Result.Notice;
using GxPress.Service.Interface.Analyze;
using GxPress.Service.Interface.Middle;
using GxPress.Service.Interface.Notice;
using GxPress.Service.Interface.Visit;
using Newtonsoft.Json;
using GxPress.Service.Interface.UserMiddle;
using GxPress.Service.Interface.ContentJson;
using GxPress.Service.Interface.CommonSqlKata;
using GxPress.Repository.Interface.WorkFlow;

namespace GxPress.Service.Implement.Notice
{
    public partial class NoticeService : INoticeService
    {
        private readonly IUserRepository _userRepository;
        private readonly INoticeRepository _noticeRepository;
        private readonly ICcRepository _ccRepository;
        private readonly IAddresseeRepository _addresseeRepository;
        private readonly IDepartmentRepository _departmentRepository;
        private readonly IMiddleService _middleService;
        private readonly IMiddleRepository _middleRepository;
        private readonly IMapper _mapper;
        private readonly IAnalyzeService _analyzeService;
        private readonly IVisitService _visitService;
        private readonly ICommentRepository _commentRepository;
        private readonly IUserMiddleService _userMiddleService;
        private readonly IContentJsonService _contentJsonService;
        private readonly ICommonSqlKataService commonSqlKataService;
        private readonly IFlowTodoRepository flowTodoRepository;
        public NoticeService(IUserRepository userRepository, IMapper mapper, INoticeRepository noticeRepository,
            ICcRepository ccRepository, IAddresseeRepository addresseeRepository,
            IDepartmentRepository departmentRepository, IMiddleService middleService,
            IMiddleRepository middleRepository, IAnalyzeService analyzeService,
            ICommentRepository commentRepository, IVisitService visitService,
            IUserMiddleService userMiddleService,
            IContentJsonService contentJsonService,
            ICommonSqlKataService commonSqlKataService,
            IFlowTodoRepository flowTodoRepository)
        {
            _noticeRepository = noticeRepository;
            _userRepository = userRepository;
            _addresseeRepository = addresseeRepository;
            _ccRepository = ccRepository;
            _departmentRepository = departmentRepository;
            _mapper = mapper;
            _middleService = middleService;
            _middleRepository = middleRepository;
            _analyzeService = analyzeService;
            _commentRepository = commentRepository;
            _visitService = visitService;
            _userMiddleService = userMiddleService;
            _contentJsonService = contentJsonService;
            this.commonSqlKataService = commonSqlKataService;
            this.flowTodoRepository = flowTodoRepository;
        }
        /// <summary>
        /// 获取通知的点赞列表
        /// </summary>
        /// <param name="id"></param>
        /// <param name="userId"></param>
        /// <returns></returns>
        public async Task<NoticeDetailResult> GetNoticeDetailAsync(int id, int userId)
        {

            var notice = await _noticeRepository.GetAsync(id);
            if (notice == null)
                throw new BusinessException("通知不存在");
            var noticeDetailResult = new Result.Notice.NoticeDetailResult();
            var result = _mapper.Map<Result.Notice.NoticeDetailResult>(notice);
            //获取新版
            result.AddresseeUserMiddles = await _userMiddleService.FindUserMiddlesAsync(10, id);
            result.CcUserMiddles = await _userMiddleService.FindUserMiddlesAsync(20, id);
            //json
            var contentJsonData = JsonConvert.DeserializeObject<List<ContentJsonData>>(result.Content);
            foreach (var item in contentJsonData)
                item.File = StringUtils.AddDomain(item.File);
            result.Data = contentJsonData;
            //获取用户
            var user = await _userRepository.GetAsync(result.UserId);
            result.UserName = user.Name;
            result.AllCount = await _addresseeRepository.CountAsync(Q.Where(nameof(Addressee.SourceId), id));
            result.ReadCount = await _addresseeRepository.CountAsync(Q.Where(nameof(Addressee.SourceId), id).Where(nameof(Addressee.IsRead), true));
            //获取收件人
            var noticeAddresseeList =
                await _addresseeRepository.GetUserByNoticeIdAsync(id);
            result.NoticeAddresseeNames = noticeAddresseeList.Select(n => n.Name).ToList();
            var IsRead = await _addresseeRepository.ExistsAsync(Q.Where(nameof(Entity.Middle.Middle.IsRead), true)
                  .Where(nameof(Addressee.SourceId), id)
                  .Where(nameof(Addressee.UserId), userId));
            //修改阅读量
            if (IsRead == false)
            {
                if (await _addresseeRepository.UpdateAsync(Q.Set(nameof(Entity.Middle.Middle.IsRead), true)
                    .Where(nameof(Addressee.SourceId), id)
                    .Where(nameof(Addressee.UserId), userId)))
                    result.ReadCount++;
            }
            //修改访问量
            await _visitService.AddVisit(userId, 5, id);
            //修改middle的阅读
            // await _middleRepository.UpdateAsync(Q.Set(nameof(Entity.Middle.Middle.IsRead), true).Where(nameof(Entity.Middle.Middle.UserId), userId).Where(nameof(Entity.Middle.Middle.MiddleId), id).Where(nameof(Entity.Middle.Middle.FolderType), 1));
            var analyzeRequest = new Request.App.Analyze.AnalyzeRequest();
            analyzeRequest.TypeValue = GxPress.EnumConst.AllTypeConst.Notice.GetHashCode();
            analyzeRequest.AnalyzeType = 1;
            analyzeRequest.SourceId = id;
            analyzeRequest.UserId = userId;
            //点赞数量
            result.PraiseCount = await _analyzeService.CountAsync(analyzeRequest);
            //获取话题的评论数量
            var commentCount =
                await _commentRepository.CountAsync(Q.Where(nameof(Entity.Comment.ArticleId), id).Where(nameof(Entity.Comment.TypeValue), analyzeRequest.TypeValue).Where(nameof(Entity.Comment.Pid), 0));
            result.CommentCount = commentCount;
            //获取话题的转发数量
            analyzeRequest.AnalyzeType = 4;
            var retransmissionCount = await _analyzeService.CountAsync(analyzeRequest);
            result.RetransmissionCount = retransmissionCount;
            result.IsRetransmission = await _analyzeService.ExistsAsync(analyzeRequest);
            //获取话题的收藏数量
            analyzeRequest.AnalyzeType = 3;
            var collectCount = await _analyzeService.CountAsync(analyzeRequest);
            result.CollectCount = collectCount;
            //是否收藏
            result.IsCollect = await _analyzeService.ExistsAsync(analyzeRequest);
            //获取话题的点赞数量
            analyzeRequest.AnalyzeType = 1;
            var praiseCount = await _analyzeService.CountAsync(analyzeRequest);
            result.PraiseCount = praiseCount;
            //是否点赞
            result.IsPraise = await _analyzeService.ExistsAsync(analyzeRequest);
            var request = new PraisePageSearchRequest { SourceId = id, TypeValue = AllTypeConst.Notice.GetHashCode(), Page = 1, PerPage = 3 };
            result.NoticePraisePagedList = await _analyzeService.GetPraisePageAsync(request);
            //是否是当前用户创建
            result.IsAdmin = notice.UserId == userId;
            return result;
        }
        /// <summary>
        /// 根据通知ID获取通知详情
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<NoticeEditDetailResult> NoticeEditDetailAsync(int id)
        {
            var notice = await _noticeRepository.GetAsync(id);
            var result = _mapper.Map<NoticeEditDetailResult>(notice);
            //抄送人
            var noticeCcList = await _ccRepository.GetNoticeCcByNoticeIdAsync(id, GxPress.EnumConst.FolderTypeConst.Notice.GetHashCode());
            //收件人
            var noticeAddressee = await _addresseeRepository.GetNoticeAddresseeByNoticeIdAsync(id);
            //获取新版
            result.AddresseeUserMiddles = await _userMiddleService.FindUserMiddlesAsync(10, id);
            result.CcUserMiddles = await _userMiddleService.FindUserMiddlesAsync(20, id);
            var noticeAddresseeUsers =
                await _userRepository.UserListInsAsync(noticeAddressee.Select(n => n.UserId).ToList());
            result.NoticeAddresseeUsers =
                noticeAddresseeUsers.Select(n => _mapper.Map<NoticeAddresseeUser>(n)).ToList();

            var noticeCcUsers = await _userRepository.UserListInsAsync(noticeCcList.Select(n => n.UserId).ToList());
            result.NoticeCcUsers = noticeCcUsers.Select(n => _mapper.Map<NoticeCcUser>(n)).ToList();
            foreach (var noticeAddresseeUser in result.NoticeAddresseeUsers)
            {
                noticeAddresseeUser.AvatarUrl = StringUtils.AddDomainMin(noticeAddresseeUser.AvatarUrl);
            }

            foreach (var noticeCcUser in result.NoticeCcUsers)
            {
                noticeCcUser.AvatarUrl = StringUtils.AddDomainMin(noticeCcUser.AvatarUrl);
            }
            var jsonData = JsonConvert.DeserializeObject<List<ContentJsonData>>(result.Content);
            foreach (var item in jsonData)
                item.File = StringUtils.AddDomain(item.File);
            result.Data = jsonData;
            return result;
        }

        /// <summary>
        /// 获取通知详情
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<Result.Notice.NoticeDetailResult> GetNoticeDetailResultAsync(int id, int userId)
        {
            var notice = await _noticeRepository.GetAsync(id);
            if (notice == null)
                throw new BusinessException("通知不存在");
            var noticeDetailResult = new Result.Notice.NoticeDetailResult();
            var result = _mapper.Map<Result.Notice.NoticeDetailResult>(notice);
            //获取新版
            result.AddresseeUserMiddles = await _userMiddleService.FindUserMiddlesAsync(10, id);
            result.CcUserMiddles = await _userMiddleService.FindUserMiddlesAsync(20, id);
            //json
            var contentJsonData = JsonConvert.DeserializeObject<List<ContentJsonData>>(result.Content);
            foreach (var item in contentJsonData)
                item.File = StringUtils.AddDomain(item.File);
            result.Data = contentJsonData;
            //获取用户
            var user = await _userRepository.GetAsync(result.UserId);
            result.UserName = user.Name;
            result.AllCount =
                await _addresseeRepository.CountAsync(Q.Where(nameof(Addressee.SourceId), id));
            result.ReadCount = await _addresseeRepository.CountAsync(Q
                .Where(nameof(Addressee.SourceId), id).Where(nameof(Addressee.IsRead), true));
            //获取收件人
            var noticeAddresseeList =
                await _addresseeRepository.GetAllAsync(Q.Where(nameof(Addressee.SourceId), id)
                    .Where(nameof(Entity.Middle.Middle.IsAdmin), false));
            result.NoticeAddresseeNames = noticeAddresseeList.Select(n => n.UserName).ToList();
            //修改阅读量
            await _addresseeRepository.UpdateAsync(Q.Set(nameof(Entity.Middle.Middle.IsRead), true)
                .Where(nameof(Addressee.SourceId), id)
                .Where(nameof(Addressee.UserId), userId));
            //修改middle的阅读
            await _middleRepository.UpdateAsync(Q.Set(nameof(Entity.Middle.Middle.IsRead), true).Where(nameof(Entity.Middle.Middle.UserId), userId).Where(nameof(Entity.Middle.Middle.MiddleId), id).Where(nameof(Entity.Middle.Middle.FolderType), 1));
            var analyzeRequest = new Request.App.Analyze.AnalyzeRequest();
            analyzeRequest.TypeValue = 2;
            analyzeRequest.AnalyzeType = 1;
            analyzeRequest.SourceId = id;
            analyzeRequest.UserId = userId;
            //点赞数量
            result.PraiseCount = await _analyzeService.CountAsync(analyzeRequest);
            //获取话题的评论数量
            var commentCount =
                await _commentRepository.CountAsync(Q.Where(nameof(Entity.Comment.ArticleId), id).Where(nameof(Entity.Comment.TypeValue), 1));
            result.CommentCount = commentCount;
            //获取话题的转发数量
            analyzeRequest.AnalyzeType = 4;
            var retransmissionCount = await _analyzeService.CountAsync(analyzeRequest);
            result.RetransmissionCount = retransmissionCount;
            result.IsRetransmission = await _analyzeService.ExistsAsync(analyzeRequest);
            //获取话题的收藏数量
            analyzeRequest.AnalyzeType = 3;
            var collectCount = await _analyzeService.CountAsync(analyzeRequest);
            result.CollectCount = collectCount;
            //是否收藏
            result.IsCollect = await _analyzeService.ExistsAsync(analyzeRequest);
            //获取话题的点赞数量
            analyzeRequest.AnalyzeType = 1;
            var praiseCount = await _analyzeService.CountAsync(analyzeRequest);
            result.PraiseCount = praiseCount;
            //是否点赞
            result.IsPraise = await _analyzeService.ExistsAsync(analyzeRequest);
            return result;
        }

        /// <summary>
        /// 编辑通知
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<bool> NoticeUpAsync(NoticeUpRequest request)
        {
            try
            {
                using (TransactionScope transactionScope = new TransactionScope())
                {
                    var notice = await _noticeRepository.GetAsync(request.Id);
                    if (notice == null)
                        throw new BusinessException("通知不存在");
                    var noticeInRequest = new NoticeInRequest();
                    noticeInRequest.Content = request.Content;
                    noticeInRequest.HtmlContent = request.HtmlContent;
                    noticeInRequest.NoticeType = request.NoticeType;
                    noticeInRequest.AddresseeUserMiddles = request.AddresseeUserMiddles;
                    noticeInRequest.CcUserMiddles = request.CcUserMiddles;
                    noticeInRequest.Title = request.Title;
                    noticeInRequest.UserId = request.UserId;
                    noticeInRequest.SoureId = 0;
                    noticeInRequest.Id = request.Id;
                    if (request.NoticeType == NoticeTypeConst.Send)
                    {
                        if (notice.NoticeType == NoticeTypeConst.Draft)
                        {
                            //删除
                            await _noticeRepository.DeleteAsync(Q.Where(nameof(Entity.Notice.Id), notice.Id));
                            //删除middle
                            await _middleRepository.DeleteAsync(notice.Id, GxPress.EnumConst.FolderTypeConst.Notice.GetHashCode());
                            if (notice.SourceId > 0)
                            {
                                var noticeSource = await _noticeRepository.GetAsync(notice.SourceId);
                                if (noticeSource != null)
                                    noticeInRequest.Id = noticeSource.Id;
                                else
                                    noticeInRequest.Id = 0;
                            }
                            else
                                noticeInRequest.Id = 0;
                        }
                    }
                    else
                    {
                        if (notice.NoticeType == NoticeTypeConst.Draft)
                            noticeInRequest.Id = request.Id;
                        else
                        {
                            noticeInRequest.SoureId = notice.Id;
                            var noticeSource = await _noticeRepository.GetAsync(Q.Where(nameof(Entity.Notice.SourceId), notice.Id));
                            if (noticeSource != null)
                                noticeInRequest.Id = noticeSource.Id;
                            else noticeInRequest.Id = 0;
                        }
                    }
                    await InsertAsync(noticeInRequest);
                    transactionScope.Complete();
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
            return true;
        }

        /// <summary>
        /// 根据已读未读查询通知数据
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<IEnumerable<NoticeReadListResult>> NoticeReadListAsync(NoticeReadListRequest request)
        {
            var noticeReadListResults = await _addresseeRepository.GetNoticeAddresseeByUserIdIdAsync(request);
            return noticeReadListResults;
        }

        /// <summary>
        /// 获取通知列表
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<PagedList<NoticeListPageResult>> GetNoticeListPageAsync(NoticePageSearchRequest request)
        {
            var noticeTypeValue = GxPress.EnumConst.AllTypeConst.Inbox.GetHashCode();
            var query = new SqlKata.Query("tede_middle");
            query.LeftJoin("tede_notice", "tede_notice.Id", "tede_middle.MiddleId");
            query.LeftJoin("tede_user", "tede_user.Id", "tede_notice.UserId");
            query.LeftJoin("tede_addressee", "tede_addressee.Id", "tede_middle.MiddleSonId");
            if (request.SearchType == 1)
            {
                query.Where("tede_middle.IsAdmin", true);
                query.Where("tede_middle.NoticeAddresseeType", 1);
                query.Where("tede_middle.IsDelete", false);
            }
            else if (request.SearchType == 2)
            {
                query.Where("tede_middle.AttributeValue", 1);
                query.Where("tede_middle.NoticeAddresseeType", 2);
                query.Where("tede_middle.IsDelete", false);
            }
            else if (request.SearchType == 3)
            {
                query.Where("tede_middle.AttributeValue", 1);
                query.Where("tede_middle.IsDelete", true);
            }
            else if (request.SearchType > 3)
            {
                if (request.SearchType == 16)
                {
                    query.WhereIn("tede_notice.TypeValue", new List<int> { AllTypeConst.Notice.GetHashCode(), AllTypeConst.Missive.GetHashCode(), request.SearchType, AllTypeConst.Anonymity.GetHashCode() });
                    query.Where("tede_middle.IsAdmin", true);
                }
                else
                    query.Where("tede_notice.TypeValue", request.SearchType);
                query.WhereNot("tede_middle.NoticeAddresseeType", 2);
                query.Where("tede_middle.IsDelete", false);
            }
            else
            {
                query.WhereNot("tede_middle.NoticeAddresseeType", 2);
                query.Where("tede_middle.IsDelete", false);
            }
            if (!string.IsNullOrEmpty(request.Keyword))
            {
                if (request.NoticeFolderId > 0)
                    query.Where("tede_middle.ParentId", request.NoticeFolderId);
                var sourceIdQuery = new SqlKata.Query("tede_addressee");
                sourceIdQuery.Join("tede_user", "tede_user.Id", "tede_addressee.UserId");
                sourceIdQuery.WhereColumns("tede_addressee.SourceId", "=", "tede_middle.MiddleId");
                sourceIdQuery.WhereLike("tede_user.Name", $"%{request.Keyword}%");
                sourceIdQuery.Select("tede_addressee.SourceId");
                query.WhereNot("tede_middle.AttributeValue", 2);
                query.Where(n => n.OrWhereLike("tede_notice.Title", $"%{request.Keyword}%").OrWhereLike("tede_notice.Content", $"%{request.Keyword}%")
                .OrWhere(n => n.WhereIn("tede_middle.MiddleId", sourceIdQuery)));
            }
            else
            {
                if (request.SearchType == 0)
                    query.Where("tede_middle.ParentId", request.NoticeFolderId);
            }
            if (request.SearchType > 0)
                query.Where("tede_middle.IsRecall", false);
            query.Where("tede_middle.UserId", request.UserId);
            query.Where("tede_middle.FolderType", noticeTypeValue);
            //条数
            var countQuery = query;
            //收件箱
            query = commonSqlKataService.NoticeQueryAsync(query, request.UserId);
            //通用
            //query = commonSqlKataService.GetCommonQueryAsync(noticeTypeValue, request.UserId, query, "tede_middle.MiddleId");

            query.OrderByDesc("tede_middle.AttributeValue");
            query.OrderByDesc("tede_middle.IsTop");
            query.OrderByDesc("tede_middle.LastModifiedDate");
            //query.OrderByDesc("tede_middle.Sort");
            query.ForPage(request.Page, request.PerPage);
            query.Select(
                  "tede_middle.Id", "tede_middle.MiddleId", "tede_middle.IsTop", "tede_middle.AttributeValue", "tede_middle.FolderName", "tede_middle.CreatedDate"
                , "tede_notice.{UserId,UserName,SourceId,Title,TypeValue,IsRecall}"
                , "tede_user.{AvatarUrl}"
                , "tede_addressee.{Id as NoticeAddresseeId, SourceId as NoticeId}");

            var result = await _noticeRepository.GetNoticeListPageAsync(query, countQuery);
            foreach (var item in result.Items)
            {
                item.IsAdmin = item.UserId == request.UserId;
                var typeValueIds = new List<int>{AllTypeConst.MyChecked.GetHashCode()
                ,AllTypeConst.MyCc.GetHashCode(),AllTypeConst.MySubmitted.GetHashCode()};
                if (typeValueIds.Contains(item.TypeValue))
                {
                    item.IsAdmin = item.IsFlowAdmin;
                    item.TodoId = item.SonId;
                    item.MiddleId = item.SourceId;
                    //item.UserName = item.SendUserName;
                    item.ReadCount = item.CheckedCount + 1;
                    item.AllCount = item.UCheckedCount + 1;
                    item.EnjoyUser = item.FlowUserName;
                    //我发起的
                    if (item.TypeValue == AllTypeConst.MySubmitted.GetHashCode())
                        item.IsRead = true;
                    //我抄送
                    if (item.TypeValue == AllTypeConst.MyCc.GetHashCode())
                        item.IsRead = true;
                    //我审批
                    if (item.TypeValue == AllTypeConst.MyChecked.GetHashCode())
                        item.IsRead = item.IsFlowChecked;

                    if (item.IsDone && item.IsChecked)
                        item.FlowState = FlowState.Checked;
                    else if (item.IsDone && !item.IsChecked)
                    {
                        if (item.DoneType == 1)
                            item.FlowState = FlowState.Meeting;
                        else if (item.DoneType == 2)
                            item.FlowState = FlowState.Wait;
                        else
                            item.FlowState = FlowState.Denied;
                    }
                    else if (item.IsDone && !item.IsChecked)
                        item.FlowState = FlowState.Denied;
                    else
                    {
                        item.FlowState = FlowState.Checking;
                    }
                }
                // item.Title = _contentJsonService.GetTitile(item.Title, item.Content);
                if (request.SearchType == 3)
                    item.NoticeStatus = 0;
                else if (request.SearchType == 2)
                    item.NoticeStatus = 2;
                else
                    item.NoticeStatus = 1;
                if (item.IsRecall)
                    item.IsRead = true;
            }
            return result;
        }
        /// <summary>
        /// 撤销通知
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public async Task<bool> RecallAsync(int id)
        {
            try
            {
                using (TransactionScope transactionScope = new TransactionScope())
                {
                    var query = Q.NewQuery();
                    //修改通知
                    await _noticeRepository.UpdateAsync(Q.Where(nameof(Entity.Notice.Id), id).Set(nameof(Entity.Notice.IsRecall), true));
                    //删除middle
                    query.Where(nameof(Entity.Middle.Middle.MiddleId), id);
                    query.Where(nameof(Entity.Middle.Middle.FolderType), GxPress.EnumConst.AllTypeConst.Inbox.GetHashCode());
                    query.Where(nameof(Entity.Middle.Middle.IsAdmin), false);
                    //query.Set(nameof(Entity.Middle.Middle.IsRecall), true);
                    await _middleRepository.DeleteAsync(query);
                    // //修改middle
                    // query = Q.NewQuery();
                    // query.Where(nameof(Entity.Middle.Middle.MiddleId), id);
                    // query.Where(nameof(Entity.Middle.Middle.FolderType), GxPress.EnumConst.AllTypeConst.Inbox.GetHashCode());
                    // query.Where(nameof(Entity.Middle.Middle.IsAdmin), true);
                    // query.Set(nameof(Entity.Middle.Middle.IsRecall), true);
                    // await _middleRepository.UpdateAsync(query);
                    // //修改为草稿箱
                    // query = Q.NewQuery();
                    // query.Where(nameof(Entity.Middle.Middle.MiddleId), id);
                    // query.Where(nameof(Entity.Middle.Middle.FolderType), GxPress.EnumConst.FolderTypeConst.Notice.GetHashCode());
                    // query.Where(nameof(Entity.Middle.Middle.IsAdmin), true);
                    // query.Set(nameof(Entity.Middle.Middle.NoticeAddresseeType), 2);
                    // await _middleRepository.UpdateAsync(query);
                    //修改未撤回状态
                    await _noticeRepository.UpdateAsync(Q.Where(nameof(Entity.Notice.Id), id).Set(nameof(Entity.Notice.NoticeType), NoticeTypeConst.Draft.GetHashCode()));
                    transactionScope.Complete();
                }
            }
            catch (System.Exception ex)
            {
                throw new BusinessException(ex.Message);
            }
            return true;
        }

        public async Task<bool> UpdateNoticeTitleAsync()
        {
            var query = Q.NewQuery();
            query.Where(n => n.OrWhereNull(nameof(Entity.Notice.Title)).OrWhere(nameof(Entity.Notice.Title), "=", ""));
            var result = await _noticeRepository.GetAllAsync(query);
            foreach (var item in result)
            {
                item.Title = _contentJsonService.GetTitile(item.Title, item.Content);
                await _noticeRepository.UpdateAsync(item);
            }
            return true;
        }
    }
}