@jetta/blocks-allocator 0.0.0-stage → 0.1.0-0

package/src/input_preparation/stackability_index/Blocks_Stackability_Index_Calculator.js

@@ -0,0 +1,58 @@
+const {allocation_item_map_function} = require('../../Blocks_Preparation/Cube_Map_Function')
+const calculate_slots_stackability_index = require('./Slots_Stackability_index_Calculator')
+const {
+    create_stackability_pop_stack,
+    add_stackability_index_amount,
+    finalize_stackability_pop_stack
+} = require('./stackability_index_pop_stack')
+
+module.exports = function(block_list, item_list)
+{
+    const item_stackability_index_map = map_item_by_stackability_index(item_list)
+
+    for (const block of block_list)
+    {
+        calculate_slots_stackability_index(block, item_stackability_index_map)
+    }
+}
+
+/**
+ * @param {object[]} item_list
+ * @returns {Record<string, { segments: Array<{ value: number, remaining: number }>, segment_index: number }>}
+ */
+function map_item_by_stackability_index(item_list)
+{
+    const mapped_items = {}
+    for (const item of item_list)
+    {
+        for (const rotated_item of item.get_all_rotated_options())
+        {
+            const hash = allocation_item_map_function(rotated_item)
+            if (!mapped_items[hash])
+            {
+                mapped_items[hash] = create_stackability_pop_stack()
+            }
+            add_stackability_index_amount(
+                mapped_items[hash],
+                item.get_stackability_index(),
+                item.get_amount()
+            )
+        }
+    }
+
+    return finalize_mapped_pop_stacks(mapped_items)
+}
+
+/**
+ * @param {Record<string, { counts: Map<number, number> }>} mapped_items
+ * @returns {Record<string, { segments: Array<{ value: number, remaining: number }>, segment_index: number }>}
+ */
+function finalize_mapped_pop_stacks(mapped_items)
+{
+    const finalized = {}
+    for (const key of Object.keys(mapped_items))
+    {
+        finalized[key] = finalize_stackability_pop_stack(mapped_items[key])
+    }
+    return finalized
+}

package/src/input_preparation/stackability_index/Slots_Stackability_index_Calculator.js

@@ -0,0 +1,28 @@
+const {cube_map_function} = require('../../Blocks_Preparation/Cube_Map_Function')
+const {
+    clone_stackability_pop_stack,
+    pop_stackability_index
+} = require('./stackability_index_pop_stack')
+
+module.exports = function(block, item_stackability_index_map)
+{
+    const slot_hash_set = new Set(block.get_slot_list().map(slot => cube_map_function(slot)))
+    const possible_slots_stackability_index = {}
+    for (const slot_hash of slot_hash_set)
+    {
+        if (item_stackability_index_map[slot_hash])
+        {
+            possible_slots_stackability_index[slot_hash]
+                = clone_stackability_pop_stack(item_stackability_index_map[slot_hash])
+        }
+    }
+
+    for (const slot of block.get_slot_list())
+    {
+        const slot_hash = cube_map_function(slot)
+        const slot_stackability_index = pop_stackability_index(possible_slots_stackability_index[slot_hash])
+        slot.set_stackability_index(slot_stackability_index)
+    }
+
+    block.calculate_stackability_index()
+}

package/src/input_preparation/stackability_index/Stackability_Input_Creator.js

@@ -0,0 +1,27 @@
+module.exports = function(item_list)
+{
+    return item_list.map(item => create_input_item(item))
+}
+
+function create_input_item(item)
+{
+    return  {
+        id: item._id,
+        amount: item.qtd,
+        width: item.largura,
+        height: item.altura,
+        length: item.comprimento,
+        weight: item.peso,
+        supported_weight: item.pesoMaxSuportado,
+        maximum_stacking: item.empilhamentoMaximo,
+        rotation_list: Object.keys(item.rotacao).filter(rotation => item.rotacao[rotation]),
+        stacking_unit: item.stackingUnit.toLowerCase(),
+        stacking_rules: {
+            family: item.stacking.family,
+            supported_families: item.stacking.supported_families,
+            only_stack_same_family: item.restricoes.empilharFamilias,
+            only_stack_same_area: item.restricoes.empilharAreaIgual,
+            only_stack_same_item: item.restricoes.empilharItemIgual
+        }
+    }
+}

package/src/input_preparation/stackability_index/stackability_index_pop_stack.js

@@ -0,0 +1,81 @@
+/**
+ * @returns {{ counts: Map<number, number> }}
+ */
+function create_stackability_pop_stack()
+{
+    return { counts: new Map() }
+}
+
+/**
+ * @param {{ counts: Map<number, number> }} stack
+ * @param {number} index_value
+ * @param {number} amount
+ */
+function add_stackability_index_amount(stack, index_value, amount)
+{
+    const previous = stack.counts.get(index_value) || 0
+    stack.counts.set(index_value, previous + amount)
+}
+
+/**
+ * @param {{ counts: Map<number, number> }} stack
+ * @returns {{ segments: Array<{ value: number, remaining: number }>, segment_index: number }}
+ */
+function finalize_stackability_pop_stack(stack)
+{
+    const sorted_values = [...stack.counts.keys()].sort((left, right) => left - right)
+    const segments = sorted_values.map(value => ({
+        value,
+        remaining: stack.counts.get(value)
+    }))
+    return {
+        segments,
+        segment_index: segments.length - 1
+    }
+}
+
+/**
+ * @param {{ segments: Array<{ value: number, remaining: number }>, segment_index: number }} stack
+ * @returns {{ segments: Array<{ value: number, remaining: number }>, segment_index: number }}
+ */
+function clone_stackability_pop_stack(stack)
+{
+    const segments = stack.segments.map(segment => ({
+        value: segment.value,
+        remaining: segment.remaining
+    }))
+    let segment_index = stack.segment_index
+    while (segment_index >= 0 && segments[segment_index].remaining === 0)
+    {
+        segment_index--
+    }
+    return { segments, segment_index }
+}
+
+/**
+ * Pops the highest remaining stackability index (same order as pop on sorted expanded array).
+ * @param {{ segments: Array<{ value: number, remaining: number }>, segment_index: number }} stack
+ * @returns {number|undefined}
+ */
+function pop_stackability_index(stack)
+{
+    while (stack.segment_index >= 0)
+    {
+        const segment = stack.segments[stack.segment_index]
+        if (segment.remaining > 0)
+        {
+            segment.remaining--
+            return segment.value
+        }
+        stack.segment_index--
+    }
+    return undefined
+}
+
+module.exports = {
+    create_stackability_pop_stack,
+    add_stackability_index_amount,
+    finalize_stackability_pop_stack,
+    clone_stackability_pop_stack,
+    pop_stackability_index
+}

package/src/input_preparation/stacking_constraints/Weight_Stacking_Validation.js

@@ -0,0 +1,15 @@
+const {le} = require('@jetta/number-compare')
+const GAP = 1.5
+
+const sort_height_desc = (a, b) => b.altura - a.altura
+const sort_weight_desc = (a, b) => b.peso - a.peso
+
+const get_tallest_container_height = (container_list) => container_list.sort(sort_height_desc)[0].altura
+
+module.exports = function enable_weight_stacking_validation(transport, item_list)
+{
+    const tallest_container_height = get_tallest_container_height(transport.containers)
+    const heaviest_item            = item_list.sort(sort_weight_desc)[0]
+    const stacked_items            = Math.floor(tallest_container_height / heaviest_item.altura)
+    return le(heaviest_item.pesoMaxSuportado, (stacked_items * heaviest_item.peso * GAP))
+}

package/src/lp_optimizer_result_status.js

@@ -0,0 +1,20 @@
+/**
+ * True when the remote optimizer status should be mapped as a successful LP for allocation.
+ * @param {string|number} status - Return value of `OptimizationResult.status()` from `@jetta/lp-framework`.
+ * @returns {boolean}
+ */
+function is_lp_optimizer_result_success(status)
+{
+    if (status === 1)
+    {
+        return true
+    }
+    if (typeof status !== 'string')
+    {
+        return false
+    }
+    const normalized = status.toLowerCase()
+    return normalized !== 'infeasible' && normalized !== 'not initialized'
+}
+
+module.exports = { is_lp_optimizer_result_success }

package/src/messages/Allocator_Message.js

@@ -0,0 +1,42 @@
+/**
+ * Stable dotted keys for blocks-wall-allocation messages in jettacargo_messages.
+ * Portal-api resolves these against locales; do not use English as lookup keys.
+ */
+const ALLOCATOR_MESSAGE = Object.freeze({
+    INVALID_INPUT: 'allocator.061001',
+    INVALID_INPUT_TYPE: 'allocator.061002',
+    INVALID_BLOCK_MODULE_CONFIG: 'allocator.061003',
+    RELATION_CONFIG_MISMATCH: 'allocator.061004',
+    INTERNAL_ERROR: 'allocator.064001',
+    RELATION_COLOCATION_VIOLATION: 'allocator.064002',
+    RELATION_ALLOCATION_INCOMPLETE: 'allocator.064003',
+    NO_BLOCKS_WERE_CREATED: 'allocator.064004',
+    FAILED_TO_RETRIEVE_BLOCK: 'allocator.064005',
+    FAILED_TO_CREATE_BLOCKS: 'allocator.064006',
+    NO_BLOCK_OPTIONS: 'allocator.064007',
+    INVALID_SPACE: 'allocator.064008',
+    NO_SPACE_LEFT: 'allocator.064009',
+    OPTIMIZATION_INFEASIBLE: 'allocator.064010',
+    NO_VALID_ALLOCATION: 'allocator.064011',
+    INVALID_STACKING: 'allocator.064012',
+    NO_SUITABLE_ITEM: 'allocator.064013',
+    TIE_RATIO_ORIENTATION_MISMATCH: 'allocator.064014',
+    LOOSE_ON_TIE_RATIO_FAILED: 'allocator.064015',
+    NO_FLOOR_FOOTPRINT_TWIN: 'allocator.064016',
+    NO_AVAILABLE_ITEMS: 'allocator.064017',
+    EMPTY_SLOT: 'allocator.064018',
+    ITEM_TALLER_THAN_LIMIT: 'allocator.064019',
+    NO_SLOTS_FOR_ITEMS: 'allocator.064020',
+    RESTRICTED_BLOCK: 'allocator.064021',
+    EMPTY_BLOCK_ITEM_LIST: 'allocator.064022',
+    MISSING_ITEM_STOCK: 'allocator.064023',
+    INVALID_ITEM_AMOUNT: 'allocator.064024',
+    INVALID_PARAMETER: 'allocator.064025',
+    INSUFFICIENT_SHAPE_STOCK: 'allocator.064026',
+    LP_PLAN_ITEM_UNAVAILABLE: 'allocator.064027',
+    LP_PLAN_ITEM_STACKING_FAILED: 'allocator.064028'
+})
+
+module.exports = {
+    ALLOCATOR_MESSAGE
+}

package/src/messages/resolve_error_message_entry.js

@@ -0,0 +1,57 @@
+const { ALLOCATOR_MESSAGE } = require('./Allocator_Message')
+
+/**
+ * Builds a catalog wire tuple [dotted.key, ...params].
+ * @param {string} message_key
+ * @param {string[]} [params=[]]
+ * @returns {string[]}
+ */
+function build_message_entry(message_key, params = [])
+{
+    return [message_key, ...params]
+}
+
+/**
+ * @param {unknown} error_value
+ * @returns {boolean}
+ */
+function has_message_entry(error_value)
+{
+    return error_value !== null
+        && typeof error_value === 'object'
+        && Array.isArray(error_value.message_entry)
+}
+
+/**
+ * Resolves thrown values into catalog message tuples for the error envelope.
+ * @param {unknown} error_value
+ * @returns {string[][]}
+ */
+function resolve_error_message_entry(error_value)
+{
+    if (has_message_entry(error_value))
+    {
+        return [error_value.message_entry]
+    }
+
+    if (is_no_space_left_exception(error_value))
+    {
+        return [[ALLOCATOR_MESSAGE.NO_SPACE_LEFT]]
+    }
+
+    return [[ALLOCATOR_MESSAGE.INTERNAL_ERROR]]
+}
+
+/**
+ * @param {unknown} error_value
+ * @returns {boolean}
+ */
+function is_no_space_left_exception(error_value)
+{
+    return error_value !== null
+        && typeof error_value === 'object'
+        && error_value.name === 'NoSpaceLeftException'
+}
+
+module.exports = resolve_error_message_entry
+module.exports.build_message_entry = build_message_entry

package/src/models/Allocated_Item.js

@@ -0,0 +1,136 @@
+const { PositionedCube} = require('@jetta/empty-spaces-manager')
+const { read_stacking_rules } = require('./Stacking_Rules')
+class Allocated_Item extends PositionedCube
+{
+    #item
+    #group_id
+    #tie_ratio_orientation
+    constructor(item, x, y, z)
+    {
+        super({
+            x,
+            y,
+            z,
+            width: item.get_width(),
+            height: item.get_height(),
+            length: item.get_length()
+        })
+        this.#item = item
+        this.#group_id = item.get_group_id()
+        this.#tie_ratio_orientation = item.get_tie_ratio_orientation?.()
+    }
+
+    get_weight()
+    {
+        return this.#item.get_weight()
+    }
+
+    get_allocation_item()
+    {
+        return this.#item.copy()
+    }
+
+    /**
+     * Returns the wrapped allocation item without copying (for stacking validation reads).
+     * @returns {object}
+     */
+    get_stacking_source_item()
+    {
+        return this.#item
+    }
+
+    set_group_id(group_id)
+    {
+        this.#group_id = group_id
+    }
+
+    /**
+     * @returns {'3_2'|'2_3'|undefined} Tie-ratio variant orientation for compound blocks.
+     */
+    get_tie_ratio_orientation()
+    {
+        return this.#tie_ratio_orientation
+    }
+
+    set_tie_ratio_orientation(tie_ratio_orientation)
+    {
+        this.#tie_ratio_orientation = tie_ratio_orientation
+    }
+
+    /**
+     * @returns {string|number|undefined} Block group identifier shared by slots in the same compound block.
+     */
+    get_group_id()
+    {
+        return this.#group_id
+    }
+
+    to_json()
+    {
+        const contract = {
+            'type': this.#item.get_json()['tipo'],
+            'y': this.get_z(),//disgraça de inversão
+            'x': this.get_x(),
+            'z': this.get_y(),//disgraça de inversão
+            'tipo': this.#item.get_json()['tipo'],
+            'rotation': this.#item.get_current_rotation_id(),
+            '_id': this.#item.get_json()['_id'],
+            'rotaSequencia': this.#item.get_json()['rotaSequencia'] ?? 0,
+            'h': this.get_height(),
+            'w': this.get_width(),
+            'd': this.get_length(),
+            'wg': this.#item.get_json()['peso'] ?? this.#item.get_json()['wg'],
+            'supported_weight': this.#item.get_json()['pesoMaxSuportado'] ?? this.#item.get_json()['supported_weight'],
+            'constraint': read_stacking_rules(this.#item.get_json()),
+            'current_rotation': this.#item.get_current_rotation(),
+            'stacking': this.#item.get_json()['stacking'],
+            'stacking_limit': this.#item.get_json()['empilhamentoMaximo'] ?? this.#item.get_json()['stacking_limit'],
+            'waypoint_id': this.#item.get_json()['cliente'] ?? this.#item.get_json()['waypoint_id'] ?? '',
+            'priority': this.#item.get_json()['priority'] ?? this.#item.get_json()['prioridade'] ?? 0,
+            'restrictions':this.#item.get_json()['restricoes'] ?? this.#item.get_json()['restrictions'],
+            'is_previously_allocated':this.#item.get_json()['is_previously_allocated'],
+            'embalagem':this.#item.get_json()['embalagem'],
+            'id':this.#item.get_json()['id'],
+            'stackingUnit':this.#item.get_json()['stackingUnit']
+        }
+        if (this.#group_id !== undefined)
+        {
+            contract.groupId = this.#group_id
+        }
+        if (this.#tie_ratio_orientation !== undefined)
+        {
+            contract.tie_ratio_orientation = this.#tie_ratio_orientation
+        }
+
+        return contract
+    }
+
+    is_block_with_slots_of_same_measure()
+    {
+        return this.#item.get_json()['is_slots_of_same_measure'] || false
+    }
+
+    get_id()
+    {
+        return this.#item.get_id()
+    }
+
+    to_simplified_json()
+    {
+        const contract = {
+            'type': this.#item.get_json()['tipo'],
+            'y': this.get_y(),//disgraça de inversão
+            'x': this.get_x(),
+            'z': this.get_z(),//disgraça de inversão
+            '_id': this.#item.get_json()['_id'],
+            'h': this.get_height(),
+            'w': this.get_width(),
+            'd': this.get_length(),
+            'waypoint_id': this.#item.get_json()['cliente'] || '',
+        }
+
+        return contract
+    }
+}
+
+module.exports = Allocated_Item

package/src/models/Allocation_Item.js

@@ -0,0 +1,219 @@
+const { Item, Rotations } = require('@jetta/empty-spaces-manager')
+const item_json_reader = require('./item_json_reader')
+const Allocated_Item = require('./Allocated_Item')
+const round = require('../tools/Rounder')
+const { allocation_item_map_function } = require('../Blocks_Preparation/Cube_Map_Function')
+const SUPPORTED_WEIGTH_STACKING_STR = 'supportedWeight'
+const is_object = (value) => value !== null && typeof value === 'object' && Object.getPrototypeOf(value) === Object.prototype
+
+class Allocation_Item extends Item
+{
+    #json
+    #weight
+    #amount
+    #id
+    #x
+    #y
+    #z
+    #group_id
+    #relational_group_id
+    #relational_links
+    #tie_ratio_orientation
+    #stackability_index
+    #stacking_info
+    #all_rotated_options_cache = null
+
+    constructor(data, rotation = Rotations.POS1)
+    {
+        super(item_json_reader(data, rotation))
+        this.#json = data
+        this.#weight = data.peso ?? data.weight ?? data.wg
+        this.#id = data._id
+        this.#amount = data.qtd ?? 0
+        const sp =  this.#get_starting_point_data(data)
+        this.#x = sp.x
+        this.#y = sp.y
+        this.#z = sp.z
+        this.#group_id = data.groupId
+        this.#relational_group_id = data.relational_group_id
+        this.#relational_links = data.relational_links
+        this.#tie_ratio_orientation = data.tie_ratio_orientation
+        this.#stackability_index = data.stackability_index
+        this.#stacking_info = this.#set_stacking_info(data)
+    }
+
+    #get_starting_point_data(data)
+    {
+        if (is_object(data))
+        {
+            return { x: data.x ?? 0, y: data.z ?? 0, z: data.y ?? 0 }
+        }
+
+        return {x: data.get_x(), y: data.get_y(), z: data.get_z()}
+    }
+
+    #set_stacking_info(json)
+    {
+        return {
+            weight: json.peso ?? json.wg,
+            supported_weight : json.pesoMaxSuportado ?? json.supported_weight,
+            max_stacking: json.empilhamentoMaximo ?? json.stacking_limit,
+            restrictions : json.restricoes ?? json.restrictions,
+            stacking_family : json.stacking?.family,
+            stack_by_supported_weight : json.stackingUnit === SUPPORTED_WEIGTH_STACKING_STR,
+            supported_families: json.stacking?.supported_families,
+            priority: json.prioridade ?? json.priority
+        }
+    }
+
+    get_stacking_info()
+    {
+        return this.#stacking_info
+    }
+
+
+    get_stackability_index()
+    {
+        return this.#stackability_index
+    }
+
+    set_group_id(group_id)
+    {
+        this.#group_id = group_id
+    }
+
+    get_group_id()
+    {
+        return this.#group_id
+    }
+
+    get_relational_group_id()
+    {
+        return this.#relational_group_id
+    }
+
+    get_relational_links()
+    {
+        return this.#relational_links
+    }
+
+    get_relational_link_quantity()
+    {
+        if (!this.#relational_links)
+        {
+            return 1
+        }
+        return this.#relational_links[this.get_user_id()] || 1
+    }
+
+    get_tie_ratio_orientation()
+    {
+        return this.#tie_ratio_orientation
+    }
+
+    set_tie_ratio_orientation(tie_ratio_orientation)
+    {
+        this.#tie_ratio_orientation = tie_ratio_orientation
+    }
+
+    get_weight()
+    {
+        return this.#weight
+    }
+
+    get_id()
+    {
+        return this.#id
+    }
+
+    get_user_id()
+    {
+        return this.#json.id
+    }
+
+    update_amount(amount)
+    {
+        this.#amount = amount
+    }
+
+    get_amount()
+    {
+        return this.#amount
+    }
+
+    copy_rotated(rotated_item)
+    {
+        const copy = this.copy()
+        copy.copy_dimensions(rotated_item)
+        return copy
+    }
+
+    copy()
+    {
+        const copy = new Allocation_Item(this.#json)
+        copy.update_amount(this.#amount)
+        return copy
+    }
+
+    get_x()
+    {
+        return this.#x
+    }
+
+    get_y()
+    {
+        return this.#y
+    }
+
+    get_z()
+    {
+        return this.#z
+    }
+
+    sum_position_vector(vector)
+    {
+        this.#x = round(vector.get_x() + this.#x)
+        this.#y = round(vector.get_y() + this.#y)
+        this.#z = round(vector.get_z() + this.#z)
+    }
+
+    get_item_as_positioned_cube()
+    {
+        const item =  new Allocated_Item(
+            this,
+            this.#x,
+            this.#y,
+            this.#z
+        )
+        item.set_group_id(this.#group_id)
+        if (this.#tie_ratio_orientation !== undefined)
+        {
+            item.set_tie_ratio_orientation(this.#tie_ratio_orientation)
+        }
+        return item
+    }
+
+    get_json()
+    {
+        return Object.assign({}, this.#json)
+    }
+
+    get_hash()
+    {
+        return allocation_item_map_function(this)
+    }
+
+    /**
+     * @returns {Array<object>}
+     */
+    get_all_rotated_options()
+    {
+        if (this.#all_rotated_options_cache === null)
+        {
+            this.#all_rotated_options_cache = super.get_all_rotated_options()
+        }
+        return this.#all_rotated_options_cache
+    }
+}
+
+module.exports = Allocation_Item