package com.qianwen.smartman.modules.perf.service.impl;
|
|
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;
|
import com.qianwen.smartman.common.utils.DistinctKeyUtil;
|
import com.qianwen.smartman.common.utils.ExtraLambdaQueryWrapper;
|
import com.qianwen.smartman.common.utils.Lambda;
|
import com.qianwen.smartman.common.utils.MessageUtils;
|
import com.qianwen.smartman.common.utils.TimeUtils;
|
import com.qianwen.smartman.common.utils.TreeUtils;
|
import com.qianwen.smartman.modules.cps.entity.Workstation;
|
import com.qianwen.smartman.modules.cps.service.IEmployeeService;
|
import com.qianwen.smartman.modules.cps.service.IWorkstationService;
|
import com.qianwen.smartman.modules.cps.vo.CommonGroupTypeVO;
|
import com.qianwen.smartman.modules.cps.vo.EmployeeVO;
|
import com.qianwen.smartman.modules.cps.vo.GroupTreeVO;
|
import com.qianwen.smartman.modules.perf.dto.WorkstationBO;
|
import com.qianwen.smartman.modules.perf.entity.EmployeeOnOffWork;
|
import com.qianwen.smartman.modules.perf.enums.DbTypeEnum;
|
import com.qianwen.smartman.modules.perf.enums.OnOffWorkEnum;
|
import com.qianwen.smartman.modules.perf.enums.WorkStatusEnum;
|
import com.qianwen.smartman.modules.perf.mapper.EmployeeOnOffWorkMapper;
|
import com.qianwen.smartman.modules.perf.service.IEmployeeOnOffWorkService;
|
import com.qianwen.smartman.modules.perf.service.IEmployeeSendService;
|
import com.qianwen.smartman.modules.perf.vo.BatchOnWorkVO;
|
import com.qianwen.smartman.modules.perf.vo.CurrWorkDetailVO;
|
import com.qianwen.smartman.modules.perf.vo.CurrWorkLogVO;
|
import com.qianwen.smartman.modules.perf.vo.EmployeeOnOffWorkVO;
|
import com.qianwen.smartman.modules.perf.vo.EmployeeWorkStatusVO;
|
import com.qianwen.smartman.modules.perf.vo.OffEmployeeTreeVO;
|
import com.qianwen.smartman.modules.perf.vo.QueryEmployeeLogVO;
|
import com.qianwen.smartman.modules.perf.vo.QueryWorkStatusVO;
|
import com.qianwen.smartman.modules.perf.vo.SearchEmployeeWorkVO;
|
import com.qianwen.smartman.modules.perf.vo.SearchWorkEmployeeVO;
|
|
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);
|
|
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(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:
|
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 (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);
|
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 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()),
|
Lambda.in(Func.isNotEmpty(vo.getEmployeeIds()), EmployeeOnOffWork::getOnEmployeeId, vo.getEmployeeIds())
|
.in(EmployeeOnOffWork::getWorkstationId, vo.getWorkstationIds())
|
.nested(nt -> {
|
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()),
|
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 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 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(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(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(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(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(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(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]));
|
|
}
|
|
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 = 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();
|
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));
|
}
|
}
|
