Build an E-Commerce Platform

Sign in Get started

This episode is for members only

Sign up to access "Build an E-Commerce Platform" right now.

Already a member? Sign in to continue

Playing

68. Handling deleted cart records

Episodes

0%

Your progress

Total: 8h 42m
Played: 0m
Remaining: 8h 42m

Join or sign in to track your progress

01. Introduction and demo

02. Installing Laravel, Breeze and Livewire

03. Creating categories

04. Recursively displaying categories

05. Product model and migration

06. Showing a product

07. Product variation setup

08. Creating the product selector

09. Loading child variation dropdowns

10. Faking adding the final variation

11. Setting up product stock

12. Calculating variation stock levels

13. Adding product images with MediaLibrary

14. Creating the product gallery

15. Providing a fallback image

16. Adding media to product variations

17. Creating the cart model

18. Registering the cart service

19. Creating a cart session

20. Showing the cart in the navigation

21. Caching the cart instance

22. Adding items to the cart

23. Creating the notification component

24. Showing the user's cart

25. Outputting cart items

26. Showing variation specifics

27. Updating item quantity

28. Removing an item from the cart

29. Calculating the cart summary

30. Showing the category products page

31. Indexing products in Meilisearch

32. Hooking up products to categories

33. Building the product browser

34. Showing child categories

35. Indexing product variations for filtering

36. Outputting variations for filtering

37. Hooking up product filters with Livewire

38. Filtering products

39. Filtering by price

40. Adding global navigation search

41. Handling products that are not live

42. Price range category fix

43. Scaffolding the checkout page

44. Listing shipping options

45. Calculating the cart totals

46. Validating the account form

47. Validating the shipping form

48. Saving the shipping address

49. Selecting a saved shipping address

50. Fix shipping address error for non authenticated users

51. Redirecting if the cart is empty

52. Checking for quantity changes

53. Syncing if quantities have changed

54. Flashing a message when quantities have changed

55. Setting up for orders

56. Creating an order

57. Attaching variations to order

58. Reducing stock after ordering

59. Meilisearch filter query fix

60. Showing the order confirmation page

61. Attaching orders for registering guest users

62. Scaffolding the orders page

63. Filling in order variation details

64. Returning the order status

65. Detecting order status changes

66. Sending the order status change email

67. Sending an order confirmation email

68. Handling deleted cart records

69. Transferring the guest cart

70. Creating a presenter for the order status

71. Setting up Stripe

72. Creating and updating a PaymentIntent

73. The Stripe card form

74. Validating before payment

75. Submitting a payment

76. Checking for a successful payment

77. Handling Stripe client errors

78. Entangling Stripe customer data

Transcript

00:00

OK.

00:00

So we're going to fix up an issue that we saw earlier in the course. And also, when a user checks out, we're going to go ahead and delete the cart record

00:08

from the database. Otherwise, what's going to happen is we're going to have a huge amount of these cart records hanging around.

00:14

You will end up with more than you need, because of course, the users will come in, add things to their cart, and not check out. But of course, we would want to keep them in there,

00:23

because that gives you an opportunity then to perhaps check out which items users have added to their cart and who hasn't checked out. So we're going to leave the carts in here.

00:32

We're not going to always clear them up. But when we check out, we're going to remove the cart record, because there's no need for it to be in there.

00:39

The first thing that we're going to do, though, is look at what happens when we just delete a cart record from the database. If we come over and now give this a refresh,

00:46

you can see that we get an error. Attempt to read property variations on null. Now of course, the reason that this is working is because over in our cart, we are

00:56

trying to access the instance, which of course, doesn't exist. Now the only reason that we're allowed to access this instance is because if we just come up to, say, exists, we're just checking if the session has

01:10

that key in this specified by config. It doesn't actually check that the instance is available. So what we could also do is just say this instance and see what we get.

01:22

So let's come over and give this a refresh. And you can see this now works. Now a side effect of this is that when we give this a refresh, a new cart has been created.

01:30

It's not going to be created every single time. If we just come over, we still keep one in there. And the reason that that is the case is remember over in our cart middleware,

01:39

we are checking if the cart exists, which is the check that we've just changed. And if it doesn't exist, we're going to go ahead and create a cart passing that user.

01:48

So that's very, very simply fixed up this issue just to make sure that this still exists in the database. Let's now go ahead and create another method in here. And we'll just do this up here called destroy.

02:01

This is going to go ahead and just completely destroy this cart. And we're going to call this when we check out. For now, though, what we're going to do

02:08

is over in the cart middleware, go and call that in here. So let's say cart destroy. Now this is going to have the same effect as if we didn't have this check in place.

02:16

It's going to create a new cart. And then it's going to immediately destroy it. So at the moment, of course, this does nothing. We have undefined variable cart.

02:23

Let's just fix that up to this cart. That's going to do nothing at the moment, because we're not doing anything inside of cart here. So what do we want to do to destroy a cart?

02:35

Well, we want to delete the database record. But we also want to delete the session record. Or we could just leave this as it is, because our exist check handles this up.

02:43

But I think destroying this from the database would work well as well. So the first thing that we're going to do is go ahead and remove this from the session.

02:52

So let's go ahead and say this session. And we can go ahead and say forget. So we just need to pass in the config just here, like so, and we're done.

03:02

So that's going to remove that from the session. And then we want to go ahead and delete the instance. So we're just going to say instance and delete. Remember, instance returns to us a model that we get.

03:15

So by deleting that, that will remove that from the database. So if I just give this a refresh, what is effectively happening is it's removing from the database.

03:23

But as soon as we land back on this page, it's going to go ahead and put a new item into the cart table for us. Now, at the moment, we get cannot access delete on null.

03:34

That kind of makes sense, because we're just doing this in our cart middleware. That doesn't make sense whatsoever. So we're going to go ahead and do this over in our checkout.

03:41

So we can do this just down here. And we can reference cart, because that's how we're putting it in here. And we can just use destroy.

03:48

So let's start from the beginning. Let's get rid of this record here. Verify that when we refresh this, this creates a new cart for us.

03:55

This starts with ABA, so let's keep an eye on that. If we refresh this again, of course it stays the same. Now let's go ahead and just check out and see what we get. So let's choose one of these.

04:05

And let's go ahead and hit cart, checkout, choose this pre-saved address, hit confirm. And there we go. That should have removed the cart for us.

04:14

So that's got rid of that. It has put a new record in there. So it's entirely up to you whether you do implement this or not,

04:20

because once we refresh, we're technically recreating that cart session. So you could just leave that as it is, because we have emptied the cart,

04:27

or you could go ahead and remove that. So you create a new cart instance. I'll leave it up to you whether you want to go ahead and physically delete that.

04:36

Okay, there we go. A couple of changes to our cart, really importantly to handle what happens when we delete a cart instance from the database.

Episode summary

In this episode, we're cleaning up some loose ends in our shopping cart! We noticed earlier in the course that cart records in the database can pile up—especially since users may start carts and never check out. While you might want to keep some carts hanging around for analytics, there's no reason to keep a cart after someone has completed their purchase.

We start by exploring what happens if a cart record is simply deleted from the database—we find that this can cause errors in our application because the code expects the cart to exist. We then update our logic to handle cases where the cart is missing, so things don't break unexpectedly.

Next, we implement a destroy method for the cart, which removes the cart both from the user's session and from the database. We hook this up so that when a user checks out, their cart is fully removed. Afterwards, if the user comes back, a fresh cart is automatically created for them.

Finally, we test everything out and discuss some options: you can choose whether to remove the cart entirely once the session is over, or just leave it—either is fine depending on how you want your app to behave!

All in all, this episode is about responsibly tidying up cart records to keep your database neat, while preventing unexpected errors when carts disappear.

Episode discussion

No comments, yet. Be the first!