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

41. Handling products that are not live

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

We're now going to deal with products that are not live, meaning they're not marked as live in the database, and shouldn't be shown anywhere. They shouldn't be shown in our search results, they shouldn't be shown on the categories page just here, and we shouldn't be able to access

00:14

them like this. Now the easiest way to do this is to add a global scope, so that's what we're going to be doing right now. Okay, so to add a global scope over in the model that you want to use, if we just come up to the very top, what we're going to do is add a static method in here called booted. Now this will be invoked when the model is booted, so here what we can do is say

00:43

something like static add global scope, and then we can pass the scope in. Now we don't have that at the moment, so let's go ahead and create this now under models. I tend to put this in a scopes directory, and let's just call this live scope like so. Okay, so let's build this out. The namespace now is going to be app models and scopes. The class name is of course live scope, and this needs to

01:06

extend the base scope over on Laravel, so let's pull this in. It doesn't look like we can find it here, so oh no, so it needs to implement scope. Let's go ahead and say implement scope, and there it is. So it's under database eloquent and scope, and then this requires that we have an apply method. So let's go ahead and create our apply, and that gives us our builder and our model that

01:33

filled automatically, but go ahead and type that out if your IDE doesn't. So with this, what we can do is just apply from this builder, which is our query builder, and remember over in our database, if we just head over to that really quickly, we've got this live at property just here. So what we can do is say builder where not null live at, meaning if this is null, then it means it's not

02:00

live, and if it is not null, it means it is live, so this is good. Okay, so now that we have our scope, we can go over and actually add this global scope by going ahead and saying new live scope, pulling that in, and we should be good. So if we just come over and give this a refresh and click on one of these products, of course this is going to work. Let's set the Nike Air Force 2 to not

02:21

live. So if we come over here and just set live at to null, and we come over and give this a refresh, we get a 404, because that is now being applied everywhere, including root model binding, and if we come over to here, that also isn't found here, because when we do a mellisearch search, we're pulling this back, but then of course we're relooking that data up in the database.

02:43

Now if we go ahead and do a search for this, you can notice that it's also not in there, because we are hitting mellisearch through laravel scout, so it's not pulling this back. Now if we come over to mellisearch here, you can see both of these products are still in here. If we just go and run scout flush to reset that, and then scout import, and we come over,

03:03

you can see that only one has been indexed. That global scope that we have set in there has gone ahead and applied to that as well, so it's now not even in our mellisearch index. So there we go. We cannot now access any products that have not been set live, and we can tweak this later if we need to get around it.

Episode summary

In this episode, we're focusing on making sure that products that aren't marked as "live" in our database don't show up anywhere on our site. That means hiding them from the search results, category listings, and making it so you can't even access them directly with a URL.

The main approach here is using a global scope in our Product model. We walk through adding a booted static method to the model, then setting up a dedicated LiveScope class in a scopes directory. This scope checks the live_at field and only includes products where it's not null (which means they're live).

Once that's in place, we test it out: set a product to not be live, and we see it disappears from everywhere—even from Meilisearch search queries after we flush and re-import with Scout. The result is a much cleaner and more secure product experience. Don’t worry, you can always tweak the scope later if you need an exception.

So, by the end of this, we've locked down access to non-live products everywhere in the application, making our product listings and search much more robust.

Episode discussion

No comments, yet. Be the first!