Unit introduction
Welcome to the fourth unit of the “Introduction to iterators and array aggregators” course in the Make Intermediate learning path.
By now you should know what iterators and aggregators are.
In this unit you will gain an understanding of where an iterator and an aggregator can be useful in Make. We will go through a couple of use cases and hopefully inspire you to create more in Make!
Let’s get to it!
Get inspired with use cases
This unit is theory-based. We will explore a couple of different use cases using Make.
Note that you don’t need to build these scenarios, but feel free to open Make and explore them on your own! The goal here is to understand how an iterator and an aggregator can be useful in Make.
We hope to give you some ideas which can also serve as an inspiration for you to go on and try to build your own scenarios!
We will also provide templates so you can see for yourself how these scenarios work from the inside.
Let’s get started!
Use case example 1: Updating contacts
Let’s imagine Alex is moving to France from the UK. To continue communicating with his friends and family, all of his UK based contacts will need the country code added to their phone number. This scenario will change all the phone numbers under a contact in Google Contacts to add the UK country calling code.
Google Contacts: List My Contacts
Alex has 4 contacts on his list.
The first module Google Contacts → List My Contacts will produce a separate bundle for each contact in his Google Contacts list.
Here on the image you can see that there are 4 bundles as output, meaning there are 4 contacts on Alex’s list.
Every bundle has a lot of information about each contact (address, photo, phone number, etc.). Alex may not need all of this information for his purposes.
Array aggregator
The Array aggregator module will create one bundle as an output.
Alex mapped it to extract only the information that he needs - contact ID, address (to establish if the user is in the UK), and the user’s phone number.
Iterator
The Iterator module will provide 4 separate new bundles to update, containing only the information needed that he has set up in the previous module (contact ID, address, phone number).
Filter
The filter here is the crucial bit, as it will help determine which bundles will be updated in the next module, based on the set conditions.
It does this by using the filters “phone number does not contain +44” AND “address country contains GB”.
If we do not add these filters, every contact, regardless of their location, would have +44 added to it.
Notice on the image that only 2 bundles here pass the filter. This means that only 2 contacts match the filter criteria.
Note: This scenario only works as intended for contacts with exactly one address and one phone number.
Google Contacts: Update a Contact
Finally the Update a contact module maps the contact ID with the change that needs to be made - add +44, and then the phone number.
Note the space between the two sets of numbers. This means that “12345” becomes “+44 12345”.
Remember that 2 bundles passed the filter? This equals to 2 credits here, that means 2 contacts were updated in Google Contacts.
Use case 2: e-commerce
In this scenario, let’s imagine Victoria works in an e-commerce startup that sells clothes. She wants to get information about products in customers’ orders and convert that to an invoice.
JSON
The first module (Parse JSON) provides data of the specific order in a JSON string. It outputs as an array, which contains 3 collections (T-shirt, Dress and Jeans). In each output collection, you can see the name of each item, its size and price.
Iterator
The Iterator module takes the single array, and splits it into 3 separate bundles.
Text Aggregator
The Tools → Text aggregator module will compose a single string, mapping each property value with text. The text string will be used as part of the invoice that will be created. This outputs a single bundle.
Set Variable
The Tools → Set variable module uses a combination of numeric and array functions:
map()will take thepricevalue from the output bundle.sum()will add all 3 of them together.30 + 60 + 50 = 140
You don’t need to worry about this for now - we’ll cover the map() function in the next course!
Note: The value being mapped is from the JSON module, rather than the Text aggregator.
Google Drive
Finally, the last module Google Drive → Create a File from Text combines the text string and order sum from the previous modules and creates an output, giving us our invoice. You can see the example of the invoice on the image below.
An alternative approach
Let’s look back to the previous scenario (Use case 2: e-commerce). The same scenario can also be built in a different way.
Note that the first 3 modules are exactly the same as in the previous scenario so we will not go over them again here. If you need a refresher, just check the previous slide once again.
Let’s look at how to build it in an alternative way!
Second Iterator
The difference comes in the second Iterator, which enables us to create the total value of the items.
This module is doing the same thing as the first module – it creates 3 separate bundles. These will be used by the next module to create the total value of the items.
Tools > Numeric aggregator
The Tools > Numeric aggregator module is calculating the SUM of all the items from the previous Iterator.
The reason for the price*1 here in the Value field is because you would usually have the quantity of line items in your data. As a workaround, multiplying the price by quantity gives the full amount for each item - in this case it’s 1.
Notice that the final result is 140 (30+60+50=140). This stands for the price sum of all items.
Tools > Compose a string
The Tools > Compose a string module maps both the text from the first set of iterations (Text aggregator), and the total value of the order (Numeric aggregator) in one string.
This outputs as one bundle.
Google Drive > Create a File from Text
Finally, the last module Google Drive → Create a File from Text creates an output of the previous Compose a string module, creating our invoice.
You can see the invoice example on the image below.
Note that this will be the same as in the previous scenario.
Element - text / text and image (Portrait) - LARGE
Let’s compare!
As you have seen, in Make it is possible to come to the same solution but in different ways. This means that you can have different scenarios that use different modules but in the end make the same final outcome, such as the one here.
The difference between the two scenarios that we have covered is that they use different modules - the first one uses 5 modules and the second one 7 modules. Also, the first one uses fewer credits than the second one.
Note that instead of the Google Drive module, we could use any other communication module, such as email or instant messaging modules.
We could also forego the Set variable module in the first scenario and map the function directly in the Google Drive module, optimizing our scenario even more.
scenario 1 = 5 credits scenario 2 = 7 credits