WMS_MAIN/app/service/systems/location.js
liufumingren 5ce689d771 1
Co-authored-by: Copilot <copilot@github.com>
2026-04-30 19:20:31 +08:00

421 lines
12 KiB
JavaScript
Raw 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 Service = require('egg').Service;
class LocationService extends Service {
/**
* 创建货架并自动生成仓位
* @param {Object} params 货架基础参数
*/
async createRackWithSpaces(params) {
const { ctx } = this;
const { app } = ctx;
// 开启事务
return await app.model.transaction(async transaction => {
// 1. 创建货架
const rack = await app.model.LocationZone.create({
...params,
zone_type: 'rack',
is_active: true,
}, { transaction });
// 2. 自动生成仓位
await this._generateSpacesForRack(rack.id, rack, transaction);
// 3. 计算库区内的货架排序
if (rack.parent_id) {
await this._calculateAreaRackOrder(rack.warehouse_id, rack.parent_id, transaction);
}
// 4. 计算拣货路径
await this._calculatePickPathForWarehouse(rack.warehouse_id, transaction);
return rack;
});
}
/**
* 为货架生成仓位
* @param {number|string} rackId 货架ID
* @param {Object} rack 货架信息
* @param {Object} transaction 事务对象
*/
async _generateSpacesForRack(rackId, rack, transaction) {
const { app } = this;
const { rack_columns, rack_rows, rack_levels } = rack;
const spaces = [];
// 计算每个仓位的尺寸
const cellLength = rack.length / rack_columns / 10; // mm转cm
const cellWidth = rack.width / rack_levels / 10; // mm转cm
const cellHeight = rack.height / rack_rows / 10; // mm转cm
// 生成所有仓位
for (let row = 1; row <= rack_rows; row++) {
for (let column = 1; column <= rack_columns; column++) {
for (let level = 1; level <= rack_levels; level++) {
const spaceCode = `${rack.zone_code}-${column.toString().padStart(2, '0')}-${row.toString().padStart(2, '0')}-${level.toString().padStart(2, '0')}`;
// 计算相对坐标
const relativeX = (column - 1) * cellLength;
const relativeY = (row - 1) * cellHeight;
const relativeZ = (level - 1) * cellWidth;
spaces.push({
warehouse_id: rack.warehouse_id,
zone_id: rackId,
location_type_id: 1, // 默认仓位类型
space_code: spaceCode,
row_no: row.toString(),
column_no: column.toString(),
level_no: level.toString(),
cell_no: `${column}-${row}-${level}`,
length: cellLength,
width: cellWidth,
height: cellHeight,
volume: cellLength * cellWidth * cellHeight / 1000000, // cm³转m³
max_weight: 100, // 默认100kg
space_status: 'AVAILABLE',
is_enabled: true,
relative_x: relativeX,
relative_y: relativeY,
relative_z: relativeZ,
});
}
}
}
// 批量插入仓位
if (spaces.length > 0) {
await app.model.LocationSpace.bulkCreate(spaces, { transaction });
}
this.ctx.logger.info(`为货架 ${rack.zone_code} 生成了 ${spaces.length} 个仓位`);
}
/**
* 计算库区内货架的排序(按X坐标排序)
* @param {number|string} warehouseId 仓库ID
* @param {number|string} areaId 库区ID
* @param {Object} transaction 事务对象
*/
async _calculateAreaRackOrder(warehouseId, areaId, transaction) {
const { app } = this;
// 获取库区内的所有货架,按X坐标排序
const racks = await app.model.LocationZone.findAll({
where: {
warehouse_id: warehouseId,
parent_id: areaId,
zone_type: 'rack',
is_active: true,
deleted_at: null,
},
order: [[ 'x', 'ASC' ]],
transaction,
});
// 更新排序序号
for (let i = 0; i < racks.length; i++) {
await racks[i].update({
path_sequence: i + 1,
}, { transaction });
}
this.ctx.logger.info(`更新库区 ${areaId} 内 ${racks.length} 个货架的排序`);
}
/**
* 计算仓库的拣货路径
* @param {number|string} warehouseId 仓库ID
* @param {Object} transaction 事务对象
*/
async _calculatePickPathForWarehouse(warehouseId, transaction) {
const { app } = this;
// 1. 获取起始拣货点
const pickStart = await app.model.LocationZone.findOne({
where: {
warehouse_id: warehouseId,
zone_type: 'pick_start',
is_active: true,
deleted_at: null,
},
transaction,
});
if (!pickStart) {
this.ctx.logger.warn(`仓库 ${warehouseId} 没有设置起始拣货点`);
return;
}
// 2. 获取所有货架,按距离排序
const racks = await app.model.LocationZone.findAll({
where: {
warehouse_id: warehouseId,
zone_type: 'rack',
is_active: true,
deleted_at: null,
},
transaction,
});
// 3. 计算距离并排序(曼哈顿距离)
const sortedRacks = racks.map(rack => {
const distance = Math.abs(rack.x - pickStart.x) + Math.abs(rack.y - pickStart.y);
return {
rack,
distance,
};
}).sort((a, b) => a.distance - b.distance);
// 4. 更新货架的拣货顺序和距离
for (let i = 0; i < sortedRacks.length; i++) {
const { rack, distance } = sortedRacks[i];
await rack.update({
path_sequence: i + 1,
pick_distance: distance,
}, { transaction });
// 5. 更新该货架下所有仓位的拣货顺序
await this._updateSpacePickSequence(rack.id, i + 1, distance, transaction);
}
this.ctx.logger.info(`为仓库 ${warehouseId} 计算了 ${sortedRacks.length} 个货架的拣货路径`);
}
/**
* 更新货架下仓位的拣货顺序
* @param {number|string} rackId 货架ID
* @param {number} rackSequence 货架拣货顺序
* @param {number} rackDistance 起始点距离
* @param {Object} transaction 事务对象
*/
async _updateSpacePickSequence(rackId, rackSequence, rackDistance, transaction) {
const { app } = this;
// 获取货架信息
const rack = await app.model.LocationZone.findByPk(rackId, { transaction });
if (!rack) return;
// 获取货架的所有仓位
const spaces = await app.model.LocationSpace.findAll({
where: {
zone_id: rackId,
is_enabled: true,
deleted_at: null,
},
order: [
[ 'row_no', 'ASC' ], // 从下层开始
[ 'column_no', 'ASC' ], // 从左到右
[ 'level_no', 'ASC' ], // 从外到内
],
transaction,
});
// 更新每个仓位的拣货顺序
for (let i = 0; i < spaces.length; i++) {
const space = spaces[i];
const spaceSequence = rackSequence * 1000 + i + 1; // 货架顺序 + 仓位顺序
// 计算预估拣货时间(基于层数)
const row = parseInt(space.row_no) || 1;
let pickTimeEstimate = 30; // 默认30秒
if (row <= 2) pickTimeEstimate = 25; // 下层快
else if (row <= 4) pickTimeEstimate = 40; // 中层需要梯子
else pickTimeEstimate = 60; // 上层需要设备
await space.update({
pick_sequence: spaceSequence,
distance_from_start: rackDistance,
pick_time_estimate: pickTimeEstimate,
pick_priority: this._calculatePickPriority(row, rackDistance),
}, { transaction });
}
this.ctx.logger.info(`更新货架 ${rack.zone_code} 下 ${spaces.length} 个仓位的拣货顺序`);
}
/**
* 计算拣货优先级
* @param {number} row 层数
* @param {number} distance 距离
*/
_calculatePickPriority(row, distance) {
// 行数越小(下层)优先级越高
const rowPriority = Math.max(1, 10 - (row || 1));
// 距离越近优先级越高
const distancePriority = Math.max(1, 10 - Math.floor(distance / 1000));
// 综合优先级(1-100)
return Math.min(100, Math.max(1, rowPriority * 5 + distancePriority * 5));
}
/**
* 更新货架位置后重新计算路径
* @param {number|string} rackId 货架ID
* @param {Object} newPosition 新坐标
*/
async updateRackPosition(rackId, newPosition) {
const { ctx, app } = this;
return await app.model.transaction(async transaction => {
// 1. 检查货架是否有占用仓位
const occupiedSpaces = await app.model.LocationSpace.count({
where: {
zone_id: rackId,
space_status: [ 'OCCUPIED', 'RESERVED' ],
is_enabled: true,
deleted_at: null,
},
transaction,
});
if (occupiedSpaces > 0) {
ctx.throw(400, `货架有 ${occupiedSpaces} 个占用或预留仓位,不能修改位置`);
}
// 2. 更新货架位置
const rack = await app.model.LocationZone.findByPk(rackId, { transaction });
if (!rack) {
ctx.throw(404, '货架不存在');
}
await rack.update({
x: newPosition.x,
y: newPosition.y,
z: newPosition.z || rack.z,
}, { transaction });
// 3. 重新计算库区内货架排序
if (rack.parent_id) {
await this._calculateAreaRackOrder(rack.warehouse_id, rack.parent_id, transaction);
}
// 4. 重新计算拣货路径
await this._calculatePickPathForWarehouse(rack.warehouse_id, transaction);
return rack;
});
}
/**
* 获取拣货路径
* @param {number|string} warehouseId 仓库ID
* @param {Object} options 查询选项
*/
async getPickPath(warehouseId, options = {}) {
const { app } = this;
const {
includeSpaces = false,
limit = 50,
sortBy = 'path_sequence',
} = options;
// 获取货架的拣货路径
const racks = await app.model.LocationZone.findAll({
where: {
warehouse_id: warehouseId,
zone_type: 'rack',
is_active: true,
deleted_at: null,
},
order: [[ sortBy, 'ASC' ]],
limit,
include: includeSpaces ? [{
model: app.model.LocationSpace,
as: 'spaces',
where: {
is_enabled: true,
deleted_at: null,
space_status: [ 'AVAILABLE', 'OCCUPIED' ],
},
required: false,
order: [[ 'pick_sequence', 'ASC' ]],
}] : [],
});
// 计算总距离和时间
let totalDistance = 0;
let totalTime = 0;
racks.forEach(rack => {
if (rack.pick_distance) totalDistance += rack.pick_distance;
if (rack.spaces) {
rack.spaces.forEach(space => {
if (space.pick_time_estimate) totalTime += space.pick_time_estimate;
});
}
});
return {
racks,
summary: {
totalRacks: racks.length,
totalDistance: `${(totalDistance / 1000).toFixed(2)}米`,
estimatedTotalTime: `${Math.ceil(totalTime / 60)}分钟`,
},
};
}
/**
* 批量更新邻居关系
* @param {number|string} warehouseId 仓库ID
*/
async updateNeighborRelations(warehouseId) {
const { app } = this;
// 获取所有货架
const racks = await app.model.LocationZone.findAll({
where: {
warehouse_id: warehouseId,
zone_type: 'rack',
is_active: true,
deleted_at: null,
},
});
// 为每个货架计算邻居
for (const rack of racks) {
const neighbors = await this._findNeighborRacks(rack, racks);
await rack.update({
neighbor_zone_ids: neighbors.map(n => n.id),
});
}
this.ctx.logger.info(`为仓库 ${warehouseId} 更新了 ${racks.length} 个货架的邻居关系`);
}
/**
* 查找相邻货架
* @param {Object} currentRack 当前货架
* @param {Array<Object>} allRacks 所有货架
*/
async _findNeighborRacks(currentRack, allRacks) {
const NEIGHBOR_DISTANCE = 2000; // 2米内视为邻居
return allRacks.filter(rack => {
if (rack.id === currentRack.id) return false;
// 计算两个货架中心点的距离
const currentCenterX = currentRack.x + currentRack.length / 2;
const currentCenterY = currentRack.y + currentRack.width / 2;
const rackCenterX = rack.x + rack.length / 2;
const rackCenterY = rack.y + rack.width / 2;
const distance = Math.sqrt(
Math.pow(currentCenterX - rackCenterX, 2) +
Math.pow(currentCenterY - rackCenterY, 2)
);
return distance <= NEIGHBOR_DISTANCE;
});
}
}
module.exports = LocationService;