EPCMS/src/main/java/com/vverp/dao/PurchaseOrderItemDao.java

package com.vverp.dao;

import com.vverp.dto.*;
import com.vverp.entity.PurchaseOrderItem;
import com.vverp.util.CriteriaUtils;
import org.hibernate.internal.SQLQueryImpl;
import org.hibernate.transform.Transformers;
import org.springframework.stereotype.Repository;

import javax.persistence.Query;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;

/**
* @author 
* @date 2020-03-25 16:50
*/
@Repository
public class PurchaseOrderItemDao extends BaseOrderItemDao<PurchaseOrderItem, Long> {

    public OrderInfo analyze(Date startDate, Date endDate) {
        OrderQuery orderQuery = new OrderQuery();
        orderQuery.setCreateDateStart(startDate);
        orderQuery.setCreateDateEnd(endDate);
        return orderInfo(orderQuery);
    }

    public PurchaseOrderItem findByInd(Integer ind,Long orderId) {
        CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
        CriteriaQuery<PurchaseOrderItem> criteriaQuery = criteriaBuilder.createQuery(PurchaseOrderItem.class);
        Root<PurchaseOrderItem> root = criteriaQuery.from(PurchaseOrderItem.class);
        criteriaQuery.select(root);
        Predicate predicate = criteriaBuilder.conjunction();
        if (ind != null) {
            predicate = criteriaBuilder.and(predicate, criteriaBuilder.equal(root.get("ind"), ind));
        }
        if (orderId != null) {
            predicate = criteriaBuilder.and(predicate, criteriaBuilder.equal(root.get("purchaseOrder").get("id"), orderId));
        }
        criteriaQuery.where(predicate);
        try {
            return findList(criteriaQuery, null,null,null,null).get(0);
        }catch (Exception e){
            return null;
        }
    }

    public List<CommonRankDTO> produceRankDTO(Date startDate, Date endDate, Integer limit, String orderBy) {
        CriteriaBuilder criteriaBuilder = this.entityManager.getCriteriaBuilder();
        CriteriaQuery<CommonRankDTO> criteriaQuery = criteriaBuilder.createQuery(CommonRankDTO.class);
        Root<PurchaseOrderItem> root = criteriaQuery.from(PurchaseOrderItem.class);
        criteriaQuery.select(
                criteriaBuilder.construct(CommonRankDTO.class,
                        root.get("productId"),
                        root.get("productCode"),
                        criteriaBuilder.sum(root.get("count")),
                        criteriaBuilder.sum(criteriaBuilder.prod(root.get("price"), root.get("count"))))
        );
        Predicate predicate = criteriaBuilder.conjunction();
        predicate = CriteriaUtils.dateFilter(criteriaBuilder, predicate, root, startDate, endDate);
        criteriaQuery.where(predicate);
        criteriaQuery.groupBy(root.get("productId"), root.get("productCode"));

        if (orderBy != null) {
            if (orderBy.equals("count")) {
                criteriaQuery.orderBy(criteriaBuilder.desc(criteriaBuilder.sum(root.get("count"))));
            } else if (orderBy.equals("amount")) {
                criteriaQuery.orderBy(criteriaBuilder.desc(criteriaBuilder.sum(criteriaBuilder.prod(root.get("price"), root.get("count")))));
            }
        }

        if (limit != null) {
            return entityManager.createQuery(criteriaQuery).setMaxResults(limit).getResultList();
        } else {
            return entityManager.createQuery(criteriaQuery).getResultList();
        }
    }

    public BigDecimal sumCount(Long orderId, List<Long> idList) {
        return sumCount("count", orderId, idList);
    }
    public BigDecimal sumHavePurchaseCount(Long orderId, List<Long> idList) {
        return sumCount("havePurchaseCount", orderId, idList);
    }
    public BigDecimal sumInboundCount(Long orderId) {
        return sumCount("inboundCount", orderId, null);
    }
    public BigDecimal sumCount(String prop, Long orderId, List<Long> idList) {
        CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
        CriteriaQuery<BigDecimal> criteriaQuery = criteriaBuilder.createQuery(BigDecimal.class);
        Root<PurchaseOrderItem> root = criteriaQuery.from(PurchaseOrderItem.class);
        criteriaQuery.select(criteriaBuilder.sum(root.get(prop)));
        Predicate all = criteriaBuilder.conjunction();
        if (orderId != null) {
            all = criteriaBuilder.and(all, criteriaBuilder.equal(root.get("purchaseOrder").get("id"), orderId));
        }
        if (idList != null) {
            CriteriaBuilder.In<Long> idIn = criteriaBuilder.in(root.get("id"));
            idIn.value(0L);
            for (Long id : idList) {
                idIn.value(id);
            }
            all = criteriaBuilder.and(all, idIn);
        }
        criteriaQuery.where(all);
        BigDecimal res = null;
        try {
            res = entityManager.createQuery(criteriaQuery).getSingleResult();
        } catch (Exception ignored) {
        }
        return res == null ? BigDecimal.ZERO : res;
    }

    public List<PoiMoDto> findIdMaterialOrderIdMap(Long purchaseOrderId) {
        String jpql = "select poi.id as id, moi.material_order as materialOrderId from t_purchase_order_item poi left join t_material_order_item moi on poi.id = moi.order_item_id where poi.purchase_order = :purchaseOrderId ";
        Query query = entityManager.createNativeQuery(jpql).setParameter("purchaseOrderId", purchaseOrderId);
        query.unwrap(SQLQueryImpl.class).setResultTransformer(Transformers.aliasToBean(PoiMoDto.class));
        return query.getResultList();
    }
    public List<PoiPsiDto> findDeliveryCountAndInboundCountByPurchaseOrderId(Long purchaseOrderId) {
        String jpql = "select poi.id as id, sum(psi.count) as deliveryCount, sum(psi.in_stock_num) as inboundCount from t_purchase_order_item poi left join t_purchase_stock_item psi on poi.id = psi.purchase_order_item_id where poi.purchase_order = :purchaseOrderId group by poi.id ";
        Query query = entityManager.createNativeQuery(jpql).setParameter("purchaseOrderId", purchaseOrderId);
        query.unwrap(SQLQueryImpl.class).setResultTransformer(Transformers.aliasToBean(PoiPsiDto.class));
        return query.getResultList();
    }
    public PoiPsiDto findDeliveryCountAndInboundCountByPoiId(Long purchaseOrderItemId) {
        String jpql = "select poi.id as id, sum(psi.count) as deliveryCount, sum(psi.in_stock_num) as inboundCount from t_purchase_order_item poi left join t_purchase_stock_item psi on poi.id = psi.purchase_order_item_id where poi.id = :id ";
        Query query = entityManager.createNativeQuery(jpql).setParameter("id", purchaseOrderItemId).setMaxResults(1);
        query.unwrap(SQLQueryImpl.class).setResultTransformer(Transformers.aliasToBean(PoiPsiDto.class));
        List resultList = query.getResultList();
        return (PoiPsiDto) resultList.stream().findFirst().orElse(null);
    }
}