Collections

Shopper\Core\Models\Collection

use Shopper\Core\Models\Collection;

// The model implements
- Shopper\Core\Models\Contracts\Collection
- Spatie\MediaLibrary\HasMedia

namespace App\Models;

use Shopper\Core\Models\Collection as BaseCollection;

class Collection extends BaseCollection
{
    // Add your customizations here
}

return [
    'collection' => \App\Models\Collection::class,
];

use Shopper\Core\Enum\CollectionType;

CollectionType::Manual  // Products are manually selected
CollectionType::Auto    // Products are added based on rules

$collection->isManual();    // true for manual collections
$collection->isAutomatic(); // true for automatic collections

// Get all products in the collection
$collection->products;

// Add products (manual collection)
$collection->products()->attach([$productId1, $productId2]);

// Remove products
$collection->products()->detach($productId);

// Sync products
$collection->products()->sync($productIds);

// Get all zones associated with a collection
$collection->zones;

// Attach zones to a collection
$collection->zones()->attach([$zoneId1, $zoneId2]);

// Detach zones
$collection->zones()->detach($zoneId);

// Sync zones
$collection->zones()->sync($zoneIds);

use Shopper\Core\Models\Zone;

$zone = Zone::query()->find($id);

// Get all collections for this zone
$zone->collections;

use Shopper\Core\Enum\Operator;
use Shopper\Core\Enum\Rule;

// Get collection rules
$collection->rules; // Collection of CollectionRule models

// Add a rule
$collection->rules()->create([
    'rule' => Rule::ProductTitle,
    'operator' => Operator::Contains,
    'value' => 'summer',
]);

use Shopper\Core\Models\Collection;

// Get manual collections only
Collection::query()->manual()->get();

// Get automatic collections only
Collection::query()->automatic()->get();

use Shopper\Core\Enum\Rule;

Rule::ProductTitle      // Match product title
Rule::ProductPrice      // Match product price
Rule::CompareAtPrice    // Match compare at price
Rule::InventoryStock    // Match stock level
Rule::ProductBrand      // Match product brand
Rule::ProductCategory   // Match product category
Rule::ProductCreatedAt  // Match product creation date
Rule::ProductFeatured   // Match featured status
Rule::ProductRating     // Match average rating
Rule::ProductSalesCount // Match total units sold

use Shopper\Core\Enum\Operator;

Operator::Equals        // equals_to
Operator::NotEquals     // not_equals_to
Operator::GreaterThan   // greater_than
Operator::LessThan      // less_than
Operator::StartsWith    // starts_with
Operator::EndsWith      // ends_with
Operator::Contains      // contains
Operator::NotContains   // not_contains

// All rules must match
$collection->match_conditions = 'all';

// Any rule can match
$collection->match_conditions = 'any';

// Get formatted first rule for admin display
$collection->firstRule();

// Returns: "Product title contains Summer + 2 other"

use Shopper\Core\Models\Collection;
use Shopper\Core\Enum\CollectionType;

$collection = Collection::query()->create([
    'name' => 'Summer Essentials',
    'type' => CollectionType::Manual,
    'published_at' => now(),
]);

// Add products manually
$collection->products()->attach([
    $product1->id,
    $product2->id,
]);

use Shopper\Core\Enum\CollectionType;
use Shopper\Core\Enum\Operator;
use Shopper\Core\Enum\Rule;

$collection = Collection::query()->create([
    'name' => 'Sale Items',
    'type' => CollectionType::Auto,
    'match_conditions' => 'all',
    'published_at' => now(),
]);

// Add rules
$collection->rules()->createMany([
    [
        'rule' => Rule::ProductPrice,
        'operator' => Operator::LessThan,
        'value' => '5000', // $50.00 in cents
    ],
    [
        'rule' => Rule::ProductTitle,
        'operator' => Operator::Contains,
        'value' => 'sale',
    ],
]);

$collection = Collection::query()->create([
    'name' => 'Best Sellers',
    'type' => CollectionType::Auto,
    'match_conditions' => 'all',
    'published_at' => now(),
]);

$collection->rules()->create([
    'rule' => Rule::ProductSalesCount,
    'operator' => Operator::GreaterThan,
    'value' => '10', // More than 10 units sold
]);

$collection = Collection::query()->create([
    'name' => 'Top Rated',
    'type' => CollectionType::Auto,
    'match_conditions' => 'all',
    'published_at' => now(),
]);

$collection->rules()->create([
    'rule' => Rule::ProductRating,
    'operator' => Operator::GreaterThan,
    'value' => '3', // Average rating > 3 (4-5 stars)
]);

// Get all published collections
$collections = Collection::query()
    ->whereNotNull('published_at')
    ->where('published_at', '<=', now())
    ->get();

// Get collection with products
$collection = Collection::query()
    ->where('slug', 'summer-essentials')
    ->with(['products' => fn ($q) => $q->publish()])
    ->firstOrFail();

// Get manual collections only
$manualCollections = Collection::query()->manual()->get();

// Get automatic collections with rules
$autoCollections = Collection::query()
    ->automatic()
    ->with('rules')
    ->get();

use Shopper\Core\Models\Collection;

$collection = Collection::query()->find($id);

// Get all products (works for both manual and automatic collections)
$products = $collection->getProducts();

// Get the query builder for pagination or further filtering
$products = $collection->productsQuery()->paginate(12);

// With additional filtering
$products = $collection->productsQuery()
    ->where('featured', true)
    ->orderBy('name')
    ->get();

// Automatic collection with rules
$collection = Collection::query()
    ->where('slug', 'sale-items')
    ->with('rules') // Eager load rules for performance
    ->first();

// Products matching the collection's rules
$products = $collection->getProducts();

use Shopper\Core\Queries\CollectionProductsQuery;

// Direct usage of the query class
$query = new CollectionProductsQuery();
$products = $query->get($collection);

// Or get the builder for customization
$builder = $query->query($collection);
$products = $builder->with('brand')->paginate(10);

# Sync all automatic collections
php artisan shopper:collections:sync

# Sync a specific collection
php artisan shopper:collections:sync --collection=1

use Shopper\Core\Actions\SyncCollectionProductsAction;
use Shopper\Core\Models\Collection;

$collection = Collection::query()->find($id);

$action = new SyncCollectionProductsAction();
$syncedCount = $action->execute($collection);

php artisan queue:work

// config/shopper/features.php
use Shopper\Enum\FeatureState;

return [
    'collection' => FeatureState::Disabled,
];

php artisan shopper:component:publish collection

use Shopper\Livewire;

return [
    'pages' => [
        'collection-index' => Livewire\Pages\Collection\Index::class,
        'collection-edit' => Livewire\Pages\Collection\Edit::class,
    ],
    'components' => [
        'collections.products' => Livewire\Components\Collection\CollectionProducts::class,

        'slide-overs.collection-rules' => Livewire\SlideOvers\CollectionRules::class,
        'slide-overs.add-collection-form' => Livewire\SlideOvers\AddCollectionForm::class,
        'slide-overs.collection-products-list' => Livewire\SlideOvers\CollectionProductsList::class,
    ],
];

namespace App\Http\Controllers;

use Shopper\Core\Models\Collection;

class CollectionController extends Controller
{
    public function index()
    {
        $collections = Collection::query()
            ->whereNotNull('published_at')
            ->where('published_at', '<=', now())
            ->withCount('products')
            ->get();

        return view('collections.index', compact('collections'));
    }

    public function show(string $slug)
    {
        $collection = Collection::query()
            ->where('slug', $slug)
            ->whereNotNull('published_at')
            ->with('rules') // Eager load rules for automatic collections
            ->firstOrFail();

        // Works for both manual and automatic collections
        $products = $collection->productsQuery()
            ->with(['brand', 'media'])
            ->paginate(12);

        return view('collections.show', compact('collection', 'products'));
    }
}