From f5114972497953a70772f202a8ae2a0bf96659b0 Mon Sep 17 00:00:00 2001 From: zss <zss@example.com> Date: 星期五, 14 二月 2025 17:17:30 +0800 Subject: [PATCH] 搬迁绩效模块(班次+工时) --- basic-server/src/main/resources/mapper/StandardProductListMapper.xml | 2 performance-server/src/main/java/com/ruoyi/performance/service/AuxiliaryWorkingHoursService.java | 26 basic-server/src/main/java/com/ruoyi/basic/service/impl/SealServiceImpl.java | 39 performance-server/src/main/java/com/ruoyi/performance/controller/AuxiliaryWorkingHoursController.java | 59 performance-server/src/main/java/com/ruoyi/performance/service/impl/AuxiliaryOriginalHoursServiceImpl.java | 635 +++++++ performance-server/src/main/resources/mapper/AuxiliaryOriginalHoursMapper.xml | 59 performance-server/src/main/java/com/ruoyi/performance/utils/CustomerDoubleSerialize.java | 26 performance-server/src/main/java/com/ruoyi/performance/service/impl/ShiftTimeServiceImpl.java | 41 performance-server/src/main/java/com/ruoyi/performance/pojo/AuxiliaryWorkingHours.java | 60 performance-server/src/main/java/com/ruoyi/performance/excel/AuxiliaryCorrectionHoursListener.java | 41 performance-server/src/main/java/com/ruoyi/performance/mapper/PerformanceShiftMapper.java | 41 performance-server/src/main/java/com/ruoyi/performance/service/AuxiliaryWorkingHoursDayService.java | 44 performance-server/src/main/java/com/ruoyi/performance/controller/AuxiliaryWorkingHoursDayController.java | 101 + performance-server/src/main/java/com/ruoyi/performance/service/impl/AuxiliaryCorrectionHoursServiceImpl.java | 104 + performance-server/src/main/resources/mapper/PerformanceShiftMapper.xml | 135 + ruoyi-common/src/main/java/com/ruoyi/common/utils/JackSonUtil.java | 133 + performance-server/src/main/java/com/ruoyi/performance/controller/PerformanceShiftController.java | 152 + basic-server/src/main/java/com/ruoyi/basic/pojo/Seal.java | 43 inspect-server/pom.xml | 15 performance-server/src/main/java/com/ruoyi/performance/dto/AuxiliaryOutputWorkingHoursDto.java | 19 performance-server/src/main/java/com/ruoyi/performance/service/AuxiliaryOriginalHoursService.java | 30 performance-server/src/main/java/com/ruoyi/performance/controller/ShiftTimeController.java | 55 performance-server/src/main/java/com/ruoyi/performance/dto/AuxiliaryOriginalHoursLookDto.java | 26 performance-server/src/main/java/com/ruoyi/performance/controller/AuxiliaryOutputWorkingHoursController.java | 74 performance-server/src/main/java/com/ruoyi/performance/pojo/PerformanceShift.java | 54 performance-server/src/main/java/com/ruoyi/performance/service/impl/AuxiliaryWorkingHoursDayServiceImpl.java | 232 ++ performance-server/src/main/java/com/ruoyi/performance/pojo/AuxiliaryOutputWorkingHours.java | 123 + performance-server/src/main/java/com/ruoyi/performance/utils/StyleMonthUtils.java | 86 performance-server/src/main/java/com/ruoyi/performance/service/PerformanceShiftService.java | 32 performance-server/src/main/java/com/ruoyi/performance/mapper/AuxiliaryOutputWorkingHoursMapper.java | 55 performance-server/src/main/java/com/ruoyi/performance/service/AuxiliaryOutputWorkingHoursService.java | 44 performance-server/src/main/resources/mapper/AuxiliaryWorkingHoursMapper.xml | 38 performance-server/src/main/java/com/ruoyi/performance/service/ShiftTimeService.java | 22 performance-server/src/main/resources/mapper/AuxiliaryCorrectionHoursMapper.xml | 75 performance-server/src/main/java/com/ruoyi/performance/mapper/AuxiliaryWorkingHoursMapper.java | 19 performance-server/src/main/java/com/ruoyi/performance/mapper/ShiftTimeMapper.java | 16 performance-server/src/main/java/com/ruoyi/performance/pojo/AuxiliaryCorrectionHours.java | 181 ++ performance-server/src/main/java/com/ruoyi/performance/pojo/ShiftTime.java | 54 basic-server/src/main/java/com/ruoyi/basic/mapper/SealMapper.java | 17 performance-server/src/main/java/com/ruoyi/performance/dto/PerformanceShiftAddDto.java | 27 performance-server/src/main/java/com/ruoyi/performance/service/impl/AuxiliaryOutputWorkingHoursServiceImpl.java | 260 ++ pom.xml | 8 performance-server/src/main/java/com/ruoyi/performance/mapper/AuxiliaryCorrectionHoursMapper.java | 27 performance-server/src/main/java/com/ruoyi/performance/dto/AuxiliaryOriginalHoursDto.java | 251 ++ performance-server/src/main/java/com/ruoyi/performance/dto/HoursDay.java | 15 performance-server/src/main/java/com/ruoyi/performance/dto/AuxiliaryAllDto.java | 35 basic-server/src/main/java/com/ruoyi/basic/service/SealService.java | 24 performance-server/src/main/java/com/ruoyi/performance/dto/AuxiliaryWorkingHoursDayDto.java | 16 performance-server/src/main/java/com/ruoyi/performance/mapper/AuxiliaryOriginalHoursMapper.java | 13 basic-server/src/main/resources/mapper/SealMapper.xml | 19 performance-server/src/main/java/com/ruoyi/performance/pojo/AuxiliaryWorkingHoursDay.java | 113 + performance-server/src/main/java/com/ruoyi/performance/utils/StyleYearUtils.java | 89 + ruoyi-admin/pom.xml | 7 performance-server/src/main/resources/mapper/ShiftTimeMapper.xml | 17 performance-server/src/main/java/com/ruoyi/performance/dto/AuxiliaryCorrectionHoursDto.java | 22 performance-server/pom.xml | 34 performance-server/src/main/java/com/ruoyi/performance/controller/AuxiliaryCorrectionHoursController.java | 59 performance-server/src/main/resources/mapper/AuxiliaryOutputWorkingHoursMapper.xml | 186 ++ ruoyi-common/pom.xml | 4 ruoyi-system/src/main/java/com/ruoyi/system/mapper/CustomMapper.java | 3 performance-server/src/main/java/com/ruoyi/performance/service/AuxiliaryCorrectionHoursService.java | 29 performance-server/src/main/java/com/ruoyi/performance/service/impl/PerformanceShiftServiceImpl.java | 563 ++++++ performance-server/src/main/java/com/ruoyi/performance/service/impl/AuxiliaryWorkingHoursServiceImpl.java | 55 performance-server/src/main/resources/mapper/AuxiliaryWorkingHoursDayMapper.xml | 116 + performance-server/src/main/java/com/ruoyi/performance/dto/PerformanceShiftMapDto.java | 27 performance-server/src/main/java/com/ruoyi/performance/mapper/AuxiliaryWorkingHoursDayMapper.java | 43 performance-server/src/main/java/com/ruoyi/performance/controller/AuxiliaryOriginalHoursController.java | 44 basic-server/src/main/java/com/ruoyi/basic/controller/SealController.java | 50 68 files changed, 5,162 insertions(+), 2 deletions(-) diff --git a/basic-server/src/main/java/com/ruoyi/basic/controller/SealController.java b/basic-server/src/main/java/com/ruoyi/basic/controller/SealController.java new file mode 100644 index 0000000..02ab6bb --- /dev/null +++ b/basic-server/src/main/java/com/ruoyi/basic/controller/SealController.java @@ -0,0 +1,50 @@ +package com.ruoyi.basic.controller; + +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.ruoyi.basic.pojo.Laboratory; +import com.ruoyi.basic.pojo.Seal; +import com.ruoyi.basic.service.SealService; +import com.ruoyi.common.core.domain.Result; +import com.ruoyi.common.utils.JackSonUtil; +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiOperation; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +import javax.annotation.Resource; +import java.util.List; +import java.util.Map; + +/** + * 鍗扮珷绠$悊(SealController)琛ㄦ帶鍒跺眰 + */ +@Api(tags = "鍗扮珷绠$悊") + +@RestController +@RequestMapping("/sealScope") +public class SealController { + + @Resource + private SealService sealService; + + @ApiOperation(value = "娣诲姞鍗扮珷鍙傛暟") + @PostMapping("/addSeal") + public Result addSeal(@RequestBody Seal seal) { + int i = sealService.addSeal(seal); + if(i>0){ + Integer labId = seal.getLabId(); + List<Laboratory> laboratory = sealService.Laboratory(labId); + return Result.success(laboratory); + }else{ + return Result.fail(); + } + + } + @ApiOperation(value="鏌ヨ鍗扮珷鍒楄〃") + @PostMapping("/selectSeal") + public Result selectSeal(Page page,Seal seal) { + return Result.success(sealService.selectSeal(page,seal)); + } +} diff --git a/basic-server/src/main/java/com/ruoyi/basic/mapper/SealMapper.java b/basic-server/src/main/java/com/ruoyi/basic/mapper/SealMapper.java new file mode 100644 index 0000000..9b96fc9 --- /dev/null +++ b/basic-server/src/main/java/com/ruoyi/basic/mapper/SealMapper.java @@ -0,0 +1,17 @@ +package com.ruoyi.basic.mapper; + +import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.baomidou.mybatisplus.core.metadata.IPage; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.ruoyi.basic.pojo.Laboratory; +import com.ruoyi.basic.pojo.Seal; +import org.apache.ibatis.annotations.Param; + +import java.util.List; + +public interface SealMapper extends BaseMapper<Seal> { + IPage<Seal>selectSeal(Page page, @Param("ew") QueryWrapper<Seal> ew); + List<Laboratory> selectLaboratory (Integer labId); + +} diff --git a/basic-server/src/main/java/com/ruoyi/basic/pojo/Seal.java b/basic-server/src/main/java/com/ruoyi/basic/pojo/Seal.java new file mode 100644 index 0000000..783703c --- /dev/null +++ b/basic-server/src/main/java/com/ruoyi/basic/pojo/Seal.java @@ -0,0 +1,43 @@ +package com.ruoyi.basic.pojo; + +import com.baomidou.mybatisplus.annotation.*; +import com.fasterxml.jackson.annotation.JsonFormat; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +import java.io.Serializable; +import java.time.LocalDateTime; + +/** + * 鍗扮珷绠$悊(Laboratory)琛ㄥ璞� + */ + +@TableName(value = "seal") +@Data +public class Seal implements Serializable { + @ApiModelProperty(value = "涓婚敭") + @TableId(type = IdType.AUTO) + private Integer id; + + @ApiModelProperty(value = "瀹為獙瀹d") + private Integer labId; + + @TableField(exist=false) + @ApiModelProperty(value = "瀹為獙瀹ゅ悕绉�") + private String laboratoryName; + + @ApiModelProperty(value = "鍗扮珷鍥剧墖") + private String address; + + @ApiModelProperty(value = "鍗扮珷绫诲瀷") + private String type; + + @ApiModelProperty(value = "鍒涘缓浜篿d") + @TableField(fill = FieldFill.INSERT) + private Integer createUser; + + @TableField(fill = FieldFill.INSERT) + @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") + private LocalDateTime createTime; +} + diff --git a/basic-server/src/main/java/com/ruoyi/basic/service/SealService.java b/basic-server/src/main/java/com/ruoyi/basic/service/SealService.java new file mode 100644 index 0000000..a31c595 --- /dev/null +++ b/basic-server/src/main/java/com/ruoyi/basic/service/SealService.java @@ -0,0 +1,24 @@ +package com.ruoyi.basic.service; + + +import com.baomidou.mybatisplus.core.metadata.IPage; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.baomidou.mybatisplus.extension.service.IService; +import com.ruoyi.basic.pojo.Laboratory; +import com.ruoyi.basic.pojo.Seal; + +import java.util.List; +import java.util.Map; + +public interface SealService extends IService<Seal> { + + //鏂板 + int addSeal(Seal seal); + + //鏌ヨ + IPage<Seal> selectSeal(Page page, Seal seal); + + List<Laboratory> Laboratory(Integer id); + + +} diff --git a/basic-server/src/main/java/com/ruoyi/basic/service/impl/SealServiceImpl.java b/basic-server/src/main/java/com/ruoyi/basic/service/impl/SealServiceImpl.java new file mode 100644 index 0000000..8e86931 --- /dev/null +++ b/basic-server/src/main/java/com/ruoyi/basic/service/impl/SealServiceImpl.java @@ -0,0 +1,39 @@ +package com.ruoyi.basic.service.impl; +import com.baomidou.mybatisplus.core.metadata.IPage; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; +import com.ruoyi.basic.mapper.SealMapper; +import com.ruoyi.basic.pojo.Laboratory; +import com.ruoyi.basic.pojo.Seal; +import com.ruoyi.basic.service.SealService; +import com.ruoyi.common.utils.QueryWrappers; +import lombok.AllArgsConstructor; +import org.springframework.stereotype.Service; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +@Service +@AllArgsConstructor +public class SealServiceImpl extends ServiceImpl<SealMapper, Seal> implements SealService { + private SealMapper sealMapper; + + + @Override + public int addSeal(Seal seal) { + return sealMapper.insert(seal); + } + + + + + @Override + public IPage<Seal> selectSeal(Page page, Seal seal) { + return sealMapper.selectSeal(page, QueryWrappers.queryWrappers(seal)); + } + @Override + public List<Laboratory> Laboratory(Integer labId) { + return sealMapper.selectLaboratory(labId); + } +} diff --git a/basic-server/src/main/resources/mapper/SealMapper.xml b/basic-server/src/main/resources/mapper/SealMapper.xml new file mode 100644 index 0000000..5cb3595 --- /dev/null +++ b/basic-server/src/main/resources/mapper/SealMapper.xml @@ -0,0 +1,19 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE mapper + PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" + "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> +<mapper namespace="com.ruoyi.basic.mapper.SealMapper"> + <select id="selectSeal" resultType="com.ruoyi.basic.pojo.Seal"> + select l.id,s.lab_id,l.laboratory_name ,s.address, s.type as Type,s.create_time + from seal s LEFT JOIN laboratory l on s.lab_id=l.id + <if test="ew.customSqlSegment != null and ew.customSqlSegment != ''"> + ${ew.customSqlSegment} + </if> + + </select> + <select id="selectLaboratory" resultType="com.ruoyi.basic.pojo.Laboratory"> + SELECT * + from laboratory + WHERE id = #{labId} + </select> +</mapper> diff --git a/basic-server/src/main/resources/mapper/StandardProductListMapper.xml b/basic-server/src/main/resources/mapper/StandardProductListMapper.xml index 8223bfc..52d6bfe 100644 --- a/basic-server/src/main/resources/mapper/StandardProductListMapper.xml +++ b/basic-server/src/main/resources/mapper/StandardProductListMapper.xml @@ -69,8 +69,8 @@ <if test="insItems != ''"> and inspection_item_subclass = #{insItems} </if> - group by spl.id order by p.id + group by spl.id </select> <select id="getOne" resultType="com.ruoyi.basic.pojo.StandardProductList"> select * from standard_product_list diff --git a/inspect-server/pom.xml b/inspect-server/pom.xml index 0b3b4bc..fc8d299 100644 --- a/inspect-server/pom.xml +++ b/inspect-server/pom.xml @@ -11,6 +11,21 @@ <artifactId>inspect-server</artifactId> + <dependencies> + <dependency> + <groupId>com.ruoyi</groupId> + <artifactId>ruoyi-common</artifactId> + </dependency> + <dependency> + <groupId>com.ruoyi</groupId> + <artifactId>ruoyi-framework</artifactId> + </dependency> + <dependency> + <groupId>com.ruoyi</groupId> + <artifactId>ruoyi-system</artifactId> + </dependency> + </dependencies> + <properties> <maven.compiler.source>8</maven.compiler.source> <maven.compiler.target>8</maven.compiler.target> diff --git a/performance-server/pom.xml b/performance-server/pom.xml new file mode 100644 index 0000000..12db53e --- /dev/null +++ b/performance-server/pom.xml @@ -0,0 +1,34 @@ +<?xml version="1.0" encoding="UTF-8"?> +<project xmlns="http://maven.apache.org/POM/4.0.0" + xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" + xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> + <parent> + <artifactId>ruoyi</artifactId> + <groupId>com.ruoyi</groupId> + <version>3.8.9</version> + </parent> + <modelVersion>4.0.0</modelVersion> + + <artifactId>performance-server</artifactId> + + <dependencies> + <dependency> + <groupId>com.ruoyi</groupId> + <artifactId>ruoyi-common</artifactId> + </dependency> + <dependency> + <groupId>com.ruoyi</groupId> + <artifactId>ruoyi-framework</artifactId> + </dependency> + <dependency> + <groupId>com.ruoyi</groupId> + <artifactId>ruoyi-system</artifactId> + </dependency> + </dependencies> + + <properties> + <maven.compiler.source>8</maven.compiler.source> + <maven.compiler.target>8</maven.compiler.target> + </properties> + +</project> diff --git a/performance-server/src/main/java/com/ruoyi/performance/controller/AuxiliaryCorrectionHoursController.java b/performance-server/src/main/java/com/ruoyi/performance/controller/AuxiliaryCorrectionHoursController.java new file mode 100644 index 0000000..290e0f2 --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/controller/AuxiliaryCorrectionHoursController.java @@ -0,0 +1,59 @@ +package com.ruoyi.performance.controller; + +import com.alibaba.excel.EasyExcel; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.ruoyi.common.core.domain.Result; +import com.ruoyi.common.utils.JackSonUtil; +import com.ruoyi.performance.dto.AuxiliaryCorrectionHoursDto; +import com.ruoyi.performance.excel.AuxiliaryCorrectionHoursListener; +import com.ruoyi.performance.service.AuxiliaryCorrectionHoursService; +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiOperation; +import lombok.AllArgsConstructor; +import org.springframework.web.bind.annotation.*; +import org.springframework.web.multipart.MultipartFile; + +import javax.annotation.Resource; +import java.io.IOException; +import java.util.Map; + +/** + * <p> + * 宸ユ椂缁熻鐨勪慨姝e伐鏃� 鍓嶇鎺у埗鍣� + * </p> + * + * @author 姹熻嫃榈烽洀缃戠粶绉戞妧鏈夐檺鍏徃 + * @since 2024-05-29 02:38:19 + */ +@Api(tags = "宸ユ椂缁熻-淇宸ユ椂") +@AllArgsConstructor +@RestController +@RequestMapping("/auxiliaryCorrectionHours") +public class AuxiliaryCorrectionHoursController { + + @Resource + AuxiliaryCorrectionHoursService auxiliaryCorrectionHoursService; + + @ApiOperation(value = "鏌ヨ淇宸ユ椂") + @PostMapping("/selectAuxiliaryCorrectionHours") + public Result selectAuxiliaryCorrectionHours(Page page,AuxiliaryCorrectionHoursDto entity) throws Exception { + return Result.success(auxiliaryCorrectionHoursService.selectAuxiliaryCorrectionHours(page, entity)); + } + + /** + * excel涓婁紶 + * + * @return + */ + @ApiOperation(value = "瀵煎叆淇宸ユ椂") + @PostMapping("/upload") + public Result upload(@RequestParam("file") MultipartFile file) { + try { + EasyExcel.read(file.getInputStream(), AuxiliaryCorrectionHoursDto.class, new AuxiliaryCorrectionHoursListener(auxiliaryCorrectionHoursService)).sheet().doRead(); + } catch (IOException e) { + e.printStackTrace(); + } + return Result.success(); + } + +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/controller/AuxiliaryOriginalHoursController.java b/performance-server/src/main/java/com/ruoyi/performance/controller/AuxiliaryOriginalHoursController.java new file mode 100644 index 0000000..e70636c --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/controller/AuxiliaryOriginalHoursController.java @@ -0,0 +1,44 @@ +package com.ruoyi.performance.controller; + +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.ruoyi.common.core.domain.Result; +import com.ruoyi.common.utils.JackSonUtil; +import com.ruoyi.performance.dto.AuxiliaryOriginalHoursLookDto; +import com.ruoyi.performance.service.AuxiliaryOriginalHoursService; +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiOperation; +import lombok.AllArgsConstructor; +import org.springframework.web.bind.annotation.*; + +import javax.annotation.Resource; +import javax.servlet.http.HttpServletResponse; +import java.io.IOException; +import java.util.Map; + +@Api(tags = "宸ユ椂缁熻-鍘熷宸ユ椂") +@AllArgsConstructor +@RestController +@RequestMapping("/auxiliaryOriginalHours") +public class AuxiliaryOriginalHoursController { + + @Resource + AuxiliaryOriginalHoursService auxiliaryOriginalHoursService; + + @ApiOperation(value = "鏌ヨ鍘熷宸ユ椂") + @PostMapping("/selectAuxiliaryOriginalHours") + public Result selectAuxiliaryOriginalHours(Page page, AuxiliaryOriginalHoursLookDto entity) throws Exception { + return Result.success(auxiliaryOriginalHoursService.selectAuxiliaryOriginalHours(page, entity)); + } + + @ApiOperation(value = "瀵煎嚭鍘熷宸ユ椂") + @PostMapping("/exportOriginalHours") + public void exportOriginalHours(@RequestParam("month") String month, @RequestParam("name") String name, @RequestParam("departLims") String departLims,HttpServletResponse response) throws IOException { + auxiliaryOriginalHoursService.exportWorkingHours(month,name,departLims,response); + } + + @ApiOperation(value = "鏌ヨ鏈堜唤鍏ㄩ儴宸ユ椂") + @PostMapping("/selectAuxiliaryAllByMonth") + public Result selectAuxiliaryAllByMonth(@RequestBody AuxiliaryOriginalHoursLookDto dto){ + return Result.success(auxiliaryOriginalHoursService.selectAuxiliaryAllByMonth(dto)); + } +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/controller/AuxiliaryOutputWorkingHoursController.java b/performance-server/src/main/java/com/ruoyi/performance/controller/AuxiliaryOutputWorkingHoursController.java new file mode 100644 index 0000000..5fb7d13 --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/controller/AuxiliaryOutputWorkingHoursController.java @@ -0,0 +1,74 @@ +package com.ruoyi.performance.controller; + +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.ruoyi.common.core.domain.Result; +import com.ruoyi.common.utils.JackSonUtil; +import com.ruoyi.performance.dto.AuxiliaryOutputWorkingHoursDto; +import com.ruoyi.performance.service.AuxiliaryOutputWorkingHoursService; +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiOperation; +import lombok.AllArgsConstructor; +import org.springframework.web.bind.annotation.*; + +import javax.annotation.Resource; +import javax.servlet.http.HttpServletResponse; +import java.io.IOException; +import java.util.Map; + +/** + * <p> + * 鏃ュ伐鏃剁鐞嗙殑浜ч噺宸ユ椂 鍓嶇鎺у埗鍣� + * </p> + * + * @author 姹熻嫃榈烽洀缃戠粶绉戞妧鏈夐檺鍏徃 + * @since 2024-05-28 03:48:48 + */ +@Api(tags = "鏃ュ伐鏃剁鐞�-浜ч噺宸ユ椂") +@AllArgsConstructor +@RestController +@RequestMapping("/auxiliaryOutputWorkingHours") +public class AuxiliaryOutputWorkingHoursController { + + @Resource + private AuxiliaryOutputWorkingHoursService auxiliaryOutputWorkingHoursService; + + @ApiOperation(value = "鏌ヨ浜ч噺宸ユ椂") + @PostMapping("/selectAuxiliaryOutputWorkingHours") + public Result selectAuxiliaryOutputWorkingHours(Page page,AuxiliaryOutputWorkingHoursDto entity) throws Exception { + return Result.success(auxiliaryOutputWorkingHoursService.selectAuxiliaryOutputWorkingHours(page, entity)); + } + + @ApiOperation(value = "缁熻浜ч噺宸ユ椂姹囨�诲拰杈呭姪宸ユ椂姹囨��") + @PostMapping("/collectWorkingHours") + public Result collectWorkingHours(@RequestBody Map<String, Object> data)throws Exception{ + AuxiliaryOutputWorkingHoursDto entity = JackSonUtil.unmarshal(JackSonUtil.marshal(data.get("entity")), AuxiliaryOutputWorkingHoursDto.class); + return Result.success(auxiliaryOutputWorkingHoursService.collectWorkingHours(entity)); + } + + + @ApiOperation(value = "瀵煎嚭浜ч噺宸ユ椂+杈呭姪宸ユ椂") + @GetMapping("/exportWorkingHours") + public void exportWorkingHours(HttpServletResponse response) throws IOException { + auxiliaryOutputWorkingHoursService.exportWorkingHours(response); + } + + @ApiOperation(value = "缁勯暱鏉冮檺") + @PostMapping("/leader") + public Result leader() { + return Result.success(); + } + + + /** + * 瀵煎嚭浜ч噺宸ユ椂 + * @param response + * @throws IOException + */ + @ApiOperation(value = "瀵煎嚭浜ч噺宸ユ椂") + @PostMapping("/exportOutputHours") + public void exportOutputHours(@RequestBody Map<String, Object> data, HttpServletResponse response) throws Exception { + AuxiliaryOutputWorkingHoursDto entity = JackSonUtil.unmarshal(JackSonUtil.marshal(data.get("entity")), AuxiliaryOutputWorkingHoursDto.class); + auxiliaryOutputWorkingHoursService.exportOutputHours(entity, response); + } + +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/controller/AuxiliaryWorkingHoursController.java b/performance-server/src/main/java/com/ruoyi/performance/controller/AuxiliaryWorkingHoursController.java new file mode 100644 index 0000000..bab8fc7 --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/controller/AuxiliaryWorkingHoursController.java @@ -0,0 +1,59 @@ +package com.ruoyi.performance.controller; + +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.ruoyi.common.core.domain.Result; +import com.ruoyi.common.utils.JackSonUtil; +import com.ruoyi.performance.pojo.AuxiliaryWorkingHours; +import com.ruoyi.performance.service.AuxiliaryWorkingHoursService; +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiOperation; +import lombok.AllArgsConstructor; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +import javax.annotation.Resource; +import java.util.Map; + +/** + * <p> + * 杈呭姪宸ユ椂 鍓嶇鎺у埗鍣� + * </p> + * + * @author 姹熻嫃榈烽洀缃戠粶绉戞妧鏈夐檺鍏徃 + * @since 2024-05-09 06:58:31 + */ +@Api(tags = "缁╂晥绠$悊-杈呭姪宸ユ椂璁剧疆") +@AllArgsConstructor +@RestController +@RequestMapping("/auxiliaryWorkingHours") +public class AuxiliaryWorkingHoursController { + @Resource + private AuxiliaryWorkingHoursService auxiliaryWorkingHoursService; + + @ApiOperation(value="鏌ヨ杈呭姪宸ユ椂") + @PostMapping("/selectAuxiliaryWorkingHours") + public Result selectAuxiliaryWorkingHours(Page page,AuxiliaryWorkingHours entity) throws Exception { + return Result.success(auxiliaryWorkingHoursService.selectAuxiliaryWorkingHours(page,entity)); + } + + @ApiOperation(value="鍒犻櫎杈呭姪宸ユ椂") + @PostMapping("/deleteAuxiliaryWorkingHours") + public Result deleteAuxiliaryWorkingHours(Integer id){ + return Result.success(auxiliaryWorkingHoursService.deleteAuxiliaryWorkingHours(id)); + } + + @ApiOperation(value="淇敼杈呭姪宸ユ椂") + @PostMapping("/upAuxiliaryWorkingHours") + public Result upAuxiliaryWorkingHours(@RequestBody AuxiliaryWorkingHours auxiliaryWorkingHours){ + return Result.success(auxiliaryWorkingHoursService.upAuxiliaryWorkingHours(auxiliaryWorkingHours)); + } + + @ApiOperation(value="鏂板杈呭姪宸ユ椂") + @PostMapping("/insertAuxiliaryWorkingHours") + public Result insertAuxiliaryWorkingHours(@RequestBody AuxiliaryWorkingHours auxiliaryWorkingHours){ + return Result.success(auxiliaryWorkingHoursService.insertAuxiliaryWorkingHours(auxiliaryWorkingHours)); + } + +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/controller/AuxiliaryWorkingHoursDayController.java b/performance-server/src/main/java/com/ruoyi/performance/controller/AuxiliaryWorkingHoursDayController.java new file mode 100644 index 0000000..97b0a81 --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/controller/AuxiliaryWorkingHoursDayController.java @@ -0,0 +1,101 @@ +package com.ruoyi.performance.controller; + +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.ruoyi.common.core.domain.Result; +import com.ruoyi.common.utils.JackSonUtil; +import com.ruoyi.performance.dto.AuxiliaryWorkingHoursDayDto; +import com.ruoyi.performance.dto.HoursDay; +import com.ruoyi.performance.pojo.AuxiliaryWorkingHoursDay; +import com.ruoyi.performance.service.AuxiliaryWorkingHoursDayService; +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiOperation; +import lombok.AllArgsConstructor; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +import javax.annotation.Resource; +import javax.servlet.http.HttpServletResponse; +import java.io.IOException; +import java.time.LocalDateTime; +import java.util.Map; + +/** + * <p> + * 鏃ュ伐鏃剁鐞嗙殑杈呭姪宸ユ椂 鍓嶇鎺у埗鍣� + * </p> + * + * @author 姹熻嫃榈烽洀缃戠粶绉戞妧鏈夐檺鍏徃 + * @since 2024-05-28 02:22:19 + */ +@Api(tags = "鏃ュ伐鏃剁鐞�-杈呭姪宸ユ椂") +@AllArgsConstructor +@RestController +@RequestMapping("/auxiliaryWorkingHoursDay") +public class AuxiliaryWorkingHoursDayController { + + @Resource + private AuxiliaryWorkingHoursDayService auxiliaryWorkingHoursDayService; + + @ApiOperation(value = "鏌ヨ宸ユ椂缁熻鐨勮緟鍔╁伐鏃�") + @PostMapping("/selectAuxiliaryWorkingHoursDay") + public Result selectAuxiliaryWorkingHoursDay(Page page,AuxiliaryWorkingHoursDayDto entity) throws Exception { + return Result.success(auxiliaryWorkingHoursDayService.selectAuxiliaryWorkingHoursDay(page, entity)); + } + + @ApiOperation(value = "鏍规嵁缂栧彿鏌ヨ杈呭姪宸ユ椂閰嶇疆淇℃伅") + @PostMapping("/selectAuxiliaryWorkingHoursByNumber") + public Result selectAuxiliaryWorkingHoursByNumber(String number) { + return Result.success(auxiliaryWorkingHoursDayService.selectAuxiliaryWorkingHoursByNumber(number)); + } + + @ApiOperation(value = "鏍规嵁缂栧彿褰撳墠鐢ㄦ埛淇℃伅鏌ヨ鎵�鍦ㄧ彮娆�") + @PostMapping("/selectshiftByUser") + public Result selectshiftByUser(LocalDateTime dateTime) { + return Result.success(auxiliaryWorkingHoursDayService.selectshiftByUser(dateTime)); + } + + @ApiOperation(value = "褰曞叆鏁版嵁(宸ユ椂缁熻鐨勮緟鍔╁伐鏃�)") + @PostMapping("/insertAuxiliaryWorkingHoursDay") + public Result insertAuxiliaryWorkingHoursDay(@RequestBody AuxiliaryWorkingHoursDay auxiliaryWorkingHoursDay) { + return Result.success(auxiliaryWorkingHoursDayService.insertAuxiliaryWorkingHoursDay(auxiliaryWorkingHoursDay)); + } + + @ApiOperation(value = "鎵瑰噯宸ユ椂缁熻鐨勮緟鍔╁伐鏃�") + @PostMapping("/approve") + public Result approve(@RequestBody HoursDay hoursDay ) { + return Result.success(auxiliaryWorkingHoursDayService.checkOrApprove(hoursDay)); + } + + @ApiOperation(value = "瀹℃牳宸ユ椂缁熻鐨勮緟鍔╁伐鏃�") + @PostMapping("/check") + public Result check(@RequestBody HoursDay hoursDay ) { + return Result.success(auxiliaryWorkingHoursDayService.checkOrApprove(hoursDay)); + } + + @ApiOperation(value = "缂栬緫宸ユ椂缁熻鐨勮緟鍔╁伐鏃�") + @PostMapping("/updateAuxiliaryWorkingHoursDay") + public Result updateAuxiliaryWorkingHoursDay(@RequestBody AuxiliaryWorkingHoursDay auxiliaryWorkingHoursDay) { + return Result.success(auxiliaryWorkingHoursDayService.updateAuxiliaryWorkingHoursDay(auxiliaryWorkingHoursDay)); + } + + @ApiOperation(value = "鍒犻櫎宸ユ椂缁熻鐨勮緟鍔╁伐鏃�") + @PostMapping("/deleteAuxiliaryWorkingHoursDay") + public Result deleteAuxiliaryWorkingHoursDay(Integer id) { + return Result.success(auxiliaryWorkingHoursDayService.deleteAuxiliaryWorkingHoursDay(id)); + } + + /** + * 瀵煎嚭杈呭姪宸ユ椂 + * @param response + * @throws IOException + */ + @ApiOperation(value = "瀵煎嚭杈呭姪宸ユ椂") + @PostMapping("/exportAssistantHours") + public void exportAssistantHours(@RequestBody Map<String, Object> data, HttpServletResponse response) throws Exception { + AuxiliaryWorkingHoursDayDto entity = JackSonUtil.unmarshal(JackSonUtil.marshal(data.get("entity")), AuxiliaryWorkingHoursDayDto.class); + auxiliaryWorkingHoursDayService.exportWorkingHours(entity, response); + } + +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/controller/PerformanceShiftController.java b/performance-server/src/main/java/com/ruoyi/performance/controller/PerformanceShiftController.java new file mode 100644 index 0000000..ecdabdb --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/controller/PerformanceShiftController.java @@ -0,0 +1,152 @@ +package com.ruoyi.performance.controller; + +import com.alibaba.excel.EasyExcel; +import com.alibaba.excel.write.style.HorizontalCellStyleStrategy; +import com.alibaba.excel.write.style.column.LongestMatchColumnWidthStyleStrategy; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.ruoyi.common.core.domain.Result; +import com.ruoyi.common.core.domain.entity.SysDictData; +import com.ruoyi.performance.dto.PerformanceShiftAddDto; +import com.ruoyi.performance.pojo.PerformanceShift; +import com.ruoyi.performance.service.PerformanceShiftService; +import com.ruoyi.performance.utils.StyleMonthUtils; +import com.ruoyi.performance.utils.StyleYearUtils; +import com.ruoyi.system.service.ISysDictTypeService; +import com.ruoyi.system.service.UserService; +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiOperation; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.*; + +import javax.annotation.Resource; +import javax.servlet.http.HttpServletResponse; +import javax.validation.constraints.NotNull; +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.LocalTime; +import java.time.temporal.TemporalAdjusters; +import java.time.temporal.WeekFields; +import java.util.Collection; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import java.util.stream.Collectors; + + +/** + * <p> + * 缁╂晥绠$悊-鐝 鍓嶇鎺у埗鍣� + * </p> + * + * @author 姹熻嫃榈烽洀缃戠粶绉戞妧鏈夐檺鍏徃 + * @since 2024-05-08 09:12:04 + */ +@Api(tags = "缁╂晥绠$悊-鐝") +@RestController +@RequestMapping("/performanceShift") +public class PerformanceShiftController { + + @Autowired + private PerformanceShiftService performanceShiftService; + + @Resource + private ISysDictTypeService dictTypeService; + + @Resource + private UserService userService; + + @ApiOperation(value = "鎺掔彮") + @PostMapping("add") + public Result<?> performanceShiftAdd(@RequestBody PerformanceShiftAddDto performanceShiftAddDto) { + performanceShiftService.performanceShiftAdd(performanceShiftAddDto); + return Result.success(); + } + + @ApiOperation(value = "鏈堜唤鍒嗛〉鏌ヨ") + @PostMapping("page") + public Result<?> performanceShiftPage(Integer size, Integer current, String time, String userName, String laboratory) { + return Result.success(performanceShiftService.performanceShiftPage(new Page<>(current, size), time, userName, laboratory)); + } + + @ApiOperation(value = "骞翠唤鍒嗛〉鏌ヨ") + @PostMapping("pageYear") + public Result<?> performanceShiftPageYear(Integer size, Integer current, String time, String userName, String laboratory) { + return Result.success(performanceShiftService.performanceShiftPageYear(new Page<>(current, size), time, userName, laboratory)); + } + + @ApiOperation(value = "鐝鐘舵�佷慨鏀�") + @PutMapping("update") + public Result<?> performanceShiftUpdate(@RequestBody PerformanceShift performanceShift) { + performanceShiftService.performanceShiftUpdate(performanceShift); + return Result.success(); + } + + @ApiOperation(value = "瀵煎嚭") + @GetMapping("export") + public void exportToExcel(@NotNull(message = "鏃堕棿涓嶈兘涓虹┖锛�") String time, String userName, String laboratory, Boolean isMonth, HttpServletResponse response) throws Exception { + Map<Object, Object> data; + response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"); + response.setHeader("requestType","excel"); + response.setHeader("Access-Control-Expose-Headers", "requestType"); + if (!isMonth) { + data = performanceShiftService.exportToYearExcel(time, userName, laboratory); + // 璁剧疆鍗曞厓鏍兼牱寮� + HorizontalCellStyleStrategy horizontalCellStyleStrategy = new HorizontalCellStyleStrategy(StyleYearUtils.getHeadStyle(), StyleYearUtils.getContentStyle()); + // 淇濆瓨鍒扮涓�涓猻heet涓� + EasyExcel.write(response.getOutputStream()) + .head((List<List<String>>) data.get("header")) + .registerWriteHandler(new LongestMatchColumnWidthStyleStrategy()) // 鑷�傚簲鍒楀 + .registerWriteHandler(horizontalCellStyleStrategy) + .sheet("骞村害") + .doWrite((Collection<?>) data.get("data")); + } else { + data = performanceShiftService.exportToMonthExcel(time, userName, laboratory); + // 璁剧疆鍗曞厓鏍兼牱寮� + HorizontalCellStyleStrategy horizontalCellStyleStrategy = new HorizontalCellStyleStrategy(StyleMonthUtils.getHeadStyle(), StyleMonthUtils.getContentStyle()); + EasyExcel.write(response.getOutputStream()) + .head((List<List<String>>) data.get("header")) + .registerWriteHandler(horizontalCellStyleStrategy) + .sheet("鏈堝害") + .doWrite((Collection<?>) data.get("data")); + } + } + + @ApiOperation(value = "涓存椂鎺ュ彛-娣诲姞7鏈堜唤8鏈堜唤鐨勬暟鎹�") + @GetMapping("temporaryInterface") + public void temporaryInterface() { + System.out.println("寮�濮嬬粰姣忎釜浜鸿繘琛屾帓鐝�,榛樿鏃╃彮======start"); + // TODO 缁欐瘡涓汉閮借繘琛屾帓鐝�(榛樿鏃╃彮) + PerformanceShiftAddDto performanceShiftAddDto = new PerformanceShiftAddDto(); + //鐝--鏃�(鏌ヨ瀛楀吀) + List<SysDictData> shiftType = dictTypeService.selectDictDataByName("鐝绫诲瀷"); + List<String> collect = shiftType.stream().filter(enums -> enums.getDictLabel().equals("鏃�")).map(enums -> enums.getDictValue()).collect(Collectors.toList()); + performanceShiftAddDto.setShift(collect.get(0)); + //浜哄憳--鎵�鏈変汉 + String userIds = userService.list().stream().map(user -> user.getId().toString()).distinct().collect(Collectors.joining(",")); + performanceShiftAddDto.setUserId(userIds); + //鍛ㄦ--褰撴湀鎵�鏈� + // 鑾峰彇褰撳墠鏃ユ湡 + LocalDate today = LocalDate.of(2024, 8, 15); + // 鑾峰彇鏈湀鐨勭涓�澶╁拰鏈�鍚庝竴澶� + LocalDate firstDayOfMonth = today.with(TemporalAdjusters.firstDayOfMonth()); + LocalDate lastDayOfMonth = today.with(TemporalAdjusters.lastDayOfMonth()); + // 鑾峰彇鍛ㄥ瓧娈典俊鎭紙鏍规嵁鍖哄煙璁剧疆锛� + WeekFields weekFields = WeekFields.of(Locale.getDefault()); + // 鑾峰彇鏈湀绗竴澶╃殑鍛ㄤ竴 + LocalDate startOfWeek = firstDayOfMonth.with(TemporalAdjusters.previousOrSame(weekFields.getFirstDayOfWeek())); + // 閬嶅巻鏈湀鎵�鏈夊ぉ鏁帮紝鎵惧嚭姣忓懆鐨勭涓�澶╁拰鏈�鍚庝竴澶� + LocalDate endOfWeek; + while (startOfWeek.isBefore(firstDayOfMonth.plusMonths(1))) { + endOfWeek = startOfWeek.plusDays(6); + LocalDateTime startDateTime = LocalDateTime.of(startOfWeek, LocalTime.MIDNIGHT); + LocalDateTime endDateTime = LocalDateTime.of(endOfWeek, LocalTime.MIDNIGHT); + System.out.println("Week starts on " + startDateTime + " and ends on " + endDateTime); + performanceShiftAddDto.setStartWeek(startDateTime); + performanceShiftAddDto.setEndWeek(endDateTime); + performanceShiftService.performanceShiftAdd(performanceShiftAddDto); + startOfWeek = startOfWeek.plusWeeks(1); + } + + System.out.println("鎺掔彮缁撴潫======end"); + } +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/controller/ShiftTimeController.java b/performance-server/src/main/java/com/ruoyi/performance/controller/ShiftTimeController.java new file mode 100644 index 0000000..96364e1 --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/controller/ShiftTimeController.java @@ -0,0 +1,55 @@ +package com.ruoyi.performance.controller; + +import com.ruoyi.common.core.domain.Result; +import com.ruoyi.performance.pojo.ShiftTime; +import com.ruoyi.performance.service.ShiftTimeService; +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiOperation; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +/** + * <p> + * 鐝瀵瑰簲鐨勬椂闂� 鍓嶇鎺у埗鍣� + * </p> + * + * @author 姹熻嫃榈烽洀缃戠粶绉戞妧鏈夐檺鍏徃 + * @since 2024-07-24 11:22:17 + */ +@Api(tags = "缁╂晥绠$悊-鐝鎺掔彮") +@RestController +@RequestMapping("/shiftTime") +public class ShiftTimeController { + + @Autowired + private ShiftTimeService shiftTimeService; + + @ApiOperation(value = "鎺掔彮鏃堕棿閰嶇疆") + @PostMapping("add") + public Result<?> shiftTimeAdd(@RequestBody ShiftTime shiftTime) { + shiftTimeService.shiftTimeAdd(shiftTime); + return Result.success(); + } + + @ApiOperation(value = "鎺掔彮鏃堕棿閰嶇疆鏌ヨ") + @PostMapping("list") + public Result<?> shiftTimeList() { + return Result.success(shiftTimeService.shiftTimeList()); + } + + @ApiOperation(value = "鎺掔彮鏃堕棿閰嶇疆鍒犻櫎") + @PostMapping("remove") + public Result<?> shiftTimeRemove(Long id) { + return Result.success(shiftTimeService.removeById(id)); + } + + @ApiOperation(value = "鎺掔彮鏃堕棿閰嶇疆淇敼") + @PostMapping("update") + public Result<?> shiftTimeUpdate(@RequestBody ShiftTime shiftTime) { + return Result.success(shiftTimeService.updateById(shiftTime)); + } + +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/dto/AuxiliaryAllDto.java b/performance-server/src/main/java/com/ruoyi/performance/dto/AuxiliaryAllDto.java new file mode 100644 index 0000000..8b3afb1 --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/dto/AuxiliaryAllDto.java @@ -0,0 +1,35 @@ +package com.ruoyi.performance.dto; + +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +import java.math.BigDecimal; + +/** + * 宸ユ椂缁熻鍒楄〃 + * + * @Author zhuo + * @Date 2024/10/25 + */ +@Data +public class AuxiliaryAllDto { + + @ApiModelProperty("浜ч噺宸ユ椂") + private BigDecimal yieldHour; + + @ApiModelProperty("杈呭姪宸ユ椂") + private BigDecimal subsidiaryHour; + + @ApiModelProperty("鎬诲伐鏃�") + private BigDecimal totalHour; + + @ApiModelProperty("浜哄憳id") + private Integer userId; + + @ApiModelProperty("濮撳悕") + private String userName; + + @ApiModelProperty("鏈堜唤") + private String month; + +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/dto/AuxiliaryCorrectionHoursDto.java b/performance-server/src/main/java/com/ruoyi/performance/dto/AuxiliaryCorrectionHoursDto.java new file mode 100644 index 0000000..b6066cf --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/dto/AuxiliaryCorrectionHoursDto.java @@ -0,0 +1,22 @@ +package com.ruoyi.performance.dto; + +import com.alibaba.excel.annotation.ExcelProperty; +import com.ruoyi.performance.pojo.AuxiliaryCorrectionHours; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +import java.math.BigDecimal; + +@Data +public class AuxiliaryCorrectionHoursDto extends AuxiliaryCorrectionHours { + + @ApiModelProperty("濮撳悕") + @ExcelProperty(value = "濮撳悕") + private String name; + + @ApiModelProperty("閮ㄩ棬") + private String departLims; + + @ApiModelProperty("鎬诲伐鏃�") + private BigDecimal total; +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/dto/AuxiliaryOriginalHoursDto.java b/performance-server/src/main/java/com/ruoyi/performance/dto/AuxiliaryOriginalHoursDto.java new file mode 100644 index 0000000..e037f05 --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/dto/AuxiliaryOriginalHoursDto.java @@ -0,0 +1,251 @@ +package com.ruoyi.performance.dto; + +import com.alibaba.excel.annotation.ExcelIgnore; +import com.alibaba.excel.annotation.ExcelProperty; +import com.ruoyi.performance.pojo.AuxiliaryCorrectionHours; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +import java.math.BigDecimal; + +@Data +//鍘熷宸ユ椂 +public class AuxiliaryOriginalHoursDto { + + @ApiModelProperty("濮撳悕") + @ExcelProperty(value = "濮撳悕") + private String name; + + //淇宸ユ椂 + private AuxiliaryCorrectionHours auxiliaryCorrectionHours; + + @ApiModelProperty("绫诲瀷") + @ExcelProperty(value = "绫诲瀷") + private String type; + + @ApiModelProperty("1鏃ュ伐鏃�") + @ExcelProperty(value = "1鏃�") + private BigDecimal oneHours; + + @ExcelIgnore + private Integer one; + + @ApiModelProperty("2鏃ュ伐鏃�") + @ExcelProperty(value = "2鏃�") + private BigDecimal twoHours; + + @ExcelIgnore + private Integer two; + + @ApiModelProperty("3鏃ュ伐鏃�") + @ExcelProperty(value = "3鏃�") + private BigDecimal threeHours; + + @ExcelIgnore + private Integer three; + + @ApiModelProperty("4鏃ュ伐鏃�") + @ExcelProperty(value = "4鏃�") + private BigDecimal fourHours; + + @ExcelIgnore + private Integer four; + + @ApiModelProperty("5鏃ュ伐鏃�") + @ExcelProperty(value = "5鏃�") + private BigDecimal fiveHours; + + @ExcelIgnore + private Integer five; + + @ApiModelProperty("6鏃ュ伐鏃�") + @ExcelProperty(value = "6鏃�") + private BigDecimal sixHours; + + @ExcelIgnore + private Integer six; + + @ApiModelProperty("7鏃ュ伐鏃�") + @ExcelProperty(value = "7鏃�") + private BigDecimal sevenHours; + + @ExcelIgnore + private Integer seven; + + @ApiModelProperty("8鏃ュ伐鏃�") + @ExcelProperty(value = "8鏃�") + private BigDecimal eightHours; + + @ExcelIgnore + private Integer eight; + + @ApiModelProperty("9鏃ュ伐鏃�") + @ExcelProperty(value = "9鏃�") + private BigDecimal nineHours; + + @ExcelIgnore + private Integer nine; + + @ApiModelProperty("10鏃ュ伐鏃�") + @ExcelProperty(value = "10鏃�") + private BigDecimal tenHours; + + @ExcelIgnore + private Integer ten; + + @ApiModelProperty("11鏃ュ伐鏃�") + @ExcelProperty(value = "11鏃�") + private BigDecimal elevenHours; + + @ExcelIgnore + private Integer eleven; + + @ApiModelProperty("12鏃ュ伐鏃�") + @ExcelProperty(value = "12鏃�") + private BigDecimal twelveHours; + + @ExcelIgnore + private Integer twelve; + + @ApiModelProperty("13鏃ュ伐鏃�") + @ExcelProperty(value = "13鏃�") + private BigDecimal thirteenHours; + + @ExcelIgnore + private Integer thirteen; + + @ApiModelProperty("14鏃ュ伐鏃�") + @ExcelProperty(value = "14鏃�") + private BigDecimal fourteenHours; + + @ExcelIgnore + private Integer fourteen; + + @ApiModelProperty("15鏃ュ伐鏃�") + @ExcelProperty(value = "15鏃�") + private BigDecimal fifteenHours; + + @ExcelIgnore + private Integer fifteen; + + @ApiModelProperty("16鏃ュ伐鏃�") + @ExcelProperty(value = "16鏃�") + private BigDecimal sixteenHours; + + @ExcelIgnore + private Integer sixteen; + + @ApiModelProperty("17鏃ュ伐鏃�") + @ExcelProperty(value = "17鏃�") + private BigDecimal seventeenHours; + + @ExcelIgnore + private Integer seventeen; + + @ApiModelProperty("18鏃ュ伐鏃�") + @ExcelProperty(value = "18鏃�") + private BigDecimal eighteenHours; + + @ExcelIgnore + private Integer eighteen; + + @ApiModelProperty("19鏃ュ伐鏃�") + @ExcelProperty(value = "19鏃�") + private BigDecimal nineteenHours; + + @ExcelIgnore + private Integer nineteen; + + @ApiModelProperty("20鏃ュ伐鏃�") + @ExcelProperty(value = "20鏃�") + private BigDecimal twentyHours; + + @ExcelIgnore + private Integer twenty; + + @ApiModelProperty("21鏃ュ伐鏃�") + @ExcelProperty(value = "21鏃�") + private BigDecimal twentyOneHours; + + @ExcelIgnore + private Integer twentyOne; + + @ApiModelProperty("22鏃ュ伐鏃�") + @ExcelProperty(value = "22鏃�") + private BigDecimal twentyTwoHours; + + @ExcelIgnore + private Integer twentyTwo; + + @ApiModelProperty("23鏃ュ伐鏃�") + @ExcelProperty(value = "23鏃�") + private BigDecimal twentyThreeHours; + + @ExcelIgnore + private Integer twentyThree; + + @ApiModelProperty("24鏃ュ伐鏃�") + @ExcelProperty(value = "24鏃�") + private BigDecimal twentyFourHours; + + @ExcelIgnore + private Integer twentyFour; + + @ApiModelProperty("25鏃ュ伐鏃�") + @ExcelProperty(value = "25鏃�") + private BigDecimal twentyFiveHours; + + @ExcelIgnore + private Integer twentyFive; + + @ApiModelProperty("26鏃ュ伐鏃�") + @ExcelProperty(value = "26鏃�") + private BigDecimal twentySixHours; + + @ExcelIgnore + private Integer twentySix; + + @ApiModelProperty("27鏃ュ伐鏃�") + @ExcelProperty(value = "27鏃�") + private BigDecimal twentySevenHours; + + @ExcelIgnore + private Integer twentySeven; + + @ApiModelProperty("28鏃ュ伐鏃�") + @ExcelProperty(value = "28鏃�") + private BigDecimal twentyEightHours; + + @ExcelIgnore + private Integer twentyEight; + + @ApiModelProperty("29鏃ュ伐鏃�") + @ExcelProperty(value = "29鏃�") + private BigDecimal twentyNineHours; + + @ExcelIgnore + private Integer twentyNine; + + @ApiModelProperty("30鏃ュ伐鏃�") + @ExcelProperty(value = "30鏃�") + private BigDecimal thirtyHours; + + @ExcelIgnore + private Integer thirty; + + @ApiModelProperty("31鏃ュ伐鏃�") + @ExcelProperty(value = "31鏃�") + private BigDecimal thirtyOneHours; + + @ExcelIgnore + private Integer thirtyOne; + + @ApiModelProperty("鎬诲伐鏃�") + @ExcelProperty(value = "鎬诲伐鏃�") + private BigDecimal total; + + @ApiModelProperty("鏈堜唤") + @ExcelProperty(value = "鏈堜唤") + private String month; + +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/dto/AuxiliaryOriginalHoursLookDto.java b/performance-server/src/main/java/com/ruoyi/performance/dto/AuxiliaryOriginalHoursLookDto.java new file mode 100644 index 0000000..8ccf68d --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/dto/AuxiliaryOriginalHoursLookDto.java @@ -0,0 +1,26 @@ +package com.ruoyi.performance.dto; + + +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +import javax.validation.constraints.NotNull; + +@Data +//鍘熷宸ユ椂缁熻鐨勬煡璇㈡潯浠� +public class AuxiliaryOriginalHoursLookDto { + + @NotNull + private String month;//鏈堜唤 + + private String name; + + private String departLims; + + + @ApiModelProperty("寮�濮嬫椂闂�") + private String beginDate; + + @ApiModelProperty("缁撴潫鏃堕棿") + private String endDate; +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/dto/AuxiliaryOutputWorkingHoursDto.java b/performance-server/src/main/java/com/ruoyi/performance/dto/AuxiliaryOutputWorkingHoursDto.java new file mode 100644 index 0000000..0b5699a --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/dto/AuxiliaryOutputWorkingHoursDto.java @@ -0,0 +1,19 @@ +package com.ruoyi.performance.dto; + +import com.alibaba.excel.annotation.ExcelIgnoreUnannotated; +import com.alibaba.excel.annotation.ExcelProperty; +import com.ruoyi.performance.pojo.AuxiliaryOutputWorkingHours; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +@Data +@ExcelIgnoreUnannotated +public class AuxiliaryOutputWorkingHoursDto extends AuxiliaryOutputWorkingHours { + + @ApiModelProperty("妫�娴嬩汉") + @ExcelProperty(index = 1, value = "妫�娴嬩汉") + private String name; + + @ApiModelProperty("鐢电紗鏍囪瘑") + private String cableTag; +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/dto/AuxiliaryWorkingHoursDayDto.java b/performance-server/src/main/java/com/ruoyi/performance/dto/AuxiliaryWorkingHoursDayDto.java new file mode 100644 index 0000000..92f3b2e --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/dto/AuxiliaryWorkingHoursDayDto.java @@ -0,0 +1,16 @@ +package com.ruoyi.performance.dto; + +import com.alibaba.excel.annotation.ExcelIgnoreUnannotated; +import com.alibaba.excel.annotation.ExcelProperty; +import com.ruoyi.performance.pojo.AuxiliaryWorkingHoursDay; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +@Data +@ExcelIgnoreUnannotated +public class AuxiliaryWorkingHoursDayDto extends AuxiliaryWorkingHoursDay { + + @ApiModelProperty("濮撳悕") + @ExcelProperty(index = 1, value = "濮撳悕") + private String name; +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/dto/HoursDay.java b/performance-server/src/main/java/com/ruoyi/performance/dto/HoursDay.java new file mode 100644 index 0000000..3add587 --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/dto/HoursDay.java @@ -0,0 +1,15 @@ +package com.ruoyi.performance.dto; + +import com.ruoyi.performance.pojo.AuxiliaryWorkingHoursDay; +import lombok.Data; + +import java.util.List; + +@Data +public class HoursDay { + + // 鎿嶄綔, 1閫氳繃, 2閫�鍥� + private String operation; + + private List<AuxiliaryWorkingHoursDay> auxiliaryWorkingHoursDays; +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/dto/PerformanceShiftAddDto.java b/performance-server/src/main/java/com/ruoyi/performance/dto/PerformanceShiftAddDto.java new file mode 100644 index 0000000..a1811b9 --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/dto/PerformanceShiftAddDto.java @@ -0,0 +1,27 @@ +package com.ruoyi.performance.dto; + +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +import javax.validation.constraints.NotNull; +import java.time.LocalDateTime; + +@Data +public class PerformanceShiftAddDto { + + @NotNull(message = "璇烽�夋嫨鐝") + @ApiModelProperty("鐝") + private String shift; + + @NotNull(message = "璇烽�夋嫨鍛樺伐") + @ApiModelProperty("鍛樺伐id") + private String userId; + + @NotNull(message = "璇烽�夋嫨鍛ㄦ") + @ApiModelProperty("寮�濮嬪懆娆�") + private LocalDateTime startWeek; + + @NotNull(message = "璇烽�夋嫨鍛ㄦ") + @ApiModelProperty("缁撴潫鍛ㄦ") + private LocalDateTime endWeek; +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/dto/PerformanceShiftMapDto.java b/performance-server/src/main/java/com/ruoyi/performance/dto/PerformanceShiftMapDto.java new file mode 100644 index 0000000..1405d71 --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/dto/PerformanceShiftMapDto.java @@ -0,0 +1,27 @@ +package com.ruoyi.performance.dto; + +import lombok.Data; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +@Data +public class PerformanceShiftMapDto { + + private String name; + + private String shiftTime; + + private String userId; + + private String department; + + private Map<String, Object> monthlyAttendance = new HashMap<>(); + + private Map<String, Object> sidebarAnnualAttendance = new HashMap<>();; + private List<Map<String, Object>> list = new ArrayList<>(); + + private List<Map<Object, Object>> headerList = new ArrayList<>(); +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/excel/AuxiliaryCorrectionHoursListener.java b/performance-server/src/main/java/com/ruoyi/performance/excel/AuxiliaryCorrectionHoursListener.java new file mode 100644 index 0000000..f022143 --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/excel/AuxiliaryCorrectionHoursListener.java @@ -0,0 +1,41 @@ +package com.ruoyi.performance.excel; + + +import com.alibaba.excel.context.AnalysisContext; +import com.alibaba.excel.event.AnalysisEventListener; +import com.ruoyi.performance.dto.AuxiliaryCorrectionHoursDto; +import com.ruoyi.performance.service.AuxiliaryCorrectionHoursService; + +import java.util.ArrayList; +import java.util.List; + +public class AuxiliaryCorrectionHoursListener extends AnalysisEventListener<AuxiliaryCorrectionHoursDto> { + + private static final int BATCH_COUNT = 1000; + List<AuxiliaryCorrectionHoursDto> list = new ArrayList<>(); + + private AuxiliaryCorrectionHoursService auxiliaryCorrectionHoursService; + + public AuxiliaryCorrectionHoursListener(AuxiliaryCorrectionHoursService auxiliaryCorrectionHoursService) { + this.auxiliaryCorrectionHoursService = auxiliaryCorrectionHoursService; + } + + @Override + public void invoke(AuxiliaryCorrectionHoursDto data, AnalysisContext analysisContext) { + list.add(data); + if (list.size() >= BATCH_COUNT) { + save(); + list.clear(); + } + } + + @Override + public void doAfterAllAnalysed(AnalysisContext analysisContext) { + save(); + } + + + private void save() { + auxiliaryCorrectionHoursService.importExcel(list); + } +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/mapper/AuxiliaryCorrectionHoursMapper.java b/performance-server/src/main/java/com/ruoyi/performance/mapper/AuxiliaryCorrectionHoursMapper.java new file mode 100644 index 0000000..96db341 --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/mapper/AuxiliaryCorrectionHoursMapper.java @@ -0,0 +1,27 @@ +package com.ruoyi.performance.mapper; + +import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.baomidou.mybatisplus.core.metadata.IPage; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.ruoyi.performance.dto.AuxiliaryCorrectionHoursDto; +import com.ruoyi.performance.pojo.AuxiliaryCorrectionHours; +import org.apache.ibatis.annotations.Param; + +import java.util.List; + +/** + * <p> + * 宸ユ椂缁熻鐨勪慨姝e伐鏃� Mapper 鎺ュ彛 + * </p> + * + * @author 姹熻嫃榈烽洀缃戠粶绉戞妧鏈夐檺鍏徃 + * @since 2024-05-29 02:38:19 + */ +public interface AuxiliaryCorrectionHoursMapper extends BaseMapper<AuxiliaryCorrectionHours> { + + IPage<AuxiliaryCorrectionHoursDto> selectAuxiliaryCorrectionHours(Page page, @Param("ew") QueryWrapper<AuxiliaryCorrectionHoursDto> ew, @Param("ids") List<Long> ids); + + List<Integer> selDepartLimsByName(String departLims); + +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/mapper/AuxiliaryOriginalHoursMapper.java b/performance-server/src/main/java/com/ruoyi/performance/mapper/AuxiliaryOriginalHoursMapper.java new file mode 100644 index 0000000..e55ca6d --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/mapper/AuxiliaryOriginalHoursMapper.java @@ -0,0 +1,13 @@ +package com.ruoyi.performance.mapper; + +import org.apache.ibatis.annotations.Param; + +import java.util.List; +import java.util.Map; + +public interface AuxiliaryOriginalHoursMapper { + + //鏌ヨ璇ユ湀鐨勬�诲伐鏃� + List<Map<String, Object>> totalHours(@Param("month") String month, @Param("ids") List<Integer> ids); + +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/mapper/AuxiliaryOutputWorkingHoursMapper.java b/performance-server/src/main/java/com/ruoyi/performance/mapper/AuxiliaryOutputWorkingHoursMapper.java new file mode 100644 index 0000000..a563f4a --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/mapper/AuxiliaryOutputWorkingHoursMapper.java @@ -0,0 +1,55 @@ +package com.ruoyi.performance.mapper; + +import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.baomidou.mybatisplus.core.metadata.IPage; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.ruoyi.performance.dto.AuxiliaryAllDto; +import com.ruoyi.performance.dto.AuxiliaryOriginalHoursLookDto; +import com.ruoyi.performance.dto.AuxiliaryOutputWorkingHoursDto; +import com.ruoyi.performance.pojo.AuxiliaryOutputWorkingHours; +import org.apache.ibatis.annotations.Param; + +import java.util.List; +import java.util.Map; + +/** + * <p> + * 鏃ュ伐鏃剁鐞嗙殑浜ч噺宸ユ椂 Mapper 鎺ュ彛 + * </p> + * + * @author 姹熻嫃榈烽洀缃戠粶绉戞妧鏈夐檺鍏徃 + * @since 2024-05-28 03:48:48 + */ +public interface AuxiliaryOutputWorkingHoursMapper extends BaseMapper<AuxiliaryOutputWorkingHours> { + + IPage<AuxiliaryOutputWorkingHoursDto> selectAuxiliaryOutputWorkingHours(Page page, @Param("ew") QueryWrapper<AuxiliaryOutputWorkingHoursDto> ew, @Param("ids") List<Long> ids); + + //鏌ヨ缁熻宸ユ椂瀵煎嚭鏁版嵁 + List<AuxiliaryOutputWorkingHoursDto> selectDataByUser(@Param("ids") List<Long> ids); + + //鏌ヨ璇ユ湀鐨勪骇閲忓伐鏃� + List<Map<String, Object>> totalHours(@Param("month") String month, @Param("ids") List<Long> ids, @Param("type") String type); + + + List<AuxiliaryOutputWorkingHours> selectListByIds(@Param("ids") List<Long> ids); + + List<AuxiliaryOutputWorkingHours> selectLists(@Param("ew") QueryWrapper<AuxiliaryOutputWorkingHours> ew, @Param("ids") List<Long> ids); + + /** + * 鏌ヨ + * @param dto + * @return + */ + List<AuxiliaryAllDto> selectAuxiliaryAllByMonth(@Param("dto") AuxiliaryOriginalHoursLookDto dto, @Param("userIds") List<Long> userIds); + + /** + * 鏌ヨ杈呭姪宸ユ椂 + * @param dto + * @param userIds + * @return + */ + List<AuxiliaryAllDto> selectSubsidiaryAllByMonth(@Param("dto") AuxiliaryOriginalHoursLookDto dto, @Param("userIds") List<Long> userIds); + + List<AuxiliaryOutputWorkingHoursDto> selectAuxiliaryOutputWorkingHoursList(@Param("ew") QueryWrapper<AuxiliaryOutputWorkingHoursDto> ew, @Param("ids") List<Long> ids); +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/mapper/AuxiliaryWorkingHoursDayMapper.java b/performance-server/src/main/java/com/ruoyi/performance/mapper/AuxiliaryWorkingHoursDayMapper.java new file mode 100644 index 0000000..58d7e12 --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/mapper/AuxiliaryWorkingHoursDayMapper.java @@ -0,0 +1,43 @@ +package com.ruoyi.performance.mapper; + +import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.baomidou.mybatisplus.core.metadata.IPage; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.ruoyi.performance.dto.AuxiliaryWorkingHoursDayDto; +import com.ruoyi.performance.pojo.AuxiliaryWorkingHoursDay; +import org.apache.ibatis.annotations.Param; + +import java.util.List; +import java.util.Map; + +/** + * <p> + * 鏃ュ伐鏃剁鐞嗙殑杈呭姪宸ユ椂 Mapper 鎺ュ彛 + * </p> + * + * @author 姹熻嫃榈烽洀缃戠粶绉戞妧鏈夐檺鍏徃 + * @since 2024-05-28 02:22:19 + */ +public interface AuxiliaryWorkingHoursDayMapper extends BaseMapper<AuxiliaryWorkingHoursDay> { + + IPage<AuxiliaryWorkingHoursDayDto> selectAuxiliaryWorkingHoursDay(Page page, @Param("ew") QueryWrapper<AuxiliaryWorkingHoursDayDto> ew, @Param("ids") List<Long> ids); + + //鏌ヨ杈呭姪宸ユ椂瀵煎嚭淇℃伅 + List<AuxiliaryWorkingHoursDayDto> selectDataByUser(@Param("ids") List<Long> ids); + + List<AuxiliaryWorkingHoursDay> selectListByIds(@Param("ids") List<Long> ids); + + //鏌ヨ璇ユ湀鐨勮緟鍔╁伐鏃� + List<Map<String, Object>> totalHours(@Param("month") String month, @Param("ids") List<Long> ids); + + List<AuxiliaryWorkingHoursDay> selectLists(@Param("ew") QueryWrapper<AuxiliaryWorkingHoursDay> ew, @Param("ids") List<Long> ids); + + /** + * 鏌ヨ杈呭姪宸ユ椂闆嗗悎 + * @param ew + * @param ids + * @return + */ + List<AuxiliaryWorkingHoursDayDto> selectAuxiliaryWorkingHoursDayList(@Param("ew") QueryWrapper<AuxiliaryWorkingHoursDayDto> ew, @Param("ids") List<Long> ids); +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/mapper/AuxiliaryWorkingHoursMapper.java b/performance-server/src/main/java/com/ruoyi/performance/mapper/AuxiliaryWorkingHoursMapper.java new file mode 100644 index 0000000..46f2c6a --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/mapper/AuxiliaryWorkingHoursMapper.java @@ -0,0 +1,19 @@ +package com.ruoyi.performance.mapper; + +import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.baomidou.mybatisplus.core.metadata.IPage; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.ruoyi.performance.pojo.AuxiliaryWorkingHours; + +/** + * <p> + * 杈呭姪宸ユ椂 Mapper 鎺ュ彛 + * </p> + * + * @author 姹熻嫃榈烽洀缃戠粶绉戞妧鏈夐檺鍏徃 + * @since 2024-05-09 06:58:31 + */ +public interface AuxiliaryWorkingHoursMapper extends BaseMapper<AuxiliaryWorkingHours> { + IPage<AuxiliaryWorkingHours> selectAuxiliaryWorkingHours(Page page, QueryWrapper<AuxiliaryWorkingHours> ew); +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/mapper/PerformanceShiftMapper.java b/performance-server/src/main/java/com/ruoyi/performance/mapper/PerformanceShiftMapper.java new file mode 100644 index 0000000..091ad29 --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/mapper/PerformanceShiftMapper.java @@ -0,0 +1,41 @@ +package com.ruoyi.performance.mapper; + +import com.baomidou.mybatisplus.core.metadata.IPage; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.ruoyi.framework.mybatis_config.MyBaseMapper; +import com.ruoyi.performance.dto.PerformanceShiftMapDto; +import com.ruoyi.performance.pojo.PerformanceShift; +import org.springframework.data.repository.query.Param; + +import java.util.List; +import java.util.Map; + +/** + * <p> + * 缁╂晥绠$悊-鐝 Mapper 鎺ュ彛 + * </p> + * + * @author 姹熻嫃榈烽洀缃戠粶绉戞妧鏈夐檺鍏徃 + * @since 2024-05-08 09:12:04 + */ +public interface PerformanceShiftMapper extends MyBaseMapper<PerformanceShift> { + + IPage<PerformanceShiftMapDto> performanceShiftPage( + Page<Object> page, + @Param("time") String time, + @Param("userName") String userName, + @Param("laboratory") String laboratory + ); + + List<Map<String, Object>> performanceShiftYearPage(@Param("time") String time, + @Param("userName") String userName, + @Param("laboratory") String laboratory); + + IPage<Map<String, Object>> performanceShiftYear(Page<Object> page, String time, String userName, String laboratory); + + List<Map<String, Object>> performanceShiftYearList(String time, String userName, String laboratory); + + List<PerformanceShiftMapDto> performanceShiftList(String time, String userName, String laboratory); + + String seldepLimsId(int depLimsId); +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/mapper/ShiftTimeMapper.java b/performance-server/src/main/java/com/ruoyi/performance/mapper/ShiftTimeMapper.java new file mode 100644 index 0000000..192e8ee --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/mapper/ShiftTimeMapper.java @@ -0,0 +1,16 @@ +package com.ruoyi.performance.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.ruoyi.performance.pojo.ShiftTime; + +/** + * <p> + * 鐝瀵瑰簲鐨勬椂闂� Mapper 鎺ュ彛 + * </p> + * + * @author 姹熻嫃榈烽洀缃戠粶绉戞妧鏈夐檺鍏徃 + * @since 2024-07-24 11:22:17 + */ +public interface ShiftTimeMapper extends BaseMapper<ShiftTime> { + +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/pojo/AuxiliaryCorrectionHours.java b/performance-server/src/main/java/com/ruoyi/performance/pojo/AuxiliaryCorrectionHours.java new file mode 100644 index 0000000..e786968 --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/pojo/AuxiliaryCorrectionHours.java @@ -0,0 +1,181 @@ +package com.ruoyi.performance.pojo; + +import com.alibaba.excel.annotation.ExcelProperty; +import com.baomidou.mybatisplus.annotation.*; +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.Getter; +import lombok.Setter; + +import java.io.Serializable; +import java.math.BigDecimal; +import java.time.LocalDateTime; + +/** + * <p> + * 宸ユ椂缁熻鐨勪慨姝e伐鏃� + * </p> + * + * @author 姹熻嫃榈烽洀缃戠粶绉戞妧鏈夐檺鍏徃 + * @since 2024-05-29 02:38:19 + */ +@Getter +@Setter +@TableName("auxiliary_correction_hours") +@ApiModel(value = "AuxiliaryCorrectionHours瀵硅薄", description = "宸ユ椂缁熻鐨勪慨姝e伐鏃�") +public class AuxiliaryCorrectionHours implements Serializable { + + @TableId(value = "id", type = IdType.AUTO) + private Integer id; + + @ApiModelProperty("濮撳悕id") + private Integer nameUser; + + @ApiModelProperty("绫诲瀷") + @ExcelProperty(value = "绫诲瀷") + private String type; + + @ApiModelProperty("1") + @ExcelProperty(value = "1鏃�") + private BigDecimal oneHours; + + @ApiModelProperty("2") + @ExcelProperty(value = "2鏃�") + private BigDecimal twoHours; + + @ApiModelProperty("3") + @ExcelProperty(value = "3鏃�") + private BigDecimal threeHours; + + @ApiModelProperty("4") + @ExcelProperty(value = "4鏃�") + private BigDecimal fourHours; + + @ApiModelProperty("5") + @ExcelProperty(value = "5鏃�") + private BigDecimal fiveHours; + + @ApiModelProperty("6") + @ExcelProperty(value = "6鏃�") + private BigDecimal sixHours; + + @ApiModelProperty("7") + @ExcelProperty(value = "7鏃�") + private BigDecimal sevenHours; + + @ApiModelProperty("8") + @ExcelProperty(value = "8鏃�") + private BigDecimal eightHours; + + @ApiModelProperty("9") + @ExcelProperty(value = "9鏃�") + private BigDecimal nineHours; + + @ApiModelProperty("10") + @ExcelProperty(value = "10鏃�") + private BigDecimal tenHours; + + @ApiModelProperty("11") + @ExcelProperty(value = "11鏃�") + private BigDecimal elevenHours; + + @ApiModelProperty("12") + @ExcelProperty(value = "12鏃�") + private BigDecimal twelveHours; + + @ApiModelProperty("13") + @ExcelProperty(value = "13鏃�") + private BigDecimal thirteenHours; + + @ApiModelProperty("14") + @ExcelProperty(value = "14鏃�") + private BigDecimal fourteenHours; + + @ApiModelProperty("15") + @ExcelProperty(value = "15鏃�") + private BigDecimal fifteenHours; + + @ApiModelProperty("16") + @ExcelProperty(value = "16鏃�") + private BigDecimal sixteenHours; + + @ApiModelProperty("17") + @ExcelProperty(value = "17鏃�") + private BigDecimal seventeenHours; + + @ApiModelProperty("18") + @ExcelProperty(value = "18鏃�") + private BigDecimal eighteenHours; + + @ApiModelProperty("19") + @ExcelProperty(value = "19鏃�") + private BigDecimal nineteenHours; + + @ApiModelProperty("20") + @ExcelProperty(value = "20鏃�") + private BigDecimal twentyHours; + + @ApiModelProperty("21") + @ExcelProperty(value = "21鏃�") + private BigDecimal twentyOneHours; + + @ApiModelProperty("22") + @ExcelProperty(value = "22鏃�") + private BigDecimal twentyTwoHours; + + @ApiModelProperty("23") + @ExcelProperty(value = "23鏃�") + private BigDecimal twentyThreeHours; + + @ApiModelProperty("24") + @ExcelProperty(value = "24鏃�") + private BigDecimal twentyFourHours; + + @ApiModelProperty("25") + @ExcelProperty(value = "25鏃�") + private BigDecimal twentyFiveHours; + + @ApiModelProperty("26") + @ExcelProperty(value = "26鏃�") + private BigDecimal twentySixHours; + + @ApiModelProperty("27") + @ExcelProperty(value = "27鏃�") + private BigDecimal twentySevenHours; + + @ApiModelProperty("28") + @ExcelProperty(value = "28鏃�") + private BigDecimal twentyEightHours; + + @ApiModelProperty("29") + @ExcelProperty(value = "29鏃�") + private BigDecimal twentyNineHours; + + @ApiModelProperty("30") + @ExcelProperty(value = "30鏃�") + private BigDecimal thirtyHours; + + @ApiModelProperty("31") + @ExcelProperty(value = "31鏃�") + private BigDecimal thirtyOneHours; + + @ApiModelProperty("鏈堜唤") + @ExcelProperty(value = "鏈堜唤") + private String month; + + @ApiModelProperty("鍒涘缓鏃堕棿") + @TableField(fill = FieldFill.INSERT) + private LocalDateTime createTime; + + @ApiModelProperty("淇敼鏃堕棿") + @TableField(fill = FieldFill.INSERT_UPDATE) + private LocalDateTime updateTime; + + @ApiModelProperty("鍒涘缓浜篿d") + @TableField(fill = FieldFill.INSERT) + private Integer createUser; + + @ApiModelProperty("淇敼浜篿d") + @TableField(fill = FieldFill.INSERT_UPDATE) + private Integer updateUser; +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/pojo/AuxiliaryOutputWorkingHours.java b/performance-server/src/main/java/com/ruoyi/performance/pojo/AuxiliaryOutputWorkingHours.java new file mode 100644 index 0000000..45fecbe --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/pojo/AuxiliaryOutputWorkingHours.java @@ -0,0 +1,123 @@ +package com.ruoyi.performance.pojo; + +import com.alibaba.excel.annotation.ExcelIgnoreUnannotated; +import com.alibaba.excel.annotation.ExcelProperty; +import com.baomidou.mybatisplus.annotation.*; +import com.fasterxml.jackson.annotation.JsonFormat; +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.Getter; +import lombok.Setter; + +import java.io.Serializable; +import java.math.BigDecimal; +import java.time.LocalDateTime; + +/** + * <p> + * 鏃ュ伐鏃剁鐞嗙殑浜ч噺宸ユ椂 + * </p> + * + * @author 姹熻嫃榈烽洀缃戠粶绉戞妧鏈夐檺鍏徃 + * @since 2024-05-28 03:48:48 + */ +@Getter +@Setter +@TableName("auxiliary_output_working_hours") +@ApiModel(value = "AuxiliaryOutputWorkingHours瀵硅薄", description = "鏃ュ伐鏃剁鐞嗙殑浜ч噺宸ユ椂") +@ExcelIgnoreUnannotated +public class AuxiliaryOutputWorkingHours implements Serializable { + + @TableId(value = "id", type = IdType.AUTO) + private Integer id; + + @ApiModelProperty("妫�娴嬮」鍒嗙被") + @ExcelProperty(index = 2, value = "妫�娴嬮」鍒嗙被") + private String inspectionItemClass; + + @ApiModelProperty("妫�娴嬮」") + @ExcelProperty(index = 3, value = "妫�娴嬮」") + private String inspectionItem; + + @ApiModelProperty("妫�娴嬪瓙椤�") + @ExcelProperty(index = 4, value = "妫�娴嬪瓙椤�") + private String inspectionItemSubclass; + + @ApiModelProperty("鏍峰搧id") + private Integer sampleId; + + @ApiModelProperty("鏍峰搧缂栧彿") + @ExcelProperty(index = 6, value = "鏍峰搧缂栧彿") + private String sample; + + @ApiModelProperty("鍔犵彮濮旀墭鍗曞彿") + private String overtimeOrderNo; + + @ApiModelProperty("鍔犵彮宸ユ椂") + private BigDecimal overtimeWorkTime; + + @ApiModelProperty("鍔犵彮鏁伴噺") + private Integer overtimeAmount; + + @ApiModelProperty("闈炲姞鐝鎵樺崟鍙�") + private Integer orderId; + + @ApiModelProperty("濮旀墭鍗曞彿") + @ExcelProperty(index = 5, value = "濮旀墭鍗曞彿") + private String orderNo; + + @ApiModelProperty("宸ユ椂") + private BigDecimal workTime; + + @ApiModelProperty("鏁伴噺") + private Integer amount; + + @ApiModelProperty("浜ч噺宸ユ椂") + @ExcelProperty(index = 7, value = "浜ч噺宸ユ椂") + private BigDecimal outputWorkTime; + + @ApiModelProperty("鏃ユ湡") + @ExcelProperty(index = 10, value = "鏃ユ湡") + private String dateTime; + + @ApiModelProperty("鍛ㄦ") + @ExcelProperty(index = 11, value = "鍛ㄦ") + private String week; + + @ApiModelProperty("鏄熸湡") + @ExcelProperty(index = 12, value = "鏄熸湡") + private String weekDay; + + @ApiModelProperty("妫�娴嬩汉id") + @TableField("`check`") + private Integer check; + + @ApiModelProperty("鍒涘缓鏃堕棿") + @TableField(fill = FieldFill.INSERT) + @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") + private LocalDateTime createTime; + + @ApiModelProperty("淇敼鏃堕棿") + @TableField(fill = FieldFill.INSERT_UPDATE) + @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") + private LocalDateTime updateTime; + + @ApiModelProperty("鍒涘缓浜篿d") + @TableField(fill = FieldFill.INSERT) + private Integer createUser; + + @ApiModelProperty("淇敼浜篿d") + @TableField(fill = FieldFill.INSERT_UPDATE) + private Integer updateUser; + + @ApiModelProperty("宸ユ椂鍒嗙粍") + @ExcelProperty(index = 8, value = "宸ユ椂鍒嗙粍") + private String manHourGroup; + + @ApiModelProperty("鍗曚环") + @ExcelProperty(index = 9, value = "鍗曚环") + private BigDecimal price; + + @ApiModelProperty("妫�楠岄」id") + private Integer insProductId; +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/pojo/AuxiliaryWorkingHours.java b/performance-server/src/main/java/com/ruoyi/performance/pojo/AuxiliaryWorkingHours.java new file mode 100644 index 0000000..8dd3516 --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/pojo/AuxiliaryWorkingHours.java @@ -0,0 +1,60 @@ +package com.ruoyi.performance.pojo; + +import com.baomidou.mybatisplus.annotation.*; +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.Getter; +import lombok.Setter; + +import java.io.Serializable; +import java.math.BigDecimal; +import java.time.LocalDateTime; + +/** + * <p> + * 杈呭姪宸ユ椂 + * </p> + * + * @author 姹熻嫃榈烽洀缃戠粶绉戞妧鏈夐檺鍏徃 + * @since 2024-05-09 06:58:31 + */ +@Getter +@Setter +@TableName("auxiliary_working_hours") +@ApiModel(value = "AuxiliaryWorkingHours瀵硅薄", description = "杈呭姪宸ユ椂") +public class AuxiliaryWorkingHours implements Serializable { + @ApiModelProperty("涓婚敭ID") + @TableId(type = IdType.AUTO) + private Integer id; + @ApiModelProperty("缂栧彿") + private String number; + @ApiModelProperty("杈呭姪椤圭洰鍚嶇О") + private String auxiliaryProject; + @ApiModelProperty("鏍稿噯宸ユ椂") + private BigDecimal approvedWorkingHour; + @ApiModelProperty("澶囨敞") + private String remarks; + + @ApiModelProperty("鍒涘缓浜篿d") + @TableField(fill = FieldFill.INSERT) + private Integer createUser; + + @ApiModelProperty("淇敼浜篿d") + @TableField(fill = FieldFill.INSERT_UPDATE) + private Integer updateUser; + + @ApiModelProperty("鍒涘缓鏃堕棿") + @TableField(fill = FieldFill.INSERT) + private LocalDateTime createTime; + + @ApiModelProperty("淇敼鏃堕棿") + @TableField(fill = FieldFill.INSERT_UPDATE) + private LocalDateTime updateTime; + + @ApiModelProperty("閮ㄩ棬") + private String department; + @ApiModelProperty("瀹為獙瀹�") + private String laboratory; + @ApiModelProperty("鍗曚綅") + private String unit; +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/pojo/AuxiliaryWorkingHoursDay.java b/performance-server/src/main/java/com/ruoyi/performance/pojo/AuxiliaryWorkingHoursDay.java new file mode 100644 index 0000000..a4fef6a --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/pojo/AuxiliaryWorkingHoursDay.java @@ -0,0 +1,113 @@ +package com.ruoyi.performance.pojo; + +import com.alibaba.excel.annotation.ExcelIgnoreUnannotated; +import com.alibaba.excel.annotation.ExcelProperty; +import com.baomidou.mybatisplus.annotation.*; +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +import java.io.Serializable; +import java.math.BigDecimal; +import java.time.LocalDateTime; + +/** + * <p> + * 鏃ュ伐鏃剁鐞嗙殑杈呭姪宸ユ椂 + * </p> + * + * @author 姹熻嫃榈烽洀缃戠粶绉戞妧鏈夐檺鍏徃 + * @since 2024-05-28 02:22:19 + */ +@Data +@TableName("auxiliary_working_hours_day") +@ApiModel(value = "AuxiliaryWorkingHoursDay瀵硅薄", description = "鏃ュ伐鏃剁鐞嗙殑杈呭姪宸ユ椂") +@ExcelIgnoreUnannotated +public class AuxiliaryWorkingHoursDay implements Serializable { + + @TableId(value = "id", type = IdType.AUTO) + private Integer id; + + @ApiModelProperty("濮撳悕id") + private Integer nameUser; + + @ApiModelProperty("缂栧彿") + @ExcelProperty(index = 2, value = "缂栧彿") + private String number; + + @ApiModelProperty("杈呭姪椤圭洰鍚嶇О") + @ExcelProperty(index = 3, value = "杈呭姪椤圭洰鍚嶇О") + private String auxiliaryProject; + + @ApiModelProperty("鏍稿噯宸ユ椂") + @ExcelProperty(index = 5, value = "鏍稿噯宸ユ椂") + private BigDecimal approvedWorkingHour; + + @ApiModelProperty("鏁伴噺") + @ExcelProperty(index = 6, value = "鏁伴噺") + private Integer amount; + + @ApiModelProperty("杈呭姪宸ユ椂") + @ExcelProperty(index = 7, value = "杈呭姪宸ユ椂") + private BigDecimal nonproductiveTime; + + @ApiModelProperty("杈呭姪璇存槑") + @ExcelProperty(index = 8, value = "杈呭姪璇存槑") + private String remarks; + + @ApiModelProperty("澶嶆牳浜�") + @ExcelProperty(index = 9, value = "澶嶆牳浜�") + private String reviewer; + + @ApiModelProperty("澶嶆牳鏁伴噺") + @ExcelProperty(index = 10, value = "澶嶆牳鏁伴噺") + private Integer reviewerNumber; + + @ApiModelProperty("澶嶆牳宸ユ椂") + @ExcelProperty(index = 11, value = "澶嶆牳宸ユ椂") + private BigDecimal reviewerNonproductiveTime; + + @ApiModelProperty("澶嶆牳璇存槑") + @ExcelProperty(index = 12, value = "澶嶆牳璇存槑") + private String reviewerRemark; + + @ApiModelProperty("骞�") + @ExcelProperty(index = 13, value = "骞�") + private String year; + + @ApiModelProperty("鐝") + @ExcelProperty(index = 14, value = "鐝") + private String shift; + + @ApiModelProperty("鍛ㄦ") + @ExcelProperty(index = 15, value = "鍛ㄦ") + private String week; + + @ApiModelProperty("鏄熸湡") + @ExcelProperty(index = 16, value = "鏄熸湡") + private String weekDay; + + @ApiModelProperty("鍒涘缓鏃堕棿") + @TableField(fill = FieldFill.INSERT) + private LocalDateTime createTime; + + @ApiModelProperty("淇敼鏃堕棿") + @TableField(fill = FieldFill.INSERT_UPDATE) + private LocalDateTime updateTime; + + @ApiModelProperty("鍒涘缓浜篿d") + @TableField(fill = FieldFill.INSERT) + private Integer createUser; + + @ApiModelProperty("淇敼浜篿d") + @TableField(fill = FieldFill.INSERT_UPDATE) + private Integer updateUser; + + @ApiModelProperty("鐘舵��") + @ExcelProperty(index = 4, value = "鐘舵��") + private String state; + + @ApiModelProperty("鏃ユ湡") + @ExcelProperty(index = 17, value = "鏃ユ湡") + private String dateTime; +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/pojo/PerformanceShift.java b/performance-server/src/main/java/com/ruoyi/performance/pojo/PerformanceShift.java new file mode 100644 index 0000000..bad6986 --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/pojo/PerformanceShift.java @@ -0,0 +1,54 @@ +package com.ruoyi.performance.pojo; + +import com.baomidou.mybatisplus.annotation.*; +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +import java.io.Serializable; +import java.time.LocalDateTime; + +/** + * <p> + * 缁╂晥绠$悊-鐝 + * </p> + * + * @author 姹熻嫃榈烽洀缃戠粶绉戞妧鏈夐檺鍏徃 + * @since 2024-05-08 09:12:04 + */ +@Data +@TableName("performance_shift") +@ApiModel(value = "PerformanceShift瀵硅薄", description = "缁╂晥绠$悊-鐝") +public class PerformanceShift implements Serializable { + + private static final long serialVersionUID = 1L; + + @ApiModelProperty("涓婚敭ID") + @TableId(type = IdType.AUTO) + private Integer id; + + @ApiModelProperty("鐝") + private String shift; + + @ApiModelProperty("鍛樺伐id") + private Integer userId; + + @ApiModelProperty("鎺掔彮鏃ユ湡") + private LocalDateTime workTime; + + @ApiModelProperty("鍒涘缓浜篒d") + @TableField(fill = FieldFill.INSERT) + private Integer createUser; + + @ApiModelProperty("鍒涘缓鏃ユ湡") + @TableField(fill = FieldFill.INSERT) + private LocalDateTime createTime; + + @ApiModelProperty("鏇存柊浜�") + @TableField(fill = FieldFill.INSERT_UPDATE) + private Integer updateUser; + + @ApiModelProperty("鏇存柊鏃堕棿") + @TableField(fill = FieldFill.INSERT_UPDATE) + private LocalDateTime updateTime; +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/pojo/ShiftTime.java b/performance-server/src/main/java/com/ruoyi/performance/pojo/ShiftTime.java new file mode 100644 index 0000000..ba7018e --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/pojo/ShiftTime.java @@ -0,0 +1,54 @@ +package com.ruoyi.performance.pojo; + +import com.baomidou.mybatisplus.annotation.*; +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.Getter; +import lombok.Setter; + +import java.io.Serializable; +import java.time.LocalDateTime; + +/** + * <p> + * 鐝瀵瑰簲鐨勬椂闂� + * </p> + * + * @author 姹熻嫃榈烽洀缃戠粶绉戞妧鏈夐檺鍏徃 + * @since 2024-07-24 11:22:17 + */ +@Getter +@Setter +@TableName("shift_time") +@ApiModel(value = "ShiftTime瀵硅薄", description = "鐝瀵瑰簲鐨勬椂闂�") +public class ShiftTime implements Serializable { + + @ApiModelProperty("涓婚敭ID") + @TableId(value = "id", type = IdType.AUTO) + private Integer id; + + @ApiModelProperty("鐝") + private String shift; + + @ApiModelProperty("寮�濮嬫椂闂�") + private String startTime; + + @ApiModelProperty("缁撴潫鏃堕棿") + private String endTime; + + @ApiModelProperty("鍒涘缓浜篒d") + @TableField(fill = FieldFill.INSERT) + private Integer createUser; + + @ApiModelProperty("鍒涘缓鏃ユ湡") + @TableField(fill = FieldFill.INSERT) + private LocalDateTime createTime; + + @ApiModelProperty("鏇存柊浜篒d") + @TableField(fill = FieldFill.INSERT_UPDATE) + private Integer updateUser; + + @ApiModelProperty("鏇存柊鏃堕棿") + @TableField(fill = FieldFill.INSERT_UPDATE) + private LocalDateTime updateTime; +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/service/AuxiliaryCorrectionHoursService.java b/performance-server/src/main/java/com/ruoyi/performance/service/AuxiliaryCorrectionHoursService.java new file mode 100644 index 0000000..36ae0c9 --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/service/AuxiliaryCorrectionHoursService.java @@ -0,0 +1,29 @@ +package com.ruoyi.performance.service; + +import com.baomidou.mybatisplus.core.metadata.IPage; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.baomidou.mybatisplus.extension.service.IService; +import com.ruoyi.performance.dto.AuxiliaryCorrectionHoursDto; +import com.ruoyi.performance.pojo.AuxiliaryCorrectionHours; + +import java.util.List; +import java.util.Map; + +/** + * <p> + * 宸ユ椂缁熻鐨勪慨姝e伐鏃� 鏈嶅姟绫� + * </p> + * + * @author 姹熻嫃榈烽洀缃戠粶绉戞妧鏈夐檺鍏徃 + * @since 2024-05-29 02:38:19 + */ +public interface AuxiliaryCorrectionHoursService extends IService<AuxiliaryCorrectionHours> { + + IPage<AuxiliaryCorrectionHoursDto> selectAuxiliaryCorrectionHours(Page page, AuxiliaryCorrectionHoursDto auxiliaryCorrectionHoursDto); + + /** + * 瀵煎叆涓婁紶 + * @param list + */ + void importExcel(List<AuxiliaryCorrectionHoursDto> list); +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/service/AuxiliaryOriginalHoursService.java b/performance-server/src/main/java/com/ruoyi/performance/service/AuxiliaryOriginalHoursService.java new file mode 100644 index 0000000..05dd08c --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/service/AuxiliaryOriginalHoursService.java @@ -0,0 +1,30 @@ +package com.ruoyi.performance.service; + +import com.baomidou.mybatisplus.core.metadata.IPage; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.ruoyi.performance.dto.AuxiliaryAllDto; +import com.ruoyi.performance.dto.AuxiliaryOriginalHoursDto; +import com.ruoyi.performance.dto.AuxiliaryOriginalHoursLookDto; + +import javax.servlet.http.HttpServletResponse; +import java.io.IOException; +import java.util.List; +import java.util.Map; + +public interface AuxiliaryOriginalHoursService { + + IPage<AuxiliaryOriginalHoursDto> selectAuxiliaryOriginalHours(Page page, AuxiliaryOriginalHoursLookDto auxiliaryOriginalHoursLookDto); + + /** + * 瀵煎嚭鍘熷宸ユ椂 + * + * @param response + */ + void exportWorkingHours(String month, String name, String departLims,HttpServletResponse response) throws IOException; + + /** + * 鏌ヨ鏈堜唤鍏ㄩ儴宸ユ椂 + * @return + */ + List<AuxiliaryAllDto> selectAuxiliaryAllByMonth(AuxiliaryOriginalHoursLookDto dto); +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/service/AuxiliaryOutputWorkingHoursService.java b/performance-server/src/main/java/com/ruoyi/performance/service/AuxiliaryOutputWorkingHoursService.java new file mode 100644 index 0000000..c3f4818 --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/service/AuxiliaryOutputWorkingHoursService.java @@ -0,0 +1,44 @@ +package com.ruoyi.performance.service; + +import com.baomidou.mybatisplus.core.metadata.IPage; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.baomidou.mybatisplus.extension.service.IService; +import com.ruoyi.performance.dto.AuxiliaryOutputWorkingHoursDto; +import com.ruoyi.performance.pojo.AuxiliaryOutputWorkingHours; + +import javax.servlet.http.HttpServletResponse; +import java.io.IOException; +import java.util.Map; + +/** + * <p> + * 鏃ュ伐鏃剁鐞嗙殑浜ч噺宸ユ椂 鏈嶅姟绫� + * </p> + * + * @author 姹熻嫃榈烽洀缃戠粶绉戞妧鏈夐檺鍏徃 + * @since 2024-05-28 03:48:48 + */ +public interface AuxiliaryOutputWorkingHoursService extends IService<AuxiliaryOutputWorkingHours> { + + IPage<AuxiliaryOutputWorkingHoursDto> selectAuxiliaryOutputWorkingHours(Page page, AuxiliaryOutputWorkingHoursDto auxiliaryOutputWorkingHoursDto); + + /** + * 缁熻浜ч噺宸ユ椂姹囨�诲拰杈呭姪宸ユ椂姹囨�� + * @return + */ + Map<String,Object> collectWorkingHours(AuxiliaryOutputWorkingHoursDto auxiliaryOutputWorkingHoursDto); + + /** + * 瀵煎嚭 + * @param response + * @throws IOException + */ + void exportWorkingHours(HttpServletResponse response)throws IOException; + + /** + * 瀵煎嚭浜ч噺宸ユ椂 + * @param entity + * @param response + */ + void exportOutputHours(AuxiliaryOutputWorkingHoursDto entity, HttpServletResponse response); +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/service/AuxiliaryWorkingHoursDayService.java b/performance-server/src/main/java/com/ruoyi/performance/service/AuxiliaryWorkingHoursDayService.java new file mode 100644 index 0000000..5c04cff --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/service/AuxiliaryWorkingHoursDayService.java @@ -0,0 +1,44 @@ +package com.ruoyi.performance.service; + +import com.baomidou.mybatisplus.core.metadata.IPage; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.baomidou.mybatisplus.extension.service.IService; +import com.ruoyi.performance.dto.AuxiliaryWorkingHoursDayDto; +import com.ruoyi.performance.dto.HoursDay; +import com.ruoyi.performance.pojo.AuxiliaryWorkingHoursDay; + +import javax.servlet.http.HttpServletResponse; +import java.time.LocalDateTime; +import java.util.Map; + +/** + * <p> + * 鏃ュ伐鏃剁鐞嗙殑杈呭姪宸ユ椂 鏈嶅姟绫� + * </p> + * + * @author 姹熻嫃榈烽洀缃戠粶绉戞妧鏈夐檺鍏徃 + * @since 2024-05-28 02:22:19 + */ +public interface AuxiliaryWorkingHoursDayService extends IService<AuxiliaryWorkingHoursDay> { + + IPage<AuxiliaryWorkingHoursDayDto> selectAuxiliaryWorkingHoursDay(Page page, AuxiliaryWorkingHoursDayDto auxiliaryWorkingHoursDayDto); + + int insertAuxiliaryWorkingHoursDay(AuxiliaryWorkingHoursDay auxiliaryWorkingHoursDay); + + AuxiliaryWorkingHoursDay selectAuxiliaryWorkingHoursByNumber(String number); + + boolean checkOrApprove(HoursDay hoursDay); + + int updateAuxiliaryWorkingHoursDay(AuxiliaryWorkingHoursDay auxiliaryWorkingHoursDay); + + int deleteAuxiliaryWorkingHoursDay(Integer id); + + String selectshiftByUser(LocalDateTime dateTime); + + /** + * 瀵煎嚭杈呭姪宸ユ椂 + * @param entity + * @param response + */ + void exportWorkingHours(AuxiliaryWorkingHoursDayDto entity, HttpServletResponse response); +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/service/AuxiliaryWorkingHoursService.java b/performance-server/src/main/java/com/ruoyi/performance/service/AuxiliaryWorkingHoursService.java new file mode 100644 index 0000000..d8a6000 --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/service/AuxiliaryWorkingHoursService.java @@ -0,0 +1,26 @@ +package com.ruoyi.performance.service; + +import com.baomidou.mybatisplus.core.metadata.IPage; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.baomidou.mybatisplus.extension.service.IService; +import com.ruoyi.performance.pojo.AuxiliaryWorkingHours; + +import java.util.Map; + +/** + * <p> + * 杈呭姪宸ユ椂 鏈嶅姟绫� + * </p> + * + * @author 姹熻嫃榈烽洀缃戠粶绉戞妧鏈夐檺鍏徃 + * @since 2024-05-09 06:58:31 + */ +public interface AuxiliaryWorkingHoursService extends IService<AuxiliaryWorkingHours> { + IPage<AuxiliaryWorkingHours> selectAuxiliaryWorkingHours(Page page, AuxiliaryWorkingHours auxiliaryWorkingHours); + + int deleteAuxiliaryWorkingHours(Integer id); + + int upAuxiliaryWorkingHours(AuxiliaryWorkingHours auxiliaryWorkingHours); + + int insertAuxiliaryWorkingHours(AuxiliaryWorkingHours auxiliaryWorkingHours); +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/service/PerformanceShiftService.java b/performance-server/src/main/java/com/ruoyi/performance/service/PerformanceShiftService.java new file mode 100644 index 0000000..dce8d3a --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/service/PerformanceShiftService.java @@ -0,0 +1,32 @@ +package com.ruoyi.performance.service; + +import com.baomidou.mybatisplus.core.metadata.IPage; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.baomidou.mybatisplus.extension.service.IService; +import com.ruoyi.performance.dto.PerformanceShiftAddDto; +import com.ruoyi.performance.pojo.PerformanceShift; + +import java.util.Map; + +/** + * <p> + * 缁╂晥绠$悊-鐝 鏈嶅姟绫� + * </p> + * + * @author 姹熻嫃榈烽洀缃戠粶绉戞妧鏈夐檺鍏徃 + * @since 2024-05-08 09:12:04 + */ +public interface PerformanceShiftService extends IService<PerformanceShift> { + + void performanceShiftAdd(PerformanceShiftAddDto performanceShiftAddDto); + + Map<String, Object> performanceShiftPage(Page<Object> page, String time, String userName, String laboratory); + + void performanceShiftUpdate(PerformanceShift performanceShift); + + IPage<Map<String, Object>> performanceShiftPageYear(Page<Object> page, String time, String userName, String laboratory); + + Map<Object, Object> exportToYearExcel(String time, String userName, String laboratory) throws Exception; + + Map<Object, Object> exportToMonthExcel(String time, String userName, String laboratory); +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/service/ShiftTimeService.java b/performance-server/src/main/java/com/ruoyi/performance/service/ShiftTimeService.java new file mode 100644 index 0000000..617a20c --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/service/ShiftTimeService.java @@ -0,0 +1,22 @@ +package com.ruoyi.performance.service; + +import com.baomidou.mybatisplus.extension.service.IService; +import com.ruoyi.performance.pojo.ShiftTime; + +import java.util.List; + +/** + * <p> + * 鐝瀵瑰簲鐨勬椂闂� 鏈嶅姟绫� + * </p> + * + * @author 姹熻嫃榈烽洀缃戠粶绉戞妧鏈夐檺鍏徃 + * @since 2024-07-24 11:22:17 + */ +public interface ShiftTimeService extends IService<ShiftTime> { + + void shiftTimeAdd(ShiftTime shiftTime); + + List<ShiftTime> shiftTimeList(); + +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/service/impl/AuxiliaryCorrectionHoursServiceImpl.java b/performance-server/src/main/java/com/ruoyi/performance/service/impl/AuxiliaryCorrectionHoursServiceImpl.java new file mode 100644 index 0000000..3cc5139 --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/service/impl/AuxiliaryCorrectionHoursServiceImpl.java @@ -0,0 +1,104 @@ +package com.ruoyi.performance.service.impl; + +import cn.hutool.core.collection.CollectionUtil; +import com.baomidou.mybatisplus.core.metadata.IPage; +import com.baomidou.mybatisplus.core.toolkit.ObjectUtils; +import com.baomidou.mybatisplus.core.toolkit.Wrappers; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; +import com.ruoyi.common.core.domain.entity.User; +import com.ruoyi.common.utils.QueryWrappers; +import com.ruoyi.performance.dto.AuxiliaryCorrectionHoursDto; +import com.ruoyi.performance.mapper.AuxiliaryCorrectionHoursMapper; +import com.ruoyi.performance.pojo.AuxiliaryCorrectionHours; +import com.ruoyi.performance.service.AuxiliaryCorrectionHoursService; +import com.ruoyi.system.mapper.UserMapper; +import org.apache.commons.math3.analysis.function.Power; +import org.springframework.beans.BeanUtils; +import org.springframework.stereotype.Service; + +import javax.annotation.Resource; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.regex.Pattern; +import java.util.stream.Collectors; + +/** + * <p> + * 宸ユ椂缁熻鐨勪慨姝e伐鏃� 鏈嶅姟瀹炵幇绫� + * </p> + * + * @author 姹熻嫃榈烽洀缃戠粶绉戞妧鏈夐檺鍏徃 + * @since 2024-05-29 02:38:19 + */ +@Service +public class AuxiliaryCorrectionHoursServiceImpl extends ServiceImpl<AuxiliaryCorrectionHoursMapper, AuxiliaryCorrectionHours> implements AuxiliaryCorrectionHoursService { + + @Resource + AuxiliaryCorrectionHoursMapper auxiliaryCorrectionHoursMapper; + + @Resource + UserMapper userMapper; + + + @Override + public IPage<AuxiliaryCorrectionHoursDto> selectAuxiliaryCorrectionHours(Page page, AuxiliaryCorrectionHoursDto auxiliaryCorrectionHoursDto) { + List<Long> ids = new ArrayList<>(); + String departLims = auxiliaryCorrectionHoursDto.getDepartLims(); + auxiliaryCorrectionHoursDto.setDepartLims(null); + if (ObjectUtils.isNotEmpty(departLims)) { + //鍏堟ā绯婃煡璇㈠嚭鏉d + List<Integer> ides = auxiliaryCorrectionHoursMapper.selDepartLimsByName(departLims); + for (Integer ide : ides) { + List<User> users = userMapper.selectList(Wrappers.<User>lambdaQuery() + .like(User::getDepartLimsId, ide)); + if (ObjectUtils.isNotEmpty(users)) { + ids.clear(); + ids.addAll(users.stream().map(User::getId).distinct().collect(Collectors.toList())); + } + } + } + if (ids.size() == 0) { + ids = null; + } + return auxiliaryCorrectionHoursMapper.selectAuxiliaryCorrectionHours(page, QueryWrappers.queryWrappers(auxiliaryCorrectionHoursDto).eq("month", auxiliaryCorrectionHoursDto.getMonth()), ids); + } + + //瀵煎叆涓婁紶 + @Override + public void importExcel(List<AuxiliaryCorrectionHoursDto> list) { + if (CollectionUtil.isEmpty(list)) { + return; + } + List<AuxiliaryCorrectionHours> auxiliaryCorrectionHoursList = new ArrayList<>(); + List<AuxiliaryCorrectionHours> auxiliaryCorrectionHoursList1 = new ArrayList<>(); + for (AuxiliaryCorrectionHoursDto auxiliaryCorrectionHoursDto : list) { + AuxiliaryCorrectionHours auxiliaryCorrectionHours = new AuxiliaryCorrectionHours(); + User user = userMapper.selectOne(Wrappers.<User>lambdaQuery().eq(User::getName, auxiliaryCorrectionHoursDto.getName())); + if (ObjectUtils.isEmpty(user)) { + throw new RuntimeException("绯荤粺娌℃湁鏌ュ埌" + auxiliaryCorrectionHoursDto.getName() + "杩欎釜鐢ㄦ埛淇℃伅!"); + } + String regex = "\\d{4}-\\d{2}"; + if (!Pattern.matches(regex, auxiliaryCorrectionHoursDto.getMonth())) { + throw new RuntimeException(auxiliaryCorrectionHoursDto.getMonth() + "鏍煎紡涓嶆纭�,鏈堜唤鏍煎紡搴斾负yyyy-MM"); + } + BeanUtils.copyProperties(auxiliaryCorrectionHoursDto, auxiliaryCorrectionHours); + auxiliaryCorrectionHours.setNameUser(user.getId().intValue()); + AuxiliaryCorrectionHours auxiliaryCorrectionHours1 = auxiliaryCorrectionHoursMapper.selectOne(Wrappers.<AuxiliaryCorrectionHours>lambdaQuery() + .eq(AuxiliaryCorrectionHours::getNameUser, user.getId()) + .eq(AuxiliaryCorrectionHours::getType, auxiliaryCorrectionHours.getType()) + .eq(AuxiliaryCorrectionHours::getMonth, auxiliaryCorrectionHours.getMonth())); + if (ObjectUtils.isNotEmpty(auxiliaryCorrectionHours1)) { + auxiliaryCorrectionHoursList1.add(auxiliaryCorrectionHours); + } else { + auxiliaryCorrectionHoursList.add(auxiliaryCorrectionHours); + } + } + //鎵归噺鏂板 + saveBatch(auxiliaryCorrectionHoursList); + //鎵归噺淇敼 + updateBatchById(auxiliaryCorrectionHoursList1); + } +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/service/impl/AuxiliaryOriginalHoursServiceImpl.java b/performance-server/src/main/java/com/ruoyi/performance/service/impl/AuxiliaryOriginalHoursServiceImpl.java new file mode 100644 index 0000000..490b042 --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/service/impl/AuxiliaryOriginalHoursServiceImpl.java @@ -0,0 +1,635 @@ +package com.ruoyi.performance.service.impl; + +import com.alibaba.excel.EasyExcel; +import com.alibaba.excel.ExcelWriter; +import com.alibaba.excel.write.metadata.WriteSheet; +import com.alibaba.excel.write.style.column.LongestMatchColumnWidthStyleStrategy; +import com.baomidou.mybatisplus.core.metadata.IPage; +import com.baomidou.mybatisplus.core.toolkit.CollectionUtils; +import com.baomidou.mybatisplus.core.toolkit.ObjectUtils; +import com.baomidou.mybatisplus.core.toolkit.StringUtils; +import com.baomidou.mybatisplus.core.toolkit.Wrappers; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.ruoyi.common.core.domain.entity.User; +import com.ruoyi.common.exception.base.BaseException; +import com.ruoyi.performance.dto.AuxiliaryAllDto; +import com.ruoyi.performance.dto.AuxiliaryCorrectionHoursDto; +import com.ruoyi.performance.dto.AuxiliaryOriginalHoursDto; +import com.ruoyi.performance.dto.AuxiliaryOriginalHoursLookDto; +import com.ruoyi.performance.mapper.AuxiliaryCorrectionHoursMapper; +import com.ruoyi.performance.mapper.AuxiliaryOriginalHoursMapper; +import com.ruoyi.performance.mapper.AuxiliaryOutputWorkingHoursMapper; +import com.ruoyi.performance.mapper.AuxiliaryWorkingHoursDayMapper; +import com.ruoyi.performance.pojo.AuxiliaryCorrectionHours; +import com.ruoyi.performance.service.AuxiliaryOriginalHoursService; +import com.ruoyi.system.mapper.UserMapper; +import org.apache.commons.math3.analysis.function.Power; +import org.springframework.beans.BeanUtils; +import org.springframework.stereotype.Service; + +import javax.annotation.Resource; +import javax.servlet.http.HttpServletResponse; +import java.io.IOException; +import java.math.BigDecimal; +import java.math.RoundingMode; +import java.net.URLEncoder; +import java.time.LocalDate; +import java.time.format.DateTimeFormatter; +import java.util.*; +import java.util.stream.Collectors; + +@Service +public class AuxiliaryOriginalHoursServiceImpl implements AuxiliaryOriginalHoursService { + + @Resource + UserMapper userMapper; + + @Resource + AuxiliaryOriginalHoursMapper auxiliaryOriginalHoursMapper; + + @Resource + AuxiliaryOutputWorkingHoursMapper auxiliaryOutputWorkingHoursMapper; + + @Resource + AuxiliaryWorkingHoursDayMapper auxiliaryWorkingHoursDayMapper; + + @Resource + AuxiliaryCorrectionHoursMapper auxiliaryCorrectionHoursMapper; + + @Override + public IPage<AuxiliaryOriginalHoursDto> selectAuxiliaryOriginalHours(Page page, AuxiliaryOriginalHoursLookDto auxiliaryOriginalHoursLookDto) { + List<Long> ids = new ArrayList<>(); + String departLims = auxiliaryOriginalHoursLookDto.getDepartLims(); + auxiliaryOriginalHoursLookDto.setDepartLims(null); + String name = auxiliaryOriginalHoursLookDto.getName(); + auxiliaryOriginalHoursLookDto.setName(null); + if (ObjectUtils.isNotEmpty(departLims)) { + //鍏堟ā绯婃煡璇㈠嚭鏉d + List<Integer> ides = auxiliaryCorrectionHoursMapper.selDepartLimsByName(departLims); + for (Integer ide : ides) { + List<User> users = userMapper.selectList(Wrappers.<User>lambdaQuery() + .like(User::getDepartLimsId, ide)); + if (ObjectUtils.isNotEmpty(users)) { + ides.clear(); + ids.addAll(users.stream().map(User::getId).distinct().collect(Collectors.toList())); + } + } + } + if (ObjectUtils.isNotEmpty(name)) { + ids.clear(); + ids.add(userMapper.selectOne(Wrappers.<User>lambdaQuery().like(User::getName, name)).getId()); + } + if (ids.size() == 0) { + ids = null; + } + IPage<AuxiliaryOriginalHoursDto> originalHoursDtoIPage = new Page<>(); + originalHoursDtoIPage.setSize(page.getSize()); + originalHoursDtoIPage.setCurrent(page.getCurrent()); + List<AuxiliaryOriginalHoursDto> auxiliaryOriginalHoursDtos = new ArrayList<>(); + Map<String, AuxiliaryOriginalHoursDto> data1 = new HashMap<>(); + Map<String, AuxiliaryOriginalHoursDto> data2 = new HashMap<>(); + Map<String, AuxiliaryOriginalHoursDto> data3 = new HashMap<>(); + //浜ч噺宸ユ椂 + List<Map<String, Object>> maps = auxiliaryOutputWorkingHoursMapper.totalHours(auxiliaryOriginalHoursLookDto.getMonth(), ids, "浜ч噺宸ユ椂"); + if (ObjectUtils.isNotEmpty(maps)) { + data1 = getData(maps, "浜ч噺宸ユ椂"); + auxiliaryOriginalHoursDtos.addAll(data1.values()); + } + //杈呭姪宸ユ椂 + List<Map<String, Object>> maps1 = auxiliaryWorkingHoursDayMapper.totalHours(auxiliaryOriginalHoursLookDto.getMonth(), ids); + if (ObjectUtils.isNotEmpty(maps1)) { + data2 = getData(maps1, "杈呭姪宸ユ椂"); + auxiliaryOriginalHoursDtos.addAll(data2.values()); + } + //鍔犵彮宸ユ椂 + List<Map<String, Object>> maps2 = auxiliaryOutputWorkingHoursMapper.totalHours(auxiliaryOriginalHoursLookDto.getMonth(), ids, "鍔犵彮宸ユ椂"); + if (ObjectUtils.isNotEmpty(maps2)) { + data3 = getData(maps2, "鍔犵彮宸ユ椂"); + auxiliaryOriginalHoursDtos.addAll(data3.values()); + } + //鎬诲伐鏃�=浜ч噺宸ユ椂+杈呭姪宸ユ椂+鍔犵彮宸ユ椂 + Map<String, AuxiliaryOriginalHoursDto> data4 = new HashMap<String, AuxiliaryOriginalHoursDto>(); + if (data1.size() > 0) { + Map<String, AuxiliaryOriginalHoursDto> data5 = data1; + if (data2.size() > 0) { + merge(data5, data4, data2); + } + if (data3.size() > 0) { +// merge(data5,data4,data3); + } + if (data2.size() == 0 && data3.size() == 0) { + for (Map.Entry<String, AuxiliaryOriginalHoursDto> entry : data5.entrySet()) { + AuxiliaryOriginalHoursDto dto = entry.getValue(); + AuxiliaryOriginalHoursDto originalHoursDto = new AuxiliaryOriginalHoursDto(); + BeanUtils.copyProperties(dto, originalHoursDto); + originalHoursDto.setType("鎬诲伐鏃�"); + data4.put(entry.getKey(), originalHoursDto); + } + } + auxiliaryOriginalHoursDtos.addAll(data4.values()); + } + + auxiliaryOriginalHoursDtos = auxiliaryOriginalHoursDtos.stream().sorted(Comparator.comparing(AuxiliaryOriginalHoursDto::getName)).collect(Collectors.toList()); + // 妫�鏌ユ瘡涓汉鐨勫伐鏃剁被鍨嬶紝琛ュ叏缂哄皯鐨勫伐鏃� + Map<String, Set<String>> workHoursMap = new HashMap<>(); + String[] requiredHours = {"浜ч噺宸ユ椂", "杈呭姪宸ユ椂", "鍔犵彮宸ユ椂", "鎬诲伐鏃�"}; + for (AuxiliaryOriginalHoursDto dto : auxiliaryOriginalHoursDtos) { + workHoursMap.computeIfAbsent(dto.getName(), k -> new HashSet<>()).add(dto.getType()); + } + List<AuxiliaryOriginalHoursDto> result = auxiliaryOriginalHoursDtos; + for (String name1 : workHoursMap.keySet()) { + Set<String> workTypes = workHoursMap.get(name1); + for (String requiredHour : requiredHours) { + if (!workTypes.contains(requiredHour)) { + AuxiliaryOriginalHoursDto auxiliaryOriginalHoursDto = new AuxiliaryOriginalHoursDto(); + auxiliaryOriginalHoursDto.setName(name1); + auxiliaryOriginalHoursDto.setAuxiliaryCorrectionHours(null); + auxiliaryOriginalHoursDto.setType(requiredHour); + auxiliaryOriginalHoursDto.setMonth(auxiliaryOriginalHoursLookDto.getMonth()); + result.add(auxiliaryOriginalHoursDto); + } + } + } + List<String> order = Arrays.asList("浜ч噺宸ユ椂", "杈呭姪宸ユ椂", "鍔犵彮宸ユ椂", "鎬诲伐鏃�"); + Comparator<AuxiliaryOriginalHoursDto> comparator = Comparator.comparingInt(dto -> { + String type = dto.getType(); + return order.indexOf(type) == -1 ? order.size() : order.indexOf(type); + }); + result = result.stream().sorted(Comparator.comparing(AuxiliaryOriginalHoursDto::getName).thenComparing(comparator)).collect(Collectors.toList()); + originalHoursDtoIPage.setRecords(result); + originalHoursDtoIPage.setTotal(result.size()); + return originalHoursDtoIPage; + } + + + //瀵煎嚭鍘熷宸ユ椂 + @Override + public void exportWorkingHours(String month, String name, String departLims, HttpServletResponse response) throws IOException { + List<AuxiliaryOriginalHoursDto> auxiliaryOriginalHoursDtos = new ArrayList<AuxiliaryOriginalHoursDto>(); + //鏌ヨ鍘熷宸ユ椂(浣跨敤鍒嗛〉鏌ヨ) + AuxiliaryOriginalHoursLookDto auxiliaryOriginalHoursLookDto = new AuxiliaryOriginalHoursLookDto(); + if (ObjectUtils.isNotEmpty(month)) { + auxiliaryOriginalHoursLookDto.setMonth(month); + } + if (ObjectUtils.isNotEmpty(name)) { + auxiliaryOriginalHoursLookDto.setName(name); + } + if (ObjectUtils.isNotEmpty(departLims)) { + auxiliaryOriginalHoursLookDto.setDepartLims(departLims); + } + IPage<AuxiliaryOriginalHoursDto> body = selectAuxiliaryOriginalHours(new Page(-1, -1), auxiliaryOriginalHoursLookDto); + auxiliaryOriginalHoursDtos = body.getRecords(); + response.setContentType("application/vnd.ms-excel"); + response.setCharacterEncoding("UTF-8"); + // 杩欓噷URLEncoder.encode鍙互闃叉涓枃涔辩爜 褰撶劧鍜宔asyexcel娌℃湁鍏崇郴 + String fileName = URLEncoder.encode("宸ユ椂缁熻瀵煎嚭", "UTF-8"); + response.setHeader("Content-disposition", "attachment;filename=" + fileName + ".xlsx"); + try { + // 鏂板缓ExcelWriter + ExcelWriter excelWriter = EasyExcel.write(response.getOutputStream()).registerWriteHandler(new LongestMatchColumnWidthStyleStrategy()).build(); + WriteSheet mainSheet = EasyExcel.writerSheet(0, "鍘熷宸ユ椂瀵煎嚭").head(AuxiliaryOriginalHoursDto.class).build(); + excelWriter.write(auxiliaryOriginalHoursDtos, mainSheet); + // 鍏抽棴娴� + excelWriter.finish(); + } catch (IOException e) { + throw new RuntimeException("瀵煎嚭澶辫触"); + } + + } + + /** + * 鏌ヨ鏈堜唤鍏ㄩ儴宸ユ椂 + * + * @return + */ + @Override + public List<AuxiliaryAllDto> selectAuxiliaryAllByMonth(AuxiliaryOriginalHoursLookDto dto) { + if (StringUtils.isBlank(dto.getMonth())) { + throw new BaseException("缂哄皯鏈堜唤"); + } + List<Long> userIds = new ArrayList<>(); + + String name = dto.getName(); + if (ObjectUtils.isNotEmpty(name)) { + userIds.addAll(userMapper.selectList(Wrappers.<User>lambdaQuery().like(User::getName, name)).stream().map(User::getId).collect(Collectors.toList())); + } + // 瑙f瀽杈撳叆鐨勬椂闂村瓧绗︿覆 + LocalDate date = LocalDate.parse(dto.getMonth() + "-01", DateTimeFormatter.ofPattern("yyyy-MM-dd")); + + // 鑾峰彇鍓嶄竴涓湀鐨�26鍙� + LocalDate previousMonth26th = date.minusMonths(1).withDayOfMonth(26); + + // 鑾峰彇褰撳墠鏈堢殑25鍙� + LocalDate currentMonth25th = date.withDayOfMonth(25); + + // 鏍煎紡鍖栨棩鏈熶负 yyyy-MM-dd HH:mm:ss + DateTimeFormatter outputFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd"); + String beginDate = previousMonth26th.atStartOfDay().format(outputFormatter); + String endDate = currentMonth25th.atStartOfDay().format(outputFormatter); +// dto.setBeginDate(beginDate + " 00:00:00"); +// dto.setEndDate(endDate + " 23:59:59"); + dto.setBeginDate(beginDate); + dto.setEndDate(endDate); + + + // 鏌ヨ浜ч噺宸ユ椂 + List<AuxiliaryAllDto> auxiliaryAllDtos = auxiliaryOutputWorkingHoursMapper.selectAuxiliaryAllByMonth(dto, userIds); + + // 鏌ヨ杈呭姪宸ユ椂 + List<AuxiliaryAllDto> auxiliarySubsidiary = auxiliaryOutputWorkingHoursMapper.selectSubsidiaryAllByMonth(dto, userIds); + + //浜ч噺宸ユ椂杩涜浜哄憳鍒嗙粍, 鎶婅緟鍔╁伐鏃舵坊鍔� + Map<Integer, List<AuxiliaryAllDto>> groupIds = auxiliaryAllDtos.stream().collect(Collectors.groupingBy(AuxiliaryAllDto::getUserId)); + + for (AuxiliaryAllDto auxiliaryAllDto : auxiliarySubsidiary) { + List<AuxiliaryAllDto> allDtos = groupIds.get(auxiliaryAllDto.getUserId()); + // 鍒ゆ柇鏄惁涓虹┖ + if (CollectionUtils.isNotEmpty(allDtos)) { + // 娣诲姞杈呭姪宸ユ椂 + allDtos.get(0).setSubsidiaryHour(auxiliaryAllDto.getSubsidiaryHour()); + + } else { + // 娌℃湁鏀逛汉鍛樻坊鍔犱竴琛� + auxiliaryAllDtos.add(auxiliaryAllDto); + } + } + for (AuxiliaryAllDto auxiliaryAllDto : auxiliaryAllDtos) { + BigDecimal total = (auxiliaryAllDto.getYieldHour() != null ? auxiliaryAllDto.getYieldHour() : BigDecimal.ZERO) + .add(auxiliaryAllDto.getSubsidiaryHour() != null ? auxiliaryAllDto.getSubsidiaryHour() : BigDecimal.ZERO); + auxiliaryAllDto.setTotalHour(total); + } + + return auxiliaryAllDtos; + } + + private Map<String, AuxiliaryOriginalHoursDto> getData(List<Map<String, Object>> objectMaps, String type) { + Map<String, AuxiliaryOriginalHoursDto> dtoMap = new HashMap<>(); + for (Map<String, Object> objectMap : objectMaps) { + String name = objectMap.get("name").toString(); + String month = objectMap.get("month").toString().substring(0, 7); + AuxiliaryOriginalHoursDto auxiliaryOriginalHoursDto = dtoMap.get(name); + if (auxiliaryOriginalHoursDto == null) { + auxiliaryOriginalHoursDto = new AuxiliaryOriginalHoursDto(); + auxiliaryOriginalHoursDto.setName(name); + auxiliaryOriginalHoursDto.setType(type); + auxiliaryOriginalHoursDto.setMonth(month); + // 鏌ヨ杩欎釜浜鸿繖涓湀鏄惁鏈変慨姝g殑浜ч噺宸ユ椂 + AuxiliaryCorrectionHours auxiliaryCorrectionHours = auxiliaryCorrectionHoursMapper.selectOne(Wrappers.<AuxiliaryCorrectionHours>lambdaQuery() + .eq(AuxiliaryCorrectionHours::getNameUser, userMapper.selectOne(Wrappers.<User>lambdaQuery().eq(User::getName, auxiliaryOriginalHoursDto.getName())).getId()) + .eq(AuxiliaryCorrectionHours::getType, auxiliaryOriginalHoursDto.getType()) + .eq(AuxiliaryCorrectionHours::getMonth, auxiliaryOriginalHoursDto.getMonth())); + auxiliaryOriginalHoursDto.setAuxiliaryCorrectionHours(auxiliaryCorrectionHours); + } + AuxiliaryCorrectionHours auxiliaryCorrectionHours = auxiliaryOriginalHoursDto.getAuxiliaryCorrectionHours(); + switch (objectMap.get("month").toString().substring(8, 10)) { + case "01": + auxiliaryOriginalHoursDto.setOneHours(new BigDecimal(objectMap.get("manHours").toString())); + if (ObjectUtils.isNotEmpty(auxiliaryCorrectionHours)) { + if (auxiliaryCorrectionHours.getOneHours().compareTo(auxiliaryOriginalHoursDto.getOneHours()) != 0) { + auxiliaryOriginalHoursDto.setOne(1); + } + } + break; + case "02": + auxiliaryOriginalHoursDto.setTwoHours(new BigDecimal(objectMap.get("manHours").toString())); + if (ObjectUtils.isNotEmpty(auxiliaryCorrectionHours)) { + if (auxiliaryCorrectionHours.getTwoHours().compareTo(auxiliaryOriginalHoursDto.getTwoHours()) != 0) { + auxiliaryOriginalHoursDto.setTwo(1); + } + } + break; + case "03": + auxiliaryOriginalHoursDto.setThreeHours(new BigDecimal(objectMap.get("manHours").toString())); + if (ObjectUtils.isNotEmpty(auxiliaryCorrectionHours)) { + if (auxiliaryCorrectionHours.getThreeHours().compareTo(auxiliaryOriginalHoursDto.getThreeHours()) != 0) { + auxiliaryOriginalHoursDto.setThree(1); + } + } + break; + case "04": + auxiliaryOriginalHoursDto.setFourHours(new BigDecimal(objectMap.get("manHours").toString())); + if (ObjectUtils.isNotEmpty(auxiliaryCorrectionHours)) { + if (auxiliaryCorrectionHours.getFourHours().compareTo(auxiliaryOriginalHoursDto.getFourHours()) != 0) { + auxiliaryOriginalHoursDto.setFour(1); + } + } + break; + case "05": + auxiliaryOriginalHoursDto.setFiveHours(new BigDecimal(objectMap.get("manHours").toString())); + if (ObjectUtils.isNotEmpty(auxiliaryCorrectionHours)) { + if (auxiliaryCorrectionHours.getFiveHours().compareTo(auxiliaryOriginalHoursDto.getFiveHours()) != 0) { + auxiliaryOriginalHoursDto.setFive(1); + } + } + break; + case "06": + auxiliaryOriginalHoursDto.setSixHours(new BigDecimal(objectMap.get("manHours").toString())); + if (ObjectUtils.isNotEmpty(auxiliaryCorrectionHours)) { + if (auxiliaryCorrectionHours.getSixHours().compareTo(auxiliaryOriginalHoursDto.getSixHours()) != 0) { + auxiliaryOriginalHoursDto.setSix(1); + } + } + break; + case "07": + auxiliaryOriginalHoursDto.setSevenHours(new BigDecimal(objectMap.get("manHours").toString())); + if (ObjectUtils.isNotEmpty(auxiliaryCorrectionHours)) { + if (auxiliaryCorrectionHours.getSevenHours().compareTo(auxiliaryOriginalHoursDto.getSevenHours()) != 0) { + auxiliaryOriginalHoursDto.setSeven(1); + } + } + break; + case "08": + auxiliaryOriginalHoursDto.setEightHours(new BigDecimal(objectMap.get("manHours").toString())); + if (ObjectUtils.isNotEmpty(auxiliaryCorrectionHours)) { + if (auxiliaryCorrectionHours.getEightHours().compareTo(auxiliaryOriginalHoursDto.getEightHours()) != 0) { + auxiliaryOriginalHoursDto.setEight(1); + } + } + break; + case "09": + auxiliaryOriginalHoursDto.setNineHours(new BigDecimal(objectMap.get("manHours").toString())); + if (ObjectUtils.isNotEmpty(auxiliaryCorrectionHours)) { + if (auxiliaryCorrectionHours.getNineHours().compareTo(auxiliaryOriginalHoursDto.getNineHours()) != 0) { + auxiliaryOriginalHoursDto.setNine(1); + } + } + break; + case "10": + auxiliaryOriginalHoursDto.setTenHours(new BigDecimal(objectMap.get("manHours").toString())); + if (ObjectUtils.isNotEmpty(auxiliaryCorrectionHours)) { + if (auxiliaryCorrectionHours.getTenHours().compareTo(auxiliaryOriginalHoursDto.getTenHours()) != 0) { + auxiliaryOriginalHoursDto.setTen(1); + } + } + break; + case "11": + auxiliaryOriginalHoursDto.setElevenHours(new BigDecimal(objectMap.get("manHours").toString())); + if (ObjectUtils.isNotEmpty(auxiliaryCorrectionHours)) { + if (auxiliaryCorrectionHours.getElevenHours().compareTo(auxiliaryOriginalHoursDto.getElevenHours()) != 0) { + auxiliaryOriginalHoursDto.setEleven(1); + } + } + break; + case "12": + auxiliaryOriginalHoursDto.setTwelveHours(new BigDecimal(objectMap.get("manHours").toString())); + if (ObjectUtils.isNotEmpty(auxiliaryCorrectionHours)) { + if (auxiliaryCorrectionHours.getTwelveHours().compareTo(auxiliaryOriginalHoursDto.getTwelveHours()) != 0) { + auxiliaryOriginalHoursDto.setTwelve(1); + } + } + break; + case "13": + auxiliaryOriginalHoursDto.setThirteenHours(new BigDecimal(objectMap.get("manHours").toString())); + if (ObjectUtils.isNotEmpty(auxiliaryCorrectionHours)) { + if (auxiliaryCorrectionHours.getThirteenHours().compareTo(auxiliaryOriginalHoursDto.getThirteenHours()) != 0) { + auxiliaryOriginalHoursDto.setThirteen(1); + } + } + break; + case "14": + auxiliaryOriginalHoursDto.setFourteenHours(new BigDecimal(objectMap.get("manHours").toString())); + if (ObjectUtils.isNotEmpty(auxiliaryCorrectionHours)) { + if (auxiliaryCorrectionHours.getFourteenHours().compareTo(auxiliaryOriginalHoursDto.getFourteenHours()) != 0) { + auxiliaryOriginalHoursDto.setFourteen(1); + } + } + break; + case "15": + auxiliaryOriginalHoursDto.setFifteenHours(new BigDecimal(objectMap.get("manHours").toString())); + if (ObjectUtils.isNotEmpty(auxiliaryCorrectionHours)) { + if (auxiliaryCorrectionHours.getFifteenHours().compareTo(auxiliaryOriginalHoursDto.getFifteenHours()) != 0) { + auxiliaryOriginalHoursDto.setFifteen(1); + } + } + break; + case "16": + auxiliaryOriginalHoursDto.setSixteenHours(new BigDecimal(objectMap.get("manHours").toString())); + if (ObjectUtils.isNotEmpty(auxiliaryCorrectionHours)) { + if (auxiliaryCorrectionHours.getSixteenHours().compareTo(auxiliaryOriginalHoursDto.getSixteenHours()) != 0) { + auxiliaryOriginalHoursDto.setSixteen(1); + } + } + break; + case "17": + auxiliaryOriginalHoursDto.setSeventeenHours(new BigDecimal(objectMap.get("manHours").toString())); + if (ObjectUtils.isNotEmpty(auxiliaryCorrectionHours)) { + if (auxiliaryCorrectionHours.getSeventeenHours().compareTo(auxiliaryOriginalHoursDto.getSeventeenHours()) != 0) { + auxiliaryOriginalHoursDto.setSeventeen(1); + } + } + break; + case "18": + auxiliaryOriginalHoursDto.setEighteenHours(new BigDecimal(objectMap.get("manHours").toString())); + if (ObjectUtils.isNotEmpty(auxiliaryCorrectionHours)) { + if (auxiliaryCorrectionHours.getEighteenHours().compareTo(auxiliaryOriginalHoursDto.getEighteenHours()) != 0) { + auxiliaryOriginalHoursDto.setEighteen(1); + } + } + break; + case "19": + auxiliaryOriginalHoursDto.setNineteenHours(new BigDecimal(objectMap.get("manHours").toString())); + if (ObjectUtils.isNotEmpty(auxiliaryCorrectionHours)) { + if (auxiliaryCorrectionHours.getNineteenHours().compareTo(auxiliaryOriginalHoursDto.getNineteenHours()) != 0) { + auxiliaryOriginalHoursDto.setNineteen(1); + } + } + break; + case "20": + auxiliaryOriginalHoursDto.setTwentyHours(new BigDecimal(objectMap.get("manHours").toString())); + if (ObjectUtils.isNotEmpty(auxiliaryCorrectionHours)) { + if (auxiliaryCorrectionHours.getTwentyHours().compareTo(auxiliaryOriginalHoursDto.getTwentyHours()) != 0) { + auxiliaryOriginalHoursDto.setTwenty(1); + } + } + break; + case "21": + auxiliaryOriginalHoursDto.setTwentyOneHours(new BigDecimal(objectMap.get("manHours").toString())); + if (ObjectUtils.isNotEmpty(auxiliaryCorrectionHours)) { + if (auxiliaryCorrectionHours.getTwentyOneHours().compareTo(auxiliaryOriginalHoursDto.getTwentyOneHours()) != 0) { + auxiliaryOriginalHoursDto.setTwentyOne(1); + } + } + break; + case "22": + auxiliaryOriginalHoursDto.setTwentyTwoHours(new BigDecimal(objectMap.get("manHours").toString())); + if (ObjectUtils.isNotEmpty(auxiliaryCorrectionHours)) { + if (auxiliaryCorrectionHours.getTwentyTwoHours().compareTo(auxiliaryOriginalHoursDto.getTwentyTwoHours()) != 0) { + auxiliaryOriginalHoursDto.setTwentyTwo(1); + } + } + break; + case "23": + auxiliaryOriginalHoursDto.setTwentyThreeHours(new BigDecimal(objectMap.get("manHours").toString())); + if (ObjectUtils.isNotEmpty(auxiliaryCorrectionHours)) { + if (auxiliaryCorrectionHours.getTwentyThreeHours().compareTo(auxiliaryOriginalHoursDto.getTwentyThreeHours()) != 0) { + auxiliaryOriginalHoursDto.setTwentyThree(1); + } + } + break; + case "24": + auxiliaryOriginalHoursDto.setTwentyFourHours(new BigDecimal(objectMap.get("manHours").toString())); + if (ObjectUtils.isNotEmpty(auxiliaryCorrectionHours)) { + if (auxiliaryCorrectionHours.getTwentyFourHours().compareTo(auxiliaryOriginalHoursDto.getTwentyFourHours()) != 0) { + auxiliaryOriginalHoursDto.setTwentyFour(1); + } + } + break; + case "25": + auxiliaryOriginalHoursDto.setTwentyFiveHours(new BigDecimal(objectMap.get("manHours").toString())); + if (ObjectUtils.isNotEmpty(auxiliaryCorrectionHours)) { + if (auxiliaryCorrectionHours.getTwentyFiveHours().compareTo(auxiliaryOriginalHoursDto.getTwentyFiveHours()) != 0) { + auxiliaryOriginalHoursDto.setTwentyFive(1); + } + } + break; + case "26": + auxiliaryOriginalHoursDto.setTwentySixHours(new BigDecimal(objectMap.get("manHours").toString())); + if (ObjectUtils.isNotEmpty(auxiliaryCorrectionHours)) { + if (auxiliaryCorrectionHours.getTwentySixHours().compareTo(auxiliaryOriginalHoursDto.getTwentySixHours()) != 0) { + auxiliaryOriginalHoursDto.setTwentySix(1); + } + } + break; + case "27": + auxiliaryOriginalHoursDto.setTwentySevenHours(new BigDecimal(objectMap.get("manHours").toString())); + if (ObjectUtils.isNotEmpty(auxiliaryCorrectionHours)) { + if (auxiliaryCorrectionHours.getTwentySevenHours().compareTo(auxiliaryOriginalHoursDto.getTwentySevenHours()) != 0) { + auxiliaryOriginalHoursDto.setTwentySeven(1); + } + } + break; + case "28": + auxiliaryOriginalHoursDto.setTwentyEightHours(new BigDecimal(objectMap.get("manHours").toString())); + if (ObjectUtils.isNotEmpty(auxiliaryCorrectionHours)) { + if (auxiliaryCorrectionHours.getTwentyEightHours().compareTo(auxiliaryOriginalHoursDto.getTwentyEightHours()) != 0) { + auxiliaryOriginalHoursDto.setTwentyEight(1); + } + } + break; + case "29": + auxiliaryOriginalHoursDto.setTwentyNineHours(new BigDecimal(objectMap.get("manHours").toString())); + if (ObjectUtils.isNotEmpty(auxiliaryCorrectionHours)) { + if (auxiliaryCorrectionHours.getTwentyNineHours().compareTo(auxiliaryOriginalHoursDto.getTwentyNineHours()) != 0) { + auxiliaryOriginalHoursDto.setTwentyNine(1); + } + } + break; + case "30": + auxiliaryOriginalHoursDto.setThirtyHours(new BigDecimal(objectMap.get("manHours").toString())); + if (ObjectUtils.isNotEmpty(auxiliaryCorrectionHours)) { + if (auxiliaryCorrectionHours.getThirtyHours().compareTo(auxiliaryOriginalHoursDto.getThirtyHours()) != 0) { + auxiliaryOriginalHoursDto.setThirty(1); + } + } + break; + case "31": + auxiliaryOriginalHoursDto.setThirtyOneHours(new BigDecimal(objectMap.get("manHours").toString())); + if (ObjectUtils.isNotEmpty(auxiliaryCorrectionHours)) { + if (auxiliaryCorrectionHours.getThirtyOneHours().compareTo(auxiliaryOriginalHoursDto.getThirtyOneHours()) != 0) { + auxiliaryOriginalHoursDto.setThirtyOne(1); + } + } + break; + } + auxiliaryOriginalHoursDto.setTotal((ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getOneHours()) ? auxiliaryOriginalHoursDto.getOneHours() : BigDecimal.ZERO) + .add(ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getThreeHours()) ? auxiliaryOriginalHoursDto.getThreeHours() : BigDecimal.ZERO) + .add(ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getFourHours()) ? auxiliaryOriginalHoursDto.getFourHours() : BigDecimal.ZERO) + .add(ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getFiveHours()) ? auxiliaryOriginalHoursDto.getFiveHours() : BigDecimal.ZERO) + .add(ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getSixHours()) ? auxiliaryOriginalHoursDto.getSixHours() : BigDecimal.ZERO) + .add(ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getSevenHours()) ? auxiliaryOriginalHoursDto.getSevenHours() : BigDecimal.ZERO) + .add(ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getEightHours()) ? auxiliaryOriginalHoursDto.getEightHours() : BigDecimal.ZERO) + .add(ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getNineHours()) ? auxiliaryOriginalHoursDto.getNineHours() : BigDecimal.ZERO) + .add(ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getTenHours()) ? auxiliaryOriginalHoursDto.getTenHours() : BigDecimal.ZERO) + .add(ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getElevenHours()) ? auxiliaryOriginalHoursDto.getElevenHours() : BigDecimal.ZERO) + .add(ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getTwelveHours()) ? auxiliaryOriginalHoursDto.getTwelveHours() : BigDecimal.ZERO) + .add(ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getThirteenHours()) ? auxiliaryOriginalHoursDto.getThirteenHours() : BigDecimal.ZERO) + .add(ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getFourteenHours()) ? auxiliaryOriginalHoursDto.getFourteenHours() : BigDecimal.ZERO) + .add(ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getFifteenHours()) ? auxiliaryOriginalHoursDto.getFifteenHours() : BigDecimal.ZERO) + .add(ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getSixteenHours()) ? auxiliaryOriginalHoursDto.getSixteenHours() : BigDecimal.ZERO) + .add(ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getSeventeenHours()) ? auxiliaryOriginalHoursDto.getSeventeenHours() : BigDecimal.ZERO) + .add(ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getEighteenHours()) ? auxiliaryOriginalHoursDto.getEighteenHours() : BigDecimal.ZERO) + .add(ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getNineteenHours()) ? auxiliaryOriginalHoursDto.getNineteenHours() : BigDecimal.ZERO) + .add(ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getTwentyHours()) ? auxiliaryOriginalHoursDto.getTwentyHours() : BigDecimal.ZERO) + .add(ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getTwentyOneHours()) ? auxiliaryOriginalHoursDto.getTwentyOneHours() : BigDecimal.ZERO) + .add(ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getTwentyTwoHours()) ? auxiliaryOriginalHoursDto.getTwentyTwoHours() : BigDecimal.ZERO) + .add(ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getTwentyThreeHours()) ? auxiliaryOriginalHoursDto.getTwentyThreeHours() : BigDecimal.ZERO) + .add(ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getTwentyFourHours()) ? auxiliaryOriginalHoursDto.getTwentyFourHours() : BigDecimal.ZERO) + .add(ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getTwentyFiveHours()) ? auxiliaryOriginalHoursDto.getTwentyFiveHours() : BigDecimal.ZERO) + .add(ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getTwentySixHours()) ? auxiliaryOriginalHoursDto.getTwentySixHours() : BigDecimal.ZERO) + .add(ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getTwentySevenHours()) ? auxiliaryOriginalHoursDto.getTwentySevenHours() : BigDecimal.ZERO) + .add(ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getTwentyEightHours()) ? auxiliaryOriginalHoursDto.getTwentyEightHours() : BigDecimal.ZERO) + .add(ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getTwentyNineHours()) ? auxiliaryOriginalHoursDto.getTwentyNineHours() : BigDecimal.ZERO) + .add(ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getThirtyHours()) ? auxiliaryOriginalHoursDto.getThirtyHours() : BigDecimal.ZERO) + .add(ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getThirtyOneHours()) ? auxiliaryOriginalHoursDto.getThirtyOneHours() : BigDecimal.ZERO) + ); + auxiliaryOriginalHoursDto.setTotal(auxiliaryOriginalHoursDto.getTotal().setScale(4, RoundingMode.HALF_UP)); + + dtoMap.put(name, auxiliaryOriginalHoursDto); + } + return dtoMap; + } + + //鍚堝苟 + private void merge(Map<String, AuxiliaryOriginalHoursDto> data5, Map<String, AuxiliaryOriginalHoursDto> data4, Map<String, AuxiliaryOriginalHoursDto> data2) { + for (Map.Entry<String, AuxiliaryOriginalHoursDto> entry : data2.entrySet()) { + String key = entry.getKey(); + AuxiliaryOriginalHoursDto value = entry.getValue(); + if (data5.containsKey(key)) { + for (Map.Entry<String, AuxiliaryOriginalHoursDto> dtoEntry : data5.entrySet()) { + if (dtoEntry.getKey().equals(key)) { + AuxiliaryOriginalHoursDto auxiliaryOriginalHoursDto = new AuxiliaryOriginalHoursDto(); + AuxiliaryOriginalHoursDto hoursDto = data5.get(key); + BeanUtils.copyProperties(hoursDto, auxiliaryOriginalHoursDto); + auxiliaryOriginalHoursDto.setType("鎬诲伐鏃�"); + auxiliaryOriginalHoursDto.setOneHours((ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getOneHours()) ? auxiliaryOriginalHoursDto.getOneHours() : BigDecimal.ZERO).add(ObjectUtils.isNotEmpty(value.getOneHours()) ? value.getOneHours() : BigDecimal.ZERO)); + auxiliaryOriginalHoursDto.setTwoHours((ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getTwoHours()) ? auxiliaryOriginalHoursDto.getTwoHours() : BigDecimal.ZERO).add(ObjectUtils.isNotEmpty(value.getTwoHours()) ? value.getTwoHours() : BigDecimal.ZERO)); + auxiliaryOriginalHoursDto.setThreeHours((ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getThreeHours()) ? auxiliaryOriginalHoursDto.getThreeHours() : BigDecimal.ZERO).add(ObjectUtils.isNotEmpty(value.getThreeHours()) ? value.getThreeHours() : BigDecimal.ZERO)); + auxiliaryOriginalHoursDto.setFourHours((ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getFourHours()) ? auxiliaryOriginalHoursDto.getFourHours() : BigDecimal.ZERO).add(ObjectUtils.isNotEmpty(value.getFourHours()) ? value.getFourHours() : BigDecimal.ZERO)); + auxiliaryOriginalHoursDto.setFiveHours((ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getFiveHours()) ? auxiliaryOriginalHoursDto.getFiveHours() : BigDecimal.ZERO).add(ObjectUtils.isNotEmpty(value.getFiveHours()) ? value.getFiveHours() : BigDecimal.ZERO)); + auxiliaryOriginalHoursDto.setSixHours((ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getSixHours()) ? auxiliaryOriginalHoursDto.getSixHours() : BigDecimal.ZERO).add(ObjectUtils.isNotEmpty(value.getSixHours()) ? value.getSixHours() : BigDecimal.ZERO)); + auxiliaryOriginalHoursDto.setSevenHours((ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getSevenHours()) ? auxiliaryOriginalHoursDto.getSevenHours() : BigDecimal.ZERO).add(ObjectUtils.isNotEmpty(value.getSevenHours()) ? value.getSevenHours() : BigDecimal.ZERO)); + auxiliaryOriginalHoursDto.setEightHours((ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getEightHours()) ? auxiliaryOriginalHoursDto.getEightHours() : BigDecimal.ZERO).add(ObjectUtils.isNotEmpty(value.getEightHours()) ? value.getEightHours() : BigDecimal.ZERO)); + auxiliaryOriginalHoursDto.setNineHours((ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getNineHours()) ? auxiliaryOriginalHoursDto.getNineHours() : BigDecimal.ZERO).add(ObjectUtils.isNotEmpty(value.getNineHours()) ? value.getNineHours() : BigDecimal.ZERO)); + auxiliaryOriginalHoursDto.setTenHours((ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getTenHours()) ? auxiliaryOriginalHoursDto.getTenHours() : BigDecimal.ZERO).add(ObjectUtils.isNotEmpty(value.getTenHours()) ? value.getTenHours() : BigDecimal.ZERO)); + auxiliaryOriginalHoursDto.setElevenHours((ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getElevenHours()) ? auxiliaryOriginalHoursDto.getElevenHours() : BigDecimal.ZERO).add(ObjectUtils.isNotEmpty(value.getElevenHours()) ? value.getElevenHours() : BigDecimal.ZERO)); + auxiliaryOriginalHoursDto.setTwelveHours((ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getTwelveHours()) ? auxiliaryOriginalHoursDto.getTwelveHours() : BigDecimal.ZERO).add(ObjectUtils.isNotEmpty(value.getTwelveHours()) ? value.getTwelveHours() : BigDecimal.ZERO)); + auxiliaryOriginalHoursDto.setThirteenHours((ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getThirteenHours()) ? auxiliaryOriginalHoursDto.getThirteenHours() : BigDecimal.ZERO).add(ObjectUtils.isNotEmpty(value.getThirteenHours()) ? value.getThirteenHours() : BigDecimal.ZERO)); + auxiliaryOriginalHoursDto.setFourteenHours((ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getFourteenHours()) ? auxiliaryOriginalHoursDto.getFourteenHours() : BigDecimal.ZERO).add(ObjectUtils.isNotEmpty(value.getFourteenHours()) ? value.getFourteenHours() : BigDecimal.ZERO)); + auxiliaryOriginalHoursDto.setFifteenHours((ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getFifteenHours()) ? auxiliaryOriginalHoursDto.getFifteenHours() : BigDecimal.ZERO).add(ObjectUtils.isNotEmpty(value.getFifteenHours()) ? value.getFifteenHours() : BigDecimal.ZERO)); + auxiliaryOriginalHoursDto.setSixteenHours((ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getSixteenHours()) ? auxiliaryOriginalHoursDto.getSixteenHours() : BigDecimal.ZERO).add(ObjectUtils.isNotEmpty(value.getSixteenHours()) ? value.getSixteenHours() : BigDecimal.ZERO)); + auxiliaryOriginalHoursDto.setSeventeenHours((ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getSeventeenHours()) ? auxiliaryOriginalHoursDto.getSeventeenHours() : BigDecimal.ZERO).add(ObjectUtils.isNotEmpty(value.getSeventeenHours()) ? value.getSeventeenHours() : BigDecimal.ZERO)); + auxiliaryOriginalHoursDto.setEighteenHours((ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getEighteenHours()) ? auxiliaryOriginalHoursDto.getEighteenHours() : BigDecimal.ZERO).add(ObjectUtils.isNotEmpty(value.getEighteenHours()) ? value.getEighteenHours() : BigDecimal.ZERO)); + auxiliaryOriginalHoursDto.setNineteenHours((ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getNineteenHours()) ? auxiliaryOriginalHoursDto.getNineteenHours() : BigDecimal.ZERO).add(ObjectUtils.isNotEmpty(value.getNineteenHours()) ? value.getNineteenHours() : BigDecimal.ZERO)); + auxiliaryOriginalHoursDto.setTwelveHours((ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getTwelveHours()) ? auxiliaryOriginalHoursDto.getTwelveHours() : BigDecimal.ZERO).add(ObjectUtils.isNotEmpty(value.getTwelveHours()) ? value.getTwelveHours() : BigDecimal.ZERO)); + auxiliaryOriginalHoursDto.setTwentyOneHours((ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getTwentyOneHours()) ? auxiliaryOriginalHoursDto.getTwentyOneHours() : BigDecimal.ZERO).add(ObjectUtils.isNotEmpty(value.getTwentyOneHours()) ? value.getTwentyOneHours() : BigDecimal.ZERO)); + auxiliaryOriginalHoursDto.setTwentyTwoHours((ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getTwentyTwoHours()) ? auxiliaryOriginalHoursDto.getTwentyTwoHours() : BigDecimal.ZERO).add(ObjectUtils.isNotEmpty(value.getTwentyTwoHours()) ? value.getTwentyTwoHours() : BigDecimal.ZERO)); + auxiliaryOriginalHoursDto.setTwentyThreeHours((ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getTwentyThreeHours()) ? auxiliaryOriginalHoursDto.getTwentyThreeHours() : BigDecimal.ZERO).add(ObjectUtils.isNotEmpty(value.getTwentyThreeHours()) ? value.getTwentyThreeHours() : BigDecimal.ZERO)); + BigDecimal v = ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getTwentyFourHours()) ? auxiliaryOriginalHoursDto.getTwentyFourHours() : BigDecimal.ZERO; + BigDecimal v1 = ObjectUtils.isNotEmpty(value.getTwentyFourHours()) ? value.getTwentyFourHours() : BigDecimal.ZERO; + BigDecimal v2 = v.add(v1); + auxiliaryOriginalHoursDto.setTwentyFourHours((ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getTwentyFourHours()) ? auxiliaryOriginalHoursDto.getTwentyFourHours() : BigDecimal.ZERO).add(ObjectUtils.isNotEmpty(value.getTwentyFourHours()) ? value.getTwentyFourHours() : BigDecimal.ZERO)); + auxiliaryOriginalHoursDto.setTwentyFiveHours((ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getTwentyFiveHours()) ? auxiliaryOriginalHoursDto.getTwentyFiveHours() : BigDecimal.ZERO).add(ObjectUtils.isNotEmpty(value.getTwentyFiveHours()) ? value.getTwentyFiveHours() : BigDecimal.ZERO)); + auxiliaryOriginalHoursDto.setTwentySixHours((ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getTwentySixHours()) ? auxiliaryOriginalHoursDto.getTwentySixHours() : BigDecimal.ZERO).add(ObjectUtils.isNotEmpty(value.getTwentySixHours()) ? value.getTwentySixHours() : BigDecimal.ZERO)); + auxiliaryOriginalHoursDto.setTwentySevenHours((ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getTwentySevenHours()) ? auxiliaryOriginalHoursDto.getTwentySevenHours() : BigDecimal.ZERO).add(ObjectUtils.isNotEmpty(value.getTwentySevenHours()) ? value.getTwentySevenHours() : BigDecimal.ZERO)); + auxiliaryOriginalHoursDto.setTwentyEightHours((ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getTwentyEightHours()) ? auxiliaryOriginalHoursDto.getTwentyEightHours() : BigDecimal.ZERO).add(ObjectUtils.isNotEmpty(value.getTwentyEightHours()) ? value.getTwentyEightHours() : BigDecimal.ZERO)); + auxiliaryOriginalHoursDto.setTwentyNineHours((ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getTwentyNineHours()) ? auxiliaryOriginalHoursDto.getTwentyNineHours() : BigDecimal.ZERO).add(ObjectUtils.isNotEmpty(value.getTwentyNineHours()) ? value.getTwentyNineHours() : BigDecimal.ZERO)); + auxiliaryOriginalHoursDto.setThirtyHours((ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getThirtyHours()) ? auxiliaryOriginalHoursDto.getThirtyHours() : BigDecimal.ZERO).add(ObjectUtils.isNotEmpty(value.getThirtyHours()) ? value.getThirtyHours() : BigDecimal.ZERO)); + auxiliaryOriginalHoursDto.setThirtyOneHours((ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getThirtyOneHours()) ? auxiliaryOriginalHoursDto.getThirtyOneHours() : BigDecimal.ZERO).add(ObjectUtils.isNotEmpty(value.getThirtyOneHours()) ? value.getThirtyOneHours() : BigDecimal.ZERO)); + auxiliaryOriginalHoursDto.setTotal((ObjectUtils.isNotEmpty(auxiliaryOriginalHoursDto.getTotal()) ? auxiliaryOriginalHoursDto.getTotal() : BigDecimal.ZERO).add(ObjectUtils.isNotEmpty(value.getTotal()) ? value.getTotal() : BigDecimal.ZERO)); + data4.put(key, auxiliaryOriginalHoursDto); + } /*else { + AuxiliaryOriginalHoursDto hoursDto = data5.get(dtoEntry.getKey()); + AuxiliaryOriginalHoursDto dto = new AuxiliaryOriginalHoursDto(); + BeanUtils.copyProperties(hoursDto, dto); + dto.setType("鎬诲伐鏃�"); + data4.put(dtoEntry.getKey(), dto); + }*/ + } + } else { + value.setType("鎬诲伐鏃�"); + data4.put(key, value); + } + } + + } +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/service/impl/AuxiliaryOutputWorkingHoursServiceImpl.java b/performance-server/src/main/java/com/ruoyi/performance/service/impl/AuxiliaryOutputWorkingHoursServiceImpl.java new file mode 100644 index 0000000..d087d07 --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/service/impl/AuxiliaryOutputWorkingHoursServiceImpl.java @@ -0,0 +1,260 @@ +package com.ruoyi.performance.service.impl; + +import com.alibaba.excel.EasyExcel; +import com.alibaba.excel.ExcelWriter; +import com.alibaba.excel.write.metadata.WriteSheet; +import com.alibaba.excel.write.style.column.LongestMatchColumnWidthStyleStrategy; +import com.baomidou.mybatisplus.core.metadata.IPage; +import com.baomidou.mybatisplus.core.toolkit.ObjectUtils; +import com.baomidou.mybatisplus.core.toolkit.Wrappers; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; +import com.ruoyi.common.core.domain.entity.User; +import com.ruoyi.common.utils.QueryWrappers; +import com.ruoyi.performance.dto.AuxiliaryOutputWorkingHoursDto; +import com.ruoyi.performance.dto.AuxiliaryWorkingHoursDayDto; +import com.ruoyi.performance.mapper.AuxiliaryOutputWorkingHoursMapper; +import com.ruoyi.performance.mapper.AuxiliaryWorkingHoursDayMapper; +import com.ruoyi.performance.pojo.AuxiliaryOutputWorkingHours; +import com.ruoyi.performance.pojo.AuxiliaryWorkingHoursDay; +import com.ruoyi.performance.service.AuxiliaryOutputWorkingHoursService; +import com.ruoyi.system.mapper.UserMapper; +import org.apache.commons.math3.analysis.function.Power; +import org.springframework.stereotype.Service; + +import javax.annotation.Resource; +import javax.servlet.http.HttpServletResponse; +import java.io.IOException; +import java.math.BigDecimal; +import java.net.URLEncoder; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; + +/** + * <p> + * 鏃ュ伐鏃剁鐞嗙殑浜ч噺宸ユ椂 鏈嶅姟瀹炵幇绫� + * </p> + * + * @author 姹熻嫃榈烽洀缃戠粶绉戞妧鏈夐檺鍏徃 + * @since 2024-05-28 03:48:48 + */ +@Service +public class AuxiliaryOutputWorkingHoursServiceImpl extends ServiceImpl<AuxiliaryOutputWorkingHoursMapper, AuxiliaryOutputWorkingHours> implements AuxiliaryOutputWorkingHoursService { + + @Resource + AuxiliaryOutputWorkingHoursMapper auxiliaryOutputWorkingHoursMapper; + + @Resource + AuxiliaryWorkingHoursDayMapper auxiliaryWorkingHoursDayMapper; + + @Resource + UserMapper userMapper; + + @Override + public IPage<AuxiliaryOutputWorkingHoursDto> selectAuxiliaryOutputWorkingHours(Page page, AuxiliaryOutputWorkingHoursDto auxiliaryOutputWorkingHoursDto) { + String dates = auxiliaryOutputWorkingHoursDto.getDateTime(); + String week = auxiliaryOutputWorkingHoursDto.getWeek(); + auxiliaryOutputWorkingHoursDto.setDateTime(null); + auxiliaryOutputWorkingHoursDto.setWeek(null); + List<Long> ids = new ArrayList<>(); + if (ids.size() == 0) { + ids = null; + } + if (ObjectUtils.isNotEmpty(dates) && ObjectUtils.isNotEmpty(week)) { + String[] split = dates.replaceAll("\\[", "").replaceAll("]", "").replaceAll("\"", "").split(","); + String[] weeks = week.replaceAll("\\[", "").replaceAll("]", "").replaceAll("\"", "").split(","); + IPage<AuxiliaryOutputWorkingHoursDto> auxiliaryOutputWorkingHoursDtoIPage = auxiliaryOutputWorkingHoursMapper.selectAuxiliaryOutputWorkingHours(page, + QueryWrappers.queryWrappers(auxiliaryOutputWorkingHoursDto) + .ge("date_time", split[0]).le("date_time", split[1] + " 23:59:59") + .ge("week", weeks[0]).le("week", weeks[1]), ids); + for (AuxiliaryOutputWorkingHoursDto record : auxiliaryOutputWorkingHoursDtoIPage.getRecords()) { + record.setDateTime(record.getDateTime().substring(0,10)); + } + return auxiliaryOutputWorkingHoursDtoIPage ; + } else if (ObjectUtils.isNotEmpty(dates) && ObjectUtils.isEmpty(week)) { + String[] split = dates.replaceAll("\\[", "").replaceAll("]", "").replaceAll("\"", "").split(","); + IPage<AuxiliaryOutputWorkingHoursDto> auxiliaryOutputWorkingHoursDtoIPage = auxiliaryOutputWorkingHoursMapper.selectAuxiliaryOutputWorkingHours(page, + QueryWrappers.queryWrappers(auxiliaryOutputWorkingHoursDto) + .ge("date_time", split[0]).le("date_time", split[1] + " 23:59:59"), ids); + for (AuxiliaryOutputWorkingHoursDto record : auxiliaryOutputWorkingHoursDtoIPage.getRecords()) { + record.setDateTime(record.getDateTime().substring(0,10)); + } + return auxiliaryOutputWorkingHoursDtoIPage ; + } else if (ObjectUtils.isEmpty(dates) && ObjectUtils.isNotEmpty(week)) { + String[] weeks = week.replaceAll("\\[", "").replaceAll("]", "").replaceAll("\"", "").split(","); + IPage<AuxiliaryOutputWorkingHoursDto> auxiliaryOutputWorkingHoursDtoIPage = auxiliaryOutputWorkingHoursMapper.selectAuxiliaryOutputWorkingHours(page, + QueryWrappers.queryWrappers(auxiliaryOutputWorkingHoursDto) + .ge("week", weeks[0]).le("week", weeks[1]), ids); + for (AuxiliaryOutputWorkingHoursDto record : auxiliaryOutputWorkingHoursDtoIPage.getRecords()) { + record.setDateTime(record.getDateTime().substring(0,10)); + } + return auxiliaryOutputWorkingHoursDtoIPage ; + } else { + IPage<AuxiliaryOutputWorkingHoursDto> auxiliaryOutputWorkingHoursDtoIPage = auxiliaryOutputWorkingHoursMapper.selectAuxiliaryOutputWorkingHours(page, QueryWrappers.queryWrappers(auxiliaryOutputWorkingHoursDto), ids); + for (AuxiliaryOutputWorkingHoursDto record : auxiliaryOutputWorkingHoursDtoIPage.getRecords()) { + record.setDateTime(record.getDateTime().substring(0,10)); + } + return auxiliaryOutputWorkingHoursDtoIPage ; + } + } + + //缁熻浜ч噺宸ユ椂姹囨�诲拰杈呭姪宸ユ椂姹囨�� + @Override + public Map<String, Object> collectWorkingHours(AuxiliaryOutputWorkingHoursDto auxiliaryOutputWorkingHoursDto) { + AuxiliaryOutputWorkingHours outputWorkingHours = new AuxiliaryOutputWorkingHours(); + AuxiliaryWorkingHoursDay workingHoursDay = new AuxiliaryWorkingHoursDay(); + List<Long> ids = new ArrayList<>(); + if (ObjectUtils.isNotEmpty(auxiliaryOutputWorkingHoursDto.getWeekDay())){ + outputWorkingHours.setWeekDay(auxiliaryOutputWorkingHoursDto.getWeekDay()); + workingHoursDay.setWeekDay(auxiliaryOutputWorkingHoursDto.getWeekDay()); + } + if (ObjectUtils.isNotEmpty(auxiliaryOutputWorkingHoursDto.getName())){ + List<User> user = userMapper.selectList(Wrappers.<User>lambdaQuery().like(User::getName, auxiliaryOutputWorkingHoursDto.getName())); + ids.addAll(user.stream().map(User::getId).collect(Collectors.toList())); + } + String dates = auxiliaryOutputWorkingHoursDto.getDateTime(); + auxiliaryOutputWorkingHoursDto.setDateTime(null); + Map<String, Object> map = new HashMap<>(); + BigDecimal sumOutputWorkTime = BigDecimal.ZERO; + BigDecimal sumApprovedWorkingHour = BigDecimal.ZERO; + + //鍒ゆ柇鏄粍闀胯繕鏄粍鍛樿繕鏄鐞嗗憳 + List<AuxiliaryOutputWorkingHours> auxiliaryOutputWorkingHours = new ArrayList<>(); + List<AuxiliaryWorkingHoursDay> auxiliaryWorkingHoursDays = new ArrayList<>(); + if (ids.size() == 0) { + ids=null; + } + if (ObjectUtils.isNotEmpty(dates)) { + String[] split = dates.replaceAll("\\[", "").replaceAll("]", "").replaceAll("\"", "").split(","); + //缁熻褰撳墠鐢ㄦ埛鐨勪骇鍝佸伐鏃� + auxiliaryOutputWorkingHours = auxiliaryOutputWorkingHoursMapper.selectLists(QueryWrappers.queryWrappers(outputWorkingHours) + .ge("date_time", split[0]) + .le("date_time", split[1] + " 23:59:59"),ids); + //缁熻褰撳墠鐢ㄦ埛鐨勮緟鍔╁伐鏃� + auxiliaryWorkingHoursDays = auxiliaryWorkingHoursDayMapper.selectLists(QueryWrappers.queryWrappers(workingHoursDay) + .eq("state","宸叉壒鍑�") + .ge("date_time", split[0]) + .le("date_time", split[1] + " 23:59:59"),ids); + }else if (ObjectUtils.isNotEmpty(auxiliaryOutputWorkingHoursDto.getWeekDay())){ + //缁熻褰撳墠鐢ㄦ埛鐨勪骇鍝佸伐鏃� + auxiliaryOutputWorkingHours = auxiliaryOutputWorkingHoursMapper.selectLists(QueryWrappers.queryWrappers(outputWorkingHours),ids); + //缁熻褰撳墠鐢ㄦ埛鐨勮緟鍔╁伐鏃� + auxiliaryWorkingHoursDays = auxiliaryWorkingHoursDayMapper.selectLists(QueryWrappers.queryWrappers(workingHoursDay).eq("state","宸叉壒鍑�"),ids); + } + else { + auxiliaryOutputWorkingHours = auxiliaryOutputWorkingHoursMapper.selectListByIds(ids); + auxiliaryWorkingHoursDays = auxiliaryWorkingHoursDayMapper.selectListByIds(ids); + } + if (ObjectUtils.isNotEmpty(auxiliaryOutputWorkingHours)) { + Map<String, BigDecimal> sumMap = new HashMap<>(); + for (AuxiliaryOutputWorkingHours auxiliaryOutputWorkingHour : auxiliaryOutputWorkingHours) { + if (!sumMap.containsKey(auxiliaryOutputWorkingHour.getManHourGroup()+auxiliaryOutputWorkingHour.getOrderNo()+auxiliaryOutputWorkingHour.getSample())) { + sumMap.put(auxiliaryOutputWorkingHour.getManHourGroup()+auxiliaryOutputWorkingHour.getOrderNo()+auxiliaryOutputWorkingHour.getSample(), auxiliaryOutputWorkingHour.getOutputWorkTime()); + } + } + sumOutputWorkTime = sumMap.values().stream().reduce(BigDecimal.ZERO, BigDecimal::add); + } + map.put("浜ч噺宸ユ椂姹囨��", sumOutputWorkTime); + if (ObjectUtils.isNotEmpty(auxiliaryWorkingHoursDays)) { + for (AuxiliaryWorkingHoursDay auxiliaryWorkingHoursDay : auxiliaryWorkingHoursDays) { + sumApprovedWorkingHour = sumApprovedWorkingHour.add(auxiliaryWorkingHoursDay.getReviewerNonproductiveTime());//澶嶆牳宸ユ椂 + } + } + map.put("杈呭姪宸ユ椂姹囨��", sumApprovedWorkingHour); + return map; + } + + //瀵煎嚭 + @Override + public void exportWorkingHours(HttpServletResponse response) throws IOException { + List<AuxiliaryOutputWorkingHoursDto> auxiliaryOutputWorkingHoursDtos = new ArrayList<>(); + List<AuxiliaryWorkingHoursDayDto> auxiliaryWorkingHoursDayDtos = new ArrayList<>(); + List<Long> ids = new ArrayList<>(); + //鏌ヨ杈呭姪宸ユ椂 + auxiliaryWorkingHoursDayDtos = auxiliaryWorkingHoursDayMapper.selectDataByUser(ids); + //鏌ヨ缁熻宸ユ椂 + auxiliaryOutputWorkingHoursDtos = auxiliaryOutputWorkingHoursMapper.selectDataByUser(ids); + response.setContentType("application/vnd.ms-excel"); + response.setCharacterEncoding("UTF-8"); + // 杩欓噷URLEncoder.encode鍙互闃叉涓枃涔辩爜 褰撶劧鍜宔asyexcel娌℃湁鍏崇郴 + String fileName = URLEncoder.encode("鏃ュ伐鏃剁鐞嗗鍑�", "UTF-8"); + response.setHeader("Content-disposition", "attachment;filename=" + fileName + ".xlsx"); + try { + // 鏂板缓ExcelWriter + ExcelWriter excelWriter = EasyExcel.write(response.getOutputStream()).registerWriteHandler(new LongestMatchColumnWidthStyleStrategy()).build(); + + WriteSheet mainSheet = EasyExcel.writerSheet(0, "杈呭姪宸ユ椂瀵煎嚭").head(AuxiliaryWorkingHoursDayDto.class).build(); + excelWriter.write(auxiliaryWorkingHoursDayDtos, mainSheet); + + WriteSheet mainSheet1 = EasyExcel.writerSheet(1, "浜ч噺宸ユ椂瀵煎嚭").head(AuxiliaryOutputWorkingHoursDto.class).build(); + excelWriter.write(auxiliaryOutputWorkingHoursDtos, mainSheet1); + // 鍏抽棴娴� + excelWriter.finish(); + } catch (IOException e) { + throw new RuntimeException("瀵煎嚭澶辫触"); + } + } + + /** + * 瀵煎嚭浜ч噺宸ユ椂 + * @param response + */ + @Override + public void exportOutputHours(AuxiliaryOutputWorkingHoursDto auxiliaryOutputWorkingHoursDto, HttpServletResponse response) { + //鏌ヨ瀵煎嚭鐨勮垂鐢ㄧ粺璁℃暟鎹� + String dates = auxiliaryOutputWorkingHoursDto.getDateTime(); + String week = auxiliaryOutputWorkingHoursDto.getWeek(); + auxiliaryOutputWorkingHoursDto.setDateTime(null); + auxiliaryOutputWorkingHoursDto.setWeek(null); + + List<Long> ids = new ArrayList<>(); + String name = auxiliaryOutputWorkingHoursDto.getName(); + if (ObjectUtils.isNotEmpty(name)) { + ids.addAll(userMapper.selectList(Wrappers.<User>lambdaQuery().like(User::getName, name)).stream().map(User::getId).collect(Collectors.toList())); + } + + List<AuxiliaryOutputWorkingHoursDto> auxiliaryOutputWorkingHoursDtoIPage = new ArrayList<>(); + if (ObjectUtils.isNotEmpty(dates) && ObjectUtils.isNotEmpty(week)) { + String[] split = dates.replaceAll("\\[", "").replaceAll("]", "").replaceAll("\"", "").split(","); + String[] weeks = week.replaceAll("\\[", "").replaceAll("]", "").replaceAll("\"", "").split(","); + auxiliaryOutputWorkingHoursDtoIPage = auxiliaryOutputWorkingHoursMapper.selectAuxiliaryOutputWorkingHoursList(QueryWrappers.queryWrappers(auxiliaryOutputWorkingHoursDto) + .ge("date_time", split[0]).le("date_time", split[1] + " 23:59:59") + .ge("week", weeks[0]).le("week", weeks[1]), ids); + + } else if (ObjectUtils.isNotEmpty(dates) && ObjectUtils.isEmpty(week)) { + String[] split = dates.replaceAll("\\[", "").replaceAll("]", "").replaceAll("\"", "").split(","); + auxiliaryOutputWorkingHoursDtoIPage = auxiliaryOutputWorkingHoursMapper.selectAuxiliaryOutputWorkingHoursList(QueryWrappers.queryWrappers(auxiliaryOutputWorkingHoursDto) + .ge("date_time", split[0]).le("date_time", split[1] + " 23:59:59"), ids); + + } else if (ObjectUtils.isEmpty(dates) && ObjectUtils.isNotEmpty(week)) { + String[] weeks = week.replaceAll("\\[", "").replaceAll("]", "").replaceAll("\"", "").split(","); + auxiliaryOutputWorkingHoursDtoIPage = auxiliaryOutputWorkingHoursMapper.selectAuxiliaryOutputWorkingHoursList(QueryWrappers.queryWrappers(auxiliaryOutputWorkingHoursDto) + .ge("week", weeks[0]).le("week", weeks[1]), ids); + + } else { + auxiliaryOutputWorkingHoursDtoIPage = auxiliaryOutputWorkingHoursMapper.selectAuxiliaryOutputWorkingHoursList(QueryWrappers.queryWrappers(auxiliaryOutputWorkingHoursDto), ids); + } + + try { + response.setContentType("application/vnd.ms-excel"); + response.setCharacterEncoding("UTF-8"); + // 杩欓噷URLEncoder.encode鍙互闃叉涓枃涔辩爜 褰撶劧鍜宔asyexcel娌℃湁鍏崇郴 + String fileName = URLEncoder.encode("浜ч噺宸ユ椂淇℃伅瀵煎嚭", "UTF-8"); + response.setHeader("Content-disposition", "attachment;filename=" + fileName + ".xlsx"); + //鏂板缓ExcelWriter + ExcelWriter excelWriter = EasyExcel.write(response.getOutputStream()).registerWriteHandler(new LongestMatchColumnWidthStyleStrategy()).build(); + //鑾峰彇sheet0瀵硅薄 + WriteSheet mainSheet = EasyExcel.writerSheet(0, "浜ч噺宸ユ椂淇℃伅瀵煎嚭").head(AuxiliaryOutputWorkingHoursDto.class).build(); + + //鍚憇heet0鍐欏叆鏁版嵁 浼犲叆绌簂ist杩欐牱鍙鍑鸿〃澶� + excelWriter.write(auxiliaryOutputWorkingHoursDtoIPage, mainSheet); + //鍏抽棴娴� + excelWriter.finish(); + } catch (IOException e) { + throw new RuntimeException("瀵煎嚭澶辫触"); + } + } +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/service/impl/AuxiliaryWorkingHoursDayServiceImpl.java b/performance-server/src/main/java/com/ruoyi/performance/service/impl/AuxiliaryWorkingHoursDayServiceImpl.java new file mode 100644 index 0000000..55fa4c2 --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/service/impl/AuxiliaryWorkingHoursDayServiceImpl.java @@ -0,0 +1,232 @@ +package com.ruoyi.performance.service.impl; + +import com.alibaba.excel.EasyExcel; +import com.alibaba.excel.ExcelWriter; +import com.alibaba.excel.write.metadata.WriteSheet; +import com.alibaba.excel.write.style.column.LongestMatchColumnWidthStyleStrategy; +import com.baomidou.mybatisplus.core.metadata.IPage; +import com.baomidou.mybatisplus.core.toolkit.ObjectUtils; +import com.baomidou.mybatisplus.core.toolkit.Wrappers; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; +import com.ruoyi.common.core.domain.entity.User; +import com.ruoyi.common.exception.base.BaseException; +import com.ruoyi.common.utils.QueryWrappers; +import com.ruoyi.common.utils.SecurityUtils; +import com.ruoyi.performance.dto.AuxiliaryWorkingHoursDayDto; +import com.ruoyi.performance.dto.HoursDay; +import com.ruoyi.performance.mapper.AuxiliaryWorkingHoursDayMapper; +import com.ruoyi.performance.mapper.AuxiliaryWorkingHoursMapper; +import com.ruoyi.performance.mapper.PerformanceShiftMapper; +import com.ruoyi.performance.pojo.AuxiliaryWorkingHours; +import com.ruoyi.performance.pojo.AuxiliaryWorkingHoursDay; +import com.ruoyi.performance.pojo.PerformanceShift; +import com.ruoyi.performance.service.AuxiliaryWorkingHoursDayService; +import com.ruoyi.system.mapper.UserMapper; +import org.apache.commons.math3.analysis.function.Power; +import org.springframework.beans.BeanUtils; +import org.springframework.stereotype.Service; + +import javax.annotation.Resource; +import javax.servlet.http.HttpServletResponse; +import java.io.IOException; +import java.net.URLEncoder; +import java.time.LocalDateTime; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; + +/** + * <p> + * 鏃ュ伐鏃剁鐞嗙殑杈呭姪宸ユ椂 鏈嶅姟瀹炵幇绫� + * </p> + * + * @author 姹熻嫃榈烽洀缃戠粶绉戞妧鏈夐檺鍏徃 + * @since 2024-05-28 02:22:19 + */ +@Service +public class AuxiliaryWorkingHoursDayServiceImpl extends ServiceImpl<AuxiliaryWorkingHoursDayMapper, AuxiliaryWorkingHoursDay> implements AuxiliaryWorkingHoursDayService { + + @Resource + AuxiliaryWorkingHoursDayMapper auxiliaryWorkingHoursDayMapper; + + @Resource + AuxiliaryWorkingHoursMapper auxiliaryWorkingHoursMapper; + + @Resource + UserMapper userMapper; + + @Resource + PerformanceShiftMapper performanceShiftMapper; + + @Override + public IPage<AuxiliaryWorkingHoursDayDto> selectAuxiliaryWorkingHoursDay(Page page, AuxiliaryWorkingHoursDayDto auxiliaryWorkingHoursDayDto) { + String dates = auxiliaryWorkingHoursDayDto.getDateTime(); + String week = auxiliaryWorkingHoursDayDto.getWeek(); + auxiliaryWorkingHoursDayDto.setDateTime(null); + auxiliaryWorkingHoursDayDto.setWeek(null); + Map<String, Object> map = new HashMap<>(); + List<Long> ids = new ArrayList<>(); + if (ids.size() == 0) { + ids = null; + } + if (ObjectUtils.isNotEmpty(dates) && ObjectUtils.isNotEmpty(week)) { + String[] split = dates.replaceAll("\\[", "").replaceAll("]", "").replaceAll("\"", "").split(","); + String[] weeks = week.replaceAll("\\[", "").replaceAll("]", "").replaceAll("\"", "").split(","); + IPage<AuxiliaryWorkingHoursDayDto> auxiliaryWorkingHoursDayDtoIPage = auxiliaryWorkingHoursDayMapper.selectAuxiliaryWorkingHoursDay(page, + QueryWrappers.queryWrappers(auxiliaryWorkingHoursDayDto) + .ge("date_time", split[0]).le("date_time", split[1] + " 23:59:59") + .ge("week", weeks[0]).le("week", weeks[1]), ids); + for (AuxiliaryWorkingHoursDayDto record : auxiliaryWorkingHoursDayDtoIPage.getRecords()) { + record.setDateTime(record.getDateTime().substring(0, 10)); + } + return auxiliaryWorkingHoursDayDtoIPage; + } else if (ObjectUtils.isNotEmpty(dates) && ObjectUtils.isEmpty(week)) { + String[] split = dates.replaceAll("\\[", "").replaceAll("]", "").replaceAll("\"", "").split(","); + IPage<AuxiliaryWorkingHoursDayDto> auxiliaryWorkingHoursDayDtoIPage = auxiliaryWorkingHoursDayMapper.selectAuxiliaryWorkingHoursDay(page, + QueryWrappers.queryWrappers(auxiliaryWorkingHoursDayDto) + .ge("date_time", split[0]).le("date_time", split[1] + " 23:59:59"), ids); + for (AuxiliaryWorkingHoursDayDto record : auxiliaryWorkingHoursDayDtoIPage.getRecords()) { + record.setDateTime(record.getDateTime().substring(0, 10)); + } + return auxiliaryWorkingHoursDayDtoIPage; + } else if (ObjectUtils.isEmpty(dates) && ObjectUtils.isNotEmpty(week)) { + String[] weeks = week.replaceAll("\\[", "").replaceAll("]", "").replaceAll("\"", "").split(","); + IPage<AuxiliaryWorkingHoursDayDto> auxiliaryWorkingHoursDayDtoIPage = auxiliaryWorkingHoursDayMapper.selectAuxiliaryWorkingHoursDay(page, + QueryWrappers.queryWrappers(auxiliaryWorkingHoursDayDto) + .ge("week", weeks[0]).le("week", weeks[1]), ids); + for (AuxiliaryWorkingHoursDayDto record : auxiliaryWorkingHoursDayDtoIPage.getRecords()) { + record.setDateTime(record.getDateTime().substring(0, 10)); + } + return auxiliaryWorkingHoursDayDtoIPage; + } else { + IPage<AuxiliaryWorkingHoursDayDto> auxiliaryWorkingHoursDayDtoIPage = auxiliaryWorkingHoursDayMapper.selectAuxiliaryWorkingHoursDay(page, QueryWrappers.queryWrappers(auxiliaryWorkingHoursDayDto), ids); + for (AuxiliaryWorkingHoursDayDto record : auxiliaryWorkingHoursDayDtoIPage.getRecords()) { + record.setDateTime(record.getDateTime().substring(0, 10)); + } + return auxiliaryWorkingHoursDayDtoIPage; + } + + } + + //鏍规嵁缂栧彿鏌ヨ杈呭姪宸ユ椂閰嶇疆淇℃伅 + @Override + public AuxiliaryWorkingHoursDay selectAuxiliaryWorkingHoursByNumber(String number) { + //鏍规嵁濉啓鐨勭紪鍙锋煡璇㈣緟鍔╁伐鏃堕厤缃� + AuxiliaryWorkingHours auxiliaryWorkingHours = auxiliaryWorkingHoursMapper.selectOne(Wrappers.<AuxiliaryWorkingHours>lambdaQuery().eq(AuxiliaryWorkingHours::getNumber, number)); + if (ObjectUtils.isEmpty(auxiliaryWorkingHours)) { + throw new BaseException("璇ョ紪鍙锋病鏈夊搴旂殑杈呭姪宸ユ椂閰嶇疆"); + } + AuxiliaryWorkingHoursDay auxiliaryWorkingHoursDay = new AuxiliaryWorkingHoursDay(); + BeanUtils.copyProperties(auxiliaryWorkingHours, auxiliaryWorkingHoursDay); + return auxiliaryWorkingHoursDay; + } + + //褰曞叆鏁版嵁(鏂板) + @Override + public int insertAuxiliaryWorkingHoursDay(AuxiliaryWorkingHoursDay auxiliaryWorkingHoursDay) { + Integer userId = SecurityUtils.getUserId().intValue(); + auxiliaryWorkingHoursDay.setNameUser(userId);//濮撳悕id + auxiliaryWorkingHoursDay.setState("宸叉彁浜�"); + return auxiliaryWorkingHoursDayMapper.insert(auxiliaryWorkingHoursDay); + } + + //瀹℃牳/鎵瑰噯 + @Override + public boolean checkOrApprove(HoursDay hoursDay) { + List<AuxiliaryWorkingHoursDay> auxiliaryWorkingHoursDays = hoursDay.getAuxiliaryWorkingHoursDays(); + for (AuxiliaryWorkingHoursDay auxiliaryWorkingHoursDay : auxiliaryWorkingHoursDays) { + Integer userId = SecurityUtils.getUserId().intValue(); + auxiliaryWorkingHoursDay.setReviewer(userMapper.selectById(userId).getName()); + if (auxiliaryWorkingHoursDay.getReviewerNumber() == null) { + auxiliaryWorkingHoursDay.setReviewerNumber(auxiliaryWorkingHoursDay.getAmount());//澶嶆牳鏁伴噺 + auxiliaryWorkingHoursDay.setReviewerNonproductiveTime(auxiliaryWorkingHoursDay.getNonproductiveTime());//澶嶆牳宸ユ椂 + } + } + return updateBatchById(auxiliaryWorkingHoursDays); + } + + //缂栬緫 + @Override + public int updateAuxiliaryWorkingHoursDay(AuxiliaryWorkingHoursDay auxiliaryWorkingHoursDay) { + Integer userId = SecurityUtils.getUserId().intValue(); + auxiliaryWorkingHoursDay.setNameUser(userId);//濮撳悕id + return auxiliaryWorkingHoursDayMapper.updateById(auxiliaryWorkingHoursDay); + } + + //鍒犻櫎 + @Override + public int deleteAuxiliaryWorkingHoursDay(Integer id) { + return auxiliaryWorkingHoursDayMapper.deleteById(id); + } + + //鏍规嵁缂栧彿褰撳墠鐢ㄦ埛淇℃伅鏌ヨ鎵�鍦ㄧ彮娆� + @Override + public String selectshiftByUser(LocalDateTime dateTime) { + Integer userId = SecurityUtils.getUserId().intValue(); + PerformanceShift performanceShift = performanceShiftMapper.selectOne(Wrappers.<PerformanceShift>lambdaQuery().eq(PerformanceShift::getUserId, userId).eq(PerformanceShift::getWorkTime, dateTime)); + if (ObjectUtils.isEmpty(performanceShift)) { + return null; + } + return performanceShift.getShift(); + } + + /** + * 瀵煎嚭杈呭姪宸ユ椂 + * @param + * @param response + */ + @Override + public void exportWorkingHours(AuxiliaryWorkingHoursDayDto auxiliaryWorkingHoursDayDto, HttpServletResponse response) { + String dates = auxiliaryWorkingHoursDayDto.getDateTime(); + String week = auxiliaryWorkingHoursDayDto.getWeek(); + auxiliaryWorkingHoursDayDto.setDateTime(null); + auxiliaryWorkingHoursDayDto.setWeek(null); + List<Long> ids = new ArrayList<>(); + String name = auxiliaryWorkingHoursDayDto.getName(); + if (ObjectUtils.isNotEmpty(name)) { + ids.addAll(userMapper.selectList(Wrappers.<User>lambdaQuery().like(User::getName, name)).stream().map(User::getId).collect(Collectors.toList())); + } + List<AuxiliaryWorkingHoursDayDto> auxiliaryWorkingHoursDayDtoIPage = new ArrayList<>(); + if (ObjectUtils.isNotEmpty(dates) && ObjectUtils.isNotEmpty(week)) { + String[] split = dates.replaceAll("\\[", "").replaceAll("]", "").replaceAll("\"", "").split(","); + String[] weeks = week.replaceAll("\\[", "").replaceAll("]", "").replaceAll("\"", "").split(","); + auxiliaryWorkingHoursDayDtoIPage = auxiliaryWorkingHoursDayMapper.selectAuxiliaryWorkingHoursDayList(QueryWrappers.queryWrappers(auxiliaryWorkingHoursDayDto) + .ge("date_time", split[0]).le("date_time", split[1] + " 23:59:59") + .ge("week", weeks[0]).le("week", weeks[1]), ids); + } else if (ObjectUtils.isNotEmpty(dates) && ObjectUtils.isEmpty(week)) { + String[] split = dates.replaceAll("\\[", "").replaceAll("]", "").replaceAll("\"", "").split(","); + auxiliaryWorkingHoursDayDtoIPage = auxiliaryWorkingHoursDayMapper.selectAuxiliaryWorkingHoursDayList(QueryWrappers.queryWrappers(auxiliaryWorkingHoursDayDto) + .ge("date_time", split[0]).le("date_time", split[1] + " 23:59:59"), ids); + } else if (ObjectUtils.isEmpty(dates) && ObjectUtils.isNotEmpty(week)) { + String[] weeks = week.replaceAll("\\[", "").replaceAll("]", "").replaceAll("\"", "").split(","); + auxiliaryWorkingHoursDayDtoIPage = auxiliaryWorkingHoursDayMapper.selectAuxiliaryWorkingHoursDayList(QueryWrappers.queryWrappers(auxiliaryWorkingHoursDayDto) + .ge("week", weeks[0]).le("week", weeks[1]), ids); + } else { + auxiliaryWorkingHoursDayDtoIPage = auxiliaryWorkingHoursDayMapper.selectAuxiliaryWorkingHoursDayList( QueryWrappers.queryWrappers(auxiliaryWorkingHoursDayDto), ids); + } + + try { + response.setContentType("application/vnd.ms-excel"); + response.setCharacterEncoding("UTF-8"); + // 杩欓噷URLEncoder.encode鍙互闃叉涓枃涔辩爜 褰撶劧鍜宔asyexcel娌℃湁鍏崇郴 + String fileName = URLEncoder.encode("杈呭姪宸ユ椂淇℃伅瀵煎嚭", "UTF-8"); + response.setHeader("Content-disposition", "attachment;filename=" + fileName + ".xlsx"); + //鏂板缓ExcelWriter + ExcelWriter excelWriter = EasyExcel.write(response.getOutputStream()).registerWriteHandler(new LongestMatchColumnWidthStyleStrategy()).build(); + //鑾峰彇sheet0瀵硅薄 + WriteSheet mainSheet = EasyExcel.writerSheet(0, "杈呭姪宸ユ椂淇℃伅瀵煎嚭").head(AuxiliaryWorkingHoursDayDto.class).build(); + + //鍚憇heet0鍐欏叆鏁版嵁 浼犲叆绌簂ist杩欐牱鍙鍑鸿〃澶� + excelWriter.write(auxiliaryWorkingHoursDayDtoIPage, mainSheet); + //鍏抽棴娴� + excelWriter.finish(); + } catch (IOException e) { + throw new RuntimeException("瀵煎嚭澶辫触"); + } + } + + +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/service/impl/AuxiliaryWorkingHoursServiceImpl.java b/performance-server/src/main/java/com/ruoyi/performance/service/impl/AuxiliaryWorkingHoursServiceImpl.java new file mode 100644 index 0000000..9863d69 --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/service/impl/AuxiliaryWorkingHoursServiceImpl.java @@ -0,0 +1,55 @@ +package com.ruoyi.performance.service.impl; + +import com.baomidou.mybatisplus.core.metadata.IPage; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; +import com.ruoyi.common.utils.QueryWrappers; +import com.ruoyi.performance.mapper.AuxiliaryWorkingHoursMapper; +import com.ruoyi.performance.pojo.AuxiliaryWorkingHours; +import com.ruoyi.performance.service.AuxiliaryWorkingHoursService; +import org.springframework.stereotype.Service; + +import javax.annotation.Resource; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; + +/** + * <p> + * 杈呭姪宸ユ椂 鏈嶅姟瀹炵幇绫� + * </p> + * + * @author 姹熻嫃榈烽洀缃戠粶绉戞妧鏈夐檺鍏徃 + * @since 2024-05-09 06:58:31 + */ +@Service +public class AuxiliaryWorkingHoursServiceImpl extends ServiceImpl<AuxiliaryWorkingHoursMapper, AuxiliaryWorkingHours> implements AuxiliaryWorkingHoursService { + + @Resource + private AuxiliaryWorkingHoursMapper auxiliaryWorkingHoursMapper; + @Override + public IPage<AuxiliaryWorkingHours> selectAuxiliaryWorkingHours(Page page, AuxiliaryWorkingHours auxiliaryWorkingHours) { + return auxiliaryWorkingHoursMapper.selectAuxiliaryWorkingHours(page, QueryWrappers.queryWrappers(auxiliaryWorkingHours)); + } + + @Override + public int deleteAuxiliaryWorkingHours(Integer id) { + return auxiliaryWorkingHoursMapper.deleteById(id); + } + + @Override + public int upAuxiliaryWorkingHours(AuxiliaryWorkingHours auxiliaryWorkingHours) { + return auxiliaryWorkingHoursMapper.updateById(auxiliaryWorkingHours); + } + + @Override + public int insertAuxiliaryWorkingHours(AuxiliaryWorkingHours auxiliaryWorkingHours) { + //缂栧彿涓嶈兘閲嶅 + List<String> strings = auxiliaryWorkingHoursMapper.selectList(null).stream().map(AuxiliaryWorkingHours::getNumber).distinct().collect(Collectors.toList()); + if (strings.contains(auxiliaryWorkingHours.getNumber())){ + throw new RuntimeException("缂栧彿涓嶈兘閲嶅!"); + } + return auxiliaryWorkingHoursMapper.insert(auxiliaryWorkingHours); + } +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/service/impl/PerformanceShiftServiceImpl.java b/performance-server/src/main/java/com/ruoyi/performance/service/impl/PerformanceShiftServiceImpl.java new file mode 100644 index 0000000..966317f --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/service/impl/PerformanceShiftServiceImpl.java @@ -0,0 +1,563 @@ +package com.ruoyi.performance.service.impl; + +import cn.hutool.core.date.DateTime; +import cn.hutool.core.date.DateUtil; +import com.baomidou.mybatisplus.core.metadata.IPage; +import com.baomidou.mybatisplus.core.toolkit.Wrappers; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; +import com.ruoyi.common.core.domain.entity.SysDictData; +import com.ruoyi.common.core.domain.entity.User; +import com.ruoyi.common.utils.JackSonUtil; +import com.ruoyi.common.utils.SecurityUtils; +import com.ruoyi.performance.dto.PerformanceShiftAddDto; +import com.ruoyi.performance.dto.PerformanceShiftMapDto; +import com.ruoyi.performance.mapper.PerformanceShiftMapper; +import com.ruoyi.performance.pojo.PerformanceShift; +import com.ruoyi.performance.service.PerformanceShiftService; +import com.ruoyi.system.mapper.UserMapper; +import com.ruoyi.system.service.ISysDictTypeService; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; +import org.springframework.util.ObjectUtils; + +import java.math.BigDecimal; +import java.text.SimpleDateFormat; +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.ZoneId; +import java.time.format.DateTimeFormatter; +import java.time.temporal.TemporalAdjusters; +import java.util.*; + +/** + * <p> + * 缁╂晥绠$悊-鐝 鏈嶅姟瀹炵幇绫� + * </p> + * + * @author 姹熻嫃榈烽洀缃戠粶绉戞妧鏈夐檺鍏徃 + * @since 2024-05-08 09:12:04 + */ +@Service +public class PerformanceShiftServiceImpl extends ServiceImpl<PerformanceShiftMapper, PerformanceShift> implements PerformanceShiftService { + + @Autowired + private ISysDictTypeService dictTypeService; + + @Autowired + UserMapper userMapper; + + @Transactional(rollbackFor = Exception.class) + @Override + public void performanceShiftAdd(PerformanceShiftAddDto performanceShiftAddDto) { + List<PerformanceShift> list = new ArrayList<>(); + LocalDateTime startWeek = performanceShiftAddDto.getStartWeek(); + LocalDateTime endWeek = performanceShiftAddDto.getEndWeek(); + + + DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd"); + String formattedDateTime = performanceShiftAddDto.getStartWeek().format(formatter); + String[] splitUserId = performanceShiftAddDto.getUserId().split(","); + for (String userId : splitUserId) { + //鍒ゆ柇鏄惁璺ㄦ湀 + boolean isMonth = startWeek.getMonthValue() != endWeek.getMonthValue(); + if (isMonth){ + //濡傛灉璺ㄦ湀,鍒欎袱涓湀閮藉垽鏂竴涓嬬湅鏁版嵁搴撴槸鍝釜鏈堜唤鐨勬暟鎹病鏈� + boolean exists1 = baseMapper.exists(Wrappers.<PerformanceShift>lambdaQuery() + .eq(PerformanceShift::getWorkTime, startWeek) + .eq(PerformanceShift::getUserId, userId)); + boolean exists2 = baseMapper.exists(Wrappers.<PerformanceShift>lambdaQuery() + .eq(PerformanceShift::getWorkTime, endWeek) + .eq(PerformanceShift::getUserId, userId)); + if (!exists1 && !exists2){ + //涓や釜鏈堥兘涓嶅瓨鍦ㄦ暟鎹� + list = saveMonth(performanceShiftAddDto.getStartWeek(), userId, list); + list = saveMonth(performanceShiftAddDto.getEndWeek(), userId, list); + }else if (!exists1 && exists2){ + //寮�濮嬬殑鏈堜唤涓嶅瓨鍦ㄦ暟鎹� + list = saveMonth(performanceShiftAddDto.getStartWeek(), userId, list); + }else if (exists1 && !exists2){ + //缁撴潫鐨勬湀浠戒笉瀛樺湪鏁版嵁 + list = saveMonth(performanceShiftAddDto.getEndWeek(), userId, list); + } + }else { + //涓嶈法鏈� + boolean exists = baseMapper.exists(Wrappers.<PerformanceShift>lambdaQuery() + .in(PerformanceShift::getWorkTime, formattedDateTime) + .eq(PerformanceShift::getUserId, userId)); + // 濡傛灉涓嶅瓨鍦ㄦ坊鍔犳暟鎹� + if (!exists) { + list = saveMonth(performanceShiftAddDto.getEndWeek(), userId, list); + } + } + } + if (!list.isEmpty()) { + baseMapper.insertBatchSomeColumn(list); + list.clear(); + } + // 鍐嶆鏇存柊 + List<LocalDateTime> datesBetween = getLocalDateTimesBetween(performanceShiftAddDto.getStartWeek(), performanceShiftAddDto.getEndWeek()); + for (LocalDateTime date : datesBetween) { + for (String s : splitUserId) { + PerformanceShift performanceShift = new PerformanceShift(); + performanceShift.setShift(performanceShiftAddDto.getShift()); + performanceShift.setUserId(Integer.valueOf(s)); + performanceShift.setWorkTime(date); + String formatterDateTime = date.format(formatter); + baseMapper.update(new PerformanceShift(), Wrappers.<PerformanceShift>lambdaUpdate() + .set(PerformanceShift::getShift, performanceShiftAddDto.getShift()) + .eq(PerformanceShift::getUserId, s) + .eq(PerformanceShift::getWorkTime, formatterDateTime)); + } + } + } + + private List<PerformanceShift> saveMonth (LocalDateTime week,String userId,List<PerformanceShift> list){ + LocalDate firstDayOfMonth = week.toLocalDate().withDayOfMonth(1); + LocalDate lastDayOfMonth = week.toLocalDate().with(TemporalAdjusters.lastDayOfMonth()); + List<LocalDateTime> localDateTimesBetween = getLocalDateTimesBetween(firstDayOfMonth.atStartOfDay(), lastDayOfMonth.atStartOfDay()); + localDateTimesBetween.forEach(i -> { + PerformanceShift performanceShift = new PerformanceShift(); + performanceShift.setUserId(Integer.valueOf(userId)); + performanceShift.setWorkTime(i); + performanceShift.setShift(""); + list.add(performanceShift); + if (list.size() >= 1000) { + baseMapper.insertBatchSomeColumn(list); + list.clear(); + } + }); + return list; + } + + @Override + public Map<String, Object> performanceShiftPage(Page<Object> page, String time, String userName, String laboratory) { + //鏌ヨ褰撳墠鐧诲綍浜哄憳鐨勬灦鏋� + Integer userId = SecurityUtils.getUserId().intValue(); + //鍒ゆ柇鍏ㄩ儴,涓汉,缁勭粐鐨勬潈闄� + User user = userMapper.selectById(userId);//褰撳墠鐧诲綍鐨勪汉 + //鑾峰彇褰撳墠浜烘墍灞炲疄楠屽id + String departLimsId = user.getDepartLimsId(); + if (com.baomidou.mybatisplus.core.toolkit.ObjectUtils.isNotEmpty(departLimsId) && !departLimsId.equals("")) { + String[] split = departLimsId.split(","); + //鏌ヨ瀵瑰簲鏋舵瀯鍚嶇О(閫氫俊瀹為獙瀹�,鐢靛姏瀹為獙瀹�,妫�娴嬪姙) + String departLims = baseMapper.seldepLimsId(Integer.parseInt(split[split.length - 1])); + if (departLims.contains("瀹為獙瀹�")) { + laboratory = departLims; + } + } + IPage<PerformanceShiftMapDto> mapIPage = baseMapper.performanceShiftPage(page, time, userName, laboratory); + + List<SysDictData> shiftType = dictTypeService.selectDictDataByName("鐝绫诲瀷"); + List<Map<String, Object>> mapYearIPage = baseMapper.performanceShiftYearPage(time, userName, laboratory); + mapIPage.getRecords().forEach(i -> { + String[] shiftTimes = i.getShiftTime().split(";"); + double totalAttendance = 0; + List<Map<String, Object>> map = new ArrayList<>(); + // 鍒嗗壊鏃ユ湡 + for (String shiftTime : shiftTimes) { + Map<String, Object> hashMap = new HashMap<>(); + String[] shiftTimeAndShift = shiftTime.split("锛�"); + for (SysDictData enums : shiftType) { + if (!i.getMonthlyAttendance().containsKey(enums.getDictLabel())) { + i.getMonthlyAttendance().put(enums.getDictLabel(), 0); + } + if (enums.getDictValue().equals(shiftTimeAndShift[1])) { + BigDecimal bigDecimal = new BigDecimal(i.getMonthlyAttendance().get(enums.getDictLabel()).toString()); + i.getMonthlyAttendance().put(enums.getDictLabel(), bigDecimal.add(new BigDecimal("1"))); + } + // 鍗婏紝鍙﹀鍗婂ぉ绠楃粰鏃� + if (shiftTimeAndShift[1].equals("5") && enums.getDictValue().equals("0")) { + BigDecimal bigDecimal = new BigDecimal(i.getMonthlyAttendance().get(enums.getDictLabel()).toString()); + i.getMonthlyAttendance().put(enums.getDictLabel(), bigDecimal.add(new BigDecimal("0.5"))); + } + } + // 鏃╋紝涓紝澶滐紝宸� + if (shiftTimeAndShift[1].equals("1") || shiftTimeAndShift[1].equals("2") || shiftTimeAndShift[1].equals("0") || shiftTimeAndShift[1].equals("6")) { + i.getMonthlyAttendance().put("totalAttendance", totalAttendance += 1); + } + // 鍗� + if (shiftTimeAndShift[1].equals("5")) { + i.getMonthlyAttendance().put("totalAttendance", totalAttendance += 0.5); + } + hashMap.put("id", shiftTimeAndShift[2]); + hashMap.put("shift", shiftTimeAndShift[1]); + hashMap.put("time", shiftTimeAndShift[0]); + map.add(hashMap); + } + double totalYearAttendance = 0; + Map<String, Object> hashMap = new HashMap<>(); + for (Map<String, Object> record : mapYearIPage) { + if (record.get("user_id").toString().equals(i.getUserId())) { + for (SysDictData enums : shiftType) { + if (!hashMap.containsKey(enums.getDictLabel())) { + hashMap.put(enums.getDictLabel(), 0); + } + if (enums.getDictValue().equals(record.get("shift"))) { + BigDecimal num = new BigDecimal(hashMap.get(enums.getDictLabel()).toString()); + hashMap.put(enums.getDictLabel(), num.add(new BigDecimal("1"))); + } + // 鍗婏紝鍙﹀鍗婂ぉ绠楃粰鏃� + if (record.get("shift").equals("5") && enums.getDictValue().equals("0")) { + BigDecimal bigDecimal = new BigDecimal(hashMap.get(enums.getDictLabel()).toString()); + hashMap.put(enums.getDictLabel(), bigDecimal.add(new BigDecimal("0.5"))); + } + } + if (record.get("shift").equals("1") || record.get("shift").equals("2") || record.get("shift").equals("0") || record.get("shift").equals("6")) { + hashMap.put("totalAttendance", totalYearAttendance += 1); + } + // 鍗� + if (record.get("shift").equals("5")) { + hashMap.put("totalAttendance", totalYearAttendance += 0.5); + } + } + } + i.setSidebarAnnualAttendance(hashMap); + i.setList(map); + i.setShiftTime(null); + }); + // 鑾峰彇header鏃堕棿 + DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd"); + DateTimeFormatter formatters = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); + // 灏嗗瓧绗︿覆鏃堕棿杞崲涓� LocalDateTime 绫诲瀷鏃堕棿 + LocalDateTime localDateTime = LocalDateTime.parse(time, formatters); + LocalDate firstDayOfMonth = localDateTime.toLocalDate().withDayOfMonth(1); + LocalDate lastDayOfMonth = localDateTime.toLocalDate().with(TemporalAdjusters.lastDayOfMonth()); + List<LocalDateTime> localDateTimesBetween = getLocalDateTimesBetween(firstDayOfMonth.atStartOfDay(), lastDayOfMonth.atStartOfDay()); + List<Object> list1 = new ArrayList<>(); + for (LocalDateTime dateTime : localDateTimesBetween) { + Map<Object, Object> hashMap = new HashMap<>(); + DateTime parse = DateUtil.parse(dateTime.format(formatter)); + hashMap.put("weekly", DateUtil.weekOfYear(DateUtil.offsetDay(parse, 1))); + hashMap.put("headerTime", getWeek(dateTime.format(formatters))); + list1.add(hashMap); + } + Map<String, Object> resultMap = new HashMap<>(); + resultMap.put("page", mapIPage); + resultMap.put("headerList", list1); + return resultMap; + } + + @Override + public void performanceShiftUpdate(PerformanceShift performanceShift) { + baseMapper.update(new PerformanceShift(), Wrappers.<PerformanceShift>lambdaUpdate() + .eq(PerformanceShift::getId, performanceShift.getId()) + .set(PerformanceShift::getShift, performanceShift.getShift())); + } + + @Override + public IPage<Map<String, Object>> performanceShiftPageYear(Page<Object> page, String time, String userName, String laboratory) { + //鏌ヨ褰撳墠鐧诲綍浜哄憳鐨勬灦鏋� + Integer userId = SecurityUtils.getUserId().intValue(); + //鍒ゆ柇鍏ㄩ儴,涓汉,缁勭粐鐨勬潈闄� + User user = userMapper.selectById(userId);//褰撳墠鐧诲綍鐨勪汉 + //鑾峰彇褰撳墠浜烘墍灞炲疄楠屽id + String departLimsId = user.getDepartLimsId(); + if (com.baomidou.mybatisplus.core.toolkit.ObjectUtils.isNotEmpty(departLimsId) && !departLimsId.equals("")) { + String[] split = departLimsId.split(","); + //鏌ヨ瀵瑰簲鏋舵瀯鍚嶇О(閫氫俊瀹為獙瀹�,鐢靛姏瀹為獙瀹�,妫�娴嬪姙) + String departLims = baseMapper.seldepLimsId(Integer.parseInt(split[split.length - 1])); + if (departLims.contains("瀹為獙瀹�")) { + laboratory = departLims; + } + } + IPage<Map<String, Object>> mapYearIPage = baseMapper.performanceShiftYear(page, time, userName, laboratory); + List<SysDictData> shiftType = dictTypeService.selectDictDataByName("鐝绫诲瀷"); + mapYearIPage.setRecords(annualAttendanceProcessing(mapYearIPage.getRecords(), shiftType)); + return mapYearIPage; + } + + // 骞村垎椤典笌瀵煎嚭鍏卞悓浣跨敤 + public List<Map<String, Object>> annualAttendanceProcessing(List<Map<String, Object>> mapYearList, List<SysDictData> shiftType) { + for (Map<String, Object> map : mapYearList) { + Map<String, Object> resultMap = new LinkedHashMap<>(); + Map<String, Object> hashMapYear = new LinkedHashMap<>(); + double totalYearAttendance = 0; + // 涓�骞�12涓湀 + for (int i = 1; i < 13; i++) { + Map<String, Object> hashMapMonth = new LinkedHashMap<>(); + double totalMonthAttendance = 0; + for (SysDictData shift : shiftType) { + // 鍒濆鍖栬祴鍊� + if (!hashMapYear.containsKey(shift.getDictLabel())) { + hashMapYear.put(shift.getDictLabel(), 0); + } + // 鏈� + if (!ObjectUtils.isEmpty(map.get("month_str"))) { + String charArray = map.get("month_str").toString(); + int count = countOccurrences(charArray, i + "锛�" + shift.getDictValue()); + hashMapMonth.put(shift.getDictLabel(), count); + hashMapYear.put(shift.getDictLabel(), new BigDecimal(hashMapYear.get(shift.getDictLabel()).toString()).add(new BigDecimal(count))); + // 鏃╋紝涓紝澶滐紝宸� + if (shift.getDictValue().equals("0") || shift.getDictValue().equals("1") || shift.getDictValue().equals("2") || shift.getDictValue().equals("6")) { + totalMonthAttendance += count; + totalYearAttendance += count; + } +// 鍗婏紝鍙﹀鍗婂ぉ绠楃粰鏃� + if (shift.getDictValue().equals("5")) { + BigDecimal multiply = new BigDecimal("0.5").multiply(new BigDecimal(count)).setScale(1, BigDecimal.ROUND_CEILING); + hashMapMonth.put(shiftType.get(0).getDictLabel(), new BigDecimal(hashMapMonth.get(shiftType.get(0).getDictLabel()).toString()).add(multiply)); + hashMapYear.put(shiftType.get(0).getDictLabel(), new BigDecimal(hashMapYear.get(shiftType.get(0).getDictLabel()).toString()).add(multiply)); + totalMonthAttendance += multiply.doubleValue(); + totalYearAttendance += multiply.doubleValue(); + } + } + // 绌烘暟鎹� + else { + map.put("work_time", i); + hashMapMonth.put(shift.getDictLabel(), 0); + } + } + hashMapMonth.put("totalMonthAttendance", totalMonthAttendance); + hashMapYear.put("totalYearAttendance", totalYearAttendance); + resultMap.put(i + "", hashMapMonth); + } + map.remove("month_str"); + map.remove("year_str"); + map.put("year", hashMapYear); + map.put("month", resultMap); + } + return mapYearList; + } + + public static int countOccurrences(String str, String target) { + int count = 0; + int index = 0; + while ((index = str.indexOf(target, index)) != -1) { + count++; + index += target.length(); + } + return count; + } + + public List<List<Object>> dataRequiredForProcessingIntoExcel(List<Map<String, Object>> list, List<SysDictData> enums) throws Exception { + List<List<Object>> data = new ArrayList<>(); + for (int i = 0; i < list.size(); i++) { + List<Object> excelRowList = new ArrayList<>(); + excelRowList.add(i + 1); + excelRowList.add(list.get(i).get("account")); + excelRowList.add(list.get(i).get("name")); + Map<String, Object> year = JackSonUtil.unmarshal(JackSonUtil.marshal(list.get(i).get("year")), Map.class); + excelRowList.add(year.get("totalYearAttendance")); + enums.forEach(j -> { + if (!j.getDictValue().equals("5")) { + excelRowList.add(year.get(j.getDictLabel())); + } + }); + Map<String, Map<String, Object>> month = JackSonUtil.unmarshal(JackSonUtil.marshal(list.get(i).get("month")), Map.class); + for (int j = 1; j < 13; j++) { + Object totalMonthAttendance = month.get(j + "").get("totalMonthAttendance"); + excelRowList.add(totalMonthAttendance); + for (SysDictData anEnum : enums) { + if (!anEnum.getDictValue().equals("5")) { + excelRowList.add(month.get(j + "").get(anEnum.getDictLabel())); + } + } + } + data.add(excelRowList); + } + return data; + } + + @Override + public Map<Object, Object> exportToYearExcel(String time, String userName, String laboratory) throws Exception { + Map<Object, Object> map = new HashMap<>(); + List<SysDictData> shiftType = dictTypeService.selectDictDataByName("鐝绫诲瀷"); + DateTimeFormatter formatters = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); + // 灏嗗瓧绗︿覆鏃堕棿杞崲涓� LocalDateTime 绫诲瀷鏃堕棿 + LocalDateTime localDateTime = LocalDateTime.parse(time, formatters); + map.put("header", getYearHeader(localDateTime.getYear() + " 骞�", shiftType)); + List<Map<String, Object>> mapYearList = baseMapper.performanceShiftYearList(time, userName, laboratory); + annualAttendanceProcessing(mapYearList, shiftType); + List<List<Object>> lists = dataRequiredForProcessingIntoExcel(mapYearList, shiftType); + map.put("data", lists); + return map; + } + + @Override + public Map<Object, Object> exportToMonthExcel(String time, String userName, String laboratory) { + List<SysDictData> shiftType = dictTypeService.selectDictDataByName("鐝绫诲瀷"); + List<PerformanceShiftMapDto> mapIPage = baseMapper.performanceShiftList(time, userName, laboratory); + mapIPage.forEach(i -> { + String[] shiftTimes = i.getShiftTime().split(";"); + double totalAttendance = 0; + List<Map<String, Object>> map = new ArrayList<>(); + // 鍒嗗壊鏃ユ湡 + for (String shiftTime : shiftTimes) { + Map<String, Object> hashMap = new HashMap<>(); + String[] shiftTimeAndShift = shiftTime.split("锛�"); + for (SysDictData enums : shiftType) { + if (!i.getMonthlyAttendance().containsKey(enums.getDictLabel())) { + i.getMonthlyAttendance().put(enums.getDictLabel(), 0); + } + if (enums.getDictValue().equals(shiftTimeAndShift[1])) { + BigDecimal bigDecimal = new BigDecimal(i.getMonthlyAttendance().get(enums.getDictLabel()).toString()); + i.getMonthlyAttendance().put(enums.getDictLabel(), bigDecimal.add(new BigDecimal("1"))); + } + // 鍗婏紝鍙﹀鍗婂ぉ绠楃粰鏃� + if (shiftTimeAndShift[1].equals("5") && enums.getDictValue().equals("0")) { + BigDecimal bigDecimal = new BigDecimal(i.getMonthlyAttendance().get(enums.getDictLabel()).toString()); + i.getMonthlyAttendance().put(enums.getDictLabel(), bigDecimal.add(new BigDecimal("0.5"))); + } + } + // 鏃╋紝涓紝澶滐紝宸� + if (shiftTimeAndShift[1].equals("1") || shiftTimeAndShift[1].equals("2") || shiftTimeAndShift[1].equals("0") || shiftTimeAndShift[1].equals("6")) { + i.getMonthlyAttendance().put("totalAttendance", totalAttendance += 1); + } + // 鍗� + if (shiftTimeAndShift[1].equals("5")) { + i.getMonthlyAttendance().put("totalAttendance", totalAttendance += 0.5); + } + hashMap.put("id", shiftTimeAndShift[2]); + hashMap.put("shift", shiftTimeAndShift[1]); + hashMap.put("time", shiftTimeAndShift[0]); + map.add(hashMap); + } + i.setList(map); + i.setShiftTime(null); + }); + Map<Object, Object> map = new HashMap<>(); + DateTimeFormatter formatters = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); + // 灏嗗瓧绗︿覆鏃堕棿杞崲涓� LocalDateTime 绫诲瀷鏃堕棿 + LocalDateTime localDateTime = LocalDateTime.parse(time, formatters); + map.put("header", getMonthHeader(localDateTime, shiftType)); + List<List<Object>> lists = dataRequiredForProcessingIntoExcelMonth(mapIPage, shiftType); + map.put("data", lists); + return map; + } + + // 鑾峰彇涓や釜localDateTime鐨勬瘡涓�澶� + public static List<LocalDateTime> getLocalDateTimesBetween(LocalDateTime start, LocalDateTime end) { + List<LocalDateTime> localDateTimes = new ArrayList<>(); + LocalDate currentDate = start.toLocalDate(); + LocalDateTime currentLocalDateTime = start; + while (!currentDate.isAfter(end.toLocalDate())) { + localDateTimes.add(currentLocalDateTime); + currentLocalDateTime = currentLocalDateTime.plusDays(1); + currentDate = currentDate.plusDays(1); + } + return localDateTimes; + } + + public static String getWeek(String dayStr) { + SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); + try { + Date date = sdf.parse(dayStr); + Calendar calendar = Calendar.getInstance(); + calendar.setTime(date); + int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK); + int day = calendar.get(Calendar.DAY_OF_MONTH); + return day + " " + getWeekDay(dayOfWeek); + } catch (Exception e) { + e.printStackTrace(); + } + return null; + } + + public static String getWeekDay(int dayOfWeek) { + switch (dayOfWeek) { + case Calendar.MONDAY: + return "鍛ㄤ竴"; + case Calendar.TUESDAY: + return "鍛ㄤ簩"; + case Calendar.WEDNESDAY: + return "鍛ㄤ笁"; + case Calendar.THURSDAY: + return "鍛ㄥ洓"; + case Calendar.FRIDAY: + return "鍛ㄤ簲"; + case Calendar.SATURDAY: + return "鍛ㄥ叚"; + case Calendar.SUNDAY: + return "鍛ㄦ棩"; + default: + return "鏈煡"; + } + } + + /** + * 杩斿洖琛ㄥご + * <p> + * 澶栧眰List浠h〃琛屽唴灞� List浠h〃鍒� 鐩稿悓鐨勫垪鏁版嵁浼氳涓诲姩鍚堝苟 + * 鏋勯�犲弻鍒楄〃澶� + * + * @return List<List < String>> + */ + private static List<List<String>> getYearHeader(String year, List<SysDictData> enums) { + List<List<String>> line = new ArrayList<>(); + line.add(Arrays.asList("鑰冨嫟姹囨��", "搴忓彿", "搴忓彿")); + line.add(Arrays.asList("鑰冨嫟姹囨��", "宸ュ彿", "宸ュ彿")); + line.add(Arrays.asList("鑰冨嫟姹囨��", "濮撳悕", "濮撳悕")); + line.add(Arrays.asList("鍑哄嫟璇︽儏", year, "鍑哄嫟")); + // 骞� header + for (SysDictData anEnum : enums) { + if (!anEnum.getDictValue().equals("5")) { + line.add(Arrays.asList("鑰冨嫟姹囨��", year, anEnum.getDictLabel())); + } + } + // 鏈坔eader + for (int i = 1; i < 13; i++) { + line.add(Arrays.asList("鍑哄嫟璇︽儏", i + " 鏈�", "鍑哄嫟")); + for (SysDictData anEnum : enums) { + if (!anEnum.getDictValue().equals("5")) { + line.add(Arrays.asList("鍑哄嫟璇︽儏", i + " 鏈�", anEnum.getDictLabel())); + } + } + } + return line; + } + + private static List<List<String>> getMonthHeader(LocalDateTime localDateTimeYear, List<SysDictData> enums) { + String year = localDateTimeYear.getYear() + " 骞翠汉鍛樼彮娆�"; + List<List<String>> line = new ArrayList<>(); + line.add(Arrays.asList(year, "搴忓彿", "搴忓彿", "搴忓彿")); + line.add(Arrays.asList(year, "濮撳悕", "濮撳悕", "濮撳悕")); + line.add(Arrays.asList(year, "瀹為獙瀹�", "瀹為獙瀹�", "瀹為獙瀹�")); + line.add(Arrays.asList(year, localDateTimeYear.getYear() + "", localDateTimeYear.getYear() + "", "鍑哄嫟")); + line.add(Arrays.asList(year, localDateTimeYear.getYear() + "", localDateTimeYear.getYear() + "", enums.get(3).getDictLabel())); + line.add(Arrays.asList(year, "骞�", "骞�", enums.get(4).getDictLabel())); + line.add(Arrays.asList(year, localDateTimeYear.getMonthValue() + "", localDateTimeYear.getMonthValue() + "", enums.get(0).getDictLabel())); + line.add(Arrays.asList(year, "鏈�", "鏈�", enums.get(1).getDictLabel())); + line.add(Arrays.asList(year, "", "", enums.get(2).getDictLabel())); + line.add(Arrays.asList(year, "鍛ㄦ", "鏄熸湡", "鍑哄樊")); + LocalDate firstDayOfMonth = localDateTimeYear.toLocalDate().withDayOfMonth(1); + LocalDate lastDayOfMonth = localDateTimeYear.toLocalDate().with(TemporalAdjusters.lastDayOfMonth()); + List<LocalDateTime> timeList = getLocalDateTimesBetween(firstDayOfMonth.atStartOfDay(), lastDayOfMonth.atStartOfDay()); + timeList.forEach(i -> { + int dayOfYear = i.getDayOfMonth(); + Date from = Date.from(i.atZone(ZoneId.systemDefault()).toInstant()); + String weekDay = getWeekDay(i.getDayOfWeek().getValue()); + line.add(Arrays.asList(year, DateUtil.weekOfYear(DateUtil.offsetDay(from, 1)) + "", weekDay, dayOfYear + "")); + }); + return line; + } + + public List<List<Object>> dataRequiredForProcessingIntoExcelMonth(List<PerformanceShiftMapDto> list, List<SysDictData> enums) { + List<List<Object>> data = new ArrayList<>(); + for (int i = 0; i < list.size(); i++) { + List<Object> excelRowList = new ArrayList<>(); + excelRowList.add(i + 1); + excelRowList.add(list.get(i).getName()); + excelRowList.add(list.get(i).getDepartment()); + excelRowList.add(list.get(i).getMonthlyAttendance().get("totalAttendance")); + excelRowList.add(list.get(i).getMonthlyAttendance().get(enums.get(3).getDictLabel())); // 浼� + excelRowList.add(list.get(i).getMonthlyAttendance().get(enums.get(4).getDictLabel())); // 鍋� + excelRowList.add(list.get(i).getMonthlyAttendance().get(enums.get(0).getDictLabel())); // 鏃� + excelRowList.add(list.get(i).getMonthlyAttendance().get(enums.get(1).getDictLabel())); // 涓� + excelRowList.add(list.get(i).getMonthlyAttendance().get(enums.get(2).getDictLabel())); // 澶� + excelRowList.add(list.get(i).getMonthlyAttendance().get(enums.get(6).getDictLabel())); // 宸� + for (Map<String, Object> o : list.get(i).getList()) { + String enumLabel = ""; + for (SysDictData anEnum : enums) { + if (anEnum.getDictValue().equals(o.get("shift"))) { + enumLabel = anEnum.getDictLabel(); + } + } + excelRowList.add(ObjectUtils.isEmpty(enumLabel) ? "-" : enumLabel); + } + data.add(excelRowList); + } + return data; + } +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/service/impl/ShiftTimeServiceImpl.java b/performance-server/src/main/java/com/ruoyi/performance/service/impl/ShiftTimeServiceImpl.java new file mode 100644 index 0000000..cff7cbc --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/service/impl/ShiftTimeServiceImpl.java @@ -0,0 +1,41 @@ +package com.ruoyi.performance.service.impl; + +import com.baomidou.mybatisplus.core.toolkit.Wrappers; +import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; +import com.ruoyi.common.exception.base.BaseException; +import com.ruoyi.performance.mapper.ShiftTimeMapper; +import com.ruoyi.performance.pojo.ShiftTime; +import com.ruoyi.performance.service.ShiftTimeService; +import org.springframework.stereotype.Service; + +import javax.annotation.Resource; +import java.util.List; + +/** + * <p> + * 鐝瀵瑰簲鐨勬椂闂� 鏈嶅姟瀹炵幇绫� + * </p> + * + * @author 姹熻嫃榈烽洀缃戠粶绉戞妧鏈夐檺鍏徃 + * @since 2024-07-24 11:22:17 + */ +@Service +public class ShiftTimeServiceImpl extends ServiceImpl<ShiftTimeMapper, ShiftTime> implements ShiftTimeService { + + @Resource + ShiftTimeMapper shiftTimeMapper; + + @Override + public void shiftTimeAdd(ShiftTime shiftTime) { + List<ShiftTime> shiftTimes = shiftTimeMapper.selectList(Wrappers.<ShiftTime>lambdaQuery().eq(ShiftTime::getShift, shiftTime.getShift())); + if (shiftTimes.size() > 0) { + throw new BaseException("宸插瓨鍦ㄨ鐝鐨勬椂闂撮厤缃�,璇峰垹鎺夊悗鍐嶆柊澧�!"); + } + shiftTimeMapper.insert(shiftTime); + } + + @Override + public List<ShiftTime> shiftTimeList() { + return shiftTimeMapper.selectList(null); + } +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/utils/CustomerDoubleSerialize.java b/performance-server/src/main/java/com/ruoyi/performance/utils/CustomerDoubleSerialize.java new file mode 100644 index 0000000..576ae14 --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/utils/CustomerDoubleSerialize.java @@ -0,0 +1,26 @@ +package com.ruoyi.performance.utils; + +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.databind.JsonSerializer; +import com.fasterxml.jackson.databind.SerializerProvider; + +import java.io.IOException; +import java.text.DecimalFormat; + +public class CustomerDoubleSerialize extends JsonSerializer { + private DecimalFormat df = new DecimalFormat("0.0000"); + + @Override + public void serialize(Object o, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException { + if(o.toString() != null && !o.toString().equals("0.0")) { + Double dd=Double.parseDouble(o.toString()); + jsonGenerator.writeString(df.format(dd)); + } else{ + if(o.toString().equals("0.0")) { + jsonGenerator.writeString("0"); + } else { + jsonGenerator.writeString(o.toString()); + } + } + } +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/utils/StyleMonthUtils.java b/performance-server/src/main/java/com/ruoyi/performance/utils/StyleMonthUtils.java new file mode 100644 index 0000000..3edee60 --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/utils/StyleMonthUtils.java @@ -0,0 +1,86 @@ +package com.ruoyi.performance.utils; + +import com.alibaba.excel.write.metadata.style.WriteCellStyle; +import com.alibaba.excel.write.metadata.style.WriteFont; +import org.apache.poi.ss.usermodel.BorderStyle; +import org.apache.poi.ss.usermodel.FillPatternType; +import org.apache.poi.ss.usermodel.HorizontalAlignment; +import org.apache.poi.ss.usermodel.VerticalAlignment; + +public class StyleMonthUtils { + /** + * 鏍囬鏍峰紡 + * @return + */ + public static WriteCellStyle getHeadStyle(){ + // 澶寸殑绛栫暐 + WriteCellStyle headWriteCellStyle = new WriteCellStyle(); + // 鑳屾櫙棰滆壊 +// headWriteCellStyle.setFillForegroundColor(IndexedColors.WHITE.getIndex()); +// headWriteCellStyle.setFillPatternType(FillPatternType.SOLID_FOREGROUND); + + // 瀛椾綋 + WriteFont headWriteFont = new WriteFont(); + headWriteFont.setFontName("绛夌嚎");//璁剧疆瀛椾綋鍚嶅瓧 + headWriteFont.setFontHeightInPoints((short)9);//璁剧疆瀛椾綋澶у皬 + headWriteFont.setBold(true);//瀛椾綋鍔犵矖 + headWriteFont.setColor((short) 0); + headWriteCellStyle.setWriteFont(headWriteFont); //鍦ㄦ牱寮忕敤搴旂敤璁剧疆鐨勫瓧浣�; + + // 鏍峰紡 + headWriteCellStyle.setBorderBottom(BorderStyle.THIN);//璁剧疆搴曡竟妗�; + headWriteCellStyle.setBottomBorderColor((short) 0);//璁剧疆搴曡竟妗嗛鑹�; + headWriteCellStyle.setBorderLeft(BorderStyle.THIN); //璁剧疆宸﹁竟妗�; + headWriteCellStyle.setLeftBorderColor((short) 0);//璁剧疆宸﹁竟妗嗛鑹�; + headWriteCellStyle.setBorderRight(BorderStyle.THIN);//璁剧疆鍙宠竟妗�; + headWriteCellStyle.setRightBorderColor((short) 0);//璁剧疆鍙宠竟妗嗛鑹�; + headWriteCellStyle.setBorderTop(BorderStyle.THIN);//璁剧疆椤惰竟妗�; + headWriteCellStyle.setTopBorderColor((short) 0); //璁剧疆椤惰竟妗嗛鑹�; + + headWriteCellStyle.setWrapped(false); //璁剧疆鑷姩鎹㈣; + + headWriteCellStyle.setHorizontalAlignment(HorizontalAlignment.CENTER);//璁剧疆姘村钩瀵归綈鐨勬牱寮忎负灞呬腑瀵归綈; + headWriteCellStyle.setVerticalAlignment(VerticalAlignment.CENTER); //璁剧疆鍨傜洿瀵归綈鐨勬牱寮忎负灞呬腑瀵归綈; + headWriteCellStyle.setShrinkToFit(true);//璁剧疆鏂囨湰鏀剁缉鑷冲悎閫� + + return headWriteCellStyle; + } + + + /** + * 鍐呭鏍峰紡 + * @return + */ + public static WriteCellStyle getContentStyle(){ + // 鍐呭鐨勭瓥鐣� + WriteCellStyle contentWriteCellStyle = new WriteCellStyle(); + + // 杩欓噷闇�瑕佹寚瀹� FillPatternType 涓篎illPatternType.SOLID_FOREGROUND 涓嶇劧鏃犳硶鏄剧ず鑳屾櫙棰滆壊.澶撮粯璁や簡 FillPatternType鎵�浠ュ彲浠ヤ笉鎸囧畾 +// contentWriteCellStyle.setFillForegroundColor(IndexedColors.LIGHT_GREEN.getIndex()); + contentWriteCellStyle.setFillPatternType(FillPatternType.SOLID_FOREGROUND); + + // 璁剧疆瀛椾綋 + WriteFont contentWriteFont = new WriteFont(); + contentWriteFont.setFontHeightInPoints((short) 10);//璁剧疆瀛椾綋澶у皬 + contentWriteFont.setFontName("绛夌嚎"); //璁剧疆瀛椾綋鍚嶅瓧 + contentWriteCellStyle.setWriteFont(contentWriteFont);//鍦ㄦ牱寮忕敤搴旂敤璁剧疆鐨勫瓧浣�; + + //璁剧疆鏍峰紡; + contentWriteCellStyle.setBorderBottom(BorderStyle.THIN);//璁剧疆搴曡竟妗�; + contentWriteCellStyle.setBottomBorderColor((short) 0);//璁剧疆搴曡竟妗嗛鑹�; + contentWriteCellStyle.setBorderLeft(BorderStyle.THIN); //璁剧疆宸﹁竟妗�; + contentWriteCellStyle.setLeftBorderColor((short) 0);//璁剧疆宸﹁竟妗嗛鑹�; + contentWriteCellStyle.setBorderRight(BorderStyle.THIN);//璁剧疆鍙宠竟妗�; + contentWriteCellStyle.setRightBorderColor((short) 0);//璁剧疆鍙宠竟妗嗛鑹�; + contentWriteCellStyle.setBorderTop(BorderStyle.THIN);//璁剧疆椤惰竟妗�; + contentWriteCellStyle.setTopBorderColor((short) 0); ///璁剧疆椤惰竟妗嗛鑹�; + + contentWriteCellStyle.setHorizontalAlignment(HorizontalAlignment.CENTER);// 姘村钩灞呬腑 + contentWriteCellStyle.setVerticalAlignment(VerticalAlignment.CENTER);// 鍨傜洿灞呬腑 + contentWriteCellStyle.setWrapped(false); //璁剧疆鑷姩鎹㈣; + +// contentWriteCellStyle.setShrinkToFit(true);//璁剧疆鏂囨湰鏀剁缉鑷冲悎閫� + + return contentWriteCellStyle; + } +} diff --git a/performance-server/src/main/java/com/ruoyi/performance/utils/StyleYearUtils.java b/performance-server/src/main/java/com/ruoyi/performance/utils/StyleYearUtils.java new file mode 100644 index 0000000..0076249 --- /dev/null +++ b/performance-server/src/main/java/com/ruoyi/performance/utils/StyleYearUtils.java @@ -0,0 +1,89 @@ +package com.ruoyi.performance.utils; + +import com.alibaba.excel.write.metadata.style.WriteCellStyle; +import com.alibaba.excel.write.metadata.style.WriteFont; +import org.apache.poi.ss.usermodel.BorderStyle; +import org.apache.poi.ss.usermodel.FillPatternType; +import org.apache.poi.ss.usermodel.HorizontalAlignment; +import org.apache.poi.ss.usermodel.VerticalAlignment; + +public class StyleYearUtils { + /** + * 鏍囬鏍峰紡 + * + * @return + */ + public static WriteCellStyle getHeadStyle() { + // 澶寸殑绛栫暐 + WriteCellStyle headWriteCellStyle = new WriteCellStyle(); + // 鑳屾櫙棰滆壊 +// headWriteCellStyle.setFillForegroundColor(IndexedColors.GREEN.getIndex()); + headWriteCellStyle.setFillPatternType(FillPatternType.SOLID_FOREGROUND); + + // 瀛椾綋 + WriteFont headWriteFont = new WriteFont(); + headWriteFont.setFontName("浠垮畫");//璁剧疆瀛椾綋鍚嶅瓧 + headWriteFont.setFontHeightInPoints((short) 9);//璁剧疆瀛椾綋澶у皬 + headWriteFont.setBold(true);//瀛椾綋鍔犵矖 + headWriteFont.setColor((short) 1); + headWriteCellStyle.setWriteFont(headWriteFont); //鍦ㄦ牱寮忕敤搴旂敤璁剧疆鐨勫瓧浣�; + + // 鏍峰紡 + headWriteCellStyle.setBorderBottom(BorderStyle.THIN);//璁剧疆搴曡竟妗�; + headWriteCellStyle.setBottomBorderColor((short) 1);//璁剧疆搴曡竟妗嗛鑹�; + headWriteCellStyle.setBorderLeft(BorderStyle.THIN); //璁剧疆宸﹁竟妗�; + headWriteCellStyle.setLeftBorderColor((short) 1);//璁剧疆宸﹁竟妗嗛鑹�; + headWriteCellStyle.setBorderRight(BorderStyle.THIN);//璁剧疆鍙宠竟妗�; + headWriteCellStyle.setRightBorderColor((short) 1);//璁剧疆鍙宠竟妗嗛鑹�; + headWriteCellStyle.setBorderTop(BorderStyle.THIN);//璁剧疆椤惰竟妗�; + headWriteCellStyle.setTopBorderColor((short) 1); //璁剧疆椤惰竟妗嗛鑹�; + + headWriteCellStyle.setWrapped(false); //璁剧疆鑷姩鎹㈣; + + headWriteCellStyle.setHorizontalAlignment(HorizontalAlignment.CENTER);//璁剧疆姘村钩瀵归綈鐨勬牱寮忎负灞呬腑瀵归綈; + headWriteCellStyle.setVerticalAlignment(VerticalAlignment.CENTER); //璁剧疆鍨傜洿瀵归綈鐨勬牱寮忎负灞呬腑瀵归綈; + headWriteCellStyle.setShrinkToFit(true);//璁剧疆鏂囨湰鏀剁缉鑷冲悎閫� + + return headWriteCellStyle; + } + + + /** + * 鍐呭鏍峰紡 + * + * @return + */ + public static WriteCellStyle getContentStyle() { + // 鍐呭鐨勭瓥鐣� + WriteCellStyle contentWriteCellStyle = new WriteCellStyle(); + + // 杩欓噷闇�瑕佹寚瀹� FillPatternType 涓篎illPatternType.SOLID_FOREGROUND 涓嶇劧鏃犳硶鏄剧ず鑳屾櫙棰滆壊.澶撮粯璁や簡 FillPatternType鎵�浠ュ彲浠ヤ笉鎸囧畾 +// contentWriteCellStyle.setFillForegroundColor(IndexedColors.GREY_25_PERCENT.getIndex()); + contentWriteCellStyle.setFillPatternType(FillPatternType.SOLID_FOREGROUND); + + // 璁剧疆瀛椾綋 + WriteFont contentWriteFont = new WriteFont(); + contentWriteFont.setFontHeightInPoints((short) 9);//璁剧疆瀛椾綋澶у皬 + contentWriteFont.setFontName("浠垮畫"); //璁剧疆瀛椾綋鍚嶅瓧 + contentWriteCellStyle.setWriteFont(contentWriteFont);//鍦ㄦ牱寮忕敤搴旂敤璁剧疆鐨勫瓧浣�; + + //璁剧疆鏍峰紡; + contentWriteCellStyle.setBorderBottom(BorderStyle.THIN);//璁剧疆搴曡竟妗�; + contentWriteCellStyle.setBottomBorderColor((short) 0);//璁剧疆搴曡竟妗嗛鑹�; + contentWriteCellStyle.setBorderLeft(BorderStyle.THIN); //璁剧疆宸﹁竟妗�; + contentWriteCellStyle.setLeftBorderColor((short) 0);//璁剧疆宸﹁竟妗嗛鑹�; + contentWriteCellStyle.setBorderRight(BorderStyle.THIN);//璁剧疆鍙宠竟妗�; + contentWriteCellStyle.setRightBorderColor((short) 0);//璁剧疆鍙宠竟妗嗛鑹�; + contentWriteCellStyle.setBorderTop(BorderStyle.THIN);//璁剧疆椤惰竟妗�; + contentWriteCellStyle.setTopBorderColor((short) 0); ///璁剧疆椤惰竟妗嗛鑹�; + + contentWriteCellStyle.setHorizontalAlignment(HorizontalAlignment.CENTER);// 姘村钩灞呬腑 + contentWriteCellStyle.setVerticalAlignment(VerticalAlignment.CENTER);// 鍨傜洿灞呬腑 + contentWriteCellStyle.setWrapped(false); //璁剧疆鑷姩鎹㈣; + +// contentWriteCellStyle.setShrinkToFit(true);//璁剧疆鏂囨湰鏀剁缉鑷冲悎閫� + + return contentWriteCellStyle; + } + +} diff --git a/performance-server/src/main/resources/mapper/AuxiliaryCorrectionHoursMapper.xml b/performance-server/src/main/resources/mapper/AuxiliaryCorrectionHoursMapper.xml new file mode 100644 index 0000000..ec609d0 --- /dev/null +++ b/performance-server/src/main/resources/mapper/AuxiliaryCorrectionHoursMapper.xml @@ -0,0 +1,75 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> +<mapper namespace="com.ruoyi.performance.mapper.AuxiliaryCorrectionHoursMapper"> + <!-- 閫氱敤鏌ヨ鏄犲皠缁撴灉 --> + <resultMap id="BaseResultMap" type="com.ruoyi.performance.pojo.AuxiliaryCorrectionHours"> + <id column="id" property="id"/> + <result column="name_user" property="nameUser"/> + <result column="type" property="type"/> + <result column="one_hours" property="oneHours"/> + <result column="two_hours" property="twoHours"/> + <result column="three_hours" property="threeHours"/> + <result column="four_hours" property="fourHours"/> + <result column="five_hours" property="fiveHours"/> + <result column="six_hours" property="sixHours"/> + <result column="seven_hours" property="sevenHours"/> + <result column="eight_hours" property="eightHours"/> + <result column="nine_hours" property="nineHours"/> + <result column="ten_hours" property="tenHours"/> + <result column="eleven_hours" property="elevenHours"/> + <result column="twelve_hours" property="twelveHours"/> + <result column="thirteen_hours" property="thirteenHours"/> + <result column="fourteen_hours" property="fourteenHours"/> + <result column="fifteen_hours" property="fifteenHours"/> + <result column="sixteen_hours" property="sixteenHours"/> + <result column="seventeen_hours" property="seventeenHours"/> + <result column="eighteen_hours" property="eighteenHours"/> + <result column="nineteen_hours" property="nineteenHours"/> + <result column="twenty_hours" property="twentyHours"/> + <result column="twenty_one_hours" property="twentyOneHours"/> + <result column="twenty_two_hours" property="twentyTwoHours"/> + <result column="twenty_three_hours" property="twentyThreeHours"/> + <result column="twenty_four_hours" property="twentyFourHours"/> + <result column="twenty_five_hours" property="twentyFiveHours"/> + <result column="twenty_six_hours" property="twentySixHours"/> + <result column="twenty_seven_hours" property="twentySevenHours"/> + <result column="twenty_eight_hours" property="twentyEightHours"/> + <result column="twenty_nine_hours" property="twentyNineHours"/> + <result column="thirty_hours" property="thirtyHours"/> + <result column="thirty_one_hours" property="thirtyOneHours"/> + <result column="month" property="month"/> + <result column="create_time" property="createTime"/> + <result column="update_time" property="updateTime"/> + <result column="create_user" property="createUser"/> + <result column="update_user" property="updateUser"/> + </resultMap> + <select id="selectAuxiliaryCorrectionHours" resultType="com.ruoyi.performance.dto.AuxiliaryCorrectionHoursDto"> + select A.* + from ( + select ach.*, + name, + sum(one_hours+two_hours+ three_hours+ four_hours+ five_hours+ six_hours+ seven_hours+ eight_hours+ nine_hours+ + ten_hours+ eleven_hours+ twelve_hours+thirteen_hours+ fourteen_hours+ fifteen_hours+ sixteen_hours+ + seventeen_hours+ eighteen_hours+ nineteen_hours+ twenty_hours+ twenty_one_hours+ twenty_two_hours+ + twenty_three_hours+ twenty_four_hours+ twenty_five_hours+ twenty_six_hours+ twenty_seven_hours+ + twenty_eight_hours+ twenty_nine_hours+ thirty_hours+ thirty_one_hours) as total + FROM auxiliary_correction_hours ach + left join user on user.id=ach.name_user + WHERE 1=1 + <if test="ids !=null and ids != ''"> + and name_user in + <foreach collection="ids" index="index" open="(" separator="," close=")" item="val"> + #{val} + </foreach> + </if> + ) A + <if test="ew.customSqlSegment != null and ew.customSqlSegment != ''"> + ${ew.customSqlSegment} + </if> + </select> + <select id="selDepartLimsByName" resultType="java.lang.Integer"> + select id + from department_lims + where name LIKE CONCAT('%', #{departLims}, '%'); + </select> +</mapper> diff --git a/performance-server/src/main/resources/mapper/AuxiliaryOriginalHoursMapper.xml b/performance-server/src/main/resources/mapper/AuxiliaryOriginalHoursMapper.xml new file mode 100644 index 0000000..71e2892 --- /dev/null +++ b/performance-server/src/main/resources/mapper/AuxiliaryOriginalHoursMapper.xml @@ -0,0 +1,59 @@ +<?xml version="1.0" encoding="UTF-8" ?> +<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" > +<mapper namespace="com.ruoyi.performance.mapper.AuxiliaryOriginalHoursMapper"> + <select id="totalHours" resultType="java.util.Map"> + select E.name, E.month, E.total manHours + from (select C.name, C.month, C.manHours + D.manHours as total + from (select A.name, + A.month, + FORMAT(SUM(manHour), 4) as manHours + from ( + select user.name, + case + when reviewer_nonproductive_time is null then nonproductive_time + else reviewer_nonproductive_time end as manHour, + date_time as month + from auxiliary_working_hours_day awhd + left join user on user.id = awhd.name_user + left join department_lims dl on depart_lims_id = dl.id + where date_time LIKE CONCAT('%', #{month}, '%') + and awhd.state='宸叉壒鍑�' + <!--and name_user in(#{ids})--> + <if test="ids !=null and ids != ''"> + and name_user in + <foreach collection="ids" index="index" open="(" separator="," close=")" item="val"> + #{val} + </foreach> + </if> + order by month + ) A + group by A.name, A.month) C + INNER JOIN + (select B.name, + B.month, + B.manHours + from ( + select user.name, + date_time as month, + FORMAT(SUM(output_work_time), 4) as manHours + from auxiliary_output_working_hours aowh + left join user on user.id = aowh.`check` + left join department_lims dl on depart_lims_id = dl.id + where date_time LIKE CONCAT('%', #{month}, '%') + <!--and `check` in(#{ids})--> + <if test="ids !=null and ids != ''"> + and `check` in + <foreach collection="ids" index="index" open="(" separator="," close=")" item="val"> + #{val} + </foreach> + </if> + group by user.name, month + order by user.name, month + ) B + group by B.name, B.month) D + on C.month = D.month + where C.name = D.name + ) E + group by E.name, E.month + </select> +</mapper> diff --git a/performance-server/src/main/resources/mapper/AuxiliaryOutputWorkingHoursMapper.xml b/performance-server/src/main/resources/mapper/AuxiliaryOutputWorkingHoursMapper.xml new file mode 100644 index 0000000..9229c98 --- /dev/null +++ b/performance-server/src/main/resources/mapper/AuxiliaryOutputWorkingHoursMapper.xml @@ -0,0 +1,186 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> +<mapper namespace="com.ruoyi.performance.mapper.AuxiliaryOutputWorkingHoursMapper"> + <!-- 閫氱敤鏌ヨ鏄犲皠缁撴灉 --> + <resultMap id="BaseResultMap" type="com.ruoyi.performance.pojo.AuxiliaryOutputWorkingHours"> + <id column="id" property="id"/> + <result column="inspection_item" property="inspectionItem"/> + <result column="inspection_item_subclass" property="inspectionItemSubclass"/> + <result column="sample" property="sample"/> + <result column="overtime_order_no" property="overtimeOrderNo"/> + <result column="overtime_work_time" property="overtimeWorkTime"/> + <result column="overtime_amount" property="overtimeAmount"/> + <result column="order_no" property="orderNo"/> + <result column="work_time" property="workTime"/> + <result column="amount" property="amount"/> + <result column="output_work_time" property="outputWorkTime"/> + <result column="date_time" property="dateTime"/> + <result column="week" property="week"/> + <result column="week_day" property="weekDay"/> + <result column="check" property="check"/> + <result column="create_time" property="createTime"/> + <result column="update_time" property="updateTime"/> + <result column="create_user" property="createUser"/> + <result column="update_user" property="updateUser"/> + </resultMap> + + <sql id="selectAuxiliaryOutputWorking"> + select * + from ( + select aowh.id, + aowh.inspection_item_class, + aowh.inspection_item, + aowh.inspection_item_subclass, + aowh.overtime_order_no, + aowh.overtime_work_time, + aowh.overtime_amount, + aowh.order_no, + aowh.work_time, + aowh.amount, + aowh.output_work_time, + aowh.date_time, + aowh.week, + aowh.week_day, + user.name, + aowh.sample, + aowh.price, + aowh.man_hour_group, + ip.cable_tag + FROM auxiliary_output_working_hours aowh + left join ins_product ip on ip.id = aowh.ins_product_id + left join user on user.id=aowh.`check` + WHERE 1=1 + <if test="ids !=null and ids.size() > 0"> + and `check` in + <foreach collection="ids" index="index" open="(" separator="," close=")" item="val"> + #{val} + </foreach> + </if> + ) A + <if test="ew.customSqlSegment != null and ew.customSqlSegment != ''"> + ${ew.customSqlSegment} + </if> + </sql> + <select id="selectAuxiliaryOutputWorkingHours" resultType="com.ruoyi.performance.dto.AuxiliaryOutputWorkingHoursDto"> + <include refid="selectAuxiliaryOutputWorking"/> + </select> + <select id="selectDataByUser" resultType="com.ruoyi.performance.dto.AuxiliaryOutputWorkingHoursDto"> + select aowh.*, name, ip.cable_tag cableTag + FROM auxiliary_output_working_hours aowh + left join ins_product ip on ip.id = aowh.ins_product_id + left join user on user.id = aowh.`check` + WHERE 1 = 1 + <if test="ids !=null and ids.size() > 0"> + and `check` in + <foreach collection="ids" index="index" open="(" separator="," close=")" item="val"> + #{val} + </foreach> + </if> + </select> + <select id="totalHours" resultType="java.util.Map"> + select A.name, + A.month, + FORMAT(SUM(A.manHours), 4) manHours + from( + select user.name, + date_time as month, + order_no, + sample, + man_hour_group, + case when #{type}='鍔犵彮宸ユ椂' then case when overtime_work_time is null then 0 else overtime_work_time end + else case when work_time is null then 0 else work_time end end as manHours + -- FORMAT(SUM(output_work_time), 4) as manHours + from auxiliary_output_working_hours aowh + left join user on user.id=aowh.`check` + left join department_lims dl on depart_lims_id=dl.id + where date_time LIKE CONCAT('%', #{month}, '%') + <if test="ids !=null and ids != ''"> + and `check` in + <foreach collection="ids" open="(" separator="," close=")" item="val"> + #{val} + </foreach> + </if> + group by user.name,date_time,order_no, + sample, + man_hour_group + order by user.name,date_time,order_no, + sample, + man_hour_group + )A + group by A.name, + A.month + order by A.name, + A.month + </select> + <select id="selectListByIds" resultType="com.ruoyi.performance.pojo.AuxiliaryOutputWorkingHours"> + select * from auxiliary_output_working_hours + where 1=1 + <if test="ids !=null and ids != ''"> + and `check` in + <foreach collection="ids" index="index" open="(" separator="," close=")" item="val"> + #{val} + </foreach> + </if> + </select> + + <select id="selectLists" resultMap="BaseResultMap"> + select * from(select * from auxiliary_output_working_hours + WHERE 1=1 + <if test="ids !=null and ids != ''"> + and `check` in + <foreach collection="ids" index="index" open="(" separator="," close=")" item="val"> + #{val} + </foreach> + </if> + ) A + <if test="ew.customSqlSegment != null and ew.customSqlSegment != ''"> + ${ew.customSqlSegment} + </if> + </select> + <select id="selectAuxiliaryAllByMonth" resultType="com.ruoyi.performance.dto.AuxiliaryAllDto"> + select sum(aowh.work_time) yieldHour, + u.name userName, + aowh.`check` userId, + #{dto.month} month + from (SELECT * + FROM auxiliary_output_working_hours + GROUP BY CASE + WHEN man_hour_group IS NOT NULL AND man_hour_group != '' THEN man_hour_group + ELSE id + END + , CASE + WHEN man_hour_group IS NOT NULL AND man_hour_group != '' THEN order_id + ELSE id + END) aowh + left join user u on u.id = aowh.`check` + where aowh.date_time between #{dto.beginDate} and #{dto.endDate} + <if test="userIds !=null and userIds.size() > 0"> + and aowh.`check` in + <foreach collection="userIds" index="index" open="(" separator="," close=")" item="val"> + #{val} + </foreach> + </if> + group by aowh.`check` + </select> + <select id="selectSubsidiaryAllByMonth" resultType="com.ruoyi.performance.dto.AuxiliaryAllDto"> + select sum(awhd.reviewer_nonproductive_time) subsidiaryHour, + u.name userName, + awhd.name_user userId, + #{dto.month} month + from auxiliary_working_hours_day awhd + left join user u on u.id = awhd.name_user + where awhd.date_time between #{dto.beginDate} and #{dto.endDate} + and awhd.state = '宸叉壒鍑�' + <if test="userIds !=null and userIds.size() > 0"> + and awhd.name_user in + <foreach collection="userIds" index="index" open="(" separator="," close=")" item="val"> + #{val} + </foreach> + </if> + group by awhd.name_user + </select> + <!-- 鏌ヨ浜ч噺宸ユ椂闆嗗悎 --> + <select id="selectAuxiliaryOutputWorkingHoursList" resultType="com.ruoyi.performance.dto.AuxiliaryOutputWorkingHoursDto"> + <include refid="selectAuxiliaryOutputWorking"/> + </select> +</mapper> diff --git a/performance-server/src/main/resources/mapper/AuxiliaryWorkingHoursDayMapper.xml b/performance-server/src/main/resources/mapper/AuxiliaryWorkingHoursDayMapper.xml new file mode 100644 index 0000000..48e6bb2 --- /dev/null +++ b/performance-server/src/main/resources/mapper/AuxiliaryWorkingHoursDayMapper.xml @@ -0,0 +1,116 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> +<mapper namespace="com.ruoyi.performance.mapper.AuxiliaryWorkingHoursDayMapper"> + <!-- 閫氱敤鏌ヨ鏄犲皠缁撴灉 --> + <resultMap id="BaseResultMap" type="com.ruoyi.performance.pojo.AuxiliaryWorkingHoursDay"> + <id column="id" property="id"/> + <result column="nameUser" property="nameUser"/> + <result column="number" property="number"/> + <result column="auxiliary_project" property="auxiliaryProject"/> + <result column="approved_working_hour" property="approvedWorkingHour"/> + <result column="amount" property="amount"/> + <result column="nonproductive_time" property="nonproductiveTime"/> + <result column="remarks" property="remarks"/> + <result column="reviewer" property="reviewer"/> + <result column="reviewer_number" property="reviewerNumber"/> + <result column="reviewer_nonproductive_time" property="reviewerNonproductiveTime"/> + <result column="reviewer_remark" property="reviewerRemark"/> + <result column="year" property="year"/> + <result column="shift" property="shift"/> + <result column="week" property="week"/> + <result column="week_day" property="weekDay"/> + <result column="create_time" property="createTime"/> + <result column="update_time" property="updateTime"/> + <result column="create_user" property="createUser"/> + <result column="update_user" property="updateUser"/> + <result column="state" property="state"/> + </resultMap> + + <sql id="selectAuxiliaryWorkingHours"> + select A.* + from ( + select awhd.*,name + FROM auxiliary_working_hours_day awhd + left join user on name_user=user.id + WHERE 1=1 + <if test="ids !=null and ids.size() > 0"> + and name_user in + <foreach collection="ids" index="index" open="(" separator="," close=")" item="val"> + #{val} + </foreach> + </if> + ) A + <if test="ew.customSqlSegment != null and ew.customSqlSegment != ''"> + ${ew.customSqlSegment} + </if> + </sql> + + <select id="selectAuxiliaryWorkingHoursDay" resultType="com.ruoyi.performance.dto.AuxiliaryWorkingHoursDayDto"> + <include refid="selectAuxiliaryWorkingHours"/> + </select> + <select id="selectDataByUser" resultType="com.ruoyi.performance.dto.AuxiliaryWorkingHoursDayDto"> + select awhd.*,name + FROM auxiliary_working_hours_day awhd + left join user on name_user=user.id + WHERE 1=1 + <if test="ids !=null and ids.size() > 0"> + and name_user in + <foreach collection="ids" index="index" open="(" separator="," close=")" item="val"> + #{val} + </foreach> + </if> + </select> + <select id="selectListByIds" resultType="com.ruoyi.performance.pojo.AuxiliaryWorkingHoursDay"> + select * from auxiliary_working_hours_day + where state='宸插鏍�' + <if test="ids !=null and ids != ''"> + and name_user in + <foreach collection="ids" index="index" open="(" separator="," close=")" item="val"> + #{val} + </foreach> + </if> + </select> + <select id="totalHours" resultType="java.util.Map"> + select A.name, + A.month, + FORMAT(SUM(manHour), 4)as manHours + from( + select user.name, + case when reviewer_nonproductive_time is null then nonproductive_time + else reviewer_nonproductive_time end as manHour, + date_time as month + from auxiliary_working_hours_day awhd + left join user on user.id=awhd.name_user + left join department_lims dl on depart_lims_id=dl.id + where date_time LIKE CONCAT('%', #{month}, '%') + and awhd.state='宸叉壒鍑�' + <if test="ids !=null and ids.size() > 0"> + and name_user in + <foreach collection="ids" index="index" open="(" separator="," close=")" item="val"> + #{val} + </foreach> + </if> + order by month,user.name + )A + group by A.name,A.month + order by A.name,A.month + </select> + + <select id="selectLists" resultMap="BaseResultMap"> + select * from(select * from auxiliary_working_hours_day + WHERE 1=1 + <if test="ids !=null and ids.size() > 0"> + and name_user in + <foreach collection="ids" index="index" open="(" separator="," close=")" item="val"> + #{val} + </foreach> + </if> + ) A + <if test="ew.customSqlSegment != null and ew.customSqlSegment != ''"> + ${ew.customSqlSegment} + </if> + </select> + <select id="selectAuxiliaryWorkingHoursDayList" resultType="com.ruoyi.performance.dto.AuxiliaryWorkingHoursDayDto"> + <include refid="selectAuxiliaryWorkingHours"/> + </select> +</mapper> diff --git a/performance-server/src/main/resources/mapper/AuxiliaryWorkingHoursMapper.xml b/performance-server/src/main/resources/mapper/AuxiliaryWorkingHoursMapper.xml new file mode 100644 index 0000000..0c4fd2c --- /dev/null +++ b/performance-server/src/main/resources/mapper/AuxiliaryWorkingHoursMapper.xml @@ -0,0 +1,38 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> +<mapper namespace="com.ruoyi.performance.mapper.AuxiliaryWorkingHoursMapper"> + + <!-- 閫氱敤鏌ヨ鏄犲皠缁撴灉 --> + <resultMap id="BaseResultMap" type="com.ruoyi.performance.pojo.AuxiliaryWorkingHours"> + <id column="id" property="id" /> + <result column="number" property="number"/> + <result column="AuxiliaryProject" property="auxiliaryProject" /> + <result column="approved_working_hour" property="approvedWorkingHour" /> + <result column="remarks" property="remarks" /> + <result column="create_user" property="createUser" /> + <result column="update_user" property="updateUser" /> + <result column="create_time" property="createTime" /> + <result column="update_time" property="updateTime" /> + <result column="department" property="department" /> + <result column="laboratory" property="laboratory" /> + <result column="unit" property="unit"/> + </resultMap> + <select id="selectAuxiliaryWorkingHours" resultType="com.ruoyi.performance.pojo.AuxiliaryWorkingHours"> + select data.* + from ( + select + awh.id, + awh.number, + awh.auxiliary_project, + awh.laboratory, + awh.unit, + awh.approved_working_hour, + awh.department, + awh.remarks + FROM auxiliary_working_hours awh + ) data + <if test="ew.customSqlSegment != null and ew.customSqlSegment != ''"> + ${ew.customSqlSegment} + </if> + </select> +</mapper> diff --git a/performance-server/src/main/resources/mapper/PerformanceShiftMapper.xml b/performance-server/src/main/resources/mapper/PerformanceShiftMapper.xml new file mode 100644 index 0000000..751ca1a --- /dev/null +++ b/performance-server/src/main/resources/mapper/PerformanceShiftMapper.xml @@ -0,0 +1,135 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> +<mapper namespace="com.ruoyi.performance.mapper.PerformanceShiftMapper"> + + <resultMap id="performanceShiftPageMap" type="com.ruoyi.performance.dto.PerformanceShiftMapDto"> + <result column="name" property="name"/> + <result column="shift_time" property="shiftTime"/> + <result column="user_id" property="userId" /> + <result column="department" property="department" /> + </resultMap> + + <select id="performanceShiftPage" resultMap="performanceShiftPageMap"> + SELECT + if(u2.department is not null and u2.department != '', CONCAT(u2.name, '锛�', u2.department, '锛�'), u2.name) name, + GROUP_CONCAT(s.work_time, '锛�', s.shift, '锛�', s.id order by s.work_time SEPARATOR ';') AS shift_time, u2.id user_id + FROM performance_shift s + LEFT JOIN (SELECT distinct u.* from + user u + left join department_lims dl on FIND_IN_SET(dl.id,u.depart_lims_id) + where state=1 + <if test="laboratory != null and laboratory != ''"> + and dl.name=#{laboratory} + </if> + ) u2 on u2.id = s.user_id + <where> + name is not null + <if test="time != null and time != ''"> + and DATE_FORMAT(s.work_time, '%Y-%m') = DATE_FORMAT(#{time}, '%Y-%m' ) + </if> + <if test="userName != null and userName != ''"> + and u2.name like concat('%', #{userName}, '%') + </if> + </where> + order by s.create_time + GROUP BY u2.id + </select> + + <select id="performanceShiftYearPage" resultType="map"> + SELECT + s.user_id, s.shift + FROM performance_shift s + LEFT JOIN (SELECT u.* from + user u + left join department_lims dl on FIND_IN_SET(dl.id,u.depart_lims_id) + where state=1 + <if test="laboratory != null and laboratory != ''"> + and dl.name=#{laboratory} + </if> + ) u2 on u2.id = s.user_id + where s.shift is not NULL + and s.shift != '' + and name is not null + <if test="time != null and time != ''"> + and DATE_FORMAT(s.work_time, '%Y') = DATE_FORMAT(#{time}, '%Y' ) + </if> + <if test="userName != null and userName != ''"> + and u2.name like concat('%', #{userName}, '%') + </if> + order by s.create_time + </select> + + <select id="performanceShiftYear" resultType="java.util.Map"> + SELECT if(u2.department is not null and u2.department != '', CONCAT(u2.name, '锛�', u2.department, '锛�'), u2.name) name, + s.user_id, u2.account, + DATE_FORMAT(s.work_time, '%c') work_time, + GROUP_CONCAT(DATE_FORMAT(s.work_time, '%c'), '锛�', s.shift order by s.work_time SEPARATOR ';') month_str + FROM performance_shift s + LEFT JOIN (SELECT u.* from + user u + left join department_lims dl on FIND_IN_SET(dl.id,u.depart_lims_id) + where state=1 + <if test="laboratory != null and laboratory != ''"> + and dl.name=#{laboratory} + </if> + ) u2 on u2.id = s.user_id + where s.shift is not NULL + and s.shift != '' + and name is not null + <if test="time != null and time != ''"> + and DATE_FORMAT(s.work_time, '%Y') = DATE_FORMAT(#{time}, '%Y' ) + </if> + <if test="userName != null and userName != ''"> + and u.name like concat('%', #{userName}, '%') + </if> + GROUP BY u2.id + order by s.create_time + </select> + + <select id="performanceShiftYearList" resultType="map"> + SELECT if(u.department is not null and u.department != '', CONCAT(u.name, '锛�', u.department, '锛�'), u.name) name, + s.user_id, u.account, + DATE_FORMAT(s.work_time, '%c') work_time, + GROUP_CONCAT(DATE_FORMAT(s.work_time, '%c'), '锛�', s.shift order by s.work_time SEPARATOR ';') month_str + FROM performance_shift s + LEFT JOIN user u on u.id = s.user_id + where s.shift is not NULL + and s.shift != '' + <if test="time != null and time != ''"> + and DATE_FORMAT(s.work_time, '%Y') = DATE_FORMAT(#{time}, '%Y' ) + </if> + <if test="userName != null and userName != ''"> + and u.name like concat('%', #{userName}, '%') + </if> + <if test="laboratory != null and laboratory != ''"> + </if> + GROUP BY u.id + order by s.create_time + </select> + + <select id="performanceShiftList" resultMap="performanceShiftPageMap"> + SELECT + if(u.department is not null and u.department != '', CONCAT(u.name, '锛�', u.department, '锛�'), u.name) name, + GROUP_CONCAT(s.work_time, '锛�', s.shift, '锛�', s.id order by s.work_time SEPARATOR ';') AS shift_time, u.id user_id, u.department + FROM performance_shift s + LEFT JOIN user u on u.id = s.user_id + <where> + <if test="time != null and time != ''"> + and DATE_FORMAT(s.work_time, '%Y-%m') = DATE_FORMAT(#{time}, '%Y-%m' ) + </if> + <if test="userName != null and userName != ''"> + and u.name like concat('%', #{userName}, '%') + </if> + <if test="laboratory != null and laboratory != ''"> + </if> + </where> + order by s.create_time + GROUP BY u.id + </select> + + <select id="seldepLimsId" resultType="java.lang.String"> + select name + from department_lims + where id = #{depLimsId} + </select> +</mapper> diff --git a/performance-server/src/main/resources/mapper/ShiftTimeMapper.xml b/performance-server/src/main/resources/mapper/ShiftTimeMapper.xml new file mode 100644 index 0000000..49ac714 --- /dev/null +++ b/performance-server/src/main/resources/mapper/ShiftTimeMapper.xml @@ -0,0 +1,17 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> +<mapper namespace="com.ruoyi.performance.mapper.ShiftTimeMapper"> + + <!-- 閫氱敤鏌ヨ鏄犲皠缁撴灉 --> + <resultMap id="BaseResultMap" type="com.ruoyi.performance.pojo.ShiftTime"> + <id column="id" property="id" /> + <result column="shift" property="shift" /> + <result column="start_time" property="startTime" /> + <result column="end_time" property="endTime" /> + <result column="create_user" property="createUser" /> + <result column="create_time" property="createTime" /> + <result column="update_user" property="updateUser" /> + <result column="update_time" property="updateTime" /> + </resultMap> + +</mapper> diff --git a/pom.xml b/pom.xml index c3043d4..ab947ba 100644 --- a/pom.xml +++ b/pom.xml @@ -77,6 +77,13 @@ <scope>import</scope> </dependency> + <!--鍚庣娉ㄩ噴妫�楠屽伐鍏�--> + <dependency> + <groupId>org.springframework.boot</groupId> + <artifactId>spring-boot-starter-validation</artifactId> + <version>${spring-boot.version}</version> + </dependency> + <!-- 瑕嗙洊logback鐨勪緷璧栭厤缃�--> <dependency> <groupId>ch.qos.logback</groupId> @@ -331,6 +338,7 @@ <module>ruoyi-common</module> <module>basic-server</module> <module>inspect-server</module> + <module>performance-server</module> </modules> <packaging>pom</packaging> diff --git a/ruoyi-admin/pom.xml b/ruoyi-admin/pom.xml index 07b1109..0009314 100644 --- a/ruoyi-admin/pom.xml +++ b/ruoyi-admin/pom.xml @@ -80,6 +80,13 @@ <version>${ruoyi.version}</version> </dependency> + <!--缁╂晥妯″潡--> + <dependency> + <groupId>com.ruoyi</groupId> + <artifactId>performance-server</artifactId> + <version>${ruoyi.version}</version> + </dependency> + </dependencies> <build> diff --git a/ruoyi-common/pom.xml b/ruoyi-common/pom.xml index d5d7042..ef7ea58 100644 --- a/ruoyi-common/pom.xml +++ b/ruoyi-common/pom.xml @@ -141,6 +141,10 @@ <artifactId>commons-text</artifactId> <version>1.3</version> </dependency> + <dependency> + <groupId>com.fasterxml.jackson.datatype</groupId> + <artifactId>jackson-datatype-jsr310</artifactId> + </dependency> </dependencies> </project> diff --git a/ruoyi-common/src/main/java/com/ruoyi/common/utils/JackSonUtil.java b/ruoyi-common/src/main/java/com/ruoyi/common/utils/JackSonUtil.java new file mode 100644 index 0000000..f463e6f --- /dev/null +++ b/ruoyi-common/src/main/java/com/ruoyi/common/utils/JackSonUtil.java @@ -0,0 +1,133 @@ +package com.ruoyi.common.utils; + +import com.fasterxml.jackson.core.JsonGenerationException; +import com.fasterxml.jackson.core.JsonParseException; +import com.fasterxml.jackson.databind.JsonMappingException; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.ObjectWriter; +import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule; +import org.springframework.stereotype.Component; + +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; + +/** + * JSON瑙f瀽澶勭悊 + * + * @author 寮犲 + */ +@Component +public class JackSonUtil { + private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper(); + private static final ObjectWriter OBJECT_WRITER = OBJECT_MAPPER.writerWithDefaultPrettyPrinter(); + + public static void marshal(File file, Object value) throws Exception { + try { + OBJECT_WRITER.writeValue(file, value); + } catch (JsonGenerationException e) { + throw new Exception(e); + } catch (JsonMappingException e) { + throw new Exception(e); + } catch (IOException e) { + throw new Exception(e); + } + } + + public static void marshal(OutputStream os, Object value) throws Exception { + try { + OBJECT_WRITER.writeValue(os, value); + } catch (JsonGenerationException e) { + throw new Exception(e); + } catch (JsonMappingException e) { + throw new Exception(e); + } catch (IOException e) { + throw new Exception(e); + } + } + + public static String marshal(Object value) throws Exception { + try { + return OBJECT_WRITER.writeValueAsString(value); + } catch (JsonGenerationException e) { + throw new Exception(e); + } catch (JsonMappingException e) { + throw new Exception(e); + } catch (IOException e) { + throw new Exception(e); + } + } + + public static byte[] marshalBytes(Object value) throws Exception { + try { + return OBJECT_WRITER.writeValueAsBytes(value); + } catch (JsonGenerationException e) { + throw new Exception(e); + } catch (JsonMappingException e) { + throw new Exception(e); + } catch (IOException e) { + throw new Exception(e); + } + } + + public static <T> T unmarshal(File file, Class<T> valueType) throws Exception { + try { + return OBJECT_MAPPER.readValue(file, valueType); + } catch (JsonParseException e) { + throw new Exception(e); + } catch (JsonMappingException e) { + throw new Exception(e); + } catch (IOException e) { + throw new Exception(e); + } + } + + public static <T> T unmarshal(InputStream is, Class<T> valueType) throws Exception { + try { + return OBJECT_MAPPER.readValue(is, valueType); + } catch (JsonParseException e) { + throw new Exception(e); + } catch (JsonMappingException e) { + throw new Exception(e); + } catch (IOException e) { + throw new Exception(e); + } + } + + /** + * 瀛楃涓茶浆瀵硅薄 + * @param str + * @param valueType + * @return + * @param <T> + * @throws Exception + */ + public static <T> T unmarshal(String str, Class<T> valueType) throws Exception { + try { + OBJECT_MAPPER.registerModule(new JavaTimeModule()); + return OBJECT_MAPPER.readValue(str, valueType); + } catch (JsonParseException e) { + throw new Exception(e); + } catch (JsonMappingException e) { + throw new Exception(e); + } catch (IOException e) { + throw new Exception(e); + } + } + + public static <T> T unmarshal(byte[] bytes, Class<T> valueType) throws Exception { + try { + if (bytes == null) { + bytes = new byte[0]; + } + return OBJECT_MAPPER.readValue(bytes, 0, bytes.length, valueType); + } catch (JsonParseException e) { + throw new Exception(e); + } catch (JsonMappingException e) { + throw new Exception(e); + } catch (IOException e) { + throw new Exception(e); + } + } +} diff --git a/ruoyi-system/src/main/java/com/ruoyi/system/mapper/CustomMapper.java b/ruoyi-system/src/main/java/com/ruoyi/system/mapper/CustomMapper.java index e0d4108..71798e8 100644 --- a/ruoyi-system/src/main/java/com/ruoyi/system/mapper/CustomMapper.java +++ b/ruoyi-system/src/main/java/com/ruoyi/system/mapper/CustomMapper.java @@ -5,12 +5,13 @@ import com.baomidou.mybatisplus.core.metadata.IPage; import com.ruoyi.common.core.domain.entity.Custom; import org.apache.ibatis.annotations.Mapper; +import org.apache.ibatis.annotations.Param; import org.springframework.stereotype.Repository; @Mapper public interface CustomMapper extends BaseMapper<Custom> { - IPage<Custom> selectCustomPageList(IPage<Custom> page, QueryWrapper<Custom> ew); + IPage<Custom> selectCustomPageList(IPage<Custom> page, @Param("ew") QueryWrapper<Custom> ew); int delCustomById(Integer id); -- Gitblit v1.9.3