初始版本

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

@@ -0,0 +1,140 @@
+package com.vverp.dao;
+
+import com.vverp.dto.*;
+import com.vverp.entity.PurchaseOrderItem;
+import com.vverp.moli.util.Page;
+import com.vverp.moli.util.Pageable;
+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 dealsky
+* @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);
+    }
+}