发布等

src/main/java/com/sa/zentao/ZentaoApplication.java

@@ -3,16 +3,20 @@ package com.sa.zentao;
 import org.mybatis.spring.annotation.MapperScan;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
 import org.springframework.context.annotation.ComponentScan;
 import org.springframework.scheduling.annotation.EnableScheduling;
-
+//,exclude = DataSourceAutoConfiguration.class
 @SpringBootApplication(scanBasePackages = {"com.sa.zentao"})
 @MapperScan({"com.sa.zentao.mapper","com.sa.**.mapper"})
 @EnableScheduling
 public class ZentaoApplication {
 
 	public static void main(String[] args) {
+
+
 		SpringApplication.run(ZentaoApplication.class, args);
 	}
 
+
 }

src/main/java/com/sa/zentao/conf/AfterRunner.java

@@ -2,7 +2,10 @@ package com.sa.zentao.conf;
 
 //import com.dritec.FastDFSClient;
 
-import com.sa.zentao.service.IFestivalConfigService;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.sa.zentao.dao.ZtProjectDTO;
+import com.sa.zentao.entity.*;
+import com.sa.zentao.service.*;
 import com.sa.zentao.task.SpringTaskJob;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
@@ -12,6 +15,9 @@ import org.springframework.boot.ApplicationRunner;
 import org.springframework.core.annotation.Order;
 import org.springframework.stereotype.Component;
 
+import java.util.ArrayList;
+import java.util.List;
+
 @Component
 @Order(value = 1)
 @Slf4j
@@ -25,12 +31,19 @@ public class AfterRunner implements ApplicationRunner {
     private com.sa.zentao.task.SpringTaskJob springTaskJob;
 
 
+
+
+
+
     @Override
     public void run(ApplicationArguments args) throws Exception {
         //初始化假期
         festivalConfigService.initfestivalAndHoliday();
         springTaskJob.dkEveryDay();
         new Thread(new DevopsRunner()).start();
+
+
+
     }
 
 }

src/main/java/com/sa/zentao/conf/CodeGenerator.java

@@ -22,7 +22,7 @@ public class CodeGenerator {
     //自己的名字
     static String Author = "gqb";
 
-    public static String tableName = "zt_yw_fault_list";
+    public static String tableName = "zt_notice";
 
     /**
      * <p>

src/main/java/com/sa/zentao/conf/DynamicDataSourceConfig.java

@@ -0,0 +1,28 @@
+//import org.apache.ibatis.session.SqlSessionFactory;
+//import org.mybatis.spring.SqlSessionFactoryBean;
+//import org.mybatis.spring.annotation.MapperScan;
+//import org.springframework.boot.context.properties.ConfigurationProperties;
+//import org.springframework.context.annotation.Bean;
+//import org.springframework.context.annotation.Configuration;
+//
+//import javax.sql.DataSource;
+//
+//@Configuration
+//@MapperScan("com.example.mapper")
+//public class DynamicDataSourceConfig {
+//    @Bean
+//    @ConfigurationProperties(prefix = "spring.datasource.dynamic")
+//    public DataSource dataSource() {
+//        return new DynamicDataSource();
+//    }
+//    @Bean
+//    public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
+//        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
+//        sqlSessionFactoryBean.setDataSource(dataSource);
+//        return sqlSessionFactoryBean.getObject();
+//    }
+//    @Bean
+//    public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
+//        return new SqlSessionTemplate(sqlSessionFactory);
+//    }
+//}

src/main/java/com/sa/zentao/conf/ExcelListener.java

@@ -0,0 +1,17 @@
+package com.sa.zentao.conf;
+
+import com.alibaba.excel.context.AnalysisContext;
+import com.alibaba.excel.event.AnalysisEventListener;
+import com.sa.zentao.dao.ZtTaskImportDTO;
+
+public class ExcelListener extends AnalysisEventListener<ZtTaskImportDTO> {
+    @Override
+    public void invoke(ZtTaskImportDTO data, AnalysisContext context) {
+        System.out.println("读取到数据：" + data);
+    }
+ 
+    @Override
+    public void doAfterAllAnalysed(AnalysisContext context) {
+        // 所有数据解析完成后做的事情
+    }
+}

src/main/java/com/sa/zentao/conf/ParamOutAspect.java

@@ -0,0 +1,140 @@
+package com.sa.zentao.conf;
+
+import com.fasterxml.jackson.annotation.JsonAutoDetect;
+import com.fasterxml.jackson.annotation.PropertyAccessor;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.SerializationFeature;
+import jakarta.servlet.http.HttpServletResponse;
+import lombok.extern.slf4j.Slf4j;
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.annotation.Around;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.reflect.MethodSignature;
+import org.springframework.stereotype.Component;
+import org.springframework.web.context.request.RequestContextHolder;
+import org.springframework.web.context.request.ServletRequestAttributes;
+import org.springframework.web.multipart.MultipartFile;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+@Component
+@Aspect
+@Slf4j
+public class ParamOutAspect {
+
+    //对包下所有的controller结尾的类的所有方法增强
+    private final String Controller = "execution(* com.sa..*Controller.*(..))";
+
+    //对包下所有的controller结尾的类的所有方法增强
+//    private final String executeExpr = "execution(* com.sa.yyc.rest..*Controller.*(..))";
+
+
+
+    @Around(Controller)
+    public Object controller(ProceedingJoinPoint joinPoint) throws Throwable {
+        log.info("后台调用接口---------------------");
+        //获取response
+        HttpServletResponse response = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getResponse();
+        //核心设置
+        response.setHeader("Access-Control-Allow-Origin", "*");
+        log.info("加入请求头标成功");
+
+        /**
+         * 获取 request 中包含的请求参数
+         */
+        String uuid = UUID.randomUUID().toString();
+        jakarta.servlet.http.HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
+        /**
+         * 获取切点请求参数(class,method)
+         */
+        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
+        Method method = signature.getMethod();
+        String params = getRequestParams(request, joinPoint);
+
+        /**
+         * 入参日志
+         */
+        log.info("[AOP-LOG-START-入参]\n\trequestMark: {}\n\trequestIP: {}\n\tcontentType:{}\n\trequestUrl: {}\n\t" +
+                        "requestMethod: {}\n\trequestParams: {}\n\ttargetClassAndMethod: {}#{}", uuid, request.getRemoteAddr(),
+                request.getHeader("Content-Type"),request.getRequestURL(), request.getMethod(), params,
+                method.getDeclaringClass().getName(), method.getName());
+
+
+        String authorization = request.getHeader("Authorization");
+        log.info("token : " + authorization);
+
+        String str =request.getRequestURI().replaceAll("/+$","");
+
+
+       Object proceed = joinPoint.proceed();
+
+
+
+//        if(ObjectUtils.isEmpty(result)){
+//            Object proceed = joinPoint.proceed();
+//            if(proceed!=null){
+//                result = (Result)proceed;
+//            }
+//        }
+
+
+        log.info("[AOP-LOG-END-返回]\n\t{}", proceed);
+        return proceed;
+    }
+
+    private String getRequestParams(jakarta.servlet.http.HttpServletRequest request, ProceedingJoinPoint joinPoint) throws JsonProcessingException {
+        StringBuilder params = new StringBuilder();
+        if ("GET".equalsIgnoreCase(request.getMethod())) {
+            params.append(request.getQueryString());
+        }
+        if ("POST".equalsIgnoreCase(request.getMethod())) {
+            /**
+             * 获取 request parameter 中的参数
+             */
+            Map<String, String[]> parameterMap = request.getParameterMap();
+            if (parameterMap != null && !parameterMap.isEmpty()) {
+                for (Map.Entry<String, String[]> entry : parameterMap.entrySet()) {
+                    params.append(entry.getKey() + " = " + entry.getValue()[0] + ";");
+                }
+            }
+            /**
+             * 获取非 request parameter 中的参数
+             */
+            Object[] objects = joinPoint.getArgs();
+            for (Object arg : objects) {
+                if (arg == null) {
+                    break;
+                }
+                String className = arg.getClass().getName().toLowerCase();
+                String contentType = request.getHeader("Content-Type");
+                /**
+                 * 文件参数,上传文件信息
+                 */
+                if (className.contains("MultipartFile".toLowerCase())) {
+                    MultipartFile multipartFile = (MultipartFile) arg;
+                    params.append("fileSize = " + multipartFile.getSize() + ";");
+                    params.append("fileContentType = " + multipartFile.getContentType() + ";");
+                    params.append("fieldName = " + multipartFile.getName() + ";");
+                    params.append("fileOriginalName = " + multipartFile.getOriginalFilename() + ";");
+                }
+                if (contentType != null && contentType.contains("application/json")){
+                    /**
+                     * json 参数
+                     */
+                    ObjectMapper mapper = new ObjectMapper();
+                    mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
+                    mapper.setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY);
+                    params.append(mapper.writeValueAsString(arg));
+                }
+            }
+        }
+        return params.toString();
+    }
+
+
+}

src/main/java/com/sa/zentao/controller/CommonsController.java

@@ -1,8 +1,13 @@
 package com.sa.zentao.controller;
 
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.sa.zentao.conf.RiskUserThreadLocal;
 import com.sa.zentao.dao.BusinessException;
 import com.sa.zentao.dao.Code;
 import com.sa.zentao.dao.Result;
+import com.sa.zentao.dao.UploadDTO;
+import com.sa.zentao.entity.ZtFile;
+import com.sa.zentao.service.IZtFileService;
 import com.sa.zentao.utils.DateUtils;
 import com.sa.zentao.utils.UploadUtil;
 import lombok.extern.slf4j.Slf4j;
@@ -11,8 +16,12 @@ import org.springframework.beans.factory.annotation.Value;
 import org.springframework.web.bind.annotation.*;
 import org.springframework.web.multipart.MultipartFile;
 
+import java.io.ByteArrayOutputStream;
+import java.io.FileInputStream;
 import java.io.IOException;
+import java.io.InputStream;
 import java.lang.reflect.Method;
+import java.net.URL;
 import java.util.*;
 import java.util.stream.Collectors;
 
@@ -45,18 +54,120 @@ public class CommonsController {
     @Value("${file.baseUrl}")
     private String baseUrl;
 
+
+    @Autowired
+    private IZtFileService fileService;
+
+
     @PostMapping("/upload")
-    public Result<String> upload(@RequestParam("file") MultipartFile file){
+    public Result<String> upload(  UploadDTO file){
-        if (file.isEmpty()) {
+        if (file.getFile().isEmpty()) {
             return Result.fail(Code.FAIL);
         }
         try {
             // 获取文件名
-            String fName = file.getOriginalFilename();
+            String fName = file.getFile().getOriginalFilename();
+            String title=fName;
+            fName=fName.substring(fName.lastIndexOf("."),fName.length());
+           String extension=fName.toString();
+            fName=  DateUtils.formatDate(new Date(),"yyyyMMddHHmmss")+UUID.randomUUID().toString().replaceAll("-","")+fName;
+            // 获取文件的字节
+            byte[] bytes = file.getFile().getBytes();
+            String p ="";
+            String os = System.getProperty("os.name");
+            if (os.toLowerCase().startsWith("win")) {  //如果是Windows系统
+                log.info("win");
+                os=windowsFilePath +"\\";
+            }else{ //linux和mac系统
+                log.info("linux");
+                os=linuxFilePath+"/";
+            }
+
+
+            // 使用文件名在服务器端创建文件
+            java.nio.file.Path path = java.nio.file.Paths.get(os + fName);
+
+            // 写入文件到服务器的指定目录
+            java.nio.file.Files.write(path, bytes);
+            ZtFile f=new ZtFile();
+            f.setAddedby(RiskUserThreadLocal.get().getName());
+            f.setAddeddate(new Date());
+            f.setDeleted("0");
+            f.setExtension(extension);
+            f.setTitle(title);
+            f.setSize(bytes.length);
+            f.setPathname(baseUrl+"/zentao/img/"+fName);
+            f.setObjectid(file.getObjectId());
+            fileService.save(f);
+
+            return Result.success(f);
+        } catch (Exception e) {
+            throw new BusinessException("文件上传失败");
+        }
+    }
+
+    @PostMapping("/removeFile")
+    public Result removeFile(  UploadDTO file){
+        ZtFile ztFile = this.fileService.getById(file.getId());
+        if("1".equals(ztFile.getDeleted())){
+            throw new BusinessException("已删除");
+        }
+        ztFile.setDeleted("1");
+        this.fileService.updateById(ztFile);
+        return Result.success();
+    }
+
+    @PostMapping("/fileList")
+    public Result fileList(  UploadDTO file){
+        List<ZtFile> list = this.fileService.list(new QueryWrapper<ZtFile>().lambda().eq(ZtFile::getDeleted, "0")
+                .eq(ZtFile::getObjecttype, file.getObjectType()).eq(ZtFile::getObjectid, file.getObjectId()));
+
+
+        return Result.success(list);
+    }
+
+
+    @GetMapping("/test")
+    public Result<String> upload(){
+        downLoad("http://192.168.1.161:8088/file-download-1.html");
+        return Result.success();
+    }
+
+    public  String downLoad(String u){
+
+        String ext = u.substring(u.lastIndexOf(".") + 1).toLowerCase();
+        StringBuffer buffername = new StringBuffer(u.substring(u.lastIndexOf("/")+1));
+
+        URL url = null;
+        try {
+            url = new URL(u);
+            InputStream inputStream = url.openStream();
+
+//            byte[] buffer = new byte[1024];
+//            int len;
+            ByteArrayOutputStream outStream = new ByteArrayOutputStream();
+//            while ((len = inputStream.read(buffer)) != -1) {
+//                outStream.write(buffer, 0, len);
+//            }
+
+//            byte[] buffer = new byte[1024];
+//            int len;
+//            String path="/data/"+"202407/03103347085011a0";
+//            FileInputStream fileInputStream = new FileInputStream(path);
+//            while ((len = fileInputStream.read(buffer)) != -1) {
+//                outStream.write(buffer, 0, len);
+//            }
+//            fileInputStream.close();
+
+
+
+
+            // 获取文件名
+            String fName = "1.png";
             fName=fName.substring(fName.lastIndexOf("."),fName.length());
             fName=  DateUtils.formatDate(new Date(),"yyyyMMddHHmmss")+UUID.randomUUID().toString().replaceAll("-","")+fName;
             // 获取文件的字节
-            byte[] bytes = file.getBytes();
+            byte[] bytes = outStream.toByteArray();
             String p ="";
             String os = System.getProperty("os.name");
             if (os.toLowerCase().startsWith("win")) {  //如果是Windows系统
@@ -74,13 +185,20 @@ public class CommonsController {
             // 写入文件到服务器的指定目录
             java.nio.file.Files.write(path, bytes);
 
-            return Result.success(baseUrl+"/zentao/img/"+fName);
+            String fileAbsolutePath =baseUrl+"/zentao/img/"+fName;
+
+            System.out.print(fileAbsolutePath);
+
+
+            outStream.close();
+            inputStream.close();
+            return fileAbsolutePath;
         } catch (Exception e) {
-            throw new BusinessException("文件上传失败");
+            e.printStackTrace();
         }
+        return null;
     }
 
 
 
-
 }

src/main/java/com/sa/zentao/controller/ZtBugController.java

@@ -2,6 +2,7 @@ package com.sa.zentao.controller;
 
 
 import com.github.pagehelper.PageInfo;
+import com.sa.zentao.dao.BusinessException;
 import com.sa.zentao.dao.Result;
 import com.sa.zentao.dao.ZtBugDTO;
 import com.sa.zentao.dao.ZtCaseDTO;
@@ -78,12 +79,20 @@ public class ZtBugController {
         return Result.success(bugService.getById(qo.getId()));
     }
 
+    @RequestMapping(value = "/assignedTo", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
+    public Result assignedTo(@RequestBody ZtBugQo qo){
+        bugService.assignedTo(qo);
+        return Result.success();
+    }
+    //指派
     @RequestMapping(value = "/bugInfoById", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
     public Result bugInfoById(@RequestBody ZtBugQo qo){
-        return Result.success(bugService.bugInfoById(qo.getId()));
+        ZtBugDTO ztBugDTO = bugService.bugInfoById(qo.getId());
+
+        return Result.success(ztBugDTO);
     }
 
-
+    //完成
     @RequestMapping(value = "/resolved", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
     public Result resolved(@RequestBody ZtBugDTO dto){
         bugService.resolved(dto);

src/main/java/com/sa/zentao/controller/ZtCountController.java

@@ -2,14 +2,13 @@ package com.sa.zentao.controller;
 
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.sa.zentao.conf.RiskUserThreadLocal;
-import com.sa.zentao.dao.BusinessException;
+import com.sa.zentao.dao.*;
-import com.sa.zentao.dao.Result;
-import com.sa.zentao.dao.ZtCaseDTO;
 import com.sa.zentao.entity.ZtBug;
 import com.sa.zentao.entity.ZtProject;
 import com.sa.zentao.entity.ZtStory;
 import com.sa.zentao.entity.ZtTask;
 import com.sa.zentao.qo.ZtCountQo;
+import com.sa.zentao.qo.ZtProjectQo;
 import com.sa.zentao.service.IZtBugService;
 import com.sa.zentao.service.IZtProjectService;
 import com.sa.zentao.service.IZtStoryService;
@@ -104,12 +103,12 @@ public class ZtCountController {
     @RequestMapping(value = "/projectList", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
     public Result projectList(@RequestBody ZtCaseDTO dto){
 
-        List<ZtProject> project = projectService.list(new QueryWrapper<ZtProject>().lambda().eq(ZtProject::getType, "project")
+        List<ZtProject> project = projectService.list(new QueryWrapper<ZtProject>().lambda().eq(ZtProject::getType, "program")
-        .eq(ZtProject::getStatus,"doing")
+        .eq(ZtProject::getStatus,"doing").orderByDesc(ZtProject::getId)
         );
         return Result.success(project) ;
     }
-    //项目 任务 需求  等统计 项目统计
+    //项目 任务 需求  等统计 项目统计   24-12-13改为项目集统计
     @RequestMapping(value = "/projectInfoById", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
     public Result projectInfoById(@RequestBody ZtCaseDTO dto){
 
@@ -118,5 +117,46 @@ public class ZtCountController {
     }
 
 
+    //系统需求
 
+//    @RequestMapping(value = "/projectInfoById", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
+//    public Result storyFeedbackCount(@RequestBody ZtCaseDTO dto){
+//
+//        ZtStoryCountDTO result=countService.storyFeedbackCount(dto);
+//
+//        return Result.success(result) ;
+//    }
+
+
+    //我的需求列表
+    @RequestMapping(value = "/myStoryList", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
+    public Result<ZtStoryDTO> myStoryList(@RequestBody ZtProjectQo qo){
+        return Result.success(countService.myStoryList(qo));
+    }
+    //我的问题列表  产品   开发
+    @RequestMapping(value = "/myFeedbackList", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
+    public Result<ZtStoryFeedbackDTO> myFeedbackList(@RequestBody ZtProjectQo qo){
+        return Result.success(countService.ztStoryFeedbackDTO(qo));
+    }
+    //我的问题列表  产品   开发
+    @RequestMapping(value = "/myFeedbackPageList", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
+    public Result<ZtStoryFeedbackDTO> myFeedbackPageList(@RequestBody ZtProjectQo qo){
+        return Result.success(countService.myFeedbackPageList(qo));
+    }
+
+
+    //我的任务列表
+    @RequestMapping(value = "/myTaskList", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
+    public Result<ZtTaskDTO> myTaskList(@RequestBody ZtProjectQo qo){
+        return Result.success(countService.myTaskList(qo));
+    }
+    //运维任务列表
+    @RequestMapping(value = "/myYwList", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
+    public Result<ZtTaskDTO> myYwList(@RequestBody ZtProjectQo qo){
+        return Result.success(countService.myYwList(qo));
+    }
+    @RequestMapping(value = "/myDevops", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
+    public Result<ZtCronDevopsDTO> myDevops(@RequestBody ZtProjectQo qo){
+        return Result.success(countService.myDevops(qo));
+    }
 }

src/main/java/com/sa/zentao/controller/ZtFileController.java

@@ -0,0 +1,20 @@
+package com.sa.zentao.controller;
+
+
+import org.springframework.web.bind.annotation.RequestMapping;
+
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * <p>
+ *  前端控制器
+ * </p>
+ *
+ * @author gqb
+ * @since 2024-12-20
+ */
+@RestController
+@RequestMapping("/zt-file")
+public class ZtFileController {
+
+}

src/main/java/com/sa/zentao/controller/ZtNoticeController.java

@@ -0,0 +1,48 @@
+package com.sa.zentao.controller;
+
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.github.pagehelper.PageInfo;
+import com.sa.zentao.dao.Result;
+import com.sa.zentao.dao.ZtProjectDTO;
+import com.sa.zentao.entity.ZtNotice;
+import com.sa.zentao.qo.ZtProjectQo;
+import com.sa.zentao.service.IZtNoticeService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+
+/**
+ * <p>
+ *  前端控制器
+ * </p>
+ *
+ * @author gqb
+ * @since 2024-12-26
+ */
+@RestController
+@RequestMapping("/zt-notice")
+public class ZtNoticeController {
+
+    @Autowired
+    private IZtNoticeService noticeService;
+
+    //项目集
+    @RequestMapping(value = "/list", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
+    public Result<PageInfo<ZtProjectDTO>> pageList(@RequestBody ZtProjectQo qo){
+
+        List<ZtNotice> list = noticeService.list(new QueryWrapper<ZtNotice>().lambda()
+                .eq(ZtNotice::getFlag, 0).orderByDesc(ZtNotice::getId));
+
+
+        return Result.success(list);
+
+    }
+
+
+}

src/main/java/com/sa/zentao/controller/ZtProductController.java

@@ -91,6 +91,13 @@ public class ZtProductController {
         return Result.success();
 
     }
+
+    @RequestMapping(value = "/getById", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
+    public Result modifyProduct(@RequestBody ZtProjectQo qo){
+        return Result.success(this.ztProductService.getById(qo.getId()));
+
+    }
+
     @RequestMapping(value = "/getProductByProjectId", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
     public Result getProductByProjectId(@RequestBody ZtProductDTO dto){
         ZtProjectproduct project = projectproductService.getOne(new QueryWrapper<ZtProjectproduct>().lambda()

src/main/java/com/sa/zentao/controller/ZtProjectController.java

@@ -314,6 +314,14 @@ public class ZtProjectController {
         return Result.success(this.ztProjectService.projectTeamTimeWork(qo));
     }
 
+    //迭代列表根据项目
+    @RequestMapping(value = "/executionByProject", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
+    public Result executionByProject(@RequestBody ZtProjectQo qo){
+
+        List<ZtProject> pList = this.ztProjectService.execListByProject(qo.getProject());
+        return Result.success(pList);
+    }
+
 
 
 }

src/main/java/com/sa/zentao/controller/ZtReleaseController.java

@@ -0,0 +1,105 @@
+package com.sa.zentao.controller;
+
+
+import com.github.pagehelper.PageInfo;
+import com.sa.zentao.dao.Result;
+import com.sa.zentao.dao.ZtReleaseDTO;
+import com.sa.zentao.dao.ZtStoryDTO;
+import com.sa.zentao.dao.ZtTaskDTO;
+import com.sa.zentao.entity.ZtStory;
+import com.sa.zentao.qo.ZtProjectQo;
+import com.sa.zentao.qo.ZtReleaseQo;
+import com.sa.zentao.service.IZtReleaseService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+
+/**
+ * <p>
+ *  前端控制器
+ * </p>
+ *
+ * @author gqb
+ * @since 2024-12-26
+ */
+@RestController
+@RequestMapping("/zt-release")
+public class ZtReleaseController {
+
+    @Autowired
+    private IZtReleaseService releaseService;
+
+    @RequestMapping(value = "/addRelease", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
+    public Result addRelease(@RequestBody ZtReleaseDTO dto){
+        releaseService.addRelease(dto);
+        return Result.success();
+    }
+
+    @RequestMapping(value = "/modifyRelease", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
+    public Result modifyRelease(@RequestBody ZtReleaseDTO dto){
+        releaseService.modifyRelease(dto);
+        return Result.success();
+    }
+
+    @RequestMapping(value = "/pageList", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
+    public Result<ZtReleaseDTO> pageList(@RequestBody ZtReleaseQo qo){
+        return Result.success(releaseService.pageList(qo));
+    }
+
+    @RequestMapping(value = "/releaseStoryPageList", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
+    public Result<ZtReleaseDTO> releaseStoryPageList(@RequestBody ZtReleaseQo qo){
+        PageInfo<ZtStoryDTO> info=releaseService.releaseStoryPageList(qo);
+        return Result.success(info);
+    }
+
+    @RequestMapping(value = "/projectStoryPageList", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
+    public Result<ZtReleaseDTO> projectStoryPageList(@RequestBody ZtReleaseQo qo){
+        PageInfo<ZtStoryDTO> info=releaseService.projectStoryPageList(qo);
+        return Result.success(info);
+    }
+
+    @RequestMapping(value = "/removeStory", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
+    public Result<ZtReleaseDTO> removeStory(@RequestBody ZtReleaseQo qo){
+        releaseService.removeStory(qo);
+        return Result.success();
+    }
+    @RequestMapping(value = "/batchSyncStory", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
+    public Result<ZtReleaseDTO> batchSyncStory(@RequestBody ZtReleaseQo qo){
+        releaseService.batchSyncStory(qo);
+        return Result.success();
+    }
+
+
+    @RequestMapping(value = "/assignedTo", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
+    public Result assignedTo(@RequestBody ZtReleaseQo dto){
+        releaseService.assignedTo(dto);
+        return Result.success();
+    }
+
+    @RequestMapping(value = "/userReview", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
+    public Result userReview(@RequestBody ZtReleaseQo dto){
+        releaseService.userReview(dto);
+        return Result.success();
+    }
+
+
+    @RequestMapping(value = "/release", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
+    public Result release(@RequestBody ZtReleaseQo dto){
+        releaseService.release(dto);
+        return Result.success();
+    }
+
+    @RequestMapping(value = "/execMenu", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
+    public Result execMenu(@RequestBody ZtReleaseQo dto){
+        return Result.success(releaseService.execMenu(dto));
+    }
+
+
+
+
+}

src/main/java/com/sa/zentao/controller/ZtReleaseDetailsController.java

@@ -0,0 +1,20 @@
+package com.sa.zentao.controller;
+
+
+import org.springframework.web.bind.annotation.RequestMapping;
+
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * <p>
+ *  前端控制器
+ * </p>
+ *
+ * @author gqb
+ * @since 2024-12-26
+ */
+@RestController
+@RequestMapping("/zt-release-executions")
+public class ZtReleaseDetailsController {
+
+}

src/main/java/com/sa/zentao/controller/ZtStoryController.java

@@ -51,6 +51,14 @@ public class ZtStoryController {
 
     }
 
+    @RequestMapping(value = "/myStoryPageList", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
+    public Result<ZtStoryDTO> myStoryPageList(@RequestBody ZtProjectQo qo){
+
+        return Result.success(ztStoryService.myStoryPageList(qo));
+
+    }
+
+
     @RequestMapping(value = "/storyListByProject", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
     public Result<ZtStoryDTO> storyListByProject(@RequestBody ZtProjectQo qo){
         List<ZtStoryDTO> list=ztStoryService.storyListByProject(qo);
@@ -123,7 +131,12 @@ public class ZtStoryController {
         ztStoryService.addReview(dto);
         return Result.success();
     }
-
+    //添加备注
+    @RequestMapping(value = "/addRemark", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
+    public Result addRemark(@RequestBody ZtStoryDTO dto){
+        ztStoryService.addRemark(dto);
+        return Result.success();
+    }
     //评审
     @RequestMapping(value = "/userReview", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
     public Result userReview(@RequestBody ZtStoryDTO dto){

src/main/java/com/sa/zentao/controller/ZtStoryFeedbackController.java

@@ -65,5 +65,17 @@ public class ZtStoryFeedbackController {
         return Result.success(waitList);
     }
 
+    //指派
+    @RequestMapping(value = "/assignedTo", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
+    public Result assignedTo(@RequestBody ZtStoryDTO dto){
+        storyFeedbackService.assignedTo(dto);
+        return Result.success();
+    }
+    //开始处理
+    @RequestMapping(value = "/startHand", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
+    public Result startHand(@RequestBody ZtStoryDTO dto){
+        storyFeedbackService.startHand(dto);
+        return Result.success();
+    }
 
 }

src/main/java/com/sa/zentao/controller/ZtStoryUserController.java

@@ -8,6 +8,7 @@ import com.sa.zentao.dao.ZtStoryDTO;
 import com.sa.zentao.dao.ZtStoryUserDTO;
 import com.sa.zentao.entity.ZtStoryUser;
 import com.sa.zentao.qo.StoryQo;
+import com.sa.zentao.qo.ZtProjectQo;
 import com.sa.zentao.service.IZtStoryUserService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.RequestBody;
@@ -69,4 +70,17 @@ public class ZtStoryUserController {
         return Result.success(list);
     }
 
+    @RequestMapping(value = "/storyListByProductId", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
+    public Result<ZtStoryUserDTO> storyListByProductId(@RequestBody ZtProjectQo qo){
+        List<ZtStoryUserDTO> list=storyUserService.storyListByProductId(qo);
+        return Result.success(list);
+    }
+
+    //评审
+    @RequestMapping(value = "/userReview", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
+    public Result userReview(@RequestBody ZtStoryDTO dto){
+        storyUserService.userReview(dto);
+        return Result.success();
+    }
+
 }

src/main/java/com/sa/zentao/controller/ZtTaskController.java

@@ -1,22 +1,32 @@
 package com.sa.zentao.controller;
 
 
+import com.alibaba.excel.EasyExcel;
+import com.alibaba.excel.read.listener.PageReadListener;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.github.pagehelper.PageInfo;
-import com.sa.zentao.dao.Result;
+import com.sa.zentao.conf.ExcelListener;
-import com.sa.zentao.dao.ZtProjectDTO;
+import com.sa.zentao.conf.LoginRiskUser;
-import com.sa.zentao.dao.ZtTaskDTO;
+import com.sa.zentao.conf.RiskUserThreadLocal;
-import com.sa.zentao.entity.ZtTask;
+import com.sa.zentao.dao.*;
+import com.sa.zentao.entity.*;
 import com.sa.zentao.qo.ZtProjectQo;
-import com.sa.zentao.service.IZtTaskService;
+import com.sa.zentao.service.*;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.format.annotation.DateTimeFormat;
-import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.util.CollectionUtils;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
 
-import org.springframework.web.bind.annotation.RequestMethod;
+import javax.servlet.http.HttpServletRequest;
-import org.springframework.web.bind.annotation.RestController;
+import javax.servlet.http.HttpServletResponse;
-
+import java.math.BigDecimal;
-import java.util.List;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.*;
 
 /**
  * <p>
@@ -28,6 +38,7 @@ import java.util.List;
  */
 @RestController
 @RequestMapping("/zt-task")
+@Slf4j
 public class ZtTaskController {
 
     @Autowired
@@ -39,18 +50,43 @@ public class ZtTaskController {
         return Result.success(ztTaskService.taskPageList(qo));
     }
 
+    @RequestMapping(value = "/myTaskPageList", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
+    public Result<PageInfo<ZtTaskDTO>> myTaskPageList(@RequestBody ZtProjectQo qo){
+
+        return Result.success(ztTaskService.myTaskPageList(qo));
+    }
+
+
     @RequestMapping(value = "/addTask", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
     public Result addTask(@RequestBody ZtTaskDTO dto){
         ztTaskService.addTask(dto);
         return Result.success();
     }
 
+    @RequestMapping(value = "/assignedTo", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
+    public Result assignedTo(@RequestBody ZtTaskDTO dto){
+        ztTaskService.assignedTo(dto);
+        return Result.success();
+    }
+
     @RequestMapping(value = "/batchAddTask", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
     public Result batchAddTask(@RequestBody ZtTaskDTO dto){
         ztTaskService.batchAddTask(dto);
         return Result.success();
     }
 
+    @RequestMapping(value = "/approval", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
+    public Result approval(@RequestBody ZtTaskDTO dto){
+        ztTaskService.approval(dto);
+        return Result.success();
+    }
+
+    @RequestMapping(value = "/batchApproval", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
+    public Result batchApproval(@RequestBody ZtTaskDTO dto){
+        ztTaskService.batchApproval(dto);
+        return Result.success();
+    }
+
     @RequestMapping(value = "/modifyTask", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
     public Result modifyTask(@RequestBody ZtTaskDTO dto){
         ztTaskService.modifyTask(dto);
@@ -75,7 +111,12 @@ public class ZtTaskController {
         ztTaskService.closeTask(dto);
         return Result.success();
     }
-
+    //添加备注
+    @RequestMapping(value = "/addRemark", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
+    public Result addRemark(@RequestBody ZtTaskDTO dto){
+        ztTaskService.addRemark(dto);
+        return Result.success();
+    }
     //取消任务
     @RequestMapping(value = "/cancelTask", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
     public Result cancelTask(@RequestBody ZtTaskDTO dto){
@@ -93,7 +134,9 @@ public class ZtTaskController {
     //获取Task根据id
     @RequestMapping(value = "/getTaskById", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
     public Result getTaskById(@RequestBody ZtTaskDTO dto){
-        return Result.success(ztTaskService.getById(dto.getId()));
+        ZtTaskDTO task=ztTaskService.getTaskById(dto.getId());
+        return Result.success(task);
+
     }
 
 
@@ -105,7 +148,354 @@ public class ZtTaskController {
         //   需求关联的迭代
         List<ZtTask> list = this.ztTaskService.list(new QueryWrapper<ZtTask>().lambda().eq(ZtTask::getStory, dto.getStory()));
 
+        Map<String, ZtUser> userMap = this.userService.userMapByIds(null);
+        for (ZtTask t:list) {
+            ZtUser ztUser = userMap.get(t.getAssignedTo());
+            if(ztUser!=null){
+                t.setAssignedTo(ztUser.getNickname());
+            }
+        }
+
+
         return Result.success(list);
     }
 
+    @Autowired
+    private IZtProjectService projectService;
+    @Autowired
+    private IZtStoryService  storyService;
+    @Autowired
+    private IZtUserService userService;
+    @Autowired
+    private IZtProjectstoryService projectstoryService;
+    @Autowired
+    private IZtKanbanlaneService kanbanlaneService;
+
+
+    @RequestMapping(value = "/uploadTask", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
+    public Result humanAffairsUploadFile(MultipartFile file) throws Exception {
+        SimpleDateFormat f=new SimpleDateFormat("yyyy/MM/dd");
+        EasyExcel.read(file.getInputStream(), ZtTaskImportDTO.class, new PageReadListener<ZtTaskImportDTO>(dataList -> {
+            int i=0;
+            for (ZtTaskImportDTO dto:dataList) {
+                i+=1;
+                ZtProject sprint = projectService.getOne(new QueryWrapper<ZtProject>().lambda()
+                        .eq(ZtProject::getType, "sprint").eq(ZtProject::getName, dto.getExecName()));
+                if(sprint==null){
+                    log.error("未查询到{}",dto.getExecName());
+                }
+                ZtStory story = this.storyService.getOne(new QueryWrapper<ZtStory>().lambda().eq(ZtStory::getTitle, dto.getStoryName()));
+                if(sprint==null){
+                    log.error("未查询到{}",dto.getStoryName());
+                }
+                ZtUser user = this.userService.getOne(new QueryWrapper<ZtUser>().lambda().eq(ZtUser::getNickname, dto.getAssignedName()));
+                if(user==null){
+                    log.error("未查询到{}",dto.getAssignedName());
+                }
+                String start = dto.getStart();
+
+                String end = dto.getEnd();
+
+                ZtProjectstory pStory = projectstoryService.getOne(new QueryWrapper<ZtProjectstory>().lambda().
+                        eq(ZtProjectstory::getStory, story.getId()).ne(ZtProjectstory::getProject,0));
+
+
+
+                ZtTask task=new ZtTask();
+                try {
+                    Date parse = f.parse(start);
+                    task.setEstStarted(parse);
+                    Date endDate = f.parse(end);
+                    task.setDeadline(endDate);
+                } catch (Exception e) {
+//                    e.printStackTrace();
+                    if(task.getEstStarted()==null){
+                        task.setEstStarted(new Date());
+                    }
+                    if(task.getDeadline()==null){
+                        task.setDeadline(new Date());
+                    }
+                }
+                task.setOpenedby("liyuyan");
+                task.setOpeneddate(new Date());
+                task.setProject(pStory.getProject());
+                task.setExecution(sprint.getId());
+                task.setStory(story.getId());
+                task.setAssignedTo(user.getAccount());
+                task.setStatus("wait");
+                task.setName(dto.getTaskName());
+                log.error("getConsumed,{} ,index {}",dto.getConsumed(),i);
+                try {
+                    task.setEstimate(Float.valueOf(dto.getConsumed()));
+                    task.setLeft(Float.valueOf(dto.getConsumed()));
+                }catch (Exception e){
+                    task.setEstimate(0F);
+                    task.setLeft(0F);
+//                    log.error("",e);
+                }
+                ZtTaskDTO ztTaskDTO = new ZtTaskDTO();
+
+                BeanUtils.copyProperties(task,ztTaskDTO);
+                LoginRiskUser u=new LoginRiskUser();
+                u.setName("liyuyan");
+                RiskUserThreadLocal.set(u);
+                ztTaskService.save(task);
+
+//                estStarted deadline
+
+                kanbanlaneService.addTask( task.getExecution(), Arrays.asList(task));
+
+
+            }
+
+        },600)).sheet().doRead();
+
+        return Result.success();
+    }
+
+
+
+
+    @Autowired
+    private com.sa.zentao.service.IZtStoryService IZtStoryService;
+
+
+    @Autowired
+    private IZtExecutionprojectService executionprojectService;
+
+    @Autowired
+    private IZtProjectproductService projectproductService;
+
+
+    @Autowired
+    private IZtStoryspecService storyspecService;
+
+
+    //同步中道
+    @RequestMapping(value = "/syncZdStory", method = RequestMethod.GET, produces = "application/json; charset=UTF-8")
+    public Result syncZdStory(@RequestParam("implementName")String implementName){
+
+
+        if(StringUtils.isEmpty(implementName)){
+            return Result.success();
+        }
+        List<ZtProject> list1 = this.projectService.list(new QueryWrapper<ZtProject>().lambda().eq(ZtProject::getName, implementName));
+        if(CollectionUtils.isEmpty(list1)){
+            throw new BusinessException("未查询到");
+        }
+        ZtProject sprint = this.projectService.getOne(new QueryWrapper<ZtProject>().lambda().eq(ZtProject::getName, implementName)
+                .eq(ZtProject::getType, "sprint"));
+
+        ZtProjectDTO d=projectService.selectPrdByName(implementName);
+        if(d!=null){
+            //执行id
+            Integer id = d.getId();
+            List<ZtProjectstory> ztProjectstories = projectstoryService.storyListPrd(id);
+            for (ZtProjectstory story:ztProjectstories) {
+                //老的
+                ZtStory oldStory=storyService.getPrdById(story.getStory());
+                if(oldStory==null){
+                    continue;
+                }
+                List<ZtStoryspec> listSpec = storyspecService.getPrdById(oldStory.getId());
+
+                ZtStory newStory = storyService.getById(oldStory.getId());
+                if(newStory!=null){
+                    continue;
+                }
+                if(!CollectionUtils.isEmpty(listSpec)){
+                    ZtStoryspec ztStoryspec = listSpec.get(0);
+                    ztStoryspec.setFiles(null);
+                    storyspecService.save(ztStoryspec);
+                }
+
+                List<String> userList=new ArrayList();
+
+
+                String openedby = oldStory.getOpenedby();
+                if(!StringUtils.isEmpty(openedby)){
+                    String[] split = openedby.split(",");
+                    for (String sName:split) {
+                        if(!StringUtils.isEmpty(sName)){
+                            if("closed".equals(sName)){
+                                continue;
+                            }
+                            userList.add(sName);
+                        }
+                    }
+                }
+
+
+                String assignedTo = oldStory.getAssignedTo();
+                if(!StringUtils.isEmpty(assignedTo)){
+                    String[] split = assignedTo.split(",");
+                    for (String sName:split) {
+                        if(!StringUtils.isEmpty(sName)){
+                            if("closed".equals(sName)){
+                                continue;
+                            }
+                            userList.add(sName);
+                        }
+                    }
+                }
+
+
+                String lasteditedby = oldStory.getLasteditedby();
+                if(!StringUtils.isEmpty(lasteditedby)){
+                    String[] split = lasteditedby.split(",");
+                    for (String sName:split) {
+                        if(!StringUtils.isEmpty(sName)){
+                            if("closed".equals(sName)){
+                                continue;
+                            }
+                            userList.add(sName);
+                        }
+                    }
+                }
+                String reviewedby = oldStory.getReviewedby();
+                if(!StringUtils.isEmpty(reviewedby)){
+                    String[] split = reviewedby.split(",");
+                    for (String sName:split) {
+
+                        if(!StringUtils.isEmpty(sName)){
+                            if("closed".equals(sName)){
+                                continue;
+                            }
+                            userList.add(sName);
+                        }
+                    }
+                }
+                for (String uName:userList) {
+                    ZtUser ztUser = this.userService.selectByName(uName);
+                    if(ztUser==null){
+                        if("closed".equals(uName)){
+                            continue;
+                        }
+                        ZtUser u =   this.userService.selectPrdByName(uName);
+                        u.setId(null);
+                        u.setNickname(u.getRealname());
+                        userService.save(u);
+                    }
+                }
+
+                //新的执行id
+                Integer id1 = sprint.getId();
+                //执行关联的项目 id
+                List<ZtExecutionproject> list = executionprojectService.list(new QueryWrapper<ZtExecutionproject>().lambda()
+                        .eq(ZtExecutionproject::getExecution, id1));
+                Integer project = list.get(0).getProject();
+                //产品id
+                ZtProjectproduct projectproduct = projectproductService.getOne(new QueryWrapper<ZtProjectproduct>()
+                        .lambda().eq(ZtProjectproduct::getProject, project));
+                Integer product = projectproduct.getProduct();
+
+
+
+
+                //创建新的需求
+                oldStory.setProduct(product);
+                oldStory.setStage("wait");
+                oldStory.setStatus("active");
+                storyService.save(oldStory);
+                //项目关联需求
+                ZtProjectDTO dto=new ZtProjectDTO();
+                dto.setStoryIds(new ArrayList<>(){
+                    {
+                        add(oldStory.getId());
+                    }
+                });
+                dto.setProject(project);
+                this.projectService.projectSyncStory(dto);
+                dto.setExcludeId(id1);
+                this.projectService.executionSyncStory(dto);
+
+
+
+
+            }
+
+        }
+
+        return Result.success();
+    }
+
+
+
+    //同步中道
+    @RequestMapping(value = "/test", method = RequestMethod.GET, produces = "application/json; charset=UTF-8")
+    public Result test(@RequestParam("implementName")String implementName){
+
+
+        if(StringUtils.isEmpty(implementName)){
+            return Result.success();
+        }
+        List<ZtProject> list1 = this.projectService.list(new QueryWrapper<ZtProject>().lambda().eq(ZtProject::getName, implementName));
+        if(CollectionUtils.isEmpty(list1)){
+            throw new BusinessException("未查询到");
+        }
+        ZtProject sprint = this.projectService.getOne(new QueryWrapper<ZtProject>().lambda().eq(ZtProject::getName, implementName)
+                .eq(ZtProject::getType, "sprint"));
+
+        ZtProjectDTO d=projectService.selectPrdByName(implementName);
+        if(d!=null){
+            //执行id
+            Integer id = d.getId();
+            List<ZtProjectstory> ztProjectstories = projectstoryService.storyListPrd(id);
+            for (ZtProjectstory story:ztProjectstories) {
+                //老的
+                ZtStory oldStory=storyService.getPrdById(story.getStory());
+                if(oldStory==null){
+                    continue;
+                }
+                List<ZtStoryspec> listSpec = storyspecService.getPrdById(oldStory.getId());
+
+                ZtStory newStory = storyService.getById(oldStory.getId());
+                if(!CollectionUtils.isEmpty(listSpec)){
+                    ZtStoryspec ztStoryspec = listSpec.get(0);
+                    ztStoryspec.setFiles(null);
+                    storyspecService.save(ztStoryspec);
+                }
+                newStory.setOpenedby(oldStory.getOpenedby());
+                storyService.updateById(newStory);
+
+
+                List<String> userList=new ArrayList();
+
+
+                String openedby = oldStory.getOpenedby();
+                if(!StringUtils.isEmpty(openedby)){
+                    String[] split = openedby.split(",");
+                    for (String sName:split) {
+                        if(!StringUtils.isEmpty(sName)){
+                            if("closed".equals(sName)){
+                                continue;
+                            }
+                            userList.add(sName);
+                        }
+                    }
+                }
+
+
+                for (String uName:userList) {
+                    ZtUser ztUser = this.userService.selectByName(uName);
+                    if(ztUser==null){
+                        if("closed".equals(uName)){
+                            continue;
+                        }
+                        ZtUser u =   this.userService.selectPrdByName(uName);
+                        u.setId(null);
+                        u.setNickname(u.getRealname());
+                        userService.save(u);
+                    }
+                }
+
+
+
+            }
+
+        }
+
+        return Result.success();
+    }
+
 }

src/main/java/com/sa/zentao/controller/ZtUserController.java

@@ -1,6 +1,7 @@
 package com.sa.zentao.controller;
 
 
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
 import com.github.pagehelper.PageInfo;
@@ -12,9 +13,11 @@ import com.sa.zentao.dao.ZtUserDTO;
 import com.sa.zentao.entity.ZtUser;
 import com.sa.zentao.enums.ActionStatus;
 import com.sa.zentao.enums.ActionType;
+import com.sa.zentao.mapper.ZtUserMapper;
 import com.sa.zentao.qo.ZtUserQo;
 import com.sa.zentao.service.IZtActionService;
 import com.sa.zentao.service.IZtUserService;
+import com.sa.zentao.utils.ChineseUtil;
 import com.sa.zentao.utils.JwtUtil;
 import com.tencentcloudapi.common.Credential;
 import com.tencentcloudapi.common.exception.TencentCloudSDKException;
@@ -52,12 +55,30 @@ public class ZtUserController {
     @Autowired
     private IZtActionService actionService;
 
+    @Autowired
+    private ZtUserMapper userMapper;
+
+    @RequestMapping(value = "/allList", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
+    public Result allList(@RequestBody ZtUser user){
+        List<ZtUserDTO> ztUserDTOS = userMapper.listAll(null);
+
+
+        return Result.success();
+    }
+
 
 
     @RequestMapping(value = "/userList", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
     public Result<List<ZtUser>> userList(@RequestBody ZtProjectDTO dto){
-        return Result.success(userService.list(new QueryWrapper<ZtUser>()
+        LambdaQueryWrapper<ZtUser> eq = new QueryWrapper<ZtUser>()
-                .lambda().eq(ZtUser::getDeleted,"0")
+                .lambda().eq(ZtUser::getDeleted, "0");
+        if(!StringUtils.isEmpty(dto.getName())){
+            eq.like(ZtUser::getAccount,dto.getName())
+            .or().like(ZtUser::getNickname,dto.getName())
+                    .or().like(ZtUser::getPinyin,dto.getName())
+            ;
+        }
+        return Result.success(userService.list(eq
         ));
     }
 
@@ -109,7 +130,7 @@ public class ZtUserController {
             ztUser.setProductIds(StringUtils.join(productList,","));
         }
 
-
+        ztUser.setPinyin(ChineseUtil.getFirst(ztUser.getNickname()));
 
         this.userService.save(ztUser);
         this.actionService.addAction(ActionType.USER, ActionStatus.XJ,ztUser.getId(),null,null,null, RiskUserThreadLocal.get().getName(),null,ztUser.getAccount());
@@ -132,7 +153,9 @@ public class ZtUserController {
         if(!CollectionUtils.isEmpty(list)){
             throw new BusinessException("请检查用户");
         }
-
+        if(!ztUser.getNickname().equals(user.getNickname())){
+            ztUser.setPinyin(ChineseUtil.getFirst(ztUser.getNickname()));
+        }
         ztUser.setAccount(user.getAccount());
 
         ztUser.setPassword(user.getPassword());

src/main/java/com/sa/zentao/dao/ProjectWorkTaskDTO.java

@@ -0,0 +1,66 @@
+package com.sa.zentao.dao;
+
+import com.alibaba.excel.annotation.ExcelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import java.io.Serializable;
+import java.math.BigDecimal;
+
+@Data
+@EqualsAndHashCode(callSuper = false)
+public class ProjectWorkTaskDTO implements Serializable {
+
+
+
+    @ExcelProperty(value = "任务id",index =0)
+    private Integer taskId;
+    //完成需求总量
+    @ExcelProperty(value = "需求id",index =1)
+    private Integer storyId;
+    //迭代
+    @ExcelProperty(value = "冲刺",index =2)
+    private String execName;
+    //冲刺开始时间
+    @ExcelProperty(value = "冲刺开始时间",index =3)
+    private String execStartDate;
+    //冲刺结束时间
+    @ExcelProperty(value = "冲刺结束时间",index =4)
+    private String execEndDate;
+    //上月剩余未完成需求量
+
+    //已验收需求总量
+    @ExcelProperty(value = "需求",index =5)
+    private String storyName;
+    //验收通过率
+    @ExcelProperty(value = "任务名称",index =6)
+    private String taskName;
+    //验收不通过数量
+    @ExcelProperty(value = "任务类型",index =7)
+    private String typeName;
+    //指派人
+    @ExcelProperty(value = "指派人",index =8)
+    private String assignedTo;
+
+    @ExcelProperty(value = "产出工时",index =9)
+    private float workTime;
+
+    @ExcelProperty(value = "预估工时",index =10)
+    private float planTime;
+
+    @ExcelProperty(value = "剩余工时",index =11)
+    private float balanceTime;
+    //状态
+    @ExcelProperty(value = "状态",index =12)
+    private String status;
+
+    @ExcelProperty(value = "任务开始时间",index =13)
+    private String startDate;
+
+    @ExcelProperty(value = "任务结束时间",index =14)
+    private String endDate;
+
+    @ExcelProperty(value = "持续日期",index =15)
+    private Integer keepTime;
+
+}

src/main/java/com/sa/zentao/dao/UploadDTO.java

@@ -0,0 +1,28 @@
+package com.sa.zentao.dao;
+
+import com.alibaba.excel.annotation.ExcelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.springframework.web.multipart.MultipartFile;
+
+import java.io.Serializable;
+
+@Data
+@EqualsAndHashCode(callSuper = false)
+public class UploadDTO implements Serializable {
+
+    private Integer id;
+
+    private MultipartFile file;
+
+    private String url;
+
+    private String title;
+
+    private String objectType;
+
+    private Integer objectId;
+
+
+
+}

src/main/java/com/sa/zentao/dao/ZtBugDTO.java

@@ -112,8 +112,8 @@ public class ZtBugDTO implements Serializable {
     private String openedbuild;
 
     @TableField("assignedTo")
-    private String assignedto;
+    private String assignedTo;
-    private String assignedtoName;
+    private String assignedToName;
     @TableField("assignedDate")
     private Date assigneddate;
 
@@ -190,4 +190,6 @@ public class ZtBugDTO implements Serializable {
     private ZtStory ztStory;
 
     private ZtTask ztTask;
+
+    private String files;
 }

src/main/java/com/sa/zentao/dao/ZtCasestepDTO.java

@@ -40,4 +40,6 @@ public class ZtCasestepDTO implements Serializable {
     private Integer status;
 
     private String caseResult;
+
+    private String remark;
 }

src/main/java/com/sa/zentao/dao/ZtReleaseDTO.java

@@ -0,0 +1,101 @@
+package com.sa.zentao.dao;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.sa.zentao.entity.ZtReleaseDetails;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import java.io.Serializable;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.util.Date;
+import java.util.List;
+
+/**
+ * <p>
+ * 
+ * </p>
+ *
+ * @author gqb
+ * @since 2024-12-26
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+public class ZtReleaseDTO implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    @TableId(value = "id", type = IdType.AUTO)
+    private Integer id;
+
+    private String project;
+
+    private Integer product;
+
+    private String branch;
+
+    private Integer shadow;
+
+    private String build;
+
+    private String name;
+
+    private String marker;
+
+    private Date date;
+
+    private String stories;
+
+    private String bugs;
+
+    @TableField("leftBugs")
+    private String leftbugs;
+
+    private String desc;
+
+    private String mailto;
+
+    private String notify;
+    //    //reviewing待评审
+    //    //waitRelease 待发布
+    //    //released 发不成功
+    //    //closed 发布失败
+    private String status;
+
+    @TableField("subStatus")
+    private String substatus;
+
+    @TableField("createdBy")
+    private String createdby;
+
+    @TableField("createdDate")
+    private Date createddate;
+
+    private String deleted;
+
+    private String executions;
+
+    private String executionsName;
+    private String level;
+
+    //风险评估
+    private String danger;
+
+    private String  assignedTo;
+
+    private String  assignedToName;
+
+    private Date releaseDate;
+
+    private String  noticeTitle;
+
+    private String  noticeContent;
+
+    private String failRemark;
+
+    private String releaseFailRemark;
+
+    private List<ZtReleaseDetailsDTO> details;
+}

src/main/java/com/sa/zentao/dao/ZtReleaseDetailsDTO.java

@@ -0,0 +1,36 @@
+package com.sa.zentao.dao;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import java.io.Serializable;
+
+/**
+ * <p>
+ * 
+ * </p>
+ *
+ * @author gqb
+ * @since 2024-12-26
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+public class ZtReleaseDetailsDTO implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    @TableId(value = "id", type = IdType.AUTO)
+    private Integer id;
+
+    private Integer releaseId;
+
+    private Integer objectId;
+
+    private String objectType;
+    //  released已发布 closed 关闭
+    private String status;
+
+
+}

src/main/java/com/sa/zentao/dao/ZtStoryCountDTO.java

@@ -24,24 +24,42 @@ import java.util.List;
 public class ZtStoryCountDTO implements Serializable {
 
     //待评审
-    private BigDecimal dpsCount;
+    private String dpsCount;
 
-    //评审通过
+    //评审通过   未开始的
-    private BigDecimal pstgCount;
+    private String pstgCount;
+
+    //计划中
+    private String planCount;
+
+
+    //进行中  研发中心
+    private String jxzCount;
+
+    //测试中
+    private String testingCount;
 
-    //进行中
-    private BigDecimal jxzCount;
     //延期
-    private BigDecimal yqCount;
+    private String yqCount;
     //测试完毕
-    private BigDecimal cswbCount;
+    private String cswbCount;
     //上线待验收
-    private BigDecimal dysCount;
+    private String dysCount;
     //验收不通过
-    private BigDecimal ysNoCount;
+    private String ysNoCount;
     //验收通过
-    private BigDecimal ysYesCount;
+    private String ysYesCount;
 
     //bug量
-    private BigDecimal bugCount;
+    private String bugCount;
+
+
+    //问题反馈 未受理
+    private String feedbackWslCount;
+    //处理中的
+    private String feedbackClzCount;
+    //处理完的
+    private String feedbackClwCount;
+    //延期的
+    private String feedbackYqCount;
 }

src/main/java/com/sa/zentao/dao/ZtStoryDTO.java

@@ -37,6 +37,14 @@ public class ZtStoryDTO implements Serializable {
     private Integer parent;
 
     private Integer product;
+    private Integer productId;
+
+    private String   productName;
+    private String projectName;
+    private Integer projectId;
+
+    private String  implementName;
+    private Integer   implementId;
 
     private Integer branch;
 
@@ -232,4 +240,13 @@ public class ZtStoryDTO implements Serializable {
     private Integer feedbackId;
 
     private Integer userStory;
+
+    private String ysRemark;
+    //验收人
+    private String ysUser;
+
+    private Integer taskCount;
+
+    private Integer releaseFlag=0;
+
 }

src/main/java/com/sa/zentao/dao/ZtStoryFeedbackDTO.java

@@ -65,7 +65,7 @@ public class ZtStoryFeedbackDTO implements Serializable {
 
     private String spec;
 
-    // wait  finish close
+    // wait  finished closed
     private String status;
 
     private String fileUrl;
@@ -75,4 +75,13 @@ public class ZtStoryFeedbackDTO implements Serializable {
     private String closeRemark;
 
     private Integer product;
+    //预计完成时间
+    private  Date planFinishDate;
+
+
+    private Date finishDate;
+    //响应时间  处理时间
+    private Date handDate;
+    //关闭日期
+    private Date closeDate;
 }

src/main/java/com/sa/zentao/dao/ZtStoryUserDTO.java

@@ -10,6 +10,7 @@ import java.io.Serializable;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.util.Date;
+import java.util.List;
 
 /**
  * <p>
@@ -200,4 +201,12 @@ public class ZtStoryUserDTO implements Serializable {
     private String remark;
 
     private String storyList;
+
+    private List<String> userViewId;
+
+    private List<ZtStoryreviewDTO> views;
+
+    private String revieweUser;
+
+    private String files;
 }

src/main/java/com/sa/zentao/dao/ZtTaskDTO.java

@@ -29,6 +29,12 @@ public class ZtTaskDTO implements Serializable {
     @TableId(value = "id", type = IdType.AUTO)
     private Integer id;
 
+    //审批状态  0待审批  1审批通过  2拒绝
+    private Integer approvalStatus;
+    //审核拒绝原因
+    private String approvalRemark;
+
+
     private Integer project;
 
     private Integer parent;
@@ -171,5 +177,16 @@ public class ZtTaskDTO implements Serializable {
 
     private String files;
 
+    private String reviewingUser;
+
     private List<ZtTaskDTO> list;
+
+    private List<Integer> idList;
+
+    private Long deadlineTime;
+
+    //0 否 1 是
+    private Integer finishedFlag=0;
+    private String implementName;
+    private Integer  implementId;
 }

src/main/java/com/sa/zentao/dao/ZtTaskImportDTO.java

@@ -0,0 +1,52 @@
+package com.sa.zentao.dao;
+
+import com.alibaba.excel.annotation.ExcelProperty;
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import java.io.Serializable;
+import java.util.Date;
+import java.util.List;
+
+/**
+ * <p>
+ * 
+ * </p>
+ *
+ * @author gqb
+ * @since 2024-06-25
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+public class ZtTaskImportDTO implements Serializable {
+
+    /**
+     * 	员工id
+     */
+    @ExcelProperty(value = "执行",index = 0)
+    private String execName;
+    /**
+     * 	员工姓名
+     */
+    @ExcelProperty(value = "需求名称",index = 1)
+    private String storyName;
+
+    @ExcelProperty(value = "任务名称",index = 2)
+    private String taskName;
+
+    @ExcelProperty(value = "指派",index = 3)
+    private String assignedName;
+
+    @ExcelProperty(value = "消耗",index = 4)
+    private String consumed;
+//    estStarted deadline
+
+    @ExcelProperty(value = "开始",index = 5)
+    private String start;
+
+    @ExcelProperty(value = "结束",index = 6)
+    private String end;
+}

src/main/java/com/sa/zentao/dao/ZtUserDTO.java

@@ -130,4 +130,6 @@ public class ZtUserDTO implements Serializable {
     private String productIds;
     private String productNames;
 
+    private String color;
+
 }

src/main/java/com/sa/zentao/entity/VerificationCode.java

@@ -41,4 +41,5 @@ public class VerificationCode implements Serializable {
     private LocalDateTime expirationTime;
 
 
+
 }

src/main/java/com/sa/zentao/entity/ZtBug.java

@@ -85,7 +85,10 @@ public class ZtBug implements Serializable {
 //    testing
 //            tested
 //    closed
+    // ZtBug 已完成
     //1.active     2.confire=1   3.解决进行中 不变  4 resolved 完成  5.测试中不变  6.测试完毕不变
+    // 'active','resolved','closed'?
+    // active 激活
     @TableField("`status`")
     private String status;
 
@@ -120,7 +123,7 @@ public class ZtBug implements Serializable {
     private String openedbuild;
 
     @TableField("assignedTo")
-    private String assignedto;
+    private String assignedTo;
 
     @TableField("assignedDate")
     private Date assigneddate;

src/main/java/com/sa/zentao/entity/ZtFile.java

@@ -0,0 +1,58 @@
+package com.sa.zentao.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import java.time.LocalDateTime;
+import com.baomidou.mybatisplus.annotation.TableField;
+import java.io.Serializable;
+import java.util.Date;
+
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+/**
+ * <p>
+ * 
+ * </p>
+ *
+ * @author gqb
+ * @since 2024-12-20
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+public class ZtFile implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    @TableId(value = "id", type = IdType.AUTO)
+    private Integer id;
+
+    private String pathname;
+
+    //文件名
+    private String title;
+    //后缀
+    private String extension;
+
+    private Integer size;
+
+    @TableField("objectType")
+    private String objecttype;
+
+    @TableField("objectID")
+    private Integer objectid;
+
+    @TableField("addedBy")
+    private String addedby;
+
+    @TableField("addedDate")
+    private Date addeddate;
+
+    private Integer downloads;
+
+    private String extra;
+    //正常0  1删除
+    private String deleted;
+
+
+}

src/main/java/com/sa/zentao/entity/ZtNotice.java

@@ -0,0 +1,49 @@
+package com.sa.zentao.entity;
+
+import java.time.LocalDateTime;
+import java.io.Serializable;
+import java.util.Date;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+/**
+ * <p>
+ * 
+ * </p>
+ *
+ * @author gqb
+ * @since 2024-12-26
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+public class ZtNotice implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+    @TableId(value = "id", type = IdType.AUTO)
+    private Integer id;
+
+    private String name;
+
+    private String remark;
+
+    private String title;
+
+    private Date createDate;
+
+    private String createUser;
+
+    /**
+     * 最后生效日期
+     */
+    private Date loseDate;
+
+    private String objectType;
+
+    private Integer objectId;
+    // 0 正常  1 失效
+    private Integer flag;
+
+}

src/main/java/com/sa/zentao/entity/ZtRelease.java

@@ -0,0 +1,95 @@
+package com.sa.zentao.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import java.time.LocalDate;
+import com.baomidou.mybatisplus.annotation.TableId;
+import java.time.LocalDateTime;
+import com.baomidou.mybatisplus.annotation.TableField;
+import java.io.Serializable;
+import java.util.Date;
+
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+/**
+ * <p>
+ * 
+ * </p>
+ *
+ * @author gqb
+ * @since 2024-12-26
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+public class ZtRelease implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    @TableId(value = "id", type = IdType.AUTO)
+    private Integer id;
+
+    private String project;
+
+    private Integer product;
+
+    private String branch;
+
+    private Integer shadow;
+
+    private String build;
+    @TableField("`name`")
+    private String name;
+
+    private String marker;
+
+    private Date date;
+
+    private String stories;
+
+    private String bugs;
+
+    @TableField("leftBugs")
+    private String leftbugs;
+    @TableField("`desc`")
+    private String desc;
+
+    private String mailto;
+
+    private String notify;
+    //reviewing待评审
+    //waitRelease 待发布
+    //released 发不成功
+    //close 发布失败
+    @TableField("`status`")
+    private String status;
+
+    @TableField("subStatus")
+    private String substatus;
+
+    @TableField("createdBy")
+    private String createdby;
+
+    @TableField("createdDate")
+    private Date createddate;
+
+    private String deleted;
+
+    private String executions;
+    @TableField("`level`")
+    private String level;
+
+    private String danger;
+
+    private String  assignedTo;
+
+    private Date releaseDate;
+
+    private String  noticeTitle;
+
+    private String  noticeContent;
+
+
+    private String failRemark;
+
+    private String releaseFailRemark;
+}

src/main/java/com/sa/zentao/entity/ZtReleaseDetails.java

@@ -0,0 +1,36 @@
+package com.sa.zentao.entity;
+
+import java.io.Serializable;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+/**
+ * <p>
+ * 
+ * </p>
+ *
+ * @author gqb
+ * @since 2024-12-26
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+public class ZtReleaseDetails implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    @TableId(value = "id", type = IdType.AUTO)
+    private Integer id;
+
+    private Integer releaseId;
+
+    private Integer objectId;
+
+    private String objectType;
+    //  released已发布 closed 关闭
+    private String status;
+
+
+}

src/main/java/com/sa/zentao/entity/ZtStory.java

@@ -192,5 +192,11 @@ public class ZtStory implements Serializable {
     //1通过 2不通过
     private Integer ysFlag;
 
+    private String ysRemark;
+
     private Integer userStory;
+
+    private String ysUser;
+
+    private Integer taskCount;
 }

src/main/java/com/sa/zentao/entity/ZtStoryFeedback.java

@@ -64,10 +64,10 @@ public class ZtStoryFeedback implements Serializable {
     private String  assignedTo;
 
     private String spec;
-    // wait  doing finish closed
+    // wait  doing finished closed
+
     private String status;
 
-    private Integer finishDate;
 
     private String fileUrl;
 
@@ -77,4 +77,13 @@ public class ZtStoryFeedback implements Serializable {
     private String closeRemark;
 
     private Integer product;
+
+    //预计完成时间
+    private  Date planFinishDate;
+
+    private Date finishDate;
+    //响应时间  处理时间
+    private Date handDate;
+    //关闭日期
+    private Date closeDate;
 }

src/main/java/com/sa/zentao/entity/ZtStoryUser.java

@@ -63,13 +63,14 @@ public class ZtStoryUser implements Serializable {
     private Integer pri;
 
     private Float estimate;
-    //wait  active   finished closed
+    //  active   finished closed   //reviewing  评审中 active 激活   draft 草稿
     private String status;
-
+//    reviewing
     @TableField("subStatus")
     private String substatus;
 
     private String color;
+    //closed 关闭 wait 初始化   projected 已立项   developing 研发中 developed 研发完毕  testing 测试中 tested测试完毕 released已发布 verified已验收  closed 已关闭
 
     private String stage;
 

src/main/java/com/sa/zentao/entity/ZtStoryreview.java

@@ -32,7 +32,9 @@ public class ZtStoryreview implements Serializable {
 
     @TableField("reviewDate")
     private Date reviewdate;
-
+    //story  需求, userStory 用户需求 feedback 问题反馈
+    @TableField("type")
+    private String type;
 
     public String getKey(){
         return version+"-"+story;

src/main/java/com/sa/zentao/entity/ZtTask.java

@@ -28,6 +28,9 @@ public class ZtTask implements Serializable {
     @TableId(value = "id", type = IdType.AUTO)
     private Integer id;
 
+    //审核拒绝原因
+    private String approvalRemark;
+
     private Integer project;
 
     private Integer parent;
@@ -64,15 +67,15 @@ public class ZtTask implements Serializable {
     //预计工时  新增
     private Float estimate;
 
-    //总计多少小时
+    //总计多少小时 用了
     private Float consumed;
     //剩余   开发
     @TableField("`left`")
     private Float left;
-    //预计完成
+    //deadline 预计完成  estStarted预计开始
     private Date deadline;
 
-    //pause 暂停  cancel取消  closed 关闭 done 完成
+    //pause 暂停  cancel取消  closed 关闭 done 完成 wait  reviewing待评审 doing
     @TableField("`status`")
     private String status;
 
@@ -102,7 +105,7 @@ public class ZtTask implements Serializable {
     //预计开始
     @TableField("estStarted")
     private Date estStarted;
-
+    //真实开始
     @TableField("realStarted")
     private Date realstarted;
 
@@ -166,4 +169,8 @@ public class ZtTask implements Serializable {
     private String vision;
 
     private String files;
+
+    private String reviewingUser;
+
+    private Long deadlineTime;
 }

src/main/java/com/sa/zentao/entity/ZtUser.java

@@ -129,4 +129,6 @@ public class ZtUser implements Serializable {
     @TableField(exist = false)
     private String code;
 
+    private String color;
+
 }

src/main/java/com/sa/zentao/enums/ActionStatus.java

@@ -25,6 +25,8 @@ public enum ActionStatus {
     FB(18, "fb","发布"),
 
     QR(19, "qr","确认"),
+    KSCE(21, "tested","开始测试"),
+    CSWC(20, "tested","测试完成"),
 
     LOGIN(100, "login","登录"),
     ;

src/main/java/com/sa/zentao/enums/FileTypes.java

@@ -0,0 +1,42 @@
+package com.sa.zentao.enums;
+
+import com.baomidou.mybatisplus.annotation.EnumValue;
+
+public enum FileTypes {
+
+    task("task","任务"),
+    story("story", "需求"),
+    bug("bug", "BUG"),
+    userStory("userStory", "用户需求"),
+    feedbackStory("feedbackStory", "问题反馈"),
+    ywTask("ywTask", "运维任务"),
+
+    ;
+
+    @EnumValue
+    private String code;
+    private String value;
+
+    private FileTypes(String code, String value) {
+        this.code = code;
+        this.value = value;
+    }
+
+    public String getCode() {
+        return this.code;
+    }
+
+    public String getValue() {
+        return this.value;
+    }
+
+    public static FileTypes transferType(String code){
+        FileTypes[] values = values();
+        for (FileTypes v:values ) {
+            if(v.code.equals(code)){
+                return v;
+            }
+        }
+        return null;
+    }
+}

src/main/java/com/sa/zentao/enums/StoryStageEnums.java

@@ -0,0 +1,37 @@
+package com.sa.zentao.enums;
+
+import com.baomidou.mybatisplus.annotation.EnumValue;
+
+public enum StoryStageEnums {
+    //closed 关闭 wait 初始化   projected 已立项   developing 研发中 developed 研发完毕  testing 测试中
+    // tested测试完毕 released已发布 verified已验收  closed 已关闭
+
+    closed(1, "closed","关闭"),
+    wait(2, "wait","初始化"),
+    projected(3, "projected","已立项"),
+    developing(4, "developing","研发中"),
+    testing(5, "testing","测试中"),
+    tested(6, "tested","测试完毕"),
+    released(7, "released","已发布"),
+    verified(8, "verified","已验收"),
+    ;
+
+
+    private int code;
+    @EnumValue
+    private String value;
+    private String desc;
+    private StoryStageEnums(int code, String value,String desc) {
+        this.code = code;
+        this.value = value;
+        this.desc=desc;
+    }
+
+    public int getCode() {
+        return this.code;
+    }
+
+    public String getValue() {
+        return this.value;
+    }
+}

src/main/java/com/sa/zentao/enums/TaskStatus.java

@@ -0,0 +1,44 @@
+package com.sa.zentao.enums;
+
+import com.baomidou.mybatisplus.annotation.EnumValue;
+
+public enum TaskStatus {
+
+    //pause 暂停  cancel取消  closed 关闭 done 完成 wait  reviewing待评审 doing
+
+    pause("pause","暂停"),
+    cancel("cancel", "取消"),
+    closed("closed", "关闭"),
+    done("done", "完成"),
+    wait("wait", "准备好"),
+    reviewing("reviewing", "待评审"),
+    doing("doing", "进行中"),
+    ;
+
+    @EnumValue
+    private String code;
+    private String value;
+
+    private TaskStatus(String code, String value) {
+        this.code = code;
+        this.value = value;
+    }
+
+    public String getCode() {
+        return this.code;
+    }
+
+    public String getValue() {
+        return this.value;
+    }
+
+   public static TaskStatus transferType(String code){
+        TaskStatus[] values = values();
+        for (TaskStatus v:values ) {
+            if(v.code.equals(code)){
+                return v;
+            }
+        }
+        return null;
+    }
+}

src/main/java/com/sa/zentao/enums/TaskType.java

@@ -0,0 +1,44 @@
+package com.sa.zentao.enums;
+
+import com.baomidou.mybatisplus.annotation.EnumValue;
+
+public enum TaskType {
+
+    design("design","设计"),
+    devel("devel", "开发"),
+    request("request", "需求"),
+    test("test", "测试"),
+    study("study", "研究"),
+    discuss("discuss", "讨论"),
+    ui("ui", "界面"),
+    affair("affair", "事务"),
+    misc("misc", "其他"),
+    ;
+
+    @EnumValue
+    private String code;
+    private String value;
+
+    private TaskType(String code, String value) {
+        this.code = code;
+        this.value = value;
+    }
+
+    public String getCode() {
+        return this.code;
+    }
+
+    public String getValue() {
+        return this.value;
+    }
+
+   public static TaskType transferType(String code){
+        TaskType[] values = values();
+        for (TaskType v:values ) {
+            if(v.code.equals(code)){
+                return v;
+            }
+        }
+        return null;
+    }
+}

src/main/java/com/sa/zentao/enums/UserType.java

@@ -8,6 +8,8 @@ public enum UserType {
     XMGLY(2, "项目管理员"),
     KFZ(3, "开发者"),
     GSGC(4, "公司高层"),
+    CS(5, "测试人员"),
+    YW(6, "运维"),
     ;
 
     @EnumValue

src/main/java/com/sa/zentao/mapper/ZtFileMapper.java

@@ -0,0 +1,16 @@
+package com.sa.zentao.mapper;
+
+import com.sa.zentao.entity.ZtFile;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+
+/**
+ * <p>
+ *  Mapper 接口
+ * </p>
+ *
+ * @author gqb
+ * @since 2024-12-20
+ */
+public interface ZtFileMapper extends BaseMapper<ZtFile> {
+
+}

src/main/java/com/sa/zentao/mapper/ZtProjectMapper.java

@@ -1,5 +1,6 @@
 package com.sa.zentao.mapper;
 
+import com.baomidou.dynamic.datasource.annotation.DS;
 import com.sa.zentao.dao.ZtProjectDTO;
 import com.sa.zentao.entity.ZtProject;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
@@ -29,4 +30,7 @@ public interface ZtProjectMapper extends BaseMapper<ZtProject> {
     List<ZtProject> getProjectByProduct(@Param("qo") ZtProjectQo qo);
 
     List<ZtProject> executionListByProduct(@Param("qo")ZtProjectQo qo);
+
+    @DS("slave")
+    ZtProjectDTO selectPrdByName(@Param("name") String name);
 }

src/main/java/com/sa/zentao/mapper/ZtProjectstoryMapper.java

@@ -1,7 +1,11 @@
 package com.sa.zentao.mapper;
 
+import com.baomidou.dynamic.datasource.annotation.DS;
 import com.sa.zentao.entity.ZtProjectstory;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
 
 /**
  * <p>
@@ -13,4 +17,7 @@ import com.baomidou.mybatisplus.core.mapper.BaseMapper;
  */
 public interface ZtProjectstoryMapper extends BaseMapper<ZtProjectstory> {
 
+    @DS("slave")
+    List<ZtProjectstory> storyListPrd(@Param("id") Integer id);
+
 }

src/main/java/com/sa/zentao/mapper/ZtStoryMapper.java

@@ -1,5 +1,6 @@
 package com.sa.zentao.mapper;
 
+import com.baomidou.dynamic.datasource.annotation.DS;
 import com.sa.zentao.dao.ZtStoryDTO;
 import com.sa.zentao.entity.ZtStory;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
@@ -22,4 +23,13 @@ public interface ZtStoryMapper extends BaseMapper<ZtStory> {
 
     List<ZtStoryDTO> projectStoryPageList(@Param("qo") ZtProjectQo qo);
 
+    List<ZtStoryDTO> allStoryPageList(@Param("qo") ZtProjectQo qo);
+
+    List<ZtStoryDTO> myStoryPageList(@Param("qo")ZtProjectQo qo);
+
+    @DS("slave")
+    ZtStory getPrdById(@Param("id") Integer id);
+
+
+    List<ZtStoryDTO> storyPageListByIds(@Param("ids") List<String> ids);
 }

src/main/java/com/sa/zentao/mapper/ZtStoryspecMapper.java

@@ -1,7 +1,11 @@
 package com.sa.zentao.mapper;
 
+import com.baomidou.dynamic.datasource.annotation.DS;
 import com.sa.zentao.entity.ZtStoryspec;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
 
 /**
  * <p>
@@ -13,4 +17,6 @@ import com.baomidou.mybatisplus.core.mapper.BaseMapper;
  */
 public interface ZtStoryspecMapper extends BaseMapper<ZtStoryspec> {
 
+    @DS("slave")
+    List<ZtStoryspec> getPrdById(@Param("id") Integer id);
 }

src/main/java/com/sa/zentao/mapper/ZtUserMapper.java

@@ -1,9 +1,12 @@
 package com.sa.zentao.mapper;
 
+import com.baomidou.dynamic.datasource.annotation.DS;
+import com.sa.zentao.dao.ZtUserDTO;
 import com.sa.zentao.entity.ZtUser;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import com.sa.zentao.qo.ZtUserQo;
 import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.Select;
 
 import java.util.List;
 
@@ -18,4 +21,13 @@ import java.util.List;
 public interface ZtUserMapper extends BaseMapper<ZtUser> {
 
     List<ZtUser> pageList(@Param("qo") ZtUserQo qo);
+
+
+    @DS("slave")
+    @Select("select * from zt_user")
+    List<ZtUserDTO> listAll(@Param("qo") ZtUserQo qo);
+
+    @DS("slave")
+    ZtUser selectPrdByName(@Param("name")String userName);
+
 }

src/main/java/com/sa/zentao/qo/StoryQo.java

@@ -4,6 +4,8 @@ import com.sa.zentao.enums.ActionType;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 
+import java.util.List;
+
 @Data
 @EqualsAndHashCode(callSuper = false)
 public class StoryQo extends BaseQo {
@@ -11,9 +13,15 @@ public class StoryQo extends BaseQo {
 
     private Integer id;
 
+    private String title;
+
     private String userName;
     private String  module;
     private String searchVal;
 
     private Integer productId;
+
+    private String ids;
+
+    private List<String> storyIds;
 }

src/main/java/com/sa/zentao/qo/ZtBugQo.java

@@ -37,7 +37,7 @@ public class ZtBugQo extends BaseQo {
 
     private String step;
 
-    private String assignedto;
+    private String assignedTo;
 
     private String desc;
 }

src/main/java/com/sa/zentao/qo/ZtProjectQo.java

@@ -63,5 +63,20 @@ public class ZtProjectQo extends BaseQo {
 
     private Date date;
 
+    private Integer kfz=0;
+
     private List<String> teamList;
+
+    private String searchCode;
+    private String searchValue;
+
+    private String  orderName;
+    private String  orderSort;
+
+    //0 否 1 是
+    private Integer finishedFlag=0;
+
+    private String ids;
+
+    private List<String> objIds;
 }

src/main/java/com/sa/zentao/qo/ZtReleaseQo.java

@@ -0,0 +1,56 @@
+package com.sa.zentao.qo;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import java.io.Serializable;
+import java.util.Date;
+import java.util.List;
+
+/**
+ * <p>
+ * 
+ * </p>
+ *
+ * @author gqb
+ * @since 2024-12-26
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+public class ZtReleaseQo extends BaseQo {
+
+    private static final long serialVersionUID = 1L;
+
+    @TableId(value = "id", type = IdType.AUTO)
+    private Integer id;
+
+    private String assignedTo;
+
+    private Integer project;
+    //0 不通过  1通过
+    private Integer revieweResult;
+
+    //发布失败原因
+    private String releaseFailRemark;
+    //失败原因
+    private String  failRemark;
+    //标题
+    private String title;
+    //备注
+    private String remark;
+    //  1 推送  2.不推送
+    private Integer pushFlag;
+    //ALL   WFB  YFB
+    private String searchVal;
+
+    private Integer execution;
+
+    private String name;
+
+    private Integer storyId;
+
+    private List<Integer> storyList;
+}

src/main/java/com/sa/zentao/service/IZtBugService.java

@@ -32,4 +32,6 @@ public interface IZtBugService extends IService<ZtBug> {
     PageInfo<ZtBugDTO> myBugPageList(ZtProjectQo qo);
 
     ZtBugDTO bugInfoById(Integer id);
+
+    void assignedTo(ZtBugQo qo);
 }

src/main/java/com/sa/zentao/service/IZtFileService.java

@@ -0,0 +1,19 @@
+package com.sa.zentao.service;
+
+import com.sa.zentao.entity.ZtFile;
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.sa.zentao.enums.FileTypes;
+
+/**
+ * <p>
+ *  服务类
+ * </p>
+ *
+ * @author gqb
+ * @since 2024-12-20
+ */
+public interface IZtFileService extends IService<ZtFile> {
+
+
+    void updateFile(String fileIds, Integer objectId, FileTypes type);
+}

src/main/java/com/sa/zentao/service/IZtKanbanlaneService.java

@@ -40,4 +40,6 @@ public interface IZtKanbanlaneService extends IService<ZtKanbanlane> {
      * @return
      */
     public ZtKanbancell getZtKanbanlane(String type, String status, Integer id);
+    //
+    void removeExecutionStory(Integer execution, Integer story);
 }

src/main/java/com/sa/zentao/service/IZtNoticeService.java

@@ -0,0 +1,16 @@
+package com.sa.zentao.service;
+
+import com.sa.zentao.entity.ZtNotice;
+import com.baomidou.mybatisplus.extension.service.IService;
+
+/**
+ * <p>
+ *  服务类
+ * </p>
+ *
+ * @author gqb
+ * @since 2024-12-26
+ */
+public interface IZtNoticeService extends IService<ZtNotice> {
+
+}

src/main/java/com/sa/zentao/service/IZtProjectService.java

@@ -85,7 +85,7 @@ public interface IZtProjectService extends IService<ZtProject> {
 
     List<ZtUser> execTeamList(ZtProjectQo qo);
 
-    Map<String,List<Map<String,String>>> projectTeamTimeWork(ZtProjectQo qo);
+    Map<String,List<Map<String,Object>>> projectTeamTimeWork(ZtProjectQo qo);
 
     void editImplement(ZtProjectDTO dto);
 
@@ -96,4 +96,10 @@ public interface IZtProjectService extends IService<ZtProject> {
     ZtProjectDTO copyExecInfoById(ZtProjectDTO dto);
 
     List<ZtProject> projectByExecution(ZtProjectDTO dto);
+
+    ZtProjectDTO selectPrdByName(String s);
+
+    List<ZtProject> execListByProject(Integer project);
+
+    void removeExecutionStory(Integer id);
 }

src/main/java/com/sa/zentao/service/IZtProjectstoryService.java

@@ -3,6 +3,8 @@ package com.sa.zentao.service;
 import com.sa.zentao.entity.ZtProjectstory;
 import com.baomidou.mybatisplus.extension.service.IService;
 
+import java.util.List;
+
 /**
  * <p>
  *  服务类
@@ -13,4 +15,5 @@ import com.baomidou.mybatisplus.extension.service.IService;
  */
 public interface IZtProjectstoryService extends IService<ZtProjectstory> {
 
+    List<ZtProjectstory> storyListPrd(Integer id);
 }

src/main/java/com/sa/zentao/service/IZtReleaseDetailsService.java

@@ -0,0 +1,23 @@
+package com.sa.zentao.service;
+
+import com.sa.zentao.dao.ZtStoryDTO;
+import com.sa.zentao.entity.ZtReleaseDetails;
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.sa.zentao.qo.ZtReleaseQo;
+
+import java.util.List;
+
+/**
+ * <p>
+ *  服务类
+ * </p>
+ *
+ * @author gqb
+ * @since 2024-12-26
+ */
+public interface IZtReleaseDetailsService extends IService<ZtReleaseDetails> {
+
+    List<ZtStoryDTO> releasePageList(ZtReleaseQo qo);
+
+    List<ZtStoryDTO> storyPageList(ZtReleaseQo qo);
+}

src/main/java/com/sa/zentao/service/IZtReleaseService.java

@@ -0,0 +1,49 @@
+package com.sa.zentao.service;
+
+import com.github.pagehelper.PageInfo;
+import com.sa.zentao.dao.Result;
+import com.sa.zentao.dao.ZtReleaseDTO;
+import com.sa.zentao.dao.ZtStoryDTO;
+import com.sa.zentao.entity.ZtRelease;
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.sa.zentao.qo.ZtReleaseQo;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * <p>
+ *  服务类
+ * </p>
+ *
+ * @author gqb
+ * @since 2024-12-26
+ */
+public interface IZtReleaseService extends IService<ZtRelease> {
+
+    void addRelease(ZtReleaseDTO dto);
+
+
+    void modifyRelease(ZtReleaseDTO dto);
+
+    PageInfo<ZtReleaseDTO> pageList(ZtReleaseQo qo);
+
+    void assignedTo(ZtReleaseQo dto);
+
+    void userReview(ZtReleaseQo dto);
+
+    void release(ZtReleaseQo dto);
+
+
+    List<Map<String,Object>> execMenu(ZtReleaseQo dto);
+
+    PageInfo<ZtStoryDTO> execStoryPageList(ZtReleaseQo qo);
+
+    PageInfo<ZtStoryDTO> releaseStoryPageList(ZtReleaseQo qo);
+
+    PageInfo<ZtStoryDTO> projectStoryPageList(ZtReleaseQo qo);
+
+    void removeStory(ZtReleaseQo qo);
+
+    void batchSyncStory(ZtReleaseQo qo);
+}

src/main/java/com/sa/zentao/service/IZtStoryFeedbackService.java

@@ -1,6 +1,7 @@
 package com.sa.zentao.service;
 
 import com.github.pagehelper.PageInfo;
+import com.sa.zentao.dao.ZtStoryDTO;
 import com.sa.zentao.dao.ZtStoryFeedbackDTO;
 import com.sa.zentao.entity.ZtStoryFeedback;
 import com.baomidou.mybatisplus.extension.service.IService;
@@ -25,4 +26,13 @@ public interface IZtStoryFeedbackService extends IService<ZtStoryFeedback> {
     void editFeedback(ZtStoryFeedbackDTO dto);
 
     void changeStatus(ZtStoryFeedbackDTO dto);
+
+    void assignedTo(ZtStoryDTO dto);
+
+    void startHand(ZtStoryDTO dto);
+
+    List<ZtStoryFeedbackDTO> ztStoryFeedbackDTO(ZtProjectQo qo);
+
+    PageInfo<ZtStoryFeedbackDTO> myFeedbackPageList(ZtProjectQo qo);
+
 }

src/main/java/com/sa/zentao/service/IZtStoryService.java

@@ -6,8 +6,10 @@ import com.sa.zentao.entity.ZtProject;
 import com.sa.zentao.entity.ZtStory;
 import com.baomidou.mybatisplus.extension.service.IService;
 import com.sa.zentao.qo.ZtProjectQo;
+import org.apache.ibatis.annotations.Param;
 
 import java.util.List;
+import java.util.Map;
 
 /**
  * <p>
@@ -47,6 +49,12 @@ public interface IZtStoryService extends IService<ZtStory> {
     void startStory(Integer story,Integer execution);
 
     void finishStory(Integer story,Integer execution);
+    //测试完毕
+    void testedStory(Integer story);
+    //测试中
+    void testingStory(Integer story);
+    //发布
+    void releaseStory(Integer story);
 
     void changeStatus(ZtStoryDTO dto);
 
@@ -63,4 +71,14 @@ public interface IZtStoryService extends IService<ZtStory> {
     void changeAssignedTo(ZtStoryDTO dto);
 
     void changeExecution(ZtStoryDTO dto);
+
+    ZtStory getPrdById(Integer id);
+
+    PageInfo<ZtStoryDTO> myStoryPageList(ZtProjectQo qo);
+
+    void addRemark(ZtStoryDTO dto);
+
+    List<ZtStoryDTO> myStoryList(ZtProjectQo qo);
+
+    public Map<Integer, ZtProject> getExecutionMapByStory(List<ZtStoryDTO> list);
 }

src/main/java/com/sa/zentao/service/IZtStoryUserService.java

@@ -1,10 +1,14 @@
 package com.sa.zentao.service;
 
 import com.github.pagehelper.PageInfo;
+import com.sa.zentao.dao.ZtStoryDTO;
 import com.sa.zentao.dao.ZtStoryUserDTO;
 import com.sa.zentao.entity.ZtStoryUser;
 import com.baomidou.mybatisplus.extension.service.IService;
 import com.sa.zentao.qo.StoryQo;
+import com.sa.zentao.qo.ZtProjectQo;
+
+import java.util.List;
 
 /**
  * <p>
@@ -23,4 +27,9 @@ public interface IZtStoryUserService extends IService<ZtStoryUser> {
     PageInfo<ZtStoryUserDTO> pageList(StoryQo dto);
 
     void changeStatus(ZtStoryUserDTO dto);
+
+    List<ZtStoryUserDTO> storyListByProductId(ZtProjectQo qo);
+
+    void userReview(ZtStoryDTO dto);
+
 }

src/main/java/com/sa/zentao/service/IZtStoryspecService.java

@@ -3,6 +3,8 @@ package com.sa.zentao.service;
 import com.sa.zentao.entity.ZtStoryspec;
 import com.baomidou.mybatisplus.extension.service.IService;
 
+import java.util.List;
+
 /**
  * <p>
  *  服务类
@@ -13,4 +15,5 @@ import com.baomidou.mybatisplus.extension.service.IService;
  */
 public interface IZtStoryspecService extends IService<ZtStoryspec> {
 
+    List<ZtStoryspec> getPrdById(Integer id);
 }

src/main/java/com/sa/zentao/service/IZtTaskService.java

@@ -3,6 +3,7 @@ package com.sa.zentao.service;
 import com.github.pagehelper.PageInfo;
 import com.sa.zentao.dao.ZtProjectDTO;
 import com.sa.zentao.dao.ZtTaskDTO;
+import com.sa.zentao.dao.ZtYwTaskDTO;
 import com.sa.zentao.entity.ZtTask;
 import com.baomidou.mybatisplus.extension.service.IService;
 import com.sa.zentao.qo.ZtProjectQo;
@@ -37,4 +38,18 @@ public interface IZtTaskService extends IService<ZtTask> {
 
     void batchAddTask(ZtTaskDTO dto);
 
+    void approval(ZtTaskDTO dto);
+
+    PageInfo<ZtTaskDTO> myTaskPageList(ZtProjectQo qo);
+
+    void assignedTo(ZtTaskDTO dto);
+
+    void batchApproval(ZtTaskDTO dto);
+
+    List<ZtTaskDTO> myTaskList(ZtProjectQo qo);
+
+    void addRemark(ZtTaskDTO dto);
+
+    ZtTaskDTO getTaskById(Integer id);
+
 }

src/main/java/com/sa/zentao/service/IZtUserService.java

@@ -32,4 +32,6 @@ public interface IZtUserService extends IService<ZtUser> {
     void sendCode(ZtUser user);
 
     ZtUser login(ZtUser user);
+
+    ZtUser selectPrdByName(String userName);
 }

src/main/java/com/sa/zentao/service/IZtYwTaskService.java

@@ -4,8 +4,11 @@ import com.github.pagehelper.PageInfo;
 import com.sa.zentao.dao.ZtYwTaskDTO;
 import com.sa.zentao.entity.ZtYwTask;
 import com.baomidou.mybatisplus.extension.service.IService;
+import com.sa.zentao.qo.ZtProjectQo;
 import com.sa.zentao.qo.ZtYwPatrolQo;
 
+import java.util.List;
+
 /**
  * <p>
  *  服务类
@@ -29,4 +32,6 @@ public interface IZtYwTaskService extends IService<ZtYwTask> {
     void check(ZtYwTaskDTO dto);
 
     void remindMail();
+
+    List<ZtYwTaskDTO> ywTaskService(ZtProjectQo qo);
 }

src/main/java/com/sa/zentao/service/impl/IZtCountService.java

@@ -1,16 +1,29 @@
 package com.sa.zentao.service.impl;
 
 import com.alibaba.excel.EasyExcel;
+import com.alibaba.excel.ExcelWriter;
+import com.alibaba.excel.annotation.ExcelProperty;
+import com.alibaba.excel.write.builder.ExcelWriterSheetBuilder;
+import com.alibaba.excel.write.metadata.WriteSheet;
+import com.alibaba.excel.write.metadata.WriteTable;
+import com.alibaba.excel.write.style.column.LongestMatchColumnWidthStyleStrategy;
 import com.alibaba.fastjson.JSONObject;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.github.pagehelper.PageInfo;
 import com.sa.zentao.conf.LoginRiskUser;
 import com.sa.zentao.conf.RiskUserThreadLocal;
 import com.sa.zentao.dao.*;
 import com.sa.zentao.entity.*;
+import com.sa.zentao.enums.TaskStatus;
+import com.sa.zentao.enums.TaskType;
 import com.sa.zentao.enums.UserType;
 import com.sa.zentao.qo.ZtCountQo;
+import com.sa.zentao.qo.ZtProjectQo;
+import com.sa.zentao.qo.ZtUserQo;
 import com.sa.zentao.service.*;
 import com.sa.zentao.utils.DateUtils;
+import jakarta.servlet.ServletOutputStream;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -21,8 +34,10 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.ByteArrayOutputStream;
 import java.math.BigDecimal;
+import java.math.RoundingMode;
 import java.util.*;
 import java.util.stream.Collectors;
+import java.util.stream.DoubleStream;
 
 @Service
 @Slf4j
@@ -37,6 +52,12 @@ public class IZtCountService {
     @Autowired
     private IZtTaskService taskService;
 
+    @Autowired
+    private IZtYwTaskService ywTaskService;
+    @Autowired
+    private IZtCronDevopsService cronDevopsService;
+
+
     public Map<String, Object> todayWorkCount(ZtCaseDTO dto) {
         String name = RiskUserThreadLocal.get().getName();
         if (StringUtils.isEmpty(name)) {
@@ -47,7 +68,8 @@ public class IZtCountService {
 
         List<ZtStory> storyList = storyService.list(new QueryWrapper<ZtStory>().lambda()
                 .eq(ZtStory::getAssignedTo, name).ne(ZtStory::getStatus, "closed"));
-        long storyCount = storyList.stream().filter(o->o.getAssignedTo().equals(name)).filter(o->!o.getStage().equals("verified")).count();
+        List<ZtStory> storyCountList = storyList.stream().filter(o -> o.getAssignedTo().equals(name)).filter(o -> !o.getStage().equals("verified")).collect(Collectors.toList());
+
 
         //已经验收
 //        long noFinishStoryCount = storyService.count(new QueryWrapper<ZtStory>().lambda()
@@ -56,50 +78,76 @@ public class IZtCountService {
 //        );
         Date date = new Date();
 
-        result.put("storyCount", storyCount);
+
+        result.put("storyCount", storyCountList.stream().map(o->o.getId()+"").collect(Collectors.joining(",")));
         result.put("storyTimeOutCount", storyList.stream().filter(o -> !"verified".equalsIgnoreCase(o.getStage()))
                 .filter(o->o.getAssignedTo().equals(name))
-                .filter(o -> o.getPlanEndDate() != null && o.getPlanEndDate().getTime() < date.getTime()).count());
+                .filter(o -> o.getPlanEndDate() != null && o.getPlanEndDate().getTime() < date.getTime())
+                .map(o->o.getId()+"").collect(Collectors.joining(",")));
 
-        List<ZtBug> bugList = bugService.list(new QueryWrapper<ZtBug>().lambda().eq(ZtBug::getAssignedto, name)
+        List<ZtBug> bugList = bugService.list(new QueryWrapper<ZtBug>().lambda().eq(ZtBug::getAssignedTo, name)
                 .ne(ZtBug::getStatus, "closed")
         );
         long bugCount = bugList.stream().filter(o->o.getStatus().equals("active")).count();
 
-        long resolvedBugCount = bugService.count(new QueryWrapper<ZtBug>().lambda().eq(ZtBug::getAssignedto, name)
+        long resolvedBugCount = bugService.count(new QueryWrapper<ZtBug>().lambda().eq(ZtBug::getAssignedTo, name)
                 .eq(ZtBug::getStatus, "resolved")
         );
 
-        result.put("bugCount", bugCount);
+        result.put("bugCount", bugList.stream().filter(o->o.getStatus().equals("active"))  .map(o->o.getId()+"").collect(Collectors.joining(",")));
-        result.put("bugTimeOutCount", bugList.stream().filter(o -> o.getDeadline() != null && o.getDeadline().getTime() < date.getTime()).filter(o -> "active".equalsIgnoreCase(o.getStatus())).count());
+        result.put("bugTimeOutCount", bugList.stream().filter(o -> o.getDeadline() != null && o.getDeadline().getTime() < date.getTime())
+                .filter(o -> "active".equalsIgnoreCase(o.getStatus())) .map(o->o.getId()+"").collect(Collectors.joining(",")));
 
 
         List<ZtTask> taskList = taskService.list(new QueryWrapper<ZtTask>().lambda()
                 .eq(ZtTask::getAssignedTo, name).ne(ZtTask::getStatus, "closed"));
 
+
+
         long taskCount=taskList.stream().filter(o->o.getStatus().equals("doing")||o.getStatus().equals("wait")).count();
         long resolvedTaskCount = taskList.stream().filter(o->o.getStatus().equals("done")).count();
 //                taskService.count(new QueryWrapper<ZtTask>().lambda()
 //                .eq(ZtTask::getAssignedTo, name).eq(ZtTask::getStatus, "done"));
 
-        result.put("taskCount", taskCount);
+        result.put("taskCount", taskList.stream().filter(o->o.getStatus().equals("doing")||o.getStatus().equals("wait")).map(o->o.getId()+"").collect(Collectors.joining(",")));
-        result.put("taskTimeOutCount", taskList.stream().filter(o -> o.getDeadline() != null && o.getDeadline().getTime() < date.getTime())
+        result.put("taskTimeOutCount", taskList.stream().filter(o -> o.getDeadline() != null && DateUtils.getDayLast(o.getDeadline()).getTime() < date.getTime())
-                .filter(o -> o.getStatus().equalsIgnoreCase("doing")||o.getStatus().equalsIgnoreCase("wait")).count());
+                .filter(o -> o.getStatus().equalsIgnoreCase("doing")||o.getStatus().equalsIgnoreCase("wait")).map(o->o.getId()+"").collect(Collectors.joining(",")));
         if (taskCount == 0 && bugCount == 0) {
-
-
             result.put("process", 0L);
         } else {
             BigDecimal divide = BigDecimal.valueOf(resolvedTaskCount + resolvedBugCount).divide(BigDecimal.valueOf(taskList.size() + bugList.size()), 2, BigDecimal.ROUND_HALF_UP);
-
-
             result.put("process", divide.multiply(BigDecimal.valueOf(100)));
         }
+        List<ZtStoryFeedback> feedbacks = this.storyFeedbackService.list(new QueryWrapper<ZtStoryFeedback>().lambda()
+                .ne(ZtStoryFeedback::getStatus, "closed")
+                .eq(ZtStoryFeedback::getAssignedTo,RiskUserThreadLocal.get().getName())
+        );
+        //处理中  问题
+        result.put("feedbackActive",feedbacks.stream().filter(o->"doing".equals(o.getStatus())).map(o->o.getId()+"").collect(Collectors.joining(",")));
+        //处理完  问题
+        result.put("feedbackFinished",feedbacks.stream().filter(o->"finished".equals(o.getStatus())).map(o->o.getId()+"").collect(Collectors.joining(",")));
+
+
+        if(UserType.YW==RiskUserThreadLocal.get().getUserType()){
+
+            List<ZtYwTask> list = ywTaskService.list(new QueryWrapper<ZtYwTask>().lambda().eq(ZtYwTask::getCreateUser, RiskUserThreadLocal.get().getName()));
+
+
+
+            result.put("activeTask",list.stream().filter(o->2==o.getTaskStatus()||1==o.getTaskStatus()).count());
+            result.put("handTask",list.stream().filter(o->3==o.getTaskStatus()).count());
+            result.put("yqTask",list.stream().filter(o->2==o.getTaskStatus()||1==o.getTaskStatus())
+                    .filter(o->o.getTaskStartDate().getTime()<new Date().getTime())
+                    .count());
+        }
 
         return result;
     }
 
-
+    @Autowired
+    private IZtProjectproductService projectproductService;
+    @Autowired
+    private IZtProductService productService;
 
     public ZtStoryCountDTO storyCount(ZtCaseDTO dto) {
         LoginRiskUser loginRiskUser = RiskUserThreadLocal.get();
@@ -107,96 +155,216 @@ public class IZtCountService {
 
         UserType userType = loginRiskUser.getUserType();
         ZtStoryCountDTO result = new ZtStoryCountDTO();
-        if (userType == UserType.GSGC) {
+        if (userType == UserType.GSGC||loginRiskUser.getName().equals("admin")) {
+
+            List<ZtStoryUser> list = this.storyUserService.list(new QueryWrapper<ZtStoryUser>().lambda().in(ZtStoryUser::getStatus, "active", "reviewing"));
+
             List<ZtStory> ztStory = storyService.list(new QueryWrapper<ZtStory>()
                     .lambda().eq(ZtStory::getDeleted, "0")
                     .ne(ZtStory::getStatus, "closed")
             );
-            result.setDpsCount(BigDecimal.valueOf(ztStory.stream().filter(o -> "reviewing".equals(o.getStatus())).count()));
+            result.setDpsCount(list.stream().filter(o -> "reviewing".equals(o.getStatus())).map(o->o.getId()+"").collect(Collectors.joining(",")));
-            result.setPstgCount(BigDecimal.valueOf(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
+            result.setPstgCount(list.stream().filter(o -> "active".equals(o.getStatus()))
-                    .filter(o -> o.getStage().equals("wait")).count()));
+                    .filter(o -> o.getStage().equals("wait")).map(o->o.getId()+"").collect(Collectors.joining(",")));
-            result.setJxzCount(BigDecimal.valueOf(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
+
-                    .filter(o -> o.getStage().equals("developing")).count()));
+            result.setPlanCount(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
-            result.setYqCount(BigDecimal.valueOf(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
+                    .filter(o -> o.getStage().equals("wait")).map(o->o.getId()+"").collect(Collectors.joining(",")));
+
+            result.setTestingCount(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
+                    .filter(o -> o.getStage().equals("testing")).map(o->o.getId()+"").collect(Collectors.joining(",")));
+
+            result.setJxzCount(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
+                    .filter(o -> o.getStage().equals("developing")).map(o->o.getId()+"").collect(Collectors.joining(",")));
+            result.setYqCount(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
                     .filter(o -> !o.getStage().equals("verified") && !o.getStage().equals("verified"))
                     .filter(o -> o.getPlanEndDate() != null && o.getPlanEndDate().getTime() < new Date().getTime())
-                    .count()));
+                    .map(o->o.getId()+"").collect(Collectors.joining(",")));
-            result.setCswbCount(BigDecimal.valueOf(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
+            result.setCswbCount(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
                     .filter(o -> o.getStage().equals("tested"))
-                    .count()));
+                    .map(o->o.getId()+"").collect(Collectors.joining(",")));
-            result.setDysCount(BigDecimal.valueOf(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
+            result.setDysCount(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
                     .filter(o -> o.getStage().equals("released"))
-                    .count()));
+                    .map(o->o.getId()+"").collect(Collectors.joining(",")));
-            result.setYsNoCount(BigDecimal.valueOf(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
+            result.setYsNoCount(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
                     .filter(o -> o.getStage().equals("verified"))
                     .filter(o -> o.getYsFlag() == 2)
-                    .count()));
+                    .map(o->o.getId()+"").collect(Collectors.joining(",")));
-            result.setYsYesCount(BigDecimal.valueOf(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
+            result.setYsYesCount(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
                     .filter(o -> o.getStage().equals("verified"))
                     .filter(o -> o.getYsFlag() == 1||o.getYsFlag() == 0)
-                    .count()));
+                    .map(o->o.getId()+"").collect(Collectors.joining(",")));
+
+            List<ZtStoryFeedback> feedbacks = this.storyFeedbackService.list(new QueryWrapper<ZtStoryFeedback>().lambda().ne(ZtStoryFeedback::getStatus, "closed"));
+
+            //问题反馈 未受理
+            result.setFeedbackWslCount(feedbacks.stream().filter(o->"wait".equals(o.getStatus())) .map(o->o.getId()+"").collect(Collectors.joining(",")));
+            //处理中的
+            result.setFeedbackClzCount(feedbacks.stream().filter(o->"doing".equals(o.getStatus())) .map(o->o.getId()+"").collect(Collectors.joining(",")));
+            //处理完的
+            result.setFeedbackClwCount(feedbacks.stream().filter(o->"finished".equals(o.getStatus())) .map(o->o.getId()+"").collect(Collectors.joining(",")));
+            //延期的
+            result.setFeedbackYqCount(feedbacks.stream().filter(o->o.getPlanFinishDate()!=null&&o.getPlanFinishDate().getTime()<new Date().getTime()) .map(o->o.getId()+"").collect(Collectors.joining(",")));
+
         } else if (userType == UserType.CP) {
-            //产品看自己的需求
+
-            List<ZtStory> ztStory = storyService.list(new QueryWrapper<ZtStory>()
+            List<Integer> integers = this.projectService.authList();
-                    .lambda().eq(ZtStory::getDeleted, "0")
+
-                    .ne(ZtStory::getStatus, "closed")
+            List<ZtProduct> list = this.productService.list(new QueryWrapper<ZtProduct>().lambda().in(ZtProduct::getProgram, integers));
-                    .eq(ZtStory::getOpenedby,loginRiskUser.getName())
+
+            List<ZtStoryUser> storyUsers = this.storyUserService.list(new QueryWrapper<ZtStoryUser>().lambda()
+                    .in(ZtStoryUser::getStatus, "active", "reviewing")
+                    .in(ZtStoryUser::getProduct,list.stream().map(o->o.getId()).collect(Collectors.toList()))
+                    .eq(ZtStoryUser::getAssignedto,loginRiskUser.getName())
             );
-            result.setDpsCount(BigDecimal.valueOf(ztStory.stream().filter(o -> "reviewing".equals(o.getStatus())).count()));
+
-            result.setPstgCount(BigDecimal.valueOf(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
+
-                    .filter(o -> o.getStage().equals("wait")).count()));
+            //产品看自己的需求
-            result.setJxzCount(BigDecimal.valueOf(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
+            List<ZtStory> ztStory =null;
-                    .filter(o -> o.getStage().equals("developing")).count()));
+            if(CollectionUtils.isEmpty(list)){
-            result.setYqCount(BigDecimal.valueOf(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
+                ztStory=new ArrayList<>();
+            }else{
+                ztStory = storyService.list(new QueryWrapper<ZtStory>()
+                        .lambda().eq(ZtStory::getDeleted, "0")
+                        .ne(ZtStory::getStatus, "closed")
+                        .eq(ZtStory::getOpenedby,loginRiskUser.getName())
+                        .in(ZtStory::getProduct,list.stream().map(o->o.getId()).collect(Collectors.toList())));
+            }
+
+            result.setDpsCount(storyUsers.stream().filter(o -> "reviewing".equals(o.getStatus())) .map(o->o.getId()+"").collect(Collectors.joining(",")));
+
+            result.setPstgCount(storyUsers.stream().filter(o -> "active".equals(o.getStatus()))
+                    .filter(o -> o.getStage().equals("wait")) .map(o->o.getId()+"").collect(Collectors.joining(",")));
+
+            result.setPlanCount(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
+                    .filter(o -> o.getStage().equals("wait")) .map(o->o.getId()+"").collect(Collectors.joining(",")));
+
+            result.setJxzCount(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
+                    .filter(o -> o.getStage().equals("developing")) .map(o->o.getId()+"").collect(Collectors.joining(",")));
+
+            result.setYqCount(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
                     .filter(o -> !o.getStage().equals("verified") && !o.getStage().equals("verified"))
                     .filter(o -> o.getPlanEndDate() != null && o.getPlanEndDate().getTime() < new Date().getTime())
-                    .count()));
+                    .map(o->o.getId()+"").collect(Collectors.joining(",")));
-            result.setCswbCount(BigDecimal.valueOf(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
+            result.setCswbCount(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
                     .filter(o -> o.getStage().equals("tested"))
-                    .count()));
+                    .map(o->o.getId()+"").collect(Collectors.joining(",")));
-            result.setDysCount(BigDecimal.valueOf(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
+            result.setDysCount(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
                     .filter(o -> o.getStage().equals("released"))
-                    .count()));
+                    .map(o->o.getId()+"").collect(Collectors.joining(",")));
-            result.setYsNoCount(BigDecimal.valueOf(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
+            result.setYsNoCount(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
                     .filter(o -> o.getStage().equals("verified"))
                     .filter(o -> o.getYsFlag() == 2)
-                    .count()));
+                    .map(o->o.getId()+"").collect(Collectors.joining(",")));
-            result.setYsYesCount(BigDecimal.valueOf(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
+            result.setYsYesCount(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
                     .filter(o -> o.getStage().equals("verified"))
                     .filter(o -> o.getYsFlag() == 1)
-                    .count()));
+                    .map(o->o.getId()+"").collect(Collectors.joining(",")));
+
+
+            List<ZtStoryFeedback> feedbacks = this.storyFeedbackService.list(new QueryWrapper<ZtStoryFeedback>()
+                    .lambda().ne(ZtStoryFeedback::getStatus, "closed")
+                    .eq(ZtStoryFeedback::getAssignedTo,loginRiskUser.getName()).or().eq(ZtStoryFeedback::getOpenedBy,loginRiskUser.getName())
+
+            );
+
+            //问题反馈 未受理
+            result.setFeedbackWslCount(feedbacks.stream().filter(o->"wait".equals(o.getStatus())) .map(o->o.getId()+"").collect(Collectors.joining(",")));
+            //处理中的
+            result.setFeedbackClzCount(feedbacks.stream().filter(o->"doing".equals(o.getStatus())) .map(o->o.getId()+"").collect(Collectors.joining(",")));
+            //处理完的
+            result.setFeedbackClwCount(feedbacks.stream().filter(o->"finished".equals(o.getStatus())) .map(o->o.getId()+"").collect(Collectors.joining(",")));
+            //延期的
+            result.setFeedbackYqCount(feedbacks.stream().filter(o->o.getPlanFinishDate()!=null&&o.getPlanFinishDate().getTime()<new Date().getTime())
+                    .map(o->o.getId()+"").collect(Collectors.joining(",")));
+
         } else if (userType == UserType.XMGLY) {
 
-            List<ZtStory> ztStory = storyService.list(new QueryWrapper<ZtStory>()
+
-                    .lambda().eq(ZtStory::getDeleted, "0")
+            List<Integer> integers = this.projectService.authList();
-                    .ne(ZtStory::getStatus, "closed")
+
+            List<ZtProduct> pList = this.productService.list(new QueryWrapper<ZtProduct>().lambda().in(ZtProduct::getProgram, integers));
+
+            List<ZtStoryUser> storyUsers = this.storyUserService.list(new QueryWrapper<ZtStoryUser>().lambda()
+                    .in(ZtStoryUser::getStatus, "active", "reviewing")
+                    .in(ZtStoryUser::getProduct,pList.stream().map(o->o.getId()).collect(Collectors.toList()))
             );
-            result.setDpsCount(BigDecimal.valueOf(ztStory.stream().filter(o -> "reviewing".equals(o.getStatus())).count()));
+
-            result.setPstgCount(BigDecimal.valueOf(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
+            LambdaQueryWrapper<ZtStory> eq = new QueryWrapper<ZtStory>()
-                    .filter(o -> o.getStage().equals("wait")).count()));
+                    .lambda().eq(ZtStory::getDeleted, "0")
-            result.setJxzCount(BigDecimal.valueOf(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
+                    .ne(ZtStory::getStatus, "closed");
-                    .filter(o -> o.getStage().equals("developing")).count()));
+
-            result.setYqCount(BigDecimal.valueOf(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
+            List<ZtStory> ztStory =new ArrayList<>();
+
+//                    .in(ZtStory::getProduct,integers)
+//                    .or()
+//                    .in()
+
+            if(!CollectionUtils.isEmpty(integers)){
+                //所有的产品
+                if(!CollectionUtils.isEmpty(pList)){
+                    eq.in(ZtStory::getProduct,pList.stream().map(o->o.getId()).collect(Collectors.toList()));
+                    List<ZtProjectproduct> list = this.projectproductService.list(new QueryWrapper<ZtProjectproduct>().lambda()
+                            .in(ZtProjectproduct::getProduct, pList.stream().map(o -> o.getId()).collect(Collectors.toList())));
+                    if(!CollectionUtils.isEmpty(list)){
+                        eq.or().in(ZtStory::getProject,list.stream().map(o->o.getProject()).collect(Collectors.toList()));
+                    }
+                    ztStory=this.storyService.list(eq);
+                }
+            }
+
+            result.setDpsCount(storyUsers.stream().filter(o -> "reviewing".equals(o.getStatus())) .map(o->o.getId()+"").collect(Collectors.joining(",")));
+            result.setPstgCount(storyUsers.stream().filter(o -> "active".equals(o.getStatus()))
+                    .filter(o -> o.getStage().equals("wait")) .map(o->o.getId()+"").collect(Collectors.joining(",")));
+
+
+            result.setPlanCount(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
+                    .filter(o -> o.getStage().equals("wait")) .map(o->o.getId()+"").collect(Collectors.joining(",")));
+
+            result.setTestingCount(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
+                    .filter(o -> o.getStage().equals("testing")) .map(o->o.getId()+"").collect(Collectors.joining(",")));
+
+            result.setDpsCount(ztStory.stream().filter(o -> "reviewing".equals(o.getStatus())) .map(o->o.getId()+"").collect(Collectors.joining(",")));
+            result.setPstgCount(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
+                    .filter(o -> o.getStage().equals("wait")) .map(o->o.getId()+"").collect(Collectors.joining(",")));
+            result.setJxzCount(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
+                    .filter(o -> o.getStage().equals("developing")) .map(o->o.getId()+"").collect(Collectors.joining(",")));
+            result.setYqCount(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
                     .filter(o -> !o.getStage().equals("verified") && !o.getStage().equals("verified"))
                     .filter(o -> o.getPlanEndDate() != null && o.getPlanEndDate().getTime() < new Date().getTime())
-                    .count()));
+                    .map(o->o.getId()+"").collect(Collectors.joining(",")));
-            result.setCswbCount(BigDecimal.valueOf(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
+            result.setCswbCount(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
                     .filter(o -> o.getStage().equals("tested"))
-                    .count()));
+                    .map(o->o.getId()+"").collect(Collectors.joining(",")));
-            result.setDysCount(BigDecimal.valueOf(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
+            result.setDysCount(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
                     .filter(o -> o.getStage().equals("released"))
-                    .count()));
+                    .map(o->o.getId()+"").collect(Collectors.joining(",")));
-            result.setYsNoCount(BigDecimal.valueOf(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
+            result.setYsNoCount(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
                     .filter(o -> o.getStage().equals("verified"))
                     .filter(o -> o.getYsFlag() == 2)
-                    .count()));
+                    .map(o->o.getId()+"").collect(Collectors.joining(",")));
-            result.setYsYesCount(BigDecimal.valueOf(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
+            result.setYsYesCount(ztStory.stream().filter(o -> "active".equals(o.getStatus()))
                     .filter(o -> o.getStage().equals("verified"))
                     .filter(o -> o.getYsFlag() == 1)
-                    .count()));
+                    .map(o->o.getId()+"").collect(Collectors.joining(",")));
-            long bugCount = bugService.count(new QueryWrapper<ZtBug>().lambda().eq(ZtBug::getStatus, "active"));
+            List<ZtBug> active = bugService.list(new QueryWrapper<ZtBug>().lambda().eq(ZtBug::getStatus, "active"));
 
-            result.setBugCount(BigDecimal.valueOf(bugCount));
+            result.setBugCount(active.stream(). map(o->o.getId()+"").collect(Collectors.joining(",")));
+
+
+            List<ZtStoryFeedback> feedbacks = this.storyFeedbackService.list(new QueryWrapper<ZtStoryFeedback>()
+                    .lambda().ne(ZtStoryFeedback::getStatus, "closed")
+                    .in(ZtStoryFeedback::getProduct,pList.stream().map(o->o.getId()).collect(Collectors.toList()))
+
+            );
+
+            //问题反馈 未受理
+            result.setFeedbackWslCount(feedbacks.stream().filter(o->"wait".equals(o.getStatus())) .map(o->o.getId()+"").collect(Collectors.joining(",")));
+            //处理中的
+            result.setFeedbackClzCount(feedbacks.stream().filter(o->"doing".equals(o.getStatus())) .map(o->o.getId()+"").collect(Collectors.joining(",")));
+            //处理完的
+            result.setFeedbackClwCount(feedbacks.stream().filter(o->"finished".equals(o.getStatus())) .map(o->o.getId()+"").collect(Collectors.joining(",")));
+            //延期的
+            result.setFeedbackYqCount(feedbacks.stream().filter(o->o.getPlanFinishDate()!=null&&o.getPlanFinishDate().getTime()<new Date().getTime()) .map(o->o.getId()+"").collect(Collectors.joining(",")));
         }
 
 
@@ -237,19 +405,197 @@ public class IZtCountService {
             List<ProjectWorkDetailsDTO> workDetailsDTOS = projectWorkCount(qo,request,response);
 
             ByteArrayOutputStream os = new ByteArrayOutputStream();
-            EasyExcel.write(os, ProjectWorkDetailsDTO.class)
+//            ExcelWriter excelWriter = EasyExcel.write(os).build();
-                    .sheet("导出").doWrite(workDetailsDTOS);
 
+            WriteSheet 统计 = EasyExcel.writerSheet("统计").
+                    registerWriteHandler(new LongestMatchColumnWidthStyleStrategy())
+                    .needHead(Boolean.TRUE)
+                    .build();
+
+
+
+            List<WorkDetailsDTO> workDetailsDTOS1 = workDetailsCount(qo);
+
+            List<ProjectWorkTaskDTO> workTasks= workTaskCounts(qo);
+
+//            excelWriter.write(workDetailsDTOS, 统计, accountInfo);
+//            excelWriter.write(workDetailsDTOS1, 统计, tweetInfo);
+
+//            EasyExcel.write(os, ProjectWorkDetailsDTO.class)
+//                    .sheet("统计").doWrite(workDetailsDTOS);
 
             response.setContentType("application/vnd.ms-excel;charset=UTF-8");
-            response.getOutputStream().write(os.toByteArray());
+//            response.("Access-Control-Expose-Headers","Content-Disposition");//不设置该参数前端（vue）接收不到文件名
+//            response.setHeader("Content-disposition", "attachment;filename=" +  fileName + ".xlsx");
+
+            ServletOutputStream outputStream = response.getOutputStream();
+
+
+            ExcelWriter excelWriter = EasyExcel.write(response.getOutputStream())
+                    .  registerWriteHandler(new LongestMatchColumnWidthStyleStrategy())
+                    .needHead(Boolean.TRUE).build();
+            for (int i = 0; i < 3; i++) {
+
+                if(i==1){
+                    WriteSheet writeSheet = EasyExcel.writerSheet(i, "导出工作量")
+                          .head(ProjectWorkDetailsDTO.class)
+                            .needHead(Boolean.TRUE).build();
+                    excelWriter.write(workDetailsDTOS, writeSheet);
+                }
+                else   if(i==2){
+                    //任务
+                    WriteSheet writeSheet = EasyExcel.writerSheet(i, "任务统计")
+                            .head(ProjectWorkTaskDTO.class)
+                            .needHead(Boolean.TRUE).build();
+                    excelWriter.write(workTasks, writeSheet);
+                }
+                else{
+                    WriteSheet writeSheet = EasyExcel.writerSheet(i, "导出统计")
+                            .head(WorkDetailsDTO.class)
+                            .needHead(Boolean.TRUE).build();
+                    excelWriter.write(workDetailsDTOS1, writeSheet);
+                }
+
+            }
+            excelWriter.finish();
+
+
+
+
+
+
             response.getOutputStream().close();
             response.flushBuffer();
+
+
+
         }catch (Exception e){
             log.error("",e);
         }
     }
 
+    private List<ProjectWorkTaskDTO> workTaskCounts(ZtCountQo qo) {
+
+        Date d = qo.getDate();
+        int time = DateUtils.getWorkDaysInCurrentMonth(d) * 6;
+
+        if(d==null){
+            d=new Date();
+        }
+        Date firstDayOfMonth = DateUtils.getFirstDayOfMonth(d);
+        Date lastDayOfMonth = DateUtils.getLastDayOfMonth(d);
+
+        //产品集
+        Integer project = qo.getProject();
+        List<ZtProduct> productList = this.productService.list(new QueryWrapper<ZtProduct>().lambda().eq(ZtProduct::getProgram, project));
+        if (CollectionUtils.isEmpty(productList)) {
+            return new ArrayList<>();
+        }
+        List<ZtProjectproduct> projectproducts = this.projectproductService.list(new QueryWrapper<ZtProjectproduct>().lambda()
+                .in(ZtProjectproduct::getProduct, productList.stream().map(o -> o.getId()).collect(Collectors.toList())));
+        if (CollectionUtils.isEmpty(projectproducts)) {
+            return new ArrayList<>();
+        }
+
+
+        List<ZtExecutionproject> list = executionprojectService.list(new QueryWrapper<ZtExecutionproject>().lambda()
+                .in(ZtExecutionproject::getProject, projectproducts.stream().map(o->o.getProject()).collect(Collectors.toList())));
+        if (CollectionUtils.isEmpty(list)) {
+            return new ArrayList<>();
+        }
+        List<ZtProject> ztProjects = this.projectService.listByIds(list.stream().map(o -> o.getExecution()).collect(Collectors.toList()));
+        if (CollectionUtils.isEmpty(ztProjects)) {
+            return new ArrayList<>();
+        }
+        List<Integer> executionIds = ztProjects.stream().map(o -> o.getId()).collect(Collectors.toList());
+        //所有任务
+        List<ZtTask> taskList = this.taskService.list(new QueryWrapper<ZtTask>().lambda().in(ZtTask::getExecution, executionIds));
+        if (CollectionUtils.isEmpty(taskList)) {
+            return new ArrayList<>();
+        }
+        taskList = taskList.stream()
+                .filter(o ->
+                                (       o.getFinishedDate()!=null&& (o.getFinishedDate().getTime() >= firstDayOfMonth.getTime() && o.getFinishedDate().getTime() <= lastDayOfMonth.getTime()))
+                        ||
+                                        (o.getEstStarted()!=null&&o.getDeadline()!=null)&&
+                                         ((  o.getDeadline().getTime()<=lastDayOfMonth.getTime()&&   o.getDeadline().getTime()>=firstDayOfMonth.getTime())
+                                        ||
+                                        (  o.getEstStarted().getTime()<=lastDayOfMonth.getTime()&&   o.getEstStarted().getTime()>=firstDayOfMonth.getTime()))
+
+//                                || (o.getDeadline().getTime() >=firstDayOfMonth.getTime() && o.getDeadline().getTime() <= lastDayOfMonth.getTime())
+//                        || (o.getEstStarted().getTime()<=firstDayOfMonth.getTime() && o.getDeadline().getTime() > firstDayOfMonth.getTime())
+                ).collect(Collectors.toList());
+
+        if(CollectionUtils.isEmpty(taskList)){
+            return new ArrayList<>();
+        }
+        List<ProjectWorkTaskDTO> result=new ArrayList();
+
+        Map<Integer,ZtStory> storyMap=storyMap(taskList);
+        Map<String, ZtUser> userMap = this.userService.userMapByIds(null);
+
+
+
+
+        for (ZtTask t:taskList) {
+            ProjectWorkTaskDTO    dto=new ProjectWorkTaskDTO();
+
+            dto.setTaskId(t.getId());
+            dto.setStoryId(t.getStory());
+            dto.setTaskName(t.getName());
+            List<ZtProject> execList = ztProjects.stream().filter(o -> o.getId().intValue() == t.getExecution().intValue()).collect(Collectors.toList());
+            dto.setExecName(execList.get(0).getName());
+            dto.setExecStartDate(DateUtils.formatDate(t.getEstStarted()));
+            dto.setExecEndDate(DateUtils.formatDate(t.getDeadline()));
+
+            dto.setStoryName(t.getStory()==0?"0":storyMap.get(t.getStory()).getTitle());
+
+            dto.setTypeName(TaskType.transferType(t.getType())==null?"":TaskType.transferType(t.getType()).getValue());
+            ZtUser ztUser = userMap.get(t.getAssignedTo());
+
+
+            dto.setAssignedTo(ztUser==null?null:ztUser.getNickname());
+
+            dto.setWorkTime(t.getConsumed());
+            dto.setPlanTime(t.getEstimate());
+            dto.setBalanceTime(BigDecimal.valueOf(t.getEstimate()).subtract(BigDecimal.valueOf(t.getConsumed())).setScale(2,BigDecimal.ROUND_HALF_UP).floatValue());
+            dto.setStatus(TaskStatus.transferType(t.getStatus())==null?"":TaskStatus.transferType(t.getStatus()).getValue());
+
+
+            dto.setStartDate(DateUtils.formatDate(t.getRealstarted()));
+            dto.setEndDate(DateUtils.formatDate(t.getFinishedDate()));
+            dto.setKeepTime(t.getFinishedDate()==null?(DateUtils.daysBetween(t.getRealstarted(),t.getFinishedDate())):(DateUtils.daysBetween(t.getEstStarted(),t.getDeadline())));
+
+            result.add(dto);
+        }
+        return result;
+    }
+
+
+    private Map<Integer, ZtStory> storyMap(List<ZtTask> taskList) {
+        List<ZtTask> fTaskList = taskList.stream().filter(o -> o.getStory() != null && o.getStory() != 0).collect(Collectors.toList());
+        if(CollectionUtils.isEmpty(fTaskList)){
+            return new HashMap<>();
+        }
+        List<ZtStory> ztStories = this.storyService.listByIds(fTaskList.stream().map(o->o.getStory()).collect(Collectors.toList()));
+        return ztStories.stream().collect(Collectors.toMap(ZtStory::getId,o->o));
+    }
+
+    private List<List<String>> head() {
+        List<List<String>> list = new ArrayList<>();
+        List<String> head0 = new ArrayList<>();
+        head0.add("字符串" );
+        List<String> head1 = new ArrayList<>();
+        head1.add("数字" );
+        List<String> head2 = new ArrayList<>();
+        head2.add("日期" );
+        list.add(head0);
+        list.add(head1);
+        list.add(head2);
+        return list;
+
+    }
+
     private List<Integer> getStoryIds(Integer project) {
         List<ZtProjectstory> list1 = this.projectstoryService.list(new QueryWrapper<ZtProjectstory>().lambda()
                 .eq(ZtProjectstory::getProject, project)
@@ -261,10 +607,22 @@ public class IZtCountService {
         Date d = qo.getDate();
         Date firstDayOfMonth = DateUtils.getFirstDayOfMonth(d);
         Date lastDayOfMonth = DateUtils.getLastDayOfMonth(d);
-
-        List<ZtProject> pList = this.projectService.list(new QueryWrapper<ZtProject>().lambda().eq(ZtProject::getStatus, "doing").eq(ZtProject::getType, "project"));
-
         List<ProjectWorkDetailsDTO> result=new ArrayList<>();
+        //产品集id
+        Integer pId = qo.getProject();
+
+        List<ZtProduct> productList = this.productService.list(new QueryWrapper<ZtProduct>().lambda().eq(ZtProduct::getProgram, pId));
+        if(CollectionUtils.isEmpty(productList)){
+            return result;
+        }
+        List<ZtProjectproduct> projectproducts = this.projectproductService.list(new QueryWrapper<ZtProjectproduct>().lambda().in(ZtProjectproduct::getProduct, productList.stream().map(o -> o.getId()).collect(Collectors.toList())));
+        if(CollectionUtils.isEmpty(projectproducts)){
+            return result;
+        }
+
+        List<ZtProject> pList = this.projectService.listByIds(projectproducts.stream().map(o->o.getProject()).collect(Collectors.toList()));
+
+
 
         for (ZtProject p:pList) {
 
@@ -312,7 +670,7 @@ public class IZtCountService {
             dto.setFinishCount(finishStoryList.size());
             //完成任务总量
             List<ZtTask> taskList = CollectionUtils.isEmpty(storyList)?new ArrayList<>():this.taskService.list(new QueryWrapper<ZtTask>().lambda()
-                    .in(ZtTask::getStory, storyList.stream().map(o -> o.getStory()).collect(Collectors.toList())));
+                    .in(ZtTask::getExecution, list.stream().map(o -> o.getExecution()).collect(Collectors.toList())));
             // 完成后可能会被关闭
             List<ZtTask> done = taskList.stream().filter(o -> o.getStatus().equals("done")||o.getStatus().equals("closed"))
                     .filter(o->o.getFinishedDate()!=null&&(firstDayOfMonth.getTime()<=o.getFinishedDate().getTime()&&
@@ -320,11 +678,14 @@ public class IZtCountService {
             dto.setFinishTaskCount(done.size());
             //完成需求总工时
 //        double sum = taskList.stream().map(o -> o.getEstimate()).mapToDouble(e -> Double.valueOf(e)).sum();
-            double sum =  done.stream().map(o->o.getEstimate()).mapToDouble(e -> Double.valueOf(e)).sum();
+            List<Float> fList = done.stream().map(o -> o.getEstimate()).collect(Collectors.toList());
-            dto.setStoryTotalTime(BigDecimal.valueOf(sum));
+
+
+
+            dto.setStoryTotalTime(floatBatchAdd(fList));
             //实际产出工时
-            double sum2 = done.stream().map(o -> o.getConsumed()).mapToDouble(e -> Double.valueOf(e)).sum();
+            fList = done.stream().map(o -> o.getConsumed()).collect(Collectors.toList());
-            dto.setUseStoryTotalTime(BigDecimal.valueOf(sum2));
+            dto.setUseStoryTotalTime(floatBatchAdd(fList));
 //        上月剩余未完成需求量
 
 //        上月未完成需求量预计工时
@@ -353,6 +714,17 @@ public class IZtCountService {
         return result;
     }
 
+    private BigDecimal floatBatchAdd(List<Float> list){
+        BigDecimal f=BigDecimal.ZERO;
+        for (Float i:list ) {
+            f=f.add(BigDecimal.valueOf(i));
+        }
+        BigDecimal decimal = f.setScale(2, BigDecimal.ROUND_HALF_UP);
+
+        return decimal;
+    }
+
+
     public List<WorkDetailsDTO> workDetailsCount(ZtCountQo qo) {
 
 
@@ -365,10 +737,21 @@ public class IZtCountService {
         Date firstDayOfMonth = DateUtils.getFirstDayOfMonth(d);
         Date lastDayOfMonth = DateUtils.getLastDayOfMonth(d);
 
-        //项目id
+        //产品集
         Integer project = qo.getProject();
+        List<ZtProduct> productList = this.productService.list(new QueryWrapper<ZtProduct>().lambda().eq(ZtProduct::getProgram, project));
+        if (CollectionUtils.isEmpty(productList)) {
+            return new ArrayList<>();
+        }
+        List<ZtProjectproduct> projectproducts = this.projectproductService.list(new QueryWrapper<ZtProjectproduct>().lambda()
+                .in(ZtProjectproduct::getProduct, productList.stream().map(o -> o.getId()).collect(Collectors.toList())));
+        if (CollectionUtils.isEmpty(projectproducts)) {
+            return new ArrayList<>();
+        }
+
+
         List<ZtExecutionproject> list = executionprojectService.list(new QueryWrapper<ZtExecutionproject>().lambda()
-                .eq(ZtExecutionproject::getProject, project));
+                .in(ZtExecutionproject::getProject, projectproducts.stream().map(o->o.getProject()).collect(Collectors.toList())));
         if (CollectionUtils.isEmpty(list)) {
             return new ArrayList<>();
         }
@@ -416,9 +799,9 @@ public class IZtCountService {
             dto.setUserName(u.getNickname());
             dto.setTaskCount(BigDecimal.valueOf(taskList.stream().filter(o -> o.getAssignedTo().equals(u.getAccount())).count()));
             //预计工时
-            dto.setStoryTotalTime(BigDecimal.valueOf(fTask.stream().map(o -> o.getEstimate()).mapToDouble(e -> Double.valueOf(e)).sum()));
+            dto.setStoryTotalTime(floatBatchAdd(fTask.stream().map(o -> o.getEstimate()).collect(Collectors.toList())));
 //
-            dto.setWorkTime(BigDecimal.valueOf(fTask.stream().map(o -> o.getConsumed()).mapToDouble(e -> Double.valueOf(e)).sum()));
+            dto.setWorkTime(floatBatchAdd(fTask.stream().map(o -> o.getConsumed()).collect(Collectors.toList())));
 //            6*实际工作天数
             dto.setHaveTime(BigDecimal.valueOf(time));
             dto.setSaturation(dto.getWorkTime().compareTo(BigDecimal.ZERO)==0?BigDecimal.ZERO:dto.getWorkTime().divide(dto.getHaveTime(),2,BigDecimal.ROUND_HALF_UP));
@@ -433,13 +816,27 @@ public class IZtCountService {
     }
 
     public Object projectInfoById(Integer id) {
-
-        ZtProject byId = this.projectService.getById(id);
-
-        List<ZtProjectstory> list = this.projectstoryService.list(new QueryWrapper<ZtProjectstory>().lambda()
-                .eq(ZtProjectstory::getProject, id));
         Map<Object,Object> map=new HashMap<>();
         Map<Object,Object> objMap=new HashMap<>();
+        //产品集
+        ZtProject project = this.projectService.getById(id);
+        //产品集下所有产品
+        List<ZtProduct> products = this.productService.list(new QueryWrapper<ZtProduct>().lambda().eq(ZtProduct::getProgram, project.getId()));
+        if(CollectionUtils.isEmpty(products)){
+            return zeroMap(map,objMap);
+        }
+        //项目列表
+        List<ZtProjectproduct> projectList = this.projectproductService.list(new QueryWrapper<ZtProjectproduct>().lambda()
+                .in(ZtProjectproduct::getProduct, products.stream().map(o -> o.getId()).collect(Collectors.toList())));
+        if(CollectionUtils.isEmpty(projectList)){
+            return zeroMap(map,objMap);
+        }
+
+
+        List<ZtProjectstory> list = this.projectstoryService.list(new QueryWrapper<ZtProjectstory>().lambda()
+                .in(ZtProjectstory::getProject, projectList.stream().map(o->o.getProject()).collect(Collectors.toList())));
+
+
         if(CollectionUtils.isEmpty(list)){
             return zeroMap(map,objMap);
         }
@@ -456,9 +853,16 @@ public class IZtCountService {
         objMap.put("balance",count-finish);
         map.put("story",objMap);
 
-        //项目成员  项目迭代下所有人员
+        //项目成员  项目迭代下所有人员  projectList 项目列表
+        List<ZtExecutionproject> exexList = this.executionprojectService.list(new QueryWrapper<ZtExecutionproject>().lambda()
+                .in(ZtExecutionproject::getProject, projectList.stream().map(o -> o.getProject()).collect(Collectors.toList())));
 
-        List<ZtTask> taskList = this.taskService.list(new QueryWrapper<ZtTask>().lambda().in(ZtTask::getStory, ztStories.stream().map(o -> o.getId()).collect(Collectors.toList())));
+        if(CollectionUtils.isEmpty(exexList)){
+            return zeroTaskMap(map,objMap);
+        }
+
+        List<ZtTask> taskList = this.taskService.list(new QueryWrapper<ZtTask>().lambda()
+                .in(ZtTask::getExecution, exexList.stream().map(o -> o.getExecution()).collect(Collectors.toList())));
         if(CollectionUtils.isEmpty(taskList)){
             return zeroTaskMap(map,objMap);
         }
@@ -466,9 +870,15 @@ public class IZtCountService {
 
         objMap=new HashMap<>();
         objMap.put("totalUser",taskList.stream().map(o->o.getAssignedTo()).distinct().count());
-        objMap.put("planTime",taskList.stream().map(o->o.getEstimate()).mapToDouble(e->Double.valueOf(e)).sum());
+        double planTime = taskList.stream().map(o -> o.getEstimate()).mapToDouble(e -> Double.valueOf(e)).sum();
-        objMap.put("useTime",taskList.stream().map(o->o.getConsumed()).mapToDouble(e->Double.valueOf(e)).sum());
+        planTime=planTime>0?new BigDecimal(planTime).setScale(1, RoundingMode.HALF_UP).doubleValue():planTime;
+        objMap.put("planTime",planTime);
+        double useTime =taskList.stream().map(o->o.getConsumed()).mapToDouble(e->Double.valueOf(e)).sum();
+        useTime=useTime>0?new BigDecimal(useTime).setScale(1, RoundingMode.HALF_UP).doubleValue():useTime;
+         objMap.put("useTime",useTime);
         map.put("zy",objMap);
+
+
         objMap=new HashMap<>();
 
         objMap.put("wait",taskList.stream().filter(o->"wait".equals(o.getStatus())).count());
@@ -538,6 +948,8 @@ public class IZtCountService {
         objMap.put("wait",0);
         objMap.put("process",0);
         objMap.put("finish",0);
+        objMap.put("totalCount",0);
+
         map.put("task",objMap);
         objMap=new HashMap<>();
         objMap.put("totalBug",0);
@@ -545,6 +957,14 @@ public class IZtCountService {
         objMap.put("noSolve",0);
         map.put("bug",objMap);
 
+
+        objMap=new HashMap<>();
+        objMap.put("online",0);
+        objMap.put("ysAll",0);
+        objMap.put("ysNo",0);
+        map.put("ys",objMap);
+
+
         return map;
     }
 
@@ -569,4 +989,52 @@ public class IZtCountService {
             log.error("",e);
         }
     }
+
+    @Autowired
+    private IZtStoryUserService storyUserService;
+
+    @Autowired
+    private IZtStoryFeedbackService storyFeedbackService;
+
+    public ZtStoryCountDTO storyFeedbackCount(ZtCaseDTO dto) {
+        LoginRiskUser loginRiskUser = RiskUserThreadLocal.get();
+        UserType userType = RiskUserThreadLocal.get().getUserType();
+        if(UserType.XMGLY==userType){
+            //查询产品集的需求
+        }else if(UserType.GSGC==userType||loginRiskUser.getName().equals("admin")){
+            //查询所有的
+        }
+        return null;
+    }
+
+    public List<ZtStoryDTO> myStoryList(ZtProjectQo qo) {
+
+        return this.storyService.myStoryList(qo);
+    }
+
+    public List<ZtStoryFeedbackDTO> ztStoryFeedbackDTO(ZtProjectQo qo) {
+        return  this.storyFeedbackService.ztStoryFeedbackDTO(qo);
+    }
+
+    public PageInfo<ZtStoryFeedbackDTO> myFeedbackPageList(ZtProjectQo qo) {
+        return storyFeedbackService.myFeedbackPageList(qo);
+    }
+
+    public List<ZtTaskDTO> myTaskList(ZtProjectQo qo) {
+        return this.taskService.myTaskList(qo);
+    }
+
+    public List<ZtYwTaskDTO> myYwList(ZtProjectQo qo) {
+        return this.ywTaskService.ywTaskService(qo);
+
+    }
+
+    public List<ZtCronDevopsDTO> myDevops(ZtProjectQo qo) {
+        ZtUserQo dto=new ZtUserQo();
+        dto.setCurrentPage(1);
+        dto.setPageSize(10000);
+        return cronDevopsService.pageList(dto).getList();
+    }
+
+
 }

src/main/java/com/sa/zentao/service/impl/ZtActionServiceImpl.java

@@ -89,6 +89,8 @@ public class ZtActionServiceImpl extends ServiceImpl<ZtActionMapper, ZtAction> i
     @Override
     public List<ZtActionDTO> actionList(ActionQo qo) {
 
+        Map<String, ZtUser> userMap = this.userService.userMapByIds(null);
+
         ActionType type = qo.getType();
 
         Integer id = qo.getId();
@@ -102,6 +104,15 @@ public class ZtActionServiceImpl extends ServiceImpl<ZtActionMapper, ZtAction> i
             List<ZtActionDTO> ztActionDTOS = BeanCopyUtil.copyListProperties(list, ZtActionDTO::new);
 
             for (ZtActionDTO dto:ztActionDTOS) {
+
+                ZtUser ztUser = userMap.get(dto.getExtra());
+                if(ztUser!=null){
+                    dto.setExtra(ztUser.getNickname());
+                }
+                 ztUser = userMap.get(dto.getActor());
+                if(ztUser!=null){
+                    dto.setActor(ztUser.getNickname());
+                }
                 dto.setActionValue(ActionStatus.valueForDesc(dto.getAction()));
             }
             return ztActionDTOS;
@@ -130,7 +141,9 @@ public class ZtActionServiceImpl extends ServiceImpl<ZtActionMapper, ZtAction> i
                 s.setActionValue(ActionStatus.valueForDesc(t.getAction()));
                 if(ActionType.XQ.getValue().equals(t.getObjecttype())){
                     ZtStory story = storyService.getById(t.getObjectid());
-                    s.setActionValue("需求:"+story.getTitle()+"-"+s.getActionValue());
+                    if(story!=null){
+                        s.setActionValue("需求:"+story.getTitle()+"-"+s.getActionValue());
+                    }
                 }
                 if(ActionType.RW.getValue().equals(t.getObjecttype())){
                     ZtTask task = taskService.getById(t.getObjectid());

src/main/java/com/sa/zentao/service/impl/ZtBugServiceImpl.java

@@ -5,13 +5,17 @@ import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.github.pagehelper.Page;
 import com.github.pagehelper.PageHelper;
 import com.github.pagehelper.PageInfo;
+import com.sa.zentao.conf.LoginRiskUser;
 import com.sa.zentao.conf.RiskUserThreadLocal;
 import com.sa.zentao.dao.BusinessException;
 import com.sa.zentao.dao.ZtBugDTO;
 import com.sa.zentao.dao.ZtCaseDTO;
+import com.sa.zentao.dao.ZtTaskDTO;
 import com.sa.zentao.entity.*;
 import com.sa.zentao.enums.ActionStatus;
 import com.sa.zentao.enums.ActionType;
+import com.sa.zentao.enums.FileTypes;
+import com.sa.zentao.enums.UserType;
 import com.sa.zentao.mapper.ZtBugMapper;
 import com.sa.zentao.qo.ZtBugQo;
 import com.sa.zentao.qo.ZtProjectQo;
@@ -24,10 +28,7 @@ import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.util.CollectionUtils;
 
-import java.util.Arrays;
+import java.util.*;
-import java.util.Date;
-import java.util.List;
-import java.util.Map;
 import java.util.stream.Collectors;
 
 /**
@@ -51,59 +52,22 @@ public class ZtBugServiceImpl extends ServiceImpl<ZtBugMapper, ZtBug> implements
     @Autowired
     private IZtUserService userService;
 
-    @Override
-    public PageInfo<ZtBugDTO> bugPageList(ZtProjectQo qo) {
-        Page<ZtBugDTO> page = PageHelper.startPage(qo.getCurrentPage(), qo.getPageSize());
-        qo.setUserName(RiskUserThreadLocal.get().getName());
-        List<ZtBugDTO> result = this.baseMapper.bugPageList(qo);
-        if(!CollectionUtils.isEmpty(result)){
-            List<String> fIds = result.stream().map(o -> o.getOpenedby()).collect(Collectors.toList());
-            fIds.addAll(result.stream().map(o->o.getAssignedto()).collect(Collectors.toList()));
-            Map<String, ZtUser> userMap = userService.userMapByIds(fIds);
 
-            for (ZtBugDTO bug:result ) {
+    @Autowired
+    private IZtProjectstoryService projectstoryService;
 
-                ZtUser ztUser = userMap.get(bug.getOpenedby());
+    @Autowired
-                if(ztUser!=null){
+    private IZtStoryService storyService;
-                    bug.setOpenedbyName(ztUser.getNickname());
-                }
-                ztUser = userMap.get(bug.getAssignedto());
 
-                if(ztUser!=null){
+    @Autowired
-                    bug.setAssignedtoName(ztUser.getNickname());
+    private IZtFileService fileService;
-                }
+    @Autowired
+    private IZtProjectService ztProjectService;
 
-            }
+    @Autowired
-        }
+    private IZtProductService productService;
-        return new PageInfo<ZtBugDTO>(result);
+    @Autowired
-    }
+    private IZtProjectproductService projectproductService;
-
-    @Override
-    public PageInfo<ZtBugDTO> myBugPageList(ZtProjectQo qo) {
-        Page<ZtBugDTO> page = PageHelper.startPage(qo.getCurrentPage(), qo.getPageSize());
-        qo.setUserName(RiskUserThreadLocal.get().getName());
-        List<ZtBugDTO> result = this.baseMapper.myBugPageList(qo);
-        if(!CollectionUtils.isEmpty(result)){
-            List<String> fIds = result.stream().map(o -> o.getOpenedby()).collect(Collectors.toList());
-            fIds.addAll(result.stream().map(o->o.getAssignedto()).collect(Collectors.toList()));
-            Map<String, ZtUser> userMap = userService.userMapByIds(fIds);
-
-            for (ZtBugDTO bug:result ) {
-
-                ZtUser ztUser = userMap.get(bug.getOpenedby());
-                if(ztUser!=null){
-                    bug.setOpenedbyName(ztUser.getNickname());
-                }
-                ztUser = userMap.get(bug.getAssignedto());
-
-                if(ztUser!=null){
-                    bug.setAssignedtoName(ztUser.getNickname());
-                }
-
-            }
-        }
-        return new PageInfo<ZtBugDTO>(result);
-    }
 
     @Autowired
     private IZtProjectService projectService;
@@ -112,9 +76,107 @@ public class ZtBugServiceImpl extends ServiceImpl<ZtBugMapper, ZtBug> implements
     private IZtTaskService taskService;
 
 
+    @Override
+    public PageInfo<ZtBugDTO> bugPageList(ZtProjectQo qo) {
+        Page<ZtBugDTO> page = PageHelper.startPage(qo.getCurrentPage(), qo.getPageSize());
+        qo.setUserName(RiskUserThreadLocal.get().getName());
+        List<ZtBugDTO> result = this.baseMapper.bugPageList(qo);
+        if(!CollectionUtils.isEmpty(result)){
+            List<String> fIds = result.stream().map(o -> o.getOpenedby()).collect(Collectors.toList());
+            fIds.addAll(result.stream().map(o->o.getAssignedTo()).collect(Collectors.toList()));
+            Map<String, ZtUser> userMap = userService.userMapByIds(fIds);
+
+            for (ZtBugDTO bug:result ) {
+
+                ZtUser ztUser = userMap.get(bug.getOpenedby());
+                if(ztUser!=null){
+                    bug.setOpenedbyName(ztUser.getNickname());
+                }
+                ztUser = userMap.get(bug.getAssignedTo());
+
+                if(ztUser!=null){
+                    bug.setAssignedToName(ztUser.getNickname());
+                }
+
+            }
+        }
+        return new PageInfo<ZtBugDTO>(result);
+    }
+
+
+    @Override
+    public PageInfo<ZtBugDTO> myBugPageList(ZtProjectQo qo) {
+
+        qo.setUserName(RiskUserThreadLocal.get().getName());
+        LoginRiskUser loginRiskUser = RiskUserThreadLocal.get();
+        //执行ids
+        List<Integer> projectAuthList=new ArrayList<>();
+        if(UserType.GSGC!=loginRiskUser.getUserType()){
+
+
+            //自己有权限的  产品集
+            List<Integer> integers = this.ztProjectService.authList();
+
+            if(!CollectionUtils.isEmpty(integers)){
+                List<ZtProduct> pList = this.productService.list(new QueryWrapper<ZtProduct>().lambda().in(ZtProduct::getProgram, integers));
+                //所有的产品
+                if(!CollectionUtils.isEmpty(pList)){
+                    List<ZtProjectproduct> list = this.projectproductService.list(new QueryWrapper<ZtProjectproduct>().lambda().in(ZtProjectproduct::getProduct, pList.stream().map(o -> o.getId()).collect(Collectors.toList())));
+
+                    if(!CollectionUtils.isEmpty(list)){
+                        projectAuthList=list.stream().map(o->o.getProject()).collect(Collectors.toList());
+
+                    }
+                }
+            }
+        }
+        if(UserType.GSGC!=loginRiskUser.getUserType()&&CollectionUtils.isEmpty(projectAuthList)){
+            return new PageInfo<ZtBugDTO>();
+        }
+
+
+        qo.setProjectIds(projectAuthList);
+        Page<ZtBugDTO> page = PageHelper.startPage(qo.getCurrentPage(), qo.getPageSize());
+        qo.setUserName(RiskUserThreadLocal.get().getName());
+
+        if(!StringUtils.isEmpty(qo.getIds())){
+            String[] split = qo.getIds().split(",");
+            qo.setObjIds(new ArrayList<>(Arrays.asList(split)));
+        }
+
+
+        List<ZtBugDTO> result = this.baseMapper.myBugPageList(qo);
+        if(!CollectionUtils.isEmpty(result)){
+            List<String> fIds = result.stream().map(o -> o.getOpenedby()).collect(Collectors.toList());
+            fIds.addAll(result.stream().map(o->o.getAssignedTo()).collect(Collectors.toList()));
+            Map<String, ZtUser> userMap = userService.userMapByIds(fIds);
+
+            for (ZtBugDTO bug:result ) {
+
+                ZtUser ztUser = userMap.get(bug.getOpenedby());
+                if(ztUser!=null){
+                    bug.setOpenedbyName(ztUser.getNickname());
+                }
+                ztUser = userMap.get(bug.getAssignedTo());
+
+                if(ztUser!=null){
+                    bug.setAssignedToName(ztUser.getNickname());
+                }
+
+            }
+        }
+        return new PageInfo<ZtBugDTO>(result);
+    }
+
+
+
+
     @Override
     public ZtBugDTO bugInfoById(Integer id) {
         ZtBug ztBug = this.getById(id);
+        if(ztBug==null){
+            throw new BusinessException("未查询到数据");
+        }
 
         Integer project = ztBug.getProject();
 
@@ -141,11 +203,22 @@ public class ZtBugServiceImpl extends ServiceImpl<ZtBugMapper, ZtBug> implements
         return d;
     }
 
-    @Autowired
+    @Override
-    private IZtProjectstoryService projectstoryService;
+    @Transactional
+    public void assignedTo(ZtBugQo qo) {
+        ZtBug ztBug = this.baseMapper.selectById(qo.getId());
+        if(ztBug==null){
+            throw new BusinessException("未查询到");
+        }
+        ztBug.setAssignedTo(qo.getAssignedTo());
+        ztBug.setLasteditedby(RiskUserThreadLocal.get().getName());
+        ztBug.setLastediteddate(new Date());
+        this.baseMapper.updateById(ztBug);
+        this.actionService.addAction(ActionType.BUG, ActionStatus.FP,ztBug.getId(),ztBug.getProject()+"",ztBug.getProject(),ztBug.getExecution()
+                ,RiskUserThreadLocal.get().getName(),ztBug.getSteps(),""
+        );
+    }
 
-    @Autowired
-    private IZtStoryService storyService;
 
 
     @Override
@@ -170,16 +243,23 @@ public class ZtBugServiceImpl extends ServiceImpl<ZtBugMapper, ZtBug> implements
 
 
         }
+
         this.baseMapper.insert(ztBug);
+        fileService.updateFile(dto.getFiles(),ztBug.getId(), FileTypes.bug);
         if(dto.getExecution()!=null&&dto.getExecution()!=0){
             kanbanlaneService.addBug(dto.getExecution(), Arrays.asList(ztBug));
         }
+        Integer tostory = ztBug.getTostory();
+
+
+
         this.actionService.addAction(ActionType.BUG, ActionStatus.XJ,ztBug.getId(),ztBug.getProject()+"",ztBug.getProject(),ztBug.getExecution()
                 ,RiskUserThreadLocal.get().getName(),ztBug.getSteps(),""
         );
     }
 
     @Override
+    @Transactional
     public void editBug(ZtBugDTO dto) {
         ZtBug ztBug = this.baseMapper.selectById(dto.getId());
         BeanUtils.copyProperties(dto,ztBug,"execution");
@@ -189,6 +269,9 @@ public class ZtBugServiceImpl extends ServiceImpl<ZtBugMapper, ZtBug> implements
         ztBug.setLastediteddate(new Date());
         ztBug.setStatus("active");
         this.baseMapper.updateById(ztBug);
+
+        fileService.updateFile(dto.getFiles(),ztBug.getId(), FileTypes.bug);
+
         this.actionService.addAction(ActionType.BUG, ActionStatus.BJ,ztBug.getId(),ztBug.getProject()+"",ztBug.getProject(),ztBug.getExecution()
                 ,RiskUserThreadLocal.get().getName(),ztBug.getSteps(),""
         );
@@ -200,8 +283,8 @@ public class ZtBugServiceImpl extends ServiceImpl<ZtBugMapper, ZtBug> implements
         Integer id = qo.getId();
         //bug
         ZtBug ztBug = this.baseMapper.selectById(id);
-        if(!StringUtils.isEmpty(qo.getAssignedto())){
+        if(!StringUtils.isEmpty(qo.getAssignedTo())){
-            ztBug.setAssignedto(qo.getAssignedto());
+            ztBug.setAssignedTo(qo.getAssignedTo());
         }
         if("confirmed".equalsIgnoreCase(qo.getStatus())){
             //
@@ -266,18 +349,22 @@ public class ZtBugServiceImpl extends ServiceImpl<ZtBugMapper, ZtBug> implements
         ztBug.setResolvedby(RiskUserThreadLocal.get().getName());
         ztBug.setResolution(dto.getResolution());
         ztBug.setResolveddate(new Date());
-        ztBug.setAssignedto(dto.getAssignedto());
+        ztBug.setAssignedTo(dto.getAssignedTo());
         this.baseMapper.updateById(ztBug);
         if(ztBug.getExecution()!=null&&ztBug.getExecution()!=0) {
             kanbanlaneService.changeStatus(ztBug.getExecution(), ztBug.getId(), "bug", "fixed");
         }
 
+
+
+
         this.actionService.addAction(ActionType.BUG, ActionStatus.WC,ztBug.getId(),ztBug.getProject()+"",ztBug.getProject(),ztBug.getExecution()
         ,RiskUserThreadLocal.get().getName(),dto.getRemark(),""
         );
     }
 
     @Override
+    @Transactional
     public void reActive(ZtBugDTO dto) {
         ZtBug ztBug = this.baseMapper.selectById(dto.getId());
         if(ztBug.getStatus().equals("closed")){
@@ -288,7 +375,7 @@ public class ZtBugServiceImpl extends ServiceImpl<ZtBugMapper, ZtBug> implements
         ztBug.setLasteditedby(RiskUserThreadLocal.get().getName());
         this.baseMapper.updateById(ztBug);
         if(ztBug.getExecution()!=null&&ztBug.getExecution()!=0) {
-            kanbanlaneService.changeStatus(ztBug.getExecution(), ztBug.getId(), "bug", "resolving");
+            kanbanlaneService.changeStatus(ztBug.getExecution(), ztBug.getId(), "bug", "fixing");
         }
 
         this.actionService.addAction(ActionType.BUG, ActionStatus.JH,ztBug.getId(),ztBug.getProject()+"",ztBug.getProject(),ztBug.getExecution()

src/main/java/com/sa/zentao/service/impl/ZtEffortServiceImpl.java

@@ -137,10 +137,16 @@ public class ZtEffortServiceImpl extends ServiceImpl<ZtEffortMapper, ZtEffort> i
                     .equals(s)).collect(Collectors.toList());
 
 
-            map.put(s,collect.stream().map(o -> o.getConsumed()).reduce(0F, (a, b) -> a + b)+"");
+            map.put(s,collect.stream().map(o -> o.getConsumed()).reduce(0F, (a, b) -> fAdd(a,b))+"");
 
         }
 
         return map;
     }
+
+    private Float fAdd(Float a,Float b){
+        BigDecimal f1 = BigDecimal.valueOf(a);
+        BigDecimal f2 = BigDecimal.valueOf(b);
+        return f1.add(f1).setScale(2,BigDecimal.ROUND_HALF_UP).floatValue();
+    }
 }

src/main/java/com/sa/zentao/service/impl/ZtFileServiceImpl.java

@@ -0,0 +1,53 @@
+package com.sa.zentao.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
+import com.sa.zentao.entity.ZtFile;
+import com.sa.zentao.enums.FileTypes;
+import com.sa.zentao.mapper.ZtFileMapper;
+import com.sa.zentao.service.IZtFileService;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * <p>
+ *  服务实现类
+ * </p>
+ *
+ * @author gqb
+ * @since 2024-12-20
+ */
+@Service
+public class ZtFileServiceImpl extends ServiceImpl<ZtFileMapper, ZtFile> implements IZtFileService {
+
+    @Override
+    @Transactional
+    public void updateFile(String fileIds, Integer objectId, FileTypes type) {
+        if(StringUtils.isEmpty(fileIds)){
+            return;
+        }
+        String[] split = fileIds.split(",");
+        if(split==null||split.length==0){
+            return;
+        }
+        this.baseMapper.update(new UpdateWrapper<ZtFile>()
+        .lambda().set(ZtFile::getDeleted,"1")
+                        .notIn(ZtFile::getId,split)
+                        .eq(ZtFile::getObjectid,objectId).eq(ZtFile::getObjecttype,type.getCode())
+
+        );
+        List<ZtFile> ztFiles = this.baseMapper.selectBatchIds(Arrays.asList(split));
+        for (ZtFile f:ztFiles) {
+            f.setObjectid(objectId);
+            f.setObjecttype(type.getCode());
+        }
+        this.saveOrUpdateBatch(ztFiles);
+
+    }
+}

src/main/java/com/sa/zentao/service/impl/ZtKanbanlaneServiceImpl.java

@@ -5,6 +5,7 @@ import com.sa.zentao.conf.RiskUserThreadLocal;
 import com.sa.zentao.dao.Result;
 import com.sa.zentao.dao.ZtKanbancolumnDTO;
 import com.sa.zentao.dao.ZtKanbanlaneDTO;
+import com.sa.zentao.dao.ZtStoryDTO;
 import com.sa.zentao.entity.*;
 import com.sa.zentao.enums.ActionStatus;
 import com.sa.zentao.enums.ActionType;
@@ -19,11 +20,13 @@ import com.sa.zentao.utils.KanBanConstant;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 import org.springframework.util.CollectionUtils;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Map;
 import java.util.stream.Collectors;
 
 /**
@@ -44,6 +47,10 @@ public class ZtKanbanlaneServiceImpl extends ServiceImpl<ZtKanbanlaneMapper, ZtK
 
     @Autowired
     private IZtStoryService storyService;
+
+    @Autowired
+    private IZtStoryspecService storyspecService;
+
     @Autowired
     private IZtTaskService taskService;
     @Autowired
@@ -54,6 +61,8 @@ public class ZtKanbanlaneServiceImpl extends ServiceImpl<ZtKanbanlaneMapper, ZtK
     @Autowired
     private IZtActionService actionService;
 
+    @Autowired
+    private IZtUserService userService;
 
 
     @Override
@@ -65,7 +74,7 @@ public class ZtKanbanlaneServiceImpl extends ServiceImpl<ZtKanbanlaneMapper, ZtK
             return new ArrayList<>();
         }
         List<ZtKanbanlaneDTO> ztKanbanlanes = BeanCopyUtil.copyListProperties(list, ZtKanbanlaneDTO::new);
-
+        Map<String, ZtUser> userMap = this.userService.userMapByIds(null);
 
         List<ZtKanbancolumnDTO> listColumn =kanbancolumnService.listByLaneIds(ztKanbanlanes.stream().map(o->o.getId()).collect(Collectors.toList()));
         for (ZtKanbanlaneDTO dto:ztKanbanlanes) {
@@ -78,12 +87,51 @@ public class ZtKanbanlaneServiceImpl extends ServiceImpl<ZtKanbanlaneMapper, ZtK
                     List<String> ids = (List<String>)CollectionUtils.arrayToList(cards.split(",")).stream().filter(o -> !StringUtils.isEmpty(String.valueOf(o))).collect(Collectors.toList());
                     if("story".equalsIgnoreCase(d.getCardType())){
                         List<ZtStory> ztStories = this.storyService.listByIds(ids);
-                        d.setList(ztStories);
+                        List<ZtStoryDTO> ztStoryDTOS = BeanCopyUtil.copyListProperties(ztStories, ZtStoryDTO::new);
+                        List<ZtStoryspec> storySpecList = storyspecService.list(new QueryWrapper<ZtStoryspec>().lambda().in(ZtStoryspec::getStory, ids));
+                        if(!CollectionUtils.isEmpty(ztStories)){
+
+                            for (ZtStoryDTO st:ztStoryDTOS) {
+                                ZtUser ztUser = userMap.get(st.getAssignedTo());
+
+                                if(ztUser!=null){
+                                    st.setAssignedTo(ztUser.getNickname());
+                                    st.setColor(ztUser.getColor());
+                                }
+                                List<ZtStoryspec> storyspecs = storySpecList.stream().filter(o -> o.getStory().intValue() == st.getId().intValue()).collect(Collectors.toList());
+                                if(!CollectionUtils.isEmpty(storyspecs)){
+                                    ZtStoryspec ztStoryspec = storyspecs.get(0);
+                                    st.setSpec(ztStoryspec.getSpec());
+                                    st.setVerify(ztStoryspec.getVerify());
+                                }
+
+                            }
+                        }
+                        d.setList(ztStoryDTOS);
                     }else if("bug".equalsIgnoreCase(d.getCardType())){
                         List<ZtBug> ztBugs = bugService.listByIds(ids);
+                        if(!CollectionUtils.isEmpty(ztBugs)){
+                            for (ZtBug st:ztBugs) {
+
+                                ZtUser ztUser = userMap.get(st.getAssignedTo());
+                                if(ztUser!=null){
+                                    st.setColor(ztUser.getColor());
+                                    st.setAssignedTo(ztUser.getNickname());
+                                }
+                            }
+                        }
                         d.setList(ztBugs);
                     }else if("task".equalsIgnoreCase(d.getCardType())){
                         List<ZtTask> ztTasks = taskService.listByIds(ids);
+                        if(!CollectionUtils.isEmpty(ztTasks)){
+                            for (ZtTask st:ztTasks) {
+                                ZtUser ztUser = userMap.get(st.getAssignedTo());
+                                if(ztUser!=null){
+                                    st.setColor(ztUser.getColor());
+                                    st.setAssignedTo(ztUser.getNickname());
+                                }
+                            }
+                        }
                         d.setList(ztTasks);
                     }
                 }
@@ -205,7 +253,6 @@ public class ZtKanbanlaneServiceImpl extends ServiceImpl<ZtKanbanlaneMapper, ZtK
 
         }
         this.kanbancellService.updateById(thisZtKanbancell);
-
         ZtKanbancell ztKanbanlane = this.baseMapper.getZtKanbanlane(type, toStatus, execId);
         String cards = ztKanbanlane.getCards();
         List l=StringUtils.isEmpty(cards)?new ArrayList<>():new ArrayList<>(Arrays.asList(cards.split(",")));
@@ -290,6 +337,23 @@ public class ZtKanbanlaneServiceImpl extends ServiceImpl<ZtKanbanlaneMapper, ZtK
         return this.baseMapper.getZtKanbanlane(type,status,id);
     }
 
+    @Override
+    @Transactional
+    public void removeExecutionStory(Integer execution, Integer story) {
+        List<ZtKanbancell> list = this.kanbancellService.list(new QueryWrapper<ZtKanbancell>().lambda().eq(ZtKanbancell::getKanban, execution));
+        for (ZtKanbancell cell:list) {
+            if(!StringUtils.isEmpty(cell.getCards())){
+                String[] split = cell.getCards().split(",");
+                List<String> sList =new ArrayList(Arrays.asList(split));
+                if(sList.contains(story+"")){
+                    sList.remove(story + "");
+                    cell.setCards(sList.stream().collect(Collectors.joining(",")));
+                    this.kanbancellService.updateById(cell);
+                }
+            }
+        }
+    }
+
     private void taskChange(KanbanQo qo) {
         ZtTask ztTask = this.taskService.getById(qo.getId());
         ztTask.setStatus(qo.getStatusType());
@@ -304,4 +368,5 @@ public class ZtKanbanlaneServiceImpl extends ServiceImpl<ZtKanbanlaneMapper, ZtK
 
 
     }
+
 }

src/main/java/com/sa/zentao/service/impl/ZtNoticeServiceImpl.java

@@ -0,0 +1,20 @@
+package com.sa.zentao.service.impl;
+
+import com.sa.zentao.entity.ZtNotice;
+import com.sa.zentao.mapper.ZtNoticeMapper;
+import com.sa.zentao.service.IZtNoticeService;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.springframework.stereotype.Service;
+
+/**
+ * <p>
+ *  服务实现类
+ * </p>
+ *
+ * @author gqb
+ * @since 2024-12-26
+ */
+@Service
+public class ZtNoticeServiceImpl extends ServiceImpl<ZtNoticeMapper, ZtNotice> implements IZtNoticeService {
+
+}

src/main/java/com/sa/zentao/service/impl/ZtProjectServiceImpl.java

@@ -31,6 +31,7 @@ import java.math.BigDecimal;
 import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.DoubleStream;
+import java.util.stream.Stream;
 
 /**
  * <p>
@@ -993,26 +994,48 @@ public class ZtProjectServiceImpl extends ServiceImpl<ZtProjectMapper, ZtProject
 
     //按照每月多少天 1-31 每天的工作
     @Override
-    public  Map<String,List<Map<String,String>>> projectTeamTimeWork(ZtProjectQo qo) {
+    public  Map<String,List<Map<String,Object>>> projectTeamTimeWork(ZtProjectQo qo) {
-        Map<String,List<Map<String,String>>> map=new HashMap<>();
+        Map<String,List<Map<String,Object>>> map=new HashMap<>();
 
         Date date = qo.getDate();
 
         Date firstDayOfMonth = DateUtils.getFirstDayOfMonth(date);
         Date lastDayOfMonth = new Date(DateUtils.getLastDayOfMonth(date).getTime()+1000*2);
+        //产品集
+        Integer project = qo.getProject();
 
-        List<ZtTask> list = this.taskService.list(new QueryWrapper<ZtTask>().lambda().eq(ZtTask::getProject, qo.getProject()));
+        //产品
+        List<ZtProduct> products = this.productService.list(new QueryWrapper<ZtProduct>().lambda().eq(ZtProduct::getProgram, project));
+        if(CollectionUtils.isEmpty(products)){
+            return new HashMap<>();
+        }
+        //项目列表
+        List<ZtProjectproduct> projectList = this.projectproductService.list(new QueryWrapper<ZtProjectproduct>().lambda()
+                .in(ZtProjectproduct::getProduct, products.stream().map(o -> o.getId()).collect(Collectors.toList())));
+        if(CollectionUtils.isEmpty(projectList)){
+            return new HashMap<>();
+        }
+
+        List<ZtExecutionproject> execList = this.executionprojectService.list(new QueryWrapper<ZtExecutionproject>().lambda()
+                .in(ZtExecutionproject::getProject, projectList.stream().map(o -> o.getProject()).collect(Collectors.toList())));
+        if(CollectionUtils.isEmpty(execList)){
+            return new HashMap<>();
+        }
 
 
-        List<ZtEffort> efforts = this.effortService.list(new QueryWrapper<ZtEffort>().lambda().eq(ZtEffort::getProject, qo.getProject())
+        List<ZtTask> list = this.taskService.list(new QueryWrapper<ZtTask>().lambda().in(ZtTask::getExecution, execList.stream().map(o->o.getExecution()).collect(Collectors.toList())));
+        if(CollectionUtils.isEmpty(list)){
+            return new HashMap<>();
+        }
+        //工时
+        List<ZtEffort> efforts = this.effortService.list(new QueryWrapper<ZtEffort>().lambda()
+                .eq(ZtEffort::getObjecttype, "task")
+                .in(ZtEffort::getObjectid, list.stream().map(o->o.getId()).collect(Collectors.toList()))
                 .gt(ZtEffort::getDate, new Date(firstDayOfMonth.getTime() - 2000)).lt(ZtEffort::getDate, lastDayOfMonth)
         );
 
 
 
-        //项目关联的执行
-        List<ZtExecutionproject> execList = this.executionprojectService.list(new QueryWrapper<ZtExecutionproject>().lambda()
-                .eq(ZtExecutionproject::getProject, qo.getProject()));
         if(CollectionUtils.isEmpty(execList)){
             return new HashMap<>();
         }
@@ -1037,21 +1060,41 @@ public class ZtProjectServiceImpl extends ServiceImpl<ZtProjectMapper, ZtProject
 
 
         for (int i =0;i<DateUtils.getDays(date);i++){
-            Date  d=DateUtils.dateAddDay(date,i);
+            Date  d=DateUtils.dateAddDay(firstDayOfMonth,i);
-            List<Map<String,String>> l=new ArrayList<>();
+            List<Map<String,Object>> l=new ArrayList<>();
             for (String s:accountIds) {
                 ZtUser ztUser = uMap.get(s);
-                List<ZtEffort> fList = efforts.stream().filter(o -> o.getAccount().equals(s))
+//                List<ZtEffort> fList = efforts.stream().filter(o -> o.getAccount().equals(s))
-                        .filter(o->DateUtils.formatDate(o.getDate()).equals(DateUtils.formatDate(d)))
+//                        .filter(o->DateUtils.formatDate(o.getDate()).equals(DateUtils.formatDate(d)))
+//                        .collect(Collectors.toList());
+                List<ZtTask> taskList = list.stream().filter(o -> o.getEstStarted() != null && DateUtils.formatDate(o.getEstStarted()).equals(DateUtils.formatDate(d)))
+                            .filter(o->o.getAssignedTo().equals(ztUser.getAccount()))
                         .collect(Collectors.toList());
 
-                Map<String,String> m=new HashMap<>();
+
-                //分配
+
-                m.put("allocation","0");
+                Map<String,Object> m=new HashMap<>();
+                if(!CollectionUtils.isEmpty(taskList)){
+                    m.put("name",ztUser.getNickname());
+
+                    //分配
+                    m.put("allocation",taskList.stream().map(o->o.getEstimate()).mapToDouble(e -> Double.valueOf(e)).sum()+"");
+
+                    m.put("task",taskList);
+                }else{
+                    m.put("name",ztUser.getNickname());
+                    //分配
+                    m.put("allocation","");
+
+                    m.put("task","");
+                }
                 //使用
-                double sum = fList.stream().mapToDouble(o -> o.getConsumed()).sum();
+//                double sum = fList.stream().mapToDouble(o -> o.getConsumed()).sum();
-                m.put("use",sum+"");
+                //任务id
-                m.put("name",ztUser.getNickname());
+//                List<Integer> taskIds = fList.stream().map(o -> o.getObjectid()).collect(Collectors.toList());
+
+//                m.put("use",sum+"");
+
                 l.add(m);
 
             }
@@ -1173,6 +1216,42 @@ public class ZtProjectServiceImpl extends ServiceImpl<ZtProjectMapper, ZtProject
         return ztProjects;
     }
 
+    @Override
+    public ZtProjectDTO selectPrdByName(String s) {
+
+        return this.baseMapper.selectPrdByName(s);
+    }
+
+    @Override
+    public List<ZtProject> execListByProject(Integer project) {
+
+        List<ZtExecutionproject> list = this.executionprojectService.list(new QueryWrapper<ZtExecutionproject>().lambda()
+                .eq(ZtExecutionproject::getProject, project));
+        if(CollectionUtils.isEmpty(list)){
+            return new ArrayList<>();
+        }
+        List<Integer> ids = list.stream().map(o -> o.getExecution()).collect(Collectors.toList());
+
+
+        return this.listByIds(ids);
+    }
+
+    @Override
+    public void removeExecutionStory(Integer id) {
+
+        List<ZtProjectstory> list = this.projectstoryService.list(new QueryWrapper<ZtProjectstory>().lambda()
+                .eq(ZtProjectstory::getStory, id).ne(ZtProjectstory::getExecution, 0));
+        if(!CollectionUtils.isEmpty(list)){
+
+            //删除迭代
+            this.projectstoryService.remove(new QueryWrapper<ZtProjectstory>().lambda()
+                    .eq(ZtProjectstory::getStory,id).ne(ZtProjectstory::getExecution,0));
+            //删除看板
+            this.kanbanlaneService.removeExecutionStory(list.get(0).getExecution(),id);
+        }
+
+    }
+
 
     //修改项目集
     @Override
@@ -1648,11 +1727,11 @@ public class ZtProjectServiceImpl extends ServiceImpl<ZtProjectMapper, ZtProject
     }
 
     private Float floatBatchAdd(List<Float> list){
-        Float f=0f;
+        BigDecimal f=BigDecimal.ZERO;
         for (Float i:list ) {
-            f+=i;
+            f=f.add(BigDecimal.valueOf(i));
         }
-        return f;
+        return f.floatValue();
     }
 
 }

src/main/java/com/sa/zentao/service/impl/ZtProjectstoryServiceImpl.java

@@ -6,6 +6,8 @@ import com.sa.zentao.service.IZtProjectstoryService;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import org.springframework.stereotype.Service;
 
+import java.util.List;
+
 /**
  * <p>
  *  服务实现类
@@ -17,4 +19,8 @@ import org.springframework.stereotype.Service;
 @Service
 public class ZtProjectstoryServiceImpl extends ServiceImpl<ZtProjectstoryMapper, ZtProjectstory> implements IZtProjectstoryService {
 
+    @Override
+    public List<ZtProjectstory> storyListPrd(Integer id) {
+        return this.baseMapper.storyListPrd(id);
+    }
 }

src/main/java/com/sa/zentao/service/impl/ZtReleaseDetailsServiceImpl.java

@@ -0,0 +1,33 @@
+package com.sa.zentao.service.impl;
+
+import com.sa.zentao.dao.ZtStoryDTO;
+import com.sa.zentao.entity.ZtReleaseDetails;
+import com.sa.zentao.mapper.ZtReleaseDetailsMapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.sa.zentao.qo.ZtReleaseQo;
+import com.sa.zentao.service.IZtReleaseDetailsService;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+/**
+ * <p>
+ *  服务实现类
+ * </p>
+ *
+ * @author gqb
+ * @since 2024-12-26
+ */
+@Service
+public class ZtReleaseDetailsServiceImpl extends ServiceImpl<ZtReleaseDetailsMapper, ZtReleaseDetails> implements IZtReleaseDetailsService {
+
+    @Override
+    public List<ZtStoryDTO> releasePageList(ZtReleaseQo qo) {
+        return this.baseMapper.releasePageList(qo);
+    }
+
+    @Override
+    public List<ZtStoryDTO> storyPageList(ZtReleaseQo qo) {
+        return this.baseMapper.storyPageList(qo);
+    }
+}

src/main/java/com/sa/zentao/service/impl/ZtReleaseServiceImpl.java

@@ -0,0 +1,422 @@
+package com.sa.zentao.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.github.pagehelper.Page;
+import com.github.pagehelper.PageHelper;
+import com.github.pagehelper.PageInfo;
+import com.sa.zentao.conf.RiskUserThreadLocal;
+import com.sa.zentao.dao.*;
+import com.sa.zentao.entity.*;
+import com.sa.zentao.enums.StoryStageEnums;
+import com.sa.zentao.mapper.ZtReleaseMapper;
+import com.sa.zentao.qo.ZtReleaseQo;
+import com.sa.zentao.service.*;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.sa.zentao.utils.BeanCopyUtil;
+import com.sa.zentao.utils.DateUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.util.CollectionUtils;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * <p>
+ *  服务实现类
+ * </p>
+ *
+ * @author gqb
+ * @since 2024-12-26
+ */
+@Service
+public class ZtReleaseServiceImpl extends ServiceImpl<ZtReleaseMapper, ZtRelease> implements IZtReleaseService {
+
+    @Autowired
+    private IZtReleaseDetailsService releaseDetailsService;
+    @Autowired
+    private IZtProjectService projectService;
+    @Autowired
+    private IZtUserService userService;
+
+
+    @Override
+    public void addRelease(ZtReleaseDTO dto) {
+        if(StringUtils.isEmpty(dto.getProject())){
+            throw new BusinessException("请选择项目");
+        }
+
+
+        ZtRelease ztRelease = new ZtRelease();
+        BeanUtils.copyProperties(dto,ztRelease);
+        ztRelease.setCreatedby(RiskUserThreadLocal.get().getName());
+        ztRelease.setStatus("reviewing");
+        ztRelease.setCreateddate(new Date());
+        this.baseMapper.insert(ztRelease);
+
+
+        String execStr = dto.getExecutions();
+        if(!StringUtils.isEmpty(execStr)){
+            List<String> execIds = new ArrayList<String>(Arrays.asList(execStr.split(",")));
+
+            List<ZtProjectstory> list = this.projectstoryService.list(new QueryWrapper<ZtProjectstory>().lambda()
+                    .in(ZtProjectstory::getExecution, execIds));
+            if(!CollectionUtils.isEmpty(list)){
+                List<ZtStory> sList = this.storyService.list(new QueryWrapper<ZtStory>()
+                        .lambda().eq(ZtStory::getStatus, "active")
+                        .in(ZtStory::getId,list.stream().map(o->o.getStory()).collect(Collectors.toList()))
+                        .eq(ZtStory::getStage, StoryStageEnums.tested.getValue()));
+                if(!CollectionUtils.isEmpty(sList)){
+                    List<ZtReleaseDetails> releaseStoryList = this.releaseDetailsService.list(new QueryWrapper<ZtReleaseDetails>().lambda()
+                            .in(ZtReleaseDetails::getObjectId, sList.stream().map(o -> o.getId()).collect(Collectors.toList())));
+                    List<Integer> sIds = releaseStoryList.stream().map(o -> o.getObjectId().intValue()).collect(Collectors.toList());
+
+
+                    List<ZtReleaseDetails> saveBatch=new ArrayList<>();
+                    for (ZtStory s:sList) {
+                        if(!sIds.contains(s.getId())){
+                            ZtReleaseDetails e=new ZtReleaseDetails();
+                             e.setObjectId(s.getId());
+                             e.setObjectType("story");
+                             e.setReleaseId(ztRelease.getId());
+                             e.setStatus("wait");
+                             saveBatch.add(e);
+                        }
+                    }
+                    releaseDetailsService.saveBatch(saveBatch);
+                }
+            }
+        }
+
+    }
+
+    @Override
+    @Transactional
+    public void modifyRelease(ZtReleaseDTO dto) {
+        ZtRelease ztRelease = this.baseMapper.selectById(dto.getId());
+
+        if(ztRelease==null){
+            throw new BusinessException("未查询到数据");
+        }
+        BeanUtils.copyProperties(dto,ztRelease,"id");
+        this.baseMapper.updateById(ztRelease);
+
+        String project = ztRelease.getExecutions();
+        String[] split = project.split(",");
+
+    }
+
+    @Override
+    public PageInfo<ZtReleaseDTO> pageList(ZtReleaseQo qo) {
+
+        Page<ZtReleaseDTO> page = PageHelper.startPage(qo.getCurrentPage(), qo.getPageSize());
+
+        List<ZtReleaseDTO> list = this.baseMapper.pageList(qo);
+
+        if(!CollectionUtils.isEmpty(list)){
+            Map<String, ZtUser> userMap = userService.userMapByIds(null);
+
+            List<ZtReleaseDetails> details = this.releaseDetailsService.list(new QueryWrapper<ZtReleaseDetails>().lambda().in(ZtReleaseDetails::getReleaseId, list.stream().map(o -> o.getId()).collect(Collectors.toList())));
+
+
+
+            for (ZtReleaseDTO dto:list) {
+
+//                ZtReleaseDetailsDTO
+                List<ZtReleaseDetails> fDetails = details.stream().filter(o -> o.getReleaseId().intValue() == dto.getId().intValue()).collect(Collectors.toList());
+
+                if(!CollectionUtils.isEmpty(fDetails)){
+                    dto.setDetails(BeanCopyUtil.copyListProperties(fDetails, ZtReleaseDetailsDTO::new));
+                }
+                ZtUser ztUser = userMap.get(dto.getAssignedTo());
+                if(ztUser!=null){
+                    dto.setAssignedToName(ztUser.getNickname());
+                }
+                ztUser = userMap.get(dto.getCreatedby());
+                if(ztUser!=null){
+                    dto.setCreatedby(ztUser.getNickname());
+                }
+            }
+        }
+
+        return new PageInfo<ZtReleaseDTO>(list);
+    }
+
+    @Override
+    public void assignedTo(ZtReleaseQo dto) {
+        ZtRelease ztRelease = this.baseMapper.selectById(dto.getId());
+        if(ztRelease==null){
+            throw new BusinessException("未查询到数据");
+        }
+        ztRelease.setAssignedTo(dto.getAssignedTo());
+        this.baseMapper.updateById(ztRelease);
+    }
+
+    @Override
+    public void userReview(ZtReleaseQo dto) {
+        ZtRelease ztRelease = this.baseMapper.selectById(dto.getId());
+        if(ztRelease==null){
+            throw new BusinessException("未查询到数据");
+        }
+        if(!"reviewing".equals(ztRelease.getStatus())){
+            throw new BusinessException("当前无需评审");
+        }
+        //0 不通过
+        if(dto.getRevieweResult()==1){
+            ztRelease.setStatus("waitRelease");
+        }else{
+            ztRelease.setStatus("closed");
+            ztRelease.setFailRemark(dto.getFailRemark());
+            String project = ztRelease.getExecutions();
+            String[] split = project.split(",");
+            List<ZtReleaseDetails> executions = releaseDetailsService.list(new QueryWrapper<ZtReleaseDetails>().lambda()
+                    .eq(ZtReleaseDetails::getReleaseId,ztRelease.getId())
+            );
+            for (ZtReleaseDetails s:executions ) {
+                s.setStatus("closed");
+                releaseDetailsService.updateById(s);
+            }
+
+        }
+
+        this.baseMapper.updateById(ztRelease);
+    }
+    @Autowired
+    private IZtNoticeService noticeService;
+
+    @Autowired
+    private IZtProjectstoryService projectstoryService;
+
+    @Autowired
+    private IZtStoryService storyService;
+
+    @Override
+    @Transactional
+    public void release(ZtReleaseQo dto) {
+
+        ZtRelease ztRelease = this.baseMapper.selectById(dto.getId());
+        if(ztRelease==null){
+            throw new BusinessException("未查询到数据");
+        }
+
+        //0 不通过
+        if(dto.getRevieweResult()==0){
+
+            ztRelease.setStatus("closed");
+            ztRelease.setReleaseFailRemark(dto.getReleaseFailRemark());
+            String project = ztRelease.getExecutions();
+            String[] split = project.split(",");
+            List<ZtReleaseDetails> executions = releaseDetailsService.list(new QueryWrapper<ZtReleaseDetails>().lambda()
+                    .eq(ZtReleaseDetails::getReleaseId,ztRelease.getId())
+            );
+            for (ZtReleaseDetails s:executions ) {
+                s.setStatus("closed");
+                releaseDetailsService.updateById(s);
+            }
+
+        }else{
+            ztRelease.setStatus("released");
+        }
+        if(1==dto.getPushFlag()){
+            //推送
+            ZtNotice notice=new ZtNotice();
+            notice.setName(dto.getTitle());
+            notice.setTitle(dto.getTitle());
+            notice.setRemark(dto.getRemark());
+            notice.setCreateDate(new Date());
+            notice.setCreateUser(RiskUserThreadLocal.get().getName());
+            notice.setLoseDate(DateUtils.dateAddDay(new Date(),30));
+            notice.setObjectType("release");
+            notice.setObjectId(ztRelease.getId());
+            notice.setFlag(0);
+            noticeService.save(notice);
+        }
+        List<ZtReleaseDetails> details = this.releaseDetailsService.list(new QueryWrapper<ZtReleaseDetails>().lambda().eq(ZtReleaseDetails::getReleaseId, ztRelease.getId()).eq(ZtReleaseDetails::getObjectType, "story"));
+
+        List<Integer> storyList=new ArrayList<Integer>();
+        for (ZtReleaseDetails d:details ) {
+            storyList.add(d.getObjectId());
+        }
+
+//        List<ZtProjectstory> list = this.projectstoryService.list(new QueryWrapper<ZtProjectstory>().lambda()
+//                .in(ZtProjectstory::getStory, split).ne(ZtProjectstory::getExecution,0));
+        if(CollectionUtils.isEmpty(storyList)){
+            throw new BusinessException("当前迭代无需求无法发布");
+        }
+        List<ZtStory> ztStories = storyService.listByIds(storyList);
+        for (ZtStory st:ztStories) {
+            if("active".equals(st.getStatus())&&"wait".equals(st.getStage())){
+                continue;
+            }
+            if("closed".equals(st.getStatus())||"closed".equals(st.getStage())){
+                continue;
+            }
+            if(!"tested".equals(st.getStage())){
+                throw new BusinessException(st.getTitle()+" 当前需求无法发布，请检查");
+            }
+            this.storyService.releaseStory(st.getId());
+        }
+
+        this.baseMapper.updateById(ztRelease);
+    }
+
+    @Override
+    public List<Map<String,Object>> execMenu(ZtReleaseQo qo) {
+
+
+        return null;
+    }
+    @Autowired
+    private IZtExecutionprojectService executionprojectService;
+
+    @Override
+    public PageInfo<ZtStoryDTO> execStoryPageList(ZtReleaseQo qo) {
+
+
+        return new PageInfo<ZtStoryDTO>();
+    }
+
+    @Override
+    public PageInfo<ZtStoryDTO> releaseStoryPageList(ZtReleaseQo qo) {
+        Integer id = qo.getId();
+        Page<ZtReleaseDTO> page = PageHelper.startPage(qo.getCurrentPage(), qo.getPageSize());
+
+        List<ZtStoryDTO> list = this.releaseDetailsService.releasePageList(qo);
+
+        Map<String, ZtUser> userMap = this.userService.userMapByIds(null);
+
+
+
+        Map<Integer, ZtProject> executionMapByStory = this.storyService.getExecutionMapByStory(list);
+
+
+        for (ZtStoryDTO d : list) {
+            d.setRevieweUser(d.getReviewedby().replaceAll(",", " "));
+            ZtUser ztUser = userMap.get(d.getAssignedTo());
+            if(ztUser!=null){
+                d.setAssignedToName(ztUser.getNickname());
+            }
+
+            ztUser = userMap.get(d.getOpenedby());
+            if(ztUser!=null){
+                d.setOpenedbyName(ztUser.getNickname());
+            }
+            ZtProject ztProject = executionMapByStory.get(d.getId());
+            if(ztProject!=null){
+                d.setExecution(ztProject.getId());
+                d.setExecutionName(ztProject.getName());
+            }
+        }
+        return new PageInfo<ZtStoryDTO>(list);
+    }
+
+    @Override
+    public PageInfo<ZtStoryDTO> projectStoryPageList(ZtReleaseQo qo) {
+        ZtRelease ztRelease = this.baseMapper.selectById(qo.getId());
+
+        String project = ztRelease.getProject();
+
+        // 项目查找所有迭代
+        List<ZtExecutionproject> execList = this.executionprojectService.list(new QueryWrapper<ZtExecutionproject>().lambda().eq(ZtExecutionproject::getProject, project));
+        if(CollectionUtils.isEmpty(execList)){
+            return new PageInfo<ZtStoryDTO>();
+        }
+        //迭代查找所有需求
+        List<ZtProjectstory> pStorys = this.projectstoryService.list(new QueryWrapper<ZtProjectstory>().lambda().in(ZtProjectstory::getExecution,
+                execList.stream().map(o -> o.getExecution()).collect(Collectors.toList())));
+        if(CollectionUtils.isEmpty(pStorys)){
+            return new PageInfo<ZtStoryDTO>();
+        }
+        //过滤掉已关联的迭代需求
+        List<Integer> storyIdList = pStorys.stream().map(o -> o.getStory()).collect(Collectors.toList());
+
+        List<ZtRelease> ztReleases = this.baseMapper.selectList(new QueryWrapper<ZtRelease>().lambda().eq(ZtRelease::getProject, project));
+
+        List<ZtReleaseDetails> list = this.releaseDetailsService.list(new QueryWrapper<ZtReleaseDetails>().lambda()
+                .in(ZtReleaseDetails::getReleaseId, ztReleases.stream().map(o -> o.getId()).collect(Collectors.toList())).ne(ZtReleaseDetails::getStatus, "closed")
+                .eq(ZtReleaseDetails::getObjectType, "story")
+        );
+        if(!CollectionUtils.isEmpty(list)){
+            List<Integer> fIds = list.stream().map(o -> o.getObjectId()).collect(Collectors.toList());
+
+            Iterator<ZtProjectstory> iterator = pStorys.iterator();
+            while (iterator.hasNext()){
+                ZtProjectstory next = iterator.next();
+                if(fIds.contains(next.getStory())){
+                    iterator.remove();
+                }
+            }
+        }
+        qo.setStoryList(pStorys.stream().map(o->o.getStory()).collect(Collectors.toList()));
+        Page<ZtReleaseDTO> page = PageHelper.startPage(qo.getCurrentPage(), qo.getPageSize());
+        List<ZtStoryDTO> storyList = this.releaseDetailsService.storyPageList(qo);
+
+        Map<String, ZtUser> userMap = this.userService.userMapByIds(null);
+
+
+
+        Map<Integer, ZtProject> executionMapByStory = this.storyService.getExecutionMapByStory(storyList);
+
+
+        for (ZtStoryDTO d : storyList) {
+            ZtUser ztUser = userMap.get(d.getAssignedTo());
+            if(ztUser!=null){
+                d.setAssignedToName(ztUser.getNickname());
+            }
+
+            ztUser = userMap.get(d.getOpenedby());
+            if(ztUser!=null){
+                d.setOpenedbyName(ztUser.getNickname());
+            }
+            ZtProject ztProject = executionMapByStory.get(d.getId());
+            if(ztProject!=null){
+                d.setExecution(ztProject.getId());
+                d.setExecutionName(ztProject.getName());
+            }
+        }
+        return new PageInfo<ZtStoryDTO>(storyList);
+    }
+
+    @Override
+    public void removeStory(ZtReleaseQo qo) {
+        Integer id = qo.getId();
+        Integer storyId = qo.getStoryId();
+
+        ZtRelease ztRelease = this.baseMapper.selectById(id);
+
+        ZtReleaseDetails releaseDetails = this.releaseDetailsService.getOne(new QueryWrapper<ZtReleaseDetails>().lambda().eq(ZtReleaseDetails::getReleaseId, id)
+                .eq(ZtReleaseDetails::getObjectId, storyId));
+        releaseDetails.setStatus("closed");
+        this.releaseDetailsService.updateById(releaseDetails);
+
+    }
+
+    @Override
+    @Transactional
+    public void batchSyncStory(ZtReleaseQo qo) {
+        List<Integer> storyList = qo.getStoryList();
+        List<ZtReleaseDetails> list = this.releaseDetailsService.list(new QueryWrapper<ZtReleaseDetails>().lambda()
+                .eq(ZtReleaseDetails::getObjectType, "story").ne(ZtReleaseDetails::getStatus, "closed")
+                .in(ZtReleaseDetails::getObjectId, storyList)
+        );
+        if(!CollectionUtils.isEmpty(list)){
+            throw new BusinessException("需求已被关联需求id :"+ list.get(0).getId());
+        }
+        List<ZtReleaseDetails> saveBatch=new ArrayList<>();
+        for (Integer story:storyList) {
+            ZtReleaseDetails e=new ZtReleaseDetails();
+            e.setObjectId(story);
+            e.setObjectType("story");
+            e.setReleaseId(qo.getId());
+            e.setStatus("wait");
+            saveBatch.add(e);
+        }
+
+        releaseDetailsService.saveBatch(saveBatch);
+
+    }
+}

src/main/java/com/sa/zentao/service/impl/ZtStoryFeedbackServiceImpl.java

@@ -1,24 +1,28 @@
 package com.sa.zentao.service.impl;
 
 import ch.qos.logback.core.util.StringUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.github.pagehelper.Page;
 import com.github.pagehelper.PageHelper;
 import com.github.pagehelper.PageInfo;
 import com.sa.zentao.conf.RiskUserThreadLocal;
 import com.sa.zentao.dao.BusinessException;
+import com.sa.zentao.dao.ZtStoryDTO;
 import com.sa.zentao.dao.ZtStoryFeedbackDTO;
+import com.sa.zentao.entity.ZtProduct;
 import com.sa.zentao.entity.ZtStory;
 import com.sa.zentao.entity.ZtStoryFeedback;
 import com.sa.zentao.entity.ZtUser;
 import com.sa.zentao.enums.ActionStatus;
 import com.sa.zentao.enums.ActionType;
+import com.sa.zentao.enums.FileTypes;
+import com.sa.zentao.enums.UserType;
 import com.sa.zentao.mapper.ZtStoryFeedbackMapper;
 import com.sa.zentao.qo.ZtProjectQo;
-import com.sa.zentao.service.IZtActionService;
+import com.sa.zentao.service.*;
-import com.sa.zentao.service.IZtStoryFeedbackService;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import com.sa.zentao.service.IZtStoryService;
+import com.sa.zentao.utils.BeanCopyUtil;
-import com.sa.zentao.service.IZtUserService;
 import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
@@ -26,10 +30,7 @@ import org.springframework.transaction.annotation.Transactional;
 import org.springframework.util.CollectionUtils;
 import org.springframework.util.StringUtils;
 
-import java.util.Date;
+import java.util.*;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
 import java.util.stream.Collectors;
 
 /**
@@ -52,6 +53,9 @@ public class ZtStoryFeedbackServiceImpl extends ServiceImpl<ZtStoryFeedbackMappe
     @Autowired
     private IZtActionService actionService;
 
+    @Autowired
+    private IZtFileService fileService;
+
     @Override
     public PageInfo<ZtStoryFeedbackDTO> pageList(ZtProjectQo qo) {
 
@@ -110,6 +114,9 @@ public class ZtStoryFeedbackServiceImpl extends ServiceImpl<ZtStoryFeedbackMappe
         ztStoryFeedback.setStatus("wait");
 
         this.baseMapper.insert(ztStoryFeedback);
+
+        fileService.updateFile(dto.getFiles(),ztStoryFeedback.getId(), FileTypes.feedbackStory);
+
         actionService.addAction(ActionType.WTFK, ActionStatus.XJ, dto.getId(),  dto.getProduct()+"", null, null,
                 RiskUserThreadLocal.get().getName(), dto.getSpec(), "");
     }
@@ -122,6 +129,9 @@ public class ZtStoryFeedbackServiceImpl extends ServiceImpl<ZtStoryFeedbackMappe
         ztStoryFeedback.setUpdateUser(RiskUserThreadLocal.get().getName());
         ztStoryFeedback.setUpdateDate(new Date());
         this.baseMapper.updateById(ztStoryFeedback);
+
+        fileService.updateFile(dto.getFiles(),ztStoryFeedback.getId(), FileTypes.feedbackStory);
+
         actionService.addAction(ActionType.WTFK, ActionStatus.BJ, dto.getId(),  dto.getProduct()+"", null, null,
                 RiskUserThreadLocal.get().getName(), null, "");
     }
@@ -134,10 +144,165 @@ public class ZtStoryFeedbackServiceImpl extends ServiceImpl<ZtStoryFeedbackMappe
         }
         ztStoryFeedback.setStatus(dto.getStatus());
         ztStoryFeedback.setCloseRemark(dto.getCloseRemark());
+        if("finished".equals(dto.getStatus())){
+            ztStoryFeedback.setFinishDate(new Date());
+        }else{
+            ztStoryFeedback.setCloseDate(new Date());
+        }
+
         this.baseMapper.updateById(ztStoryFeedback);
         if(!StringUtils.isEmpty(dto.getCloseRemark())){
             actionService.addAction(ActionType.WTFK, ActionStatus.BJ, dto.getId(),  dto.getProduct()+"", null, null,
                     RiskUserThreadLocal.get().getName(), dto.getCloseRemark(), "");
         }
     }
+
+    //指派
+    @Override
+    public void assignedTo(ZtStoryDTO dto) {
+        ZtStoryFeedback ztStory = this.baseMapper.selectById(dto.getId());
+        if (ztStory == null) {
+            throw new BusinessException("未查询到");
+        }
+        if("closed".equals(ztStory.getStatus())){
+            throw new BusinessException("当前已关闭");
+        }
+        ztStory.setAssignedTo(org.apache.commons.lang3.StringUtils.isEmpty(dto.getAssignedTo()) ? "" : dto.getAssignedTo());
+        ztStory.setUpdateDate(new Date());
+        this.baseMapper.updateById(ztStory);
+
+        actionService.addAction(ActionType.WTFK, ActionStatus.FP, ztStory.getId(), ztStory.getProduct() + "", null, null,
+                RiskUserThreadLocal.get().getName(), dto.getDesc(), ztStory.getAssignedTo());
+
+    }
+
+    @Override
+    public void startHand(ZtStoryDTO dto) {
+        ZtStoryFeedback ztStoryFeedback = this.baseMapper.selectById(dto.getId());
+        if(ztStoryFeedback==null){
+            throw new BusinessException("未查询到");
+        }
+        ztStoryFeedback.setStatus("doing");
+        ztStoryFeedback.setUpdateUser(RiskUserThreadLocal.get().getName());
+        ztStoryFeedback.setUpdateDate(new Date());
+        ztStoryFeedback.setHandDate(new Date());
+        this.baseMapper.updateById(ztStoryFeedback);
+        actionService.addAction(ActionType.WTFK, ActionStatus.KS, ztStoryFeedback.getId(), ztStoryFeedback.getProduct() + "", null, null,
+                RiskUserThreadLocal.get().getName(), dto.getDesc(), ztStoryFeedback.getAssignedTo());
+    }
+    @Autowired
+    private  IZtProjectService projectService;
+    @Autowired
+    private IZtProductService productService;
+
+    @Override
+    public List<ZtStoryFeedbackDTO> ztStoryFeedbackDTO(ZtProjectQo qo) {
+
+        List<Integer> authList = this.projectService.authList();
+        if(CollectionUtils.isEmpty(authList)){
+            return new ArrayList<>();
+        }
+        List<ZtProduct> list = productService.list(new QueryWrapper<ZtProduct>().lambda().in(ZtProduct::getProgram, authList));
+        if(CollectionUtils.isEmpty(list)){
+            return new ArrayList<>();
+        }
+        LambdaQueryWrapper<ZtStoryFeedback> query = new QueryWrapper<ZtStoryFeedback>().lambda()
+                .eq(ZtStoryFeedback::getAssignedTo, RiskUserThreadLocal.get().getName())
+                .or().eq(ZtStoryFeedback::getOpenedBy, RiskUserThreadLocal.get().getName());
+        if(!org.apache.commons.lang3.StringUtils.isEmpty(qo.getSearchValue())){
+            if("ALL".equals(qo.getSearchValue())){
+                query.eq(ZtStoryFeedback::getAssignedTo,RiskUserThreadLocal.get().getName());
+            }
+            if("ZGW".equals(qo.getSearchValue())){
+                query.eq(ZtStoryFeedback::getAssignedTo,RiskUserThreadLocal.get().getName());
+            }
+            if("WCJ".equals(qo.getSearchValue())){
+                query.eq(ZtStoryFeedback::getOpenedBy,RiskUserThreadLocal.get().getName());
+            }
+            if("YJJ".equals(qo.getSearchValue())){
+                query.eq(ZtStoryFeedback::getStatus,"finished");
+            }
+            if("YGB".equals(qo.getSearchValue())){
+                query.eq(ZtStoryFeedback::getStatus, "closed");
+            }
+
+        }else{
+            query.ne(ZtStoryFeedback::getStatus, "closed");
+        }
+
+        if(UserType.GSGC==RiskUserThreadLocal.get().getUserType()||"admin".equals(RiskUserThreadLocal.get().getName())){
+
+        }else {
+            query.in(ZtStoryFeedback::getProduct, list.stream().map(o -> o.getId()).collect(Collectors.toList()));
+        }
+        query.orderByDesc(ZtStoryFeedback::getId);
+        List<ZtStoryFeedback> closed = this.baseMapper.selectList(
+                query
+        );
+        if(CollectionUtils.isEmpty(closed)){
+            return new ArrayList<>();
+        }
+        return BeanCopyUtil.copyListProperties(closed,ZtStoryFeedbackDTO::new);
+    }
+
+    @Override
+    public PageInfo<ZtStoryFeedbackDTO> myFeedbackPageList(ZtProjectQo qo) {
+
+
+
+        List<Integer> authList = this.projectService.authList();
+        if(CollectionUtils.isEmpty(authList)){
+            return new PageInfo<ZtStoryFeedbackDTO>();
+        }
+        List<ZtProduct> list = productService.list(new QueryWrapper<ZtProduct>().lambda().in(ZtProduct::getProgram, authList));
+        if(CollectionUtils.isEmpty(list)){
+            return new PageInfo<ZtStoryFeedbackDTO>();
+        }
+
+        Page<ZtStoryDTO> page = PageHelper.startPage(qo.getCurrentPage(), qo.getPageSize());
+
+        LambdaQueryWrapper<ZtStoryFeedback> query = new QueryWrapper<ZtStoryFeedback>().lambda()
+                .eq(ZtStoryFeedback::getAssignedTo, RiskUserThreadLocal.get().getName())
+                .or().eq(ZtStoryFeedback::getOpenedBy, RiskUserThreadLocal.get().getName());
+        if(!org.apache.commons.lang3.StringUtils.isEmpty(qo.getSearchValue())){
+            if("ALL".equals(qo.getSearchValue())){
+                query.eq(ZtStoryFeedback::getAssignedTo,RiskUserThreadLocal.get().getName());
+            }
+            if("ZGW".equals(qo.getSearchValue())){
+                query.eq(ZtStoryFeedback::getAssignedTo,RiskUserThreadLocal.get().getName());
+            }
+            if("WCJ".equals(qo.getSearchValue())){
+                query.eq(ZtStoryFeedback::getOpenedBy,RiskUserThreadLocal.get().getName());
+            }
+            if("YJJ".equals(qo.getSearchValue())){
+                query.eq(ZtStoryFeedback::getStatus,"finished");
+            }
+            if("YGB".equals(qo.getSearchValue())){
+                query.eq(ZtStoryFeedback::getStatus, "closed");
+            }
+
+        }else{
+            query.ne(ZtStoryFeedback::getStatus, "closed");
+        }
+
+        if(UserType.GSGC==RiskUserThreadLocal.get().getUserType()||"admin".equals(RiskUserThreadLocal.get().getName())){
+
+        }else {
+            query.in(ZtStoryFeedback::getProduct, list.stream().map(o -> o.getId()).collect(Collectors.toList()));
+        }
+
+
+        if(!org.apache.commons.lang3.StringUtils.isEmpty(qo.getIds())){
+            String[] split = qo.getIds().split(",");
+            query.in(ZtStoryFeedback::getId, new ArrayList<>(Arrays.asList(split)));
+        }
+
+        query.orderByDesc(ZtStoryFeedback::getId);
+
+
+        List<ZtStoryFeedback> listFeedback= this.baseMapper.selectList(
+                query
+        );
+        return new PageInfo<ZtStoryFeedbackDTO>(BeanCopyUtil.copyListProperties(listFeedback,ZtStoryFeedbackDTO::new));
+    }
 }

src/main/java/com/sa/zentao/service/impl/ZtStoryServiceImpl.java

@@ -8,12 +8,11 @@ import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import com.github.pagehelper.Page;
 import com.github.pagehelper.PageHelper;
 import com.github.pagehelper.PageInfo;
+import com.sa.zentao.conf.LoginRiskUser;
 import com.sa.zentao.conf.RiskUserThreadLocal;
 import com.sa.zentao.dao.*;
 import com.sa.zentao.entity.*;
-import com.sa.zentao.enums.ActionStatus;
+import com.sa.zentao.enums.*;
-import com.sa.zentao.enums.ActionType;
-import com.sa.zentao.enums.ProductStoryStatus;
 import com.sa.zentao.mapper.ZtStoryMapper;
 import com.sa.zentao.qo.KanbanQo;
 import com.sa.zentao.qo.ZtBugQo;
@@ -42,6 +41,12 @@ import java.util.stream.Collectors;
 @Service
 public class ZtStoryServiceImpl extends ServiceImpl<ZtStoryMapper, ZtStory> implements IZtStoryService {
 
+    @Autowired
+    private IZtStoryFeedbackService storyFeedbackService;
+
+    @Autowired
+    private IZtFileService fileService;
+
     @Autowired
     private IZtStoryreviewService storyreviewService;
 
@@ -132,7 +137,7 @@ public class ZtStoryServiceImpl extends ServiceImpl<ZtStoryMapper, ZtStory> impl
     private Map<Integer, List<ZtStoryreviewDTO>> getReviewMap(List<ZtStoryDTO> list) {
         List<ZtStoryreview> list1 = storyreviewService.list(new QueryWrapper<ZtStoryreview>().lambda().in(ZtStoryreview::getStory
                 , list.stream().map(o -> o.getId()).collect(Collectors.toList())
-        ));
+        ).eq(ZtStoryreview::getType,"story"));
 
         if (CollectionUtils.isEmpty(list1)) {
             return new HashMap<>();
@@ -155,8 +160,7 @@ public class ZtStoryServiceImpl extends ServiceImpl<ZtStoryMapper, ZtStory> impl
 
         }
     }
-    @Autowired
+
-    private IZtStoryFeedbackService storyFeedbackService;
 
     @Override
     @Transactional
@@ -193,6 +197,7 @@ public class ZtStoryServiceImpl extends ServiceImpl<ZtStoryMapper, ZtStory> impl
         spec.setFiles(dto.getFileUrl());
         storyspecService.save(spec);
 
+        fileService.updateFile(dto.getFiles(),s.getId(), FileTypes.story);
 
         if(dto.getFeedbackId()!=null&&dto.getFeedbackId()!=0){
             ZtStoryFeedback storyFeedback = this.storyFeedbackService.getById(dto.getFeedbackId());
@@ -223,6 +228,7 @@ public class ZtStoryServiceImpl extends ServiceImpl<ZtStoryMapper, ZtStory> impl
                 v.setStory(s.getId());
                 v.setVersion(s.getVersion());
                 v.setReviewer(str);
+                v.setType("story");
                 this.storyreviewService.save(v);
                 actionService.addAction(ActionType.XQ, ActionStatus.PS, s.getId(), s.getProduct() + "", s.getProject(), null,
                         RiskUserThreadLocal.get().getName(), dto.getClosedreason(), str);
@@ -313,7 +319,24 @@ public class ZtStoryServiceImpl extends ServiceImpl<ZtStoryMapper, ZtStory> impl
         if("closed".equals(ztStory.getStatus())){
             throw new BusinessException("当前已关闭");
         }
-        BeanUtils.copyProperties(dto, ztStory);
+        //老的迭代
+        List<ZtProjectstory> pList = projectstoryService.list(new QueryWrapper<ZtProjectstory>().lambda().eq(ZtProjectstory::getStory, ztStory.getId())
+                .ne(ZtProjectstory::getExecution, 0)
+        );
+
+        Integer execution = dto.getExecution();
+        if(execution!=null&&execution!=0){
+            if(!CollectionUtils.isEmpty(pList)&&pList.get(0).getExecution().intValue()!=execution.intValue()){
+                List<ZtTask> list = this.taskService.list(new QueryWrapper<ZtTask>().lambda().eq(ZtTask::getStory, ztStory.getId()));
+                if(!CollectionUtils.isEmpty(list)){
+                    throw new BusinessException("当前任务已开始无法更换迭代");
+                }
+            }
+
+        }
+
+
+        BeanUtils.copyProperties(dto, ztStory,"stage");
         if("draft".equalsIgnoreCase(ztStory.getStatus())){
             ztStory.setStatus("reviewing");
             if (ztStory.getProduct() != null&&ztStory.getProduct()!=0) {
@@ -341,19 +364,30 @@ public class ZtStoryServiceImpl extends ServiceImpl<ZtStoryMapper, ZtStory> impl
             }
         }
 
+
+
+        String stage = ztStory.getStage();
+        if(!StringUtils.isEmpty(stage)&&!stage.equals(dto.getStage())){
+            ZtStoryDTO s =new ZtStoryDTO();
+            s.setIdList(Arrays.asList(ztStory.getId()));
+            s.setStage(dto.getStage());
+            this.changeStatus(s);
+        }
         this.baseMapper.updateById(ztStory);
 
+        fileService.updateFile(dto.getFiles(),ztStory.getId(), FileTypes.story);
+
         List<String> userViewId = dto.getUserViewId();
         if(!CollectionUtils.isEmpty(userViewId)){
            storyreviewService.remove(new QueryWrapper<ZtStoryreview>().lambda().eq(ZtStoryreview::getStory
-                    , id
+                    , id).eq(ZtStoryreview::getType,"story"));
-            ));
 
             for (String str : dto.getUserViewId()) {
                 ZtStoryreview v = new ZtStoryreview();
                 v.setStory(ztStory.getId());
                 v.setVersion(ztStory.getVersion());
                 v.setReviewer(str);
+                v.setType("story");
                 this.storyreviewService.save(v);
                 actionService.addAction(ActionType.XQ, ActionStatus.PS, ztStory.getId(), ztStory.getProduct() + "", ztStory.getProject(), null,
                         RiskUserThreadLocal.get().getName(), dto.getClosedreason(), str);
@@ -372,19 +406,11 @@ public class ZtStoryServiceImpl extends ServiceImpl<ZtStoryMapper, ZtStory> impl
 
 
 
-
-
-
-
-
-
-        // 1.如果是产品   那么关联  项目   执行   2.如果是项目   关联执行
         if(dto.getExecution()!=null&&dto.getExecution()!=0){
-
+            //1.没有绑定  解绑
-
             ZtProjectstory execStory = this.projectstoryService.getOne(new QueryWrapper<ZtProjectstory>().lambda().eq(ZtProjectstory::getStory, ztStory.getId())
                     .ne(ZtProjectstory::getExecution, 0));
-            //如果没有关联过迭代
+            //如果没有关联过迭代 去关联  第一次
             if(execStory==null){
                 //如果是产品型需求  加项目   加迭代    如果是项目型产品  加迭代
 
@@ -417,18 +443,78 @@ public class ZtStoryServiceImpl extends ServiceImpl<ZtStoryMapper, ZtStory> impl
                 d.setStoryIds(new ArrayList<>(){{add(ztStory.getId());}});
                 projectService.executionSyncStory(d);
             }
+            else if(dto.getExecution().intValue()==pList.get(0).getExecution().intValue()){
+                //编辑没动  不用管
+            }else{
 
 
+
+                //2.绑定了  切换
+                //1. 删除projectStory   迭代的  删除看板
+                projectService.removeExecutionStory(ztStory.getId());
+                //2. 新增
+                ZtProjectDTO d=new ZtProjectDTO();
+                d.setExcludeId(dto.getExecution());
+                d.setStoryIds(new ArrayList<>(){{add(ztStory.getId());}});
+                projectService.executionSyncStory(d);
+            }
+
         }
-
+//        else{
+//            List<ZtTask> list = this.taskService.list(new QueryWrapper<ZtTask>().lambda().eq(ZtTask::getStory, ztStory.getId()));
+//            if(!CollectionUtils.isEmpty(list)){
+//                throw new BusinessException("当前任务已开始无法更换迭代");
+//            }
+//            //3可能解绑  查询是否以前关联过
+//            projectService.removeExecutionStory(ztStory.getId());
+//        }
     }
 
 
+    @Override
+    public void addRemark(ZtStoryDTO dto) {
+        ZtStory ztStory = this.baseMapper.selectById(dto.getId());
+        List<ZtProjectstory> list = this.projectstoryService.list(new QueryWrapper<ZtProjectstory>().lambda().eq(ZtProjectstory::getStory, dto.getId()));
+
+        Integer projectId=null;
+        Integer executionId=null;
+        if(!CollectionUtils.isEmpty(list)){
+            List<ZtProjectstory> projectList = list.stream().filter(o -> o.getProject() != null && o.getProject() != 0).collect(Collectors.toList());
+            if(!CollectionUtils.isEmpty(projectList)){
+                projectId=projectList.get(0).getProject();
+            }
+            List<ZtProjectstory> executionList = list.stream().filter(o -> o.getProject() != null && o.getProject() != 0).collect(Collectors.toList());
+            if(!CollectionUtils.isEmpty(executionList)){
+                executionId=executionList.get(0).getExecution();
+            }
+        }
+        actionService.addAction(ActionType.XQ, ActionStatus.TJBZ, dto.getId(), ztStory.getProduct() + "", projectId, executionId,
+                RiskUserThreadLocal.get().getName(), dto.getRemark(), "");
+    }
+
+    @Override
+    public List<ZtStoryDTO> myStoryList(ZtProjectQo qo) {
+
+        List<ZtStory> closed = this.baseMapper.selectList(new QueryWrapper<ZtStory>().lambda()
+                .ne(ZtStory::getStatus, "closed")
+                .eq(ZtStory::getAssignedTo, RiskUserThreadLocal.get().getName())
+                .or().eq(ZtStory::getOpenedby, RiskUserThreadLocal.get().getName())
+        );
+        if(CollectionUtils.isEmpty(closed)){
+            return new ArrayList<>();
+        }
+        return BeanCopyUtil.copyListProperties(closed,ZtStoryDTO::new);
+    }
+
     @Override
     public PageInfo<ZtStoryDTO> projectStoryPageList(ZtProjectQo qo) {
         Page<ZtStoryDTO> page = PageHelper.startPage(qo.getCurrentPage(), qo.getPageSize());
         Integer productId = qo.getProductId();
+        if(!"admin".equals(RiskUserThreadLocal.get().getName())){
+            qo.setUserName(RiskUserThreadLocal.get().getName());
+        }
         qo.setUserName(RiskUserThreadLocal.get().getName());
+        //
         List<ZtStoryDTO> list = this.baseMapper.projectStoryPageList(qo);
         if (!CollectionUtils.isEmpty(list)) {
             Map<Integer, List<ZtStoryreviewDTO>> rMap = getReviewMap(list);
@@ -465,7 +551,7 @@ public class ZtStoryServiceImpl extends ServiceImpl<ZtStoryMapper, ZtStory> impl
     }
 
     //需求id  执行
-    private Map<Integer, ZtProject> getExecutionMapByStory(List<ZtStoryDTO> list) {
+    public Map<Integer, ZtProject> getExecutionMapByStory(List<ZtStoryDTO> list) {
         List<ZtProjectstory> pStoryList = projectstoryService.list(new QueryWrapper<ZtProjectstory>().lambda().ne(ZtProjectstory::getExecution, 0)
                 .in(ZtProjectstory::getStory, list.stream().map(o -> o.getId()).collect(Collectors.toList()))
         );
@@ -566,11 +652,13 @@ public class ZtStoryServiceImpl extends ServiceImpl<ZtStoryMapper, ZtStory> impl
     @Override
     @Transactional
     public void startStory(Integer id, Integer execution) {
-
+        if(id==null||id==0){
+            return;
+        }
         ZtStory ztStory = this.baseMapper.selectById(id);
 
         if("closed".equals(ztStory.getStatus())){
-            throw new BusinessException("当前已关闭");
+            throw new BusinessException("需求当前已关闭");
         }
 
         List<String> stateList = Arrays.asList("wait", "projected");
@@ -611,13 +699,36 @@ public class ZtStoryServiceImpl extends ServiceImpl<ZtStoryMapper, ZtStory> impl
     @Override
     @Transactional
     public void finishStory(Integer id, Integer execution) {
-        ZtStory ztStory = this.baseMapper.selectById(id);
 
+        if(id==null||id==0){
+            return;
+        }
+        ZtStory ztStory = this.baseMapper.selectById(id);
+        if(ztStory==null){
+            throw new BusinessException("未查询到需求");
+        }
         if(!Arrays.asList("wait","projected","developing").contains(ztStory.getStage())){
+            if("testing".equals(ztStory.getStage())){
+                List<ZtTask> list = taskService.list(new QueryWrapper<ZtTask>().lambda().eq(ZtTask::getStory, id)
+                        .in(ZtTask::getStatus, Arrays.asList("wait", "doing", "pause"))
+                        .in(ZtTask::getType,"devel","test")
+                );
+                if (!CollectionUtils.isEmpty(list)) {
+                    return;
+                }else{
+                    ztStory.setStage("tested");
+                    this.baseMapper.updateById(ztStory);
+                    kanbanlaneService.changeStatus(execution,id,"story","tested");
+                    actionService.addAction(ActionType.XQ, ActionStatus.CSWC, ztStory.getId(), ztStory.getProduct() + "", ztStory.getProject(), null,
+                            RiskUserThreadLocal.get().getName(), null, "");
+                }
+            }
             return;
         }
         List<ZtTask> list = taskService.list(new QueryWrapper<ZtTask>().lambda().eq(ZtTask::getStory, id)
-                .in(ZtTask::getStatus, Arrays.asList("wait", "doing", "pause")));
+                .in(ZtTask::getStatus, Arrays.asList("wait", "doing", "pause"))
+                .eq(ZtTask::getType,"devel")
+        );
 
         if (!CollectionUtils.isEmpty(list)) {
             return;
@@ -629,6 +740,195 @@ public class ZtStoryServiceImpl extends ServiceImpl<ZtStoryMapper, ZtStory> impl
                 RiskUserThreadLocal.get().getName(), null, "");
     }
 
+    @Override
+    public void testedStory(Integer story) {
+
+        if(story==null||story==0){
+            return;
+        }
+
+        ZtStory ztStory = this.baseMapper.selectById(story);
+        if(ztStory==null){
+            throw new BusinessException("未查询到数据-需求");
+        }
+
+        if(!Arrays.asList("wait","projected","developing","developed","testing").contains(ztStory.getStage())){
+            return;
+        }
+
+        if("closed".equals(ztStory.getStatus())){
+            throw new BusinessException("当前已关闭");
+        }
+        if(!"testing".equals(ztStory.getStage())){
+            throw new BusinessException("当前无法更改测试状态");
+        }
+        List<Integer> execIds = getExecutionId(ztStory);
+        if(CollectionUtils.isEmpty(execIds)){
+            throw new BusinessException("当前无迭代，不可以更改");
+        }
+        List<ZtTask> list = taskService.list(new QueryWrapper<ZtTask>().lambda().eq(ZtTask::getStory, story)
+                .in(ZtTask::getStatus, Arrays.asList("wait", "doing", "pause"))
+                .in(ZtTask::getType,"test","devel")
+        );
+        if (!CollectionUtils.isEmpty(list)) {
+            return;
+        }
+        String oldStatus = ztStory.getStage();
+
+
+        String newStatus ="tested";
+
+        ztStory.setStage(newStatus);
+        if("tested".equals(newStatus)&&ztStory.getStartDate()==null){
+            actionService.addAction(ActionType.XQ, ActionStatus.CSWC, ztStory.getId(), ztStory.getProduct() + "", ztStory.getProject(), null,
+                    RiskUserThreadLocal.get().getName(), null, "");
+        }
+        this.baseMapper.updateById(ztStory);
+
+        for (Integer execId : execIds) {
+            if(execId!=null){
+                this.kanbanlaneService.changeStatus(execId, ztStory.getId(), "story","tested");
+                if (!oldStatus.equalsIgnoreCase(newStatus)&&ztStory.getProduct()!=0) {
+
+                    ProductStoryStatus oldPStatus = null;
+                    ProductStoryStatus newPStatus = null;
+
+                    oldPStatus = getProductStatus(oldStatus);
+
+                    newPStatus = getProductStatus(newStatus);
+
+                    this.productService.productChangeStatus(ztStory.getProduct(), oldPStatus, newPStatus);
+                }
+            }
+        }
+
+    }
+
+
+    @Override
+    @Transactional
+    public void releaseStory(Integer story) {
+        if(story==null||story==0){
+            return;
+        }
+
+        ZtStory ztStory = this.baseMapper.selectById(story);
+        if(ztStory==null){
+            throw new BusinessException("未查询到数据-需求");
+        }
+
+        if(!Arrays.asList("wait","projected","developing","developed","testing","tested").contains(ztStory.getStage())){
+            return;
+        }
+
+        if("closed".equals(ztStory.getStatus())){
+            throw new BusinessException("当前已关闭");
+        }
+        if(!"tested".equals(ztStory.getStage())){
+            throw new BusinessException("当前无法更改发布状态");
+        }
+        List<Integer> execIds = getExecutionId(ztStory);
+        if(CollectionUtils.isEmpty(execIds)){
+            throw new BusinessException("当前无迭代，不可以更改");
+        }
+        List<ZtTask> list = taskService.list(new QueryWrapper<ZtTask>().lambda().eq(ZtTask::getStory, story)
+                .in(ZtTask::getStatus, Arrays.asList("wait", "doing", "pause"))
+                .in(ZtTask::getType,"test","devel")
+        );
+        if (!CollectionUtils.isEmpty(list)) {
+            throw new BusinessException("当前有存在的任务未完成");
+        }
+        String oldStatus = ztStory.getStage();
+
+
+        String newStatus ="released";
+
+        ztStory.setStage(newStatus);
+        if("released".equals(newStatus)){
+            List<ZtProjectstory> execList = this.projectstoryService.list(new QueryWrapper<ZtProjectstory>().lambda().eq(ZtProjectstory::getStory, story).ne(ZtProjectstory::getExecution, 0));
+            Integer execId=null;
+            if(!CollectionUtils.isEmpty(execList)){
+                execId=execList.get(0).getExecution();
+            }
+            actionService.addAction(ActionType.XQ, ActionStatus.FB, ztStory.getId(), ztStory.getProduct() + "", ztStory.getProject(), execId,
+                    RiskUserThreadLocal.get().getName(), null, "");
+        }
+        this.baseMapper.updateById(ztStory);
+
+        for (Integer execId : execIds) {
+            if(execId!=null){
+                this.kanbanlaneService.changeStatus(execId, ztStory.getId(), "story","released");
+                if (!oldStatus.equalsIgnoreCase(newStatus)&&ztStory.getProduct()!=0) {
+
+                    ProductStoryStatus oldPStatus = null;
+                    ProductStoryStatus newPStatus = null;
+
+                    oldPStatus = getProductStatus(oldStatus);
+
+                    newPStatus = getProductStatus(newStatus);
+
+                    this.productService.productChangeStatus(ztStory.getProduct(), oldPStatus, newPStatus);
+                }
+            }
+        }
+    }
+
+    @Override
+    public void testingStory(Integer story) {
+        if(story==null||story==0){
+            return;
+        }
+
+        ZtStory ztStory = this.baseMapper.selectById(story);
+        if(ztStory==null){
+            throw new BusinessException("未查询到数据-需求");
+        }
+        if(!Arrays.asList("wait","projected","developing","developed").contains(ztStory.getStage())){
+            return;
+        }
+        if("closed".equals(ztStory.getStatus())){
+            throw new BusinessException("当前已关闭");
+        }
+//        if(!"developed".equals(ztStory.getStage())){
+//            throw new BusinessException("当前无法更改测试状态");
+//        }
+        List<Integer> execIds = getExecutionId(ztStory);
+        if(CollectionUtils.isEmpty(execIds)){
+            throw new BusinessException("当前无迭代，不可以更改");
+        }
+
+        String oldStatus = ztStory.getStage();
+
+
+        String newStatus ="testing";
+
+        ztStory.setStage(newStatus);
+        if("testing".equals(newStatus)&&ztStory.getStartDate()==null){
+            actionService.addAction(ActionType.XQ, ActionStatus.KSCE, ztStory.getId(), ztStory.getProduct() + "", ztStory.getProject(), null,
+                    RiskUserThreadLocal.get().getName(), null, "");
+        }
+        this.baseMapper.updateById(ztStory);
+
+        for (Integer execId : execIds) {
+            if(execId!=null){
+                this.kanbanlaneService.changeStatus(execId, ztStory.getId(), "story","testing");
+                if (!oldStatus.equalsIgnoreCase(newStatus)&&ztStory.getProduct()!=0) {
+
+                    ProductStoryStatus oldPStatus = null;
+                    ProductStoryStatus newPStatus = null;
+
+                    oldPStatus = getProductStatus(oldStatus);
+
+                    newPStatus = getProductStatus(newStatus);
+
+                    this.productService.productChangeStatus(ztStory.getProduct(), oldPStatus, newPStatus);
+                }
+            }
+        }
+
+    }
+
+
     @Override
     @Transactional
     public void changeStatus(ZtStoryDTO dto) {
@@ -656,6 +956,9 @@ public class ZtStoryServiceImpl extends ServiceImpl<ZtStoryMapper, ZtStory> impl
 
 
             String newStatus =dto.getStage();
+            if(newStatus.equals("wait")){
+                newStatus="ready";
+            }
 
             if("closed".equalsIgnoreCase(newStatus)){
                 ztStory.setStatus("closed");
@@ -667,7 +970,7 @@ public class ZtStoryServiceImpl extends ServiceImpl<ZtStoryMapper, ZtStory> impl
                 actionService.addAction(ActionType.XQ, ActionStatus.GB, ztStory.getId(), ztStory.getProduct() + "", ztStory.getProject(), null,
                         RiskUserThreadLocal.get().getName(), null, "");
             }else{
-                ztStory.setStage(newStatus);
+                ztStory.setStage(dto.getStage());
             }
             if("released".equals(newStatus)&&ztStory.getEndDate()==null){
                 ztStory.setEndDate(new Date());
@@ -683,7 +986,7 @@ public class ZtStoryServiceImpl extends ServiceImpl<ZtStoryMapper, ZtStory> impl
 
             for (Integer execId : execIds) {
                 if(execId!=null){
-                    this.kanbanlaneService.changeStatus(execId, i, "story", dto.getStage());
+                    this.kanbanlaneService.changeStatus(execId, i, "story", newStatus);
                     if (!oldStatus.equalsIgnoreCase(newStatus)&&ztStory.getProduct()!=0) {
 
                         ProductStoryStatus oldPStatus = null;
@@ -778,6 +1081,100 @@ public class ZtStoryServiceImpl extends ServiceImpl<ZtStoryMapper, ZtStory> impl
         }
     }
 
+    @Override
+    public ZtStory getPrdById(Integer id) {
+        return this.baseMapper.getPrdById(id);
+    }
+
+    @Override
+    public PageInfo<ZtStoryDTO> myStoryPageList(ZtProjectQo qo) {
+        Page<ZtStoryDTO> page = null;
+        Integer productId = qo.getProductId();
+        LoginRiskUser loginRiskUser = RiskUserThreadLocal.get();
+//        if(!"admin".equals(loginRiskUser.getName())){
+//
+//        }
+        qo.setUserName(loginRiskUser.getName());
+        List<ZtStoryDTO> list =null;
+
+        //首页根据id查询的
+        if(!StringUtils.isEmpty(qo.getIds())){
+            String[] split = qo.getIds().split(",");
+            List<String> ids =new ArrayList<>(Arrays.asList(split));
+            list=this.baseMapper.storyPageListByIds(ids);
+        }else{
+            if(UserType.KFZ==loginRiskUser.getUserType()||UserType.CS==loginRiskUser.getUserType()){
+
+                page= PageHelper.startPage(qo.getCurrentPage(), qo.getPageSize());
+                qo.setKfz(1);
+                list=this.baseMapper.projectStoryPageList(qo);
+            }else if(UserType.GSGC==loginRiskUser.getUserType()){
+                //全部
+                page= PageHelper.startPage(qo.getCurrentPage(), qo.getPageSize());
+                list=this.baseMapper.allStoryPageList(qo);
+            }else{
+                //自己有权限的  产品集
+                List<Integer> integers = this.projectService.authList();
+
+                if(!CollectionUtils.isEmpty(integers)){
+                    List<ZtProduct> pList = this.productService.list(new QueryWrapper<ZtProduct>().lambda().in(ZtProduct::getProgram, integers));
+                    //所有的产品
+                    if(!CollectionUtils.isEmpty(pList)){
+                        qo.setProductIds(pList.stream().map(o->o.getId()).collect(Collectors.toList()));
+                        page= PageHelper.startPage(qo.getCurrentPage(), qo.getPageSize());
+                        list=this.baseMapper.myStoryPageList(qo);
+                    }else{
+                        list=new ArrayList<>();
+                    }
+
+                }else{
+                    list=new ArrayList<>();
+                }
+
+            }
+
+        }
+
+
+
+
+
+        if (!CollectionUtils.isEmpty(list)) {
+            Map<Integer, List<ZtStoryreviewDTO>> rMap = getReviewMap(list);
+
+
+            Map<Integer,ZtProject> execMap= getExecutionMapByStory(list);
+            List<String> userIds = list.stream().map(o -> o.getAssignedTo()).collect(Collectors.toList());
+            userIds.addAll(list.stream().map(o -> o.getOpenedby()).collect(Collectors.toList()));
+
+
+            Map<String, ZtUser> userMap = this.userService.userMapByIds(userIds);
+
+
+            for (ZtStoryDTO d : list) {
+                d.setRevieweUser(d.getReviewedby().replaceAll(",", " "));
+                d.setViews(rMap.get(d.getId()));
+                ZtProject ztProject = execMap.get(d.getId());
+                if(ztProject!=null){
+                    d.setPlan(ztProject.getName());
+                }
+                ZtUser ztUser = userMap.get(d.getAssignedTo());
+                if(ztUser!=null){
+                    d.setAssignedToName(ztUser.getNickname());
+                }
+
+                ztUser = userMap.get(d.getOpenedby());
+                if(ztUser!=null){
+                    d.setOpenedbyName(ztUser.getNickname());
+                }
+            }
+        }
+
+        return new PageInfo<ZtStoryDTO>(list);
+    }
+
+
+
     private void closeTaskBug(Integer i) {
         List<ZtTask> taskList = this.taskService.list(new QueryWrapper<ZtTask>().lambda().eq(ZtTask::getStory,i).ne(ZtTask::getStatus,"closed"));
 
@@ -872,7 +1269,7 @@ public class ZtStoryServiceImpl extends ServiceImpl<ZtStoryMapper, ZtStory> impl
         }
         //删除评审表
         this.storyreviewService.remove(new QueryWrapper<ZtStoryreview>().lambda()
-                .eq(ZtStoryreview::getStory, ztStory.getId()));
+                .eq(ZtStoryreview::getStory, ztStory.getId()).eq(ZtStoryreview::getType,"story"));
 
         //更新表
         this.baseMapper.update(new UpdateWrapper<ZtStory>()
@@ -901,6 +1298,7 @@ public class ZtStoryServiceImpl extends ServiceImpl<ZtStoryMapper, ZtStory> impl
                 v.setStory(ztStory.getId());
                 v.setVersion(ztStory.getVersion());
                 v.setReviewer(str);
+                v.setType("story");
                 this.storyreviewService.save(v);
             }
         }
@@ -919,6 +1317,7 @@ public class ZtStoryServiceImpl extends ServiceImpl<ZtStoryMapper, ZtStory> impl
         Integer revieweResult = dto.getRevieweResult();
         ztStory.setStage("verified");
         ztStory.setYsFlag(revieweResult);
+        ztStory.setYsRemark(dto.getDesc());
         this.baseMapper.updateById(ztStory);
         ActionStatus status;
         if(revieweResult==1){
@@ -936,8 +1335,29 @@ public class ZtStoryServiceImpl extends ServiceImpl<ZtStoryMapper, ZtStory> impl
     public ZtStoryDTO getStoryById(Integer id) {
         ZtStory ztStory = this.baseMapper.selectById(id);
         ZtStoryDTO d=new ZtStoryDTO();
+
         BeanUtils.copyProperties(ztStory,d);
-            List<String> userIds = new ArrayList<>();
+        if(d.getProduct()!=null&&d.getProduct()!=0){
+            ZtProduct product = this.productService.getById(d.getProduct());
+
+            d.setProductId(product.getId());
+            d.setProductName(product.getName());
+        }
+        ZtProjectstory projectstory = this.projectstoryService.getOne(new QueryWrapper<ZtProjectstory>().lambda().eq(ZtProjectstory::getStory, ztStory.getId()).ne(ZtProjectstory::getProject,0));
+        if(projectstory!=null){
+            ZtProject ztProject = this.projectService.getById(projectstory.getProject());
+
+            d.setProjectId(ztProject.getId());
+            d.setProjectName(ztProject.getName());
+        }
+        ZtProjectstory execstory = this.projectstoryService.getOne(new QueryWrapper<ZtProjectstory>().lambda().eq(ZtProjectstory::getStory, ztStory.getId()).ne(ZtProjectstory::getExecution,0));
+        if(execstory!=null){
+            ZtProject ztProject = this.projectService.getById(execstory.getExecution());
+
+            d.setImplementId(ztProject.getId());
+            d.setImplementName(ztProject.getName());
+        }
+        List<String> userIds = new ArrayList<>();
             userIds.add(ztStory.getAssignedTo());
             userIds.add(ztStory.getOpenedby());
 
@@ -995,6 +1415,7 @@ public class ZtStoryServiceImpl extends ServiceImpl<ZtStoryMapper, ZtStory> impl
         ZtStoryreview view = this.storyreviewService.getOne(new QueryWrapper<ZtStoryreview>().lambda()
                 .eq(ZtStoryreview::getStory, ztStory.getId())
                 .eq(ZtStoryreview::getReviewer, RiskUserThreadLocal.get().getName())
+                .eq(ZtStoryreview::getType,"story")
         );
         if (view == null) {
             throw new BusinessException("当前无评审");
@@ -1016,12 +1437,13 @@ public class ZtStoryServiceImpl extends ServiceImpl<ZtStoryMapper, ZtStory> impl
         lambda.set(ZtStoryreview::getReviewdate, new Date());
         lambda.eq(ZtStoryreview::getStory, ztStory.getId());
         lambda.eq(ZtStoryreview::getReviewer, RiskUserThreadLocal.get().getName());
+        lambda.eq(ZtStoryreview::getType,"story");
         this.storyreviewService.update(lambda);
 
 
         ztStory.setReviewedby(StringUtils.isEmpty(ztStory.getReviewedby()) ? "," + RiskUserThreadLocal.get().getName() : ztStory.getReviewedby() + "," + RiskUserThreadLocal.get().getName());
         List<ZtStoryreview> list = this.storyreviewService.list(new QueryWrapper<ZtStoryreview>().lambda()
-                .eq(ZtStoryreview::getStory, ztStory.getId())
+                .eq(ZtStoryreview::getStory, ztStory.getId()).eq(ZtStoryreview::getType,"story")
         );
 
         if (list.stream().filter(o -> o.getReviewdate() != null).collect(Collectors.toList()).size() >= list.size()) {
@@ -1141,7 +1563,7 @@ public class ZtStoryServiceImpl extends ServiceImpl<ZtStoryMapper, ZtStory> impl
 
         ProductStoryStatus oldPStatus = null;
         if (status.equalsIgnoreCase("developing")||status.equalsIgnoreCase("testing")
-                ||status.equalsIgnoreCase("tested")
+                ||status.equalsIgnoreCase("tested")||status.equalsIgnoreCase("developed")
         ) {
 
             oldPStatus = ProductStoryStatus.JH;

src/main/java/com/sa/zentao/service/impl/ZtStoryUserServiceImpl.java

@@ -1,6 +1,8 @@
 package com.sa.zentao.service.impl;
 
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
 import com.github.pagehelper.Page;
 import com.github.pagehelper.PageHelper;
@@ -10,13 +12,13 @@ import com.sa.zentao.dao.*;
 import com.sa.zentao.entity.*;
 import com.sa.zentao.enums.ActionStatus;
 import com.sa.zentao.enums.ActionType;
+import com.sa.zentao.enums.FileTypes;
 import com.sa.zentao.mapper.ZtStoryUserMapper;
 import com.sa.zentao.qo.StoryQo;
-import com.sa.zentao.service.IZtActionService;
+import com.sa.zentao.qo.ZtProjectQo;
-import com.sa.zentao.service.IZtStoryService;
+import com.sa.zentao.service.*;
-import com.sa.zentao.service.IZtStoryUserService;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import com.sa.zentao.service.IZtUserService;
+import com.sa.zentao.utils.BeanCopyUtil;
 import com.sa.zentao.utils.Constant;
 import com.sa.zentao.utils.DateUtils;
 import org.apache.commons.lang3.StringUtils;
@@ -50,6 +52,14 @@ public class ZtStoryUserServiceImpl extends ServiceImpl<ZtStoryUserMapper, ZtSto
     @Autowired
     private IZtStoryService storyService;
 
+    @Autowired
+    private IZtStoryreviewService storyreviewService;
+
+    @Autowired
+    private IZtProductService productService;
+
+    @Autowired
+    private IZtFileService fileService;
 
     @Override
     @Transactional
@@ -63,14 +73,32 @@ public class ZtStoryUserServiceImpl extends ServiceImpl<ZtStoryUserMapper, ZtSto
         s.setVersion(1);
         s.setLasteditedby(RiskUserThreadLocal.get().getName());
         s.setLastediteddate(new Date());
-        s.setStatus("active");
+        if(!"draft".equals(dto.getStatus())){
+            s.setStatus("reviewing");
+        }
         s.setStage("wait");
         this.baseMapper.insert(s);
 
-
+        fileService.updateFile(dto.getFiles(),s.getId(), FileTypes.userStory);
 
         actionService.addAction(ActionType.USERXQ, ActionStatus.XJ, s.getId(),  dto.getProduct()+"", null, null,
                 RiskUserThreadLocal.get().getName(), dto.getClosedreason(), "");
+
+        if (!CollectionUtils.isEmpty(dto.getUserViewId())) {
+            for (String str : dto.getUserViewId()) {
+                ZtStoryreview v = new ZtStoryreview();
+                v.setStory(s.getId());
+                v.setVersion(s.getVersion());
+                v.setReviewer(str);
+                v.setType("userStory");
+                this.storyreviewService.save(v);
+                actionService.addAction(ActionType.XQ, ActionStatus.PS, s.getId(), s.getProduct() + "", s.getProject(), null,
+                        RiskUserThreadLocal.get().getName(), dto.getClosedreason(), str);
+            }
+
+        }
+
+
     }
 
     @Override
@@ -89,8 +117,13 @@ public class ZtStoryUserServiceImpl extends ServiceImpl<ZtStoryUserMapper, ZtSto
         BeanUtils.copyProperties(dto, ztStory);
         ztStory.setLasteditedby(RiskUserThreadLocal.get().getName());
         ztStory.setLastediteddate(new Date());
+        if("draft".equals(dto.getStatus())){
+            ztStory.setStatus("reviewing");
+        }
         this.baseMapper.updateById(ztStory);
 
+        fileService.updateFile(dto.getFiles(),ztStory.getId(), FileTypes.userStory);
+
         actionService.addAction(ActionType.USERXQ, ActionStatus.BJ, dto.getId(), dto.getProduct() + "", dto.getProject(), null,
                     RiskUserThreadLocal.get().getName(), dto.getRemark(), "");
 
@@ -101,6 +134,12 @@ public class ZtStoryUserServiceImpl extends ServiceImpl<ZtStoryUserMapper, ZtSto
         Page<ZtStoryUserDTO> page = PageHelper.startPage(qo.getCurrentPage(), qo.getPageSize());
 
         qo.setUserName(RiskUserThreadLocal.get().getName());
+
+        if(!StringUtils.isEmpty(qo.getIds())){
+            String[] split = qo.getIds().split(",");
+            qo.setStoryIds(new ArrayList<>(Arrays.asList(split)));
+        }
+
         List<ZtStoryUserDTO> list = this.baseMapper.pageList(qo);
         if (!CollectionUtils.isEmpty(list)) {
 
@@ -113,8 +152,13 @@ public class ZtStoryUserServiceImpl extends ServiceImpl<ZtStoryUserMapper, ZtSto
 
             Map<Integer, List<ZtStory>> storyUserMap = getStoryUserMap(list);
 
+            Map<Integer, List<ZtStoryreviewDTO>> rMap = getReviewMap(list);
 
             for (ZtStoryUserDTO d : list) {
+
+                d.setRevieweUser(d.getReviewedby().replaceAll(",", " "));
+                d.setViews(rMap.get(d.getId()));
+
                 ZtUser ztUser = userMap.get(d.getOpenedby());
                 if(ztUser!=null){
                     d.setOpenedby(ztUser.getNickname());
@@ -151,6 +195,102 @@ public class ZtStoryUserServiceImpl extends ServiceImpl<ZtStoryUserMapper, ZtSto
                 RiskUserThreadLocal.get().getName(), dto.getRemark(), "");
     }
 
+    @Override
+    public List<ZtStoryUserDTO> storyListByProductId(ZtProjectQo qo) {
+        LambdaQueryWrapper<ZtStoryUser> eq = new QueryWrapper<ZtStoryUser>()
+                .lambda().eq(ZtStoryUser::getProduct, qo.getProductId())
+                .eq(ZtStoryUser::getDeleted, "0");
+
+        List<ZtStoryUser> ztStories = this.baseMapper.selectList(eq);
+        if (CollectionUtils.isEmpty(ztStories)) {
+            return new ArrayList<>();
+        } else {
+            return BeanCopyUtil.copyListProperties(ztStories, ZtStoryUserDTO::new);
+        }
+    }
+
+    @Override
+    public void userReview(ZtStoryDTO dto) {
+        ZtStoryUser ztStory = this.baseMapper.selectById(dto.getId());
+        if("closed".equals(ztStory.getStatus())){
+            throw new BusinessException("当前已关闭");
+        }
+        ZtStoryreview view = this.storyreviewService.getOne(new QueryWrapper<ZtStoryreview>().lambda()
+                .eq(ZtStoryreview::getStory, ztStory.getId())
+                .eq(ZtStoryreview::getReviewer, RiskUserThreadLocal.get().getName())
+                .eq(ZtStoryreview::getType,"userStory")
+        );
+        if (view == null) {
+            throw new BusinessException("当前无评审");
+        }
+        LambdaUpdateWrapper<ZtStoryreview> lambda = new UpdateWrapper<ZtStoryreview>
+                ().lambda();
+        ActionStatus actionStatus = null;
+        if (dto.getRevieweResult() == 1) {
+            //通过
+            lambda.set(ZtStoryreview::getResult, "pass");
+            actionStatus=ActionStatus.PSTG;
+        } else if (dto.getRevieweResult() == 2) {
+            lambda.set(ZtStoryreview::getResult, "reject");
+            actionStatus=ActionStatus.PSYDMQ;
+        } else {
+            lambda.set(ZtStoryreview::getResult, "reject");
+            actionStatus=ActionStatus.PSBTG;
+        }
+        lambda.set(ZtStoryreview::getReviewdate, new Date());
+        lambda.eq(ZtStoryreview::getStory, ztStory.getId());
+        lambda.eq(ZtStoryreview::getReviewer, RiskUserThreadLocal.get().getName());
+        lambda.eq(ZtStoryreview::getType,"userStory");
+        this.storyreviewService.update(lambda);
+
+
+        ztStory.setReviewedby(StringUtils.isEmpty(ztStory.getReviewedby()) ? "," + RiskUserThreadLocal.get().getName() : ztStory.getReviewedby() + "," + RiskUserThreadLocal.get().getName());
+        List<ZtStoryreview> list = this.storyreviewService.list(new QueryWrapper<ZtStoryreview>().lambda()
+                .eq(ZtStoryreview::getStory, ztStory.getId()).eq(ZtStoryreview::getType,"userStory")
+        );
+
+        if (list.stream().filter(o -> o.getReviewdate() != null).collect(Collectors.toList()).size() >= list.size()) {
+            //end
+            List<ZtStoryreview> rejectList = list.stream().filter(o -> "reject".equalsIgnoreCase(o.getResult())).collect(Collectors.toList());
+            if (!CollectionUtils.isEmpty(rejectList)) {
+                ztStory.setStatus("closed");
+            } else {
+                ztStory.setStatus("active");
+                ztStory.setStage("wait");
+                ztStory.setRevieweddate(
+                        new Date()
+                );
+            }
+        }
+        if (dto.getRevieweResult() == 2 || dto.getRevieweResult() == 0) {
+            ztStory.setStatus("closed");
+            ztStory.setClosedreason(dto.getClosedreason());
+        }
+        this.baseMapper.updateById(ztStory);
+
+        //添加action
+        actionService.addAction(ActionType.USERXQ, actionStatus, ztStory.getId(), ztStory.getProduct() + "", ztStory.getProject(), null,
+                RiskUserThreadLocal.get().getName(), dto.getDesc(), ztStory.getAssignedto());
+
+
+//        if("active".equalsIgnoreCase(ztStory.getStatus())||"closed".equalsIgnoreCase(ztStory.getStatus())){
+//            Integer product = ztStory.getProduct();
+//            if(product!=null&&product!=0){
+//                ZtProduct ztProduct = this.productService.getById(product);
+//                ztProduct.setReviewingStories(ztProduct.getReviewingStories()-1);
+//                if("active".equalsIgnoreCase(ztStory.getStatus())){
+//                    ztProduct.setActiveStories(ztProduct.getActiveStories()+1);
+//                }else{
+//                    ztProduct.setClosedStories(ztProduct.getClosedStories()+1);
+//                }
+//                this.productService.updateById(ztProduct);
+//            }
+//
+//        }
+
+
+    }
+
     private Map<Integer, List<ZtStory>> getStoryUserMap(List<ZtStoryUserDTO> list) {
         List<Integer> ids = list.stream().map(o -> o.getId()).collect(Collectors.toList());
 
@@ -162,4 +302,32 @@ public class ZtStoryUserServiceImpl extends ServiceImpl<ZtStoryUserMapper, ZtSto
         }
     }
 
+
+
+    private Map<Integer, List<ZtStoryreviewDTO>> getReviewMap(List<ZtStoryUserDTO> list) {
+        List<ZtStoryreview> list1 = storyreviewService.list(new QueryWrapper<ZtStoryreview>().lambda().in(ZtStoryreview::getStory
+                , list.stream().map(o -> o.getId()).collect(Collectors.toList())
+        ).eq(ZtStoryreview::getType,"userStory"));
+
+        if (CollectionUtils.isEmpty(list1)) {
+            return new HashMap<>();
+        } else {
+            list1 = list1.stream().filter(o -> StringUtils.isEmpty(o.getResult())).collect(Collectors.toList());
+            if(CollectionUtils.isEmpty(list1)){
+                return new HashMap<>();
+            }
+
+            Map<String, ZtUser> userMap = this.userService.userMapByIds(list1.stream().map(o -> o.getReviewer()).collect(Collectors.toList()));
+            List<ZtStoryreviewDTO> ztStoryreviewDTOS = BeanCopyUtil.copyListProperties(list1, ZtStoryreviewDTO::new);
+            for (ZtStoryreviewDTO view:ztStoryreviewDTOS) {
+                ZtUser ztUser = userMap.get(view.getReviewer());
+                if(ztUser!=null){
+                    view.setReviewerName(ztUser.getNickname());
+                }
+            }
+
+            return  ztStoryreviewDTOS.stream().collect(Collectors.groupingBy(ZtStoryreviewDTO::getStory));
+
+        }
+    }
 }

src/main/java/com/sa/zentao/service/impl/ZtStoryspecServiceImpl.java

@@ -6,6 +6,8 @@ import com.sa.zentao.service.IZtStoryspecService;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import org.springframework.stereotype.Service;
 
+import java.util.List;
+
 /**
  * <p>
  *  服务实现类
@@ -17,4 +19,8 @@ import org.springframework.stereotype.Service;
 @Service
 public class ZtStoryspecServiceImpl extends ServiceImpl<ZtStoryspecMapper, ZtStoryspec> implements IZtStoryspecService {
 
+    @Override
+    public List<ZtStoryspec> getPrdById(Integer id) {
+        return this.baseMapper.getPrdById(id);
+    }
 }

src/main/java/com/sa/zentao/service/impl/ZtTaskServiceImpl.java

@@ -5,14 +5,14 @@ import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.github.pagehelper.Page;
 import com.github.pagehelper.PageHelper;
 import com.github.pagehelper.PageInfo;
+import com.sa.zentao.conf.LoginRiskUser;
 import com.sa.zentao.conf.RiskUserThreadLocal;
-import com.sa.zentao.dao.BusinessException;
+import com.sa.zentao.dao.*;
-import com.sa.zentao.dao.ZtEffortDTO;
-import com.sa.zentao.dao.ZtStoryDTO;
-import com.sa.zentao.dao.ZtTaskDTO;
 import com.sa.zentao.entity.*;
 import com.sa.zentao.enums.ActionStatus;
 import com.sa.zentao.enums.ActionType;
+import com.sa.zentao.enums.FileTypes;
+import com.sa.zentao.enums.UserType;
 import com.sa.zentao.mapper.ZtTaskMapper;
 import com.sa.zentao.qo.KanbanQo;
 import com.sa.zentao.qo.ZtProjectQo;
@@ -27,6 +27,7 @@ import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.util.CollectionUtils;
 
+import java.math.BigDecimal;
 import java.util.*;
 import java.util.stream.Collectors;
 
@@ -64,6 +65,11 @@ public class ZtTaskServiceImpl extends ServiceImpl<ZtTaskMapper, ZtTask> impleme
     @Autowired
     private IZtEffortService effortService;
 
+    @Autowired
+    private IZtProductService productService;
+
+    @Autowired
+    private IZtExecutionprojectService executionprojectService;
 
 
     @Override
@@ -93,9 +99,200 @@ public class ZtTaskServiceImpl extends ServiceImpl<ZtTaskMapper, ZtTask> impleme
         return new PageInfo<ZtTaskDTO>(list);
     }
 
+    @Override
+    public void assignedTo(ZtTaskDTO dto) {
+
+        ZtTask ztTask = this.baseMapper.selectById(dto.getId());
+        if(ztTask==null){
+            throw new BusinessException("未查询到数据");
+        }
+        ztTask.setAssignedTo(dto.getAssignedTo());
+        ztTask.setLasteditedby(RiskUserThreadLocal.get().getName());
+        ztTask.setLastediteddate(new Date());
+        this.baseMapper.updateById(ztTask);
+
+
+        ZtProjectproduct projectproduct = projectproductService.getOne(new QueryWrapper<ZtProjectproduct>().lambda().eq(ZtProjectproduct::getProject, ztTask.getProject()));
+
+
+        actionService.addAction(ActionType.RW, ActionStatus.FP,ztTask.getId()
+                ,projectproduct==null?null:projectproduct.getProduct().toString(),projectproduct==null?null:projectproduct.getProject(),ztTask.getExecution(),
+                RiskUserThreadLocal.get().getName(),null,null);
+    }
+
+    @Override
+    @Transactional
+    public void batchApproval(ZtTaskDTO dto) {
+        List<Integer> idList = dto.getIdList();
+
+        if(CollectionUtils.isEmpty(idList)){
+            throw new BusinessException("请检查");
+        }
+        List<ZtTask> ztTasks = this.listByIds(idList);
+        List<ZtTask> reviewingList = ztTasks.stream().filter(o -> !"reviewing".equals(o.getStatus())).collect(Collectors.toList());
+        if(!CollectionUtils.isEmpty(reviewingList)){
+            throw new BusinessException(reviewingList.get(0).getName()+"当前状态无法评审");
+        }
+        List<ZtTask> tList = reviewingList.stream().filter(o -> !RiskUserThreadLocal.get().getName().equals(o.getReviewingUser())).collect(Collectors.toList());
+        if(!CollectionUtils.isEmpty(tList)){
+            throw new BusinessException(tList.get(0).getName()+"当前评审人错误");
+        }
+        for (ZtTask t:ztTasks) {
+            if(dto.getApprovalStatus()==1){
+                t.setStatus("wait");
+            }else{
+                t.setStatus("closed");
+            }
+
+            t.setApprovalRemark(dto.getApprovalRemark());
+            t.setLastediteddate(new Date());
+            t.setLasteditedby(RiskUserThreadLocal.get().getName());
+            this.baseMapper.updateById(t);
+
+
+            ZtProjectproduct projectproduct = projectproductService.getOne(new QueryWrapper<ZtProjectproduct>().lambda().eq(ZtProjectproduct::getProject, t.getProject()));
+
+
+            if(dto.getApprovalStatus()==1){
+                actionService.addAction(ActionType.RW, ActionStatus.PSTG,t.getId(),projectproduct==null?null:projectproduct.getProduct().toString(),projectproduct==null?null:projectproduct.getProject(),t.getExecution(),
+                        RiskUserThreadLocal.get().getName(),dto.getApprovalRemark(),null);
+            }else if(dto.getApprovalStatus()==2){
+                actionService.addAction(ActionType.RW, ActionStatus.PSBTG,t.getId(),projectproduct==null?null:projectproduct.getProduct().toString(),projectproduct==null?null:projectproduct.getProject(),t.getExecution(),
+                        RiskUserThreadLocal.get().getName(),dto.getApprovalRemark(),null);
+            }
+        }
+    }
+
+    @Override
+    public List<ZtTaskDTO> myTaskList(ZtProjectQo qo) {
+        List<ZtTask> closed = this.baseMapper.selectList(new QueryWrapper<ZtTask>().lambda()
+                .ne(ZtTask::getStatus, "closed").eq(ZtTask::getOpenedby, RiskUserThreadLocal.get().getName())
+                .or().eq(ZtTask::getAssignedTo, RiskUserThreadLocal.get().getName())
+                .orderByDesc(ZtTask::getDeadline)
+                .orderByDesc(ZtTask::getId)
+        );
+        if(CollectionUtils.isEmpty(closed)){
+            return new ArrayList<>();
+        }
+
+        return BeanCopyUtil.copyListProperties(closed,ZtTaskDTO::new);
+    }
+
+
+
+    @Override
+    public void addRemark(ZtTaskDTO dto) {
+        ZtTask task = this.baseMapper.selectById(dto.getId());
+
+        Integer productId=null;
+        Integer projectId=null;
+        Integer execution=null;
+        if(task.getStory()!=null&&task.getStory()!=0){
+            ZtStory story = this.storyService.getById(task.getStory());
+            List<ZtProjectstory> list = this.projectstoryService.list(new QueryWrapper<ZtProjectstory>().lambda().eq(ZtProjectstory::getStory, task.getStory()));
+
+            if(!CollectionUtils.isEmpty(list)){
+                List<ZtProjectstory> projectList = list.stream().filter(o -> o.getProject() != null && o.getProject() != 0).collect(Collectors.toList());
+                if(!CollectionUtils.isEmpty(projectList)){
+                    projectId=projectList.get(0).getProject();
+                }
+                List<ZtProjectstory> executionList = list.stream().filter(o -> o.getProject() != null && o.getProject() != 0).collect(Collectors.toList());
+                if(!CollectionUtils.isEmpty(executionList)){
+                    execution=executionList.get(0).getExecution();
+                }
+            }
+        }
+
+
+        actionService.addAction(ActionType.RW, ActionStatus.TJBZ, dto.getId(), productId==null?"":productId+"", projectId, task.getExecution(),
+                RiskUserThreadLocal.get().getName(), dto.getRemark(), "");
+    }
+
+    @Override
+    public ZtTaskDTO getTaskById(Integer id) {
+        ZtTask ztTask = this.baseMapper.selectById(id);
+        if(ztTask==null){
+            throw new BusinessException("未查询到数据");
+        }
+        ZtTaskDTO dto=new ZtTaskDTO();
+        BeanUtils.copyProperties(ztTask,dto);
+        ZtProject project = this.ztProjectService.getById(ztTask.getExecution());
+        dto.setImplementId(project.getId());
+        dto.setImplementName(project.getName());
+
+        return dto;
+    }
+
+
+    @Override
+    public PageInfo<ZtTaskDTO> myTaskPageList(ZtProjectQo qo) {
+
+        qo.setUserName(RiskUserThreadLocal.get().getName());
+        LoginRiskUser loginRiskUser = RiskUserThreadLocal.get();
+        //执行ids
+        List<Integer> projectAuthList=new ArrayList<>();
+        if(UserType.GSGC!=loginRiskUser.getUserType()){
+
+
+            //自己有权限的  产品集
+            List<Integer> integers = this.ztProjectService.authList();
+
+            if(!CollectionUtils.isEmpty(integers)){
+                List<ZtProduct> pList = this.productService.list(new QueryWrapper<ZtProduct>().lambda().in(ZtProduct::getProgram, integers));
+                //所有的产品
+                if(!CollectionUtils.isEmpty(pList)){
+                    List<ZtProjectproduct> list = this.projectproductService.list(new QueryWrapper<ZtProjectproduct>().lambda().in(ZtProjectproduct::getProduct, pList.stream().map(o -> o.getId()).collect(Collectors.toList())));
+
+                    if(!CollectionUtils.isEmpty(list)){
+                        List<ZtExecutionproject> projectList = executionprojectService.list(new QueryWrapper<ZtExecutionproject>().lambda().in(ZtExecutionproject::getProject, list.stream().map(o -> o.getProject()).collect(Collectors.toList())));
+                        projectAuthList=projectList.stream().map(o->o.getExecution()).collect(Collectors.toList());
+
+                    }
+                }
+            }
+        }
+        if(UserType.GSGC!=loginRiskUser.getUserType()&&CollectionUtils.isEmpty(projectAuthList)){
+            return new PageInfo<ZtTaskDTO>();
+        }
+        Page<ZtTaskDTO> page = PageHelper.startPage(qo.getCurrentPage(), qo.getPageSize());
+        qo.setProjectIds(projectAuthList);
+
+        if(!StringUtils.isEmpty(qo.getIds())){
+            String[] split = qo.getIds().split(",");
+            qo.setObjIds(new ArrayList<>(Arrays.asList(split)));
+        }
+
+        List<ZtTaskDTO> list = this.baseMapper.taskPageList(qo);
+        if(!CollectionUtils.isEmpty(list)){
+            List<String> userIds = list.stream().map(o -> o.getFinishedby()).collect(Collectors.toList());
+            userIds.addAll(list.stream().map(o -> o.getAssignedTo()).collect(Collectors.toList()));
+            Map<String, ZtUser> userMap = this.userService.userMapByIds(userIds);
+
+            for (ZtTaskDTO task:list) {
+                ZtUser ztUser = userMap.get(task.getFinishedby());
+                if(ztUser!=null){
+                    task.setFinishedbyName(ztUser.getNickname());
+                }
+                ztUser = userMap.get(task.getAssignedTo());
+                if(ztUser!=null){
+                    task.setAssignedToName(ztUser.getNickname());
+                }
+
+
+            }
+
+        }
+        return new PageInfo<ZtTaskDTO>(list);
+    }
+
+
+
     @Autowired
     private IZtProjectstoryService projectstoryService;
 
+    @Autowired
+    private IZtFileService fileService;
+
     @Override
     @Transactional
     public void addTask(ZtTaskDTO dto) {
@@ -108,22 +305,46 @@ public class ZtTaskServiceImpl extends ServiceImpl<ZtTaskMapper, ZtTask> impleme
         //项目
         Integer story = ztTask.getStory();
         if(story!=null&&story!=0){
+            ZtStory ztStory = this.storyService.getById(story);
+            ztStory.setTaskCount(ztStory.getTaskCount()+1);
+            this.storyService.updateById(ztStory);
             List<ZtProjectstory> list = projectstoryService.list(new QueryWrapper<ZtProjectstory>().lambda().eq(ZtProjectstory::getStory, story)
             .ne(ZtProjectstory::getProject,0)
             );
 
             if(!CollectionUtils.isEmpty(list)){
                 ztTask.setProject(list.get(0).getProject());
+            }else{
+                List<ZtExecutionproject> execList = this.executionprojectService.list(new QueryWrapper<ZtExecutionproject>().lambda().eq(ZtExecutionproject::getExecution, ztTask.getExecution()));
+                ztTask.setProject(execList.get(0).getExecution());
             }
         }
-        ztTask.setStatus("wait");
+        //如果是开发人员   需要评审
+        UserType userType = RiskUserThreadLocal.get().getUserType();
+        if(userType==UserType.KFZ){
+            ZtProject ztProject = this.ztProjectService.getById(ztTask.getExecution());
+            ztTask.setStatus("reviewing");
+            ztTask.setReviewingUser(ztProject.getPm());
+        }else{
+            ztTask.setStatus("wait");
+            ztTask.setReviewingUser(null);
+        }
+
+
+        if(ztTask.getDeadline()!=null){
+            ztTask.setDeadlineTime(ztTask.getDeadline().getTime()/1000);
+        }
         this.baseMapper.insert(ztTask);
+
+        fileService.updateFile(dto.getFiles(),ztTask.getId(), FileTypes.task);
         if(ztTask.getExecution()!=null&&ztTask.getExecution()!=0){
             kanbanlaneService.addTask( dto.getExecution(), Arrays.asList(ztTask));
         }
 
         ZtProjectproduct projectproduct = projectproductService.getOne(new QueryWrapper<ZtProjectproduct>().lambda().eq(ZtProjectproduct::getProject, ztTask.getProject()));
 
+
+
         actionService.addAction(ActionType.RW, ActionStatus.XJ,ztTask.getId()
                 ,projectproduct==null?null:projectproduct.getProduct().toString(),projectproduct==null?null:projectproduct.getProject(),ztTask.getExecution(),
                 RiskUserThreadLocal.get().getName(),dto.getDesc(),null);
@@ -136,19 +357,43 @@ public class ZtTaskServiceImpl extends ServiceImpl<ZtTaskMapper, ZtTask> impleme
         if(ztTask==null){
             throw new BusinessException("未查询到数据");
         }
-        BeanUtils.copyProperties(dto,ztTask);
+        String desc = ztTask.getDesc();
+
+        BeanUtils.copyProperties(dto,ztTask,"left","consumed");
+        ztTask.setEstimate(dto.getLeft());
+        //剩余
+        ztTask.setLeft(BigDecimal.valueOf(dto.getLeft()).subtract(BigDecimal.valueOf(ztTask.getConsumed())).setScale(2,BigDecimal.ROUND_HALF_UP).floatValue());
+        ztTask.setLastediteddate(new Date());
+        ztTask.setLasteditedby(RiskUserThreadLocal.get().getName());
+        if(ztTask.getDeadline()!=null){
+            ztTask.setDeadlineTime(ztTask.getDeadline().getTime()/1000);
+        }
         this.baseMapper.updateById(ztTask);
 
+        fileService.updateFile(dto.getFiles(),ztTask.getId(), FileTypes.task);
+
         Integer storyId = ztTask.getStory();
-        ZtStory story = this.storyService.getById(storyId);
+        if(storyId!=null&&storyId!=0){
-
+            ZtStory story = this.storyService.getById(storyId);
-
+            actionService.addAction(ActionType.RW, ActionStatus.BJ,ztTask.getId(),story.getProduct()==null?"":story.getProduct().toString(),ztTask.getProject(),ztTask.getExecution(),
-        actionService.addAction(ActionType.RW, ActionStatus.BJ,ztTask.getId(),story.getProduct()==null?"":story.getProduct().toString(),ztTask.getProject(),ztTask.getExecution(),
+                    RiskUserThreadLocal.get().getName(),(!StringUtils.isEmpty(desc)&&!desc.equals(dto.getDesc()))?dto.getDesc():null,null);
-                RiskUserThreadLocal.get().getName(),dto.getDesc(),null);
+            if(!StringUtils.isEmpty(dto.getRemark())){
-        if(!StringUtils.isEmpty(dto.getRemark())){
+                actionService.addAction(ActionType.RW, ActionStatus.TJBZ,ztTask.getId(),story.getProduct()==null?"":story.getProduct().toString(),ztTask.getProject(),ztTask.getExecution(),
-            actionService.addAction(ActionType.RW, ActionStatus.TJBZ,ztTask.getId(),story.getProduct()==null?"":story.getProduct().toString(),ztTask.getProject(),ztTask.getExecution(),
+                        RiskUserThreadLocal.get().getName(),dto.getRemark(),null);
-                    RiskUserThreadLocal.get().getName(),dto.getRemark(),null);
+            }
+        }else{
+            actionService.addAction(ActionType.RW, ActionStatus.BJ,ztTask.getId(),"",ztTask.getProject(),ztTask.getExecution(),
+                    RiskUserThreadLocal.get().getName(),(!StringUtils.isEmpty(desc)&&!desc.equals(dto.getDesc()))?dto.getDesc():null,null);
+            if(!StringUtils.isEmpty(dto.getRemark())){
+                actionService.addAction(ActionType.RW, ActionStatus.TJBZ,ztTask.getId(),"",ztTask.getProject(),ztTask.getExecution(),
+                        RiskUserThreadLocal.get().getName(),dto.getRemark(),null);
+            }
         }
+
+
+
+
+
     }
 
     @Override
@@ -163,19 +408,28 @@ public class ZtTaskServiceImpl extends ServiceImpl<ZtTaskMapper, ZtTask> impleme
             throw new BusinessException("未查询到数据");
         }
         ztTask.setAssignedTo(dto.getAssignedTo());
-        ztTask.setEstStarted(dto.getEstStarted());
+        ztTask.setRealstarted(dto.getEstStarted());
-        ztTask.setStatus("doing");
+        if(dto.getFinishedFlag()==0){
+            ztTask.setStatus("doing");
+        }else{
+            ztTask.setStatus("done");
+            ztTask.setFinishedby(RiskUserThreadLocal.get().getName());
+            ztTask.setFinishedDate(new Date());
+        }
+
         ztTask.setLasteditedby(RiskUserThreadLocal.get().getName());
         ztTask.setLastediteddate(new Date());
         ztTask.setConsumed(dto.getConsumed());
         ztTask.setLeft(dto.getLeft()-dto.getConsumed());
         this.baseMapper.updateById(ztTask);
+        if(dto.getConsumed()>0){
+            ZtEffortDTO e=new ZtEffortDTO();
+            BeanUtils.copyProperties(ztTask,e);
+            e.setWork(dto.getRemark());
+            e.setObjectid(ztTask.getId());
+            this.effortService.add(e);
+        }
 
-        ZtEffortDTO e=new ZtEffortDTO();
-        BeanUtils.copyProperties(ztTask,e);
-        e.setWork(dto.getDesc());
-        e.setObjectid(ztTask.getId());
-        this.effortService.add(e);
         //添加action
         ZtProjectproduct projectproduct = projectproductService.getOne(new QueryWrapper<ZtProjectproduct>().lambda()
                 .eq(ZtProjectproduct::getProject, ztTask.getProject()));
@@ -190,11 +444,17 @@ public class ZtTaskServiceImpl extends ServiceImpl<ZtTaskMapper, ZtTask> impleme
                 qo.setTabType("task");
                 qo.setId(dto.getId());
                 //查
-                ZtKanbancell ztKanbanlane = this.kanbanlaneService.getZtKanbanlane("task", "wait", dto.getExecution());
+                ZtKanbancell ztKanbanlane = this.kanbanlaneService.getZtKanbanlane("task", "wait", ztTask.getExecution());
 
                 qo.setFromId(ztKanbanlane.getColumn());
                 //查
-                ztKanbanlane = this.kanbanlaneService.getZtKanbanlane("task", "developing", dto.getExecution());
+                if(dto.getFinishedFlag()==0){
+                    ztKanbanlane = this.kanbanlaneService.getZtKanbanlane("task", "developing", ztTask.getExecution());
+
+                }else{
+                    ztKanbanlane = this.kanbanlaneService.getZtKanbanlane("task", "developed", ztTask.getExecution());
+
+                }
                 qo.setToId(ztKanbanlane.getColumn());
                 kanbanlaneService.changeStatus(qo);
             }else{
@@ -207,9 +467,14 @@ public class ZtTaskServiceImpl extends ServiceImpl<ZtTaskMapper, ZtTask> impleme
                 kanbanlaneService.changeStatus(qo);
             }
         }
-
+        if("devel".equals(ztTask.getType())){
-        //处理需求
+            //处理需求
-        this.storyService.startStory(ztTask.getStory(),ztTask.getExecution());
+            this.storyService.startStory(ztTask.getStory(),ztTask.getExecution());
+        }
+        if("test".equals(ztTask.getType())){
+            //处理需求
+            this.storyService.testingStory(ztTask.getStory());
+        }
 
 
         Integer execution = ztTask.getExecution();
@@ -218,7 +483,19 @@ public class ZtTaskServiceImpl extends ServiceImpl<ZtTaskMapper, ZtTask> impleme
             project.setStatus("doing");
             this.ztProjectService.updateById(project);
         }
+        if(dto.getFinishedFlag()==1){
+            String type = ztTask.getType();
+            if(ztTask.getStory()!=null&&ztTask.getStory()!=0){
+                if("test".equals(type)){
+                    this.storyService.testedStory(ztTask.getStory());
+                }else
+                if("devel".equals(type)){
+                    //开发
+                    this.storyService.finishStory(ztTask.getStory(),ztTask.getExecution());
+                }
 
+            }
+        }
 
     }
 
@@ -275,7 +552,33 @@ public class ZtTaskServiceImpl extends ServiceImpl<ZtTaskMapper, ZtTask> impleme
             }
         }
 
-        this.storyService.finishStory(ztTask.getStory(),ztTask.getExecution());
+
+        // devel 开发  request 需求  test
+        //如果有一个开发任务进行中，并且所有的测试任务还没有开始，需求的研发阶段为“研发中”
+        //如果所有的开发任务已经完成，并且所有的测试任务还没有开始，则为“研发完毕"
+        //如果有一个测试任务进行中，则视为“测试中”
+        //如果所有的测试任务已经结束，但还有一些开发任务没有结束，则视为"测试中"
+        //如果所有的测试任务已经结束，并且所有的开发任务已经结束，则视为"测试完毕"
+//        pause 暂停  cancel取消  closed 关闭 done 完成 wait  reviewing待评审 doing
+//        devel 开发  request 需求  test
+        String type = ztTask.getType();
+        if(ztTask.getStory()!=null&&ztTask.getStory()!=0){
+            if("test".equals(type)){
+                this.storyService.testedStory(ztTask.getStory());
+            }else
+            if("devel".equals(type)){
+                //开发
+                this.storyService.finishStory(ztTask.getStory(),ztTask.getExecution());
+            }
+
+        }
+
+
+
+//        if(ztTask.getStory()!=null&&ztTask.getStory()!=0){
+//            this.storyService.finishStory(ztTask.getStory(),ztTask.getExecution());
+//        }
+
     }
 
     @Override
@@ -326,6 +629,7 @@ public class ZtTaskServiceImpl extends ServiceImpl<ZtTaskMapper, ZtTask> impleme
     }
 
     @Override
+    @Transactional
     public void cancelTask(ZtTaskDTO dto) {
         ZtTask ztTask = this.baseMapper.selectById(dto.getId());
         String status = ztTask.getStatus();
@@ -377,46 +681,84 @@ public class ZtTaskServiceImpl extends ServiceImpl<ZtTaskMapper, ZtTask> impleme
     @Override
     @Transactional
     public void batchAddTask(ZtTaskDTO dto) {
-        if(CollectionUtils.isEmpty(dto.getList())){
+        throw new BusinessException("已弃用");
-            throw new BusinessException("请检查数据");
+//        if(CollectionUtils.isEmpty(dto.getList())){
+//            throw new BusinessException("请检查数据");
+//        }
+//        long count = dto.getList().stream().filter(o -> StringUtils.isEmpty(o.getName())).count();
+//        if(count>0){
+//            throw new BusinessException("请检查数据");
+//        }
+//
+//        Integer storyId = dto.getList().get(0).getStory();
+//        ZtProjectstory projectstory = projectstoryService.getOne(new QueryWrapper<ZtProjectstory>().lambda().eq(ZtProjectstory::getStory, storyId)
+//                .ne(ZtProjectstory::getProject, 0)
+//        );
+//
+//
+//        List<ZtTaskDTO> list = dto.getList();
+//        List<ZtTask> saveList =new ArrayList();
+//        for (ZtTaskDTO d:list) {
+//            ZtTask ztTask = new ZtTask();
+//
+//            BeanUtils.copyProperties(d,ztTask);
+//            ztTask.setProject(projectstory.getProject());
+//            ztTask.setOpenedby(RiskUserThreadLocal.get().getName());
+//            ztTask.setOpeneddate(new Date());
+//            ztTask.setStatus("reviewing");
+//            if(ztTask.getDeadline()!=null){
+//                ztTask.setDeadlineTime(ztTask.getDeadline().getTime()/1000);
+//            }
+//            saveList.add(ztTask);
+//        }
+//        this.saveBatch(saveList);
+//
+//        kanbanlaneService.addTask( list.get(0).getExecution(),saveList);
+//        ZtStory story = storyService.getById(list.get(0).getStory());
+//        for (ZtTask t:saveList) {
+//
+//            ZtProjectproduct projectproduct = projectproductService.getOne(new QueryWrapper<ZtProjectproduct>().lambda().eq(ZtProjectproduct::getProject, story.getProject()));
+//
+//            actionService.addAction(ActionType.RW, ActionStatus.XJ,t.getId(),projectproduct==null?null:projectproduct.getProduct().toString(),projectproduct==null?null:projectproduct.getProject(),t.getExecution(),
+//                    RiskUserThreadLocal.get().getName(),dto.getDesc(),null);
+//        }
+
+    }
+
+    @Override
+    @Transactional
+    public void approval(ZtTaskDTO dto) {
+        ZtTask t = this.baseMapper.selectById(dto.getId());
+        if(!t.getStatus().equals("reviewing")){
+            throw new BusinessException("未查询到数据");
         }
-        long count = dto.getList().stream().filter(o -> StringUtils.isEmpty(o.getName())).count();
+        if(dto.getApprovalStatus()==1){
-        if(count>0){
+            t.setStatus("wait");
-            throw new BusinessException("请检查数据");
+        }else{
+            t.setStatus("closed");
         }
 
-        Integer storyId = dto.getList().get(0).getStory();
+        t.setApprovalRemark(dto.getApprovalRemark());
-        ZtProjectstory projectstory = projectstoryService.getOne(new QueryWrapper<ZtProjectstory>().lambda().eq(ZtProjectstory::getStory, storyId)
+        t.setLastediteddate(new Date());
-                .ne(ZtProjectstory::getProject, 0)
+        t.setLasteditedby(RiskUserThreadLocal.get().getName());
-        );
+        this.baseMapper.updateById(t);
 
 
-        List<ZtTaskDTO> list = dto.getList();
+        ZtProjectproduct projectproduct = projectproductService.getOne(new QueryWrapper<ZtProjectproduct>().lambda().eq(ZtProjectproduct::getProject, t.getProject()));
-        List<ZtTask> saveList =new ArrayList();
-        for (ZtTaskDTO d:list) {
-            ZtTask ztTask = new ZtTask();
 
-            BeanUtils.copyProperties(d,ztTask);
-            ztTask.setProject(projectstory.getProject());
-            ztTask.setOpenedby(RiskUserThreadLocal.get().getName());
-            ztTask.setOpeneddate(new Date());
-            ztTask.setStatus("wait");
-            saveList.add(ztTask);
-        }
-        this.saveBatch(saveList);
 
-        kanbanlaneService.addTask( list.get(0).getExecution(),saveList);
+        if(dto.getApprovalStatus()==1){
-        ZtStory story = storyService.getById(list.get(0).getStory());
+                    actionService.addAction(ActionType.RW, ActionStatus.PSTG,t.getId(),projectproduct==null?null:projectproduct.getProduct().toString(),projectproduct==null?null:projectproduct.getProject(),t.getExecution(),
-        for (ZtTask t:saveList) {
+                            RiskUserThreadLocal.get().getName(),dto.getApprovalRemark(),null);
-
+        }else if(dto.getApprovalStatus()==2){
-            ZtProjectproduct projectproduct = projectproductService.getOne(new QueryWrapper<ZtProjectproduct>().lambda().eq(ZtProjectproduct::getProject, story.getProject()));
+                    actionService.addAction(ActionType.RW, ActionStatus.PSBTG,t.getId(),projectproduct==null?null:projectproduct.getProduct().toString(),projectproduct==null?null:projectproduct.getProject(),t.getExecution(),
-
+                            RiskUserThreadLocal.get().getName(),dto.getApprovalRemark(),null);
-            actionService.addAction(ActionType.RW, ActionStatus.XJ,t.getId(),projectproduct==null?null:projectproduct.getProduct().toString(),projectproduct==null?null:projectproduct.getProject(),t.getExecution(),
-                    RiskUserThreadLocal.get().getName(),dto.getDesc(),null);
         }
 
     }
 
+
+
     @Override
     public List<ZtTaskDTO> taskListByExecution(ZtTaskDTO dto) {
         LambdaQueryWrapper<ZtTask> eq = new QueryWrapper<ZtTask>().lambda();

src/main/java/com/sa/zentao/service/impl/ZtUserServiceImpl.java

@@ -1,5 +1,6 @@
 package com.sa.zentao.service.impl;
 
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.github.pagehelper.Page;
 import com.github.pagehelper.PageHelper;
@@ -98,7 +99,7 @@ public class ZtUserServiceImpl extends ServiceImpl<ZtUserMapper, ZtUser> impleme
 
         //项目  或者产品id
         Integer id = dto.getId();
-        if(id==null){
+        if(id==null||id==0){
             return new ArrayList<>();
         }
         //product project
@@ -109,7 +110,11 @@ public class ZtUserServiceImpl extends ServiceImpl<ZtUserMapper, ZtUser> impleme
                 return new ArrayList<>();
             }else{
                 String[] split = reviewer.split(",");
-                List<ZtUser> ztUsers = this.list(new QueryWrapper<ZtUser>().lambda().in(ZtUser::getAccount,Arrays.asList(split)));
+                LambdaQueryWrapper<ZtUser> in = new QueryWrapper<ZtUser>().lambda().in(ZtUser::getAccount, Arrays.asList(split));
+                if(!StringUtils.isEmpty(dto.getName())){
+                    in.like(ZtUser::getAccount, dto.getName());
+                }
+                List<ZtUser> ztUsers = this.list(in);
                 return ztUsers;
             }
     }
@@ -195,6 +200,11 @@ public class ZtUserServiceImpl extends ServiceImpl<ZtUserMapper, ZtUser> impleme
         return login;
     }
 
+    @Override
+    public ZtUser selectPrdByName(String userName) {
+        return this.baseMapper.selectPrdByName(userName);
+    }
+
     public boolean sendSms(String phoneNumber, String verificationCode) {
         try {
             // 初始化腾讯云短信服务客户端

src/main/java/com/sa/zentao/service/impl/ZtYwTaskServiceImpl.java

@@ -13,10 +13,12 @@ import com.sa.zentao.entity.ZtCronDevopsUser;
 import com.sa.zentao.entity.ZtUser;
 import com.sa.zentao.entity.ZtYwTask;
 import com.sa.zentao.mapper.ZtYwTaskMapper;
+import com.sa.zentao.qo.ZtProjectQo;
 import com.sa.zentao.qo.ZtYwPatrolQo;
 import com.sa.zentao.service.IZtUserService;
 import com.sa.zentao.service.IZtYwTaskService;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.sa.zentao.utils.BeanCopyUtil;
 import com.sa.zentao.utils.DateUtils;
 import com.sa.zentao.utils.SendEmail;
 import org.apache.commons.lang3.StringUtils;
@@ -25,10 +27,7 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.util.CollectionUtils;
 
-import java.util.Arrays;
+import java.util.*;
-import java.util.Date;
-import java.util.List;
-import java.util.Map;
 
 /**
  * <p>
@@ -109,6 +108,7 @@ public class ZtYwTaskServiceImpl extends ServiceImpl<ZtYwTaskMapper, ZtYwTask> i
         }
         ztYwTask.setTaskStatus(4);
         ztYwTask.setDeliver(dto.getDeliver());
+        ztYwTask.setFinishDate(new Date());
         this.baseMapper.updateById(ztYwTask);
     }
 
@@ -160,4 +160,16 @@ public class ZtYwTaskServiceImpl extends ServiceImpl<ZtYwTaskMapper, ZtYwTask> i
 
         }
     }
+
+    @Override
+    public List<ZtYwTaskDTO> ywTaskService(ZtProjectQo qo) {
+        List<ZtYwTask> ztYwTasks = this.baseMapper.selectList(new QueryWrapper<ZtYwTask>().lambda()
+                .ne(ZtYwTask::getTaskStatus, 4)
+                .eq(ZtYwTask::getCreateUser, RiskUserThreadLocal.get().getName())
+        );
+        if(CollectionUtils.isEmpty(ztYwTasks)){
+            return new ArrayList<>();
+        }
+        return BeanCopyUtil.copyListProperties(ztYwTasks,ZtYwTaskDTO::new);
+    }
 }

src/main/java/com/sa/zentao/utils/ChineseUtil.java

@@ -0,0 +1,124 @@
+package com.sa.zentao.utils;
+
+import java.text.Collator;
+import java.util.Locale;
+
+public class ChineseUtil {
+    // 简体中文的编码范围从B0A1（45217）一直到F7FE（63486）
+    private static int BEGIN = 45217;
+    private static int END = 63486;
+
+    // 按照声 母表示，这个表是在GB2312中的出现的第一个汉字，
+    //也就是说“啊”是代表首字母a的第一个汉字。
+    // i, u, v都不做声母, 自定规则跟随前面的字母
+    private static char[] charTable = { '啊', '芭', '擦', '搭', '蛾', '发', '噶', '哈',
+            '哈', '击', '喀', '垃', '妈', '拿', '哦', '啪', '期', '然', '撒', '塌', '塌',
+            '塌', '挖', '昔', '压', '匝', };
+
+    // 二十六个字母区间对应二十七个端点
+    // GB2312码汉字区间十进制表示
+    private static int[] table = new int[27];
+
+    // 对应首字母区间表
+    private static char[] initialTable = { 'A', 'B', 'C', 'D', 'E', 'F', 'G',
+            'H', 'H', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
+            'T', 'T', 'W', 'X', 'Y', 'Z', };
+
+    // 初始化
+    static {
+        for (int i = 0; i < 26; i++) {
+            // 得到GB2312码的首字母区间端点表，十进制。
+            table[i] = gbValue(charTable[i]);
+        }
+        table[26] = END;// 区间表结尾
+    }
+
+    // ------------------------public方法区------------------------
+    // 根据一个包含汉字的字符串返回一个汉字拼音首字母的字符串。
+    public static String first(String S) {
+        String Result = "";
+        if (S == null || S.equals("")) {
+            return "#";
+        }
+        char cs = S.charAt(0);
+        try {
+
+            Result += Char2Initial(cs);
+
+        } catch (Exception e) {
+            Result = "%";
+            e.printStackTrace();
+        }
+        return Result;
+    }
+
+    // ------------------------private方法区------------------------
+    /**
+     * 输入字符,得到他的声母,英文字母返回对应的大写字母,其他非简体汉字返回 '#'　
+     */
+    private static char Char2Initial(char ch) {
+        // 对英文字母的处理：小写字母转换为大写，大写的直接返回
+        if (ch >= 'a' && ch <= 'z') {
+            return (char) (ch - 'a' + 'A');
+        }
+        if (ch >= 'A' && ch <= 'Z') {
+            return ch;
+        }
+        // 对非英文字母的处理：转化为首字母，然后判断是否在码表范围内，
+        // 若不是，则直接返回。
+        // 若是，则在码表内的进行判断。
+        int gb = gbValue(ch);// 汉字转换首字母
+        if ((gb < BEGIN) || (gb > END))// 在码表区间之前，直接返回
+        {
+            return '#';
+        }
+        int i;
+        for (i = 0; i < 26; i++) {
+            // 判断匹配码表区间，匹配到就break,判断区间形如“[,)”
+            if ((gb >= table[i]) && (gb < table[i + 1])) {
+                break;
+            }
+        }
+        if (gb == END) {// 补上GB2312区间最右端
+            i = 25;
+        }
+        return initialTable[i]; // 在码表区间中，返回首字母
+    }
+
+    /**
+     * 取出汉字的编码 cn 汉字 　　
+     */
+    private static int gbValue(char ch) {// 将一个汉字（GB2312）转换为十进制表示。
+        String str = new String();
+        str += ch;
+        try {
+            byte[] bytes = str.getBytes("GB2312");
+            if (bytes.length < 2) {
+                return 0;
+            }
+            return (bytes[0] << 8 & 0xff00) + (bytes[1] & 0xff);
+        } catch (Exception e) {
+            return 0;
+        }
+    }
+
+   public static String  getFirst(String str){
+        try {
+            char[] chars = str.toCharArray();
+            StringBuilder build=new StringBuilder();
+            for (char c:chars ) {
+                try {
+                    String first = first(String.valueOf(c));
+                    build.append(first.toLowerCase());
+                }catch (Exception e){}
+
+            }
+            return  build.toString();
+        }catch (Exception e){
+            return null;
+        }
+
+    }
+
+
+}

src/main/java/com/sa/zentao/utils/DateUtils.java

@@ -1,5 +1,6 @@
 package com.sa.zentao.utils;
 
+import com.sa.zentao.dao.BusinessException;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 
@@ -35,6 +36,20 @@ public class DateUtils {
 
     }
 
+    public static Date  getDayLast(Date date   ){
+        if(date==null){
+            throw new BusinessException("日期为空");
+        }
+        Calendar instance = Calendar.getInstance();
+        instance.setTime(date);
+
+        instance.set(Calendar.HOUR_OF_DAY,23);
+        instance.set(Calendar.MINUTE,59);
+        instance.set(Calendar.SECOND,59);
+        return instance.getTime();
+
+    }
+
     public static int getWorkDaysInCurrentMonth(Date date) {
 
         Date startDate = DateUtils.getMonthStartDate(date);

src/main/java/com/sa/zentao/utils/KanBanConstant.java

@@ -83,6 +83,7 @@ public class KanBanConstant {
 
 
     public static   Map<String,String> TaskMap=new HashMap<>(){{
+        put("reviewing","wait");
         put("wait","wait");
         put("doing","developing");
         put("done","developed");

src/main/resources/application-dev.yml

@@ -7,10 +7,27 @@
 
 spring:
   datasource:
-    url: jdbc:mysql://127.0.0.1:3306/zentao_dev?useUnicode=true&characterEncoding=UTF8&useSSL=false&serverTimezone=Asia/Shanghai&allowMultiQueries=true&allowPublicKeyRetrieval=true
+    dynamic:
-    username: oa_user
+      primary: master #设置默认的数据源或者数据源组,默认值即为master
-    password: PX4fTAAsJ#T!
+      strict: false #严格匹配数据源,默认false. true未匹配到指定数据源时抛异常,false使用默认数据源
-    driver-class-name: com.mysql.cj.jdbc.Driver
+      datasource:
+        master:
+          url: jdbc:mysql://127.0.0.1:3306/zentao_dev?useUnicode=true&characterEncoding=UTF8&useSSL=false&serverTimezone=Asia/Shanghai&allowMultiQueries=true&allowPublicKeyRetrieval=true
+          username: oa_user
+          password: PX4fTAAsJ#T!
+          driver-class-name: com.mysql.cj.jdbc.Driver # 3.2.0开始支持SPI可省略此配置
+        slave:
+          url: jdbc:mysql://192.168.3.111:3516/zentao?zeroDateTimeBehavior=convertToNull&useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC&autoReconnect=true
+          username: root
+          password: 123456
+          driver-class-name: com.mysql.cj.jdbc.Driver
+
+#spring:
+#  datasource:
+#    url: jdbc:mysql://192.168.3.200:3306/zentao_dev?useUnicode=true&characterEncoding=UTF8&useSSL=false&serverTimezone=Asia/Shanghai&allowMultiQueries=true&allowPublicKeyRetrieval=true
+#    username: oa_user
+#    password: PX4fTAAsJ#T!
+#    driver-class-name: com.mysql.cj.jdbc.Driver
 
 
 file:

src/main/resources/application-local.yml

@@ -1,10 +1,54 @@
+#spring:
+#  datasource:
+#    dynamic:
+#      primary: master #设置默认的数据源或者数据源组,默认值即为master
+#      strict: true #严格匹配数据源,默认false. true未匹配到指定数据源时抛异常,false使用默认数据源
+#      datasource:
+#        master:
+#          url: jdbc:mysql://192.168.1.161:3306/zentao?useUnicode=true&characterEncoding=UTF8&useSSL=false&serverTimezone=Asia/Shanghai&allowMultiQueries=true&allowPublicKeyRetrieval=true
+#          username: devgps
+#          password: dev@2021GPS
+#          driver-class-name: com.mysql.cj.jdbc.Driver # 3.2.0开始支持SPI可省略此配置
+#        slave:
+#          url: jdbc:mysql:///192.168.3.111:3516?zentao?useUnicode=true&characterEncoding=UTF8&useSSL=false&serverTimezone=Asia/Shanghai&allowMultiQueries=true&allowPublicKeyRetrieval=true
+#          username: root
+#          password: 123456
+#          driver-class-name: com.mysql.cj.jdbc.Driver
+
 spring:
   datasource:
-    url: jdbc:mysql://192.168.1.161:3306/zentao?useUnicode=true&characterEncoding=UTF8&useSSL=false&serverTimezone=Asia/Shanghai&allowMultiQueries=true&allowPublicKeyRetrieval=true
+    dynamic:
-    username: devgps
+      primary: master #设置默认的数据源或者数据源组,默认值即为master
-    password: dev@2021GPS
+      strict: false #严格匹配数据源,默认false. true未匹配到指定数据源时抛异常,false使用默认数据源
-    driver-class-name: com.mysql.cj.jdbc.Driver
+      datasource:
+        master:
+          url: jdbc:mysql://192.168.1.161:3306/zentao?useUnicode=true&characterEncoding=UTF8&useSSL=false&serverTimezone=Asia/Shanghai&allowMultiQueries=true&allowPublicKeyRetrieval=true
+          username: devgps
+          password: dev@2021GPS
+#          url: jdbc:mysql://192.168.3.200:3306/zentao_dev?useUnicode=true&characterEncoding=UTF8&useSSL=false&serverTimezone=Asia/Shanghai&allowMultiQueries=true&allowPublicKeyRetrieval=true
+#          username: root
+#          password: PX4fTAAsJ#T!1
+
+          driver-class-name: com.mysql.cj.jdbc.Driver # 3.2.0开始支持SPI可省略此配置
+        slave:
+          url: jdbc:mysql://192.168.3.111:3516/zentao?zeroDateTimeBehavior=convertToNull&useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC&autoReconnect=true
+          username: root
+          password: 123456
+          driver-class-name: com.mysql.cj.jdbc.Driver
+
 
 
 file:
-  baseUrl: http://127.0.0.1:8085
+  baseUrl: http://127.0.0.1:8085
+
+
+#spring:
+#  datasource:
+#    url: jdbc:mysql://192.168.3.111:3516/zentao?useUnicode=true&characterEncoding=UTF8&useSSL=false&serverTimezone=Asia/Shanghai&allowMultiQueries=true&allowPublicKeyRetrieval=true
+#    username: root
+#    password: 123456
+#    driver-class-name: com.mysql.cj.jdbc.Driver
+#
+#
+#file:
+#  baseUrl: http://127.0.0.1:8085

src/main/resources/application.yml

@@ -8,7 +8,7 @@ spring:
   profiles:
     active: local
   application:
-    name: oasystem
+    name: zentao
   main:
     allow-bean-definition-overriding: true
     allow-circular-references: true   #循环依赖