1346 lines
59 KiB
PHP
1346 lines
59 KiB
PHP
<?php
|
|
|
|
namespace App\Services;
|
|
|
|
use App\Models\Inventory;
|
|
use App\Models\InventoryMovement;
|
|
use App\Models\InventorySerial;
|
|
use App\Models\InventoryWarehouse;
|
|
use App\Models\UserEvent;
|
|
use App\Models\Warehouse;
|
|
use Illuminate\Support\Facades\DB;
|
|
|
|
/**
|
|
* Servicio para gestión de movimientos de inventario
|
|
*
|
|
* El stock vive en inventory_warehouse, no en inventories
|
|
*/
|
|
class InventoryMovementService
|
|
{
|
|
/**
|
|
* Entrada de inventario
|
|
*/
|
|
public function entry(array $data): InventoryMovement
|
|
{
|
|
return DB::transaction(function () use ($data) {
|
|
$inventory = Inventory::findOrFail($data['inventory_id']);
|
|
$warehouse = Warehouse::findOrFail($data['warehouse_id']);
|
|
$serialNumbers = $data['serial_numbers'] ?? null;
|
|
|
|
// cargar la unidad de medida
|
|
$inventory->load('unitOfMeasure');
|
|
|
|
// Conversión de equivalencia de unidades
|
|
$inputUnitId = $data['unit_of_measure_id'] ?? $inventory->unit_of_measure_id;
|
|
$inputQuantity = (float) $data['quantity'];
|
|
$inputUnitCost = (float) $data['unit_cost'];
|
|
$usesEquivalence = $inputUnitId && $inputUnitId != $inventory->unit_of_measure_id;
|
|
|
|
if ($usesEquivalence && $inventory->track_serials) {
|
|
throw new \Exception('No se pueden usar equivalencias de unidad para productos con rastreo de seriales.');
|
|
}
|
|
|
|
$quantity = $usesEquivalence ? $inventory->convertToBaseUnits($inputQuantity, $inputUnitId) : $inputQuantity;
|
|
$unitCost = $usesEquivalence ? $inventory->convertCostToBaseUnit($inputUnitCost, $inputUnitId) : $inputUnitCost;
|
|
|
|
// Solo validar seriales si track_serials Y la unidad NO permite decimales
|
|
$requiresSerials = $inventory->track_serials && ! $inventory->unitOfMeasure?->allows_decimals;
|
|
|
|
if ($requiresSerials) {
|
|
if (empty($serialNumbers)) {
|
|
throw new \Exception('Este producto requiere números de serie. Debe proporcionar '.$quantity.' seriales.');
|
|
}
|
|
|
|
// Filtrar seriales vacíos y hacer trim
|
|
$serialNumbers = array_filter(array_map('trim', $serialNumbers), function ($serial) {
|
|
return ! empty($serial);
|
|
});
|
|
|
|
// Re-indexar el array
|
|
$serialNumbers = array_values($serialNumbers);
|
|
|
|
$serialCount = count($serialNumbers);
|
|
if ($serialCount != $quantity) {
|
|
throw new \Exception("La cantidad de seriales ({$serialCount}) no coincide con la cantidad ({$quantity}). Seriales recibidos: ".implode(', ', $serialNumbers));
|
|
}
|
|
}
|
|
|
|
// Obtener stock actual para calcular costo promedio ponderado
|
|
$currentStock = $inventory->stock;
|
|
$currentCost = $inventory->price?->cost ?? 0.00;
|
|
|
|
// Calcular nuevo costo promedio ponderado
|
|
$newCost = $this->calculateWeightedAverageCost(
|
|
$currentStock,
|
|
$currentCost,
|
|
$quantity,
|
|
$unitCost
|
|
);
|
|
|
|
// Actualizar costo en prices
|
|
$this->updateProductCost($inventory, $newCost);
|
|
|
|
// Registrar movimiento PRIMERO
|
|
$movement = InventoryMovement::create([
|
|
'inventory_id' => $inventory->id,
|
|
'warehouse_from_id' => null,
|
|
'warehouse_to_id' => $warehouse->id,
|
|
'movement_type' => 'entry',
|
|
'quantity' => $quantity,
|
|
'unit_cost' => $unitCost,
|
|
'unit_of_measure_id' => $usesEquivalence ? $inputUnitId : null,
|
|
'unit_quantity' => $usesEquivalence ? $inputQuantity : null,
|
|
'unit_cost_original' => $usesEquivalence ? $inputUnitCost : null,
|
|
'supplier_id' => $data['supplier_id'] ?? null,
|
|
'user_id' => auth()->id(),
|
|
'notes' => $data['notes'] ?? null,
|
|
'invoice_reference' => $data['invoice_reference'] ?? null,
|
|
]);
|
|
|
|
// Crear seriales DESPUÉS del movimiento (para asignar movement_id)
|
|
if ($requiresSerials && ! empty($serialNumbers)) {
|
|
$serials = [];
|
|
foreach ($serialNumbers as $serialNumber) {
|
|
$serials[] = [
|
|
'inventory_id' => $inventory->id,
|
|
'movement_id' => $movement->id, // Ahora tenemos el ID
|
|
'warehouse_id' => $warehouse->id,
|
|
'serial_number' => trim($serialNumber),
|
|
'status' => 'disponible',
|
|
'created_at' => now(),
|
|
'updated_at' => now(),
|
|
];
|
|
}
|
|
InventorySerial::insert($serials);
|
|
|
|
// Activar track_serials si no estaba activo
|
|
if (! $inventory->track_serials) {
|
|
$inventory->update(['track_serials' => true]);
|
|
}
|
|
|
|
// Sincronizar stock desde seriales
|
|
$inventory->syncStock();
|
|
} else {
|
|
// **SIN SERIALES**: Actualizar stock manualmente (permite decimales)
|
|
$this->updateWarehouseStock($inventory->id, $warehouse->id, $quantity);
|
|
}
|
|
|
|
return $movement;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Entrada múltiple de inventario (varios productos)
|
|
*/
|
|
public function bulkEntry(array $data): array
|
|
{
|
|
return DB::transaction(function () use ($data) {
|
|
$warehouse = Warehouse::findOrFail($data['warehouse_id']);
|
|
$movements = [];
|
|
|
|
foreach ($data['products'] as $productData) {
|
|
$inventory = Inventory::findOrFail($productData['inventory_id']);
|
|
$inventory->load('unitOfMeasure');
|
|
$serialNumbers = $productData['serial_numbers'] ?? null;
|
|
|
|
// Conversión de equivalencia de unidades
|
|
$inputUnitId = $productData['unit_of_measure_id'] ?? $inventory->unit_of_measure_id;
|
|
$inputQuantity = (float) $productData['quantity'];
|
|
$inputUnitCost = (float) $productData['unit_cost'];
|
|
$usesEquivalence = $inputUnitId && $inputUnitId != $inventory->unit_of_measure_id;
|
|
|
|
if ($usesEquivalence && $inventory->track_serials) {
|
|
throw new \Exception("No se pueden usar equivalencias de unidad para productos con rastreo de seriales ({$inventory->name}).");
|
|
}
|
|
|
|
$quantity = $usesEquivalence ? $inventory->convertToBaseUnits($inputQuantity, $inputUnitId) : $inputQuantity;
|
|
$unitCost = $usesEquivalence ? $inventory->convertCostToBaseUnit($inputUnitCost, $inputUnitId) : $inputUnitCost;
|
|
|
|
// Validar seriales si el producto los requiere
|
|
if ($inventory->track_serials) {
|
|
if (empty($serialNumbers)) {
|
|
throw new \Exception("El producto '{$inventory->name}' requiere números de serie. Debe proporcionar {$quantity} seriales.");
|
|
}
|
|
|
|
// Filtrar seriales vacíos y hacer trim
|
|
$serialNumbers = array_filter(array_map('trim', $serialNumbers), function ($serial) {
|
|
return ! empty($serial);
|
|
});
|
|
|
|
// Re-indexar el array
|
|
$serialNumbers = array_values($serialNumbers);
|
|
|
|
$serialCount = count($serialNumbers);
|
|
if ($serialCount != $quantity) {
|
|
throw new \Exception("El producto '{$inventory->name}': cantidad de seriales ({$serialCount}) no coincide con cantidad ({$quantity}). Seriales recibidos: ".implode(', ', $serialNumbers));
|
|
}
|
|
|
|
// Actualizar el array limpio
|
|
$productData['serial_numbers'] = $serialNumbers;
|
|
}
|
|
|
|
// Obtener stock actual para calcular costo promedio ponderado
|
|
$currentStock = $inventory->stock;
|
|
$currentCost = $inventory->price?->cost ?? 0.00;
|
|
|
|
// Calcular nuevo costo promedio ponderado
|
|
$newCost = $this->calculateWeightedAverageCost(
|
|
$currentStock,
|
|
$currentCost,
|
|
$quantity,
|
|
$unitCost
|
|
);
|
|
|
|
// Actualizar costo en prices
|
|
$this->updateProductCost($inventory, $newCost);
|
|
|
|
// Crear movimiento PRIMERO
|
|
$movement = InventoryMovement::create([
|
|
'inventory_id' => $inventory->id,
|
|
'warehouse_from_id' => null,
|
|
'warehouse_to_id' => $warehouse->id,
|
|
'movement_type' => 'entry',
|
|
'quantity' => $quantity,
|
|
'unit_cost' => $unitCost,
|
|
'unit_of_measure_id' => $usesEquivalence ? $inputUnitId : null,
|
|
'unit_quantity' => $usesEquivalence ? $inputQuantity : null,
|
|
'unit_cost_original' => $usesEquivalence ? $inputUnitCost : null,
|
|
'supplier_id' => $data['supplier_id'] ?? null,
|
|
'user_id' => auth()->id(),
|
|
'notes' => $data['notes'] ?? null,
|
|
'invoice_reference' => $data['invoice_reference'],
|
|
]);
|
|
|
|
// Crear seriales DESPUÉS (para asignar movement_id)
|
|
if (! empty($serialNumbers)) {
|
|
$serials = [];
|
|
foreach ($serialNumbers as $serialNumber) {
|
|
$serials[] = [
|
|
'inventory_id' => $inventory->id,
|
|
'movement_id' => $movement->id,
|
|
'warehouse_id' => $warehouse->id,
|
|
'serial_number' => trim($serialNumber),
|
|
'status' => 'disponible',
|
|
'created_at' => now(),
|
|
'updated_at' => now(),
|
|
];
|
|
}
|
|
InventorySerial::insert($serials);
|
|
|
|
// Activar track_serials si no estaba activo
|
|
if (! $inventory->track_serials) {
|
|
$inventory->update(['track_serials' => true]);
|
|
}
|
|
|
|
// Sincronizar stock desde seriales
|
|
$inventory->syncStock();
|
|
} else {
|
|
// Sin seriales, actualizar stock manualmente
|
|
$this->updateWarehouseStock($inventory->id, $warehouse->id, $quantity);
|
|
}
|
|
|
|
$movements[] = $movement->load(['inventory', 'warehouseTo']);
|
|
}
|
|
|
|
return $movements;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Salida múltiple de inventario (varios productos)
|
|
*/
|
|
public function bulkExit(array $data): array
|
|
{
|
|
return DB::transaction(function () use ($data) {
|
|
$warehouse = Warehouse::findOrFail($data['warehouse_id']);
|
|
$movements = [];
|
|
|
|
foreach ($data['products'] as $productData) {
|
|
$inventory = Inventory::with('unitOfMeasure')->findOrFail($productData['inventory_id']);
|
|
$serialNumbers = $productData['serial_numbers'] ?? null;
|
|
|
|
// Conversión de equivalencia de unidades
|
|
$inputUnitId = $productData['unit_of_measure_id'] ?? $inventory->unit_of_measure_id;
|
|
$inputQuantity = (float) $productData['quantity'];
|
|
$usesEquivalence = $inputUnitId && $inputUnitId != $inventory->unit_of_measure_id;
|
|
|
|
if ($usesEquivalence && $inventory->track_serials) {
|
|
throw new \Exception("No se pueden usar equivalencias de unidad para productos con rastreo de seriales ({$inventory->name}).");
|
|
}
|
|
|
|
$quantity = $usesEquivalence ? $inventory->convertToBaseUnits($inputQuantity, $inputUnitId) : $inputQuantity;
|
|
|
|
// Solo exigir seriales si track_serials Y unidad NO permite decimales
|
|
$requiresSerials = $inventory->track_serials && ! $inventory->unitOfMeasure?->allows_decimals;
|
|
|
|
// Validar y procesar seriales si el producto los requiere
|
|
if ($requiresSerials) {
|
|
if (empty($serialNumbers)) {
|
|
throw new \Exception("El producto '{$inventory->name}' requiere números de serie. Debe proporcionar {$quantity} seriales.");
|
|
}
|
|
|
|
// Filtrar seriales vacíos y hacer trim
|
|
$serialNumbers = array_filter(array_map('trim', $serialNumbers), function ($serial) {
|
|
return ! empty($serial);
|
|
});
|
|
$serialNumbers = array_values($serialNumbers);
|
|
|
|
$serialCount = count($serialNumbers);
|
|
if ($serialCount != $quantity) {
|
|
throw new \Exception("El producto '{$inventory->name}': cantidad de seriales ({$serialCount}) no coincide con cantidad ({$quantity}). Ajuste la cantidad o agregue/elimine seriales.");
|
|
}
|
|
|
|
// Validar que los seriales existan, pertenezcan al producto, estén disponibles y en el almacén correcto
|
|
foreach ($serialNumbers as $serialNumber) {
|
|
$serial = InventorySerial::where('serial_number', $serialNumber)
|
|
->where('inventory_id', $inventory->id)
|
|
->first();
|
|
|
|
if (! $serial) {
|
|
throw new \Exception("Producto '{$inventory->name}': El serial '{$serialNumber}' no pertenece a este producto.");
|
|
}
|
|
|
|
if ($serial->status != 'disponible') {
|
|
throw new \Exception("Producto '{$inventory->name}': El serial '{$serialNumber}' no está disponible (estado: {$serial->status}).");
|
|
}
|
|
|
|
if ($serial->warehouse_id != $warehouse->id) {
|
|
throw new \Exception("Producto '{$inventory->name}': El serial '{$serialNumber}' no está en el almacén seleccionado.");
|
|
}
|
|
}
|
|
|
|
// Registrar movimiento PRIMERO para tener el ID disponible
|
|
$movement = InventoryMovement::create([
|
|
'inventory_id' => $inventory->id,
|
|
'warehouse_from_id' => $warehouse->id,
|
|
'warehouse_to_id' => null,
|
|
'movement_type' => 'exit',
|
|
'quantity' => $quantity,
|
|
'unit_of_measure_id' => $usesEquivalence ? $inputUnitId : null,
|
|
'unit_quantity' => $usesEquivalence ? $inputQuantity : null,
|
|
'user_id' => auth()->id(),
|
|
'notes' => $data['notes'] ?? null,
|
|
]);
|
|
|
|
// Marcar seriales como salida (no eliminar, para conservar historial)
|
|
InventorySerial::whereIn('serial_number', $serialNumbers)
|
|
->where('inventory_id', $inventory->id)
|
|
->update([
|
|
'status' => 'salida',
|
|
'exit_movement_id' => $movement->id,
|
|
]);
|
|
|
|
// Sincronizar stock desde seriales
|
|
$inventory->syncStock();
|
|
} else {
|
|
// Sin seriales, validar y decrementar stock manualmente
|
|
$this->validateStock($inventory->id, $warehouse->id, $quantity);
|
|
$this->updateWarehouseStock($inventory->id, $warehouse->id, -$quantity);
|
|
|
|
// Registrar movimiento
|
|
$movement = InventoryMovement::create([
|
|
'inventory_id' => $inventory->id,
|
|
'warehouse_from_id' => $warehouse->id,
|
|
'warehouse_to_id' => null,
|
|
'movement_type' => 'exit',
|
|
'quantity' => $quantity,
|
|
'unit_of_measure_id' => $usesEquivalence ? $inputUnitId : null,
|
|
'unit_quantity' => $usesEquivalence ? $inputQuantity : null,
|
|
'user_id' => auth()->id(),
|
|
'notes' => $data['notes'] ?? null,
|
|
]);
|
|
}
|
|
|
|
$movements[] = $movement->load(['inventory', 'warehouseFrom']);
|
|
}
|
|
|
|
return $movements;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Traspaso múltiple entre almacenes (varios productos)
|
|
*/
|
|
public function bulkTransfer(array $data): array
|
|
{
|
|
return DB::transaction(function () use ($data) {
|
|
$warehouseFrom = Warehouse::findOrFail($data['warehouse_from_id']);
|
|
$warehouseTo = Warehouse::findOrFail($data['warehouse_to_id']);
|
|
$movements = [];
|
|
|
|
// Validar que no sea el mismo almacén
|
|
if ($warehouseFrom->id === $warehouseTo->id) {
|
|
throw new \Exception('No se puede traspasar al mismo almacén.');
|
|
}
|
|
|
|
foreach ($data['products'] as $productData) {
|
|
$inventory = Inventory::with('unitOfMeasure')->findOrFail($productData['inventory_id']);
|
|
$serialNumbers = (array) ($productData['serial_numbers'] ?? null);
|
|
|
|
// Conversión de equivalencia de unidades
|
|
$inputUnitId = $productData['unit_of_measure_id'] ?? $inventory->unit_of_measure_id;
|
|
$inputQuantity = (float) $productData['quantity'];
|
|
$usesEquivalence = $inputUnitId && $inputUnitId != $inventory->unit_of_measure_id;
|
|
|
|
if ($usesEquivalence && $inventory->track_serials) {
|
|
throw new \Exception("No se pueden usar equivalencias de unidad para productos con rastreo de seriales ({$inventory->name}).");
|
|
}
|
|
|
|
$quantity = $usesEquivalence ? $inventory->convertToBaseUnits($inputQuantity, $inputUnitId) : $inputQuantity;
|
|
|
|
// Validar y procesar seriales si el producto los requiere
|
|
if ($inventory->track_serials) {
|
|
if (empty($serialNumbers)) {
|
|
throw new \Exception("El producto '{$inventory->name}' requiere números de serie. Debe proporcionar {$quantity} seriales.");
|
|
}
|
|
|
|
// Filtrar seriales vacíos y hacer trim
|
|
$serialNumbers = array_filter(array_map('trim', $serialNumbers), function ($serial) {
|
|
return ! empty($serial);
|
|
});
|
|
$serialNumbers = array_values($serialNumbers);
|
|
|
|
$serialCount = count($serialNumbers);
|
|
if ($serialCount != $quantity) {
|
|
throw new \Exception("El producto '{$inventory->name}': cantidad de seriales ({$serialCount}) no coincide con cantidad ({$quantity}). Ajuste la cantidad o agregue/elimine seriales.");
|
|
}
|
|
|
|
// Validar que los seriales existan, pertenezcan al producto, estén disponibles y en el almacén origen
|
|
foreach ($serialNumbers as $serialNumber) {
|
|
$serial = InventorySerial::where('serial_number', $serialNumber)
|
|
->where('inventory_id', $inventory->id)
|
|
->first();
|
|
|
|
if (! $serial) {
|
|
throw new \Exception("Producto '{$inventory->name}': El serial '{$serialNumber}' no pertenece a este producto.");
|
|
}
|
|
|
|
if ($serial->status !== 'disponible') {
|
|
throw new \Exception("Producto '{$inventory->name}': El serial '{$serialNumber}' no está disponible (estado: {$serial->status}).");
|
|
}
|
|
|
|
if ($serial->warehouse_id !== $warehouseFrom->id) {
|
|
throw new \Exception("Producto '{$inventory->name}': El serial '{$serialNumber}' no está en el almacén origen.");
|
|
}
|
|
}
|
|
|
|
// Registrar movimiento PRIMERO para tener el ID disponible
|
|
$movement = InventoryMovement::create([
|
|
'inventory_id' => $inventory->id,
|
|
'warehouse_from_id' => $warehouseFrom->id,
|
|
'warehouse_to_id' => $warehouseTo->id,
|
|
'movement_type' => 'transfer',
|
|
'quantity' => $quantity,
|
|
'unit_of_measure_id' => $usesEquivalence ? $inputUnitId : null,
|
|
'unit_quantity' => $usesEquivalence ? $inputQuantity : null,
|
|
'user_id' => auth()->id(),
|
|
'notes' => $data['notes'] ?? null,
|
|
]);
|
|
|
|
// Actualizar warehouse_id y transfer_movement_id de los seriales seleccionados
|
|
InventorySerial::whereIn('serial_number', $serialNumbers)
|
|
->where('inventory_id', $inventory->id)
|
|
->update([
|
|
'warehouse_id' => $warehouseTo->id,
|
|
'transfer_movement_id' => $movement->id,
|
|
]);
|
|
|
|
// Sincronizar stock desde seriales (actualiza ambos almacenes)
|
|
$inventory->syncStock();
|
|
} else {
|
|
// Sin seriales, validar y actualizar stock manualmente
|
|
$this->validateStock($inventory->id, $warehouseFrom->id, $quantity);
|
|
$this->updateWarehouseStock($inventory->id, $warehouseFrom->id, -$quantity);
|
|
$this->updateWarehouseStock($inventory->id, $warehouseTo->id, $quantity);
|
|
|
|
// Registrar movimiento
|
|
$movement = InventoryMovement::create([
|
|
'inventory_id' => $inventory->id,
|
|
'warehouse_from_id' => $warehouseFrom->id,
|
|
'warehouse_to_id' => $warehouseTo->id,
|
|
'movement_type' => 'transfer',
|
|
'quantity' => $quantity,
|
|
'unit_of_measure_id' => $usesEquivalence ? $inputUnitId : null,
|
|
'unit_quantity' => $usesEquivalence ? $inputQuantity : null,
|
|
'user_id' => auth()->id(),
|
|
'notes' => $data['notes'] ?? null,
|
|
]);
|
|
}
|
|
|
|
$movements[] = $movement->load(['inventory', 'warehouseFrom', 'warehouseTo']);
|
|
}
|
|
|
|
return $movements;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Calcular costo promedio ponderado
|
|
*/
|
|
protected function calculateWeightedAverageCost(
|
|
float $currentStock,
|
|
float $currentCost,
|
|
float $entryQuantity,
|
|
float $entryCost
|
|
): float {
|
|
if ($currentStock <= 0) {
|
|
return $entryCost;
|
|
}
|
|
$totalValue = ($currentStock * $currentCost) + ($entryQuantity * $entryCost);
|
|
$totalQuantity = $currentStock + $entryQuantity;
|
|
|
|
return round($totalValue / $totalQuantity, 2);
|
|
}
|
|
|
|
protected function updateProductCost(Inventory $inventory, float $newCost): void
|
|
{
|
|
$inventory->price()->updateOrCreate(
|
|
['inventory_id' => $inventory->id],
|
|
['cost' => $newCost]
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Salida de inventario (merma, ajuste negativo, robo, daño)
|
|
*/
|
|
public function exit(array $data): InventoryMovement
|
|
{
|
|
return DB::transaction(function () use ($data) {
|
|
$inventory = Inventory::findOrFail($data['inventory_id']);
|
|
$warehouse = Warehouse::findOrFail($data['warehouse_id']);
|
|
$serialNumbers = $data['serial_numbers'] ?? null;
|
|
|
|
// Cargar la unidad de medida
|
|
$inventory->load('unitOfMeasure');
|
|
|
|
// Conversión de equivalencia de unidades
|
|
$inputUnitId = $data['unit_of_measure_id'] ?? $inventory->unit_of_measure_id;
|
|
$inputQuantity = (float) $data['quantity'];
|
|
$usesEquivalence = $inputUnitId && $inputUnitId != $inventory->unit_of_measure_id;
|
|
|
|
if ($usesEquivalence && $inventory->track_serials) {
|
|
throw new \Exception('No se pueden usar equivalencias de unidad para productos con rastreo de seriales.');
|
|
}
|
|
|
|
$quantity = $usesEquivalence ? $inventory->convertToBaseUnits($inputQuantity, $inputUnitId) : $inputQuantity;
|
|
|
|
// Solo validar seriales si track_serials Y la unidad NO permite decimales
|
|
$requiresSerials = $inventory->track_serials && ! $inventory->unitOfMeasure?->allows_decimals;
|
|
|
|
// Validar y procesar seriales si el producto los requiere
|
|
if ($requiresSerials) {
|
|
if (empty($serialNumbers)) {
|
|
throw new \Exception('Este producto requiere números de serie. Debe proporcionar '.$quantity.' seriales.');
|
|
}
|
|
|
|
// Filtrar seriales vacíos y hacer trim
|
|
$serialNumbers = array_filter(array_map('trim', $serialNumbers), function ($serial) {
|
|
return ! empty($serial);
|
|
});
|
|
$serialNumbers = array_values($serialNumbers);
|
|
|
|
$serialCount = count($serialNumbers);
|
|
if ($serialCount != $quantity) {
|
|
throw new \Exception("La cantidad de seriales ({$serialCount}) no coincide con la cantidad ({$quantity}). Ajuste la cantidad o agregue/elimine seriales.");
|
|
}
|
|
|
|
// Validar que los seriales existan, pertenezcan al producto, estén disponibles y en el almacén correcto
|
|
foreach ($serialNumbers as $serialNumber) {
|
|
$serial = InventorySerial::where('serial_number', $serialNumber)
|
|
->where('inventory_id', $inventory->id)
|
|
->first();
|
|
|
|
if (! $serial) {
|
|
throw new \Exception("El serial '{$serialNumber}' no pertenece a este producto.");
|
|
}
|
|
|
|
if ($serial->status !== 'disponible') {
|
|
throw new \Exception("El serial '{$serialNumber}' no está disponible (estado: {$serial->status}).");
|
|
}
|
|
|
|
if ($serial->warehouse_id !== $warehouse->id) {
|
|
throw new \Exception("El serial '{$serialNumber}' no está en el almacén seleccionado.");
|
|
}
|
|
}
|
|
|
|
// Registrar movimiento PRIMERO para tener el ID disponible
|
|
$movement = InventoryMovement::create([
|
|
'inventory_id' => $inventory->id,
|
|
'warehouse_from_id' => $warehouse->id,
|
|
'warehouse_to_id' => null,
|
|
'movement_type' => 'exit',
|
|
'quantity' => $quantity,
|
|
'unit_of_measure_id' => $usesEquivalence ? $inputUnitId : null,
|
|
'unit_quantity' => $usesEquivalence ? $inputQuantity : null,
|
|
'user_id' => auth()->id(),
|
|
'notes' => $data['notes'] ?? null,
|
|
]);
|
|
|
|
// Marcar seriales como salida (no eliminar, para conservar historial)
|
|
InventorySerial::whereIn('serial_number', $serialNumbers)
|
|
->where('inventory_id', $inventory->id)
|
|
->update([
|
|
'status' => 'salida',
|
|
'exit_movement_id' => $movement->id,
|
|
]);
|
|
|
|
// Sincronizar stock desde seriales
|
|
$inventory->syncStock();
|
|
|
|
return $movement;
|
|
} else {
|
|
// **SIN SERIALES**: Validar y decrementar stock manualmente
|
|
$this->validateStock($inventory->id, $warehouse->id, $quantity);
|
|
$this->updateWarehouseStock($inventory->id, $warehouse->id, -$quantity);
|
|
}
|
|
|
|
// Registrar movimiento (solo para caso sin seriales)
|
|
return InventoryMovement::create([
|
|
'inventory_id' => $inventory->id,
|
|
'warehouse_from_id' => $warehouse->id,
|
|
'warehouse_to_id' => null,
|
|
'movement_type' => 'exit',
|
|
'quantity' => $quantity,
|
|
'unit_of_measure_id' => $usesEquivalence ? $inputUnitId : null,
|
|
'unit_quantity' => $usesEquivalence ? $inputQuantity : null,
|
|
'user_id' => auth()->id(),
|
|
'notes' => $data['notes'] ?? null,
|
|
]);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Traspaso entre almacenes
|
|
*/
|
|
public function transfer(array $data): InventoryMovement
|
|
{
|
|
return DB::transaction(function () use ($data) {
|
|
$inventory = Inventory::with('unitOfMeasure')->findOrFail($data['inventory_id']);
|
|
$warehouseFrom = Warehouse::findOrFail($data['warehouse_from_id']);
|
|
$warehouseTo = Warehouse::findOrFail($data['warehouse_to_id']);
|
|
$serialNumbers = $data['serial_numbers'] ?? null;
|
|
|
|
// Conversión de equivalencia de unidades
|
|
$inputUnitId = $data['unit_of_measure_id'] ?? $inventory->unit_of_measure_id;
|
|
$inputQuantity = (float) $data['quantity'];
|
|
$usesEquivalence = $inputUnitId && $inputUnitId != $inventory->unit_of_measure_id;
|
|
|
|
if ($usesEquivalence && $inventory->track_serials) {
|
|
throw new \Exception('No se pueden usar equivalencias de unidad para productos con rastreo de seriales.');
|
|
}
|
|
|
|
$quantity = $usesEquivalence ? $inventory->convertToBaseUnits($inputQuantity, $inputUnitId) : $inputQuantity;
|
|
|
|
// Validar que no sea el mismo almacén
|
|
if ($warehouseFrom->id === $warehouseTo->id) {
|
|
throw new \Exception('No se puede traspasar al mismo almacén.');
|
|
}
|
|
|
|
// Solo exigir seriales si track_serials Y unidad NO permite decimales
|
|
$requiresSerials = $inventory->track_serials && ! $inventory->unitOfMeasure?->allows_decimals;
|
|
|
|
// Validar y procesar seriales si el producto los requiere
|
|
if ($requiresSerials) {
|
|
if (empty($serialNumbers)) {
|
|
throw new \Exception('Este producto requiere números de serie. Debe proporcionar '.$quantity.' seriales.');
|
|
}
|
|
|
|
// Filtrar seriales vacíos y hacer trim
|
|
$serialNumbers = array_filter(array_map('trim', $serialNumbers), function ($serial) {
|
|
return ! empty($serial);
|
|
});
|
|
$serialNumbers = array_values($serialNumbers);
|
|
|
|
$serialCount = count($serialNumbers);
|
|
if ($serialCount != $quantity) {
|
|
throw new \Exception("La cantidad de seriales ({$serialCount}) no coincide con la cantidad ({$quantity}). Ajuste la cantidad o agregue/elimine seriales.");
|
|
}
|
|
|
|
// Validar que los seriales existan, pertenezcan al producto, estén disponibles y en el almacén origen
|
|
foreach ($serialNumbers as $serialNumber) {
|
|
$serial = InventorySerial::where('serial_number', $serialNumber)
|
|
->where('inventory_id', $inventory->id)
|
|
->first();
|
|
|
|
if (! $serial) {
|
|
throw new \Exception("El serial '{$serialNumber}' no pertenece a este producto.");
|
|
}
|
|
|
|
if ($serial->status !== 'disponible') {
|
|
throw new \Exception("El serial '{$serialNumber}' no está disponible (estado: {$serial->status}).");
|
|
}
|
|
|
|
if ($serial->warehouse_id !== $warehouseFrom->id) {
|
|
throw new \Exception("El serial '{$serialNumber}' no está en el almacén origen.");
|
|
}
|
|
}
|
|
|
|
// Registrar movimiento PRIMERO para tener el ID disponible
|
|
$movement = InventoryMovement::create([
|
|
'inventory_id' => $inventory->id,
|
|
'warehouse_from_id' => $warehouseFrom->id,
|
|
'warehouse_to_id' => $warehouseTo->id,
|
|
'movement_type' => 'transfer',
|
|
'quantity' => $quantity,
|
|
'unit_of_measure_id' => $usesEquivalence ? $inputUnitId : null,
|
|
'unit_quantity' => $usesEquivalence ? $inputQuantity : null,
|
|
'user_id' => auth()->id(),
|
|
'notes' => $data['notes'] ?? null,
|
|
]);
|
|
|
|
// Actualizar warehouse_id y transfer_movement_id de los seriales seleccionados
|
|
InventorySerial::whereIn('serial_number', $serialNumbers)
|
|
->where('inventory_id', $inventory->id)
|
|
->update([
|
|
'warehouse_id' => $warehouseTo->id,
|
|
'transfer_movement_id' => $movement->id,
|
|
]);
|
|
|
|
// Sincronizar stock desde seriales (actualiza ambos almacenes)
|
|
$inventory->syncStock();
|
|
|
|
return $movement;
|
|
} else {
|
|
// Sin seriales, validar y actualizar stock manualmente
|
|
$this->validateStock($inventory->id, $warehouseFrom->id, $quantity);
|
|
$this->updateWarehouseStock($inventory->id, $warehouseFrom->id, -$quantity);
|
|
$this->updateWarehouseStock($inventory->id, $warehouseTo->id, $quantity);
|
|
}
|
|
|
|
// Registrar movimiento (solo para caso sin seriales)
|
|
return InventoryMovement::create([
|
|
'inventory_id' => $inventory->id,
|
|
'warehouse_from_id' => $warehouseFrom->id,
|
|
'warehouse_to_id' => $warehouseTo->id,
|
|
'movement_type' => 'transfer',
|
|
'quantity' => $quantity,
|
|
'unit_of_measure_id' => $usesEquivalence ? $inputUnitId : null,
|
|
'unit_quantity' => $usesEquivalence ? $inputQuantity : null,
|
|
'user_id' => auth()->id(),
|
|
'notes' => $data['notes'] ?? null,
|
|
]);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Actualizar stock en inventory_warehouse
|
|
*/
|
|
public function updateWarehouseStock(int $inventoryId, int $warehouseId, float $quantityChange): void
|
|
{
|
|
$record = InventoryWarehouse::firstOrCreate(
|
|
[
|
|
'inventory_id' => $inventoryId,
|
|
'warehouse_id' => $warehouseId,
|
|
],
|
|
['stock' => 0]
|
|
);
|
|
|
|
$newStock = $record->stock + $quantityChange;
|
|
|
|
if ($newStock < 0) {
|
|
throw new \Exception('Stock insuficiente en el almacén.');
|
|
}
|
|
|
|
$record->update(['stock' => $newStock]);
|
|
}
|
|
|
|
/**
|
|
* Validar stock disponible
|
|
*/
|
|
public function validateStock(int $inventoryId, int $warehouseId, float $requiredQuantity): void
|
|
{
|
|
$record = InventoryWarehouse::where('inventory_id', $inventoryId)
|
|
->where('warehouse_id', $warehouseId)
|
|
->first();
|
|
|
|
$availableStock = $record?->stock ?? 0;
|
|
|
|
if ($availableStock < $requiredQuantity) {
|
|
throw new \Exception("Stock insuficiente. Disponible: {$availableStock}, Requerido: {$requiredQuantity}");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Registrar movimiento de venta
|
|
*/
|
|
public function recordSale(int $inventoryId, int $warehouseId, float $quantity, int $saleId): InventoryMovement
|
|
{
|
|
return InventoryMovement::create([
|
|
'inventory_id' => $inventoryId,
|
|
'warehouse_from_id' => $warehouseId,
|
|
'warehouse_to_id' => null,
|
|
'movement_type' => 'sale',
|
|
'quantity' => $quantity,
|
|
'reference_type' => 'App\Models\Sale',
|
|
'reference_id' => $saleId,
|
|
'user_id' => auth()->id(),
|
|
]);
|
|
}
|
|
|
|
/**
|
|
* Registrar movimiento de devolución
|
|
*/
|
|
public function recordReturn(int $inventoryId, int $warehouseId, float $quantity, int $returnId): InventoryMovement
|
|
{
|
|
return InventoryMovement::create([
|
|
'inventory_id' => $inventoryId,
|
|
'warehouse_from_id' => null,
|
|
'warehouse_to_id' => $warehouseId,
|
|
'movement_type' => 'return',
|
|
'quantity' => $quantity,
|
|
'reference_type' => 'App\Models\Returns',
|
|
'reference_id' => $returnId,
|
|
'user_id' => auth()->id(),
|
|
]);
|
|
}
|
|
|
|
/**
|
|
* Obtener el almacén principal
|
|
*/
|
|
public function getMainWarehouseId(): int
|
|
{
|
|
$warehouse = Warehouse::where('is_main', true)->first();
|
|
|
|
if (! $warehouse) {
|
|
throw new \Exception('No existe un almacén principal configurado.');
|
|
}
|
|
|
|
return $warehouse->id;
|
|
}
|
|
|
|
/**
|
|
* Actualizar un movimiento existente
|
|
*/
|
|
public function updateMovement(int $movementId, array $data): InventoryMovement
|
|
{
|
|
return DB::transaction(function () use ($movementId, $data) {
|
|
$movement = InventoryMovement::findOrFail($movementId);
|
|
|
|
// No permitir editar movimientos de venta o devolución (son automáticos)
|
|
if (in_array($movement->movement_type, ['sale', 'return'])) {
|
|
throw new \Exception('No se pueden editar movimientos de venta o devolución.');
|
|
}
|
|
|
|
// Preparar datos completos para actualización según tipo
|
|
$updateData = $this->prepareUpdateData($movement, $data);
|
|
|
|
// Aplicar según el tipo de movimiento
|
|
if ($movement->movement_type === 'entry') {
|
|
// Entradas usan lógica delta (no revertir + reaplicar)
|
|
$this->applyEntryDeltaUpdate($movement, $updateData);
|
|
} else {
|
|
// Salidas y traspasos mantienen lógica revert + apply
|
|
$this->revertMovement($movement);
|
|
|
|
match ($movement->movement_type) {
|
|
'exit' => $this->applyExitUpdate($movement, $updateData),
|
|
'transfer' => $this->applyTransferUpdate($movement, $updateData),
|
|
};
|
|
}
|
|
|
|
// Actualizar el registro del movimiento
|
|
$movement->update($updateData);
|
|
|
|
UserEvent::report(model: $movement, event: 'updated', key: 'movement_type');
|
|
|
|
return $movement->load(['inventory', 'warehouseFrom', 'warehouseTo', 'user', 'supplier', 'serials', 'transferredSerials', 'exitedSerials']);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Preparar datos completos para actualización
|
|
*/
|
|
protected function prepareUpdateData(InventoryMovement $movement, array $data): array
|
|
{
|
|
$inventory = $movement->inventory;
|
|
|
|
// Determinar si se usa equivalencia de unidades
|
|
$inputUnitId = $data['unit_of_measure_id'] ?? $movement->unit_of_measure_id ?? $inventory->unit_of_measure_id;
|
|
$usesEquivalence = $inputUnitId && $inputUnitId != $inventory->unit_of_measure_id;
|
|
|
|
// Convertir cantidad a unidades base si usa equivalencia
|
|
$inputQuantity = (float) ($data['quantity'] ?? ($movement->unit_quantity ?? $movement->quantity));
|
|
$quantity = $usesEquivalence ? $inventory->convertToBaseUnits($inputQuantity, $inputUnitId) : $inputQuantity;
|
|
|
|
$updateData = [
|
|
'quantity' => $quantity,
|
|
'unit_of_measure_id' => $usesEquivalence ? $inputUnitId : null,
|
|
'unit_quantity' => $usesEquivalence ? $inputQuantity : null,
|
|
'notes' => $data['notes'] ?? $movement->notes,
|
|
];
|
|
|
|
// Pasar serial_numbers si fueron proporcionados
|
|
if (! empty($data['serial_numbers'])) {
|
|
$updateData['serial_numbers'] = $data['serial_numbers'];
|
|
}
|
|
|
|
// Campos específicos por tipo de movimiento
|
|
if ($movement->movement_type === 'entry') {
|
|
$inputUnitCost = (float) ($data['unit_cost'] ?? ($movement->unit_cost_original ?? $movement->unit_cost));
|
|
$unitCost = $usesEquivalence ? $inventory->convertCostToBaseUnit($inputUnitCost, $inputUnitId) : $inputUnitCost;
|
|
|
|
$updateData['unit_cost'] = $unitCost;
|
|
$updateData['unit_cost_original'] = $usesEquivalence ? $inputUnitCost : null;
|
|
$updateData['invoice_reference'] = $data['invoice_reference'] ?? $movement->invoice_reference;
|
|
$updateData['warehouse_to_id'] = $data['warehouse_to_id'] ?? $movement->warehouse_to_id;
|
|
$updateData['supplier_id'] = array_key_exists('supplier_id', $data) ? $data['supplier_id'] : $movement->supplier_id;
|
|
} elseif ($movement->movement_type === 'exit') {
|
|
$updateData['warehouse_from_id'] = $data['warehouse_from_id'] ?? $movement->warehouse_from_id;
|
|
} elseif ($movement->movement_type === 'transfer') {
|
|
$updateData['warehouse_from_id'] = $data['warehouse_from_id'] ?? $movement->warehouse_from_id;
|
|
$updateData['warehouse_to_id'] = $data['warehouse_to_id'] ?? $movement->warehouse_to_id;
|
|
}
|
|
|
|
return $updateData;
|
|
}
|
|
|
|
/**
|
|
* Revertir el impacto de un movimiento en el stock
|
|
*/
|
|
protected function revertMovement(InventoryMovement $movement): void
|
|
{
|
|
switch ($movement->movement_type) {
|
|
// Las entradas NO se revierten aquí, usan lógica delta en applyEntryDeltaUpdate()
|
|
|
|
case 'exit':
|
|
$inventory = $movement->inventory;
|
|
$inventory->load('unitOfMeasure');
|
|
$usesSerials = $inventory->track_serials && ! $inventory->unitOfMeasure?->allows_decimals;
|
|
|
|
if ($usesSerials) {
|
|
// Revertir seriales: restaurar a disponible y limpiar exit_movement_id
|
|
InventorySerial::where('exit_movement_id', $movement->id)
|
|
->update([
|
|
'status' => 'disponible',
|
|
'exit_movement_id' => null,
|
|
]);
|
|
$inventory->syncStock();
|
|
} else {
|
|
// Revertir salida sin seriales: devolver stock al almacén origen
|
|
$this->updateWarehouseStock(
|
|
$movement->inventory_id,
|
|
$movement->warehouse_from_id,
|
|
$movement->quantity
|
|
);
|
|
}
|
|
break;
|
|
|
|
case 'transfer':
|
|
$inventory = $movement->inventory;
|
|
|
|
if ($inventory->track_serials) {
|
|
// Revertir seriales: mover de vuelta al almacén origen
|
|
InventorySerial::where('transfer_movement_id', $movement->id)
|
|
->update([
|
|
'warehouse_id' => $movement->warehouse_from_id,
|
|
'transfer_movement_id' => null,
|
|
]);
|
|
$inventory->syncStock();
|
|
} else {
|
|
// Revertir traspaso sin seriales: devolver al origen, quitar del destino
|
|
$this->updateWarehouseStock(
|
|
$movement->inventory_id,
|
|
$movement->warehouse_from_id,
|
|
$movement->quantity
|
|
);
|
|
$this->updateWarehouseStock(
|
|
$movement->inventory_id,
|
|
$movement->warehouse_to_id,
|
|
-$movement->quantity
|
|
);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Aplicar actualización de entrada usando lógica delta
|
|
*
|
|
* calcula la diferencia entre la cantidad original y la nueva,
|
|
* y valida si esa diferencia es posible dado el stock actual.
|
|
*/
|
|
protected function applyEntryDeltaUpdate(InventoryMovement $movement, array $data): void
|
|
{
|
|
$inventory = $movement->inventory;
|
|
$oldQuantity = (float) $movement->quantity;
|
|
$newQuantity = (float) ($data['quantity'] ?? $movement->quantity);
|
|
$oldUnitCost = (float) $movement->unit_cost;
|
|
$newUnitCost = (float) ($data['unit_cost'] ?? $movement->unit_cost);
|
|
$oldWarehouseId = $movement->warehouse_to_id;
|
|
$newWarehouseId = $data['warehouse_to_id'] ?? $movement->warehouse_to_id;
|
|
$warehouseChanged = $newWarehouseId != $oldWarehouseId;
|
|
|
|
// --- Recálculo de costo promedio ponderado (ANTES de ajustar stock) ---
|
|
$currentStock = (float) $inventory->stock;
|
|
$currentCost = (float) ($inventory->price?->cost ?? 0.00);
|
|
|
|
// Revertir contribución de la entrada original al costo promedio
|
|
$stockSinEntrada = $currentStock - $oldQuantity;
|
|
|
|
if ($stockSinEntrada > 0) {
|
|
$costoRevertido = (($currentStock * $currentCost) - ($oldQuantity * $oldUnitCost)) / $stockSinEntrada;
|
|
$costoRevertido = max(0, $costoRevertido);
|
|
} else {
|
|
$costoRevertido = $newUnitCost;
|
|
$stockSinEntrada = 0;
|
|
}
|
|
|
|
$newCost = $this->calculateWeightedAverageCost(
|
|
$stockSinEntrada,
|
|
$costoRevertido,
|
|
$newQuantity,
|
|
$newUnitCost
|
|
);
|
|
|
|
$this->updateProductCost($inventory, $newCost);
|
|
|
|
// --- Ajuste de stock y seriales ---
|
|
$inventory->load('unitOfMeasure');
|
|
$usesSerials = $inventory->track_serials && ! $inventory->unitOfMeasure?->allows_decimals;
|
|
|
|
if ($usesSerials) {
|
|
// Productos con seriales: el stock se sincroniza automáticamente desde syncStock()
|
|
// Solo necesitamos actualizar los seriales, el stock se recalcula al final
|
|
$this->updateMovementSerials($movement, $data);
|
|
} else {
|
|
// Productos sin seriales: ajustar stock manualmente con delta
|
|
if ($warehouseChanged) {
|
|
$oldWarehouseStock = $inventory->stockInWarehouse($oldWarehouseId);
|
|
|
|
if ($oldWarehouseStock < $oldQuantity) {
|
|
throw new \Exception(
|
|
'No se puede cambiar el almacén de esta entrada porque el stock actual '
|
|
."del almacén origen ({$oldWarehouseStock}) no es suficiente para retirar "
|
|
."las {$oldQuantity} unidades originales. Los productos ya fueron vendidos o movidos."
|
|
);
|
|
}
|
|
|
|
$this->updateWarehouseStock($inventory->id, $oldWarehouseId, -$oldQuantity);
|
|
$this->updateWarehouseStock($inventory->id, $newWarehouseId, $newQuantity);
|
|
} else {
|
|
$delta = $newQuantity - $oldQuantity;
|
|
|
|
if ($delta != 0) {
|
|
if ($delta < 0) {
|
|
$currentWarehouseStock = $inventory->stockInWarehouse($newWarehouseId);
|
|
|
|
if ($currentWarehouseStock < abs($delta)) {
|
|
throw new \Exception(
|
|
"No se puede reducir esta entrada de {$oldQuantity} a {$newQuantity} "
|
|
."porque el stock actual del almacén ({$currentWarehouseStock}) no es suficiente "
|
|
.'para absorber la reducción de '.abs($delta).' unidades. '
|
|
.'Los productos ya fueron vendidos o movidos.'
|
|
);
|
|
}
|
|
}
|
|
|
|
$this->updateWarehouseStock($inventory->id, $newWarehouseId, $delta);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Aplicar actualización de salida
|
|
*/
|
|
protected function applyExitUpdate(InventoryMovement $movement, array $data): void
|
|
{
|
|
$inventory = $movement->inventory;
|
|
$inventory->load('unitOfMeasure');
|
|
$usesSerials = $inventory->track_serials && ! $inventory->unitOfMeasure?->allows_decimals;
|
|
$warehouseFromId = $data['warehouse_from_id'] ?? $movement->warehouse_from_id;
|
|
$quantity = $data['quantity'] ?? $movement->quantity;
|
|
|
|
if ($usesSerials) {
|
|
$serialNumbers = $data['serial_numbers'] ?? [];
|
|
|
|
if (empty($serialNumbers)) {
|
|
throw new \Exception('Debe proporcionar los números de serie para actualizar esta salida.');
|
|
}
|
|
|
|
$serialNumbers = array_values(array_filter(array_map('trim', $serialNumbers)));
|
|
|
|
if (count($serialNumbers) != $quantity) {
|
|
throw new \Exception('La cantidad de seriales no coincide con la cantidad del movimiento.');
|
|
}
|
|
|
|
// Validar que los seriales existan, estén disponibles y en el almacén correcto
|
|
foreach ($serialNumbers as $serialNumber) {
|
|
$serial = InventorySerial::where('serial_number', $serialNumber)
|
|
->where('inventory_id', $inventory->id)
|
|
->first();
|
|
|
|
if (! $serial) {
|
|
throw new \Exception("El serial '{$serialNumber}' no pertenece a este producto.");
|
|
}
|
|
if ($serial->status !== 'disponible') {
|
|
throw new \Exception("El serial '{$serialNumber}' no está disponible (estado: {$serial->status}).");
|
|
}
|
|
if ($serial->warehouse_id !== $warehouseFromId) {
|
|
throw new \Exception("El serial '{$serialNumber}' no está en el almacén seleccionado.");
|
|
}
|
|
}
|
|
|
|
// Marcar los nuevos seriales como salida
|
|
InventorySerial::whereIn('serial_number', $serialNumbers)
|
|
->where('inventory_id', $inventory->id)
|
|
->update([
|
|
'status' => 'salida',
|
|
'exit_movement_id' => $movement->id,
|
|
]);
|
|
|
|
$inventory->syncStock();
|
|
} else {
|
|
// Validar stock disponible
|
|
$this->validateStock($movement->inventory_id, $warehouseFromId, $quantity);
|
|
|
|
// Aplicar nueva salida
|
|
$this->updateWarehouseStock($movement->inventory_id, $warehouseFromId, -$quantity);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Aplicar actualización de traspaso
|
|
*/
|
|
protected function applyTransferUpdate(InventoryMovement $movement, array $data): void
|
|
{
|
|
$warehouseFromId = $data['warehouse_from_id'] ?? $movement->warehouse_from_id;
|
|
$warehouseToId = $data['warehouse_to_id'] ?? $movement->warehouse_to_id;
|
|
$quantity = $data['quantity'] ?? $movement->quantity;
|
|
$inventory = $movement->inventory;
|
|
|
|
// Validar que no sea el mismo almacén
|
|
if ($warehouseFromId === $warehouseToId) {
|
|
throw new \Exception('No se puede traspasar al mismo almacén.');
|
|
}
|
|
|
|
if ($inventory->track_serials) {
|
|
$serialNumbers = $data['serial_numbers'] ?? [];
|
|
|
|
if (empty($serialNumbers)) {
|
|
throw new \Exception("Se requieren los números de serie para editar el traspaso de '{$inventory->name}'.");
|
|
}
|
|
|
|
if (count($serialNumbers) !== (int) $quantity) {
|
|
throw new \Exception('La cantidad no coincide con el número de seriales proporcionados.');
|
|
}
|
|
|
|
// Validar que cada serial esté disponible en el almacén origen
|
|
foreach ($serialNumbers as $serialNumber) {
|
|
$serial = InventorySerial::where('inventory_id', $inventory->id)
|
|
->where('serial_number', $serialNumber)
|
|
->where('warehouse_id', $warehouseFromId)
|
|
->where('status', 'disponible')
|
|
->first();
|
|
|
|
if (! $serial) {
|
|
throw new \Exception("Serial {$serialNumber} no disponible en el almacén origen.");
|
|
}
|
|
}
|
|
|
|
// Mover seriales al almacén destino
|
|
InventorySerial::where('inventory_id', $inventory->id)
|
|
->whereIn('serial_number', $serialNumbers)
|
|
->update([
|
|
'warehouse_id' => $warehouseToId,
|
|
'transfer_movement_id' => $movement->id,
|
|
]);
|
|
|
|
$inventory->syncStock();
|
|
} else {
|
|
// Validar stock disponible en origen
|
|
$this->validateStock($movement->inventory_id, $warehouseFromId, $quantity);
|
|
|
|
// Aplicar nuevo traspaso
|
|
$this->updateWarehouseStock($movement->inventory_id, $warehouseFromId, -$quantity);
|
|
$this->updateWarehouseStock($movement->inventory_id, $warehouseToId, $quantity);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sincronizar stock en inventory_warehouse basado en seriales disponibles
|
|
* Solo aplica para productos con track_serials = true
|
|
*/
|
|
public function syncStockFromSerials(Inventory $inventory): void
|
|
{
|
|
if (! $inventory->track_serials) {
|
|
return;
|
|
}
|
|
|
|
// Contar seriales disponibles por almacén
|
|
$stockByWarehouse = $inventory->serials()
|
|
->where('status', 'disponible')
|
|
->whereNotNull('warehouse_id')
|
|
->selectRaw('warehouse_id, COUNT(*) as total')
|
|
->groupBy('warehouse_id')
|
|
->pluck('total', 'warehouse_id');
|
|
|
|
// Actualizar stock en cada almacén
|
|
foreach ($stockByWarehouse as $warehouseId => $count) {
|
|
InventoryWarehouse::updateOrCreate(
|
|
[
|
|
'inventory_id' => $inventory->id,
|
|
'warehouse_id' => $warehouseId,
|
|
],
|
|
['stock' => $count]
|
|
);
|
|
}
|
|
|
|
// Poner en 0 los almacenes que ya no tienen seriales disponibles
|
|
InventoryWarehouse::where('inventory_id', $inventory->id)
|
|
->whereNotIn('warehouse_id', $stockByWarehouse->keys())
|
|
->update(['stock' => 0]);
|
|
}
|
|
|
|
/**
|
|
* Actualizar seriales de un movimiento usando lógica delta
|
|
*
|
|
* - Aumento (delta > 0): solo agrega los nuevos seriales sin tocar los existentes
|
|
* - Reducción (delta < 0): solo elimina seriales disponibles, bloquea si hay vendidos/devueltos en los que se quieren quitar
|
|
* - Sin cambio de cantidad: permite reemplazar seriales disponibles por otros
|
|
*/
|
|
protected function updateMovementSerials(InventoryMovement $movement, array $data): void
|
|
{
|
|
$inventory = $movement->inventory;
|
|
|
|
if (! $inventory->track_serials) {
|
|
return;
|
|
}
|
|
|
|
// Solo aplicar a movimientos de entrada
|
|
if ($movement->movement_type !== 'entry') {
|
|
return;
|
|
}
|
|
|
|
$oldQuantity = (int) $movement->quantity;
|
|
$newQuantity = (int) ($data['quantity'] ?? $movement->quantity);
|
|
$quantityChanged = $newQuantity != $oldQuantity;
|
|
$serialsProvided = ! empty($data['serial_numbers']);
|
|
$warehouseToId = $data['warehouse_to_id'] ?? $movement->warehouse_to_id;
|
|
|
|
// Si NO cambió la cantidad Y NO se proporcionaron seriales, no hacer nada
|
|
if (! $quantityChanged && ! $serialsProvided) {
|
|
return;
|
|
}
|
|
|
|
// Si cambió la cantidad pero NO se proporcionaron seriales, lanzar error
|
|
if ($quantityChanged && ! $serialsProvided) {
|
|
throw new \Exception('Debe proporcionar los números de serie cuando cambia la cantidad del movimiento.');
|
|
}
|
|
|
|
// Obtener seriales actuales del movimiento
|
|
$currentSerials = InventorySerial::where('movement_id', $movement->id)->get();
|
|
$existingSerialNumbers = $currentSerials->pluck('serial_number')->toArray();
|
|
$newSerialNumbers = array_values(array_filter(array_map('trim', $data['serial_numbers'])));
|
|
|
|
// Validar que la cantidad de seriales proporcionados coincida con la nueva cantidad
|
|
if (count($newSerialNumbers) !== $newQuantity) {
|
|
throw new \Exception(
|
|
'La cantidad de números de serie ('.count($newSerialNumbers).') debe coincidir con la cantidad del movimiento ('.$newQuantity.').'
|
|
);
|
|
}
|
|
|
|
// Determinar qué seriales se conservan, cuáles se agregan y cuáles se eliminan
|
|
$serialesToKeep = array_intersect($newSerialNumbers, $existingSerialNumbers);
|
|
$serialesToAdd = array_diff($newSerialNumbers, $existingSerialNumbers);
|
|
$serialesToRemove = array_diff($existingSerialNumbers, $newSerialNumbers);
|
|
|
|
// Validar que los seriales a eliminar estén disponibles (no vendidos/devueltos)
|
|
if (! empty($serialesToRemove)) {
|
|
$unavailable = $currentSerials
|
|
->whereIn('serial_number', $serialesToRemove)
|
|
->where('status', '!=', 'disponible');
|
|
|
|
if ($unavailable->isNotEmpty()) {
|
|
$unavailableNumbers = $unavailable->pluck('serial_number')->implode(', ');
|
|
throw new \Exception(
|
|
"No se pueden quitar los seriales [{$unavailableNumbers}] porque ya fueron vendidos o devueltos."
|
|
);
|
|
}
|
|
|
|
// Validar que los seriales a eliminar no hayan sido traspasados a otro almacén
|
|
$transferred = $currentSerials
|
|
->whereIn('serial_number', $serialesToRemove)
|
|
->where('warehouse_id', '!=', $movement->warehouse_to_id);
|
|
|
|
if ($transferred->isNotEmpty()) {
|
|
$transferredNumbers = $transferred->pluck('serial_number')->implode(', ');
|
|
throw new \Exception(
|
|
"No se pueden quitar los seriales [{$transferredNumbers}] porque fueron traspasados a otro almacén."
|
|
);
|
|
}
|
|
}
|
|
|
|
// Validar que los nuevos seriales no existan ya en el sistema
|
|
foreach ($serialesToAdd as $serialNumber) {
|
|
$exists = InventorySerial::where('serial_number', $serialNumber)
|
|
->where('movement_id', '!=', $movement->id)
|
|
->exists();
|
|
|
|
if ($exists) {
|
|
throw new \Exception("El número de serie '{$serialNumber}' ya existe en el sistema.");
|
|
}
|
|
}
|
|
|
|
// Eliminar seriales que ya no están en la lista
|
|
if (! empty($serialesToRemove)) {
|
|
InventorySerial::where('movement_id', $movement->id)
|
|
->whereIn('serial_number', $serialesToRemove)
|
|
->where('status', 'disponible')
|
|
->delete();
|
|
}
|
|
|
|
// Actualizar almacén de los seriales que se conservan (por si cambió el almacén)
|
|
if (! empty($serialesToKeep)) {
|
|
InventorySerial::where('movement_id', $movement->id)
|
|
->whereIn('serial_number', $serialesToKeep)
|
|
->update(['warehouse_id' => $warehouseToId]);
|
|
}
|
|
|
|
// Crear los nuevos seriales
|
|
if (! empty($serialesToAdd)) {
|
|
$serials = [];
|
|
foreach ($serialesToAdd as $serialNumber) {
|
|
$serials[] = [
|
|
'inventory_id' => $inventory->id,
|
|
'movement_id' => $movement->id,
|
|
'serial_number' => $serialNumber,
|
|
'warehouse_id' => $warehouseToId,
|
|
'status' => 'disponible',
|
|
'created_at' => now(),
|
|
'updated_at' => now(),
|
|
];
|
|
}
|
|
InventorySerial::insert($serials);
|
|
}
|
|
|
|
// Sincronizar stock desde seriales
|
|
$inventory->syncStock();
|
|
}
|
|
|
|
/**
|
|
* Revertir seriales de un movimiento
|
|
*/
|
|
protected function revertSerials(InventoryMovement $movement): void
|
|
{
|
|
$inventory = $movement->inventory;
|
|
|
|
if (! $inventory->track_serials) {
|
|
return;
|
|
}
|
|
|
|
switch ($movement->movement_type) {
|
|
case 'entry':
|
|
// Eliminar seriales creados por este movimiento (solo si están disponibles)
|
|
InventorySerial::where('movement_id', $movement->id)
|
|
->where('status', 'disponible')
|
|
->delete();
|
|
break;
|
|
|
|
case 'exit':
|
|
case 'transfer':
|
|
break;
|
|
}
|
|
}
|
|
}
|