QRAPI/API/Wood.Service/SystemManage/MessageService.cs

using Microsoft.AspNetCore.Mvc;
using SqlSugar;
using System.Security.Policy;
using Wood.Data.Repository;
using Wood.Entity;
using Wood.Entity.SystemManage;
using Wood.Service.BaseService;
using Wood.Service.SystemManage.Dto;
using Wood.Service.SystemManage.Manager;
using Wood.Service.SystemManage.Param;
using Wood.Util;
using Wood.Util.JwtAuthorization;

namespace Wood.Service.SystemManage
{
	public class MessageService : ApiCRUDService<MessageEntity, MessageEntity, MessageAddParam, MessageUpdateParam>
	{
		private UserManager _userManager { get; }
		private SqlSugarRepository<UserMessageEntity> _userMessageRepository { get; }
		private OrgManager _orgManager { get; }

		public MessageService(SqlSugarRepository<MessageEntity> repository, UserManager userManager, SqlSugarRepository<UserMessageEntity> userMessageRepository, OrgManager orgManager) : base(repository)
		{
			_userManager = userManager;
			_userMessageRepository = userMessageRepository;
			_orgManager = orgManager;
		}

		/// <summary>
		/// 发布通知公告
		/// </summary>
		/// <param name="param"></param>
		/// <returns></returns>
		public async Task Publish(MessagePublishParam param)
		{
			var user = this.UserInfo();
			if (!user!.IsAdmin)
				throw Oops.Oh("非管理员，无法发布！");

			var message = await _repository.GetByIdAsync(param.Id);
			if (message == null)
				throw Oops.Oh("没有找到可发布的通知公告！");

			message.Status = MessageStatusEnum.Published;
			message.PublishAt = DateTime.Now;
			message.PublisherId = user.UserId;
			message.PublisherName = user.RealName;
			message.PublisherOrgId = user.OrgId;
			message.PublisherOrgName = (await _orgManager.AsRepository().GetByIdAsync(user.OrgId))?.OrgName;
			message.MessageType = param.MessageType;

			// 更新发布状态和时间
			await _repository.UpdateAsync(message);

			if (param.UserIds.Any())
			{
				var ums = param.UserIds.Select(it => new UserMessageEntity
				{
					IsRead = false,
					MessageId = param.Id,
					UserId = it,
				});

				await _userMessageRepository.InsertRangeAsync(ums.ToArray());
			}
			else
			{
				var ids = await _userManager.GetOwnUserIdList();
				var ums = ids.Select(it => new UserMessageEntity
				{
					IsRead = false,
					MessageId = param.Id,
					UserId = it,
				});
				await _userMessageRepository.InsertRangeAsync(ums.ToArray());
			}

		}

		/// <summary>
		/// 设置通知公告已读状态
		/// </summary>
		/// <param name="param"></param>
		/// <returns></returns>
		[HttpGet]
		public async Task SetRead(BaseIdParam param)
		{
			await _userMessageRepository.UpdateAsync(u => new UserMessageEntity
			{
				IsRead = true,
				ReadTime = DateTime.Now
			}, u => u.Id == param.Id);
		}

		/// <summary>
		/// 设置通知公告已读状态
		/// </summary>
		/// <returns></returns>
		[HttpGet]
		public async ValueTask<int> MessageCount()
		{
			var user = this.UserInfo();
			return await _userMessageRepository.CountAsync(it => !it.IsRead && it.UserId == user!.UserId);
		}

		/// <summary>
		/// 设置所有通知公告已读状态
		/// </summary>
		/// <returns></returns>
		[HttpGet]
		public async Task SetAllRead()
		{
			var user = this.UserInfo();
			await _userMessageRepository.UpdateAsync(u => new UserMessageEntity
			{
				IsRead = true,
				ReadTime = DateTime.Now
			}, u => u.UserId == user!.UserId);
		}

		/// <summary>
		/// 获取接收的通知公告
		/// </summary>
		/// <param name="param"></param>
		/// <returns></returns>
		public async Task<TDataPaged<MessagePageReceivedDto>> PagedReceived(MessagePageReceivedParam param)
		{
			var user = this.UserInfo();
			return await _userMessageRepository.AsQueryable().Includes(u => u.Message)
				.Where(u => u.UserId == user!.UserId)
				.WhereIF(!string.IsNullOrWhiteSpace(param.Title), u => u.Message!.Title!.Contains(param.Title!
				.Trim()))
				.WhereIF(param.Type.HasValue, u => u.Message!.MessageType == param.Type)
				.OrderBy(u => u.CreateTime, OrderByType.Desc)
				.Select(u => new MessagePageReceivedDto
				{
					Id = u.Id.SelectAll(),
					PublisherName = u.Message!.PublisherName,
					PublisherOrgName = u.Message!.PublisherOrgName,
					PublishAt=u.Message.PublishAt,
					Title = u.Message!.Title,
					MessageType = u.Message!.MessageType,
				})
				.ToPagedListAsync(param.PageIndex, param.PageSize);
		}

		/// <summary>
		/// 获取发布的通知公告
		/// </summary>
		/// <param name="param"></param>
		/// <returns></returns>
		public async Task<TDataPaged<MessagePagedPublishDto>> PagedPublish(MessagePagePublishParam param)
		{
			var user = this.UserInfo();
			return await _repository.AsQueryable()
				.Where(u => u.CreateUserId == user!.UserId)
				.WhereIF(!string.IsNullOrWhiteSpace(param.Title), u => u!.Title!.Contains(param.Title!
				.Trim()))
				.WhereIF(param.Type.HasValue, u => u!.MessageType == param.Type)
				.OrderBy(u => u.CreateTime, OrderByType.Desc)
				.Select(it => new MessagePagedPublishDto
				{
					Id = it.Id.SelectAll()
				})
				.ToPagedListAsync(param.PageIndex, param.PageSize);
		}

		/// <summary>
		/// 删除
		/// </summary>
		/// <param name="param"></param>
		/// <returns></returns>
		public override async Task Delete(BaseIdListParam param)
		{
			if (param.Ids.Any())
			{
				await _repository.FakeDeleteAsync(it => param.Ids.Contains(it.Id));
				await _userMessageRepository.DeleteAsync(it => param.Ids.Contains(it.MessageId));
			}
		}

		/// <summary>
		/// 撤回
		/// </summary>
		/// <param name="param"></param>
		/// <returns></returns>
		public async Task Recalled(BaseIdListParam param)
		{
			if (param.Ids.Any())
			{
				await _repository.AsUpdateable()
					.SetColumns(it => new MessageEntity { Status = MessageStatusEnum.Cancel, RecalledAt = DateTime.Now })
					.Where(it => param.Ids.Contains(it.Id)).ExecuteCommandAsync();
				await _userMessageRepository.DeleteAsync(it => param.Ids.Contains(it.MessageId));
			}
		}
	}
}