version 1.0 dev

rankin-common-utils/src/main/java/cn/rankin/common/utils/api/model/APICodeManager.java

@@ -29,6 +29,9 @@ public class APICodeManager {
     public final static int _C_OPERATE_ERROR = 1001;
     public final static APICode OPERATE_ERROR = new APICode(_C_OPERATE_ERROR, "操作失败");
 
+    public final static int _C_CAN_NOT_DEL = 1002;
+    public final static APICode CAN_NOT_DEL = new APICode(_C_CAN_NOT_DEL, "无法删除");
+
     public static APICode ok(String message) {
         return new APICode(_C_OK, message);
     }

rankin-common-utils/src/main/java/cn/rankin/common/utils/dto/product/CourseDTO.java

@@ -3,8 +3,6 @@ package cn.rankin.common.utils.dto.product;
 import cn.rankin.common.utils.enums.BaseStatusEnum;
 import lombok.Data;
 
-import javax.persistence.EnumType;
-import javax.persistence.Enumerated;
 import java.io.Serializable;
 import java.util.*;
 
@@ -25,17 +23,16 @@ public class CourseDTO implements Serializable {
 
     private String keyword;
 
-    private String cvImgIds;
+    private String cvImgList;
 
-    private String bgImgIds;
+    private String bgImgList;
 
-    @Enumerated(EnumType.ORDINAL)
     private BaseStatusEnum status;
 
     // 有序
-    private List<SubRelationDTO> subList;
+    private List<CourseSubRelationDTO> subItemList;
 
-    private List<SupportDTO> supportList;
+    private List<String> supportList;
 
 }
 

rankin-common-utils/src/main/java/cn/rankin/common/utils/dto/product/SubRelationDTO.java

@@ -6,7 +6,7 @@ import lombok.Data;
 import java.io.Serializable;
 
 @Data
-public class SubRelationDTO implements Serializable {
+public class CourseSubRelationDTO implements Serializable {
 
     private String id;
 

rankin-common-utils/src/main/java/cn/rankin/common/utils/dto/product/GroupDTO.java

@@ -0,0 +1,28 @@
+package cn.rankin.common.utils.dto.product;
+
+import cn.rankin.common.utils.enums.BaseStatusEnum;
+import lombok.Data;
+
+import javax.validation.constraints.NotNull;
+import java.io.Serializable;
+import java.util.List;
+
+@Data
+public class GroupDTO implements Serializable {
+
+    private String id;
+
+    @NotNull
+    private String code;
+
+    private String name;
+
+    @NotNull
+    private String merchantId;
+
+    private Integer sort;
+
+    private List<TagDTO> tagList;
+
+    private BaseStatusEnum status;
+}

rankin-common-utils/src/main/java/cn/rankin/common/utils/dto/product/ItemDTO.java

@@ -6,7 +6,6 @@ import lombok.Data;
 
 import java.io.Serializable;
 import java.util.List;
-import java.util.Set;
 
 @Data
 public class ItemDTO implements Serializable {
@@ -29,5 +28,5 @@ public class ItemDTO implements Serializable {
 
     private List<ItemPriceDTO> priceList;
 
-    private Set<String> tagList;
+    private List<String> tagList;
 }

rankin-common-utils/src/main/java/cn/rankin/common/utils/dto/product/LessonDTO.java

@@ -1,7 +1,9 @@
 package cn.rankin.common.utils.dto.product;
 
+import cn.rankin.common.utils.enums.BaseStatusEnum;
 import lombok.Data;
 
+import javax.validation.constraints.NotNull;
 import java.io.Serializable;
 import java.util.List;
 
@@ -10,6 +12,7 @@ public class LessonDTO implements Serializable {
 
     private String id;
 
+    @NotNull
     private String code;
 
     private String name;
@@ -18,6 +21,8 @@ public class LessonDTO implements Serializable {
 
     private Integer sort;
 
-    private List<WareDTO> wareList;
+    private BaseStatusEnum status;
+
+    private List<String> wareList;
 
 }

rankin-common-utils/src/main/java/cn/rankin/common/utils/dto/product/SupportDTO.java

@@ -4,7 +4,7 @@ import cn.rankin.common.utils.enums.BaseStatusEnum;
 import lombok.Data;
 
 import java.io.Serializable;
-import java.util.Set;
+import java.util.List;
 
 @Data
 public class SupportDTO implements Serializable {
@@ -21,10 +21,10 @@ public class SupportDTO implements Serializable {
 
     private String detail;
 
-    private String imgIds;
+    private String imgList;
 
     private BaseStatusEnum status;
 
-    private Set<String> supportList;
+    private List<String> supportList;
 
 }

rankin-common-utils/src/main/java/cn/rankin/common/utils/dto/product/TagDTO.java

@@ -1,25 +1,23 @@
 package cn.rankin.common.utils.dto.product;
 
 import cn.rankin.common.utils.enums.BaseStatusEnum;
-import cn.rankin.common.utils.enums.TagTypeEnum;
 import lombok.Data;
 
 import java.io.Serializable;
+import java.util.List;
 
 @Data
 public class TagDTO implements Serializable {
 
     private String id;
 
-    private String code;
+    private String groupId;
 
     private String name;
 
-    private TagTypeEnum type;
-
-    private String merchantId;
-
     private Integer sort;
 
+    private List<String> itemList;
+
     private BaseStatusEnum status;
 }

rankin-common-utils/src/main/java/cn/rankin/common/utils/dto/product/WareDTO.java

@@ -1,7 +1,6 @@
 package cn.rankin.common.utils.dto.product;
 
 import cn.rankin.common.utils.enums.BaseStatusEnum;
-import cn.rankin.common.utils.enums.WareTypeEnum;
 import lombok.Data;
 
 import javax.validation.constraints.NotNull;
@@ -20,12 +19,7 @@ public class WareDTO implements Serializable {
 
     private String digest;
 
-    @NotNull
-    private WareTypeEnum type;
-
-    private String playUrl;
-
-    private List<String> imgIds;
+    private List<String> resourceList;
 
     private String cpId;
 

rankin-common-utils/src/main/java/cn/rankin/common/utils/dto/search/TagSearchDTO.java

@@ -1,11 +1,13 @@
 package cn.rankin.common.utils.dto.search;
 
+import cn.rankin.common.utils.enums.BaseStatusEnum;
+import cn.rankin.common.utils.enums.WareTypeEnum;
 import lombok.Data;
 
 import java.io.Serializable;
 
 @Data
-public class TagSearchDTO implements Serializable {
+public class GroupSearchDTO implements Serializable{
 
     private String code;
 
@@ -13,6 +15,8 @@ public class TagSearchDTO implements Serializable {
 
     private String merchantId;
 
+    private BaseStatusEnum status;
+
     private String sort;
 
     private Integer by;

rankin-common-utils/src/main/java/cn/rankin/common/utils/dto/search/SearchDTO.java

@@ -1,5 +1,6 @@
 package cn.rankin.common.utils.dto.search;
 
+import cn.rankin.common.utils.enums.BaseStatusEnum;
 import cn.rankin.common.utils.enums.WareTypeEnum;
 import lombok.Data;
 
@@ -12,7 +13,7 @@ public class SearchDTO implements Serializable {
 
     private String name;
 
-    private WareTypeEnum type;
+    private BaseStatusEnum status;
 
     private String sort;
 

rankin-common-utils/src/main/java/cn/rankin/common/utils/enums/EnumUtil.java

@@ -0,0 +1,33 @@
+package cn.rankin.common.utils.enums;
+
+public class EnumUtil {
+
+    public static boolean compare(ItemTypeEnum itemType, TagTypeEnum tagType) {
+        switch (tagType) {
+            default:
+                return false;
+            case COURSE:
+                if (itemType.equals(ItemTypeEnum.COURSE)) {
+                    return true;
+                }
+                break;
+            case SUPPORT:
+                if (itemType.equals(ItemTypeEnum.SUPPORT)) {
+                    return true;
+                }
+                break;
+            case TRAINING:
+                if (itemType.equals(ItemTypeEnum.COURSE)) {
+                    return true;
+                }
+                break;
+        }
+        return false;
+    }
+
+    public static void main(String[] args) {
+        boolean diff = compare(ItemTypeEnum.COURSE, TagTypeEnum.SUPPORT);
+        System.out.println(diff);
+    }
+
+}

rankin-common-utils/src/main/java/cn/rankin/common/utils/enums/ItemTypeEnum.java

@@ -22,4 +22,10 @@ public enum ItemTypeEnum {
         }
         return null;
     }
+
+    public static void main(String[] args) {
+        ItemTypeEnum courseType = ItemTypeEnum.COURSE;
+        TagTypeEnum tagType = TagTypeEnum.COURSE;
+        System.out.println(courseType.name().equals(tagType.name()));
+    }
 }

rankin-common-utils/src/main/java/cn/rankin/common/utils/util/JpaSortUtil.java

@@ -0,0 +1,29 @@
+package cn.rankin.common.utils.util;
+
+import cn.rankin.common.utils.enums.BaseOrderEnum;
+import org.springframework.data.domain.Sort;
+import org.springframework.util.CollectionUtils;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+
+public class JpaSortUtil {
+
+    public static Sort sort(LinkedHashMap<String,BaseOrderEnum> sortMap){
+        if (CollectionUtils.isEmpty(sortMap)) {
+            return null;
+        }
+
+        List<Sort.Order> sorts = new ArrayList<>();
+        sortMap.forEach((prop, order) -> {
+            if (BaseOrderEnum.ASC.equals(order)) {
+                sorts.add(new Sort.Order(Sort.Direction.ASC, prop));
+            } else {
+                sorts.add(new Sort.Order(Sort.Direction.DESC, prop));
+            }
+        });
+
+        return new Sort(sorts);
+    }
+}

rankin-common-utils/src/main/java/cn/rankin/common/utils/util/ListToMapUtil.java

@@ -1,49 +0,0 @@
-package cn.rankin.common.utils.util;
-
-import cn.rankin.common.utils.dto.product.LessonDTO;
-import com.alibaba.fastjson.JSON;
-import lombok.Data;
-
-import java.lang.reflect.Field;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-@Data
-public class ListToMapUtil<K, V> {
-
-    private List<V> list = new ArrayList<>();
-
-    public ListToMapUtil(List<V> list) {
-        this.list = list;
-    }
-
-    public Map<K, V> parse(String key) {
-        Map<K, V> map = new HashMap<>();
-        list.forEach(v -> {
-            K k = null;
-            try {
-                Field field = v.getClass().getDeclaredField(key);
-                field.setAccessible(true);
-                k = (K) field.get(v);
-            }catch (Exception e) {
-                throw new RuntimeException(e.getCause());
-            }
-            map.put((K) k, v);
-        });
-        return map;
-    }
-
-    public static void main(String[] args) {
-        List<LessonDTO> list = new ArrayList<>();
-        for (int i = 0; i < 10; i++) {
-            LessonDTO tmp = new LessonDTO();
-            tmp.setCode(String.valueOf(i));
-            list.add(tmp);
-        }
-
-        ListToMapUtil<String, LessonDTO> mapUtil = new ListToMapUtil(list);
-        System.out.println(JSON.toJSONString(mapUtil.parse("code")));
-    }
-}

rankin-common-utils/src/main/java/cn/rankin/common/utils/util/ListUtil.java

@@ -0,0 +1,69 @@
+package cn.rankin.common.utils.util;
+
+import cn.rankin.common.utils.dto.product.LessonDTO;
+import com.alibaba.fastjson.JSON;
+import lombok.Data;
+
+import java.beans.PropertyDescriptor;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@Data
+public class ListUtil {
+
+    public static <K, V> Map<K, V> convert(List<V> list, String fieldName4Key, Class<V> c) {
+        Map<K, V> map = new HashMap<K, V>();
+        if (list != null) {
+            try {
+                PropertyDescriptor propDesc = new PropertyDescriptor(fieldName4Key, c);
+                Method methodGetKey = propDesc.getReadMethod();
+                for (int i = 0; i < list.size(); i++) {
+                    V value = list.get(i);
+                    @SuppressWarnings("unchecked")
+                    K key = (K) methodGetKey.invoke(list.get(i));
+                    map.put(key, value);
+                }
+            } catch (Exception e) {
+                throw new IllegalArgumentException("field can't match the key!");
+            }
+        }
+
+        return map;
+    }
+
+    public static <T> List<T> subtract(List<T> source, List<T> target) {
+        if (source == null) {
+            return null;
+        }else if (source.size() == 0) {
+            return new ArrayList<>();
+        }
+
+        if (target == null || target.size() == 0) {
+            return source;
+        }
+
+        List<T> result = new ArrayList<>();
+        source.forEach( s -> {
+            if (!target.contains(s)) {
+                result.add(s);
+            }
+        });
+
+        return result;
+    }
+
+    public static void main(String[] args) {
+        List<LessonDTO> list = new ArrayList<>();
+        for (int i = 0; i < 10; i++) {
+            LessonDTO tmp = new LessonDTO();
+            tmp.setCode(String.valueOf(i));
+            list.add(tmp);
+        }
+
+        Map<String, LessonDTO> test = ListUtil.convert(list, "code", LessonDTO.class);
+        System.out.println(JSON.toJSONString(test));
+    }
+}

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

@@ -1,17 +1,29 @@
 package cn.rankin.productservice.controller;
 
+import cn.rankin.common.utils.api.model.APICode;
 import cn.rankin.common.utils.api.model.APICodeManager;
 import cn.rankin.common.utils.api.model.APIResult;
 import cn.rankin.common.utils.dto.product.CourseDTO;
+import cn.rankin.common.utils.dto.product.CourseSubRelationDTO;
 import cn.rankin.common.utils.dto.search.SearchDTO;
 import cn.rankin.common.utils.api.page.Page;
-import cn.rankin.productservice.entity.Course;
-import cn.rankin.productservice.service.CourseService;
+import cn.rankin.common.utils.enums.BaseOrderEnum;
+import cn.rankin.common.utils.enums.CourseSubTypeEnum;
+import cn.rankin.productservice.entity.*;
+import cn.rankin.productservice.proxy.CourseServiceProxy;
+import cn.rankin.productservice.service.*;
+import cn.rankin.productservice.vo.CourseSubItemVo;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.transaction.interceptor.TransactionAspectSupport;
 import org.springframework.web.bind.annotation.*;
 
+import java.util.LinkedHashMap;
+import java.util.List;
+
+
 @Slf4j
 @RestController
 @RequestMapping(value = "course")
@@ -20,6 +32,12 @@ public class CourseController {
     @Autowired
     private CourseService courseService;
 
+    @Autowired
+    private CourseServiceProxy courseServiceProxy;
+
+    @Autowired
+    private ItemService itemService;
+
     @RequestMapping(value = "/list", method = RequestMethod.GET)
     public APIResult<Page<Course>> getWareList(SearchDTO searchDTO) {
         Course course = new Course();
@@ -34,10 +52,16 @@ public class CourseController {
             course.setName("%" + name + "%");
         }
 
-        return courseService.search(course, searchDTO.getPageNo(), searchDTO.getPageSize());
+        course.setStatus(searchDTO.getStatus());
+
+        LinkedHashMap<String, BaseOrderEnum> sort = new LinkedHashMap<>();
+        sort.put("gmtModified", BaseOrderEnum.DESC);
+
+        return courseService.search(course, searchDTO.getPageNo(), searchDTO.getPageSize(), sort);
     }
 
     // 创建资源
+    @Transactional
     @RequestMapping(method = RequestMethod.POST)
     public APIResult<Course> create(@RequestBody CourseDTO courseDTO) {
         String code = courseDTO.getCode();
@@ -49,27 +73,100 @@ public class CourseController {
             return APIResult.error(APICodeManager.ALREADY_EXISTS);
         }
 
-        return courseService.create(courseDTO);
+        APIResult<Course> result = courseService.create(courseDTO);
+        if (!result.getSuccess()) {
+            return result;
+        }
+
+        Course course = result.getData();
+        String courseId = result.getData().getId();
+
+        // 更新二级关系
+        List<CourseSubRelationDTO> subRelationList = courseDTO.getSubItemList();
+        if (subRelationList != null) {
+            APIResult<List<CourseSubItemVo>> subResult = courseServiceProxy.updateSubRelation(courseId, subRelationList);
+            if (!subResult.getSuccess()) {
+                // 显示回滚
+                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+                return APIResult.error(new APICode(subResult.getCode(), subResult.getMessage()));
+            }
+            course.setSubItemList(subResult.getData());
+        }
+
+        // 更新周边关系
+        List<String> supportIdList = courseDTO.getSupportList();
+        if (supportIdList != null) {
+            APIResult<List<Support>> supportResult = courseServiceProxy.updateSupportRelation(courseId, supportIdList);
+            if (!supportResult.getSuccess()) {
+                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+                return APIResult.error(new APICode(supportResult.getCode(), supportResult.getMessage()));
+            }
+            course.setSupportList(supportResult.getData());
+        }
+
+        return result;
     }
 
     // 修改资源
+    @Transactional
     @RequestMapping(method = RequestMethod.PUT)
     public APIResult<Course> update(@RequestBody CourseDTO courseDTO) {
         if (courseDTO.getId() == null) {
             return APIResult.error(APICodeManager.PARAMETER_ERROR);
         }
 
-        return courseService.update(courseDTO);
+        APIResult<Course> result = courseService.update(courseDTO);
+        if (!result.getSuccess()) {
+            return result;
+        }
+
+        Course course = result.getData();
+        String courseId = result.getData().getId();
+
+
+        // 更新二级关系
+        List<CourseSubRelationDTO> subRelationList = courseDTO.getSubItemList();
+        if (subRelationList != null) {
+            APIResult<List<CourseSubItemVo>> subResult = courseServiceProxy.updateSubRelation(courseId, subRelationList);
+            if (!subResult.getSuccess()) {
+                // 显示回滚
+                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+                return APIResult.error(new APICode(subResult.getCode(), subResult.getMessage()));
+            }
+            course.setSubItemList(subResult.getData());
+        }
+
+        // 更新周边关系
+        List<String> supportIdList = courseDTO.getSupportList();
+        if (supportIdList != null) {
+            APIResult<List<Support>> supportResult = courseServiceProxy.updateSupportRelation(courseId, supportIdList);
+            if (!supportResult.getSuccess()) {
+                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+                return APIResult.error(new APICode(supportResult.getCode(), supportResult.getMessage()));
+            }
+            course.setSupportList(supportResult.getData());
+        }
+
+        return result;
     }
 
     // 删除
     @RequestMapping(value = "/{id}", method = RequestMethod.DELETE)
-    public APIResult<Boolean> delete(@PathVariable("id") String id) {
+    public APIResult delete(@PathVariable("id") String id) {
         if (StringUtils.isEmpty(id)) {
             return APIResult.error(APICodeManager.PARAMETER_ERROR);
         }
 
-        return courseService.delete(id);
+        APIResult<List<Item>> itemResult = itemService.findAllBySubId(id);
+        if (itemResult.getData() == null || itemResult.getData().size() == 0) {
+            return courseService.delete(id);
+        }
+
+        APIResult<List<Item>> result = APIResult.error(APICodeManager.CAN_NOT_DEL);
+        result.setData(itemResult.getData());
+
+        return result;
+
     }
 
     @RequestMapping(value = "/{id}", method = RequestMethod.GET)
@@ -78,7 +175,20 @@ public class CourseController {
             return APIResult.error(APICodeManager.PARAMETER_ERROR);
         }
 
-        return courseService.findById(id);
-    }
+        APIResult<Course> result = courseService.findById(id);
+        Course course = result.getData();
+        if (!result.getSuccess() || course == null) {
+            return result;
+        }
 
+        // subItem set
+        List<CourseSubItemVo> subItemVoList = courseServiceProxy.findSubItemVo(id);
+        course.setSubItemList(subItemVoList);
+
+        // support set
+        List<Support> supportList = courseServiceProxy.findSupportList(id);
+        course.setSupportList(supportList);
+
+        return result;
+    }
 }

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

@@ -0,0 +1,130 @@
+package cn.rankin.productservice.controller;
+
+import cn.rankin.common.utils.api.model.APICode;
+import cn.rankin.common.utils.api.model.APIResult;
+import cn.rankin.common.utils.api.page.Page;
+import cn.rankin.common.utils.dto.product.GroupDTO;
+import cn.rankin.common.utils.dto.product.TagDTO;
+import cn.rankin.common.utils.dto.search.GroupSearchDTO;
+import cn.rankin.common.utils.enums.BaseOrderEnum;
+import cn.rankin.productservice.entity.Group;
+import cn.rankin.productservice.entity.Tag;
+import cn.rankin.productservice.service.GroupService;
+import cn.rankin.productservice.service.TagService;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.util.CollectionUtils;
+import org.springframework.web.bind.annotation.*;
+
+import javax.validation.Valid;
+import java.util.LinkedHashMap;
+import java.util.List;
+
+@RestController
+@RequestMapping(value = "group")
+public class GroupController {
+
+    @Autowired
+    private GroupService groupService;
+
+    @Autowired
+    private TagService tagService;
+
+    @RequestMapping(value = "/list", method = RequestMethod.GET)
+    public APIResult<Page<Group>> search(GroupSearchDTO searchDTO) {
+        Group group = new Group();
+
+        String code = searchDTO.getCode();
+        if (!StringUtils.isEmpty(code)) {
+            group.setCode("%" + code + "%");
+        }
+
+        String name = searchDTO.getName();
+        if (!StringUtils.isEmpty(name)) {
+            group.setName("%" + name + "%");
+        }
+
+        // others
+        group.setStatus(searchDTO.getStatus());
+        group.setMerchantId(searchDTO.getMerchantId());
+
+        // sort
+        LinkedHashMap<String, BaseOrderEnum> sort = new LinkedHashMap<>();
+        sort.put("gmtModified", BaseOrderEnum.DESC);
+
+        return groupService.search(group, searchDTO.getPageNo(), searchDTO.getPageSize(), sort);
+    }
+
+    @Transactional
+    @RequestMapping(method = RequestMethod.POST)
+    public APIResult<Group> create(@Valid @RequestBody GroupDTO groupDTO) {
+
+        APIResult<Group> result = groupService.create(groupDTO);
+        if (!result.getSuccess()) {
+            return result;
+        }
+
+        Group group = result.getData();
+
+        List<TagDTO> tagDTOList = groupDTO.getTagList();
+        if (!CollectionUtils.isEmpty(tagDTOList)) {
+            APIResult<List<Tag>> tagResult = tagService.updateGroupRelation(group.getId(), tagDTOList);
+            group.setTagList(tagResult.getData());
+        }
+
+        return result;
+    }
+
+    @Transactional
+    @RequestMapping(method = RequestMethod.PUT)
+    public APIResult<Group> update(@Valid @RequestBody GroupDTO groupDTO) {
+        APIResult<Group> result = groupService.update(groupDTO);
+        if (!result.getSuccess()) {
+            return result;
+        }
+
+        Group group = result.getData();
+
+        List<TagDTO> tagDTOList = groupDTO.getTagList();
+        if (tagDTOList != null) {
+            APIResult<List<Tag>> tagResult = tagService.updateGroupRelation(group.getId(), tagDTOList);
+            if (!tagResult.getSuccess()) {
+                return APIResult.error(new APICode(tagResult.getCode(), tagResult.getMessage()));
+            }
+            group.setTagList(tagResult.getData());
+        }
+
+        return result;
+    }
+
+    @RequestMapping(value = "/{id}", method = RequestMethod.DELETE)
+    public APIResult<Boolean> delete(@PathVariable String id) {
+        APIResult<Boolean> groupResult = groupService.delete(id);
+        if (!groupResult.getSuccess()) {
+            return groupResult;
+        }
+
+        // 同时删除下属所有tag
+        return tagService.deleteByGroupId(id);
+    }
+
+    @RequestMapping(value = "/{id}", method = RequestMethod.GET)
+    public APIResult<Group> getGroup(@PathVariable String id) {
+        APIResult<Group> result = groupService.findNormalById(id);
+        Group group = result.getData();
+        if (!result.getSuccess() || group == null) {
+            return result;
+        }
+
+        APIResult<List<Tag>> tagResult = tagService.findNormalByGroupId(id);
+        if (!tagResult.getSuccess()) {
+            return APIResult.error(new APICode(tagResult.getCode(), tagResult.getMessage()));
+        }
+
+        group.setTagList(tagResult.getData());
+        return result;
+
+    }
+
+}

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

@@ -1,16 +1,27 @@
 package cn.rankin.productservice.controller;
 
+import cn.rankin.common.utils.api.model.APICode;
 import cn.rankin.common.utils.api.model.APICodeManager;
 import cn.rankin.common.utils.api.model.APIResult;
 import cn.rankin.common.utils.api.page.Page;
 import cn.rankin.common.utils.dto.product.ItemDTO;
+import cn.rankin.common.utils.dto.product.ItemPriceDTO;
 import cn.rankin.common.utils.dto.search.ItemSearchDTO;
+import cn.rankin.common.utils.enums.BaseOrderEnum;
 import cn.rankin.productservice.entity.Item;
+import cn.rankin.productservice.entity.ItemPrice;
+import cn.rankin.productservice.entity.Tag;
+import cn.rankin.productservice.proxy.ItemServiceProxy;
 import cn.rankin.productservice.service.ItemService;
 import org.apache.commons.lang.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.transaction.interceptor.TransactionAspectSupport;
 import org.springframework.web.bind.annotation.*;
 
+import java.util.LinkedHashMap;
+import java.util.List;
+
 @RestController
 @RequestMapping(value = "item")
 public class ItemController {
@@ -18,6 +29,9 @@ public class ItemController {
     @Autowired
     private ItemService itemService;
 
+    @Autowired
+    private ItemServiceProxy itemServiceProxy;
+
     @RequestMapping(value = "/list", method = RequestMethod.GET)
     public APIResult<Page<Item>> search(ItemSearchDTO searchDTO) {
         Item item = new Item();
@@ -37,26 +51,86 @@ public class ItemController {
         item.setType(searchDTO.getType());
         item.setMerchantId(searchDTO.getMerchantId());
 
-        return itemService.search(item, searchDTO.getPageNo(), searchDTO.getPageSize());
+        // sort
+        LinkedHashMap<String, BaseOrderEnum> sort = new LinkedHashMap<>();
+        sort.put("gmtModified", BaseOrderEnum.DESC);
+
+        return itemService.search(item, searchDTO.getPageNo(), searchDTO.getPageSize(), sort);
     }
 
+    @Transactional
     @RequestMapping(method = RequestMethod.POST)
     public APIResult<Item> create(@RequestBody ItemDTO itemDTO) {
         String code = itemDTO.getCode();
         if (StringUtils.isEmpty(code) || itemDTO.getMerchantId() == null) {
             return APIResult.error(APICodeManager.PARAMETER_ERROR);
         }
+
         // 保存商品信息
-        return itemService.create(itemDTO);
+        APIResult<Item> result = itemService.create(itemDTO);
+        Item item = result.getData();
+        if (!result.getSuccess()) {
+            return result;
+        }
+
+        String itemId = item.getId();
+
+        // 保存标签关系
+        List<String> tagIdList = itemDTO.getTagList();
+        if (tagIdList != null) {
+            APIResult<List<Tag>> tagResult = itemServiceProxy.updateTagRelation(itemId, tagIdList);
+            if (!tagResult.getSuccess()) {
+                // 显示回滚
+                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+                return APIResult.error(new APICode(tagResult.getCode(), tagResult.getMessage()));
+            }
+            item.setTagList(tagResult.getData());
+        }
+
+        // 保存价格
+        List<ItemPriceDTO> itemPriceDTOList = itemDTO.getPriceList();
+        if (itemPriceDTOList != null) {
+            List<ItemPrice> priceList = itemServiceProxy.updatePrice(itemId, itemPriceDTOList).getData();
+            item.setPriceList(priceList);
+        }
+
+        return result;
     }
 
+    @Transactional
     @RequestMapping(method = RequestMethod.PUT)
     public APIResult<Item> update(@RequestBody ItemDTO itemDTO) {
         if (itemDTO.getId() == null) {
             return APIResult.error(APICodeManager.PARAMETER_ERROR);
         }
 
-        return itemService.update(itemDTO);
+        // 保存商品信息
+        APIResult<Item> result = itemService.update(itemDTO);
+        Item item = result.getData();
+        if (!result.getSuccess()) {
+            return result;
+        }
+
+        String itemId = item.getId();
+        // 保存标签关系
+        List<String> tagIdList = itemDTO.getTagList();
+        if (tagIdList != null) {
+            APIResult<List<Tag>> tagResult = itemServiceProxy.updateTagRelation(itemId, tagIdList);
+            if (!tagResult.getSuccess()) {
+                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+                return APIResult.error(new APICode(tagResult.getCode(), tagResult.getMessage()));
+            }
+            item.setTagList(tagResult.getData());
+        }
+
+        // 保存价格
+        List<ItemPriceDTO> itemPriceDTOList = itemDTO.getPriceList();
+        if (itemPriceDTOList != null) {
+            List<ItemPrice> priceList = itemServiceProxy.updatePrice(itemId, itemPriceDTOList).getData();
+            item.setPriceList(priceList);
+        }
+
+        return result;
     }
 
     @RequestMapping(value = "/{id}", method = RequestMethod.DELETE)
@@ -68,4 +142,8 @@ public class ItemController {
         return itemService.delete(itemId);
     }
 
+    @RequestMapping(value = "/{id}", method = RequestMethod.GET)
+    public APIResult<Item> getItem(@PathVariable("id") String Id) {
+        return null;
+    }
 }

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

@@ -1,23 +1,44 @@
 package cn.rankin.productservice.controller;
 
+import cn.rankin.common.utils.api.model.APICode;
 import cn.rankin.common.utils.api.model.APICodeManager;
 import cn.rankin.common.utils.api.model.APIResult;
 import cn.rankin.common.utils.dto.search.SearchDTO;
 import cn.rankin.common.utils.api.page.Page;
 import cn.rankin.common.utils.dto.product.LessonDTO;
-import cn.rankin.productservice.entity.Lesson;
-import cn.rankin.productservice.service.LessonService;
+import cn.rankin.common.utils.enums.BaseOrderEnum;
+import cn.rankin.productservice.entity.*;
+import cn.rankin.productservice.service.*;
 import org.apache.commons.lang.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.transaction.interceptor.TransactionAspectSupport;
 import org.springframework.web.bind.annotation.*;
 
+import javax.validation.Valid;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+
 @RestController
 @RequestMapping(value = "lesson")
 public class LessonController {
 
     @Autowired
+    private CourseService courseService;
+
+    @Autowired
+    private CourseSubRelationService courseSubRelationService;
+
+    @Autowired
     private LessonService lessonService;
 
+    @Autowired
+    private LessonWareRelationService lessonWareRelationService;
+
+    @Autowired
+    private WareService wareService;
+
     @RequestMapping(value = "/list", method = RequestMethod.GET)
     public APIResult<Page<Lesson>> getLessonList(SearchDTO searchDTO) {
         Lesson lesson = new Lesson();
@@ -32,42 +53,158 @@ public class LessonController {
             lesson.setName(name);
         }
 
-        return lessonService.search(lesson, searchDTO.getPageNo(), searchDTO.getPageSize());
+        lesson.setStatus(searchDTO.getStatus());
+
+        // sort
+        LinkedHashMap<String, BaseOrderEnum> sort = new LinkedHashMap() { {
+            this.put("gmtModified", BaseOrderEnum.DESC);
+        }};
+
+        return lessonService.search(lesson, searchDTO.getPageNo(), searchDTO.getPageSize(), sort);
     }
 
     @RequestMapping(value = "/{id}", method = RequestMethod.GET)
     public APIResult<Lesson> getLesson(@PathVariable String id) {
+
         if (StringUtils.isEmpty(id)) {
             return APIResult.error(APICodeManager.PARAMETER_ERROR);
         }
 
-        return lessonService.findById(id);
+        APIResult<Lesson> result = lessonService.findById(id);
+        Lesson lesson = result.getData();
+        if (!result.getSuccess() || lesson == null) {
+            return result;
+        }
+
+        List<LessonWareRelation> relationList = lessonWareRelationService.findByLessonId(lesson.getId());
+        if (relationList == null || relationList.size() == 0) {
+            return result;
+        }
+
+        List<String> wareIdList = new ArrayList() {
+            {
+                relationList.forEach( e -> add(e.getWareId()));
+            }
+        };
+
+        APIResult<List<Ware>> wareList = wareService.findByIds(wareIdList);
+        lesson.setWareList(wareList.getData());
+
+        return result;
+
     }
 
+    @Transactional
     @RequestMapping(method = RequestMethod.POST)
-    public APIResult<Lesson> create(@RequestBody LessonDTO lessonDTO) {
+    public APIResult<Lesson> create(@Valid @RequestBody LessonDTO lessonDTO) {
         String code = lessonDTO.getCode();
         if (lessonDTO.getId() != null || StringUtils.isEmpty(code)) {
             return APIResult.error(APICodeManager.PARAMETER_ERROR);
         }
 
-        return lessonService.create(lessonDTO);
+        // 更新课
+        APIResult<Lesson> result = lessonService.create(lessonDTO);
+        if (!result.getSuccess()) {
+            return result;
+        }
+
+        String Id = result.getData().getId();
+
+        // 为空不更新
+        List<String> wareIdList = lessonDTO.getWareList();
+        if (wareIdList == null) {
+            return result;
+        }
+
+        APIResult<List<Ware>> wareResult = updateRelation(Id, wareIdList);
+        if (!wareResult.getSuccess()) {
+            // 显示回滚
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            return APIResult.error(new APICode(wareResult.getCode(), wareResult.getMessage()));
+        }
+
+        List<Ware> wareList = wareResult.getData();
+        if (wareList != null) {
+            result.getData().setWareList(wareList);
+        }
+
+        return result;
     }
 
+    @Transactional
     @RequestMapping(method = RequestMethod.PUT)
-    public APIResult<Lesson> update(@RequestBody Lesson lesson) {
-        if (lesson.getId() == null) {
-            return APIResult.error(APICodeManager.PARAMETER_ERROR);
+    public APIResult<Lesson> update(@Valid @RequestBody LessonDTO lessonDTO) {
+        String Id = lessonDTO.getId();
+        if (Id == null) {
+            return APIResult.error(APICodeManager.error("参数错误: id不能为空"));
         }
 
-        return lessonService.update(lesson);
+        List<String> wareIdList = lessonDTO.getWareList();
+        List<Ware> wareList = new ArrayList<>();
+        if (wareIdList != null) {
+            APIResult<List<Ware>> wareResult = updateRelation(Id, wareIdList);
+            if (!wareResult.getSuccess()) {
+                return APIResult.error(new APICode(wareResult.getCode(), wareResult.getMessage()));
+            }else {
+                wareList = wareResult.getData();
+            }
+        }
+
+        APIResult<Lesson> result = lessonService.update(lessonDTO);
+        if (result.getSuccess() && result.getData() != null) {
+            result.getData().setWareList(wareList);
+        }
+
+        return result;
     }
 
     @RequestMapping(value = "/{id}", method = RequestMethod.DELETE)
-    public APIResult<Boolean> delete(@PathVariable("id") String id) {
+    public APIResult delete(@PathVariable("id") String id) {
         if (StringUtils.isEmpty(id)) {
             return APIResult.error(APICodeManager.PARAMETER_ERROR);
         }
-        return lessonService.delete(id);
+
+        List<CourseSubRelation> courseSubRelationList = courseSubRelationService.findByLessonId(id);
+        if (courseSubRelationList == null || courseSubRelationList.size() != 0) {
+            return lessonService.delete(id);
+        }
+
+        List<String> courseIdList = new ArrayList<>();
+        courseSubRelationList.forEach( relation -> {
+            String courseId = relation.getCourseId();
+            if (!courseIdList.contains(courseId)) {
+                courseIdList.add(courseId);
+            }
+        });
+
+        APIResult<List<Course>> courseResult = courseService.findAllByIds(courseIdList);
+        APIResult<List<Course>> result = APIResult.error(APICodeManager.CAN_NOT_DEL);
+        result.setData(courseResult.getData());
+
+        return result;
+
+    }
+
+    // 更新课与课件的关系
+    @Transactional
+    public APIResult<List<Ware>> updateRelation(String lessonId, List<String> wareIdList) {
+        if (wareIdList == null) {
+            return APIResult.ok();
+        }
+
+        List<Ware> wareList = new ArrayList<>();
+        if (wareIdList.size() == 0) {
+            lessonWareRelationService.deleteByLessonId(lessonId);
+        }else {
+            // 验证wareId的正确性
+            APIResult<List<Ware>> wareResult = wareService.findByIds(wareIdList);
+            wareList = wareResult.getData();
+            if (wareList == null || wareList.size() != wareIdList.size()) {
+                return APIResult.error(APICodeManager.error("存在错误的课件"));
+            }
+            lessonWareRelationService.update(lessonId, wareIdList);
+        }
+
+        return APIResult.ok(wareList);
     }
 }

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

@@ -1,16 +1,25 @@
 package cn.rankin.productservice.controller;
 
+import cn.rankin.common.utils.api.model.APICode;
 import cn.rankin.common.utils.api.model.APICodeManager;
 import cn.rankin.common.utils.api.model.APIResult;
 import cn.rankin.common.utils.api.page.Page;
 import cn.rankin.common.utils.dto.search.SearchDTO;
 import cn.rankin.common.utils.dto.product.SupportDTO;
+import cn.rankin.common.utils.enums.BaseOrderEnum;
 import cn.rankin.productservice.entity.Support;
+import cn.rankin.productservice.proxy.SupportServiceProxy;
+import cn.rankin.productservice.service.SupportSelfRelationService;
 import cn.rankin.productservice.service.SupportService;
 import org.apache.commons.lang.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.transaction.interceptor.TransactionAspectSupport;
 import org.springframework.web.bind.annotation.*;
 
+import java.util.LinkedHashMap;
+import java.util.List;
+
 @RestController
 @RequestMapping(value = "support")
 public class SupportController {
@@ -18,6 +27,12 @@ public class SupportController {
     @Autowired
     private SupportService supportService;
 
+    @Autowired
+    private SupportSelfRelationService selfRelationService;
+
+    @Autowired
+    private SupportServiceProxy supportServiceProxy;
+
     @RequestMapping(value = "/list", method = RequestMethod.GET)
     public APIResult<Page<Support>> search(SearchDTO searchDTO) {
         Support support = new Support();
@@ -32,7 +47,11 @@ public class SupportController {
             support.setName("%" + name + "%");
         }
 
-        return supportService.search(support, searchDTO.getPageNo(), searchDTO.getPageSize());
+        support.setStatus(searchDTO.getStatus());
+        LinkedHashMap<String, BaseOrderEnum> sort = new LinkedHashMap<>();
+        sort.put("gmtModified", BaseOrderEnum.DESC);
+
+        return supportService.search(support, searchDTO.getPageNo(), searchDTO.getPageSize(), sort);
     }
 
     @RequestMapping(value = "/{id}", method = RequestMethod.GET)
@@ -41,9 +60,21 @@ public class SupportController {
             return APIResult.error(APICodeManager.PARAMETER_ERROR);
         }
 
-        return supportService.findById(id);
+        APIResult<Support> result = supportService.findById(id);
+        if (!result.getSuccess()) {
+            return result;
+        }
+
+        Support support = result.getData();
+
+        APIResult<List<Support>> supportResult = supportServiceProxy.getRelationSupport(support.getId());
+        support.setSupportList(supportResult.getData());
+
+        return result;
+
     }
 
+    @Transactional
     @RequestMapping(method = RequestMethod.POST)
     public APIResult<Support> create(@RequestBody SupportDTO supportDTO) {
         String code = supportDTO.getCode();
@@ -51,7 +82,22 @@ public class SupportController {
             return APIResult.error(APICodeManager.PARAMETER_ERROR);
         }
 
-        return supportService.create(supportDTO);
+        APIResult<Support> result = supportService.create(supportDTO);
+        Support support = result.getData();
+        List<String> supportIdList = supportDTO.getSupportList();
+        if (supportIdList == null || supportIdList.size() == 0 || support == null) {
+            return result;
+        }
+
+        APIResult<List<Support>> supportResult = supportServiceProxy.updateSelfRelation(support.getId(), supportIdList);
+        if (!supportResult.getSuccess()) {
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            return APIResult.error(new APICode(supportResult.getCode(), supportResult.getMessage()));
+        }
+        support.setSupportList(supportResult.getData());
+
+        return result;
+
     }
 
     @RequestMapping(method = RequestMethod.PUT)
@@ -60,7 +106,24 @@ public class SupportController {
             return APIResult.error(APICodeManager.PARAMETER_ERROR);
         }
 
-        return supportService.update(supportDTO);
+        APIResult<Support> result = supportService.update(supportDTO);
+        Support support = result.getData();
+
+        List<String> supportIdList = supportDTO.getSupportList();
+        if (supportIdList == null || support == null) {
+            return result;
+        }else if (supportIdList.size() == 0) {
+            selfRelationService.deleteBySupportId(support.getId());
+            return result;
+        }
+
+        APIResult<List<Support>> supportResult = supportServiceProxy.updateSelfRelation(support.getId(), supportIdList);
+        if (!supportResult.getSuccess()) {
+            return APIResult.error(new APICode(supportResult.getCode(), supportResult.getMessage()));
+        }
+        support.setSupportList(supportResult.getData());
+
+        return result;
     }
 
     @RequestMapping(value = "/{id}", method = RequestMethod.DELETE)

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

@@ -1,17 +1,29 @@
 package cn.rankin.productservice.controller;
 
+import cn.rankin.common.utils.api.model.APICode;
 import cn.rankin.common.utils.api.model.APICodeManager;
 import cn.rankin.common.utils.api.model.APIResult;
 import cn.rankin.common.utils.api.page.Page;
 import cn.rankin.common.utils.dto.product.TagDTO;
-import cn.rankin.common.utils.dto.search.TagSearchDTO;
+import cn.rankin.common.utils.enums.*;
+import cn.rankin.productservice.entity.Item;
+import cn.rankin.productservice.entity.ItemTagRelation;
 import cn.rankin.productservice.entity.Tag;
+import cn.rankin.productservice.service.ItemService;
+import cn.rankin.productservice.service.ItemTagRelationService;
 import cn.rankin.productservice.service.TagService;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.transaction.interceptor.TransactionAspectSupport;
+import org.springframework.util.CollectionUtils;
 import org.springframework.web.bind.annotation.*;
 
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+
 @Slf4j
 @RestController
 @RequestMapping(value = "tag")
@@ -20,53 +32,133 @@ public class TagController {
     @Autowired
     private TagService tagService;
 
-    @RequestMapping(value = "/list", method = RequestMethod.GET)
-    public APIResult<Page<Tag>> search(TagSearchDTO searchDTO) {
-        Tag tag = new Tag();
-
-        String code = searchDTO.getCode();
-        if (!StringUtils.isEmpty(code)) {
-            tag.setCode("%" + code + "%");
-        }
-
-        String name = searchDTO.getName();
-        if (!StringUtils.isEmpty(name)) {
-            tag.setName("%" + name + "%");
-        }
-
-        String merchantId = searchDTO.getMerchantId();
-        if (merchantId != null) {
-            tag.setMerchantId(merchantId);
-        }
-
-        return tagService.search(tag, searchDTO.getPageNo(), searchDTO.getPageSize());
-    }
-
-    @RequestMapping(method = RequestMethod.POST)
-    public APIResult<Tag> create(@RequestBody TagDTO tagDTO) {
-        String code = tagDTO.getCode();
-        if (StringUtils.isEmpty(code)) {
-            return APIResult.error(APICodeManager.PARAMETER_ERROR);
-        }
-
-        return tagService.create(tagDTO);
-    }
-
-    @RequestMapping(method = RequestMethod.PUT)
-    public APIResult<Tag> update(@RequestBody TagDTO tagDTO) {
-        if (tagDTO.getId() == null) {
-            return APIResult.error(APICodeManager.PARAMETER_ERROR);
-        }
-
-        return tagService.update(tagDTO);
-    }
+    @Autowired
+    private ItemTagRelationService tagRelationService;
 
-    @RequestMapping(value = "/{code}", method = RequestMethod.DELETE)
-    public APIResult<Boolean> delete(@PathVariable String code) {
-        if (StringUtils.isEmpty(code)) {
-            return APIResult.error(APICodeManager.PARAMETER_ERROR);
-        }
+    @Autowired
+    private ItemService itemService;
 
-        return tagService.delete(code);
-    }
+//    @RequestMapping(value = "/{id}", method = RequestMethod.GET)
+//    public APIResult<Tag> getTag(@PathVariable String id) {
+//        APIResult<Tag> result = tagService.findById(id);
+//        Tag tag = result.getData();
+//        if (tag == null) {
+//            return result;
+//        }
+//
+//        APIResult<List<Item>> itemResult = getTagItem(tag.getId());
+//        tag.setItemList(itemResult.getData());
+//
+//        return result;
+//
+//    }
+//
+//    @Transactional
+//    @RequestMapping(method = RequestMethod.POST)
+//    public APIResult<Tag> create(@RequestBody TagDTO tagDTO) {
+//
+//        APIResult<Tag> result = tagService.create(tagDTO);
+//        Tag tag = result.getData();
+//
+//        List<String> itemIdList = tagDTO.getItemList();
+//        if (itemIdList == null || tag == null) {
+//            return result;
+//        }
+//
+//        APIResult<List<Item>> relationResult = updateTagRelation(tag, itemIdList);
+//        if (!relationResult.getSuccess()) {
+//            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+//            return APIResult.error(new APICode(relationResult.getCode(), relationResult.getMessage()));
+//        }
+//        tag.setItemList(relationResult.getData());
+//
+//        return result;
+//
+//    }
+//
+//    @Transactional
+//    @RequestMapping(method = RequestMethod.PUT)
+//    public APIResult<Tag> update(@RequestBody TagDTO tagDTO) {
+//        if (tagDTO.getId() == null) {
+//            return APIResult.error(APICodeManager.PARAMETER_ERROR);
+//        }
+//
+//        APIResult<Tag> result = tagService.update(tagDTO);
+//        Tag tag = result.getData();
+//
+//        List<String> itemIdList = tagDTO.getItemList();
+//        if (itemIdList == null || tag == null) {
+//            return result;
+//        }
+//
+//        APIResult<List<Item>> relationResult = updateTagRelation(tag, itemIdList);
+//        if (!relationResult.getSuccess()) {
+//            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+//            return APIResult.error(new APICode(relationResult.getCode(), relationResult.getMessage()));
+//        }
+//        tag.setItemList(relationResult.getData());
+//
+//        return tagService.update(tagDTO);
+//    }
+//
+//    @RequestMapping(value = "/id", method = RequestMethod.DELETE)
+//    public APIResult delete(@PathVariable String id) {
+//        if (StringUtils.isEmpty(id)) {
+//            return APIResult.error(APICodeManager.PARAMETER_ERROR);
+//        }
+//
+//        List<ItemTagRelation> relationList = tagRelationService.findAllByTagId(id);
+//        if (CollectionUtils.isEmpty(relationList)) {
+//            return tagService.delete(id);
+//        }
+//
+//        List<String> itemIdList = new ArrayList<>();
+//        relationList.forEach( relation -> {
+//            String itemId = relation.getItemId();
+//            if (itemId != null && !itemIdList.contains(itemId)) {
+//                itemIdList.add(itemId);
+//            }
+//        });
+//
+//        List<Item> itemList = itemService.findAllByIds(itemIdList).getData();
+//
+//        APIResult<List<Item>> result = APIResult.error(APICodeManager.CAN_NOT_DEL);
+//        result.setData(itemList);
+//
+//        return result;
+//    }
+//
+//    @Transactional
+//    public APIResult<List<Item>> updateTagRelation(Tag tag, List<String> itemIdList) {
+//        List<Item> itemList = itemService.findAllByIds(itemIdList).getData();
+//        if (itemList == null || itemList.size() != itemIdList.size()) {
+//            return APIResult.error(APICodeManager.error("itemId不匹配"));
+//        }
+//
+//        TagTypeEnum tagType = tag.getType();
+//        String merchantId = tag.getMerchantId();
+//        for (int i = 0; i < itemList.size(); i++) {
+//            Item item = itemList.get(i);
+//            if (!item.getMerchantId().equals(merchantId) || !EnumUtil.compare(item.getType(), tagType)) {
+//                return APIResult.error(APICodeManager.error("类型或渠道商不匹配"));
+//            }
+//        }
+//
+//        tagRelationService.updateByTag(tag.getId(), itemIdList);
+//        return APIResult.ok(itemList);
+//    }
+//
+//    public APIResult<List<Item>> getTagItem(String tagId) {
+//        List<ItemTagRelation> relationList = tagRelationService.findByTagId(tagId);
+//        if (relationList == null || relationList.size() == 0) {
+//            return APIResult.ok();
+//        }
+//
+//        List<String> itemIdList = new ArrayList<>();
+//        relationList.forEach( relation -> itemIdList.add(relation.getItemId()));
+//
+//        // 返回上架的item
+//        return itemService.findAllByIds(itemIdList, ItemStatusEnum.DEL);
+//
+//    }
 }

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

@@ -5,6 +5,9 @@ import cn.rankin.common.utils.api.model.APIResult;
 import cn.rankin.common.utils.dto.search.SearchDTO;
 import cn.rankin.common.utils.api.page.Page;
 import cn.rankin.common.utils.dto.product.WareDTO;
+import cn.rankin.common.utils.enums.BaseOrderEnum;
+import cn.rankin.productservice.entity.Lesson;
+import cn.rankin.productservice.entity.LessonWareRelation;
 import cn.rankin.productservice.entity.Ware;
 import cn.rankin.common.utils.enums.WareTypeEnum;
 import cn.rankin.productservice.service.LessonService;
@@ -16,6 +19,9 @@ import org.springframework.web.bind.annotation.*;
 
 import javax.validation.Valid;
 import javax.validation.constraints.NotNull;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
 
 @RestController
 @RequestMapping(value = "ware")
@@ -44,20 +50,19 @@ public class WareController {
             ware.setName("%" + name + "%");
         }
 
-        ware.setType(searchDTO.getType());
+        ware.setStatus(searchDTO.getStatus());
 
-        return wareService.search(ware, searchDTO.getPageNo(), searchDTO.getPageSize());
+        // sort
+        LinkedHashMap<String, BaseOrderEnum> sort = new LinkedHashMap() { {
+            this.put("gmtModified", BaseOrderEnum.DESC);
+        }};
+
+        return wareService.search(ware, searchDTO.getPageNo(), searchDTO.getPageSize(), sort);
     }
 
     // 创建资源
     @RequestMapping(method = RequestMethod.POST)
     public APIResult<Ware> create(@Valid @RequestBody WareDTO wareDTO) {
-        String code = wareDTO.getCode();
-        WareTypeEnum type = wareDTO.getType();
-        if (StringUtils.isEmpty(code) || type == null) {
-            return APIResult.error(APICodeManager.PARAMETER_ERROR);
-        }
-
         return wareService.create(wareDTO);
     }
 
@@ -65,7 +70,7 @@ public class WareController {
     @RequestMapping(method = RequestMethod.PUT)
     public APIResult<Ware> update(@Valid @RequestBody WareDTO wareDTO) {
         if (wareDTO.getId() == null) {
-            return APIResult.error(APICodeManager.PARAMETER_ERROR);
+            return APIResult.error(APICodeManager.error("参数错误: id"));
         }
 
         return wareService.update(wareDTO);
@@ -73,8 +78,27 @@ public class WareController {
 
     // 删除资源
     @RequestMapping(value = "/{id}", method = RequestMethod.DELETE)
-    public APIResult<Boolean> delete(@NotNull @PathVariable("id") String id) {
-        return wareService.delete(id);
+    public APIResult delete(@NotNull @PathVariable("id") String id) {
+        List<LessonWareRelation> existRel = relationService.findByWareId(id);
+        if (existRel == null || existRel.size() == 0) {
+            return wareService.delete(id);
+        }
+
+        List<String> lessonIds = new ArrayList<>();
+        existRel.forEach( rel ->
+            {
+                String lessonId = rel.getLessonId();
+                if (!lessonIds.contains(lessonId)) {
+                    lessonIds.add(rel.getLessonId());
+                }
+            }
+        );
+
+        List<Lesson> lessonList = lessonService.findAllByIds(lessonIds).getData();
+        APIResult<List<Lesson>> result = APIResult.error(APICodeManager.CAN_NOT_DEL);
+        result.setData(lessonList);
+
+        return result;
     }
 
     // 取一个

rankin-product-service/src/main/java/cn/rankin/productservice/entity/Course.java

@@ -17,7 +17,7 @@ import java.util.List;
 @Data
 @ToString
 @Entity
-@Table(name = "lj_course")
+@Table(name = "lj_course", indexes = {@Index(columnList = "code"), @Index(columnList = "name")})
 @DynamicInsert
 @DynamicUpdate
 public class Course implements Serializable{
@@ -43,11 +43,11 @@ public class Course implements Serializable{
     @Column
     private String keyword;
 
-    @Column(name = "cv_img_ids")
-    private String cvImgIds;
+    @Column(name = "cv_img_list")
+    private String cvImgList;
 
-    @Column(name = "bg_img_ids")
-    private String bgImgIds;
+    @Column(name = "bg_img_list")
+    private String bgImgList;
 
     @Column
     @Enumerated(EnumType.ORDINAL)
@@ -72,8 +72,9 @@ public class Course implements Serializable{
     @Transient
     private List<CourseSubItemVo> subItemList;
 
-    @ManyToMany(fetch = FetchType.EAGER)
-    @JoinTable(name = "lj_course_support_relation", joinColumns = {@JoinColumn(name = "course_id", referencedColumnName = "id")},
-            inverseJoinColumns = {@JoinColumn(name = "support_id", referencedColumnName = "id")})
+//    @ManyToMany(fetch = FetchType.EAGER)
+//    @JoinTable(name = "lj_course_support_relation", joinColumns = {@JoinColumn(name = "course_id", referencedColumnName = "id")},
+//            inverseJoinColumns = {@JoinColumn(name = "support_id", referencedColumnName = "id")})
+    @Transient
     private List<Support> supportList;
 }

rankin-product-service/src/main/java/cn/rankin/productservice/entity/CourseSubRelation.java

@@ -1,5 +1,6 @@
 package cn.rankin.productservice.entity;
 
+import cn.rankin.common.utils.enums.BaseStatusEnum;
 import cn.rankin.common.utils.enums.CourseSubTypeEnum;
 import lombok.Data;
 import lombok.ToString;
@@ -13,7 +14,8 @@ import java.util.Date;
 @Data
 @ToString
 @Entity
-@Table(name = "lj_course_sub_relation")
+@Table(name = "lj_course_sub_relation", uniqueConstraints = {@UniqueConstraint(columnNames = {"course_id", "sub_id", "type"})},
+        indexes = {@Index(columnList = "course_id"), @Index(columnList = "sub_id")})
 @DynamicInsert
 @DynamicUpdate
 public class CourseSubRelation implements Serializable {
@@ -34,6 +36,9 @@ public class CourseSubRelation implements Serializable {
     @Column
     private Integer sort;
 
+    @Column
+    private BaseStatusEnum status;
+
     @Column(name = "gmt_created", updatable = false, insertable = false)
     @Temporal(TemporalType.TIMESTAMP)
     private Date gmtCreated;

rankin-product-service/src/main/java/cn/rankin/productservice/entity/CourseSupportRelation.java

@@ -0,0 +1,39 @@
+package cn.rankin.productservice.entity;
+
+import cn.rankin.common.utils.enums.BaseStatusEnum;
+import lombok.Data;
+import lombok.ToString;
+import org.hibernate.annotations.DynamicInsert;
+import org.hibernate.annotations.DynamicUpdate;
+
+import javax.persistence.*;
+import java.io.Serializable;
+import java.util.Date;
+
+@Data
+@ToString
+@Table(name = "lj_course_support_relation", uniqueConstraints = {@UniqueConstraint(columnNames = {"course_id", "support_id"})},
+        indexes = {@Index(columnList = "course_id"), @Index(columnList = "support_id")})
+@Entity
+@DynamicInsert
+@DynamicUpdate
+public class CourseSupportRelation implements Serializable {
+
+    @Id
+    private String id;
+
+    @Column(name = "course_id")
+    private String courseId;
+
+    @Column(name = "support_id")
+    private String supportId;
+
+    private Integer sort;
+
+    @Enumerated(EnumType.ORDINAL)
+    private BaseStatusEnum status;
+
+    @Column(name = "gmt_created", updatable = false, insertable = false, columnDefinition = "timestamp NULL DEFAULT CURRENT_TIMESTAMP")
+    @Temporal(TemporalType.TIMESTAMP)
+    private Date gmtCreated;
+}

rankin-product-service/src/main/java/cn/rankin/productservice/entity/Group.java

@@ -0,0 +1,51 @@
+package cn.rankin.productservice.entity;
+
+import cn.rankin.common.utils.enums.BaseStatusEnum;
+import lombok.Data;
+import lombok.ToString;
+import org.hibernate.annotations.DynamicInsert;
+import org.hibernate.annotations.DynamicUpdate;
+
+import javax.persistence.*;
+import java.io.Serializable;
+import java.util.Date;
+import java.util.List;
+
+@Data
+@ToString
+@Entity
+@Table(name = "lj_group", uniqueConstraints = {@UniqueConstraint(columnNames = {"code", "merchant_id"})})
+@DynamicInsert
+@DynamicUpdate
+public class Group implements Serializable {
+
+    @Id
+    private String id;
+
+    @Column(unique = true, updatable = false)
+    private String code;
+
+    @Column(nullable = false)
+    private String name;
+
+    @Column(name = "merchant_id", updatable = false)
+    private String merchantId;
+
+    @Column
+    private Integer sort;
+
+    @Column
+    @Enumerated(EnumType.ORDINAL)
+    private BaseStatusEnum status;
+
+    @Transient
+    private List<Tag> tagList;
+
+    @Column(name = "gmt_created", updatable = false, insertable = false, columnDefinition = "timestamp NULL DEFAULT CURRENT_TIMESTAMP")
+    @Temporal(TemporalType.TIMESTAMP)
+    private Date gmtCreated;
+
+    @Column(name = "gmt_modified", updatable = false, insertable = false, columnDefinition = "timestamp NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP")
+    @Temporal(TemporalType.TIMESTAMP)
+    private Date gmtModified;
+}

rankin-product-service/src/main/java/cn/rankin/productservice/entity/Item.java

@@ -10,12 +10,14 @@ import org.hibernate.annotations.DynamicUpdate;
 import javax.persistence.*;
 import java.io.Serializable;
 import java.util.Date;
+import java.util.List;
 import java.util.Set;
 
 @Data
 @ToString
 @Entity
-@Table(name = "lj_item")
+@Table(name = "lj_item", uniqueConstraints = {@UniqueConstraint(columnNames= {"sub_id", "merchant_id"})},
+        indexes = {@Index(columnList = "code"), @Index(columnList = "name"), @Index(columnList = "sub_id")})
 @DynamicInsert
 @DynamicUpdate
 public class Item implements Serializable {
@@ -23,7 +25,7 @@ public class Item implements Serializable {
     @Id
     private String id;
 
-    @Column(name = "sub_id")
+    @Column(name = "sub_id", updatable = false)
     private String subId;
 
     @Column
@@ -53,12 +55,14 @@ public class Item implements Serializable {
     @Temporal(TemporalType.TIMESTAMP)
     private Date gmtModified;
 
-    @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER, mappedBy = "itemId")
-    @OrderBy("duration asc")
-    private Set<ItemPrice> priceList;
+//    @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER, mappedBy = "itemId")
+//    @OrderBy("duration asc")
+    @Transient
+    private List<ItemPrice> priceList;
 
-    @ManyToMany(fetch = FetchType.LAZY)
-    @JoinTable(name = "lj_item_tag_relation", joinColumns = {@JoinColumn(name="item_id", referencedColumnName="id")},
-            inverseJoinColumns = {@JoinColumn(name = "tag_id", referencedColumnName = "id", unique = false)})
-    private Set<Tag> tagList;
+//    @ManyToMany(fetch = FetchType.LAZY)
+//    @JoinTable(name = "lj_item_tag_relation", joinColumns = {@JoinColumn(name="item_id", referencedColumnName="id")},
+//            inverseJoinColumns = {@JoinColumn(name = "tag_id", referencedColumnName = "id", unique = false)})
+    @Transient
+    private List<Tag> tagList;
 }

rankin-product-service/src/main/java/cn/rankin/productservice/entity/ItemPrice.java

@@ -1,5 +1,6 @@
 package cn.rankin.productservice.entity;
 
+import cn.rankin.common.utils.enums.BaseStatusEnum;
 import cn.rankin.common.utils.enums.PriceTypeEnum;
 import lombok.Data;
 import lombok.ToString;
@@ -14,20 +15,19 @@ import java.util.Date;
 @Data
 @ToString
 @Entity
-@Table(name = "lj_item_price",  uniqueConstraints = {@UniqueConstraint(columnNames = {"item_id", "type", "duration"})})
+@Table(name = "lj_item_price",  uniqueConstraints = {@UniqueConstraint(columnNames = {"item_id", "type", "duration"})},
+        indexes = {@Index(columnList = "item_id")})
 @DynamicInsert
 @DynamicUpdate
 public class ItemPrice implements Serializable {
 
     @Id
-    @GeneratedValue(generator = "uuid")
-    @GenericGenerator(name = "uuid", strategy = "uuid")
     private String id;
 
     @Column
     private String name;
 
-    @Column(name = "item_id")
+    @Column(name = "item_id", updatable = false)
     private String itemId;
 
     @Column
@@ -46,8 +46,11 @@ public class ItemPrice implements Serializable {
     @Column(name = "terminal_price")
     private Double terminalPrice;
 
+    private Integer sort;
+
     @Column
-    private Integer status;
+    @Enumerated(EnumType.ORDINAL)
+    private BaseStatusEnum status;
 
     @Column(name = "gmt_created", updatable = false, insertable = false)
     @Temporal(TemporalType.TIMESTAMP)

rankin-product-service/src/main/java/cn/rankin/productservice/entity/ItemTagRelation.java

@@ -0,0 +1,39 @@
+package cn.rankin.productservice.entity;
+
+import cn.rankin.common.utils.enums.BaseStatusEnum;
+import lombok.Data;
+import lombok.ToString;
+import org.hibernate.annotations.DynamicInsert;
+import org.hibernate.annotations.DynamicUpdate;
+
+import javax.persistence.*;
+import java.io.Serializable;
+import java.util.Date;
+
+@Data
+@ToString
+@Table(name = "lj_item_tag_relation", uniqueConstraints = {@UniqueConstraint(columnNames = {"item_id", "tag_id"})},
+        indexes = {@Index(columnList = "item_id"), @Index(columnList = "tag_id")})
+@Entity
+@DynamicUpdate
+@DynamicInsert
+public class ItemTagRelation implements Serializable {
+
+    @Id
+    private String id;
+
+    @Column(name = "item_id")
+    private String itemId;
+
+    @Column(name = "tag_id")
+    private String tagId;
+
+    @Column
+    private Integer sort;
+
+    @Enumerated(EnumType.ORDINAL)
+    private BaseStatusEnum status;
+
+    @Temporal(TemporalType.TIMESTAMP)
+    private Date gmtCreated;
+}

rankin-product-service/src/main/java/cn/rankin/productservice/entity/Lesson.java

@@ -14,7 +14,7 @@ import java.util.List;
 @Data
 @ToString
 @Entity
-@Table(name = "lj_lesson")
+@Table(name = "lj_lesson", indexes = {@Index(columnList = "code"), @Index(columnList = "name")})
 @DynamicInsert
 @DynamicUpdate
 public class Lesson implements Serializable {
@@ -34,7 +34,7 @@ public class Lesson implements Serializable {
     @Column
     private Integer sort;
 
-    @Column
+    @Column(nullable = false)
     @Enumerated(EnumType.ORDINAL)
     private BaseStatusEnum status;
 
@@ -46,9 +46,6 @@ public class Lesson implements Serializable {
     @Temporal(TemporalType.TIMESTAMP)
     private Date gmtModified;
 
-    @ManyToMany(fetch = FetchType.LAZY)
-    @JoinTable(name = "lj_lesson_ware_relation", joinColumns = {@JoinColumn(name = "lesson_id", referencedColumnName = "id")},
-            inverseJoinColumns = {@JoinColumn(name = "ware_id", referencedColumnName = "id")})
-    @OrderColumn(name = "sort")
+    @Transient
     private List<Ware> wareList;
 }

rankin-product-service/src/main/java/cn/rankin/productservice/entity/LessonWareRelation.java

@@ -1,5 +1,6 @@
 package cn.rankin.productservice.entity;
 
+import cn.rankin.common.utils.enums.BaseStatusEnum;
 import lombok.Data;
 import lombok.ToString;
 import org.hibernate.annotations.DynamicInsert;
@@ -13,14 +14,13 @@ import java.util.Date;
 @Data
 @ToString
 @Entity
-@Table(name = "lj_lesson_ware_relation")
+@Table(name = "lj_lesson_ware_relation", uniqueConstraints = {@UniqueConstraint(columnNames = {"lesson_id", "ware_id"})},
+        indexes = {@Index(columnList = "lesson_id"), @Index(columnList = "ware_id")})
 @DynamicInsert
 @DynamicUpdate
 public class LessonWareRelation implements Serializable{
 
     @Id
-    @GeneratedValue(generator = "uuid")
-    @GenericGenerator(name = "uuid", strategy = "uuid")
     private String id;
 
     @Column(name = "lesson_id")
@@ -32,6 +32,10 @@ public class LessonWareRelation implements Serializable{
     @Column
     private Integer sort;
 
+    @Column
+    @Enumerated(EnumType.ORDINAL)
+    private BaseStatusEnum status;
+
     @Column(name = "gmt_created", updatable = false, insertable = false, columnDefinition = "timestamp NULL DEFAULT CURRENT_TIMESTAMP")
     @Temporal(TemporalType.TIMESTAMP)
     private Date gmtCreated;

rankin-product-service/src/main/java/cn/rankin/productservice/entity/Support.java

@@ -9,12 +9,13 @@ import org.hibernate.annotations.DynamicUpdate;
 import javax.persistence.*;
 import java.io.Serializable;
 import java.util.Date;
+import java.util.List;
 import java.util.Set;
 
 @Data
 @ToString
 @Entity
-@Table(name = "lj_support")
+@Table(name = "lj_support", indexes = {@Index(columnList = "code"), @Index(columnList = "name")})
 @DynamicInsert
 @DynamicUpdate
 public class Support implements Serializable {
@@ -22,7 +23,7 @@ public class Support implements Serializable {
     @Id
     private String id;
 
-    @Column
+    @Column(unique = true, nullable = false)
     private String code;
 
     @Column
@@ -37,8 +38,8 @@ public class Support implements Serializable {
     @Column
     private String detail;
 
-    @Column(name = "img_ids")
-    private String imgIds;
+    @Column(name = "img_list")
+    private String imgList;
 
     @Column
     @Enumerated(EnumType.ORDINAL)
@@ -52,8 +53,9 @@ public class Support implements Serializable {
     @Temporal(TemporalType.TIMESTAMP)
     private Date gmtModified;
 
-    @ManyToMany(fetch = FetchType.EAGER)
-    @JoinTable(name = "lj_support_reference", joinColumns = {@JoinColumn(name = "fid", referencedColumnName = "id")},
-            inverseJoinColumns = {@JoinColumn(name = "tid", referencedColumnName = "id")})
-    private Set<Support> supportList;
+//    @ManyToMany(fetch = FetchType.EAGER)
+//    @JoinTable(name = "lj_support_reference", joinColumns = {@JoinColumn(name = "fid", referencedColumnName = "id")},
+//            inverseJoinColumns = {@JoinColumn(name = "tid", referencedColumnName = "id")})
+    @Transient
+    private List<Support> supportList;
 }

rankin-product-service/src/main/java/cn/rankin/productservice/entity/SupportSelfRelation.java

@@ -1,5 +1,6 @@
 package cn.rankin.productservice.entity;
 
+import cn.rankin.common.utils.enums.BaseStatusEnum;
 import lombok.Data;
 import lombok.ToString;
 import org.hibernate.annotations.DynamicInsert;
@@ -12,7 +13,8 @@ import java.util.Date;
 @Data
 @ToString
 @Entity
-@Table(name = "lj_support_self_relation")
+@Table(name = "lj_support_self_relation", uniqueConstraints = {@UniqueConstraint(columnNames = {"fid", "tid"})},
+        indexes = {@Index(columnList = "fid"), @Index(columnList = "tid")})
 @DynamicInsert
 @DynamicUpdate
 public class SupportSelfRelation implements Serializable {
@@ -26,6 +28,11 @@ public class SupportSelfRelation implements Serializable {
     @Column
     private String tid;
 
+    private Integer sort;
+
+    @Enumerated(EnumType.ORDINAL)
+    private BaseStatusEnum status;
+
     @Column(name = "gmt_created", insertable = false, updatable = false)
     @Temporal(TemporalType.TIMESTAMP)
     private Date gmtCreated;

rankin-product-service/src/main/java/cn/rankin/productservice/entity/Tag.java

@@ -1,7 +1,6 @@
 package cn.rankin.productservice.entity;
 
 import cn.rankin.common.utils.enums.BaseStatusEnum;
-import cn.rankin.common.utils.enums.TagTypeEnum;
 import lombok.Data;
 import lombok.ToString;
 import org.hibernate.annotations.DynamicInsert;
@@ -14,7 +13,8 @@ import java.util.Date;
 @Data
 @ToString
 @Entity
-@Table(name = "lj_tag")
+@Table(name = "lj_tag", uniqueConstraints = {@UniqueConstraint(columnNames = {"name", "group_id"})},
+        indexes = {@Index(columnList = "name")})
 @DynamicInsert
 @DynamicUpdate
 public class Tag implements Serializable {
@@ -23,17 +23,10 @@ public class Tag implements Serializable {
     private String id;
 
     @Column
-    private String code;
-
-    @Column
     private String name;
 
-    @Column
-    @Enumerated(EnumType.ORDINAL)
-    private TagTypeEnum type;
-
-    @Column(name = "merchant_id")
-    private String merchantId;
+    @Column(name = "group_id", updatable = false, nullable = false)
+    private String groupId;
 
     @Column
     private Integer sort;
@@ -49,4 +42,10 @@ public class Tag 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 String merchantId;
+
+    @Transient
+    private String groupName;
 }

rankin-product-service/src/main/java/cn/rankin/productservice/entity/Ware.java

@@ -17,7 +17,7 @@ import java.util.List;
 @Data
 @ToString
 @Entity
-@Table(name = "lj_ware")
+@Table(name = "lj_ware", indexes = {@Index(columnList = "code"), @Index(columnList = "name")})
 @DynamicInsert
 @DynamicUpdate
 public class Ware implements Serializable{
@@ -34,16 +34,9 @@ public class Ware implements Serializable{
     @Column
     private String digest;
 
-    @Column
-    @Enumerated(EnumType.ORDINAL)
-    private WareTypeEnum type;
-
-    @Column(name = "play_url")
-    private String playUrl;
-
-    @Column(name = "img_ids")
+    @Column(name = "resource_list")
     @Convert(converter = ListAttributeConverter.class)
-    private List<String> imgIds;
+    private List<String> resourceList;
 
     @Column(name = "cp_id")
     private String cpId;

rankin-product-service/src/main/java/cn/rankin/productservice/proxy/CourseServiceProxy.java

@@ -0,0 +1,136 @@
+package cn.rankin.productservice.proxy;
+
+import cn.rankin.common.utils.api.model.APICodeManager;
+import cn.rankin.common.utils.api.model.APIResult;
+import cn.rankin.common.utils.dto.product.CourseSubRelationDTO;
+import cn.rankin.common.utils.enums.CourseSubTypeEnum;
+import cn.rankin.productservice.entity.CourseSubRelation;
+import cn.rankin.productservice.entity.CourseSupportRelation;
+import cn.rankin.productservice.entity.Lesson;
+import cn.rankin.productservice.entity.Support;
+import cn.rankin.productservice.service.CourseSubRelationService;
+import cn.rankin.productservice.service.CourseSupportRelationService;
+import cn.rankin.productservice.service.LessonService;
+import cn.rankin.productservice.service.SupportService;
+import cn.rankin.productservice.vo.CourseSubItemVo;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static cn.rankin.productservice.utils.DTOConverter.convert;
+
+@Service
+public class CourseServiceProxy {
+
+    @Autowired
+    private CourseSubRelationService courseSubRelationService;
+
+    @Autowired
+    private LessonService lessonService;
+
+    @Autowired
+    private CourseSupportRelationService courseSupportRelationService;
+
+    @Autowired
+    private SupportService supportService;
+
+    // find sub item by courseId
+    public List<CourseSubItemVo> findSubItemVo(String courseId) {
+        List<CourseSubItemVo> subItemVoList = new ArrayList<>();
+
+        List<CourseSubRelation> courseSubRelationList = courseSubRelationService.findByCourseId(courseId);
+        if (courseSubRelationList == null || courseSubRelationList.size() == 0) {
+            return subItemVoList;
+        }
+
+        List<String> lessonIdList = new ArrayList<>();
+        courseSubRelationList.forEach( relation -> {
+            if (CourseSubTypeEnum.LESSON.equals(relation.getType())) {
+                lessonIdList.add(relation.getSubId());
+            }
+        });
+
+        APIResult<List<Lesson>> lessonResult = lessonService.findByIds(lessonIdList);
+        List<Lesson> lessonList = lessonResult.getData();
+        if (lessonList != null && lessonList.size() > 0) {
+            lessonList.forEach(lesson -> subItemVoList.add(convert(lesson)));
+        }
+
+        return subItemVoList;
+    }
+
+    // find support by courseId
+    public List<Support> findSupportList(String courseId) {
+
+        List<CourseSupportRelation> supportRelationList = courseSupportRelationService.findByCourseId(courseId);
+        if (supportRelationList == null || supportRelationList.size() == 0) {
+            return new ArrayList<>();
+        }
+
+        List<String> supportIdList = new ArrayList<>();
+        supportRelationList.forEach( relation -> supportIdList.add(relation.getSupportId()));
+        APIResult<List<Support>> supportResult = supportService.findByIds(supportIdList);
+
+        return supportResult.getData();
+    }
+
+    // 更新二级关系
+    @Transactional
+    public APIResult<List<CourseSubItemVo>> updateSubRelation(String courseId, List<CourseSubRelationDTO> subRelationDTOList) {
+        // TODO: 暂时不考虑单元
+        if (subRelationDTOList == null) {
+            return APIResult.ok();
+        }else if (subRelationDTOList.size() == 0) {
+            courseSubRelationService.deleteByCourseId(courseId);
+            return APIResult.ok(new ArrayList<>());
+        }
+
+        List<String> lessonIdList = new ArrayList<>();
+        subRelationDTOList.forEach( relation -> {
+            if (CourseSubTypeEnum.LESSON.equals(relation.getType())) {
+                lessonIdList.add(relation.getId());
+            }
+        });
+
+        // 查课
+        APIResult<List<Lesson>> lessonResult = lessonService.findByIds(lessonIdList);
+        List<Lesson> lessonList = lessonResult.getData();
+        if (lessonList == null || lessonList.size() != lessonIdList.size()) {
+            return APIResult.error(APICodeManager.error("存在错误的课"));
+        }
+
+        courseSubRelationService.update(courseId, subRelationDTOList);
+
+        List<CourseSubItemVo> subItemVoList = new ArrayList<>();
+        lessonResult.getData().forEach( lesson -> {
+            subItemVoList.add(convert(lesson));
+        });
+
+        return APIResult.ok(subItemVoList);
+    }
+
+    // 更新周边关系
+    @Transactional
+    public APIResult<List<Support>> updateSupportRelation(String courseId, List<String> supportIdList) {
+        if (supportIdList == null) {
+            return APIResult.ok();
+        }
+
+        List<Support> supportList = new ArrayList<>();
+        if (supportIdList.size() == 0) {
+            courseSupportRelationService.deleteByCourseId(courseId);
+        }else {
+            APIResult<List<Support>> supportResult = supportService.findByIds(supportIdList);
+            supportList = supportResult.getData();
+            if (supportList == null || supportList.size() != supportIdList.size()) {
+                return APIResult.error(APICodeManager.error("存在错误的周边"));
+            }
+            courseSupportRelationService.update(courseId, supportIdList);
+        }
+
+        return APIResult.ok(supportList);
+    }
+}

rankin-product-service/src/main/java/cn/rankin/productservice/proxy/ItemServiceProxy.java

@@ -0,0 +1,111 @@
+package cn.rankin.productservice.proxy;
+
+import cn.rankin.common.utils.api.model.APICodeManager;
+import cn.rankin.common.utils.api.model.APIResult;
+import cn.rankin.common.utils.dto.product.ItemPriceDTO;
+import cn.rankin.common.utils.enums.EnumUtil;
+import cn.rankin.common.utils.enums.ItemTypeEnum;
+import cn.rankin.productservice.entity.Item;
+import cn.rankin.productservice.entity.ItemPrice;
+import cn.rankin.productservice.entity.Support;
+import cn.rankin.productservice.entity.Tag;
+import cn.rankin.productservice.service.ItemPriceService;
+import cn.rankin.productservice.service.ItemService;
+import cn.rankin.productservice.service.ItemTagRelationService;
+import cn.rankin.productservice.service.TagService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Service
+public class ItemServiceProxy {
+
+    @Autowired
+    private ItemService itemService;
+
+    @Autowired
+    private ItemPriceService itemPriceService;
+
+    @Autowired
+    private ItemTagRelationService tagRelationService;
+
+    @Autowired
+    private TagService tagService;
+
+    public Item loadItem(String itemId) {
+        Item item = itemService.findOne(itemId);
+        if (item == null) {
+            return null;
+        }
+
+        ItemTypeEnum itemType = item.getType();
+        if (itemType == ItemTypeEnum.COURSE) {
+
+        }
+
+        return null;
+    }
+
+    public List<Support> getSupport(Item item) {
+        return null;
+    }
+
+    public List<Tag> getTagList(Item item) {
+        return null;
+    }
+
+    @Transactional
+    public APIResult<List<ItemPrice>> updatePrice(String itemId, List<ItemPriceDTO> priceDTOList) {
+        List<ItemPrice> priceList = new ArrayList<>();
+        if (priceDTOList == null) {
+            return APIResult.ok();
+        }
+
+        if (priceDTOList.size() == 0) {
+            itemPriceService.deleteByItemId(itemId);
+        }else {
+            priceList = itemPriceService.update(itemId, priceDTOList).getData();
+        }
+
+        return APIResult.ok(priceList);
+    }
+
+    @Transactional
+    public APIResult<List<Tag>> updateTagRelation(String itemId, List<String> tagIdList) {
+        List<Tag> tagList = new ArrayList<>();
+        if (tagIdList == null) {
+            return APIResult.ok();
+        }
+
+        if (tagIdList.size() == 0) {
+            tagRelationService.deleteByItemId(itemId);
+        }else {
+            APIResult<List<Tag>> tagResult = tagService.findByIds(tagIdList);
+            tagList = tagResult.getData();
+            if (tagList == null || tagList.size() != tagIdList.size()) {
+                return APIResult.error(APICodeManager.error("包含错误的标签"));
+            }
+
+            Item item = itemService.findById(itemId).getData();
+            if (item == null) {
+                return APIResult.error(APICodeManager.error("商品不存在"));
+            }
+
+            String merchantId = item.getMerchantId();
+            ItemTypeEnum itemType = item.getType();
+            for (int i = 0; i < tagList.size(); i++) {
+                Tag tag = tagList.get(i);
+//                if (!tag.getMerchantId().equals(merchantId) || !EnumUtil.compare(itemType, tag.getType())) {
+//                    return APIResult.error(APICodeManager.error("包含错误的标签"));
+//                }
+            }
+
+            tagRelationService.updateByItem(itemId, tagIdList);
+        }
+
+        return APIResult.ok(tagList);
+    }
+}

rankin-product-service/src/main/java/cn/rankin/productservice/proxy/SupportServiceProxy.java

@@ -0,0 +1,57 @@
+package cn.rankin.productservice.proxy;
+
+import cn.rankin.common.utils.api.model.APICodeManager;
+import cn.rankin.common.utils.api.model.APIResult;
+import cn.rankin.productservice.entity.Support;
+import cn.rankin.productservice.entity.SupportSelfRelation;
+import cn.rankin.productservice.service.SupportSelfRelationService;
+import cn.rankin.productservice.service.SupportService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Service
+public class SupportServiceProxy {
+
+    @Autowired
+    private SupportService supportService;
+
+    @Autowired
+    private SupportSelfRelationService selfRelationService;
+
+    @Transactional
+    public APIResult<List<Support>> updateSelfRelation(String fid, List<String> tids) {
+        if (tids == null) {
+            return APIResult.ok();
+        }else if (tids.size() == 0) {
+            return APIResult.ok(new ArrayList<Support>());
+        }
+
+        APIResult<List<Support>> supportResult = supportService.findByIds(tids);
+        List<Support> supportList = supportResult.getData();
+        if (supportList == null || supportList.size() != tids.size()) {
+            return APIResult.error(APICodeManager.error("存在错误的周边id"));
+        }
+
+        selfRelationService.update(fid, tids);
+
+        return APIResult.ok(supportList);
+    }
+
+    public APIResult<List<Support>> getRelationSupport(String fid) {
+        List<SupportSelfRelation> relationList = selfRelationService.findByFid(fid);
+        if (relationList == null || relationList.size() == 0) {
+            return APIResult.ok(new ArrayList<>());
+        }
+
+        List<String> supportIdList = new ArrayList<>();
+        relationList.forEach( relation -> supportIdList.add(relation.getTid()));
+
+        APIResult<List<Support>> supportResult = supportService.findByIds(supportIdList);
+
+        return APIResult.ok(supportResult.getData());
+    }
+}

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

@@ -2,19 +2,25 @@ package cn.rankin.productservice.repository;
 
 import cn.rankin.common.utils.enums.BaseStatusEnum;
 import cn.rankin.common.utils.jpa.BasicJpaRepository;
+import cn.rankin.productservice.entity.Course;
 import org.springframework.data.jpa.repository.Modifying;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.query.Param;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.util.List;
+
 public interface CourseRepository extends BasicJpaRepository<Course, String> {
 
     Long countByCode(String code);
 
     Course findById(String id);
 
+    @Query(value = "select c from Course c where c.id in (:ids) and c.status = :status")
+    List<Course> findByIdIn(@Param("ids") List<String> ids, @Param("status") BaseStatusEnum status);
+
     @Transactional
     @Modifying(clearAutomatically = true)
     @Query(value = "update Course c set c.status = :status where c.id = :id")
-    Integer updateStatusById(@Param("id") String id, @Param("status") BaseStatusEnum status);
+    Integer deleteById(@Param("id") String id, @Param("status") BaseStatusEnum status);
 }

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

@@ -1,16 +1,27 @@
 package cn.rankin.productservice.repository;
 
+import cn.rankin.common.utils.enums.BaseStatusEnum;
 import cn.rankin.common.utils.jpa.BasicJpaRepository;
 import cn.rankin.productservice.entity.CourseSubRelation;
+import org.springframework.data.jpa.repository.Modifying;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.query.Param;
+import org.springframework.transaction.annotation.Transactional;
 
 import java.util.List;
 
 public interface CourseSubRelationRepository extends BasicJpaRepository<CourseSubRelation, String> {
 
-    Long deleteByCourseId(String courseId);
+    List<CourseSubRelation> findAllByCourseId(String courseId);
 
-    @Query(value = "select r from CourseSubRelation r where r.courseId = :courseId order by r.sort")
-    List<CourseSubRelation> findByCourseId(@Param("courseId") String courseId);
+    @Query(value = "select r from CourseSubRelation r where r.courseId = :courseId and r.status = :status order by r.sort")
+    List<CourseSubRelation> findByCourseId(@Param("courseId") String courseId, @Param("status") BaseStatusEnum status);
+
+    @Query(value = "select r from CourseSubRelation r where r.subId = :subId and r.status = :status")
+    List<CourseSubRelation> findBySubId(@Param("subId") String subId, @Param("status") BaseStatusEnum status);
+
+    @Transactional
+    @Modifying(clearAutomatically = true)
+    @Query(value = "update CourseSubRelation r set r.status = :status where r.courseId = :courseId")
+    Integer deleteByCourseId(@Param("courseId") String courseId, @Param("status") BaseStatusEnum status);
 }

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

@@ -0,0 +1,24 @@
+package cn.rankin.productservice.repository;
+
+import cn.rankin.common.utils.enums.BaseStatusEnum;
+import cn.rankin.common.utils.jpa.BasicJpaRepository;
+import cn.rankin.productservice.entity.CourseSupportRelation;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+public interface CourseSupportRelationRepository extends BasicJpaRepository<CourseSupportRelation, String> {
+
+    @Query(value = "select r from CourseSupportRelation r where r.courseId = :courseId and r.status = :status order by r.sort")
+    List<CourseSupportRelation> findByCourseId(@Param("courseId") String courseId, @Param("status") BaseStatusEnum status);
+
+    List<CourseSupportRelation> findAllByCourseId(String courseId);
+
+    @Transactional
+    @Modifying(clearAutomatically = true)
+    @Query(value = "update CourseSupportRelation r set r.status = :status where r.courseId = :courseId")
+    Integer deleteByCourseId(@Param("courseId") String courseId, @Param("status")BaseStatusEnum status);
+}

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

@@ -0,0 +1,22 @@
+package cn.rankin.productservice.repository;
+
+import cn.rankin.common.utils.enums.BaseStatusEnum;
+import cn.rankin.common.utils.jpa.BasicJpaRepository;
+import cn.rankin.productservice.entity.Group;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import org.springframework.transaction.annotation.Transactional;
+
+public interface GroupRepository extends BasicJpaRepository<Group, String> {
+
+    Long countByCode(String code);
+
+    @Query(value = "select g from Group g where g.id = :id and g.status = :status")
+    Group findNormalById(@Param("id") String id, @Param("status") BaseStatusEnum status);
+
+    @Transactional
+    @Modifying(clearAutomatically = true)
+    @Query(value = "update Group g set g.status = :status where g.id = :id")
+    Integer deleteById(@Param("id") String id, @Param("status")BaseStatusEnum status);
+}

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

@@ -1,14 +1,27 @@
 package cn.rankin.productservice.repository;
 
+import cn.rankin.common.utils.enums.BaseStatusEnum;
 import cn.rankin.common.utils.jpa.BasicJpaRepository;
 import cn.rankin.productservice.entity.ItemPrice;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import org.springframework.transaction.annotation.Transactional;
 
 import java.util.List;
 
 public interface ItemPriceRepository extends BasicJpaRepository<ItemPrice, String> {
 
+    List<ItemPrice> findByItemId(String itemId);
 
-    List<ItemPrice> findByItemId(Long itemId);
+    @Transactional
+    @Modifying(clearAutomatically = true)
+    @Query(value = "update ItemPrice p set p.status = :status where p.itemId = :itemId")
+    Integer deleteByItemId(@Param("itemId") String itemId, @Param("status") BaseStatusEnum status);
+
+    @Transactional
+    @Modifying(clearAutomatically = true)
+    @Query(value = "update ItemPrice p set p.status = :status where p.id not in (:ids)")
+    Integer deleteExcludeId(@Param("ids") List ids, @Param("status") BaseStatusEnum status);
 
-    Long countById(String id);
 }

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

@@ -8,9 +8,18 @@ import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.query.Param;
 
 import javax.transaction.Transactional;
+import java.util.List;
 
 public interface ItemRepository extends BasicJpaRepository<Item, String> {
 
+    @Query(value = "select i from Item i where i.subId = :subId and i.status = :status")
+    List<Item> findBySubId(@Param("subId") String subId, @Param("status") ItemStatusEnum status);
+
+    List<Item> findAllBySubId(String subId);
+
+    @Query(value = "select i from Item i where i.id in (:ids) and i.status <> :status")
+    List<Item> findAllByIdIn(@Param("ids") List<String> ids, @Param("status") ItemStatusEnum status);
+
     @Transactional
     @Modifying(clearAutomatically = true)
     @Query(value = "update Item i set i.status = :status where i.id = :itemId")

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

@@ -0,0 +1,31 @@
+package cn.rankin.productservice.repository;
+
+import cn.rankin.common.utils.enums.BaseStatusEnum;
+import cn.rankin.common.utils.jpa.BasicJpaRepository;
+import cn.rankin.productservice.entity.ItemTagRelation;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+public interface ItemTagRelationRepository extends BasicJpaRepository<ItemTagRelation, String> {
+
+    List<ItemTagRelation> findAllByItemId(String itemId);
+
+    @Query(value = "select r from ItemTagRelation r where r.tagId = :tagId and r.status = :status")
+    List<ItemTagRelation> findByTagId(@Param("tagId") String tagId, @Param("status") BaseStatusEnum status);
+
+    List<ItemTagRelation> findAllByTagId(String tagId);
+
+    @Transactional
+    @Modifying(clearAutomatically = true)
+    @Query(value = "update ItemTagRelation r set r.status = :status where r.itemId = :itemId")
+    Integer deleteByItemId(@Param("itemId") String itemId, @Param("status")BaseStatusEnum status);
+
+    @Transactional
+    @Modifying(clearAutomatically = true)
+    @Query(value = "update ItemTagRelation r set r.status = :status where r.tagId = :tagId")
+    Integer deleteByTagId(@Param("tagId") String tagId, @Param("status") BaseStatusEnum status);
+}

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

@@ -1,8 +1,13 @@
 package cn.rankin.productservice.repository;
 
+import cn.rankin.common.utils.enums.BaseStatusEnum;
 import cn.rankin.common.utils.jpa.BasicJpaRepository;
 import cn.rankin.productservice.entity.Lesson;
+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;
+import org.springframework.transaction.annotation.Transactional;
 
 import java.util.List;
 
@@ -12,4 +17,11 @@ public interface LessonRepository extends BasicJpaRepository<Lesson, String> {
     Long countByCode(String code);
 
     Long countByIdIn(List<String> ids);
+
+    List<Lesson> findByIdIn(@Param("ids") List<String> ids, @Param("status") BaseStatusEnum status);
+
+    @Transactional
+    @Modifying(clearAutomatically = true)
+    @Query(value = "update Lesson l set l.status = :status where l.id = :id")
+    Integer deleteById(@Param("id") String id, @Param("status")BaseStatusEnum status);
 }

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

@@ -1,11 +1,29 @@
 package cn.rankin.productservice.repository;
 
+import cn.rankin.common.utils.enums.BaseStatusEnum;
 import cn.rankin.common.utils.jpa.BasicJpaRepository;
 import cn.rankin.productservice.entity.LessonWareRelation;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import org.springframework.transaction.annotation.Transactional;
 
 import java.util.List;
 
 public interface LessonWareRelationRepository extends BasicJpaRepository<LessonWareRelation, String> {
 
-    List<LessonWareRelation> findByWareIdIn(List<String> wareids);
+    List<LessonWareRelation> findAllByWareId(String wareId);
+
+    List<LessonWareRelation> findAllByLessonId(String lessonId);
+
+    @Query(value = "select r from LessonWareRelation r where r.wareId = :wareId and r.status = :status")
+    List<LessonWareRelation> findByWareId(@Param("wareId") String wareId, @Param("status") BaseStatusEnum status);
+
+    @Query(value = "select r from LessonWareRelation r where r.lessonId = :lessonId and r.status = :status order by r.sort asc")
+    List<LessonWareRelation> findByLessonId(@Param("lessonId") String lessonId, @Param("status") BaseStatusEnum status);
+
+    @Transactional
+    @Modifying(clearAutomatically = true)
+    @Query(value = "update LessonWareRelation r set r.status = :status where r.lessonId = :lessonId")
+    Integer deleteByLessonId(@Param("lessonId") String lessonId, @Param("status") BaseStatusEnum status);
 }

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

@@ -14,7 +14,8 @@ public interface SupportRepository extends BasicJpaRepository<Support, String> {
 
     Long countByCode(String code);
 
-    Long countByIdIn(List<String> ids);
+    @Query(value = "select s from Support s where s.id in (:ids) and s.status = :status")
+    List<Support> findByIdIn(@Param("ids") List<String> ids, @Param("status") BaseStatusEnum status);
 
     @Transactional
     @Modifying(clearAutomatically = true)

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

@@ -1,16 +1,25 @@
 package cn.rankin.productservice.repository;
 
+import cn.rankin.common.utils.enums.BaseStatusEnum;
 import cn.rankin.common.utils.jpa.BasicJpaRepository;
 import cn.rankin.productservice.entity.SupportSelfRelation;
+import org.springframework.data.jpa.repository.Modifying;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.query.Param;
 
+import javax.transaction.Transactional;
 import java.util.List;
 
 public interface SupportSelfRelationRepository extends BasicJpaRepository<SupportSelfRelation, String> {
 
-   Long deleteAllByFid(String fid);
+    @Query(value = "select r from SupportSelfRelation r where r.fid = :fid and r.status = :status order by r.sort")
+    List<SupportSelfRelation> findByFid(@Param("fid") String fid, @Param("status") BaseStatusEnum status);
+
+    List<SupportSelfRelation> findAllByFid(String fid);
+
+    @Transactional
+    @Modifying(clearAutomatically = true)
+    @Query(value = "update SupportSelfRelation r set r.status = :status where r.fid = :fid")
+    Integer deleteByFid(@Param("fid") String fid, @Param("status")BaseStatusEnum status);
 
-   @Query(value = "select distinct s.tid from SupportSelfRelation s where s.fid = :fid")
-   List<String> findRefByFid(@Param("fid") String fid);
 }

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

@@ -13,12 +13,21 @@ import java.util.List;
 
 public interface TagRepository extends BasicJpaRepository<Tag, String> {
 
-    Long countByIdIn(List<String> ids);
+    List<Tag> findByIdss(List<String> tagIdList, BaseStatusEnum status);
 
-    Long countByCode(String code);
+    @Query(value = "select t from Tag t where t.groupId = :groupId and t.status = :status")
+    List<Tag> findNormalByGroupId(@Param("groupId") String groupId, @Param("status") BaseStatusEnum status);
+
+    @Query(value = "select t from Tag t where t.id in (:ids) and t.status = :status order by t.sort asc")
+    List<Tag> findByIdIn(@Param("ids") List<String> ids, @Param("status") BaseStatusEnum status);
 
     @Transactional
     @Modifying(clearAutomatically = true)
     @Query(value = "update Tag t set t.status = :status where t.id = :id")
     Integer updateStatusById(@Param("id") String id, @Param("status") BaseStatusEnum status);
+
+    @Transactional
+    @Modifying(clearAutomatically = true)
+    @Query(value = "update Tag t set t.status = :status where t.groupId = :groupId")
+    Integer deleteByGroupId(@Param("groupId") String groupId, @Param("status") BaseStatusEnum status);
 }

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

@@ -1,7 +1,10 @@
 package cn.rankin.productservice.repository;
 
+import cn.rankin.common.utils.enums.BaseStatusEnum;
 import cn.rankin.common.utils.jpa.BasicJpaRepository;
 import cn.rankin.productservice.entity.Ware;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
 import org.springframework.stereotype.Repository;
 
 import java.util.List;
@@ -13,4 +16,10 @@ public interface WareRepository extends BasicJpaRepository<Ware, String> {
 
     Long countByIdIn(List<String> Ids);
 
+    @Query(value = "update Ware w set w.status = :status  where w.id = :id")
+    Integer deleteAllById(@Param("id") String id, @Param("status") BaseStatusEnum status);
+
+    @Query(value = "select w from Ware w where w.id in (:ids) and w.status = :status")
+    List<Ware> findByIdIn(@Param("ids") List<String> ids, @Param("status") BaseStatusEnum status);
+
 }

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

@@ -0,0 +1,24 @@
+package cn.rankin.productservice.repository;
+
+import cn.rankin.common.utils.enums.BaseStatusEnum;
+import cn.rankin.productservice.entity.Tag;
+import org.springframework.stereotype.Component;
+import org.springframework.stereotype.Repository;
+
+import javax.persistence.EntityManager;
+import javax.persistence.PersistenceContext;
+import javax.persistence.Query;
+import java.util.List;
+
+@Repository
+public class tagRepositoryImpl {
+
+    @PersistenceContext
+    private EntityManager entityManager;
+
+    public List<Tag> findByIdss(List<String> tagIdList, BaseStatusEnum status) {
+        StringBuilder builder = new StringBuilder("select t.*, g.name as group_name, g.merchant_id from lj_tag t left outer join lj_group g on t.group_id = g.id where 1=1");
+        Query query = entityManager.createNativeQuery(builder.toString(), Tag.class);
+        return query.getResultList();
+    }
+}

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

@@ -4,23 +4,19 @@ import cn.rankin.common.utils.api.model.APICodeManager;
 import cn.rankin.common.utils.api.model.APIResult;
 import cn.rankin.common.utils.api.page.Page;
 import cn.rankin.common.utils.dto.product.CourseDTO;
-import cn.rankin.common.utils.dto.product.SubRelationDTO;
+import cn.rankin.common.utils.enums.BaseOrderEnum;
 import cn.rankin.common.utils.enums.BaseStatusEnum;
-import cn.rankin.common.utils.enums.CourseSubTypeEnum;
-import cn.rankin.common.utils.util.ListToMapUtil;
+import cn.rankin.common.utils.util.JpaSortUtil;
 import cn.rankin.productservice.entity.*;
 import cn.rankin.productservice.repository.*;
 import cn.rankin.productservice.utils.DTOConverter;
-import cn.rankin.productservice.vo.CourseSubItemVo;
-import com.alibaba.fastjson.JSON;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
-import java.util.ArrayList;
+import java.util.LinkedHashMap;
 import java.util.List;
-import java.util.Map;
 
 @Slf4j
 @Service
@@ -29,64 +25,12 @@ public class CourseService {
     @Autowired
     private CourseRepository courseRepository;
 
-    @Autowired
-    private LessonRepository lessonRepository;
-
-    @Autowired
-    private CourseSubRelationRepository subRelationRepository;
-
     public boolean exists(String code) {
         Long count = courseRepository.countByCode(code);
         return count > 0L;
     }
 
-    public boolean checkSubItemIds(List<SubRelationDTO> subRelationDTOList) {
-        // TODO: 目前只包含课
-        if (subRelationDTOList == null || subRelationDTOList.size() == 0) {
-            return true;
-        }
-
-        List<String> lessonIdList = new ArrayList<>();
-        subRelationDTOList.forEach( r -> {
-            String subId = r.getId();
-            CourseSubTypeEnum type = r.getType();
-            if (type.equals(CourseSubTypeEnum.LESSON)) {
-                lessonIdList.add(subId);
-            }
-        });
-        Long count = lessonRepository.countByIdIn(lessonIdList);
-        if (count < lessonIdList.size()) {
-            return false;
-        }
-        return true;
-    }
-
-    @Transactional
-    public List<CourseSubRelation> updateSubRelation(String courseId, List<SubRelationDTO> subRelationDTOList) {
-        // TODO: 暂时不考虑单元
-        if (subRelationDTOList == null) {
-            return null;
-        }
-
-        Long count = subRelationRepository.deleteByCourseId(courseId);
-        log.info("delete course sub item, code={}, num={}", courseId, String.valueOf(count));
-
-        List<CourseSubRelation> subRelationList = new ArrayList<>();
-        for (int i = 0; i < subRelationDTOList.size(); i++) {
-            SubRelationDTO relationDTO = subRelationDTOList.get(i);
-            CourseSubRelation relation = new CourseSubRelation();
-            relation.setCourseId(courseId);
-            relation.setSubId(relationDTO.getId());
-            relation.setType(relationDTO.getType());
-            relation.setSort(i);
-            subRelationList.add(relation);
-        }
-
-        List<CourseSubRelation> result = subRelationRepository.save(subRelationList);
-        return result;
-    }
-
-    public APIResult<Page<Course>> search(Course course, Integer pageNo, Integer pageSize) {
+    public APIResult<Page<Course>> search(Course course, Integer pageNo, Integer pageSize, LinkedHashMap<String, BaseOrderEnum> sort) {
         Long count = courseRepository.count(course);
         Page<Course> page = new Page(count, pageNo, pageSize);
 
@@ -94,7 +38,7 @@ public class CourseService {
             return APIResult.ok(page);
         }
 
-        List<Course> wareList = courseRepository.find(course, page.getStart(), pageSize);
+        List<Course> wareList = courseRepository.find(course, page.getStart(), pageSize, JpaSortUtil.sort(sort));
         page.setList(wareList);
 
         return APIResult.ok(page);
@@ -107,41 +51,24 @@ public class CourseService {
             return APIResult.error(APICodeManager.ALREADY_EXISTS);
         }
 
-        // sub item check
-        List<SubRelationDTO> subRelationDTOList = courseDTO.getSubList();
-        if (!checkSubItemIds(subRelationDTOList)) {
-            return APIResult.error(APICodeManager.error("包含错误课编码"));
-        }
-
-
         Course course = DTOConverter.convert(courseDTO);
         Course result = courseRepository.save(course);
 
-        String courseId = result.getId();
-        updateSubRelation(courseId, subRelationDTOList);
-
         return APIResult.ok(result);
     }
 
     @Transactional
     public APIResult<Course> update(CourseDTO courseDTO) {
-        List<SubRelationDTO> subRelationDTOList = courseDTO.getSubList();
-        if (!checkSubItemIds(subRelationDTOList)) {
-            return APIResult.error(APICodeManager.error("包含错误课编码"));
-        }
 
         Course course = DTOConverter.convert(courseDTO);
-        Course result = courseRepository.save(course);
-
-        String courseId = result.getId();
-        updateSubRelation(courseId, subRelationDTOList);
+        Course result = courseRepository.update(course);
 
         return APIResult.ok(result);
     }
 
     @Transactional
     public APIResult<Boolean> delete(String id) {
-        Integer count = courseRepository.updateStatusById(id, BaseStatusEnum.DEL);
+        Integer count = courseRepository.deleteById(id, BaseStatusEnum.DEL);
         if (count > 0) {
             return APIResult.ok(true);
         }
@@ -149,46 +76,17 @@ public class CourseService {
     }
 
     public APIResult<Course> findById(String id) {
-        //TODO: 目前只加载课, 不加载单元
         Course course = courseRepository.findById(id);
         if (course == null) {
             return APIResult.error(APICodeManager.NOT_EXISTS);
         }
 
-        // 你瞅瞅, 加上单元难不难?
-        List<CourseSubRelation> subRelationList = subRelationRepository.findByCourseId(id);
-        if (subRelationList == null || subRelationList.size() == 0) {
-            return APIResult.ok(course);
-        }
-
-        List<CourseSubItemVo> subItemVoList = new ArrayList<>();
-
-        List<String> lessonIdList = new ArrayList<>();
-        subRelationList.forEach( rel -> {
-            CourseSubTypeEnum type = rel.getType();
-            String subId = rel.getSubId();
-            if (type.equals(CourseSubTypeEnum.LESSON)) {
-                lessonIdList.add(subId);
-            }
-        });
-
-        List<Lesson> lessonList = lessonRepository.findByIds(lessonIdList);
-        log.info(JSON.toJSONString(lessonList));
-        Map<String, Lesson> lessonMap = new ListToMapUtil<String, Lesson>(lessonList).parse("id");
-
-        for(CourseSubRelation rel: subRelationList) {
-            String subCode = rel.getSubId();
-            CourseSubTypeEnum type = rel.getType();
-            if (type.equals(CourseSubTypeEnum.LESSON)) {
-                Lesson lesson = lessonMap.get(subCode);
-                CourseSubItemVo vo = CourseSubItemVo.parseToVo(lesson);
-                subItemVoList.add(vo);
-            }
-        }
-
-        course.setSubItemList(subItemVoList);
-
         return APIResult.ok(course);
     }
 
+    public APIResult<List<Course>> findAllByIds(List<String> courseIdList) {
+//        List<Course> courseList = courseRepository.findByIdIn(courseIdList, BaseStatusEnum.NORMAL);
+        List<Course> courseList = courseRepository.findByIds(courseIdList);
+        return APIResult.ok(courseIdList);
+    }
 }

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

@@ -0,0 +1,84 @@
+package cn.rankin.productservice.service;
+
+import cn.rankin.common.utils.dto.product.CourseSubRelationDTO;
+import cn.rankin.common.utils.enums.BaseStatusEnum;
+import cn.rankin.common.utils.util.ListUtil;
+import cn.rankin.productservice.entity.CourseSubRelation;
+import cn.rankin.productservice.repository.CourseSubRelationRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static cn.rankin.productservice.utils.DTOConverter.convert;
+
+@Service
+public class CourseSubRelationService {
+
+    @Autowired
+    private CourseSubRelationRepository subRelationRepository;
+
+    public List<CourseSubRelation> findByLessonId(String lessonId) {
+        return subRelationRepository.findBySubId(lessonId, BaseStatusEnum.NORMAL);
+    }
+
+    public List<CourseSubRelation> findByCourseId(String coursId) {
+        return subRelationRepository.findByCourseId(coursId, BaseStatusEnum.NORMAL);
+    }
+
+    @Transactional
+    public Integer deleteByCourseId(String courseId) {
+        return subRelationRepository.deleteByCourseId(courseId, BaseStatusEnum.DEL);
+    }
+
+    @Transactional
+    public void update(String courseId, List<CourseSubRelationDTO> subRelationDTOList) {
+        if (subRelationDTOList == null) {
+            return;
+        }else if (subRelationDTOList.size() == 0) {
+            deleteByCourseId(courseId);
+            return;
+        }
+
+        // 记录顺序数组: 最新的
+        List<String> subIdList = new ArrayList<>();
+
+        subRelationDTOList.forEach( e -> {
+            String subId = e.getId();
+            subIdList.add(subId);
+        });
+
+        // 更新现有的, 同时记录现有的关系
+        List<String> currentIdList = new ArrayList<>();
+        List<CourseSubRelation> currentRelationList = subRelationRepository.findAllByCourseId(courseId);
+        currentRelationList.forEach( e -> {
+            String subId = e.getSubId();
+            if (!subIdList.contains(subId)) {
+                e.setStatus(BaseStatusEnum.DEL);
+            }else {
+                e.setStatus(BaseStatusEnum.NORMAL);
+            }
+            currentIdList.add(subId);
+        });
+
+        // 新加的
+        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));
+            });
+        }
+
+        // 排序
+        currentRelationList.forEach( relation -> {
+            String subId = relation.getSubId();
+            Integer sort = subIdList.indexOf(subId);
+            relation.setSort(sort);
+        });
+
+        subRelationRepository.save(currentRelationList);
+    }
+}

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

@@ -0,0 +1,75 @@
+package cn.rankin.productservice.service;
+
+import cn.rankin.common.utils.enums.BaseStatusEnum;
+import cn.rankin.common.utils.util.ListUtil;
+import cn.rankin.productservice.entity.CourseSupportRelation;
+import cn.rankin.productservice.repository.CourseSupportRelationRepository;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Slf4j
+@Service
+public class CourseSupportRelationService {
+
+    @Autowired
+    private CourseSupportRelationRepository relationRepository;
+
+    public List<CourseSupportRelation> findByCourseId(String courseId) {
+        return relationRepository.findByCourseId(courseId, BaseStatusEnum.NORMAL);
+    }
+
+    @Transactional
+    public Integer deleteByCourseId(String courseId) {
+        return relationRepository.deleteByCourseId(courseId, BaseStatusEnum.DEL);
+    }
+
+    @Transactional
+    public void update(String courseId, List<String> supportIdList) {
+        if (supportIdList == null) {
+            return;
+        }else if (supportIdList.size() == 0) {
+            deleteByCourseId(courseId);
+            return;
+        }
+
+        List<CourseSupportRelation> relationList = relationRepository.findAllByCourseId(courseId);
+        List<String> existSupportIdList = new ArrayList<>();
+
+        // 更新现存的
+        relationList.forEach( relation -> {
+            String supportId = relation.getSupportId();
+            if (supportIdList.contains(supportId)) {
+                relation.setStatus(BaseStatusEnum.NORMAL);
+            }else {
+                relation.setStatus(BaseStatusEnum.DEL);
+            }
+            existSupportIdList.add(supportId);
+        });
+
+        // 更新新加的
+        List<String> notExistsSupportIdList = ListUtil.subtract(supportIdList, existSupportIdList);
+        if (notExistsSupportIdList != null && notExistsSupportIdList.size() > 0) {
+            notExistsSupportIdList.forEach( id -> {
+                CourseSupportRelation relation = new CourseSupportRelation();
+                relation.setCourseId(courseId);
+                relation.setSupportId(id);
+                relation.setStatus(BaseStatusEnum.NORMAL);
+                relationList.add(relation);
+            });
+        }
+
+        // 排序
+        relationList.forEach( relation -> {
+            String supportId = relation.getSupportId();
+            Integer sort = supportIdList.indexOf(supportId);
+            relation.setSort(sort);
+        });
+
+        relationRepository.save(relationList);
+    }
+}

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

@@ -0,0 +1,87 @@
+package cn.rankin.productservice.service;
+
+import cn.rankin.common.utils.api.model.APICodeManager;
+import cn.rankin.common.utils.api.model.APIResult;
+import cn.rankin.common.utils.api.page.Page;
+import cn.rankin.common.utils.dto.product.GroupDTO;
+import cn.rankin.common.utils.enums.BaseOrderEnum;
+import cn.rankin.common.utils.enums.BaseStatusEnum;
+import cn.rankin.common.utils.util.JpaSortUtil;
+import cn.rankin.productservice.entity.Group;
+import cn.rankin.productservice.repository.GroupRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.LinkedHashMap;
+import java.util.List;
+
+import static cn.rankin.productservice.utils.DTOConverter.convert;
+
+@Service
+public class GroupService {
+
+    @Autowired
+    private GroupRepository groupRepository;
+
+    public APIResult<Group> findById(String id) {
+        Group group = groupRepository.find(id);
+        if (group == null) {
+            return APIResult.error(APICodeManager.NOT_EXISTS);
+        }
+        return APIResult.ok(group);
+    }
+
+    public APIResult<Group> findNormalById(String id) {
+        Group group = groupRepository.findNormalById(id, BaseStatusEnum.NORMAL);
+        if (group == null) {
+            return APIResult.error(APICodeManager.NOT_EXISTS);
+        }
+        return APIResult.ok(group);
+    }
+
+    public APIResult<Page<Group>> search(Group group, Integer pageNo, Integer pageSize, LinkedHashMap<String, BaseOrderEnum> sort) {
+        Long count = groupRepository.count(group);
+
+        Page<Group> page = new Page<>(count, pageNo, pageSize);
+        if (count == 0) {
+            return APIResult.ok(page);
+        }
+
+        List<Group> groupList = groupRepository.find(group, page.getStart(), page.getPageSize(), JpaSortUtil.sort(sort));
+        page.setList(groupList);
+
+        return APIResult.ok(page);
+    }
+
+    public boolean exists(String code) {
+        Long count = groupRepository.countByCode(code);
+        return count > 0;
+    }
+
+    @Transactional
+    public APIResult<Group> create(GroupDTO groupDTO) {
+        String code = groupDTO.getCode();
+        if (exists(code)) {
+            return APIResult.error(APICodeManager.ALREADY_EXISTS);
+        }
+
+        Group group = convert(groupDTO);
+        Group result = groupRepository.save(group);
+
+        return APIResult.ok(result);
+    }
+
+    @Transactional
+    public APIResult<Group> update(GroupDTO groupDTO) {
+        Group group = convert(groupDTO);
+        Group result = groupRepository.update(group);
+        return APIResult.ok(result);
+    }
+
+    @Transactional
+    public APIResult<Boolean> delete(String id) {
+        Integer count = groupRepository.deleteById(id, BaseStatusEnum.DEL);
+        return APIResult.ok(count > 0);
+    }
+}

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

@@ -3,6 +3,9 @@ package cn.rankin.productservice.service;
 import cn.rankin.common.utils.api.model.APICodeManager;
 import cn.rankin.common.utils.api.model.APIResult;
 import cn.rankin.common.utils.dto.product.ItemPriceDTO;
+import cn.rankin.common.utils.enums.BaseStatusEnum;
+import cn.rankin.common.utils.util.ListUtil;
+import cn.rankin.productservice.entity.CourseSubRelation;
 import cn.rankin.productservice.entity.ItemPrice;
 import cn.rankin.productservice.repository.ItemPriceRepository;
 import lombok.extern.slf4j.Slf4j;
@@ -14,6 +17,8 @@ import javax.transaction.Transactional;
 import java.util.ArrayList;
 import java.util.List;
 
+import static cn.rankin.productservice.utils.DTOConverter.convert;
+
 @Slf4j
 @Service
 public class ItemPriceService {
@@ -21,85 +26,42 @@ public class ItemPriceService {
     @Autowired
     private ItemPriceRepository priceRepository;
 
-    public List<ItemPrice> findByItemId(Long itemId) {
-        return priceRepository.findByItemId(itemId);
-    }
-
-    public ItemPrice findById(String priceId) {
-        return priceRepository.find(priceId);
-    }
-
-    public boolean exists(ItemPriceDTO priceDTO) {
-        ItemPrice price = new ItemPrice();
-        price.setItemId(priceDTO.getItemId());
-        price.setType(priceDTO.getType());
-        price.setDuration(priceDTO.getDuration());
-
-        Long count = priceRepository.count(price);
-
-        return count > 0L;
-    }
-
+    // 传过来的数组, 更新status为NORMAL, 没有传的但存在于数据库的更新为DEL
     @Transactional
-    public APIResult<ItemPrice> create(ItemPriceDTO priceDTO) {
-        if (exists(priceDTO)) {
-            return APIResult.error(APICodeManager.ALREADY_EXISTS);
-        }
-
-        ItemPrice price = new ItemPrice();
-        BeanUtils.copyProperties(priceDTO, price);
-
-        ItemPrice result = priceRepository.save(price);
-        return APIResult.ok(result);
-    }
+    public APIResult<List<ItemPrice>> update(String itemId, List<ItemPriceDTO> priceDTOList) {
+        List<ItemPrice> priceList = new ArrayList<>();
 
-    @Transactional
-    public APIResult<ItemPrice> update(ItemPriceDTO priceDTO) {
-        if (!exists(priceDTO)) {
-            return APIResult.error(APICodeManager.NOT_EXISTS);
+        if (priceDTOList == null) {
+            return APIResult.ok();
+        }else if (priceDTOList.size() == 0) {
+            deleteByItemId(itemId);
+            return APIResult.ok(priceList);
         }
 
-        ItemPrice price = new ItemPrice();
-        BeanUtils.copyProperties(priceDTO, price);
-        ItemPrice result = priceRepository.update(price);
-
-        return APIResult.ok(result);
-    }
-
-    @Transactional
-    public APIResult<List<ItemPrice>> createMulti(List<ItemPriceDTO> priceDTOList) {
-        List<ItemPrice> priceList = new ArrayList<>();
-        priceDTOList.forEach( dto -> {
-            ItemPrice price = new ItemPrice();
-            BeanUtils.copyProperties(dto, price);
-            priceList.add(price);
-        });
+        List<String> priceIdList = new ArrayList<>();
+        for (int i = 0; i < priceDTOList.size(); i++) {
+            ItemPriceDTO dto = priceDTOList.get(i);
+            String priceId = dto.getId();
+            if (priceId != null) {
+                priceIdList.add(priceId);
+            }
+            ItemPrice itemPrice = convert(dto);
+            itemPrice.setStatus(BaseStatusEnum.NORMAL);
+            itemPrice.setSort(i);
+            priceList.add(itemPrice);
+        }
 
+        if (priceIdList.size() > 0) {
+            priceRepository.deleteExcludeId(priceIdList, BaseStatusEnum.DEL);
+        }
         List<ItemPrice> result = priceRepository.save(priceList);
 
         return APIResult.ok(result);
-    }
 
-    @Transactional
-    public APIResult<List<ItemPrice>> updateMulti(List<ItemPriceDTO> priceDTOList) {
-        List<ItemPrice> priceList = new ArrayList<>();
-        priceDTOList.forEach( dto -> {
-            ItemPrice price = new ItemPrice();
-            BeanUtils.copyProperties(dto, price);
-            priceList.add(price);
-        });
-
-        List<ItemPrice> result = priceRepository.update(priceList);
-        return APIResult.ok(result);
     }
 
     @Transactional
-    public APIResult<Boolean> deleteById(String priceId) {
-        Long count = priceRepository.countById(priceId);
-        if (count == 0) {
-            return APIResult.error(APICodeManager.NOT_EXISTS);
-        }
-        priceRepository.delete(priceId);
-        return APIResult.ok(true);
+    public Integer deleteByItemId(String itemId) {
+        return priceRepository.deleteByItemId(itemId, BaseStatusEnum.DEL);
     }
 }

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

@@ -4,11 +4,16 @@ import cn.rankin.common.utils.api.model.APICodeManager;
 import cn.rankin.common.utils.api.model.APIResult;
 import cn.rankin.common.utils.api.page.Page;
 import cn.rankin.common.utils.dto.product.ItemDTO;
+import cn.rankin.common.utils.enums.BaseOrderEnum;
+import cn.rankin.common.utils.enums.BaseStatusEnum;
 import cn.rankin.common.utils.enums.ItemStatusEnum;
+import cn.rankin.common.utils.enums.ItemTypeEnum;
+import cn.rankin.common.utils.util.JpaSortUtil;
 import cn.rankin.productservice.entity.Item;
 import cn.rankin.productservice.repository.*;
 import cn.rankin.productservice.utils.DTOConverter;
 import lombok.extern.slf4j.Slf4j;
+import org.aspectj.weaver.ast.ITestVisitor;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
@@ -22,20 +27,39 @@ public class ItemService {
     @Autowired
     private ItemRepository itemRepository;
 
-    @Autowired
-    private CourseRepository courseRepository;
-
-    public boolean checkCourseCode(String code) {
-        Long count = courseRepository.countByCode(code);
-        return count > 0L;
-    }
-
     public boolean exists(Item item) {
         Long count = itemRepository.count(item);
         return count > 0L;
     }
 
-    public APIResult<Page<Item>> search(Item item, Integer pageNo, Integer pageSize) {
+    public APIResult<List<Item>> findAllBySubId(String courseId) {
+        List<Item> itemList = itemRepository.findAllBySubId(courseId);
+        return APIResult.ok(itemList);
+    }
+
+    public APIResult<List<Item>> findAllByIds(List<String> ids) {
+        List<Item> itemList = itemRepository.findByIds(ids);
+        return APIResult.ok(itemList);
+    }
+
+    public APIResult<List<Item>> findAllByIds(List<String> ids, ItemStatusEnum status) {
+        List<Item> itemList = itemRepository.findAllByIdIn(ids, status);
+        return APIResult.ok(itemList);
+    }
+
+    public APIResult<Item> findById(String itemId) {
+        Item item = itemRepository.find(itemId);
+        if (!ItemStatusEnum.DEL.equals(item.getStatus())) {
+            return APIResult.ok(item);
+        }
+        return APIResult.error(APICodeManager.NOT_EXISTS);
+    }
+
+    public Item findOne(String itemId) {
+        return itemRepository.find(itemId);
+    }
+
+    public APIResult<Page<Item>> search(Item item, Integer pageNo, Integer pageSize, LinkedHashMap<String, BaseOrderEnum> sort) {
         Long count = itemRepository.count(item);
         Page<Item> page = new Page(count, pageNo, pageSize);
 
@@ -43,7 +67,7 @@ public class ItemService {
             return APIResult.ok(page);
         }
 
-        List<Item> itemList = itemRepository.find(item, page.getStart(), pageSize);
+        List<Item> itemList = itemRepository.find(item, page.getStart(), pageSize, JpaSortUtil.sort(sort));
         page.setList(itemList);
 
         return APIResult.ok(page);
@@ -51,12 +75,6 @@ public class ItemService {
 
     @Transactional
     public APIResult<Item> create(ItemDTO itemDTO) {
-        // 检查course是否存在
-        String code = itemDTO.getCode();
-        if (!checkCourseCode(code)) {
-            return APIResult.error(APICodeManager.error("课程不存在"));
-        }
-
         // 检查course与merchantId的唯一性
         Item sample = new Item();
         sample.setSubId(itemDTO.getSubId());
@@ -83,12 +101,6 @@ public class ItemService {
 
     @Transactional
     public APIResult<Item> update(ItemDTO itemDTO) {
-        // 检查course是否存在
-        String code = itemDTO.getCode();
-        if (!checkCourseCode(code)) {
-            return APIResult.error(APICodeManager.error("课程不存在"));
-        }
-
         // 检查course与merchantId是否存在
         Item sample = new Item();
         sample.setSubId(itemDTO.getSubId());

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

@@ -0,0 +1,119 @@
+package cn.rankin.productservice.service;
+
+import cn.rankin.common.utils.enums.BaseStatusEnum;
+import cn.rankin.common.utils.util.ListUtil;
+import cn.rankin.productservice.entity.ItemTagRelation;
+import cn.rankin.productservice.repository.ItemTagRelationRepository;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Slf4j
+@Service
+public class ItemTagRelationService {
+
+    @Autowired
+    private ItemTagRelationRepository relationRepository;
+
+    public List<ItemTagRelation> findAllByTagId(String id) {
+        return relationRepository.findAllByTagId(id);
+    }
+
+    public List<ItemTagRelation> findByTagId(String id) {
+        return relationRepository.findByTagId(id, BaseStatusEnum.NORMAL);
+    }
+
+    @Transactional
+    public Integer deleteByItemId(String itemId) {
+        return relationRepository.deleteByItemId(itemId, BaseStatusEnum.DEL);
+    }
+
+    @Transactional
+    public Integer deleteByTagId(String tagId) {
+        return relationRepository.deleteByTagId(tagId, BaseStatusEnum.DEL);
+    }
+
+    @Transactional
+    public void updateByItem(String itemId, List<String> tagIdList) {
+        if (tagIdList == null) {
+            return;
+        }else if (tagIdList.size() == 0) {
+            deleteByItemId(itemId);
+            return;
+        }
+
+        List<ItemTagRelation> relationList = relationRepository.findAllByItemId(itemId);
+
+        List<String> currentIdList = new ArrayList<>();
+        relationList.forEach( relation -> {
+            String tagId = relation.getTagId();
+            if (!tagIdList.contains(tagId)) {
+                relation.setStatus(BaseStatusEnum.DEL);
+            }else {
+                relation.setStatus(BaseStatusEnum.NORMAL);
+            }
+            currentIdList.add(tagId);
+        });
+
+        List<String> notExistTagIdList = ListUtil.subtract(tagIdList, currentIdList);
+        if (notExistTagIdList != null && notExistTagIdList.size() > 0) {
+            notExistTagIdList.forEach( tagId -> {
+                ItemTagRelation relation = new ItemTagRelation();
+                relation.setItemId(itemId);
+                relation.setTagId(tagId);
+                relation.setSort(0);
+                relation.setStatus(BaseStatusEnum.NORMAL);
+                relationList.add(relation);
+            });
+        }
+
+        relationRepository.save(relationList);
+    }
+
+    @Transactional
+    public void updateByTag(String tagId, List<String> itemIdList) {
+        if (itemIdList == null) {
+            return;
+        }else if (itemIdList.size() == 0) {
+            deleteByItemId(tagId);
+            return;
+        }
+
+        List<ItemTagRelation> relationList = relationRepository.findAllByTagId(tagId);
+
+        List<String> currentIdList = new ArrayList<>();
+        relationList.forEach( relation -> {
+            String itemId = relation.getItemId();
+            if (itemIdList.contains(itemId)) {
+                relation.setStatus(BaseStatusEnum.NORMAL);
+            }else {
+                relation.setStatus(BaseStatusEnum.DEL);
+            }
+            currentIdList.add(itemId);
+        });
+
+        List<String> notExistItemIdList = ListUtil.subtract(itemIdList, currentIdList);
+        if (notExistItemIdList != null && notExistItemIdList.size() > 0) {
+            notExistItemIdList.forEach( itemId -> {
+                ItemTagRelation relation = new ItemTagRelation();
+                relation.setItemId(itemId);
+                relation.setTagId(tagId);
+                relation.setStatus(BaseStatusEnum.NORMAL);
+                relationList.add(relation);
+            });
+        }
+
+        // 排序
+        relationList.forEach( relation -> {
+            String itemId = relation.getItemId();
+            Integer index = itemIdList.indexOf(itemId);
+            relation.setSort(index);
+        });
+
+        relationRepository.save(relationList);
+    }
+}

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

@@ -4,18 +4,24 @@ import cn.rankin.common.utils.api.model.APICodeManager;
 import cn.rankin.common.utils.api.model.APIResult;
 import cn.rankin.common.utils.api.page.Page;
 import cn.rankin.common.utils.dto.product.LessonDTO;
+import cn.rankin.common.utils.enums.BaseOrderEnum;
+import cn.rankin.common.utils.enums.BaseStatusEnum;
+import cn.rankin.common.utils.util.JpaSortUtil;
+import cn.rankin.common.utils.util.ListUtil;
 import cn.rankin.productservice.entity.Lesson;
 import cn.rankin.productservice.repository.LessonRepository;
-import cn.rankin.productservice.repository.WareRepository;
+import cn.rankin.productservice.utils.DTOConverter;
 import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.util.ArrayList;
+import java.util.LinkedHashMap;
 import java.util.List;
-import java.util.Set;
+import java.util.Map;
+
+import static cn.rankin.productservice.utils.DTOConverter.convert;
 
 @Slf4j
 @Service
@@ -24,10 +30,31 @@ public class LessonService {
     @Autowired
     private LessonRepository lessonRepository;
 
-    @Autowired
-    private WareRepository wareRepository;
+    public APIResult<List<Lesson>> findAllByIds(List<String> lessonIds) {
+        List<Lesson> lessonList = lessonRepository.findByIds(lessonIds);
+        return APIResult.ok(lessonList);
+    }
+
+    public APIResult<List<Lesson>> findByIds(List<String> lessonIds) {
+        List<Lesson> lessonList = lessonRepository.findByIdIn(lessonIds, BaseStatusEnum.NORMAL);
+
+        if (lessonList == null || lessonList.size() == 0) {
+            return APIResult.ok(lessonList);
+        }
 
-    public APIResult<Page<Lesson>> search(Lesson lesson, Integer pageNo, Integer pageSize) {
+        Map<String, Lesson> lessonMap = ListUtil.convert(lessonList, "id", Lesson.class);
+        List<Lesson> sortLessonList = new ArrayList<>();
+        lessonIds.forEach( id -> {
+            Lesson lesson = lessonMap.get(id);
+            if (lesson != null) {
+                sortLessonList.add(lesson);
+            }
+        });
+
+        return APIResult.ok(sortLessonList);
+    }
+
+    public APIResult<Page<Lesson>> search(Lesson lesson, Integer pageNo, Integer pageSize, LinkedHashMap<String, BaseOrderEnum> sort) {
         Long count = lessonRepository.count(lesson);
         Page<Lesson> page = new Page(count, pageNo, pageSize);
 
@@ -35,32 +62,12 @@ public class LessonService {
             return APIResult.ok(page);
         }
 
-        List<Lesson> wareList = lessonRepository.find(lesson, page.getStart(), pageSize);
-        page.setList(wareList);
+        List<Lesson> lessonList = lessonRepository.find(lesson, page.getStart(), pageSize, JpaSortUtil.sort(sort));
+        page.setList(lessonList);
 
         return APIResult.ok(page);
     }
 
-    public static Lesson convert(LessonDTO lessonDTO) {
-        Lesson lesson = new Lesson();
-        BeanUtils.copyProperties(lessonDTO, lesson);
-
-//        List<WareDTO> wareDTOList = lessonDTO.getWareList();
-//        if (CollectionUtils.isEmpty(wareDTOList)) {
-//            return lesson;
-//        }
-//
-//        List<Ware> wareList = new ArrayList<>();
-//        wareDTOList.forEach( dto -> {
-//            Ware ware = new Ware();
-//            BeanUtils.copyProperties(dto, ware);
-//            wareList.add(ware);
-//        });
-//
-//        lesson.setWareList(wareList);
-        return lesson;
-    }
-
     public APIResult<Lesson> findById(String id) {
         Lesson lesson = lessonRepository.find(id);
         if (lesson == null) {
@@ -75,21 +82,6 @@ public class LessonService {
         return count > 0L;
     }
 
-    public boolean checkWareIds(Set<String> wareIdSet) {
-        if (wareIdSet == null || wareIdSet.size() == 0) {
-            return true;
-        }
-
-        List<String> wareIdList = new ArrayList<>();
-        wareIdList.addAll(wareIdSet);
-
-        Long count = wareRepository.countByIdIn(wareIdList);
-        if (count < wareIdSet.size()) {
-            return false;
-        }
-        return true;
-    }
-
     @Transactional
     public APIResult<Lesson> create(LessonDTO lessonDTO) {
         String code = lessonDTO.getCode();
@@ -97,40 +89,23 @@ public class LessonService {
             return APIResult.error(APICodeManager.ALREADY_EXISTS);
         }
 
-//        Set<String> wareIdSet = lessonDTO.getWareList();
-//        if (!checkWareIds(wareIdSet)) {
-//            log.error("lesson: {} contains error ware code: {}", code, JSON.toJSONString(wareIdSet));
-//            return APIResult.error(APICodeManager.error("包含错误的课件"));
-//        }
-
         Lesson lesson = convert(lessonDTO);
         Lesson result = lessonRepository.save(lesson);
 
-//        String lessonId = result.getId();
-//        updateWareRelation(lessonId, wareIdSet);
-
         return APIResult.ok(result);
     }
 
     @Transactional
-    public APIResult<Lesson> update(Lesson lessonDTO) {
-//        Set<String> wareIdSet = lessonDTO.getWareList();
-//        if (!checkWareIds(wareIdSet)) {
-//            return APIResult.error(APICodeManager.error("包含错误的课件"));
-//        }
-
-//        Lesson lesson = convert(lessonDTO);
-        Lesson result = lessonRepository.update(lessonDTO);
-
-//        String lessonId = result.getId();
-//        updateWareRelation(lessonId, wareIdSet);
+    public APIResult<Lesson> update(LessonDTO lessonDTO) {
+        Lesson lesson = DTOConverter.convert(lessonDTO);
+        Lesson result = lessonRepository.update(lesson);
 
         return APIResult.ok(result);
     }
 
     @Transactional
     public APIResult<Boolean> delete(String id) {
-        lessonRepository.delete(id);
+        lessonRepository.deleteById(id, BaseStatusEnum.DEL);
         return APIResult.ok(true);
     }
 

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

@@ -1,11 +1,15 @@
 package cn.rankin.productservice.service;
 
+import cn.rankin.common.utils.enums.BaseStatusEnum;
+import cn.rankin.common.utils.util.ListUtil;
 import cn.rankin.productservice.entity.LessonWareRelation;
 import cn.rankin.productservice.repository.LessonWareRelationRepository;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 
+import java.util.ArrayList;
 import java.util.List;
 
 @Slf4j
@@ -15,7 +19,62 @@ public class LessonWareRelationService {
     @Autowired
     private LessonWareRelationRepository relationRepository;
 
-    public List<LessonWareRelation> findByWareIds(List<String> wareIds) {
-        return relationRepository.findByWareIdIn(wareIds);
+    public List<LessonWareRelation> findByWareId(String wareId) {
+        return relationRepository.findByWareId(wareId, BaseStatusEnum.NORMAL);
+    }
+
+    public List<LessonWareRelation> findByLessonId(String lessonId) {
+        return relationRepository.findByLessonId(lessonId, BaseStatusEnum.NORMAL);
+    }
+
+    @Transactional
+    public Integer deleteByLessonId(String lessonId) {
+        return relationRepository.deleteByLessonId(lessonId, BaseStatusEnum.DEL);
+    }
+
+    @Transactional
+    public void update(String lessonId, List<String> wareIdList) {
+        if (wareIdList == null) {
+            return;
+        }else if (wareIdList.size() == 0) {
+            deleteByLessonId(lessonId);
+            return;
+        }
+
+        List<LessonWareRelation> relationList = relationRepository.findAllByLessonId(lessonId);
+        List<String> existWareIdList = new ArrayList<>();
+
+        // 更新现存的
+        relationList.forEach( relation -> {
+            String wareId = relation.getWareId();
+            if (wareIdList.contains(wareId)) {
+                relation.setStatus(BaseStatusEnum.NORMAL);
+            }else {
+                relation.setStatus(BaseStatusEnum.DEL);
+            }
+            existWareIdList.add(wareId);
+        });
+
+        // 更新新加的
+        List<String> notExistsWareIdList = ListUtil.subtract(wareIdList, existWareIdList);
+        if (notExistsWareIdList != null && notExistsWareIdList.size() > 0) {
+            notExistsWareIdList.forEach( id -> {
+                LessonWareRelation relation = new LessonWareRelation();
+                relation.setLessonId(lessonId);
+                relation.setWareId(id);
+                relation.setStatus(BaseStatusEnum.NORMAL);
+                relationList.add(relation);
+            });
+        }
+
+        // 排序
+        relationList.forEach( relation -> {
+            String wareId = relation.getWareId();
+            Integer sort = wareIdList.indexOf(wareId);
+            relation.setSort(sort);
+        });
+
+        relationRepository.save(relationList);
+
     }
 }

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

@@ -0,0 +1,73 @@
+package cn.rankin.productservice.service;
+
+import cn.rankin.common.utils.enums.BaseStatusEnum;
+import cn.rankin.common.utils.util.ListUtil;
+import cn.rankin.productservice.entity.SupportSelfRelation;
+import cn.rankin.productservice.repository.SupportSelfRelationRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import javax.transaction.Transactional;
+import java.util.ArrayList;
+import java.util.List;
+
+@Service
+public class SupportSelfRelationService {
+
+    @Autowired
+    private SupportSelfRelationRepository relationRepository;
+
+    @Transactional
+    public Integer deleteBySupportId(String supportId) {
+        return relationRepository.deleteByFid(supportId, BaseStatusEnum.DEL);
+    }
+
+    public List<SupportSelfRelation> findByFid(String fid) {
+        return relationRepository.findByFid(fid, BaseStatusEnum.NORMAL);
+    }
+
+    @Transactional
+    public void update(String supportId, List<String> supportIdList) {
+        if (supportIdList == null) {
+            return;
+        }else if (supportIdList.size() == 0) {
+            deleteBySupportId(supportId);
+            return;
+        }
+
+        List<SupportSelfRelation> relationList = relationRepository.findAllByFid(supportId);
+        List<String> existSupportIdList = new ArrayList<>();
+
+        // 更新现存的
+        relationList.forEach( relation -> {
+            String tid = relation.getTid();
+            if (supportIdList.contains(tid)) {
+                relation.setStatus(BaseStatusEnum.NORMAL);
+            }else {
+                relation.setStatus(BaseStatusEnum.DEL);
+            }
+            existSupportIdList.add(tid);
+        });
+
+        // 更新新加的
+        List<String> notExistsSupportIdList = ListUtil.subtract(supportIdList, existSupportIdList);
+        if (notExistsSupportIdList != null && notExistsSupportIdList.size() > 0) {
+            notExistsSupportIdList.forEach( id -> {
+                SupportSelfRelation relation = new SupportSelfRelation();
+                relation.setFid(supportId);
+                relation.setTid(id);
+                relation.setStatus(BaseStatusEnum.NORMAL);
+                relationList.add(relation);
+            });
+        }
+
+        // 排序
+        relationList.forEach( relation -> {
+            String tid = relation.getTid();
+            Integer sort = supportIdList.indexOf(tid);
+            relation.setSort(sort);
+        });
+
+        relationRepository.save(relationList);
+    }
+}

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

@@ -4,7 +4,10 @@ import cn.rankin.common.utils.api.model.APICodeManager;
 import cn.rankin.common.utils.api.model.APIResult;
 import cn.rankin.common.utils.api.page.Page;
 import cn.rankin.common.utils.dto.product.SupportDTO;
+import cn.rankin.common.utils.enums.BaseOrderEnum;
 import cn.rankin.common.utils.enums.BaseStatusEnum;
+import cn.rankin.common.utils.util.JpaSortUtil;
+import cn.rankin.common.utils.util.ListUtil;
 import cn.rankin.productservice.entity.Support;
 import cn.rankin.productservice.entity.SupportSelfRelation;
 import cn.rankin.productservice.repository.SupportRepository;
@@ -15,10 +18,9 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
+import java.util.*;
+
+import static cn.rankin.productservice.utils.DTOConverter.convert;
 
 @Slf4j
 @Service
@@ -27,26 +29,30 @@ public class SupportService {
     @Autowired
     private SupportRepository supportRepository;
 
-    @Autowired
-    private SupportSelfRelationRepository selfRelationRepository;
-
-    public static Support convert(SupportDTO supportDTO) {
-        Support support = new Support();
-        BeanUtils.copyProperties(supportDTO, support);
-        Set<String> supportIdSet = supportDTO.getSupportList();
-        if (supportIdSet != null && supportIdSet.size() > 0) {
-            Set<Support> supportSet = new HashSet<>();
-            supportIdSet.forEach( e -> {
-                Support s = new Support();
-                s.setId(e);
-                supportSet.add(s);
-            });
-            support.setSupportList(supportSet);
+    public boolean exists(String code) {
+        Long count = supportRepository.countByCode(code);
+        return count > 0;
+    }
+
+    public APIResult<List<Support>> findByIds(List<String> supportIdList) {
+        List<Support> supportList = supportRepository.findByIdIn(supportIdList, BaseStatusEnum.NORMAL);
+        if (supportList == null || supportList.size() == 0) {
+            return APIResult.ok(supportList);
         }
-        return support;
+
+        Map<String, Support> supportMap = ListUtil.convert(supportList, "id", Support.class);
+        List<Support> sortSupportList = new ArrayList<>();
+        supportIdList.forEach( id -> {
+            Support support = supportMap.get(id);
+            if (support != null) {
+                sortSupportList.add(support);
+            }
+        });
+
+        return APIResult.ok(supportList);
     }
 
-    public APIResult<Page<Support>> search(Support support, Integer pageNo, Integer pageSize) {
+    public APIResult<Page<Support>> search(Support support, Integer pageNo, Integer pageSize, LinkedHashMap<String, BaseOrderEnum> sort) {
         Long count = supportRepository.count(support);
         Page<Support> page = new Page(count, pageNo, pageSize);
 
@@ -54,50 +60,12 @@ public class SupportService {
             return APIResult.ok(page);
         }
 
-        List<Support> supportList = supportRepository.find(support, page.getStart(), pageSize);
+        List<Support> supportList = supportRepository.find(support, page.getStart(), pageSize, JpaSortUtil.sort(sort));
         page.setList(supportList);
 
         return APIResult.ok(page);
     }
 
-    public boolean exists(String code) {
-        Long count = supportRepository.countByCode(code);
-        return count > 0;
-    }
-
-    public boolean checkSupportIds(Set<String> supportSet) {
-        if (supportSet == null || supportSet.size() == 0) {
-            return true;
-        }
-
-        List<String> supportIdList = new ArrayList<>();
-        supportIdList.addAll(supportSet);
-        Long count = supportRepository.countByIdIn(supportIdList);
-        if (count < supportSet.size()) {
-            return false;
-        }
-        return true;
-    }
-
-    @Transactional
-    public List<SupportSelfRelation> updateSupportList(String supportId, Set<String> supportIdSet) {
-        if (supportIdSet == null) {
-            return null;
-        }
-
-        selfRelationRepository.deleteAllByFid(supportId);
-
-        List<SupportSelfRelation> supportSelfRelationList = new ArrayList<>();
-        for (String s : supportIdSet) {
-            SupportSelfRelation relation = new SupportSelfRelation();
-            relation.setFid(supportId);
-            relation.setTid(s);
-            supportSelfRelationList.add(relation);
-        }
-
-        return selfRelationRepository.save(supportSelfRelationList);
-    }
-
     @Transactional
     public APIResult<Support> create(SupportDTO supportDTO) {
         String code = supportDTO.getCode();
@@ -105,32 +73,17 @@ public class SupportService {
             return APIResult.error(APICodeManager.ALREADY_EXISTS);
         }
 
-        Set<String> supportIdSet = supportDTO.getSupportList();
-        if (!checkSupportIds(supportIdSet)) {
-            return APIResult.error(APICodeManager.error("包含错误的id"));
-        }
-
         Support support = convert(supportDTO);
         Support result = supportRepository.save(support);
-
-        String supportId = result.getId();
-        updateSupportList(supportId, supportIdSet);
-
         return APIResult.ok(result);
     }
 
     @Transactional
     public APIResult<Support> update(SupportDTO supportDTO) {
-//        Set<String> supportIdSet = supportDTO.getSupportList();
-//        if (!checkSupportIds(supportIdSet)) {
-//            return APIResult.error(APICodeManager.error("存在错误的周边编号"));
-//        }
 
         Support support = convert(supportDTO);
-        Support result = supportRepository.save(support);
+        Support result = supportRepository.update(support);
         
-//        String supportId = result.getId();
-//        updateSupportList(supportId, supportIdSet);
         return APIResult.ok(result);
     }
 
@@ -145,20 +98,10 @@ public class SupportService {
     }
 
     public APIResult<Support> findById(String id) {
-//        SupportVo supportVo = new SupportVo();
         Support support = supportRepository.find(id);
         if (support == null) {
             return APIResult.error(APICodeManager.NOT_EXISTS);
         }
-//        }else {
-//            BeanUtils.copyProperties(support, supportVo);
-//        }
-
-//        List<String> supportIdList = selfRelationRepository.findRefByFid(id);
-//        List<Support> supportList = supportRepository.findByIds(supportIdList);
-//
-//        supportVo.setSupportList(supportList);
-
         return APIResult.ok(support);
     }
 

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

@@ -4,17 +4,23 @@ import cn.rankin.common.utils.api.model.APICodeManager;
 import cn.rankin.common.utils.api.model.APIResult;
 import cn.rankin.common.utils.api.page.Page;
 import cn.rankin.common.utils.dto.product.TagDTO;
+import cn.rankin.common.utils.enums.BaseOrderEnum;
 import cn.rankin.common.utils.enums.BaseStatusEnum;
+import cn.rankin.common.utils.util.JpaSortUtil;
 import cn.rankin.productservice.entity.Tag;
 import cn.rankin.productservice.repository.TagRepository;
 import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.BeanUtils;
+import org.apache.commons.lang.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
 import java.util.List;
 
+import static cn.rankin.productservice.utils.DTOConverter.convert;
+
 @Slf4j
 @Service
 public class TagService {
@@ -22,7 +28,17 @@ public class TagService {
     @Autowired
     private TagRepository tagRepository;
 
-    public APIResult<Page<Tag>> search(Tag tag, Integer pageNo, Integer pageSize) {
+    public APIResult<Tag> findById(String id) {
+        Tag tag = tagRepository.find(id);
+        return APIResult.ok(tag);
+    }
+
+    public APIResult<List<Tag>> findByIds(List<String> tagIdList) {
+        List<Tag> tagList = tagRepository.findByIdIn(tagIdList, BaseStatusEnum.NORMAL);
+        return APIResult.ok(tagList);
+    }
+
+    public APIResult<Page<Tag>> search(Tag tag, Integer pageNo, Integer pageSize, LinkedHashMap<String, BaseOrderEnum> sort) {
         Long count = tagRepository.count(tag);
         Page<Tag> page = new Page(count, pageNo, pageSize);
 
@@ -30,29 +46,14 @@ public class TagService {
             return APIResult.ok(page);
         }
 
-        List<Tag> tagList = tagRepository.find(tag, page.getStart(), pageSize);
+        List<Tag> tagList = tagRepository.find(tag, page.getStart(), pageSize, JpaSortUtil.sort(sort));
         page.setList(tagList);
 
         return APIResult.ok(page);
     }
 
-    public boolean exists(String code) {
-        Long count = tagRepository.countByCode(code);
-        return count > 0L;
-    }
-
-    public static Tag convert(TagDTO tagDTO) {
-        Tag tag = new Tag();
-        BeanUtils.copyProperties(tagDTO, tag);
-        return tag;
-    }
-
     @Transactional
     public APIResult<Tag> create(TagDTO tagDTO) {
-        String code = tagDTO.getCode();
-        if (exists(code)) {
-            return APIResult.error(APICodeManager.ALREADY_EXISTS);
-        }
 
         Tag tag = convert(tagDTO);
         Tag result = tagRepository.save(tag);
@@ -62,10 +63,6 @@ public class TagService {
 
     @Transactional
     public APIResult<Tag> update(TagDTO tagDTO) {
-        String code = tagDTO.getCode();
-        if (!exists(code)) {
-            return APIResult.error(APICodeManager.NOT_EXISTS);
-        }
 
         Tag tag = convert(tagDTO);
         Tag result = tagRepository.update(tag);
@@ -81,4 +78,55 @@ public class TagService {
         }
         return APIResult.error(APICodeManager.NOT_EXISTS);
     }
+
+    @Transactional
+    public APIResult<Boolean> deleteByGroupId(String groupId) {
+        tagRepository.deleteByGroupId(groupId, BaseStatusEnum.DEL);
+        return APIResult.ok(true);
+    }
+
+    public APIResult<List<Tag>> findNormalByGroupId(String groupId) {
+        List<Tag> tagList = tagRepository.findNormalByGroupId(groupId, BaseStatusEnum.NORMAL);
+        return APIResult.ok(tagList);
+    }
+
+    @Transactional
+    public APIResult<List<Tag>> updateGroupRelation(String groupId, List<TagDTO> tagDTOList) {
+        if (tagDTOList == null) {
+            return APIResult.ok();
+        }
+
+        deleteByGroupId(groupId);
+
+        if (tagDTOList.size() == 0) {
+            return APIResult.ok(new ArrayList<>());
+        }
+
+        List<String> tagIdList = new ArrayList<>();
+        List<Tag> tagList = new ArrayList<>();
+        for (int i = 0; i < tagDTOList.size(); i++) {
+            TagDTO dto = tagDTOList.get(i);
+            if (dto == null) {
+                continue;
+            }
+
+            String tagId = dto.getId();
+            if (!StringUtils.isEmpty(tagId)) {
+                tagIdList.add(tagId);
+            }
+
+            Tag tag = convert(dto);
+            tag.setGroupId(groupId);
+            tag.setSort(i);
+            tag.setStatus(BaseStatusEnum.NORMAL);
+
+            tagList.add(tag);
+        }
+
+        List<Tag> result = tagRepository.save(tagList);
+
+        return APIResult.ok(result);
+
+    }
+
 }

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

@@ -4,16 +4,20 @@ import cn.rankin.common.utils.api.model.APICodeManager;
 import cn.rankin.common.utils.api.model.APIResult;
 import cn.rankin.common.utils.api.page.Page;
 import cn.rankin.common.utils.dto.product.WareDTO;
+import cn.rankin.common.utils.enums.BaseOrderEnum;
+import cn.rankin.common.utils.enums.BaseStatusEnum;
+import cn.rankin.common.utils.util.JpaSortUtil;
+import cn.rankin.common.utils.util.ListUtil;
 import cn.rankin.productservice.entity.Ware;
 import cn.rankin.productservice.repository.WareRepository;
-import com.alibaba.fastjson.JSON;
 import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
-import java.util.List;
+import java.util.*;
+
+import static cn.rankin.productservice.utils.DTOConverter.convert;
 
 @Slf4j
 @Service
@@ -22,7 +26,7 @@ public class WareService {
     @Autowired
     private WareRepository wareRepository;
 
-    public APIResult<Page<Ware>> search(Ware ware, Integer pageNo, Integer pageSize) {
+    public APIResult<Page<Ware>> search(Ware ware, Integer pageNo, Integer pageSize, LinkedHashMap<String, BaseOrderEnum> sort) {
         Long count = wareRepository.count(ware);
         Page<Ware> page = new Page(count, pageNo, pageSize);
 
@@ -30,7 +34,7 @@ public class WareService {
             return APIResult.ok(page);
         }
 
-        List<Ware> wareList = wareRepository.find(ware, page.getStart(), pageSize);
+        List<Ware> wareList = wareRepository.find(ware, page.getStart(), pageSize, JpaSortUtil.sort(sort));
         page.setList(wareList);
 
         return APIResult.ok(page);
@@ -41,15 +45,12 @@ public class WareService {
         return count > 0L;
     }
 
-    public static Ware convert(WareDTO wareDTO) {
-        Ware ware = new Ware();
-        BeanUtils.copyProperties(wareDTO, ware);
-        return ware;
-    }
-
     @Transactional
     public APIResult<Ware> create(WareDTO wareDTO) {
         Ware ware = convert(wareDTO);
+        if (exists(ware.getCode())) {
+            return APIResult.error(APICodeManager.ALREADY_EXISTS);
+        }
         Ware result = wareRepository.save(ware);
         return APIResult.ok(result);
     }
@@ -58,15 +59,17 @@ public class WareService {
     public APIResult<Ware> update(WareDTO wareDTO) {
         Ware ware = convert(wareDTO);
         Ware result = wareRepository.update(ware);
-        log.info(JSON.toJSONString(ware));
 
         return APIResult.ok(result);
     }
 
     @Transactional
     public APIResult<Boolean> delete(String id) {
-        wareRepository.delete(id);
-        return APIResult.ok(true);
+        Integer count = wareRepository.deleteAllById(id, BaseStatusEnum.DEL);
+        if (count > 0) {
+            return APIResult.ok(true);
+        }
+        return APIResult.error(APICodeManager.NOT_EXISTS);
     }
 
     public APIResult<Ware> findById(String id) {
@@ -77,4 +80,22 @@ public class WareService {
         return APIResult.ok(ware);
     }
 
+    public APIResult<List<Ware>> findByIds(List<String> ids) {
+        List<Ware> wareList = wareRepository.findByIdIn(ids, BaseStatusEnum.NORMAL);
+
+        if (wareList == null || wareList.size() == 0) {
+            return APIResult.ok(wareList);
+        }
+
+        Map<String, Ware> wareMap = ListUtil.convert(wareList, "id", Ware.class);
+        List<Ware> sortWareList = new ArrayList<>();
+        ids.forEach( id -> {
+            Ware ware = wareMap.get(id);
+            if (ware != null) {
+                sortWareList.add(ware);
+            }
+        });
+
+        return APIResult.ok(sortWareList);
+    }
 }

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

@@ -1,8 +1,11 @@
 package cn.rankin.productservice.utils;
 
 import cn.rankin.common.utils.dto.product.*;
+import cn.rankin.common.utils.enums.CourseSubTypeEnum;
 import cn.rankin.productservice.entity.*;
+import cn.rankin.productservice.vo.CourseSubItemVo;
 import org.springframework.beans.BeanUtils;
+import org.springframework.util.CollectionUtils;
 
 import java.util.ArrayList;
 import java.util.HashSet;
@@ -16,27 +19,6 @@ public class DTOConverter {
         Item item = new Item();
         BeanUtils.copyProperties(itemDTO, item);
 
-        List<ItemPriceDTO> priceDTOList = itemDTO.getPriceList();
-        if (priceDTOList == null || priceDTOList.size() == 0) {
-            return item;
-        }
-
-        Set<ItemPrice> priceList = new HashSet<>();
-        priceDTOList.forEach(dto -> priceList.add(convert(dto)));
-        item.setPriceList(priceList);
-
-        Set<String> tagDTOList = itemDTO.getTagList();
-        if (tagDTOList == null || tagDTOList.size() == 0) {
-            return item;
-        }
-        Set<Tag> tagSet = new HashSet<>();
-        tagDTOList.forEach( tagId -> {
-            Tag tag = new Tag();
-            tag.setId(tagId);
-            tagSet.add(tag);
-        });
-        item.setTagList(tagSet);
-
         return item;
     }
 
@@ -45,14 +27,6 @@ public class DTOConverter {
         Course course = new Course();
         BeanUtils.copyProperties(courseDTO, course);
 
-        List<SupportDTO> supportDTOList = courseDTO.getSupportList();
-        if (supportDTOList == null || supportDTOList.size() == 0) {
-            return course;
-        }
-
-        List<Support> supportList = new ArrayList<>();
-        supportDTOList.forEach( dto -> supportList.add(convert(dto)));
-        course.setSupportList(supportList);
         return course;
     }
 
@@ -76,4 +50,43 @@ public class DTOConverter {
         BeanUtils.copyProperties(itemPriceDTO, itemPrice);
         return itemPrice;
     }
+
+    // LessonDTO to Lesson
+    public static Lesson convert(LessonDTO lessonDTO) {
+        Lesson lesson = new Lesson();
+        BeanUtils.copyProperties(lessonDTO, lesson);
+
+        return lesson;
+    }
+
+    // Lesson to CourseSubItemVo
+    public static CourseSubItemVo convert(Lesson lesson) {
+        CourseSubItemVo subItemVo = new CourseSubItemVo();
+        BeanUtils.copyProperties(lesson, subItemVo);
+        subItemVo.setType(CourseSubTypeEnum.LESSON);
+
+        return subItemVo;
+    }
+
+    // CourseSubRelationDTO convert CourseSubRelation
+    public static CourseSubRelation convert(String courseId, CourseSubRelationDTO courseSubRelationDTO) {
+        CourseSubRelation relation = new CourseSubRelation();
+        relation.setCourseId(courseId);
+        relation.setSubId(courseSubRelationDTO.getId());
+        relation.setType(courseSubRelationDTO.getType());
+
+        return relation;
+    }
+
+    public static Group convert(GroupDTO groupDTO) {
+        Group group = new Group();
+        BeanUtils.copyProperties(groupDTO, group);
+        return group;
+    }
+
+    public static Tag convert(TagDTO tagDTO) {
+        Tag tag = new Tag();
+        BeanUtils.copyProperties(tagDTO, tag);
+        return tag;
+    }
 }

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

@@ -0,0 +1,21 @@
+package cn.rankin.productservice.utils;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class TestUtil {
+
+    public static void main(String[] args) {
+        List<String> list1 = new ArrayList<>();
+        list1.add("1");
+        list1.add("2");
+
+        List<String> list2 = new ArrayList<>();
+        list2.add("1");
+        list2.add("2");
+        list2.add("3");
+
+        list1.removeAll(list2);
+        System.out.println(list1);
+    }
+}

rankin-product-service/src/test/java/cn/rankin/productservice/repository/tagRepositoryImplTest.java

@@ -0,0 +1,33 @@
+package cn.rankin.productservice.repository;
+
+import cn.rankin.common.utils.enums.BaseStatusEnum;
+import cn.rankin.productservice.ProductServiceApplication;
+import com.alibaba.fastjson.JSON;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.Assert.*;
+
+@Slf4j
+@RunWith(SpringJUnit4ClassRunner.class)
+@SpringBootTest(classes = ProductServiceApplication.class)
+public class tagRepositoryImplTest {
+
+    @Autowired
+    private TagRepository tagRepository;
+
+    @Test
+    public void findByIds() throws Exception {
+        List<String> idList = new ArrayList<>();
+        idList.add("1");
+        log.info(JSON.toJSONString(tagRepository.findByIdss(idList, BaseStatusEnum.NORMAL)));
+    }
+
+}