添加了查看部门下所有任务接口

notes-job/src/main/java/com/zjty/tynotes/job/basic/controller/WorkController.java

@@ -20,6 +20,7 @@ import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
 
 import java.util.Date;
+import java.util.List;
 
 import static org.springframework.http.ResponseEntity.ok;
 
@@ -174,8 +175,7 @@ public class WorkController {
                 workService.alterTaskStatus(workId, status);
                 businessTreeManagement.saveAction(userId, workId, Action.FINISH_WORK, new Date(), msg);
                 break;
-            case WorkStatus
-                        .FINISHED:
+            case WorkStatus.FINISHED:
                 workService.alterTaskStatus(workId, status);
                 businessTreeManagement.saveAction(userId, workId, Action.FINISHED_WORK, new Date(), msg);
 
@@ -201,4 +201,11 @@ public class WorkController {
         return ok(workService.findBySuperoirIdCount(workId));
     }
 
+    @GetMapping(value = "/select/work/{userId}")
+    @ApiOperation(value = "根据用户id查看其部门所有的任务", notes = "部门所有的任务")
+    public ResponseEntity<List<WorkVo>> selectWorkUserId(@PathVariable("userId") String userId) {
+
+        return ok(workService.selectUserIdsWork(userId));
+    }
+
 }

notes-job/src/main/java/com/zjty/tynotes/job/basic/repository/WorkRepository.java

@@ -13,6 +13,18 @@ import java.util.List;
  */
 @Repository
 public interface WorkRepository extends MongoRepository<Work, String> {
+    /**
+     *   上级任务id查询所有子任务
+     * @param superiorId 任务id
+     * @return 任务集合
+     */
     List<Work> findBySuperiorId(String superiorId);
 
+    /**
+     * 根据执行者id查询所有的任务
+     * @param ids 用户id集合
+     * @return
+     */
+    List<Work> findAllByExecutorIn(List<String> ids);
+
 }

notes-job/src/main/java/com/zjty/tynotes/job/basic/service/WorkService.java

@@ -2,6 +2,7 @@ package com.zjty.tynotes.job.basic.service;
 
 import com.zjty.tynotes.job.basic.entity.database.Work;
 import com.zjty.tynotes.job.basic.entity.response.WorkIsNotCommit;
+import com.zjty.tynotes.job.basic.entity.response.WorkVo;
 import com.zjty.tynotes.job.basic.service.impl.WorkServiceImpl;
 import org.springframework.stereotype.Service;
 
@@ -126,4 +127,6 @@ public interface WorkService {
 //     * 查看正在进行中的任务
 //     */
 //    List<Work> selectTimeWork();
+
+     List<WorkVo> selectUserIdsWork(String userId);
 }

notes-job/src/main/java/com/zjty/tynotes/job/basic/service/impl/ConversionServiceImpl.java

@@ -3,6 +3,7 @@ package com.zjty.tynotes.job.basic.service.impl;
 import com.zjty.tynotes.job.basic.entity.database.Attachment;
 import com.zjty.tynotes.job.basic.entity.database.Work;
 import com.zjty.tynotes.job.basic.entity.response.WorkVo;
+import com.zjty.tynotes.job.basic.repository.AttachmentRepository;
 import com.zjty.tynotes.job.basic.service.AttachmentService;
 import com.zjty.tynotes.job.basic.service.ConversionService;
 import com.zjty.tynotes.pas.entity.User;
@@ -21,7 +22,7 @@ public class ConversionServiceImpl implements ConversionService {
     IUserService iUserService;
 
     @Autowired
-    AttachmentService attachmentService;
+    AttachmentRepository attachmentRepository;
 
     @Override
     public WorkVo workToVo(Work work) {
@@ -42,7 +43,7 @@ public class ConversionServiceImpl implements ConversionService {
 
         if (attachIds!=null && attachIds.size()!=0){
             for (String id:attachIds){
-                attachments.add(attachmentService.findById(id));
+                attachments.add(attachmentRepository.findById(id).get());
             }
         }
         return new WorkVo(

notes-job/src/main/java/com/zjty/tynotes/job/basic/service/impl/WorkServiceImpl.java

@@ -3,11 +3,15 @@ package com.zjty.tynotes.job.basic.service.impl;
 import com.google.common.collect.Lists;
 import com.zjty.tynotes.job.basic.entity.database.Work;
 import com.zjty.tynotes.job.basic.entity.response.WorkIsNotCommit;
+import com.zjty.tynotes.job.basic.entity.response.WorkVo;
 import com.zjty.tynotes.job.basic.repository.WorkRepository;
+import com.zjty.tynotes.job.basic.service.ConversionService;
 import com.zjty.tynotes.job.basic.service.WorkService;
 import com.zjty.tynotes.job.common.constant.WorkStatus;
 import com.zjty.tynotes.job.common.exception.BadRequestException;
 import com.zjty.tynotes.job.common.exception.NotFoundException;
+import com.zjty.tynotes.pas.service.IUserService;
+import com.zjty.tynotes.pas.service.impl.UserServiceImpl;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
@@ -16,6 +20,7 @@ import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;
 import java.util.Optional;
+import java.util.stream.Collectors;
 
 import static java.util.Objects.isNull;
 import static java.util.Objects.nonNull;
@@ -35,6 +40,11 @@ public class WorkServiceImpl implements WorkService {
     private final
     WorkRepository workRepository;
 
+    @Autowired
+    IUserService iUserService;
+
+    @Autowired
+    ConversionService conversionService;
     @Autowired
     public WorkServiceImpl(WorkRepository workRepository) {
         this.workRepository = workRepository;
@@ -115,6 +125,9 @@ public class WorkServiceImpl implements WorkService {
         workRepository.save(ob);
     }
 
+
+
+
     @Override
     public void deleteWork(String taskId, int personalWorkload, int workloadCount) {
         Work ob = workRepository.findById(taskId).get();
@@ -179,6 +192,16 @@ public class WorkServiceImpl implements WorkService {
 
     }
 
+    @Override
+    public List<WorkVo> selectUserIdsWork(String userId) {
+
+
+        return workRepository.findAllByExecutorIn(iUserService.findUsers(userId))
+                .stream()
+                .map(conversionService::workToVo)
+                .collect(Collectors.toList());
+    }
+
 //    @Override
 //    public List<Work> selectTimeWork() {
 ////        LocalDateTime minTime = LocalDateTime.now().with(LocalTime.MIN).atZone(ZoneOffset.ofHours(8)).ge;

notes-job/src/main/java/com/zjty/tynotes/job/common/exception/WorkAttribution1.java

@@ -21,6 +21,10 @@ public interface WorkAttribution1 {
      */
     int ME_RELEASE_WORK = 3;
 
+    /**
+     * 我的接收任务
+     */
+    int ME_RECEIVE_WORK = 4;
 
 
 

notes-job/src/main/java/com/zjty/tynotes/job/status/entity/RedisPersonalWork.java

@@ -84,4 +84,17 @@ public class RedisPersonalWork {
      */
     @ApiModelProperty(value = "是否是代办任务",name = "isNotCommission",example = "1是代办 0不是")
     private int isNotCommission;
+
+//    /**
+//     * 任务根据人员的状态
+//     */
+//    @ApiModelProperty(value = "任务根据人员的状态")
+//    private int TaskPersonnelStatus;
+
+    /**
+     * 执行人和发布者是否是同一人
+     */
+    private int executorEqualRelease;
+
+
 }

notes-job/src/main/java/com/zjty/tynotes/job/status/service/impl/InternalServiceImpl.java

 package com.zjty.tynotes.job.status.service.impl;
 
 import com.zjty.tynotes.job.common.Constants;
+import com.zjty.tynotes.job.common.constant.WorkStatus;
 import com.zjty.tynotes.job.common.exception.WorkAttribution;
+import com.zjty.tynotes.job.common.exception.WorkAttribution1;
 import com.zjty.tynotes.job.status.entity.Personnel;
 import com.zjty.tynotes.job.status.entity.RedisPersonalWork;
 import com.zjty.tynotes.job.status.service.InternalService;
@@ -31,7 +33,10 @@ public class InternalServiceImpl implements InternalService {
             for (Object object:lists){
 
                 RedisPersonalWork redisPersonalWork=(RedisPersonalWork)object;
-                if (redisPersonalWork.getWorkAttribution()==WorkAttribution.ME_WORK){
+                if (redisPersonalWork.getWorkAttribution()==WorkAttribution1.ME_RECEIVE_WORK && redisPersonalWork.getStatus().equals(WorkStatus.ONGOING)){
+                    count++;
+                }
+                if (redisPersonalWork.getExecutorEqualRelease()==1&& redisPersonalWork.getStatus().equals(WorkStatus.ONGOING)){
                     count++;
                 }
             }
@@ -47,7 +52,10 @@ public class InternalServiceImpl implements InternalService {
         for (Object object:lists){
 
             RedisPersonalWork redisPersonalWork=(RedisPersonalWork)object;
-            if (redisPersonalWork.getWorkAttribution()==WorkAttribution.ME_WORK){
+            if (redisPersonalWork.getWorkAttribution()==WorkAttribution1.ME_RECEIVE_WORK && redisPersonalWork.getStatus().equals(WorkStatus.ONGOING)){
+                count++;
+            }
+            if (redisPersonalWork.getExecutorEqualRelease()==1&& redisPersonalWork.getStatus().equals(WorkStatus.ONGOING)){
                 count++;
             }
         }

notes-job/src/main/java/com/zjty/tynotes/job/status/service/impl/TestSeeServiceImpl.java

 package com.zjty.tynotes.job.status.service.impl;
 
 import com.zjty.tynotes.job.common.Constants;
+import com.zjty.tynotes.job.common.constant.WorkStatus;
 import com.zjty.tynotes.job.common.exception.WorkAttribution1;
 import com.zjty.tynotes.job.status.entity.EsListSum;
 import com.zjty.tynotes.job.status.entity.RedisListSum;
@@ -37,9 +38,10 @@ public class TestSeeServiceImpl implements TestSeeService {
         List<Object> objectList=redisTemplate.opsForList().range(Constants.REDIS_EVENT+id,0,-1);
         for (Object object:objectList){
             RedisPersonalWork redisPersonalWork=(RedisPersonalWork)object;
-            if (redisPersonalWork.getWorkAttribution()==WorkAttribution1.ME_RELATED_WORK){
+            if (redisPersonalWork.getWorkAttribution()==WorkAttribution1.ME_RELATED_WORK || redisPersonalWork.getWorkAttribution()==WorkAttribution1.ME_RECEIVE_WORK || redisPersonalWork.getExecutorEqualRelease()==1 ){
                 list.add(redisPersonalWork);
             }
+
         }
 
         return listSum(list,size,page);

notes-job/src/main/java/com/zjty/tynotes/job/status/service/impl/TestServiceImpl.java

@@ -7,7 +7,6 @@ import com.zjty.tynotes.job.common.constant.WorkStatus;
 import com.zjty.tynotes.job.common.exception.WorkAttribution;
 import com.zjty.tynotes.job.common.exception.WorkAttribution1;
 import com.zjty.tynotes.job.status.entity.RedisPersonalWork;
-import com.zjty.tynotes.job.status.entity.RoleSum;
 import com.zjty.tynotes.job.status.entity.RoleSum1;
 import com.zjty.tynotes.job.status.service.TestService;
 import com.zjty.tynotes.job.status.utils.JacksonUtil;
@@ -62,46 +61,78 @@ public class TestServiceImpl implements TestService {
         Long time=new Date().getTime();
         String releaseName= iUserService.findUserById(work.getPublisher()).getUsername();
         String executorName= iUserService.findUserById(work.getExecutor()).getUsername();
-        RedisPersonalWork personalWork=new RedisPersonalWork(work.getId(),time,work.getTitle(),work.getStatus(),releaseName,executorName,1,WorkAttribution.ME_WORK,latestNews,work.getSuperiorId(),new ArrayList<>(),0);
-        //发布人
-        if (work.getSuperiorId()==null){
-            personalWork.setWorkAttribution(WorkAttribution1.ME_RELEASE_WORK);
-            personalWork.setReadState(0);
-            redisTemplate.opsForList().leftPush(Constants.REDIS_EVENT+work.getPublisher(),personalWork);
-
-            asynchronousAddEs(Constants.REDIS_EVENT+work.getPublisher(),personalWork);
-            List<Object> list=redisTemplate.opsForList().range(Constants.REDIS_EVENT+work.getPublisher(),0,-1);
-            assert list != null;
-            pushData(work.getPublisher(),JacksonUtil.toJSon(statisticalRoleCount(list)));
-            log.info("{}这里发送{}",work.getPublisher(), JacksonUtil.toJSon(statisticalRoleCount(list)));
+        RedisPersonalWork personalWork=new RedisPersonalWork(work.getId(),time,work.getTitle(),work.getStatus(),releaseName,executorName,1,WorkAttribution.ME_WORK,latestNews,work.getSuperiorId(),new ArrayList<>(),0,0);
+        if (releaseName.equals(executorName)){
+            if (work.getSuperiorId() == null){
+                personalWork.setWorkAttribution(WorkAttribution1.ME_RELEASE_WORK);
+                personalWork.setExecutorEqualRelease(1);
+                personalWork.setReadState(0);
+                personalWork.setIsNotCommission(1);
+                redisTemplate.opsForList().leftPush(Constants.REDIS_EVENT + work.getPublisher(), personalWork);
+
+                asynchronousAddEs(Constants.REDIS_EVENT + work.getPublisher(), personalWork);
+                List<Object> list = redisTemplate.opsForList().range(Constants.REDIS_EVENT + work.getPublisher(), 0, -1);
+                assert list != null;
+                pushData(work.getPublisher(), JacksonUtil.toJSon(statisticalRoleCount(list)));
+                log.info("{}这里发送{}", work.getPublisher(), JacksonUtil.toJSon(statisticalRoleCount(list)));
+
+            }else {
+                uIds = tests(work.getSuperiorId(), uIds);
+                personalWork.setWorkAttribution(WorkAttribution1.ME_RESOLVE_WORK);
+                personalWork.setExecutorEqualRelease(1);
+                personalWork.setReadState(0);
+                personalWork.setIsNotCommission(1);
+                redisTemplate.opsForList().leftPush(Constants.REDIS_EVENT + work.getPublisher(), personalWork);
+
+                asynchronousAddEs(Constants.REDIS_EVENT + work.getPublisher(), personalWork);
+                List<Object> list = redisTemplate.opsForList().range(Constants.REDIS_EVENT + work.getPublisher(), 0, -1);
+                assert list != null;
+                pushData(work.getPublisher(), JacksonUtil.toJSon(statisticalRoleCount(list)));
+                log.info("{}这里发送{}", work.getPublisher(), JacksonUtil.toJSon(statisticalRoleCount(list)));
+
+            }
 
         }else {
-            uIds=tests(work.getSuperiorId(),uIds);
-            personalWork.setWorkAttribution(WorkAttribution1.ME_RESOLVE_WORK);
-            personalWork.setReadState(0);
-            redisTemplate.opsForList().leftPush(Constants.REDIS_EVENT+work.getPublisher(),personalWork);
+            //发布人
+            if (work.getSuperiorId() == null) {
+                personalWork.setWorkAttribution(WorkAttribution1.ME_RELEASE_WORK);
+                personalWork.setReadState(0);
+                redisTemplate.opsForList().leftPush(Constants.REDIS_EVENT + work.getPublisher(), personalWork);
+
+                asynchronousAddEs(Constants.REDIS_EVENT + work.getPublisher(), personalWork);
+                List<Object> list = redisTemplate.opsForList().range(Constants.REDIS_EVENT + work.getPublisher(), 0, -1);
+                assert list != null;
+                pushData(work.getPublisher(), JacksonUtil.toJSon(statisticalRoleCount(list)));
+                log.info("{}这里发送{}", work.getPublisher(), JacksonUtil.toJSon(statisticalRoleCount(list)));
 
-            asynchronousAddEs(Constants.REDIS_EVENT+work.getPublisher(),personalWork);
-            List<Object> list=redisTemplate.opsForList().range(Constants.REDIS_EVENT+work.getPublisher(),0,-1);
-            assert list != null;
-            pushData(work.getPublisher(),JacksonUtil.toJSon(statisticalRoleCount(list)));
-            subWork(list,work,work.getPublisher());
-            log.info("{}这里发送{}",work.getPublisher(), JacksonUtil.toJSon(statisticalRoleCount(list)));
-        }
-        //执行人 判断执行人是否有分解权限
+            } else {
+                uIds = tests(work.getSuperiorId(), uIds);
+                personalWork.setWorkAttribution(WorkAttribution1.ME_RESOLVE_WORK);
+                personalWork.setReadState(0);
+                redisTemplate.opsForList().leftPush(Constants.REDIS_EVENT + work.getPublisher(), personalWork);
+
+                asynchronousAddEs(Constants.REDIS_EVENT + work.getPublisher(), personalWork);
+                List<Object> list = redisTemplate.opsForList().range(Constants.REDIS_EVENT + work.getPublisher(), 0, -1);
+                assert list != null;
+                pushData(work.getPublisher(), JacksonUtil.toJSon(statisticalRoleCount(list)));
+                subWork(list, work, work.getPublisher());
+                log.info("{}这里发送{}", work.getPublisher(), JacksonUtil.toJSon(statisticalRoleCount(list)));
+            }
+            //执行人 判断执行人是否有分解权限
 
-        personalWork.setWorkAttribution(WorkAttribution1.ME_RELATED_WORK);
-        personalWork.setReadState(1);
-        personalWork.setIsNotCommission(1);
-        redisTemplate.opsForList().leftPush(Constants.REDIS_EVENT+work.getExecutor(),personalWork);
+            personalWork.setWorkAttribution(WorkAttribution1.ME_RECEIVE_WORK);
+            personalWork.setReadState(1);
+            personalWork.setIsNotCommission(1);
+            redisTemplate.opsForList().leftPush(Constants.REDIS_EVENT + work.getExecutor(), personalWork);
 
-        asynchronousAddEs(Constants.REDIS_EVENT+work.getExecutor(),personalWork);
-        List<Object> list=redisTemplate.opsForList().range(Constants.REDIS_EVENT+work.getExecutor(),0,-1);
-        assert list != null;
-        pushData(work.getExecutor(),JacksonUtil.toJSon(statisticalRoleCount(list)));
-        subWork(list,work,work.getExecutor());
-        log.info("{}这里发送{}",work.getExecutor(), JacksonUtil.toJSon(statisticalRoleCount(list)));
+            asynchronousAddEs(Constants.REDIS_EVENT + work.getExecutor(), personalWork);
+            List<Object> list = redisTemplate.opsForList().range(Constants.REDIS_EVENT + work.getExecutor(), 0, -1);
+            assert list != null;
+            pushData(work.getExecutor(), JacksonUtil.toJSon(statisticalRoleCount(list)));
+            subWork(list, work, work.getExecutor());
+            log.info("{}这里发送{}", work.getExecutor(), JacksonUtil.toJSon(statisticalRoleCount(list)));
 
+        }
         //有待修改
         if (uIds.size()!=0) {
             for (String id : uIds) {
@@ -111,7 +142,7 @@ public class TestServiceImpl implements TestService {
                 redisTemplate.opsForList().leftPush(Constants.REDIS_EVENT + id, personalWork);
 
                 asynchronousAddEs(Constants.REDIS_EVENT + id, personalWork);
-                list = redisTemplate.opsForList().range(Constants.REDIS_EVENT + id, 0, -1);
+              List<Object>  list = redisTemplate.opsForList().range(Constants.REDIS_EVENT + id, 0, -1);
                 assert list != null;
                 pushData(id, JacksonUtil.toJSon(statisticalRoleCount(list)));
                 subWork(list, work, id);
@@ -127,30 +158,59 @@ public class TestServiceImpl implements TestService {
 
         String releaseName= iUserService.findUserById(work.getPublisher()).getUsername();
         String executorName= iUserService.findUserById(work.getExecutor()).getUsername();
-        RedisPersonalWork personalWork=new RedisPersonalWork(work.getId(),time,work.getTitle(),work.getStatus(),releaseName,executorName,1,WorkAttribution.ME_WORK,latestNews,work.getSuperiorId(),new ArrayList<>(),0);
-        //发布人
-        if (work.getSuperiorId()==null){
-            personalWork.setWorkAttribution(WorkAttribution1.ME_RELEASE_WORK);
-            personalWork.setReadState(0);
-            redisTemplate.opsForList().leftPush(Constants.REDIS_EVENT+work.getPublisher(),personalWork);
-
-            asynchronousAddEs(Constants.REDIS_EVENT+work.getPublisher(),personalWork);
-            List<Object> list=redisTemplate.opsForList().range(Constants.REDIS_EVENT+work.getPublisher(),0,-1);
-            assert list != null;
-            pushData(work.getPublisher(),JacksonUtil.toJSon(statisticalRoleCount(list)));
-            log.info("{}这里发送{}",work.getPublisher(), JacksonUtil.toJSon(statisticalRoleCount(list)));
+        RedisPersonalWork personalWork=new RedisPersonalWork(work.getId(),time,work.getTitle(),work.getStatus(),releaseName,executorName,1,WorkAttribution.ME_WORK,latestNews,work.getSuperiorId(),new ArrayList<>(),0,0);
+        if (releaseName.equals(executorName)){
+            if (work.getSuperiorId() == null){
+                personalWork.setWorkAttribution(WorkAttribution1.ME_RELEASE_WORK);
+                personalWork.setExecutorEqualRelease(1);
+                personalWork.setReadState(0);
+                redisTemplate.opsForList().leftPush(Constants.REDIS_EVENT + work.getPublisher(), personalWork);
+
+                asynchronousAddEs(Constants.REDIS_EVENT + work.getPublisher(), personalWork);
+                List<Object> list = redisTemplate.opsForList().range(Constants.REDIS_EVENT + work.getPublisher(), 0, -1);
+                assert list != null;
+                pushData(work.getPublisher(), JacksonUtil.toJSon(statisticalRoleCount(list)));
+                log.info("{}这里发送{}", work.getPublisher(), JacksonUtil.toJSon(statisticalRoleCount(list)));
 
+            }else {
+                personalWork.setWorkAttribution(WorkAttribution1.ME_RESOLVE_WORK);
+                personalWork.setExecutorEqualRelease(1);
+                personalWork.setReadState(0);
+                redisTemplate.opsForList().leftPush(Constants.REDIS_EVENT + work.getPublisher(), personalWork);
+
+                asynchronousAddEs(Constants.REDIS_EVENT + work.getPublisher(), personalWork);
+                List<Object> list = redisTemplate.opsForList().range(Constants.REDIS_EVENT + work.getPublisher(), 0, -1);
+                assert list != null;
+                pushData(work.getPublisher(), JacksonUtil.toJSon(statisticalRoleCount(list)));
+                log.info("{}这里发送{}", work.getPublisher(), JacksonUtil.toJSon(statisticalRoleCount(list)));
+
+            }
         }else {
-            personalWork.setWorkAttribution(WorkAttribution1.ME_RESOLVE_WORK);
-            personalWork.setReadState(0);
-            redisTemplate.opsForList().leftPush(Constants.REDIS_EVENT+work.getPublisher(),personalWork);
 
-            asynchronousAddEs(Constants.REDIS_EVENT+work.getPublisher(),personalWork);
-            List<Object> list=redisTemplate.opsForList().range(Constants.REDIS_EVENT+work.getPublisher(),0,-1);
-            assert list != null;
-            pushData(work.getPublisher(),JacksonUtil.toJSon(statisticalRoleCount(list)));
-            subWork(list,work,work.getPublisher());
-            log.info("{}这里发送{}",work.getPublisher(), JacksonUtil.toJSon(statisticalRoleCount(list)));
+            //发布人
+            if (work.getSuperiorId() == null) {
+                personalWork.setWorkAttribution(WorkAttribution1.ME_RELEASE_WORK);
+                personalWork.setReadState(0);
+                redisTemplate.opsForList().leftPush(Constants.REDIS_EVENT + work.getPublisher(), personalWork);
+
+                asynchronousAddEs(Constants.REDIS_EVENT + work.getPublisher(), personalWork);
+                List<Object> list = redisTemplate.opsForList().range(Constants.REDIS_EVENT + work.getPublisher(), 0, -1);
+                assert list != null;
+                pushData(work.getPublisher(), JacksonUtil.toJSon(statisticalRoleCount(list)));
+                log.info("{}这里发送{}", work.getPublisher(), JacksonUtil.toJSon(statisticalRoleCount(list)));
+
+            } else {
+                personalWork.setWorkAttribution(WorkAttribution1.ME_RESOLVE_WORK);
+                personalWork.setReadState(0);
+                redisTemplate.opsForList().leftPush(Constants.REDIS_EVENT + work.getPublisher(), personalWork);
+
+                asynchronousAddEs(Constants.REDIS_EVENT + work.getPublisher(), personalWork);
+                List<Object> list = redisTemplate.opsForList().range(Constants.REDIS_EVENT + work.getPublisher(), 0, -1);
+                assert list != null;
+                pushData(work.getPublisher(), JacksonUtil.toJSon(statisticalRoleCount(list)));
+                subWork(list, work, work.getPublisher());
+                log.info("{}这里发送{}", work.getPublisher(), JacksonUtil.toJSon(statisticalRoleCount(list)));
+            }
         }
     }
 
@@ -163,36 +223,54 @@ public class TestServiceImpl implements TestService {
         }
         String releaseName= iUserService.findUserById(work.getPublisher()).getUsername();
         String executorName= iUserService.findUserById(work.getExecutor()).getUsername();
-        RedisPersonalWork personalWork=new RedisPersonalWork(work.getId(),time,work.getTitle(),work.getStatus(),releaseName,executorName,1,WorkAttribution.ME_WORK,latestNews,work.getSuperiorId(),new ArrayList<>(),0);
-        //发布人
-        List<Object> objects = redisTemplate.opsForList().range(Constants.REDIS_EVENT + work.getPublisher(), 0, -1);
-        for (Object object:objects){
-            RedisPersonalWork redisPersonalWork=(RedisPersonalWork) object;
-            if (work.getId().equals(redisPersonalWork.getWorkId())){
-                redisTemplate.opsForList().remove(Constants.REDIS_EVENT+work.getPublisher(),1,redisPersonalWork);
-                redisPersonalWork.setStatus(work.getStatus());
-                redisPersonalWork.setTime(time);
-                redisPersonalWork.setLatestNews(latestNews);
-                redisTemplate.opsForList().leftPush(Constants.REDIS_EVENT+work.getPublisher(),redisPersonalWork);
-                asynchronousAddEs(Constants.REDIS_EVENT+work.getPublisher(),personalWork);
+        RedisPersonalWork personalWork=new RedisPersonalWork(work.getId(),time,work.getTitle(),work.getStatus(),releaseName,executorName,1,WorkAttribution.ME_WORK,latestNews,work.getSuperiorId(),new ArrayList<>(),0,0);
+        if (releaseName.equals(executorName)){
+            List<Object> objects = redisTemplate.opsForList().range(Constants.REDIS_EVENT + work.getPublisher(), 0, -1);
+            for (Object object : objects) {
+                RedisPersonalWork redisPersonalWork = (RedisPersonalWork) object;
+                if (work.getId().equals(redisPersonalWork.getWorkId())) {
+                    redisTemplate.opsForList().remove(Constants.REDIS_EVENT + work.getPublisher(), 1, redisPersonalWork);
+                    redisPersonalWork.setStatus(work.getStatus());
+                    redisPersonalWork.setTime(time);
+                    redisPersonalWork.setIsNotCommission(1);
+                    redisPersonalWork.setLatestNews(latestNews);
+                    redisTemplate.opsForList().leftPush(Constants.REDIS_EVENT + work.getPublisher(), redisPersonalWork);
+                    asynchronousAddEs(Constants.REDIS_EVENT + work.getPublisher(), personalWork);
+                }
             }
-        }
-        pushData(work.getPublisher(),JacksonUtil.toJSon(statisticalRoleCount(objects)));
-        subWork(objects,work,work.getPublisher());
-        log.info("{}这里发送{}",work.getPublisher(), JacksonUtil.toJSon(statisticalRoleCount(objects)));
+            pushData(work.getPublisher(), JacksonUtil.toJSon(statisticalRoleCount(objects)));
+            subWork(objects, work, work.getPublisher());
+            log.info("{}这里发送{}", work.getPublisher(), JacksonUtil.toJSon(statisticalRoleCount(objects)));
+        }else {
+            //发布人
+            List<Object> objects = redisTemplate.opsForList().range(Constants.REDIS_EVENT + work.getPublisher(), 0, -1);
+            for (Object object : objects) {
+                RedisPersonalWork redisPersonalWork = (RedisPersonalWork) object;
+                if (work.getId().equals(redisPersonalWork.getWorkId())) {
+                    redisTemplate.opsForList().remove(Constants.REDIS_EVENT + work.getPublisher(), 1, redisPersonalWork);
+                    redisPersonalWork.setStatus(work.getStatus());
+                    redisPersonalWork.setTime(time);
+                    redisPersonalWork.setLatestNews(latestNews);
+                    redisTemplate.opsForList().leftPush(Constants.REDIS_EVENT + work.getPublisher(), redisPersonalWork);
+                    asynchronousAddEs(Constants.REDIS_EVENT + work.getPublisher(), personalWork);
+                }
+            }
+            pushData(work.getPublisher(), JacksonUtil.toJSon(statisticalRoleCount(objects)));
+            subWork(objects, work, work.getPublisher());
+            log.info("{}这里发送{}", work.getPublisher(), JacksonUtil.toJSon(statisticalRoleCount(objects)));
 
             personalWork.setWorkAttribution(WorkAttribution1.ME_RELATED_WORK);
             personalWork.setReadState(1);
             personalWork.setIsNotCommission(1);
-            redisTemplate.opsForList().leftPush(Constants.REDIS_EVENT+work.getExecutor(),personalWork);
+            redisTemplate.opsForList().leftPush(Constants.REDIS_EVENT + work.getExecutor(), personalWork);
 
-            asynchronousAddEs(Constants.REDIS_EVENT+work.getExecutor(),personalWork);
-            List<Object> list=redisTemplate.opsForList().range(Constants.REDIS_EVENT+work.getExecutor(),0,-1);
+            asynchronousAddEs(Constants.REDIS_EVENT + work.getExecutor(), personalWork);
+            List<Object> list = redisTemplate.opsForList().range(Constants.REDIS_EVENT + work.getExecutor(), 0, -1);
             assert list != null;
-            pushData(work.getExecutor(),JacksonUtil.toJSon(statisticalRoleCount(list)));
-            subWork(list,work,work.getExecutor());
-            log.info("{}这里发送{}",work.getExecutor(), JacksonUtil.toJSon(statisticalRoleCount(list)));
-
+            pushData(work.getExecutor(), JacksonUtil.toJSon(statisticalRoleCount(list)));
+            subWork(list, work, work.getExecutor());
+            log.info("{}这里发送{}", work.getExecutor(), JacksonUtil.toJSon(statisticalRoleCount(list)));
+        }
         //有待修改
         for (String id:uIds){
             personalWork.setWorkAttribution(WorkAttribution1.ME_RELATED_WORK);
@@ -201,7 +279,7 @@ public class TestServiceImpl implements TestService {
             redisTemplate.opsForList().leftPush(Constants.REDIS_EVENT+id,personalWork);
 
             asynchronousAddEs(Constants.REDIS_EVENT+id,personalWork);
-            list=redisTemplate.opsForList().range(Constants.REDIS_EVENT+id,0,-1);
+           List<Object> list=redisTemplate.opsForList().range(Constants.REDIS_EVENT+id,0,-1);
             assert list != null;
             pushData(id,JacksonUtil.toJSon(statisticalRoleCount(list)));
             subWork(list,work,id);
@@ -216,76 +294,116 @@ public class TestServiceImpl implements TestService {
         if (work.getSuperiorId()!=null) {
             uIds = tests(work.getSuperiorId(), uIds);
         }
-        //发布者
-        List<Object> list = redisTemplate.opsForList().range(Constants.REDIS_EVENT + work.getPublisher(), 0, -1);
-        for (Object object:list){
-            RedisPersonalWork redisPersonalWork=(RedisPersonalWork)object;
-            if (redisPersonalWork.getWorkId().equals(work.getId())){
-                redisTemplate.opsForList().remove(Constants.REDIS_EVENT+work.getPublisher(),1,redisPersonalWork);
-                redisPersonalWork.setStatus(status);
-                redisPersonalWork.setTime(time);
-                if (work.getPublisher().equals(executorId)){
-                    redisPersonalWork.setReadState(0);
-                }else {
-                    redisPersonalWork.setReadState(1);
-                }
-                switch(status){
-                    case WorkStatus.ONGOING:
-                        redisPersonalWork.setIsNotCommission(0);
-                        break;
-                    case WorkStatus.AUDIT:
-                        redisPersonalWork.setIsNotCommission(1);
-                        break;
-                    case WorkStatus.REVIEW:
-                        redisPersonalWork.setIsNotCommission(0);
-                        break;
-                default:
-                    redisPersonalWork.setIsNotCommission(0);
-                    break;
-                }
 
-                redisPersonalWork.setLatestNews(latestNews);
-                redisTemplate.opsForList().leftPush(Constants.REDIS_EVENT+work.getPublisher(),redisPersonalWork);
-                asynchronousAddEs(Constants.REDIS_EVENT+work.getPublisher(),redisPersonalWork);
+        if (work.getExecutor().equals(work.getPublisher())){
+            List<Object> list = redisTemplate.opsForList().range(Constants.REDIS_EVENT + work.getPublisher(), 0, -1);
+            for (Object object : list) {
+                RedisPersonalWork redisPersonalWork = (RedisPersonalWork) object;
+                if (redisPersonalWork.getWorkId().equals(work.getId())) {
+                    redisTemplate.opsForList().remove(Constants.REDIS_EVENT + work.getPublisher(), 1, redisPersonalWork);
+                    redisPersonalWork.setStatus(status);
+                    redisPersonalWork.setTime(time);
+                    if (work.getPublisher().equals(executorId)) {
+                        redisPersonalWork.setReadState(0);
+                    } else {
+                        redisPersonalWork.setReadState(1);
+                    }
+                    switch (status) {
+                        case WorkStatus.ONGOING:
+                            redisPersonalWork.setIsNotCommission(1);
+                            break;
+                        case WorkStatus.AUDIT:
+                            redisPersonalWork.setIsNotCommission(1);
+                            break;
+                        case WorkStatus.REVIEW:
+                            redisPersonalWork.setIsNotCommission(1);
+                            break;
+                        default:
+                            redisPersonalWork.setIsNotCommission(0);
+                            break;
+                    }
+
+                    redisPersonalWork.setLatestNews(latestNews);
+                    redisTemplate.opsForList().leftPush(Constants.REDIS_EVENT + work.getPublisher(), redisPersonalWork);
+                    asynchronousAddEs(Constants.REDIS_EVENT + work.getPublisher(), redisPersonalWork);
+                }
             }
-        }
-        pushData(work.getPublisher(),JacksonUtil.toJSon(statisticalRoleCount(list)));
-     //执行者
-        list = redisTemplate.opsForList().range(Constants.REDIS_EVENT + work.getExecutor(), 0, -1);
-        for (Object object:list){
-            RedisPersonalWork redisPersonalWork=(RedisPersonalWork)object;
-            if (redisPersonalWork.getWorkId().equals(work.getId())){
-                redisTemplate.opsForList().remove(Constants.REDIS_EVENT+work.getExecutor(),1,redisPersonalWork);
-                redisPersonalWork.setStatus(status);
-                if (work.getPublisher().equals(executorId)){
-                    redisPersonalWork.setReadState(0);
-                }else {
-                    redisPersonalWork.setReadState(1);
+            pushData(work.getPublisher(), JacksonUtil.toJSon(statisticalRoleCount(list)));
+
+
+        }else {
+
+            //发布者
+            List<Object> list = redisTemplate.opsForList().range(Constants.REDIS_EVENT + work.getPublisher(), 0, -1);
+            for (Object object : list) {
+                RedisPersonalWork redisPersonalWork = (RedisPersonalWork) object;
+                if (redisPersonalWork.getWorkId().equals(work.getId())) {
+                    redisTemplate.opsForList().remove(Constants.REDIS_EVENT + work.getPublisher(), 1, redisPersonalWork);
+                    redisPersonalWork.setStatus(status);
+                    redisPersonalWork.setTime(time);
+                    if (work.getPublisher().equals(executorId)) {
+                        redisPersonalWork.setReadState(0);
+                    } else {
+                        redisPersonalWork.setReadState(1);
+                    }
+                    switch (status) {
+                        case WorkStatus.ONGOING:
+                            redisPersonalWork.setIsNotCommission(0);
+                            break;
+                        case WorkStatus.AUDIT:
+                            redisPersonalWork.setIsNotCommission(1);
+                            break;
+                        case WorkStatus.REVIEW:
+                            redisPersonalWork.setIsNotCommission(0);
+                            break;
+                        default:
+                            redisPersonalWork.setIsNotCommission(0);
+                            break;
+                    }
+
+                    redisPersonalWork.setLatestNews(latestNews);
+                    redisTemplate.opsForList().leftPush(Constants.REDIS_EVENT + work.getPublisher(), redisPersonalWork);
+                    asynchronousAddEs(Constants.REDIS_EVENT + work.getPublisher(), redisPersonalWork);
                 }
-                redisPersonalWork.setTime(time);
-                switch(status){
-                    case WorkStatus.ONGOING:
-                        redisPersonalWork.setIsNotCommission(1);
-                        break;
-                    case WorkStatus.AUDIT:
-                        redisPersonalWork.setIsNotCommission(0);
-                        break;
-                    case WorkStatus.REVIEW:
-                        redisPersonalWork.setIsNotCommission(1);
-                        break;
-                    default:
-                        redisPersonalWork.setIsNotCommission(0);
-                        break;
+            }
+            pushData(work.getPublisher(), JacksonUtil.toJSon(statisticalRoleCount(list)));
+            //执行者
+            list = redisTemplate.opsForList().range(Constants.REDIS_EVENT + work.getExecutor(), 0, -1);
+            for (Object object : list) {
+                RedisPersonalWork redisPersonalWork = (RedisPersonalWork) object;
+                if (redisPersonalWork.getWorkId().equals(work.getId())) {
+                    redisTemplate.opsForList().remove(Constants.REDIS_EVENT + work.getExecutor(), 1, redisPersonalWork);
+                    redisPersonalWork.setStatus(status);
+                    if (work.getPublisher().equals(executorId)) {
+                        redisPersonalWork.setReadState(0);
+                    } else {
+                        redisPersonalWork.setReadState(1);
+                    }
+                    redisPersonalWork.setTime(time);
+                    switch (status) {
+                        case WorkStatus.ONGOING:
+                            redisPersonalWork.setIsNotCommission(1);
+                            break;
+                        case WorkStatus.AUDIT:
+                            redisPersonalWork.setIsNotCommission(0);
+                            break;
+                        case WorkStatus.REVIEW:
+                            redisPersonalWork.setIsNotCommission(1);
+                            break;
+                        default:
+                            redisPersonalWork.setIsNotCommission(0);
+                            break;
+                    }
+                    redisPersonalWork.setLatestNews(latestNews);
+                    redisTemplate.opsForList().leftPush(Constants.REDIS_EVENT + work.getExecutor(), redisPersonalWork);
+                    asynchronousAddEs(Constants.REDIS_EVENT + work.getExecutor(), redisPersonalWork);
                 }
-                redisPersonalWork.setLatestNews(latestNews);
-                redisTemplate.opsForList().leftPush(Constants.REDIS_EVENT+work.getExecutor(),redisPersonalWork);
-                asynchronousAddEs(Constants.REDIS_EVENT+work.getExecutor(),redisPersonalWork);
             }
+            pushData(work.getExecutor(), JacksonUtil.toJSon(statisticalRoleCount(list)));
         }
-        pushData(work.getExecutor(),JacksonUtil.toJSon(statisticalRoleCount(list)));
    if (uIds.size()!=0) {
        for (String uId:uIds) {
-           list = redisTemplate.opsForList().range(Constants.REDIS_EVENT + uId, 0, -1);
+        List<Object>   list = redisTemplate.opsForList().range(Constants.REDIS_EVENT + uId, 0, -1);
            for (Object object : list) {
                RedisPersonalWork redisPersonalWork = (RedisPersonalWork) object;
                if (redisPersonalWork.getWorkId().equals(work.getId())) {
@@ -312,37 +430,59 @@ public class TestServiceImpl implements TestService {
             uIds = tests(work.getSuperiorId(), uIds);
         }
         Long time=new Date().getTime();
-        //发布者
-        List<Object> list = redisTemplate.opsForList().range(Constants.REDIS_EVENT + work.getPublisher(), 0, -1);
-        for (Object object:list){
-            RedisPersonalWork redisPersonalWork=(RedisPersonalWork)object;
-            if (redisPersonalWork.getWorkId().equals(work.getId())){
-                redisTemplate.opsForList().remove(Constants.REDIS_EVENT+work.getPublisher(),1,redisPersonalWork);
-                redisPersonalWork.setReadState(0);
-                redisPersonalWork.setTime(time);
-                redisPersonalWork.setLatestNews(latestNews);
-                redisTemplate.opsForList().leftPush(Constants.REDIS_EVENT+work.getPublisher(),redisPersonalWork);
-                asynchronousAddEs(Constants.REDIS_EVENT+work.getPublisher(),redisPersonalWork);
+        if (work.getExecutor().equals(work.getPublisher())){
+            List<Object> list = redisTemplate.opsForList().range(Constants.REDIS_EVENT + work.getPublisher(), 0, -1);
+            for (Object object : list) {
+                RedisPersonalWork redisPersonalWork = (RedisPersonalWork) object;
+                if (redisPersonalWork.getWorkId().equals(work.getId())) {
+                    redisTemplate.opsForList().remove(Constants.REDIS_EVENT + work.getPublisher(), 1, redisPersonalWork);
+                    redisPersonalWork.setReadState(0);
+                    redisPersonalWork.setTime(time);
+                    redisPersonalWork.setLatestNews(latestNews);
+                    redisTemplate.opsForList().leftPush(Constants.REDIS_EVENT + work.getPublisher(), redisPersonalWork);
+                    asynchronousAddEs(Constants.REDIS_EVENT + work.getPublisher(), redisPersonalWork);
+                }
             }
-        }
-        pushData(work.getPublisher(),JacksonUtil.toJSon(statisticalRoleCount(list)));
-        //执行者
-        list = redisTemplate.opsForList().range(Constants.REDIS_EVENT + work.getExecutor(), 0, -1);
-        for (Object object:list){
-            RedisPersonalWork redisPersonalWork=(RedisPersonalWork)object;
-            if (redisPersonalWork.getWorkId().equals(work.getId())){
-                redisTemplate.opsForList().remove(Constants.REDIS_EVENT+work.getExecutor(),1,redisPersonalWork);
-                redisPersonalWork.setReadState(1);
-                redisPersonalWork.setTime(time);
-                redisPersonalWork.setLatestNews(latestNews);
-                redisTemplate.opsForList().leftPush(Constants.REDIS_EVENT+work.getExecutor(),redisPersonalWork);
-                asynchronousAddEs(Constants.REDIS_EVENT+work.getExecutor(),redisPersonalWork);
+            pushData(work.getPublisher(), JacksonUtil.toJSon(statisticalRoleCount(list)));
+
+        }else {
+
+            //发布者
+            List<Object> list = redisTemplate.opsForList().range(Constants.REDIS_EVENT + work.getPublisher(), 0, -1);
+            for (Object object : list) {
+                RedisPersonalWork redisPersonalWork = (RedisPersonalWork) object;
+                if (redisPersonalWork.getWorkId().equals(work.getId())) {
+                    redisTemplate.opsForList().remove(Constants.REDIS_EVENT + work.getPublisher(), 1, redisPersonalWork);
+                    if (executorId.equals(work.getPublisher())) {
+                        redisPersonalWork.setReadState(0);
+                    }else {
+                        redisPersonalWork.setReadState(1);
+                    }
+                    redisPersonalWork.setTime(time);
+                    redisPersonalWork.setLatestNews(latestNews);
+                    redisTemplate.opsForList().leftPush(Constants.REDIS_EVENT + work.getPublisher(), redisPersonalWork);
+                    asynchronousAddEs(Constants.REDIS_EVENT + work.getPublisher(), redisPersonalWork);
+                }
             }
+            pushData(work.getPublisher(), JacksonUtil.toJSon(statisticalRoleCount(list)));
+            //执行者
+            list = redisTemplate.opsForList().range(Constants.REDIS_EVENT + work.getExecutor(), 0, -1);
+            for (Object object : list) {
+                RedisPersonalWork redisPersonalWork = (RedisPersonalWork) object;
+                if (redisPersonalWork.getWorkId().equals(work.getId())) {
+                    redisTemplate.opsForList().remove(Constants.REDIS_EVENT + work.getExecutor(), 1, redisPersonalWork);
+                    redisPersonalWork.setReadState(1);
+                    redisPersonalWork.setTime(time);
+                    redisPersonalWork.setLatestNews(latestNews);
+                    redisTemplate.opsForList().leftPush(Constants.REDIS_EVENT + work.getExecutor(), redisPersonalWork);
+                    asynchronousAddEs(Constants.REDIS_EVENT + work.getExecutor(), redisPersonalWork);
+                }
+            }
+            pushData(work.getExecutor(), JacksonUtil.toJSon(statisticalRoleCount(list)));
         }
-        pushData(work.getExecutor(),JacksonUtil.toJSon(statisticalRoleCount(list)));
         if (uIds.size()!=0) {
             for (String uId:uIds) {
-                list = redisTemplate.opsForList().range(Constants.REDIS_EVENT + uId, 0, -1);
+             List<Object>  list = redisTemplate.opsForList().range(Constants.REDIS_EVENT + uId, 0, -1);
                 for (Object object : list) {
                     RedisPersonalWork redisPersonalWork = (RedisPersonalWork) object;
                     if (redisPersonalWork.getWorkId().equals(work.getId())) {
@@ -367,49 +507,67 @@ public class TestServiceImpl implements TestService {
             uIds = tests(work.getSuperiorId(), uIds);
         }
         Long time=new Date().getTime();
-        //发布者
-        List<Object> list = redisTemplate.opsForList().range(Constants.REDIS_EVENT + work.getPublisher(), 0, -1);
-        for (Object object:list){
-            RedisPersonalWork redisPersonalWork=(RedisPersonalWork)object;
-            if (redisPersonalWork.getWorkId().equals(work.getId())){
-                redisTemplate.opsForList().remove(Constants.REDIS_EVENT+work.getPublisher(),1,redisPersonalWork);
-                if (work.getPublisher().equals(executorId)){
-                    redisPersonalWork.setReadState(0);
-                    redisPersonalWork.setIsNotCommission(0);
-                }else {
-                    redisPersonalWork.setReadState(1);
+        if (work.getExecutor().equals(work.getPublisher())){
+            List<Object> list = redisTemplate.opsForList().range(Constants.REDIS_EVENT + work.getPublisher(), 0, -1);
+            for (Object object : list) {
+                RedisPersonalWork redisPersonalWork = (RedisPersonalWork) object;
+                if (redisPersonalWork.getWorkId().equals(work.getId())) {
+                    redisTemplate.opsForList().remove(Constants.REDIS_EVENT + work.getPublisher(), 1, redisPersonalWork);
                     redisPersonalWork.setIsNotCommission(1);
+                    redisPersonalWork.setReadState(0);
+                    redisPersonalWork.setTime(time);
+                    redisPersonalWork.setLatestNews(latestNews);
+                    redisTemplate.opsForList().leftPush(Constants.REDIS_EVENT + work.getPublisher(), redisPersonalWork);
+                    asynchronousAddEs(Constants.REDIS_EVENT + work.getPublisher(), redisPersonalWork);
                 }
-                redisPersonalWork.setTime(time);
-                redisPersonalWork.setLatestNews(latestNews);
-                redisTemplate.opsForList().leftPush(Constants.REDIS_EVENT+work.getPublisher(),redisPersonalWork);
-                asynchronousAddEs(Constants.REDIS_EVENT+work.getPublisher(),redisPersonalWork);
             }
-        }
-        pushData(work.getPublisher(),JacksonUtil.toJSon(statisticalRoleCount(list)));
-        //执行者
-        list = redisTemplate.opsForList().range(Constants.REDIS_EVENT + work.getExecutor(), 0, -1);
-        for (Object object:list){
-            RedisPersonalWork redisPersonalWork=(RedisPersonalWork)object;
-            if (redisPersonalWork.getWorkId().equals(work.getId())){
-                redisTemplate.opsForList().remove(Constants.REDIS_EVENT+work.getExecutor(),1,redisPersonalWork);
-                if (work.getExecutor().equals(executorId)){
-                    redisPersonalWork.setReadState(0);
-                    redisPersonalWork.setIsNotCommission(0);
-                }else {
-                    redisPersonalWork.setReadState(1);
-                    redisPersonalWork.setIsNotCommission(0);
+            pushData(work.getPublisher(), JacksonUtil.toJSon(statisticalRoleCount(list)));
+
+        }else {
+            //发布者
+            List<Object> list = redisTemplate.opsForList().range(Constants.REDIS_EVENT + work.getPublisher(), 0, -1);
+            for (Object object : list) {
+                RedisPersonalWork redisPersonalWork = (RedisPersonalWork) object;
+                if (redisPersonalWork.getWorkId().equals(work.getId())) {
+                    redisTemplate.opsForList().remove(Constants.REDIS_EVENT + work.getPublisher(), 1, redisPersonalWork);
+                    if (work.getPublisher().equals(executorId)) {
+                        redisPersonalWork.setReadState(0);
+                        redisPersonalWork.setIsNotCommission(0);
+                    } else {
+                        redisPersonalWork.setReadState(1);
+                        redisPersonalWork.setIsNotCommission(1);
+                    }
+                    redisPersonalWork.setTime(time);
+                    redisPersonalWork.setLatestNews(latestNews);
+                    redisTemplate.opsForList().leftPush(Constants.REDIS_EVENT + work.getPublisher(), redisPersonalWork);
+                    asynchronousAddEs(Constants.REDIS_EVENT + work.getPublisher(), redisPersonalWork);
                 }
-                redisPersonalWork.setTime(time);
-                redisPersonalWork.setLatestNews(latestNews);
-                redisTemplate.opsForList().leftPush(Constants.REDIS_EVENT+work.getExecutor(),redisPersonalWork);
-                asynchronousAddEs(Constants.REDIS_EVENT+work.getExecutor(),redisPersonalWork);
             }
+            pushData(work.getPublisher(), JacksonUtil.toJSon(statisticalRoleCount(list)));
+            //执行者
+            list = redisTemplate.opsForList().range(Constants.REDIS_EVENT + work.getExecutor(), 0, -1);
+            for (Object object : list) {
+                RedisPersonalWork redisPersonalWork = (RedisPersonalWork) object;
+                if (redisPersonalWork.getWorkId().equals(work.getId())) {
+                    redisTemplate.opsForList().remove(Constants.REDIS_EVENT + work.getExecutor(), 1, redisPersonalWork);
+                    if (work.getExecutor().equals(executorId)) {
+                        redisPersonalWork.setReadState(0);
+                        redisPersonalWork.setIsNotCommission(0);
+                    } else {
+                        redisPersonalWork.setReadState(1);
+                        redisPersonalWork.setIsNotCommission(0);
+                    }
+                    redisPersonalWork.setTime(time);
+                    redisPersonalWork.setLatestNews(latestNews);
+                    redisTemplate.opsForList().leftPush(Constants.REDIS_EVENT + work.getExecutor(), redisPersonalWork);
+                    asynchronousAddEs(Constants.REDIS_EVENT + work.getExecutor(), redisPersonalWork);
+                }
+            }
+            pushData(work.getExecutor(), JacksonUtil.toJSon(statisticalRoleCount(list)));
         }
-        pushData(work.getExecutor(),JacksonUtil.toJSon(statisticalRoleCount(list)));
         if (uIds.size()!=0) {
             for (String uId:uIds) {
-                list = redisTemplate.opsForList().range(Constants.REDIS_EVENT + uId, 0, -1);
+             List<Object>   list = redisTemplate.opsForList().range(Constants.REDIS_EVENT + uId, 0, -1);
                 for (Object object : list) {
                     RedisPersonalWork redisPersonalWork = (RedisPersonalWork) object;
                     if (redisPersonalWork.getWorkId().equals(work.getId())) {
@@ -511,6 +669,12 @@ public class TestServiceImpl implements TestService {
                             unread1=1;
                         }
                     }
+                    if (redisPersonalWork.getExecutorEqualRelease()==1){
+                        role2++;
+                        if (redisPersonalWork.getReadState()==1){
+                            unread2=1;
+                        }
+                    }
                     break;
                 case WorkAttribution1.ME_RELEASE_WORK :
                     role4++;
@@ -518,6 +682,26 @@ public class TestServiceImpl implements TestService {
                         unread4=1;
                     }
 
+                    if (redisPersonalWork.getIsNotCommission()==1){
+                        role1++;
+                        if (redisPersonalWork.getReadState()==1){
+                            unread1=1;
+                        }
+                    }
+
+                    if (redisPersonalWork.getExecutorEqualRelease()==1){
+                        role2++;
+                        if (redisPersonalWork.getReadState()==1){
+                            unread2=1;
+                        }
+                    }
+                    break;
+                case WorkAttribution1.ME_RECEIVE_WORK :
+                    role2++;
+                    if (redisPersonalWork.getReadState()==1){
+                        unread2=1;
+                    }
+
                     if (redisPersonalWork.getIsNotCommission()==1){
                         role1++;
                         if (redisPersonalWork.getReadState()==1){