package org.jeecg.modules.weekly.service.impl;
|
|
|
import com.alibaba.fastjson.JSON;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import org.apache.commons.lang3.StringUtils;
|
import org.apache.shiro.SecurityUtils;
|
import org.jeecg.common.api.vo.Result;
|
import org.jeecg.common.constant.CacheConstant;
|
import org.jeecg.common.system.vo.LoginUser;
|
import org.jeecg.common.util.DateUtils;
|
import org.jeecg.common.util.HTMLUtils;
|
import org.jeecg.common.util.RedisUtil;
|
import org.jeecg.modules.weekly.entity.*;
|
import org.jeecg.modules.weekly.entity.ProProject;
|
import org.jeecg.modules.weekly.feign.ProjectClient;
|
import org.jeecg.modules.weekly.mapper.WekEvaluateMapper;
|
import org.jeecg.modules.weekly.mapper.WekRecordMapper;
|
import org.jeecg.modules.weekly.service.IWekRecordService;
|
import org.jeecg.modules.weekly.vo.*;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.lang.reflect.Field;
|
import java.text.NumberFormat;
|
import java.text.SimpleDateFormat;
|
import java.time.LocalDate;
|
import java.time.temporal.TemporalAdjusters;
|
import java.util.*;
|
import java.util.concurrent.atomic.AtomicBoolean;
|
import java.util.concurrent.atomic.AtomicInteger;
|
import java.util.concurrent.atomic.AtomicReference;
|
import java.util.stream.Collectors;
|
import java.util.stream.IntStream;
|
|
|
/**
|
* 周报记录
|
* <p>
|
* 注：1、查询个人周报时会查询一年的每一周，没数据则显示空列表
|
* methods: queryWeeklyListByWeekNo
|
* 2、查询部门周报或项目周报时只查询有数据的周，不查询空数据
|
* methods: queryDepartUserWeeklyList、queryProjectWeekly、queryAllProjectWeekly
|
*/
|
@Service
|
public class WekRecordServiceImpl extends ServiceImpl<WekRecordMapper, WekRecord> implements IWekRecordService {
|
@Autowired
|
private WekRecordMapper wekRecordMapper;
|
@Autowired
|
private WekEvaluateMapper wekEvaluateMapper;
|
@Autowired
|
private RedisUtil redisUtil;
|
@Autowired
|
private ProjectClient projectClient;
|
|
|
@Override
|
@Transactional
|
public void insertBatch(WekResultBean resultBean) {
|
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
|
List<WekWeekBean> weekList = resultBean.getWeekList();
|
for (int i = 0; i < weekList.size(); i++) {
|
WekWeekBean weekBean = weekList.get(i);
|
if (weekBean == null) continue;
|
List<WekTypeBean> typeList = weekBean.getTypeList();
|
if (typeList == null) continue;
|
for (int j = 0; j < typeList.size(); j++) {
|
WekTypeBean typeBean = typeList.get(j);
|
if (typeBean == null) continue;
|
List<WekRecord> wekList = typeBean.getWekList();
|
if (wekList == null || wekList.size() < 1) continue;
|
wekList.forEach((item) -> {
|
item.setUser(sysUser.getUsername());
|
item.setYearWeek(item.getYear() * 100 + item.getWeek());
|
});
|
saveOrUpdateBatch(wekList);
|
|
}
|
}
|
|
|
}
|
|
@Override
|
public List<WekWeekBean> querySingleThisWeek(WekRecord wekRecord) {
|
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
|
int curWeek = DateUtils.getCurWeek();
|
int curYear = DateUtils.getCurYear();
|
|
//查询本周和上周数据
|
List<WekRecord> list = new ArrayList<>();
|
if (curWeek != 1) {
|
int arr[] = {curWeek, curWeek - 1};
|
QueryWrapper<WekRecord> queryWrapper = new QueryWrapper<>();
|
queryWrapper.lambda().eq(WekRecord::getYear, curYear).eq(WekRecord::getUser, sysUser.getUsername()).and(j -> j.in(WekRecord::getWeek, arr[0], arr[1]));
|
queryWrapper.lambda().orderByAsc(WekRecord::getCreateTime);
|
List<WekRecord> list1 = this.list(queryWrapper);
|
list.addAll(list1);
|
} else {
|
QueryWrapper<WekRecord> queryWrapper2 = new QueryWrapper<>();
|
queryWrapper2.lambda().eq(WekRecord::getYear, curYear - 1).eq(WekRecord::getUser, sysUser.getUsername()).and(j -> j.in(WekRecord::getWeek, 52));
|
queryWrapper2.lambda().orderByAsc(WekRecord::getCreateTime);
|
List<WekRecord> list2 = this.list(queryWrapper2);
|
list.addAll(list2);
|
|
|
QueryWrapper<WekRecord> queryWrapper = new QueryWrapper<>();
|
queryWrapper.lambda().eq(WekRecord::getYear, curYear).eq(WekRecord::getUser, sysUser.getUsername()).and(j -> j.in(WekRecord::getWeek, 1));
|
queryWrapper.lambda().orderByAsc(WekRecord::getCreateTime);
|
List<WekRecord> list1 = this.list(queryWrapper);
|
list.addAll(list1);
|
|
|
}
|
|
|
//自动录入
|
autoEnter(list, curWeek,curYear);
|
|
|
//根据周和数据类型分类
|
Map<Integer, Map<Integer, List<WekRecord>>> collect = list.stream().collect(Collectors.groupingBy(t -> t.getWeek(), Collectors.groupingBy(t -> t.getType())));
|
List<WekWeekBean> templateData = createTemplateData();
|
|
/**
|
* 将周报信息填充到模板中
|
*/
|
//周
|
for (Map.Entry<Integer, Map<Integer, List<WekRecord>>> entry : collect.entrySet()) {
|
for (int i = 0; i < templateData.size(); i++) {
|
WekWeekBean week = templateData.get(i);
|
week.setUsername(sysUser.getUsername());
|
week.setShowDetail(true);
|
|
if (entry.getKey() == week.getWeek()) {
|
Map<Integer, List<WekRecord>> typeMap = entry.getValue();
|
List<WekTypeBean> typeList = week.getTypeList();
|
//周报类型 0-本周周报 1-本周计划外 2-下周计划 3-下周需协调
|
for (Map.Entry<Integer, List<WekRecord>> type : typeMap.entrySet()) {
|
for (int j = 0; j < typeList.size(); j++) {
|
|
WekTypeBean typeBean = typeList.get(j);
|
if (typeBean.getWeek() == week.getWeek() && typeBean.getType() == type.getKey()) {
|
typeBean.getWekList().addAll(type.getValue());
|
}
|
}
|
|
}
|
}
|
}
|
|
}
|
return templateData;
|
}
|
|
/**
|
* 本周周报自动录入上周下周计划内容
|
*
|
* @param list 本周和上周周报记录
|
* @param curWeek 当前周号
|
*/
|
private void autoEnter(List<WekRecord> list, int curWeek,int curYear) {
|
//TODO 上周计划填充到本周内容（思想：本周周报内容没有记录的时候，查询上周计划填充，只填充不做真实保存，用户编辑本周周报保存后再真实保存）
|
//1.0本周周报内容
|
List<WekRecord> tWeekList = list.stream().filter(i -> i.getWeek() == curWeek).collect(Collectors.toList());
|
//1.1上周周报内容
|
List<WekRecord> lWeekList = new ArrayList<>();
|
if (curWeek != 1) {
|
List<WekRecord> collect = list.stream().filter(i -> i.getWeek() == (curWeek - 1)).collect(Collectors.toList());
|
lWeekList.addAll(collect);
|
} else {
|
List<WekRecord> collect = list.stream().filter(i -> i.getWeek() == 52).collect(Collectors.toList());
|
lWeekList.addAll(collect);
|
}
|
|
|
//2.0本周没有周报记录
|
if (tWeekList.isEmpty()) {
|
//2.1上周有数据
|
if (!lWeekList.isEmpty()) {
|
//type = 2 下周计划
|
List<WekRecord> nList = lWeekList.stream().filter(i -> i.getType() == 2).collect(Collectors.toList());
|
//2.2上周周报存在下周计划数据
|
if (!nList.isEmpty()) {
|
for (int i = 0; i < nList.size(); i++) {
|
WekRecord record = nList.get(i);
|
WekRecord item = new WekRecord();
|
//将上周周报的下周计划 填充到本周周报内容
|
BeanUtils.copyProperties(record, item);
|
item.setId(UUID.randomUUID().toString().replace("-", ""));
|
item.setWeek(curWeek);
|
item.setYear(curYear);
|
item.setYearWeek(item.getYear() * 100 + item.getWeek());
|
item.setType(0);
|
item.setCreateTime(DateUtils.minusSeconds(nList.size()-i));
|
item.setUpdateTime(null);
|
list.add(item);
|
}
|
}
|
}
|
}
|
}
|
|
@Override
|
public List<WekWeekBean> queryWeeklyListByWeekNo(Integer year, Integer week, String username) {
|
|
List<WekWeekBean> result = new ArrayList<>();
|
|
QueryWrapper<WekRecord> queryWrapper = new QueryWrapper<>();
|
queryWrapper.lambda().eq(WekRecord::getYear, year).eq(WekRecord::getUser, username).and(j -> j.in(WekRecord::getWeek, week));
|
queryWrapper.lambda().orderByAsc(WekRecord::getCreateTime);
|
List<WekRecord> list = this.list(queryWrapper);
|
//没有数据则返回空白数据
|
if (list.isEmpty()) {
|
return createEmptyData(year, week,username);
|
}
|
|
|
//根据周和数据类型分类
|
Map<Integer, Map<Integer, List<WekRecord>>> collect = list.stream().collect(Collectors.groupingBy(t -> t.getWeek(), Collectors.groupingBy(t -> t.getType())));
|
|
for (Map.Entry<Integer, Map<Integer, List<WekRecord>>> entry : collect.entrySet()) {
|
Map<Integer, List<WekRecord>> typeMap = entry.getValue();
|
WekWeekBean weekBean = new WekWeekBean();
|
weekBean.setWeek(entry.getKey());
|
weekBean.setStartDateStr1(DateUtils.weekToDayStartStr(year, entry.getKey()));
|
weekBean.setEndDateStr1(DateUtils.weekToDayEndStr(year, entry.getKey()));
|
String tws = DateUtils.weekToDayEndStr(year, entry.getKey(), "yyyy-MM-dd");
|
weekBean.setWeekInMonth(DateUtils.getWeekInMonth(tws,2));
|
weekBean.setStartDateStr2(DateUtils.weekToDayStartStr(year, entry.getKey() + 1));
|
weekBean.setEndDateStr2(DateUtils.weekToDayEndStr(year, entry.getKey() + 1));
|
weekBean.setShow(true);
|
weekBean.setUsername(username);
|
weekBean.setShowDetail(true);
|
List<WekTypeBean> typeList = new ArrayList<>();
|
for (int i = 0; i < 4; i++) {
|
WekTypeBean typeBean = new WekTypeBean();
|
typeBean.setWeek(entry.getKey());
|
typeBean.setType(i);
|
configTypeName(entry.getKey(), typeBean);
|
if (typeMap.containsKey(i)) {
|
typeBean.setWekList(typeMap.get(i));
|
} else {
|
List<WekRecord> wekRecords = new ArrayList<>();
|
typeBean.setWekList(wekRecords);
|
}
|
typeList.add(typeBean);
|
}
|
|
weekBean.setTypeList(typeList);
|
weekBean.setUsername(username);
|
weekBean.setYear(year);
|
result.add(weekBean);
|
}
|
|
return result;
|
}
|
|
@Override
|
public List<WekWeekBean> queryDepartUserWeeklyList(String orgCode, int page) {
|
List<WekWeekBean> result = new ArrayList<>();
|
//查询部门下用户
|
List<String> departUsers = wekRecordMapper.queryDepartUsers(orgCode);
|
|
if (departUsers == null || departUsers.size() < 1) {
|
return result;
|
}
|
WekRecord mapParams = new WekRecord();
|
|
//先查询数据的年 周
|
List<HashMap<String, Object>> hashMaps = wekRecordMapper.queryYearWeekGroup(mapParams);
|
|
//页码大于总数据时
|
if (page > hashMaps.size()) {
|
return result;
|
}
|
HashMap<String, Object> stringObjectHashMap = hashMaps.get(page - 1);
|
int curYear = (int) stringObjectHashMap.get("year");
|
int curWeek = (int) stringObjectHashMap.get("week");
|
//拼接查询条件
|
QueryWrapper<WekRecord> queryWrapper = new QueryWrapper<>();
|
queryWrapper.in("user", departUsers).in("year", curYear).in("week", curWeek).orderByDesc("user").orderByDesc("year").orderByDesc("week").orderByAsc("type");
|
queryWrapper.lambda().orderByAsc(WekRecord::getCreateTime);
|
//查询数据
|
List<WekRecord> list = wekRecordMapper.selectList(queryWrapper);
|
//按照 用户-周-数据类型 分类数据
|
Map<String, Map<Integer, Map<Integer, List<WekRecord>>>> collect = list.stream().collect(Collectors.groupingBy(t -> t.getUser(), Collectors.groupingBy(t -> t.getWeek(), Collectors.groupingBy(t -> t.getType()))));
|
|
for (Map.Entry<String, Map<Integer, Map<Integer, List<WekRecord>>>> userEntry : collect.entrySet()) {
|
Map<Integer, Map<Integer, List<WekRecord>>> weekMap = userEntry.getValue();
|
for (Map.Entry<Integer, Map<Integer, List<WekRecord>>> entry : weekMap.entrySet()) {
|
Map<Integer, List<WekRecord>> typeMap = entry.getValue();
|
WekWeekBean weekBean = new WekWeekBean();
|
weekBean.setWeek(entry.getKey());
|
weekBean.setStartDateStr1(DateUtils.weekToDayStartStr(entry.getKey()));
|
weekBean.setEndDateStr1(DateUtils.weekToDayEndStr(entry.getKey()));
|
weekBean.setStartDateStr2(DateUtils.weekToDayStartStr(entry.getKey() + 1));
|
weekBean.setEndDateStr2(DateUtils.weekToDayEndStr(entry.getKey() + 1));
|
weekBean.setShow(true);
|
List<WekTypeBean> typeList = new ArrayList<>();
|
for (int i = 0; i < 4; i++) {
|
WekTypeBean typeBean = new WekTypeBean();
|
typeBean.setWeek(entry.getKey());
|
typeBean.setType(i);
|
configTypeName(entry.getKey(), typeBean);
|
if (typeMap.containsKey(i)) {
|
typeBean.setWekList(typeMap.get(i));
|
} else {
|
List<WekRecord> wekRecords = new ArrayList<>();
|
typeBean.setWekList(wekRecords);
|
}
|
typeList.add(typeBean);
|
}
|
|
weekBean.setTypeList(typeList);
|
weekBean.setYear(curYear);
|
weekBean.setUsername(userEntry.getKey());
|
result.add(weekBean);
|
}
|
}
|
|
//姓名升序
|
Comparator nameCom = Comparator.comparing(
|
WekWeekBean::getUsername);
|
//week 降序
|
Comparator weekCom = Comparator.comparingInt(
|
WekWeekBean::getWeek).reversed();
|
result.sort(nameCom.thenComparing(weekCom));
|
|
return result;
|
}
|
|
|
@Override
|
public List<WekWeekBean> queryJuniorBatchWeekly(String usernames, int page) {
|
List<WekWeekBean> result = new ArrayList<>();
|
String[] split = usernames.split(",");
|
//查询部门下用户
|
List<String> departUsers = Arrays.asList(split);
|
|
if (departUsers == null || departUsers.size() < 1) {
|
return result;
|
}
|
WekRecord mapParams = new WekRecord();
|
|
//先查询数据的年 周
|
List<HashMap<String, Object>> hashMaps = wekRecordMapper.queryYearWeekGroup(mapParams);
|
|
//页码大于总数据时
|
if (page > hashMaps.size()) {
|
return result;
|
}
|
HashMap<String, Object> stringObjectHashMap = hashMaps.get(page - 1);
|
int curYear = (int) stringObjectHashMap.get("year");
|
int curWeek = (int) stringObjectHashMap.get("week");
|
//拼接查询条件
|
QueryWrapper<WekRecord> queryWrapper = new QueryWrapper<>();
|
queryWrapper.in("user", departUsers).in("year", curYear).in("week", curWeek).orderByDesc("user").orderByDesc("year").orderByDesc("week").orderByAsc("type");
|
//查询数据
|
List<WekRecord> list = wekRecordMapper.selectList(queryWrapper);
|
//按照 用户-周-数据类型 分类数据
|
Map<String, Map<Integer, Map<Integer, List<WekRecord>>>> collect = list.stream().collect(Collectors.groupingBy(t -> t.getUser(), Collectors.groupingBy(t -> t.getWeek(), Collectors.groupingBy(t -> t.getType()))));
|
|
for (Map.Entry<String, Map<Integer, Map<Integer, List<WekRecord>>>> userEntry : collect.entrySet()) {
|
Map<Integer, Map<Integer, List<WekRecord>>> weekMap = userEntry.getValue();
|
for (Map.Entry<Integer, Map<Integer, List<WekRecord>>> entry : weekMap.entrySet()) {
|
Map<Integer, List<WekRecord>> typeMap = entry.getValue();
|
WekWeekBean weekBean = new WekWeekBean();
|
weekBean.setWeek(entry.getKey());
|
weekBean.setStartDateStr1(DateUtils.weekToDayStartStr(entry.getKey()));
|
weekBean.setEndDateStr1(DateUtils.weekToDayEndStr(entry.getKey()));
|
weekBean.setStartDateStr2(DateUtils.weekToDayStartStr(entry.getKey() + 1));
|
weekBean.setEndDateStr2(DateUtils.weekToDayEndStr(entry.getKey() + 1));
|
weekBean.setShow(true);
|
List<WekTypeBean> typeList = new ArrayList<>();
|
for (int i = 0; i < 4; i++) {
|
WekTypeBean typeBean = new WekTypeBean();
|
typeBean.setWeek(entry.getKey());
|
typeBean.setType(i);
|
configTypeName(entry.getKey(), typeBean);
|
if (typeMap.containsKey(i)) {
|
typeBean.setWekList(typeMap.get(i));
|
} else {
|
List<WekRecord> wekRecords = new ArrayList<>();
|
typeBean.setWekList(wekRecords);
|
}
|
typeList.add(typeBean);
|
}
|
|
weekBean.setTypeList(typeList);
|
weekBean.setYear(curYear);
|
weekBean.setUsername(userEntry.getKey());
|
result.add(weekBean);
|
}
|
}
|
|
//姓名升序
|
Comparator nameCom = Comparator.comparing(
|
WekWeekBean::getUsername);
|
//week 降序
|
Comparator weekCom = Comparator.comparingInt(
|
WekWeekBean::getWeek).reversed();
|
result.sort(nameCom.thenComparing(weekCom));
|
|
return result;
|
}
|
|
@Override
|
public List<ProjectTreeVo> projectTreeList(ProProject project) {
|
List<ProProject> proProjects = wekRecordMapper.queryProjectList(project);
|
ProjectTreeVo treeVo = new ProjectTreeVo();
|
Map<String, Object> slotMap = new HashMap<>();
|
slotMap.put("icon", "proGroup");
|
treeVo.setId("0");
|
treeVo.setTitle("项目列表");
|
treeVo.setValue("0");
|
treeVo.setType(1);
|
treeVo.setScopedSlots(slotMap);
|
|
List<ProjectTreeVo> result = new ArrayList<>();
|
List<ProjectTreeVo> subList = new ArrayList<>();
|
for (int i = 0; i < proProjects.size(); i++) {
|
ProProject proProject = proProjects.get(i);
|
ProjectTreeVo vo = new ProjectTreeVo(proProject);
|
Map<String, Object> slot = new HashMap<>();
|
slot.put("icon", "proItem");
|
vo.setLeaf(true);
|
vo.setType(2);
|
vo.setScopedSlots(slot);
|
subList.add(vo);
|
}
|
treeVo.setChildren(subList);
|
result.add(treeVo);
|
|
return result;
|
}
|
|
@Override
|
public List<WekProject> queryProjectWeekly(String xm, int page) {
|
List<WekProject> result = new ArrayList<>();
|
|
WekRecord mapParams = new WekRecord();
|
if (!StringUtils.isEmpty(xm)) {
|
mapParams.setXm(xm);
|
}
|
//先查询数据的年 周
|
List<HashMap<String, Object>> hashMaps = wekRecordMapper.queryYearWeekGroup(mapParams);
|
|
//页码大于总数据时
|
if (page > hashMaps.size()) {
|
return result;
|
}
|
HashMap<String, Object> stringObjectHashMap = hashMaps.get(page - 1);
|
int curYear = (int) stringObjectHashMap.get("year");
|
int curWeek = (int) stringObjectHashMap.get("week");
|
|
|
QueryWrapper<WekRecord> queryWrapper = new QueryWrapper<>();
|
queryWrapper.lambda().eq(WekRecord::getYear, curYear).and(j -> j.in(WekRecord::getWeek, curWeek));
|
//条件查询
|
if (!StringUtils.isEmpty(xm)) {
|
queryWrapper.lambda().eq(WekRecord::getXm, xm);
|
}
|
queryWrapper.lambda().orderByAsc(WekRecord::getUser);
|
//只查询0-本周总结
|
queryWrapper.lambda().eq(WekRecord::getType, 0);
|
List<WekRecord> list = wekRecordMapper.selectList(queryWrapper);
|
|
//根据周分类
|
Map<Integer, List<WekRecord>> collect = list.stream().collect(Collectors.groupingBy(t -> t.getWeek()));
|
|
for (Map.Entry<Integer, List<WekRecord>> entry : collect.entrySet()) {
|
List<WekRecord> value = entry.getValue();
|
WekProject pro = new WekProject();
|
Map<String, String> colorMap = new HashMap<>();
|
pro.setWeek(entry.getKey());
|
pro.setYear(curYear);
|
pro.setStartDateStr1(DateUtils.weekToDayStartStr(entry.getKey()));
|
pro.setEndDateStr1(DateUtils.weekToDayEndStr(entry.getKey()));
|
pro.setWekRecordList(value);
|
pro.setXmName(value.get(0).getXmName());
|
pro.setShow(true);
|
|
//根据项目内成员生成颜色
|
for (int i = 0; i < value.size(); i++) {
|
WekRecord record = value.get(i);
|
if (!colorMap.containsKey(record.getUser()))
|
colorMap.put(record.getUser(), HTMLUtils.getColor(colorMap.size()));
|
}
|
pro.setColorMap(colorMap);
|
result.add(pro);
|
|
}
|
return result;
|
|
}
|
|
@Override
|
public List<WekProject> queryAllProjectWeekly(int page) {
|
|
List<WekProject> result = new ArrayList<>();
|
WekRecord mapParams = new WekRecord();
|
//先查询数据的年 周
|
List<HashMap<String, Object>> hashMaps = wekRecordMapper.queryAllXmYearWeekGroup(mapParams);
|
|
//页码大于总数据时
|
if (page > hashMaps.size()) {
|
return result;
|
}
|
HashMap<String, Object> stringObjectHashMap = hashMaps.get(page - 1);
|
int curYear = (int) stringObjectHashMap.get("year");
|
int curWeek = (int) stringObjectHashMap.get("week");
|
|
QueryWrapper<WekRecord> queryWrapper = new QueryWrapper<>();
|
queryWrapper.in("year", curYear).in("week", curWeek).in("type", 0).isNotNull("xm").orderByDesc("year").orderByDesc("week").orderByAsc("user");
|
//查询数据
|
List<WekRecord> list = wekRecordMapper.selectList(queryWrapper);
|
//按照 项目-周 分类数据
|
Map<String, Map<Integer, List<WekRecord>>> collect = list.stream().collect(Collectors.groupingBy(t -> t.getXm(), Collectors.groupingBy(t -> t.getWeek())));
|
|
for (Map.Entry<String, Map<Integer, List<WekRecord>>> project : collect.entrySet()) {
|
String xm = project.getKey();
|
for (Map.Entry<Integer, List<WekRecord>> entry : project.getValue().entrySet()) {
|
List<WekRecord> value = entry.getValue();
|
WekProject pro = new WekProject();
|
Map<String, String> colorMap = new HashMap<>();
|
pro.setWeek(entry.getKey());
|
pro.setYear(curYear);
|
pro.setStartDateStr1(DateUtils.weekToDayStartStr(entry.getKey()));
|
pro.setEndDateStr1(DateUtils.weekToDayEndStr(entry.getKey()));
|
pro.setWekRecordList(value);
|
pro.setXmName(value.get(0).getXmName());
|
pro.setShow(true);
|
|
//根据项目内成员生成颜色
|
for (int i = 0; i < value.size(); i++) {
|
WekRecord record = value.get(i);
|
if (!colorMap.containsKey(record.getUser()))
|
colorMap.put(record.getUser(), HTMLUtils.getColor(colorMap.size()));
|
}
|
pro.setColorMap(colorMap);
|
result.add(pro);
|
}
|
}
|
//项目名升序
|
Comparator nameCom = Comparator.comparing(
|
WekProject::getXmName);
|
//week 降序
|
Comparator weekCom = Comparator.comparingInt(
|
WekProject::getWeek).reversed();
|
result.sort(nameCom.thenComparing(weekCom));
|
return result;
|
}
|
|
@Override
|
public Result<List<Map<String, Object>>> statisticsList(WekRecord wekRecord) {
|
Result<List<Map<String, Object>>> result = new Result<>();
|
int SUB_TYPE_1 = 1;//项目相关工作
|
int SUB_TYPE_2 = 2;//日常事务工作
|
|
//查询参数
|
Map<String, Object> param = new HashMap<>();
|
param.put("xm", wekRecord.getXm()); //项目名称
|
param.put("user", wekRecord.getUser());//用户
|
//计算日期的周
|
if (wekRecord.getKsrq() != null) {
|
Integer sno = DateUtils.getWeekNoByDate(wekRecord.getKsrq());
|
int year = DateUtils.getYear(wekRecord.getKsrq());
|
param.put("syear", year);//查询开始年份
|
param.put("sweek", sno);//查询开始星期号
|
}
|
if (wekRecord.getJsrq() != null) {
|
Integer eno = DateUtils.getWeekNoByDate(wekRecord.getJsrq());
|
int year = DateUtils.getYear(wekRecord.getJsrq());
|
param.put("eyear", year);//查询结束年份
|
param.put("eweek", eno);//查询结束星期号
|
}
|
|
|
//查询数据包括type 0-本周总结 和 1-本周计划外工作
|
//0对数据进行分组，通过subtype进行分组 subtype 1-项目相关工作 2-日常事务工作（需统计type 0-本周总结 和 1-本周计划外工作，只区分项目相关和日常事务）
|
List<WekRecord> list = wekRecordMapper.statisticsList(param);
|
//测试 TODO 删除
|
// list = list.stream().filter(i -> i.getId().intValue() <= 150).collect(Collectors.toList());
|
|
//统计有周报记录的所有成员（表格的列）
|
List<Map<String, Object>> userList = new ArrayList<>();
|
list.removeIf(item -> item.getUser() == null);
|
Map<String, List<WekRecord>> userMaps = list.stream().collect(Collectors.groupingBy(t -> t.getUser()));
|
for (Map.Entry<String, List<WekRecord>> user : userMaps.entrySet()) {
|
Map<String, Object> map = new HashMap<>();
|
map.put("name", user.getKey());
|
userList.add(map);
|
|
}
|
//合计
|
Map<String, Object> hjMap = new HashMap<>();
|
//纵向合计（个人总工时合计）
|
hjMap.put("xm", "hj");
|
hjMap.put("xmName", "合计");
|
|
//1.1. 过滤subtype 1-项目相关工作数据
|
list.removeIf(item -> item.getSubType() == null);
|
List<WekRecord> proWeeklyList = list.stream().filter(item -> item.getSubType() == SUB_TYPE_1).collect(Collectors.toList());
|
proWeeklyList.removeIf(item -> item.getXm() == null);
|
|
//1.2.统计项目-成员的工时（表格每一行数据）
|
List<Map<String, Object>> proResultList = new ArrayList<>();
|
Map<String, Map<String, List<WekRecord>>> proCollect = proWeeklyList.stream().collect(Collectors.groupingBy(t -> t.getXm(), Collectors.groupingBy(t -> t.getUser())));
|
for (Map.Entry<String, Map<String, List<WekRecord>>> project : proCollect.entrySet()) {
|
Map<String, Object> item = new HashMap<>();
|
String key = project.getKey();
|
Map<String, List<WekRecord>> userMap = project.getValue();
|
//项目
|
item.put("xm", key);
|
|
for (Map.Entry<String, List<WekRecord>> user : userMap.entrySet()) {
|
//统计项目内个人的工时
|
item.put(user.getKey(), user.getValue().stream().filter(wek -> wek.getGs() != null).mapToDouble(WekRecord::getGs).sum());
|
if (user.getValue() != null && user.getValue().size() > 0)
|
item.put("xmName", user.getValue().get(0).getXmName());
|
|
Double cur = (Double) item.get(user.getKey());
|
//统计总工时
|
if (hjMap.containsKey(user.getKey())) {
|
Double total = (Double) hjMap.get(user.getKey());
|
hjMap.put(user.getKey(), total + cur);
|
} else {
|
hjMap.put(user.getKey(), cur);
|
}
|
}
|
proResultList.add(item);
|
}
|
|
//2.1 过滤subtype 2-日常事务工作
|
List<WekRecord> extWeeklyList = list.stream().filter(item -> item.getSubType() == SUB_TYPE_2).collect(Collectors.toList());
|
extWeeklyList.removeIf(item -> item.getExt() == null);
|
//2.2.统计日常事务-成员的工时（表格每一行数据）
|
List<Map<String, Object>> extResultList = new ArrayList<>();
|
Map<Integer, Map<String, List<WekRecord>>> extCollect = extWeeklyList.stream().collect(Collectors.groupingBy(t -> t.getExt(), Collectors.groupingBy(t -> t.getUser())));
|
for (Map.Entry<Integer, Map<String, List<WekRecord>>> ext : extCollect.entrySet()) {
|
Map<String, Object> item = new HashMap<>();
|
Integer key = ext.getKey();
|
Map<String, List<WekRecord>> userMap = ext.getValue();
|
//日常事务id //TODO 为统一前端数据，需要把键设置与项目数据一致
|
//item.put("ext",key);
|
item.put("xm", key);
|
|
for (Map.Entry<String, List<WekRecord>> user : userMap.entrySet()) {
|
//统计日常事务内个人的工时
|
item.put(user.getKey(), user.getValue().stream().filter(wek -> wek.getGs() != null).mapToDouble(WekRecord::getGs).sum());
|
if (user.getValue() != null && user.getValue().size() > 0)
|
//TODO 为统一前端数据，需要把键设置与项目数据一致
|
item.put("xmName", user.getValue().get(0).getExtName());
|
|
Double cur = (Double) item.get(user.getKey());
|
//统计总工时
|
if (hjMap.containsKey(user.getKey())) {
|
Double total = (Double) hjMap.get(user.getKey());
|
hjMap.put(user.getKey(), total + cur);
|
} else {
|
hjMap.put(user.getKey(), cur);
|
}
|
}
|
extResultList.add(item);
|
}
|
|
List<Map<String, Object>> resultList = new ArrayList<>();
|
|
resultList.add(hjMap);
|
resultList.addAll(extResultList);
|
resultList.addAll(proResultList);
|
//计算合计工时
|
for (int i = 0; i < resultList.size(); i++) {
|
Map<String, Object> map = resultList.get(i);
|
Double hj = 0.0;
|
for (Map.Entry<String, Object> item : map.entrySet()) {
|
if (item.getValue() instanceof Double) {
|
hj += (Double) item.getValue();
|
}
|
}
|
//横向合计(项目总工时合计)
|
map.put("hj", hj);
|
}
|
|
result.setResult(resultList);
|
result.setResultExt(userList);
|
|
return result;
|
}
|
|
@Override
|
public Result<List<Map<String, Object>>> statisticsYearList(WekRecord wekRecord) {
|
List<ProProject> proProjects = wekRecordMapper.queryProjectList(null);
|
Map<String, List<ProProject>> xmMaps = proProjects.stream().collect(Collectors.groupingBy(t -> t.getId()));
|
Result<List<Map<String, Object>>> result = new Result<>();
|
//1.生成title
|
Map<String, Object> root = createStatisticsYearTitle();
|
List<Map<String, Object>> statisticsYearTitle = (List<Map<String, Object>>) root.get("colmuns");
|
Map<Integer, String> configMap = (Map<Integer, String>) root.get("config");
|
|
//2.生成数据
|
List<Map<String, Object>> record = new ArrayList<>();
|
int SUB_TYPE_1 = 1;//项目相关工作
|
int SUB_TYPE_2 = 2;//日常事务工作
|
int curYear = DateUtils.getCurYear();
|
|
QueryWrapper<WekRecord> queryWrapper = new QueryWrapper<>();
|
//查询数据包括type 0-本周总结 和 1-本周计划外工作
|
queryWrapper.lambda().eq(WekRecord::getYear, curYear).in(WekRecord::getType, Arrays.asList(0, 1));
|
if (!StringUtils.isEmpty(wekRecord.getXm())) {
|
queryWrapper.lambda().in(WekRecord::getXm, Arrays.asList(wekRecord.getXm().split(",")));
|
}
|
List<WekRecord> list = wekRecordMapper.selectList(queryWrapper);
|
//2.1统计项目相关数据
|
list.removeIf(item -> item.getSubType() == null);
|
List<WekRecord> proWeeklyList = list.stream().filter(item -> item.getSubType() == SUB_TYPE_1).collect(Collectors.toList());
|
proWeeklyList.removeIf(item -> item.getXm() == null);
|
List<Map<String, Object>> proResultList = new ArrayList<>();
|
Map<String, Map<Integer, List<WekRecord>>> proCollect = proWeeklyList.stream().collect(Collectors.groupingBy(t -> t.getXm(), Collectors.groupingBy(t -> t.getWeek())));
|
for (Map.Entry<String, Map<Integer, List<WekRecord>>> project : proCollect.entrySet()) {
|
Map<String, Object> item = new HashMap<>();
|
String key = project.getKey();
|
Map<Integer, List<WekRecord>> weekMap = project.getValue();
|
//项目
|
item.put("xm", key);
|
//组装数据列、统计周、季度工时
|
statisWeeklyGs(configMap, weekMap, item, SUB_TYPE_1);
|
|
proResultList.add(item);
|
}
|
|
//2.2 过滤subtype 2-日常事务工作
|
List<WekRecord> extWeeklyList = list.stream().filter(item -> item.getSubType() == SUB_TYPE_2).collect(Collectors.toList());
|
extWeeklyList.removeIf(item -> item.getExt() == null);
|
List<Map<String, Object>> extResultList = new ArrayList<>();
|
Map<Integer, Map<Integer, List<WekRecord>>> extCollect = extWeeklyList.stream().collect(Collectors.groupingBy(t -> t.getExt(), Collectors.groupingBy(t -> t.getWeek())));
|
for (Map.Entry<Integer, Map<Integer, List<WekRecord>>> ext : extCollect.entrySet()) {
|
Map<String, Object> item = new HashMap<>();
|
Integer key = ext.getKey();
|
Map<Integer, List<WekRecord>> weekMap = ext.getValue();
|
//日常事务id //TODO 为统一前端数据，需要把键设置与项目数据一致
|
//item.put("ext",key);
|
item.put("xm", key);
|
|
//组装数据列、统计周、季度工时
|
statisWeeklyGs(configMap, weekMap, item, SUB_TYPE_2);
|
extResultList.add(item);
|
}
|
List<Map<String, Object>> resultList = new ArrayList<>();
|
|
extResultList.addAll(proResultList);
|
|
//添加一条合计数据
|
Map<String, Object> hjMap = new HashMap<>();
|
hjMap.put("xm", 0);
|
hjMap.put("xmName", "总工时");
|
//统计总工时
|
double total = extResultList.stream().mapToDouble(t -> Double.parseDouble(t.get("total").toString())).sum();
|
hjMap.put("total", total);
|
hjMap.put("prop", "100%");
|
for (int i = 0; i < extResultList.size(); i++) {
|
if (extResultList.size() < 1) continue;
|
Map<String, Object> map = extResultList.get(i);
|
if (!map.containsKey("total")) continue;
|
//项目工时
|
double xmGs = Double.parseDouble(map.get("total").toString());
|
if (xmGs <= 0) continue;
|
//计算项目工时占比
|
NumberFormat nf = NumberFormat.getPercentInstance();
|
nf.setMinimumFractionDigits(2);
|
String res = nf.format((float) xmGs / (float) total);
|
map.put("prop", res);
|
|
//获取项目信息
|
List<ProProject> xm = xmMaps.get(map.get("xm"));
|
if (xm != null && xm.size() > 0) {
|
map.put("xmfzr", xm.get(0).getXmfzr());
|
map.put("xmlx", xm.get(0).getXmlx());
|
map.put("year", DateUtils.date2Str(xm.get(0).getKsrq(), new SimpleDateFormat("yyyy")));
|
}
|
|
|
//统计合计值
|
for (Map.Entry<String, Object> entry : map.entrySet()) {
|
String key = entry.getKey();
|
if (!key.startsWith("m") && !key.startsWith("s")) continue;
|
Object value = entry.getValue();
|
if (value instanceof Number) {
|
if (!hjMap.containsKey(key)) {
|
hjMap.put(key, value);
|
} else {
|
Double o = (Double) hjMap.get(key);
|
Double v = (Double) value;
|
hjMap.put(key, o + v);
|
}
|
}
|
|
|
}
|
|
|
}
|
|
resultList.add(hjMap);
|
resultList.addAll(extResultList);
|
|
result.setResultExt(statisticsYearTitle);
|
result.setResult(resultList);
|
|
return result;
|
}
|
|
@Override
|
public Map<String, Object> customExportWeekly(WekRecord wekRecord) {
|
Map<String, Object> res = new HashMap<>();
|
int SUB_TYPE_1 = 1;//项目相关工作
|
int SUB_TYPE_2 = 2;//日常事务工作
|
|
//查询参数
|
Map<String, Object> param = new HashMap<>();
|
param.put("xm", wekRecord.getXm()); //项目名称
|
param.put("user", wekRecord.getUser());//用户
|
//计算日期的周
|
if (wekRecord.getKsrq() != null) {
|
Integer sno = DateUtils.getWeekNoByDate(wekRecord.getKsrq());
|
int year = DateUtils.getYear(wekRecord.getKsrq());
|
param.put("syear", year);//查询开始年份
|
param.put("sweek", sno);//查询开始星期号
|
}
|
if (wekRecord.getJsrq() != null) {
|
Integer eno = DateUtils.getWeekNoByDate(wekRecord.getJsrq());
|
int year = DateUtils.getYear(wekRecord.getJsrq());
|
param.put("eyear", year);//查询结束年份
|
param.put("eweek", eno);//查询结束星期号
|
}
|
|
|
//查询所有项目
|
List<ProProject> proProjects = wekRecordMapper.queryProjectList(null);
|
Map<String, ProProject> allproMap = proProjects.stream().collect(Collectors.toMap(ProProject::getId, item -> item));
|
//查询所有用户
|
Object o = redisUtil.get(CacheConstant.SYS_USER_ALL_CACHE);
|
Map<String, String> alluserMap = new HashMap<>();
|
if (o != null) {
|
alluserMap = (Map) JSON.parse(o.toString());
|
}
|
|
List<WekRecord> wekList = wekRecordMapper.statisticsList(param);
|
//根据部门过滤
|
List<WekRecord> list = departFilter(wekRecord, wekList);
|
|
|
//统计有周报记录的所有成员（表格的列）
|
List<Map<String, Object>> userList = new ArrayList<>();
|
list.removeIf(item -> item.getUser() == null);
|
Map<String, List<WekRecord>> userMaps = list.stream().collect(Collectors.groupingBy(t -> t.getUser()));
|
for (Map.Entry<String, List<WekRecord>> user : userMaps.entrySet()) {
|
Map<String, Object> map = new HashMap<>();
|
map.put("name", alluserMap.get(user.getKey()));
|
map.put("column", "{pro." + user.getKey() + "}");
|
map.put("key", user.getKey());
|
userList.add(map);
|
}
|
|
Map<String, Object> map = new HashMap<>();
|
map.put("name", "合计");
|
map.put("column", "{pro.hj}");
|
map.put("key", "hj");
|
userList.add(map);
|
|
|
//1.1. 过滤subtype 1-项目相关工作数据
|
list.removeIf(item -> item.getSubType() == null);
|
List<WekRecord> proWeeklyList = list.stream().filter(item -> item.getSubType() == SUB_TYPE_1).collect(Collectors.toList());
|
proWeeklyList.removeIf(item -> item.getXm() == null || item.getUser() == null);
|
|
//1.2.统计项目-成员的工时（表格每一行数据） 项目相关数据
|
List<Map<String, Object>> proResultList = new ArrayList<>();
|
Map<String, Map<String, List<WekRecord>>> proCollect = proWeeklyList.stream().collect(Collectors.groupingBy(t -> t.getXm(), Collectors.groupingBy(t -> t.getUser())));
|
|
proCollect.forEach((String xm, Map<String, List<WekRecord>> xmWekMap) -> {
|
Map<String, Object> item = new HashMap<>();
|
ProProject proProject = allproMap.get(xm);
|
item.put("xmmc", proProject.getXmmc());
|
item.put("xmbh", proProject.getXmbh());
|
//一个项目的合计工时
|
AtomicReference<Double> hj = new AtomicReference<>(0.0);
|
xmWekMap.forEach((String user, List<WekRecord> userWekList) -> {
|
double sum = userWekList.stream().filter(i -> i.getGs() != null).mapToDouble(i -> i.getGs()).sum();
|
item.put(user, sum);
|
hj.updateAndGet(v -> new Double((double) (v + sum)));
|
});
|
item.put("hj", hj.get());
|
userList.forEach(i -> {
|
String userkey = i.get("key").toString();
|
if (!item.containsKey(userkey)) {
|
item.put(userkey, 0.0);
|
}
|
});
|
|
proResultList.add(item);
|
});
|
|
List<WekRecord> extWeeklyList = list.stream().filter(item -> item.getSubType() == SUB_TYPE_2).collect(Collectors.toList());
|
extWeeklyList.removeIf(item -> item.getExtName() == null || item.getUser() == null);
|
|
//1.3 统计其他-成员的工时（表格每一行数据） 其他相关数据
|
List<Map<String, Object>> extResultList = new ArrayList<>();
|
Map<String, Map<String, List<WekRecord>>> extCollect = extWeeklyList.stream().collect(Collectors.groupingBy(t -> t.getExtName(), Collectors.groupingBy(t -> t.getUser())));
|
|
extCollect.forEach((String extName, Map<String, List<WekRecord>> xmWekMap) -> {
|
Map<String, Object> item = new HashMap<>();
|
item.put("xmmc", extName);
|
item.put("xmbh", "");
|
//其他相关数据的合计工时
|
AtomicReference<Double> hj = new AtomicReference<>(0.0);
|
xmWekMap.forEach((String user, List<WekRecord> userWekList) -> {
|
double sum = userWekList.stream().filter(i -> i.getGs() != null).mapToDouble(i -> i.getGs()).sum();
|
item.put(user, sum);
|
hj.updateAndGet(v -> new Double((double) (v + sum)));
|
});
|
item.put("hj", hj.get());
|
userList.forEach(i -> {
|
String userkey = i.get("key").toString();
|
if (!item.containsKey(userkey)) {
|
item.put(userkey, 0.0);
|
}
|
});
|
|
extResultList.add(item);
|
});
|
|
extResultList.addAll(proResultList);
|
//列 合计
|
Map<String, Object> item = new HashMap<>();
|
item.put("xmmc", "合计");
|
item.put("xmbh", "");
|
userList.forEach(i -> {
|
String col = i.get("key").toString();
|
Double sum = extResultList.stream().mapToDouble(j -> (Double) j.get(col)).sum();
|
item.put(col, sum.intValue());
|
});
|
List<Map<String, Object>> resultList = new ArrayList<>();
|
resultList.add(item);
|
resultList.addAll(extResultList);
|
|
String ks = DateUtils.getWeekInMonth(wekRecord.getKsrq());
|
// int smonth = DateUtils.getMonth(wekRecord.getKsrq());
|
// int syear = DateUtils.getYear(wekRecord.getKsrq());
|
|
String js = DateUtils.getWeekInMonth(wekRecord.getJsrq());
|
// int emonth = DateUtils.getMonth(wekRecord.getJsrq());
|
// int eyear = DateUtils.getYear(wekRecord.getJsrq());
|
|
String sks = DateUtils.date2Str(wekRecord.getKsrq(), DateUtils.date_sdf.get());
|
String sjs = DateUtils.date2Str(wekRecord.getJsrq(), DateUtils.date_sdf.get());
|
|
res.put("title", ks + " ~ " + js + "("+sks +" - "+ sjs+")");
|
res.put("users", userList);
|
res.put("data", resultList);
|
|
if(wekRecord.getDetailFlag()==1){
|
List<Map<String, Object>> userWeeklys = createUserWeeklys(list, userList);
|
res.put("usersweeklys", userWeeklys);
|
}
|
|
|
return res;
|
|
}
|
|
/**
|
* 周报数据按照、用户、年、周分组
|
*
|
* @param list 周报记录
|
* @param userList 用户列表
|
*/
|
private List<Map<String, Object>> createUserWeeklys(List<WekRecord> list, List<Map<String, Object>> userList) {
|
List<String> users = userList.stream().map(i -> {
|
return i.get("key").toString();
|
}).collect(Collectors.toList());
|
//查询所有用户信息
|
List<HashMap<String, Object>> userInfoList = wekRecordMapper.queryUsersInfoByNames(users);
|
Map<String, HashMap<String, Object>> userinfos = userInfoList.stream()
|
.collect(Collectors.toMap(item -> item.get("username").toString(), item -> item, (v1, v2) -> {
|
return v1;
|
}));
|
|
List<Map<String, Object>> usersweekly = new ArrayList<>();
|
list.removeIf(i -> i.getYear() == null || i.getWeek() == null);
|
Map<String, Map<Integer, Map<Integer, List<WekRecord>>>> collect = list.stream().collect(Collectors.groupingBy(i -> i.getUser(), Collectors.groupingBy(t -> t.getYear(), Collectors.groupingBy(t -> t.getWeek()))));
|
collect.forEach((user, uWekMap) -> {
|
uWekMap.forEach((year, yWekMap) -> {
|
yWekMap.forEach((week, wList) -> {
|
Map<String, Object> userAweekly = createUserAweekly(user, year, week, wList, userinfos);
|
usersweekly.add(userAweekly);
|
|
});
|
});
|
});
|
return usersweekly;
|
}
|
|
/**
|
* @param user 用户usernmae
|
* @param year 周报所属年份
|
* @param week 周报所属周号
|
* @param wList 周报记录
|
* @param userinfos 用户信息
|
* @return
|
*/
|
private Map<String, Object> createUserAweekly(String user, Integer year, Integer week, List<WekRecord> wList, Map<String, HashMap<String, Object>> userinfos) {
|
Map<String, Object> res = new HashMap<>();
|
Map<String, Object> basisinfo = new HashMap<>();
|
String start = DateUtils.weekToDayStartStr(year, week, "yyyy-MM-dd");
|
String end = DateUtils.weekToFriDayEndStr(year, week, "yyyy-MM-dd");
|
String sheet = DateUtils.getWeekInMonth(end,2);
|
HashMap<String, Object> userMap = userinfos.get(user);
|
if (userinfos != null && userMap != null) {
|
basisinfo.put("departname", userMap.get("departname"));
|
basisinfo.put("post", userMap.get("post"));
|
basisinfo.put("realname", userMap.get("realname"));
|
}
|
|
basisinfo.put("start", start);
|
basisinfo.put("end", end);
|
basisinfo.put("sheet", basisinfo.containsKey("realname") ? basisinfo.get("realname") + "-" + sheet : user + "-" + sheet);
|
|
|
Map<Integer, List<WekRecord>> collect = wList.stream().collect(Collectors.groupingBy(i -> i.getType()));
|
//数据库周报类型
|
int[] types = {0, 1, 2, 3};
|
Map<String, Object> gsMap = new HashMap<>();
|
AtomicInteger dataIndex = new AtomicInteger(1);
|
collect.forEach((k, v) -> {
|
AtomicInteger index = new AtomicInteger(1);
|
List<Map<String, Object>> typeList = v.stream().map(i -> {
|
Map<String, Object> item = new HashMap<>();
|
if (k == types[0]) {
|
item.put("part", "本周工作汇报");
|
} else if (k == types[1]) {
|
item.put("part", "本周计划外工作");
|
} else if (k == types[2]) {
|
item.put("part", "下周工作计划");
|
} else if (k == types[3]) {
|
item.put("part", "需协调事务");
|
}
|
item.put("no", index.getAndIncrement());
|
if (i.getSubType() == 1) {
|
item.put("name", i.getXmName());
|
} else if (i.getSubType() == 2) {
|
item.put("name", i.getExtName());
|
}
|
item.put("wbs", i.getWbsName());
|
item.put("content", i.getGzms());
|
item.put("delivery", i.getXmDeliver());
|
item.put("hour", i.getGs());
|
|
Date createTime = i.getCreateTime();
|
|
int weekNo = DateUtils.getWeekNo(createTime);
|
item.put("mon", weekNo == 1 ? "√" : "");
|
item.put("tue", weekNo == 2 ? "√" : "");
|
item.put("wed", weekNo == 3 ? "√" : "");
|
item.put("thi", weekNo == 4 ? "√" : "");
|
item.put("fri", weekNo == 5 ? "√" : "");
|
return item;
|
}).filter(i -> i.containsKey("part")).collect(Collectors.toList());
|
|
res.put("data" + dataIndex, typeList);
|
double sum = v.stream().filter(i -> i.getGs() != null).mapToDouble(WekRecord::getGs).sum();
|
gsMap.put("zgs" + dataIndex, sum);
|
dataIndex.getAndIncrement();
|
});
|
res.put("zgs", gsMap);
|
res.put("basisinfo", basisinfo);
|
|
//导出周报考评信息
|
String eid = user + (year * 100 + week);
|
WekEvaluate wekEvaluate = wekEvaluateMapper.selectById(eid);
|
if(wekEvaluate!=null){
|
WekEvaluateBean bean = new WekEvaluateBean();
|
BeanUtils.copyProperties(wekEvaluate,bean);
|
if(bean.getZpDate()!=null){
|
String zpDate = DateUtils.date2Str(bean.getZpDate(), DateUtils.datetimeFormat.get());
|
bean.setZpDateStr(zpDate);
|
}
|
|
if(bean.getKpDate()!=null){
|
String kpDate = DateUtils.date2Str(bean.getKpDate(), DateUtils.datetimeFormat.get());
|
bean.setKpDateStr(kpDate);
|
}
|
Map<String, Object> evaMap = convertToMap(bean);
|
res.put("eva", evaMap);
|
}
|
|
|
return res;
|
|
}
|
|
|
@Override
|
public Map<String, Object> exportAweekly(WekRecord wekRecord) {
|
Map<String, Object> res = new HashMap<>();
|
QueryWrapper<WekRecord> queryWrapper = new QueryWrapper<>();
|
queryWrapper.lambda().eq(WekRecord::getYear, wekRecord.getYear());
|
queryWrapper.lambda().eq(WekRecord::getWeek, wekRecord.getWeek());
|
queryWrapper.lambda().eq(WekRecord::getUser, wekRecord.getUser());
|
|
if (wekRecord.getUser() == null || wekRecord.getYear() == null || wekRecord.getWeek() == null) {
|
return res;
|
}
|
//周报数据
|
List<WekRecord> list = wekRecordMapper.selectList(queryWrapper);
|
if (list == null || list.size() < 1) {
|
return res;
|
}
|
|
Map<Integer, List<WekRecord>> collect = list.stream().filter(i -> i.getSubType() != null && i.getType() != null).collect(Collectors.groupingBy(i -> i.getType()));
|
//数据库周报类型
|
int[] types = {0, 1, 2, 3};
|
Map<String, Object> gsMap = new HashMap<>();
|
AtomicInteger dataIndex = new AtomicInteger(1);
|
collect.forEach((k, v) -> {
|
AtomicInteger index = new AtomicInteger(1);
|
List<Map<String, Object>> typeList = v.stream().map(i -> {
|
Map<String, Object> item = new HashMap<>();
|
if (k == types[0]) {
|
item.put("part", "本周工作汇报");
|
} else if (k == types[1]) {
|
item.put("part", "本周计划外工作");
|
} else if (k == types[2]) {
|
item.put("part", "下周工作计划");
|
} else if (k == types[3]) {
|
item.put("part", "需协调事务");
|
}
|
item.put("no", index.getAndIncrement());
|
if (i.getSubType() == 1) {
|
item.put("name", i.getXmName());
|
} else if (i.getSubType() == 2) {
|
item.put("name", i.getExtName());
|
}
|
item.put("wbs", i.getWbsName());
|
item.put("content", i.getGzms());
|
item.put("delivery", i.getXmDeliver());
|
item.put("hour", i.getGs());
|
|
Date createTime = i.getCreateTime();
|
|
int weekNo = DateUtils.getWeekNo(createTime);
|
item.put("mon", weekNo == 1 ? "√" : "");
|
item.put("tue", weekNo == 2 ? "√" : "");
|
item.put("wed", weekNo == 3 ? "√" : "");
|
item.put("thi", weekNo == 4 ? "√" : "");
|
item.put("fri", weekNo == 5 ? "√" : "");
|
return item;
|
}).filter(i -> i.containsKey("part")).collect(Collectors.toList());
|
|
res.put("data" + dataIndex, typeList);
|
double sum = v.stream().filter(i -> i.getGs() != null).mapToDouble(WekRecord::getGs).sum();
|
gsMap.put("zgs" + dataIndex, sum);
|
dataIndex.getAndIncrement();
|
});
|
|
res.put("size", list.size());
|
res.put("zgs", gsMap);
|
|
//导出周报考评信息
|
String eid = wekRecord.getUser() + (wekRecord.getYear() * 100 + wekRecord.getWeek());
|
WekEvaluate wekEvaluate = wekEvaluateMapper.selectById(eid);
|
if(wekEvaluate!=null){
|
WekEvaluateBean bean = new WekEvaluateBean();
|
BeanUtils.copyProperties(wekEvaluate,bean);
|
if(bean.getZpDate()!=null){
|
String zpDate = DateUtils.date2Str(bean.getZpDate(), DateUtils.datetimeFormat.get());
|
bean.setZpDateStr(zpDate);
|
}
|
|
if(bean.getKpDate()!=null){
|
String kpDate = DateUtils.date2Str(bean.getKpDate(), DateUtils.datetimeFormat.get());
|
bean.setKpDateStr(kpDate);
|
}
|
Map<String, Object> evaMap = convertToMap(bean);
|
res.put("eva", evaMap);
|
}
|
|
return res;
|
}
|
|
public static Map<String, Object> convertToMap(Object entity) {
|
Map<String, Object> map = new HashMap<>();
|
|
Field[] fields = entity.getClass().getSuperclass().getDeclaredFields();
|
Field[] fields2 = entity.getClass().getDeclaredFields();
|
|
for (Field field : fields) {
|
field.setAccessible(true);
|
try {
|
Object value = field.get(entity);
|
map.put(field.getName(), value);
|
} catch (IllegalAccessException e) {
|
// 处理异常情况
|
e.printStackTrace();
|
}
|
}
|
|
for (Field field : fields2) {
|
field.setAccessible(true);
|
try {
|
Object value = field.get(entity);
|
map.put(field.getName(), value);
|
} catch (IllegalAccessException e) {
|
// 处理异常情况
|
e.printStackTrace();
|
}
|
}
|
|
return map;
|
}
|
|
@Override
|
public Map<String, Object> queryUserInfoByName(String user) {
|
List<HashMap<String, Object>> hashMaps = wekRecordMapper.queryUserInfoByName(user);
|
return hashMaps != null && hashMaps.size() > 0 ? hashMaps.get(0) : null;
|
}
|
|
@Override
|
public void calcWbsProgress(WekRecord wekRecord) {
|
String wbs = wekRecord.getWbs();
|
//没有wbs
|
if (StringUtils.isEmpty(wbs)) {
|
return;
|
}
|
//当前填写进度
|
Integer curJd = wekRecord.getJd();
|
if (curJd == null || curJd == 0) {
|
return;
|
}
|
QueryWrapper<WekRecord> wekRecordQueryWrapper = new QueryWrapper<>();
|
wekRecordQueryWrapper.lambda().eq(WekRecord::getWbs, wbs);
|
List<WekRecord> wekRecordList = wekRecordMapper.selectList(wekRecordQueryWrapper);
|
Map<String, List<WekRecord>> userWekMap = wekRecordList.stream().collect(Collectors.groupingBy(item -> item.getUser()));
|
Result<ProProjectLink> proLinkResult = projectClient.queryWbsId(wbs);
|
ProProjectLink result = proLinkResult.getResult();
|
if (result == null) return;
|
String zymc = result.getZymc();
|
if (StringUtils.isEmpty(zymc)) return;
|
String[] users = zymc.split(",");
|
int length = users.length;
|
|
//wbs 已完成
|
if (result.getWcjd() != null && result.getWcjd() == 1) {
|
return;
|
}
|
|
//如果当前填写进度 == 1000 视为wbs完成，后续不再计算wbs进度
|
if (curJd == 1000) {
|
result.setWcjd(1);
|
result.setJd(100);
|
projectClient.editLink(result);
|
return;
|
}
|
|
//根据周报填写进度修改wbs进度
|
//wbs进度
|
int totalJd = 0;
|
for (int i = 0; i < length; i++) {
|
String user = users[i];
|
if (userWekMap.containsKey(user)) {
|
List<WekRecord> oList = userWekMap.get(user);
|
if (oList.size() < 1) continue;
|
//当前wbs进度最大一个
|
WekRecord record = oList.stream().filter(item -> item.getJd() != null).max(Comparator.comparing(WekRecord::getJd)).get();
|
if (record == null || record.getJd() == null) continue;
|
Integer jd = record.getJd();
|
totalJd += jd;
|
}
|
|
}
|
if (totalJd > 0 && length > 0) {
|
totalJd /= length;
|
result.setJd(totalJd);
|
//所有人完成才设置wbs为完成
|
if (totalJd >= 100) result.setWcjd(1);
|
projectClient.editLink(result);
|
}
|
|
|
}
|
|
/**
|
* 部门过滤，只需要sysOrgCode中数据
|
*
|
* @param wekRecord sysOrgCode需要包含的部门
|
* @param list 周报数据
|
* @return 过滤部门周报数据
|
*/
|
private List<WekRecord> departFilter(WekRecord wekRecord, List<WekRecord> list) {
|
if (!StringUtils.isEmpty(wekRecord.getSysOrgCode())) {
|
String sysOrgCode = wekRecord.getSysOrgCode();
|
String[] split = sysOrgCode.split(",");
|
List<String> departs = Arrays.asList(split);
|
return list.stream().filter(i -> {
|
AtomicBoolean allow = new AtomicBoolean(false);
|
String orgCode = i.getSysOrgCode();
|
departs.forEach(org -> {
|
if (orgCode!=null && orgCode.startsWith(org)) {
|
allow.set(true);
|
}
|
});
|
return allow.get();
|
}).collect(Collectors.toList());
|
}
|
return list;
|
}
|
|
/**
|
* 统计周报工时
|
*
|
* @param configMap 一年所有星期
|
* @param weekMap 数据库周报记录 key-周号 value-周报记录
|
* @param item 生成的数据
|
* @param subType 数据类型 1-项目相关 2-其他事项
|
*/
|
private void statisWeeklyGs(Map<Integer, String> configMap, Map<Integer, List<WekRecord>> weekMap, Map<String, Object> item, int subType) {
|
int SUB_TYPE_1 = 1;//项目相关工作
|
int SUB_TYPE_2 = 2;//日常事务工作
|
//TODO 此处遍历的是一年所有的星期
|
for (Map.Entry<Integer, String> week : configMap.entrySet()) {
|
|
if (weekMap.containsKey(week.getKey())) {
|
//统计项目内一周的工时 TODO week的key为周号；value为生成title的数据列
|
item.put(week.getValue(), weekMap.get(week.getKey()).stream().filter(wek -> wek.getGs() != null).mapToDouble(WekRecord::getGs).sum());
|
if (subType == SUB_TYPE_1) {
|
if (!item.containsKey("xmName")) item.put("xmName", weekMap.get(week.getKey()).get(0).getXmName());
|
} else if (subType == SUB_TYPE_2) {
|
if (!item.containsKey("xmName")) item.put("xmName", weekMap.get(week.getKey()).get(0).getExtName());
|
}
|
//数据列（dataIndex）的规则是 m+（月份）+w+（星期号），此处截取月份判断数据属于哪个季
|
int i = Integer.parseInt(week.getValue().substring(1, 2));
|
//统计四季数据 四季的数据列为(s1,s2,s3,s4)
|
if (i < 4) {
|
if (!item.containsKey("s1")) {
|
item.put("s1", item.get(week.getValue()));
|
} else {
|
Double sTotal = (Double) item.get("s1") + (Double) item.get(week.getValue());
|
item.put("s1", sTotal);
|
}
|
} else if (i > 3 && i < 7) {
|
if (!item.containsKey("s2")) {
|
item.put("s2", item.get(week.getValue()));
|
} else {
|
Double sTotal = (Double) item.get("s2") + (Double) item.get(week.getValue());
|
item.put("s2", sTotal);
|
}
|
} else if (i > 6 && i < 10) {
|
if (!item.containsKey("s3")) {
|
item.put("s3", item.get(week.getValue()));
|
} else {
|
Double sTotal = (Double) item.get("s3") + (Double) item.get(week.getValue());
|
item.put("s3", sTotal);
|
}
|
|
} else if (i > 9 && i < 13) {
|
if (!item.containsKey("s4")) {
|
item.put("s4", item.get(week.getValue()));
|
} else {
|
Double sTotal = (Double) item.get("s4") + (Double) item.get(week.getValue());
|
item.put("s4", sTotal);
|
}
|
}
|
|
|
} else {
|
item.put(week.getValue(), 0.0);
|
}
|
|
|
}
|
|
|
//四季总数据
|
item.put("total", 0.0);
|
for (int j = 1; j <= 4; j++) {
|
String season = "s" + j;
|
if (item.containsKey(season)) {
|
Double s = (Double) item.get(season);
|
Double t = (Double) item.get("total");
|
item.put("total", s + t);
|
} else {
|
//没有数据的季 设置工时为0
|
item.put(season, 0.0);
|
}
|
|
}
|
|
}
|
|
/**
|
* 生成周报年统计报表的titile
|
*/
|
private Map<String, Object> createStatisticsYearTitle() {
|
Map<String, Object> root = new HashMap<>();
|
//title
|
List<Map<String, Object>> res = new ArrayList<>();
|
//周号对应colmun
|
Map<Integer, String> map = new HashMap<>();
|
//当前年
|
int curYear = DateUtils.getCurYear();
|
//统计一年有多少周
|
int yearWeekCount = 0;
|
//统计一季有多少周
|
int seasonCount = 0;
|
//先加一列全年合计
|
Map<String, Object> yearMap = new HashMap<>();
|
yearMap.put("title", curYear + "年");
|
List<Map<String, Object>> countYearList = new ArrayList<>();
|
yearMap.put("children", countYearList);
|
|
Map<String, Object> yearItem = new HashMap<>();
|
yearItem.put("title", "总计");
|
yearItem.put("column", "total");
|
countYearList.add(yearItem);
|
|
Map<String, Object> yearItem2 = new HashMap<>();
|
yearItem2.put("title", "占比");
|
yearItem2.put("column", "prop");
|
countYearList.add(yearItem2);
|
|
|
res.add(yearMap);
|
int curSeason = 0;
|
int curMonth = DateUtils.getCurMonth();
|
if (curMonth < 4) {
|
curSeason = 1;
|
} else if (curMonth > 3 && curMonth < 7) {
|
curSeason = 2;
|
} else if (curMonth > 6 && curMonth < 10) {
|
curSeason = 3;
|
} else {
|
curSeason = 4;
|
}
|
//一年12个月
|
for (int i = 1; i <= 12; i++) {
|
|
//月
|
Map<String, Object> monthMap = new HashMap<>();
|
monthMap.put("title", i + "月");
|
List<Map<String, Object>> weekList = new ArrayList<>();
|
monthMap.put("children", weekList);
|
res.add(monthMap);
|
//季
|
if (i % 3 == 0) {
|
seasonCount++;
|
Map<String, Object> seasonMap = new HashMap<>();
|
seasonMap.put("title", "第" + seasonCount + "季度");
|
seasonMap.put("column", "s" + seasonCount);
|
seasonMap.put("cno", seasonCount);
|
seasonMap.put("curSeason", curSeason);
|
res.add(seasonMap);
|
}
|
|
|
LocalDate date = LocalDate.of(curYear, i, 1);
|
//获取当月第一天是星期几
|
int week = date.getDayOfWeek().getValue();
|
//这个月最后一天
|
date = date.with(TemporalAdjusters.lastDayOfMonth());
|
//获取这天是这个月的第几天
|
int dayOfMonth = date.getDayOfMonth();
|
//统计一个月有多少周 （TODO ：此处分周逻辑保持和周报获取周逻辑一致，定义周日在哪个月则设定本周属于哪个月）
|
int monthWeekCount = 0;
|
for (int j = 1; j <= dayOfMonth; j++) {
|
LocalDate everyDay = LocalDate.of(curYear, i, j);
|
int d = everyDay.getDayOfWeek().getValue();
|
//System.err.println("日期：" + everyDay + "-星期：" + d);
|
if (d % 7 == 0) {
|
monthWeekCount++;
|
yearWeekCount++;
|
String weekToDayStartStr = DateUtils.weekToDayStartStr(yearWeekCount);
|
String weekToDayEndStr = DateUtils.weekToDayEndStr(yearWeekCount);
|
//System.out.println(i + "月：" + monthWeekCount + "周-No:" + yearWeekCount + "------" + weekToDayStartStr + "==" + weekToDayEndStr);
|
//添加每个月的周
|
Map<String, Object> weekMap = new HashMap<>();
|
weekMap.put("title", i + "月第" + monthWeekCount + "周");
|
weekMap.put("column", "m" + i + "w" + monthWeekCount);
|
weekMap.put("wstart", weekToDayStartStr);
|
weekMap.put("wend", weekToDayEndStr);
|
weekMap.put("wno", yearWeekCount);
|
weekMap.put("curWeek", DateUtils.getCurWeek());
|
weekList.add(weekMap);
|
|
map.put(yearWeekCount, "m" + i + "w" + monthWeekCount);
|
|
}
|
}
|
|
}
|
root.put("colmuns", res);
|
root.put("config", map);
|
return root;
|
}
|
|
|
//创建本周和上周数据模板
|
private List<WekWeekBean> createTemplateData() {
|
//当前周
|
int curWeekNo = DateUtils.getCurWeek();
|
//当前年
|
int curYear = DateUtils.getCurYear();
|
String curWeekStart = DateUtils.weekToDayStartStr(curWeekNo);
|
String curWeekEnd = DateUtils.weekToDayEndStr(curWeekNo);
|
//上周
|
int lastWeekNo = curWeekNo - 1;
|
String lastWeekStart = DateUtils.weekToDayStartStr(lastWeekNo);
|
String lastWeekEnd = DateUtils.weekToDayEndStr(lastWeekNo);
|
if (curWeekNo == 1) {
|
lastWeekNo = 52;
|
lastWeekStart = DateUtils.weekToDayStartStr(curYear-1, lastWeekNo);
|
lastWeekEnd = DateUtils.weekToDayEndStr(curYear-1,lastWeekNo);
|
}
|
|
//下周
|
int nextWeekNo = curWeekNo + 1;
|
String nextWeekStart = DateUtils.weekToDayStartStr(nextWeekNo);
|
String nextWeekEnd = DateUtils.weekToDayEndStr(nextWeekNo);
|
|
|
//本周数据（本周数据显示本周内容和下周计划）
|
List<WekWeekBean> rootList = new ArrayList<>();
|
WekWeekBean thisWeek = new WekWeekBean();
|
thisWeek.setShow(true);
|
thisWeek.setWeek(curWeekNo);
|
thisWeek.setStartDateStr1(curWeekStart);
|
thisWeek.setEndDateStr1(curWeekEnd);
|
String tws = DateUtils.weekToDayEndStr(curYear, curWeekNo, "yyyy-MM-dd");
|
thisWeek.setWeekInMonth(DateUtils.getWeekInMonth(tws,2));
|
thisWeek.setStartDateStr2(nextWeekStart);
|
thisWeek.setEndDateStr2(nextWeekEnd);
|
thisWeek.setYear(curYear);
|
//上周数据
|
WekWeekBean lastWeek = new WekWeekBean();
|
lastWeek.setShow(false);
|
lastWeek.setWeek(lastWeekNo);
|
lastWeek.setStartDateStr1(lastWeekStart);
|
lastWeek.setEndDateStr1(lastWeekEnd);
|
String lws = DateUtils.weekToDayEndStr(curYear, lastWeekNo, "yyyy-MM-dd");
|
lastWeek.setWeekInMonth(DateUtils.getWeekInMonth(lws,2));
|
lastWeek.setStartDateStr2(curWeekStart);
|
lastWeek.setEndDateStr2(curWeekEnd);
|
lastWeek.setYear(curYear);
|
if (curWeekNo == 1) {
|
lastWeek.setYear(curYear-1);
|
}
|
|
|
//周里面的4种类型 0-本周总结、1-本周计划外工作、2-下周计划、3-下周需协调事务
|
List<WekTypeBean> typeList1 = new ArrayList<>();
|
for (int i = 0; i < 4; i++) {
|
WekTypeBean type = new WekTypeBean(i, thisWeek.getWeek());
|
List<WekRecord> list = new ArrayList<>();
|
type.setWekList(list);
|
configTypeName(curWeekNo, type);
|
typeList1.add(type);
|
}
|
//周里面的4种类型 0-本周总结、1-本周计划外工作、2-下周计划、3-下周需协调事务
|
List<WekTypeBean> typeList2 = new ArrayList<>();
|
for (int i = 0; i < 4; i++) {
|
WekTypeBean type = new WekTypeBean(i, lastWeek.getWeek());
|
List<WekRecord> list = new ArrayList<>();
|
type.setWekList(list);
|
configTypeName(curWeekNo, type);
|
typeList2.add(type);
|
}
|
|
thisWeek.setTypeList(typeList1);
|
thisWeek.setShowDetail(true);
|
lastWeek.setTypeList(typeList2);
|
lastWeek.setShowDetail(true);
|
rootList.add(thisWeek);
|
rootList.add(lastWeek);
|
return rootList;
|
}
|
|
//创建空白数据
|
private List<WekWeekBean> createEmptyData(Integer year, Integer week,String username) {
|
|
String curWeekStart = DateUtils.weekToDayStartStr(week);
|
String curWeekEnd = DateUtils.weekToDayEndStr(week);
|
|
//下周
|
int nextWeekNo = week + 1;
|
String nextWeekStart = DateUtils.weekToDayStartStr(nextWeekNo);
|
String nextWeekEnd = DateUtils.weekToDayEndStr(nextWeekNo);
|
|
//本周数据（本周数据显示本周内容和下周计划）
|
List<WekWeekBean> rootList = new ArrayList<>();
|
WekWeekBean thisWeek = new WekWeekBean();
|
thisWeek.setShow(true);
|
thisWeek.setWeek(week);
|
thisWeek.setStartDateStr1(curWeekStart);
|
thisWeek.setEndDateStr1(curWeekEnd);
|
String tws = DateUtils.weekToDayEndStr(year, week, "yyyy-MM-dd");
|
thisWeek.setWeekInMonth(DateUtils.getWeekInMonth(tws,2));
|
thisWeek.setStartDateStr2(nextWeekStart);
|
thisWeek.setEndDateStr2(nextWeekEnd);
|
thisWeek.setYear(year);
|
thisWeek.setUsername(username);
|
|
//周里面的4种类型 0-本周总结、1-本周计划外工作、2-下周计划、3-下周需协调事务
|
List<WekTypeBean> typeList1 = new ArrayList<>();
|
for (int i = 0; i < 4; i++) {
|
WekTypeBean type = new WekTypeBean(i, thisWeek.getWeek());
|
List<WekRecord> list = new ArrayList<>();
|
type.setWekList(list);
|
configTypeName(week, type);
|
typeList1.add(type);
|
}
|
|
|
thisWeek.setTypeList(typeList1);
|
thisWeek.setShowDetail(true);
|
rootList.add(thisWeek);
|
|
return rootList;
|
}
|
|
/**
|
* 生成周标签名
|
*
|
* @param curWeek
|
* @param typeBean
|
*/
|
private void configTypeName(int curWeek, WekTypeBean typeBean) {
|
String thisWeekTypeName[] = {"本周总结", "本周计划外工作", "下周计划", "下周需协调事务"};
|
String lastWeekTypeName[] = {"上周总结", "上周计划外工作", "本周计划", "本周计划外工作"};
|
String normalWeekTypeName[] = {"工作总结", "计划外工作", "工作计划", "需协调事务"};
|
int type = typeBean.getType();
|
if (curWeek == typeBean.getWeek()) {
|
typeBean.setName(thisWeekTypeName[type]);
|
}/*else if((curWeek-1) == typeBean.getWeek() ){
|
typeBean.setName(lastWeekTypeName[type]);
|
}*/ else {
|
typeBean.setName(normalWeekTypeName[type]);
|
}
|
|
}
|
}
|
