iailab-module-model/iailab-module-model-biz/src/main/java/com/iailab/module/model/mcs/pre/service/impl/MmPredictItemServiceImpl.java

@@ -2,36 +2,33 @@

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.iailab.framework.common.page.PageData;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.iailab.framework.common.pojo.PageResult;
import com.iailab.framework.common.service.impl.BaseServiceImpl;
import com.iailab.framework.common.util.object.BeanUtils;
import com.iailab.module.model.mcs.pre.dao.MmPredictItemDao;
import com.iailab.module.model.mcs.pre.dto.MmPredictItemDTO;
import com.iailab.module.model.mcs.pre.entity.*;
import com.iailab.module.model.mcs.pre.enums.ItemIncreaseCodeEnum;
import com.iailab.module.model.mcs.pre.enums.ItemTypeEnum;
import com.iailab.module.model.mcs.pre.service.MmPredictItemService;
import com.iailab.module.model.mcs.pre.service.SequenceNumService;
import com.iailab.module.model.mcs.pre.service.MmSequenceNumService;
import com.iailab.module.model.mcs.pre.vo.MmPredictItemPageReqVO;
import com.iailab.module.model.mcs.pre.vo.MmPredictItemRespVO;
import com.iailab.module.model.mdk.vo.ItemVO;
import com.iailab.module.model.mdk.vo.MergeItemVO;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * @author PanZhibao
 * @date 2021年04月26日 14:03
 */
@Service("mmPredictItemService")
public class MmPredictItemServiceImpl extends BaseServiceImpl<MmPredictItemDao, MmPredictItemEntity> implements MmPredictItemService {
@Service
public class MmPredictItemServiceImpl extends ServiceImpl<MmPredictItemDao, MmPredictItemEntity> implements MmPredictItemService {

    @Autowired
    private DmModuleItemServiceImpl dmModuleItemService;
@@ -55,41 +52,38 @@
    private MmItemTypeImpl mmItemTypeImpl;

    @Autowired
    private SequenceNumService sequenceNumService;
    private MmSequenceNumService sequenceNumService;

    @Autowired
    private MmPredictItemDao mmPredictItemDao;

    @Override
    public PageResult<MmPredictItemRespVO> getPageList(Map<String, Object> params) {
        PageResult<MmPredictItemRespVO> result = new PageResult();
        IPage<MmPredictItemRespVO> page = baseDao.getPageList(
                getPage(params, "CREATE_TIME", false),
                params
        );
        result.setList(page.getRecords());
        result.setTotal(page.getTotal());
        return result;
    }
    public PageResult<MmPredictItemRespVO> queryPage(MmPredictItemPageReqVO reqVO) {
        IPage<MmPredictItemRespVO> page = mmPredictItemDao.selectPage(reqVO);

    private QueryWrapper<MmPredictItemEntity> getWrapper(Map<String, Object> params) {
        QueryWrapper<MmPredictItemEntity> wrapper = new QueryWrapper<>();
        return wrapper;
        return  new PageResult<MmPredictItemRespVO>(page.getRecords(), page.getTotal());
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void savePredictItem(MmPredictItemDTO mmPredictItemDto) {
    public List<MmPredictItemRespVO> list(Map<String, Object> params) {
        return mmPredictItemDao.queryList(params);
    }

    @Override
    public void add(MmPredictItemDTO mmPredictItemDto) {
        MmPredictItemEntity predictItem = mmPredictItemDto.getMmPredictItem();
        predictItem.setId(UUID.randomUUID().toString());
        predictItem.setCreateTime(new Date());
        predictItem.setUpdateTime(new Date());

        MmItemTypeEntity itemType = mmItemTypeImpl.getById(predictItem.getItemtypeid());
        if (ItemTypeEnum.NORMAL_ITEM.getName().equals(itemType.getItemtypename())) {
            SequenceNumEntity sequenceNumEntity = sequenceNumService.getAndIncreaseByCode(ItemIncreaseCodeEnum.IM.toString());
        if (itemType != null && ItemTypeEnum.NORMAL_ITEM.getName().equals(itemType.getItemtypename())) {
            MmSequenceNumEntity sequenceNumEntity = sequenceNumService.getAndIncreaseByCode(ItemIncreaseCodeEnum.IM.toString());
            String str = String.format("%010d", sequenceNumEntity.getSequenceNum());
            predictItem.setItemno(sequenceNumEntity.getPrefix() + str);

            MmPredictModelEntity mmPredictModel = mmPredictItemDto.getMmPredictModel();
            SequenceNumEntity preMdlSequenceNumEntity = sequenceNumService.getAndIncreaseByCode(ItemIncreaseCodeEnum.PRE_MDL.toString());
            MmSequenceNumEntity preMdlSequenceNumEntity = sequenceNumService.getAndIncreaseByCode(ItemIncreaseCodeEnum.PRE_MDL.toString());
            String preMdlStr = String.format("%04d", preMdlSequenceNumEntity.getSequenceNum());
            mmPredictModel.setModelno(preMdlSequenceNumEntity.getPrefix() + preMdlStr);
            mmPredictModel.setItemid(predictItem.getId());
@@ -106,8 +100,8 @@
                item.setModelid(mmPredictModel.getId());
            });
            mmModelParamService.saveList(mmModelParamList);
        } else if (ItemTypeEnum.MERGE_ITEM.getName().equals(itemType.getItemtypename())) {
            SequenceNumEntity sequenceNumEntity = sequenceNumService.getAndIncreaseByCode(ItemIncreaseCodeEnum.IC.toString());
        } else if (itemType != null && ItemTypeEnum.MERGE_ITEM.getName().equals(itemType.getItemtypename())) {
            MmSequenceNumEntity sequenceNumEntity = sequenceNumService.getAndIncreaseByCode(ItemIncreaseCodeEnum.IC.toString());
            String str = String.format("%010d", sequenceNumEntity.getSequenceNum());
            predictItem.setItemno(sequenceNumEntity.getPrefix() + str);

@@ -115,7 +109,7 @@
            mMmPredictMergeItem.setItemid(predictItem.getId());
            mmPredictMergeItemService.savePredictMergeItem(mMmPredictMergeItem);
        }
        insert(predictItem);
        mmPredictItemDao.insert(predictItem);
        DmModuleItemEntity dmModuleItem = mmPredictItemDto.getDmModuleItem();
        dmModuleItem.setItemid(predictItem.getId());
        dmModuleItemService.saveModuleItem(dmModuleItem);
@@ -126,13 +120,12 @@
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void update(MmPredictItemDTO mmPredictItemDto) {
        MmPredictItemEntity predictItem = mmPredictItemDto.getMmPredictItem();
        predictItem.setUpdateTime(new Date());
        this.updateById(predictItem);
        mmPredictItemDao.updateById(predictItem);
        MmItemTypeEntity itemType = mmItemTypeImpl.getById(predictItem.getItemtypeid());
        if (ItemTypeEnum.NORMAL_ITEM.getName().equals(itemType.getItemtypename())) {
        if (itemType != null && ItemTypeEnum.NORMAL_ITEM.getName().equals(itemType.getItemtypename())) {
            MmPredictModelEntity mmPredictModel = mmPredictItemDto.getMmPredictModel();
            mmPredictModelService.update(mmPredictModel);

@@ -147,52 +140,45 @@
                item.setModelid(mmPredictModel.getId());
            });
            mmModelParamService.saveList(mmModelParamList);
        } else if (ItemTypeEnum.MERGE_ITEM.getName().equals(itemType.getItemtypename())) {
        } else if (itemType != null && ItemTypeEnum.MERGE_ITEM.getName().equals(itemType.getItemtypename())) {
            MmPredictMergeItemEntity mMmPredictMergeItem = mmPredictItemDto.getMmPredictMergeItem();
            mmPredictMergeItemService.update(mMmPredictMergeItem);
        }
        DmModuleItemEntity dmModuleItem = mmPredictItemDto.getDmModuleItem();
        dmModuleItemService.update(dmModuleItem);

        if(!"".equals(dmModuleItem.getId()) && dmModuleItem.getId() != null){
            dmModuleItemService.update(dmModuleItem);
        }
        MmItemOutputEntity mmItemOutput = mmPredictItemDto.getMmItemOutput();
        mmItemOutputService.update(mmItemOutput);
        if(!"".equals(mmItemOutput.getId()) && dmModuleItem.getId() != null){
            mmItemOutputService.update(mmItemOutput);
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void deleteBatch(String[] itemIds) {
        deleteBatchIds(Arrays.asList(itemIds));
        mmPredictItemDao.deleteBatchIds(Arrays.asList(itemIds));
        mmPredictMergeItemService.deleteBatch(itemIds);
        mmPredictModelService.deleteBatch(itemIds);
        mmItemOutputService.deleteBatch(itemIds);
    }

    @Override
    public MmPredictItemDTO getDetailById(String id, Map<String, Object> params) {
        MmPredictItemDTO mmPredictItemDto = new MmPredictItemDTO();
        MmPredictItemEntity predictItem = selectById(id);
    public MmPredictItemDTO info(String id) {
        MmPredictItemEntity predictItem = mmPredictItemDao.selectById(id);
        MmPredictItemDTO mmPredictItemDto = BeanUtils.toBean(predictItem, MmPredictItemDTO.class);
        mmPredictItemDto.setMmPredictItem(predictItem);
        mmPredictItemDto.setDmModuleItem(dmModuleItemService.getByItemid(id));
        mmPredictItemDto.setMmItemOutput(mmItemOutputService.getByItemid(id));
        MmItemTypeEntity itemType = mmItemTypeImpl.getById(predictItem.getItemtypeid());
        if (ItemTypeEnum.NORMAL_ITEM.getName().equals(itemType.getItemtypename())) {
        if (itemType != null && ItemTypeEnum.NORMAL_ITEM.getName().equals(itemType.getItemtypename())) {
            MmPredictModelEntity mmPredictModel = mmPredictModelService.getByItemid(id);
            mmPredictItemDto.setMmPredictModel(mmPredictModel);
            mmPredictItemDto.setMmModelArithSettingsList(mmModelArithSettingsService.getByModelid(mmPredictModel.getId()));
            mmPredictItemDto.setMmModelParamList(mmModelParamService.getByModelid(mmPredictModel.getId()));
        } else if (ItemTypeEnum.MERGE_ITEM.getName().equals(itemType.getItemtypename())) {
        } else if (itemType != null && ItemTypeEnum.MERGE_ITEM.getName().equals(itemType.getItemtypename())) {
            mmPredictItemDto.setMmPredictMergeItem(mmPredictMergeItemService.getByItemid(id));
        }

        return mmPredictItemDto;
    }

    @Override
    public boolean exportItemResult(HttpServletResponse response, HttpServletRequest request, String id, Map<String, Object> params) {
        //MmPredictItemDTO mmPredictItemDto = this.getPredictValuesById(id, params);
        //List<MmItemResultEntity> itemResultList = mmPredictItemDto.getMmItemResultList();

        return true;
    }

    @Override
@@ -203,21 +189,15 @@
        QueryWrapper<MmPredictItemEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.ne(StringUtils.isNotBlank(id), "id", id);
        queryWrapper.and(wrapper -> wrapper.eq("itemname", itemname).or().eq("itemno", itemno));
        List<MmPredictItemEntity> list = baseDao.selectList(queryWrapper);
        List<MmPredictItemEntity> list = mmPredictItemDao.selectList(queryWrapper);
        return list.size();
    }

    @Override
    public Long count() {
        QueryWrapper<MmPredictItemEntity> queryWrapper = new QueryWrapper<>();
        return baseDao.selectCount(queryWrapper);
    }

    @Override
    public List<ItemVO> getByModuleId(String moduleId) {
        Map<String, Object> params = new HashMap<>();

        return baseDao.getByModuleId(params);
        return mmPredictItemDao.getByModuleId(params);
    }

    @Override
@@ -227,7 +207,7 @@
        }
        Map<String, Object> params = new HashMap(1);
        params.put("ITEMNO", itemNo);
        List<ItemVO> list = baseDao.getItem(params);
        List<ItemVO> list = mmPredictItemDao.getItem(params);
        if (CollectionUtils.isEmpty(list)) {
            return null;
        }
@@ -241,7 +221,7 @@
        }
        Map<String, Object> params = new HashMap(1);
        params.put("ITEMID", itemId);
        List<ItemVO> list = baseDao.getItem(params);
        List<ItemVO> list = mmPredictItemDao.getItem(params);
        if (CollectionUtils.isEmpty(list)) {
            return null;
        }
@@ -255,7 +235,7 @@
        }
        Map<String, Object> params = new HashMap(1);
        params.put("ITEMID", itemId);
        List<MergeItemVO> list = baseDao.getMergeItemByItemId(params);
        List<MergeItemVO> list = mmPredictItemDao.getMergeItemByItemId(params);
        if (CollectionUtils.isEmpty(list)) {
            return null;
        }