814 lines
32 KiB
Python
814 lines
32 KiB
Python
#!/usr/bin/env python
|
||
# -*- coding: utf-8 -*-
|
||
"""
|
||
文章管理接口
|
||
"""
|
||
|
||
from flask import Blueprint, request, jsonify
|
||
import logging
|
||
import time
|
||
import random
|
||
from datetime import datetime
|
||
from auth_utils import require_auth, AuthUtils
|
||
from database_config import get_db_manager, format_datetime_fields
|
||
from log_utils import log_create, log_update, log_delete, log_error, log_operation
|
||
|
||
logger = logging.getLogger('article_server')
|
||
|
||
# 创建蓝图
|
||
article_bp = Blueprint('article', __name__, url_prefix='/api/articles')
|
||
|
||
@article_bp.route('/list', methods=['GET'])
|
||
@require_auth
|
||
def get_articles_list():
|
||
"""获取文章列表（聚合图片和标签）"""
|
||
client_ip = request.environ.get('HTTP_X_FORWARDED_FOR', request.environ.get('REMOTE_ADDR', '未知'))
|
||
logger.info(f"[获取文章列表] 开始处理请求, IP: {client_ip}")
|
||
|
||
try:
|
||
current_user = AuthUtils.get_current_user()
|
||
enterprise_id = current_user.get('enterprise_id')
|
||
|
||
logger.info(f"[获取文章列表] 用户信息 - 用户ID: {current_user.get('user_id')}, 企业ID: {enterprise_id}, IP: {client_ip}")
|
||
|
||
if not enterprise_id:
|
||
logger.warning(f"[获取文章列表] 无法获取企业ID, IP: {client_ip}")
|
||
return jsonify({
|
||
'code': 400,
|
||
'message': '无法获取企业ID',
|
||
'data': None
|
||
}), 400
|
||
|
||
# 获取查询参数
|
||
page = int(request.args.get('page', 1))
|
||
page_size = int(request.args.get('pageSize', 20))
|
||
keyword = request.args.get('keyword', '').strip()
|
||
product_id = request.args.get('product_id', '').strip()
|
||
status = request.args.get('status', '').strip()
|
||
|
||
logger.info(f"[获取文章列表] 查询参数: page={page}, pageSize={page_size}, keyword={keyword}, product_id={product_id}, status={status}, 企业ID: {enterprise_id}, IP: {client_ip}")
|
||
|
||
# 构建查询条件
|
||
where_conditions = ["a.enterprise_id = %s"]
|
||
params = [enterprise_id]
|
||
|
||
if keyword:
|
||
where_conditions.append("(a.title LIKE %s OR a.content LIKE %s OR a.topic LIKE %s)")
|
||
keyword_pattern = f"%{keyword}%"
|
||
params.extend([keyword_pattern, keyword_pattern, keyword_pattern])
|
||
|
||
if product_id:
|
||
where_conditions.append("a.product_id = %s")
|
||
params.append(product_id)
|
||
|
||
if status:
|
||
where_conditions.append("a.status = %s")
|
||
params.append(status)
|
||
|
||
where_clause = " AND ".join(where_conditions)
|
||
|
||
# 计算偏移量
|
||
offset = (page - 1) * page_size
|
||
|
||
db_manager = get_db_manager()
|
||
|
||
# 查询总数
|
||
count_sql = f"""
|
||
SELECT COUNT(*) as total
|
||
FROM ai_articles a
|
||
WHERE {where_clause}
|
||
"""
|
||
count_result = db_manager.execute_query(count_sql, params)
|
||
total = count_result[0]['total']
|
||
|
||
# ✅ 查询文章列表（聚合图片和标签）
|
||
sql = f"""
|
||
SELECT a.id, a.batch_id, a.enterprise_id, a.product_id, a.topic_type_id,
|
||
a.prompt_workflow_id, a.topic, a.title, a.content, a.department,
|
||
a.departmentids, a.author_id, a.author_name, a.department_id, a.department_name,
|
||
a.created_user_id, a.review_user_id, a.publish_user_id, a.status, a.channel,
|
||
a.review_comment, a.publish_time, a.publish_link, a.baijiahao_id, a.baijiahao_status,
|
||
a.word_count, a.image_count, a.coze_tag, a.created_at, a.updated_at,
|
||
p.name as product_name,
|
||
pw.prompt_workflow_name as prompt_name
|
||
FROM ai_articles a
|
||
LEFT JOIN ai_products p ON a.product_id = p.id
|
||
LEFT JOIN ai_prompt_workflow pw ON a.prompt_workflow_id = pw.id
|
||
WHERE {where_clause}
|
||
ORDER BY a.created_at DESC
|
||
LIMIT %s OFFSET %s
|
||
"""
|
||
params.extend([page_size, offset])
|
||
articles = db_manager.execute_query(sql, params)
|
||
|
||
# ✅ 聚合每篇文章的图片和标签
|
||
for article in articles:
|
||
article_id = article['id']
|
||
|
||
# 查询文章图片
|
||
images_sql = """
|
||
SELECT id, image_id, image_url, image_thumb_url, image_tag_id,
|
||
sort_order, keywords_id, keywords_name, department_id,
|
||
department_name, image_source, created_at
|
||
FROM ai_article_images
|
||
WHERE article_id = %s
|
||
ORDER BY sort_order ASC, created_at ASC
|
||
"""
|
||
article['images'] = db_manager.execute_query(images_sql, (article_id,))
|
||
|
||
# 查询文章标签
|
||
tags_sql = """
|
||
SELECT id, coze_tag, created_at
|
||
FROM ai_article_tags
|
||
WHERE article_id = %s
|
||
"""
|
||
tags_result = db_manager.execute_query(tags_sql, (article_id,))
|
||
article['tags'] = tags_result[0] if tags_result else None
|
||
|
||
# 格式化日期时间字段
|
||
articles = format_datetime_fields(articles)
|
||
|
||
logger.info(f"[获取文章列表] 查询成功, 总数: {total}, 当前页: {page}, 每页: {page_size}, 返回数量: {len(articles)}, 企业ID: {enterprise_id}, IP: {client_ip}")
|
||
|
||
return jsonify({
|
||
'code': 200,
|
||
'message': 'success',
|
||
'data': {
|
||
'total': total,
|
||
'list': articles
|
||
},
|
||
'timestamp': int(datetime.now().timestamp() * 1000)
|
||
})
|
||
|
||
except Exception as e:
|
||
logger.error(f"[获取文章列表] 处理请求时发生错误: {str(e)}", exc_info=True)
|
||
return jsonify({
|
||
'code': 500,
|
||
'message': '服务器内部错误',
|
||
'data': None
|
||
}), 500
|
||
|
||
|
||
@article_bp.route('/generate', methods=['POST'])
|
||
@require_auth
|
||
def generate_article():
|
||
"""生成文案"""
|
||
client_ip = request.environ.get('HTTP_X_FORWARDED_FOR', request.environ.get('REMOTE_ADDR', '未知'))
|
||
logger.info(f"[生成文案] 开始处理生成文案请求, IP: {client_ip}")
|
||
|
||
try:
|
||
current_user = AuthUtils.get_current_user()
|
||
enterprise_id = current_user.get('enterprise_id')
|
||
|
||
logger.info(f"[生成文案] 用户信息 - 用户ID: {current_user.get('user_id')}, 企业ID: {enterprise_id}, IP: {client_ip}")
|
||
|
||
if not enterprise_id:
|
||
logger.warning(f"[生成文案] 无法获取企业ID, IP: {client_ip}")
|
||
return jsonify({
|
||
'code': 400,
|
||
'message': '无法获取企业ID',
|
||
'data': None
|
||
}), 400
|
||
|
||
data = request.get_json()
|
||
if not data:
|
||
logger.warning(f"[生成文案] 请求参数为空, 企业ID: {enterprise_id}, IP: {client_ip}")
|
||
return jsonify({
|
||
'code': 400,
|
||
'message': '请求参数错误',
|
||
'data': None
|
||
}), 400
|
||
|
||
logger.info(f"[生成文案] 收到生成请求, 产品ID: {data.get('product_id')}, 提示词ID: {data.get('prompt_workflow_id')}, 主题数: {len(data.get('topics', []))}, 企业ID: {enterprise_id}, IP: {client_ip}")
|
||
|
||
# 验证必需字段
|
||
required_fields = ['product_id', 'prompt_workflow_id', 'topics']
|
||
for field in required_fields:
|
||
if not data.get(field):
|
||
logger.warning(f"[生成文案] 缺少必需字段: {field}, 企业ID: {enterprise_id}, IP: {client_ip}")
|
||
return jsonify({
|
||
'code': 400,
|
||
'message': f'缺少必需字段: {field}',
|
||
'data': None
|
||
}), 400
|
||
|
||
db_manager = get_db_manager()
|
||
|
||
# 验证产品是否存在
|
||
logger.info(f"[生成文案] 验证产品是否存在, 产品ID: {data['product_id']}, 企业ID: {enterprise_id}")
|
||
check_product_sql = "SELECT id, name FROM ai_products WHERE id = %s AND enterprise_id = %s"
|
||
product = db_manager.execute_query(check_product_sql, (data['product_id'], enterprise_id))
|
||
|
||
if not product:
|
||
logger.warning(f"[生成文案] 产品不存在, 产品ID: {data['product_id']}, 企业ID: {enterprise_id}, IP: {client_ip}")
|
||
return jsonify({
|
||
'code': 404,
|
||
'message': '产品不存在',
|
||
'data': None
|
||
}), 404
|
||
|
||
logger.info(f"[生成文案] 产品验证成功, 产品名称: {product[0]['name']}, ID: {data['product_id']}")
|
||
|
||
# 验证提示词是否存在
|
||
logger.info(f"[生成文案] 验证提示词是否存在, 提示词ID: {data['prompt_workflow_id']}, 企业ID: {enterprise_id}")
|
||
check_prompt_sql = "SELECT id FROM ai_prompt_workflow WHERE id = %s AND enterprise_id = %s"
|
||
prompt = db_manager.execute_query(check_prompt_sql, (data['prompt_workflow_id'], enterprise_id))
|
||
|
||
if not prompt:
|
||
logger.warning(f"[生成文案] 提示词不存在, 提示词ID: {data['prompt_workflow_id']}, 企业ID: {enterprise_id}, IP: {client_ip}")
|
||
return jsonify({
|
||
'code': 404,
|
||
'message': '提示词不存在',
|
||
'data': None
|
||
}), 404
|
||
|
||
logger.info(f"[生成文案] 提示词验证成功, ID: {data['prompt_workflow_id']}")
|
||
|
||
count = data.get('count', 1)
|
||
topics = data['topics'][:count] if len(data['topics']) >= count else data['topics']
|
||
|
||
logger.info(f"[生成文案] 开始生成文案, 主题数量: {len(topics)}, 产品: {product[0]['name']}, 企业ID: {enterprise_id}")
|
||
|
||
generated_articles = []
|
||
|
||
# 生成batch_id（时间戳 + 6位随机数）
|
||
timestamp = int(time.time())
|
||
random_num = random.randint(100000, 999999)
|
||
batch_id = f"{timestamp}{random_num}"
|
||
|
||
logger.info(f"[批量生成文章] 生成batch_id: {batch_id}, 待处理数据行数: {len(topics)}")
|
||
|
||
for topic in topics:
|
||
logger.info(f"[生成文案] 开始生成主题文案: {topic}, 产品: {product[0]['name']}")
|
||
# TODO: 这里应该调用AI接口生成文案内容
|
||
# 目前使用模拟数据
|
||
title = f"{topic}"
|
||
#content = f"这是一篇关于{topic}的精彩内容..."
|
||
|
||
# 插入文案记录（content字段先为空，等待后续脚本填充）
|
||
sql = """
|
||
INSERT INTO ai_articles
|
||
(enterprise_id, product_id, prompt_workflow_id, title, topic, content, status, batch_id)
|
||
VALUES (%s, %s, %s, %s, %s, %s, %s, %s)
|
||
"""
|
||
article_id = db_manager.execute_insert(sql, (
|
||
enterprise_id,
|
||
data['product_id'],
|
||
data['prompt_workflow_id'],
|
||
title,
|
||
topic,
|
||
'', # ✅ content字段先设为空，等待后续脚本填充
|
||
'generate',
|
||
batch_id
|
||
))
|
||
|
||
logger.info(f"[生成文案] 文案生成成功, 文案ID: {article_id}, 主题: {topic}, 标题: {title}")
|
||
|
||
generated_articles.append({
|
||
'id': article_id,
|
||
'title': title,
|
||
'topic': topic
|
||
})
|
||
|
||
# 更新产品和企业文案总数
|
||
update_product_sql = "UPDATE ai_products SET articles_total = articles_total + %s WHERE id = %s"
|
||
db_manager.execute_update(update_product_sql, (len(generated_articles), data['product_id']))
|
||
|
||
update_enterprise_sql = "UPDATE ai_enterprises SET articles_total = articles_total + %s WHERE id = %s"
|
||
db_manager.execute_update(update_enterprise_sql, (len(generated_articles), enterprise_id))
|
||
|
||
# 更新提示词使用次数
|
||
update_prompt_sql = "UPDATE ai_prompt_workflow SET usage_count = usage_count + %s WHERE id = %s"
|
||
db_manager.execute_update(update_prompt_sql, (len(generated_articles), data['prompt_workflow_id']))
|
||
|
||
logger.info(f"生成文案成功: {len(generated_articles)}篇")
|
||
|
||
return jsonify({
|
||
'code': 200,
|
||
'message': '生成成功',
|
||
'data': {
|
||
'generated': len(generated_articles),
|
||
'articles': generated_articles
|
||
},
|
||
'timestamp': int(datetime.now().timestamp() * 1000)
|
||
})
|
||
|
||
except Exception as e:
|
||
logger.error(f"[生成文案] 处理请求时发生错误: {str(e)}", exc_info=True)
|
||
return jsonify({
|
||
'code': 500,
|
||
'message': '服务器内部错误',
|
||
'data': None
|
||
}), 500
|
||
|
||
|
||
@article_bp.route('/create_Discard', methods=['POST'])
|
||
@require_auth
|
||
def create_article():
|
||
"""创建文章"""
|
||
client_ip = request.environ.get('HTTP_X_FORWARDED_FOR', request.environ.get('REMOTE_ADDR', '未知'))
|
||
logger.info(f"[创建文章] 开始处理请求, IP: {client_ip}")
|
||
|
||
try:
|
||
current_user = AuthUtils.get_current_user()
|
||
enterprise_id = current_user.get('enterprise_id')
|
||
user_id = current_user.get('user_id', 0)
|
||
|
||
if not enterprise_id:
|
||
return jsonify({
|
||
'code': 400,
|
||
'message': '无法获取企业ID',
|
||
'data': None
|
||
}), 400
|
||
|
||
data = request.get_json()
|
||
if not data:
|
||
return jsonify({
|
||
'code': 400,
|
||
'message': '请求参数错误',
|
||
'data': None
|
||
}), 400
|
||
|
||
# 验证必需字段
|
||
required_fields = ['title', 'content']
|
||
for field in required_fields:
|
||
if not data.get(field):
|
||
return jsonify({
|
||
'code': 400,
|
||
'message': f'缺少必需字段: {field}',
|
||
'data': None
|
||
}), 400
|
||
|
||
db_manager = get_db_manager()
|
||
|
||
# ✅ 插入文章主表
|
||
article_sql = """
|
||
INSERT INTO ai_articles
|
||
(enterprise_id, product_id, topic_type_id, prompt_workflow_id, topic, title, content,
|
||
department, departmentids, author_id, author_name, department_id, department_name,
|
||
created_user_id, status, channel, word_count, image_count, batch_id)
|
||
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
|
||
"""
|
||
article_id = db_manager.execute_insert(article_sql, (
|
||
enterprise_id,
|
||
data.get('product_id', 0),
|
||
data.get('topic_type_id', 0),
|
||
data.get('prompt_workflow_id', 0),
|
||
data.get('topic', ''),
|
||
data['title'],
|
||
data['content'],
|
||
data.get('department', ''),
|
||
data.get('departmentids', ''),
|
||
data.get('author_id'),
|
||
data.get('author_name'),
|
||
data.get('department_id'),
|
||
data.get('department_name'),
|
||
user_id,
|
||
data.get('status', 'draft'),
|
||
data.get('channel', 1),
|
||
data.get('word_count', len(data['content'])),
|
||
data.get('image_count', 0),
|
||
data.get('batch_id', 0)
|
||
))
|
||
|
||
# ✅ 插入文章图片
|
||
if data.get('images'):
|
||
for img in data['images']:
|
||
image_sql = """
|
||
INSERT INTO ai_article_images
|
||
(enterprise_id, article_id, image_id, image_url, image_thumb_url,
|
||
image_tag_id, sort_order, keywords_id, keywords_name,
|
||
department_id, department_name, image_source)
|
||
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
|
||
"""
|
||
db_manager.execute_insert(image_sql, (
|
||
enterprise_id,
|
||
article_id,
|
||
img.get('image_id', 0),
|
||
img.get('image_url', ''),
|
||
img.get('image_thumb_url', ''),
|
||
img.get('image_tag_id', 0),
|
||
img.get('sort_order', 0),
|
||
img.get('keywords_id', 0),
|
||
img.get('keywords_name', ''),
|
||
img.get('department_id', 0),
|
||
img.get('department_name', ''),
|
||
img.get('image_source', 0)
|
||
))
|
||
|
||
# ✅ 插入文章标签
|
||
if data.get('coze_tag'):
|
||
tag_sql = """
|
||
INSERT INTO ai_article_tags (enterprise_id, article_id, coze_tag)
|
||
VALUES (%s, %s, %s)
|
||
"""
|
||
db_manager.execute_insert(tag_sql, (enterprise_id, article_id, data['coze_tag']))
|
||
|
||
logger.info(f"[创建文章] 创建成功, 文章ID: {article_id}, 企业ID: {enterprise_id}")
|
||
|
||
return jsonify({
|
||
'code': 200,
|
||
'message': '创建成功',
|
||
'data': {
|
||
'id': article_id,
|
||
'title': data['title']
|
||
},
|
||
'timestamp': int(datetime.now().timestamp() * 1000)
|
||
})
|
||
|
||
except Exception as e:
|
||
logger.error(f"[创建文章] 处理请求时发生错误: {str(e)}", exc_info=True)
|
||
return jsonify({
|
||
'code': 500,
|
||
'message': '服务器内部错误',
|
||
'data': None
|
||
}), 500
|
||
|
||
@article_bp.route('/<int:article_id>', methods=['PUT'])
|
||
@require_auth
|
||
def update_article(article_id):
|
||
"""更新文章"""
|
||
client_ip = request.environ.get('HTTP_X_FORWARDED_FOR', request.environ.get('REMOTE_ADDR', '未知'))
|
||
logger.info(f"[更新文章] 开始处理请求, 文章ID: {article_id}, IP: {client_ip}")
|
||
|
||
try:
|
||
current_user = AuthUtils.get_current_user()
|
||
enterprise_id = current_user.get('enterprise_id')
|
||
|
||
if not enterprise_id:
|
||
return jsonify({
|
||
'code': 400,
|
||
'message': '无法获取企业ID',
|
||
'data': None
|
||
}), 400
|
||
|
||
data = request.get_json()
|
||
if not data:
|
||
return jsonify({
|
||
'code': 400,
|
||
'message': '请求参数错误',
|
||
'data': None
|
||
}), 400
|
||
|
||
db_manager = get_db_manager()
|
||
|
||
# 检查文章是否存在且属于当前企业
|
||
check_sql = "SELECT id, status FROM ai_articles WHERE id = %s AND enterprise_id = %s"
|
||
existing = db_manager.execute_query(check_sql, (article_id, enterprise_id))
|
||
|
||
if not existing:
|
||
return jsonify({
|
||
'code': 404,
|
||
'message': '文章不存在',
|
||
'data': None
|
||
}), 404
|
||
|
||
old_status = existing[0]['status']
|
||
|
||
# ✅ 构建更新字段
|
||
update_fields = []
|
||
params = []
|
||
|
||
field_mapping = {
|
||
'product_id': 'product_id',
|
||
'topic_type_id': 'topic_type_id',
|
||
'prompt_workflow_id': 'prompt_workflow_id',
|
||
'topic': 'topic',
|
||
'title': 'title',
|
||
'content': 'content',
|
||
'department': 'department',
|
||
'departmentids': 'departmentids',
|
||
'author_id': 'author_id',
|
||
'author_name': 'author_name',
|
||
'department_id': 'department_id',
|
||
'department_name': 'department_name',
|
||
'status': 'status',
|
||
'channel': 'channel',
|
||
'review_comment': 'review_comment',
|
||
'publish_time': 'publish_time',
|
||
'publish_link': 'publish_link',
|
||
'baijiahao_id': 'baijiahao_id',
|
||
'baijiahao_status': 'baijiahao_status',
|
||
'word_count': 'word_count',
|
||
'image_count': 'image_count',
|
||
'batch_id': 'batch_id'
|
||
}
|
||
|
||
for field, db_field in field_mapping.items():
|
||
if field in data:
|
||
update_fields.append(f"{db_field} = %s")
|
||
params.append(data[field])
|
||
|
||
if update_fields:
|
||
params.append(article_id)
|
||
sql = f"UPDATE ai_articles SET {', '.join(update_fields)}, updated_at = NOW() WHERE id = %s"
|
||
db_manager.execute_update(sql, params)
|
||
|
||
# ✅ 更新文章图片（先删除后插入）
|
||
if 'images' in data:
|
||
# 删除旧图片
|
||
db_manager.execute_update("DELETE FROM ai_article_images WHERE article_id = %s", (article_id,))
|
||
|
||
# 插入新图片
|
||
if data['images']:
|
||
for img in data['images']:
|
||
image_sql = """
|
||
INSERT INTO ai_article_images
|
||
(enterprise_id, article_id, image_id, image_url, image_thumb_url,
|
||
image_tag_id, sort_order, keywords_id, keywords_name,
|
||
department_id, department_name, image_source)
|
||
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
|
||
"""
|
||
db_manager.execute_insert(image_sql, (
|
||
enterprise_id,
|
||
article_id,
|
||
img.get('image_id', 0),
|
||
img.get('image_url', ''),
|
||
img.get('image_thumb_url', ''),
|
||
img.get('image_tag_id', 0),
|
||
img.get('sort_order', 0),
|
||
img.get('keywords_id', 0),
|
||
img.get('keywords_name', ''),
|
||
img.get('department_id', 0),
|
||
img.get('department_name', ''),
|
||
img.get('image_source', 0)
|
||
))
|
||
|
||
# ✅ 更新文章标签
|
||
if 'coze_tag' in data:
|
||
# 检查是否已存在标签
|
||
tag_check = db_manager.execute_query(
|
||
"SELECT id FROM ai_article_tags WHERE article_id = %s",
|
||
(article_id,)
|
||
)
|
||
|
||
if tag_check:
|
||
# 更新标签
|
||
db_manager.execute_update(
|
||
"UPDATE ai_article_tags SET coze_tag = %s WHERE article_id = %s",
|
||
(data['coze_tag'], article_id)
|
||
)
|
||
else:
|
||
# 插入标签
|
||
db_manager.execute_insert(
|
||
"INSERT INTO ai_article_tags (enterprise_id, article_id, coze_tag) VALUES (%s, %s, %s)",
|
||
(enterprise_id, article_id, data['coze_tag'])
|
||
)
|
||
|
||
# ✅ 如果状态发生变化，记录到发布记录表
|
||
new_status = data.get('status')
|
||
if new_status and new_status != old_status:
|
||
# 查询文章信息
|
||
article_info = db_manager.execute_query(
|
||
"SELECT product_id, topic, title FROM ai_articles WHERE id = %s",
|
||
(article_id,)
|
||
)
|
||
|
||
if article_info:
|
||
record_sql = """
|
||
INSERT INTO ai_article_published_records
|
||
(article_id, enterprise_id, product_id, topic, title, created_user_id,
|
||
status, channel, word_count, image_count, publish_time, publish_link)
|
||
SELECT id, enterprise_id, product_id, topic, title, created_user_id,
|
||
status, channel, word_count, image_count, publish_time, publish_link
|
||
FROM ai_articles
|
||
WHERE id = %s
|
||
"""
|
||
db_manager.execute_insert(record_sql, (article_id,))
|
||
|
||
logger.info(f"[更新文章] 更新成功, 文章ID: {article_id}, 企业ID: {enterprise_id}")
|
||
|
||
return jsonify({
|
||
'code': 200,
|
||
'message': '更新成功',
|
||
'data': None,
|
||
'timestamp': int(datetime.now().timestamp() * 1000)
|
||
})
|
||
|
||
except Exception as e:
|
||
logger.error(f"[更新文章] 处理请求时发生错误: {str(e)}", exc_info=True)
|
||
return jsonify({
|
||
'code': 500,
|
||
'message': '服务器内部错误',
|
||
'data': None
|
||
}), 500
|
||
|
||
@article_bp.route('/<int:article_id>', methods=['GET'])
|
||
@require_auth
|
||
def get_article_detail(article_id):
|
||
"""获取文章详情（包含图片、标签、发布记录）"""
|
||
try:
|
||
current_user = AuthUtils.get_current_user()
|
||
enterprise_id = current_user.get('enterprise_id')
|
||
|
||
if not enterprise_id:
|
||
return jsonify({
|
||
'code': 400,
|
||
'message': '无法获取企业ID',
|
||
'data': None
|
||
}), 400
|
||
|
||
db_manager = get_db_manager()
|
||
|
||
# ✅ 查询文章详情（包含所有字段）
|
||
sql = """
|
||
SELECT a.id, a.batch_id, a.enterprise_id, a.product_id, a.topic_type_id,
|
||
a.prompt_workflow_id, a.topic, a.title, a.content, a.department,
|
||
a.departmentids, a.author_id, a.author_name, a.department_id, a.department_name,
|
||
a.created_user_id, a.review_user_id, a.publish_user_id, a.status, a.channel,
|
||
a.review_comment, a.publish_time, a.publish_link, a.baijiahao_id, a.baijiahao_status,
|
||
a.word_count, a.image_count, a.coze_tag, a.created_at, a.updated_at,
|
||
p.name as product_name,
|
||
pw.prompt_workflow_name as prompt_name
|
||
FROM ai_articles a
|
||
LEFT JOIN ai_products p ON a.product_id = p.id
|
||
LEFT JOIN ai_prompt_workflow pw ON a.prompt_workflow_id = pw.id
|
||
WHERE a.id = %s AND a.enterprise_id = %s
|
||
"""
|
||
result = db_manager.execute_query(sql, (article_id, enterprise_id))
|
||
|
||
if not result:
|
||
return jsonify({
|
||
'code': 404,
|
||
'message': '文章不存在',
|
||
'data': None
|
||
}), 404
|
||
|
||
article = result[0]
|
||
|
||
# ✅ 查询文章图片
|
||
images_sql = """
|
||
SELECT id, image_id, image_url, image_thumb_url, image_tag_id,
|
||
sort_order, keywords_id, keywords_name, department_id,
|
||
department_name, image_source, created_at
|
||
FROM ai_article_images
|
||
WHERE article_id = %s
|
||
ORDER BY sort_order ASC, created_at ASC
|
||
"""
|
||
article['images'] = db_manager.execute_query(images_sql, (article_id,))
|
||
|
||
# ✅ 查询文章标签
|
||
tags_sql = """
|
||
SELECT id, coze_tag, created_at
|
||
FROM ai_article_tags
|
||
WHERE article_id = %s
|
||
"""
|
||
tags_result = db_manager.execute_query(tags_sql, (article_id,))
|
||
article['tags'] = tags_result[0] if tags_result else None
|
||
|
||
# ✅ 查询文章发布记录
|
||
records_sql = """
|
||
SELECT id, status, created_user_id, review_user_id, publish_user_id,
|
||
review_comment, publish_time, publish_link, word_count, image_count, created_at
|
||
FROM ai_article_published_records
|
||
WHERE article_id = %s
|
||
ORDER BY created_at DESC
|
||
"""
|
||
article['publish_records'] = db_manager.execute_query(records_sql, (article_id,))
|
||
|
||
# 格式化日期字段
|
||
article = format_datetime_fields([article])[0]
|
||
|
||
logger.info(f"获取文章详情成功: ID {article_id}")
|
||
|
||
return jsonify({
|
||
'code': 200,
|
||
'message': 'success',
|
||
'data': article,
|
||
'timestamp': int(datetime.now().timestamp() * 1000)
|
||
})
|
||
|
||
except Exception as e:
|
||
logger.error(f"[获取文章详情] 处理请求时发生错误: {str(e)}", exc_info=True)
|
||
return jsonify({
|
||
'code': 500,
|
||
'message': '服务器内部错误',
|
||
'data': None
|
||
}), 500
|
||
|
||
@article_bp.route('/<int:article_id>', methods=['DELETE'])
|
||
@require_auth
|
||
def delete_article(article_id):
|
||
"""删除文章（级联删除图片和标签）"""
|
||
try:
|
||
current_user = AuthUtils.get_current_user()
|
||
enterprise_id = current_user.get('enterprise_id')
|
||
|
||
if not enterprise_id:
|
||
return jsonify({
|
||
'code': 400,
|
||
'message': '无法获取企业ID',
|
||
'data': None
|
||
}), 400
|
||
|
||
db_manager = get_db_manager()
|
||
|
||
# 检查文章是否存在且属于当前企业
|
||
check_sql = "SELECT id, title FROM ai_articles WHERE id = %s AND enterprise_id = %s"
|
||
existing = db_manager.execute_query(check_sql, (article_id, enterprise_id))
|
||
|
||
if not existing:
|
||
return jsonify({
|
||
'code': 404,
|
||
'message': '文章不存在',
|
||
'data': None
|
||
}), 404
|
||
|
||
# ✅ 删除文章图片
|
||
db_manager.execute_update("DELETE FROM ai_article_images WHERE article_id = %s", (article_id,))
|
||
|
||
# ✅ 删除文章标签
|
||
db_manager.execute_update("DELETE FROM ai_article_tags WHERE article_id = %s", (article_id,))
|
||
|
||
# ✅ 删除文章主表
|
||
sql = "DELETE FROM ai_articles WHERE id = %s"
|
||
db_manager.execute_update(sql, (article_id,))
|
||
|
||
logger.info(f"删除文章成功: ID {article_id}")
|
||
|
||
return jsonify({
|
||
'code': 200,
|
||
'message': '删除成功',
|
||
'data': None,
|
||
'timestamp': int(datetime.now().timestamp() * 1000)
|
||
})
|
||
|
||
except Exception as e:
|
||
logger.error(f"[删除文章] 处理请求时发生错误: {str(e)}", exc_info=True)
|
||
return jsonify({
|
||
'code': 500,
|
||
'message': '服务器内部错误',
|
||
'data': None
|
||
}), 500
|
||
|
||
@article_bp.route('/list_dashboard', methods=['GET'])
|
||
@require_auth
|
||
def get_articles_dashboard():
|
||
"""获取文章仪表盘统计"""
|
||
client_ip = request.environ.get('HTTP_X_FORWARDED_FOR', request.environ.get('REMOTE_ADDR', '未知'))
|
||
logger.info(f"[文章仪表盘] 开始处理请求, IP: {client_ip}")
|
||
|
||
try:
|
||
current_user = AuthUtils.get_current_user()
|
||
enterprise_id = current_user.get('enterprise_id')
|
||
|
||
if not enterprise_id:
|
||
logger.warning(f"[文章仪表盘] 无法获取企业ID, IP: {client_ip}")
|
||
return jsonify({
|
||
'code': 400,
|
||
'message': '无法获取企业ID',
|
||
'data': None
|
||
}), 400
|
||
|
||
db_manager = get_db_manager()
|
||
|
||
# ✅ 1. 文章总数：status != 'draft'
|
||
articles_total_sql = """
|
||
SELECT COUNT(id) as total
|
||
FROM ai_articles
|
||
WHERE enterprise_id = %s
|
||
"""
|
||
articles_total_result = db_manager.execute_query(articles_total_sql, (enterprise_id,))
|
||
articles_total = articles_total_result[0]['total'] if articles_total_result else 0
|
||
|
||
# ✅ 2. 能发的文章：status = 'published_review'
|
||
articles_available_sql = """
|
||
SELECT COUNT(id) as total
|
||
FROM ai_articles
|
||
WHERE enterprise_id = %s AND status = 'published_review'
|
||
"""
|
||
articles_available_result = db_manager.execute_query(articles_available_sql, (enterprise_id,))
|
||
articles_available = articles_available_result[0]['total'] if articles_available_result else 0
|
||
|
||
# ✅ 3. 发布成功：status = 'published'
|
||
articles_published_sql = """
|
||
SELECT COUNT(id) as total
|
||
FROM ai_articles
|
||
WHERE enterprise_id = %s AND status = 'published'
|
||
"""
|
||
articles_published_result = db_manager.execute_query(articles_published_sql, (enterprise_id,))
|
||
articles_published = articles_published_result[0]['total'] if articles_published_result else 0
|
||
|
||
stats = {
|
||
'articles_total': articles_total,
|
||
'articles_available': articles_available,
|
||
'articles_published': articles_published
|
||
}
|
||
|
||
logger.info(f"[文章仪表盘] 查询成功, 企业ID: {enterprise_id}, 总数: {articles_total}, 可发: {articles_available}, 已发: {articles_published}, IP: {client_ip}")
|
||
|
||
return jsonify({
|
||
'code': 200,
|
||
'message': 'success',
|
||
'data': stats,
|
||
'timestamp': int(datetime.now().timestamp() * 1000)
|
||
})
|
||
|
||
except Exception as e:
|
||
logger.error(f"[文章仪表盘] 处理请求时发生错误: {str(e)}", exc_info=True)
|
||
return jsonify({
|
||
'code': 500,
|
||
'message': '服务器内部错误',
|
||
'data': None
|
||
}), 500
|