tbianchini/shopit-back
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(variants): add minimum and maximum use dates to variants and update related logic

Browse Source
This commit is contained in:
ncoronel
2026-07-27 14:59:07 -03:00
parent 069867522a
commit aa4f3303fc
16 changed files with 391 additions and 28 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
app/Domains/Catalog/Models/CatalogItem.php
View File

@@ -7,6 +7,7 @@ use App\Domains\Catalog\Enums\CatalogItemType;
use App\Domains\Catalog\Enums\InventoryPolicy;
use App\Domains\Catalog\Services\CatalogInventoryService;
use App\Domains\Tenant\Models\Tenant;
use Carbon\CarbonInterface;
use Illuminate\Database\Eloquent\Attributes\Fillable;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
@@ -163,6 +164,16 @@ class CatalogItem extends Model
return $this->nombre;
}
public function getMinimumUseDate(): ?CarbonInterface
{
return $this->minimum_use_date;
}
public function getMaximumUseDate(): ?CarbonInterface
{
return $this->maximum_use_date;
}
public function isBundle(): bool
{
return $this->type === CatalogItemType::Bundle;

17
app/Domains/Catalog/Models/Variant.php
View File

@@ -3,6 +3,7 @@
namespace App\Domains\Catalog\Models;
use App\Domains\Attachable\Models\Attachment;
use Carbon\CarbonInterface;
use Illuminate\Database\Eloquent\Attributes\Fillable;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
@@ -13,6 +14,8 @@ use Illuminate\Database\Eloquent\Relations\HasMany;
#[Fillable([
'catalog_item_id',
'inventory_id',
'minimum_use_date',
'maximum_use_date',
])]
class Variant extends Model
{
@@ -27,6 +30,8 @@ class Variant extends Model
return [
'catalog_item_id' => 'integer',
'inventory_id' => 'integer',
'minimum_use_date' => 'datetime',
'maximum_use_date' => 'datetime',
];
}
@@ -89,4 +94,16 @@ class Variant extends Model
return $definitions === '' ? $name : "{$name} ({$definitions})";
}
public function getMinimumUseDate(): ?CarbonInterface
{
return $this->minimum_use_date
?? $this->catalogItem->getMinimumUseDate();
}
public function getMaximumUseDate(): ?CarbonInterface
{
return $this->maximum_use_date
?? $this->catalogItem->getMaximumUseDate();
}
}

7
app/Domains/Catalog/Requests/StoreCatalogItemRequest.php
View File

@@ -76,6 +76,13 @@ class StoreCatalogItemRequest extends FormRequest
'variants.*.inventory_id' => ['prohibited'],
'variants.*.reserved_stock' => ['prohibited'],
'variants.*.sold_units' => ['prohibited'],
'variants.*.minimum_use_date' => ['sometimes', 'nullable', 'date'],
'variants.*.maximum_use_date' => [
'sometimes',
'nullable',
'date',
'after_or_equal:variants.*.minimum_use_date',
],
'variants.*.values' => ['sometimes', 'array'],
'variants.*.values.*' => ['nullable', 'string'],
'variants.*.images' => ['sometimes', 'array'],

6
app/Domains/Catalog/Resources/CatalogItemDetailResource.php
View File

@@ -111,6 +111,12 @@ class CatalogItemDetailResource extends JsonResource
return [
'id' => $variant->id,
'stock_tecnico' => $this->variantStock($variant),
'minimum_use_date' => $variant->minimum_use_date,
'maximum_use_date' => $variant->maximum_use_date,
'effective_minimum_use_date' => $variant->minimum_use_date
?? $this->minimum_use_date,
'effective_maximum_use_date' => $variant->maximum_use_date
?? $this->maximum_use_date,
'values' => $variant->definitions
->mapWithKeys(fn ($definition) => [
$definition->itemAttribute?->attribute?->codigo => $definition->value,

6
app/Domains/Catalog/Resources/CatalogItemResource.php
View File

@@ -33,6 +33,12 @@ class CatalogItemResource extends JsonResource
->map(fn ($variant) => [
'id' => $variant->id,
'real_stock' => $variant->inventory?->real_stock,
'minimum_use_date' => $variant->minimum_use_date,
'maximum_use_date' => $variant->maximum_use_date,
'effective_minimum_use_date' => $variant->minimum_use_date
?? $this->minimum_use_date,
'effective_maximum_use_date' => $variant->maximum_use_date
?? $this->maximum_use_date,
'values' => $variant->definitions
->mapWithKeys(fn ($definition) => [
$definition->itemAttribute?->attribute?->codigo => $definition->value,

23
app/Domains/Catalog/Services/CatalogService.php
View File

@@ -450,7 +450,12 @@ class CatalogService
$inventory = $this->createInventory((int) ($data['real_stock'] ?? 0));
$variant = $catalogItem->variants()->create([
'inventory_id' => $inventory->id,
'minimum_use_date' => $data['minimum_use_date'] ?? null,
'maximum_use_date' => $data['maximum_use_date'] ?? null,
]);
$variant->setRelation('catalogItem', $catalogItem);
$this->validateVariantUseDates($variant, $index);
foreach ($data['values'] ?? [] as $attributeCode => $value) {
$itemAttribute = $itemAttributes[$attributeCode] ?? null;
@@ -472,6 +477,24 @@ class CatalogService
return $variant;
}
private function validateVariantUseDates(Variant $variant, int $index): void
{
$minimumUseDate = $variant->getMinimumUseDate();
$maximumUseDate = $variant->getMaximumUseDate();
if (
$minimumUseDate !== null
&& $maximumUseDate !== null
&& $maximumUseDate->lessThan($minimumUseDate)
) {
throw ValidationException::withMessages([
"variants.{$index}.maximum_use_date" => [
'La fecha maxima efectiva debe ser posterior o igual a la fecha minima efectiva.',
],
]);
}
}
/**
* @param array<string, mixed> $data
* @param array<int, array<string, mixed>> $variants

9
app/Domains/Ticket/Exceptions/TicketGenerationException.php
View File

@@ -29,6 +29,15 @@ class TicketGenerationException extends RuntimeException
return new self("El producto {$catalogItem->id} alcanzó su fecha máxima de uso.");
}
public static function variantNotFound(
CatalogItem $catalogItem,
int $variantId,
): self {
return new self(
"La variante {$variantId} no pertenece al producto {$catalogItem->id}.",
);
}
public static function purchaseWithoutUser(Purchase $purchase): self
{
return new self("La compra {$purchase->id} no tiene un usuario asociado.");

102
app/Domains/Ticket/Services/TicketGeneratorService.php
View File

@@ -4,6 +4,7 @@ namespace App\Domains\Ticket\Services;
use App\Domains\Auth\Models\User;
use App\Domains\Catalog\Models\CatalogItem;
use App\Domains\Catalog\Models\Variant;
use App\Domains\Ticket\Exceptions\TicketGenerationException;
use App\Domains\Ticket\Models\Ticket;
use Carbon\CarbonInterface;
@@ -29,38 +30,60 @@ class TicketGeneratorService
$now = now();
return DB::transaction(function () use ($catalogItem, $user, $quantity, $sourceVariantId, $now): Collection {
$catalogItems = $this->resolveCatalogItems($catalogItem, $quantity, $now);
$targets = $this->resolveTargets(
$catalogItem,
$quantity,
$sourceVariantId,
$now,
);
return $catalogItems->map(fn (CatalogItem $item): Ticket => Ticket::query()->create([
'tenant_code' => $item->tenant_code,
'ticket' => (string) Str::uuid(),
'name' => $item->nombre,
'description' => (string) ($item->descripcion ?? ''),
'source_catalog_item_id' => $catalogItem->getKey(),
'source_variant_id' => $sourceVariantId,
'starts_at' => $item->minimum_use_date,
'expires_at' => $item->maximum_use_date,
'used_at' => null,
'user_id' => $user->getKey(),
]));
return $targets->map(function (array $target) use (
$catalogItem,
$sourceVariantId,
$user,
): Ticket {
$item = $target['catalog_item'];
$selectedItem = $target['variant'] ?? $item;
return Ticket::query()->create([
'tenant_code' => $item->tenant_code,
'ticket' => (string) Str::uuid(),
'name' => $item->nombre,
'description' => (string) ($item->descripcion ?? ''),
'source_catalog_item_id' => $catalogItem->getKey(),
'source_variant_id' => $sourceVariantId,
'starts_at' => $selectedItem->getMinimumUseDate(),
'expires_at' => $selectedItem->getMaximumUseDate(),
'used_at' => null,
'user_id' => $user->getKey(),
]);
});
});
}
/**
* @return Collection<int, CatalogItem>
* @return Collection<int, array{catalog_item: CatalogItem, variant: Variant|null}>
*/
private function resolveCatalogItems(
private function resolveTargets(
CatalogItem $catalogItem,
int $quantity,
?int $sourceVariantId,
CarbonInterface $now,
): Collection {
if (! $catalogItem->isBundle()) {
$this->validateCatalogItem($catalogItem, $now);
$variant = $this->resolveVariant($catalogItem, $sourceVariantId);
$this->validateTarget($catalogItem, $variant, $now);
return Collection::times($quantity, fn (): CatalogItem => $catalogItem);
return Collection::times($quantity, fn (): array => [
'catalog_item' => $catalogItem,
'variant' => $variant,
]);
}
$catalogItem->loadMissing('bundleComponents.catalogItem');
$catalogItem->loadMissing([
'bundleComponents.catalogItem',
'bundleComponents.variant.catalogItem',
]);
if ($catalogItem->bundleComponents->isEmpty()) {
throw TicketGenerationException::emptyBundle($catalogItem);
@@ -69,23 +92,56 @@ class TicketGeneratorService
return $catalogItem->bundleComponents
->flatMap(function ($component) use ($quantity, $now): Collection {
$componentItem = $component->catalogItem;
$this->validateCatalogItem($componentItem, $now);
$variant = $component->variant;
$this->validateTarget($componentItem, $variant, $now);
return Collection::times(
$quantity * $component->quantity,
fn (): CatalogItem => $componentItem,
fn (): array => [
'catalog_item' => $componentItem,
'variant' => $variant,
],
);
})
->values();
}
private function validateCatalogItem(CatalogItem $catalogItem, CarbonInterface $now): void
{
private function resolveVariant(
CatalogItem $catalogItem,
?int $sourceVariantId,
): ?Variant {
if ($sourceVariantId === null) {
return null;
}
$variant = $catalogItem->variants()
->whereKey($sourceVariantId)
->first();
if ($variant === null) {
throw TicketGenerationException::variantNotFound(
$catalogItem,
$sourceVariantId,
);
}
$variant->setRelation('catalogItem', $catalogItem);
return $variant;
}
private function validateTarget(
CatalogItem $catalogItem,
?Variant $variant,
CarbonInterface $now,
): void {
if (! $catalogItem->has_tickets) {
throw TicketGenerationException::ticketsDisabled($catalogItem);
}
if ($catalogItem->maximum_use_date?->lessThanOrEqualTo($now)) {
$selectedItem = $variant ?? $catalogItem;
if ($selectedItem->getMaximumUseDate()?->lessThanOrEqualTo($now)) {
throw TicketGenerationException::maximumUseDateReached($catalogItem);
}
}