生成律师端表及相应代码，

表结构和ER图在文件“Lawyer System Table Structure Specification.md”进行说明
基础接口由AI生成（先开发用不到的接口最后进行删除）：

### 核心用户表（2个）
1. `lawyer_user` - 律师用户表（✅ 已完成）
2. `life_user` - 客户端用户表（✅ 已存在）这个是老表，其他都是新的

### 基础配置表（1个）
3. `lawyer_legal_problem_scenario` - 法律问题场景表（✅ 已完成）

### 核心业务表（4个）
4. `lawyer_consultation_order` - 咨询订单表（✅ 已完成）
5. `lawyer_chat_session` - 聊天会话表（✅ 已完成）
6. `lawyer_chat_message` - 聊天消息表（✅ 已完成）
7. `lawyer_service_area` - 律师服务领域关联表（✅ 已完成）

### 扩展功能表（5个）
8. `lawyer_img` - 律师图片表（✅ 已完成）
9. `lawyer_common_question` - 常见问题表（✅ 已完成）
10. `lawyer_consultation_review` - 咨询评价表（✅ 已完成）
11. `lawyer_payment_transaction` - 支付交易表（✅ 已完成）
12. `lawyer_ai_interaction_log` - AI交互日志表（✅ 已完成）
13. `lawyer_user_search_history` - 用户搜索历史表（✅ 已完成）

Lawyer System Table Structure Specification.md

@@ -0,0 +1,591 @@
+# 法律咨询平台系统 - 数据库表结构分析
+
+## 一、表结构概览
+
+### 核心用户表（2个）
+1. `lawyer_user` - 律师用户表（✅ 已完成）
+2. `life_user` - 客户端用户表（✅ 已存在）
+
+### 基础配置表（1个）
+3. `lawyer_legal_problem_scenario` - 法律问题场景表（✅ 已完成）
+
+### 核心业务表（4个）
+4. `lawyer_consultation_order` - 咨询订单表（✅ 已完成）
+5. `lawyer_chat_session` - 聊天会话表（✅ 已完成）
+6. `lawyer_chat_message` - 聊天消息表（✅ 已完成）
+7. `lawyer_service_area` - 律师服务领域关联表（✅ 已完成）
+
+### 扩展功能表（5个）
+8. `lawyer_img` - 律师图片表（✅ 已完成）
+9. `lawyer_common_question` - 常见问题表（✅ 已完成）
+10. `lawyer_consultation_review` - 咨询评价表（✅ 已完成）
+11. `lawyer_payment_transaction` - 支付交易表（✅ 已完成）
+12. `lawyer_ai_interaction_log` - AI交互日志表（✅ 已完成）
+13. `lawyer_user_search_history` - 用户搜索历史表（✅ 已完成）
+
+---
+
+## 二、详细表结构分析
+
+### 1. `lawyer_user` - 律师用户表
+- **状态**: ✅ 已创建实体类、Mapper、Service、Controller、XML、SQL
+- **用途**: 存储律师用户的基本信息、认证信息、服务信息等
+- **关键字段**:
+  - `id` (主键)
+  - `phone` (手机号, 唯一)
+  - `name` (姓名)
+  - `lawyer_certificate_no` (律师执业证号)
+  - `law_firm` (所属律师事务所名称)
+  - `certification_status` (资质认证状态)
+  - `consultation_fee` (咨询收费标准)
+  - `agency_fee` (代理收费标准)
+  - `service_score` (服务评分)
+  - `service_count` (服务次数)
+- **关联关系**:
+  - **一对多**: 一个律师可以有多个图片 (`lawyer_img`)
+  - **一对多**: 一个律师可以有多个服务领域 (`lawyer_service_area`)
+  - **一对多**: 一个律师可以有多个咨询订单 (`lawyer_consultation_order`)
+  - **一对多**: 一个律师可以有多个聊天会话 (`lawyer_chat_session`)
+  - **一对多**: 一个律师可以收到多个评价 (`lawyer_consultation_review`)
+
+---
+
+### 2. `lawyer_legal_problem_scenario` - 法律问题场景表
+- **状态**: ✅ 已创建实体类、Mapper、Service、Controller、XML、SQL
+- **用途**: 存储法律问题分类的树形结构（一级分类7个，二级分类14个，三级分类30个）
+- **关键字段**:
+  - `id` (主键)
+  - `code` (编号, 如: L1, L1-01, L1-01-01)
+  - `name` (名称)
+  - `parent_id` (父类主键)
+  - `parent_code` (父类编号)
+  - `parentName` (父类名称)
+  - `sort_order` (排序字段)
+  - `status` (状态)
+- **关联关系**:
+  - **自关联**: 树形结构，通过 `parent_id` 关联自身
+  - **一对多**: 一个法律问题场景可以关联多个律师服务领域 (`lawyer_service_area`)
+  - **一对多**: 一个法律问题场景可以有多个咨询订单 (`lawyer_consultation_order`)
+  - **一对多**: 一个法律问题场景可以有多个常见问题 (`lawyer_common_question`)
+  - **一对多**: 一个法律问题场景可以关联多个AI交互日志 (`lawyer_ai_interaction_log`)
+
+---
+
+### 8. `lawyer_img` - 律师图片表
+- **状态**: ✅ 已创建实体类、Mapper、Service、Controller、XML、SQL
+- **用途**: 存储律师相关的图片（头像、执业证、身份证、案例图片等）
+- **关键字段**:
+  - `id` (主键)
+  - `lawyer_id` (律师用户ID, FK -> lawyer_user)
+  - `img_type` (图片类型: 0:其他, 1:头像, 2:执业证照片, 3:身份证正面, 4:身份证反面, 5:案例图片, 6:相册图片, 7:资质证书, 8:荣誉证书, 9:工作照片)
+  - `img_url` (图片链接)
+  - `img_description` (图片描述)
+  - `img_sort` (图片排序)
+  - `business_id` (业务ID)
+- **关联关系**:
+  - **多对一**: 多个图片属于一个律师 (`lawyer_user`)
+
+---
+
+### 7. `lawyer_service_area` - 律师服务领域关联表
+- **状态**: ✅ 已创建实体类、Mapper、Service、Controller、XML、SQL
+- **用途**: 律师与法律问题场景的多对多关联表（律师擅长哪些领域）
+- **关键字段**:
+  - `id` (主键)
+  - `lawyer_user_id` (律师用户ID, FK -> lawyer_user)
+  - `problem_scenar_id` (法律问题场景ID, FK -> lawyer_legal_problem_scenario)
+  - `sort_order` (排序, 数值越小越靠前)
+  - `status` (状态)
+  - **唯一索引**: UK(lawyer_user_id, problem_scenar_id)
+- **关联关系**:
+  - **多对一**: 多个关联记录属于一个律师 (`lawyer_user`)
+  - **多对一**: 多个关联记录关联一个法律问题场景 (`lawyer_legal_problem_scenario`)
+  - **作用**: 实现律师与法律问题场景的多对多关系
+
+---
+
+### 4. `lawyer_consultation_order` - 咨询订单表（核心业务表）
+- **状态**: ✅ 已创建实体类、Mapper、Service、Controller、XML、SQL
+- **用途**: 记录用户与律师之间的咨询订单，是整个业务的核心
+- **关键字段**:
+  - `id` (主键)
+  - `order_number` (订单编号, 唯一, 如: LAW2023071500123)
+  - `client_user_id` (客户端用户ID, FK -> life_user)
+  - `lawyer_user_id` (律师用户ID, FK -> lawyer_user)
+  - `problem_scenar_id` (法律问题场景ID, FK -> lawyer_legal_problem_scenario)
+  - `problem_description` (问题描述)
+  - `order_amount` (订单金额, 单位:分)
+  - `consultation_fee` (咨询费用, 单位:分)
+  - `start_time` (咨询开始时间)
+  - `end_time` (咨询结束时间)
+  - `order_status` (订单状态: 0:待支付, 1:已支付, 2:进行中, 3:已完成, 4:已取消)
+  - `payment_status` (支付状态: 0:未支付, 1:已支付)
+  - `payment_time` (支付时间)
+  - `validity_period` (订单有效期)
+  - `rating` (用户评分, 1-5星)
+  - `comment` (用户评价内容)
+- **关联关系**:
+  - **多对一**: 多个订单属于一个客户端用户 (`life_user`)
+  - **多对一**: 多个订单属于一个律师 (`lawyer_user`)
+  - **多对一**: 多个订单关联一个法律问题场景 (`lawyer_legal_problem_scenario`)
+  - **一对多**: 一个订单可以有一个聊天会话 (`lawyer_chat_session`)
+  - **一对多**: 一个订单可以有多条聊天消息 (`lawyer_chat_message`)
+  - **一对多**: 一个订单可以有多笔支付交易 (`lawyer_payment_transaction`)
+  - **一对一**: 一个订单可以有一个评价 (`lawyer_consultation_review`)
+
+---
+
+### 5. `lawyer_chat_session` - 聊天会话表
+- **状态**: ✅ 已创建实体类、Mapper、Service、Controller、XML、SQL
+- **用途**: 管理咨询会话，关联订单和消息
+- **关键字段**:
+  - `id` (主键)
+  - `consultation_order_id` (咨询订单ID, FK -> lawyer_consultation_order)
+  - `client_user_id` (客户端用户ID, FK -> life_user)
+  - `lawyer_user_id` (律师用户ID, FK -> lawyer_user)
+  - `session_type` (会话类型: 0:文本咨询, 1:语音咨询, 2:视频咨询)
+  - `status` (会话状态: 0:未开始, 1:进行中, 2:已结束)
+  - `last_message_id` (最后一条消息ID, FK -> lawyer_chat_message)
+  - `last_message_time` (最后一条消息时间)
+- **关联关系**:
+  - **多对一**: 多个会话属于一个咨询订单 (`lawyer_consultation_order`)
+  - **多对一**: 多个会话属于一个客户端用户 (`life_user`)
+  - **多对一**: 多个会话属于一个律师 (`lawyer_user`)
+  - **多对一**: 一个会话的最后一条消息 (`lawyer_chat_message`)
+  - **一对多**: 一个会话可以有多条聊天消息 (`lawyer_chat_message`)
+
+---
+
+### 6. `lawyer_chat_message` - 聊天消息表
+- **状态**: ✅ 已创建实体类、Mapper、Service、Controller、XML、SQL
+- **用途**: 存储咨询会话中的具体聊天消息
+- **关键字段**:
+  - `id` (主键)
+  - `chat_session_id` (聊天会话ID, FK -> lawyer_chat_session)
+  - `consultation_order_id` (咨询订单ID, FK -> lawyer_consultation_order, 冗余字段便于查询)
+  - `sender_id` (发送者ID, 可以是life_user的id或lawyer_user的id)
+  - `sender_type` (发送者类型: 0:客户端用户, 1:律师用户)
+  - `message_content` (消息内容, TEXT)
+  - `message_type` (消息类型: 0:文本, 1:图片, 2:语音, 3:文件, 4:视频)
+  - `media_url` (媒体文件URL)
+  - `message_timestamp` (消息发送时间)
+  - `read_status` (阅读状态: 0:未读, 1:已读)
+  - `read_time` (阅读时间)
+- **关联关系**:
+  - **多对一**: 多条消息属于一个聊天会话 (`lawyer_chat_session`)
+  - **多对一**: 多条消息属于一个咨询订单 (`lawyer_consultation_order`)
+  - **被关联**: 可以被 `lawyer_chat_session.last_message_id` 引用
+
+---
+
+### 9. `lawyer_common_question` - 常见问题表
+- **状态**: ✅ 已创建实体类、Mapper、Service、Controller、XML、SQL
+- **用途**: 存储常见问题及回答（FAQ）
+- **关键字段**:
+  - `id` (主键)
+  - `question_text` (问题文本)
+  - `answer_text` (回答内容, TEXT)
+  - `category_type` (分类类型: 0:推荐, 1:常见问题)
+  - `problem_scenar_id` (关联法律问题场景ID, FK -> lawyer_legal_problem_scenario, 可选)
+  - `sort_order` (排序)
+  - `view_count` (浏览次数)
+  - `status` (状态)
+- **关联关系**:
+  - **多对一**: 多个常见问题可以关联一个法律问题场景 (`lawyer_legal_problem_scenario`)
+
+---
+
+### 10. `lawyer_consultation_review` - 咨询评价表
+- **状态**: ✅ 已创建实体类、Mapper、Service、Controller、XML、SQL
+- **用途**: 存储用户对咨询服务的评价
+- **关键字段**:
+  - `id` (主键)
+  - `consultation_order_id` (咨询订单ID, FK -> lawyer_consultation_order)
+  - `client_user_id` (评价用户ID, FK -> life_user)
+  - `lawyer_user_id` (被评价律师ID, FK -> lawyer_user)
+  - `rating` (评分, 1-5星)
+  - `comment` (评价内容, TEXT)
+  - `service_quality` (服务质量评分, 1-5星)
+  - `response_speed` (响应速度评分, 1-5星)
+  - `professional_level` (专业水平评分, 1-5星)
+  - **唯一索引**: UK(consultation_order_id, delete_flag) - 确保一个订单只有一个有效评价
+- **关联关系**:
+  - **一对一**: 一个订单对应一个评价 (`lawyer_consultation_order`)
+  - **多对一**: 多个评价属于一个客户端用户 (`life_user`)
+  - **多对一**: 多个评价属于一个律师 (`lawyer_user`)
+
+---
+
+### 11. `lawyer_payment_transaction` - 支付交易表
+- **状态**: ✅ 已创建实体类、Mapper、Service、Controller、XML、SQL
+- **用途**: 记录支付交易信息
+- **关键字段**:
+  - `id` (主键)
+  - `consultation_order_id` (咨询订单ID, FK -> lawyer_consultation_order)
+  - `client_user_id` (支付用户ID, FK -> life_user)
+  - `transaction_number` (交易流水号, 唯一)
+  - `transaction_amount` (交易金额, 单位:分)
+  - `payment_method` (支付方式: 0:微信, 1:支付宝, 2:银行卡)
+  - `transaction_status` (交易状态: 0:待支付, 1:支付成功, 2:支付失败, 3:已退款)
+  - `transaction_time` (交易时间)
+  - `third_party_trade_no` (第三方交易号)
+  - `refund_amount` (退款金额, 单位:分)
+  - `refund_time` (退款时间)
+- **关联关系**:
+  - **多对一**: 多笔交易属于一个咨询订单 (`lawyer_consultation_order`)
+  - **多对一**: 多笔交易属于一个客户端用户 (`life_user`)
+
+---
+
+### 12. `lawyer_ai_interaction_log` - AI交互日志表
+- **状态**: ✅ 已创建实体类、Mapper、Service、Controller、XML、SQL
+- **用途**: 记录用户与AI助手的对话历史
+- **关键字段**:
+  - `id` (主键)
+  - `client_user_id` (客户端用户ID, FK -> life_user)
+  - `conversation_id` (会话ID, 用于关联同一会话的多条消息)
+  - `query_text` (用户输入内容, TEXT)
+  - `response_text` (AI回复内容, TEXT)
+  - `problem_scenar_id` (关联的法律问题场景ID, FK -> lawyer_legal_problem_scenario, 可选)
+  - `interaction_time` (交互时间)
+- **关联关系**:
+  - **多对一**: 多条日志属于一个客户端用户 (`life_user`)
+  - **多对一**: 多条日志可以关联一个法律问题场景 (`lawyer_legal_problem_scenario`)
+
+---
+
+### 13. `lawyer_user_search_history` - 用户搜索历史表
+- **状态**: ✅ 已创建实体类、Mapper、Service、Controller、XML、SQL
+- **用途**: 存储用户搜索历史（如：搜索律师姓名、法律问题、律所名称）
+- **关键字段**:
+  - `id` (主键)
+  - `client_user_id` (用户ID, FK -> life_user)
+  - `search_keyword` (搜索关键词)
+  - `search_type` (搜索类型: 0:律师姓名, 1:法律问题, 2:律所名称)
+  - `search_time` (搜索时间)
+- **关联关系**:
+  - **多对一**: 多条搜索历史属于一个客户端用户 (`life_user`)
+
+---
+
+### 14. `life_user` - 客户端用户表
+- **状态**: ✅ 已存在实体类、Mapper、Service、Controller
+- **用途**: 存储使用平台进行咨询的普通用户信息（与律师用户区分）
+- **关键字段**:
+  - `id` (主键)
+  - `user_phone` (用户手机号)
+  - `guanfang_phone` (官方手机号)
+  - `user_name` (用户昵称)
+  - `real_name` (真实姓名)
+  - `user_sex` (性别, String类型)
+  - `user_brithday` (生日, 注意字段名拼写)
+  - `user_image` (用户头像URL)
+  - `id_card` (身份证号)
+  - `province`, `city`, `district`, `address` (地址信息)
+  - `jianjie` (简介)
+  - `money` (用户余额, 单位:分)
+  - `pay_password` (支付密码)
+  - `alipay_account` (支付宝账号)
+  - `invited_num` (邀请码)
+  - `invite_code` (个人邀请码)
+  - `bind_invite_code` (绑定他人邀请码)
+  - `xiaofei_time` (消费次数)
+  - `xiaofei_amount` (消费金额)
+  - `chaping_time` (差评次数)
+  - `clock_img_id` (打卡广场小人图片id)
+  - `logout_flag` (注销标记: 0:未注销, 1:已注销)
+  - `logout_reason` (注销原因)
+  - `logout_time` (注销申请时间)
+- **关联关系**:
+  - **一对多**: 一个用户可以有多个咨询订单 (`lawyer_consultation_order`)
+  - **一对多**: 一个用户可以有多个聊天会话 (`lawyer_chat_session`)
+  - **一对多**: 一个用户可以有多个评价 (`lawyer_consultation_review`)
+  - **一对多**: 一个用户可以有多笔支付交易 (`lawyer_payment_transaction`)
+  - **一对多**: 一个用户可以有多个AI交互日志 (`lawyer_ai_interaction_log`)
+  - **一对多**: 一个用户可以有多个搜索历史 (`lawyer_user_search_history`)
+
+---
+
+## 三、表关系图（ER图）
+
+```
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                          核心用户表                                           │
+├─────────────────────────────────────────────────────────────────────────────┤
+│  lawyer_user (律师用户) ──────────┐                                           │
+│  life_user (客户端用户) ──────────┼───────────────────────────┐               │
+└─────────────────────────────────┼───────────────────────────┼───────────────┘
+                                  │                           │
+                                  │                           │
+┌─────────────────────────────────┼───────────────────────────┼──────────────────┐
+│        基础配置表                 │                           │                  │
+├─────────────────────────────────┼───────────────────────────┼──────────────────┤
+│  lawyer_legal_problem_scenario (法律问题场景)                 │                  │
+│       ▲                                                     │                  │
+│       │ (1:N)                                               │                  │
+└─────────────────────────────────────────────────────────────┼──────────────────┘
+                                                              │
+┌─────────────────────────────────────────────────────────────┼──────────────────┐
+│                   核心业务表                                  │                  │
+├─────────────────────────────────────────────────────────────┼──────────────────┤
+│  lawyer_consultation_order (咨询订单) ◄──────────────────────┼───────────────────┤
+│       │                                                     │                  │
+│       │ (1:1)                                               │                  │
+│       ├──► lawyer_consultation_review (咨询评价)             │                  │
+│       │                                                     │                  │
+│       │ (1:N)                                               │                  │
+│       ├──► lawyer_payment_transaction (支付交易)             │                  │
+│       │                                                     │                  │
+│       │ (1:N)                                               │                  │
+│       ├──► lawyer_chat_session (聊天会话)                    │                  │
+│       │       │                                             │                  │
+│       │       │ (1:N)                                       │                  │
+│       │       └──► lawyer_chat_message (聊天消息)            │                  │
+│       │                                                     │                  │
+│                                                             │                  │
+│  lawyer_service_area (律师服务领域)                           │                  │
+│       │                                                     │                  │
+│       ├──► lawyer_user                                      │                  │
+│       └──► lawyer_legal_problem_scenario                    │                  │
+└─────────────────────────────────────────────────────────────┼──────────────────┘
+                                                              │
+┌─────────────────────────────────────────────────────────────┼──────────────────┐
+│                     扩展功能表                                │                  │
+├─────────────────────────────────────────────────────────────┼──────────────────┤
+│  lawyer_img (律师图片) ────► lawyer_user                      │                  │
+│                                                             │                  │
+│  lawyer_common_question (常见问题) ────► lawyer_legal_problem_scenario           │
+│                                                             │                  │
+│  lawyer_ai_interaction_log (AI交互日志) ────► life_user       │                  │
+│                               └───► lawyer_legal_problem_scenario              │
+│                                                             │                  │
+│  lawyer_user_search_history (搜索历史) ────► life_user       │                   │
+└─────────────────────────────────────────────────────────────┴──────────────────┘
+```
+
+---
+
+## 四、表关系详细说明
+
+### 4.1 核心业务关系链
+
+#### 业务流程：咨询订单 → 聊天会话 → 聊天消息
+```
+life_user (客户端用户)
+    └──► lawyer_consultation_order (咨询订单)
+            ├──► lawyer_chat_session (聊天会话)
+            │       └──► lawyer_chat_message (聊天消息) [多条]
+            │
+            ├──► lawyer_payment_transaction (支付交易) [多条]
+            │
+            └──► lawyer_consultation_review (咨询评价) [1条]
+```
+
+#### 律师信息关系链
+```
+lawyer_user (律师用户)
+    ├──► lawyer_img (律师图片) [多条]
+    ├──► lawyer_service_area (服务领域) [多条]
+    │       └──► lawyer_legal_problem_scenario (法律问题场景)
+    │
+    └──► lawyer_consultation_order (咨询订单) [多条]
+```
+
+#### 法律问题场景关系链
+```
+lawyer_legal_problem_scenario (法律问题场景) [树形结构]
+    ├──► lawyer_service_area (律师服务领域) [多条]
+    │       └──► lawyer_user (律师用户)
+    │
+    ├──► lawyer_consultation_order (咨询订单) [多条]
+    │
+    ├──► lawyer_common_question (常见问题) [多条]
+    │
+    └──► lawyer_ai_interaction_log (AI交互日志) [多条]
+```
+
+### 4.2 外键关系汇总
+
+| 子表 | 外键字段 | 父表 | 关系类型 | 说明 |
+|------|---------|------|---------|------|
+| `lawyer_img` | `lawyer_id` | `lawyer_user` | 多对一 | 多个图片属于一个律师 |
+| `lawyer_service_area` | `lawyer_user_id` | `lawyer_user` | 多对一 | 多个服务领域属于一个律师 |
+| `lawyer_service_area` | `problem_scenar_id` | `lawyer_legal_problem_scenario` | 多对一 | 多个关联记录关联一个法律问题场景 |
+| `lawyer_consultation_order` | `client_user_id` | `life_user` | 多对一 | 多个订单属于一个客户端用户 |
+| `lawyer_consultation_order` | `lawyer_user_id` | `lawyer_user` | 多对一 | 多个订单属于一个律师 |
+| `lawyer_consultation_order` | `problem_scenar_id` | `lawyer_legal_problem_scenario` | 多对一 | 多个订单关联一个法律问题场景 |
+| `lawyer_chat_session` | `consultation_order_id` | `lawyer_consultation_order` | 多对一 | 多个会话属于一个订单 |
+| `lawyer_chat_session` | `client_user_id` | `life_user` | 多对一 | 多个会话属于一个客户端用户 |
+| `lawyer_chat_session` | `lawyer_user_id` | `lawyer_user` | 多对一 | 多个会话属于一个律师 |
+| `lawyer_chat_session` | `last_message_id` | `lawyer_chat_message` | 多对一 | 会话的最后一条消息 |
+| `lawyer_chat_message` | `chat_session_id` | `lawyer_chat_session` | 多对一 | 多条消息属于一个会话 |
+| `lawyer_chat_message` | `consultation_order_id` | `lawyer_consultation_order` | 多对一 | 多条消息属于一个订单（冗余） |
+| `lawyer_common_question` | `problem_scenar_id` | `lawyer_legal_problem_scenario` | 多对一 | 多个常见问题关联一个法律问题场景 |
+| `lawyer_consultation_review` | `consultation_order_id` | `lawyer_consultation_order` | 一对一 | 一个订单对应一个评价 |
+| `lawyer_consultation_review` | `client_user_id` | `life_user` | 多对一 | 多个评价属于一个客户端用户 |
+| `lawyer_consultation_review` | `lawyer_user_id` | `lawyer_user` | 多对一 | 多个评价属于一个律师 |
+| `lawyer_payment_transaction` | `consultation_order_id` | `lawyer_consultation_order` | 多对一 | 多笔交易属于一个订单 |
+| `lawyer_payment_transaction` | `client_user_id` | `life_user` | 多对一 | 多笔交易属于一个客户端用户 |
+| `lawyer_ai_interaction_log` | `client_user_id` | `life_user` | 多对一 | 多条日志属于一个客户端用户 |
+| `lawyer_ai_interaction_log` | `problem_scenar_id` | `lawyer_legal_problem_scenario` | 多对一 | 多条日志关联一个法律问题场景 |
+| `lawyer_user_search_history` | `client_user_id` | `life_user` | 多对一 | 多条搜索历史属于一个客户端用户 |
+
+### 4.3 自关联关系
+
+| 表名 | 自关联字段 | 说明 |
+|------|-----------|------|
+| `lawyer_legal_problem_scenario` | `parent_id` | 树形结构，通过 `parent_id` 关联自身，实现三级分类 |
+
+---
+
+## 五、数据完整性约束
+
+### 5.1 唯一约束
+- `lawyer_user.phone` - 手机号唯一
+- `lawyer_consultation_order.order_number` - 订单编号唯一
+- `lawyer_payment_transaction.transaction_number` - 交易流水号唯一
+- `lawyer_service_area(lawyer_user_id, problem_scenar_id)` - 律师与法律问题场景的组合唯一
+- `lawyer_consultation_review(consultation_order_id, delete_flag)` - 一个订单只能有一个有效评价
+
+### 5.2 逻辑删除
+所有表都使用 `delete_flag` 字段进行逻辑删除：
+- `delete_flag = 0` - 未删除
+- `delete_flag = 1` - 已删除
+
+### 5.3 状态字段
+- **订单状态**: `order_status` (0:待支付, 1:已支付, 2:进行中, 3:已完成, 4:已取消)
+- **支付状态**: `payment_status` (0:未支付, 1:已支付)
+- **交易状态**: `transaction_status` (0:待支付, 1:支付成功, 2:支付失败, 3:已退款)
+- **会话状态**: `status` (0:未开始, 1:进行中, 2:已结束)
+- **认证状态**: `certification_status` (0:未认证, 1:认证中, 2:已认证, 3:认证失败)
+
+---
+
+## 六、索引设计建议
+
+### 6.1 主键索引
+所有表的主键 `id` 自动创建主键索引。
+
+### 6.2 外键索引
+所有外键字段都创建索引，提高关联查询性能。
+
+### 6.3 联合索引
+根据常用查询场景创建联合索引：
+
+| 表名 | 联合索引 | 说明 |
+|------|---------|------|
+| `lawyer_user` | `(status, delete_flag)` | 查询可用律师 |
+| `lawyer_consultation_order` | `(client_user_id, order_status, delete_flag)` | 用户订单查询（关联life_user） |
+| `lawyer_consultation_order` | `(lawyer_user_id, order_status, delete_flag)` | 律师订单查询 |
+| `lawyer_chat_message` | `(chat_session_id, message_timestamp, delete_flag)` | 会话消息查询 |
+| `lawyer_service_area` | `(lawyer_user_id, problem_scenar_id, delete_flag)` | 律师服务领域查询 |
+| `lawyer_img` | `(lawyer_id, img_type, delete_flag)` | 律师图片查询 |
+
+### 6.4 时间字段索引
+- `created_time` - 创建时间索引，用于按时间排序
+- `updated_time` - 更新时间索引
+- `last_message_time` - 最后消息时间索引
+- `message_timestamp` - 消息时间戳索引
+
+---
+
+## 七、业务场景查询示例
+
+### 7.1 查询律师的详细信息
+```sql
+SELECT lu.*
+FROM lawyer_user lu
+WHERE lu.id = ? AND lu.delete_flag = 0;
+```
+
+### 7.2 查询律师的服务领域
+```sql
+SELECT lsa.*, lps.name as problem_scenario_name
+FROM lawyer_service_area lsa
+INNER JOIN lawyer_legal_problem_scenario lps ON lsa.problem_scenar_id = lps.id
+WHERE lsa.lawyer_user_id = ? AND lsa.delete_flag = 0 AND lsa.status = 1
+ORDER BY lsa.sort_order;
+```
+
+### 7.3 查询用户的订单列表
+```sql
+SELECT lco.*, lu.name as lawyer_name, lps.name as problem_scenario_name
+FROM lawyer_consultation_order lco
+LEFT JOIN lawyer_user lu ON lco.lawyer_user_id = lu.id
+LEFT JOIN lawyer_legal_problem_scenario lps ON lco.problem_scenar_id = lps.id
+WHERE lco.client_user_id = ? AND lco.delete_flag = 0
+ORDER BY lco.created_time DESC;
+```
+
+### 7.4 查询订单的聊天记录
+```sql
+SELECT lcm.*
+FROM lawyer_chat_message lcm
+WHERE lcm.consultation_order_id = ? AND lcm.delete_flag = 0
+ORDER BY lcm.message_timestamp ASC;
+```
+
+### 7.5 查询律师的评价统计
+```sql
+SELECT 
+    COUNT(*) as total_reviews,
+    AVG(rating) as avg_rating,
+    AVG(service_quality) as avg_service_quality,
+    AVG(response_speed) as avg_response_speed,
+    AVG(professional_level) as avg_professional_level
+FROM lawyer_consultation_review
+WHERE lawyer_user_id = ? AND delete_flag = 0;
+```
+
+---
+
+## 八、注意事项
+
+1. **统一字段命名规范**：
+   - 所有表都包含标准字段：`delete_flag`, `created_time`, `created_user_id`, `updated_time`, `updated_user_id`
+   - 主键统一使用 `id` (INT, AUTO_INCREMENT)
+   - 外键统一命名为 `xxx_id`
+
+2. **逻辑删除**：
+   - 所有表都使用 `delete_flag` 字段进行逻辑删除（0:未删除, 1:已删除）
+   - 使用 `@TableLogic` 注解
+
+3. **索引设计**：
+   - 主键自动创建索引
+   - 外键字段创建索引
+   - 常用查询字段创建联合索引（如：`lawyer_user_id + status + delete_flag`）
+
+4. **金额字段**：
+   - 统一使用 INT 类型，单位：分（避免浮点数精度问题）
+
+5. **时间字段**：
+   - `created_time`: DEFAULT CURRENT_TIMESTAMP
+   - `updated_time`: DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+
+6. **数据一致性**：
+   - 订单状态变更时，需要同步更新相关表的记录
+   - 评价添加后，需要更新律师的评分统计（`lawyer_user.service_score`等）
+
+7. **树形结构**：
+   - `lawyer_legal_problem_scenario` 使用 `parent_id` 实现三级分类
+   - 查询子节点时使用递归查询或维护 `parent_code` 路径
+
+---
+
+## 九、表状态统计
+
+### 已完成（13个表）
+✅ lawyer_user  
+✅ lawyer_legal_problem_scenario  
+✅ lawyer_img  
+✅ lawyer_service_area  
+✅ lawyer_consultation_order  
+✅ lawyer_chat_session  
+✅ lawyer_chat_message  
+✅ lawyer_common_question  
+✅ lawyer_consultation_review  
+✅ lawyer_payment_transaction  
+✅ lawyer_ai_interaction_log  
+✅ lawyer_user_search_history  
+✅ life_user - 客户端用户表（已存在）
+

alien-entity/src/main/java/shop/alien/entity/store/LawyerAiInteractionLog.java

@@ -0,0 +1,77 @@
+package shop.alien.entity.store;
+
+import com.baomidou.mybatisplus.annotation.*;
+import com.baomidou.mybatisplus.extension.activerecord.Model;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonInclude;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.util.Date;
+
+/**
+ * AI交互日志
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Data
+@JsonInclude
+@TableName("lawyer_ai_interaction_log")
+@ApiModel(value = "LawyerAiInteractionLog对象", description = "AI交互日志")
+public class LawyerAiInteractionLog extends Model<LawyerAiInteractionLog> {
+
+    @ApiModelProperty(value = "主键")
+    @TableId(value = "id", type = IdType.AUTO)
+    private Integer id;
+
+    @ApiModelProperty(value = "客户端用户ID")
+    @TableField("client_user_id")
+    private Integer clientUserId;
+
+    @ApiModelProperty(value = "会话ID")
+    @TableField("conversation_id")
+    private String conversationId;
+
+    @ApiModelProperty(value = "用户输入内容")
+    @TableField("query_text")
+    private String queryText;
+
+    @ApiModelProperty(value = "AI回复内容")
+    @TableField("response_text")
+    private String responseText;
+
+    @ApiModelProperty(value = "关联的法律问题场景ID")
+    @TableField("problem_scenar_id")
+    private Integer problemScenarId;
+
+    @ApiModelProperty(value = "交互时间")
+    @TableField("interaction_time")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date interactionTime;
+
+    @ApiModelProperty(value = "删除标记, 0:未删除, 1:已删除")
+    @TableField("delete_flag")
+    @TableLogic
+    private Integer deleteFlag;
+
+    @ApiModelProperty(value = "创建时间")
+    @TableField(value = "created_time", fill = FieldFill.INSERT)
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date createdTime;
+
+    @ApiModelProperty(value = "创建人ID")
+    @TableField("created_user_id")
+    private Integer createdUserId;
+
+    @ApiModelProperty(value = "修改时间")
+    @TableField(value = "updated_time", fill = FieldFill.UPDATE)
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date updatedTime;
+
+    @ApiModelProperty(value = "修改人ID")
+    @TableField("updated_user_id")
+    private Integer updatedUserId;
+}
+

alien-entity/src/main/java/shop/alien/entity/store/LawyerChatMessage.java

@@ -0,0 +1,94 @@
+package shop.alien.entity.store;
+
+import com.baomidou.mybatisplus.annotation.*;
+import com.baomidou.mybatisplus.extension.activerecord.Model;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonInclude;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.util.Date;
+
+/**
+ * 聊天消息
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Data
+@JsonInclude
+@TableName("lawyer_chat_message")
+@ApiModel(value = "LawyerChatMessage对象", description = "聊天消息")
+public class LawyerChatMessage extends Model<LawyerChatMessage> {
+
+    @ApiModelProperty(value = "主键")
+    @TableId(value = "id", type = IdType.AUTO)
+    private Integer id;
+
+    @ApiModelProperty(value = "聊天会话ID")
+    @TableField("chat_session_id")
+    private Integer chatSessionId;
+
+    @ApiModelProperty(value = "咨询订单ID")
+    @TableField("consultation_order_id")
+    private Integer consultationOrderId;
+
+    @ApiModelProperty(value = "发送者ID")
+    @TableField("sender_id")
+    private Integer senderId;
+
+    @ApiModelProperty(value = "发送者类型, 0:客户端用户, 1:律师用户")
+    @TableField("sender_type")
+    private Integer senderType;
+
+    @ApiModelProperty(value = "消息内容")
+    @TableField("message_content")
+    private String messageContent;
+
+    @ApiModelProperty(value = "消息类型, 0:文本, 1:图片, 2:语音, 3:文件, 4:视频")
+    @TableField("message_type")
+    private Integer messageType;
+
+    @ApiModelProperty(value = "媒体文件URL")
+    @TableField("media_url")
+    private String mediaUrl;
+
+    @ApiModelProperty(value = "消息发送时间")
+    @TableField("message_timestamp")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date messageTimestamp;
+
+    @ApiModelProperty(value = "阅读状态, 0:未读, 1:已读")
+    @TableField("read_status")
+    private Integer readStatus;
+
+    @ApiModelProperty(value = "阅读时间")
+    @TableField("read_time")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date readTime;
+
+    @ApiModelProperty(value = "删除标记, 0:未删除, 1:已删除")
+    @TableField("delete_flag")
+    @TableLogic
+    private Integer deleteFlag;
+
+    @ApiModelProperty(value = "创建时间")
+    @TableField(value = "created_time", fill = FieldFill.INSERT)
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date createdTime;
+
+    @ApiModelProperty(value = "创建人ID")
+    @TableField("created_user_id")
+    private Integer createdUserId;
+
+    @ApiModelProperty(value = "修改时间")
+    @TableField(value = "updated_time", fill = FieldFill.UPDATE)
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date updatedTime;
+
+    @ApiModelProperty(value = "修改人ID")
+    @TableField("updated_user_id")
+    private Integer updatedUserId;
+}
+

alien-entity/src/main/java/shop/alien/entity/store/LawyerChatSession.java

@@ -0,0 +1,81 @@
+package shop.alien.entity.store;
+
+import com.baomidou.mybatisplus.annotation.*;
+import com.baomidou.mybatisplus.extension.activerecord.Model;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonInclude;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.util.Date;
+
+/**
+ * 聊天会话
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Data
+@JsonInclude
+@TableName("lawyer_chat_session")
+@ApiModel(value = "LawyerChatSession对象", description = "聊天会话")
+public class LawyerChatSession extends Model<LawyerChatSession> {
+
+    @ApiModelProperty(value = "主键")
+    @TableId(value = "id", type = IdType.AUTO)
+    private Integer id;
+
+    @ApiModelProperty(value = "咨询订单ID")
+    @TableField("consultation_order_id")
+    private Integer consultationOrderId;
+
+    @ApiModelProperty(value = "客户端用户ID")
+    @TableField("client_user_id")
+    private Integer clientUserId;
+
+    @ApiModelProperty(value = "律师用户ID")
+    @TableField("lawyer_user_id")
+    private Integer lawyerUserId;
+
+    @ApiModelProperty(value = "会话类型, 0:文本咨询, 1:语音咨询, 2:视频咨询")
+    @TableField("session_type")
+    private Integer sessionType;
+
+    @ApiModelProperty(value = "会话状态, 0:未开始, 1:进行中, 2:已结束")
+    @TableField("status")
+    private Integer status;
+
+    @ApiModelProperty(value = "最后一条消息ID")
+    @TableField("last_message_id")
+    private Integer lastMessageId;
+
+    @ApiModelProperty(value = "最后一条消息时间")
+    @TableField("last_message_time")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date lastMessageTime;
+
+    @ApiModelProperty(value = "删除标记, 0:未删除, 1:已删除")
+    @TableField("delete_flag")
+    @TableLogic
+    private Integer deleteFlag;
+
+    @ApiModelProperty(value = "创建时间")
+    @TableField(value = "created_time", fill = FieldFill.INSERT)
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date createdTime;
+
+    @ApiModelProperty(value = "创建人ID")
+    @TableField("created_user_id")
+    private Integer createdUserId;
+
+    @ApiModelProperty(value = "修改时间")
+    @TableField(value = "updated_time", fill = FieldFill.UPDATE)
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date updatedTime;
+
+    @ApiModelProperty(value = "修改人ID")
+    @TableField("updated_user_id")
+    private Integer updatedUserId;
+}
+

alien-entity/src/main/java/shop/alien/entity/store/LawyerCommonQuestion.java

@@ -0,0 +1,80 @@
+package shop.alien.entity.store;
+
+import com.baomidou.mybatisplus.annotation.*;
+import com.baomidou.mybatisplus.extension.activerecord.Model;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonInclude;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.util.Date;
+
+/**
+ * 常见问题
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Data
+@JsonInclude
+@TableName("lawyer_common_question")
+@ApiModel(value = "LawyerCommonQuestion对象", description = "常见问题")
+public class LawyerCommonQuestion extends Model<LawyerCommonQuestion> {
+
+    @ApiModelProperty(value = "主键")
+    @TableId(value = "id", type = IdType.AUTO)
+    private Integer id;
+
+    @ApiModelProperty(value = "问题文本")
+    @TableField("question_text")
+    private String questionText;
+
+    @ApiModelProperty(value = "回答内容")
+    @TableField("answer_text")
+    private String answerText;
+
+    @ApiModelProperty(value = "分类类型, 0:推荐, 1:常见问题")
+    @TableField("category_type")
+    private Integer categoryType;
+
+    @ApiModelProperty(value = "关联法律问题场景ID")
+    @TableField("problem_scenar_id")
+    private Integer problemScenarId;
+
+    @ApiModelProperty(value = "排序")
+    @TableField("sort_order")
+    private Integer sortOrder;
+
+    @ApiModelProperty(value = "浏览次数")
+    @TableField("view_count")
+    private Integer viewCount;
+
+    @ApiModelProperty(value = "状态, 0:禁用, 1:启用")
+    @TableField("status")
+    private Integer status;
+
+    @ApiModelProperty(value = "删除标记, 0:未删除, 1:已删除")
+    @TableField("delete_flag")
+    @TableLogic
+    private Integer deleteFlag;
+
+    @ApiModelProperty(value = "创建时间")
+    @TableField(value = "created_time", fill = FieldFill.INSERT)
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date createdTime;
+
+    @ApiModelProperty(value = "创建人ID")
+    @TableField("created_user_id")
+    private Integer createdUserId;
+
+    @ApiModelProperty(value = "修改时间")
+    @TableField(value = "updated_time", fill = FieldFill.UPDATE)
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date updatedTime;
+
+    @ApiModelProperty(value = "修改人ID")
+    @TableField("updated_user_id")
+    private Integer updatedUserId;
+}
+

alien-entity/src/main/java/shop/alien/entity/store/LawyerConsultationOrder.java

@@ -0,0 +1,116 @@
+package shop.alien.entity.store;
+
+import com.baomidou.mybatisplus.annotation.*;
+import com.baomidou.mybatisplus.extension.activerecord.Model;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonInclude;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.util.Date;
+
+/**
+ * 咨询订单
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Data
+@JsonInclude
+@TableName("lawyer_consultation_order")
+@ApiModel(value = "LawyerConsultationOrder对象", description = "咨询订单")
+public class LawyerConsultationOrder extends Model<LawyerConsultationOrder> {
+
+    @ApiModelProperty(value = "主键")
+    @TableId(value = "id", type = IdType.AUTO)
+    private Integer id;
+
+    @ApiModelProperty(value = "订单编号")
+    @TableField("order_number")
+    private String orderNumber;
+
+    @ApiModelProperty(value = "客户端用户ID")
+    @TableField("client_user_id")
+    private Integer clientUserId;
+
+    @ApiModelProperty(value = "律师用户ID")
+    @TableField("lawyer_user_id")
+    private Integer lawyerUserId;
+
+    @ApiModelProperty(value = "法律问题场景ID")
+    @TableField("problem_scenar_id")
+    private Integer problemScenarId;
+
+    @ApiModelProperty(value = "问题描述")
+    @TableField("problem_description")
+    private String problemDescription;
+
+    @ApiModelProperty(value = "订单金额,单位分")
+    @TableField("order_amount")
+    private Integer orderAmount;
+
+    @ApiModelProperty(value = "咨询费用,单位分")
+    @TableField("consultation_fee")
+    private Integer consultationFee;
+
+    @ApiModelProperty(value = "咨询开始时间")
+    @TableField("start_time")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date startTime;
+
+    @ApiModelProperty(value = "咨询结束时间")
+    @TableField("end_time")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date endTime;
+
+    @ApiModelProperty(value = "订单状态, 0:待支付, 1:已支付, 2:进行中, 3:已完成, 4:已取消")
+    @TableField("order_status")
+    private Integer orderStatus;
+
+    @ApiModelProperty(value = "支付状态, 0:未支付, 1:已支付")
+    @TableField("payment_status")
+    private Integer paymentStatus;
+
+    @ApiModelProperty(value = "支付时间")
+    @TableField("payment_time")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date paymentTime;
+
+    @ApiModelProperty(value = "订单有效期")
+    @TableField("validity_period")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date validityPeriod;
+
+    @ApiModelProperty(value = "用户评分, 1-5星")
+    @TableField("rating")
+    private Integer rating;
+
+    @ApiModelProperty(value = "用户评价内容")
+    @TableField("comment")
+    private String comment;
+
+    @ApiModelProperty(value = "删除标记, 0:未删除, 1:已删除")
+    @TableField("delete_flag")
+    @TableLogic
+    private Integer deleteFlag;
+
+    @ApiModelProperty(value = "创建时间")
+    @TableField(value = "created_time", fill = FieldFill.INSERT)
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date createdTime;
+
+    @ApiModelProperty(value = "创建人ID")
+    @TableField("created_user_id")
+    private Integer createdUserId;
+
+    @ApiModelProperty(value = "修改时间")
+    @TableField(value = "updated_time", fill = FieldFill.UPDATE)
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date updatedTime;
+
+    @ApiModelProperty(value = "修改人ID")
+    @TableField("updated_user_id")
+    private Integer updatedUserId;
+}
+

alien-entity/src/main/java/shop/alien/entity/store/LawyerConsultationReview.java

@@ -0,0 +1,84 @@
+package shop.alien.entity.store;
+
+import com.baomidou.mybatisplus.annotation.*;
+import com.baomidou.mybatisplus.extension.activerecord.Model;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonInclude;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.util.Date;
+
+/**
+ * 咨询评价
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Data
+@JsonInclude
+@TableName("lawyer_consultation_review")
+@ApiModel(value = "LawyerConsultationReview对象", description = "咨询评价")
+public class LawyerConsultationReview extends Model<LawyerConsultationReview> {
+
+    @ApiModelProperty(value = "主键")
+    @TableId(value = "id", type = IdType.AUTO)
+    private Integer id;
+
+    @ApiModelProperty(value = "咨询订单ID")
+    @TableField("consultation_order_id")
+    private Integer consultationOrderId;
+
+    @ApiModelProperty(value = "评价用户ID")
+    @TableField("client_user_id")
+    private Integer clientUserId;
+
+    @ApiModelProperty(value = "被评价律师ID")
+    @TableField("lawyer_user_id")
+    private Integer lawyerUserId;
+
+    @ApiModelProperty(value = "评分, 1-5星")
+    @TableField("rating")
+    private Integer rating;
+
+    @ApiModelProperty(value = "评价内容")
+    @TableField("comment")
+    private String comment;
+
+    @ApiModelProperty(value = "服务质量评分, 1-5星")
+    @TableField("service_quality")
+    private Integer serviceQuality;
+
+    @ApiModelProperty(value = "响应速度评分, 1-5星")
+    @TableField("response_speed")
+    private Integer responseSpeed;
+
+    @ApiModelProperty(value = "专业水平评分, 1-5星")
+    @TableField("professional_level")
+    private Integer professionalLevel;
+
+    @ApiModelProperty(value = "删除标记, 0:未删除, 1:已删除")
+    @TableField("delete_flag")
+    @TableLogic
+    private Integer deleteFlag;
+
+    @ApiModelProperty(value = "创建时间")
+    @TableField(value = "created_time", fill = FieldFill.INSERT)
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date createdTime;
+
+    @ApiModelProperty(value = "创建人ID")
+    @TableField("created_user_id")
+    private Integer createdUserId;
+
+    @ApiModelProperty(value = "修改时间")
+    @TableField(value = "updated_time", fill = FieldFill.UPDATE)
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date updatedTime;
+
+    @ApiModelProperty(value = "修改人ID")
+    @TableField("updated_user_id")
+    private Integer updatedUserId;
+}
+

alien-entity/src/main/java/shop/alien/entity/store/LawyerImg.java

@@ -0,0 +1,76 @@
+package shop.alien.entity.store;
+
+import com.baomidou.mybatisplus.annotation.*;
+import com.baomidou.mybatisplus.extension.activerecord.Model;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonInclude;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.util.Date;
+
+/**
+ * 律师图片
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Data
+@JsonInclude
+@TableName("lawyer_img")
+@ApiModel(value = "LawyerImg对象", description = "律师图片")
+public class LawyerImg extends Model<LawyerImg> {
+
+    @ApiModelProperty(value = "主键")
+    @TableId(value = "id", type = IdType.AUTO)
+    private Integer id;
+
+    @ApiModelProperty(value = "律师用户ID")
+    @TableField("lawyer_id")
+    private Integer lawyerId;
+
+    @ApiModelProperty(value = "图片类型, 0:其他, 1:头像, 2:执业证照片, 3:身份证正面, 4:身份证反面, 5:案例图片, 6:相册图片, 7:资质证书, 8:荣誉证书, 9:工作照片")
+    @TableField("img_type")
+    private Integer imgType;
+
+    @ApiModelProperty(value = "图片描述")
+    @TableField("img_description")
+    private String imgDescription;
+
+    @ApiModelProperty(value = "图片排序")
+    @TableField("img_sort")
+    private Integer imgSort;
+
+    @ApiModelProperty(value = "图片链接")
+    @TableField("img_url")
+    private String imgUrl;
+
+    @ApiModelProperty(value = "删除标记, 0:未删除, 1:已删除")
+    @TableField("delete_flag")
+    @TableLogic
+    private Integer deleteFlag;
+
+    @ApiModelProperty(value = "创建时间")
+    @TableField(value = "created_time", fill = FieldFill.INSERT)
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date createdTime;
+
+    @ApiModelProperty(value = "创建人ID")
+    @TableField("created_user_id")
+    private Integer createdUserId;
+
+    @ApiModelProperty(value = "修改时间")
+    @TableField(value = "updated_time", fill = FieldFill.INSERT_UPDATE)
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date updatedTime;
+
+    @ApiModelProperty(value = "修改人ID")
+    @TableField("updated_user_id")
+    private Integer updatedUserId;
+
+    @ApiModelProperty(value = "业务ID")
+    @TableField("business_id")
+    private Integer businessId;
+}
+

alien-entity/src/main/java/shop/alien/entity/store/LawyerLegalProblemScenario.java

@@ -0,0 +1,80 @@
+package shop.alien.entity.store;
+
+import com.baomidou.mybatisplus.annotation.*;
+import com.baomidou.mybatisplus.extension.activerecord.Model;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonInclude;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.util.Date;
+
+/**
+ * 法律问题场景表
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Data
+@JsonInclude
+@TableName("lawyer_legal_problem_scenario")
+@ApiModel(value = "LawyerLegalProblemScenario对象", description = "法律问题场景")
+public class LawyerLegalProblemScenario extends Model<LawyerLegalProblemScenario> {
+
+    @ApiModelProperty(value = "主键")
+    @TableId(value = "id", type = IdType.AUTO)
+    private Integer id;
+
+    @ApiModelProperty(value = "编号")
+    @TableField("code")
+    private String code;
+
+    @ApiModelProperty(value = "名称")
+    @TableField("name")
+    private String name;
+
+    @ApiModelProperty(value = "父类主键")
+    @TableField("parent_id")
+    private Integer parentId;
+
+    @ApiModelProperty(value = "父类编号")
+    @TableField("parent_code")
+    private String parentCode;
+
+    @ApiModelProperty(value = "父类名称")
+    @TableField("parentName")
+    private String parent_name;
+
+    @ApiModelProperty(value = "排序字段, 数值越小越靠前")
+    @TableField("sort_order")
+    private Integer sortOrder;
+
+    @ApiModelProperty(value = "状态, 0:禁用, 1:启用")
+    @TableField("status")
+    private Integer status;
+
+    @ApiModelProperty(value = "删除标记, 0:未删除, 1:已删除")
+    @TableField("delete_flag")
+    @TableLogic
+    private Integer deleteFlag;
+
+    @ApiModelProperty(value = "创建时间")
+    @TableField(value = "created_time", fill = FieldFill.INSERT)
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date createdTime;
+
+    @ApiModelProperty(value = "创建人ID")
+    @TableField("created_user_id")
+    private Integer createdUserId;
+
+    @ApiModelProperty(value = "修改时间")
+    @TableField(value = "updated_time", fill = FieldFill.UPDATE)
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date updatedTime;
+
+    @ApiModelProperty(value = "修改人ID")
+    @TableField("updated_user_id")
+    private Integer updatedUserId;
+}
+

alien-entity/src/main/java/shop/alien/entity/store/LawyerPaymentTransaction.java

@@ -0,0 +1,94 @@
+package shop.alien.entity.store;
+
+import com.baomidou.mybatisplus.annotation.*;
+import com.baomidou.mybatisplus.extension.activerecord.Model;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonInclude;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.util.Date;
+
+/**
+ * 支付交易
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Data
+@JsonInclude
+@TableName("lawyer_payment_transaction")
+@ApiModel(value = "LawyerPaymentTransaction对象", description = "支付交易")
+public class LawyerPaymentTransaction extends Model<LawyerPaymentTransaction> {
+
+    @ApiModelProperty(value = "主键")
+    @TableId(value = "id", type = IdType.AUTO)
+    private Integer id;
+
+    @ApiModelProperty(value = "咨询订单ID")
+    @TableField("consultation_order_id")
+    private Integer consultationOrderId;
+
+    @ApiModelProperty(value = "支付用户ID")
+    @TableField("client_user_id")
+    private Integer clientUserId;
+
+    @ApiModelProperty(value = "交易流水号")
+    @TableField("transaction_number")
+    private String transactionNumber;
+
+    @ApiModelProperty(value = "交易金额,单位分")
+    @TableField("transaction_amount")
+    private Integer transactionAmount;
+
+    @ApiModelProperty(value = "支付方式, 0:微信, 1:支付宝, 2:银行卡")
+    @TableField("payment_method")
+    private Integer paymentMethod;
+
+    @ApiModelProperty(value = "交易状态, 0:待支付, 1:支付成功, 2:支付失败, 3:已退款")
+    @TableField("transaction_status")
+    private Integer transactionStatus;
+
+    @ApiModelProperty(value = "交易时间")
+    @TableField("transaction_time")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date transactionTime;
+
+    @ApiModelProperty(value = "第三方交易号")
+    @TableField("third_party_trade_no")
+    private String thirdPartyTradeNo;
+
+    @ApiModelProperty(value = "退款金额,单位分")
+    @TableField("refund_amount")
+    private Integer refundAmount;
+
+    @ApiModelProperty(value = "退款时间")
+    @TableField("refund_time")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date refundTime;
+
+    @ApiModelProperty(value = "删除标记, 0:未删除, 1:已删除")
+    @TableField("delete_flag")
+    @TableLogic
+    private Integer deleteFlag;
+
+    @ApiModelProperty(value = "创建时间")
+    @TableField(value = "created_time", fill = FieldFill.INSERT)
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date createdTime;
+
+    @ApiModelProperty(value = "创建人ID")
+    @TableField("created_user_id")
+    private Integer createdUserId;
+
+    @ApiModelProperty(value = "修改时间")
+    @TableField(value = "updated_time", fill = FieldFill.UPDATE)
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date updatedTime;
+
+    @ApiModelProperty(value = "修改人ID")
+    @TableField("updated_user_id")
+    private Integer updatedUserId;
+}
+

alien-entity/src/main/java/shop/alien/entity/store/LawyerServiceArea.java

@@ -0,0 +1,68 @@
+package shop.alien.entity.store;
+
+import com.baomidou.mybatisplus.annotation.*;
+import com.baomidou.mybatisplus.extension.activerecord.Model;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonInclude;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.util.Date;
+
+/**
+ * 律师服务领域关联
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Data
+@JsonInclude
+@TableName("lawyer_service_area")
+@ApiModel(value = "LawyerServiceArea对象", description = "律师服务领域关联")
+public class LawyerServiceArea extends Model<LawyerServiceArea> {
+
+    @ApiModelProperty(value = "主键")
+    @TableId(value = "id", type = IdType.AUTO)
+    private Integer id;
+
+    @ApiModelProperty(value = "律师用户ID")
+    @TableField("lawyer_user_id")
+    private Integer lawyerUserId;
+
+    @ApiModelProperty(value = "法律问题场景ID")
+    @TableField("problem_scenar_id")
+    private Integer problemScenarId;
+
+    @ApiModelProperty(value = "排序, 数值越小越靠前")
+    @TableField("sort_order")
+    private Integer sortOrder;
+
+    @ApiModelProperty(value = "状态, 0:禁用, 1:启用")
+    @TableField("status")
+    private Integer status;
+
+    @ApiModelProperty(value = "删除标记, 0:未删除, 1:已删除")
+    @TableField("delete_flag")
+    @TableLogic
+    private Integer deleteFlag;
+
+    @ApiModelProperty(value = "创建时间")
+    @TableField(value = "created_time", fill = FieldFill.INSERT)
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date createdTime;
+
+    @ApiModelProperty(value = "创建人ID")
+    @TableField("created_user_id")
+    private Integer createdUserId;
+
+    @ApiModelProperty(value = "修改时间")
+    @TableField(value = "updated_time", fill = FieldFill.UPDATE)
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date updatedTime;
+
+    @ApiModelProperty(value = "修改人ID")
+    @TableField("updated_user_id")
+    private Integer updatedUserId;
+}
+

alien-entity/src/main/java/shop/alien/entity/store/LawyerUser.java

@@ -0,0 +1,279 @@
+package shop.alien.entity.store;
+
+import com.baomidou.mybatisplus.annotation.*;
+import com.baomidou.mybatisplus.extension.activerecord.Model;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonInclude;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.util.Date;
+
+/**
+ * 律师用户
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Data
+@JsonInclude
+@TableName("lawyer_user")
+@ApiModel(value = "LawyerUser对象", description = "律师用户")
+public class LawyerUser extends Model<LawyerUser> {
+
+    public LawyerUser() {
+    }
+
+    public LawyerUser(Integer id, Integer money) {
+        this.id = id;
+        this.money = money;
+    }
+
+    @ApiModelProperty(value = "主键")
+    @TableId(value = "id", type = IdType.AUTO)
+    private Integer id;
+
+    @ApiModelProperty(value = "手机号")
+    @TableField("phone")
+    private String phone;
+
+    @ApiModelProperty(value = "姓名")
+    @TableField("name")
+    private String name;
+
+    @ApiModelProperty(value = "身份证")
+    @TableField("id_card")
+    private String idCard;
+
+    @ApiModelProperty(value = "密码")
+    @TableField("password")
+    private String password;
+
+    @ApiModelProperty(value = "支付密码")
+    @TableField("pay_password")
+    private String payPassword;
+
+    @ApiModelProperty(value = "用户余额,单位分")
+    @TableField("money")
+    private Integer money;
+
+    @ApiModelProperty(value = "用户状态, 0:禁用, 1:启用")
+    @TableField("status")
+    private Integer status;
+
+    @ApiModelProperty(value = "密码状态, 0:初始密码, 1:已修改, 2:手机号已验证")
+    @TableField("pass_type")
+    private Integer passType;
+
+    @ApiModelProperty(value = "删除标记, 0:未删除, 1:已删除")
+    @TableField("delete_flag")
+    @TableLogic
+    private Integer deleteFlag;
+
+    @ApiModelProperty(value = "创建时间")
+    @TableField(value = "created_time", fill = FieldFill.INSERT)
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date createdTime;
+
+    @ApiModelProperty(value = "创建人ID")
+    @TableField("created_user_id")
+    private Integer createdUserId;
+
+    @ApiModelProperty(value = "修改时间")
+    @TableField(value = "updated_time", fill = FieldFill.UPDATE)
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date updatedTime;
+
+    @ApiModelProperty(value = "修改人ID")
+    @TableField("updated_user_id")
+    private Integer updatedUserId;
+
+    @ApiModelProperty(value = "注销标记, 0:未注销, 1:已注销")
+    @TableField("logout_flag")
+    private Integer logoutFlag;
+
+    @ApiModelProperty(value = "注销原因")
+    @TableField("logout_reason")
+    private String logoutReason;
+
+    @ApiModelProperty(value = "注销申请时间")
+    @TableField(value = "logout_time", fill = FieldFill.INSERT)
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date logoutTime;
+
+    @ApiModelProperty(value = "注销code")
+    @TableField("logout_code")
+    private String logoutCode;
+
+    @ApiModelProperty(value = "昵称")
+    @TableField("nick_name")
+    private String nickName;
+
+    @ApiModelProperty(value = "账号简介")
+    @TableField("account_blurb")
+    private String accountBlurb;
+
+    @ApiModelProperty(value = "头像")
+    @TableField("head_img")
+    private String headImg;
+
+    @ApiModelProperty(value = "支付宝账号")
+    @TableField("alipay_account")
+    private String alipayAccount;
+
+    // ========== 律师特有字段 ==========
+
+    @ApiModelProperty(value = "律师执业证号")
+    @TableField("lawyer_certificate_no")
+    private String lawyerCertificateNo;
+
+    @ApiModelProperty(value = "所属律师事务所")
+    @TableField("law_firm")
+    private String lawFirm;
+
+    @ApiModelProperty(value = "执业年限")
+    @TableField("practice_years")
+    private Integer practiceYears;
+
+    @ApiModelProperty(value = "执业开始日期")
+    @TableField("practice_start_date")
+    @JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+8")
+    private Date practiceStartDate;
+
+    @ApiModelProperty(value = "专业领域,多个用逗号分隔")
+    @TableField("specialty_fields")
+    private String specialtyFields;
+
+    @ApiModelProperty(value = "资质认证状态, 0:未认证, 1:认证中, 2:已认证, 3:认证失败")
+    @TableField("certification_status")
+    private Integer certificationStatus;
+
+    @ApiModelProperty(value = "认证失败原因")
+    @TableField("certification_fail_reason")
+    private String certificationFailReason;
+
+    @ApiModelProperty(value = "认证时间")
+    @TableField("certification_time")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date certificationTime;
+
+    @ApiModelProperty(value = "认证审核人ID")
+    @TableField("certification_reviewer_id")
+    private Integer certificationReviewerId;
+
+    @ApiModelProperty(value = "执业证照片")
+    @TableField("certificate_image")
+    private String certificateImage;
+
+    @ApiModelProperty(value = "身份证正面照片")
+    @TableField("id_card_front_image")
+    private String idCardFrontImage;
+
+    @ApiModelProperty(value = "身份证反面照片")
+    @TableField("id_card_back_image")
+    private String idCardBackImage;
+
+    @ApiModelProperty(value = "服务评分, 0-100分")
+    @TableField("service_score")
+    private Integer serviceScore;
+
+    @ApiModelProperty(value = "服务次数")
+    @TableField("service_count")
+    private Integer serviceCount;
+
+    @ApiModelProperty(value = "好评数")
+    @TableField("good_review_count")
+    private Integer goodReviewCount;
+
+    @ApiModelProperty(value = "中评数")
+    @TableField("medium_review_count")
+    private Integer mediumReviewCount;
+
+    @ApiModelProperty(value = "差评数")
+    @TableField("bad_review_count")
+    private Integer badReviewCount;
+
+    @ApiModelProperty(value = "咨询收费标准(单位分/小时)")
+    @TableField("consultation_fee")
+    private Integer consultationFee;
+
+    @ApiModelProperty(value = "代理收费标准(单位分)")
+    @TableField("agency_fee")
+    private Integer agencyFee;
+
+    @ApiModelProperty(value = "所属省份")
+    @TableField("province")
+    private String province;
+
+    @ApiModelProperty(value = "所属城市")
+    @TableField("city")
+    private String city;
+
+    @ApiModelProperty(value = "所属区县")
+    @TableField("district")
+    private String district;
+
+    @ApiModelProperty(value = "详细地址")
+    @TableField("address")
+    private String address;
+
+    @ApiModelProperty(value = "邮箱")
+    @TableField("email")
+    private String email;
+
+    @ApiModelProperty(value = "性别, 0:未知, 1:男, 2:女")
+    @TableField("gender")
+    private Integer gender;
+
+    @ApiModelProperty(value = "生日")
+    @TableField("birthday")
+    @JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+8")
+    private Date birthday;
+
+    @ApiModelProperty(value = "个人简介(详细)")
+    @TableField("personal_introduction")
+    private String personalIntroduction;
+
+    @ApiModelProperty(value = "教育背景")
+    @TableField("education_background")
+    private String educationBackground;
+
+    @ApiModelProperty(value = "工作经历")
+    @TableField("work_experience")
+    private String workExperience;
+
+    @ApiModelProperty(value = "擅长案件类型")
+    @TableField("expertise_cases")
+    private String expertiseCases;
+
+    @ApiModelProperty(value = "是否在线, 0:离线, 1:在线")
+    @TableField("is_online")
+    private Integer isOnline;
+
+    @ApiModelProperty(value = "最后在线时间")
+    @TableField("last_online_time")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date lastOnlineTime;
+
+    @ApiModelProperty(value = "是否推荐, 0:不推荐, 1:推荐")
+    @TableField("is_recommended")
+    private Integer isRecommended;
+
+    @ApiModelProperty(value = "推荐排序")
+    @TableField("recommend_sort")
+    private Integer recommendSort;
+
+    @TableField(exist = false)
+    private String userName;
+
+    @TableField(exist = false)
+    private String userImage;
+
+    @TableField(exist = false)
+    private String jianjie;
+
+    @TableField(exist = false)
+    private String moneyStr;
+}
+

alien-entity/src/main/java/shop/alien/entity/store/LawyerUserSearchHistory.java

@@ -0,0 +1,56 @@
+package shop.alien.entity.store;
+
+import com.baomidou.mybatisplus.annotation.*;
+import com.baomidou.mybatisplus.extension.activerecord.Model;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonInclude;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.util.Date;
+
+/**
+ * 用户搜索历史
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Data
+@JsonInclude
+@TableName("lawyer_user_search_history")
+@ApiModel(value = "LawyerUserSearchHistory对象", description = "用户搜索历史")
+public class LawyerUserSearchHistory extends Model<LawyerUserSearchHistory> {
+
+    @ApiModelProperty(value = "主键")
+    @TableId(value = "id", type = IdType.AUTO)
+    private Integer id;
+
+    @ApiModelProperty(value = "用户ID")
+    @TableField("client_user_id")
+    private Integer clientUserId;
+
+    @ApiModelProperty(value = "搜索关键词")
+    @TableField("search_keyword")
+    private String searchKeyword;
+
+    @ApiModelProperty(value = "搜索类型, 0:律师姓名, 1:法律问题, 2:律所名称")
+    @TableField("search_type")
+    private Integer searchType;
+
+    @ApiModelProperty(value = "搜索时间")
+    @TableField("search_time")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date searchTime;
+
+    @ApiModelProperty(value = "删除标记, 0:未删除, 1:已删除")
+    @TableField("delete_flag")
+    @TableLogic
+    private Integer deleteFlag;
+
+    @ApiModelProperty(value = "创建时间")
+    @TableField(value = "created_time", fill = FieldFill.INSERT)
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date createdTime;
+}
+

alien-entity/src/main/java/shop/alien/entity/store/vo/LawyerImgTypeVo.java

@@ -0,0 +1,29 @@
+package shop.alien.entity.store.vo;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+/**
+ * 律师图片类型
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Data
+@JsonInclude
+public class LawyerImgTypeVo {
+
+    @ApiModelProperty(value = "图片类型, 0:其他, 1:头像, 2:执业证照片, 3:身份证正面, 4:身份证反面, 5:案例图片, 6:相册图片, 7:资质证书, 8:荣誉证书, 9:工作照片")
+    private Integer imgType;
+
+    @ApiModelProperty(value = "图片类型字符串")
+    private String imgTypeStr;
+
+    @ApiModelProperty(value = "数量")
+    private Integer count;
+
+    @ApiModelProperty(value = "图片地址")
+    private String imgUrl;
+}
+

alien-entity/src/main/java/shop/alien/mapper/LawyerAiInteractionLogMapper.java

@@ -0,0 +1,19 @@
+package shop.alien.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.apache.ibatis.annotations.Mapper;
+import shop.alien.entity.store.LawyerAiInteractionLog;
+
+/**
+ * <p>
+ * AI交互日志 Mapper 接口
+ * </p>
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Mapper
+public interface LawyerAiInteractionLogMapper extends BaseMapper<LawyerAiInteractionLog> {
+
+}
+

alien-entity/src/main/java/shop/alien/mapper/LawyerChatMessageMapper.java

@@ -0,0 +1,19 @@
+package shop.alien.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.apache.ibatis.annotations.Mapper;
+import shop.alien.entity.store.LawyerChatMessage;
+
+/**
+ * <p>
+ * 聊天消息 Mapper 接口
+ * </p>
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Mapper
+public interface LawyerChatMessageMapper extends BaseMapper<LawyerChatMessage> {
+
+}
+

alien-entity/src/main/java/shop/alien/mapper/LawyerChatSessionMapper.java

@@ -0,0 +1,18 @@
+package shop.alien.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.apache.ibatis.annotations.Mapper;
+import shop.alien.entity.store.LawyerChatSession;
+
+/**
+ * <p>
+ * 聊天会话 Mapper 接口
+ * </p>
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Mapper
+public interface LawyerChatSessionMapper extends BaseMapper<LawyerChatSession> {
+
+}

alien-entity/src/main/java/shop/alien/mapper/LawyerCommonQuestionMapper.java

@@ -0,0 +1,19 @@
+package shop.alien.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.apache.ibatis.annotations.Mapper;
+import shop.alien.entity.store.LawyerCommonQuestion;
+
+/**
+ * <p>
+ * 常见问题 Mapper 接口
+ * </p>
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Mapper
+public interface LawyerCommonQuestionMapper extends BaseMapper<LawyerCommonQuestion> {
+
+}
+

alien-entity/src/main/java/shop/alien/mapper/LawyerConsultationOrderMapper.java

@@ -0,0 +1,19 @@
+package shop.alien.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.apache.ibatis.annotations.Mapper;
+import shop.alien.entity.store.LawyerConsultationOrder;
+
+/**
+ * <p>
+ * 咨询订单 Mapper 接口
+ * </p>
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Mapper
+public interface LawyerConsultationOrderMapper extends BaseMapper<LawyerConsultationOrder> {
+
+}
+

alien-entity/src/main/java/shop/alien/mapper/LawyerConsultationReviewMapper.java

@@ -0,0 +1,19 @@
+package shop.alien.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.apache.ibatis.annotations.Mapper;
+import shop.alien.entity.store.LawyerConsultationReview;
+
+/**
+ * <p>
+ * 咨询评价 Mapper 接口
+ * </p>
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Mapper
+public interface LawyerConsultationReviewMapper extends BaseMapper<LawyerConsultationReview> {
+
+}
+

alien-entity/src/main/java/shop/alien/mapper/LawyerImgMapper.java

@@ -0,0 +1,44 @@
+package shop.alien.mapper;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baomidou.mybatisplus.core.toolkit.Constants;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.Select;
+import shop.alien.entity.store.LawyerImg;
+import shop.alien.entity.store.vo.LawyerImgTypeVo;
+
+import java.util.List;
+
+/**
+ * 律师图片 Mapper 接口
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Mapper
+public interface LawyerImgMapper extends BaseMapper<LawyerImg> {
+
+    @Select("select IFNULL(img_type, 0) img_type, count(1) count, img_url imgUrl from lawyer_img where lawyer_id = #{lawyerId} and img_type = 0 and delete_flag= 0 " +
+            "union all " +
+            "select IFNULL(img_type, 1) img_type, count(1) count, img_url imgUrl from lawyer_img where lawyer_id = #{lawyerId} and img_type = 1 and delete_flag= 0 " +
+            "union all " +
+            "select IFNULL(img_type, 2) img_type, count(1) count, img_url imgUrl from lawyer_img where lawyer_id = #{lawyerId} and img_type = 2 and delete_flag= 0 " +
+            "union all " +
+            "select IFNULL(img_type, 5) img_type, count(1) count, img_url imgUrl from lawyer_img where lawyer_id = #{lawyerId} and img_type = 5 and delete_flag= 0 " +
+            "union all " +
+            "select IFNULL(img_type, 6) img_type, count(1) count, img_url imgUrl from lawyer_img where lawyer_id = #{lawyerId} and img_type = 6 and delete_flag= 0")
+    List<LawyerImgTypeVo> getLawyerImgTypeCount(@Param("lawyerId") Integer lawyerId);
+
+    /**
+     * 根据业务ID获取图片
+     *
+     * @param queryWrapper 查询条件
+     * @return 图片列表
+     */
+    @Select("SELECT * " +
+            "FROM lawyer_img ${ew.customSqlSegment}")
+    List<LawyerImg> getImgsByBusinessIds(@Param(Constants.WRAPPER) QueryWrapper<LawyerImg> queryWrapper);
+}
+

alien-entity/src/main/java/shop/alien/mapper/LawyerLegalProblemScenarioMapper.java

@@ -0,0 +1,19 @@
+package shop.alien.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.apache.ibatis.annotations.Mapper;
+import shop.alien.entity.store.LawyerLegalProblemScenario;
+
+/**
+ * <p>
+ * 法律问题场景 Mapper 接口
+ * </p>
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Mapper
+public interface LawyerLegalProblemScenarioMapper extends BaseMapper<LawyerLegalProblemScenario> {
+
+}
+

alien-entity/src/main/java/shop/alien/mapper/LawyerPaymentTransactionMapper.java

@@ -0,0 +1,19 @@
+package shop.alien.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.apache.ibatis.annotations.Mapper;
+import shop.alien.entity.store.LawyerPaymentTransaction;
+
+/**
+ * <p>
+ * 支付交易 Mapper 接口
+ * </p>
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Mapper
+public interface LawyerPaymentTransactionMapper extends BaseMapper<LawyerPaymentTransaction> {
+
+}
+

alien-entity/src/main/java/shop/alien/mapper/LawyerServiceAreaMapper.java

@@ -0,0 +1,19 @@
+package shop.alien.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.apache.ibatis.annotations.Mapper;
+import shop.alien.entity.store.LawyerServiceArea;
+
+/**
+ * <p>
+ * 律师服务领域关联 Mapper 接口
+ * </p>
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Mapper
+public interface LawyerServiceAreaMapper extends BaseMapper<LawyerServiceArea> {
+
+}
+

alien-entity/src/main/java/shop/alien/mapper/LawyerUserMapper.java

@@ -0,0 +1,19 @@
+package shop.alien.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.apache.ibatis.annotations.Mapper;
+import shop.alien.entity.store.LawyerUser;
+
+/**
+ * <p>
+ * 律师用户 Mapper 接口
+ * </p>
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Mapper
+public interface LawyerUserMapper extends BaseMapper<LawyerUser> {
+
+}
+

alien-entity/src/main/java/shop/alien/mapper/LawyerUserSearchHistoryMapper.java

@@ -0,0 +1,19 @@
+package shop.alien.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.apache.ibatis.annotations.Mapper;
+import shop.alien.entity.store.LawyerUserSearchHistory;
+
+/**
+ * <p>
+ * 用户搜索历史 Mapper 接口
+ * </p>
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Mapper
+public interface LawyerUserSearchHistoryMapper extends BaseMapper<LawyerUserSearchHistory> {
+
+}
+

alien-entity/src/main/resources/mapper/LawyerAiInteractionLogMapper.xml

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="shop.alien.mapper.LawyerAiInteractionLogMapper">
+
+    <!-- 通用查询映射结果 -->
+    <resultMap id="BaseResultMap" type="shop.alien.entity.store.LawyerAiInteractionLog">
+        <id column="id" property="id" />
+        <result column="client_user_id" property="clientUserId" />
+        <result column="conversation_id" property="conversationId" />
+        <result column="query_text" property="queryText" />
+        <result column="response_text" property="responseText" />
+        <result column="problem_scenar_id" property="problemScenarId" />
+        <result column="interaction_time" property="interactionTime" />
+        <result column="delete_flag" property="deleteFlag" />
+        <result column="created_time" property="createdTime" />
+        <result column="created_user_id" property="createdUserId" />
+        <result column="updated_time" property="updatedTime" />
+        <result column="updated_user_id" property="updatedUserId" />
+    </resultMap>
+
+    <!-- 通用查询结果列 -->
+    <sql id="Base_Column_List">
+        id, client_user_id, conversation_id, query_text, response_text, problem_scenar_id,
+        interaction_time, delete_flag, created_time, created_user_id, updated_time, updated_user_id
+    </sql>
+
+</mapper>
+

alien-entity/src/main/resources/mapper/LawyerChatMessageMapper.xml

@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="shop.alien.mapper.LawyerChatMessageMapper">
+
+    <!-- 通用查询映射结果 -->
+    <resultMap id="BaseResultMap" type="shop.alien.entity.store.LawyerChatMessage">
+        <id column="id" property="id" />
+        <result column="chat_session_id" property="chatSessionId" />
+        <result column="consultation_order_id" property="consultationOrderId" />
+        <result column="sender_id" property="senderId" />
+        <result column="sender_type" property="senderType" />
+        <result column="message_content" property="messageContent" />
+        <result column="message_type" property="messageType" />
+        <result column="media_url" property="mediaUrl" />
+        <result column="message_timestamp" property="messageTimestamp" />
+        <result column="read_status" property="readStatus" />
+        <result column="read_time" property="readTime" />
+        <result column="delete_flag" property="deleteFlag" />
+        <result column="created_time" property="createdTime" />
+        <result column="created_user_id" property="createdUserId" />
+        <result column="updated_time" property="updatedTime" />
+        <result column="updated_user_id" property="updatedUserId" />
+    </resultMap>
+
+    <!-- 通用查询结果列 -->
+    <sql id="Base_Column_List">
+        id, chat_session_id, consultation_order_id, sender_id, sender_type, message_content,
+        message_type, media_url, message_timestamp, read_status, read_time, delete_flag,
+        created_time, created_user_id, updated_time, updated_user_id
+    </sql>
+
+</mapper>

alien-entity/src/main/resources/mapper/LawyerChatSessionMapper.xml

@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="shop.alien.mapper.LawyerChatSessionMapper">
+
+    <!-- 通用查询映射结果 -->
+    <resultMap id="BaseResultMap" type="shop.alien.entity.store.LawyerChatSession">
+        <id column="id" property="id" />
+        <result column="consultation_order_id" property="consultationOrderId" />
+        <result column="client_user_id" property="clientUserId" />
+        <result column="lawyer_user_id" property="lawyerUserId" />
+        <result column="session_type" property="sessionType" />
+        <result column="status" property="status" />
+        <result column="last_message_id" property="lastMessageId" />
+        <result column="last_message_time" property="lastMessageTime" />
+        <result column="delete_flag" property="deleteFlag" />
+        <result column="created_time" property="createdTime" />
+        <result column="created_user_id" property="createdUserId" />
+        <result column="updated_time" property="updatedTime" />
+        <result column="updated_user_id" property="updatedUserId" />
+    </resultMap>
+
+    <!-- 通用查询结果列 -->
+    <sql id="Base_Column_List">
+        id, consultation_order_id, client_user_id, lawyer_user_id, session_type, status,
+        last_message_id, last_message_time, delete_flag, created_time, created_user_id,
+        updated_time, updated_user_id
+    </sql>
+
+</mapper>

alien-entity/src/main/resources/mapper/LawyerCommonQuestionMapper.xml

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="shop.alien.mapper.LawyerCommonQuestionMapper">
+
+    <!-- 通用查询映射结果 -->
+    <resultMap id="BaseResultMap" type="shop.alien.entity.store.LawyerCommonQuestion">
+        <id column="id" property="id" />
+        <result column="question_text" property="questionText" />
+        <result column="answer_text" property="answerText" />
+        <result column="category_type" property="categoryType" />
+        <result column="problem_scenar_id" property="problemScenarId" />
+        <result column="sort_order" property="sortOrder" />
+        <result column="view_count" property="viewCount" />
+        <result column="status" property="status" />
+        <result column="delete_flag" property="deleteFlag" />
+        <result column="created_time" property="createdTime" />
+        <result column="created_user_id" property="createdUserId" />
+        <result column="updated_time" property="updatedTime" />
+        <result column="updated_user_id" property="updatedUserId" />
+    </resultMap>
+
+    <!-- 通用查询结果列 -->
+    <sql id="Base_Column_List">
+        id, question_text, answer_text, category_type, problem_scenar_id, sort_order,
+        view_count, status, delete_flag, created_time, created_user_id, updated_time, updated_user_id
+    </sql>
+
+</mapper>

alien-entity/src/main/resources/mapper/LawyerConsultationOrderMapper.xml

@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="shop.alien.mapper.LawyerConsultationOrderMapper">
+
+    <!-- 通用查询映射结果 -->
+    <resultMap id="BaseResultMap" type="shop.alien.entity.store.LawyerConsultationOrder">
+        <id column="id" property="id" />
+        <result column="order_number" property="orderNumber" />
+        <result column="client_user_id" property="clientUserId" />
+        <result column="lawyer_user_id" property="lawyerUserId" />
+        <result column="problem_scenar_id" property="problemScenarId" />
+        <result column="problem_description" property="problemDescription" />
+        <result column="order_amount" property="orderAmount" />
+        <result column="consultation_fee" property="consultationFee" />
+        <result column="start_time" property="startTime" />
+        <result column="end_time" property="endTime" />
+        <result column="order_status" property="orderStatus" />
+        <result column="payment_status" property="paymentStatus" />
+        <result column="payment_time" property="paymentTime" />
+        <result column="validity_period" property="validityPeriod" />
+        <result column="rating" property="rating" />
+        <result column="comment" property="comment" />
+        <result column="delete_flag" property="deleteFlag" />
+        <result column="created_time" property="createdTime" />
+        <result column="created_user_id" property="createdUserId" />
+        <result column="updated_time" property="updatedTime" />
+        <result column="updated_user_id" property="updatedUserId" />
+    </resultMap>
+
+    <!-- 通用查询结果列 -->
+    <sql id="Base_Column_List">
+        id, order_number, client_user_id, lawyer_user_id, problem_scenar_id, problem_description,
+        order_amount, consultation_fee, start_time, end_time, order_status, payment_status,
+        payment_time, validity_period, rating, comment, delete_flag, created_time,
+        created_user_id, updated_time, updated_user_id
+    </sql>
+
+</mapper>
+

alien-entity/src/main/resources/mapper/LawyerConsultationReviewMapper.xml

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="shop.alien.mapper.LawyerConsultationReviewMapper">
+
+    <!-- 通用查询映射结果 -->
+    <resultMap id="BaseResultMap" type="shop.alien.entity.store.LawyerConsultationReview">
+        <id column="id" property="id" />
+        <result column="consultation_order_id" property="consultationOrderId" />
+        <result column="client_user_id" property="clientUserId" />
+        <result column="lawyer_user_id" property="lawyerUserId" />
+        <result column="rating" property="rating" />
+        <result column="comment" property="comment" />
+        <result column="service_quality" property="serviceQuality" />
+        <result column="response_speed" property="responseSpeed" />
+        <result column="professional_level" property="professionalLevel" />
+        <result column="delete_flag" property="deleteFlag" />
+        <result column="created_time" property="createdTime" />
+        <result column="created_user_id" property="createdUserId" />
+        <result column="updated_time" property="updatedTime" />
+        <result column="updated_user_id" property="updatedUserId" />
+    </resultMap>
+
+    <!-- 通用查询结果列 -->
+    <sql id="Base_Column_List">
+        id, consultation_order_id, client_user_id, lawyer_user_id, rating, comment,
+        service_quality, response_speed, professional_level, delete_flag, created_time,
+        created_user_id, updated_time, updated_user_id
+    </sql>
+
+</mapper>

alien-entity/src/main/resources/mapper/LawyerImgMapper.xml

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="shop.alien.mapper.LawyerImgMapper">
+
+    <!-- 通用查询映射结果 -->
+    <resultMap id="BaseResultMap" type="shop.alien.entity.store.LawyerImg">
+        <id column="id" property="id" />
+        <result column="lawyer_id" property="lawyerId" />
+        <result column="img_type" property="imgType" />
+        <result column="img_description" property="imgDescription" />
+        <result column="img_sort" property="imgSort" />
+        <result column="img_url" property="imgUrl" />
+        <result column="delete_flag" property="deleteFlag" />
+        <result column="created_time" property="createdTime" />
+        <result column="created_user_id" property="createdUserId" />
+        <result column="updated_time" property="updatedTime" />
+        <result column="updated_user_id" property="updatedUserId" />
+        <result column="business_id" property="businessId" />
+    </resultMap>
+
+    <!-- 通用查询结果列 -->
+    <sql id="Base_Column_List">
+        id, lawyer_id, img_type, img_description, img_sort, img_url, delete_flag, created_time, created_user_id, updated_time, updated_user_id, business_id
+    </sql>
+
+</mapper>
+

alien-entity/src/main/resources/mapper/LawyerLegalProblemScenarioMapper.xml

@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="shop.alien.mapper.LawyerLegalProblemScenarioMapper">
+
+    <!-- 通用查询映射结果 -->
+    <resultMap id="BaseResultMap" type="shop.alien.entity.store.LawyerLegalProblemScenario">
+        <id column="id" property="id" />
+        <result column="code" property="code" />
+        <result column="name" property="name" />
+        <result column="parent_id" property="parentId" />
+        <result column="parent_code" property="parentCode" />
+        <result column="parentName" property="parent_name" />
+        <result column="sort_order" property="sortOrder" />
+        <result column="status" property="status" />
+        <result column="delete_flag" property="deleteFlag" />
+        <result column="created_time" property="createdTime" />
+        <result column="created_user_id" property="createdUserId" />
+        <result column="updated_time" property="updatedTime" />
+        <result column="updated_user_id" property="updatedUserId" />
+    </resultMap>
+
+    <!-- 通用查询结果列 -->
+    <sql id="Base_Column_List">
+        id, code, name, parent_id, parent_code, parentName, sort_order, status, delete_flag,
+        created_time, created_user_id, updated_time, updated_user_id
+    </sql>
+
+</mapper>
+

alien-entity/src/main/resources/mapper/LawyerPaymentTransactionMapper.xml

@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="shop.alien.mapper.LawyerPaymentTransactionMapper">
+
+    <!-- 通用查询映射结果 -->
+    <resultMap id="BaseResultMap" type="shop.alien.entity.store.LawyerPaymentTransaction">
+        <id column="id" property="id" />
+        <result column="consultation_order_id" property="consultationOrderId" />
+        <result column="client_user_id" property="clientUserId" />
+        <result column="transaction_number" property="transactionNumber" />
+        <result column="transaction_amount" property="transactionAmount" />
+        <result column="payment_method" property="paymentMethod" />
+        <result column="transaction_status" property="transactionStatus" />
+        <result column="transaction_time" property="transactionTime" />
+        <result column="third_party_trade_no" property="thirdPartyTradeNo" />
+        <result column="refund_amount" property="refundAmount" />
+        <result column="refund_time" property="refundTime" />
+        <result column="delete_flag" property="deleteFlag" />
+        <result column="created_time" property="createdTime" />
+        <result column="created_user_id" property="createdUserId" />
+        <result column="updated_time" property="updatedTime" />
+        <result column="updated_user_id" property="updatedUserId" />
+    </resultMap>
+
+    <!-- 通用查询结果列 -->
+    <sql id="Base_Column_List">
+        id, consultation_order_id, client_user_id, transaction_number, transaction_amount,
+        payment_method, transaction_status, transaction_time, third_party_trade_no,
+        refund_amount, refund_time, delete_flag, created_time, created_user_id,
+        updated_time, updated_user_id
+    </sql>
+
+</mapper>
+

alien-entity/src/main/resources/mapper/LawyerServiceAreaMapper.xml

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="shop.alien.mapper.LawyerServiceAreaMapper">
+
+    <!-- 通用查询映射结果 -->
+    <resultMap id="BaseResultMap" type="shop.alien.entity.store.LawyerServiceArea">
+        <id column="id" property="id" />
+        <result column="lawyer_user_id" property="lawyerUserId" />
+        <result column="problem_scenar_id" property="problemScenarId" />
+        <result column="sort_order" property="sortOrder" />
+        <result column="status" property="status" />
+        <result column="delete_flag" property="deleteFlag" />
+        <result column="created_time" property="createdTime" />
+        <result column="created_user_id" property="createdUserId" />
+        <result column="updated_time" property="updatedTime" />
+        <result column="updated_user_id" property="updatedUserId" />
+    </resultMap>
+
+    <!-- 通用查询结果列 -->
+    <sql id="Base_Column_List">
+        id, lawyer_user_id, problem_scenar_id, sort_order, status, delete_flag,
+        created_time, created_user_id, updated_time, updated_user_id
+    </sql>
+
+</mapper>
+

alien-entity/src/main/resources/mapper/LawyerUserMapper.xml

@@ -0,0 +1,81 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="shop.alien.mapper.LawyerUserMapper">
+
+    <!-- 通用查询映射结果 -->
+    <resultMap id="BaseResultMap" type="shop.alien.entity.store.LawyerUser">
+        <id column="id" property="id" />
+        <result column="phone" property="phone" />
+        <result column="name" property="name" />
+        <result column="id_card" property="idCard" />
+        <result column="password" property="password" />
+        <result column="pay_password" property="payPassword" />
+        <result column="money" property="money" />
+        <result column="status" property="status" />
+        <result column="pass_type" property="passType" />
+        <result column="delete_flag" property="deleteFlag" />
+        <result column="created_time" property="createdTime" />
+        <result column="created_user_id" property="createdUserId" />
+        <result column="updated_time" property="updatedTime" />
+        <result column="updated_user_id" property="updatedUserId" />
+        <result column="logout_flag" property="logoutFlag" />
+        <result column="logout_reason" property="logoutReason" />
+        <result column="logout_time" property="logoutTime" />
+        <result column="logout_code" property="logoutCode" />
+        <result column="nick_name" property="nickName" />
+        <result column="account_blurb" property="accountBlurb" />
+        <result column="head_img" property="headImg" />
+        <result column="alipay_account" property="alipayAccount" />
+        <result column="lawyer_certificate_no" property="lawyerCertificateNo" />
+        <result column="law_firm" property="lawFirm" />
+        <result column="law_firm_id" property="lawFirmId" />
+        <result column="practice_years" property="practiceYears" />
+        <result column="practice_start_date" property="practiceStartDate" />
+        <result column="specialty_fields" property="specialtyFields" />
+        <result column="certification_status" property="certificationStatus" />
+        <result column="certification_fail_reason" property="certificationFailReason" />
+        <result column="certification_time" property="certificationTime" />
+        <result column="certification_reviewer_id" property="certificationReviewerId" />
+        <result column="certificate_image" property="certificateImage" />
+        <result column="id_card_front_image" property="idCardFrontImage" />
+        <result column="id_card_back_image" property="idCardBackImage" />
+        <result column="service_score" property="serviceScore" />
+        <result column="service_count" property="serviceCount" />
+        <result column="good_review_count" property="goodReviewCount" />
+        <result column="medium_review_count" property="mediumReviewCount" />
+        <result column="bad_review_count" property="badReviewCount" />
+        <result column="consultation_fee" property="consultationFee" />
+        <result column="agency_fee" property="agencyFee" />
+        <result column="province" property="province" />
+        <result column="city" property="city" />
+        <result column="district" property="district" />
+        <result column="address" property="address" />
+        <result column="email" property="email" />
+        <result column="gender" property="gender" />
+        <result column="birthday" property="birthday" />
+        <result column="personal_introduction" property="personalIntroduction" />
+        <result column="education_background" property="educationBackground" />
+        <result column="work_experience" property="workExperience" />
+        <result column="expertise_cases" property="expertiseCases" />
+        <result column="is_online" property="isOnline" />
+        <result column="last_online_time" property="lastOnlineTime" />
+        <result column="is_recommended" property="isRecommended" />
+        <result column="recommend_sort" property="recommendSort" />
+    </resultMap>
+
+    <!-- 通用查询结果列 -->
+    <sql id="Base_Column_List">
+        id, phone, name, id_card, password, pay_password, money, status, pass_type, delete_flag,
+        created_time, created_user_id, updated_time, updated_user_id, logout_flag, logout_reason,
+        logout_time, logout_code, nick_name, account_blurb, head_img, alipay_account,
+        lawyer_certificate_no, law_firm, law_firm_id, practice_years, practice_start_date,
+        specialty_fields, certification_status, certification_fail_reason, certification_time,
+        certification_reviewer_id, certificate_image, id_card_front_image, id_card_back_image,
+        service_score, service_count, good_review_count, medium_review_count, bad_review_count,
+        consultation_fee, agency_fee, province, city, district, address, email, gender, birthday,
+        personal_introduction, education_background, work_experience, expertise_cases,
+        is_online, last_online_time, is_recommended, recommend_sort
+    </sql>
+
+</mapper>
+

alien-entity/src/main/resources/mapper/LawyerUserSearchHistoryMapper.xml

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="shop.alien.mapper.LawyerUserSearchHistoryMapper">
+
+    <!-- 通用查询映射结果 -->
+    <resultMap id="BaseResultMap" type="shop.alien.entity.store.LawyerUserSearchHistory">
+        <id column="id" property="id" />
+        <result column="client_user_id" property="clientUserId" />
+        <result column="search_keyword" property="searchKeyword" />
+        <result column="search_type" property="searchType" />
+        <result column="search_time" property="searchTime" />
+        <result column="delete_flag" property="deleteFlag" />
+        <result column="created_time" property="createdTime" />
+    </resultMap>
+
+    <!-- 通用查询结果列 -->
+    <sql id="Base_Column_List">
+        id, client_user_id, search_keyword, search_type, search_time, delete_flag, created_time
+    </sql>
+
+</mapper>
+

alien-store/src/main/java/shop/alien/store/controller/LawyerAiInteractionLogController.java

@@ -0,0 +1,113 @@
+package shop.alien.store.controller;
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import io.swagger.annotations.*;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.bind.annotation.*;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.LawyerAiInteractionLog;
+import shop.alien.store.service.LawyerAiInteractionLogService;
+
+import java.util.List;
+
+/**
+ * AI交互日志 前端控制器
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Slf4j
+@Api(tags = {"律师平台-AI交互日志"})
+@ApiSort(21)
+@CrossOrigin
+@RestController
+@RequestMapping("/lawyer/aiInteractionLog")
+@RequiredArgsConstructor
+public class LawyerAiInteractionLogController {
+
+    private final LawyerAiInteractionLogService aiInteractionLogService;
+
+    @ApiOperation("获取所有AI交互日志")
+    @ApiOperationSupport(order = 1)
+    @GetMapping("/getAll")
+    public R<List<LawyerAiInteractionLog>> getAll() {
+        log.info("LawyerAiInteractionLogController.getAll");
+        return R.data(aiInteractionLogService.list());
+    }
+
+    @ApiOperation("根据id获取AI交互日志")
+    @ApiOperationSupport(order = 2)
+    @ApiImplicitParams({@ApiImplicitParam(name = "id", value = "主键", dataType = "Integer", paramType = "query", required = true)})
+    @GetMapping("/getOne")
+    public R<LawyerAiInteractionLog> getOne(Integer id) {
+        log.info("LawyerAiInteractionLogController.getOne?id={}", id);
+        return R.data(aiInteractionLogService.getById(id));
+    }
+
+    @ApiOperation("根据会话ID查询交互日志列表")
+    @ApiOperationSupport(order = 3)
+    @ApiImplicitParams({@ApiImplicitParam(name = "conversationId", value = "会话ID", dataType = "String", paramType = "query", required = true)})
+    @GetMapping("/getListByConversationId")
+    public R<List<LawyerAiInteractionLog>> getListByConversationId(String conversationId) {
+        log.info("LawyerAiInteractionLogController.getListByConversationId?conversationId={}", conversationId);
+        return R.data(aiInteractionLogService.getListByConversationId(conversationId));
+    }
+
+    @ApiOperation("分页查询AI交互日志列表")
+    @ApiOperationSupport(order = 4)
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "pageNum", value = "页数", dataType = "int", paramType = "query", required = true),
+            @ApiImplicitParam(name = "pageSize", value = "页容", dataType = "int", paramType = "query", required = true),
+            @ApiImplicitParam(name = "clientUserId", value = "客户端用户ID", dataType = "Integer", paramType = "query"),
+            @ApiImplicitParam(name = "conversationId", value = "会话ID", dataType = "String", paramType = "query"),
+            @ApiImplicitParam(name = "problemScenarId", value = "法律问题场景ID", dataType = "Integer", paramType = "query")
+    })
+    @GetMapping("/getAiInteractionLogList")
+    public R<IPage<LawyerAiInteractionLog>> getAiInteractionLogList(@RequestParam(defaultValue = "1") int pageNum,
+                                                                @RequestParam(defaultValue = "10") int pageSize,
+                                                                @RequestParam(required = false) Integer clientUserId,
+                                                                @RequestParam(required = false) String conversationId,
+                                                                @RequestParam(required = false) Integer problemScenarId) {
+        log.info("LawyerAiInteractionLogController.getAiInteractionLogList?pageNum={},pageSize={},clientUserId={},conversationId={},problemScenarId={}",
+                pageNum, pageSize, clientUserId, conversationId, problemScenarId);
+        return aiInteractionLogService.getAiInteractionLogList(pageNum, pageSize, clientUserId, conversationId, problemScenarId);
+    }
+
+    @ApiOperation("新增AI交互日志")
+    @ApiOperationSupport(order = 5)
+    @PostMapping("/addAiInteractionLog")
+    public R<LawyerAiInteractionLog> addAiInteractionLog(@RequestBody LawyerAiInteractionLog aiInteractionLog) {
+        log.info("LawyerAiInteractionLogController.addAiInteractionLog?aiInteractionLog={}", aiInteractionLog);
+        return aiInteractionLogService.addAiInteractionLog(aiInteractionLog);
+    }
+
+    @ApiOperation("编辑AI交互日志")
+    @ApiOperationSupport(order = 6)
+    @PostMapping("/editAiInteractionLog")
+    public R<LawyerAiInteractionLog> editAiInteractionLog(@RequestBody LawyerAiInteractionLog aiInteractionLog) {
+        log.info("LawyerAiInteractionLogController.editAiInteractionLog?aiInteractionLog={}", aiInteractionLog);
+        return aiInteractionLogService.editAiInteractionLog(aiInteractionLog);
+    }
+
+    @ApiOperation("删除AI交互日志")
+    @ApiOperationSupport(order = 7)
+    @DeleteMapping("/deleteAiInteractionLog")
+    public R<Boolean> deleteAiInteractionLog(@RequestParam(value = "id") Integer id) {
+        log.info("LawyerAiInteractionLogController.deleteAiInteractionLog?id={}", id);
+        return aiInteractionLogService.deleteAiInteractionLog(id);
+    }
+
+    @ApiOperation("保存或更新AI交互日志")
+    @ApiOperationSupport(order = 8)
+    @PostMapping("/saveOrUpdate")
+    public R<LawyerAiInteractionLog> saveOrUpdate(@RequestBody LawyerAiInteractionLog aiInteractionLog) {
+        log.info("LawyerAiInteractionLogController.saveOrUpdate?aiInteractionLog={}", aiInteractionLog);
+        boolean result = aiInteractionLogService.saveOrUpdate(aiInteractionLog);
+        if (result) {
+            return R.data(aiInteractionLog);
+        }
+        return R.fail("操作失败");
+    }
+}
+

alien-store/src/main/java/shop/alien/store/controller/LawyerChatMessageController.java

@@ -0,0 +1,113 @@
+package shop.alien.store.controller;
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import io.swagger.annotations.*;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.bind.annotation.*;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.LawyerChatMessage;
+import shop.alien.store.service.LawyerChatMessageService;
+
+import java.util.List;
+
+/**
+ * 聊天消息 前端控制器
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Slf4j
+@Api(tags = {"律师平台-聊天消息"})
+@ApiSort(16)
+@CrossOrigin
+@RestController
+@RequestMapping("/lawyer/chatMessage")
+@RequiredArgsConstructor
+public class LawyerChatMessageController {
+
+    private final LawyerChatMessageService chatMessageService;
+
+    @ApiOperation("获取所有聊天消息")
+    @ApiOperationSupport(order = 1)
+    @GetMapping("/getAll")
+    public R<List<LawyerChatMessage>> getAll() {
+        log.info("LawyerChatMessageController.getAll");
+        return R.data(chatMessageService.list());
+    }
+
+    @ApiOperation("根据id获取聊天消息")
+    @ApiOperationSupport(order = 2)
+    @ApiImplicitParams({@ApiImplicitParam(name = "id", value = "主键", dataType = "Integer", paramType = "query", required = true)})
+    @GetMapping("/getOne")
+    public R<LawyerChatMessage> getOne(Integer id) {
+        log.info("LawyerChatMessageController.getOne?id={}", id);
+        return R.data(chatMessageService.getById(id));
+    }
+
+    @ApiOperation("根据会话ID查询消息列表")
+    @ApiOperationSupport(order = 3)
+    @ApiImplicitParams({@ApiImplicitParam(name = "chatSessionId", value = "聊天会话ID", dataType = "Integer", paramType = "query", required = true)})
+    @GetMapping("/getListBySessionId")
+    public R<List<LawyerChatMessage>> getListBySessionId(Integer chatSessionId) {
+        log.info("LawyerChatMessageController.getListBySessionId?chatSessionId={}", chatSessionId);
+        return R.data(chatMessageService.getListBySessionId(chatSessionId));
+    }
+
+    @ApiOperation("分页查询聊天消息列表")
+    @ApiOperationSupport(order = 4)
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "pageNum", value = "页数", dataType = "int", paramType = "query", required = true),
+            @ApiImplicitParam(name = "pageSize", value = "页容", dataType = "int", paramType = "query", required = true),
+            @ApiImplicitParam(name = "chatSessionId", value = "聊天会话ID", dataType = "Integer", paramType = "query"),
+            @ApiImplicitParam(name = "consultationOrderId", value = "咨询订单ID", dataType = "Integer", paramType = "query"),
+            @ApiImplicitParam(name = "senderType", value = "发送者类型", dataType = "Integer", paramType = "query")
+    })
+    @GetMapping("/getChatMessageList")
+    public R<IPage<LawyerChatMessage>> getChatMessageList(@RequestParam(defaultValue = "1") int pageNum,
+                                                      @RequestParam(defaultValue = "10") int pageSize,
+                                                      @RequestParam(required = false) Integer chatSessionId,
+                                                      @RequestParam(required = false) Integer consultationOrderId,
+                                                      @RequestParam(required = false) Integer senderType) {
+        log.info("LawyerChatMessageController.getChatMessageList?pageNum={},pageSize={},chatSessionId={},consultationOrderId={},senderType={}",
+                pageNum, pageSize, chatSessionId, consultationOrderId, senderType);
+        return chatMessageService.getChatMessageList(pageNum, pageSize, chatSessionId, consultationOrderId, senderType);
+    }
+
+    @ApiOperation("新增聊天消息")
+    @ApiOperationSupport(order = 5)
+    @PostMapping("/addChatMessage")
+    public R<LawyerChatMessage> addChatMessage(@RequestBody LawyerChatMessage chatMessage) {
+        log.info("LawyerChatMessageController.addChatMessage?chatMessage={}", chatMessage);
+        return chatMessageService.addChatMessage(chatMessage);
+    }
+
+    @ApiOperation("编辑聊天消息")
+    @ApiOperationSupport(order = 6)
+    @PostMapping("/editChatMessage")
+    public R<LawyerChatMessage> editChatMessage(@RequestBody LawyerChatMessage chatMessage) {
+        log.info("LawyerChatMessageController.editChatMessage?chatMessage={}", chatMessage);
+        return chatMessageService.editChatMessage(chatMessage);
+    }
+
+    @ApiOperation("删除聊天消息")
+    @ApiOperationSupport(order = 7)
+    @DeleteMapping("/deleteChatMessage")
+    public R<Boolean> deleteChatMessage(@RequestParam(value = "id") Integer id) {
+        log.info("LawyerChatMessageController.deleteChatMessage?id={}", id);
+        return chatMessageService.deleteChatMessage(id);
+    }
+
+    @ApiOperation("保存或更新聊天消息")
+    @ApiOperationSupport(order = 8)
+    @PostMapping("/saveOrUpdate")
+    public R<LawyerChatMessage> saveOrUpdate(@RequestBody LawyerChatMessage chatMessage) {
+        log.info("LawyerChatMessageController.saveOrUpdate?chatMessage={}", chatMessage);
+        boolean result = chatMessageService.saveOrUpdate(chatMessage);
+        if (result) {
+            return R.data(chatMessage);
+        }
+        return R.fail("操作失败");
+    }
+}
+

alien-store/src/main/java/shop/alien/store/controller/LawyerChatSessionController.java

@@ -0,0 +1,115 @@
+package shop.alien.store.controller;
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import io.swagger.annotations.*;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.bind.annotation.*;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.LawyerChatSession;
+import shop.alien.store.service.LawyerChatSessionService;
+
+import java.util.List;
+
+/**
+ * 聊天会话 前端控制器
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Slf4j
+@Api(tags = {"律师平台-聊天会话"})
+@ApiSort(15)
+@CrossOrigin
+@RestController
+@RequestMapping("/lawyer/chatSession")
+@RequiredArgsConstructor
+public class LawyerChatSessionController {
+
+    private final LawyerChatSessionService chatSessionService;
+
+    @ApiOperation("获取所有聊天会话")
+    @ApiOperationSupport(order = 1)
+    @GetMapping("/getAll")
+    public R<List<LawyerChatSession>> getAll() {
+        log.info("LawyerChatSessionController.getAll");
+        return R.data(chatSessionService.list());
+    }
+
+    @ApiOperation("根据id获取聊天会话")
+    @ApiOperationSupport(order = 2)
+    @ApiImplicitParams({@ApiImplicitParam(name = "id", value = "主键", dataType = "Integer", paramType = "query", required = true)})
+    @GetMapping("/getOne")
+    public R<LawyerChatSession> getOne(Integer id) {
+        log.info("LawyerChatSessionController.getOne?id={}", id);
+        return R.data(chatSessionService.getById(id));
+    }
+
+    @ApiOperation("根据订单ID获取聊天会话")
+    @ApiOperationSupport(order = 3)
+    @ApiImplicitParams({@ApiImplicitParam(name = "consultationOrderId", value = "咨询订单ID", dataType = "Integer", paramType = "query", required = true)})
+    @GetMapping("/getByOrderId")
+    public R<LawyerChatSession> getByOrderId(Integer consultationOrderId) {
+        log.info("LawyerChatSessionController.getByOrderId?consultationOrderId={}", consultationOrderId);
+        return R.data(chatSessionService.getByOrderId(consultationOrderId));
+    }
+
+    @ApiOperation("分页查询聊天会话列表")
+    @ApiOperationSupport(order = 4)
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "pageNum", value = "页数", dataType = "int", paramType = "query", required = true),
+            @ApiImplicitParam(name = "pageSize", value = "页容", dataType = "int", paramType = "query", required = true),
+            @ApiImplicitParam(name = "consultationOrderId", value = "咨询订单ID", dataType = "Integer", paramType = "query"),
+            @ApiImplicitParam(name = "clientUserId", value = "客户端用户ID", dataType = "Integer", paramType = "query"),
+            @ApiImplicitParam(name = "lawyerUserId", value = "律师用户ID", dataType = "Integer", paramType = "query"),
+            @ApiImplicitParam(name = "status", value = "会话状态", dataType = "Integer", paramType = "query")
+    })
+    @GetMapping("/getChatSessionList")
+    public R<IPage<LawyerChatSession>> getChatSessionList(@RequestParam(defaultValue = "1") int pageNum,
+                                                      @RequestParam(defaultValue = "10") int pageSize,
+                                                      @RequestParam(required = false) Integer consultationOrderId,
+                                                      @RequestParam(required = false) Integer clientUserId,
+                                                      @RequestParam(required = false) Integer lawyerUserId,
+                                                      @RequestParam(required = false) Integer status) {
+        log.info("LawyerChatSessionController.getChatSessionList?pageNum={},pageSize={},consultationOrderId={},clientUserId={},lawyerUserId={},status={}",
+                pageNum, pageSize, consultationOrderId, clientUserId, lawyerUserId, status);
+        return chatSessionService.getChatSessionList(pageNum, pageSize, consultationOrderId, clientUserId, lawyerUserId, status);
+    }
+
+    @ApiOperation("新增聊天会话")
+    @ApiOperationSupport(order = 5)
+    @PostMapping("/addChatSession")
+    public R<LawyerChatSession> addChatSession(@RequestBody LawyerChatSession chatSession) {
+        log.info("LawyerChatSessionController.addChatSession?chatSession={}", chatSession);
+        return chatSessionService.addChatSession(chatSession);
+    }
+
+    @ApiOperation("编辑聊天会话")
+    @ApiOperationSupport(order = 6)
+    @PostMapping("/editChatSession")
+    public R<LawyerChatSession> editChatSession(@RequestBody LawyerChatSession chatSession) {
+        log.info("LawyerChatSessionController.editChatSession?chatSession={}", chatSession);
+        return chatSessionService.editChatSession(chatSession);
+    }
+
+    @ApiOperation("删除聊天会话")
+    @ApiOperationSupport(order = 7)
+    @DeleteMapping("/deleteChatSession")
+    public R<Boolean> deleteChatSession(@RequestParam(value = "id") Integer id) {
+        log.info("LawyerChatSessionController.deleteChatSession?id={}", id);
+        return chatSessionService.deleteChatSession(id);
+    }
+
+    @ApiOperation("保存或更新聊天会话")
+    @ApiOperationSupport(order = 8)
+    @PostMapping("/saveOrUpdate")
+    public R<LawyerChatSession> saveOrUpdate(@RequestBody LawyerChatSession chatSession) {
+        log.info("LawyerChatSessionController.saveOrUpdate?chatSession={}", chatSession);
+        boolean result = chatSessionService.saveOrUpdate(chatSession);
+        if (result) {
+            return R.data(chatSession);
+        }
+        return R.fail("操作失败");
+    }
+}
+

alien-store/src/main/java/shop/alien/store/controller/LawyerCommonQuestionController.java

@@ -0,0 +1,115 @@
+package shop.alien.store.controller;
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import io.swagger.annotations.*;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.bind.annotation.*;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.LawyerCommonQuestion;
+import shop.alien.store.service.LawyerCommonQuestionService;
+
+import java.util.List;
+
+/**
+ * 常见问题 前端控制器
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Slf4j
+@Api(tags = {"律师平台-常见问题"})
+@ApiSort(18)
+@CrossOrigin
+@RestController
+@RequestMapping("/lawyer/commonQuestion")
+@RequiredArgsConstructor
+public class LawyerCommonQuestionController {
+
+    private final LawyerCommonQuestionService commonQuestionService;
+
+    @ApiOperation("获取所有常见问题")
+    @ApiOperationSupport(order = 1)
+    @GetMapping("/getAll")
+    public R<List<LawyerCommonQuestion>> getAll() {
+        log.info("LawyerCommonQuestionController.getAll");
+        return R.data(commonQuestionService.list());
+    }
+
+    @ApiOperation("根据id获取常见问题")
+    @ApiOperationSupport(order = 2)
+    @ApiImplicitParams({@ApiImplicitParam(name = "id", value = "主键", dataType = "Integer", paramType = "query", required = true)})
+    @GetMapping("/getOne")
+    public R<LawyerCommonQuestion> getOne(Integer id) {
+        log.info("LawyerCommonQuestionController.getOne?id={}", id);
+        return R.data(commonQuestionService.getById(id));
+    }
+
+    @ApiOperation("根据分类类型查询常见问题列表")
+    @ApiOperationSupport(order = 3)
+    @ApiImplicitParams({@ApiImplicitParam(name = "categoryType", value = "分类类型, 0:推荐, 1:常见问题", dataType = "Integer", paramType = "query", required = true)})
+    @GetMapping("/getListByCategoryType")
+    public R<List<LawyerCommonQuestion>> getListByCategoryType(Integer categoryType) {
+        log.info("LawyerCommonQuestionController.getListByCategoryType?categoryType={}", categoryType);
+        return R.data(commonQuestionService.getListByCategoryType(categoryType));
+    }
+
+    @ApiOperation("分页查询常见问题列表")
+    @ApiOperationSupport(order = 4)
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "pageNum", value = "页数", dataType = "int", paramType = "query", required = true),
+            @ApiImplicitParam(name = "pageSize", value = "页容", dataType = "int", paramType = "query", required = true),
+            @ApiImplicitParam(name = "questionText", value = "问题文本", dataType = "String", paramType = "query"),
+            @ApiImplicitParam(name = "categoryType", value = "分类类型", dataType = "Integer", paramType = "query"),
+            @ApiImplicitParam(name = "problemScenarId", value = "法律问题场景ID", dataType = "Integer", paramType = "query"),
+            @ApiImplicitParam(name = "status", value = "状态", dataType = "Integer", paramType = "query")
+    })
+    @GetMapping("/getCommonQuestionList")
+    public R<IPage<LawyerCommonQuestion>> getCommonQuestionList(@RequestParam(defaultValue = "1") int pageNum,
+                                                           @RequestParam(defaultValue = "10") int pageSize,
+                                                           @RequestParam(required = false) String questionText,
+                                                           @RequestParam(required = false) Integer categoryType,
+                                                           @RequestParam(required = false) Integer problemScenarId,
+                                                           @RequestParam(required = false) Integer status) {
+        log.info("LawyerCommonQuestionController.getCommonQuestionList?pageNum={},pageSize={},questionText={},categoryType={},problemScenarId={},status={}",
+                pageNum, pageSize, questionText, categoryType, problemScenarId, status);
+        return commonQuestionService.getCommonQuestionList(pageNum, pageSize, questionText, categoryType, problemScenarId, status);
+    }
+
+    @ApiOperation("新增常见问题")
+    @ApiOperationSupport(order = 5)
+    @PostMapping("/addCommonQuestion")
+    public R<LawyerCommonQuestion> addCommonQuestion(@RequestBody LawyerCommonQuestion commonQuestion) {
+        log.info("LawyerCommonQuestionController.addCommonQuestion?commonQuestion={}", commonQuestion);
+        return commonQuestionService.addCommonQuestion(commonQuestion);
+    }
+
+    @ApiOperation("编辑常见问题")
+    @ApiOperationSupport(order = 6)
+    @PostMapping("/editCommonQuestion")
+    public R<LawyerCommonQuestion> editCommonQuestion(@RequestBody LawyerCommonQuestion commonQuestion) {
+        log.info("LawyerCommonQuestionController.editCommonQuestion?commonQuestion={}", commonQuestion);
+        return commonQuestionService.editCommonQuestion(commonQuestion);
+    }
+
+    @ApiOperation("删除常见问题")
+    @ApiOperationSupport(order = 7)
+    @DeleteMapping("/deleteCommonQuestion")
+    public R<Boolean> deleteCommonQuestion(@RequestParam(value = "id") Integer id) {
+        log.info("LawyerCommonQuestionController.deleteCommonQuestion?id={}", id);
+        return commonQuestionService.deleteCommonQuestion(id);
+    }
+
+    @ApiOperation("保存或更新常见问题")
+    @ApiOperationSupport(order = 8)
+    @PostMapping("/saveOrUpdate")
+    public R<LawyerCommonQuestion> saveOrUpdate(@RequestBody LawyerCommonQuestion commonQuestion) {
+        log.info("LawyerCommonQuestionController.saveOrUpdate?commonQuestion={}", commonQuestion);
+        boolean result = commonQuestionService.saveOrUpdate(commonQuestion);
+        if (result) {
+            return R.data(commonQuestion);
+        }
+        return R.fail("操作失败");
+    }
+}
+

alien-store/src/main/java/shop/alien/store/controller/LawyerConsultationOrderController.java

@@ -0,0 +1,106 @@
+package shop.alien.store.controller;
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import io.swagger.annotations.*;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.bind.annotation.*;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.LawyerConsultationOrder;
+import shop.alien.store.service.LawyerConsultationOrderService;
+
+import java.util.List;
+
+/**
+ * 咨询订单 前端控制器
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Slf4j
+@Api(tags = {"律师平台-咨询订单"})
+@ApiSort(14)
+@CrossOrigin
+@RestController
+@RequestMapping("/lawyer/consultationOrder")
+@RequiredArgsConstructor
+public class LawyerConsultationOrderController {
+
+    private final LawyerConsultationOrderService consultationOrderService;
+
+    @ApiOperation("获取所有咨询订单")
+    @ApiOperationSupport(order = 1)
+    @GetMapping("/getAll")
+    public R<List<LawyerConsultationOrder>> getAll() {
+        log.info("LawyerConsultationOrderController.getAll");
+        return R.data(consultationOrderService.list());
+    }
+
+    @ApiOperation("根据id获取咨询订单")
+    @ApiOperationSupport(order = 2)
+    @ApiImplicitParams({@ApiImplicitParam(name = "id", value = "主键", dataType = "Integer", paramType = "query", required = true)})
+    @GetMapping("/getOne")
+    public R<LawyerConsultationOrder> getOne(Integer id) {
+        log.info("LawyerConsultationOrderController.getOne?id={}", id);
+        return R.data(consultationOrderService.getById(id));
+    }
+
+    @ApiOperation("分页查询咨询订单列表")
+    @ApiOperationSupport(order = 3)
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "pageNum", value = "页数", dataType = "int", paramType = "query", required = true),
+            @ApiImplicitParam(name = "pageSize", value = "页容", dataType = "int", paramType = "query", required = true),
+            @ApiImplicitParam(name = "orderNumber", value = "订单编号", dataType = "String", paramType = "query"),
+            @ApiImplicitParam(name = "clientUserId", value = "客户端用户ID", dataType = "Integer", paramType = "query"),
+            @ApiImplicitParam(name = "lawyerUserId", value = "律师用户ID", dataType = "Integer", paramType = "query"),
+            @ApiImplicitParam(name = "orderStatus", value = "订单状态", dataType = "Integer", paramType = "query")
+    })
+    @GetMapping("/getConsultationOrderList")
+    public R<IPage<LawyerConsultationOrder>> getConsultationOrderList(@RequestParam(defaultValue = "1") int pageNum,
+                                                                 @RequestParam(defaultValue = "10") int pageSize,
+                                                                 @RequestParam(required = false) String orderNumber,
+                                                                 @RequestParam(required = false) Integer clientUserId,
+                                                                 @RequestParam(required = false) Integer lawyerUserId,
+                                                                 @RequestParam(required = false) Integer orderStatus) {
+        log.info("LawyerConsultationOrderController.getConsultationOrderList?pageNum={},pageSize={},orderNumber={},clientUserId={},lawyerUserId={},orderStatus={}",
+                pageNum, pageSize, orderNumber, clientUserId, lawyerUserId, orderStatus);
+        return consultationOrderService.getConsultationOrderList(pageNum, pageSize, orderNumber, clientUserId, lawyerUserId, orderStatus);
+    }
+
+    @ApiOperation("新增咨询订单")
+    @ApiOperationSupport(order = 4)
+    @PostMapping("/addConsultationOrder")
+    public R<LawyerConsultationOrder> addConsultationOrder(@RequestBody LawyerConsultationOrder consultationOrder) {
+        log.info("LawyerConsultationOrderController.addConsultationOrder?consultationOrder={}", consultationOrder);
+        return consultationOrderService.addConsultationOrder(consultationOrder);
+    }
+
+    @ApiOperation("编辑咨询订单")
+    @ApiOperationSupport(order = 5)
+    @PostMapping("/editConsultationOrder")
+    public R<LawyerConsultationOrder> editConsultationOrder(@RequestBody LawyerConsultationOrder consultationOrder) {
+        log.info("LawyerConsultationOrderController.editConsultationOrder?consultationOrder={}", consultationOrder);
+        return consultationOrderService.editConsultationOrder(consultationOrder);
+    }
+
+    @ApiOperation("删除咨询订单")
+    @ApiOperationSupport(order = 6)
+    @DeleteMapping("/deleteConsultationOrder")
+    public R<Boolean> deleteConsultationOrder(@RequestParam(value = "id") Integer id) {
+        log.info("LawyerConsultationOrderController.deleteConsultationOrder?id={}", id);
+        return consultationOrderService.deleteConsultationOrder(id);
+    }
+
+    @ApiOperation("保存或更新咨询订单")
+    @ApiOperationSupport(order = 7)
+    @PostMapping("/saveOrUpdate")
+    public R<LawyerConsultationOrder> saveOrUpdate(@RequestBody LawyerConsultationOrder consultationOrder) {
+        log.info("LawyerConsultationOrderController.saveOrUpdate?consultationOrder={}", consultationOrder);
+        boolean result = consultationOrderService.saveOrUpdate(consultationOrder);
+        if (result) {
+            return R.data(consultationOrder);
+        }
+        return R.fail("操作失败");
+    }
+}
+

alien-store/src/main/java/shop/alien/store/controller/LawyerConsultationReviewController.java

@@ -0,0 +1,113 @@
+package shop.alien.store.controller;
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import io.swagger.annotations.*;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.bind.annotation.*;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.LawyerConsultationReview;
+import shop.alien.store.service.LawyerConsultationReviewService;
+
+import java.util.List;
+
+/**
+ * 咨询评价 前端控制器
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Slf4j
+@Api(tags = {"律师平台-咨询评价"})
+@ApiSort(19)
+@CrossOrigin
+@RestController
+@RequestMapping("/lawyer/consultationReview")
+@RequiredArgsConstructor
+public class LawyerConsultationReviewController {
+
+    private final LawyerConsultationReviewService consultationReviewService;
+
+    @ApiOperation("获取所有咨询评价")
+    @ApiOperationSupport(order = 1)
+    @GetMapping("/getAll")
+    public R<List<LawyerConsultationReview>> getAll() {
+        log.info("LawyerConsultationReviewController.getAll");
+        return R.data(consultationReviewService.list());
+    }
+
+    @ApiOperation("根据id获取咨询评价")
+    @ApiOperationSupport(order = 2)
+    @ApiImplicitParams({@ApiImplicitParam(name = "id", value = "主键", dataType = "Integer", paramType = "query", required = true)})
+    @GetMapping("/getOne")
+    public R<LawyerConsultationReview> getOne(Integer id) {
+        log.info("LawyerConsultationReviewController.getOne?id={}", id);
+        return R.data(consultationReviewService.getById(id));
+    }
+
+    @ApiOperation("根据律师ID查询评价列表")
+    @ApiOperationSupport(order = 3)
+    @ApiImplicitParams({@ApiImplicitParam(name = "lawyerUserId", value = "律师用户ID", dataType = "Integer", paramType = "query", required = true)})
+    @GetMapping("/getListByLawyerId")
+    public R<List<LawyerConsultationReview>> getListByLawyerId(Integer lawyerUserId) {
+        log.info("LawyerConsultationReviewController.getListByLawyerId?lawyerUserId={}", lawyerUserId);
+        return R.data(consultationReviewService.getListByLawyerId(lawyerUserId));
+    }
+
+    @ApiOperation("分页查询咨询评价列表")
+    @ApiOperationSupport(order = 4)
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "pageNum", value = "页数", dataType = "int", paramType = "query", required = true),
+            @ApiImplicitParam(name = "pageSize", value = "页容", dataType = "int", paramType = "query", required = true),
+            @ApiImplicitParam(name = "consultationOrderId", value = "咨询订单ID", dataType = "Integer", paramType = "query"),
+            @ApiImplicitParam(name = "lawyerUserId", value = "律师用户ID", dataType = "Integer", paramType = "query"),
+            @ApiImplicitParam(name = "clientUserId", value = "客户端用户ID", dataType = "Integer", paramType = "query")
+    })
+    @GetMapping("/getConsultationReviewList")
+    public R<IPage<LawyerConsultationReview>> getConsultationReviewList(@RequestParam(defaultValue = "1") int pageNum,
+                                                                   @RequestParam(defaultValue = "10") int pageSize,
+                                                                   @RequestParam(required = false) Integer consultationOrderId,
+                                                                   @RequestParam(required = false) Integer lawyerUserId,
+                                                                   @RequestParam(required = false) Integer clientUserId) {
+        log.info("LawyerConsultationReviewController.getConsultationReviewList?pageNum={},pageSize={},consultationOrderId={},lawyerUserId={},clientUserId={}",
+                pageNum, pageSize, consultationOrderId, lawyerUserId, clientUserId);
+        return consultationReviewService.getConsultationReviewList(pageNum, pageSize, consultationOrderId, lawyerUserId, clientUserId);
+    }
+
+    @ApiOperation("新增咨询评价")
+    @ApiOperationSupport(order = 5)
+    @PostMapping("/addConsultationReview")
+    public R<LawyerConsultationReview> addConsultationReview(@RequestBody LawyerConsultationReview consultationReview) {
+        log.info("LawyerConsultationReviewController.addConsultationReview?consultationReview={}", consultationReview);
+        return consultationReviewService.addConsultationReview(consultationReview);
+    }
+
+    @ApiOperation("编辑咨询评价")
+    @ApiOperationSupport(order = 6)
+    @PostMapping("/editConsultationReview")
+    public R<LawyerConsultationReview> editConsultationReview(@RequestBody LawyerConsultationReview consultationReview) {
+        log.info("LawyerConsultationReviewController.editConsultationReview?consultationReview={}", consultationReview);
+        return consultationReviewService.editConsultationReview(consultationReview);
+    }
+
+    @ApiOperation("删除咨询评价")
+    @ApiOperationSupport(order = 7)
+    @DeleteMapping("/deleteConsultationReview")
+    public R<Boolean> deleteConsultationReview(@RequestParam(value = "id") Integer id) {
+        log.info("LawyerConsultationReviewController.deleteConsultationReview?id={}", id);
+        return consultationReviewService.deleteConsultationReview(id);
+    }
+
+    @ApiOperation("保存或更新咨询评价")
+    @ApiOperationSupport(order = 8)
+    @PostMapping("/saveOrUpdate")
+    public R<LawyerConsultationReview> saveOrUpdate(@RequestBody LawyerConsultationReview consultationReview) {
+        log.info("LawyerConsultationReviewController.saveOrUpdate?consultationReview={}", consultationReview);
+        boolean result = consultationReviewService.saveOrUpdate(consultationReview);
+        if (result) {
+            return R.data(consultationReview);
+        }
+        return R.fail("操作失败");
+    }
+}
+

alien-store/src/main/java/shop/alien/store/controller/LawyerImgController.java

@@ -0,0 +1,107 @@
+package shop.alien.store.controller;
+
+import com.alibaba.excel.util.CollectionUtils;
+import io.swagger.annotations.*;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.bind.annotation.*;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.LawyerImg;
+import shop.alien.entity.store.vo.LawyerImgTypeVo;
+import shop.alien.store.service.LawyerImgService;
+
+import java.util.List;
+
+/**
+ * 律师图片Controller
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Slf4j
+@Api(tags = {"律师平台-律师图片"})
+@ApiSort(12)
+@CrossOrigin
+@RestController
+@RequestMapping("/lawyer/img")
+@RequiredArgsConstructor
+public class LawyerImgController {
+
+    private final LawyerImgService lawyerImgService;
+
+    @ApiOperation("获取图片")
+    @ApiOperationSupport(order = 1)
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "lawyerId", value = "律师ID", dataType = "Integer", paramType = "query", required = true),
+            @ApiImplicitParam(name = "imgType", value = "图片类型, 0:其他, 1:头像, 2:执业证照片, 3:身份证正面, 4:身份证反面, 5:案例图片, 6:相册图片, 7:资质证书, 8:荣誉证书, 9:工作照片", dataType = "Integer", paramType = "query", required = true)
+    })
+    @GetMapping("/getByLawyerId")
+    public R<List<LawyerImg>> getByLawyerId(Integer lawyerId, Integer imgType) {
+        log.info("LawyerImgController.getByLawyerId?lawyerId={}&imgType={}", lawyerId, imgType);
+        return R.data(lawyerImgService.getLawyerImg(lawyerId, imgType));
+    }
+
+    @ApiOperation("获取所有图片类型和数量")
+    @ApiOperationSupport(order = 2)
+    @ApiImplicitParams({@ApiImplicitParam(name = "lawyerId", value = "律师ID", dataType = "Integer", paramType = "query", required = true)})
+    @GetMapping("/getLawyerImgTypeCount")
+    public R<List<LawyerImgTypeVo>> getLawyerImgTypeCount(Integer lawyerId) {
+        log.info("LawyerImgController.getLawyerImgTypeCount?lawyerId={}", lawyerId);
+        return R.data(lawyerImgService.getLawyerImgTypeCount(lawyerId));
+    }
+
+    @ApiOperation("新增或修改图片")
+    @ApiOperationSupport(order = 3)
+    @PostMapping("/saveOrUpdate")
+    public R<String> saveOrUpdate(@RequestBody List<LawyerImg> lawyerImgList) {
+        log.info("LawyerImgController.saveOrUpdate?lawyerImgList={}", lawyerImgList);
+        if (CollectionUtils.isEmpty(lawyerImgList)) {
+            return R.fail("图片列表不能为空");
+        }
+        Integer id = lawyerImgList.get(0).getId();
+        if (lawyerImgService.saveOrUpdateBatch(lawyerImgList)) {
+            if (null != id) {
+                return R.success("修改成功");
+            }
+            return R.success("新增成功");
+        }
+        return R.fail("失败");
+    }
+
+    @ApiOperation(value = "删除图片")
+    @ApiOperationSupport(order = 4)
+    @PostMapping("/delete")
+    public R<String> delete(@RequestBody List<Integer> ids) {
+        log.info("LawyerImgController.delete?ids={}", ids);
+        if (lawyerImgService.removeByIds(ids)) {
+            return R.success("删除成功");
+        }
+        return R.fail("删除失败");
+    }
+
+    @ApiOperation("获取图片URL列表")
+    @ApiOperationSupport(order = 5)
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "id", value = "律师ID", dataType = "String", paramType = "query", required = true),
+            @ApiImplicitParam(name = "imgType", value = "图片类型", dataType = "Integer", paramType = "query", required = true)
+    })
+    @GetMapping("/getUrl")
+    public R<List<String>> getUrl(String id, Integer imgType) {
+        log.info("LawyerImgController.getUrl?id={}&imgType={}", id, imgType);
+        return R.data(lawyerImgService.getUrl(id, imgType));
+    }
+
+    @ApiOperation("通过businessId获取图片")
+    @ApiOperationSupport(order = 6)
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "lawyerId", value = "律师ID", dataType = "Integer", paramType = "query", required = true),
+            @ApiImplicitParam(name = "imgType", value = "图片类型, 0:其他, 1:头像, 2:执业证照片, 3:身份证正面, 4:身份证反面, 5:案例图片, 6:相册图片, 7:资质证书, 8:荣誉证书, 9:工作照片", dataType = "Integer", paramType = "query", required = true),
+            @ApiImplicitParam(name = "businessId", value = "业务ID", dataType = "Integer", paramType = "query", required = true)
+    })
+    @GetMapping("/getByBusinessId")
+    public R<List<LawyerImg>> getByBusinessId(Integer lawyerId, Integer imgType, Integer businessId) {
+        log.info("LawyerImgController.getByBusinessId?lawyerId={}&imgType={}&businessId={}", lawyerId, imgType, businessId);
+        return R.data(lawyerImgService.getByBusinessId(lawyerId, imgType, businessId));
+    }
+}
+

alien-store/src/main/java/shop/alien/store/controller/LawyerLegalProblemScenarioController.java

@@ -0,0 +1,122 @@
+package shop.alien.store.controller;
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import io.swagger.annotations.*;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.bind.annotation.*;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.LawyerLegalProblemScenario;
+import shop.alien.store.service.LawyerLegalProblemScenarioService;
+
+import java.util.List;
+
+/**
+ * 法律问题场景 前端控制器
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Slf4j
+@Api(tags = {"律师平台-法律问题场景"})
+@ApiSort(11)
+@CrossOrigin
+@RestController
+@RequestMapping("/lawyer/legalProblemScenar")
+@RequiredArgsConstructor
+public class LawyerLegalProblemScenarioController {
+
+    private final LawyerLegalProblemScenarioService lawyerLegalProblemScenarioService;
+
+    @ApiOperation("获取所有法律问题场景")
+    @ApiOperationSupport(order = 1)
+    @GetMapping("/getAll")
+    public R<List<LawyerLegalProblemScenario>> getAll() {
+        log.info("LawyerLegalProblemScenarioController.getAll");
+        return R.data(lawyerLegalProblemScenarioService.list());
+    }
+
+    @ApiOperation("根据id获取法律问题场景")
+    @ApiOperationSupport(order = 2)
+    @ApiImplicitParams({@ApiImplicitParam(name = "id", value = "主键", dataType = "Integer", paramType = "query", required = true)})
+    @GetMapping("/getOne")
+    public R<LawyerLegalProblemScenario> getOne(Integer id) {
+        log.info("LawyerLegalProblemScenarioController.getOne?id={}", id);
+        return R.data(lawyerLegalProblemScenarioService.getById(id));
+    }
+
+    @ApiOperation("分页查询法律问题场景列表")
+    @ApiOperationSupport(order = 3)
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "pageNum", value = "页数", dataType = "int", paramType = "query", required = true),
+            @ApiImplicitParam(name = "pageSize", value = "页容", dataType = "int", paramType = "query", required = true),
+            @ApiImplicitParam(name = "name", value = "名称", dataType = "String", paramType = "query"),
+            @ApiImplicitParam(name = "code", value = "编号", dataType = "String", paramType = "query"),
+            @ApiImplicitParam(name = "status", value = "状态", dataType = "Integer", paramType = "query")
+    })
+    @GetMapping("/getLawyerLegalProblemScenarList")
+    public R<IPage<LawyerLegalProblemScenario>> getLawyerLegalProblemScenarList(@RequestParam(defaultValue = "1") int pageNum,
+                                                                                @RequestParam(defaultValue = "10") int pageSize,
+                                                                                @RequestParam(required = false) String name,
+                                                                                @RequestParam(required = false) String code,
+                                                                                @RequestParam(required = false) Integer status) {
+        log.info("LawyerLegalProblemScenarioController.getLawyerLegalProblemScenarList?pageNum={},pageSize={},name={},code={},status={}", pageNum, pageSize, name, code, status);
+        return lawyerLegalProblemScenarioService.getLawyerLegalProblemScenarioList(pageNum, pageSize, name, code, status);
+    }
+
+    @ApiOperation("根据父类ID查询子分类列表")
+    @ApiOperationSupport(order = 4)
+    @ApiImplicitParams({@ApiImplicitParam(name = "parentId", value = "父类主键", dataType = "String", paramType = "query")})
+    @GetMapping("/getListByParentId")
+    public R<List<LawyerLegalProblemScenario>> getListByParentId(@RequestParam(required = false) String parentId) {
+        log.info("LawyerLegalProblemScenarioController.getListByParentId?parentId={}", parentId);
+        return R.data(lawyerLegalProblemScenarioService.getListByParentId(parentId));
+    }
+
+    @ApiOperation("根据父类编号查询子分类列表")
+    @ApiOperationSupport(order = 5)
+    @ApiImplicitParams({@ApiImplicitParam(name = "parentCode", value = "父类编号", dataType = "String", paramType = "query")})
+    @GetMapping("/getListByParentCode")
+    public R<List<LawyerLegalProblemScenario>> getListByParentCode(@RequestParam(required = false) String parentCode) {
+        log.info("LawyerLegalProblemScenarioController.getListByParentCode?parentCode={}", parentCode);
+        return R.data(lawyerLegalProblemScenarioService.getListByParentCode(parentCode));
+    }
+
+    @ApiOperation("新增法律问题场景")
+    @ApiOperationSupport(order = 6)
+    @PostMapping("/addLawyerLegalProblemScenar")
+    public R<LawyerLegalProblemScenario> addLawyerLegalProblemScenar(@RequestBody LawyerLegalProblemScenario lawyerLegalProblemScenario) {
+        log.info("LawyerLegalProblemScenarioController.addLawyerLegalProblemScenar?lawyerLegalProblemScenario={}", lawyerLegalProblemScenario);
+        return lawyerLegalProblemScenarioService.addLawyerLegalProblemScenario(lawyerLegalProblemScenario);
+    }
+
+    @ApiOperation("编辑法律问题场景")
+    @ApiOperationSupport(order = 7)
+    @PostMapping("/editLawyerLegalProblemScenar")
+    public R<LawyerLegalProblemScenario> editLawyerLegalProblemScenar(@RequestBody LawyerLegalProblemScenario lawyerLegalProblemScenario) {
+        log.info("LawyerLegalProblemScenarioController.editLawyerLegalProblemScenar?lawyerLegalProblemScenario={}", lawyerLegalProblemScenario);
+        return lawyerLegalProblemScenarioService.editLawyerLegalProblemScenario(lawyerLegalProblemScenario);
+    }
+
+    @ApiOperation("删除法律问题场景")
+    @ApiOperationSupport(order = 8)
+    @DeleteMapping("/deleteLawyerLegalProblemScenar")
+    public R<Boolean> deleteLawyerLegalProblemScenar(@RequestParam(value = "id") Integer id) {
+        log.info("LawyerLegalProblemScenarioController.deleteLawyerLegalProblemScenar?id={}", id);
+        return lawyerLegalProblemScenarioService.deleteLawyerLegalProblemScenario(id);
+    }
+
+    @ApiOperation("保存或更新法律问题场景")
+    @ApiOperationSupport(order = 9)
+    @PostMapping("/saveOrUpdate")
+    public R<LawyerLegalProblemScenario> saveOrUpdate(@RequestBody LawyerLegalProblemScenario lawyerLegalProblemScenario) {
+        log.info("LawyerLegalProblemScenarioController.saveOrUpdate?lawyerLegalProblemScenario={}", lawyerLegalProblemScenario);
+        boolean result = lawyerLegalProblemScenarioService.saveOrUpdate(lawyerLegalProblemScenario);
+        if (result) {
+            return R.data(lawyerLegalProblemScenario);
+        }
+        return R.fail("操作失败");
+    }
+
+}
+

alien-store/src/main/java/shop/alien/store/controller/LawyerPaymentTransactionController.java

@@ -0,0 +1,104 @@
+package shop.alien.store.controller;
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import io.swagger.annotations.*;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.bind.annotation.*;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.LawyerPaymentTransaction;
+import shop.alien.store.service.LawyerPaymentTransactionService;
+
+import java.util.List;
+
+/**
+ * 支付交易 前端控制器
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Slf4j
+@Api(tags = {"律师平台-支付交易"})
+@ApiSort(20)
+@CrossOrigin
+@RestController
+@RequestMapping("/lawyer/paymentTransaction")
+@RequiredArgsConstructor
+public class LawyerPaymentTransactionController {
+
+    private final LawyerPaymentTransactionService paymentTransactionService;
+
+    @ApiOperation("获取所有支付交易")
+    @ApiOperationSupport(order = 1)
+    @GetMapping("/getAll")
+    public R<List<LawyerPaymentTransaction>> getAll() {
+        log.info("LawyerPaymentTransactionController.getAll");
+        return R.data(paymentTransactionService.list());
+    }
+
+    @ApiOperation("根据id获取支付交易")
+    @ApiOperationSupport(order = 2)
+    @ApiImplicitParams({@ApiImplicitParam(name = "id", value = "主键", dataType = "Integer", paramType = "query", required = true)})
+    @GetMapping("/getOne")
+    public R<LawyerPaymentTransaction> getOne(Integer id) {
+        log.info("LawyerPaymentTransactionController.getOne?id={}", id);
+        return R.data(paymentTransactionService.getById(id));
+    }
+
+    @ApiOperation("分页查询支付交易列表")
+    @ApiOperationSupport(order = 3)
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "pageNum", value = "页数", dataType = "int", paramType = "query", required = true),
+            @ApiImplicitParam(name = "pageSize", value = "页容", dataType = "int", paramType = "query", required = true),
+            @ApiImplicitParam(name = "consultationOrderId", value = "咨询订单ID", dataType = "Integer", paramType = "query"),
+            @ApiImplicitParam(name = "clientUserId", value = "客户端用户ID", dataType = "Integer", paramType = "query"),
+            @ApiImplicitParam(name = "transactionStatus", value = "交易状态", dataType = "Integer", paramType = "query")
+    })
+    @GetMapping("/getPaymentTransactionList")
+    public R<IPage<LawyerPaymentTransaction>> getPaymentTransactionList(@RequestParam(defaultValue = "1") int pageNum,
+                                                                   @RequestParam(defaultValue = "10") int pageSize,
+                                                                   @RequestParam(required = false) Integer consultationOrderId,
+                                                                   @RequestParam(required = false) Integer clientUserId,
+                                                                   @RequestParam(required = false) Integer transactionStatus) {
+        log.info("LawyerPaymentTransactionController.getPaymentTransactionList?pageNum={},pageSize={},consultationOrderId={},clientUserId={},transactionStatus={}",
+                pageNum, pageSize, consultationOrderId, clientUserId, transactionStatus);
+        return paymentTransactionService.getPaymentTransactionList(pageNum, pageSize, consultationOrderId, clientUserId, transactionStatus);
+    }
+
+    @ApiOperation("新增支付交易")
+    @ApiOperationSupport(order = 4)
+    @PostMapping("/addPaymentTransaction")
+    public R<LawyerPaymentTransaction> addPaymentTransaction(@RequestBody LawyerPaymentTransaction paymentTransaction) {
+        log.info("LawyerPaymentTransactionController.addPaymentTransaction?paymentTransaction={}", paymentTransaction);
+        return paymentTransactionService.addPaymentTransaction(paymentTransaction);
+    }
+
+    @ApiOperation("编辑支付交易")
+    @ApiOperationSupport(order = 5)
+    @PostMapping("/editPaymentTransaction")
+    public R<LawyerPaymentTransaction> editPaymentTransaction(@RequestBody LawyerPaymentTransaction paymentTransaction) {
+        log.info("LawyerPaymentTransactionController.editPaymentTransaction?paymentTransaction={}", paymentTransaction);
+        return paymentTransactionService.editPaymentTransaction(paymentTransaction);
+    }
+
+    @ApiOperation("删除支付交易")
+    @ApiOperationSupport(order = 6)
+    @DeleteMapping("/deletePaymentTransaction")
+    public R<Boolean> deletePaymentTransaction(@RequestParam(value = "id") Integer id) {
+        log.info("LawyerPaymentTransactionController.deletePaymentTransaction?id={}", id);
+        return paymentTransactionService.deletePaymentTransaction(id);
+    }
+
+    @ApiOperation("保存或更新支付交易")
+    @ApiOperationSupport(order = 7)
+    @PostMapping("/saveOrUpdate")
+    public R<LawyerPaymentTransaction> saveOrUpdate(@RequestBody LawyerPaymentTransaction paymentTransaction) {
+        log.info("LawyerPaymentTransactionController.saveOrUpdate?paymentTransaction={}", paymentTransaction);
+        boolean result = paymentTransactionService.saveOrUpdate(paymentTransaction);
+        if (result) {
+            return R.data(paymentTransaction);
+        }
+        return R.fail("操作失败");
+    }
+}
+

alien-store/src/main/java/shop/alien/store/controller/LawyerServiceAreaController.java

@@ -0,0 +1,113 @@
+package shop.alien.store.controller;
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import io.swagger.annotations.*;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.bind.annotation.*;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.LawyerServiceArea;
+import shop.alien.store.service.LawyerServiceAreaService;
+
+import java.util.List;
+
+/**
+ * 律师服务领域关联 前端控制器
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Slf4j
+@Api(tags = {"律师平台-律师服务领域关联"})
+@ApiSort(17)
+@CrossOrigin
+@RestController
+@RequestMapping("/lawyer/serviceArea")
+@RequiredArgsConstructor
+public class LawyerServiceAreaController {
+
+    private final LawyerServiceAreaService lawyerServiceAreaService;
+
+    @ApiOperation("获取所有律师服务领域关联")
+    @ApiOperationSupport(order = 1)
+    @GetMapping("/getAll")
+    public R<List<LawyerServiceArea>> getAll() {
+        log.info("LawyerServiceAreaController.getAll");
+        return R.data(lawyerServiceAreaService.list());
+    }
+
+    @ApiOperation("根据id获取律师服务领域关联")
+    @ApiOperationSupport(order = 2)
+    @ApiImplicitParams({@ApiImplicitParam(name = "id", value = "主键", dataType = "Integer", paramType = "query", required = true)})
+    @GetMapping("/getOne")
+    public R<LawyerServiceArea> getOne(Integer id) {
+        log.info("LawyerServiceAreaController.getOne?id={}", id);
+        return R.data(lawyerServiceAreaService.getById(id));
+    }
+
+    @ApiOperation("根据律师ID查询服务领域列表")
+    @ApiOperationSupport(order = 3)
+    @ApiImplicitParams({@ApiImplicitParam(name = "lawyerUserId", value = "律师用户ID", dataType = "Integer", paramType = "query", required = true)})
+    @GetMapping("/getListByLawyerId")
+    public R<List<LawyerServiceArea>> getListByLawyerId(Integer lawyerUserId) {
+        log.info("LawyerServiceAreaController.getListByLawyerId?lawyerUserId={}", lawyerUserId);
+        return R.data(lawyerServiceAreaService.getListByLawyerId(lawyerUserId));
+    }
+
+    @ApiOperation("分页查询律师服务领域列表")
+    @ApiOperationSupport(order = 4)
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "pageNum", value = "页数", dataType = "int", paramType = "query", required = true),
+            @ApiImplicitParam(name = "pageSize", value = "页容", dataType = "int", paramType = "query", required = true),
+            @ApiImplicitParam(name = "lawyerUserId", value = "律师用户ID", dataType = "Integer", paramType = "query"),
+            @ApiImplicitParam(name = "problemScenarId", value = "法律问题场景ID", dataType = "Integer", paramType = "query"),
+            @ApiImplicitParam(name = "status", value = "状态", dataType = "Integer", paramType = "query")
+    })
+    @GetMapping("/getLawyerServiceAreaList")
+    public R<IPage<LawyerServiceArea>> getLawyerServiceAreaList(@RequestParam(defaultValue = "1") int pageNum,
+                                                                  @RequestParam(defaultValue = "10") int pageSize,
+                                                                  @RequestParam(required = false) Integer lawyerUserId,
+                                                                  @RequestParam(required = false) Integer problemScenarId,
+                                                                  @RequestParam(required = false) Integer status) {
+        log.info("LawyerServiceAreaController.getLawyerServiceAreaList?pageNum={},pageSize={},lawyerUserId={},problemScenarId={},status={}",
+                pageNum, pageSize, lawyerUserId, problemScenarId, status);
+        return lawyerServiceAreaService.getLawyerServiceAreaList(pageNum, pageSize, lawyerUserId, problemScenarId, status);
+    }
+
+    @ApiOperation("新增律师服务领域")
+    @ApiOperationSupport(order = 5)
+    @PostMapping("/addLawyerServiceArea")
+    public R<LawyerServiceArea> addLawyerServiceArea(@RequestBody LawyerServiceArea lawyerServiceArea) {
+        log.info("LawyerServiceAreaController.addLawyerServiceArea?lawyerServiceArea={}", lawyerServiceArea);
+        return lawyerServiceAreaService.addLawyerServiceArea(lawyerServiceArea);
+    }
+
+    @ApiOperation("编辑律师服务领域")
+    @ApiOperationSupport(order = 6)
+    @PostMapping("/editLawyerServiceArea")
+    public R<LawyerServiceArea> editLawyerServiceArea(@RequestBody LawyerServiceArea lawyerServiceArea) {
+        log.info("LawyerServiceAreaController.editLawyerServiceArea?lawyerServiceArea={}", lawyerServiceArea);
+        return lawyerServiceAreaService.editLawyerServiceArea(lawyerServiceArea);
+    }
+
+    @ApiOperation("删除律师服务领域")
+    @ApiOperationSupport(order = 7)
+    @DeleteMapping("/deleteLawyerServiceArea")
+    public R<Boolean> deleteLawyerServiceArea(@RequestParam(value = "id") Integer id) {
+        log.info("LawyerServiceAreaController.deleteLawyerServiceArea?id={}", id);
+        return lawyerServiceAreaService.deleteLawyerServiceArea(id);
+    }
+
+    @ApiOperation("保存或更新律师服务领域")
+    @ApiOperationSupport(order = 8)
+    @PostMapping("/saveOrUpdate")
+    public R<LawyerServiceArea> saveOrUpdate(@RequestBody LawyerServiceArea lawyerServiceArea) {
+        log.info("LawyerServiceAreaController.saveOrUpdate?lawyerServiceArea={}", lawyerServiceArea);
+        boolean result = lawyerServiceAreaService.saveOrUpdate(lawyerServiceArea);
+        if (result) {
+            return R.data(lawyerServiceArea);
+        }
+        return R.fail("操作失败");
+    }
+}
+

alien-store/src/main/java/shop/alien/store/controller/LawyerUserController.java

@@ -0,0 +1,101 @@
+package shop.alien.store.controller;
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import io.swagger.annotations.*;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.bind.annotation.*;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.LawyerUser;
+import shop.alien.store.service.LawyerUserService;
+
+/**
+ * 律师用户 前端控制器
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Slf4j
+@Api(tags = {"律师平台-律师用户"})
+@ApiSort(10)
+@CrossOrigin
+@RestController
+@RequestMapping("/lawyer/user")
+@RequiredArgsConstructor
+public class LawyerUserController {
+
+    private final LawyerUserService lawyerUserService;
+
+    @ApiOperation("获取所有律师用户")
+    @ApiOperationSupport(order = 1)
+    @GetMapping("/getAll")
+    public R<java.util.List<LawyerUser>> getAll() {
+        log.info("LawyerUserController.getAll");
+        return R.data(lawyerUserService.list());
+    }
+
+    @ApiOperation("根据id获取律师用户")
+    @ApiOperationSupport(order = 2)
+    @ApiImplicitParams({@ApiImplicitParam(name = "id", value = "主键", dataType = "Integer", paramType = "query", required = true)})
+    @GetMapping("/getOne")
+    public R<LawyerUser> getOne(Integer id) {
+        log.info("LawyerUserController.getOne?id={}", id);
+        return R.data(lawyerUserService.getById(id));
+    }
+
+    @ApiOperation("分页查询律师用户列表")
+    @ApiOperationSupport(order = 3)
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "pageNum", value = "页数", dataType = "int", paramType = "query", required = true),
+            @ApiImplicitParam(name = "pageSize", value = "页容", dataType = "int", paramType = "query", required = true),
+            @ApiImplicitParam(name = "name", value = "姓名", dataType = "String", paramType = "query"),
+            @ApiImplicitParam(name = "phone", value = "手机号", dataType = "String", paramType = "query"),
+            @ApiImplicitParam(name = "status", value = "状态", dataType = "Integer", paramType = "query")
+    })
+    @GetMapping("/getLawyerUserList")
+    public R<IPage<LawyerUser>> getLawyerUserList(@RequestParam(defaultValue = "1") int pageNum,
+                                                    @RequestParam(defaultValue = "10") int pageSize,
+                                                    @RequestParam(required = false) String name,
+                                                    @RequestParam(required = false) String phone,
+                                                    @RequestParam(required = false) Integer status) {
+        log.info("LawyerUserController.getLawyerUserList?pageNum={},pageSize={},name={},phone={},status={}", pageNum, pageSize, name, phone, status);
+        return lawyerUserService.getLawyerUserList(pageNum, pageSize, name, phone, status);
+    }
+
+    @ApiOperation("新增律师用户")
+    @ApiOperationSupport(order = 4)
+    @PostMapping("/addLawyerUser")
+    public R<LawyerUser> addLawyerUser(@RequestBody LawyerUser lawyerUser) {
+        log.info("LawyerUserController.addLawyerUser?lawyerUser={}", lawyerUser);
+        return lawyerUserService.addLawyerUser(lawyerUser);
+    }
+
+    @ApiOperation("编辑律师用户")
+    @ApiOperationSupport(order = 5)
+    @PostMapping("/editLawyerUser")
+    public R<LawyerUser> editLawyerUser(@RequestBody LawyerUser lawyerUser) {
+        log.info("LawyerUserController.editLawyerUser?lawyerUser={}", lawyerUser);
+        return lawyerUserService.editLawyerUser(lawyerUser);
+    }
+
+    @ApiOperation("删除律师用户")
+    @ApiOperationSupport(order = 6)
+    @DeleteMapping("/deleteLawyerUser")
+    public R<Boolean> deleteLawyerUser(@RequestParam(value = "id") Integer id) {
+        log.info("LawyerUserController.deleteLawyerUser?id={}", id);
+        return lawyerUserService.deleteLawyerUser(id);
+    }
+
+    @ApiOperation("保存或更新律师用户")
+    @ApiOperationSupport(order = 7)
+    @PostMapping("/saveOrUpdate")
+    public R<LawyerUser> saveOrUpdate(@RequestBody LawyerUser lawyerUser) {
+        log.info("LawyerUserController.saveOrUpdate?lawyerUser={}", lawyerUser);
+        boolean result = lawyerUserService.saveOrUpdate(lawyerUser);
+        if (result) {
+            return R.data(lawyerUser);
+        }
+        return R.fail("操作失败");
+    }
+}
+

alien-store/src/main/java/shop/alien/store/controller/LawyerUserSearchHistoryController.java

@@ -0,0 +1,99 @@
+package shop.alien.store.controller;
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import io.swagger.annotations.*;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.bind.annotation.*;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.LawyerUserSearchHistory;
+import shop.alien.store.service.LawyerUserSearchHistoryService;
+
+import java.util.List;
+
+/**
+ * 用户搜索历史 前端控制器
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Slf4j
+@Api(tags = {"律师平台-用户搜索历史"})
+@ApiSort(22)
+@CrossOrigin
+@RestController
+@RequestMapping("/lawyer/userSearchHistory")
+@RequiredArgsConstructor
+public class LawyerUserSearchHistoryController {
+
+    private final LawyerUserSearchHistoryService userSearchHistoryService;
+
+    @ApiOperation("获取所有用户搜索历史")
+    @ApiOperationSupport(order = 1)
+    @GetMapping("/getAll")
+    public R<List<LawyerUserSearchHistory>> getAll() {
+        log.info("LawyerUserSearchHistoryController.getAll");
+        return R.data(userSearchHistoryService.list());
+    }
+
+    @ApiOperation("根据id获取用户搜索历史")
+    @ApiOperationSupport(order = 2)
+    @ApiImplicitParams({@ApiImplicitParam(name = "id", value = "主键", dataType = "Integer", paramType = "query", required = true)})
+    @GetMapping("/getOne")
+    public R<LawyerUserSearchHistory> getOne(Integer id) {
+        log.info("LawyerUserSearchHistoryController.getOne?id={}", id);
+        return R.data(userSearchHistoryService.getById(id));
+    }
+
+    @ApiOperation("根据用户ID查询搜索历史列表")
+    @ApiOperationSupport(order = 3)
+    @ApiImplicitParams({@ApiImplicitParam(name = "clientUserId", value = "客户端用户ID", dataType = "Integer", paramType = "query", required = true)})
+    @GetMapping("/getListByUserId")
+    public R<List<LawyerUserSearchHistory>> getListByUserId(Integer clientUserId) {
+        log.info("LawyerUserSearchHistoryController.getListByUserId?clientUserId={}", clientUserId);
+        return R.data(userSearchHistoryService.getListByUserId(clientUserId));
+    }
+
+    @ApiOperation("分页查询用户搜索历史列表")
+    @ApiOperationSupport(order = 4)
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "pageNum", value = "页数", dataType = "int", paramType = "query", required = true),
+            @ApiImplicitParam(name = "pageSize", value = "页容", dataType = "int", paramType = "query", required = true),
+            @ApiImplicitParam(name = "clientUserId", value = "客户端用户ID", dataType = "Integer", paramType = "query"),
+            @ApiImplicitParam(name = "searchType", value = "搜索类型", dataType = "Integer", paramType = "query")
+    })
+    @GetMapping("/getUserSearchHistoryList")
+    public R<IPage<LawyerUserSearchHistory>> getUserSearchHistoryList(@RequestParam(defaultValue = "1") int pageNum,
+                                                                 @RequestParam(defaultValue = "10") int pageSize,
+                                                                 @RequestParam(required = false) Integer clientUserId,
+                                                                 @RequestParam(required = false) Integer searchType) {
+        log.info("LawyerUserSearchHistoryController.getUserSearchHistoryList?pageNum={},pageSize={},clientUserId={},searchType={}",
+                pageNum, pageSize, clientUserId, searchType);
+        return userSearchHistoryService.getUserSearchHistoryList(pageNum, pageSize, clientUserId, searchType);
+    }
+
+    @ApiOperation("新增用户搜索历史")
+    @ApiOperationSupport(order = 5)
+    @PostMapping("/addUserSearchHistory")
+    public R<LawyerUserSearchHistory> addUserSearchHistory(@RequestBody LawyerUserSearchHistory userSearchHistory) {
+        log.info("LawyerUserSearchHistoryController.addUserSearchHistory?userSearchHistory={}", userSearchHistory);
+        return userSearchHistoryService.addUserSearchHistory(userSearchHistory);
+    }
+
+    @ApiOperation("删除用户搜索历史")
+    @ApiOperationSupport(order = 6)
+    @DeleteMapping("/deleteUserSearchHistory")
+    public R<Boolean> deleteUserSearchHistory(@RequestParam(value = "id") Integer id) {
+        log.info("LawyerUserSearchHistoryController.deleteUserSearchHistory?id={}", id);
+        return userSearchHistoryService.deleteUserSearchHistory(id);
+    }
+
+    @ApiOperation("清空用户搜索历史")
+    @ApiOperationSupport(order = 7)
+    @DeleteMapping("/clearUserSearchHistory")
+    public R<Boolean> clearUserSearchHistory(@RequestParam(value = "clientUserId") Integer clientUserId) {
+        log.info("LawyerUserSearchHistoryController.clearUserSearchHistory?clientUserId={}", clientUserId);
+        return userSearchHistoryService.clearUserSearchHistory(clientUserId);
+    }
+}
+

alien-store/src/main/java/shop/alien/store/service/LawyerAiInteractionLogService.java

@@ -0,0 +1,63 @@
+package shop.alien.store.service;
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.service.IService;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.LawyerAiInteractionLog;
+
+import java.util.List;
+
+/**
+ * AI交互日志 服务类
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+public interface LawyerAiInteractionLogService extends IService<LawyerAiInteractionLog> {
+
+    /**
+     * 分页查询AI交互日志列表
+     *
+     * @param pageNum         页码
+     * @param pageSize        页容
+     * @param clientUserId    客户端用户ID
+     * @param conversationId  会话ID
+     * @param problemScenarId 法律问题场景ID
+     * @return IPage<LawyerAiInteractionLog>
+     */
+    R<IPage<LawyerAiInteractionLog>> getAiInteractionLogList(int pageNum, int pageSize, Integer clientUserId,
+                                                        String conversationId, Integer problemScenarId);
+
+    /**
+     * 根据会话ID查询交互日志列表
+     *
+     * @param conversationId 会话ID
+     * @return List<LawyerAiInteractionLog>
+     */
+    List<LawyerAiInteractionLog> getListByConversationId(String conversationId);
+
+    /**
+     * 新增AI交互日志
+     *
+     * @param aiInteractionLog AI交互日志
+     * @return R<LawyerAiInteractionLog>
+     */
+    R<LawyerAiInteractionLog> addAiInteractionLog(LawyerAiInteractionLog aiInteractionLog);
+
+    /**
+     * 编辑AI交互日志
+     *
+     * @param aiInteractionLog AI交互日志
+     * @return R<LawyerAiInteractionLog>
+     */
+    R<LawyerAiInteractionLog> editAiInteractionLog(LawyerAiInteractionLog aiInteractionLog);
+
+    /**
+     * 删除AI交互日志
+     *
+     * @param id 主键
+     * @return R<Boolean>
+     */
+    R<Boolean> deleteAiInteractionLog(Integer id);
+}
+

alien-store/src/main/java/shop/alien/store/service/LawyerChatMessageService.java

@@ -0,0 +1,63 @@
+package shop.alien.store.service;
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.service.IService;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.LawyerChatMessage;
+
+import java.util.List;
+
+/**
+ * 聊天消息 服务类
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+public interface LawyerChatMessageService extends IService<LawyerChatMessage> {
+
+    /**
+     * 分页查询聊天消息列表
+     *
+     * @param pageNum             页码
+     * @param pageSize            页容
+     * @param chatSessionId       聊天会话ID
+     * @param consultationOrderId 咨询订单ID
+     * @param senderType          发送者类型
+     * @return IPage<LawyerChatMessage>
+     */
+    R<IPage<LawyerChatMessage>> getChatMessageList(int pageNum, int pageSize, Integer chatSessionId,
+                                             Integer consultationOrderId, Integer senderType);
+
+    /**
+     * 根据会话ID查询消息列表
+     *
+     * @param chatSessionId 聊天会话ID
+     * @return List<LawyerChatMessage>
+     */
+    List<LawyerChatMessage> getListBySessionId(Integer chatSessionId);
+
+    /**
+     * 新增聊天消息
+     *
+     * @param chatMessage 聊天消息
+     * @return R<LawyerChatMessage>
+     */
+    R<LawyerChatMessage> addChatMessage(LawyerChatMessage chatMessage);
+
+    /**
+     * 编辑聊天消息
+     *
+     * @param chatMessage 聊天消息
+     * @return R<LawyerChatMessage>
+     */
+    R<LawyerChatMessage> editChatMessage(LawyerChatMessage chatMessage);
+
+    /**
+     * 删除聊天消息
+     *
+     * @param id 主键
+     * @return R<Boolean>
+     */
+    R<Boolean> deleteChatMessage(Integer id);
+}
+

alien-store/src/main/java/shop/alien/store/service/LawyerChatSessionService.java

@@ -0,0 +1,64 @@
+package shop.alien.store.service;
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.service.IService;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.LawyerChatSession;
+
+import java.util.List;
+
+/**
+ * 聊天会话 服务类
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+public interface LawyerChatSessionService extends IService<LawyerChatSession> {
+
+    /**
+     * 分页查询聊天会话列表
+     *
+     * @param pageNum             页码
+     * @param pageSize            页容
+     * @param consultationOrderId 咨询订单ID
+     * @param clientUserId        客户端用户ID
+     * @param lawyerUserId        律师用户ID
+     * @param status              会话状态
+     * @return IPage<LawyerChatSession>
+     */
+    R<IPage<LawyerChatSession>> getChatSessionList(int pageNum, int pageSize, Integer consultationOrderId,
+                                             Integer clientUserId, Integer lawyerUserId, Integer status);
+
+    /**
+     * 根据订单ID查询会话
+     *
+     * @param consultationOrderId 咨询订单ID
+     * @return LawyerChatSession
+     */
+    LawyerChatSession getByOrderId(Integer consultationOrderId);
+
+    /**
+     * 新增聊天会话
+     *
+     * @param chatSession 聊天会话
+     * @return R<LawyerChatSession>
+     */
+    R<LawyerChatSession> addChatSession(LawyerChatSession chatSession);
+
+    /**
+     * 编辑聊天会话
+     *
+     * @param chatSession 聊天会话
+     * @return R<LawyerChatSession>
+     */
+    R<LawyerChatSession> editChatSession(LawyerChatSession chatSession);
+
+    /**
+     * 删除聊天会话
+     *
+     * @param id 主键
+     * @return R<Boolean>
+     */
+    R<Boolean> deleteChatSession(Integer id);
+}
+

alien-store/src/main/java/shop/alien/store/service/LawyerCommonQuestionService.java

@@ -0,0 +1,64 @@
+package shop.alien.store.service;
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.service.IService;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.LawyerCommonQuestion;
+
+import java.util.List;
+
+/**
+ * 常见问题 服务类
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+public interface LawyerCommonQuestionService extends IService<LawyerCommonQuestion> {
+
+    /**
+     * 分页查询常见问题列表
+     *
+     * @param pageNum         页码
+     * @param pageSize        页容
+     * @param questionText    问题文本
+     * @param categoryType    分类类型
+     * @param problemScenarId 法律问题场景ID
+     * @param status          状态
+     * @return IPage<LawyerCommonQuestion>
+     */
+    R<IPage<LawyerCommonQuestion>> getCommonQuestionList(int pageNum, int pageSize, String questionText,
+                                                    Integer categoryType, Integer problemScenarId, Integer status);
+
+    /**
+     * 根据分类类型查询常见问题列表
+     *
+     * @param categoryType 分类类型
+     * @return List<LawyerCommonQuestion>
+     */
+    List<LawyerCommonQuestion> getListByCategoryType(Integer categoryType);
+
+    /**
+     * 新增常见问题
+     *
+     * @param commonQuestion 常见问题
+     * @return R<LawyerCommonQuestion>
+     */
+    R<LawyerCommonQuestion> addCommonQuestion(LawyerCommonQuestion commonQuestion);
+
+    /**
+     * 编辑常见问题
+     *
+     * @param commonQuestion 常见问题
+     * @return R<LawyerCommonQuestion>
+     */
+    R<LawyerCommonQuestion> editCommonQuestion(LawyerCommonQuestion commonQuestion);
+
+    /**
+     * 删除常见问题
+     *
+     * @param id 主键
+     * @return R<Boolean>
+     */
+    R<Boolean> deleteCommonQuestion(Integer id);
+}
+

alien-store/src/main/java/shop/alien/store/service/LawyerConsultationOrderService.java

@@ -0,0 +1,54 @@
+package shop.alien.store.service;
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.service.IService;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.LawyerConsultationOrder;
+
+/**
+ * 咨询订单 服务类
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+public interface LawyerConsultationOrderService extends IService<LawyerConsultationOrder> {
+
+    /**
+     * 分页查询咨询订单列表
+     *
+     * @param pageNum      页码
+     * @param pageSize     页容
+     * @param orderNumber  订单编号
+     * @param clientUserId 客户端用户ID
+     * @param lawyerUserId 律师用户ID
+     * @param orderStatus  订单状态
+     * @return IPage<LawyerConsultationOrder>
+     */
+    R<IPage<LawyerConsultationOrder>> getConsultationOrderList(int pageNum, int pageSize, String orderNumber,
+                                                          Integer clientUserId, Integer lawyerUserId, Integer orderStatus);
+
+    /**
+     * 新增咨询订单
+     *
+     * @param consultationOrder 咨询订单
+     * @return R<LawyerConsultationOrder>
+     */
+    R<LawyerConsultationOrder> addConsultationOrder(LawyerConsultationOrder consultationOrder);
+
+    /**
+     * 编辑咨询订单
+     *
+     * @param consultationOrder 咨询订单
+     * @return R<LawyerConsultationOrder>
+     */
+    R<LawyerConsultationOrder> editConsultationOrder(LawyerConsultationOrder consultationOrder);
+
+    /**
+     * 删除咨询订单
+     *
+     * @param id 主键
+     * @return R<Boolean>
+     */
+    R<Boolean> deleteConsultationOrder(Integer id);
+}
+

alien-store/src/main/java/shop/alien/store/service/LawyerConsultationReviewService.java

@@ -0,0 +1,63 @@
+package shop.alien.store.service;
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.service.IService;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.LawyerConsultationReview;
+
+import java.util.List;
+
+/**
+ * 咨询评价 服务类
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+public interface LawyerConsultationReviewService extends IService<LawyerConsultationReview> {
+
+    /**
+     * 分页查询咨询评价列表
+     *
+     * @param pageNum             页码
+     * @param pageSize            页容
+     * @param consultationOrderId 咨询订单ID
+     * @param lawyerUserId        律师用户ID
+     * @param clientUserId        客户端用户ID
+     * @return IPage<LawyerConsultationReview>
+     */
+    R<IPage<LawyerConsultationReview>> getConsultationReviewList(int pageNum, int pageSize, Integer consultationOrderId,
+                                                            Integer lawyerUserId, Integer clientUserId);
+
+    /**
+     * 根据律师ID查询评价列表
+     *
+     * @param lawyerUserId 律师用户ID
+     * @return List<LawyerConsultationReview>
+     */
+    List<LawyerConsultationReview> getListByLawyerId(Integer lawyerUserId);
+
+    /**
+     * 新增咨询评价
+     *
+     * @param consultationReview 咨询评价
+     * @return R<LawyerConsultationReview>
+     */
+    R<LawyerConsultationReview> addConsultationReview(LawyerConsultationReview consultationReview);
+
+    /**
+     * 编辑咨询评价
+     *
+     * @param consultationReview 咨询评价
+     * @return R<LawyerConsultationReview>
+     */
+    R<LawyerConsultationReview> editConsultationReview(LawyerConsultationReview consultationReview);
+
+    /**
+     * 删除咨询评价
+     *
+     * @param id 主键
+     * @return R<Boolean>
+     */
+    R<Boolean> deleteConsultationReview(Integer id);
+}
+

alien-store/src/main/java/shop/alien/store/service/LawyerImgService.java

@@ -0,0 +1,62 @@
+package shop.alien.store.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.LawyerImg;
+import shop.alien.entity.store.vo.LawyerImgTypeVo;
+
+import java.util.List;
+
+/**
+ * 律师图片 服务类
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+public interface LawyerImgService extends IService<LawyerImg> {
+
+    /**
+     * 获取律师图片
+     *
+     * @param lawyerId 律师ID
+     * @param imgType  图片类型, 0:其他, 1:头像, 2:执业证照片, 3:身份证正面, 4:身份证反面, 5:案例图片, 6:相册图片, 7:资质证书, 8:荣誉证书, 9:工作照片
+     * @return list
+     */
+    List<LawyerImg> getLawyerImg(Integer lawyerId, Integer imgType);
+
+    /**
+     * 获取所有图片类型和数量
+     *
+     * @param lawyerId 律师ID
+     * @return LawyerImgTypeVo
+     */
+    List<LawyerImgTypeVo> getLawyerImgTypeCount(Integer lawyerId);
+
+    /**
+     * 获取图片URL列表
+     *
+     * @param id      律师ID
+     * @param imgType 图片类型
+     * @return List<String>
+     */
+    List<String> getUrl(String id, Integer imgType);
+
+    /**
+     * 通过businessId获取图片
+     *
+     * @param lawyerId  律师ID
+     * @param imgType   图片类型
+     * @param businessId 业务ID
+     * @return list
+     */
+    List<LawyerImg> getByBusinessId(Integer lawyerId, Integer imgType, Integer businessId);
+
+    /**
+     * 删除图片
+     *
+     * @param lawyerId 律师ID
+     * @param imgType  图片类型
+     */
+    int saveOrUpdateImg(Integer lawyerId, Integer imgType);
+}
+

alien-store/src/main/java/shop/alien/store/service/LawyerLegalProblemScenarioService.java

@@ -0,0 +1,72 @@
+package shop.alien.store.service;
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.service.IService;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.LawyerLegalProblemScenario;
+
+import java.util.List;
+
+/**
+ * 法律问题场景 服务类
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+public interface LawyerLegalProblemScenarioService extends IService<LawyerLegalProblemScenario> {
+
+    /**
+     * 分页查询法律问题场景列表
+     *
+     * @param pageNum  页码
+     * @param pageSize 页容
+     * @param name     名称
+     * @param code     编号
+     * @param status   状态
+     * @return IPage<LawyerLegalProblemScenar>
+     */
+    R<IPage<LawyerLegalProblemScenario>> getLawyerLegalProblemScenarioList(int pageNum, int pageSize, String name, String code, Integer status);
+
+    /**
+     * 根据父类ID查询子分类列表
+     *
+     * @param parentId 父类主键
+     * @return List<LawyerLegalProblemScenar>
+     */
+    List<LawyerLegalProblemScenario> getListByParentId(String parentId);
+
+    /**
+     * 根据父类编号查询子分类列表
+     *
+     * @param parentCode 父类编号
+     * @return List<LawyerLegalProblemScenar>
+     */
+    List<LawyerLegalProblemScenario> getListByParentCode(String parentCode);
+
+    /**
+     * 新增法律问题场景
+     *
+     * @param lawyerLegalProblemScenario 法律问题场景
+     * @return R<LawyerLegalProblemScenar>
+     */
+    R<LawyerLegalProblemScenario> addLawyerLegalProblemScenario(LawyerLegalProblemScenario lawyerLegalProblemScenario);
+
+    /**
+     * 编辑法律问题场景
+     *
+     * @param lawyerLegalProblemScenario 法律问题场景
+     * @return R<LawyerLegalProblemScenar>
+     */
+    R<LawyerLegalProblemScenario> editLawyerLegalProblemScenario(LawyerLegalProblemScenario lawyerLegalProblemScenario);
+
+    /**
+     * 删除法律问题场景
+     *
+     * @param id 主键
+     * @return R<Boolean>
+     */
+    R<Boolean> deleteLawyerLegalProblemScenario(Integer id);
+
+
+}
+

alien-store/src/main/java/shop/alien/store/service/LawyerPaymentTransactionService.java

@@ -0,0 +1,53 @@
+package shop.alien.store.service;
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.service.IService;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.LawyerPaymentTransaction;
+
+/**
+ * 支付交易 服务类
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+public interface LawyerPaymentTransactionService extends IService<LawyerPaymentTransaction> {
+
+    /**
+     * 分页查询支付交易列表
+     *
+     * @param pageNum             页码
+     * @param pageSize            页容
+     * @param consultationOrderId 咨询订单ID
+     * @param clientUserId        客户端用户ID
+     * @param transactionStatus   交易状态
+     * @return IPage<LawyerPaymentTransaction>
+     */
+    R<IPage<LawyerPaymentTransaction>> getPaymentTransactionList(int pageNum, int pageSize, Integer consultationOrderId,
+                                                           Integer clientUserId, Integer transactionStatus);
+
+    /**
+     * 新增支付交易
+     *
+     * @param paymentTransaction 支付交易
+     * @return R<LawyerPaymentTransaction>
+     */
+    R<LawyerPaymentTransaction> addPaymentTransaction(LawyerPaymentTransaction paymentTransaction);
+
+    /**
+     * 编辑支付交易
+     *
+     * @param paymentTransaction 支付交易
+     * @return R<LawyerPaymentTransaction>
+     */
+    R<LawyerPaymentTransaction> editPaymentTransaction(LawyerPaymentTransaction paymentTransaction);
+
+    /**
+     * 删除支付交易
+     *
+     * @param id 主键
+     * @return R<Boolean>
+     */
+    R<Boolean> deletePaymentTransaction(Integer id);
+}
+

alien-store/src/main/java/shop/alien/store/service/LawyerServiceAreaService.java

@@ -0,0 +1,63 @@
+package shop.alien.store.service;
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.service.IService;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.LawyerServiceArea;
+
+import java.util.List;
+
+/**
+ * 律师服务领域关联 服务类
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+public interface LawyerServiceAreaService extends IService<LawyerServiceArea> {
+
+    /**
+     * 分页查询律师服务领域列表
+     *
+     * @param pageNum       页码
+     * @param pageSize      页容
+     * @param lawyerUserId  律师用户ID
+     * @param problemScenarId 法律问题场景ID
+     * @param status        状态
+     * @return IPage<LawyerServiceArea>
+     */
+    R<IPage<LawyerServiceArea>> getLawyerServiceAreaList(int pageNum, int pageSize, Integer lawyerUserId,
+                                                         Integer problemScenarId, Integer status);
+
+    /**
+     * 根据律师ID查询服务领域列表
+     *
+     * @param lawyerUserId 律师用户ID
+     * @return List<LawyerServiceArea>
+     */
+    List<LawyerServiceArea> getListByLawyerId(Integer lawyerUserId);
+
+    /**
+     * 新增律师服务领域
+     *
+     * @param lawyerServiceArea 律师服务领域关联
+     * @return R<LawyerServiceArea>
+     */
+    R<LawyerServiceArea> addLawyerServiceArea(LawyerServiceArea lawyerServiceArea);
+
+    /**
+     * 编辑律师服务领域
+     *
+     * @param lawyerServiceArea 律师服务领域关联
+     * @return R<LawyerServiceArea>
+     */
+    R<LawyerServiceArea> editLawyerServiceArea(LawyerServiceArea lawyerServiceArea);
+
+    /**
+     * 删除律师服务领域
+     *
+     * @param id 主键
+     * @return R<Boolean>
+     */
+    R<Boolean> deleteLawyerServiceArea(Integer id);
+}
+

alien-store/src/main/java/shop/alien/store/service/LawyerUserSearchHistoryService.java

@@ -0,0 +1,61 @@
+package shop.alien.store.service;
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.service.IService;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.LawyerUserSearchHistory;
+
+import java.util.List;
+
+/**
+ * 用户搜索历史 服务类
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+public interface LawyerUserSearchHistoryService extends IService<LawyerUserSearchHistory> {
+
+    /**
+     * 分页查询用户搜索历史列表
+     *
+     * @param pageNum     页码
+     * @param pageSize    页容
+     * @param clientUserId 客户端用户ID
+     * @param searchType  搜索类型
+     * @return IPage<LawyerUserSearchHistory>
+     */
+    R<IPage<LawyerUserSearchHistory>> getUserSearchHistoryList(int pageNum, int pageSize, Integer clientUserId, Integer searchType);
+
+    /**
+     * 根据用户ID查询搜索历史列表
+     *
+     * @param clientUserId 客户端用户ID
+     * @return List<LawyerUserSearchHistory>
+     */
+    List<LawyerUserSearchHistory> getListByUserId(Integer clientUserId);
+
+    /**
+     * 新增用户搜索历史
+     *
+     * @param userSearchHistory 用户搜索历史
+     * @return R<LawyerUserSearchHistory>
+     */
+    R<LawyerUserSearchHistory> addUserSearchHistory(LawyerUserSearchHistory userSearchHistory);
+
+    /**
+     * 删除用户搜索历史
+     *
+     * @param id 主键
+     * @return R<Boolean>
+     */
+    R<Boolean> deleteUserSearchHistory(Integer id);
+
+    /**
+     * 清空用户搜索历史
+     *
+     * @param clientUserId 客户端用户ID
+     * @return R<Boolean>
+     */
+    R<Boolean> clearUserSearchHistory(Integer clientUserId);
+}
+

alien-store/src/main/java/shop/alien/store/service/LawyerUserService.java

@@ -0,0 +1,54 @@
+package shop.alien.store.service;
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.service.IService;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.LawyerUser;
+
+import java.util.List;
+
+/**
+ * 律师用户 服务类
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+public interface LawyerUserService extends IService<LawyerUser> {
+
+    /**
+     * 分页查询律师用户列表
+     *
+     * @param pageNum  页码
+     * @param pageSize 页容
+     * @param name     姓名
+     * @param phone    手机号
+     * @param status   状态
+     * @return IPage<LawyerUser>
+     */
+    R<IPage<LawyerUser>> getLawyerUserList(int pageNum, int pageSize, String name, String phone, Integer status);
+
+    /**
+     * 新增律师用户
+     *
+     * @param lawyerUser 律师用户
+     * @return R<LawyerUser>
+     */
+    R<LawyerUser> addLawyerUser(LawyerUser lawyerUser);
+
+    /**
+     * 编辑律师用户
+     *
+     * @param lawyerUser 律师用户
+     * @return R<LawyerUser>
+     */
+    R<LawyerUser> editLawyerUser(LawyerUser lawyerUser);
+
+    /**
+     * 删除律师用户
+     *
+     * @param id 主键
+     * @return R<Boolean>
+     */
+    R<Boolean> deleteLawyerUser(Integer id);
+}
+

alien-store/src/main/java/shop/alien/store/service/impl/LawyerAiInteractionLogServiceImpl.java

@@ -0,0 +1,95 @@
+package shop.alien.store.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.util.StringUtils;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.LawyerAiInteractionLog;
+import shop.alien.mapper.LawyerAiInteractionLogMapper;
+import shop.alien.store.service.LawyerAiInteractionLogService;
+
+import java.util.List;
+
+/**
+ * AI交互日志 服务实现类
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Slf4j
+@Transactional
+@Service
+@RequiredArgsConstructor
+public class LawyerAiInteractionLogServiceImpl extends ServiceImpl<LawyerAiInteractionLogMapper, LawyerAiInteractionLog> implements LawyerAiInteractionLogService {
+
+    private final LawyerAiInteractionLogMapper aiInteractionLogMapper;
+
+    @Override
+    public R<IPage<LawyerAiInteractionLog>> getAiInteractionLogList(int pageNum, int pageSize, Integer clientUserId,
+                                                               String conversationId, Integer problemScenarId) {
+        log.info("LawyerAiInteractionLogServiceImpl.getAiInteractionLogList?pageNum={},pageSize={},clientUserId={},conversationId={},problemScenarId={}",
+                pageNum, pageSize, clientUserId, conversationId, problemScenarId);
+        Page<LawyerAiInteractionLog> page = new Page<>(pageNum, pageSize);
+        LambdaQueryWrapper<LawyerAiInteractionLog> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(LawyerAiInteractionLog::getDeleteFlag, 0);
+        if (clientUserId != null) {
+            queryWrapper.eq(LawyerAiInteractionLog::getClientUserId, clientUserId);
+        }
+        if (StringUtils.hasText(conversationId)) {
+            queryWrapper.eq(LawyerAiInteractionLog::getConversationId, conversationId);
+        }
+        if (problemScenarId != null) {
+            queryWrapper.eq(LawyerAiInteractionLog::getProblemScenarId, problemScenarId);
+        }
+        queryWrapper.orderByDesc(LawyerAiInteractionLog::getInteractionTime);
+        IPage<LawyerAiInteractionLog> pageResult = this.page(page, queryWrapper);
+        return R.data(pageResult);
+    }
+
+    @Override
+    public List<LawyerAiInteractionLog> getListByConversationId(String conversationId) {
+        log.info("LawyerAiInteractionLogServiceImpl.getListByConversationId?conversationId={}", conversationId);
+        LambdaQueryWrapper<LawyerAiInteractionLog> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(LawyerAiInteractionLog::getConversationId, conversationId)
+                .eq(LawyerAiInteractionLog::getDeleteFlag, 0)
+                .orderByAsc(LawyerAiInteractionLog::getInteractionTime);
+        return this.list(queryWrapper);
+    }
+
+    @Override
+    public R<LawyerAiInteractionLog> addAiInteractionLog(LawyerAiInteractionLog aiInteractionLog) {
+        log.info("LawyerAiInteractionLogServiceImpl.addAiInteractionLog?aiInteractionLog={}", aiInteractionLog);
+        boolean result = this.save(aiInteractionLog);
+        if (result) {
+            return R.data(aiInteractionLog);
+        }
+        return R.fail("新增失败");
+    }
+
+    @Override
+    public R<LawyerAiInteractionLog> editAiInteractionLog(LawyerAiInteractionLog aiInteractionLog) {
+        log.info("LawyerAiInteractionLogServiceImpl.editAiInteractionLog?aiInteractionLog={}", aiInteractionLog);
+        boolean result = this.updateById(aiInteractionLog);
+        if (result) {
+            return R.data(aiInteractionLog);
+        }
+        return R.fail("修改失败");
+    }
+
+    @Override
+    public R<Boolean> deleteAiInteractionLog(Integer id) {
+        log.info("LawyerAiInteractionLogServiceImpl.deleteAiInteractionLog?id={}", id);
+        boolean result = this.removeById(id);
+        if (result) {
+            return R.success("删除成功");
+        }
+        return R.fail("删除失败");
+    }
+}
+

alien-store/src/main/java/shop/alien/store/service/impl/LawyerChatMessageServiceImpl.java

@@ -0,0 +1,94 @@
+package shop.alien.store.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.LawyerChatMessage;
+import shop.alien.mapper.LawyerChatMessageMapper;
+import shop.alien.store.service.LawyerChatMessageService;
+
+import java.util.List;
+
+/**
+ * 聊天消息 服务实现类
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Slf4j
+@Transactional
+@Service
+@RequiredArgsConstructor
+public class LawyerChatMessageServiceImpl extends ServiceImpl<LawyerChatMessageMapper, LawyerChatMessage> implements LawyerChatMessageService {
+
+    private final LawyerChatMessageMapper chatMessageMapper;
+
+    @Override
+    public R<IPage<LawyerChatMessage>> getChatMessageList(int pageNum, int pageSize, Integer chatSessionId,
+                                                     Integer consultationOrderId, Integer senderType) {
+        log.info("LawyerChatMessageServiceImpl.getChatMessageList?pageNum={},pageSize={},chatSessionId={},consultationOrderId={},senderType={}",
+                pageNum, pageSize, chatSessionId, consultationOrderId, senderType);
+        Page<LawyerChatMessage> page = new Page<>(pageNum, pageSize);
+        LambdaQueryWrapper<LawyerChatMessage> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(LawyerChatMessage::getDeleteFlag, 0);
+        if (chatSessionId != null) {
+            queryWrapper.eq(LawyerChatMessage::getChatSessionId, chatSessionId);
+        }
+        if (consultationOrderId != null) {
+            queryWrapper.eq(LawyerChatMessage::getConsultationOrderId, consultationOrderId);
+        }
+        if (senderType != null) {
+            queryWrapper.eq(LawyerChatMessage::getSenderType, senderType);
+        }
+        queryWrapper.orderByAsc(LawyerChatMessage::getMessageTimestamp);
+        IPage<LawyerChatMessage> pageResult = this.page(page, queryWrapper);
+        return R.data(pageResult);
+    }
+
+    @Override
+    public List<LawyerChatMessage> getListBySessionId(Integer chatSessionId) {
+        log.info("LawyerChatMessageServiceImpl.getListBySessionId?chatSessionId={}", chatSessionId);
+        LambdaQueryWrapper<LawyerChatMessage> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(LawyerChatMessage::getChatSessionId, chatSessionId)
+                .eq(LawyerChatMessage::getDeleteFlag, 0)
+                .orderByAsc(LawyerChatMessage::getMessageTimestamp);
+        return this.list(queryWrapper);
+    }
+
+    @Override
+    public R<LawyerChatMessage> addChatMessage(LawyerChatMessage chatMessage) {
+        log.info("LawyerChatMessageServiceImpl.addChatMessage?chatMessage={}", chatMessage);
+        boolean result = this.save(chatMessage);
+        if (result) {
+            return R.data(chatMessage);
+        }
+        return R.fail("新增失败");
+    }
+
+    @Override
+    public R<LawyerChatMessage> editChatMessage(LawyerChatMessage chatMessage) {
+        log.info("LawyerChatMessageServiceImpl.editChatMessage?chatMessage={}", chatMessage);
+        boolean result = this.updateById(chatMessage);
+        if (result) {
+            return R.data(chatMessage);
+        }
+        return R.fail("修改失败");
+    }
+
+    @Override
+    public R<Boolean> deleteChatMessage(Integer id) {
+        log.info("LawyerChatMessageServiceImpl.deleteChatMessage?id={}", id);
+        boolean result = this.removeById(id);
+        if (result) {
+            return R.success("删除成功");
+        }
+        return R.fail("删除失败");
+    }
+}
+

alien-store/src/main/java/shop/alien/store/service/impl/LawyerChatSessionServiceImpl.java

@@ -0,0 +1,95 @@
+package shop.alien.store.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.LawyerChatSession;
+import shop.alien.mapper.LawyerChatSessionMapper;
+import shop.alien.store.service.LawyerChatSessionService;
+
+/**
+ * 聊天会话 服务实现类
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Slf4j
+@Transactional
+@Service
+@RequiredArgsConstructor
+public class LawyerChatSessionServiceImpl extends ServiceImpl<LawyerChatSessionMapper, LawyerChatSession> implements LawyerChatSessionService {
+
+    private final LawyerChatSessionMapper chatSessionMapper;
+
+    @Override
+    public R<IPage<LawyerChatSession>> getChatSessionList(int pageNum, int pageSize, Integer consultationOrderId,
+                                                     Integer clientUserId, Integer lawyerUserId, Integer status) {
+        log.info("LawyerChatSessionServiceImpl.getChatSessionList?pageNum={},pageSize={},consultationOrderId={},clientUserId={},lawyerUserId={},status={}",
+                pageNum, pageSize, consultationOrderId, clientUserId, lawyerUserId, status);
+        Page<LawyerChatSession> page = new Page<>(pageNum, pageSize);
+        LambdaQueryWrapper<LawyerChatSession> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(LawyerChatSession::getDeleteFlag, 0);
+        if (consultationOrderId != null) {
+            queryWrapper.eq(LawyerChatSession::getConsultationOrderId, consultationOrderId);
+        }
+        if (clientUserId != null) {
+            queryWrapper.eq(LawyerChatSession::getClientUserId, clientUserId);
+        }
+        if (lawyerUserId != null) {
+            queryWrapper.eq(LawyerChatSession::getLawyerUserId, lawyerUserId);
+        }
+        if (status != null) {
+            queryWrapper.eq(LawyerChatSession::getStatus, status);
+        }
+        queryWrapper.orderByDesc(LawyerChatSession::getLastMessageTime);
+        IPage<LawyerChatSession> pageResult = this.page(page, queryWrapper);
+        return R.data(pageResult);
+    }
+
+    @Override
+    public LawyerChatSession getByOrderId(Integer consultationOrderId) {
+        log.info("LawyerChatSessionServiceImpl.getByOrderId?consultationOrderId={}", consultationOrderId);
+        LambdaQueryWrapper<LawyerChatSession> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(LawyerChatSession::getConsultationOrderId, consultationOrderId)
+                .eq(LawyerChatSession::getDeleteFlag, 0)
+                .last("LIMIT 1");
+        return this.getOne(queryWrapper);
+    }
+
+    @Override
+    public R<LawyerChatSession> addChatSession(LawyerChatSession chatSession) {
+        log.info("LawyerChatSessionServiceImpl.addChatSession?chatSession={}", chatSession);
+        boolean result = this.save(chatSession);
+        if (result) {
+            return R.data(chatSession);
+        }
+        return R.fail("新增失败");
+    }
+
+    @Override
+    public R<LawyerChatSession> editChatSession(LawyerChatSession chatSession) {
+        log.info("LawyerChatSessionServiceImpl.editChatSession?chatSession={}", chatSession);
+        boolean result = this.updateById(chatSession);
+        if (result) {
+            return R.data(chatSession);
+        }
+        return R.fail("修改失败");
+    }
+
+    @Override
+    public R<Boolean> deleteChatSession(Integer id) {
+        log.info("LawyerChatSessionServiceImpl.deleteChatSession?id={}", id);
+        boolean result = this.removeById(id);
+        if (result) {
+            return R.success("删除成功");
+        }
+        return R.fail("删除失败");
+    }
+}
+

alien-store/src/main/java/shop/alien/store/service/impl/LawyerCommonQuestionServiceImpl.java

@@ -0,0 +1,99 @@
+package shop.alien.store.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.util.StringUtils;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.LawyerCommonQuestion;
+import shop.alien.mapper.LawyerCommonQuestionMapper;
+import shop.alien.store.service.LawyerCommonQuestionService;
+
+import java.util.List;
+
+/**
+ * 常见问题 服务实现类
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Slf4j
+@Transactional
+@Service
+@RequiredArgsConstructor
+public class LawyerCommonQuestionServiceImpl extends ServiceImpl<LawyerCommonQuestionMapper, LawyerCommonQuestion> implements LawyerCommonQuestionService {
+
+    private final LawyerCommonQuestionMapper commonQuestionMapper;
+
+    @Override
+    public R<IPage<LawyerCommonQuestion>> getCommonQuestionList(int pageNum, int pageSize, String questionText,
+                                                           Integer categoryType, Integer problemScenarId, Integer status) {
+        log.info("LawyerCommonQuestionServiceImpl.getCommonQuestionList?pageNum={},pageSize={},questionText={},categoryType={},problemScenarId={},status={}",
+                pageNum, pageSize, questionText, categoryType, problemScenarId, status);
+        Page<LawyerCommonQuestion> page = new Page<>(pageNum, pageSize);
+        LambdaQueryWrapper<LawyerCommonQuestion> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(LawyerCommonQuestion::getDeleteFlag, 0);
+        if (StringUtils.hasText(questionText)) {
+            queryWrapper.like(LawyerCommonQuestion::getQuestionText, questionText);
+        }
+        if (categoryType != null) {
+            queryWrapper.eq(LawyerCommonQuestion::getCategoryType, categoryType);
+        }
+        if (problemScenarId != null) {
+            queryWrapper.eq(LawyerCommonQuestion::getProblemScenarId, problemScenarId);
+        }
+        if (status != null) {
+            queryWrapper.eq(LawyerCommonQuestion::getStatus, status);
+        }
+        queryWrapper.orderByAsc(LawyerCommonQuestion::getSortOrder);
+        IPage<LawyerCommonQuestion> pageResult = this.page(page, queryWrapper);
+        return R.data(pageResult);
+    }
+
+    @Override
+    public List<LawyerCommonQuestion> getListByCategoryType(Integer categoryType) {
+        log.info("LawyerCommonQuestionServiceImpl.getListByCategoryType?categoryType={}", categoryType);
+        LambdaQueryWrapper<LawyerCommonQuestion> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(LawyerCommonQuestion::getCategoryType, categoryType)
+                .eq(LawyerCommonQuestion::getDeleteFlag, 0)
+                .eq(LawyerCommonQuestion::getStatus, 1)
+                .orderByAsc(LawyerCommonQuestion::getSortOrder);
+        return this.list(queryWrapper);
+    }
+
+    @Override
+    public R<LawyerCommonQuestion> addCommonQuestion(LawyerCommonQuestion commonQuestion) {
+        log.info("LawyerCommonQuestionServiceImpl.addCommonQuestion?commonQuestion={}", commonQuestion);
+        boolean result = this.save(commonQuestion);
+        if (result) {
+            return R.data(commonQuestion);
+        }
+        return R.fail("新增失败");
+    }
+
+    @Override
+    public R<LawyerCommonQuestion> editCommonQuestion(LawyerCommonQuestion commonQuestion) {
+        log.info("LawyerCommonQuestionServiceImpl.editCommonQuestion?commonQuestion={}", commonQuestion);
+        boolean result = this.updateById(commonQuestion);
+        if (result) {
+            return R.data(commonQuestion);
+        }
+        return R.fail("修改失败");
+    }
+
+    @Override
+    public R<Boolean> deleteCommonQuestion(Integer id) {
+        log.info("LawyerCommonQuestionServiceImpl.deleteCommonQuestion?id={}", id);
+        boolean result = this.removeById(id);
+        if (result) {
+            return R.success("删除成功");
+        }
+        return R.fail("删除失败");
+    }
+}
+

alien-store/src/main/java/shop/alien/store/service/impl/LawyerConsultationOrderServiceImpl.java

@@ -0,0 +1,86 @@
+package shop.alien.store.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.util.StringUtils;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.LawyerConsultationOrder;
+import shop.alien.mapper.LawyerConsultationOrderMapper;
+import shop.alien.store.service.LawyerConsultationOrderService;
+
+/**
+ * 咨询订单 服务实现类
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Slf4j
+@Transactional
+@Service
+@RequiredArgsConstructor
+public class LawyerConsultationOrderServiceImpl extends ServiceImpl<LawyerConsultationOrderMapper, LawyerConsultationOrder> implements LawyerConsultationOrderService {
+
+    private final LawyerConsultationOrderMapper consultationOrderMapper;
+
+    @Override
+    public R<IPage<LawyerConsultationOrder>> getConsultationOrderList(int pageNum, int pageSize, String orderNumber,
+                                                                 Integer clientUserId, Integer lawyerUserId, Integer orderStatus) {
+        log.info("LawyerConsultationOrderServiceImpl.getConsultationOrderList?pageNum={},pageSize={},orderNumber={},clientUserId={},lawyerUserId={},orderStatus={}",
+                pageNum, pageSize, orderNumber, clientUserId, lawyerUserId, orderStatus);
+        Page<LawyerConsultationOrder> page = new Page<>(pageNum, pageSize);
+        LambdaQueryWrapper<LawyerConsultationOrder> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(LawyerConsultationOrder::getDeleteFlag, 0);
+        if (StringUtils.hasText(orderNumber)) {
+            queryWrapper.eq(LawyerConsultationOrder::getOrderNumber, orderNumber);
+        }
+        if (clientUserId != null) {
+            queryWrapper.eq(LawyerConsultationOrder::getClientUserId, clientUserId);
+        }
+        if (lawyerUserId != null) {
+            queryWrapper.eq(LawyerConsultationOrder::getLawyerUserId, lawyerUserId);
+        }
+        if (orderStatus != null) {
+            queryWrapper.eq(LawyerConsultationOrder::getOrderStatus, orderStatus);
+        }
+        queryWrapper.orderByDesc(LawyerConsultationOrder::getCreatedTime);
+        IPage<LawyerConsultationOrder> pageResult = this.page(page, queryWrapper);
+        return R.data(pageResult);
+    }
+
+    @Override
+    public R<LawyerConsultationOrder> addConsultationOrder(LawyerConsultationOrder consultationOrder) {
+        log.info("LawyerConsultationOrderServiceImpl.addConsultationOrder?consultationOrder={}", consultationOrder);
+        boolean result = this.save(consultationOrder);
+        if (result) {
+            return R.data(consultationOrder);
+        }
+        return R.fail("新增失败");
+    }
+
+    @Override
+    public R<LawyerConsultationOrder> editConsultationOrder(LawyerConsultationOrder consultationOrder) {
+        log.info("LawyerConsultationOrderServiceImpl.editConsultationOrder?consultationOrder={}", consultationOrder);
+        boolean result = this.updateById(consultationOrder);
+        if (result) {
+            return R.data(consultationOrder);
+        }
+        return R.fail("修改失败");
+    }
+
+    @Override
+    public R<Boolean> deleteConsultationOrder(Integer id) {
+        log.info("LawyerConsultationOrderServiceImpl.deleteConsultationOrder?id={}", id);
+        boolean result = this.removeById(id);
+        if (result) {
+            return R.success("删除成功");
+        }
+        return R.fail("删除失败");
+    }
+}
+

alien-store/src/main/java/shop/alien/store/service/impl/LawyerConsultationReviewServiceImpl.java

@@ -0,0 +1,94 @@
+package shop.alien.store.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.LawyerConsultationReview;
+import shop.alien.mapper.LawyerConsultationReviewMapper;
+import shop.alien.store.service.LawyerConsultationReviewService;
+
+import java.util.List;
+
+/**
+ * 咨询评价 服务实现类
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Slf4j
+@Transactional
+@Service
+@RequiredArgsConstructor
+public class LawyerConsultationReviewServiceImpl extends ServiceImpl<LawyerConsultationReviewMapper, LawyerConsultationReview> implements LawyerConsultationReviewService {
+
+    private final LawyerConsultationReviewMapper consultationReviewMapper;
+
+    @Override
+    public R<IPage<LawyerConsultationReview>> getConsultationReviewList(int pageNum, int pageSize, Integer consultationOrderId,
+                                                                  Integer lawyerUserId, Integer clientUserId) {
+        log.info("LawyerConsultationReviewServiceImpl.getConsultationReviewList?pageNum={},pageSize={},consultationOrderId={},lawyerUserId={},clientUserId={}",
+                pageNum, pageSize, consultationOrderId, lawyerUserId, clientUserId);
+        Page<LawyerConsultationReview> page = new Page<>(pageNum, pageSize);
+        LambdaQueryWrapper<LawyerConsultationReview> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(LawyerConsultationReview::getDeleteFlag, 0);
+        if (consultationOrderId != null) {
+            queryWrapper.eq(LawyerConsultationReview::getConsultationOrderId, consultationOrderId);
+        }
+        if (lawyerUserId != null) {
+            queryWrapper.eq(LawyerConsultationReview::getLawyerUserId, lawyerUserId);
+        }
+        if (clientUserId != null) {
+            queryWrapper.eq(LawyerConsultationReview::getClientUserId, clientUserId);
+        }
+        queryWrapper.orderByDesc(LawyerConsultationReview::getCreatedTime);
+        IPage<LawyerConsultationReview> pageResult = this.page(page, queryWrapper);
+        return R.data(pageResult);
+    }
+
+    @Override
+    public List<LawyerConsultationReview> getListByLawyerId(Integer lawyerUserId) {
+        log.info("LawyerConsultationReviewServiceImpl.getListByLawyerId?lawyerUserId={}", lawyerUserId);
+        LambdaQueryWrapper<LawyerConsultationReview> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(LawyerConsultationReview::getLawyerUserId, lawyerUserId)
+                .eq(LawyerConsultationReview::getDeleteFlag, 0)
+                .orderByDesc(LawyerConsultationReview::getCreatedTime);
+        return this.list(queryWrapper);
+    }
+
+    @Override
+    public R<LawyerConsultationReview> addConsultationReview(LawyerConsultationReview consultationReview) {
+        log.info("LawyerConsultationReviewServiceImpl.addConsultationReview?consultationReview={}", consultationReview);
+        boolean result = this.save(consultationReview);
+        if (result) {
+            return R.data(consultationReview);
+        }
+        return R.fail("新增失败");
+    }
+
+    @Override
+    public R<LawyerConsultationReview> editConsultationReview(LawyerConsultationReview consultationReview) {
+        log.info("LawyerConsultationReviewServiceImpl.editConsultationReview?consultationReview={}", consultationReview);
+        boolean result = this.updateById(consultationReview);
+        if (result) {
+            return R.data(consultationReview);
+        }
+        return R.fail("修改失败");
+    }
+
+    @Override
+    public R<Boolean> deleteConsultationReview(Integer id) {
+        log.info("LawyerConsultationReviewServiceImpl.deleteConsultationReview?id={}", id);
+        boolean result = this.removeById(id);
+        if (result) {
+            return R.success("删除成功");
+        }
+        return R.fail("删除失败");
+    }
+}
+

alien-store/src/main/java/shop/alien/store/service/impl/LawyerImgServiceImpl.java

@@ -0,0 +1,140 @@
+package shop.alien.store.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import shop.alien.entity.store.LawyerImg;
+import shop.alien.entity.store.vo.LawyerImgTypeVo;
+import shop.alien.mapper.LawyerImgMapper;
+import shop.alien.store.service.LawyerImgService;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+/**
+ * 律师图片 服务实现类
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Slf4j
+@Transactional
+@Service
+@RequiredArgsConstructor
+public class LawyerImgServiceImpl extends ServiceImpl<LawyerImgMapper, LawyerImg> implements LawyerImgService {
+
+    private final LawyerImgMapper lawyerImgMapper;
+
+    /**
+     * 获取律师图片
+     *
+     * @param lawyerId 律师ID
+     * @param imgType  图片类型, 0:其他, 1:头像, 2:执业证照片, 3:身份证正面, 4:身份证反面, 5:案例图片, 6:相册图片, 7:资质证书, 8:荣誉证书, 9:工作照片
+     * @return list
+     */
+    @Override
+    public List<LawyerImg> getLawyerImg(Integer lawyerId, Integer imgType) {
+        log.info("LawyerImgServiceImpl.getLawyerImg?lawyerId={}&imgType={}", lawyerId, imgType);
+        LambdaQueryWrapper<LawyerImg> lambdaQueryWrapper = new LambdaQueryWrapper<>();
+        lambdaQueryWrapper.eq(LawyerImg::getLawyerId, lawyerId)
+                .eq(LawyerImg::getImgType, imgType)
+                .orderByAsc(LawyerImg::getImgSort);
+        return this.list(lambdaQueryWrapper);
+    }
+
+    /**
+     * 获取所有图片类型和数量
+     *
+     * @param lawyerId 律师ID
+     * @return LawyerImgTypeVo
+     */
+    @Override
+    public List<LawyerImgTypeVo> getLawyerImgTypeCount(Integer lawyerId) {
+        log.info("LawyerImgServiceImpl.getLawyerImgTypeCount?lawyerId={}", lawyerId);
+        List<LawyerImgTypeVo> lawyerImgTypeVoList = lawyerImgMapper.getLawyerImgTypeCount(lawyerId);
+        for (LawyerImgTypeVo lawyerImgTypeVo : lawyerImgTypeVoList) {
+            //图片类型, 0:其他, 1:头像, 2:执业证照片, 3:身份证正面, 4:身份证反面, 5:案例图片, 6:相册图片, 7:资质证书, 8:荣誉证书, 9:工作照片
+            switch (lawyerImgTypeVo.getImgType()) {
+                case 0:
+                    lawyerImgTypeVo.setImgTypeStr("其他");
+                    break;
+                case 1:
+                    lawyerImgTypeVo.setImgTypeStr("头像");
+                    break;
+                case 2:
+                    lawyerImgTypeVo.setImgTypeStr("执业证照片");
+                    break;
+                case 3:
+                    lawyerImgTypeVo.setImgTypeStr("身份证正面");
+                    break;
+                case 4:
+                    lawyerImgTypeVo.setImgTypeStr("身份证反面");
+                    break;
+                case 5:
+                    lawyerImgTypeVo.setImgTypeStr("案例图片");
+                    break;
+                case 6:
+                    lawyerImgTypeVo.setImgTypeStr("相册图片");
+                    break;
+                case 7:
+                    lawyerImgTypeVo.setImgTypeStr("资质证书");
+                    break;
+                case 8:
+                    lawyerImgTypeVo.setImgTypeStr("荣誉证书");
+                    break;
+                case 9:
+                    lawyerImgTypeVo.setImgTypeStr("工作照片");
+                    break;
+            }
+        }
+        return lawyerImgTypeVoList.stream().sorted(Comparator.comparing(LawyerImgTypeVo::getImgType)).collect(Collectors.toList());
+    }
+
+    @Override
+    public List<String> getUrl(String id, Integer imgType) {
+        log.info("LawyerImgServiceImpl.getUrl?id={}&imgType={}", id, imgType);
+        QueryWrapper<LawyerImg> qw = new QueryWrapper<>();
+        qw.eq(Objects.nonNull(id), "lawyer_id", id)
+                .eq(Objects.nonNull(imgType), "img_type", imgType);
+        List<LawyerImg> resDb = lawyerImgMapper.selectList(qw);
+        return resDb.stream().map(LawyerImg::getImgUrl).collect(Collectors.toList());
+    }
+
+    /**
+     * 通过businessId获取图片
+     *
+     * @param lawyerId  律师ID
+     * @param imgType   图片类型
+     * @param businessId 业务ID
+     * @return list
+     */
+    @Override
+    public List<LawyerImg> getByBusinessId(Integer lawyerId, Integer imgType, Integer businessId) {
+        log.info("LawyerImgServiceImpl.getByBusinessId?lawyerId={}&imgType={}&businessId={}", lawyerId, imgType, businessId);
+        LambdaQueryWrapper<LawyerImg> lambdaQueryWrapper = new LambdaQueryWrapper<>();
+        lambdaQueryWrapper.eq(LawyerImg::getLawyerId, lawyerId)
+                .eq(LawyerImg::getImgType, imgType)
+                .eq(LawyerImg::getBusinessId, businessId)
+                .orderByAsc(LawyerImg::getImgSort);
+        return this.list(lambdaQueryWrapper);
+    }
+
+    @Override
+    public int saveOrUpdateImg(Integer lawyerId, Integer imgType) {
+        log.info("LawyerImgServiceImpl.saveOrUpdateImg?lawyerId={}&imgType={}", lawyerId, imgType);
+        int result = 0;
+        if (lawyerId != null && lawyerId > 0 && imgType != null) {
+            result = lawyerImgMapper.delete(new LambdaQueryWrapper<LawyerImg>()
+                    .eq(LawyerImg::getLawyerId, lawyerId)
+                    .eq(LawyerImg::getImgType, imgType));
+        }
+        return result;
+    }
+}
+

alien-store/src/main/java/shop/alien/store/service/impl/LawyerLegalProblemScenarioServiceImpl.java

@@ -0,0 +1,115 @@
+package shop.alien.store.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.util.StringUtils;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.LawyerLegalProblemScenario;
+import shop.alien.mapper.LawyerLegalProblemScenarioMapper;
+import shop.alien.store.service.LawyerLegalProblemScenarioService;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * 法律问题场景 服务实现类
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Slf4j
+@Transactional
+@Service
+@RequiredArgsConstructor
+public class LawyerLegalProblemScenarioServiceImpl extends ServiceImpl<LawyerLegalProblemScenarioMapper, LawyerLegalProblemScenario> implements LawyerLegalProblemScenarioService {
+
+    private final LawyerLegalProblemScenarioMapper lawyerLegalProblemScenarioMapper;
+
+    @Override
+    public R<IPage<LawyerLegalProblemScenario>> getLawyerLegalProblemScenarioList(int pageNum, int pageSize, String name, String code, Integer status) {
+        log.info("LawyerLegalProblemScenarioServiceImpl.getLawyerLegalProblemScenarioList?pageNum={},pageSize={},name={},code={},status={}", pageNum, pageSize, name, code, status);
+        Page<LawyerLegalProblemScenario> page = new Page<>(pageNum, pageSize);
+        LambdaQueryWrapper<LawyerLegalProblemScenario> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(LawyerLegalProblemScenario::getDeleteFlag, 0);
+        if (StringUtils.hasText(name)) {
+            queryWrapper.like(LawyerLegalProblemScenario::getName, name);
+        }
+        if (StringUtils.hasText(code)) {
+            queryWrapper.eq(LawyerLegalProblemScenario::getCode, code);
+        }
+        if (status != null) {
+            queryWrapper.eq(LawyerLegalProblemScenario::getStatus, status);
+        }
+        queryWrapper.orderByAsc(LawyerLegalProblemScenario::getSortOrder);
+        IPage<LawyerLegalProblemScenario> pageResult = this.page(page, queryWrapper);
+        return R.data(pageResult);
+    }
+
+    @Override
+    public List<LawyerLegalProblemScenario> getListByParentId(String parentId) {
+        log.info("LawyerLegalProblemScenarioServiceImpl.getListByParentId?parentId={}", parentId);
+        LambdaQueryWrapper<LawyerLegalProblemScenario> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(LawyerLegalProblemScenario::getDeleteFlag, 0);
+        queryWrapper.eq(LawyerLegalProblemScenario::getStatus, 1);
+        if (parentId == null) {
+            queryWrapper.isNull(LawyerLegalProblemScenario::getParentId);
+        } else {
+            queryWrapper.eq(LawyerLegalProblemScenario::getParentId, parentId);
+        }
+        queryWrapper.orderByAsc(LawyerLegalProblemScenario::getSortOrder);
+        return this.list(queryWrapper);
+    }
+
+    @Override
+    public List<LawyerLegalProblemScenario> getListByParentCode(String parentCode) {
+        log.info("LawyerLegalProblemScenarioServiceImpl.getListByParentCode?parentCode={}", parentCode);
+        LambdaQueryWrapper<LawyerLegalProblemScenario> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(LawyerLegalProblemScenario::getDeleteFlag, 0);
+        queryWrapper.eq(LawyerLegalProblemScenario::getStatus, 1);
+        if (parentCode == null) {
+            queryWrapper.isNull(LawyerLegalProblemScenario::getParentCode);
+        } else {
+            queryWrapper.eq(LawyerLegalProblemScenario::getParentCode, parentCode);
+        }
+        queryWrapper.orderByAsc(LawyerLegalProblemScenario::getSortOrder);
+        return this.list(queryWrapper);
+    }
+
+    @Override
+    public R<LawyerLegalProblemScenario> addLawyerLegalProblemScenario(LawyerLegalProblemScenario LawyerLegalProblemScenario) {
+        log.info("LawyerLegalProblemScenarioServiceImpl.addLawyerLegalProblemScenario?LawyerLegalProblemScenario={}", LawyerLegalProblemScenario);
+        boolean result = this.save(LawyerLegalProblemScenario);
+        if (result) {
+            return R.data(LawyerLegalProblemScenario);
+        }
+        return R.fail("新增失败");
+    }
+
+    @Override
+    public R<LawyerLegalProblemScenario> editLawyerLegalProblemScenario(LawyerLegalProblemScenario LawyerLegalProblemScenario) {
+        log.info("LawyerLegalProblemScenarioServiceImpl.editLawyerLegalProblemScenario?LawyerLegalProblemScenario={}", LawyerLegalProblemScenario);
+        boolean result = this.updateById(LawyerLegalProblemScenario);
+        if (result) {
+            return R.data(LawyerLegalProblemScenario);
+        }
+        return R.fail("修改失败");
+    }
+
+    @Override
+    public R<Boolean> deleteLawyerLegalProblemScenario(Integer id) {
+        log.info("LawyerLegalProblemScenarioServiceImpl.deleteLawyerLegalProblemScenario?id={}", id);
+        boolean result = this.removeById(id);
+        if (result) {
+            return R.success("删除成功");
+        }
+        return R.fail("删除失败");
+    }
+
+}
+

alien-store/src/main/java/shop/alien/store/service/impl/LawyerPaymentTransactionServiceImpl.java

@@ -0,0 +1,82 @@
+package shop.alien.store.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.LawyerPaymentTransaction;
+import shop.alien.mapper.LawyerPaymentTransactionMapper;
+import shop.alien.store.service.LawyerPaymentTransactionService;
+
+/**
+ * 支付交易 服务实现类
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Slf4j
+@Transactional
+@Service
+@RequiredArgsConstructor
+public class LawyerPaymentTransactionServiceImpl extends ServiceImpl<LawyerPaymentTransactionMapper, LawyerPaymentTransaction> implements LawyerPaymentTransactionService {
+
+    private final LawyerPaymentTransactionMapper paymentTransactionMapper;
+
+    @Override
+    public R<IPage<LawyerPaymentTransaction>> getPaymentTransactionList(int pageNum, int pageSize, Integer consultationOrderId,
+                                                                   Integer clientUserId, Integer transactionStatus) {
+        log.info("LawyerPaymentTransactionServiceImpl.getPaymentTransactionList?pageNum={},pageSize={},consultationOrderId={},clientUserId={},transactionStatus={}",
+                pageNum, pageSize, consultationOrderId, clientUserId, transactionStatus);
+        Page<LawyerPaymentTransaction> page = new Page<>(pageNum, pageSize);
+        LambdaQueryWrapper<LawyerPaymentTransaction> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(LawyerPaymentTransaction::getDeleteFlag, 0);
+        if (consultationOrderId != null) {
+            queryWrapper.eq(LawyerPaymentTransaction::getConsultationOrderId, consultationOrderId);
+        }
+        if (clientUserId != null) {
+            queryWrapper.eq(LawyerPaymentTransaction::getClientUserId, clientUserId);
+        }
+        if (transactionStatus != null) {
+            queryWrapper.eq(LawyerPaymentTransaction::getTransactionStatus, transactionStatus);
+        }
+        queryWrapper.orderByDesc(LawyerPaymentTransaction::getTransactionTime);
+        IPage<LawyerPaymentTransaction> pageResult = this.page(page, queryWrapper);
+        return R.data(pageResult);
+    }
+
+    @Override
+    public R<LawyerPaymentTransaction> addPaymentTransaction(LawyerPaymentTransaction paymentTransaction) {
+        log.info("LawyerPaymentTransactionServiceImpl.addPaymentTransaction?paymentTransaction={}", paymentTransaction);
+        boolean result = this.save(paymentTransaction);
+        if (result) {
+            return R.data(paymentTransaction);
+        }
+        return R.fail("新增失败");
+    }
+
+    @Override
+    public R<LawyerPaymentTransaction> editPaymentTransaction(LawyerPaymentTransaction paymentTransaction) {
+        log.info("LawyerPaymentTransactionServiceImpl.editPaymentTransaction?paymentTransaction={}", paymentTransaction);
+        boolean result = this.updateById(paymentTransaction);
+        if (result) {
+            return R.data(paymentTransaction);
+        }
+        return R.fail("修改失败");
+    }
+
+    @Override
+    public R<Boolean> deletePaymentTransaction(Integer id) {
+        log.info("LawyerPaymentTransactionServiceImpl.deletePaymentTransaction?id={}", id);
+        boolean result = this.removeById(id);
+        if (result) {
+            return R.success("删除成功");
+        }
+        return R.fail("删除失败");
+    }
+}
+

alien-store/src/main/java/shop/alien/store/service/impl/LawyerServiceAreaServiceImpl.java

@@ -0,0 +1,95 @@
+package shop.alien.store.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.LawyerServiceArea;
+import shop.alien.mapper.LawyerServiceAreaMapper;
+import shop.alien.store.service.LawyerServiceAreaService;
+
+import java.util.List;
+
+/**
+ * 律师服务领域关联 服务实现类
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Slf4j
+@Transactional
+@Service
+@RequiredArgsConstructor
+public class LawyerServiceAreaServiceImpl extends ServiceImpl<LawyerServiceAreaMapper, LawyerServiceArea> implements LawyerServiceAreaService {
+
+    private final LawyerServiceAreaMapper lawyerServiceAreaMapper;
+
+    @Override
+    public R<IPage<LawyerServiceArea>> getLawyerServiceAreaList(int pageNum, int pageSize, Integer lawyerUserId,
+                                                                 Integer problemScenarId, Integer status) {
+        log.info("LawyerServiceAreaServiceImpl.getLawyerServiceAreaList?pageNum={},pageSize={},lawyerUserId={},problemScenarId={},status={}",
+                pageNum, pageSize, lawyerUserId, problemScenarId, status);
+        Page<LawyerServiceArea> page = new Page<>(pageNum, pageSize);
+        LambdaQueryWrapper<LawyerServiceArea> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(LawyerServiceArea::getDeleteFlag, 0);
+        if (lawyerUserId != null) {
+            queryWrapper.eq(LawyerServiceArea::getLawyerUserId, lawyerUserId);
+        }
+        if (problemScenarId != null) {
+            queryWrapper.eq(LawyerServiceArea::getProblemScenarId, problemScenarId);
+        }
+        if (status != null) {
+            queryWrapper.eq(LawyerServiceArea::getStatus, status);
+        }
+        queryWrapper.orderByAsc(LawyerServiceArea::getSortOrder);
+        IPage<LawyerServiceArea> pageResult = this.page(page, queryWrapper);
+        return R.data(pageResult);
+    }
+
+    @Override
+    public List<LawyerServiceArea> getListByLawyerId(Integer lawyerUserId) {
+        log.info("LawyerServiceAreaServiceImpl.getListByLawyerId?lawyerUserId={}", lawyerUserId);
+        LambdaQueryWrapper<LawyerServiceArea> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(LawyerServiceArea::getLawyerUserId, lawyerUserId)
+                .eq(LawyerServiceArea::getDeleteFlag, 0)
+                .eq(LawyerServiceArea::getStatus, 1)
+                .orderByAsc(LawyerServiceArea::getSortOrder);
+        return this.list(queryWrapper);
+    }
+
+    @Override
+    public R<LawyerServiceArea> addLawyerServiceArea(LawyerServiceArea lawyerServiceArea) {
+        log.info("LawyerServiceAreaServiceImpl.addLawyerServiceArea?lawyerServiceArea={}", lawyerServiceArea);
+        boolean result = this.save(lawyerServiceArea);
+        if (result) {
+            return R.data(lawyerServiceArea);
+        }
+        return R.fail("新增失败");
+    }
+
+    @Override
+    public R<LawyerServiceArea> editLawyerServiceArea(LawyerServiceArea lawyerServiceArea) {
+        log.info("LawyerServiceAreaServiceImpl.editLawyerServiceArea?lawyerServiceArea={}", lawyerServiceArea);
+        boolean result = this.updateById(lawyerServiceArea);
+        if (result) {
+            return R.data(lawyerServiceArea);
+        }
+        return R.fail("修改失败");
+    }
+
+    @Override
+    public R<Boolean> deleteLawyerServiceArea(Integer id) {
+        log.info("LawyerServiceAreaServiceImpl.deleteLawyerServiceArea?id={}", id);
+        boolean result = this.removeById(id);
+        if (result) {
+            return R.success("删除成功");
+        }
+        return R.fail("删除失败");
+    }
+}
+

alien-store/src/main/java/shop/alien/store/service/impl/LawyerUserSearchHistoryServiceImpl.java

@@ -0,0 +1,94 @@
+package shop.alien.store.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.LawyerUserSearchHistory;
+import shop.alien.mapper.LawyerUserSearchHistoryMapper;
+import shop.alien.store.service.LawyerUserSearchHistoryService;
+
+import java.util.List;
+
+/**
+ * 用户搜索历史 服务实现类
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Slf4j
+@Transactional
+@Service
+@RequiredArgsConstructor
+public class LawyerUserSearchHistoryServiceImpl extends ServiceImpl<LawyerUserSearchHistoryMapper, LawyerUserSearchHistory> implements LawyerUserSearchHistoryService {
+
+    private final LawyerUserSearchHistoryMapper userSearchHistoryMapper;
+
+    @Override
+    public R<IPage<LawyerUserSearchHistory>> getUserSearchHistoryList(int pageNum, int pageSize, Integer clientUserId, Integer searchType) {
+        log.info("LawyerUserSearchHistoryServiceImpl.getUserSearchHistoryList?pageNum={},pageSize={},clientUserId={},searchType={}",
+                pageNum, pageSize, clientUserId, searchType);
+        Page<LawyerUserSearchHistory> page = new Page<>(pageNum, pageSize);
+        LambdaQueryWrapper<LawyerUserSearchHistory> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(LawyerUserSearchHistory::getDeleteFlag, 0);
+        if (clientUserId != null) {
+            queryWrapper.eq(LawyerUserSearchHistory::getClientUserId, clientUserId);
+        }
+        if (searchType != null) {
+            queryWrapper.eq(LawyerUserSearchHistory::getSearchType, searchType);
+        }
+        queryWrapper.orderByDesc(LawyerUserSearchHistory::getSearchTime);
+        IPage<LawyerUserSearchHistory> pageResult = this.page(page, queryWrapper);
+        return R.data(pageResult);
+    }
+
+    @Override
+    public List<LawyerUserSearchHistory> getListByUserId(Integer clientUserId) {
+        log.info("LawyerUserSearchHistoryServiceImpl.getListByUserId?clientUserId={}", clientUserId);
+        LambdaQueryWrapper<LawyerUserSearchHistory> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(LawyerUserSearchHistory::getClientUserId, clientUserId)
+                .eq(LawyerUserSearchHistory::getDeleteFlag, 0)
+                .orderByDesc(LawyerUserSearchHistory::getSearchTime)
+                .last("LIMIT 20");
+        return this.list(queryWrapper);
+    }
+
+    @Override
+    public R<LawyerUserSearchHistory> addUserSearchHistory(LawyerUserSearchHistory userSearchHistory) {
+        log.info("LawyerUserSearchHistoryServiceImpl.addUserSearchHistory?userSearchHistory={}", userSearchHistory);
+        boolean result = this.save(userSearchHistory);
+        if (result) {
+            return R.data(userSearchHistory);
+        }
+        return R.fail("新增失败");
+    }
+
+    @Override
+    public R<Boolean> deleteUserSearchHistory(Integer id) {
+        log.info("LawyerUserSearchHistoryServiceImpl.deleteUserSearchHistory?id={}", id);
+        boolean result = this.removeById(id);
+        if (result) {
+            return R.success("删除成功");
+        }
+        return R.fail("删除失败");
+    }
+
+    @Override
+    public R<Boolean> clearUserSearchHistory(Integer clientUserId) {
+        log.info("LawyerUserSearchHistoryServiceImpl.clearUserSearchHistory?clientUserId={}", clientUserId);
+        LambdaQueryWrapper<LawyerUserSearchHistory> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(LawyerUserSearchHistory::getClientUserId, clientUserId)
+                .eq(LawyerUserSearchHistory::getDeleteFlag, 0);
+        boolean result = this.remove(queryWrapper);
+        if (result) {
+            return R.success("清空成功");
+        }
+        return R.fail("清空失败");
+    }
+}
+

alien-store/src/main/java/shop/alien/store/service/impl/LawyerUserServiceImpl.java

@@ -0,0 +1,81 @@
+package shop.alien.store.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.util.StringUtils;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.LawyerUser;
+import shop.alien.mapper.LawyerUserMapper;
+import shop.alien.store.service.LawyerUserService;
+
+/**
+ * 律师用户 服务实现类
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Slf4j
+@Transactional
+@Service
+@RequiredArgsConstructor
+public class LawyerUserServiceImpl extends ServiceImpl<LawyerUserMapper, LawyerUser> implements LawyerUserService {
+
+    private final LawyerUserMapper lawyerUserMapper;
+
+    @Override
+    public R<IPage<LawyerUser>> getLawyerUserList(int pageNum, int pageSize, String name, String phone, Integer status) {
+        log.info("LawyerUserServiceImpl.getLawyerUserList?pageNum={},pageSize={},name={},phone={},status={}", pageNum, pageSize, name, phone, status);
+        Page<LawyerUser> page = new Page<>(pageNum, pageSize);
+        LambdaQueryWrapper<LawyerUser> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(LawyerUser::getDeleteFlag, 0);
+        if (StringUtils.hasText(name)) {
+            queryWrapper.like(LawyerUser::getName, name);
+        }
+        if (StringUtils.hasText(phone)) {
+            queryWrapper.eq(LawyerUser::getPhone, phone);
+        }
+        if (status != null) {
+            queryWrapper.eq(LawyerUser::getStatus, status);
+        }
+        queryWrapper.orderByDesc(LawyerUser::getCreatedTime);
+        IPage<LawyerUser> pageResult = this.page(page, queryWrapper);
+        return R.data(pageResult);
+    }
+
+    @Override
+    public R<LawyerUser> addLawyerUser(LawyerUser lawyerUser) {
+        log.info("LawyerUserServiceImpl.addLawyerUser?lawyerUser={}", lawyerUser);
+        boolean result = this.save(lawyerUser);
+        if (result) {
+            return R.data(lawyerUser);
+        }
+        return R.fail("新增失败");
+    }
+
+    @Override
+    public R<LawyerUser> editLawyerUser(LawyerUser lawyerUser) {
+        log.info("LawyerUserServiceImpl.editLawyerUser?lawyerUser={}", lawyerUser);
+        boolean result = this.updateById(lawyerUser);
+        if (result) {
+            return R.data(lawyerUser);
+        }
+        return R.fail("修改失败");
+    }
+
+    @Override
+    public R<Boolean> deleteLawyerUser(Integer id) {
+        log.info("LawyerUserServiceImpl.deleteLawyerUser?id={}", id);
+        boolean result = this.removeById(id);
+        if (result) {
+            return R.success("删除成功");
+        }
+        return R.fail("删除失败");
+    }
+}
+