00:00
[MUSIC]
00:05
So let's say that instead of creating a brand new Cineast for these,
00:08
we instead want to use the pool of Cineast that we have and
00:10
assign them for the relationship from that pool.
00:13
Essentially reusing Cineast as we go about movies so
00:16
that we have multiple Cineast assigned as cast members or
00:18
crew members to multiple movies rather than just one by one as we have here.
00:24
Let's hide PGM back away and let's remove what we have so far.
00:28
Getting this back to how it was prior to last lesson.
00:30
Okay, let's put a couple line breaks here so
00:32
that we can focus on just this one line for right now.
00:34
Let's plop the results of this factory's creation into a variable.
00:38
So let's do const.
00:39
And since this is the only movie factory that we're not doing anything to,
00:42
we're not applying any states, not tapping through it or anything like that.
00:45
Let's put these in a variable just called our default movies,
00:48
since it's using all the defaults.
00:49
This should be an array of movie models as you can see here.
00:53
What we can do is actually just use these models now as actual relationships
00:58
to create relations randomly for
01:01
the Cineast pool that we're providing into our create movies method.
01:04
Okay, so we're going to get a pool of promises.
01:06
So let's give ourselves a place to house those.
01:08
So up here at the top of our create movies method, let's just do const
01:12
promises equals an array and we can specify the type for this as a promise any array.
01:19
Okay, we don't really care what the promise is going to return at the end of
01:21
the day, we just want to make sure that we can wait for
01:23
all of them to finish before we return out of this method.
01:25
Okay, so let's loop over our default movies like so, and
01:29
we'll have an individual movie here.
01:31
We'll do const crew Cineast equals.
01:34
And let's create ourselves a utility to grab a random number of Cineast out of
01:38
our Cineast array.
01:39
So let's create a private method called get random that accepts in an array.
01:43
We'll need a type for this array so
01:44
that we can return back the same type that we provide in.
01:48
For that, we'll need to add in a type variable to our method itself, and
01:52
we'll call that T.
01:53
Then we'll provide the number to plug out of the array so
01:57
that we can get any random number that we want.
01:58
First, let's shuffle our array.
02:00
So we'll shuffle equals array.sort 0.5 minus math random.
02:07
Then with our shuffled array, we'll go ahead and return shuffle.slice,
02:12
start at the zero index, and go to the pluck number that we've provided it.
02:16
So now if we scroll up from our Cineast array,
02:19
we should be able to do this.get random, provide in our Cineast array, and
02:24
say that maybe we want to pluck five out of that array.
02:27
If we take a look at our crew Cineast type, we now have a Cineast array.
02:31
Awesome.
02:31
Well, in terms of creating our relationship,
02:34
what we really care about are just the IDs.
02:36
So let's do crew Cineast IDs there, map over our results,
02:40
pluck out the ID, and return that ID.
02:43
So now our crew Cineast IDs should be a number array, which it is.
02:46
We can go ahead and give this a copy and
02:48
do the exact same thing for our cast Cineasts as well.
02:52
For this, so that we can discern them, let's do three.
02:54
Okay, with the individual movie that we're looping over,
02:57
we can now grab the relationship, so related crew members dot, and
03:01
attach in the random array of IDs that we've grabbed.
03:04
So that would be our crew Cineast IDs like so.
03:08
And that's how we can create records using a many to many relationship.
03:12
From the movie model instance, we grab the relation we want to create records for,
03:16
and attach IDs for that relation.
03:19
And it will populate our many to many pivot table with the movie's ID,
03:23
as well as each one of the relation IDs that we provide it.
03:26
In our particular case though, we have pivot data we also need to provide.
03:31
And this does complicate the call a little bit.
03:33
But if we take a look at a hard coded version,
03:34
we'll see that it's still relatively straightforward.
03:36
So instead of providing an array of IDs, we'll now want to provide in
03:40
an object where the key is the ID.
03:43
So if we want to bind a Cineast with an ID of one to the movie that we're working
03:46
with, the key would be the ID of one for that Cineast.
03:50
And then the value for this key is going to be the pivot table data that should be
03:54
created for this Cineast with an ID of one, and they're binding to this movie.
03:58
So that would be their title of, let's say, camera operator,
04:02
as well as their sort order of zero.
04:06
And then we just do that same thing over and over again for
04:09
each one of the Cineasts that we want to bind.
04:12
Ignore my poor formatting there, but say if we want to then attach a Cineast with
04:15
an ID of two, we do that exact same thing with a key of now two.
04:20
And that will bind both a Cineast with an ID of one with this particular pivot table
04:24
information, and a Cineast with an ID of two with this pivot table information.
04:29
So we could change that up to make them unique per each one, and
04:32
it would account for that accordingly.
04:34
So what we would want to do is do that in a loop based fashion for
04:37
our loop of IDs here.
04:39
So we'll scroll down, get rid of the object that we have here so far.
04:42
And the easiest way to do that would be to reduce through the array.
04:45
So we'll do crew Cineast IDs, reduce.
04:49
We'll have our overall object that will create the relationships,
04:52
as well as the current ID that we're working on.
04:55
And then we're also going to want the index so that we can increment our sort.
04:59
Okay, we'll return that back and instantiate the default value as an object.
05:05
So for our object, we'll bind in the current ID we're working with and
05:09
have that value equal our intermediary table data.
05:12
So we could have a title of say camera operator and
05:16
our sort order of the current index.
05:19
Then we will return back our new object, give that a save for our formatting.
05:23
And we do have a couple red squigglies going on still.
05:25
So first we have already used the variable index,
05:28
that is if we scroll up right there.
05:31
So we'll just call this i.
05:32
I think we're all relatively familiar with i at this point.
05:35
So we'll move forward with that.
05:36
And then second, we're getting an implicit any type here.
05:39
So all that we need to do to fix that is provide a type to our reduce method.
05:42
So we'll do two angle brackets there.
05:45
And let's hover over attached and
05:46
that will provide us the type that we're working with right here.
05:49
So let's give that a copy and paste it in.
05:51
Now we don't have a model object imported.
05:53
So let's just type model object, hit tab to auto import that and
05:57
we should be good, awesome.
05:59
So now we're looping over each one of our crew Cineast IDs,
06:02
adding in an object where the key is the individual ID and
06:06
the object is the pivot table data that we want created with that ID.
06:10
And then returning back that new object,
06:12
which will then be attached into our movie via our crew members relationship.
06:17
We'll want to do this several times over for
06:19
each one of the movies that we're creating.
06:20
So let's extract this out into a helper method as well.
06:24
So we'll give this a copy, scroll down, and let's do private attach crew members.
06:29
We'll paste that in.
06:30
And what we want to do is provide in a movie of type movie,
06:34
provide in our IDs array, which will be a number array.
06:37
And then for our titles, we'll create an array and
06:39
pluck a random title out of that array for the Cineast that we're binding.
06:43
And we just need to update our crew Cineast IDs to just IDs now,
06:47
give it a save to fix that formatting.
06:48
And we can go ahead and just return that back and this will be an async method.
06:53
Let's also have this method randomly pluck the IDs for
06:57
us as well to just get rid of one extra duplicate line.
07:00
So attach random crew members and instead of IDs,
07:04
let's have this be our actual Cineast array, just like so.
07:07
Okay, let's scroll up to where we are grabbing random crew Cineast IDs.
07:12
Give that a copy, scroll back down and paste it within our attach random crew
07:15
members array.
07:17
I misspelled Cineast, so we'll give that a copy and
07:19
paste it there as well to get that correct.
07:20
Okay, and then we can provide the number that we want to create into this argument
07:25
as well, so we'll just have an argument called number, which will be a type number.
07:30
And provide that into our get random method, so number there.
07:33
And let's update the name of this to be just IDs.
07:37
Awesome, so now our attach random crew members method takes in a movie,
07:40
takes in an array of Cineasts and a number to randomly pluck from the Cineasts.
07:45
It will get that random number and their IDs from our Cineast array,
07:49
attach them to our movie via our relationship.
07:52
And now all that's left to do is make our Cineast title random as well.
07:56
So let's go ahead and scroll up to the top of our cedar here.
07:59
And let's do titles as a string array equals an array.
08:03
And we'll do camera operator as one, maybe an art director,
08:08
hair and makeup production manager.
08:12
Might have somebody for wardrobe, a line producer, sound mixer,
08:17
maybe a cinematographer.
08:18
I think I spelled that wrong.
08:20
Okay, I think that's supposed to be an A and a gaffer.
08:23
And that should be good for our titles.
08:24
So we'll scroll back down to where we are attaching our random crew members.
08:28
And for the title, instead of placing in a hard coded string,
08:31
we will do this get random, provide in our this title.
08:36
Let's pluralize that name.
08:38
Scroll back up, plop an S on the end of that.
08:40
There we go, scroll back down, titles.
08:42
And we just want one, so we'll provide one there.
08:44
And then we need the first result, so we'll do zero there.
08:47
Okay, so now we have our attach random crew members.
08:50
Let's do the exact same thing for our cast members as well.
08:53
So we'll give that whole method there a copy and a paste and attach random cast members.
08:58
The relationship for this will now be cast members.
09:01
And instead of providing titles, we'll instead want to provide in character names.
09:06
So instead of creating a manual list of character names,
09:10
we can actually make use of our Sinisfactory to get a character name randomly.
09:15
So inside of our reduce call here, let's do const record equals await Sinisfactory.makeStubbed.
09:24
And this will make us a Cineast using our Sinisfactory,
09:27
but it won't actually persist it to the database.
09:29
Now we just have a Cineast record that doesn't exist in the database available to us.
09:34
And we can do record.fullname to provide the random full name
09:38
that we got from our Sinisfactory into our character name.
09:41
However, this is asynchronous.
09:44
So let's move this outside of this call to simplify things.
09:48
And let's create many instead.
09:51
The number that we want to create is the total number of cast members that we're trying to create here.
09:54
So we'll just pass our number directly in there.
09:57
This is now records.
09:58
And now we can do records, reach for the index.fullname instead, and everything will be happy.
10:04
All right, so now it's time to make use of these two attach calls.
10:07
So scroll back up, get rid of everything that we have here, just like so.
10:11
And we can even get rid of these two lines here.
10:13
Now let's change our game plan here a little bit.
10:15
So instead of plopping all of our movies into a variable, looping over them individually,
10:19
let's plop all of our movies into a single variable.
10:22
So up here at the top, and we'll do let movie records set the type to a movie model array
10:28
and instantiate the value to an empty array.
10:30
We'll scroll back down, and we'll just concatenate in each of the results as we create them.
10:34
So we'll do movie records.concat, wrap that up there.
10:38
Movie records equals the resulting concatenation.
10:41
And we'll want to do that for each one of these three here as well.
10:44
So movie records equals movie records.concat, and wrap those up as well, just like so.
10:51
And then let's scroll up and do the exact same thing for the ones that we're tapping
10:53
over as well.
10:54
So let's do let movie records equals those there, and then we can just get rid of our
10:58
instantiation up there.
11:00
Let's get rid of our promises as well, since we have these all housed inside of a single
11:03
array.
11:04
We can just do const promises equals movie records.map.
11:08
We have our individual movie, and then inside of here, we'll await this, attach random cast
11:15
members, provide in our movie, provide in the pool of Cineasts we have in our array,
11:19
and then the number that we want to create.
11:21
Let's do four for right now.
11:22
Okay.
11:23
And then we can return this.attach crew members, movie, our cynist pool, and let's create three
11:29
cast members.
11:30
All right.
11:31
Lastly, these two things aren't happy because that's missing parentheses, and then we need
11:34
to make it async as well.
11:35
All right.
11:36
So let's await promise.all our array of promises.
11:41
Okay.
11:42
So now we have our array of movie models, which contains the result of each one of the
11:46
movie factories that we run, including the ones that we tap over as well.
11:51
We are then awaiting the results of the attach random cast members and attach random crew
11:57
members for each one of those movies right here.
12:00
So if we did everything correctly, we should be able to jump back into our terminal.
12:04
Let's clear that out and let's rerun our migration refresh seed, just like so.
12:10
Okay.
12:11
Everything completed successfully.
12:12
So it appears like everything would be correct.
12:15
Let's jump into PgAdmin.
12:16
Let's scroll up.
12:18
Let's right click on our database, refresh, scroll back down.
12:21
If we right click now on our crew movies table, view edit data, let's do all rows.
12:26
Okay.
12:27
Look at that.
12:28
We got 1260 rows back.
12:30
However, the pool that we worked with was just a pool of 10 Cineasts.
12:34
So as we look through our cynist ID column here, we should not see any above 10 since
12:40
these are the first records that we're creating.
12:42
It should be one through 10 for the cynist IDs.
12:45
So as we scroll through this, it looks like everything went correctly.
12:48
I'm not seeing anything above 10.
12:50
Awesome.
12:51
We have our sort order going one through two as well.
12:55
And this is our crew movies table.
12:56
So if we jump back into our text editor, we are creating three crew members.
13:01
So our sort there seems accurate as well.
13:04
Let's run through our cast movies next and verify that.
13:07
So we'll right click, view edit data, all rows.
13:09
All right.
13:10
We got 1680.
13:12
Same thing here.
13:13
We should not see any above 10 and we're creating four here.
13:15
So we should see sorts zero through three.
13:18
So scroll through here.
13:20
Everything here looks a-okay as well.
13:22
Awesome.
13:23
So now we have a pool of Cineasts that we're creating right here.
13:28
If we wanted more variants, we can create more Cineasts.
13:31
So we could create a hundred there and now we wouldn't have so much repetition within
13:35
our crew movies.
13:36
So let's go ahead and rerun our seed with that.
13:39
So let's clear out, rerun that, and then we'll have a pool of 100 Cineasts that we're working
13:44
through.
13:45
There we go.
13:46
So things should be a little bit more dynamic there.
13:47
And the Cineasts are randomly being bound as crew and cast members to the movies that
13:53
that we're creating.
Join The Discussion! (0 Comments)
Please sign in or sign up for free to join in on the dicussion.
Be the first to Comment!