政策发布,政策预览,第三方政策接口

src/main/java/com/qs/serve/common/model/consts/BudgetLogOptFlag.java

@@ -22,5 +22,7 @@ public interface BudgetLogOptFlag {
     /** 9-行政区域迁移调增，10-行政区域迁移调减 */
     Integer State_9 = 9;
     Integer State_10 = 10;
+    /** 11-政策调减 */
+    Integer State_11 = 11;
 
 }

src/main/java/com/qs/serve/modules/tbs/entity/TbsBudgetCostItem.java

@@ -229,6 +229,9 @@ public class TbsBudgetCostItem implements Serializable {
     /** TbsActivityCenterGoods的id */
     private Long centerGoodItemId;
 
+    /** 标识是否政策生成的item，不参与业务，为以后拓展使用 */
+    private Integer policyFlag;
+
     /** 是否无效（退回，拒绝时使用,释放则不计入预算占用） */
     private Integer invalidFlag;
 

src/main/java/com/qs/serve/modules/tbs/entity/TbsBudgetCostItemPolicy.java

@@ -0,0 +1,182 @@
+package com.qs.serve.modules.tbs.entity;
+
+import java.time.LocalDate;
+import java.io.Serializable;
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+
+import com.baomidou.mybatisplus.annotation.*;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+import org.hibernate.validator.constraints.Length;
+import org.springframework.format.annotation.DateTimeFormat;
+
+import javax.validation.constraints.NotNull;
+import javax.validation.constraints.NotBlank;
+
+/**
+ * 预算费用明细 实体类
+ * @author YenHex
+ * @since 2023-02-22
+ */
+@Data
+@TableName("tbs_budget_cost_item_policy")
+public class TbsBudgetCostItemPolicy implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    /** id */
+    @TableId(type = IdType.AUTO)
+    private Long id;
+
+    /** 费用申请id */
+    @NotNull(message = "费用申请id不能为空")
+    private Long policyId;
+
+    /** 活动id */
+    @NotNull(message = "活动id不能为空")
+    private Long policyItemId;
+
+    /** 活动编码 */
+    @Length(max = 30,message = "活动编码长度不能超过30字")
+    private String policyItemCode;
+
+    /** 科目id */
+    @NotNull(message = "科目id不能为空")
+    private Long subjectId;
+
+    /** 科目编码 */
+    @NotBlank(message = "科目编码不能为空")
+    @Length(max = 50,message = "科目编码长度不能超过50字")
+    private String subjectCode;
+
+    /** 科目名称 */
+    @NotBlank(message = "科目名称不能为空")
+    @Length(max = 50,message = "科目名称长度不能超过50字")
+    private String subjectName;
+
+    /** 成本中心类型 */
+    @NotBlank(message = "成本中心类型不能为空")
+    @Length(max = 50,message = "成本中心类型长度不能超过50字")
+    private String centerType;
+
+    /** 成本中心id */
+    @NotBlank(message = "成本中心id不能为空")
+    @Length(max = 32,message = "成本中心id长度不能超过32字")
+    private String centerId;
+
+    /** 成本中心编码 */
+    @NotBlank(message = "成本中心编码不能为空")
+    @Length(max = 50,message = "成本中心编码长度不能超过50字")
+    private String centerCode;
+
+    /** 成本中心名称 */
+    @NotBlank(message = "成本中心名称不能为空")
+    @Length(max = 50,message = "成本中心名称长度不能超过50字")
+    private String centerName;
+
+    /** 费用额度 */
+    @NotNull(message = "费用额度不能为空")
+    private BigDecimal policyItemAmount;
+
+    /** 备注 */
+    @Length(max = 255,message = "备注长度不能超过255字")
+    private String remark;
+
+    /** 创建时间 */
+    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss",timezone = "GMT+8")
+    @TableField(fill = FieldFill.INSERT)
+    private LocalDateTime createTime;
+
+    /** 最后更新时间 */
+    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss",timezone = "GMT+8")
+    @TableField(fill = FieldFill.UPDATE)
+    private LocalDateTime updateTime;
+
+    /** 所属租户 */
+    @JsonIgnore
+    @JsonProperty
+    private String tenantId;
+
+    /** 创建人 */
+    @TableField(fill = FieldFill.INSERT)
+    private String createBy;
+
+    /** 更新人 */
+    @TableField(fill = FieldFill.UPDATE)
+    private String updateBy;
+
+    /** 逻辑删除标记（0：显示；1：隐藏） */
+    @JsonIgnore
+    @JsonProperty
+    private String delFlag;
+
+    /** 政策项开始时间 */
+    @NotNull(message = "政策项开始时间不能为空")
+    @DateTimeFormat(pattern = "yyyy-MM-dd")
+    @JsonFormat(pattern = "yyyy-MM-dd",timezone = "GMT+8")
+    private LocalDate policyItemStartDate;
+
+    /** 政策项结束时间 */
+    @NotNull(message = "政策项结束时间不能为空")
+    @DateTimeFormat(pattern = "yyyy-MM-dd")
+    @JsonFormat(pattern = "yyyy-MM-dd",timezone = "GMT+8")
+    private LocalDate policyItemEndDate;
+
+    /** 考核id */
+    @NotNull(message = "考核id不能为空")
+    private Long scheduleId;
+
+    /** 考核期项id */
+    @NotNull(message = "考核期项id不能为空")
+    private Long scheduleItemId;
+
+    /** 考核期名称 */
+    @NotBlank(message = "考核期名称不能为空")
+    @Length(max = 30,message = "考核期名称长度不能超过30字")
+    private String scheduleItemName;
+
+    /** 录入时，考核期可用预算 */
+    @NotNull(message = "录入时，考核期可用预算不能为空")
+    private BigDecimal scheduleItemAmount;
+
+    /** 录入时，考核期已用金额(含申请占用金额) */
+    @NotNull(message = "录入时，考核期已用金额(含申请占用金额)不能为空")
+    private BigDecimal scheduleItemAmountUsed;
+
+    /** 录入时，考核期申请占用金额 */
+    @NotNull(message = "录入时，考核期申请占用金额不能为空")
+    private BigDecimal scheduleItemAmountApply;
+
+    /** 预算id */
+    @NotNull(message = "预算id不能为空")
+    private Long budgetId;
+
+    /** 预算考核期id */
+    @NotNull(message = "预算考核期id不能为空")
+    private Long scheduleItemBudgetId;
+
+    /** 是否无效 */
+    @NotNull(message = "是否无效不能为空")
+    private Integer invalidFlag;
+
+    /** 客户id */
+    @NotNull(message = "客户id不能为空")
+    private Long supplierId;
+
+    /** 客户编码 */
+    @NotBlank(message = "客户编码不能为空")
+    @Length(max = 30,message = "客户编码长度不能超过30字")
+    private String supplierCode;
+
+    /** 客户名称 */
+    @NotBlank(message = "客户名称不能为空")
+    @Length(max = 30,message = "客户名称长度不能超过30字")
+    private String supplierName;
+
+}
+

src/main/java/com/qs/serve/modules/tbs/entity/dto/TbsBudgetCostResult.java

@@ -6,7 +6,9 @@ import com.fasterxml.jackson.annotation.JsonFormat;
 import com.qs.serve.modules.tbs.entity.TbsActivity;
 import com.qs.serve.modules.tbs.entity.TbsBudget;
 import com.qs.serve.modules.tbs.entity.TbsBudgetCostItem;
+import com.qs.serve.modules.tbs.entity.TbsBudgetCostItemPolicy;
 import com.qs.serve.modules.tbs.entity.vo.TbsBudgetTableVo;
+import com.qs.serve.modules.tzc.entity.TzcPolicyItem;
 import lombok.Data;
 import org.hibernate.validator.constraints.Length;
 import org.springframework.format.annotation.DateTimeFormat;
@@ -24,12 +26,18 @@ import java.util.List;
 @Data
 public class TbsBudgetCostResult {
 
-    /** 匹配费用占用(含超支预算) */
+    /** 活动：匹配费用占用(含超支预算) */
     private List<TbsBudgetCostItem> budgetMatchList;
 
-    /** 没有匹配预算的费用 */
+    /** 活动：没有匹配预算的费用 */
     private List<TbsBudgetCostItem> budgetUnMatchList;
 
+    /** 政策：匹配费用占用(含超支预算) */
+    private List<TbsBudgetCostItemPolicy> policyBudgetMatchList;
+
+    /** 政策：没有匹配预算的费用 */
+    private List<TbsBudgetCostItemPolicy> policyBudgetUnMatchList;
+
     /** 表数据封装 */
     private TbsBudgetTableVo tableData;
 
@@ -39,4 +47,6 @@ public class TbsBudgetCostResult {
     /** 后台数据数据封装 */
     private List<TbsActivity> activityList;
 
+    /** 后台数据数据封装 */
+    private List<TzcPolicyItem> policyItemList;
 }

src/main/java/com/qs/serve/modules/tbs/entity/dto/TbsBudgetItemCostResult.java

@@ -0,0 +1,77 @@
+package com.qs.serve.modules.tbs.entity.dto;
+
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.qs.serve.common.util.CopierUtil;
+import com.qs.serve.modules.tbs.entity.TbsBudgetCostItem;
+import com.qs.serve.modules.tbs.entity.TbsBudgetCostItemPolicy;
+import com.qs.serve.modules.tzc.entity.TzcPolicyItem;
+import lombok.Data;
+
+import java.math.BigDecimal;
+
+/**
+ * @author YenHex
+ * @since 2023/2/22
+ */
+@Data
+public class TbsBudgetItemCostResult {
+
+    /** 后台参数：预算id */
+    private Long budgetId;
+
+    /** 后台参数：考核id */
+    private Long scheduleId;
+
+    /** 后台参数：考核期项id */
+    private Long scheduleItemId;
+
+    /** 后台参数：考核期项id */
+    private String scheduleItemName;
+
+    /** 后台参数：录入时考核期可用预算 */
+    private BigDecimal scheduleItemAmount;
+
+    /** 后台参数：录入时，考核期已用金额(含申请占用金额) */
+    private BigDecimal scheduleItemAmountUsed;
+
+    /** 后台参数：录入时，考核期申请占用金额 */
+    private BigDecimal scheduleItemAmountApply;
+
+    /** 后台参数：费用考核期项id */
+    private Long scheduleItemBudgetId;
+
+    private TzcPolicyItem policyItem;
+
+    public TbsBudgetCostItemPolicy toBudgetCostItem(){
+        TbsBudgetCostItemPolicy itemPolicy = new TbsBudgetCostItemPolicy();
+        if(policyItem!=null){
+            itemPolicy.setPolicyId(policyItem.getPolicyId());
+            itemPolicy.setPolicyItemId(policyItem.getId());
+            itemPolicy.setPolicyItemCode(policyItem.getPolicyItemCode());
+            itemPolicy.setSubjectId(policyItem.getSubjectId());
+            itemPolicy.setSubjectCode(policyItem.getSubjectCode());
+            itemPolicy.setSubjectName(policyItem.getSubjectName());
+            itemPolicy.setCenterCode(policyItem.getCenterCode());
+            itemPolicy.setCenterId(policyItem.getCenterId());
+            itemPolicy.setCenterName(policyItem.getCenterName());
+            itemPolicy.setSupplierId(policyItem.getSupplierId());
+            itemPolicy.setSupplierCode(policyItem.getSupplierCode());
+            itemPolicy.setSupplierName(policyItem.getSupplierName());
+            itemPolicy.setPolicyItemAmount(policyItem.getDiscountMax());
+            itemPolicy.setPolicyItemStartDate(policyItem.getPolicyStartDate());
+            itemPolicy.setPolicyItemEndDate(policyItem.getPolicyEndDate());
+        }
+        itemPolicy.setBudgetId(this.getBudgetId());
+        itemPolicy.setScheduleId(this.getScheduleId());
+        itemPolicy.setScheduleItemId(this.getScheduleItemId());
+        itemPolicy.setScheduleItemBudgetId(this.getScheduleItemBudgetId());
+        itemPolicy.setScheduleItemName(this.getScheduleItemName());
+        //绑定录入时可用预算
+        itemPolicy.setScheduleItemAmount(this.getScheduleItemAmount());
+        //剩余的可用预算
+        itemPolicy.setScheduleItemAmountUsed(this.getScheduleItemAmountUsed());
+        itemPolicy.setScheduleItemAmountApply(this.getScheduleItemAmountApply());
+        return itemPolicy;
+    }
+
+}

src/main/java/com/qs/serve/modules/tbs/mapper/TbsBudgetCostItemPolicyMapper.java

@@ -0,0 +1,14 @@
+package com.qs.serve.modules.tbs.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.qs.serve.modules.tbs.entity.TbsBudgetCostItemPolicy;
+
+/**
+ * 预算费用明细 Mapper
+ * @author YenHex
+ * @date 2023-02-22
+ */
+public interface TbsBudgetCostItemPolicyMapper extends BaseMapper<TbsBudgetCostItemPolicy> {
+
+}
+

src/main/java/com/qs/serve/modules/tbs/service/TbsBudgetCostItemPolicyService.java

@@ -0,0 +1,14 @@
+package com.qs.serve.modules.tbs.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.qs.serve.modules.tbs.entity.TbsBudgetCostItemPolicy;
+
+/**
+ * 预算费用明细 服务接口
+ * @author YenHex
+ * @date 2023-02-22
+ */
+public interface TbsBudgetCostItemPolicyService extends IService<TbsBudgetCostItemPolicy> {
+
+}
+

src/main/java/com/qs/serve/modules/tbs/service/impl/TbsBudgetCostItemPolicyServiceImpl.java

@@ -0,0 +1,22 @@
+package com.qs.serve.modules.tbs.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import lombok.AllArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import com.qs.serve.modules.tbs.entity.TbsBudgetCostItemPolicy;
+import com.qs.serve.modules.tbs.service.TbsBudgetCostItemPolicyService;
+import com.qs.serve.modules.tbs.mapper.TbsBudgetCostItemPolicyMapper;
+
+/**
+ * 预算费用明细 服务实现类
+ * @author YenHex
+ * @since 2023-02-22
+ */
+@Slf4j
+@Service
+@AllArgsConstructor
+public class TbsBudgetCostItemPolicyServiceImpl extends ServiceImpl<TbsBudgetCostItemPolicyMapper,TbsBudgetCostItemPolicy> implements TbsBudgetCostItemPolicyService {
+
+}
+

src/main/java/com/qs/serve/modules/third/PortalOfCostController.java

@@ -1,7 +1,8 @@
 package com.qs.serve.modules.third;
 
 import com.qs.serve.common.model.dto.R;
-import com.qs.serve.modules.third.entity.ProcessCreateBo;
+import com.qs.serve.modules.third.entity.ProcessCreateCostApplyBo;
+import com.qs.serve.modules.third.entity.ProcessCreatePolicyCostBo;
 import com.qs.serve.modules.third.service.PortalOfCostApplication;
 import lombok.AllArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@@ -26,14 +27,25 @@ public class PortalOfCostController {
     private PortalOfCostApplication portalOfCostApplication;
 
     /**
-     * 一站式创建费用
+     * 一站式创建费用(费用申请)
      * @param createBo
      * @return
      */
-    @PostMapping("create")
+    //@PostMapping("createByCostApply")
-    public R<?> createCostProcess(@Valid @RequestBody ProcessCreateBo createBo){
+    public R<?> createCostProcess(@Valid @RequestBody ProcessCreateCostApplyBo createBo){
         portalOfCostApplication.createCostProcess(createBo);
         return R.ok();
     }
 
+    /**
+     * 一站式创建费用(政策)
+     * @param createBo
+     * @return
+     */
+    @PostMapping("createByPolicy")
+    public R<?> createCostProcess2(@Valid @RequestBody ProcessCreatePolicyCostBo createBo){
+        portalOfCostApplication.createCostProcessByPolicy(createBo);
+        return R.ok();
+    }
+
 }

src/main/java/com/qs/serve/modules/third/entity/ProcessCreateBo.java → src/main/java/com/qs/serve/modules/third/entity/ProcessCreateCostApplyBo.java

@@ -11,7 +11,7 @@ import java.util.List;
  * @since 2023/2/14
  */
 @Data
-public class ProcessCreateBo {
+public class ProcessCreateCostApplyBo {
 
     /** 员工编码(申请人/操作人) */
     @NotNull(message = "员工编码 不能为空")

src/main/java/com/qs/serve/modules/third/entity/ProcessCreatePolicyCostBo.java

@@ -0,0 +1,46 @@
+package com.qs.serve.modules.third.entity;
+
+import lombok.Data;
+
+import javax.validation.constraints.NotNull;
+import java.math.BigDecimal;
+import java.util.List;
+
+/**
+ * @author YenHex
+ * @since 2023/2/14
+ */
+@Data
+public class ProcessCreatePolicyCostBo {
+
+    /** 政策明细编码 */
+    @NotNull(message = "政策明细编码 不能为空")
+    private String policyItemCode;
+
+    /** 员工编码(申请人/操作人) */
+    @NotNull(message = "员工编码 不能为空")
+    private String userCode;
+
+    /** 暂无应用场景，记录在支付表(可为空) */
+    private String erpCode;
+
+    /** 费用编码 */
+    @NotNull(message = "费用编码 不能为空")
+    private String costCode;
+
+    /** 费用主题 */
+    @NotNull(message = "费用主题 不能为空")
+    private String costTheme;
+
+    /** 发票号 */
+    @NotNull(message = "发票号 不能为空")
+    private String billNumber;
+
+    /** 统计金额 */
+    @NotNull(message = "合计金额 不能为空")
+    private BigDecimal totalAmount;
+
+    @NotNull(message = "存货编码 不能为空")
+    private List<ProcessGoodsItem> goodsList;
+
+}

src/main/java/com/qs/serve/modules/third/service/PortalOfCostApplication.java

@@ -14,7 +14,6 @@ import com.qs.serve.modules.bms.service.BmsSupplierService;
 import com.qs.serve.modules.goods.entity.GoodsCategory;
 import com.qs.serve.modules.goods.entity.GoodsSku;
 import com.qs.serve.modules.goods.entity.GoodsSpu;
-import com.qs.serve.modules.goods.entity.dto.TbsCenterDto;
 import com.qs.serve.modules.goods.service.GoodsCategoryService;
 import com.qs.serve.modules.goods.service.GoodsSkuService;
 import com.qs.serve.modules.goods.service.GoodsSpuService;
@@ -30,8 +29,13 @@ import com.qs.serve.modules.tbs.common.TbsCostApplyState;
 import com.qs.serve.modules.tbs.entity.*;
 import com.qs.serve.modules.tbs.entity.dto.TbsBudgetCostResult;
 import com.qs.serve.modules.tbs.service.*;
-import com.qs.serve.modules.third.entity.ProcessCreateBo;
+import com.qs.serve.modules.third.entity.ProcessCreateCostApplyBo;
+import com.qs.serve.modules.third.entity.ProcessCreatePolicyCostBo;
 import com.qs.serve.modules.third.entity.ProcessGoodsItem;
+import com.qs.serve.modules.tzc.entity.TzcPolicy;
+import com.qs.serve.modules.tzc.entity.TzcPolicyItem;
+import com.qs.serve.modules.tzc.service.TzcPolicyItemService;
+import com.qs.serve.modules.tzc.service.TzcPolicyService;
 import com.qs.serve.modules.vtb.common.VtbVerificationState;
 import com.qs.serve.modules.vtb.entity.VtbVerification;
 import com.qs.serve.modules.vtb.entity.VtbVerificationSubject;
@@ -72,10 +76,10 @@ public class PortalOfCostApplication {
 
     private SysUserService userService;
 
+    private TbsCostApplyService costApplyService;
     private TbsCostUnItemService costUnItemService;
     private TbsBudgetLogService budgetLogService;
     private TbsBudgetApplicationService budgetApplicationService;
-    private TbsCostApplyService costApplyService;
 
     private GoodsSkuService goodsSkuService;
     private GoodsSpuService goodsSpuService;
@@ -87,9 +91,289 @@ public class PortalOfCostApplication {
     private VtbVerificationService verificationService;
     private VtbVerificationSubjectService verificationSubjectService;
 
+    private TzcPolicyService policyService;
+    private TzcPolicyItemService policyItemServiceService;
+
+
+
+    @Transactional(rollbackFor = Exception.class)
+    public void createCostProcessByPolicy(ProcessCreatePolicyCostBo createBo){
+        SysUser user = userService.getByAccount(createBo.getUserCode());
+        if(user==null){Assert.throwEx("用户不存在，请重新编辑");}
+        TzcPolicyItem policyItem = policyItemServiceService.getByPolicyItemCode(createBo.getPolicyItemCode());
+        if(policyItem==null){ Assert.throwEx("政策项不存在，请重新编辑");}
+        BmsSupplier supplier = supplierService.getById(policyItem.getSupplierId());
+        BmsSubject subject = subjectService.getById(policyItem.getSubjectId());
+        //发票号
+        String billNumber = createBo.getBillNumber();
+        //拦截是否已保存
+        LambdaQueryWrapper<PayPayment> payLqw = new LambdaQueryWrapper<>();
+        payLqw.eq(PayPayment::getBillNumber,billNumber);
+        long countPay = paymentService.count(payLqw);
+        if(countPay>0){Assert.throwEx("发票号已存在，请勿重复提交");}
+        //初始化sku列表
+        List<ProcessGoodsItem> processGoodsItems = createBo.getGoodsList();
+        List<GoodsSku> skuList = this.initSkuListOfProcess(createBo.getGoodsList());
+        //常用参数
+        final String GOODS_TYPE = "sku";
+        final String CENTER_TYPE = "customer";
+        final BigDecimal OneHundred = new BigDecimal("100");
+        LocalDateTime nowTime = LocalDateTime.now();
+        LocalDate nowDate = LocalDate.now();
+        String erpCode = createBo.getErpCode();
+        Long supplierId = Long.parseLong(supplier.getId());
+        BigDecimal totalAmount = createBo.getTotalAmount();
+        String costCode = createBo.getCostCode();
+        String costTheme = createBo.getCostTheme();
+        String random = String.format("%03d",new Random().nextInt(999));
+        String activityCode = "G"+ StringUtils.genShortId() + random;
+        String activityTitle = "由核销API生成的活动";
+        //构建费用申请
+        TbsCostApply costApply = new TbsCostApply();
+        costApply.setCode(costCode);
+        costApply.setChargeTheme(costTheme);
+        costApply.setChargeState(TbsCostApplyState.State_3_finished.getCode());
+        costApply.setSupplierId(supplierId);
+        costApply.setSupplierName(supplier.getName());
+        costApply.setSupplierCode(supplier.getCode());
+        costApply.setUserId(user.getId());
+        costApply.setUserCode(user.getCode());
+        costApply.setUserName(user.getName());
+        costApply.setTotalActivity(1);
+        costApply.setTotalActivityAmount(totalAmount);
+        costApply.setTotalActivityUsedAmount(totalAmount);
+        //构建活动
+        TbsActivity activity = new TbsActivity();
+        activity.setActivityCode(activityCode);
+        activity.setActivityState(TbsActivityState.STATE_1_Finished);
+        activity.setCostPassFlag(1);
+        activity.setCostPassTime(nowTime);
+        activity.setActTitle(activityTitle);
+        activity.setSupplierId(supplierId);
+        activity.setSupplierName(supplier.getName());
+        activity.setSupplierCode(supplier.getCode());
+        activity.setActStartDate(nowDate);
+        activity.setActEndDate(nowDate);
+        activity.setPreStartDate(nowDate);
+        activity.setPreEndDate(nowDate);
+        activity.setPreCheckDate(nowDate);
+        activity.setTotalAmount(totalAmount);
+        activity.setUsedAmount(totalAmount);
+        activity.setFinishedFlag(ResultFlag.OK);
+        activity.setFinishedTime(nowTime);
+        //活动-科目
+        TbsActivitySubject activitySubject = new TbsActivitySubject();
+        activitySubject.setSubjectId(subject.getId());
+        activitySubject.setSubjectCode(subject.getSubjectCode());
+        activitySubject.setSubjectName(subject.getSubjectName());
+        activitySubject.setAmount(totalAmount);
+        activitySubject.setUsedAmount(totalAmount);
+        activitySubject.setCountSession(0);
+        activitySubject.setCountPerson(0);
+
+        //活动-成本中心
+        TbsActivityCenter activityCenter = new TbsActivityCenter();
+        activityCenter.setSubjectId(subject.getId());
+        activityCenter.setCenterAmount(totalAmount);
+        activityCenter.setCenterRate(OneHundred);
+        activityCenter.setCenterType(CENTER_TYPE);
+        activityCenter.setCenterId(supplier.getId());
+        activityCenter.setCenterName(supplier.getName());
+        activityCenter.setCenterCode(supplier.getCode());
+        activityCenter.setUsedAmount(totalAmount);
+
+        //活动-商品
+        List<TbsActivityGoods> activityGoodsList = new ArrayList<>();
+        for (GoodsSku sku : skuList) {
+            GoodsSpu goodsSpu = goodsSpuService.getById(sku.getSpuId());
+            GoodsCategory category1 = goodsCategoryService.getById(goodsSpu.getCategoryFirst());
+            GoodsCategory category2 = goodsCategoryService.getById(goodsSpu.getCategorySecond());
+            GoodsCategory category3 = goodsCategoryService.getById(goodsSpu.getCategoryThird());
+            TbsActivityGoods activityGoods = new TbsActivityGoods();
+            activityGoods.setTargetType(GOODS_TYPE);
+            activityGoods.setTargetId(sku.getId());
+            activityGoods.setTargetCode(sku.getSkuCode());
+            activityGoods.setTargetName(sku.getSpecInfos());
+            activityGoods.setTargetLevelPathIds(category1.getId()+"_"+category2.getId()+"_"+category3.getId()+"_"+goodsSpu.getId()+"_"+sku.getId());
+            activityGoods.setTargetLevelPathNames(category1.getName()+"_"+category2.getName()+"_"+category3.getName()+"_"+goodsSpu.getName()+"_"+sku.getSpecInfos());
+            activityGoodsList.add(activityGoods);
+        }
+        //活动-商品与成本中心记录
+        List<TbsActivityCenterGoods> activityCenterGoodsList = new ArrayList<>();
+        for (int i = 0; i < activityGoodsList.size(); i++) {
+            TbsActivityGoods activityGoods = activityGoodsList.get(i);
+            TbsActivityCenterGoods centerGoods = new TbsActivityCenterGoods();
+            centerGoods.setActivityCode(activity.getActivityCode());
+            centerGoods.setCenterGoodsCode(activity.getActivityCode()+"_"+(i+1));
+            centerGoods.setSupplierId(supplierId);
+            centerGoods.setSupplierCode(supplier.getCode());
+            centerGoods.setSupplierName(supplier.getName());
+            //设置成本中心
+            centerGoods.setCenterType(CENTER_TYPE);
+            centerGoods.setCenterId(supplier.getId());
+            centerGoods.setCenterCode(supplier.getCode());
+            centerGoods.setCenterName(supplier.getName());
+            centerGoods.setCenterRate(OneHundred);
+            centerGoods.setCenterAmount(totalAmount);
+            //设置科目
+            centerGoods.setSubjectId(subject.getId());
+            centerGoods.setSubjectCode(subject.getSubjectCode());
+            centerGoods.setSubjectName(subject.getSubjectName());
+            //设置活动时间
+            centerGoods.setActEndDate(nowDate);
+            centerGoods.setActStartDate(nowDate);
+            centerGoods.setPreEndDate(nowDate);
+            centerGoods.setPreStartDate(nowDate);
+            centerGoods.setPreCheckDate(nowDate);
+            //设置目标
+            centerGoods.setTargetId(activityGoods.getTargetId());
+            centerGoods.setTargetType(activityGoods.getTargetType());
+            centerGoods.setTargetCode(activityGoods.getTargetCode());
+            centerGoods.setTargetName(activityGoods.getTargetName());
+            centerGoods.setTargetLevelPathIds(activityGoods.getTargetLevelPathIds());
+            centerGoods.setTargetLevelPathNames(activityGoods.getTargetLevelPathNames());
+            // 分配金额
+            for (ProcessGoodsItem goodsItem : processGoodsItems) {
+                if(goodsItem.getInventoryCode().equals(activityGoods.getTargetCode())){
+                    BigDecimal rate = goodsItem.getAmount().divide(totalAmount, RoundingMode.UP);
+                    centerGoods.setCenterGoodsAmount(goodsItem.getAmount());
+                    centerGoods.setCenterGoodsRate(rate);
+                    centerGoods.setUsedAmount(goodsItem.getAmount());
+                    break;
+                }
+            }
+            activityCenterGoodsList.add(centerGoods);
+        }
+
+        //保存活动有关数据
+        costApplyService.save(costApply);
+        activity.setCostApplyId(costApply.getId());
+        activityService.save(activity);
+        activitySubject.setCostApplyId(costApply.getId());
+        activitySubject.setActivityId(activity.getId());
+        activitySubjectService.save(activitySubject);
+        activityCenter.setCostApplyId(costApply.getId());
+        activityCenter.setActivityId(activity.getId());
+        activityCenterService.save(activityCenter);
+        activityGoodsList.forEach(item->{
+            item.setCostApplyId(costApply.getId());
+            item.setActivityId(activity.getId());
+        });
+        activityGoodsService.saveBatch(activityGoodsList);
+        activityCenterGoodsList.forEach(item->{
+            item.setCostApplyId(costApply.getId());
+            item.setActivityId(activity.getId());
+        });
+        activityCenterGoodsService.saveBatch(activityCenterGoodsList);
+
+        //获取匹配的预算结果
+        TbsBudgetCostResult budgetCostResult = budgetApplicationService.buildBudgetCostResult(
+                costApply.getId(),
+                Arrays.asList(activity),
+                Arrays.asList(activitySubject),
+                activityCenterGoodsList,
+                Arrays.asList(activityCenter),true,false,false);
+
+        //不匹配的商品，保存到无预算表
+        List<TbsBudgetCostItem> unMatchBudgetItem =  budgetCostResult.getBudgetUnMatchList();
+        List<TbsCostUnItem> costUnItemList = new ArrayList<>();
+        if(CollectionUtil.isNotEmpty(unMatchBudgetItem)){
+            for (TbsBudgetCostItem budgetCostItem : unMatchBudgetItem) {
+                TbsCostUnItem costUnItem = budgetCostItem.toTbsCostUnItem(activity);
+                costUnItemList.add(costUnItem);
+            }
+        }
+        costUnItemService.saveBatch(costUnItemList);
+
+        //TODO 修改预算日志，记录政策使用情况
+        //匹配的商品，生成预算日志
+        List<TbsBudgetCostItem> matchBudgetItem =  budgetCostResult.getBudgetMatchList();
+        List<TbsBudgetLog> budgetLogList = new ArrayList<>();
+        if(CollectionUtil.isNotEmpty(matchBudgetItem)){
+            for (TbsBudgetCostItem costItem : matchBudgetItem) {
+                TbsBudget currBudget = null;
+                for (TbsBudget budget : budgetCostResult.getBudgetList()) {
+                    if(costItem.getBudgetId().equals(budget.getId())){
+                        currBudget = budget;
+                        break;
+                    }
+                }
+                TbsBudgetLog budgetLog = budgetLogService.buildTbsBudgetLog(BudgetLogOptFlag.State_11,user, costApply, costItem, currBudget,costItem.getCenterGoodsAmount().negate(),activity);
+                budgetLogList.add(budgetLog);
+            }
+        }
+        budgetLogService.saveBatch(budgetLogList);
+
+        //保存核销申请
+        VtbVerification verification = new VtbVerification();
+        verification.setVerificationCode("HX"+ IdUtil.timeStampId());
+        verification.setFinishedTime(nowTime);
+        verification.setVerificationState(VtbVerificationState.Finished.getCode());
+        verification.setActivityId(activity.getId());
+        verification.setSupplierId(activity.getSupplierId());
+        verification.setSupplierCode(activity.getSupplierCode());
+        verification.setSupplierName(activity.getSupplierName());
+        verification.setUserId(user.getId());
+        verification.setUserCode(user.getCode());
+        verification.setUserName(user.getName());
+        verification.setAmount(totalAmount);
+        verification.setAmountRecord(totalAmount);
+        verification.setPaymentState(ResultFlag.OK);
+        verificationService.save(verification);
+
+        //保存核销费用结果
+        VtbVerificationSubject verificationSubject = new VtbVerificationSubject();
+        verificationSubject.setVerificationId(verification.getId());
+        verificationSubject.setVerificationSubCode(verification.getVerificationCode()+"_1");
+        verificationSubject.setCostApplyId(costApply.getId());
+        verificationSubject.setActivityId(activity.getId());
+        verificationSubject.setSubjectId(subject.getId());
+        verificationSubject.setSubjectCode(subject.getSubjectCode());
+        verificationSubject.setSubjectName(subject.getSubjectName());
+        verificationSubject.setSupplierId(Long.parseLong(supplier.getId()));
+        verificationSubject.setSupplierCode(supplier.getCode());
+        verificationSubject.setSupplierName(supplier.getName());
+        verificationSubject.setPayFinishedFlag(ResultFlag.OK);
+        verificationSubject.setUsedAmount(totalAmount);
+        verificationSubject.setUsedAmountRecord(totalAmount);
+        verificationSubject.setCountPerson(0);
+        verificationSubject.setCountSession(0);
+        verificationSubjectService.save(verificationSubject);
+
+        //保存支付
+        PayPayment payPayment = new PayPayment();
+        payPayment.setPayType(PaymentType.PAYMENT);
+        payPayment.setPayCode("PM"+ StringUtils.genShortId());
+        payPayment.setSupplierId(supplierId);
+        payPayment.setSupplierCode(supplier.getCode());
+        payPayment.setSupplierName(supplier.getName());
+        payPayment.setPayAmount(totalAmount);
+        payPayment.setUserId(user.getId());
+        payPayment.setUserCode(user.getCode());
+        payPayment.setUserName(user.getName());
+        payPayment.setPayTime(nowTime);
+        payPayment.setErpCode(erpCode);
+        payPayment.setBillNumber(billNumber);
+        paymentService.save(payPayment);
+
+        PayPaymentItem paymentItem = new PayPaymentItem();
+        paymentItem.setPaymentId(payPayment.getId());
+        paymentItem.setPayType(PaymentType.PAYMENT);
+        paymentItem.setSupplierId(supplierId);
+        paymentItem.setItemPayAmount(totalAmount);
+        paymentItem.setVerificationId(verification.getId());
+        paymentItem.setVerificationSubjectId(verificationSubject.getId());
+        paymentItem.setCostApplyId(costApply.getId());
+        paymentItem.setActivityId(activity.getId());
+        paymentItem.setActivityCode(activity.getActivityCode());
+        paymentItem.setSubjectId(subject.getId());
+        paymentItem.setSubjectCode(subject.getSubjectCode());
+        paymentItem.setSubjectName(subject.getSubjectName());
+        paymentItemService.save(paymentItem);
+    }
 
     @Transactional(rollbackFor = Exception.class)
-    public void createCostProcess(ProcessCreateBo createBo){
+    public void createCostProcess(ProcessCreateCostApplyBo createBo){
         SysUser user = userService.getByAccount(createBo.getUserCode());
         if(user==null){Assert.throwEx("用户不存在，请重新编辑");}
         BmsSupplier supplier = supplierService.getByCode(createBo.getCustomerCode(),createBo.getCustomerBelong());
@@ -105,7 +389,7 @@ public class PortalOfCostApplication {
         if(countPay>0){Assert.throwEx("发票号已存在，请勿重复提交");}
         //初始化sku列表
         List<ProcessGoodsItem> processGoodsItems = createBo.getGoodsList();
-        List<GoodsSku> skuList = this.initSkuListOfProcess(createBo);
+        List<GoodsSku> skuList = this.initSkuListOfProcess(createBo.getGoodsList());
         //常用参数
         final String GOODS_TYPE = "sku";
         final String CENTER_TYPE = "customer";
@@ -374,13 +658,13 @@ public class PortalOfCostApplication {
 
     /**
      * 创建流程中，初始化SKU列表
-     * @param createBo
+     * @param goodsList
      * @return
      */
-    private List<GoodsSku> initSkuListOfProcess(ProcessCreateBo createBo) {
+    private List<GoodsSku> initSkuListOfProcess(List<ProcessGoodsItem> goodsList) {
         List<GoodsSku> goodsSkus = null;
-        if(CollectionUtil.isNotEmpty(createBo.getGoodsList())){
+        if(CollectionUtil.isNotEmpty(goodsList)){
-            List<String> invCodes = createBo.getGoodsList().stream()
+            List<String> invCodes = goodsList.stream()
                     .map(ProcessGoodsItem::getInventoryCode).distinct().collect(Collectors.toList());
             LambdaQueryWrapper<GoodsSku> skuLqw = new LambdaQueryWrapper<>();
             skuLqw.in(GoodsSku::getSkuCode,invCodes);

src/main/java/com/qs/serve/modules/tzc/controller/TzcPolicyController.java

@@ -10,8 +10,11 @@ import com.qs.serve.common.util.AuthContextUtils;
 import com.qs.serve.common.util.PageUtil;
 import com.qs.serve.common.util.CopierUtil;
 import com.qs.serve.common.util.StringUtils;
+import com.qs.serve.modules.tbs.entity.dto.TbsBudgetCostResult;
+import com.qs.serve.modules.tbs.entity.vo.TbsBudgetTableVo;
 import com.qs.serve.modules.tzc.common.TzcPolicyStatus;
 import com.qs.serve.modules.tzc.entity.TzcPolicyItem;
+import com.qs.serve.modules.tzc.service.TzcPolicyApplication;
 import com.qs.serve.modules.tzc.service.TzcPolicyItemService;
 import lombok.AllArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@@ -38,6 +41,18 @@ public class TzcPolicyController {
 
     private TzcPolicyService tzcPolicyService;
     private TzcPolicyItemService tzcPolicyItemService;
+    private TzcPolicyApplication policyApplication;
+
+    /**
+     * 预览
+     * @param id
+     * @return
+     */
+    @GetMapping("preview")
+    public R<TbsBudgetTableVo> preview(Long id){
+        TbsBudgetCostResult result = policyApplication.buildBudgetCostResult(id,false,true);
+        return R.ok(result.getTableData());
+    }
 
     /**
      * 翻页

src/main/java/com/qs/serve/modules/tzc/service/TzcPolicyApplication.java

@@ -4,8 +4,12 @@ import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.qs.serve.common.util.Assert;
 import com.qs.serve.common.util.CollectionUtil;
 import com.qs.serve.modules.sys.service.SysConfigService;
+import com.qs.serve.modules.tbs.common.TbsGoodsType;
+import com.qs.serve.modules.tbs.common.util.TbsBudgetCostUtil;
 import com.qs.serve.modules.tbs.entity.*;
 import com.qs.serve.modules.tbs.entity.dto.TbsBudgetCostResult;
+import com.qs.serve.modules.tbs.entity.dto.TbsBudgetItemCostResult;
+import com.qs.serve.modules.tbs.entity.vo.TbsBudgetTableVo;
 import com.qs.serve.modules.tbs.mapper.TbsBudgetMapper;
 import com.qs.serve.modules.tbs.mapper.TbsScheduleItemBudgetMapper;
 import com.qs.serve.modules.tbs.service.TbsBudgetApplicationService;
@@ -17,6 +21,7 @@ import com.qs.serve.modules.tzc.entity.TzcPolicyGoods;
 import com.qs.serve.modules.tzc.entity.TzcPolicyItem;
 import lombok.AllArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
+import org.jetbrains.annotations.NotNull;
 import org.springframework.stereotype.Service;
 
 import java.math.BigDecimal;
@@ -33,6 +38,7 @@ import java.util.stream.Collectors;
 public class TzcPolicyApplication {
 
     private TzcPolicyService tzcPolicyService;
+    private TzcPolicyItemService tzcPolicyItemService;
     private TzcPolicyGoodsService tzcPolicyGoodsService;
     private TbsBudgetApplicationService budgetApplicationService;
     private TbsScheduleItemBudgetService tbsScheduleItemBudgetService;
@@ -49,21 +55,25 @@ public class TzcPolicyApplication {
         //
     }
 
+    public TbsBudgetCostResult buildBudgetCostResult(Long policyId,
+                                                     Boolean throwEx,
+                                                     Boolean buildTableFlag){
+        Boolean overspend = false;
+        List<TzcPolicyItem> policyItemList = tzcPolicyItemService.listByPolicyId(policyId);
+        return this.buildBudgetCostResult(policyId,policyItemList,overspend,throwEx,buildTableFlag);
+    }
+
     /**
      * 创建费用占用结果
-     * @param costApplyId 用于加载历史预算时，排除当前费用占比
+     * @param policyId 用于加载历史预算时，排除当前费用占比
-     * @param policyList 政策列表
      * @param policyItemList 政策项列表
-     * @param policyGoodsList 政策商品
      * @param overspend 是否支持超出预算
      * @param throwEx 是否需要抛出异常
      * @param buildTableFlag 创建表VO
      * @return
      */
-    public TbsBudgetCostResult buildBudgetCostResult(Long costApplyId,
+    public TbsBudgetCostResult buildBudgetCostResult(Long policyId,
-                                                     List<TzcPolicy> policyList,
                                                      List<TzcPolicyItem> policyItemList,
-                                                     List<TzcPolicyGoods> policyGoodsList,
                                                      Boolean overspend,
                                                      Boolean throwEx,
                                                      Boolean buildTableFlag){
@@ -71,7 +81,7 @@ public class TzcPolicyApplication {
         List<Long> budgetIds = new ArrayList<>();
         //没有预算的活动
         Set<Long> noBudgetPolicyIds = new HashSet<>();
-        //所有满足条件的考核期，用于加载历史核销费用
+        //所有满足条件的考核期，用于加载历史核销费用,并设置不满足时间条件的预算
         List<TbsScheduleItemBudget> scheduleItemList = this.loadScheduleBudgetAndSetting(policyItemList, budgetIds, noBudgetPolicyIds);
         List<String> centerIds = policyItemList.stream().map(TzcPolicyItem::getCenterId).collect(Collectors.toList());
         List<Long> subjectIds = policyItemList.stream().map(TzcPolicyItem::getSubjectId).distinct().collect(Collectors.toList());
@@ -89,7 +99,7 @@ public class TzcPolicyApplication {
         List<TbsBudget> noConditionBudgetList = new ArrayList<>();
         //加载预算条件和关联预算匹配,返回是否由无条件预算
         boolean budgetNoCondition = budgetApplicationService.loadConditionByBudgetsAndMatch(budgetList, noConditionBudgetList);
-        //预算条件需包含活动条件， Map结构：活动id->满足的预算id列表
+        //预算条件需包含活动条件， Map结构：政策id->满足的预算id列表
         Map<Long,List<Long>> policyAllowBudgetIdMap = this.buildPolicyBudgetMap(policyItemList, budgetList, noConditionBudgetList);
         //活动拦截
         if(!budgetNoCondition){
@@ -100,9 +110,10 @@ public class TzcPolicyApplication {
         //统计费用申请占用金额
         Map<Long,BigDecimal> budgetItemApplyAmountMap = new HashMap<>(scheduleItemList.size());
         for (TbsScheduleItemBudget itemBudget : scheduleItemList) {
-            BigDecimal budgetItemApplyAmount =  tbsScheduleItemBudgetMapper.totalApplyAmount(itemBudget.getId(),costApplyId);
+            //TODO 需要重新检查这里
+            BigDecimal budgetItemApplyAmount =  tbsScheduleItemBudgetMapper.totalApplyAmount(itemBudget.getId(),policyId);
             budgetItemApplyAmountMap.put(itemBudget.getId(),budgetItemApplyAmount);
-            BigDecimal budgetItemAmount = tbsScheduleItemBudgetMapper.totalCostAmount(itemBudget.getBudgetId(),itemBudget.getScheduleItemId(),costApplyId);
+            BigDecimal budgetItemAmount = tbsScheduleItemBudgetMapper.totalCostAmount(itemBudget.getBudgetId(),itemBudget.getScheduleItemId(),policyId);
             //因为结果为负数，需去相反数
             budgetItemAmount = budgetItemAmount==null?BigDecimal.ZERO:budgetItemAmount.negate();
             budgetItemAmountMap.put(itemBudget.getId(),budgetItemAmount);
@@ -110,57 +121,149 @@ public class TzcPolicyApplication {
         //统计当前活动前置项占用预算
         Map<Long,BigDecimal> counterMap = new HashMap<>();
         //匹配预算主要方法
-        final List<TbsActivityCenterGoods> actMatchList = new ArrayList<>();
+        final List<TbsBudgetItemCostResult> actMatchList = new ArrayList<>();
-        final List<TbsActivityCenterGoods> actUnMatchList = new ArrayList<>();
+        final List<TbsBudgetItemCostResult> actUnMatchList = new ArrayList<>();
-        for (TzcPolicyGoods policyGoods : policyGoodsList) {
+        for (TzcPolicyItem policyItem : policyItemList) {
-//            this.matchPolicyMain(policyGoods,throwEx, overspend, activityList, budgetItemAmountMap, budgetList,
+            this.matchPolicyMain(policyItem,throwEx,overspend,budgetItemAmountMap,budgetList,
-//                    noConditionBudgetList, counterMap, actMatchList, actUnMatchList,policyAllowBudgetIdMap,budgetItemApplyAmountMap);
+                    noConditionBudgetList,counterMap,actMatchList,
+                    actUnMatchList,policyAllowBudgetIdMap,budgetItemApplyAmountMap);
+        }
+        List<TbsBudgetCostItemPolicy> budgetMatchList = actMatchList.stream()
+                .map(TbsBudgetItemCostResult::toBudgetCostItem).collect(Collectors.toList());
+        List<TbsBudgetCostItemPolicy> budgetUnMatchList = actUnMatchList.stream()
+                .map(TbsBudgetItemCostResult::toBudgetCostItem).collect(Collectors.toList());
+        TbsBudgetTableVo tableVo = null;
+        if(buildTableFlag){
+            //构建tableDTO
+            tableVo = this.buildBudgetTableVo(budgetItemAmountMap, budgetList, budgetMatchList, budgetUnMatchList);
+        }
+        TbsBudgetCostResult result = new TbsBudgetCostResult();
+        result.setPolicyBudgetMatchList(budgetMatchList);
+        result.setPolicyBudgetUnMatchList(budgetUnMatchList);
+        result.setTableData(tableVo);
+        result.setBudgetList(budgetList);
+        result.setPolicyItemList(policyItemList);
+        return result;
     }
-        return null;
+
+    /**
+     * 建立费用预算表
+     * @param budgetItemAmountMap
+     * @param budgetList
+     * @param budgetMatchList
+     * @param budgetUnMatchList
+     * @return
+     */
+    private TbsBudgetTableVo buildBudgetTableVo(Map<Long,BigDecimal> budgetItemAmountMap,
+                                                List<TbsBudget> budgetList,
+                                                List<TbsBudgetCostItemPolicy> budgetMatchList,
+                                                List<TbsBudgetCostItemPolicy> budgetUnMatchList) {
+        List<TbsBudgetCostItemPolicy> allBudgetItem = new ArrayList<>();
+        allBudgetItem.addAll(budgetMatchList);
+        allBudgetItem.addAll(budgetUnMatchList);
+        TbsBudgetTableVo tableVo = new TbsBudgetTableVo();
+        List<TbsBudgetTableVo.TopTheadHeader> topTheadHeaders = new ArrayList<>();
+        Map<Long,List<TbsBudgetCostItemPolicy>> tmpMap = allBudgetItem.stream().collect(Collectors.groupingBy(TbsBudgetCostItemPolicy::getScheduleItemBudgetId));
+        for (Long scheduleItemBudgetId : tmpMap.keySet()) {
+            if(scheduleItemBudgetId.equals(0L)){continue;}
+            TbsBudgetCostItemPolicy budgetCostItem = tmpMap.get(scheduleItemBudgetId).get(0);
+            String budgetCode = null;
+            for (TbsBudget budget : budgetList) {
+                if(budget.getId().equals(budgetCostItem.getBudgetId())){
+                    budgetCode = budget.getBudgetCode();
+                    break;
+                }
+            }
+            BigDecimal budgetAmount = budgetCostItem.getScheduleItemAmount();
+            String scheduleItemName = budgetCostItem.getScheduleItemName();
+            TbsBudgetTableVo.TopTheadHeader theadHeader = new TbsBudgetTableVo.TopTheadHeader();
+            theadHeader.setId(scheduleItemBudgetId+"");
+            theadHeader.setLabel(budgetCode+"("+scheduleItemName+")");
+            BigDecimal totalUsed = budgetItemAmountMap.get(scheduleItemBudgetId);
+            theadHeader.setBudgetAmount(budgetAmount.subtract(totalUsed));
+            theadHeader.setTotalAmount(budgetAmount);
+            BigDecimal applyAmount = budgetCostItem.getScheduleItemAmountApply()==null?BigDecimal.ZERO:budgetCostItem.getScheduleItemAmountApply();
+            theadHeader.setCostApplyAmount(applyAmount);
+            theadHeader.setCostAppliedAmount(totalUsed.subtract(applyAmount));
+            topTheadHeaders.add(theadHeader);
+        }
+        //自定义超额预算
+        TbsBudgetTableVo.TopTheadHeader overTopHeader = new TbsBudgetTableVo.TopTheadHeader();
+        overTopHeader.setId("0");
+        overTopHeader.setLabel("其它预算");
+        overTopHeader.setBudgetAmount(BigDecimal.ZERO);
+        topTheadHeaders.add(overTopHeader);
+
+        List<TbsBudgetTableVo.LeftTheadHeader> leftTheadHeaders = new ArrayList<>();
+        for (TbsBudgetCostItemPolicy costItemPolicy : allBudgetItem) {
+            String policyItemCode = costItemPolicy.getPolicyItemCode();
+            Long policyItemId = costItemPolicy.getPolicyItemId();
+            TbsBudgetTableVo.LeftTheadHeader theadHeader = new TbsBudgetTableVo.LeftTheadHeader();
+            theadHeader.setActivityCode(policyItemCode);
+            theadHeader.setId(costItemPolicy.getPolicyItemId()+"");
+            theadHeader.setSubjectId(costItemPolicy.getSubjectId());
+            theadHeader.setSubjectName(costItemPolicy.getSubjectName());
+            theadHeader.setCenterId(costItemPolicy.getCenterId());
+            theadHeader.setCenterName(costItemPolicy.getCenterName());
+            theadHeader.setTargetType("policy_item");
+            theadHeader.setTargetId(policyItemId);
+            theadHeader.setLabel(policyItemCode);
+            theadHeader.setLabelCombo(policyItemCode);
+            leftTheadHeaders.add(theadHeader);
+        }
+        List<TbsBudgetTableVo.TableValue> tableValueList = new ArrayList<>();
+        for (TbsBudgetCostItemPolicy costItem : allBudgetItem) {
+            TbsBudgetTableVo.TableValue tableValue = new TbsBudgetTableVo.TableValue();
+            tableValue.setTopId(costItem.getScheduleItemBudgetId()+"");
+            tableValue.setLeftId(costItem.getPolicyId()+"");
+            tableValue.setValue(costItem.getPolicyItemAmount());
+            tableValueList.add(tableValue);
+        }
+        tableVo.setTableValueList(tableValueList);
+        tableVo.setTopTheadHeaderList(topTheadHeaders);
+        tableVo.setLeftTheadHeaderList(leftTheadHeaders);
+        return tableVo;
     }
 
     /**
      * 匹配的主要方法
-     * @param policyGoods 政策商品
+     * @param policyItem 政策项
      * @param throwEx 预算不够时抛出异常
      * @param overspend 超值标识
-     * @param policyItemList 所有政策项
      * @param budgetItemAmountMap 统计所有占用预算金额
      * @param allBudgetList 所有预算
      * @param noConditionBudgetList 没有条件的预算列表
      * @param counterMap 历史预算占用
      * @param actMatchList 匹配预算占用的费用(含超支预算)
      * @param actUnMatchList 没有匹配预算的费用
-     * @param activityAllowBudgetIdMap 满足当前活动项的费用idMap
+     * @param allowBudgetIdMap 满足当前活动项的费用idMap
      * @param budgetItemApplyAmountMap 统计费用申请占用金额
      */
-    private void matchPolicyMain(TzcPolicyGoods policyGoods,
+    private void matchPolicyMain(TzcPolicyItem policyItem,
                                    Boolean throwEx,
                                    boolean overspend,
-                                   List<TzcPolicyItem> policyItemList,
                                    Map<Long,BigDecimal> budgetItemAmountMap,
                                    final List<TbsBudget> allBudgetList,
                                    List<TbsBudget> noConditionBudgetList,
                                    Map<Long, BigDecimal> counterMap,
-                                   final List<TzcPolicyGoods> actMatchList,
+                                   final List<TbsBudgetItemCostResult> actMatchList,
-                                   final List<TzcPolicyGoods> actUnMatchList,
+                                   final List<TbsBudgetItemCostResult> actUnMatchList,
-                                   final Map<Long,List<Long>> activityAllowBudgetIdMap,
+                                   final Map<Long,List<Long>> allowBudgetIdMap,
                                    Map<Long,BigDecimal> budgetItemApplyAmountMap) {
+        TbsBudgetItemCostResult budgetItemCostResult = new TbsBudgetItemCostResult();
+        budgetItemCostResult.setPolicyItem(policyItem);
         //过滤满全条件的预算
-        List<Long> allowBudgetIds = activityAllowBudgetIdMap.get(policyGoods.getPolicyItemId());
+        List<Long> allowBudgetIds = allowBudgetIdMap.get(policyItem.getId());
-        List<TbsBudget> budgetList = allBudgetList.stream().filter(obj->allowBudgetIds.contains(obj.getId())).collect(Collectors.toList());
         //PS：排序规则：优先为时间条件，其次匹配品牌条件
+        List<TbsBudget> budgetList = allBudgetList.stream().filter(obj->allowBudgetIds.contains(obj.getId())).collect(Collectors.toList());
         //按品类条件,提取可用预算(列表已按小维度到大维度排列)
-        List<TbsBudget> currentItemBudgetList = budgetApplicationService.filterMatchGoodsCondition(budgetList, policyGoods.getTargetLevelPathIds());
+        List<TzcPolicyGoods> policyGoodsList = tzcPolicyGoodsService.listByItemId(policyItem.getId());
+        List<String> levelPathIdsList = policyGoodsList.stream().map(TzcPolicyGoods::getTargetLevelPathIds).collect(Collectors.toList());
+        List<TbsBudget> currentItemBudgetList = this.filterMatchGoodsCondition(budgetList, levelPathIdsList);
         //关联无条件预算
         currentItemBudgetList.addAll(noConditionBudgetList);
         //提取可用预算的考核期
         List<TbsScheduleItemBudget> currentScheduleItemBudgets = new ArrayList<>();
-        for (TzcPolicyItem policyItem : policyItemList) {
-            //忽略重叠情况
-            if(!policyGoods.getPolicyItemId().equals(policyItem.getId())){
-                continue;
-            }
         //当前科目
         Long subjectId = policyItem.getSubjectId();
         //拦截非当前成本中心
@@ -181,82 +284,122 @@ public class TzcPolicyApplication {
                 }
             }
         }
-        }
         //检测是否有是否足够预算
-//        BigDecimal goodsAmount = activityCostItem.getCenterGoodsAmount();
+        BigDecimal goodsAmount = policyItem.getDiscountMax();
-//        if(CollectionUtil.isNotEmpty(currentScheduleItemBudgets)){
+        if(CollectionUtil.isNotEmpty(currentScheduleItemBudgets)){
-//            boolean isMatch = false;
+            boolean isMatch = false;
-//            for (TbsScheduleItemBudget itemBudget : currentScheduleItemBudgets) {
+            for (TbsScheduleItemBudget itemBudget : currentScheduleItemBudgets) {
-//                //历史费用(含申请占用金额)
+                //历史费用(含申请占用金额)
-//                BigDecimal totalUsed = budgetItemAmountMap.get(itemBudget.getId());
+                BigDecimal totalUsed = budgetItemAmountMap.get(itemBudget.getId());
-//                //当前项费用
+                //当前项费用
-//                BigDecimal budgetAmount = itemBudget.getBudgetAmount();
+                BigDecimal budgetAmount = itemBudget.getBudgetAmount();
-//                //前置费用
+                //前置费用
-//                BigDecimal lastAmount =  counterMap.get(itemBudget.getId());
+                BigDecimal lastAmount =  counterMap.get(itemBudget.getId());
-//                if(lastAmount==null){
+                if(lastAmount==null){
-//                    lastAmount = BigDecimal.ZERO;
+                    lastAmount = BigDecimal.ZERO;
-//                }
+                }
-//                //判断是否够用
+                //判断是否够用
-//                if(budgetAmount.subtract(lastAmount).subtract(totalUsed).compareTo(goodsAmount)>0){
+                if(budgetAmount.subtract(lastAmount).subtract(totalUsed).compareTo(goodsAmount)>0){
-//                    activityCostItem.setBudgetId(itemBudget.getBudgetId());
+                    budgetItemCostResult.setBudgetId(itemBudget.getBudgetId());
-//                    activityCostItem.setScheduleId(itemBudget.getScheduleId());
+                    budgetItemCostResult.setScheduleId(itemBudget.getScheduleId());
-//                    activityCostItem.setScheduleItemId(itemBudget.getScheduleItemId());
+                    budgetItemCostResult.setScheduleItemId(itemBudget.getScheduleItemId());
-//                    activityCostItem.setScheduleItemBudgetId(itemBudget.getId());
+                    budgetItemCostResult.setScheduleItemBudgetId(itemBudget.getId());
-//                    activityCostItem.setScheduleItemName(itemBudget.getItemName());
+                    budgetItemCostResult.setScheduleItemName(itemBudget.getItemName());
-//                    //绑定录入时可用预算
+                    //绑定录入时可用预算
-//                    activityCostItem.setScheduleItemAmount(budgetAmount);
+                    budgetItemCostResult.setScheduleItemAmount(budgetAmount);
-//                    //剩余的可用预算
+                    //剩余的可用预算
-//                    activityCostItem.setScheduleItemAmountUsed(totalUsed);
+                    budgetItemCostResult.setScheduleItemAmountUsed(totalUsed);
-//                    activityCostItem.setScheduleItemAmountApply(budgetItemApplyAmountMap.get(itemBudget.getId()));
+                    budgetItemCostResult.setScheduleItemAmountApply(budgetItemApplyAmountMap.get(itemBudget.getId()));
-//                    isMatch = true;
+                    isMatch = true;
-//                    //记录当前费用使用考核期费用
+                    //记录当前费用使用考核期费用
-//                    lastAmount = lastAmount.add(goodsAmount);
+                    lastAmount = lastAmount.add(goodsAmount);
-//                    counterMap.put(itemBudget.getId(),lastAmount);
+                    counterMap.put(itemBudget.getId(),lastAmount);
-//                    actMatchList.add(activityCostItem);
+                    actMatchList.add(budgetItemCostResult);
-//                    break;
+                    break;
-//                }
+                }
-//            }
+            }
-//            //无匹配的预算
+            //无匹配的预算
-//            if(!isMatch){
+            if(!isMatch){
-//                if (throwEx){
+                if (throwEx){
-//                    Assert.throwEx("品类["+ activityCostItem.getTargetName()+"]预算不足");
+                    Assert.throwEx("政策["+ policyItem.getPolicyItemCode()+"]预算不足");
-//                }
+                }
-//                if(overspend){
+                if(overspend){
-//                    TbsScheduleItemBudget itemBudget = currentScheduleItemBudgets.get(0);
+                    TbsScheduleItemBudget itemBudget = currentScheduleItemBudgets.get(0);
-//                    activityCostItem.setBudgetId(itemBudget.getBudgetId());
+                    budgetItemCostResult.setBudgetId(itemBudget.getBudgetId());
-//                    activityCostItem.setScheduleId(itemBudget.getScheduleId());
+                    budgetItemCostResult.setScheduleId(itemBudget.getScheduleId());
-//                    activityCostItem.setScheduleItemId(itemBudget.getScheduleItemId());
+                    budgetItemCostResult.setScheduleItemId(itemBudget.getScheduleItemId());
-//                    activityCostItem.setScheduleItemBudgetId(itemBudget.getId());
+                    budgetItemCostResult.setScheduleItemBudgetId(itemBudget.getId());
-//                    activityCostItem.setScheduleItemName(itemBudget.getItemName());
+                    budgetItemCostResult.setScheduleItemName(itemBudget.getItemName());
-//                    //记录当前费用使用考核期费用
+                    //记录当前费用使用考核期费用
-//                    BigDecimal lastAmount = counterMap.get(itemBudget.getId());
+                    BigDecimal lastAmount = counterMap.get(itemBudget.getId());
-//                    if(lastAmount==null){
+                    if(lastAmount==null){
-//                        lastAmount = BigDecimal.ZERO;
+                        lastAmount = BigDecimal.ZERO;
-//                    }
+                    }
-//                    lastAmount = lastAmount.add(goodsAmount);
+                    lastAmount = lastAmount.add(goodsAmount);
-//                    counterMap.put(itemBudget.getId(),lastAmount);
+                    counterMap.put(itemBudget.getId(),lastAmount);
-//                    actMatchList.add(activityCostItem);
+                    actMatchList.add(budgetItemCostResult);
-//                }else{
+                }else{
-//                    activityCostItem.setBudgetId(0L);
+                    budgetItemCostResult.setBudgetId(0L);
-//                    activityCostItem.setScheduleId(0L);
+                    budgetItemCostResult.setScheduleId(0L);
-//                    activityCostItem.setScheduleItemId(0L);
+                    budgetItemCostResult.setScheduleItemId(0L);
-//                    activityCostItem.setScheduleItemBudgetId(0L);
+                    budgetItemCostResult.setScheduleItemBudgetId(0L);
-//                    activityCostItem.setScheduleItemName("无");
+                    budgetItemCostResult.setScheduleItemName("无");
-//                    actUnMatchList.add(activityCostItem);
+                    actUnMatchList.add(budgetItemCostResult);
-//                }
+                }
-//            }
+            }
-//        }else {
+        }else {
-//            if(throwEx){
+            if(throwEx){
-//                Assert.throwEx("品类["+ activityCostItem.getTargetName()+"]无可用预算");
+                Assert.throwEx("政策["+ policyItem.getPolicyItemCode()+"]无可用预算");
-//            }
+            }
-//            //添加到预算超支表
+            //添加到预算超支表
-//            activityCostItem.setBudgetId(0L);
+            budgetItemCostResult.setBudgetId(0L);
-//            activityCostItem.setScheduleId(0L);
+            budgetItemCostResult.setScheduleId(0L);
-//            activityCostItem.setScheduleItemId(0L);
+            budgetItemCostResult.setScheduleItemId(0L);
-//            activityCostItem.setScheduleItemBudgetId(0L);
+            budgetItemCostResult.setScheduleItemBudgetId(0L);
-//            activityCostItem.setScheduleItemName("无");
+            budgetItemCostResult.setScheduleItemName("无");
-//            actUnMatchList.add(activityCostItem);
+            actUnMatchList.add(budgetItemCostResult);
-//        }
+        }
+    }
+
+    /**
+     * 按品类条件,提取可用预算
+     * @param budgetList 预算(已关联参数_条件列表)
+     * @param levelPathIdsList
+     * @return
+     */
+    @NotNull
+    public List<TbsBudget> filterMatchGoodsCondition(List<TbsBudget> budgetList,List<String> levelPathIdsList) {
+        List<TbsBudget> currentItemBudgetList = new ArrayList<>();
+        for (TbsBudget budget : budgetList) {
+            if(budget.getConditionFlag().equals(1)){
+                List<TbsBudgetCondition> budgetConditionListByBudget = budget.getBudgetConditionList();
+                boolean anyUnMatch = true;
+                for (String levelPath : levelPathIdsList) {
+                    boolean match = false;
+                    Set<String> levelPathSet = new LinkedHashSet<>();
+                    levelPathSet.add(levelPath);
+                    TbsBudgetCostUtil.buildPaths(levelPath,levelPathSet);
+                    for (String conditionString : levelPathSet) {
+                        if(!match){
+                            for (TbsBudgetCondition budgetCondition : budgetConditionListByBudget) {
+                                if(budgetCondition.getTargetLevelPathIds().contains(conditionString)){
+                                    match = true;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    if(!match){
+                        anyUnMatch = false;
+                        break;
+                    }
+                }
+                if(!anyUnMatch){
+                    currentItemBudgetList.add(budget);
+                }
+            }
+        }
+        return currentItemBudgetList;
     }
 
     /**

src/main/java/com/qs/serve/modules/tzc/service/TzcPolicyItemService.java

@@ -16,6 +16,8 @@ public interface TzcPolicyItemService extends IService<TzcPolicyItem> {
 
     List<TzcPolicyItem> listByPolicyId(Long id);
 
+    TzcPolicyItem getByPolicyItemCode(String code);
+
     R<?> modify(TzcPolicyItemBo param);
 
 }

src/main/java/com/qs/serve/modules/tzc/service/impl/TzcPolicyItemServiceImpl.java

@@ -48,6 +48,13 @@ public class TzcPolicyItemServiceImpl extends ServiceImpl<TzcPolicyItemMapper,Tz
     private GoodsApplicationService goodsApplicationService;
     private TzcPolicyGoodsService tzcPolicyGoodsService;
 
+    @Override
+    public TzcPolicyItem getByPolicyItemCode(String code) {
+        LambdaQueryWrapper<TzcPolicyItem> lqw = new LambdaQueryWrapper<>();
+        lqw.eq(TzcPolicyItem::getPolicyItemCode,code);
+        return this.getOne(lqw,false);
+    }
+
     @Override
     public List<TzcPolicyItem> listByPolicyId(Long id) {
         LambdaQueryWrapper<TzcPolicyItem> lqw = new LambdaQueryWrapper<>();