├── .gitignore
├── src
    ├── Exceptions
    │   ├── InvalidRowIDException.php
    │   ├── UnknownModelException.php
    │   └── CartAlreadyStoredException.php
    ├── Facades
    │   └── Cart.php
    ├── CartItemOptions.php
    ├── Contracts
    │   └── Buyable.php
    ├── CanBeBought.php
    ├── ShoppingcartServiceProvider.php
    ├── CartItem.php
    └── Cart.php
├── .travis.yml
├── tests
    ├── Fixtures
    │   ├── ProductModel.php
    │   └── BuyableProduct.php
    ├── CartAssertions.php
    ├── CartItemTest.php
    └── CartTest.php
├── phpunit.xml
├── database
    └── migrations
    │   └── 0000_00_00_000000_create_shoppingcart_table.php
├── LICENSE
├── composer.json
├── config
    └── cart.php
└── README.md


/.gitignore:
--------------------------------------------------------------------------------
1 | /vendor
2 | composer.phar
3 | composer.lock
4 | .DS_Store


--------------------------------------------------------------------------------
/src/Exceptions/InvalidRowIDException.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Surfsidemedia\Shoppingcart\Exceptions;
4 | 
5 | use RuntimeException;
6 | 
7 | class InvalidRowIDException extends RuntimeException {}


--------------------------------------------------------------------------------
/src/Exceptions/UnknownModelException.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Surfsidemedia\Shoppingcart\Exceptions;
4 | 
5 | use RuntimeException;
6 | 
7 | class UnknownModelException extends RuntimeException {}


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: php
 2 | 
 3 | php:
 4 |   - 7.0
 5 | 
 6 | before_script:
 7 |   - composer self-update
 8 |   - composer install --prefer-source --no-interaction
 9 | 
10 | script: vendor/bin/phpunit
11 | 


--------------------------------------------------------------------------------
/src/Exceptions/CartAlreadyStoredException.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Surfsidemedia\Shoppingcart\Exceptions;
4 | 
5 | use RuntimeException;
6 | 
7 | class CartAlreadyStoredException extends RuntimeException {}


--------------------------------------------------------------------------------
/tests/Fixtures/ProductModel.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Surfsidemedia\Tests\Shoppingcart\Fixtures;
 4 | 
 5 | class ProductModel
 6 | {
 7 |     public $someValue = 'Some value';
 8 | 
 9 |     public function find($id)
10 |     {
11 |         return $this;
12 |     }
13 | }


--------------------------------------------------------------------------------
/src/Facades/Cart.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Surfsidemedia\Shoppingcart\Facades;
 3 | 
 4 | use Illuminate\Support\Facades\Facade;
 5 | 
 6 | class Cart extends Facade {
 7 |     /**
 8 |      * Get the registered name of the component.
 9 |      *
10 |      * @return string
11 |      */
12 |     protected static function getFacadeAccessor()
13 |     {
14 |         return 'cart';
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/CartItemOptions.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Surfsidemedia\Shoppingcart;
 4 | 
 5 | use Illuminate\Support\Collection;
 6 | 
 7 | class CartItemOptions extends Collection
 8 | {
 9 |     /**
10 |      * Get the option by the given key.
11 |      *
12 |      * @param string $key
13 |      * @return mixed
14 |      */
15 |     public function __get($key)
16 |     {
17 |         return $this->get($key);
18 |     }
19 | }


--------------------------------------------------------------------------------
/phpunit.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <phpunit backupGlobals="false"
 3 |          backupStaticAttributes="false"
 4 |          bootstrap="vendor/autoload.php"
 5 |          colors="true"
 6 |          convertErrorsToExceptions="true"
 7 |          convertNoticesToExceptions="true"
 8 |          convertWarningsToExceptions="true"
 9 |          processIsolation="false"
10 |          stopOnFailure="false"
11 |          syntaxCheck="false">
12 |     <testsuites>
13 |         <testsuite name="Package Test Suite">
14 |             <directory suffix=".php">./tests/</directory>
15 |         </testsuite>
16 |     </testsuites>
17 | </phpunit>


--------------------------------------------------------------------------------
/src/Contracts/Buyable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Surfsidemedia\Shoppingcart\Contracts;
 4 | 
 5 | interface Buyable
 6 | {
 7 |     /**
 8 |      * Get the identifier of the Buyable item.
 9 |      *
10 |      * @return int|string
11 |      */
12 |     public function getBuyableIdentifier($options = null);
13 | 
14 |     /**
15 |      * Get the description or title of the Buyable item.
16 |      *
17 |      * @return string
18 |      */
19 |     public function getBuyableDescription($options = null);
20 | 
21 |     /**
22 |      * Get the price of the Buyable item.
23 |      *
24 |      * @return float
25 |      */
26 |     public function getBuyablePrice($options = null);
27 | }


--------------------------------------------------------------------------------
/database/migrations/0000_00_00_000000_create_shoppingcart_table.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Illuminate\Support\Facades\Schema;
 4 | use Illuminate\Database\Schema\Blueprint;
 5 | use Illuminate\Database\Migrations\Migration;
 6 | 
 7 | class CreateShoppingcartTable extends Migration
 8 | {
 9 |     /**
10 |      * Run the migrations.
11 |      */
12 |     public function up()
13 |     {
14 |         Schema::create(config('cart.database.table'), function (Blueprint $table) {
15 |             $table->string('identifier');
16 |             $table->string('instance');
17 |             $table->longText('content');
18 |             $table->nullableTimestamps();
19 | 
20 |             $table->primary(['identifier', 'instance']);
21 |         });
22 |     }
23 |     /**
24 |      * Reverse the migrations.
25 |      */
26 |     public function down()
27 |     {
28 |         Schema::drop(config('cart.database.table'));
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/CanBeBought.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Surfsidemedia\Shoppingcart;
 4 | 
 5 | trait CanBeBought
 6 | {
 7 | 
 8 |     /**
 9 |      * Get the identifier of the Buyable item.
10 |      *
11 |      * @return int|string
12 |      */
13 |     public function getBuyableIdentifier($options = null)
14 |     {
15 |         return method_exists($this, 'getKey') ? $this->getKey() : $this->id;
16 |     }
17 | 
18 |     /**
19 |      * Get the description or title of the Buyable item.
20 |      *
21 |      * @return string
22 |      */
23 |     public function getBuyableDescription($options = null)
24 |     {
25 |         if(property_exists($this, 'name')) return $this->name;
26 |         if(property_exists($this, 'title')) return $this->title;
27 |         if(property_exists($this, 'description')) return $this->description;
28 | 
29 |         return null;
30 |     }
31 | 
32 |     /**
33 |      * Get the price of the Buyable item.
34 |      *
35 |      * @return float
36 |      */
37 |     public function getBuyablePrice($options = null)
38 |     {
39 |         if(property_exists($this, 'price')) return $this->price;
40 | 
41 |         return null;
42 |     }
43 | }


--------------------------------------------------------------------------------
/tests/CartAssertions.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Surfsidemedia\Tests\Shoppingcart;
 4 | 
 5 | use Surfsidemedia\Shoppingcart\Cart;
 6 | use PHPUnit\Framework\Assert as PHPUnit;
 7 | 
 8 | trait CartAssertions
 9 | {
10 |     /**
11 |      * Assert that the cart contains the given number of items.
12 |      *
13 |      * @param int|float                     $items
14 |      * @param \Surfsidemedia\Shoppingcart\Cart $cart
15 |      */
16 |     public function assertItemsInCart($items, Cart $cart)
17 |     {
18 |         $actual = $cart->count();
19 | 
20 |         PHPUnit::assertEquals($items, $cart->count(), "Expected the cart to contain {$items} items, but got {$actual}.");
21 |     }
22 | 
23 |     /**
24 |      * Assert that the cart contains the given number of rows.
25 |      *
26 |      * @param int                           $rows
27 |      * @param \Surfsidemedia\Shoppingcart\Cart $cart
28 |      */
29 |     public function assertRowsInCart($rows, Cart $cart)
30 |     {
31 |         $actual = $cart->content()->count();
32 | 
33 |         PHPUnit::assertCount($rows, $cart->content(), "Expected the cart to contain {$rows} rows, but got {$actual}.");
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2025 Surfsidemedia <surfsidesmedia@gmail.com>
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.


--------------------------------------------------------------------------------
/src/ShoppingcartServiceProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Surfsidemedia\Shoppingcart;
 4 | 
 5 | use Illuminate\Auth\Events\Logout;
 6 | use Illuminate\Session\SessionManager;
 7 | use Illuminate\Support\ServiceProvider;
 8 | 
 9 | class ShoppingcartServiceProvider extends ServiceProvider
10 | {
11 | 
12 |     /**
13 |      * Register the service provider.
14 |      *
15 |      * @return void
16 |      */
17 |     public function register()
18 |     {
19 |         $this->app->bind('cart', 'Surfsidemedia\Shoppingcart\Cart');
20 | 
21 |         $config = __DIR__ . '/../config/cart.php';
22 |         $this->mergeConfigFrom($config, 'cart');
23 | 
24 |         $this->publishes([__DIR__ . '/../config/cart.php' => config_path('cart.php')], 'config');
25 | 
26 |         $this->app['events']->listen(Logout::class, function () {
27 |             if ($this->app['config']->get('cart.destroy_on_logout')) {
28 |                 $this->app->make(SessionManager::class)->forget('cart');
29 |             }
30 |         });
31 | 
32 |         if ( ! class_exists('CreateShoppingcartTable')) {
33 |             // Publish the migration
34 |             $timestamp = date('Y_m_d_His', time());
35 | 
36 |             $this->publishes([
37 |                 __DIR__.'/../database/migrations/0000_00_00_000000_create_shoppingcart_table.php' => database_path('migrations/'.$timestamp.'_create_shoppingcart_table.php'),
38 |             ], 'migrations');
39 |         }
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/tests/Fixtures/BuyableProduct.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Surfsidemedia\Tests\Shoppingcart\Fixtures;
 4 | 
 5 | use Surfsidemedia\Shoppingcart\Contracts\Buyable;
 6 | 
 7 | class BuyableProduct implements Buyable
 8 | {
 9 |     /**
10 |      * @var int|string
11 |      */
12 |     private $id;
13 | 
14 |     /**
15 |      * @var string
16 |      */
17 |     private $name;
18 | 
19 |     /**
20 |      * @var float
21 |      */
22 |     private $price;
23 | 
24 |     /**
25 |      * BuyableProduct constructor.
26 |      *
27 |      * @param int|string $id
28 |      * @param string     $name
29 |      * @param float      $price
30 |      */
31 |     public function __construct($id = 1, $name = 'Item name', $price = 10.00)
32 |     {
33 |         $this->id = $id;
34 |         $this->name = $name;
35 |         $this->price = $price;
36 |     }
37 | 
38 |     /**
39 |      * Get the identifier of the Buyable item.
40 |      *
41 |      * @return int|string
42 |      */
43 |     public function getBuyableIdentifier($options = null)
44 |     {
45 |         return $this->id;
46 |     }
47 | 
48 |     /**
49 |      * Get the description or title of the Buyable item.
50 |      *
51 |      * @return string
52 |      */
53 |     public function getBuyableDescription($options = null)
54 |     {
55 |         return $this->name;
56 |     }
57 | 
58 |     /**
59 |      * Get the price of the Buyable item.
60 |      *
61 |      * @return float
62 |      */
63 |     public function getBuyablePrice($options = null)
64 |     {
65 |         return $this->price;
66 |     }
67 | }


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "surfsidemedia/shoppingcart",
 3 |     "description": "Laravel Shoppingcart",
 4 |     "keywords": ["laravel", "shoppingcart"],
 5 |     "license": "MIT",
 6 |     "authors": [
 7 |         {
 8 |             "name": "Sudhir Kumar",
 9 |             "email": "surfsidesmedia@gmail.com"
10 |         }
11 |     ],
12 |     "require": {
13 |       	"illuminate/support": "5.1.*|5.2.*|5.3.*|5.4.*|5.5.*|5.6.*|5.7.*|5.8.*|^6|^7|^8|^9|^10|^11|^12",
14 |     	"illuminate/session": "5.1.*|5.2.*|5.3.*|5.4.*|5.5.*|5.6.*|5.7.*|5.8.*|^6|^7|^8|^9|^10|^11|^12",
15 |        	"illuminate/events": "5.1.*|5.2.*|5.3.*|5.4.*|5.5.*|5.6.*|5.7.*|5.8.*|^6|^7|^8|^9|^10|^11|^12"
16 |     },
17 |     "require-dev": {
18 |         "phpunit/phpunit": "~5.0 || ~6.0 || ~7.0 || ~10.0 || ^10.5 || ^11.5",
19 |         "mockery/mockery": "~1.6",
20 |         "orchestra/testbench": "~3.1"
21 |     },
22 |     "autoload": {
23 |         "psr-4": {
24 |             "Surfsidemedia\\Shoppingcart\\": "src/"
25 |         }
26 |     },
27 |     "autoload-dev": {
28 |         "psr-4": {
29 |             "Surfsidemedia\\Tests\\Shoppingcart\\": "tests/"
30 |         }
31 |     },
32 |     "suggest": {
33 |         "Surfsidemedia/notify": "Simple flash notifications for Laravel"
34 |     },
35 |     "minimum-stability": "stable",
36 |     "extra": {
37 |         "laravel": {
38 |             "providers": [
39 |                 "Surfsidemedia\\Shoppingcart\\ShoppingcartServiceProvider"
40 |             ],
41 |             "aliases": {
42 |                 "Cart": "Surfsidemedia\\Shoppingcart\\Facades\\Cart"
43 |             }
44 |         }
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/tests/CartItemTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Surfsidemedia\Tests\Shoppingcart;
 4 | 
 5 | use Orchestra\Testbench\TestCase;
 6 | use Surfsidemedia\Shoppingcart\CartItem;
 7 | use Surfsidemedia\Shoppingcart\ShoppingcartServiceProvider;
 8 | 
 9 | class CartItemTest extends TestCase
10 | {
11 |     /**
12 |      * Set the package service provider.
13 |      *
14 |      * @param \Illuminate\Foundation\Application $app
15 |      * @return array
16 |      */
17 |     protected function getPackageProviders($app)
18 |     {
19 |         return [ShoppingcartServiceProvider::class];
20 |     }
21 | 
22 |     /** @test */
23 |     public function it_can_be_cast_to_an_array()
24 |     {
25 |         $cartItem = new CartItem(1, 'Some item', 10.00, ['size' => 'XL', 'color' => 'red']);
26 |         $cartItem->setQuantity(2);
27 | 
28 |         $this->assertEquals([
29 |             'id' => 1,
30 |             'name' => 'Some item',
31 |             'price' => 10.00,
32 |             'rowId' => '07d5da5550494c62daf9993cf954303f',
33 |             'qty' => 2,
34 |             'options' => [
35 |                 'size' => 'XL',
36 |                 'color' => 'red'
37 |             ],
38 |             'tax' => 0.0,
39 |             'subtotal' => 20.00,
40 |             'isSaved' => false
41 |         ], $cartItem->toArray());
42 |     }
43 | 
44 |     /** @test */
45 |     public function it_can_be_cast_to_json()
46 |     {
47 |         $cartItem = new CartItem(1, 'Some item', 10.00, ['size' => 'XL', 'color' => 'red']);
48 |         $cartItem->setQuantity(2);
49 | 
50 |         $this->assertJson($cartItem->toJson());
51 | 
52 |         $json = '{"rowId":"07d5da5550494c62daf9993cf954303f","id":1,"name":"Some item","qty":2,"price":10,"options":{"size":"XL","color":"red"},"tax":"0.00","isSaved":false,"subtotal":"20.00"}';
53 | 
54 |         $this->assertEquals($json, $cartItem->toJson());
55 |     }
56 | }
57 | 


--------------------------------------------------------------------------------
/config/cart.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | return [
 4 | 
 5 |     /*
 6 |     |--------------------------------------------------------------------------
 7 |     | Default tax rate
 8 |     |--------------------------------------------------------------------------
 9 |     |
10 |     | This default tax rate will be used when you make a class implement the
11 |     | Taxable interface and use the HasTax trait.
12 |     |
13 |     */
14 | 
15 |     'tax' => 21,
16 | 
17 |     /*
18 |     |--------------------------------------------------------------------------
19 |     | Shoppingcart database settings
20 |     |--------------------------------------------------------------------------
21 |     |
22 |     | Here you can set the connection that the shoppingcart should use when
23 |     | storing and restoring a cart.
24 |     |
25 |     */
26 | 
27 |     'database' => [
28 | 
29 |         'connection' => null,
30 | 
31 |         'table' => 'shoppingcart',
32 | 
33 |     ],
34 | 
35 |     /*
36 |     |--------------------------------------------------------------------------
37 |     | Destroy the cart on user logout
38 |     |--------------------------------------------------------------------------
39 |     |
40 |     | When this option is set to 'true' the cart will automatically
41 |     | destroy all cart instances when the user logs out.
42 |     |
43 |     */
44 | 
45 |     'destroy_on_logout' => false,
46 | 
47 |     /*
48 |     |--------------------------------------------------------------------------
49 |     | Default number format
50 |     |--------------------------------------------------------------------------
51 |     |
52 |     | This defaults will be used for the formated numbers if you don't
53 |     | set them in the method call.
54 |     |
55 |     */
56 | 
57 |     'format' => [
58 | 
59 |         'decimals' => 2,
60 | 
61 |         'decimal_point' => '.',
62 | 
63 |         'thousand_seperator' => ','
64 | 
65 |     ],
66 | 
67 | ];


--------------------------------------------------------------------------------
/src/CartItem.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Surfsidemedia\Shoppingcart;
  4 | 
  5 | use Illuminate\Contracts\Support\Arrayable;
  6 | use Surfsidemedia\Shoppingcart\Contracts\Buyable;
  7 | use Illuminate\Contracts\Support\Jsonable;
  8 | 
  9 | use Illuminate\Support\Arr;
 10 | 
 11 | class CartItem implements Arrayable, Jsonable
 12 | {
 13 |     /**
 14 |      * The rowID of the cart item.
 15 |      *
 16 |      * @var string
 17 |      */
 18 |     public $rowId;
 19 | 
 20 |     /**
 21 |      * The ID of the cart item.
 22 |      *
 23 |      * @var int|string
 24 |      */
 25 |     public $id;
 26 | 
 27 |     /**
 28 |      * The quantity for this cart item.
 29 |      *
 30 |      * @var int|float
 31 |      */
 32 |     public $qty;
 33 | 
 34 |     /**
 35 |      * The name of the cart item.
 36 |      *
 37 |      * @var string
 38 |      */
 39 |     public $name;
 40 | 
 41 |     /**
 42 |      * The price without TAX of the cart item.
 43 |      *
 44 |      * @var float
 45 |      */
 46 |     public $price;
 47 | 
 48 |     /**
 49 |      * The options for this cart item.
 50 |      *
 51 |      * @var array
 52 |      */
 53 |     public $options;
 54 | 
 55 |     /**
 56 |      * The FQN of the associated model.
 57 |      *
 58 |      * @var string|null
 59 |      */
 60 |     private $associatedModel = null;
 61 | 
 62 |     /**
 63 |      * The tax rate for the cart item.
 64 |      *
 65 |      * @var int|float
 66 |      */
 67 |     private $taxRate = 0;
 68 | 
 69 |     /**
 70 |      * Is item saved for later.
 71 |      *
 72 |      * @var boolean
 73 |      */
 74 |     private $isSaved = false;
 75 | 
 76 |     /**
 77 |      * CartItem constructor.
 78 |      *
 79 |      * @param int|string $id
 80 |      * @param string     $name
 81 |      * @param float      $price
 82 |      * @param array      $options
 83 |      */
 84 |     public function __construct($id, $name, $price, array $options = [])
 85 |     {
 86 |         if(empty($id)) {
 87 |             throw new \InvalidArgumentException('Please supply a valid identifier.');
 88 |         }
 89 |         if(empty($name)) {
 90 |             throw new \InvalidArgumentException('Please supply a valid name.');
 91 |         }
 92 |         if(strlen($price) < 0 || ! is_numeric($price)) {
 93 |             throw new \InvalidArgumentException('Please supply a valid price.');
 94 |         }
 95 | 
 96 |         $this->id       = $id;
 97 |         $this->name     = $name;
 98 |         $this->price    = floatval($price);
 99 |         $this->options  = new CartItemOptions($options);
100 |         $this->rowId = $this->generateRowId($id, $options);
101 |     }
102 | 
103 |     /**
104 |      * Returns the formatted price without TAX.
105 |      *
106 |      * @param int    $decimals
107 |      * @param string $decimalPoint
108 |      * @param string $thousandSeperator
109 |      * @return string
110 |      */
111 |     public function price($decimals = null, $decimalPoint = null, $thousandSeperator = null)
112 |     {
113 |         return $this->numberFormat($this->price, $decimals, $decimalPoint, $thousandSeperator);
114 |     }
115 |     
116 |     /**
117 |      * Returns the formatted price with TAX.
118 |      *
119 |      * @param int    $decimals
120 |      * @param string $decimalPoint
121 |      * @param string $thousandSeperator
122 |      * @return string
123 |      */
124 |     public function priceTax($decimals = null, $decimalPoint = null, $thousandSeperator = null)
125 |     {
126 |         return $this->numberFormat($this->priceTax, $decimals, $decimalPoint, $thousandSeperator);
127 |     }
128 | 
129 |     /**
130 |      * Returns the formatted subtotal.
131 |      * Subtotal is price for whole CartItem without TAX
132 |      *
133 |      * @param int    $decimals
134 |      * @param string $decimalPoint
135 |      * @param string $thousandSeperator
136 |      * @return string
137 |      */
138 |     public function subtotal($decimals = null, $decimalPoint = null, $thousandSeperator = null)
139 |     {
140 |         return $this->numberFormat($this->subtotal, $decimals, $decimalPoint, $thousandSeperator);
141 |     }
142 |     
143 |     /**
144 |      * Returns the formatted total.
145 |      * Total is price for whole CartItem with TAX
146 |      *
147 |      * @param int    $decimals
148 |      * @param string $decimalPoint
149 |      * @param string $thousandSeperator
150 |      * @return string
151 |      */
152 |     public function total($decimals = null, $decimalPoint = null, $thousandSeperator = null)
153 |     {
154 |         return $this->numberFormat($this->total, $decimals, $decimalPoint, $thousandSeperator);
155 |     }
156 | 
157 |     /**
158 |      * Returns the formatted tax.
159 |      *
160 |      * @param int    $decimals
161 |      * @param string $decimalPoint
162 |      * @param string $thousandSeperator
163 |      * @return string
164 |      */
165 |     public function tax($decimals = null, $decimalPoint = null, $thousandSeperator = null)
166 |     {
167 |         return $this->numberFormat($this->tax, $decimals, $decimalPoint, $thousandSeperator);
168 |     }
169 |     
170 |     /**
171 |      * Returns the formatted tax.
172 |      *
173 |      * @param int    $decimals
174 |      * @param string $decimalPoint
175 |      * @param string $thousandSeperator
176 |      * @return string
177 |      */
178 |     public function taxTotal($decimals = null, $decimalPoint = null, $thousandSeperator = null)
179 |     {
180 |         return $this->numberFormat($this->taxTotal, $decimals, $decimalPoint, $thousandSeperator);
181 |     }
182 | 
183 |     /**
184 |      * Set the quantity for this cart item.
185 |      *
186 |      * @param int|float $qty
187 |      */
188 |     public function setQuantity($qty)
189 |     {
190 |         if(empty($qty) || ! is_numeric($qty))
191 |             throw new \InvalidArgumentException('Please supply a valid quantity.');
192 | 
193 |         $this->qty = $qty;
194 |     }
195 | 
196 |     /**
197 |      * Update the cart item from a Buyable.
198 |      *
199 |      * @param \Surfsidemedia\Shoppingcart\Contracts\Buyable $item
200 |      * @return void
201 |      */
202 |     public function updateFromBuyable(Buyable $item)
203 |     {
204 |         $this->id       = $item->getBuyableIdentifier($this->options);
205 |         $this->name     = $item->getBuyableDescription($this->options);
206 |         $this->price    = $item->getBuyablePrice($this->options);
207 |         $this->priceTax = $this->price + $this->tax;
208 |     }
209 | 
210 |     /**
211 |      * Update the cart item from an array.
212 |      *
213 |      * @param array $attributes
214 |      * @return void
215 |      */
216 |     public function updateFromArray(array $attributes)
217 |     {
218 |         $this->id       = Arr::get($attributes, 'id', $this->id);
219 |         $this->qty      = Arr::get($attributes, 'qty', $this->qty);
220 |         $this->name     = Arr::get($attributes, 'name', $this->name);
221 |         $this->price    = Arr::get($attributes, 'price', $this->price);
222 |         $this->priceTax = $this->price + $this->tax;
223 |         $this->options  = new CartItemOptions(Arr::get($attributes, 'options', $this->options));
224 | 
225 |         $this->rowId = $this->generateRowId($this->id, $this->options->all());
226 |     }
227 | 
228 |     /**
229 |      * Associate the cart item with the given model.
230 |      *
231 |      * @param mixed $model
232 |      * @return \Surfsidemedia\Shoppingcart\CartItem
233 |      */
234 |     public function associate($model)
235 |     {
236 |         $this->associatedModel = is_string($model) ? $model : get_class($model);
237 |         
238 |         return $this;
239 |     }
240 | 
241 |     /**
242 |      * Set the tax rate.
243 |      *
244 |      * @param int|float $taxRate
245 |      * @return \Surfsidemedia\Shoppingcart\CartItem
246 |      */
247 |     public function setTaxRate($taxRate)
248 |     {
249 |         $this->taxRate = $taxRate;
250 |         
251 |         return $this;
252 |     }
253 | 
254 |     /**
255 |      * Set saved state.
256 |      *
257 |      * @param bool $bool
258 |      * @return \Surfsidemedia\Shoppingcart\CartItem
259 |      */
260 |     public function setSaved($bool)
261 |     {
262 |         $this->isSaved = $bool;
263 | 
264 |         return $this;
265 |     }
266 | 
267 |     /**
268 |      * Get an attribute from the cart item or get the associated model.
269 |      *
270 |      * @param string $attribute
271 |      * @return mixed
272 |      */
273 |     public function __get($attribute)
274 |     {
275 |         if(property_exists($this, $attribute)) {
276 |             return $this->{$attribute};
277 |         }
278 | 
279 |         if ($attribute === 'priceTax') {
280 |             return number_format(($this->price + $this->tax), 2, '.', '');
281 |         }
282 | 
283 |         if ($attribute === 'subtotal') {
284 |             return number_format(($this->qty * $this->price), 2, '.', '');
285 |         }
286 | 
287 |         if ($attribute === 'total') {
288 |             return number_format(($this->qty * $this->priceTax), 2, '.', '');
289 |         }
290 | 
291 |         if ($attribute === 'tax') {
292 |             return number_format(($this->price * ($this->taxRate / 100)), 2, '.', '');
293 |         }
294 | 
295 |         if ($attribute === 'taxTotal') {
296 |             return number_format(($this->tax * $this->qty), 2, '.', '');
297 |         }
298 | 
299 |         if($attribute === 'model' && isset($this->associatedModel)) {
300 |             return with(new $this->associatedModel)->find($this->id);
301 |         }
302 | 
303 |         return null;
304 |     }
305 | 
306 |     /**
307 |      * Create a new instance from a Buyable.
308 |      *
309 |      * @param \Surfsidemedia\Shoppingcart\Contracts\Buyable $item
310 |      * @param array                                      $options
311 |      * @return \Surfsidemedia\Shoppingcart\CartItem
312 |      */
313 |     public static function fromBuyable(Buyable $item, array $options = [])
314 |     {
315 |         return new self($item->getBuyableIdentifier($options), $item->getBuyableDescription($options), $item->getBuyablePrice($options), $options);
316 |     }
317 | 
318 |     /**
319 |      * Create a new instance from the given array.
320 |      *
321 |      * @param array $attributes
322 |      * @return \Surfsidemedia\Shoppingcart\CartItem
323 |      */
324 |     public static function fromArray(array $attributes)
325 |     {
326 |         $options = Arr::get($attributes, 'options', []);
327 | 
328 |         return new self($attributes['id'], $attributes['name'], $attributes['price'], $options);
329 |     }
330 | 
331 |     /**
332 |      * Create a new instance from the given attributes.
333 |      *
334 |      * @param int|string $id
335 |      * @param string     $name
336 |      * @param float      $price
337 |      * @param array      $options
338 |      * @return \Surfsidemedia\Shoppingcart\CartItem
339 |      */
340 |     public static function fromAttributes($id, $name, $price, array $options = [])
341 |     {
342 |         return new self($id, $name, $price, $options);
343 |     }
344 | 
345 |     /**
346 |      * Generate a unique id for the cart item.
347 |      *
348 |      * @param string $id
349 |      * @param array  $options
350 |      * @return string
351 |      */
352 |     protected function generateRowId($id, array $options)
353 |     {
354 |         ksort($options);
355 | 
356 |         return md5($id . serialize($options));
357 |     }
358 | 
359 |     /**
360 |      * Get the instance as an array.
361 |      *
362 |      * @return array
363 |      */
364 |     public function toArray()
365 |     {
366 |         return [
367 |             'rowId'    => $this->rowId,
368 |             'id'       => $this->id,
369 |             'name'     => $this->name,
370 |             'qty'      => $this->qty,
371 |             'price'    => $this->price,
372 |             'options'  => $this->options->toArray(),
373 |             'tax'      => $this->tax,
374 |             'isSaved'      => $this->isSaved,
375 |             'subtotal' => $this->subtotal
376 |         ];
377 |     }
378 | 
379 |     /**
380 |      * Convert the object to its JSON representation.
381 |      *
382 |      * @param int $options
383 |      * @return string
384 |      */
385 |     public function toJson($options = 0)
386 |     {
387 |         if (isset($this->associatedModel)){
388 |             
389 |            return json_encode(array_merge($this->toArray(), ['model' => $this->model]), $options);
390 |         }
391 |         
392 |         return json_encode($this->toArray(), $options);
393 |     }
394 | 
395 |     /**
396 |      * Get the formatted number.
397 |      *
398 |      * @param float  $value
399 |      * @param int    $decimals
400 |      * @param string $decimalPoint
401 |      * @param string $thousandSeperator
402 |      * @return string
403 |      */
404 |     private function numberFormat($value, $decimals = null, $decimalPoint = null, $thousandSeperator = null)
405 |     {
406 |         if (is_null($decimals)){
407 |             $decimals = is_null(config('cart.format.decimals')) ? 2 : config('cart.format.decimals');
408 |         }
409 | 
410 |         if (is_null($decimalPoint)){
411 |             $decimalPoint = is_null(config('cart.format.decimal_point')) ? '.' : config('cart.format.decimal_point');
412 |         }
413 | 
414 |         if (is_null($thousandSeperator)){
415 |             $thousandSeperator = is_null(config('cart.format.thousand_seperator')) ? ',' : config('cart.format.thousand_seperator');
416 |         }
417 | 
418 |         return number_format($value, $decimals, $decimalPoint, $thousandSeperator);
419 |     }
420 | }
421 | 


--------------------------------------------------------------------------------
/src/Cart.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Surfsidemedia\Shoppingcart;
  4 | 
  5 | use Closure;
  6 | use Illuminate\Support\Collection;
  7 | use Illuminate\Session\SessionManager;
  8 | use Illuminate\Database\DatabaseManager;
  9 | use Illuminate\Contracts\Events\Dispatcher;
 10 | use Surfsidemedia\Shoppingcart\Contracts\Buyable;
 11 | use Surfsidemedia\Shoppingcart\Exceptions\UnknownModelException;
 12 | use Surfsidemedia\Shoppingcart\Exceptions\InvalidRowIDException;
 13 | use Surfsidemedia\Shoppingcart\Exceptions\CartAlreadyStoredException;
 14 | 
 15 | class Cart
 16 | {
 17 |     const DEFAULT_INSTANCE = 'default';
 18 | 
 19 |     /**
 20 |      * Instance of the session manager.
 21 |      *
 22 |      * @var \Illuminate\Session\SessionManager
 23 |      */
 24 |     protected $session;
 25 | 
 26 |     /**
 27 |      * Instance of the event dispatcher.
 28 |      *
 29 |      * @var \Illuminate\Contracts\Events\Dispatcher
 30 |      */
 31 |     private $events;
 32 | 
 33 |     /**
 34 |      * Holds the current cart instance.
 35 |      *
 36 |      * @var string
 37 |      */
 38 |     private $instance;
 39 | 
 40 |     /**
 41 |      * Cart constructor.
 42 |      *
 43 |      * @param \Illuminate\Session\SessionManager      $session
 44 |      * @param \Illuminate\Contracts\Events\Dispatcher $events
 45 |      */
 46 |     public function __construct(SessionManager $session, Dispatcher $events)
 47 |     {
 48 |         $this->session = $session;
 49 |         $this->events = $events;
 50 | 
 51 |         $this->instance(self::DEFAULT_INSTANCE);
 52 |     }
 53 | 
 54 |     /**
 55 |      * Set the current cart instance.
 56 |      *
 57 |      * @param string|null $instance
 58 |      * @return \Surfsidemedia\Shoppingcart\Cart
 59 |      */
 60 |     public function instance($instance = null)
 61 |     {
 62 |         $instance = $instance ?: self::DEFAULT_INSTANCE;
 63 | 
 64 |         $this->instance = sprintf('%s.%s', 'cart', $instance);
 65 | 
 66 |         return $this;
 67 |     }
 68 | 
 69 |     /**
 70 |      * Get the current cart instance.
 71 |      *
 72 |      * @return string
 73 |      */
 74 |     public function currentInstance()
 75 |     {
 76 |         return str_replace('cart.', '', $this->instance);
 77 |     }
 78 | 
 79 |     /**
 80 |      * Add an item to the cart.
 81 |      *
 82 |      * @param mixed     $id
 83 |      * @param mixed     $name
 84 |      * @param int|float $qty
 85 |      * @param float     $price
 86 |      * @param array     $options
 87 |      * @param float     $taxrate
 88 |      * @return \Surfsidemedia\Shoppingcart\CartItem
 89 |      */
 90 |     public function add($id, $name = null, $qty = null, $price = null, array $options = [], $taxrate = null)
 91 |     {
 92 |         if ($this->isMulti($id)) {
 93 |             return array_map(function ($item) {
 94 |                 return $this->add($item);
 95 |             }, $id);
 96 |         }
 97 | 
 98 |         if ($id instanceof CartItem) {
 99 |             $cartItem = $id;
100 |         } else {
101 |             $cartItem = $this->createCartItem($id, $name, $qty, $price, $options, $taxrate);
102 |         }
103 | 
104 |         $content = $this->getContent();
105 | 
106 |         if ($content->has($cartItem->rowId)) {
107 |             $cartItem->qty += $content->get($cartItem->rowId)->qty;
108 |         }
109 | 
110 |         $content->put($cartItem->rowId, $cartItem);
111 | 
112 |         $this->events->dispatch('cart.added', $cartItem);
113 | 
114 |         $this->session->put($this->instance, $content);
115 | 
116 |         return $cartItem;
117 |     }
118 | 
119 |     /**
120 |      * Update the cart item with the given rowId.
121 |      *
122 |      * @param string $rowId
123 |      * @param mixed  $qty
124 |      * @return \Surfsidemedia\Shoppingcart\CartItem
125 |      */
126 |     public function update($rowId, $qty)
127 |     {
128 |         $cartItem = $this->get($rowId);
129 | 
130 |         if ($qty instanceof Buyable) {
131 |             $cartItem->updateFromBuyable($qty);
132 |         } elseif (is_array($qty)) {
133 |             $cartItem->updateFromArray($qty);
134 |         } else {
135 |             $cartItem->qty = $qty;
136 |         }
137 | 
138 |         $content = $this->getContent();
139 | 
140 |         if ($rowId !== $cartItem->rowId) {
141 |             $content->pull($rowId);
142 | 
143 |             if ($content->has($cartItem->rowId)) {
144 |                 $existingCartItem = $this->get($cartItem->rowId);
145 |                 $cartItem->setQuantity($existingCartItem->qty + $cartItem->qty);
146 |             }
147 |         }
148 | 
149 |         if ($cartItem->qty <= 0) {
150 |             $this->remove($cartItem->rowId);
151 |             return;
152 |         } else {
153 |             $content->put($cartItem->rowId, $cartItem);
154 |         }
155 | 
156 |         $this->events->dispatch('cart.updated', $cartItem);
157 | 
158 |         $this->session->put($this->instance, $content);
159 | 
160 |         return $cartItem;
161 |     }
162 | 
163 |     /**
164 |      * Remove the cart item with the given rowId from the cart.
165 |      *
166 |      * @param string $rowId
167 |      * @return void
168 |      */
169 |     public function remove($rowId)
170 |     {
171 |         $cartItem = $this->get($rowId);
172 | 
173 |         $content = $this->getContent();
174 | 
175 |         $content->pull($cartItem->rowId);
176 | 
177 |         $this->events->dispatch('cart.removed', $cartItem);
178 | 
179 |         $this->session->put($this->instance, $content);
180 |     }
181 | 
182 |     /**
183 |      * Get a cart item from the cart by its rowId.
184 |      *
185 |      * @param string $rowId
186 |      * @return \Surfsidemedia\Shoppingcart\CartItem
187 |      */
188 |     public function get($rowId)
189 |     {
190 |         $content = $this->getContent();
191 | 
192 |         if ( ! $content->has($rowId))
193 |             throw new InvalidRowIDException("The cart does not contain rowId {$rowId}.");
194 | 
195 |         return $content->get($rowId);
196 |     }
197 | 
198 |     /**
199 |      * Destroy the current cart instance.
200 |      *
201 |      * @return void
202 |      */
203 |     public function destroy()
204 |     {
205 |         $this->session->remove($this->instance);
206 |     }
207 | 
208 |     /**
209 |      * Get the content of the cart.
210 |      *
211 |      * @return \Illuminate\Support\Collection
212 |      */
213 |     public function content()
214 |     {
215 |         if (is_null($this->session->get($this->instance))) {
216 |             return new Collection([]);
217 |         }
218 | 
219 |         return $this->session->get($this->instance);
220 |     }
221 | 
222 |     /**
223 |      * Get the number of items in the cart.
224 |      *
225 |      * @return int|float
226 |      */
227 |     public function count()
228 |     {
229 |         $content = $this->getContent();
230 | 
231 |         return $content->sum('qty');
232 |     }
233 | 
234 |     /**
235 |      * Get the total price of the items in the cart.
236 |      *
237 |      * @param int    $decimals
238 |      * @param string $decimalPoint
239 |      * @param string $thousandSeperator
240 |      * @return string
241 |      */
242 |     public function total($decimals = null, $decimalPoint = null, $thousandSeperator = null)
243 |     {
244 |         $content = $this->getContent();
245 | 
246 |         $total = $content->reduce(function ($total, CartItem $cartItem) {
247 |             return $total + ($cartItem->qty * $cartItem->priceTax);
248 |         }, 0);
249 | 
250 |         return $this->numberFormat($total, $decimals, $decimalPoint, $thousandSeperator);
251 |     }
252 | 
253 |     /**
254 |      * Get the total tax of the items in the cart.
255 |      *
256 |      * @param int    $decimals
257 |      * @param string $decimalPoint
258 |      * @param string $thousandSeperator
259 |      * @return float
260 |      */
261 |     public function tax($decimals = null, $decimalPoint = null, $thousandSeperator = null)
262 |     {
263 |         $content = $this->getContent();
264 | 
265 |         $tax = $content->reduce(function ($tax, CartItem $cartItem) {
266 |             return $tax + ($cartItem->qty * $cartItem->tax);
267 |         }, 0);
268 | 
269 |         return $this->numberFormat($tax, $decimals, $decimalPoint, $thousandSeperator);
270 |     }
271 | 
272 |     /**
273 |      * Get the subtotal (total - tax) of the items in the cart.
274 |      *
275 |      * @param int    $decimals
276 |      * @param string $decimalPoint
277 |      * @param string $thousandSeperator
278 |      * @return float
279 |      */
280 |     public function subtotal($decimals = null, $decimalPoint = null, $thousandSeperator = null)
281 |     {
282 |         $content = $this->getContent();
283 | 
284 |         $subTotal = $content->reduce(function ($subTotal, CartItem $cartItem) {
285 |             return $subTotal + ($cartItem->qty * $cartItem->price);
286 |         }, 0);
287 | 
288 |         return $this->numberFormat($subTotal, $decimals, $decimalPoint, $thousandSeperator);
289 |     }
290 | 
291 |     /**
292 |      * Search the cart content for a cart item matching the given search closure.
293 |      *
294 |      * @param \Closure $search
295 |      * @return \Illuminate\Support\Collection
296 |      */
297 |     public function search(Closure $search)
298 |     {
299 |         $content = $this->getContent();
300 | 
301 |         return $content->filter($search);
302 |     }
303 | 
304 |     /**
305 |      * Associate the cart item with the given rowId with the given model.
306 |      *
307 |      * @param string $rowId
308 |      * @param mixed  $model
309 |      * @return void
310 |      */
311 |     public function associate($rowId, $model)
312 |     {
313 |         if(is_string($model) && ! class_exists($model)) {
314 |             throw new UnknownModelException("The supplied model {$model} does not exist.");
315 |         }
316 | 
317 |         $cartItem = $this->get($rowId);
318 | 
319 |         $cartItem->associate($model);
320 | 
321 |         $content = $this->getContent();
322 | 
323 |         $content->put($cartItem->rowId, $cartItem);
324 | 
325 |         $this->session->put($this->instance, $content);
326 |     }
327 | 
328 |     /**
329 |      * Set the tax rate for the cart item with the given rowId.
330 |      *
331 |      * @param string    $rowId
332 |      * @param int|float $taxRate
333 |      * @return void
334 |      */
335 |     public function setTax($rowId, $taxRate)
336 |     {
337 |         $cartItem = $this->get($rowId);
338 | 
339 |         $cartItem->setTaxRate($taxRate);
340 | 
341 |         $content = $this->getContent();
342 | 
343 |         $content->put($cartItem->rowId, $cartItem);
344 | 
345 |         $this->session->put($this->instance, $content);
346 |     }
347 | 
348 |     /**
349 |      * Store an the current instance of the cart.
350 |      *
351 |      * @param mixed $identifier
352 |      * @return void
353 |      */
354 |     public function store($identifier)
355 |     {
356 |         $content = $this->getContent();
357 | 
358 | 
359 |         $this->getConnection()
360 |              ->table($this->getTableName())
361 |              ->where('identifier', $identifier)
362 |              ->where('instance', $this->currentInstance())
363 |              ->delete();
364 | 
365 | 
366 |         $this->getConnection()->table($this->getTableName())->insert([
367 |             'identifier' => $identifier,
368 |             'instance' => $this->currentInstance(),
369 |             'content' => serialize($content),
370 |             'created_at'=> new \DateTime()
371 |         ]);
372 | 
373 |         $this->events->dispatch('cart.stored');
374 |     }
375 | 
376 |     /**
377 |      * Restore the cart with the given identifier.
378 |      *
379 |      * @param mixed $identifier
380 |      * @return void
381 |      */
382 |     public function restore($identifier)
383 |     {
384 |         if( ! $this->storedCartWithIdentifierExists($identifier)) {
385 |             return;
386 |         }
387 | 
388 |         $stored = $this->getConnection()->table($this->getTableName())
389 |             ->where('instance', $this->currentInstance())
390 |             ->where('identifier', $identifier)->first();
391 | 
392 |         $storedContent = unserialize(data_get($stored, 'content'));
393 | 
394 |         $currentInstance = $this->currentInstance();
395 | 
396 |         $this->instance(data_get($stored, 'instance'));
397 | 
398 |         $content = $this->getContent();
399 | 
400 |         foreach ($storedContent as $cartItem) {
401 |             $content->put($cartItem->rowId, $cartItem);
402 |         }
403 | 
404 |         $this->events->dispatch('cart.restored');
405 | 
406 |         $this->session->put($this->instance, $content);
407 | 
408 |         $this->instance($currentInstance);
409 | 
410 |     }
411 | 
412 | 
413 | 
414 |     /**
415 |      * Deletes the stored cart with given identifier
416 |      *
417 |      * @param mixed $identifier
418 |      */
419 |     public function deleteStoredCart($identifier) {
420 |         $this->getConnection()
421 |              ->table($this->getTableName())
422 |              ->where('identifier', $identifier)
423 |              ->delete();
424 |     }
425 | 
426 | 
427 | 
428 |     /**
429 |      * Magic method to make accessing the total, tax and subtotal properties possible.
430 |      *
431 |      * @param string $attribute
432 |      * @return float|null
433 |      */
434 |     public function __get($attribute)
435 |     {
436 |         if($attribute === 'total') {
437 |             return $this->total();
438 |         }
439 | 
440 |         if($attribute === 'tax') {
441 |             return $this->tax();
442 |         }
443 | 
444 |         if($attribute === 'subtotal') {
445 |             return $this->subtotal();
446 |         }
447 | 
448 |         return null;
449 |     }
450 | 
451 |     /**
452 |      * Get the carts content, if there is no cart content set yet, return a new empty Collection
453 |      *
454 |      * @return \Illuminate\Support\Collection
455 |      */
456 |     protected function getContent()
457 |     {
458 |         $content = $this->session->has($this->instance)
459 |             ? $this->session->get($this->instance)
460 |             : new Collection;
461 | 
462 |         return $content;
463 |     }
464 | 
465 |     /**
466 |      * Create a new CartItem from the supplied attributes.
467 |      *
468 |      * @param mixed     $id
469 |      * @param mixed     $name
470 |      * @param int|float $qty
471 |      * @param float     $price
472 |      * @param array     $options
473 |      * @param float     $taxrate
474 |      * @return \Surfsidemedia\Shoppingcart\CartItem
475 |      */
476 |     private function createCartItem($id, $name, $qty, $price, array $options, $taxrate)
477 |     {
478 |         if ($id instanceof Buyable) {
479 |             $cartItem = CartItem::fromBuyable($id, $qty ?: []);
480 |             $cartItem->setQuantity($name ?: 1);
481 |             $cartItem->associate($id);
482 |         } elseif (is_array($id)) {
483 |             $cartItem = CartItem::fromArray($id);
484 |             $cartItem->setQuantity($id['qty']);
485 |         } else {
486 |             $cartItem = CartItem::fromAttributes($id, $name, $price, $options);
487 |             $cartItem->setQuantity($qty);
488 |         }
489 | 
490 |         if(isset($taxrate) && is_numeric($taxrate)) {
491 |             $cartItem->setTaxRate($taxrate);
492 |         } else {
493 |             $cartItem->setTaxRate(config('cart.tax'));
494 |         }
495 | 
496 |         return $cartItem;
497 |     }
498 | 
499 |     /**
500 |      * Check if the item is a multidimensional array or an array of Buyables.
501 |      *
502 |      * @param mixed $item
503 |      * @return bool
504 |      */
505 |     private function isMulti($item)
506 |     {
507 |         if ( ! is_array($item)) return false;
508 | 
509 |         return is_array(head($item)) || head($item) instanceof Buyable;
510 |     }
511 | 
512 |     /**
513 |      * @param $identifier
514 |      * @return bool
515 |      */
516 |     protected function storedCartWithIdentifierExists($identifier)
517 |     {
518 |         return $this->getConnection()->table($this->getTableName())->where('identifier', $identifier)->where('instance', $this->currentInstance())->exists();
519 |     }
520 | 
521 |     /**
522 |      * Get the database connection.
523 |      *
524 |      * @return \Illuminate\Database\Connection
525 |      */
526 |     protected function getConnection()
527 |     {
528 |         $connectionName = $this->getConnectionName();
529 | 
530 |         return app(DatabaseManager::class)->connection($connectionName);
531 |     }
532 | 
533 |     /**
534 |      * Get the database table name.
535 |      *
536 |      * @return string
537 |      */
538 |     protected function getTableName()
539 |     {
540 |         return config('cart.database.table', 'shoppingcart');
541 |     }
542 | 
543 |     /**
544 |      * Get the database connection name.
545 |      *
546 |      * @return string
547 |      */
548 |     private function getConnectionName()
549 |     {
550 |         $connection = config('cart.database.connection');
551 | 
552 |         return is_null($connection) ? config('database.default') : $connection;
553 |     }
554 | 
555 |     /**
556 |      * Get the Formated number
557 |      *
558 |      * @param $value
559 |      * @param $decimals
560 |      * @param $decimalPoint
561 |      * @param $thousandSeperator
562 |      * @return string
563 |      */
564 |     private function numberFormat($value, $decimals, $decimalPoint, $thousandSeperator)
565 |     {
566 |         if(is_null($decimals)){
567 |             $decimals = is_null(config('cart.format.decimals')) ? 2 : config('cart.format.decimals');
568 |         }
569 |         if(is_null($decimalPoint)){
570 |             $decimalPoint = is_null(config('cart.format.decimal_point')) ? '.' : config('cart.format.decimal_point');
571 |         }
572 |         if(is_null($thousandSeperator)){
573 |             $thousandSeperator = is_null(config('cart.format.thousand_seperator')) ? ',' : config('cart.format.thousand_seperator');
574 |         }
575 | 
576 |         return number_format($value, $decimals, $decimalPoint, $thousandSeperator);
577 |     }
578 | }
579 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | A simple shoppingcart implementation for Laravel.
  2 | 
  3 | ## Installation
  4 | 
  5 | Install the package through [Composer](http://getcomposer.org/). 
  6 | 
  7 | Run the Composer require command from the Terminal:
  8 | 
  9 |     composer require surfsidemedia/shoppingcart
 10 |     
 11 | If you're using Laravel 5.5 or above, this is all there is to do. 
 12 | 
 13 | Should you still be on version 5.4 of Laravel, the final steps for you are to add the service provider of the package and alias the package. To do this open your `config/app.php` file.
 14 | 
 15 | Add a new line to the `providers` array:
 16 | 
 17 | 	Surfsidemedia\Shoppingcart\ShoppingcartServiceProvider::class
 18 | 
 19 | And optionally add a new line to the `aliases` array:
 20 | 
 21 | 	'Cart' => Surfsidemedia\Shoppingcart\Facades\Cart::class,
 22 | 
 23 | Now you're ready to start using the shoppingcart in your application.
 24 | 
 25 | **As of version 2 of this package it's possibly to use dependency injection to inject an instance of the Cart class into your controller or other class**
 26 | 
 27 | ## Overview
 28 | Look at one of the following topics to learn more about LaravelShoppingcart
 29 | 
 30 | * [Usage](#usage)
 31 | * [Collections](#collections)
 32 | * [Instances](#instances)
 33 | * [Models](#models)
 34 | * [Database](#database)
 35 | * [Exceptions](#exceptions)
 36 | * [Events](#events)
 37 | * [Example](#example)
 38 | 
 39 | ## Usage
 40 | 
 41 | The shoppingcart gives you the following methods to use:
 42 | 
 43 | ### Cart::add()
 44 | 
 45 | Adding an item to the cart is really simple, you just use the `add()` method, which accepts a variety of parameters.
 46 | 
 47 | In its most basic form you can specify the id, name, quantity, price of the product you'd like to add to the cart.
 48 | 
 49 | ```php
 50 | Cart::add('293ad', 'Product 1', 1, 9.99);
 51 | ```
 52 | 
 53 | As an optional fifth parameter you can pass it options, so you can add multiple items with the same id, but with (for instance) a different size.
 54 | 
 55 | ```php
 56 | Cart::add('293ad', 'Product 1', 1, 9.99, ['size' => 'large']);
 57 | ```
 58 | 
 59 | You can optional pass different taxrates to the items.
 60 | ```php
 61 | Cart::add('293ad', 'Product 1', 1, 9.99, ['size' => 'large'], 20);
 62 | ```
 63 | 
 64 | **The `add()` method will return an CartItem instance of the item you just added to the cart.**
 65 | 
 66 | Maybe you prefer to add the item using an array? As long as the array contains the required keys, you can pass it to the method. The options key is optional.
 67 | 
 68 | ```php
 69 | Cart::add(['id' => '293ad', 'name' => 'Product 1', 'qty' => 1, 'price' => 9.99, 'options' => ['size' => 'large']]);
 70 | ```
 71 | 
 72 | New in version 2 of the package is the possibility to work with the [Buyable](#buyable) interface. The way this works is that you have a model implement the `Buyable` interface, which will make you implement a few methods so the package knows how to get the id, name and price from your model. 
 73 | This way you can just pass the `add()` method a model and the quantity and it will automatically add it to the cart. 
 74 | 
 75 | The path to the `Buyable` interface is:
 76 | 
 77 |     Surfsidemedia\Shoppingcart\Contracts\Buyable;
 78 | 
 79 | **As an added bonus it will automatically associate the model with the CartItem**
 80 | 
 81 | ```php
 82 | Cart::add($product, 1, ['size' => 'large']);
 83 | ```
 84 | As an optional third parameter you can add options.
 85 | ```php
 86 | Cart::add($product, 1, ['size' => 'large']);
 87 | ```
 88 | 
 89 | Finally, you can also add multipe items to the cart at once.
 90 | You can just pass the `add()` method an array of arrays, or an array of Buyables and they will be added to the cart. 
 91 | 
 92 | **When adding multiple items to the cart, the `add()` method will return an array of CartItems.**
 93 | 
 94 | ```php
 95 | Cart::add([
 96 |   ['id' => '293ad', 'name' => 'Product 1', 'qty' => 1, 'price' => 10.00],
 97 |   ['id' => '4832k', 'name' => 'Product 2', 'qty' => 1, 'price' => 10.00, 'options' => ['size' => 'large']]
 98 | ]);
 99 | 
100 | Cart::add([$product1, $product2]);
101 | 
102 | ```
103 | 
104 | ### Cart::update()
105 | 
106 | To update an item in the cart, you'll first need the rowId of the item.
107 | Next you can use the `update()` method to update it.
108 | 
109 | If you simply want to update the quantity, you'll pass the update method the rowId and the new quantity:
110 | 
111 | ```php
112 | $rowId = 'da39a3ee5e6b4b0d3255bfef95601890afd80709';
113 | 
114 | Cart::update($rowId, 2); // Will update the quantity
115 | ```
116 | 
117 | If you want to update more attributes of the item, you can either pass the update method an array or a `Buyable` as the second parameter. This way you can update all information of the item with the given rowId.
118 | 
119 | ```php
120 | Cart::update($rowId, ['name' => 'Product 1']); // Will update the name
121 | 
122 | Cart::update($rowId, $product); // Will update the id, name and price
123 | 
124 | ```
125 | 
126 | ### Cart::remove()
127 | 
128 | To remove an item for the cart, you'll again need the rowId. This rowId you simply pass to the `remove()` method and it will remove the item from the cart.
129 | 
130 | ```php
131 | $rowId = 'da39a3ee5e6b4b0d3255bfef95601890afd80709';
132 | 
133 | Cart::remove($rowId);
134 | ```
135 | 
136 | ### Cart::get()
137 | 
138 | If you want to get an item from the cart using its rowId, you can simply call the `get()` method on the cart and pass it the rowId.
139 | 
140 | ```php
141 | $rowId = 'da39a3ee5e6b4b0d3255bfef95601890afd80709';
142 | 
143 | Cart::get($rowId);
144 | ```
145 | 
146 | ### Cart::content()
147 | 
148 | Of course you also want to get the carts content. This is where you'll use the `content` method. This method will return a Collection of CartItems which you can iterate over and show the content to your customers.
149 | 
150 | ```php
151 | Cart::content();
152 | ```
153 | 
154 | This method will return the content of the current cart instance, if you want the content of another instance, simply chain the calls.
155 | 
156 | ```php
157 | Cart::instance('wishlist')->content();
158 | ```
159 | 
160 | ### Cart::destroy()
161 | 
162 | If you want to completely remove the content of a cart, you can call the destroy method on the cart. This will remove all CartItems from the cart for the current cart instance.
163 | 
164 | ```php
165 | Cart::destroy();
166 | ```
167 | 
168 | ### Cart::total()
169 | 
170 | The `total()` method can be used to get the calculated total of all items in the cart, given there price and quantity.
171 | 
172 | ```php
173 | Cart::total();
174 | ```
175 | 
176 | The method will automatically format the result, which you can tweak using the three optional parameters
177 | 
178 | ```php
179 | Cart::total($decimals, $decimalSeperator, $thousandSeperator);
180 | ```
181 | 
182 | You can set the default number format in the config file.
183 | 
184 | **If you're not using the Facade, but use dependency injection in your (for instance) Controller, you can also simply get the total property `$cart->total`**
185 | 
186 | ### Cart::tax()
187 | 
188 | The `tax()` method can be used to get the calculated amount of tax for all items in the cart, given there price and quantity.
189 | 
190 | ```php
191 | Cart::tax();
192 | ```
193 | 
194 | The method will automatically format the result, which you can tweak using the three optional parameters
195 | 
196 | ```php
197 | Cart::tax($decimals, $decimalSeperator, $thousandSeperator);
198 | ```
199 | 
200 | You can set the default number format in the config file.
201 | 
202 | **If you're not using the Facade, but use dependency injection in your (for instance) Controller, you can also simply get the tax property `$cart->tax`**
203 | 
204 | ### Cart::subtotal()
205 | 
206 | The `subtotal()` method can be used to get the total of all items in the cart, minus the total amount of tax. 
207 | 
208 | ```php
209 | Cart::subtotal();
210 | ```
211 | 
212 | The method will automatically format the result, which you can tweak using the three optional parameters
213 | 
214 | ```php
215 | Cart::subtotal($decimals, $decimalSeperator, $thousandSeperator);
216 | ```
217 | 
218 | You can set the default number format in the config file.
219 | 
220 | **If you're not using the Facade, but use dependency injection in your (for instance) Controller, you can also simply get the subtotal property `$cart->subtotal`**
221 | 
222 | ### Cart::count()
223 | 
224 | If you want to know how many items there are in your cart, you can use the `count()` method. This method will return the total number of items in the cart. So if you've added 2 books and 1 shirt, it will return 3 items.
225 | 
226 | ```php
227 | Cart::count();
228 | ```
229 | 
230 | ### Cart::search()
231 | 
232 | To find an item in the cart, you can use the `search()` method.
233 | 
234 | **This method was changed on version 2**
235 | 
236 | Behind the scenes, the method simply uses the filter method of the Laravel Collection class. This means you must pass it a Closure in which you'll specify you search terms.
237 | 
238 | If you for instance want to find all items with an id of 1:
239 | 
240 | ```php
241 | $cart->search(function ($cartItem, $rowId) {
242 | 	return $cartItem->id === 1;
243 | });
244 | ```
245 | 
246 | As you can see the Closure will receive two parameters. The first is the CartItem to perform the check against. The second parameter is the rowId of this CartItem.
247 | 
248 | **The method will return a Collection containing all CartItems that where found**
249 | 
250 | This way of searching gives you total control over the search process and gives you the ability to create very precise and specific searches.
251 | 
252 | ## Collections
253 | 
254 | On multiple instances the Cart will return to you a Collection. This is just a simple Laravel Collection, so all methods you can call on a Laravel Collection are also available on the result.
255 | 
256 | As an example, you can quicky get the number of unique products in a cart:
257 | 
258 | ```php
259 | Cart::content()->count();
260 | ```
261 | 
262 | Or you can group the content by the id of the products:
263 | 
264 | ```php
265 | Cart::content()->groupBy('id');
266 | ```
267 | 
268 | ## Instances
269 | 
270 | The packages supports multiple instances of the cart. The way this works is like this:
271 | 
272 | You can set the current instance of the cart by calling `Cart::instance('newInstance')`. From this moment, the active instance of the cart will be `newInstance`, so when you add, remove or get the content of the cart, you're work with the `newInstance` instance of the cart.
273 | If you want to switch instances, you just call `Cart::instance('otherInstance')` again, and you're working with the `otherInstance` again.
274 | 
275 | So a little example:
276 | 
277 | ```php
278 | Cart::instance('shopping')->add('192ao12', 'Product 1', 1, 9.99);
279 | 
280 | // Get the content of the 'shopping' cart
281 | Cart::content();
282 | 
283 | Cart::instance('wishlist')->add('sdjk922', 'Product 2', 1, 19.95, ['size' => 'medium']);
284 | 
285 | // Get the content of the 'wishlist' cart
286 | Cart::content();
287 | 
288 | // If you want to get the content of the 'shopping' cart again
289 | Cart::instance('shopping')->content();
290 | 
291 | // And the count of the 'wishlist' cart again
292 | Cart::instance('wishlist')->count();
293 | ```
294 | 
295 | **N.B. Keep in mind that the cart stays in the last set instance for as long as you don't set a different one during script execution.**
296 | 
297 | **N.B.2 The default cart instance is called `default`, so when you're not using instances,`Cart::content();` is the same as `Cart::instance('default')->content()`.**
298 | 
299 | ## Models
300 | 
301 | Because it can be very convenient to be able to directly access a model from a CartItem is it possible to associate a model with the items in the cart. Let's say you have a `Product` model in your application. With the `associate()` method, you can tell the cart that an item in the cart, is associated to the `Product` model. 
302 | 
303 | That way you can access your model right from the `CartItem`!
304 | 
305 | The model can be accessed via the `model` property on the CartItem.
306 | 
307 | **If your model implements the `Buyable` interface and you used your model to add the item to the cart, it will associate automatically.**
308 | 
309 | Here is an example:
310 | 
311 | ```php
312 | 
313 | // First we'll add the item to the cart.
314 | $cartItem = Cart::add('293ad', 'Product 1', 1, 9.99, ['size' => 'large']);
315 | 
316 | // Next we associate a model with the item.
317 | Cart::associate($cartItem->rowId, 'Product');
318 | 
319 | // Or even easier, call the associate method on the CartItem!
320 | $cartItem->associate('Product');
321 | 
322 | // You can even make it a one-liner
323 | Cart::add('293ad', 'Product 1', 1, 9.99, ['size' => 'large'])->associate('Product');
324 | 
325 | // Now, when iterating over the content of the cart, you can access the model.
326 | foreach(Cart::content() as $row) {
327 | 	echo 'You have ' . $row->qty . ' items of ' . $row->model->name . ' with description: "' . $row->model->description . '" in your cart.';
328 | }
329 | ```
330 | 
331 | ### Buyable
332 | 
333 | For the convenience of faster adding items to cart and their automatic association, your model can implement `Buyable` interface. To do so, it must implement such functions:
334 | 
335 | ```php
336 |     public function getBuyableIdentifier(){
337 |         return $this->id;
338 |     }
339 | 
340 |     public function getBuyableDescription(){
341 |         return $this->name;
342 |     }
343 | 
344 |     public function getBuyablePrice(){
345 |         return $this->price;
346 |     }
347 | ```
348 | 
349 | Example:
350 | 
351 | ```php
352 | <?php
353 | 
354 | namespace App\Models;
355 | 
356 | use Surfsidemedia\Shoppingcart\Contracts\Buyable;
357 | use Illuminate\Database\Eloquent\Model;
358 | 
359 | class Product exends Model implements Buyable {
360 |     public function getBuyableIdentifier($options = null) {
361 |         return $this->id;
362 |     }
363 | 
364 |     public function getBuyableDescription($options = null) {
365 |         return $this->name;
366 |     }
367 | 
368 |     public function getBuyablePrice($options = null) {
369 |         return $this->price;
370 |     }
371 | }
372 | ```
373 | 
374 | 
375 | ## Database
376 | 
377 | - [Config](#configuration)
378 | - [Storing the cart](#storing-the-cart)
379 | - [Restoring the cart](#restoring-the-cart)
380 | 
381 | ### Configuration
382 | To save cart into the database so you can retrieve it later, the package needs to know which database connection to use and what the name of the table is.
383 | By default the package will use the default database connection and use a table named `shoppingcart`.
384 | If you want to change these options, you'll have to publish the `config` file.
385 | 
386 |     php artisan vendor:publish --provider="Surfsidemedia\Shoppingcart\ShoppingcartServiceProvider" --tag="config"
387 | 
388 | This will give you a `cart.php` config file in which you can make the changes.
389 | 
390 | To make your life easy, the package also includes a ready to use `migration` which you can publish by running:
391 | 
392 |     php artisan vendor:publish --provider="Surfsidemedia\Shoppingcart\ShoppingcartServiceProvider" --tag="migrations"
393 |     
394 | This will place a `shoppingcart` table's migration file into `database/migrations` directory. Now all you have to do is run `php artisan migrate` to migrate your database.
395 | 
396 | ### Storing the cart    
397 | To store your cart instance into the database, you have to call the `store($identifier) ` method. Where `$identifier` is a random key, for instance the id or username of the user.
398 | 
399 |     Cart::store('username');
400 |     
401 |     // To store a cart instance named 'wishlist'
402 |     Cart::instance('wishlist')->store('username');
403 | 
404 | ### Restoring the cart
405 | If you want to retrieve the cart from the database and restore it, all you have to do is call the  `restore($identifier)` where `$identifier` is the key you specified for the `store` method.
406 |  
407 |     Cart::restore('username');
408 |     
409 |     // To restore a cart instance named 'wishlist'
410 |     Cart::instance('wishlist')->restore('username');
411 | 
412 | ## Exceptions
413 | 
414 | The Cart package will throw exceptions if something goes wrong. This way it's easier to debug your code using the Cart package or to handle the error based on the type of exceptions. The Cart packages can throw the following exceptions:
415 | 
416 | | Exception                    | Reason                                                                             |
417 | | ---------------------------- | ---------------------------------------------------------------------------------- |
418 | | *CartAlreadyStoredException* | When trying to store a cart that was already stored using the specified identifier |
419 | | *InvalidRowIDException*      | When the rowId that got passed doesn't exists in the current cart instance         |
420 | | *UnknownModelException*      | When you try to associate an none existing model to a CartItem.                    |
421 | 
422 | ## Events
423 | 
424 | The cart also has events build in. There are five events available for you to listen for.
425 | 
426 | | Event         | Fired                                    | Parameter                        |
427 | | ------------- | ---------------------------------------- | -------------------------------- |
428 | | cart.added    | When an item was added to the cart.      | The `CartItem` that was added.   |
429 | | cart.updated  | When an item in the cart was updated.    | The `CartItem` that was updated. |
430 | | cart.removed  | When an item is removed from the cart.   | The `CartItem` that was removed. |
431 | | cart.stored   | When the content of a cart was stored.   | -                                |
432 | | cart.restored | When the content of a cart was restored. | -                                |
433 | 
434 | ## Example
435 | 
436 | Below is a little example of how to list the cart content in a table:
437 | 
438 | ```php
439 | 
440 | // Add some items in your Controller.
441 | Cart::add('192ao12', 'Product 1', 1, 9.99);
442 | Cart::add('1239ad0', 'Product 2', 2, 5.95, ['size' => 'large']);
443 | 
444 | // Display the content in a View.
445 | <table>
446 |    	<thead>
447 |        	<tr>
448 |            	<th>Product</th>
449 |            	<th>Qty</th>
450 |            	<th>Price</th>
451 |            	<th>Subtotal</th>
452 |        	</tr>
453 |    	</thead>
454 | 
455 |    	<tbody>
456 | 
457 |    		<?php foreach(Cart::content() as $row) :?>
458 | 
459 |        		<tr>
460 |            		<td>
461 |                		<p><strong><?php echo $row->name; ?></strong></p>
462 |                		<p><?php echo ($row->options->has('size') ? $row->options->size : ''); ?></p>
463 |            		</td>
464 |            		<td><input type="text" value="<?php echo $row->qty; ?>"></td>
465 |            		<td>$<?php echo $row->price; ?></td>
466 |            		<td>$<?php echo $row->total; ?></td>
467 |        		</tr>
468 | 
469 | 	   	<?php endforeach;?>
470 | 
471 |    	</tbody>
472 |    	
473 |    	<tfoot>
474 |    		<tr>
475 |    			<td colspan="2">&nbsp;</td>
476 |    			<td>Subtotal</td>
477 |    			<td><?php echo Cart::subtotal(); ?></td>
478 |    		</tr>
479 |    		<tr>
480 |    			<td colspan="2">&nbsp;</td>
481 |    			<td>Tax</td>
482 |    			<td><?php echo Cart::tax(); ?></td>
483 |    		</tr>
484 |    		<tr>
485 |    			<td colspan="2">&nbsp;</td>
486 |    			<td>Total</td>
487 |    			<td><?php echo Cart::total(); ?></td>
488 |    		</tr>
489 |    	</tfoot>
490 | </table>
491 | ```
492 | 


--------------------------------------------------------------------------------
/tests/CartTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Surfsidemedia\Tests\Shoppingcart;
  4 | 
  5 | use Mockery;
  6 | use PHPUnit\Framework\Assert;
  7 | use Surfsidemedia\Shoppingcart\Cart;
  8 | use Orchestra\Testbench\TestCase;
  9 | use Illuminate\Auth\Events\Logout;
 10 | use Illuminate\Support\Collection;
 11 | use Surfsidemedia\Shoppingcart\CartItem;
 12 | use Illuminate\Support\Facades\Event;
 13 | use Illuminate\Session\SessionManager;
 14 | use Illuminate\Contracts\Auth\Authenticatable;
 15 | use Surfsidemedia\Shoppingcart\ShoppingcartServiceProvider;
 16 | use Surfsidemedia\Tests\Shoppingcart\Fixtures\ProductModel;
 17 | use Surfsidemedia\Tests\Shoppingcart\Fixtures\BuyableProduct;
 18 | 
 19 | class CartTest extends TestCase
 20 | {
 21 |     use CartAssertions;
 22 | 
 23 |     /**
 24 |      * Set the package service provider.
 25 |      *
 26 |      * @param \Illuminate\Foundation\Application $app
 27 |      * @return array
 28 |      */
 29 |     protected function getPackageProviders($app)
 30 |     {
 31 |         return [ShoppingcartServiceProvider::class];
 32 |     }
 33 | 
 34 |     /**
 35 |      * Define environment setup.
 36 |      *
 37 |      * @param  \Illuminate\Foundation\Application  $app
 38 |      * @return void
 39 |      */
 40 |     protected function getEnvironmentSetUp($app)
 41 |     {
 42 |         $app['config']->set('cart.database.connection', 'testing');
 43 | 
 44 |         $app['config']->set('session.driver', 'array');
 45 | 
 46 |         $app['config']->set('database.default', 'testing');
 47 |         $app['config']->set('database.connections.testing', [
 48 |             'driver'   => 'sqlite',
 49 |             'database' => ':memory:',
 50 |             'prefix'   => '',
 51 |         ]);
 52 |     }
 53 | 
 54 |     /**
 55 |      * Setup the test environment.
 56 |      *
 57 |      * @return void
 58 |      */
 59 |     protected function setUp()
 60 |     {
 61 |         parent::setUp();
 62 | 
 63 |         $this->app->afterResolving('migrator', function ($migrator) {
 64 |             $migrator->path(realpath(__DIR__.'/../database/migrations'));
 65 |         });
 66 |     }
 67 | 
 68 |     /** @test */
 69 |     public function it_has_a_default_instance()
 70 |     {
 71 |         $cart = $this->getCart();
 72 | 
 73 |         $this->assertEquals(Cart::DEFAULT_INSTANCE, $cart->currentInstance());
 74 |     }
 75 | 
 76 |     /** @test */
 77 |     public function it_can_have_multiple_instances()
 78 |     {
 79 |         $cart = $this->getCart();
 80 | 
 81 |         $cart->add(new BuyableProduct(1, 'First item'));
 82 | 
 83 |         $cart->instance('wishlist')->add(new BuyableProduct(2, 'Second item'));
 84 | 
 85 |         $this->assertItemsInCart(1, $cart->instance(Cart::DEFAULT_INSTANCE));
 86 |         $this->assertItemsInCart(1, $cart->instance('wishlist'));
 87 |     }
 88 |     
 89 |     /** @test */
 90 |     public function it_can_add_an_item()
 91 |     {
 92 |         Event::fake();
 93 | 
 94 |         $cart = $this->getCart();
 95 | 
 96 |         $cart->add(new BuyableProduct);
 97 | 
 98 |         $this->assertEquals(1, $cart->count());
 99 | 
100 |         Event::assertDispatched('cart.added');
101 |     }
102 | 
103 |     /** @test */
104 |     public function it_will_return_the_cartitem_of_the_added_item()
105 |     {
106 |         Event::fake();
107 | 
108 |         $cart = $this->getCart();
109 | 
110 |         $cartItem = $cart->add(new BuyableProduct);
111 | 
112 |         $this->assertInstanceOf(CartItem::class, $cartItem);
113 |         $this->assertEquals('027c91341fd5cf4d2579b49c4b6a90da', $cartItem->rowId);
114 | 
115 |         Event::assertDispatched('cart.added');
116 |     }
117 | 
118 |     /** @test */
119 |     public function it_can_add_multiple_buyable_items_at_once()
120 |     {
121 |         Event::fake();
122 | 
123 |         $cart = $this->getCart();
124 | 
125 |         $cart->add([new BuyableProduct(1), new BuyableProduct(2)]);
126 | 
127 |         $this->assertEquals(2, $cart->count());
128 | 
129 |         Event::assertDispatched('cart.added');
130 |     }
131 | 
132 |     /** @test */
133 |     public function it_will_return_an_array_of_cartitems_when_you_add_multiple_items_at_once()
134 |     {
135 |         Event::fake();
136 | 
137 |         $cart = $this->getCart();
138 | 
139 |         $cartItems = $cart->add([new BuyableProduct(1), new BuyableProduct(2)]);
140 | 
141 |         $this->assertTrue(is_array($cartItems));
142 |         $this->assertCount(2, $cartItems);
143 |         $this->assertContainsOnlyInstancesOf(CartItem::class, $cartItems);
144 | 
145 |         Event::assertDispatched('cart.added');
146 |     }
147 | 
148 |     /** @test */
149 |     public function it_can_add_an_item_from_attributes()
150 |     {
151 |         Event::fake();
152 | 
153 |         $cart = $this->getCart();
154 | 
155 |         $cart->add(1, 'Test item', 1, 10.00);
156 | 
157 |         $this->assertEquals(1, $cart->count());
158 | 
159 |         Event::assertDispatched('cart.added');
160 |     }
161 | 
162 |     /** @test */
163 |     public function it_can_add_an_item_from_an_array()
164 |     {
165 |         Event::fake();
166 | 
167 |         $cart = $this->getCart();
168 | 
169 |         $cart->add(['id' => 1, 'name' => 'Test item', 'qty' => 1, 'price' => 10.00]);
170 | 
171 |         $this->assertEquals(1, $cart->count());
172 | 
173 |         Event::assertDispatched('cart.added');
174 |     }
175 | 
176 |     /** @test */
177 |     public function it_can_add_multiple_array_items_at_once()
178 |     {
179 |         Event::fake();
180 | 
181 |         $cart = $this->getCart();
182 | 
183 |         $cart->add([
184 |             ['id' => 1, 'name' => 'Test item 1', 'qty' => 1, 'price' => 10.00],
185 |             ['id' => 2, 'name' => 'Test item 2', 'qty' => 1, 'price' => 10.00]
186 |         ]);
187 | 
188 |         $this->assertEquals(2, $cart->count());
189 | 
190 |         Event::assertDispatched('cart.added');
191 |     }
192 | 
193 |     /** @test */
194 |     public function it_can_add_an_item_with_options()
195 |     {
196 |         Event::fake();
197 | 
198 |         $cart = $this->getCart();
199 | 
200 |         $options = ['size' => 'XL', 'color' => 'red'];
201 | 
202 |         $cart->add(new BuyableProduct, 1, $options);
203 | 
204 |         $cartItem = $cart->get('07d5da5550494c62daf9993cf954303f');
205 | 
206 |         $this->assertInstanceOf(CartItem::class, $cartItem);
207 |         $this->assertEquals('XL', $cartItem->options->size);
208 |         $this->assertEquals('red', $cartItem->options->color);
209 | 
210 |         Event::assertDispatched('cart.added');
211 |     }
212 | 
213 |     /**
214 |      * @test
215 |      * @expectedException \InvalidArgumentException
216 |      * @expectedExceptionMessage Please supply a valid identifier.
217 |      */
218 |     public function it_will_validate_the_identifier()
219 |     {
220 |         $cart = $this->getCart();
221 | 
222 |         $cart->add(null, 'Some title', 1, 10.00);
223 |     }
224 | 
225 |     /**
226 |      * @test
227 |      * @expectedException \InvalidArgumentException
228 |      * @expectedExceptionMessage Please supply a valid name.
229 |      */
230 |     public function it_will_validate_the_name()
231 |     {
232 |         $cart = $this->getCart();
233 | 
234 |         $cart->add(1, null, 1, 10.00);
235 |     }
236 | 
237 |     /**
238 |      * @test
239 |      * @expectedException \InvalidArgumentException
240 |      * @expectedExceptionMessage Please supply a valid quantity.
241 |      */
242 |     public function it_will_validate_the_quantity()
243 |     {
244 |         $cart = $this->getCart();
245 | 
246 |         $cart->add(1, 'Some title', 'invalid', 10.00);
247 |     }
248 | 
249 |     /**
250 |      * @test
251 |      * @expectedException \InvalidArgumentException
252 |      * @expectedExceptionMessage Please supply a valid price.
253 |      */
254 |     public function it_will_validate_the_price()
255 |     {
256 |         $cart = $this->getCart();
257 | 
258 |         $cart->add(1, 'Some title', 1, 'invalid');
259 |     }
260 | 
261 |     /** @test */
262 |     public function it_will_update_the_cart_if_the_item_already_exists_in_the_cart()
263 |     {
264 |         $cart = $this->getCart();
265 | 
266 |         $item = new BuyableProduct;
267 | 
268 |         $cart->add($item);
269 |         $cart->add($item);
270 | 
271 |         $this->assertItemsInCart(2, $cart);
272 |         $this->assertRowsInCart(1, $cart);
273 |     }
274 | 
275 |     /** @test */
276 |     public function it_will_keep_updating_the_quantity_when_an_item_is_added_multiple_times()
277 |     {
278 |         $cart = $this->getCart();
279 | 
280 |         $item = new BuyableProduct;
281 | 
282 |         $cart->add($item);
283 |         $cart->add($item);
284 |         $cart->add($item);
285 | 
286 |         $this->assertItemsInCart(3, $cart);
287 |         $this->assertRowsInCart(1, $cart);
288 |     }
289 | 
290 |     /** @test */
291 |     public function it_can_update_the_quantity_of_an_existing_item_in_the_cart()
292 |     {
293 |         Event::fake();
294 | 
295 |         $cart = $this->getCart();
296 | 
297 |         $cart->add(new BuyableProduct);
298 | 
299 |         $cart->update('027c91341fd5cf4d2579b49c4b6a90da', 2);
300 | 
301 |         $this->assertItemsInCart(2, $cart);
302 |         $this->assertRowsInCart(1, $cart);
303 | 
304 |         Event::assertDispatched('cart.updated');
305 |     }
306 | 
307 |     /** @test */
308 |     public function it_can_update_an_existing_item_in_the_cart_from_a_buyable()
309 |     {
310 |         Event::fake();
311 | 
312 |         $cart = $this->getCart();
313 | 
314 |         $cart->add(new BuyableProduct);
315 | 
316 |         $cart->update('027c91341fd5cf4d2579b49c4b6a90da', new BuyableProduct(1, 'Different description'));
317 | 
318 |         $this->assertItemsInCart(1, $cart);
319 |         $this->assertEquals('Different description', $cart->get('027c91341fd5cf4d2579b49c4b6a90da')->name);
320 | 
321 |         Event::assertDispatched('cart.updated');
322 |     }
323 | 
324 |     /** @test */
325 |     public function it_can_update_an_existing_item_in_the_cart_from_an_array()
326 |     {
327 |         Event::fake();
328 | 
329 |         $cart = $this->getCart();
330 | 
331 |         $cart->add(new BuyableProduct);
332 | 
333 |         $cart->update('027c91341fd5cf4d2579b49c4b6a90da', ['name' => 'Different description']);
334 | 
335 |         $this->assertItemsInCart(1, $cart);
336 |         $this->assertEquals('Different description', $cart->get('027c91341fd5cf4d2579b49c4b6a90da')->name);
337 | 
338 |         Event::assertDispatched('cart.updated');
339 |     }
340 | 
341 |     /**
342 |      * @test
343 |      * @expectedException \Surfsidemedia\Shoppingcart\Exceptions\InvalidRowIDException
344 |      */
345 |     public function it_will_throw_an_exception_if_a_rowid_was_not_found()
346 |     {
347 |         $cart = $this->getCart();
348 | 
349 |         $cart->add(new BuyableProduct);
350 | 
351 |         $cart->update('none-existing-rowid', new BuyableProduct(1, 'Different description'));
352 |     }
353 | 
354 |     /** @test */
355 |     public function it_will_regenerate_the_rowid_if_the_options_changed()
356 |     {
357 |         $cart = $this->getCart();
358 | 
359 |         $cart->add(new BuyableProduct, 1, ['color' => 'red']);
360 | 
361 |         $cart->update('ea65e0bdcd1967c4b3149e9e780177c0', ['options' => ['color' => 'blue']]);
362 | 
363 |         $this->assertItemsInCart(1, $cart);
364 |         $this->assertEquals('7e70a1e9aaadd18c72921a07aae5d011', $cart->content()->first()->rowId);
365 |         $this->assertEquals('blue', $cart->get('7e70a1e9aaadd18c72921a07aae5d011')->options->color);
366 |     }
367 | 
368 |     /** @test */
369 |     public function it_will_add_the_item_to_an_existing_row_if_the_options_changed_to_an_existing_rowid()
370 |     {
371 |         $cart = $this->getCart();
372 | 
373 |         $cart->add(new BuyableProduct, 1, ['color' => 'red']);
374 |         $cart->add(new BuyableProduct, 1, ['color' => 'blue']);
375 | 
376 |         $cart->update('7e70a1e9aaadd18c72921a07aae5d011', ['options' => ['color' => 'red']]);
377 | 
378 |         $this->assertItemsInCart(2, $cart);
379 |         $this->assertRowsInCart(1, $cart);
380 |     }
381 | 
382 |     /** @test */
383 |     public function it_can_remove_an_item_from_the_cart()
384 |     {
385 |         Event::fake();
386 | 
387 |         $cart = $this->getCart();
388 | 
389 |         $cart->add(new BuyableProduct);
390 | 
391 |         $cart->remove('027c91341fd5cf4d2579b49c4b6a90da');
392 | 
393 |         $this->assertItemsInCart(0, $cart);
394 |         $this->assertRowsInCart(0, $cart);
395 | 
396 |         Event::assertDispatched('cart.removed');
397 |     }
398 | 
399 |     /** @test */
400 |     public function it_will_remove_the_item_if_its_quantity_was_set_to_zero()
401 |     {
402 |         Event::fake();
403 | 
404 |         $cart = $this->getCart();
405 | 
406 |         $cart->add(new BuyableProduct);
407 | 
408 |         $cart->update('027c91341fd5cf4d2579b49c4b6a90da', 0);
409 | 
410 |         $this->assertItemsInCart(0, $cart);
411 |         $this->assertRowsInCart(0, $cart);
412 | 
413 |         Event::assertDispatched('cart.removed');
414 |     }
415 | 
416 |     /** @test */
417 |     public function it_will_remove_the_item_if_its_quantity_was_set_negative()
418 |     {
419 |         Event::fake();
420 | 
421 |         $cart = $this->getCart();
422 | 
423 |         $cart->add(new BuyableProduct);
424 | 
425 |         $cart->update('027c91341fd5cf4d2579b49c4b6a90da', -1);
426 | 
427 |         $this->assertItemsInCart(0, $cart);
428 |         $this->assertRowsInCart(0, $cart);
429 | 
430 |         Event::assertDispatched('cart.removed');
431 |     }
432 | 
433 |     /** @test */
434 |     public function it_can_get_an_item_from_the_cart_by_its_rowid()
435 |     {
436 |         $cart = $this->getCart();
437 | 
438 |         $cart->add(new BuyableProduct);
439 | 
440 |         $cartItem = $cart->get('027c91341fd5cf4d2579b49c4b6a90da');
441 | 
442 |         $this->assertInstanceOf(CartItem::class, $cartItem);
443 |     }
444 | 
445 |     /** @test */
446 |     public function it_can_get_the_content_of_the_cart()
447 |     {
448 |         $cart = $this->getCart();
449 | 
450 |         $cart->add(new BuyableProduct(1));
451 |         $cart->add(new BuyableProduct(2));
452 | 
453 |         $content = $cart->content();
454 | 
455 |         $this->assertInstanceOf(Collection::class, $content);
456 |         $this->assertCount(2, $content);
457 |     }
458 | 
459 |     /** @test */
460 |     public function it_will_return_an_empty_collection_if_the_cart_is_empty()
461 |     {
462 |         $cart = $this->getCart();
463 | 
464 |         $content = $cart->content();
465 | 
466 |         $this->assertInstanceOf(Collection::class, $content);
467 |         $this->assertCount(0, $content);
468 |     }
469 | 
470 |     /** @test */
471 |     public function it_will_include_the_tax_and_subtotal_when_converted_to_an_array()
472 |     {
473 |         $cart = $this->getCart();
474 | 
475 |         $cart->add(new BuyableProduct(1));
476 |         $cart->add(new BuyableProduct(2));
477 | 
478 |         $content = $cart->content();
479 | 
480 |         $this->assertInstanceOf(Collection::class, $content);
481 |         $this->assertEquals([
482 |             '027c91341fd5cf4d2579b49c4b6a90da' => [
483 |                 'rowId' => '027c91341fd5cf4d2579b49c4b6a90da',
484 |                 'id' => 1,
485 |                 'name' => 'Item name',
486 |                 'qty' => 1,
487 |                 'price' => 10.00,
488 |                 'tax' => 2.10,
489 |                 'subtotal' => 10.0,
490 |                 'isSaved' => false,
491 |                 'options' => [],
492 |             ],
493 |             '370d08585360f5c568b18d1f2e4ca1df' => [
494 |                 'rowId' => '370d08585360f5c568b18d1f2e4ca1df',
495 |                 'id' => 2,
496 |                 'name' => 'Item name',
497 |                 'qty' => 1,
498 |                 'price' => 10.00,
499 |                 'tax' => 2.10,
500 |                 'subtotal' => 10.0,
501 |                 'isSaved' => false,
502 |                 'options' => [],
503 |             ]
504 |         ], $content->toArray());
505 |     }
506 | 
507 |     /** @test */
508 |     public function it_can_destroy_a_cart()
509 |     {
510 |         $cart = $this->getCart();
511 | 
512 |         $cart->add(new BuyableProduct);
513 | 
514 |         $this->assertItemsInCart(1, $cart);
515 | 
516 |         $cart->destroy();
517 | 
518 |         $this->assertItemsInCart(0, $cart);
519 |     }
520 | 
521 |     /** @test */
522 |     public function it_can_get_the_total_price_of_the_cart_content()
523 |     {
524 |         $cart = $this->getCart();
525 | 
526 |         $cart->add(new BuyableProduct(1, 'First item', 10.00));
527 |         $cart->add(new BuyableProduct(2, 'Second item', 25.00), 2);
528 | 
529 |         $this->assertItemsInCart(3, $cart);
530 |         $this->assertEquals(60.00, $cart->subtotal());
531 |     }
532 | 
533 |     /** @test */
534 |     public function it_can_return_a_formatted_total()
535 |     {
536 |         $cart = $this->getCart();
537 | 
538 |         $cart->add(new BuyableProduct(1, 'First item', 1000.00));
539 |         $cart->add(new BuyableProduct(2, 'Second item', 2500.00), 2);
540 | 
541 |         $this->assertItemsInCart(3, $cart);
542 |         $this->assertEquals('6.000,00', $cart->subtotal(2, ',', '.'));
543 |     }
544 | 
545 |     /** @test */
546 |     public function it_can_search_the_cart_for_a_specific_item()
547 |     {
548 |         $cart = $this->getCart();
549 | 
550 |         $cart->add(new BuyableProduct(1, 'Some item'));
551 |         $cart->add(new BuyableProduct(2, 'Another item'));
552 | 
553 |         $cartItem = $cart->search(function ($cartItem, $rowId) {
554 |             return $cartItem->name == 'Some item';
555 |         });
556 | 
557 |         $this->assertInstanceOf(Collection::class, $cartItem);
558 |         $this->assertCount(1, $cartItem);
559 |         $this->assertInstanceOf(CartItem::class, $cartItem->first());
560 |         $this->assertEquals(1, $cartItem->first()->id);
561 |     }
562 | 
563 |     /** @test */
564 |     public function it_can_search_the_cart_for_multiple_items()
565 |     {
566 |         $cart = $this->getCart();
567 | 
568 |         $cart->add(new BuyableProduct(1, 'Some item'));
569 |         $cart->add(new BuyableProduct(2, 'Some item'));
570 |         $cart->add(new BuyableProduct(3, 'Another item'));
571 | 
572 |         $cartItem = $cart->search(function ($cartItem, $rowId) {
573 |             return $cartItem->name == 'Some item';
574 |         });
575 | 
576 |         $this->assertInstanceOf(Collection::class, $cartItem);
577 |     }
578 | 
579 |     /** @test */
580 |     public function it_can_search_the_cart_for_a_specific_item_with_options()
581 |     {
582 |         $cart = $this->getCart();
583 | 
584 |         $cart->add(new BuyableProduct(1, 'Some item'), 1, ['color' => 'red']);
585 |         $cart->add(new BuyableProduct(2, 'Another item'), 1, ['color' => 'blue']);
586 | 
587 |         $cartItem = $cart->search(function ($cartItem, $rowId) {
588 |             return $cartItem->options->color == 'red';
589 |         });
590 | 
591 |         $this->assertInstanceOf(Collection::class, $cartItem);
592 |         $this->assertCount(1, $cartItem);
593 |         $this->assertInstanceOf(CartItem::class, $cartItem->first());
594 |         $this->assertEquals(1, $cartItem->first()->id);
595 |     }
596 | 
597 |     /** @test */
598 |     public function it_will_associate_the_cart_item_with_a_model_when_you_add_a_buyable()
599 |     {
600 |         $cart = $this->getCart();
601 | 
602 |         $cart->add(new BuyableProduct);
603 | 
604 |         $cartItem = $cart->get('027c91341fd5cf4d2579b49c4b6a90da');
605 | 
606 |         $this->assertContains(BuyableProduct::class, Assert::readAttribute($cartItem, 'associatedModel'));
607 |     }
608 | 
609 |     /** @test */
610 |     public function it_can_associate_the_cart_item_with_a_model()
611 |     {
612 |         $cart = $this->getCart();
613 | 
614 |         $cart->add(1, 'Test item', 1, 10.00);
615 | 
616 |         $cart->associate('027c91341fd5cf4d2579b49c4b6a90da', new ProductModel);
617 | 
618 |         $cartItem = $cart->get('027c91341fd5cf4d2579b49c4b6a90da');
619 | 
620 |         $this->assertEquals(ProductModel::class, Assert::readAttribute($cartItem, 'associatedModel'));
621 |     }
622 | 
623 |     /**
624 |      * @test
625 |      * @expectedException \Surfsidemedia\Shoppingcart\Exceptions\UnknownModelException
626 |      * @expectedExceptionMessage The supplied model SomeModel does not exist.
627 |      */
628 |     public function it_will_throw_an_exception_when_a_non_existing_model_is_being_associated()
629 |     {
630 |         $cart = $this->getCart();
631 | 
632 |         $cart->add(1, 'Test item', 1, 10.00);
633 | 
634 |         $cart->associate('027c91341fd5cf4d2579b49c4b6a90da', 'SomeModel');
635 |     }
636 | 
637 |     /** @test */
638 |     public function it_can_get_the_associated_model_of_a_cart_item()
639 |     {
640 |         $cart = $this->getCart();
641 | 
642 |         $cart->add(1, 'Test item', 1, 10.00);
643 | 
644 |         $cart->associate('027c91341fd5cf4d2579b49c4b6a90da', new ProductModel);
645 | 
646 |         $cartItem = $cart->get('027c91341fd5cf4d2579b49c4b6a90da');
647 | 
648 |         $this->assertInstanceOf(ProductModel::class, $cartItem->model);
649 |         $this->assertEquals('Some value', $cartItem->model->someValue);
650 |     }
651 | 
652 |     /** @test */
653 |     public function it_can_calculate_the_subtotal_of_a_cart_item()
654 |     {
655 |         $cart = $this->getCart();
656 | 
657 |         $cart->add(new BuyableProduct(1, 'Some title', 9.99), 3);
658 | 
659 |         $cartItem = $cart->get('027c91341fd5cf4d2579b49c4b6a90da');
660 | 
661 |         $this->assertEquals(29.97, $cartItem->subtotal);
662 |     }
663 | 
664 |     /** @test */
665 |     public function it_can_return_a_formatted_subtotal()
666 |     {
667 |         $cart = $this->getCart();
668 | 
669 |         $cart->add(new BuyableProduct(1, 'Some title', 500), 3);
670 | 
671 |         $cartItem = $cart->get('027c91341fd5cf4d2579b49c4b6a90da');
672 | 
673 |         $this->assertEquals('1.500,00', $cartItem->subtotal(2, ',', '.'));
674 |     }
675 | 
676 |     /** @test */
677 |     public function it_can_calculate_tax_based_on_the_default_tax_rate_in_the_config()
678 |     {
679 |         $cart = $this->getCart();
680 | 
681 |         $cart->add(new BuyableProduct(1, 'Some title', 10.00), 1);
682 | 
683 |         $cartItem = $cart->get('027c91341fd5cf4d2579b49c4b6a90da');
684 | 
685 |         $this->assertEquals(2.10, $cartItem->tax);
686 |     }
687 | 
688 |     /** @test */
689 |     public function it_can_calculate_tax_based_on_the_specified_tax()
690 |     {
691 |         $cart = $this->getCart();
692 | 
693 |         $cart->add(new BuyableProduct(1, 'Some title', 10.00), 1);
694 | 
695 |         $cart->setTax('027c91341fd5cf4d2579b49c4b6a90da', 19);
696 | 
697 |         $cartItem = $cart->get('027c91341fd5cf4d2579b49c4b6a90da');
698 | 
699 |         $this->assertEquals(1.90, $cartItem->tax);
700 |     }
701 | 
702 |     /** @test */
703 |     public function it_can_return_the_calculated_tax_formatted()
704 |     {
705 |         $cart = $this->getCart();
706 | 
707 |         $cart->add(new BuyableProduct(1, 'Some title', 10000.00), 1);
708 | 
709 |         $cartItem = $cart->get('027c91341fd5cf4d2579b49c4b6a90da');
710 | 
711 |         $this->assertEquals('2.100,00', $cartItem->tax(2, ',', '.'));
712 |     }
713 | 
714 |     /** @test */
715 |     public function it_can_calculate_the_total_tax_for_all_cart_items()
716 |     {
717 |         $cart = $this->getCart();
718 | 
719 |         $cart->add(new BuyableProduct(1, 'Some title', 10.00), 1);
720 |         $cart->add(new BuyableProduct(2, 'Some title', 20.00), 2);
721 | 
722 |         $this->assertEquals(10.50, $cart->tax);
723 |     }
724 | 
725 |     /** @test */
726 |     public function it_can_return_formatted_total_tax()
727 |     {
728 |         $cart = $this->getCart();
729 | 
730 |         $cart->add(new BuyableProduct(1, 'Some title', 1000.00), 1);
731 |         $cart->add(new BuyableProduct(2, 'Some title', 2000.00), 2);
732 | 
733 |         $this->assertEquals('1.050,00', $cart->tax(2, ',', '.'));
734 |     }
735 | 
736 |     /** @test */
737 |     public function it_can_return_the_subtotal()
738 |     {
739 |         $cart = $this->getCart();
740 | 
741 |         $cart->add(new BuyableProduct(1, 'Some title', 10.00), 1);
742 |         $cart->add(new BuyableProduct(2, 'Some title', 20.00), 2);
743 | 
744 |         $this->assertEquals(50.00, $cart->subtotal);
745 |     }
746 | 
747 |     /** @test */
748 |     public function it_can_return_formatted_subtotal()
749 |     {
750 |         $cart = $this->getCart();
751 | 
752 |         $cart->add(new BuyableProduct(1, 'Some title', 1000.00), 1);
753 |         $cart->add(new BuyableProduct(2, 'Some title', 2000.00), 2);
754 | 
755 |         $this->assertEquals('5000,00', $cart->subtotal(2, ',', ''));
756 |     }
757 | 
758 |     /** @test */
759 |     public function it_can_return_cart_formated_numbers_by_config_values()
760 |     {
761 |         $this->setConfigFormat(2, ',', '');
762 | 
763 |         $cart = $this->getCart();
764 | 
765 |         $cart->add(new BuyableProduct(1, 'Some title', 1000.00), 1);
766 |         $cart->add(new BuyableProduct(2, 'Some title', 2000.00), 2);
767 | 
768 |         $this->assertEquals('5000,00', $cart->subtotal());
769 |         $this->assertEquals('1050,00', $cart->tax());
770 |         $this->assertEquals('6050,00', $cart->total());
771 | 
772 |         $this->assertEquals('5000,00', $cart->subtotal);
773 |         $this->assertEquals('1050,00', $cart->tax);
774 |         $this->assertEquals('6050,00', $cart->total);
775 |     }
776 | 
777 |     /** @test */
778 |     public function it_can_return_cartItem_formated_numbers_by_config_values()
779 |     {
780 |         $this->setConfigFormat(2, ',', '');
781 | 
782 |         $cart = $this->getCart();
783 | 
784 |         $cart->add(new BuyableProduct(1, 'Some title', 2000.00), 2);
785 | 
786 |         $cartItem = $cart->get('027c91341fd5cf4d2579b49c4b6a90da');
787 | 
788 |         $this->assertEquals('2000,00', $cartItem->price());
789 |         $this->assertEquals('2420,00', $cartItem->priceTax());
790 |         $this->assertEquals('4000,00', $cartItem->subtotal());
791 |         $this->assertEquals('4840,00', $cartItem->total());
792 |         $this->assertEquals('420,00', $cartItem->tax());
793 |         $this->assertEquals('840,00', $cartItem->taxTotal());
794 |     }
795 | 
796 |     /** @test */
797 |     public function it_can_store_the_cart_in_a_database()
798 |     {
799 |         $this->artisan('migrate', [
800 |             '--database' => 'testing',
801 |         ]);
802 | 
803 |         Event::fake();
804 | 
805 |         $cart = $this->getCart();
806 | 
807 |         $cart->add(new BuyableProduct);
808 | 
809 |         $cart->store($identifier = 123);
810 | 
811 |         $serialized = serialize($cart->content());
812 | 
813 |         $this->assertDatabaseHas('shoppingcart', ['identifier' => $identifier, 'instance' => 'default', 'content' => $serialized]);
814 | 
815 |         Event::assertDispatched('cart.stored');
816 |     }
817 | 
818 |     /** @test */
819 |     public function it_can_update_the_cart_in_database()
820 |     {
821 |         $this->artisan('migrate', [
822 |             '--database' => 'testing',
823 |         ]);
824 | 
825 |         Event::fake();
826 | 
827 |         $cart = $this->getCart();
828 | 
829 |         $cart->add(new BuyableProduct);
830 | 
831 |         $cart->store($identifier = 123);
832 | 
833 |         $serialized = serialize($cart->content());
834 | 
835 |         $this->assertDatabaseHas('shoppingcart', ['identifier' => $identifier, 'instance' => 'default', 'content' => $serialized]);
836 |         
837 |         Event::assertDispatched('cart.stored');
838 |     }
839 | 
840 |     /** @test */
841 |     public function it_can_restore_a_cart_from_the_database()
842 |     {
843 |         $this->artisan('migrate', [
844 |             '--database' => 'testing',
845 |         ]);
846 | 
847 |         Event::fake();
848 | 
849 |         $cart = $this->getCart();
850 | 
851 |         $cart->add(new BuyableProduct);
852 | 
853 |         $cart->store($identifier = 123);
854 | 
855 |         $cart->destroy();
856 | 
857 |         $this->assertItemsInCart(0, $cart);
858 | 
859 |         $cart->restore($identifier);
860 | 
861 |         $this->assertItemsInCart(1, $cart);       
862 | 
863 |         Event::assertDispatched('cart.restored');
864 |     }
865 | 
866 |     /** @test */
867 |     public function it_will_just_keep_the_current_instance_if_no_cart_with_the_given_identifier_was_stored()
868 |     {
869 |         $this->artisan('migrate', [
870 |             '--database' => 'testing',
871 |         ]);
872 | 
873 |         $cart = $this->getCart();
874 | 
875 |         $cart->restore($identifier = 123);
876 | 
877 |         $this->assertItemsInCart(0, $cart);
878 |     }
879 | 
880 |     /** @test */
881 |     public function it_can_calculate_all_values()
882 |     {
883 |         $cart = $this->getCart();
884 | 
885 |         $cart->add(new BuyableProduct(1, 'First item', 10.00), 2);
886 | 
887 |         $cartItem = $cart->get('027c91341fd5cf4d2579b49c4b6a90da');
888 | 
889 |         $cart->setTax('027c91341fd5cf4d2579b49c4b6a90da', 19);
890 | 
891 |         $this->assertEquals(10.00, $cartItem->price(2));
892 |         $this->assertEquals(11.90, $cartItem->priceTax(2));
893 |         $this->assertEquals(20.00, $cartItem->subtotal(2));
894 |         $this->assertEquals(23.80, $cartItem->total(2));
895 |         $this->assertEquals(1.90, $cartItem->tax(2));
896 |         $this->assertEquals(3.80, $cartItem->taxTotal(2));
897 | 
898 |         $this->assertEquals(20.00, $cart->subtotal(2));
899 |         $this->assertEquals(23.80, $cart->total(2));
900 |         $this->assertEquals(3.80, $cart->tax(2));
901 |     }
902 | 
903 |     /** @test */
904 |     public function it_will_destroy_the_cart_when_the_user_logs_out_and_the_config_setting_was_set_to_true()
905 |     {
906 |         $this->app['config']->set('cart.destroy_on_logout', true);
907 | 
908 |         $this->app->instance(SessionManager::class, Mockery::mock(SessionManager::class, function ($mock) {
909 |             $mock->shouldReceive('forget')->once()->with('cart');
910 |         }));
911 | 
912 |         $user = Mockery::mock(Authenticatable::class);
913 | 
914 |         event(new Logout($user));
915 |     }
916 | 
917 |     /**
918 |      * Get an instance of the cart.
919 |      *
920 |      * @return \Surfsidemedia\Shoppingcart\Cart
921 |      */
922 |     private function getCart()
923 |     {
924 |         $session = $this->app->make('session');
925 |         $events = $this->app->make('events');
926 | 
927 |         return new Cart($session, $events);
928 |     }
929 | 
930 |     /**
931 |      * Set the config number format.
932 |      * 
933 |      * @param int    $decimals
934 |      * @param string $decimalPoint
935 |      * @param string $thousandSeperator
936 |      */
937 |     private function setConfigFormat($decimals, $decimalPoint, $thousandSeperator)
938 |     {
939 |         $this->app['config']->set('cart.format.decimals', $decimals);
940 |         $this->app['config']->set('cart.format.decimal_point', $decimalPoint);
941 |         $this->app['config']->set('cart.format.thousand_seperator', $thousandSeperator);
942 |     }
943 | }
944 | 


--------------------------------------------------------------------------------