tj

RuoYi-Vue/ruoyi-system/src/main/java/com/ruoyi/novel/controller/AdminNovelController.java

 import com.ruoyi.common.core.domain.AjaxResult;
 import com.ruoyi.common.core.page.TableDataInfo;
 import com.ruoyi.novel.domain.AuthorApplication;
-import com.ruoyi.novel.domain.Chapter;
 import com.ruoyi.novel.domain.Novel;
+import com.ruoyi.novel.domain.NovelChapter;
 import com.ruoyi.novel.service.NovelService;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.http.HttpStatus;
-import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
 import org.springframework.web.multipart.MultipartFile;
 
 import java.util.List;
-import java.util.Map;
 
 @RestController
 @RequestMapping("/admin/novel")
                                     @RequestParam Long novelId,
                                     @RequestParam(required = false) Integer chapterOrder) {
         try {
-            Chapter chapter = novelService.processChapterUpload(file, novelId, chapterOrder);
+            NovelChapter chapter = novelService.processChapterUpload(file, novelId, chapterOrder);
             return AjaxResult.success(chapter);
         } catch (Exception e) {
             return AjaxResult.error(e.getMessage());

RuoYi-Vue/ruoyi-system/src/main/java/com/ruoyi/novel/controller/NovelController.java

 import com.ruoyi.common.core.page.TableDataInfo;
 import com.ruoyi.common.core.page.TableSupport;
 import com.ruoyi.novel.domain.AuthorApplicationDTO;
-import com.ruoyi.novel.domain.Chapter;
 import com.ruoyi.novel.domain.Novel;
 import com.ruoyi.novel.domain.NovelCategory;
+import com.ruoyi.novel.domain.NovelChapter;
 import com.ruoyi.novel.mapper.NovelMapper;
 import com.ruoyi.novel.service.IAuthService;
 import com.ruoyi.novel.service.NovelSearchService;
 import com.ruoyi.novel.service.NovelService;
-import jdk.jfr.Category;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.cache.annotation.Cacheable;
     public AjaxResult getChapterContent(@PathVariable("chapterId") Long chapterId) {
         //return AjaxResult.success(novelService.getChapterContent(chapterId));
 
-        Chapter chapter = novelService.getChapterContent(chapterId);
+        NovelChapter chapter = novelService.getChapterContent(chapterId);
         if (chapter == null) {
             return AjaxResult.error("章节不存在");
         }

RuoYi-Vue/ruoyi-system/src/main/java/com/ruoyi/novel/domain/Chapter.java

-package com.ruoyi.novel.domain;
-
-
-import com.ruoyi.novel.service.NovelService;
-import com.ruoyi.system.domain.SysOperLog;
-import lombok.Data;
-import org.springframework.beans.factory.annotation.Autowired;
-
-import javax.persistence.*;
-import java.util.Date;
-
-@Data
-@Entity
-@Table(name = "chapter")
-public class Chapter {
-
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long id;
-    @Column(name = "novel_id")
-    private Long novelId;
-    private String title;
-    @Lob
-    @Column(columnDefinition = "TEXT")
-    private String content;
-    @Column(name = "chapter_order")
-    private Integer chapterOrder;
-
-    @Column(name = "create_time")
-    private Date createTime;
-
-    // Getters and setters
-}

RuoYi-Vue/ruoyi-system/src/main/java/com/ruoyi/novel/mapper/CategoryMapper.java

-package com.ruoyi.novel.mapper;
-
-import com.ruoyi.novel.domain.NovelCategory;
-import jdk.jfr.Category;
-import org.apache.ibatis.annotations.Mapper;
-import org.apache.ibatis.annotations.Param;
-
-import java.util.List;
-
-// CategoryMapper.java
-@Mapper
-public interface CategoryMapper {
-    List<NovelCategory> selectCategoryList();
-    NovelCategory selectById(@Param("categoryId") String categoryId);
-}

RuoYi-Vue/ruoyi-system/src/main/java/com/ruoyi/novel/mapper/ChapterMapper.java

-package com.ruoyi.novel.mapper;
-
-import com.ruoyi.novel.domain.Chapter;
-import org.apache.ibatis.annotations.Mapper;
-
-import java.util.List;
-@Mapper
-public interface ChapterMapper {
-    Chapter selectChapterById(Long id);
-    int insertChapter(Chapter chapter);
-    List<Chapter> selectChapterList(Chapter chapter);
-    Integer selectMaxChapterOrder(Long novelId);
-    int selectChapterCountByNovelId(Long novelId);
-}

RuoYi-Vue/ruoyi-system/src/main/java/com/ruoyi/novel/mapper/NovelCategoryMapper.java

 import com.ruoyi.novel.domain.NovelCategory;
 import java.util.List;
 import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
 
 @Mapper // 确保添加 Mapper 注解
 public interface NovelCategoryMapper {
     List<NovelCategory> selectCategoryList();
-    NovelCategory selectById(Integer categoryId);
+    //NovelCategory selectById(Integer categoryId);
+
+//    List<NovelCategory> selectCategoryList();
+    NovelCategory selectById(@Param("categoryId") String categoryId);
 }

RuoYi-Vue/ruoyi-system/src/main/java/com/ruoyi/novel/mapper/NovelChapterMapper.java

     Integer selectMaxChapterOrderByNovelId(Long novelId);
 
     void updateReadCount(Long id);
+
+//    NovelChapter selectChapterById(Long id);
+//    int insertChapter(NovelChapter chapter);
+    List<NovelChapter> selectChapterList(NovelChapter chapter);
+    Integer selectMaxChapterOrder(Long novelId);
+    int selectChapterCountByNovelId(Long novelId);
 }

RuoYi-Vue/ruoyi-system/src/main/java/com/ruoyi/novel/service/ChapterRepository.java

 package com.ruoyi.novel.service;
 
-import com.ruoyi.novel.domain.Chapter;
+import com.ruoyi.novel.domain.NovelChapter;
 import org.apache.ibatis.annotations.Param;
 //import org.springframework.data.elasticsearch.annotations.Query;
 import org.springframework.data.jpa.repository.JpaRepository;
 import java.util.List;
 
 // ChapterRepository.java
-public interface ChapterRepository extends JpaRepository<Chapter, Long> {
+public interface ChapterRepository extends JpaRepository<NovelChapter, Long> {
 
-    List<Chapter> findByNovelIdOrderByChapterOrderAsc(Long novelId);
+    List<NovelChapter> findByNovelIdOrderByChapterOrderAsc(Long novelId);
 
-    @Query("SELECT MAX(c.chapterOrder) FROM Chapter c WHERE c.novelId = :novelId")
-    Integer findMaxChapterOrderByNovelId(@Param("novelId") Long novelId);
+//    @Query("SELECT MAX(c.chapterOrder) FROM NovelChapter c WHERE c.novelId = :novelId")
+//    Integer findMaxChapterOrderByNovelId(@Param("novelId") Long novelId);
 }

RuoYi-Vue/ruoyi-system/src/main/java/com/ruoyi/novel/service/NovelCategoryService.java

 public interface NovelCategoryService {
     List<NovelCategory> list();
     List<NovelCategory> selectCategoryList();
-    NovelCategory getCategoryById(Integer categoryId);
+    NovelCategory getCategoryById(String categoryId);
     List<NovelCategory> getCategoryTree();
 }

RuoYi-Vue/ruoyi-system/src/main/java/com/ruoyi/novel/service/NovelService.java

     List<NovelCategory> getAllCategories();
     List<Novel> getHotNovels();
     NovelCategory getNovelsByCategory(Long categoryId);
-    List<Chapter> getChaptersByNovelId(Long novelId);
-    Chapter getChapterContent(Long chapterId);
+    List<NovelChapter> getChaptersByNovelId(Long novelId);
+    NovelChapter getChapterContent(Long chapterId);
     void submitAuthorApplication(AuthorApplicationDTO dto, Long userId);
 
     List<Novel> getAllNovels();
 
     Novel processNovelUpload(MultipartFile file, String title, Long authorId);
 
-    Chapter processChapterUpload(MultipartFile file, Long novelId, Integer chapterOrder);
+    NovelChapter processChapterUpload(MultipartFile file, Long novelId, Integer chapterOrder);
 
 //    void processNovelUpload(NovelUploadDTO dto);
 //

RuoYi-Vue/ruoyi-system/src/main/java/com/ruoyi/novel/service/impl/ChapterServiceImpl.java

 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.ruoyi.novel.domain.NovelChapter;
 import com.ruoyi.novel.domain.NovelContent;
-import com.ruoyi.novel.mapper.ChapterMapper;
+//import com.ruoyi.novel.mapper.ChapterMapper;
 import com.ruoyi.novel.mapper.NovelChapterMapper;
 import com.ruoyi.novel.mapper.NovelContentMapper;
 import com.ruoyi.novel.service.ChapterService;

RuoYi-Vue/ruoyi-system/src/main/java/com/ruoyi/novel/service/impl/NovelCategoryServiceImpl.java

     }
 
     @Override
-    public NovelCategory getCategoryById(Integer categoryId) {
+    public NovelCategory getCategoryById(String categoryId) {
         return novelCategoryMapper.selectById(categoryId);
     }
 

RuoYi-Vue/ruoyi-system/src/main/java/com/ruoyi/novel/service/impl/NovelServiceImpl.java

 import com.ruoyi.novel.config.TableSupport;
 import com.ruoyi.novel.domain.*;
 import com.ruoyi.novel.mapper.AuthorApplicationMapper;
-import com.ruoyi.novel.mapper.CategoryMapper;
-import com.ruoyi.novel.mapper.ChapterMapper;
+import com.ruoyi.novel.mapper.NovelCategoryMapper;
+import com.ruoyi.novel.mapper.NovelChapterMapper;
 import com.ruoyi.novel.mapper.NovelMapper;
 //import com.ruoyi.novel.repository.elastic.NovelSearchRepository;
 
 import com.ruoyi.novel.service.*;
 import com.ruoyi.novel.utils.Base64Utils;
 import com.ruoyi.system.mapper.SysUserMapper;
-import jdk.jfr.Category;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
     @Autowired
     private NovelMapper novelMapper;
     @Autowired
-    private ChapterMapper chapterMapper;
+    private NovelChapterMapper chapterMapper;
 
     @Autowired
     private AuthorApplicationMapper authorApplicationMapper;
 
     @Autowired
-    private CategoryMapper categoryMapper;
+    private NovelCategoryMapper categoryMapper;
 
     @Autowired
     private SysUserMapper userMapper;
             novelMapper.insertNovel(novel);
 
             // 解析并保存章节
-            List<Chapter> chapters = parseChapters(file);
+            List<NovelChapter> chapters = parseChapters(file);
             for (int i = 0; i < chapters.size(); i++) {
-                Chapter chapter = chapters.get(i);
+                NovelChapter chapter = chapters.get(i);
                 chapter.setNovelId(novel.getId());
                 chapter.setChapterOrder(i + 1);
                 chapter.setCreateTime(new Date());
         }
     }
 
-    private List<Chapter> parseChapters(MultipartFile file) throws IOException {
-        List<Chapter> chapters = new ArrayList<>();
+    private List<NovelChapter> parseChapters(MultipartFile file) throws IOException {
+        List<NovelChapter> chapters = new ArrayList<>();
         try (BufferedReader reader = new BufferedReader(new InputStreamReader(file.getInputStream()))) {
             StringBuilder content = new StringBuilder();
             String line;
                         line.matches("第\\d+章\\s+.+"));
     }
 
-    private Chapter createChapter(String title, String content) {
-        Chapter chapter = new Chapter();
+    private NovelChapter createChapter(String title, String content) {
+        NovelChapter chapter = new NovelChapter();
         chapter.setTitle(title);
         chapter.setContent(content);
         return chapter;
     }
     @Override
     @Transactional
-    public Chapter processChapterUpload(MultipartFile file, Long novelId, Integer chapterOrder) {
+    public NovelChapter processChapterUpload(MultipartFile file, Long novelId, Integer chapterOrder) {
         try {
             // 验证小说存在
             Novel novel = novelMapper.selectNovelById(novelId);
             String content = new String(file.getBytes());
 
             // 创建章节
-            Chapter chapter = new Chapter();
+            NovelChapter chapter = new NovelChapter();
             chapter.setNovelId(novelId);
             chapter.setTitle("第" + chapterOrder + "章");
             chapter.setContent(content);
     }
 
     @Override
-    public List<Chapter> getChaptersByNovelId(Long novelId) {
-        Chapter chapter = new Chapter();
+    public List<NovelChapter> getChaptersByNovelId(Long novelId) {
+        NovelChapter chapter = new NovelChapter();
         chapter.setNovelId(novelId);
         return chapterMapper.selectChapterList(chapter);
     }
 
+//    @Override
+//    public Chapter getChapterContent(Long chapterId) {
+//        Chapter chapter = chapterMapper.selectChapterById(chapterId);
+//        if (chapter != null && chapter.getContent() != null) {
+//            // 解码Base64内容
+//            String decodedContent = Base64Utils.decode(chapter.getContent());
+//            chapter.setContent(decodedContent);
+//        }
+//        return chapter;
+//        //return chapterMapper.selectChapterById(chapterId);
+//    }
     @Override
-    public Chapter getChapterContent(Long chapterId) {
-        Chapter chapter = chapterMapper.selectChapterById(chapterId);
+    public NovelChapter getChapterContent(Long chapterId) {
+        NovelChapter chapter = chapterMapper.selectChapterById(chapterId);
         if (chapter != null && chapter.getContent() != null) {
-            // 解码Base64内容
-            String decodedContent = Base64Utils.decode(chapter.getContent());
-            chapter.setContent(decodedContent);
+            try {
+                // 解码Base64内容
+                String decodedContent = Base64Utils.decode(chapter.getContent());
+                chapter.setContent(decodedContent);
+            } catch (Exception e) {
+                logger.error("Base64解码失败，章节ID: " + chapterId, e);
+                // 如果解码失败，保持原内容不变
+            }
         }
         return chapter;
-        //return chapterMapper.selectChapterById(chapterId);
     }
-
     @Override
     @Transactional
     public void submitAuthorApplication(AuthorApplicationDTO dto, Long userId) {

RuoYi-Vue/ruoyi-system/src/main/resources/mapper/novel/ChapterMapper.xml → RuoYi-Vue/ruoyi-system/src/main/resources/mapper/novel/NovelCategoryMapper.xml

 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
-<mapper namespace="com.ruoyi.novel.mapper.CategoryMapper">
+<mapper namespace="com.ruoyi.novel.mapper.NovelCategoryMapper">
 
     <resultMap id="NovelCategoryResult" type="NovelCategory">
         <id property="id" column="id" />
         ORDER BY sort ASC
     </select>
 
-    <select id="selectById" parameterType="String" resultMap="NovelCategoryResult">
+    <select id="selectById" resultMap="NovelCategoryResult">
         SELECT id, title, pid, sort
         FROM novel_category
         WHERE id = #{categoryId}
     </select>
-    <select id="selectChapterCountByNovelId" parameterType="Long" resultType="int">
-        SELECT COUNT(*) FROM novel_chapter WHERE novel_id = #{novelId}
-    </select>
 </mapper>

RuoYi-Vue/ruoyi-system/src/main/resources/mapper/novel/NovelChapterMapper.xml

 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
-<mapper namespace="com.ruoyi.novel.mapper.NovelCategoryMapper">
+<mapper namespace="com.ruoyi.novel.mapper.NovelChapterMapper">
 
-    <resultMap id="NovelCategoryResult" type="NovelCategory">
+    <resultMap id="NovelChapterResult" type="NovelChapter">
         <id property="id" column="id" />
-        <result property="title" column="title" />
-        <result property="pid" column="pid" />
-        <result property="sort" column="sort" />
-        <!-- 其他字段映射 -->
+        <result property="novelId" column="novel_id" />
+        <result property="chapterTitle" column="chapter_title" />
+        <result property="chapterOrder" column="chapter_order" />
+        <result property="publishTime" column="publish_time" />
+        <result property="isVip" column="is_vip" />
+        <result property="createTime" column="create_time" />
+        <result property="updateTime" column="update_time" />
+        <result property="content" column="content" />
+        <result property="novelType" column="novel_type" />
+        <result property="updated" column="updated" />
+        <result property="reurl" column="reurl" />
     </resultMap>
 
-    <select id="selectCategoryList" resultMap="NovelCategoryResult">
-        SELECT id, title, pid, sort
-        FROM novel_category
-        WHERE status = 1
-        ORDER BY sort ASC
+    <sql id="selectChapterVo">
+        select id, novel_id, chapter_title, chapter_order, publish_time, is_vip, create_time, update_time, content, novel_type, updated, reurl
+        from novel_chapter
+    </sql>
+
+    <!-- 根据ID查询章节 -->
+    <select id="selectChapterById" parameterType="Long" resultMap="NovelChapterResult">
+        <include refid="selectChapterVo"/>
+        where id = #{id}
+    </select>
+
+    <!-- 插入章节 -->
+    <insert id="insertChapter" parameterType="NovelChapter" useGeneratedKeys="true" keyProperty="id">
+        insert into novel_chapter (
+            novel_id,
+            chapter_title,
+            chapter_order,
+            publish_time,
+            is_vip,
+            create_time,
+            update_time,
+            content,
+            novel_type,
+            updated,
+            reurl
+        ) values (
+                     #{novelId},
+                     #{chapterTitle},
+                     #{chapterOrder},
+                     #{publishTime},
+                     #{isVip},
+                     #{createTime},
+                     #{updateTime},
+                     #{content},
+                     #{novelType},
+                     #{updated},
+                     #{reurl}
+                 )
+    </insert>
+
+    <!-- 查询章节列表 -->
+    <select id="selectChapterList" parameterType="NovelChapter" resultMap="NovelChapterResult">
+        <include refid="selectChapterVo"/>
+        <where>
+            <if test="novelId != null"> and novel_id = #{novelId}</if>
+            <if test="chapterTitle != null and chapterTitle != ''"> and chapter_title like concat('%', #{chapterTitle}, '%')</if>
+            <if test="chapterOrder != null"> and chapter_order = #{chapterOrder}</if>
+            <if test="isVip != null"> and is_vip = #{isVip}</if>
+        </where>
+        order by chapter_order asc
     </select>
 
-    <select id="selectById" resultMap="NovelCategoryResult">
-        SELECT id, title, pid, sort
-        FROM novel_category
-        WHERE id = #{categoryId}
+    <!-- 查询小说的最大章节序号 -->
+    <select id="selectMaxChapterOrder" parameterType="Long" resultType="Integer">
+        select max(chapter_order) from novel_chapter where novel_id = #{novelId}
     </select>
+
+    <!-- 查询小说的章节数量 -->
+    <select id="selectChapterCountByNovelId" parameterType="Long" resultType="int">
+        select count(*) from novel_chapter where novel_id = #{novelId}
+    </select>
+
 </mapper>