pref修改

yangys

2024-03-31 2969df3e404db3cd116f27db1495e523ce05bf86

pref修改

 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();