pref修改

yangys

2024-03-31 2969df3e404db3cd116f27db1495e523ce05bf86

 smart-man-boot/src/main/java/com/qianwen/smartman/modules/perf/service/impl/EmployeeOnOffWorkServiceImpl.java

@@ -1,18 +1,25 @@
package com.qianwen.smartman.modules.perf.service.impl;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import java.lang.invoke.SerializedLambda;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

import org.apache.commons.compress.utils.Lists;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.qianwen.core.log.exception.ServiceException;
import com.qianwen.core.mp.base.BaseEntity;
import com.qianwen.core.mp.service.impl.BladeServiceImpl;
import com.qianwen.core.mp.support.Condition;
import com.qianwen.core.secure.utils.AuthUtil;
import com.qianwen.core.tool.utils.DateUtil;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.core.tool.utils.SpringUtil;
import com.qianwen.smartman.common.cache.cps.EmployeeCache;
import com.qianwen.smartman.common.constant.CommonGroupConstant;
import com.qianwen.smartman.common.enums.CommonGroupTypeEnum;
@@ -22,15 +29,6 @@
import com.qianwen.smartman.common.utils.MessageUtils;
import com.qianwen.smartman.common.utils.TimeUtils;
import com.qianwen.smartman.common.utils.TreeUtils;
import com.qianwen.core.log.exception.ServiceException;
import com.qianwen.core.mp.base.BaseEntity;
import com.qianwen.core.mp.service.impl.BladeServiceImpl;
import com.qianwen.core.mp.support.Condition;
import com.qianwen.core.notify.DefaultNotifyType;
import com.qianwen.core.secure.utils.AuthUtil;
import com.qianwen.core.tool.utils.DateUtil;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.core.tool.utils.SpringUtil;
import com.qianwen.smartman.modules.cps.entity.Workstation;
import com.qianwen.smartman.modules.cps.service.IEmployeeService;
import com.qianwen.smartman.modules.cps.service.IWorkstationService;
@@ -55,12 +53,9 @@
import com.qianwen.smartman.modules.perf.vo.QueryWorkStatusVO;
import com.qianwen.smartman.modules.perf.vo.SearchEmployeeWorkVO;
import com.qianwen.smartman.modules.perf.vo.SearchWorkEmployeeVO;
import org.springframework.stereotype.Service;

public class EmployeeOnOffWorkServiceImpl extends BladeServiceImpl<EmployeeOnOffWorkMapper, EmployeeOnOffWork> implements IEmployeeOnOffWorkService {
     private static final Logger log = LoggerFactory.getLogger(com.qianwen.smartman.modules.perf.service.impl.EmployeeOnOffWorkServiceImpl.class);
	  
     static final /* synthetic */ int[] $SwitchMap$com$qianwen$smartman$modules$perf$enums$WorkStatusEnum;
     
     private final IEmployeeService employeeService;
     
@@ -76,9 +71,25 @@
     
     public List<EmployeeWorkStatusVO> allWorkstationStatus(QueryWorkStatusVO vo) {
       List<WorkstationBO> workstations = vo.getWorkstations();
       if (Func.isEmpty(workstations))
       if (Func.isEmpty(workstations)) {
         return Lists.newArrayList(); 
       }
	    
       WorkStatusEnum queryType = vo.getQueryType();
       switch(queryType) {
       case ALL://0
          return allWorkStatusList(workstations);
       case ON://1
          return onWorkStatusList(workstations, OnOffWorkEnum.WILL_OFF.getCode());
	    	
       case OFF://2
          return offWorkStatusList(workstations, OnOffWorkEnum.WILL_OFF.getCode());
       case MY:
          return currentEmployeeWork(workstations);
	    	
       }
	  
       /*
       switch ($SwitchMap$com$qianwen$smartman$modules$perf$enums$WorkStatusEnum[queryType.ordinal()]) {
                               //com.qianwen.smartman.modules.perf.enums.WorkStatusEnum
         case 1:
@@ -89,7 +100,7 @@
           return offWorkStatusList(workstations, OnOffWorkEnum.WILL_OFF.getCode());
         case 4:
           return currentEmployeeWork(workstations);
       } 
       }*/
       return Lists.newArrayList();
     }
     
@@ -101,6 +112,17 @@
       Integer type = vo.getType();
       List<Long> workstationIds = (List<Long>)vo.getWorks().stream().map(WorkstationBO::getId).collect(Collectors.toList());
       EmployeeCache.clearPerfCache(workstationIds);
	    
       switch (OnOffWorkEnum.of(type)) {
         case WILL_ON:
           batchOnWorkstation(vo);
           break;
         case WILL_OFF:
           batchOffWorkstation(vo);
           break;
       } 
	    
       /*
       switch ($SwitchMap$com$qianwen$smartman$modules$perf$enums$WorkStatusEnum[OnOffWorkEnum.of(type).ordinal()]) {
         case 1:
           batchOnWorkstation(vo);
@@ -108,7 +130,7 @@
         case 2:
           batchOffWorkstation(vo);
           break;
       } 
       } */
       this.employeeSendService.sendMessageRocket(workstationIds);
       return Boolean.valueOf(true);
     }
@@ -128,32 +150,33 @@
     public IPage<EmployeeOnOffWorkVO> queryOnOffLog(QueryEmployeeLogVO vo) {
       IPage<EmployeeOnOffWork> page;
       if (Func.isEmpty(vo.getWorkstationIds()))
         return (IPage<EmployeeOnOffWorkVO>)new Page(); 
         return new Page<>(); 
	    
       String dbType = SpringUtil.getContext().getEnvironment().getProperty("datasource.type");
       String startTime = TimeUtils.getStartTime(vo.getStartTime());
       String endTime = TimeUtils.getEndTime(vo.getEndTime());
       if (DbTypeEnum.ORACLE.getCode().equals(dbType)) {
         page = page(Condition.getPage(vo.getQuery()), 
             (Wrapper)((ExtraLambdaQueryWrapper)Lambda.in(Func.isNotEmpty(vo.getEmployeeIds()), EmployeeOnOffWork::getOnEmployeeId, vo.getEmployeeIds())
             .in(EmployeeOnOffWork::getWorkstationId, vo.getWorkstationIds()))
             Lambda.in(Func.isNotEmpty(vo.getEmployeeIds()), EmployeeOnOffWork::getOnEmployeeId, vo.getEmployeeIds())
             .in(EmployeeOnOffWork::getWorkstationId, vo.getWorkstationIds())
             .nested(nt -> {
                ExtraLambdaQueryWrapper extraLambdaQueryWrapper = (ExtraLambdaQueryWrapper) nt.apply("(online_time between TO_DATE({0}, 'yyyy-mm-dd hh24:mi:ss') and TO_DATE({1}, 'yyyy-mm-dd hh24:mi:ss')) or (offline_time between TO_DATE({2}, 'yyyy-mm-dd hh24:mi:ss') and TO_DATE({3}, 'yyyy-mm-dd hh24:mi:ss'))", new Object[] { startTime, endTime, startTime, endTime });
                ExtraLambdaQueryWrapper extraLambdaQueryWrapper = nt.apply("(online_time between TO_DATE({0}, 'yyyy-mm-dd hh24:mi:ss') and TO_DATE({1}, 'yyyy-mm-dd hh24:mi:ss')) or (offline_time between TO_DATE({2}, 'yyyy-mm-dd hh24:mi:ss') and TO_DATE({3}, 'yyyy-mm-dd hh24:mi:ss'))", new Object[] { startTime, endTime, startTime, endTime });
                }));
       } else {
         page = page(Condition.getPage(vo.getQuery()), 
             (Wrapper)((ExtraLambdaQueryWrapper)Lambda.in(Func.isNotEmpty(vo.getEmployeeIds()), EmployeeOnOffWork::getOnEmployeeId, vo.getEmployeeIds())
             .nested(n -> (ExtraLambdaQueryWrapper)((ExtraLambdaQueryWrapper)((ExtraLambdaQueryWrapper)n.between(EmployeeOnOffWork::getOnlineTime, startTime, endTime)).or()).between(EmployeeOnOffWork::getOfflineTime, startTime, endTime)))
             Lambda.in(Func.isNotEmpty(vo.getEmployeeIds()), EmployeeOnOffWork::getOnEmployeeId, vo.getEmployeeIds())
             .nested(n -> n.between(EmployeeOnOffWork::getOnlineTime, startTime, endTime).or().between(EmployeeOnOffWork::getOfflineTime, startTime, endTime))
             
             .in(EmployeeOnOffWork::getWorkstationId, vo.getWorkstationIds()));
       } 
       List<EmployeeOnOffWork> records = page.getRecords();
       if (Func.isEmpty(records))
         return (IPage<EmployeeOnOffWorkVO>)new Page(); 
       Page page1 = new Page(page.getCurrent(), page.getSize(), page.getTotal());
       page1.setRecords((List)records.stream()
         return new Page<>(); 
       Page<EmployeeOnOffWorkVO>  page1 = new Page<>(page.getCurrent(), page.getSize(), page.getTotal());
       page1.setRecords(records.stream()
           .map(com.qianwen.smartman.modules.perf.service.impl.EmployeeOnOffWorkServiceImpl::convertWork)
           .collect(Collectors.toList()));
       return (IPage<EmployeeOnOffWorkVO>)page1;
       return page1;
     }
     
     public List<WorkstationBO> employeeWork(SearchEmployeeWorkVO vo) {
@@ -162,10 +185,10 @@
       String startTime = DateUtil.formatDateTime(vo.getStartTime());
       String endTime = DateUtil.formatDateTime(vo.getEndTime());
       if (DbTypeEnum.ORACLE.getCode().equals(dbType)) {
         works = list((Wrapper)Lambda.eq(EmployeeOnOffWork::getOnEmployeeId, vo.getEmployeeId())
             .nested(nt -> (ExtraLambdaQueryWrapper)nt.apply("(online_time between TO_DATE({0}, 'yyyy-mm-dd hh24:mi:ss') and TO_DATE({1}, 'yyyy-mm-dd hh24:mi:ss'))", new Object[] { startTime, endTime })));
         works = list(Lambda.eq(EmployeeOnOffWork::getOnEmployeeId, vo.getEmployeeId())
             .nested(nt -> nt.apply("(online_time between TO_DATE({0}, 'yyyy-mm-dd hh24:mi:ss') and TO_DATE({1}, 'yyyy-mm-dd hh24:mi:ss'))", new Object[] { startTime, endTime })));
       } else {
         works = list((Wrapper)Lambda.eq(EmployeeOnOffWork::getOnEmployeeId, vo.getEmployeeId())
         works = list(Lambda.eq(EmployeeOnOffWork::getOnEmployeeId, vo.getEmployeeId())
             .between(EmployeeOnOffWork::getOnlineTime, startTime, endTime));
       } 
       if (Func.isEmpty(works))
@@ -183,10 +206,10 @@
       String startTime = DateUtil.formatDateTime(vo.getStartTime());
       String endTime = DateUtil.formatDateTime(vo.getEndTime());
       if (DbTypeEnum.ORACLE.getCode().equals(dbType)) {
         works = list((Wrapper)Lambda.eq(EmployeeOnOffWork::getWorkstationId, vo.getWorkstationId())
             .nested(nt -> (ExtraLambdaQueryWrapper)nt.apply("(online_time between TO_DATE({0}, 'yyyy-mm-dd hh24:mi:ss') and TO_DATE({1}, 'yyyy-mm-dd hh24:mi:ss'))", new Object[] { startTime, endTime })));
         works = list(Lambda.eq(EmployeeOnOffWork::getWorkstationId, vo.getWorkstationId())
             .nested(nt -> nt.apply("(online_time between TO_DATE({0}, 'yyyy-mm-dd hh24:mi:ss') and TO_DATE({1}, 'yyyy-mm-dd hh24:mi:ss'))", new Object[] { startTime, endTime })));
       } else {
         works = list((Wrapper)Lambda.eq(EmployeeOnOffWork::getWorkstationId, vo.getWorkstationId())
         works = list(Lambda.eq(EmployeeOnOffWork::getWorkstationId, vo.getWorkstationId())
             .between(EmployeeOnOffWork::getOnlineTime, startTime, endTime));
       } 
       if (Func.isEmpty(works))
@@ -208,13 +231,13 @@
     
     public void currentEmployeeWork(String employeeId, String workstationId) {
      
       List<EmployeeOnOffWork> currEmployeeId = list((Wrapper)((LambdaQueryWrapper)Wrappers.lambdaQuery()
           .eq(EmployeeOnOffWork::getOnEmployeeId, employeeId))
       List<EmployeeOnOffWork> currEmployeeId = list(Wrappers.<EmployeeOnOffWork>lambdaQuery()
           .eq(EmployeeOnOffWork::getOnEmployeeId, employeeId)
           .eq(EmployeeOnOffWork::getOnlineType, OnOffWorkEnum.WILL_OFF.getCode()));
       if (Func.isNotEmpty(currEmployeeId))
         throw new ServiceException(MessageUtils.message("perf.current.employee.login", new Object[0])); 
       List<EmployeeOnOffWork> works = list((Wrapper)((LambdaQueryWrapper)Wrappers.lambdaQuery()
           .eq(EmployeeOnOffWork::getWorkstationId, workstationId))
       List<EmployeeOnOffWork> works = list(Wrappers.<EmployeeOnOffWork>lambdaQuery()
           .eq(EmployeeOnOffWork::getWorkstationId, workstationId)
           .eq(EmployeeOnOffWork::getOnlineType, OnOffWorkEnum.WILL_OFF.getCode()));
       if (Func.isNotEmpty(works))
         throw new ServiceException(MessageUtils.message("perf.current.work.login", new Object[0])); 
@@ -277,10 +300,10 @@
       EmployeeVO employee = currentEmployee();
       if (Func.isNull(employee))
         return Lists.newArrayList(); 
       List<Long> wIds = (List<Long>)workstations.stream().map(WorkstationBO::getId).collect(Collectors.toList());
       List<EmployeeOnOffWork> works = list((Wrapper)((ExtraLambdaQueryWrapper)((ExtraLambdaQueryWrapper)Lambda.create()
           .in(EmployeeOnOffWork::getWorkstationId, wIds))
           .eq(EmployeeOnOffWork::getOnEmployeeId, employee.getId()))
       List<Long> wIds = workstations.stream().map(WorkstationBO::getId).collect(Collectors.toList());
       List<EmployeeOnOffWork> works = list(Lambda.<EmployeeOnOffWork>create()
           .in(EmployeeOnOffWork::getWorkstationId, wIds)
           .eq(EmployeeOnOffWork::getOnEmployeeId, employee.getId())
           .eq(EmployeeOnOffWork::getOnlineType, OnOffWorkEnum.WILL_OFF.getCode()));
       if (Func.isEmpty(works))
         return Lists.newArrayList();