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

71. Setting up Stripe

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

In this episode we're going to take a moment to get Stripe set up, so of course we can process payments.

00:05

So we're going to go ahead and attach the Stripe library to our container, we'll take a look around Stripe if you're new, and then we'll pretty much be ready to create payment intents and go ahead and charge the user at checkout. So the first thing that we're going to do is go ahead and pull in the Stripe PHP library, so let's go ahead and grab the composer

00:24

command to do this and pull this in, it's going to go ahead and install that for us, and then before we do anything else let's go ahead and grab our keys over on Stripe, so we can attach these to our config and then go ahead and pass these into Stripe when we boot it up. So if you don't already have a Stripe account of course you're going to need to go ahead and

00:44

sign up, and then you're going to need to come over to the test mode, toggle this. Now under the developers section here, add API keys, you'll find your publishable key which is used for the client side, and your secret key which is used for the server side. So we're going to go ahead and pull in both of these, we can hit reveal test key as well, and of course go ahead and enter our

01:05

password, and once we've done that we'll go ahead and see our secret key. So what we're going to do is come over and just create out some new config in here, so let's go over to our config section, let's create out a stripe.php file, and then from here we'll just build up a new config, so we'll just return an array, and we'll say secret, and we're going to use our environment

01:30

variables for this, so let's name them now, let's say stripe secret, and we'll just say stripe key, in fact we'll pump that to the top because usually we'll put the publishable key at the top, and that's just going to be stripe key. Great, so we want to pull both of these over to our EMV, let's do this at the bottom, stripe key, and of course stripe secret. Okay, let's go ahead and

01:56

grab both of these, so copy these over here, and we're pretty much done with our config stuff. So we can reference these if we head over to config, and I think it's under services, we can use stripe inside of here, or do what we've done and create our separate config file for this, it doesn't really matter too much, but we've got that in there now. Now the next thing that we need

02:19

to do is create a service provider so we can bind this to Laravel's container, and then we can use this wherever we like. We're going to do this in a really simple way and just bind it by a string, not to an interface, just so we can conveniently pluck it out of the container wherever we need. So for this we're going to go ahead and make a provider, we could do this an app service provider,

02:40

but let's go ahead and create a stripe service provider just so it is in its own provider, and let's go ahead and open up that stripe service provider under app and providers, and we're going to come down to the register section here, and we're going to go ahead and bind this in as a singleton. So let's go ahead and say singleton stripe, and then for this all we need

03:01

to do is create our closure, and then just return a new stripe instance. So for this we're going to go ahead and return a new stripe client which is from the package that we just pulled in, and then the only thing that we really need to pass to this for our use is the stripe secret. Now that we've created that stripe config we can say stripe.secret and that'll be pulled

03:23

directly from our env. So the last thing that we need to do is just come over to config and app and go ahead and paste in our service provider in here. So let's say stripe service provider, much like we did for our cart service provider, and we're pretty much done. That is stripe pulled in and we can start to look at processing payments on the checkout.

Episode summary

In this episode, we're getting Stripe all set up so we can start processing payments within our app. We'll start by pulling in the official Stripe PHP library using Composer, and then take a quick look around the Stripe dashboard—perfect if you're brand new and need to know where to find things.

Next, we'll walk through setting up your Stripe API keys (both publishable and secret) in test mode, grabbing them from the Stripe dashboard, and storing them securely in your environment file. We'll then create a dedicated Stripe config file in our project so Laravel can easily access these keys wherever we need them.

After that, we'll create a simple service provider to bind the Stripe client to Laravel’s service container. This makes using Stripe in different parts of our app super convenient. We'll keep things straightforward by using a string binding, making it easy to pull out the Stripe client anywhere the need arises.

By the end of this episode, Stripe will be fully integrated in your Laravel project, and you'll be ready to move on to actually accepting payments at checkout!

Episode discussion

No comments, yet. Be the first!