package com.highdatas.srs.web;
|
|
|
import com.alibaba.fastjson.JSON;
|
import com.alibaba.fastjson.JSONArray;
|
import com.alibaba.fastjson.JSONObject;
|
import com.baomidou.mybatisplus.mapper.EntityWrapper;
|
import com.baomidou.mybatisplus.mapper.Wrapper;
|
import com.baomidou.mybatisplus.plugins.Page;
|
import com.fasterxml.jackson.core.JsonProcessingException;
|
import com.highdatas.srs.entity.*;
|
import com.highdatas.srs.pojo.CodeMsg;
|
import com.highdatas.srs.pojo.Result;
|
import com.highdatas.srs.service.*;
|
import com.highdatas.srs.util.DbUtils;
|
import com.highdatas.srs.util.FileUtils;
|
import org.apache.commons.lang3.StringUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.web.bind.annotation.*;
|
|
import javax.servlet.http.HttpServletRequest;
|
import java.io.UnsupportedEncodingException;
|
import java.math.BigDecimal;
|
import java.text.DecimalFormat;
|
import java.text.MessageFormat;
|
import java.text.ParseException;
|
import java.text.SimpleDateFormat;
|
import java.util.*;
|
import java.util.function.IntFunction;
|
|
/**
|
* <p>
|
* 前端控制器
|
* </p>
|
*
|
* @author kimi
|
* @since 2020-01-15
|
*/
|
@RestController
|
@RequestMapping("/scheme")
|
public class SchemeController {
|
@Autowired
|
ISchemeService schemeService;
|
@Autowired
|
ISysUserService userService;
|
@Autowired
|
ISchemeDetailService iSchemeDetailService;
|
@Autowired
|
IProjectDealService projectDealService;
|
@Autowired
|
ISysRoleMappingService roleMappingService;
|
@Autowired
|
ISysRoleService roleService;
|
@Autowired
|
ISchemeDetailParttimeService detailParttimeService;
|
@Autowired
|
ISysTargetService targetService;
|
@Value("${base.file.path}")
|
String basePath;
|
|
@RequestMapping(value = "/achieve", method = RequestMethod.GET)
|
public Result getAcheve(@RequestParam String type, HttpServletRequest request) throws ParseException {
|
EntityWrapper<Scheme> schemeEntityWrapper = new EntityWrapper<>();
|
//编辑 取消 不计入
|
schemeEntityWrapper.notIn("status", "edit");
|
List<Scheme> schemes = schemeService.selectList(schemeEntityWrapper);
|
|
List<SchemeDetail> detailList = new ArrayList<>();
|
for (Scheme scheme : schemes) {
|
String id = scheme.getId();
|
EntityWrapper<SchemeDetail> schemeDetailEntityWrapper = new EntityWrapper<>();
|
schemeDetailEntityWrapper.eq("parent_id", id);
|
List<SchemeDetail> schemeDetails = iSchemeDetailService.selectList(schemeDetailEntityWrapper);
|
detailList.addAll(schemeDetails);
|
}
|
|
if (type.equalsIgnoreCase("total")) {
|
Result result = getTotalOptions(detailList);
|
}else if (type.equalsIgnoreCase("per")) {
|
Result result = getPerOptions(detailList);
|
}else if (type.equalsIgnoreCase("after")) {
|
Result result = getAfterOptions(detailList);
|
}else if(type.equalsIgnoreCase("month")) {
|
Result result = getMonthOptions(detailList);
|
}else if(type.equalsIgnoreCase("team")) {
|
Result result = getTeamOptions(detailList);
|
}else if(type.equalsIgnoreCase("member")) {
|
Result result = getTeamOptions(detailList);
|
}
|
return Result.success(null);
|
}
|
|
private Result getTeamOptions(List<SchemeDetail> detailList) {
|
return null;
|
}
|
|
private Result getMonthOptions(List<SchemeDetail> detailList) throws ParseException {
|
Date now = new Date();
|
Calendar calendar = Calendar.getInstance();
|
calendar.setTime(now);
|
JSONObject resultData = new JSONObject();
|
List<String> months = new ArrayList<>();
|
List<String> types = new ArrayList<>();
|
types.add("指标");
|
types.add("完成");
|
types.add("达成率");
|
List<JSONObject> datas = new ArrayList<>();
|
JSONObject targetDataObject = new JSONObject();
|
targetDataObject.put("name", "指标");
|
targetDataObject.put("type", "bar");
|
datas.add(targetDataObject);
|
JSONObject amountDataObject = new JSONObject();
|
amountDataObject.put("name", "完成");
|
amountDataObject.put("type", "bar");
|
datas.add(amountDataObject);
|
JSONObject achieveDataObject = new JSONObject();
|
achieveDataObject.put("name", "达成率");
|
achieveDataObject.put("type", "line");
|
datas.add(achieveDataObject);
|
|
List<JSONObject> entityset = new ArrayList<>();
|
|
JSONObject targetEntityObject = new JSONObject();
|
targetEntityObject.put("type", "指标");
|
entityset.add(targetEntityObject);
|
JSONObject amountEntityObject = new JSONObject();
|
amountEntityObject.put("type", "完成");
|
entityset.add(amountEntityObject);
|
JSONObject achieveEntityObject = new JSONObject();
|
achieveEntityObject.put("type", "达成率");
|
entityset.add(achieveEntityObject);
|
|
for (int i = 0; i < 12; i++) {
|
|
calendar.set(calendar.get(Calendar.YEAR),calendar.get(Calendar.MONTH),1,0,0,0);
|
Date yearStart = calendar.getTime();
|
calendar.add(Calendar.MONTH, 1);
|
calendar.add(Calendar.DAY_OF_MONTH, -1);
|
Date yearEnd = calendar.getTime();
|
int year = calendar.get(Calendar.YEAR);
|
int month = calendar.get(Calendar.MONTH) + 1;
|
String oneMonth = MessageFormat.format("{0}{1}", year, month);
|
|
BigDecimal totalBudget = BigDecimal.ZERO;
|
|
for (SchemeDetail schemeDetail : detailList) {
|
BigDecimal rangeBudget = getRangeBudget(schemeDetail, yearStart, yearEnd);
|
totalBudget = totalBudget.add(rangeBudget);
|
}
|
//2 target
|
|
EntityWrapper<SysTarget> sysTargetEntityWrapper = new EntityWrapper<>();
|
sysTargetEntityWrapper.eq("amt_type", "pro")
|
.eq("year", year);
|
List<SysTarget> sysTargets = targetService.selectList(sysTargetEntityWrapper);
|
BigDecimal totalTarget = BigDecimal.ZERO;
|
|
for (SysTarget sysTarget : sysTargets) {
|
BigDecimal one = sysTarget.getTarget();
|
totalTarget = totalTarget.add(one);
|
}
|
BigDecimal achieve;
|
if(totalTarget.compareTo(BigDecimal.ZERO) == 0) {
|
achieve = BigDecimal.ZERO;
|
}else {
|
achieve = totalBudget.multiply(BigDecimal.valueOf(100)).divide(totalTarget, 1, BigDecimal.ROUND_HALF_UP);
|
}
|
ArrayList<BigDecimal> targetData = (ArrayList<BigDecimal>) targetDataObject.get("data");
|
if (targetData == null) {
|
targetData = new ArrayList<BigDecimal>();
|
}
|
targetData.add(i, totalTarget);
|
|
ArrayList<BigDecimal> amountData = (ArrayList<BigDecimal>) amountDataObject.get("data");
|
if (amountData == null) {
|
amountData = new ArrayList<BigDecimal>();
|
}
|
amountData.add(i, totalBudget);
|
|
ArrayList<BigDecimal> achieveData = (ArrayList<BigDecimal>) achieveDataObject.get("data");
|
if (achieveData == null) {
|
achieveData = new ArrayList<BigDecimal>();
|
}
|
achieveData.add(i, achieve);
|
|
targetEntityObject.put(oneMonth, totalTarget);
|
amountEntityObject.put(oneMonth, totalBudget);
|
achieveEntityObject.put(oneMonth, achieve);
|
|
months.add(oneMonth);
|
calendar.add(Calendar.MONTH , -1);
|
}
|
resultData.put("months",months);
|
resultData.put("types",types);
|
resultData.put("datas",datas);
|
resultData.put("entityset",entityset);
|
|
return Result.success(resultData);
|
}
|
|
private Result getAfterOptions(List<SchemeDetail> detailList) throws ParseException {
|
//0
|
Date now = new Date();
|
Calendar calendar = Calendar.getInstance();
|
calendar.setTime(now);
|
calendar.set(calendar.get(Calendar.YEAR),5,1,0,0,0);
|
Date yearStart = calendar.getTime();
|
calendar.add(Calendar.MONTH, 7);
|
calendar.add(Calendar.DAY_OF_MONTH, -1);
|
|
Date yearEnd = calendar.getTime();
|
|
//1 amount
|
BigDecimal totalBudget = BigDecimal.ZERO;
|
for (SchemeDetail schemeDetail : detailList) {
|
BigDecimal rangeBudget = getRangeBudget(schemeDetail, yearStart, yearEnd);
|
totalBudget = totalBudget.add(rangeBudget);
|
}
|
//2 target
|
int year = calendar.get(Calendar.YEAR);
|
EntityWrapper<SysTarget> sysTargetEntityWrapper = new EntityWrapper<>();
|
sysTargetEntityWrapper.eq("amt_type", "pro")
|
.eq("year", year).eq("tgt_type","per");
|
List<SysTarget> sysTargets = targetService.selectList(sysTargetEntityWrapper);
|
BigDecimal totalTarget = BigDecimal.ZERO;
|
|
for (SysTarget sysTarget : sysTargets) {
|
BigDecimal one = sysTarget.getTarget();
|
totalTarget = totalTarget.add(one);
|
}
|
if(totalTarget.compareTo(BigDecimal.ZERO) == 0) {
|
return Result.success(0);
|
}else {
|
BigDecimal achieve = totalBudget.multiply(BigDecimal.valueOf(100)).divide(totalTarget, 1, BigDecimal.ROUND_HALF_UP);
|
return Result.success(achieve);
|
}
|
}
|
|
private Result getPerOptions(List<SchemeDetail> detailList) throws ParseException {
|
//0
|
Date now = new Date();
|
Calendar calendar = Calendar.getInstance();
|
calendar.setTime(now);
|
calendar.set(calendar.get(Calendar.YEAR),0,1,0,0,0);
|
Date yearStart = calendar.getTime();
|
calendar.add(Calendar.MONTH, 7);
|
calendar.add(Calendar.DAY_OF_MONTH, -1);
|
|
Date yearEnd = calendar.getTime();
|
|
//1 amount
|
BigDecimal totalBudget = BigDecimal.ZERO;
|
for (SchemeDetail schemeDetail : detailList) {
|
BigDecimal rangeBudget = getRangeBudget(schemeDetail, yearStart, yearEnd);
|
totalBudget = totalBudget.add(rangeBudget);
|
}
|
//2 target
|
int year = calendar.get(Calendar.YEAR);
|
EntityWrapper<SysTarget> sysTargetEntityWrapper = new EntityWrapper<>();
|
sysTargetEntityWrapper.eq("amt_type", "pro")
|
.eq("year", year).eq("tgt_type","per");
|
List<SysTarget> sysTargets = targetService.selectList(sysTargetEntityWrapper);
|
BigDecimal totalTarget = BigDecimal.ZERO;
|
|
for (SysTarget sysTarget : sysTargets) {
|
BigDecimal one = sysTarget.getTarget();
|
totalTarget = totalTarget.add(one);
|
}
|
if(totalTarget.compareTo(BigDecimal.ZERO) == 0) {
|
return Result.success(0);
|
}else {
|
BigDecimal achieve = totalBudget.multiply(BigDecimal.valueOf(100)).divide(totalTarget, 1, BigDecimal.ROUND_HALF_UP);
|
return Result.success(achieve);
|
}
|
}
|
|
private Result getTotalOptions(List<SchemeDetail> detailList) throws ParseException {
|
//0
|
Date now = new Date();
|
Calendar calendar = Calendar.getInstance();
|
calendar.setTime(now);
|
calendar.set(calendar.get(Calendar.YEAR),0,1,0,0,0);
|
Date yearStart = calendar.getTime();
|
calendar.add(Calendar.YEAR, 1);
|
calendar.add(Calendar.DAY_OF_MONTH, -1);
|
Date yearEnd = calendar.getTime();
|
|
//1 amount
|
BigDecimal totalBudget = BigDecimal.ZERO;
|
for (SchemeDetail schemeDetail : detailList) {
|
BigDecimal rangeBudget = getRangeBudget(schemeDetail, yearStart, yearEnd);
|
totalBudget = totalBudget.add(rangeBudget);
|
}
|
//2 target
|
int year = calendar.get(Calendar.YEAR);
|
EntityWrapper<SysTarget> sysTargetEntityWrapper = new EntityWrapper<>();
|
sysTargetEntityWrapper.eq("amt_type", "pro").eq("year", year);
|
List<SysTarget> sysTargets = targetService.selectList(sysTargetEntityWrapper);
|
BigDecimal totalTarget = BigDecimal.ZERO;
|
|
for (SysTarget sysTarget : sysTargets) {
|
BigDecimal one = sysTarget.getTarget();
|
totalTarget = totalTarget.add(one);
|
}
|
if(totalTarget.compareTo(BigDecimal.ZERO) == 0) {
|
return Result.success(0);
|
}else {
|
BigDecimal achieve = totalBudget.multiply(BigDecimal.valueOf(100)).divide(totalTarget, 1, BigDecimal.ROUND_HALF_UP);
|
return Result.success(achieve);
|
}
|
}
|
|
|
|
private BigDecimal getRangeBudget(SchemeDetail schemeDetail, Date yearStart, Date yearEnd) throws ParseException {
|
BigDecimal average = BigDecimal.ZERO;
|
BigDecimal rangeBudget = BigDecimal.ZERO;
|
Integer rangeDays;
|
BigDecimal budget = schemeDetail.getBudget();
|
Boolean finish = schemeDetail.getFinish();
|
Boolean edit = schemeDetail.getEdit();
|
Boolean delay = schemeDetail.getDelay();
|
if (edit) {
|
return BigDecimal.ZERO;
|
}
|
if (finish) {
|
int dayDiffer = DbUtils.getDayDiffer(schemeDetail.getStartTime(), schemeDetail.getFinishTime());
|
dayDiffer = Math.abs(dayDiffer);
|
average = budget.divide(BigDecimal.valueOf(dayDiffer), 10, BigDecimal.ROUND_HALF_UP);
|
rangeDays = DbUtils.getRangeDays(schemeDetail.getStartTime(), schemeDetail.getFinishTime(), yearStart, yearEnd);
|
rangeDays = Math.abs(rangeDays);
|
}
|
if (delay) {
|
Date endTime = schemeDetail.getEndTime();
|
Integer dayDiffer = null;
|
Date now = new Date();
|
if (endTime.before(now)) {
|
dayDiffer = DbUtils.getDayDiffer(schemeDetail.getStartTime(), now);
|
dayDiffer = Math.abs(dayDiffer);
|
rangeDays = DbUtils.getRangeDays(schemeDetail.getStartTime(), now, yearStart, yearEnd);
|
rangeDays = Math.abs(rangeDays);
|
}else {
|
dayDiffer = DbUtils.getDayDiffer(schemeDetail.getStartTime(), schemeDetail.getEndTime());
|
dayDiffer = Math.abs(dayDiffer);
|
rangeDays = DbUtils.getRangeDays(schemeDetail.getStartTime(), schemeDetail.getEndTime(), yearStart, yearEnd);
|
|
}
|
average = budget.divide(BigDecimal.valueOf(dayDiffer), 10, BigDecimal.ROUND_HALF_UP);
|
rangeBudget = average.multiply(BigDecimal.valueOf(rangeDays));
|
}
|
|
return rangeBudget;
|
}
|
|
@RequestMapping(value = "/daywork/{id}", method = RequestMethod.GET)
|
public Result dayByUser(@PathVariable String id, HttpServletRequest request) {
|
String userId = request.getParameter("userId");
|
|
Date now = new Date();
|
Calendar instance = Calendar.getInstance();
|
instance.setTime(now);
|
instance.set(Calendar.HOUR_OF_DAY, 0 );
|
instance.set(Calendar.MINUTE, 0 );
|
instance.set(Calendar.SECOND, 0);
|
now = instance.getTime();
|
instance.add(Calendar.DAY_OF_YEAR,-1);
|
Date yesterday = instance.getTime();
|
instance.add(Calendar.DAY_OF_YEAR,2);
|
Date tomorrow = instance.getTime();
|
EntityWrapper<SchemeDetail> schemeDetailEntityWrapper = new EntityWrapper<>();
|
EntityWrapper<SchemeDetail> dealWrapper = new EntityWrapper<>();
|
schemeDetailEntityWrapper.eq("parent_id", id);
|
dealWrapper.eq("parent_id", id);
|
dealWrapper.eq("finish",true);
|
int total = iSchemeDetailService.selectCount(schemeDetailEntityWrapper);
|
int deal = iSchemeDetailService.selectCount(dealWrapper);
|
|
EntityWrapper<SchemeDetail> yesEntityWrapper = new EntityWrapper<>();
|
EntityWrapper<SchemeDetail> yesDealWrapper = new EntityWrapper<>();
|
yesEntityWrapper.eq("parent_id", id);
|
yesDealWrapper.eq("parent_id", id);
|
yesDealWrapper.eq("finish",true);
|
|
if (!StringUtils.isEmpty(userId)) {
|
schemeDetailEntityWrapper.eq("user_id", userId);
|
dealWrapper.eq("user_id", userId);
|
yesDealWrapper.eq("user_id", userId);
|
yesEntityWrapper.eq("user_id", userId);
|
}
|
|
schemeDetailEntityWrapper.le("start_time", now);
|
schemeDetailEntityWrapper.gt("end_time", now);
|
|
dealWrapper.ge("update_time",now);
|
dealWrapper.lt("update_time",tomorrow);
|
|
int nowTotal = iSchemeDetailService.selectCount(schemeDetailEntityWrapper);
|
|
yesEntityWrapper.le("start_time", yesterday);
|
yesEntityWrapper.gt("end_time", yesterday);
|
int yesTotal = iSchemeDetailService.selectCount(yesEntityWrapper);
|
|
int nowDeal = iSchemeDetailService.selectCount(dealWrapper);
|
|
yesDealWrapper.ge("update_time",yesterday);
|
yesDealWrapper.lt("update_time",now);
|
int yestDeal = iSchemeDetailService.selectCount(yesDealWrapper);
|
JSONObject object = new JSONObject();
|
object.fluentPut("total",total);
|
object.fluentPut("nowTotal",nowTotal);
|
object.fluentPut("yesTotal",yesTotal);
|
object.fluentPut("deal",deal);
|
object.fluentPut("nowDeal",nowDeal);
|
object.fluentPut("yesDeal",yestDeal);
|
|
return Result.success(object);
|
}
|
|
@RequestMapping(value = "/get/{id}", method = RequestMethod.GET)
|
public Result get(@PathVariable String id) {
|
Scheme scheme = schemeService.selectById(id);
|
String leadUserId = scheme.getLeadUserId();
|
if (!StringUtils.isEmpty(leadUserId)) {
|
String[] split = leadUserId.split(";");
|
ArrayList<List<String>> lists = new ArrayList<>();
|
for (String one : split) {
|
if (StringUtils.isEmpty(one)) {
|
continue;
|
}
|
SysRoleMapping mapping = roleMappingService.selectOne(new EntityWrapper<SysRoleMapping>().eq("user_id", one));
|
if (mapping == null) {
|
continue;
|
}
|
SysRole sysRole = roleService.selectById(mapping.getRoleId());
|
ArrayList<String> sysRoleMappings = new ArrayList<>();
|
sysRoleMappings.add(sysRole.getName());
|
sysRoleMappings.add(mapping.getUserId());
|
lists.add(sysRoleMappings);
|
}
|
scheme.setLeadUserList(lists);
|
}
|
|
return Result.success(scheme);
|
}
|
|
@RequestMapping(value = "/typesCnt", method = RequestMethod.GET)
|
public Result typesCnt() {
|
EntityWrapper<Scheme> editWrapper = new EntityWrapper<>();
|
editWrapper.eq("status", "edit");
|
int edit = schemeService.selectCount(editWrapper);
|
EntityWrapper<Scheme> workingWrapper = new EntityWrapper<>();
|
workingWrapper.eq("status", "working");
|
int working = schemeService.selectCount(workingWrapper);
|
EntityWrapper<Scheme> finishWrapper = new EntityWrapper<>();
|
finishWrapper.eq("status", "finish");
|
int finish = schemeService.selectCount(finishWrapper);
|
|
EntityWrapper<Scheme> delayWrapper = new EntityWrapper<>();
|
delayWrapper.eq("status", "delay");
|
int delay = schemeService.selectCount(delayWrapper);
|
|
int total = schemeService.selectCount(null);
|
|
|
ArrayList<Integer> result = new ArrayList<>();
|
result.add(edit);
|
result.add(working);
|
result.add(delay);
|
result.add(finish);
|
|
JSONObject object = new JSONObject();
|
object.fluentPut("total", total);
|
object.fluentPut("typeCnt", result);
|
return Result.success(object);
|
}
|
|
@RequestMapping(value = "/getSchemeInfo/{id}", method = RequestMethod.GET)
|
public Result getSchemeInfo(@PathVariable String id) throws UnsupportedEncodingException, ParseException {
|
Scheme scheme = schemeService.selectById(id);
|
List<SchemeDetail> schemeDetailList = iSchemeDetailService.selectList(new EntityWrapper<SchemeDetail>().eq("parent_id", id));
|
HashMap<String, SysUser> userSet = new HashMap<>();
|
for (SchemeDetail detail : schemeDetailList) {
|
String userId = detail.getUserId();
|
SysUser sysUser = userService.selectById(userId);
|
if (sysUser == null || userSet.containsKey(sysUser.getId())) {
|
continue;
|
}
|
|
userSet.put(sysUser.getId(), sysUser);
|
}
|
List<ProjectDeal> dealList = projectDealService.selectList(new EntityWrapper<ProjectDeal>().eq("scheme_id", id));
|
String rootPath = basePath + "/" + scheme.getName();
|
ArrayList<JSONObject> childrenFiles = FileUtils.getChildrenFiles(rootPath);
|
|
Date startTime = scheme.getStartTime();
|
Date endTime = scheme.getEndTime();
|
Calendar start = Calendar.getInstance();
|
start.setTime(startTime);
|
|
JSONObject result = new JSONObject();
|
JSONObject option = new JSONObject();
|
// 详情
|
JSONArray array = new JSONArray();
|
long totalCnt = 0;
|
long usedCnt = 0;
|
HashMap<String, Double> detailDayBudgetMap = new HashMap<>();
|
for (SchemeDetail detail : schemeDetailList) {
|
Boolean finish = detail.getFinish();
|
int dayDiffer = DbUtils.getDayDiffer(detail.getStartTime(), detail.getEndTime());
|
BigDecimal budget = detail.getBudget();
|
totalCnt += budget.doubleValue();
|
BigDecimal oneDayBudget = budget.divide(new BigDecimal(dayDiffer).abs(), 2, BigDecimal.ROUND_HALF_UP);
|
detailDayBudgetMap.put(detail.getId(), oneDayBudget.doubleValue());
|
int days = 0;
|
|
if (finish) {
|
days = DbUtils.getDayDiffer(detail.getStartTime(), detail.getFinishTime());
|
} else if (!detail.getEdit()){
|
days = DbUtils.getDayDiffer(detail.getStartTime(), new Date());
|
}
|
double used = 0.0;
|
if (days > 0) {
|
used = oneDayBudget.multiply(new BigDecimal(days)).doubleValue();
|
usedCnt += used;
|
}
|
|
JSONObject o = (JSONObject) JSON.toJSON(detail);
|
SchemeDetailType type = detail.getType();
|
o.fluentPut("name", type.covert());
|
o.fluentPut("usedCnt", used);
|
o.fluentPut("totalCnt", budget.doubleValue());
|
|
array.add(o);
|
}
|
result.fluentPut("scheme", array);
|
result.fluentPut("totalCnt", totalCnt);
|
result.fluentPut("usedCnt", usedCnt);
|
|
List<String> time = new ArrayList<>();
|
List<Double> totalList = new ArrayList<>();
|
List<Double> todoList = new ArrayList<>();
|
SimpleDateFormat dateFormat = new SimpleDateFormat("MM-dd");
|
Double preTotal = 0.0;
|
Double preTodo = 0.0;
|
DecimalFormat df =new java.text.DecimalFormat("#.00");
|
while (startTime.before(endTime)) {
|
startTime = start.getTime();
|
time.add(dateFormat.format(startTime));
|
EntityWrapper<SchemeDetail> schemeDetailEntityWrapper = new EntityWrapper<>();
|
schemeDetailEntityWrapper.le("start_time", startTime);
|
schemeDetailEntityWrapper.eq("parent_id", scheme.getId());
|
schemeDetailEntityWrapper.gt("end_time", startTime);
|
|
schemeDetailEntityWrapper.eq("edit", false);
|
List<SchemeDetail> schemeDetailList1 = iSchemeDetailService.selectList(schemeDetailEntityWrapper);
|
double onedayBudget = 0;
|
for (SchemeDetail detail : schemeDetailList1) {
|
String id1 = detail.getId();
|
Double oneBudget = detailDayBudgetMap.get(id1);
|
onedayBudget +=oneBudget;
|
}
|
|
Double expantCnt = totalCnt - (preTotal + onedayBudget);
|
expantCnt = new BigDecimal(expantCnt).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
|
|
totalList.add(expantCnt > 0 ? expantCnt : 0);
|
preTotal = preTotal + onedayBudget;
|
|
int dayDiffer = DbUtils.getDayDiffer(startTime, new Date());
|
if (dayDiffer >= 0) {
|
EntityWrapper<SchemeDetail> entityWrapper1 = new EntityWrapper<>();
|
entityWrapper1.le("start_time", startTime);
|
entityWrapper1.gt("finish_time",startTime);
|
entityWrapper1.eq("parent_id", scheme.getId());
|
entityWrapper1.eq("edit", false);
|
List<SchemeDetail> schemeDetailList3 = iSchemeDetailService.selectList(entityWrapper1);
|
|
double todo = 0.0;
|
for (SchemeDetail detail : schemeDetailList3) {
|
String id1 = detail.getId();
|
Double oneBudget = detailDayBudgetMap.get(id1);
|
todo +=oneBudget;
|
}
|
EntityWrapper<SchemeDetail> entityWrapper = new EntityWrapper<>();
|
entityWrapper.le("start_time", startTime);
|
entityWrapper.eq("finish", false);
|
entityWrapper.isNull("finish_time");
|
entityWrapper.eq("parent_id", scheme.getId());
|
entityWrapper.eq("edit", false);
|
List<SchemeDetail> schemeDetailList2 = iSchemeDetailService.selectList(entityWrapper);
|
|
for (SchemeDetail detail : schemeDetailList2) {
|
String id1 = detail.getId();
|
Double oneBudget = detailDayBudgetMap.get(id1);
|
todo +=oneBudget;
|
}
|
double todoCnt = totalCnt - (preTodo + todo);
|
todoCnt = new BigDecimal(todoCnt).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
|
|
todoList.add(todoCnt);
|
preTodo = preTodo + todo;
|
}
|
|
start.add(Calendar.DAY_OF_YEAR, 1);
|
}
|
|
|
option.fluentPut("xAxis", time);
|
option.fluentPut("yAxis1", todoList);
|
option.fluentPut("yAxis2", totalList);
|
|
// 图
|
result.fluentPut("option", option);
|
// 记录
|
result.fluentPut("record", dealList);
|
// 人员
|
result.fluentPut("users", userSet.values());
|
|
|
//目录
|
result.fluentPut("paths",childrenFiles);
|
return Result.success(result);
|
}
|
|
|
|
@RequestMapping(value = "/working/{id}", method = RequestMethod.GET)
|
public Result working(@PathVariable String id) {
|
Scheme scheme = schemeService.selectById(id);
|
List<SchemeDetail> schemeDetailList = iSchemeDetailService.selectList(new EntityWrapper<SchemeDetail>().eq("parent_id", id));
|
for (SchemeDetail detail : schemeDetailList) {
|
detail.setEdit(false);
|
detail.updateById();
|
}
|
if (scheme.getStatus().equalsIgnoreCase("edit")) {
|
scheme.setStatus("working");
|
}
|
|
boolean b = scheme.updateById();
|
if (b) {
|
return Result.success(CodeMsg.UPDATE_SUCCESS);
|
} else {
|
return Result.error(CodeMsg.UPDATE_ERROR);
|
}
|
|
}
|
@RequestMapping(value = "/all", method = RequestMethod.GET)
|
public Result all() {
|
List<Scheme> schemes = schemeService.selectList(null);
|
return Result.success(schemes);
|
}
|
|
@RequestMapping(value = "/save/{id}", method = RequestMethod.GET)
|
public Result save(@PathVariable String id, @RequestParam BigDecimal budget) {
|
Scheme scheme = schemeService.selectById(id);
|
if (scheme == null) {
|
return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
|
}
|
scheme.setBudget(budget).updateById();
|
return Result.success(scheme);
|
}
|
|
@RequestMapping(value = "/page/{pageNo}", method = RequestMethod.GET)
|
public Result get(@PathVariable Integer pageNo, HttpServletRequest request) {
|
String pageSize = request.getParameter("pageSize");
|
String name = request.getParameter("name");
|
String status = request.getParameter("status");
|
String type = request.getParameter("type");
|
String userId = request.getParameter("userId");
|
String isRun = request.getParameter("isRun");
|
String orderBy = request.getParameter("orderBy");
|
|
EntityWrapper<Scheme> schemeEntityWrapper = new EntityWrapper<>();
|
|
if (!StringUtils.isEmpty(name)) {
|
schemeEntityWrapper.like("name", name);
|
}
|
if (!StringUtils.isEmpty(orderBy)) {
|
schemeEntityWrapper.orderBy(orderBy);
|
}
|
if (!StringUtils.isEmpty(userId)) {
|
schemeEntityWrapper.eq("user_id", userId);
|
}
|
if (!StringUtils.isEmpty(type)) {
|
schemeEntityWrapper.like("type", type);
|
}
|
if (!StringUtils.isEmpty(status)) {
|
schemeEntityWrapper.eq("status", status);
|
}
|
if (!StringUtils.isEmpty(isRun) && Boolean.valueOf(isRun)) {
|
schemeEntityWrapper.ne("status", "edit");
|
}
|
|
Page<Scheme> schemePage;
|
|
if (StringUtils.isEmpty(pageSize)) {
|
schemePage = new Page<>(pageNo, 15);
|
}
|
else {
|
schemePage = new Page<>(pageNo, Integer.valueOf(pageSize));
|
}
|
|
Page<Scheme> page = schemeService.selectPage(schemePage, schemeEntityWrapper);
|
List<Scheme> schemes = schemeService.selectList(schemeEntityWrapper);
|
JSONObject resultObj = new JSONObject();
|
BigDecimal decimal = new BigDecimal(0);
|
BigDecimal moneydecimal = new BigDecimal(0);
|
for (Scheme scheme : schemes) {
|
if (scheme.getBudget() != null) {
|
decimal = decimal.add(scheme.getBudget());
|
}
|
if (scheme.getPayMoney() != null) {
|
moneydecimal = moneydecimal.add(scheme.getPayMoney());
|
}
|
}
|
resultObj.fluentPut("budget", decimal);
|
resultObj.fluentPut("payMoney", moneydecimal);
|
List<Scheme> records = page.getRecords();
|
Page<JSONObject> jsonObjectPage = new Page<>();
|
jsonObjectPage.setTotal(page.getTotal());
|
jsonObjectPage.setCurrent(page.getCurrent());
|
jsonObjectPage.setSize(page.getSize());
|
List<JSONObject> result = new ArrayList<>();
|
|
for (Scheme scheme : records) {
|
JSONObject json = (JSONObject) JSON.toJSON(scheme);
|
Wrapper<SchemeDetail> delayWrapper = new EntityWrapper<SchemeDetail>().eq("parent_id", scheme.getId());
|
Wrapper<SchemeDetail> finishWrapper = new EntityWrapper<SchemeDetail>().eq("parent_id", scheme.getId());
|
List<SchemeDetail> detailList = iSchemeDetailService.selectList(delayWrapper);
|
BigDecimal totalBudget = new BigDecimal(0);
|
for (SchemeDetail detail : detailList) {
|
BigDecimal budget = detail.getBudget();
|
totalBudget = totalBudget.add(budget);
|
}
|
int total =detailList.size();
|
int delayInt = iSchemeDetailService.selectCount(delayWrapper.eq("delay", true));
|
|
int finishInt = iSchemeDetailService.selectCount(finishWrapper.eq("finish", true));
|
json.fluentPut("totalCnt", total);
|
json.fluentPut("delayCnt", delayInt);
|
json.fluentPut("finishCnt", finishInt);
|
json.fluentPut("totalBudget", totalBudget);
|
|
//
|
List<SchemeDetail> schemeDetailList = iSchemeDetailService.selectList(new EntityWrapper<SchemeDetail>().eq("parent_id", scheme.getId()).eq("finish", true));
|
Date beginDate = null;
|
Date endDate = null;
|
for (SchemeDetail detail : schemeDetailList) {
|
if (beginDate == null) {
|
beginDate = detail.getStartTime();
|
}
|
else {
|
int i = DbUtils.compareDate(beginDate, detail.getStartTime());
|
if(i == -1) {
|
beginDate = detail.getStartTime();
|
}
|
}
|
|
if (endDate == null) {
|
endDate = detail.getFinishTime();
|
}else {
|
if (detail.getFinish() && detail.getFinishTime() != null) {
|
|
int i = DbUtils.compareDate(endDate, detail.getFinishTime());
|
if(i == 1) {
|
endDate = detail.getFinishTime();
|
}
|
}
|
|
}
|
}
|
json.fluentPut("beginDate", beginDate);
|
json.fluentPut("endDate", endDate);
|
result.add(json);
|
}
|
jsonObjectPage.setRecords(result);
|
resultObj.fluentPut("datas", jsonObjectPage);
|
return Result.success(resultObj);
|
}
|
@RequestMapping(value = "/checkCode/{code}", method = RequestMethod.GET)
|
public Result add(@RequestParam String code) {
|
int cnt = schemeService.selectCount(new EntityWrapper<Scheme>().eq("code", code));
|
if (cnt == 0) {
|
return Result.success(true);
|
}
|
return Result.success(false);
|
}
|
|
@RequestMapping(value = "/addOrUpdate", method = RequestMethod.POST)
|
public Result add( @RequestBody Scheme scheme) {
|
|
String code = scheme.getCode();
|
Wrapper<Scheme> codeWrapper = new EntityWrapper<Scheme>().eq("code", code);
|
if (!StringUtils.isEmpty(scheme.getId())) {
|
codeWrapper.ne("id", scheme.getId());
|
}
|
int i = schemeService.selectCount(codeWrapper);
|
if (i > 0) {
|
return Result.error(CodeMsg.EXISTSCODE_ERROR);
|
}
|
|
if (StringUtils.isEmpty(scheme.getId())) {
|
scheme.setId(DbUtils.getUUID()).setCreateTime(new Date());
|
}
|
|
Date startTime = scheme.getStartTime();
|
Date endTime = scheme.getEndTime();
|
|
List<SchemeDetail> schemeDetailList = iSchemeDetailService.selectList(new EntityWrapper<SchemeDetail>().eq("parent_id", scheme.getId()));
|
for (SchemeDetail detail : schemeDetailList) {
|
Date detailStartTime = detail.getStartTime();
|
if (detailStartTime != null) {
|
boolean effectiveDate = DbUtils.isEffectiveDate(detailStartTime, startTime, endTime);
|
if(!effectiveDate) {
|
detail.setStartTime(startTime);
|
}
|
}
|
Date detailEndTime = detail.getEndTime();
|
if (detailEndTime != null) {
|
boolean effectiveDate = DbUtils.isEffectiveDate(detailEndTime, startTime, endTime);
|
if(!effectiveDate) {
|
detail.setEndTime(endTime);
|
}
|
}
|
|
|
boolean updated = detail.updateById();
|
|
}
|
boolean insert = scheme.insertOrUpdate();
|
if (insert) {
|
return Result.success(scheme.getId());
|
} else {
|
return Result.error(CodeMsg.INSERT_ERROR);
|
}
|
}
|
|
@RequestMapping(value = "/update/{id}", method = RequestMethod.GET)
|
public Result add(@PathVariable String id, HttpServletRequest request) throws JsonProcessingException {
|
String data = request.getParameter("data");
|
Scheme scheme = DbUtils.json2Bean(data, Scheme.class);
|
Date startTime = scheme.getStartTime();
|
Date endTime = scheme.getEndTime();
|
|
List<SchemeDetail> schemeDetailList = iSchemeDetailService.selectList(new EntityWrapper<SchemeDetail>().eq("parent_id", scheme.getId()));
|
for (SchemeDetail detail : schemeDetailList) {
|
Date detailStartTime = detail.getStartTime();
|
if (detailStartTime != null) {
|
boolean effectiveDate = DbUtils.isEffectiveDate(detailStartTime, startTime, endTime);
|
if(!effectiveDate) {
|
detail.setStartTime(startTime);
|
}
|
}
|
Date detailEndTime = detail.getEndTime();
|
if (detailEndTime != null) {
|
boolean effectiveDate = DbUtils.isEffectiveDate(detailEndTime, startTime, endTime);
|
if(!effectiveDate) {
|
detail.setEndTime(endTime);
|
}
|
}
|
detail.updateById();
|
}
|
boolean b = scheme.updateById();
|
// reseachType to enum
|
|
if (b) {
|
return Result.success(CodeMsg.UPDATE_SUCCESS);
|
} else {
|
return Result.error(CodeMsg.UPDATE_ERROR);
|
}
|
}
|
|
@RequestMapping(value = "/del/{id}", method = RequestMethod.GET)
|
public Result del(@PathVariable String id, HttpServletRequest request) throws JsonProcessingException {
|
Scheme scheme = schemeService.selectById(id);
|
List<SchemeDetail> schemeDetailList = iSchemeDetailService.selectList(new EntityWrapper<SchemeDetail>().eq("parent_id", scheme.getId()));
|
for (SchemeDetail detail : schemeDetailList) {
|
detailParttimeService.delete(new EntityWrapper<SchemeDetailParttime>().eq("parent_id", detail.getId()));
|
detail.deleteById();
|
}
|
|
boolean delete = scheme.deleteById();
|
|
if (delete) {
|
return Result.success(CodeMsg.DELETE_SUCCESS);
|
} else {
|
return Result.error(CodeMsg.DELETE_ERROR);
|
}
|
}
|
}
|
