This episode is for members only
Sign up to access "Build an E-Commerce Platform" right now.
Get started
Already a member? Sign in to continue
Playing
18. Registering the cart service
Episodes
01. Introduction and demo
9m 42s
0%
02. Installing Laravel, Breeze and Livewire
4m 47s
0%
03. Creating categories
9m 4s
0%
04. Recursively displaying categories
8m 21s
0%
05. Product model and migration
2m 50s
0%
06. Showing a product
7m 50s
0%
07. Product variation setup
10m 26s
0%
08. Creating the product selector
10m 34s
0%
09. Loading child variation dropdowns
4m 28s
0%
10. Faking adding the final variation
9m 33s
0%
11. Setting up product stock
4m 34s
0%
12. Calculating variation stock levels
9m 1s
0%
13. Adding product images with MediaLibrary
8m 50s
0%
14. Creating the product gallery
7m 28s
0%
15. Providing a fallback image
2m 56s
0%
16. Adding media to product variations
3m 37s
0%
17. Creating the cart model
3m 37s
0%
18. Registering the cart service
6m 34s
0%
19. Creating a cart session
11m 4s
0%
20. Showing the cart in the navigation
9m 19s
0%
21. Caching the cart instance
3m 2s
0%
22. Adding items to the cart
14m 1s
0%
23. Creating the notification component
8m 5s
0%
24. Showing the user's cart
6m 50s
0%
25. Outputting cart items
4m 50s
0%
26. Showing variation specifics
8m 8s
0%
27. Updating item quantity
8m 2s
0%
28. Removing an item from the cart
6m 1s
0%
29. Calculating the cart summary
8m 7s
0%
30. Showing the category products page
5m 1s
0%
31. Indexing products in Meilisearch
8m 32s
0%
32. Hooking up products to categories
4m 15s
0%
33. Building the product browser
13m 32s
0%
34. Showing child categories
1m 51s
0%
35. Indexing product variations for filtering
8m
0%
36. Outputting variations for filtering
12m 52s
0%
37. Hooking up product filters with Livewire
7m 48s
0%
38. Filtering products
12m 24s
0%
39. Filtering by price
9m 50s
0%
40. Adding global navigation search
7m 50s
0%
41. Handling products that are not live
3m 22s
0%
42. Price range category fix
1m 18s
0%
43. Scaffolding the checkout page
8m 6s
0%
44. Listing shipping options
9m 3s
0%
45. Calculating the cart totals
2m 52s
0%
46. Validating the account form
9m 10s
0%
47. Validating the shipping form
5m 47s
0%
48. Saving the shipping address
8m 4s
0%
49. Selecting a saved shipping address
6m 39s
0%
50. Fix shipping address error for non authenticated users
1m 7s
0%
51. Redirecting if the cart is empty
2m 42s
0%
52. Checking for quantity changes
7m 11s
0%
53. Syncing if quantities have changed
11m 59s
0%
54. Flashing a message when quantities have changed
5m 48s
0%
55. Setting up for orders
5m 17s
0%
56. Creating an order
13m 24s
0%
57. Attaching variations to order
6m 13s
0%
58. Reducing stock after ordering
2m 56s
0%
59. Meilisearch filter query fix
1m 33s
0%
60. Showing the order confirmation page
7m 39s
0%
61. Attaching orders for registering guest users
5m 17s
0%
62. Scaffolding the orders page
5m 30s
0%
63. Filling in order variation details
5m 24s
0%
64. Returning the order status
4m 39s
0%
65. Detecting order status changes
10m 49s
0%
66. Sending the order status change email
5m 12s
0%
67. Sending an order confirmation email
2m 47s
0%
68. Handling deleted cart records
4m 44s
0%
69. Transferring the guest cart
2m 44s
0%
70. Creating a presenter for the order status
4m 31s
0%
71. Setting up Stripe
3m 43s
0%
72. Creating and updating a PaymentIntent
16m 21s
0%
73. The Stripe card form
3m 35s
0%
74. Validating before payment
5m 34s
0%
75. Submitting a payment
6m 40s
0%
76. Checking for a successful payment
5m 47s
0%
77. Handling Stripe client errors
3m 11s
0%
78. Entangling Stripe customer data
2m 18s
0%
Transcript
00:00
Our cart class is going to be different from our cart model,
00:03
and it's going to live in a completely different place. And this is going to be responsible for providing all of the methods that we need to manage our cart. So let's start with a new folder over in app
00:13
and just call this cart. And we'll create a new file in here called cart.php. Let's go ahead and just scaffold this out really quickly. So let's give this a namespace of app and cart.
00:24
And let's, of course, give this a class name of cart. So nothing in here at the moment. What we do want is an interface to this, first of all, to potentially define a list of the methods.
00:35
Not that is super important now, because we know that there's pretty much only going to be one instance of our cart, but also so we can bind it nicely
00:43
to our container within Laravel. So I'm going to go ahead and create a new folder in here and just call this contracts. We can even put that in the same folder.
00:51
And we're going to go and call this cart interface.php. So let's define this out really quickly. So this is a PHP interface called cart interface. And we're not going to put anything in here just for now.
01:03
Let's just give this a namespace really quickly of app, cart, and contracts. And we're pretty much done. The last step is just going ahead
01:12
and making sure we implement our cart interface from that contracts folder. So what we can now do is bind this to our container. And then any methods that we add in here,
01:24
like add, will be available. So we could accept a variation in here to add to our cart, all of that good stuff. We're not going to do that just yet,
01:32
but at least we get this bound in so we can access it from anywhere. So to do this, we're going to create out a service provider, which is specifically going to bind this to our container.
01:42
So let's go ahead and make a provider with Laravel and call this cart service provider. Now, the first thing I'm going to do before I forget is come over to config and app
01:53
and just come down to register this service provider. So let's do this under our application service providers. We can just copy this one down, change this to cart service provider, and we're done.
02:05
So if we hop over to our cart service provider, let's see what we need to register. So we're going to add this in here as a singleton. So we say this app and singleton.
02:15
We need to give this a name. So rather than give it a string name, we want to be able to effectively get this out of our container using the interface name
02:23
so we can inject this automatically into any methods we use, including inside of LiveWire components. So we're going to call this or register this
02:31
under the cart interface namespace. So wherever we need this now, we can pluck it out using the interface. And now we're going to create a closure in here
02:39
and we're going to return a new instance of our cart. Now be careful because we're using the same name for our cart model and our cart class. We could probably do it changing this around,
02:50
but make sure you put in app cart cart and not app models cart because that's definitely not what we need. So that is pretty much it.
02:58
Let's test this out maybe over on our home controller just to see if this works. So to grab your cart out at any point during your app, there's a couple of ways that you can do this.
03:09
Let's look at two ways just in case you need to use either way. The first way is to automatically fetch this out using the cart interface, using auto wiring,
03:19
and we're just going to call that cart. So by providing this in here, making sure that we've got that pulled in at the top, we can go ahead and die dump on cart
03:28
and see what that gives us. Let's go over to the homepage and there we go. We have an instance of our cart, which we can now use to start adding products,
03:38
removing products, anything that we need to do. The second way to do this is to go ahead and use app and then pass in the cart interface class into this. So let's just die dump on this and come over
03:55
and we get exactly the same thing. So you can do this either way. We're mostly going to be doing this with auto wiring and passing this into, for example,
04:04
our invoke magic method. Now we don't need this over on the homepage, so let's get rid of all of this and we'll get rid of any reference to that as well,
04:12
but we can now use our cart anywhere we need. Before we go though, we need to think about the fact that we're using sessions to manage this. Now we could use cookies,
04:22
we could pretty much do anything. We're just going to stick with sessions now because it's a little bit simpler. Now inside of our cart,
04:28
let's just open this up under app and cart, we want to accept into the constructor of this our session manager. So let's go ahead and pull all this up
04:38
and let's accept in here our session manager and we will just call that session. So that's now going to be available if we just set that protected inside of our constructor
04:50
as session somewhere inside of here. So let's just mock this out really quickly by just creating out a create method. Now what this method is eventually going to end up doing
05:00
is creating a fresh cart in the database for us linked up and attached to our session, but let's just do nothing in here for now. We'll just die dump on this session
05:12
just to make sure we're passing that through properly. So if we come over to our cart service provider, we now need to pass a fresh instance of our session manager into here.
05:20
It's a couple of ways that you can do that, but a really easy way is just using Laravel session helper. Now, just to kind of give you an idea about this,
05:28
if we just go down to our boot method here and just die dump on session and come over to any page, you can see that we get that instance of session manager. That's why we type hinted it inside of our main car.
05:40
The basic thing that we need to do though is actually get access to our session functionality so we can read and write from our session. Okay, so now again,
05:49
if we maybe just come back over to the home controller actually and inject this in really quickly, so session, not session, cart interface, and call that cart,
05:59
let's just go ahead and invoke that cart create method, which we're eventually gonna do inside of middleware. So let's go over and just give that a refresh and there we go.
06:08
We're still die dumping our session manager because inside of that create method over on our cart, we're just dying and dumping that. So that's all working nicely
06:16
and we've got access to our session manager so we can go ahead and write to the session using some sort of key and have that within the session lifetime.
06:26
Now it's exactly what we're gonna do in the next part. We're gonna look at creating a cart in the database and hooking it up to the session so we always have it available.
78 episodes•8 hrs 42 mins•3 years ago
Overview
Build a robust e-commerce platform with a Laravel and Livewire. Features products with unlimited and flexible variations, a product browser with filters and price range slider, global product search, guest checkout, shipping and payment implementation, order status tracking and more.
Alex Garrett-Smith
Hey, I'm the founder of Codecourse!
Episode discussion
No comments, yet. Be the first!