复制营期，排序营期课程

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

@@ -159,6 +159,13 @@ public class FsUserCoursePeriodController extends BaseController {
         return fsUserCoursePeriodDaysService.insertCourse(entity);
     }
 
+    @PreAuthorize("@ss.hasPermi('course:period:dayRemove')")
+    @Log(title = "会员营期课程删除并重排日期", businessType = BusinessType.DELETE)
+    @DeleteMapping("/day/reorder")
+    public AjaxResult dayRemoveAndReorder(@RequestParam Long[] ids, @RequestParam(defaultValue = "false") boolean reorder) {
+        return toAjax(fsUserCoursePeriodDaysService.deletePeriodDaysAndReorder(ids, reorder));
+    }
+
     @PreAuthorize("@ss.hasPermi('course:period:dayRemove')")
     @Log(title = "会员营期课程删除", businessType = BusinessType.DELETE)
     @DeleteMapping("/day/{ids}")
@@ -295,6 +302,15 @@ public class FsUserCoursePeriodController extends BaseController {
         return R.ok();
     }
 
+    @PreAuthorize("@ss.hasPermi('course:period:copy')")
+    @Log(title = "会员营期", businessType = BusinessType.INSERT)
+    @ApiOperation("复制营期")
+    @PostMapping("/copy/{periodId}")
+    public R copyPeriod(@PathVariable Long periodId) {
+        Long newPeriodId = fsUserCoursePeriodService.copyPeriod(periodId);
+        return R.ok().put("data", newPeriodId);
+    }
+
     @PostMapping("/periodCourseStatisticCount")
     @ApiOperation("会员详情训练营数据总览")
     public R periodCourseStatisticCount(@RequestBody PeriodStatisticCountParam param) {

fs-service/src/main/java/com/fs/course/service/IFsUserCoursePeriodDaysService.java

@@ -131,4 +131,13 @@ public interface IFsUserCoursePeriodDaysService extends IService<FsUserCoursePer
 
     List<Long> selectFsUserCoursePeriodDaysByTime(String periodSTime,String periodETime);
 
-    }
+    /**
+     * 删除营期课程并将后续课程日期顺延 -1 天
+     *
+     * @param ids      要删除的课程 ID 数组
+     * @param reorder  是否重排日期
+     * @return 结果
+     */
+    int deletePeriodDaysAndReorder(Long[] ids, boolean reorder);
+
+}

fs-service/src/main/java/com/fs/course/service/IFsUserCoursePeriodService.java

@@ -76,6 +76,13 @@ public interface IFsUserCoursePeriodService
      */
     void closePeriod(Long id);
 
+    /**
+     * 复制营期（含课程及关联公司）
+     * @param periodId 源营期ID
+     * @return 新营期ID
+     */
+    Long copyPeriod(Long periodId);
+
     /**
      * 更新营期状态
      */

fs-service/src/main/java/com/fs/course/service/impl/FsUserCoursePeriodDaysServiceImpl.java

@@ -153,6 +153,59 @@ public class FsUserCoursePeriodDaysServiceImpl extends ServiceImpl<FsUserCourseP
         return flag;
     }
 
+    /**
+     * 删除营期课程，并可选将同营期后续课程日期整体 -1 天
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public int deletePeriodDaysAndReorder(Long[] ids, boolean reorder) {
+        List<FsUserCoursePeriodDays> toDelete = fsUserCoursePeriodDaysMapper.selectBatchIds(Arrays.asList(ids));
+        if (toDelete.isEmpty()) return 0;
+
+        List<Long> periodDayIds = toDelete.stream().map(FsUserCoursePeriodDays::getId).collect(Collectors.toList());
+        List<Long> getPeriodIds = toDelete.stream().map(FsUserCoursePeriodDays::getPeriodId).collect(Collectors.toList());
+        List<Long> videoIds = toDelete.stream().map(FsUserCoursePeriodDays::getVideoId).collect(Collectors.toList());
+
+        int flag = fsUserCoursePeriodDaysMapper.updateBatchDelFlag(periodDayIds.toArray(new Long[0]), 1);
+        fsUserCourseVideoRedPackageMapper.deleteFsUserCourseVideoRedPackageByVedioIds(
+                videoIds.toArray(new Long[0]), getPeriodIds.toArray(new Long[0]));
+
+        if (reorder) {
+            // 找出被删课程中最小的 dayDate，后续课程从该日期往后顺延 -1 天
+            LocalDate minDeletedDate = toDelete.stream()
+                    .filter(d -> d.getDayDate() != null)
+                    .map(FsUserCoursePeriodDays::getDayDate)
+                    .min(LocalDate::compareTo)
+                    .orElse(null);
+            if (minDeletedDate != null) {
+                // 每个营期单独处理，保证只影响对应营期的后续课程
+                for (Long periodId : new HashSet<>(getPeriodIds)) {
+                    List<FsUserCoursePeriodDays> laterCourses = fsUserCoursePeriodDaysMapper.selectList(
+                            new LambdaQueryWrapper<FsUserCoursePeriodDays>()
+                                    .eq(FsUserCoursePeriodDays::getPeriodId, periodId)
+                                    .gt(FsUserCoursePeriodDays::getDayDate, minDeletedDate)
+                                    .orderByAsc(FsUserCoursePeriodDays::getDayDate)
+                    );
+                    if (laterCourses.isEmpty()) continue;
+                    for (FsUserCoursePeriodDays day : laterCourses) {
+                        day.setDayDate(day.getDayDate().minusDays(1));
+                        if (day.getStartDateTime() != null) {
+                            day.setStartDateTime(day.getStartDateTime().minusDays(1));
+                        }
+                        if (day.getEndDateTime() != null) {
+                            day.setEndDateTime(day.getEndDateTime().minusDays(1));
+                        }
+                        if (day.getLastJoinTime() != null) {
+                            day.setLastJoinTime(day.getLastJoinTime().minusDays(1));
+                        }
+                    }
+                    fsUserCoursePeriodDaysMapper.batchUpdateCoursePeriodDays(laterCourses);
+                }
+            }
+        }
+        return flag;
+    }
+
     /**
      * 删除营期课程信息
      *

fs-service/src/main/java/com/fs/course/service/impl/FsUserCoursePeriodServiceImpl.java

@@ -6,12 +6,16 @@ import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import com.fs.common.core.redis.RedisCache;
 import com.fs.common.exception.CustomException;
 import com.fs.common.exception.ServiceException;
+import com.fs.common.utils.bean.BeanUtils;
 import com.fs.course.domain.FsUserCoursePeriod;
+import com.fs.course.domain.FsUserCoursePeriodCompany;
 import com.fs.course.domain.FsUserCoursePeriodDays;
 import com.fs.course.mapper.FsUserCoursePeriodDaysMapper;
 import com.fs.course.mapper.FsUserCoursePeriodMapper;
 import com.fs.course.mapper.FsUserCourseVideoRedPackageMapper;
 import com.fs.course.param.PeriodStatisticCountParam;
+import com.fs.course.service.IFsUserCoursePeriodCompanyService;
+import com.fs.course.service.IFsUserCoursePeriodDaysService;
 import com.fs.course.service.IFsUserCoursePeriodService;
 import com.fs.course.vo.FsCourseStaticsCountVO;
 import com.fs.course.vo.FsUserCoursePeriodVO;
@@ -46,6 +50,10 @@ public class FsUserCoursePeriodServiceImpl implements IFsUserCoursePeriodService
     private FsUserCoursePeriodDaysMapper fsUserCoursePeriodDaysMapper;
     @Resource
     private FsUserCourseVideoRedPackageMapper fsUserCourseVideoRedPackageMapper;
+    @Resource
+    private IFsUserCoursePeriodDaysService fsUserCoursePeriodDaysService;
+    @Resource
+    private IFsUserCoursePeriodCompanyService fsUserCoursePeriodCompanyService;
 
     /**
      * 查询会员营期
@@ -214,6 +222,59 @@ public class FsUserCoursePeriodServiceImpl implements IFsUserCoursePeriodService
         return fsUserCoursePeriodMapper.selectFsUserCoursePeriodPage(fsUserCoursePeriod);
     }
 
+    /**
+     * 复制营期（含课程及关联公司）
+     */
+    @Transactional(rollbackFor = Exception.class)
+    @Override
+    public Long copyPeriod(Long periodId) {
+        FsUserCoursePeriod source = fsUserCoursePeriodMapper.selectFsUserCoursePeriodById(periodId);
+        if (Objects.isNull(source)) {
+            throw new ServiceException("营期不存在");
+        }
+        if (Objects.equals(source.getDelFlag(), 1)) {
+            throw new ServiceException("营期已删除，无法复制");
+        }
+
+        FsUserCoursePeriod copy = new FsUserCoursePeriod();
+        BeanUtils.copyProperties(source, copy, "periodId");
+        copy.setPeriodName(source.getPeriodName() + " - 副本");
+        copy.setDelFlag(0);
+        copy.setUpdateTime(null);
+        insertFsUserCoursePeriod(copy);
+
+        Long newPeriodId = copy.getPeriodId();
+
+        FsUserCoursePeriodDays queryDays = new FsUserCoursePeriodDays();
+        queryDays.setPeriodId(periodId);
+        List<FsUserCoursePeriodDays> courseList = fsUserCoursePeriodDaysMapper.selectFsUserCoursePeriodDaysList(queryDays);
+        if (CollectionUtils.isNotEmpty(courseList)) {
+            List<FsUserCoursePeriodDays> copyCourseList = courseList.stream().map(day -> {
+                FsUserCoursePeriodDays copyDay = new FsUserCoursePeriodDays();
+                BeanUtils.copyProperties(day, copyDay, "id");
+                copyDay.setPeriodId(newPeriodId);
+                copyDay.setCreateTime(new Date());
+                copyDay.setUpdateTime(null);
+                return copyDay;
+            }).collect(Collectors.toList());
+            fsUserCoursePeriodDaysService.saveBatch(copyCourseList);
+        }
+
+        List<FsUserCoursePeriodCompany> companyList = fsUserCoursePeriodCompanyService.list(
+                Wrappers.<FsUserCoursePeriodCompany>lambdaQuery().eq(FsUserCoursePeriodCompany::getPeriodId, periodId));
+        if (CollectionUtils.isNotEmpty(companyList)) {
+            List<FsUserCoursePeriodCompany> copyCompanyList = companyList.stream().map(company -> {
+                FsUserCoursePeriodCompany copyCompany = new FsUserCoursePeriodCompany();
+                BeanUtils.copyProperties(company, copyCompany, "id");
+                copyCompany.setPeriodId(newPeriodId);
+                return copyCompany;
+            }).collect(Collectors.toList());
+            fsUserCoursePeriodCompanyService.saveBatch(copyCompanyList);
+        }
+
+        return newPeriodId;
+    }
+
     /**
      * 结束营期
      * @param id    营期ID