using Admin.NET.Core;
|
using Furion.DatabaseAccessor;
|
using Furion.DatabaseAccessor.Extensions;
|
using Furion.DependencyInjection;
|
using Furion.DynamicApiController;
|
using Furion.FriendlyException;
|
using Mapster;
|
using Microsoft.AspNetCore.Mvc;
|
using Microsoft.EntityFrameworkCore;
|
|
namespace Admin.NET.Application.Notice
|
{
|
/// <summary>
|
/// 通知公告服务
|
/// </summary>
|
[ApiDescriptionSettings(Name = "Notice", Order = 100)]
|
[Route("api")]
|
public class SysNoticeService : ISysNoticeService, IDynamicApiController, ITransient
|
{
|
private readonly IRepository<SysNotice> _sysNoticeRep; // 通知公告表仓储
|
private readonly IRepository<SysNoticeUser> _sysNoticeUserRep; // 通知公告用户表仓储
|
private readonly IRepository<SysEmp> _sysEmpRep;
|
private readonly ISysNoticeUserService _sysNoticeUserService;
|
|
/// <summary>
|
/// 构造函数
|
/// </summary>
|
/// <param name="sysNoticeRep"></param>
|
/// <param name="sysNoticeUserRep"></param>
|
/// <param name="sysEmpRep"></param>
|
/// <param name="sysNoticeUserService"></param>
|
public SysNoticeService(IRepository<SysNotice> sysNoticeRep,
|
IRepository<SysNoticeUser> sysNoticeUserRep,
|
IRepository<SysEmp> sysEmpRep,
|
ISysNoticeUserService sysNoticeUserService)
|
{
|
_sysNoticeRep = sysNoticeRep;
|
_sysNoticeUserRep = sysNoticeUserRep;
|
_sysEmpRep = sysEmpRep;
|
_sysNoticeUserService = sysNoticeUserService;
|
}
|
|
/// <summary>
|
/// 分页查询通知公告
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpGet("sysNotice/page")]
|
public async Task<PageResult<SysNotice>> QueryNoticePageList([FromQuery] NoticePageInput input)
|
{
|
var searchValue = !string.IsNullOrEmpty(input.SearchValue?.Trim());
|
var notices = await _sysNoticeRep.DetachedEntities
|
.Where(searchValue, u => EF.Functions.Like(u.Title, $"%{input.SearchValue.Trim()}%") ||
|
EF.Functions.Like(u.Content, $"%{input.SearchValue.Trim()}%"))
|
.Where(input.Type > 0, u => u.Type == input.Type)
|
.Where(u => u.Status != NoticeStatus.DELETED)
|
//通知公告管理应只有发布人可以管理自己发布的，其他人只能在已收公告中看到
|
.Where(u => u.PublicUserId == CurrentUserInfo.UserId)
|
.ToADPagedListAsync(input.PageNo, input.PageSize);
|
return notices;
|
}
|
|
/// <summary>
|
/// 增加通知公告
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpPost("sysNotice/add")]
|
public async Task AddNotice(AddNoticeInput input)
|
{
|
if (input.Status != NoticeStatus.DRAFT && input.Status != NoticeStatus.PUBLIC)
|
throw Oops.Oh(ErrorCode.D7000);
|
|
var notice = input.Adapt<SysNotice>();
|
await UpdatePublicInfo(notice);
|
// 如果是发布，则设置发布时间
|
if (input.Status == NoticeStatus.PUBLIC)
|
notice.PublicTime = DateTimeOffset.Now;
|
var newItem = await notice.InsertNowAsync();
|
//如果是草稿则将状态标记为暂不通知，下次更改状态后再修改为未更改状态
|
if (notice.Status != NoticeStatus.DRAFT)
|
{
|
// 通知到的人
|
var noticeUserIdList = input.NoticeUserIdList;
|
var noticeUserStatus = NoticeUserStatus.UNREAD;
|
await _sysNoticeUserService.Add(newItem.Entity.Id, noticeUserIdList, noticeUserStatus);
|
}
|
else
|
{
|
var noticeUserIdList = input.NoticeUserIdList;
|
var noticeUserStatus = NoticeUserStatus.NONOTICE;
|
await _sysNoticeUserService.Add(newItem.Entity.Id, noticeUserIdList, noticeUserStatus);
|
}
|
}
|
|
/// <summary>
|
/// 删除通知公告
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpPost("sysNotice/delete")]
|
public async Task DeleteNotice(DeleteNoticeInput input)
|
{
|
var notice = await _sysNoticeRep.FirstOrDefaultAsync(u => u.Id == input.Id);
|
if (notice.Status != NoticeStatus.DRAFT && notice.Status != NoticeStatus.CANCEL) // 只能删除草稿和撤回的公告
|
throw Oops.Oh(ErrorCode.D7001);
|
if (notice.PublicUserId != CurrentUserInfo.UserId)
|
throw Oops.Oh(ErrorCode.D7003);
|
await notice.DeleteAsync();
|
}
|
|
/// <summary>
|
/// 更新通知公告
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpPost("sysNotice/edit")]
|
public async Task UpdateNotice(UpdateNoticeInput input)
|
{
|
if (input.Status != NoticeStatus.DRAFT && input.Status != NoticeStatus.PUBLIC)
|
throw Oops.Oh(ErrorCode.D7000);
|
|
// 非草稿状态
|
if (input.Status != NoticeStatus.DRAFT)
|
throw Oops.Oh(ErrorCode.D7002);
|
// 如果发布者非本人则不能修改
|
SysNotice noticeInDb = await _sysNoticeRep.DetachedEntities.Where(u => u.Id == input.Id).FirstOrDefaultAsync();
|
if (noticeInDb.PublicUserId != CurrentUserInfo.UserId)
|
throw Oops.Oh(ErrorCode.D7003);
|
|
var notice = input.Adapt<SysNotice>();
|
if (input.Status == NoticeStatus.PUBLIC)
|
{
|
notice.PublicTime = DateTimeOffset.Now;
|
await UpdatePublicInfo(notice);
|
}
|
await notice.UpdateAsync();
|
//如果修改后的状态为非草稿状态则通知
|
if (notice.Status != NoticeStatus.DRAFT)
|
{
|
// 通知到的人
|
var noticeUserIdList = input.NoticeUserIdList;
|
var noticeUserStatus = NoticeUserStatus.UNREAD;
|
await _sysNoticeUserService.Update(input.Id, noticeUserIdList, noticeUserStatus);
|
}
|
}
|
|
/// <summary>
|
/// 获取通知公告详情
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpGet("sysNotice/detail")]
|
public async Task<NoticeDetailOutput> GetNotice([FromQuery] QueryNoticeInput input)
|
{
|
var notice = await _sysNoticeRep.FirstOrDefaultAsync(u => u.Id == input.Id);
|
|
// 获取通知到的用户
|
var noticeUserList = await _sysNoticeUserService.GetNoticeUserListByNoticeId(input.Id);
|
var noticeUserIdList = new List<string>();
|
var noticeUserReadInfoList = new List<NoticeUserRead>();
|
if (noticeUserList != null)
|
{
|
noticeUserList.ForEach(u =>
|
{
|
noticeUserIdList.Add(u.UserId.ToString());
|
var noticeUserRead = new NoticeUserRead
|
{
|
UserId = u.UserId,
|
UserName = CurrentUserInfo.Name,
|
ReadStatus = u.ReadStatus,
|
ReadTime = u.ReadTime
|
};
|
noticeUserReadInfoList.Add(noticeUserRead);
|
});
|
}
|
var noticeResult = notice.Adapt<NoticeDetailOutput>();
|
noticeResult.NoticeUserIdList = noticeUserIdList;
|
noticeResult.NoticeUserReadInfoList = noticeUserReadInfoList;
|
if (noticeResult.Status == NoticeStatus.CANCEL)
|
{
|
noticeResult.Content = "<h1 style=\"text-align: center; \">该内容已被发布者撤回</h1>";
|
}
|
// 如果该条通知公告为已发布，则将当前用户的该条通知公告设置为已读
|
if (notice.Status == NoticeStatus.PUBLIC || notice.Status == NoticeStatus.CANCEL)
|
await _sysNoticeUserService.Read(notice.Id, CurrentUserInfo.UserId, NoticeUserStatus.READ);
|
return noticeResult;
|
}
|
|
/// <summary>
|
/// 修改通知公告状态
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpPost("sysNotice/changeStatus")]
|
public async Task ChangeStatus(ChangeStatusNoticeInput input)
|
{
|
// 状态应为撤回或删除或发布
|
if (input.Status != NoticeStatus.CANCEL && input.Status != NoticeStatus.DELETED && input.Status != NoticeStatus.PUBLIC)
|
throw Oops.Oh(ErrorCode.D7000);
|
|
var noticeuser = await _sysNoticeUserRep.DetachedEntities.Where(u => u.NoticeId == input.Id).Select(u => u.UserId).ToListAsync();
|
|
var notice = await _sysNoticeRep.FirstOrDefaultAsync(u => u.Id == input.Id);
|
if (notice.PublicUserId != CurrentUserInfo.UserId)
|
{
|
throw Oops.Oh(ErrorCode.D7003);
|
}
|
notice.Status = input.Status;
|
if (input.Status == NoticeStatus.CANCEL)
|
{
|
notice.CancelTime = DateTimeOffset.Now;
|
}
|
else if (input.Status == NoticeStatus.PUBLIC)
|
{
|
notice.PublicTime = DateTimeOffset.Now;
|
}
|
await notice.UpdateAsync();
|
if (notice.Status != NoticeStatus.DRAFT)
|
{
|
// 通知到的人
|
var noticeUserIdList = noticeuser;
|
var noticeUserStatus = NoticeUserStatus.UNREAD;
|
await _sysNoticeUserService.Update(input.Id, noticeUserIdList, noticeUserStatus);
|
}
|
}
|
|
/// <summary>
|
/// 获取接收的通知公告
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpGet("sysNotice/received")]
|
public async Task<PageResult<NoticeReceiveOutput>> ReceivedNoticePageList([FromQuery] NoticePageInput input)
|
{
|
var searchValue = !string.IsNullOrEmpty(input.SearchValue?.Trim());
|
var notices = await _sysNoticeRep.DetachedEntities.Join(_sysNoticeUserRep.DetachedEntities, u => u.Id, e => e.NoticeId, (u, e) => new { u, e })
|
.Where(u => u.e.UserId == CurrentUserInfo.UserId)
|
.Where(searchValue, u => EF.Functions.Like(u.u.Title, $"%{input.SearchValue.Trim()}%") ||
|
EF.Functions.Like(u.u.Content, $"%{input.SearchValue.Trim()}%"))
|
.Where(input.Type > 0, u => u.u.Type == input.Type)
|
.Where(u => u.u.Status != NoticeStatus.DELETED && u.u.Status != NoticeStatus.DRAFT)
|
.Select(u => u.u.Adapt(u.e.Adapt<NoticeReceiveOutput>()))
|
.ToADPagedListAsync(input.PageNo, input.PageSize);
|
return notices;
|
}
|
|
/// <summary>
|
/// 更新发布信息
|
/// </summary>
|
/// <param name="notice"></param>
|
[NonAction]
|
private async Task UpdatePublicInfo(SysNotice notice)
|
{
|
var currUserId = CurrentUserInfo.UserId;
|
var emp = await _sysEmpRep.FirstOrDefaultAsync(u => u.Id == currUserId, false);
|
notice.PublicUserId = currUserId;
|
notice.PublicUserName = CurrentUserInfo.Name;
|
notice.PublicOrgId = emp.OrgId;
|
notice.PublicOrgName = emp.OrgName;
|
}
|
|
/// <summary>
|
/// 未处理消息
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpGet("sysNotice/unread")]
|
public async Task<dynamic> UnReadNoticeList([FromQuery] NoticeInput input)
|
{
|
var dic = typeof(NoticeType).EnumToList();
|
var notices = await (from n in _sysNoticeRep.AsQueryable()
|
join u in _sysNoticeUserRep.AsQueryable() on n.Id equals u.NoticeId
|
where u.UserId == CurrentUserInfo.UserId
|
&& u.ReadStatus == NoticeUserStatus.UNREAD
|
orderby n.CreatedTime descending
|
select new NoticeReceiveOutput
|
{
|
CancelTime = n.CancelTime,
|
Id = n.Id,
|
Content = n.Content,
|
Title = n.Title,
|
Status = n.Status,
|
Type = n.Type,
|
PublicOrgId = n.PublicOrgId,
|
PublicOrgName = n.PublicOrgName,
|
PublicTime = n.PublicTime,
|
PublicUserId = n.PublicUserId,
|
PublicUserName = n.PublicUserName,
|
ReadStatus = u.ReadStatus,
|
ReadTime = u.ReadTime
|
})
|
.Skip(input.PageNo > 0 ? input.PageNo - 1 : input.PageNo)
|
.Take(input.PageSize)
|
.ToListAsync();
|
|
var count = notices.Count();
|
|
List<dynamic> noticeClays = new List<dynamic>();
|
int index = 0;
|
foreach (var item in dic)
|
{
|
noticeClays.Add(
|
new
|
{
|
Index = index++,
|
Key = item.Describe,
|
Value = item.Value,
|
NoticeData = notices.Where(m => m.Type == item.Value).ToList()
|
}
|
);
|
}
|
return new
|
{
|
Rows = noticeClays,
|
TotalRows = count
|
};
|
}
|
}
|
}
|
