更新多个功能

2026-06-29 07:35:07 +08:00
parent fa94f52b53
commit cf7e2560b5
41 changed files with 2388 additions and 37 deletions
@@ -0,0 +1,34 @@
+package cn.novalon.gym.manage.groupcourse.dao;
+
+import cn.novalon.gym.manage.groupcourse.entity.BannerEntity;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.r2dbc.repository.Modifying;
+import org.springframework.data.r2dbc.repository.Query;
+import org.springframework.data.r2dbc.repository.R2dbcRepository;
+import org.springframework.stereotype.Repository;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.time.LocalDateTime;
+
+@Repository
+public interface BannerDao extends R2dbcRepository<BannerEntity, Long> {
+
+    Mono<BannerEntity> findByIdAndDeletedAtIsNull(Long id);
+
+    Flux<BannerEntity> findAllByDeletedAtIsNull();
+
+    Flux<BannerEntity> findAllByDeletedAtIsNull(Sort sort);
+
+    Flux<BannerEntity> findByIsActiveTrueAndDeletedAtIsNull();
+
+    Flux<BannerEntity> findByIsActiveTrueAndDeletedAtIsNull(Sort sort);
+
+    @Modifying
+    @Query("UPDATE banner SET is_active = :isActive, updated_at = :updatedAt WHERE id = :id AND deleted_at IS NULL")
+    Mono<Integer> updateActiveStatus(Long id, Boolean isActive, LocalDateTime updatedAt);
+
+    @Modifying
+    @Query("UPDATE banner SET deleted_at = :deletedAt WHERE id = :id")
+    Mono<Integer> softDelete(Long id, LocalDateTime deletedAt);
+}
@@ -48,6 +48,10 @@ public interface GroupCourseDao extends R2dbcRepository<GroupCourseEntity, Long>
    @Query("UPDATE group_course SET status = '2', updated_at = :updatedAt WHERE status = '0' AND end_time <= NOW() AND deleted_at IS NULL")
    Mono<Integer> completeExpiredCourses(LocalDateTime updatedAt);

+    @Modifying
+    @Query("UPDATE group_course SET status = '0', current_members = 0, start_time = start_time + INTERVAL '7 days', end_time = end_time + INTERVAL '7 days', updated_at = :updatedAt WHERE is_recurring = TRUE AND status = '2' AND end_time <= NOW() AND deleted_at IS NULL")
+    Mono<Integer> renewRecurringCourses(LocalDateTime updatedAt);
+
    Flux<GroupCourseEntity> findByCourseTypeAndDeletedAtIsNull(Long courseType);

    /**
@@ -96,6 +100,11 @@ public interface GroupCourseDao extends R2dbcRepository<GroupCourseEntity, Long>
            }
        }

+        // 5. 常态化团课筛选
+        if (query.getIsRecurring() != null) {
+            conditions.add("is_recurring = :isRecurring");
+        }
+
        sql.append(" AND ").append(String.join(" AND ", conditions));

        // 5. 价格排序 / 6. 剩余名额最多排序
@@ -145,6 +154,9 @@ public interface GroupCourseDao extends R2dbcRepository<GroupCourseEntity, Long>
        if (query.getEndDate() != null) {
            spec = spec.bind("endDate", query.getEndDate());
        }
+        if (query.getIsRecurring() != null) {
+            spec = spec.bind("isRecurring", query.getIsRecurring());
+        }
        spec = spec.bind("limit", size);
        spec = spec.bind("offset", offset);

@@ -169,6 +181,7 @@ public interface GroupCourseDao extends R2dbcRepository<GroupCourseEntity, Long>
            entity.setCreatedAt(row.get("created_at", LocalDateTime.class));
            entity.setUpdatedAt(row.get("updated_at", LocalDateTime.class));
            entity.setDeletedAt(row.get("deleted_at", LocalDateTime.class));
+            entity.setIsRecurring(row.get("is_recurring", Boolean.class));
            return entity;
        }).all();
    }
@@ -211,6 +224,10 @@ public interface GroupCourseDao extends R2dbcRepository<GroupCourseEntity, Long>
            }
        }

+        if (query.getIsRecurring() != null) {
+            conditions.add("is_recurring = :isRecurring");
+        }
+
        sql.append(" AND ").append(String.join(" AND ", conditions));

        DatabaseClient.GenericExecuteSpec spec = databaseClient.sql(sql.toString());
@@ -227,6 +244,9 @@ public interface GroupCourseDao extends R2dbcRepository<GroupCourseEntity, Long>
        if (query.getEndDate() != null) {
            spec = spec.bind("endDate", query.getEndDate());
        }
+        if (query.getIsRecurring() != null) {
+            spec = spec.bind("isRecurring", query.getIsRecurring());
+        }

        return spec.map((row, meta) -> row.get(0, Long.class)).one();
    }
@@ -0,0 +1,43 @@
+package cn.novalon.gym.manage.groupcourse.domain;
+
+import cn.novalon.gym.manage.sys.core.domain.BaseDomain;
+import io.swagger.v3.oas.annotations.media.Schema;
+
+public class Banner extends BaseDomain {
+
+    @Schema(description = "背景图URL", example = "https://example.com/banner.jpg")
+    private String imageUrl;
+
+    @Schema(description = "主标题", example = "突破自我")
+    private String title;
+
+    @Schema(description = "副标题", example = "超越极限")
+    private String subtitle;
+
+    @Schema(description = "简介", example = "科学训练 · 遇见更好的自己")
+    private String description;
+
+    @Schema(description = "排序（数值越大越靠前）", example = "10")
+    private Integer sortOrder;
+
+    @Schema(description = "是否启用", example = "true")
+    private Boolean isActive;
+
+    public String getImageUrl() { return imageUrl; }
+    public void setImageUrl(String imageUrl) { this.imageUrl = imageUrl; }
+
+    public String getTitle() { return title; }
+    public void setTitle(String title) { this.title = title; }
+
+    public String getSubtitle() { return subtitle; }
+    public void setSubtitle(String subtitle) { this.subtitle = subtitle; }
+
+    public String getDescription() { return description; }
+    public void setDescription(String description) { this.description = description; }
+
+    public Integer getSortOrder() { return sortOrder; }
+    public void setSortOrder(Integer sortOrder) { this.sortOrder = sortOrder; }
+
+    public Boolean getIsActive() { return isActive; }
+    public void setIsActive(Boolean isActive) { this.isActive = isActive; }
+}
@@ -60,6 +60,10 @@ public class GroupCourse extends BaseDomain{
    @Schema(description = "二维码路径", example = "D:\\Games\\exmp\\image\\abc123_20260618120000.png")
    private String qrCodePath;

+    //是否常态化团课
+    @Schema(description = "是否常态化团课", example = "true")
+    private Boolean isRecurring;
+
    public String getCourseName() {
        return courseName;
    }
@@ -163,4 +167,12 @@ public class GroupCourse extends BaseDomain{
    public void setQrCodePath(String qrCodePath) {
        this.qrCodePath = qrCodePath;
    }
+
+    public Boolean getIsRecurring() {
+        return isRecurring;
+    }
+
+    public void setIsRecurring(Boolean isRecurring) {
+        this.isRecurring = isRecurring;
+    }
 }
@@ -40,6 +40,9 @@ public class GroupCourseQueryDto {
    @Schema(description = "每页大小", example = "10")
    private Integer size = 10;

+    @Schema(description = "是否常态化团课筛选：null-不过滤, true-仅常态化, false-仅非常态化", example = "true")
+    private Boolean isRecurring;
+
    // ===== Getters and Setters =====

    public String getCourseName() {
@@ -113,4 +116,12 @@ public class GroupCourseQueryDto {
    public void setSize(Integer size) {
        this.size = size;
    }
+
+    public Boolean getIsRecurring() {
+        return isRecurring;
+    }
+
+    public void setIsRecurring(Boolean isRecurring) {
+        this.isRecurring = isRecurring;
+    }
 }
@@ -0,0 +1,45 @@
+package cn.novalon.gym.manage.groupcourse.entity;
+
+import cn.novalon.gym.manage.db.entity.BaseEntity;
+import org.springframework.data.relational.core.mapping.Column;
+import org.springframework.data.relational.core.mapping.Table;
+
+@Table("banner")
+public class BannerEntity extends BaseEntity {
+
+    @Column("image_url")
+    private String imageUrl;
+
+    @Column("title")
+    private String title;
+
+    @Column("subtitle")
+    private String subtitle;
+
+    @Column("description")
+    private String description;
+
+    @Column("sort_order")
+    private Integer sortOrder;
+
+    @Column("is_active")
+    private Boolean isActive;
+
+    public String getImageUrl() { return imageUrl; }
+    public void setImageUrl(String imageUrl) { this.imageUrl = imageUrl; }
+
+    public String getTitle() { return title; }
+    public void setTitle(String title) { this.title = title; }
+
+    public String getSubtitle() { return subtitle; }
+    public void setSubtitle(String subtitle) { this.subtitle = subtitle; }
+
+    public String getDescription() { return description; }
+    public void setDescription(String description) { this.description = description; }
+
+    public Integer getSortOrder() { return sortOrder; }
+    public void setSortOrder(Integer sortOrder) { this.sortOrder = sortOrder; }
+
+    public Boolean getIsActive() { return isActive; }
+    public void setIsActive(Boolean isActive) { this.isActive = isActive; }
+}
@@ -62,6 +62,10 @@ public class GroupCourseEntity extends BaseEntity {
    @Column("qr_code_path")
    private String qrCodePath;

+    //是否常态化团课
+    @Column("is_recurring")
+    private Boolean isRecurring;
+
    public String getCourseName() {
        return courseName;
    }
@@ -165,4 +169,12 @@ public class GroupCourseEntity extends BaseEntity {
    public void setQrCodePath(String qrCodePath) {
        this.qrCodePath = qrCodePath;
    }
+
+    public Boolean getIsRecurring() {
+        return isRecurring;
+    }
+
+    public void setIsRecurring(Boolean isRecurring) {
+        this.isRecurring = isRecurring;
+    }
 }
@@ -0,0 +1,224 @@
+package cn.novalon.gym.manage.groupcourse.handler;
+
+import cn.novalon.gym.manage.groupcourse.domain.Banner;
+import cn.novalon.gym.manage.groupcourse.service.IBannerService;
+import cn.novalon.gym.manage.sys.core.service.ISysUserService;
+import cn.novalon.gym.manage.sys.util.AuthUtil;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import org.springframework.http.HttpStatus;
+import org.springframework.stereotype.Component;
+import org.springframework.web.reactive.function.server.ServerRequest;
+import org.springframework.web.reactive.function.server.ServerResponse;
+import reactor.core.publisher.Mono;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@Component
+@Tag(name = "轮播图管理", description = "轮播图相关操作")
+public class BannerHandler {
+
+    private final IBannerService bannerService;
+    private final ISysUserService sysUserService;
+    private final AuthUtil authUtil;
+
+    public BannerHandler(IBannerService bannerService,
+                         ISysUserService sysUserService,
+                         AuthUtil authUtil) {
+        this.bannerService = bannerService;
+        this.sysUserService = sysUserService;
+        this.authUtil = authUtil;
+    }
+
+    @Operation(summary = "获取所有轮播图", description = "获取系统中所有轮播图列表，支持按排序字段排序")
+    public Mono<ServerResponse> getAllBanners(ServerRequest request) {
+        String sortBy = request.queryParam("sortBy").orElse("sortOrder");
+        String sortOrder = request.queryParam("sortOrder").orElse("desc");
+
+        return ServerResponse.ok()
+                .body(bannerService.findAll(sortBy, sortOrder), Banner.class);
+    }
+
+    @Operation(summary = "获取所有启用的轮播图", description = "获取系统中所有已启用的轮播图列表")
+    public Mono<ServerResponse> getAllActiveBanners(ServerRequest request) {
+        return ServerResponse.ok()
+                .body(bannerService.findAllActive(), Banner.class);
+    }
+
+    @Operation(summary = "根据ID获取轮播图", description = "根据ID获取轮播图详情")
+    public Mono<ServerResponse> getBannerById(ServerRequest request) {
+        Long id = Long.valueOf(request.pathVariable("id"));
+        return bannerService.findById(id)
+                .flatMap(banner -> ServerResponse.ok().bodyValue(banner))
+                .switchIfEmpty(ServerResponse.notFound().build());
+    }
+
+    @Operation(summary = "创建轮播图", description = "创建新的轮播图记录")
+    public Mono<ServerResponse> createBanner(ServerRequest request) {
+        return request.bodyToMono(Banner.class)
+                .flatMap(banner -> {
+                    if (banner.getImageUrl() == null || banner.getImageUrl().isBlank()) {
+                        Map<String, Object> error = new HashMap<>();
+                        error.put("success", false);
+                        error.put("message", "背景图不能为空");
+                        return ServerResponse.badRequest().bodyValue(error);
+                    }
+                    if (banner.getTitle() == null || banner.getTitle().isBlank()) {
+                        Map<String, Object> error = new HashMap<>();
+                        error.put("success", false);
+                        error.put("message", "主标题不能为空");
+                        return ServerResponse.badRequest().bodyValue(error);
+                    }
+
+                    return bannerService.create(banner)
+                            .flatMap(r -> {
+                                Map<String, Object> response = new HashMap<>();
+                                response.put("success", true);
+                                response.put("message", "轮播图创建成功");
+                                response.put("data", r);
+                                return ServerResponse.ok().bodyValue(response);
+                            })
+                            .onErrorResume(error -> {
+                                Map<String, Object> response = new HashMap<>();
+                                response.put("success", false);
+                                response.put("message", error.getMessage());
+                                return ServerResponse.badRequest().bodyValue(response);
+                            });
+                });
+    }
+
+    @Operation(summary = "更新轮播图", description = "更新指定轮播图信息，需验证管理员密码")
+    public Mono<ServerResponse> updateBanner(ServerRequest request) {
+        Long adminId = authUtil.getMemberIdOrThrow(request);
+        Long id = Long.valueOf(request.pathVariable("id"));
+        String adminPassword = request.queryParam("adminPassword").orElse(null);
+
+        if (adminPassword == null || adminPassword.isBlank()) {
+            Map<String, Object> error = new HashMap<>();
+            error.put("success", false);
+            error.put("message", "管理员密码不能为空");
+            return ServerResponse.badRequest().bodyValue(error);
+        }
+
+        return sysUserService.verifyPassword(adminId, adminPassword)
+                .flatMap(valid -> {
+                    if (!valid) {
+                        Map<String, Object> error = new HashMap<>();
+                        error.put("success", false);
+                        error.put("message", "管理员密码错误");
+                        return ServerResponse.status(HttpStatus.FORBIDDEN).bodyValue(error);
+                    }
+                    return request.bodyToMono(Banner.class)
+                            .flatMap(banner -> bannerService.update(id, banner)
+                                    .flatMap(r -> {
+                                        Map<String, Object> response = new HashMap<>();
+                                        response.put("success", true);
+                                        response.put("message", "轮播图更新成功");
+                                        response.put("data", r);
+                                        return ServerResponse.ok().bodyValue(response);
+                                    })
+                                    .onErrorResume(error -> {
+                                        Map<String, Object> response = new HashMap<>();
+                                        response.put("success", false);
+                                        response.put("message", error.getMessage());
+                                        return ServerResponse.badRequest().bodyValue(response);
+                                    }));
+                });
+    }
+
+    @Operation(summary = "删除轮播图", description = "删除指定轮播图（软删除），需验证管理员密码")
+    public Mono<ServerResponse> deleteBanner(ServerRequest request) {
+        Long adminId = authUtil.getMemberIdOrThrow(request);
+        Long id = Long.valueOf(request.pathVariable("id"));
+        String adminPassword = request.queryParam("adminPassword").orElse(null);
+
+        if (adminPassword == null || adminPassword.isBlank()) {
+            Map<String, Object> error = new HashMap<>();
+            error.put("success", false);
+            error.put("message", "管理员密码不能为空");
+            return ServerResponse.badRequest().bodyValue(error);
+        }
+
+        return sysUserService.verifyPassword(adminId, adminPassword)
+                .flatMap(valid -> {
+                    if (!valid) {
+                        Map<String, Object> error = new HashMap<>();
+                        error.put("success", false);
+                        error.put("message", "管理员密码错误");
+                        return ServerResponse.status(HttpStatus.FORBIDDEN).bodyValue(error);
+                    }
+                    return bannerService.delete(id)
+                            .then(Mono.defer(() -> {
+                                Map<String, Object> response = new HashMap<>();
+                                response.put("success", true);
+                                response.put("message", "轮播图删除成功");
+                                return ServerResponse.ok().bodyValue(response);
+                            }))
+                            .onErrorResume(error -> {
+                                Map<String, Object> response = new HashMap<>();
+                                response.put("success", false);
+                                response.put("message", error.getMessage());
+                                return ServerResponse.badRequest().bodyValue(response);
+                            });
+                });
+    }
+
+    @Operation(summary = "启用轮播图", description = "启用指定轮播图")
+    public Mono<ServerResponse> enableBanner(ServerRequest request) {
+        Long id = Long.valueOf(request.pathVariable("id"));
+
+        return bannerService.enable(id)
+                .flatMap(r -> {
+                    Map<String, Object> response = new HashMap<>();
+                    response.put("success", true);
+                    response.put("message", "轮播图启用成功");
+                    response.put("data", r);
+                    return ServerResponse.ok().bodyValue(response);
+                })
+                .onErrorResume(error -> {
+                    Map<String, Object> response = new HashMap<>();
+                    response.put("success", false);
+                    response.put("message", error.getMessage());
+                    return ServerResponse.badRequest().bodyValue(response);
+                });
+    }
+
+    @Operation(summary = "禁用轮播图", description = "禁用指定轮播图，需验证管理员密码")
+    public Mono<ServerResponse> disableBanner(ServerRequest request) {
+        Long adminId = authUtil.getMemberIdOrThrow(request);
+        Long id = Long.valueOf(request.pathVariable("id"));
+        String adminPassword = request.queryParam("adminPassword").orElse(null);
+
+        if (adminPassword == null || adminPassword.isBlank()) {
+            Map<String, Object> error = new HashMap<>();
+            error.put("success", false);
+            error.put("message", "管理员密码不能为空");
+            return ServerResponse.badRequest().bodyValue(error);
+        }
+
+        return sysUserService.verifyPassword(adminId, adminPassword)
+                .flatMap(valid -> {
+                    if (!valid) {
+                        Map<String, Object> error = new HashMap<>();
+                        error.put("success", false);
+                        error.put("message", "管理员密码错误");
+                        return ServerResponse.status(HttpStatus.FORBIDDEN).bodyValue(error);
+                    }
+                    return bannerService.disable(id)
+                            .flatMap(r -> {
+                                Map<String, Object> response = new HashMap<>();
+                                response.put("success", true);
+                                response.put("message", "轮播图禁用成功");
+                                response.put("data", r);
+                                return ServerResponse.ok().bodyValue(response);
+                            })
+                            .onErrorResume(error -> {
+                                Map<String, Object> response = new HashMap<>();
+                                response.put("success", false);
+                                response.put("message", error.getMessage());
+                                return ServerResponse.badRequest().bodyValue(response);
+                            });
+                });
+    }
+}
@@ -177,4 +177,31 @@ public class GroupCourseBookingHandler {
        response.put("message", message);
        return ServerResponse.badRequest().bodyValue(response);
    }
+
+    /**
+     * 扫码签到（二维码扫一扫签到）
+     * 用户扫描团课签到二维码后，更新预约记录状态为 2（已出席）
+     */
+    @Operation(summary = "扫码签到", description = "用户扫描团课二维码签到，更新预约状态为已出席")
+    public Mono<ServerResponse> qrSignIn(ServerRequest request) {
+        Long courseId = Long.valueOf(request.pathVariable("courseId"));
+
+        return request.bodyToMono(Map.class)
+                .flatMap(body -> {
+                    if (body.get("memberId") == null) {
+                        return buildErrorResponse("请提供会员ID");
+                    }
+                    Long memberId = toLong(body.get("memberId"), "memberId");
+
+                    return bookingService.qrSignIn(courseId, memberId)
+                            .flatMap(booking -> {
+                                Map<String, Object> response = new HashMap<>();
+                                response.put("success", true);
+                                response.put("message", "签到成功");
+                                response.put("data", booking);
+                                return ServerResponse.ok().bodyValue(response);
+                            })
+                            .onErrorResume(error -> buildErrorResponse(error.getMessage()));
+                });
+    }
 }
@@ -10,6 +10,10 @@ import cn.novalon.gym.manage.groupcourse.service.IGroupCourseService;
 import cn.novalon.gym.manage.sys.core.service.ISysUserService;
 import cn.novalon.gym.manage.sys.util.AuthUtil;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.zxing.BarcodeFormat;
+import com.google.zxing.client.j2se.MatrixToImageWriter;
+import com.google.zxing.common.BitMatrix;
+import com.google.zxing.qrcode.QRCodeWriter;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import jakarta.validation.Validator;
@@ -18,7 +22,10 @@ import org.springframework.stereotype.Component;
 import org.springframework.web.reactive.function.server.ServerRequest;
 import org.springframework.web.reactive.function.server.ServerResponse;
 import reactor.core.publisher.Mono;
+import reactor.core.scheduler.Schedulers;

+import java.io.ByteArrayOutputStream;
+import java.util.Base64;
 import java.util.HashMap;
 import java.util.Map;

@@ -372,4 +379,44 @@ public class GroupCourseHandler {
                            });
                });
    }
+
+    @Operation(summary = "获取团课签到二维码", description = "根据团课ID生成签到二维码（base64）")
+    public Mono<ServerResponse> getCourseQRCode(ServerRequest request) {
+        Long courseId = Long.valueOf(request.pathVariable("id"));
+
+        return groupCourseService.findById(courseId)
+                .flatMap(course -> {
+                    return Mono.fromCallable(() -> {
+                        String qrContent = "{\"courseId\":" + course.getId()
+                                + ",\"courseName\":\"" + escapeJson(course.getCourseName()) + "\"}";
+
+                        QRCodeWriter qrCodeWriter = new QRCodeWriter();
+                        BitMatrix bitMatrix = qrCodeWriter.encode(qrContent, BarcodeFormat.QR_CODE, 300, 300);
+
+                        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+                        MatrixToImageWriter.writeToStream(bitMatrix, "PNG", outputStream);
+                        byte[] pngBytes = outputStream.toByteArray();
+                        String base64 = Base64.getEncoder().encodeToString(pngBytes);
+
+                        Map<String, Object> result = new HashMap<>();
+                        result.put("base64", "data:image/png;base64," + base64);
+                        result.put("courseId", course.getId());
+                        result.put("courseName", course.getCourseName());
+                        result.put("width", 300);
+                        result.put("height", 300);
+                        return result;
+                    }).subscribeOn(reactor.core.scheduler.Schedulers.boundedElastic());
+                })
+                .flatMap(result -> ServerResponse.ok().bodyValue(result))
+                .switchIfEmpty(ServerResponse.notFound().build());
+    }
+
+    private String escapeJson(String s) {
+        if (s == null) return "";
+        return s.replace("\\", "\\\\")
+                .replace("\"", "\\\"")
+                .replace("\n", "\\n")
+                .replace("\r", "\\r")
+                .replace("\t", "\\t");
+    }
 }
@@ -0,0 +1,24 @@
+package cn.novalon.gym.manage.groupcourse.repository;
+
+import cn.novalon.gym.manage.groupcourse.domain.Banner;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+public interface IBannerRepository {
+
+    Mono<Banner> findById(Long id);
+
+    Flux<Banner> findAll();
+
+    Flux<Banner> findAll(String sortBy, String sortOrder);
+
+    Flux<Banner> findAllActive();
+
+    Mono<Banner> save(Banner banner);
+
+    Mono<Banner> update(Banner banner);
+
+    Mono<Void> deleteById(Long id);
+
+    Mono<Banner> updateActiveStatus(Long id, Boolean isActive);
+}
@@ -0,0 +1,113 @@
+package cn.novalon.gym.manage.groupcourse.repository.impl;
+
+import cn.hutool.core.bean.BeanUtil;
+import cn.novalon.gym.manage.groupcourse.dao.BannerDao;
+import cn.novalon.gym.manage.groupcourse.domain.Banner;
+import cn.novalon.gym.manage.groupcourse.entity.BannerEntity;
+import cn.novalon.gym.manage.groupcourse.repository.IBannerRepository;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
+import org.springframework.stereotype.Repository;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.time.LocalDateTime;
+
+@Repository
+public class BannerRepository implements IBannerRepository {
+
+    private final BannerDao bannerDao;
+    private final R2dbcEntityTemplate r2dbcEntityTemplate;
+
+    public BannerRepository(BannerDao bannerDao, R2dbcEntityTemplate r2dbcEntityTemplate) {
+        this.bannerDao = bannerDao;
+        this.r2dbcEntityTemplate = r2dbcEntityTemplate;
+    }
+
+    @Override
+    public Mono<Banner> findById(Long id) {
+        return bannerDao.findByIdAndDeletedAtIsNull(id)
+                .map(this::toDomain);
+    }
+
+    @Override
+    public Flux<Banner> findAll() {
+        return bannerDao.findAllByDeletedAtIsNull()
+                .map(this::toDomain);
+    }
+
+    @Override
+    public Flux<Banner> findAll(String sortBy, String sortOrder) {
+        Sort.Direction direction = "asc".equalsIgnoreCase(sortOrder)
+                ? Sort.Direction.ASC
+                : Sort.Direction.DESC;
+        Sort sort = Sort.by(direction, sortBy);
+        return bannerDao.findAllByDeletedAtIsNull(sort)
+                .map(this::toDomain);
+    }
+
+    @Override
+    public Flux<Banner> findAllActive() {
+        return bannerDao.findByIsActiveTrueAndDeletedAtIsNull(Sort.by(Sort.Direction.DESC, "sortOrder"))
+                .map(this::toDomain);
+    }
+
+    @Override
+    public Mono<Banner> save(Banner banner) {
+        BannerEntity entity = toEntity(banner);
+        entity.setCreatedAt(LocalDateTime.now());
+        entity.setUpdatedAt(LocalDateTime.now());
+        if (entity.getSortOrder() == null) {
+            entity.setSortOrder(0);
+        }
+        if (entity.getIsActive() == null) {
+            entity.setIsActive(true);
+        }
+
+        return bannerDao.save(entity)
+                .map(this::toDomain);
+    }
+
+    @Override
+    public Mono<Banner> update(Banner banner) {
+        BannerEntity entity = toEntity(banner);
+        entity.setUpdatedAt(LocalDateTime.now());
+
+        return r2dbcEntityTemplate.update(entity)
+                .then(findById(banner.getId()));
+    }
+
+    @Override
+    public Mono<Void> deleteById(Long id) {
+        return bannerDao.softDelete(id, LocalDateTime.now())
+                .then();
+    }
+
+    @Override
+    public Mono<Banner> updateActiveStatus(Long id, Boolean isActive) {
+        return bannerDao.updateActiveStatus(id, isActive, LocalDateTime.now())
+                .flatMap(updated -> {
+                    if (updated > 0) {
+                        return findById(id);
+                    }
+                    return Mono.empty();
+                });
+    }
+
+    private Banner toDomain(BannerEntity entity) {
+        if (entity == null) return null;
+        Banner banner = new Banner();
+        BeanUtil.copyProperties(entity, banner);
+        return banner;
+    }
+
+    private BannerEntity toEntity(Banner domain) {
+        if (domain == null) return null;
+        BannerEntity entity = new BannerEntity();
+        BeanUtil.copyProperties(domain, entity);
+        if (domain.getId() != null) {
+            entity.markNotNew();
+        }
+        return entity;
+    }
+}
@@ -138,6 +138,7 @@ public class GroupCourseRepository implements IGroupCourseRepository {
        entity.setUpdatedAt(LocalDateTime.now());
        entity.setStatus(0L);
        entity.setCurrentMembers(0);
+        entity.setIsRecurring(groupCourse.getIsRecurring() != null ? groupCourse.getIsRecurring() : false);
        
        return groupCourseDao.save(entity)
                .map(groupCourseConverter::toDomain);
@@ -147,6 +148,7 @@ public class GroupCourseRepository implements IGroupCourseRepository {
    public Mono<GroupCourse> update(GroupCourse groupCourse) {
        GroupCourseEntity entity = groupCourseConverter.toEntity(groupCourse);
        entity.setUpdatedAt(LocalDateTime.now());
+        entity.setIsRecurring(groupCourse.getIsRecurring() != null ? groupCourse.getIsRecurring() : false);
        
        return r2dbcEntityTemplate.update(entity)
                .then(findByIdAndDeletedAtIsNull(groupCourse.getId()));
@@ -0,0 +1,48 @@
+package cn.novalon.gym.manage.groupcourse.scheduler;
+
+import cn.novalon.gym.manage.groupcourse.dao.GroupCourseDao;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+
+import java.time.LocalDateTime;
+
+/**
+ * 常态化团课自动续期定时任务
+ * 
+ * 功能：定期检查已结束的常态化团课（is_recurring = TRUE 且 status = '2'），
+ * 自动重置状态为正常（status = '0'），并将课程时间推迟一周，重新开始。
+ * 
+ * @date 2026-06-29
+ */
+@Component
+public class GroupCourseRecurringScheduler {
+
+    private static final Logger logger = LoggerFactory.getLogger(GroupCourseRecurringScheduler.class);
+
+    private final GroupCourseDao groupCourseDao;
+
+    public GroupCourseRecurringScheduler(GroupCourseDao groupCourseDao) {
+        this.groupCourseDao = groupCourseDao;
+    }
+
+    /**
+     * 每分钟检查一次，将已结束的常态化团课重置为正常状态，
+     * 并将上课时间/下课时间各推迟一周
+     */
+    @Scheduled(fixedRate = 60000)
+    public void renewRecurringCourses() {
+        logger.debug("定时任务开始检查常态化团课，续期已结束的课程");
+
+        groupCourseDao.renewRecurringCourses(LocalDateTime.now())
+                .subscribe(
+                        count -> {
+                            if (count > 0) {
+                                logger.info("常态化团课续期完成，更新了 {} 条课程", count);
+                            }
+                        },
+                        error -> logger.error("常态化团课续期定时任务执行失败：{}", error.getMessage(), error)
+                );
+    }
+}
@@ -0,0 +1,26 @@
+package cn.novalon.gym.manage.groupcourse.service;
+
+import cn.novalon.gym.manage.groupcourse.domain.Banner;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+public interface IBannerService {
+
+    Mono<Banner> findById(Long id);
+
+    Flux<Banner> findAll();
+
+    Flux<Banner> findAll(String sortBy, String sortOrder);
+
+    Flux<Banner> findAllActive();
+
+    Mono<Banner> create(Banner banner);
+
+    Mono<Banner> update(Long id, Banner banner);
+
+    Mono<Void> delete(Long id);
+
+    Mono<Banner> enable(Long id);
+
+    Mono<Banner> disable(Long id);
+}
@@ -62,4 +62,14 @@ public interface IGroupCourseBookingService {
     * @return 处理的记录数
     */
    Mono<Integer> processAbsentMembers();
+
+    /**
+     * 扫码签到
+     * 用户扫描团课二维码签到，将预约状态更新为已出席(2)
+     * 
+     * @param courseId 团课ID
+     * @param memberId 会员ID
+     * @return 更新后的预约记录
+     */
+    Mono<GroupCourseBooking> qrSignIn(Long courseId, Long memberId);
 }
@@ -0,0 +1,99 @@
+package cn.novalon.gym.manage.groupcourse.service.impl;
+
+import cn.novalon.gym.manage.groupcourse.domain.Banner;
+import cn.novalon.gym.manage.groupcourse.repository.IBannerRepository;
+import cn.novalon.gym.manage.groupcourse.service.IBannerService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+@Service
+public class BannerService implements IBannerService {
+
+    private static final Logger logger = LoggerFactory.getLogger(BannerService.class);
+
+    private final IBannerRepository bannerRepository;
+
+    public BannerService(IBannerRepository bannerRepository) {
+        this.bannerRepository = bannerRepository;
+    }
+
+    @Override
+    public Mono<Banner> findById(Long id) {
+        return bannerRepository.findById(id);
+    }
+
+    @Override
+    public Flux<Banner> findAll() {
+        return bannerRepository.findAll();
+    }
+
+    @Override
+    public Flux<Banner> findAll(String sortBy, String sortOrder) {
+        return bannerRepository.findAll(sortBy, sortOrder);
+    }
+
+    @Override
+    public Flux<Banner> findAllActive() {
+        return bannerRepository.findAllActive();
+    }
+
+    @Override
+    public Mono<Banner> create(Banner banner) {
+        if (banner.getImageUrl() == null || banner.getImageUrl().isBlank()) {
+            return Mono.error(new RuntimeException("背景图不能为空"));
+        }
+        if (banner.getTitle() == null || banner.getTitle().isBlank()) {
+            return Mono.error(new RuntimeException("主标题不能为空"));
+        }
+
+        return bannerRepository.save(banner)
+                .doOnSuccess(r -> logger.info("轮播图创建成功 - id={}, title={}", r.getId(), r.getTitle()))
+                .doOnError(error -> logger.error("轮播图创建失败 - error: {}", error.getMessage()));
+    }
+
+    @Override
+    public Mono<Banner> update(Long id, Banner banner) {
+        return bannerRepository.findById(id)
+                .switchIfEmpty(Mono.error(new RuntimeException("轮播图不存在")))
+                .flatMap(existing -> {
+                    if (banner.getImageUrl() != null) existing.setImageUrl(banner.getImageUrl());
+                    if (banner.getTitle() != null) existing.setTitle(banner.getTitle());
+                    if (banner.getSubtitle() != null) existing.setSubtitle(banner.getSubtitle());
+                    if (banner.getDescription() != null) existing.setDescription(banner.getDescription());
+                    if (banner.getSortOrder() != null) existing.setSortOrder(banner.getSortOrder());
+                    if (banner.getIsActive() != null) existing.setIsActive(banner.getIsActive());
+
+                    return bannerRepository.update(existing);
+                })
+                .doOnSuccess(r -> logger.info("轮播图更新成功 - id={}", id))
+                .doOnError(error -> logger.error("轮播图更新失败 - id={}, error: {}", id, error.getMessage()));
+    }
+
+    @Override
+    public Mono<Void> delete(Long id) {
+        return bannerRepository.findById(id)
+                .switchIfEmpty(Mono.error(new RuntimeException("轮播图不存在")))
+                .flatMap(banner -> bannerRepository.deleteById(id)
+                        .doOnSuccess(v -> logger.info("轮播图删除成功 - id={}", id))
+                        .doOnError(error -> logger.error("轮播图删除失败 - id={}, error: {}", id, error.getMessage())));
+    }
+
+    @Override
+    public Mono<Banner> enable(Long id) {
+        return bannerRepository.updateActiveStatus(id, true)
+                .switchIfEmpty(Mono.error(new RuntimeException("轮播图不存在")))
+                .doOnSuccess(r -> logger.info("轮播图启用成功 - id={}", id))
+                .doOnError(error -> logger.error("轮播图启用失败 - id={}, error: {}", id, error.getMessage()));
+    }
+
+    @Override
+    public Mono<Banner> disable(Long id) {
+        return bannerRepository.updateActiveStatus(id, false)
+                .switchIfEmpty(Mono.error(new RuntimeException("轮播图不存在")))
+                .doOnSuccess(r -> logger.info("轮播图禁用成功 - id={}", id))
+                .doOnError(error -> logger.error("轮播图禁用失败 - id={}, error: {}", id, error.getMessage()));
+    }
+}
@@ -9,6 +9,7 @@ import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseRepository;
 import cn.novalon.gym.manage.groupcourse.service.IGroupCourseBookingService;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.r2dbc.core.DatabaseClient;
 import org.springframework.stereotype.Service;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
@@ -46,6 +47,7 @@ public class GroupCourseBookingService implements IGroupCourseBookingService {
    private final GroupCourseRedisService redisService;
    private final BookingReminderEventPublisher bookingReminderEventPublisher;
    private final BookingSagaHandler bookingSagaHandler;
+    private final DatabaseClient databaseClient;

    // 预约提前时间限制（分钟）
    private static final long BOOKING_MIN_ADVANCE_MINUTES = 30;
@@ -56,12 +58,14 @@ public class GroupCourseBookingService implements IGroupCourseBookingService {
                                     IGroupCourseRepository courseRepository,
                                     GroupCourseRedisService redisService,
                                     BookingReminderEventPublisher bookingReminderEventPublisher,
-                                     BookingSagaHandler bookingSagaHandler) {
+                                     BookingSagaHandler bookingSagaHandler,
+                                     DatabaseClient databaseClient) {
        this.bookingRepository = bookingRepository;
        this.courseRepository = courseRepository;
        this.redisService = redisService;
        this.bookingReminderEventPublisher = bookingReminderEventPublisher;
        this.bookingSagaHandler = bookingSagaHandler;
+        this.databaseClient = databaseClient;
    }

    @Override
@@ -347,6 +351,78 @@ public class GroupCourseBookingService implements IGroupCourseBookingService {
                .doOnComplete(() -> logger.debug("查询完成：courseId={}", courseId));
    }

+    @Override
+    public Mono<GroupCourseBooking> qrSignIn(Long courseId, Long memberId) {
+        logger.info("扫码签到：courseId={}, memberId={}", courseId, memberId);
+
+        return courseRepository.findByIdAndDeletedAtIsNull(courseId)
+                .switchIfEmpty(Mono.error(new RuntimeException("团课不存在或已删除")))
+                .flatMap(course -> {
+                    // 校验1：团课状态必须为 0（正常）
+                    Long status = course.getStatus();
+                    if (status == null || status != 0L) {
+                        String msg;
+                        if (status == null) msg = "课程状态异常";
+                        else if (status == 1L) msg = "课程已取消，无法签到";
+                        else if (status == 2L) msg = "课程已结束，无法签到";
+                        else msg = "课程状态不可签到";
+                        return Mono.error(new RuntimeException(msg));
+                    }
+
+                    // 校验2：用户是否预约了该课程（状态为 0-已预约）
+                    return bookingRepository.findValidBooking(courseId, memberId)
+                            .switchIfEmpty(Mono.error(new RuntimeException("您未预约此课程，无法签到")))
+                            .flatMap(booking -> {
+                                // 校验3：预约状态必须为 0
+                                if (!"0".equals(booking.getStatus())) {
+                                    String msg;
+                                    if ("1".equals(booking.getStatus())) msg = "预约已取消";
+                                    else if ("2".equals(booking.getStatus())) msg = "已签到，无需重复签到";
+                                    else msg = "预约状态异常";
+                                    return Mono.error(new RuntimeException(msg));
+                                }
+
+                                // 更新预约状态为 2（已出席）
+                                return bookingRepository.updateStatus(booking.getId(), "2")
+                                        .then(Mono.defer(() -> {
+                                            // 同步写入签到记录，供仪表盘统计
+                                            LocalDateTime now = LocalDateTime.now();
+                                            LocalDateTime todayStart = now.toLocalDate().atStartOfDay();
+                                            LocalDateTime todayEnd = todayStart.plusDays(1);
+
+                                            // 先检查今天是否已有成功签到记录，避免重复
+                                            return databaseClient.sql(
+                                                "SELECT sign_in_status FROM sign_in_record WHERE member_id = :memberId AND sign_in_time >= :startTime AND sign_in_time < :endTime AND is_delete = false AND sign_in_status = 'SUCCESS' ORDER BY sign_in_time DESC LIMIT 1")
+                                                .bind("memberId", memberId)
+                                                .bind("startTime", todayStart)
+                                                .bind("endTime", todayEnd)
+                                                .map(row -> row.get("sign_in_status", String.class))
+                                                .one()
+                                                .flatMap(existing -> {
+                                                    // 已有签到记录，不重复插入
+                                                    return bookingRepository.findById(booking.getId());
+                                                })
+                                                .switchIfEmpty(
+                                                    // 无今日签到记录，插入一条
+                                                    databaseClient.sql(
+                                                        "INSERT INTO sign_in_record (member_id, member_card_id, sign_in_time, sign_in_type, sign_in_status, source, created_at, updated_at, is_delete) " +
+                                                        "VALUES (:memberId, :memberCardId, :signInTime, 'QR_CODE', 'SUCCESS', 'MINI_PROGRAM', NOW(), NOW(), false)")
+                                                        .bind("memberId", memberId)
+                                                        .bind("memberCardId", booking.getMemberCardRecordId())
+                                                        .bind("signInTime", now)
+                                                        .fetch()
+                                                        .rowsUpdated()
+                                                        .then(bookingRepository.findById(booking.getId()))
+                                                );
+                                        }));
+                            });
+                })
+                .doOnSuccess(booking -> logger.info("扫码签到成功：bookingId={}, courseId={}, memberId={}", 
+                        booking.getId(), courseId, memberId))
+                .doOnError(error -> logger.error("扫码签到失败：courseId={}, memberId={}, error={}", 
+                        courseId, memberId, error.getMessage()));
+    }
+
    @Override
    public Mono<Integer> processAbsentMembers() {
        logger.info("开始处理已开始课程但未到场会员的预约记录");
@@ -347,6 +347,9 @@ public class GroupCourseService implements IGroupCourseService {
                    if (groupCourse.getQrCodePath() != null) {
                        existing.setQrCodePath(groupCourse.getQrCodePath());
                    }
+                    if (groupCourse.getIsRecurring() != null) {
+                        existing.setIsRecurring(groupCourse.getIsRecurring());
+                    }
                    return groupCourseRepository.update(existing);
                })
                .doOnSuccess(course -> logger.info("团课更新成功 - id={}", id))