update by wangzq

PC

2024-03-31 8c9ba6667b89cc0494d05b5da4355dde205b8d4a

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

@@ -23,8 +23,10 @@
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;
@@ -55,487 +57,308 @@
import com.qianwen.smartman.modules.perf.vo.SearchWorkEmployeeVO;
import org.springframework.stereotype.Service;

@Service
/* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/perf/service/impl/EmployeeOnOffWorkServiceImpl.class */
public class EmployeeOnOffWorkServiceImpl extends BladeServiceImpl<EmployeeOnOffWorkMapper, EmployeeOnOffWork> implements IEmployeeOnOffWorkService {
    private static final Logger log = LoggerFactory.getLogger(EmployeeOnOffWorkServiceImpl.class);
    private final IEmployeeService employeeService;
    private final IWorkstationService workstationService;
    private final IEmployeeSendService employeeSendService;

    private static /* synthetic */ Object $deserializeLambda$(SerializedLambda lambda) {
        String implMethodName = lambda.getImplMethodName();
        boolean z = true;
        switch (implMethodName.hashCode()) {
            case -698756170:
                if (implMethodName.equals("getOnlineTime")) {
                    z = true;
                    break;
                }
                break;
            case -698740701:
                if (implMethodName.equals("getOnlineType")) {
                    z = true;
                    break;
                }
                break;
            case -557259320:
                if (implMethodName.equals("getWorkstationId")) {
                    z = false;
                    break;
                }
                break;
            case 408973850:
                if (implMethodName.equals("getOfflineTime")) {
                    z = true;
                    break;
                }
                break;
            case 840166942:
                if (implMethodName.equals("getOnEmployeeId")) {
                    z = true;
                    break;
                }
                break;
        }
        switch (z) {
            case false:
                if (lambda.getImplMethodKind() == 5 && lambda.getFunctionalInterfaceClass().equals("com/baomidou/mybatisplus/core/toolkit/support/SFunction") && lambda.getFunctionalInterfaceMethodName().equals("apply") && lambda.getFunctionalInterfaceMethodSignature().equals("(Ljava/lang/Object;)Ljava/lang/Object;") && lambda.getImplClass().equals("org/springblade/modules/perf/entity/EmployeeOnOffWork") && lambda.getImplMethodSignature().equals("()Ljava/lang/Long;")) {
                    return (v0) -> {
                        return v0.getWorkstationId();
                    };
                }
                if (lambda.getImplMethodKind() == 5 && lambda.getFunctionalInterfaceClass().equals("com/baomidou/mybatisplus/core/toolkit/support/SFunction") && lambda.getFunctionalInterfaceMethodName().equals("apply") && lambda.getFunctionalInterfaceMethodSignature().equals("(Ljava/lang/Object;)Ljava/lang/Object;") && lambda.getImplClass().equals("org/springblade/modules/perf/entity/EmployeeOnOffWork") && lambda.getImplMethodSignature().equals("()Ljava/lang/Long;")) {
                    return (v0) -> {
                        return v0.getWorkstationId();
                    };
                }
                if (lambda.getImplMethodKind() == 5 && lambda.getFunctionalInterfaceClass().equals("com/baomidou/mybatisplus/core/toolkit/support/SFunction") && lambda.getFunctionalInterfaceMethodName().equals("apply") && lambda.getFunctionalInterfaceMethodSignature().equals("(Ljava/lang/Object;)Ljava/lang/Object;") && lambda.getImplClass().equals("org/springblade/modules/perf/entity/EmployeeOnOffWork") && lambda.getImplMethodSignature().equals("()Ljava/lang/Long;")) {
                    return (v0) -> {
                        return v0.getWorkstationId();
                    };
                }
                if (lambda.getImplMethodKind() == 5 && lambda.getFunctionalInterfaceClass().equals("com/baomidou/mybatisplus/core/toolkit/support/SFunction") && lambda.getFunctionalInterfaceMethodName().equals("apply") && lambda.getFunctionalInterfaceMethodSignature().equals("(Ljava/lang/Object;)Ljava/lang/Object;") && lambda.getImplClass().equals("org/springblade/modules/perf/entity/EmployeeOnOffWork") && lambda.getImplMethodSignature().equals("()Ljava/lang/Long;")) {
                    return (v0) -> {
                        return v0.getWorkstationId();
                    };
                }
                if (lambda.getImplMethodKind() == 5 && lambda.getFunctionalInterfaceClass().equals("com/baomidou/mybatisplus/core/toolkit/support/SFunction") && lambda.getFunctionalInterfaceMethodName().equals("apply") && lambda.getFunctionalInterfaceMethodSignature().equals("(Ljava/lang/Object;)Ljava/lang/Object;") && lambda.getImplClass().equals("org/springblade/modules/perf/entity/EmployeeOnOffWork") && lambda.getImplMethodSignature().equals("()Ljava/lang/Long;")) {
                    return (v0) -> {
                        return v0.getWorkstationId();
                    };
                }
                if (lambda.getImplMethodKind() == 5 && lambda.getFunctionalInterfaceClass().equals("com/baomidou/mybatisplus/core/toolkit/support/SFunction") && lambda.getFunctionalInterfaceMethodName().equals("apply") && lambda.getFunctionalInterfaceMethodSignature().equals("(Ljava/lang/Object;)Ljava/lang/Object;") && lambda.getImplClass().equals("org/springblade/modules/perf/entity/EmployeeOnOffWork") && lambda.getImplMethodSignature().equals("()Ljava/lang/Long;")) {
                    return (v0) -> {
                        return v0.getWorkstationId();
                    };
                }
                break;
            case true:
                if (lambda.getImplMethodKind() == 5 && lambda.getFunctionalInterfaceClass().equals("com/baomidou/mybatisplus/core/toolkit/support/SFunction") && lambda.getFunctionalInterfaceMethodName().equals("apply") && lambda.getFunctionalInterfaceMethodSignature().equals("(Ljava/lang/Object;)Ljava/lang/Object;") && lambda.getImplClass().equals("org/springblade/modules/perf/entity/EmployeeOnOffWork") && lambda.getImplMethodSignature().equals("()Ljava/lang/Integer;")) {
                    return (v0) -> {
                        return v0.getOnlineType();
                    };
                }
                if (lambda.getImplMethodKind() == 5 && lambda.getFunctionalInterfaceClass().equals("com/baomidou/mybatisplus/core/toolkit/support/SFunction") && lambda.getFunctionalInterfaceMethodName().equals("apply") && lambda.getFunctionalInterfaceMethodSignature().equals("(Ljava/lang/Object;)Ljava/lang/Object;") && lambda.getImplClass().equals("org/springblade/modules/perf/entity/EmployeeOnOffWork") && lambda.getImplMethodSignature().equals("()Ljava/lang/Integer;")) {
                    return (v0) -> {
                        return v0.getOnlineType();
                    };
                }
                if (lambda.getImplMethodKind() == 5 && lambda.getFunctionalInterfaceClass().equals("com/baomidou/mybatisplus/core/toolkit/support/SFunction") && lambda.getFunctionalInterfaceMethodName().equals("apply") && lambda.getFunctionalInterfaceMethodSignature().equals("(Ljava/lang/Object;)Ljava/lang/Object;") && lambda.getImplClass().equals("org/springblade/modules/perf/entity/EmployeeOnOffWork") && lambda.getImplMethodSignature().equals("()Ljava/lang/Integer;")) {
                    return (v0) -> {
                        return v0.getOnlineType();
                    };
                }
                break;
            case true:
                if (lambda.getImplMethodKind() == 5 && lambda.getFunctionalInterfaceClass().equals("com/baomidou/mybatisplus/core/toolkit/support/SFunction") && lambda.getFunctionalInterfaceMethodName().equals("apply") && lambda.getFunctionalInterfaceMethodSignature().equals("(Ljava/lang/Object;)Ljava/lang/Object;") && lambda.getImplClass().equals("org/springblade/modules/perf/entity/EmployeeOnOffWork") && lambda.getImplMethodSignature().equals("()Ljava/util/Date;")) {
                    return (v0) -> {
                        return v0.getOfflineTime();
                    };
                }
                break;
            case true:
                if (lambda.getImplMethodKind() == 5 && lambda.getFunctionalInterfaceClass().equals("com/baomidou/mybatisplus/core/toolkit/support/SFunction") && lambda.getFunctionalInterfaceMethodName().equals("apply") && lambda.getFunctionalInterfaceMethodSignature().equals("(Ljava/lang/Object;)Ljava/lang/Object;") && lambda.getImplClass().equals("org/springblade/modules/perf/entity/EmployeeOnOffWork") && lambda.getImplMethodSignature().equals("()Ljava/lang/Long;")) {
                    return (v0) -> {
                        return v0.getOnEmployeeId();
                    };
                }
                if (lambda.getImplMethodKind() == 5 && lambda.getFunctionalInterfaceClass().equals("com/baomidou/mybatisplus/core/toolkit/support/SFunction") && lambda.getFunctionalInterfaceMethodName().equals("apply") && lambda.getFunctionalInterfaceMethodSignature().equals("(Ljava/lang/Object;)Ljava/lang/Object;") && lambda.getImplClass().equals("org/springblade/modules/perf/entity/EmployeeOnOffWork") && lambda.getImplMethodSignature().equals("()Ljava/lang/Long;")) {
                    return (v0) -> {
                        return v0.getOnEmployeeId();
                    };
                }
                if (lambda.getImplMethodKind() == 5 && lambda.getFunctionalInterfaceClass().equals("com/baomidou/mybatisplus/core/toolkit/support/SFunction") && lambda.getFunctionalInterfaceMethodName().equals("apply") && lambda.getFunctionalInterfaceMethodSignature().equals("(Ljava/lang/Object;)Ljava/lang/Object;") && lambda.getImplClass().equals("org/springblade/modules/perf/entity/EmployeeOnOffWork") && lambda.getImplMethodSignature().equals("()Ljava/lang/Long;")) {
                    return (v0) -> {
                        return v0.getOnEmployeeId();
                    };
                }
                if (lambda.getImplMethodKind() == 5 && lambda.getFunctionalInterfaceClass().equals("com/baomidou/mybatisplus/core/toolkit/support/SFunction") && lambda.getFunctionalInterfaceMethodName().equals("apply") && lambda.getFunctionalInterfaceMethodSignature().equals("(Ljava/lang/Object;)Ljava/lang/Object;") && lambda.getImplClass().equals("org/springblade/modules/perf/entity/EmployeeOnOffWork") && lambda.getImplMethodSignature().equals("()Ljava/lang/Long;")) {
                    return (v0) -> {
                        return v0.getOnEmployeeId();
                    };
                }
                if (lambda.getImplMethodKind() == 5 && lambda.getFunctionalInterfaceClass().equals("com/baomidou/mybatisplus/core/toolkit/support/SFunction") && lambda.getFunctionalInterfaceMethodName().equals("apply") && lambda.getFunctionalInterfaceMethodSignature().equals("(Ljava/lang/Object;)Ljava/lang/Object;") && lambda.getImplClass().equals("org/springblade/modules/perf/entity/EmployeeOnOffWork") && lambda.getImplMethodSignature().equals("()Ljava/lang/Long;")) {
                    return (v0) -> {
                        return v0.getOnEmployeeId();
                    };
                }
                if (lambda.getImplMethodKind() == 5 && lambda.getFunctionalInterfaceClass().equals("com/baomidou/mybatisplus/core/toolkit/support/SFunction") && lambda.getFunctionalInterfaceMethodName().equals("apply") && lambda.getFunctionalInterfaceMethodSignature().equals("(Ljava/lang/Object;)Ljava/lang/Object;") && lambda.getImplClass().equals("org/springblade/modules/perf/entity/EmployeeOnOffWork") && lambda.getImplMethodSignature().equals("()Ljava/lang/Long;")) {
                    return (v0) -> {
                        return v0.getOnEmployeeId();
                    };
                }
                break;
            case true:
                if (lambda.getImplMethodKind() == 5 && lambda.getFunctionalInterfaceClass().equals("com/baomidou/mybatisplus/core/toolkit/support/SFunction") && lambda.getFunctionalInterfaceMethodName().equals("apply") && lambda.getFunctionalInterfaceMethodSignature().equals("(Ljava/lang/Object;)Ljava/lang/Object;") && lambda.getImplClass().equals("org/springblade/modules/perf/entity/EmployeeOnOffWork") && lambda.getImplMethodSignature().equals("()Ljava/util/Date;")) {
                    return (v0) -> {
                        return v0.getOnlineTime();
                    };
                }
                if (lambda.getImplMethodKind() == 5 && lambda.getFunctionalInterfaceClass().equals("com/baomidou/mybatisplus/core/toolkit/support/SFunction") && lambda.getFunctionalInterfaceMethodName().equals("apply") && lambda.getFunctionalInterfaceMethodSignature().equals("(Ljava/lang/Object;)Ljava/lang/Object;") && lambda.getImplClass().equals("org/springblade/modules/perf/entity/EmployeeOnOffWork") && lambda.getImplMethodSignature().equals("()Ljava/util/Date;")) {
                    return (v0) -> {
                        return v0.getOnlineTime();
                    };
                }
                if (lambda.getImplMethodKind() == 5 && lambda.getFunctionalInterfaceClass().equals("com/baomidou/mybatisplus/core/toolkit/support/SFunction") && lambda.getFunctionalInterfaceMethodName().equals("apply") && lambda.getFunctionalInterfaceMethodSignature().equals("(Ljava/lang/Object;)Ljava/lang/Object;") && lambda.getImplClass().equals("org/springblade/modules/perf/entity/EmployeeOnOffWork") && lambda.getImplMethodSignature().equals("()Ljava/util/Date;")) {
                    return (v0) -> {
                        return v0.getOnlineTime();
                    };
                }
                break;
        }
        throw new IllegalArgumentException("Invalid lambda deserialization");
    }

    public EmployeeOnOffWorkServiceImpl(final IEmployeeService employeeService, final IWorkstationService workstationService, final IEmployeeSendService employeeSendService) {
        this.employeeService = employeeService;
        this.workstationService = workstationService;
        this.employeeSendService = employeeSendService;
    }

    @Override // org.springblade.modules.perf.service.IEmployeeOnOffWorkService
    public List<EmployeeWorkStatusVO> allWorkstationStatus(QueryWorkStatusVO vo) {
        List<WorkstationBO> workstations = vo.getWorkstations();
        if (Func.isEmpty(workstations)) {
            return Lists.newArrayList();
        }
        WorkStatusEnum queryType = vo.getQueryType();
        switch (queryType) {
            case ALL:
                return allWorkStatusList(workstations);
            case ON:
                return onWorkStatusList(workstations, OnOffWorkEnum.WILL_OFF.getCode());
            case OFF:
                return offWorkStatusList(workstations, OnOffWorkEnum.WILL_OFF.getCode());
            case MY:
                return currentEmployeeWork(workstations);
            default:
                return Lists.newArrayList();
        }
    }

    @Override // org.springblade.modules.perf.service.IEmployeeOnOffWorkService
    public EmployeeVO currentEmployee() {
        return this.employeeService.currentEmployee(AuthUtil.getUserId());
    }

    @Override // org.springblade.modules.perf.service.IEmployeeOnOffWorkService
    public Boolean batchOnOffWorkstation(BatchOnWorkVO vo) {
        vo.getType();
        List<Long> workstationIds = (List) vo.getWorks().stream().map((v0) -> {
            return v0.getId();
        }).collect(Collectors.toList());
        EmployeeCache.clearPerfCache(workstationIds);
        switch (OnOffWorkEnum.of(type)) {
            case WILL_ON:
                batchOnWorkstation(vo);
                break;
            case WILL_OFF:
                batchOffWorkstation(vo);
                break;
        }
        this.employeeSendService.sendMessageRocket(workstationIds);
        return true;
    }

    @Override // org.springblade.modules.perf.service.IEmployeeOnOffWorkService
    public List<GroupTreeVO> willOnWork() {
        List<GroupTreeVO> children = this.baseMapper.willOnWork(OnOffWorkEnum.WILL_OFF.getCode());
        CommonGroupTypeVO commonGroupType = new CommonGroupTypeVO().setGroupType(CommonGroupTypeEnum.WORKSTATION.getName()).setGroupCategory(CommonGroupConstant.DEFAULT_CATEGORY);
        return TreeUtils.allGroupTree(commonGroupType, children);
    }

    @Override // org.springblade.modules.perf.service.IEmployeeOnOffWorkService
    public List<OffEmployeeTreeVO> willOffWork() {
        List<OffEmployeeTreeVO> children = this.baseMapper.willOffWork(OnOffWorkEnum.WILL_OFF.getCode());
        CommonGroupTypeVO commonGroupType = new CommonGroupTypeVO().setGroupType(CommonGroupTypeEnum.WORKSTATION.getName()).setGroupCategory(CommonGroupConstant.DEFAULT_CATEGORY);
        return TreeUtils.allGroupTreeOff(commonGroupType, children);
    }

    @Override // org.springblade.modules.perf.service.IEmployeeOnOffWorkService
    public IPage<EmployeeOnOffWorkVO> queryOnOffLog(QueryEmployeeLogVO vo) {
        IPage<EmployeeOnOffWork> page;
        if (Func.isEmpty(vo.getWorkstationIds())) {
            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()), (v0) -> {
                return v0.getOnEmployeeId();
            }, vo.getEmployeeIds()).in((v0) -> {
                return v0.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});
            }));
        } else {
            page = page(Condition.getPage(vo.getQuery()), (Wrapper) ((ExtraLambdaQueryWrapper) Lambda.in(Func.isNotEmpty(vo.getEmployeeIds()), (v0) -> {
                return v0.getOnEmployeeId();
            }, vo.getEmployeeIds()).nested(n -> {
                ExtraLambdaQueryWrapper extraLambdaQueryWrapper = (ExtraLambdaQueryWrapper) ((ExtraLambdaQueryWrapper) ((ExtraLambdaQueryWrapper) n.between((v0) -> {
                    return v0.getOnlineTime();
                }, startTime, endTime)).or()).between((v0) -> {
                    return v0.getOfflineTime();
                }, startTime, endTime);
            })).in((v0) -> {
                return v0.getWorkstationId();
            }, vo.getWorkstationIds()));
        }
        List<EmployeeOnOffWork> records = page.getRecords();
        if (Func.isEmpty(records)) {
            return new Page();
        }
        Page page2 = new Page(page.getCurrent(), page.getSize(), page.getTotal());
        page2.setRecords((List) records.stream().map(EmployeeOnOffWorkServiceImpl::convertWork).collect(Collectors.toList()));
        return page2;
    }

    @Override // org.springblade.modules.perf.service.IEmployeeOnOffWorkService
    public List<WorkstationBO> employeeWork(SearchEmployeeWorkVO vo) {
        List<EmployeeOnOffWork> works;
        String dbType = SpringUtil.getContext().getEnvironment().getProperty("datasource.type");
        String startTime = DateUtil.formatDateTime(vo.getStartTime());
        String endTime = DateUtil.formatDateTime(vo.getEndTime());
        if (DbTypeEnum.ORACLE.getCode().equals(dbType)) {
            works = list((Wrapper) Lambda.eq((v0) -> {
                return v0.getOnEmployeeId();
            }, vo.getEmployeeId()).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'))", new Object[]{startTime, endTime});
            }));
        } else {
            works = list((Wrapper) Lambda.eq((v0) -> {
                return v0.getOnEmployeeId();
            }, vo.getEmployeeId()).between((v0) -> {
                return v0.getOnlineTime();
            }, startTime, endTime));
        }
        if (Func.isEmpty(works)) {
            return Lists.newArrayList();
        }
        return (List) works.stream().map(w -> {
            return WorkstationBO.builder().id(w.getWorkstationId()).workstationCode(w.getWorkstationCode()).workstationName(w.getWorkstationName()).build();
        }).filter(DistinctKeyUtil.distinctByKey((v0) -> {
            return v0.getId();
        })).collect(Collectors.toList());
    }

    @Override // org.springblade.modules.perf.service.IEmployeeOnOffWorkService
    public List<EmployeeVO> workEmployee(SearchWorkEmployeeVO vo) {
        List<EmployeeOnOffWork> works;
        String dbType = SpringUtil.getContext().getEnvironment().getProperty("datasource.type");
        String startTime = DateUtil.formatDateTime(vo.getStartTime());
        String endTime = DateUtil.formatDateTime(vo.getEndTime());
        if (DbTypeEnum.ORACLE.getCode().equals(dbType)) {
            works = list((Wrapper) Lambda.eq((v0) -> {
                return v0.getWorkstationId();
            }, vo.getWorkstationId()).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'))", new Object[]{startTime, endTime});
            }));
        } else {
            works = list((Wrapper) Lambda.eq((v0) -> {
                return v0.getWorkstationId();
            }, vo.getWorkstationId()).between((v0) -> {
                return v0.getOnlineTime();
            }, startTime, endTime));
        }
        if (Func.isEmpty(works)) {
            return Lists.newArrayList();
        }
        return (List) works.stream().map(w -> {
            EmployeeVO res = new EmployeeVO();
            res.setId(w.getOnEmployeeId());
            res.setCode(w.getOnEmployeeCode());
            res.setName(w.getOnEmployeeName());
            return res;
        }).filter(DistinctKeyUtil.distinctByKey((v0) -> {
            return v0.getId();
        })).collect(Collectors.toList());
    }

    @Override // org.springblade.modules.perf.service.IEmployeeOnOffWorkService
    public List<CurrWorkDetailVO> currWorkLog(CurrWorkLogVO vo) {
        return this.baseMapper.currWorkLog(vo.getWorkstationId());
    }

    @Override // org.springblade.modules.perf.service.IEmployeeOnOffWorkService
    public void currentEmployeeWork(String employeeId, String workstationId) {
        List<EmployeeOnOffWork> currEmployeeId = list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
            return v0.getOnEmployeeId();
        }, employeeId)).eq((v0) -> {
            return v0.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((v0) -> {
            return v0.getWorkstationId();
        }, workstationId)).eq((v0) -> {
            return v0.getOnlineType();
        }, OnOffWorkEnum.WILL_OFF.getCode()));
        if (Func.isNotEmpty(works)) {
            throw new ServiceException(MessageUtils.message("perf.current.work.login", new Object[0]));
        }
    }

    private List<EmployeeWorkStatusVO> allWorkStatusList(List<WorkstationBO> workstations) {
        Map<Long, Workstation> workstationMap = workstationMap();
        List<Long> wIds = (List) workstations.stream().map((v0) -> {
            return v0.getId();
        }).collect(Collectors.toList());
        List<EmployeeOnOffWork> works = this.baseMapper.queryWork(wIds, null);
        Map<Long, EmployeeOnOffWork> onOffWorkMap = (Map) works.stream().collect(Collectors.toMap((v0) -> {
            return v0.getWorkstationId();
        }, v -> {
            return v;
        }));
        return (List) workstations.stream().map(c -> {
            Long workstationId = c.getId();
            Workstation workstation = (Workstation) workstationMap.get(workstationId);
            if (Func.isNull(workstation)) {
                return null;
            }
            EmployeeOnOffWork employeeOnOffWork = (EmployeeOnOffWork) onOffWorkMap.get(workstationId);
            EmployeeWorkStatusVO res = EmployeeWorkStatusVO.builder().onType(OnOffWorkEnum.WILL_ON.getCode()).workstationId(workstationId).workstationCode(workstation.getCode()).workstationName(workstation.getName()).avatar(workstation.getAvatar()).build();
            if (Func.isNull(employeeOnOffWork) || employeeOnOffWork.getOnlineType().equals(OnOffWorkEnum.WILL_ON.getCode())) {
                return res;
            }
            res.setId(employeeOnOffWork.getId());
            res.setOnType(employeeOnOffWork.getOnlineType());
            res.setOnEmployeeId(employeeOnOffWork.getOnEmployeeId());
            res.setOnEmployeeCode(employeeOnOffWork.getOnEmployeeCode());
            res.setOnEmployeeName(employeeOnOffWork.getOnEmployeeName());
            res.setOnEmployeeAvatar(employeeOnOffWork.getOnEmployeeAvatar());
            res.setOnlineTime(employeeOnOffWork.getOnlineTime());
            return res;
        }).filter((v0) -> {
            return Func.notNull(v0);
        }).collect(Collectors.toList());
    }

    private List<EmployeeWorkStatusVO> onWorkStatusList(List<WorkstationBO> workstations, Integer onType) {
        List<Long> wIds = (List) workstations.stream().map((v0) -> {
            return v0.getId();
        }).collect(Collectors.toList());
        List<EmployeeOnOffWork> works = this.baseMapper.queryWork(wIds, onType);
        if (Func.isEmpty(works)) {
            return Lists.newArrayList();
        }
        return (List) works.stream().map(EmployeeOnOffWorkServiceImpl::convert).collect(Collectors.toList());
    }

    private List<EmployeeWorkStatusVO> offWorkStatusList(List<WorkstationBO> workstations, Integer onType) {
        Map<Long, Workstation> workstationMap = workstationMap();
        List<Long> wIds = (List) workstations.stream().map((v0) -> {
            return v0.getId();
        }).collect(Collectors.toList());
        List<EmployeeOnOffWork> works = this.baseMapper.queryWork(wIds, onType);
        Set<Long> workstationIds = (Set) works.stream().map((v0) -> {
            return v0.getWorkstationId();
        }).collect(Collectors.toSet());
        return (List) workstations.stream().filter(c -> {
            return !workstationIds.contains(c.getId());
        }).map(c2 -> {
            Long workstationId = c2.getId();
            Workstation workstation = (Workstation) workstationMap.get(workstationId);
            if (Func.isNull(workstation)) {
                return null;
            }
            return EmployeeWorkStatusVO.builder().onType(OnOffWorkEnum.WILL_ON.getCode()).workstationId(workstationId).workstationCode(workstation.getCode()).workstationName(workstation.getName()).avatar(workstation.getAvatar()).build();
        }).filter((v0) -> {
            return Func.notNull(v0);
        }).collect(Collectors.toList());
    }

    private List<EmployeeWorkStatusVO> currentEmployeeWork(List<WorkstationBO> workstations) {
        EmployeeVO employee = currentEmployee();
        if (Func.isNull(employee)) {
            return Lists.newArrayList();
        }
        List<Long> wIds = (List) workstations.stream().map((v0) -> {
            return v0.getId();
        }).collect(Collectors.toList());
        List<EmployeeOnOffWork> works = list((Wrapper) ((ExtraLambdaQueryWrapper) ((ExtraLambdaQueryWrapper) Lambda.create().in((v0) -> {
            return v0.getWorkstationId();
        }, wIds)).eq((v0) -> {
            return v0.getOnEmployeeId();
        }, employee.getId())).eq((v0) -> {
            return v0.getOnlineType();
        }, OnOffWorkEnum.WILL_OFF.getCode()));
        if (Func.isEmpty(works)) {
            return Lists.newArrayList();
        }
        Map<Long, Workstation> workMap = workstationMap();
        return (List) works.stream().map(w -> {
            EmployeeWorkStatusVO vo = convert(w);
            Workstation workstation = (Workstation) workMap.get(w.getWorkstationId());
            if (Func.isNull(workstation)) {
                return null;
            }
            vo.setAvatar(workstation.getAvatar());
            return vo;
        }).filter((v0) -> {
            return Func.notNull(v0);
        }).collect(Collectors.toList());
    }

    private static EmployeeWorkStatusVO convert(EmployeeOnOffWork work) {
        return EmployeeWorkStatusVO.builder().id(work.getId()).onType(work.getOnlineType()).onEmployeeId(work.getOnEmployeeId()).onEmployeeCode(work.getOnEmployeeCode()).onEmployeeName(work.getOnEmployeeName()).onEmployeeAvatar(work.getOnEmployeeAvatar()).workstationId(work.getWorkstationId()).workstationCode(work.getWorkstationCode()).workstationName(work.getWorkstationName()).onlineTime(work.getOnlineTime()).build();
    }

    private static EmployeeOnOffWorkVO convertWork(EmployeeOnOffWork work) {
        return EmployeeOnOffWorkVO.builder().id(work.getId()).employeeId(work.getOnEmployeeId()).employeeName(work.getOnEmployeeName()).employeeCode(work.getOnEmployeeCode()).workstationId(work.getWorkstationId()).workstationCode(work.getWorkstationCode()).workstationName(work.getWorkstationName()).onlineTime(work.getOnlineTime()).offlineTime(work.getOfflineTime()).createTime(work.getCreateTime()).build();
    }

    private void batchOnWorkstation(BatchOnWorkVO vo) {
        List<WorkstationBO> works = vo.getWorks();
        List<EmployeeOnOffWork> onOffWorks = (List) works.stream().map(w -> {
            return convertWork(vo, w);
        }).collect(Collectors.toList());
        saveBatch(onOffWorks);
    }

    private void batchOffWorkstation(BatchOnWorkVO vo) {
        List<WorkstationBO> works = vo.getWorks();
        List<EmployeeOnOffWork> offWorks = (List) works.stream().map(w -> {
            EmployeeOnOffWork work = new EmployeeOnOffWork().setOffEmployeeId(vo.getEmployeeId()).setOffEmployeeCode(vo.getEmployeeCode()).setOffEmployeeName(vo.getEmployeeName()).setOffEmployeeAvatar(vo.getEmployeeAvatar()).setOnlineType(OnOffWorkEnum.WILL_ON.getCode()).setOfflineTime(vo.getTime());
            work.setId(w.getLogId());
            return work;
        }).collect(Collectors.toList());
        updateBatchById(offWorks);
    }

    private EmployeeOnOffWork convertWork(BatchOnWorkVO vo, WorkstationBO work) {
        return new EmployeeOnOffWork().setOnlineTime(vo.getTime()).setOnEmployeeId(vo.getEmployeeId()).setOnEmployeeName(vo.getEmployeeName()).setOnEmployeeCode(vo.getEmployeeCode()).setOnEmployeeAvatar(vo.getEmployeeAvatar()).setWorkstationId(work.getId()).setWorkstationName(work.getWorkstationName()).setWorkstationCode(work.getWorkstationCode()).setWorkstationAvatar(work.getAvatar()).setOnlineType(OnOffWorkEnum.WILL_OFF.getCode());
    }

    private Map<Long, Workstation> workstationMap() {
        List<Workstation> workstations = this.workstationService.list();
        return (Map) workstations.stream().collect(Collectors.toMap((v0) -> {
            return v0.getId();
        }, v -> {
            return v;
        }));
    }
}
     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;
	  
     private final IWorkstationService workstationService;
	  
     private final IEmployeeSendService employeeSendService;
	  
     public EmployeeOnOffWorkServiceImpl(IEmployeeService employeeService, IWorkstationService workstationService, IEmployeeSendService employeeSendService) {
       this.employeeService = employeeService;
       this.workstationService = workstationService;
       this.employeeSendService = employeeSendService;
     }
	  
     public List<EmployeeWorkStatusVO> allWorkstationStatus(QueryWorkStatusVO vo) {
       List<WorkstationBO> workstations = vo.getWorkstations();
       if (Func.isEmpty(workstations))
         return Lists.newArrayList(); 
       WorkStatusEnum queryType = vo.getQueryType();
       switch ($SwitchMap$com$qianwen$smartman$modules$perf$enums$WorkStatusEnum[queryType.ordinal()]) {
                               //com.qianwen.smartman.modules.perf.enums.WorkStatusEnum
         case 1:
           return allWorkStatusList(workstations);
         case 2:
           return onWorkStatusList(workstations, OnOffWorkEnum.WILL_OFF.getCode());
         case 3:
           return offWorkStatusList(workstations, OnOffWorkEnum.WILL_OFF.getCode());
         case 4:
           return currentEmployeeWork(workstations);
       } 
       return Lists.newArrayList();
     }
	  
     public EmployeeVO currentEmployee() {
       return this.employeeService.currentEmployee(AuthUtil.getUserId());
     }
	  
     public Boolean batchOnOffWorkstation(BatchOnWorkVO vo) {
       Integer type = vo.getType();
       List<Long> workstationIds = (List<Long>)vo.getWorks().stream().map(WorkstationBO::getId).collect(Collectors.toList());
       EmployeeCache.clearPerfCache(workstationIds);
       switch ($SwitchMap$com$qianwen$smartman$modules$perf$enums$WorkStatusEnum[OnOffWorkEnum.of(type).ordinal()]) {
         case 1:
           batchOnWorkstation(vo);
           break;
         case 2:
           batchOffWorkstation(vo);
           break;
       } 
       this.employeeSendService.sendMessageRocket(workstationIds);
       return Boolean.valueOf(true);
     }
	  
     public List<GroupTreeVO> willOnWork() {
       List<GroupTreeVO> children = ((EmployeeOnOffWorkMapper)this.baseMapper).willOnWork(OnOffWorkEnum.WILL_OFF.getCode());
       CommonGroupTypeVO commonGroupType = (new CommonGroupTypeVO()).setGroupType(CommonGroupTypeEnum.WORKSTATION.getName()).setGroupCategory(CommonGroupConstant.DEFAULT_CATEGORY);
       return TreeUtils.allGroupTree(commonGroupType, children);
     }
	  
     public List<OffEmployeeTreeVO> willOffWork() {
       List<OffEmployeeTreeVO> children = ((EmployeeOnOffWorkMapper)this.baseMapper).willOffWork(OnOffWorkEnum.WILL_OFF.getCode());
       CommonGroupTypeVO commonGroupType = (new CommonGroupTypeVO()).setGroupType(CommonGroupTypeEnum.WORKSTATION.getName()).setGroupCategory(CommonGroupConstant.DEFAULT_CATEGORY);
       return TreeUtils.allGroupTreeOff(commonGroupType, children);
     }
	  
     public IPage<EmployeeOnOffWorkVO> queryOnOffLog(QueryEmployeeLogVO vo) {
       IPage<EmployeeOnOffWork> page;
       if (Func.isEmpty(vo.getWorkstationIds()))
         return (IPage<EmployeeOnOffWorkVO>)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()))
             .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 });
                }));
       } 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)))
	          
             .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()
           .map(com.qianwen.smartman.modules.perf.service.impl.EmployeeOnOffWorkServiceImpl::convertWork)
           .collect(Collectors.toList()));
       return (IPage<EmployeeOnOffWorkVO>)page1;
     }
	  
     public List<WorkstationBO> employeeWork(SearchEmployeeWorkVO vo) {
       List<EmployeeOnOffWork> works;
       String dbType = SpringUtil.getContext().getEnvironment().getProperty("datasource.type");
       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 })));
       } else {
         works = list((Wrapper)Lambda.eq(EmployeeOnOffWork::getOnEmployeeId, vo.getEmployeeId())
             .between(EmployeeOnOffWork::getOnlineTime, startTime, endTime));
       } 
       if (Func.isEmpty(works))
         return Lists.newArrayList(); 
       return (List<WorkstationBO>)works.stream()
         .map(w -> WorkstationBO.builder().id(w.getWorkstationId()).workstationCode(w.getWorkstationCode()).workstationName(w.getWorkstationName()).build())
	      
         .filter(DistinctKeyUtil.distinctByKey(WorkstationBO::getId))
         .collect(Collectors.toList());
     }
	  
     public List<EmployeeVO> workEmployee(SearchWorkEmployeeVO vo) {
       List<EmployeeOnOffWork> works;
       String dbType = SpringUtil.getContext().getEnvironment().getProperty("datasource.type");
       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 })));
       } else {
         works = list((Wrapper)Lambda.eq(EmployeeOnOffWork::getWorkstationId, vo.getWorkstationId())
             .between(EmployeeOnOffWork::getOnlineTime, startTime, endTime));
       } 
       if (Func.isEmpty(works))
         return Lists.newArrayList(); 
       return (List<EmployeeVO>)works.stream()
         .map(w -> {
             EmployeeVO res = new EmployeeVO();
             res.setId(w.getOnEmployeeId());
             res.setCode(w.getOnEmployeeCode());
             res.setName(w.getOnEmployeeName());
             return res;
           }).filter(DistinctKeyUtil.distinctByKey(EmployeeVO::getId))
         .collect(Collectors.toList());
     }
	  
     public List<CurrWorkDetailVO> currWorkLog(CurrWorkLogVO vo) {
       return ((EmployeeOnOffWorkMapper)this.baseMapper).currWorkLog(vo.getWorkstationId());
     }
	  
     public void currentEmployeeWork(String employeeId, String workstationId) {
		
       List<EmployeeOnOffWork> currEmployeeId = list((Wrapper)((LambdaQueryWrapper)Wrappers.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))
           .eq(EmployeeOnOffWork::getOnlineType, OnOffWorkEnum.WILL_OFF.getCode()));
       if (Func.isNotEmpty(works))
         throw new ServiceException(MessageUtils.message("perf.current.work.login", new Object[0])); 
	    
     }
	  
     private List<EmployeeWorkStatusVO> allWorkStatusList(List<WorkstationBO> workstations) {
       Map<Long, Workstation> workstationMap = workstationMap();
       List<Long> wIds = (List<Long>)workstations.stream().map(WorkstationBO::getId).collect(Collectors.toList());
       List<EmployeeOnOffWork> works = ((EmployeeOnOffWorkMapper)this.baseMapper).queryWork(wIds, null);
       Map<Long, EmployeeOnOffWork> onOffWorkMap = (Map<Long, EmployeeOnOffWork>)works.stream().collect(Collectors.toMap(EmployeeOnOffWork::getWorkstationId, v -> v));
       return (List<EmployeeWorkStatusVO>)workstations.stream()
         .map(c -> {
             Long workstationId = c.getId();
             Workstation workstation = (Workstation)workstationMap.get(workstationId);
             if (Func.isNull(workstation))
               return null; 
             EmployeeOnOffWork employeeOnOffWork = (EmployeeOnOffWork)onOffWorkMap.get(workstationId);
             EmployeeWorkStatusVO res = EmployeeWorkStatusVO.builder().onType(OnOffWorkEnum.WILL_ON.getCode()).workstationId(workstationId).workstationCode(workstation.getCode()).workstationName(workstation.getName()).avatar(workstation.getAvatar()).build();
             if (Func.isNull(employeeOnOffWork) || employeeOnOffWork.getOnlineType().equals(OnOffWorkEnum.WILL_ON.getCode()))
               return res; 
             res.setId(employeeOnOffWork.getId());
             res.setOnType(employeeOnOffWork.getOnlineType());
             res.setOnEmployeeId(employeeOnOffWork.getOnEmployeeId());
             res.setOnEmployeeCode(employeeOnOffWork.getOnEmployeeCode());
             res.setOnEmployeeName(employeeOnOffWork.getOnEmployeeName());
             res.setOnEmployeeAvatar(employeeOnOffWork.getOnEmployeeAvatar());
             res.setOnlineTime(employeeOnOffWork.getOnlineTime());
             return res;
           }).filter(Func::notNull)
         .collect(Collectors.toList());
     }
	  
     private List<EmployeeWorkStatusVO> onWorkStatusList(List<WorkstationBO> workstations, Integer onType) {
       List<Long> wIds = (List<Long>)workstations.stream().map(WorkstationBO::getId).collect(Collectors.toList());
       List<EmployeeOnOffWork> works = ((EmployeeOnOffWorkMapper)this.baseMapper).queryWork(wIds, onType);
       if (Func.isEmpty(works))
         return Lists.newArrayList(); 
       return (List<EmployeeWorkStatusVO>)works.stream()
         .map(com.qianwen.smartman.modules.perf.service.impl.EmployeeOnOffWorkServiceImpl::convert)
         .collect(Collectors.toList());
     }
	  
     private List<EmployeeWorkStatusVO> offWorkStatusList(List<WorkstationBO> workstations, Integer onType) {
       Map<Long, Workstation> workstationMap = workstationMap();
       List<Long> wIds = (List<Long>)workstations.stream().map(WorkstationBO::getId).collect(Collectors.toList());
       List<EmployeeOnOffWork> works = ((EmployeeOnOffWorkMapper)this.baseMapper).queryWork(wIds, onType);
       Set<Long> workstationIds = (Set<Long>)works.stream().map(EmployeeOnOffWork::getWorkstationId).collect(Collectors.toSet());
       return (List<EmployeeWorkStatusVO>)workstations.stream()
         .filter(c -> !workstationIds.contains(c.getId()))
         .map(c -> {
             Long workstationId = c.getId();
             Workstation workstation = (Workstation)workstationMap.get(workstationId);
             return Func.isNull(workstation) ? null : EmployeeWorkStatusVO.builder().onType(OnOffWorkEnum.WILL_ON.getCode()).workstationId(workstationId).workstationCode(workstation.getCode()).workstationName(workstation.getName()).avatar(workstation.getAvatar()).build();
           }).filter(Func::notNull)
         .collect(Collectors.toList());
     }
	  
     private List<EmployeeWorkStatusVO> currentEmployeeWork(List<WorkstationBO> workstations) {
       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()))
           .eq(EmployeeOnOffWork::getOnlineType, OnOffWorkEnum.WILL_OFF.getCode()));
       if (Func.isEmpty(works))
         return Lists.newArrayList(); 
       Map<Long, Workstation> workMap = workstationMap();
       return (List<EmployeeWorkStatusVO>)works.stream()
         .map(w -> {
             EmployeeWorkStatusVO vo = convert(w);
             Workstation workstation = (Workstation)workMap.get(w.getWorkstationId());
             if (Func.isNull(workstation))
               return null; 
             vo.setAvatar(workstation.getAvatar());
             return vo;
           }).filter(Func::notNull)
         .collect(Collectors.toList());
     }
	  
     private static EmployeeWorkStatusVO convert(EmployeeOnOffWork work) {
       return EmployeeWorkStatusVO.builder()
         .id(work.getId())
         .onType(work.getOnlineType())
         .onEmployeeId(work.getOnEmployeeId())
         .onEmployeeCode(work.getOnEmployeeCode())
         .onEmployeeName(work.getOnEmployeeName())
         .onEmployeeAvatar(work.getOnEmployeeAvatar())
         .workstationId(work.getWorkstationId())
         .workstationCode(work.getWorkstationCode())
         .workstationName(work.getWorkstationName())
         .onlineTime(work.getOnlineTime())
         .build();
     }
	  
     private static EmployeeOnOffWorkVO convertWork(EmployeeOnOffWork work) {
       return EmployeeOnOffWorkVO.builder()
         .id(work.getId())
         .employeeId(work.getOnEmployeeId())
         .employeeName(work.getOnEmployeeName())
         .employeeCode(work.getOnEmployeeCode())
         .workstationId(work.getWorkstationId())
         .workstationCode(work.getWorkstationCode())
         .workstationName(work.getWorkstationName())
         .onlineTime(work.getOnlineTime())
         .offlineTime(work.getOfflineTime())
         .createTime(work.getCreateTime())
         .build();
     }
	  
     private void batchOnWorkstation(BatchOnWorkVO vo) {
       List<WorkstationBO> works = vo.getWorks();
       List<EmployeeOnOffWork> onOffWorks = (List<EmployeeOnOffWork>)works.stream().map(w -> convertWork(vo, w)).collect(Collectors.toList());
       saveBatch(onOffWorks);
     }
	  
     private void batchOffWorkstation(BatchOnWorkVO vo) {
       List<WorkstationBO> works = vo.getWorks();
       List<EmployeeOnOffWork> offWorks = (List<EmployeeOnOffWork>)works.stream().map(w -> {
             EmployeeOnOffWork work = (new EmployeeOnOffWork()).setOffEmployeeId(vo.getEmployeeId()).setOffEmployeeCode(vo.getEmployeeCode()).setOffEmployeeName(vo.getEmployeeName()).setOffEmployeeAvatar(vo.getEmployeeAvatar()).setOnlineType(OnOffWorkEnum.WILL_ON.getCode()).setOfflineTime(vo.getTime());
             work.setId(w.getLogId());
             return work;
           }).collect(Collectors.toList());
       updateBatchById(offWorks);
     }
	  
     private EmployeeOnOffWork convertWork(BatchOnWorkVO vo, WorkstationBO work) {
       return (new EmployeeOnOffWork())
         .setOnlineTime(vo.getTime())
         .setOnEmployeeId(vo.getEmployeeId())
         .setOnEmployeeName(vo.getEmployeeName())
         .setOnEmployeeCode(vo.getEmployeeCode())
         .setOnEmployeeAvatar(vo.getEmployeeAvatar())
         .setWorkstationId(work.getId())
         .setWorkstationName(work.getWorkstationName())
         .setWorkstationCode(work.getWorkstationCode())
         .setWorkstationAvatar(work.getAvatar())
         .setOnlineType(OnOffWorkEnum.WILL_OFF.getCode());
     }
	  
     private Map<Long, Workstation> workstationMap() {
       List<Workstation> workstations = this.workstationService.list();
       return (Map<Long, Workstation>)workstations.stream().collect(Collectors.toMap(BaseEntity::getId, v -> v));
     }
   }