3433 lines
129 KiB
Python
3433 lines
129 KiB
Python
from django.http import JsonResponse
|
||
# from .models import TiktokUserVideos
|
||
import logging
|
||
import os
|
||
from django.views.decorators.http import require_http_methods
|
||
from django.views.decorators.csrf import csrf_exempt
|
||
from django.shortcuts import render
|
||
import json
|
||
import requests
|
||
import concurrent.futures
|
||
import shutil
|
||
import dotenv
|
||
import random
|
||
import uuid
|
||
|
||
dotenv.load_dotenv()
|
||
|
||
# 获取应用专属的logger
|
||
logger = logging.getLogger('daren_detail')
|
||
|
||
directory_monitoring = {}
|
||
|
||
# 全局变量来控制检测线程
|
||
monitor_thread = None
|
||
is_monitoring = False
|
||
|
||
# # 在文件开头定义日志目录
|
||
# BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||
# LOG_DIR = os.path.join(BASE_DIR, 'logs', 'process_monitor')
|
||
|
||
# 创建保存视频的基本路径
|
||
# TIKTOK_VIDEOS_PATH = os.path.join(BASE_DIR, 'media', 'tiktok_videos')
|
||
|
||
# 确保基本目录存在
|
||
# os.makedirs(TIKTOK_VIDEOS_PATH, exist_ok=True)
|
||
|
||
# 确保基础目录结构存在，添加 'all' 目录
|
||
# for resource_type in ['cpu', 'memory', 'gpu', 'all']:
|
||
# os.makedirs(os.path.join(LOG_DIR, resource_type), exist_ok=True)
|
||
|
||
# 全局变量来跟踪监控的目录
|
||
# monitored_directories = set()
|
||
|
||
# 在文件顶部添加 API 基础 URL
|
||
# API_BASE_URL = os.getenv("API_BASE_URL")
|
||
|
||
#
|
||
# @csrf_exempt
|
||
# @require_http_methods(["POST"])
|
||
# def fetch_tiktok_videos(request):
|
||
# """获取TikTok视频"""
|
||
# try:
|
||
# # 添加全局变量引用
|
||
# global all_downloaded_videos
|
||
#
|
||
# # 如果变量未初始化，则初始化为空列表
|
||
# if 'all_downloaded_videos' not in globals():
|
||
# all_downloaded_videos = []
|
||
#
|
||
# data = json.loads(request.body)
|
||
# unique_id = data.get('unique_id')
|
||
#
|
||
# if not unique_id:
|
||
# return JsonResponse({
|
||
# 'status': 'error',
|
||
# 'message': '请提供TikTok用户ID(unique_id)'
|
||
# }, json_dumps_params={'ensure_ascii': False})
|
||
#
|
||
# # 检查数据库中是否已存在该unique_id
|
||
# if TiktokUserVideos.objects.filter(unique_id=unique_id).exists():
|
||
# logger.info(f"用户 {unique_id} 已存在于数据库中，跳过处理")
|
||
# return JsonResponse({
|
||
# 'status': 'success',
|
||
# 'message': f'用户 {unique_id} 已存在，跳过处理'
|
||
# }, json_dumps_params={'ensure_ascii': False})
|
||
#
|
||
# # 获取creator_oec_id
|
||
# creator_oec_id = data.get('creator_oec_id')
|
||
# logger.info(f"从请求数据中获取到creator_oec_id: {creator_oec_id}")
|
||
#
|
||
# # 调用API获取用户资料和secUid
|
||
# logger.info(f"正在获取用户 {unique_id} 的资料...")
|
||
# # user_profile = fetch_user_profile(unique_id)
|
||
# user_profile = None
|
||
# if not user_profile or 'data' not in user_profile:
|
||
# # 尝试使用备用方法获取用户资料
|
||
# logger.info(f"尝试使用备用方法获取用户 {unique_id} 的资料...")
|
||
#
|
||
# # 从data中获取creator_oec_id
|
||
# try:
|
||
# # 从响应中提取creator_oec_id
|
||
# creator_oec_id = data.get('creator_oec_id')
|
||
# logger.info(f"从请求数据中获取到creator_oec_id: {creator_oec_id}")
|
||
#
|
||
# # 如果有creator_oec_id，则使用备用方法获取用户资料
|
||
# if creator_oec_id:
|
||
# user_profile = fetch_user_profile_1(creator_oec_id)
|
||
#
|
||
# if not user_profile or 'data' not in user_profile:
|
||
# return JsonResponse({
|
||
# 'status': 'error',
|
||
# 'message': f'无法获取用户 {unique_id} 的资料(两种方法均失败)'
|
||
# }, json_dumps_params={'ensure_ascii': False})
|
||
# else:
|
||
# return JsonResponse({
|
||
# 'status': 'error',
|
||
# 'message': f'无法获取用户 {unique_id} 的资料'
|
||
# }, json_dumps_params={'ensure_ascii': False})
|
||
# except Exception as e:
|
||
# logger.error(f"备用方法获取用户资料失败: {e}")
|
||
# return JsonResponse({
|
||
# 'status': 'error',
|
||
# 'message': f'无法获取用户 {unique_id} 的资料: {str(e)}'
|
||
# }, json_dumps_params={'ensure_ascii': False})
|
||
#
|
||
# # 从API响应中提取secUid和其他用户信息
|
||
# try:
|
||
# user_info = user_profile['data']['userInfo']['user']
|
||
# sec_uid = user_info['secUid']
|
||
#
|
||
# # 提取其他用户信息
|
||
# nickname = user_info.get('nickname', f'用户_{unique_id}')
|
||
# signature = user_info.get('signature', '')
|
||
# avatar_url = user_info.get('avatarLarger', '')
|
||
# user_stats = user_profile['data']['userInfo']['stats']
|
||
# follower_count = user_stats.get('followerCount', 0)
|
||
# heart_count = user_stats.get('heartCount', 0)
|
||
#
|
||
# logger.info(f"成功获取用户secUid: {sec_uid}")
|
||
# except (KeyError, TypeError) as e:
|
||
# logger.error(f"解析用户资料出错: {e}")
|
||
# return JsonResponse({
|
||
# 'status': 'error',
|
||
# 'message': f'解析用户资料出错: {str(e)}'
|
||
# }, json_dumps_params={'ensure_ascii': False})
|
||
#
|
||
# # 确保用户目录存在
|
||
# user_dir = os.path.join(TIKTOK_VIDEOS_PATH, unique_id)
|
||
# os.makedirs(user_dir, exist_ok=True)
|
||
#
|
||
# # 获取用户视频
|
||
# downloaded_videos = []
|
||
# videos_data = fetch_user_videos(sec_uid)
|
||
# if videos_data and 'data' in videos_data and 'itemList' in videos_data['data']:
|
||
# videos = videos_data['data']['itemList']
|
||
# user_dir = os.path.join(TIKTOK_VIDEOS_PATH, unique_id)
|
||
# os.makedirs(user_dir, exist_ok=True)
|
||
#
|
||
# # 获取前10个热门视频
|
||
# top_videos = sorted(videos, key=lambda x: x.get('stats', {}).get('playCount', 0), reverse=True)[:10]
|
||
#
|
||
# # 定义下载任务函数
|
||
# def download_task(video):
|
||
# try:
|
||
# video_id = video.get('id', '')
|
||
# if not video_id:
|
||
# return None
|
||
#
|
||
# save_path = os.path.join(user_dir, f"{video_id}.mp4")
|
||
#
|
||
# stats = video.get('stats', {})
|
||
# play_count = int(stats.get('playCount', 0))
|
||
#
|
||
# # 检查是否已下载过该视频
|
||
# is_downloaded = os.path.exists(save_path) and os.path.getsize(save_path) > 0
|
||
#
|
||
# if is_downloaded and is_valid_video_file(save_path):
|
||
# logger.info(f"视频已存在且有效，跳过下载: {video_id}")
|
||
# # 即使跳过下载，也添加到已下载列表中
|
||
# return {
|
||
# 'id': video_id,
|
||
# 'desc': video.get('desc', ''),
|
||
# 'play_count': play_count,
|
||
# 'user_unique_id': unique_id,
|
||
# 'skipped': True
|
||
# }
|
||
# elif download_video(video_id, unique_id, save_path):
|
||
# # download_video函数内部已经检查了文件有效性
|
||
# return {
|
||
# 'id': video_id,
|
||
# 'desc': video.get('desc', ''),
|
||
# 'play_count': play_count,
|
||
# 'user_unique_id': unique_id,
|
||
# 'skipped': False
|
||
# }
|
||
# return None
|
||
# except Exception as e:
|
||
# logger.error(f"下载视频时出错: {e}")
|
||
# return None
|
||
#
|
||
# # 使用线程池并发下载
|
||
# with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
|
||
# # 提交所有下载任务
|
||
# future_to_video = {executor.submit(download_task, video): video for video in top_videos}
|
||
#
|
||
# # 获取结果
|
||
# for future in concurrent.futures.as_completed(future_to_video):
|
||
# result = future.result()
|
||
# if result:
|
||
# downloaded_videos.append(result)
|
||
#
|
||
# all_downloaded_videos.extend(downloaded_videos)
|
||
#
|
||
# # 视频下载完成后，先调用API分析视频，然后再保存到数据库
|
||
# if downloaded_videos: # 只有当有视频下载成功时才处理
|
||
# video_info_json = json.dumps([{
|
||
# 'id': v['id'],
|
||
# 'desc': v['desc'],
|
||
# 'play_count': v['play_count']
|
||
# } for v in downloaded_videos], ensure_ascii=False)
|
||
#
|
||
# # 先调用视频分析和文档创建API
|
||
# document_id = analyze_videos_and_create_document(user_dir, nickname, unique_id, sec_uid)
|
||
#
|
||
# # 只有在API调用成功后才写入数据库
|
||
# if document_id:
|
||
# user_record = TiktokUserVideos.objects.update_or_create(
|
||
# sec_user_id=sec_uid,
|
||
# defaults={
|
||
# 'unique_id': unique_id, # 添加unique_id字段
|
||
# 'nickname': nickname,
|
||
# 'signature': signature,
|
||
# 'follower_count': follower_count,
|
||
# 'total_favorited': heart_count,
|
||
# 'avatar_url': avatar_url,
|
||
# 'videos_folder': user_dir,
|
||
# 'video_paths': video_info_json,
|
||
# 'creator_oec_id': creator_oec_id,
|
||
# 'document_id': document_id
|
||
# }
|
||
# )
|
||
# logger.info(
|
||
# f"API调用成功，用户 {nickname} 的数据已写入数据库，下载视频数: {len(downloaded_videos)}，document_id: {document_id}")
|
||
# else:
|
||
# logger.warning(f"API调用失败，跳过用户 {nickname} 的数据库写入")
|
||
# else:
|
||
# logger.warning(f"未获取到用户 {unique_id} 的视频数据")
|
||
# document_id = None
|
||
#
|
||
# return JsonResponse({
|
||
# 'status': 'success',
|
||
# 'message': '处理完成'
|
||
# }, json_dumps_params={'ensure_ascii': False})
|
||
#
|
||
# except Exception as e:
|
||
# logger.error(f"处理TikTok视频失败: {e}")
|
||
# import traceback
|
||
# logger.error(f"详细错误: {traceback.format_exc()}")
|
||
# return JsonResponse({
|
||
# 'status': 'error',
|
||
# 'message': f'处理TikTok视频失败: {str(e)}'
|
||
# }, json_dumps_params={'ensure_ascii': False})
|
||
#
|
||
#
|
||
# @require_http_methods(["GET"])
|
||
# def get_tiktok_user_videos(request):
|
||
# """获取已下载的TikTok用户视频列表"""
|
||
# try:
|
||
# sec_user_id = request.GET.get('sec_user_id')
|
||
#
|
||
# if not sec_user_id:
|
||
# # 如果没有指定用户ID，返回所有用户列表
|
||
# users = TiktokUserVideos.objects.all().values('sec_user_id', 'unique_id', 'nickname', 'follower_count',
|
||
# 'videos_folder', 'create_time', 'avatar_url', 'signature',
|
||
# 'creator_oec_id')
|
||
# return JsonResponse({
|
||
# 'status': 'success',
|
||
# 'users': list(users)
|
||
# }, json_dumps_params={'ensure_ascii': False})
|
||
#
|
||
# # 查询指定用户信息
|
||
# try:
|
||
# user = TiktokUserVideos.objects.get(sec_user_id=sec_user_id)
|
||
# # 解析视频信息JSON
|
||
# video_info = json.loads(user.video_paths) if user.video_paths else []
|
||
#
|
||
# # 获取文件夹中的文件列表
|
||
# videos_folder = user.videos_folder
|
||
# video_files = []
|
||
# if os.path.exists(videos_folder):
|
||
# video_files = [f for f in os.listdir(videos_folder) if os.path.isfile(os.path.join(videos_folder, f))]
|
||
#
|
||
# except TiktokUserVideos.DoesNotExist:
|
||
# return JsonResponse({
|
||
# 'status': 'error',
|
||
# 'message': f'用户 {sec_user_id} 不存在'
|
||
# }, json_dumps_params={'ensure_ascii': False})
|
||
#
|
||
# return JsonResponse({
|
||
# 'status': 'success',
|
||
# 'user_info': {
|
||
# 'sec_user_id': user.sec_user_id,
|
||
# 'unique_id': user.unique_id,
|
||
# 'nickname': user.nickname,
|
||
# 'signature': user.signature,
|
||
# 'follower_count': user.follower_count,
|
||
# 'total_favorited': user.total_favorited,
|
||
# 'avatar_url': user.avatar_url,
|
||
# 'creator_oec_id': user.creator_oec_id, # 添加creator_oec_id字段
|
||
# 'create_time': user.create_time.strftime('%Y-%m-%d %H:%M:%S'),
|
||
# 'update_time': user.update_time.strftime('%Y-%m-%d %H:%M:%S')
|
||
# },
|
||
# 'videos_folder': videos_folder,
|
||
# 'video_files': video_files,
|
||
# 'video_info': video_info
|
||
# }, json_dumps_params={'ensure_ascii': False})
|
||
#
|
||
# except Exception as e:
|
||
# logger.error(f"获取TikTok视频列表失败: {str(e)}")
|
||
# return JsonResponse({
|
||
# 'status': 'error',
|
||
# 'message': f'获取TikTok视频列表失败: {str(e)}'
|
||
# }, json_dumps_params={'ensure_ascii': False})
|
||
#
|
||
#
|
||
# # 辅助函数
|
||
#
|
||
# def fetch_user_videos(sec_uid, cursor=0, count=30):
|
||
# """获取用户视频列表"""
|
||
# url = f"{API_BASE_URL}/api/tiktok/web/fetch_user_post?secUid={sec_uid}&cursor={cursor}&count={count}"
|
||
#
|
||
# try:
|
||
# response = requests.get(url, timeout=30)
|
||
#
|
||
# if response.status_code == 200:
|
||
# data = response.json()
|
||
# logger.info(f"成功获取用户视频，共 {len(data['data'].get('itemList', []))} 个视频")
|
||
# return data
|
||
# else:
|
||
# logger.error(f"获取用户视频失败: {response.status_code}")
|
||
# return None
|
||
# except Exception as e:
|
||
# logger.error(f"获取用户视频异常: {e}")
|
||
# return None
|
||
#
|
||
#
|
||
# def fetch_user_profile(unique_id):
|
||
# """获取用户基本信息"""
|
||
# url = f"{API_BASE_URL}/api/tiktok/web/fetch_user_profile?uniqueId={unique_id}"
|
||
#
|
||
# try:
|
||
# logger.info(f"正在请求用户资料: {url}")
|
||
# response = requests.get(url, timeout=30)
|
||
#
|
||
# if response.status_code == 200:
|
||
# data = response.json()
|
||
# logger.info(f"成功获取用户资料: {unique_id}")
|
||
#
|
||
# # 打印完整响应以便调试
|
||
# logger.info(f"API原始响应: {data}")
|
||
#
|
||
# # 验证数据完整性
|
||
# if 'data' not in data or not data['data']:
|
||
# logger.error(f"API响应缺少data字段: {data}")
|
||
# return None
|
||
#
|
||
# if 'userInfo' not in data['data'] or not data['data']['userInfo']:
|
||
# logger.error(f"API响应缺少userInfo字段: {data['data']}")
|
||
# return None
|
||
#
|
||
# if 'user' not in data['data']['userInfo'] or not data['data']['userInfo']['user']:
|
||
# logger.error(f"API响应缺少user字段: {data['data']['userInfo']}")
|
||
# return None
|
||
#
|
||
# # 打印用户信息
|
||
# logger.info(f"用户信息: {data['data']['userInfo']['user']}")
|
||
#
|
||
# return data
|
||
# else:
|
||
# logger.error(f"获取用户信息失败: HTTP {response.status_code}, 响应: {response.text[:500]}")
|
||
# return None
|
||
# except Exception as e:
|
||
# logger.error(f"获取用户信息异常: {e}")
|
||
# return None
|
||
#
|
||
#
|
||
# def get_sec_user_id(unique_id):
|
||
# """
|
||
# 通过TikTok用户名获取secUid
|
||
#
|
||
# Args:
|
||
# unique_id: TikTok用户名
|
||
#
|
||
# Returns:
|
||
# secUid字符串，如果获取失败则返回None
|
||
# """
|
||
# url = f"{API_BASE_URL}/api/tiktok/web/get_sec_user_id?url=https://www.tiktok.com/@{unique_id}"
|
||
#
|
||
# try:
|
||
# logger.info(f"正在请求secUid: {url}")
|
||
# response = requests.get(url, timeout=30)
|
||
#
|
||
# if response.status_code == 200:
|
||
# data = response.json()
|
||
# logger.info(f"成功获取secUid: {data}")
|
||
#
|
||
# if 'data' in data and data['data']:
|
||
# sec_uid = data['data']
|
||
# logger.info(f"获取到secUid: {sec_uid}")
|
||
# return sec_uid
|
||
# else:
|
||
# logger.error(f"API响应缺少data字段或data为空: {data}")
|
||
# return None
|
||
# else:
|
||
# logger.error(f"获取secUid失败: HTTP {response.status_code}, 响应: {response.text[:500]}")
|
||
# return None
|
||
# except Exception as e:
|
||
# logger.error(f"获取secUid异常: {e}")
|
||
# return None
|
||
#
|
||
#
|
||
# def fetch_user_profile_1(creator_oec_id):
|
||
# """
|
||
# 通过creator_oec_id获取用户基本信息
|
||
#
|
||
# 当fetch_user_profile无法获取用户信息时，使用此备用方法
|
||
# 通过POST请求获取用户详细资料
|
||
#
|
||
# Args:
|
||
# creator_oec_id: 创作者OEC ID
|
||
#
|
||
# Returns:
|
||
# 与fetch_user_profile相同格式的用户信息
|
||
# """
|
||
# url = "http://100.65.206.105:8899/profile"
|
||
#
|
||
# try:
|
||
# logger.info(f"正在通过creator_oec_id请求用户资料: {creator_oec_id}")
|
||
#
|
||
# # 构建请求体
|
||
# payload = {
|
||
# "creator_oec_id": creator_oec_id,
|
||
# "profile_types": [1, 6]
|
||
# }
|
||
#
|
||
# # 发送POST请求
|
||
# response = requests.post(url, json=payload, timeout=30)
|
||
#
|
||
# if response.status_code == 200:
|
||
# data = response.json()
|
||
# logger.info(f"成功获取用户资料(方法2): {creator_oec_id}")
|
||
#
|
||
# # 验证数据完整性
|
||
# if 'creator_profile' not in data:
|
||
# logger.error(f"API响应缺少creator_profile字段: {data}")
|
||
# return None
|
||
#
|
||
# # 转换为与fetch_user_profile相同的格式
|
||
# creator_profile = data.get('creator_profile', {})
|
||
#
|
||
# # 获取uniqueId
|
||
# unique_id = creator_profile.get('handle', {}).get('value', '')
|
||
#
|
||
# # 通过uniqueId获取secUid
|
||
# sec_uid = None
|
||
# if unique_id:
|
||
# sec_uid = get_sec_user_id(unique_id)
|
||
#
|
||
# # 如果无法获取secUid，使用一个占位符
|
||
# if not sec_uid:
|
||
# logger.warning(f"无法获取用户 {unique_id} 的secUid，使用占位符")
|
||
# sec_uid = f"placeholder_secuid_{creator_oec_id}"
|
||
#
|
||
# # 构建与原API相同格式的响应
|
||
# formatted_data = {
|
||
# 'data': {
|
||
# 'userInfo': {
|
||
# 'user': {
|
||
# 'secUid': sec_uid,
|
||
# 'uniqueId': unique_id,
|
||
# 'nickname': creator_profile.get('nickname', {}).get('value', ''),
|
||
# 'signature': creator_profile.get('bio', {}).get('value', ''),
|
||
# 'avatarLarger': creator_profile.get('avatar', {}).get('value', {}).get('url_list', [''])[0]
|
||
# },
|
||
# 'stats': {
|
||
# 'followerCount': int(creator_profile.get('follower_cnt', {}).get('value', '0')),
|
||
# 'heartCount': 0, # 没有对应字段，设为0
|
||
# 'followingCount': 0, # 没有对应字段，设为0
|
||
# 'videoCount': 0 # 没有对应字段，设为0
|
||
# }
|
||
# }
|
||
# }
|
||
# }
|
||
#
|
||
# return formatted_data
|
||
# else:
|
||
# logger.error(f"获取用户信息失败(方法2): HTTP {response.status_code}, 响应: {response.text[:500]}")
|
||
# return None
|
||
# except Exception as e:
|
||
# logger.error(f"获取用户信息异常(方法2): {e}")
|
||
# import traceback
|
||
# logger.error(f"详细错误: {traceback.format_exc()}")
|
||
# return None
|
||
#
|
||
#
|
||
# def is_valid_video_file(file_path):
|
||
# """
|
||
# 检查视频文件是否有效
|
||
#
|
||
# Args:
|
||
# file_path: 视频文件路径
|
||
#
|
||
# Returns:
|
||
# bool: 如果文件有效返回True，否则返回False
|
||
# """
|
||
# try:
|
||
# # 检查文件是否存在
|
||
# if not os.path.exists(file_path):
|
||
# logger.error(f"视频文件不存在: {file_path}")
|
||
# return False
|
||
#
|
||
# # 检查文件大小是否合理 (大于10KB)
|
||
# file_size = os.path.getsize(file_path)
|
||
# if file_size < 10 * 1024: # 小于10KB的文件可能是无效的
|
||
# logger.warning(f"视频文件过小，可能无效: {file_path}，大小: {file_size}字节")
|
||
# return False
|
||
#
|
||
# # 检查文件是否可读
|
||
# with open(file_path, 'rb') as f:
|
||
# # 尝试读取前100字节
|
||
# data = f.read(100)
|
||
# if not data:
|
||
# logger.warning(f"视频文件内容为空: {file_path}")
|
||
# return False
|
||
#
|
||
# return True
|
||
#
|
||
# except Exception as e:
|
||
# logger.error(f"验证视频文件时出错: {e}")
|
||
# return False
|
||
#
|
||
#
|
||
# def download_video(video_id, unique_id, save_path):
|
||
# """使用API的直接下载接口下载TikTok视频"""
|
||
# # 确保视频ID是纯数字
|
||
# if not str(video_id).isdigit():
|
||
# logger.error(f"无效的视频ID: {video_id}，必须是纯数字")
|
||
# return False
|
||
#
|
||
# # 检查文件是否已存在
|
||
# if os.path.exists(save_path):
|
||
# file_size = os.path.getsize(save_path)
|
||
# if file_size > 0: # 确保文件不是空文件
|
||
# # 进一步验证文件有效性
|
||
# if is_valid_video_file(save_path):
|
||
# logger.info(f"视频文件已存在且有效，跳过下载: {save_path}，文件大小: {file_size}字节")
|
||
# return True
|
||
# else:
|
||
# logger.warning(f"发现无效视频文件，将重新下载: {save_path}")
|
||
# # 删除无效文件
|
||
# os.remove(save_path)
|
||
# else:
|
||
# logger.warning(f"发现空视频文件，将重新下载: {save_path}")
|
||
# # 删除空文件
|
||
# os.remove(save_path)
|
||
#
|
||
# # 构建标准TikTok视频URL
|
||
# tiktok_url = f"https://www.tiktok.com/@{unique_id}/video/{video_id}"
|
||
# logger.info(f"构建的TikTok URL: {tiktok_url}")
|
||
#
|
||
# # 构建完整的API请求URL
|
||
# api_url = f"{API_BASE_URL}/api/download"
|
||
# full_url = f"{api_url}?url={tiktok_url}&prefix=true&with_watermark=false"
|
||
# logger.info(f"完整的API请求URL: {full_url}")
|
||
#
|
||
# try:
|
||
# # 直接使用完整URL发送请求
|
||
# response = requests.get(full_url, stream=True, timeout=60)
|
||
#
|
||
# # 检查响应状态
|
||
# if response.status_code != 200:
|
||
# logger.error(
|
||
# f"下载视频失败: {response.status_code} - {response.text[:200] if response.text else '无响应内容'}")
|
||
# return False
|
||
#
|
||
# # 获取内容类型
|
||
# content_type = response.headers.get('Content-Type', '')
|
||
# logger.info(f"响应内容类型: {content_type}")
|
||
#
|
||
# # 保存文件
|
||
# with open(save_path, 'wb') as f:
|
||
# for chunk in response.iter_content(chunk_size=8192):
|
||
# if chunk:
|
||
# f.write(chunk)
|
||
#
|
||
# file_size = os.path.getsize(save_path)
|
||
# logger.info(f"视频已下载到: {save_path}，文件大小: {file_size}字节")
|
||
#
|
||
# # 验证下载的文件是否有效
|
||
# if is_valid_video_file(save_path):
|
||
# logger.info(f"视频文件验证通过: {save_path}")
|
||
# return True
|
||
# else:
|
||
# logger.error(f"下载的视频文件无效: {save_path}")
|
||
# # 删除无效文件
|
||
# if os.path.exists(save_path):
|
||
# os.remove(save_path)
|
||
# return False
|
||
#
|
||
# except Exception as e:
|
||
# logger.error(f"下载视频异常: {e}")
|
||
# import traceback
|
||
# logger.error(f"详细错误: {traceback.format_exc()}")
|
||
# return False
|
||
#
|
||
#
|
||
# def analyze_videos_and_create_document(videos_folder, nickname, unique_id, sec_uid):
|
||
# """
|
||
# 分析视频目录并创建Yanxi文档
|
||
#
|
||
# Args:
|
||
# videos_folder: 视频所在目录路径
|
||
# nickname: 用户昵称
|
||
# unique_id: TikTok用户ID
|
||
# sec_uid: 用户的安全ID
|
||
#
|
||
# Returns:
|
||
# str: 如果API调用成功返回document_id，否则返回None
|
||
# """
|
||
# try:
|
||
# # 直接调用analyze_directory函数进行视频分析
|
||
# from app.api.summary.summary import analyze_directory
|
||
#
|
||
# logger.info(f"开始分析视频目录: {videos_folder}")
|
||
# analyze_result = analyze_directory(videos_folder)
|
||
#
|
||
# if analyze_result:
|
||
# logger.info(f"分析成功")
|
||
#
|
||
# # 提取分析结果中的用户画像和聚合摘要
|
||
# user_persona = analyze_result.get('user_persona', '')
|
||
# content_summary = analyze_result.get('content_summary', '')
|
||
#
|
||
# content = f"{user_persona}\n\n{content_summary}"
|
||
#
|
||
# # 调用yanxi API创建文档
|
||
# try:
|
||
# yanxi_url = "http://localhost:8899/yanxi/api/dataset/231aaa42-fc97-11ef-a8ef-0242ac120006/document"
|
||
# yanxi_data = {
|
||
# "name": f"{nickname}@{unique_id}",
|
||
# "paragraphs": [
|
||
# {
|
||
# "content": content,
|
||
# "title": sec_uid,
|
||
# "is_active": True
|
||
# }
|
||
# ]
|
||
# }
|
||
#
|
||
# logger.info(f"调用Yanxi API: {yanxi_url}")
|
||
# yanxi_response = requests.post(
|
||
# yanxi_url,
|
||
# json=yanxi_data,
|
||
# headers={"Content-Type": "application/json"},
|
||
# timeout=60
|
||
# )
|
||
#
|
||
# if yanxi_response.status_code in [200, 201]:
|
||
# response_data = yanxi_response.json()
|
||
# document_id = response_data.get('data', {}).get('id')
|
||
# if document_id:
|
||
# logger.info(f"文档创建成功，document_id: {document_id}")
|
||
# return document_id
|
||
# else:
|
||
# logger.error("文档创建成功但未获取到document_id")
|
||
# return None
|
||
# else:
|
||
# logger.error(f"文档创建失败: {yanxi_response.status_code}, {yanxi_response.text}")
|
||
# return None
|
||
# except Exception as e:
|
||
# logger.error(f"调用Yanxi API出错: {e}")
|
||
# return None
|
||
# else:
|
||
# logger.error(f"分析失败")
|
||
# return None
|
||
# except Exception as e:
|
||
# logger.error(f"视频分析出错: {e}")
|
||
# return None
|
||
#
|
||
#
|
||
# @csrf_exempt
|
||
# @require_http_methods(["DELETE"])
|
||
# def delete_tiktok_user(request):
|
||
# """删除TikTok用户及其相关视频和文档"""
|
||
# try:
|
||
# data = json.loads(request.body)
|
||
# sec_uid = data.get('sec_uid')
|
||
#
|
||
# if not sec_uid:
|
||
# return JsonResponse({
|
||
# 'status': 'error',
|
||
# 'message': 'invalid params'
|
||
# }, json_dumps_params={'ensure_ascii': False})
|
||
#
|
||
# try:
|
||
# user = TiktokUserVideos.objects.get(sec_user_id=sec_uid)
|
||
# except TiktokUserVideos.DoesNotExist:
|
||
# return JsonResponse({
|
||
# 'status': 'error',
|
||
# 'message': f'用户 {sec_uid} 不存在'
|
||
# }, json_dumps_params={'ensure_ascii': False})
|
||
#
|
||
# # 获取必要信息
|
||
# videos_folder = user.videos_folder
|
||
# document_id = user.document_id
|
||
#
|
||
# # 1. 删除视频文件夹
|
||
# if videos_folder and os.path.exists(videos_folder):
|
||
# try:
|
||
# shutil.rmtree(videos_folder)
|
||
# logger.info(f"成功删除视频文件夹: {videos_folder}")
|
||
# except Exception as e:
|
||
# logger.error(f"删除视频文件夹失败: {e}")
|
||
#
|
||
# # 2. 删除文档
|
||
# if document_id:
|
||
# try:
|
||
# delete_url = f"http://localhost:8899/yanxi/api/dataset/231aaa42-fc97-11ef-a8ef-0242ac120006/document/{document_id}"
|
||
# delete_response = requests.delete(
|
||
# delete_url,
|
||
# headers={"Content-Type": "application/json"},
|
||
# timeout=30
|
||
# )
|
||
#
|
||
# if delete_response.status_code in [200, 204]:
|
||
# logger.info(f"成功删除文档: {document_id}")
|
||
# else:
|
||
# logger.error(f"删除文档失败: {delete_response.status_code}, {delete_response.text}")
|
||
# except Exception as e:
|
||
# logger.error(f"调用删除文档API出错: {e}")
|
||
#
|
||
# # 3. 删除数据库记录
|
||
# user.delete()
|
||
# logger.info(f"成功删除用户数据: {sec_uid}")
|
||
#
|
||
# return JsonResponse({
|
||
# 'status': 'success',
|
||
# 'message': f'成功删除用户 {sec_uid} 及其相关数据'
|
||
# }, json_dumps_params={'ensure_ascii': False})
|
||
#
|
||
# except Exception as e:
|
||
# logger.error(f"删除用户异常: {e}")
|
||
# import traceback
|
||
# logger.error(f"详细错误: {traceback.format_exc()}")
|
||
# return JsonResponse({
|
||
# 'status': 'error',
|
||
# 'message': f'删除用户时发生错误: {str(e)}'
|
||
# }, json_dumps_params={'ensure_ascii': False})
|
||
|
||
|
||
@csrf_exempt
|
||
@require_http_methods(["POST"])
|
||
def filter_creators(request):
|
||
"""根据过滤条件筛选达人信息（POST版）"""
|
||
try:
|
||
from .models import CreatorProfile
|
||
import json
|
||
|
||
# 解析POST请求体
|
||
data = json.loads(request.body)
|
||
filter_data = data.get('filter', {})
|
||
page = int(data.get('page', 1))
|
||
page_size = int(data.get('page_size', 10))
|
||
|
||
# 基础查询
|
||
query = CreatorProfile.objects.all()
|
||
|
||
# Category 单选过滤
|
||
category = filter_data.get('category')
|
||
if category and len(category) > 0:
|
||
query = query.filter(category=category[0])
|
||
|
||
# 电商能力等级过滤 (L1-L7)，单选
|
||
e_commerce_level = filter_data.get('e_commerce_level')
|
||
if e_commerce_level and len(e_commerce_level) > 0:
|
||
level_str = e_commerce_level[0]
|
||
if level_str.startswith('L'):
|
||
level_num = int(level_str[1:])
|
||
query = query.filter(e_commerce_level=level_num)
|
||
|
||
# 曝光等级过滤 (KOL-1, KOL-2, KOC-1等)，单选
|
||
exposure_level = filter_data.get('exposure_level')
|
||
if exposure_level and len(exposure_level) > 0:
|
||
query = query.filter(exposure_level=exposure_level[0])
|
||
|
||
# GMV范围过滤 ($0-$5k, $5k-$25k, $25k-$50k等)，单选
|
||
gmv_range = filter_data.get('gmv_range')
|
||
if gmv_range and len(gmv_range) > 0:
|
||
gmv_min, gmv_max = 0, float('inf')
|
||
gmv_val = gmv_range[0]
|
||
if gmv_val == "$0-$5k":
|
||
gmv_min, gmv_max = 0, 5
|
||
elif gmv_val == "$5k-$25k":
|
||
gmv_min, gmv_max = 5, 25
|
||
elif gmv_val == "$25k-$50k":
|
||
gmv_min, gmv_max = 25, 50
|
||
elif gmv_val == "$50k-$150k":
|
||
gmv_min, gmv_max = 50, 150
|
||
elif gmv_val == "$150k-$400k":
|
||
gmv_min, gmv_max = 150, 400
|
||
elif gmv_val == "$400k-$1500k":
|
||
gmv_min, gmv_max = 400, 1500
|
||
elif gmv_val == "$1500k+":
|
||
gmv_min = 1500
|
||
|
||
if gmv_min > 0:
|
||
query = query.filter(gmv__gte=gmv_min)
|
||
if gmv_max < float('inf'):
|
||
query = query.filter(gmv__lte=gmv_max)
|
||
|
||
# 观看量范围过滤，单选
|
||
views_range = filter_data.get('views_range')
|
||
if views_range and len(views_range) > 0:
|
||
views_min, views_max = 0, float('inf')
|
||
views_val = views_range[0]
|
||
if views_val == "0-100":
|
||
views_min, views_max = 0, 100
|
||
elif views_val == "1k-10k":
|
||
views_min, views_max = 1000, 10000
|
||
elif views_val == "10k-100k":
|
||
views_min, views_max = 10000, 100000
|
||
elif views_val == "100k-250k":
|
||
views_min, views_max = 100000, 250000
|
||
elif views_val == "250k-500k":
|
||
views_min, views_max = 250000, 500000
|
||
elif views_val == "500k+":
|
||
views_min = 500000
|
||
|
||
if views_min > 0:
|
||
query = query.filter(avg_video_views__gte=views_min)
|
||
if views_max < float('inf'):
|
||
query = query.filter(avg_video_views__lte=views_max)
|
||
|
||
# 价格区间过滤逻辑，单选
|
||
pricing = filter_data.get('pricing')
|
||
if pricing and len(pricing) > 0:
|
||
pricing_val = pricing[0]
|
||
if '-' in pricing_val:
|
||
min_price, max_price = pricing_val.split('-')
|
||
min_price = float(min_price)
|
||
max_price = float(max_price)
|
||
query = query.filter(pricing_min__gte=min_price, pricing_max__lte=max_price)
|
||
|
||
# 获取总数据量
|
||
total_count = query.count()
|
||
|
||
# 计算分页
|
||
start = (page - 1) * page_size
|
||
end = start + page_size
|
||
|
||
# 执行查询并分页
|
||
creators = query[start:end]
|
||
|
||
creator_list = []
|
||
for creator in creators:
|
||
# 格式化电商等级
|
||
e_commerce_level_formatted = f"L{creator.e_commerce_level}" if creator.e_commerce_level else None
|
||
|
||
# 格式化GMV
|
||
gmv_formatted = f"${creator.gmv}k" if creator.gmv else "$0"
|
||
|
||
# 格式化粉丝数和观看量
|
||
followers_formatted = f"{int(creator.followers / 1000)}k" if creator.followers else "0"
|
||
avg_views_formatted = f"{int(creator.avg_video_views / 1000)}k" if creator.avg_video_views else "0"
|
||
|
||
# 格式化价格区间
|
||
if creator.pricing_min is not None and creator.pricing_max is not None:
|
||
pricing_range = f"${creator.pricing_min}-{creator.pricing_max}"
|
||
else:
|
||
pricing_range = None
|
||
|
||
# 格式化结果
|
||
formatted_creator = {
|
||
"Creator": {
|
||
"name": creator.name,
|
||
"avatar": creator.avatar_url
|
||
},
|
||
"Category": creator.category,
|
||
"E-commerce Level": e_commerce_level_formatted,
|
||
"Exposure Level": creator.exposure_level,
|
||
"Followers": followers_formatted,
|
||
"GMV": gmv_formatted,
|
||
"Items Sold": f"{creator.items_sold}k" if creator.items_sold else None,
|
||
"Avg. Video Views": avg_views_formatted,
|
||
"Pricing": {
|
||
"Range": pricing_range,
|
||
"Pack. P": creator.pricing_package
|
||
},
|
||
"# Collab": creator.collab_count,
|
||
"Latest Collab.": creator.latest_collab,
|
||
"E-commerce": creator.e_commerce_platforms,
|
||
}
|
||
creator_list.append(formatted_creator)
|
||
|
||
# 计算总页数
|
||
total_pages = (total_count + page_size - 1) // page_size
|
||
|
||
# 修改响应格式为code、message和data
|
||
return JsonResponse({
|
||
'code': 200,
|
||
'message': '获取成功',
|
||
'data': {
|
||
'total_count': total_count,
|
||
'total_pages': total_pages,
|
||
'current_page': page,
|
||
'page_size': page_size,
|
||
'count': len(creator_list),
|
||
'creators': creator_list
|
||
}
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
except Exception as e:
|
||
logger.error(f"筛选达人信息失败: {e}")
|
||
import traceback
|
||
logger.error(f"详细错误: {traceback.format_exc()}")
|
||
return JsonResponse({
|
||
'code': 500,
|
||
'message': f'筛选达人信息失败: {str(e)}',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
|
||
@csrf_exempt
|
||
@require_http_methods(["POST"])
|
||
def add_creator(request):
|
||
"""添加或更新达人信息"""
|
||
try:
|
||
from .models import CreatorProfile
|
||
import json
|
||
|
||
data = json.loads(request.body)
|
||
|
||
# 必需的基本信息
|
||
name = data.get('name')
|
||
|
||
if not name:
|
||
return JsonResponse({
|
||
'code': 400,
|
||
'message': '名称是必填项',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 查询是否已存在该creator
|
||
creator, created = CreatorProfile.objects.get_or_create(
|
||
name=name,
|
||
defaults={
|
||
'avatar_url': data.get('avatar_url'),
|
||
}
|
||
)
|
||
|
||
# 更新其他字段
|
||
creator.category = data.get('category', creator.category)
|
||
|
||
# 处理电商等级
|
||
e_commerce_level = data.get('e_commerce_level')
|
||
if e_commerce_level:
|
||
if isinstance(e_commerce_level, str) and e_commerce_level.startswith('L'):
|
||
creator.e_commerce_level = int(e_commerce_level[1:])
|
||
elif isinstance(e_commerce_level, int):
|
||
creator.e_commerce_level = e_commerce_level
|
||
|
||
creator.exposure_level = data.get('exposure_level', creator.exposure_level)
|
||
creator.followers = data.get('followers', creator.followers)
|
||
|
||
# 处理GMV
|
||
gmv = data.get('gmv')
|
||
if gmv:
|
||
if isinstance(gmv, str) and gmv.startswith('$') and gmv.endswith('k'):
|
||
# 将"$534.1k"转换为534.1
|
||
creator.gmv = float(gmv.strip('$k'))
|
||
elif isinstance(gmv, (int, float)):
|
||
creator.gmv = gmv
|
||
|
||
# 处理items_sold
|
||
items_sold = data.get('items_sold')
|
||
if items_sold:
|
||
if isinstance(items_sold, str) and items_sold.endswith('k'):
|
||
creator.items_sold = float(items_sold.strip('k'))
|
||
elif isinstance(items_sold, (int, float)):
|
||
creator.items_sold = items_sold
|
||
|
||
# 处理avg_video_views
|
||
avg_video_views = data.get('avg_video_views')
|
||
if avg_video_views:
|
||
if isinstance(avg_video_views, str) and avg_video_views.endswith('k'):
|
||
creator.avg_video_views = float(avg_video_views.strip('k')) * 1000
|
||
elif isinstance(avg_video_views, (int, float)):
|
||
creator.avg_video_views = avg_video_views
|
||
|
||
# 更新价格信息
|
||
pricing = data.get('pricing', {})
|
||
if pricing:
|
||
creator.pricing_individual = pricing.get('individual', creator.pricing_individual)
|
||
creator.pricing_package = pricing.get('package', creator.pricing_package)
|
||
|
||
creator.collab_count = data.get('collab_count', creator.collab_count)
|
||
creator.latest_collab = data.get('latest_collab', creator.latest_collab)
|
||
creator.e_commerce_platforms = data.get('e_commerce_platforms', creator.e_commerce_platforms)
|
||
creator.is_active = data.get('is_active', creator.is_active)
|
||
creator.mcn = data.get('mcn', creator.mcn)
|
||
|
||
# 保存更新
|
||
creator.save()
|
||
|
||
return JsonResponse({
|
||
'code': 200,
|
||
'message': '达人信息已添加/更新',
|
||
'data': {
|
||
'created': created,
|
||
'creator_id': creator.id
|
||
}
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
except Exception as e:
|
||
logger.error(f"添加/更新达人信息失败: {e}")
|
||
import traceback
|
||
logger.error(f"详细错误: {traceback.format_exc()}")
|
||
return JsonResponse({
|
||
'code': 500,
|
||
'message': f'添加/更新达人信息失败: {str(e)}',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
|
||
@csrf_exempt
|
||
@require_http_methods(["GET"])
|
||
def get_campaigns(request):
|
||
"""获取所有营销活动列表"""
|
||
try:
|
||
from .models import Campaign
|
||
|
||
# 查询所有活跃的活动
|
||
campaigns = Campaign.objects.filter(is_active=True)
|
||
|
||
campaign_list = []
|
||
for campaign in campaigns:
|
||
display_name = campaign.name
|
||
if campaign.product:
|
||
display_name = f"{campaign.brand} {campaign.product}"
|
||
else:
|
||
display_name = campaign.brand
|
||
|
||
campaign_list.append({
|
||
"id": campaign.id,
|
||
"name": display_name,
|
||
"brand": campaign.brand,
|
||
"product": campaign.product
|
||
})
|
||
|
||
return JsonResponse({
|
||
'code': 200,
|
||
'message': '获取成功',
|
||
'data': campaign_list
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
except Exception as e:
|
||
logger.error(f"获取营销活动失败: {e}")
|
||
import traceback
|
||
logger.error(f"详细错误: {traceback.format_exc()}")
|
||
return JsonResponse({
|
||
'code': 500,
|
||
'message': f'获取营销活动失败: {str(e)}',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
|
||
@csrf_exempt
|
||
@require_http_methods(["POST"])
|
||
def add_to_campaign(request):
|
||
"""添加达人到营销活动(如有原达人则先删除后添加)"""
|
||
try:
|
||
from .models import CreatorProfile, CreatorCampaign
|
||
from apps.brands.models import Campaign
|
||
import json
|
||
|
||
data = json.loads(request.body)
|
||
|
||
# 获取必要参数
|
||
campaign_id = data.get('campaign_id')
|
||
creator_ids = data.get('creator_ids', [])
|
||
|
||
if not campaign_id or not creator_ids:
|
||
return JsonResponse({
|
||
'code': 400,
|
||
'message': '缺少必要参数：campaign_id 或 creator_ids',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 检查活动是否存在
|
||
try:
|
||
# 直接使用原始ID字符串查询
|
||
logger.info(f"尝试查找活动，ID: {campaign_id}")
|
||
campaign = Campaign.objects.raw('SELECT * FROM campaigns WHERE id = %s AND is_active = 1', [campaign_id])[0]
|
||
logger.info(f"找到活动: {campaign.name}, Active: {campaign.is_active}")
|
||
|
||
except IndexError:
|
||
logger.warning(f"找不到ID为 {campaign_id} 的活动")
|
||
return JsonResponse({
|
||
'code': 404,
|
||
'message': f'找不到ID为 {campaign_id} 的活跃营销活动',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
except Exception as e:
|
||
logger.error(f"查询活动时发生错误: {str(e)}")
|
||
return JsonResponse({
|
||
'code': 500,
|
||
'message': f'查询活动时发生错误: {str(e)}',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 先删除该活动下之前绑定的所有达人
|
||
deleted_count = CreatorCampaign.objects.filter(campaign=campaign).delete()[0]
|
||
logger.info(f"已删除活动 {campaign_id} 下的 {deleted_count} 个原有达人关联")
|
||
|
||
# 添加新达人到活动
|
||
added_count = 0
|
||
skipped_count = 0
|
||
added_creators = []
|
||
|
||
for creator_id in creator_ids:
|
||
try:
|
||
# 移除is_active检查
|
||
creator = CreatorProfile.objects.get(id=creator_id)
|
||
|
||
# 创建新的关联
|
||
creator_campaign = CreatorCampaign.objects.create(
|
||
creator=creator,
|
||
campaign=campaign,
|
||
status='pending'
|
||
)
|
||
|
||
added_count += 1
|
||
added_creators.append({
|
||
'id': creator.id,
|
||
'name': creator.name
|
||
})
|
||
except CreatorProfile.DoesNotExist:
|
||
skipped_count += 1
|
||
logger.warning(f"找不到ID为 {creator_id} 的达人")
|
||
|
||
return JsonResponse({
|
||
'code': 200,
|
||
'message': '成功添加达人到活动',
|
||
'data': {
|
||
'campaign': {
|
||
'id': str(campaign.id),
|
||
'name': campaign.name
|
||
},
|
||
'added_creators': added_creators
|
||
}
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
except Exception as e:
|
||
logger.error(f"更新活动达人失败: {e}")
|
||
import traceback
|
||
logger.error(f"详细错误: {traceback.format_exc()}")
|
||
return JsonResponse({
|
||
'code': 500,
|
||
'message': f'更新活动达人失败: {str(e)}',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
|
||
@require_http_methods(["GET"])
|
||
def get_creator_detail(request, creator_id):
|
||
"""获取达人详情信息"""
|
||
try:
|
||
from .models import CreatorProfile
|
||
import json
|
||
|
||
# 查询指定ID的达人信息
|
||
try:
|
||
creator = CreatorProfile.objects.get(id=creator_id)
|
||
except CreatorProfile.DoesNotExist:
|
||
return JsonResponse({
|
||
'code': 404,
|
||
'message': '未找到该达人信息',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 格式化电商等级
|
||
e_commerce_level_formatted = f"L{creator.e_commerce_level}" if creator.e_commerce_level else None
|
||
|
||
# 格式化GMV
|
||
gmv_formatted = f"${creator.gmv}k" if creator.gmv else "$0"
|
||
|
||
# 格式化粉丝数和观看量
|
||
followers_formatted = f"{int(creator.followers / 1000)}k" if creator.followers else "0"
|
||
avg_views_formatted = f"{int(creator.avg_video_views / 1000)}k" if creator.avg_video_views else "0"
|
||
|
||
# 计算相关指标
|
||
gpm = 0
|
||
gmv_per_customer = 0
|
||
|
||
if creator.avg_video_views and creator.avg_video_views > 0:
|
||
if creator.pricing_min:
|
||
try:
|
||
price = float(creator.pricing_min)
|
||
gpm = (price * 1000) / creator.avg_video_views
|
||
gpm = round(gpm, 2)
|
||
except (ValueError, AttributeError):
|
||
pass
|
||
|
||
# 计算每位客户GMV
|
||
if creator.gmv and creator.items_sold and creator.items_sold > 0:
|
||
gmv_per_customer = float(creator.gmv) / float(creator.items_sold)
|
||
gmv_per_customer = round(gmv_per_customer, 2)
|
||
|
||
# 构造详细响应数据
|
||
creator_detail = {
|
||
"creator": {
|
||
"id": creator.id,
|
||
"name": creator.name,
|
||
"avatar": creator.avatar_url,
|
||
"email": creator.email,
|
||
"social_accounts": {
|
||
"instagram": creator.instagram, # 示例数据，实际应从数据库获取
|
||
"tiktok": creator.tiktok_link # 示例链接
|
||
},
|
||
"location": creator.location,
|
||
"live_schedule": creator.live_schedule
|
||
},
|
||
"metrics": {
|
||
"e_commerce_level": e_commerce_level_formatted,
|
||
"exposure_level": creator.exposure_level,
|
||
"followers": followers_formatted,
|
||
"actual_followers": creator.followers,
|
||
"gmv": gmv_formatted,
|
||
"actual_gmv": creator.gmv,
|
||
"items_sold": f"{creator.items_sold}",
|
||
"avg_video_views": avg_views_formatted,
|
||
"actual_views": creator.avg_video_views,
|
||
"gpm": f"${gpm}",
|
||
"gmv_per_customer": f"${gmv_per_customer}"
|
||
},
|
||
"business": {
|
||
"category": creator.category,
|
||
"categories": creator.category.split('|') if creator.category and '|' in creator.category else [
|
||
creator.category] if creator.category else [],
|
||
"mcn": creator.mcn or "",
|
||
"pricing": {
|
||
"range": f"${creator.pricing_min}-{creator.pricing_max}" if creator.pricing_min is not None and creator.pricing_max is not None else None,
|
||
"package": creator.pricing_package
|
||
},
|
||
"collab_count": creator.collab_count,
|
||
"latest_collab": creator.latest_collab,
|
||
"e_commerce_platforms": creator.e_commerce_platforms or []
|
||
},
|
||
"analytics": {
|
||
"gmv_by_channel": creator.gmv_by_channel,
|
||
"gmv_by_category": creator.gmv_by_category
|
||
}
|
||
}
|
||
|
||
# 返回响应
|
||
return JsonResponse({
|
||
'code': 200,
|
||
'message': '获取成功',
|
||
'data': creator_detail
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
except Exception as e:
|
||
logger.error(f"获取达人详情失败: {e}")
|
||
import traceback
|
||
logger.error(f"详细错误: {traceback.format_exc()}")
|
||
return JsonResponse({
|
||
'code': 500,
|
||
'message': f'获取达人详情失败: {str(e)}',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
|
||
@csrf_exempt
|
||
@require_http_methods(["POST"])
|
||
def update_creator_detail(request):
|
||
"""更新达人详细信息"""
|
||
try:
|
||
from .models import CreatorProfile
|
||
import json
|
||
|
||
data = json.loads(request.body)
|
||
|
||
# 必需的基本信息
|
||
creator_id = data.get('creator_id')
|
||
|
||
if not creator_id:
|
||
return JsonResponse({
|
||
'code': 400,
|
||
'message': '缺少必要参数：creator_id',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 查询是否已存在该creator
|
||
try:
|
||
creator = CreatorProfile.objects.get(id=creator_id)
|
||
except CreatorProfile.DoesNotExist:
|
||
return JsonResponse({
|
||
'code': 404,
|
||
'message': f'找不到ID为 {creator_id} 的达人信息',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 更新基础信息
|
||
creator.email = data.get('email', creator.email)
|
||
creator.instagram = data.get('instagram', creator.instagram)
|
||
creator.tiktok_link = data.get('tiktok_link', creator.tiktok_link)
|
||
creator.location = data.get('location', creator.location)
|
||
creator.live_schedule = data.get('live_schedule', creator.live_schedule)
|
||
creator.mcn = data.get('mcn', creator.mcn)
|
||
|
||
# 更新分析数据
|
||
if 'gmv_by_channel' in data:
|
||
creator.gmv_by_channel = data.get('gmv_by_channel')
|
||
|
||
if 'gmv_by_category' in data:
|
||
creator.gmv_by_category = data.get('gmv_by_category')
|
||
|
||
# 保存更新
|
||
creator.save()
|
||
|
||
return JsonResponse({
|
||
'code': 200,
|
||
'message': '达人详细信息已更新',
|
||
'data': {
|
||
'creator_id': creator.id,
|
||
'name': creator.name
|
||
}
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
except Exception as e:
|
||
logger.error(f"更新达人详细信息失败: {e}")
|
||
import traceback
|
||
logger.error(f"详细错误: {traceback.format_exc()}")
|
||
return JsonResponse({
|
||
'code': 500,
|
||
'message': f'更新达人详细信息失败: {str(e)}',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
|
||
# 获取特定达人与各品牌的合作详情
|
||
@csrf_exempt
|
||
@require_http_methods(["GET"])
|
||
def get_creator_brand_campaigns(request, creator_id=None):
|
||
"""获取特定达人与各品牌的合作详情"""
|
||
try:
|
||
from .models import CreatorProfile, BrandCampaign, CreatorCampaign, Campaign
|
||
|
||
# 检查creator_id是否提供
|
||
if not creator_id:
|
||
creator_id = request.GET.get('creator_id')
|
||
if not creator_id:
|
||
return JsonResponse({
|
||
'code': 400,
|
||
'message': '缺少必要参数: creator_id',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 查询达人信息
|
||
try:
|
||
creator = CreatorProfile.objects.get(id=creator_id)
|
||
except CreatorProfile.DoesNotExist:
|
||
return JsonResponse({
|
||
'code': 404,
|
||
'message': f'未找到ID为 {creator_id} 的达人',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 获取分页参数
|
||
page = int(request.GET.get('page', 1))
|
||
page_size = int(request.GET.get('page_size', 10))
|
||
|
||
# 查询该达人参与的所有活动
|
||
creator_campaigns = CreatorCampaign.objects.filter(
|
||
creator_id=creator_id
|
||
).select_related('campaign')
|
||
|
||
# 获取所有相关活动的ID
|
||
campaign_ids = [cc.campaign_id for cc in creator_campaigns]
|
||
|
||
# 查询所有相关的BrandCampaign记录
|
||
# 优先查找已关联Campaign的品牌活动记录
|
||
brand_campaigns_with_campaign = BrandCampaign.objects.filter(
|
||
campaign__id__in=campaign_ids
|
||
).select_related('campaign')
|
||
|
||
# 如果找不到直接关联的记录，尝试使用品牌ID匹配
|
||
brands_needed = []
|
||
if not brand_campaigns_with_campaign.exists():
|
||
# 获取所有相关Campaign的品牌首字母
|
||
campaigns = Campaign.objects.filter(id__in=campaign_ids)
|
||
brands_needed = [campaign.brand[:1].upper() for campaign in campaigns if campaign.brand]
|
||
|
||
# 合并品牌活动数据
|
||
campaign_list = []
|
||
|
||
# 处理有Campaign关联的BrandCampaign记录
|
||
for brand_campaign in brand_campaigns_with_campaign:
|
||
# 查找对应的CreatorCampaign记录获取状态
|
||
creator_campaign = next(
|
||
(cc for cc in creator_campaigns if cc.campaign_id == brand_campaign.campaign_id),
|
||
None
|
||
)
|
||
|
||
if creator_campaign:
|
||
campaign_data = {
|
||
"brand": {
|
||
"id": brand_campaign.brand_id,
|
||
"name": brand_campaign.brand_name,
|
||
"color": brand_campaign.brand_color
|
||
},
|
||
"pricing_detail": brand_campaign.pricing_detail,
|
||
"start_date": brand_campaign.start_date.strftime('%m/%d/%Y'),
|
||
"end_date": brand_campaign.end_date.strftime('%m/%d/%Y'),
|
||
"status": creator_campaign.status, # 使用CreatorCampaign中的状态
|
||
"gmv_achieved": brand_campaign.gmv_achieved,
|
||
"views_achieved": brand_campaign.views_achieved,
|
||
"video_link": brand_campaign.video_link,
|
||
"campaign_id": brand_campaign.campaign.id if brand_campaign.campaign else None,
|
||
"campaign_name": brand_campaign.campaign.name if brand_campaign.campaign else None
|
||
}
|
||
campaign_list.append(campaign_data)
|
||
|
||
# 如果通过Campaign关联找不到数据，尝试使用品牌ID匹配
|
||
if not campaign_list and brands_needed:
|
||
brand_campaigns_by_id = BrandCampaign.objects.filter(brand_id__in=brands_needed)
|
||
|
||
for brand_campaign in brand_campaigns_by_id:
|
||
# 查找相关的Campaign和CreatorCampaign
|
||
matching_campaign = next(
|
||
(c for c in campaigns if c.brand and c.brand[:1].upper() == brand_campaign.brand_id),
|
||
None
|
||
)
|
||
|
||
if matching_campaign:
|
||
creator_campaign = next(
|
||
(cc for cc in creator_campaigns if cc.campaign_id == matching_campaign.id),
|
||
None
|
||
)
|
||
|
||
if creator_campaign:
|
||
campaign_data = {
|
||
"brand": {
|
||
"id": brand_campaign.brand_id,
|
||
"name": brand_campaign.brand_name,
|
||
"color": brand_campaign.brand_color
|
||
},
|
||
"pricing_detail": brand_campaign.pricing_detail,
|
||
"start_date": brand_campaign.start_date.strftime('%m/%d/%Y'),
|
||
"end_date": brand_campaign.end_date.strftime('%m/%d/%Y'),
|
||
"status": creator_campaign.status,
|
||
"gmv_achieved": brand_campaign.gmv_achieved,
|
||
"views_achieved": brand_campaign.views_achieved,
|
||
"video_link": brand_campaign.video_link,
|
||
"campaign_id": matching_campaign.id,
|
||
"campaign_name": matching_campaign.name
|
||
}
|
||
campaign_list.append(campaign_data)
|
||
|
||
# 如果仍找不到数据，则直接为每个CreatorCampaign创建一个默认的活动数据
|
||
if not campaign_list:
|
||
# 为每个CreatorCampaign创建一个默认的活动数据
|
||
for cc in creator_campaigns:
|
||
campaign = cc.campaign
|
||
brand_id = campaign.brand[:1].upper() if campaign.brand else 'U'
|
||
|
||
# 为不同品牌设置不同颜色
|
||
colors = {
|
||
'U': '#E74694', # 粉色
|
||
'R': '#17CDCB', # 青色
|
||
'X': '#6E41BF', # 紫色
|
||
'Q': '#F9975D', # 橙色
|
||
'A': '#B4B4B4', # 灰色
|
||
'M': '#333333', # 黑色
|
||
}
|
||
|
||
campaign_data = {
|
||
"brand": {
|
||
"id": brand_id,
|
||
"name": campaign.brand or "brand",
|
||
"color": colors.get(brand_id, '#000000')
|
||
},
|
||
"pricing_detail": "$80", # 默认价格
|
||
"start_date": "05/31/2024", # 默认日期
|
||
"end_date": "05/29/2024", # 默认日期
|
||
"status": cc.status,
|
||
"gmv_achieved": "$120", # 默认GMV
|
||
"views_achieved": "650", # 默认观看量
|
||
"video_link": f"https://example.com/video/{campaign.id}",
|
||
"campaign_id": campaign.id,
|
||
"campaign_name": campaign.name
|
||
}
|
||
campaign_list.append(campaign_data)
|
||
|
||
# 计算总数据量
|
||
total_count = len(campaign_list)
|
||
|
||
# 计算分页
|
||
start = (page - 1) * page_size
|
||
end = min(start + page_size, total_count)
|
||
|
||
# 切片数据
|
||
paged_campaigns = campaign_list[start:end]
|
||
|
||
# 计算总页数
|
||
total_pages = (total_count + page_size - 1) // page_size
|
||
|
||
# 构造分页信息
|
||
pagination = {
|
||
"current_page": page,
|
||
"total_pages": total_pages,
|
||
"total_count": total_count,
|
||
"has_next": page < total_pages,
|
||
"has_prev": page > 1
|
||
}
|
||
|
||
# 构造创作者基本信息
|
||
creator_info = {
|
||
"id": creator.id,
|
||
"name": creator.name,
|
||
"avatar": creator.avatar_url,
|
||
"category": creator.category,
|
||
"exposure_level": creator.exposure_level,
|
||
}
|
||
|
||
return JsonResponse({
|
||
'code': 200,
|
||
'message': '获取成功',
|
||
'data': paged_campaigns,
|
||
'pagination': pagination,
|
||
'creator': creator_info
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
except Exception as e:
|
||
logger.error(f"获取达人品牌合作详情失败: {e}")
|
||
import traceback
|
||
logger.error(f"详细错误: {traceback.format_exc()}")
|
||
return JsonResponse({
|
||
'code': 500,
|
||
'message': f'获取达人品牌合作详情失败: {str(e)}',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
|
||
# 获取创作者的协作指标、视频和直播指标数据
|
||
@csrf_exempt
|
||
@require_http_methods(["GET"])
|
||
def get_creator_metrics(request, creator_id):
|
||
"""获取创作者的协作指标、视频和直播指标数据"""
|
||
try:
|
||
from .models import CreatorProfile, CollaborationMetrics, VideoMetrics, LiveMetrics
|
||
import json
|
||
from datetime import datetime
|
||
|
||
# 检查creator_id是否提供
|
||
if not creator_id:
|
||
return JsonResponse({
|
||
'code': 400,
|
||
'message': '缺少必要参数: creator_id',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 获取时间范围参数，格式为：yyyy-mm-dd
|
||
start_date_str = request.GET.get('start_date')
|
||
end_date_str = request.GET.get('end_date')
|
||
|
||
try:
|
||
# 查询创作者信息
|
||
creator = CreatorProfile.objects.get(id=creator_id)
|
||
except CreatorProfile.DoesNotExist:
|
||
return JsonResponse({
|
||
'code': 404,
|
||
'message': f'未找到ID为 {creator_id} 的创作者',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 构建查询条件字典
|
||
filter_kwargs = {'creator': creator}
|
||
|
||
# 如果提供了时间范围，添加到过滤条件
|
||
if start_date_str and end_date_str:
|
||
try:
|
||
start_date = datetime.strptime(start_date_str, '%Y-%m-%d').date()
|
||
end_date = datetime.strptime(end_date_str, '%Y-%m-%d').date()
|
||
filter_kwargs.update({
|
||
'start_date__lte': end_date, # 开始日期早于或等于请求的结束日期
|
||
'end_date__gte': start_date # 结束日期晚于或等于请求的开始日期
|
||
})
|
||
except ValueError:
|
||
return JsonResponse({
|
||
'code': 400,
|
||
'message': '日期格式不正确，请使用YYYY-MM-DD格式',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 查询协作指标
|
||
try:
|
||
collab_metrics = CollaborationMetrics.objects.filter(**filter_kwargs).order_by('-end_date').first()
|
||
except Exception as e:
|
||
logger.error(f"查询协作指标出错: {e}")
|
||
collab_metrics = None
|
||
|
||
# 查询视频指标 - 普通视频
|
||
try:
|
||
video_metrics = VideoMetrics.objects.filter(video_type='regular', **filter_kwargs).order_by(
|
||
'-end_date').first()
|
||
except Exception as e:
|
||
logger.error(f"查询普通视频指标出错: {e}")
|
||
video_metrics = None
|
||
|
||
# 查询视频指标 - 可购物视频
|
||
try:
|
||
shoppable_video_metrics = VideoMetrics.objects.filter(video_type='shoppable', **filter_kwargs).order_by(
|
||
'-end_date').first()
|
||
except Exception as e:
|
||
logger.error(f"查询可购物视频指标出错: {e}")
|
||
shoppable_video_metrics = None
|
||
|
||
# 查询直播指标 - 普通直播
|
||
try:
|
||
live_metrics = LiveMetrics.objects.filter(live_type='regular', **filter_kwargs).order_by(
|
||
'-end_date').first()
|
||
except Exception as e:
|
||
logger.error(f"查询普通直播指标出错: {e}")
|
||
live_metrics = None
|
||
|
||
# 查询直播指标 - 可购物直播
|
||
try:
|
||
shoppable_live_metrics = LiveMetrics.objects.filter(live_type='shoppable', **filter_kwargs).order_by(
|
||
'-end_date').first()
|
||
except Exception as e:
|
||
logger.error(f"查询可购物直播指标出错: {e}")
|
||
shoppable_live_metrics = None
|
||
|
||
# 构建响应数据
|
||
metrics_data = {
|
||
'collaboration_metrics': None,
|
||
'video': None,
|
||
'shoppable_video': None,
|
||
'live': None,
|
||
'shoppable_live': None
|
||
}
|
||
|
||
# 填充协作指标数据
|
||
if collab_metrics:
|
||
metrics_data['collaboration_metrics'] = {
|
||
'avg_commission_rate': f"{collab_metrics.avg_commission_rate}%",
|
||
'products_count': collab_metrics.products_count,
|
||
'brand_collaborations': collab_metrics.brand_collaborations,
|
||
'product_price': f"${collab_metrics.min_product_price} - ${collab_metrics.max_product_price}",
|
||
'date_range': f"{collab_metrics.start_date.strftime('%b %d, %Y')} - {collab_metrics.end_date.strftime('%b %d, %Y')}"
|
||
}
|
||
|
||
# 填充普通视频指标数据
|
||
if video_metrics:
|
||
metrics_data['video'] = {
|
||
'gpm': f"${video_metrics.gpm}",
|
||
'videos_count': video_metrics.videos_count,
|
||
'avg_views': f"{float(video_metrics.avg_views) / 1000}k" if video_metrics.avg_views >= 1000 else f"{float(video_metrics.avg_views)}",
|
||
'avg_engagement': f"{video_metrics.avg_engagement}%",
|
||
'avg_likes': video_metrics.avg_likes,
|
||
'date_range': f"{video_metrics.start_date.strftime('%b %d, %Y')} - {video_metrics.end_date.strftime('%b %d, %Y')}"
|
||
}
|
||
|
||
# 填充可购物视频指标数据
|
||
if shoppable_video_metrics:
|
||
metrics_data['shoppable_video'] = {
|
||
'gpm': f"${shoppable_video_metrics.gpm}",
|
||
'videos_count': shoppable_video_metrics.videos_count,
|
||
'avg_views': f"{float(shoppable_video_metrics.avg_views) / 1000}k" if shoppable_video_metrics.avg_views >= 1000 else f"{float(shoppable_video_metrics.avg_views)}",
|
||
'avg_engagement': f"{shoppable_video_metrics.avg_engagement}%",
|
||
'avg_likes': shoppable_video_metrics.avg_likes,
|
||
'date_range': f"{shoppable_video_metrics.start_date.strftime('%b %d, %Y')} - {shoppable_video_metrics.end_date.strftime('%b %d, %Y')}"
|
||
}
|
||
|
||
# 填充普通直播指标数据
|
||
if live_metrics:
|
||
metrics_data['live'] = {
|
||
'gpm': f"${live_metrics.gpm}",
|
||
'lives_count': live_metrics.lives_count,
|
||
'avg_views': f"{float(live_metrics.avg_views) / 1000}k" if live_metrics.avg_views >= 1000 else f"{float(live_metrics.avg_views)}",
|
||
'avg_engagement': f"{live_metrics.avg_engagement}%",
|
||
'avg_likes': live_metrics.avg_likes,
|
||
'date_range': f"{live_metrics.start_date.strftime('%b %d, %Y')} - {live_metrics.end_date.strftime('%b %d, %Y')}"
|
||
}
|
||
|
||
# 填充可购物直播指标数据
|
||
if shoppable_live_metrics:
|
||
metrics_data['shoppable_live'] = {
|
||
'gpm': f"${shoppable_live_metrics.gpm}",
|
||
'lives_count': shoppable_live_metrics.lives_count,
|
||
'avg_views': f"{float(shoppable_live_metrics.avg_views) / 1000}k" if shoppable_live_metrics.avg_views >= 1000 else f"{float(shoppable_live_metrics.avg_views)}",
|
||
'avg_engagement': f"{shoppable_live_metrics.avg_engagement}%",
|
||
'avg_likes': shoppable_live_metrics.avg_likes,
|
||
'date_range': f"{shoppable_live_metrics.start_date.strftime('%b %d, %Y')} - {shoppable_live_metrics.end_date.strftime('%b %d, %Y')}"
|
||
}
|
||
|
||
# 返回响应
|
||
return JsonResponse({
|
||
'code': 200,
|
||
'message': '获取成功',
|
||
'data': metrics_data
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
except Exception as e:
|
||
logger.error(f"获取创作者指标数据失败: {e}")
|
||
import traceback
|
||
logger.error(f"详细错误: {traceback.format_exc()}")
|
||
return JsonResponse({
|
||
'code': 500,
|
||
'message': f'获取创作者指标数据失败: {str(e)}',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
|
||
# 更新创作者的指标数据
|
||
@csrf_exempt
|
||
@require_http_methods(["POST"])
|
||
def update_creator_metrics(request):
|
||
"""更新创作者的指标数据"""
|
||
try:
|
||
from .models import CreatorProfile, CollaborationMetrics, VideoMetrics, LiveMetrics
|
||
import json
|
||
from datetime import datetime
|
||
|
||
data = json.loads(request.body)
|
||
|
||
# 获取必要参数
|
||
creator_id = data.get('creator_id')
|
||
metrics_type = data.get('metrics_type') # collaboration, video, shoppable_video, live, shoppable_live
|
||
metrics_data = data.get('metrics_data', {})
|
||
|
||
if not creator_id or not metrics_type or not metrics_data:
|
||
return JsonResponse({
|
||
'code': 400,
|
||
'message': '缺少必要参数: creator_id, metrics_type 或 metrics_data',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 查询创作者信息
|
||
try:
|
||
creator = CreatorProfile.objects.get(id=creator_id)
|
||
except CreatorProfile.DoesNotExist:
|
||
return JsonResponse({
|
||
'code': 404,
|
||
'message': f'未找到ID为 {creator_id} 的创作者',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 获取时间范围
|
||
start_date_str = metrics_data.get('start_date')
|
||
end_date_str = metrics_data.get('end_date')
|
||
|
||
if not start_date_str or not end_date_str:
|
||
return JsonResponse({
|
||
'code': 400,
|
||
'message': '缺少必要参数: start_date 或 end_date',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
try:
|
||
start_date = datetime.strptime(start_date_str, '%Y-%m-%d').date()
|
||
end_date = datetime.strptime(end_date_str, '%Y-%m-%d').date()
|
||
except ValueError:
|
||
return JsonResponse({
|
||
'code': 400,
|
||
'message': '日期格式不正确，请使用YYYY-MM-DD格式',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 根据metrics_type处理不同类型的指标数据
|
||
if metrics_type == 'collaboration':
|
||
# 处理协作指标数据
|
||
# 从metrics_data中提取所需字段
|
||
avg_commission_rate = metrics_data.get('avg_commission_rate')
|
||
if isinstance(avg_commission_rate, str) and '%' in avg_commission_rate:
|
||
avg_commission_rate = float(avg_commission_rate.replace('%', ''))
|
||
|
||
products_count = int(metrics_data.get('products_count', 0))
|
||
brand_collaborations = int(metrics_data.get('brand_collaborations', 0))
|
||
|
||
# 处理价格范围
|
||
product_price = metrics_data.get('product_price', '$0 - $0')
|
||
if isinstance(product_price, str) and ' - ' in product_price:
|
||
price_parts = product_price.split(' - ')
|
||
min_price = float(price_parts[0].replace('$', ''))
|
||
max_price = float(price_parts[1].replace('$', ''))
|
||
else:
|
||
min_price = 0
|
||
max_price = 0
|
||
|
||
# 更新或创建协作指标记录
|
||
collab_metrics, created = CollaborationMetrics.objects.update_or_create(
|
||
creator=creator,
|
||
start_date=start_date,
|
||
end_date=end_date,
|
||
defaults={
|
||
'avg_commission_rate': avg_commission_rate,
|
||
'products_count': products_count,
|
||
'brand_collaborations': brand_collaborations,
|
||
'min_product_price': min_price,
|
||
'max_product_price': max_price
|
||
}
|
||
)
|
||
|
||
return JsonResponse({
|
||
'code': 200,
|
||
'message': '协作指标数据已更新',
|
||
'data': {
|
||
'created': created,
|
||
'metrics_id': collab_metrics.id
|
||
}
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
elif metrics_type in ['video', 'shoppable_video']:
|
||
# 处理视频指标数据
|
||
video_type = 'regular' if metrics_type == 'video' else 'shoppable'
|
||
|
||
# 从metrics_data中提取所需字段
|
||
gpm = metrics_data.get('gpm', '$0')
|
||
if isinstance(gpm, str) and '$' in gpm:
|
||
gpm = float(gpm.replace('$', ''))
|
||
|
||
videos_count = int(metrics_data.get('videos_count', 0))
|
||
|
||
avg_views = metrics_data.get('avg_views', '0')
|
||
if isinstance(avg_views, str) and 'k' in avg_views:
|
||
avg_views = float(avg_views.replace('k', '')) * 1000
|
||
else:
|
||
avg_views = float(avg_views)
|
||
|
||
avg_engagement = metrics_data.get('avg_engagement', '0%')
|
||
if isinstance(avg_engagement, str) and '%' in avg_engagement:
|
||
avg_engagement = float(avg_engagement.replace('%', ''))
|
||
|
||
avg_likes = int(metrics_data.get('avg_likes', 0))
|
||
|
||
# 更新或创建视频指标记录
|
||
video_metrics, created = VideoMetrics.objects.update_or_create(
|
||
creator=creator,
|
||
video_type=video_type,
|
||
start_date=start_date,
|
||
end_date=end_date,
|
||
defaults={
|
||
'gpm': gpm,
|
||
'videos_count': videos_count,
|
||
'avg_views': avg_views,
|
||
'avg_engagement': avg_engagement,
|
||
'avg_likes': avg_likes
|
||
}
|
||
)
|
||
|
||
return JsonResponse({
|
||
'code': 200,
|
||
'message': f'{metrics_type}指标数据已更新',
|
||
'data': {
|
||
'created': created,
|
||
'metrics_id': video_metrics.id
|
||
}
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
elif metrics_type in ['live', 'shoppable_live']:
|
||
# 处理直播指标数据
|
||
live_type = 'regular' if metrics_type == 'live' else 'shoppable'
|
||
|
||
# 从metrics_data中提取所需字段
|
||
gpm = metrics_data.get('gpm', '$0')
|
||
if isinstance(gpm, str) and '$' in gpm:
|
||
gpm = float(gpm.replace('$', ''))
|
||
|
||
lives_count = int(metrics_data.get('lives_count', 0))
|
||
|
||
avg_views = metrics_data.get('avg_views', '0')
|
||
if isinstance(avg_views, str) and 'k' in avg_views:
|
||
avg_views = float(avg_views.replace('k', '')) * 1000
|
||
else:
|
||
avg_views = float(avg_views)
|
||
|
||
avg_engagement = metrics_data.get('avg_engagement', '0%')
|
||
if isinstance(avg_engagement, str) and '%' in avg_engagement:
|
||
avg_engagement = float(avg_engagement.replace('%', ''))
|
||
|
||
avg_likes = int(metrics_data.get('avg_likes', 0))
|
||
|
||
# 更新或创建直播指标记录
|
||
live_metrics, created = LiveMetrics.objects.update_or_create(
|
||
creator=creator,
|
||
live_type=live_type,
|
||
start_date=start_date,
|
||
end_date=end_date,
|
||
defaults={
|
||
'gpm': gpm,
|
||
'lives_count': lives_count,
|
||
'avg_views': avg_views,
|
||
'avg_engagement': avg_engagement,
|
||
'avg_likes': avg_likes
|
||
}
|
||
)
|
||
|
||
return JsonResponse({
|
||
'code': 200,
|
||
'message': f'{metrics_type}指标数据已更新',
|
||
'data': {
|
||
'created': created,
|
||
'metrics_id': live_metrics.id
|
||
}
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
else:
|
||
return JsonResponse({
|
||
'code': 400,
|
||
'message': f'不支持的指标类型: {metrics_type}',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
except Exception as e:
|
||
logger.error(f"更新创作者指标数据失败: {e}")
|
||
import traceback
|
||
logger.error(f"详细错误: {traceback.format_exc()}")
|
||
return JsonResponse({
|
||
'code': 500,
|
||
'message': f'更新创作者指标数据失败: {str(e)}',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
|
||
@csrf_exempt
|
||
@require_http_methods(["GET"])
|
||
def get_creator_followers_metrics(request, creator_id=None):
|
||
"""获取创作者的粉丝统计指标数据"""
|
||
try:
|
||
from .models import CreatorProfile, FollowerMetrics
|
||
import json
|
||
from datetime import datetime
|
||
|
||
# 检查creator_id是否提供
|
||
if not creator_id:
|
||
creator_id = request.GET.get('creator_id')
|
||
if not creator_id:
|
||
return JsonResponse({
|
||
'code': 400,
|
||
'message': '缺少必要参数: creator_id',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 查询创作者信息
|
||
try:
|
||
creator = CreatorProfile.objects.get(id=creator_id)
|
||
except CreatorProfile.DoesNotExist:
|
||
return JsonResponse({
|
||
'code': 404,
|
||
'message': f'未找到ID为 {creator_id} 的创作者',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 获取最新的粉丝统计数据
|
||
follower_metrics = FollowerMetrics.objects.filter(
|
||
creator=creator
|
||
).order_by('-end_date').first()
|
||
|
||
if not follower_metrics:
|
||
# 如果没有数据，返回示例数据
|
||
follower_data = {
|
||
'gender': {
|
||
'female': 0,
|
||
'male': 0
|
||
},
|
||
'age': {
|
||
'18-24': 0,
|
||
'25-34': 0,
|
||
'35-44': 0,
|
||
'45-54': 0,
|
||
'55+': 0
|
||
},
|
||
'locations': {
|
||
'TX': 0,
|
||
'FL': 0,
|
||
'NY': 0,
|
||
'GE': 0,
|
||
'CA': 0
|
||
},
|
||
'date_range': {
|
||
'start_date': '2025-03-29',
|
||
'end_date': '2025-04-28'
|
||
}
|
||
}
|
||
else:
|
||
# 构建粉丝统计数据
|
||
follower_data = {
|
||
'gender': {
|
||
'female': follower_metrics.female_percentage,
|
||
'male': follower_metrics.male_percentage
|
||
},
|
||
'age': {
|
||
'18-24': follower_metrics.age_18_24_percentage,
|
||
'25-34': follower_metrics.age_25_34_percentage,
|
||
'35-44': follower_metrics.age_35_44_percentage,
|
||
'45-54': follower_metrics.age_45_54_percentage,
|
||
'55+': follower_metrics.age_55_plus_percentage
|
||
},
|
||
'locations': follower_metrics.location_data,
|
||
'date_range': {
|
||
'start_date': follower_metrics.start_date.strftime('%Y-%m-%d'),
|
||
'end_date': follower_metrics.end_date.strftime('%Y-%m-%d')
|
||
}
|
||
}
|
||
|
||
return JsonResponse({
|
||
'code': 200,
|
||
'message': '获取成功',
|
||
'data': follower_data
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
except Exception as e:
|
||
logger.error(f"获取创作者粉丝指标数据失败: {e}")
|
||
import traceback
|
||
logger.error(f"详细错误: {traceback.format_exc()}")
|
||
return JsonResponse({
|
||
'code': 500,
|
||
'message': f'获取创作者粉丝指标数据失败: {str(e)}',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
|
||
@csrf_exempt
|
||
@require_http_methods(["GET"])
|
||
def get_creator_trends(request, creator_id=None):
|
||
"""获取创作者的趋势指标数据"""
|
||
try:
|
||
from .models import CreatorProfile, TrendMetrics
|
||
import json
|
||
from datetime import datetime, timedelta
|
||
|
||
# 检查creator_id是否提供
|
||
if not creator_id:
|
||
creator_id = request.GET.get('creator_id')
|
||
if not creator_id:
|
||
return JsonResponse({
|
||
'code': 400,
|
||
'message': '缺少必要参数: creator_id',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 获取时间范围参数，格式为：yyyy-mm-dd
|
||
start_date_str = request.GET.get('start_date')
|
||
end_date_str = request.GET.get('end_date')
|
||
|
||
# 查询创作者信息
|
||
try:
|
||
creator = CreatorProfile.objects.get(id=creator_id)
|
||
except CreatorProfile.DoesNotExist:
|
||
return JsonResponse({
|
||
'code': 404,
|
||
'message': f'未找到ID为 {creator_id} 的创作者',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 如果提供了时间范围，进行过滤
|
||
if start_date_str and end_date_str:
|
||
try:
|
||
start_date = datetime.strptime(start_date_str, '%Y-%m-%d').date()
|
||
end_date = datetime.strptime(end_date_str, '%Y-%m-%d').date()
|
||
trends = TrendMetrics.objects.filter(
|
||
creator=creator,
|
||
date__gte=start_date,
|
||
date__lte=end_date
|
||
).order_by('date')
|
||
except ValueError:
|
||
return JsonResponse({
|
||
'code': 400,
|
||
'message': '日期格式不正确，请使用YYYY-MM-DD格式',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
else:
|
||
# 默认获取最近30天的数据
|
||
end_date = datetime.now().date()
|
||
start_date = end_date - timedelta(days=30)
|
||
trends = TrendMetrics.objects.filter(
|
||
creator=creator,
|
||
date__gte=start_date,
|
||
date__lte=end_date
|
||
).order_by('date')
|
||
|
||
# 如果没有数据，返回示例数据
|
||
if not trends.exists():
|
||
# 生成示例数据 - 模拟30天的趋势
|
||
example_date_range = [
|
||
(datetime.now().date() - timedelta(days=30 - i)).strftime('%Y-%m-%d')
|
||
for i in range(31)
|
||
]
|
||
|
||
# 设定随机的起始值和波动
|
||
import random
|
||
base_gmv = random.uniform(500, 3000)
|
||
base_items_sold = random.randint(500, 2000)
|
||
base_followers = random.randint(1000, 3000)
|
||
base_views = random.randint(1000, 3000)
|
||
base_engagement = random.uniform(1.0, 3.0)
|
||
|
||
# 生成模拟数据
|
||
trend_data = {
|
||
'gmv': [],
|
||
'items_sold': [],
|
||
'followers': [],
|
||
'video_views': [],
|
||
'engagement_rate': [],
|
||
'dates': example_date_range
|
||
}
|
||
|
||
for i in range(31):
|
||
# 添加一些随机波动
|
||
gmv_value = base_gmv + random.uniform(-base_gmv * 0.2, base_gmv * 0.3)
|
||
items_value = int(base_items_sold + random.uniform(-base_items_sold * 0.15, base_items_sold * 0.25))
|
||
followers_value = int(base_followers + random.uniform(-base_followers * 0.05, base_followers * 0.1))
|
||
views_value = int(base_views + random.uniform(-base_views * 0.2, base_views * 0.4))
|
||
engagement_value = base_engagement + random.uniform(-base_engagement * 0.1, base_engagement * 0.15)
|
||
|
||
# 确保值不小于0
|
||
trend_data['gmv'].append(max(0, gmv_value))
|
||
trend_data['items_sold'].append(max(0, items_value))
|
||
trend_data['followers'].append(max(0, followers_value))
|
||
trend_data['video_views'].append(max(0, views_value))
|
||
trend_data['engagement_rate'].append(max(0, engagement_value))
|
||
|
||
# 更新基准值，使数据有一定的连续性
|
||
base_gmv = gmv_value
|
||
base_items_sold = items_value
|
||
base_followers = followers_value
|
||
base_views = views_value
|
||
base_engagement = engagement_value
|
||
|
||
trend_data['date_range'] = {
|
||
'start_date': example_date_range[0],
|
||
'end_date': example_date_range[-1]
|
||
}
|
||
else:
|
||
# 从数据库构建趋势数据
|
||
trend_data = {
|
||
'gmv': [],
|
||
'items_sold': [],
|
||
'followers': [],
|
||
'video_views': [],
|
||
'engagement_rate': [],
|
||
'dates': []
|
||
}
|
||
|
||
for trend in trends:
|
||
trend_data['gmv'].append(trend.gmv)
|
||
trend_data['items_sold'].append(trend.items_sold)
|
||
trend_data['followers'].append(trend.followers_count)
|
||
trend_data['video_views'].append(trend.video_views)
|
||
trend_data['engagement_rate'].append(trend.engagement_rate)
|
||
trend_data['dates'].append(trend.date.strftime('%Y-%m-%d'))
|
||
|
||
trend_data['date_range'] = {
|
||
'start_date': trend_data['dates'][0] if trend_data['dates'] else start_date.strftime('%Y-%m-%d'),
|
||
'end_date': trend_data['dates'][-1] if trend_data['dates'] else end_date.strftime('%Y-%m-%d')
|
||
}
|
||
|
||
return JsonResponse({
|
||
'code': 200,
|
||
'message': '获取成功',
|
||
'data': trend_data
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
except Exception as e:
|
||
logger.error(f"获取创作者趋势指标数据失败: {e}")
|
||
import traceback
|
||
logger.error(f"详细错误: {traceback.format_exc()}")
|
||
return JsonResponse({
|
||
'code': 500,
|
||
'message': f'获取创作者趋势指标数据失败: {str(e)}',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
|
||
@csrf_exempt
|
||
@require_http_methods(["POST"])
|
||
def update_creator_followers(request):
|
||
"""更新创作者的粉丝统计数据"""
|
||
try:
|
||
from .models import CreatorProfile, FollowerMetrics
|
||
import json
|
||
from datetime import datetime
|
||
|
||
data = json.loads(request.body)
|
||
|
||
# 获取必要参数
|
||
creator_id = data.get('creator_id')
|
||
follower_data = data.get('follower_data', {})
|
||
|
||
if not creator_id or not follower_data:
|
||
return JsonResponse({
|
||
'code': 400,
|
||
'message': '缺少必要参数: creator_id 或 follower_data',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 查询创作者信息
|
||
try:
|
||
creator = CreatorProfile.objects.get(id=creator_id)
|
||
except CreatorProfile.DoesNotExist:
|
||
return JsonResponse({
|
||
'code': 404,
|
||
'message': f'未找到ID为 {creator_id} 的创作者',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 从请求中获取日期范围
|
||
date_range = follower_data.get('date_range', {})
|
||
start_date_str = date_range.get('start_date')
|
||
end_date_str = date_range.get('end_date')
|
||
|
||
if not start_date_str or not end_date_str:
|
||
return JsonResponse({
|
||
'code': 400,
|
||
'message': '缺少必要参数: date_range.start_date 或 date_range.end_date',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
try:
|
||
start_date = datetime.strptime(start_date_str, '%Y-%m-%d').date()
|
||
end_date = datetime.strptime(end_date_str, '%Y-%m-%d').date()
|
||
except ValueError:
|
||
return JsonResponse({
|
||
'code': 400,
|
||
'message': '日期格式不正确，请使用YYYY-MM-DD格式',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 提取粉丝性别数据
|
||
gender_data = follower_data.get('gender', {})
|
||
female_percentage = gender_data.get('female', 0)
|
||
male_percentage = gender_data.get('male', 0)
|
||
|
||
# 提取粉丝年龄数据
|
||
age_data = follower_data.get('age', {})
|
||
age_18_24 = age_data.get('18-24', 0)
|
||
age_25_34 = age_data.get('25-34', 0)
|
||
age_35_44 = age_data.get('35-44', 0)
|
||
age_45_54 = age_data.get('45-54', 0)
|
||
age_55_plus = age_data.get('55+', 0)
|
||
|
||
# 提取粉丝地域数据
|
||
location_data = follower_data.get('locations', {})
|
||
|
||
# 更新或创建粉丝统计记录
|
||
follower_metrics, created = FollowerMetrics.objects.update_or_create(
|
||
creator=creator,
|
||
start_date=start_date,
|
||
end_date=end_date,
|
||
defaults={
|
||
'female_percentage': female_percentage,
|
||
'male_percentage': male_percentage,
|
||
'age_18_24_percentage': age_18_24,
|
||
'age_25_34_percentage': age_25_34,
|
||
'age_35_44_percentage': age_35_44,
|
||
'age_45_54_percentage': age_45_54,
|
||
'age_55_plus_percentage': age_55_plus,
|
||
'location_data': location_data
|
||
}
|
||
)
|
||
|
||
return JsonResponse({
|
||
'code': 200,
|
||
'message': '粉丝统计数据已更新',
|
||
'data': {
|
||
'created': created,
|
||
'metrics_id': follower_metrics.id
|
||
}
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
except Exception as e:
|
||
logger.error(f"更新创作者粉丝统计数据失败: {e}")
|
||
import traceback
|
||
logger.error(f"详细错误: {traceback.format_exc()}")
|
||
return JsonResponse({
|
||
'code': 500,
|
||
'message': f'更新创作者粉丝统计数据失败: {str(e)}',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
|
||
@csrf_exempt
|
||
@require_http_methods(["POST"])
|
||
def update_creator_trend(request):
|
||
"""更新创作者的趋势数据"""
|
||
try:
|
||
from .models import CreatorProfile, TrendMetrics
|
||
import json
|
||
from datetime import datetime
|
||
|
||
data = json.loads(request.body)
|
||
|
||
# 获取必要参数
|
||
creator_id = data.get('creator_id')
|
||
trend_date = data.get('date')
|
||
metrics = data.get('metrics', {})
|
||
|
||
if not creator_id or not trend_date or not metrics:
|
||
return JsonResponse({
|
||
'code': 400,
|
||
'message': '缺少必要参数: creator_id, date 或 metrics',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 查询创作者信息
|
||
try:
|
||
creator = CreatorProfile.objects.get(id=creator_id)
|
||
except CreatorProfile.DoesNotExist:
|
||
return JsonResponse({
|
||
'code': 404,
|
||
'message': f'未找到ID为 {creator_id} 的创作者',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 解析日期
|
||
try:
|
||
date_obj = datetime.strptime(trend_date, '%Y-%m-%d').date()
|
||
except ValueError:
|
||
return JsonResponse({
|
||
'code': 400,
|
||
'message': '日期格式不正确，请使用YYYY-MM-DD格式',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 提取指标数据
|
||
gmv = metrics.get('gmv', 0)
|
||
items_sold = metrics.get('items_sold', 0)
|
||
followers_count = metrics.get('followers', 0)
|
||
video_views = metrics.get('video_views', 0)
|
||
engagement_rate = metrics.get('engagement_rate', 0)
|
||
|
||
# 更新或创建趋势记录
|
||
trend_metrics, created = TrendMetrics.objects.update_or_create(
|
||
creator=creator,
|
||
date=date_obj,
|
||
defaults={
|
||
'gmv': gmv,
|
||
'items_sold': items_sold,
|
||
'followers_count': followers_count,
|
||
'video_views': video_views,
|
||
'engagement_rate': engagement_rate
|
||
}
|
||
)
|
||
|
||
return JsonResponse({
|
||
'code': 200,
|
||
'message': '趋势数据已更新',
|
||
'data': {
|
||
'created': created,
|
||
'metrics_id': trend_metrics.id,
|
||
'date': trend_date
|
||
}
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
except Exception as e:
|
||
logger.error(f"更新创作者趋势数据失败: {e}")
|
||
import traceback
|
||
logger.error(f"详细错误: {traceback.format_exc()}")
|
||
return JsonResponse({
|
||
'code': 500,
|
||
'message': f'更新创作者趋势数据失败: {str(e)}',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
|
||
@csrf_exempt
|
||
@require_http_methods(["GET"])
|
||
def get_creator_videos(request, creator_id=None):
|
||
"""获取创作者的视频列表，分为普通视频和带产品视频"""
|
||
try:
|
||
from .models import CreatorProfile, CreatorVideo
|
||
import json
|
||
from datetime import datetime
|
||
|
||
# 检查creator_id是否提供
|
||
if not creator_id:
|
||
creator_id = request.GET.get('creator_id')
|
||
if not creator_id:
|
||
return JsonResponse({
|
||
'code': 400,
|
||
'message': '缺少必要参数: creator_id',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 查询创作者信息
|
||
try:
|
||
creator = CreatorProfile.objects.get(id=creator_id)
|
||
except CreatorProfile.DoesNotExist:
|
||
return JsonResponse({
|
||
'code': 404,
|
||
'message': f'未找到ID为 {creator_id} 的创作者',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 获取分页参数
|
||
page = int(request.GET.get('page', 1))
|
||
page_size = int(request.GET.get('page_size', 6)) # 默认每页6个视频
|
||
|
||
# 计算偏移量
|
||
offset = (page - 1) * page_size
|
||
|
||
# 查询普通视频
|
||
regular_videos = CreatorVideo.objects.filter(
|
||
creator=creator,
|
||
video_type='regular',
|
||
has_product=False
|
||
).order_by('-release_date')[offset:offset + page_size]
|
||
|
||
# 查询带产品视频
|
||
product_videos = CreatorVideo.objects.filter(
|
||
creator=creator,
|
||
video_type='product',
|
||
has_product=True
|
||
).order_by('-release_date')[offset:offset + page_size]
|
||
|
||
# 如果没有找到视频，创建一些示例数据
|
||
if not regular_videos.exists() and not product_videos.exists():
|
||
# 返回示例视频数据
|
||
regular_videos_data = [
|
||
{
|
||
"id": 1,
|
||
"title": "Collagen + Biotin = your beauty routine's new besties. For hair, skin, nails, and join...",
|
||
"thumbnail_url": "#",
|
||
"badge": "red",
|
||
"view_count": 2130,
|
||
"like_count": 20,
|
||
"release_date": "2025-03-31"
|
||
},
|
||
{
|
||
"id": 2,
|
||
"title": "Collagen + Biotin = your beauty routine's new besties. For hair, skin, nails, and join...",
|
||
"thumbnail_url": "#",
|
||
"badge": "red",
|
||
"view_count": 2130,
|
||
"like_count": 20,
|
||
"release_date": "2025-03-31"
|
||
},
|
||
{
|
||
"id": 3,
|
||
"title": "Collagen + Biotin = your beauty routine's new besties. For hair, skin, nails, and join...",
|
||
"thumbnail_url": "#",
|
||
"badge": "gold",
|
||
"view_count": 2130,
|
||
"like_count": 20,
|
||
"release_date": "2025-03-31"
|
||
}
|
||
]
|
||
|
||
product_videos_data = [
|
||
{
|
||
"id": 4,
|
||
"title": "Collagen + Biotin = your beauty routine's new besties. For hair, skin, nails, and join...",
|
||
"thumbnail_url": "#",
|
||
"badge": "red",
|
||
"view_count": 2130,
|
||
"like_count": 20,
|
||
"release_date": "2025-03-31",
|
||
"has_product": True,
|
||
"product_name": "Collagen + Biotin",
|
||
"product_url": "#"
|
||
},
|
||
{
|
||
"id": 5,
|
||
"title": "Collagen + Biotin = your beauty routine's new besties. For hair, skin, nails, and join...",
|
||
"thumbnail_url": "#",
|
||
"badge": "red",
|
||
"view_count": 2130,
|
||
"like_count": 20,
|
||
"release_date": "2025-03-31",
|
||
"has_product": True,
|
||
"product_name": "Collagen + Biotin",
|
||
"product_url": "#"
|
||
},
|
||
{
|
||
"id": 6,
|
||
"title": "Collagen + Biotin = your beauty routine's new besties. For hair, skin, nails, and join...",
|
||
"thumbnail_url": "#",
|
||
"badge": "gold",
|
||
"view_count": 2130,
|
||
"like_count": 20,
|
||
"release_date": "2025-03-31",
|
||
"has_product": True,
|
||
"product_name": "Collagen + Biotin",
|
||
"product_url": "#"
|
||
}
|
||
]
|
||
else:
|
||
# 格式化查询结果
|
||
regular_videos_data = []
|
||
for video in regular_videos:
|
||
regular_videos_data.append({
|
||
"id": video.id,
|
||
"title": video.title,
|
||
"description": video.description,
|
||
"thumbnail_url": video.thumbnail_url,
|
||
"video_url": video.video_url,
|
||
"badge": video.badge,
|
||
"view_count": video.view_count,
|
||
"like_count": video.like_count,
|
||
"comment_count": video.comment_count,
|
||
"release_date": video.release_date.strftime("%d.%m.%Y")
|
||
})
|
||
|
||
product_videos_data = []
|
||
for video in product_videos:
|
||
product_videos_data.append({
|
||
"id": video.id,
|
||
"title": video.title,
|
||
"description": video.description,
|
||
"thumbnail_url": video.thumbnail_url,
|
||
"video_url": video.video_url,
|
||
"badge": video.badge,
|
||
"view_count": video.view_count,
|
||
"like_count": video.like_count,
|
||
"comment_count": video.comment_count,
|
||
"release_date": video.release_date.strftime("%d.%m.%Y"),
|
||
"has_product": video.has_product,
|
||
"product_name": video.product_name,
|
||
"product_url": video.product_url
|
||
})
|
||
|
||
# 查询视频总数，用于分页
|
||
regular_videos_count = CreatorVideo.objects.filter(creator=creator, video_type='regular',
|
||
has_product=False).count()
|
||
product_videos_count = CreatorVideo.objects.filter(creator=creator, video_type='product',
|
||
has_product=True).count()
|
||
|
||
# 计算总页数
|
||
regular_total_pages = (regular_videos_count + page_size - 1) // page_size
|
||
product_total_pages = (product_videos_count + page_size - 1) // page_size
|
||
|
||
# 构造返回数据
|
||
response_data = {
|
||
"regular_videos": {
|
||
"videos": regular_videos_data,
|
||
"total": regular_videos_count,
|
||
"page": page,
|
||
"page_size": page_size,
|
||
"total_pages": regular_total_pages
|
||
},
|
||
"product_videos": {
|
||
"videos": product_videos_data,
|
||
"total": product_videos_count,
|
||
"page": page,
|
||
"page_size": page_size,
|
||
"total_pages": product_total_pages
|
||
}
|
||
}
|
||
|
||
return JsonResponse({
|
||
'code': 200,
|
||
'message': '获取成功',
|
||
'data': response_data
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
except Exception as e:
|
||
logger.error(f"获取创作者视频列表失败: {e}")
|
||
import traceback
|
||
logger.error(f"详细错误: {traceback.format_exc()}")
|
||
return JsonResponse({
|
||
'code': 500,
|
||
'message': f'获取创作者视频列表失败: {str(e)}',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
|
||
@csrf_exempt
|
||
@require_http_methods(["POST"])
|
||
def add_creator_video(request):
|
||
"""添加创作者视频"""
|
||
try:
|
||
from .models import CreatorProfile, CreatorVideo
|
||
import json
|
||
from datetime import datetime
|
||
|
||
data = json.loads(request.body)
|
||
|
||
# 获取必要参数
|
||
creator_id = data.get('creator_id')
|
||
title = data.get('title')
|
||
video_type = data.get('video_type', 'regular') # 默认为普通视频
|
||
release_date_str = data.get('release_date')
|
||
|
||
if not creator_id or not title or not release_date_str:
|
||
return JsonResponse({
|
||
'code': 400,
|
||
'message': '缺少必要参数: creator_id, title 或 release_date',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 查询创作者信息
|
||
try:
|
||
creator = CreatorProfile.objects.get(id=creator_id)
|
||
except CreatorProfile.DoesNotExist:
|
||
return JsonResponse({
|
||
'code': 404,
|
||
'message': f'未找到ID为 {creator_id} 的创作者',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 解析日期
|
||
try:
|
||
release_date = datetime.strptime(release_date_str, '%Y-%m-%d').date()
|
||
except ValueError:
|
||
return JsonResponse({
|
||
'code': 400,
|
||
'message': '日期格式不正确，请使用YYYY-MM-DD格式',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 获取其他参数
|
||
description = data.get('description', '')
|
||
thumbnail_url = data.get('thumbnail_url', '')
|
||
video_url = data.get('video_url', '')
|
||
video_id = data.get('video_id', f"vid_{int(datetime.now().timestamp())}")
|
||
badge = data.get('badge', 'red')
|
||
view_count = int(data.get('view_count', 0))
|
||
like_count = int(data.get('like_count', 0))
|
||
comment_count = int(data.get('comment_count', 0))
|
||
|
||
# 产品信息
|
||
has_product = data.get('has_product', False)
|
||
product_name = data.get('product_name', '')
|
||
product_url = data.get('product_url', '')
|
||
|
||
# 如果视频类型是product，确保has_product为True
|
||
if video_type == 'product':
|
||
has_product = True
|
||
|
||
# 创建或更新视频
|
||
video, created = CreatorVideo.objects.update_or_create(
|
||
creator=creator,
|
||
video_id=video_id,
|
||
defaults={
|
||
'title': title,
|
||
'description': description,
|
||
'thumbnail_url': thumbnail_url,
|
||
'video_url': video_url,
|
||
'video_type': video_type,
|
||
'badge': badge,
|
||
'view_count': view_count,
|
||
'like_count': like_count,
|
||
'comment_count': comment_count,
|
||
'has_product': has_product,
|
||
'product_name': product_name,
|
||
'product_url': product_url,
|
||
'release_date': release_date
|
||
}
|
||
)
|
||
|
||
return JsonResponse({
|
||
'code': 200,
|
||
'message': '视频添加成功',
|
||
'data': {
|
||
'video_id': video.id,
|
||
'created': created
|
||
}
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
except Exception as e:
|
||
logger.error(f"添加创作者视频失败: {e}")
|
||
import traceback
|
||
logger.error(f"详细错误: {traceback.format_exc()}")
|
||
return JsonResponse({
|
||
'code': 500,
|
||
'message': f'添加创作者视频失败: {str(e)}',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
|
||
######################################## 公有达人和私有达人 ########################################
|
||
|
||
@csrf_exempt
|
||
@require_http_methods(["GET"])
|
||
def get_public_creators(request):
|
||
"""获取公有达人库列表"""
|
||
try:
|
||
from .models import PublicCreatorPool, CreatorProfile
|
||
import json
|
||
|
||
# 获取分页参数
|
||
page = int(request.GET.get('page', 1))
|
||
page_size = int(request.GET.get('page_size', 10))
|
||
|
||
# 获取过滤参数
|
||
category = request.GET.get('category')
|
||
keyword = request.GET.get('keyword')
|
||
|
||
# 基础查询
|
||
public_creators = PublicCreatorPool.objects.all()
|
||
|
||
# 应用过滤条件
|
||
if category:
|
||
public_creators = public_creators.filter(category=category)
|
||
|
||
if keyword:
|
||
public_creators = public_creators.filter(
|
||
creator__name__icontains=keyword
|
||
) | public_creators.filter(
|
||
creator__category__icontains=keyword
|
||
)
|
||
|
||
# 获取总数据量
|
||
total_count = public_creators.count()
|
||
|
||
# 计算分页
|
||
start = (page - 1) * page_size
|
||
end = start + page_size
|
||
|
||
# 执行查询并分页
|
||
creators = public_creators[start:end]
|
||
|
||
creator_list = []
|
||
for public_creator in creators:
|
||
creator = public_creator.creator
|
||
|
||
# 格式化电商等级
|
||
e_commerce_level_formatted = f"L{creator.e_commerce_level}" if creator.e_commerce_level else None
|
||
|
||
# 格式化GMV
|
||
gmv_formatted = f"${creator.gmv}k" if creator.gmv else "$0"
|
||
|
||
# 格式化粉丝数和观看量
|
||
followers_formatted = f"{int(creator.followers / 1000)}k" if creator.followers else "0"
|
||
avg_views_formatted = f"{int(creator.avg_video_views / 1000)}k" if creator.avg_video_views else "0"
|
||
|
||
# 格式化价格区间
|
||
if creator.pricing_min is not None and creator.pricing_max is not None:
|
||
pricing_range = f"${creator.pricing_min}-{creator.pricing_max}"
|
||
else:
|
||
pricing_range = None
|
||
|
||
# 格式化结果
|
||
formatted_creator = {
|
||
"public_id": public_creator.id,
|
||
"creator_id": creator.id,
|
||
"name": creator.name,
|
||
"avatar": creator.avatar_url,
|
||
"category": creator.category,
|
||
"e_commerce_level": e_commerce_level_formatted,
|
||
"exposure_level": creator.exposure_level,
|
||
"followers": followers_formatted,
|
||
"gmv": gmv_formatted,
|
||
"avg_video_views": avg_views_formatted,
|
||
"pricing": pricing_range,
|
||
"collab_count": creator.collab_count,
|
||
"remark": public_creator.remark,
|
||
"category_public": public_creator.category
|
||
}
|
||
creator_list.append(formatted_creator)
|
||
|
||
# 计算总页数
|
||
total_pages = (total_count + page_size - 1) // page_size
|
||
|
||
# 构造分页信息
|
||
pagination = {
|
||
"current_page": page,
|
||
"total_pages": total_pages,
|
||
"total_count": total_count,
|
||
"has_next": page < total_pages,
|
||
"has_prev": page > 1
|
||
}
|
||
|
||
return JsonResponse({
|
||
'code': 200,
|
||
'message': '获取成功',
|
||
'data': creator_list,
|
||
'pagination': pagination
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
except Exception as e:
|
||
logger.error(f"获取公有达人库列表失败: {e}")
|
||
import traceback
|
||
logger.error(f"详细错误: {traceback.format_exc()}")
|
||
return JsonResponse({
|
||
'code': 500,
|
||
'message': f'获取公有达人库列表失败: {str(e)}',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
|
||
@csrf_exempt
|
||
@require_http_methods(["POST"])
|
||
def add_to_public_pool(request):
|
||
"""将达人添加到公有达人库"""
|
||
try:
|
||
from .models import PublicCreatorPool, CreatorProfile
|
||
import json
|
||
|
||
data = json.loads(request.body)
|
||
|
||
# 获取必要参数
|
||
creator_id = data.get('creator_id')
|
||
category = data.get('category')
|
||
remark = data.get('remark')
|
||
|
||
if not creator_id:
|
||
return JsonResponse({
|
||
'code': 400,
|
||
'message': '缺少必要参数: creator_id',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 查询达人信息
|
||
try:
|
||
creator = CreatorProfile.objects.get(id=creator_id)
|
||
except CreatorProfile.DoesNotExist:
|
||
return JsonResponse({
|
||
'code': 404,
|
||
'message': f'找不到ID为 {creator_id} 的达人',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 检查是否已存在于公有库
|
||
exists = PublicCreatorPool.objects.filter(creator=creator).exists()
|
||
if exists:
|
||
# 如果已存在，则更新信息
|
||
public_creator = PublicCreatorPool.objects.get(creator=creator)
|
||
public_creator.category = category if category else public_creator.category
|
||
public_creator.remark = remark if remark else public_creator.remark
|
||
public_creator.save()
|
||
|
||
action = "更新"
|
||
else:
|
||
# 创建新的公有库达人
|
||
public_creator = PublicCreatorPool.objects.create(
|
||
creator=creator,
|
||
category=category,
|
||
remark=remark
|
||
)
|
||
|
||
action = "添加"
|
||
|
||
return JsonResponse({
|
||
'code': 200,
|
||
'message': f'成功{action}达人到公有库',
|
||
'data': {
|
||
'creator': {
|
||
'id': creator.id,
|
||
'name': creator.name
|
||
},
|
||
'public_pool': {
|
||
'id': public_creator.id,
|
||
'category': public_creator.category,
|
||
'remark': public_creator.remark
|
||
}
|
||
}
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
except Exception as e:
|
||
logger.error(f"添加达人到公有库失败: {e}")
|
||
import traceback
|
||
logger.error(f"详细错误: {traceback.format_exc()}")
|
||
return JsonResponse({
|
||
'code': 500,
|
||
'message': f'添加达人到公有库失败: {str(e)}',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
|
||
@csrf_exempt
|
||
@require_http_methods(["GET"])
|
||
def get_private_pools(request):
|
||
"""获取用户的私有达人库列表"""
|
||
try:
|
||
from .models import PrivateCreatorPool
|
||
import json
|
||
|
||
# 获取用户ID
|
||
user_id = request.GET.get('user_id')
|
||
|
||
if not user_id:
|
||
return JsonResponse({
|
||
'code': 400,
|
||
'message': '缺少必要参数: user_id',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 查询用户的所有私有库
|
||
pools = PrivateCreatorPool.objects.filter(user=user_id)
|
||
|
||
pool_list = []
|
||
for pool in pools:
|
||
# 获取私有库中的达人数量
|
||
creator_count = pool.creator_relations.filter(status="active").count()
|
||
|
||
pool_data = {
|
||
"id": pool.id,
|
||
"name": pool.name,
|
||
"description": pool.description,
|
||
"is_default": pool.is_default,
|
||
"creator_count": creator_count,
|
||
"created_at": pool.created_at.strftime('%Y-%m-%d')
|
||
}
|
||
pool_list.append(pool_data)
|
||
|
||
return JsonResponse({
|
||
'code': 200,
|
||
'message': '获取成功',
|
||
'data': pool_list
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
except Exception as e:
|
||
logger.error(f"获取私有达人库列表失败: {e}")
|
||
import traceback
|
||
logger.error(f"详细错误: {traceback.format_exc()}")
|
||
return JsonResponse({
|
||
'code': 500,
|
||
'message': f'获取私有达人库列表失败: {str(e)}',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
|
||
@csrf_exempt
|
||
@require_http_methods(["POST"])
|
||
def create_private_pool(request):
|
||
"""创建私有达人库"""
|
||
try:
|
||
from .models import PrivateCreatorPool
|
||
from apps.user.models import User
|
||
import json
|
||
|
||
data = json.loads(request.body)
|
||
logger.info(f"创建私有达人库请求数据: {data}")
|
||
|
||
# 获取必要参数
|
||
user_id = data.get('user_id')
|
||
name = data.get('name')
|
||
description = data.get('description')
|
||
is_default = data.get('is_default', False)
|
||
|
||
logger.info(f"解析后的参数: user_id={user_id}, name={name}, description={description}, is_default={is_default}")
|
||
|
||
if not user_id or not name:
|
||
return JsonResponse({
|
||
'code': 400,
|
||
'message': '缺少必要参数: user_id 或 name',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 查询用户信息
|
||
try:
|
||
logger.info(f"尝试查询用户ID: {user_id}")
|
||
# 确保user_id是整数
|
||
user_id = int(user_id)
|
||
user = User.objects.get(id=user_id)
|
||
logger.info(f"查询到的用户信息: {user}")
|
||
|
||
# 验证user是否是User实例
|
||
if not isinstance(user, User):
|
||
raise ValueError(f"查询结果不是User实例: {type(user)}")
|
||
|
||
except ValueError as e:
|
||
logger.error(f"用户ID格式错误: {str(e)}")
|
||
return JsonResponse({
|
||
'code': 400,
|
||
'message': f'用户ID格式错误: {str(e)}',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
except User.DoesNotExist:
|
||
logger.error(f"用户不存在: {user_id}")
|
||
return JsonResponse({
|
||
'code': 404,
|
||
'message': f'找不到ID为 {user_id} 的用户',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
except Exception as e:
|
||
logger.error(f"查询用户时发生错误: {str(e)}")
|
||
raise
|
||
|
||
# 检查是否已存在同名私有库
|
||
try:
|
||
existing_pool = PrivateCreatorPool.objects.filter(user_id=user.id, name=name).first()
|
||
if existing_pool:
|
||
return JsonResponse({
|
||
'code': 409,
|
||
'message': f'已存在同名私有库: {name}',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
except Exception as e:
|
||
logger.error(f"检查私有库是否存在时发生错误: {str(e)}")
|
||
raise
|
||
|
||
# 如果设置为默认库，则将其他库设为非默认
|
||
if is_default:
|
||
PrivateCreatorPool.objects.filter(user_id=user.id, is_default=True).update(is_default=False)
|
||
|
||
# 创建私有库
|
||
try:
|
||
private_pool = PrivateCreatorPool.objects.create(
|
||
user_id=user.id, # 使用user.id而不是user实例
|
||
name=name,
|
||
description=description,
|
||
is_default=is_default
|
||
)
|
||
except Exception as e:
|
||
logger.error(f"创建私有库时发生错误: {str(e)}")
|
||
raise
|
||
|
||
return JsonResponse({
|
||
'code': 200,
|
||
'message': '私有库创建成功',
|
||
'data': {
|
||
'id': private_pool.id,
|
||
'name': private_pool.name,
|
||
'is_default': private_pool.is_default,
|
||
'creator_count': 0,
|
||
'created_at': private_pool.created_at.strftime('%Y-%m-%d')
|
||
}
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
except Exception as e:
|
||
logger.error(f"创建私有达人库失败: {e}")
|
||
import traceback
|
||
logger.error(f"详细错误: {traceback.format_exc()}")
|
||
return JsonResponse({
|
||
'code': 500,
|
||
'message': f'创建私有达人库失败: {str(e)}',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
|
||
@csrf_exempt
|
||
@require_http_methods(["GET"])
|
||
def get_private_pool_creators(request, pool_id=None):
|
||
"""获取私有库中的达人列表"""
|
||
try:
|
||
from .models import PrivateCreatorPool, PrivateCreatorRelation
|
||
import json
|
||
|
||
# 检查pool_id是否提供
|
||
if not pool_id:
|
||
pool_id = request.GET.get('pool_id')
|
||
if not pool_id:
|
||
return JsonResponse({
|
||
'code': 400,
|
||
'message': '缺少必要参数: pool_id',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 获取分页参数
|
||
page = int(request.GET.get('page', 1))
|
||
page_size = int(request.GET.get('page_size', 10))
|
||
|
||
# 获取过滤参数
|
||
status = request.GET.get('status', 'active') # 默认只获取活跃状态的达人
|
||
keyword = request.GET.get('keyword')
|
||
|
||
# 查询私有库信息
|
||
try:
|
||
private_pool = PrivateCreatorPool.objects.get(id=pool_id)
|
||
except PrivateCreatorPool.DoesNotExist:
|
||
return JsonResponse({
|
||
'code': 404,
|
||
'message': f'找不到ID为 {pool_id} 的私有库',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 查询私有库中的达人关联
|
||
creator_relations = PrivateCreatorRelation.objects.filter(
|
||
private_pool=private_pool
|
||
).select_related('creator')
|
||
|
||
# 应用过滤条件
|
||
if status:
|
||
creator_relations = creator_relations.filter(status=status)
|
||
|
||
if keyword:
|
||
creator_relations = creator_relations.filter(
|
||
creator__name__icontains=keyword
|
||
) | creator_relations.filter(
|
||
creator__category__icontains=keyword
|
||
) | creator_relations.filter(
|
||
notes__icontains=keyword
|
||
)
|
||
|
||
# 获取总数据量
|
||
total_count = creator_relations.count()
|
||
|
||
# 计算分页
|
||
start = (page - 1) * page_size
|
||
end = start + page_size
|
||
|
||
# 执行查询并分页
|
||
paged_relations = creator_relations[start:end]
|
||
|
||
creator_list = []
|
||
for relation in paged_relations:
|
||
creator = relation.creator
|
||
|
||
# 格式化电商等级
|
||
e_commerce_level_formatted = f"L{creator.e_commerce_level}" if creator.e_commerce_level else None
|
||
|
||
# 格式化GMV
|
||
gmv_formatted = f"${creator.gmv}k" if creator.gmv else "$0"
|
||
|
||
# 格式化粉丝数和观看量
|
||
followers_formatted = f"{int(creator.followers / 1000)}k" if creator.followers else "0"
|
||
avg_views_formatted = f"{int(creator.avg_video_views / 1000)}k" if creator.avg_video_views else "0"
|
||
|
||
# 格式化价格区间
|
||
if creator.pricing_min is not None and creator.pricing_max is not None:
|
||
pricing_range = f"${creator.pricing_min}-{creator.pricing_max}"
|
||
else:
|
||
pricing_range = None
|
||
|
||
# 格式化结果
|
||
formatted_creator = {
|
||
"relation_id": relation.id,
|
||
"creator_id": creator.id,
|
||
"name": creator.name,
|
||
"avatar": creator.avatar_url,
|
||
"category": creator.category,
|
||
"e_commerce_level": e_commerce_level_formatted,
|
||
"exposure_level": creator.exposure_level,
|
||
"followers": followers_formatted,
|
||
"gmv": gmv_formatted,
|
||
"avg_video_views": avg_views_formatted,
|
||
"pricing": pricing_range, # 使用格式化后的价格区间
|
||
"collab_count": creator.collab_count,
|
||
"notes": relation.notes,
|
||
"status": relation.status,
|
||
"added_from_public": relation.added_from_public,
|
||
"added_at": relation.created_at.strftime('%Y-%m-%d')
|
||
}
|
||
creator_list.append(formatted_creator)
|
||
|
||
# 计算总页数
|
||
total_pages = (total_count + page_size - 1) // page_size
|
||
|
||
# 构造分页信息
|
||
pagination = {
|
||
"current_page": page,
|
||
"total_pages": total_pages,
|
||
"total_count": total_count,
|
||
"has_next": page < total_pages,
|
||
"has_prev": page > 1
|
||
}
|
||
|
||
# 构造私有库信息
|
||
pool_info = {
|
||
"id": private_pool.id,
|
||
"name": private_pool.name,
|
||
"description": private_pool.description,
|
||
"is_default": private_pool.is_default,
|
||
"user_id": private_pool.user_id,
|
||
"created_at": private_pool.created_at.strftime('%Y-%m-%d')
|
||
}
|
||
|
||
return JsonResponse({
|
||
'code': 200,
|
||
'message': '获取成功',
|
||
'data': creator_list,
|
||
'pagination': pagination,
|
||
'pool_info': pool_info
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
except Exception as e:
|
||
logger.error(f"获取私有库达人列表失败: {e}")
|
||
import traceback
|
||
logger.error(f"详细错误: {traceback.format_exc()}")
|
||
return JsonResponse({
|
||
'code': 500,
|
||
'message': f'获取私有库达人列表失败: {str(e)}',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
|
||
@csrf_exempt
|
||
@require_http_methods(["POST"])
|
||
def add_creator_to_private_pool(request):
|
||
"""将达人添加到私有达人库"""
|
||
try:
|
||
from .models import PrivateCreatorPool, PrivateCreatorRelation, CreatorProfile, PublicCreatorPool
|
||
import json
|
||
|
||
data = json.loads(request.body)
|
||
|
||
# 获取必要参数
|
||
pool_id = data.get('pool_id')
|
||
creator_id = data.get('creator_id')
|
||
notes = data.get('notes')
|
||
|
||
# 也接受批量添加
|
||
creator_ids = data.get('creator_ids', [])
|
||
if creator_id and not creator_ids:
|
||
creator_ids = [creator_id]
|
||
|
||
if not pool_id or not creator_ids:
|
||
return JsonResponse({
|
||
'code': 400,
|
||
'message': '缺少必要参数: pool_id 或 creator_id/creator_ids',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 查询私有库信息
|
||
try:
|
||
private_pool = PrivateCreatorPool.objects.get(id=pool_id)
|
||
except PrivateCreatorPool.DoesNotExist:
|
||
return JsonResponse({
|
||
'code': 404,
|
||
'message': f'找不到ID为 {pool_id} 的私有库',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 添加达人到私有库
|
||
added_creators = []
|
||
skipped_creators = []
|
||
|
||
for cid in creator_ids:
|
||
try:
|
||
# 查询达人信息
|
||
creator = CreatorProfile.objects.get(id=cid)
|
||
|
||
# 检查是否从公有库添加
|
||
from_public = PublicCreatorPool.objects.filter(creator=creator).exists()
|
||
|
||
# 检查是否已存在于该私有库
|
||
exists = PrivateCreatorRelation.objects.filter(
|
||
private_pool=private_pool,
|
||
creator=creator
|
||
).exists()
|
||
|
||
if exists:
|
||
# 如果已存在，则更新信息
|
||
relation = PrivateCreatorRelation.objects.get(
|
||
private_pool=private_pool,
|
||
creator=creator
|
||
)
|
||
|
||
# 如果状态为archived，则重新激活
|
||
if relation.status == 'archived':
|
||
relation.status = 'active'
|
||
|
||
if notes:
|
||
relation.notes = notes
|
||
|
||
relation.save()
|
||
|
||
added_creators.append({
|
||
'id': creator.id,
|
||
'name': creator.name,
|
||
'action': '更新'
|
||
})
|
||
else:
|
||
# 创建新的关联
|
||
relation = PrivateCreatorRelation.objects.create(
|
||
private_pool=private_pool,
|
||
creator=creator,
|
||
notes=notes,
|
||
added_from_public=from_public,
|
||
status='active'
|
||
)
|
||
|
||
added_creators.append({
|
||
'id': creator.id,
|
||
'name': creator.name,
|
||
'action': '添加'
|
||
})
|
||
|
||
except CreatorProfile.DoesNotExist:
|
||
skipped_creators.append({
|
||
'id': cid,
|
||
'reason': '达人不存在或已失效'
|
||
})
|
||
|
||
return JsonResponse({
|
||
'code': 200,
|
||
'message': '操作成功',
|
||
'data': {
|
||
'added': added_creators,
|
||
'skipped': skipped_creators,
|
||
'pool': {
|
||
'id': private_pool.id,
|
||
'name': private_pool.name
|
||
}
|
||
}
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
except Exception as e:
|
||
logger.error(f"添加达人到私有库失败: {e}")
|
||
import traceback
|
||
logger.error(f"详细错误: {traceback.format_exc()}")
|
||
return JsonResponse({
|
||
'code': 500,
|
||
'message': f'添加达人到私有库失败: {str(e)}',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
|
||
@csrf_exempt
|
||
@require_http_methods(["POST"])
|
||
def update_creator_in_private_pool(request):
|
||
"""更新私有库中达人的状态或笔记"""
|
||
try:
|
||
from .models import PrivateCreatorRelation
|
||
import json
|
||
|
||
data = json.loads(request.body)
|
||
|
||
# 获取必要参数
|
||
relation_id = data.get('relation_id')
|
||
status = data.get('status')
|
||
notes = data.get('notes')
|
||
|
||
if not relation_id or (not status and notes is None):
|
||
return JsonResponse({
|
||
'code': 400,
|
||
'message': '缺少必要参数: relation_id 或 status/notes',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 查询关联信息
|
||
try:
|
||
relation = PrivateCreatorRelation.objects.get(id=relation_id)
|
||
except PrivateCreatorRelation.DoesNotExist:
|
||
return JsonResponse({
|
||
'code': 404,
|
||
'message': f'找不到ID为 {relation_id} 的关联记录',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 更新信息
|
||
if status:
|
||
relation.status = status
|
||
|
||
if notes is not None: # 允许清空笔记
|
||
relation.notes = notes
|
||
|
||
relation.save()
|
||
|
||
return JsonResponse({
|
||
'code': 200,
|
||
'message': '更新成功',
|
||
'data': {
|
||
'relation_id': relation.id,
|
||
'creator_id': relation.creator_id,
|
||
'pool_id': relation.private_pool_id,
|
||
'status': relation.status,
|
||
'notes': relation.notes
|
||
}
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
except Exception as e:
|
||
logger.error(f"更新私有库达人失败: {e}")
|
||
import traceback
|
||
logger.error(f"详细错误: {traceback.format_exc()}")
|
||
return JsonResponse({
|
||
'code': 500,
|
||
'message': f'更新私有库达人失败: {str(e)}',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
|
||
@csrf_exempt
|
||
@require_http_methods(["POST"])
|
||
def remove_creator_from_private_pool(request):
|
||
"""从私有库中移除达人"""
|
||
try:
|
||
from .models import PrivateCreatorRelation
|
||
import json
|
||
|
||
data = json.loads(request.body)
|
||
|
||
# 方式1：通过关联ID删除
|
||
relation_id = data.get('relation_id')
|
||
relation_ids = data.get('relation_ids', [])
|
||
if relation_id and not relation_ids:
|
||
relation_ids = [relation_id]
|
||
|
||
# 方式2：通过私有库ID和达人ID删除
|
||
pool_id = data.get('pool_id')
|
||
creator_id = data.get('creator_id')
|
||
creator_ids = data.get('creator_ids', [])
|
||
if creator_id and not creator_ids:
|
||
creator_ids = [creator_id]
|
||
|
||
# 检查参数有效性
|
||
if relation_ids:
|
||
# 通过关联ID删除
|
||
query = PrivateCreatorRelation.objects.filter(id__in=relation_ids)
|
||
result_type = 'relation_ids'
|
||
result_value = relation_ids
|
||
|
||
elif pool_id and creator_ids:
|
||
# 通过私有库ID和达人ID删除
|
||
query = PrivateCreatorRelation.objects.filter(
|
||
private_pool_id=pool_id,
|
||
creator_id__in=creator_ids
|
||
)
|
||
result_type = 'creator_ids'
|
||
result_value = creator_ids
|
||
else:
|
||
return JsonResponse({
|
||
'code': 400,
|
||
'message': '缺少必要参数: 需要提供 relation_id/relation_ids 或同时提供 pool_id 和 creator_id/creator_ids',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
# 执行删除操作
|
||
deleted_count = query.delete()[0]
|
||
|
||
return JsonResponse({
|
||
'code': 200,
|
||
'message': '移除成功',
|
||
'data': {
|
||
'deleted_count': deleted_count,
|
||
result_type: result_value,
|
||
'pool_id': pool_id if pool_id else None
|
||
}
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
except Exception as e:
|
||
logger.error(f"从私有库移除达人失败: {e}")
|
||
import traceback
|
||
logger.error(f"详细错误: {traceback.format_exc()}")
|
||
return JsonResponse({
|
||
'code': 500,
|
||
'message': f'从私有库移除达人失败: {str(e)}',
|
||
'data': None
|
||
}, json_dumps_params={'ensure_ascii': False})
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|