feat: add reusable tabs component with swipe

.github/ISSUE_TEMPLATE/新功能建议.md

@@ -1,20 +0,0 @@
----
-name: 新功能建议
-about: 请为该项目提出一个想法
-title: ''
-labels: ''
-assignees: ''
-
----
-
-**你的功能请求是否与某个问题相关？请描述。**
-请清晰、简洁地说明问题。例如：“我经常因为……而感到困扰。”
-
-**你期望的解决方案**
-请清晰、简洁地描述你希望发生的事情/功能如何工作。
-
-**你考虑过的替代方案**
-请清晰、简洁地说明你已考虑过的其他解决方案或功能。
-
-**其他上下文**
-在此添加与功能请求相关的其他信息或截图。

.github/ISSUE_TEMPLATE/错误-bug报告.md

@@ -1,41 +0,0 @@
----
-name: 错误/Bug报告
-about: 创建报告以帮助我们改进
-title: ''
-labels: ''
-assignees: ''
-
----
-
-**描述 Bug**
-对该 Bug 进行清晰简明的描述。
-
-**复现步骤**
-复现该问题的步骤：
-
-1. 进入 '...'
-2. 点击 '...'
-3. 下拉到 '...'
-4. 看到错误
-
-**预期行为**
-清晰简明地描述你期望发生的情况。
-
-**截图**
-如果适用，请添加截图以帮助解释问题。
-
-**桌面端（请完成以下信息）：**
-
-* 操作系统：\[例如 iOS]
-* 浏览器：\[例如 Chrome、Safari]
-* 版本：\[例如 22]
-
-**移动端（请完成以下信息）：**
-
-* 设备：\[例如 iPhone6]
-* 操作系统：\[例如 iOS8.1]
-* 浏览器：\[例如 系统自带浏览器、Safari]
-* 版本：\[例如 22]
-
-**附加上下文**
-在此添加与问题相关的其他上下文信息。

.gitignore

@@ -1,30 +1,7 @@
-# IDE
 .idea
 target
-
-# log
-logs
-
-# deps
-node_modules
-
-# test & build
-coverage
-out/
-build
-dist
-*.tsbuildinfo
-
-# misc
-.DS_Store
-*.pem
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-
-# env
-*.env
-.env*.local
-
-# others
 openisle.iml
+node_modules
+dist
+open-isle.env
+logs

CODE_OF_CONDUCT.md

@@ -1,32 +0,0 @@
-# OpenIsle Code of Conduct
-
-Like the technical community as a whole, the OpenIsle team and community is made up of a mixture of professionals and volunteers from all over the world, working on every aspect of the mission - including mentorship, teaching, and connecting people.
-
-Diversity is one of our huge strengths, but it can also lead to communication issues and unhappiness. To that end, we have a few ground rules that we ask people to adhere to. This code applies equally to founders, mentors and those seeking help and guidance.
-
-This isn’t an exhaustive list of things that you can’t do. Rather, take it in the spirit in which it’s intended - a guide to make it easier to enrich all of us and the technical communities in which we participate.
-
-This code of conduct applies to all spaces managed by the OpenIsle project or . This includes IRC, the mailing lists, the issue tracker, DSF events, and any other forums created by the project team which the community uses for communication. In addition, violations of this code outside these spaces may affect a person's ability to participate within them.
-
-If you believe someone is violating the code of conduct, we ask that you report it by emailing [](mailto:). For more details please see our 
-
-- **Be friendly and patient.**
-- **Be welcoming.** We strive to be a community that welcomes and supports people of all backgrounds and identities. This includes, but is not limited to members of any race, ethnicity, culture, national origin, colour, immigration status, social and economic class, educational level, sex, sexual orientation, gender identity and expression, age, size, family status, political belief, religion, and mental and physical ability.
-- **Be considerate.** Your work will be used by other people, and you in turn will depend on the work of others. Any decision you take will affect users and colleagues, and you should take those consequences into account when making decisions. Remember that we're a world-wide community, so you might not be communicating in someone else's primary language.
-- **Be respectful.** Not all of us will agree all the time, but disagreement is no excuse for poor behavior and poor manners. We might all experience some frustration now and then, but we cannot allow that frustration to turn into a personal attack. It’s important to remember that a community where people feel uncomfortable or threatened is not a productive one. Members of the OpenIsle community should be respectful when dealing with other members as well as with people outside the OpenIsle community.
-- **Be careful in the words that you choose.** We are a community of professionals, and we conduct ourselves professionally. Be kind to others. Do not insult or put down other participants. Harassment and other exclusionary behavior aren't acceptable. This includes, but is not limited to: 
- - Violent threats or language directed against another person.
- - Discriminatory jokes and language.
- - Posting sexually explicit or violent material.
- - Posting (or threatening to post) other people's personally identifying information ("doxing").
- - Personal insults, especially those using racist or sexist terms.
- - Unwelcome sexual attention.
- - Advocating for, or encouraging, any of the above behavior.
- - Repeated harassment of others. In general, if someone asks you to stop, then stop.
-- **When we disagree, try to understand why.** Disagreements, both social and technical, happen all the time and OpenIsle is no exception. It is important that we resolve disagreements and differing views constructively. Remember that we’re different. The strength of OpenIsle comes from its varied community, people from a wide range of backgrounds. Different people have different perspectives on issues. Being unable to understand why someone holds a viewpoint doesn’t mean that they’re wrong. Don’t forget that it is human to err and blaming each other doesn’t get us anywhere. Instead, focus on helping to resolve issues and learning from mistakes.
-
-Original text courtesy of the [Speak Up! project](http://web.archive.org/web/20141109123859/http://speakup.io/coc.html).
-
-## Questions?
-
-If you have questions, please see . If that doesn't answer your questions, feel free to [contact us](mailto:).

CONTRIBUTING.md

@@ -1,185 +1,109 @@
-- [前置工作](#前置工作)
-- [启动后端服务](#启动后端服务)
-    - [本地 IDEA](#本地-idea)
-        - [配置环境变量](#配置环境变量)
-        - [配置 IDEA 参数](#配置-idea-参数)
-        - [配置 MySQL](#配置-mysql)
-    - [Docker 环境](#docker-环境)
-        - [配置环境变量](#配置环境变量-1)
-        - [构建并启动镜像](#构建并启动镜像)
-- [启动前端服务](#启动前端服务)
-    - [配置环境变量](#配置环境变量-2)
-    - [安装依赖和运行](#安装依赖和运行)
-- [其他配置](#其他配置)
+#### **⚠️注意：仅想修改前端的朋友可不用部署后端服务**
 
-## 前置工作
+## 如何部署
 
-先克隆仓库：
+> Step1 先克隆仓库
 
 ```shell
 git clone https://github.com/nagisa77/OpenIsle.git
 cd OpenIsle
 ```
 
-- 后端开发环境
-    - JDK 17+
-- 前端开发环境
-    - Node.JS 20+
-
-## 启动后端服务
-
-启动后端服务有多种方式，选择一种即可。
-
-> [!IMPORTANT]
-> 仅想修改前端的朋友可不用部署后端服务。转到 [启动前端服务](#启动前端服务) 章节。
-
-### 本地 IDEA
+> Step2 后端部署
 
 ```shell
-cd backend/
+cd backend
 ```
 
-IDEA 打开 `backend/` 文件夹。
+以IDEA编辑器为例，IDEA打开backend文件夹。
 
-#### 配置环境变量
-
-1. 生成环境变量文件
-
-    ```shell
-    cp open-isle.env.example open-isle.env
-    ```
-
-    `open-isle.env.example` 是环境变量模板，`open-isle.env` 才是真正读取的内容
-
-2. 修改环境变量，留下需要的，比如你要开发 Google 登录业务，就需要谷歌相关的变量，数据库是一定要的
-
-    ![环境变量](assets/contributing/backend_img_7.png)
-
-3. 应用环境文件，选择刚刚的 `open-isle.env`
-
-可以在 `open-isle.env` 按需填写个性化的配置，该文件不会被 Git 追踪。比如你想把服务跑在 `8082`（默认为 `8080`），那么直接改 `open-isle.env` 即可：
-
-```ini
-SERVER_PORT=8082
-```
-
-另一种方式是修改 `.properities` 文件（但不建议），位于 `src/main/application.properties`，该配置同样来源于 `open-isle.env`，但修改 `.properties` 文件会被 Git 追踪。
-
-![配置数据库](assets/contributing/backend_img_5.png)
-
-#### 配置 IDEA 参数
-
-- 设置 JDK 版本为 java 17
-- 设置 VM Option，最好运行在其他端口，非 `8080`，这里设置 `8081`
-
-    ```shell
-    -Dserver.port=8081
-    ```
-
-![配置1](assets/contributing/backend_img_3.png)
-
-![配置2](assets/contributing/backend_img_2.png)
-
-#### 配置 MySQL
-
-> [!TIP]
-> 如果不知道怎么配置数据库可以参考 [Docker 环境](#docker-环境) 章节
-
-1. 本机配置 MySQL 服务（网上很多教程，忽略）
-
-    + 可以用 Laragon，自带 MySQL 包括 Nodejs，版本建议 `6.x`，`7` 以后需要 Lisence
-    + [下载地址](https://github.com/leokhoa/laragon/releases)
-
-2. 填写环境变量
-
-    ![环境变量](assets/contributing/backend_img_6.png)
-
-    ```ini
-    MYSQL_URL=jdbc:mysql://<数据库地址>:<端口>/<数据库名>?useUnicode=yes&characterEncoding=UTF-8&useInformationSchema=true&useSSL=false&serverTimezone=UTC
-    MYSQL_USER=<数据库用户名>
-    MYSQL_PASSWORD=<数据库密码>
-    ```
-
-3. 执行 [`db/init/init_script.sql`](backend/src/main/resources/db/init/init_script.sql) 脚本，导入基本的数据
-
-    ![初始化脚本](assets/contributing/resources_img.png)
-
-4. 处理完环境问题直接跑起来就能通了
-
-    ![运行画面](assets/contributing/backend_img_4.png)
-
-### Docker 环境
-#### 配置环境变量
+- 设置VM Option，最好运行在其他端口，非8080，这里设置8081
 
 ```shell
-cd docker/
+-Dserver.port=8081
 ```
 
-主要配置两个 `.env` 文件
+![CleanShot 2025-08-04 at 11 .35.49.png](https://openisle-1307107697.cos.accelerate.myqcloud.com/dynamic_assert/4cf210cfc6ea478a80dfc744c85ccdc4.png)
 
-- `backend/open-isle.env`：后端环境变量，配置同上，见 [配置环境变量](#配置环境变量)。
-- `docker/.env`：Docker Compose 环境变量，主要配置 MySQL 相关
-    ```shell
-    cp .env.example .env
-    ```
+- 设置jdk版本为java 17
 
-> [!TIP]
-> 使用单独的 `.env` 文件是为了兼容线上环境或已启用 MySQL 服务的情况，如果只是想快速体验或者启动统一的环境，则推荐使用本方式。
+![CleanShot 2025-08-04 at 11 .38.03@2x.png](https://openisle-1307107697.cos.accelerate.myqcloud.com/dynamic_assert/392eeec753ae436ca12a78f750dfea2d.png)
 
-在指定 `docker/.env` 后，`backend/open-isle.env` 中以下配置会被覆盖，这样就确保使用了同一份配置。
+- 本机配置MySQL服务（网上很多教程，忽略）
+- 设置环境变量.env 文件 或.properties 文件（二选一）
 
-```ini
-MYSQL_URL=
-MYSQL_USER=
-MYSQL_PASSWORD=
-```
-
-#### 构建并启动镜像
+1. 环境变量文件生成
 
 ```shell
-docker compose up -d
+cp open-isle.env.example open-isle.env
 ```
 
-如果想了解启动过程发生了什么可以查看日志
+修改环境变量，留下需要的，比如你要开发Google登录业务，就需要谷歌相关的变量，数据库是一定要的
+
+![CleanShot 2025-08-04 at 11 .41.36@2x.png](https://openisle-1307107697.cos.accelerate.myqcloud.com/dynamic_assert/896c8363b6e64ea19d18c12ec4dae2b4.png)
+
+应用环境文件， 选择刚刚的`open-isle.env`
+
+![CleanShot 2025-08-04 at 11 .44.41.png](https://openisle-1307107697.cos.accelerate.myqcloud.com/dynamic_assert/f588e37838014a6684c141605639b9fa.png)
+
+2. 直接修改 .properities 文件
+
+位置src/main/application.properties, 数据库需要修改标红处，其他按需修改
+
+![CleanShot 2025-08-04 at 11 .47.11@2x.png](https://openisle-1307107697.cos.accelerate.myqcloud.com/dynamic_assert/28c3104448a245419e0b06aee861abb4.png)
+
+处理完环境问题直接跑起来就能通了
+
+![CleanShot 2025-08-04 at 11 .49.01@2x.png](https://openisle-1307107697.cos.accelerate.myqcloud.com/dynamic_assert/2c945eae44b1477db09e80fc96b5e02d.png)
+
+> Step3 前端部署
+
+前端可以依赖本机部署的后端，也可以直接调用线上的后端接口
 
 ```shell
-docker compose logs
+cd ../frontend_nuxt/
 ```
 
-## 启动前端服务
-
-> [!IMPORTANT]
-> **⚠️ 环境要求：Node.js 版本最低 20.0.0（因为 Nuxt 框架要求）**
+copy环境.env文件
 
 ```shell
-cd frontend_nuxt/
+cp .env.staging.example .env
 ```
 
-### 配置环境变量
+1. 依赖本机部署的后端：打开本文件夹，修改.env 修改为瞄准本机后端端口
 
-前端可以依赖本机部署的后端，也可以直接调用线上的后端接口。
+```yaml
+; 本地部署后端
+NUXT_PUBLIC_API_BASE_URL=https://127.0.0.1:8081
+; 预发环境后端
+; NUXT_PUBLIC_API_BASE_URL=https://staging.open-isle.com
+; 生产环境后端
+; NUXT_PUBLIC_API_BASE_URL=https://www.open-isle.com
+```
 
-- 利用预发环境：**（⚠️ 强烈推荐只开发前端的朋友使用该环境）**
+2. 依赖预发环境后台环境
 
-    ```shell
-    cp .env.staging.example .env
-    ```
+**(⚠️强烈推荐只部署前端的朋友使用该环境)**
 
-- 利用生产环境
+```yaml
+; 本地部署后端
+; NUXT_PUBLIC_API_BASE_URL=https://127.0.0.1:8081
+; 预发环境后端
+NUXT_PUBLIC_API_BASE_URL=https://staging.open-isle.com
+; 生产环境后端
+; NUXT_PUBLIC_API_BASE_URL=https://www.open-isle.com
+```
 
-    ```shell
-    cp .env.production.example .env
-    ```
+4. 依赖线上后台环境
 
-- 利用本地环境
-
-    ```shell
-    cp .env.dev.example .env
-    ```
-
-### 安装依赖和运行
-
-前端安装依赖并启动服务。
+```yaml
+; 本地部署后端
+; NUXT_PUBLIC_API_BASE_URL=https://127.0.0.1:8081
+; 预发环境后端
+; NUXT_PUBLIC_API_BASE_URL=https://staging.open-isle.com
+; 生产环境后端
+NUXT_PUBLIC_API_BASE_URL=https://www.open-isle.com
+```
 
 ```shell
 # 安装依赖
@@ -189,22 +113,4 @@ npm install --verbose
 npm run dev
 ```
 
-如此一来，浏览器访问 http://127.0.0.1:3000 即可访问前端页面。
-
-## 其他配置
-
-配置第三方登录，这里以 GitHub 为例：
-
-- 修改 `application.properties` 配置
-
-    ![后端配置](assets/contributing/backend_img.png)
-
-- 修改 `.env` 配置
-
-    ![前端](assets/contributing/fontend_img.png)
-
-- 配置第三方登录回调地址
-
-    ![github配置](assets/contributing/github_img.png)
-
-    ![github配置2](assets/contributing/github_img_2.png)
+如此一来，浏览器访问 http://127.0.0.1:3000 即可访问前端页面

LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Tim
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

backend/open-isle.env.example

@@ -1,8 +1,5 @@
-# === Spring Boot ===
-SERVER_PORT=8080
-
 # === Database ===
-MYSQL_URL=jdbc:mysql://<数据库地址>:<数据库端口>/<数据库名>?useUnicode=yes&characterEncoding=UTF-8&useInformationSchema=true&useSSL=false&serverTimezone=UTC
+MYSQL_URL=jdbc:mysql://<数据库地址>:<端口>/<数据库名>?useUnicode=yes&characterEncoding=UTF-8&useInformationSchema=true&useSSL=false&serverTimezone=UTC
 MYSQL_USER=<数据库用户名>
 MYSQL_PASSWORD=<数据库密码>
 
@@ -31,7 +28,6 @@ TWITTER_CLIENT_ID=<你的twitter-client-id>
 TWITTER_CLIENT_SECRET=<你的-twitter-client-secret>
 DISCORD_CLIENT_ID=<你的discord-client-id>
 DISCORD_CLIENT_SECRET=<你的discord-client-secret>
-TELEGRAM_BOT_TOKEN=<你的telegram-bot-token>
 
 # === OPENAI ===
 OPENAI_API_KEY=<你的openai-api-key>
@@ -40,10 +36,4 @@ OPENAI_API_KEY=<你的openai-api-key>
 WEBPUSH_PUBLIC_KEY=<你的webpush-public-key>
 WEBPUSH_PRIVATE_KEY=<你的webpush-private-key>
 
-# === RabbitMQ ===
-RABBITMQ_HOST=<你的rabbitmq_host>
-RABBITMQ_PORT=<你的rabbitmq_port>
-RABBITMQ_USERNAME=<你的rabbitmq_username>
-RABBITMQ_PASSWORD=<你的rabbitmq_password>
-
 # LOG_LEVEL=DEBUG

backend/pom.xml

@@ -26,22 +26,9 @@
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-web</artifactId>
     </dependency>
-    <dependency>
-        <groupId>org.springframework.boot</groupId>
-        <artifactId>spring-boot-starter-amqp</artifactId>
-    </dependency>
     <dependency>
       <groupId>org.springframework.boot</groupId>
-      <artifactId>spring-boot-starter-data-redis</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>com.fasterxml.jackson.datatype</groupId>
-      <artifactId>jackson-datatype-jsr310</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>com.fasterxml.jackson.datatype</groupId>
-      <artifactId>jackson-datatype-hibernate6</artifactId>
-      <version>2.20.0</version>
+      <artifactId>spring-boot-starter-websocket</artifactId>
     </dependency>
     <dependency>
       <groupId>org.slf4j</groupId>
@@ -127,11 +114,6 @@
       <artifactId>bcprov-jdk15on</artifactId>
       <version>1.70</version>
     </dependency>
-    <dependency>
-      <groupId>org.springdoc</groupId>
-      <artifactId>springdoc-openapi-starter-webmvc-api</artifactId>
-      <version>2.2.0</version>
-    </dependency>
   </dependencies>
 
   <build>
@@ -159,26 +141,6 @@
           </annotationProcessorPaths>
         </configuration>
       </plugin>
-
-      <plugin>
-        <!-- https://github.com/OpenAPITools/openapi-generator/blob/master/modules/openapi-generator-maven-plugin/README.md -->
-        <groupId>org.springdoc</groupId>
-        <artifactId>springdoc-openapi-maven-plugin</artifactId>
-        <version>1.4</version>
-        <executions>
-          <execution>
-            <goals>
-              <goal>generate</goal>
-            </goals>
-          </execution>
-        </executions>
-        <configuration>
-          <!-- 此处为硬编码，应优化为 env 的配置 -->
-          <apiDocsUrl>http://localhost:8080/api/v3/api-docs</apiDocsUrl>
-          <outputFileName>openapi.json</outputFileName>
-          <outputDir>${project.build.directory}</outputDir>
-        </configuration>
-      </plugin>
     </plugins>
   </build>
 </project>

backend/src/main/java/com/openisle/config/CachingConfig.java

@@ -1,109 +0,0 @@
-package com.openisle.config;
-
-import com.fasterxml.jackson.annotation.JsonAutoDetect;
-import com.fasterxml.jackson.annotation.JsonTypeInfo;
-import com.fasterxml.jackson.annotation.PropertyAccessor;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
-import com.fasterxml.jackson.datatype.hibernate6.Hibernate6Module;
-import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
-import org.springframework.cache.CacheManager;
-import org.springframework.cache.annotation.EnableCaching;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.context.annotation.Primary;
-import org.springframework.data.redis.cache.RedisCacheConfiguration;
-import org.springframework.data.redis.cache.RedisCacheManager;
-import org.springframework.data.redis.connection.RedisConnectionFactory;
-import org.springframework.data.redis.core.RedisTemplate;
-import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
-import org.springframework.data.redis.serializer.RedisSerializationContext;
-import org.springframework.data.redis.serializer.RedisSerializer;
-import org.springframework.data.redis.serializer.StringRedisSerializer;
-
-import java.time.Duration;
-
-/**
- * Redis 缓存配置类
- * @author smallclover
- * @since 2025-09-04
- */
-@Configuration
-@EnableCaching
-public class CachingConfig {
-
-    // 标签缓存名
-    public static final String TAG_CACHE_NAME="openisle_tags";
-    // 分类缓存名
-    public static final String CATEGORY_CACHE_NAME="openisle_categories";
-
-    /**
-     * 自定义Redis的序列化器
-     * @return
-     */
-    @Bean()
-    @Primary
-    public RedisSerializer<Object> redisSerializer() {
-        // 注册 JavaTimeModule 來支持 Java 8 的日期和时间 API,否则回报一下错误，同时还要引入jsr310
-
-        // org.springframework.data.redis.serializer.SerializationException: Could not write JSON: Java 8 date/time type `java.time.LocalDateTime` not supported by default:
-        // add Module "com.fasterxml.jackson.datatype:jackson-datatype-jsr310" to enable handling
-        // (through reference chain: java.util.ArrayList[0]->com.openisle.dto.TagDto["createdAt"])
-        // 设置可见性，允许序列化所有元素
-        ObjectMapper objectMapper = new ObjectMapper();
-        objectMapper.registerModule(new JavaTimeModule());
-        // Hibernate6Module 可以自动处理懒加载代理对象。
-        // Tag对象的creator是FetchType.LAZY
-        objectMapper.registerModule(new Hibernate6Module()
-                .disable(Hibernate6Module.Feature.USE_TRANSIENT_ANNOTATION));
-        // service的时候带上类型信息
-        // 启用类型信息，避免 LinkedHashMap 问题
-        objectMapper.activateDefaultTyping(
-                LaissezFaireSubTypeValidator.instance,
-                ObjectMapper.DefaultTyping.NON_FINAL,
-                JsonTypeInfo.As.PROPERTY
-        );
-        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
-        return new GenericJackson2JsonRedisSerializer(objectMapper);
-    }
-
-    /**
-     * 配置 Spring Cache 使用 RedisCacheManager
-     */
-    @Bean
-    public CacheManager cacheManager(RedisConnectionFactory connectionFactory, RedisSerializer<Object> redisSerializer) {
-
-        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
-                .entryTtl(Duration.ZERO) // 默认缓存不过期
-                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
-                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
-                .disableCachingNullValues(); // 禁止缓存 null 值
-//        个别缓存单独设置TTL时间
-//        Map<String, RedisCacheConfiguration> cacheConfigs = new HashMap<>();
-//        cacheConfigs.put("openisle_tags", RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ZERO));
-//        cacheConfigs.put("openisle_categories", RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ZERO));
-
-        return RedisCacheManager.builder(connectionFactory)
-                .cacheDefaults(config)
-                .build();
-    }
-
-    /**
-     * 配置 RedisTemplate，支持直接操作 Redis
-     */
-    @Bean
-    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory,  RedisSerializer<Object> redisSerializer) {
-        RedisTemplate<String, Object> template = new RedisTemplate<>();
-        template.setConnectionFactory(connectionFactory);
-
-        // key 和 hashKey 使用 String 序列化
-        template.setKeySerializer(new StringRedisSerializer());
-        template.setHashKeySerializer(new StringRedisSerializer());
-
-        // value 和 hashValue 使用 JSON 序列化
-        template.setValueSerializer(redisSerializer);
-        template.setHashValueSerializer(redisSerializer);
-
-        return template;
-    }
-}

backend/src/main/java/com/openisle/config/OpenApiConfig.java

@@ -1,48 +0,0 @@
-package com.openisle.config;
-
-import io.swagger.v3.oas.models.Components;
-import io.swagger.v3.oas.models.OpenAPI;
-import io.swagger.v3.oas.models.info.Info;
-import io.swagger.v3.oas.models.security.SecurityRequirement;
-import io.swagger.v3.oas.models.security.SecurityScheme;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-
-@Configuration
-public class OpenApiConfig {
-
-    @Value("${springdoc.info.title}")
-    private String title;
-
-    @Value("${springdoc.info.description}")
-    private String description;
-
-    @Value("${springdoc.info.version}")
-    private String version;
-
-    @Value("${springdoc.info.scheme}")
-    private String scheme;
-
-    @Value("${springdoc.info.header}")
-    private String header;
-
-    @Bean
-    public OpenAPI openAPI() {
-        SecurityScheme securityScheme = new SecurityScheme()
-			.type(SecurityScheme.Type.HTTP)
-			.scheme(scheme.toLowerCase())
-			.bearerFormat("JWT")
-			.in(SecurityScheme.In.HEADER)
-			.name(header);
-
-        return new OpenAPI()
-                .info(new Info()
-					.title(title)
-					.description(description)
-					.version(version))
-                .components(new Components()
-					.addSecuritySchemes("JWT", securityScheme))
-                .addSecurityItem(new SecurityRequirement().addList("JWT"));
-    }
-}

backend/src/main/java/com/openisle/config/RabbitMQConfig.java

@@ -1,204 +0,0 @@
-package com.openisle.config;
-
-import lombok.RequiredArgsConstructor;
-import org.springframework.amqp.core.Binding;
-import org.springframework.amqp.core.BindingBuilder;
-import org.springframework.amqp.core.Queue;
-import org.springframework.amqp.core.TopicExchange;
-import org.springframework.amqp.rabbit.connection.ConnectionFactory;
-import org.springframework.amqp.rabbit.core.RabbitTemplate;
-import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
-import org.springframework.beans.factory.annotation.Qualifier;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import org.springframework.amqp.rabbit.core.RabbitAdmin;
-import org.springframework.boot.CommandLineRunner;
-import org.springframework.context.annotation.DependsOn;
-
-import jakarta.annotation.PostConstruct;
-import java.util.ArrayList;
-import java.util.List;
-
-@Configuration
-@RequiredArgsConstructor
-public class RabbitMQConfig {
-
-    public static final String EXCHANGE_NAME = "openisle-exchange";
-    // 保持向后兼容的常量
-    public static final String QUEUE_NAME = "notifications-queue";
-    public static final String ROUTING_KEY = "notifications.routingkey";
-    
-    // 硬编码为16以匹配ShardingStrategy中的十六进制分片逻辑
-    private final int queueCount = 16;
-    
-    @Value("${rabbitmq.queue.durable}")
-    private boolean queueDurable;
-
-    @PostConstruct
-    public void init() {
-        System.out.println("RabbitMQ配置初始化: 队列数量=" + queueCount + ", 持久化=" + queueDurable);
-    }
-
-    @Bean
-    public TopicExchange exchange() {
-        return new TopicExchange(EXCHANGE_NAME);
-    }
-
-    /**
-     * 创建所有分片队列, 使用十六进制后缀 (0-f)
-     */
-    @Bean
-    public List<Queue> shardedQueues() {
-        System.out.println("开始创建分片队列 Bean...");
-        
-        List<Queue> queues = new ArrayList<>();
-        for (int i = 0; i < queueCount; i++) {
-            String shardKey = Integer.toHexString(i);
-            String queueName = "notifications-queue-" + shardKey;
-            Queue queue = new Queue(queueName, queueDurable);
-            queues.add(queue);
-        }
-        
-        System.out.println("分片队列 Bean 创建完成，总数: " + queues.size());
-        return queues;
-    }
-
-    /**
-     * 创建所有分片绑定, 使用十六进制路由键 (notifications.shard.0 - notifications.shard.f)
-     */
-    @Bean
-    public List<Binding> shardedBindings(TopicExchange exchange, @Qualifier("shardedQueues") List<Queue> shardedQueues) {
-        System.out.println("开始创建分片绑定 Bean...");
-        List<Binding> bindings = new ArrayList<>();
-        if (shardedQueues != null) {
-            for (Queue queue : shardedQueues) {
-                String queueName = queue.getName();
-                String shardKey = queueName.substring("notifications-queue-".length());
-                String routingKey = "notifications.shard." + shardKey;
-                Binding binding = BindingBuilder.bind(queue).to(exchange).with(routingKey);
-                bindings.add(binding);
-            }
-        }
-        
-        System.out.println("分片绑定 Bean 创建完成，总数: " + bindings.size());
-        return bindings;
-    }
-
-    /**
-     * 保持向后兼容的单队列配置（可选）
-     */
-    @Bean
-    public Queue legacyQueue() {
-        return new Queue(QUEUE_NAME, queueDurable);
-    }
-
-    /**
-     * 保持向后兼容的单队列绑定（可选）
-     */
-    @Bean
-    public Binding legacyBinding(Queue legacyQueue, TopicExchange exchange) {
-        return BindingBuilder.bind(legacyQueue).to(exchange).with(ROUTING_KEY);
-    }
-
-    @Bean
-    public Jackson2JsonMessageConverter messageConverter() {
-        ObjectMapper objectMapper = new ObjectMapper();
-        objectMapper.registerModule(new com.fasterxml.jackson.datatype.jsr310.JavaTimeModule());
-        objectMapper.disable(com.fasterxml.jackson.databind.SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
-        return new Jackson2JsonMessageConverter(objectMapper);
-    }
-
-    @Bean
-    public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory) {
-        return new RabbitAdmin(connectionFactory);
-    }
-
-    @Bean
-    public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
-        RabbitTemplate template = new RabbitTemplate(connectionFactory);
-        template.setMessageConverter(messageConverter());
-        return template;
-    }
-
-    /**
-     * 使用 CommandLineRunner 确保在应用完全启动后声明队列到 RabbitMQ
-     * 这样可以确保 RabbitAdmin 和所有 Bean 都已正确初始化
-     */
-    @Bean
-    @DependsOn({"rabbitAdmin", "shardedQueues", "exchange"})
-    public CommandLineRunner queueDeclarationRunner(RabbitAdmin rabbitAdmin,
-                                                   @Qualifier("shardedQueues") List<Queue> shardedQueues,
-                                                   TopicExchange exchange,
-                                                   Queue legacyQueue,
-                                                   @Qualifier("shardedBindings") List<Binding> shardedBindings,
-                                                   Binding legacyBinding) {
-        return args -> {
-            System.out.println("=== 开始主动声明 RabbitMQ 组件 ===");
-            
-            try {
-                // 声明交换
-                rabbitAdmin.declareExchange(exchange);
-                
-                // 声明分片队列 - 检查存在性
-                System.out.println("开始检查并声明 " + shardedQueues.size() + " 个分片队列...");
-                int successCount = 0;
-                int skippedCount = 0;
-                
-                for (Queue queue : shardedQueues) {
-                    String queueName = queue.getName();
-                    try {
-                        // 使用 declareQueue 的返回值判断队列是否已存在
-                        // 如果队列已存在且配置匹配，declareQueue 会返回现有队列信息
-                        // 如果不匹配或不存在，会创建新队列
-                        rabbitAdmin.declareQueue(queue);
-                        successCount++;
-                    } catch (org.springframework.amqp.AmqpIOException e) {
-                        if (e.getMessage().contains("PRECONDITION_FAILED") && e.getMessage().contains("durable")) {
-                            skippedCount++;
-                        }
-                    } catch (Exception e) {
-                        System.err.println("队列声明失败: " + queueName + ", 错误: " + e.getMessage());
-                    }
-                }
-                System.out.println("分片队列处理完成: 成功 " + successCount + ", 跳过 " + skippedCount + ", 总数 " + shardedQueues.size());
-                
-                // 声明分片绑定
-                System.out.println("开始声明 " + shardedBindings.size() + " 个分片绑定...");
-                int bindingSuccessCount = 0;
-                for (Binding binding : shardedBindings) {
-                    try {
-                        rabbitAdmin.declareBinding(binding);
-                        bindingSuccessCount++;
-                    } catch (Exception e) {
-                        System.err.println("绑定声明失败: " + e.getMessage());
-                    }
-                }
-                System.out.println("分片绑定声明完成: 成功 " + bindingSuccessCount + "/" + shardedBindings.size());
-                
-                // 声明遗留队列和绑定 - 检查存在性
-                try {
-                    rabbitAdmin.declareQueue(legacyQueue);
-                    rabbitAdmin.declareBinding(legacyBinding);
-                    System.out.println("遗留队列和绑定就绪: " + QUEUE_NAME + " (已存在或新创建)");
-                } catch (org.springframework.amqp.AmqpIOException e) {
-                    if (e.getMessage().contains("PRECONDITION_FAILED") && e.getMessage().contains("durable")) {
-                        System.out.println("遗留队列已存在但 durable 设置不匹配: " + QUEUE_NAME + ", 保持现有队列");
-                    } else {
-                        System.err.println("遗留队列声明失败: " + QUEUE_NAME + ", 错误: " + e.getMessage());
-                    }
-                } catch (Exception e) {
-                    System.err.println("遗留队列声明失败: " + QUEUE_NAME + ", 错误: " + e.getMessage());
-                }
-                
-                System.out.println("=== RabbitMQ 组件声明完成 ===");
-                System.out.println("请检查 RabbitMQ 管理界面确认队列已正确创建");
-                
-            } catch (Exception e) {
-                System.err.println("RabbitMQ 组件声明过程中发生严重错误:");
-                e.printStackTrace();
-            }
-        };
-    }
-}

backend/src/main/java/com/openisle/config/RedisConnectionLogger.java

@@ -1,35 +0,0 @@
-package com.openisle.config;
-
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.factory.InitializingBean;
-import org.springframework.data.redis.connection.RedisConnectionFactory;
-import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
-import org.springframework.stereotype.Component;
-
-/**
- * Logs a message when a Redis connection is successfully established.
- */
-@Component
-@Slf4j
-public class RedisConnectionLogger implements InitializingBean {
-
-    private final RedisConnectionFactory connectionFactory;
-
-    public RedisConnectionLogger(RedisConnectionFactory connectionFactory) {
-        this.connectionFactory = connectionFactory;
-    }
-
-    @Override
-    public void afterPropertiesSet() {
-        try (var connection = connectionFactory.getConnection()) {
-            connection.ping();
-            if (connectionFactory instanceof LettuceConnectionFactory lettuce) {
-                log.info("Redis connection established at {}:{}", lettuce.getHostName(), lettuce.getPort());
-            } else {
-                log.info("Redis connection established");
-            }
-        } catch (Exception e) {
-            log.error("Failed to connect to Redis", e);
-        }
-    }
-}

backend/src/main/java/com/openisle/config/SecurityConfig.java

@@ -74,14 +74,10 @@ public class SecurityConfig {
         CorsConfiguration cfg = new CorsConfiguration();
         cfg.setAllowedOrigins(List.of(
                 "http://127.0.0.1:8080",
-                "http://127.0.0.1:8081",
-                "http://127.0.0.1:8082",
                 "http://127.0.0.1:3000",
                 "http://127.0.0.1:3001",
                 "http://127.0.0.1",
                 "http://localhost:8080",
-                "http://localhost:8081",
-                "http://localhost:8082",
                 "http://localhost:3000",
                 "http://localhost:3001",
                 "http://localhost",
@@ -89,7 +85,6 @@ public class SecurityConfig {
                 "http://30.211.97.238",
                 "http://192.168.7.98",
                 "http://192.168.7.98:3000",
-                "https://petstore.swagger.io",
                 websiteUrl,
                 websiteUrl.replace("://www.", "://")
         ));
@@ -111,7 +106,6 @@ public class SecurityConfig {
             .authorizeHttpRequests(auth -> auth
                     .requestMatchers(HttpMethod.OPTIONS, "/**").permitAll()
                     .requestMatchers("/api/ws/**", "/api/sockjs/**").permitAll()
-                    .requestMatchers("/api/v3/api-docs/**").permitAll()
                     .requestMatchers(HttpMethod.POST, "/api/auth/**").permitAll()
                     .requestMatchers(HttpMethod.GET, "/api/posts/**").permitAll()
                     .requestMatchers(HttpMethod.GET, "/api/comments/**").permitAll()
@@ -182,8 +176,7 @@ public class SecurityConfig {
                         return;
                     }
                 } else if (!uri.startsWith("/api/auth") && !publicGet
-                        && !uri.startsWith("/api/ws") && !uri.startsWith("/api/sockjs")
-                        && !uri.startsWith("/api/v3/api-docs")) {
+                        && !uri.startsWith("/api/ws") && !uri.startsWith("/api/sockjs")) {
                     response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                     response.setContentType("application/json");
                     response.getWriter().write("{\"error\": \"Missing token\"}");

backend/src/main/java/com/openisle/config/ShardInfo.java

@@ -1,14 +0,0 @@
-package com.openisle.config;
-
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-@Data
-@AllArgsConstructor
-@NoArgsConstructor
-public class ShardInfo {
-    private int shardIndex;
-    private String queueName;
-    private String routingKey;
-}

backend/src/main/java/com/openisle/config/ShardingStrategy.java

@@ -1,84 +0,0 @@
-package com.openisle.config;
-
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.stereotype.Component;
-
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.atomic.AtomicLong;
-import java.util.Map;
-import java.util.stream.Collectors;
-
-@Component
-@Slf4j
-public class ShardingStrategy {
-    
-    // 固定为16以匹配RabbitMQConfig中的十六进制分片逻辑
-    private static final int QUEUE_COUNT = 16;
-    
-    // 分片分布统计
-    private final Map<Integer, AtomicLong> shardCounts = new ConcurrentHashMap<>();
-    
-    /**
-     * 根据用户名获取分片信息（基于哈希值首字符）
-     */
-    public ShardInfo getShardInfo(String username) {
-        if (username == null || username.isEmpty()) {
-            // 空用户名默认分到第0个分片
-            return getShardInfoByIndex(0);
-        }
-        
-        // 计算用户名的哈希值并转为十六进制字符串
-        String hash = Integer.toHexString(Math.abs(username.hashCode()));
-        
-        // 取哈希值的第一个字符 (0-9, a-f)
-        char firstChar = hash.charAt(0);
-        
-        // 十六进制字符映射到队列
-        int shard = getShardFromHexChar(firstChar);
-        recordShardUsage(shard);
-        
-        log.debug("Username '{}' -> hash '{}' -> firstChar '{}' -> shard {}", 
-                 username, hash, firstChar, shard);
-        
-        return getShardInfoByIndex(shard);
-    }
-    
-    /**
-     * 将十六进制字符映射到分片索引
-     */
-    private int getShardFromHexChar(char hexChar) {
-        int charValue;
-        if (hexChar >= '0' && hexChar <= '9') {
-            charValue = hexChar - '0'; // 0-9
-        } else if (hexChar >= 'a' && hexChar <= 'f') {
-            charValue = hexChar - 'a' + 10; // 10-15
-        } else {
-            // 异常情况，默认为0
-            charValue = 0;
-        }
-        
-        // 映射到队列数量范围内
-        return charValue % QUEUE_COUNT;
-    }
-    
-    /**
-     * 根据分片索引获取分片信息
-     */
-    private ShardInfo getShardInfoByIndex(int shard) {
-        String shardKey = Integer.toHexString(shard);
-        return new ShardInfo(
-            shard,
-            "notifications-queue-" + shardKey,
-            "notifications.shard." + shardKey
-        );
-    }
-    
-    /**
-     * 记录分片使用统计
-     */
-    private void recordShardUsage(int shard) {
-        shardCounts.computeIfAbsent(shard, k -> new AtomicLong(0)).incrementAndGet();
-    }
-
-}

backend/src/main/java/com/openisle/config/WebSocketConfig.java

@@ -0,0 +1,110 @@
+package com.openisle.config;
+
+import com.openisle.service.JwtService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.messaging.Message;
+import org.springframework.messaging.MessageChannel;
+import org.springframework.messaging.simp.config.ChannelRegistration;
+import org.springframework.messaging.simp.config.MessageBrokerRegistry;
+import org.springframework.messaging.simp.stomp.StompCommand;
+import org.springframework.messaging.simp.stomp.StompHeaderAccessor;
+import org.springframework.messaging.support.ChannelInterceptor;
+import org.springframework.messaging.support.MessageHeaderAccessor;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
+import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
+import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;
+
+@Configuration
+@EnableWebSocketMessageBroker
+@RequiredArgsConstructor
+public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
+    
+    private final JwtService jwtService;
+    private final UserDetailsService userDetailsService;
+    @Value("${app.website-url}")
+    private String websiteUrl;
+
+    @Override
+    public void configureMessageBroker(MessageBrokerRegistry config) {
+        // Enable a simple memory-based message broker to carry the messages back to the client on destinations prefixed with "/topic" and "/queue"
+        config.enableSimpleBroker("/topic", "/queue");
+        // Set user destination prefix for personal messages
+        config.setUserDestinationPrefix("/user");
+        // Designates the "/app" prefix for messages that are bound for @MessageMapping-annotated methods.
+        config.setApplicationDestinationPrefixes("/app");
+    }
+
+    @Override
+    public void registerStompEndpoints(StompEndpointRegistry registry) {
+        // 1) 原生 WebSocket（不带 SockJS）
+        registry.addEndpoint("/api/ws")
+                .setAllowedOriginPatterns(
+                        "https://staging.open-isle.com",
+                        "https://www.staging.open-isle.com",
+                        websiteUrl,
+                        websiteUrl.replace("://www.", "://"),
+                        "http://localhost:*",
+                        "http://127.0.0.1:*",
+                        "http://192.168.7.98:*",
+                        "http://30.211.97.238:*"
+                );
+
+        // 2) SockJS 回退：单独路径
+        registry.addEndpoint("/api/sockjs")
+                .setAllowedOriginPatterns(
+                        "https://staging.open-isle.com",
+                        "https://www.staging.open-isle.com",
+                        websiteUrl,
+                        websiteUrl.replace("://www.", "://"),
+                        "http://localhost:*",
+                        "http://127.0.0.1:*",
+                        "http://192.168.7.98:*",
+                        "http://30.211.97.238:*"
+                )
+                .withSockJS()
+                .setWebSocketEnabled(true)
+                .setSessionCookieNeeded(false);
+    }
+
+
+
+    @Override
+    public void configureClientInboundChannel(ChannelRegistration registration) {
+        registration.interceptors(new ChannelInterceptor() {
+            @Override
+            public Message<?> preSend(Message<?> message, MessageChannel channel) {
+                StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
+                
+                if (StompCommand.CONNECT.equals(accessor.getCommand())) {
+                    System.out.println("WebSocket CONNECT command received");
+                    String authHeader = accessor.getFirstNativeHeader("Authorization");
+                    System.out.println("Authorization header: " + (authHeader != null ? "present" : "missing"));
+                    
+                    if (authHeader != null && authHeader.startsWith("Bearer ")) {
+                        String token = authHeader.substring(7);
+                        try {
+                            String username = jwtService.validateAndGetSubject(token);
+                            System.out.println("JWT validated for user: " + username);
+                            var userDetails = userDetailsService.loadUserByUsername(username);
+                            Authentication auth = new UsernamePasswordAuthenticationToken(
+                                userDetails, null, userDetails.getAuthorities());
+                            accessor.setUser(auth);
+                            System.out.println("WebSocket user set: " + username);
+                        } catch (Exception e) {
+                            System.err.println("JWT validation failed: " + e.getMessage());
+                        }
+                    }
+                } else if (StompCommand.SUBSCRIBE.equals(accessor.getCommand())) {
+                    System.out.println("WebSocket SUBSCRIBE to: " + accessor.getDestination());
+                    System.out.println("WebSocket user during subscribe: " + (accessor.getUser() != null ? accessor.getUser().getName() : "null"));
+                }
+                return message;
+            }
+        });
+    }
+}

backend/src/main/java/com/openisle/controller/AuthController.java

@@ -26,7 +26,6 @@ public class AuthController {
     private final GithubAuthService githubAuthService;
     private final DiscordAuthService discordAuthService;
     private final TwitterAuthService twitterAuthService;
-    private final TelegramAuthService telegramAuthService;
     private final RegisterModeService registerModeService;
     private final NotificationService notificationService;
     private final UserRepository userRepository;
@@ -361,51 +360,6 @@ public class AuthController {
         ));
     }
 
-    @PostMapping("/telegram")
-    public ResponseEntity<?> loginWithTelegram(@RequestBody TelegramLoginRequest req) {
-        boolean viaInvite = req.getInviteToken() != null && !req.getInviteToken().isEmpty();
-        InviteService.InviteValidateResult inviteValidateResult = inviteService.validate(req.getInviteToken());
-        if (viaInvite && !inviteValidateResult.isValidate()) {
-            return ResponseEntity.badRequest().body(Map.of("error", "Invalid invite token"));
-        }
-        Optional<AuthResult> resultOpt = telegramAuthService.authenticate(
-                req,
-                registerModeService.getRegisterMode(),
-                viaInvite);
-        if (resultOpt.isPresent()) {
-            AuthResult result = resultOpt.get();
-            if (viaInvite && result.isNewUser()) {
-                inviteService.consume(req.getInviteToken(), inviteValidateResult.getInviteToken().getInviter().getUsername());
-                return ResponseEntity.ok(Map.of(
-                        "token", jwtService.generateToken(result.getUser().getUsername()),
-                        "reason_code", "INVITE_APPROVED"
-                ));
-            }
-            if (RegisterMode.DIRECT.equals(registerModeService.getRegisterMode())) {
-                return ResponseEntity.ok(Map.of("token", jwtService.generateToken(result.getUser().getUsername())));
-            }
-            if (!result.getUser().isApproved()) {
-                if (result.getUser().getRegisterReason() != null && !result.getUser().getRegisterReason().isEmpty()) {
-                    return ResponseEntity.badRequest().body(Map.of(
-                            "error", "Account awaiting approval",
-                            "reason_code", "IS_APPROVING",
-                            "token", jwtService.generateReasonToken(result.getUser().getUsername())
-                    ));
-                }
-                return ResponseEntity.badRequest().body(Map.of(
-                        "error", "Account awaiting approval",
-                        "reason_code", "NOT_APPROVED",
-                        "token", jwtService.generateReasonToken(result.getUser().getUsername())
-                ));
-            }
-            return ResponseEntity.ok(Map.of("token", jwtService.generateToken(result.getUser().getUsername())));
-        }
-        return ResponseEntity.badRequest().body(Map.of(
-                "error", "Invalid telegram data",
-                "reason_code", "INVALID_CREDENTIALS"
-        ));
-    }
-
     @GetMapping("/check")
     public ResponseEntity<?> checkToken() {
         return ResponseEntity.ok(Map.of("valid", true));

backend/src/main/java/com/openisle/controller/NotificationController.java

@@ -62,14 +62,4 @@ public class NotificationController {
     public void updatePref(@RequestBody NotificationPreferenceUpdateRequest req, Authentication auth) {
         notificationService.updatePreference(auth.getName(), req.getType(), req.isEnabled());
     }
-
-    @GetMapping("/email-prefs")
-    public List<NotificationPreferenceDto> emailPrefs(Authentication auth) {
-        return notificationService.listEmailPreferences(auth.getName());
-    }
-
-    @PostMapping("/email-prefs")
-    public void updateEmailPref(@RequestBody NotificationPreferenceUpdateRequest req, Authentication auth) {
-        notificationService.updateEmailPreference(auth.getName(), req.getType(), req.isEnabled());
-    }
 }

backend/src/main/java/com/openisle/controller/PointHistoryController.java

@@ -7,11 +7,9 @@ import lombok.RequiredArgsConstructor;
 import org.springframework.security.core.Authentication;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
 
 import java.util.List;
-import java.util.Map;
 import java.util.stream.Collectors;
 
 @RestController
@@ -27,10 +25,4 @@ public class PointHistoryController {
                 .map(pointHistoryMapper::toDto)
                 .collect(Collectors.toList());
     }
-
-    @GetMapping("/trend")
-    public List<Map<String, Object>> trend(Authentication auth,
-                                          @RequestParam(value = "days", defaultValue = "30") int days) {
-        return pointService.trend(auth.getName(), days);
-    }
 }

backend/src/main/java/com/openisle/controller/PostController.java

@@ -3,7 +3,6 @@ package com.openisle.controller;
 import com.openisle.dto.PostDetailDto;
 import com.openisle.dto.PostRequest;
 import com.openisle.dto.PostSummaryDto;
-import com.openisle.dto.PollDto;
 import com.openisle.mapper.PostMapper;
 import com.openisle.model.Post;
 import com.openisle.service.*;
@@ -43,8 +42,7 @@ public class PostController {
                 req.getTitle(), req.getContent(), req.getTagIds(),
                 req.getType(), req.getPrizeDescription(), req.getPrizeIcon(),
                 req.getPrizeCount(), req.getPointCost(),
-                req.getStartTime(), req.getEndTime(),
-                req.getOptions(), req.getMultiple());
+                req.getStartTime(), req.getEndTime());
         draftService.deleteDraft(auth.getName());
         PostDetailDto dto = postMapper.toDetailDto(post, auth.getName());
         dto.setReward(levelService.awardForPost(auth.getName()));
@@ -88,17 +86,6 @@ public class PostController {
         return ResponseEntity.ok().build();
     }
 
-    @GetMapping("/{id}/poll/progress")
-    public ResponseEntity<PollDto> pollProgress(@PathVariable Long id) {
-        return ResponseEntity.ok(postMapper.toSummaryDto(postService.getPoll(id)).getPoll());
-    }
-
-    @PostMapping("/{id}/poll/vote")
-    public ResponseEntity<Void> vote(@PathVariable Long id, @RequestParam("option") List<Integer> option, Authentication auth) {
-        postService.votePoll(id, auth.getName(), option);
-        return ResponseEntity.ok().build();
-    }
-
     @GetMapping
     public List<PostSummaryDto> listPosts(@RequestParam(value = "categoryId", required = false) Long categoryId,
                                    @RequestParam(value = "categoryIds", required = false) List<Long> categoryIds,

backend/src/main/java/com/openisle/controller/ReactionController.java

@@ -36,7 +36,6 @@ public class ReactionController {
                                                    Authentication auth) {
         Reaction reaction = reactionService.reactToPost(auth.getName(), postId, req.getType());
         if (reaction == null) {
-            pointService.deductForReactionOfPost(auth.getName(), postId);
             return ResponseEntity.noContent().build();
         }
         ReactionDto dto = reactionMapper.toDto(reaction);
@@ -51,7 +50,6 @@ public class ReactionController {
                                                       Authentication auth) {
         Reaction reaction = reactionService.reactToComment(auth.getName(), commentId, req.getType());
         if (reaction == null) {
-            pointService.deductForReactionOfComment(auth.getName(), commentId);
             return ResponseEntity.noContent().build();
         }
         ReactionDto dto = reactionMapper.toDto(reaction);

backend/src/main/java/com/openisle/controller/RssController.java

@@ -41,7 +41,7 @@ public class RssController {
 
     // 兼容 Markdown/HTML 两类图片写法（用于 enclosure）
     private static final Pattern MD_IMAGE = Pattern.compile("!\\[[^\\]]*\\]\\(([^)]+)\\)");
-    private static final Pattern HTML_IMAGE = Pattern.compile("<BaseImage[^>]+src=[\"']?([^\"'>]+)[\"']?[^>]*>");
+    private static final Pattern HTML_IMAGE = Pattern.compile("<img[^>]+src=[\"']?([^\"'>]+)[\"']?[^>]*>");
 
     private static final DateTimeFormatter RFC1123 = DateTimeFormatter.RFC_1123_DATE_TIME;
 

backend/src/main/java/com/openisle/dto/MessageNotificationPayload.java

@@ -1,15 +0,0 @@
-package com.openisle.dto;
-
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-import java.io.Serializable;
-
-@Data
-@NoArgsConstructor
-@AllArgsConstructor
-public class MessageNotificationPayload implements Serializable {
-    private String targetUsername;
-    private Object payload;
-}

backend/src/main/java/com/openisle/dto/PollDto.java

@@ -1,17 +0,0 @@
-package com.openisle.dto;
-
-import lombok.Data;
-
-import java.time.LocalDateTime;
-import java.util.List;
-import java.util.Map;
-
-@Data
-public class PollDto {
-    private List<String> options;
-    private Map<Integer, Integer> votes;
-    private LocalDateTime endTime;
-    private List<AuthorDto> participants;
-    private Map<Integer, List<AuthorDto>> optionParticipants;
-    private boolean multiple;
-}

backend/src/main/java/com/openisle/dto/PostRequest.java

@@ -26,8 +26,5 @@ public class PostRequest {
     private Integer pointCost;
     private LocalDateTime startTime;
     private LocalDateTime endTime;
-    // fields for poll posts
-    private List<String> options;
-    private Boolean multiple;
 }
 

backend/src/main/java/com/openisle/dto/PostSummaryDto.java

@@ -31,7 +31,6 @@ public class PostSummaryDto {
     private int pointReward;
     private PostType type;
     private LotteryDto lottery;
-    private PollDto poll;
     private boolean rssExcluded;
     private boolean closed;
 }

backend/src/main/java/com/openisle/dto/TelegramLoginRequest.java

@@ -1,16 +0,0 @@
-package com.openisle.dto;
-
-import lombok.Data;
-
-/** Request for Telegram login. */
-@Data
-public class TelegramLoginRequest {
-    private String id;
-    private String firstName;
-    private String lastName;
-    private String username;
-    private String photoUrl;
-    private Long authDate;
-    private String hash;
-    private String inviteToken;
-}

backend/src/main/java/com/openisle/mapper/PostMapper.java

@@ -5,24 +5,18 @@ import com.openisle.dto.PostDetailDto;
 import com.openisle.dto.PostSummaryDto;
 import com.openisle.dto.ReactionDto;
 import com.openisle.dto.LotteryDto;
-import com.openisle.dto.PollDto;
-import com.openisle.dto.AuthorDto;
 import com.openisle.model.CommentSort;
 import com.openisle.model.Post;
 import com.openisle.model.LotteryPost;
-import com.openisle.model.PollPost;
 import com.openisle.model.User;
-import com.openisle.model.PollVote;
 import com.openisle.service.CommentService;
 import com.openisle.service.ReactionService;
 import com.openisle.service.SubscriptionService;
-import com.openisle.repository.PollVoteRepository;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Component;
 
 import java.time.LocalDateTime;
 import java.util.List;
-import java.util.Map;
 import java.util.stream.Collectors;
 
 /** Mapper responsible for converting posts into DTOs. */
@@ -38,7 +32,6 @@ public class PostMapper {
     private final UserMapper userMapper;
     private final TagMapper tagMapper;
     private final CategoryMapper categoryMapper;
-    private final PollVoteRepository pollVoteRepository;
 
     public PostSummaryDto toSummaryDto(Post post) {
         PostSummaryDto dto = new PostSummaryDto();
@@ -100,19 +93,5 @@ public class PostMapper {
             l.setWinners(lp.getWinners().stream().map(userMapper::toAuthorDto).collect(Collectors.toList()));
             dto.setLottery(l);
         }
-
-        if (post instanceof PollPost pp) {
-            PollDto p = new PollDto();
-            p.setOptions(pp.getOptions());
-            p.setVotes(pp.getVotes());
-            p.setEndTime(pp.getEndTime());
-            p.setParticipants(pp.getParticipants().stream().map(userMapper::toAuthorDto).collect(Collectors.toList()));
-            Map<Integer, List<AuthorDto>> optionParticipants = pollVoteRepository.findByPostId(pp.getId()).stream()
-                    .collect(Collectors.groupingBy(PollVote::getOptionIndex,
-                            Collectors.mapping(v -> userMapper.toAuthorDto(v.getUser()), Collectors.toList())));
-            p.setOptionParticipants(optionParticipants);
-            p.setMultiple(Boolean.TRUE.equals(pp.getMultiple()));
-            dto.setPoll(p);
-        }
     }
 }

backend/src/main/java/com/openisle/model/Comment.java

@@ -5,8 +5,6 @@ import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
 import org.hibernate.annotations.CreationTimestamp;
-import org.hibernate.annotations.SQLDelete;
-import org.hibernate.annotations.Where;
 
 import java.time.LocalDateTime;
 
@@ -15,8 +13,6 @@ import java.time.LocalDateTime;
 @Setter
 @NoArgsConstructor
 @Table(name = "comments")
-@SQLDelete(sql = "UPDATE comments SET deleted_at = CURRENT_TIMESTAMP(6) WHERE id = ?")
-@Where(clause = "deleted_at IS NULL")
 public class Comment {
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
@@ -45,7 +41,4 @@ public class Comment {
     @Column
     private LocalDateTime pinnedAt;
 
-    @Column(name = "deleted_at")
-    private LocalDateTime deletedAt;
-
 }

backend/src/main/java/com/openisle/model/Draft.java

@@ -22,7 +22,7 @@ public class Draft {
 
     private String title;
 
-    @Column(columnDefinition = "LONGTEXT")
+    @Column(columnDefinition = "TEXT")
     private String content;
 
     @ManyToOne(fetch = FetchType.LAZY, optional = false)

backend/src/main/java/com/openisle/model/InviteToken.java

@@ -14,13 +14,6 @@ public class InviteToken {
     @Id
     private String token;
 
-    /**
-     * Short token used in invite links. Existing records may have this field null
-     * and fall back to {@link #token} for backward compatibility.
-     */
-    @Column(unique = true)
-    private String shortToken;
-
     @ManyToOne
     private User inviter;
 

backend/src/main/java/com/openisle/model/Message.java

@@ -1,6 +1,5 @@
 package com.openisle.model;
 
-import com.fasterxml.jackson.annotation.JsonBackReference;
 import jakarta.persistence.*;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
@@ -21,7 +20,6 @@ public class Message {
 
     @ManyToOne(optional = false, fetch = FetchType.LAZY)
     @JoinColumn(name = "conversation_id")
-    @JsonBackReference
     private MessageConversation conversation;
 
     @ManyToOne(optional = false, fetch = FetchType.LAZY)

backend/src/main/java/com/openisle/model/MessageConversation.java

@@ -1,7 +1,5 @@
 package com.openisle.model;
 
-import com.fasterxml.jackson.annotation.JsonBackReference;
-import com.fasterxml.jackson.annotation.JsonManagedReference;
 import jakarta.persistence.*;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
@@ -43,10 +41,8 @@ public class MessageConversation {
     private Message lastMessage;
 
     @OneToMany(mappedBy = "conversation", cascade = CascadeType.ALL, orphanRemoval = true)
-    @JsonBackReference
     private Set<MessageParticipant> participants = new HashSet<>();
 
     @OneToMany(mappedBy = "conversation", cascade = CascadeType.ALL, orphanRemoval = true)
-    @JsonBackReference
     private Set<Message> messages = new HashSet<>();
 }

backend/src/main/java/com/openisle/model/MessageParticipant.java

@@ -1,6 +1,5 @@
 package com.openisle.model;
 
-import com.fasterxml.jackson.annotation.JsonBackReference;
 import jakarta.persistence.*;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
@@ -20,7 +19,6 @@ public class MessageParticipant {
 
     @ManyToOne(optional = false, fetch = FetchType.LAZY)
     @JoinColumn(name = "conversation_id")
-    @JsonBackReference
     private MessageConversation conversation;
 
     @ManyToOne(optional = false, fetch = FetchType.LAZY)

backend/src/main/java/com/openisle/model/NotificationType.java

@@ -40,12 +40,6 @@ public enum NotificationType {
     LOTTERY_WIN,
     /** Your lottery post was drawn */
     LOTTERY_DRAW,
-    /** Someone participated in your poll */
-    POLL_VOTE,
-    /** Your poll post has concluded */
-    POLL_RESULT_OWNER,
-    /** A poll you participated in has concluded */
-    POLL_RESULT_PARTICIPANT,
     /** Your post was featured */
     POST_FEATURED,
     /** You were mentioned in a post or comment */

backend/src/main/java/com/openisle/model/PointHistory.java

@@ -4,8 +4,6 @@ import jakarta.persistence.*;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
-import org.hibernate.annotations.SQLDelete;
-import org.hibernate.annotations.Where;
 
 import java.time.LocalDateTime;
 
@@ -15,8 +13,6 @@ import java.time.LocalDateTime;
 @Setter
 @NoArgsConstructor
 @Table(name = "point_histories")
-@SQLDelete(sql = "UPDATE point_histories SET deleted_at = CURRENT_TIMESTAMP(6) WHERE id = ?")
-@Where(clause = "deleted_at IS NULL")
 public class PointHistory {
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
@@ -50,7 +46,4 @@ public class PointHistory {
 
     @Column(name = "created_at", nullable = false)
     private LocalDateTime createdAt;
-
-    @Column(name = "deleted_at")
-    private LocalDateTime deletedAt;
 }

backend/src/main/java/com/openisle/model/PointHistoryType.java

@@ -5,8 +5,6 @@ public enum PointHistoryType {
     COMMENT,
     POST_LIKED,
     COMMENT_LIKED,
-    POST_LIKE_CANCELLED,
-    COMMENT_LIKE_CANCELLED,
     INVITE,
     FEATURE,
     SYSTEM_ONLINE,

backend/src/main/java/com/openisle/model/PollPost.java

@@ -1,43 +0,0 @@
-package com.openisle.model;
-
-import jakarta.persistence.*;
-import lombok.Getter;
-import lombok.NoArgsConstructor;
-import lombok.Setter;
-
-import java.time.LocalDateTime;
-import java.util.*;
-
-@Entity
-@Table(name = "poll_posts")
-@Getter
-@Setter
-@NoArgsConstructor
-@PrimaryKeyJoinColumn(name = "post_id")
-public class PollPost extends Post {
-    @ElementCollection
-    @CollectionTable(name = "poll_post_options", joinColumns = @JoinColumn(name = "post_id"))
-    @Column(name = "option_text")
-    private List<String> options = new ArrayList<>();
-
-    @ElementCollection
-    @CollectionTable(name = "poll_post_votes", joinColumns = @JoinColumn(name = "post_id"))
-    @MapKeyColumn(name = "option_index")
-    @Column(name = "vote_count")
-    private Map<Integer, Integer> votes = new HashMap<>();
-
-    @ManyToMany
-    @JoinTable(name = "poll_participants",
-            joinColumns = @JoinColumn(name = "post_id"),
-            inverseJoinColumns = @JoinColumn(name = "user_id"))
-    private Set<User> participants = new HashSet<>();
-
-    @Column
-    private Boolean multiple = false;
-
-    @Column
-    private LocalDateTime endTime;
-
-    @Column
-    private boolean resultAnnounced = false;
-}

backend/src/main/java/com/openisle/model/PollVote.java

@@ -1,28 +0,0 @@
-package com.openisle.model;
-
-import jakarta.persistence.*;
-import lombok.Getter;
-import lombok.NoArgsConstructor;
-import lombok.Setter;
-
-@Entity
-@Table(name = "poll_votes", uniqueConstraints = @UniqueConstraint(columnNames = {"post_id", "user_id", "option_index"}))
-@Getter
-@Setter
-@NoArgsConstructor
-public class PollVote {
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long id;
-
-    @ManyToOne(fetch = FetchType.LAZY, optional = false)
-    @JoinColumn(name = "post_id")
-    private PollPost post;
-
-    @ManyToOne(fetch = FetchType.LAZY, optional = false)
-    @JoinColumn(name = "user_id")
-    private User user;
-
-    @Column(name = "option_index", nullable = false)
-    private int optionIndex;
-}

backend/src/main/java/com/openisle/model/Post.java

@@ -31,7 +31,7 @@ public class Post {
     @Column(nullable = false)
     private String title;
 
-    @Column(nullable = false, columnDefinition = "LONGTEXT")
+    @Column(nullable = false, columnDefinition = "TEXT")
     private String content;
 
     @CreationTimestamp

backend/src/main/java/com/openisle/model/PostType.java

@@ -2,6 +2,5 @@ package com.openisle.model;
 
 public enum PostType {
     NORMAL,
-    LOTTERY,
-    POLL
+    LOTTERY
 }

backend/src/main/java/com/openisle/model/Tag.java

@@ -38,8 +38,8 @@ public class Tag {
     @Column(nullable = false, updatable = false,
             columnDefinition = "DATETIME(6) DEFAULT CURRENT_TIMESTAMP(6)")
     private LocalDateTime createdAt;
-    // 改用redis缓存之后选择立即加载策略
-    @ManyToOne(fetch = FetchType.EAGER)
+
+    @ManyToOne(fetch = FetchType.LAZY)
     @JoinColumn(name = "creator_id")
     private User creator;
 }

backend/src/main/java/com/openisle/model/User.java

@@ -74,12 +74,6 @@ public class User {
             NotificationType.USER_ACTIVITY
     );
 
-    @ElementCollection(targetClass = NotificationType.class)
-    @CollectionTable(name = "user_disabled_email_notification_types", joinColumns = @JoinColumn(name = "user_id"))
-    @Column(name = "notification_type")
-    @Enumerated(EnumType.STRING)
-    private Set<NotificationType> disabledEmailNotificationTypes = EnumSet.noneOf(NotificationType.class);
-
     @CreationTimestamp
     @Column(nullable = false, updatable = false,
             columnDefinition = "DATETIME(6) DEFAULT CURRENT_TIMESTAMP(6)")

backend/src/main/java/com/openisle/repository/InviteTokenRepository.java

@@ -9,8 +9,4 @@ import java.util.Optional;
 
 public interface InviteTokenRepository extends JpaRepository<InviteToken, String> {
     Optional<InviteToken> findByInviterAndCreatedDate(User inviter, LocalDate createdDate);
-
-    Optional<InviteToken> findByShortToken(String shortToken);
-
-    boolean existsByShortToken(String shortToken);
 }

backend/src/main/java/com/openisle/repository/MessageConversationRepository.java

@@ -11,9 +11,6 @@ import java.util.List;
 
 @Repository
 public interface MessageConversationRepository extends JpaRepository<MessageConversation, Long> {
-
-    @Query("SELECT c FROM MessageConversation c LEFT JOIN FETCH c.participants p LEFT JOIN FETCH p.user WHERE c.id = :id")
-    java.util.Optional<MessageConversation> findByIdWithParticipantsAndUsers(@Param("id") Long id);
     @Query("SELECT c FROM MessageConversation c " +
            "WHERE c.channel = false AND size(c.participants) = 2 " +
            "AND EXISTS (SELECT 1 FROM c.participants p1 WHERE p1.user = :user1) " +

backend/src/main/java/com/openisle/repository/NotificationRepository.java

@@ -5,7 +5,6 @@ import com.openisle.model.User;
 import com.openisle.model.Post;
 import com.openisle.model.Comment;
 import com.openisle.model.NotificationType;
-import com.openisle.model.ReactionType;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
@@ -30,8 +29,4 @@ public interface NotificationRepository extends JpaRepository<Notification, Long
     List<Notification> findByTypeAndFromUser(NotificationType type, User fromUser);
 
     void deleteByTypeAndFromUserAndPost(NotificationType type, User fromUser, Post post);
-
-    void deleteByTypeAndFromUserAndPostAndReactionType(NotificationType type, User fromUser, Post post, ReactionType reactionType);
-
-    void deleteByTypeAndFromUserAndCommentAndReactionType(NotificationType type, User fromUser, Comment comment, ReactionType reactionType);
 }

backend/src/main/java/com/openisle/repository/PointHistoryRepository.java

@@ -2,17 +2,11 @@ package com.openisle.repository;
 
 import com.openisle.model.PointHistory;
 import com.openisle.model.User;
-import com.openisle.model.Comment;
 import org.springframework.data.jpa.repository.JpaRepository;
 
-import java.time.LocalDateTime;
 import java.util.List;
 
 public interface PointHistoryRepository extends JpaRepository<PointHistory, Long> {
     List<PointHistory> findByUserOrderByIdDesc(User user);
     long countByUser(User user);
-
-    List<PointHistory> findByUserAndCreatedAtAfterOrderByCreatedAtDesc(User user, LocalDateTime createdAt);
-    
-    List<PointHistory> findByComment(Comment comment);
 }

backend/src/main/java/com/openisle/repository/PollPostRepository.java

@@ -1,13 +0,0 @@
-package com.openisle.repository;
-
-import com.openisle.model.PollPost;
-import org.springframework.data.jpa.repository.JpaRepository;
-
-import java.time.LocalDateTime;
-import java.util.List;
-
-public interface PollPostRepository extends JpaRepository<PollPost, Long> {
-    List<PollPost> findByEndTimeAfterAndResultAnnouncedFalse(LocalDateTime now);
-
-    List<PollPost> findByEndTimeBeforeAndResultAnnouncedFalse(LocalDateTime now);
-}

backend/src/main/java/com/openisle/repository/PollVoteRepository.java

@@ -1,10 +0,0 @@
-package com.openisle.repository;
-
-import com.openisle.model.PollVote;
-import org.springframework.data.jpa.repository.JpaRepository;
-
-import java.util.List;
-
-public interface PollVoteRepository extends JpaRepository<PollVote, Long> {
-    List<PollVote> findByPostId(Long postId);
-}

backend/src/main/java/com/openisle/service/CategoryService.java

@@ -1,11 +1,8 @@
 package com.openisle.service;
 
-import com.openisle.config.CachingConfig;
 import com.openisle.model.Category;
 import com.openisle.repository.CategoryRepository;
 import lombok.RequiredArgsConstructor;
-import org.springframework.cache.annotation.CacheEvict;
-import org.springframework.cache.annotation.Cacheable;
 import org.springframework.stereotype.Service;
 
 import java.util.List;
@@ -14,7 +11,7 @@ import java.util.List;
 @RequiredArgsConstructor
 public class CategoryService {
     private final CategoryRepository categoryRepository;
-    @CacheEvict(value = CachingConfig.CATEGORY_CACHE_NAME, allEntries = true)
+
     public Category createCategory(String name, String description, String icon, String smallIcon) {
         Category category = new Category();
         category.setName(name);
@@ -23,7 +20,7 @@ public class CategoryService {
         category.setSmallIcon(smallIcon);
         return categoryRepository.save(category);
     }
-    @CacheEvict(value = CachingConfig.CATEGORY_CACHE_NAME, allEntries = true)
+
     public Category updateCategory(Long id, String name, String description, String icon, String smallIcon) {
         Category category = categoryRepository.findById(id)
                 .orElseThrow(() -> new IllegalArgumentException("Category not found"));
@@ -41,7 +38,7 @@ public class CategoryService {
         }
         return categoryRepository.save(category);
     }
-    @CacheEvict(value = CachingConfig.CATEGORY_CACHE_NAME, allEntries = true)
+
     public void deleteCategory(Long id) {
         categoryRepository.deleteById(id);
     }
@@ -51,14 +48,6 @@ public class CategoryService {
                 .orElseThrow(() -> new IllegalArgumentException("Category not found"));
     }
 
-    /**
-     * 该方法每次首页加载都会访问，加入缓存
-     * @return
-     */
-    @Cacheable(
-            value = CachingConfig.CATEGORY_CACHE_NAME,
-            key = "'listCategories:'"
-    )
     public List<Category> listCategories() {
         return categoryRepository.findAll();
     }

backend/src/main/java/com/openisle/service/CommentService.java

@@ -4,7 +4,6 @@ import com.openisle.model.Comment;
 import com.openisle.model.Post;
 import com.openisle.model.User;
 import com.openisle.model.NotificationType;
-import com.openisle.model.PointHistory;
 import com.openisle.model.CommentSort;
 import com.openisle.repository.CommentRepository;
 import com.openisle.repository.PostRepository;
@@ -12,10 +11,8 @@ import com.openisle.repository.UserRepository;
 import com.openisle.repository.ReactionRepository;
 import com.openisle.repository.CommentSubscriptionRepository;
 import com.openisle.repository.NotificationRepository;
-import com.openisle.repository.PointHistoryRepository;
 import com.openisle.service.NotificationService;
 import com.openisle.service.SubscriptionService;
-import com.openisle.service.PointService;
 import com.openisle.model.Role;
 import com.openisle.exception.RateLimitException;
 import lombok.RequiredArgsConstructor;
@@ -23,9 +20,6 @@ import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 
 import java.util.List;
-import java.util.Set;
-import java.util.HashSet;
-import java.util.stream.Collectors;
 import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Pageable;
 import org.springframework.transaction.annotation.Transactional;
@@ -43,8 +37,6 @@ public class CommentService {
     private final ReactionRepository reactionRepository;
     private final CommentSubscriptionRepository commentSubscriptionRepository;
     private final NotificationRepository notificationRepository;
-    private final PointHistoryRepository pointHistoryRepository;
-    private final PointService pointService;
     private final ImageUploader imageUploader;
 
     @Transactional
@@ -71,19 +63,16 @@ public class CommentService {
         log.debug("Comment {} saved for post {}", comment.getId(), postId);
         imageUploader.addReferences(imageUploader.extractUrls(content));
         if (!author.getId().equals(post.getAuthor().getId())) {
-            notificationService.createNotification(post.getAuthor(), NotificationType.COMMENT_REPLY, post, comment,
-                    null, null, null, null);
+            notificationService.createNotification(post.getAuthor(), NotificationType.COMMENT_REPLY, post, comment, null, null, null, null);
         }
         for (User u : subscriptionService.getPostSubscribers(postId)) {
             if (!u.getId().equals(author.getId())) {
-                notificationService.createNotification(u, NotificationType.POST_UPDATED, post, comment, null, null,
-                        null, null);
+                notificationService.createNotification(u, NotificationType.POST_UPDATED, post, comment, null, null, null, null);
             }
         }
         for (User u : subscriptionService.getSubscribers(author.getUsername())) {
             if (!u.getId().equals(author.getId())) {
-                notificationService.createNotification(u, NotificationType.USER_ACTIVITY, post, comment, null, null,
-                        null, null);
+                notificationService.createNotification(u, NotificationType.USER_ACTIVITY, post, comment, null, null, null, null);
             }
         }
         notificationService.notifyMentions(content, author, post, comment);
@@ -120,25 +109,21 @@ public class CommentService {
         log.debug("Reply {} saved for parent {}", comment.getId(), parentId);
         imageUploader.addReferences(imageUploader.extractUrls(content));
         if (!author.getId().equals(parent.getAuthor().getId())) {
-            notificationService.createNotification(parent.getAuthor(), NotificationType.COMMENT_REPLY, parent.getPost(),
-                    comment, null, null, null, null);
+            notificationService.createNotification(parent.getAuthor(), NotificationType.COMMENT_REPLY, parent.getPost(), comment, null, null, null, null);
         }
         for (User u : subscriptionService.getCommentSubscribers(parentId)) {
             if (!u.getId().equals(author.getId())) {
-                notificationService.createNotification(u, NotificationType.COMMENT_REPLY, parent.getPost(), comment,
-                        null, null, null, null);
+                notificationService.createNotification(u, NotificationType.COMMENT_REPLY, parent.getPost(), comment, null, null, null, null);
             }
         }
         for (User u : subscriptionService.getPostSubscribers(parent.getPost().getId())) {
             if (!u.getId().equals(author.getId())) {
-                notificationService.createNotification(u, NotificationType.POST_UPDATED, parent.getPost(), comment,
-                        null, null, null, null);
+                notificationService.createNotification(u, NotificationType.POST_UPDATED, parent.getPost(), comment, null, null, null, null);
             }
         }
         for (User u : subscriptionService.getSubscribers(author.getUsername())) {
             if (!u.getId().equals(author.getId())) {
-                notificationService.createNotification(u, NotificationType.USER_ACTIVITY, parent.getPost(), comment,
-                        null, null, null, null);
+                notificationService.createNotification(u, NotificationType.USER_ACTIVITY, parent.getPost(), comment, null, null, null, null);
             }
         }
         notificationService.notifyMentions(content, author, parent.getPost(), comment);
@@ -250,33 +235,11 @@ public class CommentService {
         for (Comment c : replies) {
             deleteCommentCascade(c);
         }
-
-        // 逻辑删除相关的积分历史记录，并收集受影响的用户
-        List<PointHistory> pointHistories = pointHistoryRepository.findByComment(comment);
-        // 收集需要重新计算积分的用户
-        Set<User> usersToRecalculate = pointHistories.stream().map(PointHistory::getUser).collect(Collectors.toSet());
-
-        // 删除其他相关数据
         reactionRepository.findByComment(comment).forEach(reactionRepository::delete);
         commentSubscriptionRepository.findByComment(comment).forEach(commentSubscriptionRepository::delete);
         notificationRepository.deleteAll(notificationRepository.findByComment(comment));
         imageUploader.removeReferences(imageUploader.extractUrls(comment.getContent()));
-
-        // 逻辑删除评论
         commentRepository.delete(comment);
-        // 删除积分历史
-        pointHistoryRepository.deleteAll(pointHistories);
-
-        // 重新计算受影响用户的积分
-        if (!usersToRecalculate.isEmpty()) {
-            for (User user : usersToRecalculate) {
-                int newPoints = pointService.recalculateUserPoints(user);
-                user.setPoint(newPoints);
-                log.debug("Recalculated points for user {}: {}", user.getUsername(), newPoints);
-            }
-            userRepository.saveAll(usersToRecalculate);
-        }
-
         log.debug("deleteCommentCascade removed comment {}", comment.getId());
     }
 

backend/src/main/java/com/openisle/service/InviteService.java

@@ -30,53 +30,33 @@ public class InviteService {
         LocalDate today = LocalDate.now();
         Optional<InviteToken> existing = inviteTokenRepository.findByInviterAndCreatedDate(inviter, today);
         if (existing.isPresent()) {
-            InviteToken inviteToken = existing.get();
-            return inviteToken.getShortToken() != null ? inviteToken.getShortToken() : inviteToken.getToken();
+            return existing.get().getToken();
         }
-
         String token = jwtService.generateInviteToken(username);
-        String shortToken;
-        do {
-            shortToken = java.util.UUID.randomUUID().toString().replace("-", "").substring(0, 8);
-        } while (inviteTokenRepository.existsByShortToken(shortToken));
-
         InviteToken inviteToken = new InviteToken();
         inviteToken.setToken(token);
-        inviteToken.setShortToken(shortToken);
         inviteToken.setInviter(inviter);
         inviteToken.setCreatedDate(today);
         inviteToken.setUsageCount(0);
         inviteTokenRepository.save(inviteToken);
-        return shortToken;
+        return token;
     }
 
     public InviteValidateResult validate(String token) {
         if (token == null || token.isEmpty()) {
             return new InviteValidateResult(null, false);
         }
-
-        InviteToken invite = inviteTokenRepository.findById(token).orElse(null);
-        String realToken = token;
-        if (invite == null) {
-            invite = inviteTokenRepository.findByShortToken(token).orElse(null);
-            if (invite == null) {
-                return new InviteValidateResult(null, false);
-            }
-            realToken = invite.getToken();
-        }
-
         try {
-            jwtService.validateAndGetSubjectForInvite(realToken);
+            jwtService.validateAndGetSubjectForInvite(token);
         } catch (Exception e) {
             return new InviteValidateResult(null, false);
         }
-
-        return new InviteValidateResult(invite, invite.getUsageCount() < 3);
+        InviteToken invite = inviteTokenRepository.findById(token).orElse(null);
+        return new InviteValidateResult(invite, invite != null && invite.getUsageCount() < 3);
     }
 
     public void consume(String token, String newUserName) {
-        InviteToken invite = inviteTokenRepository.findById(token)
-                .orElseGet(() -> inviteTokenRepository.findByShortToken(token).orElseThrow());
+        InviteToken invite = inviteTokenRepository.findById(token).orElseThrow();
         invite.setUsageCount(invite.getUsageCount() + 1);
         inviteTokenRepository.save(invite);
         pointService.awardForInvite(invite.getInviter().getUsername(), newUserName);

backend/src/main/java/com/openisle/service/MessageService.java

@@ -16,18 +16,16 @@ import com.openisle.dto.MessageDto;
 import com.openisle.dto.ReactionDto;
 import com.openisle.dto.UserSummaryDto;
 import com.openisle.mapper.ReactionMapper;
-import com.openisle.dto.MessageNotificationPayload;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
+import org.springframework.messaging.simp.SimpMessagingTemplate;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.time.LocalDateTime;
-import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
 import java.util.stream.Collectors;
 
 @Service
@@ -39,7 +37,7 @@ public class MessageService {
     private final MessageConversationRepository conversationRepository;
     private final MessageParticipantRepository participantRepository;
     private final UserRepository userRepository;
-    private final NotificationProducer notificationProducer;
+    private final SimpMessagingTemplate messagingTemplate;
     private final ReactionRepository reactionRepository;
     private final ReactionMapper reactionMapper;
 
@@ -71,41 +69,26 @@ public class MessageService {
         conversationRepository.save(conversation);
         log.info("Conversation {} updated with last message ID {}", conversation.getId(), message.getId());
 
-        
-        try {
-            MessageDto messageDto = toDto(message);
-            
-            long unreadCount = getUnreadMessageCount(recipientId);
+        // Broadcast the new message to subscribed clients
+        MessageDto messageDto = toDto(message);
+        String conversationDestination = "/topic/conversation/" + conversation.getId();
+        messagingTemplate.convertAndSend(conversationDestination, messageDto);
+        log.info("Message {} broadcasted to destination: {}", message.getId(), conversationDestination);
 
-            // 创建包含对话和参与者信息的完整payload
-            Map<String, Object> conversationInfo = new HashMap<>();
-            conversationInfo.put("id", conversation.getId());
-            conversationInfo.put("participants", conversation.getParticipants().stream()
-                .map(p -> {
-                    Map<String, Object> participantInfo = new HashMap<>();
-                    participantInfo.put("userId", p.getUser().getId());
-                    participantInfo.put("username", p.getUser().getUsername());
-                    return participantInfo;
-                }).collect(Collectors.toList()));
-            
-            Map<String, Object> combinedPayload = new HashMap<>();
-            combinedPayload.put("message", messageDto);
-            combinedPayload.put("unreadCount", unreadCount);
-            combinedPayload.put("conversation", conversationInfo);
-            combinedPayload.put("senderId", senderId);
-            if (notificationProducer != null) {
-                log.info("NotificationProducer is available");
-            } else {
-                log.info("ERROR: NotificationProducer is NULL!");
-                return message;
-            }
-            log.info("Recipient username: {}", recipient.getUsername());
-            
-            notificationProducer.sendNotification(new MessageNotificationPayload(recipient.getUsername(), combinedPayload));
-            log.info("=== Notification call completed ===");
-        } catch (Exception e) {
-            log.error("=== Error in notification process ===", e);
-        }
+        // Also notify the recipient on their personal channel to update the conversation list
+        String userDestination = "/topic/user/" + recipient.getId() + "/messages";
+        messagingTemplate.convertAndSend(userDestination, messageDto);
+        log.info("Message {} notification sent to destination: {}", message.getId(), userDestination);
+
+        // Notify recipient of new unread count
+        long unreadCount = getUnreadMessageCount(recipientId);
+        log.info("Calculating unread count for user {}: {}", recipientId, unreadCount);
+        
+        // Send using username instead of user ID for WebSocket routing
+        String recipientUsername = recipient.getUsername();
+        messagingTemplate.convertAndSendToUser(recipientUsername, "/queue/unread-count", unreadCount);
+        log.info("Sent unread count {} to user {} (username: {}) via WebSocket destination: /user/{}/queue/unread-count",
+                unreadCount, recipientId, recipientUsername, recipientUsername);
 
         return message;
     }
@@ -114,7 +97,7 @@ public class MessageService {
     public Message sendMessageToConversation(Long senderId, Long conversationId, String content, Long replyToId) {
         User sender = userRepository.findById(senderId)
                 .orElseThrow(() -> new IllegalArgumentException("Sender not found"));
-        MessageConversation conversation = conversationRepository.findByIdWithParticipantsAndUsers(conversationId)
+        MessageConversation conversation = conversationRepository.findById(conversationId)
                 .orElseThrow(() -> new IllegalArgumentException("Conversation not found"));
 
         // Join the conversation if not already a participant (useful for channels)
@@ -141,30 +124,22 @@ public class MessageService {
         conversationRepository.save(conversation);
 
         MessageDto messageDto = toDto(message);
+        String conversationDestination = "/topic/conversation/" + conversation.getId();
+        messagingTemplate.convertAndSend(conversationDestination, messageDto);
 
-        // Build participant payloads once to avoid duplicate broadcasts
-        java.util.List<Map<String, Object>> participantInfos = conversation.getParticipants().stream()
-                .filter(p -> !p.getUser().getId().equals(senderId))
-                .map(p -> {
-                    Map<String, Object> info = new HashMap<>();
-                    info.put("userId", p.getUser().getId());
-                    info.put("username", p.getUser().getUsername());
-                    info.put("unreadCount", getUnreadMessageCount(p.getUser().getId()));
-                    info.put("channelUnread", getUnreadChannelCount(p.getUser().getId()));
-                    return info;
-                }).collect(Collectors.toList());
+        // Notify all participants except sender for updates
+        for (MessageParticipant participant : conversation.getParticipants()) {
+            if (participant.getUser().getId().equals(senderId)) continue;
+            String userDestination = "/topic/user/" + participant.getUser().getId() + "/messages";
+            messagingTemplate.convertAndSend(userDestination, messageDto);
 
-        Map<String, Object> conversationInfo = new HashMap<>();
-        conversationInfo.put("id", conversation.getId());
-        conversationInfo.put("participants", participantInfos);
+            long unreadCount = getUnreadMessageCount(participant.getUser().getId());
+            String username = participant.getUser().getUsername();
+            messagingTemplate.convertAndSendToUser(username, "/queue/unread-count", unreadCount);
 
-        Map<String, Object> combinedPayload = new HashMap<>();
-        combinedPayload.put("message", messageDto);
-        combinedPayload.put("conversation", conversationInfo);
-        combinedPayload.put("senderId", senderId);
-
-        // Use sender's username for sharding; only one notification is needed
-        notificationProducer.sendNotification(new MessageNotificationPayload(sender.getUsername(), combinedPayload));
+            long channelUnread = getUnreadChannelCount(participant.getUser().getId());
+            messagingTemplate.convertAndSendToUser(username, "/queue/channel-unread", channelUnread);
+        }
 
         return message;
     }

backend/src/main/java/com/openisle/service/NotificationProducer.java

@@ -1,63 +0,0 @@
-package com.openisle.service;
-
-import com.openisle.config.RabbitMQConfig;
-import com.openisle.config.ShardInfo;
-import com.openisle.config.ShardingStrategy;
-import com.openisle.dto.MessageNotificationPayload;
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.amqp.rabbit.core.RabbitTemplate;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.stereotype.Service;
-
-@Service
-@RequiredArgsConstructor
-@Slf4j
-public class NotificationProducer {
-
-    private final RabbitTemplate rabbitTemplate;
-    private final ShardingStrategy shardingStrategy;
-    
-    @Value("${rabbitmq.sharding.enabled}")
-    private boolean shardingEnabled;
-
-    public void sendNotification(MessageNotificationPayload payload) {
-        String targetUsername = payload.getTargetUsername();
-        
-        try {
-            if (shardingEnabled) {
-                // 使用分片策略发送消息
-                sendShardedNotification(payload, targetUsername);
-            } else {
-                // 使用原始单队列方式发送（向后兼容）
-                sendLegacyNotification(payload);
-            }
-        } catch (Exception e) {
-            log.error("Failed to send message to RabbitMQ for user: {}", targetUsername, e);
-            throw e;
-        }
-    }
-    
-    /**
-     * 使用分片策略发送消息
-     */
-    private void sendShardedNotification(MessageNotificationPayload payload, String targetUsername) {
-        ShardInfo shardInfo = shardingStrategy.getShardInfo(targetUsername);
-        rabbitTemplate.convertAndSend(
-            RabbitMQConfig.EXCHANGE_NAME,
-            shardInfo.getRoutingKey(),
-            payload
-        );
-    }
-    
-    /**
-     * 使用原始单队列方式发送消息（向后兼容）
-     */
-    private void sendLegacyNotification(MessageNotificationPayload payload) {
-        rabbitTemplate.convertAndSend(
-            RabbitMQConfig.EXCHANGE_NAME,
-            RabbitMQConfig.ROUTING_KEY,
-            payload
-        );
-    }
-}

backend/src/main/java/com/openisle/service/NotificationService.java

@@ -19,7 +19,6 @@ import java.util.regex.Pattern;
 import java.util.regex.Matcher;
 import java.util.Set;
 import java.util.HashSet;
-import java.util.EnumSet;
 
 import java.util.List;
 import java.util.ArrayList;
@@ -41,12 +40,6 @@ public class NotificationService {
 
     private static final Pattern MENTION_PATTERN = Pattern.compile("@\\[([^\\]]+)\\]");
 
-    private static final Set<NotificationType> EMAIL_TYPES = EnumSet.of(
-            NotificationType.COMMENT_REPLY,
-            NotificationType.LOTTERY_WIN,
-            NotificationType.LOTTERY_DRAW
-    );
-
     private String buildPayload(String body, String url) {
         // Ensure push notifications contain a link to the related resource so
         // that verifications can assert its presence and users can navigate
@@ -82,8 +75,7 @@ public class NotificationService {
         n = notificationRepository.save(n);
 
 //        Runnable asyncTask = () -> {
-            if (type == NotificationType.COMMENT_REPLY && user.getEmail() != null && post != null && comment != null
-                    && !user.getDisabledEmailNotificationTypes().contains(NotificationType.COMMENT_REPLY)) {
+            if (type == NotificationType.COMMENT_REPLY && user.getEmail() != null && post != null && comment != null) {
                 String url = String.format("%s/posts/%d#comment-%d", websiteUrl, post.getId(), comment.getId());
                 emailSender.sendEmail(user.getEmail(), "有人回复了你", url);
                 sendCustomPush(user, "有人回复了你", url);
@@ -122,14 +114,6 @@ public class NotificationService {
         return n;
     }
 
-    public void deleteReactionNotification(User fromUser, Post post, Comment comment, ReactionType reactionType) {
-        if (post != null) {
-            notificationRepository.deleteByTypeAndFromUserAndPostAndReactionType(NotificationType.REACTION, fromUser, post, reactionType);
-        } else if (comment != null) {
-            notificationRepository.deleteByTypeAndFromUserAndCommentAndReactionType(NotificationType.REACTION, fromUser, comment, reactionType);
-        }
-    }
-
     /**
      * Create notifications for all admins when a user submits a register request.
      * Old register request notifications from the same applicant are removed first.
@@ -195,35 +179,6 @@ public class NotificationService {
         userRepository.save(user);
     }
 
-    public List<NotificationPreferenceDto> listEmailPreferences(String username) {
-        User user = userRepository.findByUsername(username)
-                .orElseThrow(() -> new com.openisle.exception.NotFoundException("User not found"));
-        Set<NotificationType> disabled = user.getDisabledEmailNotificationTypes();
-        List<NotificationPreferenceDto> prefs = new ArrayList<>();
-        for (NotificationType nt : EMAIL_TYPES) {
-            NotificationPreferenceDto dto = new NotificationPreferenceDto();
-            dto.setType(nt);
-            dto.setEnabled(!disabled.contains(nt));
-            prefs.add(dto);
-        }
-        return prefs;
-    }
-
-    public void updateEmailPreference(String username, NotificationType type, boolean enabled) {
-        if (!EMAIL_TYPES.contains(type)) {
-            return;
-        }
-        User user = userRepository.findByUsername(username)
-                .orElseThrow(() -> new com.openisle.exception.NotFoundException("User not found"));
-        Set<NotificationType> disabled = user.getDisabledEmailNotificationTypes();
-        if (enabled) {
-            disabled.remove(type);
-        } else {
-            disabled.add(type);
-        }
-        userRepository.save(user);
-    }
-
     public List<Notification> listNotifications(String username, Boolean read, int page, int size) {
         User user = userRepository.findByUsername(username)
                 .orElseThrow(() -> new com.openisle.exception.NotFoundException("User not found"));

backend/src/main/java/com/openisle/service/PointService.java

@@ -7,10 +7,6 @@ import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 
 import java.time.LocalDate;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
 
 @Service
 @RequiredArgsConstructor
@@ -150,16 +146,6 @@ public class PointService {
         return addPoint(poster, 10, PointHistoryType.POST_LIKED, post, null, reactioner);
     }
 
-    public int deductForReactionOfPost(String reactionerName, Long postId) {
-        User poster = postRepository.findById(postId).orElseThrow().getAuthor();
-        User reactioner = userRepository.findByUsername(reactionerName).orElseThrow();
-        if (poster.getId().equals(reactioner.getId())) {
-            return 0;
-        }
-        Post post = postRepository.findById(postId).orElseThrow();
-        return addPoint(poster, -10, PointHistoryType.POST_LIKE_CANCELLED, post, null, reactioner);
-    }
-
     // 考虑点赞者和评论者是同一个的情况
     public int awardForReactionOfComment(String reactionerName, Long commentId) {
         // 根据帖子id找到评论者
@@ -179,17 +165,6 @@ public class PointService {
         return addPoint(commenter, 10, PointHistoryType.COMMENT_LIKED, post, comment, reactioner);
     }
 
-    public int deductForReactionOfComment(String reactionerName, Long commentId) {
-        User commenter = commentRepository.findById(commentId).orElseThrow().getAuthor();
-        User reactioner = userRepository.findByUsername(reactionerName).orElseThrow();
-        if (commenter.getId().equals(reactioner.getId())) {
-            return 0;
-        }
-        Comment comment = commentRepository.findById(commentId).orElseThrow();
-        Post post = comment.getPost();
-        return addPoint(commenter, -10, PointHistoryType.COMMENT_LIKE_CANCELLED, post, comment, reactioner);
-    }
-
     public java.util.List<PointHistory> listHistory(String userName) {
         User user = userRepository.findByUsername(userName).orElseThrow();
         if (pointHistoryRepository.countByUser(user) == 0) {
@@ -198,53 +173,4 @@ public class PointService {
         return pointHistoryRepository.findByUserOrderByIdDesc(user);
     }
 
-    public List<Map<String, Object>> trend(String userName, int days) {
-        if (days < 1) days = 1;
-        User user = userRepository.findByUsername(userName).orElseThrow();
-        LocalDate end = LocalDate.now();
-        LocalDate start = end.minusDays(days - 1L);
-        var histories = pointHistoryRepository.findByUserAndCreatedAtAfterOrderByCreatedAtDesc(
-                user, start.atStartOfDay());
-        int idx = 0;
-        int balance = user.getPoint();
-        List<Map<String, Object>> result = new ArrayList<>();
-        for (LocalDate day = end; !day.isBefore(start); day = day.minusDays(1)) {
-            result.add(Map.of("date", day.toString(), "value", balance));
-            while (idx < histories.size() && histories.get(idx).getCreatedAt().toLocalDate().isEqual(day)) {
-                balance -= histories.get(idx).getAmount();
-                idx++;
-            }
-        }
-        Collections.reverse(result);
-        return result;
-    }
-
-    /**
-     * 重新计算用户的积分总数
-     * 通过累加所有积分历史记录来重新计算用户的当前积分
-     */
-    public int recalculateUserPoints(User user) {
-        // 获取用户所有的积分历史记录（由于@Where注解，已删除的记录会被自动过滤）
-        List<PointHistory> histories = pointHistoryRepository.findByUserOrderByIdDesc(user);
-        
-        int totalPoints = 0;
-        for (PointHistory history : histories) {
-            totalPoints += history.getAmount();
-        }
-        
-        // 更新用户积分
-        user.setPoint(totalPoints);
-        userRepository.save(user);
-        
-        return totalPoints;
-    }
-
-    /**
-     * 重新计算用户的积分总数（通过用户名）
-     */
-    public int recalculateUserPoints(String userName) {
-        User user = userRepository.findByUsername(userName).orElseThrow();
-        return recalculateUserPoints(user);
-    }
-
 }

backend/src/main/java/com/openisle/service/PostService.java

@@ -9,11 +9,8 @@ import com.openisle.model.Category;
 import com.openisle.model.Comment;
 import com.openisle.model.NotificationType;
 import com.openisle.model.LotteryPost;
-import com.openisle.model.PollPost;
-import com.openisle.model.PollVote;
 import com.openisle.repository.PostRepository;
 import com.openisle.repository.LotteryPostRepository;
-import com.openisle.repository.PollPostRepository;
 import com.openisle.repository.UserRepository;
 import com.openisle.repository.CategoryRepository;
 import com.openisle.repository.TagRepository;
@@ -23,7 +20,6 @@ import com.openisle.repository.CommentRepository;
 import com.openisle.repository.ReactionRepository;
 import com.openisle.repository.PostSubscriptionRepository;
 import com.openisle.repository.NotificationRepository;
-import com.openisle.repository.PollVoteRepository;
 import com.openisle.model.Role;
 import com.openisle.exception.RateLimitException;
 import lombok.extern.slf4j.Slf4j;
@@ -58,8 +54,6 @@ public class PostService {
     private final CategoryRepository categoryRepository;
     private final TagRepository tagRepository;
     private final LotteryPostRepository lotteryPostRepository;
-    private final PollPostRepository pollPostRepository;
-    private final PollVoteRepository pollVoteRepository;
     private PublishMode publishMode;
     private final NotificationService notificationService;
     private final SubscriptionService subscriptionService;
@@ -84,8 +78,6 @@ public class PostService {
                        CategoryRepository categoryRepository,
                        TagRepository tagRepository,
                        LotteryPostRepository lotteryPostRepository,
-                       PollPostRepository pollPostRepository,
-                       PollVoteRepository pollVoteRepository,
                        NotificationService notificationService,
                        SubscriptionService subscriptionService,
                        CommentService commentService,
@@ -105,8 +97,6 @@ public class PostService {
         this.categoryRepository = categoryRepository;
         this.tagRepository = tagRepository;
         this.lotteryPostRepository = lotteryPostRepository;
-        this.pollPostRepository = pollPostRepository;
-        this.pollVoteRepository = pollVoteRepository;
         this.notificationService = notificationService;
         this.subscriptionService = subscriptionService;
         this.commentService = commentService;
@@ -135,15 +125,6 @@ public class PostService {
         for (LotteryPost lp : lotteryPostRepository.findByEndTimeBeforeAndWinnersIsEmpty(now)) {
             applicationContext.getBean(PostService.class).finalizeLottery(lp.getId());
         }
-        for (PollPost pp : pollPostRepository.findByEndTimeAfterAndResultAnnouncedFalse(now)) {
-            ScheduledFuture<?> future = taskScheduler.schedule(
-                    () -> applicationContext.getBean(PostService.class).finalizePoll(pp.getId()),
-                    java.util.Date.from(pp.getEndTime().atZone(ZoneId.systemDefault()).toInstant()));
-            scheduledFinalizations.put(pp.getId(), future);
-        }
-        for (PollPost pp : pollPostRepository.findByEndTimeBeforeAndResultAnnouncedFalse(now)) {
-            applicationContext.getBean(PostService.class).finalizePoll(pp.getId());
-        }
     }
 
     public PublishMode getPublishMode() {
@@ -185,9 +166,7 @@ public class PostService {
                            Integer prizeCount,
                            Integer pointCost,
                            LocalDateTime startTime,
-                           LocalDateTime endTime,
-                           java.util.List<String> options,
-                           Boolean multiple) {
+                           LocalDateTime endTime) {
         long recent = postRepository.countByAuthorAfter(username,
                 java.time.LocalDateTime.now().minusMinutes(5));
         if (recent >= 1) {
@@ -221,15 +200,6 @@ public class PostService {
             lp.setStartTime(startTime);
             lp.setEndTime(endTime);
             post = lp;
-        } else if (actualType == PostType.POLL) {
-            if (options == null || options.size() < 2) {
-                throw new IllegalArgumentException("At least two options required");
-            }
-            PollPost pp = new PollPost();
-            pp.setOptions(options);
-            pp.setEndTime(endTime);
-            pp.setMultiple(multiple != null && multiple);
-            post = pp;
         } else {
             post = new Post();
         }
@@ -242,8 +212,6 @@ public class PostService {
         post.setStatus(publishMode == PublishMode.REVIEW ? PostStatus.PENDING : PostStatus.PUBLISHED);
         if (post instanceof LotteryPost) {
             post = lotteryPostRepository.save((LotteryPost) post);
-        } else if (post instanceof PollPost) {
-            post = pollPostRepository.save((PollPost) post);
         } else {
             post = postRepository.save(post);
         }
@@ -278,11 +246,6 @@ public class PostService {
                     () -> applicationContext.getBean(PostService.class).finalizeLottery(lp.getId()),
                     java.util.Date.from(lp.getEndTime().atZone(ZoneId.systemDefault()).toInstant()));
             scheduledFinalizations.put(lp.getId(), future);
-        } else if (post instanceof PollPost pp && pp.getEndTime() != null) {
-            ScheduledFuture<?> future = taskScheduler.schedule(
-                    () -> applicationContext.getBean(PostService.class).finalizePoll(pp.getId()),
-                    java.util.Date.from(pp.getEndTime().atZone(ZoneId.systemDefault()).toInstant()));
-            scheduledFinalizations.put(pp.getId(), future);
         }
         return post;
     }
@@ -298,66 +261,6 @@ public class PostService {
         }
     }
 
-    public PollPost getPoll(Long postId) {
-        return pollPostRepository.findById(postId)
-                .orElseThrow(() -> new com.openisle.exception.NotFoundException("Post not found"));
-    }
-
-    @Transactional
-    public PollPost votePoll(Long postId, String username, java.util.List<Integer> optionIndices) {
-        PollPost post = pollPostRepository.findById(postId)
-                .orElseThrow(() -> new com.openisle.exception.NotFoundException("Post not found"));
-        if (post.getEndTime() != null && post.getEndTime().isBefore(LocalDateTime.now())) {
-            throw new IllegalStateException("Poll has ended");
-        }
-        User user = userRepository.findByUsername(username)
-                .orElseThrow(() -> new com.openisle.exception.NotFoundException("User not found"));
-        if (post.getParticipants().contains(user)) {
-            throw new IllegalArgumentException("User already voted");
-        }
-        if (optionIndices == null || optionIndices.isEmpty()) {
-            throw new IllegalArgumentException("No options selected");
-        }
-        java.util.Set<Integer> unique = new java.util.HashSet<>(optionIndices);
-        for (int optionIndex : unique) {
-            if (optionIndex < 0 || optionIndex >= post.getOptions().size()) {
-                throw new IllegalArgumentException("Invalid option");
-            }
-        }
-        post.getParticipants().add(user);
-        for (int optionIndex : unique) {
-            post.getVotes().merge(optionIndex, 1, Integer::sum);
-            PollVote vote = new PollVote();
-            vote.setPost(post);
-            vote.setUser(user);
-            vote.setOptionIndex(optionIndex);
-            pollVoteRepository.save(vote);
-        }
-        PollPost saved = pollPostRepository.save(post);
-        if (post.getAuthor() != null && !post.getAuthor().getId().equals(user.getId())) {
-            notificationService.createNotification(post.getAuthor(), NotificationType.POLL_VOTE, post, null, null, user, null, null);
-        }
-        return saved;
-    }
-
-    @Transactional
-    public void finalizePoll(Long postId) {
-        scheduledFinalizations.remove(postId);
-        pollPostRepository.findById(postId).ifPresent(pp -> {
-            if (pp.isResultAnnounced()) {
-                return;
-            }
-            pp.setResultAnnounced(true);
-            pollPostRepository.save(pp);
-            if (pp.getAuthor() != null) {
-                notificationService.createNotification(pp.getAuthor(), NotificationType.POLL_RESULT_OWNER, pp, null, null, null, null, null);
-            }
-            for (User participant : pp.getParticipants()) {
-                notificationService.createNotification(participant, NotificationType.POLL_RESULT_PARTICIPANT, pp, null, null, null, null, null);
-            }
-        });
-    }
-
     @Transactional
     public void finalizeLottery(Long postId) {
         log.info("start to finalizeLottery for {}", postId);
@@ -374,16 +277,14 @@ public class PostService {
             lp.setWinners(winners);
             lotteryPostRepository.save(lp);
             for (User w : winners) {
-                if (w.getEmail() != null &&
-                        !w.getDisabledEmailNotificationTypes().contains(NotificationType.LOTTERY_WIN)) {
+                if (w.getEmail() != null) {
                     emailSender.sendEmail(w.getEmail(), "你中奖了", "恭喜你在抽奖贴 \"" + lp.getTitle() + "\" 中获奖");
                 }
                 notificationService.createNotification(w, NotificationType.LOTTERY_WIN, lp, null, null, lp.getAuthor(), null, null);
                 notificationService.sendCustomPush(w, "你中奖了", String.format("%s/posts/%d", websiteUrl, lp.getId()));
             }
             if (lp.getAuthor() != null) {
-                if (lp.getAuthor().getEmail() != null &&
-                        !lp.getAuthor().getDisabledEmailNotificationTypes().contains(NotificationType.LOTTERY_DRAW)) {
+                if (lp.getAuthor().getEmail() != null) {
                     emailSender.sendEmail(lp.getAuthor().getEmail(), "抽奖已开奖", "您的抽奖贴 \"" + lp.getTitle() + "\" 已开奖");
                 }
                 notificationService.createNotification(lp.getAuthor(), NotificationType.LOTTERY_DRAW, lp, null, null, null, null, null);

backend/src/main/java/com/openisle/service/ReactionService.java

@@ -42,7 +42,6 @@ public class ReactionService {
         java.util.Optional<Reaction> existing =
                 reactionRepository.findByUserAndPostAndType(user, post, type);
         if (existing.isPresent()) {
-            notificationService.deleteReactionNotification(user, post, null, type);
             reactionRepository.delete(existing.get());
             return null;
         }
@@ -66,7 +65,6 @@ public class ReactionService {
         java.util.Optional<Reaction> existing =
                 reactionRepository.findByUserAndCommentAndType(user, comment, type);
         if (existing.isPresent()) {
-            notificationService.deleteReactionNotification(user, null, comment, type);
             reactionRepository.delete(existing.get());
             return null;
         }

backend/src/main/java/com/openisle/service/TagService.java

@@ -1,12 +1,9 @@
 package com.openisle.service;
 
-import com.openisle.config.CachingConfig;
 import com.openisle.model.Tag;
 import com.openisle.model.User;
 import com.openisle.repository.TagRepository;
 import com.openisle.repository.UserRepository;
-import org.springframework.cache.annotation.CacheEvict;
-import org.springframework.cache.annotation.Cacheable;
 import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Pageable;
 import lombok.RequiredArgsConstructor;
@@ -21,7 +18,6 @@ public class TagService {
     private final TagValidator tagValidator;
     private final UserRepository userRepository;
 
-    @CacheEvict(value = CachingConfig.TAG_CACHE_NAME, allEntries = true)
     public Tag createTag(String name, String description, String icon, String smallIcon, boolean approved, String creatorUsername) {
         tagValidator.validate(name);
         Tag tag = new Tag();
@@ -46,7 +42,6 @@ public class TagService {
         return createTag(name, description, icon, smallIcon, true, null);
     }
 
-    @CacheEvict(value = CachingConfig.TAG_CACHE_NAME, allEntries = true)
     public Tag updateTag(Long id, String name, String description, String icon, String smallIcon) {
         Tag tag = tagRepository.findById(id)
                 .orElseThrow(() -> new IllegalArgumentException("Tag not found"));
@@ -66,7 +61,6 @@ public class TagService {
         return tagRepository.save(tag);
     }
 
-    @CacheEvict(value = CachingConfig.TAG_CACHE_NAME, allEntries = true)
     public void deleteTag(Long id) {
         tagRepository.deleteById(id);
     }
@@ -91,20 +85,10 @@ public class TagService {
         return tagRepository.findByApprovedTrue();
     }
 
-    /**
-     * 该方法每次首页加载都会访问，加入缓存
-     * @param keyword
-     * @return
-     */
-    @Cacheable(
-            value = CachingConfig.TAG_CACHE_NAME,
-            key = "'searchTags:' + (#keyword ?: '')"//keyword为null的场合返回空
-    )
     public List<Tag> searchTags(String keyword) {
         if (keyword == null || keyword.isBlank()) {
             return tagRepository.findByApprovedTrue();
         }
-
         return tagRepository.findByNameContainingIgnoreCaseAndApprovedTrue(keyword);
     }
 

backend/src/main/java/com/openisle/service/TelegramAuthService.java

@@ -1,102 +0,0 @@
-package com.openisle.service;
-
-import com.openisle.dto.TelegramLoginRequest;
-import com.openisle.model.RegisterMode;
-import com.openisle.model.Role;
-import com.openisle.model.User;
-import com.openisle.repository.UserRepository;
-import lombok.RequiredArgsConstructor;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.stereotype.Service;
-
-import javax.crypto.Mac;
-import javax.crypto.spec.SecretKeySpec;
-import java.nio.charset.StandardCharsets;
-import java.security.MessageDigest;
-import java.util.*;
-
-@Service
-@RequiredArgsConstructor
-public class TelegramAuthService {
-    private final UserRepository userRepository;
-    private final AvatarGenerator avatarGenerator;
-
-    @Value("${telegram.bot-token:}")
-    private String botToken;
-
-    public Optional<AuthResult> authenticate(TelegramLoginRequest req, RegisterMode mode, boolean viaInvite) {
-        try {
-            if (botToken == null || botToken.isEmpty()) {
-                return Optional.empty();
-            }
-            String dataCheckString = buildDataCheckString(req);
-            MessageDigest md = MessageDigest.getInstance("SHA-256");
-            byte[] secretKey = md.digest(botToken.getBytes(StandardCharsets.UTF_8));
-            Mac mac = Mac.getInstance("HmacSHA256");
-            mac.init(new SecretKeySpec(secretKey, "HmacSHA256"));
-            byte[] hash = mac.doFinal(dataCheckString.getBytes(StandardCharsets.UTF_8));
-            String hex = bytesToHex(hash);
-            if (!hex.equalsIgnoreCase(req.getHash())) {
-                return Optional.empty();
-            }
-            String username = req.getUsername();
-            String email = (username != null ? username : req.getId()) + "@telegram.org";
-            String avatar = req.getPhotoUrl();
-            return Optional.of(processUser(email, username, avatar, mode, viaInvite));
-        } catch (Exception e) {
-            return Optional.empty();
-        }
-    }
-
-    private String buildDataCheckString(TelegramLoginRequest req) {
-        List<String> data = new ArrayList<>();
-        if (req.getAuthDate() != null) data.add("auth_date=" + req.getAuthDate());
-        if (req.getFirstName() != null) data.add("first_name=" + req.getFirstName());
-        if (req.getId() != null) data.add("id=" + req.getId());
-        if (req.getLastName() != null) data.add("last_name=" + req.getLastName());
-        if (req.getPhotoUrl() != null) data.add("photo_url=" + req.getPhotoUrl());
-        if (req.getUsername() != null) data.add("username=" + req.getUsername());
-        Collections.sort(data);
-        return String.join("\n", data);
-    }
-
-    private String bytesToHex(byte[] bytes) {
-        StringBuilder sb = new StringBuilder();
-        for (byte b : bytes) {
-            sb.append(String.format("%02x", b));
-        }
-        return sb.toString();
-    }
-
-    private AuthResult processUser(String email, String username, String avatar, RegisterMode mode, boolean viaInvite) {
-        Optional<User> existing = userRepository.findByEmail(email);
-        if (existing.isPresent()) {
-            User user = existing.get();
-            if (!user.isVerified()) {
-                user.setVerified(true);
-                user.setVerificationCode(null);
-                userRepository.save(user);
-            }
-            return new AuthResult(user, false);
-        }
-        String baseUsername = username != null ? username : email.split("@")[0];
-        String finalUsername = baseUsername;
-        int suffix = 1;
-        while (userRepository.findByUsername(finalUsername).isPresent()) {
-            finalUsername = baseUsername + suffix++;
-        }
-        User user = new User();
-        user.setUsername(finalUsername);
-        user.setEmail(email);
-        user.setPassword("");
-        user.setRole(Role.USER);
-        user.setVerified(true);
-        user.setApproved(mode == RegisterMode.DIRECT || viaInvite);
-        if (avatar != null) {
-            user.setAvatar(avatar);
-        } else {
-            user.setAvatar(avatarGenerator.generate(finalUsername));
-        }
-        return new AuthResult(userRepository.save(user), true);
-    }
-}

backend/src/main/resources/application.properties

@@ -1,6 +1,3 @@
-# for spring boot
-server.port=${SERVER_PORT:8080}
-
 # for mysql
 logging.level.root=${LOG_LEVEL:INFO}
 logging.level.com.openisle.service.CosImageUploader=DEBUG
@@ -9,11 +6,6 @@ spring.datasource.username=${MYSQL_USER:root}
 spring.datasource.password=${MYSQL_PASSWORD:password}
 spring.jpa.hibernate.ddl-auto=update
 
-# for redis
-spring.data.redis.host=${REDIS_HOST:localhost}
-spring.data.redis.port=${REDIS_PORT:6379}
-spring.data.redis.database=${REDIS_DATABASE:0}
-
 # for jwt
 app.jwt.secret=${JWT_SECRET:jwt_sec}
 app.jwt.reason-secret=${JWT_REASON_SECRET:jwt_reason_sec}
@@ -77,8 +69,6 @@ discord.client-secret=${DISCORD_CLIENT_SECRET:}
 # Twitter OAuth configuration
 twitter.client-id=${TWITTER_CLIENT_ID:}
 twitter.client-secret=${TWITTER_CLIENT_SECRET:}
-# Telegram login configuration
-telegram.bot-token=${TELEGRAM_BOT_TOKEN:}
 # OpenAI configuration
 openai.api-key=${OPENAI_API_KEY:}
 openai.model=${OPENAI_MODEL:gpt-4o}
@@ -91,23 +81,3 @@ app.website-url=${WEBSITE_URL:https://www.open-isle.com}
 # Web push configuration
 app.webpush.public-key=${WEBPUSH_PUBLIC_KEY:}
 app.webpush.private-key=${WEBPUSH_PRIVATE_KEY:}
-
-# RabbitMQ Configuration
-spring.rabbitmq.host=${RABBITMQ_HOST:localhost}
-spring.rabbitmq.port=${RABBITMQ_PORT:5672}
-spring.rabbitmq.username=${RABBITMQ_USERNAME:guest}
-spring.rabbitmq.password=${RABBITMQ_PASSWORD:guest}
-
-# RabbitMQ 队列配置 - 修改为非持久化以匹配现有队列
-rabbitmq.queue.durable=true
-rabbitmq.sharding.enabled=true
-
-# springdoc-openapi-starter-webmvc-api
-# see https://springdoc.org/#springdoc-openapi-core-properties
-springdoc.api-docs.path=/api/v3/api-docs
-springdoc.api-docs.enabled=true
-springdoc.info.title=OpenIsle
-springdoc.info.description=OpenIsle Open API Documentation
-springdoc.info.version=0.0.1
-springdoc.info.scheme=Bearer
-springdoc.info.header=Authorization

backend/src/main/resources/db/init/init_script.sql

@@ -1,81 +0,0 @@
--- 2025-09-02
--- 本地化开发，初始化脚本
--- 抽奖的时候奖品图片是必须的，把相关代码注释掉即可跳过check
-
--- 设置字符集和排序规则
-SET NAMES utf8;
-SET CHARACTER SET utf8;
-SET collation_connection = utf8_general_ci;
-
--- 创建 users 表（如果不存在）
-CREATE TABLE IF NOT EXISTS `users` (
-	`id` bigint NOT NULL AUTO_INCREMENT,
-	`approved` bit(1) DEFAULT NULL,
-	`avatar` varchar(255) DEFAULT NULL,
-	`created_at` datetime(6) DEFAULT NULL,
-	`display_medal` varchar(255) DEFAULT NULL,
-	`email` varchar(255) NOT NULL,
-	`experience` int DEFAULT NULL,
-	`introduction` text,
-	`password` varchar(255) NOT NULL,
-	`password_reset_code` varchar(255) DEFAULT NULL,
-	`point` int DEFAULT NULL,
-	`register_reason` text,
-	`role` varchar(20) DEFAULT 'USER',
-	`username` varchar(50) NOT NULL,
-	`verification_code` varchar(255) DEFAULT NULL,
-	`verified` bit(1) DEFAULT NULL,
-	PRIMARY KEY (`id`),
-	UNIQUE KEY `UK_users_email` (`email`),
-	UNIQUE KEY `UK_users_username` (`username`)
-);
-
--- 清空users表
-DELETE FROM `users`;
--- 插入用户，两个普通用户，一个管理员
--- username:admin/user1/user2 password:123321
-INSERT INTO `users` (`id`, `approved`, `avatar`, `created_at`, `display_medal`, `email`, `experience`, `introduction`, `password`, `password_reset_code`, `point`, `register_reason`, `role`, `username`, `verification_code`, `verified`) VALUES
-	(1, b'1', '', '2025-09-01 16:08:17.426430', 'PIONEER', 'adminmail@openisle.com', 70, NULL, '$2a$10$m.lLbT3wFtnzFMi7JqN17ecv/dzH704WzU1f/xvQ0nVz4XxTXPT0K', NULL, 110, '测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试', 'ADMIN', 'admin', NULL, b'1'),
-	(2, b'1', '', '2025-09-03 16:08:17.426430', 'PIONEER', 'usermail2@openisle.com', 70, NULL, '$2a$10$m.lLbT3wFtnzFMi7JqN17ecv/dzH704WzU1f/xvQ0nVz4XxTXPT0K', NULL, 110, '测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试', 'USER', 'user1', NULL, b'1'),
-	(3, b'1', '', '2025-09-02 17:21:21.617666', 'PIONEER', 'usermail1@openisle.com', 40, NULL, '$2a$10$m.lLbT3wFtnzFMi7JqN17ecv/dzH704WzU1f/xvQ0nVz4XxTXPT0K', NULL, 40, '测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试', 'USER', 'user2', NULL, b'1');
-
--- 创建 tags 表（如果不存在）
-CREATE TABLE IF NOT EXISTS `tags` (
-  `id` bigint NOT NULL AUTO_INCREMENT,
-  `approved` bit(1) DEFAULT NULL,
-  `created_at` datetime(6) DEFAULT NULL,
-  `description` text,
-  `icon` varchar(255) DEFAULT NULL,
-  `name` varchar(50) NOT NULL,
-  `small_icon` varchar(255) DEFAULT NULL,
-  `creator_id` bigint DEFAULT NULL,
-  PRIMARY KEY (`id`),
-  UNIQUE KEY `UK_tags_name` (`name`),
-  KEY `FK_tags_creator` (`creator_id`),
-  CONSTRAINT `FK_tags_creator` FOREIGN KEY (`creator_id`) REFERENCES `users` (`id`)
-);
--- 清空tags表
-DELETE FROM `tags`;
--- 插入标签，三个测试用标签
-INSERT INTO `tags` (`id`, `approved`, `created_at`, `description`, `icon`, `name`, `small_icon`, `creator_id`) VALUES
-	(1, b'1', '2025-09-02 10:51:56.000000', '测试用标签1', NULL, '测试用标签1', NULL, NULL),
-	(2, b'1', '2025-09-02 10:51:56.000000', '测试用标签2', NULL, '测试用标签2', NULL, NULL),
-	(3, b'1', '2025-09-02 10:51:56.000000', '测试用标签3', NULL, '测试用标签3', NULL, NULL);
-
--- 创建 categories 表（如果不存在）
-CREATE TABLE IF NOT EXISTS `categories` (
-  `id` bigint NOT NULL AUTO_INCREMENT,
-  `description` text,
-  `icon` varchar(255) DEFAULT NULL,
-  `name` varchar(50) NOT NULL,
-  `small_icon` varchar(255) DEFAULT NULL,
-  PRIMARY KEY (`id`),
-  UNIQUE KEY `UK_categories_name` (`name`)
-);
--- 清空categories表
-DELETE FROM `categories`;
--- 插入分类，三个测试用分类
-INSERT INTO `categories` (`id`, `description`, `icon`, `name`, `small_icon`) VALUES
-	(1, '测试用分类1', '1', '测试用分类1', NULL),
-	(2, '测试用分类2', '2', '测试用分类2', NULL),
-	(3, '测试用分类3', '3', '测试用分类3', NULL);

backend/src/main/resources/db/migration/V4__add_logical_delete_support.sql

@@ -1,11 +0,0 @@
--- Add logical delete support for comments and point_histories tables
-
--- Add deleted_at column to comments table
-ALTER TABLE comments ADD COLUMN deleted_at DATETIME(6) NULL;
-
--- Add deleted_at column to point_histories table  
-ALTER TABLE point_histories ADD COLUMN deleted_at DATETIME(6) NULL;
-
--- Add index for better performance on logical delete queries
-CREATE INDEX idx_comments_deleted_at ON comments(deleted_at);
-CREATE INDEX idx_point_histories_deleted_at ON point_histories(deleted_at);

backend/src/test/java/com/openisle/controller/PointHistoryControllerTest.java

@@ -1,65 +0,0 @@
-package com.openisle.controller;
-
-import com.openisle.config.CustomAccessDeniedHandler;
-import com.openisle.config.SecurityConfig;
-import com.openisle.service.PointService;
-import com.openisle.mapper.PointHistoryMapper;
-import com.openisle.service.JwtService;
-import com.openisle.repository.UserRepository;
-import com.openisle.model.User;
-import com.openisle.model.Role;
-import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
-import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
-import org.springframework.boot.test.mock.mockito.MockBean;
-import org.springframework.context.annotation.Import;
-import org.springframework.test.web.servlet.MockMvc;
-
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-
-import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
-
-@WebMvcTest(PointHistoryController.class)
-@AutoConfigureMockMvc
-@Import({SecurityConfig.class, CustomAccessDeniedHandler.class})
-class PointHistoryControllerTest {
-    @Autowired
-    private MockMvc mockMvc;
-
-    @MockBean
-    private JwtService jwtService;
-    @MockBean
-    private UserRepository userRepository;
-    @MockBean
-    private PointService pointService;
-    @MockBean
-    private PointHistoryMapper pointHistoryMapper;
-
-    @Test
-    void trendReturnsSeries() throws Exception {
-        Mockito.when(jwtService.validateAndGetSubject("token")).thenReturn("user");
-        User user = new User();
-        user.setUsername("user");
-        user.setPassword("p");
-        user.setEmail("u@example.com");
-        user.setRole(Role.USER);
-        Mockito.when(userRepository.findByUsername("user")).thenReturn(Optional.of(user));
-        List<Map<String, Object>> data = List.of(
-                Map.of("date", java.time.LocalDate.now().minusDays(1).toString(), "value", 100),
-                Map.of("date", java.time.LocalDate.now().toString(), "value", 110)
-        );
-        Mockito.when(pointService.trend(Mockito.eq("user"), Mockito.anyInt())).thenReturn(data);
-
-        mockMvc.perform(get("/api/point-histories/trend").param("days", "2")
-                        .header("Authorization", "Bearer token"))
-                .andExpect(status().isOk())
-                .andExpect(jsonPath("$[0].value").value(100))
-                .andExpect(jsonPath("$[1].value").value(110));
-    }
-}

backend/src/test/java/com/openisle/controller/PostControllerTest.java

@@ -76,7 +76,7 @@ class PostControllerTest {
         post.setTags(Set.of(tag));
 
         when(postService.createPost(eq("alice"), eq(1L), eq("t"), eq("c"), eq(List.of(1L)),
-                isNull(), isNull(), isNull(), isNull(), isNull(), isNull(), isNull(), isNull(), isNull())).thenReturn(post);
+                isNull(), isNull(), isNull(), isNull(), isNull(), isNull(), isNull())).thenReturn(post);
         when(postService.viewPost(eq(1L), any())).thenReturn(post);
         when(commentService.getCommentsForPost(eq(1L), any())).thenReturn(List.of());
         when(commentService.getParticipants(anyLong(), anyInt())).thenReturn(List.of());
@@ -187,7 +187,7 @@ class PostControllerTest {
                 .andExpect(status().isBadRequest());
 
         verify(postService, never()).createPost(any(), any(), any(), any(), any(),
-                any(), any(), any(), any(), any(), any(), any(), any(), any());
+                any(), any(), any(), any(), any(), any(), any());
     }
 
     @Test

backend/src/test/java/com/openisle/service/CommentServiceTest.java

@@ -6,8 +6,6 @@ import com.openisle.repository.UserRepository;
 import com.openisle.repository.ReactionRepository;
 import com.openisle.repository.CommentSubscriptionRepository;
 import com.openisle.repository.NotificationRepository;
-import com.openisle.repository.PointHistoryRepository;
-import com.openisle.service.PointService;
 import com.openisle.exception.RateLimitException;
 import org.junit.jupiter.api.Test;
 
@@ -26,12 +24,10 @@ class CommentServiceTest {
         ReactionRepository reactionRepo = mock(ReactionRepository.class);
         CommentSubscriptionRepository subRepo = mock(CommentSubscriptionRepository.class);
         NotificationRepository nRepo = mock(NotificationRepository.class);
-        PointHistoryRepository pointHistoryRepo = mock(PointHistoryRepository.class);
-        PointService pointService = mock(PointService.class);
         ImageUploader imageUploader = mock(ImageUploader.class);
 
         CommentService service = new CommentService(commentRepo, postRepo, userRepo,
-                notifService, subService, reactionRepo, subRepo, nRepo, pointHistoryRepo, pointService, imageUploader);
+                notifService, subService, reactionRepo, subRepo, nRepo, imageUploader);
 
         when(commentRepo.countByAuthorAfter(eq("alice"), any())).thenReturn(3L);
 

backend/src/test/java/com/openisle/service/PostServiceTest.java

@@ -22,8 +22,6 @@ class PostServiceTest {
         CategoryRepository catRepo = mock(CategoryRepository.class);
         TagRepository tagRepo = mock(TagRepository.class);
         LotteryPostRepository lotteryRepo = mock(LotteryPostRepository.class);
-        PollPostRepository pollPostRepo = mock(PollPostRepository.class);
-        PollVoteRepository pollVoteRepo = mock(PollVoteRepository.class);
         NotificationService notifService = mock(NotificationService.class);
         SubscriptionService subService = mock(SubscriptionService.class);
         CommentService commentService = mock(CommentService.class);
@@ -39,7 +37,7 @@ class PostServiceTest {
         PointService pointService = mock(PointService.class);
 
         PostService service = new PostService(postRepo, userRepo, catRepo, tagRepo, lotteryRepo,
-                pollPostRepo, pollVoteRepo, notifService, subService, commentService, commentRepo,
+                notifService, subService, commentService, commentRepo,
                 reactionRepo, subRepo, notificationRepo, postReadService,
                 imageUploader, taskScheduler, emailSender, context, pointService, PublishMode.DIRECT);
         when(context.getBean(PostService.class)).thenReturn(service);
@@ -71,8 +69,6 @@ class PostServiceTest {
         CategoryRepository catRepo = mock(CategoryRepository.class);
         TagRepository tagRepo = mock(TagRepository.class);
         LotteryPostRepository lotteryRepo = mock(LotteryPostRepository.class);
-        PollPostRepository pollPostRepo = mock(PollPostRepository.class);
-        PollVoteRepository pollVoteRepo = mock(PollVoteRepository.class);
         NotificationService notifService = mock(NotificationService.class);
         SubscriptionService subService = mock(SubscriptionService.class);
         CommentService commentService = mock(CommentService.class);
@@ -88,7 +84,7 @@ class PostServiceTest {
         PointService pointService = mock(PointService.class);
 
         PostService service = new PostService(postRepo, userRepo, catRepo, tagRepo, lotteryRepo,
-                pollPostRepo, pollVoteRepo, notifService, subService, commentService, commentRepo,
+                notifService, subService, commentService, commentRepo,
                 reactionRepo, subRepo, notificationRepo, postReadService,
                 imageUploader, taskScheduler, emailSender, context, pointService, PublishMode.DIRECT);
         when(context.getBean(PostService.class)).thenReturn(service);
@@ -126,8 +122,6 @@ class PostServiceTest {
         CategoryRepository catRepo = mock(CategoryRepository.class);
         TagRepository tagRepo = mock(TagRepository.class);
         LotteryPostRepository lotteryRepo = mock(LotteryPostRepository.class);
-        PollPostRepository pollPostRepo = mock(PollPostRepository.class);
-        PollVoteRepository pollVoteRepo = mock(PollVoteRepository.class);
         NotificationService notifService = mock(NotificationService.class);
         SubscriptionService subService = mock(SubscriptionService.class);
         CommentService commentService = mock(CommentService.class);
@@ -143,7 +137,7 @@ class PostServiceTest {
         PointService pointService = mock(PointService.class);
 
         PostService service = new PostService(postRepo, userRepo, catRepo, tagRepo, lotteryRepo,
-                pollPostRepo, pollVoteRepo, notifService, subService, commentService, commentRepo,
+                notifService, subService, commentService, commentRepo,
                 reactionRepo, subRepo, notificationRepo, postReadService,
                 imageUploader, taskScheduler, emailSender, context, pointService, PublishMode.DIRECT);
         when(context.getBean(PostService.class)).thenReturn(service);
@@ -152,7 +146,7 @@ class PostServiceTest {
 
         assertThrows(RateLimitException.class,
                 () -> service.createPost("alice", 1L, "t", "c", List.of(1L),
-                        null, null, null, null, null, null, null, null, null));
+                        null, null, null, null, null, null, null));
     }
 
     @Test
@@ -162,8 +156,6 @@ class PostServiceTest {
         CategoryRepository catRepo = mock(CategoryRepository.class);
         TagRepository tagRepo = mock(TagRepository.class);
         LotteryPostRepository lotteryRepo = mock(LotteryPostRepository.class);
-        PollPostRepository pollPostRepo = mock(PollPostRepository.class);
-        PollVoteRepository pollVoteRepo = mock(PollVoteRepository.class);
         NotificationService notifService = mock(NotificationService.class);
         SubscriptionService subService = mock(SubscriptionService.class);
         CommentService commentService = mock(CommentService.class);
@@ -179,7 +171,7 @@ class PostServiceTest {
         PointService pointService = mock(PointService.class);
 
         PostService service = new PostService(postRepo, userRepo, catRepo, tagRepo, lotteryRepo,
-                pollPostRepo, pollVoteRepo, notifService, subService, commentService, commentRepo,
+                notifService, subService, commentService, commentRepo,
                 reactionRepo, subRepo, notificationRepo, postReadService,
                 imageUploader, taskScheduler, emailSender, context, pointService, PublishMode.DIRECT);
         when(context.getBean(PostService.class)).thenReturn(service);

docker/.env.example

@@ -1,11 +0,0 @@
-# 前端访问端口
-SERVER_PORT=8080
-
-# MySQL 配置
-MYSQL_ROOT_PASSWORD=toor
-
-# 会覆盖 `open-isle.env`
-MYSQL_PORT=3306
-MYSQL_DATABASE=openisle
-MYSQL_USER=<数据库用户名>
-MYSQL_PASSWORD=<数据库密码>

docker/docker-compose.yaml

@@ -1,45 +0,0 @@
-services:
-  # MySQL service
-  mysql:
-    image: mysql:8.0
-    container_name: openisle-mysql
-    restart: always
-    env_file:
-      - ../backend/open-isle.env
-      - ./.env
-    ports:
-      - "${MYSQL_PORT}:3306"
-    volumes:
-      - mysql-data:/var/lib/mysql
-      - ../backend/src/main/resources/db/init:/docker-entrypoint-initdb.d
-    networks:
-      - openisle-network
-
-  # Java spring boot service
-  springboot:
-    image: maven:3.9-eclipse-temurin-17
-    container_name: openisle-springboot
-    working_dir: /app
-    env_file:
-      - ../backend/open-isle.env
-      - ./.env
-    environment:
-      - MYSQL_URL=jdbc:mysql://mysql:${MYSQL_PORT}/${MYSQL_DATABASE}?useUnicode=yes&characterEncoding=UTF-8&useInformationSchema=true&useSSL=false&serverTimezone=UTC&allowPublicKeyRetrieval=true
-    ports:
-      - "${SERVER_PORT}:8080"
-    volumes:
-      - ../backend:/app
-      - maven-repo:/root/.m2
-    depends_on:
-      - mysql
-    command: mvn clean spring-boot:run -Dmaven.test.skip=true
-    networks:
-      - openisle-network
-
-networks:
-  openisle-network:
-    driver: bridge
-
-volumes:
-  mysql-data:
-  maven-repo:

frontend_nuxt/.env.dev.example

@@ -1,10 +0,0 @@
-; 本地部署后端
-NUXT_PUBLIC_API_BASE_URL=https://127.0.0.1:8081
-NUXT_PUBLIC_WEBSOCKET_URL=https://127.0.0.1:8082
-NUXT_PUBLIC_WEBSITE_BASE_URL=http://localhost:3000
-
-NUXT_PUBLIC_GOOGLE_CLIENT_ID=777830451304-nt8afkkap18gui4f9entcha99unal744.apps.googleusercontent.com
-NUXT_PUBLIC_GITHUB_CLIENT_ID=Ov23liVkO1NPAX5JyWxJ
-NUXT_PUBLIC_DISCORD_CLIENT_ID=1394985417044000779
-NUXT_PUBLIC_TWITTER_CLIENT_ID=ZTRTU05KSk9KTTJrTTdrVC1tc1E6MTpjaQ
-NUXT_PUBLIC_TELEGRAM_BOT_ID=8450237135

frontend_nuxt/.env.example

@@ -3,17 +3,13 @@
 ; 预发环境后端
 ; NUXT_PUBLIC_API_BASE_URL=https://staging.open-isle.com
 ; 生产环境后端
-NUXT_PUBLIC_API_BASE_URL=https://open-isle.com
-
-; 生产环境ws后端
-NUXT_PUBLIC_WEBSOCKET_URL=https://open-isle.com/websocket
+NUXT_PUBLIC_API_BASE_URL=https://www.open-isle.com
 
 ; 预发环境
 ; NUXT_PUBLIC_WEBSITE_BASE_URL=https://staging.open-isle.com
 ; 正式环境/生产环境
-NUXT_PUBLIC_WEBSITE_BASE_URL=https://open-isle.com
+NUXT_PUBLIC_WEBSITE_BASE_URL=https://www.open-isle.com
 NUXT_PUBLIC_GOOGLE_CLIENT_ID=777830451304-nt8afkkap18gui4f9entcha99unal744.apps.googleusercontent.com
 NUXT_PUBLIC_GITHUB_CLIENT_ID=Ov23liVkO1NPAX5JyWxJ
 NUXT_PUBLIC_DISCORD_CLIENT_ID=1394985417044000779
 NUXT_PUBLIC_TWITTER_CLIENT_ID=ZTRTU05KSk9KTTJrTTdrVC1tc1E6MTpjaQ
-NUXT_PUBLIC_TELEGRAM_BOT_ID=8450237135

frontend_nuxt/.env.production.example

@@ -1,13 +0,0 @@
-
-; 生产环境后端
-NUXT_PUBLIC_API_BASE_URL=https://open-isle.com
-; 正式环境/生产环境
-NUXT_PUBLIC_WEBSITE_BASE_URL=https://open-isle.com
-; 生产环境ws后端
-NUXT_PUBLIC_WEBSOCKET_URL=https://open-isle.com/websocket
-
-NUXT_PUBLIC_GOOGLE_CLIENT_ID=777830451304-nt8afkkap18gui4f9entcha99unal744.apps.googleusercontent.com
-NUXT_PUBLIC_GITHUB_CLIENT_ID=Ov23liVkO1NPAX5JyWxJ
-NUXT_PUBLIC_DISCORD_CLIENT_ID=1394985417044000779
-NUXT_PUBLIC_TWITTER_CLIENT_ID=ZTRTU05KSk9KTTJrTTdrVC1tc1E6MTpjaQ
-NUXT_PUBLIC_TELEGRAM_BOT_ID=8450237135

frontend_nuxt/.env.staging.example

@@ -1,17 +1,16 @@
 ; 本地部署后端
 ; NUXT_PUBLIC_API_BASE_URL=https://127.0.0.1:8081
-
 ; 预发环境后端
 NUXT_PUBLIC_API_BASE_URL=https://staging.open-isle.com
-
-; 预发环境ws后端
-NUXT_PUBLIC_WEBSOCKET_URL=https://staging.open-isle.com/websocket
+; 生产环境后端
+; NUXT_PUBLIC_API_BASE_URL=https://www.open-isle.com
 
 ; 预发环境
 NUXT_PUBLIC_WEBSITE_BASE_URL=https://staging.open-isle.com
+; 正式环境/生产环境
+; NUXT_PUBLIC_WEBSITE_BASE_URL=https://www.open-isle.com
 
 NUXT_PUBLIC_GOOGLE_CLIENT_ID=777830451304-nt8afkkap18gui4f9entcha99unal744.apps.googleusercontent.com
 NUXT_PUBLIC_GITHUB_CLIENT_ID=Ov23liVkO1NPAX5JyWxJ
 NUXT_PUBLIC_DISCORD_CLIENT_ID=1394985417044000779
 NUXT_PUBLIC_TWITTER_CLIENT_ID=ZTRTU05KSk9KTTJrTTdrVC1tc1E6MTpjaQ
-NUXT_PUBLIC_TELEGRAM_BOT_ID=8450237135

frontend_nuxt/app.vue

@@ -58,7 +58,6 @@ const hideMenu = computed(() => {
     '/discord-callback',
     '/forgot-password',
     '/google-callback',
-    '/telegram-callback',
   ].includes(useRoute().path)
 })
 
@@ -139,7 +138,7 @@ const goToNewPost = () => {
   height: 60px;
   border-radius: 50%;
   position: fixed;
-  bottom: 70px;
+  bottom: 40px;
   right: 20px;
   font-size: 20px;
   cursor: pointer;

frontend_nuxt/assets/global.css

@@ -18,8 +18,8 @@
   --background-color-blur: rgba(255, 255, 255, 0.57);
   --menu-border-color: lightgray;
   --normal-border-color: lightgray;
-  --menu-selected-background-color: rgba(242, 242, 242, 0.884);
-  --menu-text-color: rgb(99, 99, 99);
+  --menu-selected-background-color: rgba(228, 228, 228, 0.884);
+  --menu-text-color: black;
   --scroller-background-color: rgba(130, 175, 180, 0.5);
   /* --normal-background-color: rgb(241, 241, 241); */
   --normal-background-color: white;
@@ -27,21 +27,13 @@
   --code-highlight-background-color: rgb(241, 241, 241);
   --login-background-color: rgb(248, 248, 248);
   --login-background-color-hover: #e0e0e0;
-  --text-color: rgb(70, 70, 70);
+  --text-color: black;
   --blockquote-text-color: #6a737d;
   --menu-width: 200px;
   --page-max-width: 1400px;
   --page-max-width-mobile: 900px;
   --article-info-background-color: #f0f0f0;
   --activity-card-background-color: #fafafa;
-  --poll-option-button-background-color: rgb(218, 218, 218);
-  --telegram-bg: #caedff74;
-  --telegram-bg-hover: #67a2c088;
-  --twitter-bg: rgb(68, 68, 68);
-  --twitter-bg-hover: rgb(91, 91, 91);
-  --discord-bg: #5865f258;
-  --discord-bg-hover: #5865f2b1;
-  --featured-color: rgb(255, 170, 0);
 }
 
 [data-theme='dark'] {
@@ -58,7 +50,7 @@
   --menu-border-color: #555;
   --normal-border-color: #555;
   --menu-selected-background-color: rgba(255, 255, 255, 0.1);
-  --menu-text-color: rgb(173, 173, 173);
+  --menu-text-color: white;
   /* --normal-background-color: #000000; */
   --normal-background-color: #333;
   --lottery-background-color: #4e4e4e;
@@ -69,7 +61,6 @@
   --blockquote-text-color: #999;
   --article-info-background-color: #747373;
   --activity-card-background-color: #585858;
-  --poll-option-button-background-color: #3a3a3a;
 }
 
 :root[data-frosted='off'] {
@@ -84,7 +75,7 @@
 body {
   margin: 0;
   padding: 0;
-  font-family: 'WenQuanYi Micro Hei', 'Helvetica Neue', Arial, sans-serif;
+  font-family: 'Roboto', sans-serif;
   background-color: var(--normal-background-color);
   color: var(--text-color);
   /* 禁止滚动 */
@@ -100,7 +91,7 @@ body {
 
 .vditor-toolbar--pin {
   top: calc(var(--header-height) + 1px) !important;
-  z-index: 20;
+  z-index: 2000;
 }
 
 .vditor-panel {
@@ -151,7 +142,6 @@ body {
 .info-content-text video {
   max-width: 100%;
 }
-
 .info-content-text {
   word-break: break-word;
   max-width: 100%;
@@ -162,9 +152,6 @@ body {
   padding-left: 1em;
   border-left: 4px solid #d0d7de;
   color: var(--blockquote-text-color);
-  background-color: var(--menu-selected-background-color);
-  padding-top: 1px;
-  padding-bottom: 1px;
 }
 
 .info-content-text pre {
@@ -174,7 +161,6 @@ body {
   border-radius: 4px;
   line-height: 1.5;
   position: relative;
-  white-space: break-spaces;
 }
 
 .info-content-text pre .line-numbers {
@@ -201,6 +187,7 @@ body {
   font-family: 'Maple Mono', monospace;
   font-size: 13px;
   border-radius: 4px;
+  white-space: break-spaces;
   background-color: var(--code-highlight-background-color);
   color: var(--text-color);
 }
@@ -249,14 +236,6 @@ body {
   overflow-x: auto; /* 小屏可横向滚动 */
 }
 
-.info-content-text hr {
-  border: none;
-  border-top: 1px solid var(--normal-border-color);
-  padding: 0;
-  height: 1px;
-  width: 100%;
-}
-
 .info-content-text thead th {
   background-color: var(--primary-color);
   color: #fff;

frontend_nuxt/assets/icons/discord.svg

@@ -1 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" shape-rendering="geometricPrecision" text-rendering="geometricPrecision" image-rendering="optimizeQuality" fill-rule="evenodd" clip-rule="evenodd" viewBox="0 0 512 512"><path fill="#5865F2" d="M105 0h302c57.928.155 104.845 47.072 105 104.996V407c-.155 57.926-47.072 104.844-104.996 104.998L105 512C47.074 511.844.156 464.926.002 407.003L0 105C.156 47.072 47.074.155 104.997 0H105z"/><g data-name="图层 2"><g data-name="Discord Logos"><path fill="#fff" fill-rule="nonzero" d="M368.896 153.381a269.506 269.506 0 00-67.118-20.637 186.88 186.88 0 00-8.57 17.475 250.337 250.337 0 00-37.247-2.8c-12.447 0-24.955.946-37.25 2.776-2.511-5.927-5.427-11.804-8.592-17.454a271.73 271.73 0 00-67.133 20.681c-42.479 62.841-53.991 124.112-48.235 184.513a270.622 270.622 0 0082.308 41.312c6.637-8.959 12.582-18.497 17.63-28.423a173.808 173.808 0 01-27.772-13.253c2.328-1.688 4.605-3.427 6.805-5.117 25.726 12.083 53.836 18.385 82.277 18.385 28.442 0 56.551-6.302 82.279-18.387 2.226 1.817 4.503 3.557 6.805 5.117a175.002 175.002 0 01-27.823 13.289 197.847 197.847 0 0017.631 28.4 269.513 269.513 0 0082.363-41.305l-.007.007c6.754-70.045-11.538-130.753-48.351-184.579zM201.968 300.789c-16.04 0-29.292-14.557-29.292-32.465s12.791-32.592 29.241-32.592 29.599 14.684 29.318 32.592c-.282 17.908-12.919 32.465-29.267 32.465zm108.062 0c-16.066 0-29.267-14.557-29.267-32.465s12.791-32.592 29.267-32.592c16.475 0 29.522 14.684 29.241 32.592-.281 17.908-12.894 32.465-29.241 32.465z" data-name="Discord Logo - Large - White"/></g></g></svg>
+<svg role="img" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><title>Discord</title><path d="M20.317 4.3698a19.7913 19.7913 0 00-4.8851-1.5152.0741.0741 0 00-.0785.0371c-.211.3753-.4447.8648-.6083 1.2495-1.8447-.2762-3.68-.2762-5.4868 0-.1636-.3933-.4058-.8742-.6177-1.2495a.077.077 0 00-.0785-.037 19.7363 19.7363 0 00-4.8852 1.515.0699.0699 0 00-.0321.0277C.5334 9.0458-.319 13.5799.0992 18.0578a.0824.0824 0 00.0312.0561c2.0528 1.5076 4.0413 2.4228 5.9929 3.0294a.0777.0777 0 00.0842-.0276c.4616-.6304.8731-1.2952 1.226-1.9942a.076.076 0 00-.0416-.1057c-.6528-.2476-1.2743-.5495-1.8722-.8923a.077.077 0 01-.0076-.1277c.1258-.0943.2517-.1923.3718-.2914a.0743.0743 0 01.0776-.0105c3.9278 1.7933 8.18 1.7933 12.0614 0a.0739.0739 0 01.0785.0095c.1202.099.246.1981.3728.2924a.077.077 0 01-.0066.1276 12.2986 12.2986 0 01-1.873.8914.0766.0766 0 00-.0407.1067c.3604.698.7719 1.3628 1.225 1.9932a.076.076 0 00.0842.0286c1.961-.6067 3.9495-1.5219 6.0023-3.0294a.077.077 0 00.0313-.0552c.5004-5.177-.8382-9.6739-3.5485-13.6604a.061.061 0 00-.0312-.0286zM8.02 15.3312c-1.1825 0-2.1569-1.0857-2.1569-2.419 0-1.3332.9555-2.4189 2.157-2.4189 1.2108 0 2.1757 1.0952 2.1568 2.419 0 1.3332-.9555 2.4189-2.1569 2.4189zm7.9748 0c-1.1825 0-2.1569-1.0857-2.1569-2.419 0-1.3332.9554-2.4189 2.1569-2.4189 1.2108 0 2.1757 1.0952 2.1568 2.419 0 1.3332-.946 2.4189-2.1568 2.4189Z"/></svg>

frontend_nuxt/assets/icons/telegram.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64"><defs><clipPath id="A"><path d="M15.903 131.998c0-65.17 52.83-118 118-118s118 52.83 118 118-52.83 118-118 118-118-52.83-118-118"/></clipPath><linearGradient x1="133.903" y1="13.999" x2="133.903" y2="249.999" gradientUnits="userSpaceOnUse" spreadMethod="pad" id="B"><stop offset="0" stop-color="#1d93d2"/><stop offset="1" stop-color="#38b0e3"/></linearGradient><clipPath id="C"><path d="M0 265.9h266.987V0H0z"/></clipPath><clipPath id="D"><path d="M0 265.9h266.987V0H0z"/></clipPath><clipPath id="E"><path d="M0 265.9h266.987V0H0z"/></clipPath></defs><g transform="matrix(.271187 0 0 -.271187 -4.312678 67.796339)"><path d="M15.903 131.998c0-65.17 52.83-118 118-118s118 52.83 118 118-52.83 118-118 118-118-52.83-118-118" fill="url(#B)" clip-path="url(#A)"/><g clip-path="url(#C)"><path d="M95.778 123.374l14-38.75S111.528 81 113.403 81s29.75 29 29.75 29l31 59.875-77.875-36.5z" fill="#c8daea"/></g><g clip-path="url(#D)"><path d="M114.34 113.436l-2.688-28.562s-1.125-8.75 7.625 0 17.125 15.5 17.125 15.5" fill="#a9c6d8"/></g><g clip-path="url(#E)"><path d="M96.03 121.99l-28.795 9.383s-3.437 1.395-2.333 4.562c.228.653.687 1.208 2.062 2.167 6.382 4.447 118.104 44.604 118.104 44.604s3.155 1.062 5.02.356c.852-.323 1.396-.688 1.854-2.02.167-.485.263-1.516.25-2.542-.01-.74-.1-1.425-.166-2.5-.68-10.98-21.04-92.918-21.04-92.918s-1.218-4.795-5.583-4.958c-1.592-.06-3.524.263-5.834 2.25-8.565 7.368-38.172 27.265-44.713 31.64-.37.246-.474.567-.537.88-.092.46.4 1.034.4 1.034s51.552 45.825 52.924 50.633c.106.373-.293.557-.834.396-3.424-1.26-62.78-38.74-69.33-42.88-.383-.242-1.457-.086-1.457-.086" fill="#fff"/></g></g></svg>

frontend_nuxt/assets/icons/twitter.svg

@@ -1 +1,4 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="-480 -466.815 2160 2160"><circle fill="#444" cx="600" cy="613.185" r="1080"/><path fill="#fff" d="M306.615 79.694H144.011L892.476 1150.3h162.604ZM0 0h357.328l309.814 450.883L1055.03 0h105.86L714.15 519.295 1200 1226.37H842.672L515.493 750.215 105.866 1226.37H0l468.485-544.568Z"/></svg>
+<svg role="img" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">
+  <title>Twitter icon</title>
+  <path d="M23.954 4.569c-.885.389-1.83.654-2.825.775 1.014-.611 1.794-1.574 2.163-2.723-.949.555-2.005.959-3.127 1.184-.897-.959-2.173-1.559-3.591-1.559-2.717 0-4.92 2.203-4.92 4.917 0 .39.045.765.127 1.124-4.083-.205-7.697-2.159-10.126-5.134-.422.722-.666 1.561-.666 2.475 0 1.709.87 3.214 2.188 4.096-.807-.026-1.566-.248-2.229-.616v.061c0 2.385 1.693 4.374 3.946 4.827-.413.111-.849.171-1.296.171-.314 0-.615-.03-.916-.086.631 1.953 2.445 3.376 4.6 3.416-1.68 1.318-3.808 2.105-6.102 2.105-.39 0-.779-.023-1.17-.069 2.189 1.394 4.768 2.209 7.548 2.209 9.051 0 14.001-7.496 14.001-13.986 0-.21 0-.42-.015-.63.961-.689 1.8-1.56 2.46-2.548l-.047-.02z"/>
+</svg>

frontend_nuxt/components/AchievementList.vue

@@ -9,7 +9,7 @@
       ]"
       @click="selectMedal(medal)"
     >
-      <BaseImage
+      <img
         :src="medal.icon"
         :alt="medal.title"
         :class="['achievements-list-item-icon', { not_completed: !medal.completed }]"

frontend_nuxt/components/ActivityPopup.vue

@@ -1,7 +1,7 @@
 <template>
   <BasePopup :visible="visible" @close="close">
     <div class="activity-popup">
-      <BaseImage v-if="icon" :src="icon" class="activity-popup-icon" alt="activity icon" />
+      <img v-if="icon" :src="icon" class="activity-popup-icon" alt="activity icon" />
       <div class="activity-popup-text">{{ text }}</div>
       <div class="activity-popup-actions">
         <div class="activity-popup-button" @click="gotoActivity">立即前往</div>

frontend_nuxt/components/ArticleCategory.vue

@@ -1,7 +1,7 @@
 <template>
   <div class="article-category-container" v-if="category">
     <div class="article-info-item" @click="gotoCategory">
-      <BaseImage
+      <img
         v-if="category.smallIcon"
         class="article-info-item-img"
         :src="category.smallIcon"

frontend_nuxt/components/ArticleTags.vue

@@ -6,7 +6,7 @@
       :key="tag.id || tag.name"
       @click="gotoTag(tag)"
     >
-      <BaseImage
+      <img
         v-if="tag.smallIcon"
         class="article-info-item-img"
         :src="tag.smallIcon"

frontend_nuxt/components/BaseImage.vue

@@ -1,66 +0,0 @@
-<template>
-  <NuxtImg
-    v-bind="passAttrs"
-    :src="src"
-    :alt="alt"
-    loading="lazy"
-    :placeholder="placeholder"
-    placeholder-class="base-image-ph"
-    @load="onLoad"
-    @error="onError"
-    :class="['base-image', passAttrs.class, { 'is-loaded': loaded }]"
-  />
-</template>
-
-<script setup>
-import { computed, ref } from 'vue'
-import { useAttrs } from 'vue'
-
-const props = defineProps({
-  src: { type: String, required: true },
-  alt: { type: String, default: '' },
-})
-
-const attrs = useAttrs()
-
-const passAttrs = computed(() => {
-  const { placeholder, ...rest } = attrs
-  return rest
-})
-
-const loaded = ref(false)
-const img = useImage()
-
-const placeholder = computed(() => {
-  if (!props.src) return undefined
-  return img(props.src, { w: 16, h: 16, f: 'webp', q: 20, blur: 1 })
-})
-
-function onLoad() {
-  loaded.value = true
-}
-function onError() {
-  loaded.value = true
-}
-</script>
-
-<style scoped>
-.base-image {
-  transition:
-    filter 0.35s ease,
-    transform 0.35s ease,
-    opacity 0.35s ease;
-  opacity: 0.92;
-}
-
-.base-image-ph {
-  filter: blur(20px);
-  transform: scale(0.5);
-}
-
-.base-image.is-loaded {
-  /* Allow filters from parent classes (e.g. grayscale for unfinished medals) */
-  transform: none;
-  opacity: 1;
-}
-</style>

frontend_nuxt/components/BaseTabs.vue

@@ -1,92 +1,110 @@
 <template>
-  <div class="base-tabs">
+  <div class="base-tabs-wrapper" @touchstart="onTouchStart" @touchend="onTouchEnd">
     <div class="base-tabs-header">
       <div class="base-tabs-items">
         <div
           v-for="tab in tabs"
-          :key="tab.key"
-          :class="['base-tabs-item', { selected: modelValue === tab.key }]"
-          @click="$emit('update:modelValue', tab.key)"
+          :key="tab.name"
+          :class="['base-tab-item', { selected: tab.name === current }]"
+          @click="select(tab.name)"
         >
           <i v-if="tab.icon" :class="tab.icon"></i>
-          <div class="base-tabs-item-label">{{ tab.label }}</div>
+          <span>{{ tab.label }}</span>
         </div>
       </div>
-      <div class="base-tabs-header-right">
+      <div class="base-tabs-right">
         <slot name="right"></slot>
       </div>
     </div>
-    <div class="base-tabs-content" @touchstart="onTouchStart" @touchend="onTouchEnd">
-      <slot></slot>
+    <div class="base-tabs-content">
+      <slot :current="current"></slot>
     </div>
   </div>
 </template>
 
 <script setup>
+import { ref, watch } from 'vue'
+
 const props = defineProps({
-  modelValue: { type: String, required: true },
-  tabs: { type: Array, default: () => [] },
+  modelValue: { type: String, default: undefined },
+  tabs: { type: Array, required: true },
+  swipe: { type: Boolean, default: true },
 })
 
 const emit = defineEmits(['update:modelValue'])
 
-let touchStartX = 0
+const current = ref(props.modelValue ?? (props.tabs[0] && props.tabs[0].name))
+
+watch(
+  () => props.modelValue,
+  (val) => {
+    if (val !== undefined) current.value = val
+  },
+)
+
+function select(name) {
+  emit('update:modelValue', name)
+}
+
+let startX = 0
 
 function onTouchStart(e) {
-  touchStartX = e.touches[0].clientX
+  if (!props.swipe) return
+  startX = e.changedTouches[0].clientX
 }
 
 function onTouchEnd(e) {
-  const diffX = e.changedTouches[0].clientX - touchStartX
-  if (Math.abs(diffX) > 50) {
-    const index = props.tabs.findIndex((t) => t.key === props.modelValue)
-    if (diffX < 0 && index < props.tabs.length - 1) {
-      emit('update:modelValue', props.tabs[index + 1].key)
-    } else if (diffX > 0 && index > 0) {
-      emit('update:modelValue', props.tabs[index - 1].key)
+  if (!props.swipe) return
+  const endX = e.changedTouches[0].clientX
+  const diff = endX - startX
+  if (Math.abs(diff) > 50) {
+    const index = props.tabs.findIndex((t) => t.name === current.value)
+    if (diff < 0 && index < props.tabs.length - 1) {
+      emit('update:modelValue', props.tabs[index + 1].name)
+    } else if (diff > 0 && index > 0) {
+      emit('update:modelValue', props.tabs[index - 1].name)
     }
   }
 }
 </script>
 
 <style scoped>
+.base-tabs-wrapper {
+  display: flex;
+  flex-direction: column;
+}
+
 .base-tabs-header {
   display: flex;
-  border-bottom: 1px solid var(--normal-border-color);
   align-items: center;
-  flex-direction: row;
+  justify-content: space-between;
+  border-bottom: 1px solid var(--normal-border-color);
 }
 
 .base-tabs-items {
   display: flex;
   overflow-x: auto;
   scrollbar-width: none;
-  flex: 1;
 }
 
-.base-tabs-item {
+.base-tab-item {
   padding: 10px 20px;
   cursor: pointer;
   white-space: nowrap;
-  display: flex;
-  align-items: center;
 }
 
-.base-tabs-item i {
-  margin-right: 6px;
-}
-
-.base-tabs-item.selected {
+.base-tab-item.selected {
   color: var(--primary-color);
   border-bottom: 2px solid var(--primary-color);
 }
 
-.base-tabs-header-right {
-  display: flex;
-  flex-shrink: 0;
+.base-tab-item i {
+  margin-right: 6px;
 }
 
-.base-tabs-content {
-  width: 100%;
+.base-tabs-right {
+  display: flex;
+  align-items: center;
+  flex: 0 0 auto;
 }
 </style>

frontend_nuxt/components/BaseTimeline.vue

@@ -6,9 +6,9 @@
         :class="{ clickable: !!item.iconClick }"
         @click="item.iconClick && item.iconClick()"
       >
-        <BaseImage v-if="item.src" :src="item.src" class="timeline-img" alt="timeline item" />
+        <img v-if="item.src" :src="item.src" class="timeline-img" alt="timeline item" />
         <i v-else-if="item.icon" :class="item.icon"></i>
-        <BaseImage v-else-if="item.emoji" :src="item.emoji" class="timeline-emoji" alt="emoji" />
+        <img v-else-if="item.emoji" :src="item.emoji" class="timeline-emoji" alt="emoji" />
       </div>
       <div class="timeline-content">
         <slot name="item" :item="item">{{ item.content }}</slot>

frontend_nuxt/components/CategorySelect.vue

@@ -9,7 +9,7 @@
       <div class="option-container">
         <div class="option-main">
           <template v-if="option.icon">
-            <BaseImage
+            <img
               v-if="isImageIcon(option.icon)"
               :src="option.icon"
               class="option-icon"

frontend_nuxt/components/CommentItem.vue

@@ -8,7 +8,7 @@
   >
     <!-- <div class="user-avatar-container">
       <div class="user-avatar-item">
-        <BaseImage class="user-avatar-item-img" :src="comment.avatar" alt="avatar" />
+        <img class="user-avatar-item-img" :src="comment.avatar" alt="avatar" />
       </div>
     </div>   -->
     <div class="info-content">
@@ -23,13 +23,9 @@
             >{{ getMedalTitle(comment.medal) }}</NuxtLink
           >
           <i v-if="comment.pinned" class="fas fa-thumbtack pin-icon"></i>
-          <span v-if="level >= 2" class="reply-item">
+          <span v-if="level >= 2">
             <i class="fas fa-reply reply-icon"></i>
-            <span class="reply-info">
-              <BaseImage class="reply-avatar"  :src="comment.parentUserAvatar || '/default-avatar.svg'" alt="avatar"
-              @click="comment.parentUserClick && comment.parentUserClick()" />
-              <span class="reply-user-name">{{ comment.parentUserName }}</span>
-            </span>
+            <span class="user-name reply-user-name">{{ comment.parentUserName }}</span>
           </span>
           <div class="post-time">{{ comment.time }}</div>
         </div>
@@ -254,7 +250,6 @@ const submitReply = async (parentUserName, text, clear) => {
         medal: data.author.displayMedal,
         text: data.content,
         parentUserName: parentUserName,
-        parentUserAvatar: props.comment.avatar,
         reactions: [],
         reply: (data.replies || []).map((r) => ({
           id: r.id,
@@ -381,22 +376,7 @@ const handleContentClick = (e) => {
   justify-content: space-between;
 }
 
-.reply-item, .reply-info {
-  display: inline-flex;
-  flex-direction: row;
-  align-items: center;
-}
-
-.reply-avatar {
-  width: 20px;
-  height: 20px;
-  border-radius: 50%;
-  margin-right: 5px;
-  cursor: pointer;
-}
-
 .reply-icon {
-  color: var(--primary-color);
   margin-right: 10px;
   margin-left: 10px;
   opacity: 0.5;

frontend_nuxt/components/Dropdown.vue

@@ -13,7 +13,7 @@
             <template v-for="(label, idx) in selectedLabels" :key="label.id">
               <div class="selected-label">
                 <template v-if="label.icon">
-                  <BaseImage
+                  <img
                     v-if="isImageIcon(label.icon)"
                     :src="label.icon"
                     class="option-icon"
@@ -32,7 +32,7 @@
           <span v-if="selectedLabels.length">
             <div class="selected-label">
               <template v-if="selectedLabels[0].icon">
-                <BaseImage
+                <img
                   v-if="isImageIcon(selectedLabels[0].icon)"
                   :src="selectedLabels[0].icon"
                   class="option-icon"
@@ -69,12 +69,7 @@
         >
           <slot name="option" :option="o" :isSelected="isSelected(o.id)">
             <template v-if="o.icon">
-              <BaseImage
-                v-if="isImageIcon(o.icon)"
-                :src="o.icon"
-                class="option-icon"
-                :alt="o.name"
-              />
+              <img v-if="isImageIcon(o.icon)" :src="o.icon" class="option-icon" :alt="o.name" />
               <i v-else :class="['option-icon', o.icon]"></i>
             </template>
             <span>{{ o.name }}</span>
@@ -105,12 +100,7 @@
             >
               <slot name="option" :option="o" :isSelected="isSelected(o.id)">
                 <template v-if="o.icon">
-                  <BaseImage
-                    v-if="isImageIcon(o.icon)"
-                    :src="o.icon"
-                    class="option-icon"
-                    :alt="o.name"
-                  />
+                  <img v-if="isImageIcon(o.icon)" :src="o.icon" class="option-icon" :alt="o.name" />
                   <i v-else :class="['option-icon', o.icon]"></i>
                 </template>
                 <span>{{ o.name }}</span>

frontend_nuxt/components/HeaderComponent.vue

@@ -4,7 +4,7 @@
       <div class="header-content-left">
         <div v-if="showMenuBtn" class="menu-btn-wrapper">
           <button class="menu-btn" ref="menuBtn" @click="$emit('toggle-menu')">
-            <i class="fas fa-bars micon"></i>
+            <i class="fas fa-bars"></i>
           </button>
           <span
             v-if="isMobile && (unreadMessageCount > 0 || hasChannelUnread)"
@@ -12,7 +12,7 @@
           ></span>
         </div>
         <NuxtLink class="logo-container" :to="`/`" @click="refrechData">
-          <BaseImage
+          <img
             alt="OpenIsle"
             src="https://openisle-1307107697.cos.ap-guangzhou.myqcloud.com/assert/image.png"
             width="60"
@@ -75,6 +75,7 @@
           </div>
         </div>
       </ClientOnly>
+
       <SearchDropdown ref="searchDropdown" v-if="isMobile && showSearch" @close="closeSearch" />
     </div>
   </header>
@@ -148,14 +149,13 @@ const copyInviteLink = async () => {
     if (res.ok) {
       const data = await res.json()
       const inviteLink = data.token ? `${WEBSITE_BASE_URL}/signup?invite_token=${data.token}` : ''
-      /**
+      /** 
        * navigator.clipboard在webkit中有点奇怪的行为
        * https://stackoverflow.com/questions/62327358/javascript-clipboard-api-safari-ios-notallowederror-message
        * https://webkit.org/blog/10247/new-webkit-features-in-safari-13-1/
-       */
+      */
       setTimeout(() => {
-        navigator.clipboard
-          .writeText(inviteLink)
+        navigator.clipboard.writeText(inviteLink)
           .then(() => {
             toast.success('邀请链接已复制')
           })
@@ -318,10 +318,6 @@ onMounted(async () => {
   gap: 20px;
 }
 
-.micon {
-  margin-left: 10px;
-}
-
 .menu-btn {
   font-size: 24px;
   background: none;
@@ -374,7 +370,6 @@ onMounted(async () => {
   display: flex;
   align-items: center;
   cursor: pointer;
-  margin-right: 10px;
 }
 
 .avatar-img {