507 lines
17 KiB
Python
507 lines
17 KiB
Python
"""今日订单：真单统计 + 可选假数据混合（独立于抢单池假单）。"""
|
||
from __future__ import annotations
|
||
|
||
import logging
|
||
from datetime import datetime, time, timedelta
|
||
from decimal import Decimal
|
||
|
||
from django.conf import settings
|
||
from django.db import IntegrityError, transaction
|
||
from django.db.models import Q
|
||
from django.utils import timezone
|
||
|
||
from orders.models import Order, TodayOrderFake, TodayOrderFakeBatchState, TodayOrderShowConfig
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
# 进行中：已下单/待抢、进行中、指定中
|
||
DOING_STATUSES = {1, 2, 7}
|
||
# 不计入当日有效单：未支付、支付失败、已废弃
|
||
EXCLUDE_STATUSES = {9, 14, 25}
|
||
|
||
# 明细列表假单上限（角标仍用完整 show_count）
|
||
_FAKE_LIST_CAP = 3000
|
||
_FAKE_COUNT_CAP = 20000
|
||
|
||
|
||
def _now_naive():
|
||
"""项目 USE_TZ=False，MySQL 只接受 naive datetime。"""
|
||
now = timezone.now()
|
||
if timezone.is_aware(now):
|
||
return timezone.make_naive(now)
|
||
return now
|
||
|
||
|
||
def _today_range():
|
||
now = _now_naive()
|
||
start = datetime.combine(now.date(), time.min)
|
||
end = start + timedelta(days=1)
|
||
return start, end
|
||
|
||
|
||
def _abs_media(path: str) -> str:
|
||
p = (path or '').strip()
|
||
if not p:
|
||
return ''
|
||
if p.startswith('http://') or p.startswith('https://'):
|
||
return p
|
||
base = (getattr(settings, 'COS_DOMAIN', '') or '').rstrip('/')
|
||
return f'{base}/{p.lstrip("/")}' if base else p
|
||
|
||
|
||
def get_or_create_config(club_id: str) -> TodayOrderShowConfig:
|
||
cid = (club_id or '').strip()
|
||
row = TodayOrderShowConfig.query.filter(club_id=cid).first()
|
||
if row:
|
||
return row
|
||
row = TodayOrderShowConfig(club_id=cid, mix_enabled=False, batch_size=5, interval_seconds=120)
|
||
try:
|
||
row.save()
|
||
except IntegrityError:
|
||
row = TodayOrderShowConfig.query.filter(club_id=cid).first()
|
||
if not row:
|
||
raise
|
||
return row
|
||
|
||
|
||
def config_to_dict(row: TodayOrderShowConfig | None) -> dict:
|
||
if not row:
|
||
return {
|
||
'club_id': '',
|
||
'mix_enabled': False,
|
||
'batch_size': 5,
|
||
'interval_seconds': 120,
|
||
}
|
||
return {
|
||
'club_id': row.club_id,
|
||
'mix_enabled': bool(row.mix_enabled),
|
||
'batch_size': int(row.batch_size or 5),
|
||
'interval_seconds': int(row.interval_seconds or 120),
|
||
}
|
||
|
||
|
||
def save_config(club_id: str, data: dict) -> dict:
|
||
row = get_or_create_config(club_id)
|
||
|
||
def _as_bool(v):
|
||
if isinstance(v, bool):
|
||
return v
|
||
if isinstance(v, (int, float)):
|
||
return bool(v)
|
||
if isinstance(v, (list, tuple)):
|
||
v = v[-1] if v else False
|
||
s = str(v or '').strip().lower()
|
||
if s in ('1', 'true', 'yes', 'on'):
|
||
return True
|
||
if s in ('0', 'false', 'no', 'off', ''):
|
||
return False
|
||
return bool(v)
|
||
|
||
def _as_int(v, default):
|
||
if isinstance(v, (list, tuple)):
|
||
v = v[-1] if v else default
|
||
if v is None or v == '':
|
||
return default
|
||
try:
|
||
return int(float(v))
|
||
except (TypeError, ValueError):
|
||
return default
|
||
|
||
if 'mix_enabled' in data:
|
||
row.mix_enabled = _as_bool(data.get('mix_enabled'))
|
||
if 'batch_size' in data and data.get('batch_size') is not None and data.get('batch_size') != '':
|
||
row.batch_size = max(0, min(500, _as_int(data.get('batch_size'), row.batch_size or 5)))
|
||
if 'interval_seconds' in data and data.get('interval_seconds') is not None and data.get('interval_seconds') != '':
|
||
row.interval_seconds = max(
|
||
1, min(86400, _as_int(data.get('interval_seconds'), row.interval_seconds or 120)),
|
||
)
|
||
row.save()
|
||
return config_to_dict(row)
|
||
|
||
|
||
def _leixing_icon_map(club_id: str, leixing_ids: set[int]) -> dict[int, str]:
|
||
if not leixing_ids:
|
||
return {}
|
||
out = {}
|
||
try:
|
||
from jituan.services.club_shangpin_leixing import build_club_leixing_list_for_api
|
||
for row in build_club_leixing_list_for_api(club_id):
|
||
lid = int(row.get('id') or 0)
|
||
if lid in leixing_ids:
|
||
out[lid] = _abs_media(row.get('tupian_url') or '')
|
||
except Exception as e:
|
||
logger.warning('leixing icon map failed: %s', e)
|
||
if len(out) < len(leixing_ids):
|
||
try:
|
||
from products.models import ShangpinLeixing
|
||
for lx in ShangpinLeixing.query.filter(id__in=list(leixing_ids)):
|
||
if lx.id not in out:
|
||
out[int(lx.id)] = _abs_media(lx.tupian_url or '')
|
||
except Exception as e:
|
||
logger.warning('fallback leixing icons failed: %s', e)
|
||
return out
|
||
|
||
|
||
def _real_qs(club_id: str):
|
||
start, end = _today_range()
|
||
return (
|
||
Order.query.filter(ClubID=club_id, CreateTime__gte=start, CreateTime__lt=end)
|
||
.exclude(Status__in=list(EXCLUDE_STATUSES))
|
||
)
|
||
|
||
|
||
def _parse_fake_ids(raw) -> list[int]:
|
||
if not isinstance(raw, list):
|
||
return []
|
||
out = []
|
||
for x in raw:
|
||
try:
|
||
if isinstance(x, bool):
|
||
continue
|
||
out.append(int(x))
|
||
except (TypeError, ValueError):
|
||
continue
|
||
return out
|
||
|
||
|
||
def _ensure_batch_state(club_id: str) -> TodayOrderFakeBatchState:
|
||
state = TodayOrderFakeBatchState.query.filter(club_id=club_id).first()
|
||
if state:
|
||
return state
|
||
state = TodayOrderFakeBatchState(
|
||
club_id=club_id, fake_ids=[], show_count=0, last_shuffle_at=None,
|
||
)
|
||
try:
|
||
state.save()
|
||
except IntegrityError:
|
||
state = TodayOrderFakeBatchState.query.filter(club_id=club_id).first()
|
||
if not state:
|
||
raise
|
||
return state
|
||
|
||
|
||
def _tick_fake_show_count(club_id: str, cfg: TodayOrderShowConfig) -> int:
|
||
"""
|
||
惰性累加「假单展示数量」（抢单池「今日」角标用这个）：
|
||
- 当天首次有人请求：show_count = batch_size（如 35）
|
||
- 之后每过 interval 秒再有人请求：show_count += batch_size（526→561→596）
|
||
- 未到间隔：数字不变
|
||
- 无人请求：时间到了也不涨
|
||
- 跨自然日：清零重计
|
||
数量与假单池「行数」脱钩；明细从池子循环填充。
|
||
"""
|
||
if not cfg.mix_enabled or int(cfg.batch_size or 0) <= 0:
|
||
return 0
|
||
if not TodayOrderFake.query.filter(club_id=club_id, is_active=True).exists():
|
||
return 0
|
||
|
||
batch_n = max(1, int(cfg.batch_size))
|
||
interval = max(1, int(cfg.interval_seconds or 120))
|
||
now = _now_naive()
|
||
today = now.date()
|
||
|
||
with transaction.atomic():
|
||
state = (
|
||
TodayOrderFakeBatchState.objects
|
||
.select_for_update()
|
||
.filter(club_id=club_id)
|
||
.first()
|
||
)
|
||
if not state:
|
||
_ensure_batch_state(club_id)
|
||
state = (
|
||
TodayOrderFakeBatchState.objects
|
||
.select_for_update()
|
||
.filter(club_id=club_id)
|
||
.first()
|
||
)
|
||
if not state:
|
||
return 0
|
||
|
||
last = state.last_shuffle_at
|
||
if last and timezone.is_aware(last):
|
||
last = timezone.make_naive(last)
|
||
|
||
show_count = int(getattr(state, 'show_count', 0) or 0)
|
||
# 兼容旧逻辑：只有 fake_ids
|
||
if show_count <= 0:
|
||
legacy_ids = _parse_fake_ids(state.fake_ids)
|
||
if legacy_ids:
|
||
show_count = len(legacy_ids)
|
||
|
||
if last is None or last.date() != today:
|
||
show_count = 0
|
||
last = None
|
||
|
||
add_batches = 0
|
||
if show_count <= 0:
|
||
add_batches = 1
|
||
elif last is not None:
|
||
elapsed = (now - last).total_seconds()
|
||
if elapsed >= interval:
|
||
add_batches = int(elapsed // interval)
|
||
|
||
if add_batches > 0:
|
||
show_count = min(show_count + batch_n * add_batches, _FAKE_COUNT_CAP)
|
||
if last is None:
|
||
new_last = now
|
||
else:
|
||
new_last = last + timedelta(seconds=add_batches * interval)
|
||
if new_last > now:
|
||
new_last = now
|
||
state.show_count = show_count
|
||
state.last_shuffle_at = new_last
|
||
state.save(update_fields=['show_count', 'last_shuffle_at', 'UpdateTime'])
|
||
elif int(getattr(state, 'show_count', 0) or 0) != show_count:
|
||
state.show_count = show_count
|
||
state.save(update_fields=['show_count', 'UpdateTime'])
|
||
|
||
return int(state.show_count or 0)
|
||
|
||
|
||
def _load_fake_display_rows(club_id: str, show_count: int) -> list[tuple[TodayOrderFake, int]]:
|
||
"""按 show_count 从假单池循环取行。"""
|
||
if show_count <= 0:
|
||
return []
|
||
pool = list(
|
||
TodayOrderFake.query.filter(club_id=club_id, is_active=True).order_by('-sort_order', '-id')
|
||
)
|
||
if not pool:
|
||
return []
|
||
n = min(int(show_count), _FAKE_LIST_CAP)
|
||
return [(pool[i % len(pool)], i) for i in range(n)]
|
||
|
||
|
||
def _serialize_real(o: Order, icon_map: dict[int, str]) -> dict:
|
||
lid = int(o.ProductTypeID or 0) if o.ProductTypeID else 0
|
||
img = _abs_media(o.ImageURL or '')
|
||
if not img and lid:
|
||
img = icon_map.get(lid) or ''
|
||
st = int(o.Status or 0)
|
||
tab = 'doing' if st in DOING_STATUSES else 'done'
|
||
platform = int(o.Platform or 0)
|
||
source = 'pingtai' if platform == 1 else ('shangjia' if platform == 2 else 'pingtai')
|
||
return {
|
||
'id': f'r:{o.OrderID}',
|
||
'is_fake': False,
|
||
'order_id': o.OrderID,
|
||
'source': source,
|
||
'platform': platform,
|
||
'tab': tab,
|
||
'status': st,
|
||
'price': str(o.Amount if o.Amount is not None else '0.00'),
|
||
'jieshao': (o.Description or o.Remark or '').strip() or '订单',
|
||
'image_url': img,
|
||
'leixing_id': lid or None,
|
||
}
|
||
|
||
|
||
def _serialize_fake(f: TodayOrderFake, icon_map: dict[int, str], seq: int = 0) -> dict:
|
||
lid = int(f.leixing_id or 0) if f.leixing_id else 0
|
||
img = _abs_media(f.image_url or '')
|
||
if not img and lid:
|
||
img = icon_map.get(lid) or ''
|
||
platform = int(f.platform or 1)
|
||
source = 'pingtai' if platform == 1 else 'shangjia'
|
||
tab = 'doing' if int(f.status or 1) == TodayOrderFake.STATUS_DOING else 'done'
|
||
return {
|
||
'id': f'f:{f.id}:{seq}',
|
||
'is_fake': True,
|
||
'order_id': f'FAKE-{f.id}-{seq}',
|
||
'source': source,
|
||
'platform': platform,
|
||
'tab': tab,
|
||
'status': int(f.status or 1),
|
||
'price': str(f.price if f.price is not None else '0.00'),
|
||
'jieshao': (f.jieshao or '').strip() or '订单',
|
||
'image_url': img,
|
||
'leixing_id': lid or None,
|
||
}
|
||
|
||
|
||
def _merged_items(club_id: str) -> tuple[list[dict], int, int]:
|
||
"""返回 (明细items, 真单数, 假单展示数 show_count)。"""
|
||
cfg = get_or_create_config(club_id)
|
||
reals = list(_real_qs(club_id).order_by('-CreateTime')[:800])
|
||
show_count = _tick_fake_show_count(club_id, cfg)
|
||
fake_rows = _load_fake_display_rows(club_id, show_count)
|
||
lids = set()
|
||
for o in reals:
|
||
if o.ProductTypeID:
|
||
lids.add(int(o.ProductTypeID))
|
||
for f, _seq in fake_rows:
|
||
if f.leixing_id:
|
||
lids.add(int(f.leixing_id))
|
||
icon_map = _leixing_icon_map(club_id, lids)
|
||
items = [_serialize_real(o, icon_map) for o in reals]
|
||
items.extend(_serialize_fake(f, icon_map, seq=seq) for f, seq in fake_rows)
|
||
return items, len(reals), int(show_count)
|
||
|
||
|
||
def _filter_items(items: list[dict], source: str, tab: str) -> list[dict]:
|
||
src = (source or 'all').strip().lower()
|
||
tb = (tab or 'doing').strip().lower()
|
||
out = items
|
||
if src in ('pingtai', 'shangjia'):
|
||
out = [x for x in out if x.get('source') == src]
|
||
if tb in ('doing', 'done'):
|
||
out = [x for x in out if x.get('tab') == tb]
|
||
return out
|
||
|
||
|
||
def build_summary(items: list[dict], source: str = 'all', *, total_override: int | None = None) -> dict:
|
||
scoped = items
|
||
src = (source or 'all').strip().lower()
|
||
if src in ('pingtai', 'shangjia'):
|
||
scoped = [x for x in items if x.get('source') == src]
|
||
doing = sum(1 for x in scoped if x.get('tab') == 'doing')
|
||
done = sum(1 for x in scoped if x.get('tab') == 'done')
|
||
total = int(total_override) if total_override is not None and src == 'all' else len(scoped)
|
||
# source=all 且明细截断时，用 override 保证角标一致；doing/done 按已生成明细比例不够精确时仍用明细
|
||
if total_override is not None and src == 'all' and total > len(scoped):
|
||
# 把差额算进 done，避免 total != doing+done
|
||
done = max(done, total - doing)
|
||
return {
|
||
'total': total,
|
||
'doing': doing,
|
||
'done': done,
|
||
}
|
||
|
||
|
||
def today_order_count(club_id: str) -> dict:
|
||
"""抢单池角标：真单数 + 累加假单数（按间隔只增）。"""
|
||
cid = (club_id or '').strip()
|
||
if not cid:
|
||
return {'total': 0}
|
||
cfg = get_or_create_config(cid)
|
||
real_n = _real_qs(cid).count()
|
||
fake_n = _tick_fake_show_count(cid, cfg)
|
||
return {
|
||
'total': int(real_n) + int(fake_n),
|
||
'real': int(real_n),
|
||
'fake': int(fake_n),
|
||
}
|
||
|
||
|
||
def today_order_feed(
|
||
club_id: str,
|
||
source: str = 'all',
|
||
tab: str = 'doing',
|
||
page: int = 1,
|
||
limit: int = 15,
|
||
) -> dict:
|
||
cid = (club_id or '').strip()
|
||
page = max(1, int(page or 1))
|
||
limit = max(1, min(50, int(limit or 15)))
|
||
items, real_n, fake_n = _merged_items(cid)
|
||
summary = build_summary(
|
||
items, source=source, total_override=int(real_n) + int(fake_n),
|
||
)
|
||
filtered = _filter_items(items, source=source, tab=tab)
|
||
start = (page - 1) * limit
|
||
end = start + limit
|
||
chunk = filtered[start:end]
|
||
return {
|
||
'summary': summary,
|
||
'list': chunk,
|
||
'more': end < len(filtered),
|
||
'page': page,
|
||
'limit': limit,
|
||
}
|
||
|
||
|
||
def fake_to_admin_dict(row: TodayOrderFake) -> dict:
|
||
return {
|
||
'id': row.id,
|
||
'club_id': row.club_id,
|
||
'platform': int(row.platform or 1),
|
||
'leixing_id': row.leixing_id,
|
||
'jieshao': row.jieshao or '',
|
||
'price': str(row.price or '0.00'),
|
||
'image_url': row.image_url or '',
|
||
'image_full_url': _abs_media(row.image_url or ''),
|
||
'status': int(row.status or 1),
|
||
'is_active': bool(row.is_active),
|
||
'sort_order': int(row.sort_order or 0),
|
||
}
|
||
|
||
|
||
def list_fakes(club_id: str) -> list[dict]:
|
||
rows = TodayOrderFake.query.filter(club_id=club_id).order_by('-sort_order', '-id')
|
||
return [fake_to_admin_dict(r) for r in rows]
|
||
|
||
|
||
def _scalar(val, default=None):
|
||
"""QueryDict / multipart 偶发 list，取末项。"""
|
||
if isinstance(val, (list, tuple)):
|
||
val = val[-1] if val else default
|
||
return default if val is None else val
|
||
|
||
|
||
def upsert_fake(club_id: str, data: dict, fake_id=None) -> tuple[dict | None, str]:
|
||
cid = (club_id or '').strip()
|
||
if not cid:
|
||
return None, '缺少俱乐部'
|
||
try:
|
||
platform = int(_scalar(data.get('platform'), 1) or 1)
|
||
except (TypeError, ValueError):
|
||
return None, 'platform 无效'
|
||
if platform not in (1, 2):
|
||
return None, 'platform 须为 1 或 2'
|
||
try:
|
||
status = int(_scalar(data.get('status'), TodayOrderFake.STATUS_DOING) or TodayOrderFake.STATUS_DOING)
|
||
except (TypeError, ValueError):
|
||
return None, 'status 无效'
|
||
if status not in (TodayOrderFake.STATUS_DOING, TodayOrderFake.STATUS_DONE):
|
||
return None, 'status 仅支持进行中/已完成'
|
||
try:
|
||
price = Decimal(str(_scalar(data.get('price'), '0') if data.get('price') is not None else '0'))
|
||
except Exception:
|
||
return None, '价格无效'
|
||
leixing_id = _scalar(data.get('leixing_id'))
|
||
try:
|
||
leixing_id = int(leixing_id) if leixing_id not in (None, '') else None
|
||
except (TypeError, ValueError):
|
||
return None, '商品类型无效'
|
||
|
||
if fake_id:
|
||
if isinstance(fake_id, (list, tuple)):
|
||
try:
|
||
fake_id = int(fake_id[-1] if fake_id else 0)
|
||
except (TypeError, ValueError):
|
||
fake_id = None
|
||
row = TodayOrderFake.query.filter(id=fake_id, club_id=cid).first()
|
||
if not row:
|
||
return None, '假单不存在'
|
||
else:
|
||
row = TodayOrderFake(club_id=cid)
|
||
|
||
row.platform = platform
|
||
row.leixing_id = leixing_id
|
||
row.jieshao = str(_scalar(data.get('jieshao'), '') or '')[:2000]
|
||
row.price = price
|
||
if 'image_url' in data:
|
||
row.image_url = str(_scalar(data.get('image_url'), '') or '').strip()[:500]
|
||
row.status = status
|
||
if 'is_active' in data:
|
||
raw = _scalar(data.get('is_active'))
|
||
if isinstance(raw, str):
|
||
row.is_active = raw.strip().lower() in ('1', 'true', 'yes', 'on')
|
||
else:
|
||
row.is_active = bool(raw)
|
||
if 'sort_order' in data and data.get('sort_order') is not None:
|
||
try:
|
||
row.sort_order = int(_scalar(data.get('sort_order'), 0) or 0)
|
||
except (TypeError, ValueError):
|
||
row.sort_order = 0
|
||
row.save()
|
||
return fake_to_admin_dict(row), ''
|
||
|
||
|
||
def delete_fake(club_id: str, fake_id: int) -> tuple[bool, str]:
|
||
row = TodayOrderFake.query.filter(id=fake_id, club_id=club_id).first()
|
||
if not row:
|
||
return False, '假单不存在'
|
||
row.delete()
|
||
return True, ''
|