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

55. Setting up for orders

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

Over the next handful of episodes. We're going to focus on creating an order. We're not going to get to payment just yet

00:06

We're going to leave that to a little bit later on in the course But we want to do a huge amount of things when we order there are lots of different things that need to be covered We of course need to create an order record. We also need to attach the variations from the car We need to reduce stock and we need to clear the car

00:23

So we're going to do all of that stuff in the next few episodes So the first thing I want to do is just reduce what we've got in our cart to a sensible Quantity just so we've got something to work with and we can either be signed in or signed out for this It doesn't really matter. But the first job is to set up the order model and order migration to get this working

00:43

So let's go ahead and make a model in here called order and let's create a migration alongside of that So if we head over to the create orders table migration Let's think about all of the data that we're going to need Now the first thing is we're going to attach a uuid to this just so we have something that we can reference it by

01:01

That isn't the ID this is purely just to be able to pass in to Any endpoint that we create and that's pretty important because if the user isn't signed in we're going to redirect them over to an order Confirmation page not their orders page because of course they don't have an account later on once they do create an account

01:20

We're going to go ahead and hook up all of their orders to that user who has just signed up so what we also want to store in here is the account information of The user that has created the order if they're not authenticated So it will be this email here

01:38

And if you add any other fields to this you will probably want to fill them in as well Now if the user is authenticated, of course, we want to attach it to that user So we'll create a foreign ID in here We'll make this nullable because of course we're implementing guest checkout and we'll go ahead and constrain this as well

01:55

The next thing is going to be the shipping address and the shipping type. So two more foreign IDs in here so let's go ahead and create that out as Shipping Address ID remember we store that

02:11

When we go ahead and press order and also the shipping type ID as well So let's have the shipping type ID in here. And that's it. Okay. So the next thing is going to be the subtotal so let's go ahead and Include this as an integer

02:27

We could technically just grab this from the variations But if they change in the future Then of course it's going to be a little bit trickier to show the user the actual price that they paid now the next three columns are going to be something we're going to work on later and that will be a

02:42

Timestamp for placed at which technically we could take from the created at column Which is created with this timestamps method just here, but we're going to add these in just to demonstrate this out We're going to say packaged at and we're going to say Shipped at so what we're going to do later is when these statuses change

03:04

We're going to detect which sort of place were at in the order and then we're going to send the user An email update to tell them that the order status has changed So we'll get to that a little bit later, but we'll include all three of these in here now. Okay, so that's just about enough let's go ahead and run migrate and

03:24

Create that out and let's head straight over to the order model So we can figure out what the kind of default things we want to do to this model when it's created so let's create out a a

03:37

booted method in here and let's say that when this model is being created and Let's create our closure in here With the order we can type in that if we want to

03:50

We want to go ahead and fill in the UUID because this isn't generated automatically So let's go ahead and cast to a string the result of using the string helper UUID and That will create that in there for us before it's persisted in the database

04:06

And what we're also going to do is say order Placed at and we're going to set that to now So we're going to fill this in almost like it's a created at date, but of course, it's not really It's just an extra column that we've added now because we've done that and added them other

04:23

Columns in we need to specify these under timestamps. So placed at packaged at and shipped at So they will be converted to carbon objects when we pull them out. Let's also fill in our

04:39

Fields that we want to be fillable as well. Or of course we could set that to unguarded Let's fill these in manually So we've got the email address The subtotal which we want to fill and also placed at

04:55

Packaged at and shipped as well. We can always tweak this around later to clean it up Okay, so that should be enough for us to create an order now Fill in all the details we need and we're going to go over to the next episode to look at over on the checkout Actually creating the order down here when we hit checkout

Episode summary

In this episode, we're kicking off a mini-series all about the order creation process in our project. We're going to focus on handling everything that needs to happen when a user places an order—setting up our database models and structure. No payment handling just yet—we'll get to that later!

Here's what we do:

We talk through everything an order needs: creating the order record, attaching the cart items (variations), reducing stock, and clearing the cart after purchase.
Then we jump into actually scaffolding our Order model and its migration. You’ll see how we choose the different fields it needs, like a UUID (for easy referencing, especially for guest checkouts), linking the order to a user if logged in, or just storing an email if not.
We also add references for shipping address and shipping type, as well as a subtotal, and introduce a few timestamps (placed_at, packaged_at, and shipped_at) so the order progress can be tracked and notifications can be sent at each stage.
After running the migration, we update the model to auto-generate the UUID and set the placed_at timestamp when an order is created. We specify fillable fields and set up casting for our new timestamp columns.

By the end, we’re all set up to create an order with all the needed details, both for guests and logged-in users. In the next episode, we’ll move on to actually triggering this when the checkout button is clicked!

Episode discussion

No comments, yet. Be the first!