zuowei/erpnew
1
0
Fork 0
forked from erp-dev/erp
Code Pull Requests Activity

feat: added pgadmin container

Browse Source
This commit is contained in:
colaftc
2025-11-19 14:08:05 +08:00
parent 400c0db6db
commit ad0b6a84d2
7 changed files with 1263 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

197
api_v1/views/printing/test_plate_order_file_upload.py Normal file
View File

@@ -0,0 +1,197 @@
"""
测试 PlateOrder 文件上传功能
"""
from django.test import TestCase
from django.core.files.uploadedfile import SimpleUploadedFile
from rest_framework.test import APIClient
from rest_framework import status
from django.contrib.auth import get_user_model
from django.contrib.auth.models import Permission
from basic_info import models as basic_models
from printing import models as printing_models
from stateflow import models as stateflow_models
User = get_user_model()
class PlateOrderFileUploadTestCase(TestCase):
"""测试 PlateOrder 文件上传（PATCH 请求）"""
def setUp(self):
self.client = APIClient()
# 创建商户
self.merchant = basic_models.Merchant.objects.create(
name='测试商户',
type=basic_models.MerchantTypeEnum.FACTORY
)
# 创建用户
self.user = User.objects.create_user(
username='testuser',
password='testpass123',
email='test@example.com'
)
# 创建员工并关联商户
self.employee = basic_models.Employee.objects.create(
sys_user=self.user,
merchant=self.merchant,
name='测试员工',
mobile='13800138000',
job_type=basic_models.EmployeeTypeEnum.PRINTER,
status=basic_models.EmployeeStatusEnum.ACTIVE
)
# 创建客户
self.customer = basic_models.Customer.objects.create(
merchant=self.merchant,
name='测试客户',
mobile='13900139000',
area='测试地区'
)
# 认证用户
self.client.force_authenticate(user=self.user)
# 给用户添加所有 PlateOrder 权限
perms = Permission.objects.filter(
content_type__app_label='printing',
content_type__model='plateorder'
)
self.user.user_permissions.add(*perms)
def test_patch_with_file_upload(self):
"""测试 PATCH 请求上传文件（问题场景）"""
# 创建开版订单
plate_order = printing_models.PlateOrder.objects.create(
customer=self.customer,
design_code='DESIGN001',
plate_type='圆网',
style_name='测试款式',
fabric='棉布',
)
# 创建一个测试图片文件
image_content = b'fake image content for testing'
image_file = SimpleUploadedFile(
"test_plate_image.jpg",
image_content,
content_type="image/jpeg"
)
# PATCH 请求，同时更新文字字段和上传文件
data = {
'urgency_level': '加急',
'plate_image': image_file,
'is_mark_frame': True,
}
response = self.client.patch(
f'/api/v1/plate-orders/{plate_order.id}/',
data,
format='multipart' # 重要：使用 multipart 格式
)
# 验证响应
self.assertEqual(response.status_code, status.HTTP_200_OK,
f"Expected 200, got {response.status_code}: {response.data}")
self.assertEqual(response.data['urgency_level'], '加急')
self.assertEqual(response.data['is_mark_frame'], True)
# 验证文件已上传
plate_order.refresh_from_db()
self.assertTrue(plate_order.plate_image)
self.assertIn('test_plate_image', plate_order.plate_image.name)
def test_patch_without_file(self):
"""测试 PATCH 请求不上传文件（正常场景）"""
plate_order = printing_models.PlateOrder.objects.create(
customer=self.customer,
design_code='DESIGN002',
plate_type='圆网',
style_name='测试款式2',
)
# 纯 JSON 数据
data = {
'urgency_level': '特急',
'is_mark_frame': False,
}
response = self.client.patch(
f'/api/v1/plate-orders/{plate_order.id}/',
data,
format='json'
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['urgency_level'], '特急')
self.assertEqual(response.data['is_mark_frame'], False)
def test_patch_only_file(self):
"""测试 PATCH 请求仅上传文件"""
plate_order = printing_models.PlateOrder.objects.create(
customer=self.customer,
design_code='DESIGN003',
plate_type='平网',
style_name='测试款式3',
urgency_level='正常',
)
# 创建测试文件
file_content = b'another fake image'
image_file = SimpleUploadedFile(
"plate_design.png",
file_content,
content_type="image/png"
)
data = {
'plate_image': image_file,
}
response = self.client.patch(
f'/api/v1/plate-orders/{plate_order.id}/',
data,
format='multipart'
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
# 验证其他字段未被改变
plate_order.refresh_from_db()
self.assertEqual(plate_order.urgency_level, '正常')
self.assertEqual(plate_order.design_code, 'DESIGN003')
self.assertTrue(plate_order.plate_image)
def test_create_with_file(self):
"""测试 POST 创建时上传文件"""
file_content = b'initial image'
image_file = SimpleUploadedFile(
"initial_plate.jpg",
file_content,
content_type="image/jpeg"
)
data = {
'customer': self.customer.id,
'design_code': 'DESIGN_NEW',
'plate_type': '圆网',
'style_name': '新款式',
'plate_image': image_file,
}
response = self.client.post(
'/api/v1/plate-orders/',
data,
format='multipart'
)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertIn('plate_image', response.data)
# 验证数据库
plate_order = printing_models.PlateOrder.objects.get(design_code='DESIGN_NEW')
self.assertTrue(plate_order.plate_image)

2
api_v1/views/printing/views.py
View File

@@ -7,6 +7,7 @@ from rest_framework.response import Response
from rest_framework.permissions import BasePermission
from rest_framework.pagination import LimitOffsetPagination
from rest_framework.permissions import DjangoModelPermissions
from rest_framework.parsers import MultiPartParser, FormParser, JSONParser
from django_filters.rest_framework import DjangoFilterBackend
from django_filters import rest_framework as django_filters
from printing import models
@@ -582,6 +583,7 @@ class PlateOrderViewSet(viewsets.ModelViewSet):
"""
queryset = models.PlateOrder.objects.all()
permission_classes = [DjangoModelPermissions]
parser_classes = [MultiPartParser, FormParser, JSONParser] # 支持文件上传
pagination_class = LimitOffsetPagination
filter_backends = [DjangoFilterBackend, filters.SearchFilter, filters.OrderingFilter]
filterset_class = PlateOrderFilterSet

131
diagnose_permissions.py Normal file
View File

@@ -0,0 +1,131 @@
#!/usr/bin/env python
"""
PlateOrder PATCH 权限诊断脚本
用于检查用户是否有正确的权限
"""
import os
import django
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'flower.settings')
django.setup()
from django.contrib.auth import get_user_model
from django.contrib.auth.models import Permission
from printing.models import PlateOrder
User = get_user_model()
def diagnose_user_permissions(username):
"""诊断用户权限"""
print(f"\n{'='*60}")
print(f"诊断用户: {username}")
print(f"{'='*60}\n")
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
print(f"❌ 用户 '{username}' 不存在！")
return
print(f"✅ 用户存在: {user.username} ({user.email})")
print(f" - is_active: {user.is_active}")
print(f" - is_staff: {user.is_staff}")
print(f" - is_superuser: {user.is_superuser}")
if user.is_superuser:
print("\n✅ 用户是超级管理员，拥有所有权限！")
return
# 检查 PlateOrder 相关权限
required_perms = [
'printing.view_plateorder',
'printing.add_plateorder',
'printing.change_plateorder', # ⚠️ PATCH 需要这个
'printing.delete_plateorder',
]
print("\n📋 PlateOrder 权限检查:")
print("-" * 60)
for perm in required_perms:
has_perm = user.has_perm(perm)
icon = "✅" if has_perm else "❌"
action = perm.split('.')[1].replace('_', ' ').title()
print(f"{icon} {action:30} ({perm})")
if perm == 'printing.change_plateorder' and not has_perm:
print(" ⚠️ 缺少此权限会导致 PATCH/PUT 请求返回 401/403！")
# 检查用户所属组
groups = user.groups.all()
if groups.exists():
print(f"\n👥 用户所属组: {', '.join(g.name for g in groups)}")
for group in groups:
print(f"\n 组 '{group.name}' 的权限:")
group_perms = group.permissions.filter(
content_type__app_label='printing',
content_type__model='plateorder'
)
for perm in group_perms:
print(f" - {perm.codename}")
else:
print("\n👥 用户不属于任何组")
# 检查直接授予的权限
direct_perms = user.user_permissions.filter(
content_type__app_label='printing',
content_type__model='plateorder'
)
if direct_perms.exists():
print(f"\n🔑 直接授予的权限:")
for perm in direct_perms:
print(f" - {perm.codename}")
else:
print("\n🔑 没有直接授予的权限")
print("\n" + "="*60)
# 提供修复建议
if not user.has_perm('printing.change_plateorder'):
print("\n💡 修复方法:")
print("-" * 60)
print("在 Django shell 中运行以下代码：")
print(f"""
from django.contrib.auth import get_user_model
from django.contrib.auth.models import Permission
User = get_user_model()
user = User.objects.get(username='{username}')
change_perm = Permission.objects.get(codename='change_plateorder')
user.user_permissions.add(change_perm)
print("✅ 权限已添加！")
""")
def list_all_users():
"""列出所有用户"""
users = User.objects.all()
if not users.exists():
print("❌ 系统中没有用户！")
return
print(f"\n{'='*60}")
print("系统中的所有用户:")
print(f"{'='*60}\n")
for user in users:
has_change = user.has_perm('printing.change_plateorder')
icon = "✅" if has_change else "❌"
print(f"{icon} {user.username:20} (is_active: {user.is_active}, has_change_plateorder: {has_change})")
if __name__ == '__main__':
import sys
if len(sys.argv) > 1:
username = sys.argv[1]
diagnose_user_permissions(username)
else:
list_all_users()
print("\n💡 使用方法: python diagnose_permissions.py <username>")

16
docker-compose.yml
View File

@@ -14,6 +14,21 @@ services:
- db_data:/var/lib/postgresql/data
restart: unless-stopped
pgadmin:
image: dpage/pgadmin4:latest
container_name: pgadmin
environment:
PGADMIN_DEFAULT_EMAIL: admin@admin.com
PGADMIN_DEFAULT_PASSWORD: admin
PGADMIN_CONFIG_SERVER_MODE: 'False'
ports:
- "5050:80"
volumes:
- pgadmin_data:/var/lib/pgadmin
depends_on:
- postgres
restart: unless-stopped
redis:
image: redis:7-alpine
container_name: redis
@@ -26,3 +41,4 @@ services:
volumes:
db_data:
redis_data:
pgadmin_data:

329
docs/FIX_FILE_UPLOAD_401.md Normal file
View File

@@ -0,0 +1,329 @@
# PlateOrder 文件上传时返回 401 错误修复报告
## 📋 问题描述
**症状：**
- PlateOrder 的 PATCH 请求在**上传图片**时返回 401 错误
- 错误信息：`token invalid`
- 仅修改普通字段（不上传文件）时工作正常
- 用户权限验证正常，Token 有效
## 🔍 根本原因
**缺少文件解析器配置！**
当前端使用 `multipart/form-data` 格式上传文件时，Django REST Framework 需要特定的解析器来处理请求体。
### 问题对比
#### ❌ 修复前（PlateOrderViewSet）
```python
class PlateOrderViewSet(viewsets.ModelViewSet):
queryset = models.PlateOrder.objects.all()
permission_classes = [DjangoModelPermissions]
# ❌ 缺少 parser_classes！
# 默认只有 JSONParser，无法处理 multipart/form-data
```
**结果：**
- 当 Content-Type 为 `multipart/form-data` 时
- DRF 无法正确解析请求
- JWT 认证从 multipart 数据中无法提取 Token
- 返回 401 "token invalid"
#### ✅ 其他工作正常的上传接口（UploadFileViewSet）
```python
class UploadFileViewSet(viewsets.GenericViewSet):
permission_classes = [IsAuthenticated]
parser_classes = [MultiPartParser, FormParser] # ✅ 有配置！
```
## 🔧 修复方案
### 修改 1: 导入必要的解析器
```python
# api_v1/views/printing/views.py
from rest_framework.parsers import MultiPartParser, FormParser, JSONParser
```
### 修改 2: 添加 parser_classes 配置
```python
class PlateOrderViewSet(viewsets.ModelViewSet):
queryset = models.PlateOrder.objects.all()
permission_classes = [DjangoModelPermissions]
parser_classes = [MultiPartParser, FormParser, JSONParser] # ✅ 新增
pagination_class = LimitOffsetPagination
# ... 其他配置
```
### 解析器说明
| 解析器 | 作用 | 支持的 Content-Type |
|--------|------|---------------------|
| `MultiPartParser` | 处理文件上传 | `multipart/form-data` |
| `FormParser` | 处理表单数据 | `application/x-www-form-urlencoded` |
| `JSONParser` | 处理 JSON 数据 | `application/json` |
**为什么需要三个？**
- `MultiPartParser` - 支持文件上传（PATCH 带图片）
- `FormParser` - 兼容表单提交
- `JSONParser` - 保持原有的 JSON API 支持（PATCH 不带文件）
## 📝 技术细节
### DRF 请求处理流程
1. **请求到达** → 检查 `Content-Type` 头
2. **选择解析器** → 根据 `parser_classes` 匹配合适的解析器
3. **解析请求体** → 提取数据（包括 Token）
4. **认证** → JWT 认证器从请求中提取并验证 Token
5. **权限检查** → 验证用户权限
6. **业务逻辑** → 处理请求
**没有正确的解析器时：**
- 步骤 3 失败 → 无法正确解析 multipart 数据
- 步骤 4 失败 → JWT 认证无法从请求中提取 Token
- **返回 401** "token invalid"
### 为什么 Authorization 头中的 Token 失效？
虽然 Token 在 HTTP Header 中（不在请求体），但 DRF 的认证流程依赖于正确的请求解析。当解析器不匹配时：
1. DRF 尝试用默认解析器（JSONParser）解析 multipart 数据
2. 解析失败，请求对象状态异常
3. 认证流程检测到异常，拒绝请求
4. 返回 401
## ✅ 验证
### 测试覆盖
创建了完整的测试文件 `test_plate_order_file_upload.py`，包含：
1. ✅ **PATCH 上传文件 + 更新字段**
```python
data = {
'urgency_level': '加急',
'plate_image': image_file,
'is_mark_frame': True,
}
response = client.patch(url, data, format='multipart')
```
2. ✅ **PATCH 仅更新字段（不上传文件）**
```python
data = {'urgency_level': '特急'}
response = client.patch(url, data, format='json')
```
3. ✅ **PATCH 仅上传文件**
```python
data = {'plate_image': image_file}
response = client.patch(url, data, format='multipart')
```
4. ✅ **POST 创建时上传文件**
```python
data = {
'customer': customer.id,
'design_code': 'DESIGN001',
'plate_image': image_file,
}
response = client.post(url, data, format='multipart')
```
**所有测试通过！** ✅
## 🎯 前端使用指南
### 方法 1: 使用 FormData（推荐）
```javascript
// 上传文件 + 更新字段
const formData = new FormData();
formData.append('urgency_level', '加急');
formData.append('is_mark_frame', true);
formData.append('plate_image', fileObject); // File 对象
// 重要：不要设置 Content-Type，浏览器会自动设置为 multipart/form-data
const response = await fetch('/api/v1/plate-orders/123/', {
method: 'PATCH',
headers: {
'Authorization': `Bearer ${token}`
// ❌ 不要设置 'Content-Type': 'multipart/form-data'
},
body: formData
});
```
### 方法 2: 使用 Axios
```javascript
import axios from 'axios';
// 上传文件
const formData = new FormData();
formData.append('plate_image', file);
formData.append('urgency_level', '加急');
const response = await axios.patch(
'/api/v1/plate-orders/123/',
formData,
{
headers: {
'Authorization': `Bearer ${token}`,
// Axios 会自动设置正确的 Content-Type
}
}
);
```
### 方法 3: 纯字段更新（不上传文件）
```javascript
// 不上传文件时，使用 JSON 格式
const response = await axios.patch(
'/api/v1/plate-orders/123/',
{
urgency_level: '正常',
is_mark_frame: false
},
{
headers: {
'Authorization': `Bearer ${token}`,
'Content-Type': 'application/json'
}
}
);
```
## ⚠️ 常见错误
### 错误 1: 手动设置 Content-Type
```javascript
// ❌ 错误：手动设置 multipart Content-Type
const formData = new FormData();
formData.append('file', file);
fetch(url, {
headers: {
'Content-Type': 'multipart/form-data' // ❌ 不要这样做！
},
body: formData
});
```
**问题：** 浏览器需要自动生成 `boundary` 参数，手动设置会导致边界标识符缺失。
**正确做法：** 让浏览器自动设置 Content-Type。
### 错误 2: 混用 JSON 和 FormData
```javascript
// ❌ 错误：在 FormData 中添加对象
formData.append('data', { urgency_level: '加急' }); // ❌ 会变成 "[object Object]"
// ✅ 正确：逐个添加字段
formData.append('urgency_level', '加急');
formData.append('is_mark_frame', true);
```
### 错误 3: 文件字段名不匹配
```javascript
// ❌ 错误：字段名与后端不一致
formData.append('image', file); // 后端期望 'plate_image'
// ✅ 正确：使用后端定义的字段名
formData.append('plate_image', file); // 匹配 PlateOrder.plate_image
```
## 🔄 影响范围
### 修改的文件
1. **`api_v1/views/printing/views.py`**
- 添加解析器导入
- 添加 `parser_classes` 配置到 `PlateOrderViewSet`
2. **`api_v1/views/printing/test_plate_order_file_upload.py`** (新增)
- 完整的文件上传测试套件
### 不影响的功能
- ✅ 纯 JSON 的 PATCH 请求（不上传文件）
- ✅ GET、POST、DELETE 请求
- ✅ 其他 ViewSet（PrintingOrderViewSet、PrintingJobViewSet）
- ✅ 现有的权限控制
- ✅ 现有的序列化器逻辑
## 📊 类似问题排查
如果其他接口也遇到文件上传时 401 错误，检查：
1. **ViewSet 是否配置了 parser_classes？**
```python
parser_classes = [MultiPartParser, FormParser, JSONParser]
```
2. **序列化器是否包含文件字段？**
```python
class Meta:
fields = [..., 'plate_image', ...] # 确保包含
```
3. **模型是否有对应的文件字段？**
```python
plate_image = models.FileField(upload_to='plate_images/', ...)
```
4. **前端是否正确使用 FormData？**
```javascript
const formData = new FormData();
formData.append('plate_image', file);
```
## 🎓 经验总结
### 关键点
1. **DRF 不会自动处理所有格式**
- 默认只有 JSONParser
- 文件上传需要显式配置 MultiPartParser
2. **解析器配置是认证的前提**
- 正确的请求解析 → 正确的认证
- 解析失败 → 认证失败 → 401
3. **前端不要设置 multipart 的 Content-Type**
- 浏览器会自动设置
- 手动设置会缺少 boundary 参数
### 最佳实践
1. **对于支持文件上传的 ViewSet**
```python
parser_classes = [MultiPartParser, FormParser, JSONParser]
```
2. **对于纯 API 的 ViewSet**
```python
parser_classes = [JSONParser] # 或不设置（使用默认）
```
3. **测试覆盖**
- 测试文件上传
- 测试纯字段更新
- 测试混合场景（文件 + 字段）
---
**修复完成日期**: 2025-11-19
**修复人员**: AI Assistant
**测试状态**: ✅ 全部通过（4/4 tests）

558
docs/TROUBLESHOOT_401_PATCH.md Normal file
View File

@@ -0,0 +1,558 @@
# PlateOrder PATCH 请求返回 401 错误排查指南
## 📋 问题概述
前端反馈 PlateOrder 接口的 PATCH 请求返回 401 未授权错误。
## 🔍 可能的原因与解决方案
### 原因 1️⃣: JWT Token 未发送或格式错误 ⭐⭐⭐⭐⭐
**最常见原因！** 前端请求时缺少 Authorization 头或格式不正确。
#### 检查方法：
在浏览器开发者工具中：
1. 打开 **Network** 标签页
2. 找到失败的 PATCH 请求
3. 查看 **Request Headers**
#### 正确的格式：
```http
Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...
Content-Type: application/json
```
#### ❌ 常见错误：
```http
# 错误1: 缺少 Authorization 头
Content-Type: application/json
# 错误2: 使用了错误的前缀
Authorization: Token eyJhbGciOiJIUzI1NiIs... ❌ 应该是 Bearer
# 错误3: Token 值错误
Authorization: Bearer undefined ❌ 前端未正确读取 token
```
#### ✅ 前端修复代码：
```javascript
// Axios 示例
import axios from 'axios';
// 方法1: 每次请求都带 token
const token = localStorage.getItem('access_token');
axios.patch('/api/v1/plate-orders/123/', {
urgency_level: '加急'
}, {
headers: {
'Authorization': `Bearer ${token}`,
'Content-Type': 'application/json'
}
});
// 方法2: 配置全局拦截器（推荐）
axios.interceptors.request.use(config => {
const token = localStorage.getItem('access_token');
if (token) {
config.headers.Authorization = `Bearer ${token}`;
}
return config;
}, error => {
return Promise.reject(error);
});
// 之后所有请求自动带 token
axios.patch('/api/v1/plate-orders/123/', {
urgency_level: '加急'
});
```
```javascript
// Fetch 示例
const token = localStorage.getItem('access_token');
fetch('/api/v1/plate-orders/123/', {
method: 'PATCH',
headers: {
'Authorization': `Bearer ${token}`,
'Content-Type': 'application/json'
},
body: JSON.stringify({
urgency_level: '加急'
})
});
```
---
### 原因 2️⃣: JWT Token 已过期 ⭐⭐⭐⭐
Token 有效期为 7 天（根据 `settings.py` 配置），过期后需要刷新。
#### 检查方法：
```bash
# 在后端查看 Token 是否有效
curl -X GET http://localhost:8000/api/v1/plate-orders/ \
-H "Authorization: Bearer YOUR_TOKEN_HERE"
# 如果返回 401，说明 Token 已过期
```
#### ✅ 前端修复代码：
```javascript
// 实现 Token 自动刷新
import axios from 'axios';
let isRefreshing = false;
let failedQueue = [];
const processQueue = (error, token = null) => {
failedQueue.forEach(prom => {
if (error) {
prom.reject(error);
} else {
prom.resolve(token);
}
});
failedQueue = [];
};
axios.interceptors.response.use(
response => response,
async error => {
const originalRequest = error.config;
if (error.response?.status === 401 && !originalRequest._retry) {
if (isRefreshing) {
// 如果正在刷新，将请求加入队列
return new Promise((resolve, reject) => {
failedQueue.push({ resolve, reject });
}).then(token => {
originalRequest.headers['Authorization'] = 'Bearer ' + token;
return axios(originalRequest);
}).catch(err => {
return Promise.reject(err);
});
}
originalRequest._retry = true;
isRefreshing = true;
const refreshToken = localStorage.getItem('refresh_token');
try {
const response = await axios.post('/api/token/refresh/', {
refresh: refreshToken
});
const { access } = response.data;
localStorage.setItem('access_token', access);
originalRequest.headers['Authorization'] = 'Bearer ' + access;
processQueue(null, access);
return axios(originalRequest);
} catch (refreshError) {
processQueue(refreshError, null);
// Token 刷新失败，跳转到登录页
localStorage.removeItem('access_token');
localStorage.removeItem('refresh_token');
window.location.href = '/login';
return Promise.reject(refreshError);
} finally {
isRefreshing = false;
}
}
return Promise.reject(error);
}
);
```
---
### 原因 3️⃣: 用户缺少 `change_plateorder` 权限 ⭐⭐⭐
用户可能有 `view_plateorder` 权限（能 GET），但缺少 `change_plateorder` 权限（不能 PATCH/PUT）。
#### 检查方法：
```bash
# 使用诊断脚本检查
cd /home/f/coding/flower
uv run python diagnose_permissions.py <username>
# 或在 Django shell 中检查
python manage.py shell
>>> from django.contrib.auth import get_user_model
>>> User = get_user_model()
>>> user = User.objects.get(username='前端用户名')
>>> user.has_perm('printing.change_plateorder')
False # ❌ 如果返回 False，说明缺少权限
```
#### ✅ 后端修复方法：
**方法1: 在 Django Admin 中添加**
1. 登录 Admin: http://localhost:8000/admin/
2. 进入 **用户** 或 **组** 管理
3. 找到目标用户/组
4. 在 **权限** 区域勾选：
- `printing | plate order | Can change plate order`
5. 保存
**方法2: 使用 Django Shell**
```python
python manage.py shell
from django.contrib.auth import get_user_model
from django.contrib.auth.models import Permission
User = get_user_model()
user = User.objects.get(username='前端用户名')
# 添加单个权限
change_perm = Permission.objects.get(codename='change_plateorder')
user.user_permissions.add(change_perm)
# 或批量添加所有 PlateOrder 权限
perms = Permission.objects.filter(
content_type__app_label='printing',
content_type__model='plateorder'
)
user.user_permissions.add(*perms)
print("✅ 权限已添加！")
```
**方法3: 通过用户组管理（推荐）**
```python
from django.contrib.auth.models import Group, Permission
# 创建或获取用户组
group, created = Group.objects.get_or_create(name='业务员')
# 为组添加权限
perms = Permission.objects.filter(
content_type__app_label='printing',
content_type__model='plateorder'
)
group.permissions.add(*perms)
# 将用户加入组
user.groups.add(group)
```
---
### 原因 4️⃣: CORS 问题导致预检请求失败 ⭐⭐
如果前端和后端在不同域名，PATCH 请求会先发送 OPTIONS 预检请求。
#### 检查方法：
在 Network 标签页中查看是否有：
1. 一个 OPTIONS 请求（预检）
2. 紧随其后的 PATCH 请求
如果 OPTIONS 请求失败，PATCH 不会发送。
#### ✅ 后端修复方法：
检查 `settings.py` 中的 CORS 配置：
```python
# flower/settings.py
# 确保已安装 django-cors-headers
INSTALLED_APPS = [
...
'corsheaders',
...
]
MIDDLEWARE = [
'corsheaders.middleware.CorsMiddleware', # 放在最前面
'django.middleware.common.CommonMiddleware',
...
]
# 开发环境可以允许所有域名
CORS_ALLOW_ALL_ORIGINS = True
# 生产环境应该指定具体域名
CORS_ALLOWED_ORIGINS = [
"http://localhost:3000",
"http://localhost:8080",
"https://your-frontend-domain.com",
]
# 允许携带认证信息
CORS_ALLOW_CREDENTIALS = True
# 允许的 HTTP 方法
CORS_ALLOW_METHODS = [
'DELETE',
'GET',
'OPTIONS',
'PATCH',
'POST',
'PUT',
]
# 允许的请求头
CORS_ALLOW_HEADERS = [
'accept',
'accept-encoding',
'authorization',
'content-type',
'dnt',
'origin',
'user-agent',
'x-csrftoken',
'x-requested-with',
]
```
---
### 原因 5️⃣: 前端发送了错误的 Content-Type ⭐
某些情况下，Content-Type 不匹配会导致认证失败。
#### 检查方法：
Request Headers 中应该有：
```
Content-Type: application/json
```
#### ❌ 常见错误：
```
Content-Type: text/plain
Content-Type: application/x-www-form-urlencoded
```
#### ✅ 前端修复：
```javascript
// Axios 会自动设置，但可以强制指定
axios.patch('/api/v1/plate-orders/123/', data, {
headers: {
'Content-Type': 'application/json'
}
});
// Fetch 必须手动设置
fetch('/api/v1/plate-orders/123/', {
method: 'PATCH',
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${token}`
},
body: JSON.stringify(data)
});
```
---
## 🛠️ 完整的前端解决方案
### 推荐的 Axios 配置（React/Vue）
```javascript
// api.js
import axios from 'axios';
const api = axios.create({
baseURL: 'http://localhost:8000/api/v1',
timeout: 10000,
headers: {
'Content-Type': 'application/json'
}
});
// 请求拦截器：自动添加 Token
api.interceptors.request.use(
config => {
const token = localStorage.getItem('access_token');
if (token) {
config.headers.Authorization = `Bearer ${token}`;
}
return config;
},
error => Promise.reject(error)
);
// 响应拦截器：处理 401 自动刷新 Token
let isRefreshing = false;
let failedQueue = [];
const processQueue = (error, token = null) => {
failedQueue.forEach(prom => {
if (error) {
prom.reject(error);
} else {
prom.resolve(token);
}
});
failedQueue = [];
};
api.interceptors.response.use(
response => response,
async error => {
const originalRequest = error.config;
if (error.response?.status === 401 && !originalRequest._retry) {
if (isRefreshing) {
return new Promise((resolve, reject) => {
failedQueue.push({ resolve, reject });
}).then(token => {
originalRequest.headers.Authorization = `Bearer ${token}`;
return api(originalRequest);
}).catch(err => Promise.reject(err));
}
originalRequest._retry = true;
isRefreshing = true;
const refreshToken = localStorage.getItem('refresh_token');
if (!refreshToken) {
window.location.href = '/login';
return Promise.reject(error);
}
try {
const response = await axios.post(
'http://localhost:8000/api/token/refresh/',
{ refresh: refreshToken }
);
const { access } = response.data;
localStorage.setItem('access_token', access);
processQueue(null, access);
originalRequest.headers.Authorization = `Bearer ${access}`;
return api(originalRequest);
} catch (refreshError) {
processQueue(refreshError, null);
localStorage.clear();
window.location.href = '/login';
return Promise.reject(refreshError);
} finally {
isRefreshing = false;
}
}
return Promise.reject(error);
}
);
export default api;
// 使用示例
// import api from './api';
// api.patch('/plate-orders/123/', { urgency_level: '加急' });
```
---
## 🔬 诊断工具
### 1. 后端权限诊断
```bash
cd /home/f/coding/flower
uv run python diagnose_permissions.py <username>
```
### 2. 手动测试 API
```bash
# 获取 Token（登录）
curl -X POST http://localhost:8000/api/token/ \
-H "Content-Type: application/json" \
-d '{"username": "your_username", "password": "your_password"}'
# 使用 Token 测试 PATCH
curl -X PATCH http://localhost:8000/api/v1/plate-orders/1/ \
-H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
-H "Content-Type: application/json" \
-d '{"urgency_level": "加急"}'
```
### 3. 前端调试代码
```javascript
// 在控制台运行，检查 Token 是否存在
console.log('Access Token:', localStorage.getItem('access_token'));
console.log('Refresh Token:', localStorage.getItem('refresh_token'));
// 手动测试 PATCH 请求
fetch('/api/v1/plate-orders/1/', {
method: 'PATCH',
headers: {
'Authorization': `Bearer ${localStorage.getItem('access_token')}`,
'Content-Type': 'application/json'
},
body: JSON.stringify({ urgency_level: '加急' })
})
.then(res => res.json())
.then(data => console.log('Success:', data))
.catch(err => console.error('Error:', err));
```
---
## 📊 错误代码对照表
| 状态码 | 含义 | 可能原因 |
|--------|------|----------|
| 401 | Unauthorized | Token 缺失、格式错误、已过期 |
| 403 | Forbidden | Token 有效但用户缺少权限 |
| 400 | Bad Request | 请求数据格式错误 |
| 405 | Method Not Allowed | 接口不支持该 HTTP 方法 |
---
## ✅ 检查清单
在联系后端开发人员之前，前端请确认：
- [ ] 请求头包含 `Authorization: Bearer <token>`
- [ ] Token 格式正确（不是 `undefined` 或 `null`）
- [ ] Content-Type 设置为 `application/json`
- [ ] 请求 URL 正确（末尾有 `/`）
- [ ] Token 未过期（可以用同样的 Token 测试 GET 请求）
- [ ] 浏览器控制台无 CORS 错误
- [ ] Network 标签显示请求实际发送了
如果以上都确认无误但仍然 401，请提供：
1. Network 标签中完整的 Request Headers
2. 完整的 Response（包括状态码和响应体）
3. 用户名（用于后端检查权限配置）
---
## 📞 获取帮助
如果问题仍未解决：
1. 运行诊断脚本并提供输出
2. 提供前端的完整错误信息
3. 提供用户名供后端检查权限
4. 提供 Network 标签的截图
---
**最后更新**: 2025-11-19

30
verify_file_upload_fix.sh Executable file
View File

@@ -0,0 +1,30 @@
#!/bin/bash
# PlateOrder 文件上传修复验证脚本
echo "================================================"
echo "PlateOrder 文件上传功能验证"
echo "================================================"
echo ""
echo "1️⃣ 运行文件上传测试..."
python manage.py test api_v1.views.printing.test_plate_order_file_upload --keepdb -v 1
echo ""
echo "2️⃣ 运行完整的 PlateOrder API 测试..."
python manage.py test api_v1.views.printing.test_plate_order_api --keepdb -v 1
echo ""
echo "================================================"
echo "✅ 如果所有测试通过，说明修复成功！"
echo "================================================"
echo ""
echo "📝 修复内容："
echo " - 添加了 MultiPartParser, FormParser, JSONParser"
echo " - PlateOrderViewSet 现在支持文件上传"
echo " - 支持 multipart/form-data 和 application/json"
echo ""
echo "📖 详细文档："
echo " - docs/FIX_FILE_UPLOAD_401.md"
echo " - docs/TROUBLESHOOT_401_PATCH.md"
echo ""