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

58. Reducing stock after ordering

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

Okay, so after we've created the order and we have attached the variations,

00:05

we of course need to reduce the stock. So we're going to do this in a slightly inefficient way by going ahead and iterating through all of the contents, which means if we had 10 items now can't, we're going to go ahead and form 10 queries.

00:19

We'll clear this up a little bit later, but let's get this done for now. Once we've iterated through them for each of the variations, which we get into this closure here,

00:29

we are going to go ahead and access the stocks, and we're going to create a record, and remember this is going to be a negative record. So all we need to do for this is in the amount,

00:40

just subtract from zero. So we're just going to grab from that pivot table, the quantity, and that's pretty much it. So let's go ahead and try this out.

00:52

We just come over here. Remember, we're not clearing our car out just at the moment, so we've got all of these products still in here. Let's go and choose an address.

01:01

We'll keep an eye on our stocks table as well. So let's open this up and just keep that open. Let's click confirm order, and yeah, we need to add the fillable property to stock.

01:12

Let's head over to the model here, and let's jump down and of course, go ahead and add in that fillable column, and that's going to be amount.

01:22

Let's head back over, try that again, and make sure we choose an address. There we go. If we head over to our stocks table now,

01:32

we have a minus two and a minus five in there because of course, we chose two and five as our quantities. So the last thing we want to do is just clear out all of the items from the car.

01:44

So let's go ahead and say, we're going to call this remove all, or you could just call it clear. Let's go over to our car model,

01:52

and let's implement that remove all method, and all we're going to do here is access the car instance, go ahead and grab the variations relationship, and when we call detach on this relationship

02:08

without passing anything through, it's just going to remove all of these for us. So eventually now we're going to get to the point where these are removed from our car,

02:18

and of course, we're not going to see it up in the navigation. So if we go over to the database, let's clear out these negative stocks once again.

02:26

Let's clear this order out, or all of these orders, we can actually truncate this table, and let's try this from scratch. So let's choose an address,

02:37

let's go ahead and confirm this order and pay, and when we give this a refresh, we're actually redirected back to the car page because of middleware that we added earlier.

02:47

But of course, if we head over to the database, that order's been created, the variations have been attached, and then stocks have been reduced.

Episode summary

In this episode, we tackle the crucial step of reducing stock levels after a customer places an order. We start by iterating through the items in the order and, for each product variation, create a new stock record with a negative quantity to reflect the items that have just been purchased. While this initial approach involves running several queries (one for each order item), we mention that we'll revisit and optimize this later.

As we walk through the implementation, we run into a small hiccup — we need to make sure the amount property is fillable in our Stock model. After adding that, we run the process again and verify that negative stock entries are being added correctly, matching the quantities ordered.

To tidy things up, we also implement a removeAll (or clear) method for the cart, clearing out all items once the order has been placed. We demonstrate how this works by confirming an order, checking the database, and ensuring the cart is emptied out.

By the end of this lesson, you'll have seen how to subtract ordered quantities from stock and how to clear the cart after checkout. We also show a quick reset and test the workflow from scratch to make sure everything’s working as expected.

Episode discussion

No comments, yet. Be the first!