训练营

fs-admin/src/main/java/com/fs/course/controller/FsUserCourseTrainingCampController.java

@@ -0,0 +1,87 @@
+package com.fs.course.controller;
+
+import com.fs.common.annotation.Log;
+import com.fs.common.core.domain.AjaxResult;
+import com.fs.common.enums.BusinessType;
+import com.fs.common.utils.SortUtils;
+import com.fs.course.dto.FsUserCourseTrainingCampDTO;
+import com.fs.course.service.IFsUserCourseTrainingCampService;
+import com.fs.course.vo.FsUserCourseTrainingCampVO;
+import com.github.pagehelper.PageHelper;
+import com.github.pagehelper.PageInfo;
+import lombok.AllArgsConstructor;
+import org.assertj.core.util.Arrays;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.*;
+
+import javax.validation.Valid;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@RestController
+@RequestMapping("/course/trainingCamp")
+@AllArgsConstructor
+public class FsUserCourseTrainingCampController {
+
+    private final IFsUserCourseTrainingCampService fsUserCourseTrainingCampService;
+
+    /**
+     * 查询训练营列表
+     */
+    @PreAuthorize("@ss.hasPermi('course:trainingCamp:list')")
+    @GetMapping("/list")
+    public AjaxResult list(@RequestParam(required = false) String trainingCampName,
+                           @RequestParam String scs,
+                           @RequestParam(required = false, defaultValue = "1") Integer pageNum,
+                           @RequestParam(required = false, defaultValue = "10") Integer pageSize)
+    {
+        Map<String, Object> params = new HashMap<>();
+        params.put("trainingCampName", trainingCampName);
+        params.put("scs", SortUtils.parseSort(scs));
+
+        PageHelper.startPage(pageNum, pageSize);
+        List<FsUserCourseTrainingCampVO> list = fsUserCourseTrainingCampService.selectFsUserCourseTrainingCampVOListByMap(params);
+        return AjaxResult.success(new PageInfo<>(list));
+    }
+
+    /**
+     * 新增训练营
+     * @param params    参数
+     * @return  AjaxResult
+     */
+    @PreAuthorize("@ss.hasPermi('course:trainingCamp:add')")
+    @Log(title = "训练营", businessType = BusinessType.INSERT)
+    @PostMapping
+    public AjaxResult add(@Valid @RequestBody FsUserCourseTrainingCampDTO params) {
+        fsUserCourseTrainingCampService.add(params);
+        return AjaxResult.success();
+    }
+
+    /**
+     * 删除训练营
+     * @param ids    参数
+     * @return  AjaxResult
+     */
+    @PreAuthorize("@ss.hasPermi('course:trainingCamp:remove')")
+    @Log(title = "训练营", businessType = BusinessType.DELETE)
+    @DeleteMapping("/{ids}")
+    public AjaxResult del(@PathVariable Long[] ids) {
+        fsUserCourseTrainingCampService.del(ids);
+        return AjaxResult.success();
+    }
+
+    /**
+     * 复制训练营
+     * @param id    参数
+     * @return  AjaxResult
+     */
+    @PreAuthorize("@ss.hasPermi('course:trainingCamp:add')")
+    @Log(title = "训练营", businessType = BusinessType.INSERT)
+    @PostMapping("/copy/{id}")
+    public AjaxResult copy(@PathVariable Long id) {
+        fsUserCourseTrainingCampService.copy(id);
+        return AjaxResult.success();
+    }
+
+}

fs-common/src/main/java/com/fs/common/core/domain/SortRule.java

@@ -0,0 +1,13 @@
+package com.fs.common.core.domain;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class SortRule {
+    private String column;
+    private String order;
+}

fs-common/src/main/java/com/fs/common/utils/SortUtils.java

@@ -0,0 +1,39 @@
+package com.fs.common.utils;
+
+import com.fs.common.core.domain.SortRule;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class SortUtils {
+
+    /**
+     * 解析排序规则
+     * @param sortStr   排序字符串  a(desc),b(asc),c(desc)
+     * @return list
+     */
+    public static List<SortRule> parseSort(String sortStr) {
+        List<SortRule> rules = new ArrayList<>();
+        if (StringUtils.isBlank(sortStr)) {
+            return rules;
+        }
+
+        String[] sortParts = sortStr.split(",");
+        for (String part : sortParts) {
+            String[] split = part.trim().split("\\(");
+            if (split.length != 2) {
+                continue;
+            }
+
+            String field = split[0].trim().replace(" ", ""); // 字段名：a, b, c
+
+            String direction = split[1].replace(")", "").trim(); // 方向：desc
+            if (!"asc".equalsIgnoreCase(direction) && !"desc".equalsIgnoreCase(direction)) {
+                continue;
+            }
+
+            rules.add(new SortRule(field, direction));
+        }
+        return rules;
+    }
+}

fs-service-system/src/main/java/com/fs/course/domain/FsUserCourseTrainingCamp.java

@@ -1,11 +1,13 @@
 package com.fs.course.domain;
 
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
 import com.fasterxml.jackson.annotation.JsonFormat;
 import com.fs.common.annotation.Excel;
-import org.apache.commons.lang3.builder.ToStringBuilder;
-import org.apache.commons.lang3.builder.ToStringStyle;
+import lombok.Data;
 
-import java.util.Date;
+import java.time.LocalDateTime;
 
 /**
  * 会员训练营对象 fs_user_course_training_camp
@@ -13,11 +15,13 @@ import java.util.Date;
  * @author fs
  * @date 2025-04-15
  */
+@Data
+@TableName("fs_user_course_training_camp")
 public class FsUserCourseTrainingCamp
 {
-    private static final long serialVersionUID = 1L;
 
     /** id */
+    @TableId(type = IdType.AUTO)
     private Long trainingCampId;
 
     /** 训练营名称 */
@@ -31,51 +35,5 @@ public class FsUserCourseTrainingCamp
     /** 创建时间 */
     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
     @Excel(name = "创建时间")
-    private Date createTime;
-
-    public void setTrainingCampId(Long trainingCampId)
-    {
-        this.trainingCampId = trainingCampId;
-    }
-
-    public Long getTrainingCampId()
-    {
-        return trainingCampId;
-    }
-    public void setTrainingCampName(String trainingCampName)
-    {
-        this.trainingCampName = trainingCampName;
-    }
-
-    public String getTrainingCampName()
-    {
-        return trainingCampName;
-    }
-    public void setOrderNumber(Long orderNumber)
-    {
-        this.orderNumber = orderNumber;
-    }
-
-    public Long getOrderNumber()
-    {
-        return orderNumber;
-    }
-
-    public Date getCreateTime() {
-        return createTime;
-    }
-
-    public void setCreateTime(Date createTime) {
-        this.createTime = createTime;
-    }
-
-    @Override
-    public String toString() {
-        return new ToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE)
-            .append("training campId", getTrainingCampId())
-            .append("training campName", getTrainingCampName())
-            .append("orderNumber", getOrderNumber())
-            .append("createTime", getCreateTime())
-            .toString();
-    }
+    private LocalDateTime createTime;
 }

fs-service-system/src/main/java/com/fs/course/dto/FsUserCourseTrainingCampDTO.java

@@ -0,0 +1,15 @@
+package com.fs.course.dto;
+
+import lombok.Data;
+
+import javax.validation.constraints.NotBlank;
+
+@Data
+public class FsUserCourseTrainingCampDTO {
+
+    /**
+     * 训练营名称
+     */
+    @NotBlank(message = "训练营名称不能为空")
+    private String trainingCampName;
+}

fs-service-system/src/main/java/com/fs/course/mapper/FsUserCoursePeriodMapper.java

@@ -3,6 +3,8 @@ package com.fs.course.mapper;
 import java.util.List;
 import com.fs.course.domain.FsUserCoursePeriod;
 import com.fs.course.vo.FsUserCoursePeriodVO;
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.Select;
 
 /**
  * 会员营期Mapper接口
@@ -65,4 +67,12 @@ public interface FsUserCoursePeriodMapper
      * @return
      */
     List<FsUserCoursePeriodVO> selectFsUserCoursePeriodPage(FsUserCoursePeriod fsUserCoursePeriod);
+
+    /**
+     * 查询训练营营期
+     * @param id    训练营ID
+     * @return  list
+     */
+    @Select("select * from fs_user_course_period where training_camp_id = #{id}")
+    List<FsUserCoursePeriod> selectFsUserCoursePeriodListByTrainingCampId(@Param("id") Long id);
 }

fs-service-system/src/main/java/com/fs/course/mapper/FsUserCourseTrainingCampMapper.java

@@ -1,7 +1,14 @@
 package com.fs.course.mapper;
 
-import java.util.List;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import com.fs.course.domain.FsUserCourseTrainingCamp;
+import com.fs.course.vo.FsUserCourseTrainingCampVO;
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.Select;
+
+import java.util.List;
+import java.util.Map;
 
 /**
  * 会员训练营Mapper接口
@@ -9,53 +16,20 @@ import com.fs.course.domain.FsUserCourseTrainingCamp;
  * @author fs
  * @date 2025-04-15
  */
-public interface FsUserCourseTrainingCampMapper
+public interface FsUserCourseTrainingCampMapper extends BaseMapper<FsUserCourseTrainingCamp>
 {
-    /**
-     * 查询会员训练营
-     *
-     * @param trainingCampId 会员训练营ID
-     * @return 会员训练营
-     */
-    public FsUserCourseTrainingCamp selectFsUserCourseTrainingCampById(Long trainingCampId);
-
-    /**
-     * 查询会员训练营列表
-     *
-     * @param fsUserCourseTrainingCamp 会员训练营
-     * @return 会员训练营集合
-     */
-    public List<FsUserCourseTrainingCamp> selectFsUserCourseTrainingCampList(FsUserCourseTrainingCamp fsUserCourseTrainingCamp);
-
-    /**
-     * 新增会员训练营
-     *
-     * @param fsUserCourseTrainingCamp 会员训练营
-     * @return 结果
-     */
-    public int insertFsUserCourseTrainingCamp(FsUserCourseTrainingCamp fsUserCourseTrainingCamp);
-
-    /**
-     * 修改会员训练营
-     *
-     * @param fsUserCourseTrainingCamp 会员训练营
-     * @return 结果
-     */
-    public int updateFsUserCourseTrainingCamp(FsUserCourseTrainingCamp fsUserCourseTrainingCamp);
 
     /**
-     * 删除会员训练营
-     *
-     * @param trainingCampId 会员训练营ID
-     * @return 结果
+     * 查询训练营列表
+     * @param params    参数
+     * @return  list
      */
-    public int deleteFsUserCourseTrainingCampById(Long trainingCampId);
+    List<FsUserCourseTrainingCampVO> selectFsUserCourseTrainingCampVOListByMap(@Param("params") Map<String, Object> params);
 
     /**
-     * 批量删除会员训练营
-     *
-     * @param trainingCampIds 需要删除的数据ID
-     * @return 结果
+     * 获取序号
+     * @return 序号
      */
-    public int deleteFsUserCourseTrainingCampByIds(Long[] trainingCampIds);
+    @Select("select ifnull(max(order_number), 0) + 1 from fs_user_course_training_camp")
+    Long getOrderNumber();
 }

fs-service-system/src/main/java/com/fs/course/service/IFsUserCourseTrainingCampService.java

@@ -1,7 +1,14 @@
 package com.fs.course.service;
 
-import java.util.List;
+
+import com.baomidou.mybatisplus.extension.service.IService;
 import com.fs.course.domain.FsUserCourseTrainingCamp;
+import com.fs.course.dto.FsUserCourseTrainingCampDTO;
+import com.fs.course.vo.FsUserCourseTrainingCampVO;
+
+import javax.validation.Valid;
+import java.util.List;
+import java.util.Map;
 
 /**
  * 会员训练营Service接口
@@ -9,53 +16,31 @@ import com.fs.course.domain.FsUserCourseTrainingCamp;
  * @author fs
  * @date 2025-04-15
  */
-public interface IFsUserCourseTrainingCampService
+public interface IFsUserCourseTrainingCampService extends IService<FsUserCourseTrainingCamp>
 {
-    /**
-     * 查询会员训练营
-     *
-     * @param trainingCampId 会员训练营ID
-     * @return 会员训练营
-     */
-    public FsUserCourseTrainingCamp selectFsUserCourseTrainingCampById(Long trainingCampId);
-
-    /**
-     * 查询会员训练营列表
-     *
-     * @param fsUserCourseTrainingCamp 会员训练营
-     * @return 会员训练营集合
-     */
-    public List<FsUserCourseTrainingCamp> selectFsUserCourseTrainingCampList(FsUserCourseTrainingCamp fsUserCourseTrainingCamp);
 
     /**
-     * 新增会员训练营
-     *
-     * @param fsUserCourseTrainingCamp 会员训练营
-     * @return 结果
+     * 查询训练营列表
+     * @param params    参数
+     * @return  list
      */
-    public int insertFsUserCourseTrainingCamp(FsUserCourseTrainingCamp fsUserCourseTrainingCamp);
+    List<FsUserCourseTrainingCampVO> selectFsUserCourseTrainingCampVOListByMap(Map<String, Object> params);
 
     /**
-     * 修改会员训练营
-     *
-     * @param fsUserCourseTrainingCamp 会员训练营
-     * @return 结果
+     * 新增训练营
+     * @param params    参数
      */
-    public int updateFsUserCourseTrainingCamp(FsUserCourseTrainingCamp fsUserCourseTrainingCamp);
+    void add(FsUserCourseTrainingCampDTO params);
 
     /**
-     * 批量删除会员训练营
-     *
-     * @param trainingCampIds 需要删除的会员训练营ID
-     * @return 结果
+     * 删除训练营
+     * @param ids   ids
      */
-    public int deleteFsUserCourseTrainingCampByIds(Long[] trainingCampIds);
+    void del(Long[] ids);
 
     /**
-     * 删除会员训练营信息
-     *
-     * @param trainingCampId 会员训练营ID
-     * @return 结果
+     * 复制训练营
+     * @param id    id
      */
-    public int deleteFsUserCourseTrainingCampById(Long trainingCampId);
+    void copy(Long id);
 }

fs-service-system/src/main/java/com/fs/course/service/impl/FsUserCourseTrainingCampServiceImpl.java

@@ -1,12 +1,24 @@
 package com.fs.course.service.impl;
 
-import java.util.List;
-import com.fs.common.utils.DateUtils;
-import org.springframework.beans.factory.annotation.Autowired;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.fs.common.BeanCopyUtils;
+import com.fs.common.exception.ServiceException;
+import com.fs.common.utils.bean.BeanUtils;
+import com.fs.course.domain.FsUserCoursePeriod;
+import com.fs.course.dto.FsUserCourseTrainingCampDTO;
+import com.fs.course.mapper.FsUserCoursePeriodMapper;
+import com.fs.course.vo.FsUserCourseTrainingCampVO;
+import lombok.AllArgsConstructor;
 import org.springframework.stereotype.Service;
 import com.fs.course.mapper.FsUserCourseTrainingCampMapper;
 import com.fs.course.domain.FsUserCourseTrainingCamp;
 import com.fs.course.service.IFsUserCourseTrainingCampService;
+import org.springframework.transaction.annotation.Transactional;
+
+import javax.annotation.Resource;
+import java.time.LocalDateTime;
+import java.util.*;
 
 /**
  * 会员训练营Service业务层处理
@@ -15,81 +27,76 @@ import com.fs.course.service.IFsUserCourseTrainingCampService;
  * @date 2025-04-15
  */
 @Service
-public class FsUserCourseTrainingCampServiceImpl implements IFsUserCourseTrainingCampService
+@AllArgsConstructor
+public class FsUserCourseTrainingCampServiceImpl extends ServiceImpl<FsUserCourseTrainingCampMapper, FsUserCourseTrainingCamp> implements IFsUserCourseTrainingCampService
 {
-    @Autowired
-    private FsUserCourseTrainingCampMapper fsUserCourseTrainingCampMapper;
 
-    /**
-     * 查询会员训练营
-     *
-     * @param trainingCampId 会员训练营ID
-     * @return 会员训练营
-     */
-    @Override
-    public FsUserCourseTrainingCamp selectFsUserCourseTrainingCampById(Long trainingCampId)
-    {
-        return fsUserCourseTrainingCampMapper.selectFsUserCourseTrainingCampById(trainingCampId);
-    }
+    private final FsUserCoursePeriodMapper fsUserCoursePeriodMapper;
 
     /**
-     * 查询会员训练营列表
-     *
-     * @param fsUserCourseTrainingCamp 会员训练营
-     * @return 会员训练营
+     * 查询训练营列表
+     * @param params    参数
+     * @return  list
      */
     @Override
-    public List<FsUserCourseTrainingCamp> selectFsUserCourseTrainingCampList(FsUserCourseTrainingCamp fsUserCourseTrainingCamp)
-    {
-        return fsUserCourseTrainingCampMapper.selectFsUserCourseTrainingCampList(fsUserCourseTrainingCamp);
-    }
+    public List<FsUserCourseTrainingCampVO> selectFsUserCourseTrainingCampVOListByMap(Map<String, Object> params) {
+        List<FsUserCourseTrainingCampVO> voList = baseMapper.selectFsUserCourseTrainingCampVOListByMap(params);
 
-    /**
-     * 新增会员训练营
-     *
-     * @param fsUserCourseTrainingCamp 会员训练营
-     * @return 结果
-     */
-    @Override
-    public int insertFsUserCourseTrainingCamp(FsUserCourseTrainingCamp fsUserCourseTrainingCamp)
-    {
-        fsUserCourseTrainingCamp.setCreateTime(DateUtils.getNowDate());
-        return fsUserCourseTrainingCampMapper.insertFsUserCourseTrainingCamp(fsUserCourseTrainingCamp);
+        // TODO: 会员数处理
+        voList.forEach(v -> v.setVipCount(0));
+        return voList;
     }
 
     /**
-     * 修改会员训练营
-     *
-     * @param fsUserCourseTrainingCamp 会员训练营
-     * @return 结果
+     * 新增训练营
+     * @param params    参数
      */
     @Override
-    public int updateFsUserCourseTrainingCamp(FsUserCourseTrainingCamp fsUserCourseTrainingCamp)
-    {
-        return fsUserCourseTrainingCampMapper.updateFsUserCourseTrainingCamp(fsUserCourseTrainingCamp);
+    public void add(FsUserCourseTrainingCampDTO params) {
+        FsUserCourseTrainingCamp trainingCamp = new FsUserCourseTrainingCamp();
+        trainingCamp.setTrainingCampName(params.getTrainingCampName());
+        trainingCamp.setOrderNumber(baseMapper.getOrderNumber());
+        trainingCamp.setCreateTime(LocalDateTime.now());
+        baseMapper.insert(trainingCamp);
     }
 
     /**
-     * 批量删除会员训练营
-     *
-     * @param trainingCampIds 需要删除的会员训练营ID
-     * @return 结果
+     * 删除训练营
+     * @param ids   ids
      */
     @Override
-    public int deleteFsUserCourseTrainingCampByIds(Long[] trainingCampIds)
-    {
-        return fsUserCourseTrainingCampMapper.deleteFsUserCourseTrainingCampByIds(trainingCampIds);
+    public void del(Long[] ids) {
+        baseMapper.deleteBatchIds(Arrays.asList(ids));
     }
 
     /**
-     * 删除会员训练营信息
-     *
-     * @param trainingCampId 会员训练营ID
-     * @return 结果
+     * 复制训练营
+     * @param id    id
      */
     @Override
-    public int deleteFsUserCourseTrainingCampById(Long trainingCampId)
-    {
-        return fsUserCourseTrainingCampMapper.deleteFsUserCourseTrainingCampById(trainingCampId);
+    @Transactional(rollbackFor = Exception.class)
+    public void copy(Long id) {
+        FsUserCourseTrainingCamp fsUserCourseTrainingCamp = baseMapper.selectById(id);
+        if (Objects.isNull(fsUserCourseTrainingCamp)) {
+            throw new ServiceException("训练营不存在");
+        }
+
+        // 复制训练营
+        FsUserCourseTrainingCamp trainingCamp = new FsUserCourseTrainingCamp();
+        trainingCamp.setTrainingCampName(fsUserCourseTrainingCamp.getTrainingCampName() + " - 副本");
+        trainingCamp.setOrderNumber(baseMapper.getOrderNumber());
+        trainingCamp.setCreateTime(LocalDateTime.now());
+        baseMapper.insert(trainingCamp);
+
+        // 复制营期
+        List<FsUserCoursePeriod> fsUserCoursePeriods = fsUserCoursePeriodMapper.selectFsUserCoursePeriodListByTrainingCampId(id);
+        if (!fsUserCoursePeriods.isEmpty()) {
+            fsUserCoursePeriods.stream().map(p -> {
+                FsUserCoursePeriod copy = new FsUserCoursePeriod();
+                BeanUtils.copyProperties(p, copy, "periodId");
+                copy.setTrainingCampId(trainingCamp.getTrainingCampId());
+                return copy;
+            }).forEach(fsUserCoursePeriodMapper::insertFsUserCoursePeriod);
+        }
     }
 }

fs-service-system/src/main/java/com/fs/course/vo/FsUserCourseTrainingCampVO.java

@@ -0,0 +1,35 @@
+package com.fs.course.vo;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+@Data
+public class FsUserCourseTrainingCampVO {
+    /**
+     * 主键ID
+     */
+    private Long trainingCampId;
+    /**
+     * 训练营名称
+     */
+    private String trainingCampName;
+    /**
+     * 序号
+     */
+    private Integer orderNumber;
+    /**
+     * 最近营期开课日期
+     */
+    @JsonFormat(pattern = "yyyy-MM-dd")
+    private LocalDateTime recentDate;
+    /**
+     * 营期数
+     */
+    private Integer periodCount;
+    /**
+     * 会员总数
+     */
+    private Integer vipCount;
+}

fs-service-system/src/main/resources/mapper/course/FsUserCourseTrainingCampMapper.xml

@@ -4,65 +4,32 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
 "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 <mapper namespace="com.fs.course.mapper.FsUserCourseTrainingCampMapper">
 
-    <resultMap type="FsUserCourseTrainingCamp" id="FsUserCourseTrainingCampResult">
-        <result property="trainingCampId"    column="training_camp_id"    />
-        <result property="trainingCampName"    column="training_camp_name"    />
-        <result property="orderNumber"    column="order_number"    />
-        <result property="createTime"    column="create_time"    />
-    </resultMap>
-
-    <sql id="selectFsUserCourseTrainingCampVo">
-        select training_camp_id, training_camp_name, order_number, create_time from fs_user_course_training_camp
-    </sql>
-
-    <select id="selectFsUserCourseTrainingCampList" parameterType="FsUserCourseTrainingCamp" resultMap="FsUserCourseTrainingCampResult">
-        <include refid="selectFsUserCourseTrainingCampVo"/>
+    <!-- 查询训练营列表 -->
+    <select id="selectFsUserCourseTrainingCampVOListByMap" resultType="com.fs.course.vo.FsUserCourseTrainingCampVO">
+        select
+            ctc.training_camp_id,
+            ctc.training_camp_name,
+            ctc.order_number,
+            min(if(ctp.period_starting_time > now(), ctp.period_starting_time, null)) as recent_date,
+            count(ctp.period_id) as period_count
+        from fs_user_course_training_camp ctc
+        left join fs_user_course_period ctp on ctc.training_camp_id = ctp.training_camp_id
         <where>
-            <if test="training campName != null  and trainingCampName != ''"> and training_camp_name like concat('%', #{trainingCampName}, '%')</if>
-            <if test="orderNumber != null "> and order_number = #{orderNumber}</if>
+            <if test="params.trainingCampName != null and params.trainingCampName != ''">
+                and ctc.training_camp_name like concat('%',#{params.trainingCampName},'%')
+            </if>
         </where>
+        group by ctc.training_camp_id, ctc.training_camp_name, ctc.order_number
+        order by
+        <choose>
+            <when test="params.scs != null and params.scs.size() > 0">
+                <foreach collection="params.scs" item="sc" separator=",">
+                    ${sc.column} ${sc.order}
+                </foreach>
+            </when>
+            <otherwise>
+                ctc.order_number desc, ctc.training_camp_id desc
+            </otherwise>
+        </choose>
     </select>
-
-    <select id="selectFsUserCourseTrainingCampById" parameterType="Long" resultMap="FsUserCourseTrainingCampResult">
-        <include refid="selectFsUserCourseTrainingCampVo"/>
-        where training_camp_id = #{trainingCampId}
-    </select>
-
-    <insert id="insertFsUserCourseTrainingCamp" parameterType="FsUserCourseTrainingCamp">
-        insert into fs_user_course_training_camp
-        <trim prefix="(" suffix=")" suffixOverrides=",">
-            <if test="trainingCampId != null">training_camp_id,</if>
-            <if test="trainingCampName != null">training_camp_name,</if>
-            <if test="orderNumber != null">order_number,</if>
-            <if test="createTime != null">create_time,</if>
-         </trim>
-        <trim prefix="values (" suffix=")" suffixOverrides=",">
-            <if test="trainingCampId != null">#{trainingCampId},</if>
-            <if test="trainingCampName != null">#{trainingCampName},</if>
-            <if test="orderNumber != null">#{orderNumber},</if>
-            <if test="createTime != null">#{createTime},</if>
-         </trim>
-    </insert>
-
-    <update id="updateFsUserCourseTrainingCamp" parameterType="FsUserCourseTrainingCamp">
-        update fs_user_course_training_camp
-        <trim prefix="SET" suffixOverrides=",">
-            <if test="trainingCampName != null">training_camp_name = #{trainingCampName},</if>
-            <if test="orderNumber != null">order_number = #{orderNumber},</if>
-            <if test="createTime != null">create_time = #{createTime},</if>
-        </trim>
-        where training_camp_id = #{trainingCampId}
-    </update>
-
-    <delete id="deleteFsUserCourseTrainingCampById" parameterType="Long">
-        delete from fs_user_course_training_camp where training_camp_id = #{trainingCampId}
-    </delete>
-
-    <delete id="deleteFsUserCourseTrainingCampByIds" parameterType="String">
-        delete from fs_user_course_training_camp where training_camp_id in
-        <foreach item="trainingCampId" collection="array" open="(" separator="," close=")">
-            #{trainingCampId}
-        </foreach>
-    </delete>
-
 </mapper>