Month: February 2021

Recently I raised a support ticket with a tech company I was subscribed to where we were trying to resolve an integration issue I had with their service. Once we had it all resolved they followed up with a feedback form. That feedback form just happened to be a Google Form.

Great, that’s cool. But that wasn’t what got me excited. They had exposed the raw URL link to the form in the email and I noticed that there were some references to my name, my support number and a few other things in the URL query parameters.

I clicked the link to the Google Form and, as expected, the Google Form appeared with these values prefilled into my form.

We this is a pretty cool convenience, I thought. How did they get all the query paths to each form item?

A couple of days passed and I had a chance to figure it all out.

In this tutorial, I’ll walk you through accessing the prefill tool in Google Forms. Then, if you are keen on doing some coding, we’ll create a little custom feedback form for unique users that we will deliver via email.

Let’s play!

Google Forms prefill tool

Accessing the Google Forms prefill tool

First, take a look at my example Google Form:

Go ahead and type forms.new in your Chrome browser address bar and create a few form items so you can play along.

Once you are done, got to the top right next to your avatar and you will see a vertical ellipsis. Give it a good old click.

A popup window will appear. Three items down and you will see the menu item, Get a pre-filled link. Go on, you know you want to click it. I won’t judge.

A new window will appear in your browser with a sample of your form. Go ahead and fill out any part of the form that you want to have prefilled.

We’ll fill out the first three items in our form. Here, take a look:

As you can see above I have added my name (Yagi the Goat), a ticket number (6047) and issue (Login – Passwords).

You might have noticed down the bottom left of the screen a grey box with the prompt, Prefill responses, and then ‘Get link’.

Go ahead and scroll down to the bottom of your form and click the Get link button (1).

Then click the COPY LINK button in the grey bar (2).

Paste your link in a new browser tab and hit enter to check that the pre-fill is what you wanted.

If you are happy with the prefill results, then paste the pre-fill link somewhere safe for you to use later.

You should end up with a URL a little like this:

https://docs.google.com/forms/d/e/1FAIpQLSd4QDc4MRkoERExe9KeMLww9P7VNRHFOfpBLwX_Mo-g5TJ0Vw/viewform?usp=pp_url&entry.1046214884=Yagi+the+Goat&entry.2009896212=6047&entry.415477766=Login+-+Passwords

You should be able to see some of the pre-fill items in your URL that you added earlier. We’ll go onto this later if you are following along to the Google Apps Script portion of this tutorial.

 

Why would you use a pre-fill in a Google Form?

At first, I was a little lost at the usefulness of using a standard static pre-fill for your Google Form. Surely not all people on your form will need to choose the same thing. I mean, you may as well leave it out of the form, right.

However, after a bit of noggin scratching, I thought that maybe you could use a static prefill like this for a standard response to help most users skip filling in unnecessary parts of the form while still making it flexible enough for the user to change the form if they need to.

When it does become an awesome tool is when you can use the URL generated and update fields to customise it for each user.

In the next part of this tutorial, we will do just that with the help of some Google Apps Script and then add our form to a custom email.

 

Create a custom prefilled form link and email it

In this portion of the tutorial, we are going to create a custom pre-filled form link by altering our copied pre-filled form link and then send a custom email to a user with their name and their own unique Google Form link.

The example

Let’s assume we have our very own tech support team. After we complete each ticket, our team are eager (yeah right!) to find out how well they performed in their support of the client.

The team stores each completed ticket details in a Google Sheet like below:

Looking at the image of the Google Sheet above, we only want to send an email to those clients whose checkbox in column I is unchecked – indicating that they haven’t received and email yet.

We then want to send an email to our users with a message and a link to our unique pre-filled Google form.

For example, our last user, Andrew Bynum, would get an email like this:

Then when Andrew clicked on the form link he would be navigated to his own pre-filled Google Form with the first 3 items filled in like below :

The anatomy of the pre-fill URL bar

That was generated with this bespoke URL:

https://docs.google.com/forms/d/e/1FAIpQLSd4QDc4MRkoERExe9KeMLww9P7VNRHFOfpBLwX_Mo-g5TJ0Vw/viewform?entry.1046214884=Andrew+Bynum&entry.2009896212=11007&entry.415477766=Billing&gxids=7628

If you look carefully, you will see some of the input we put in our form when we were using the Google Forms pre-fill tool.

https://docs.google.com/forms/d/e/1FAIpQLSd4QDc4MRkoERExe9KeMLww9P7VNRHFOfpBLwX_Mo-g5TJ0Vw/

This portion of the URL directs the user to the Google Form, with the ID of the form in blue above between the last two forward slashes.

viewform?entry.1046214884=Andrew+Bynum&entry.2009896212=11007&entry.415477766=Billing&gxids=7628

Next, you can see 3 occurrences of entry followed by a number (in red) then equals to the pre-fill input we added (in green). Note that if a prefill item has a space, it is replaced with a plus (+) symbol.

We start to write out our code we can replace these pre-filled inputs with a variable that can update for each user we send our form to.

Time to check out the code to see how we do this.

The Code

This is a pretty basic procedural code so we will simply pack it into one function. No need to go crazy here:

Main variables

Variables to update

We need to first set up some main variables that we will reference in our project. First, we will get access to the Google Sheet that contains the ticket data for our clients – the Tickets file we mentioned earlier – using the SpreadsheetApp class.

We then call the openById() method which takes one argument, the file id. This can be found in the URL and should look similar to the one in the example. This is then put in the SS variable. Line 10

Next, we need to get to the sheet tab our data is in. For us, this is Ticket. So we reference this sheet tab name with our getSheetByName() method and store it in our SHEET variable. Line 11

We will want to indicate what row our user data starts because we don’t want to include our headers. Here we set our ROW_START variable to 2 because our first user is in row 2.

Getting data range and values

Our next task is to get the range of all the data we need to add our pre-fill values, emails and client name data along with our checkbox to see if we need to email that user. We may as well select all the columns and grab the last row.

To grab the full range of our data we use the getRange() method. Which can take many types of arguments, but for us, we want to give it 4 number values:

• Row start
• Column start
• Number of rows
• Number of columns

We’ll add our ROW_START in our…um…row start argument. Our column start in the first column. Then we grab the last row, which will likely change often by using the getLastRow(). This will update as new entries come in.  We then subtract this by the row start and add 1 to exclude the header. Line 13

To then get the values of the range we use our new range variable and call the getValues() method. This will produce a 2d array of all the data on our sheet. Line 14

Keeping track of emails sent.

Our checkboxes in column I keeps track of who we have sent our feedback form to. We will update the checkbox with a tick if we have sent the form using some code.

Before we jump into our loop through each ticket we need to keep track of where the boxes are unticked and where the row of unticked boxes finish. We do this by setting up an object to store untick start and end rows that we will preset as false and update as we loop through the rows.

If you wanted to speed things up in a bigger Google Sheet you could store the start row in a Properties Service like in the post below, but that’s beyond the scope of this tutorial.

https://yagisanatode.com/2019/11/16/how-to-automatically-navigate-to-the-first-empty-row-in-a-google-sheet-using-google-apps-script/

Looping through our data and setting up our column variables

Now that we have the values of our Google Sheet in our VALUES variable, we want to loop through the 2d array and set some variables to each column of data we want to use in our script. We use the forEach method for our loop here with the first argument being the array containing all the cell data in the row and the second one, the row index:

Next, we need to assign some variables to each relevant row item that we will use in either our email or our pre-fill. To do this we will use some destructuring to cleanly build our variables:

The bolded items are the only columns we want to use. In our destructured variable assignment, we create an array of all the variables we want to use and put a blank comma space between the variables we don’t want to use.

Creating the first name variable

It’s kinda weird these days to address someone by their first and last name in an email greeting. Some people even find it a little insincere or annoying. So we might want to just stick to the more popular informal first name.

To get our first name, or fname, we use the Javascript substring method to just get the first part of our string up to just before the first space. The substring method takes 2 arguments. The start position and end position. We find out the end position by using the indexof method that searches a string of text and if it finds the corresponding value, it will report the position of the value, but if the value does not exist it will report -1.

The resulting code would look like this:

Now, we are not certain if our users have put in a second name, or even have one for that matter. So if we just created our fname varaiable with this code we would get a weird error if we had a single name.

To fix that, we are going to use a ternary operator that we will first use to check if the name variable is a single name or not. Here again, we use the indexof method to check if there is a positive number. If so we will use the code above to generate our name. Otherwise, we will use just the name. Check out the full line of code:

Swapping spaces between words for “+”

When we create our custom pre-fills we noticed that spaces were repaced with plus symbols “+” in the URL. We want to keep the full name and the issues in our prefill and we know that both items potentially contain spaces in the text. To change the spaces to plus symbols, we will use the Javascript replace method with the help of a little bit of regular expressions.

The replace method takes two arguments, the item to search for and the item you want to replace it with. Because the item we are searching for is a space it’s good practice to use a regular expression rather that ” ” to be certain you catch it. Our regular expression looks like this:

The \s is the symbol for spaces. The two / mean anything between. The g is the symbol for global. So essentially this expression is saying that is is looking for any occurrence of a space all over (globally) in the string.

We’ll update the two original variables (which will upset the functional programming purists, but hey, it’s only a small bit of code) so our two lines will look like this:

Sending off our email

In the next section of our function (Lines 33-46), we check to see if we need to send an email, and if we do, we send it away with our pre-filled link to our form.

First, we use an if statement to check if the current feedback cell is false, then we are good to send the email.

Sendemail()

Next, we invoke the GmailApp Google Apps Script class and then use the sendEmail method. The sendEmail() method can take a few different argument structures, but I like to use the full method approach that takes the following:

1. Recipient: The email of the person you are sending your email to.
2. Subject: What your email is about.
3. Body: We’ll put in a placeholder here, “see HTML body” because we want to use HTML to make our email look fancy.
4. Options: The are a lot of options you can put inside the curly braces {} of this object, but for us, we just want to add htmlBody. Which allows us to add HTML to our email.

Let’s have a look at the sendEmail() method so far:

The HMTL Email

We will use template literals to create our string of HTML text. Template literals start and end with backticks (`). If you want to add a variable into the string all you need to do is add ${your variable}. The other bonus is that you can happily put your string on new lines of your code without having to close and concatenate your string each time.

Let’s take a look at our htmlBody value:

You can see that it all looks like pretty standard HTML text separated by paragraph tags <p> and breaks </br>. We’ve added in the first name (fname) in the greeting at the start and then created a link to our pre-filled form that we have customised with our variables.

Here is what each entry looks like:

• entry.1046214884=${name}
• entry.2009896212=${ticket}
• entry.415477766=${issue}

Once this part is complete the emails are all sent off. Time to update our Google Sheet to show we have done this job.

Updating the checkboxes

The checkbox process occurs at the end in two stages here. First as we are iterating through our forEach loop we need to keep a record of the first unchecked box and the last one.

Remember earlier that we had set up the variable, uncheckedBoxRange, before we started the loop. Now we want to check if this is the first time we have found an unchecked box. If it is we want to update uncheckedBoxRange.start with the current index plus the ROW_START value to get the row number and also update the uncheckedBoxRange.end.

If we have already found the first occurrence of an unchecked box, we skip updating the start value and just update the end value.

Outside our loop, we then need to use our uncheckedBoxRange object values to update our checkbox columns in our Google Sheet.

First, we need to get the total number of emails we sent. We do this by subtracting the uncheckedBoxRange.end from the start and add 1.

We then want to create a string of true values equal to the uncheckedCount. This can be done fairly cleanly by the new Array constructor that can take an argument to generate n amount of values in an array.

Next, we use the fill method to identify what we want to fill each array value with. For us, this is a child array with the value true in each. Why a new array inside our main array? Because each row of a sheet is its own array.

We then use the Google Apps Script getRange() method again to select our range referencing our start row of unchecked boxes, column nine, the total number of unchecked boxes. We don’t have any other columns to worry about so we don’t need a fourth argument.

Finally, we use the setValues() method inserting our newly created array of true (or ticks) into our checkboxes.

Conclusion

To run your code from the Google Apps Script IDE simply click on run and follow the prompts:

Alternatively, you could set a time trigger to run your code daily or weekly or when the Google Sheet changes, or have a button or menu item that you click in your sheet to run the code.

Here are a few tutorials on the topic:

• Google Apps Scripts: Create Time Triggers to automatically send email task reminders from a Google Sheets check list
• Google Apps Script: How to Connect a Button to a Function in Google Sheets

So what do you think? Would you use pre-fill in your own project? I would love to hear how you applied custom pre-fill. It’s always interesting to see what creative things people develop.

Need help with Google Workspace development?

My team of experts can help you with all of your needs, from custom app development to integrations and security. We have a proven track record of success in helping businesses of all sizes get the most out of Google Workspace.

Schedule a free consultation today to discuss your needs and get started or learn more about our services here.