Merge branch 'master' of http://110.188.24.182:10023/Fengwo/hotline

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,6 +35,8 @@ public class EndWorkflowHandler : INotificationHandler<EndWorkflowNotify>
     private readonly IRepository<OrderScreen> _orderScreenRepository;
     private readonly IRepository<Bulletin> _bulletinRepository;
     private readonly IRepository<Circular> _circularRepository;
+    private readonly IRepositorySqlSugar<CircularReadGroup> _circularReadGroupRepository;
+    private readonly IRepositorySqlSugar<CircularRecord> _circularRecordRepository;
 
     public EndWorkflowHandler(
         IKnowledgeDomainService knowledgeDomainService,
@@ -48,7 +50,9 @@ public class EndWorkflowHandler : INotificationHandler<EndWorkflowNotify>
         IRepository<OrderVisitDetail> orderVisitedDetailRepository,
         IRepository<OrderScreen> orderScreenRepository,
         IRepository<Bulletin> bulletinRepository,
-        IRepository<Circular> circularRepository
+        IRepository<Circular> circularRepository,
+        IRepositorySqlSugar<CircularReadGroup> circularReadGroupRepository,
+        IRepositorySqlSugar<CircularRecord> circularRecordRepository
         )
     {
         _knowledgeDomainService = knowledgeDomainService;
@@ -63,6 +67,8 @@ public class EndWorkflowHandler : INotificationHandler<EndWorkflowNotify>
         _orderVisitedDetailRepository = orderVisitedDetailRepository;
         _bulletinRepository = bulletinRepository;
         _circularRepository = circularRepository;
+        _circularReadGroupRepository = circularReadGroupRepository;
+        _circularRecordRepository = circularRecordRepository;
     }
 
     /// <summary>Handles a notification</summary>
@@ -139,7 +145,30 @@ public class EndWorkflowHandler : INotificationHandler<EndWorkflowNotify>
                     circular.CircularTime = DateTime.Now;
                     await _circularRepository.UpdateAsync(circular, cancellationToken);
                     //更新阅读数量
-
+                    if (circular.CircularType == Share.Enums.Article.ECircularType.Person)
+                    {
+                        //个人
+                         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);
+    }
+}

src/Hotline/FlowEngine/Workflows/Workflow.cs

@@ -389,10 +389,7 @@ public partial class Workflow
     /// </summary>
     public void UpdateActualOption()
     {
-        var stepBox = Steps.FirstOrDefault(d => d.Code == ActualHandleStepCode);
-        if (stepBox is null)
-            throw new UserFriendlyException($"未查询到对应实际办理节点，workflowId: {Id}");
-        var step = stepBox.Steps.FirstOrDefault(d => d.Id == ActualHandleStepId);
+        var step = Steps.FirstOrDefault(d => d.Id == ActualHandleStepId);
         if (step is null)
             throw new UserFriendlyException($"未查询到对应实际办理子节点，workflowId: {Id}");
         ActualOpinion = step.Opinion;

src/Hotline/FlowEngine/Workflows/WorkflowDomainService.cs

@@ -1324,9 +1324,9 @@ namespace Hotline.FlowEngine.Workflows
                  null, null, null,
                      EWorkflowStepStatus.WaitForAccept, ECountersignPosition.None, DateTime.Now);
 
-            step.Accept(_sessionContext.RequiredUserId, _sessionContext.UserName,
-                _sessionContext.RequiredOrgId, _sessionContext.OrgName,
-                _sessionContext.OrgAreaCode, _sessionContext.OrgAreaName);
+            //step.Accept(_sessionContext.RequiredUserId, _sessionContext.UserName,
+            //    _sessionContext.RequiredOrgId, _sessionContext.OrgName,
+            //    _sessionContext.OrgAreaCode, _sessionContext.OrgAreaName);
 
             HandleStep(step, string.Empty);