package doumeemes.service.business.impl;
|
|
import com.alibaba.fastjson.JSONObject;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.dingtalk.api.response.OapiProcessinstanceGetResponse;
|
import com.github.pagehelper.PageHelper;
|
import com.github.pagehelper.PageInfo;
|
import doumeemes.core.constants.ResponseStatus;
|
import doumeemes.core.exception.BusinessException;
|
import doumeemes.core.model.LoginUserInfo;
|
import doumeemes.core.model.PageData;
|
import doumeemes.core.model.PageWrap;
|
import doumeemes.core.utils.Constants;
|
import doumeemes.core.utils.DateUtil;
|
import doumeemes.core.utils.Utils;
|
import doumeemes.core.utils.dingding.DingDingUtil;
|
import doumeemes.core.utils.redis.RedisUtil;
|
import doumeemes.dao.business.BackOrderDetailMapper;
|
import doumeemes.dao.business.BackorderMapper;
|
import doumeemes.dao.business.dto.MaterialListDTO;
|
import doumeemes.dao.business.model.*;
|
import doumeemes.dao.business.vo.DdInstanceStatusVO;
|
import doumeemes.dao.ext.*;
|
import doumeemes.dao.ext.dto.QueryAppliancesExtDTO;
|
import doumeemes.dao.ext.dto.QueryWorkorderRecordExtDTO;
|
import doumeemes.dao.ext.vo.*;
|
import doumeemes.service.business.BackorderService;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import doumeemes.service.business.CompanyService;
|
import doumeemes.service.business.WTransferService;
|
import doumeemes.service.ext.CompanyExtService;
|
import doumeemes.service.ext.DepartmentExtService;
|
import doumeemes.service.ext.PlansExtService;
|
import org.apache.commons.lang3.StringUtils;
|
import org.apache.shiro.SecurityUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.data.redis.core.RedisTemplate;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.CollectionUtils;
|
|
import java.math.BigDecimal;
|
import java.util.ArrayList;
|
import java.util.Date;
|
import java.util.List;
|
|
/**
|
* 工单类-返修申请单信息表Service实现
|
* @author 江蹄蹄
|
* @date 2022/07/19 14:29
|
*/
|
@Service
|
public class BackorderServiceImpl implements BackorderService {
|
@Autowired
|
private RedisTemplate<String, Object> redisTemplate;
|
@Autowired
|
private BackorderMapper backorderMapper;
|
@Autowired
|
private CompanyExtService companyExtService;
|
@Autowired
|
private WTransferService wTransferService;
|
|
@Autowired
|
private AppliancesExtMapper appliancesExtMapper;
|
@Autowired
|
private BackOrderDetailMapper backOrderDetailMapper;
|
@Autowired
|
private ProceduresExtMapper proceduresExtMapper;
|
@Autowired
|
private WarehouseExtMapper warehouseExtMapper;
|
|
@Autowired
|
private CompanyUserExtMapper companyUserExtMapper;
|
@Autowired
|
private PlansExtService plansExtService;
|
@Autowired
|
private DepartmentExtService departmentExtService;
|
@Autowired
|
private DepartmentExtMapper departmentExtMapper;
|
|
@Override
|
@Transactional(rollbackFor = {BusinessException.class,Exception.class})
|
public Integer create(Backorder backorder) {
|
LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
|
if(!Constants.equalsInteger(user.getType(),Constants.USERTYPE.COM)){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(), "对不起，您无权限进行该操作！");
|
}
|
if( StringUtils.isBlank(backorder.getContent())
|
|| backorder.getType()== null
|
|| backorder.getApplianceIdList()== null
|
|| backorder.getApplianceIdList().size()==0){
|
throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "对不起，请按要求填写和选择提交数据！");
|
}
|
|
Procedures procedures = null;
|
if(!Constants.equalsInteger(backorder.getType(),Constants.BACKORDER_TYPE.scrap)){
|
if(backorder.getBackProcedureId()== null
|
|| backorder.getPlanDate()== null) {
|
throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "对不起，请按要求填写和选择提交数据！");
|
}
|
Date pDate = DateUtil.getDateFromString(DateUtil.getShortTime(backorder.getPlanDate()) +" 00:00:00");
|
Date nDate = DateUtil.getDateFromString(DateUtil.getShortTime(DateUtil.getCurrentDate()) +" 00:00:00");
|
if(DateUtil.dateAddDays(nDate,1).getTime() > pDate.getTime()){
|
throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "对不起，计划生产日期必须为今天以后的日期！");
|
}
|
procedures = new Procedures();
|
procedures.setDeleted(Constants.ZERO);
|
procedures.setRootDepartId(user.getRootDepartment().getId());
|
procedures.setId(backorder.getBackProcedureId());
|
procedures = proceduresExtMapper.selectOne(new QueryWrapper<>(procedures).last(" limit 1"));
|
if(procedures == null){
|
throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "对不起，请选择正确的返工工序！");
|
}
|
backorder.setBackProcedureName(procedures.getName());
|
}else{
|
if(backorder.getWarehouseId() == null){
|
//入库仓库编码
|
throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "对不起，请按要求填写和选择提交数据！");
|
}
|
Warehouse w = new Warehouse();
|
w.setRootDepartId(user.getRootDepartment().getId());
|
w.setDeleted(Constants.ZERO);
|
w.setId(backorder.getWarehouseId());
|
w = warehouseExtMapper.selectOne(new QueryWrapper<>(w).last(" limit 1"));
|
if(w == null){
|
throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "对不起，入库仓库不存在！");
|
}
|
backorder.setWarehouseName(w.getName());
|
}
|
|
Backorder order = new Backorder();
|
order.setDeleted(Constants.ZERO);
|
order.setStatus(Constants.BACKORDER_STATUS.ing);
|
String ids = "";
|
for(Integer tid : backorder.getApplianceIdList()){
|
if(StringUtils.isNotBlank(ids)){
|
ids+=",";
|
}
|
ids +=tid;
|
}
|
int count = backorderMapper.selectCount(new LambdaQueryWrapper<>(order).exists(" select b.id from back_order_detail b where b.backorder_id=backorder.id and b.deleted=0 and b.appliance_id in ("+ids+")"));
|
if(count>0){
|
throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "对不起，选择的工装有正在申请单，不可以再次申请！");
|
}
|
//根据请求数据，查询全部器具信息
|
List<AppliancesExtListVO> aList = appliancesExtMapper.selectList(initApplianceParam(user,backorder.getApplianceIdList()));
|
if(aList == null || aList.size() ==0){
|
throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "对不起，请选择正确的工装器具！");
|
}
|
|
AppliancesExtListVO taModel = aList.get(0);
|
//累计总物料数量
|
BigDecimal num = new BigDecimal(0);
|
backorder.setDetailList(new ArrayList<>());
|
//不同篮筐的物料、生产工序、质量属性、仓库、批次必须相同
|
for(AppliancesExtListVO a : aList){
|
if(!Constants.equalsInteger(backorder.getType(),Constants.BACKORDER_TYPE.scrap)
|
&&(!Constants.equalsInteger(a.getMaterialId(),taModel.getMaterialId())
|
|| !Constants.equalsInteger(a.getProcedureId(),taModel.getProcedureId())
|
|| !StringUtils.equals(a.getBatch(),taModel.getBatch())
|
|| !Constants.equalsInteger(a.getQualityType(),taModel.getQualityType())
|
|| !Constants.equalsInteger(a.getWarehouseId(),taModel.getWarehouseId()) )){
|
throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "对不起，工装的物料、生产工序、质量属性、仓库必须相同！");
|
}
|
if(a.getBackorderId() !=null){
|
throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "对不起，选择的工装【"+a.getCode()+"】有正绑定返修申请单，不可以再次申请！");
|
}
|
if(a.getPmodel() == null){
|
throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "对不起，工装【"+a.getCode()+"】所属工序为空！");
|
}
|
if(a.getPmodel().getOrgId() == null){
|
throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "对不起，工装【"+a.getCode()+"】生产工序未绑定工厂，不能进行返工申请！");
|
}
|
if(a.getWarehouseId() == null){
|
throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "对不起，工装【"+a.getCode()+"】不在仓库内，不能进行返工申请！");
|
}
|
if(a.getBackorderId()!=null){
|
//篮筐有返工返修申请单号
|
throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "对不起，工装【"+a.getCode()+"】已关联返工返修申请单，不能再申请！");
|
}
|
num = num.add(Constants.formatBigdecimal(a.getNum()));
|
BackOrderDetail detail = new BackOrderDetail();
|
detail.setDeleted(Constants.ZERO);
|
detail.setCreateUser(backorder.getCreateUser());
|
detail.setRootDepartId(backorder.getRootDepartId());
|
detail.setOrderDepartId(backorder.getOrderDepartId());
|
detail.setCreateTime(backorder.getCreateTime());
|
detail.setBackorderId(backorder.getId());
|
detail.setApplianceId(a.getId());
|
detail.setNum(a.getNum());
|
detail.setApplianceCode(a.getCode());
|
detail.setBatch(StringUtils.defaultString(a.getBatch(),""));
|
detail.setProcedureName(a.getPmodel()==null?"":a.getPmodel().getName());
|
detail.setMaterialId(a.getMaterialId());
|
detail.setUnitName(a.getUmodelName());
|
detail.setUnitData(a.getUmodelData());
|
detail.setMaterialCode(a.getMaterialCode());
|
detail.setMaterialName(a.getMaterialName());
|
detail.setProcedureId(a.getProcedureId());
|
backorder.getDetailList().add(detail);
|
}
|
if(!Constants.equalsInteger(backorder.getType(),Constants.BACKORDER_TYPE.scrap)){
|
//批次号
|
backorder.setBatch(taModel.getBatch());
|
}
|
//根据第一个篮筐的生产工序查询对应的工厂信息展示
|
backorder.setProcedureId(taModel.getProcedureId());
|
DepartmentExtListVO org = departmentExtService.getModelById(user.getCompany().getId(),taModel.getPmodel().getOrgId());
|
backorder.setOrgName(org==null?null:org.getName());
|
if(!Constants.equalsInteger(backorder.getType(),Constants.BACKORDER_TYPE.scrap)){
|
backorder.setMaterialId(taModel.getMaterialId());
|
backorder.setUnitId(taModel.getMdmodel()!=null?taModel.getMdmodel().getUnitId():null);
|
}
|
backorder.setFactoryId( taModel.getPmodel().getOrgId());
|
backorder.setDeleted(Constants.ZERO);
|
backorder.setCreateUser(user.getId());
|
backorder.setCreateTime(DateUtil.getCurrentDate());
|
backorder.setRootDepartId(user.getRootDepartment().getId());
|
backorder.setOrderDepartId(user.getCurComDepartment().getId());
|
backorder.setTitle(user.getCompanyUser().getName()+"提交的"+Constants.BACKORDER_TYPE.getTitleByType(backorder.getType()));
|
backorder.setWarehouseOutId(taModel.getWarehouseId());
|
backorder.setCode(getNextCode(user.getCompany().getId()));
|
backorder.setWarehouseOutName(taModel.getWhmodel()==null?"":taModel.getWhmodel().getName());
|
backorder.setStatus(Constants.BACKORDER_STATUS.ing);
|
backorder.setCreateUserName(user.getCompanyUser().getName() +" / " +user.getDepartment().getName());
|
backorder.setNum(num);
|
String info ="";
|
if(Constants.equalsInteger(backorder.getType(),Constants.BACKORDER_TYPE.scrap)){
|
//如果是报废申请
|
info = backorder.getCreateUserName()+"，提交"
|
+Constants.BACKORDER_TYPE.getTitleByType(backorder.getType())
|
+"，入库仓库为"+backorder.getWarehouseName();
|
}else if(Constants.equalsInteger(backorder.getType(),Constants.BACKORDER_TYPE.customer_back)){
|
//如果是可返单
|
info = backorder.getCreateUserName()+"，提交"
|
+Constants.BACKORDER_TYPE.getTitleByType(backorder.getType())
|
+"，返修客户："+backorder.getCustomerName()
|
+"，返修工序为"+backorder.getBackProcedureName();;
|
}else{
|
info = backorder.getCreateUserName()+"，提交"
|
+Constants.BACKORDER_TYPE.getTitleByType(backorder.getType())
|
+"，返修工序为"+backorder.getBackProcedureName();
|
}
|
backorder.setRemark(info);
|
//不良工序、返修工序负责人相同，则跳过审批直接自动创建返修工序的“返工返修”类型计划
|
boolean isSelf = procedures==null?false:Constants.equalsInteger(procedures.getUserId(),taModel.getPmodel().getUserId());
|
Integer orderId = null;
|
//报废必须走审批
|
if(!isSelf || Constants.equalsInteger(Constants.BACKORDER_TYPE.scrap,backorder.getType()) ){
|
if(StringUtils.isBlank(user.getCompanyUser().getDdUserid())) {
|
throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "对不起，您不具备发起钉钉审批的条件，如有疑问请联系管理员！");
|
}
|
try {
|
String ddinfo = user.getCompany().getDingdingInfo();
|
JSONObject json = JSONObject.parseObject(ddinfo);
|
String processCode = json.getString("instance_tmp_"+backorder.getType()+"_"+backorder.getFactoryId());
|
String instanceid = DingDingUtil.startProcessInstance(companyExtService.getDingdingToken(user.getCompany().getId()),user.getCompanyUser().getDdUserid() , processCode, backorder);
|
if(StringUtils.isBlank(instanceid)){
|
throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "对不起，发起钉钉审批失败，请稍后重试！");
|
}
|
backorder.setInstanceId(instanceid);
|
} catch (Exception e) {
|
throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "对不起，发起钉钉审批失败，请稍后重试！");
|
}
|
//插入数据
|
backorderMapper.insert(backorder);
|
}else{
|
//审批通过agree
|
backorder.setStatus(Constants.BACKORDER_STATUS.yes);
|
//插入数据
|
orderId = backorderMapper.insert(backorder);
|
//生成生产计划
|
Plans p = new Plans();
|
p.setMaterialId(backorder.getMaterialId());
|
p.setDeleted(Constants.ZERO);
|
p.setCreateUser(backorder.getCreateUser());
|
p.setUserId(backorder.getCreateUser());
|
p.setCreateTime(DateUtil.getCurrentDate());
|
p.setBatch(backorder.getBatch());
|
// p.setBatch(plansExtService.getNextBatch(backorder.getCompanyId()));
|
p.setStatus(Constants.PLAN_STATUS.create);
|
p.setRootDepartId(backorder.getRootDepartId());
|
p.setDepartId(backorder.getOrderDepartId());
|
p.setUnitId(backorder.getUnitId());
|
p.setType(Constants.PLAN_TYPE.back);
|
p.setBackorderId(backorder.getId());
|
p.setPlanDate(backorder.getPlanDate());
|
p.setNum(Constants.formatBigdecimal(backorder.getNum()).intValue());
|
p.setProcedureId(backorder.getBackProcedureId());
|
p.setFactoryId(backorder.getFactoryId());
|
plansExtService.createDirect(p);
|
}
|
|
//遍历更新篮筐数据，并插入明细记录
|
for(AppliancesExtListVO a : aList){
|
Appliances aModel = new Appliances();
|
aModel.setId(a.getId());
|
aModel.setUpdateUser(user.getId());
|
// aModel.setWorkorderId(backorder.getId());
|
if(Constants.equalsInteger(backorder.getStatus(),Constants.BACKORDER_STATUS.yes)){
|
aModel.setBackProcedureId(backorder.getBackProcedureId());
|
}
|
aModel.setUpdateTime(backorder.getCreateTime());
|
aModel.setSaleorderId(backorder.getSaleorderId());
|
aModel.setBackorderId(Constants.formatIntegerNum(orderId) >0?backorder.getId():null);
|
aModel.setWarehouseId(a.getWarehouseId());
|
aModel.setLocationId(a.getLocationId());
|
appliancesExtMapper.updateById(aModel);
|
}
|
for(BackOrderDetail detail : backorder.getDetailList()){
|
detail.setBackorderId(backorder.getId());
|
backOrderDetailMapper.insert(detail);
|
}
|
|
return backorder.getId();
|
}
|
|
private QueryAppliancesExtDTO initApplianceParam(LoginUserInfo user,List<Integer> idList ) {
|
List<MaterialListDTO> apList = new ArrayList<>();
|
for(Integer id : idList){
|
MaterialListDTO t = new MaterialListDTO();
|
t.setApplianceId(id);
|
apList.add(t);
|
}
|
QueryAppliancesExtDTO appliancesExtDTO = new QueryAppliancesExtDTO();
|
appliancesExtDTO.setDeleted(Constants.ZERO);
|
appliancesExtDTO.setRootDepartId(user.getRootDepartment().getId());
|
appliancesExtDTO.setDepartId(user.getComDepartment().getId());
|
appliancesExtDTO.setRecordList(apList);
|
return appliancesExtDTO;
|
|
}
|
@Override
|
public void deleteById(Integer id) {
|
backorderMapper.deleteById(id);
|
}
|
|
@Override
|
public void delete(Backorder backorder) {
|
UpdateWrapper<Backorder> deleteWrapper = new UpdateWrapper<>(backorder);
|
backorderMapper.delete(deleteWrapper);
|
}
|
|
@Override
|
public void deleteByIdInBatch(List<Integer> ids) {
|
if (CollectionUtils.isEmpty(ids)) {
|
return;
|
}
|
backorderMapper.deleteBatchIds(ids);
|
}
|
|
@Override
|
public void updateById(Backorder backorder) {
|
backorderMapper.updateById(backorder);
|
}
|
|
@Override
|
public void updateByIdInBatch(List<Backorder> backorders) {
|
if (CollectionUtils.isEmpty(backorders)) {
|
return;
|
}
|
for (Backorder backorder: backorders) {
|
this.updateById(backorder);
|
}
|
}
|
|
@Override
|
public Backorder findById(Integer id) {
|
LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
|
if(!Constants.equalsInteger(user.getType(),Constants.USERTYPE.COM)){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(), "对不起，您无权限进行该操作！");
|
}
|
Backorder model = new Backorder();
|
model.setId(id);
|
model.setDeleted(Constants.ZERO);
|
model.setRootDepartId(user.getRootDepartment().getId());
|
model = backorderMapper.selectByModel(model);
|
|
if(model == null){
|
throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(), "对不起，该数据不存在！");
|
}
|
List<DepartmentExtListVO> allDepartList = RedisUtil.getObject(redisTemplate,Constants.RedisKeys.COM_DEPART_LIST_KEY+user.getCompany().getId(),ArrayList.class);
|
//用户信息
|
initProUser(user,model,allDepartList);
|
BackOrderDetail d = new BackOrderDetail();
|
d.setBackorderId(model.getId());
|
d.setDeleted(Constants.ZERO);
|
List<BackOrderDetail> detailList = backOrderDetailMapper.selectList(d);
|
model.setDetailList(detailList);
|
|
model.setRecordList(getRecordListFromDingding(user,model.getInstanceId()));
|
return model;
|
}
|
|
private List<DdInstanceStatusVO> getRecordListFromDingding(LoginUserInfo user,String instanceId) {
|
List<DdInstanceStatusVO> list = new ArrayList<>();
|
try {
|
List<OapiProcessinstanceGetResponse.OperationRecordsVo> result = DingDingUtil.getProcessInstance(companyExtService.getDingdingToken(user.getCompany().getId()) , instanceId);
|
if(result!=null){
|
for(OapiProcessinstanceGetResponse.OperationRecordsVo r : result){
|
DdInstanceStatusVO t = new DdInstanceStatusVO();
|
t.setUserid(r.getUserid());
|
t.setDate(r.getDate());
|
t.setOperationResult(r.getOperationResult());
|
t.setOperationType(r.getOperationType());
|
t.setRemark(r.getRemark());
|
t.setUserModel(getUserModelByDduserId(r.getUserid(),user));
|
list.add(t);
|
}
|
}
|
} catch (Exception e) {
|
throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "对不起，发起钉钉审批失败，请稍后重试！");
|
}
|
return list;
|
}
|
|
private CompanyUser getUserModelByDduserId(String userid, LoginUserInfo user) {
|
CompanyUser u = new CompanyUser();
|
u.setRootDepartId(user.getRootDepartment().getId());
|
u.setDeleted(Constants.ZERO);
|
u.setDdUserid(userid);
|
u = companyUserExtMapper.selectOne(new QueryWrapper<>(u).last(" limit 1"));
|
return u;
|
}
|
|
@Override
|
public Backorder findOne(Backorder backorder) {
|
QueryWrapper<Backorder> wrapper = new QueryWrapper<>(backorder);
|
return backorderMapper.selectOne(wrapper);
|
}
|
@Override
|
public void dealProcessInstance(String processInstanceId,String type,String result) {
|
if(StringUtils.isBlank(processInstanceId)){
|
return;
|
}
|
if(StringUtils.equals(type,"finish" ) || StringUtils.equals(type,"terminate" )){
|
//如果是审批结束或者终止
|
Backorder backorder = new Backorder();
|
backorder.setInstanceId(processInstanceId);
|
backorder= backorderMapper.selectByModel(backorder);
|
if(backorder!=null){
|
Backorder model = new Backorder();
|
model.setId(backorder.getId());
|
model.setUpdateTime(DateUtil.getCurrentDate());
|
if(StringUtils.equals(type,"finish" ) ){
|
//审批正常结束
|
if(StringUtils.equals(result,"agree" ) ){
|
//审批通过agree
|
model.setStatus(Constants.BACKORDER_STATUS.yes);
|
//生成生产计划
|
if(Constants.equalsInteger(backorder.getDeleted(),Constants.ZERO)
|
&& Constants.equalsInteger(backorder.getStatus(),Constants.BACKORDER_STATUS.ing)){
|
BackOrderDetail dModel = new BackOrderDetail();
|
dModel.setBackorderId(backorder.getId());
|
dModel.setDeleted(Constants.ZERO);
|
List<BackOrderDetail> details = backOrderDetailMapper.selectList(dModel);
|
if(details!=null){
|
for(BackOrderDetail d : details){
|
UpdateWrapper updateWrapper = new UpdateWrapper();
|
updateWrapper.eq("ID",d.getApplianceId());
|
updateWrapper.set("BACKORDER_ID",backorder.getId());
|
updateWrapper.set("UPDATE_TIME",DateUtil.getCurrentDate());
|
if(!Constants.equalsInteger(backorder.getType(),Constants.BACKORDER_TYPE.scrap)){
|
updateWrapper.set("BACK_PROCEDURE_ID",backorder.getBackProcedureId());
|
updateWrapper.set("SALEORDER_ID",backorder.getSaleorderId());
|
}
|
appliancesExtMapper.update(null,updateWrapper);
|
}
|
}
|
if(Constants.equalsInteger(backorder.getType(),Constants.BACKORDER_TYPE.scrap)){
|
//报废处理
|
Department d = departmentExtMapper.selectById(backorder.getRootDepartId());
|
if(d!=null){
|
CompanyExtListVO com = companyExtService.getModelById(d.getCompanyId());
|
wTransferService.dealScrapApply(backorder,com);
|
}
|
}else{
|
Plans p = new Plans();
|
p.setMaterialId(backorder.getMaterialId());
|
p.setDeleted(Constants.ZERO);
|
p.setCreateUser(backorder.getCreateUser());
|
p.setUserId(backorder.getCreateUser());
|
p.setCreateTime(DateUtil.getCurrentDate());
|
//从返修单取批次号
|
p.setBatch(backorder.getBatch());
|
// p.setBatch(plansExtService.getNextBatch(backorder.getCompanyId()));
|
p.setStatus(Constants.PLAN_STATUS.create);
|
p.setRootDepartId(backorder.getRootDepartId());
|
p.setDepartId(backorder.getOrderDepartId());
|
p.setUnitId(backorder.getUnitId());
|
p.setType(Constants.PLAN_TYPE.back);
|
p.setBackorderId(backorder.getId());
|
p.setPlanDate(backorder.getPlanDate());
|
p.setNum(Constants.formatBigdecimal(backorder.getNum()).intValue());
|
p.setProcedureId(backorder.getBackProcedureId());
|
p.setFactoryId(backorder.getFactoryId());
|
plansExtService.createDirect(p);
|
}
|
|
}
|
}else{
|
//审批不通过refuse
|
model.setStatus(Constants.BACKORDER_STATUS.no);
|
}
|
}else{
|
|
model.setStatus(Constants.BACKORDER_STATUS.stop);
|
}
|
//审批终止
|
UpdateWrapper updateWrapper = new UpdateWrapper();
|
updateWrapper.eq("ID",model.getId());
|
updateWrapper.set("STATUS",model.getStatus());
|
updateWrapper.set("UPDATE_TIME",DateUtil.getCurrentDate());
|
backorderMapper.update(null,updateWrapper);
|
// backorderMapper.updateById(model);
|
}
|
}
|
}
|
|
@Override
|
public List<Backorder> findList(Backorder backorder) {
|
QueryWrapper<Backorder> wrapper = new QueryWrapper<>(backorder);
|
return backorderMapper.selectList(wrapper);
|
}
|
@Override
|
public synchronized String getNextCode(Integer comId ){
|
String prefix = DateUtil.getDate(new Date(),"yyyyMMdd") +"-";
|
Integer countNum = RedisUtil.getObject(redisTemplate, Constants.RedisKeys.COM_BACKORDER_CODE_KEY+comId,Integer.class);
|
countNum = Constants.formatIntegerNum(countNum)+1;
|
//更新缓存
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.COM_BACKORDER_CODE_KEY+comId,countNum);
|
String nextIndex =Integer.toString( countNum);
|
return prefix + StringUtils.leftPad(nextIndex,4,"0");
|
}
|
@Override
|
public PageData<Backorder> findPageNew(PageWrap<Backorder> pageWrap) {
|
LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
|
if(!Constants.equalsInteger(user.getType(),Constants.USERTYPE.COM)){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(), "对不起，您无权限进行该操作！");
|
}
|
//只能查看当前根组织的数据
|
pageWrap.getModel().setDeleted(Constants.ZERO);
|
pageWrap.getModel().setRootDepartId(user.getRootDepartment().getId());
|
//只能查看当前根组织的数据
|
pageWrap.getModel().setRootDepartId(user.getRootDepartment().getId());
|
pageWrap.getModel().setOrderDepartId(user.getCurComDepartment().getId());
|
//数据权限
|
List<Integer> dataPermission = user.getDepartPermissionList();
|
if(dataPermission!=null){
|
pageWrap.getModel().setCreateUser(user.getId());
|
pageWrap.getModel().setDepartIds(dataPermission);
|
/* if(dataPermission.size() == 0){
|
//只能看自己的
|
pageWrap.getModel().setCreateUser(user.getId());
|
}else{
|
//否则走数据权限
|
pageWrap.getModel().setDepartIds(dataPermission);
|
}*/
|
}
|
PageHelper.startPage(pageWrap.getPage(), pageWrap.getCapacity());
|
List<Backorder> result = backorderMapper.selectList(pageWrap.getModel());
|
if(result!=null){
|
List<DepartmentExtListVO> allDepartList = RedisUtil.getObject(redisTemplate,Constants.RedisKeys.COM_DEPART_LIST_KEY+user.getCompany().getId(),ArrayList.class);
|
for(Backorder w : result){
|
initProUser(user,w,allDepartList);
|
}
|
}
|
return PageData.from(new PageInfo<>(result));
|
}
|
private void initProUser(LoginUserInfo user, Backorder data, List<DepartmentExtListVO> allDepartList) {
|
if(data.getCreateUser() ==null){
|
return;
|
}
|
CompanyUser query=new CompanyUser();
|
query.setUserId(data.getCreateUser());
|
query.setRootDepartId(user.getRootDepartment().getId());
|
query.setDeleted(Constants.ZERO);
|
CompanyUser comp= companyUserExtMapper.selectOne(new QueryWrapper<>(query).last(" limit 1"));
|
if(comp!=null){
|
data.setCreateUserName(comp.getName());
|
DepartmentExtListVO d = departmentExtService.getModelById(user.getCompany().getId(),comp.getDepartmentId(),allDepartList);
|
String dName =(d==null?"":StringUtils.defaultString(d.getName(),""));
|
data.setDepartmentName(dName);
|
}
|
}
|
@Override
|
public PageData<Backorder> findPage(PageWrap<Backorder> pageWrap) {
|
LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
|
if(!Constants.equalsInteger(user.getType(),Constants.USERTYPE.COM)){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(), "对不起，您无权限进行该操作！");
|
}
|
//只能查看当前根组织的数据
|
pageWrap.getModel().setDeleted(Constants.ZERO);
|
pageWrap.getModel().setRootDepartId(user.getRootDepartment().getId());
|
pageWrap.getModel().setOrderDepartId(user.getCurComDepartment().getId());
|
IPage<Backorder> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity());
|
QueryWrapper<Backorder> queryWrapper = new QueryWrapper<>();
|
Utils.MP.blankToNull(pageWrap.getModel());
|
if (pageWrap.getModel().getId() != null) {
|
queryWrapper.lambda().eq(Backorder::getId, pageWrap.getModel().getId());
|
}
|
if (pageWrap.getModel().getDeleted() != null) {
|
queryWrapper.lambda().eq(Backorder::getDeleted, pageWrap.getModel().getDeleted());
|
}
|
if (pageWrap.getModel().getCreateUser() != null) {
|
queryWrapper.lambda().eq(Backorder::getCreateUser, pageWrap.getModel().getCreateUser());
|
}
|
if (pageWrap.getModel().getCreateTime() != null) {
|
queryWrapper.lambda().ge(Backorder::getCreateTime, Utils.Date.getStart(pageWrap.getModel().getCreateTime()));
|
queryWrapper.lambda().le(Backorder::getCreateTime, Utils.Date.getEnd(pageWrap.getModel().getCreateTime()));
|
}
|
if (pageWrap.getModel().getUpdateUser() != null) {
|
queryWrapper.lambda().eq(Backorder::getUpdateUser, pageWrap.getModel().getUpdateUser());
|
}
|
if (pageWrap.getModel().getUpdateTime() != null) {
|
queryWrapper.lambda().ge(Backorder::getUpdateTime, Utils.Date.getStart(pageWrap.getModel().getUpdateTime()));
|
queryWrapper.lambda().le(Backorder::getUpdateTime, Utils.Date.getEnd(pageWrap.getModel().getUpdateTime()));
|
}
|
if (pageWrap.getModel().getRemark() != null) {
|
queryWrapper.lambda().eq(Backorder::getRemark, pageWrap.getModel().getRemark());
|
}
|
if (pageWrap.getModel().getRootDepartId() != null) {
|
queryWrapper.lambda().eq(Backorder::getRootDepartId, pageWrap.getModel().getRootDepartId());
|
}
|
if (pageWrap.getModel().getOrderDepartId() != null) {
|
queryWrapper.lambda().eq(Backorder::getOrderDepartId, pageWrap.getModel().getOrderDepartId());
|
}
|
if (pageWrap.getModel().getProcedureId() != null) {
|
queryWrapper.lambda().eq(Backorder::getProcedureId, pageWrap.getModel().getProcedureId());
|
}
|
if (pageWrap.getModel().getMaterialId() != null) {
|
queryWrapper.lambda().eq(Backorder::getMaterialId, pageWrap.getModel().getMaterialId());
|
}
|
if (pageWrap.getModel().getBatch() != null) {
|
queryWrapper.lambda().eq(Backorder::getBatch, pageWrap.getModel().getBatch());
|
}
|
if (pageWrap.getModel().getType() != null) {
|
queryWrapper.lambda().eq(Backorder::getType, pageWrap.getModel().getType());
|
}
|
if (pageWrap.getModel().getPlanDate() != null) {
|
queryWrapper.lambda().ge(Backorder::getPlanDate, Utils.Date.getStart(pageWrap.getModel().getPlanDate()));
|
queryWrapper.lambda().le(Backorder::getPlanDate, Utils.Date.getEnd(pageWrap.getModel().getPlanDate()));
|
}
|
if (pageWrap.getModel().getBackProcedureId() != null) {
|
queryWrapper.lambda().eq(Backorder::getBackProcedureId, pageWrap.getModel().getBackProcedureId());
|
}
|
if (pageWrap.getModel().getContent() != null) {
|
queryWrapper.lambda().eq(Backorder::getContent, pageWrap.getModel().getContent());
|
}
|
if (pageWrap.getModel().getStatus() != null) {
|
queryWrapper.lambda().eq(Backorder::getStatus, pageWrap.getModel().getStatus());
|
}
|
if (pageWrap.getModel().getInstanceId() != null) {
|
queryWrapper.lambda().eq(Backorder::getInstanceId, pageWrap.getModel().getInstanceId());
|
}
|
if (pageWrap.getModel().getCode() != null) {
|
queryWrapper.lambda().eq(Backorder::getCode, pageWrap.getModel().getCode());
|
}
|
if (pageWrap.getModel().getNum() != null) {
|
queryWrapper.lambda().eq(Backorder::getNum, pageWrap.getModel().getNum());
|
}
|
if (pageWrap.getModel().getSaleorderId() != null) {
|
queryWrapper.lambda().eq(Backorder::getSaleorderId, pageWrap.getModel().getSaleorderId());
|
}
|
if (pageWrap.getModel().getWarehouseId() != null) {
|
queryWrapper.lambda().eq(Backorder::getWarehouseId, pageWrap.getModel().getWarehouseId());
|
}
|
for(PageWrap.SortData sortData: pageWrap.getSorts()) {
|
if (sortData.getDirection().equalsIgnoreCase(PageWrap.DESC)) {
|
queryWrapper.orderByDesc(sortData.getProperty());
|
} else {
|
queryWrapper.orderByAsc(sortData.getProperty());
|
}
|
}
|
return PageData.from(backorderMapper.selectPage(page, queryWrapper));
|
}
|
|
@Override
|
public long count(Backorder backorder) {
|
QueryWrapper<Backorder> wrapper = new QueryWrapper<>(backorder);
|
return backorderMapper.selectCount(wrapper);
|
}
|
}
|
