feat: use iconpark in base tabs

refactor: support iconpark in menu and header

.gitignore

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

CONTRIBUTING.md

@@ -1,111 +1,185 @@
-#### **⚠️注意：仅想修改前端的朋友可不用部署后端服务**
+- [前置工作](#前置工作)
+- [启动后端服务](#启动后端服务)
+    - [本地 IDEA](#本地-idea)
+        - [配置环境变量](#配置环境变量)
+        - [配置 IDEA 参数](#配置-idea-参数)
+        - [配置 MySQL](#配置-mysql)
+    - [Docker 环境](#docker-环境)
+        - [配置环境变量](#配置环境变量-1)
+        - [构建并启动镜像](#构建并启动镜像)
+- [启动前端服务](#启动前端服务)
+    - [配置环境变量](#配置环境变量-2)
+    - [安装依赖和运行](#安装依赖和运行)
+- [其他配置](#其他配置)
 
-## 如何部署
+## 前置工作
 
-> Step1 先克隆仓库
+先克隆仓库：
 
 ```shell
 git clone https://github.com/nagisa77/OpenIsle.git
 cd OpenIsle
 ```
 
-> Step2 后端部署
+- 后端开发环境
+    - JDK 17+
+- 前端开发环境
+    - Node.JS 20+
+
+## 启动后端服务
+
+启动后端服务有多种方式，选择一种即可。
+
+> [!IMPORTANT]
+> 仅想修改前端的朋友可不用部署后端服务。转到 [启动前端服务](#启动前端服务) 章节。
+
+### 本地 IDEA
 
 ```shell
-cd backend
+cd backend/
 ```
 
-以IDEA编辑器为例，IDEA打开backend文件夹。
+IDEA 打开 `backend/` 文件夹。
 
-- 设置VM Option，最好运行在其他端口，非8080，这里设置8081
+#### 配置环境变量
+
+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 环境
+#### 配置环境变量
 
 ```shell
--Dserver.port=8081
+cd docker/
 ```
 
-![CleanShot 2025-08-04 at 11 .35.49.png](https://openisle-1307107697.cos.accelerate.myqcloud.com/dynamic_assert/4cf210cfc6ea478a80dfc744c85ccdc4.png)
+主要配置两个 `.env` 文件
 
-- 设置jdk版本为java 17
+- `backend/open-isle.env`：后端环境变量，配置同上，见 [配置环境变量](#配置环境变量)。
+- `docker/.env`：Docker Compose 环境变量，主要配置 MySQL 相关
+    ```shell
+    cp .env.example .env
+    ```
 
-![CleanShot 2025-08-04 at 11 .38.03@2x.png](https://openisle-1307107697.cos.accelerate.myqcloud.com/dynamic_assert/392eeec753ae436ca12a78f750dfea2d.png)
+> [!TIP]
+> 使用单独的 `.env` 文件是为了兼容线上环境或已启用 MySQL 服务的情况，如果只是想快速体验或者启动统一的环境，则推荐使用本方式。
 
-- 本机配置MySQL服务（网上很多教程，忽略）
-- 设置环境变量.env 文件 或.properties 文件（二选一）
+在指定 `docker/.env` 后，`backend/open-isle.env` 中以下配置会被覆盖，这样就确保使用了同一份配置。
 
-1. 环境变量文件生成
+```ini
+MYSQL_URL=
+MYSQL_USER=
+MYSQL_PASSWORD=
+```
+
+#### 构建并启动镜像
 
 ```shell
-cp open-isle.env.example open-isle.env
+docker compose up -d
 ```
 
-修改环境变量，留下需要的，比如你要开发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 前端部署
-
-**⚠️ 环境要求：Node.js 版本最低 20.0.0（因为 Nuxt 框架要求）**
-
-前端可以依赖本机部署的后端，也可以直接调用线上的后端接口
+如果想了解启动过程发生了什么可以查看日志
 
 ```shell
-cd ../frontend_nuxt/
+docker compose logs
 ```
 
-copy环境.env文件
+## 启动前端服务
+
+> [!IMPORTANT]
+> **⚠️ 环境要求：Node.js 版本最低 20.0.0（因为 Nuxt 框架要求）**
 
 ```shell
-cp .env.staging.example .env
+cd frontend_nuxt/
 ```
 
-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
-```
+- 利用生产环境
 
-4. 依赖线上后台环境
+    ```shell
+    cp .env.production.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.dev.example .env
+    ```
+
+### 安装依赖和运行
+
+前端安装依赖并启动服务。
 
 ```shell
 # 安装依赖
@@ -115,4 +189,22 @@ npm install --verbose
 npm run dev
 ```
 
-如此一来，浏览器访问 http://127.0.0.1:3000 即可访问前端页面
+如此一来，浏览器访问 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)

backend/open-isle.env.example

@@ -1,5 +1,8 @@
+# === 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=<数据库密码>
 
@@ -28,6 +31,7 @@ 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>
@@ -36,4 +40,10 @@ 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,9 +26,22 @@
       <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-websocket</artifactId>
+      <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>
     </dependency>
     <dependency>
       <groupId>org.slf4j</groupId>
@@ -114,6 +127,11 @@
       <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>
@@ -141,6 +159,26 @@
           </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

@@ -0,0 +1,109 @@
+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

@@ -0,0 +1,48 @@
+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

@@ -0,0 +1,204 @@
+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

@@ -0,0 +1,35 @@
+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,10 +74,14 @@ 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",
@@ -85,6 +89,7 @@ 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.", "://")
         ));
@@ -106,6 +111,7 @@ 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()
@@ -176,7 +182,8 @@ public class SecurityConfig {
                         return;
                     }
                 } else if (!uri.startsWith("/api/auth") && !publicGet
-                        && !uri.startsWith("/api/ws") && !uri.startsWith("/api/sockjs")) {
+                        && !uri.startsWith("/api/ws") && !uri.startsWith("/api/sockjs")
+                        && !uri.startsWith("/api/v3/api-docs")) {
                     response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                     response.setContentType("application/json");
                     response.getWriter().write("{\"error\": \"Missing token\"}");

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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,84 @@
+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

@@ -1,110 +0,0 @@
-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,6 +26,7 @@ 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;
@@ -360,6 +361,51 @@ 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/dto/MessageNotificationPayload.java

@@ -0,0 +1,15 @@
+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/TelegramLoginRequest.java

@@ -0,0 +1,16 @@
+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/model/Message.java

@@ -1,5 +1,6 @@
 package com.openisle.model;
 
+import com.fasterxml.jackson.annotation.JsonBackReference;
 import jakarta.persistence.*;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
@@ -20,6 +21,7 @@ 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,5 +1,7 @@
 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;
@@ -41,8 +43,10 @@ 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,5 +1,6 @@
 package com.openisle.model;
 
+import com.fasterxml.jackson.annotation.JsonBackReference;
 import jakarta.persistence.*;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
@@ -19,6 +20,7 @@ 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/Tag.java

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

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

@@ -11,6 +11,9 @@ 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/service/CategoryService.java

@@ -1,8 +1,11 @@
 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;
@@ -11,7 +14,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);
@@ -20,7 +23,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"));
@@ -38,7 +41,7 @@ public class CategoryService {
         }
         return categoryRepository.save(category);
     }
-
+    @CacheEvict(value = CachingConfig.CATEGORY_CACHE_NAME, allEntries = true)
     public void deleteCategory(Long id) {
         categoryRepository.deleteById(id);
     }
@@ -48,6 +51,14 @@ 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,6 +4,7 @@ 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;
@@ -14,6 +15,7 @@ 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;
@@ -21,6 +23,9 @@ 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;
@@ -39,6 +44,7 @@ public class CommentService {
     private final CommentSubscriptionRepository commentSubscriptionRepository;
     private final NotificationRepository notificationRepository;
     private final PointHistoryRepository pointHistoryRepository;
+    private final PointService pointService;
     private final ImageUploader imageUploader;
 
     @Transactional
@@ -65,16 +71,19 @@ 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);
@@ -111,21 +120,25 @@ 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);
@@ -237,15 +250,33 @@ public class CommentService {
         for (Comment c : replies) {
             deleteCommentCascade(c);
         }
-        // 逻辑删除相关的积分历史记录
-        pointHistoryRepository.findByComment(comment).forEach(pointHistoryRepository::delete);
+
+        // 逻辑删除相关的积分历史记录，并收集受影响的用户
+        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/MessageService.java

@@ -16,16 +16,18 @@ 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
@@ -37,7 +39,7 @@ public class MessageService {
     private final MessageConversationRepository conversationRepository;
     private final MessageParticipantRepository participantRepository;
     private final UserRepository userRepository;
-    private final SimpMessagingTemplate messagingTemplate;
+    private final NotificationProducer notificationProducer;
     private final ReactionRepository reactionRepository;
     private final ReactionMapper reactionMapper;
 
@@ -69,26 +71,41 @@ public class MessageService {
         conversationRepository.save(conversation);
         log.info("Conversation {} updated with last message ID {}", conversation.getId(), message.getId());
 
-        // 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);
-
-        // 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);
+        try {
+            MessageDto messageDto = toDto(message);
+            
+            long unreadCount = getUnreadMessageCount(recipientId);
+
+            // 创建包含对话和参与者信息的完整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);
+        }
 
         return message;
     }
@@ -97,7 +114,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.findById(conversationId)
+        MessageConversation conversation = conversationRepository.findByIdWithParticipantsAndUsers(conversationId)
                 .orElseThrow(() -> new IllegalArgumentException("Conversation not found"));
 
         // Join the conversation if not already a participant (useful for channels)
@@ -124,22 +141,30 @@ public class MessageService {
         conversationRepository.save(conversation);
 
         MessageDto messageDto = toDto(message);
-        String conversationDestination = "/topic/conversation/" + conversation.getId();
-        messagingTemplate.convertAndSend(conversationDestination, messageDto);
 
-        // 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);
+        // 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());
 
-            long unreadCount = getUnreadMessageCount(participant.getUser().getId());
-            String username = participant.getUser().getUsername();
-            messagingTemplate.convertAndSendToUser(username, "/queue/unread-count", unreadCount);
+        Map<String, Object> conversationInfo = new HashMap<>();
+        conversationInfo.put("id", conversation.getId());
+        conversationInfo.put("participants", participantInfos);
 
-            long channelUnread = getUnreadChannelCount(participant.getUser().getId());
-            messagingTemplate.convertAndSendToUser(username, "/queue/channel-unread", channelUnread);
-        }
+        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));
 
         return message;
     }

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

@@ -0,0 +1,63 @@
+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/PointService.java

@@ -219,4 +219,32 @@ public class PointService {
         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/TagService.java

@@ -1,9 +1,12 @@
 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;
@@ -18,6 +21,7 @@ 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();
@@ -42,6 +46,7 @@ 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"));
@@ -61,6 +66,7 @@ public class TagService {
         return tagRepository.save(tag);
     }
 
+    @CacheEvict(value = CachingConfig.TAG_CACHE_NAME, allEntries = true)
     public void deleteTag(Long id) {
         tagRepository.deleteById(id);
     }
@@ -85,10 +91,20 @@ 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

@@ -0,0 +1,102 @@
+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,3 +1,6 @@
+# for spring boot
+server.port=${SERVER_PORT:8080}
+
 # for mysql
 logging.level.root=${LOG_LEVEL:INFO}
 logging.level.com.openisle.service.CosImageUploader=DEBUG
@@ -6,6 +9,11 @@ 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=0
+
 # for jwt
 app.jwt.secret=${JWT_SECRET:jwt_sec}
 app.jwt.reason-secret=${JWT_REASON_SECRET:jwt_reason_sec}
@@ -69,6 +77,8 @@ 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}
@@ -81,3 +91,23 @@ 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

@@ -0,0 +1,81 @@
+-- 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/test/java/com/openisle/service/CommentServiceTest.java

@@ -7,6 +7,7 @@ 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,10 +27,11 @@ class CommentServiceTest {
         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, imageUploader);
+                notifService, subService, reactionRepo, subRepo, nRepo, pointHistoryRepo, pointService, imageUploader);
 
         when(commentRepo.countByAuthorAfter(eq("alice"), any())).thenReturn(3L);
 

docker/.env.example

@@ -0,0 +1,11 @@
+# 前端访问端口
+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

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,10 @@
+; 本地部署后端
+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,13 +3,17 @@
 ; 预发环境后端
 ; NUXT_PUBLIC_API_BASE_URL=https://staging.open-isle.com
 ; 生产环境后端
-NUXT_PUBLIC_API_BASE_URL=https://www.open-isle.com
+NUXT_PUBLIC_API_BASE_URL=https://open-isle.com
+
+; 生产环境ws后端
+NUXT_PUBLIC_WEBSOCKET_URL=https://open-isle.com/websocket
 
 ; 预发环境
 ; NUXT_PUBLIC_WEBSITE_BASE_URL=https://staging.open-isle.com
 ; 正式环境/生产环境
-NUXT_PUBLIC_WEBSITE_BASE_URL=https://www.open-isle.com
+NUXT_PUBLIC_WEBSITE_BASE_URL=https://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

@@ -0,0 +1,13 @@
+
+; 生产环境后端
+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,16 +1,17 @@
 ; 本地部署后端
 ; 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
+
+; 预发环境ws后端
+NUXT_PUBLIC_WEBSOCKET_URL=https://staging.open-isle.com/websocket
 
 ; 预发环境
 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

@@ -25,7 +25,7 @@
         class="app-new-post-icon"
         @click="goToNewPost"
       >
-        <i class="fas fa-edit"></i>
+        <edit />
       </div>
     </div>
     <GlobalPopups />
@@ -58,6 +58,7 @@ const hideMenu = computed(() => {
     '/discord-callback',
     '/forgot-password',
     '/google-callback',
+    '/telegram-callback',
   ].includes(useRoute().path)
 })
 

frontend_nuxt/assets/global.css

@@ -35,6 +35,13 @@
   --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'] {
@@ -155,6 +162,9 @@ 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 {
@@ -239,6 +249,14 @@ 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 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>
+<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>

frontend_nuxt/assets/icons/telegram.svg

@@ -0,0 +1 @@
+<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,4 +1 @@
-<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>
+<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>

frontend_nuxt/components/BaseTabs.vue

@@ -8,7 +8,12 @@
           :class="['base-tabs-item', { selected: modelValue === tab.key }]"
           @click="$emit('update:modelValue', tab.key)"
         >
-          <i v-if="tab.icon" :class="tab.icon"></i>
+          <component
+            v-if="tab.icon && (typeof tab.icon !== 'string' || !tab.icon.includes(' '))"
+            :is="tab.icon"
+            class="base-tabs-item-icon"
+          />
+          <i v-else-if="tab.icon" :class="tab.icon"></i>
           <div class="base-tabs-item-label">{{ tab.label }}</div>
         </div>
       </div>
@@ -72,6 +77,7 @@ function onTouchEnd(e) {
   align-items: center;
 }
 
+.base-tabs-item-icon,
 .base-tabs-item i {
   margin-right: 6px;
 }

frontend_nuxt/components/CommentItem.vue

@@ -15,19 +15,23 @@
       <div class="common-info-content-header">
         <div class="info-content-header-left">
           <span class="user-name">{{ comment.userName }}</span>
-          <i class="fas fa-medal medal-icon"></i>
+          <medal-one class="medal-icon" />
           <NuxtLink
             v-if="comment.medal"
             class="medal-name"
             :to="`/users/${comment.userId}?tab=achievements`"
             >{{ getMedalTitle(comment.medal) }}</NuxtLink
           >
-          <i v-if="comment.pinned" class="fas fa-thumbtack pin-icon"></i>
+          <pin v-if="comment.pinned" class="pin-icon" />
           <span v-if="level >= 2" class="reply-item">
-            <i class="fas fa-reply reply-icon"></i>
+            <next class="reply-icon" />
             <span class="reply-info">
-              <BaseImage class="reply-avatar"  :src="comment.parentUserAvatar || '/default-avatar.svg'" alt="avatar"
-              @click="comment.parentUserClick && comment.parentUserClick()" />
+              <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>
@@ -36,7 +40,7 @@
         <div class="info-content-header-right">
           <DropdownMenu v-if="commentMenuItems.length > 0" :items="commentMenuItems">
             <template #trigger>
-              <i class="fas fa-ellipsis-vertical action-menu-icon"></i>
+              <more-one class="action-menu-icon" />
             </template>
           </DropdownMenu>
         </div>
@@ -49,10 +53,10 @@
       <div class="article-footer-container">
         <ReactionsGroup v-model="comment.reactions" content-type="comment" :content-id="comment.id">
           <div class="make-reaction-item comment-reaction" @click="toggleEditor">
-            <i class="far fa-comment"></i>
+            <comment-icon />
           </div>
           <div class="make-reaction-item copy-link" @click="copyCommentLink">
-            <i class="fas fa-link"></i>
+            <link-icon />
           </div>
         </ReactionsGroup>
       </div>
@@ -381,7 +385,8 @@ const handleContentClick = (e) => {
   justify-content: space-between;
 }
 
-.reply-item, .reply-info {
+.reply-item,
+.reply-info {
   display: inline-flex;
   flex-direction: row;
   align-items: center;
@@ -397,13 +402,16 @@ const handleContentClick = (e) => {
 
 .reply-icon {
   color: var(--primary-color);
-  margin-right: 10px;
   margin-left: 10px;
+  margin-right: 10px;
   opacity: 0.5;
+  transform: scaleX(-1);
 }
 
 .reply-user-name {
   opacity: 0.3;
+  display: none;
+  font-weight: bold;
 }
 
 .medal-name {

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>
+            <application-menu class="micon"></application-menu>
           </button>
           <span
             v-if="isMobile && (unreadMessageCount > 0 || hasChannelUnread)"
@@ -25,34 +25,34 @@
       <ClientOnly>
         <div class="header-content-right">
           <div v-if="isMobile" class="search-icon" @click="search">
-            <i class="fas fa-search"></i>
+            <search-icon />
           </div>
 
           <div v-if="isMobile" class="theme-icon" @click="cycleTheme">
-            <i :class="iconClass"></i>
+            <component :is="iconClass" />
           </div>
 
           <div v-if="!isMobile" class="invite_text" @click="copyInviteLink">
-            <i class="fas fa-copy"></i>
+            <copy />
             邀请
-            <i v-if="isCopying" class="fas fa-spinner fa-spin"></i>
+            <loading v-if="isCopying" />
           </div>
 
           <ToolTip content="复制RSS链接" placement="bottom">
             <div class="rss-icon" @click="copyRssLink">
-              <i class="fas fa-rss"></i>
+              <rss />
             </div>
           </ToolTip>
 
           <ToolTip v-if="!isMobile && isLogin" content="发帖" placement="bottom">
             <div class="new-post-icon" @click="goToNewPost">
-              <i class="fas fa-edit"></i>
+              <edit />
             </div>
           </ToolTip>
 
           <ToolTip v-if="isLogin" content="站内信和频道" placement="bottom">
             <div class="messages-icon" @click="goToMessages">
-              <i class="fas fa-comments"></i>
+              <message-emoji />
               <span v-if="unreadMessageCount > 0" class="unread-badge">{{
                 unreadMessageCount
               }}</span>
@@ -64,7 +64,7 @@
             <template #trigger>
               <div class="avatar-container">
                 <img class="avatar-img" :src="avatar" alt="avatar" />
-                <i class="fas fa-caret-down dropdown-icon"></i>
+                <down />
               </div>
             </template>
           </DropdownMenu>
@@ -226,11 +226,11 @@ const headerMenuItems = computed(() => [
 const iconClass = computed(() => {
   switch (themeState.mode) {
     case ThemeMode.DARK:
-      return 'fas fa-moon'
+      return 'Moon'
     case ThemeMode.LIGHT:
-      return 'fas fa-sun'
+      return 'SunOne'
     default:
-      return 'fas fa-desktop'
+      return 'ComputerOne'
   }
 })
 

frontend_nuxt/components/MenuComponent.vue

@@ -4,7 +4,7 @@
       <div class="menu-content">
         <div class="menu-item-container">
           <NuxtLink class="menu-item" exact-active-class="selected" to="/" @click="handleItemClick">
-            <i class="menu-item-icon fas fa-hashtag"></i>
+            <hashtag-key class="menu-item-icon" />
             <span class="menu-item-text">话题</span>
           </NuxtLink>
           <NuxtLink
@@ -13,7 +13,7 @@
             to="/new-post"
             @click="handleItemClick"
           >
-            <i class="menu-item-icon fas fa-edit"></i>
+            <edit class="menu-item-icon" />
             <span class="menu-item-text">发帖</span>
           </NuxtLink>
           <NuxtLink
@@ -22,7 +22,7 @@
             to="/message"
             @click="handleItemClick"
           >
-            <i class="menu-item-icon fas fa-envelope"></i>
+            <remind class="menu-item-icon" />
             <span class="menu-item-text">我的消息</span>
             <span v-if="unreadCount > 0" class="unread-container">
               <span class="unread"> {{ showUnreadCount }} </span>
@@ -34,7 +34,7 @@
             to="/about"
             @click="handleItemClick"
           >
-            <i class="menu-item-icon fas fa-info-circle"></i>
+            <info class="menu-item-icon" />
             <span class="menu-item-text">关于</span>
           </NuxtLink>
           <NuxtLink
@@ -43,7 +43,7 @@
             to="/activities"
             @click="handleItemClick"
           >
-            <i class="menu-item-icon fas fa-gift"></i>
+            <gift class="menu-item-icon" />
             <span class="menu-item-text">🔥 活动</span>
           </NuxtLink>
           <NuxtLink
@@ -53,7 +53,7 @@
             to="/about/stats"
             @click="handleItemClick"
           >
-            <i class="menu-item-icon fas fa-chart-line"></i>
+            <chart-line class="menu-item-icon" />
             <span class="menu-item-text">站点统计</span>
           </NuxtLink>
           <NuxtLink
@@ -63,7 +63,7 @@
             to="/points"
             @click="handleItemClick"
           >
-            <i class="menu-item-icon fas fa-coins"></i>
+            <finance class="menu-item-icon" />
             <span class="menu-item-text">
               积分商城
               <span v-if="myPoint !== null" class="point-count">{{ myPoint }}</span>
@@ -74,7 +74,8 @@
         <div class="menu-section">
           <div class="section-header" @click="categoryOpen = !categoryOpen">
             <span>类别</span>
-            <i :class="categoryOpen ? 'fas fa-chevron-up' : 'fas fa-chevron-down'"></i>
+            <up v-if="categoryOpen" class="menu-item-icon" />
+            <down v-else class="menu-item-icon" />
           </div>
           <div v-if="categoryOpen" class="section-items">
             <div v-if="isLoadingCategory" class="menu-loading-container">
@@ -94,7 +95,7 @@
                   class="section-item-icon"
                   :alt="c.name"
                 />
-                <i v-else :class="['section-item-icon', c.smallIcon || c.icon]"></i>
+                <component v-else :is="c.smallIcon || c.icon" class="section-item-icon" />
               </template>
               <span class="section-item-text">
                 {{ c.name }}
@@ -107,7 +108,8 @@
         <div class="menu-section">
           <div class="section-header" @click="tagOpen = !tagOpen">
             <span>标签</span>
-            <i :class="tagOpen ? 'fas fa-chevron-up' : 'fas fa-chevron-down'"></i>
+            <up v-if="tagOpen" class="menu-item-icon" />
+            <down v-else class="menu-item-icon" />
           </div>
           <div v-if="tagOpen" class="section-items">
             <div v-if="isLoadingTag" class="menu-loading-container">
@@ -120,7 +122,7 @@
                 class="section-item-icon"
                 :alt="t.name"
               />
-              <i v-else class="section-item-icon fas fa-hashtag"></i>
+              <tag-one v-else class="section-item-icon" />
               <span class="section-item-text"
                 >{{ t.name }} <span class="section-item-text-count">x {{ t.count }}</span></span
               >
@@ -133,7 +135,7 @@
       <ClientOnly v-if="!isMobile">
         <div class="menu-footer">
           <div class="menu-footer-btn" @click="cycleTheme">
-            <i :class="iconClass"></i>
+            <component :is="iconClass" class="menu-item-icon" />
           </div>
         </div>
       </ClientOnly>
@@ -193,11 +195,11 @@ const {
 const iconClass = computed(() => {
   switch (themeState.mode) {
     case ThemeMode.DARK:
-      return 'fas fa-moon'
+      return 'Moon'
     case ThemeMode.LIGHT:
-      return 'fas fa-sun'
+      return 'SunOne'
     default:
-      return 'fas fa-desktop'
+      return 'ComputerOne'
   }
 })
 

frontend_nuxt/components/PostLottery.vue

@@ -16,7 +16,8 @@
           <div class="prize-count">x {{ lottery.prizeCount }}</div>
         </div>
         <div class="prize-end-time prize-info-right">
-          <div v-if="!isMobile" class="prize-end-time-title">离结束还有</div>
+          <i v-if="!lotteryEnded" class="fas fa-stopwatch prize-end-time-icon"></i>
+          <div v-if="!isMobile && !lotteryEnded" class="prize-end-time-title">离结束</div>
           <div class="prize-end-time-value">{{ countdown }}</div>
           <div v-if="!isMobile" class="join-prize-button-container-desktop">
             <div
@@ -84,6 +85,7 @@ import { getToken, authState } from '~/utils/auth'
 import { toast } from '~/main'
 import { useRuntimeConfig } from '#imports'
 import { useIsMobile } from '~/utils/screen'
+import { useCountdown } from '~/composables/useCountdown'
 
 const props = defineProps({
   lottery: { type: Object, required: true },
@@ -95,54 +97,14 @@ const isMobile = useIsMobile()
 const loggedIn = computed(() => authState.loggedIn)
 const lotteryParticipants = computed(() => props.lottery?.participants || [])
 const lotteryWinners = computed(() => props.lottery?.winners || [])
-const lotteryEnded = computed(() => {
-  if (!props.lottery || !props.lottery.endTime) return false
-  return new Date(props.lottery.endTime).getTime() <= Date.now()
-})
+// 倒计时和结束flg
+const { countdown, isEnded } = useCountdown(props.lottery?.endTime)
+const lotteryEnded = computed(() => isEnded.value)
 const hasJoined = computed(() => {
   if (!loggedIn.value) return false
   return lotteryParticipants.value.some((p) => p.id === Number(authState.userId))
 })
 
-const countdown = ref('00:00:00')
-let timer = null
-const updateCountdown = () => {
-  if (!props.lottery || !props.lottery.endTime) {
-    countdown.value = '00:00:00'
-    return
-  }
-  const diff = new Date(props.lottery.endTime).getTime() - Date.now()
-  if (diff <= 0) {
-    countdown.value = '00:00:00'
-    if (timer) {
-      clearInterval(timer)
-      timer = null
-    }
-    return
-  }
-  const h = String(Math.floor(diff / 3600000)).padStart(2, '0')
-  const m = String(Math.floor((diff % 3600000) / 60000)).padStart(2, '0')
-  const s = String(Math.floor((diff % 60000) / 1000)).padStart(2, '0')
-  countdown.value = `${h}:${m}:${s}`
-}
-const startCountdown = () => {
-  updateCountdown()
-  if (timer) clearInterval(timer)
-  timer = setInterval(updateCountdown, 1000)
-}
-watch(
-  () => props.lottery?.endTime,
-  () => {
-    if (props.lottery && props.lottery.endTime) startCountdown()
-  },
-)
-onMounted(() => {
-  if (props.lottery && props.lottery.endTime) startCountdown()
-})
-onBeforeUnmount(() => {
-  if (timer) clearInterval(timer)
-})
-
 const gotoUser = (id) => navigateTo(`/users/${id}`, { replace: true })
 
 const config = useRuntimeConfig()
@@ -229,6 +191,11 @@ const joinLottery = async () => {
   margin-left: 10px;
 }
 
+.prize-end-time-icon {
+  font-size: 13px;
+  margin-right: 5px;
+}
+
 .prize-end-time-title {
   font-size: 13px;
   opacity: 0.7;

frontend_nuxt/components/PostPoll.vue

@@ -34,7 +34,8 @@
             <div class="poll-option-title" v-else>单选</div>
 
             <div class="poll-left-time">
-              <div class="poll-left-time-title">离结束还有</div>
+              <i class="fas fa-stopwatch poll-left-time-icon"></i>
+              <div class="poll-left-time-title">离结束</div>
               <div class="poll-left-time-value">{{ countdown }}</div>
             </div>
           </div>
@@ -107,7 +108,12 @@
         <i class="fas fa-stopwatch"></i> 投票已结束
       </div>
       <div v-else class="poll-option-hint">
-        <i class="fas fa-stopwatch"></i> 您已投票，等待结束查看结果
+        <div>您已投票，等待结束查看结果</div>
+        <div class="poll-left-time">
+          <i class="fas fa-stopwatch poll-left-time-icon"></i>
+          <div class="poll-left-time-title">离结束</div>
+          <div class="poll-left-time-value">{{ countdown }}</div>
+        </div>
       </div>
     </div>
   </div>
@@ -118,6 +124,7 @@ import { ref, computed, watch, onMounted, onBeforeUnmount } from 'vue'
 import { getToken, authState } from '~/utils/auth'
 import { toast } from '~/main'
 import { useRuntimeConfig } from '#imports'
+import { useCountdown } from '~/composables/useCountdown'
 
 const props = defineProps({
   poll: { type: Object, required: true },
@@ -140,10 +147,9 @@ const pollPercentages = computed(() =>
       })
     : [],
 )
-const pollEnded = computed(() => {
-  if (!props.poll || !props.poll.endTime) return false
-  return new Date(props.poll.endTime).getTime() <= Date.now()
-})
+// 倒计时
+const { countdown, isEnded } = useCountdown(props.poll?.endTime)
+const pollEnded = computed(() => isEnded.value)
 const hasVoted = computed(() => {
   if (!loggedIn.value) return false
   return pollParticipants.value.some((p) => p.id === Number(authState.userId))
@@ -152,45 +158,6 @@ watch([hasVoted, pollEnded], ([voted, ended]) => {
   if (voted || ended) showPollResult.value = true
 })
 
-const countdown = ref('00:00:00')
-let timer = null
-const updateCountdown = () => {
-  if (!props.poll || !props.poll.endTime) {
-    countdown.value = '00:00:00'
-    return
-  }
-  const diff = new Date(props.poll.endTime).getTime() - Date.now()
-  if (diff <= 0) {
-    countdown.value = '00:00:00'
-    if (timer) {
-      clearInterval(timer)
-      timer = null
-    }
-    return
-  }
-  const h = String(Math.floor(diff / 3600000)).padStart(2, '0')
-  const m = String(Math.floor((diff % 3600000) / 60000)).padStart(2, '0')
-  const s = String(Math.floor((diff % 60000) / 1000)).padStart(2, '0')
-  countdown.value = `${h}:${m}:${s}`
-}
-const startCountdown = () => {
-  updateCountdown()
-  if (timer) clearInterval(timer)
-  timer = setInterval(updateCountdown, 1000)
-}
-watch(
-  () => props.poll?.endTime,
-  () => {
-    if (props.poll && props.poll.endTime) startCountdown()
-  },
-)
-onMounted(() => {
-  if (props.poll && props.poll.endTime) startCountdown()
-})
-onBeforeUnmount(() => {
-  if (timer) clearInterval(timer)
-})
-
 const gotoUser = (id) => navigateTo(`/users/${id}`, { replace: true })
 
 const config = useRuntimeConfig()
@@ -361,6 +328,18 @@ const submitMultiPoll = async () => {
   gap: 5px;
 }
 
+.poll-left-time-icon {
+  font-size: 13px;
+}
+
+.poll-option-hint {
+  display: flex;
+  flex-direction: row;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 10px;
+}
+
 .poll-left-time-title {
   font-size: 13px;
   opacity: 0.7;

frontend_nuxt/components/ReactionsGroup.vue

@@ -14,13 +14,12 @@
             :class="{ selected: userReacted(r.type) }"
             @click="toggleReaction(r.type)"
           >
-            <BaseImage :src="reactionEmojiMap[r.type]" class="emoji" alt="emoji" />
+            <BaseImage :src="reactionEmojiMap[r.type]" class="reaction-emoji" alt="emoji" />
             <div>{{ counts[r.type] }}</div>
           </div>
 
           <div class="reactions-viewer-item placeholder" @click="openPanel">
-            <i class="far fa-smile reactions-viewer-item-placeholder-icon"></i>
-            <!-- <span class="reactions-viewer-item-placeholder-text">点击以表态</span> -->
+            <sly-face-whit-smile class="reactions-viewer-item-placeholder-icon" />
           </div>
         </template>
         <template v-else-if="displayedReactions.length">
@@ -42,7 +41,7 @@
         class="make-reaction-item like-reaction"
         @click="toggleReaction('LIKE')"
       >
-        <i v-if="!userReacted('LIKE')" class="far fa-heart"></i>
+        <like v-if="!userReacted('LIKE')" />
         <i v-else class="fas fa-heart"></i>
         <span class="reactions-count" v-if="likeCount">{{ likeCount }}</span>
       </div>
@@ -220,6 +219,7 @@ onMounted(async () => {
   align-items: center;
   width: 100%;
   justify-content: space-between;
+  flex-wrap: wrap;
 }
 
 .reactions-viewer {
@@ -229,6 +229,12 @@ onMounted(async () => {
   align-items: center;
 }
 
+.reaction-emoji {
+  width: 20px;
+  height: 20px;
+  vertical-align: middle;
+}
+
 .reactions-viewer-item-container {
   display: flex;
   flex-direction: row;
@@ -337,5 +343,23 @@ onMounted(async () => {
     font-size: 16px;
     padding: 3px 5px;
   }
+
+  .reactions-viewer-item.placeholder,
+  .reactions-viewer-single-item {
+    padding: 4px 8px;
+    gap: 3px;
+    border: 1px solid var(--normal-border-color);
+    border-radius: 10px;
+    margin-right: 3px;
+    margin-bottom: 3px;
+    font-size: 12px;
+    color: var(--text-color);
+    align-items: center;
+  }
+
+  .reaction-emoji {
+    width: 14px;
+    height: 14px;
+  }
 }
 </style>

frontend_nuxt/components/ThirdPartyAuth.vue

@@ -0,0 +1,183 @@
+<template>
+  <div class="third-party-auth">
+    <div
+      v-for="provider in providers"
+      :key="provider.name"
+      class="third-party-button"
+      :class="provider.name"
+      @click="provider.action"
+    >
+      <img
+        class="third-party-button-icon"
+        :class="provider.name"
+        :src="provider.icon"
+        :alt="provider.alt"
+      />
+      <div class="third-party-button-text" :class="provider.name">
+        {{ provider.label }}
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup>
+import googleIcon from '~/assets/icons/google.svg'
+import githubIcon from '~/assets/icons/github.svg'
+import discordIcon from '~/assets/icons/discord.svg'
+import twitterIcon from '~/assets/icons/twitter.svg'
+import telegramIcon from '~/assets/icons/telegram.svg'
+
+import { googleAuthorize } from '~/utils/google'
+import { githubAuthorize } from '~/utils/github'
+import { discordAuthorize } from '~/utils/discord'
+import { twitterAuthorize } from '~/utils/twitter'
+import { telegramAuthorize } from '~/utils/telegram'
+
+const props = defineProps({
+  mode: {
+    type: String,
+    default: 'login',
+  },
+  inviteToken: {
+    type: String,
+    default: '',
+  },
+})
+
+const actionText = computed(() => (props.mode === 'signup' ? '注册' : '登录'))
+
+const providers = computed(() => [
+  {
+    name: 'google',
+    icon: googleIcon,
+    action: () => googleAuthorize(props.inviteToken),
+    alt: 'Google Logo',
+    label: `Google ${actionText.value}`,
+  },
+  {
+    name: 'github',
+    icon: githubIcon,
+    action: () => githubAuthorize(props.inviteToken),
+    alt: 'GitHub Logo',
+    label: `GitHub ${actionText.value}`,
+  },
+  {
+    name: 'discord',
+    icon: discordIcon,
+    action: () => discordAuthorize(props.inviteToken),
+    alt: 'Discord Logo',
+    label: `Discord ${actionText.value}`,
+  },
+  {
+    name: 'twitter',
+    icon: twitterIcon,
+    action: () => twitterAuthorize(props.inviteToken),
+    alt: 'Twitter Logo',
+    label: `X ${actionText.value}`,
+  },
+  {
+    name: 'telegram',
+    icon: telegramIcon,
+    action: () => telegramAuthorize(props.inviteToken),
+    alt: 'Telegram Logo',
+    label: `Telegram ${actionText.value}`,
+  },
+])
+</script>
+
+<style scoped>
+.third-party-auth {
+  margin-left: 20px;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  width: 30%;
+  gap: 11px;
+}
+
+.third-party-button {
+  display: flex;
+  flex-direction: row;
+  align-items: center;
+  justify-content: center;
+  padding: 7px 20px;
+  min-width: 150px;
+  background-color: var(--login-background-color);
+  border: 1px solid var(--normal-border-color);
+  border-radius: 20px;
+  cursor: pointer;
+  gap: 10px;
+}
+
+.third-party-button:hover {
+  background-color: var(--login-background-color-hover);
+}
+
+.third-party-button-icon {
+  width: 20px;
+  height: 20px;
+}
+
+.third-party-button-text {
+  font-size: 16px;
+}
+
+.third-party-button-text.twitter {
+  color: rgb(182, 182, 182);
+}
+
+/* Provider specific classes for customization */
+.third-party-button.google {
+  background-color: var(--google-bg, var(--login-background-color));
+  color: var(--google-color, inherit);
+}
+.third-party-button.google:hover {
+  background-color: var(--google-bg-hover, var(--login-background-color-hover));
+}
+
+.third-party-button.github {
+  background-color: var(--github-bg, var(--login-background-color));
+  color: var(--github-color, inherit);
+}
+.third-party-button.github:hover {
+  background-color: var(--github-bg-hover, var(--login-background-color-hover));
+}
+
+.third-party-button.discord {
+  background-color: var(--discord-bg, var(--login-background-color));
+  color: var(--discord-color, inherit);
+}
+.third-party-button.discord:hover {
+  background-color: var(--discord-bg-hover, var(--login-background-color-hover));
+}
+
+.third-party-button.twitter {
+  background-color: var(--twitter-bg, var(--login-background-color));
+  color: var(--twitter-color, inherit);
+}
+.third-party-button.twitter:hover {
+  background-color: var(--twitter-bg-hover, var(--login-background-color-hover));
+}
+
+.third-party-button.telegram {
+  background-color: var(--telegram-bg, var(--login-background-color));
+  color: var(--telegram-color, inherit);
+}
+.third-party-button.telegram:hover {
+  background-color: var(--telegram-bg-hover, var(--login-background-color-hover));
+}
+
+@media (max-width: 768px) {
+  .third-party-auth {
+    margin-top: 20px;
+    margin-left: 0px;
+    width: calc(100% - 40px);
+    gap: 10px;
+  }
+
+  .third-party-button {
+    width: calc(100% - 40px);
+  }
+}
+</style>

frontend_nuxt/composables/useChannelsUnreadCount.js

@@ -3,82 +3,73 @@ import { useWebSocket } from './useWebSocket'
 import { getToken } from '~/utils/auth'
 
 const count = ref(0)
-let isInitialized = false
-let wsSubscription = null
+let isInitialized = false;
 
 export function useChannelsUnreadCount() {
-  const config = useRuntimeConfig()
-  const API_BASE_URL = config.public.apiBaseUrl
-  const { subscribe, isConnected, connect } = useWebSocket()
+  const config = useRuntimeConfig();
+  const API_BASE_URL = config.public.apiBaseUrl;
+  const { subscribe, isConnected, connect } = useWebSocket();
 
   const fetchChannelUnread = async () => {
-    const token = getToken()
+    const token = getToken();
     if (!token) {
-      count.value = 0
-      return
+      count.value = 0;
+      return;
     }
     try {
       const response = await fetch(`${API_BASE_URL}/api/channels/unread-count`, {
         headers: { Authorization: `Bearer ${token}` },
-      })
+      });
       if (response.ok) {
-        const data = await response.json()
-        count.value = data
+        const data = await response.json();
+        count.value = data;
       }
     } catch (e) {
-      console.error('Failed to fetch channel unread count:', e)
+      console.error('Failed to fetch channel unread count:', e);
     }
-  }
+  };
+  
+  const setupWebSocketListener = () => {
+    const destination = '/user/queue/channel-unread';
+
+    subscribe(destination, (message) => {
+      const unread = parseInt(message.body, 10);
+      if (!isNaN(unread)) {
+        count.value = unread;
+      }
+    }).then(subscription => {
+      if (subscription) {
+        console.log('频道未读消息订阅成功');
+      }
+    });
+  };
 
   const initialize = () => {
-    const token = getToken()
+    const token = getToken();
     if (!token) {
-      count.value = 0
-      return
+      count.value = 0;
+      return;
     }
-    fetchChannelUnread()
-    if (!isConnected.value) {
-      connect(token)
-    }
-    setupWebSocketListener()
-  }
 
-  const setupWebSocketListener = () => {
-    if (!wsSubscription) {
-      watch(
-        isConnected,
-        (newValue) => {
-          if (newValue && !wsSubscription) {
-            wsSubscription = subscribe('/user/queue/channel-unread', (message) => {
-              const unread = parseInt(message.body, 10)
-              if (!isNaN(unread)) {
-                count.value = unread
-              }
-            })
-          }
-        },
-        { immediate: true },
-      )
+    if (!isConnected.value) {
+      connect(token);
     }
-  }
+
+    fetchChannelUnread();
+    setupWebSocketListener();
+  };
 
   const setFromList = (channels) => {
-    count.value = Array.isArray(channels) ? channels.filter((c) => c.unreadCount > 0).length : 0
-  }
+    count.value = Array.isArray(channels) ? channels.filter((c) => c.unreadCount > 0).length : 0;
+  };
 
-  const hasUnread = computed(() => count.value > 0)
+  const hasUnread = computed(() => count.value > 0);
 
-  const token = getToken()
-  if (token) {
-    if (!isInitialized) {
-      isInitialized = true
-      initialize()
-    } else {
-      fetchChannelUnread()
-      if (!isConnected.value) {
-        connect(token)
-      }
-      setupWebSocketListener()
+  if (!isInitialized) {
+    const token = getToken();
+    if (token) {
+      isInitialized = true;
+      initialize();
     }
   }
 
@@ -88,5 +79,5 @@ export function useChannelsUnreadCount() {
     fetchChannelUnread,
     initialize,
     setFromList,
-  }
+  };
 }

frontend_nuxt/composables/useCountdown.ts

@@ -0,0 +1,51 @@
+import { ref, onMounted, onBeforeUnmount } from 'vue'
+
+/**
+ * 通用倒计时 composable
+ * @param endTime 截止时间字符串或 Date 对象
+ * @returns { countdown, isEnded }
+ */
+export function useCountdown(endTime?: string | Date) {
+  const countdown = ref('')
+  const isEnded = ref(false)
+  let timer: ReturnType<typeof setInterval> | null = null
+
+  const update = () => {
+    if (!endTime) {
+      countdown.value = ''
+      isEnded.value = true
+      return
+    }
+    const diff = new Date(endTime).getTime() - Date.now()
+    if (diff <= 0) {
+      countdown.value = '已结束'
+      isEnded.value = true
+      if (timer) clearInterval(timer)
+      return
+    }
+    // 计算天、时、分、秒
+    const days = Math.floor(diff / (24 * 3600 * 1000))
+    const hours = Math.floor((diff % (24 * 3600 * 1000)) / 3600000)
+    const minutes = Math.floor((diff % 3600000) / 60000)
+    const seconds = Math.floor((diff % 60000) / 1000)
+
+    if (days > 0) {
+      countdown.value = `${days}天 ${hours}小时 ${minutes}分 ${seconds}秒`
+    } else if (hours > 0) {
+      countdown.value = `${hours}小时 ${minutes}分 ${seconds}秒`
+    } else {
+      countdown.value = `${minutes}分 ${seconds}秒`
+    }
+  }
+
+  onMounted(() => {
+    update()
+    timer = setInterval(update, 1000)
+  })
+
+  onBeforeUnmount(() => {
+    if (timer) clearInterval(timer)
+  })
+
+  return { countdown, isEnded }
+}

frontend_nuxt/composables/useUnreadCount.js

@@ -4,7 +4,6 @@ import { getToken } from '~/utils/auth';
 
 const count = ref(0);
 let isInitialized = false;
-let wsSubscription = null;
 
 export function useUnreadCount() {
   const config = useRuntimeConfig();
@@ -30,64 +29,48 @@ export function useUnreadCount() {
     }
   };
 
-  const initialize = async () => {
+  const setupWebSocketListener = () => {
+    console.log('设置未读消息订阅...');
+    const destination = '/user/queue/unread-count';
+    
+    subscribe(destination, (message) => {
+      const unreadCount = parseInt(message.body, 10);
+      if (!isNaN(unreadCount)) {
+        count.value = unreadCount;
+      }
+    }).then(subscription => {
+      if (subscription) {
+        console.log('未读消息订阅成功');
+      }
+    });
+  };
+
+  const initialize = () => {
     const token = getToken();
     if (!token) {
       count.value = 0;
       return;
     }
 
-    // 总是获取最新的未读数量
-    fetchUnreadCount();
-    
-    // 确保WebSocket连接
     if (!isConnected.value) {
       connect(token);
     }
     
-    // 设置WebSocket监听
-    await setupWebSocketListener();
+    fetchUnreadCount();
+    setupWebSocketListener();
   };
 
-  const setupWebSocketListener = async () => {
-    // 只有在还没有订阅的情况下才设置监听
-    if (!wsSubscription) {
-      
-      watch(isConnected, (newValue) => {
-        if (newValue && !wsSubscription) {
-          const destination = `/user/queue/unread-count`;
-          wsSubscription = subscribe(destination, (message) => {
-            const unreadCount = parseInt(message.body, 10);
-            if (!isNaN(unreadCount)) {
-              count.value = unreadCount;
-            }
-          });
-        }
-      }, { immediate: true });
-    }
-  };
-
-  // 自动初始化逻辑 - 确保每次调用都能获取到未读数量并设置监听
-  const token = getToken();
-  if (token) {
-    if (!isInitialized) {
+  if (!isInitialized) {
+    const token = getToken();
+    if (token) {
       isInitialized = true;
-      initialize(); // 完整初始化，包括WebSocket监听
-    } else {
-      // 即使已经初始化，也要确保获取最新的未读数量并确保WebSocket监听存在
-      fetchUnreadCount();
-      
-      // 确保WebSocket连接和监听都存在
-      if (!isConnected.value) {
-        connect(token);
-      }
-      setupWebSocketListener();
+      initialize();
     }
   }
 
   return {
     count,
     fetchUnreadCount,
-    initialize,
+    initialize, 
   };
 }

frontend_nuxt/composables/useWebSocket.js

@@ -1,86 +1,182 @@
-import { ref } from 'vue'
+import { ref, readonly, watch } from 'vue'
 import { Client } from '@stomp/stompjs'
 import SockJS from 'sockjs-client/dist/sockjs.min.js'
 import { useRuntimeConfig } from '#app'
 
 const client = ref(null)
 const isConnected = ref(false)
+const activeSubscriptions = ref(new Map())
+// Store callbacks to allow for re-subscription after reconnect
+const resubscribeCallbacks = new Map()
+
+// Helper for unified subscription logging
+const logSubscriptionActivity = (action, destination, subscriptionId = 'N/A') => {
+  console.log(
+    `[SUB_MAN] ${action} | Dest: ${destination} | SubID: ${subscriptionId} | Active: ${activeSubscriptions.value.size}`
+  )
+}
 
 const connect = (token) => {
-  if (isConnected.value) {
+  if (isConnected.value || (client.value && client.value.active)) {
     return
   }
 
-  const config = useRuntimeConfig()
-  const API_BASE_URL = config.public.apiBaseUrl
-  const socketUrl = `${API_BASE_URL}/api/sockjs`
 
-  const socket = new SockJS(socketUrl)
+  const config = useRuntimeConfig()
+  const WEBSOCKET_URL = config.public.websocketUrl
+  const socketUrl = `${WEBSOCKET_URL}/api/sockjs`
+
   const stompClient = new Client({
-    webSocketFactory: () => socket,
+    webSocketFactory: () => new SockJS(socketUrl),
     connectHeaders: {
       Authorization: `Bearer ${token}`,
     },
-    debug: function (str) {},
-    reconnectDelay: 5000,
+    debug: function (str) {
+    
+    },
+    reconnectDelay: 10000,
     heartbeatIncoming: 4000,
     heartbeatOutgoing: 4000,
   })
 
   stompClient.onConnect = (frame) => {
     isConnected.value = true
+    resubscribeCallbacks.forEach((callback, destination) => {
+        doSubscribe(destination, callback)
+    })
   }
 
   stompClient.onStompError = (frame) => {
-    console.error('WebSocket STOMP error:', frame)
+    console.error('Full frame:', frame)
+  }
+
+  stompClient.onWebSocketError = (event) => {
+    
+  }
+
+  stompClient.onWebSocketClose = (event) => {
+    isConnected.value = false;
+    activeSubscriptions.value.clear();
+    logSubscriptionActivity('Cleared all subscriptions due to WebSocket close', 'N/A');
+  };
+  
+  stompClient.onDisconnect = (frame) => {
+    isConnected.value = false
   }
 
   stompClient.activate()
   client.value = stompClient
 }
 
+const unsubscribe = (destination) => {
+  if (!destination) {
+    return false
+  }
+  const subscription = activeSubscriptions.value.get(destination)
+  if (subscription) {
+    try {
+      subscription.unsubscribe()
+      logSubscriptionActivity('Unsubscribed', destination, subscription.id)
+    } catch (e) {
+      console.error(`Error during unsubscribe for ${destination}:`, e)
+    } finally {
+      activeSubscriptions.value.delete(destination)
+      resubscribeCallbacks.delete(destination)
+    }
+    return true
+  } else {
+    return false
+  }
+}
+
+const unsubscribeAll = () => {
+  logSubscriptionActivity('Unsubscribing from ALL', `Total: ${activeSubscriptions.value.size}`)
+  const destinations = [...activeSubscriptions.value.keys()]
+  destinations.forEach(dest => {
+    unsubscribe(dest)
+  })
+}
+
 const disconnect = () => {
+  unsubscribeAll()
   if (client.value) {
-    isConnected.value = false
-    client.value.deactivate()
+    try {
+      client.value.deactivate()
+    } catch (e) {
+      console.error('Error during client deactivation:', e)
+    }
     client.value = null
+    isConnected.value = false
+  }
+}
+
+const doSubscribe = (destination, callback) => {
+  try {
+    if (!client.value || !client.value.connected) {
+      return null
+    }
+
+    if (activeSubscriptions.value.has(destination)) {
+      unsubscribe(destination)
+    }
+
+    const subscription = client.value.subscribe(destination, (message) => {
+      callback(message)
+    })
+
+    if (subscription) {
+      activeSubscriptions.value.set(destination, subscription)
+      resubscribeCallbacks.set(destination, callback) // Store for re-subscription
+      logSubscriptionActivity('Subscribed', destination, subscription.id)
+      return subscription
+    } else {
+      return null
+    }
+  } catch (error) {
+    console.error(`Exception during subscription to ${destination}:`, error)
+    return null
   }
 }
 
 const subscribe = (destination, callback) => {
-  if (!isConnected.value || !client.value || !client.value.connected) {
-    return null
+  if (!destination) {
+    return Promise.resolve(null)
   }
 
-  try {
-    const subscription = client.value.subscribe(destination, (message) => {
-      try {
-        if (
-          destination.includes('/queue/unread-count') ||
-          destination.includes('/queue/channel-unread')
-        ) {
-          callback(message)
-        } else {
-          const parsedMessage = JSON.parse(message.body)
-          callback(parsedMessage)
+  return new Promise((resolve) => {
+    if (client.value && client.value.connected) {
+      const sub = doSubscribe(destination, callback)
+      resolve(sub)
+    } else {
+      const unwatch = watch(isConnected, (newVal) => {
+        if (newVal) {
+          setTimeout(() => {
+            const sub = doSubscribe(destination, callback)
+            unwatch()
+            resolve(sub)
+          }, 100)
         }
-      } catch (error) {
-        callback(message)
-      }
-    })
-
-    return subscription
-  } catch (error) {
-    return null
-  }
+      }, { immediate: false })
+      
+      setTimeout(() => {
+        unwatch()
+        if (!isConnected.value) {
+          resolve(null)
+        }
+      }, 15000)
+    }
+  })
 }
 
 export function useWebSocket() {
   return {
-    client,
+    client: readonly(client),
     isConnected,
     connect,
     disconnect,
     subscribe,
+    unsubscribe,
+    unsubscribeAll,
+    activeSubscriptions: readonly(activeSubscriptions),
   }
 }

frontend_nuxt/nuxt.config.ts

@@ -6,14 +6,21 @@ export default defineNuxtConfig({
   runtimeConfig: {
     public: {
       apiBaseUrl: process.env.NUXT_PUBLIC_API_BASE_URL || '',
+      websocketUrl: process.env.NUXT_PUBLIC_WEBSOCKET_URL || '',
       websiteBaseUrl: process.env.NUXT_PUBLIC_WEBSITE_BASE_URL || '',
       googleClientId: process.env.NUXT_PUBLIC_GOOGLE_CLIENT_ID || '',
       githubClientId: process.env.NUXT_PUBLIC_GITHUB_CLIENT_ID || '',
       discordClientId: process.env.NUXT_PUBLIC_DISCORD_CLIENT_ID || '',
       twitterClientId: process.env.NUXT_PUBLIC_TWITTER_CLIENT_ID || '',
+      telegramBotId: process.env.NUXT_PUBLIC_TELEGRAM_BOT_ID || '',
     },
   },
-  css: ['vditor/dist/index.css', '~/assets/fonts.css', '~/assets/global.css'],
+  css: [
+    'vditor/dist/index.css',
+    '~/assets/fonts.css',
+    '~/assets/global.css',
+    '@icon-park/vue-next/styles/index.css',
+  ],
   app: {
     pageTransition: { name: 'page', mode: 'out-in' },
     head: {
@@ -70,11 +77,11 @@ export default defineNuxtConfig({
           rel: 'manifest',
           href: '/manifest.webmanifest',
         },
-        {
-          rel: 'stylesheet',
-          href: 'https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.7.2/css/all.min.css',
-          referrerpolicy: 'no-referrer',
-        },
+        // {
+        //   rel: 'stylesheet',
+        //   href: 'https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.7.2/css/all.min.css',
+        //   referrerpolicy: 'no-referrer',
+        // },
       ],
     },
     baseURL: '/',

frontend_nuxt/package-lock.json

@@ -6,6 +6,7 @@
     "": {
       "name": "frontend_nuxt",
       "dependencies": {
+        "@icon-park/vue-next": "^1.4.2",
         "@nuxt/image": "^1.11.0",
         "@stomp/stompjs": "^7.0.0",
         "cropperjs": "^1.6.2",
@@ -25,6 +26,9 @@
         "vue-echarts": "^7.0.3",
         "vue-flatpickr-component": "^12.0.0",
         "vue-toastification": "^2.0.0-rc.5"
+      },
+      "engines": {
+        "node": ">=20.0.0"
       }
     },
     "node_modules/@ampproject/remapping": {
@@ -990,6 +994,19 @@
       "integrity": "sha512-m9FVDXU3GT2ITSe0UaMA5rU3QkfC/UXtCU8y0gSN/GugTqtVldOBWIB5V6V3sbmenVZUIpU6f+mPEO2+m5iTaA==",
       "license": "MIT"
     },
+    "node_modules/@icon-park/vue-next": {
+      "version": "1.4.2",
+      "resolved": "https://registry.npmjs.org/@icon-park/vue-next/-/vue-next-1.4.2.tgz",
+      "integrity": "sha512-+QklF255wkfBOabY+xw6FAI0Bwln/RhdwCunNy/9sKdKuChtaU67QZqU67KGAvZUTeeBgsL+yaHHxqfQeGZXEQ==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">= 8.0.0",
+        "npm": ">= 5.0.0"
+      },
+      "peerDependencies": {
+        "vue": "3.x"
+      }
+    },
     "node_modules/@img/sharp-darwin-arm64": {
       "version": "0.34.3",
       "resolved": "https://registry.npmjs.org/@img/sharp-darwin-arm64/-/sharp-darwin-arm64-0.34.3.tgz",

frontend_nuxt/package.json

@@ -2,6 +2,9 @@
   "name": "frontend_nuxt",
   "private": true,
   "type": "module",
+  "engines": {
+    "node": ">=20.0.0"
+  },
   "scripts": {
     "dev": "nuxt dev",
     "build": "nuxt build",
@@ -9,6 +12,7 @@
     "generate": "nuxt generate"
   },
   "dependencies": {
+    "@icon-park/vue-next": "^1.4.2",
     "@nuxt/image": "^1.11.0",
     "@stomp/stompjs": "^7.0.0",
     "cropperjs": "^1.6.2",

frontend_nuxt/pages/index.vue

@@ -68,12 +68,10 @@
         >
           <div class="article-main-container">
             <NuxtLink class="article-item-title main-item" :to="`/posts/${article.id}`">
-              <i v-if="article.pinned" class="fas fa-thumbtack pinned-icon"></i>
-              <i v-if="article.type === 'LOTTERY'" class="fa-solid fa-gift lottery-icon"></i>
-              <i
-                v-else-if="article.type === 'POLL'"
-                class="fa-solid fa-square-poll-vertical poll-icon"
-              ></i>
+              <pin v-if="article.pinned" theme="outline" class="pinned-icon" />
+              <gift v-if="article.type === 'LOTTERY'" class="lottery-icon" />
+              <ranking-list v-else-if="article.type === 'POLL'" class="poll-icon" />
+              <star v-if="!article.rssExcluded" class="featured-icon" />
               {{ article.title }}
             </NuxtLink>
             <NuxtLink class="article-item-description main-item" :to="`/posts/${article.id}`">
@@ -140,7 +138,6 @@ import { getToken } from '~/utils/auth'
 import { stripMarkdown } from '~/utils/markdown'
 import { useIsMobile } from '~/utils/screen'
 import TimeManager from '~/utils/time'
-
 useHead({
   title: 'OpenIsle - 全面开源的自由社区',
   meta: [
@@ -291,6 +288,7 @@ const {
       members: (p.participants || []).map((m) => ({ id: m.id, avatar: m.avatar })),
       comments: p.commentCount,
       views: p.views,
+      rssExcluded: p.rssExcluded || false,
       time: TimeManager.format(
         selectedTopic.value === '最新回复' ? p.lastReplyAt || p.createdAt : p.createdAt,
       ),
@@ -332,6 +330,7 @@ const fetchNextPage = async () => {
     members: (p.participants || []).map((m) => ({ id: m.id, avatar: m.avatar })),
     comments: p.commentCount,
     views: p.views,
+    rssExcluded: p.rssExcluded || false,
     time: TimeManager.format(
       selectedTopic.value === '最新回复' ? p.lastReplyAt || p.createdAt : p.createdAt,
     ),
@@ -547,11 +546,16 @@ const sanitizeDescription = (text) => stripMarkdown(text)
 
 .pinned-icon,
 .lottery-icon,
+.featured-icon,
 .poll-icon {
   margin-right: 4px;
   color: var(--primary-color);
 }
 
+.featured-icon {
+  color: var(--featured-color);
+}
+
 .article-item-description {
   max-width: 100%;
   margin-top: 10px;

frontend_nuxt/pages/login.vue

@@ -34,35 +34,15 @@
       </div>
     </div>
 
-    <div class="other-login-page-content">
-      <div class="login-page-button" @click="loginWithGoogle">
-        <img class="login-page-button-icon" src="../assets/icons/google.svg" alt="Google Logo" />
-        <div class="login-page-button-text">Google 登录</div>
-      </div>
-      <div class="login-page-button" @click="loginWithGithub">
-        <img class="login-page-button-icon" src="../assets/icons/github.svg" alt="GitHub Logo" />
-        <div class="login-page-button-text">GitHub 登录</div>
-      </div>
-      <div class="login-page-button" @click="loginWithDiscord">
-        <img class="login-page-button-icon" src="../assets/icons/discord.svg" alt="Discord Logo" />
-        <div class="login-page-button-text">Discord 登录</div>
-      </div>
-      <div class="login-page-button" @click="loginWithTwitter">
-        <img class="login-page-button-icon" src="../assets/icons/twitter.svg" alt="Twitter Logo" />
-        <div class="login-page-button-text">Twitter 登录</div>
-      </div>
-    </div>
+    <ThirdPartyAuth mode="login" />
   </div>
 </template>
 
 <script setup>
 import { toast } from '~/main'
 import { setToken, loadCurrentUser } from '~/utils/auth'
-import { googleAuthorize } from '~/utils/google'
-import { githubAuthorize } from '~/utils/github'
-import { discordAuthorize } from '~/utils/discord'
-import { twitterAuthorize } from '~/utils/twitter'
 import BaseInput from '~/components/BaseInput.vue'
+import ThirdPartyAuth from '~/components/ThirdPartyAuth.vue'
 import { registerPush } from '~/utils/push'
 const config = useRuntimeConfig()
 const API_BASE_URL = config.public.apiBaseUrl
@@ -105,19 +85,6 @@ const submitLogin = async () => {
     isWaitingForLogin.value = false
   }
 }
-
-const loginWithGoogle = () => {
-  googleAuthorize()
-}
-const loginWithGithub = () => {
-  githubAuthorize()
-}
-const loginWithDiscord = () => {
-  discordAuthorize()
-}
-const loginWithTwitter = () => {
-  twitterAuthorize()
-}
 </script>
 
 <style scoped>
@@ -190,16 +157,6 @@ const loginWithTwitter = () => {
   font-size: 16px;
 }
 
-.other-login-page-content {
-  margin-left: 20px;
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  justify-content: center;
-  width: 30%;
-  gap: 20px;
-}
-
 .login-page-button-primary {
   margin-top: 20px;
   display: flex;
@@ -229,29 +186,6 @@ const loginWithTwitter = () => {
   background-color: var(--primary-color-disabled);
 }
 
-.login-page-button {
-  display: flex;
-  flex-direction: row;
-  align-items: center;
-  justify-content: center;
-  padding: 10px 20px;
-  min-width: 150px;
-  background-color: var(--login-background-color);
-  border: 1px solid var(--normal-border-color);
-  border-radius: 10px;
-  cursor: pointer;
-  gap: 10px;
-}
-
-.login-page-button:hover {
-  background-color: var(--login-background-color-hover);
-}
-
-.login-page-button-icon {
-  width: 20px;
-  height: 20px;
-}
-
 .login-page-button-text {
   font-size: 16px;
 }
@@ -293,16 +227,5 @@ const loginWithTwitter = () => {
     margin-top: 0px;
     font-size: 13px;
   }
-
-  .other-login-page-content {
-    margin-top: 20px;
-    margin-left: 0px;
-    width: calc(100% - 40px);
-    gap: 10px;
-  }
-
-  .login-page-button {
-    width: calc(100% - 40px);
-  }
 }
 </style>

frontend_nuxt/pages/message-box/[id].vue

@@ -100,10 +100,9 @@ import BasePlaceholder from '~/components/BasePlaceholder.vue'
 const config = useRuntimeConfig()
 const route = useRoute()
 const API_BASE_URL = config.public.apiBaseUrl
-const { connect, disconnect, subscribe, isConnected } = useWebSocket()
+const { connect, subscribe, unsubscribe, isConnected } = useWebSocket()
 const { fetchUnreadCount: refreshGlobalUnreadCount } = useUnreadCount()
 const { fetchChannelUnread: refreshChannelUnread } = useChannelsUnreadCount()
-let subscription = null
 
 const messages = ref([])
 const participants = ref([])
@@ -334,9 +333,16 @@ onMounted(async () => {
   if (currentUser.value) {
     await fetchMessages(0)
     await markConversationAsRead()
+    await nextTick()
+    // 初次进入频道时，平滑滚动到底部
+    scrollToBottomSmooth()
     const token = getToken()
-    if (token && !isConnected.value) {
-      connect(token)
+    if (token) {
+      if (isConnected.value) {
+        subscribeToConversation()
+      } else {
+        connect(token)
+      }
     }
   } else {
     toast.error('请先登录')
@@ -344,37 +350,56 @@ onMounted(async () => {
   }
 })
 
+const subscribeToConversation = () => {
+  if (!currentUser.value) return;
+  const destination = `/topic/conversation/${conversationId}`
+  
+  subscribe(destination, async (message) => {
+    try {
+      const parsedMessage = JSON.parse(message.body)
+
+      if (parsedMessage.sender && parsedMessage.sender.id === currentUser.value.id) {
+        return
+      }
+
+      messages.value.push({
+        ...parsedMessage,
+        src: parsedMessage.sender.avatar,
+        iconClick: () => openUser(parsedMessage.sender.id),
+      })
+
+      await markConversationAsRead()
+      await nextTick()
+      
+      if (isUserNearBottom.value) {
+        scrollToBottomSmooth()
+      }
+    } catch (e) {
+      console.error("Failed to parse websocket message", e)
+    }
+  })
+}
+
 watch(isConnected, (newValue) => {
   if (newValue) {
-    setTimeout(() => {
-      subscription = subscribe(`/topic/conversation/${conversationId}`, async (message) => {
-        // 避免重复显示当前用户发送的消息
-        if (message.sender.id !== currentUser.value.id) {
-          messages.value.push({
-            ...message,
-            src: message.sender.avatar,
-            iconClick: () => {
-              openUser(message.sender.id)
-            },
-          })
-          // 收到消息后只标记已读，不强制滚动（符合“非发送不拉底”）
-          markConversationAsRead()
-          await nextTick()
-          updateNearBottom()
-        }
-      })
-    }, 500)
+    subscribeToConversation()
   }
 })
 
 onActivated(async () => {
-  // 返回页面时：刷新数据与已读，不做强制滚动，保持用户当前位置
+  // 返回页面时：刷新数据与已读，并滚动到底部
   if (currentUser.value) {
     await fetchMessages(0)
     await markConversationAsRead()
     await nextTick()
+    scrollToBottomSmooth()
     updateNearBottom()
-    if (!isConnected.value) {
+    
+    if (isConnected.value) {
+      // 如果已连接，重新订阅
+      subscribeToConversation()
+    } else {
+      // 如果未连接，则发起连接
       const token = getToken()
       if (token) connect(token)
     }
@@ -382,22 +407,17 @@ onActivated(async () => {
 })
 
 onDeactivated(() => {
-  if (subscription) {
-    subscription.unsubscribe()
-    subscription = null
-  }
-  disconnect()
+  const destination = `/topic/conversation/${conversationId}`
+  unsubscribe(destination)
 })
 
 onUnmounted(() => {
-  if (subscription) {
-    subscription.unsubscribe()
-    subscription = null
-  }
+  const destination = `/topic/conversation/${conversationId}`
+  unsubscribe(destination)
+
   if (messagesListEl.value) {
     messagesListEl.value.removeEventListener('scroll', updateNearBottom)
   }
-  disconnect()
 })
 
 function minimize() {

frontend_nuxt/pages/message-box/index.vue

@@ -118,7 +118,7 @@
 </template>
 
 <script setup>
-import { ref, onUnmounted, watch, onActivated, computed } from 'vue'
+import { ref, onUnmounted, watch, onActivated, computed, onDeactivated } from 'vue'
 import { useRoute } from 'vue-router'
 import { getToken, fetchCurrentUser } from '~/utils/auth'
 import { toast } from '~/main'
@@ -139,11 +139,10 @@ const error = ref(null)
 const route = useRoute()
 const currentUser = ref(null)
 const API_BASE_URL = config.public.apiBaseUrl
-const { connect, disconnect, subscribe, isConnected } = useWebSocket()
+const { connect, subscribe, unsubscribe, isConnected } = useWebSocket()
 const { fetchUnreadCount: refreshGlobalUnreadCount } = useUnreadCount()
 const { fetchChannelUnread: refreshChannelUnread, setFromList: setChannelUnreadFromList } =
   useChannelsUnreadCount()
-let subscription = null
 
 const activeTab = ref('channels')
 const tabs = [
@@ -259,37 +258,45 @@ onActivated(async () => {
     refreshGlobalUnreadCount()
     refreshChannelUnread()
     const token = getToken()
-    if (token && !isConnected.value) {
-      connect(token)
+    if (token) {
+      if (isConnected.value) {
+        // 如果已经连接，但可能因为组件销毁而取消了订阅，所以需要重新订阅
+        subscribeToUserMessages()
+      } else {
+        // 如果未连接，则发起连接，连接成功后 watch 回调会处理订阅
+        connect(token)
+      }
     }
   } else {
     loading.value = false
   }
 })
 
-watch(isConnected, (newValue) => {
-  if (newValue && currentUser.value) {
-    const destination = `/topic/user/${currentUser.value.id}/messages`
-
-    // 清理旧的订阅
-    if (subscription) {
-      subscription.unsubscribe()
-    }
-
-    subscription = subscribe(destination, (message) => {
+const subscribeToUserMessages = () => {
+  if (!currentUser.value) return;
+  const destination = `/topic/user/${currentUser.value.id}/messages`
+  
+  subscribe(destination, (message) => {
+    if (activeTab.value === 'messages') {
       fetchConversations()
-      if (activeTab.value === 'channels') {
-        fetchChannels()
-      }
-    })
+    }
+    fetchChannels()
+    refreshGlobalUnreadCount()
+    refreshChannelUnread()
+  })
+}
+
+watch(isConnected, (newValue) => {
+  if (newValue) {
+    subscribeToUserMessages()
   }
 })
 
-onUnmounted(() => {
-  if (subscription) {
-    subscription.unsubscribe()
+onDeactivated(() => {
+  if (currentUser.value) {
+    const destination = `/topic/user/${currentUser.value.id}/messages`
+    unsubscribe(destination)
   }
-  disconnect()
 })
 
 function goToConversation(id) {

frontend_nuxt/pages/message.vue

@@ -14,13 +14,15 @@
         <div class="message-control-container">
           <div class="message-control-title">通知设置</div>
           <div class="message-control-item-container">
-            <div v-for="pref in notificationPrefs" :key="pref.type" class="message-control-item">
-              <div class="message-control-item-label">{{ formatType(pref.type) }}</div>
-              <BaseSwitch
-                :model-value="pref.enabled"
-                @update:modelValue="(val) => togglePref(pref, val)"
-              />
-            </div>
+            <template v-for="pref in notificationPrefs"> 
+              <div v-if="canShowNotification(pref.type)" :key="pref.type" class="message-control-item">
+                <div class="message-control-item-label">{{ formatType(pref.type) }}</div>
+                <BaseSwitch
+                  :model-value="pref.enabled"
+                  @update:modelValue="(val) => togglePref(pref, val)"
+                />
+              </div>
+            </template>
           </div>
         </div>
         <div class="message-control-container">
@@ -753,6 +755,14 @@ const formatType = (t) => {
   }
 }
 
+const isAdmin = computed(() => authState.role === 'ADMIN')
+
+const needAdminSet = new Set(['POST_REVIEW_REQUEST','REGISTER_REQUEST', 'POINT_REDEEM', 'ACTIVITY_REDEEM'])
+
+const canShowNotification = (type) => {
+  return !needAdminSet.has(type) || isAdmin.value
+}
+
 onActivated(async () => {
   page.value = 0
   await fetchNotifications({ page: 0, size: pageSize, unread: selectedTab.value === 'unread' })

frontend_nuxt/pages/posts/[id]/index.vue

@@ -15,6 +15,7 @@
         <div class="article-title-container-right">
           <div v-if="status === 'PENDING'" class="article-pending-button">审核中</div>
           <div v-if="status === 'REJECTED'" class="article-block-button">已拒绝</div>
+          <div v-if="!rssExcluded" class="article-featured-button">精品</div>
           <div v-if="closed" class="article-closed-button">已关闭</div>
           <div
             v-if="!closed && loggedIn && !isAuthor && !subscribed"
@@ -785,7 +786,6 @@ onMounted(async () => {
   background-color: var(--background-color);
   display: flex;
   flex-direction: row;
-  height: 100%;
 }
 
 .loading-container {
@@ -957,6 +957,7 @@ onMounted(async () => {
 
 .article-closed-button,
 .article-subscribe-button-text,
+.article-featured-button,
 .article-unsubscribe-button-text {
   white-space: nowrap;
 }
@@ -998,6 +999,15 @@ onMounted(async () => {
   font-size: 14px;
 }
 
+.article-featured-button {
+  background-color: var(--background-color);
+  color: var(--featured-color);
+  border: 1px solid var(--featured-color);
+  padding: 5px 10px;
+  border-radius: 8px;
+  font-size: 14px;
+}
+
 .article-closed-button {
   background-color: var(--background-color);
   color: gray;

frontend_nuxt/pages/signup.vue

@@ -68,35 +68,15 @@
       </div>
     </div>
 
-    <div class="other-signup-page-content">
-      <div class="signup-page-button" @click="signupWithGoogle">
-        <img class="signup-page-button-icon" src="~/assets/icons/google.svg" alt="Google Logo" />
-        <div class="signup-page-button-text">Google 注册</div>
-      </div>
-      <div class="signup-page-button" @click="signupWithGithub">
-        <img class="signup-page-button-icon" src="~/assets/icons/github.svg" alt="GitHub Logo" />
-        <div class="signup-page-button-text">GitHub 注册</div>
-      </div>
-      <div class="signup-page-button" @click="signupWithDiscord">
-        <img class="signup-page-button-icon" src="~/assets/icons/discord.svg" alt="Discord Logo" />
-        <div class="signup-page-button-text">Discord 注册</div>
-      </div>
-      <div class="signup-page-button" @click="signupWithTwitter">
-        <img class="signup-page-button-icon" src="~/assets/icons/twitter.svg" alt="Twitter Logo" />
-        <div class="signup-page-button-text">Twitter 注册</div>
-      </div>
-    </div>
+    <ThirdPartyAuth mode="signup" :invite-token="inviteToken" />
   </div>
 </template>
 
 <script setup>
 import BaseInput from '~/components/BaseInput.vue'
 import { toast } from '~/main'
-import { discordAuthorize } from '~/utils/discord'
-import { githubAuthorize } from '~/utils/github'
-import { googleAuthorize } from '~/utils/google'
-import { twitterAuthorize } from '~/utils/twitter'
 import { loadCurrentUser, setToken } from '~/utils/auth'
+import ThirdPartyAuth from '~/components/ThirdPartyAuth.vue'
 
 const route = useRoute()
 const config = useRuntimeConfig()
@@ -216,18 +196,6 @@ const verifyCode = async () => {
     isWaitingForEmailVerified.value = false
   }
 }
-const signupWithGoogle = () => {
-  googleAuthorize(inviteToken.value)
-}
-const signupWithGithub = () => {
-  githubAuthorize(inviteToken.value)
-}
-const signupWithDiscord = () => {
-  discordAuthorize(inviteToken.value)
-}
-const signupWithTwitter = () => {
-  twitterAuthorize(inviteToken.value)
-}
 </script>
 
 <style scoped>
@@ -300,16 +268,6 @@ const signupWithTwitter = () => {
   font-size: 16px;
 }
 
-.other-signup-page-content {
-  margin-left: 20px;
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  justify-content: center;
-  width: 30%;
-  gap: 20px;
-}
-
 .signup-page-button-primary {
   margin-top: 20px;
   display: flex;
@@ -339,29 +297,6 @@ const signupWithTwitter = () => {
   background-color: var(--primary-color-hover);
 }
 
-.signup-page-button {
-  display: flex;
-  flex-direction: row;
-  align-items: center;
-  justify-content: center;
-  padding: 10px 20px;
-  background-color: var(--login-background-color);
-  border: 1px solid var(--normal-border-color);
-  border-radius: 10px;
-  cursor: pointer;
-  min-width: 150px;
-  gap: 10px;
-}
-
-.signup-page-button:hover {
-  background-color: var(--login-background-color-hover);
-}
-
-.signup-page-button-icon {
-  width: 20px;
-  height: 20px;
-}
-
 .signup-page-button-text {
   font-size: 16px;
 }
@@ -411,16 +346,5 @@ const signupWithTwitter = () => {
     margin-top: 0px;
     font-size: 13px;
   }
-
-  .other-signup-page-content {
-    margin-top: 20px;
-    margin-left: 0px;
-    width: calc(100% - 40px);
-    gap: 10px;
-  }
-
-  .signup-page-button {
-    width: calc(100% - 40px);
-  }
 }
 </style>

frontend_nuxt/pages/telegram-callback.vue

@@ -0,0 +1,42 @@
+<template>
+  <CallbackPage />
+</template>
+
+<script setup>
+import CallbackPage from '~/components/CallbackPage.vue'
+import { telegramExchange } from '~/utils/telegram'
+
+onMounted(async () => {
+  const url = new URL(window.location.href)
+  const inviteToken =
+    url.searchParams.get('invite_token') || url.searchParams.get('invitetoken') || ''
+  const hash = url.hash.startsWith('#tgAuthResult=') ? url.hash.slice('#tgAuthResult='.length) : ''
+  if (!hash) {
+    navigateTo('/login', { replace: true })
+    return
+  }
+  let authData
+  try {
+    const decoded = atob(hash)
+    const parsed = JSON.parse(decoded)
+    authData = {
+      id: String(parsed.id),
+      firstName: parsed.first_name,
+      lastName: parsed.last_name,
+      username: parsed.username,
+      photoUrl: parsed.photo_url,
+      authDate: parsed.auth_date,
+      hash: parsed.hash,
+    }
+  } catch (e) {
+    navigateTo('/login', { replace: true })
+    return
+  }
+  const result = await telegramExchange(authData, inviteToken, '')
+  if (result.needReason) {
+    navigateTo(`/signup-reason?token=${result.token}`, { replace: true })
+  } else {
+    navigateTo('/', { replace: true })
+  }
+})
+</script>

frontend_nuxt/pages/users/[id].vue

@@ -18,7 +18,7 @@
               class="profile-page-header-subscribe-button"
               @click="subscribeUser"
             >
-              <i class="fas fa-user-plus"></i>
+              <add-user />
               关注
             </div>
             <div
@@ -26,11 +26,11 @@
               class="profile-page-header-unsubscribe-button"
               @click="unsubscribeUser"
             >
-              <i class="fas fa-user-minus"></i>
+              <reduce-user />
               取消关注
             </div>
             <div v-if="!isMine" class="profile-page-header-subscribe-button" @click="sendMessage">
-              <i class="fas fa-paper-plane"></i>
+              <message-one />
               发私信
             </div>
           </div>
@@ -45,7 +45,7 @@
               content="经验值可通过发帖、评论等操作获得，达到目标后即可提升等级，解锁更多功能。"
               placement="bottom"
             >
-              <i class="fas fa-info-circle profile-exp-info"></i>
+              <info class="profile-exp-info" />
             </ToolTip>
           </div>
         </div>
@@ -368,11 +368,11 @@ const selectedTab = ref(
     : 'summary',
 )
 const tabs = [
-  { key: 'summary', label: '总结', icon: 'fas fa-chart-line' },
-  { key: 'timeline', label: '时间线', icon: 'fas fa-clock' },
-  { key: 'following', label: '关注', icon: 'fas fa-user-plus' },
-  { key: 'favorites', label: '收藏', icon: 'fas fa-bookmark' },
-  { key: 'achievements', label: '勋章', icon: 'fas fa-medal' },
+  { key: 'summary', label: '总结', icon: 'ChartLine' },
+  { key: 'timeline', label: '时间线', icon: 'AlarmClock' },
+  { key: 'following', label: '关注', icon: 'AddUser' },
+  { key: 'favorites', label: '收藏', icon: 'Bookmark' },
+  { key: 'achievements', label: '勋章', icon: 'MedalOne' },
 ]
 const followTab = ref('followers')
 
@@ -895,6 +895,7 @@ watch(selectedTab, async (val) => {
   font-weight: bold;
   color: var(--primary-color);
   text-decoration: none;
+  word-break: break-word;
 }
 
 .timeline-link:hover {
@@ -969,9 +970,5 @@ watch(selectedTab, async (val) => {
   .hot-tag {
     width: 100%;
   }
-
-  .profile-timeline {
-    width: calc(100vw - 40px);
-  }
 }
 </style>

frontend_nuxt/plugins/iconpark.client.ts

@@ -0,0 +1,78 @@
+import { defineNuxtPlugin } from 'nuxt/app'
+import {
+  Pin,
+  Fireworks,
+  Gift,
+  RankingList,
+  Star,
+  Edit,
+  HashtagKey,
+  Remind,
+  Info,
+  ChartLine,
+  Finance,
+  Up,
+  Down,
+  TagOne,
+  MedalOne,
+  Next,
+  DropDownList,
+  MoreOne,
+  SunOne,
+  Moon,
+  ComputerOne,
+  Comment,
+  Link,
+  SlyFaceWhitSmile,
+  Like,
+  ApplicationMenu,
+  Search,
+  Copy,
+  Loading,
+  Rss,
+  MessageEmoji,
+  AddUser,
+  ReduceUser,
+  MessageOne,
+  AlarmClock,
+  Bookmark,
+} from '@icon-park/vue-next'
+
+export default defineNuxtPlugin((nuxtApp) => {
+  nuxtApp.vueApp.component('Pin', Pin)
+  nuxtApp.vueApp.component('Fireworks', Fireworks)
+  nuxtApp.vueApp.component('Gift', Gift)
+  nuxtApp.vueApp.component('RankingList', RankingList)
+  nuxtApp.vueApp.component('Star', Star)
+  nuxtApp.vueApp.component('Edit', Edit)
+  nuxtApp.vueApp.component('HashtagKey', HashtagKey)
+  nuxtApp.vueApp.component('Remind', Remind)
+  nuxtApp.vueApp.component('Info', Info)
+  nuxtApp.vueApp.component('ChartLine', ChartLine)
+  nuxtApp.vueApp.component('Finance', Finance)
+  nuxtApp.vueApp.component('Up', Up)
+  nuxtApp.vueApp.component('Down', Down)
+  nuxtApp.vueApp.component('TagOne', TagOne)
+  nuxtApp.vueApp.component('MedalOne', MedalOne)
+  nuxtApp.vueApp.component('Next', Next)
+  nuxtApp.vueApp.component('DropDownList', DropDownList)
+  nuxtApp.vueApp.component('MoreOne', MoreOne)
+  nuxtApp.vueApp.component('SunOne', SunOne)
+  nuxtApp.vueApp.component('Moon', Moon)
+  nuxtApp.vueApp.component('ComputerOne', ComputerOne)
+  nuxtApp.vueApp.component('CommentIcon', Comment)
+  nuxtApp.vueApp.component('LinkIcon', Link)
+  nuxtApp.vueApp.component('SlyFaceWhitSmile', SlyFaceWhitSmile)
+  nuxtApp.vueApp.component('Like', Like)
+  nuxtApp.vueApp.component('ApplicationMenu', ApplicationMenu)
+  nuxtApp.vueApp.component('SearchIcon', Search)
+  nuxtApp.vueApp.component('Copy', Copy)
+  nuxtApp.vueApp.component('Loading', Loading)
+  nuxtApp.vueApp.component('Rss', Rss)
+  nuxtApp.vueApp.component('MessageEmoji', MessageEmoji)
+  nuxtApp.vueApp.component('AddUser', AddUser)
+  nuxtApp.vueApp.component('ReduceUser', ReduceUser)
+  nuxtApp.vueApp.component('MessageOne', MessageOne)
+  nuxtApp.vueApp.component('AlarmClock', AlarmClock)
+  nuxtApp.vueApp.component('Bookmark', Bookmark)
+})

frontend_nuxt/public/googlea6f18c4a543fb356.html

@@ -0,0 +1 @@
+google-site-verification: googlea6f18c4a543fb356.html

frontend_nuxt/utils/reactions.js

@@ -2,7 +2,11 @@ const toCdnUrl = (emoji) => {
   const codepoints = Array.from(emoji)
     .map((c) => c.codePointAt(0).toString(16))
     .join('_')
-  return `https://fonts.gstatic.com/s/e/notoemoji/latest/${codepoints}/emoji.svg`
+  // 国外镜像有点小卡 (=ﾟωﾟ)ﾉ, 国内大部分地区访问时会触发 SNI 封锁 / DNS 污染
+  // return `https://fonts.gstatic.com/s/e/notoemoji/latest/${codepoints}/emoji.svg`
+
+  // loli.net（即字节系开源社区 mirror，比如 jsDelivr 中国优化节点背后的 CDN 体系）. 不会被墙
+  return `https://gstatic.loli.net/s/e/notoemoji/latest/${codepoints}/emoji.svg`
 }
 
 export const reactionEmojiMap = {

frontend_nuxt/utils/telegram.js

@@ -0,0 +1,56 @@
+import { toast } from '../main'
+import { setToken, loadCurrentUser } from './auth'
+import { registerPush } from './push'
+
+export function telegramAuthorize(inviteToken = '') {
+  const config = useRuntimeConfig()
+  const WEBSITE_BASE_URL = config.public.websiteBaseUrl
+  const TELEGRAM_BOT_ID = config.public.telegramBotId
+  if (!TELEGRAM_BOT_ID) {
+    toast.error('Telegram 登录不可用')
+    return
+  }
+  const redirectUri = `${WEBSITE_BASE_URL}/telegram-callback${inviteToken ? `?invite_token=${encodeURIComponent(inviteToken)}` : ''}`
+  const url =
+    `https://oauth.telegram.org/auth` +
+    `?bot_id=${encodeURIComponent(TELEGRAM_BOT_ID)}` +
+    `&origin=${encodeURIComponent(redirectUri)}` +
+    `&request_access=write`
+  // `&redirect_uri=${encodeURIComponent(redirectUri)}`
+  window.location.href = url
+}
+
+export async function telegramExchange(authData, inviteToken = '', reason = '') {
+  try {
+    const config = useRuntimeConfig()
+    const API_BASE_URL = config.public.apiBaseUrl
+    const payload = { ...authData, reason }
+    if (inviteToken) payload.inviteToken = inviteToken
+    const res = await fetch(`${API_BASE_URL}/api/auth/telegram`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(payload),
+    })
+    const data = await res.json()
+    if (res.ok && data.token) {
+      setToken(data.token)
+      await loadCurrentUser()
+      toast.success('登录成功')
+      registerPush?.()
+      return { success: true, needReason: false }
+    } else if (data.reason_code === 'NOT_APPROVED') {
+      toast.info('当前为注册审核模式，请填写注册理由')
+      return { success: false, needReason: true, token: data.token }
+    } else if (data.reason_code === 'IS_APPROVING') {
+      toast.info('您的注册理由正在审批中')
+      return { success: true, needReason: false }
+    } else {
+      toast.error(data.error || '登录失败')
+      return { success: false, needReason: false, error: data.error || '登录失败' }
+    }
+  } catch (e) {
+    console.error(e)
+    toast.error('登录失败')
+    return { success: false, needReason: false, error: '登录失败' }
+  }
+}

frontend_nuxt/utils/tiebaEmoji.js

@@ -1,6 +1,9 @@
+// cdn.jsdelivr.net/gh/... 国内容易抽风
+// export const TIEBA_EMOJI_CDN = 'https://cdn.jsdelivr.net/gh/microlong666/tieba_mobile_emotions@master/'
+
+// Finally方案: 自托管
 export const TIEBA_EMOJI_CDN =
-  'https://cdn.jsdelivr.net/gh/microlong666/tieba_mobile_emotions@master/'
-// export const TIEBA_EMOJI_CDN = 'https://openisle-1307107697.cos.ap-guangzhou.myqcloud.com/assert/vditor/dist/images/emoji/'
+  'https://openisle-1307107697.cos.ap-guangzhou.myqcloud.com/assert/tieba/'
 
 export const tiebaEmoji = (() => {
   const map = { tieba1: TIEBA_EMOJI_CDN + 'image_emoticon.png' }

websocket_service/pom.xml

@@ -0,0 +1,74 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-parent</artifactId>
+        <version>3.1.1</version>
+        <relativePath/> <!-- lookup parent from repository -->
+    </parent>
+    <groupId>com.openisle</groupId>
+    <artifactId>websocket-service</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <name>websocket-service</name>
+    <description>Dedicated WebSocket service for OpenIsle</description>
+    <properties>
+        <java.version>17</java.version>
+    </properties>
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-websocket</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-security</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.jsonwebtoken</groupId>
+            <artifactId>jjwt-api</artifactId>
+            <version>0.11.5</version>
+        </dependency>
+        <dependency>
+            <groupId>io.jsonwebtoken</groupId>
+            <artifactId>jjwt-impl</artifactId>
+            <version>0.11.5</version>
+            <scope>runtime</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.jsonwebtoken</groupId>
+            <artifactId>jjwt-jackson</artifactId>
+            <version>0.11.5</version>
+            <scope>runtime</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <optional>true</optional>
+        </dependency>
+<!--        <dependency>-->
+<!--            <groupId>org.springframework.boot</groupId>-->
+<!--            <artifactId>spring-boot-starter-actuator</artifactId>-->
+<!--        </dependency>-->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>

websocket_service/src/main/java/com/openisle/websocket/WebsocketServiceApplication.java

@@ -0,0 +1,13 @@
+package com.openisle.websocket;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class WebsocketServiceApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(WebsocketServiceApplication.class, args);
+    }
+
+}

websocket_service/src/main/java/com/openisle/websocket/config/RabbitMQConfig.java

@@ -0,0 +1,27 @@
+package com.openisle.websocket.config;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.springframework.amqp.rabbit.connection.ConnectionFactory;
+import org.springframework.amqp.rabbit.core.RabbitTemplate;
+import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class RabbitMQConfig {
+
+    @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 RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
+        RabbitTemplate template = new RabbitTemplate(connectionFactory);
+        template.setMessageConverter(messageConverter());
+        return template;
+    }
+}

websocket_service/src/main/java/com/openisle/websocket/config/WebSocketAuthInterceptor.java

@@ -0,0 +1,84 @@
+package com.openisle.websocket.config;
+
+import com.openisle.websocket.security.JwtService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.messaging.Message;
+import org.springframework.messaging.MessageChannel;
+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.context.SecurityContextHolder;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+
+@Component
+@RequiredArgsConstructor
+@Slf4j
+public class WebSocketAuthInterceptor implements ChannelInterceptor {
+
+    private final JwtService jwtService;
+
+    @Override
+    public Message<?> preSend(Message<?> message, MessageChannel channel) {
+        StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
+
+        if (accessor != null && StompCommand.CONNECT.equals(accessor.getCommand())) {
+            log.info("WebSocket CONNECT 请求 - 开始认证");
+            
+            String authHeader = accessor.getFirstNativeHeader("Authorization");
+            log.debug("Authorization 头: {}", authHeader != null ? "存在" : "缺失");
+            
+            if (authHeader != null && authHeader.startsWith("Bearer ")) {
+                String token = authHeader.substring(7);
+                log.debug("提取的token长度: {}", token.length());
+                
+                try {
+                    String username = jwtService.extractUsername(token);
+                    log.debug("从token中提取的用户名: {}", username);
+                    
+                    if (username != null && jwtService.isTokenValid(token)) {
+                        UsernamePasswordAuthenticationToken authToken =
+                            new UsernamePasswordAuthenticationToken(username, null, new ArrayList<>());
+                        SecurityContextHolder.getContext().setAuthentication(authToken);
+                        accessor.setUser(authToken);
+                        log.info("WebSocket 连接认证成功，用户: {}", username);
+                    } else {
+                        log.warn("WebSocket 连接认证失败 - token无效或用户名为空");
+                        log.debug("用户名: {}, token有效性: {}", username, jwtService.isTokenValid(token));
+                        return null; // 拒绝连接
+                    }
+                } catch (Exception e) {
+                    log.error("WebSocket JWT token处理异常: {}", e.getMessage(), e);
+                    return null; // 拒绝连接
+                }
+            } else {
+                log.warn("WebSocket 连接认证失败 - 缺少有效的Authorization头");
+                log.debug("Authorization头内容: {}", authHeader);
+                return null; // 拒绝连接
+            }
+        } else if (accessor != null && StompCommand.SUBSCRIBE.equals(accessor.getCommand())) {
+            log.debug("WebSocket SUBSCRIBE 请求到: {}", accessor.getDestination());
+        } else if (accessor != null && StompCommand.SEND.equals(accessor.getCommand())) {
+            log.debug("WebSocket SEND 请求到: {}", accessor.getDestination());
+        }
+        
+        return message;
+    }
+
+    @Override
+    public void postSend(Message<?> message, MessageChannel channel, boolean sent) {
+        StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
+        
+        if (accessor != null) {
+            if (StompCommand.CONNECT.equals(accessor.getCommand()) && sent) {
+                log.info("WebSocket 连接建立成功");
+            } else if (StompCommand.DISCONNECT.equals(accessor.getCommand())) {
+                log.info("WebSocket 连接已断开");
+            }
+        }
+    }
+}

websocket_service/src/main/java/com/openisle/websocket/config/WebSocketConfig.java

@@ -0,0 +1,73 @@
+package com.openisle.websocket.config;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.messaging.simp.config.ChannelRegistration;
+import org.springframework.messaging.simp.config.MessageBrokerRegistry;
+import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
+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 WebSocketAuthInterceptor webSocketAuthInterceptor;
+    
+    @Value("${app.website-url}")
+    private String websiteUrl;
+
+    @Override
+    public void configureMessageBroker(MessageBrokerRegistry config) {
+        ThreadPoolTaskScheduler ts = new ThreadPoolTaskScheduler();
+        ts.setPoolSize(1);
+        ts.setThreadNamePrefix("wss-heartbeat-thread-");
+        ts.initialize();
+
+        config.enableSimpleBroker("/queue", "/topic")
+              .setHeartbeatValue(new long[]{10000, 10000})
+              .setTaskScheduler(ts);
+        config.setApplicationDestinationPrefixes("/app");
+        config.setUserDestinationPrefix("/user");
+    }
+
+    @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(webSocketAuthInterceptor);
+    }
+}

websocket_service/src/main/java/com/openisle/websocket/dto/MessageNotificationPayload.java

@@ -0,0 +1,15 @@
+package com.openisle.websocket.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;
+}

websocket_service/src/main/java/com/openisle/websocket/listener/NotificationListener.java

@@ -0,0 +1,114 @@
+package com.openisle.websocket.listener;
+
+import com.openisle.websocket.dto.MessageNotificationPayload;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.amqp.rabbit.annotation.RabbitListener;
+import org.springframework.lang.Nullable;
+import org.springframework.messaging.handler.annotation.Header;
+import org.springframework.messaging.simp.SimpMessagingTemplate;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+import java.util.Map;
+
+@Component
+@RequiredArgsConstructor
+@Slf4j
+public class NotificationListener {
+
+    private final SimpMessagingTemplate messagingTemplate;
+
+    /**
+     * Unified listener for all sharded queues and the backward-compatible legacy queue.
+     *
+     * @param payload The message payload.
+     * @param queueName The name of the queue the message was consumed from. This header is optional.
+     */
+    @RabbitListener(
+            id = "shardedListenerContainer",
+            queues = {
+                "notifications-queue-0", "notifications-queue-1", "notifications-queue-2", "notifications-queue-3",
+                "notifications-queue-4", "notifications-queue-5", "notifications-queue-6", "notifications-queue-7",
+                "notifications-queue-8", "notifications-queue-9", "notifications-queue-a", "notifications-queue-b",
+                "notifications-queue-c", "notifications-queue-d", "notifications-queue-e", "notifications-queue-f",
+                "notifications-queue"
+            }
+    )
+    public void receiveMessage(MessageNotificationPayload payload, @Header("amqp_consumedQueue") @Nullable String queueName) {
+        if (queueName != null) {
+            String queueNamePrefix = "notifications-queue-";
+            if (queueName.startsWith(queueNamePrefix)) {
+                String shardIndexStr = queueName.substring(queueNamePrefix.length());
+                log.info("=== RabbitMQ Message Received from Shard {} ({}) ===", shardIndexStr, queueName);
+            } else {
+                log.info("=== RabbitMQ Message Received from Legacy Queue ({}) ===", queueName);
+            }
+        }
+        String username = payload.getTargetUsername();
+        Object payloadObject = payload.getPayload();
+        log.info("Target username: {}", username);
+        log.info("Payload object type: {}", payloadObject != null ? payloadObject.getClass().getSimpleName() : "null");
+        log.info("Payload content: {}", payloadObject);
+
+        try {
+            if (payloadObject instanceof Map) {
+                Map<String, Object> payloadMap = (Map<String, Object>) payloadObject;
+
+                // 处理包含完整对话信息的消息 - 完全复制之前的WebSocket发送逻辑
+                if (payloadMap.containsKey("message") && payloadMap.containsKey("conversation") && payloadMap.containsKey("senderId")) {
+                    Object messageObj = payloadMap.get("message");
+                    Map<String, Object> conversationInfo = (Map<String, Object>) payloadMap.get("conversation");
+                    Long conversationId = ((Number) conversationInfo.get("id")).longValue();
+                    Long senderId = ((Number) payloadMap.get("senderId")).longValue();
+                    List<Map<String, Object>> participants = (List<Map<String, Object>>) conversationInfo.get("participants");
+
+                    // 1. 发送到conversation topic
+                    String conversationDestination = "/topic/conversation/" + conversationId;
+                    messagingTemplate.convertAndSend(conversationDestination, messageObj);
+                    log.info("Message broadcasted to destination: {}", conversationDestination);
+
+                    // 2. 为所有参与者（除发送者外）发送到个人频道和未读数量
+                    for (Map<String, Object> participant : participants) {
+                        Long participantUserId = ((Number) participant.get("userId")).longValue();
+                        String participantUsername = (String) participant.get("username");
+
+                        if (!participantUserId.equals(senderId)) {
+                            // 发送到用户个人消息频道
+                            String userDestination = "/topic/user/" + participantUserId + "/messages";
+                            messagingTemplate.convertAndSend(userDestination, messageObj);
+                            log.info("Message notification sent to destination: {}", userDestination);
+
+                            // 优先从 participant 中获取未读信息，兼容旧格式
+                            Object unreadCount = participant.getOrDefault("unreadCount", payloadMap.get("unreadCount"));
+                            if (unreadCount != null) {
+                                messagingTemplate.convertAndSendToUser(participantUsername, "/queue/unread-count", unreadCount);
+                                log.info("Sent unread count to user {} via /user/{}/queue/unread-count", participantUsername, participantUsername);
+                            }
+
+                            Object channelUnread = participant.getOrDefault("channelUnread", payloadMap.get("channelUnread"));
+                            if (channelUnread != null) {
+                                messagingTemplate.convertAndSendToUser(participantUsername, "/queue/channel-unread", channelUnread);
+                                log.info("Sent channel-unread to {}", participantUsername);
+                            }
+                        }
+                    }
+                }
+                // 处理简化的消息格式（向后兼容）
+                else if (payloadMap.containsKey("message")) {
+
+                    if (payloadMap.containsKey("unreadCount")) {
+                        messagingTemplate.convertAndSendToUser(username, "/queue/unread-count", payloadMap.get("unreadCount"));
+                        log.info("Sent unread count to user {} via /user/{}/queue/unread-count", username, username);
+                    }
+                    if (payloadMap.containsKey("channelUnread")) {
+                        messagingTemplate.convertAndSendToUser(username, "/queue/channel-unread", payloadMap.get("channelUnread"));
+                        log.info("Sent channel-unread to {}", username);
+                    }
+                }
+            }
+        } catch (Exception e) {
+            log.error("Failed to process and send message for user {}", username, e);
+        }
+    }
+}

websocket_service/src/main/java/com/openisle/websocket/security/ApplicationConfig.java

@@ -0,0 +1,19 @@
+package com.openisle.websocket.security;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.core.userdetails.User;
+import org.springframework.security.core.userdetails.UserDetailsService;
+
+import java.util.Collections;
+
+@Configuration
+@RequiredArgsConstructor
+public class ApplicationConfig {
+
+    @Bean
+    public UserDetailsService userDetailsService() {
+        return username -> new User(username, "", Collections.emptyList());
+    }
+}

websocket_service/src/main/java/com/openisle/websocket/security/JwtService.java

@@ -0,0 +1,98 @@
+package com.openisle.websocket.security;
+
+import io.jsonwebtoken.Claims;
+import io.jsonwebtoken.Jwts;
+import io.jsonwebtoken.security.Keys;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.nio.charset.StandardCharsets;
+import java.security.Key;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.Date;
+import java.util.function.Function;
+
+@Service
+public class JwtService {
+    
+    private static final Logger logger = LoggerFactory.getLogger(JwtService.class);
+
+    @Value("${app.jwt.secret}")
+    private String secret;
+
+    public String extractUsername(String token) {
+        return extractClaim(token, Claims::getSubject);
+    }
+
+    public <T> T extractClaim(String token, Function<Claims, T> claimsResolver) {
+        final Claims claims = extractAllClaims(token);
+        return claimsResolver.apply(claims);
+    }
+
+    public boolean isTokenValid(String token) {
+        try {
+            return !isTokenExpired(token);
+        } catch (Exception e) {
+            return false;
+        }
+    }
+
+    private boolean isTokenExpired(String token) {
+        return extractExpiration(token).before(new Date());
+    }
+
+    private Date extractExpiration(String token) {
+        return extractClaim(token, Claims::getExpiration);
+    }
+
+    private Claims extractAllClaims(String token) {
+        logger.debug("解析JWT token - secret长度: {}", secret != null ? secret.length() : "null");
+        
+        try {
+            return Jwts
+                    .parserBuilder()
+                    .setSigningKey(getSignInKey())
+                    .build()
+                    .parseClaimsJws(token)
+                    .getBody();
+        } catch (Exception e) {
+            logger.error("JWT解析失败: {}", e.getMessage());
+            throw e;
+        }
+    }
+
+    private Key getSignInKey() {
+        // 使用与backend相同的密钥处理方式：直接Base64解码
+        byte[] keyBytes;
+        try {
+            // 尝试Base64解码
+            keyBytes = java.util.Base64.getDecoder().decode(secret);
+        } catch (IllegalArgumentException e) {
+            // 如果不是Base64格式，使用UTF-8字节
+            keyBytes = secret.getBytes(StandardCharsets.UTF_8);
+            // 确保密钥长度至少256位（32字节）
+            if (keyBytes.length < 32) {
+                MessageDigest digest;
+                try {
+                    digest = MessageDigest.getInstance("SHA-256");
+                    keyBytes = digest.digest(keyBytes);
+                } catch (NoSuchAlgorithmException ex) {
+                    throw new IllegalStateException("SHA-256 not available", ex);
+                }
+            }
+        }
+        return Keys.hmacShaKeyFor(keyBytes);
+    }
+
+    public String validateAndGetSubject(String token) {
+        Claims claims = Jwts.parserBuilder()
+                .setSigningKey(getSignInKey())
+                .build()
+                .parseClaimsJws(token)
+                .getBody();
+        return claims.getSubject();
+    }
+}

websocket_service/src/main/java/com/openisle/websocket/security/SecurityConfig.java

@@ -0,0 +1,71 @@
+package com.openisle.websocket.security;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.config.Customizer;
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
+import org.springframework.security.config.http.SessionCreationPolicy;
+import org.springframework.security.web.SecurityFilterChain;
+import org.springframework.web.cors.CorsConfiguration;
+import org.springframework.web.cors.CorsConfigurationSource;
+import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
+
+import java.util.List;
+
+@Configuration
+@EnableWebSecurity
+@RequiredArgsConstructor
+public class SecurityConfig {
+
+    @Value("${app.website-url}")
+    private String websiteUrl;
+
+    @Bean
+    public CorsConfigurationSource corsConfigurationSource() {
+        CorsConfiguration configuration = new CorsConfiguration();
+        configuration.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",
+                "http://30.211.97.238:3000",
+                "http://30.211.97.238",
+                "http://192.168.7.98",
+                "http://192.168.7.98:3000",
+                websiteUrl,
+                websiteUrl.replace("://www.", "://")
+        ));
+        configuration.setAllowedMethods(List.of("GET", "POST", "PUT", "DELETE", "OPTIONS"));
+        configuration.setAllowedHeaders(List.of("*"));
+        configuration.setAllowCredentials(true);
+
+        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
+        source.registerCorsConfiguration("/**", configuration);
+        return source;
+    }
+
+    @Bean
+    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
+        http
+                .csrf().disable()
+                .cors(Customizer.withDefaults())
+                .authorizeHttpRequests(auth -> auth
+                        .requestMatchers("/**").permitAll() // Permit all HTTP requests
+                )
+                .sessionManagement(session -> session
+                        .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
+                );
+        return http.build();
+    }
+}

websocket_service/src/main/resources/application.properties

@@ -0,0 +1,22 @@
+server.port=${SERVER_PORT:8082}
+
+# 服务器配置
+spring.application.name=websocket-service
+
+# RabbitMQ 配置
+spring.rabbitmq.host=${RABBITMQ_HOST:localhost}
+spring.rabbitmq.port=${RABBITMQ_PORT:5672}
+spring.rabbitmq.username=${RABBITMQ_USERNAME:guest}
+spring.rabbitmq.password=${RABBITMQ_PASSWORD:guest}
+spring.rabbitmq.virtual-host=/
+
+# JWT 配置
+app.jwt.secret=${JWT_SECRET:jwt_sec}
+
+# 日志配置
+logging.level.com.openisle=${LOG_LEVEL:INFO}
+logging.level.org.springframework.messaging=${MESSAGING_LOG_LEVEL:DEBUG}
+logging.level.org.springframework.web.socket=${WEBSOCKET_LOG_LEVEL:DEBUG}
+
+# 网站 URL 配置
+app.website-url=${WEBSITE_URL:https://www.open-isle.com}

websocket_service/src/main/resources/logback-spring.xml

@@ -0,0 +1,140 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <!-- 定义日志输出格式 -->
+    <property name="LOG_PATTERN" value="%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n"/>
+    
+    <!-- 控制台输出 -->
+    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>${LOG_PATTERN}</pattern>
+            <charset>UTF-8</charset>
+        </encoder>
+    </appender>
+    
+    <!-- 文件输出 -->
+    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
+        <file>logs/websocket-service.log</file>
+        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
+            <fileNamePattern>logs/websocket-service.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
+            <maxFileSize>10MB</maxFileSize>
+            <maxHistory>30</maxHistory>
+            <totalSizeCap>1GB</totalSizeCap>
+        </rollingPolicy>
+        <encoder>
+            <pattern>${LOG_PATTERN}</pattern>
+            <charset>UTF-8</charset>
+        </encoder>
+    </appender>
+    
+    <!-- WebSocket 相关日志 -->
+    <appender name="WEBSOCKET_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
+        <file>logs/websocket.log</file>
+        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
+            <fileNamePattern>logs/websocket.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
+            <maxFileSize>10MB</maxFileSize>
+            <maxHistory>7</maxHistory>
+            <totalSizeCap>500MB</totalSizeCap>
+        </rollingPolicy>
+        <encoder>
+            <pattern>${LOG_PATTERN}</pattern>
+            <charset>UTF-8</charset>
+        </encoder>
+    </appender>
+    
+    <!-- 错误日志单独输出 -->
+    <appender name="ERROR_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
+        <filter class="ch.qos.logback.classic.filter.LevelFilter">
+            <level>ERROR</level>
+            <onMatch>ACCEPT</onMatch>
+            <onMismatch>DENY</onMismatch>
+        </filter>
+        <file>logs/error.log</file>
+        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
+            <fileNamePattern>logs/error.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
+            <maxFileSize>10MB</maxFileSize>
+            <maxHistory>30</maxHistory>
+            <totalSizeCap>500MB</totalSizeCap>
+        </rollingPolicy>
+        <encoder>
+            <pattern>${LOG_PATTERN}</pattern>
+            <charset>UTF-8</charset>
+        </encoder>
+    </appender>
+    
+    <!-- 异步日志配置 -->
+    <appender name="ASYNC_FILE" class="ch.qos.logback.classic.AsyncAppender">
+        <discardingThreshold>0</discardingThreshold>
+        <queueSize>512</queueSize>
+        <includeCallerData>false</includeCallerData>
+        <appender-ref ref="FILE"/>
+    </appender>
+    
+    <!-- 异步 WebSocket 日志 -->
+    <appender name="ASYNC_WEBSOCKET" class="ch.qos.logback.classic.AsyncAppender">
+        <discardingThreshold>0</discardingThreshold>
+        <queueSize>256</queueSize>
+        <includeCallerData>false</includeCallerData>
+        <appender-ref ref="WEBSOCKET_FILE"/>
+    </appender>
+    
+    <!-- 特定包的日志级别配置 -->
+    <logger name="com.openisle.websocket" level="INFO" additivity="false">
+        <appender-ref ref="CONSOLE"/>
+        <appender-ref ref="ASYNC_FILE"/>
+        <appender-ref ref="ERROR_FILE"/>
+    </logger>
+    
+    <!-- WebSocket 相关日志 -->
+    <logger name="com.openisle.websocket.controller.WebSocketController" level="DEBUG" additivity="false">
+        <appender-ref ref="ASYNC_WEBSOCKET"/>
+        <appender-ref ref="CONSOLE"/>
+    </logger>
+    
+    <logger name="com.openisle.websocket.config.WebSocketAuthInterceptor" level="INFO" additivity="false">
+        <appender-ref ref="ASYNC_WEBSOCKET"/>
+        <appender-ref ref="CONSOLE"/>
+    </logger>
+    
+    <logger name="com.openisle.websocket.listener.NotificationListener" level="INFO" additivity="false">
+        <appender-ref ref="ASYNC_WEBSOCKET"/>
+        <appender-ref ref="CONSOLE"/>
+    </logger>
+    
+    <!-- Spring WebSocket 日志 -->
+    <logger name="org.springframework.web.socket" level="DEBUG" additivity="false">
+        <appender-ref ref="ASYNC_WEBSOCKET"/>
+    </logger>
+    
+    <logger name="org.springframework.messaging" level="DEBUG" additivity="false">
+        <appender-ref ref="ASYNC_WEBSOCKET"/>
+    </logger>
+    
+    <!-- RabbitMQ 日志 -->
+    <logger name="org.springframework.amqp" level="INFO" additivity="false">
+        <appender-ref ref="CONSOLE"/>
+        <appender-ref ref="ASYNC_FILE"/>
+    </logger>
+    
+    <!-- 根日志级别配置 -->
+    <root level="INFO">
+        <appender-ref ref="CONSOLE"/>
+        <appender-ref ref="ASYNC_FILE"/>
+        <appender-ref ref="ERROR_FILE"/>
+    </root>
+    
+    <!-- 开发环境配置 -->
+    <springProfile name="dev">
+        <root level="DEBUG">
+            <appender-ref ref="CONSOLE"/>
+        </root>
+    </springProfile>
+    
+    <!-- 生产环境配置 -->
+    <springProfile name="prod">
+        <root level="WARN">
+            <appender-ref ref="ASYNC_FILE"/>
+            <appender-ref ref="ERROR_FILE"/>
+        </root>
+    </springProfile>
+    
+</configuration>

websocket_service/websocket_service.env.example

@@ -0,0 +1,12 @@
+SERVER_PORT=<your-server-port>
+
+# RabbitMQ 配置
+RABBITMQ_HOST=<your-host>
+RABBITMQ_PORT=<your-port>
+RABBITMQ_USERNAME=<your-username>
+RABBITMQ_PASSWORD=<your-password>
+
+# JWT 配置
+JWT_SECRET=<your-jwt-secret>
+
+WEBSITE_URL=<your-website-url>