liufumingren 3a4eebb71d feat(shop): 店铺所在区刷新与解绑自动禁用,禁用时作废待审核订单
- 新增 shopAreaSync:按账号拉一次商家列表(同账号多店铺共享,PageSize=200 翻页),
  把最新商家结构(FxUserId、分区声明 DbAreas)写回 shops.external_data;
  商家已不在合作列表时自动把店铺置为禁用,并写明原因
- 手动刷新入口:POST /api/shops/{id}/refresh-area(货主权限)、
  POST /api/external-print-accounts/{id}/refresh-shops-area(集团权限)
- 新增定时任务 refreshExternalShopAreas:每小时巡检,按账号 6 小时刷新一次
  (DGJ_AREA_REFRESH_HOURS 可调),自动禁用店铺后不再参与自动拉单与一键拉单
- 新增 shopOrderGuard:店铺禁用立即作废该店铺待审核订单
  (void_reason 前缀「店铺已禁用,暂停处理」),重新启用时只恢复因此暂停的订单;
  禁用店铺再拉单直接拒绝,避免又拉回待审核单
- externalPrintOrder 待审核单核对改用 LogicOrderId 批量回读(50 单/批,最多 300 单)
- orderStatus.restore 支持显式 principalId,供无登录态的系统任务调用
- 前端:店铺列表新增「所在区」列与行内/详情「刷新所在区」按钮,
  系统自动禁用的店铺状态带原因提示,启停与刷新后提示作废/恢复了多少订单
- 文档:新增 §4.2.2「所在区」刷新、§4.2.3 店铺禁用/启用与待审核订单
  (原 LastWaybillCode 小节顺延为 §4.2.4,WMS 对接文档引用同步)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-11-07 00:19:02 +08:00

791 lines
31 KiB
JavaScript
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

'use strict';
const { Controller } = require('egg');
const { parsePagination, buildPageResult } = require('../lib/pagination');
/** OMS 内创建的店铺编码前缀:用于区分「OMS 自动生成」与「平台店铺ID」 */
const CODE_PREFIX = 'OMS';
/** 店铺类型:1 平台店铺(手工/平台)2 外部打单平台商家 */
const SHOP_TYPE_PLATFORM = 1;
/** 店铺类型:外部打单平台导入的商家店铺(货主权限只读) */
const SHOP_TYPE_EXTERNAL = 2;
/** 店铺类型:数据库店铺(自建 MySQL 库拉取明文订单,需单独配置连接与字段映射) */
const SHOP_TYPE_DATABASE = 3;
/** 店铺类型:线下店铺(OMS 内手工建单使用,无自动拉单/平台对接) */
const SHOP_TYPE_OFFLINE = 4;
/** 手工新增时允许选择的店铺类型:平台店铺 / 数据库店铺 / 线下店铺 */
const CREATABLE_TYPES = [ SHOP_TYPE_PLATFORM, SHOP_TYPE_DATABASE, SHOP_TYPE_OFFLINE ];
/** 自动拉取订单的最小间隔(分钟) */
const MIN_AUTO_FETCH_INTERVAL = 3;
/**
* 解析自动拉取订单配置
* @param {Object} body 请求体
* @return {{auto_fetch_order?: number, auto_fetch_interval?: number, error?: string}} 解析结果
*/
function parseAutoFetchConfig(body) {
const result = {};
if (body.auto_fetch_order !== undefined) {
const flag = body.auto_fetch_order;
result.auto_fetch_order = flag === true || Number(flag) === 1 ? 1 : 0;
}
const rawInterval = body.auto_fetch_interval;
if (rawInterval !== undefined && rawInterval !== null && rawInterval !== '') {
const interval = Number(rawInterval);
if (!Number.isInteger(interval) || interval < MIN_AUTO_FETCH_INTERVAL) {
return { error: `自动拉取间隔必须是不小于 ${MIN_AUTO_FETCH_INTERVAL} 的整数(分钟)` };
}
result.auto_fetch_interval = interval;
}
return result;
}
/** 生成店铺编码:OMS + yyMMddHHmmss + 4 位随机数(如 OMS2609111530123456) */
function genShopCode() {
const pad = num => String(num).padStart(2, '0');
const d = new Date();
const ts =
`${pad(d.getFullYear() % 100)}${pad(d.getMonth() + 1)}${pad(d.getDate())}` +
`${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
const rand = Math.floor(1000 + Math.random() * 9000);
return `${CODE_PREFIX}${ts}${rand}`;
}
/**
* @controller ShopController 店铺管理
*/
class ShopController extends Controller {
/**
* @summary 店铺列表
* @description 分页查询店铺,支持名称/编码模糊搜索、平台与状态过滤
* @router get /api/shops
* @apikey
* @request query integer page 页码,默认 1
* @request query integer pageSize 每页条数,默认 20
* @request query integer principal_id 所属主体ID(必填,需当前账号已绑定该主体)
* @request query string keyword 关键词,匹配店铺名称或编码
* @request query string platform 平台标识,如 taobao/pdd/douyin/jd
* @request query integer status 状态:1启用 0禁用,不传则不过滤
* @request query integer type 店铺类型:1平台店铺 2外部打单平台商家 3数据库店铺 4线下店铺,不传则不过滤
* @response 200 shopListResponse success
*/
async index() {
const { ctx } = this;
const Op = this.app.Sequelize.Op;
const { page, pageSize, offset, limit } = parsePagination(ctx.query);
const { keyword, platform, status, type, subsidiary_id: subsidiaryId } = ctx.query;
const principalId = ctx.state.principalId;
const where = {};
where.principal_id = principalId;
if (keyword) {
where[Op.or] = [
{ name: { [Op.like]: `%${keyword}%` } },
{ code: { [Op.like]: `%${keyword}%` } },
];
}
if (platform) where.platform = platform;
if (status !== undefined && status !== '') where.status = Number(status);
if (type !== undefined && type !== '') where.type = Number(type);
if (subsidiaryId !== undefined && subsidiaryId !== '') where.subsidiary_id = Number(subsidiaryId);
// 所在公司权限:店铺列表仅展示自己所属公司(货主)的店铺
const access = await ctx.service.access.resolve(ctx.userId, principalId);
if (!access.isGroup) {
const ownIds = access.ownCompanyIds.map(Number);
if (where.subsidiary_id !== undefined) {
if (!ownIds.includes(Number(where.subsidiary_id))) {
ctx.body = { code: 0, message: 'success', data: buildPageResult([], 0, { page, pageSize }) };
return;
}
} else {
where.subsidiary_id = { [Op.in]: ownIds };
}
}
const { count, rows } = await ctx.model.Shop.findAndCountAll({
where,
offset,
limit,
order: [[ 'id', 'DESC' ]],
include: [
{ model: ctx.model.PrincipalSubsidiary, as: 'subsidiary', attributes: [ 'id', 'name' ], required: false },
{ model: ctx.model.Warehouse, as: 'defaultWarehouse', attributes: [ 'id', 'code', 'name' ], required: false },
],
});
// 数据库模式(预留)的密码不回显;附带扁平货主名称
const list = rows.map(row => {
const plain = row.get({ plain: true });
plain.has_db_password = !!plain.db_password;
plain.subsidiary_name = plain.subsidiary ? plain.subsidiary.name : '';
plain.default_warehouse_name = plain.defaultWarehouse
? (plain.defaultWarehouse.code ? `${plain.defaultWarehouse.code} ${plain.defaultWarehouse.name}` : plain.defaultWarehouse.name)
: '';
delete plain.defaultWarehouse;
delete plain.db_password;
return plain;
});
ctx.body = { code: 0, message: 'success', data: buildPageResult(list, count, { page, pageSize }) };
}
/**
* @summary 店铺详情
* @description 按主键查询店铺基本信息,并附带店铺商品、订单的关联统计,供详情面板展示
* @router get /api/shops/{id}
* @apikey
* @request path integer *id 店铺主键ID
* @response 200 shopDetailResponse success
*/
async show() {
const { ctx } = this;
const Op = ctx.app.Sequelize.Op;
const shop = await ctx.model.Shop.findByPk(ctx.params.id, {
include: [
{ model: ctx.model.PrincipalSubsidiary, as: 'subsidiary', attributes: [ 'id', 'name' ], required: false },
{ model: ctx.model.Warehouse, as: 'defaultWarehouse', attributes: [ 'id', 'code', 'name' ], required: false },
],
});
if (!shop) {
ctx.status = 404;
ctx.body = { code: 404, message: '店铺不存在' };
return;
}
// 所在公司权限:仅可查看自己所属公司(货主)的店铺
if (!(await this.canAccess(ctx, shop))) {
ctx.status = 403;
ctx.body = { code: 403, message: '仅可查看自己所属公司(货主)的店铺' };
return;
}
const shopId = shop.id;
const [ shopProductCount, boundCount, orderCount, orderAmount, latestOrder ] = await Promise.all([
ctx.model.ShopProduct.count({ where: { shop_id: shopId } }),
ctx.model.ShopProduct.count({ where: { shop_id: shopId, bind_type: { [Op.ne]: 0 } } }),
ctx.model.Order.count({ where: { shop_id: shopId } }),
ctx.model.Order.sum('total_amount', { where: { shop_id: shopId } }),
ctx.model.Order.findOne({
where: { shop_id: shopId },
attributes: [ 'created_at' ],
order: [[ 'id', 'DESC' ]],
raw: true,
}),
]);
const data = shop.get({ plain: true });
data.has_db_password = !!data.db_password;
data.subsidiary_name = data.subsidiary ? data.subsidiary.name : '';
data.default_warehouse_name = data.defaultWarehouse
? (data.defaultWarehouse.code ? `${data.defaultWarehouse.code} ${data.defaultWarehouse.name}` : data.defaultWarehouse.name)
: '';
delete data.defaultWarehouse;
delete data.db_password;
ctx.body = {
code: 0,
message: 'success',
data: {
...data,
stats: {
shop_product_count: shopProductCount,
shop_product_bound_count: boundCount,
order_count: orderCount,
order_amount: Number(orderAmount || 0),
latest_order_at: latestOrder ? latestOrder.created_at : null,
},
},
};
}
/**
* @summary 新增店铺
* @description name 必填;code 留空时自动生成 OMS 前缀编码(表示该店铺由 OMS 创建),
* 传入 code 时校验同一主体下唯一;type 可选 1 平台店铺(默认)/ 3 数据库店铺 / 4 线下店铺
* @router post /api/shops
* @apikey
* @request body createShopRequest *body
* @response 200 baseResponse success
*/
async create() {
const { ctx } = this;
const { name, principal_id: principalId } = ctx.request.body;
if (!name) {
ctx.status = 400;
ctx.body = { code: 400, message: 'name 为必填项' };
return;
}
const autoFetch = parseAutoFetchConfig(ctx.request.body);
if (autoFetch.error) {
ctx.status = 400;
ctx.body = { code: 400, message: autoFetch.error };
return;
}
// 所属货主必填;所在公司权限只能选自己所属公司
const subsidiary = await this.resolveSubsidiaryId(ctx.request.body.subsidiary_id, principalId);
if (!subsidiary.ok) {
ctx.status = 400;
ctx.body = { code: 400, message: subsidiary.message };
return;
}
const access = await ctx.service.access.resolve(ctx.userId, principalId);
if (!access.isGroup && !access.ownCompanyIds.map(Number).includes(Number(subsidiary.value))) {
ctx.status = 403;
ctx.body = { code: 403, message: '只能选择自己所属公司(货主)' };
return;
}
// 已有编码(如平台店铺ID)直接用;未填则生成 OMS 前缀编码
const code = String(ctx.request.body.code || '').trim();
let shopCode = code;
if (code) {
const exist = await ctx.model.Shop.findOne({ where: { principal_id: principalId, code } });
if (exist) {
ctx.status = 400;
ctx.body = { code: 400, message: '该主体下店铺编码已存在' };
return;
}
} else {
shopCode = await this.nextShopCode(principalId);
if (!shopCode) {
ctx.status = 500;
ctx.body = { code: 500, message: '店铺编码生成失败,请重试' };
return;
}
}
// 外部平台导入相关字段由对应接入逻辑维护;手工新增只允许「平台店铺 / 数据库店铺」
const body = { ...ctx.request.body };
delete body.external_print_account_id;
delete body.external_data;
delete body.db_host;
delete body.db_port;
delete body.db_name;
delete body.db_username;
delete body.db_password;
// 默认发货仓库:必须是店铺货主(下属公司)下启用的仓库
const defaultWarehouse = await this.resolveDefaultWarehouseId(body.default_warehouse_id, subsidiary.value, principalId);
if (!defaultWarehouse.ok) {
ctx.status = 400;
ctx.body = { code: 400, message: defaultWarehouse.message };
return;
}
body.default_warehouse_id = defaultWarehouse.value == null ? null : defaultWarehouse.value;
// 店铺类型:不传默认平台店铺;数据库店铺的连接信息在「配置」弹窗单独维护
let shopType = SHOP_TYPE_PLATFORM;
if (body.type !== undefined && body.type !== null && body.type !== '') {
const incoming = Number(body.type);
if (!CREATABLE_TYPES.includes(incoming)) {
ctx.status = 400;
ctx.body = { code: 400, message: '店铺类型仅支持:1 平台店铺 / 3 数据库店铺 / 4 线下店铺' };
return;
}
shopType = incoming;
}
delete body.type;
// 平台店铺必须选择平台;线下店铺不涉及平台
const platform = String(body.platform || '').trim();
if (shopType === SHOP_TYPE_PLATFORM && !platform) {
ctx.status = 400;
ctx.body = { code: 400, message: '平台店铺必须选择平台' };
return;
}
body.platform = shopType === SHOP_TYPE_OFFLINE ? null : (platform || null);
// 线下店铺没有自动拉单:关闭自动拉取并复位间隔
const isOfflineShop = shopType === SHOP_TYPE_OFFLINE;
const autoFetchOrder = isOfflineShop
? 0
: (autoFetch.auto_fetch_order == null ? 0 : autoFetch.auto_fetch_order);
const shop = await ctx.model.Shop.create({
...body,
type: shopType,
code: shopCode,
subsidiary_id: subsidiary.value,
auto_fetch_order: autoFetchOrder,
auto_fetch_interval: isOfflineShop
? MIN_AUTO_FETCH_INTERVAL
: (autoFetch.auto_fetch_interval == null ? MIN_AUTO_FETCH_INTERVAL : autoFetch.auto_fetch_interval),
});
ctx.body = { code: 0, message: 'success', data: { id: shop.id, code: shop.code } };
}
/**
* 校验「所属货主」:必须是当前主体下的下属公司(必填)
* @param {number|string|null|undefined} value 前端传入的 subsidiary_id
* @param {number|string} principalId 当前主体ID
* @return {Promise<{ok: boolean, value?: number, message?: string}>} 校验结果
*/
async resolveSubsidiaryId(value, principalId) {
if (value === undefined || value === null || value === '') {
return { ok: false, message: '请选择所属货主(下属公司)' };
}
const id = Number(value);
if (!Number.isInteger(id) || id <= 0) return { ok: false, message: '所属货主不合法' };
const subsidiary = await this.ctx.model.PrincipalSubsidiary.findOne({
where: { id, principal_id: principalId },
attributes: [ 'id' ],
});
if (!subsidiary) return { ok: false, message: '所属货主不存在或不属于当前集团' };
return { ok: true, value: Number(subsidiary.id) };
}
/**
* 判断货主ID是否属于当前账号自己的公司
* @param {Object} access 权限上下文
* @param {number|null} subsidiaryId 货主ID
* @return {boolean} 是否属于自己公司
*/
isOwnSubsidiary(access, subsidiaryId) {
if (subsidiaryId === null || subsidiaryId === undefined) return false;
return (access.ownCompanyIds || []).map(Number).includes(Number(subsidiaryId));
}
/**
* 校验「默认发货仓库」:必须存在、启用,且属于店铺所属货主
* @param {number|string|null|undefined} value 前端传入的 default_warehouse_id
* @param {number|null} subsidiaryId 店铺所属货主
* @param {number} principalId 当前主体ID
* @return {Promise<{ok: boolean, value?: number|null, message?: string}>} 校验结果(value 为 null 表示清空)
*/
async resolveDefaultWarehouseId(value, subsidiaryId, principalId) {
if (value === null || value === '') return { ok: true, value: null };
if (value === undefined) return { ok: true, value: undefined };
const id = Number(value);
if (!Number.isInteger(id) || id <= 0) return { ok: false, message: '默认发货仓库不合法' };
const warehouse = await this.ctx.model.Warehouse.findOne({
where: { id, principal_id: principalId, status: 1 },
attributes: [ 'id', 'subsidiary_id' ],
});
if (!warehouse) return { ok: false, message: '默认发货仓库不存在或已停用' };
if (subsidiaryId != null && warehouse.subsidiary_id != null
&& Number(warehouse.subsidiary_id) !== Number(subsidiaryId)) {
return { ok: false, message: '默认发货仓库不属于该店铺的货主,请选择同货主的仓库' };
}
return { ok: true, value: id };
}
/**
* 判断店铺是否为外部打单平台导入的店铺
* @param {Object} shop 店铺 model 实例
* @return {boolean} 是否外部打单平台店铺
*/
isExternalShop(shop) {
return Number(shop.type) === SHOP_TYPE_EXTERNAL || !!shop.external_print_account_id;
}
/**
* 判断当前账号是否有权访问该店铺(集团权限均可;所在公司权限限自己所属公司)
* @param {Object} ctx egg context
* @param {Object} shop 店铺 model 实例
* @return {Promise<boolean>} 是否有权限
*/
async canAccess(ctx, shop) {
const access = await ctx.service.access.resolve(ctx.userId, shop.principal_id);
if (access.isGroup) return true;
return this.isOwnSubsidiary(access, shop.subsidiary_id);
}
/**
* 生成同主体下唯一的店铺编码
* @param {number} principalId 主体ID
* @return {Promise<string|null>} 编码,重试多次仍冲突时返回 null
*/
async nextShopCode(principalId) {
const { ctx } = this;
for (let i = 0; i < 5; i++) {
const code = genShopCode();
const exist = await ctx.model.Shop.findOne({ where: { principal_id: principalId, code } });
if (!exist) return code;
}
return null;
}
/**
* @summary 更新店铺
* @description 未传入的字段保持原值;code 留空表示不修改
* @router put /api/shops/{id}
* @apikey
* @request path integer *id 店铺主键ID
* @request body updateShopRequest *body
* @response 200 baseResponse success
*/
async update() {
const { ctx } = this;
const Op = ctx.app.Sequelize.Op;
const shop = await ctx.model.Shop.findByPk(ctx.params.id);
if (!shop) {
ctx.status = 404;
ctx.body = { code: 404, message: '店铺不存在' };
return;
}
delete ctx.request.body.principal_id;
// 状态变更前后的对比基准(禁用/启用会联动处理该店铺的待审核订单)
const previousStatus = Number(shop.status);
// 所在公司权限:仅可维护自己所属公司(货主)的店铺
if (!(await this.canAccess(ctx, shop))) {
ctx.status = 403;
ctx.body = { code: 403, message: '仅可修改自己所属公司(货主)的店铺' };
return;
}
// 外部打单平台导入的店铺:货主权限只读(仅可拉取订单/同步商品)
const access = await ctx.service.access.resolve(ctx.userId, shop.principal_id);
if (!access.isGroup && this.isExternalShop(shop)) {
ctx.status = 403;
ctx.body = { code: 403, message: '外部打单平台店铺不可编辑,仅可拉取订单和同步商品' };
return;
}
// 店铺创建后不可更改所属货主(历史无货主店铺允许补齐一次)
let subsidiaryChanged = false;
const incomingSubsidiary = ctx.request.body.subsidiary_id;
if (incomingSubsidiary !== undefined && incomingSubsidiary !== null && incomingSubsidiary !== '') {
const subsidiary = await this.resolveSubsidiaryId(incomingSubsidiary, shop.principal_id);
if (!subsidiary.ok) {
ctx.status = 400;
ctx.body = { code: 400, message: subsidiary.message };
return;
}
if (shop.subsidiary_id != null && Number(subsidiary.value) !== Number(shop.subsidiary_id)) {
ctx.status = 400;
ctx.body = { code: 400, message: '店铺创建后不可更改所属货主' };
return;
}
if (!access.isGroup && !this.isOwnSubsidiary(access, subsidiary.value)) {
ctx.status = 403;
ctx.body = { code: 403, message: '只能维护自己所属公司(货主)的店铺' };
return;
}
subsidiaryChanged = shop.subsidiary_id == null;
ctx.request.body.subsidiary_id = subsidiary.value;
} else {
// 未传或传空:保持原货主,不允许清空
delete ctx.request.body.subsidiary_id;
}
// 外部平台导入 / 数据库模式相关字段由对应接入逻辑维护,普通编辑不允许修改
delete ctx.request.body.type;
delete ctx.request.body.external_print_account_id;
delete ctx.request.body.external_data;
delete ctx.request.body.db_host;
delete ctx.request.body.db_port;
delete ctx.request.body.db_name;
delete ctx.request.body.db_username;
delete ctx.request.body.db_password;
// 拉单状态由系统写入(手动/定时拉取),不允许编辑接口修改
delete ctx.request.body.last_order_sync_at;
delete ctx.request.body.last_order_sync_msg;
// 默认发货仓库:必须是(变更后的)店铺货主下启用的仓库;显式传空表示清除
const previousWarehouseId = shop.default_warehouse_id == null ? null : Number(shop.default_warehouse_id);
let warehouseChanged = false;
if (ctx.request.body.default_warehouse_id !== undefined) {
const effectiveSubsidiary = ctx.request.body.subsidiary_id ?? shop.subsidiary_id;
const resolvedWarehouse = await this.resolveDefaultWarehouseId(
ctx.request.body.default_warehouse_id,
effectiveSubsidiary == null ? null : Number(effectiveSubsidiary),
shop.principal_id
);
if (!resolvedWarehouse.ok) {
ctx.status = 400;
ctx.body = { code: 400, message: resolvedWarehouse.message };
return;
}
ctx.request.body.default_warehouse_id = resolvedWarehouse.value;
warehouseChanged = Number(resolvedWarehouse.value || 0) !== Number(previousWarehouseId || 0);
}
const autoFetch = parseAutoFetchConfig(ctx.request.body);
if (autoFetch.error) {
ctx.status = 400;
ctx.body = { code: 400, message: autoFetch.error };
return;
}
Object.assign(ctx.request.body, autoFetch);
// 平台店铺必须选择平台;线下店铺不涉及自动拉单
if (Number(shop.type) === SHOP_TYPE_PLATFORM) {
const platform = ctx.request.body.platform === undefined
? String(shop.platform || '').trim()
: String(ctx.request.body.platform || '').trim();
if (!platform) {
ctx.status = 400;
ctx.body = { code: 400, message: '平台店铺必须选择平台' };
return;
}
ctx.request.body.platform = platform;
}
if (Number(shop.type) === SHOP_TYPE_OFFLINE) {
// 线下店铺:没有自动拉单,也不涉及平台
ctx.request.body.auto_fetch_order = 0;
ctx.request.body.auto_fetch_interval = MIN_AUTO_FETCH_INTERVAL;
delete ctx.request.body.platform;
}
// 编码留空视为不修改;改动时校验同主体唯一,避免撞唯一索引报 500
const code = String(ctx.request.body.code || '').trim();
if (code) {
const exist = await ctx.model.Shop.findOne({
where: { principal_id: shop.principal_id, code, id: { [Op.ne]: shop.id } },
});
if (exist) {
ctx.status = 400;
ctx.body = { code: 400, message: '该主体下店铺编码已存在' };
return;
}
ctx.request.body.code = code;
} else {
delete ctx.request.body.code;
}
await shop.update(ctx.request.body);
// 货主变更时,店铺商品的货主跟随店铺一起调整
if (subsidiaryChanged) {
await ctx.model.ShopProduct.update(
{ subsidiary_id: shop.subsidiary_id },
{ where: { principal_id: shop.principal_id, shop_id: shop.id } }
);
}
// 店铺资料变更:清掉推送/取号用的店铺基础缓存
await ctx.service.cache.invalidateShop(shop.id);
// 默认发货仓库变更:把尚未审核的订单回填为新仓库(未手工改过仓库的)
let pendingUpdated = 0;
if (warehouseChanged) {
const applied = await ctx.service.shopWarehouse.applyToPendingOrders(shop, { previousWarehouseId });
pendingUpdated = applied.updated;
}
// 状态变更联动:禁用后无法取号,待审核订单立即作废;重新启用后把因此暂停的订单恢复回待审核
const statusChange = await this.applyStatusOrderGuard(ctx, shop, previousStatus);
ctx.body = {
code: 0,
message: 'success',
data: {
id: shop.id,
code: shop.code,
pending_orders_updated: pendingUpdated,
pending_orders_voided: statusChange.voided,
pending_orders_restored: statusChange.restored,
},
};
}
/**
* 店铺状态(启用/禁用)变更时联动处理待审核订单
* @param {Object} ctx egg context
* @param {Object} shop 店铺实例(已保存最新状态)
* @param {number} previousStatus 变更前状态
* @return {Promise<{voided: number, restored: number}>} 作废 / 恢复的订单数
*/
async applyStatusOrderGuard(ctx, shop, previousStatus) {
const status = Number(shop.status);
const result = { voided: 0, restored: 0 };
if (status === previousStatus) return result;
try {
if (status === 0) {
const guarded = await ctx.service.shopOrderGuard.voidPendingOrders(shop);
result.voided = guarded.count;
} else if (status === 1) {
const guarded = await ctx.service.shopOrderGuard.restorePendingOrders(shop);
result.restored = guarded.count;
// 人工改回启用:清掉系统自动禁用的标记,避免状态列一直提示「系统已自动禁用」
if (shop.extra && shop.extra.auto_disabled) {
const extra = { ...shop.extra };
delete extra.auto_disabled;
extra.area_restored_at = new Date();
await shop.update({ extra });
}
}
} catch (err) {
ctx.logger.warn('[shop] 店铺 %s 状态切换联动订单处理失败:%s', shop.id, err.message);
}
return result;
}
/**
* @summary 设置店铺默认发货仓库
* @description 单独维护「默认发货仓库」(外部打单平台店铺所在的公司在只读模式下也可配置):
* 仓库必须属于店铺货主且启用;保存后同时回填该店铺尚未审核订单的发货仓库
* @router put /api/shops/{id}/default-warehouse
* @apikey
* @request path integer *id 店铺主键ID
* @request body setShopDefaultWarehouseRequest *body
* @response 200 baseResponse success
*/
async setDefaultWarehouse() {
const { ctx } = this;
const shop = await ctx.model.Shop.findByPk(ctx.params.id);
if (!shop) {
ctx.status = 404;
ctx.body = { code: 404, message: '店铺不存在' };
return;
}
// 所在公司权限:仅可维护自己所属公司(货主)的店铺;集团权限不限
if (!(await this.canAccess(ctx, shop))) {
ctx.status = 403;
ctx.body = { code: 403, message: '仅可维护自己所属公司(货主)的店铺' };
return;
}
const body = ctx.request.body || {};
const resolved = await this.resolveDefaultWarehouseId(
body.default_warehouse_id,
shop.subsidiary_id == null ? null : Number(shop.subsidiary_id),
shop.principal_id
);
if (!resolved.ok) {
ctx.status = 400;
ctx.body = { code: 400, message: resolved.message };
return;
}
if (resolved.value === undefined) {
ctx.status = 400;
ctx.body = { code: 400, message: 'default_warehouse_id 不能为空(清除请传 null)' };
return;
}
const previousWarehouseId = shop.default_warehouse_id == null ? null : Number(shop.default_warehouse_id);
await shop.update({ default_warehouse_id: resolved.value });
await ctx.service.cache.invalidateShop(shop.id);
// 未审核订单跟随新的默认仓库(未手工改过仓库的)
const applied = await ctx.service.shopWarehouse.applyToPendingOrders(shop, { previousWarehouseId });
ctx.body = {
code: 0,
message: 'success',
data: {
id: Number(shop.id),
default_warehouse_id: shop.default_warehouse_id == null ? null : Number(shop.default_warehouse_id),
pending_orders_updated: applied.updated,
},
};
}
/**
* @summary 刷新店铺的「所在区」
* @description 重新拉取店铺所属打单账号的商家列表(同账号下的店铺只请求平台一次),
* 更新分区声明等拉单必需字段;商家已不在合作列表时把店铺自动禁用
* @router post /api/shops/{id}/refresh-area
* @apikey
* @request path integer *id 店铺主键ID
* @response 200 shopAreaRefreshResponse success
*/
async refreshArea() {
const { ctx } = this;
const shop = await ctx.model.Shop.findByPk(ctx.params.id);
if (!shop) {
ctx.status = 404;
ctx.body = { code: 404, message: '店铺不存在' };
return;
}
// 所在公司权限:仅可刷新自己所属公司(货主)的店铺;集团权限不限
if (!(await this.canAccess(ctx, shop))) {
ctx.status = 403;
ctx.body = { code: 403, message: '仅可刷新自己所属公司(货主)的店铺' };
return;
}
if (Number(shop.type) !== SHOP_TYPE_EXTERNAL || !shop.external_print_account_id) {
ctx.status = 400;
ctx.body = { code: 400, message: '仅外部打单平台店铺支持刷新所在区' };
return;
}
const account = await ctx.model.ExternalPrintAccount.findOne({
where: { id: shop.external_print_account_id, principal_id: shop.principal_id },
include: [
{
model: ctx.model.ExternalPrintPlatform,
as: 'platform',
attributes: [ 'id', 'code', 'name', 'url', 'fetch_waybill_no' ],
},
],
});
if (!account) {
ctx.status = 404;
ctx.body = { code: 404, message: '店铺关联的打单账号不存在' };
return;
}
try {
const data = await ctx.service.shopAreaSync.refreshAccount(account);
ctx.body = { code: 0, message: 'success', data };
} catch (err) {
ctx.status = 400;
ctx.body = { code: 400, message: err.message };
}
}
/**
* @summary 删除店铺
* @description 物理删除店铺,其下店铺商品会一并删除;存在订单引用时请先处理
* @router delete /api/shops/{id}
* @apikey
* @request path integer *id 店铺主键ID
* @response 200 baseResponse success
*/
async destroy() {
const { ctx } = this;
const shop = await ctx.model.Shop.findByPk(ctx.params.id);
if (!shop) {
ctx.status = 404;
ctx.body = { code: 404, message: '店铺不存在' };
return;
}
// 所在公司权限:仅可删除自己所属公司的店铺;外部打单平台店铺不可删除
const access = await ctx.service.access.resolve(ctx.userId, shop.principal_id);
if (!access.isGroup) {
if (!this.isOwnSubsidiary(access, shop.subsidiary_id)) {
ctx.status = 403;
ctx.body = { code: 403, message: '仅可删除自己所属公司(货主)的店铺' };
return;
}
if (this.isExternalShop(shop)) {
ctx.status = 403;
ctx.body = { code: 403, message: '外部打单平台店铺不可删除,仅可拉取订单和同步商品' };
return;
}
}
const orderCount = await ctx.model.Order.count({ where: { shop_id: shop.id } });
if (orderCount) {
ctx.status = 400;
ctx.body = { code: 400, message: `该店铺下仍有 ${orderCount} 个订单,不能删除` };
return;
}
// 数据库店铺的连接配置随店铺一起删除(一店一条),避免残留脏配置
await ctx.model.ShopDatabaseConfig.destroy({ where: { shop_id: shop.id } });
await shop.destroy();
await ctx.service.cache.invalidateShop(ctx.params.id);
ctx.body = { code: 0, message: 'success', data: { id: Number(ctx.params.id) } };
}
}
module.exports = ShopController;