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

available quantity for all of the products if it's out of stock or if the stock has been reduced. So what we're going to do here is go over to our cart model and we're going to create our new method to do this. We're going to take this really slowly because we're going to be doing a lot of mapping through collections to build up an array that we can pass through to

the sync method on the variations relationship. So let's go ahead and just call this sync available quantities. Once again we're going to make this fairly verbose just so we can kind of see what we're doing and you might come up with some magic to reduce this. So first of all let's look at the syntax that we'll need to actually update this in the database. Now at the moment

if we come over we've got we come over to our cart variation we've got one product in here with 10. I'm actually going to get rid of all of these others just so we can focus on this one here and this being updated and let's also go ahead and add another product to our cart. So let's go and find that other product and let's go ahead and add. So yeah there's no stock on that so let's

add some stock first of all. So to keep things sort of simple we'll add 10 stock on rainbow 12. If we look at the parent id there that's that one. There we go. So let's go ahead and add this in. There we go and then let's reduce the stock for that one as well. So we should see both of these change over. So let's choose this one and let's reduce that by two. So we should end up with

five and eight for these respectively over in our cart. So this one in fact let's just update the quantity over here in our cart and that's not going to work because we are dying and dumping. We'll get there. So we can actually do this manually in the database. Let's update this one to 10 as well. So basically by the end of syncing this because this one's been reduced by

two in stock and this one's been reduced by five this one should show five and this one should show eight. Hopefully that makes sense. Okay so what we want to do is eventually get to the point where we can grab our cart instance, grab our variations relationship out here and we can call sync. Now to sync something you need to pass an id in and then the pivot information. So let's say

we had a product variation one and we wanted to update the quantity to say 10. What we're going to have to do is pass another array in here. So we're going to have to array it like this. One is going to be the key that's the variation id and then in here is going to be the pivot information. So let's just say for the variation that we have in there we're reducing that to

eight for the rainbow size 12 and for the other one we're reducing this to five. This is the kind of array that we want to add a build up. So this is what we need to bear in mind. I'm going to cut this out. I'm going to paste this down here just comment it out so we can reference the structure of this when we build this up here. So let's call this array synced quantities that we can use to

pass directly into here and the way that we want to do this is again iterate through the variations much like we did here or map through the variations to build this array up based on the available quantity that we have. So what we're going to do is just say this instance variations the collection this time. We're going to map through it with the keys because remember we

need them keys intact and let's go ahead and create out our closure in here. Of course we're going to get our variation through in here. So now what we need to do is figure out the quantity that we want to return in this array here. We know the variation id so we can return that at the bottom of here but we need to figure out the quantity that needs to be synced too. So let's create a

variable for this just to make this a little bit clearer. We're going to go ahead and say variation pivot quantity and we're going to check if that's greater than the variation stocks count sum which is what we did in this check here. So effectively we're saying has this stock been reduced and has it been reduced based on this quantity here. Now if that's the case so we'll

use a ternary here what we want to do is go down to the maximum stock count that we have for that product. Really important. Otherwise what we want to do is go and just go for the quantity that the user has chosen. So let's just return an array from here and just test this out. So let's go ahead and say variation id so we're starting to build up this array here. This is the variation id so

remember we're mapping with keys and then in here we want an array with the pivot information which is going to be the quantity that we have just calculated based on this here. So there are of course shorter ways to do this but we want to be a little bit more verbose in this just so we can kind of read the code a bit better. Okay so what we're going to do here is

die dump on the sync quantities so we can see it before we test this out. So over in cart index controller let's go over to here and say cart sync available quantities and let's see what we get. Let's give that a refresh. We get a collection here with three and eight which of course are the variation ids. This one's been reduced to five and this one has been reduced to eight which is great.

Now we also need to bear in mind that if a particular product has been reduced by so much quantity that it has to come out of our cart that it has to come out of our cart because the quantity has been reduced to zero. We want to kind of get rid of that from this array. So let's just test this out in the database and we'll go over to our stocks. Let's reduce this one by 10. So let's say

someone buys 10. We've got 10 in our cart. What does that leave us with? Well of course it leaves us with nothing in our cart and zero is not a valid quantity for an item in our cart. So we need to kind of reject this from this list and we can sure enough do that with the reject method on a Laravel collection. So this will just kind of filter this out or reject this from here. So let's go ahead

and reject this based on this condition and let's go ahead and say synced quantity and we're going to access that synced quantity and we're going to check if the quantity is equal to zero. So this is the condition for rejecting that item from this collection. Give it a refresh. We only end up with this one in here. Now we're not going to do this for now. We're going to test this out by reducing

this by five first of all so we can see that over in our cart variation this does reduce and then we'll check that this is completely rejected from our cart. So now that we've got our synced quantities with dying and dumping on them we need these to be cast to an array. So let's cast these to an array because of course we need this kind of an array to pass through to this sync method

and let's go ahead and now pass this in. So synced quantities. Now we will need to do something down here. We'll look at that in just a second but let's just make sure that giving this a refresh updates this for us. So let's give that a refresh and there we go five and eight. So both of them have been updated. Now what you'll notice is on this page now that we've refreshed that the

exception was thrown we sync to the product. What we really need to do is clear the cache instance or the instance cache from our class so this can be re-plucked out and we can see the correct quantities. So what we're going to do is do something like this clear instance cache which does slow things down a little bit but not by that much. So let's go and implement this method maybe

just down here let's make this protected and to clear this cache down here let's find it this one we just need to set the instance to null so it can be re-read. So let's say clear instance cache and let's set this instance to null. Now let's move that down because it doesn't really make sense there let's just put this just above the instance method. Okay so let's try this

again let's manually set the quantity in our cart to 10 and 10 save this out come over here give it a refresh and you can see there we go. So in between that syncing our database we've cleared the instance cache for looking up our cart and the quantities are now showing properly on here otherwise the user would have to refresh the page to see these quantities which isn't great.

Okay so let's finish off by looking at what happens when we have a quantity of zero in here. Now let's go over and again switch these to 10 and 10 just to start with something really simple and if we come over to our stocks here and reduce this one by 10 like we demonstrated before that should reject that from that array. So let's go over to our sync method

and let's once again just die dump on synced quantities. So we end up with an array with just the quantity for this variation in here because that's not being reduced to zero we didn't reject it from this array using this reject method. Now what's going to happen is when we pass this through and the variation is missing because we're using the sync method

and we're not using sync without detaching it's going to go ahead and remove this from the cart effectively meaning that if it's a zero quantity it gets rid of it. So what we've done is reduce the quantity down to zero rejected it and then we're just syncing it and Laravel will take care of the rest or Eloquent will take care of the rest. So let's go over give

this a refresh and there we go so we've got our Nike Air Force 2 in there but if we head over of course because we reduced that variation and we rejected that it's only gone ahead and included this one which has a positive quantity. Now you could make this a little bit more robust by saying less than or equal to one or zero sorry but let's go ahead and just compare this to zero

because it's not that likely that this is going to go to minus one or minus two and that's pretty much it checking and syncing the products in our cart. Now we want to include this check over here on other pages as well so let's go ahead and take this and add it to our checkout index controller as well there's probably a bit of a nicer way to do this we could abstract this

into a method on its own in our cart but let's just leave this like it is for now as long as it's in there that's the main thing and then when we go through and actually process a payment we'll include this within our Livewire component. Okay let's just double check this by clicking on checkout and yeah undefined variable cart let's go and say cart interface and cart and there we go so

that's going to remove that from there as well we can even test it here we head over to variations or cart variations and bump that to 10 and come over there we go we practically just bumped it down to 8 we didn't see anything happen here but that is now working on our checkout index as well really important because of course we see this before we check out.