package com.doumee.service.business.impl; 
 | 
  
 | 
import com.doumee.core.utils.Constants; 
 | 
import com.doumee.dao.business.model.*; 
 | 
import com.doumee.service.business.third.model.PageData; 
 | 
import com.doumee.service.business.third.model.PageWrap; 
 | 
import com.doumee.core.utils.Utils; 
 | 
import com.doumee.dao.business.JkOrdersMapper; 
 | 
import com.doumee.service.business.JkOrdersService; 
 | 
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 com.github.yulichang.wrapper.MPJLambdaWrapper; 
 | 
import org.springframework.beans.factory.annotation.Autowired; 
 | 
import org.springframework.stereotype.Service; 
 | 
import org.springframework.util.CollectionUtils; 
 | 
  
 | 
import java.util.List; 
 | 
  
 | 
/** 
 | 
 * 交控-销售订单信息表Service实现 
 | 
 * @author 江蹄蹄 
 | 
 * @date 2025/09/28 09:01 
 | 
 */ 
 | 
@Service 
 | 
public class JkOrdersServiceImpl implements JkOrdersService { 
 | 
  
 | 
    @Autowired 
 | 
    private JkOrdersMapper jkOrdersMapper; 
 | 
  
 | 
    @Override 
 | 
    public Integer create(JkOrders jkOrders) { 
 | 
        jkOrdersMapper.insert(jkOrders); 
 | 
        return jkOrders.getId(); 
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public void deleteById(Integer id) { 
 | 
        jkOrdersMapper.deleteById(id); 
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public void delete(JkOrders jkOrders) { 
 | 
        UpdateWrapper<JkOrders> deleteWrapper = new UpdateWrapper<>(jkOrders); 
 | 
        jkOrdersMapper.delete(deleteWrapper); 
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public void deleteByIdInBatch(List<Integer> ids) { 
 | 
        if (CollectionUtils.isEmpty(ids)) { 
 | 
            return; 
 | 
        } 
 | 
        jkOrdersMapper.deleteBatchIds(ids); 
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public void updateById(JkOrders jkOrders) { 
 | 
        jkOrdersMapper.updateById(jkOrders); 
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public void updateByIdInBatch(List<JkOrders> jkOrderss) { 
 | 
        if (CollectionUtils.isEmpty(jkOrderss)) { 
 | 
            return; 
 | 
        } 
 | 
        for (JkOrders jkOrders: jkOrderss) { 
 | 
            this.updateById(jkOrders); 
 | 
        } 
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public JkOrders findById(Integer id) { 
 | 
        return jkOrdersMapper.selectById(id); 
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public JkOrders findOne(JkOrders jkOrders) { 
 | 
        QueryWrapper<JkOrders> wrapper = new QueryWrapper<>(jkOrders); 
 | 
        return jkOrdersMapper.selectOne(wrapper); 
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public List<JkOrders> findList(JkOrders jkOrders) { 
 | 
        QueryWrapper<JkOrders> wrapper = new QueryWrapper<>(jkOrders); 
 | 
        return jkOrdersMapper.selectList(wrapper); 
 | 
    } 
 | 
   
 | 
    @Override 
 | 
    public PageData<JkOrders> findPage(PageWrap<JkOrders> pageWrap) { 
 | 
        IPage<JkOrders> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity()); 
 | 
        MPJLambdaWrapper<JkOrders> queryWrapper = new MPJLambdaWrapper<>(); 
 | 
        Utils.MP.blankToNull(pageWrap.getModel()); 
 | 
        pageWrap.getModel().setIsdeleted(Constants.ZERO); 
 | 
        queryWrapper.selectAll(JkOrders.class ) 
 | 
                .selectAs(Category::getId,JkOrders::getCategoryId) 
 | 
                .selectAs(Category::getName,JkOrders::getCategoryName) 
 | 
                .selectAs(JkCustomer::getCode,JkOrders::getCode) 
 | 
                .selectAs(JkCustomer::getName,JkOrders::getName) 
 | 
                .selectAs(JkLine::getName,JkOrders::getLineName) 
 | 
                .leftJoin(JkCustomer.class,JkCustomer::getId,JkOrders::getCustomerId ) 
 | 
                .leftJoin(JkLine.class,JkLine::getId,JkOrders::getLineId ) 
 | 
                .leftJoin(Category.class,Category::getId,JkLine::getCategoryId ); 
 | 
        queryWrapper.eq( pageWrap.getModel().getCategoryId()!=null, JkLine::getCategoryId, pageWrap.getModel().getCategoryId()); 
 | 
        queryWrapper.eq( pageWrap.getModel().getDateInfo()!=null, JkOrders::getDateInfo, pageWrap.getModel().getDateInfo()); 
 | 
        if (pageWrap.getModel().getId() != null) { 
 | 
           queryWrapper.eq(JkOrders::getId, pageWrap.getModel().getId()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getCreator() != null) { 
 | 
           queryWrapper.eq(JkOrders::getCreator, pageWrap.getModel().getCreator()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getCreateDate() != null) { 
 | 
           queryWrapper.ge(JkOrders::getCreateDate, Utils.Date.getStart(pageWrap.getModel().getCreateDate())); 
 | 
           queryWrapper.le(JkOrders::getCreateDate, Utils.Date.getEnd(pageWrap.getModel().getCreateDate())); 
 | 
        } 
 | 
        if (pageWrap.getModel().getEditor() != null) { 
 | 
           queryWrapper.eq(JkOrders::getEditor, pageWrap.getModel().getEditor()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getEditDate() != null) { 
 | 
           queryWrapper.ge(JkOrders::getEditDate, Utils.Date.getStart(pageWrap.getModel().getEditDate())); 
 | 
           queryWrapper.le(JkOrders::getEditDate, Utils.Date.getEnd(pageWrap.getModel().getEditDate())); 
 | 
        } 
 | 
        if (pageWrap.getModel().getIsdeleted() != null) { 
 | 
           queryWrapper.eq(JkOrders::getIsdeleted, pageWrap.getModel().getIsdeleted()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getInfo() != null) { 
 | 
           queryWrapper.eq(JkOrders::getInfo, pageWrap.getModel().getInfo()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getName() != null) { 
 | 
           queryWrapper.eq(JkOrders::getName, pageWrap.getModel().getName()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getNum() != null) { 
 | 
           queryWrapper.eq(JkOrders::getNum, pageWrap.getModel().getNum()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getLineId() != null) { 
 | 
           queryWrapper.eq(JkOrders::getLineId, pageWrap.getModel().getLineId()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getStatus() != null) { 
 | 
           queryWrapper.eq(JkOrders::getStatus, pageWrap.getModel().getStatus()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getSortnum() != null) { 
 | 
           queryWrapper.eq(JkOrders::getSortnum, pageWrap.getModel().getSortnum()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getDateInfo() != null) { 
 | 
           queryWrapper.ge(JkOrders::getDateInfo, Utils.Date.getStart(pageWrap.getModel().getDateInfo())); 
 | 
           queryWrapper.le(JkOrders::getDateInfo, Utils.Date.getEnd(pageWrap.getModel().getDateInfo())); 
 | 
        } 
 | 
        if (pageWrap.getModel().getDistances() != null) { 
 | 
           queryWrapper.eq(JkOrders::getDistances, pageWrap.getModel().getDistances()); 
 | 
        } 
 | 
        queryWrapper.orderByAsc(JkOrders::getSortnum); 
 | 
        IPage<JkOrders> result = jkOrdersMapper.selectJoinPage(page, JkOrders.class,queryWrapper); 
 | 
        return PageData.from(result); 
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public long count(JkOrders jkOrders) { 
 | 
        QueryWrapper<JkOrders> wrapper = new QueryWrapper<>(jkOrders); 
 | 
        return jkOrdersMapper.selectCount(wrapper); 
 | 
    } 
 | 
} 
 |