4858 lines
236 KiB
Python
4858 lines
236 KiB
Python
"""采购路由"""
|
||
import json
|
||
import os
|
||
import re
|
||
import unicodedata
|
||
from datetime import datetime
|
||
from flask import Blueprint, request, jsonify, session, redirect, url_for, render_template
|
||
from services.db import query, execute, add_operation_log, get_db
|
||
from services.field_perms import filter_rows as filter_field_rows
|
||
from services.sales_calc import (compute_product_sales_cached,
|
||
compute_product_sales_extended_cached)
|
||
from services.inventory_calc import (compute_product_inventory_cached,
|
||
compute_product_inventory_15,
|
||
compute_product_in_transit_cached,
|
||
compute_cloud_inventory_cached,
|
||
compute_external_inventory_cached,
|
||
_determine_trend)
|
||
from services.forecast import (compute_daily_forecast, sales_predict_config_cached,
|
||
get_global_config)
|
||
from routes.auth import login_required, role_required, operation_required
|
||
from routes.products import INNER_MATERIAL_NAME_KEYS
|
||
from services.product_type import get_product_type_cached
|
||
from routes.planning import (_enrich_row_with_planning_data, _ensure_global_config,
|
||
_personnel_group_members, _personnel_group_for_value)
|
||
from services.planning_order_flag import normalize_new_old
|
||
from services.order_progress import unfinished_order_progress_map
|
||
|
||
purchase_bp = Blueprint('purchase', __name__)
|
||
|
||
PACKAGING_ORDER_STATUSES = ('未完结', '已完结')
|
||
|
||
PLANNING_SALES_SNAPSHOT_FIELDS = (
|
||
'产品分级', '昨日销量', '销售趋势', '库存', '加工厂库存', '生产在途', '采购在途',
|
||
'日销量预测', '3天平均销量', '7天平均销量', '14天平均销量',
|
||
'库存可支撑天数', '加工厂库存支撑天数', '总支撑天数', '30天平均销量', '极值判断',
|
||
)
|
||
|
||
|
||
def _build_planning_sales_snapshot(product_code, product_name='', product_type=''):
|
||
"""按计划预测默认数据口径生成一次性销量快照。"""
|
||
where = ['p.product_code=%s', 'p.deleted_at IS NULL']
|
||
params = [product_code]
|
||
if product_name:
|
||
where.append('p.product_name=%s')
|
||
params.append(product_name)
|
||
elif product_type:
|
||
where.append('p.product_type=%s')
|
||
params.append(product_type)
|
||
product_rows = query(f"""
|
||
SELECT p.*, COALESCE(s.supplier_name, p.supplier_name_match) AS supplier_name
|
||
FROM products p LEFT JOIN suppliers s ON p.supplier_code=s.supplier_code
|
||
WHERE {' AND '.join(where)} ORDER BY p.id LIMIT 1
|
||
""", params)
|
||
if not product_rows:
|
||
raise ValueError(f'未找到货品 {product_code}，无法保存销量快照')
|
||
planning_row = product_rows[0]
|
||
if planning_row.get('created_at'):
|
||
value = planning_row['created_at']
|
||
planning_row['created_at'] = value.strftime('%Y-%m-%d') if hasattr(value, 'strftime') else str(value)[:10]
|
||
if planning_row.get('cost_price') is not None:
|
||
planning_row['cost_price'] = float(planning_row['cost_price'])
|
||
planning_row['lead_time'] = planning_row.get('lead_time') or 0
|
||
planning_row['logistics_time'] = planning_row.get('logistics_time') or 0
|
||
planning_row['供应商名称'] = planning_row.get('supplier_name', '')
|
||
planning_row['生产货期'] = planning_row['lead_time']
|
||
planning_row['物流时间'] = planning_row['logistics_time']
|
||
planning_row['创建时间'] = planning_row.get('created_at', '')
|
||
planning_row['产品种类'] = get_product_type_cached(
|
||
planning_row.get('product_name', ''), planning_row.get('brand', ''),
|
||
planning_row.get('product_type'))
|
||
planning_row['批注'] = planning_row.get('remark') or ''
|
||
planning_row = _enrich_row_with_planning_data(
|
||
planning_row,
|
||
compute_product_sales_cached(),
|
||
compute_product_inventory_cached(),
|
||
compute_product_inventory_15(),
|
||
compute_product_in_transit_cached(),
|
||
{r['trend_type']: r for r in sales_predict_config_cached()},
|
||
get_global_config(),
|
||
cloud_inv_map=compute_cloud_inventory_cached(),
|
||
ext_inv_map=compute_external_inventory_cached(),
|
||
extended_sales=compute_product_sales_extended_cached(),
|
||
)
|
||
return {field: planning_row.get(field, '-') for field in PLANNING_SALES_SNAPSHOT_FIELDS}
|
||
|
||
|
||
# 海外产品清单专属备货通知：名单是非敏感业务配置，Webhook/加签只从运行环境读取，
|
||
# 不写入代码、仓库或普通配置文件，避免与采购跟单群机器人混用。
|
||
OVERSEAS_NOTIFY_NAMES_FILE = os.path.join(
|
||
os.path.dirname(os.path.dirname(__file__)), 'config', 'overseas_product_notify_names.json'
|
||
)
|
||
OVERSEAS_NOTIFY_WEBHOOK_FILE = '/etc/dy-dashboard/credentials/stocking-webhook'
|
||
OVERSEAS_NOTIFY_SECRET_FILE = '/etc/dy-dashboard/credentials/stocking-secret'
|
||
OVERSEAS_NOTIFY_GROUP_KEY = '__overseas_product_notify__'
|
||
|
||
|
||
def _normalize_overseas_product_name(value):
|
||
"""标准化海外产品清单名称，仅处理格式差异，不做模糊截断匹配。"""
|
||
text = unicodedata.normalize('NFKC', str(value or '')).casefold()
|
||
return re.sub(r'\s+', '', text)
|
||
|
||
|
||
def _read_overseas_notify_credential(path):
|
||
"""读取服务器侧受限凭据文件；明文不进入日志或应用响应。"""
|
||
try:
|
||
with open(path, 'r', encoding='utf-8') as handle:
|
||
return handle.read().strip()
|
||
except (OSError, UnicodeError):
|
||
return ''
|
||
|
||
|
||
def _load_overseas_notify_names():
|
||
"""加载海外产品名称名单；文件缺失/格式错误时安全降级为空名单。"""
|
||
try:
|
||
with open(OVERSEAS_NOTIFY_NAMES_FILE, 'r', encoding='utf-8') as handle:
|
||
payload = json.load(handle)
|
||
names = payload.get('names', []) if isinstance(payload, dict) else payload
|
||
return {
|
||
_normalize_overseas_product_name(name)
|
||
for name in names
|
||
if _normalize_overseas_product_name(name)
|
||
}
|
||
except (OSError, TypeError, ValueError) as exc:
|
||
import logging
|
||
logging.warning('[DING_NOTIFY] 海外产品清单加载失败: %s', exc)
|
||
return set()
|
||
|
||
|
||
OVERSEAS_NOTIFY_NAMES = _load_overseas_notify_names()
|
||
|
||
|
||
def _is_overseas_notify_product(product_name):
|
||
"""按海外产品清单标准化名称判断，未匹配时不触发专属通知。"""
|
||
return _normalize_overseas_product_name(product_name) in OVERSEAS_NOTIFY_NAMES
|
||
|
||
|
||
|
||
def _require_purchase_operation(page, operation):
|
||
"""统一校验下单相关接口的操作权限。"""
|
||
if not operation_required(page, operation):
|
||
return jsonify({"code": 403, "msg": "权限不足，当前账号没有该操作权限"})
|
||
return None
|
||
|
||
|
||
def _sync_backup_orderer(product_code, ordered_at, field, value):
|
||
"""将订单管理中的下单人同步到对应的下单备份记录。"""
|
||
if not product_code or not ordered_at or field not in ('product_orderer', 'packaging_orderer'):
|
||
return 0
|
||
return query(
|
||
f"UPDATE pending_orders SET `{field}`=%s WHERE product_code=%s "
|
||
"AND status IN ('ordered','rolled_back') AND ordered_at=%s",
|
||
(value or '', product_code, ordered_at)
|
||
)
|
||
|
||
|
||
def _latest_domestic_order_values(product_code):
|
||
"""读取同一货品编号最近一笔国内订单的单价和仓库。"""
|
||
if not product_code:
|
||
return {}
|
||
rows = query(
|
||
"SELECT `单价`, `仓库` FROM domestic_orders "
|
||
"WHERE `货品编号`=%s ORDER BY id DESC LIMIT 1",
|
||
(product_code,)
|
||
)
|
||
return rows[0] if rows else {}
|
||
|
||
|
||
def _latest_packaging_order_values(material_code):
|
||
"""读取同一包材编码最近一笔订单的单价和到货仓库。"""
|
||
if not material_code:
|
||
return {}
|
||
rows = query(
|
||
"SELECT `单价`, `仓库到货` FROM packaging_orders "
|
||
"WHERE `编码`=%s ORDER BY id DESC LIMIT 1",
|
||
(material_code,)
|
||
)
|
||
return rows[0] if rows else {}
|
||
|
||
|
||
def _supplier_maps():
|
||
"""构建供应商别名→全称，以及全称→简称映射。"""
|
||
rows = query("SELECT supplier_name, short_name, contract_short_name FROM suppliers")
|
||
full_name_map = {}
|
||
short_name_map = {}
|
||
for supplier in rows:
|
||
full_name = (supplier.get('supplier_name') or '').strip()
|
||
if not full_name:
|
||
continue
|
||
short_name = (supplier.get('short_name') or '').strip()
|
||
short_name_map[full_name] = short_name or full_name
|
||
for alias in (full_name, short_name, supplier.get('contract_short_name')):
|
||
alias = (alias or '').strip()
|
||
if alias:
|
||
full_name_map[alias] = full_name
|
||
return full_name_map, short_name_map
|
||
|
||
|
||
def _supplier_full_name_map():
|
||
"""兼容旧调用：构建供应商全称及简称到全称的映射。"""
|
||
return _supplier_maps()[0]
|
||
|
||
|
||
def _packaging_supplier_full_name(material_code, fallback='', source_product_code=''):
|
||
"""解析包材供应商全称，BOM/名称字段优先于可能已失步的供应商编码。
|
||
|
||
产品导入或人工编辑历史上可能只更新 ``supplier_name_match``，留下旧的
|
||
``supplier_code``。下单时若无条件按编码取供应商，会把正确名称覆盖成旧供应商。
|
||
因此优先级固定为：当前成品 BOM 供应商 > 物料供应商名称 > 请求回退值 > 编码绑定。
|
||
"""
|
||
material_code = str(material_code or '').strip()
|
||
source_product_code = str(source_product_code or '').strip()
|
||
fallback = str(fallback or '').strip()
|
||
if not material_code:
|
||
return fallback
|
||
|
||
rows = []
|
||
if source_product_code:
|
||
rows = query(
|
||
"""SELECT NULLIF(b.supplier, '') AS bom_supplier,
|
||
NULLIF(p.supplier_name_match, '') AS product_supplier,
|
||
NULLIF(s_code.supplier_name, '') AS code_supplier
|
||
FROM bom b
|
||
LEFT JOIN products p ON p.product_code=b.material_code
|
||
LEFT JOIN suppliers s_code ON s_code.supplier_code=p.supplier_code
|
||
WHERE b.product_code=%s AND b.material_code=%s
|
||
ORDER BY b.id DESC LIMIT 1""",
|
||
(source_product_code, material_code)
|
||
)
|
||
if not rows:
|
||
rows = query(
|
||
"""SELECT NULL AS bom_supplier,
|
||
NULLIF(p.supplier_name_match, '') AS product_supplier,
|
||
NULLIF(s_code.supplier_name, '') AS code_supplier
|
||
FROM products p
|
||
LEFT JOIN suppliers s_code ON s_code.supplier_code=p.supplier_code
|
||
WHERE p.product_code=%s LIMIT 1""",
|
||
(material_code,)
|
||
)
|
||
|
||
row = rows[0] if rows else {}
|
||
full_name_map, _ = _supplier_maps()
|
||
for candidate in (
|
||
row.get('bom_supplier'),
|
||
row.get('product_supplier'),
|
||
fallback,
|
||
row.get('code_supplier'),
|
||
):
|
||
candidate = str(candidate or '').strip()
|
||
if candidate:
|
||
return full_name_map.get(candidate, candidate)
|
||
return ''
|
||
|
||
|
||
# ════════════════════════════════════════════════════════════════
|
||
# 确认下单 → 钉钉群备货通知（采购跟单组别 → 对应钉钉群）
|
||
# 2026-08-24 旭东确认：群映射如下，通知格式为备货通知（货品编号/货品名称/成品数量/包材数量）
|
||
# ════════════════════════════════════════════════════════════════
|
||
FOLLOWER_GROUP_MAP = {
|
||
'跟单一组': {'group_name': '采购1组（方/余/卢/陈/李）', 'webhook': 'https://oapi.dingtalk.com/robot/send?access_token=0f7c5e134dc165eb30d580a4da3e1e141ba45c68958c4b35505202a38d6e232c', 'secret': 'SEC8a6886f1dd64cdcb3ad03373f17038c1c482ed7834218ad72ab895ae279fa8cf'},
|
||
'跟单二组': {'group_name': '采购2组（刘/闫/许/邓/范）', 'webhook': 'https://oapi.dingtalk.com/robot/send?access_token=f8314992a2a7ae29d1875ce97becadf2f6fc78cf6234083192eb9625675b3ece', 'secret': 'SEC3f83f35be412b6a977f3f9ac72a6d8e5f850010255adfb04e26029ee89332105'},
|
||
'跟单三组': {'group_name': '采购3组（蔡/张/邓/胡/李/张）', 'webhook': 'https://oapi.dingtalk.com/robot/send?access_token=55df3fb01e5ab317d0ae37a14f28e1de20a981bc2839892b7c9f39446184b4e0', 'secret': 'SECa76a2139a41e16abbf799352526b3215e9843d780cbfd95bf8ca4865c1c1f26b'},
|
||
'现货小组': {'group_name': '现货采购群', 'webhook': 'https://oapi.dingtalk.com/robot/send?access_token=8fd43253139d757ae4d14b71363ea4b40b2e8cc7165160227071d9d077e41088', 'secret': 'SEC14e42f8451d0fab4a572ffbb7b277b83857febc4e4478683fc1dc9518e91c5e9'},
|
||
}
|
||
|
||
|
||
def _resolve_follower_group(follower):
|
||
"""将采购跟单字段值解析为组别（组名或成员姓名列表 → 组名），解析不到返回 None。"""
|
||
if not follower:
|
||
return None
|
||
follower = str(follower).strip()
|
||
if follower in FOLLOWER_GROUP_MAP:
|
||
return follower
|
||
try:
|
||
groups = _personnel_group_members()
|
||
label = _personnel_group_for_value(follower, groups)
|
||
if label and label in FOLLOWER_GROUP_MAP:
|
||
return label
|
||
except Exception as e:
|
||
import logging
|
||
logging.warning(f'[DING_NOTIFY] 组别解析异常: {e}')
|
||
return None
|
||
|
||
|
||
def _send_ding_robot(webhook_url, secret, content):
|
||
"""通过钉钉机器人 Webhook 发送 markdown 消息；失败仅记日志，不影响主流程。
|
||
支持可选加签（secret 为空则跳过验签）。"""
|
||
import hashlib
|
||
import hmac
|
||
import base64
|
||
import time
|
||
import json
|
||
import urllib.parse
|
||
import urllib.request
|
||
import logging
|
||
try:
|
||
payload = {
|
||
"msgtype": "markdown",
|
||
"markdown": {"title": "备货通知", "text": content},
|
||
}
|
||
url = webhook_url
|
||
if secret:
|
||
timestamp = str(round(time.time() * 1000))
|
||
string_to_sign = f'{timestamp}\n{secret}'
|
||
hmac_code = hmac.new(secret.encode('utf-8'), string_to_sign.encode('utf-8'), digestmod=hashlib.sha256).digest()
|
||
sign = urllib.parse.quote_plus(base64.b64encode(hmac_code))
|
||
url = f'{webhook_url}×tamp={timestamp}&sign={sign}'
|
||
req = urllib.request.Request(
|
||
url, data=json.dumps(payload).encode('utf-8'),
|
||
headers={'Content-Type': 'application/json'}
|
||
)
|
||
with urllib.request.urlopen(req, timeout=10) as resp:
|
||
result = json.loads(resp.read().decode('utf-8'))
|
||
ok = result.get('errcode') == 0
|
||
if not ok:
|
||
logging.warning(f'[DING_NOTIFY] 机器人返回错误 errcode={result.get("errcode")} errmsg={result.get("errmsg")}')
|
||
return ok
|
||
except Exception as e:
|
||
logging.warning(f'[DING_NOTIFY] 群消息发送异常: {e}')
|
||
return False
|
||
|
||
|
||
def _notify_purchase_ready(notify_groups):
|
||
"""后台线程：按群聚合发送备货通知（每条商品一段，群内聚合为一条消息）。
|
||
钉钉机器人 markdown 单换行不生效，改用 <br> 强制换行，字段逐行展示。"""
|
||
import logging
|
||
for webhook, info in notify_groups.items():
|
||
try:
|
||
blocks = [line.replace('\n', '<br>') for line in info['lines']]
|
||
if info.get('kind') == 'overseas_product':
|
||
# 专属机器人必须单独配置；缺失时不回退到任何现有采购群机器人。
|
||
webhook = _read_overseas_notify_credential(OVERSEAS_NOTIFY_WEBHOOK_FILE)
|
||
secret = _read_overseas_notify_credential(OVERSEAS_NOTIFY_SECRET_FILE)
|
||
if not webhook:
|
||
logging.warning('[DING_NOTIFY] 海外产品专属机器人未配置，跳过通知')
|
||
continue
|
||
content = '备货通知<br><br>' + '<br>'.join(blocks)
|
||
_send_ding_robot(webhook, secret, content)
|
||
continue
|
||
content = '📦 **备货通知**<br><br>' + '<br><br>'.join(blocks)
|
||
_send_ding_robot(webhook, info.get('secret', ''), content)
|
||
except Exception as e:
|
||
logging.warning(f'[DING_NOTIFY] 备货通知发送失败: {e}')
|
||
|
||
|
||
@purchase_bp.route('/purchase')
|
||
@login_required
|
||
def purchase_page():
|
||
if not role_required('purchase'):
|
||
return redirect(url_for('auth.index'))
|
||
return render_template('base.html', page='purchase')
|
||
|
||
|
||
@purchase_bp.route('/orders')
|
||
@login_required
|
||
def orders_page():
|
||
if not role_required('orders'):
|
||
return redirect(url_for('auth.index'))
|
||
return render_template('base.html', page='orders')
|
||
|
||
|
||
@purchase_bp.route('/orders/domestic')
|
||
@login_required
|
||
def orders_domestic_page():
|
||
if not role_required('orders_domestic'):
|
||
return redirect(url_for('auth.index'))
|
||
return render_template('base.html', page='orders_domestic')
|
||
|
||
|
||
@purchase_bp.route('/orders/overseas')
|
||
@login_required
|
||
def orders_overseas_page():
|
||
if not role_required('orders_overseas'):
|
||
return redirect(url_for('auth.index'))
|
||
return render_template('base.html', page='orders_overseas')
|
||
|
||
|
||
@purchase_bp.route('/orders/packaging')
|
||
@login_required
|
||
def orders_packaging_page():
|
||
if not role_required('orders_packaging'):
|
||
return redirect(url_for('auth.index'))
|
||
return render_template('base.html', page='orders_packaging')
|
||
|
||
|
||
@purchase_bp.route('/purchase/ready')
|
||
@login_required
|
||
def purchase_ready_page():
|
||
if not role_required('purchase_ready'):
|
||
return redirect(url_for('auth.index'))
|
||
return render_template('base.html', page='purchase_ready')
|
||
|
||
|
||
@purchase_bp.route('/purchase/confirmed')
|
||
@login_required
|
||
def purchase_confirmed_page():
|
||
if not role_required('purchase'):
|
||
return redirect(url_for('auth.index'))
|
||
return render_template('base.html', page='purchase_confirmed')
|
||
|
||
|
||
def _select_confirm_bom(request_bom, saved_bom, base_bom):
|
||
"""确认下单时按“本次请求 > 待下单已保存数据 > BOM基础清单”选择明细。"""
|
||
if request_bom:
|
||
return request_bom
|
||
if saved_bom:
|
||
return saved_bom
|
||
return base_bom
|
||
|
||
|
||
def _extract_product_actual_qty(items, product_code):
|
||
"""从 BOM 明细中读取明确填写的成品实际下单数量。
|
||
|
||
返回 None 表示请求没有携带成品行；返回 0 也表示用户明确填写了 0，
|
||
不能再回退到旧的正式下单数量。"""
|
||
target_code = f'成品_{product_code}'
|
||
for item in items or []:
|
||
if not isinstance(item, dict) or item.get('material_code') != target_code:
|
||
continue
|
||
value = item.get('actual_quantity')
|
||
if value in (None, ''):
|
||
return None
|
||
try:
|
||
return max(0, int(float(value)))
|
||
except (TypeError, ValueError):
|
||
return 0
|
||
return None
|
||
|
||
|
||
def _normalize_pending_bom_items(items):
|
||
"""规范化待下单 BOM，同时保留下单前/后包材数据。"""
|
||
normalized = []
|
||
for item in items or []:
|
||
if not isinstance(item, dict):
|
||
continue
|
||
material_code = str(item.get('material_code') or '').strip()
|
||
if not material_code:
|
||
continue
|
||
try:
|
||
quantity = float(item.get('quantity', item.get('bom_qty', 0)) or 0)
|
||
except (TypeError, ValueError):
|
||
quantity = 0.0
|
||
try:
|
||
actual_quantity = int(float(item.get('actual_quantity', 0) or 0))
|
||
except (TypeError, ValueError):
|
||
actual_quantity = 0
|
||
current = {
|
||
'material_code': material_code,
|
||
'material_name': item.get('material_name', ''),
|
||
'quantity': quantity,
|
||
'actual_quantity': actual_quantity,
|
||
'remark': item.get('remark', ''),
|
||
'pkg_remark': item.get('pkg_remark', ''),
|
||
'change_manuscript': item.get('change_manuscript', ''),
|
||
'purchase_order_no': item.get('purchase_order_no', ''),
|
||
}
|
||
# 只有请求明确携带时才保存，避免把历史缺失值强行变成 0。
|
||
for field in ('pre_pack_qty', 'post_pack_qty'):
|
||
if field in item and item.get(field) not in (None, ''):
|
||
try:
|
||
current[field] = int(float(item.get(field) or 0))
|
||
except (TypeError, ValueError):
|
||
current[field] = 0
|
||
normalized.append(current)
|
||
return normalized
|
||
|
||
|
||
def _sync_pending_pre_packaging(product_code, items):
|
||
"""把待下单请求里明确提交的下单前包材同步到独立包材结余表。"""
|
||
for item in items or []:
|
||
material_code = str(item.get('material_code') or '').strip()
|
||
if (not material_code or material_code.startswith('成品_')
|
||
or 'pre_pack_qty' not in item):
|
||
continue
|
||
pre_pack_qty = int(item.get('pre_pack_qty') or 0)
|
||
pkg_remark = str(item.get('pkg_remark') or '').strip()
|
||
query("""INSERT INTO bom_packaging
|
||
(product_code, material_code, pre_pack_qty, post_pack_qty, pkg_remark)
|
||
VALUES (%s,%s,%s,0,%s)
|
||
ON DUPLICATE KEY UPDATE pre_pack_qty=%s, pkg_remark=%s, updated_at=NOW()""",
|
||
(product_code, material_code, pre_pack_qty, pkg_remark,
|
||
pre_pack_qty, pkg_remark))
|
||
|
||
|
||
def _resolve_confirm_packaging_qty(item, product_actual_qty):
|
||
"""Resolve the explicit packaging order quantity without falling back for zero."""
|
||
actual = item.get('actual_quantity')
|
||
if actual is not None and actual != '':
|
||
try:
|
||
return max(0, int(float(actual)))
|
||
except (TypeError, ValueError):
|
||
return 0
|
||
try:
|
||
material_qty = float(item.get('quantity', item.get('bom_qty', 0)) or 0)
|
||
except (TypeError, ValueError):
|
||
material_qty = 0
|
||
return max(0, int(material_qty * product_actual_qty))
|
||
|
||
|
||
def _resolve_roll_bom_qty(item, bom_qty_map):
|
||
"""包材结余滚动用的BOM用量：优先取 bom 表权威值，其次 bom_qty，最后才用请求里的 quantity。
|
||
|
||
前端历史版本曾把 quantity 写成“实际下单数量”，直接当用量会算出天量负数。
|
||
"""
|
||
code = str(item.get('material_code') or '').strip()
|
||
if code in bom_qty_map:
|
||
return bom_qty_map[code]
|
||
for key in ('bom_qty', 'quantity'):
|
||
try:
|
||
value = float(item.get(key) or 0)
|
||
except (TypeError, ValueError):
|
||
continue
|
||
if value:
|
||
return value
|
||
return 0.0
|
||
|
||
|
||
def _normalize_backup_bom(items, enrich=True, source_product_code='', source_ordered_at=''):
|
||
"""Keep only real packaging materials and fill display fields from product data."""
|
||
if not items:
|
||
return []
|
||
result = []
|
||
seen = set()
|
||
for item in items:
|
||
code = str(item.get('material_code') or '').strip()
|
||
if not code or code.startswith('成品_') or code in seen:
|
||
continue
|
||
seen.add(code)
|
||
current = dict(item)
|
||
current['material_code'] = code
|
||
if enrich:
|
||
if source_product_code:
|
||
price_rows = query(
|
||
"""SELECT `单价` FROM packaging_orders
|
||
WHERE `编码`=%s AND (`来源产品编码`=%s OR COALESCE(`来源产品编码`, '')='')
|
||
ORDER BY (`来源产品编码`=%s) DESC, id DESC LIMIT 1""",
|
||
(code, source_product_code, source_product_code)
|
||
)
|
||
if price_rows:
|
||
current['unit_price'] = float(price_rows[0].get('单价') or 0)
|
||
rows = query("""SELECT p.product_name, p.cost_price
|
||
FROM products p
|
||
WHERE p.product_code=%s LIMIT 1""", (code,))
|
||
if rows:
|
||
product = rows[0]
|
||
if not current.get('material_name') or current.get('material_name') == '-':
|
||
current['material_name'] = product.get('product_name') or ''
|
||
if current.get('unit_price') in (None, ''):
|
||
current['unit_price'] = float(product.get('cost_price') or 0)
|
||
supplier_full_name = _packaging_supplier_full_name(
|
||
code,
|
||
current.get('supplier_short_name') or '',
|
||
source_product_code,
|
||
)
|
||
if supplier_full_name:
|
||
_, short_name_map = _supplier_maps()
|
||
current['supplier_short_name'] = short_name_map.get(supplier_full_name, supplier_full_name)
|
||
if source_product_code and source_ordered_at:
|
||
orderer_rows = query(
|
||
"""SELECT GROUP_CONCAT(DISTINCT NULLIF(`下单人`, '')
|
||
ORDER BY id SEPARATOR '、') AS packaging_orderer
|
||
FROM packaging_orders
|
||
WHERE BINARY `编码`=BINARY %s AND BINARY `来源产品编码`=BINARY %s AND `下单时间`=%s""",
|
||
(code, source_product_code, source_ordered_at)
|
||
)
|
||
current['packaging_orderer'] = (orderer_rows[0].get('packaging_orderer')
|
||
if orderer_rows else '') or ''
|
||
qty = int(current.get('actual_quantity') or 0)
|
||
current.setdefault('price_audit_status', '未审核')
|
||
current['amount'] = round(qty * float(current.get('unit_price') or 0), 2)
|
||
result.append(current)
|
||
return result
|
||
|
||
|
||
# ─── API: 采购订单 ───
|
||
def _product_type_rank_sql(alias, preferred_type='成品'):
|
||
"""返回同一货品编码下产品档案的确定性优先级。"""
|
||
if preferred_type not in ('成品', '包材'):
|
||
raise ValueError('不支持的优先货品类型')
|
||
fallback_type = '包材' if preferred_type == '成品' else '成品'
|
||
return f"""CASE {alias}.product_type
|
||
WHEN '{preferred_type}' THEN 0
|
||
WHEN '{fallback_type}' THEN 1
|
||
ELSE 2
|
||
END"""
|
||
|
||
|
||
def _unique_product_join(alias, order_code_expr, preferred_type='成品'):
|
||
"""按订单货品编码关联一条产品档案。
|
||
|
||
同一编码允许同时建立成品和包材档案。订单列表只能关联其中一条产品记录，
|
||
否则一条订单会被联表放大成多条，删除时又因为共用同一个订单 ID 而同时消失。
|
||
先使用同字符集等值条件命中 product_code 索引，再用 BINARY 保证编码大小写
|
||
必须完全一致，避免逐条订单扫描整张产品表。
|
||
"""
|
||
rank_sql = _product_type_rank_sql('preferred_product', preferred_type)
|
||
return f"""LEFT JOIN products {alias}
|
||
ON {alias}.product_code = {order_code_expr} COLLATE utf8mb4_0900_ai_ci
|
||
AND BINARY {alias}.product_code = BINARY {order_code_expr}
|
||
AND {alias}.id = (
|
||
SELECT preferred_product.id
|
||
FROM products preferred_product
|
||
WHERE preferred_product.product_code = {order_code_expr} COLLATE utf8mb4_0900_ai_ci
|
||
AND BINARY preferred_product.product_code = BINARY {order_code_expr}
|
||
ORDER BY {rank_sql}, preferred_product.id
|
||
LIMIT 1
|
||
)"""
|
||
|
||
|
||
def _order_table_with_product_type(table, code_field, fallback_code_field=None):
|
||
"""构造带产品信息货品类型的订单数据源，确保一条订单只关联一条产品档案。"""
|
||
primary_join = _unique_product_join(
|
||
'product_type_lookup', f"order_rows.`{code_field}`", '成品'
|
||
)
|
||
type_expr = 'product_type_lookup.product_type'
|
||
if fallback_code_field:
|
||
fallback_join = _unique_product_join(
|
||
'fallback_product_type_lookup',
|
||
f"order_rows.`{fallback_code_field}`",
|
||
'成品',
|
||
)
|
||
type_expr = 'COALESCE(product_type_lookup.product_type, fallback_product_type_lookup.product_type, \'\')'
|
||
return (
|
||
f"(SELECT order_rows.*, {type_expr} AS `货品类型` FROM {table} order_rows "
|
||
f"{primary_join} {fallback_join}) {table}"
|
||
)
|
||
return (
|
||
f"(SELECT order_rows.*, COALESCE({type_expr}, '') AS `货品类型` FROM {table} order_rows "
|
||
f"{primary_join}) {table}"
|
||
)
|
||
|
||
|
||
def _order_product_type_values(table, code_field, where_extra='', params=None, fallback_code_field=None):
|
||
"""按订单筛选条件批量获取货品类型，避免构造整张关联订单表。"""
|
||
# 货品类型是低基数字段，统一在数据库完成筛选、关联和去重；即使存在联动
|
||
# 条件，也不再把订单编码全部拉回 Python 再分批查询 products。
|
||
filtered_source = f"(SELECT `{code_field}` AS primary_code"
|
||
if fallback_code_field:
|
||
filtered_source += f", `{fallback_code_field}` AS fallback_code"
|
||
filtered_source += f" FROM `{table}` WHERE 1=1 {where_extra}) o"
|
||
if fallback_code_field:
|
||
join_sql = (
|
||
f"{_unique_product_join('p_primary', 'o.primary_code', '成品')} "
|
||
f"{_unique_product_join('p_fallback', 'o.fallback_code', '成品')}"
|
||
)
|
||
type_expr = "COALESCE(p_primary.product_type, p_fallback.product_type, '')"
|
||
else:
|
||
join_sql = _unique_product_join('p', 'o.primary_code', '成品')
|
||
type_expr = "COALESCE(p.product_type, '')"
|
||
rows = query(
|
||
f"SELECT DISTINCT {type_expr} AS product_type FROM {filtered_source} {join_sql} "
|
||
f"ORDER BY product_type",
|
||
params or None
|
||
)
|
||
values = [str(row.get('product_type') or '') for row in rows]
|
||
result = [value for value in values if value]
|
||
if len(result) != len(values):
|
||
result.append('__EMPTY__')
|
||
return result
|
||
|
||
|
||
def _packaging_order_source():
|
||
"""Return packaging orders enriched with product type and finished supplier full name."""
|
||
material_product_join = _unique_product_join(
|
||
'material_product', "order_rows.`编码`", '包材'
|
||
)
|
||
finished_product_join = _unique_product_join(
|
||
'finished_product', "order_rows.`来源产品编码`", '成品'
|
||
)
|
||
return f"""(SELECT order_rows.*,
|
||
COALESCE(material_product.product_type, finished_product.product_type, '') AS `货品类型`,
|
||
COALESCE(NULLIF(finished_supplier.supplier_name, ''),
|
||
(SELECT NULLIF(alias_supplier.supplier_name, '')
|
||
FROM suppliers alias_supplier
|
||
WHERE alias_supplier.supplier_name=finished_product.supplier_name_match
|
||
OR alias_supplier.short_name=finished_product.supplier_name_match
|
||
OR alias_supplier.contract_short_name=finished_product.supplier_name_match
|
||
LIMIT 1),
|
||
NULLIF(finished_product.supplier_name_match, ''), '') AS `成品供应商`
|
||
FROM packaging_orders order_rows
|
||
{material_product_join}
|
||
{finished_product_join}
|
||
LEFT JOIN suppliers finished_supplier
|
||
ON finished_supplier.supplier_code = finished_product.supplier_code) packaging_orders"""
|
||
|
||
|
||
def _set_packaging_finished_supplier(order_id, supplier_value):
|
||
"""Update the supplier binding of the finished product linked by a packaging order."""
|
||
order_rows = query("SELECT `来源产品编码` FROM packaging_orders WHERE id=%s", (order_id,))
|
||
if not order_rows:
|
||
raise ValueError('未找到包材订单')
|
||
product_code = str(order_rows[0].get('来源产品编码') or '').strip()
|
||
if not product_code:
|
||
raise ValueError('该包材订单未关联成品，无法修改成品供应商')
|
||
|
||
supplier_value = str(supplier_value or '').strip()
|
||
if not supplier_value:
|
||
query("UPDATE products SET supplier_code=NULL, supplier_name_match=NULL WHERE product_code=%s",
|
||
(product_code,))
|
||
return product_code, ''
|
||
|
||
suppliers = query("""SELECT supplier_code, supplier_name
|
||
FROM suppliers
|
||
WHERE supplier_name=%s OR short_name=%s
|
||
OR contract_short_name=%s OR supplier_code=%s
|
||
ORDER BY CASE WHEN supplier_name=%s THEN 0 ELSE 1 END
|
||
LIMIT 1""",
|
||
(supplier_value, supplier_value, supplier_value, supplier_value, supplier_value))
|
||
if not suppliers:
|
||
raise ValueError('未匹配到供应商，请从模糊查询下拉列表中选择')
|
||
supplier = suppliers[0]
|
||
query("""UPDATE products SET supplier_code=%s, supplier_name_match=%s
|
||
WHERE product_code=%s""",
|
||
(supplier.get('supplier_code'), supplier.get('supplier_name'), product_code))
|
||
return product_code, supplier.get('supplier_name') or ''
|
||
|
||
def _enrich_order_product_types(rows, code_field, fallback_code_field=None):
|
||
"""按订单货品编号批量补充产品信息中的货品类型。"""
|
||
codes = list({str(row.get(field) or '').strip() for row in rows for field in
|
||
([fallback_code_field, code_field] if fallback_code_field else [code_field])
|
||
if field and str(row.get(field) or '').strip()})
|
||
if not codes:
|
||
return rows
|
||
placeholders = ','.join(['%s'] * len(codes))
|
||
product_rows = query(
|
||
f"SELECT product_code, product_type FROM products WHERE product_code IN ({placeholders})",
|
||
codes
|
||
)
|
||
type_by_code = {str(row.get('product_code') or '').strip(): row.get('product_type') or ''
|
||
for row in product_rows}
|
||
for row in rows:
|
||
if str(row.get('货品类型') or '').strip():
|
||
continue
|
||
code = str(row.get(code_field) or '').strip()
|
||
fallback_code = str(row.get(fallback_code_field) or '').strip() if fallback_code_field else ''
|
||
row['货品类型'] = type_by_code.get(code) or type_by_code.get(fallback_code, '')
|
||
return rows
|
||
|
||
|
||
def _resolve_order_unit_price(domestic_price, overseas_price):
|
||
"""下单备份单价：优先国内订单单价，其次海外订单单价；取不到返回 None。"""
|
||
for value in (domestic_price, overseas_price):
|
||
if value is None or str(value).strip() == '':
|
||
continue
|
||
try:
|
||
return float(value)
|
||
except (TypeError, ValueError):
|
||
continue
|
||
return None
|
||
|
||
|
||
@purchase_bp.route('/api/purchase/pending_list')
|
||
@login_required
|
||
def purchase_pending_list():
|
||
denied = _require_purchase_operation('purchase', 'view')
|
||
if denied:
|
||
return denied
|
||
"""获取待下单/已下单商品列表"""
|
||
status_filter = request.args.get('status', 'pending')
|
||
if status_filter == 'backup':
|
||
status_sql = "status IN ('ordered', 'rolled_back')"
|
||
status_params = ()
|
||
else:
|
||
status_sql = "status = %s"
|
||
status_params = (status_filter,)
|
||
bom_select = "bom_items" if status_filter != 'backup' else "NULL AS bom_items"
|
||
# 下单备份的单价按下单时点匹配生成的国内/海外订单；两表货品编号列排序规则不同，需显式指定。
|
||
price_select = ""
|
||
if status_filter == 'backup':
|
||
price_select = """,
|
||
(SELECT d.`单价` FROM domestic_orders d
|
||
WHERE d.`货品编号` = pending_orders.product_code COLLATE utf8mb4_unicode_ci
|
||
AND d.`计划下单时间` = pending_orders.ordered_at
|
||
ORDER BY d.id LIMIT 1) AS price_domestic,
|
||
(SELECT o.`单价` FROM overseas_orders o
|
||
WHERE o.`产品编码` = pending_orders.product_code COLLATE utf8mb4_unicode_ci
|
||
AND o.`计划下单时间` = pending_orders.ordered_at
|
||
ORDER BY o.id LIMIT 1) AS price_overseas"""
|
||
rows = query(f"""
|
||
SELECT id, product_code, product_name, product_type, product_grade,
|
||
supplier_name, lead_time, logistics_time, total_support_days,
|
||
procurement_follower, procurement_planner, platform, operator, created_by,
|
||
audit_price, formal_order_qty, suggested_qty, actual_order_qty, {bom_select},
|
||
production_order_no,
|
||
product_orderer, packaging_orderer,
|
||
status, created_at, updated_at, ordered_at, remark{price_select}
|
||
FROM pending_orders
|
||
WHERE {status_sql}
|
||
ORDER BY COALESCE(ordered_at, created_at) DESC, created_at DESC, id DESC
|
||
""", status_params)
|
||
if status_filter == 'backup':
|
||
# 备份列表不需要库存、销量、预测及 BOM 富化；详情打开时再按单条记录加载。
|
||
for r in rows:
|
||
r['suggested_qty'] = int(r.get('suggested_qty') or 0)
|
||
r['actual_order_qty'] = int(r.get('actual_order_qty') or 0)
|
||
r['product_orderer'] = r.get('product_orderer') or ''
|
||
r['packaging_orderer'] = r.get('packaging_orderer') or ''
|
||
r['单价'] = _resolve_order_unit_price(r.pop('price_domestic', None), r.pop('price_overseas', None))
|
||
for key in ['created_at', 'updated_at', 'ordered_at']:
|
||
value = r.get(key)
|
||
if value and hasattr(value, 'strftime'):
|
||
r[key] = value.strftime('%Y-%m-%d %H:%M:%S')
|
||
elif value and not isinstance(value, str):
|
||
r[key] = str(value)
|
||
return jsonify({"code": 0, "data": rows})
|
||
|
||
# 补充待下单专用的库存/销量衍生字段，和计划预测使用同一批缓存数据及预测配置。
|
||
sales_map = compute_product_sales_cached()
|
||
inventory_map = compute_product_inventory_cached()
|
||
factory_inventory_map = compute_product_inventory_15()
|
||
forecast_config = {r.get('trend_type'): r for r in sales_predict_config_cached()}
|
||
global_config = get_global_config()
|
||
|
||
# 格式化日期时间字段为字符串
|
||
for r in rows:
|
||
pc = r.get('product_code', '')
|
||
sales_row = sales_map.get(pc) or {}
|
||
avg3 = float(sales_row.get('3天平均销量', 0) or 0)
|
||
avg7 = float(sales_row.get('7天平均销量', 0) or 0)
|
||
avg14 = float(sales_row.get('14天平均销量', 0) or 0)
|
||
trend = _determine_trend(avg3, avg7, avg14)
|
||
forecast = float(compute_daily_forecast({
|
||
'3天平均销量': avg3, '7天平均销量': avg7,
|
||
'14天平均销量': avg14,
|
||
'30天最高销量': float(sales_row.get('30天最高销量', 0) or 0),
|
||
'销售趋势': trend
|
||
}, forecast_config) or 0)
|
||
total_inventory = float(inventory_map.get(pc, 0) or 0) + float(factory_inventory_map.get(pc, 0) or 0)
|
||
actual_qty = float(r.get('actual_order_qty') or r.get('formal_order_qty') or 0)
|
||
r['inventory_support_days'] = round(total_inventory / forecast, 1) if forecast > 0 else 999
|
||
r['stocking_support_days'] = round(actual_qty / forecast, 1) if forecast > 0 else 999
|
||
r['avg_3d_sales'] = avg3
|
||
r['avg_7d_sales'] = avg7
|
||
r['avg_14d_sales'] = avg14
|
||
r['sales_trend'] = trend
|
||
if r.get('bom_items'):
|
||
try:
|
||
raw_bom = json.loads(r['bom_items']) if isinstance(r['bom_items'], str) else r['bom_items']
|
||
r['bom_items'] = _normalize_backup_bom(
|
||
raw_bom,
|
||
source_product_code=r['product_code'],
|
||
source_ordered_at=r.get('ordered_at')
|
||
)
|
||
except (TypeError, ValueError):
|
||
r['bom_items'] = []
|
||
else:
|
||
r['bom_items'] = []
|
||
r['suggested_qty'] = int(r.get('suggested_qty') or 0)
|
||
r['actual_order_qty'] = int(r.get('actual_order_qty') or 0)
|
||
# 成品/包材下单人是下单备份独立字段，由对应订单管理修改时同步更新。
|
||
r['product_orderer'] = r.get('product_orderer') or ''
|
||
r['packaging_orderer'] = r.get('packaging_orderer') or ''
|
||
for key in ['created_at', 'updated_at', 'ordered_at']:
|
||
v = r.get(key)
|
||
if v and hasattr(v, 'strftime'):
|
||
r[key] = v.strftime('%Y-%m-%d %H:%M:%S')
|
||
elif v and not isinstance(v, str):
|
||
r[key] = str(v)
|
||
filter_field_rows('purchase_pending', rows, session.get('user_id'), session.get('role'),
|
||
page_view=bool(role_required('purchase')),
|
||
page_edit=operation_required('purchase', 'edit'))
|
||
return jsonify({"code": 0, "data": rows})
|
||
|
||
|
||
@purchase_bp.route('/api/purchase/backup/detail')
|
||
@login_required
|
||
def purchase_backup_detail():
|
||
"""按需获取单条下单备份详情，避免列表加载时逐物料富化全部 BOM。"""
|
||
denied = _require_purchase_operation('purchase_ready', 'view')
|
||
if denied:
|
||
return denied
|
||
backup_id = request.args.get('id', type=int)
|
||
if not backup_id:
|
||
return jsonify({"code": 400, "msg": "缺少备份记录 ID"}), 400
|
||
rows = query("""
|
||
SELECT id, product_code, product_name, product_type, product_grade,
|
||
supplier_name, lead_time, logistics_time, total_support_days,
|
||
procurement_follower, procurement_planner, platform, operator, created_by,
|
||
audit_price, formal_order_qty, suggested_qty, actual_order_qty, bom_items,
|
||
production_order_no, product_orderer, packaging_orderer,
|
||
status, created_at, updated_at, ordered_at, remark,
|
||
sales_snapshot, sales_snapshot_at,
|
||
(SELECT d.`单价` FROM domestic_orders d
|
||
WHERE d.`货品编号` = pending_orders.product_code COLLATE utf8mb4_unicode_ci
|
||
AND d.`计划下单时间` = pending_orders.ordered_at
|
||
ORDER BY d.id LIMIT 1) AS price_domestic,
|
||
(SELECT o.`单价` FROM overseas_orders o
|
||
WHERE o.`产品编码` = pending_orders.product_code COLLATE utf8mb4_unicode_ci
|
||
AND o.`计划下单时间` = pending_orders.ordered_at
|
||
ORDER BY o.id LIMIT 1) AS price_overseas
|
||
FROM pending_orders
|
||
WHERE id=%s AND status IN ('ordered', 'rolled_back')
|
||
LIMIT 1
|
||
""", (backup_id,))
|
||
if not rows:
|
||
return jsonify({"code": 404, "msg": "未找到下单备份"}), 404
|
||
row = rows[0]
|
||
try:
|
||
raw_bom = json.loads(row['bom_items']) if isinstance(row.get('bom_items'), str) else row.get('bom_items')
|
||
row['bom_items'] = _normalize_backup_bom(
|
||
raw_bom or [],
|
||
source_product_code=row.get('product_code'),
|
||
source_ordered_at=row.get('ordered_at')
|
||
)
|
||
except (TypeError, ValueError):
|
||
row['bom_items'] = []
|
||
for key in ['created_at', 'updated_at', 'ordered_at', 'sales_snapshot_at']:
|
||
value = row.get(key)
|
||
if value and hasattr(value, 'strftime'):
|
||
row[key] = value.strftime('%Y-%m-%d %H:%M:%S')
|
||
elif value and not isinstance(value, str):
|
||
row[key] = str(value)
|
||
row['suggested_qty'] = int(row.get('suggested_qty') or 0)
|
||
row['actual_order_qty'] = int(row.get('actual_order_qty') or 0)
|
||
row['单价'] = _resolve_order_unit_price(row.pop('price_domestic', None), row.pop('price_overseas', None))
|
||
# 只读取计划预测点击下单时保存的快照；历史备份禁止使用当前数据回填。
|
||
try:
|
||
raw_snapshot = row.pop('sales_snapshot', None)
|
||
row['sales_info'] = json.loads(raw_snapshot) if raw_snapshot else {}
|
||
if not isinstance(row['sales_info'], dict):
|
||
row['sales_info'] = {}
|
||
except (TypeError, ValueError, json.JSONDecodeError):
|
||
row['sales_info'] = {}
|
||
row['sales_snapshot_missing'] = not bool(row['sales_info'])
|
||
return jsonify({"code": 0, "data": row})
|
||
|
||
|
||
@purchase_bp.route('/api/purchase/pending_export')
|
||
@login_required
|
||
def purchase_pending_export():
|
||
"""导出下单备份历史，支持自选字段及下单时间范围。"""
|
||
denied = _require_purchase_operation('purchase_ready', 'export')
|
||
if denied:
|
||
return denied
|
||
from io import BytesIO
|
||
from flask import send_file
|
||
import openpyxl
|
||
from openpyxl.styles import Font, Alignment, PatternFill
|
||
|
||
field_defs = {
|
||
'product_type': ('产品类型', 'p.product_type', 12),
|
||
'product_code': ('货品编号', 'p.product_code', 24),
|
||
'product_name': ('货品名称', 'p.product_name', 34),
|
||
'ordered_at': ('下单时间', 'p.ordered_at', 20),
|
||
'created_by': ('下单人', 'p.created_by', 12),
|
||
'product_orderer': ('成品下单人', 'p.product_orderer', 16),
|
||
'packaging_orderer': ('包材下单人', 'p.packaging_orderer', 16),
|
||
'production_order_no': ('生产单号', 'p.production_order_no', 22),
|
||
'suggested_qty': ('建议下单数量', 'p.suggested_qty', 14),
|
||
'formal_qty': ('正式下单数量', 'p.formal_order_qty', 14),
|
||
'product_grade': ('产品分级', 'p.product_grade', 12),
|
||
'supplier_name': ('供应商名称', 'p.supplier_name', 28),
|
||
'remark': ('下单备注', 'p.remark', 30),
|
||
'lead_time': ('货期', 'p.lead_time', 10),
|
||
'logistics_time': ('物流', 'p.logistics_time', 10),
|
||
'total_support_days': ('总支撑天数', 'p.total_support_days', 14),
|
||
'procurement_follower': ('采购跟单', 'p.procurement_follower', 16),
|
||
'procurement_planner': ('采购计划', 'p.procurement_planner', 16),
|
||
'platform': ('归属平台', 'p.platform', 14),
|
||
'operator': ('运营专员', 'p.operator', 14),
|
||
'audit_price': ('是否审核价格', 'p.audit_price', 14),
|
||
'created_at': ('加入时间', 'p.created_at', 20),
|
||
}
|
||
selected = [f for f in request.args.get('fields', '').split(',') if f in field_defs]
|
||
if not selected:
|
||
return jsonify({'code': 400, 'msg': '请至少选择一个导出字段'}), 400
|
||
date_from = request.args.get('date_from', '').strip()
|
||
date_to = request.args.get('date_to', '').strip()
|
||
where = ["p.status IN ('ordered', 'rolled_back')"]
|
||
params = []
|
||
if date_from:
|
||
where.append('p.ordered_at >= %s'); params.append(date_from + ' 00:00:00')
|
||
if date_to:
|
||
where.append('p.ordered_at < DATE_ADD(%s, INTERVAL 1 DAY)'); params.append(date_to)
|
||
select_sql = ', '.join(field_defs[f][1] + ' AS `' + f + '`' for f in selected)
|
||
rows = query(f"SELECT {select_sql} FROM pending_orders p WHERE {' AND '.join(where)} ORDER BY p.ordered_at DESC, p.id DESC", params)
|
||
|
||
wb = openpyxl.Workbook()
|
||
ws = wb.active
|
||
ws.title = '下单备份'
|
||
ws.append([field_defs[f][0] for f in selected])
|
||
for cell in ws[1]:
|
||
cell.font = Font(bold=True, color='FFFFFF')
|
||
cell.fill = PatternFill('solid', fgColor='1890FF')
|
||
cell.alignment = Alignment(horizontal='center', vertical='center')
|
||
for row in rows:
|
||
values = []
|
||
for f in selected:
|
||
value = row.get(f, '')
|
||
if value is not None and hasattr(value, 'strftime'):
|
||
value = value.strftime('%Y-%m-%d %H:%M:%S')
|
||
values.append(value if value is not None else '')
|
||
ws.append(values)
|
||
for idx, f in enumerate(selected, 1):
|
||
ws.column_dimensions[openpyxl.utils.get_column_letter(idx)].width = field_defs[f][2]
|
||
ws.freeze_panes = 'A2'
|
||
ws.auto_filter.ref = ws.dimensions
|
||
output = BytesIO()
|
||
wb.save(output)
|
||
output.seek(0)
|
||
return send_file(output, as_attachment=True, download_name='下单备份.xlsx',
|
||
mimetype='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
|
||
|
||
|
||
@purchase_bp.route('/api/purchase/update_formal_qty', methods=['POST'])
|
||
@login_required
|
||
def purchase_update_formal_qty():
|
||
"""仅更新正式下单数量，不创建待下单记录"""
|
||
denied = _require_purchase_operation('purchase', 'edit')
|
||
if denied:
|
||
return denied
|
||
data = request.json
|
||
pc = data.get('product_code', '')
|
||
qty = int(data.get('formal_order_qty', 0))
|
||
if not pc:
|
||
return jsonify({"code": 400, "msg": "缺少货品编号"})
|
||
# 保存到待下单表（标记为草稿，不显示在待下单列表中）
|
||
# 注意：pending_orders 已支持同一商品多次下单（多条 ordered 历史），
|
||
# 这里只能更新当前待下单行（pending/draft），不能触碰历史备份行。
|
||
existing = query("SELECT id FROM pending_orders WHERE product_code=%s AND status IN ('pending','draft')", (pc,))
|
||
if existing:
|
||
query("UPDATE pending_orders SET formal_order_qty=%s, updated_at=NOW() WHERE product_code=%s AND status IN ('pending','draft')",
|
||
(qty, pc))
|
||
else:
|
||
# 查询产品信息补全必填字段
|
||
prod = query("SELECT product_name, product_type FROM products WHERE product_code=%s", (pc,))
|
||
pname = prod[0]['product_name'] if prod else ''
|
||
ptype = prod[0]['product_type'] if prod else ''
|
||
query("""INSERT INTO pending_orders
|
||
(product_code, product_name, product_type, formal_order_qty, status, created_by)
|
||
VALUES (%s, %s, %s, %s, 'draft', %s)""",
|
||
(pc, pname, ptype, qty, session.get('real_name', '') or session.get('username', '')))
|
||
add_operation_log('修改下单数量', f'{pc} → {qty}')
|
||
return jsonify({"code": 0, "msg": "已更新"})
|
||
|
||
|
||
@purchase_bp.route('/api/purchase/check_pending')
|
||
@login_required
|
||
def purchase_check_pending():
|
||
denied = _require_purchase_operation('purchase', 'view')
|
||
if denied:
|
||
return denied
|
||
"""检查单个商品是否已在待下单列表"""
|
||
code = request.args.get('code', '')
|
||
if not code:
|
||
return jsonify({"code": 400, "exists": False})
|
||
existing = query("SELECT id FROM pending_orders WHERE product_code=%s AND status='pending'", (code,))
|
||
return jsonify({"code": 0, "exists": bool(existing)})
|
||
|
||
|
||
@purchase_bp.route('/api/purchase/add_pending', methods=['POST'])
|
||
@login_required
|
||
def purchase_add_pending():
|
||
"""将商品加入待下单列表"""
|
||
denied = _require_purchase_operation('purchase', 'add')
|
||
if denied:
|
||
return denied
|
||
data = request.json
|
||
pc = data.get('product_code', '')
|
||
if not pc:
|
||
return jsonify({"code": 400, "msg": "缺少货品编号"})
|
||
|
||
# 检查是否已存在待下单记录
|
||
# 如果是更新操作（携带更新字段），跳过重复检查
|
||
keys = set(data.keys())
|
||
update_fields = {'formal_order_qty', 'audit_price', 'actual_order_qty', 'suggested_qty', 'remark', 'bom_items'}
|
||
is_update = bool(keys & update_fields)
|
||
|
||
# 先复用当前待下单行，否则复用计划预测保存的草稿；ordered/rolled_back 历史不参与。
|
||
existing_pending = query("""SELECT id, bom_items, new_old_product, sales_snapshot, sales_snapshot_at, status
|
||
FROM pending_orders WHERE product_code=%s AND status IN ('pending','draft')
|
||
ORDER BY CASE status WHEN 'pending' THEN 0 ELSE 1 END, updated_at DESC, id DESC
|
||
LIMIT 1""", (pc,))
|
||
if existing_pending and existing_pending[0].get('status') == 'pending' and not is_update:
|
||
return jsonify({"code": 400, "msg": f"[{pc}] 已在待下单列表中，请勿重复添加"})
|
||
|
||
# 查询该产品的BOM物料清单
|
||
# 如果请求带了bom_items，优先使用
|
||
req_bom_items = data.get('bom_items', '')
|
||
bom_json = None
|
||
bom_items_normalized = []
|
||
if req_bom_items:
|
||
try:
|
||
bom_items_normalized = _normalize_pending_bom_items(
|
||
json.loads(req_bom_items) if isinstance(req_bom_items, str) else req_bom_items
|
||
)
|
||
bom_json = json.dumps(bom_items_normalized, ensure_ascii=False) if bom_items_normalized else None
|
||
except:
|
||
bom_json = None
|
||
|
||
if not bom_json:
|
||
# 更新已有待下单记录的成品字段时，不得用基础BOM覆盖用户已填写的包材实际下单数量。
|
||
# 只有新增记录才从 bom 表初始化；明确提交的 bom_items 已在上方优先处理。
|
||
if existing_pending and existing_pending[0].get('bom_items'):
|
||
bom_json = existing_pending[0]['bom_items']
|
||
else:
|
||
bom_items = query("""
|
||
SELECT material_code, material_name, quantity
|
||
FROM bom WHERE product_code=%s ORDER BY material_code
|
||
""", (pc,))
|
||
if bom_items:
|
||
bom_items_res = [{'material_code': r['material_code'], 'material_name': r['material_name'], 'quantity': float(r['quantity'])} for r in bom_items]
|
||
if bom_items_res:
|
||
bom_json = json.dumps(bom_items_res, ensure_ascii=False)
|
||
|
||
# 从请求数据取值，空字段从 products 表补全
|
||
pn = data.get('product_name', '')
|
||
pt = data.get('product_type', '')
|
||
pg = data.get('product_grade', '')
|
||
sn = data.get('supplier_name', '')
|
||
lt = data.get('lead_time', 0)
|
||
lo = data.get('logistics_time', 0)
|
||
ts = data.get('total_support_days', 0)
|
||
pf = data.get('procurement_follower', '')
|
||
pp = data.get('procurement_planner', '')
|
||
pl = data.get('platform', '')
|
||
op = data.get('operator', '')
|
||
if not pn or not pt:
|
||
prod = query("SELECT product_name, product_type, supplier_name_match, lead_time, logistics_time, procurement_follower, procurement_planner, platform, operator FROM products WHERE product_code=%s", (pc,))
|
||
if prod:
|
||
p = prod[0]
|
||
if not pn: pn = p['product_name'] or ''
|
||
if not pt: pt = p['product_type'] or ''
|
||
if not sn: sn = p['supplier_name_match'] or ''
|
||
if not lt: lt = int(p['lead_time'] or 0)
|
||
if not lo: lo = int(p['logistics_time'] or 0)
|
||
if not pf: pf = p['procurement_follower'] or ''
|
||
if not pp: pp = p['procurement_planner'] or ''
|
||
if not pl: pl = p['platform'] or ''
|
||
if not op: op = p['operator'] or ''
|
||
|
||
formal_qty = int(data.get('formal_order_qty', 0))
|
||
suggested_qty = int(data.get('suggested_qty', 0))
|
||
actual_order_qty = int(data.get('actual_order_qty', 0))
|
||
|
||
created_by = session.get('real_name', '') or session.get('username', '')
|
||
|
||
remark_val = data.get('remark', '')
|
||
audit_price = float(data.get('audit_price', 0))
|
||
from services.planning_order_flag import snapshot_new_old
|
||
new_old_product = snapshot_new_old(pc, existing_pending[0].get('new_old_product') if existing_pending else None)
|
||
existing_sales_snapshot = existing_pending[0].get('sales_snapshot') if existing_pending else None
|
||
if existing_sales_snapshot:
|
||
sales_snapshot_json = existing_sales_snapshot
|
||
sales_snapshot_at = existing_pending[0].get('sales_snapshot_at') or datetime.now()
|
||
else:
|
||
try:
|
||
sales_snapshot = _build_planning_sales_snapshot(pc, pn, pt)
|
||
except Exception as exc:
|
||
return jsonify({"code": 500, "msg": f"销量信息快照保存失败：{exc}"})
|
||
sales_snapshot_json = json.dumps(sales_snapshot, ensure_ascii=False, default=str)
|
||
sales_snapshot_at = datetime.now()
|
||
# 已存在待下单行时按 id 更新，避免依赖 product_code 唯一索引；
|
||
# 不存在时才插入新行（同一商品可保留多条 ordered/rolled_back 历史）。
|
||
if existing_pending:
|
||
query("""
|
||
UPDATE pending_orders SET
|
||
product_name=%s, product_type=%s, product_grade=%s, supplier_name=%s,
|
||
lead_time=%s, logistics_time=%s, total_support_days=%s,
|
||
procurement_follower=%s, procurement_planner=%s, platform=%s, operator=%s, created_by=%s,
|
||
audit_price=%s, formal_order_qty=%s, suggested_qty=%s, actual_order_qty=%s, bom_items=%s, remark=%s,
|
||
new_old_product=%s, sales_snapshot=%s, sales_snapshot_at=%s,
|
||
status='pending', updated_at=NOW()
|
||
WHERE id=%s
|
||
""", (
|
||
pn, pt, pg, sn,
|
||
int(lt), int(lo), float(ts),
|
||
pf, pp, pl, op, created_by,
|
||
audit_price, formal_qty, suggested_qty, actual_order_qty, bom_json, remark_val,
|
||
new_old_product, sales_snapshot_json, sales_snapshot_at,
|
||
existing_pending[0]['id']
|
||
))
|
||
else:
|
||
query("""
|
||
INSERT INTO pending_orders
|
||
(product_code, product_name, product_type, product_grade, supplier_name,
|
||
lead_time, logistics_time, total_support_days,
|
||
procurement_follower, procurement_planner, platform, operator, created_by,
|
||
audit_price, formal_order_qty, suggested_qty, actual_order_qty, bom_items, remark,
|
||
new_old_product, sales_snapshot, sales_snapshot_at)
|
||
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
|
||
""", (
|
||
pc,
|
||
pn, pt, pg, sn,
|
||
int(lt), int(lo), float(ts),
|
||
pf, pp, pl, op,
|
||
created_by,
|
||
audit_price, formal_qty, suggested_qty, actual_order_qty, bom_json, remark_val,
|
||
new_old_product, sales_snapshot_json, sales_snapshot_at
|
||
))
|
||
if req_bom_items and bom_items_normalized:
|
||
_sync_pending_pre_packaging(pc, bom_items_normalized)
|
||
return jsonify({"code": 0, "msg": "已加入待下单列表"})
|
||
|
||
|
||
@purchase_bp.route('/api/purchase/update_pending', methods=['POST'])
|
||
@login_required
|
||
def purchase_update_pending():
|
||
"""保存计划预测下单信息或更新待下单记录；未下单的内容保存在隐藏草稿中。"""
|
||
if not (operation_required('purchase', 'edit') or operation_required('planning', 'edit')):
|
||
return jsonify({"code": 403, "msg": "权限不足，当前账号没有编辑下单信息权限"})
|
||
data = request.get_json(silent=True) or {}
|
||
product_code = data.get('product_code', '')
|
||
if not product_code:
|
||
return jsonify({"code": 400, "msg": "参数错误"})
|
||
|
||
current_rows = query(
|
||
"SELECT id, remark, bom_items, formal_order_qty, status FROM pending_orders "
|
||
"WHERE product_code=%s AND status IN ('pending','draft') "
|
||
"ORDER BY CASE status WHEN 'pending' THEN 0 ELSE 1 END, updated_at DESC, id DESC LIMIT 1",
|
||
(product_code,)
|
||
)
|
||
current = current_rows[0] if current_rows else {}
|
||
if not current:
|
||
product_rows = query("SELECT product_name, product_type FROM products WHERE product_code=%s AND deleted_at IS NULL LIMIT 1",
|
||
(product_code,))
|
||
if not product_rows:
|
||
return jsonify({"code": 404, "msg": "未找到该产品，无法保存下单草稿"})
|
||
requested_bom = data.get('bom_items')
|
||
normalized_for_insert = _normalize_pending_bom_items(requested_bom) if requested_bom is not None else []
|
||
product_actual_qty = _extract_product_actual_qty(normalized_for_insert, product_code)
|
||
if product_actual_qty is None:
|
||
try:
|
||
product_actual_qty = int(data.get('formal_order_qty') or 0)
|
||
except (TypeError, ValueError):
|
||
product_actual_qty = 0
|
||
bom_json = json.dumps(normalized_for_insert, ensure_ascii=False) if requested_bom is not None else None
|
||
draft_id = query("""INSERT INTO pending_orders
|
||
(product_code, product_name, product_type, formal_order_qty, status, created_by, bom_items, remark)
|
||
VALUES (%s, %s, %s, %s, 'draft', %s, %s, %s)""",
|
||
(product_code, product_rows[0].get('product_name') or '',
|
||
product_rows[0].get('product_type') or '', product_actual_qty,
|
||
session.get('real_name', '') or session.get('username', ''), bom_json,
|
||
data.get('remark') or ''))
|
||
current = {'id': draft_id, 'remark': '', 'bom_items': None,
|
||
'formal_order_qty': 0, 'status': 'draft'}
|
||
changes = []
|
||
|
||
# 支持更新的字段
|
||
remark = data.get('remark')
|
||
if remark is not None:
|
||
old_remark = current.get('remark') or ''
|
||
if old_remark != remark:
|
||
changes.append(f'备注：{old_remark or "（空）"} → {remark or "（空）"}')
|
||
query("UPDATE pending_orders SET remark=%s, updated_at=NOW() WHERE id=%s", (remark, current['id']))
|
||
|
||
bom_items = data.get('bom_items')
|
||
if bom_items is not None:
|
||
normalized_bom_items = _normalize_pending_bom_items(bom_items)
|
||
product_actual_qty = _extract_product_actual_qty(normalized_bom_items, product_code)
|
||
bom_str = json.dumps(normalized_bom_items, ensure_ascii=False)
|
||
try:
|
||
old_bom_items = json.loads(current.get('bom_items') or '[]')
|
||
except (TypeError, ValueError):
|
||
old_bom_items = []
|
||
|
||
old_by_code = {
|
||
item.get('material_code', ''): item
|
||
for item in old_bom_items if isinstance(item, dict)
|
||
}
|
||
new_by_code = {
|
||
item.get('material_code', ''): item
|
||
for item in bom_items if isinstance(item, dict)
|
||
}
|
||
|
||
def _format_bom_item(item):
|
||
code = item.get('material_code') or '未填写编码物料'
|
||
name = (item.get('material_name') or '').strip()
|
||
desc = code if not name else f'{code} {name}'
|
||
sub = []
|
||
aq = item.get('actual_quantity')
|
||
if aq not in (None, ''):
|
||
sub.append(f'实际下单数量 {aq}')
|
||
for key, label in (('pre_pack_qty', '前包数量'), ('post_pack_qty', '后包数量')):
|
||
v = item.get(key)
|
||
if v not in (None, '', 0):
|
||
sub.append(f'{label} {v}')
|
||
rk = (item.get('remark') or '').strip()
|
||
if rk:
|
||
sub.append('备注 ' + (rk if len(rk) <= 40 else rk[:40] + '…'))
|
||
if sub:
|
||
desc += '（' + '；'.join(sub) + '）'
|
||
return desc
|
||
|
||
if not old_by_code and new_by_code:
|
||
bom_parts = [_format_bom_item(item) for item in sorted(new_by_code.values(), key=lambda x: x.get('material_code') or '')]
|
||
changes.append(f'保存BOM明细：{len(new_by_code)}项（' + '；'.join(bom_parts) + '）')
|
||
bom_field_labels = {
|
||
'actual_quantity': '实际下单数量',
|
||
'remark': '备注',
|
||
'pkg_remark': '包材备注',
|
||
'change_manuscript': '改稿说明',
|
||
'pre_pack_qty': '前包数量',
|
||
'post_pack_qty': '后包数量',
|
||
}
|
||
for material_code in sorted(set(old_by_code) | set(new_by_code)):
|
||
old_item = old_by_code.get(material_code)
|
||
new_item = new_by_code.get(material_code)
|
||
display_code = material_code or '未填写编码物料'
|
||
if old_item is None:
|
||
if old_by_code:
|
||
changes.append(f'BOM新增：{_format_bom_item(new_item)}')
|
||
continue
|
||
if new_item is None:
|
||
changes.append(f'BOM移除：{display_code}')
|
||
continue
|
||
for field, label in bom_field_labels.items():
|
||
old_value = old_item.get(field, '')
|
||
new_value = new_item.get(field, '')
|
||
if old_value != new_value:
|
||
old_display = old_value if old_value not in (None, '') else '（空）'
|
||
new_display = new_value if new_value not in (None, '') else '（空）'
|
||
changes.append(
|
||
f'{display_code} {label}：{old_display} → {new_display}'
|
||
)
|
||
if product_actual_qty is None:
|
||
query("UPDATE pending_orders SET bom_items=%s, updated_at=NOW() WHERE id=%s", (bom_str, current['id']))
|
||
else:
|
||
old_formal_qty = int((current.get('formal_order_qty') or 0))
|
||
if old_formal_qty != product_actual_qty:
|
||
changes.append(f'成品实际下单数量：{old_formal_qty} → {product_actual_qty}')
|
||
query("UPDATE pending_orders SET formal_order_qty=%s, bom_items=%s, updated_at=NOW() WHERE id=%s",
|
||
(product_actual_qty, bom_str, current['id']))
|
||
# 待下单详情中的“下单前包材”与计划预测共用 bom_packaging 真源，保存时同步更新。
|
||
_sync_pending_pre_packaging(product_code, normalized_bom_items)
|
||
|
||
detail = f'更新 {product_code}'
|
||
if changes:
|
||
detail += '；' + '；'.join(changes)
|
||
else:
|
||
detail += '；提交内容无变化'
|
||
add_operation_log('待下单编辑', detail)
|
||
return jsonify({"code": 0, "msg": "更新成功"})
|
||
|
||
|
||
@purchase_bp.route('/api/purchase/remove_pending', methods=['POST'])
|
||
@login_required
|
||
def purchase_remove_pending():
|
||
"""从待下单列表中移除"""
|
||
data = request.json
|
||
product_codes = data.get('product_codes', [])
|
||
if not product_codes:
|
||
return jsonify({"code": 400, "msg": "缺少参数"})
|
||
# 待下单和下单备份使用不同的删除权限，避免一个权限误覆盖另一类数据。
|
||
has_ordered = query(
|
||
"SELECT id FROM pending_orders WHERE product_code IN (" + ','.join(['%s'] * len(product_codes)) + ") AND status='ordered' LIMIT 1",
|
||
product_codes
|
||
)
|
||
operation = 'delete' if has_ordered else 'delete'
|
||
page = 'purchase_ready' if has_ordered else 'purchase'
|
||
denied = _require_purchase_operation(page, operation)
|
||
if denied:
|
||
return denied
|
||
placeholders = ','.join(['%s'] * len(product_codes))
|
||
query(f"DELETE FROM pending_orders WHERE product_code IN ({placeholders}) AND status='pending'", product_codes)
|
||
for pc in product_codes:
|
||
add_operation_log('移出待下单', f'从待下单列表移除 {pc}')
|
||
return jsonify({"code": 0, "msg": "已移除"})
|
||
|
||
|
||
@purchase_bp.route('/api/purchase/confirm_order', methods=['POST'])
|
||
@login_required
|
||
def purchase_confirm_order():
|
||
"""确认下单：备份到下单管理，按产品品牌在品牌信息管理中的分类分流到国内/海外订单。"""
|
||
denied = _require_purchase_operation('purchase', 'batch_confirm')
|
||
if denied:
|
||
return denied
|
||
data = request.json
|
||
product_codes = data.get('product_codes', [])
|
||
bom_data_map = data.get('bom_data_map', {}) # 前端传入的BOM修改数据（若存在则优先使用）
|
||
if not product_codes:
|
||
return jsonify({"code": 400, "msg": "缺少参数"})
|
||
|
||
# 确认前统一按产品品牌匹配品牌信息管理分类；未分类时阻止确认，避免订单流向错误。
|
||
brand_routes = {}
|
||
product_names = {}
|
||
unresolved_brands = []
|
||
for pc in product_codes:
|
||
pending_rows = query(
|
||
"SELECT product_code, product_name, product_type FROM pending_orders "
|
||
"WHERE product_code=%s AND status='pending'",
|
||
(pc,),
|
||
)
|
||
if not pending_rows:
|
||
continue
|
||
pending = pending_rows[0]
|
||
product_rows = []
|
||
if pending.get('product_type'):
|
||
product_rows = query(
|
||
"SELECT brand, product_name FROM products WHERE product_code=%s "
|
||
"AND product_type=%s AND deleted_at IS NULL LIMIT 1",
|
||
(pc, pending['product_type']),
|
||
)
|
||
if not product_rows and pending.get('product_name'):
|
||
product_rows = query(
|
||
"SELECT brand, product_name FROM products WHERE product_code=%s "
|
||
"AND product_name=%s AND deleted_at IS NULL LIMIT 1",
|
||
(pc, pending['product_name']),
|
||
)
|
||
if not product_rows:
|
||
product_rows = query(
|
||
"SELECT brand, product_name FROM products WHERE product_code=%s "
|
||
"AND deleted_at IS NULL ORDER BY CASE WHEN TRIM(COALESCE(brand,''))='' THEN 1 ELSE 0 END, id LIMIT 1",
|
||
(pc,),
|
||
)
|
||
brand = (product_rows[0].get('brand') or '').strip() if product_rows else ''
|
||
product_names[pc] = (product_rows[0].get('product_name') or '') if product_rows else ''
|
||
brand_info = query("SELECT category FROM brand_information WHERE CONVERT(brand USING utf8mb4) COLLATE utf8mb4_unicode_ci = CONVERT(%s USING utf8mb4) COLLATE utf8mb4_unicode_ci LIMIT 1", (brand,)) if brand else []
|
||
category = (brand_info[0].get('category') or '').strip() if brand_info else ''
|
||
if category not in ('国内', '海外'):
|
||
unresolved_brands.append(brand or f'货品编号：{pc}')
|
||
else:
|
||
brand_routes[pc] = category
|
||
if unresolved_brands:
|
||
names = '、'.join(dict.fromkeys(unresolved_brands))
|
||
return jsonify({"code": 400, "msg": f"以下品牌未在品牌信息管理中完成国内/海外分类，暂不能确认下单：{names}"})
|
||
|
||
now = datetime.now()
|
||
now_str = now.strftime('%Y-%m-%d %H:%M:%S')
|
||
today = now.strftime('%Y-%m-%d')
|
||
|
||
has_product_order = False
|
||
has_packaging_order = False
|
||
notify_groups = {} # webhook -> {'group_name':..., 'lines':[...]} 备货通知按群聚合
|
||
|
||
for pc in product_codes:
|
||
# 1. 查询待下单记录
|
||
rows = query("SELECT * FROM pending_orders WHERE product_code=%s AND status='pending'", (pc,))
|
||
if not rows:
|
||
continue
|
||
row = rows[0]
|
||
request_bom = bom_data_map.get(pc)
|
||
request_product_actual_qty = _extract_product_actual_qty(request_bom, pc)
|
||
if request_product_actual_qty is not None:
|
||
# 用户在下单信息弹窗中明确填写的成品实际下单数量优先于旧快照。
|
||
# 这一步必须发生在生成国内/海外订单之前，否则订单和下单备份会沿用旧数量。
|
||
row['formal_order_qty'] = request_product_actual_qty
|
||
query("UPDATE pending_orders SET formal_order_qty=%s WHERE id=%s AND status='pending'", (request_product_actual_qty, row['id']))
|
||
|
||
# 1.5 原子抢占：先标记为已下单，防止重复点击/并发请求重复生成订单。
|
||
# 只有抢占成功（status 从 pending 变为 ordered）的请求才会继续插入订单，
|
||
# 后续重复请求因 status 已非 pending 而跳过。
|
||
# 按 id 抢占，确保命中当前待下单行（同商品可能已有历史 ordered 备份行）。
|
||
affected = execute(
|
||
"UPDATE pending_orders SET ordered_at=%s, status='ordered' WHERE id=%s AND status='pending'",
|
||
(now_str, row['id'])
|
||
)
|
||
if affected == 0:
|
||
# 已被其他请求确认，跳过该商品，避免生成重复订单
|
||
continue
|
||
|
||
# 2. 按产品品牌匹配品牌信息管理分类：国内→国内订单，海外→海外订单。
|
||
is_overseas = (brand_routes.get(pc) == '海外')
|
||
# 内料是否随包材订单同步到包材订单管理：需同时满足海外品牌 + 货品名称含
|
||
# 新西兰/新加坡/韩国（与计划预测下单信息弹窗的显示规则一致）；
|
||
# is_overseas 仍按品牌分类决定订单流向，不受此规则影响。
|
||
_inner_name = product_names.get(pc) or (row.get('product_name') or '')
|
||
allow_inner_material = is_overseas and any(
|
||
_key in _inner_name for _key in INNER_MATERIAL_NAME_KEYS
|
||
)
|
||
|
||
# 3. 计算金额
|
||
qty = row.get('formal_order_qty') or 0
|
||
price = float(row.get('audit_price') or 0)
|
||
amount = qty * price
|
||
|
||
# 成品数量>0时才创建国内/海外订单
|
||
if qty > 0:
|
||
has_product_order = True
|
||
|
||
if is_overseas and qty > 0:
|
||
from services.planning_order_flag import snapshot_new_old
|
||
new_old_product = snapshot_new_old(pc, row.get('new_old_product'))
|
||
query('UPDATE pending_orders SET new_old_product=%s WHERE id=%s', (new_old_product, row['id']))
|
||
# 写入海外订单表（含全部字段，日期留空由用户自行填写）
|
||
query("""INSERT INTO overseas_orders
|
||
(日期,计划下单时间,产品编码,状态,product_type,product_grade,lead_time,logistics_time,total_support_days,procurement_planner,platform,operator,单价,audit_price,是否审核价格,suggested_qty,actual_order_qty,数量,金额,供应商,货品名称,采购员,product_name,下单备注,旺店通生产单号,新旧品)
|
||
VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)
|
||
""", (
|
||
None, now_str,
|
||
row.get('product_code'), '未完结',
|
||
row.get('product_type', ''),
|
||
row.get('product_grade', ''),
|
||
row.get('lead_time', 0),
|
||
row.get('logistics_time', 0),
|
||
row.get('total_support_days', 0),
|
||
row.get('procurement_planner', ''),
|
||
row.get('platform', ''),
|
||
row.get('operator', ''),
|
||
price,
|
||
price,
|
||
'未审核',
|
||
row.get('suggested_qty', 0),
|
||
row.get('actual_order_qty', 0),
|
||
qty,
|
||
amount,
|
||
row.get('supplier_name'),
|
||
row.get('product_name'),
|
||
row.get('procurement_follower'),
|
||
row.get('product_name', ''),
|
||
row.get('remark', ''),
|
||
row.get('production_order_no', ''),
|
||
new_old_product
|
||
))
|
||
elif not is_overseas and qty > 0:
|
||
previous_order = _latest_domestic_order_values(row.get('product_code'))
|
||
if previous_order.get('单价') is not None:
|
||
price = float(previous_order['单价'])
|
||
amount = qty * price
|
||
warehouse = previous_order.get('仓库')
|
||
|
||
# 写入国内订单表（含全部字段，日期留空由用户自行填写）
|
||
query("""INSERT INTO domestic_orders
|
||
(日期,计划下单时间,货品编号,货品名称,状态,product_type,product_grade,lead_time,logistics_time,total_support_days,procurement_planner,platform,operator,单价,audit_price,是否审核价格,suggested_qty,actual_order_qty,数量,金额,仓库,供货商,采购员,下单备注,旺店通生产单号,未到货数,金蝶入库)
|
||
VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)
|
||
""", (
|
||
None, now_str,
|
||
row.get('product_code'),
|
||
row.get('product_name'), '未完结',
|
||
row.get('product_type', ''),
|
||
row.get('product_grade', ''),
|
||
row.get('lead_time', 0),
|
||
row.get('logistics_time', 0),
|
||
row.get('total_support_days', 0),
|
||
row.get('procurement_planner', ''),
|
||
row.get('platform', ''),
|
||
row.get('operator', ''),
|
||
price,
|
||
price,
|
||
'未审核',
|
||
row.get('suggested_qty', 0),
|
||
row.get('actual_order_qty', 0),
|
||
qty,
|
||
amount,
|
||
warehouse,
|
||
row.get('supplier_name'),
|
||
row.get('procurement_follower'),
|
||
row.get('remark', ''),
|
||
row.get('production_order_no', ''),
|
||
qty,
|
||
'否'
|
||
))
|
||
|
||
# 4. 根据物料清单生成包材下单（写入包材订单表）
|
||
import logging
|
||
# 优先使用前端传入的BOM数据（用户在BOM弹窗中编辑过实际下单数量），合并数据库中完整BOM
|
||
import json
|
||
bom_raw = row.get('bom_items')
|
||
# 先从数据库加载完整BOM清单
|
||
if bom_raw:
|
||
try:
|
||
db_bom_list = json.loads(bom_raw) if isinstance(bom_raw, str) else bom_raw
|
||
except:
|
||
db_bom_list = []
|
||
else:
|
||
db_bom_list = []
|
||
|
||
# 当前确认下单请求携带的 bom_data_map 是本次弹窗的最新数据源；
|
||
# 未携带时使用待下单记录中已保存的 BOM，确保刷新页面后确认下单仍能带上包材数量和备注。
|
||
bom_list = _select_confirm_bom(request_bom, db_bom_list, [])
|
||
if not bom_list:
|
||
# 待下单记录尚未保存 BOM 时，才回退到当前产品 BOM 基础清单。
|
||
bom_rows = query(
|
||
"SELECT material_code, material_name, quantity FROM bom WHERE product_code=%s ORDER BY id",
|
||
(pc,)
|
||
)
|
||
bom_list = _select_confirm_bom(request_bom, db_bom_list, [dict(r) for r in bom_rows])
|
||
|
||
bom_list = _normalize_backup_bom(bom_list)
|
||
# 成品实际下单数量优先取下单信息弹窗中的“成品实际下单数量”，
|
||
# 未填写时才回退到待下单记录的正式下单数量。
|
||
product_actual_qty = _extract_product_actual_qty(bom_list, pc)
|
||
if product_actual_qty is None:
|
||
product_actual_qty = int(qty or 0)
|
||
logging.warning(f'[SYNC_PACKAGING] pc={pc}, formal_qty={qty}, product_actual_qty={product_actual_qty}, bom_list_len={len(bom_list)}')
|
||
|
||
# BOM用量以 bom 表为权威来源：前端 bom_items 里的 quantity 可能被「实际下单数量」污染，
|
||
# 一旦参与「下单后包材 = 下单前 + 包材下单数 - 成品下单数×用量」就会算出天量负数。
|
||
bom_qty_map = {}
|
||
for _br in query("SELECT material_code, quantity FROM bom WHERE product_code=%s", (pc,)):
|
||
try:
|
||
bom_qty_map[str(_br.get('material_code') or '').strip()] = float(_br.get('quantity') or 0)
|
||
except (TypeError, ValueError):
|
||
continue
|
||
|
||
pack_items = [] # 本次下单包材明细 [(名称, 数量, 下单备注)]，备货通知按包材分别展示
|
||
for bm in bom_list:
|
||
mat_code = bm.get('material_code', '')
|
||
mat_name = bm.get('material_name', '')
|
||
# 成品汇总项只用于读取成品实际下单数量，不参与包材结余计算或包材下单。
|
||
if not mat_code or mat_code.startswith('成品_'):
|
||
continue
|
||
# 内料默认不参与包材下单（名称含「内料」或编码含 -NL，双条件过滤）；
|
||
# 海外品牌商品的内料需要显示并同步到包材订单管理，因此不跳过。
|
||
is_inner_material = ('内料' in (mat_name or '')) or ('-NL' in (mat_code or ''))
|
||
if is_inner_material and not allow_inner_material:
|
||
continue
|
||
# 明确保存过的实际下单数量优先，0表示不下单；只有未填写时才按用量×成品数量计算
|
||
actual_qty = bm.get('actual_quantity')
|
||
order_qty = _resolve_confirm_packaging_qty(bm, product_actual_qty)
|
||
# 将本次实际下单数量写回 BOM，确保下单备份详情弹窗能正确展示包材下单数量
|
||
bm['actual_quantity'] = order_qty
|
||
bm['amount'] = round(order_qty * float(bm.get('unit_price') or 0), 2)
|
||
if order_qty > 0:
|
||
pack_items.append((mat_name or mat_code, order_qty, bm.get('remark') or bm.get('pkg_remark', '') or ''))
|
||
print(f'[DEBUG confirm_order] mat={mat_code}, order_qty={order_qty}, act_qty={actual_qty}, formal_qty={qty}', flush=True)
|
||
if mat_code:
|
||
# 包材结余滚动：本次下单前数量取当前记录（首次由表格导入值提供）。
|
||
# 下单后 = 下单前 + 包材实际下单数量 - 成品实际下单数量，
|
||
# 并将本次结余作为下一次下单的下单前数量。
|
||
pack_rows = query(
|
||
"SELECT pre_pack_qty FROM bom_packaging WHERE product_code=%s AND material_code=%s",
|
||
(pc, mat_code)
|
||
)
|
||
pre_pack_qty = int(pack_rows[0].get('pre_pack_qty') or 0) if pack_rows else 0
|
||
bom_qty = _resolve_roll_bom_qty(bm, bom_qty_map)
|
||
post_pack_qty = pre_pack_qty + order_qty - product_actual_qty * bom_qty
|
||
bm['pre_pack_qty'] = pre_pack_qty
|
||
bm['post_pack_qty'] = post_pack_qty
|
||
query("""INSERT INTO bom_packaging
|
||
(product_code, material_code, pre_pack_qty, post_pack_qty)
|
||
VALUES (%s,%s,%s,%s)
|
||
ON DUPLICATE KEY UPDATE pre_pack_qty=%s, post_pack_qty=%s, updated_at=NOW()""",
|
||
(pc, mat_code, post_pack_qty, post_pack_qty, post_pack_qty, post_pack_qty))
|
||
print(f'[PACKAGING_ROLL] pc={pc}, mat={mat_code}, pre={pre_pack_qty}, pack_order={order_qty}, product_order={product_actual_qty}, post={post_pack_qty}', flush=True)
|
||
if mat_code and order_qty > 0:
|
||
has_packaging_order = True
|
||
previous_order = _latest_packaging_order_values(mat_code)
|
||
previous_price = previous_order.get('单价')
|
||
mat_price = float(previous_price if previous_price is not None else (bm.get('unit_price') or 0))
|
||
mat_amount = round(order_qty * mat_price, 2)
|
||
mat_supplier = _packaging_supplier_full_name(
|
||
mat_code,
|
||
bm.get('material_supplier') or bm.get('supplier_short_name') or row.get('supplier_name', ''),
|
||
pc,
|
||
)
|
||
warehouse = previous_order.get('仓库到货')
|
||
query("""INSERT INTO packaging_orders
|
||
(日期,计划下单时间,下单时间,编码,名称,单价,数量,合计,供应商,仓库到货,下单备注,进度,采购下单人,采购计划,来源产品编码,有无新稿件,是否审核价格)
|
||
VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,'未审核')
|
||
""", (
|
||
None, today, now_str, mat_code, mat_name,
|
||
mat_price, order_qty, mat_amount, mat_supplier, warehouse,
|
||
bm.get('remark') or bm.get('pkg_remark', ''), '', row.get('procurement_follower'),
|
||
row.get('procurement_planner'), pc,
|
||
'是' if str(bm.get('change_manuscript') or '').strip() in ('是', '有') else '否'
|
||
))
|
||
|
||
# 5. 保存BOM数据（含更换稿件等）到下单备份。
|
||
# 状态和 ordered_at 已在第 1.5 步抢占时更新，这里只更新 BOM（按 id，避免影响历史备份行）。
|
||
import json
|
||
import decimal
|
||
def _json_default(o):
|
||
# bom 表 quantity 等字段可能为 Decimal，先转 float 再序列化，避免 500
|
||
if isinstance(o, decimal.Decimal):
|
||
return float(o)
|
||
raise TypeError(f'Object of type {o.__class__.__name__} is not JSON serializable')
|
||
bom_str = json.dumps(bom_list, ensure_ascii=False, default=_json_default) if bom_list else None
|
||
query("UPDATE pending_orders SET bom_items=%s WHERE id=%s AND status='ordered'",
|
||
(bom_str, row['id']))
|
||
|
||
# 6. 收集钉钉群备货通知（按采购跟单组别聚合，一个群一条消息）
|
||
group_label = _resolve_follower_group(row.get('procurement_follower') or '')
|
||
if group_label and (qty > 0 or pack_items):
|
||
webhook = FOLLOWER_GROUP_MAP[group_label]['webhook']
|
||
info = notify_groups.setdefault(webhook, {
|
||
'group_name': FOLLOWER_GROUP_MAP[group_label]['group_name'],
|
||
'secret': FOLLOWER_GROUP_MAP[group_label].get('secret', ''),
|
||
'lines': []
|
||
})
|
||
product_remark = (row.get('remark') or '').strip() or '无'
|
||
if pack_items:
|
||
pack_qty_lines = '\n'.join(f"包材数量：{name}：{q}" for name, q, _rm in pack_items)
|
||
pack_remark_lines = '\n'.join(f"包材下单备注：{(_rm or '').strip() or '无'}" for name, q, _rm in pack_items)
|
||
else:
|
||
pack_qty_lines = '包材数量：无'
|
||
pack_remark_lines = ''
|
||
parts = [
|
||
f"货品编号：{row.get('product_code')}",
|
||
f"货品名称：{row.get('product_name')}",
|
||
f"成品数量：{qty}",
|
||
f"成品下单备注：{product_remark}",
|
||
pack_qty_lines,
|
||
]
|
||
if pack_remark_lines:
|
||
parts.append(pack_remark_lines)
|
||
info['lines'].append('\n'.join(parts))
|
||
|
||
# 海外产品清单专属通知：与现有按跟单小组的通知分开，不改变原通知内容。
|
||
if qty > 0 and _is_overseas_notify_product(row.get('product_name', '')):
|
||
overseas_info = notify_groups.setdefault(OVERSEAS_NOTIFY_GROUP_KEY, {
|
||
'kind': 'overseas_product',
|
||
'lines': []
|
||
})
|
||
overseas_info['lines'].append('\n'.join([
|
||
f"货品编号：{row.get('product_code') or ''}",
|
||
f"货品名称：{row.get('product_name') or ''}",
|
||
f"下单数量：{product_actual_qty}",
|
||
f"采购跟单：{row.get('procurement_follower') or ''}",
|
||
f"工厂：{row.get('supplier_name') or ''}",
|
||
]))
|
||
|
||
# 确定前端跳转目标
|
||
redirect = None
|
||
if has_product_order:
|
||
first_pc = product_codes[0] if product_codes else ''
|
||
if first_pc:
|
||
is_overseas = (brand_routes.get(first_pc) == '海外')
|
||
redirect = 'orders_overseas' if is_overseas else 'orders_domestic'
|
||
|
||
# 7. 后台线程发送钉钉群备货通知（不阻塞下单接口）
|
||
if notify_groups:
|
||
import threading
|
||
threading.Thread(target=_notify_purchase_ready, args=(notify_groups,), daemon=True).start()
|
||
|
||
return jsonify({
|
||
"code": 0,
|
||
"msg": f"已确认 {len(product_codes)} 个商品",
|
||
"redirect": redirect,
|
||
"has_product_order": has_product_order,
|
||
"has_packaging_order": has_packaging_order
|
||
})
|
||
|
||
|
||
@purchase_bp.route('/api/purchase/create_material_order', methods=['POST'])
|
||
@login_required
|
||
def purchase_create_material_order():
|
||
denied = _require_purchase_operation('purchase', 'create')
|
||
if denied:
|
||
return denied
|
||
"""为物料（BOM配套）生成采购订单"""
|
||
data = request.json
|
||
pc = data.get('product_code', '')
|
||
material_code = data.get('material_code', '')
|
||
material_name = data.get('material_name', '')
|
||
order_qty = int(data.get('order_qty', 0))
|
||
|
||
if not material_code or order_qty <= 0:
|
||
return jsonify({"code": 400, "msg": "参数错误"})
|
||
|
||
now = datetime.now()
|
||
date_prefix = now.strftime('%Y%m%d')
|
||
prefix = f"DYCG{date_prefix}"
|
||
last = query("SELECT order_no FROM purchase_orders WHERE order_no LIKE %s ORDER BY id DESC LIMIT 1",
|
||
(prefix + '%',))
|
||
if last:
|
||
last_seq = int(last[0]['order_no'][-4:])
|
||
seq = last_seq + 1
|
||
else:
|
||
seq = 1
|
||
order_no = f"{prefix}{seq:04d}"
|
||
|
||
# 查找物料成本价（作为单价）
|
||
prod = query("SELECT cost_price FROM products WHERE product_code=%s", (material_code,))
|
||
cost_price = float(prod[0]['cost_price'] or 0) if prod else 0
|
||
amount = round(order_qty * cost_price, 2)
|
||
|
||
try:
|
||
order_id = query(
|
||
"INSERT INTO purchase_orders (order_no, supplier_name, total_qty, total_amount, created_by) "
|
||
"VALUES (%s, %s, %s, %s, %s)",
|
||
(order_no, material_name, order_qty, amount, session.get('real_name', ''))
|
||
)
|
||
query(
|
||
"INSERT INTO purchase_order_items (order_id, product_code, product_name, specification, supplier_name, "
|
||
"suggested_qty, order_qty, unit_price, amount, lead_time) "
|
||
"VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)",
|
||
(order_id, material_code, material_name, '', material_name,
|
||
0, order_qty, cost_price, amount, 0)
|
||
)
|
||
add_operation_log(f"生成物料采购单 {material_code}", f"数量:{order_qty} 金额:{amount}")
|
||
return jsonify({"code": 0, "order_no": order_no, "msg": "物料采购单已生成"})
|
||
except Exception as e:
|
||
return jsonify({"code": 500, "msg": str(e)})
|
||
|
||
|
||
@purchase_bp.route('/api/purchase/batch_add_pending', methods=['POST'])
|
||
@login_required
|
||
def purchase_batch_add_pending():
|
||
denied = _require_purchase_operation('purchase', 'add')
|
||
if denied:
|
||
return denied
|
||
"""批量将商品加入待下单列表（从产品表同步数据）"""
|
||
data = request.json
|
||
product_codes = data.get('product_codes', [])
|
||
if not product_codes:
|
||
return jsonify({"code": 400, "msg": "缺少参数"})
|
||
|
||
# 查这些产品的基础信息
|
||
placeholders = ','.join(['%s'] * len(product_codes))
|
||
products = query(f"""
|
||
SELECT p.product_code, p.product_name, p.product_type,
|
||
p.lead_time, p.logistics_time, p.supplier_name_match AS supplier_name,
|
||
p.procurement_follower, p.procurement_planner, p.platform, p.operator, p.planning_new_old
|
||
FROM products p WHERE p.product_code IN ({placeholders})
|
||
""", product_codes)
|
||
|
||
prod_map = {r['product_code']: r for r in products}
|
||
|
||
added = 0
|
||
skipped = 0
|
||
for pc in product_codes:
|
||
# 检查是否已存在
|
||
existing = query("SELECT id FROM pending_orders WHERE product_code=%s AND status='pending'", (pc,))
|
||
if existing:
|
||
skipped += 1
|
||
continue
|
||
saved_draft = query("""SELECT id, new_old_product, sales_snapshot, sales_snapshot_at
|
||
FROM pending_orders WHERE product_code=%s AND status='draft'
|
||
ORDER BY updated_at DESC, id DESC LIMIT 1""", (pc,))
|
||
p = prod_map.get(pc, {})
|
||
# 查询BOM物料清单
|
||
bom_rows = query("SELECT material_code, material_name, quantity FROM bom WHERE product_code=%s", (pc,))
|
||
import json
|
||
bom_data = json.dumps([{
|
||
'material_code': r['material_code'],
|
||
'material_name': r['material_name'],
|
||
'quantity': float(r['quantity'])
|
||
} for r in bom_rows], ensure_ascii=False) if bom_rows else None
|
||
if saved_draft and saved_draft[0].get('sales_snapshot'):
|
||
sales_snapshot_json = saved_draft[0]['sales_snapshot']
|
||
sales_snapshot_at = saved_draft[0].get('sales_snapshot_at') or datetime.now()
|
||
else:
|
||
try:
|
||
sales_snapshot = _build_planning_sales_snapshot(
|
||
pc, p.get('product_name', ''), p.get('product_type', ''))
|
||
except Exception as exc:
|
||
return jsonify({"code": 500, "msg": f"[{pc}] 销量信息快照保存失败：{exc}"})
|
||
sales_snapshot_json = json.dumps(sales_snapshot, ensure_ascii=False, default=str)
|
||
sales_snapshot_at = datetime.now()
|
||
if saved_draft:
|
||
new_old_product = normalize_new_old(saved_draft[0].get('new_old_product') or p.get('planning_new_old'))
|
||
query("""UPDATE pending_orders SET product_name=%s, product_type=%s, supplier_name=%s,
|
||
lead_time=%s, logistics_time=%s, procurement_follower=%s, procurement_planner=%s,
|
||
platform=%s, operator=%s, new_old_product=%s, sales_snapshot=%s,
|
||
sales_snapshot_at=%s, status='pending', updated_at=NOW() WHERE id=%s""",
|
||
(p.get('product_name', ''), p.get('product_type', ''), p.get('supplier_name', ''),
|
||
int(p.get('lead_time', 0) or 0), int(p.get('logistics_time', 0) or 0),
|
||
p.get('procurement_follower', '') or '', p.get('procurement_planner', '') or '',
|
||
p.get('platform', '') or '', p.get('operator', '') or '', new_old_product,
|
||
sales_snapshot_json, sales_snapshot_at, saved_draft[0]['id']))
|
||
added += 1
|
||
continue
|
||
query("""
|
||
INSERT INTO pending_orders
|
||
(product_code, product_name, product_type, product_grade, supplier_name,
|
||
lead_time, logistics_time, total_support_days,
|
||
procurement_follower, procurement_planner, platform, operator,
|
||
audit_price, formal_order_qty, bom_items, new_old_product,
|
||
sales_snapshot, sales_snapshot_at)
|
||
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
|
||
""", (
|
||
pc, p.get('product_name', ''), p.get('product_type', ''), '',
|
||
p.get('supplier_name', ''), int(p.get('lead_time', 0) or 0),
|
||
int(p.get('logistics_time', 0) or 0), 0,
|
||
p.get('procurement_follower', '') or '', p.get('procurement_planner', '') or '',
|
||
p.get('platform', '') or '', p.get('operator', '') or '', 0, 0, bom_data,
|
||
normalize_new_old(p.get('planning_new_old')), sales_snapshot_json, sales_snapshot_at
|
||
))
|
||
added += 1
|
||
|
||
if added > 0:
|
||
add_operation_log('批量加入待下单', f'批量添加 {added} 个商品到待下单列表（跳过 {skipped} 个）')
|
||
return jsonify({"code": 0, "data": {"added": added, "skipped": skipped}})
|
||
|
||
|
||
@purchase_bp.route('/api/purchase/create_order', methods=['POST'])
|
||
@login_required
|
||
def purchase_create_order():
|
||
denied = _require_purchase_operation('purchase', 'create')
|
||
if denied:
|
||
return denied
|
||
"""生成采购订单"""
|
||
data = request.json
|
||
supplier_name = data.get('supplier_name', '')
|
||
items = data.get('items', [])
|
||
|
||
if not supplier_name or not items:
|
||
return jsonify({"code": 400, "msg": "参数错误"})
|
||
|
||
now = datetime.now()
|
||
date_prefix = now.strftime('%Y%m%d')
|
||
prefix = f"DYCG{date_prefix}"
|
||
last = query("SELECT order_no FROM purchase_orders WHERE order_no LIKE %s ORDER BY id DESC LIMIT 1",
|
||
(prefix + '%',))
|
||
if last:
|
||
last_seq = int(last[0]['order_no'][-4:])
|
||
seq = last_seq + 1
|
||
else:
|
||
seq = 1
|
||
order_no = f"{prefix}{seq:04d}"
|
||
|
||
total_qty = sum(item.get('order_qty', 0) for item in items)
|
||
total_amount = sum(item.get('order_qty', 0) * item.get('unit_price', 0) for item in items)
|
||
|
||
try:
|
||
order_id = query(
|
||
"INSERT INTO purchase_orders (order_no, supplier_name, total_qty, total_amount, created_by) "
|
||
"VALUES (%s, %s, %s, %s, %s)",
|
||
(order_no, supplier_name, total_qty, round(total_amount, 2), session.get('real_name', ''))
|
||
)
|
||
|
||
for item in items:
|
||
query(
|
||
"INSERT INTO purchase_order_items (order_id, product_code, product_name, specification, supplier_name, "
|
||
"suggested_qty, order_qty, unit_price, amount, lead_time) "
|
||
"VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)",
|
||
(order_id, item.get('product_code', ''), item.get('product_name', ''),
|
||
item.get('specification', ''), supplier_name,
|
||
item.get('suggested_qty', 0), item.get('order_qty', 0),
|
||
item.get('unit_price', 0), round(item.get('order_qty', 0) * item.get('unit_price', 0), 2),
|
||
item.get('lead_time', 0))
|
||
)
|
||
|
||
add_operation_log('创建采购订单', f"供应商:{supplier_name} 单号:{order_no} 金额:¥{round(total_amount,2)}")
|
||
|
||
return jsonify({"code": 0, "msg": "采购订单创建成功", "data": {"order_no": order_no, "order_id": order_id}})
|
||
except Exception as e:
|
||
return jsonify({"code": 500, "msg": str(e)})
|
||
|
||
|
||
# ─── API: 采购订单列表 ───
|
||
@purchase_bp.route('/api/purchase/orders/list')
|
||
@login_required
|
||
def purchase_orders_list():
|
||
denied = _require_purchase_operation('purchase_ready', 'view')
|
||
if denied:
|
||
return denied
|
||
page = int(request.args.get('page', 1))
|
||
size = int(request.args.get('size', 20))
|
||
offset = (page - 1) * size
|
||
order_type = request.args.get('type', '') # ''=全部, domestic=国内, overseas=海外, packaging=包材
|
||
|
||
where_extra = ''
|
||
params = []
|
||
|
||
if order_type == 'domestic':
|
||
where_extra = "AND (p.product_type IN ('成品','赠品','小样','物料','其他') OR p.product_type IS NULL)"
|
||
elif order_type == 'overseas':
|
||
where_extra = "AND p.product_type = '成品' AND (i.product_code LIKE '%%-TMGJ' OR i.product_code LIKE '%%-JDGJ' OR i.product_code LIKE '%%-JDBZ' OR i.product_code LIKE '%%-JDJWT')"
|
||
elif order_type == 'packaging':
|
||
where_extra = "AND p.product_type = '包材'"
|
||
|
||
total_count = query(f"""
|
||
SELECT COUNT(*) AS cnt FROM purchase_order_items i
|
||
JOIN purchase_orders o ON i.order_id = o.id
|
||
LEFT JOIN products p ON i.product_code = p.product_code
|
||
WHERE 1=1 {where_extra}
|
||
""", params)
|
||
total = total_count[0]['cnt'] if total_count else 0
|
||
|
||
items = query(f"""
|
||
SELECT o.id AS order_id, i.id AS item_id, o.status,
|
||
o.order_no, o.supplier_name, o.created_at AS order_time,
|
||
i.product_code, i.product_name, i.specification,
|
||
i.unit_price, i.order_qty, i.amount, i.lead_time,
|
||
COALESCE(p.product_type, '') AS product_type
|
||
FROM purchase_order_items i
|
||
JOIN purchase_orders o ON i.order_id = o.id
|
||
LEFT JOIN products p ON i.product_code = p.product_code
|
||
WHERE 1=1 {where_extra}
|
||
ORDER BY o.created_at DESC, i.id ASC
|
||
LIMIT %s OFFSET %s
|
||
""", params + [size, offset])
|
||
|
||
for row in items:
|
||
if row.get('order_time'):
|
||
try:
|
||
row['order_time'] = row['order_time'].strftime('%Y-%m-%d %H:%M') if hasattr(row['order_time'], 'strftime') else str(row['order_time'])[:16]
|
||
except:
|
||
pass
|
||
|
||
return jsonify({"code": 0, "data": {"total": total, "rows": items}})
|
||
|
||
|
||
@purchase_bp.route('/api/purchase/orders/by_product')
|
||
@login_required
|
||
def purchase_orders_by_product():
|
||
denied = _require_purchase_operation('purchase_ready', 'view')
|
||
if denied:
|
||
return denied
|
||
"""根据货品编码查询采购订单在途数据"""
|
||
code = request.args.get('code', '')
|
||
if not code:
|
||
return jsonify({"code": 400, "msg": "参数错误"})
|
||
|
||
items = query("""
|
||
SELECT o.id AS order_id, o.order_no, o.status, o.created_at AS order_time,
|
||
i.product_code, i.product_name, i.specification,
|
||
i.unit_price, i.order_qty, i.amount, i.lead_time, i.suggested_qty
|
||
FROM purchase_order_items i
|
||
JOIN purchase_orders o ON i.order_id = o.id
|
||
WHERE i.product_code = %s
|
||
ORDER BY o.created_at DESC
|
||
""", (code,))
|
||
|
||
for row in items:
|
||
if row.get('order_time'):
|
||
row['order_time'] = row['order_time'].strftime('%Y-%m-%d') if hasattr(row['order_time'], 'strftime') else str(row['order_time'])[:10]
|
||
|
||
# 汇总
|
||
total_in_transit = sum(r['order_qty'] or 0 for r in items)
|
||
total_amount = sum(float(r['amount'] or 0) for r in items)
|
||
pending_count = sum(1 for r in items if r['status'] == 'pending')
|
||
|
||
return jsonify({
|
||
"code": 0,
|
||
"data": {
|
||
"items": items,
|
||
"summary": {
|
||
"total_orders": len(items),
|
||
"total_qty": total_in_transit,
|
||
"total_amount": round(total_amount, 2),
|
||
"pending_count": pending_count
|
||
}
|
||
}
|
||
})
|
||
|
||
|
||
@purchase_bp.route('/api/purchase/orders/detail')
|
||
@login_required
|
||
def purchase_orders_detail():
|
||
denied = _require_purchase_operation('purchase_ready', 'view')
|
||
if denied:
|
||
return denied
|
||
order_id = request.args.get('id')
|
||
if not order_id:
|
||
return jsonify({"code": 400, "msg": "参数错误"})
|
||
|
||
order = query("SELECT * FROM purchase_orders WHERE id=%s", (order_id,))
|
||
if not order:
|
||
return jsonify({"code": 404, "msg": "订单不存在"})
|
||
|
||
items = query("SELECT * FROM purchase_order_items WHERE order_id=%s", (order_id,))
|
||
return jsonify({"code": 0, "data": {"order": order[0], "items": items}})
|
||
|
||
|
||
@purchase_bp.route('/api/purchase/orders/update_status', methods=['POST'])
|
||
@login_required
|
||
def purchase_orders_update_status():
|
||
denied = _require_purchase_operation('purchase_ready', 'edit')
|
||
if denied:
|
||
return denied
|
||
data = request.json
|
||
order_id = data.get('id')
|
||
status = data.get('status', '')
|
||
if not order_id or not status:
|
||
return jsonify({"code": 400, "msg": "参数错误"})
|
||
query("UPDATE purchase_orders SET status=%s WHERE id=%s", (status, order_id))
|
||
add_operation_log('更新订单状态', f"订单ID:{order_id} 状态->{status}")
|
||
return jsonify({"code": 0, "msg": "状态已更新"})
|
||
|
||
|
||
@purchase_bp.route('/api/purchase/orders/rollback', methods=['POST'])
|
||
@login_required
|
||
def purchase_orders_rollback():
|
||
denied = _require_purchase_operation('purchase_ready', 'rollback')
|
||
if denied:
|
||
return denied
|
||
data = request.json
|
||
order_id = data.get('order_id')
|
||
if not order_id:
|
||
return jsonify({"code": 400, "msg": "参数错误"})
|
||
query("DELETE FROM purchase_order_items WHERE order_id=%s", (order_id,))
|
||
query("DELETE FROM purchase_orders WHERE id=%s", (order_id,))
|
||
add_operation_log('回退订单', f"订单ID:{order_id} 回退到待下单")
|
||
return jsonify({"code": 0, "msg": "已回退到待下单管理"})
|
||
|
||
|
||
@purchase_bp.route('/api/purchase/orders/delete', methods=['POST'])
|
||
@login_required
|
||
def purchase_orders_delete():
|
||
denied = _require_purchase_operation('purchase_ready', 'delete')
|
||
if denied:
|
||
return denied
|
||
data = request.json
|
||
order_id = data.get('id')
|
||
if not order_id:
|
||
return jsonify({"code": 400, "msg": "参数错误"})
|
||
query("DELETE FROM purchase_order_items WHERE order_id=%s", (order_id,))
|
||
query("DELETE FROM purchase_orders WHERE id=%s", (order_id,))
|
||
add_operation_log('删除订单', f"订单ID:{order_id}")
|
||
return jsonify({"code": 0, "msg": "删除成功"})
|
||
|
||
|
||
def _append_table_filters(conditions, params, filters, skip_field=None):
|
||
"""Append shared list/search/numeric filters with exact list matching."""
|
||
if not isinstance(filters, dict):
|
||
return
|
||
for field, spec in filters.items():
|
||
if field == skip_field or field.startswith('_') or not isinstance(spec, dict):
|
||
continue
|
||
ftype = spec.get('type', '')
|
||
if ftype == 'search' and spec.get('value'):
|
||
conditions.append(f"`{field}` LIKE %s")
|
||
params.append('%' + str(spec['value']) + '%')
|
||
elif ftype == 'list' and spec.get('values'):
|
||
values = spec['values']
|
||
non_empty = [value for value in values if value != '__EMPTY__']
|
||
parts = []
|
||
if non_empty:
|
||
parts.append(f"`{field}` IN (" + ', '.join(['%s'] * len(non_empty)) + ')')
|
||
params.extend(non_empty)
|
||
if '__EMPTY__' in values:
|
||
parts.append(f"(`{field}` IS NULL OR `{field}` = '')")
|
||
if parts:
|
||
conditions.append('(' + ' OR '.join(parts) + ')')
|
||
elif ftype == 'num' and spec.get('cond') and spec.get('val') != '':
|
||
cond = spec['cond']
|
||
value = str(spec['val'])
|
||
op_map = {'eq': '=', 'neq': '!=', 'gt': '>', 'gte': '>=', 'lt': '<', 'lte': '<='}
|
||
try:
|
||
if cond == 'range':
|
||
bounds = [part.strip() for part in value.split(',') if part.strip()]
|
||
if len(bounds) == 2:
|
||
conditions.append(f"`{field}` BETWEEN %s AND %s")
|
||
params.extend([float(bounds[0]), float(bounds[1])])
|
||
elif cond in op_map:
|
||
conditions.append(f"`{field}` {op_map[cond]} %s")
|
||
params.append(float(value))
|
||
except ValueError:
|
||
continue
|
||
|
||
|
||
_PERSONNEL_FILTER_FIELDS = {
|
||
'采购跟单', '采购计划', '采购员', '采购开发', '包材开发', '采购下单人', '运营'
|
||
}
|
||
_PERSONNEL_FILTER_GROUPS = {
|
||
'跟单一组': ['方园霞','邝碧君','余瑞霞','卢浩然'],
|
||
'跟单二组': ['许晓珊','刘伟','王加飞','邓文婷'],
|
||
'跟单三组': ['闫伟华','蔡少铃','颜于凯','张文菁'],
|
||
'现货小组': ['莫碧霞','范亚欢'],
|
||
'计划小组': ['汤定毅','李媛','黄静','胡孟怡','张莹纯','范世澄','陈瑜'],
|
||
}
|
||
|
||
|
||
def _personnel_filter_groups():
|
||
"""读取人员信息管理中的实时分组；读取失败时兼容旧名单。"""
|
||
try:
|
||
rows = query("SELECT group_name, members_json FROM personnel_groups ORDER BY group_order, group_name")
|
||
except Exception:
|
||
return _PERSONNEL_FILTER_GROUPS
|
||
groups = {}
|
||
for row in rows:
|
||
try:
|
||
members = json.loads(row.get('members_json') or '[]')
|
||
except (TypeError, ValueError):
|
||
members = []
|
||
group_name = str(row.get('group_name') or '').strip()
|
||
if group_name:
|
||
groups[group_name] = [str(member).strip() for member in members if str(member).strip()]
|
||
return groups or _PERSONNEL_FILTER_GROUPS
|
||
|
||
|
||
def _build_exact_list_parts(field, values, params):
|
||
"""列表值精确匹配；人员分组值展开为实时组员，并兼容数据库已保存的组名。"""
|
||
if not values:
|
||
return []
|
||
if field in _PERSONNEL_FILTER_FIELDS:
|
||
groups = _personnel_filter_groups()
|
||
names = []
|
||
for selected in values:
|
||
# 订单中既有直接保存的组名，也有历史人员姓名，两种口径都要匹配。
|
||
names.append(selected)
|
||
names.extend(groups.get(selected, []))
|
||
names = list(dict.fromkeys(names))
|
||
parts = []
|
||
for name in names:
|
||
parts.append(f"FIND_IN_SET(%s, REPLACE(`{field}`, '，', ',')) > 0")
|
||
params.append(name)
|
||
return parts
|
||
placeholders = ', '.join(['%s'] * len(values))
|
||
params.extend(values)
|
||
return [f"`{field}` IN ({placeholders})"]
|
||
|
||
|
||
# 订单列表可排序字段白名单（中文列名 → 实际数据库列名）
|
||
_ORDER_SORTABLE_FIELDS = {
|
||
'domestic': {
|
||
'日期', '计划下单时间', '新旧品', '货品编号', '货品名称', '下单备注',
|
||
'单价', '是否审核价格', '数量', '金额', '供货商', '仓库', '金蝶采购单',
|
||
'采购员', '下单人', '进度', '旺店通生产单号', '是否已录入旺店通',
|
||
'采购开发', '实际到货日期', '实际到货数量', '未到货数', '预计到货日期',
|
||
'金蝶入库', '状态', '订单下达供应商时间', '待提数量', '货品类型',
|
||
},
|
||
'overseas': {
|
||
'日期', '计划下单时间', '产品编码', '单价', '是否审核价格', '数量',
|
||
'金额', '供应商', '仓库', '货品名称', '新旧品', '是否已做采购单',
|
||
'是否做入库', '采购员', '下单人', '进度', '下单备注', '采购开发',
|
||
'旺店通生产单号', '是否已录入到旺店通', '实际到货日期', '实际到货数量',
|
||
'预计到货日期', '未到货数', '状态', '订单下达供应商时间', '待提数量', '货品类型',
|
||
},
|
||
'packaging': {
|
||
'日期', '计划下单时间', '下单时间', '编码', '名称', '货品类型', '新旧品', '单价', '数量', '合计', '供应商',
|
||
'下单备注', '仓库到货', '进度', '是否已做采购单', '是否已做入库',
|
||
'采购下单人', '旺店通编号', '是否已录入旺店通', '到货日期', '状态',
|
||
'做货天数', '包材开发', '待提数量', '实际到货数量', '未到货数',
|
||
'是否审核价格', '下单人', '货品类型',
|
||
},
|
||
}
|
||
|
||
|
||
def _resolve_order_sort(order_filter_str, order_type, default_order):
|
||
"""从 order_filter JSON 解析 _sortField/_sortAsc，白名单校验后返回 ORDER BY 子句。
|
||
|
||
前端排序按钮把排序字段写入 filterState._sortField（字符串）与 _sortAsc（布尔），
|
||
序列化到 order_filter 参数中。此前后端只处理 dict 型条件（list/search/num），
|
||
排序字段被跳过导致排序失效。这里单独提取并白名单校验，防止 SQL 注入。
|
||
"""
|
||
sort_field = ''
|
||
sort_asc = False
|
||
if order_filter_str:
|
||
try:
|
||
_filters = json.loads(order_filter_str)
|
||
sort_field = _filters.get('_sortField') or ''
|
||
sort_asc = bool(_filters.get('_sortAsc'))
|
||
except Exception:
|
||
pass
|
||
allowed = _ORDER_SORTABLE_FIELDS.get(order_type, set())
|
||
if sort_field in allowed:
|
||
direction = 'ASC' if sort_asc else 'DESC'
|
||
return f"`{sort_field}` {direction}"
|
||
return default_order
|
||
|
||
|
||
# ─── 国内订单管理 API ───
|
||
def _apply_order_filter(where, params, order_filter_str, field_map):
|
||
"""解析 order_filter JSON 并追加 WHERE 条件到 where/params
|
||
field_map: {前端field: 数据库列名}
|
||
"""
|
||
if not order_filter_str:
|
||
return
|
||
try:
|
||
filters = json.loads(order_filter_str)
|
||
except Exception:
|
||
return
|
||
for field, cond in filters.items():
|
||
db_field = field_map.get(field, field)
|
||
if not isinstance(cond, dict):
|
||
continue
|
||
ftype = cond.get('type')
|
||
if ftype == 'list':
|
||
values = cond.get('values', [])
|
||
if values:
|
||
placeholders = ', '.join(['%s'] * len(values))
|
||
where.append(f"`{db_field}` IN ({placeholders})")
|
||
params.extend(values)
|
||
elif ftype == 'search':
|
||
val = cond.get('value', '')
|
||
if val:
|
||
where.append(f"`{db_field}` LIKE %s")
|
||
params.append(f"%{val}%")
|
||
elif ftype == 'num':
|
||
op_map = {
|
||
'eq': '=', 'neq': '!=', 'gt': '>', 'gte': '>=',
|
||
'lt': '<', 'lte': '<='
|
||
}
|
||
cond_op = cond.get('cond', '')
|
||
cond_val = cond.get('val', '')
|
||
if cond_op == 'range':
|
||
parts = [p.strip() for p in cond_val.split(',') if p.strip()]
|
||
if len(parts) == 2:
|
||
where.append(f"`{db_field}` >= %s AND `{db_field}` <= %s")
|
||
params.extend([float(parts[0]), float(parts[1])])
|
||
elif cond_op in op_map:
|
||
try:
|
||
num_val = float(cond_val)
|
||
where.append(f"`{db_field}` {op_map[cond_op]} %s")
|
||
params.append(num_val)
|
||
except ValueError:
|
||
pass
|
||
# 强制写入测试：如果没任何条件被加，这里硬塞一个
|
||
if not where:
|
||
where.append('1=0') # 测试标记：函数被执行
|
||
params.append('_debug_apply_executed')
|
||
|
||
|
||
@purchase_bp.route('/api/domestic/orders/list', methods=['GET', 'POST'])
|
||
@login_required
|
||
def domestic_orders_list():
|
||
denied = _require_purchase_operation('orders_domestic', 'view')
|
||
if denied:
|
||
return denied
|
||
"""国内订单列表"""
|
||
page = int(request.args.get('page', 1))
|
||
size = int(request.args.get('size', 100))
|
||
search = request.args.get('search', '')
|
||
status_filter = request.args.get('status', '')
|
||
supplier_filter = request.args.get('supplier', '')
|
||
orderer_filter = request.args.get('orderer', '')
|
||
body = request.get_json(silent=True) if request.method == 'POST' else None
|
||
body = body if isinstance(body, dict) else {}
|
||
order_filter_str = request.args.get('order_filter', '') or ''
|
||
if body.get('order_filter') is not None:
|
||
order_filter_str = json.dumps(body.get('order_filter') or {}, ensure_ascii=False)
|
||
|
||
where = []
|
||
params = []
|
||
|
||
if search:
|
||
where.append("(`货品编号` LIKE %s OR `货品名称` LIKE %s OR `供货商` LIKE %s OR `下单备注` LIKE %s)")
|
||
kw = f'%{search}%'
|
||
params.extend([kw, kw, kw, kw])
|
||
if status_filter:
|
||
where.append("`状态` = %s")
|
||
params.append(status_filter)
|
||
if supplier_filter:
|
||
where.append("`供货商` LIKE %s")
|
||
params.append(f'%{supplier_filter}%')
|
||
if orderer_filter:
|
||
where.append("`下单人` LIKE %s")
|
||
params.append(f'%{orderer_filter}%')
|
||
# 内联处理表头筛选：直接解析 order_filter_str
|
||
if order_filter_str:
|
||
import json as _json
|
||
try:
|
||
_filters = _json.loads(order_filter_str)
|
||
for _f, _c in _filters.items():
|
||
_db = _f # 前后端字段名一致
|
||
if not isinstance(_c, dict):
|
||
continue
|
||
_t = _c.get('type', '')
|
||
if _t == 'search':
|
||
_v = _c.get('value', '')
|
||
if _v:
|
||
where.append('`' + _db + '` LIKE %s')
|
||
params.append('%' + _v + '%')
|
||
elif _t == 'list':
|
||
_vs = _c.get('values', [])
|
||
if _vs:
|
||
_non_empty = [x for x in _vs if x != '__EMPTY__']
|
||
_list_parts = []
|
||
if _non_empty:
|
||
_list_parts.extend(_build_exact_list_parts(_db, _non_empty, params))
|
||
if '__EMPTY__' in _vs:
|
||
_list_parts.append("(`" + _db + "` IS NULL OR `" + _db + "` = '')")
|
||
if _list_parts:
|
||
where.append('(' + ' OR '.join(_list_parts) + ')')
|
||
elif _t == 'num':
|
||
_op = _c.get('cond', '')
|
||
_vl = _c.get('val', '')
|
||
_om = {'eq':'=','neq':'!=','gt':'>','gte':'>=','lt':'<','lte':'<='}
|
||
if _op == 'range' and _vl:
|
||
_parts = [x.strip() for x in _vl.split(',') if x.strip()]
|
||
if len(_parts) == 2:
|
||
where.append('`' + _db + '` >= %s AND `' + _db + '` <= %s')
|
||
params.extend([float(_parts[0]), float(_parts[1])])
|
||
elif _op in _om:
|
||
try:
|
||
_nv = float(_vl)
|
||
where.append('`' + _db + '` ' + _om[_op] + ' %s')
|
||
params.append(_nv)
|
||
except ValueError:
|
||
pass
|
||
except Exception:
|
||
pass
|
||
|
||
where_clause = " WHERE " + " AND ".join(where) if where else ""
|
||
|
||
offset = (page - 1) * size
|
||
|
||
domestic_source = _order_table_with_product_type('domestic_orders', '货品编号')
|
||
# 总记录数
|
||
cnt = query(f"SELECT COUNT(*) AS cnt FROM {domestic_source}{where_clause}", params)
|
||
total = cnt[0]['cnt'] if cnt else 0
|
||
|
||
# 查询数据
|
||
order_by = _resolve_order_sort(order_filter_str, 'domestic', "IFNULL(created_at,'1970-01-01') DESC, `计划下单时间` DESC, `日期` DESC")
|
||
rows = query(f"SELECT * FROM {domestic_source}{where_clause} ORDER BY {order_by} LIMIT %s OFFSET %s",
|
||
params + [size, offset])
|
||
# 兼容历史导入数据：没有到货批次时也按订单数量和实际到货数量补齐未到货数。
|
||
# 金蝶入库的业务默认值在旧数据中可能是 NULL，列表边界统一按“否”展示。
|
||
for row in rows:
|
||
if row.get('金蝶入库') in (None, ''):
|
||
row['金蝶入库'] = '否'
|
||
if row.get('未到货数') is None:
|
||
order_qty = int(row.get('数量') or 0)
|
||
arrived_qty = int(row.get('实际到货数量') or 0)
|
||
row['未到货数'] = order_qty - arrived_qty
|
||
_enrich_order_product_types(rows, '货品编号')
|
||
|
||
return jsonify({"code": 0, "data": {"rows": rows, "total": total, "page": page, "size": size}})
|
||
|
||
|
||
@purchase_bp.route('/api/domestic/orders/filters')
|
||
@login_required
|
||
def domestic_orders_filters():
|
||
denied = _require_purchase_operation('orders_domestic', 'view')
|
||
if denied:
|
||
return denied
|
||
"""获取筛选选项"""
|
||
suppliers = query("SELECT DISTINCT `供货商` FROM domestic_orders WHERE `供货商` IS NOT NULL AND `供货商` != '' ORDER BY `供货商`")
|
||
statuses = query("SELECT DISTINCT `状态` FROM domestic_orders WHERE `状态` IS NOT NULL AND `状态` != '' ORDER BY `状态`")
|
||
orderers = query("SELECT DISTINCT `下单人` FROM domestic_orders WHERE `下单人` IS NOT NULL AND `下单人` != '' ORDER BY `下单人`")
|
||
return jsonify({
|
||
"code": 0,
|
||
"data": {
|
||
"suppliers": [s['供货商'] for s in suppliers],
|
||
"statuses": [s['状态'] for s in statuses],
|
||
"orderers": [o['下单人'] for o in orderers]
|
||
}
|
||
})
|
||
|
||
|
||
@purchase_bp.route('/api/domestic/orders/update', methods=['POST'])
|
||
@login_required
|
||
def domestic_orders_update():
|
||
denied = _require_purchase_operation('orders_domestic', 'edit')
|
||
if denied:
|
||
return denied
|
||
"""更新某一行字段值"""
|
||
data = request.json
|
||
row_id = data.get('id')
|
||
field = data.get('field')
|
||
value = data.get('value')
|
||
if not row_id or not field:
|
||
return jsonify({"code": 400, "msg": "参数错误"})
|
||
|
||
allowed_fields = [c[0] for c in [
|
||
("日期",1),("计划下单时间",1),("新旧品",1),("货品编号",1),("货品名称",1),
|
||
("下单备注",1),("单价",1),("数量",1),("金额",1),("供货商",1),
|
||
("仓库",1),("金蝶采购单",1),("采购员",1),("下单人",1),("进度",1),
|
||
("旺店通生产单号",1),("实际到货日期",1),("实际到货数量",1),("待提数量",1),("未到货数",1),
|
||
("预计到货日期",1),("金蝶入库",1),("状态",1),("是否已录入旺店通",1),
|
||
("采购开发",1),("是否审核价格",1),("父记录",1),
|
||
("platform",1),("订单下达供应商时间",1),("total_support_days",1),("actual_order_qty",1)
|
||
]]
|
||
if field not in allowed_fields:
|
||
return jsonify({"code": 400, "msg": f"不允许修改字段: {field}"})
|
||
|
||
# 数值字段空字符串转NULL
|
||
numeric_fields = ['单价','数量','金额','待提数量','未到货数','实际到货数量','total_support_days','actual_order_qty']
|
||
if value == '' and field in numeric_fields:
|
||
value = None
|
||
|
||
orderer_sync = None
|
||
if field == '下单人':
|
||
rows = query("SELECT `货品编号`, `计划下单时间` FROM domestic_orders WHERE id=%s", (row_id,))
|
||
if rows: orderer_sync = (rows[0].get('货品编号'), rows[0].get('计划下单时间'))
|
||
if field == '状态':
|
||
# 完结日期与状态绑定：已完结记当天，其他状态清空。
|
||
if str(value or '').strip() == '已完结':
|
||
query("UPDATE domestic_orders SET `状态`=%s, `完结时间`=CURDATE() WHERE id=%s", (value, row_id))
|
||
else:
|
||
query("UPDATE domestic_orders SET `状态`=%s, `完结时间`=NULL WHERE id=%s", (value, row_id))
|
||
else:
|
||
query(f"UPDATE domestic_orders SET `{field}`=%s WHERE id=%s", (value, row_id))
|
||
if field == '下单人' and orderer_sync:
|
||
_sync_backup_orderer(orderer_sync[0], orderer_sync[1], 'product_orderer', value)
|
||
if field in ('数量', '实际到货日期', '实际到货数量', '未到货数'):
|
||
sync_order_arrival_totals(row_id, 'domestic')
|
||
return jsonify({"code": 0, "msg": "更新成功"})
|
||
|
||
|
||
@purchase_bp.route('/api/domestic/orders/update_fields', methods=['POST'])
|
||
@login_required
|
||
def domestic_orders_update_fields():
|
||
"""批量更新国内订单字段（详情弹窗保存用，只记录一条合并日志）"""
|
||
denied = _require_purchase_operation('orders_domestic', 'edit')
|
||
if denied:
|
||
return denied
|
||
data = request.json or {}
|
||
row_id = data.get('id')
|
||
fields = data.get('fields') or {}
|
||
if not row_id or not fields:
|
||
return jsonify({"code": 400, "msg": "参数错误"})
|
||
allowed_fields = [c[0] for c in [
|
||
("日期",1),("计划下单时间",1),("新旧品",1),("货品编号",1),("货品名称",1),
|
||
("下单备注",1),("单价",1),("数量",1),("金额",1),("供货商",1),
|
||
("仓库",1),("金蝶采购单",1),("采购员",1),("下单人",1),("进度",1),
|
||
("旺店通生产单号",1),("实际到货日期",1),("实际到货数量",1),("待提数量",1),("未到货数",1),
|
||
("预计到货日期",1),("金蝶入库",1),("状态",1),("是否已录入旺店通",1),
|
||
("采购开发",1),("是否审核价格",1),("父记录",1),
|
||
("platform",1),("订单下达供应商时间",1),("total_support_days",1),("actual_order_qty",1)
|
||
]]
|
||
numeric_fields = ['单价','数量','金额','待提数量','未到货数','实际到货数量','total_support_days','actual_order_qty']
|
||
changed_parts = []
|
||
orderer_sync = None
|
||
if '下单人' in fields:
|
||
rows = query("SELECT `货品编号`, `计划下单时间` FROM domestic_orders WHERE id=%s", (row_id,))
|
||
if rows: orderer_sync = (rows[0].get('货品编号'), rows[0].get('计划下单时间'))
|
||
has_status_update = '状态' in fields and '状态' in allowed_fields
|
||
completes_order = has_status_update and str(fields.get('状态') or '').strip() == '已完结'
|
||
for field, value in fields.items():
|
||
if field not in allowed_fields:
|
||
continue
|
||
if value == '' and field in numeric_fields:
|
||
value = None
|
||
query(f"UPDATE domestic_orders SET `{field}`=%s WHERE id=%s", (value, row_id))
|
||
changed_parts.append(f'{field}={value if value is not None else "空"}')
|
||
if field in ('数量', '实际到货日期', '实际到货数量', '未到货数'):
|
||
sync_order_arrival_totals(row_id, 'domestic')
|
||
if has_status_update:
|
||
if completes_order:
|
||
query("UPDATE domestic_orders SET `完结时间`=CURDATE() WHERE id=%s", (row_id,))
|
||
else:
|
||
query("UPDATE domestic_orders SET `完结时间`=NULL WHERE id=%s", (row_id,))
|
||
changed_parts.append('完结时间=系统自动记录' if completes_order else '完结时间=已清空')
|
||
if orderer_sync:
|
||
_sync_backup_orderer(orderer_sync[0], orderer_sync[1], 'product_orderer', fields.get('下单人'))
|
||
if changed_parts:
|
||
add_operation_log('订单字段编辑', '；'.join(changed_parts) + f'（订单ID={row_id}）', page='国内订单管理', field='；'.join(fields.keys()))
|
||
return jsonify({"code": 0, "msg": "更新成功", "changed": len(changed_parts)})
|
||
|
||
|
||
_ARRIVAL_BATCHES_SCHEMA_READY = False
|
||
|
||
|
||
def _arrival_operator_name():
|
||
name = str(session.get('real_name') or '').strip()
|
||
if name:
|
||
return name
|
||
user_id = session.get('user_id')
|
||
if user_id:
|
||
rows = query("SELECT real_name, username FROM dashboard_users WHERE id=%s", (user_id,))
|
||
if rows:
|
||
return str(rows[0].get('real_name') or rows[0].get('username') or '').strip()
|
||
return str(session.get('username') or '').strip()
|
||
|
||
|
||
def _ensure_arrival_batches_table():
|
||
"""Ensure arrival batch storage records which immutable fields were actually filled."""
|
||
global _ARRIVAL_BATCHES_SCHEMA_READY
|
||
if _ARRIVAL_BATCHES_SCHEMA_READY:
|
||
return
|
||
query("""CREATE TABLE IF NOT EXISTS arrival_batches (
|
||
id INT AUTO_INCREMENT PRIMARY KEY,
|
||
order_id INT NOT NULL,
|
||
order_type VARCHAR(20) NOT NULL DEFAULT 'domestic',
|
||
arrival_date DATE,
|
||
arrival_qty INT DEFAULT 0,
|
||
defective_qty INT NOT NULL DEFAULT 0,
|
||
operator_name VARCHAR(100) NOT NULL DEFAULT '',
|
||
operated_at DATETIME NULL,
|
||
arrival_date_filled TINYINT(1) NOT NULL DEFAULT 0,
|
||
arrival_qty_filled TINYINT(1) NOT NULL DEFAULT 0,
|
||
defective_qty_filled TINYINT(1) NOT NULL DEFAULT 0,
|
||
remark TEXT,
|
||
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
|
||
)""")
|
||
columns = query("""SELECT COLUMN_NAME AS field
|
||
FROM information_schema.columns
|
||
WHERE table_schema=DATABASE() AND table_name='arrival_batches'""")
|
||
if 'defective_qty' not in {row.get('field') for row in columns}:
|
||
query("""ALTER TABLE arrival_batches
|
||
ADD COLUMN defective_qty INT NOT NULL DEFAULT 0 AFTER arrival_qty""")
|
||
column_names = {row.get('field') for row in columns}
|
||
if 'operator_name' not in column_names:
|
||
query("""ALTER TABLE arrival_batches
|
||
ADD COLUMN operator_name VARCHAR(100) NOT NULL DEFAULT '' AFTER defective_qty""")
|
||
if 'operated_at' not in column_names:
|
||
query("""ALTER TABLE arrival_batches
|
||
ADD COLUMN operated_at DATETIME NULL AFTER operator_name""")
|
||
query("UPDATE arrival_batches SET operated_at=created_at WHERE operated_at IS NULL")
|
||
# 已保存字段一旦填写即锁定；空字段允许后续补填一次。历史 0 按“未填写”迁移，
|
||
# 因为旧前端会把空输入强制保存为 0，无法再可靠区分显式 0 与空值。
|
||
if 'arrival_date_filled' not in column_names:
|
||
query("""ALTER TABLE arrival_batches
|
||
ADD COLUMN arrival_date_filled TINYINT(1) NOT NULL DEFAULT 0 AFTER operated_at""")
|
||
query("UPDATE arrival_batches SET arrival_date_filled=IF(arrival_date IS NULL,0,1)")
|
||
if 'arrival_qty_filled' not in column_names:
|
||
query("""ALTER TABLE arrival_batches
|
||
ADD COLUMN arrival_qty_filled TINYINT(1) NOT NULL DEFAULT 0 AFTER arrival_date_filled""")
|
||
query("UPDATE arrival_batches SET arrival_qty_filled=IF(arrival_qty IS NULL OR arrival_qty=0,0,1)")
|
||
if 'defective_qty_filled' not in column_names:
|
||
query("""ALTER TABLE arrival_batches
|
||
ADD COLUMN defective_qty_filled TINYINT(1) NOT NULL DEFAULT 0 AFTER arrival_qty_filled""")
|
||
query("UPDATE arrival_batches SET defective_qty_filled=IF(defective_qty IS NULL OR defective_qty=0,0,1)")
|
||
_ARRIVAL_BATCHES_SCHEMA_READY = True
|
||
|
||
|
||
def _optional_int(data, key, label):
|
||
"""Return (value, filled), preserving the distinction between blank and zero."""
|
||
raw = data.get(key)
|
||
if raw in (None, ''):
|
||
return 0, False
|
||
try:
|
||
return int(raw), True
|
||
except (TypeError, ValueError):
|
||
raise ValueError(f'{label}必须为整数')
|
||
|
||
|
||
def _arrival_batch_quantities(data, order_type='domestic'):
|
||
"""Parse quantities; defective quantity may be any integer for all order types."""
|
||
arrival_qty, arrival_qty_filled = _optional_int(data, 'arrival_qty', '到货数量')
|
||
defective_qty, defective_qty_filled = _optional_int(data, 'defective_qty', '不良品数量')
|
||
if arrival_qty_filled and arrival_qty < 0:
|
||
raise ValueError('到货数量不能为负数')
|
||
return arrival_qty, defective_qty, arrival_qty_filled, defective_qty_filled
|
||
|
||
|
||
def _domestic_order_pre_packaging(order_id):
|
||
"""只读取当前国内订单确认下单时的包材快照，不用滚动结余回填历史。"""
|
||
orders = query("SELECT `货品编号`, `计划下单时间` FROM domestic_orders WHERE id=%s", (order_id,))
|
||
if not orders or not orders[0].get('计划下单时间'):
|
||
return {}
|
||
order = orders[0]
|
||
snapshots = query("""
|
||
SELECT bom_items FROM pending_orders
|
||
WHERE product_code=%s AND ordered_at=%s AND status='ordered'
|
||
ORDER BY id DESC LIMIT 2
|
||
""", (order['货品编号'], order['计划下单时间']))
|
||
if len(snapshots) != 1:
|
||
return {}
|
||
raw = snapshots[0].get('bom_items')
|
||
try:
|
||
items = json.loads(raw) if isinstance(raw, str) else raw
|
||
except (TypeError, ValueError):
|
||
return {}
|
||
if not isinstance(items, list):
|
||
return {}
|
||
return {str(item['material_code']): item['pre_pack_qty']
|
||
for item in items if isinstance(item, dict) and item.get('material_code')
|
||
and item.get('pre_pack_qty') is not None}
|
||
|
||
|
||
def _order_packaging_materials(order_id, order_type):
|
||
"""按成品订单的来源编码和确认时间取本批包材，禁止用最新BOM/订单代替历史。"""
|
||
fields = {
|
||
'domestic': ('domestic_orders', '货品编号'),
|
||
'overseas': ('overseas_orders', '产品编码'),
|
||
}
|
||
if order_type not in fields:
|
||
return []
|
||
table, code_field = fields[order_type]
|
||
orders = query(f'SELECT `{code_field}` AS product_code, `计划下单时间` AS ordered_at '
|
||
f'FROM {table} WHERE id=%s', (order_id,))
|
||
if not orders:
|
||
return []
|
||
order = orders[0]
|
||
ordered_at = order.get('ordered_at')
|
||
if not order.get('product_code') or not ordered_at:
|
||
return []
|
||
# 仅有日期无法区分同一天的多次确认，不猜测关联关系。
|
||
stamp = ordered_at.strftime('%Y-%m-%d %H:%M:%S') if hasattr(ordered_at, 'strftime') else str(ordered_at).strip()
|
||
if len(stamp) <= 10:
|
||
return []
|
||
packages = query("""
|
||
SELECT id, `编码` AS material_code, `名称` AS material_name,
|
||
`数量` AS order_qty, `实际到货数量` AS arrival_qty,
|
||
`下单时间` AS order_time, `到货日期` AS arrival_date, `进度` AS progress
|
||
FROM packaging_orders
|
||
WHERE `来源产品编码`=%s AND `下单时间`=%s
|
||
ORDER BY id
|
||
""", (order['product_code'], stamp))
|
||
pre_packaging = _domestic_order_pre_packaging(order_id) if order_type == 'domestic' else {}
|
||
result = []
|
||
for package in packages:
|
||
material_code = package.get('material_code') or ''
|
||
material_name = package.get('material_name') or ''
|
||
if '内料' in material_name or '-NL' in material_code:
|
||
continue
|
||
def date_text(value, length):
|
||
return (value.isoformat(sep=' ') if isinstance(value, datetime)
|
||
else str(value or ''))[:length]
|
||
result.append({
|
||
'packaging_order_id': package['id'],
|
||
'material_code': material_code,
|
||
'material_name': material_name,
|
||
'pre_pack_qty': pre_packaging.get(material_code),
|
||
'order_time': date_text(package.get('order_time'), 16),
|
||
'order_qty': package.get('order_qty') or 0,
|
||
'arrival_qty': package.get('arrival_qty') or 0,
|
||
'arrival_date': date_text(package.get('arrival_date'), 10),
|
||
'progress': package.get('progress') or '',
|
||
})
|
||
return result
|
||
|
||
|
||
@purchase_bp.route('/api/domestic/orders/detail_extras')
|
||
@login_required
|
||
def domestic_orders_detail_extras():
|
||
denied = _require_purchase_operation('orders_domestic', 'view')
|
||
if denied:
|
||
return denied
|
||
"""Return arrival batches for one exact order plus its packaging details."""
|
||
order_id = request.args.get('order_id', '')
|
||
product_code = request.args.get('product_code', '')
|
||
order_type = request.args.get('order_type', 'domestic')
|
||
if not order_id:
|
||
return jsonify({"code": 400, "msg": "缺少订单ID"})
|
||
if order_type not in ('domestic', 'overseas', 'packaging'):
|
||
return jsonify({"code": 400, "msg": "订单类型错误"})
|
||
|
||
try:
|
||
order_id_int = int(order_id)
|
||
except (TypeError, ValueError):
|
||
return jsonify({"code": 400, "msg": "订单ID错误"})
|
||
_ensure_arrival_batches_table()
|
||
|
||
arrival_batches = list(query("""
|
||
SELECT id, arrival_date, arrival_qty, defective_qty, operator_name, operated_at, remark,
|
||
arrival_date_filled, arrival_qty_filled, defective_qty_filled
|
||
FROM arrival_batches
|
||
WHERE order_id=%s AND order_type=%s
|
||
ORDER BY arrival_date DESC, id DESC
|
||
""", (order_id_int, order_type)))
|
||
for batch in arrival_batches:
|
||
batch['from_type'] = 'add'
|
||
value = batch.get('arrival_date')
|
||
if value and hasattr(value, 'strftime'):
|
||
batch['arrival_date'] = value.strftime('%Y-%m-%d')
|
||
elif value and isinstance(value, str):
|
||
batch['arrival_date'] = value[:10]
|
||
if batch.get('operated_at') and hasattr(batch['operated_at'], 'strftime'):
|
||
batch['operated_at'] = batch['operated_at'].strftime('%Y-%m-%d %H:%M:%S')
|
||
elif batch.get('operated_at') is not None:
|
||
batch['operated_at'] = str(batch['operated_at'])[:19]
|
||
|
||
packaging_materials = _order_packaging_materials(order_id_int, order_type)
|
||
|
||
return jsonify({"code": 0, "data": {
|
||
"arrival_batches": arrival_batches,
|
||
"packaging_materials": packaging_materials,
|
||
}})
|
||
|
||
|
||
@purchase_bp.route('/api/domestic/orders/add_batch', methods=['POST'])
|
||
@login_required
|
||
def domestic_orders_add_batch():
|
||
denied = _require_purchase_operation('orders_domestic', 'edit')
|
||
if denied:
|
||
return denied
|
||
"""Add an arrival batch scoped to one order type and order ID."""
|
||
data = request.json or {}
|
||
order_id = data.get('order_id')
|
||
order_type = data.get('order_type', 'domestic')
|
||
if not order_id:
|
||
return jsonify({"code": 400, "msg": "缺少订单ID"})
|
||
if order_type not in ('domestic', 'overseas', 'packaging'):
|
||
return jsonify({"code": 400, "msg": "订单类型错误"})
|
||
_ensure_arrival_batches_table()
|
||
try:
|
||
arrival_qty, defective_qty, arrival_qty_filled, defective_qty_filled = _arrival_batch_quantities(data, order_type)
|
||
except ValueError as exc:
|
||
return jsonify({"code": 400, "msg": str(exc)})
|
||
operator_name = _arrival_operator_name()
|
||
operated_at = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
|
||
row_id = query("""INSERT INTO arrival_batches
|
||
(order_id, order_type, arrival_date, arrival_qty, defective_qty, operator_name, operated_at,
|
||
arrival_date_filled, arrival_qty_filled, defective_qty_filled, remark)
|
||
VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)""", (
|
||
order_id, order_type, data.get('arrival_date') or None,
|
||
arrival_qty, defective_qty, operator_name, operated_at,
|
||
1 if data.get('arrival_date') not in (None, '') else 0,
|
||
int(arrival_qty_filled), int(defective_qty_filled), data.get('remark') or ''
|
||
))
|
||
sync_order_arrival_totals(order_id, order_type)
|
||
page_name = {'domestic': '国内订单管理', 'overseas': '海外订单管理', 'packaging': '包材订单管理'}.get(order_type, order_type)
|
||
add_operation_log('到货批次及数量', f"新增到货批次：到货日期={data.get('arrival_date') or '空'}，数量={arrival_qty}，不良品数量={defective_qty}，备注={data.get('remark') or '空'}（订单ID={order_id}）", page=page_name, field='到货批次及数量')
|
||
return jsonify({"code": 0, "msg": "添加到货批次成功", "data": {
|
||
"id": row_id, "operator_name": operator_name, "operated_at": operated_at,
|
||
"arrival_date_filled": 1 if data.get('arrival_date') not in (None, '') else 0,
|
||
"arrival_qty_filled": int(arrival_qty_filled),
|
||
"defective_qty_filled": int(defective_qty_filled),
|
||
}})
|
||
|
||
|
||
@purchase_bp.route('/api/domestic/orders/update_batch', methods=['POST'])
|
||
@login_required
|
||
def domestic_orders_update_batch():
|
||
denied = _require_purchase_operation('orders_domestic', 'edit')
|
||
if denied:
|
||
return denied
|
||
"""Update only a batch belonging to the current order type."""
|
||
data = request.json or {}
|
||
batch_id = data.get('id')
|
||
order_type = data.get('order_type', 'domestic')
|
||
if not batch_id:
|
||
return jsonify({"code": 400, "msg": "缺少批次ID"})
|
||
_ensure_arrival_batches_table()
|
||
batch_rows = query(
|
||
"SELECT order_id, arrival_date, arrival_qty, defective_qty, remark, operator_name, operated_at, "
|
||
"arrival_date_filled, arrival_qty_filled, defective_qty_filled "
|
||
"FROM arrival_batches WHERE id=%s AND order_type=%s",
|
||
(batch_id, order_type),
|
||
)
|
||
if not batch_rows:
|
||
return jsonify({"code": 404, "msg": "批次不存在或不属于当前订单"})
|
||
current = batch_rows[0]
|
||
# 已填写字段不可修改；首次保存时留空的字段允许补填一次，补填后立即锁定。
|
||
update_fields = []
|
||
update_params = []
|
||
supplemented = []
|
||
if data.get('arrival_date') not in (None, ''):
|
||
current_date = current.get('arrival_date')
|
||
if hasattr(current_date, 'isoformat'):
|
||
current_date = current_date.isoformat()
|
||
requested_date = str(data.get('arrival_date') or '')[:10]
|
||
date_locked = order_type != 'packaging' or current.get('arrival_date_filled')
|
||
if date_locked and str(current_date or '')[:10] != requested_date:
|
||
return jsonify({"code": 400, "msg": "到货日期保存后不允许修改"}), 400
|
||
if order_type == 'packaging' and not current.get('arrival_date_filled'):
|
||
update_fields.extend(['arrival_date=%s', 'arrival_date_filled=1'])
|
||
update_params.append(requested_date)
|
||
supplemented.append(f'到货日期={requested_date}')
|
||
if data.get('arrival_qty') not in (None, ''):
|
||
try:
|
||
requested_qty = int(data.get('arrival_qty'))
|
||
except (TypeError, ValueError):
|
||
return jsonify({"code": 400, "msg": "到货数量必须为整数"}), 400
|
||
if requested_qty < 0:
|
||
return jsonify({"code": 400, "msg": "到货数量不能为负数"}), 400
|
||
qty_locked = order_type != 'packaging' or current.get('arrival_qty_filled')
|
||
if qty_locked and requested_qty != int(current.get('arrival_qty') or 0):
|
||
return jsonify({"code": 400, "msg": "到货数量保存后不允许修改"}), 400
|
||
if order_type == 'packaging' and not current.get('arrival_qty_filled'):
|
||
update_fields.extend(['arrival_qty=%s', 'arrival_qty_filled=1'])
|
||
update_params.append(requested_qty)
|
||
supplemented.append(f'到货数量={requested_qty}')
|
||
if data.get('defective_qty') not in (None, ''):
|
||
try:
|
||
requested_defective = int(data.get('defective_qty'))
|
||
except (TypeError, ValueError):
|
||
return jsonify({"code": 400, "msg": "不良品数量必须为整数"}), 400
|
||
defective_locked = current.get('defective_qty_filled')
|
||
if defective_locked and requested_defective != int(current.get('defective_qty') or 0):
|
||
return jsonify({"code": 400, "msg": "不良品数量保存后不允许修改"}), 400
|
||
if not current.get('defective_qty_filled'):
|
||
update_fields.extend(['defective_qty=%s', 'defective_qty_filled=1'])
|
||
update_params.append(requested_defective)
|
||
supplemented.append(f'不良品数量={requested_defective}')
|
||
operator_name = _arrival_operator_name()
|
||
operated_at = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
|
||
old_remark = str(current.get('remark') or '')
|
||
requested_remark = str(data.get('remark') or '')
|
||
final_remark = old_remark
|
||
if requested_remark != old_remark:
|
||
if not requested_remark.startswith(old_remark):
|
||
return jsonify({"code": 400, "msg": "历史备注不允许修改，请在备注末尾追加说明"}), 400
|
||
added = requested_remark[len(old_remark):].strip()
|
||
if added:
|
||
trace = f"[{operated_at} {operator_name or '未知账号'}] {added}"
|
||
final_remark = (old_remark.rstrip() + "\n" if old_remark.strip() else '') + trace
|
||
update_fields.append('remark=%s')
|
||
update_params.append(final_remark)
|
||
if update_fields:
|
||
query(
|
||
"UPDATE arrival_batches SET " + ', '.join(update_fields) + " WHERE id=%s AND order_type=%s",
|
||
tuple(update_params) + (batch_id, order_type),
|
||
)
|
||
sync_order_arrival_totals(current['order_id'], order_type)
|
||
page_name = {'domestic': '国内订单管理', 'overseas': '海外订单管理', 'packaging': '包材订单管理'}.get(order_type, order_type)
|
||
if final_remark != old_remark:
|
||
add_operation_log(
|
||
'到货批次及数量',
|
||
f"追加到货批次备注：{added}（批次ID={batch_id}，订单ID={current['order_id']}）",
|
||
page=page_name,
|
||
field='到货批次及数量',
|
||
)
|
||
if supplemented:
|
||
add_operation_log(
|
||
'到货批次及数量',
|
||
f"补填到货批次字段：{'；'.join(supplemented)}（批次ID={batch_id}，订单ID={current['order_id']}）",
|
||
page=page_name,
|
||
field='到货批次及数量',
|
||
)
|
||
return jsonify({"code": 0, "msg": "更新成功", "data": {
|
||
"remark": final_remark,
|
||
"operator_name": current.get('operator_name') or '',
|
||
"operated_at": current.get('operated_at').strftime('%Y-%m-%d %H:%M:%S')
|
||
if hasattr(current.get('operated_at'), 'strftime') else str(current.get('operated_at') or '')[:19],
|
||
"arrival_date_filled": 1 if current.get('arrival_date_filled') or data.get('arrival_date') not in (None, '') else 0,
|
||
"arrival_qty_filled": 1 if current.get('arrival_qty_filled') or data.get('arrival_qty') not in (None, '') else 0,
|
||
"defective_qty_filled": 1 if current.get('defective_qty_filled') or data.get('defective_qty') not in (None, '') else 0,
|
||
}})
|
||
|
||
|
||
@purchase_bp.route('/api/domestic/orders/delete_batch', methods=['POST'])
|
||
@login_required
|
||
def domestic_orders_delete_batch():
|
||
denied = _require_purchase_operation('orders_domestic', 'edit')
|
||
if denied:
|
||
return denied
|
||
"""Delete only a batch belonging to the current order type."""
|
||
data = request.json or {}
|
||
batch_id = data.get('id')
|
||
order_type = data.get('order_type', 'domestic')
|
||
if not batch_id:
|
||
return jsonify({"code": 400, "msg": "缺少批次ID"})
|
||
_ensure_arrival_batches_table()
|
||
batch_rows = query("SELECT order_id FROM arrival_batches WHERE id=%s AND order_type=%s", (batch_id, order_type))
|
||
if not batch_rows:
|
||
return jsonify({"code": 404, "msg": "批次不存在或不属于当前订单"})
|
||
query("DELETE FROM arrival_batches WHERE id=%s AND order_type=%s", (batch_id, order_type))
|
||
sync_order_arrival_totals(batch_rows[0]['order_id'], order_type)
|
||
page_name = {'domestic': '国内订单管理', 'overseas': '海外订单管理', 'packaging': '包材订单管理'}.get(order_type, order_type)
|
||
add_operation_log('到货批次及数量', f"删除到货批次（批次ID={batch_id}，订单ID={batch_rows[0]['order_id']}）", page=page_name, field='到货批次及数量')
|
||
return jsonify({"code": 0, "msg": "删除成功"})
|
||
|
||
|
||
def sync_order_arrival_totals(order_id, order_type='domestic'):
|
||
"""Sync totals from batches belonging to one exact order."""
|
||
table_map = {
|
||
'domestic': ('domestic_orders', '实际到货日期'),
|
||
'overseas': ('overseas_orders', '实际到货日期'),
|
||
'packaging': ('packaging_orders', '到货日期'),
|
||
}
|
||
if order_type not in table_map:
|
||
return
|
||
table, date_col = table_map[order_type]
|
||
order_rows = query("SELECT `数量` FROM " + table + " WHERE id=%s", (order_id,))
|
||
if not order_rows:
|
||
return
|
||
_ensure_arrival_batches_table()
|
||
aggregate = query("""SELECT COUNT(*) AS batch_count,
|
||
COALESCE(SUM(arrival_qty - COALESCE(defective_qty, 0)),0) AS total,
|
||
MAX(arrival_date) AS latest_date
|
||
FROM arrival_batches
|
||
WHERE order_id=%s AND order_type=%s""", (order_id, order_type))[0]
|
||
order_qty = int(order_rows[0].get('数量') or 0)
|
||
# 批次是明细真源；没有批次时保留导入/人工维护的实际到货数量作为计算基础。
|
||
if int(aggregate.get('batch_count') or 0) > 0:
|
||
total = int(aggregate.get('total') or 0)
|
||
latest_date = aggregate.get('latest_date')
|
||
else:
|
||
current_rows = query(
|
||
"SELECT `实际到货数量`, `" + date_col + "` AS current_arrival_date FROM " + table + " WHERE id=%s",
|
||
(order_id,)
|
||
)
|
||
current = current_rows[0] if current_rows else {}
|
||
total = int(current.get('实际到货数量') or 0)
|
||
latest_date = current.get('current_arrival_date')
|
||
unfinished = order_qty - total
|
||
query("UPDATE " + table + " SET `实际到货数量`=%s, `未到货数`=%s, `" + date_col + "`=%s WHERE id=%s",
|
||
(total, unfinished, latest_date, order_id))
|
||
|
||
|
||
@purchase_bp.route('/api/domestic/orders/add', methods=['POST'])
|
||
@login_required
|
||
def domestic_orders_add():
|
||
denied = _require_purchase_operation('orders_domestic', 'create')
|
||
if denied:
|
||
return denied
|
||
"""新增一行"""
|
||
data = request.json or {}
|
||
if not data.get('货品编号'):
|
||
return jsonify({"code": 400, "msg": "货品编号不能为空"})
|
||
|
||
if '单价' not in data or '仓库' not in data:
|
||
previous_order = _latest_domestic_order_values(data['货品编号'])
|
||
if '单价' not in data and previous_order.get('单价') is not None:
|
||
data['单价'] = previous_order['单价']
|
||
if '仓库' not in data and '仓库' in previous_order:
|
||
data['仓库'] = previous_order['仓库']
|
||
if data.get('金蝶入库') in (None, ''):
|
||
data['金蝶入库'] = '否'
|
||
if data.get('数量') is not None and data.get('未到货数') in (None, ''):
|
||
data['未到货数'] = int(data.get('数量') or 0) - int(data.get('实际到货数量') or 0)
|
||
|
||
fields = ["货品编号","货品名称","供货商","数量","单价","金额","日期","计划下单时间","仓库","下单备注",
|
||
"新旧品","是否审核价格","金蝶采购单","采购员","下单人","进度","旺店通生产单号",
|
||
"是否已录入旺店通","采购开发","实际到货日期","实际到货数量","未到货数",
|
||
"预计到货日期","金蝶入库","状态","父记录"]
|
||
|
||
col_names = []
|
||
values = []
|
||
params = []
|
||
# 默认状态为未完结
|
||
has_status = False
|
||
for f in fields:
|
||
val = data.get(f)
|
||
if val is not None:
|
||
col_names.append(f"`{f}`")
|
||
values.append(f"%s")
|
||
params.append(val)
|
||
if f == '状态':
|
||
has_status = True
|
||
# 如果前端没传状态，默认设为未完结
|
||
if not has_status:
|
||
col_names.append('`状态`')
|
||
values.append('%s')
|
||
params.append('未完结')
|
||
|
||
if not col_names:
|
||
return jsonify({"code": 400, "msg": "没有可用的字段"})
|
||
|
||
sql = f"INSERT INTO domestic_orders ({', '.join(col_names)}) VALUES ({', '.join(values)})"
|
||
query(sql, params)
|
||
return jsonify({"code": 0, "msg": "添加成功"})
|
||
|
||
|
||
@purchase_bp.route('/api/domestic/orders/delete', methods=['POST'])
|
||
@login_required
|
||
def domestic_orders_delete():
|
||
denied = _require_purchase_operation('orders_domestic', 'delete')
|
||
if denied:
|
||
return denied
|
||
"""删除一行"""
|
||
data = request.json
|
||
row_id = data.get('id')
|
||
if not row_id:
|
||
return jsonify({"code": 400, "msg": "参数错误"})
|
||
query("DELETE FROM domestic_orders WHERE id=%s", (row_id,))
|
||
return jsonify({"code": 0, "msg": "删除成功"})
|
||
|
||
|
||
@purchase_bp.route('/api/domestic/orders/by_ids', methods=['POST'])
|
||
@login_required
|
||
def domestic_orders_by_ids():
|
||
denied = _require_purchase_operation('orders_domestic', 'view')
|
||
if denied:
|
||
return denied
|
||
"""根据ID列表获取订单数据（供合同生成弹窗预览用），支持多类型"""
|
||
data = request.json
|
||
ids = data.get('ids', [])
|
||
order_type = data.get('order_type', 'domestic')
|
||
if not ids:
|
||
return jsonify({"code": 400, "msg": "参数错误"})
|
||
ids = [int(i) for i in ids if str(i).isdigit()]
|
||
if not ids:
|
||
return jsonify({"code": 400, "msg": "无效的ID"})
|
||
|
||
# 根据类型选择表和字段映射
|
||
if order_type == 'overseas':
|
||
table = 'overseas_orders'
|
||
code_col = '`产品编码`'
|
||
name_col = '`货品名称`'
|
||
amt_col = '`金额`'
|
||
sup_col = '`供应商`'
|
||
elif order_type == 'packaging':
|
||
table = 'packaging_orders'
|
||
code_col = '`编码`'
|
||
name_col = '`名称`'
|
||
amt_col = '`合计`'
|
||
sup_col = '`供应商`'
|
||
else:
|
||
table = 'domestic_orders'
|
||
code_col = '`货品编号`'
|
||
name_col = '`货品名称`'
|
||
amt_col = '`金额`'
|
||
sup_col = '`供货商`'
|
||
|
||
placeholders = ','.join(['%s'] * len(ids))
|
||
rows = query(
|
||
f"SELECT id, {code_col} AS `编码`, {name_col} AS `名称`, `数量`, `单价`, {amt_col} AS `金额`, {sup_col} AS `供货商` FROM {table} WHERE id IN ({placeholders}) ORDER BY id",
|
||
ids
|
||
)
|
||
for r in rows:
|
||
for k in ['数量', '单价', '金额']:
|
||
if r.get(k) is None:
|
||
r[k] = 0
|
||
else:
|
||
try:
|
||
r[k] = float(r[k])
|
||
except:
|
||
r[k] = 0
|
||
return jsonify({"code": 0, "data": rows})
|
||
|
||
|
||
# ─── 海外订单管理 API ───
|
||
@purchase_bp.route('/api/overseas/orders/list', methods=['GET', 'POST'])
|
||
@login_required
|
||
def overseas_orders_list():
|
||
denied = _require_purchase_operation('orders_overseas', 'view')
|
||
if denied:
|
||
return denied
|
||
"""海外订单列表"""
|
||
page = int(request.args.get('page', 1))
|
||
size = int(request.args.get('size', 100))
|
||
search = request.args.get('search', '')
|
||
status_filter = request.args.get('status', '')
|
||
supplier_filter = request.args.get('supplier', '')
|
||
orderer_filter = request.args.get('orderer', '')
|
||
body = request.get_json(silent=True) if request.method == 'POST' else None
|
||
body = body if isinstance(body, dict) else {}
|
||
order_filter_str = request.args.get('order_filter', '') or ''
|
||
if body.get('order_filter') is not None:
|
||
order_filter_str = json.dumps(body.get('order_filter') or {}, ensure_ascii=False)
|
||
|
||
where = []
|
||
params = []
|
||
|
||
if search:
|
||
where.append("(`产品编码` LIKE %s OR `货品名称` LIKE %s OR `供应商` LIKE %s OR `下单备注` LIKE %s)")
|
||
kw = f'%{search}%'
|
||
params.extend([kw, kw, kw, kw])
|
||
if status_filter:
|
||
where.append("`状态` = %s")
|
||
params.append(status_filter)
|
||
if supplier_filter:
|
||
where.append("`供应商` LIKE %s")
|
||
params.append(f'%{supplier_filter}%')
|
||
if orderer_filter:
|
||
where.append("`下单人` LIKE %s")
|
||
params.append(f'%{orderer_filter}%')
|
||
# 内联处理表头筛选
|
||
if order_filter_str:
|
||
import json as _json
|
||
try:
|
||
_filters = _json.loads(order_filter_str)
|
||
for _f, _c in _filters.items():
|
||
_db = _f
|
||
if not isinstance(_c, dict):
|
||
continue
|
||
_t = _c.get('type', '')
|
||
if _t == 'search':
|
||
_v = _c.get('value', '')
|
||
if _v:
|
||
where.append('`' + _db + '` LIKE %s')
|
||
params.append('%' + _v + '%')
|
||
elif _t == 'list':
|
||
_vs = _c.get('values', [])
|
||
if _vs:
|
||
_non_empty = [x for x in _vs if x != '__EMPTY__']
|
||
_list_parts = []
|
||
if _non_empty:
|
||
_list_parts.extend(_build_exact_list_parts(_db, _non_empty, params))
|
||
if '__EMPTY__' in _vs:
|
||
_list_parts.append("(`" + _db + "` IS NULL OR `" + _db + "` = '')")
|
||
if _list_parts:
|
||
where.append('(' + ' OR '.join(_list_parts) + ')')
|
||
elif _t == 'num':
|
||
_op = _c.get('cond', '')
|
||
_vl = _c.get('val', '')
|
||
_om = {'eq':'=','neq':'!=','gt':'>','gte':'>=','lt':'<','lte':'<='}
|
||
if _op == 'range' and _vl:
|
||
_parts = [x.strip() for x in _vl.split(',') if x.strip()]
|
||
if len(_parts) == 2:
|
||
where.append('`' + _db + '` >= %s AND `' + _db + '` <= %s')
|
||
params.extend([float(_parts[0]), float(_parts[1])])
|
||
elif _op in _om:
|
||
try:
|
||
_nv = float(_vl)
|
||
where.append('`' + _db + '` ' + _om[_op] + ' %s')
|
||
params.append(_nv)
|
||
except ValueError:
|
||
pass
|
||
except Exception:
|
||
pass
|
||
|
||
where_clause = " WHERE " + " AND ".join(where) if where else ""
|
||
offset = (page - 1) * size
|
||
|
||
overseas_source = _order_table_with_product_type('overseas_orders', '产品编码')
|
||
cnt = query(f"SELECT COUNT(*) AS cnt FROM {overseas_source}{where_clause}", params)
|
||
total = cnt[0]['cnt'] if cnt else 0
|
||
|
||
order_by = _resolve_order_sort(order_filter_str, 'overseas', "IFNULL(created_at,'1970-01-01') DESC, `计划下单时间` DESC, `日期` DESC")
|
||
rows = query(f"SELECT * FROM {overseas_source}{where_clause} ORDER BY {order_by} LIMIT %s OFFSET %s",
|
||
params + [size, offset])
|
||
_enrich_order_product_types(rows, '产品编码')
|
||
|
||
return jsonify({"code": 0, "data": {"rows": rows, "total": total, "page": page, "size": size}})
|
||
|
||
|
||
@purchase_bp.route('/api/overseas/orders/filters')
|
||
@login_required
|
||
def overseas_orders_filters():
|
||
denied = _require_purchase_operation('orders_overseas', 'view')
|
||
if denied:
|
||
return denied
|
||
suppliers = query("SELECT DISTINCT `供应商` FROM overseas_orders WHERE `供应商` IS NOT NULL AND `供应商` != '' ORDER BY `供应商`")
|
||
statuses = query("SELECT DISTINCT `状态` FROM overseas_orders WHERE `状态` IS NOT NULL AND `状态` != '' ORDER BY `状态`")
|
||
orderers = query("SELECT DISTINCT `下单人` FROM overseas_orders WHERE `下单人` IS NOT NULL AND `下单人` != '' ORDER BY `下单人`")
|
||
return jsonify({"code": 0, "data": {"suppliers": [s['供应商'] for s in suppliers], "statuses": [s['状态'] for s in statuses], "orderers": [o['下单人'] for o in orderers]}})
|
||
|
||
|
||
@purchase_bp.route('/api/overseas/orders/update', methods=['POST'])
|
||
@login_required
|
||
def overseas_orders_update():
|
||
denied = _require_purchase_operation('orders_overseas', 'edit')
|
||
if denied:
|
||
return denied
|
||
data = request.json
|
||
row_id = data.get('id')
|
||
field = data.get('field')
|
||
value = data.get('value')
|
||
if not row_id or not field:
|
||
return jsonify({"code": 400, "msg": "参数错误"})
|
||
allowed_fields = ['日期','计划下单时间','产品编码','单价','数量','金额','供应商','仓库','货品名称','新旧品',
|
||
'是否已做采购单','是否做入库','采购员','下单人','进度','下单备注','采购开发',
|
||
'旺店通生产单号','是否已录入到旺店通','实际到货日期','实际到货数量','待提数量','未到货数',
|
||
'预计到货日期','状态','是否审核价格',
|
||
'platform','订单下达供应商时间','total_support_days','lead_time']
|
||
if field not in allowed_fields:
|
||
return jsonify({"code": 400, "msg": f"不允许修改字段: {field}"})
|
||
# 空字符串转NULL（适配日期/数字列）
|
||
dt_fields = ['日期','计划下单时间','预计到货日期','实际到货日期','订单下达供应商时间']
|
||
numeric_fields = ['单价','数量','金额','实际到货数量','未到货数','待提数量','total_support_days','lead_time']
|
||
if value == '' and (field in dt_fields or field in numeric_fields):
|
||
value = None
|
||
orderer_sync = None
|
||
if field == '下单人':
|
||
rows = query("SELECT `产品编码`, `计划下单时间` FROM overseas_orders WHERE id=%s", (row_id,))
|
||
if rows: orderer_sync = (rows[0].get('产品编码'), rows[0].get('计划下单时间'))
|
||
query(f"UPDATE overseas_orders SET `{field}`=%s WHERE id=%s", (value, row_id))
|
||
if field == '下单人' and orderer_sync:
|
||
_sync_backup_orderer(orderer_sync[0], orderer_sync[1], 'product_orderer', value)
|
||
if field in ('数量', '实际到货日期', '实际到货数量', '未到货数'):
|
||
sync_order_arrival_totals(row_id, 'overseas')
|
||
return jsonify({"code": 0, "msg": "更新成功"})
|
||
|
||
|
||
@purchase_bp.route('/api/overseas/orders/update_fields', methods=['POST'])
|
||
@login_required
|
||
def overseas_orders_update_fields():
|
||
"""批量更新海外订单字段（详情弹窗保存用，只记录一条合并日志）"""
|
||
denied = _require_purchase_operation('orders_overseas', 'edit')
|
||
if denied:
|
||
return denied
|
||
data = request.json or {}
|
||
row_id = data.get('id')
|
||
fields = data.get('fields') or {}
|
||
if not row_id or not fields:
|
||
return jsonify({"code": 400, "msg": "参数错误"})
|
||
allowed_fields = ['日期','计划下单时间','产品编码','单价','数量','金额','供应商','仓库','货品名称','新旧品',
|
||
'是否已做采购单','是否做入库','采购员','下单人','进度','下单备注','采购开发',
|
||
'旺店通生产单号','是否已录入到旺店通','实际到货日期','实际到货数量','待提数量','未到货数',
|
||
'预计到货日期','状态','是否审核价格',
|
||
'platform','订单下达供应商时间','total_support_days','lead_time']
|
||
dt_fields = ['日期','计划下单时间','预计到货日期','实际到货日期','订单下达供应商时间']
|
||
numeric_fields = ['单价','数量','金额','实际到货数量','未到货数','待提数量','total_support_days','lead_time']
|
||
changed_parts = []
|
||
orderer_sync = None
|
||
if '下单人' in fields:
|
||
rows = query("SELECT `产品编码`, `计划下单时间` FROM overseas_orders WHERE id=%s", (row_id,))
|
||
if rows: orderer_sync = (rows[0].get('产品编码'), rows[0].get('计划下单时间'))
|
||
for field, value in fields.items():
|
||
if field not in allowed_fields:
|
||
continue
|
||
if value == '' and (field in dt_fields or field in numeric_fields):
|
||
value = None
|
||
query(f"UPDATE overseas_orders SET `{field}`=%s WHERE id=%s", (value, row_id))
|
||
changed_parts.append(f'{field}={value if value is not None else "空"}')
|
||
if field in ('数量', '实际到货日期', '实际到货数量', '未到货数'):
|
||
sync_order_arrival_totals(row_id, 'overseas')
|
||
if orderer_sync:
|
||
_sync_backup_orderer(orderer_sync[0], orderer_sync[1], 'product_orderer', fields.get('下单人'))
|
||
if changed_parts:
|
||
add_operation_log('订单字段编辑', '；'.join(changed_parts) + f'（订单ID={row_id}）', page='海外订单管理', field='；'.join(fields.keys()))
|
||
return jsonify({"code": 0, "msg": "更新成功", "changed": len(changed_parts)})
|
||
|
||
|
||
@purchase_bp.route('/api/overseas/orders/add', methods=['POST'])
|
||
@login_required
|
||
def overseas_orders_add():
|
||
denied = _require_purchase_operation('orders_overseas', 'create')
|
||
if denied:
|
||
return denied
|
||
data = request.json
|
||
if not data.get('产品编码'):
|
||
return jsonify({"code": 400, "msg": "产品编码不能为空"})
|
||
fields = ['产品编码','货品名称','供应商','数量','单价','金额','日期','计划下单时间','仓库','下单备注',
|
||
'新旧品','是否已做采购单','是否做入库','采购员','下单人','进度','旺店通生产单号',
|
||
'是否已录入到旺店通','采购开发','实际到货日期','实际到货数量','待提数量','未到货数','预计到货日期','状态']
|
||
col_names, values, params = [], [], []
|
||
has_status = False
|
||
for f in fields:
|
||
val = data.get(f)
|
||
if val is not None:
|
||
col_names.append(f"`{f}`")
|
||
values.append("%s")
|
||
params.append(val)
|
||
if f == '状态':
|
||
has_status = True
|
||
# 默认状态为未完结
|
||
if not has_status:
|
||
col_names.append('`状态`')
|
||
values.append('%s')
|
||
params.append('未完结')
|
||
if not col_names:
|
||
return jsonify({"code": 400, "msg": "没有可用的字段"})
|
||
query(f"INSERT INTO overseas_orders ({', '.join(col_names)}) VALUES ({', '.join(values)})", params)
|
||
return jsonify({"code": 0, "msg": "添加成功"})
|
||
|
||
|
||
@purchase_bp.route('/api/overseas/orders/delete', methods=['POST'])
|
||
@login_required
|
||
def overseas_orders_delete():
|
||
denied = _require_purchase_operation('orders_overseas', 'delete')
|
||
if denied:
|
||
return denied
|
||
row_id = request.json.get('id')
|
||
if not row_id:
|
||
return jsonify({"code": 400, "msg": "参数错误"})
|
||
query("DELETE FROM overseas_orders WHERE id=%s", (row_id,))
|
||
return jsonify({"code": 0, "msg": "删除成功"})
|
||
|
||
|
||
@purchase_bp.route('/api/purchase/orders/update_item', methods=['POST'])
|
||
@login_required
|
||
def purchase_orders_update_item():
|
||
denied = _require_purchase_operation('purchase_ready', 'edit')
|
||
if denied:
|
||
return denied
|
||
data = request.json
|
||
item_id = data.get('item_id')
|
||
order_qty = data.get('order_qty')
|
||
unit_price = data.get('unit_price')
|
||
if not item_id:
|
||
return jsonify({"code": 400, "msg": "参数错误"})
|
||
|
||
if order_qty is not None:
|
||
query("UPDATE purchase_order_items SET order_qty=%s WHERE id=%s", (int(order_qty), item_id))
|
||
if unit_price is not None:
|
||
query("UPDATE purchase_order_items SET unit_price=%s WHERE id=%s", (float(unit_price), item_id))
|
||
|
||
query("UPDATE purchase_order_items SET amount = order_qty * unit_price WHERE id=%s", (item_id,))
|
||
|
||
query("""
|
||
UPDATE purchase_orders o
|
||
SET o.total_qty = (SELECT COALESCE(SUM(order_qty),0) FROM purchase_order_items WHERE order_id=o.id),
|
||
o.total_amount = (SELECT COALESCE(SUM(amount),0) FROM purchase_order_items WHERE order_id=o.id)
|
||
WHERE o.id = (SELECT order_id FROM purchase_order_items WHERE id=%s)
|
||
""", (item_id,))
|
||
|
||
return jsonify({"code": 0, "msg": "更新成功"})
|
||
|
||
|
||
# ─── 包材订单管理 API ───
|
||
@purchase_bp.route('/api/packaging/orders/list', methods=['GET', 'POST'])
|
||
@login_required
|
||
def packaging_orders_list():
|
||
denied = _require_purchase_operation('orders_packaging', 'view')
|
||
if denied:
|
||
return denied
|
||
page = int(request.args.get('page', 1))
|
||
size = int(request.args.get('size', 100))
|
||
search = request.args.get('search', '')
|
||
status_filter = request.args.get('status', '')
|
||
supplier_filter = request.args.get('supplier', '')
|
||
orderer_filter = request.args.get('orderer', '')
|
||
body = request.get_json(silent=True) if request.method == 'POST' else None
|
||
body = body if isinstance(body, dict) else {}
|
||
order_filter_str = request.args.get('order_filter', '') or ''
|
||
if body.get('order_filter') is not None:
|
||
order_filter_str = json.dumps(body.get('order_filter') or {}, ensure_ascii=False)
|
||
where = []
|
||
params = []
|
||
if search:
|
||
where.append("(`编码` LIKE %s OR `名称` LIKE %s OR `供应商` LIKE %s OR `进度` LIKE %s)")
|
||
kw = f'%{search}%'
|
||
params.extend([kw, kw, kw, kw])
|
||
if status_filter:
|
||
where.append("`状态` = %s")
|
||
params.append(status_filter)
|
||
if supplier_filter:
|
||
where.append("`供应商` LIKE %s")
|
||
params.append(f'%{supplier_filter}%')
|
||
if orderer_filter:
|
||
where.append("`采购下单人` LIKE %s")
|
||
params.append(f'%{orderer_filter}%')
|
||
# 内联处理表头筛选
|
||
if order_filter_str:
|
||
import json as _json
|
||
try:
|
||
_filters = _json.loads(order_filter_str)
|
||
for _f, _c in _filters.items():
|
||
_db = _f
|
||
if not isinstance(_c, dict):
|
||
continue
|
||
_t = _c.get('type', '')
|
||
if _t == 'search':
|
||
_v = _c.get('value', '')
|
||
if _v:
|
||
where.append('`' + _db + '` LIKE %s')
|
||
params.append('%' + _v + '%')
|
||
elif _t == 'list':
|
||
_vs = _c.get('values', [])
|
||
if _vs:
|
||
_non_empty = [x for x in _vs if x != '__EMPTY__']
|
||
_list_parts = []
|
||
if _non_empty:
|
||
_list_parts.extend(_build_exact_list_parts(_db, _non_empty, params))
|
||
if '__EMPTY__' in _vs:
|
||
_list_parts.append("(`" + _db + "` IS NULL OR `" + _db + "` = '')")
|
||
if _list_parts:
|
||
where.append('(' + ' OR '.join(_list_parts) + ')')
|
||
elif _t == 'num':
|
||
_op = _c.get('cond', '')
|
||
_vl = _c.get('val', '')
|
||
_om = {'eq':'=','neq':'!=','gt':'>','gte':'>=','lt':'<','lte':'<='}
|
||
if _op == 'range' and _vl:
|
||
_parts = [x.strip() for x in _vl.split(',') if x.strip()]
|
||
if len(_parts) == 2:
|
||
where.append('`' + _db + '` >= %s AND `' + _db + '` <= %s')
|
||
params.extend([float(_parts[0]), float(_parts[1])])
|
||
elif _op in _om:
|
||
try:
|
||
_nv = float(_vl)
|
||
where.append('`' + _db + '` ' + _om[_op] + ' %s')
|
||
params.append(_nv)
|
||
except ValueError:
|
||
pass
|
||
except Exception:
|
||
pass
|
||
where_clause = " WHERE " + " AND ".join(where) if where else ""
|
||
offset = (page - 1) * size
|
||
packaging_source = _packaging_order_source()
|
||
cnt = query(f"SELECT COUNT(*) AS cnt FROM {packaging_source}{where_clause}", params)
|
||
total = cnt[0]['cnt'] if cnt else 0
|
||
order_by = _resolve_order_sort(order_filter_str, 'packaging', '`计划下单时间` DESC, id DESC')
|
||
rows = query(f"SELECT * FROM {packaging_source}{where_clause} ORDER BY {order_by} LIMIT %s OFFSET %s", params + [size, offset])
|
||
supplier_full_names = _supplier_full_name_map()
|
||
for row in rows:
|
||
supplier = (row.get('供应商') or '').strip()
|
||
if supplier in supplier_full_names:
|
||
row['供应商'] = supplier_full_names[supplier]
|
||
_enrich_order_product_types(rows, '编码', '来源产品编码')
|
||
filter_field_rows('order_packaging', rows, session.get('user_id'), session.get('role'),
|
||
page_view=bool(role_required('orders_packaging')),
|
||
page_edit=operation_required('orders_packaging', 'edit'))
|
||
return jsonify({"code": 0, "data": {"rows": rows, "total": total, "page": page, "size": size}})
|
||
|
||
|
||
@purchase_bp.route('/api/packaging/orders/filters')
|
||
@login_required
|
||
def packaging_orders_filters():
|
||
denied = _require_purchase_operation('orders_packaging', 'view')
|
||
if denied:
|
||
return denied
|
||
suppliers = query("SELECT DISTINCT `供应商` FROM packaging_orders WHERE `供应商` IS NOT NULL AND `供应商` != '' ORDER BY `供应商`")
|
||
supplier_full_names = _supplier_full_name_map()
|
||
supplier_options = sorted({
|
||
supplier_full_names.get((supplier.get('供应商') or '').strip(), (supplier.get('供应商') or '').strip())
|
||
for supplier in suppliers if (supplier.get('供应商') or '').strip()
|
||
})
|
||
orderers = query("SELECT DISTINCT `采购下单人` FROM packaging_orders WHERE `采购下单人` IS NOT NULL AND `采购下单人` != '' ORDER BY `采购下单人`")
|
||
return jsonify({"code": 0, "data": {"suppliers": supplier_options, "statuses": list(PACKAGING_ORDER_STATUSES), "orderers": [o['采购下单人'] for o in orderers]}})
|
||
|
||
|
||
def _sync_packaging_price_to_backup(material_code, source_product_code, unit_price):
|
||
"""Sync a packaging order price into the matching ordered backup BOM.
|
||
|
||
同一商品可能存在多条 ordered 历史备份，这里只同步最新一条（当前批次）。
|
||
"""
|
||
if not material_code:
|
||
return 0
|
||
if source_product_code:
|
||
backup_rows = query(
|
||
"""SELECT id, product_code, bom_items FROM pending_orders
|
||
WHERE status='ordered' AND product_code=%s AND bom_items IS NOT NULL""",
|
||
(source_product_code,)
|
||
)
|
||
else:
|
||
backup_rows = query(
|
||
"""SELECT id, product_code, bom_items FROM pending_orders
|
||
WHERE status='ordered' AND bom_items IS NOT NULL"""
|
||
)
|
||
|
||
synced = 0
|
||
normalized_price = float(unit_price or 0)
|
||
for backup in backup_rows:
|
||
try:
|
||
bom = json.loads(backup['bom_items']) if isinstance(backup['bom_items'], str) else backup['bom_items']
|
||
except (TypeError, ValueError):
|
||
continue
|
||
changed = False
|
||
for item in bom or []:
|
||
if str(item.get('material_code') or '').strip() == material_code:
|
||
item['unit_price'] = normalized_price
|
||
changed = True
|
||
if changed:
|
||
# 只更新该备份行自身（按 id），避免影响同商品其他历史备份
|
||
query("UPDATE pending_orders SET bom_items=%s WHERE id=%s AND status='ordered'",
|
||
(json.dumps(bom, ensure_ascii=False), backup['id']))
|
||
synced += 1
|
||
return synced
|
||
|
||
|
||
@purchase_bp.route('/api/packaging/orders/update', methods=['POST'])
|
||
@login_required
|
||
def packaging_orders_update():
|
||
denied = _require_purchase_operation('orders_packaging', 'edit')
|
||
if denied:
|
||
return denied
|
||
data = request.json
|
||
row_id = data.get('id')
|
||
field = data.get('field')
|
||
value = data.get('value')
|
||
if not row_id or not field:
|
||
return jsonify({"code": 400, "msg": "参数错误"})
|
||
allowed = ['日期','计划下单时间','编码','名称','单价','数量','合计','供应商','成品供应商','仓库到货','进度','是否已做采购单','是否审核价格',
|
||
'是否已做入库','采购下单人','下单人','旺店通编号','是否已录入旺店通','到货日期','状态','做货天数','包材开发','下单备注',
|
||
'采购计划','产品种类','订单下达时间','有无新稿件','包材异常状态','待提数量','新旧品']
|
||
if field not in allowed:
|
||
return jsonify({"code": 400, "msg": f"不允许修改字段: {field}"})
|
||
if field == '新旧品' and value not in ('新品', '旧品', ''):
|
||
return jsonify({"code": 400, "msg": "新旧品只能选择新品、旧品或无"})
|
||
if field == '状态' and value not in PACKAGING_ORDER_STATUSES:
|
||
return jsonify({"code": 400, "msg": "包材订单状态只能选择未完结或已完结"})
|
||
# 数值字段空字符串转NULL
|
||
numeric_fields = ['单价','数量','合计']
|
||
if value == '' and field in numeric_fields:
|
||
value = None
|
||
|
||
if field == '成品供应商':
|
||
try:
|
||
product_code, full_name = _set_packaging_finished_supplier(row_id, value)
|
||
except ValueError as exc:
|
||
return jsonify({"code": 400, "msg": str(exc)})
|
||
add_operation_log('订单字段编辑', f'成品供应商={full_name or "空"}（订单ID={row_id}，成品编码={product_code}）',
|
||
page='包材订单管理', field='成品供应商')
|
||
return jsonify({"code": 0, "msg": "更新成功", "value": full_name})
|
||
|
||
packaging_row = None
|
||
if field == '单价':
|
||
rows = query("SELECT `编码`, `来源产品编码` FROM packaging_orders WHERE id=%s", (row_id,))
|
||
if not rows:
|
||
return jsonify({"code": 404, "msg": "未找到包材订单"})
|
||
packaging_row = rows[0]
|
||
|
||
orderer_sync = None
|
||
if field == '下单人':
|
||
rows = query("SELECT `来源产品编码`, `下单时间` FROM packaging_orders WHERE id=%s", (row_id,))
|
||
if rows: orderer_sync = (rows[0].get('来源产品编码'), rows[0].get('下单时间'))
|
||
query(f"UPDATE packaging_orders SET `{field}`=%s WHERE id=%s", (value, row_id))
|
||
if field == '下单人' and orderer_sync:
|
||
_sync_backup_orderer(orderer_sync[0], orderer_sync[1], 'packaging_orderer', value)
|
||
if field == '数量':
|
||
sync_order_arrival_totals(row_id, 'packaging')
|
||
synced = 0
|
||
if packaging_row:
|
||
synced = _sync_packaging_price_to_backup(
|
||
str(packaging_row.get('编码') or '').strip(),
|
||
str(packaging_row.get('来源产品编码') or '').strip(),
|
||
value
|
||
)
|
||
return jsonify({"code": 0, "msg": "更新成功", "backup_synced": synced})
|
||
|
||
|
||
@purchase_bp.route('/api/packaging/orders/update_fields', methods=['POST'])
|
||
@login_required
|
||
def packaging_orders_update_fields():
|
||
"""批量更新包材订单字段（详情弹窗保存用，只记录一条合并日志）"""
|
||
denied = _require_purchase_operation('orders_packaging', 'edit')
|
||
if denied:
|
||
return denied
|
||
data = request.json or {}
|
||
row_id = data.get('id')
|
||
fields = data.get('fields') or {}
|
||
if not row_id or not fields:
|
||
return jsonify({"code": 400, "msg": "参数错误"})
|
||
allowed = ['日期','计划下单时间','编码','名称','单价','数量','合计','供应商','成品供应商','仓库到货','进度','是否已做采购单','是否审核价格',
|
||
'是否已做入库','采购下单人','下单人','旺店通编号','是否已录入旺店通','到货日期','状态','做货天数','包材开发','下单备注',
|
||
'采购计划','产品种类','订单下达时间','有无新稿件','包材异常状态','待提数量','新旧品']
|
||
numeric_fields = ['单价','数量','合计']
|
||
if '新旧品' in fields and fields['新旧品'] not in ('新品', '旧品', ''):
|
||
return jsonify({"code": 400, "msg": "新旧品只能选择新品、旧品或无"})
|
||
if '状态' in fields and fields['状态'] not in PACKAGING_ORDER_STATUSES:
|
||
return jsonify({"code": 400, "msg": "包材订单状态只能选择未完结或已完结"})
|
||
changed_parts = []
|
||
orderer_sync = None
|
||
if '下单人' in fields:
|
||
rows = query("SELECT `来源产品编码`, `下单时间` FROM packaging_orders WHERE id=%s", (row_id,))
|
||
if rows: orderer_sync = (rows[0].get('来源产品编码'), rows[0].get('下单时间'))
|
||
packaging_row = None
|
||
if '单价' in fields:
|
||
rows = query("SELECT `编码`, `来源产品编码` FROM packaging_orders WHERE id=%s", (row_id,))
|
||
if rows:
|
||
packaging_row = rows[0]
|
||
for field, value in fields.items():
|
||
if field not in allowed:
|
||
continue
|
||
if field == '成品供应商':
|
||
try:
|
||
product_code, full_name = _set_packaging_finished_supplier(row_id, value)
|
||
except ValueError as exc:
|
||
return jsonify({"code": 400, "msg": str(exc)})
|
||
changed_parts.append(f'成品供应商={full_name or "空"}（成品编码={product_code}）')
|
||
continue
|
||
if value == '' and field in numeric_fields:
|
||
value = None
|
||
query(f"UPDATE packaging_orders SET `{field}`=%s WHERE id=%s", (value, row_id))
|
||
changed_parts.append(f'{field}={value if value is not None else "空"}')
|
||
if field == '数量':
|
||
sync_order_arrival_totals(row_id, 'packaging')
|
||
if packaging_row and '单价' in fields:
|
||
_sync_packaging_price_to_backup(
|
||
str(packaging_row.get('编码') or '').strip(),
|
||
str(packaging_row.get('来源产品编码') or '').strip(),
|
||
fields.get('单价')
|
||
)
|
||
if orderer_sync:
|
||
_sync_backup_orderer(orderer_sync[0], orderer_sync[1], 'packaging_orderer', fields.get('下单人'))
|
||
if changed_parts:
|
||
add_operation_log('订单字段编辑', '；'.join(changed_parts) + f'（订单ID={row_id}）', page='包材订单管理', field='；'.join(fields.keys()))
|
||
return jsonify({"code": 0, "msg": "更新成功", "changed": len(changed_parts)})
|
||
|
||
|
||
@purchase_bp.route('/api/packaging/orders/add', methods=['POST'])
|
||
@login_required
|
||
def packaging_orders_add():
|
||
denied = _require_purchase_operation('orders_packaging', 'create')
|
||
if denied:
|
||
return denied
|
||
data = request.json or {}
|
||
if not data.get('编码'):
|
||
return jsonify({"code": 400, "msg": "编码不能为空"})
|
||
|
||
material_code = data['编码']
|
||
previous_order = _latest_packaging_order_values(material_code)
|
||
if '单价' not in data and previous_order.get('单价') is not None:
|
||
data['单价'] = previous_order['单价']
|
||
if '仓库到货' not in data and '仓库到货' in previous_order:
|
||
data['仓库到货'] = previous_order['仓库到货']
|
||
data['供应商'] = _packaging_supplier_full_name(material_code, data.get('供应商', ''))
|
||
|
||
fields = ['编码','名称','供应商','数量','单价','合计','日期','计划下单时间','仓库到货','进度','是否已做采购单',
|
||
'是否已做入库','采购下单人','旺店通编号','是否已录入旺店通','到货日期','状态','做货天数','包材开发']
|
||
col_names, values, params = [], [], []
|
||
for f in fields:
|
||
val = data.get(f)
|
||
if val is not None:
|
||
col_names.append(f"`{f}`")
|
||
values.append("%s")
|
||
params.append(val)
|
||
query(f"INSERT INTO packaging_orders ({', '.join(col_names)}) VALUES ({', '.join(values)})", params)
|
||
return jsonify({"code": 0, "msg": "添加成功"})
|
||
|
||
|
||
@purchase_bp.route('/api/packaging/orders/delete', methods=['POST'])
|
||
@login_required
|
||
def packaging_orders_delete():
|
||
denied = _require_purchase_operation('orders_packaging', 'delete')
|
||
if denied:
|
||
return denied
|
||
row_id = request.json.get('id')
|
||
if not row_id:
|
||
return jsonify({"code": 400, "msg": "参数错误"})
|
||
query("DELETE FROM packaging_orders WHERE id=%s", (row_id,))
|
||
return jsonify({"code": 0, "msg": "删除成功"})
|
||
|
||
|
||
# ─── 成品提货表 API ───
|
||
def _finished_order_progress_map():
|
||
"""读取国内/海外未完结订单的进度，按最早下单时间为每个成品取统一进度。"""
|
||
return unfinished_order_progress_map()
|
||
|
||
|
||
def _finished_inventory_maps():
|
||
"""提货可用库存排除千羽仓，千羽仓按最新库存日单独汇总。"""
|
||
available = dict(compute_cloud_inventory_cached())
|
||
rows = query("""
|
||
SELECT product_code, SUM(available_qty) AS quantity
|
||
FROM inventory_detail
|
||
WHERE data_date = (SELECT MAX(data_date) FROM inventory_detail)
|
||
AND warehouse_code REGEXP '^[0-9]+$'
|
||
AND CAST(warehouse_code AS UNSIGNED) = 35
|
||
GROUP BY product_code
|
||
""")
|
||
qianyu = {r['product_code']: int(r['quantity'] or 0) for r in rows}
|
||
cloud_35 = query("""
|
||
SELECT warehouse_code FROM warehouses
|
||
WHERE warehouse_code REGEXP '^[0-9]+$'
|
||
AND CAST(warehouse_code AS UNSIGNED) = 35
|
||
AND FIND_IN_SET('云仓', warehouse_property) > 0
|
||
LIMIT 1
|
||
""")
|
||
if cloud_35:
|
||
for code, quantity in qianyu.items():
|
||
available[code] = available.get(code, 0) - quantity
|
||
return available, qianyu
|
||
|
||
|
||
def _finished_planning_rows():
|
||
"""以计划预测的成品集合为主，补入提货表的可编辑备注字段。"""
|
||
groups = _personnel_group_members()
|
||
products = query("""
|
||
SELECT p.product_code, p.product_name, p.brand, p.product_type, p.created_at,
|
||
p.lead_time AS 生产货期, p.logistics_time AS 物流时间,
|
||
COALESCE(NULLIF(s.supplier_name, ''), NULLIF(s.short_name, ''), p.supplier_name_match) AS 供应商名称,
|
||
p.procurement_follower AS 采购跟单, p.procurement_planner AS 采购计划
|
||
FROM products p
|
||
LEFT JOIN suppliers s ON p.supplier_code = s.supplier_code
|
||
OR p.supplier_name_match = s.short_name
|
||
OR p.supplier_name_match = s.contract_short_name
|
||
WHERE p.product_type NOT IN ('包材', '其他')
|
||
AND p.product_code NOT IN (SELECT product_code FROM plan_hidden)
|
||
AND NOT EXISTS (
|
||
SELECT 1 FROM brand_information bi
|
||
WHERE CONVERT(TRIM(bi.brand) USING utf8mb4) COLLATE utf8mb4_unicode_ci =
|
||
CONVERT(TRIM(p.brand) USING utf8mb4) COLLATE utf8mb4_unicode_ci
|
||
AND TRIM(bi.category) = '海外'
|
||
)
|
||
AND p.deleted_at IS NULL
|
||
ORDER BY p.product_code ASC
|
||
""")
|
||
saved = query("SELECT * FROM finished_products")
|
||
saved_by_code = {str(r.get('货品编号') or '').strip(): r for r in saved
|
||
if str(r.get('货品编号') or '').strip()}
|
||
sales = compute_product_sales_cached()
|
||
# 成品提货表的库存/销量字段与“计划预测-国内品”保持云仓口径一致。
|
||
# 保留普通库存映射供通用计划字段计算，列表字段在下方明确覆盖为云仓口径。
|
||
inv_map = compute_product_inventory_cached()
|
||
cloud_inv_map, qianyu_inv_map = _finished_inventory_maps()
|
||
from services.inventory_calc import compute_product_inventory_15
|
||
inv15_map = compute_product_inventory_15()
|
||
transit_map = compute_product_in_transit_cached()
|
||
extended_sales = compute_product_sales_extended_cached()
|
||
# 成品提货详情和外部“产品进度”列使用同一套国内/海外订单进度来源。
|
||
finished_progress_map = _finished_order_progress_map()
|
||
sp_map = {r['trend_type']: r for r in sales_predict_config_cached()}
|
||
gc = _ensure_global_config()
|
||
result = []
|
||
for product in products:
|
||
code = product.get('product_code', '')
|
||
row = dict(product)
|
||
row['产品种类'] = product.get('product_type', '')
|
||
row = _enrich_row_with_planning_data(
|
||
row, sales, inv_map, inv15_map, transit_map, sp_map, gc,
|
||
cloud_inv_map=cloud_inv_map, extended_sales=extended_sales
|
||
)
|
||
# 仅成品提货口径拆分千羽仓，不影响计划预测的云仓汇总。
|
||
row['可用库存'] = row.get('云仓库存', 0) or 0
|
||
row['千羽仓库存'] = qianyu_inv_map.get(code, 0)
|
||
row['昨日销量'] = row.get('云仓昨日销量', 0) or 0
|
||
row['3天均销量'] = row.get('云仓3天平均销量', 0) or 0
|
||
row['7天均销量'] = row.get('云仓7天平均销量', 0) or 0
|
||
row['15天均销量'] = row.get('云仓14天平均销量', 0) or 0
|
||
# 支撑天数改为云仓可用库存 / 云仓昨日销量；昨日销量为0时按999展示。
|
||
cloud_inventory = float(row.get('可用库存', 0) or 0)
|
||
cloud_yesterday = float(row.get('昨日销量', 0) or 0)
|
||
row['支撑天数'] = round(cloud_inventory / cloud_yesterday, 1) if cloud_yesterday > 0 else 999
|
||
# 采购在途取最新库存日期下所有仓库 purchase_in_transit 合计。
|
||
row['采购在途'] = transit_map.get(code, {}).get('采购在途', 0)
|
||
# 采购总数量改为最新库存日期下的生产在途与采购在途合计。
|
||
row['采购总数量'] = (row.get('生产在途', 0) or 0) + (row.get('采购在途', 0) or 0)
|
||
old = saved_by_code.get(str(code).strip(), {})
|
||
follower_group = _personnel_group_for_value(product.get('采购跟单'), groups)
|
||
follower_group = next((name for name in groups if name.casefold() == str(follower_group).casefold()), follower_group)
|
||
planner_value = str(product.get('采购计划') or '').strip()
|
||
planner_group = next((name for name in groups if name.casefold() == planner_value.casefold()), '')
|
||
planner_display = '、'.join(groups[planner_group]) if planner_group else planner_value
|
||
row.update({'id': old.get('id'), '品类': old.get('品类') or row.get('产品种类') or '',
|
||
'货品编号': code, '货品名称': product.get('product_name', ''),
|
||
'货品类型': product.get('product_type', ''),
|
||
'供应商': product.get('供应商名称') or '', '采购跟单': follower_group or product.get('采购跟单') or '',
|
||
'采购计划': planner_display, '产品进度': finished_progress_map.get(str(code).strip(), ''),
|
||
'待提数量': old.get('待提数量'),
|
||
'进度': finished_progress_map.get(str(code).strip(), ''),
|
||
'备注': old.get('备注') or '',
|
||
'可用库存': row.get('可用库存', 0), '15天均销量': row.get('15天均销量', 0),
|
||
'支撑天数': row.get('支撑天数', 0), '加工厂库存': row.get('加工厂库存', 0),
|
||
'采购总数量': row.get('采购总数量', 0), '采购在途': row.get('采购在途', 0)})
|
||
result.append(row)
|
||
return result
|
||
|
||
|
||
def _finished_row_matches(row, search, category, supplier, filter_data):
|
||
values = [row.get('货品编号'), row.get('货品名称'), row.get('供应商'), row.get('备注')]
|
||
if search and not any(search.casefold() in str(v or '').casefold() for v in values):
|
||
return False
|
||
if category and row.get('品类') != category or supplier and row.get('供应商') != supplier:
|
||
return False
|
||
for field, spec in (filter_data or {}).items():
|
||
if not isinstance(spec, dict):
|
||
continue
|
||
value = row.get(field)
|
||
if spec.get('type') == 'search' and spec.get('value') and spec['value'].casefold() not in str(value or '').casefold():
|
||
return False
|
||
if spec.get('type') == 'list' and spec.get('values'):
|
||
selected = spec['values']
|
||
if '__EMPTY__' not in selected or str(value or ''):
|
||
if str(value) not in [str(v) for v in selected]:
|
||
return False
|
||
if spec.get('type') == 'num' and spec.get('cond') and spec.get('val') != '':
|
||
try:
|
||
number = float(value or 0)
|
||
target = spec['val']
|
||
if spec['cond'] == 'range':
|
||
bounds = [float(x.strip()) for x in str(target).split(',')]
|
||
matched = len(bounds) == 2 and bounds[0] <= number <= bounds[1]
|
||
else:
|
||
target = float(target)
|
||
matched = {'eq': number == target, 'neq': number != target, 'gt': number > target,
|
||
'gte': number >= target, 'lt': number < target, 'lte': number <= target}.get(spec['cond'], True)
|
||
if not matched:
|
||
return False
|
||
except (TypeError, ValueError):
|
||
return False
|
||
return True
|
||
|
||
@purchase_bp.route('/orders/finished')
|
||
@login_required
|
||
def orders_finished_page():
|
||
if not role_required('orders_finished'):
|
||
return redirect(url_for('auth.index'))
|
||
return render_template('base.html', page='orders_finished')
|
||
|
||
|
||
@purchase_bp.route('/api/finished/list', methods=['GET', 'POST'])
|
||
@login_required
|
||
def finished_products_list():
|
||
denied = _require_purchase_operation('orders_finished', 'view')
|
||
if denied:
|
||
return denied
|
||
page = int(request.args.get('page', 1))
|
||
size = int(request.args.get('size', 100))
|
||
search = request.args.get('search', '')
|
||
category_filter = request.args.get('category', '')
|
||
supplier_filter = request.args.get('supplier', '')
|
||
# 成品提货的多选筛选值可能很多，POST 时从请求体读取，避免 GET URL 超长。
|
||
body = request.get_json(silent=True) if request.method == 'POST' else None
|
||
body = body if isinstance(body, dict) else {}
|
||
order_filter_str = request.args.get('order_filter', '') or ''
|
||
filter_data = body.get('order_filter') if request.method == 'POST' else None
|
||
if filter_data is None:
|
||
try:
|
||
filter_data = json.loads(order_filter_str) if order_filter_str else {}
|
||
except (TypeError, ValueError, json.JSONDecodeError):
|
||
filter_data = {}
|
||
if not isinstance(filter_data, dict):
|
||
filter_data = {}
|
||
sort_by = request.args.get('sort_by', '')
|
||
sort_order = request.args.get('sort_order', 'asc').lower()
|
||
all_rows = _finished_planning_rows()
|
||
rows = [r for r in all_rows if _finished_row_matches(r, search, category_filter, supplier_filter, filter_data)]
|
||
allowed_sort_fields = {'品类','货品编号','货品名称','货品类型','供应商','可用库存','千羽仓库存','昨日销量','3天均销量','7天均销量','15天均销量','支撑天数','采购总数量','生产在途','采购在途','产品进度','加工厂库存','采购跟单','采购计划','备注'}
|
||
numeric_sort_fields = {'可用库存','千羽仓库存','昨日销量','3天均销量','7天均销量','15天均销量','支撑天数','采购总数量','生产在途','采购在途','加工厂库存'}
|
||
if sort_by in allowed_sort_fields:
|
||
reverse = sort_order == 'desc'
|
||
if sort_by in numeric_sort_fields:
|
||
def sort_key(row):
|
||
try:
|
||
return float(row.get(sort_by) or 0)
|
||
except (TypeError, ValueError):
|
||
return 0
|
||
else:
|
||
def sort_key(row):
|
||
return str(row.get(sort_by) or '').casefold()
|
||
rows.sort(key=sort_key, reverse=reverse)
|
||
total = len(rows)
|
||
offset = (page - 1) * size
|
||
rows = rows[offset:offset + size]
|
||
|
||
return jsonify({"code": 0, "data": {"rows": rows, "total": total, "page": page, "size": size}})
|
||
|
||
|
||
@purchase_bp.route('/api/finished/export', methods=['POST'])
|
||
@login_required
|
||
def finished_products_export():
|
||
"""按成品提货当前筛选条件导出 Excel，并仅输出用户选择的字段。"""
|
||
denied = _require_purchase_operation('orders_finished', 'export')
|
||
if denied:
|
||
return denied
|
||
from io import BytesIO
|
||
from flask import send_file
|
||
import openpyxl
|
||
from openpyxl.styles import Font, Alignment, PatternFill
|
||
|
||
body = request.get_json(silent=True) or {}
|
||
if not isinstance(body, dict):
|
||
body = {}
|
||
field_defs = {c['field']: (c['label'], c.get('minWidth', 80) // 5 + 8)
|
||
for c in (
|
||
{'field': '品类', 'label': '品类', 'minWidth': 60},
|
||
{'field': '货品编号', 'label': '货品编号', 'minWidth': 120},
|
||
{'field': '货品名称', 'label': '货品名称', 'minWidth': 250},
|
||
{'field': '货品类型', 'label': '货品类型', 'minWidth': 100},
|
||
{'field': '供应商', 'label': '供应商', 'minWidth': 100},
|
||
{'field': '可用库存', 'label': '可用库存', 'minWidth': 70},
|
||
{'field': '千羽仓库存', 'label': '千羽仓库存', 'minWidth': 90},
|
||
{'field': '昨日销量', 'label': '昨日销量', 'minWidth': 60},
|
||
{'field': '3天均销量', 'label': '3天均销', 'minWidth': 65},
|
||
{'field': '7天均销量', 'label': '7天均销', 'minWidth': 65},
|
||
{'field': '15天均销量', 'label': '15天均销', 'minWidth': 65},
|
||
{'field': '支撑天数', 'label': '支撑天数', 'minWidth': 60},
|
||
{'field': '加工厂库存', 'label': '加工厂库存', 'minWidth': 80},
|
||
{'field': '采购总数量', 'label': '采购总数量', 'minWidth': 80},
|
||
{'field': '生产在途', 'label': '生产在途', 'minWidth': 70},
|
||
{'field': '采购在途', 'label': '采购在途', 'minWidth': 70},
|
||
{'field': '产品进度', 'label': '产品进度', 'minWidth': 130},
|
||
{'field': '采购跟单', 'label': '跟单小组', 'minWidth': 150},
|
||
{'field': '采购计划', 'label': '采购计划', 'minWidth': 100},
|
||
{'field': '备注', 'label': '备注', 'minWidth': 200},
|
||
)}
|
||
selected = [field for field in body.get('fields', []) if field in field_defs]
|
||
if session.get('role') not in ('admin', 'super_admin'):
|
||
from services.field_perms import field_perms_for_page
|
||
field_perms = field_perms_for_page(
|
||
session.get('user_id'), session.get('role'), 'orders_finished',
|
||
page_view=True, page_edit=False
|
||
)
|
||
selected = [field for field in selected
|
||
if field_perms.get(field_defs[field][0], {}).get('view', True)]
|
||
if not selected:
|
||
return jsonify({'code': 400, 'msg': '请至少选择一个有查看权限的导出字段'}), 400
|
||
|
||
search = str(body.get('search') or '').strip()
|
||
category = str(body.get('category') or '').strip()
|
||
supplier = str(body.get('supplier') or '').strip()
|
||
filter_data = body.get('order_filter') or {}
|
||
if not isinstance(filter_data, dict):
|
||
filter_data = {}
|
||
rows = [row for row in _finished_planning_rows()
|
||
if _finished_row_matches(row, search, category, supplier, filter_data)]
|
||
|
||
sort_by = body.get('sort_by') or ''
|
||
sort_order = str(body.get('sort_order') or 'asc').lower()
|
||
numeric_fields = {'可用库存', '千羽仓库存', '昨日销量', '3天均销量', '7天均销量', '15天均销量',
|
||
'支撑天数', '采购总数量', '生产在途', '采购在途', '加工厂库存'}
|
||
if sort_by in field_defs:
|
||
if sort_by in numeric_fields:
|
||
def sort_key(row):
|
||
try:
|
||
return float(row.get(sort_by) or 0)
|
||
except (TypeError, ValueError):
|
||
return 0
|
||
else:
|
||
def sort_key(row):
|
||
return str(row.get(sort_by) or '').casefold()
|
||
rows.sort(key=sort_key, reverse=sort_order == 'desc')
|
||
|
||
workbook = openpyxl.Workbook()
|
||
sheet = workbook.active
|
||
sheet.title = '成品提货管理'
|
||
sheet.append([field_defs[field][0] for field in selected])
|
||
for cell in sheet[1]:
|
||
cell.font = Font(bold=True, color='FFFFFF')
|
||
cell.fill = PatternFill('solid', fgColor='1890FF')
|
||
cell.alignment = Alignment(horizontal='center', vertical='center')
|
||
for row in rows:
|
||
sheet.append([row.get(field) if row.get(field) is not None else '' for field in selected])
|
||
for index, field in enumerate(selected, 1):
|
||
sheet.column_dimensions[openpyxl.utils.get_column_letter(index)].width = field_defs[field][1]
|
||
sheet.freeze_panes = 'A2'
|
||
sheet.auto_filter.ref = sheet.dimensions
|
||
output = BytesIO()
|
||
workbook.save(output)
|
||
output.seek(0)
|
||
return send_file(output, as_attachment=True, download_name='成品提货管理.xlsx',
|
||
mimetype='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
|
||
|
||
|
||
@purchase_bp.route('/api/finished/filters')
|
||
@login_required
|
||
def finished_products_filters():
|
||
denied = _require_purchase_operation('orders_finished', 'view')
|
||
if denied:
|
||
return denied
|
||
rows = _finished_planning_rows()
|
||
categories = sorted({str(r.get('品类') or '') for r in rows if r.get('品类')})
|
||
suppliers = sorted({str(r.get('供应商') or '') for r in rows if r.get('供应商')})
|
||
return jsonify({"code": 0, "data": {"categories": categories, "suppliers": suppliers}})
|
||
|
||
|
||
@purchase_bp.route('/api/finished/column-values', methods=['GET', 'POST'])
|
||
@login_required
|
||
def finished_products_column_values():
|
||
denied = _require_purchase_operation('orders_finished', 'view')
|
||
if denied:
|
||
return denied
|
||
body = request.get_json(silent=True) if request.method == 'POST' else None
|
||
body = body if isinstance(body, dict) else {}
|
||
field = request.args.get('field', '')
|
||
allowed_fields = {'货品编号','货品名称','货品类型','供应商','品类','可用库存','千羽仓库存','昨日销量','3天均销量','7天均销量','15天均销量','支撑天数','采购总数量','生产在途','采购在途','产品进度','加工厂库存','采购跟单','采购计划','备注'}
|
||
if not field:
|
||
return jsonify({"code": 400, "msg": "缺少field参数"})
|
||
if field not in allowed_fields:
|
||
return jsonify({"code": 0, "data": []})
|
||
try:
|
||
filters = body.get('order_filter') if body.get('order_filter') is not None else json.loads(request.args.get('order_filter', '') or '{}')
|
||
except (TypeError, ValueError, json.JSONDecodeError):
|
||
filters = {}
|
||
filters.pop(field, None)
|
||
rows = _finished_planning_rows()
|
||
rows = [r for r in rows if _finished_row_matches(r, request.args.get('search', ''), request.args.get('category', ''), request.args.get('supplier', ''), filters)]
|
||
values = sorted({str(r.get(field)) for r in rows if r.get(field) not in (None, '')})
|
||
if any(r.get(field) in (None, '') for r in rows):
|
||
values.append('__EMPTY__')
|
||
return jsonify({"code": 0, "data": values})
|
||
|
||
|
||
@purchase_bp.route('/api/finished/unfinished-orders')
|
||
@login_required
|
||
def finished_unfinished_orders():
|
||
"""根据货品编号抓取国内/海外订单管理中状态为未完结的订单列表（成品提货详情-未完结订单列表）"""
|
||
denied = _require_purchase_operation('orders_finished', 'view')
|
||
if denied:
|
||
return denied
|
||
product_code = request.args.get('product_code', '').strip()
|
||
if not product_code:
|
||
return jsonify({"code": 400, "msg": "缺少货品编号"})
|
||
rows = []
|
||
# 国内订单：货品编号匹配，状态未完结（跟单下单日期取 日期 字段，与国内订单列表一致）
|
||
domestic = list(query("""
|
||
SELECT IFNULL(DATE_FORMAT(`订单下达供应商时间`, '%%Y-%%m-%%d'), DATE_FORMAT(`日期`, '%%Y-%%m-%%d')) AS 下单日期,
|
||
`数量` AS 下单数量,
|
||
`实际到货数量` AS 到货数量, `未到货数` AS 未到货数, `进度` AS 订单进度
|
||
FROM domestic_orders
|
||
WHERE `货品编号`=%s AND `状态`='未完结'
|
||
ORDER BY 下单日期 ASC, id ASC
|
||
""", (product_code,)))
|
||
for r in domestic:
|
||
r['订单来源'] = '国内'
|
||
rows.append(r)
|
||
# 海外订单：产品编码匹配，状态未完结（跟单下单日期取 日期 字段，与海外订单列表一致）
|
||
overseas = list(query("""
|
||
SELECT IFNULL(DATE_FORMAT(`订单下达供应商时间`, '%%Y-%%m-%%d'), DATE_FORMAT(`日期`, '%%Y-%%m-%%d')) AS 下单日期,
|
||
`数量` AS 下单数量,
|
||
`实际到货数量` AS 到货数量, `未到货数` AS 未到货数, `进度` AS 订单进度
|
||
FROM overseas_orders
|
||
WHERE `产品编码`=%s AND `状态`='未完结'
|
||
ORDER BY 下单日期 ASC, id ASC
|
||
""", (product_code,)))
|
||
for r in overseas:
|
||
r['订单来源'] = '海外'
|
||
rows.append(r)
|
||
# 日期格式化
|
||
for r in rows:
|
||
d = r.get('下单日期')
|
||
if d and hasattr(d, 'strftime'):
|
||
r['下单日期'] = d.strftime('%Y-%m-%d')
|
||
elif d and isinstance(d, str):
|
||
r['下单日期'] = d[:10]
|
||
else:
|
||
r['下单日期'] = ''
|
||
r['下单数量'] = r.get('下单数量') or 0
|
||
r['到货数量'] = r.get('到货数量') or 0
|
||
r['未到货数'] = r.get('未到货数') or 0
|
||
r['订单进度'] = r.get('订单进度') or ''
|
||
# 外部“产品进度”列和详情弹窗使用同一口径，返回当前货品统一进度。
|
||
product_progress = _finished_order_progress_map().get(product_code, '')
|
||
return jsonify({"code": 0, "data": {"rows": rows, "total": len(rows),
|
||
"product_progress": product_progress}})
|
||
|
||
|
||
@purchase_bp.route('/api/finished/orders/update_fields', methods=['POST'])
|
||
@login_required
|
||
def finished_products_update_fields():
|
||
"""保存成品提货详情中的可编辑字段。"""
|
||
denied = _require_purchase_operation('orders_finished', 'view')
|
||
if denied:
|
||
return denied
|
||
data = request.json or {}
|
||
product_code = str(data.get('product_code') or '').strip()
|
||
fields = data.get('fields') or {}
|
||
if not product_code or '待提数量' not in fields:
|
||
return jsonify({"code": 400, "msg": "参数错误"})
|
||
|
||
raw_value = fields.get('待提数量')
|
||
try:
|
||
pending_qty = None if raw_value in (None, '') else int(str(raw_value).replace(',', '').strip())
|
||
except (TypeError, ValueError):
|
||
return jsonify({"code": 400, "msg": "待提数量必须填写整数"})
|
||
if pending_qty is not None and pending_qty < 0:
|
||
return jsonify({"code": 400, "msg": "待提数量不能小于0"})
|
||
|
||
# 兼容历史库：旧版 finished_products 尚无待提数量字段，首次保存时自动补齐。
|
||
columns = query("""
|
||
SELECT COLUMN_NAME FROM information_schema.COLUMNS
|
||
WHERE TABLE_SCHEMA=DATABASE() AND TABLE_NAME='finished_products' AND COLUMN_NAME='待提数量'
|
||
""")
|
||
if not columns:
|
||
query("ALTER TABLE finished_products ADD COLUMN `待提数量` INT DEFAULT NULL AFTER `采购总数量`")
|
||
|
||
saved = query("SELECT id FROM finished_products WHERE `货品编号`=%s ORDER BY id DESC LIMIT 1", (product_code,))
|
||
if saved:
|
||
query("UPDATE finished_products SET `待提数量`=%s WHERE id=%s", (pending_qty, saved[0]['id']))
|
||
else:
|
||
query("INSERT INTO finished_products (`货品编号`, `待提数量`) VALUES (%s, %s)", (product_code, pending_qty))
|
||
add_operation_log('成品提货编辑', f'货品编号:{product_code}; 待提数量:{pending_qty if pending_qty is not None else "空"}',
|
||
page='成品提货管理', field='待提数量')
|
||
return jsonify({"code": 0, "msg": "保存成功"})
|
||
|
||
|
||
@purchase_bp.route('/api/finished/orders/delete', methods=['POST'])
|
||
@login_required
|
||
def finished_products_delete():
|
||
denied = _require_purchase_operation('orders_finished', 'delete')
|
||
if denied:
|
||
return denied
|
||
row_id = request.json.get('id')
|
||
if not row_id:
|
||
return jsonify({"code": 400, "msg": "参数错误"})
|
||
query("DELETE FROM finished_products WHERE id=%s", (row_id,))
|
||
return jsonify({"code": 0, "msg": "删除成功"})
|
||
|
||
|
||
@purchase_bp.route('/api/purchase/rollback_order', methods=['POST'])
|
||
@login_required
|
||
def purchase_rollback_order():
|
||
"""下单回退：校验状态和原因后，仅回退当前下单时间对应的订单批次，历史批次不受影响。"""
|
||
denied = _require_purchase_operation('purchase_ready', 'rollback')
|
||
if denied:
|
||
return denied
|
||
data = request.json or {}
|
||
product_code = str(data.get('product_code', '')).strip()
|
||
backup_id = data.get('backup_id')
|
||
ordered_at = str(data.get('ordered_at', '') or '').strip()
|
||
rollback_reason = str(data.get('rollback_reason', '')).strip()
|
||
if not product_code:
|
||
return jsonify({"code": 400, "msg": "缺少货品编号"})
|
||
if len(rollback_reason) < 2:
|
||
return jsonify({"code": 400, "msg": "请填写至少2个字的回退原因"})
|
||
|
||
# 精确定位要回退的备份行：优先按 backup_id（同商品可能有多条 ordered 历史），
|
||
# 否则按 ordered_at，最后回退到该商品最近一次下单。
|
||
if backup_id:
|
||
rows = query("SELECT * FROM pending_orders WHERE id=%s AND status='ordered'", (backup_id,))
|
||
elif ordered_at:
|
||
rows = query(
|
||
"SELECT * FROM pending_orders WHERE product_code=%s AND status='ordered' AND ordered_at=%s",
|
||
(product_code, ordered_at)
|
||
)
|
||
else:
|
||
rows = query(
|
||
"SELECT * FROM pending_orders WHERE product_code=%s AND status='ordered' ORDER BY ordered_at DESC, id DESC LIMIT 1",
|
||
(product_code,)
|
||
)
|
||
if not rows:
|
||
return jsonify({"code": 400, "msg": "仅已下单状态的记录可以回退"})
|
||
row = rows[0]
|
||
backup_id = row['id']
|
||
|
||
# 用该备份行自身的下单时间定位订单批次，不依赖其他行。
|
||
if not ordered_at:
|
||
ordered_at = _get_ordered_backup_time(product_code, backup_id=backup_id)
|
||
if not ordered_at:
|
||
return jsonify({"code": 400, "msg": "未找到对应下单时间，无法定位回退订单"})
|
||
|
||
planner = (row.get('procurement_planner') or '').strip()
|
||
is_overseas = ('张莹纯' in planner)
|
||
order_table = 'overseas_orders' if is_overseas else 'domestic_orders'
|
||
code_field = '产品编码' if is_overseas else '货品编号'
|
||
order_rows = query(
|
||
f"SELECT id, `状态`, COALESCE(`实际到货数量`, 0) AS arrived_qty FROM {order_table} WHERE `{code_field}`=%s AND `计划下单时间`=%s",
|
||
(product_code, ordered_at)
|
||
)
|
||
blocked = [o for o in order_rows if str(o.get('状态') or '').strip() == '已完结' or int(o.get('arrived_qty') or 0) > 0]
|
||
if blocked:
|
||
return jsonify({"code": 400, "msg": "订单已完结或已有到货数量，不能回退"})
|
||
|
||
bom_raw = row.get('bom_items')
|
||
try:
|
||
bom_list = json.loads(bom_raw) if isinstance(bom_raw, str) else (bom_raw or [])
|
||
except (TypeError, ValueError, json.JSONDecodeError):
|
||
bom_list = []
|
||
material_codes = [str(bm.get('material_code') or '').strip() for bm in bom_list if str(bm.get('material_code') or '').strip()]
|
||
packaging_count = 0
|
||
if material_codes:
|
||
placeholders = ','.join(['%s'] * len(material_codes))
|
||
packaging_rows = query(
|
||
f"SELECT id, `状态`, COALESCE(`实际到货数量`, 0) AS arrived_qty FROM packaging_orders WHERE `来源产品编码`=%s AND `下单时间`=%s AND `编码` IN ({placeholders})",
|
||
(product_code, ordered_at) + tuple(material_codes)
|
||
)
|
||
if any(str(o.get('状态') or '').strip() == '已完结' or int(o.get('arrived_qty') or 0) > 0 for o in packaging_rows):
|
||
return jsonify({"code": 400, "msg": "关联包材订单已完结或已有到货数量，不能回退"})
|
||
packaging_count = len(packaging_rows)
|
||
|
||
order_ids = [str(o['id']) for o in order_rows]
|
||
query(f"DELETE FROM {order_table} WHERE `{code_field}`=%s AND `计划下单时间`=%s", (product_code, ordered_at))
|
||
if material_codes:
|
||
placeholders = ','.join(['%s'] * len(material_codes))
|
||
query(f"DELETE FROM packaging_orders WHERE `来源产品编码`=%s AND `下单时间`=%s AND `编码` IN ({placeholders})",
|
||
(product_code, ordered_at) + tuple(material_codes))
|
||
# 包材结余回退：把本次下单消耗的包材加回下单前包材（与确认下单公式互逆）。
|
||
# 消耗量 = 成品实际下单数量×包材用量 - 包材实际下单数量；回退后 pre = 当前 pre + 消耗量，post 同步为新 pre。
|
||
# 示例：成品下单1000、包材不下单，下单前5000→下单后4000；回退后 4000+1000=5000。
|
||
product_actual_qty = 0
|
||
for bm in bom_list:
|
||
if str(bm.get('material_code') or '').strip() == f'成品_{product_code}':
|
||
if bm.get('actual_quantity') is not None:
|
||
product_actual_qty = int(bm.get('actual_quantity') or 0)
|
||
break
|
||
if product_actual_qty <= 0:
|
||
product_actual_qty = int(row.get('actual_order_qty') or row.get('formal_order_qty') or 0)
|
||
pack_rollback_detail = []
|
||
# 用量同样以 bom 表为权威来源，避免历史被污染的 bom_items.quantity 再次算错结余。
|
||
bom_qty_map = {}
|
||
for _br in query("SELECT material_code, quantity FROM bom WHERE product_code=%s", (product_code,)):
|
||
try:
|
||
bom_qty_map[str(_br.get('material_code') or '').strip()] = float(_br.get('quantity') or 0)
|
||
except (TypeError, ValueError):
|
||
continue
|
||
for bm in bom_list:
|
||
mat_code = str(bm.get('material_code') or '').strip()
|
||
if not mat_code or mat_code.startswith('成品_'):
|
||
continue
|
||
# 与确认下单一致：优先使用实际下单数量，无则按用量×成品数量
|
||
mat_qty = _resolve_roll_bom_qty(bm, bom_qty_map)
|
||
actual_qty = bm.get('actual_quantity')
|
||
if actual_qty is not None and int(actual_qty) > 0:
|
||
order_qty = int(actual_qty)
|
||
elif actual_qty is not None and int(actual_qty) == 0:
|
||
order_qty = 0
|
||
else:
|
||
order_qty = int(mat_qty * product_actual_qty)
|
||
consumed = product_actual_qty * mat_qty - order_qty
|
||
if consumed == 0:
|
||
continue
|
||
pack_rows = query(
|
||
"SELECT pre_pack_qty FROM bom_packaging WHERE product_code=%s AND material_code=%s",
|
||
(product_code, mat_code)
|
||
)
|
||
cur_pre = int(pack_rows[0].get('pre_pack_qty') or 0) if pack_rows else 0
|
||
new_pre = cur_pre + consumed
|
||
query("""INSERT INTO bom_packaging
|
||
(product_code, material_code, pre_pack_qty, post_pack_qty)
|
||
VALUES (%s,%s,%s,%s)
|
||
ON DUPLICATE KEY UPDATE pre_pack_qty=%s, post_pack_qty=%s, updated_at=NOW()""",
|
||
(product_code, mat_code, new_pre, new_pre, new_pre, new_pre))
|
||
pack_rollback_detail.append(f"{mat_code}:{cur_pre}→{new_pre}")
|
||
print(f'[PACKAGING_ROLLBACK] pc={product_code}, mat={mat_code}, consumed={consumed}, pre={cur_pre}->{new_pre}', flush=True)
|
||
# 回退时保留原下单行作为历史备份，并复制一行回到待下单列表。
|
||
# 这样订单管理不再展示已回退行，但订单备份管理仍能完整保留这次下单记录。
|
||
query("UPDATE pending_orders SET status='rolled_back' WHERE id=%s AND status='ordered'", (backup_id,))
|
||
# 使用已定位到的备份行显式复制，避免 INSERT...SELECT 在不同 MySQL 配置下
|
||
# 无法可靠返回新记录并导致回退后待下单列表没有记录。
|
||
pending_id = query("""
|
||
INSERT INTO pending_orders
|
||
(product_code, product_name, product_type, product_grade, supplier_name,
|
||
lead_time, logistics_time, total_support_days,
|
||
procurement_follower, procurement_planner, platform, operator, created_by,
|
||
audit_price, formal_order_qty, suggested_qty, actual_order_qty, bom_items,
|
||
production_order_no, remark, new_old_product, sales_snapshot, sales_snapshot_at,
|
||
status, created_at, updated_at, ordered_at)
|
||
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, 'pending', NOW(), NOW(), NULL)
|
||
""", (
|
||
row.get('product_code'), row.get('product_name'), row.get('product_type'), row.get('product_grade'),
|
||
row.get('supplier_name'), row.get('lead_time'), row.get('logistics_time'), row.get('total_support_days'),
|
||
row.get('procurement_follower'), row.get('procurement_planner'), row.get('platform'), row.get('operator'),
|
||
row.get('created_by'), row.get('audit_price'), row.get('formal_order_qty'), row.get('suggested_qty'),
|
||
row.get('actual_order_qty'), row.get('bom_items'), row.get('production_order_no'), row.get('remark'),
|
||
row.get('new_old_product'), row.get('sales_snapshot'), row.get('sales_snapshot_at')
|
||
))
|
||
pending_check = query(
|
||
"SELECT id FROM pending_orders WHERE id=%s AND product_code=%s AND status='pending' LIMIT 1",
|
||
(pending_id, product_code)
|
||
)
|
||
if not pending_check:
|
||
return jsonify({"code": 500, "msg": "回退失败：未能生成待下单记录"})
|
||
detail = (
|
||
f"商品:{product_code}; 原状态:ordered; 下单时间:{ordered_at}; 订单类型:{'海外' if is_overseas else '国内'}; "
|
||
f"订单ID:{','.join(order_ids) or '无'}; 删除包材订单:{packaging_count}条; 包材回退:{';'.join(pack_rollback_detail) or '无'}; 原因:{rollback_reason}"
|
||
)
|
||
add_operation_log('下单回退', detail)
|
||
return jsonify({"code": 0, "msg": "已回退到待下单列表"})
|
||
|
||
|
||
@purchase_bp.route('/api/purchase/save_bom', methods=['POST'])
|
||
@login_required
|
||
def purchase_save_bom():
|
||
denied = _require_purchase_operation('purchase', 'edit')
|
||
if denied:
|
||
return denied
|
||
"""保存BOM实际下单数量到pending_orders"""
|
||
data = request.json
|
||
pc = data.get('product_code', '')
|
||
materials = data.get('materials', [])
|
||
if not pc or not materials:
|
||
return jsonify({"code": 400, "msg": "参数错误"})
|
||
|
||
rows = query("SELECT bom_items FROM pending_orders WHERE product_code=%s AND status='pending'", (pc,))
|
||
if not rows:
|
||
return jsonify({"code": 400, "msg": "暂无待下单记录，请先通过计划预测下单"})
|
||
|
||
import json
|
||
bom_raw = rows[0].get('bom_items', '[]')
|
||
try:
|
||
bom_list = json.loads(bom_raw) if isinstance(bom_raw, str) else bom_raw
|
||
except:
|
||
bom_list = []
|
||
|
||
# 将actual_quantity写入bom_items
|
||
mat_map = {}
|
||
for m in materials:
|
||
mat_map[m['material_code']] = m['actual_quantity']
|
||
|
||
for b in bom_list:
|
||
mc = b.get('material_code', '')
|
||
if mc in mat_map:
|
||
b['actual_quantity'] = int(mat_map[mc])
|
||
del mat_map[mc]
|
||
|
||
# 新增不在原BOM中的物料
|
||
for mc, aq in mat_map.items():
|
||
bom_list.append({'material_code': mc, 'material_name': '', 'quantity': 0, 'actual_quantity': aq})
|
||
|
||
query("UPDATE pending_orders SET bom_items=%s WHERE product_code=%s AND status='pending'",
|
||
(json.dumps(bom_list, ensure_ascii=False), pc))
|
||
|
||
return jsonify({"code": 0, "msg": "保存成功"})
|
||
|
||
|
||
def _get_ordered_backup_time(product_code, backup_id=None, ordered_at=None):
|
||
"""Return the exact order time used when this backup created its order rows.
|
||
|
||
优先按 backup_id 定位（同一商品可能存在多条 ordered 历史），
|
||
其次按传入 ordered_at，最后回退到该商品最近一次下单。
|
||
"""
|
||
if backup_id:
|
||
rows = query("SELECT ordered_at FROM pending_orders WHERE id=%s AND product_code=%s AND status='ordered'",
|
||
(backup_id, product_code))
|
||
elif ordered_at:
|
||
return str(ordered_at)[:19]
|
||
else:
|
||
rows = query(
|
||
"SELECT ordered_at FROM pending_orders WHERE product_code=%s AND status='ordered' "
|
||
"ORDER BY ordered_at DESC, id DESC LIMIT 1", (product_code,)
|
||
)
|
||
if not rows or not rows[0].get('ordered_at'):
|
||
return None
|
||
value = rows[0]['ordered_at']
|
||
return value.strftime('%Y-%m-%d %H:%M:%S') if hasattr(value, 'strftime') else str(value)[:19]
|
||
|
||
|
||
def _backup_linked_order_ids(read, table, product_code, ordered_at):
|
||
"""Prefer the exact order time; date-only legacy rows need a unique source."""
|
||
code_field, time_field = {
|
||
'domestic_orders': ('货品编号', '计划下单时间'),
|
||
'overseas_orders': ('产品编码', '计划下单时间'),
|
||
'packaging_orders': ('来源产品编码', '下单时间'),
|
||
}[table]
|
||
rows = read(f'SELECT id FROM {table} WHERE `{code_field}`=%s AND `{time_field}`=%s',
|
||
(product_code, ordered_at))
|
||
if rows:
|
||
return [row['id'] for row in rows]
|
||
|
||
day = ordered_at[:10]
|
||
legacy = read(f'SELECT id FROM {table} WHERE `{code_field}`=%s AND TRIM(`{time_field}`)=%s',
|
||
(product_code, day))
|
||
if not legacy:
|
||
return []
|
||
sources = read(
|
||
"SELECT id FROM pending_orders WHERE product_code=%s "
|
||
"AND status IN ('ordered','rolled_back') "
|
||
"AND ordered_at >= %s AND ordered_at < DATE_ADD(%s, INTERVAL 1 DAY)",
|
||
(product_code, day, day),
|
||
)
|
||
# 成品订单须唯一；同一备份可以生成多条包材订单。
|
||
if len(sources) != 1 or (table != 'packaging_orders' and len(legacy) != 1):
|
||
raise ValueError('同一商品当天有多笔记录，日期不足以确定对应订单，请核对计划下单时间')
|
||
return [row['id'] for row in legacy]
|
||
|
||
|
||
@purchase_bp.route('/api/purchase/backup/update_prod_no', methods=['POST'])
|
||
@login_required
|
||
def backup_update_prod_no():
|
||
denied = _require_purchase_operation('purchase_ready', 'edit')
|
||
if denied:
|
||
return denied
|
||
"""Save the backup and uniquely linked order numbers in one transaction."""
|
||
data = request.get_json(silent=True) or {}
|
||
product_code = data.get('product_code', '')
|
||
prod_no = data.get('production_order_no', '')
|
||
backup_id = data.get('backup_id')
|
||
ordered_at = data.get('ordered_at', '')
|
||
if not product_code:
|
||
return jsonify({"code": 400, "msg": "参数错误"})
|
||
conn = get_db()
|
||
counts = {}
|
||
try:
|
||
conn.begin()
|
||
with conn.cursor() as cur:
|
||
def read(sql, params):
|
||
cur.execute(sql, params)
|
||
return cur.fetchall()
|
||
|
||
if backup_id:
|
||
backups = read("SELECT id, ordered_at FROM pending_orders WHERE id=%s "
|
||
"AND product_code=%s AND status='ordered' FOR UPDATE", (backup_id, product_code))
|
||
elif ordered_at:
|
||
backups = read("SELECT id, ordered_at FROM pending_orders WHERE product_code=%s "
|
||
"AND status='ordered' AND ordered_at=%s FOR UPDATE", (product_code, ordered_at))
|
||
else:
|
||
backups = read("SELECT id, ordered_at FROM pending_orders WHERE product_code=%s "
|
||
"AND status='ordered' ORDER BY ordered_at DESC,id DESC LIMIT 1 FOR UPDATE", (product_code,))
|
||
if len(backups) != 1 or not backups[0].get('ordered_at'):
|
||
conn.rollback()
|
||
return jsonify({"code": 404, "msg": "未找到唯一对应的下单备份"})
|
||
backup = backups[0]
|
||
time = backup['ordered_at']
|
||
ordered_at = time.strftime('%Y-%m-%d %H:%M:%S') if hasattr(time, 'strftime') else str(time)[:19]
|
||
targets = {table: _backup_linked_order_ids(read, table, product_code, ordered_at)
|
||
for table in ('domestic_orders', 'overseas_orders', 'packaging_orders')}
|
||
cur.execute('UPDATE pending_orders SET production_order_no=%s WHERE id=%s', (prod_no, backup['id']))
|
||
for table, ids in targets.items():
|
||
counts[table] = len(ids)
|
||
if ids:
|
||
field = '生产单号' if table == 'packaging_orders' else '旺店通生产单号'
|
||
placeholders = ','.join(['%s'] * len(ids))
|
||
cur.execute(f'UPDATE {table} SET `{field}`=%s WHERE id IN ({placeholders})',
|
||
(prod_no, *ids))
|
||
conn.commit()
|
||
except ValueError as exc:
|
||
conn.rollback()
|
||
return jsonify({"code": 409, "msg": str(exc)})
|
||
except Exception:
|
||
conn.rollback()
|
||
raise
|
||
finally:
|
||
conn.close()
|
||
add_operation_log('生产单号更新', f'{product_code}/{ordered_at}: {prod_no}')
|
||
msg = '生产单号已保存，已同步对应订单'
|
||
if not any(counts.values()):
|
||
msg = '生产单号已保存，但未找到可同步的订单，请核对订单记录'
|
||
return jsonify({"code": 0, "msg": msg, "data": {"synced": counts}})
|
||
|
||
|
||
@purchase_bp.route('/api/purchase/backup/audit_material_price', methods=['POST'])
|
||
@login_required
|
||
def backup_audit_material_price():
|
||
denied = _require_purchase_operation('purchase_ready', 'edit')
|
||
if denied:
|
||
return denied
|
||
data = request.json or {}
|
||
product_code = data.get('product_code', '')
|
||
material_code = data.get('material_code', '')
|
||
backup_id = data.get('backup_id')
|
||
ordered_at = data.get('ordered_at', '')
|
||
if not product_code or not material_code:
|
||
return jsonify({"code": 400, "msg": "参数错误"})
|
||
ordered_at = _get_ordered_backup_time(product_code, backup_id=backup_id, ordered_at=ordered_at)
|
||
if not ordered_at:
|
||
return jsonify({"code": 404, "msg": "未找到对应下单时间"})
|
||
if backup_id:
|
||
rows = query("SELECT bom_items FROM pending_orders WHERE id=%s AND status='ordered'", (backup_id,))
|
||
else:
|
||
rows = query("SELECT bom_items FROM pending_orders WHERE product_code=%s AND status='ordered' AND ordered_at=%s",
|
||
(product_code, ordered_at))
|
||
if not rows:
|
||
return jsonify({"code": 404, "msg": "未找到下单备份"})
|
||
bom = rows[0].get('bom_items') or []
|
||
if isinstance(bom, str):
|
||
bom = json.loads(bom)
|
||
changed = False
|
||
for item in bom:
|
||
if item.get('material_code') == material_code:
|
||
item['price_audit_status'] = '已审核'
|
||
changed = True
|
||
if not changed:
|
||
return jsonify({"code": 404, "msg": "未找到包材"})
|
||
if backup_id:
|
||
query("UPDATE pending_orders SET bom_items=%s WHERE id=%s", (json.dumps(bom, ensure_ascii=False), backup_id))
|
||
else:
|
||
query("UPDATE pending_orders SET bom_items=%s WHERE product_code=%s AND status='ordered' AND ordered_at=%s",
|
||
(json.dumps(bom, ensure_ascii=False), product_code, ordered_at))
|
||
query("UPDATE packaging_orders SET `是否审核价格`='已审核' WHERE `编码`=%s AND `来源产品编码`=%s AND `下单时间`=%s",
|
||
(material_code, product_code, ordered_at))
|
||
add_operation_log('包材价格审核', f'{product_code}/{ordered_at}/{material_code}')
|
||
return jsonify({"code": 0, "msg": "已审核"})
|
||
|
||
@purchase_bp.route('/api/purchase/backup/update_mat_prod_no', methods=['POST'])
|
||
@login_required
|
||
def backup_update_mat_prod_no():
|
||
denied = _require_purchase_operation('purchase_ready', 'edit')
|
||
if denied:
|
||
return denied
|
||
"""更新下单备份中某个包材的生产单号"""
|
||
data = request.json
|
||
product_code = data.get('product_code', '')
|
||
material_code = data.get('material_code', '')
|
||
prod_no = data.get('production_order_no', '')
|
||
backup_id = data.get('backup_id')
|
||
ordered_at = data.get('ordered_at', '')
|
||
if not product_code or not material_code:
|
||
return jsonify({"code": 400, "msg": "参数错误"})
|
||
import json
|
||
ordered_at = _get_ordered_backup_time(product_code, backup_id=backup_id, ordered_at=ordered_at)
|
||
if not ordered_at:
|
||
return jsonify({"code": 404, "msg": "未找到对应下单时间"})
|
||
if backup_id:
|
||
rows = query("SELECT bom_items FROM pending_orders WHERE id=%s AND status='ordered'", (backup_id,))
|
||
else:
|
||
rows = query("SELECT bom_items FROM pending_orders WHERE product_code=%s AND status='ordered' AND ordered_at=%s",
|
||
(product_code, ordered_at))
|
||
if not rows:
|
||
return jsonify({"code": 404, "msg": "未找到"})
|
||
bom = rows[0]['bom_items']
|
||
if isinstance(bom, str):
|
||
bom = json.loads(bom)
|
||
changed = False
|
||
for item in bom:
|
||
if item.get('material_code') == material_code:
|
||
item['production_order_no'] = prod_no
|
||
changed = True
|
||
break
|
||
if changed:
|
||
if backup_id:
|
||
query("UPDATE pending_orders SET bom_items=%s WHERE id=%s",
|
||
(json.dumps(bom, ensure_ascii=False), backup_id))
|
||
else:
|
||
query("UPDATE pending_orders SET bom_items=%s WHERE product_code=%s AND status='ordered' AND ordered_at=%s",
|
||
(json.dumps(bom, ensure_ascii=False), product_code, ordered_at))
|
||
query("""UPDATE packaging_orders SET `生产单号`=%s
|
||
WHERE `编码`=%s AND `来源产品编码`=%s AND `下单时间`=%s""",
|
||
(prod_no, material_code, product_code, ordered_at))
|
||
add_operation_log('包材生产单号更新', f'{product_code}/{material_code}/{ordered_at}: {prod_no}')
|
||
return jsonify({"code": 0, "msg": "保存成功"})
|
||
|
||
|
||
@purchase_bp.route('/api/purchase/backup/update_mat_purchase_no', methods=['POST'])
|
||
@login_required
|
||
def backup_update_mat_purchase_no():
|
||
denied = _require_purchase_operation('purchase_ready', 'edit')
|
||
if denied:
|
||
return denied
|
||
"""更新下单备份中某个包材的采购单号"""
|
||
data = request.json
|
||
product_code = data.get('product_code', '')
|
||
material_code = data.get('material_code', '')
|
||
purchase_no = data.get('purchase_order_no', '')
|
||
change_manuscript = data.get('change_manuscript', '')
|
||
backup_id = data.get('backup_id')
|
||
ordered_at = data.get('ordered_at', '')
|
||
if not product_code or not material_code:
|
||
return jsonify({"code": 400, "msg": "参数错误"})
|
||
import json
|
||
ordered_at = _get_ordered_backup_time(product_code, backup_id=backup_id, ordered_at=ordered_at)
|
||
if not ordered_at:
|
||
return jsonify({"code": 404, "msg": "未找到对应下单时间"})
|
||
if backup_id:
|
||
rows = query("SELECT bom_items FROM pending_orders WHERE id=%s AND status='ordered'", (backup_id,))
|
||
else:
|
||
rows = query("SELECT bom_items FROM pending_orders WHERE product_code=%s AND status='ordered' AND ordered_at=%s",
|
||
(product_code, ordered_at))
|
||
if not rows:
|
||
return jsonify({"code": 404, "msg": "未找到"})
|
||
bom = rows[0]['bom_items']
|
||
if isinstance(bom, str):
|
||
bom = json.loads(bom)
|
||
changed = False
|
||
for item in bom:
|
||
if item.get('material_code') == material_code:
|
||
item['purchase_order_no'] = purchase_no
|
||
item['change_manuscript'] = change_manuscript
|
||
changed = True
|
||
break
|
||
if not changed:
|
||
return jsonify({"code": 404, "msg": "未找到对应包材"})
|
||
|
||
if backup_id:
|
||
query("UPDATE pending_orders SET bom_items=%s WHERE id=%s",
|
||
(json.dumps(bom, ensure_ascii=False), backup_id))
|
||
else:
|
||
query("UPDATE pending_orders SET bom_items=%s WHERE product_code=%s AND status='ordered' AND ordered_at=%s",
|
||
(json.dumps(bom, ensure_ascii=False), product_code, ordered_at))
|
||
|
||
packaging_rows = query(
|
||
"""SELECT id FROM packaging_orders
|
||
WHERE `编码`=%s AND `来源产品编码`=%s AND `下单时间`=%s
|
||
ORDER BY id DESC LIMIT 1""", (material_code, product_code, ordered_at)
|
||
)
|
||
if not packaging_rows:
|
||
# Legacy rows may lack source product code, but must still match the exact order time.
|
||
packaging_rows = query(
|
||
"""SELECT id FROM packaging_orders
|
||
WHERE `编码`=%s AND COALESCE(`来源产品编码`, '')='' AND `下单时间`=%s
|
||
ORDER BY id DESC LIMIT 1""", (material_code, ordered_at)
|
||
)
|
||
if not packaging_rows:
|
||
# Fallback: the ordered batch may have been deleted (e.g. dedup);
|
||
# sync into the remaining packaging order for this material/product.
|
||
packaging_rows = query(
|
||
"""SELECT id FROM packaging_orders
|
||
WHERE `编码`=%s AND `来源产品编码`=%s
|
||
ORDER BY `下单时间` DESC, id DESC LIMIT 1""", (material_code, product_code)
|
||
)
|
||
if packaging_rows:
|
||
query("""UPDATE packaging_orders
|
||
SET `是否已做采购单`=%s, `旺店通编号`=%s, `来源产品编码`=%s
|
||
WHERE id=%s""",
|
||
('是' if purchase_no else '', purchase_no, product_code, packaging_rows[0]['id']))
|
||
|
||
add_operation_log('包材采购单号更新', f'{product_code}/{material_code}/{ordered_at}: {purchase_no}')
|
||
return jsonify({"code": 0, "msg": "保存成功", "packaging_synced": bool(packaging_rows)})
|
||
|
||
|
||
@purchase_bp.route('/api/domestic/orders/column-values', methods=['GET', 'POST'])
|
||
@login_required
|
||
def domestic_orders_column_values():
|
||
"""获取国内订单指定列的唯一值（全量，支持联动筛选+搜索条件）"""
|
||
field = request.args.get('field', '')
|
||
body = request.get_json(silent=True) if request.method == 'POST' else None
|
||
body = body if isinstance(body, dict) else {}
|
||
filter_str = request.args.get('order_filter', '') or ''
|
||
if body.get('order_filter') is not None:
|
||
filter_str = json.dumps(body.get('order_filter') or {}, ensure_ascii=False)
|
||
search = request.args.get('search', '') or ''
|
||
status = request.args.get('status', '') or ''
|
||
supplier = request.args.get('supplier', '') or ''
|
||
orderer = request.args.get('orderer', '') or ''
|
||
if not field:
|
||
return jsonify({"code": 400, "msg": "缺少field参数"})
|
||
allowed_fields = {'货品编号','货品名称','货品类型','单价','数量','金额','实际到货数量','未到货数','供货商','仓库','采购员','下单人','进度','状态','下单备注','采购开发','旺店通生产单号','金蝶采购单','是否已录入旺店通','是否审核价格','新旧品','金蝶入库','日期','计划下单时间','实际到货日期','预计到货日期'}
|
||
if field not in allowed_fields:
|
||
return jsonify({"code": 0, "data": []})
|
||
source = _order_table_with_product_type('domestic_orders', '货品编号')
|
||
where_extra = ""
|
||
params = []
|
||
# 搜索栏条件
|
||
if search:
|
||
where_extra += " AND (`货品编号` LIKE %s OR `货品名称` LIKE %s OR `供货商` LIKE %s OR `下单备注` LIKE %s)"
|
||
kw = '%' + search + '%'
|
||
params.extend([kw, kw, kw, kw])
|
||
if status:
|
||
where_extra += " AND `状态` = %s"
|
||
params.append(status)
|
||
if supplier:
|
||
where_extra += " AND `供货商` LIKE %s"
|
||
params.append('%' + supplier + '%')
|
||
if orderer:
|
||
where_extra += " AND `下单人` LIKE %s"
|
||
params.append('%' + orderer + '%')
|
||
# 表头筛选条件
|
||
if filter_str:
|
||
try:
|
||
_filters = json.loads(filter_str)
|
||
_conds = []
|
||
for _k, _v in _filters.items():
|
||
if _k == field:
|
||
continue
|
||
if not isinstance(_v, dict):
|
||
continue
|
||
_t = _v.get('type', '')
|
||
if _t == 'search':
|
||
_val = _v.get('value', '')
|
||
if _val:
|
||
_conds.append('`' + _k + '` LIKE %s')
|
||
params.append('%' + _val + '%')
|
||
elif _t == 'list':
|
||
_vals = _v.get('values', [])
|
||
if _vals:
|
||
_non_empty = [x for x in _vals if x != '__EMPTY__']
|
||
_list_parts = []
|
||
if _non_empty:
|
||
_list_parts.extend(_build_exact_list_parts(_k, _non_empty, params))
|
||
if '__EMPTY__' in _vals:
|
||
_list_parts.append("(`" + _k + "` IS NULL OR `" + _k + "` = '')")
|
||
if _list_parts:
|
||
_conds.append('(' + ' OR '.join(_list_parts) + ')')
|
||
elif _t == 'num':
|
||
_cond = _v.get('cond', '')
|
||
_val = _v.get('val', '')
|
||
if _cond and _val:
|
||
cond_map = {'eq': '=', 'neq': '!=', 'gt': '>', 'gte': '>=', 'lt': '<', 'lte': '<='}
|
||
if _cond == 'range':
|
||
parts = [part.strip() for part in str(_val).split(',') if part.strip()]
|
||
if len(parts) == 2:
|
||
try:
|
||
_conds.append('`' + _k + '` >= %s AND `' + _k + '` <= %s')
|
||
params.extend([float(parts[0]), float(parts[1])])
|
||
except ValueError:
|
||
pass
|
||
else:
|
||
_op = cond_map.get(_cond)
|
||
if _op:
|
||
_conds.append('`' + _k + '` ' + _op + ' %s')
|
||
params.append(float(_val) if _val.replace('.', '').replace('-', '').isdigit() else _val)
|
||
except:
|
||
pass
|
||
if _conds:
|
||
where_extra += ' AND ' + ' AND '.join(_conds)
|
||
if field == '货品类型':
|
||
return jsonify({"code": 0, "data": _order_product_type_values('domestic_orders', '货品编号', where_extra, params)})
|
||
# 如果有空值（考虑现有筛选），追加 __EMPTY__ 标记
|
||
try:
|
||
hasEmpty = query('SELECT COUNT(*) AS cnt FROM ' + source + ' WHERE (`' + field + '` IS NULL OR CAST(`' + field + '` AS CHAR) = \'\')' + where_extra, params or None)
|
||
hasEmptyCnt = hasEmpty[0]['cnt'] if hasEmpty else 0
|
||
except Exception:
|
||
hasEmptyCnt = 0
|
||
sql = 'SELECT DISTINCT `' + field + '` AS val FROM ' + source + ' WHERE `' + field + '` IS NOT NULL AND CAST(`' + field + '` AS CHAR) != \'\'' + where_extra + ' ORDER BY val'
|
||
rows = query(sql, params or None)
|
||
vals = [r['val'] for r in rows]
|
||
if hasEmptyCnt > 0:
|
||
vals.append('__EMPTY__')
|
||
return jsonify({"code": 0, "data": vals})
|
||
|
||
|
||
@purchase_bp.route('/api/overseas/orders/column-values', methods=['GET', 'POST'])
|
||
@login_required
|
||
def overseas_orders_column_values():
|
||
"""获取海外订单指定列的唯一值（全量，支持联动筛选+搜索条件）"""
|
||
field = request.args.get('field', '')
|
||
body = request.get_json(silent=True) if request.method == 'POST' else None
|
||
body = body if isinstance(body, dict) else {}
|
||
filter_str = request.args.get('order_filter', '') or ''
|
||
if body.get('order_filter') is not None:
|
||
filter_str = json.dumps(body.get('order_filter') or {}, ensure_ascii=False)
|
||
search = request.args.get('search', '') or ''
|
||
status = request.args.get('status', '') or ''
|
||
supplier = request.args.get('supplier', '') or ''
|
||
orderer = request.args.get('orderer', '') or ''
|
||
if not field:
|
||
return jsonify({"code": 400, "msg": "缺少field参数"})
|
||
allowed_fields = {'产品编码','货品名称','货品类型','单价','数量','金额','实际到货数量','未到货数','供应商','仓库','采购员','下单人','进度','状态','下单备注','采购开发','旺店通生产单号','是否已录入到旺店通','是否审核价格','新旧品','是否已做采购单','是否做入库','日期','计划下单时间','实际到货日期','预计到货日期'}
|
||
if field not in allowed_fields:
|
||
return jsonify({"code": 0, "data": []})
|
||
source = _order_table_with_product_type('overseas_orders', '产品编码')
|
||
where_extra = ""
|
||
params = []
|
||
if search:
|
||
where_extra += " AND (`产品编码` LIKE %s OR `货品名称` LIKE %s OR `供应商` LIKE %s OR `下单备注` LIKE %s)"
|
||
kw = '%' + search + '%'
|
||
params.extend([kw, kw, kw, kw])
|
||
if status:
|
||
where_extra += " AND `状态` = %s"
|
||
params.append(status)
|
||
if supplier:
|
||
where_extra += " AND `供应商` LIKE %s"
|
||
params.append('%' + supplier + '%')
|
||
if orderer:
|
||
where_extra += " AND `下单人` LIKE %s"
|
||
params.append('%' + orderer + '%')
|
||
if filter_str:
|
||
try:
|
||
_filters = json.loads(filter_str)
|
||
_conds = []
|
||
for _k, _v in _filters.items():
|
||
if _k == field:
|
||
continue
|
||
if not isinstance(_v, dict):
|
||
continue
|
||
_t = _v.get('type', '')
|
||
if _t == 'search':
|
||
_val = _v.get('value', '')
|
||
if _val:
|
||
_conds.append('`' + _k + '` LIKE %s')
|
||
params.append('%' + _val + '%')
|
||
elif _t == 'list':
|
||
_vals = _v.get('values', [])
|
||
if _vals:
|
||
_non_empty = [x for x in _vals if x != '__EMPTY__']
|
||
_list_parts = []
|
||
if _non_empty:
|
||
_list_parts.extend(_build_exact_list_parts(_k, _non_empty, params))
|
||
if '__EMPTY__' in _vals:
|
||
_list_parts.append("(`" + _k + "` IS NULL OR `" + _k + "` = '')")
|
||
if _list_parts:
|
||
_conds.append('(' + ' OR '.join(_list_parts) + ')')
|
||
elif _t == 'num':
|
||
_cond = _v.get('cond', '')
|
||
_val = _v.get('val', '')
|
||
if _cond and _val:
|
||
cond_map = {'eq': '=', 'neq': '!=', 'gt': '>', 'gte': '>=', 'lt': '<', 'lte': '<='}
|
||
if _cond == 'range':
|
||
parts = [part.strip() for part in str(_val).split(',') if part.strip()]
|
||
if len(parts) == 2:
|
||
try:
|
||
_conds.append('`' + _k + '` >= %s AND `' + _k + '` <= %s')
|
||
params.extend([float(parts[0]), float(parts[1])])
|
||
except ValueError:
|
||
pass
|
||
else:
|
||
_op = cond_map.get(_cond)
|
||
if _op:
|
||
_conds.append('`' + _k + '` ' + _op + ' %s')
|
||
params.append(float(_val) if _val.replace('.', '').replace('-', '').isdigit() else _val)
|
||
except:
|
||
pass
|
||
if _conds:
|
||
where_extra += ' AND ' + ' AND '.join(_conds)
|
||
if field == '货品类型':
|
||
return jsonify({"code": 0, "data": _order_product_type_values('overseas_orders', '产品编码', where_extra, params)})
|
||
try:
|
||
hasEmpty = query('SELECT COUNT(*) AS cnt FROM ' + source + ' WHERE (`' + field + '` IS NULL OR CAST(`' + field + '` AS CHAR) = \'\')' + where_extra, params or None)
|
||
hasEmptyCnt = hasEmpty[0]['cnt'] if hasEmpty else 0
|
||
except Exception:
|
||
hasEmptyCnt = 0
|
||
sql = 'SELECT DISTINCT `' + field + '` AS val FROM ' + source + ' WHERE `' + field + '` IS NOT NULL AND CAST(`' + field + '` AS CHAR) != \'\'' + where_extra + ' ORDER BY val'
|
||
rows = query(sql, params or None)
|
||
vals = [r['val'] for r in rows]
|
||
if hasEmptyCnt > 0:
|
||
vals.append('__EMPTY__')
|
||
return jsonify({"code": 0, "data": vals})
|
||
|
||
|
||
@purchase_bp.route('/api/packaging/orders/column-values', methods=['GET', 'POST'])
|
||
@login_required
|
||
def packaging_orders_column_values():
|
||
"""获取包材订单指定列的唯一值（全量，支持联动筛选+搜索条件）"""
|
||
# 使用局部别名，避免后续维护时新增同名局部变量导致 json 被遮蔽。
|
||
import json as _json
|
||
field = request.args.get('field', '')
|
||
body = request.get_json(silent=True) if request.method == 'POST' else None
|
||
body = body if isinstance(body, dict) else {}
|
||
filter_str = request.args.get('order_filter', '') or ''
|
||
if body.get('order_filter') is not None:
|
||
filter_str = _json.dumps(body.get('order_filter') or {}, ensure_ascii=False)
|
||
search = request.args.get('search', '') or ''
|
||
status = request.args.get('status', '') or ''
|
||
supplier = request.args.get('supplier', '') or ''
|
||
orderer = request.args.get('orderer', '') or ''
|
||
if not field:
|
||
return jsonify({"code": 400, "msg": "缺少field参数"})
|
||
allowed_fields = {'编码','名称','货品类型','新旧品','单价','数量','合计','供应商','成品供应商','进度','状态','做货天数','仓库到货','下单备注','是否已做采购单','是否已做入库','采购下单人','旺店通编号','是否已录入旺店通','到货日期','包材开发'}
|
||
if field not in allowed_fields:
|
||
return jsonify({"code": 0, "data": []})
|
||
source = _packaging_order_source()
|
||
where_extra = ""
|
||
params = []
|
||
if search:
|
||
where_extra += " AND (`编码` LIKE %s OR `名称` LIKE %s OR `供应商` LIKE %s OR `进度` LIKE %s)"
|
||
kw = '%' + search + '%'
|
||
params.extend([kw, kw, kw, kw])
|
||
if status:
|
||
where_extra += " AND `状态` = %s"
|
||
params.append(status)
|
||
if supplier:
|
||
where_extra += " AND `供应商` LIKE %s"
|
||
params.append('%' + supplier + '%')
|
||
if orderer:
|
||
where_extra += " AND `采购下单人` LIKE %s"
|
||
params.append('%' + orderer + '%')
|
||
if filter_str:
|
||
try:
|
||
_filters = _json.loads(filter_str)
|
||
_conds = []
|
||
for _k, _v in _filters.items():
|
||
if _k == field:
|
||
continue
|
||
if not isinstance(_v, dict):
|
||
continue
|
||
_t = _v.get('type', '')
|
||
if _t == 'search':
|
||
_val = _v.get('value', '')
|
||
if _val:
|
||
_conds.append('`' + _k + '` LIKE %s')
|
||
params.append('%' + _val + '%')
|
||
elif _t == 'list':
|
||
_vals = _v.get('values', [])
|
||
if _vals:
|
||
_non_empty = [x for x in _vals if x != '__EMPTY__']
|
||
_list_parts = []
|
||
if _non_empty:
|
||
_list_parts.extend(_build_exact_list_parts(_k, _non_empty, params))
|
||
if '__EMPTY__' in _vals:
|
||
_list_parts.append("(`" + _k + "` IS NULL OR `" + _k + "` = '')")
|
||
if _list_parts:
|
||
_conds.append('(' + ' OR '.join(_list_parts) + ')')
|
||
elif _t == 'num':
|
||
_cond = _v.get('cond', '')
|
||
_val = _v.get('val', '')
|
||
if _cond and _val:
|
||
cond_map = {'eq': '=', 'neq': '!=', 'gt': '>', 'gte': '>=', 'lt': '<', 'lte': '<='}
|
||
if _cond == 'range':
|
||
parts = [part.strip() for part in str(_val).split(',') if part.strip()]
|
||
if len(parts) == 2:
|
||
try:
|
||
_conds.append('`' + _k + '` >= %s AND `' + _k + '` <= %s')
|
||
params.extend([float(parts[0]), float(parts[1])])
|
||
except ValueError:
|
||
pass
|
||
else:
|
||
_op = cond_map.get(_cond)
|
||
if _op:
|
||
_conds.append('`' + _k + '` ' + _op + ' %s')
|
||
params.append(float(_val) if _val.replace('.', '').replace('-', '').isdigit() else _val)
|
||
except:
|
||
pass
|
||
if _conds:
|
||
where_extra += ' AND ' + ' AND '.join(_conds)
|
||
if field == '货品类型':
|
||
return jsonify({"code": 0, "data": _order_product_type_values('packaging_orders', '编码', where_extra, params, '来源产品编码')})
|
||
try:
|
||
hasEmpty = query('SELECT COUNT(*) AS cnt FROM ' + source + ' WHERE (`' + field + '` IS NULL OR CAST(`' + field + '` AS CHAR) = \'\')' + where_extra, params or None)
|
||
hasEmptyCnt = hasEmpty[0]['cnt'] if hasEmpty else 0
|
||
except Exception:
|
||
hasEmptyCnt = 0
|
||
sql = 'SELECT DISTINCT `' + field + '` AS val FROM ' + source + ' WHERE `' + field + '` IS NOT NULL AND CAST(`' + field + '` AS CHAR) != \'\'' + where_extra + ' ORDER BY val'
|
||
rows = query(sql, params or None)
|
||
vals = [r['val'] for r in rows]
|
||
if hasEmptyCnt > 0:
|
||
vals.append('__EMPTY__')
|
||
return jsonify({"code": 0, "data": vals})
|