up
This commit is contained in:
root
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,331 @@
|
||||
"""认证服务：验证码 / 注册 / 登录 / 刷新 / 登出 / 找回密码"""
|
||||
import logging
|
||||
import random
|
||||
import string
|
||||
from datetime import datetime, timedelta
|
||||
|
||||
import redis.asyncio as aioredis
|
||||
from sqlalchemy import func, or_, select
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.config import biz_config, settings
|
||||
from app.core import errors
|
||||
from app.core.response import BizException
|
||||
from app.core.security import (
|
||||
create_access_token,
|
||||
create_refresh_token,
|
||||
decode_token,
|
||||
hash_password,
|
||||
verify_password,
|
||||
)
|
||||
from app.models.incentive import AssetWallet, Referral
|
||||
from app.models.user import User
|
||||
from app.services import config_service, invite_service, membership_service, sensitive_service, wallet_service
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
REFRESH_TTL = 30 * 24 * 3600
|
||||
DEACTIVATE_FREEZE_DAYS = 7
|
||||
|
||||
|
||||
# ---------- 验证码 ----------
|
||||
|
||||
def _code_key(scene: str, channel: str, target: str) -> str:
|
||||
return f"{channel}:code:{scene}:{target}"
|
||||
|
||||
|
||||
async def send_code(
|
||||
db: AsyncSession, redis: aioredis.Redis, channel: str, target: str, scene: str, ip: str
|
||||
) -> dict:
|
||||
"""发送验证码（短信/邮箱）。未配置通道时按开发模式返回 dev_code 并记日志。"""
|
||||
# 场景前置校验：register 要求未注册，login/reset 要求已注册
|
||||
user = await _find_user(db, channel, target)
|
||||
if scene == "register" and user is not None:
|
||||
raise BizException(errors.PARAM_ERROR, "该账号已注册")
|
||||
if scene in ("login", "reset") and user is None:
|
||||
raise BizException(errors.PARAM_ERROR, "该账号未注册")
|
||||
|
||||
# 限流：同号 60s 1 条 + 同号每天 10 条 + 同 IP 5 条/小时
|
||||
limit_key = f"{channel}:limit:{target}"
|
||||
if await redis.exists(limit_key):
|
||||
raise BizException(errors.RATE_LIMITED, "发送过于频繁，请 60 秒后再试")
|
||||
day_key = f"{channel}:day:{target}:{datetime.now():%Y%m%d}"
|
||||
if int(await redis.get(day_key) or 0) >= 10:
|
||||
raise BizException(errors.RATE_LIMITED, "今日验证码发送已达上限")
|
||||
ip_key = f"{channel}:iphour:{ip}:{datetime.now():%Y%m%d%H}"
|
||||
if int(await redis.get(ip_key) or 0) >= 5:
|
||||
raise BizException(errors.RATE_LIMITED, "发送过于频繁，请稍后再试")
|
||||
|
||||
code = "".join(random.choices(string.digits, k=6))
|
||||
ttl = 300 if channel == "sms" else 600
|
||||
await redis.set(_code_key(scene, channel, target), code, ex=ttl)
|
||||
await redis.set(limit_key, 1, ex=60)
|
||||
await redis.incr(day_key)
|
||||
await redis.expire(day_key, 48 * 3600)
|
||||
await redis.incr(ip_key)
|
||||
await redis.expire(ip_key, 3600)
|
||||
|
||||
data = {"expire_seconds": ttl, "retry_after": 60}
|
||||
# TODO: 接入阿里云短信 / SMTP 实际发送；未配置通道时按开发模式处理
|
||||
channel_configured = bool(settings.sms_access_key_id) if channel == "sms" else bool(settings.smtp_host)
|
||||
if not channel_configured:
|
||||
logger.info("[dev] %s code for %s (%s): %s", channel, target, scene, code)
|
||||
data["dev_code"] = code
|
||||
return data
|
||||
|
||||
|
||||
async def _verify_code(redis: aioredis.Redis, channel: str, target: str, scene: str, code: str) -> None:
|
||||
key = _code_key(scene, channel, target)
|
||||
saved = await redis.get(key)
|
||||
if not saved or saved != code:
|
||||
raise BizException(errors.CAPTCHA_ERROR)
|
||||
await redis.delete(key)
|
||||
|
||||
|
||||
async def _find_user(db: AsyncSession, channel: str, target: str) -> User | None:
|
||||
field = User.phone if channel == "sms" else User.email
|
||||
return (await db.execute(select(User).where(field == target))).scalar_one_or_none()
|
||||
|
||||
|
||||
# ---------- Token ----------
|
||||
|
||||
async def _issue_tokens(redis: aioredis.Redis, user_id: int) -> dict:
|
||||
"""签发双 Token：access 2h + refresh 30d（白名单 Set 支持多端）"""
|
||||
epoch = int(await redis.get(f"auth:epoch:{user_id}") or 0)
|
||||
access, _, _ = create_access_token(user_id, epoch)
|
||||
refresh, refresh_jti, _ = create_refresh_token(user_id, epoch)
|
||||
key = f"auth:refresh:{user_id}"
|
||||
await redis.sadd(key, refresh_jti) # type: ignore[misc]
|
||||
await redis.expire(key, REFRESH_TTL)
|
||||
return {"access_token": access, "refresh_token": refresh, "expires_in": settings.access_token_ttl}
|
||||
|
||||
|
||||
async def _user_brief(db: AsyncSession, user: User) -> dict:
|
||||
is_member = await membership_service.is_member(db, user.id)
|
||||
return {
|
||||
"user_id": user.id,
|
||||
"nickname": user.nickname,
|
||||
"avatar_url": user.avatar_url,
|
||||
"is_member": is_member,
|
||||
}
|
||||
|
||||
|
||||
# ---------- 注册 ----------
|
||||
|
||||
async def register(
|
||||
db: AsyncSession, redis: aioredis.Redis, req, device_id: str | None, ip: str
|
||||
) -> dict:
|
||||
channel = "sms" if req.type == "phone" else "email"
|
||||
target = req.phone if req.type == "phone" else req.email
|
||||
await _verify_code(redis, channel, target, "register", req.code)
|
||||
|
||||
# 唯一性校验
|
||||
dup = await db.execute(
|
||||
select(User.id).where(or_(User.phone == req.phone if req.phone else False,
|
||||
User.email == req.email if req.email else False))
|
||||
)
|
||||
if dup.first():
|
||||
raise BizException(errors.PARAM_ERROR, "手机号/邮箱已注册")
|
||||
|
||||
# 昵称：默认"用户+随机尾号"，过敏感词
|
||||
nickname = req.nickname or f"用户{random.randint(100000, 999999)}"
|
||||
if await sensitive_service.find_sensitive(db, redis, nickname):
|
||||
raise BizException(errors.SENSITIVE_WORD)
|
||||
|
||||
# 生成唯一邀请码
|
||||
invite_code = await _gen_invite_code(db)
|
||||
|
||||
user = User(
|
||||
phone=req.phone if req.type == "phone" else None,
|
||||
email=req.email if req.type == "email" else None,
|
||||
password_hash=hash_password(req.password),
|
||||
nickname=nickname,
|
||||
register_type=1 if req.type == "phone" else 2,
|
||||
invite_code=invite_code,
|
||||
register_ip=ip,
|
||||
last_login_at=datetime.now(),
|
||||
last_login_ip=ip,
|
||||
)
|
||||
db.add(user)
|
||||
await db.flush()
|
||||
await wallet_service.get_or_create_wallet(db, user.id)
|
||||
db.add(AssetWallet(user_id=user.id))
|
||||
|
||||
# 绑定推荐关系：显式邀请码（口令/手填）优先，否则取首启模糊归因缓存
|
||||
bind_code = req.invite_code
|
||||
if not bind_code and device_id:
|
||||
bind_code = await invite_service.pop_attribution(redis, device_id)
|
||||
if bind_code:
|
||||
await _bind_referral(db, redis, user, bind_code, device_id, ip)
|
||||
|
||||
# 设备注册标记（防小号绑定，须在绑定校验之后写入，否则同设备校验永远读到新账号自己）
|
||||
if device_id:
|
||||
await redis.set(f"ref:device:{device_id}", user.id)
|
||||
|
||||
# 新注册赠送体验会员（后台可配开关与天数，实时生效）
|
||||
trial_granted = None
|
||||
gift_enabled = await config_service.get_config(db, redis, "register_gift_trial.enabled", "1")
|
||||
if str(gift_enabled) == "1":
|
||||
days = await config_service.get_config_int(db, redis, "register_gift_trial.days", 1)
|
||||
order = await membership_service.grant_trial_gift(db, user.id, days)
|
||||
trial_granted = {
|
||||
"plan_code": "trial",
|
||||
"plan_name": "体验会员",
|
||||
"days": days,
|
||||
"end_at": order.end_at.strftime("%Y-%m-%d %H:%M:%S"),
|
||||
}
|
||||
|
||||
await db.commit()
|
||||
|
||||
tokens = await _issue_tokens(redis, user.id)
|
||||
return {
|
||||
"user_id": user.id,
|
||||
**tokens,
|
||||
"user": await _user_brief(db, user),
|
||||
"trial_granted": trial_granted,
|
||||
}
|
||||
|
||||
|
||||
async def _gen_invite_code(db: AsyncSession) -> str:
|
||||
alphabet = "23456789ABCDEFGHJKLMNPQRSTUVWXYZ" # 去除易混淆字符
|
||||
for _ in range(10):
|
||||
code = "".join(random.choices(alphabet, k=8))
|
||||
exists = await db.execute(select(User.id).where(User.invite_code == code))
|
||||
if not exists.first():
|
||||
return code
|
||||
raise BizException(errors.INTERNAL_ERROR, "邀请码生成失败")
|
||||
|
||||
|
||||
async def _bind_referral(
|
||||
db: AsyncSession, redis: aioredis.Redis, invitee: User, invite_code: str, device_id: str | None, ip: str
|
||||
) -> None:
|
||||
"""注册时绑定推荐关系，含风控规则（同设备无效/邀请人单日超限冻结/同IP批量注册标记）"""
|
||||
inviter = (await db.execute(select(User).where(User.invite_code == invite_code))).scalar_one_or_none()
|
||||
if inviter is None or inviter.id == invitee.id:
|
||||
return # 邀请码无效则忽略绑定（不阻断注册）
|
||||
|
||||
status, risk_flag = 0, ""
|
||||
# 同 device 已存在账号 → 绑定直接无效
|
||||
if device_id and await redis.exists(f"ref:device:{device_id}"):
|
||||
old = int(await redis.get(f"ref:device:{device_id}") or 0)
|
||||
if old and old != invitee.id:
|
||||
status, risk_flag = 2, "same_device"
|
||||
# 邀请人 24h 新增绑定 >10 → 冻结
|
||||
risk_key = f"ref:risk:{inviter.id}:{datetime.now():%Y%m%d}"
|
||||
bind_count = await redis.incr(risk_key)
|
||||
await redis.expire(risk_key, 48 * 3600)
|
||||
max_bind = (biz_config.get("referral") or {}).get("risk_max_bind_per_day", 10)
|
||||
if status == 0 and bind_count > max_bind:
|
||||
status, risk_flag = 3, "inviter_burst"
|
||||
# 同 IP 24h 注册 >5 → 标记风险
|
||||
if status == 0:
|
||||
max_reg = (biz_config.get("referral") or {}).get("risk_max_register_per_ip", 5)
|
||||
cnt = (await db.execute(
|
||||
select(func.count(User.id)).where(
|
||||
User.register_ip == ip, User.created_at > datetime.now() - timedelta(hours=24)
|
||||
)
|
||||
)).scalar() or 0
|
||||
if cnt > max_reg:
|
||||
status, risk_flag = 3, "batch_register"
|
||||
|
||||
db.add(Referral(
|
||||
inviter_id=inviter.id,
|
||||
invitee_id=invitee.id,
|
||||
invite_code=invite_code,
|
||||
status=status,
|
||||
risk_flag=risk_flag,
|
||||
register_ip=ip,
|
||||
))
|
||||
|
||||
|
||||
# ---------- 登录 ----------
|
||||
|
||||
async def login(db: AsyncSession, redis: aioredis.Redis, req, ip: str) -> dict:
|
||||
# 连续失败 5 次锁定 15 分钟（IP 维度）
|
||||
fail_key = f"login:fail:{ip}"
|
||||
if int(await redis.get(fail_key) or 0) >= 5:
|
||||
raise BizException(errors.RATE_LIMITED, "失败次数过多，账号已锁定 15 分钟", http_status=429)
|
||||
|
||||
channel = "sms" if req.type.startswith("phone") else "email"
|
||||
target = req.phone if channel == "sms" else req.email
|
||||
user = await _find_user(db, channel, target)
|
||||
|
||||
async def _fail():
|
||||
await redis.incr(fail_key)
|
||||
await redis.expire(fail_key, 15 * 60)
|
||||
raise BizException(errors.PARAM_ERROR, "账号或密码错误")
|
||||
|
||||
if user is None:
|
||||
await _fail()
|
||||
if req.type.endswith("code"):
|
||||
try:
|
||||
await _verify_code(redis, channel, target, "login", req.code)
|
||||
except BizException:
|
||||
await _fail()
|
||||
elif not verify_password(req.password, user.password_hash):
|
||||
await _fail()
|
||||
|
||||
await redis.delete(fail_key)
|
||||
|
||||
if user.status == 2:
|
||||
raise BizException(errors.FORBIDDEN, "账号已被封禁", http_status=403)
|
||||
# 注销冻结期内登录：返回 1009 + can_revoke（App 弹窗询问；确认后带 revoke=1 重试即撤销注销）
|
||||
if user.deactivate_at is not None:
|
||||
if getattr(req, "revoke", False):
|
||||
user.deactivate_at = None # 冻结期内撤销注销
|
||||
else:
|
||||
raise BizException(
|
||||
errors.ACCOUNT_DEACTIVATED, "账号已注销", http_status=403, data={"can_revoke": True}
|
||||
)
|
||||
|
||||
user.last_login_at = datetime.now()
|
||||
user.last_login_ip = ip
|
||||
await db.commit()
|
||||
|
||||
tokens = await _issue_tokens(redis, user.id)
|
||||
return {"user_id": user.id, **tokens, "user": await _user_brief(db, user)}
|
||||
|
||||
|
||||
# ---------- 刷新 / 登出 / 找回密码 ----------
|
||||
|
||||
async def refresh(db: AsyncSession, redis: aioredis.Redis, refresh_token: str) -> dict:
|
||||
"""刷新令牌：白名单校验 + 旋转（旧 refresh 立即作废）"""
|
||||
payload = decode_token(refresh_token)
|
||||
if payload.get("type") != "refresh":
|
||||
raise BizException(errors.UNAUTHORIZED, http_status=401)
|
||||
user_id = int(payload["sub"])
|
||||
jti = payload.get("jti", "")
|
||||
epoch = int(await redis.get(f"auth:epoch:{user_id}") or 0)
|
||||
if int(payload.get("ep", 0)) != epoch:
|
||||
raise BizException(errors.UNAUTHORIZED, http_status=401)
|
||||
key = f"auth:refresh:{user_id}"
|
||||
if not await redis.sismember(key, jti): # type: ignore[misc]
|
||||
raise BizException(errors.UNAUTHORIZED, http_status=401)
|
||||
await redis.srem(key, jti) # type: ignore[misc]
|
||||
# 用户仍须可用
|
||||
user = await db.get(User, user_id)
|
||||
if user is None or user.status != 1:
|
||||
raise BizException(errors.UNAUTHORIZED, http_status=401)
|
||||
return await _issue_tokens(redis, user_id)
|
||||
|
||||
|
||||
async def logout(redis: aioredis.Redis, user_id: int, access_jti: str, access_exp: int) -> None:
|
||||
"""登出：access jti 入黑名单 + 删 refresh 白名单"""
|
||||
ttl = max(access_exp - int(datetime.now().timestamp()), 1)
|
||||
await redis.set(f"token:blacklist:{access_jti}", 1, ex=ttl)
|
||||
await redis.delete(f"auth:refresh:{user_id}")
|
||||
|
||||
|
||||
async def reset_password(db: AsyncSession, redis: aioredis.Redis, req) -> None:
|
||||
channel = "sms" if req.type == "phone" else "email"
|
||||
target = req.phone if req.type == "phone" else req.email
|
||||
user = await _find_user(db, channel, target)
|
||||
if user is None:
|
||||
raise BizException(errors.PARAM_ERROR, "账号不存在")
|
||||
await _verify_code(redis, channel, target, "reset", req.code)
|
||||
|
||||
user.password_hash = hash_password(req.new_password)
|
||||
# 全端 Token 失效：递增令牌纪元 + 清 refresh 白名单
|
||||
await redis.incr(f"auth:epoch:{user.id}")
|
||||
await redis.delete(f"auth:refresh:{user.id}")
|
||||
await db.commit()
|
||||
@@ -0,0 +1,145 @@
|
||||
"""通用服务：版本检查 / 通知 / 举报（对应《03-接口文档》第 10 章）"""
|
||||
import json
|
||||
from datetime import datetime
|
||||
|
||||
import redis.asyncio as aioredis
|
||||
from sqlalchemy import func, select, update
|
||||
from sqlalchemy.exc import IntegrityError
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.core import errors, ratelimit
|
||||
from app.core.response import BizException
|
||||
from app.models.common import Notification, Report
|
||||
from app.services import config_service
|
||||
|
||||
# 举报限流：10 次/天/用户
|
||||
REPORT_DAILY_LIMIT = 10
|
||||
|
||||
|
||||
def _fmt(dt: datetime | None) -> str | None:
|
||||
return dt.strftime("%Y-%m-%d %H:%M:%S") if dt else None
|
||||
|
||||
|
||||
# ---------- 版本检查 ----------
|
||||
|
||||
async def get_app_version(db: AsyncSession, redis: aioredis.Redis, platform: str, version_code: int) -> dict:
|
||||
"""版本检查（10.1）：配置存 system_configs key=app.version.{platform}，JSON 值，后台可改"""
|
||||
raw = await config_service.get_config(db, redis, f"app.version.{platform}", "")
|
||||
cfg: dict = {}
|
||||
if raw:
|
||||
try:
|
||||
cfg = json.loads(raw)
|
||||
except (TypeError, ValueError):
|
||||
cfg = {}
|
||||
min_code = int(cfg.get("min_version_code", 0))
|
||||
return {
|
||||
"latest_version": cfg.get("latest_version", "1.0.0"),
|
||||
"latest_version_code": int(cfg.get("latest_version_code", 1)),
|
||||
"force_update": version_code < min_code,
|
||||
"update_url": cfg.get("update_url", ""),
|
||||
"notice": cfg.get("notice", ""),
|
||||
}
|
||||
|
||||
|
||||
# ---------- 通知 ----------
|
||||
|
||||
async def notify(
|
||||
db: AsyncSession, redis: aioredis.Redis, user_id: int,
|
||||
type: int, title: str, content: str = "", biz_id: str = "",
|
||||
) -> None:
|
||||
"""写入通知并累加 Redis 未读数（审核/提现/公告/评论回复共用，供后续模块调用）"""
|
||||
db.add(Notification(user_id=user_id, type=type, title=title, content=content, biz_id=biz_id))
|
||||
await db.flush()
|
||||
await redis.incr(f"notif:unread:{user_id}")
|
||||
|
||||
|
||||
async def list_notifications(
|
||||
db: AsyncSession, user_id: int, page: int, page_size: int, type: int | None
|
||||
) -> dict:
|
||||
"""通知列表（10.2）"""
|
||||
stmt = select(Notification).where(Notification.user_id == user_id)
|
||||
if type is not None:
|
||||
stmt = stmt.where(Notification.type == type)
|
||||
total = (await db.execute(select(func.count()).select_from(stmt.subquery()))).scalar() or 0
|
||||
rows = (
|
||||
await db.execute(
|
||||
stmt.order_by(Notification.id.desc()).offset((page - 1) * page_size).limit(page_size)
|
||||
)
|
||||
).scalars().all()
|
||||
return {
|
||||
"total": total,
|
||||
"list": [
|
||||
{
|
||||
"id": n.id,
|
||||
"type": n.type,
|
||||
"title": n.title,
|
||||
"content": n.content,
|
||||
"biz_id": n.biz_id,
|
||||
"is_read": bool(n.is_read),
|
||||
"created_at": _fmt(n.created_at),
|
||||
}
|
||||
for n in rows
|
||||
],
|
||||
}
|
||||
|
||||
|
||||
async def get_unread_count(db: AsyncSession, redis: aioredis.Redis, user_id: int) -> int:
|
||||
"""未读数（10.3）：直接读 Redis；缺失时从 DB 回填"""
|
||||
key = f"notif:unread:{user_id}"
|
||||
cached = await redis.get(key)
|
||||
if cached is not None:
|
||||
return max(int(cached), 0)
|
||||
count = (await db.execute(
|
||||
select(func.count(Notification.id)).where(Notification.user_id == user_id, Notification.is_read == 0)
|
||||
)).scalar() or 0
|
||||
await redis.set(key, count)
|
||||
return count
|
||||
|
||||
|
||||
async def mark_read(
|
||||
db: AsyncSession, redis: aioredis.Redis, user_id: int, ids: list[int] | None, mark_all: bool
|
||||
) -> None:
|
||||
"""标记已读（10.4）：ids 与 all 二选一；同步修正 Redis 未读数"""
|
||||
if mark_all:
|
||||
await db.execute(
|
||||
update(Notification).where(Notification.user_id == user_id, Notification.is_read == 0)
|
||||
.values(is_read=1)
|
||||
)
|
||||
await db.commit()
|
||||
await redis.set(f"notif:unread:{user_id}", 0)
|
||||
return
|
||||
if not ids:
|
||||
raise BizException(errors.PARAM_ERROR, "ids 与 all 需传其一")
|
||||
result = await db.execute(
|
||||
update(Notification)
|
||||
.where(Notification.user_id == user_id, Notification.is_read == 0, Notification.id.in_(ids))
|
||||
.values(is_read=1)
|
||||
)
|
||||
await db.commit()
|
||||
affected = result.rowcount or 0
|
||||
if affected > 0:
|
||||
# 未读数下限 0（DB 为准重算，避免并发脏读）
|
||||
remaining = (await db.execute(
|
||||
select(func.count(Notification.id)).where(Notification.user_id == user_id, Notification.is_read == 0)
|
||||
)).scalar() or 0
|
||||
await redis.set(f"notif:unread:{user_id}", remaining)
|
||||
|
||||
|
||||
# ---------- 举报 ----------
|
||||
|
||||
async def create_report(db: AsyncSession, redis: aioredis.Redis, user_id: int, req) -> None:
|
||||
"""提交举报（10.5）：唯一索引 uk_user_target 防重复（2106）；限流 10 次/天"""
|
||||
today = f"{datetime.now():%Y%m%d}"
|
||||
await ratelimit.hit(redis, f"rl:report:{user_id}:{today}", REPORT_DAILY_LIMIT, 24 * 3600)
|
||||
db.add(Report(
|
||||
user_id=user_id,
|
||||
target_type=req.target_type,
|
||||
target_id=req.target_id,
|
||||
reason_type=req.reason_type,
|
||||
remark=req.remark or "",
|
||||
))
|
||||
try:
|
||||
await db.commit()
|
||||
except IntegrityError:
|
||||
await db.rollback()
|
||||
raise BizException(errors.REPORT_DUPLICATED)
|
||||
@@ -0,0 +1,50 @@
|
||||
"""平台配置服务：system_configs 表 + Redis 缓存 60s（后台修改即时生效）"""
|
||||
from typing import Any
|
||||
|
||||
import redis.asyncio as aioredis
|
||||
from sqlalchemy import select
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.models.common import SystemConfig
|
||||
|
||||
CACHE_KEY = "config:system"
|
||||
CACHE_TTL = 60
|
||||
|
||||
|
||||
async def get_all_configs(db: AsyncSession, redis: aioredis.Redis) -> dict[str, str]:
|
||||
"""全量读取配置（Redis Hash 缓存 60s）"""
|
||||
cached = await redis.hgetall(CACHE_KEY) # type: ignore[misc]
|
||||
if cached:
|
||||
return dict(cached)
|
||||
rows = (await db.execute(select(SystemConfig))).scalars().all()
|
||||
configs = {row.config_key: row.config_value for row in rows}
|
||||
if configs:
|
||||
await redis.hset(CACHE_KEY, mapping=configs) # type: ignore[misc]
|
||||
await redis.expire(CACHE_KEY, CACHE_TTL)
|
||||
return configs
|
||||
|
||||
|
||||
async def get_config(db: AsyncSession, redis: aioredis.Redis, key: str, default: Any = None) -> str | Any:
|
||||
"""读取单个配置项"""
|
||||
configs = await get_all_configs(db, redis)
|
||||
return configs.get(key, default)
|
||||
|
||||
|
||||
async def get_config_int(db: AsyncSession, redis: aioredis.Redis, key: str, default: int) -> int:
|
||||
value = await get_config(db, redis, key, None)
|
||||
try:
|
||||
return int(value) if value is not None else default
|
||||
except (TypeError, ValueError):
|
||||
return default
|
||||
|
||||
|
||||
async def set_config(db: AsyncSession, redis: aioredis.Redis, key: str, value: str, admin_id: int | None = None) -> None:
|
||||
"""写入配置并失效缓存（后台调用）"""
|
||||
row = await db.get(SystemConfig, key)
|
||||
if row is None:
|
||||
db.add(SystemConfig(config_key=key, config_value=value, updated_by=admin_id))
|
||||
else:
|
||||
row.config_value = value
|
||||
row.updated_by = admin_id
|
||||
await db.commit()
|
||||
await redis.delete(CACHE_KEY)
|
||||
@@ -0,0 +1,324 @@
|
||||
"""激励服务：资产钱包 / 推荐绑定 / 提现（对应《03-接口文档》第 9 章、《02-技术文档》6.6）"""
|
||||
from datetime import datetime, timedelta
|
||||
from decimal import Decimal
|
||||
|
||||
import redis.asyncio as aioredis
|
||||
from sqlalchemy import func, select
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.config import biz_config
|
||||
from app.core import errors
|
||||
from app.core.response import BizException
|
||||
from app.models.incentive import AssetTransaction, AssetWallet, Referral, Withdrawal
|
||||
from app.models.user import User
|
||||
from app.services import config_service, membership_service
|
||||
|
||||
# 资产流水业务类型（与 asset_transactions.biz_type 注释一致）
|
||||
ASSET_BIZ_REBATE = 1 # 充值返利
|
||||
ASSET_BIZ_COMPLETE = 2 # 完整观看收益
|
||||
ASSET_BIZ_LIKE = 3 # 点赞收益
|
||||
ASSET_BIZ_WITHDRAW = 4 # 提现
|
||||
ASSET_BIZ_WITHDRAW_BACK = 5 # 提现退回
|
||||
ASSET_BIZ_CLAWBACK = 6 # 返利扣回
|
||||
ASSET_BIZ_ADJUST = 7 # 后台调整
|
||||
|
||||
# 提现单在途锁兜底过期（正常由后台审核后释放）
|
||||
WD_LOCK_TTL = 7 * 24 * 3600
|
||||
# 补绑邀请码时限：注册后 24h 内
|
||||
BIND_WINDOW_HOURS = 24
|
||||
|
||||
REFERRAL_STATUS_TEXT = {0: "待激活", 1: "有效", 2: "无效", 3: "风控冻结"}
|
||||
WITHDRAW_STATUS_TEXT = {0: "待审核", 1: "已打款", 2: "已拒绝"}
|
||||
|
||||
|
||||
def _fmt(dt: datetime | None) -> str | None:
|
||||
return dt.strftime("%Y-%m-%d %H:%M:%S") if dt else None
|
||||
|
||||
|
||||
def _asset_cfg() -> dict:
|
||||
return biz_config.get("asset") or {}
|
||||
|
||||
|
||||
def _withdraw_cfg() -> dict:
|
||||
return biz_config.get("withdraw") or {}
|
||||
|
||||
|
||||
# ---------- 资产钱包变更（与积分钱包同一套"行锁 + 流水 + 乐观锁"规范） ----------
|
||||
|
||||
async def get_or_create_asset_wallet(db: AsyncSession, user_id: int, for_update: bool = False) -> AssetWallet:
|
||||
stmt = select(AssetWallet).where(AssetWallet.user_id == user_id)
|
||||
if for_update:
|
||||
stmt = stmt.with_for_update()
|
||||
wallet = (await db.execute(stmt)).scalar_one_or_none()
|
||||
if wallet is None:
|
||||
wallet = AssetWallet(user_id=user_id)
|
||||
db.add(wallet)
|
||||
await db.flush()
|
||||
if for_update:
|
||||
wallet = (await db.execute(stmt)).scalar_one()
|
||||
return wallet
|
||||
|
||||
|
||||
async def change_assets(
|
||||
db: AsyncSession,
|
||||
user_id: int,
|
||||
amount: Decimal,
|
||||
biz_type: int,
|
||||
biz_id: str = "",
|
||||
remark: str = "",
|
||||
allow_negative: bool = False,
|
||||
) -> Decimal:
|
||||
"""变更资产余额，返回变动后余额。
|
||||
|
||||
- amount 正增负减；扣减默认不允许透支（退款/返利扣回场景传 allow_negative=True）
|
||||
- 同事务内：行锁 → 校验/更新余额与累计 → 写流水
|
||||
"""
|
||||
wallet = await get_or_create_asset_wallet(db, user_id, for_update=True)
|
||||
new_balance = wallet.assets + amount
|
||||
if amount < 0 and new_balance < 0 and not allow_negative:
|
||||
raise BizException(errors.ASSET_NOT_ENOUGH)
|
||||
|
||||
wallet.assets = new_balance
|
||||
wallet.version += 1
|
||||
if amount > 0:
|
||||
wallet.total_earned += amount
|
||||
elif biz_type == ASSET_BIZ_WITHDRAW:
|
||||
wallet.total_withdrawn += -amount
|
||||
|
||||
db.add(
|
||||
AssetTransaction(
|
||||
user_id=user_id,
|
||||
change_amount=amount,
|
||||
balance_after=new_balance,
|
||||
biz_type=biz_type,
|
||||
biz_id=biz_id,
|
||||
remark=remark,
|
||||
)
|
||||
)
|
||||
await db.flush()
|
||||
return new_balance
|
||||
|
||||
|
||||
# ---------- 推荐 ----------
|
||||
|
||||
async def get_my_referral(db: AsyncSession, redis: aioredis.Redis, user_id: int) -> dict:
|
||||
"""我的邀请（9.1）：邀请码 + 统计 + 当前会员身份（eligible）"""
|
||||
user = await db.get(User, user_id)
|
||||
if user is None:
|
||||
raise BizException(errors.UNAUTHORIZED, http_status=401)
|
||||
|
||||
base_url = await config_service.get_config(db, redis, "app.invite_base_url", "https://app.example.com/r/")
|
||||
total_invitees = (await db.execute(
|
||||
select(func.count(Referral.id)).where(Referral.inviter_id == user_id)
|
||||
)).scalar() or 0
|
||||
activated_count = (await db.execute(
|
||||
select(func.count(Referral.id)).where(
|
||||
Referral.inviter_id == user_id, Referral.status == 1
|
||||
)
|
||||
)).scalar() or 0
|
||||
# 邀请积分奖励累计（point_transactions biz_type=8）
|
||||
from app.models.billing import PointTransaction
|
||||
|
||||
reward_points_total = (await db.execute(
|
||||
select(func.coalesce(func.sum(PointTransaction.change_amount), 0)).where(
|
||||
PointTransaction.user_id == user_id, PointTransaction.biz_type == 8
|
||||
)
|
||||
)).scalar() or 0
|
||||
# 充值返利资产累计（asset_transactions biz_type=1）
|
||||
rebate_assets_total = (await db.execute(
|
||||
select(func.coalesce(func.sum(AssetTransaction.change_amount), 0)).where(
|
||||
AssetTransaction.user_id == user_id, AssetTransaction.biz_type == ASSET_BIZ_REBATE
|
||||
)
|
||||
)).scalar() or 0
|
||||
|
||||
return {
|
||||
"invite_code": user.invite_code,
|
||||
"invite_url": f"{base_url}{user.invite_code}",
|
||||
"eligible": await membership_service.is_member(db, user_id),
|
||||
"total_invitees": total_invitees,
|
||||
"activated_count": activated_count,
|
||||
"reward_points_total": int(reward_points_total),
|
||||
"rebate_assets_total": float(rebate_assets_total),
|
||||
}
|
||||
|
||||
|
||||
async def bind_invite_code(
|
||||
db: AsyncSession, redis: aioredis.Redis, user_id: int, invite_code: str, device_id: str | None, ip: str
|
||||
) -> dict:
|
||||
"""补绑邀请码（9.2）：注册 24h 内仅一次；无效码/已绑定/绑自己/同设备均 2101"""
|
||||
user = await db.get(User, user_id)
|
||||
if user is None:
|
||||
raise BizException(errors.UNAUTHORIZED, http_status=401)
|
||||
|
||||
bound = (await db.execute(
|
||||
select(Referral.id).where(Referral.invitee_id == user_id)
|
||||
)).first()
|
||||
if bound:
|
||||
raise BizException(errors.INVITE_CODE_INVALID, "已绑定过邀请码")
|
||||
if user.created_at < datetime.now() - timedelta(hours=BIND_WINDOW_HOURS):
|
||||
raise BizException(errors.INVITE_CODE_INVALID, "超过绑定时限（注册后24小时内可绑定）")
|
||||
|
||||
inviter = (await db.execute(
|
||||
select(User).where(User.invite_code == invite_code)
|
||||
)).scalar_one_or_none()
|
||||
if inviter is None:
|
||||
raise BizException(errors.INVITE_CODE_INVALID, "邀请码无效")
|
||||
if inviter.id == user_id:
|
||||
raise BizException(errors.INVITE_CODE_INVALID, "不能绑定自己的邀请码")
|
||||
if device_id and await redis.exists(f"ref:device:{device_id}"):
|
||||
old = int(await redis.get(f"ref:device:{device_id}") or 0)
|
||||
if old and old != user_id:
|
||||
raise BizException(errors.INVITE_CODE_INVALID, "当前设备已注册其他账号")
|
||||
|
||||
# 风控规则与注册时一致（邀请人单日超限冻结 / 同 IP 批量注册标记）
|
||||
status, risk_flag = 0, ""
|
||||
risk_key = f"ref:risk:{inviter.id}:{datetime.now():%Y%m%d}"
|
||||
bind_count = await redis.incr(risk_key)
|
||||
await redis.expire(risk_key, 48 * 3600)
|
||||
max_bind = (biz_config.get("referral") or {}).get("risk_max_bind_per_day", 10)
|
||||
if bind_count > max_bind:
|
||||
status, risk_flag = 3, "inviter_burst"
|
||||
else:
|
||||
max_reg = (biz_config.get("referral") or {}).get("risk_max_register_per_ip", 5)
|
||||
cnt = (await db.execute(
|
||||
select(func.count(User.id)).where(
|
||||
User.register_ip == ip, User.created_at > datetime.now() - timedelta(hours=24)
|
||||
)
|
||||
)).scalar() or 0
|
||||
if cnt > max_reg:
|
||||
status, risk_flag = 3, "batch_register"
|
||||
|
||||
db.add(Referral(
|
||||
inviter_id=inviter.id,
|
||||
invitee_id=user_id,
|
||||
invite_code=invite_code,
|
||||
status=status,
|
||||
risk_flag=risk_flag,
|
||||
register_ip=ip,
|
||||
))
|
||||
await db.commit()
|
||||
return {"bound": True, "status": status, "status_text": REFERRAL_STATUS_TEXT[status]}
|
||||
|
||||
|
||||
# ---------- 资产 / 提现 ----------
|
||||
|
||||
async def get_my_assets(db: AsyncSession, redis: aioredis.Redis, user_id: int) -> dict:
|
||||
"""资产钱包（9.3）"""
|
||||
wallet = await get_or_create_asset_wallet(db, user_id)
|
||||
per_yuan = Decimal(str(_asset_cfg().get("assets_per_yuan", 10)))
|
||||
has_pending = bool(await redis.exists(f"wd:pending:{user_id}")) or bool(
|
||||
(await db.execute(
|
||||
select(Withdrawal.id).where(Withdrawal.user_id == user_id, Withdrawal.status == 0)
|
||||
)).first()
|
||||
)
|
||||
return {
|
||||
"assets": float(wallet.assets),
|
||||
"assets_value_yuan": float(wallet.assets / per_yuan),
|
||||
"total_earned": float(wallet.total_earned),
|
||||
"total_withdrawn": float(wallet.total_withdrawn),
|
||||
"min_withdraw_assets": int(_withdraw_cfg().get("min_assets", 100)),
|
||||
"has_pending_withdraw": has_pending,
|
||||
}
|
||||
|
||||
|
||||
async def list_asset_records(
|
||||
db: AsyncSession, user_id: int, page: int, page_size: int, biz_type: int | None
|
||||
) -> dict:
|
||||
"""资产流水（9.4）"""
|
||||
stmt = select(AssetTransaction).where(AssetTransaction.user_id == user_id)
|
||||
if biz_type is not None:
|
||||
stmt = stmt.where(AssetTransaction.biz_type == biz_type)
|
||||
total = (await db.execute(select(func.count()).select_from(stmt.subquery()))).scalar() or 0
|
||||
rows = (
|
||||
await db.execute(
|
||||
stmt.order_by(AssetTransaction.id.desc()).offset((page - 1) * page_size).limit(page_size)
|
||||
)
|
||||
).scalars().all()
|
||||
return {
|
||||
"total": total,
|
||||
"list": [
|
||||
{
|
||||
"id": r.id,
|
||||
"change_amount": float(r.change_amount),
|
||||
"balance_after": float(r.balance_after),
|
||||
"biz_type": r.biz_type,
|
||||
"remark": r.remark,
|
||||
"created_at": _fmt(r.created_at),
|
||||
}
|
||||
for r in rows
|
||||
],
|
||||
}
|
||||
|
||||
|
||||
async def apply_withdraw(
|
||||
db: AsyncSession, redis: aioredis.Redis, user_id: int, assets: Decimal, channel: int, account: str
|
||||
) -> dict:
|
||||
"""申请提现（9.5）：在途锁防并发 → 事务内冻结扣减 + 建单；审核拒绝由后台退回并释放锁"""
|
||||
min_assets = int(_withdraw_cfg().get("min_assets", 100))
|
||||
if assets < min_assets:
|
||||
raise BizException(errors.WITHDRAW_TOO_LOW)
|
||||
|
||||
lock_key = f"wd:pending:{user_id}"
|
||||
if not await redis.set(lock_key, 1, nx=True, ex=WD_LOCK_TTL):
|
||||
raise BizException(errors.WITHDRAW_PENDING)
|
||||
try:
|
||||
# 双保险：DB 层存在待审核单也拦截（锁丢失场景）
|
||||
if (await db.execute(
|
||||
select(Withdrawal.id).where(Withdrawal.user_id == user_id, Withdrawal.status == 0)
|
||||
)).first():
|
||||
raise BizException(errors.WITHDRAW_PENDING)
|
||||
|
||||
per_yuan = Decimal(str(_asset_cfg().get("assets_per_yuan", 10)))
|
||||
amount_fen = int((assets / per_yuan) * 100) # 10资产=1元 → 1资产=10分
|
||||
# 冻结扣减（余额不足抛 2102，事务回滚）
|
||||
await change_assets(
|
||||
db, user_id, -assets, ASSET_BIZ_WITHDRAW,
|
||||
remark=f"申请提现冻结（{account}）",
|
||||
)
|
||||
wd = Withdrawal(
|
||||
withdraw_no=membership_service.gen_order_no("W"),
|
||||
user_id=user_id,
|
||||
assets=assets,
|
||||
amount_fen=amount_fen,
|
||||
channel=channel,
|
||||
account=account,
|
||||
)
|
||||
db.add(wd)
|
||||
await db.commit()
|
||||
except Exception:
|
||||
await redis.delete(lock_key) # 建单失败释放锁
|
||||
raise
|
||||
|
||||
return {
|
||||
"withdraw_no": wd.withdraw_no,
|
||||
"assets": float(wd.assets),
|
||||
"amount_yuan": float(Decimal(wd.amount_fen) / 100),
|
||||
"status": 0,
|
||||
"status_text": WITHDRAW_STATUS_TEXT[0],
|
||||
}
|
||||
|
||||
|
||||
async def list_withdraw_records(db: AsyncSession, user_id: int, page: int, page_size: int) -> dict:
|
||||
"""提现记录（9.6）"""
|
||||
stmt = select(Withdrawal).where(Withdrawal.user_id == user_id)
|
||||
total = (await db.execute(select(func.count()).select_from(stmt.subquery()))).scalar() or 0
|
||||
rows = (
|
||||
await db.execute(
|
||||
stmt.order_by(Withdrawal.id.desc()).offset((page - 1) * page_size).limit(page_size)
|
||||
)
|
||||
).scalars().all()
|
||||
return {
|
||||
"total": total,
|
||||
"list": [
|
||||
{
|
||||
"withdraw_no": w.withdraw_no,
|
||||
"assets": float(w.assets),
|
||||
"amount_yuan": float(Decimal(w.amount_fen) / 100),
|
||||
"channel": w.channel,
|
||||
"status": w.status,
|
||||
"status_text": WITHDRAW_STATUS_TEXT.get(w.status, ""),
|
||||
"created_at": _fmt(w.created_at),
|
||||
}
|
||||
for w in rows
|
||||
],
|
||||
}
|
||||
@@ -0,0 +1,321 @@
|
||||
"""互动服务：点赞 / 收藏 / 评论 / 我的收藏 / 观看历史（对应《03-接口文档》第 6 章）"""
|
||||
from datetime import datetime
|
||||
|
||||
import redis.asyncio as aioredis
|
||||
from sqlalchemy import func, select
|
||||
from sqlalchemy.dialects.mysql import insert as mysql_insert
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.config import biz_config
|
||||
from app.core import errors
|
||||
from app.core.response import BizException
|
||||
from app.models.billing import WatchRecord
|
||||
from app.models.incentive import VideoEarning
|
||||
from app.models.interaction import Comment, Favorite, Like
|
||||
from app.models.user import User
|
||||
from app.models.video import Video
|
||||
from app.services import sensitive_service, video_service, wallet_service
|
||||
|
||||
|
||||
def _fmt(dt: datetime | None) -> str | None:
|
||||
return dt.strftime("%Y-%m-%d %H:%M:%S") if dt else None
|
||||
|
||||
|
||||
def _reward_cfg() -> dict:
|
||||
return (biz_config.get("points") or {}).get("comment_reward") or {}
|
||||
|
||||
|
||||
async def _get_published_video(db: AsyncSession, video_id: int) -> Video:
|
||||
video = await db.get(Video, video_id)
|
||||
if video is None or video.status != video_service.STATUS_PUBLISHED:
|
||||
raise BizException(errors.VIDEO_NOT_AVAILABLE)
|
||||
return video
|
||||
|
||||
|
||||
# ---------- 点赞 / 收藏 ----------
|
||||
|
||||
async def toggle_like(db: AsyncSession, redis: aioredis.Redis, user_id: int, video_id: int) -> dict:
|
||||
"""切换点赞：明细 + 计数 + 创作者收益刻度（likes_accrued）同事务，取消会回退"""
|
||||
video = await _get_published_video(db, video_id)
|
||||
existing = (await db.execute(
|
||||
select(Like).where(Like.user_id == user_id, Like.video_id == video_id)
|
||||
)).scalar_one_or_none()
|
||||
|
||||
if existing:
|
||||
await db.delete(existing)
|
||||
video.like_count = max(video.like_count - 1, 0)
|
||||
is_liked = False
|
||||
stmt = mysql_insert(VideoEarning).values(video_id=video_id, author_id=video.user_id, likes_accrued=0)
|
||||
stmt = stmt.on_duplicate_key_update(likes_accrued=func.greatest(VideoEarning.likes_accrued - 1, 0))
|
||||
await db.execute(stmt)
|
||||
else:
|
||||
db.add(Like(user_id=user_id, video_id=video_id))
|
||||
video.like_count += 1
|
||||
is_liked = True
|
||||
stmt = mysql_insert(VideoEarning).values(video_id=video_id, author_id=video.user_id, likes_accrued=1)
|
||||
stmt = stmt.on_duplicate_key_update(likes_accrued=VideoEarning.likes_accrued + 1)
|
||||
await db.execute(stmt)
|
||||
|
||||
await db.commit()
|
||||
await video_service.invalidate_detail_cache(redis, video_id)
|
||||
return {"is_liked": is_liked, "like_count": video.like_count}
|
||||
|
||||
|
||||
async def toggle_favorite(db: AsyncSession, redis: aioredis.Redis, user_id: int, video_id: int) -> dict:
|
||||
"""切换收藏：明细 + 计数同事务"""
|
||||
video = await _get_published_video(db, video_id)
|
||||
existing = (await db.execute(
|
||||
select(Favorite).where(Favorite.user_id == user_id, Favorite.video_id == video_id)
|
||||
)).scalar_one_or_none()
|
||||
|
||||
if existing:
|
||||
await db.delete(existing)
|
||||
video.favorite_count = max(video.favorite_count - 1, 0)
|
||||
is_favorited = False
|
||||
else:
|
||||
db.add(Favorite(user_id=user_id, video_id=video_id))
|
||||
video.favorite_count += 1
|
||||
is_favorited = True
|
||||
|
||||
await db.commit()
|
||||
await video_service.invalidate_detail_cache(redis, video_id)
|
||||
return {"is_favorited": is_favorited, "favorite_count": video.favorite_count}
|
||||
|
||||
|
||||
# ---------- 评论 ----------
|
||||
|
||||
async def list_comments(
|
||||
db: AsyncSession, video_id: int, page: int, page_size: int, parent_id: int
|
||||
) -> dict:
|
||||
"""评论列表：parent_id=0 查一级评论（带 reply_count），否则查二级回复"""
|
||||
stmt = select(Comment).where(
|
||||
Comment.video_id == video_id, Comment.parent_id == parent_id, Comment.status == 1
|
||||
)
|
||||
total = (await db.execute(select(func.count()).select_from(stmt.subquery()))).scalar() or 0
|
||||
rows = (
|
||||
await db.execute(
|
||||
stmt.order_by(Comment.id.desc()).offset((page - 1) * page_size).limit(page_size)
|
||||
)
|
||||
).scalars().all()
|
||||
|
||||
users = {
|
||||
u.id: u
|
||||
for u in (await db.execute(
|
||||
select(User).where(User.id.in_({c.user_id for c in rows} or {0}))
|
||||
)).scalars()
|
||||
}
|
||||
|
||||
# 一级评论批量统计回复数
|
||||
reply_counts: dict[int, int] = {}
|
||||
if parent_id == 0 and rows:
|
||||
rc = await db.execute(
|
||||
select(Comment.parent_id, func.count())
|
||||
.where(Comment.parent_id.in_([c.id for c in rows]), Comment.status == 1)
|
||||
.group_by(Comment.parent_id)
|
||||
)
|
||||
reply_counts = {pid: cnt for pid, cnt in rc.all()}
|
||||
|
||||
return {
|
||||
"total": total,
|
||||
"list": [
|
||||
{
|
||||
"comment_id": c.id,
|
||||
"user": {
|
||||
"user_id": c.user_id,
|
||||
"nickname": users[c.user_id].nickname if c.user_id in users else "",
|
||||
"avatar_url": users[c.user_id].avatar_url if c.user_id in users else "",
|
||||
},
|
||||
"content": c.content,
|
||||
"like_count": c.like_count,
|
||||
"reply_count": reply_counts.get(c.id, 0),
|
||||
"created_at": _fmt(c.created_at),
|
||||
}
|
||||
for c in rows
|
||||
],
|
||||
}
|
||||
|
||||
|
||||
async def _read_prog(redis: aioredis.Redis, user_id: int, today: str) -> tuple[int, int]:
|
||||
"""读取当日评论奖励进度（count 当前进度 / daily 当日已发奖次数），跨日自动清零"""
|
||||
prog = await redis.hgetall(f"comment:prog:{user_id}") # type: ignore[misc]
|
||||
if prog.get("date") != today:
|
||||
return 0, 0
|
||||
return int(prog.get("count", 0)), int(prog.get("daily", 0))
|
||||
|
||||
|
||||
async def _write_prog(redis: aioredis.Redis, user_id: int, today: str, count: int, daily: int) -> None:
|
||||
key = f"comment:prog:{user_id}"
|
||||
await redis.hset(key, mapping={"count": count, "daily": daily, "date": today}) # type: ignore[misc]
|
||||
await redis.expire(key, 48 * 3600)
|
||||
|
||||
|
||||
async def create_comment(
|
||||
db: AsyncSession, redis: aioredis.Redis, user_id: int, video_id: int, req
|
||||
) -> dict:
|
||||
"""发表评论：敏感词 → 落库 + 计数 → ≥min_length 字计入积分进度，满 per_count 自动发奖"""
|
||||
video = await _get_published_video(db, video_id)
|
||||
if await sensitive_service.find_sensitive(db, redis, req.content):
|
||||
raise BizException(errors.SENSITIVE_WORD)
|
||||
|
||||
parent_id = int(req.parent_id or 0)
|
||||
if parent_id:
|
||||
parent = await db.get(Comment, parent_id)
|
||||
if parent is None or parent.video_id != video_id or parent.status != 1:
|
||||
raise BizException(errors.NOT_FOUND, "回复的评论不存在")
|
||||
|
||||
cfg = _reward_cfg()
|
||||
per_count = int(cfg.get("per_count", 10))
|
||||
reward = int(cfg.get("reward", 1))
|
||||
min_length = int(cfg.get("min_length", 5))
|
||||
daily_limit = int(cfg.get("daily_limit", 5))
|
||||
today = f"{datetime.now():%Y%m%d}"
|
||||
|
||||
comment = Comment(
|
||||
video_id=video_id,
|
||||
user_id=user_id,
|
||||
parent_id=parent_id,
|
||||
reply_to_user_id=req.reply_to_user_id,
|
||||
content=req.content,
|
||||
)
|
||||
video.comment_count += 1
|
||||
|
||||
rewarded_this_time = False
|
||||
counted = len(req.content) >= min_length # 字数达标才计入进度
|
||||
count, daily = await _read_prog(redis, user_id, today)
|
||||
|
||||
if counted:
|
||||
count += 1
|
||||
comment.reward_counted = 1
|
||||
if count >= per_count and daily < daily_limit:
|
||||
# 满刻度自动发奖：清零进度，标记该评论触发过发奖（删评时扣回）
|
||||
await wallet_service.change_points(
|
||||
db, user_id, reward, wallet_service.BIZ_COMMENT,
|
||||
biz_id=str(video_id), remark="评论奖励",
|
||||
)
|
||||
count, daily = 0, daily + 1
|
||||
comment.reward_counted = 2
|
||||
rewarded_this_time = True
|
||||
await _write_prog(redis, user_id, today, count, daily)
|
||||
|
||||
db.add(comment)
|
||||
await db.commit()
|
||||
await video_service.invalidate_detail_cache(redis, video_id)
|
||||
|
||||
progress: dict = {"current": count, "target": per_count, "rewarded_this_time": rewarded_this_time}
|
||||
if rewarded_this_time:
|
||||
progress["reward_points"] = reward
|
||||
return {"comment_id": comment.id, "reward_progress": progress}
|
||||
|
||||
|
||||
async def remove_comment(db: AsyncSession, redis: aioredis.Redis, comment: Comment) -> dict:
|
||||
"""删除评论核心逻辑（作者自删 / 视频作者删除 / 后台删除共用）：已计入进度的回退，已发奖的扣回"""
|
||||
video = await db.get(Video, comment.video_id)
|
||||
|
||||
cfg = _reward_cfg()
|
||||
per_count = int(cfg.get("per_count", 10))
|
||||
reward = int(cfg.get("reward", 1))
|
||||
today = f"{datetime.now():%Y%m%d}"
|
||||
# 进度归属评论作者（删除者可能是视频作者或管理员）
|
||||
count, daily = await _read_prog(redis, comment.user_id, today)
|
||||
|
||||
if comment.reward_counted == 1:
|
||||
# 仅计入进度：回退一格
|
||||
count = max(count - 1, 0)
|
||||
await _write_prog(redis, comment.user_id, today, count, daily)
|
||||
elif comment.reward_counted == 2:
|
||||
# 该评论触发过发奖：扣回积分（余额不足则扣到 0），当日已发次数回退
|
||||
wallet = await wallet_service.get_or_create_wallet(db, comment.user_id, for_update=True)
|
||||
clawback = min(reward, wallet.points)
|
||||
if clawback > 0:
|
||||
await wallet_service.change_points(
|
||||
db, comment.user_id, -clawback, wallet_service.BIZ_CLAWBACK,
|
||||
biz_id=str(comment.id), remark="删除评论扣回奖励",
|
||||
)
|
||||
daily = max(daily - 1, 0)
|
||||
await _write_prog(redis, comment.user_id, today, count, daily)
|
||||
|
||||
comment.status = 2
|
||||
comment.reward_counted = 0
|
||||
if video is not None:
|
||||
video.comment_count = max(video.comment_count - 1, 0)
|
||||
await db.commit()
|
||||
if video is not None:
|
||||
await video_service.invalidate_detail_cache(redis, video.id)
|
||||
return {"reward_progress": {"current": count, "target": per_count}}
|
||||
|
||||
|
||||
async def delete_comment(
|
||||
db: AsyncSession, redis: aioredis.Redis, user_id: int, comment_id: int
|
||||
) -> dict:
|
||||
"""删除评论（App 端）：本人评论或本人视频下的评论可删"""
|
||||
comment = await db.get(Comment, comment_id)
|
||||
if comment is None or comment.status != 1:
|
||||
raise BizException(errors.NOT_FOUND, "评论不存在")
|
||||
video = await db.get(Video, comment.video_id)
|
||||
if comment.user_id != user_id and (video is None or video.user_id != user_id):
|
||||
raise BizException(errors.FORBIDDEN, "无权删除该评论")
|
||||
return await remove_comment(db, redis, comment)
|
||||
|
||||
|
||||
# ---------- 我的收藏 / 观看历史 ----------
|
||||
|
||||
async def list_my_favorites(
|
||||
db: AsyncSession, user_id: int, page: int, page_size: int
|
||||
) -> dict:
|
||||
"""我的收藏：仅已发布视频，按收藏时间倒序，结构同 Feed 单条"""
|
||||
stmt = (
|
||||
select(Video, Favorite.created_at)
|
||||
.join(Favorite, Favorite.video_id == Video.id)
|
||||
.where(Favorite.user_id == user_id, Video.status == video_service.STATUS_PUBLISHED)
|
||||
)
|
||||
total = (await db.execute(
|
||||
select(func.count()).select_from(
|
||||
select(Favorite.id).join(Video, Video.id == Favorite.video_id).where(
|
||||
Favorite.user_id == user_id, Video.status == video_service.STATUS_PUBLISHED
|
||||
).subquery()
|
||||
)
|
||||
)).scalar() or 0
|
||||
rows = (
|
||||
await db.execute(
|
||||
stmt.order_by(Favorite.id.desc()).offset((page - 1) * page_size).limit(page_size)
|
||||
)
|
||||
).all()
|
||||
return {
|
||||
"total": total,
|
||||
"list": await video_service.serialize_videos(db, [v for v, _ in rows], user_id),
|
||||
}
|
||||
|
||||
|
||||
async def list_my_history(
|
||||
db: AsyncSession, user_id: int, page: int, page_size: int
|
||||
) -> dict:
|
||||
"""观看历史：每项 video（同 Feed 单条）+ watched_at + cost_type，按观看时间倒序"""
|
||||
base = (
|
||||
select(Video, WatchRecord.created_at, WatchRecord.cost_type)
|
||||
.join(WatchRecord, WatchRecord.video_id == Video.id)
|
||||
.where(
|
||||
WatchRecord.subject_type == 1,
|
||||
WatchRecord.subject_id == str(user_id),
|
||||
Video.status == video_service.STATUS_PUBLISHED,
|
||||
)
|
||||
)
|
||||
total = (await db.execute(
|
||||
select(func.count()).select_from(
|
||||
select(WatchRecord.id).join(Video, Video.id == WatchRecord.video_id).where(
|
||||
WatchRecord.subject_type == 1,
|
||||
WatchRecord.subject_id == str(user_id),
|
||||
Video.status == video_service.STATUS_PUBLISHED,
|
||||
).subquery()
|
||||
)
|
||||
)).scalar() or 0
|
||||
rows = (
|
||||
await db.execute(
|
||||
base.order_by(WatchRecord.id.desc()).offset((page - 1) * page_size).limit(page_size)
|
||||
)
|
||||
).all()
|
||||
|
||||
videos = await video_service.serialize_videos(db, [v for v, _, _ in rows], user_id)
|
||||
items = []
|
||||
for (v, watched_at, cost_type), serialized in zip(rows, videos):
|
||||
items.append({"video": serialized, "watched_at": _fmt(watched_at), "cost_type": cost_type})
|
||||
return {"total": total, "list": items}
|
||||
@@ -0,0 +1,169 @@
|
||||
"""推广归因服务：点击埋点 / 模糊匹配 / H5 中间页
|
||||
|
||||
三段式自建方案的辅助路径：
|
||||
1. 分享口令（剪贴板）→ 注册时显式 invite_code，准确率 100%（主路径，App 端解析）
|
||||
2. H5 中间页点击埋点（code+IP+UA 存 Redis 24h）→ App 首启上报 device_id 模糊匹配（本模块）
|
||||
3. 注册页邀请码手填（兜底，沿用 /auth/register 的 invite_code 字段）
|
||||
|
||||
安全设计：模糊匹配结果由服务端按 device_id 缓存（invite:attr:{device_id}），
|
||||
注册时服务端自取并一次性消费，不信任客户端回传，防止伪造归因。
|
||||
"""
|
||||
import html
|
||||
import json
|
||||
import time
|
||||
|
||||
import redis.asyncio as aioredis
|
||||
from sqlalchemy import select
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.models.user import User
|
||||
from app.services import config_service
|
||||
|
||||
CLICK_TTL = 24 * 3600 # 点击记录有效期（超过 24h 未安装不再归因）
|
||||
ATTR_TTL = 7 * 24 * 3600 # 归因结果缓存（命中后允许延迟安装注册）
|
||||
CLICK_DUP_TTL = 60 # 同 IP+code 60s 内重复埋点去重
|
||||
MATCH_CANDIDATES = 5 # 同 IP 最近点击候选数
|
||||
|
||||
|
||||
def _ip_key(ip: str) -> str:
|
||||
return f"invite:ip:{ip}"
|
||||
|
||||
|
||||
def _clk_key(code: str, ip: str) -> str:
|
||||
return f"invite:clk:{code}:{ip}"
|
||||
|
||||
|
||||
def attr_key(device_id: str) -> str:
|
||||
return f"invite:attr:{device_id}"
|
||||
|
||||
|
||||
# ---------- 点击埋点 ----------
|
||||
|
||||
async def record_click(redis: aioredis.Redis, code: str, ip: str, ua: str) -> dict:
|
||||
"""H5 中间页点击埋点：IP 维度 zset（score=时间戳）+ 点击详情"""
|
||||
if not ip:
|
||||
return {"recorded": False}
|
||||
# 60s 内同 IP+code 重复点击去重（页面刷新/重复打开）
|
||||
dup = await redis.set(f"invite:dup:{ip}:{code}", 1, nx=True, ex=CLICK_DUP_TTL)
|
||||
if not dup:
|
||||
return {"recorded": True, "dedup": True}
|
||||
now = time.time()
|
||||
await redis.zadd(_ip_key(ip), {code: now})
|
||||
await redis.expire(_ip_key(ip), CLICK_TTL)
|
||||
await redis.set(_clk_key(code, ip), json.dumps({"ua": ua, "ts": now}), ex=CLICK_TTL)
|
||||
return {"recorded": True}
|
||||
|
||||
|
||||
# ---------- 归因匹配 ----------
|
||||
|
||||
async def match_and_cache(redis: aioredis.Redis, device_id: str, ip: str, ua: str) -> dict:
|
||||
"""App 首启归因：按 IP 取最近一次点击的邀请码，缓存到 device_id 维度（幂等）"""
|
||||
cached = await redis.get(attr_key(device_id))
|
||||
if cached:
|
||||
return {"matched": True, "invite_code": cached}
|
||||
|
||||
code = None
|
||||
if ip:
|
||||
# 最近点击优先（同 IP 可能点击过多个推广链接，时间近者为准）
|
||||
for c in await redis.zrevrange(_ip_key(ip), 0, MATCH_CANDIDATES - 1):
|
||||
if await redis.get(_clk_key(c, ip)):
|
||||
code = c
|
||||
break
|
||||
if not code:
|
||||
return {"matched": False}
|
||||
await redis.set(attr_key(device_id), code, ex=ATTR_TTL)
|
||||
return {"matched": True, "invite_code": code}
|
||||
|
||||
|
||||
async def pop_attribution(redis: aioredis.Redis, device_id: str) -> str | None:
|
||||
"""注册时取归因结果并一次性消费"""
|
||||
key = attr_key(device_id)
|
||||
code = await redis.get(key)
|
||||
if code:
|
||||
await redis.delete(key)
|
||||
return code
|
||||
|
||||
|
||||
# ---------- H5 中间页 ----------
|
||||
|
||||
_LANDING_HTML = """<!DOCTYPE html>
|
||||
<html lang="zh-CN">
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta name="viewport" content="width=device-width,initial-scale=1,maximum-scale=1">
|
||||
<title>邀请你加入短视频</title>
|
||||
<style>
|
||||
* {{ margin:0; padding:0; box-sizing:border-box; }}
|
||||
body {{ background:#0f0f14; color:#fff; font-family:-apple-system,"PingFang SC","Helvetica Neue",sans-serif;
|
||||
min-height:100vh; display:flex; flex-direction:column; align-items:center; justify-content:center; padding:32px 24px; }}
|
||||
.logo {{ width:88px; height:88px; border-radius:20px; display:flex; align-items:center; justify-content:center;
|
||||
background:linear-gradient(135deg,#fe2c55,#7c4dff); font-size:44px; margin-bottom:20px; }}
|
||||
h1 {{ font-size:22px; margin-bottom:8px; }}
|
||||
.sub {{ color:#9a9aa5; font-size:14px; margin-bottom:32px; text-align:center; line-height:1.6; }}
|
||||
.inviter {{ color:#ffd700; }}
|
||||
.btn {{ width:100%; max-width:320px; padding:15px 0; border:none; border-radius:12px; font-size:16px;
|
||||
font-weight:600; cursor:pointer; margin-bottom:14px; }}
|
||||
.btn-primary {{ background:linear-gradient(135deg,#fe2c55,#7c4dff); color:#fff; }}
|
||||
.btn-ghost {{ background:#1e1e28; color:#e8e8ec; border:1px solid #33333f; }}
|
||||
.code {{ color:#9a9aa5; font-size:13px; margin-top:10px; }}
|
||||
.code b {{ color:#ffd700; font-size:16px; letter-spacing:2px; }}
|
||||
#toast {{ position:fixed; left:50%; bottom:60px; transform:translateX(-50%); background:#333; color:#fff;
|
||||
padding:10px 20px; border-radius:8px; font-size:14px; opacity:0; transition:opacity .3s; }}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<div class="logo">▶</div>
|
||||
<h1>{title}</h1>
|
||||
<p class="sub">新人注册立送体验会员<br>复制口令后打开 App 即可自动绑定邀请</p>
|
||||
<button class="btn btn-primary" onclick="copyCmd()">复制邀请口令</button>
|
||||
{download_btn}
|
||||
<p class="code">我的邀请码 <b>{code}</b></p>
|
||||
<div id="toast"></div>
|
||||
<script>
|
||||
var CODE = "{code}";
|
||||
var CMD = "#短视频邀请码" + CODE + "#";
|
||||
// 打开页面即埋点（记录 code+IP+UA，安装首启后据此归因）
|
||||
fetch("/api/v1/invite/click", {{
|
||||
method: "POST",
|
||||
headers: {{ "Content-Type": "application/json" }},
|
||||
body: JSON.stringify({{ code: CODE }})
|
||||
}}).catch(function() {{}});
|
||||
function toast(t) {{
|
||||
var el = document.getElementById("toast");
|
||||
el.textContent = t; el.style.opacity = 1;
|
||||
setTimeout(function() {{ el.style.opacity = 0; }}, 1800);
|
||||
}}
|
||||
function copyCmd() {{
|
||||
var done = function() {{ toast("口令已复制，打开 App 自动识别"); }};
|
||||
if (navigator.clipboard && navigator.clipboard.writeText) {{
|
||||
navigator.clipboard.writeText(CMD).then(done, function() {{ fallback(); }});
|
||||
}} else {{ fallback(); }}
|
||||
function fallback() {{
|
||||
var ta = document.createElement("textarea");
|
||||
ta.value = CMD; document.body.appendChild(ta);
|
||||
ta.select(); try {{ document.execCommand("copy"); done(); }}
|
||||
catch (e) {{ toast("复制失败，请手动输入邀请码"); }}
|
||||
document.body.removeChild(ta);
|
||||
}}
|
||||
}}
|
||||
</script>
|
||||
</body>
|
||||
</html>
|
||||
"""
|
||||
|
||||
|
||||
async def render_landing_page(db: AsyncSession, redis: aioredis.Redis, code: str) -> str:
|
||||
"""推广落地页：展示邀请人 + 复制口令 + （可选）下载入口；页面加载即自动埋点"""
|
||||
inviter = (await db.execute(select(User).where(User.invite_code == code))).scalar_one_or_none()
|
||||
if inviter is not None:
|
||||
title = f'<span class="inviter">{html.escape(inviter.nickname)}</span> 邀请你加入短视频'
|
||||
else:
|
||||
title = "邀请你加入短视频"
|
||||
|
||||
download_url = await config_service.get_config(db, redis, "app.download_url", "")
|
||||
download_btn = (
|
||||
f'<button class="btn btn-ghost" onclick="location.href=\'{html.escape(download_url, quote=True)}\'">下载 APP</button>'
|
||||
if download_url else ""
|
||||
)
|
||||
safe_code = html.escape(code)
|
||||
return _LANDING_HTML.format(title=title, code=safe_code, download_btn=download_btn)
|
||||
@@ -0,0 +1,219 @@
|
||||
"""会员服务：状态查询与开通（叠加/互斥规则对齐《01-开发文档》2.4.3）"""
|
||||
import random
|
||||
from datetime import datetime, timedelta
|
||||
|
||||
from sqlalchemy import select
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.config import biz_config
|
||||
from app.core import errors
|
||||
from app.core.response import BizException
|
||||
from app.models.user import MembershipOrder, UserMembership
|
||||
|
||||
# 会员开通记录来源
|
||||
SOURCE_POINTS = 1 # 积分购买
|
||||
SOURCE_GIFT = 2 # 活动赠送
|
||||
|
||||
PLAN_NAMES = {"trial": "体验会员", "month": "月卡", "year": "年卡", "lifetime": "终身卡"}
|
||||
|
||||
# 套餐展示元数据（价格以 config.yaml / 后台配置为准，前端不硬编码）
|
||||
PLAN_META = {
|
||||
"trial": {"name": "体验会员", "desc": "1天体验，活动同享"},
|
||||
"month": {"name": "月卡", "desc": "30天无限观看"},
|
||||
"year": {"name": "年卡", "desc": "365天无限观看"},
|
||||
"lifetime": {"name": "终身卡", "desc": "永久无限观看"},
|
||||
}
|
||||
|
||||
PLAN_BENEFITS = ["无限观看视频", "优先上传（转码/审核优先）"]
|
||||
|
||||
|
||||
def gen_order_no(prefix: str = "M") -> str:
|
||||
"""业务单号：前缀 + 时间戳 + 随机"""
|
||||
return f"{prefix}{datetime.now():%Y%m%d%H%M%S}{random.randint(100000, 999999)}"
|
||||
|
||||
|
||||
async def get_membership(db: AsyncSession, user_id: int) -> UserMembership:
|
||||
ms = await db.get(UserMembership, user_id)
|
||||
if ms is None:
|
||||
ms = UserMembership(user_id=user_id)
|
||||
db.add(ms)
|
||||
await db.flush()
|
||||
return ms
|
||||
|
||||
|
||||
def membership_active(ms: UserMembership, now: datetime | None = None) -> bool:
|
||||
"""会员有效性判定（以 expire_at 为准，终身卡永久有效）"""
|
||||
now = now or datetime.now()
|
||||
if ms.is_lifetime:
|
||||
return True
|
||||
return ms.expire_at is not None and ms.expire_at > now
|
||||
|
||||
|
||||
async def is_member(db: AsyncSession, user_id: int) -> bool:
|
||||
ms = await db.get(UserMembership, user_id)
|
||||
return ms is not None and membership_active(ms)
|
||||
|
||||
|
||||
async def grant_membership(
|
||||
db: AsyncSession,
|
||||
user_id: int,
|
||||
plan_code: str,
|
||||
points_cost: int,
|
||||
source: int,
|
||||
days: int | None = None,
|
||||
) -> MembershipOrder:
|
||||
"""开通会员并写开通记录，返回订单。
|
||||
|
||||
- 有效期内重复开通：有效期叠加（max(now, expire_at) + days）
|
||||
- 体验会员期间开通付费卡：按付费卡生效，体验剩余时间不累加
|
||||
- 终身卡不可再开通其它套餐
|
||||
"""
|
||||
plan_cfg = (biz_config.get("membership") or {}).get(plan_code)
|
||||
if not plan_cfg or not plan_cfg.get("enabled", False):
|
||||
raise BizException(errors.PARAM_ERROR, "套餐不存在或未上架")
|
||||
duration_days = int(days if days is not None else plan_cfg.get("days", 0))
|
||||
|
||||
now = datetime.now()
|
||||
ms = await get_membership(db, user_id)
|
||||
|
||||
if ms.is_lifetime:
|
||||
raise BizException(errors.LIFETIME_MEMBER)
|
||||
|
||||
if duration_days == 0: # 终身卡
|
||||
start_at, end_at = now, None
|
||||
else:
|
||||
base = now
|
||||
# 付费卡叠加：当前为付费会员且未到期 → 在到期时间上叠加
|
||||
# 体验会员转付费卡：从当前时间重新计算（体验剩余不累加）
|
||||
if membership_active(ms, now) and ms.current_plan != "trial" and plan_code != "trial":
|
||||
base = max(now, ms.expire_at) # type: ignore[arg-type]
|
||||
start_at = base
|
||||
end_at = base + timedelta(days=duration_days)
|
||||
|
||||
order = MembershipOrder(
|
||||
order_no=gen_order_no(),
|
||||
user_id=user_id,
|
||||
plan_code=plan_code,
|
||||
points_cost=points_cost,
|
||||
duration_days=duration_days,
|
||||
start_at=start_at,
|
||||
end_at=end_at,
|
||||
source=source,
|
||||
)
|
||||
db.add(order)
|
||||
|
||||
ms.is_member = 1
|
||||
ms.current_plan = plan_code
|
||||
ms.is_lifetime = 1 if duration_days == 0 else 0
|
||||
ms.expire_at = end_at
|
||||
await db.flush()
|
||||
return order
|
||||
|
||||
|
||||
async def grant_trial_gift(db: AsyncSession, user_id: int, days: int) -> MembershipOrder:
|
||||
"""新注册赠送体验会员（新用户无既有会员状态，直接设置）"""
|
||||
now = datetime.now()
|
||||
end_at = now + timedelta(days=days)
|
||||
order = MembershipOrder(
|
||||
order_no=gen_order_no(),
|
||||
user_id=user_id,
|
||||
plan_code="trial",
|
||||
points_cost=0,
|
||||
duration_days=days,
|
||||
start_at=now,
|
||||
end_at=end_at,
|
||||
source=SOURCE_GIFT,
|
||||
)
|
||||
db.add(order)
|
||||
ms = await get_membership(db, user_id)
|
||||
ms.is_member = 1
|
||||
ms.current_plan = "trial"
|
||||
ms.is_lifetime = 0
|
||||
ms.expire_at = end_at
|
||||
await db.flush()
|
||||
return order
|
||||
|
||||
|
||||
# ---------- 接口查询（第 7 章） ----------
|
||||
|
||||
def _fmt(dt: datetime | None) -> str | None:
|
||||
return dt.strftime("%Y-%m-%d %H:%M:%S") if dt else None
|
||||
|
||||
|
||||
def list_plans() -> dict:
|
||||
"""套餐列表（7.1）：价格实时读 config.yaml，游客可访问"""
|
||||
plans_cfg = biz_config.get("membership") or {}
|
||||
plans = []
|
||||
for code in ("trial", "month", "year", "lifetime"):
|
||||
cfg = plans_cfg.get(code) or {}
|
||||
meta = PLAN_META[code]
|
||||
plans.append({
|
||||
"plan_code": code,
|
||||
"name": meta["name"],
|
||||
"days": int(cfg.get("days", 0)),
|
||||
"points": int(cfg.get("points", 0)),
|
||||
"enabled": bool(cfg.get("enabled", False)),
|
||||
"desc": meta["desc"],
|
||||
})
|
||||
return {"plans": plans, "benefits": PLAN_BENEFITS}
|
||||
|
||||
|
||||
async def get_my_membership(db: AsyncSession, user_id: int) -> dict:
|
||||
"""我的会员（7.2）：当前状态 + 历史开通记录"""
|
||||
ms = await get_membership(db, user_id)
|
||||
active = membership_active(ms)
|
||||
orders = (
|
||||
await db.execute(
|
||||
select(MembershipOrder).where(MembershipOrder.user_id == user_id)
|
||||
.order_by(MembershipOrder.id.desc()).limit(50)
|
||||
)
|
||||
).scalars().all()
|
||||
remaining_days = 0
|
||||
if active and not ms.is_lifetime and ms.expire_at:
|
||||
remaining_days = max((ms.expire_at - datetime.now()).days, 0)
|
||||
return {
|
||||
"is_member": active,
|
||||
"is_lifetime": bool(ms.is_lifetime),
|
||||
"current_plan": ms.current_plan if active else None,
|
||||
"plan_name": PLAN_NAMES.get(ms.current_plan) if active else None,
|
||||
"expire_at": _fmt(ms.expire_at) if active else None,
|
||||
"remaining_days": remaining_days,
|
||||
"history": [
|
||||
{
|
||||
"order_no": o.order_no,
|
||||
"plan_name": PLAN_NAMES.get(o.plan_code, o.plan_code),
|
||||
"points_cost": o.points_cost,
|
||||
"start_at": _fmt(o.start_at),
|
||||
"end_at": _fmt(o.end_at),
|
||||
"source": o.source,
|
||||
}
|
||||
for o in orders
|
||||
],
|
||||
}
|
||||
|
||||
|
||||
async def redeem(db: AsyncSession, user_id: int, plan_code: str) -> dict:
|
||||
"""积分开通会员（7.3）：扣积分 + 开通同一事务；2004 终身卡 / 2001 积分不足"""
|
||||
from app.services import wallet_service # 避免循环引用
|
||||
|
||||
plan_cfg = (biz_config.get("membership") or {}).get(plan_code)
|
||||
if not plan_cfg or not plan_cfg.get("enabled", False):
|
||||
raise BizException(errors.PARAM_ERROR, "套餐不存在或未上架")
|
||||
points_cost = int(plan_cfg.get("points", 0))
|
||||
|
||||
# 先开通（内部校验终身卡/叠加规则），再扣积分；积分不足抛 2001 整体回滚
|
||||
order = await grant_membership(db, user_id, plan_code, points_cost, SOURCE_POINTS)
|
||||
remaining = await wallet_service.get_balance(db, user_id)
|
||||
if points_cost > 0:
|
||||
remaining = await wallet_service.change_points(
|
||||
db, user_id, -points_cost, wallet_service.BIZ_MEMBERSHIP,
|
||||
biz_id=order.order_no, remark=f"开通{PLAN_NAMES.get(plan_code, plan_code)}",
|
||||
)
|
||||
await db.commit()
|
||||
return {
|
||||
"order_no": order.order_no,
|
||||
"plan_name": PLAN_NAMES.get(plan_code, plan_code),
|
||||
"points_cost": points_cost,
|
||||
"remaining_points": remaining,
|
||||
"expire_at": _fmt(order.end_at),
|
||||
}
|
||||
@@ -0,0 +1,255 @@
|
||||
"""支付服务：充值套餐 / 下单 / 查单 / 取消 / 回调幂等入账 + 推荐返利（对应《03-接口文档》第 8 章）"""
|
||||
from datetime import datetime, timedelta
|
||||
from decimal import Decimal
|
||||
|
||||
import redis.asyncio as aioredis
|
||||
from sqlalchemy import select
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.config import biz_config
|
||||
from app.core import errors
|
||||
from app.core.response import BizException
|
||||
from app.models.billing import RechargeOrder, RechargePackage
|
||||
from app.models.incentive import Referral
|
||||
from app.payment import alipay, usdt, wechat
|
||||
from app.services import config_service, incentive_service, membership_service, wallet_service
|
||||
|
||||
ORDER_STATUS_TEXT = {0: "待支付", 1: "已支付", 2: "已关闭", 3: "已退款"}
|
||||
PAY_METHODS = [
|
||||
{"method": 1, "name": "支付宝"},
|
||||
{"method": 2, "name": "微信支付"},
|
||||
{"method": 3, "name": "USDT (TRC20)"},
|
||||
]
|
||||
|
||||
|
||||
def _fmt(dt: datetime | None) -> str | None:
|
||||
return dt.strftime("%Y-%m-%d %H:%M:%S") if dt else None
|
||||
|
||||
|
||||
def _points_per_yuan() -> int:
|
||||
return int((biz_config.get("points") or {}).get("points_per_yuan", 10))
|
||||
|
||||
|
||||
def _usdt_cfg() -> dict:
|
||||
return (biz_config.get("recharge") or {}).get("usdt") or {}
|
||||
|
||||
|
||||
# ---------- 套餐 / 下单 ----------
|
||||
|
||||
async def list_packages(db: AsyncSession, redis: aioredis.Redis) -> dict:
|
||||
"""充值套餐（8.1）：档位读 recharge_packages 表（后台实时可配），自定义金额按汇率换算"""
|
||||
rows = (await db.execute(
|
||||
select(RechargePackage).where(RechargePackage.status == 1).order_by(RechargePackage.sort, RechargePackage.id)
|
||||
)).scalars().all()
|
||||
custom_enabled = str(await config_service.get_config(db, redis, "recharge.custom.enabled", "1")) == "1"
|
||||
custom_min = await config_service.get_config_int(db, redis, "recharge.custom.min_yuan", 1)
|
||||
custom_max = await config_service.get_config_int(db, redis, "recharge.custom.max_yuan", 10000)
|
||||
return {
|
||||
"packages": [
|
||||
{"id": p.id, "amount_yuan": p.amount_yuan, "points": p.points, "bonus": p.bonus_points}
|
||||
for p in rows
|
||||
],
|
||||
"custom": {
|
||||
"enabled": custom_enabled,
|
||||
"min_yuan": custom_min,
|
||||
"max_yuan": custom_max,
|
||||
"points_per_yuan": _points_per_yuan(),
|
||||
},
|
||||
"pay_methods": PAY_METHODS,
|
||||
"usdt_rate": float(_usdt_cfg().get("rate", 7.2)),
|
||||
}
|
||||
|
||||
|
||||
async def _resolve_points(db: AsyncSession, redis: aioredis.Redis, amount_yuan: int) -> int:
|
||||
"""金额 → 到账积分：优先匹配套餐档位（含赠送），否则走自定义金额按汇率换算"""
|
||||
pkg = (await db.execute(
|
||||
select(RechargePackage).where(RechargePackage.status == 1, RechargePackage.amount_yuan == amount_yuan)
|
||||
)).scalar_one_or_none()
|
||||
if pkg:
|
||||
return pkg.points + pkg.bonus_points
|
||||
custom_enabled = str(await config_service.get_config(db, redis, "recharge.custom.enabled", "1")) == "1"
|
||||
custom_min = await config_service.get_config_int(db, redis, "recharge.custom.min_yuan", 1)
|
||||
custom_max = await config_service.get_config_int(db, redis, "recharge.custom.max_yuan", 10000)
|
||||
if not custom_enabled or not (custom_min <= amount_yuan <= custom_max):
|
||||
raise BizException(errors.PARAM_ERROR, "充值金额不在可选档位")
|
||||
return amount_yuan * _points_per_yuan()
|
||||
|
||||
|
||||
async def create_recharge(db: AsyncSession, redis: aioredis.Redis, user_id: int, req, platform: str | None = None) -> dict:
|
||||
"""创建充值订单（8.2）：iOS 开关校验 → 档位校验 → 建单 → 按渠道产出支付参数"""
|
||||
# iOS 虚拟支付合规开关（《01-开发文档》：审核期引导至网页端充值）
|
||||
if platform == "ios" and str(await config_service.get_config(db, redis, "ios_payment.enabled", "1")) == "0":
|
||||
raise BizException(errors.PARAM_ERROR, "iOS 端暂不支持应用内充值，请前往网页端充值")
|
||||
points = await _resolve_points(db, redis, req.amount_yuan)
|
||||
expire_min = int(_usdt_cfg().get("order_expire_min", 30))
|
||||
expire_at = datetime.now() + timedelta(minutes=expire_min)
|
||||
|
||||
order = RechargeOrder(
|
||||
order_no=membership_service.gen_order_no("R"),
|
||||
user_id=user_id,
|
||||
amount_fen=req.amount_yuan * 100,
|
||||
points=points,
|
||||
pay_method=req.pay_method,
|
||||
expire_at=expire_at,
|
||||
)
|
||||
|
||||
resp: dict = {}
|
||||
if req.pay_method == 3:
|
||||
# USDT：金额含随机尾差用于订单匹配，有效期内唯一
|
||||
rate = Decimal(str(_usdt_cfg().get("rate", 7.2)))
|
||||
for _ in range(10):
|
||||
amount = usdt.gen_usdt_amount(req.amount_yuan, rate)
|
||||
clash = (await db.execute(
|
||||
select(RechargeOrder.id).where(
|
||||
RechargeOrder.status == 0, RechargeOrder.usdt_amount == amount
|
||||
)
|
||||
)).first()
|
||||
if not clash:
|
||||
break
|
||||
else:
|
||||
raise BizException(errors.INTERNAL_ERROR, "USDT 金额分配失败，请重试")
|
||||
order.usdt_amount = amount
|
||||
order.usdt_rate = rate
|
||||
db.add(order)
|
||||
await db.commit()
|
||||
resp = {
|
||||
"usdt_rate": float(rate),
|
||||
"usdt_amount": str(amount),
|
||||
"receive_address": _usdt_cfg().get("address", ""),
|
||||
"network": _usdt_cfg().get("network", "TRC20"),
|
||||
}
|
||||
else:
|
||||
db.add(order)
|
||||
await db.commit()
|
||||
if req.pay_method == 1:
|
||||
resp = {"pay_params": alipay.create_app_pay_params(order.order_no, order.amount_fen)}
|
||||
else:
|
||||
resp = {"pay_params": await wechat.create_app_pay_params(order.order_no, order.amount_fen)}
|
||||
|
||||
return {
|
||||
"order_no": order.order_no,
|
||||
"pay_method": order.pay_method,
|
||||
"amount_yuan": req.amount_yuan,
|
||||
"points": points,
|
||||
"expire_at": _fmt(expire_at),
|
||||
**resp,
|
||||
}
|
||||
|
||||
|
||||
# ---------- 查单 / 取消 ----------
|
||||
|
||||
async def _get_own_order(db: AsyncSession, user_id: int, order_no: str) -> RechargeOrder:
|
||||
order = (await db.execute(
|
||||
select(RechargeOrder).where(RechargeOrder.order_no == order_no)
|
||||
)).scalar_one_or_none()
|
||||
if order is None or order.user_id != user_id:
|
||||
raise BizException(errors.ORDER_NOT_FOUND)
|
||||
return order
|
||||
|
||||
|
||||
async def get_order(db: AsyncSession, user_id: int, order_no: str) -> dict:
|
||||
"""查询订单（8.3）：App 轮询用，附当前钱包积分"""
|
||||
order = await _get_own_order(db, user_id, order_no)
|
||||
return {
|
||||
"order_no": order.order_no,
|
||||
"status": order.status,
|
||||
"status_text": ORDER_STATUS_TEXT.get(order.status, ""),
|
||||
"points": order.points,
|
||||
"paid_at": _fmt(order.paid_at),
|
||||
"wallet_points": await wallet_service.get_balance(db, user_id),
|
||||
}
|
||||
|
||||
|
||||
async def cancel_order(db: AsyncSession, user_id: int, order_no: str) -> None:
|
||||
"""取消订单（8.4）：仅待支付可取消"""
|
||||
order = await _get_own_order(db, user_id, order_no)
|
||||
if order.status != 0:
|
||||
raise BizException(errors.ORDER_STATUS_ERROR, "仅待支付订单可取消")
|
||||
order.status = 2
|
||||
await db.commit()
|
||||
|
||||
|
||||
# ---------- 入账（回调 / 人工补单共用） ----------
|
||||
|
||||
async def settle_order(
|
||||
db: AsyncSession, order_no: str, third_trade_no: str, paid_amount_fen: int | None = None
|
||||
) -> RechargeOrder:
|
||||
"""幂等入账：行锁 → 状态/金额校验 → 置已支付 → 积分到账 → 推荐返利（事件触发，同步补偿）。
|
||||
|
||||
third_trade_no 有唯一索引，第三方支付商重复回调天然幂等。
|
||||
"""
|
||||
order = (await db.execute(
|
||||
select(RechargeOrder).where(RechargeOrder.order_no == order_no).with_for_update()
|
||||
)).scalar_one_or_none()
|
||||
if order is None:
|
||||
raise BizException(errors.ORDER_NOT_FOUND)
|
||||
if order.status != 0:
|
||||
return order # 已入账/已关闭：幂等直接返回
|
||||
if paid_amount_fen is not None and paid_amount_fen != order.amount_fen:
|
||||
raise BizException(errors.AMOUNT_MISMATCH)
|
||||
|
||||
order.status = 1
|
||||
order.third_trade_no = third_trade_no
|
||||
order.paid_at = datetime.now()
|
||||
await wallet_service.change_points(
|
||||
db, order.user_id, order.points, wallet_service.BIZ_RECHARGE,
|
||||
biz_id=order.order_no, remark="充值到账",
|
||||
)
|
||||
await _rebate_for_order(db, order)
|
||||
await db.commit()
|
||||
return order
|
||||
|
||||
|
||||
async def _rebate_for_order(db: AsyncSession, order: RechargeOrder) -> None:
|
||||
"""推荐返利（《02-技术文档》6.6）：被推荐人充值成功 → 推荐人为会员则发放 充值积分×5% 资产"""
|
||||
referral = (await db.execute(
|
||||
select(Referral).where(Referral.invitee_id == order.user_id, Referral.status == 1)
|
||||
)).scalar_one_or_none()
|
||||
if referral is None:
|
||||
return
|
||||
if not await membership_service.is_member(db, referral.inviter_id):
|
||||
return # 发放时点校验推荐人会员身份
|
||||
percent = Decimal(str((biz_config.get("referral") or {}).get("rebate_percent", 5)))
|
||||
rebate = (Decimal(order.points) * percent / 100).quantize(Decimal("0.1"))
|
||||
if rebate <= 0:
|
||||
return
|
||||
await incentive_service.change_assets(
|
||||
db, referral.inviter_id, rebate, incentive_service.ASSET_BIZ_REBATE,
|
||||
biz_id=order.order_no, remark="推荐用户充值返利",
|
||||
)
|
||||
|
||||
|
||||
# ---------- 支付平台回调 ----------
|
||||
|
||||
async def handle_alipay_callback(db: AsyncSession, form: dict) -> str:
|
||||
"""支付宝回调（8.5）：RSA2 验签 → 校验单号/金额 → 幂等入账 → 纯文本 success"""
|
||||
if not alipay.verify_callback(form):
|
||||
return "failure"
|
||||
if form.get("trade_status") not in ("TRADE_SUCCESS", "TRADE_FINISHED"):
|
||||
return "failure"
|
||||
order_no = form.get("out_trade_no", "")
|
||||
try:
|
||||
paid_fen = int(Decimal(form.get("total_amount", "0")) * 100)
|
||||
await settle_order(db, order_no, form.get("trade_no", ""), paid_fen)
|
||||
except BizException:
|
||||
return "failure"
|
||||
return "success"
|
||||
|
||||
|
||||
async def handle_wechat_callback(db: AsyncSession, headers: dict, body: bytes) -> dict:
|
||||
"""微信支付回调（8.6）：V3 验签 + AES-GCM 解密 → 幂等入账 → {"code": "SUCCESS"}"""
|
||||
plain = wechat.verify_callback(headers, body)
|
||||
if not plain:
|
||||
return {"code": "FAIL", "message": "验签失败"}
|
||||
if plain.get("trade_state") != "SUCCESS":
|
||||
return {"code": "FAIL", "message": "非成功状态"}
|
||||
try:
|
||||
await settle_order(
|
||||
db,
|
||||
plain.get("out_trade_no", ""),
|
||||
plain.get("transaction_id", ""),
|
||||
int((plain.get("amount") or {}).get("total", 0)),
|
||||
)
|
||||
except BizException as e:
|
||||
return {"code": "FAIL", "message": e.message}
|
||||
return {"code": "SUCCESS"}
|
||||
@@ -0,0 +1,83 @@
|
||||
"""敏感词服务：DFA 算法，词库 Redis 缓存 60s（后台维护后即时生效，对齐《02-技术文档》6.7）"""
|
||||
import json
|
||||
import time
|
||||
|
||||
import redis.asyncio as aioredis
|
||||
from sqlalchemy import select
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.models.common import SensitiveWord
|
||||
|
||||
CACHE_KEY = "words:sensitive"
|
||||
CACHE_TTL = 60
|
||||
|
||||
|
||||
class DFAMatcher:
|
||||
"""确定性有穷自动机敏感词匹配器"""
|
||||
|
||||
def __init__(self) -> None:
|
||||
self.root: dict = {}
|
||||
|
||||
def add(self, word: str) -> None:
|
||||
node = self.root
|
||||
for ch in word.strip().lower():
|
||||
if not ch:
|
||||
continue
|
||||
node = node.setdefault(ch, {})
|
||||
node["\x00"] = True # 词结束标记
|
||||
|
||||
def find(self, text: str) -> str | None:
|
||||
"""返回命中的第一个敏感词，未命中返回 None"""
|
||||
text = text.lower()
|
||||
n = len(text)
|
||||
for i in range(n):
|
||||
node = self.root
|
||||
j = i
|
||||
while j < n and text[j] in node:
|
||||
node = node[text[j]]
|
||||
j += 1
|
||||
if "\x00" in node:
|
||||
return text[i:j]
|
||||
return None
|
||||
|
||||
|
||||
# 进程内缓存（matcher, 构建时间戳）
|
||||
_local_cache: tuple[DFAMatcher, float] | None = None
|
||||
|
||||
|
||||
async def get_matcher(db: AsyncSession, redis: aioredis.Redis) -> DFAMatcher:
|
||||
"""获取 DFA 匹配器：进程缓存 → Redis → DB，60s 重建"""
|
||||
global _local_cache
|
||||
now = time.time()
|
||||
if _local_cache and now - _local_cache[1] < CACHE_TTL:
|
||||
return _local_cache[0]
|
||||
|
||||
words: list[str] = []
|
||||
cached = await redis.get(CACHE_KEY)
|
||||
if cached:
|
||||
words = json.loads(cached)
|
||||
else:
|
||||
rows = (await db.execute(select(SensitiveWord.word))).scalars().all()
|
||||
words = [w for w in rows if w]
|
||||
await redis.set(CACHE_KEY, json.dumps(words, ensure_ascii=False), ex=CACHE_TTL)
|
||||
|
||||
matcher = DFAMatcher()
|
||||
for w in words:
|
||||
matcher.add(w)
|
||||
_local_cache = (matcher, now)
|
||||
return matcher
|
||||
|
||||
|
||||
async def find_sensitive(db: AsyncSession, redis: aioredis.Redis, text: str) -> str | None:
|
||||
"""检查文本，返回命中的敏感词或 None"""
|
||||
if not text:
|
||||
return None
|
||||
matcher = await get_matcher(db, redis)
|
||||
return matcher.find(text)
|
||||
|
||||
|
||||
async def invalidate_cache(redis: aioredis.Redis) -> None:
|
||||
"""后台增删词库后调用：清 Redis 缓存，进程缓存等 60s 内自然过期"""
|
||||
global _local_cache
|
||||
_local_cache = None
|
||||
await redis.delete(CACHE_KEY)
|
||||
@@ -0,0 +1,166 @@
|
||||
"""结算服务：周期任务（推荐激活 / 视频创作收益 / 订单超时关单）
|
||||
|
||||
由 main.py lifespan 内的 asyncio 周期协程驱动（开发环境单进程够用）；
|
||||
各结算函数均为幂等扫描，测试可直接调用。
|
||||
"""
|
||||
import asyncio
|
||||
import logging
|
||||
from datetime import datetime, timedelta
|
||||
from decimal import Decimal
|
||||
|
||||
from sqlalchemy import func, select
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.config import biz_config
|
||||
from app.database import SessionFactory
|
||||
from app.models.billing import RechargeOrder, WatchRecord
|
||||
from app.models.incentive import Referral, VideoEarning
|
||||
from app.models.user import User
|
||||
from app.services import incentive_service, membership_service, wallet_service
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
# 单轮扫描批量上限
|
||||
BATCH_SIZE = 500
|
||||
|
||||
# 周期间隔（秒）
|
||||
INTERVAL_REFERRAL = 600 # 推荐激活结算 10min
|
||||
INTERVAL_EARNINGS = 300 # 创作收益结算 5min
|
||||
INTERVAL_ORDER_CLOSE = 60 # 订单超时关单 1min
|
||||
|
||||
|
||||
def _referral_cfg() -> dict:
|
||||
return biz_config.get("referral") or {}
|
||||
|
||||
|
||||
def _asset_cfg() -> dict:
|
||||
return biz_config.get("asset") or {}
|
||||
|
||||
|
||||
# ---------- 推荐激活结算 ----------
|
||||
|
||||
async def settle_referral_activations(db: AsyncSession) -> dict:
|
||||
"""待激活推荐关系结算（《01-开发文档》2.8：72h 内观看≥N 且次日登录 → 有效；超期 → 无效）。
|
||||
|
||||
激活时点校验推荐人会员身份，会员才发放注册奖励积分（point biz_type=8）。
|
||||
"""
|
||||
cfg = _referral_cfg()
|
||||
hours = int(cfg.get("activate_hours", 72))
|
||||
watch_count = int(cfg.get("activate_watch_count", 3))
|
||||
reward = int(cfg.get("register_reward_points", 10))
|
||||
now = datetime.now()
|
||||
|
||||
rows = (await db.execute(
|
||||
select(Referral).where(Referral.status == 0).order_by(Referral.id).limit(BATCH_SIZE)
|
||||
)).scalars().all()
|
||||
activated = expired = 0
|
||||
for r in rows:
|
||||
if r.created_at + timedelta(hours=hours) < now:
|
||||
r.status = 2 # 超期未达标
|
||||
expired += 1
|
||||
continue
|
||||
watches = (await db.execute(
|
||||
select(func.count(WatchRecord.id)).where(
|
||||
WatchRecord.subject_type == 1, WatchRecord.subject_id == str(r.invitee_id)
|
||||
)
|
||||
)).scalar() or 0
|
||||
if watches < watch_count:
|
||||
continue
|
||||
invitee = await db.get(User, r.invitee_id)
|
||||
next_day_login = bool(
|
||||
invitee and invitee.last_login_at and invitee.last_login_at.date() > r.created_at.date()
|
||||
)
|
||||
if not next_day_login:
|
||||
continue
|
||||
r.status = 1
|
||||
r.activated_at = now
|
||||
activated += 1
|
||||
if reward > 0 and await membership_service.is_member(db, r.inviter_id):
|
||||
await wallet_service.change_points(
|
||||
db, r.inviter_id, reward, wallet_service.BIZ_REFERRAL,
|
||||
biz_id=str(r.id), remark="推荐新用户激活奖励",
|
||||
)
|
||||
await db.commit()
|
||||
return {"scanned": len(rows), "activated": activated, "expired": expired}
|
||||
|
||||
|
||||
# ---------- 视频创作收益结算 ----------
|
||||
|
||||
async def settle_video_earnings(db: AsyncSession) -> dict:
|
||||
"""创作收益按增量结算：完整观看每满 1000 发 1 资产、点赞每满 100 发 1 资产（余数保留）。
|
||||
|
||||
结算时点校验作者会员身份：非会员只保留计数，不推进结算刻度。
|
||||
"""
|
||||
cfg = _asset_cfg()
|
||||
views_per = int(cfg.get("complete_views_per_asset", 1000))
|
||||
likes_per = int(cfg.get("likes_per_asset", 100))
|
||||
|
||||
rows = (await db.execute(
|
||||
select(VideoEarning).order_by(VideoEarning.video_id).limit(BATCH_SIZE)
|
||||
)).scalars().all()
|
||||
settled_videos = 0
|
||||
granted = Decimal(0)
|
||||
for e in rows:
|
||||
if not await membership_service.is_member(db, e.author_id):
|
||||
continue
|
||||
view_assets = (e.complete_views - e.views_settled) // views_per if views_per > 0 else 0
|
||||
like_assets = (e.likes_accrued - e.likes_settled) // likes_per if likes_per > 0 else 0
|
||||
if view_assets <= 0 and like_assets <= 0:
|
||||
continue
|
||||
if view_assets > 0:
|
||||
await incentive_service.change_assets(
|
||||
db, e.author_id, Decimal(view_assets), incentive_service.ASSET_BIZ_COMPLETE,
|
||||
biz_id=str(e.video_id), remark="完整观看收益",
|
||||
)
|
||||
e.views_settled += view_assets * views_per
|
||||
if like_assets > 0:
|
||||
await incentive_service.change_assets(
|
||||
db, e.author_id, Decimal(like_assets), incentive_service.ASSET_BIZ_LIKE,
|
||||
biz_id=str(e.video_id), remark="点赞收益",
|
||||
)
|
||||
e.likes_settled += like_assets * likes_per
|
||||
settled_videos += 1
|
||||
granted += view_assets + like_assets
|
||||
await db.commit()
|
||||
return {"scanned": len(rows), "settled_videos": settled_videos, "granted_assets": float(granted)}
|
||||
|
||||
|
||||
# ---------- 订单超时关单 ----------
|
||||
|
||||
async def close_expired_orders(db: AsyncSession) -> dict:
|
||||
"""待支付订单超过 expire_at → 已关闭"""
|
||||
rows = (await db.execute(
|
||||
select(RechargeOrder)
|
||||
.where(RechargeOrder.status == 0, RechargeOrder.expire_at < datetime.now())
|
||||
.order_by(RechargeOrder.id)
|
||||
.limit(BATCH_SIZE)
|
||||
)).scalars().all()
|
||||
for o in rows:
|
||||
o.status = 2
|
||||
await db.commit()
|
||||
return {"closed": len(rows)}
|
||||
|
||||
|
||||
# ---------- 周期协程（lifespan 挂载） ----------
|
||||
|
||||
async def _run_loop(name: str, fn, interval: int) -> None:
|
||||
while True:
|
||||
try:
|
||||
async with SessionFactory() as db:
|
||||
result = await fn(db)
|
||||
if result:
|
||||
logger.info("周期任务[%s]完成: %s", name, result)
|
||||
except asyncio.CancelledError:
|
||||
raise
|
||||
except Exception:
|
||||
logger.exception("周期任务[%s]执行失败", name)
|
||||
await asyncio.sleep(interval)
|
||||
|
||||
|
||||
def start_periodic_tasks() -> list[asyncio.Task]:
|
||||
"""启动全部周期任务，返回 Task 列表（lifespan 退出时取消）"""
|
||||
return [
|
||||
asyncio.create_task(_run_loop("推荐激活结算", settle_referral_activations, INTERVAL_REFERRAL)),
|
||||
asyncio.create_task(_run_loop("创作收益结算", settle_video_earnings, INTERVAL_EARNINGS)),
|
||||
asyncio.create_task(_run_loop("订单超时关单", close_expired_orders, INTERVAL_ORDER_CLOSE)),
|
||||
]
|
||||
@@ -0,0 +1,68 @@
|
||||
"""本地文件存储（开发环境）：头像等小文件与上传视频存 server/uploads，经 /static 访问。
|
||||
|
||||
生产切换 OSS 时仅需替换本模块实现，调用方不变。
|
||||
"""
|
||||
import time
|
||||
|
||||
from fastapi import UploadFile
|
||||
|
||||
from app.config import BASE_DIR
|
||||
from app.core import errors
|
||||
from app.core.response import BizException
|
||||
|
||||
UPLOAD_DIR = BASE_DIR / "uploads"
|
||||
MAX_AVATAR_SIZE = 5 * 1024 * 1024 # 5MB
|
||||
|
||||
# 允许上传的视频扩展名
|
||||
VIDEO_EXTS = ("mp4", "mov", "m4v", "avi", "mkv", "webm")
|
||||
# 上传视频大小上限（与 config.yaml upload.max_size_mb 对齐）
|
||||
MAX_VIDEO_SIZE = 500 * 1024 * 1024 # 500MB
|
||||
|
||||
|
||||
def video_ext_of(filename: str | None) -> str:
|
||||
return (filename or "").rsplit(".", 1)[-1].lower() if filename and "." in filename else ""
|
||||
|
||||
|
||||
async def save_avatar(file: UploadFile, user_id: int) -> str:
|
||||
"""保存头像，返回可访问的 URL 路径"""
|
||||
ext = (file.filename or "").rsplit(".", 1)[-1].lower()
|
||||
if ext not in ("jpg", "jpeg", "png"):
|
||||
raise BizException(errors.PARAM_ERROR, "仅支持 jpg/png 图片")
|
||||
data = await file.read()
|
||||
if not data:
|
||||
raise BizException(errors.PARAM_ERROR, "文件内容为空")
|
||||
if len(data) > MAX_AVATAR_SIZE:
|
||||
raise BizException(errors.PARAM_ERROR, "图片不能超过 5MB")
|
||||
(UPLOAD_DIR / "avatars").mkdir(parents=True, exist_ok=True)
|
||||
name = f"{user_id}_{int(time.time())}.{ext}"
|
||||
(UPLOAD_DIR / "avatars" / name).write_bytes(data)
|
||||
return f"/static/avatars/{name}"
|
||||
|
||||
|
||||
def validate_object_key(object_key: str) -> str:
|
||||
"""校验上传凭证下发的 object_key 格式，防路径穿越；返回扩展名"""
|
||||
if (
|
||||
not object_key.startswith("upload/tmp/")
|
||||
or ".." in object_key
|
||||
or "\\" in object_key
|
||||
or len(object_key) > 300
|
||||
):
|
||||
raise BizException(errors.PARAM_ERROR, "object_key 无效")
|
||||
ext = video_ext_of(object_key)
|
||||
if ext not in VIDEO_EXTS:
|
||||
raise BizException(errors.PARAM_ERROR, "object_key 无效")
|
||||
return ext
|
||||
|
||||
|
||||
async def save_video(file: UploadFile, object_key: str) -> tuple[str, int]:
|
||||
"""按 object_key 保存上传的视频文件，返回 (可访问 URL 路径, 文件字节数)"""
|
||||
validate_object_key(object_key)
|
||||
data = await file.read()
|
||||
if not data:
|
||||
raise BizException(errors.PARAM_ERROR, "文件内容为空")
|
||||
if len(data) > MAX_VIDEO_SIZE:
|
||||
raise BizException(errors.PARAM_ERROR, f"视频不能超过 {MAX_VIDEO_SIZE // 1024 // 1024}MB")
|
||||
path = UPLOAD_DIR / object_key
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
path.write_bytes(data)
|
||||
return f"/static/{object_key}", len(data)
|
||||
@@ -0,0 +1,192 @@
|
||||
"""用户服务：资料 / 钱包 / 积分明细 / 注销 / 公开主页（对应《03-接口文档》第 4 章）"""
|
||||
from datetime import datetime, timedelta
|
||||
|
||||
import redis.asyncio as aioredis
|
||||
from sqlalchemy import func, select
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.config import biz_config
|
||||
from app.core import errors
|
||||
from app.core.response import BizException
|
||||
from app.core.security import verify_password
|
||||
from app.models.billing import PointTransaction
|
||||
from app.models.user import User
|
||||
from app.models.video import Video
|
||||
from app.services import membership_service, sensitive_service, video_service, wallet_service
|
||||
|
||||
DEACTIVATE_FREEZE_DAYS = 7
|
||||
|
||||
|
||||
def _mask_phone(phone: str | None) -> str | None:
|
||||
"""手机号脱敏：138****8000"""
|
||||
if not phone or len(phone) < 7:
|
||||
return phone
|
||||
return f"{phone[:3]}****{phone[-4:]}"
|
||||
|
||||
|
||||
def _fmt(dt: datetime | None) -> str | None:
|
||||
return dt.strftime("%Y-%m-%d %H:%M:%S") if dt else None
|
||||
|
||||
|
||||
async def _get_user(db: AsyncSession, user_id: int) -> User:
|
||||
user = await db.get(User, user_id)
|
||||
if user is None:
|
||||
raise BizException(errors.UNAUTHORIZED, http_status=401)
|
||||
return user
|
||||
|
||||
|
||||
async def _me_payload(db: AsyncSession, user: User) -> dict:
|
||||
"""个人信息完整结构（4.1/4.2 共用）"""
|
||||
ms = await membership_service.get_membership(db, user.id)
|
||||
active = membership_service.membership_active(ms)
|
||||
points = await wallet_service.get_balance(db, user.id)
|
||||
return {
|
||||
"user_id": user.id,
|
||||
"phone": _mask_phone(user.phone),
|
||||
"email": user.email,
|
||||
"nickname": user.nickname,
|
||||
"avatar_url": user.avatar_url,
|
||||
"bio": user.bio,
|
||||
"gender": user.gender,
|
||||
"is_member": active,
|
||||
"member_plan": ms.current_plan if active else None,
|
||||
"member_expire_at": _fmt(ms.expire_at) if active else None,
|
||||
"points": points,
|
||||
}
|
||||
|
||||
|
||||
async def get_me(db: AsyncSession, user_id: int) -> dict:
|
||||
return await _me_payload(db, await _get_user(db, user_id))
|
||||
|
||||
|
||||
async def update_me(db: AsyncSession, redis: aioredis.Redis, user_id: int, req) -> dict:
|
||||
"""修改资料：昵称/简介过敏感词"""
|
||||
user = await _get_user(db, user_id)
|
||||
if req.nickname is not None:
|
||||
if await sensitive_service.find_sensitive(db, redis, req.nickname):
|
||||
raise BizException(errors.SENSITIVE_WORD)
|
||||
user.nickname = req.nickname
|
||||
if req.bio is not None:
|
||||
if await sensitive_service.find_sensitive(db, redis, req.bio):
|
||||
raise BizException(errors.SENSITIVE_WORD)
|
||||
user.bio = req.bio
|
||||
if req.gender is not None:
|
||||
user.gender = req.gender
|
||||
await db.commit()
|
||||
return await _me_payload(db, user)
|
||||
|
||||
|
||||
async def set_avatar(db: AsyncSession, user_id: int, avatar_url: str) -> dict:
|
||||
user = await _get_user(db, user_id)
|
||||
user.avatar_url = avatar_url
|
||||
await db.commit()
|
||||
return {"avatar_url": avatar_url}
|
||||
|
||||
|
||||
# ---------- 钱包 / 积分明细 ----------
|
||||
|
||||
async def get_wallet(db: AsyncSession, redis: aioredis.Redis, user_id: int) -> dict:
|
||||
wallet = await wallet_service.get_or_create_wallet(db, user_id)
|
||||
# 评论奖励进度（Redis Hash：count 进度 / daily 当日已发 / date 当日日期）
|
||||
prog = await redis.hgetall(f"comment:prog:{user_id}") # type: ignore[misc]
|
||||
reward_cfg = (biz_config.get("points") or {}).get("comment_reward") or {}
|
||||
today = f"{datetime.now():%Y%m%d}"
|
||||
return {
|
||||
"points": wallet.points,
|
||||
"total_recharge": wallet.total_recharge,
|
||||
"total_earned": wallet.total_earned,
|
||||
"total_consumed": wallet.total_consumed,
|
||||
"comment_reward_progress": {
|
||||
"current": int(prog.get("count", 0)),
|
||||
"target": int(reward_cfg.get("per_count", 10)),
|
||||
"today_rewarded": int(prog.get("daily", 0)) if prog.get("date") == today else 0,
|
||||
"daily_limit": int(reward_cfg.get("daily_limit", 5)),
|
||||
},
|
||||
}
|
||||
|
||||
|
||||
async def get_points_records(
|
||||
db: AsyncSession, user_id: int, page: int, page_size: int, biz_type: int | None
|
||||
) -> dict:
|
||||
stmt = select(PointTransaction).where(PointTransaction.user_id == user_id)
|
||||
if biz_type is not None:
|
||||
stmt = stmt.where(PointTransaction.biz_type == biz_type)
|
||||
total = (await db.execute(select(func.count()).select_from(stmt.subquery()))).scalar() or 0
|
||||
rows = (
|
||||
await db.execute(
|
||||
stmt.order_by(PointTransaction.id.desc()).offset((page - 1) * page_size).limit(page_size)
|
||||
)
|
||||
).scalars().all()
|
||||
return {
|
||||
"total": total,
|
||||
"list": [
|
||||
{
|
||||
"id": r.id,
|
||||
"change_amount": r.change_amount,
|
||||
"balance_after": r.balance_after,
|
||||
"biz_type": r.biz_type,
|
||||
"remark": r.remark,
|
||||
"created_at": _fmt(r.created_at),
|
||||
}
|
||||
for r in rows
|
||||
],
|
||||
}
|
||||
|
||||
|
||||
# ---------- 注销 ----------
|
||||
|
||||
async def deactivate(db: AsyncSession, redis: aioredis.Redis, user_id: int, password: str) -> dict:
|
||||
"""申请注销：密码二次确认 → 进入 7 天冻结期 → 全端 Token 立即失效。
|
||||
|
||||
冻结期内登录返回 1009 + can_revoke（见 auth_service.login）；到期匿名化由定时任务执行。
|
||||
"""
|
||||
user = await _get_user(db, user_id)
|
||||
if not verify_password(password, user.password_hash):
|
||||
raise BizException(errors.PARAM_ERROR, "密码错误")
|
||||
if user.deactivate_at is not None:
|
||||
raise BizException(errors.PARAM_ERROR, "账号已在注销冻结期内")
|
||||
|
||||
now = datetime.now()
|
||||
user.deactivate_at = now
|
||||
# 全端 Token 失效：递增令牌纪元 + 清 refresh 白名单
|
||||
await redis.incr(f"auth:epoch:{user_id}")
|
||||
await redis.delete(f"auth:refresh:{user_id}")
|
||||
await db.commit()
|
||||
|
||||
revoke_before = now + timedelta(days=DEACTIVATE_FREEZE_DAYS)
|
||||
return {"deactivate_at": _fmt(now), "revoke_before": _fmt(revoke_before)}
|
||||
|
||||
|
||||
# ---------- 公开主页 ----------
|
||||
|
||||
async def get_public_profile(db: AsyncSession, user_id: int) -> dict:
|
||||
user = await db.get(User, user_id)
|
||||
if user is None or user.status != 1:
|
||||
raise BizException(errors.NOT_FOUND, "用户不存在")
|
||||
base = select(Video).where(Video.user_id == user_id, Video.status == video_service.STATUS_PUBLISHED)
|
||||
video_count = (await db.execute(select(func.count()).select_from(base.subquery()))).scalar() or 0
|
||||
total_likes = (await db.execute(select(func.coalesce(func.sum(Video.like_count), 0)).where(
|
||||
Video.user_id == user_id, Video.status == video_service.STATUS_PUBLISHED
|
||||
))).scalar() or 0
|
||||
return {
|
||||
"user_id": user.id,
|
||||
"nickname": user.nickname,
|
||||
"avatar_url": user.avatar_url,
|
||||
"bio": user.bio,
|
||||
"video_count": video_count,
|
||||
"total_likes": int(total_likes),
|
||||
}
|
||||
|
||||
|
||||
async def get_user_videos(
|
||||
db: AsyncSession, user_id: int, page: int, page_size: int, viewer_user_id: int | None
|
||||
) -> dict:
|
||||
"""他人作品列表：仅已发布"""
|
||||
stmt = select(Video).where(Video.user_id == user_id, Video.status == video_service.STATUS_PUBLISHED)
|
||||
total = (await db.execute(select(func.count()).select_from(stmt.subquery()))).scalar() or 0
|
||||
videos = (
|
||||
await db.execute(
|
||||
stmt.order_by(Video.published_at.desc()).offset((page - 1) * page_size).limit(page_size)
|
||||
)
|
||||
).scalars().all()
|
||||
return {"total": total, "list": await video_service.serialize_videos(db, list(videos), viewer_user_id)}
|
||||
@@ -0,0 +1,739 @@
|
||||
"""视频服务：Feed / 详情 / 观看计费 / 完整观看（对应《03-接口文档》第 5 章、《02-技术文档》6.4）"""
|
||||
import base64
|
||||
import hashlib
|
||||
import json
|
||||
import random
|
||||
import uuid
|
||||
from datetime import date, datetime, timedelta
|
||||
|
||||
import redis.asyncio as aioredis
|
||||
from fastapi import UploadFile
|
||||
from sqlalchemy import func, select
|
||||
from sqlalchemy.dialects.mysql import insert as mysql_insert
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.config import biz_config
|
||||
from app.core import errors, ratelimit
|
||||
from app.core.response import BizException
|
||||
from app.deps import Identity
|
||||
from app.models.billing import WatchRecord
|
||||
from app.models.incentive import VideoEarning
|
||||
from app.models.interaction import Favorite, Like
|
||||
from app.models.user import User
|
||||
from app.models.video import Category, Tag, Video, VideoTag
|
||||
from app.schemas.video import PublishVideoReq, UploadTokenReq
|
||||
from app.services import membership_service, sensitive_service, storage_service, wallet_service
|
||||
|
||||
STATUS_PUBLISHED = 2
|
||||
|
||||
STATUS_TEXT = {0: "转码中", 1: "待审核", 2: "已发布", 3: "拒绝", 4: "下架", 5: "转码失败"}
|
||||
|
||||
# 观看上报限流：60 次/分钟/计费主体
|
||||
WATCH_RATE_LIMIT = 60
|
||||
# 免费额度 Set / 已看 Set 过期时间 48h
|
||||
SET_TTL = 48 * 3600
|
||||
# 推荐候选池上限
|
||||
FEED_POOL_SIZE = 500
|
||||
# 视频详情缓存 5min
|
||||
DETAIL_CACHE_TTL = 300
|
||||
|
||||
# 免费额度 + 去重 Lua 原子脚本（《02-技术文档》3.4-2）
|
||||
FREE_QUOTA_LUA = """
|
||||
if redis.call('SISMEMBER', KEYS[1], ARGV[1]) == 1 then return 1 end
|
||||
local n = redis.call('SCARD', KEYS[1])
|
||||
if n < tonumber(ARGV[2]) then redis.call('SADD', KEYS[1], ARGV[1]) redis.call('EXPIRE', KEYS[1], ARGV[3]) return 2 end
|
||||
return 0
|
||||
"""
|
||||
|
||||
|
||||
def _fmt(dt: datetime | None) -> str | None:
|
||||
return dt.strftime("%Y-%m-%d %H:%M:%S") if dt else None
|
||||
|
||||
|
||||
def _points_cfg() -> dict:
|
||||
return biz_config.get("points") or {}
|
||||
|
||||
|
||||
# ---------- Feed 单条序列化 ----------
|
||||
|
||||
def _author_brief(user: User | None) -> dict:
|
||||
return {
|
||||
"user_id": user.id if user else 0,
|
||||
"nickname": user.nickname if user else "",
|
||||
"avatar_url": user.avatar_url if user else "",
|
||||
}
|
||||
|
||||
|
||||
async def serialize_videos(
|
||||
db: AsyncSession, videos: list[Video], viewer_user_id: int | None = None
|
||||
) -> list[dict]:
|
||||
"""Feed 单条结构（对齐《03-接口文档》5.1）：批量取作者/标签/登录用户互动状态"""
|
||||
if not videos:
|
||||
return []
|
||||
video_ids = [v.id for v in videos]
|
||||
|
||||
authors = {
|
||||
u.id: u
|
||||
for u in (await db.execute(select(User).where(User.id.in_({v.user_id for v in videos})))).scalars()
|
||||
}
|
||||
|
||||
tags_map = await get_tags_map(db, video_ids)
|
||||
|
||||
liked: set[int] = set()
|
||||
favorited: set[int] = set()
|
||||
if viewer_user_id:
|
||||
liked = set(
|
||||
(await db.execute(
|
||||
select(Like.video_id).where(Like.user_id == viewer_user_id, Like.video_id.in_(video_ids))
|
||||
)).scalars()
|
||||
)
|
||||
favorited = set(
|
||||
(await db.execute(
|
||||
select(Favorite.video_id).where(Favorite.user_id == viewer_user_id, Favorite.video_id.in_(video_ids))
|
||||
)).scalars()
|
||||
)
|
||||
|
||||
return [
|
||||
{
|
||||
"video_id": v.id,
|
||||
"title": v.title,
|
||||
"cover_url": v.cover_url,
|
||||
"video_url": v.video_url,
|
||||
"duration": v.duration,
|
||||
"category_id": v.category_id,
|
||||
"author": _author_brief(authors.get(v.user_id)),
|
||||
"view_count": v.view_count,
|
||||
"like_count": v.like_count,
|
||||
"comment_count": v.comment_count,
|
||||
"favorite_count": v.favorite_count,
|
||||
"tags": tags_map.get(v.id, []),
|
||||
"is_liked": v.id in liked,
|
||||
"is_favorited": v.id in favorited,
|
||||
}
|
||||
for v in videos
|
||||
]
|
||||
|
||||
|
||||
async def get_tags_map(db: AsyncSession, video_ids: list[int]) -> dict[int, list[str]]:
|
||||
if not video_ids:
|
||||
return {}
|
||||
rows = await db.execute(
|
||||
select(VideoTag.video_id, Tag.name)
|
||||
.join(Tag, Tag.id == VideoTag.tag_id)
|
||||
.where(VideoTag.video_id.in_(video_ids))
|
||||
)
|
||||
tags_map: dict[int, list[str]] = {}
|
||||
for vid, name in rows.all():
|
||||
tags_map.setdefault(vid, []).append(name)
|
||||
return tags_map
|
||||
|
||||
|
||||
async def get_tags_of_video(db: AsyncSession, video_id: int) -> list[str]:
|
||||
return (await get_tags_map(db, [video_id])).get(video_id, [])
|
||||
|
||||
|
||||
# ---------- 游标 ----------
|
||||
|
||||
def _encode_cursor(payload: dict) -> str:
|
||||
return base64.urlsafe_b64encode(json.dumps(payload, separators=(",", ":")).encode()).decode()
|
||||
|
||||
|
||||
def _decode_cursor(cursor: str | None) -> dict:
|
||||
if not cursor:
|
||||
return {}
|
||||
try:
|
||||
return json.loads(base64.urlsafe_b64decode(cursor.encode()))
|
||||
except Exception:
|
||||
raise BizException(errors.PARAM_ERROR, "cursor 无效")
|
||||
|
||||
|
||||
# ---------- Feed ----------
|
||||
|
||||
async def get_feed(
|
||||
db: AsyncSession,
|
||||
redis: aioredis.Redis,
|
||||
identity: Identity,
|
||||
feed_type: str,
|
||||
cursor: str | None,
|
||||
limit: int,
|
||||
category_id: int | None,
|
||||
) -> dict:
|
||||
if feed_type == "latest":
|
||||
return await _feed_latest(db, identity, cursor, limit, category_id)
|
||||
return await _feed_scored(db, redis, identity, feed_type, cursor, limit, category_id)
|
||||
|
||||
|
||||
async def _base_pool_stmt(category_id: int | None):
|
||||
stmt = select(Video).where(Video.status == STATUS_PUBLISHED, Video.published_at.isnot(None))
|
||||
if category_id:
|
||||
stmt = stmt.where(Video.category_id == category_id)
|
||||
return stmt
|
||||
|
||||
|
||||
async def _feed_latest(
|
||||
db: AsyncSession, identity: Identity, cursor: str | None, limit: int, category_id: int | None
|
||||
) -> dict:
|
||||
"""latest：published_at 游标倒序（ts + id 打破并列）"""
|
||||
stmt = await _base_pool_stmt(category_id)
|
||||
c = _decode_cursor(cursor)
|
||||
if c:
|
||||
ts, vid = datetime.fromtimestamp(c["p"]), int(c["i"])
|
||||
stmt = stmt.where((Video.published_at < ts) | ((Video.published_at == ts) & (Video.id < vid)))
|
||||
rows = list(
|
||||
(await db.execute(stmt.order_by(Video.published_at.desc(), Video.id.desc()).limit(limit + 1))).scalars()
|
||||
)
|
||||
page, rows = (len(rows) > limit), rows[:limit]
|
||||
next_cursor = None
|
||||
if page and rows:
|
||||
last = rows[-1]
|
||||
next_cursor = _encode_cursor({"p": int(last.published_at.timestamp()), "i": last.id})
|
||||
return {
|
||||
"next_cursor": next_cursor,
|
||||
"list": await serialize_videos(db, rows, identity.user_id),
|
||||
}
|
||||
|
||||
|
||||
def _hot_score(v: Video, now: datetime) -> float:
|
||||
"""热度分：view×1 + like×5 + comment×10，随发布天数衰减"""
|
||||
age_days = max((now - (v.published_at or now)).days, 0)
|
||||
base = v.view_count + v.like_count * 5 + v.comment_count * 10
|
||||
return base / (1 + age_days)
|
||||
|
||||
|
||||
async def _user_tag_prefs(db: AsyncSession, user_id: int) -> dict[str, float]:
|
||||
"""近 7 天观看/点赞/收藏视频的标签偏好（观看+1 点赞+3 收藏+5）；无偏好返回空"""
|
||||
since = datetime.now() - timedelta(days=7)
|
||||
video_ids: list[tuple[int, float]] = []
|
||||
watched = (await db.execute(
|
||||
select(WatchRecord.video_id).where(
|
||||
WatchRecord.subject_type == 1, WatchRecord.subject_id == str(user_id), WatchRecord.created_at > since
|
||||
)
|
||||
)).scalars().all()
|
||||
video_ids += [(vid, 1.0) for vid in watched]
|
||||
liked = (await db.execute(select(Like.video_id).where(Like.user_id == user_id))).scalars().all()
|
||||
video_ids += [(vid, 3.0) for vid in liked]
|
||||
fav = (await db.execute(select(Favorite.video_id).where(Favorite.user_id == user_id))).scalars().all()
|
||||
video_ids += [(vid, 5.0) for vid in fav]
|
||||
if not video_ids:
|
||||
return {}
|
||||
tags_map = await get_tags_map(db, list({vid for vid, _ in video_ids}))
|
||||
prefs: dict[str, float] = {}
|
||||
for vid, w in video_ids:
|
||||
for tag in tags_map.get(vid, []):
|
||||
prefs[tag] = prefs.get(tag, 0.0) + w
|
||||
return prefs
|
||||
|
||||
|
||||
async def _feed_scored(
|
||||
db: AsyncSession,
|
||||
redis: aioredis.Redis,
|
||||
identity: Identity,
|
||||
feed_type: str,
|
||||
cursor: str | None,
|
||||
limit: int,
|
||||
category_id: int | None,
|
||||
) -> dict:
|
||||
"""recommend / hot：候选池打分 → 当日种子确定性加权抽样 → 当日去重（不足兜底）→ 偏移游标"""
|
||||
now = datetime.now()
|
||||
today = f"{now:%Y%m%d}"
|
||||
subject = identity.subject or "anon"
|
||||
|
||||
# 1. 候选池：近 30 天已发布，封顶 FEED_POOL_SIZE
|
||||
stmt = (await _base_pool_stmt(category_id)).where(
|
||||
Video.published_at > now - timedelta(days=30)
|
||||
).order_by(Video.published_at.desc()).limit(FEED_POOL_SIZE)
|
||||
pool = list((await db.execute(stmt)).scalars())
|
||||
if not pool:
|
||||
return {"next_cursor": None, "list": []}
|
||||
|
||||
# 2. 打分
|
||||
scores: dict[int, float] = {}
|
||||
if feed_type == "recommend" and identity.user_id:
|
||||
prefs = await _user_tag_prefs(db, identity.user_id)
|
||||
else:
|
||||
prefs = {}
|
||||
tags_map = await get_tags_map(db, [v.id for v in pool])
|
||||
for v in pool:
|
||||
hot = _hot_score(v, now)
|
||||
if feed_type == "recommend" and prefs:
|
||||
# 命中偏好标签加权，未命中取热度分
|
||||
pref = sum(prefs.get(t, 0.0) for t in tags_map.get(v.id, []))
|
||||
scores[v.id] = pref * 1000 + hot if pref > 0 else hot
|
||||
else:
|
||||
# hot 策略 / 游客 / 新用户：热度分
|
||||
scores[v.id] = hot
|
||||
|
||||
# 3. 排序：hot = 热度分严格倒序；recommend = 当日种子确定性加权抽样（每日重排，同日稳定）
|
||||
if feed_type == "hot":
|
||||
ordered = sorted(pool, key=lambda v: (scores[v.id], v.id), reverse=True)
|
||||
else:
|
||||
seed = int(hashlib.md5(f"{today}{subject}".encode()).hexdigest()[:8], 16)
|
||||
rng = random.Random(seed)
|
||||
ordered = sorted(pool, key=lambda v: rng.random() ** (1.0 / max(scores[v.id], 1e-6)), reverse=True)
|
||||
|
||||
# 4. 当日去重（观看上报写入 watched Set）；候选不足时放开过滤兜底
|
||||
watched = await redis.smembers(f"watched:{subject}:{today}") # type: ignore[misc]
|
||||
filtered = [v for v in ordered if str(v.id) not in watched]
|
||||
|
||||
offset = int(_decode_cursor(cursor).get("o", 0))
|
||||
items = filtered if len(filtered) > offset else ordered
|
||||
page_items = items[offset: offset + limit]
|
||||
next_cursor = _encode_cursor({"o": offset + limit}) if len(items) > offset + limit else None
|
||||
return {
|
||||
"next_cursor": next_cursor,
|
||||
"list": await serialize_videos(db, page_items, identity.user_id),
|
||||
}
|
||||
|
||||
|
||||
# ---------- 视频详情 ----------
|
||||
|
||||
async def get_detail(db: AsyncSession, redis: aioredis.Redis, identity: Identity, video_id: int) -> dict:
|
||||
"""详情：基础数据缓存 5min（中性，不含观看者态）；登录用户叠加 my_position/互动状态"""
|
||||
cache_key = f"video:detail:{video_id}"
|
||||
cached = await redis.get(cache_key)
|
||||
if cached:
|
||||
data = json.loads(cached)
|
||||
else:
|
||||
video = await db.get(Video, video_id)
|
||||
if video is None or video.status != STATUS_PUBLISHED:
|
||||
raise BizException(errors.VIDEO_NOT_AVAILABLE)
|
||||
base = (await serialize_videos(db, [video]))[0]
|
||||
category = await db.get(Category, video.category_id) if video.category_id else None
|
||||
base.update({
|
||||
"description": video.description,
|
||||
"category": {"category_id": category.id, "name": category.name} if category else None,
|
||||
"published_at": _fmt(video.published_at),
|
||||
})
|
||||
data = base
|
||||
await redis.set(cache_key, json.dumps(data, ensure_ascii=False), ex=DETAIL_CACHE_TTL)
|
||||
|
||||
data = dict(data)
|
||||
data["my_position"] = 0
|
||||
if identity.user_id:
|
||||
# 登录用户：互动状态 + 续播进度（最近一次观看记录）
|
||||
video_id_int = int(data["video_id"])
|
||||
data["is_liked"] = bool((await db.execute(
|
||||
select(Like.id).where(Like.user_id == identity.user_id, Like.video_id == video_id_int)
|
||||
)).first())
|
||||
data["is_favorited"] = bool((await db.execute(
|
||||
select(Favorite.id).where(Favorite.user_id == identity.user_id, Favorite.video_id == video_id_int)
|
||||
)).first())
|
||||
last = (await db.execute(
|
||||
select(WatchRecord.position).where(
|
||||
WatchRecord.subject_type == 1, WatchRecord.subject_id == str(identity.user_id),
|
||||
WatchRecord.video_id == video_id_int,
|
||||
).order_by(WatchRecord.id.desc()).limit(1)
|
||||
)).scalar()
|
||||
data["my_position"] = int(last or 0)
|
||||
return data
|
||||
|
||||
|
||||
async def invalidate_detail_cache(redis: aioredis.Redis, video_id: int) -> None:
|
||||
"""状态变更（编辑/上下架/审核）时失效详情缓存"""
|
||||
await redis.delete(f"video:detail:{video_id}")
|
||||
|
||||
|
||||
# ---------- 观看上报（计费） ----------
|
||||
|
||||
async def _get_published_video(db: AsyncSession, video_id: int) -> Video:
|
||||
video = await db.get(Video, video_id)
|
||||
if video is None or video.status != STATUS_PUBLISHED:
|
||||
raise BizException(errors.VIDEO_NOT_AVAILABLE)
|
||||
return video
|
||||
|
||||
|
||||
async def report_watch(
|
||||
db: AsyncSession, redis: aioredis.Redis, identity: Identity, video_id: int, position: int
|
||||
) -> dict:
|
||||
"""计费判定链：同日去重 → 会员 → 本人 → 免费额度 Lua → 游客拦截 → 扣积分"""
|
||||
video = await _get_published_video(db, video_id)
|
||||
if not identity.subject:
|
||||
raise BizException(errors.PARAM_ERROR, "缺少 X-Device-ID")
|
||||
today = date.today()
|
||||
ymd = f"{today:%Y%m%d}"
|
||||
subject = identity.subject
|
||||
watched_key = f"watched:{subject}:{ymd}"
|
||||
|
||||
await ratelimit.hit(redis, f"rl:watch:{subject}:{datetime.now():%Y%m%d%H%M}", WATCH_RATE_LIMIT, 60)
|
||||
|
||||
# 1. 同日去重：重复观看不计费，仅更新续播进度
|
||||
if await redis.sismember(watched_key, str(video_id)): # type: ignore[misc]
|
||||
await _upsert_watch_record(db, identity, video_id, today, 3, 0, position)
|
||||
await db.commit()
|
||||
return await _watch_resp(db, redis, identity, 3, 0, ymd)
|
||||
|
||||
is_author = bool(identity.user_id and video.user_id == identity.user_id)
|
||||
cost_type, cost_points = 3, 0
|
||||
|
||||
if is_author:
|
||||
pass # 本人作品不计费
|
||||
elif identity.user_id and await membership_service.is_member(db, identity.user_id):
|
||||
cost_type = 2 # 会员免费
|
||||
else:
|
||||
# 2. 免费额度（Lua 原子：去重 + 计数 + 占位）
|
||||
free_limit = int(_points_cfg().get("daily_free_count", 10))
|
||||
free_key = f"free:watch:{subject}:{ymd}"
|
||||
res = await redis.eval(FREE_QUOTA_LUA, 1, free_key, str(video_id), str(free_limit), str(SET_TTL)) # type: ignore[misc]
|
||||
if res == 2:
|
||||
cost_type = 0 # 占用免费额度
|
||||
elif res == 1:
|
||||
cost_type = 3 # 并发下已在免费集合 → 按重复处理
|
||||
else:
|
||||
# 3. 额度用尽：游客拦截 / 用户扣积分
|
||||
if identity.is_guest:
|
||||
raise BizException(errors.FREE_LIMIT_EXCEEDED, "今日免费观看次数已用完，登录后继续观看",
|
||||
data={"need_login": True})
|
||||
cost_type = 1
|
||||
cost_points = int(_points_cfg().get("watch_cost", 1))
|
||||
try:
|
||||
await wallet_service.change_points(
|
||||
db, identity.user_id, -cost_points, wallet_service.BIZ_WATCH,
|
||||
biz_id=str(video_id), remark="观看视频",
|
||||
)
|
||||
except BizException as e:
|
||||
if e.code == errors.POINTS_NOT_ENOUGH:
|
||||
# 文档 5.3：积分不足响应 data 带当前积分
|
||||
e.data = {"points": await wallet_service.get_balance(db, identity.user_id)}
|
||||
raise
|
||||
|
||||
first_today = await _upsert_watch_record(db, identity, video_id, today, cost_type, cost_points, position)
|
||||
if first_today:
|
||||
video.view_count += 1
|
||||
await redis.sadd(watched_key, str(video_id)) # type: ignore[misc]
|
||||
await redis.expire(watched_key, SET_TTL)
|
||||
await db.commit()
|
||||
return await _watch_resp(db, redis, identity, cost_type, cost_points, ymd)
|
||||
|
||||
|
||||
async def _upsert_watch_record(
|
||||
db: AsyncSession, identity: Identity, video_id: int, watch_date: date,
|
||||
cost_type: int, cost_points: int, position: int, watch_duration: int = 0,
|
||||
) -> bool:
|
||||
"""按 uk_dedup 天然键幂等写入；返回是否当日首次（用于播放量与收益计数）"""
|
||||
insert_stmt = mysql_insert(WatchRecord).values(
|
||||
subject_type=1 if identity.user_id else 2,
|
||||
subject_id=identity.subject,
|
||||
video_id=video_id,
|
||||
watch_date=watch_date,
|
||||
cost_type=cost_type,
|
||||
cost_points=cost_points,
|
||||
position=position,
|
||||
watch_duration=watch_duration,
|
||||
)
|
||||
stmt = insert_stmt.on_duplicate_key_update(
|
||||
position=insert_stmt.inserted.position,
|
||||
watch_duration=insert_stmt.inserted.watch_duration,
|
||||
)
|
||||
result = await db.execute(stmt)
|
||||
await db.flush()
|
||||
return result.rowcount == 1
|
||||
|
||||
|
||||
async def _watch_resp(db: AsyncSession, redis: aioredis.Redis, identity: Identity,
|
||||
cost_type: int, cost_points: int, ymd: str) -> dict:
|
||||
free_limit = int(_points_cfg().get("daily_free_count", 10))
|
||||
used = await redis.scard(f"free:watch:{identity.subject}:{ymd}") # type: ignore[misc]
|
||||
remaining_points = await wallet_service.get_balance(db, identity.user_id) if identity.user_id else 0
|
||||
return {
|
||||
"cost_type": cost_type,
|
||||
"cost_points": cost_points,
|
||||
"remaining_points": remaining_points,
|
||||
"free_remaining_today": max(free_limit - int(used or 0), 0),
|
||||
}
|
||||
|
||||
|
||||
# ---------- 完整观看上报 ----------
|
||||
|
||||
async def report_complete(
|
||||
db: AsyncSession, redis: aioredis.Redis, identity: Identity, video_id: int, watch_duration: int
|
||||
) -> dict:
|
||||
"""完整观看：本人/当日重复/时长明显不足 → credited=false；有效则累计 video_earnings"""
|
||||
video = await _get_published_video(db, video_id)
|
||||
if not identity.subject:
|
||||
raise BizException(errors.PARAM_ERROR, "缺少 X-Device-ID")
|
||||
|
||||
credited = False
|
||||
is_author = bool(identity.user_id and video.user_id == identity.user_id)
|
||||
# 时长合理性：不得明显低于视频时长（低于 50% 视为异常）
|
||||
duration_ok = video.duration <= 0 or watch_duration >= video.duration * 0.5
|
||||
if not is_author and duration_ok and watch_duration > 0:
|
||||
ymd = f"{datetime.now():%Y%m%d}"
|
||||
dedup_key = f"cview:{identity.subject}:{video_id}:{ymd}"
|
||||
if await redis.set(dedup_key, 1, nx=True, ex=SET_TTL):
|
||||
stmt = mysql_insert(VideoEarning).values(
|
||||
video_id=video_id, author_id=video.user_id, complete_views=1
|
||||
).on_duplicate_key_update(complete_views=VideoEarning.complete_views + 1)
|
||||
await db.execute(stmt)
|
||||
credited = True
|
||||
# 记录实际观看时长（续播记录复用）
|
||||
await _upsert_watch_record(db, identity, video_id, date.today(), 3, 0, 0, watch_duration)
|
||||
await db.commit()
|
||||
return {"credited": credited}
|
||||
|
||||
|
||||
# ---------- 分类 ----------
|
||||
|
||||
async def list_categories(db: AsyncSession) -> list[dict]:
|
||||
rows = (await db.execute(
|
||||
select(Category).where(Category.status == 1).order_by(Category.sort, Category.id)
|
||||
)).scalars().all()
|
||||
return [{"category_id": c.id, "name": c.name} for c in rows]
|
||||
|
||||
|
||||
# ---------- 上传发布（5.5 / 5.6 / 5.7） ----------
|
||||
|
||||
# 上传凭证（object_key 占位）有效期 24h
|
||||
UPLOAD_TOKEN_TTL = 24 * 3600
|
||||
|
||||
|
||||
def _upload_cfg() -> dict:
|
||||
return biz_config.get("upload") or {}
|
||||
|
||||
|
||||
async def get_upload_token(redis: aioredis.Redis, identity: Identity, req: UploadTokenReq) -> dict:
|
||||
"""5.5 获取上传凭证：开发环境无 OSS，返回 server 中转模式，客户端改走 upload/file"""
|
||||
ext = storage_service.video_ext_of(req.file_name)
|
||||
if ext not in storage_service.VIDEO_EXTS:
|
||||
raise BizException(errors.PARAM_ERROR, "仅支持 mp4/mov/m4v/avi/mkv/webm 格式")
|
||||
max_mb = int(_upload_cfg().get("max_size_mb", 500))
|
||||
if req.file_size > max_mb * 1024 * 1024:
|
||||
raise BizException(errors.PARAM_ERROR, f"文件不能超过 {max_mb}MB")
|
||||
object_key = f"upload/tmp/{datetime.now():%Y%m%d}/{uuid.uuid4().hex}.{ext}"
|
||||
# 占位登记：upload/file 与发布时校验归属与有效期
|
||||
await redis.set(
|
||||
f"upload:obj:{object_key}", json.dumps({"uid": identity.user_id, "url": ""}), ex=UPLOAD_TOKEN_TTL
|
||||
)
|
||||
return {"upload_type": "server", "object_key": object_key, "upload_url": "/videos/upload/file"}
|
||||
|
||||
|
||||
async def _load_pending_upload(redis: aioredis.Redis, object_key: str, user_id: int) -> dict:
|
||||
raw = await redis.get(f"upload:obj:{object_key}")
|
||||
pending = json.loads(raw) if raw else None
|
||||
if not pending or pending.get("uid") != user_id:
|
||||
raise BizException(errors.PARAM_ERROR, "object_key 无效或已过期")
|
||||
return pending
|
||||
|
||||
|
||||
async def register_upload(
|
||||
redis: aioredis.Redis, identity: Identity, object_key: str, file: UploadFile
|
||||
) -> dict:
|
||||
"""upload/token 配套：multipart 中转上传，保存到本地并登记可访问 url"""
|
||||
storage_service.validate_object_key(object_key)
|
||||
await _load_pending_upload(redis, object_key, identity.user_id)
|
||||
url, size = await storage_service.save_video(file, object_key)
|
||||
await redis.set(
|
||||
f"upload:obj:{object_key}",
|
||||
json.dumps({"uid": identity.user_id, "url": url, "file_size": size}),
|
||||
ex=UPLOAD_TOKEN_TTL,
|
||||
)
|
||||
return {"object_key": object_key, "url": url, "file_size": size}
|
||||
|
||||
|
||||
async def publish_video(
|
||||
db: AsyncSession, redis: aioredis.Redis, identity: Identity, req: PublishVideoReq
|
||||
) -> dict:
|
||||
"""5.6 发布：敏感词过滤 → 分类/上传校验 → 创建 Video（开发环境无转码器，直接待审核）"""
|
||||
for text in [req.title, req.description, *req.tags]:
|
||||
if text and await sensitive_service.find_sensitive(db, redis, text):
|
||||
raise BizException(errors.SENSITIVE_WORD)
|
||||
_check_tags(req.tags)
|
||||
category = await db.get(Category, req.category_id)
|
||||
if category is None or category.status != 1:
|
||||
raise BizException(errors.PARAM_ERROR, "分类不存在")
|
||||
pending = await _load_pending_upload(redis, req.object_key, identity.user_id)
|
||||
if not pending.get("url"):
|
||||
raise BizException(errors.PARAM_ERROR, "视频文件尚未上传")
|
||||
|
||||
is_priority = 1 if await membership_service.is_member(db, identity.user_id) else 0
|
||||
video = Video(
|
||||
user_id=identity.user_id,
|
||||
category_id=req.category_id,
|
||||
title=req.title,
|
||||
description=req.description,
|
||||
video_url=pending["url"],
|
||||
file_size=int(pending.get("file_size") or 0),
|
||||
status=1, # 待审核：开发环境无转码器，由后台审核通过后直接上架
|
||||
is_priority=is_priority,
|
||||
)
|
||||
db.add(video)
|
||||
await db.flush()
|
||||
await _upsert_tags(db, video.id, req.tags)
|
||||
await redis.delete(f"upload:obj:{req.object_key}")
|
||||
await db.commit()
|
||||
return {
|
||||
"video_id": video.id,
|
||||
"status": video.status,
|
||||
"status_text": STATUS_TEXT[video.status],
|
||||
"is_priority": bool(is_priority),
|
||||
}
|
||||
|
||||
|
||||
def _check_tags(names: list[str]) -> None:
|
||||
"""标签数量与长度校验（0~5 个，每个 1~20 字）"""
|
||||
if len(names) > 5:
|
||||
raise BizException(errors.PARAM_ERROR, "标签最多 5 个")
|
||||
if any(not (1 <= len(t) <= 20) for t in names):
|
||||
raise BizException(errors.PARAM_ERROR, "每个标签 1~20 字")
|
||||
|
||||
|
||||
async def _upsert_tags(db: AsyncSession, video_id: int, names: list[str]) -> None:
|
||||
"""标签 upsert + 关联（去重保序，维护冗余 video_count）"""
|
||||
for name in dict.fromkeys(names):
|
||||
tag = (await db.execute(select(Tag).where(Tag.name == name))).scalar_one_or_none()
|
||||
if tag is None:
|
||||
tag = Tag(name=name)
|
||||
db.add(tag)
|
||||
await db.flush()
|
||||
db.add(VideoTag(video_id=video_id, tag_id=tag.id))
|
||||
tag.video_count += 1
|
||||
|
||||
|
||||
async def _replace_tags(db: AsyncSession, video_id: int, names: list[str]) -> None:
|
||||
"""编辑视频时重建标签关联：旧关联删除并回退计数 → 写新关联"""
|
||||
old = (await db.execute(
|
||||
select(VideoTag, Tag)
|
||||
.join(Tag, Tag.id == VideoTag.tag_id)
|
||||
.where(VideoTag.video_id == video_id)
|
||||
)).all()
|
||||
for link, tag in old:
|
||||
tag.video_count = max(tag.video_count - 1, 0)
|
||||
await db.delete(link)
|
||||
await _upsert_tags(db, video_id, names)
|
||||
|
||||
|
||||
# 软删除标记（模型 status：5 转码失败/已删除）
|
||||
STATUS_DELETED = 5
|
||||
|
||||
|
||||
async def _get_own_video(db: AsyncSession, identity: Identity, video_id: int) -> Video:
|
||||
"""取本人作品：不存在/已删除 → 2003；非作者 → 2107"""
|
||||
video = await db.get(Video, video_id)
|
||||
if video is None or video.status == STATUS_DELETED:
|
||||
raise BizException(errors.VIDEO_NOT_AVAILABLE)
|
||||
if video.user_id != identity.user_id:
|
||||
raise BizException(errors.NOT_AUTHOR)
|
||||
return video
|
||||
|
||||
|
||||
async def update_video(
|
||||
db: AsyncSession, redis: aioredis.Redis, identity: Identity, video_id: int, req
|
||||
) -> dict:
|
||||
"""5.12 编辑视频（仅作者）：敏感词过滤 → 分类/标签校验 → 逐字段更新 → 失效详情缓存"""
|
||||
video = await _get_own_video(db, identity, video_id)
|
||||
|
||||
texts = [t for t in (req.title, req.description) if t] + list(req.tags or [])
|
||||
for text in texts:
|
||||
if await sensitive_service.find_sensitive(db, redis, text):
|
||||
raise BizException(errors.SENSITIVE_WORD)
|
||||
|
||||
if req.title is not None:
|
||||
video.title = req.title
|
||||
if req.description is not None:
|
||||
video.description = req.description
|
||||
if req.category_id is not None:
|
||||
category = await db.get(Category, req.category_id)
|
||||
if category is None or category.status != 1:
|
||||
raise BizException(errors.PARAM_ERROR, "分类不存在")
|
||||
video.category_id = req.category_id
|
||||
if req.tags is not None:
|
||||
_check_tags(req.tags)
|
||||
await _replace_tags(db, video.id, req.tags)
|
||||
|
||||
await db.commit()
|
||||
await invalidate_detail_cache(redis, video.id)
|
||||
return {"video_id": video.id}
|
||||
|
||||
|
||||
async def delete_video(
|
||||
db: AsyncSession, redis: aioredis.Redis, identity: Identity, video_id: int
|
||||
) -> None:
|
||||
"""5.13 删除视频（仅作者，软删除）：置已删除状态 → 立即下架不可见，互动计数保留"""
|
||||
video = await _get_own_video(db, identity, video_id)
|
||||
video.status = STATUS_DELETED
|
||||
await db.commit()
|
||||
await invalidate_detail_cache(redis, video.id)
|
||||
|
||||
|
||||
async def list_my_videos(
|
||||
db: AsyncSession, user_id: int, page: int, page_size: int, status: int | None
|
||||
) -> dict:
|
||||
"""5.7 我的作品：按创建倒序（排除已删除），列表项附加 status/status_text/reject_reason"""
|
||||
stmt = select(Video).where(Video.user_id == user_id, Video.status != STATUS_DELETED)
|
||||
if status is not None:
|
||||
stmt = stmt.where(Video.status == status)
|
||||
total = (await db.execute(select(func.count()).select_from(stmt.subquery()))).scalar() or 0
|
||||
rows = list(
|
||||
(await db.execute(stmt.order_by(Video.id.desc()).offset((page - 1) * page_size).limit(page_size))).scalars()
|
||||
)
|
||||
items = await serialize_videos(db, rows, user_id)
|
||||
for item, v in zip(items, rows):
|
||||
item.update({
|
||||
"status": v.status,
|
||||
"status_text": STATUS_TEXT.get(v.status, ""),
|
||||
"reject_reason": v.reject_reason,
|
||||
"created_at": _fmt(v.created_at),
|
||||
})
|
||||
return {"total": total, "list": items}
|
||||
|
||||
|
||||
# ---------- 搜索 / 热搜 / 标签（5.9 / 5.10 / 5.11） ----------
|
||||
|
||||
# 热搜 ZSet（搜索计数，对齐《03-接口文档》5.10/5.11）
|
||||
HOT_SEARCH_KEY = "search:hot"
|
||||
# 热搜榜返回条数
|
||||
HOT_SEARCH_TOP = 10
|
||||
|
||||
|
||||
def _hot_order(stmt):
|
||||
"""hot 排序：view×1 + like×5 + comment×10（与 Feed 热度分同权，SQL 内计算）"""
|
||||
hot = Video.view_count + Video.like_count * 5 + Video.comment_count * 10
|
||||
return stmt.order_by(hot.desc(), Video.id.desc())
|
||||
|
||||
|
||||
def _latest_order(stmt):
|
||||
return stmt.order_by(Video.published_at.desc(), Video.id.desc())
|
||||
|
||||
|
||||
async def search_videos(
|
||||
db: AsyncSession, redis: aioredis.Redis, identity: Identity,
|
||||
keyword: str, sort: str, page: int, page_size: int,
|
||||
) -> dict:
|
||||
"""5.10 视频搜索：标题/标签 LIKE 匹配；命中敏感词返回空结果；搜索行为计入热搜 ZSet"""
|
||||
if await sensitive_service.find_sensitive(db, redis, keyword):
|
||||
return {"total": 0, "list": []}
|
||||
await redis.zincrby(HOT_SEARCH_KEY, 1, keyword)
|
||||
|
||||
kw = f"%{keyword}%"
|
||||
tag_video_ids = select(VideoTag.video_id).join(Tag, Tag.id == VideoTag.tag_id).where(Tag.name.like(kw))
|
||||
stmt = select(Video).where(
|
||||
Video.status == STATUS_PUBLISHED,
|
||||
Video.title.like(kw) | Video.id.in_(tag_video_ids),
|
||||
)
|
||||
total = (await db.execute(select(func.count()).select_from(stmt.subquery()))).scalar() or 0
|
||||
stmt = _latest_order(stmt) if sort == "latest" else _hot_order(stmt)
|
||||
rows = list((await db.execute(stmt.offset((page - 1) * page_size).limit(page_size))).scalars())
|
||||
return {"total": total, "list": await serialize_videos(db, rows, identity.user_id)}
|
||||
|
||||
|
||||
async def get_hot_search(redis: aioredis.Redis) -> dict:
|
||||
"""5.11 热搜榜：search:hot ZSet Top10"""
|
||||
words = await redis.zrevrange(HOT_SEARCH_KEY, 0, HOT_SEARCH_TOP - 1)
|
||||
return {"words": list(words)}
|
||||
|
||||
|
||||
async def get_tag_videos(
|
||||
db: AsyncSession, identity: Identity, tag_name: str, sort: str, page: int, page_size: int
|
||||
) -> dict:
|
||||
"""5.9 标签视频列表：标签不存在时返回空（tag 字段回显原名）"""
|
||||
tag = (await db.execute(select(Tag).where(Tag.name == tag_name))).scalar_one_or_none()
|
||||
if tag is None:
|
||||
return {"tag": tag_name, "total": 0, "list": []}
|
||||
stmt = (
|
||||
select(Video)
|
||||
.join(VideoTag, VideoTag.video_id == Video.id)
|
||||
.where(VideoTag.tag_id == tag.id, Video.status == STATUS_PUBLISHED)
|
||||
)
|
||||
total = (await db.execute(select(func.count()).select_from(stmt.subquery()))).scalar() or 0
|
||||
stmt = _latest_order(stmt) if sort == "latest" else _hot_order(stmt)
|
||||
rows = list((await db.execute(stmt.offset((page - 1) * page_size).limit(page_size))).scalars())
|
||||
return {"tag": tag.name, "total": total, "list": await serialize_videos(db, rows, identity.user_id)}
|
||||
@@ -0,0 +1,81 @@
|
||||
"""积分钱包服务：统一余额变更入口（行锁 + 流水 + 乐观锁，对齐《02-技术文档》3.4）"""
|
||||
from sqlalchemy import select
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.core import errors
|
||||
from app.core.response import BizException
|
||||
from app.models.billing import PointTransaction
|
||||
from app.models.user import UserWallet
|
||||
|
||||
# 流水业务类型
|
||||
BIZ_RECHARGE = 1 # 充值
|
||||
BIZ_WATCH = 2 # 观看消耗
|
||||
BIZ_COMMENT = 3 # 评论奖励
|
||||
BIZ_MEMBERSHIP = 4 # 开通会员
|
||||
BIZ_GIFT = 5 # 活动赠送
|
||||
BIZ_ADJUST = 6 # 后台调整
|
||||
BIZ_CLAWBACK = 7 # 奖励扣回/退款扣回
|
||||
BIZ_REFERRAL = 8 # 推荐奖励
|
||||
|
||||
|
||||
async def get_or_create_wallet(db: AsyncSession, user_id: int, for_update: bool = False) -> UserWallet:
|
||||
stmt = select(UserWallet).where(UserWallet.user_id == user_id)
|
||||
if for_update:
|
||||
stmt = stmt.with_for_update()
|
||||
wallet = (await db.execute(stmt)).scalar_one_or_none()
|
||||
if wallet is None:
|
||||
wallet = UserWallet(user_id=user_id)
|
||||
db.add(wallet)
|
||||
await db.flush()
|
||||
if for_update:
|
||||
# 新建后再加行锁，保证后续并发读到同一行
|
||||
wallet = (await db.execute(stmt)).scalar_one()
|
||||
return wallet
|
||||
|
||||
|
||||
async def change_points(
|
||||
db: AsyncSession,
|
||||
user_id: int,
|
||||
amount: int,
|
||||
biz_type: int,
|
||||
biz_id: str = "",
|
||||
remark: str = "",
|
||||
allow_negative: bool = False,
|
||||
) -> int:
|
||||
"""变更积分余额，返回变动后余额。
|
||||
|
||||
- amount 正增负减；扣减默认不允许透支（退款扣回场景传 allow_negative=True，余额可为负）
|
||||
- 同事务内：行锁 → 校验/更新余额与累计 → 写流水
|
||||
"""
|
||||
wallet = await get_or_create_wallet(db, user_id, for_update=True)
|
||||
new_balance = wallet.points + amount
|
||||
if amount < 0 and new_balance < 0 and not allow_negative:
|
||||
raise BizException(errors.POINTS_NOT_ENOUGH)
|
||||
|
||||
wallet.points = new_balance
|
||||
wallet.version += 1
|
||||
if amount > 0:
|
||||
if biz_type == BIZ_RECHARGE:
|
||||
wallet.total_recharge += amount
|
||||
else:
|
||||
wallet.total_earned += amount
|
||||
else:
|
||||
wallet.total_consumed += -amount
|
||||
|
||||
db.add(
|
||||
PointTransaction(
|
||||
user_id=user_id,
|
||||
change_amount=amount,
|
||||
balance_after=new_balance,
|
||||
biz_type=biz_type,
|
||||
biz_id=biz_id,
|
||||
remark=remark,
|
||||
)
|
||||
)
|
||||
await db.flush()
|
||||
return new_balance
|
||||
|
||||
|
||||
async def get_balance(db: AsyncSession, user_id: int) -> int:
|
||||
wallet = await get_or_create_wallet(db, user_id)
|
||||
return wallet.points
|
||||
Reference in New Issue
Block a user