add package

rankin-data-api/src/main/java/cn/rankin/data/api/product/dto/PackageDTO.java

@@ -0,0 +1,24 @@
+package cn.rankin.data.api.product.dto;
+
+import cn.rankin.common.utils.enums.BaseStatusEnum;
+import lombok.Data;
+import lombok.ToString;
+
+import java.util.List;
+
+@Data
+@ToString
+public class PackageDTO {
+
+    private String id;
+
+    private String code;
+
+    private String name;
+
+    private Integer sort;
+
+    private BaseStatusEnum status;
+
+    private List<PackageProductDTO> products;
+}

rankin-data-api/src/main/java/cn/rankin/data/api/product/dto/PackageProductDTO.java

@@ -0,0 +1,16 @@
+package cn.rankin.data.api.product.dto;
+
+import lombok.Data;
+import lombok.ToString;
+
+import java.io.Serializable;
+import java.math.BigDecimal;
+
+@Data
+@ToString
+public class PackageProductDTO implements Serializable {
+
+    private String productId;
+
+    private BigDecimal cpPrice;
+}

rankin-data-api/src/main/java/cn/rankin/data/api/product/entity/Package.java

@@ -1,6 +1,7 @@
 package cn.rankin.data.api.product.entity;
 
 import cn.rankin.common.utils.enums.BaseStatusEnum;
+import cn.rankin.data.api.product.vo.PackageProductVo;
 import lombok.Data;
 import lombok.ToString;
 import org.hibernate.annotations.DynamicInsert;
@@ -9,6 +10,7 @@ import org.hibernate.annotations.DynamicUpdate;
 import javax.persistence.*;
 import java.io.Serializable;
 import java.util.Date;
+import java.util.List;
 
 /*
 | field | type | null | default | desc | extra |
@@ -48,4 +50,7 @@ public class Package implements Serializable {
     @Column(name = "gmt_modified", updatable = false, insertable = false, columnDefinition = "timestamp NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP")
     @Temporal(TemporalType.TIMESTAMP)
     private Date gmtModified;
+
+    @Transient
+    private List<PackageProductVo> products;
 }

rankin-data-api/src/main/java/cn/rankin/data/api/product/entity/Product.java

@@ -22,7 +22,7 @@ public class Product implements Serializable {
     @Id
     private String id;
 
-    @Column(name = "pid", nullable = false)
+    @Column(name = "pid", nullable = false, unique = true)
     private String pid;
 
     private String code;

rankin-data-api/src/main/java/cn/rankin/data/api/product/vo/PackageProductVo.java

@@ -0,0 +1,33 @@
+package cn.rankin.data.api.product.vo;
+
+import cn.rankin.common.utils.enums.BaseStatusEnum;
+import cn.rankin.common.utils.enums.ProductTypeEnum;
+import lombok.Data;
+import lombok.ToString;
+
+import java.io.Serializable;
+import java.math.BigDecimal;
+import java.util.Date;
+
+@Data
+@ToString
+public class PackageProductVo implements Serializable {
+
+    private String id;
+
+    private String pid;
+
+    private String code;
+
+    private String name;
+
+    private ProductTypeEnum type;
+
+    private BigDecimal cpPrice;
+
+    private BaseStatusEnum status;
+
+    private Date gmtCreated;
+
+    private Date gmtModified;
+}

rankin-product-service/src/main/java/cn/rankin/productservice/controller/PackageController.java

@@ -1,40 +0,0 @@
-package cn.rankin.productservice.controller;
-
-import cn.rankin.common.utils.api.model.APIResult;
-import cn.rankin.common.utils.api.page.Page;
-import cn.rankin.data.api.product.entity.Package;
-import org.springframework.web.bind.annotation.PathVariable;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RequestMethod;
-import org.springframework.web.bind.annotation.RestController;
-
-@RestController
-@RequestMapping(value = "package")
-public class PackageController {
-
-    @RequestMapping(value = "/list", method = RequestMethod.GET)
-    public APIResult<Page<Package>> search() {
-        return null;
-    }
-
-    @RequestMapping(value = "/{id}", method = RequestMethod.GET)
-    public APIResult<Package> getPackage(@PathVariable String id) {
-        return null;
-    }
-
-    @RequestMapping(method = RequestMethod.POST)
-    public APIResult<Package> create() {
-        return APIResult.ok();
-    }
-
-    @RequestMapping(method = RequestMethod.PUT)
-    public APIResult<Package> update() {
-        return APIResult.ok();
-    }
-
-    @RequestMapping(value = "/{id}", method = RequestMethod.DELETE)
-    public APIResult<Boolean> delete(@PathVariable String id) {
-        return APIResult.ok();
-    }
-
-}

rankin-product-service/src/main/java/cn/rankin/productservice/controller/ProductController.java

@@ -3,16 +3,15 @@ package cn.rankin.productservice.controller;
 import cn.rankin.common.utils.api.model.APIResult;
 import cn.rankin.common.utils.api.page.Page;
 import cn.rankin.common.utils.enums.BaseOrderEnum;
-import cn.rankin.common.utils.enums.ProductTypeEnum;
 import cn.rankin.data.api.product.dto.CourseDTO;
+import cn.rankin.data.api.product.dto.PackageDTO;
 import cn.rankin.data.api.product.dto.ProductSearchDTO;
 import cn.rankin.data.api.product.dto.SupportDTO;
 import cn.rankin.data.api.product.entity.Course;
+import cn.rankin.data.api.product.entity.Package;
 import cn.rankin.data.api.product.entity.Product;
 import cn.rankin.data.api.product.entity.Support;
-import cn.rankin.productservice.code.ProductServiceAPICode;
 import cn.rankin.productservice.service.ProductService;
-import com.alibaba.fastjson.JSON;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.*;
@@ -64,6 +63,11 @@ public class ProductController {
         return productService.update(supportDTO);
     }
 
+    @RequestMapping(value = "/package", method = RequestMethod.PUT)
+    public APIResult<Package> updatePackage(@RequestBody PackageDTO packageDTO) {
+        return productService.update(packageDTO);
+    }
+
     @RequestMapping(value = "/course", method = RequestMethod.POST)
     public APIResult<Course> createCourse(@RequestBody CourseDTO courseDTO) {
         return productService.create(courseDTO);
@@ -74,6 +78,11 @@ public class ProductController {
         return productService.create(supportDTO);
     }
 
+    @RequestMapping(value = "/package", method = RequestMethod.POST)
+    public APIResult<Package> createPackage(@RequestBody PackageDTO packageDTO) {
+        return productService.create(packageDTO);
+    }
+
     @RequestMapping(value = "/{productId}", method = RequestMethod.DELETE)
     public APIResult delete(@PathVariable("productId") String productId) {
         return productService.delete(productId);

rankin-product-service/src/main/java/cn/rankin/productservice/repository/PackageProductRelationRepository.java

@@ -2,6 +2,17 @@ package cn.rankin.productservice.repository;
 
 import cn.rankin.common.utils.jpa.BasicJpaRepository;
 import cn.rankin.data.api.product.entity.PackageProductRelation;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+
+import java.util.List;
 
 public interface PackageProductRelationRepository extends BasicJpaRepository<PackageProductRelation, String> {
+
+    @Query(value = "select r from PackageProductRelation r where r.packageId = ?1 and r.status = 0 order by r.sort")
+    List<PackageProductRelation> findByPackageId(String packageId);
+
+    @Modifying(clearAutomatically = true)
+    @Query(value = "update PackageProductRelation r set r.status = 1 where r.packageId = ?1")
+    Integer deleteByPackageId(String pkgId);
 }

rankin-product-service/src/main/java/cn/rankin/productservice/repository/PackageRepository.java

@@ -4,4 +4,6 @@ import cn.rankin.common.utils.jpa.BasicJpaRepository;
 import cn.rankin.data.api.product.entity.Package;
 
 public interface PackageRepository extends BasicJpaRepository<Package, String> {
+
+    Long countByCode(String code);
 }

rankin-product-service/src/main/java/cn/rankin/productservice/repository/ProductRepository.java

@@ -5,10 +5,15 @@ import cn.rankin.data.api.product.entity.Product;
 import org.springframework.data.jpa.repository.Modifying;
 import org.springframework.data.jpa.repository.Query;
 
+import java.util.List;
+
 public interface ProductRepository extends BasicJpaRepository<Product, String> {
 
     Product findByPid(String pid);
 
+    @Query(value = "select p from Product p where p.pid in (?1) and p.status = 0")
+    List<Product> findByPids(List<String> pids);
+
     @Modifying(clearAutomatically = true)
     @Query(value = "update Product p set p.status = 1 where p.pid = ?1")
     Integer deleteByPid(String pid);

rankin-product-service/src/main/java/cn/rankin/productservice/repository/WareRepository.java

@@ -3,6 +3,7 @@ package cn.rankin.productservice.repository;
 import cn.rankin.common.utils.enums.BaseStatusEnum;
 import cn.rankin.common.utils.jpa.BasicJpaRepository;
 import cn.rankin.data.api.product.entity.Courseware;
+import org.springframework.data.jpa.repository.Modifying;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.query.Param;
 import org.springframework.stereotype.Repository;
@@ -16,6 +17,7 @@ public interface WareRepository extends BasicJpaRepository<Courseware, String> {
 
     Long countByIdIn(List<String> Ids);
 
+    @Modifying(clearAutomatically = true)
     @Query(value = "update Courseware w set w.status = :status  where w.id = :id")
     Integer deleteAllById(@Param("id") String id, @Param("status") BaseStatusEnum status);
 

rankin-product-service/src/main/java/cn/rankin/productservice/service/CourseSubRelationService.java

@@ -10,7 +10,9 @@ import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 import static cn.rankin.productservice.utils.DTOConverter.convert;
 
@@ -37,10 +39,12 @@ public class CourseSubRelationService {
     public void update(String courseId, List<CourseSubRelationDTO> subRelationDTOList) {
         // 记录顺序数组: 最新的
         List<String> subIdList = new ArrayList<>();
+        Map<String, CourseSubRelationDTO> subRelationDTOMap = new HashMap<>();
 
         subRelationDTOList.forEach( e -> {
             String subId = e.getId();
             subIdList.add(subId);
+            subRelationDTOMap.put(subId, e);
         });
 
         // 更新现有的, 同时记录现有的关系
@@ -59,9 +63,9 @@ public class CourseSubRelationService {
         // 新加的
         List<String> newAddSubIdList = ListUtil.subtract(subIdList, currentIdList);
         if (newAddSubIdList != null && newAddSubIdList.size() > 0) {
-            subRelationDTOList.forEach( e -> {
-                String subId = e.getId();
-                currentRelationList.add(convert(courseId, e));
+            newAddSubIdList.forEach( subId -> {
+                CourseSubRelationDTO subRelationDTO = subRelationDTOMap.get(subId);
+                currentRelationList.add(convert(courseId, subRelationDTO));
             });
         }
 

rankin-product-service/src/main/java/cn/rankin/productservice/service/PackageProductRelationService.java

@@ -0,0 +1,82 @@
+package cn.rankin.productservice.service;
+
+import cn.rankin.common.utils.enums.BaseStatusEnum;
+import cn.rankin.common.utils.util.ListUtil;
+import cn.rankin.data.api.product.dto.PackageProductDTO;
+import cn.rankin.data.api.product.entity.PackageProductRelation;
+import cn.rankin.productservice.repository.PackageProductRelationRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import javax.transaction.Transactional;
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static cn.rankin.productservice.utils.DTOConverter.convert;
+
+@Service
+public class PackageProductRelationService {
+
+    @Autowired
+    private PackageProductRelationRepository packageProductRelationRepository;
+
+    public List<PackageProductRelation> findByPackageId(String packageId) {
+        return packageProductRelationRepository.findByPackageId(packageId);
+    }
+
+    @Transactional
+    public Integer deleteByPackageId(String pkgId) {
+        return packageProductRelationRepository.deleteByPackageId(pkgId);
+    }
+
+    @Transactional
+    public void updateRelation(String pkgId, List<PackageProductDTO> packageProductDTOList) {
+        // 记录顺序数组: 最新的
+        List<String> productIdList = new ArrayList<>();
+        // 记录最新的定价map
+        Map<String, PackageProductDTO> packageProductDTOMap = new HashMap<>();
+
+        packageProductDTOList.forEach( packageProductDTO -> {
+            String productId = packageProductDTO.getProductId();
+            productIdList.add(productId);
+            packageProductDTOMap.put(productId, packageProductDTO);
+        });
+
+        // 更新现有的, 同时记录现有的关系
+        List<String> currentIdList = new ArrayList<>();
+        List<PackageProductRelation> currentRelationList = packageProductRelationRepository.findByPackageId(pkgId);
+        currentRelationList.forEach( relation -> {
+            String productId = relation.getPid();
+            if (!productIdList.contains(productId)) {
+                relation.setStatus(BaseStatusEnum.DEL);
+            }else {
+                relation.setStatus(BaseStatusEnum.NORMAL);
+                PackageProductDTO packageProductDTO = packageProductDTOMap.get(productId);
+                relation.setCpPrice(packageProductDTO.getCpPrice());
+            }
+            currentIdList.add(productId);
+        });
+
+        // 新加的
+        List<String> newAddProductIdList = ListUtil.subtract(productIdList, currentIdList);
+        if (newAddProductIdList != null && newAddProductIdList.size() > 0) {
+            newAddProductIdList.forEach( productId -> {
+                PackageProductDTO packageProductDTO = packageProductDTOMap.get(productId);
+                currentRelationList.add(convert(pkgId, packageProductDTO));
+            });
+        }
+
+        // 排序
+        currentRelationList.forEach( relation -> {
+            String productId = relation.getPid();
+            Integer sort = productIdList.indexOf(productId);
+            relation.setSort(sort);
+        });
+
+        packageProductRelationRepository.save(currentRelationList);
+
+    }
+}

rankin-product-service/src/main/java/cn/rankin/productservice/service/PackageService.java

@@ -1,8 +1,28 @@
 package cn.rankin.productservice.service;
 
+import cn.rankin.common.utils.api.model.APIResult;
+import cn.rankin.common.utils.util.ListUtil;
+import cn.rankin.data.api.product.dto.PackageDTO;
+import cn.rankin.data.api.product.dto.PackageProductDTO;
+import cn.rankin.data.api.product.entity.Package;
+import cn.rankin.data.api.product.entity.PackageProductRelation;
+import cn.rankin.data.api.product.entity.Product;
+import cn.rankin.data.api.product.vo.PackageProductVo;
+import cn.rankin.productservice.code.ProductServiceAPICode;
 import cn.rankin.productservice.repository.PackageRepository;
+import cn.rankin.productservice.repository.ProductRepository;
+import cn.rankin.productservice.utils.DTOConverter;
+import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
+
+import javax.transaction.Transactional;
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 
 @Service
 public class PackageService {
@@ -10,4 +30,127 @@ public class PackageService {
     @Autowired
     private PackageRepository packageRepository;
 
+    @Autowired
+    private ProductRepository productRepository;
+
+    @Autowired
+    private PackageProductRelationService packageProductRelationService;
+
+    public boolean exists(String code) {
+        Long count = packageRepository.countByCode(code);
+        return count > 0;
+    }
+
+    public APIResult<Package> getPackage(String packageId) {
+        Package pkg = packageRepository.find(packageId);
+        if (pkg == null) {
+            return APIResult.error(ProductServiceAPICode.NOT_EXISTS);
+        }
+
+        List<PackageProductVo> packageProductVoList = getPackageProducts(packageId);
+        pkg.setProducts(packageProductVoList);
+
+        return APIResult.ok(pkg);
+    }
+
+    public List<PackageProductVo> getPackageProducts(String packageId) {
+        List<PackageProductVo> packageProductVoList = new ArrayList<>();
+
+        List<PackageProductRelation> relationList = packageProductRelationService.findByPackageId(packageId);
+        if (relationList.size() == 0) {
+            return packageProductVoList;
+        }
+
+        Map<String, BigDecimal> productPriceMap = new HashMap<>();
+        List<String> productIdList = new ArrayList<>();
+        relationList.forEach(relation -> {
+            String productId = relation.getPid();
+            BigDecimal price = relation.getCpPrice();
+            productIdList.add(productId);
+            productPriceMap.put(productId, price);
+        });
+
+        List<Product> productList = productRepository.findByPids(productIdList);
+        if (CollectionUtils.isEmpty(productList)) {
+            return packageProductVoList;
+        }
+
+        Map<String, Product> productMap = ListUtil.convert(productList, "pid", Product.class);
+        for (String productId : productIdList) {
+            Product product = productMap.get(productId);
+            if (product == null) {
+                continue;
+            }
+            PackageProductVo packageProductVo = new PackageProductVo();
+            BeanUtils.copyProperties(product, packageProductVo);
+            packageProductVo.setCpPrice(productPriceMap.get(productId));
+            packageProductVoList.add(packageProductVo);
+        }
+
+        return packageProductVoList;
+    }
+
+    @Transactional
+    public APIResult<Package> create(PackageDTO packageDTO) {
+        String code = packageDTO.getCode();
+        if (exists(code)) {
+            return APIResult.error(ProductServiceAPICode.ALREADY_EXISTS);
+        }
+
+        Package pkg = DTOConverter.convert(packageDTO);
+        Package result = packageRepository.save(pkg);
+
+        String pkgId = result.getId();
+        List<PackageProductDTO> packageProductDTOList = packageDTO.getProducts();
+
+        Boolean updateResult = updateRelation(pkgId, packageProductDTOList);
+        if (!updateResult) {
+            return APIResult.error(ProductServiceAPICode.error("产品关系更新失败"));
+        }
+
+        List<PackageProductVo> packageProductVoList = getPackageProducts(pkgId);
+        pkg.setProducts(packageProductVoList);
+
+        return APIResult.ok(result);
+    }
+
+    @Transactional
+    public APIResult<Package> update(PackageDTO packageDTO) {
+        Package pkg = DTOConverter.convert(packageDTO);
+        Package result = packageRepository.update(pkg);
+
+        String pkgId = result.getId();
+        List<PackageProductDTO> packageProductDTOList = packageDTO.getProducts();
+
+        Boolean updateResult = updateRelation(pkgId, packageProductDTOList);
+        if (!updateResult) {
+            return APIResult.error(ProductServiceAPICode.error("产品关系更新失败"));
+        }
+
+        List<PackageProductVo> packageProductVoList = getPackageProducts(pkgId);
+        pkg.setProducts(packageProductVoList);
+        return APIResult.ok(pkg);
+    }
+
+    @Transactional
+    public Boolean updateRelation(String pkgId, List<PackageProductDTO> packageProductDTOList) {
+        if (packageProductDTOList == null) {
+            return true;
+        }else if (packageProductDTOList.size() == 0) {
+            packageProductRelationService.deleteByPackageId(pkgId);
+            return true;
+        }
+
+        List<String> productIdList = new ArrayList<>();
+        packageProductDTOList.forEach(packageProductDTO -> productIdList.add(packageProductDTO.getProductId()));
+
+        List<Product> productList = productRepository.findByPids(productIdList);
+        if (productIdList.size() != productList.size()) {
+            return true;
+        }
+
+        packageProductRelationService.updateRelation(pkgId, packageProductDTOList);
+        return true;
+    }
+
 }

rankin-product-service/src/main/java/cn/rankin/productservice/service/ProductService.java

@@ -6,8 +6,10 @@ import cn.rankin.common.utils.enums.BaseOrderEnum;
 import cn.rankin.common.utils.enums.ProductTypeEnum;
 import cn.rankin.common.utils.util.JpaSortUtil;
 import cn.rankin.data.api.product.dto.CourseDTO;
+import cn.rankin.data.api.product.dto.PackageDTO;
 import cn.rankin.data.api.product.dto.SupportDTO;
 import cn.rankin.data.api.product.entity.Course;
+import cn.rankin.data.api.product.entity.Package;
 import cn.rankin.data.api.product.entity.Product;
 import cn.rankin.data.api.product.entity.Support;
 import cn.rankin.productservice.code.ProductServiceAPICode;
@@ -37,6 +39,9 @@ public class ProductService {
     @Autowired
     private SupportService supportService;
 
+    @Autowired
+    private PackageService packageService;
+
     public APIResult<Page<Product>> search(Product product, Integer pageNo, Integer pageSize, LinkedHashMap<String, BaseOrderEnum> sort) {
         Long count = productRepository.count(product);
         Page<Product> page = new Page<>(count, pageNo, pageSize);
@@ -63,9 +68,11 @@ public class ProductService {
             return courseService.getCourse(productId);
         }else if (ProductTypeEnum.SUPPORT.equals(type)) {
             return supportService.getSupport(productId);
+        }else if (ProductTypeEnum.PACKAGE.equals(type)) {
+            return packageService.getPackage(productId);
         }
 
-        return null;
+        return APIResult.error(ProductServiceAPICode.NOT_EXISTS);
     }
 
     @Transactional
@@ -89,6 +96,7 @@ public class ProductService {
         return APIResult.ok();
     }
 
+    @Transactional
     public APIResult<Course> create(CourseDTO courseDTO) {
         APIResult<Course> courseAPIResult = courseService.create(courseDTO);
         if (courseAPIResult.getSuccess()) {
@@ -99,6 +107,7 @@ public class ProductService {
         return courseAPIResult;
     }
 
+    @Transactional
     public APIResult<Support> create(SupportDTO supportDTO) {
         APIResult<Support> supportAPIResult = supportService.create(supportDTO);
         if (supportAPIResult.getSuccess()) {
@@ -109,20 +118,18 @@ public class ProductService {
         return supportAPIResult;
     }
 
-    public APIResult update(String productId, Object object) {
-        Product product = productRepository.findByPid(productId);
-        ProductTypeEnum type = product.getType();
-        if (type.equals(ProductTypeEnum.COURSE)) {
-            CourseDTO courseDTO = (CourseDTO) object;
-            return update(courseDTO);
-        }else if (type.equals(ProductTypeEnum.SUPPORT)) {
-            SupportDTO supportDTO = (SupportDTO) object;
-            return update(supportDTO);
+    @Transactional
+    public APIResult<Package> create(PackageDTO packageDTO) {
+        APIResult<Package> packageAPIResult = packageService.create(packageDTO);
+        if (packageAPIResult.getSuccess()) {
+            Product product = convert(packageAPIResult.getData());
+            productRepository.save(product);
         }
 
-        return APIResult.error(ProductServiceAPICode.NOT_EXISTS);
+        return packageAPIResult;
     }
 
+    @Transactional
     public APIResult<Course> update(CourseDTO courseDTO) {
         APIResult<Course> courseAPIResult = courseService.update(courseDTO);
         if (courseAPIResult.getSuccess()) {
@@ -133,6 +140,7 @@ public class ProductService {
         return courseAPIResult;
     }
 
+    @Transactional
     public APIResult<Support> update(SupportDTO supportDTO) {
         APIResult<Support> supportAPIResult = supportService.update(supportDTO);
         if (supportAPIResult.getSuccess()) {
@@ -142,4 +150,15 @@ public class ProductService {
 
         return supportAPIResult;
     }
+
+    @Transactional
+    public APIResult<Package> update(PackageDTO packageDTO) {
+        APIResult<Package> packageAPIResult = packageService.update(packageDTO);
+        if (packageAPIResult.getSuccess()) {
+            Product product = convert(packageAPIResult.getData());
+            productRepository.update(product);
+        }
+
+        return packageAPIResult;
+    }
 }

rankin-product-service/src/main/java/cn/rankin/productservice/utils/DTOConverter.java

@@ -1,9 +1,11 @@
 package cn.rankin.productservice.utils;
 
+import cn.rankin.common.utils.enums.BaseStatusEnum;
 import cn.rankin.common.utils.enums.CourseSubTypeEnum;
 import cn.rankin.common.utils.enums.ProductTypeEnum;
 import cn.rankin.data.api.product.dto.*;
 import cn.rankin.data.api.product.entity.*;
+import cn.rankin.data.api.product.entity.Package;
 import cn.rankin.data.api.product.vo.CourseSubItemVo;
 import org.springframework.beans.BeanUtils;
 
@@ -60,6 +62,15 @@ public class DTOConverter {
         return relation;
     }
 
+    public static PackageProductRelation convert(String pkgId, PackageProductDTO productDTO) {
+        PackageProductRelation relation = new PackageProductRelation();
+        relation.setPackageId(pkgId);
+        relation.setPid(productDTO.getProductId());
+        relation.setCpPrice(productDTO.getCpPrice());
+        relation.setStatus(BaseStatusEnum.NORMAL);
+        return relation;
+    }
+
     public static TagGroup convert(GroupDTO groupDTO) {
         TagGroup tagGroup = new TagGroup();
         BeanUtils.copyProperties(groupDTO, tagGroup);
@@ -74,6 +85,7 @@ public class DTOConverter {
 
     public static Product convert(Course course) {
         Product product = new Product();
+        product.setId(course.getId());
         product.setPid(course.getId());
         product.setCode(course.getCode());
         product.setName(course.getName());
@@ -83,10 +95,23 @@ public class DTOConverter {
 
     public static Product convert(Support support) {
         Product product = new Product();
+        product.setId(support.getId());
         product.setPid(support.getId());
         product.setCode(support.getCode());
         product.setName(support.getName());
         product.setType(ProductTypeEnum.SUPPORT);
+        product.setStatus(support.getStatus());
+        return product;
+    }
+
+    public static Product convert(Package pkg) {
+        Product product = new Product();
+        product.setId(pkg.getId());
+        product.setPid(pkg.getId());
+        product.setCode(pkg.getCode());
+        product.setName(pkg.getName());
+        product.setType(ProductTypeEnum.PACKAGE);
+        product.setStatus(pkg.getStatus());
         return product;
     }
 
@@ -95,4 +120,13 @@ public class DTOConverter {
         BeanUtils.copyProperties(goodsDTO, goods);
         return goods;
     }
+
+    public static Package convert(PackageDTO packageDTO) {
+        Package pkg = new Package();
+        pkg.setId(packageDTO.getId());
+        pkg.setCode(packageDTO.getCode());
+        pkg.setName(packageDTO.getName());
+        pkg.setStatus(packageDTO.getStatus());
+        return pkg;
+    }
 }

rankin-trade-service/pom.xml

@@ -11,36 +11,56 @@
 	<name>rankin-trade-service</name>
 	<description>Trade Service For Spring Cloud</description>
 
-	<parent>
-		<groupId>org.springframework.boot</groupId>
-		<artifactId>spring-boot-starter-parent</artifactId>
-		<version>1.5.8.RELEASE</version>
-		<relativePath/> <!-- lookup parent from repository -->
-	</parent>
+    <parent>
+        <groupId>cn.rankin</groupId>
+        <artifactId>rankin</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+        <relativePath>../pom.xml</relativePath>
+    </parent>
 
-	<properties>
-		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
-		<java.version>1.8</java.version>
-		<spring-cloud.version>Dalston.SR4</spring-cloud.version>
-	</properties>
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
+        <java.version>1.8</java.version>
+        <spring-cloud.version>Dalston.SR4</spring-cloud.version>
+    </properties>
 
-	<dependencies>
-		<dependency>
-			<groupId>org.springframework.cloud</groupId>
-			<artifactId>spring-cloud-starter-config</artifactId>
-		</dependency>
-		<dependency>
-			<groupId>org.springframework.cloud</groupId>
-			<artifactId>spring-cloud-starter-eureka</artifactId>
-		</dependency>
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.cloud</groupId>
+            <artifactId>spring-cloud-starter-config</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.cloud</groupId>
+            <artifactId>spring-cloud-starter-eureka</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-jpa</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>mysql</groupId>
+            <artifactId>mysql-connector-java</artifactId>
+        </dependency>
 
-		<dependency>
-			<groupId>org.springframework.boot</groupId>
-			<artifactId>spring-boot-starter-test</artifactId>
-			<scope>test</scope>
-		</dependency>
-	</dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>cn.rankin</groupId>
+            <artifactId>rankin-common-utils</artifactId>
+            <version>0.0.1-SNAPSHOT</version>
+        </dependency>
+
+        <dependency>
+            <groupId>cn.rankin</groupId>
+            <artifactId>rankin-data-api</artifactId>
+            <version>0.0.1-SNAPSHOT</version>
+        </dependency>
+    </dependencies>
 
 	<dependencyManagement>
 		<dependencies>