circular

src/Hotline.Api/Controllers/ArticleController.cs

@@ -30,8 +30,9 @@ namespace Hotline.Api.Controllers
         private readonly IRepository<Circular> _circularRepository;
         private readonly ISessionContext _sessionContext;
         private readonly IRepository<CircularRecord> _circularRecordRepository;
+        private readonly IRepository<CircularReadGroup> _circularReadGroupRepository;
 
-        public ArticleController(IRepository<Bulletin> bulletinRepository,IMapper mapper, ISystemDomainService systemDomainService, ISystemOrganizeRepository organizeRepository, IWorkflowApplication workflowApplication, IRepository<Circular> circularRepository,ISessionContext sessionContext,IRepository<CircularRecord> circularRecordRepository)
+        public ArticleController(IRepository<Bulletin> bulletinRepository,IMapper mapper, ISystemDomainService systemDomainService, ISystemOrganizeRepository organizeRepository, IWorkflowApplication workflowApplication, IRepository<Circular> circularRepository,ISessionContext sessionContext,IRepository<CircularRecord> circularRecordRepository,IRepository<CircularReadGroup> circularReadGroupRepository)
         {
             _bulletinRepository = bulletinRepository;
             _mapper = mapper;
@@ -41,6 +42,7 @@ namespace Hotline.Api.Controllers
             _circularRepository = circularRepository;
             _sessionContext = sessionContext;
             _circularRecordRepository = circularRecordRepository;
+            _circularReadGroupRepository = circularReadGroupRepository;
         }
         #region 通知
         /// <summary>
@@ -115,7 +117,7 @@ namespace Hotline.Api.Controllers
         {
             var rsp = new
             {
-                CircularType = _systemDomainService.GetSysDicDataByCodeAsync(SysDicTypeConsts.CircularType)
+                CircularType = await _systemDomainService.GetSysDicDataByCodeAsync(SysDicTypeConsts.CircularType)
             };
             return rsp;
         }
@@ -151,6 +153,19 @@ namespace Hotline.Api.Controllers
             if (model.CircularType == ECircularType.Person)
             {
                 //个人阅读
+                var readGroup = model.CircularReadGroups.FirstOrDefault(x => x.UserId == _sessionContext.UserId && !x.IsRead);
+                if (readGroup!=null)
+                {
+                    readGroup.IsRead = true;
+                    readGroup.ReadTime = DateTime.Now;
+                    if (DateTime.Now > model.LostEfficacyTime)
+                        readGroup.IsTimeOut = true;
+                    else
+                        readGroup.IsTimeOut = false;
+                    await _circularReadGroupRepository.UpdateAsync(readGroup, HttpContext.RequestAborted);
+                    //处理计数
+
+                }
             }
             else
             {
@@ -265,7 +280,7 @@ namespace Hotline.Api.Controllers
         {
             var rsp = new
             {
-                BulletinType = _systemDomainService.GetSysDicDataByCodeAsync(SysDicTypeConsts.BulletinType)
+                BulletinType = await _systemDomainService.GetSysDicDataByCodeAsync(SysDicTypeConsts.BulletinType)
             };
             return rsp;
         }
@@ -280,7 +295,7 @@ namespace Hotline.Api.Controllers
         {
             var rsp = new
             {
-                BulletinType = _systemDomainService.GetSysDicDataByCodeAsync(SysDicTypeConsts.BulletinType),
+                BulletinType = await _systemDomainService.GetSysDicDataByCodeAsync(SysDicTypeConsts.BulletinType),
                 PushRanges = EnumExts.GetDescriptions<EPushRange>(),
                 OrgsOptions = await _organizeRepository.GetOrgJson(),
             };

src/Hotline.Application/Handlers/FlowEngine/EndWorkflowHandler.cs

@@ -35,7 +35,8 @@ public class EndWorkflowHandler : INotificationHandler<EndWorkflowNotify>
     private readonly IRepository<OrderScreen> _orderScreenRepository;
     private readonly IRepository<Bulletin> _bulletinRepository;
     private readonly IRepository<Circular> _circularRepository;
-    private readonly IRepository<CircularReadGroup> _circularReadGroupRepository;
+    private readonly IRepositorySqlSugar<CircularReadGroup> _circularReadGroupRepository;
+    private readonly IRepositorySqlSugar<CircularRecord> _circularRecordRepository;
 
     public EndWorkflowHandler(
         IKnowledgeDomainService knowledgeDomainService,
@@ -50,7 +51,8 @@ public class EndWorkflowHandler : INotificationHandler<EndWorkflowNotify>
         IRepository<OrderScreen> orderScreenRepository,
         IRepository<Bulletin> bulletinRepository,
         IRepository<Circular> circularRepository,
-        IRepository<CircularReadGroup> circularReadGroupRepository
+        IRepositorySqlSugar<CircularReadGroup> circularReadGroupRepository,
+        IRepositorySqlSugar<CircularRecord> circularRecordRepository
         )
     {
         _knowledgeDomainService = knowledgeDomainService;
@@ -66,6 +68,7 @@ public class EndWorkflowHandler : INotificationHandler<EndWorkflowNotify>
         _bulletinRepository = bulletinRepository;
         _circularRepository = circularRepository;
         _circularReadGroupRepository = circularReadGroupRepository;
+        _circularRecordRepository = circularRecordRepository;
     }
 
     /// <summary>Handles a notification</summary>
@@ -145,13 +148,26 @@ public class EndWorkflowHandler : INotificationHandler<EndWorkflowNotify>
                     if (circular.CircularType == Share.Enums.Article.ECircularType.Person)
                     {
                         //个人
-                         _circularReadGroupRepository.Queryable().Where(x => x.CircularId == circular.Id).Select(x => x.UserId).ToList();
-                        //_circularReadGroupRepository.
-
+                         var userlist = await _circularReadGroupRepository.Queryable()
+                            .Where(x => x.CircularId == circular.Id)
+                            .Select(x => x.UserId)
+                            .ToListAsync(cancellationToken);
+                        await _circularRecordRepository.Updateable()
+                            .SetColumns(x => x.RecordCount == x.RecordCount + 1)
+                            .Where(x => userlist.Contains(x.UserId))
+                            .ExecuteCommandAsync();
                     }
                     else
                     {
                         //部门
+                        var orglist = await _circularReadGroupRepository.Queryable()
+                            .Where(x => x.CircularId == circular.Id)
+                            .Select(x => x.OrgId)
+                            .ToListAsync(cancellationToken);
+                        await _circularRecordRepository.Updateable()
+                            .SetColumns(x => x.RecordCount == x.RecordCount + 1)
+                            .Where(x => orglist.Contains(x.OrgId))
+                            .ExecuteCommandAsync();
                     }
                 }
                 break;

src/Hotline/Article/CircularRecordDomainService.cs

@@ -0,0 +1,90 @@
+using Hotline.Users;
+using XF.Domain.Dependency;
+using XF.Domain.Repository;
+
+namespace Hotline.Article
+{
+    public class CircularRecordDomainService : ICircularRecordDomainService, IScopeDependency
+    {
+        private readonly IRepository<CircularRecord> _circularRecordRepository;
+        public CircularRecordDomainService(IRepository<CircularRecord> circularRecordRepository)
+        {
+              _circularRecordRepository = circularRecordRepository;
+        }
+        public async Task RecordUserHandle(string userId, bool isAdd, CancellationToken cancellationToken)
+        {
+            var userRecord = await _circularRecordRepository.GetAsync(x => x.UserId == userId);
+            if (isAdd)
+            {
+                if (userRecord!=null)
+                {
+                    if (userRecord.RecordCount>0)
+                    {
+                        userRecord.RecordCount++;
+                    }
+                    await _circularRecordRepository.UpdateAsync(userRecord);
+                }
+                else
+                {
+                    userRecord = new CircularRecord();
+                    userRecord.UserId = userId;
+                    userRecord.CircularType = Share.Enums.Article.ECircularType.Person;
+                    userRecord.RecordCount = 1;
+                    await _circularRecordRepository.AddAsync(userRecord);
+                }
+            }
+            else
+            {
+                if (userRecord!=null)
+                {
+                    if (userRecord.RecordCount > 0)
+                    {
+                        userRecord.RecordCount--;
+                    }
+                    else
+                    {
+                        userRecord.RecordCount = 0;
+                    }
+                }
+            }
+        }
+
+        public async Task RecordOrgHandle(string orgId, bool isAdd, CancellationToken cancellationToken)
+        {
+            var orgRecord = await _circularRecordRepository.GetAsync(x => x.OrgId == orgId);
+            if (isAdd)
+            {
+                if (orgRecord!=null)
+                {
+                    if (orgRecord.RecordCount > 0)
+                    {
+                        orgRecord.RecordCount++;
+                    }
+                    await _circularRecordRepository.UpdateAsync(orgRecord);
+                }
+                else
+                {
+                    orgRecord = new CircularRecord();
+                    orgRecord.OrgId = orgId;
+                    orgRecord.CircularType = Share.Enums.Article.ECircularType.Person;
+                    orgRecord.RecordCount = 1;
+                    await _circularRecordRepository.AddAsync(orgRecord);
+                }
+            }
+            else
+            {
+                if (orgRecord != null)
+                {
+                    if (orgRecord.RecordCount > 0)
+                    {
+                        orgRecord.RecordCount--;
+                    }
+                    else
+                    {
+                        orgRecord.RecordCount = 0;
+                    }
+                }
+            }
+        }
+    }
+}

src/Hotline/Article/ICircularRecordDomainService.cs

@@ -0,0 +1,10 @@
+
+namespace Hotline.Article
+{
+    public interface ICircularRecordDomainService
+    {
+        Task RecordUserHandle(string userId,bool isAdd,CancellationToken cancellationToken);
+
+        Task RecordOrgHandle(string orgId, bool isAdd, CancellationToken cancellationToken);
+    }
+}