@jetta/blocks-allocator 0.0.0-stage → 0.1.0

package/src/models/Preloaded_Allocated_Item.js

@@ -0,0 +1,132 @@
+const { PositionedCube } = require('@jetta/empty-spaces-manager')
+const {
+    build_placed_item_record,
+    build_stacking_info,
+    read_placed_position
+} = require('./placed_item_record')
+const { read_current_rotation, read_rotation_id } = require('./preloaded_rotation_helpers')
+
+function read_wire_dimensions(wire)
+{
+    return {
+        width: wire.w ?? wire.largura ?? wire.width,
+        height: wire.h ?? wire.altura ?? wire.height,
+        length: wire.d ?? wire.comprimento ?? wire.length
+    }
+}
+
+/**
+ * Lightweight in-memory model for a previously placed item (no rotation machinery).
+ */
+class Preloaded_Allocated_Item extends PositionedCube
+{
+    #record
+    #stacking_info
+    #current_rotation
+    #rotation_id
+
+    /**
+     * @param {object} wire - Raw placed item from `container.items`.
+     */
+    constructor(wire)
+    {
+        const position = read_placed_position(wire)
+        const dimensions = read_wire_dimensions(wire)
+        super({
+            x: position.x,
+            y: position.y,
+            z: position.z,
+            width: dimensions.width,
+            height: dimensions.height,
+            length: dimensions.length
+        })
+        this.#record = build_placed_item_record(wire)
+        this.#stacking_info = build_stacking_info(wire)
+        this.#current_rotation = read_current_rotation(wire)
+        this.#rotation_id = read_rotation_id(wire)
+    }
+
+    get_stacking_info()
+    {
+        return this.#stacking_info
+    }
+
+    set_group_id(group_id)
+    {
+        this.#record.groupId = group_id
+    }
+
+    get_group_id()
+    {
+        return this.#record.groupId
+    }
+
+    get_weight()
+    {
+        return this.#record.peso
+    }
+
+    get_id()
+    {
+        return this.#record._id
+    }
+
+    /**
+     * User-facing SKU id for relational counting (matches {@link Allocation_Item#get_user_id}).
+     * @returns {string|number|undefined}
+     */
+    get_user_id()
+    {
+        return this.#record.id
+    }
+
+    /**
+     * @returns {string|undefined}
+     */
+    get_relational_group_id()
+    {
+        return this.#record.relational_group_id
+    }
+
+    get_amount()
+    {
+        return 0
+    }
+
+    get_current_rotation()
+    {
+        return this.#current_rotation
+    }
+
+    get_current_rotation_id()
+    {
+        return this.#rotation_id
+    }
+
+    get_json()
+    {
+        return { ...this.#record }
+    }
+
+    /**
+     * Preloaded items are immutable; returns a new instance with the same wire shape.
+     * @returns {Preloaded_Allocated_Item}
+     */
+    copy()
+    {
+        const wire = {
+            ...this.#record,
+            x: this.get_x(),
+            y: this.get_z(),
+            z: this.get_y(),
+            w: this.get_width(),
+            h: this.get_height(),
+            d: this.get_length(),
+            current_rotation: this.#current_rotation,
+            rotation: this.#rotation_id
+        }
+        return new Preloaded_Allocated_Item(wire)
+    }
+}
+
+module.exports = Preloaded_Allocated_Item

package/src/models/Slot.js

@@ -0,0 +1,67 @@
+const assert            = require('assert')
+const {PositionedCube} = require('@jetta/empty-spaces-manager')
+const round             = require('../tools/Rounder')
+const clone             = require('../tools/Clone')
+const {eq}              = require('@jetta/number-compare')
+
+
+module.exports = class Slot extends PositionedCube
+{
+    #stackability_index = -1
+    #volume
+    constructor(x, y, z, width, height, length)
+    {
+        super({ x, y, z, width, height, length })
+        this.#volume = round(width * height * length)
+    }
+
+    get_stackability_index()
+    {
+        assert(this.#stackability_index >= 0,'stackability index has not been set.')
+        return this.#stackability_index
+    }
+
+    set_stackability_index(stackability_index)
+    {
+        assert(stackability_index >= 0,'stackability index must be bigger or equal zero.')
+        this.#stackability_index = stackability_index
+    }
+
+    get_volume()
+    {
+        return clone(this.#volume)
+    }
+
+    to_string()
+    {
+        return `${this.get_width()};${this.get_height()};${this.get_length()}`
+    }
+
+    get_hash()
+    {
+        return `${this.get_x()};${this.get_y()};${this.get_z()};${this.to_string()}`
+    }
+
+    rotated_item_fits_perfectly(item)
+    {
+
+        const fit_width  = eq(item.get_width(), this.get_width())
+        const fit_height = eq(item.get_height(), this.get_height())
+        const fit_length = eq(item.get_length(), this.get_length())
+
+        return fit_width && fit_height && fit_length
+    }
+
+    some_rotation_fits_perfectly(item)
+    {
+        const rotations = item.get_rotations()
+        const compatible_rotations = rotations
+            .map(rotation =>
+            {
+                return this.rotated_item_fits_perfectly(item.get_rotated_item(rotation))
+            })
+            .filter( result => result )
+
+        return compatible_rotations.length > 0
+    }
+}

package/src/models/Stacking_Rules.js

@@ -0,0 +1,58 @@
+
+const SAME_PACKAGE = 'EMBALAGENS_IGUAIS'
+const SAME_AREA = 'AREAS_IGUAIS'
+const ALLOWED_FAMILIES = 'ALLOWED_FAMILIES'
+const ALLOWED_FAMILIES_WITH_SAME_AREA = 'ALLOWED_FAMILIES_WITH_SAME_AREA'
+const NO_DEFINED_RULE = 'SEM_REGRA_DEFINIDA'
+const stacking_rules = {
+    SAME_PACKAGE,
+    SAME_AREA,
+    ALLOWED_FAMILIES,
+    ALLOWED_FAMILIES_WITH_SAME_AREA,
+    NO_DEFINED_RULE
+}
+
+
+function read_restrictions(restrictions)
+{
+    const same_area = restrictions['empilharAreaIgual'] || false
+    const same_package = restrictions['empilharItemIgual'] || false
+    const allowed_families = restrictions['empilharFamilias'] || false
+
+    if (same_package)
+    {
+        return SAME_PACKAGE
+    }
+    if (same_area && allowed_families)
+    {
+        return ALLOWED_FAMILIES_WITH_SAME_AREA
+    }
+    if (same_area)
+    {
+        return SAME_AREA
+    }
+    if (allowed_families)
+    {
+        return ALLOWED_FAMILIES
+    }
+    return NO_DEFINED_RULE
+}
+
+function read_stacking_rules(item_json)
+{
+
+    const restrictions = item_json['restricoes']
+    if (restrictions != undefined && restrictions != '')
+    {
+        return read_restrictions(restrictions)
+    }
+
+    const constraint = item_json['constraint']
+    if (constraint !== undefined || constraint !== '')
+    {
+        return constraint || NO_DEFINED_RULE
+    }
+    return NO_DEFINED_RULE
+}
+
+module.exports = {stacking_rules, read_stacking_rules}

package/src/models/auxiliaryFunctions/Available_Block_Module_List_Creator.js

@@ -0,0 +1,9 @@
+const {
+    build_effective_block_module_list,
+} = require('../../validation/validate_block_module_config')
+
+module.exports = function create_block_module_list(config)
+{
+    const available_blocks = config.available_blocks
+    return build_effective_block_module_list(config, available_blocks)
+}

package/src/models/auxiliaryFunctions/Measure_Translator.js

@@ -0,0 +1,24 @@
+class Translator extends Map
+{
+    constructor()
+    {
+        super()
+        const w = ['largura', 'width', 'w']
+        const h = ['altura', 'height', 'h']
+        const l = ['comprimento', 'length', 'l', 'd']
+        const measure_list = [w, h, l]
+
+        for (const measures of measure_list)
+        {
+            measures.forEach(measure => this.set(measure, measures))
+        }
+    }
+
+    get_measure(measure)
+    {
+        const measures = this.get(measure)
+        return measures
+    }
+}
+
+module.exports = new Translator()

package/src/models/auxiliaryFunctions/item_json_reader.js

@@ -0,0 +1,44 @@
+const { Rotations } = require('@jetta/empty-spaces-manager')
+const translator    = require('./Measure_Translator')
+
+function read_measures(object, measure_list)
+{
+    for (const original_measure of measure_list)
+    {
+        const translated_measures = translator.get_measure(original_measure)
+
+        for (const measure of translated_measures)
+        {
+            if (object[measure])
+            {
+                return object[measure]
+            }
+        }
+    }
+    throw new Error('not found field in json whilst allocating blocks')
+}
+
+function read_rotations(rotations, defaulty = ['pos1'])
+{
+    if (rotations && Object.keys(rotations).length > 0)
+    {
+        return Object.keys(rotations).filter(rotation=>rotations[rotation])
+    }
+    return defaulty
+}
+
+function item_json_reader(json, rotation = Rotations.POS1)
+{
+    const params = [
+        read_measures(json, ['largura', 'width']),
+        read_measures(json, ['altura', 'height']),
+        read_measures(json, ['comprimento', 'length']),
+        read_rotations(json.rotacao),
+        rotation
+    ]
+
+    return params
+}
+
+
+module.exports = item_json_reader

package/src/models/item_json_reader.js

@@ -0,0 +1,71 @@
+const { Rotations } = require('@jetta/empty-spaces-manager')
+
+function read_possibilities(obj, fields, defaulty = NaN)
+{
+    for (const field of fields)
+    {
+        if (obj[field])
+        {
+            return obj[field]
+        }
+    }
+    return defaulty
+}
+
+function read_rotations(rotations, defaulty = ['pos1'])
+{
+    if (rotations && Object.keys(rotations).length > 0)
+    {
+        return Object.keys(rotations).filter(rotation => rotations[rotation])
+    }
+    return defaulty
+}
+
+function normalize_rotation_id(rotation)
+{
+    const r = String(rotation).toLowerCase()
+    if (r.startsWith('position'))
+    {
+        return `pos${r.slice('position'.length)}`
+    }
+    return r
+}
+
+function read_rotations_from_json(json)
+{
+    const defaulty = ['pos1']
+    if (json.rotacao !== undefined && json.rotacao !== null)
+    {
+        if (Array.isArray(json.rotacao))
+        {
+            return json.rotacao.length > 0
+                ? json.rotacao.map(normalize_rotation_id)
+                : defaulty
+        }
+        return read_rotations(json.rotacao, defaulty)
+    }
+    const list = json.rotation_list
+    if (Array.isArray(list) && list.length > 0)
+    {
+        return list.map(normalize_rotation_id)
+    }
+    return defaulty
+}
+
+/**
+ * Builds an {@link Item} constructor spec from loose JSON (Portuguese or English field names).
+ *
+ * @param {object} json - Raw item fields (`largura`/`width`, `rotacao` or `rotation_list`, etc.).
+ * @param {string} [rotation=Rotations.POS1] - `current_rotation` for the spec.
+ * @returns {{ width: number, height: number, length: number, rotations: string[], current_rotation: string }}
+ */
+function item_json_reader(json, rotation = Rotations.POS1)
+{
+    const width = read_possibilities(json, ['largura', 'width', 'w'])
+    const height = read_possibilities(json, ['altura', 'height', 'h'])
+    const length = read_possibilities(json, ['comprimento', 'length', 'd'])
+    const rotations = read_rotations_from_json(json)
+    return { width, height, length, rotations, current_rotation: rotation }
+}
+
+module.exports = item_json_reader

package/src/models/placed_item_record.js

@@ -0,0 +1,70 @@
+const SUPPORTED_WEIGTH_STACKING_STR = 'supportedWeight'
+
+/**
+ * Builds a compact field bag for a previously placed item wire payload.
+ * @param {object} data - Raw placed item from container.items.
+ * @returns {object}
+ */
+function build_placed_item_record(data)
+{
+    return {
+        _id: data._id,
+        id: data.id,
+        tipo: data.tipo ?? data.type,
+        peso: data.peso ?? data.wg ?? data.weight,
+        wg: data.wg ?? data.peso ?? data.weight,
+        pesoMaxSuportado: data.pesoMaxSuportado ?? data.supported_weight,
+        supported_weight: data.supported_weight ?? data.pesoMaxSuportado,
+        empilhamentoMaximo: data.empilhamentoMaximo ?? data.stacking_limit,
+        stacking_limit: data.stacking_limit ?? data.empilhamentoMaximo,
+        restricoes: data.restricoes ?? data.restrictions ?? {},
+        restrictions: data.restrictions ?? data.restricoes ?? {},
+        stacking: data.stacking,
+        stackingUnit: data.stackingUnit,
+        groupId: data.groupId,
+        relational_group_id: data.relational_group_id,
+        rotaSequencia: data.rotaSequencia ?? 0,
+        priority: data.priority ?? data.prioridade ?? 0,
+        prioridade: data.prioridade ?? data.priority ?? 0,
+        is_previously_allocated: data.is_previously_allocated,
+        embalagem: data.embalagem,
+        cliente: data.cliente ?? data.waypoint_id ?? ''
+    }
+}
+
+/**
+ * @param {object} data - Raw placed item payload.
+ * @returns {object}
+ */
+function build_stacking_info(data)
+{
+    return {
+        weight: data.peso ?? data.wg ?? data.weight,
+        supported_weight: data.pesoMaxSuportado ?? data.supported_weight,
+        max_stacking: data.empilhamentoMaximo ?? data.stacking_limit,
+        restrictions: data.restricoes ?? data.restrictions ?? {},
+        stacking_family: data.stacking?.family,
+        stack_by_supported_weight: data.stackingUnit === SUPPORTED_WEIGTH_STACKING_STR,
+        supported_families: data.stacking?.supported_families,
+        priority: data.prioridade ?? data.priority
+    }
+}
+
+/**
+ * @param {object} data - Raw placed item payload.
+ * @returns {{ x: number, y: number, z: number }}
+ */
+function read_placed_position(data)
+{
+    return {
+        x: data.x ?? 0,
+        y: data.z ?? 0,
+        z: data.y ?? 0
+    }
+}
+
+module.exports = {
+    build_placed_item_record,
+    build_stacking_info,
+    read_placed_position
+}

package/src/models/preloaded_rotation_helpers.js

@@ -0,0 +1,38 @@
+const { Rotations } = require('@jetta/empty-spaces-manager')
+
+const ROTATION_ID_BY_NAME = {
+    [Rotations.POS1]: 0,
+    [Rotations.POS2]: 1,
+    [Rotations.POS3]: 2,
+    [Rotations.POS4]: 3,
+    [Rotations.POS5]: 4,
+    [Rotations.POS6]: 5
+}
+
+/**
+ * @param {object} wire - Placed item wire payload.
+ * @returns {string}
+ */
+function read_current_rotation(wire)
+{
+    return wire.current_rotation ?? Rotations.POS1
+}
+
+/**
+ * @param {object} wire - Placed item wire payload.
+ * @returns {number}
+ */
+function read_rotation_id(wire)
+{
+    if (wire.rotation !== undefined && wire.rotation !== null)
+    {
+        return wire.rotation
+    }
+    const rotation_name = read_current_rotation(wire)
+    return ROTATION_ID_BY_NAME[rotation_name] ?? 0
+}
+
+module.exports = {
+    read_current_rotation,
+    read_rotation_id
+}

package/src/models/slots_have_same_measure.js

@@ -0,0 +1,45 @@
+const { eq } = require('@jetta/number-compare')
+
+/**
+ * Whether every slot shares the same height and the same footprint, allowing
+ * width and length to be swapped (in-plane rotation).
+ *
+ * @param {Array<object>} slot_list
+ * @returns {boolean}
+ */
+function slots_have_same_measure(slot_list)
+{
+    if (!Array.isArray(slot_list) || slot_list.length < 2)
+    {
+        return false
+    }
+    const first_slot = slot_list[0]
+    for (let slot_index = 1; slot_index < slot_list.length; slot_index += 1)
+    {
+        if (!slot_matches_reference_slot(first_slot, slot_list[slot_index]))
+        {
+            return false
+        }
+    }
+    return true
+}
+
+/**
+ * @param {object} reference_slot
+ * @param {object} slot
+ * @returns {boolean}
+ */
+function slot_matches_reference_slot(reference_slot, slot)
+{
+    if (!eq(reference_slot.get_height(), slot.get_height()))
+    {
+        return false
+    }
+    const same_orientation = eq(reference_slot.get_width(), slot.get_width())
+        && eq(reference_slot.get_length(), slot.get_length())
+    const rotated_orientation = eq(reference_slot.get_width(), slot.get_length())
+        && eq(reference_slot.get_length(), slot.get_width())
+    return same_orientation || rotated_orientation
+}
+
+module.exports = slots_have_same_measure